fix: make enabled optional in .deepsource.toml

.deepsource.toml

@@ -2,15 +2,12 @@ version = 1
 
 [[analyzers]]
 name = "go"
-enabled = true
 
   [analyzers.meta]
   import_path = "github.com/deepsourcelabs/cli"
 
 [[analyzers]]
 name = "secrets"
-enabled = true
 
 [[analyzers]]
-name = "test-coverage"
-enabled = true
+name = "test-coverage"

configvalidator/analyzer_config_validator.go

@@ -24,15 +24,14 @@ func (c *ConfigValidator) validateAnalyzersConfig() {
 		c.pushError(fmt.Sprintf("Value of `analyzers` should be an array. Found: %v", analyzersType))
 	}
 
-	// Enabled must be boolean. And atleast one analyzer must be enabled among all mentioned in config
+	// Count enabled analyzers (missing enabled field defaults to true)
 	countEnabled := 0
 	for _, analyzer := range c.Config.Analyzers {
-		enabledType := reflect.TypeOf(analyzer.Enabled).Kind().String()
-		if enabledType != "bool" {
-			c.pushError(fmt.Sprintf("The `enabled` property should be of boolean type. Found: %v", enabledType))
-		}
+		// If enabled is not set (nil), consider it as enabled (true)
+		// If enabled is set, use its value
+		isEnabled := analyzer.Enabled == nil || *analyzer.Enabled
 
-		if analyzer.Enabled {
+		if isEnabled {
 			countEnabled++
 		}
 	}
@@ -47,7 +46,8 @@ func (c *ConfigValidator) validateAnalyzersConfig() {
 			if analyzer.Name == supportedAnalyzer {
 				// Copy the meta of activated analyzer for usage in
 				// analyzer meta validation
-				if analyzer.Enabled {
+				isEnabled := analyzer.Enabled == nil || *analyzer.Enabled
+				if isEnabled {
 					activatedAnalyzers[analyzer.Name] = analyzer.Meta
 				}
 				supported = true

configvalidator/config_validator.go

@@ -2,6 +2,8 @@ package configvalidator
 
 import (
 	"bytes"
+	"fmt"
+	"strings"
 
 	"github.com/spf13/viper"
 )
@@ -41,7 +43,20 @@ func (c *ConfigValidator) ValidateConfig(inputConfig []byte) Result {
 		return c.Result
 	}
 	// Unmarshaling the configdata into DSConfig struct
-	viper.UnmarshalExact(&config)
+	err = viper.UnmarshalExact(&config)
+	if err != nil {
+		// Check if the error is due to invalid enabled field types
+		// match `` * cannot parse 'analyzers[0].enabled' as bool: strconv.ParseBool: parsing "falsee": invalid syntax`
+		if strings.Contains(err.Error(), "strconv.ParseBool") {
+			c.Result.Valid = false
+			c.Result.Errors = append(c.Result.Errors, "The `enabled` property should be of boolean type (true/false)")
+			return c.Result
+		}
+		// Other unmarshaling errors
+		c.Result.Valid = false
+		c.Result.Errors = append(c.Result.Errors, fmt.Sprintf("Error while parsing config: %v", err))
+		return c.Result
+	}
 	c.Config = config
 
 	// Validate generic config which applies to all analyzers and transformers

configvalidator/config_validator_test.go

@@ -1,7 +1,6 @@
 package configvalidator
 
 import (
-	"reflect"
 	"testing"
 
 	"github.com/deepsourcelabs/cli/utils"
@@ -107,12 +106,43 @@ func TestValidateConfig(t *testing.T) {
             enabled = true`,
 			valid: false,
 		},
+		"valid config with enabled not set (defaults to true)": {
+			inputConfig: `
+            version = 1
+
+            [[analyzers]]
+            name = "python"
+
+            [[transformers]]
+            name = "black"`,
+			valid: true,
+		},
+
+		"invalid config with enabled = \"falsee\" (non-boolean)": {
+			inputConfig: `
+            version = 1
+
+            [[analyzers]]
+            name = "python"
+            enabled = "falsee"`,
+			valid: false,
+		},
+		"config with syntax error": {
+			inputConfig: `
+            version = 1
+
+            [[analyzers]
+            name = "python"
+            enabled = false`,
+			valid: false,
+		},
 	}
+
 	for testName, tc := range tests {
 		t.Run(testName, func(t *testing.T) {
 			c := &ConfigValidator{}
 			c.ValidateConfig([]byte(tc.inputConfig))
-			if !reflect.DeepEqual(tc.valid, c.Result.Valid) {
+			if tc.valid != c.Result.Valid {
 				t.Errorf("%s: expected: %v, got: %v. Error: %v", testName, tc.valid, c.Result.Valid, c.Result.Errors)
 			}
 		})

configvalidator/transformer_config_validator.go

@@ -21,13 +21,8 @@ func (c *ConfigValidator) validateTransformersConfig() {
 		c.pushError(fmt.Sprintf("Value of `transformers` should be an array. Found: %v", transformersType))
 	}
 
-	// Enabled property should be of boolean type
-	for _, transformer := range c.Config.Transformers {
-		enabledType := reflect.TypeOf(transformer.Enabled).Kind().String()
-		if enabledType != "bool" {
-			c.pushError(fmt.Sprintf("The `enabled` property should be of boolean type. Found: %v", enabledType))
-		}
-	}
+	// Enabled property validation is handled in the main config validator
+	// (transformers with invalid enabled types will cause unmarshaling errors)
 
 	// ==== Transformer shortcode validation ====
 	supported := false

configvalidator/types.go

@@ -4,15 +4,15 @@ package configvalidator
 type Analyzer struct {
 	Name                string      `mapstructure:"name,omitempty" json:"name,omitempty"`
 	RuntimeVersion      string      `mapstructure:"runtime_version,omitempty" json:"runtime_version,omitempty"`
-	Enabled             bool        `mapstructure:"enabled,omitempty" json:"enabled"`
+	Enabled             *bool       `mapstructure:"enabled,omitempty" json:"enabled,omitempty"`
 	DependencyFilePaths []string    `mapstructure:"dependency_file_paths,omitempty" json:"dependency_file_paths,omitempty"`
 	Meta                interface{} `mapstructure:"meta,omitempty" json:"meta,omitempty"`
 	Thresholds          interface{} `mapstructure:"thresholds,omitempty" json:"thresholds,omitempty"`
 }
 
 type Transformer struct {
 	Name    string `mapstructure:"name,omitempty" json:"name,omitempty"`
-	Enabled bool   `mapstructure:"enabled,omitempty" json:"enabled,omitempty"`
+	Enabled *bool  `mapstructure:"enabled,omitempty" json:"enabled,omitempty"`
 }
 
 type DSConfig struct {