goheader

README

go-header

Simple go source code linter providing checks for copyrgiht headers.

Features

Feature	Status	Details
✅ Copyright Headers	✔️	Supports all standard formats
✅ Parallel Processing	✔️	Processes files concurrently
✅ Comment Support	✔️	//, /* */, /* * */
✅ Go/Analysis	✔️	Native Go tooling integration
✅ Regex Customization	✔️	User-defined pattern matching
✅ Automatic Year Checks	✔️	Validates & updates copyright years
✅ Auto-Fix Files	✔️	In-place header corrections
✅ Go/Template Support	✔️	go templates can be used in headers
✍️ Multi-License Support	❌	In progress

Installation

For installation you can simply use go install.

go install github.com/denis-tingaikin/go-header/cmd/go-header@latest

Usage

  -V    print version and exit
  -all
        no effect (deprecated)
  -c int
        display offending line with this many lines of context (default -1)
  -config string
        path to config file (default ".go-header.yml")
  -cpuprofile string
        write CPU profile to this file
  -debug string
        debug flags, any subset of "fpstv"
  -diff
        with -fix, don't update the files, but print a unified diff
  -fix
        apply all suggested fixes
  -flags
        print analyzer flags in JSON
  -json
        emit JSON output
  -memprofile string
        write memory profile to this file
  -source
        no effect (deprecated)
  -tags string
        no effect (deprecated)
  -test
        indicates whether test files should be analyzed, too (default true)
  -trace string
        write trace log to this file
  -v    no effect (deprecated)

Configuration

To configuring .go-header.yml linter you simply need to fill the next fields:

---
template: # expects header template string.
template-path: # expects path to file with license header string. 
values: # expects `const` or `regexp` node with values where values is a map string to string.
  const:
    key1: value1 # const value just checks equality. Note `key1` should be used in template string as {{ key1 }} or {{ KEY1 }}.
  regexp:
    key2: value2 # regexp value just checks regex match. The value should be a valid regexp pattern. Note `key2` should be used in template string as {{ key2 }} or {{ KEY2 }}.

Where values also can be used recursively. Example:

values:
  const:
    key1: "value" 
  regexp:
    key2: "{{key1}} value1" # Reads as regex pattern "value value1"

Bult-in values

• MOD_YEAR - Returns the year when the file was modified.
• MOD_YEAR-RANGE - Returns a year-range where the range starts from the year when the file was modified.
• YEAR - Expects current year. Example header value: 2020. Example of template using: {{YEAR}} or {{year}}.
• YEAR-RANGE - Expects any valid year interval or current year. Example header value: 2020 or 2000-2020. Example of template using: {{year-range}} or {{YEAR-RANGE}}.

Execution

go-header linter expects file paths on input. If you want to run go-header only on diff files, then you can use this command:

go-header ./...

Setup example

Step 1

Create configuration file .go-header.yml in the root of project.

---
vars:
  DOMAIN: sales|product
  MY_COMPANY: {{ .DOMAIN }}.mycompany.com
template: |
  {{ .MY_COMPANY }}
  SPDX-License-Identifier: Apache-2.0

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at:

  	  http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.

Step 2

Run go-header ./...

Documentation

Index

• func New(settings *Settings) *analysis.Analyzer
• type Analyzer
  • func (a *Analyzer) Analyze(path string, file *ast.File) (*analysis.Diagnostic, error)
  • func (a *Analyzer) Run(pass *analysis.Pass) (any, error)
• type CommentStyleType
• type Config
  • func Parse(data string) (*Config, error)
  • func (c *Config) FillSettings(settings *Settings) error
  • func (c *Config) GetDelims() string
  • func (c *Config) GetParallel() int
  • func (c *Config) GetTemplate() (string, error)
  • func (c *Config) GetValues() (map[string]Value, error)
• type ConstValue
  • func (c *ConstValue) Calculate(values map[string]Value) error
  • func (c *ConstValue) Clone() Value
  • func (c *ConstValue) Get() string
  • func (c *ConstValue) Raw() string
  • func (c *ConstValue) String() string
• type Experimental
• type RegexpValue
  • func (r *RegexpValue) Calculate(values map[string]Value) error
  • func (r *RegexpValue) Clone() Value
  • func (r *RegexpValue) Get() string
  • func (r *RegexpValue) Raw() string
  • func (r *RegexpValue) String() string
• type Result
• type Settings
  • func (c *Settings) SetDelimiters(left, right string)
  • func (c *Settings) SetTemplate(tmplStr, tmplPath string) error
  • func (c *Settings) SetValues(values map[string]string)
• type Value

Functions

func New

func New(settings *Settings) *analysis.Analyzer

Types

type Analyzer

type Analyzer struct {
	Settings *Settings
}

func (*Analyzer) Analyze

func (a *Analyzer) Analyze(path string, file *ast.File) (*analysis.Diagnostic, error)

func (*Analyzer) Run

func (a *Analyzer) Run(pass *analysis.Pass) (any, error)

type CommentStyleType

type CommentStyleType int

const (
	DoubleSlash CommentStyleType = iota
	MultiLine
	MultiLineStar
)

type Config

type Config struct {
	// Values is map of values. Supports two types 'const` and `regexp`. Values can be used recursively.
	// DEPRECATED: Use Vars instead.
	Values map[string]map[string]string `yaml:"values"`
	// Template is template for checking. Uses values.
	Template string `yaml:"template"`
	// TemplatePath path to the template file. Useful if need to load the template from a specific file.
	TemplatePath string `yaml:"template-path"`
	// Vars is map of values. Values can be used recursively.
	Vars map[string]string `yaml:"vars"`
	// Delims represents a string marker for values. The default is "{{}}".
	Delims string `yaml:"delims"`
	// Parallel means a number of goroutines to proccess files. Default runtime.NumCPU()
	Parallel int `yaml:"parallel"`
	// Experimental is config for enabling experimental / work in progress features.
	Experimental Experimental `yaml:"experimental"`
}

Config represents go-header linter setup parameters

func Parse

func Parse(data string) (*Config, error)

func (*Config) FillSettings

func (c *Config) FillSettings(settings *Settings) error

func (*Config) GetDelims

func (c *Config) GetDelims() string

func (*Config) GetParallel

func (c *Config) GetParallel() int

func (*Config) GetTemplate

func (c *Config) GetTemplate() (string, error)

func (*Config) GetValues

func (c *Config) GetValues() (map[string]Value, error)

type ConstValue

type ConstValue struct {
	RawValue, Value string
}

func (*ConstValue) Calculate

func (c *ConstValue) Calculate(values map[string]Value) error

func (*ConstValue) Clone

func (c *ConstValue) Clone() Value

func (*ConstValue) Get

func (c *ConstValue) Get() string

func (*ConstValue) Raw

func (c *ConstValue) Raw() string

func (*ConstValue) String

func (c *ConstValue) String() string

type Experimental

type Experimental struct {
	// CGO if true enables support for cgo files. Currently positioning of issues can be float.
	CGO bool `yaml:"cgo"`
}

Experimental represents config params for enabling experimental / work in progress features

type RegexpValue

type RegexpValue struct {
	RawValue, Value string
}

func (*RegexpValue) Calculate

func (r *RegexpValue) Calculate(values map[string]Value) error

func (*RegexpValue) Clone

func (r *RegexpValue) Clone() Value

func (*RegexpValue) Get

func (r *RegexpValue) Get() string

func (*RegexpValue) Raw

func (r *RegexpValue) Raw() string

func (*RegexpValue) String

func (r *RegexpValue) String() string

type Result

type Result struct {
	Fix        string
	End, Start token.Pos
}

type Settings

type Settings struct {
	Values                map[string]Value
	Template              string
	LeftDelim, RightDelim string
	Parallel              int
	CGO                   bool
}

func (*Settings) SetDelimiters

func (c *Settings) SetDelimiters(left, right string)

func (*Settings) SetTemplate

func (c *Settings) SetTemplate(tmplStr, tmplPath string) error

func (*Settings) SetValues

func (c *Settings) SetValues(values map[string]string)

type Value

type Value interface {
	Calculate(map[string]Value) error
	Get() string
	Raw() string
	Clone() Value
}