Support custom forbid reason messages

In order to allow users to communicate intent to collaborators,
optionally embed custom messages into each forbidden pattern.

The syntax is as follows: `#[message goes here]identifier`

Example: `#[Please don't use this!]fmt\.Errorf`

The message section is optional, so this change should be backwards
compatible with all valid identifiers.

Author: craigfurman

forbidigo/forbidigo.go

@@ -24,6 +24,7 @@ type UsedIssue struct {
 	identifier string
 	pattern    string
 	position   token.Position
+	customMsg  string
 }
 
 func (a UsedIssue) Details() string {
@@ -36,13 +37,17 @@ func (a UsedIssue) Position() token.Position {
 
 func (a UsedIssue) String() string { return toString(a) }
 
-func toString(i Issue) string {
-	return fmt.Sprintf("%s at %s", i.Details(), i.Position())
+func toString(i UsedIssue) string {
+	s := fmt.Sprintf("%s at %s", i.Details(), i.Position())
+	if i.customMsg != "" {
+		s += ": " + i.customMsg
+	}
+	return s
 }
 
 type Linter struct {
 	cfg      config
-	patterns []*regexp.Regexp
+	patterns []*pattern
 }
 
 func DefaultPatterns() []string {
@@ -65,13 +70,13 @@ func NewLinter(patterns []string, options ...Option) (*Linter, error) {
 	if len(patterns) == 0 {
 		patterns = DefaultPatterns()
 	}
-	compiledPatterns := make([]*regexp.Regexp, 0, len(patterns))
-	for _, p := range patterns {
-		re, err := regexp.Compile(p)
+	compiledPatterns := make([]*pattern, 0, len(patterns))
+	for _, ptrn := range patterns {
+		p, err := parse(ptrn)
 		if err != nil {
-			return nil, fmt.Errorf("unable to compile pattern `%s`: %s", p, err)
+			return nil, err
 		}
-		compiledPatterns = append(compiledPatterns, re)
+		compiledPatterns = append(compiledPatterns, p)
 	}
 	return &Linter{
 		cfg:      cfg,
@@ -158,11 +163,12 @@ func (v *visitor) Visit(node ast.Node) ast.Visitor {
 		return v
 	}
 	for _, p := range v.linter.patterns {
-		if p.MatchString(v.textFor(node)) && !v.permit(node) {
+		if p.pattern.MatchString(v.textFor(node)) && !v.permit(node) {
 			v.issues = append(v.issues, UsedIssue{
 				identifier: v.textFor(node),
-				pattern:    p.String(),
+				pattern:    p.pattern.String(),
 				position:   v.fset.Position(node.Pos()),
+				customMsg:  p.msg,
 			})
 		}
 	}

forbidigo/forbidigo_test.go

@@ -19,6 +19,16 @@ func foo() {
 }`, "use of `fmt.Printf` forbidden by pattern `fmt\\.Printf` at testing.go:5:2")
 	})
 
+	t.Run("displays custom messages", func(t *testing.T) {
+		linter, _ := NewLinter([]string{`#[Please don't use this!]fmt\.Printf`})
+		expectIssues(t, linter, `
+package bar
+
+func foo() {
+	fmt.Printf("here i am")
+}`, "use of `fmt.Printf` forbidden by pattern `fmt\\.Printf` at testing.go:5:2: Please don't use this!")
+	})
+
 	t.Run("it doesn't require a package on the identifier", func(t *testing.T) {
 		linter, _ := NewLinter([]string{`Printf`})
 		expectIssues(t, linter, `

forbidigo/patterns.go

@@ -0,0 +1,31 @@
+package forbidigo
+
+import (
+	"fmt"
+	"regexp"
+)
+
+var ptrnWithMsg = regexp.MustCompile(`(#\[(?P<msg>[^\]]+)\])?(?P<pattern>.+)`)
+
+type pattern struct {
+	pattern *regexp.Regexp
+	msg     string
+}
+
+func parse(ptrn string) (*pattern, error) {
+	p := &pattern{}
+	matches := ptrnWithMsg.FindStringSubmatch(ptrn)
+	for i, name := range ptrnWithMsg.SubexpNames() {
+		if name == "msg" {
+			p.msg = matches[i]
+		} else if name == "pattern" {
+			re, err := regexp.Compile(matches[i])
+			if err != nil {
+				return nil, fmt.Errorf("unable to compile pattern `%s`: %s", matches[i], err)
+			}
+			p.pattern = re
+		}
+	}
+
+	return p, nil
+}

forbidigo/patterns_test.go

@@ -0,0 +1,32 @@
+package forbidigo
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestParseValidPattern(t *testing.T) {
+	ptrn, err := parse(`fmt\.Errorf`)
+	require.Nil(t, err)
+	assert.Equal(t, `fmt\.Errorf`, ptrn.pattern.String())
+}
+
+func TestParseValidPatternThatUsesSquareBrackets(t *testing.T) {
+	ptrn, err := parse(`[f]mt\.Errorf`)
+	require.Nil(t, err)
+	assert.Equal(t, `[f]mt\.Errorf`, ptrn.pattern.String())
+}
+
+func TestParseValidPatternWithCustomMessage(t *testing.T) {
+	ptrn, err := parse(`#[Please don't use this!]fmt\.Println`)
+	require.Nil(t, err)
+	assert.Equal(t, `fmt\.Println`, ptrn.pattern.String())
+	assert.Equal(t, "Please don't use this!", ptrn.msg)
+}
+
+func TestParseInvalidPattern_ReturnsError(t *testing.T) {
+	_, err := parse(`fmt\`)
+	assert.NotNil(t, err)
+}