Merge pull request #127 from arduino/per1234/recursive-default-false

Make the default value of the --recursive flag false

Author: per1234

Diff for: internal/cli/cli.go

@@ -35,7 +35,7 @@ func Root() *cobra.Command {
 	rootCommand.PersistentFlags().String("format", "text", "The output format can be {text|json}.")
 	rootCommand.PersistentFlags().String("library-manager", "", "Configure the rules for libraries in the Arduino Library Manager index. Can be {submit|update|false}.\nsubmit: Also run additional rules required to pass before a library is accepted for inclusion in the index.\nupdate: Also run additional rules required to pass before new releases of a library already in the index are accepted.\nfalse: Don't run any Library Manager-specific rules.")
 	rootCommand.PersistentFlags().String("project-type", "all", "Only check projects of the specified type and their subprojects. Can be {sketch|library|all}.")
-	rootCommand.PersistentFlags().String("recursive", "true", "Search path recursively for Arduino projects to check. Can be {true|false}.")
+	rootCommand.PersistentFlags().Bool("recursive", false, "Search path recursively for Arduino projects to check. Can be {true|false}.")
 	rootCommand.PersistentFlags().String("report-file", "", "Save a report on the rules to this file.")
 	rootCommand.PersistentFlags().BoolP("verbose", "v", false, "Show more information while running rules.")
 	rootCommand.PersistentFlags().Bool("version", false, "Print version and timestamp of the build.")

Diff for: internal/configuration/configuration.go

@@ -81,11 +81,7 @@ func Initialize(flags *pflag.FlagSet, projectPaths []string) error {
 		return fmt.Errorf("--project-type flag value %s not valid", superprojectTypeFilterString)
 	}
 
-	recursiveString, _ := flags.GetString("recursive")
-	recursive, err = strconv.ParseBool(recursiveString)
-	if err != nil {
-		return fmt.Errorf("--recursive flag value %s not valid", recursiveString)
-	}
+	recursive, _ = flags.GetBool("recursive")
 
 	reportFilePathString, _ := flags.GetString("report-file")
 	reportFilePath = paths.New(reportFilePathString)

Diff for: internal/configuration/configuration_test.go

@@ -159,9 +159,6 @@ func TestInitializeProjectType(t *testing.T) {
 func TestInitializeRecursive(t *testing.T) {
 	flags := test.ConfigurationFlags()
 
-	flags.Set("recursive", "foo")
-	assert.Error(t, Initialize(flags, projectPaths))
-
 	flags.Set("recursive", "true")
 	assert.Nil(t, Initialize(flags, projectPaths))
 	assert.True(t, Recursive())

Diff for: 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
 }

Diff for: 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 {

Diff for: 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

Diff for: 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,

Diff for: 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()
 	}

Diff for: 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, ""},

Diff for: internal/rule/rulefunction/testdata/packageindexes/missing/.gitkeep

@@ -27,7 +27,7 @@ func ConfigurationFlags() *pflag.FlagSet {
 	flags.String("log-format", "text", "")
 	flags.String("log-level", "panic", "")
 	flags.String("project-type", "all", "")
-	flags.String("recursive", "true", "")
+	flags.Bool("recursive", true, "")
 	flags.String("report-file", "", "")
 	flags.Bool("verbose", false, "")
 	flags.Bool("version", false, "")

Diff for: internal/util/test/test.go

@@ -26,9 +26,12 @@
 
 
 def test_defaults(run_command):
-    result = run_command(cmd=[], custom_working_dir=test_data_path.joinpath("recursive"))
+    result = run_command(cmd=[], custom_working_dir=test_data_path.joinpath("ValidSketch"))
     assert result.ok
 
+    result = run_command(cmd=[], custom_working_dir=test_data_path.joinpath("recursive"))
+    assert not result.ok
+
 
 @pytest.mark.parametrize(
     "project_folder, compliance_level",
@@ -115,31 +118,44 @@ def test_project_type_invalid(run_command):
 
 def test_recursive(run_command):
     valid_projects_path = test_data_path.joinpath("recursive")
-    result = run_command(cmd=["--recursive", "true", valid_projects_path])
-    assert result.ok
-
-    result = run_command(cmd=["--recursive", "false", valid_projects_path])
+    result = run_command(cmd=[valid_projects_path])
     assert not result.ok
 
-
-def test_recursive_invalid(run_command):
-    result = run_command(cmd=["--recursive", "foo", test_data_path.joinpath("ValidSketch")])
-    assert not result.ok
+    result = run_command(cmd=["--recursive", valid_projects_path])
+    assert result.ok
 
 
 def test_report_file(run_command, working_dir):
     project_path = test_data_path.joinpath("ValidSketch")
+    compliance = "permissive"
+    library_manager = "update"
+    project_type = "sketch"
     report_file_name = "report.json"
-    result = run_command(cmd=["--report-file", report_file_name, project_path])
+    result = run_command(
+        cmd=[
+            "--compliance",
+            compliance,
+            "--library-manager",
+            library_manager,
+            "--project-type",
+            project_type,
+            "--recursive",
+            "--report-file",
+            report_file_name,
+            project_path,
+        ]
+    )
     assert result.ok
     with pathlib.Path(working_dir, report_file_name).open() as report_file:
         report = json.load(report_file)
 
     assert pathlib.PurePath(report["configuration"]["paths"][0]) == project_path
-    assert report["configuration"]["projectType"] == "all"
+    assert report["configuration"]["projectType"] == project_type
     assert report["configuration"]["recursive"]
     assert pathlib.PurePath(report["projects"][0]["path"]) == project_path
     assert report["projects"][0]["projectType"] == "sketch"
+    assert report["projects"][0]["configuration"]["compliance"] == compliance
+    assert report["projects"][0]["configuration"]["libraryManager"] == library_manager
     assert report["projects"][0]["summary"]["pass"]
     assert report["projects"][0]["summary"]["errorCount"] == 0
     assert report["summary"]["pass"]
@@ -187,7 +203,7 @@ def test_version(run_command):
 
 
 def test_arduino_lint_official(run_command):
-    project_path = test_data_path.joinpath("ARDUINO_LINT_OFFICIAL")
+    project_path = test_data_path.joinpath("ARDUINO_LINT_OFFICIAL", "Arduino_Lib")
 
     result = run_command(cmd=[project_path])
     assert not result.ok