Add denyRegex support for import-alias-naming rule

README.md

@@ -534,7 +534,7 @@ List of all available rules. The rules ported from `golint` are left unchanged a
 | [`datarace`](./RULES_DESCRIPTIONS.md#datarace)          |  n/a   |  Spots potential dataraces |    no    |  no   |
 | [`comment-spacings`](./RULES_DESCRIPTIONS.md#comment-spacings)          |  []string   |  Warns on malformed comments |    no    |  no   |
 | [`redundant-import-alias`](./RULES_DESCRIPTIONS.md#redundant-import-alias)          |  n/a   |  Warns on import aliases matching the imported package name |    no    |  no   |
-| [`import-alias-naming`](./RULES_DESCRIPTIONS.md#import-alias-naming)         | string (defaults to ^[a-z][a-z0-9]{0,}$) | Conventions around the naming of import aliases.                              |    no    |  no   |
+| [`import-alias-naming`](./RULES_DESCRIPTIONS.md#import-alias-naming)         | string or map[string]string (defaults to allow regex pattern ^[a-z][a-z0-9]{0,}$) | Conventions around the naming of import aliases.                              |    no    |  no   |
 | [`enforce-map-style`](./RULES_DESCRIPTIONS.md#enforce-map-style) |  string (defaults to "any")  |  Enforces consistent usage of `make(map[type]type)` or `map[type]type{}` for map initialization. Does not affect `make(map[type]type, size)` constructions. |    no    |  no   |
 | [`enforce-slice-style`](./RULES_DESCRIPTIONS.md#enforce-slice-style) |  string (defaults to "any")  |  Enforces consistent usage of `make([]type, 0)` or `[]type{}` for slice initialization. Does not affect `make(map[type]type, non_zero_len, or_non_zero_cap)` constructions. |    no    |  no   |
 

RULES_DESCRIPTIONS.md

@@ -489,13 +489,28 @@ _Description_: Aligns with Go's naming conventions, as outlined in the official
 the principles of good package naming. Users can follow these guidelines by default or define a custom regex rule.
 Importantly, aliases with underscores ("_") are always allowed.
 
-_Configuration_: (string) regular expression to match the aliases (default: ^[a-z][a-z0-9]{0,}$)
+_Configuration_ (1): (string) as plain string accepts allow regexp pattern for aliases (default: ^[a-z][a-z0-9]{0,}$),
+_Configuration_ (2): (map[string]string) as a map accepts two values:
+* for a key "allowRegex" accepts allow regexp pattern
+* for a key "denyRegex deny regexp pattern
 
-Example:
+_Note_: If both `allowRegex` and `denyRegex` are provided, the alias must comply with both of them.
+If none are given (i.e. an empty map), the default value ^[a-z][a-z0-9]{0,}$ for allowRegex is used.
+Unknown keys will result in an error.
+
+
+Example (1):
+
+```toml
+[rule.import-alias-naming]
+  arguments = ["^[a-z][a-z0-9]{0,}$"]
+```
+
+Example (2):
 
 ```toml
 [rule.import-alias-naming]
-  arguments =["^[a-z][a-z0-9]{0,}$"]
+  arguments = [ { allowRegex = "^[a-z][a-z0-9]{0,}$", denyRegex = '^v\d+$' } ]
 ```
 
 ## import-shadowing

rule/import-alias-naming.go

@@ -10,14 +10,15 @@ import (
 
 // ImportAliasNamingRule lints import alias naming.
 type ImportAliasNamingRule struct {
-	configured       bool
-	namingRuleRegexp *regexp.Regexp
+	configured  bool
+	allowRegexp *regexp.Regexp
+	denyRegexp  *regexp.Regexp
 	sync.Mutex
 }
 
-const defaultNamingRule = "^[a-z][a-z0-9]{0,}$"
+const defaultImportAliasNamingAllowRule = "^[a-z][a-z0-9]{0,}$"
 
-var defaultNamingRuleRegexp = regexp.MustCompile(defaultNamingRule)
+var defaultImportAliasNamingAllowRegexp = regexp.MustCompile(defaultImportAliasNamingAllowRule)
 
 func (r *ImportAliasNamingRule) configure(arguments lint.Arguments) {
 	r.Lock()
@@ -26,20 +27,31 @@ func (r *ImportAliasNamingRule) configure(arguments lint.Arguments) {
 		return
 	}
 
-	if len(arguments) < 1 {
-		r.namingRuleRegexp = defaultNamingRuleRegexp
+	if len(arguments) == 0 {
+		r.allowRegexp = defaultImportAliasNamingAllowRegexp
 		return
 	}
 
-	namingRule, ok := arguments[0].(string) // Alt. non panicking version
-	if !ok {
-		panic(fmt.Sprintf("Invalid argument '%v' for 'import-alias-naming' rule. Expecting string, got %T", arguments[0], arguments[0]))
+	switch namingRule := arguments[0].(type) {
+	case string:
+		r.setAllowRule(namingRule)
+	case map[string]any: // expecting map[string]string
+		for k, v := range namingRule {
+			switch k {
+			case "allowRegex":
+				r.setAllowRule(v)
+			case "denyRegex":
+				r.setDenyRule(v)
+			default:
+				panic(fmt.Sprintf("Invalid map key for 'import-alias-naming' rule. Expecting 'allowRegex' or 'denyRegex', got %v", k))
+			}
+		}
+	default:
+		panic(fmt.Sprintf("Invalid argument '%v' for 'import-alias-naming' rule. Expecting string or map[string]string, got %T", arguments[0], arguments[0]))
 	}
 
-	var err error
-	r.namingRuleRegexp, err = regexp.Compile(namingRule)
-	if err != nil {
-		panic(fmt.Sprintf("Invalid argument to the import-alias-naming rule. Expecting %q to be a valid regular expression, got: %v", namingRule, err))
+	if r.allowRegexp == nil && r.denyRegexp == nil {
+		r.allowRegexp = defaultImportAliasNamingAllowRegexp
 	}
 }
 
@@ -60,10 +72,19 @@ func (r *ImportAliasNamingRule) Apply(file *lint.File, arguments lint.Arguments)
 			continue
 		}
 
-		if !r.namingRuleRegexp.MatchString(alias.Name) {
+		if r.allowRegexp != nil && !r.allowRegexp.MatchString(alias.Name) {
+			failures = append(failures, lint.Failure{
+				Confidence: 1,
+				Failure:    fmt.Sprintf("import name (%s) must match the regular expression: %s", alias.Name, r.allowRegexp.String()),
+				Node:       alias,
+				Category:   "imports",
+			})
+		}
+
+		if r.denyRegexp != nil && r.denyRegexp.MatchString(alias.Name) {
 			failures = append(failures, lint.Failure{
 				Confidence: 1,
-				Failure:    fmt.Sprintf("import name (%s) must match the regular expression: %s", alias.Name, r.namingRuleRegexp.String()),
+				Failure:    fmt.Sprintf("import name (%s) must NOT match the regular expression: %s", alias.Name, r.denyRegexp.String()),
 				Node:       alias,
 				Category:   "imports",
 			})
@@ -77,3 +98,29 @@ func (r *ImportAliasNamingRule) Apply(file *lint.File, arguments lint.Arguments)
 func (*ImportAliasNamingRule) Name() string {
 	return "import-alias-naming"
 }
+
+func (r *ImportAliasNamingRule) setAllowRule(value any) {
+	namingRule, ok := value.(string)
+	if !ok {
+		panic(fmt.Sprintf("Invalid argument '%v' for import-alias-naming allowRegexp rule. Expecting string, got %T", value, value))
+	}
+
+	namingRuleRegexp, err := regexp.Compile(namingRule)
+	if err != nil {
+		panic(fmt.Sprintf("Invalid argument to the import-alias-naming allowRegexp rule. Expecting %q to be a valid regular expression, got: %v", namingRule, err))
+	}
+	r.allowRegexp = namingRuleRegexp
+}
+
+func (r *ImportAliasNamingRule) setDenyRule(value any) {
+	namingRule, ok := value.(string)
+	if !ok {
+		panic(fmt.Sprintf("Invalid argument '%v' for import-alias-naming denyRegexp rule. Expecting string, got %T", value, value))
+	}
+
+	namingRuleRegexp, err := regexp.Compile(namingRule)
+	if err != nil {
+		panic(fmt.Sprintf("Invalid argument to the import-alias-naming denyRegexp rule. Expecting %q to be a valid regular expression, got: %v", namingRule, err))
+	}
+	r.denyRegexp = namingRuleRegexp
+}

test/import-alias-naming_test.go

@@ -9,7 +9,36 @@ import (
 
 func TestImportAliasNaming(t *testing.T) {
 	testRule(t, "import-alias-naming", &rule.ImportAliasNamingRule{})
+	testRule(t, "import-alias-naming", &rule.ImportAliasNamingRule{}, &lint.RuleConfig{
+		Arguments: lint.Arguments{
+			map[string]any{},
+		},
+	})
+}
+
+func TestImportAliasNaming_CustomConfig(t *testing.T) {
 	testRule(t, "import-alias-naming-custom-config", &rule.ImportAliasNamingRule{}, &lint.RuleConfig{
 		Arguments: []any{`^[a-z]+$`},
 	})
 }
+
+func TestImportAliasNaming_CustomConfigWithMultipleRules(t *testing.T) {
+	testRule(t, "import-alias-naming-custom-config-with-multiple-values", &rule.ImportAliasNamingRule{}, &lint.RuleConfig{
+		Arguments: []any{
+			map[string]any{
+				"allowRegex": `^[a-z][a-z0-9]*$`,
+				"denyRegex":  `^((v\d+)|(v\d+alpha\d+))$`,
+			},
+		},
+	})
+}
+
+func TestImportAliasNaming_CustomConfigWithOnlyDeny(t *testing.T) {
+	testRule(t, "import-alias-naming-custom-config-with-only-deny", &rule.ImportAliasNamingRule{}, &lint.RuleConfig{
+		Arguments: []any{
+			map[string]any{
+				"denyRegex": `^((v\d+)|(v\d+alpha\d+))$`,
+			},
+		},
+	})
+}

testdata/import-alias-naming-custom-config-with-multiple-values.go

@@ -0,0 +1,17 @@
+package fixtures
+
+import (
+	_ "strings"
+	bar_foo "strings"  // MATCH /import name (bar_foo) must match the regular expression: ^[a-z][a-z0-9]*$/
+	fooBAR "strings"   // MATCH /import name (fooBAR) must match the regular expression: ^[a-z][a-z0-9]*$/
+	v1 "strings"       // MATCH /import name (v1) must NOT match the regular expression: ^((v\d+)|(v\d+alpha\d+))$/
+	v1alpha1 "strings" // MATCH /import name (v1alpha1) must NOT match the regular expression: ^((v\d+)|(v\d+alpha\d+))$/
+	magical "magic/hat"
+)
+
+func somefunc() {
+	fooBAR.Clone("")
+	bar_foo.Clone("")
+	v1.Clone("")
+	magical.Clone("")
+}

testdata/import-alias-naming-custom-config-with-only-deny.go

@@ -0,0 +1,17 @@
+package fixtures
+
+import (
+	_ "strings"
+	bar_foo "strings"
+	fooBAR "strings"
+	v1 "strings"       // MATCH /import name (v1) must NOT match the regular expression: ^((v\d+)|(v\d+alpha\d+))$/
+	v1alpha1 "strings" // MATCH /import name (v1alpha1) must NOT match the regular expression: ^((v\d+)|(v\d+alpha\d+))$/
+	magical "magic/hat"
+)
+
+func somefunc() {
+	fooBAR.Clone("")
+	bar_foo.Clone("")
+	v1.Clone("")
+	magical.Clone("")
+}