imporve var-naming - add upperCaseConst option to allow UPPER_CASED…

… constants #851 (#852)

* imporve `var-naming`  - add upperCaseConst  option to allow UPPER_CASED constants #851

Co-authored-by: chavacava <[email protected]>

RULES_DESCRIPTIONS.md

@@ -670,13 +670,17 @@ _Configuration_: N/A
 
 _Description_: This rule warns when [initialism](https:/golang/go/wiki/CodeReviewComments#initialisms), [variable](https:/golang/go/wiki/CodeReviewComments#variable-names) or [package](https:/golang/go/wiki/CodeReviewComments#package-names) naming conventions are not followed.
 
-_Configuration_: This rule accepts two slices of strings, a whitelist and a blacklist of initialisms. By default, the rule behaves exactly as the alternative in `golint` but optionally, you can relax it (see [golint/lint/issues/89](https:/golang/lint/issues/89))
+_Configuration_: This rule accepts two slices of strings and one optional slice with single map with named parameters.
+(it's due to TOML hasn't "slice of any" and we keep backward compatibility with previous config version)
+First slice is a whitelist and second one is a blacklist of initialisms. 
+In map, you can add "upperCaseConst=true" parameter to allow `UPPER_CASE` for `const` 
+By default, the rule behaves exactly as the alternative in `golint` but optionally, you can relax it (see [golint/lint/issues/89](https:/golang/lint/issues/89))
 
 Example:
 
 ```toml
 [rule.var-naming]
- arguments = [["ID"], ["VM"]]
+ arguments = [["ID"], ["VM"], [{upperCaseConst=true}]]
 ```
 
 ## var-declaration

rule/var-naming.go

@@ -13,11 +13,15 @@ import (
 
 var anyCapsRE = regexp.MustCompile(`[A-Z]`)
 
+// regexp for constant names like `SOME_CONST`, `SOME_CONST_2`, `X123_3` (#851)
+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
+ configured bool
+ whitelist []string
+ blacklist []string
+ upperCaseConst bool // if true - allows to use UPPER_SOME_NAMES for constants
  sync.Mutex
 }
 
@@ -31,6 +35,23 @@ func (r *VarNamingRule) configure(arguments lint.Arguments) {
  if len(arguments) >= 2 {
  r.blacklist = getList(arguments[1], "blacklist")
  }
+
+ if len(arguments) >= 3 {
+ // not pretty code because should keep compatibility with TOML (no mixed array types) and new map parameters
+ thirdArgument := arguments[2]
+ asSlice, ok := thirdArgument.([]interface{})
+ if !ok {
+ panic(fmt.Sprintf("Invalid third argument to the var-naming rule. Expecting a %s of type slice, got %T", "options", arguments[2]))
+ }
+ if len(asSlice) != 1 {
+ panic(fmt.Sprintf("Invalid third argument to the var-naming rule. Expecting a %s of type slice, of len==1, but %d", "options", len(asSlice)))
+ }
+ args, ok := asSlice[0].(map[string]interface{})
+ if !ok {
+ panic(fmt.Sprintf("Invalid third argument to the var-naming rule. Expecting a %s of type slice, of len==1, with map, but %T", "options", asSlice[0]))
+ }
+ r.upperCaseConst = fmt.Sprint(args["upperCaseConst"]) == "true"
+ }
  r.configured = true
  }
  r.Unlock()
@@ -52,6 +73,7 @@ func (r *VarNamingRule) Apply(file *lint.File, arguments lint.Arguments) []lint.
  onFailure: func(failure lint.Failure) {
  failures = append(failures, failure)
  },
+ upperCaseConst: r.upperCaseConst,
  }
 
  // Package names need slightly different handling than other names.
@@ -82,25 +104,31 @@ func (*VarNamingRule) Name() string {
  return "var-naming"
 }
 
-func checkList(fl *ast.FieldList, thing string, w *lintNames) {
+func (w *lintNames) checkList(fl *ast.FieldList, thing string) {
  if fl == nil {
  return
  }
  for _, f := range fl.List {
  for _, id := range f.Names {
- check(id, thing, w)
+ w.check(id, thing)
  }
  }
 }
 
-func check(id *ast.Ident, thing string, w *lintNames) {
+func (w *lintNames) check(id *ast.Ident, thing string) {
  if id.Name == "_" {
  return
  }
  if knownNameExceptions[id.Name] {
  return
  }
 
+ // #851 upperCaseConst support
+ // if it's const
+ if thing == token.CONST.String() && w.upperCaseConst && upperCaseConstRE.Match([]byte(id.Name)) {
+ return
+ }
+
  // Handle two common styles from other languages that don't belong in Go.
  if len(id.Name) >= 5 && allCapsRE.MatchString(id.Name) && strings.Contains(id.Name, "_") {
  w.onFailure(lint.Failure{
@@ -144,11 +172,12 @@ func check(id *ast.Ident, thing string, w *lintNames) {
 }
 
 type lintNames struct {
- file *lint.File
- fileAst *ast.File
- onFailure func(lint.Failure)
- whitelist []string
- blacklist []string
+ file *lint.File
+ fileAst *ast.File
+ onFailure func(lint.Failure)
+ whitelist []string
+ blacklist []string
+ upperCaseConst bool
 }
 
 func (w *lintNames) Visit(n ast.Node) ast.Visitor {
@@ -159,7 +188,7 @@ func (w *lintNames) Visit(n ast.Node) ast.Visitor {
  }
  for _, exp := range v.Lhs {
  if id, ok := exp.(*ast.Ident); ok {
- check(id, "var", w)
+ w.check(id, "var")
  }
  }
  case *ast.FuncDecl:
@@ -181,31 +210,24 @@ func (w *lintNames) Visit(n ast.Node) ast.Visitor {
  // not exported in the Go API.
  // See https:/golang/lint/issues/144.
  if ast.IsExported(v.Name.Name) || !isCgoExported(v) {
- check(v.Name, thing, w)
+ w.check(v.Name, thing)
  }
 
- checkList(v.Type.Params, thing+" parameter", w)
- checkList(v.Type.Results, thing+" result", w)
+ w.checkList(v.Type.Params, thing+" parameter")
+ w.checkList(v.Type.Results, thing+" result")
  case *ast.GenDecl:
  if v.Tok == token.IMPORT {
  return w
  }
- var thing string
- switch v.Tok {
- case token.CONST:
- thing = "const"
- case token.TYPE:
- thing = "type"
- case token.VAR:
- thing = "var"
- }
+
+ thing := v.Tok.String()
  for _, spec := range v.Specs {
  switch s := spec.(type) {
  case *ast.TypeSpec:
- check(s.Name, thing, w)
+ w.check(s.Name, thing)
  case *ast.ValueSpec:
  for _, id := range s.Names {
- check(id, thing, w)
+ w.check(id, thing)
  }
  }
  }
@@ -217,23 +239,23 @@ func (w *lintNames) Visit(n ast.Node) ast.Visitor {
  if !ok { // might be an embedded interface name
  continue
  }
- checkList(ft.Params, "interface method parameter", w)
- checkList(ft.Results, "interface method result", w)
+ w.checkList(ft.Params, "interface method parameter")
+ w.checkList(ft.Results, "interface method result")
  }
  case *ast.RangeStmt:
  if v.Tok == token.ASSIGN {
  return w
  }
  if id, ok := v.Key.(*ast.Ident); ok {
- check(id, "range var", w)
+ w.check(id, "range var")
  }
  if id, ok := v.Value.(*ast.Ident); ok {
- check(id, "range var", w)
+ w.check(id, "range var")
  }
  case *ast.StructType:
  for _, f := range v.Fields.List {
  for _, id := range f.Names {
- check(id, "struct field", w)
+ w.check(id, "struct field")
  }
  }
  }

test/var-naming_test.go

@@ -13,4 +13,9 @@ func TestVarNaming(t *testing.T) {
  })
 
  testRule(t, "var-naming_test", &rule.VarNamingRule{}, &lint.RuleConfig{})
+
+ testRule(t, "var-naming_upperCaseConst-false", &rule.VarNamingRule{}, &lint.RuleConfig{})
+ testRule(t, "var-naming_upperCaseConst-true", &rule.VarNamingRule{}, &lint.RuleConfig{
+ Arguments: []interface{}{[]interface{}{}, []interface{}{}, []interface{}{map[string]interface{}{"upperCaseConst": true}}},
+ })
 }

testdata/var-naming_upperCaseConst-false.go

@@ -0,0 +1,9 @@
+// should fail if upperCaseConst = false (by default) #851
+
+package fixtures
+
+const SOME_CONST_2 = 1 // MATCH /don't use ALL_CAPS in Go names; use CamelCase/
+
+const (
+ SOME_CONST_3 = 3 // MATCH /don't use ALL_CAPS in Go names; use CamelCase/
+)

testdata/var-naming_upperCaseConst-true.go

@@ -0,0 +1,10 @@
+// should pass if upperCaseConst = true
+
+package fixtures
+
+const SOME_CONST_2 = 2
+
+const (
+ SOME_CONST_3 = 3
+ VER = 0
+)