Add exclude option

Added --exclude option that mimics ctag's exclude flag. The pattern is expected to be a shell glob pattern (which is what Go's filepath.Match method expects). It can be set multiple times to set several filters. Once the file list is built, the patterns will be applied to each file to filter out any names that match the exclude patterns before processing.

Author: Andrew Carter

files_test.go

@@ -0,0 +1,97 @@
+package main
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+)
+
+var sources = []string{
+	"LICENSE",
+	"README.md",
+	"fields.go",
+	"fields_test.go",
+	"files_test.go",
+	"main.go",
+	"parser.go",
+	"parser_test.go",
+	"tag.go",
+	"tag_test.go",
+	"tags",
+	"tests/const.go-src",
+	"tests/func.go-src",
+	"tests/import.go-src",
+	"tests/interface.go-src",
+	"tests/range.go-src",
+	"tests/simple.go-src",
+	"tests/struct.go-src",
+	"tests/type.go-src",
+	"tests/var.go-src",
+}
+
+func TestCommandLineFiles(t *testing.T) {
+	patterns := patternList{}
+
+	files, err := getFileNames(sources, false, patterns)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if !reflect.DeepEqual(sources, files) {
+		t.Errorf("%+v != %+v", sources, files)
+	}
+}
+
+func TestSingleExcludePattern(t *testing.T) {
+	// Single pattern - exclude *_test.go files
+	patterns := []string{"*_test.go"}
+	files, err := getFileNames(sources, false, patterns)
+	if err != nil {
+		t.Error(err)
+	}
+
+	for _, f := range files {
+		if strings.HasSuffix(f, "_test.go") {
+			t.Errorf("%v should not be included", f)
+		}
+	}
+}
+
+func TestMultipeExcludePatterns(t *testing.T) {
+	// Multiple patterns - exclude *_test.go and **/*-src
+	patterns := []string{"*_test.go", "**/*-src"}
+	files, err := getFileNames(sources, false, patterns)
+	if err != nil {
+		t.Error(err)
+	}
+
+	for _, f := range files {
+		if strings.HasSuffix(f, "_test.go") || strings.HasSuffix(f, "-src") {
+			t.Errorf("%v should not be included", f)
+		}
+	}
+}
+
+func TestRecursiveExcludes(t *testing.T) {
+	input := []string{"/usr/local/go/src"}
+	patterns := []string{
+		"*_test.go",
+		"/usr/local/go/src/*/*/testdata/*",
+		"/usr/local/go/src/*/*/testdata/*/*",
+		"/usr/local/go/src/*/*/testdata/*/*/*",
+		"/usr/local/go/src/*/*/testdata/*/*/*/*",
+		"/usr/local/go/src/*/*/testdata/*/*/*/*/*",
+		"/usr/local/go/src/*/*/testdata/*/*/*/*/*/*",
+		"/usr/local/go/src/*/*/testdata/*/*/*/*/*/*/*",
+	}
+	files, err := getFileNames(input, true, patterns)
+	if err != nil {
+		t.Error(err)
+	}
+	for _, f := range files {
+		if strings.HasSuffix(f, "_test.go") || strings.Contains(f, "/testdata/") {
+			t.Errorf("%v should not be included", f)
+		}
+	}
+	t.Log(files)
+}

main.go

@@ -21,16 +21,28 @@ const (
 	AuthorEmail = "[email protected]"
 )
 
+type patternList []string
+
+func (p *patternList) String() string {
+	return fmt.Sprint(*p)
+}
+
+func (p *patternList) Set(value string) error {
+	*p = append(*p, value)
+	return nil
+}
+
 var (
-	printVersion bool
-	inputFile    string
-	outputFile   string
-	recurse      bool
-	sortOutput   bool
-	silent       bool
-	relative     bool
-	listLangs    bool
-	fields       string
+	printVersion    bool
+	inputFile       string
+	outputFile      string
+	recurse         bool
+	sortOutput      bool
+	silent          bool
+	relative        bool
+	listLangs       bool
+	fields          string
+	excludePatterns patternList
 )
 
 // ignore unknown flags
@@ -47,6 +59,7 @@ func init() {
 	flags.BoolVar(&relative, "tag-relative", false, "file paths should be relative to the directory containing the tag file.")
 	flags.BoolVar(&listLangs, "list-languages", false, "list supported languages.")
 	flags.StringVar(&fields, "fields", "", "include selected extension fields (only +l).")
+	flags.Var(&excludePatterns, "exclude", "exclude files and directories matching 'pattern'. May be called multiple times.")
 
 	flags.Usage = func() {
 		fmt.Fprintf(os.Stderr, "gotags version %s\n\n", Version)
@@ -69,6 +82,43 @@ func walkDir(names []string, dir string) ([]string, error) {
 	return names, e
 }
 
+// includeName will return true supplied list of patterns do not exclude name
+func includeName(name string, patterns []string) (bool, error) {
+	for _, p := range patterns {
+		// Compare pattern to full path and then to base filename
+		for _, v := range []string{name, filepath.Base(name)} {
+			m, err := filepath.Match(p, v)
+			if err != nil {
+				// Error - exclude
+				return false, err
+			}
+			if m == true {
+				// Matches filepath - exclude
+				return false, nil
+			}
+		}
+	}
+
+	// No filters matched - include the file
+	return true, nil
+}
+
+func filterNames(names []string, patterns []string) ([]string, error) {
+	var ret []string
+
+	for _, f := range names {
+		ok, err := includeName(f, patterns)
+		if err != nil {
+			return nil, err
+		}
+		if ok {
+			ret = append(ret, f)
+		}
+	}
+
+	return ret, nil
+}
+
 func recurseNames(names []string) ([]string, error) {
 	var ret []string
 	for _, name := range names {
@@ -113,22 +163,32 @@ func readNames(names []string) ([]string, error) {
 	return names, nil
 }
 
-func getFileNames() ([]string, error) {
+func getFileNames(files []string, recurse bool, excludes patternList) ([]string, error) {
 	var names []string
 
-	names = append(names, flags.Args()...)
+	// Start with list of supplied file names
+	names = append(names, files...)
+
+	// Read filenames from input file if provided
 	names, err := readNames(names)
 	if err != nil {
 		return nil, err
 	}
 
+	// Recurse into directories in the file list
 	if recurse {
 		names, err = recurseNames(names)
 		if err != nil {
 			return nil, err
 		}
 	}
 
+	// Apply excludes patterns
+	names, err = filterNames(names, excludes)
+	if err != nil {
+		return nil, err
+	}
+
 	return names, nil
 }
 
@@ -145,7 +205,7 @@ func main() {
 		return
 	}
 
-	files, err := getFileNames()
+	files, err := getFileNames(flags.Args(), recurse, excludePatterns)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "cannot get specified files\n\n")
 		flags.Usage()