Merge pull request #88 from arduino/per1234/remove-all-check-mode

Remove "All" check mode

Author: per1234

check/check.go

@@ -71,6 +71,10 @@ func shouldRun(checkConfiguration checkconfigurations.Type, currentProject proje
 		return false, nil
 	}
 
+	return IsEnabled(checkConfiguration, configurationCheckModes)
+}
+
+func IsEnabled(checkConfiguration checkconfigurations.Type, configurationCheckModes map[checkmode.Type]bool) (bool, error) {
 	for _, disableMode := range checkConfiguration.DisableModes {
 		if configurationCheckModes[disableMode] {
 			return false, nil

check/checkconfigurations/checkconfigurations.go

@@ -0,0 +1,67 @@
+// 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 [email protected].
+
+package checkconfigurations_test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/arduino/arduino-check/check"
+	"github.com/arduino/arduino-check/check/checkconfigurations"
+	"github.com/arduino/arduino-check/check/checklevel"
+	"github.com/arduino/arduino-check/configuration/checkmode"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestConfigurationResolution(t *testing.T) {
+	for _, checkConfiguration := range checkconfigurations.Configurations() {
+		for checkMode := range checkmode.Types {
+			enabled, err := check.IsEnabled(checkConfiguration, map[checkmode.Type]bool{checkMode: true})
+			assert.Nil(t, err, fmt.Sprintf("Enable configuration of check %s doesn't resolve for check mode %s", checkConfiguration.ID, checkMode))
+			if err == nil && enabled {
+				_, err := checklevel.CheckLevelForCheckModes(checkConfiguration, map[checkmode.Type]bool{checkMode: true})
+				assert.Nil(t, err, fmt.Sprintf("Level configuration of check %s doesn't resolve for check mode %s", checkConfiguration.ID, checkMode))
+			}
+		}
+	}
+}
+
+func TestConfigurationCheckModeConflict(t *testing.T) {
+	// Having the same check mode in multiple configurations results in the configuration behavior being dependent on which order the fields are processed in, which may change.
+	for _, checkConfiguration := range checkconfigurations.Configurations() {
+		conflict, checkMode := checkModeConflict(checkConfiguration.DisableModes, checkConfiguration.EnableModes)
+		assert.False(t, conflict, fmt.Sprintf("Duplicated check mode %s in enable configuration of check %s", checkMode, checkConfiguration.ID))
+
+		conflict, checkMode = checkModeConflict(checkConfiguration.InfoModes, checkConfiguration.WarningModes, checkConfiguration.ErrorModes)
+		assert.False(t, conflict, fmt.Sprintf("Duplicated check mode %s in level configuration of check %s", checkMode, checkConfiguration.ID))
+	}
+}
+
+// checkModeConflict checks whether the same check mode is present in multiple configuration fields.
+func checkModeConflict(configurations ...[]checkmode.Type) (bool, checkmode.Type) {
+	modeCounter := 0
+	checkModeMap := make(map[checkmode.Type]bool)
+	for _, configuration := range configurations {
+		for _, checkMode := range configuration {
+			modeCounter += 1
+			checkModeMap[checkMode] = true
+			if len(checkModeMap) < modeCounter {
+				return true, checkMode
+			}
+		}
+	}
+	return false, checkmode.Default
+}

check/checkconfigurations/checkconfigurations_test.go

@@ -39,6 +39,10 @@ const (
 // CheckLevel determines the check level assigned to failure of the given check under the current tool configuration.
 func CheckLevel(checkConfiguration checkconfigurations.Type) (Type, error) {
 	configurationCheckModes := configuration.CheckModes(checkConfiguration.ProjectType)
+	return CheckLevelForCheckModes(checkConfiguration, configurationCheckModes)
+}
+
+func CheckLevelForCheckModes(checkConfiguration checkconfigurations.Type, configurationCheckModes map[checkmode.Type]bool) (Type, error) {
 	for _, errorMode := range checkConfiguration.ErrorModes {
 		if configurationCheckModes[errorMode] {
 			return Error, nil

check/checklevel/checklevel.go

@@ -35,10 +35,22 @@ const (
 	LibraryManagerSubmission             // --library-manager=submit
 	LibraryManagerIndexed                // --library-manager=update
 	Official                             // ARDUINO_CHECK_OFFICIAL
-	All                                  // always
 	Default                              // default
 )
 
+var empty struct{}
+
+// Types provides an iterator and validator for Type.
+var Types = map[Type]struct{}{
+	Strict:                   empty,
+	Specification:            empty,
+	Permissive:               empty,
+	LibraryManagerSubmission: empty,
+	LibraryManagerIndexed:    empty,
+	Official:                 empty,
+	Default:                  empty,
+}
+
 // ComplianceModeFromString parses the --compliance flag value and returns the corresponding check mode settings.
 func ComplianceModeFromString(complianceModeString string) (bool, bool, bool, error) {
 	switch strings.ToLower(complianceModeString) {
@@ -81,9 +93,6 @@ func Modes(defaultCheckModes map[projecttype.Type]map[Type]bool, customCheckMode
 		logrus.Tracef("Check mode option %s set to %t\n", key, checkModes[key])
 	}
 
-	// This mode is always enabled
-	checkModes[All] = true
-
 	return checkModes
 }
 

configuration/checkmode/checkmode.go

@@ -23,19 +23,29 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
+func TestTypes(t *testing.T) {
+	for key := range Types {
+		_, valid := Types[key]
+		assert.True(t, valid)
+	}
+
+	_, valid := Types[Strict]
+	assert.True(t, valid)
+	_, valid = Types[42]
+	assert.False(t, valid)
+}
+
 func TestMode(t *testing.T) {
 	defaultCheckModes := map[projecttype.Type]map[Type]bool{
 		projecttype.Sketch: {
 			LibraryManagerSubmission: false,
 			LibraryManagerIndexed:    false,
 			Official:                 false,
-			All:                      true,
 		},
 		projecttype.Library: {
 			LibraryManagerSubmission: true,
 			LibraryManagerIndexed:    false,
 			Official:                 false,
-			All:                      true,
 		},
 	}