Extract gomodifytags to a library

This PR moves the gomodifytags tool into its package to be imported by other applications (i.e.: gopls).

A new entrypoint into gomodifytags is provided via Modification.Apply(), which uses the specified start and end positions
to apply struct tag modifications to the file without returning the new content.

Also updates staticcheck version

related: golang/vscode-go#2002

Author: madelinekalil

.github/workflows/go.yml

@@ -41,7 +41,7 @@ jobs:
     - name: Staticcheck
       uses: dominikh/staticcheck-action@v1.3.0
       with:
-        version: "2023.1.7"
+        version: "2025.1"
         install-go: false
 
     - name: Build

README.md

@@ -386,6 +386,12 @@ type Server struct {
 }
 ```
 
+To remove multiple options from the same tag, you can repeat the tag name. For example:
+
+```
+$ gomodifytags -file demo.go -struct Server -remove-options json=first_option,json=other_option
+```
+
 Lastly, to remove all options without explicitly defining the keys and names,
 we can use the `-clear-options` flag. The following example will remove all
 options for the given struct:

main.go

@@ -0,0 +1,372 @@
+package modifytags
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/token"
+	"sort"
+	"strconv"
+	"strings"
+	"unicode"
+
+	"github.com/fatih/camelcase"
+	"github.com/fatih/structtag"
+)
+
+// A Transform determines how Go field names will be translated into
+// names used in struct tags. For example, the [SnakeCase] transform
+// converts the field MyField into the json tag json:"my_field".
+type Transform int
+
+const (
+	NoTransform Transform = iota
+	SnakeCase             // MyField -> my_field
+	CamelCase             // MyField -> myField
+	LispCase              // MyField -> my-field
+	PascalCase            // MyField -> MyField
+	TitleCase             // MyField -> My Field
+	Keep                  // keep the existing field name
+)
+
+// A Modification defines how struct tags should be modified for a given input struct.
+type Modification struct {
+	Add        []string            // tags to add
+	AddOptions map[string][]string // options to add, per tag
+
+	Remove        []string            // tags to remove
+	RemoveOptions map[string][]string // options to remove, per tag
+
+	Overwrite            bool // if set, replace existing tags when adding
+	SkipUnexportedFields bool // if set, do not modify tags on unexported struct fields
+
+	Transform    Transform // transform rule for adding tags
+	Sort         bool      // if set, sort tags in ascending order by key name
+	ValueFormat  string    // format for the tag's value, after transformation; for example "column:{field}"
+	Clear        bool      // if set, clear all tags. tags are cleared before any new tags are added
+	ClearOptions bool      // if set, clear all tag options; options are cleared before any new options are added
+}
+
+// Apply applies the struct tag modifications of the receiver to all
+// struct fields contained within the given node between start and end position, modifying its input.
+func (mod *Modification) Apply(fset *token.FileSet, node ast.Node, start, end token.Pos) error {
+	err := mod.validate()
+	if err != nil {
+		return err
+	}
+
+	err = mod.rewrite(fset, node, start, end)
+	if _, ok := err.(*RewriteErrors); ok {
+		return err
+	}
+	return nil
+}
+
+// rewrite rewrites the node for structs between the start and end positions
+func (mod *Modification) rewrite(fset *token.FileSet, node ast.Node, start, end token.Pos) error {
+	var errs []error
+
+	rewriteFunc := func(n ast.Node) bool {
+		x, ok := n.(*ast.StructType)
+		if !ok {
+			return true
+		}
+
+		for _, f := range x.Fields.List {
+			if !(start <= f.End() && f.Pos() <= end) {
+				continue // not in range
+			}
+
+			fieldName := ""
+			if len(f.Names) != 0 {
+				for _, field := range f.Names {
+					if !mod.SkipUnexportedFields || isPublicName(field.Name) {
+						fieldName = field.Name
+						break
+					}
+				}
+			}
+
+			// anonymous field
+			if f.Names == nil {
+				ident, ok := f.Type.(*ast.Ident)
+				if !ok {
+					continue
+				}
+
+				if !mod.SkipUnexportedFields {
+					fieldName = ident.Name
+				}
+			}
+
+			// nothing to process, continue with next field
+			if fieldName == "" {
+				continue
+			}
+
+			if f.Tag == nil {
+				f.Tag = &ast.BasicLit{}
+			}
+
+			res, err := mod.processField(fieldName, f.Tag.Value)
+			if err != nil {
+				errs = append(errs, fmt.Errorf("%s:%d:%d:%s",
+					fset.Position(f.Pos()).Filename,
+					fset.Position(f.Pos()).Line,
+					fset.Position(f.Pos()).Column,
+					err))
+				continue
+			}
+
+			f.Tag.Value = res
+		}
+
+		return true
+	}
+
+	ast.Inspect(node, rewriteFunc)
+
+	if len(errs) > 0 {
+		return &RewriteErrors{Errs: errs}
+	}
+	return nil
+}
+
+// processField returns the new struct tag value for the given field
+func (mod *Modification) processField(fieldName, tagVal string) (string, error) {
+	var tag string
+	if tagVal != "" {
+		var err error
+		tag, err = strconv.Unquote(tagVal)
+		if err != nil {
+			return "", err
+		}
+	}
+
+	tags, err := structtag.Parse(tag)
+	if err != nil {
+		return "", err
+	}
+
+	tags = mod.removeTags(tags)
+	tags, err = mod.removeTagOptions(tags)
+	if err != nil {
+		return "", err
+	}
+
+	tags = mod.clearTags(tags)
+	tags = mod.clearOptions(tags)
+
+	tags, err = mod.addTags(fieldName, tags)
+	if err != nil {
+		return "", err
+	}
+
+	tags, err = mod.addTagOptions(tags)
+	if err != nil {
+		return "", err
+	}
+
+	if mod.Sort {
+		sort.Sort(tags)
+	}
+
+	res := tags.String()
+	if res != "" {
+		res = quote(tags.String())
+	}
+
+	return res, nil
+}
+
+func (mod *Modification) removeTags(tags *structtag.Tags) *structtag.Tags {
+	if len(mod.Remove) == 0 {
+		return tags
+	}
+
+	tags.Delete(mod.Remove...)
+	return tags
+}
+
+func (mod *Modification) clearTags(tags *structtag.Tags) *structtag.Tags {
+	if !mod.Clear {
+		return tags
+	}
+
+	tags.Delete(tags.Keys()...)
+	return tags
+}
+
+func (mod *Modification) clearOptions(tags *structtag.Tags) *structtag.Tags {
+	if !mod.ClearOptions {
+		return tags
+	}
+
+	for _, t := range tags.Tags() {
+		t.Options = nil
+	}
+
+	return tags
+}
+
+func (mod *Modification) removeTagOptions(tags *structtag.Tags) (*structtag.Tags, error) {
+	if len(mod.RemoveOptions) == 0 {
+		return tags, nil
+	}
+
+	for key, val := range mod.RemoveOptions {
+		for _, option := range val {
+			tags.DeleteOptions(key, option)
+		}
+	}
+
+	return tags, nil
+}
+
+func (mod *Modification) addTagOptions(tags *structtag.Tags) (*structtag.Tags, error) {
+	if len(mod.AddOptions) == 0 {
+		return tags, nil
+	}
+
+	for key, val := range mod.AddOptions {
+		tags.AddOptions(key, val...)
+	}
+
+	return tags, nil
+}
+
+func (mod *Modification) addTags(fieldName string, tags *structtag.Tags) (*structtag.Tags, error) {
+	if len(mod.Add) == 0 {
+		return tags, nil
+	}
+
+	split := camelcase.Split(fieldName)
+	name := ""
+
+	unknown := false
+	switch mod.Transform {
+	case SnakeCase:
+		var lowerSplit []string
+		for _, s := range split {
+			s = strings.Trim(s, "_")
+			if s == "" {
+				continue
+			}
+			lowerSplit = append(lowerSplit, strings.ToLower(s))
+		}
+
+		name = strings.Join(lowerSplit, "_")
+	case LispCase:
+		var lowerSplit []string
+		for _, s := range split {
+			lowerSplit = append(lowerSplit, strings.ToLower(s))
+		}
+
+		name = strings.Join(lowerSplit, "-")
+	case CamelCase:
+		var titled []string
+		for _, s := range split {
+			titled = append(titled, strings.Title(s))
+		}
+
+		titled[0] = strings.ToLower(titled[0])
+
+		name = strings.Join(titled, "")
+	case PascalCase:
+		var titled []string
+		for _, s := range split {
+			titled = append(titled, strings.Title(s))
+		}
+
+		name = strings.Join(titled, "")
+	case TitleCase:
+		var titled []string
+		for _, s := range split {
+			titled = append(titled, strings.Title(s))
+		}
+
+		name = strings.Join(titled, " ")
+	case Keep:
+		name = fieldName
+	default:
+		unknown = true
+	}
+
+	if mod.ValueFormat != "" {
+		prevName := name
+		name = strings.ReplaceAll(mod.ValueFormat, "{field}", name)
+		if name == mod.ValueFormat {
+			// support old style for backward compatibility
+			name = strings.ReplaceAll(mod.ValueFormat, "$field", prevName)
+		}
+	}
+
+	for _, key := range mod.Add {
+		split = strings.SplitN(key, ":", 2)
+		if len(split) >= 2 {
+			key = split[0]
+			name = strings.Join(split[1:], "")
+		} else if unknown {
+			// the user didn't pass any value but want to use an unknown
+			// transform. We don't return above in the default as the user
+			// might pass a value
+			return nil, fmt.Errorf("unknown transform option %q", mod.Transform)
+		}
+
+		tag, err := tags.Get(key)
+		if err != nil {
+			// tag doesn't exist, create a new one
+			tag = &structtag.Tag{
+				Key:  key,
+				Name: name,
+			}
+		} else if mod.Overwrite {
+			tag.Name = name
+		}
+
+		if err := tags.Set(tag); err != nil {
+			return nil, err
+		}
+	}
+
+	return tags, nil
+}
+
+func isPublicName(name string) bool {
+	for _, c := range name {
+		return unicode.IsUpper(c)
+	}
+	return false
+}
+
+// validate determines whether the Modification is valid or not.
+func (mod *Modification) validate() error {
+	if len(mod.Add) == 0 &&
+		len(mod.AddOptions) == 0 &&
+		!mod.Clear &&
+		!mod.ClearOptions &&
+		len(mod.RemoveOptions) == 0 &&
+		len(mod.Remove) == 0 {
+		return errors.New("one of " +
+			"[-add-tags, -add-options, -remove-tags, -remove-options, -clear-tags, -clear-options]" +
+			" should be defined")
+	}
+	return nil
+}
+
+func quote(tag string) string {
+	return "`" + tag + "`"
+}
+
+type RewriteErrors struct {
+	Errs []error
+}
+
+func (r *RewriteErrors) Error() string {
+	var buf bytes.Buffer
+	for _, e := range r.Errs {
+		buf.WriteString(fmt.Sprintf("%s\n", e.Error()))
+	}
+	return buf.String()
+}

main_test.go

@@ -0,0 +1,133 @@
+package modifytags
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"go/format"
+	"go/parser"
+	"go/token"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+var update = flag.Bool("update", false, "update golden (.out) files")
+
+// This is the directory where our test fixtures are.
+const fixtureDir = "./test-fixtures"
+
+func TestApply(t *testing.T) {
+	var tests = []struct {
+		file  string
+		m     *Modification
+		start token.Pos
+		end   token.Pos
+	}{
+		{
+			file: "all_structs",
+			m: &Modification{
+				Add:       []string{"json"},
+				Transform: SnakeCase,
+			},
+			start: token.Pos(1),
+			end:   token.NoPos, // will be set to end of file
+		},
+		{
+			file: "clear_all_tags",
+			m: &Modification{
+				Clear: true,
+			},
+			start: token.Pos(1),
+			end:   token.NoPos, // will be set to end of file
+		},
+		{
+			file: "remove_some_tags",
+			m: &Modification{
+				Remove: []string{"json"},
+			},
+			start: token.Pos(1),
+			end:   token.NoPos, // will be set to end of file
+		},
+		{
+			file: "add_tags_pos_between_line",
+			m: &Modification{
+				Add: []string{"json"},
+				AddOptions: map[string][]string{
+					"json": {"omitempty"},
+				},
+				Transform: SnakeCase,
+			},
+			start: token.Pos(50),  // middle of second struct field
+			end:   token.Pos(200), // middle of fourth struct field
+		},
+	}
+
+	for _, ts := range tests {
+		ts := ts
+
+		t.Run(ts.file, func(t *testing.T) {
+			filePath := filepath.Join(fixtureDir, fmt.Sprintf("%s.input", ts.file))
+			file, err := os.Open(filePath)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer file.Close()
+
+			fset := token.NewFileSet()
+
+			node, err := parser.ParseFile(fset, filepath.Join(fixtureDir, fmt.Sprintf("%s.input", ts.file)), nil, parser.ParseComments)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			if ts.start == token.NoPos {
+				ts.start = node.End()
+			}
+			if ts.end == token.NoPos {
+				ts.end = node.End()
+			}
+
+			err = ts.m.Apply(fset, node, ts.start, ts.end)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			var got bytes.Buffer
+			err = format.Node(&got, fset, node)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			// update golden file if necessary
+			golden := filepath.Join(fixtureDir, fmt.Sprintf("%s.golden", ts.file))
+
+			if *update {
+				err := ioutil.WriteFile(golden, got.Bytes(), 0644)
+				if err != nil {
+					t.Error(err)
+				}
+				return
+			}
+
+			// get golden file
+			want, err := ioutil.ReadFile(golden)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			from, err := ioutil.ReadFile(filePath)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			// compare
+			if !bytes.Equal(got.Bytes(), want) {
+				t.Errorf("case %s\ngot:\n====\n\n%s\nwant:\n=====\n\n%s\nfrom:\n=====\n\n%s\n",
+					ts.file, got.Bytes(), want, from)
+			}
+
+		})
+	}
+}

modifytags/modifytags.go

@@ -0,0 +1,8 @@
+package foo
+
+type foo struct {
+	bar string
+	t   bool   `json:"t,omitempty"`
+	qux string `json:"qux,omitempty"`
+	yoo string `json:"yoo,omitempty"`
+}

modifytags/modifytags_test.go

@@ -0,0 +1,8 @@
+package foo
+
+type foo struct {
+	bar string
+	t   bool
+	qux string
+	yoo string
+}

modifytags/test-fixtures/add_tags_pos_between_line.golden

@@ -0,0 +1,22 @@
+package main
+
+type foo struct {
+	bar       string   `json:"bar"`
+	MyExample bool     `json:"my_example"`
+	MyAnother []string `json:"my_another"`
+}
+
+const exampleVar = "foo"
+
+type bar struct {
+	// loose comment
+
+	// home
+	ankara string `json:"ankara"`
+	yeap   bool   `json:"yeap"` // just a boolean
+
+	// great cities
+	cities []string `json:"cities"`
+
+	// seconed loose comment
+}

modifytags/test-fixtures/add_tags_pos_between_line.input

@@ -0,0 +1,22 @@
+package main
+
+type foo struct {
+	bar       string
+	MyExample bool
+	MyAnother []string
+}
+
+const exampleVar = "foo"
+
+type bar struct {
+	// loose comment
+
+	// home
+	ankara string
+	yeap   bool // just a boolean
+
+	// great cities
+	cities []string
+
+	// seconed loose comment
+}

modifytags/test-fixtures/all_structs.golden

@@ -0,0 +1,9 @@
+package foo
+
+type foo struct {
+	bar string 
+	t   bool   
+	t   bool   
+	qux string 
+	yoo string 
+}

modifytags/test-fixtures/all_structs.input

@@ -0,0 +1,9 @@
+package foo
+
+type foo struct {
+	bar string `json:"bar,omitempty" hcl:"bar,omitnested"`
+	t   bool   `hcl:"t"`
+	t   bool   `hcl:"t,omitempty"`
+	qux string `json:"qux,omitempty" hcl:"qux,squash,keys"`
+	yoo string `json:"yoo"`
+}

modifytags/test-fixtures/clear_all_tags.golden

@@ -0,0 +1,9 @@
+package main
+
+type foo struct {
+	bar string `hcl:"bar,omitnested"`
+	t   bool   `hcl:"t"`
+	t   bool   `hcl:"t,omitempty"`
+	qux string `hcl:"qux,squash,keys"`
+	yoo string 
+}

modifytags/test-fixtures/clear_all_tags.input

@@ -0,0 +1,9 @@
+package main
+
+type foo struct {
+	bar string `json:"bar,omitempty" hcl:"bar,omitnested"`
+	t   bool   `hcl:"t"`
+	t   bool   `hcl:"t,omitempty"`
+	qux string `json:"qux,omitempty" hcl:"qux,squash,keys"`
+	yoo string `json:"yoo"`
+}

modifytags/test-fixtures/remove_some_tags.golden

@@ -0,0 +1 @@
+package foo

modifytags/test-fixtures/remove_some_tags.input

@@ -0,0 +1 @@
+package foo