$30 off During Our Annual Pro Sale. View Details »

Building a go tool to modify struct tags

July 13, 2017

1.6k

Building a go tool to modify struct tags

Struct field tags are an important part of encode/decode types, especially when using packages such as encoding/json. However, modifying tags is repetitive, cumbersome and open to human errors. We can make it easy to modify tags with an automated tool that is written for this sole purpose.

Fatih Arslan

July 13, 2017

Tweet

More Decks by Fatih Arslan

See All by Fatih Arslan

Go at DigitalOcean

The Past and Future of Vim-go

How to write your own Go tool

Uzaktan Çalışmak

Tools for working with Go Code

Other Decks in Programming

See All in Programming

文系出身・開発未経験エンジニアが入社から5年間で実践した学習法〜エンジニアの世界で圧倒的に成長するために〜 (LT) - NIFTY Tech Day 2023

Amazon Rekognition デモ / 20231208-aws_seminar-01-rekognition-demo

アクセシビリティを理解するとフロントエンドのテストが楽になる！

Scala Left Fold Parallelisation- Three Approaches

Unity Searchを拡張して高度な検索型UIを実現する

DevTools Extension 3分クッキング

Comment choisir les « bons » composants open source ? (Capitole du Libre 2023)

DIGGLEの分析基盤アーキテクチャ

コンピュータグラフィクスの空

DRIVE CHARTのMLOpsを体感しよう

re:Invent 2023 機械学習、アナリティクス系 "推し" アップデート紹介

cmnakamurashogo

文化祭入退場システムCracker (at U-22プログラミング・コンテスト)

Featured

See All Featured

How to name files

Fashionably flexible responsive web design (full day workshop)

Put a Button on it: Removing Barriers to Going Fast.

Designing the Hi-DPI Web

The Invisible Customer

Building Flexible Design Systems

yeseniaperezcruz

Learning to Love Humans: Emotional Interface Design

The World Runs on Bad Software

Visualizing Your Data: Incorporating Mongo into Loggly Infrastructure

Designing with Data

Building Effective Engineering Teams - LeadDev

Building Applications with DynamoDB

Transcript

Building a go tool
to modify struct tags
Fatih Arslan
Software Engineer @DigitalOcean

View Slide
Why do we need
tooling?

View Slide
type Example struct {
Foo string
}

View Slide
type Example struct {
Foo string `json:"foo"`
}

View Slide
What about structs with
many ﬁelds?

View Slide
type Example struct {
StatusID int64
Foo string
Bar bool
Server struct {
Address string
TLS bool
}
DiskSize int64
Volumes []string
}

View Slide
type Example struct {
StatusID int64 `json:"status_id"`
Foo string `json:"foo" xml:"foo"`
Bar bool `json:"bar" xml:"bar"`
Server struct {
Address string `json:"address"`
TLS bool `json:"tls",xml:"tls"`
} `json="server"`
DiskSize int64 `json:disk_size`
Volumes []string `"json":"volumes"`
}

View Slide
Working with struct tags
is not fun

View Slide
So, what's a struct tag?
type Example struct {
Foo string `json:"foo"`
}

View Slide
There is no ofﬁcial spec of
the struct tag

View Slide
Struct tag deﬁnition

View Slide
But fortunately, we have an
inofﬁcial one in stdlib!

View Slide
Spec is deﬁned in the
reﬂect package

View Slide
reﬂect.StructTag

View Slide
Let's decompose the spec

View Slide
json:"foo"

View Slide
json:"foo"
key

View Slide
json:"foo"
value
(quoted)

View Slide
json:"foo"
colon
(not speciﬁed clearly)

View Slide
json:"foo" xml:"foo"
space separation

View Slide
type Example struct {
Foo string `json:"foo"`
}
backticks

View Slide
type Example struct {
Foo string `json:"foo"`
}

View Slide
type Example struct {
Foo string "json:\"foo\""
}
quotes instead of backticks
(works, but not fun to deal with)

View Slide
json:"foo,omitempty"
value

View Slide
json:"foo,omitempty"
option
(not part of the spec)

View Slide
Recap

View Slide
`json:"foo,omitempty"
option
(not part of the spec)
space separation
key
value
xml:"bar"`
backtick

View Slide
Back to our initial slide!

View Slide
type Example struct {
StatusID int64 `json:"status_id"`
Foo string `json:"foo" xml:"foo"`
Bar bool `json:"bar" xml:"bar"`
Server struct {
Address string `json:"address"`
TLS bool `json:"tls",xml:"tls"`
} `json="server"`
DiskSize int64 `json:disk_size`
Volumes []string `"json":"volumes"`
}

View Slide
It has some errors

View Slide
type Example struct {
StatusID int64 `json:"status_id"`
Foo string `json:"foo" xml:"foo"`
Bar bool `json:"bar" xml:"bar"`
Server struct {
Address string `json:"address"`
TLS bool `json:"tls",xml:"tls"`
} `json="server"`
DiskSize int64 `json:disk_size`
Volumes []string `"json":"volumes"`
}

View Slide
type Example struct {
StatusID int64 `json:"status_id"`
Foo string `json:"foo" xml:"foo"`
Bar bool `json:"bar" xml:"bar"`
Server struct {
Address string `json:"address"`
TLS bool `json:"tls",xml:"tls"`
} `json="server"`
DiskSize int64 `json:disk_size`
Volumes []string `"json":"volumes"`
}
`json:"tls" xml:"tls"`

View Slide
type Example struct {
StatusID int64 `json:"status_id"`
Foo string `json:"foo" xml:"foo"`
Bar bool `json:"bar" xml:"bar"`
Server struct {
Address string `json:"address"`
TLS bool `json:"tls",xml:"tls"`
} `json="server"`
DiskSize int64 `json:disk_size`
Volumes []string `"json":"volumes"`
}

View Slide
type Example struct {
StatusID int64 `json:"status_id"`
Foo string `json:"foo" xml:"foo"`
Bar bool `json:"bar" xml:"bar"`
Server struct {
Address string `json:"address"`
TLS bool `json:"tls",xml:"tls"`
} `json="server"`
DiskSize int64 `json:disk_size`
Volumes []string `"json":"volumes"`
}
`json:"server"`

View Slide
type Example struct {
StatusID int64 `json:"status_id"`
Foo string `json:"foo" xml:"foo"`
Bar bool `json:"bar" xml:"bar"`
Server struct {
Address string `json:"address"`
TLS bool `json:"tls",xml:"tls"`
} `json="server"`
DiskSize int64 `json:disk_size`
Volumes []string `"json":"volumes"`
}

View Slide
type Example struct {
StatusID int64 `json:"status_id"`
Foo string `json:"foo" xml:"foo"`
Bar bool `json:"bar" xml:"bar"`
Server struct {
Address string `json:"address"`
TLS bool `json:"tls",xml:"tls"`
} `json="server"`
DiskSize int64 `json:disk_size`
Volumes []string `"json":"volumes"`
}
`json:"disk_size"`

View Slide
type Example struct {
StatusID int64 `json:"status_id"`
Foo string `json:"foo" xml:"foo"`
Bar bool `json:"bar" xml:"bar"`
Server struct {
Address string `json:"address"`
TLS bool `json:"tls",xml:"tls"`
} `json="server"`
DiskSize int64 `json:disk_size`
Volumes []string `"json":"volumes"`
}

View Slide
type Example struct {
StatusID int64 `json:"status_id"`
Foo string `json:"foo" xml:"foo"`
Bar bool `json:"bar" xml:"bar"`
Server struct {
Address string `json:"address"`
TLS bool `json:"tls",xml:"tls"`
} `json="server"`
DiskSize int64 `json:disk_size`
Volumes []string `"json":"volumes"`
} `json:"volumes"`

View Slide
First attempt
(to automate it)

View Slide
Old implementation
• From the cursor search backwards for the first 'struct {' literal
• Once found, do a forward search for the right hand brace }
• Get the line numbers between the two braces
• For each line, get the first identifier, convert it to camel_case word
and then append to the same line
• A combination of Vim's search() function and regex is being used

View Slide
type Example struct {
Foo string
Bar |bool
}
cursor

View Slide
type Example struct {
Foo string
Bar |bool
}

View Slide
type Example struct {
Foo string
Bar |bool
}

View Slide
type Example struct {
Foo string
Bar |bool
}

View Slide
type Example struct {
Foo string
Bar |bool
}

View Slide
type Example struct {
Foo string `json:"foo"`
Bar |bool `json:"bar"`
}

View Slide
Problems

View Slide
No Formatting
type Example struct {
Bar string `json:"bar"`
Foo bool `json:"foo"`
}
type Example struct {
Bar string `json:"bar"`
Foo bool `json:"foo"`
}
want
have

View Slide
In-line comments
type Example struct {
Bar string `json:"bar"` // comment for bar
Foo bool `json:"foo"`
}
type Example struct {
Bar string // comment for bar `json:"bar"`
Foo bool `json:"foo"`
}
want
have

View Slide
Nested structs
type Example struct {
Bar bool `json:"bar"`
Server struct { `json:"server"`
Address string `json:"address"`
}
}
type Example struct {
Bar bool `json:"bar"`
Server struct {
Address string `json:"address"`
} `json:"server"`
}
have
want

View Slide
Duplicate tags
type Example struct {
Bar string `json:"bar"` `xml:"bar"`
Foo bool `xml:"foo"`
}
have
type Example struct {
Bar string `json:"bar" xml:"bar"`
Foo bool `xml:"foo"`
}
want

View Slide
more quirks
• not able to remove tags
• not able to add or remove options
• ﬁeld with interface{} types don't work
• comment with braces ({ and }) don't work
• ...

View Slide
How do we ﬁx it?

View Slide
Second attempt
(and also the ﬁnal one )

View Slide
Two issues that need to be ﬁxed
Parse struct
Parse struct tag

View Slide
1. Parse Struct

View Slide
The Go Parser Family

View Slide
go/token go/scanner
go/parser
go/ast
go/printer

View Slide
First,
a quick tutorial about go/ast

View Slide
3 + 2
*ast.BinaryExpr

View Slide
3 + 2
*ast.BinaryExpr
*ast.BasicLit
3

View Slide
3 + 2
*ast.BinaryExpr
*ast.BasicLit
2

View Slide
3 + 2
*ast.BinaryExpr
*ast.BasicLit *ast.BasicLit
3 2
+

View Slide
3 + (7 - 5)
*ast.BinaryExpr
*ast.BasicLit
3
+
*ast.BinaryExpr
*ast.BasicLit *ast.BasicLit
5
-
7

View Slide
3 + (7 - 5)
*ast.BinaryExpr
*ast.BasicLit
3
+
*ast.BinaryExpr
*ast.BasicLit *ast.BasicLit
5
-
7

View Slide
type Example struct {
Foo string `json:"foo"`
}
*ast.TypeSpec

View Slide
type Example struct {
Foo string `json:"foo"`
}
*ast.TypeSpec
*ast.StructType

View Slide
type Example struct {
Foo string `json:"foo"`
}
*ast.TypeSpec
*ast.StructType
*ast.FieldList

View Slide
type Example struct {
Foo string `json:"foo"`
}
*ast.TypeSpec
*ast.StructType
*ast.FieldList *ast.Field

View Slide
type Example struct {
Foo string `json:"foo"`
}
*ast.TypeSpec
*ast.StructType
*ast.FieldList *ast.Field
[]*ast.Ident
Foo

View Slide
type Example struct {
Foo string `json:"foo"`
}
*ast.TypeSpec
*ast.StructType
*ast.FieldList *ast.Field *ast.Ident
string

View Slide
type Example struct {
Foo string `json:"foo"`
}
*ast.TypeSpec
*ast.StructType
*ast.FieldList *ast.Field
*ast.BasicLit
`json:"foo"`
(a.k.a: struct tag)

View Slide
type Example struct {
Foo string `json:"foo"`
}
*ast.TypeSpec
*ast.StructType
*ast.FieldList *ast.Field
[]*ast.Ident
*ast.Ident
*ast.BasicLit

View Slide
ast.Node

View Slide
All nodes deﬁne the
starting and ending positions

View Slide
How do we parse a Struct?

View Slide
src := `package main
type Example struct {
Foo string` + " `json:\"foo\"` }"
fset := token.NewFileSet()
file, err := parser.ParseFile(fset, "demo", src, parser.ParseComments)
if err != nil {
panic(err)
}
ast.Inspect(file, func(x ast.Node) bool {
s, ok := x.(*ast.StructType)
if !ok {
return true
}
for _, field := range s.Fields.List {
fmt.Printf("Field: %s\n", field.Names[0].Name)
fmt.Printf("Tag: %s\n", field.Tag.Value)
}
return false
})

View Slide
src := `package main
type Example struct {
Foo string` + " `json:\"foo\"` }"
fset := token.NewFileSet()
file, err := parser.ParseFile(fset, "demo", src, parser.ParseComments)
if err != nil {
panic(err)
}
ast.Inspect(file, func(x ast.Node) bool {
s, ok := x.(*ast.StructType)
if !ok {
return true
}
for _, field := range s.Fields.List {
fmt.Printf("Field: %s\n", field.Names[0].Name)
fmt.Printf("Tag: %s\n", field.Tag.Value)
}
return false
})

View Slide
src := `package main
type Example struct {
Foo string` + " `json:\"foo\"` }"
fset := token.NewFileSet()
file, err := parser.ParseFile(fset, "demo", src, parser.ParseComments)
if err != nil {
panic(err)
}
ast.Inspect(file, func(x ast.Node) bool {
s, ok := x.(*ast.StructType)
if !ok {
return true
}
for _, field := range s.Fields.List {
fmt.Printf("Field: %s\n", field.Names[0].Name)
fmt.Printf("Tag: %s\n", field.Tag.Value)
}
return false
})

View Slide
src := `package main
type Example struct {
Foo string` + " `json:\"foo\"` }"
fset := token.NewFileSet()
file, err := parser.ParseFile(fset, "demo", src, parser.ParseComments)
if err != nil {
panic(err)
}
ast.Inspect(file, func(x ast.Node) bool {
s, ok := x.(*ast.StructType)
if !ok {
return true
}
for _, field := range s.Fields.List {
fmt.Printf("Field: %s\n", field.Names[0].Name)
fmt.Printf("Tag: %s\n", field.Tag.Value)
}
return false
})

View Slide
src := `package main
type Example struct {
Foo string` + " `json:\"foo\"` }"
fset := token.NewFileSet()
file, err := parser.ParseFile(fset, "demo", src, parser.ParseComments)
if err != nil {
panic(err)
}
ast.Inspect(file, func(x ast.Node) bool {
s, ok := x.(*ast.StructType)
if !ok {
return true
}
for _, field := range s.Fields.List {
fmt.Printf("Field: %s\n", field.Names[0].Name)
fmt.Printf("Tag: %s\n", field.Tag.Value)
}
return false
})

View Slide
src := `package main
type Example struct {
Foo string` + " `json:\"foo\"` }"
fset := token.NewFileSet()
file, err := parser.ParseFile(fset, "demo", src, parser.ParseComments)
if err != nil {
panic(err)
}
ast.Inspect(file, func(x ast.Node) bool {
s, ok := x.(*ast.StructType)
if !ok {
return true
}
for _, field := range s.Fields.List {
fmt.Printf("Field: %s\n", field.Names[0].Name)
fmt.Printf("Tag: %s\n", field.Tag.Value)
}
return false
})
Field: Foo
Tag: `json:"foo"`

View Slide
2. Parse Struct Tag

View Slide
How to parse a Struct Tag?

View Slide
Remember this?

View Slide
package main
import (
"fmt"
"reflect"
)
func main() {
tag := reflect.StructTag(`json:"foo"`)
value := tag.Get("json")
fmt.Printf("value: %q\n", value)
}

View Slide
package main
import (
"fmt"
"reflect"
)
func main() {
tag := reflect.StructTag(`json:"foo"`)
value := tag.Get("json")
fmt.Printf("value: %q\n", value)
}
$ go run main.go
value: "foo"

View Slide
reﬂect.StructTag is not
perfect ...

View Slide
Issues with reﬂect.StructTag
• can't detect if the tag is malformed (only go vet knows that)
• doesn't know the semantics of options (i.e: omitempty)
• doesn't return all existing tags
• modifying existing tags is not possible

View Slide
reﬂect
cmd/vet

View Slide
Let's improve it
with a custom package

View Slide
import "github.com/fatih/structtag"

View Slide
structtag

View Slide
Parse and list all tags
tags, err := structtag.Parse(`json:"foo,omitempty" xml:"foo"`)
if err != nil {
panic(err)
}
// iterate over all key-value pairs
for _, t := range tags.Tags() {
fmt.Printf("tag: %+v\n", t)
}
$ go run main.go
tag: json:"foo,omitempty"
tag: xml:"foo"

View Slide
Get a single Tag
tags, err := structtag.Parse(`json:"foo,omitempty" xml:"foo"`)
if err != nil {
panic(err)
}
jsonTag, err := tags.Get("json")
if err != nil {
panic(err)
}
fmt.Println(jsonTag) // Output: json:"foo,omitempty"
fmt.Println(jsonTag.Key) // Output: json
fmt.Println(jsonTag.Name) // Output: foo
fmt.Println(jsonTag.Options) // Output: [omitempty]

View Slide
Change existing tag
jsonTag, err := tags.Get(`json:"foo,omitempty"`)
if err != nil {
panic(err)
}
jsonTag.Name = "bar"
jsonTag.Options = nil
tags.Set(jsonTag)
fmt.Println(tags)
json:"bar"

View Slide
Add new tag
tags, err := structtag.Parse(`json:"foo,omitempty" xml:"foo"`)
hclTag := &structtag.Tag{
Key: "hcl",
Name: "gopher",
Options: []string{"squash"},
}
// add new tag
tags.Set(hclTag)
fmt.Println(tags)
json:"foo,omitempty" xml:"foo" hcl:"gopher,squash"

View Slide
Add/remove options
tags, err := structtag.Parse(`json:"foo" xml:"bar,comment"`)
if err != nil {
panic(err)
}
tags.AddOptions("json", "omitempty")
tags.DeleteOptions("xml", "comment")
fmt.Println(tags) // json:"foo,omitempty" xml:"bar"

View Slide
Both issues are ﬁxed now
Parse struct (using go/parser)
Parse struct tag (using fatih/structtag)

View Slide
Write a CLI tool

View Slide
gomodifytags

View Slide
go get github.com/fatih/gomodifytags

View Slide
func main() {
var cfg config
node = cfg.parse()
start, end = cfg.findSelection(node)
rewritten = cfg.rewrite(node, start, end)
out = cfg.format(rewritten)
fmt.Println(out)
}
1. Fetch conﬁguration settings
2. Parse content
3. Find selection
4. Modify the struct tag
5. Output the result

View Slide
func main() {
var cfg config
node = cfg.parse()
start, end = cfg.findSelection(node)
rewritten = cfg.rewrite(node, start, end)
out = cfg.format(rewritten)
fmt.Println(out)
}
1. Fetch conﬁguration settings
2. Parse content
3. Find selection
4. Modify the struct tag
5. Output the result

View Slide
Fetch conﬁguration settings

View Slide
cfg := &config{
file: *flagFile,
line: *flagLine,
structName: *flagStruct,
offset: *flagOffset,
output: *flagOutput,
write: *flagWrite,
clear: *flagClearTags,
clearOption: *flagClearOptions,
transform: *flagTransform,
sort: *flagSort,
override: *flagOverride,
}
$ gomodifytags --file example.go ...
Use ﬂags to set
conﬁguration

View Slide
Things we need:
1. What content to process
2. Where and what to output
3. Which struct to modify
4. Which tags to modify

View Slide
Things we need:
type config struct {
file string
modified io.Reader
output string
write bool
offset int
structName string
line string
start, end int
remove []string
add []string
override bool
transform string
sort bool
clear bool
addOpts []string
removeOpts []string
clearOpt bool
}
1. What content to process
2. Where and what to output
3. Which struct to modify
4. Which tags to modify

View Slide
Things we need:
type config struct {
file string
modified io.Reader
output string
write bool
offset int
structName string
line string
start, end int
remove []string
add []string
override bool
transform string
sort bool
clear bool
addOpts []string
removeOpts []string
clearOpt bool
}
1. What content to process
2. Where and what to output
3. Which struct to modify
4. Which tags to modify

View Slide
Things we need:
type config struct {
file string
modified io.Reader
output string
write bool
offset int
structName string
line string
start, end int
remove []string
add []string
override bool
transform string
sort bool
clear bool
addOpts []string
removeOpts []string
clearOpt bool
}
1. What content to process
2. Where and what to output
3. Which struct to modify
4. Which tags to modify

View Slide
Things we need:
type config struct {
file string
modified io.Reader
output string
write bool
offset int
structName string
line string
start, end int
remove []string
add []string
override bool
transform string
sort bool
clear bool
addOpts []string
removeOpts []string
clearOpt bool
}
1. What content to process
2. Where and what to output
3. Which struct to modify
4. Which tags to modify

View Slide
package main
type Example struct {
Foo string
} $ gomodifytags
-ﬁle example.go
-struct Example
-add-tags json

View Slide
package main
type Example struct {
Foo string
}
parse
gomodifytags

View Slide
Parse content

View Slide
func main() {
var cfg config
node = cfg.parse()
start, end = cfg.findSelection(node)
rewritten = cfg.rewrite(node, start, end)
out = cfg.format(rewritten)
fmt.Println(out)
}
1. Fetch conﬁguration settings
2. Parse content
3. Find selection
4. Modify the struct tag
5. Output the result

View Slide
parse
gomodifytags
go/parser
package main
type Example struct {
Foo string
}

View Slide
parse
gomodifytags
go/parser
go/ast.Node
package main
type Example struct {
Foo string
}

View Slide
gomodifytags
parse
parse go/parser
package main
type Example struct {
Foo string
}
*ast.TypeSpec
*ast.StructType
*ast.FieldList *ast.Field
[]*ast.Ident
*ast.Ident
tag

View Slide
func (c *config) parse() (ast.Node, error) {
c.fset = token.NewFileSet()
var contents interface{}
if c.modified != nil {
archive, err := buildutil.ParseOverlayArchive(c.modified)
if err != nil {
return nil, fmt.Errorf("failed to parse -modified archive: %v", err)
}
fc, ok := archive[c.file]
if !ok {
return nil, fmt.Errorf("couldn't find %s in archive", c.file)
}
contents = fc
}
return parser.ParseFile(c.fset, c.file, contents, parser.ParseComments)
}
Parse content

View Slide
func (c *config) parse() (ast.Node, error) {
c.fset = token.NewFileSet()
var contents interface{}
if c.modified != nil {
archive, err := buildutil.ParseOverlayArchive(c.modified)
if err != nil {
return nil, fmt.Errorf("failed to parse -modified archive: %v", err)
}
fc, ok := archive[c.file]
if !ok {
return nil, fmt.Errorf("couldn't find %s in archive", c.file)
}
contents = fc
}
return parser.ParseFile(c.fset, c.file, contents, parser.ParseComments)
}
Parse content (cont.)

View Slide
package main
type Example struct {
Foo string
}
parse
gomodifytags
parse

View Slide
package main
type Example struct {
Foo string
}
parse ﬁnd
gomodifytags

View Slide
Find start and end positions

View Slide
func main() {
var cfg config
node = cfg.parse()
start, end = cfg.findSelection(node)
rewritten = cfg.rewrite(node, start, end)
out = cfg.format(rewritten)
fmt.Println(out)
}
1. Fetch conﬁguration settings
2. Parse content
3. Find selection
4. Modify the struct tag
5. Output the result

View Slide
gomodifytags
*ast.TypeSpec
*ast.StructType
*ast.FieldList *ast.Field
[]*ast.Ident
*ast.Ident
tag
this is our ﬁle
ast.Node

View Slide
parse ﬁnd
gomodifytags
*ast.TypeSpec
*ast.StructType
*ast.FieldList *ast.Field
[]*ast.Ident
*ast.Ident
ast.BasicLit
which is an AST tree

View Slide
parse ﬁnd
gomodifytags
*ast.TypeSpec
*ast.StructType
*ast.FieldList *ast.Field
[]*ast.Ident
*ast.Ident
ast.BasicLit
select struct that matches
our criteria ...

View Slide
There are many ways to
ﬁnd a struct

View Slide
package main
type Example struct {
Foo string
}
type Server struct {
Name string
Port int
EnableLogs bool
}
type Person struct {
Name string
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

View Slide
package main
type Example struct {
Foo string
}
type Server struct {
Name string
Port int
EnableLogs bool
}
type Person struct {
Name string
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

View Slide
package main
type Example struct {
Foo string
}
type Server struct {
Name string
Port int
EnableLogs bool
}
type Person struct {
Name string
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
struct name:
Server

View Slide
package main
type Example struct {
Foo string
}
type Server struct {
Name string
Port int
EnableLogs bool
}
type Person struct {
Name string
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
struct name:
Server
start line: 8
end line: 10

View Slide
package main
type Example struct {
Foo string
}
type Server struct {
Name string
Port| int
EnableLogs bool
}
type Person struct {
Name string
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
offset byte:
96 (of 163)

View Slide
package main
type Example struct {
Foo string
}
type Server struct {
Name string
Port| int
EnableLogs bool
}
type Person struct {
Name string
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
offset byte:
96 (of 163)
start line: 8
end line: 10

View Slide
package main
type Example struct {
Foo string
}
type Server struct {
Name string
Port int
EnableLogs bool
}
type Person struct {
Name string
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
start line: 8
end line: 10
.. or specify explicit lines

View Slide
package main
type Example struct {
Foo string
}
type Server struct {
Name string
Port int
EnableLogs bool
}
type Person struct {
Name string
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
start line: 9
end line: 9
.. or specify explicit lines

View Slide
parse ﬁnd
gomodifytags
*ast.TypeSpec
*ast.StructType
*ast.FieldList *ast.Field
[]*ast.Ident
*ast.Ident
ast.BasicLit
select struct that matches
our criteria ...

View Slide
gomodifytags
*ast.TypeSpec
*ast.StructType
*ast.FieldList *ast.Field
[]*ast.Ident
*ast.Ident
ast.BasicLit
... and get the
start and end lines
start line: 8
end line: 10

View Slide
func (c *config) findSelection(node ast.Node) (int, int, error) {
if c.line != "" {
return c.lineSelection(node)
} else if c.offset != 0 {
return c.offsetSelection(node)
} else if c.structName != "" {
return c.structSelection(node)
}
return 0, 0, errors.New("-line, -offset or -struct is not passed")
}
Find selection

View Slide
func (c *config) findSelection(node ast.Node) (int, int, error) {
if c.line != "" {
return c.lineSelection(node)
} else if c.offset != 0 {
return c.offsetSelection(node)
} else if c.structName != "" {
return c.structSelection(node)
}
return 0, 0, errors.New("-line, -offset or -struct is not passed")
}
Find selection

View Slide
Collecting structs

View Slide
// collectStructs collects and maps structType nodes to their positions
func collectStructs(node ast.Node) map[token.Pos]*structType {
structs := make(map[token.Pos]*structType, 0)
collectStructs := func(n ast.Node) bool {
t, ok := n.(*ast.TypeSpec)
if !ok {
return true
}
structName := t.Name.Name
x, ok := t.Type.(*ast.StructType)
if !ok {
return true
}
structs[x.Pos()] = &structType{
name: structName,
node: x,
}
return true
}
ast.Inspect(node, collectStructs)
return structs
}

View Slide
// collectStructs collects and maps structType nodes to their positions
func collectStructs(node ast.Node) map[token.Pos]*structType {
structs := make(map[token.Pos]*structType)
collectStructs := func(n ast.Node) bool {
t, ok := n.(*ast.TypeSpec)
if !ok {
return true
}
structName := t.Name.Name
x, ok := t.Type.(*ast.StructType)
if !ok {
return true
}
structs[x.Pos()] = &structType{
name: structName,
node: x,
}
return true
}
ast.Inspect(node, collectStructs)
return structs
}
type structType struct {
name string
node *ast.StructType
}

View Slide
// collectStructs collects and maps structType nodes to their positions
func collectStructs(node ast.Node) map[token.Pos]*structType {
structs := make(map[token.Pos]*structType)
collectStructs := func(n ast.Node) bool {
t, ok := n.(*ast.TypeSpec)
if !ok {
return true
}
structName := t.Name.Name
x, ok := t.Type.(*ast.StructType)
if !ok {
return true
}
structs[x.Pos()] = &structType{
name: structName,
node: x,
}
return true
}
ast.Inspect(node, collectStructs)
return structs
}

View Slide
// collectStructs collects and maps structType nodes to their positions
func collectStructs(node ast.Node) map[token.Pos]*structType {
structs := make(map[token.Pos]*structType)
collectStructs := func(n ast.Node) bool {
t, ok := n.(*ast.TypeSpec)
if !ok {
return true
}
structName := t.Name.Name
x, ok := t.Type.(*ast.StructType)
if !ok {
return true
}
structs[x.Pos()] = &structType{
name: structName,
node: x,
}
return true
}
ast.Inspect(node, collectStructs)
return structs
}
type structType struct {
name string
node *ast.StructType
}

View Slide
// collectStructs collects and maps structType nodes to their positions
func collectStructs(node ast.Node) map[token.Pos]*structType {
structs := make(map[token.Pos]*structType)
collectStructs := func(n ast.Node) bool {
t, ok := n.(*ast.TypeSpec)
if !ok {
return true
}
structName := t.Name.Name
x, ok := t.Type.(*ast.StructType)
if !ok {
return true
}
structs[x.Pos()] = &structType{
name: structName,
node: x,
}
return true
}
ast.Inspect(node, collectStructs)
return structs
}

View Slide
var encStruct *ast.StructType
for _, st := range collectStructs() {
if st.name == c.structName {
encStruct = st.node
}
start = c.fset.Position(encStruct.Pos()).Line
end = c.fset.Position(encStruct.End()).Line
}
Struct selection

View Slide
var encStruct *ast.StructType
for _, st := range collectStructs() {
if st.name == c.structName {
encStruct = st.node
}
start = c.fset.Position(encStruct.Pos()).Line
end = c.fset.Position(encStruct.End()).Line
}
Struct selection

View Slide
var encStruct *ast.StructType
for _, st := range collectStructs() {
if st.name == c.structName {
encStruct = st.node
}
start = c.fset.Position(encStruct.Pos()).Line
end = c.fset.Position(encStruct.End()).Line
}
Struct selection

View Slide
var encStruct *ast.StructType
for _, st := range collectStructs() {
if st.name == c.structName {
encStruct = st.node
}
start = c.fset.Position(encStruct.Pos()).Line
end = c.fset.Position(encStruct.End()).Line
}
Struct selection

View Slide
var encStruct *ast.StructType
for _, st := range collectStructs() {
structBegin := c.fset.Position(st.node.Pos()).Offset
structEnd := c.fset.Position(st.node.End()).Offset
if structBegin <= c.offset && c.offset <= structEnd {
encStruct = st.node
break
}
}
start = c.fset.Position(encStruct.Pos()).Line
end = c.fset.Position(encStruct.End()).Line
Offset selection

View Slide
var encStruct *ast.StructType
for _, st := range collectStructs() {
structBegin := c.fset.Position(st.node.Pos()).Offset
structEnd := c.fset.Position(st.node.End()).Offset
if structBegin <= c.offset && c.offset <= structEnd {
encStruct = st.node
break
}
}
start = c.fset.Position(encStruct.Pos()).Line
end = c.fset.Position(encStruct.End()).Line
Offset selection

View Slide
var encStruct *ast.StructType
for _, st := range collectStructs() {
structBegin := c.fset.Position(st.node.Pos()).Offset
structEnd := c.fset.Position(st.node.End()).Offset
if structBegin <= c.offset && c.offset <= structEnd {
encStruct = st.node
break
}
}
start = c.fset.Position(encStruct.Pos()).Line
end = c.fset.Position(encStruct.End()).Line
Offset selection

View Slide
var encStruct *ast.StructType
for _, st := range collectStructs() {
structBegin := c.fset.Position(st.node.Pos()).Offset
structEnd := c.fset.Position(st.node.End()).Offset
if structBegin <= c.offset && c.offset <= structEnd {
encStruct = st.node
break
}
}
start = c.fset.Position(encStruct.Pos()).Line
end = c.fset.Position(encStruct.End()).Line
Offset selection

View Slide
var encStruct *ast.StructType
for _, st := range collectStructs() {
structBegin := c.fset.Position(st.node.Pos()).Offset
structEnd := c.fset.Position(st.node.End()).Offset
if structBegin <= c.offset && c.offset <= structEnd {
encStruct = st.node
break
}
}
start = c.fset.Position(encStruct.Pos()).Line
end = c.fset.Position(encStruct.End()).Line
Offset selection

View Slide
package main
type Example struct {
Foo string
}
parse ﬁnd
gomodifytags
ﬁnd

View Slide
package main
type Example struct {
Foo string
}
parse ﬁnd
modify
gomodifytags

View Slide
Rewrite the struct tag

View Slide
func main() {
var cfg config
node = cfg.parse()
start, end = cfg.findSelection(node)
rewritten = cfg.rewrite(node, start, end)
out = cfg.format(rewritten)
fmt.Println(out)
}
1. Fetch conﬁguration settings
2. Parse content
3. Find selection
4. Modify the struct tag
5. Output the result

View Slide
gomodifytags
start and end lines
we're going to modify
start line: 8
end line: 10

View Slide
gomodifytags
*ast.TypeSpec
*ast.StructType
*ast.FieldList *ast.Field
[]*ast.Ident
*ast.Ident
ast.BasicLit
our parsed AST
start line: 8
end line: 10

View Slide
gomodifytags
*ast.TypeSpec
*ast.StructType
*ast.FieldList *ast.Field
[]*ast.Ident
*ast.Ident
ast.BasicLit
struct we're
going to modify
start line: 8
end line: 10
*ast.StructType

View Slide
gomodifytags
*ast.StructType
*ast.FieldList

View Slide
gomodifytags
*ast.StructType
6
7
8
9
10
11
12
*ast.Field
*ast.Field
*ast.Field
*ast.Field
*ast.Field

View Slide
gomodifytags
*ast.StructType
*ast.Field
[]*ast.Ident
*ast.Ident
*ast.BasicLit

View Slide
type Example struct {
Foo string `json:"foo"`
}
gomodifytags
*ast.StructType
*ast.Field
[]*ast.Ident
*ast.Ident
*ast.BasicLit

View Slide
type Example struct {
Foo string `json:"foo"
}
gomodifytags
*ast.StructType
*ast.Field
Foo
string
`json:"foo"`

View Slide
type Example struct {
Foo string `json:"foo"`
}
gomodifytags
*ast.StructType
*ast.Field
Foo
string
`json:"foo"`

View Slide
type Example struct {
Foo string `json:"bar"
}
gomodifytags
*ast.StructType
*ast.Field
Foo
string
`json:"foo"
`json:"bar"`
type Example struct {
Foo string `json:"foo"`
}

View Slide
How do we rewrite a
struct tag?

View Slide
src := `package main
type Example struct {
Foo string` + " `json:\"foo\"` }"
fset := token.NewFileSet()
file, err := parser.ParseFile(fset, "demo", src, parser.ParseComments)
if err != nil {
panic(err)
}
ast.Inspect(file, func(x ast.Node) bool {
s, ok := x.(*ast.StructType)
if !ok {
return true
}
for _, field := range s.Fields.List {
// found field!
field.Tag.Value = `json:"bar"`
}
return false
})
After ﬁnding a ﬁeld,
replace the value

View Slide
src := `package main
type Example struct {
Foo string` + " `json:\"foo\"` }"
fset := token.NewFileSet()
file, err := parser.ParseFile(fset, "demo", src, parser.ParseComments)
if err != nil {
panic(err)
}
ast.Inspect(file, func(x ast.Node) bool {
s, ok := x.(*ast.StructType)
if !ok {
return true
}
for _, field := range s.Fields.List {
// found field!
field.Tag.Value = `json:"bar"`
}
return false
})
Tag: `json:"foo"`
Tag: `json:"bar"`
After ﬁnding a ﬁeld,
replace the value

View Slide
type Example struct {
DiskSize string
}
gomodifytags
*ast.StructType
*ast.Field
DiskSize
string

View Slide
type Example struct {
DiskSize string
}
gomodifytags
*ast.StructType
*ast.Field
DiskSize
string

View Slide
gomodifytags
*ast.StructType
*ast.Field
DiskSize
string
json:"disk_size"
process()
type Example struct {
DiskSize string
}
type Example struct {
DiskSize string `json:"disk_size"`
}

View Slide
src := `package main
type Example struct {
Foo string` + " `json:\"foo\"` }"
fset := token.NewFileSet()
file, err := parser.ParseFile(fset, "demo", src, parser.ParseComments)
if err != nil {
panic(err)
}
ast.Inspect(file, func(x ast.Node) bool {
s, ok := x.(*ast.StructType)
if !ok {
return true
}
for _, field := range s.Fields.List {
// found field!
field.Tag.Value = process(field)
}
return false
})
tags = c.removeTags(tags)
tags, err = c.removeTagOptions(tags)
if err != nil {
return "", err
}
tags = c.clearTags(tags)
tags = c.clearOptions(tags)
tags, err = c.addTags(fieldName, tags)
if err != nil {
return "", err
}
tags, err = c.addTagOptions(tags)
if err != nil {
return "", err
}
if c.sort {
sort.Sort(tags)
}

View Slide
gomodifytags
*ast.StructType
8
9
10
*ast.Field
*ast.Field
*ast.Field
*ast.Field
*ast.Field
select ﬁeld between
start and end lines ...
Modify overview

View Slide
gomodifytags
*ast.StructType
8
9
10
*ast.Field
*ast.Field
*ast.Field
*ast.Field
*ast.Field
... and rewrite selected
ﬁelds tags
8
9
10
*ast.Field
*ast.Field
*ast.Field
*ast.Field
*ast.Field
rewrite
Modify overview

View Slide
package main
type Example struct {
Foo string
}
parse ﬁnd
modify
gomodifytags
modify

View Slide
func (c *config) rewriteFields(node ast.Node) (ast.Node, error) {
var rewriteErr error
rewriteFunc := func(n ast.Node) bool {
x, ok := n.(*ast.StructType)
if !ok {
return true
}
for _, f := range x.Fields.List {
// process each field
// ...
}
return true
}
ast.Inspect(node, rewriteFunc)
return node, rewriteErr
}

View Slide
func (c *config) rewriteFields(node ast.Node) (ast.Node, error) {
var rewriteErr error
rewriteFunc := func(n ast.Node) bool {
x, ok := n.(*ast.StructType)
if !ok {
return true
}
for _, f := range x.Fields.List {
// process each field
// ...
}
return true
}
ast.Inspect(node, rewriteFunc)
return node, rewriteErr
}

View Slide
func (c *config) rewriteFields(node ast.Node) (ast.Node, error) {
var rewriteErr error
rewriteFunc := func(n ast.Node) bool {
x, ok := n.(*ast.StructType)
if !ok {
return true
}
for _, f := range x.Fields.List {
// process each field
// ...
}
return true
}
ast.Inspect(node, rewriteFunc)
return node, rewriteErr
}

View Slide
for _, f := range x.Fields.List {
line := c.fset.Position(f.Pos()).Line
if !(c.start <= line && line <= c.end) {
continue
}
if f.Tag == nil {
f.Tag = &ast.BasicLit{}
}
// ...
}

View Slide
for _, f := range x.Fields.List {
line := c.fset.Position(f.Pos()).Line
if !(c.start <= line && line <= c.end) {
continue
}
if f.Tag == nil {
f.Tag = &ast.BasicLit{}
}
// ...
}

View Slide
for _, f := range x.Fields.List {
line := c.fset.Position(f.Pos()).Line
if !(c.start <= line && line <= c.end) {
continue
}
if f.Tag == nil {
f.Tag = &ast.BasicLit{}
}
// ...
}

View Slide
for _, f := range x.Fields.List {
fieldName := ""
if len(f.Names) != 0 {
fieldName = f.Names[0].Name
}
if f.Names == nil {
ident, ok := f.Type.(*ast.Ident)
if !ok {
continue // anonymous field
}
fieldName = ident.Name
}
res, err := c.process(fieldName, f.Tag.Value)
if err != nil {
rewriteErr = err
return true
}
f.Tag.Value = res
}

View Slide
for _, f := range x.Fields.List {
fieldName := ""
if len(f.Names) != 0 {
fieldName = f.Names[0].Name
}
if f.Names == nil {
ident, ok := f.Type.(*ast.Ident)
if !ok {
continue // anonymous field
}
fieldName = ident.Name
}
res, err := c.process(fieldName, f.Tag.Value)
if err != nil {
rewriteErr = err
return true
}
f.Tag.Value = res
}

View Slide
for _, f := range x.Fields.List {
fieldName := ""
if len(f.Names) != 0 {
fieldName = f.Names[0].Name
}
if f.Names == nil {
ident, ok := f.Type.(*ast.Ident)
if !ok {
continue // anonymous field
}
fieldName = ident.Name
}
res, err := c.process(fieldName, f.Tag.Value)
if err != nil {
rewriteErr = err
return true
}
f.Tag.Value = res
}

View Slide
Processing the tags

View Slide
func (c *config) process(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
}
// process tags ...
res := tags.String()
if res != "" {
res = quote(tags.String())
}
return res, nil
}

View Slide
func (c *config) process(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
}
// process tags ...
res := tags.String()
if res != "" {
res = quote(tags.String())
}
return res, nil
}

View Slide
func (c *config) process(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
}
// process tags ...
res := tags.String()
if res != "" {
res = quote(tags.String())
}
return res, nil
}

View Slide
func (c *config) process(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
}
// process tags ...
res := tags.String()
if res != "" {
res = quote(tags.String())
}
return res, nil
}
tags = c.removeTags(tags)
tags, err = c.removeTagOptions(tags)
if err != nil {
return "", err
}
tags = c.clearTags(tags)
tags = c.clearOptions(tags)
tags, err = c.addTags(fieldName, tags)
if err != nil {
return "", err
}
tags, err = c.addTagOptions(tags)
if err != nil {
return "", err
}
if c.sort {
sort.Sort(tags)
}

View Slide
func (c *config) process(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
}
// process tags ...
res := tags.String()
if res != "" {
res = quote(tags.String())
}
return res, nil
}
tags = c.removeTags(tags)
tags, err = c.removeTagOptions(tags)
if err != nil {
return "", err
}
tags = c.clearTags(tags)
tags = c.clearOptions(tags)
tags, err = c.addTags(fieldName, tags)
if err != nil {
return "", err
}
tags, err = c.addTagOptions(tags)
if err != nil {
return "", err
}
if c.sort {
sort.Sort(tags)
}

View Slide
func (c *config) process(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
}
// process tags ...
res := tags.String()
if res != "" {
res = quote(tags.String())
}
return res, nil
}

View Slide
func (c *config) rewriteFields(node ast.Node) (ast.Node, error) {
var rewriteErr error
rewriteFunc := func(n ast.Node) bool {
x, ok := n.(*ast.StructType)
if !ok {
return true
}
for _, f := range x.Fields.List {
// process each field
// ...
}
return true
}
ast.Inspect(node, rewriteFunc)
return node, rewriteErr
}

View Slide
package main
type Example struct {
Foo string
}
parse ﬁnd
modify
format
gomodifytags

View Slide
Output the result

View Slide
func main() {
var cfg config
node = cfg.parse()
start, end = cfg.findSelection(node)
rewritten = cfg.rewrite(node, start, end)
out = cfg.format(rewritten)
fmt.Println(out)
}
1. Fetch conﬁguration settings
2. Parse content
3. Find selection
4. Modify the struct tag
5. Output the result

View Slide
gomodifytags
ast.Node (modiﬁed)

View Slide
gomodifytags
ast.Node (modiﬁed)
go/format
Pass the modiﬁed node
to go/format

View Slide
gomodifytags
ast.Node (modiﬁed)
go/format
... and output the result
to stdout
package main
type Example struct {
Foo string `json:"foo"`
}

View Slide
package main
type Server struct {
Name string
Port int
EnableLogs bool
BaseDomain string
Credentials struct {
Username string
Password string
}
}
package main
type Server struct {
Name string `json:"name"`
Port int `json:"port"`
EnableLogs bool `json:"enable_logs"`
BaseDomain string `json:"base_domain"`
Credentials struct {
Username string `json:"username"`
Password string `json:"password"`
} `json:"credentials"`
}
Input Output
$ gomodifytags
-ﬁle example.go
-struct Server
-add-tags json

View Slide
gomodifytags
ast.Node (modiﬁed)
go/format
Also has support for
custom JSON output
{
"start": 3,
"end": 5,
"lines": [
"type Example struct {",
" Foo string `json:\"foo\"`",
"}"
]
}

View Slide
package main
type Server struct {
Name string
Port int
EnableLogs bool
BaseDomain string
Credentials struct {
Username string
Password string
}
}
{
"start": 3,
"end": 12,
"lines": [
"type Server struct {",
" Name string `xml:\"name\"`",
" Port int `xml:\"port\"`",
" EnableLogs bool `xml:\"enable_logs\"`",
" BaseDomain string `xml:\"base_domain\"`",
" Credentials struct {",
" Username string `xml:\"username\"`",
" Password string `xml:\"password\"`",
" } `xml:\"credentials\"`",
"}"
]
}
Input
JSON Output
$ gomodifytags
-ﬁle example.go
-struct Server
-add-tags json
-format json

View Slide
Why stdout?
• by default, it means "dry-run"
• immediate feedback
• tools can redirect the output
• composable (gomodifytags myﬁle.go > newﬁle.go)

View Slide
func (c *config) format(file ast.Node) (string, error) {
switch c.output {
case "source":
// return formatted source
case "json":
// return only changes in json
default:
return "", fmt.Errorf("unknown output mode: %s", c.output)
}
}
Output the result

View Slide
func (c *config) format(file ast.Node) (string, error) {
switch c.output {
case "source":
// return formatted source
case "json":
// return only changes in json
default:
return "", fmt.Errorf("unknown output mode: %s", c.output)
}
}
Output the result

View Slide
var buf bytes.Buffer
err := format.Node(&buf, c.fset, file)
if err != nil {
return "", err
}
if c.write {
err = ioutil.WriteFile(c.file, buf.Bytes(), 0)
if err != nil {
return "", err
}
}
return buf.String(), nil
Source ﬁle

View Slide
var buf bytes.Buffer
err := format.Node(&buf, c.fset, file)
if err != nil {
return "", err
}
if c.write {
err = ioutil.WriteFile(c.file, buf.Bytes(), 0)
if err != nil {
return "", err
}
}
return buf.String(), nil
Source ﬁle

View Slide
var buf bytes.Buffer
err := format.Node(&buf, c.fset, file)
if err != nil {
return "", err
}
if c.write {
err = ioutil.WriteFile(c.file, buf.Bytes(), 0)
if err != nil {
return "", err
}
}
return buf.String(), nil
Source ﬁle

View Slide
var buf bytes.Buffer
err := format.Node(&buf, c.fset, file)
if err != nil {
return "", err
}
var lines []string
scanner := bufio.NewScanner(bytes.NewBufferString(buf.String()))
for scanner.Scan() {
lines = append(lines, scanner.Text())
}
if c.start > len(lines) {
return "", errors.New("line selection is invalid")
}
...
JSON output

View Slide
var buf bytes.Buffer
err := format.Node(&buf, c.fset, file)
if err != nil {
return "", err
}
var lines []string
scanner := bufio.NewScanner(bytes.NewBufferString(buf.String()))
for scanner.Scan() {
lines = append(lines, scanner.Text())
}
if c.start > len(lines) {
return "", errors.New("line selection is invalid")
}
...
JSON output

View Slide
out := &output{
Start: c.start,
End: c.end,
Lines: lines[c.start-1 : c.end],
}
o, err := json.MarshalIndent(out, "", " ")
if err != nil {
return "", err
}
return string(o), nil
JSON output (cont.)

View Slide
out := &output{
Start: c.start,
End: c.end,
Lines: lines[c.start-1 : c.end],
}
o, err := json.MarshalIndent(out, "", " ")
if err != nil {
return "", err
}
return string(o), nil
JSON output (cont.)

View Slide
package main
type Example struct {
Foo string
}
parse ﬁnd
modify
gomodifytags
format
format

View Slide
package main
type Example struct {
Foo string
}
parse ﬁnd
modify
gomodifytags
format
Overview

View Slide
Overview

View Slide
gomodifytags

View Slide
gomodifytags
package main
type Example struct {
Foo string
}

View Slide
package main
type Example struct {
Foo string
}
-ﬁle example.go
-struct Example
-add-tags json
gomodifytags

View Slide
package main
type Example struct {
Foo string
}
parse
gomodifytags

View Slide
package main
type Example struct {
Foo string
}
parse ﬁnd
gomodifytags

View Slide
package main
type Example struct {
Foo string
}
parse ﬁnd
modify
gomodifytags

View Slide
package main
type Example struct {
Foo string
}
parse ﬁnd
modify
format
gomodifytags

View Slide
package main
type Example struct {
Foo string
}
package main
type Example struct {
Foo string `json:"foo"`
}
parse ﬁnd
modify
format
gomodifytags

View Slide
Demo time

View Slide
Built from the ground up for editors
• selecting structs based on offset or range of lines
• write result to stdout or ﬁle
• json output for easy parsing
• support for unsaved buffers
• individual cli ﬂags for all features

View Slide
Supported editors
• vim with vim-go
• atom with go-plus (thanks Zac Bergquist)
• vscode with vscode-go (thanks Ramya Rao)
• emacs - WIP (https://github.com/syohex/emacs-go-add-tags/issues/
6)

View Slide
Fixed bugs

View Slide
Recap
• A single tool to rule all editors
• Easy maintenance
• Free of bugs due stdlib tooling (go/parser family)
• Happy and productive users

View Slide
Thanks!
Fatih Arslan
@fatih
@fatih
[email protected]

View Slide