Default PROJECT_PATH argument to current working directory

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 or current path if no PROJECT_PATH argument provided.",
 		Run:                   command.ArduinoCheck,
 	}
 

configuration/configuration.go

@@ -74,16 +74,25 @@ func Initialize(flags *pflag.FlagSet, projectPaths []string) error {
 	reportFilePathString, _ := flags.GetString("report-file")
 	reportFilePath = paths.New(reportFilePathString)
 
-	for _, projectPath := range projectPaths {
-		targetPath := paths.New(projectPath)
-		targetPathExists, err := targetPath.ExistCheck()
+	if len(projectPaths) == 0 {
+		// Default to using current working directory.
+		workingDirectoryPath, err := os.Getwd()
 		if err != nil {
-			return fmt.Errorf("Problem processing PROJECT_PATH argument value %v: %v", targetPath, err)
+			return fmt.Errorf("Error when setting default PROJECT_PATH argument: %s", err)
 		}
-		if !targetPathExists {
-			return fmt.Errorf("PROJECT_PATH argument %v does not exist", targetPath)
+		targetPaths.Add(paths.New(workingDirectoryPath))
+	} else {
+		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)
 		}
-		targetPaths.AddIfMissing(targetPath)
 	}
 
 	if officialModeString, ok := os.LookupEnv("ARDUINO_CHECK_OFFICIAL"); ok {

configuration/configuration_test.go

@@ -28,13 +28,18 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func TestInitialize(t *testing.T) {
-	flags := test.ConfigurationFlags()
+var projectPaths []string
 
+func init() {
 	projectPath, err := os.Getwd()
-	require.Nil(t, err)
-	projectPaths := []string{projectPath}
+	if err != nil {
+		panic(err)
+	}
+	projectPaths = []string{projectPath}
+}
 
+func TestInitializeFormat(t *testing.T) {
+	flags := test.ConfigurationFlags()
 	flags.Set("format", "foo")
 	assert.Error(t, Initialize(flags, projectPaths))
 
@@ -45,7 +50,10 @@ func TestInitialize(t *testing.T) {
 	flags.Set("format", "json")
 	assert.Nil(t, Initialize(flags, projectPaths))
 	assert.Equal(t, outputformat.JSON, OutputFormat())
+}
 
+func TestInitializeLibraryManager(t *testing.T) {
+	flags := test.ConfigurationFlags()
 	flags.Set("library-manager", "foo")
 	assert.Error(t, Initialize(flags, projectPaths))
 
@@ -71,6 +79,10 @@ func TestInitialize(t *testing.T) {
 	assert.Nil(t, Initialize(flags, projectPaths))
 	assert.False(t, customCheckModes[checkmode.LibraryManagerSubmission])
 	assert.False(t, customCheckModes[checkmode.LibraryManagerIndexed])
+}
+
+func TestInitializeLogFormat(t *testing.T) {
+	flags := test.ConfigurationFlags()
 
 	flags.Set("log-format", "foo")
 	assert.Error(t, Initialize(flags, projectPaths))
@@ -80,6 +92,10 @@ func TestInitialize(t *testing.T) {
 
 	flags.Set("log-format", "json")
 	assert.Nil(t, Initialize(flags, projectPaths))
+}
+
+func TestInitializePermissive(t *testing.T) {
+	flags := test.ConfigurationFlags()
 
 	flags.Set("permissive", "true")
 	assert.Nil(t, Initialize(flags, projectPaths))
@@ -88,6 +104,10 @@ func TestInitialize(t *testing.T) {
 	flags.Set("permissive", "false")
 	assert.Nil(t, Initialize(flags, projectPaths))
 	assert.False(t, customCheckModes[checkmode.Permissive])
+}
+
+func TestInitializeProjectType(t *testing.T) {
+	flags := test.ConfigurationFlags()
 
 	flags.Set("project-type", "foo")
 	assert.Error(t, Initialize(flags, projectPaths))
@@ -111,6 +131,10 @@ func TestInitialize(t *testing.T) {
 	flags.Set("project-type", "all")
 	assert.Nil(t, Initialize(flags, projectPaths))
 	assert.Equal(t, projecttype.All, SuperprojectTypeFilter())
+}
+
+func TestInitializeRecursive(t *testing.T) {
+	flags := test.ConfigurationFlags()
 
 	flags.Set("recursive", "true")
 	assert.Nil(t, Initialize(flags, projectPaths))
@@ -119,6 +143,10 @@ func TestInitialize(t *testing.T) {
 	flags.Set("recursive", "false")
 	assert.Nil(t, Initialize(flags, projectPaths))
 	assert.False(t, Recursive())
+}
+
+func TestInitializeReportFile(t *testing.T) {
+	flags := test.ConfigurationFlags()
 
 	flags.Set("report-file", "")
 	assert.Nil(t, Initialize(flags, projectPaths))
@@ -128,11 +156,26 @@ func TestInitialize(t *testing.T) {
 	flags.Set("report-file", reportFilePath.String())
 	assert.Nil(t, Initialize(flags, projectPaths))
 	assert.Equal(t, reportFilePath, ReportFilePath())
+}
 
-	assert.Nil(t, Initialize(flags, projectPaths))
+func TestInitializeProjectPath(t *testing.T) {
+	targetPaths = nil
+	assert.Nil(t, Initialize(test.ConfigurationFlags(), []string{}))
+	workingDirectoryPath, err := os.Getwd()
+	require.Nil(t, err)
+	assert.Equal(t, paths.NewPathList(workingDirectoryPath), TargetPaths(), "Default PROJECT_PATH to current working directory")
+
+	targetPaths = nil
+	assert.Nil(t, Initialize(test.ConfigurationFlags(), projectPaths))
 	assert.Equal(t, paths.NewPathList(projectPaths[0]), TargetPaths())
 
-	assert.Error(t, Initialize(flags, []string{"/nonexistent"}))
+	targetPaths = nil
+	assert.Error(t, Initialize(test.ConfigurationFlags(), []string{"/nonexistent"}))
+}
+
+func TestInitializeOfficial(t *testing.T) {
+	assert.Nil(t, Initialize(test.ConfigurationFlags(), projectPaths))
+	assert.False(t, customCheckModes[checkmode.Official], "Default official check mode")
 
 	os.Setenv("ARDUINO_CHECK_OFFICIAL", "true")
 	assert.Nil(t, Initialize(test.ConfigurationFlags(), projectPaths))