refactor: rename blacklist to blocklist and whitelist to allowlist

config/config.go

@@ -56,6 +56,7 @@ var allRules = append([]lint.Rule{
  &rule.ConstantLogicalExprRule{},
  &rule.BoolLiteralRule{},
  &rule.ImportsBlacklistRule{},
+ &rule.ImportsBlocklistRule{},
  &rule.FunctionResultsLimitRule{},
  &rule.MaxPublicStructsRule{},
  &rule.RangeValInClosureRule{},

lint/utils.go

@@ -6,7 +6,7 @@ import (
 )
 
 // Name returns a different name if it should be different.
-func Name(name string, whitelist, blacklist []string) (should string) {
+func Name(name string, allowlist, blocklist []string) (should string) {
  // Fast path for simple cases: "_" and all lowercase.
  if name == "_" {
  return name
@@ -57,12 +57,12 @@ func Name(name string, whitelist, blacklist []string) (should string) {
  // [w,i) is a word.
  word := string(runes[w:i])
  ignoreInitWarnings := map[string]bool{}
- for _, i := range whitelist {
+ for _, i := range allowlist {
  ignoreInitWarnings[i] = true
  }
 
  extraInits := map[string]bool{}
- for _, i := range blacklist {
+ for _, i := range blocklist {
  extraInits[i] = true
  }
 

rule/add-constant.go

@@ -18,13 +18,13 @@ const (
  kindSTRING = "STRING"
 )
 
-type whiteList map[string]map[string]bool
+type allowList map[string]map[string]bool
 
-func newWhiteList() whiteList {
+func newAllowList() allowList {
  return map[string]map[string]bool{kindINT: {}, kindFLOAT: {}, kindSTRING: {}}
 }
 
-func (wl whiteList) add(kind, list string) {
+func (wl allowList) add(kind, list string) {
  elems := strings.Split(list, ",")
  for _, e := range elems {
  wl[kind][e] = true
@@ -33,7 +33,7 @@ func (wl whiteList) add(kind, list string) {
 
 // AddConstantRule lints unused params in functions.
 type AddConstantRule struct {
- whiteList whiteList
+ allowList allowList
  ignoreFunctions []*regexp.Regexp
  strLitLimit int
  sync.Mutex
@@ -53,7 +53,7 @@ func (r *AddConstantRule) Apply(file *lint.File, arguments lint.Arguments) []lin
  onFailure: onFailure,
  strLits: make(map[string]int),
  strLitLimit: r.strLitLimit,
- whiteLst: r.whiteList,
+ allowList: r.allowList,
  ignoreFunctions: r.ignoreFunctions,
  structTags: make(map[*ast.BasicLit]struct{}),
  }
@@ -72,7 +72,7 @@ type lintAddConstantRule struct {
  onFailure func(lint.Failure)
  strLits map[string]int
  strLitLimit int
- whiteLst whiteList
+ allowList allowList
  ignoreFunctions []*regexp.Regexp
  structTags map[*ast.BasicLit]struct{}
 }
@@ -155,7 +155,7 @@ func (w *lintAddConstantRule) isIgnoredFunc(fName string) bool {
 }
 
 func (w *lintAddConstantRule) checkStrLit(n *ast.BasicLit) {
- if w.whiteLst[kindSTRING][n.Value] {
+ if w.allowList[kindSTRING][n.Value] {
  return
  }
 
@@ -175,7 +175,7 @@ func (w *lintAddConstantRule) checkStrLit(n *ast.BasicLit) {
 }
 
 func (w *lintAddConstantRule) checkNumLit(kind string, n *ast.BasicLit) {
- if w.whiteLst[kind][n.Value] {
+ if w.allowList[kind][n.Value] {
  return
  }
 
@@ -196,9 +196,9 @@ func (r *AddConstantRule) configure(arguments lint.Arguments) {
  r.Lock()
  defer r.Unlock()
 
- if r.whiteList == nil {
+ if r.allowList == nil {
  r.strLitLimit = defaultStrLitLimit
- r.whiteList = newWhiteList()
+ r.allowList = newAllowList()
  if len(arguments) > 0 {
  args, ok := arguments[0].(map[string]any)
  if !ok {
@@ -223,7 +223,7 @@ func (r *AddConstantRule) configure(arguments lint.Arguments) {
  if !ok {
  panic(fmt.Sprintf("Invalid argument to the add-constant rule, string expected. Got '%v' (%T)", v, v))
  }
- r.whiteList.add(kind, list)
+ r.allowList.add(kind, list)
  case "maxLitCount":
  sl, ok := v.(string)
  if !ok {

rule/confusing-naming.go

@@ -111,7 +111,7 @@ func checkMethodName(holder string, id *ast.Ident, w *lintConfusingNames) {
  pkgm.methods[holder] = make(map[string]*referenceMethod, 1)
  }
 
- // update the black list
+ // update the block list
  if pkgm.methods[holder] == nil {
  println("no entry for '", holder, "'")
  }

rule/imports-blocklist.go

@@ -0,0 +1,73 @@
+package rule
+
+import (
+ "fmt"
+ "regexp"
+ "sync"
+
+ "github.com/mgechev/revive/lint"
+)
+
+// ImportsBlocklistRule lints given else constructs.
+type ImportsBlocklistRule struct {
+ blocklist []*regexp.Regexp
+ sync.Mutex
+}
+
+var replaceImportRegexp = regexp.MustCompile(`/?\*\*/?`)
+
+func (r *ImportsBlocklistRule) configure(arguments lint.Arguments) {
+ r.Lock()
+ defer r.Unlock()
+
+ if r.blocklist == nil {
+ r.blocklist = make([]*regexp.Regexp, 0)
+
+ for _, arg := range arguments {
+ argStr, ok := arg.(string)
+ if !ok {
+ panic(fmt.Sprintf("Invalid argument to the imports-blocklist rule. Expecting a string, got %T", arg))
+ }
+ regStr, err := regexp.Compile(fmt.Sprintf(`(?m)"%s"$`, replaceImportRegexp.ReplaceAllString(argStr, `(\W|\w)*`)))
+ if err != nil {
+ panic(fmt.Sprintf("Invalid argument to the imports-blocklist rule. Expecting %q to be a valid regular expression, got: %v", argStr, err))
+ }
+ r.blocklist = append(r.blocklist, regStr)
+ }
+ }
+}
+
+func (r *ImportsBlocklistRule) isBlocklisted(path string) bool {
+ for _, regex := range r.blocklist {
+ if regex.MatchString(path) {
+ return true
+ }
+ }
+ return false
+}
+
+// Apply applies the rule to given file.
+func (r *ImportsBlocklistRule) Apply(file *lint.File, arguments lint.Arguments) []lint.Failure {
+ r.configure(arguments)
+
+ var failures []lint.Failure
+
+ for _, is := range file.AST.Imports {
+ path := is.Path
+ if path != nil && r.isBlocklisted(path.Value) {
+ failures = append(failures, lint.Failure{
+ Confidence: 1,
+ Failure: "should not use the following blocklisted import: " + path.Value,
+ Node: is,
+ Category: "imports",
+ })
+ }
+ }
+
+ return failures
+}
+
+// Name returns the rule name.
+func (*ImportsBlocklistRule) Name() string {
+ return "imports-blocklist"
+}

rule/var-naming.go

@@ -19,8 +19,8 @@ var upperCaseConstRE = regexp.MustCompile(`^_?[A-Z][A-Z\d]*(_[A-Z\d]+)*$`)
 // VarNamingRule lints given else constructs.
 type VarNamingRule struct {
  configured bool
- whitelist []string
- blacklist []string
+ allowlist []string
+ blocklist []string
  upperCaseConst bool // if true - allows to use UPPER_SOME_NAMES for constants
  skipPackageNameChecks bool
  sync.Mutex
@@ -35,11 +35,11 @@ func (r *VarNamingRule) configure(arguments lint.Arguments) {
 
  r.configured = true
  if len(arguments) >= 1 {
- r.whitelist = getList(arguments[0], "whitelist")
+ r.allowlist = getList(arguments[0], "whitelist")
  }
 
  if len(arguments) >= 2 {
- r.blacklist = getList(arguments[1], "blacklist")
+ r.blocklist = getList(arguments[1], "blacklist")
  }
 
  if len(arguments) >= 3 {
@@ -93,8 +93,8 @@ func (r *VarNamingRule) Apply(file *lint.File, arguments lint.Arguments) []lint.
  walker := lintNames{
  file: file,
  fileAst: fileAst,
- whitelist: r.whitelist,
- blacklist: r.blacklist,
+ allowlist: r.allowlist,
+ blocklist: r.blocklist,
  onFailure: func(failure lint.Failure) {
  failures = append(failures, failure)
  },
@@ -151,7 +151,7 @@ func (w *lintNames) check(id *ast.Ident, thing string) {
  return
  }
 
- should := lint.Name(id.Name, w.whitelist, w.blacklist)
+ should := lint.Name(id.Name, w.allowlist, w.blocklist)
  if id.Name == should {
  return
  }
@@ -177,8 +177,8 @@ type lintNames struct {
  file *lint.File
  fileAst *ast.File
  onFailure func(lint.Failure)
- whitelist []string
- blacklist []string
+ allowlist []string
+ blocklist []string
  upperCaseConst bool
 }
 

test/import-blocklist_test.go

@@ -0,0 +1,34 @@
+package test
+
+import (
+ "testing"
+
+ "github.com/mgechev/revive/lint"
+ "github.com/mgechev/revive/rule"
+)
+
+func TestImportsBlocklistOriginal(t *testing.T) {
+ args := []any{"crypto/md5", "crypto/sha1"}
+
+ testRule(t, "imports-blocklist-original", &rule.ImportsBlocklistRule{}, &lint.RuleConfig{
+ Arguments: args,
+ })
+}
+
+func TestImportsBlocklist(t *testing.T) {
+ args := []any{"github.com/full/match", "wildcard/**/between", "wildcard/backward/**", "**/wildcard/forward", "full"}
+
+ testRule(t, "imports-blocklist", &rule.ImportsBlocklistRule{}, &lint.RuleConfig{
+ Arguments: args,
+ })
+}
+
+func BenchmarkImportsBlocklist(b *testing.B) {
+ args := []any{"github.com/full/match", "wildcard/**/between", "wildcard/backward/**", "**/wildcard/forward", "full"}
+ var t *testing.T
+ for i := 0; i <= b.N; i++ {
+ testRule(t, "imports-blocklist", &rule.ImportsBlocklistRule{}, &lint.RuleConfig{
+ Arguments: args,
+ })
+ }
+}

testdata/imports-blocklist-original.go

@@ -0,0 +1,8 @@
+package fixtures
+
+import (
+ "crypto/md5" // MATCH /should not use the following blocklisted import: "crypto/md5"/
+ "crypto/sha1" // MATCH /should not use the following blocklisted import: "crypto/sha1"/
+ "strings"
+)
+

testdata/imports-blocklist.go

@@ -0,0 +1,19 @@
+package fixtures
+
+import (
+ "github.com/full/match" // MATCH /should not use the following blocklisted import: "github.com/full/match"/
+ "bithub.com/full/match"
+ "github.com/full/matche"
+ "wildcard/between" // MATCH /should not use the following blocklisted import: "wildcard/between"/
+ "wildcard/pkg1/between" // MATCH /should not use the following blocklisted import: "wildcard/pkg1/between"/
+ "wildcard/pkg1/pkg2/between" // MATCH /should not use the following blocklisted import: "wildcard/pkg1/pkg2/between"/
+ "wildcard/backward" // MATCH /should not use the following blocklisted import: "wildcard/backward"/
+ "wildcard/backward/pkg" // MATCH /should not use the following blocklisted import: "wildcard/backward/pkg"/
+ "wildcard/backward/pkg/pkg1" // MATCH /should not use the following blocklisted import: "wildcard/backward/pkg/pkg1"/
+ "wildcard/forward" // MATCH /should not use the following blocklisted import: "wildcard/forward"/
+ "pkg/wildcard/forward" // MATCH /should not use the following blocklisted import: "pkg/wildcard/forward"/
+ "pkg/pkg1/wildcard/forward" // MATCH /should not use the following blocklisted import: "pkg/pkg1/wildcard/forward"/
+ "full" // MATCH /should not use the following blocklisted import: "full"/
+ "github.com/partical/match/fully"
+ "strings"
+)