tagalign

README

Go Tag Align

TagAlign is used to align and sort tags in Go struct. It can make the struct more readable and easier to maintain.

For example, this struct

type FooBar struct {
    Foo    int    `json:"foo" validate:"required"`
    Bar    string `json:"bar" validate:"required"`
    FooFoo int8   `json:"foo_foo" validate:"required"`
    BarBar int    `json:"bar_bar" validate:"required"`
    FooBar struct {
    Foo    int    `json:"foo" yaml:"foo" validate:"required"`
    Bar222 string `json:"bar222" validate:"required" yaml:"bar"`
    } `json:"foo_bar" validate:"required"`
    BarFoo    string `json:"bar_foo" validate:"required"`
    BarFooBar string `json:"bar_foo_bar" validate:"required"`
}

can be aligned to:

type FooBar struct {
    Foo    int    `json:"foo"     validate:"required"`
    Bar    string `json:"bar"     validate:"required"`
    FooFoo int8   `json:"foo_foo" validate:"required"`
    BarBar int    `json:"bar_bar" validate:"required"`
    FooBar struct {
        Foo    int    `json:"foo"    yaml:"foo"          validate:"required"`
        Bar222 string `json:"bar222" validate:"required" yaml:"bar"`
    } `json:"foo_bar" validate:"required"`
    BarFoo    string `json:"bar_foo"     validate:"required"`
    BarFooBar string `json:"bar_foo_bar" validate:"required"`
}

Usage

By default tagalign will only align tags, but not sort them. But alignment and sort feature can work together or separately.

• As a Golangci Linter (Recommended)

  Tagalign is a built-in linter in Golangci Lint since v1.53.

  Note: In order to have the best experience, add the --fix flag to golangci-lint to enable the autofix feature.

• Standalone Mode

  Install it using GO or download it here.

  go install github.com/4meepo/tagalign/cmd/tagalign@latest
  

  Run it in your terminal.

  # Only align tags.
  tagalign -fix {package path}
  # Only sort tags with fixed order.
  tagalign -fix -noalign -sort -order "json,xml" {package path}
  # Align and sort together.
  tagalign -fix -sort -order "json,xml" {package path}
  # Align and sort together in strict style.
  tagalign -fix -sort -order "json,xml" -strict {package path}
  

Advanced Features

Sort Tag

In addition to alignment, it can also sort tags with fixed order. If we enable sort with fixed order json,xml, the following code

type SortExample struct {
    Foo    int `json:"foo,omitempty" yaml:"bar" xml:"baz" binding:"required" gorm:"column:foo" zip:"foo" validate:"required"`
    Bar    int `validate:"required"  yaml:"foo" xml:"bar" binding:"required" json:"bar,omitempty" gorm:"column:bar" zip:"bar" `
    FooBar int `gorm:"column:bar" validate:"required"   xml:"bar" binding:"required" json:"bar,omitempty"  zip:"bar" yaml:"foo"`
}

will be sorted and aligned to:

type SortExample struct {
    Foo    int `json:"foo,omitempty" xml:"baz" binding:"required" gorm:"column:foo" validate:"required" yaml:"bar" zip:"foo"`
    Bar    int `json:"bar,omitempty" xml:"bar" binding:"required" gorm:"column:bar" validate:"required" yaml:"foo" zip:"bar"`
    FooBar int `json:"bar,omitempty" xml:"bar" binding:"required" gorm:"column:bar" validate:"required" yaml:"foo" zip:"bar"`
}

The fixed order is json,xml, so the tags json and xml will be sorted and aligned first, and the rest tags will be sorted and aligned in the dictionary order.

Strict Style

Sometimes, you may want to align your tags in strict style. In this style, the tags will be sorted and aligned in the dictionary order, and the tags with the same name will be aligned together. For example, the following code

type StrictStyleExample struct {
    Foo int ` xml:"baz" yaml:"bar" zip:"foo" binding:"required" gorm:"column:foo"  validate:"required"`
    Bar int `validate:"required" gorm:"column:bar"  yaml:"foo" xml:"bar" binding:"required" json:"bar,omitempty" `
}

will be aligned to

type StrictStyleExample struct {
    Foo int `binding:"required" gorm:"column:foo"                      validate:"required" xml:"baz" yaml:"bar" zip:"foo"`
    Bar int `binding:"required" gorm:"column:bar" json:"bar,omitempty" validate:"required" xml:"bar" yaml:"foo"`
}

⚠️Note: The strict style can't run without the align or sort feature enabled.

References

Golang AST Visualizer

Create New Golang CI Linter

Autofix Example

Integrating

Documentation

Index

• func NewAnalyzer(options ...Option) *analysis.Analyzer
• type Helper
  • func (w *Helper) Issues() []Issue
  • func (w *Helper) Process(pass *analysis.Pass)
• type InlineFix
• type Issue
  • func Run(pass *analysis.Pass, options ...Option) []Issue
• type Mode
• type Option
  • func WithAlign(enabled bool) Option
  • func WithMode(mode Mode) Option
  • func WithSort(fixedOrder ...string) Option
  • func WithStrictStyle() Option
• type Style

Functions

func NewAnalyzer

func NewAnalyzer(options ...Option) *analysis.Analyzer

Types

type Helper

type Helper struct {
	// contains filtered or unexported fields
}

func (*Helper) Issues

func (w *Helper) Issues() []Issue

Issues returns all issues found by the analyzer. It is used to integrate with golangci-lint.

func (*Helper) Process

func (w *Helper) Process(pass *analysis.Pass)

type InlineFix

type InlineFix struct {
	StartCol  int // zero-based
	Length    int
	NewString string
}

type Issue

type Issue struct {
	Pos       token.Position
	Message   string
	InlineFix InlineFix
}

Issue is used to integrate with golangci-lint's inline auto fix.

func Run

func Run(pass *analysis.Pass, options ...Option) []Issue

type Mode

type Mode int

const (
	StandaloneMode Mode = iota
	GolangciLintMode
)

type Option

type Option func(*Helper)

func WithAlign

func WithAlign(enabled bool) Option

WithAlign configure whether enable tags align. Align is enabled by default.

func WithMode

func WithMode(mode Mode) Option

WithMode specify the mode of tagalign.

func WithSort

func WithSort(fixedOrder ...string) Option

WithSort enable tags sort. fixedOrder specify the order of tags, the other tags will be sorted by name. Sory is disabled by default.

func WithStrictStyle

func WithStrictStyle() Option

WithStrictStyle configure whether enable strict style. StrictStyle is disabled by default. Note: StrictStyle must be used with WithAlign(true) and WithSort(...) together, or it will be ignored.

type Style

type Style int

const (
	DefaultStyle Style = iota
	StrictStyle
)