go/revive
1
0
Fork 0
mirror of https://github.com/mgechev/revive.git synced 2025-06-02 22:57:22 +02:00
Code Issues Releases Activity

unused-param,unused-receiver: refactor configure func (#1157)

Browse Source
This commit is contained in:
Oleksandr Redko 2024-12-04 06:55:19 +02:00 committed by GitHub
parent 7f7d024f11
commit 09fb350a27
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
4 changed files with 47 additions and 32 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
rule/unused_param.go
View File

@ -9,6 +9,8 @@ import (
"github.com/mgechev/revive/lint"
)
var allowBlankIdentifierRegex = regexp.MustCompile("^_$")
// UnusedParamRule lints unused params in functions.
type UnusedParamRule struct {
// regex to check if some name is valid for unused parameter, "^_$" by default
@ -21,31 +23,30 @@ type UnusedParamRule struct {
func (r *UnusedParamRule) configure(args lint.Arguments) {
// while by default args is an array, i think it's good to provide structures inside it by default, not arrays or primitives
// it's more compatible to JSON nature of configurations
var allowRegexStr string
if len(args) == 0 {
allowRegexStr = "^_$"
r.allowRegex = allowBlankIdentifierRegex
r.failureMsg = "parameter '%s' seems to be unused, consider removing or renaming it as _"
} else {
if len(args) == 0 {
return
}
// Arguments = [{}]
options := args[0].(map[string]any)
// Arguments = [{allowRegex="^_"}]
if allowRegexParam, ok := options["allowRegex"]; ok {
allowRegexStr, ok = allowRegexParam.(string)
allowRegexParam, ok := options["allowRegex"]
if !ok {
return
}
// Arguments = [{allowRegex="^_"}]
allowRegexStr, ok := allowRegexParam.(string)
if !ok {
panic(fmt.Errorf("error configuring %s rule: allowRegex is not string but [%T]", r.Name(), allowRegexParam))
}
}
}
var err error
r.allowRegex, err = regexp.Compile(allowRegexStr)
if err != nil {
panic(fmt.Errorf("error configuring %s rule: allowRegex is not valid regex [%s]: %v", r.Name(), allowRegexStr, err))
}
if r.failureMsg == "" {
r.failureMsg = "parameter '%s' seems to be unused, consider removing or renaming it to match " + r.allowRegex.String()
}
}
// Apply applies the rule to given file.
func (r *UnusedParamRule) Apply(file *lint.File, args lint.Arguments) []lint.Failure {

21
rule/unused_receiver.go
View File

@ -21,31 +21,30 @@ type UnusedReceiverRule struct {
func (r *UnusedReceiverRule) configure(args lint.Arguments) {
// while by default args is an array, i think it's good to provide structures inside it by default, not arrays or primitives
// it's more compatible to JSON nature of configurations
var allowRegexStr string
if len(args) == 0 {
allowRegexStr = "^_$"
r.allowRegex = allowBlankIdentifierRegex
r.failureMsg = "method receiver '%s' is not referenced in method's body, consider removing or renaming it as _"
} else {
if len(args) == 0 {
return
}
// Arguments = [{}]
options := args[0].(map[string]any)
// Arguments = [{allowRegex="^_"}]
if allowRegexParam, ok := options["allowRegex"]; ok {
allowRegexStr, ok = allowRegexParam.(string)
allowRegexParam, ok := options["allowRegex"]
if !ok {
return
}
// Arguments = [{allowRegex="^_"}]
allowRegexStr, ok := allowRegexParam.(string)
if !ok {
panic(fmt.Errorf("error configuring [unused-receiver] rule: allowRegex is not string but [%T]", allowRegexParam))
}
}
}
var err error
r.allowRegex, err = regexp.Compile(allowRegexStr)
if err != nil {
panic(fmt.Errorf("error configuring [unused-receiver] rule: allowRegex is not valid regex [%s]: %v", allowRegexStr, err))
}
if r.failureMsg == "" {
r.failureMsg = "method receiver '%s' is not referenced in method's body, consider removing or renaming it to match " + r.allowRegex.String()
}
}
// Apply applies the rule to given file.
func (r *UnusedReceiverRule) Apply(file *lint.File, args lint.Arguments) []lint.Failure {

4
test/unused_param_test.go
View File

@ -9,6 +9,10 @@ import (
func TestUnusedParam(t *testing.T) {
testRule(t, "unused_param", &rule.UnusedParamRule{})
testRule(t, "unused_param", &rule.UnusedParamRule{}, &lint.RuleConfig{Arguments: []any{}})
testRule(t, "unused_param", &rule.UnusedParamRule{}, &lint.RuleConfig{Arguments: []any{
map[string]any{"a": "^xxx"},
}})
testRule(t, "unused_param_custom_regex", &rule.UnusedParamRule{}, &lint.RuleConfig{Arguments: []any{
map[string]any{"allowRegex": "^xxx"},
}})

11
test/unused_receiver_test.go
View File

@ -9,7 +9,18 @@ import (
func TestUnusedReceiver(t *testing.T) {
testRule(t, "unused_receiver", &rule.UnusedReceiverRule{})
testRule(t, "unused_receiver", &rule.UnusedReceiverRule{}, &lint.RuleConfig{Arguments: []any{}})
testRule(t, "unused_receiver", &rule.UnusedReceiverRule{}, &lint.RuleConfig{Arguments: []any{
map[string]any{"a": "^xxx"},
}})
testRule(t, "unused_receiver_custom_regex", &rule.UnusedReceiverRule{}, &lint.RuleConfig{Arguments: []any{
map[string]any{"allowRegex": "^xxx"},
}})
}
func BenchmarkUnusedReceiver(b *testing.B) {
var t *testing.T
for i := 0; i <= b.N; i++ {
testRule(t, "unused_receiver", &rule.UnusedReceiverRule{})
}
}