support ignoring file or directories

use the doublestar library to support pattern matching of files or
directories to ignore. This replaces (and deprecates) the previous
-skip flag which only supported file extensions.

.github/workflows/tests.yaml

@@ -5,7 +5,7 @@ jobs:
  test:
  strategy:
  matrix:
- go-version: [1.x, 1.15.x]
+ go-version: [1.x, 1.16.x]
  platform: [ubuntu-latest]
  include:
  # only update test coverage stats with the most recent go version on linux

README.md

@@ -19,10 +19,14 @@ to any file that already has one.
  -l license type: apache, bsd, mit, mpl (defaults to "apache")
  -y year (defaults to current year)
  -check check only mode: verify presence of license headers and exit with non-zero code if missing
+ -ignore file patterns to ignore, for example: -ignore **/*.go -ignore vendor/**
 
 The pattern argument can be provided multiple times, and may also refer
 to single files.
 
+The `-ignore` flag can use any pattern [supported by
+doublestar](https://github.com/bmatcuk/doublestar#patterns).
+
 ## Running in a Docker Container
 
 - Clone the repository using `git clone https://github.com/google/addlicense.git`

go.mod

@@ -2,4 +2,7 @@ module github.com/google/addlicense
 
 go 1.13
 
-require golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e
+require (
+ github.com/bmatcuk/doublestar/v4 v4.0.2 // indirect
+ golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e
+)

go.sum

@@ -1,2 +1,4 @@
+github.com/bmatcuk/doublestar/v4 v4.0.2 h1:X0krlUVAVmtr2cRoTqR8aDMrDqnB36ht8wpWTiQ3jsA=
+github.com/bmatcuk/doublestar/v4 v4.0.2/go.mod h1:xBQ8jztBU6kakFMg+8WGxn0c6z1fTSPVIjEY1Wr7jzc=
 golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e h1:vcxGaoTs7kV8m5Np9uUNQin4BrLOthgV7252N8V+FwY=
 golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=

main.go

@@ -30,6 +30,7 @@ import (
  "strings"
  "time"
 
+ doublestar "github.com/bmatcuk/doublestar/v4"
  "golang.org/x/sync/errgroup"
 )
 
@@ -48,7 +49,8 @@ Flags:
 `
 
 var (
- skipExtensionFlags skipExtensionFlag
+ skipExtensionFlags stringSlice
+ ignorePatterns stringSlice
  spdx spdxFlag
 
  holder = flag.String("c", "Google LLC", "copyright holder")
@@ -64,17 +66,19 @@ func init() {
  fmt.Fprintln(os.Stderr, helpText)
  flag.PrintDefaults()
  }
- flag.Var(&skipExtensionFlags, "skip", "To skip files to check/add the header file, for example: -skip rb -skip go")
+ flag.Var(&skipExtensionFlags, "skip", "[deprecated: see -ignore] file extensions to skip, for example: -skip rb -skip go")
+ flag.Var(&ignorePatterns, "ignore", "file patterns to ignore, for example: -ignore **/*.go -ignore vendor/**")
  flag.Var(&spdx, "s", "Include SPDX identifier in license header. Set -s=only to only include SPDX identifier.")
 }
 
-type skipExtensionFlag []string
+// stringSlice stores the results of a repeated command line flag as a string slice.
+type stringSlice []string
 
-func (i *skipExtensionFlag) String() string {
+func (i *stringSlice) String() string {
  return fmt.Sprint(*i)
 }
 
-func (i *skipExtensionFlag) Set(value string) error {
+func (i *stringSlice) Set(value string) error {
  *i = append(*i, value)
  return nil
 }
@@ -109,6 +113,17 @@ func main() {
  os.Exit(1)
  }
 
+ // convert -skip flags to -ignore equivalents
+ for _, s := range skipExtensionFlags {
+ ignorePatterns = append(ignorePatterns, fmt.Sprintf("**/*.%s", s))
+ }
+ // verify that all ignorePatterns are valid
+ for _, p := range ignorePatterns {
+ if !doublestar.ValidatePattern(p) {
+ log.Fatalf("ignore pattern %q is not valid", p)
+ }
+ }
+
  // map legacy license values
  if t, ok := legacyLicenseTypes[*license]; ok {
  *license = t
@@ -200,17 +215,27 @@ func walk(ch chan<- *file, start string) error {
  if fi.IsDir() {
  return nil
  }
- for _, skip := range skipExtensionFlags {
- if strings.TrimPrefix(filepath.Ext(fi.Name()), ".") == skip || fi.Name() == skip {
- log.Printf("%s: skipping this file", fi.Name())
- return nil
- }
+ if fileMatches(path, ignorePatterns) {
+ log.Printf("skipping: %s", path)
+ return nil
  }
  ch <- &file{path, fi.Mode()}
  return nil
  })
 }
 
+// fileMatches determines if path matches one of the provided file patterns.
+// Patterns are assumed to be valid.
+func fileMatches(path string, patterns []string) bool {
+ for _, p := range patterns {
+ // ignore error, since we assume patterns are valid
+ if match, _ := doublestar.Match(p, path); match {
+ return true
+ }
+ }
+ return false
+}
+
 // addLicense add a license to the file if missing.
 //
 // It returns true if the file was updated.

main_test.go

@@ -206,3 +206,63 @@ func TestMPL(t *testing.T) {
  t.Fatalf("%v\n%s", err, out)
  }
 }
+
+func TestFileMatches(t *testing.T) {
+ tests := []struct {
+ pattern string
+ path string
+ wantMatch bool
+ }{
+ // basic single directory patterns
+ {"", "file.c", false},
+ {"*.c", "file.h", false},
+ {"*.c", "file.c", true},
+
+ // subdirectory patterns
+ {"*.c", "vendor/file.c", false},
+ {"**/*.c", "vendor/file.c", true},
+ {"vendor/**", "vendor/file.c", true},
+ {"vendor/**/*.c", "vendor/file.c", true},
+ {"vendor/**/*.c", "vendor/a/b/file.c", true},
+
+ // single character "?" match
+ {"*.?", "file.c", true},
+ {"*.?", "file.go", false},
+ {"*.??", "file.c", false},
+ {"*.??", "file.go", true},
+
+ // character classes - sets and ranges
+ {"*.[ch]", "file.c", true},
+ {"*.[ch]", "file.h", true},
+ {"*.[ch]", "file.ch", false},
+ {"*.[a-z]", "file.c", true},
+ {"*.[a-z]", "file.h", true},
+ {"*.[a-z]", "file.go", false},
+ {"*.[a-z]", "file.R", false},
+
+ // character classes - negations
+ {"*.[^ch]", "file.c", false},
+ {"*.[^ch]", "file.h", false},
+ {"*.[^ch]", "file.R", true},
+ {"*.[!ch]", "file.c", false},
+ {"*.[!ch]", "file.h", false},
+ {"*.[!ch]", "file.R", true},
+
+ // comma-separated alternative matches
+ {"*.{c,go}", "file.c", true},
+ {"*.{c,go}", "file.go", true},
+ {"*.{c,go}", "file.h", false},
+
+ // negating alternative matches
+ {"*.[^{c,go}]", "file.c", false},
+ {"*.[^{c,go}]", "file.go", false},
+ {"*.[^{c,go}]", "file.h", true},
+ }
+
+ for _, tt := range tests {
+ patterns := []string{tt.pattern}
+ if got := fileMatches(tt.path, patterns); got != tt.wantMatch {
+ t.Errorf("fileMatches(%q, %q) returned %v, want %v", tt.path, patterns, got, tt.wantMatch)
+ }
+ }
+}