Support --fields=+l

Signed-off-by: Lewis Marshall <[email protected]>

Author: lmars

fields.go

@@ -0,0 +1,38 @@
+package main
+
+import (
+	"fmt"
+	"regexp"
+)
+
+// FieldSet is a set of extension fields to include in a tag.
+type FieldSet map[TagField]bool
+
+// Includes tests whether the given field is included in the set.
+func (f FieldSet) Includes(field TagField) bool {
+	b, ok := f[field]
+	return ok && b
+}
+
+// ErrInvalidFields is an error returned when attempting to parse invalid
+// fields.
+type ErrInvalidFields struct {
+	Fields string
+}
+
+func (e ErrInvalidFields) Error() string {
+	return fmt.Sprintf("invalid fields: %s", e.Fields)
+}
+
+// currently only "+l" is supported
+var fieldsPattern = regexp.MustCompile(`^\+l$`)
+
+func parseFields(fields string) (FieldSet, error) {
+	if fields == "" {
+		return FieldSet{}, nil
+	}
+	if fieldsPattern.MatchString(fields) {
+		return FieldSet{Language: true}, nil
+	}
+	return FieldSet{}, ErrInvalidFields{fields}
+}

fields_test.go

@@ -0,0 +1,32 @@
+package main
+
+import (
+	"testing"
+)
+
+func TestParseFieldsEmpty(t *testing.T) {
+	_, err := parseFields("")
+	if err != nil {
+		t.Fatalf("unexpected error from parseFields: %s", err)
+	}
+}
+
+func TestParseFieldsLanguage(t *testing.T) {
+	set, err := parseFields("+l")
+	if err != nil {
+		t.Fatalf("unexpected error from parseFields: %s", err)
+	}
+	if !set.Includes(Language) {
+		t.Fatal("expected set to include Language")
+	}
+}
+
+func TestParseFieldsInvalid(t *testing.T) {
+	_, err := parseFields("junk")
+	if err == nil {
+		t.Fatal("expected parseFields to return error")
+	}
+	if _, ok := err.(ErrInvalidFields); !ok {
+		t.Fatalf("expected parseFields to return error of type ErrInvalidFields, got %T", err)
+	}
+}

main.go

@@ -30,6 +30,7 @@ var (
 	silent       bool
 	relative     bool
 	listLangs    bool
+	fields       string
 )
 
 // Initialize flags.
@@ -42,6 +43,7 @@ func init() {
 	flag.BoolVar(&silent, "silent", false, "do not produce any output on error.")
 	flag.BoolVar(&relative, "tag-relative", false, "file paths should be relative to the directory containing the tag file.")
 	flag.BoolVar(&listLangs, "list-languages", false, "list supported languages.")
+	flag.StringVar(&fields, "fields", "", "include selected extension fields (only +l).")
 
 	flag.Usage = func() {
 		fmt.Fprintf(os.Stderr, "gotags version %s\n\n", Version)
@@ -164,6 +166,13 @@ func main() {
 		}
 	}
 
+	fieldSet, err := parseFields(fields)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "%s\n\n", err)
+		flag.Usage()
+		os.Exit(1)
+	}
+
 	tags := []Tag{}
 	for _, file := range files {
 		ts, err := Parse(file, relative, basedir)
@@ -178,6 +187,9 @@ func main() {
 
 	output := createMetaTags()
 	for _, tag := range tags {
+		if fieldSet.Includes(Language) {
+			tag.Fields[Language] = "Go"
+		}
 		output = append(output, tag.String())
 	}
 

tag.go

@@ -28,6 +28,7 @@ const (
 	ReceiverType  TagField = "ctype"
 	Line          TagField = "line"
 	InterfaceType TagField = "ntype"
+	Language      TagField = "language"
 )
 
 // TagType represents the type of a tag in a tag line.