Add command line interface

Author: per1234

README.md

@@ -1,6 +1,7 @@
 # arduino-check
 
-`arduino-check` automatically checks for common problems in your [Arduino](https://www.arduino.cc/) projects:
+`arduino-check` is a command line tool that automatically checks for common problems in your
+[Arduino](https://www.arduino.cc/) projects:
 
 - Sketches
 - Libraries

cli/cli.go

@@ -0,0 +1,44 @@
+// This file is part of arduino-check.
+//
+// Copyright 2020 ARDUINO SA (http://www.arduino.cc/)
+//
+// This software is released under the GNU General Public License version 3,
+// which covers the main part of arduino-check.
+// The terms of this license can be found at:
+// https://www.gnu.org/licenses/gpl-3.0.en.html
+//
+// You can be released from the requirements of the above licenses by purchasing
+// a commercial license. Buying such a license is mandatory if you want to
+// modify or otherwise use the software for commercial activities involving the
+// Arduino software without disclosing the source code of your own applications.
+// To purchase a commercial license, send an email to license@arduino.cc.
+
+// Package cli defines the arduino-check command line interface.
+package cli
+
+import (
+	"github.com/arduino/arduino-check/command"
+	"github.com/spf13/cobra"
+)
+
+// Root creates a new arduino-check command root.
+func Root() *cobra.Command {
+	rootCommand := &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.",
+		Run:                   command.ArduinoCheck,
+	}
+
+	rootCommand.PersistentFlags().String("format", "text", "The output format, can be {text|json}.")
+	rootCommand.PersistentFlags().String("library-manager", "", "Configure the checks for libraries in the Arduino Library Manager index. Can be {submit|update|false}.\nsubmit: Also run additional checks required to pass before a library is accepted for inclusion in the index.\nupdate: Also run additional checks required to pass before new releases of a library already in the index are accepted.\nfalse: Don't run any Library Manager-specific checks.")
+	rootCommand.PersistentFlags().String("log-format", "text", "The output format for the logs, can be {text|json}.")
+	rootCommand.PersistentFlags().String("log-level", "panic", "Messages with this level and above will be logged. Valid levels are: trace, debug, info, warn, error, fatal, panic")
+	rootCommand.PersistentFlags().Bool("permissive", false, "Only fail when critical issues are detected.")
+	rootCommand.PersistentFlags().String("project-type", "all", "Only check projects of the specified type and their subprojects. Can be {sketch|library|all}.")
+	rootCommand.PersistentFlags().Bool("recursive", true, "Search path recursively for Arduino projects to check. Can be {true|false}.")
+	rootCommand.PersistentFlags().String("report-file", "", "Save a report on the checks to this file.")
+
+	return rootCommand
+}

command/command.go

@@ -0,0 +1,72 @@
+// This file is part of arduino-check.
+//
+// Copyright 2020 ARDUINO SA (http://www.arduino.cc/)
+//
+// This software is released under the GNU General Public License version 3,
+// which covers the main part of arduino-check.
+// The terms of this license can be found at:
+// https://www.gnu.org/licenses/gpl-3.0.en.html
+//
+// You can be released from the requirements of the above licenses by purchasing
+// a commercial license. Buying such a license is mandatory if you want to
+// modify or otherwise use the software for commercial activities involving the
+// Arduino software without disclosing the source code of your own applications.
+// To purchase a commercial license, send an email to license@arduino.cc.
+
+// Package command implements the arduino-check commands.
+package command
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/arduino/arduino-check/check"
+	"github.com/arduino/arduino-check/configuration"
+	"github.com/arduino/arduino-check/project"
+	"github.com/arduino/arduino-check/result"
+	"github.com/arduino/arduino-check/result/feedback"
+	"github.com/arduino/arduino-check/result/outputformat"
+	"github.com/spf13/cobra"
+)
+
+// arduinoCheck is the root command function.
+func ArduinoCheck(rootCommand *cobra.Command, cliArguments []string) {
+	if err := configuration.Initialize(rootCommand.Flags(), cliArguments); err != nil {
+		feedback.Errorf("Configuration error: %v", err)
+		os.Exit(1)
+	}
+
+	result.Results.Initialize()
+
+	projects, err := project.FindProjects()
+	if err != nil {
+		feedback.Errorf("Error while finding projects: %v", err)
+		os.Exit(1)
+	}
+
+	for _, project := range projects {
+		check.RunChecks(project)
+	}
+
+	// All projects have been checked, so summarize their check results in the report.
+	result.Results.AddSummary()
+
+	if configuration.OutputFormat() == outputformat.Text {
+		if len(projects) > 1 {
+			// There are multiple projects, print the summary of check results for all projects.
+			fmt.Print(result.Results.SummaryText())
+		}
+	} else {
+		// Print the complete JSON formatted report.
+		fmt.Println(result.Results.JSONReport())
+	}
+
+	if configuration.ReportFilePath() != nil {
+		// Write report file.
+		result.Results.WriteReport()
+	}
+
+	if !result.Results.Passed() {
+		os.Exit(1)
+	}
+}

configuration/checkmode/checkmode.go

@@ -17,6 +17,9 @@
 package checkmode
 
 import (
+	"fmt"
+	"strings"
+
 	"github.com/arduino/arduino-check/project/projecttype"
 	"github.com/sirupsen/logrus"
 )
@@ -34,6 +37,20 @@ const (
 	Default                              // default
 )
 
+// LibraryManagerModeFromString parses the --library-manager flag value and returns the corresponding check mode settings.
+func LibraryManagerModeFromString(libraryManagerModeString string) (bool, bool, error) {
+	switch strings.ToLower(libraryManagerModeString) {
+	case "submit":
+		return true, false, nil
+	case "update":
+		return false, true, nil
+	case "false":
+		return false, false, nil
+	default:
+		return false, false, fmt.Errorf("No matching Library Manager mode for string %s", libraryManagerModeString)
+	}
+}
+
 // Modes merges the default check mode values for the given superproject type with any user-specified check mode settings.
 func Modes(defaultCheckModes map[projecttype.Type]map[Type]bool, customCheckModes map[Type]bool, superprojectType projecttype.Type) map[Type]bool {
 	checkModes := make(map[Type]bool)

configuration/configuration.go

@@ -17,42 +17,96 @@
 package configuration
 
 import (
+	"fmt"
 	"os"
+	"strings"
 
 	"github.com/arduino/arduino-check/configuration/checkmode"
 	"github.com/arduino/arduino-check/project/projecttype"
 	"github.com/arduino/arduino-check/result/outputformat"
 	"github.com/arduino/go-paths-helper"
 	"github.com/sirupsen/logrus"
+	"github.com/spf13/pflag"
 )
 
-// TODO: will it be possible to use init() instead?
 // Initialize sets up the tool configuration according to defaults and user-specified options.
-func Initialize() {
-	setDefaults()
-	// TODO configuration according to command line input
-	// TODO validate target path value, exit if not found
-	// TODO support multiple paths
-	// TODO validate output format input
+func Initialize(flags *pflag.FlagSet, projectPaths []string) error {
+	var err error
+	outputFormatString, _ := flags.GetString("format")
+	outputFormat, err = outputformat.FromString(outputFormatString)
+	if err != nil {
+		return fmt.Errorf("--format flag value %s not valid", outputFormatString)
+	}
 
-	targetPath = paths.New("e:/electronics/arduino/libraries/arduino-check-test-library")
+	libraryManagerModeString, _ := flags.GetString("library-manager")
+	if libraryManagerModeString != "" {
+		customCheckModes[checkmode.LibraryManagerSubmission], customCheckModes[checkmode.LibraryManagerIndexed], err = checkmode.LibraryManagerModeFromString(libraryManagerModeString)
+		if err != nil {
+			return fmt.Errorf("--library-manager flag value %s not valid", libraryManagerModeString)
+		}
+	}
 
-	// customCheckModes[checkmode.Permissive] = false
-	// customCheckModes[checkmode.LibraryManagerSubmission] = false
-	// customCheckModes[checkmode.LibraryManagerIndexed] = false
-	// customCheckModes[checkmode.Official] = false
-	// superprojectType = projecttype.All
+	logFormatString, _ := flags.GetString("log-format")
+	logFormat, err := logFormatFromString(logFormatString)
+	if err != nil {
+		return fmt.Errorf("--log-format flag value %s not valid", logFormatString)
+	}
+	logrus.SetFormatter(logFormat)
+
+	logLevelString, _ := flags.GetString("log-level")
+	logLevel, err := logrus.ParseLevel(logLevelString)
+	if err != nil {
+		return fmt.Errorf("--log-level flag value %s not valid", logLevelString)
+	}
+	logrus.SetLevel(logLevel)
+
+	customCheckModes[checkmode.Permissive], _ = flags.GetBool("permissive")
 
-	outputFormat = outputformat.JSON
-	//reportFilePath = paths.New("report.json")
+	superprojectTypeFilterString, _ := flags.GetString("project-type")
+	superprojectTypeFilter, err = projecttype.FromString(superprojectTypeFilterString)
+	if err != nil {
+		return fmt.Errorf("--project-type flag value %s not valid", superprojectTypeFilterString)
+	}
+
+	recursive, _ = flags.GetBool("recursive")
+
+	// TODO: validate path
+	reportFilePathString, _ := flags.GetString("report-file")
+	reportFilePath = paths.New(reportFilePathString)
+
+	// TODO validate target path value, exit if not found
+	// TODO support multiple paths
+	targetPath = paths.New(projectPaths[0])
 
-	logrus.SetLevel(logrus.PanicLevel)
+	// TODO: set via environment variable
+	// customCheckModes[checkmode.Official] = false
 
 	logrus.WithFields(logrus.Fields{
-		"superproject type filter": SuperprojectTypeFilter(),
-		"recursive":                Recursive(),
-		"projects path":            TargetPath(),
+		"output format":                   OutputFormat(),
+		"Library Manager submission mode": customCheckModes[checkmode.LibraryManagerSubmission],
+		"Library Manager update mode":     customCheckModes[checkmode.LibraryManagerIndexed],
+		"log format":                      logFormatString,
+		"log level":                       logrus.GetLevel().String(),
+		"permissive":                      customCheckModes[checkmode.Permissive],
+		"superproject type filter":        SuperprojectTypeFilter(),
+		"recursive":                       Recursive(),
+		"report file":                     ReportFilePath(),
+		"projects path":                   TargetPath(),
 	}).Debug("Configuration initialized")
+
+	return nil
+}
+
+// logFormatFromString parses the --log-format flag value and returns the corresponding log formatter.
+func logFormatFromString(logFormatString string) (logrus.Formatter, error) {
+	switch strings.ToLower(logFormatString) {
+	case "text":
+		return &logrus.TextFormatter{}, nil
+	case "json":
+		return &logrus.JSONFormatter{}, nil
+	default:
+		return nil, fmt.Errorf("No matching log format for string %s", logFormatString)
+	}
 }
 
 var customCheckModes = make(map[checkmode.Type]bool)