diff options
Diffstat (limited to '.golangci.yml')
| -rw-r--r-- | .golangci.yml | 804 |
1 files changed, 804 insertions, 0 deletions
diff --git a/.golangci.yml b/.golangci.yml new file mode 100644 index 0000000..b8b8f9d --- /dev/null +++ b/.golangci.yml @@ -0,0 +1,804 @@ +run: + tests: true # include test files or not, default is true + go: '1.22' + +linters: + enable: + - asciicheck # Simple linter to check that your code does not contain non-ASCII identifiers + - bodyclose # checks whether HTTP response body is closed successfully + - depguard # Go linter that checks if package imports are in a list of acceptable packages + - dupl # Tool for code clone detection + - errcheck # Errcheck is a program for checking for unchecked errors in go programs. These unchecked errors can be critical bugs in some cases + - errorlint # errorlint is a linter for that can be used to find code that will cause problems with the error wrapping scheme introduced in Go 1.13 + - exhaustive # check exhaustiveness of enum switch statements and map literals + - exportloopref # checks for pointers to enclosing loop variables + - gochecknoinits # Checks that no init functions are present in Go code + - gocognit # Computes and checks the cognitive complexity of functions + - goconst # Finds repeated strings that could be replaced by a constant + - gocritic # Provides diagnostics that check for bugs, performance and style issues + - gocyclo # Computes and checks the cyclomatic complexity of functions + - godot # Check if comments end in a period + - gofmt # Gofmt checks whether code was gofmt-ed. By default, this tool runs with -s option to check for code simplification + - goheader # Checks is file header matches to pattern + - goimports # In addition to fixing imports, goimports also formats your code in the same style as gofmt + - gomodguard # Allow and block list linter for direct Go module dependencies. This is different from depguard where there are different block types for example version constraints and module recommendations + - gosec # Inspects source code for security problems + - gosimple # Linter for Go source code that specializes in simplifying code + - govet # Vet examines Go source code and reports suspicious constructs, such as Printf calls whose arguments do not align with the format string + - ineffassign # Detects when assignments to existing variables are not used + - misspell # Finds commonly misspelled English words in comments + - nakedret # Finds naked returns in functions greater than a specified function length + - nestif # Reports deeply nested if statements + - noctx # noctx finds sending http request without context.Context + - nolintlint # Reports ill-formed or insufficient nolint directives + - paralleltest # paralleltest detects missing usage of t.Parallel() method in your Go test + - prealloc # Finds slice declarations that could potentially be pre-allocated + - revive # Fast, configurable, extensible, flexible, and beautiful linter for Go. Drop-in replacement of golint + - rowserrcheck # checks whether Err of rows is checked successfully + - sqlclosecheck # Checks that sql.Rows and sql.Stmt are closed + - staticcheck # It's a set of rules from staticcheck. It's not the same thing as the staticcheck binary. The author of staticcheck doesn't support or approve the use of staticcheck as a library inside golangci-lint + - stylecheck # Stylecheck is a replacement for golint + - tparallel # tparallel detects inappropriate usage of t.Parallel() method in your Go test codes + - typecheck # Like the front-end of a Go compiler, parses and type-checks Go code + - unconvert # Remove unnecessary type conversions + - unparam # Reports unused function parameters + - unused # Checks Go code for unused constants, variables, functions and types + - whitespace # Tool for detection of leading and trailing whitespace + - asasalint # check for pass []any as any in variadic func(...any) + - bidichk # Checks for dangerous unicode character sequences + - containedctx # containedctx is a linter that detects struct contained context.Context field + - cyclop # checks function and package cyclomatic complexity + - decorder # check declaration order and count of types, constants, variables and functions + - dogsled # Checks assignments with too many blank identifiers (e.g. x, _, _, _, := f()) + - dupword # checks for duplicate words in the source code + - durationcheck # check for two durations multiplied together + - errchkjson # Checks types passed to the json encoding functions. Reports unsupported types and optionally reports occasions, where the check for the returned error can be omitted. + - errname # Checks that sentinel errors are prefixed with the `Err` and error types are suffixed with the `Error` + - execinquery # execinquery is a linter about query string checker in Query function which reads your Go src files and warning it finds + - forbidigo # Forbids identifiers + - forcetypeassert # finds forced type assertions + - funlen # Tool for detection of long functions + - gomnd # An analyzer to detect magic numbers + - gomoddirectives # Manage the use of 'replace', 'retract', and 'excludes' directives in go.mod + - goprintffuncname # Checks that printf-like functions are named with `f` at the end + - grouper # An analyzer to analyze expression groups + - importas # Enforces consistent import aliases + - interfacebloat # A linter that checks the number of methods inside an interface + - lll # Reports long lines + - loggercheck # Checks key valur pairs for common logger libraries (kitlog,klog,logr,zap) + - maintidx # maintidx measures the maintainability index of each function + - makezero # Finds slice declarations with non-zero initial length + - nilerr # Finds the code that returns nil even if it checks that the error is not nil + - nilnil # Checks that there is no simultaneous return of `nil` error and an invalid value + - nlreturn # nlreturn checks for a new line before return and branch statements to increase code clarity + - nosprintfhostport # Checks for misuse of Sprintf to construct a host with port in a URL + - predeclared # find code that shadows one of Go's predeclared identifiers + - promlinter # Check Prometheus metrics naming via promlint + - reassign # Checks that package variables are not reassigned + - tagliatelle # Checks the struct tags + - tenv # tenv is analyzer that detects using os.Setenv instead of t.Setenv since Go1.17 + - testableexamples # linter checks if examples are testable (have an expected output) + - thelper # thelper detects golang test helpers without t.Helper() call and checks the consistency of test helpers + - usestdlibvars # A linter that detect the possibility to use variables/constants from the Go standard library + - varnamelen # checks that the length of a variable's name matches its scope + - wastedassign # wastedassign finds wasted assignment statements + - wsl # Whitespace Linter - Forces you to use empty lines + disable: + # [disabled] + # Use goimports instead. + - gci # Gci controls golang package import order and makes it always deterministic + # This is just a most stupid linter rule ever. + - testpackage # linter that makes you use a separate _test package + # Sometimes you really need globals. + - gochecknoglobals # check that no global variables exist + # This is stupid. + - exhaustruct # Checks if all structure fields are initialized. + # Sometimes you just have to return unwrapped error. + - wrapcheck # Checks that errors returned from external packages are wrapped. + # Not always and not everywhere. + - ireturn # Accept Interfaces, Return Concrete Types. + # They are useful to handle errors in deferred functions. + - nonamedreturns # Reports all named returns. + # Disabled because of lack of configuration. It makes a lot of unnecessary noise. + - goerr113 # Golang linter to check the errors handling expressions. + # Disabled because of the bug of reporting already sorted imports order. + - gofumpt # Gofumpt checks whether code was gofumpt-ed. + + # [deprecated] + - structcheck # Finds unused struct fields + - varcheck # Finds unused global variables and constants + - deadcode # Finds unused code + - exhaustivestruct # Checks if all struct's fields are initialized + - godox # Tool for detection of FIXME, TODO and other comment keywords + - golint # Golint differs from gofmt. Gofmt reformat Go source code, whereas golint prints out style mistakes + - ifshort # Checks that your code uses short syntax for if-statements whenever possible + - interfacer # Linter that suggests narrower interface types + - maligned # Tool to detect Go structs that would take less memory if their fields were sorted + - nosnakecase # nosnakecase is a linter that detects snake case of variable naming and function name + - scopelint # Scopelint checks for unpinned variables in go programs + +linters-settings: + depguard: + rules: + prevent_unmaintained_packages: + list-mode: lax # allow unless explicitely denied + files: + - $all + - "!$test" + allow: + - $gostd + deny: + - pkg: io/ioutil + desc: "replaced by io and os packages since Go 1.16: https://tip.golang.org/doc/go1.16#ioutil" + + paralleltest: + # Ignore missing calls to `t.Parallel()` and only report incorrect uses of it. + # Default: false + ignore-missing: true + + revive: + # Maximum number of open files at the same time. + # See https://github.com/mgechev/revive#command-line-flags + # Defaults to unlimited. + + # When set to false, ignores files with "GENERATED" header, similar to golint. + # See https://github.com/mgechev/revive#available-rules for details. + # Default: false + ignore-generated-header: true + # Sets the default severity. + # See https://github.com/mgechev/revive#configuration + # Default: warning + severity: warning + # Enable all available rules. + # Default: false + enable-all-rules: true + # Sets the default failure confidence. + # This means that linting errors with less than 0.8 confidence will be ignored. + # Default: 0.8 + confidence: 0.1 + rules: + # Suggests using constant for magic numbers and string literals. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#add-constant + # TODO: try rule later. Looks like it is broken in 1.50.0. Use gomnd instead + - name: add-constant + severity: warning + disabled: true + arguments: + - maxLitCount: '5' + allowStrs: '""' + allowInts: '0,1,2,3,4,5,6,7,8,9,10,24,30,31' + allowFloats: '0.0,0.,1.0,1.,2.0,2.' + + + # Warns when a function receives more parameters than the maximum set by the rule's configuration. + # Enforcing a maximum number of parameters helps to keep the code readable and maintainable. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#argument-limit + - name: argument-limit + severity: warning + disabled: false + arguments: [ 4 ] + + # Check for commonly mistaken usages of the sync/atomic package + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#atomic + - name: atomic + severity: warning + disabled: false + + # Warns on bare (a.k.a. naked) returns + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#banned-characters + - name: banned-characters + severity: warning + disabled: false + arguments: [ "Ω", "Σ", "σ", "7" ] + + # Checks given banned characters in identifiers(func, var, const). Comments are not checked. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#bare-return + - name: bare-return + severity: warning + disabled: false + + # Blank import should be only in a main or test package, or have a comment justifying it. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#blank-imports + - name: blank-imports + severity: warning + disabled: false + + # Using Boolean literals (true, false) in logic expressions may make the code less readable. + # This rule suggests removing Boolean literals from logic expressions. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#bool-literal-in-expr + - name: bool-literal-in-expr + severity: warning + disabled: false + + # Explicitly invoking the garbage collector is, except for specific uses in benchmarking, very dubious. + # The garbage collector can be configured through environment variables as described here: https://pkg.go.dev/runtime + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#call-to-gc + - name: call-to-gc + severity: warning + disabled: false + + # Description: Cognitive complexity is a measure of how hard code is to understand. + # While cyclomatic complexity is good to measure "testability" of the code, cognitive complexity + # aims to provide a more precise measure of the difficulty of understanding the code. + # Enforcing a maximum complexity per function helps to keep code readable and maintainable. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#cognitive-complexity + - name: cognitive-complexity + severity: warning + disabled: false + arguments: [ 30 ] + + # Methods or fields of struct that have names different only by capitalization could be confusing. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#confusing-naming + - name: confusing-naming + severity: warning + disabled: false + + # Function or methods that return multiple, no named, values of the same type could induce error. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#confusing-results + - name: confusing-results + severity: warning + disabled: false + + # The rule spots logical expressions that evaluate always to the same value. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#constant-logical-expr + - name: constant-logical-expr + severity: warning + disabled: false + + # By convention, context.Context should be the first parameter of a function. + # https://github.com/golang/go/wiki/CodeReviewComments#contexts + # This rule spots function declarations that do not follow the convention. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#context-as-argument + - name: context-as-argument + severity: warning + disabled: false + arguments: [ { allowTypesBefore = "*testing.T" } ] + + # Basic types should not be used as a key in context.WithValue. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#context-keys-type + - name: context-keys-type + severity: warning + disabled: false + + # Cyclomatic complexity is a measure of code complexity. + # Enforcing a maximum complexity per function helps to keep code readable and maintainable. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#cyclomatic + - name: cyclomatic + severity: warning + disabled: false + arguments: [ 15 ] + + # This rule spots potential dataraces caused by go-routines capturing (by-reference) particular + # identifiers of the function from which go-routines are created. + # The rule is able to spot two of such cases: go-routines capturing named return values, + # and capturing for-range values. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#datarace + - name: datarace + severity: warning + disabled: false + + # Packages exposing functions that can stop program execution by exiting are hard to reuse. + # This rule looks for program exits in functions other than main() or init(). + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#deep-exit + - name: deep-exit + severity: warning + disabled: false + + # This rule warns on some common mistakes when using defer statement. + # It currently alerts on the following situations: + # - [ call-chain ] - even if deferring call-chains of the form foo()() is valid, + # it does not help code understanding (only the last call is deferred) + # - [ loop ] - deferring inside loops can be misleading (deferred functions are not executed at the end + # of the loop iteration but of the current function) and it could lead to exhausting the execution stack + # - [ method-call ] - deferring a call to a method can lead to subtle bugs if the method does not have a pointer receiver + # - [ recover ] - calling recover outside a deferred function has no effect + # - [ immediate-recover ] - calling recover at the time a defer is registered, rather than as part of the deferred callback. + # e.g. defer recover() or equivalent. + # - [ return ] - returning values form a deferred function has no effect. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#defer + - name: defer + severity: warning + disabled: false + arguments: + - [ "call-chain", "loop", "method-call", "recover", "immediate-recover", "return" ] + + # Importing with . makes the programs much harder to understand because it is unclear + # whether names belong to the current package or to an imported package. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#dot-imports + - name: dot-imports + severity: warning + disabled: false + + # It is possible to unintentionally import the same package twice. + # This rule looks for packages that are imported two or more times. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#duplicated-imports + - name: duplicated-imports + severity: warning + disabled: false + + # In GO it is idiomatic to minimize nesting statements, a typical example is to avoid if-then-else constructions. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#early-return + - name: early-return + severity: warning + disabled: false + + # Empty blocks make code less readable and could be a symptom of a bug or unfinished refactoring. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#empty-block + - name: empty-block + severity: warning + disabled: false + + # Sometimes gofmt is not enough to enforce a common formatting of a code-base. + # This rule warns when there are heading or trailing newlines in code blocks. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#empty-lines + - name: empty-lines + severity: warning + disabled: false + + # By convention, for the sake of readability, variables of type error must be named with the prefix err. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#error-naming + - name: error-naming + severity: warning + disabled: false + + # By convention, for the sake of readability, the errors should be last in the list of returned values by a function. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#error-return + - name: error-return + severity: warning + disabled: false + + # By convention, for better readability, error messages should not be capitalized or end with punctuation or a newline. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#error-strings + - name: error-strings + severity: warning + disabled: false + + # It is possible to get a simpler program by replacing errors.New(fmt.Sprintf()) with fmt.Errorf(). + # This rule spots that kind of simplification opportunities. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#errorf + - name: errorf + severity: warning + disabled: false + + # Exported function and methods should have comments. + # This warns on undocumented exported functions and methods. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#exported + - name: exported + severity: warning + disabled: false + arguments: [ ] + + # This rule helps to enforce a common header for all source files in a project by spotting those files + # that do not have the specified header. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#file-header + - name: file-header + severity: warning + disabled: true + arguments: [ "" ] + + # If a function controls the flow of another by passing it information on what to do, both functions are said to be control-coupled. + # Coupling among functions must be minimized for better maintainability of the code. + # This rule warns on boolean parameters that create a control coupling. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#flag-parameter + - name: flag-parameter + severity: warning + disabled: false + + # Functions returning too many results can be hard to understand/use. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#function-result-limit + - name: function-result-limit + severity: warning + disabled: false + arguments: [ 2 ] + + # Functions too long (with many statements and/or lines) can be hard to understand. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#function-length + - name: function-length + severity: warning + disabled: false + # (int,int) the maximum allowed statements and lines. + # Must be non-negative integers. Set to 0 to disable the check + arguments: [ 30, 0 ] + + # Typically, functions with names prefixed with Get are supposed to return a value. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#get-return + - name: get-return + severity: warning + disabled: false + + # An if-then-else conditional with identical implementations in both branches is an error. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#identical-branches + - name: identical-branches + severity: warning + disabled: false + + # Checking if an error is nil to just after return the error or nil is redundant. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#if-return + - name: if-return + severity: warning + disabled: false + + # By convention, for better readability, incrementing an integer variable by 1 is recommended + # to be done using the ++ operator. + # This rule spots expressions like i += 1 and i -= 1 and proposes to change them into i++ and i--. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#increment-decrement + - name: increment-decrement + severity: warning + disabled: false + + # To improve the readability of code, it is recommended to reduce the indentation as much as possible. + # This rule highlights redundant else-blocks that can be eliminated from the code. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#indent-error-flow + - name: indent-error-flow + severity: warning + disabled: false + + # Warns when importing black-listed packages. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#imports-blacklist + - name: imports-blocklist + severity: warning + disabled: false + arguments: + - "crypto/md5" + - "crypto/sha1" + + # In GO it is possible to declare identifiers (packages, structs, interfaces, parameters, + # receivers, variables, constants...) that conflict with the name of an imported package. + # This rule spots identifiers that shadow an import. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#import-shadowing + - name: import-shadowing + severity: warning + disabled: false + + # Warns in the presence of code lines longer than a configured maximum. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#line-length-limit + - name: line-length-limit + severity: warning + disabled: false + arguments: [ 150 ] + + # Packages declaring too many public structs can be hard to understand/use, + # and could be a symptom of bad design. + # This rule warns on files declaring more than a configured, maximum number of public structs. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#max-public-structs + - name: max-public-structs + severity: warning + disabled: true + arguments: [ 3 ] + + # A function that modifies its parameters can be hard to understand. + # It can also be misleading if the arguments are passed by value by the caller. + # This rule warns when a function modifies one or more of its parameters. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#modifies-parameter + - name: modifies-parameter + severity: warning + disabled: false + + # A method that modifies its receiver value can have undesired behavior. + # The modification can be also the root of a bug because the actual value receiver could be a copy of that used at the calling site. + # This rule warns when a method modifies its receiver. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#modifies-value-receiver + - name: modifies-value-receiver + severity: warning + disabled: false + + # Packages declaring structs that contain other inline struct definitions can be hard to understand/read for other developers. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#nested-structs + - name: nested-structs + severity: warning + disabled: false + + # conditional expressions can be written to take advantage of short circuit evaluation and speed up + # its average evaluation time by forcing the evaluation of less time-consuming terms before more costly ones. + # This rule spots logical expressions where the order of evaluation of terms seems non-optimal. + # Please notice that confidence of this rule is low and is up to the user to decide if the suggested + # rewrite of the expression keeps the semantics of the original one. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#optimize-operands-order + - name: optimize-operands-order + severity: warning + disabled: false + + # Packages should have comments. This rule warns on undocumented packages and when packages comments are detached to the package keyword. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#package-comments + - name: package-comments + severity: warning + disabled: false + + # This rule suggests a shorter way of writing ranges that do not use the second value. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#range + - name: range + severity: warning + disabled: false + + # Range variables in a loop are reused at each iteration; therefore a goroutine created + # in a loop will point to the range variable with from the upper scope. + # This way, the goroutine could use the variable with an undesired value. + # This rule warns when a range value (or index) is used inside a closure. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#range-val-in-closure + - name: range-val-in-closure + severity: warning + disabled: false + + # Range variables in a loop are reused at each iteration. This rule warns when assigning the address of the variable, + # passing the address to append() or using it in a map. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#range-val-address + - name: range-val-address + severity: warning + disabled: false + + # By convention, receiver names in a method should reflect their identity. + # For example, if the receiver is of type Parts, p is an adequate name for it. + # Contrary to other languages, it is not idiomatic to name receivers as this or self. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#receiver-naming + - name: receiver-naming + severity: warning + disabled: false + + # Constant names like false, true, nil, function names like append, make, and basic type names like bool, + # and byte are not reserved words of the language; therefore the can be redefined. + # Even if possible, redefining these built in names can lead to bugs very difficult to detect. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#redefines-builtin-id + - name: redefines-builtin-id + severity: warning + disabled: false + + # explicit type conversion string(i) where i has an integer type other than + # rune might behave not as expected by the developer (e.g. string(42) is not "42"). + # This rule spot that kind of suspicious conversions. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#string-of-int + - name: string-of-int + severity: warning + disabled: false + + # This rule allows you to configure a list of regular expressions that string literals + # in certain function calls are checked against. This is geared towards user facing applications + # where string literals are often used for messages that will be presented to users, + # so it may be desirable to enforce consistent formatting. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#string-format + - name: string-format + severity: warning + disabled: true + arguments: [ ] + + # Struct tags are not checked at compile time. + # This rule, checks and warns if it finds errors in common struct tags types like: + # asn1, default, json, protobuf, xml, yaml. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#struct-tag + - name: struct-tag + severity: warning + disabled: false + + # To improve the readability of code, it is recommended to reduce the indentation as much as possible. + # This rule highlights redundant else-blocks that can be eliminated from the code. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#superfluous-else + - name: superfluous-else + severity: warning + disabled: false + + # This rule warns when using == and != for equality check time.Time and suggest to time.time.Equal method, + # for about information follow this link: https://pkg.go.dev/time#Time + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#time-equal + - name: time-equal + severity: warning + disabled: false + + # Using unit-specific suffix like "Secs", "Mins", ... when naming variables of type time.Duration + # can be misleading, this rule highlights those cases. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#time-naming + - name: time-naming + severity: warning + disabled: false + + # This rule warns when initialism, variable or package naming conventions are not followed. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#var-naming + - name: var-naming + severity: warning + disabled: false + arguments: + - [ ] # AllowList + - [ "ID", "VM" ] # DenyList + + # This rule proposes simplifications of variable declarations. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#var-declaration + - name: var-declaration + severity: warning + disabled: false + + # Unconditional recursive calls will produce infinite recursion, thus program stack overflow. + # This rule detects and warns about unconditional (direct) recursive calls. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#unconditional-recursion + - name: unconditional-recursion + severity: warning + disabled: false + + # This rule warns on wrongly named un-exported symbols, i.e. un-exported symbols whose name + # start with a capital letter. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#unexported-naming + - name: unexported-naming + severity: warning + disabled: false + + # This rule warns when an exported function or method returns a value of an un-exported type. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#unexported-return + - name: unexported-return + severity: warning + disabled: false + + # This rule warns when errors returned by a function are not explicitly handled on the caller side. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#unhandled-error + - name: unhandled-error + severity: warning + disabled: false + arguments: + - "fmt.Println" + - "fmt.Printf" + + # This rule suggests to remove redundant statements like a break at the end of a case block, + # for improving the code's readability. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#unnecessary-stmt + - name: unnecessary-stmt + severity: warning + disabled: false + + # This rule spots and proposes to remove unreachable code. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#unreachable-code + - name: unreachable-code + severity: warning + disabled: false + + # This rule warns on unused parameters. Functions or methods with unused parameters can be a symptom of an unfinished refactoring or a bug. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#unused-parameter + - name: unused-parameter + severity: warning + disabled: false + + # This rule warns on unused method receivers. + # Methods with unused receivers can be a symptom of an unfinished refactoring or a bug. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#unused-receiver + - name: unused-receiver + severity: warning + disabled: false + + # This rule warns on useless break statements in case clauses of switch and select statements. + # GO, unlike other programming languages like C, only executes statements of the selected case + # while ignoring the subsequent case clauses. + # Therefore, inserting a break at the end of a case clause has no effect. + # Because break statements are rarely used in case clauses, when switch or select statements + # are inside a for-loop, the programmer might wrongly assume that a break in a case clause will + # take the control out of the loop. The rule emits a specific warning for such cases. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#useless-break + - name: useless-break + severity: warning + disabled: false + + # Function parameters that are passed by value, are in fact a copy of the original argument. + # Passing a copy of a sync.WaitGroup is usually not what the developer wants to do. + # This rule warns when a sync.WaitGroup expected as a by-value parameter in a function or method. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#waitgroup-by-value + - name: waitgroup-by-value + severity: warning + disabled: false + + forbidigo: + # Forbid the following identifiers (list of regexp). + # Default: ["^(fmt\\.Print(|f|ln)|print|println)$"] + forbid: + # Optionally put comments at the end of the regex, surrounded by `(# )?` + # Escape any special characters. + - '^print.*$(# print statements should not be committed)' + # Exclude godoc examples from forbidigo checks. + # Default: true + exclude-godoc-examples: true + + cyclop: + # The maximal code complexity to report. + # Default: 10 + max-complexity: 15 + # The maximal average package complexity. + # If it's higher than 0.0 (float) the check is enabled + # Default: 0.0 + package-average: 6 + # Should ignore tests. + # Default: false + skip-tests: true + + funlen: + # Checks the number of lines in a function. + # If lower than 0, disable the check. + # Default: 60 + lines: 200 + # Checks the number of statements in a function. + # If lower than 0, disable the check. + # Default: 40 + statements: 50 + + tagliatelle: + # Check the struck tag name case. + case: + # Use the struct field name to check the name of the struct tag. + # Default: false + use-field-name: false + # `camel` is used for `json` and `yaml` (can be overridden) + # Default: {} + rules: + # Any struct tag type can be used. + # Support string case: `camel`, `pascal`, `kebab`, `snake`, `goCamel`, `goPascal`, `goKebab`, `goSnake`, `upper`, `lower` + json: snake + yaml: camel + xml: camel + bson: camel + avro: snake + mapstructure: kebab + + varnamelen: + # The longest distance, in source lines, that is being considered a "small scope". + # Variables used in at most this many lines will be ignored. + # Default: 5 + max-distance: 10 + # The minimum length of a variable's name that is considered "long". + # Variable names that are at least this long will be ignored. + # Default: 3 + min-name-length: 1 + # Check method receivers. + # Default: false + check-receiver: true + # Check named return values. + # Default: false + check-return: true + # Check type parameters. + # Default: false + check-type-param: true + # Ignore "ok" variables that hold the bool return value of a type assertion. + # Default: false + ignore-type-assert-ok: true + # Ignore "ok" variables that hold the bool return value of a map index. + # Default: false + ignore-map-index-ok: true + # Ignore "ok" variables that hold the bool return value of a channel receive. + # Default: false + ignore-chan-recv-ok: true + # Optional list of variable names that should be ignored completely. + # Default: [] + ignore-names: + - err + # Optional list of variable declarations that should be ignored completely. + # Entries must be in one of the following forms (see below for examples): + # - for variables, parameters, named return values, method receivers, or type parameters: + # <name> <type> (<type> can also be a pointer/slice/map/chan/...) + # - for constants: const <name> + # + # Default: [] + ignore-decls: + - t testing.T + - e error + - i int + - T any + + lll: + # Max line length, lines longer will be reported. + # '\t' is counted as 1 character by default, and can be changed with the tab-width option. + # Default: 120. + line-length: 150 + # Tab width in spaces. + # Default: 1 + tab-width: 1 + + nlreturn: + # Size of the block (including return statement that is still "OK") + # so no return split required. + # Default: 1 + block-size: 3 + + wsl: + # See https://github.com/bombsimon/wsl/blob/master/doc/configuration.md for + # documentation of available settings. These are the defaults for golangci-lint. + allow-assign-and-anything: false + allow-assign-and-call: true + allow-cuddle-declarations: false + allow-multiline-assign: true + allow-separated-leading-comment: false + allow-trailing-comment: false + force-case-trailing-whitespace: 0 + force-err-cuddling: false + force-short-decl-cuddling: false + strict-append: true
\ No newline at end of file |