header: add ability to provide regexps for variables (#6)

Author: joshuasing

README.md

@@ -80,6 +80,8 @@ Flags:
         display offending line with this many lines of context (default -1)
   -comment-style string
         Comment style (line, block) (default "line")
+  -copyright-header-matcher string
+        Copyright header matcher regexp (used to detect existence of any copyright header) (default "(?i)copyright")
   -cpuprofile string
         write CPU profile to this file
   -debug string
@@ -94,14 +96,12 @@ Flags:
         print analyzer flags in JSON
   -json
         emit JSON output
-  -match-header-regexp string
-        Match header regexp (used to detect any copyright headers) (default "(?i)copyright")
-  -match-tmpl string
-        Match license header template
-  -match-tmpl-file string
-        Match license header template file (used to detect existing license headers which may be updated)
-  -match-tmpl-regexp
-        Whether the provided match template is a regexp expression
+  -matcher string
+        License header matcher (This is template, when executed it must become valid regexp)
+  -matcher-escape
+        Whether to regexp-escape the matcher
+  -matcher-file string
+        License header matcher file)
   -max-concurrent int
         Maximum concurrent processes to use when processing files (default 32)
   -memprofile string
@@ -121,6 +121,8 @@ Flags:
   -v    no effect (deprecated)
   -var string
         Template variables (e.g. a=Hello,b=Test)
+  -var-regexp string
+        Template variable regexps (e.g. 'a=(Hello|World),b=(?i)test'
   -year-mode string
         Year formatting mode (preserve, preserve-this-year-range, preserve-modified-range, this-year, last-modified, git-range, git-modified-years) (default "preserve")
 ```

cmd/golicenser/golicenser.go

@@ -44,6 +44,7 @@ var (
 	author                 string
 	authorRegexp           string
 	variables              string
+	variableRegexps        string
 	yearModeStr            string
 	commentStyleStr        string
 	exclude                string
@@ -65,6 +66,8 @@ func init() {
 	flagSet.StringVar(&authorRegexp, "author-regexp", "",
 		"Regexp to match copyright author (default: match author)")
 	flagSet.StringVar(&variables, "var", "", "Template variables (e.g. a=Hello,b=Test)")
+	flagSet.StringVar(&variableRegexps, "var-regexp", "",
+		"Template variable regexps (e.g. 'a=(Hello|World),b=(?i)test'")
 	flagSet.StringVar(&yearModeStr, "year-mode", golicenser.YearMode(0).String(),
 		"Year formatting mode (preserve, preserve-this-year-range, preserve-modified-range, this-year, last-modified, git-range, git-modified-years)")
 	flagSet.StringVar(&commentStyleStr, "comment-style", golicenser.CommentStyle(0).String(),
@@ -101,7 +104,7 @@ var analyzer = &analysis.Analyzer{
 			//nolint:gosec // Reading user-defined file.
 			b, err := os.ReadFile(matcherFile)
 			if err != nil {
-				log.Fatal("read match template file: ", err)
+				log.Fatal("read matcher file: ", err)
 			}
 			matcher = string(b)
 		} else {
@@ -111,14 +114,27 @@ var analyzer = &analysis.Analyzer{
 		}
 
 		// Parse variables
-		vars := make(map[string]any)
+		vars := make(map[string]golicenser.Var)
 		if variables != "" {
 			for _, v := range strings.Split(variables, ",") {
 				parts := strings.SplitN(v, "=", 2)
 				if len(parts) != 2 {
 					log.Fatal("invalid variable: ", v)
 				}
-				vars[parts[0]] = parts[1]
+				vars[parts[0]] = golicenser.Var{Value: parts[1]}
+			}
+		}
+		if variableRegexps != "" {
+			for _, v := range strings.Split(variableRegexps, ",") {
+				parts := strings.SplitN(v, "=", 2)
+				if len(parts) != 2 {
+					log.Fatal("invalid variable: ", v)
+				}
+				va, ok := vars[parts[0]]
+				if !ok {
+					log.Fatal("regexp for non-existent variable: ", v)
+				}
+				va.Regexp = parts[1]
 			}
 		}
 

header.go

@@ -24,7 +24,6 @@ import (
 	"bytes"
 	"fmt"
 	"io"
-	"maps"
 	"path/filepath"
 	"regexp"
 	"strings"
@@ -221,7 +220,7 @@ type Header struct {
 	matcher *regexp.Regexp
 
 	author       string
-	variables    map[string]any
+	variables    map[string]Var
 	yearMode     YearMode
 	commentStyle CommentStyle
 }
@@ -230,14 +229,24 @@ var tmplFuncMap = template.FuncMap{
 	"basename": filepath.Base,
 }
 
+// Var is a template variable.
+type Var struct {
+	// Value is the variable value.
+	Value string
+
+	// Regexp is a regexp used to match the variable value.
+	// If empty, the regexp-escaped value of Value will be used.
+	Regexp string
+}
+
 // HeaderOpts are the options for creating a license header.
 type HeaderOpts struct {
 	Template      string
 	Matcher       string
 	MatcherEscape bool
 	Author        string
 	AuthorRegexp  string
-	Variables     map[string]any
+	Variables     map[string]Var
 	YearMode      YearMode
 	CommentStyle  CommentStyle
 }
@@ -264,11 +273,23 @@ func NewHeader(opts HeaderOpts) (*Header, error) {
 		"filename": "test",
 		"year":     "2025",
 	}
-	maps.Copy(m, opts.Variables)
+	addVariables(m, opts.Variables)
 	if err = t.Execute(io.Discard, m); err != nil {
 		return nil, fmt.Errorf("execute template: %w", err)
 	}
 
+	// Test compiling variable regexps.
+	for name, v := range opts.Variables {
+		switch v.Regexp {
+		case "":
+			v.Regexp = regexp.QuoteMeta(v.Value)
+		default:
+			if _, err = regexp.Compile(v.Regexp); err != nil {
+				return nil, fmt.Errorf("compile %q regexp: %w", name, err)
+			}
+		}
+	}
+
 	// Create author regexp
 	authorRegexpStr := opts.AuthorRegexp
 	if authorRegexpStr == "" {
@@ -284,15 +305,15 @@ func NewHeader(opts HeaderOpts) (*Header, error) {
 		mt, err := template.New("").Funcs(tmplFuncMap).
 			Option("missingkey=error").Parse(opts.Matcher)
 		if err != nil {
-			return nil, fmt.Errorf("new match template: %w", err)
+			return nil, fmt.Errorf("new matcher template: %w", err)
 		}
 		matcher, err = headerMatcher(mt, opts.MatcherEscape, authorRegexp, opts.Variables)
 		if err != nil {
-			return nil, fmt.Errorf("create header matcher (with match template): %w", err)
+			return nil, fmt.Errorf("create header matcher: %w", err)
 		}
 	} else {
-		// If a match template wasn't provided, create a matcher using the
-		// header template (regexp-escaped).
+		// If a matcher wasn't provided, create a matcher using the header
+		// template (regexp-escaped).
 		matcher, err = headerMatcher(t, true, authorRegexp, opts.Variables)
 		if err != nil {
 			return nil, fmt.Errorf("create header matcher: %w", err)
@@ -399,7 +420,7 @@ func (h *Header) render(filename, year string) (string, error) {
 		"filename": filename,
 		"year":     year,
 	}
-	maps.Copy(m, h.variables)
+	addVariables(m, h.variables)
 
 	var b bytes.Buffer
 	if err := h.tmpl.Execute(&b, m); err != nil {
@@ -408,32 +429,47 @@ func (h *Header) render(filename, year string) (string, error) {
 	return b.String(), nil
 }
 
-func headerMatcher(tmpl *template.Template, escapeTmpl bool, authorRegexp *regexp.Regexp, variables map[string]any) (*regexp.Regexp, error) {
-	m := map[string]any{
-		"author":   "__AUTHOR__",
-		"filename": "__FILENAME__",
-		"year":     "__YEAR__",
+func headerMatcher(tmpl *template.Template, escapeTmpl bool, authorRegexp *regexp.Regexp, variables map[string]Var) (*regexp.Regexp, error) {
+	m := map[string]string{
+		"author":   "__VAR_author__",
+		"filename": "__VAR_filename__",
+		"year":     "__VAR_year__",
+	}
+	regexps := map[string]string{
+		"author":   authorRegexp.String(),
+		"filename": "(?P<filename>.+)",
+		"year":     regexpYears.String(),
+	}
+	for k, v := range variables {
+		m[k] = "__VAR_" + k + "__"
+		regexps[k] = v.Regexp
 	}
-	maps.Copy(m, variables)
 
 	// Execute matcher template.
 	var b bytes.Buffer
 	if err := tmpl.Execute(&b, m); err != nil {
 		return nil, fmt.Errorf("execute template: %w", err)
 	}
 	headerExpr := b.String()
+
+	// Optionally escape the rendered template.
 	if escapeTmpl {
 		headerExpr = regexp.QuoteMeta(b.String())
 	}
 
-	// Insert regexp matchers here, as there is a chance we escape the
-	// headerExpr above.
-	expr := strings.NewReplacer(
-		"__AUTHOR__", authorRegexp.String(),
-		"__FILENAME__", "(?P<filename>.+)",
-		"__YEAR__", regexpYears.String(),
-	).Replace(headerExpr)
+	// Replace variable placeholders with regexp expressions.
+	replacements := make([]string, 0, len(m)*2)
+	for k, v := range m {
+		replacements = append(replacements, v, regexps[k])
+	}
+	headerExpr = strings.NewReplacer(replacements...).Replace(headerExpr)
+
+	// Compile header matcher regexp.
+	return regexp.Compile(headerExpr)
+}
 
-	// Compile header matching regexp.
-	return regexp.Compile(expr)
+func addVariables(m map[string]any, vars map[string]Var) {
+	for k, v := range vars {
+		m[k] = v.Value
+	}
 }