Support multiple PROJECT_PATH arguments

Author: per1234

Diff for: cli/cli.go

@@ -27,7 +27,7 @@ func Root() *cobra.Command {
 		Short:                 "Linter for Arduino projects.",
 		Long:                  "arduino-check checks specification compliance and for other common problems with Arduino projects",
 		DisableFlagsInUseLine: true,
-		Use:                   "arduino-check [FLAG]... PROJECT_PATH\n\nRun checks on PROJECT_PATH.",
+		Use:                   "arduino-check [FLAG]... PROJECT_PATH...\n\nRun checks on PROJECT_PATH.",
 		Run:                   command.ArduinoCheck,
 	}
 

Diff for: configuration/configuration.go

@@ -74,14 +74,16 @@ func Initialize(flags *pflag.FlagSet, projectPaths []string) error {
 	reportFilePathString, _ := flags.GetString("report-file")
 	reportFilePath = paths.New(reportFilePathString)
 
-	// TODO support multiple paths
-	targetPath = paths.New(projectPaths[0])
-	targetPathExists, err := targetPath.ExistCheck()
-	if err != nil {
-		return fmt.Errorf("Problem processing PROJECT_PATH argument value %v: %v", projectPaths[0], err)
-	}
-	if !targetPathExists {
-		return fmt.Errorf("PROJECT_PATH argument %v does not exist", projectPaths[0])
+	for _, projectPath := range projectPaths {
+		targetPath := paths.New(projectPath)
+		targetPathExists, err := targetPath.ExistCheck()
+		if err != nil {
+			return fmt.Errorf("Problem processing PROJECT_PATH argument value %v: %v", targetPath, err)
+		}
+		if !targetPathExists {
+			return fmt.Errorf("PROJECT_PATH argument %v does not exist", targetPath)
+		}
+		targetPaths.AddIfMissing(targetPath)
 	}
 
 	if officialModeString, ok := os.LookupEnv("ARDUINO_CHECK_OFFICIAL"); ok {
@@ -101,7 +103,7 @@ func Initialize(flags *pflag.FlagSet, projectPaths []string) error {
 		"superproject type filter":        SuperprojectTypeFilter(),
 		"recursive":                       Recursive(),
 		"report file":                     ReportFilePath(),
-		"projects path":                   TargetPath(),
+		"projects path":                   TargetPaths(),
 	}).Debug("Configuration initialized")
 
 	return nil
@@ -154,11 +156,11 @@ func ReportFilePath() *paths.Path {
 	return reportFilePath
 }
 
-var targetPath *paths.Path
+var targetPaths paths.PathList
 
-// TargetPath returns the projects search path.
-func TargetPath() *paths.Path {
-	return targetPath
+// TargetPaths returns the projects search paths.
+func TargetPaths() paths.PathList {
+	return targetPaths
 }
 
 // SchemasPath returns the path to the folder containing the JSON schemas.

Diff for: configuration/configuration_test.go

@@ -130,7 +130,7 @@ func TestInitialize(t *testing.T) {
 	assert.Equal(t, reportFilePath, ReportFilePath())
 
 	assert.Nil(t, Initialize(flags, projectPaths))
-	assert.Equal(t, paths.New(projectPaths[0]), TargetPath())
+	assert.Equal(t, paths.NewPathList(projectPaths[0]), TargetPaths())
 
 	assert.Error(t, Initialize(flags, []string{"/nonexistent"}))
 

Diff for: project/project.go

@@ -39,17 +39,26 @@ type Type struct {
 // FindProjects searches the target path configured by the user for projects of the type configured by the user as well as the subprojects of those project.
 // It returns a slice containing the definitions of each found project.
 func FindProjects() ([]Type, error) {
-	targetPath := configuration.TargetPath()
-	superprojectTypeFilter := configuration.SuperprojectTypeFilter()
-	recursive := configuration.Recursive()
+	var foundProjects []Type
+
+	for _, targetPath := range configuration.TargetPaths() {
+		foundProjectsForTargetPath, err := findProjects(targetPath)
+		if err != nil {
+			return nil, err
+		}
+		foundProjects = append(foundProjects, foundProjectsForTargetPath...)
+	}
+	return foundProjects, nil
+}
 
+func findProjects(targetPath *paths.Path) ([]Type, error) {
 	var foundProjects []Type
 
 	// If targetPath is a file, targetPath itself is the project, so it's only necessary to determine/verify the type.
 	if targetPath.IsNotDir() {
 		logrus.Debug("Projects path is file")
 		// The filename provides additional information about the project type. So rather than using isProject(), which doesn't make use this information, use a specialized function that does.
-		isProject, projectType := isProjectIndicatorFile(targetPath, superprojectTypeFilter)
+		isProject, projectType := isProjectIndicatorFile(targetPath, configuration.SuperprojectTypeFilter())
 		if isProject {
 			foundProject := Type{
 				Path:             targetPath.Parent(),
@@ -66,7 +75,7 @@ func FindProjects() ([]Type, error) {
 		return nil, fmt.Errorf("specified path %s is not an Arduino project", targetPath)
 	}
 
-	foundProjects = append(foundProjects, findProjectsUnderPath(targetPath, superprojectTypeFilter, recursive)...)
+	foundProjects = append(foundProjects, findProjectsUnderPath(targetPath, configuration.SuperprojectTypeFilter(), configuration.Recursive())...)
 
 	if foundProjects == nil {
 		return nil, fmt.Errorf("no projects found under %s", targetPath)

Diff for: result/result.go

@@ -44,9 +44,9 @@ type Type struct {
 }
 
 type toolConfigurationReportType struct {
-	Paths       []*paths.Path `json:"paths"`
-	ProjectType string        `json:"projectType"`
-	Recursive   bool          `json:"recursive"`
+	Paths       paths.PathList `json:"paths"`
+	ProjectType string         `json:"projectType"`
+	Recursive   bool           `json:"recursive"`
 }
 
 type projectReportType struct {
@@ -84,7 +84,7 @@ type summaryReportType struct {
 // Initialize adds the tool configuration data to the results data.
 func (results *Type) Initialize() {
 	results.Configuration = toolConfigurationReportType{
-		Paths:       []*paths.Path{configuration.TargetPath()},
+		Paths:       configuration.TargetPaths(),
 		ProjectType: configuration.SuperprojectTypeFilter().String(),
 		Recursive:   configuration.Recursive(),
 	}