Add exclude-private option

Added flag `-exclude-private` to chose to filter any symbols that are not public when building the tag file. This is very useful for building a tag file for the Go standard library or a third party API.

Author: Andrew Carter

README.md

@@ -21,6 +21,7 @@ Or using package manager `brew` on OS X
 
 	-L="": source file names are read from the specified file. If file is "-", input is read from standard in.
 	-R=false: recurse into directories in the file list.
+	-exclude-private=false: exclude private symbols.
 	-f="": write output to specified file. If file is "-", output is written to standard out.
 	-silent=false: do not produce any output on error.
 	-sort=true: sort tags.

main.go

@@ -22,15 +22,16 @@ const (
 )
 
 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
+	excludePrivate bool
 )
 
 // ignore unknown flags
@@ -47,6 +48,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.BoolVar(&excludePrivate, "exclude-private", false, "exclude private symbols.")
 
 	flags.Usage = func() {
 		fmt.Fprintf(os.Stderr, "gotags version %s\n\n", Version)
@@ -178,7 +180,7 @@ func main() {
 
 	tags := []Tag{}
 	for _, file := range files {
-		ts, err := Parse(file, relative, basedir)
+		ts, err := Parse(file, relative, basedir, excludePrivate)
 		if err != nil {
 			if !silent {
 				fmt.Fprintf(os.Stderr, "parse error: %s\n\n", err)

parser.go

@@ -12,22 +12,25 @@ import (
 
 // tagParser contains the data needed while parsing.
 type tagParser struct {
-	fset     *token.FileSet
-	tags     []Tag    // list of created tags
-	types    []string // all types we encounter, used to determine the constructors
-	relative bool     // should filenames be relative to basepath
-	basepath string   // output file directory
+	fset           *token.FileSet
+	tags           []Tag    // list of created tags
+	types          []string // all types we encounter, used to determine the constructors
+	relative       bool     // should filenames be relative to basepath
+	basepath       string   // output file directory
+	excludePrivate bool     // exclude private symbols
 }
 
-// Parse parses the source in filename and returns a list of tags. If relative
-// is true, the filenames in the list of tags are relative to basepath.
-func Parse(filename string, relative bool, basepath string) ([]Tag, error) {
+// Parse parses the source in filename and returns a list of tags.
+// If relative is true, the filenames in the list of tags are relative to basepath.
+// If excludePrivate is true, any symbols that are not exported will be excluded.
+func Parse(filename string, relative bool, basepath string, excludePrivate bool) ([]Tag, error) {
 	p := &tagParser{
-		fset:     token.NewFileSet(),
-		tags:     []Tag{},
-		types:    make([]string, 0),
-		relative: relative,
-		basepath: basepath,
+		fset:           token.NewFileSet(),
+		tags:           []Tag{},
+		types:          make([]string, 0),
+		relative:       relative,
+		basepath:       basepath,
+		excludePrivate: excludePrivate,
 	}
 
 	f, err := parser.ParseFile(p.fset, filename, nil, 0)
@@ -90,6 +93,10 @@ func (p *tagParser) parseFunction(f *ast.FuncDecl) {
 	tag := p.createTag(f.Name.Name, f.Pos(), Function)
 
 	tag.Fields[Access] = getAccess(tag.Name)
+	if p.excludeTag(tag) {
+		return
+	}
+
 	tag.Fields[Signature] = fmt.Sprintf("(%s)", getTypes(f.Type.Params, true))
 	tag.Fields[TypeField] = getTypes(f.Type.Results, false)
 
@@ -113,6 +120,9 @@ func (p *tagParser) parseTypeDeclaration(ts *ast.TypeSpec) {
 	tag := p.createTag(ts.Name.Name, ts.Pos(), Type)
 
 	tag.Fields[Access] = getAccess(tag.Name)
+	if p.excludeTag(tag) {
+		return
+	}
 
 	switch s := ts.Type.(type) {
 	case *ast.StructType:
@@ -140,6 +150,9 @@ func (p *tagParser) parseValueDeclaration(v *ast.ValueSpec) {
 
 		tag := p.createTag(d.Name, d.Pos(), Variable)
 		tag.Fields[Access] = getAccess(tag.Name)
+		if p.excludeTag(tag) {
+			continue
+		}
 
 		if v.Type != nil {
 			tag.Fields[TypeField] = getType(v.Type, true)
@@ -164,6 +177,9 @@ func (p *tagParser) parseStructFields(name string, s *ast.StructType) {
 			for _, n := range f.Names {
 				tag = p.createTag(n.Name, n.Pos(), Field)
 				tag.Fields[Access] = getAccess(tag.Name)
+				if p.excludeTag(tag) {
+					continue
+				}
 				tag.Fields[ReceiverType] = name
 				tag.Fields[TypeField] = getType(f.Type, true)
 				p.tags = append(p.tags, tag)
@@ -172,6 +188,9 @@ func (p *tagParser) parseStructFields(name string, s *ast.StructType) {
 			// embedded field
 			tag = p.createTag(getType(f.Type, true), f.Pos(), Embedded)
 			tag.Fields[Access] = getAccess(tag.Name)
+			if p.excludeTag(tag) {
+				continue
+			}
 			tag.Fields[ReceiverType] = name
 			tag.Fields[TypeField] = getType(f.Type, true)
 			p.tags = append(p.tags, tag)
@@ -192,6 +211,9 @@ func (p *tagParser) parseInterfaceMethods(name string, s *ast.InterfaceType) {
 		}
 
 		tag.Fields[Access] = getAccess(tag.Name)
+		if p.excludeTag(tag) {
+			continue
+		}
 
 		if t, ok := f.Type.(*ast.FuncType); ok {
 			tag.Fields[Signature] = fmt.Sprintf("(%s)", getTypes(t.Params, true))
@@ -249,6 +271,14 @@ func (p *tagParser) belongsToReceiver(types *ast.FieldList) (name string, ok boo
 	return "", false
 }
 
+// excludeTag returns true if tag symbol is not public and excludePrivate is set.
+func (p *tagParser) excludeTag(tag Tag) bool {
+	if p.excludePrivate && tag.Fields[Access] != "public" {
+		return true
+	}
+	return false
+}
+
 // getTypes returns a comma separated list of types in fields. If includeNames is
 // true each type is preceded by a comma separated list of parameter names.
 func getTypes(fields *ast.FieldList, includeNames bool) string {

parser_test.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"fmt"
 	"path/filepath"
 	"runtime"
 	"strconv"
@@ -110,23 +111,35 @@ func TestParse(t *testing.T) {
 			continue
 		}
 
-		tags, err := Parse(testCase.filename, testCase.relative, basepath)
-		if err != nil {
-			t.Errorf("[%s] Parse error: %s", testCase.filename, err)
-			continue
-		}
+		// Repeat each test - once with all symbols and once without private symbols
+		for _, excludePrivate := range []bool{false, true} {
+			tags, err := Parse(testCase.filename, testCase.relative, basepath, excludePrivate)
+			if err != nil {
+				t.Errorf("[%s] Parse error: %s", testCase.filename, err)
+				continue
+			}
 
-		if len(tags) != len(testCase.tags) {
-			t.Errorf("[%s] len(tags) == %d, want %d", testCase.filename, len(tags), len(testCase.tags))
-			continue
-		}
+			expected := expectedTags(testCase.tags, excludePrivate)
 
-		for i, tag := range testCase.tags {
-			if len(tag.File) == 0 {
-				tag.File = testCase.filename
+			if len(tags) != len(expected) {
+				msg := fmt.Sprintf("[%s] len(tags) == %d, want %d",
+					testCase.filename,
+					len(tags),
+					len(expected))
+				if excludePrivate {
+					msg += " (exclude private)"
+				}
+				t.Error(msg)
+				continue
 			}
-			if tags[i].String() != tag.String() {
-				t.Errorf("[%s] tag(%d)\n  is:%s\nwant:%s", testCase.filename, i, tags[i].String(), tag.String())
+
+			for i, tag := range expected {
+				if len(tag.File) == 0 {
+					tag.File = testCase.filename
+				}
+				if tags[i].String() != tag.String() {
+					t.Errorf("[%s] tag(%d)\n  is:%s\nwant:%s", testCase.filename, i, tags[i].String(), tag.String())
+				}
 			}
 		}
 	}
@@ -145,3 +158,17 @@ func tag(n string, l int, t TagType, fields F) (tag Tag) {
 
 	return
 }
+
+// expectedTags filters out tags that are private when excludePrivate enabled
+func expectedTags(tags []Tag, excludePrivate bool) []Tag {
+	expected := []Tag{}
+	for _, tag := range tags {
+		if tag.Type != Package && tag.Type != Import {
+			if excludePrivate && tag.Fields[Access] != "public" {
+				continue
+			}
+		}
+		expected = append(expected, tag)
+	}
+	return expected
+}