Improve handling of missing package index

Following the convention of the other project types, the user can specify the path to a folder containing a package
index.

Previously, when no file resembling a package index was found in that folder, the linting process would error. It is
correct for this to be considered an error, however the panic process was used for this purpose. Although it printed a
friendly error message at the start of the output, a panic also outputs a traceback. That traceback is very useful for
debugging the code of the action, but it's not very user friendly. The established convention is that panics are used
for errors that should not occur if the tool is operating correctly, which errors caused by the user input are handled
only with a friendly error message.

The new behavior is to use the rule system to handle this situation. This allows for the addition of additional rules
that might provide the user with information about the cause of the error.

Author: per1234

internal/project/packageindex/packageindex.go

@@ -81,5 +81,5 @@ func Find(folderPath *paths.Path) (*paths.Path, error) {
 		}
 	}
 
-	return nil, fmt.Errorf("No package index file found in %s", folderPath)
+	return nil, nil
 }

internal/project/packageindex/packageindex_test.go

@@ -70,7 +70,7 @@ func TestFind(t *testing.T) {
 		{"Single", testDataPath.Join("HasPackageIndex"), testDataPath.Join("HasPackageIndex", "package_foo_index.json"), assert.Nil},
 		{"Multiple", testDataPath.Join("HasMultiple"), testDataPath.Join("HasMultiple", "package_foo_index.json"), assert.Nil},
 		{"Valid extension fallback", testDataPath.Join("HasJSON"), testDataPath.Join("HasJSON", "foo.json"), assert.Nil},
-		{"None", testDataPath.Join("HasNone"), nil, assert.NotNil},
+		{"None", testDataPath.Join("HasNone"), nil, assert.Nil},
 	}
 
 	for _, testTable := range testTables {

internal/project/projectdata/packageindex.go

@@ -21,7 +21,9 @@ import (
 
 // InitializeForPackageIndex gathers the package index rule data for the specified project.
 func InitializeForPackageIndex() {
-	packageIndex, packageIndexLoadError = packageindex.LoadIndex(ProjectPath())
+	if ProjectPath() != nil {
+		packageIndex, packageIndexLoadError = packageindex.LoadIndex(ProjectPath())
+	}
 }
 
 var packageIndex *packageindex.Index

internal/rule/ruleconfiguration/ruleconfiguration.go

@@ -1481,6 +1481,22 @@ var configurations = []Type{
 		ErrorModes:       []rulemode.Type{rulemode.Strict},
 		RuleFunction:     rulefunction.IncorrectArduinoDotHFileNameCase,
 	},
+	{
+		ProjectType:      projecttype.PackageIndex,
+		SuperprojectType: projecttype.All,
+		Category:         "data",
+		Subcategory:      "general",
+		ID:               "IS001",
+		Brief:            "missing",
+		Description:      "",
+		MessageTemplate:  "No package index was found in specified project path. See: https://arduino.github.io/arduino-cli/latest/package_index_json-specification/",
+		DisableModes:     nil,
+		EnableModes:      []rulemode.Type{rulemode.Default},
+		InfoModes:        nil,
+		WarningModes:     nil,
+		ErrorModes:       []rulemode.Type{rulemode.Default},
+		RuleFunction:     rulefunction.PackageIndexMissing,
+	},
 	{
 		ProjectType:      projecttype.PackageIndex,
 		SuperprojectType: projecttype.All,

internal/rule/rulefunction/packageindex.go

@@ -22,8 +22,21 @@ import (
 
 // The rule functions for package indexes.
 
+// PackageIndexMissing checks whether a file resembling a package index was found in the specified project folder.
+func PackageIndexMissing() (result ruleresult.Type, output string) {
+	if projectdata.ProjectPath() == nil {
+		return ruleresult.Fail, ""
+	}
+
+	return ruleresult.Pass, ""
+}
+
 // PackageIndexJSONFormat checks whether the package index file is a valid JSON document.
 func PackageIndexJSONFormat() (result ruleresult.Type, output string) {
+	if projectdata.ProjectPath() == nil {
+		return ruleresult.NotRun, "Package index not found"
+	}
+
 	if isValidJSON(projectdata.ProjectPath()) {
 		return ruleresult.Pass, ""
 	}
@@ -33,6 +46,10 @@ func PackageIndexJSONFormat() (result ruleresult.Type, output string) {
 
 // PackageIndexFormat checks for invalid package index data format.
 func PackageIndexFormat() (result ruleresult.Type, output string) {
+	if projectdata.ProjectPath() == nil {
+		return ruleresult.NotRun, "Package index not found"
+	}
+
 	if projectdata.PackageIndexLoadError() != nil {
 		return ruleresult.Fail, projectdata.PackageIndexLoadError().Error()
 	}

internal/rule/rulefunction/packageindex_test.go

@@ -59,6 +59,15 @@ func checkPackageIndexRuleFunction(ruleFunction Type, testTables []packageIndexR
 	}
 }
 
+func TestPackageIndexMissing(t *testing.T) {
+	testTables := []packageIndexRuleFunctionTestTable{
+		{"Missing", "missing", ruleresult.Fail, ""},
+		{"Present", "valid-package-index", ruleresult.Pass, ""},
+	}
+
+	checkPackageIndexRuleFunction(PackageIndexMissing, testTables, t)
+}
+
 func TestPackageIndexJSONFormat(t *testing.T) {
 	testTables := []packageIndexRuleFunctionTestTable{
 		{"Invalid JSON", "invalid-JSON", ruleresult.Fail, ""},