chglog

package module

v0.0.0-...-a7ea4b9 Latest Latest Go to latest Published: May 12, 2020 License: MIT Imports: 13 Imported by: 0

Details

Valid go.mod file
Redistributable license
Tagged version
Stable version
Learn more about best practices

Repository

github.com/Ya3Sh/git-chglog

Links

Open Source Insights

README ¶

git-chglog

CHANGELOG generator implemented in Go (Golang).
Anytime, anywhere, Write your CHANGELOG.

Features

♻ High portability
- It works with single binary. Therefore, any project (environment) can be used.
🔰 Simple usability
- The CLI usage is very simple and has low learning costs.
- For example, the simplest command is $ git-chglog.
🚀 High flexibility
- Commit message format and ...
- CHANGELOG's style (Template) and ...
- etc ...

How it works

git-chglog internally uses the git command to get data to include in the CHANGELOG.
The basic steps are as follows.

Get all the tags.
Get the commits contained between tagA and tagB.
Execute with all tags corresponding to tag query that were specified in Step 1 and 2.

Getting Started

We will start with installation and introduce the steps up to the automatic generation of the configuration file and template.

Installation

Please install git-chglog in a way that matches your environment.

Homebrew (for macOS users)

$ brew tap git-chglog/git-chglog
$ brew install git-chglog

Scoop (for Windows users)

$ scoop install git-chglog

Go users

$ go get -u github.com/git-chglog/git-chglog/cmd/git-chglog

If you are using another platform, you can download a binary from the releases page and place it in a directory in your $PATH.

Test Installation

You can check with the following command whether the git-chglog command was included in a directory that is in your $PATH.

$ git-chglog --version
# outputs the git-chglog version

Quick Start

git-chglog requires configuration files and templates to generate a CHANGELOG.

However, it is a waste of time to create configuration files and templates from scratch.

Therefore we recommend using the --init option which will create them interactively 👍

$ git-chglog --init

init option demo

You are now ready for configuration files and templates!

Let's immediately generate a CHANGELOG of your project.
By doing the following simple command, Markdown for your CHANGELOG is displayed on stdout.

$ git-chglog

Use -o (--output) option if you want to output to a file instead of stdout.

$ git-chglog -o CHANGELOG.md

You now know basic usage of git-chglog!

In order to make a better CHANGELOG, please refer to the following document and customize it.

CLI Usage

$ git-chglog --help

USAGE:
  git-chglog [options] <tag query>

    There are the following specification methods for <tag query>.

    1. <old>..<new> - Commit contained in <old> tags from <new>.
    2. <name>..     - Commit from the <name> to the latest tag.
    3. ..<name>     - Commit from the oldest tag to <name>.
    4. <name>       - Commit contained in <name>.

OPTIONS:
  --init                                generate the git-chglog configuration file in interactive
  --config value, -c value              specifies a different configuration file to pick up (default: ".chglog/config.yml")
  --output value, -o value              output path and filename for the changelogs. If not specified, output to stdout
  --next-tag value                      treat unreleased commits as specified tags (EXPERIMENTAL)
  --silent                              disable stdout output
  --no-color                            disable color output [$NO_COLOR]
  --no-emoji                            disable emoji output [$NO_EMOJI]
  --no-case                             disable case sensitive filters
  --tag-filter-pattern value, -p value  regular expression of tag filter. Is specified, only matched tags will be picked
  --help, -h                            show help
  --version, -v                         print the version

EXAMPLE:

  $ git-chglog

    If <tag query> is not specified, it corresponds to all tags.
    This is the simplest example.

  $ git-chglog 1.0.0..2.0.0

    The above is a command to generate CHANGELOG including commit of 1.0.0 to 2.0.0.

  $ git-chglog 1.0.0

    The above is a command to generate CHANGELOG including commit of only 1.0.0.

  $ git-chglog $(git describe --tags $(git rev-list --tags --max-count=1))

    The above is a command to generate CHANGELOG with the commit included in the latest tag.

  $ git-chglog --output CHANGELOG.md

    The above is a command to output to CHANGELOG.md instead of standard output.

  $ git-chglog --config custom/dir/config.yml

    The above is a command that uses a configuration file placed other than ".chglog/config.yml".

`tag query`

You can specify which commits to include in the generation of CHANGELOG using <tag query>.

The table below shows Query patterns and summaries, and Query examples.

Query	Description	Example
`<old>..<new>`	Commit contained in `<new>` tags from `<old>`.	`$ git-chglog 1.0.0..2.0.0`
`<name>..`	Commit from the `<name>` to the latest tag.	`$ git-chglog 1.0.0..`
`..<name>`	Commit from the oldest tag to `<name>`.	`$ git-chglog ..2.0.0`
`<name>`	Commit contained in `<name>`.	`$ git-chglog 1.0.0`

Configuration

The git-chglog configuration is a yaml file. The default location is .chglog/config.yml.

Below is a complete list that you can use with git-chglog.

bin: git
style: ""
template: CHANGELOG.tpl.md
info:
  title: CHANGELOG
  repository_url: https://github.com/git-chglog/git-chglog

options:
  commits:
    filters:
      Type:
        - feat
    sort_by: Scope

  commit_groups:
    group_by: Type
    sort_by: Title
    title_maps:
      feat: Features

  header:
    pattern: "<regexp>"
    pattern_maps:
      - PropName

  issues:
    prefix:
      - #

  refs:
    actions:
      - Closes
      - Fixes

  merges:
    pattern: "^Merge branch '(\\w+)'$"
    pattern_maps:
      - Source

  reverts:
    pattern: "^Revert \"([\\s\\S]*)\"$"
    pattern_maps:
      - Header

  notes:
    keywords:
      - BREAKING CHANGE

`bin`

Git execution command.

Required	Type	Default	Description
N	String	`"git"`	-

`style`

CHANGELOG style. Automatic linking of issues and notices, initial value setting such as merges etc. are done automatically.

Required	Type	Default	Description
N	String	`"none"`	Should be `"github"` `"gitlab"` `"bitbucket"` `"none"`

`template`

Path for the template file. It is specified by a relative path from the setting file. Absolute paths are also ok.

Required	Type	Default	Description
N	String	`"CHANGELOG.tpl.md"`	-

`info`

Metadata for CHANGELOG. Depending on Style, it is sometimes used in processing, so it is recommended to specify it.

Key	Required	Type	Default	Description
`title`	N	String	`"CHANGELOG"`	Title of CHANGELOG.
`repository_url`	N	String	none	URL of git repository.

`options`

Options used to process commits.

`options.commits`

Options concerning the acquisition and sort of commits.

Key	Required	Type	Default	Description
`filters`	N	Map in List	none	Filter by using `Commit` properties and values. Filtering is not done by specifying an empty value.
`sort_by`	N	String	`"Scope"`	Property name to use for sorting `Commit`. See Commit.

`options.commit_groups`

Options for groups of commits.

Key	Required	Type	Default	Description
`group_by`	N	String	`"Type"`	Property name of `Commit` to be grouped into `CommitGroup`. See CommitGroup.
`sort_by`	N	String	`"Title"`	Property name to use for sorting `CommitGroup`. See CommitGroup.
`title_maps`	N	Map in List	none	Map for `CommitGroup` title conversion.

`options.header`

This option is used for parsing the commit header.

Key	Required	Type	Default	Description
`pattern`	Y	String	none	A regular expression to use for parsing the commit header.
`pattern_maps`	Y	List	none	A rule for mapping the result of `HeaderPattern` to the property of `Commit`. See Commit.

`options.issues`

This option is used to detect issues.

Key	Required	Type	Default	Description
`prefix`	N	List	none	Prefix used for issues. (e.g. `#`, `#gh-`)

`options.refs`

This option is for parsing references.

Key	Required	Type	Default	Description
`actions`	N	List	none	Word list of `Ref.Action`. See Ref.

`options.merges`

Options to detect and parse merge commits.

Key	Required	Type	Default	Description
`pattern`	N	String	none	Similar to `options.header.pattern`.
`pattern_maps`	N	List	none	Similar to `options.header.pattern_maps`.

`options.reverts`

Options to detect and parse revert commits.

Key	Required	Type	Default	Description
`pattern`	N	String	none	Similar to `options.header.pattern`.
`pattern_maps`	N	List	none	Similar to `options.header.pattern_maps`.

`options.notes`

Options to detect notes contained in commit bodies.

Key	Required	Type	Default	Description
`keywords`	N	List	none	Keyword list to find `Note`. A semicolon is a separator, like `<keyword>:` (e.g. `BREAKING CHANGE`).

Templates

The git-chglog template uses the text/template package. For basic usage please refer to the following.

text/template

If you are not satisfied with the prepared template please try customizing one.

The basic templates are as follows.

Example:

{{ if .Versions -}}
<a name="unreleased"></a>
## [Unreleased]

{{ if .Unreleased.CommitGroups -}}
{{ range .Unreleased.CommitGroups -}}
### {{ .Title }}
{{ range .Commits -}}
- {{ if .Scope }}**{{ .Scope }}:** {{ end }}{{ .Subject }}
{{ end }}
{{ end -}}
{{ end -}}
{{ end -}}

{{ range .Versions }}
<a name="{{ .Tag.Name }}"></a>
## {{ if .Tag.Previous }}[{{ .Tag.Name }}]{{ else }}{{ .Tag.Name }}{{ end }} - {{ datetime "2006-01-02" .Tag.Date }}
{{ range .CommitGroups -}}
### {{ .Title }}
{{ range .Commits -}}
- {{ if .Scope }}**{{ .Scope }}:** {{ end }}{{ .Subject }}
{{ end }}
{{ end -}}

{{- if .RevertCommits -}}
### Reverts
{{ range .RevertCommits -}}
- {{ .Revert.Header }}
{{ end }}
{{ end -}}

{{- if .MergeCommits -}}
### Pull Requests
{{ range .MergeCommits -}}
- {{ .Header }}
{{ end }}
{{ end -}}

{{- if .NoteGroups -}}
{{ range .NoteGroups -}}
### {{ .Title }}
{{ range .Notes }}
{{ .Body }}
{{ end }}
{{ end -}}
{{ end -}}
{{ end -}}

{{- if .Versions }}
[Unreleased]: {{ .Info.RepositoryURL }}/compare/{{ $latest := index .Versions 0 }}{{ $latest.Tag.Name }}...HEAD
{{ range .Versions -}}
{{ if .Tag.Previous -}}
[{{ .Tag.Name }}]: {{ $.Info.RepositoryURL }}/compare/{{ .Tag.Previous.Name }}...{{ .Tag.Name }}
{{ end -}}
{{ end -}}
{{ end -}}

See the godoc RenderData documentation for available variables.

Supported Styles

Name	Status	Features
GitHub	✅	Mentions automatic link. Automatic link to references.
GitLab	✅	Mentions automatic link. Automatic link to references.
Bitbucket	✅	Mentions automatic link. Automatic link to references.

📝 Even with styles that are not yet supported, it is possible to make ordinary CHANGELOG.

FAQ

Why do not you output files by default?

This is not for the purpose of completely automating the generation of CHANGELOG files, it is only for assisting generation.

It is ideal to describe everything included in CHANGELOG in your commits. But actually it is very difficult to do it perfectly.

There are times when you need to edit the generated output to write a great CHANGELOG.

By displaying it on the standard output, it makes it easy to change the contents.

Can I commit CHANGELOG changes before creating tags?

Yes, it can be solved by using the --next-tag flag.

For example, let's say you want to upgrade your project to 2.0.0.
You can create CHANGELOG containing 2.0.0 as follows.

$ git-chglog --next-tag 2.0.0 -o CHANGELOG.md
$ git commit -am "release 2.0.0"
$ git tag 2.0.0

The point to notice is that before actually creating a tag with git, it is conveying the next version with --next-tag 👍

This is a step that is necessary for project operation in many cases.

Can I generate a CHANGELOG based on certain tags?

Yes, it can be solved by use the --tag-filter-pattern flag.

For example, the following command will only include tags starting with "v":

$ git-chglog --tag-filter-pattern '^v'

TODO

Windows Support
More styles (GitHub, GitLab, Bitbucket 🎉)
Snippetization of configuration files (improvement of reusability)
More test test test ... (and example)

Thanks

git-chglog is inspired by conventional-changelog. Thank you!

Contributing

We alway welcome your contributions 👏

Development

Fork (https://github.com/git-chglog/git-chglog) 🎉
Create a feature branch ☕
Run test suite with the $ make test command and confirm that it passes ⚡
Commit your changes 📝
Rebase your local changes against the master branch 💡
Create new Pull Request 💌

Bugs, feature requests and comments are more than welcome in the issues.

Feedback

I would like to make git-chglog a better tool.
The goal is to be able to use in various projects.

Therefore, your feedback is very useful.
I am very happy to tell you your opinions on Issues and PR ❤

CHANGELOG

See CHANGELOG.md

git-chglog/artwork - Assets for git-chglog.

License

MIT © tsuyoshiwada

Documentation ¶

Overview ¶

Package chglog implements main logic for the CHANGELOG generate.

Example ¶

gen := NewGenerator(&Config{
	Bin:        "git",
	WorkingDir: ".",
	Template:   "CHANGELOG.tpl.md",
	Info: &Info{
		Title:         "CHANGELOG",
		RepositoryURL: "https://github.com/git-chglog/git-chglog",
	},
	Options: &Options{
		CommitFilters: map[string][]string{
			"Type": []string{
				"feat",
				"fix",
			},
		},
		CommitSortBy:      "Scope",
		CommitGroupBy:     "Type",
		CommitGroupSortBy: "Title",
		CommitGroupTitleMaps: map[string]string{
			"feat": "Features",
			"fix":  "Bug Fixes",
		},
		HeaderPattern: "^(\\w*)(?:\\(([\\w\\$\\.\\-\\*\\s]*)\\))?\\:\\s(.*)$",
		HeaderPatternMaps: []string{
			"Type",
			"Scope",
			"Subject",
		},
		IssuePrefix: []string{
			"#",
			"gh-",
		},
		RefActions:   []string{},
		MergePattern: "^Merge pull request #(\\d+) from (.*)$",
		MergePatternMaps: []string{
			"Ref",
			"Source",
		},
		RevertPattern: "^Revert \"([\\s\\S]*)\"$",
		RevertPatternMaps: []string{
			"Header",
		},
		NoteKeywords: []string{
			"BREAKING CHANGE",
		},
	},
})

buf := &bytes.Buffer{}
err := gen.Generate(buf, "")

if err != nil {
	log.Fatalln(err)
}

fmt.Println(buf.String())

Index ¶

type Author
type BitbucketProcessor
- func (p *BitbucketProcessor) Bootstrap(config *Config)
- func (p *BitbucketProcessor) ProcessCommit(commit *Commit) *Commit
type Commit
type CommitGroup
type Committer
type Config
type Generator
- func NewGenerator(config *Config) *Generator
- func (gen *Generator) Generate(w io.Writer, query string) error
type GitHubProcessor
- func (p *GitHubProcessor) Bootstrap(config *Config)
- func (p *GitHubProcessor) ProcessCommit(commit *Commit) *Commit
type GitLabProcessor
- func (p *GitLabProcessor) Bootstrap(config *Config)
- func (p *GitLabProcessor) ProcessCommit(commit *Commit) *Commit
type Hash
type Info
type Merge
type Note
type NoteGroup
type Options
type Processor
type Ref
type RelateTag
type RenderData
type Revert
type Tag
type Unreleased
type Version

Examples ¶

Package

Constants ¶

This section is empty.

Variables ¶

This section is empty.

Functions ¶

This section is empty.

Types ¶

type Author ¶

type Author struct {
	Name  string
	Email string
	Date  time.Time
}

Author of commit

type BitbucketProcessor ¶

type BitbucketProcessor struct {
	Host string // Host name used for link destination. Note: You must include the protocol (e.g. "https://bitbucket.org")
	// contains filtered or unexported fields
}

BitbucketProcessor is optimized for CHANGELOG used in Bitbucket

The following processing is performed

Mentions automatic link (@tsuyoshiwada -> [@tsuyoshiwada](https://bitbucket.org/tsuyoshiwada/))
Automatic link to references (#123 -> [#123](https://bitbucket.org/owner/repo/issues/123/))

func (*BitbucketProcessor) Bootstrap ¶

func (p *BitbucketProcessor) Bootstrap(config *Config)

Bootstrap ...

func (*BitbucketProcessor) ProcessCommit ¶

func (p *BitbucketProcessor) ProcessCommit(commit *Commit) *Commit

ProcessCommit ...

type Commit ¶

type Commit struct {
	Hash      *Hash
	Author    *Author
	Committer *Committer
	Merge     *Merge  // If it is not a merge commit, `nil` is assigned
	Revert    *Revert // If it is not a revert commit, `nil` is assigned
	Refs      []*Ref
	Notes     []*Note
	Mentions  []string // Name of the user included in the commit header or body
	Header    string   // (e.g. `feat(core): Add new feature`)
	Type      string   // (e.g. `feat`)
	Scope     string   // (e.g. `core`)
	Subject   string   // (e.g. `Add new feature`)
	Body      string
}

Commit data

type CommitGroup ¶

type CommitGroup struct {
	RawTitle string // Raw title before conversion (e.g. `build`)
	Title    string // Conversion by `CommitGroupTitleMaps` option, or title converted in title case (e.g. `Build`)
	Commits  []*Commit
}

CommitGroup is a collection of commits grouped according to the `CommitGroupBy` option

type Committer ¶

type Committer struct {
	Name  string
	Email string
	Date  time.Time
}

Committer of commit

type Config ¶

type Config struct {
	Bin        string // Git execution command
	WorkingDir string // Working directory
	Template   string // Path for template file. If a relative path is specified, it depends on the value of `WorkingDir`.
	Info       *Info
	Options    *Options
}

Config for generating CHANGELOG

type Generator ¶

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

Generator of CHANGELOG

func NewGenerator ¶

func NewGenerator(config *Config) *Generator

NewGenerator receives `Config` and create an new `Generator`

func (*Generator) Generate ¶

func (gen *Generator) Generate(w io.Writer, query string) error

Generate gets the commit based on the specified tag `query` and writes the result to `io.Writer`

tag `query` can be specified with the following rule

<old>..<new> - Commit contained in `<new>` tags from `<old>` (e.g. `1.0.0..2.0.0`)
<tagname>..  - Commit from the `<tagname>` to the latest tag (e.g. `1.0.0..`)
..<tagname>  - Commit from the oldest tag to `<tagname>` (e.g. `..1.0.0`)
<tagname>    - Commit contained in `<tagname>` (e.g. `1.0.0`)

type GitHubProcessor ¶

type GitHubProcessor struct {
	Host string // Host name used for link destination. Note: You must include the protocol (e.g. "https://github.com")
	// contains filtered or unexported fields
}

GitHubProcessor is optimized for CHANGELOG used in GitHub

The following processing is performed

Mentions automatic link (@tsuyoshiwada -> [@tsuyoshiwada](https://github.com/tsuyoshiwada))
Automatic link to references (#123 -> [#123](https://github.com/owner/repo/issues/123))

func (*GitHubProcessor) Bootstrap ¶

func (p *GitHubProcessor) Bootstrap(config *Config)

Bootstrap ...

func (*GitHubProcessor) ProcessCommit ¶

func (p *GitHubProcessor) ProcessCommit(commit *Commit) *Commit

ProcessCommit ...

type GitLabProcessor ¶

type GitLabProcessor struct {
	Host string // Host name used for link destination. Note: You must include the protocol (e.g. "https://gitlab.com")
	// contains filtered or unexported fields
}

GitLabProcessor is optimized for CHANGELOG used in GitLab

The following processing is performed

Mentions automatic link (@tsuyoshiwada -> [@tsuyoshiwada](https://gitlab.com/tsuyoshiwada))
Automatic link to references (#123 -> [#123](https://gitlab.com/owner/repo/issues/123))

func (*GitLabProcessor) Bootstrap ¶

func (p *GitLabProcessor) Bootstrap(config *Config)

Bootstrap ...

func (*GitLabProcessor) ProcessCommit ¶

func (p *GitLabProcessor) ProcessCommit(commit *Commit) *Commit

ProcessCommit ...

type Hash ¶

type Hash struct {
	Long  string
	Short string
}

Hash of commit

type Info ¶

type Info struct {
	Title         string // Title of CHANGELOG
	RepositoryURL string // URL of git repository
}

Info is metadata related to CHANGELOG

type Merge ¶

type Merge struct {
	Ref    string
	Source string
}

Merge info for commit

type Note ¶

type Note struct {
	Title string // (e.g. `BREAKING CHANGE`)
	Body  string // `Note` content body
}

Note of commit

type NoteGroup ¶

type NoteGroup struct {
	Title string
	Notes []*Note
}

NoteGroup is a collection of `Note` grouped by titles

type Options ¶

type Options struct {
	Processor            Processor
	NextTag              string              // Treat unreleased commits as specified tags (EXPERIMENTAL)
	TagFilterPattern     string              // Filter tag by regexp
	NoCaseSensitive      bool                // Filter commits in a case insensitive way
	CommitFilters        map[string][]string // Filter by using `Commit` properties and values. Filtering is not done by specifying an empty value
	CommitSortBy         string              // Property name to use for sorting `Commit` (e.g. `Scope`)
	CommitGroupBy        string              // Property name of `Commit` to be grouped into `CommitGroup` (e.g. `Type`)
	CommitGroupSortBy    string              // Property name to use for sorting `CommitGroup` (e.g. `Title`)
	CommitGroupTitleMaps map[string]string   // Map for `CommitGroup` title conversion
	HeaderPattern        string              // A regular expression to use for parsing the commit header
	HeaderPatternMaps    []string            // A rule for mapping the result of `HeaderPattern` to the property of `Commit`
	IssuePrefix          []string            // Prefix used for issues (e.g. `#`, `gh-`)
	RefActions           []string            // Word list of `Ref.Action`
	MergePattern         string              // A regular expression to use for parsing the merge commit
	MergePatternMaps     []string            // Similar to `HeaderPatternMaps`
	RevertPattern        string              // A regular expression to use for parsing the revert commit
	RevertPatternMaps    []string            // Similar to `HeaderPatternMaps`
	NoteKeywords         []string            // Keyword list to find `Note`. A semicolon is a separator, like `<keyword>:` (e.g. `BREAKING CHANGE`)
	Path                 string              // Path filter
}

Options is an option used to process commits

type Processor ¶

type Processor interface {
	Bootstrap(*Config)
	ProcessCommit(*Commit) *Commit
}

Processor hooks the internal processing of `Generator`, it is possible to adjust the contents

type Ref ¶

type Ref struct {
	Action string // (e.g. `Closes`)
	Ref    string // (e.g. `123`)
	Source string // (e.g. `owner/repository`)
}

Ref is abstract data related to commit. (e.g. `Issues`, `Pull Request`)

type RelateTag ¶

type RelateTag struct {
	Name    string
	Subject string
	Date    time.Time
}

RelateTag is sibling tag data of `Tag`. If you give `Tag`, the reference hierarchy will be deepened. This struct is used to minimize the hierarchy of references

type RenderData ¶

type RenderData struct {
	Info       *Info
	Unreleased *Unreleased
	Versions   []*Version
}

RenderData is the data passed to the template

type Revert ¶

type Revert struct {
	Header string
}

Revert info for commit

type Tag ¶

type Tag struct {
	Name     string
	Subject  string
	Date     time.Time
	Next     *RelateTag
	Previous *RelateTag
}

Tag is data of git-tag

type Unreleased ¶

type Unreleased struct {
	CommitGroups  []*CommitGroup
	Commits       []*Commit
	MergeCommits  []*Commit
	RevertCommits []*Commit
	NoteGroups    []*NoteGroup
}

Unreleased is unreleased commit dataset

type Version ¶

type Version struct {
	Tag           *Tag
	CommitGroups  []*CommitGroup
	Commits       []*Commit
	MergeCommits  []*Commit
	RevertCommits []*Commit
	NoteGroups    []*NoteGroup
}

Version is a tag-separeted datset to be included in CHANGELOG

Source Files ¶

View all Source files

Directories ¶

Path	Synopsis
cmd
git-chglog command

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL

README ¶

git-chglog

Table of Contents

Features

How it works

Getting Started

Installation

Homebrew (for macOS users)

Scoop (for Windows users)

Go users

Test Installation

Quick Start

CLI Usage

tag query

Configuration

bin

style

template

info

options

options.commits

options.commit_groups

options.header

options.issues

options.refs

options.merges

options.reverts

options.notes

Templates

Supported Styles

FAQ

TODO

Thanks

Contributing

Development

Feedback

CHANGELOG

Related Projects

License

Documentation ¶

Overview ¶

Index ¶

Examples ¶

Constants ¶

Variables ¶

Functions ¶

Types ¶

type Author ¶

type BitbucketProcessor ¶

func (*BitbucketProcessor) Bootstrap ¶

func (*BitbucketProcessor) ProcessCommit ¶

type Commit ¶

type CommitGroup ¶

type Committer ¶

type Config ¶

type Generator ¶

func NewGenerator ¶

func (*Generator) Generate ¶

type GitHubProcessor ¶

func (*GitHubProcessor) Bootstrap ¶

func (*GitHubProcessor) ProcessCommit ¶

type GitLabProcessor ¶

func (*GitLabProcessor) Bootstrap ¶

func (*GitLabProcessor) ProcessCommit ¶

type Hash ¶

type Info ¶

type Merge ¶

type Note ¶

type NoteGroup ¶

type Options ¶

type Processor ¶

type Ref ¶

type RelateTag ¶

type RenderData ¶

type Revert ¶

type Tag ¶

type Unreleased ¶

type Version ¶

Source Files ¶

Directories ¶

`tag query`

`bin`

`style`

`template`

`info`

`options`

`options.commits`

`options.commit_groups`

`options.header`

`options.issues`

`options.refs`

`options.merges`

`options.reverts`

`options.notes`