fix(deps): update module gopkg.in/yaml.v2 to v3 (#246)

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>

.chglog/CHANGELOG.tpl.md

@@ -1,22 +1,56 @@
-{{range .Versions}}
-<a name="{{.Tag.Name}}"></a>
-## {{if .Tag.Previous}}[{{.Tag.Name}}]({{$.Info.RepositoryURL}}/compare/{{.Tag.Previous.Name}}...{{.Tag.Name}}){{else}}{{.Tag.Name}}{{end}} ({{datetime "2006-01-02" .Tag.Date}})
-{{range .CommitGroups}}
-### {{.Title}}
-{{range .Commits}}
-* {{.Subject}}{{end}}
-{{end}}{{if .RevertCommits}}
+{{ 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}}
+{{ range .RevertCommits -}}
+- {{ .Revert.Header }}
+{{ end }}
+{{ end -}}
+
+{{- if .MergeCommits -}}
 ### Pull Requests
-{{range .MergeCommits}}
-* {{.Header}}{{end}}
-{{end}}{{range .NoteGroups}}
-### {{.Title}}
-{{range .Notes}}
-{{.Body}}
-{{end}}
-{{end}}
-{{end}}
+{{ 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 -}}

.chglog/config.yml

@@ -11,16 +11,19 @@ options:
         - fix
         - perf
         - refactor
+        - chore
   commit_groups:
     title_maps:
       feat: Features
       fix: Bug Fixes
       perf: Performance Improvements
       refactor: Code Refactoring
+      chore: Chores
   header:
-    pattern: "^(\\w*)\\:\\s(.*)$"
+    pattern: "^(\\w*)(?:\\(([\\w\\$\\.\\-\\*\\s]*)\\))?\\:\\s(.*)$"
     pattern_maps:
       - Type
+      - Scope
       - Subject
   notes:
     keywords:

.github/renovate.json

@@ -0,0 +1,25 @@
+{
+  "semanticCommits": true,
+  "prHourlyLimit": 5,
+  "reviewersFromCodeOwners": true,
+  "labels": [
+    "dependencies"
+  ],
+  "extends": [
+    "config:base",
+    "group:allNonMajor"
+  ],
+  "postUpdateOptions": ["gomodTidy"],
+  "major": {
+    "labels": [
+      "dependencies",
+      "major"
+    ]
+  },
+  "minor": {
+    "labels": [
+      "dependencies",
+      "minor"
+    ]
+  }
+}

.github/workflows/ci.yml

@@ -0,0 +1,105 @@
+name: ci
+
+on:
+  pull_request:
+    types: ["opened", "synchronize"]
+    paths-ignore:
+      - "README.md"
+  push:
+    branches:
+      - master
+    paths-ignore:
+      - "README.md"
+
+env:
+  GO_VERSION: "1.24"
+  GOLANGCI_VERSION: "v1.64.8"
+
+jobs:
+  tests:
+    runs-on: ubuntu-20.04
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: ${{ env.GO_VERSION }}
+
+      - name: Run tests
+        run: make test
+
+      - name: Install goveralls
+        run: |
+          go install github.com/mattn/goveralls@latest
+          echo $GOPATH
+          ls -lash $GOPATH
+          which goveralls
+        working-directory: /tmp
+
+      - name: Send coverage
+        run: goveralls -coverprofile=cover.out -service=github
+        env:
+          COVERALLS_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  lint:
+    runs-on: ubuntu-20.04
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: ${{ env.GO_VERSION }}
+
+      - name: golangci-lint
+        uses: golangci/golangci-lint-action@v6
+        with:
+          version: ${{ env.GOLANGCI_VERSION }}
+
+  docker-image-tests:
+    runs-on: ubuntu-20.04
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+      
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: ${{ env.GO_VERSION }}
+
+      - name: Run tests
+        run: make build
+      
+      - name: Test docker image
+        run: |
+          docker build -t git-chglog:ci-build .
+          docker run -v ${GITHUB_WORKSPACE}:/workdir -w /workdir git-chglog:ci-build > ${GITHUB_WORKSPACE}/ci-build.md
+          head ${GITHUB_WORKSPACE}/ci-build.md
+
+  goreleaser-test:
+    runs-on: ubuntu-20.04
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: ${{ env.GO_VERSION }}
+
+      - name: Run GoReleaser
+        uses: goreleaser/goreleaser-action@v4
+        with:
+          version: latest
+          args: release --clean --skip=publish --snapshot

.github/workflows/publish.yml

@@ -0,0 +1,34 @@
+name: publish
+
+on:
+  push:
+    branches:
+      - master
+
+env:
+  GO_VERSION: "1.24"
+  DOCKER_REGISTRY: "quay.io"
+
+jobs:
+  docker:
+    runs-on: ubuntu-20.04
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: ${{ env.GO_VERSION }}
+
+      - name: Login to Docker Registry
+        uses: docker/login-action@v2
+        with:
+          registry: ${{ env.DOCKER_REGISTRY }}
+          username: ${{ secrets.QUAY_IO_USER }}
+          password: ${{ secrets.QUAY_IO_TOKEN }}
+
+      - name: Build and Push docker image
+        run: DOCKER_TAG=edge make docker push

.github/workflows/release.yml

@@ -0,0 +1,39 @@
+name: release
+
+on:
+  push:
+    tags:
+      - "*"
+
+env:
+  GO_VERSION: "1.24"
+  DOCKER_REGISTRY: "quay.io"
+
+jobs:
+  goreleaser:
+    runs-on: ubuntu-20.04
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: ${{ env.GO_VERSION }}
+
+      - name: Login to Docker Registry
+        uses: docker/login-action@v2
+        with:
+          registry: ${{ env.DOCKER_REGISTRY }}
+          username: ${{ secrets.QUAY_IO_USER }}
+          password: ${{ secrets.QUAY_IO_TOKEN }}
+
+      - name: Run GoReleaser
+        uses: goreleaser/goreleaser-action@v4
+        with:
+          version: latest
+          args: release --clean
+        env:
+          GITHUB_TOKEN: ${{ secrets.GORELEASER_TOKEN }}

.gitignore

@@ -10,6 +10,7 @@
 *.dll
 *.so
 *.dylib
+/git-chglog
 
 # Test binary, build with `go test -c`
 *.test
@@ -20,17 +21,27 @@
 # Project-local glide cache, RE: https://github.com/Masterminds/glide/issues/736
 .glide/
 
+# in https://github.com/git-chglog/git-chglog/pull/85 we moved from dep to gomod
+vendor
+
 ### macOS ###
 *.DS_Store
 .AppleDouble
 .LSOverride
 
 # Icon must end with two \r
-Icon
+Icon
 
 # Thumbnails
 ._*
 
+# Intellij IDEA
+*.iml
+.idea
+
+# vscode IDE
+.vscode
+
 # Files that might appear in the root of a volume
 .DocumentRevisions-V100
 .fseventsd

.golangci.yml

@@ -0,0 +1,103 @@
+# https://golangci-lint.run/usage/configuration/
+run:
+  timeout: 10m
+
+  tests: true
+
+linters-settings:
+  gofmt:
+    # simplify code: gofmt with `-s` option, true by default
+    simplify: true
+
+  goimports:
+    # put imports beginning with prefix after 3rd-party packages;
+    # it's a comma-separated list of prefixes
+    local-prefixes: github.com/git-chglog/git-chglog
+
+  gocyclo:
+    # minimal code complexity to report, 30 by default (but we recommend 10-20)
+    min-complexity: 10
+
+  dupl:
+    # tokens count to trigger issue, 150 by default
+    threshold: 100
+
+  goconst:
+    # minimal length of string constant, 3 by default
+    min-len: 3
+    # minimal occurrences count to trigger, 3 by default
+    min-occurrences: 5
+
+  lll:
+    # tab width in spaces. Default to 1.
+    tab-width: 1
+
+  unparam:
+    # Inspect exported functions, default is false. Set to true if no external program/library imports your code.
+    # XXX: if you enable this setting, unparam will report a lot of false-positives in text editors:
+    # if it's called for subdir of a project it can't find external interfaces. All text editor integrations
+    # with golangci-lint call it on a directory with the changed file.
+    check-exported: false
+
+  nakedret:
+    # make an issue if func has more lines of code than this setting and it has naked returns; default is 30
+    max-func-lines: 30
+
+  prealloc:
+    # XXX: we don't recommend using this linter before doing performance profiling.
+    # For most programs usage of prealloc will be a premature optimization.
+
+    # Report preallocation suggestions only on simple loops that have no returns/breaks/continues/gotos in them.
+    # True by default.
+    simple: true
+    range-loops: true # Report preallocation suggestions on range loops, true by default
+    for-loops: false # Report preallocation suggestions on for loops, false by default
+
+  misspell:
+    locale: US
+
+linters:
+  enable:
+    - gosimple 
+    - staticcheck
+    - unused
+    - gocyclo
+    - goconst
+    - goimports
+    - gofmt  # We enable this as well as goimports for its simplify mode.
+    - prealloc
+    - unconvert
+    - misspell
+    - nakedret
+    - dupl
+    #- depguard TODO fix later
+
+  presets:
+    - bugs
+    - unused
+  fast: false
+
+issues:
+  # Excluding configuration per-path and per-linter
+  exclude-rules:
+    # Exclude some linters from running on tests files.
+    - path: _test(ing)?\.go
+      linters:
+        - gocyclo
+        - errcheck
+        - dupl
+        - gosec
+        - unparam
+        - testifylint
+        - depguard
+
+  # Show only new issues: if there are unstaged changes or untracked files,
+  # only those changes are analyzed, else only changes in HEAD~ are analyzed.
+  # It's a super-useful option for integration of golangci-lint into existing
+  # large codebase. It's not practical to fix all existing issues at the moment
+  # of integration: much better don't allow issues in new code.
+  # Default is false.
+  new: false
+
+  # Maximum count of issues with the same text. Set to 0 to disable. Default is 3.
+  max-same-issues: 0

.goreleaser.yml

@@ -0,0 +1,57 @@
+version: 2
+
+# This is an example .goreleaser.yml file with some sane defaults.
+# Make sure to check the documentation at http://goreleaser.com
+project_name: git-chglog
+
+before:
+  hooks:
+    # You may remove this if you don't use go modules.
+    - go mod download
+
+builds:
+  - dir: cmd/git-chglog
+    env:
+      - CGO_ENABLED=0
+    goos:
+      - linux
+      - windows
+      - darwin
+    goarch:
+      - 386
+      - amd64
+      - arm
+      - arm64
+
+archives:
+  - format_overrides:
+      - goos: windows
+        format: zip
+
+checksum:
+  name_template: "checksums.txt"
+
+changelog:
+  sort: desc
+  filters:
+    exclude:
+      - "^Merge"
+
+snapshot:
+  name_template: "{{ .Tag }}-next"
+
+dockers:
+  - image_templates:
+      - "quay.io/git-chglog/git-chglog:{{ .RawVersion }}"
+      - "quay.io/git-chglog/git-chglog:latest"
+
+brews:
+  - repository:
+      owner: git-chglog
+      name: homebrew-git-chglog
+    homepage: "https://godoc.org/github.com/git-chglog/git-chglog"
+    description: "CHANGELOG generator implemented in Go (Golang)."
+    test: |
+      system "#{bin}/git-chglog --help"
+    install: |
+      bin.install "git-chglog"

.travis.yml

@@ -1,22 +0,0 @@
-language: go
-sudo: false
-notifications:
-  email: false
-go:
-  - 1.9
-before_install:
-  - go get github.com/mattn/goveralls
-  - go get github.com/mitchellh/gox
-  - go get github.com/tcnksm/ghr
-before_script:
-  - export TZ=Asia/Tokyo
-  - sudo timedatectl set-timezone Asia/Tokyo
-  - timedatectl
-script:
-  - make test
-  - goveralls -service=travis-ci
-branches:
-  only:
-    - master
-after_success:
-  - ./scripts/release.sh

CHANGELOG.md

@@ -1,41 +1,461 @@
-# CHANGELOG
+<a name="unreleased"></a>
+## [Unreleased]
+
+
+<a name="v0.15.4"></a>
+## [v0.15.4] - 2023-02-15
+### Bug Fixes
+- release process ([#231](https://github.com/git-chglog/git-chglog/issues/231))
+- **ci:** add integration test with docker image ([#226](https://github.com/git-chglog/git-chglog/issues/226))
+- **deps:** update module github.com/urfave/cli/v2 to v2.24.3 ([#227](https://github.com/git-chglog/git-chglog/issues/227))
+- **deps:** update module github.com/fatih/color to v1.14.1 ([#224](https://github.com/git-chglog/git-chglog/issues/224))
+- **deps:** update all non-major dependencies ([#223](https://github.com/git-chglog/git-chglog/issues/223))
+
+### Chores
+- new release due to shecksum mismatch. Closes [#232](https://github.com/git-chglog/git-chglog/issues/232)
+- update changelog for v0.15.3
+- update changelog for v0.15.3
+- bump docker/login-action to v2. Closes [#206](https://github.com/git-chglog/git-chglog/issues/206)
+- bump goreleaser/goreleaser-action to v4. Closes [#208](https://github.com/git-chglog/git-chglog/issues/208)
+
+
+<a name="v0.15.2"></a>
+## [v0.15.2] - 2023-01-22
+### Bug Fixes
+- typo in readme ([#196](https://github.com/git-chglog/git-chglog/issues/196))
+- **deps:** update module gopkg.in/yaml.v2 to v3 ([#221](https://github.com/git-chglog/git-chglog/issues/221))
+
+### Chores
+- update changelog for v0.15.2
+- update changelog for v0.15.2
+- update Go install instructions ([#205](https://github.com/git-chglog/git-chglog/issues/205))
+- bump golang to 1.19 ([#218](https://github.com/git-chglog/git-chglog/issues/218))
+- **deps:** update all non-major dependencies ([#220](https://github.com/git-chglog/git-chglog/issues/220))
+
+
+<a name="v0.15.1"></a>
+## [v0.15.1] - 2021-12-14
+### Bug Fixes
+- **deps:** update all non-major dependencies ([#179](https://github.com/git-chglog/git-chglog/issues/179))
+- **deps:** update module github.com/andygrunwald/go-jira to v1.14.0 ([#167](https://github.com/git-chglog/git-chglog/issues/167))
+- **deps:** update module github.com/alecaivazis/survey/v2 to v2.2.16 ([#165](https://github.com/git-chglog/git-chglog/issues/165))
+- **deps:** update module github.com/alecaivazis/survey/v2 to v2.2.15 ([#163](https://github.com/git-chglog/git-chglog/issues/163))
+
+### Chores
+- update changelog for v0.15.1
+- ignore .vscode
+- **deps:** update all non-major dependencies docker tags ([#168](https://github.com/git-chglog/git-chglog/issues/168))
+
+
+<a name="v0.15.0"></a>
+## [v0.15.0] - 2021-07-09
+### Bug Fixes
+- **deps:** update module github.com/alecaivazis/survey/v2 to v2.2.14 ([#158](https://github.com/git-chglog/git-chglog/issues/158))
+- **deps:** update module github.com/alecaivazis/survey/v2 to v2.2.13 ([#156](https://github.com/git-chglog/git-chglog/issues/156))
+- **deps:** update module github.com/fatih/color to v1.12.0 ([#150](https://github.com/git-chglog/git-chglog/issues/150))
+- **deps:** update module github.com/fatih/color to v1.11.0 ([#149](https://github.com/git-chglog/git-chglog/issues/149))
+- **deps:** update module github.com/alecaivazis/survey/v2 to v2.2.12 ([#147](https://github.com/git-chglog/git-chglog/issues/147))
+
+### Chores
+- update changelog for v0.15.0
+- **deps:** update alpine docker tag to v3.14.0 ([#153](https://github.com/git-chglog/git-chglog/issues/153))
+
+### Features
+- Automatic link for gitlab merge requests ([#160](https://github.com/git-chglog/git-chglog/issues/160))
+
+
+<a name="v0.14.2"></a>
+## [v0.14.2] - 2021-04-16
+### Bug Fixes
+- add CommitGroupTitleOrder back to Options ([#143](https://github.com/git-chglog/git-chglog/issues/143))
+
+### Chores
+- update changelog for v0.14.2
+- **deps:** update alpine docker tag to v3.13.5 ([#144](https://github.com/git-chglog/git-chglog/issues/144))
+
+
+<a name="v0.14.1"></a>
+## [v0.14.1] - 2021-04-13
+### Bug Fixes
+- **template:** address regression in string functions for template engine ([#142](https://github.com/git-chglog/git-chglog/issues/142))
+
+### Chores
+- update changelog for v0.14.1
+- add docker target to Makefile ([#138](https://github.com/git-chglog/git-chglog/issues/138))
+- add make release target ([#130](https://github.com/git-chglog/git-chglog/issues/130))
+- **deps:** update alpine docker tag to v3.13.4 ([#136](https://github.com/git-chglog/git-chglog/issues/136))
+
+### Features
+- add docker image on release and master ([#135](https://github.com/git-chglog/git-chglog/issues/135))
+
+
+<a name="v0.14.0"></a>
+## [v0.14.0] - 2021-03-28
+### Chores
+- update changelog for v0.14.0
+- **CHANGELOG:** regenerate CHANGELOG with type-scope and KAC template ([#129](https://github.com/git-chglog/git-chglog/issues/129))
+
+### Features
+- add sprig template functions support ([#131](https://github.com/git-chglog/git-chglog/issues/131))
+- add `--sort [TYPE]` flag  ([#78](https://github.com/git-chglog/git-chglog/issues/78))
+
+
+<a name="v0.13.0"></a>
+## [v0.13.0] - 2021-03-23
+### Chores
+- update changelog for v0.13.0
+- use ldflags to pass version to build process ([#127](https://github.com/git-chglog/git-chglog/issues/127))
+
+### Features
+- add support for rendering .Body after .Subject as part of list ([#121](https://github.com/git-chglog/git-chglog/issues/121))
+
+
+<a name="v0.12.0"></a>
+## [v0.12.0] - 2021-03-20
+### Chores
+- update changelog for v0.12.0
+- bumps version to v0.12.0
+- bump golang to 1.16 ([#118](https://github.com/git-chglog/git-chglog/issues/118))
+- **ci:** add golangci-lint action and apply linting changes ([#120](https://github.com/git-chglog/git-chglog/issues/120))
+
+### Features
+- allow tag sorting by semver ([#124](https://github.com/git-chglog/git-chglog/issues/124))
+
+### BREAKING CHANGE
+
+`JiraIssueId` has been renamed to `JiraIssueID`. This impacts the value for `pattern_maps` in `config.yml`.
+
+* chore(ci): add golangci-lint action
+
+* chore(lint): address errcheck lint failures
+
+* chore(lint): address misspell lint failures
+
+* chore(lint): address gocritic lint failures
+
+* chore(lint): address golint lint failures
+
+* chore(lint): address structcheck lint failures
+
+* chore(lint): address gosimple lint failures
+
+* chore(lint): address gofmt lint failures
+
+* chore(ci): port to official golangci-lint github action
+
+* Update golangci configuration for better coverage
+
+
+<a name="v0.11.2"></a>
+## [v0.11.2] - 2021-03-13
+### Bug Fixes
+- `--template` and `--repository-url` flags not being used ([#119](https://github.com/git-chglog/git-chglog/issues/119))
+
+### Chores
+- update changelog for v0.11.2
+- bumps version to v0.11.2
+
+
+<a name="v0.11.1"></a>
+## [v0.11.1] - 2021-03-12
+### Bug Fixes
+- **short flags:** correctly define cli flags with shorthands ([#117](https://github.com/git-chglog/git-chglog/issues/117))
+
+### Chores
+- update readme and changelog for v0.11.1
+- bumps version to v0.11.1
+
+
+<a name="v0.11.0"></a>
+## [v0.11.0] - 2021-03-12
+### Bug Fixes
+- **deps:** update all non-major dependencies ([#115](https://github.com/git-chglog/git-chglog/issues/115))
+- **deps:** update module gopkg.in/kyokomi/emoji.v1 to github.com/kyokomi/emoji/v2 ([#109](https://github.com/git-chglog/git-chglog/issues/109))
+- **deps:** update module github.com/urfave/cli to v2 ([#107](https://github.com/git-chglog/git-chglog/issues/107))
+- **deps:** update module github.com/stretchr/testify to v1.7.0 ([#103](https://github.com/git-chglog/git-chglog/issues/103))
+- **deps:** update module gopkg.in/alecaivazis/survey.v1 to github.com/AlecAivazis/survey/v2 ([#108](https://github.com/git-chglog/git-chglog/issues/108))
+- **init:** support OptionAnswer form in survey/v2 ([#113](https://github.com/git-chglog/git-chglog/issues/113))
+
+### Chores
+- update changelog for v0.11.0
+- bumps version to v0.11.0
+- **deps:** add initial renovatebot configuration ([#102](https://github.com/git-chglog/git-chglog/issues/102))
+
+### Features
+- add Jira integration ([#52](https://github.com/git-chglog/git-chglog/issues/52))
+- **flag:** --path filtering - refs ([#62](https://github.com/git-chglog/git-chglog/issues/62)). Closes [#35](https://github.com/git-chglog/git-chglog/issues/35)
+
+
+<a name="v0.10.0"></a>
+## [v0.10.0] - 2021-01-16
+### Bug Fixes
+- ignore only git-chglog binary in root and not subfolder
+
+### Chores
+- update changelog for v0.10.0
+- bumps version to v0.10.0
+- sorts changelog desc and excludes Merge commits
+- fix Makefile typo ([#82](https://github.com/git-chglog/git-chglog/issues/82))
+- **asdf:** add asdf install support to README ([#79](https://github.com/git-chglog/git-chglog/issues/79))
+
+### Features
+- Adds 'Custom' sort_type to CommitGroup ([#69](https://github.com/git-chglog/git-chglog/issues/69))
+- enable tag_filter_pattern in config options ([#72](https://github.com/git-chglog/git-chglog/issues/72))
+- switch from dep to go mod ([#85](https://github.com/git-chglog/git-chglog/issues/85))
+- add option to filter commits in a case insensitive way
+- add upperFirst template function
+- Add emoji format and some formatters in variables
+
+### Reverts
+- Revert "ci: switches to personal GH Token for brew cross repo releases"
+- ci: switches to personal GH Token for brew cross repo releases
+
+### Pull Requests
+- Merge pull request [#65](https://github.com/git-chglog/git-chglog/issues/65) from barryib/case-sensitive-option
+- Merge pull request [#59](https://github.com/git-chglog/git-chglog/issues/59) from momotaro98/feature/add-emoji-template-in-init
+- Merge pull request [#66](https://github.com/git-chglog/git-chglog/issues/66) from barryib/add-upper-first-func
+- Merge pull request [#68](https://github.com/git-chglog/git-chglog/issues/68) from unixorn/tweak-readme
+
+
+<a name="0.9.1"></a>
+## [0.9.1] - 2019-09-23
+
+<a name="0.9.0"></a>
+## [0.9.0] - 2019-09-23
+### Bug Fixes
+- Fixing tests on windows
+
+### Features
+- Add --tag-filter-pattern flag.
+
+### Pull Requests
+- Merge pull request [#44](https://github.com/git-chglog/git-chglog/issues/44) from evanchaoli/tag-filter
+- Merge pull request [#41](https://github.com/git-chglog/git-chglog/issues/41) from StanleyGoldman/fixing-tests-windows
+- Merge pull request [#37](https://github.com/git-chglog/git-chglog/issues/37) from ForkingSyndrome/master
+
+
+<a name="0.8.0"></a>
+## [0.8.0] - 2019-02-23
+### Features
+- add the contains, hasPrefix, hasSuffix, replace, lower and upper functions to the template functions map
+
+### Pull Requests
+- Merge pull request [#34](https://github.com/git-chglog/git-chglog/issues/34) from atosatto/template-functions
+
+
+<a name="0.7.1"></a>
+## [0.7.1] - 2018-11-10
+### Bug Fixes
+- Panic occured when exec --next-tag with HEAD with tag
+
+### Pull Requests
+- Merge pull request [#31](https://github.com/git-chglog/git-chglog/issues/31) from drubin/patch-1
+- Merge pull request [#30](https://github.com/git-chglog/git-chglog/issues/30) from vvakame/fix-panic
+
+
+<a name="0.7.0"></a>
+## [0.7.0] - 2018-05-06
+### Bug Fixes
+- Remove accidentally added `Unreleased.Tag`
+
+### Chores
+- Update `changelog` task in Makefile
+
+### Features
+- Add URL of output example for template style
+- Add `--next-tag` flag (experimental)
+
+### Pull Requests
+- Merge pull request [#22](https://github.com/git-chglog/git-chglog/issues/22) from git-chglog/feat/add-preview-style-link
+- Merge pull request [#21](https://github.com/git-chglog/git-chglog/issues/21) from git-chglog/feat/next-tag
+
+
+<a name="0.6.0"></a>
+## [0.6.0] - 2018-05-04
+### Chores
+- Update CHANGELOG template format
+
+### Features
+- Add tag name header id for keep-a-changelog template
+
+### Pull Requests
+- Merge pull request [#20](https://github.com/git-chglog/git-chglog/issues/20) from git-chglog/feat/kac-template-title-id
+
+
+<a name="0.5.0"></a>
+## [0.5.0] - 2018-05-04
+### Bug Fixes
+- Add unreleased commits section to keep-a-changelog template [#15](https://github.com/git-chglog/git-chglog/issues/15)
+
+### Chores
+- Update CHANGELOG template format
+
+### Features
+- Update template format to human readable
+- Add `Unreleased` field to `RenderData`
+
+### Pull Requests
+- Merge pull request [#19](https://github.com/git-chglog/git-chglog/issues/19) from git-chglog/fix/unreleased-commits
+- Merge pull request [#18](https://github.com/git-chglog/git-chglog/issues/18) from ringohub/master
+
+
+<a name="0.4.0"></a>
+## [0.4.0] - 2018-04-14
+### Features
+- Add support for Bitbucket
+
+### Pull Requests
+- Merge pull request [#17](https://github.com/git-chglog/git-chglog/issues/17) from git-chglog/feat/bitbucket
+
+
+<a name="0.3.3"></a>
+## [0.3.3] - 2018-04-07
+### Features
+- Change to kindly error message when git-tag does not exist
+
+### Pull Requests
+- Merge pull request [#16](https://github.com/git-chglog/git-chglog/issues/16) from git-chglog/fix/empty-tag-handling
+
+
+<a name="0.3.2"></a>
+## [0.3.2] - 2018-04-02
+### Bug Fixes
+- Fix color output bug in windows help command
+
+### Pull Requests
+- Merge pull request [#14](https://github.com/git-chglog/git-chglog/issues/14) from git-chglog/fix/windows-help-color
+
+
+<a name="0.3.1"></a>
+## [0.3.1] - 2018-03-15
+### Bug Fixes
+- fix preview string of commit subject
+
+### Pull Requests
+- Merge pull request [#13](https://github.com/git-chglog/git-chglog/issues/13) from kt3k/feature/fix-preview
+
+
+<a name="0.3.0"></a>
+## [0.3.0] - 2018-03-12
+### Chores
+- Add helper task for generate CHANGELOG
+
+### Features
+- Add support for GitLab
+
+### Pull Requests
+- Merge pull request [#12](https://github.com/git-chglog/git-chglog/issues/12) from git-chglog/feat/gitlab
+
+
+<a name="0.2.0"></a>
+## [0.2.0] - 2018-03-02
+### Chores
+- Fix release flow (retry)
+- Add AppVeyor config
+
+### Features
+- Add template for `Keep a changelog` to the `--init` option
+- Supports vim like `j/k` keybind with item selection of `--init`
+
+### Pull Requests
+- Merge pull request [#11](https://github.com/git-chglog/git-chglog/issues/11) from git-chglog/develop
+- Merge pull request [#10](https://github.com/git-chglog/git-chglog/issues/10) from mattn/fix-test
+- Merge pull request [#9](https://github.com/git-chglog/git-chglog/issues/9) from mattn/windows-color
 
 
 <a name="0.1.0"></a>
-## [0.1.0](https://github.com/git-chglog/git-chglog/compare/0.0.2...0.1.0) (2018-02-25)
-
+## [0.1.0] - 2018-02-25
 ### Bug Fixes
+- Fix a bug that `Commit.Revert.Header` is not converted by `GitHubProcessor`
+- Fix error message when `Tag` can not be acquired
+- Fix `Revert` of template created by Initializer
 
-* Fix a bug that `Commit.Revert.Header` is not converted by `GitHubProcessor`
-* Fix error message when `Tag` can not be acquired
-* Fix `Revert` of template created by Initializer
+### Chores
+- Fix release scripts
+- Remove unnecessary task
+- Add coverage measurement task for local confirmation
+- Change release method of git tag on TravisCI
 
 ### Code Refactoring
-
-* Refactor `Initializer` to testable
+- Refactor `Initializer` to testable
 
 ### Features
+- Supports annotated git-tag and adds `Tag.Subject` field [#3](https://github.com/git-chglog/git-chglog/issues/3)
+- Remove commit message preview on select format
+- Add Git Basic to commit message format
+- Add preview to the commit message format of `--init` option
 
-* Supports annotated git-tag and adds `Tag.Subject` field [#3](https://github.com/git-chglog/git-chglog/issues/3)
-* Remove commit message preview on select format
-* Add Git Basic to commit message format
-* Add preview to the commit message format of `--init` option
+### Pull Requests
+- Merge pull request [#8](https://github.com/git-chglog/git-chglog/issues/8) from git-chglog/feat/0.0.3
+- Merge pull request [#6](https://github.com/git-chglog/git-chglog/issues/6) from git-chglog/chore/coverage
+- Merge pull request [#4](https://github.com/git-chglog/git-chglog/issues/4) from paralax/patch-1
+- Merge pull request [#5](https://github.com/git-chglog/git-chglog/issues/5) from git-chglog/develop
+- Merge pull request [#1](https://github.com/git-chglog/git-chglog/issues/1) from git-chglog/develop
 
 
 <a name="0.0.2"></a>
-## [0.0.2](https://github.com/git-chglog/git-chglog/compare/0.0.1...0.0.2) (2018-02-19)
-
-### Bug Fixes
-
-* Fix `Revert` of template created by Initializer
-
-### Features
-
-* Add Git Basic to commit message format
-* Add preview to the commit message format of `--init` option
+## [0.0.2] - 2018-02-18
+### Chores
+- Fix release script
+- Add release process
 
 
 <a name="0.0.1"></a>
-## 0.0.1 (2018-02-18)
+## 0.0.1 - 2018-02-18
+### Bug Fixes
+- Fix parsing of revert and body
 
-First release :tada:
+### Chores
+- Fix timezone in TravisCI
+- Add travis configuration
+- Add Makefile for task management
+- Fix testcase depending on datetime
+- Update vendor packages
+- Add e2e tests
+- Setup gitignore
+- Initial commit
+- **editor:** Add Editorconfig
+
+### Code Refactoring
+- Fix typo
+- Change to return an error if corresponding commit is empty
+- Refactor the main logic
+
+### Features
+- Add cli client
+- Add commits in commit version struct
+- Add config normalize process
+- Add Next and Previous in Tag
+- Add MergeCommits and RevertCommits
+- First implement
+
+
+[Unreleased]: https://github.com/git-chglog/git-chglog/compare/v0.15.4...HEAD
+[v0.15.4]: https://github.com/git-chglog/git-chglog/compare/v0.15.2...v0.15.4
+[v0.15.2]: https://github.com/git-chglog/git-chglog/compare/v0.15.1...v0.15.2
+[v0.15.1]: https://github.com/git-chglog/git-chglog/compare/v0.15.0...v0.15.1
+[v0.15.0]: https://github.com/git-chglog/git-chglog/compare/v0.14.2...v0.15.0
+[v0.14.2]: https://github.com/git-chglog/git-chglog/compare/v0.14.1...v0.14.2
+[v0.14.1]: https://github.com/git-chglog/git-chglog/compare/v0.14.0...v0.14.1
+[v0.14.0]: https://github.com/git-chglog/git-chglog/compare/v0.13.0...v0.14.0
+[v0.13.0]: https://github.com/git-chglog/git-chglog/compare/v0.12.0...v0.13.0
+[v0.12.0]: https://github.com/git-chglog/git-chglog/compare/v0.11.2...v0.12.0
+[v0.11.2]: https://github.com/git-chglog/git-chglog/compare/v0.11.1...v0.11.2
+[v0.11.1]: https://github.com/git-chglog/git-chglog/compare/v0.11.0...v0.11.1
+[v0.11.0]: https://github.com/git-chglog/git-chglog/compare/v0.10.0...v0.11.0
+[v0.10.0]: https://github.com/git-chglog/git-chglog/compare/0.9.1...v0.10.0
+[0.9.1]: https://github.com/git-chglog/git-chglog/compare/0.9.0...0.9.1
+[0.9.0]: https://github.com/git-chglog/git-chglog/compare/0.8.0...0.9.0
+[0.8.0]: https://github.com/git-chglog/git-chglog/compare/0.7.1...0.8.0
+[0.7.1]: https://github.com/git-chglog/git-chglog/compare/0.7.0...0.7.1
+[0.7.0]: https://github.com/git-chglog/git-chglog/compare/0.6.0...0.7.0
+[0.6.0]: https://github.com/git-chglog/git-chglog/compare/0.5.0...0.6.0
+[0.5.0]: https://github.com/git-chglog/git-chglog/compare/0.4.0...0.5.0
+[0.4.0]: https://github.com/git-chglog/git-chglog/compare/0.3.3...0.4.0
+[0.3.3]: https://github.com/git-chglog/git-chglog/compare/0.3.2...0.3.3
+[0.3.2]: https://github.com/git-chglog/git-chglog/compare/0.3.1...0.3.2
+[0.3.1]: https://github.com/git-chglog/git-chglog/compare/0.3.0...0.3.1
+[0.3.0]: https://github.com/git-chglog/git-chglog/compare/0.2.0...0.3.0
+[0.2.0]: https://github.com/git-chglog/git-chglog/compare/0.1.0...0.2.0
+[0.1.0]: https://github.com/git-chglog/git-chglog/compare/0.0.2...0.1.0
+[0.0.2]: https://github.com/git-chglog/git-chglog/compare/0.0.1...0.0.2

CONTRIBUTING.md

@@ -2,22 +2,21 @@
 
 Thank you for contributing `git-chglog` :tada:
 
-
 ## Templates
 
 Please use issue/PR templates which are inserted automatically.
 
-
 ## Found a Bug?
 
-If you find a bug in the source code, you can help us by [submitting an issue](https://github.com/git-chglog/git-chglog/issues) to our [GitHub Repository](https://github.com/git-chglog/git-chglog). Even better, you can submit a Pull Request with a fix.
-
+If you find a bug in the source code, you can help us by [submitting an issue]
+to our [GitHub Repository]. Even better, you can submit a Pull Request with a
+fix.
 
 ## Commit Message Format
 
-A format influenced by [Angular commit message](https://github.com/angular/angular/blob/master/CONTRIBUTING.md#commit-message-format).
+A format influenced by [Angular commit message].
 
-```
+```text
 <type>: <subject>
 <BLANK LINE>
 <body>
@@ -25,26 +24,31 @@ A format influenced by [Angular commit message](https://github.com/angular/angul
 <footer>
 ```
 
-
 ### Type
 
 Must be one of the following:
 
-* **docs:** Documention only changes
-* **ci:** Changes to our CI configuration files and scripts
-* **chore:** Updating Makefile etc, no production code changes
-* **feat:** A new feature
-* **fix:** A bug fix
-* **perf:** A code change that improves performance
-* **refactor:** A code change that neither fixes a bug nor adds a feature
-* **style:** Changes that do not affect the meaning of the code
-* **test:** Adding missing tests or correcting existing tests
-
+- **docs:** Documention only changes
+- **ci:** Changes to our CI configuration files and scripts
+- **chore:** Updating Makefile etc, no production code changes
+- **feat:** A new feature
+- **fix:** A bug fix
+- **perf:** A code change that improves performance
+- **refactor:** A code change that neither fixes a bug nor adds a feature
+- **style:** Changes that do not affect the meaning of the code
+- **test:** Adding missing tests or correcting existing tests
 
 ### Footer
 
-The footer should contain a [closing reference to an issue](https://help.github.com/articles/closing-issues-via-commit-messages/) if any.
+The footer should contain a [closing reference to an issue] if any.
 
-The **footer** should contain any information about **Breaking Changes** and is also the place to reference GitHub issues that this commit **Closes**.
+The **footer** should contain any information about **Breaking Changes** and is
+also the place to reference GitHub issues that this commit **Closes**.
 
-**Breaking Changes** should start with the word `BREAKING CHANGE:` with a space or two newlines. The rest of the commit message is then used for this.
+**Breaking Changes** should start with the word `BREAKING CHANGE:` with a space
+or two newlines. The rest of the commit message is then used for this.
+
+[submitting an issue]: https://github.com/git-chglog/git-chglog/issues
+[GitHub Repository]: https://github.com/git-chglog/git-chglog
+[Angular commit message]: https://github.com/angular/angular/blob/master/CONTRIBUTING.md#commit-message-format
+[closing reference to an issue]: https://help.github.com/articles/closing-issues-via-commit-messages/

Dockerfile

@@ -0,0 +1,12 @@
+FROM alpine
+
+RUN apk add --no-cache git && \
+    mkdir /workdir && \
+    git config --global --add safe.directory /workdir
+
+COPY git-chglog /usr/local/bin/git-chglog
+
+WORKDIR /workdir
+RUN chmod +x /usr/local/bin/git-chglog
+
+ENTRYPOINT [ "/usr/local/bin/git-chglog" ]

Gopkg.lock

@@ -1,97 +0,0 @@
-# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
-
-
-[[projects]]
-  name = "github.com/davecgh/go-spew"
-  packages = ["spew"]
-  revision = "346938d642f2ec3594ed81d874461961cd0faa76"
-  version = "v1.1.0"
-
-[[projects]]
-  name = "github.com/fatih/color"
-  packages = ["."]
-  revision = "507f6050b8568533fb3f5504de8e5205fa62a114"
-  version = "v1.6.0"
-
-[[projects]]
-  name = "github.com/imdario/mergo"
-  packages = ["."]
-  revision = "163f41321a19dd09362d4c63cc2489db2015f1f4"
-  version = "0.3.2"
-
-[[projects]]
-  name = "github.com/mattn/go-colorable"
-  packages = ["."]
-  revision = "167de6bfdfba052fa6b2d3664c8f5272e23c9072"
-  version = "v0.0.9"
-
-[[projects]]
-  name = "github.com/mattn/go-isatty"
-  packages = ["."]
-  revision = "0360b2af4f38e8d38c7fce2a9f4e702702d73a39"
-  version = "v0.0.3"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/mgutz/ansi"
-  packages = ["."]
-  revision = "9520e82c474b0a04dd04f8a40959027271bab992"
-
-[[projects]]
-  name = "github.com/pmezard/go-difflib"
-  packages = ["difflib"]
-  revision = "792786c7400a136282c1664665ae0a8db921c6c2"
-  version = "v1.0.0"
-
-[[projects]]
-  name = "github.com/stretchr/testify"
-  packages = ["assert"]
-  revision = "12b6f73e6084dad08a7c6e575284b177ecafbc71"
-  version = "v1.2.1"
-
-[[projects]]
-  name = "github.com/tsuyoshiwada/go-gitcmd"
-  packages = ["."]
-  revision = "5f1f5f9475df211f8b48620d704284d7375229c3"
-  version = "0.0.1"
-
-[[projects]]
-  name = "github.com/urfave/cli"
-  packages = ["."]
-  revision = "cfb38830724cc34fedffe9a2a29fb54fa9169cd1"
-  version = "v1.20.0"
-
-[[projects]]
-  branch = "master"
-  name = "golang.org/x/sys"
-  packages = ["unix"]
-  revision = "37707fdb30a5b38865cfb95e5aab41707daec7fd"
-
-[[projects]]
-  name = "gopkg.in/AlecAivazis/survey.v1"
-  packages = [
-    ".",
-    "core",
-    "terminal"
-  ]
-  revision = "0aa8b6a162b391fe2d95648b7677d1d6ac2090a6"
-  version = "v1.4.1"
-
-[[projects]]
-  name = "gopkg.in/kyokomi/emoji.v1"
-  packages = ["."]
-  revision = "7e06b236c489543f53868841f188a294e3383eab"
-  version = "v1.5"
-
-[[projects]]
-  branch = "v2"
-  name = "gopkg.in/yaml.v2"
-  packages = ["."]
-  revision = "d670f9405373e636a5a2765eea47fac0c9bc91a4"
-
-[solve-meta]
-  analyzer-name = "dep"
-  analyzer-version = 1
-  inputs-digest = "0be1d1c2f1a9b1c1f1d63ad065141425b62687efb378f6657b088ddf993c3882"
-  solver-name = "gps-cdcl"
-  solver-version = 1

Gopkg.toml

@@ -1,36 +0,0 @@
-[[constraint]]
-  name = "github.com/stretchr/testify"
-  version = "1.2.1"
-
-[[constraint]]
-  name = "github.com/tsuyoshiwada/go-gitcmd"
-  version = "0.0.1"
-
-[[constraint]]
-  name = "github.com/urfave/cli"
-  version = "1.20.0"
-
-[prune]
-  non-go = true
-  go-tests = true
-  unused-packages = true
-
-[[constraint]]
-  name = "github.com/fatih/color"
-  version = "1.6.0"
-
-[[constraint]]
-  name = "github.com/imdario/mergo"
-  version = "0.3.2"
-
-[[constraint]]
-  branch = "v2"
-  name = "gopkg.in/yaml.v2"
-
-[[constraint]]
-  name = "gopkg.in/AlecAivazis/survey.v1"
-  version = "1.4.1"
-
-[[constraint]]
-  name = "gopkg.in/kyokomi/emoji.v1"
-  version = "1.5.0"

Makefile

@@ -1,32 +1,108 @@
-.PHONY: bootstrap
-bootstrap: clean deps
+# Build variables
+VERSION ?= $(shell git describe --tags --always)
 
-.PHONY: deps
-deps:
-	dep ensure -v
+# Go variables
+GO      ?= go
+GOOS    ?= $(shell $(GO) env GOOS)
+GOARCH  ?= $(shell $(GO) env GOARCH)
+GOHOST  ?= GOOS=$(GOOS) GOARCH=$(GOARCH) $(GO)
+
+LDFLAGS ?= "-X main.version=$(VERSION)"
+
+# Docker variables
+DEFAULT_TAG  ?= $(shell echo "$(VERSION)" | tr -d 'v')
+DOCKER_IMAGE := quay.io/git-chglog/git-chglog
+DOCKER_TAG   ?= $(DEFAULT_TAG)
+
+.PHONY: all
+all: help
+
+###############
+##@ Development
 
 .PHONY: clean
-clean:
-	rm -rf ./vendor/
+clean:   ## Clean workspace
+	@ $(MAKE) --no-print-directory log-$@
 	rm -rf ./dist/
 	rm -rf ./git-chglog
 	rm -rf $(GOPATH)/bin/git-chglog
 	rm -rf cover.out
 
-.PHONY: bulid
-build:
-	go build -i -o git-chglog
-
 .PHONY: test
-test:
-	go test -v `go list ./... | grep -v /vendor/`
+test:   ## Run tests
+	@ $(MAKE) --no-print-directory log-$@
+	$(GOHOST) test -covermode atomic -coverprofile cover.out -v ./...
 
-.PHONY: coverage
-coverage:
-	goverage -coverprofile=cover.out `go list ./... | grep -v /vendor/`
-	go tool cover -func=cover.out
-	@rm -rf cover.out
+.PHONY: lint
+lint:   ## Run linters
+	@ $(MAKE) --no-print-directory log-$@
+	golangci-lint run
+
+#########
+##@ Build
+
+.PHONY: build
+build:   ## Build git-chglog
+	@ $(MAKE) --no-print-directory log-$@
+	CGO_ENABLED=0 $(GOHOST) build -ldflags=$(LDFLAGS) -o git-chglog ./cmd/git-chglog
 
 .PHONY: install
-install:
-	go install ./cmd/git-chglog
+install:   ## Install git-chglog
+	@ $(MAKE) --no-print-directory log-$@
+	$(GOHOST) install ./cmd/git-chglog
+
+.PHONY: docker
+docker: build   ## Build Docker image
+	@ $(MAKE) --no-print-directory log-$@
+	docker build --pull --tag $(DOCKER_IMAGE):$(DOCKER_TAG) .
+
+.PHONY: push
+push:   ## Push Docker image
+	@ $(MAKE) --no-print-directory log-$@
+	docker push $(DOCKER_IMAGE):$(DOCKER_TAG)
+
+###########
+##@ Release
+
+.PHONY: changelog
+changelog: build   ## Generate changelog
+	@ $(MAKE) --no-print-directory log-$@
+	./git-chglog --next-tag $(VERSION) -o CHANGELOG.md
+
+.PHONY: release
+release: changelog   ## Release a new tag
+	@ $(MAKE) --no-print-directory log-$@
+	git add CHANGELOG.md
+	git commit -m "chore: update changelog for $(VERSION)"
+	git tag $(VERSION)
+	git push origin master $(VERSION)
+
+########
+##@ Help
+
+.PHONY: help
+help:   ## Display this help
+	@awk \
+		-v "col=\033[36m" -v "nocol=\033[0m" \
+		' \
+			BEGIN { \
+				FS = ":.*##" ; \
+				printf "Usage:\n  make %s<target>%s\n", col, nocol \
+			} \
+			/^[a-zA-Z_-]+:.*?##/ { \
+				printf "  %s%-12s%s %s\n", col, $$1, nocol, $$2 \
+			} \
+			/^##@/ { \
+				printf "\n%s%s%s\n", nocol, substr($$0, 5), nocol \
+			} \
+		' $(MAKEFILE_LIST)
+
+log-%:
+	@grep -h -E '^$*:.*?## .*$$' $(MAKEFILE_LIST) | \
+		awk \
+			'BEGIN { \
+				FS = ":.*?## " \
+			}; \
+			{ \
+				printf "\033[36m==> %s\033[0m\n", $$2 \
+			}'

README.md

@@ -3,117 +3,153 @@
 ![git-chglog](https://raw.githubusercontent.com/git-chglog/artwork/master/repo-banner%402x.png)
 
 [![godoc.org](https://img.shields.io/badge/godoc-reference-blue.svg?style=flat-square)](https://godoc.org/github.com/git-chglog/git-chglog)
-[![Travis](https://img.shields.io/travis/git-chglog/git-chglog.svg?style=flat-square)](https://travis-ci.org/git-chglog/git-chglog)
+[![Actions Status](https://github.com/git-chglog/git-chglog/workflows/tests/badge.svg)](https://github.com/git-chglog/git-chglog/actions)
 [![Coverage Status](https://img.shields.io/coveralls/github/git-chglog/git-chglog.svg?style=flat-square)](https://coveralls.io/github/git-chglog/git-chglog?branch=master)
 [![MIT License](http://img.shields.io/badge/license-MIT-blue.svg?style=flat-square)](https://github.com/git-chglog/git-chglog/blob/master/LICENSE)
 
-> CHANGELOG generator implemented in Go (Golang).  
+> CHANGELOG generator implemented in Go (Golang).
 > _Anytime, anywhere, Write your CHANGELOG._
 
-
-
-
 ## Table of Contents
 
-* [Features](#features)
-* [How it works](#how-it-works)
-* [Getting Started](#getting-started)
+- [git-chglog](#git-chglog)
+  - [Table of Contents](#table-of-contents)
+  - [Features](#features)
+  - [How it works](#how-it-works)
+  - [Getting Started](#getting-started)
     - [Installation](#installation)
-        + [Homebrew (for macOS users)](#homebrew-for-macos-users)
-        + [Go users](#go-users)
+      - [Homebrew (for macOS users)](#homebrew-for-macos-users)
+      - [Scoop (for Windows users)](#scoop-for-windows-users)
+      - [asdf](#asdf)
+      - [Go users](#go-users)
+    - [Docker](#docker)
     - [Test Installation](#test-installation)
     - [Quick Start](#quick-start)
-* [CLI Usage](#cli-usage)
+  - [CLI Usage](#cli-usage)
     - [`tag query`](#tag-query)
-* [Configuration](#configuration)
-* [Templates](#templates)
-* [Supported Styles](#supported-styles)
-* [FAQ](#faq)
-* [TODO](#todo)
-* [Thanks](#thanks)
-* [Contributing](#contributing)
-    - [Development](#development)
-    - [Feedback](#feedback)
-* [CHANGELOG](#changelog)
-* [Related Projects](#related-projects)
-* [License](#license)
-
-
-
+  - [Configuration](#configuration)
+    - [`bin`](#bin)
+    - [`style`](#style)
+    - [`template`](#template)
+    - [`info`](#info)
+    - [`options`](#options)
+      - [`options.sort`](#optionssort)
+      - [`options.commits`](#optionscommits)
+      - [`options.commit_groups`](#optionscommit_groups)
+      - [`options.header`](#optionsheader)
+      - [`options.issues`](#optionsissues)
+      - [`options.refs`](#optionsrefs)
+      - [`options.merges`](#optionsmerges)
+      - [`options.reverts`](#optionsreverts)
+      - [`options.notes`](#optionsnotes)
+  - [Templates](#templates)
+  - [Supported Styles](#supported-styles)
+  - [Jira Integration](#jira-integration)
+    - [1. Change the header parse pattern to recognize Jira issue id in the configure file](#1-change-the-header-parse-pattern-to-recognize-jira-issue-id-in-the-configure-file)
+    - [2. Add Jira configuration to the configure file](#2-add-jira-configuration-to-the-configure-file)
+    - [3. Update the template to show Jira data](#3-update-the-template-to-show-jira-data)
+  - [FAQ](#faq)
+  - [TODO](#todo)
+  - [Thanks](#thanks)
+  - [Contributing](#contributing)
+  - [Development](#development)
+  - [Release Process](#release-process)
+  - [Feedback](#feedback)
+  - [CHANGELOG](#changelog)
+  - [Related Projects](#related-projects)
+  - [License](#license)
 
 ## Features
 
-* :recycle: High portability
-    - It works with single binary. Therefore, any project (environment) can be used.
-* :beginner: Simple usability
-    - The CLI usage is very simple and has low learning costs.
-    - For example, the simplest command is `$ git-chglog`.
-* :rocket: High flexibility
-    - Commit message format and ...
-    - CHANGELOG's style (Template) and ...
-    - etc ...
-
-
-
+- :recycle: High portability
+  - It works with single binary. Therefore, any project (environment) can be used.
+- :beginner: Simple usability
+  - The CLI usage is very simple and has low learning costs.
+  - For example, the simplest command is `$ git-chglog`.
+- :rocket: 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 CHANGELOG.  
-The basic steps are as follows.
+`git-chglog` internally uses the `git` command to get data to include in the
+CHANGELOG. The basic steps are as follows.
 
 1. Get all the tags.
-1. Get the commit contained between `tagA` and `tagB`.
-1. Execute with all tags corresponding to [tag query](#tag-query) that specified Step 1 to 2.
-
-
-
+1. Get the commits contained between `tagA` and `tagB`.
+1. Execute with all tags corresponding to [tag query](#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.
-
+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)
+#### [Homebrew](https://brew.sh) (for macOS users)
 
 ```bash
-$ brew tap git-chglog/git-chglog
-$ brew install git-chglog
+brew tap git-chglog/git-chglog
+brew install git-chglog
+```
+
+#### [Scoop](https://scoop.sh) (for Windows users)
+
+```bash
+scoop install git-chglog
+```
+
+#### [asdf](https://asdf-vm.com/)
+
+```bash
+asdf plugin-add git-chglog https://github.com/GoodwayGroup/asdf-git-chglog.git
+asdf install git-chglog latest
 ```
 
 #### Go users
 
 ```bash
-$ go get -u github.com/git-chglog/git-chglog/cmd/git-chglog
+go install github.com/git-chglog/git-chglog/cmd/git-chglog@latest
 ```
 
+### [Docker](https://www.docker.com/)
+The compiled docker images are maintained on [quay.io](https://quay.io/repository/git-chglog/git-chglog). 
+We maintain the following tags:
+- `edge`: Image that is build from the current `HEAD` of the main line branch.
+- `latest`: Image that is built from the [latest released version](https://github.com/git-chglog/git-chglog/releases)
+- `x.y.y` (versions): Images that are build from the tagged versions within Github.
+```bash
+docker pull quay.io/git-chglog/git-chglog:latest
+docker run -v "$PWD":/workdir quay.io/git-chglog/git-chglog --version
+```
 ---
 
-If you are in another platform, you can download binary from [release page](https://github.com/git-chglog/git-chglog/releases) and place it in `$PATH` directory.
-
+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 valid `$PATH`.
+You can check with the following command whether the `git-chglog` command was
+included in a directory that is in your `$PATH`.
 
 ```bash
 $ git-chglog --version
-# output the git-chglog version
+# outputs the git-chglog version
 ```
 
-
 ### Quick Start
 
-`git-chglog` requires configuration files and templates to generate CHANGELOG.  
-However, it is a waste of time to create configuration files and templates with scratch.
+`git-chglog` requires configuration files and templates to generate a CHANGELOG.
 
-Therefore we recommend using the `--init` option which can create them interactively :+1:
+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 :+1:
 
 ```bash
-$ git-chglog --init
+git-chglog --init
 ```
 
 ![init option demo](./docs/assets/init.gif)
@@ -122,26 +158,26 @@ $ git-chglog --init
 
 You are now ready for configuration files and templates!
 
-Let's immediately generate CHANGELOG of your project.  
-By doing the following simple command, Markdown of CHANGELOG is displayed on stdout.
+Let's immediately generate a CHANGELOG of your project.
+By doing the following simple command, Markdown for your CHANGELOG is displayed
+on stdout.
 
 ```bash
-$ git-chglog
+git-chglog
 ```
 
-Use `-o` (`--output`) option if you want to output to file instead of stdout.
+Use `-o` (`--output`) option if you want to output to a file instead of stdout.
 
 ```bash
-$ git-chglog -o CHANGELOG.md
+git-chglog -o CHANGELOG.md
 ```
 
 ---
 
-This is how basic usage is over!  
-In order to make better CHANGELOG, please refer to the following document and customize it.
-
-
+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
 
@@ -153,20 +189,30 @@ USAGE:
 
     There are the following specification methods for <tag query>.
 
-    1. <old>..<new> - Commit contained in <new> tags from <old>.
+    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
-  --silent                  disable stdout output
-  --no-color                disable color output [$NO_COLOR]
-  --no-emoji                disable emoji output [$NO_EMOJI]
-  --help, -h                show help
-  --version, -v             print the version
+  --init                      generate the git-chglog configuration file in interactive (default: false)
+  --path value                Filter commits by path(s). Can use multiple times.
+  --config value, -c value    specifies a different configuration file to pick up (default: ".chglog/config.yml")
+  --template value, -t value  specifies a template file to pick up. If not specified, use the one in config
+  --repository-url value      specifies git repo URL. If not specified, use 'repository_url' in config
+  --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 (default: false)
+  --no-color                  disable color output (default: false) [$NO_COLOR]
+  --no-emoji                  disable emoji output (default: false) [$NO_EMOJI]
+  --no-case                   disable case sensitive filters (default: false)
+  --tag-filter-pattern value  Regular expression of tag filter. Is specified, only matched tags will be picked
+  --jira-url value            Jira URL [$JIRA_URL]
+  --jira-username value       Jira username [$JIRA_USERNAME]
+  --jira-token value          Jira token [$JIRA_TOKEN]
+  --sort value                Specify how to sort tags; currently supports "date" or by "semver" (default: date)
+  --help, -h                  show help (default: false)
+  --version, -v               print the version (default: false)
 
 EXAMPLE:
 
@@ -194,12 +240,16 @@ EXAMPLE:
   $ git-chglog --config custom/dir/config.yml
 
     The above is a command that uses a configuration file placed other than ".chglog/config.yml".
-```
 
+  $ git-chglog --path path/to/my/component --output CHANGELOG.component.md
+
+    Filter commits by specific paths or files in git and output to a component specific changelog.
+```
 
 ### `tag query`
 
-You can specify a commit to include in the generation of CHANGELOG using `<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                     |
@@ -209,12 +259,10 @@ The table below shows Query patterns and summaries, and Query examples.
 | `..<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 write with the yaml file. Default location is `.chglog/config.yml`.
+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`.
 
@@ -227,6 +275,9 @@ info:
   repository_url: https://github.com/git-chglog/git-chglog
 
 options:
+  tag_filter_pattern: '^v'
+  sort: "date"
+
   commits:
     filters:
       Type:
@@ -236,6 +287,8 @@ options:
   commit_groups:
     group_by: Type
     sort_by: Title
+    title_order:
+      - feat
     title_maps:
       feat: Features
 
@@ -268,7 +321,6 @@ options:
       - BREAKING CHANGE
 ```
 
-
 ### `bin`
 
 Git execution command.
@@ -277,57 +329,65 @@ Git execution command.
 |:---------|:-------|:--------|:------------|
 | 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"` `"none"` |
+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 template file. It is specified by a relative path from the setting file. Absolute pass is ok.
+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.
+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.sort`
+
+Options concerning the acquisition and sort of commits.
+
+| Required | Type        | Default   | Description                                                                                                         |
+|:---------|:------------|:----------|:--------------------------------------------------------------------------------------------------------------------|
+| N        | String      | `"date"` | Defines how tags are sorted in the generated change log. Values: "date", "semver". |
+
 #### `options.commits`
 
-Option concerning acquisition and sort of commit.
+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](https://godoc.org/github.com/git-chglog/git-chglog#Commit). |
+| 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`
 
-Option for groups of commits.
+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][doc-commit]. |
-| `sort_by`    | N        | String      | `"Title"` | Property name to use for sorting `CommitGroup`. See [CommitGroup][doc-commit-group].       |
-| `title_maps` | N        | Map in List | none      | Map for `CommitGroup` title conversion.                                                    |
+| Key           | Required | Type        | Default   | Description                                                                                |
+|:--------------|:---------|:------------|:----------|:-------------------------------------------------------------------------------------------|
+| `group_by`    | N        | String      | `"Type"`  | Property name of `Commit` to be grouped into `CommitGroup`. See [CommitGroup][doc-commit]. |
+| `sort_by`     | N        | String      | `"Title"` | Property name to use for sorting `CommitGroup`. See [CommitGroup][doc-commit-group].       |
+| `title_order` | N        | List        | none      | Predefined order of titles to use for sorting `CommitGroup`. Only if `sort_by` is `Custom` |
+| `title_maps`  | N        | Map in List | none      | Map for `CommitGroup` title conversion.                                                    |
 
 #### `options.header`
 
@@ -356,7 +416,7 @@ This option is for parsing references.
 
 #### `options.merges`
 
-Option to detect and parse merge commit.
+Options to detect and parse merge commits.
 
 | Key            | Required | Type   | Default | Description                               |
 |:---------------|:---------|:-------|:--------|:------------------------------------------|
@@ -365,7 +425,7 @@ Option to detect and parse merge commit.
 
 #### `options.reverts`
 
-Option to detect and parse revert commit.
+Options to detect and parse revert commits.
 
 | Key            | Required | Type   | Default | Description                               |
 |:---------------|:---------|:-------|:--------|:------------------------------------------|
@@ -374,22 +434,32 @@ Option to detect and parse revert commit.
 
 #### `options.notes`
 
-Option to detect notes contained in commit body.
+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.
+The `git-chglog` template uses the `text/template` package and enhanced templating functions provided by [Sprig]. For basic usage please refer to the following.
 
-> [text/template](https://golang.org/pkg/text/template/)
+- [text/template](https://golang.org/pkg/text/template/)
+- [Sprig]
 
-If you are not satisfied with the prepared template please try customizing.
+We have implemented the following custom template functions. These override functions provided by [Sprig].
+
+| Name         | Signature                                     | Description                                                                   |
+| :----------- | :-------------------------------------------- | :---------------------------------------------------------------------------- |
+| `contains`   | `func(s, substr string) bool`                 | Reports whether `substr` is within `s` using `strings.Contains`               |
+| `datetime`   | `func(layout string, input time.Time) string` | Generate a formatted Date string based on layout                              |
+| `hasPrefix`  | `func(s, prefix string) bool`                 | Tests whether the string `s` begins with `prefix` using `strings.HasPrefix`   |
+| `hasSuffix`  | `func(s, suffix string) bool`                 | Tests whether the string `s` ends with `suffix`. using `strings.HasPrefix`    |
+| `indent`     | `func(s string, n int) string`                | Indent all lines of `s` by `n` spaces                                         |
+| `replace`    | `func(s, old, new string, n int) string`      | Replace `old` with `new` within string `s`, `n` times using `strings.Replace` |
+| `upperFirst` | `func(s string) string`                       | Upper case the first character of a string                                    |
+
+If you are not satisfied with the prepared template please try customizing one.
 
 ---
 
@@ -398,129 +468,281 @@ The basic templates are as follows.
 **Example:**
 
 ```markdown
-{{range .Versions}}
-<a name="{{.Tag.Name}}"></a>
-## {{if .Tag.Previous}}[{{.Tag.Name}}]({{$.Info.RepositoryURL}}/compare/{{.Tag.Previous.Name}}...{{.Tag.Name}}){{else}}{{.Tag.Name}}{{end}} ({{datetime "2006-01-02" .Tag.Date}})
-{{range .CommitGroups}}
-### {{.Title}}
-{{range .Commits}}
-* {{if ne .Scope ""}}**{{.Scope}}:** {{end}}{{.Subject}}{{end}}
-{{end}}{{if .RevertCommits}}
+{{ 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}}
-* {{.Header}}{{end}}
-{{end}}{{if .MergeCommits}}
+{{ range .RevertCommits -}}
+- {{ .Revert.Header }}
+{{ end }}
+{{ end -}}
+
+{{- if .MergeCommits -}}
 ### Pull Requests
-{{range .MergeCommits}}
-* {{.Header}}{{end}}
-{{end}}{{range .NoteGroups}}
-### {{.Title}}
-{{range .Notes}}
-{{.Body}}
-{{end}}
-{{end}}
-{{end}}
+{{ 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 godoc [RenderData][doc-render-data] for available variables.
-
-
+See the godoc [RenderData][doc-render-data] documentation for available variables.
 
 ## Supported Styles
 
-| Name                                       | Status                | Features                                               |
-|:-------------------------------------------|:----------------------|:-------------------------------------------------------|
-| [GitHub](https://github.com/)              | :white_check_mark:    | Mentions automatic link. Automatic link to references. |
-| [GitLab](https://about.gitlab.com/)        | :white_medium_square: | -                                                      |
-| [Bitbucket](https://bitbucket.org/product) | :white_medium_square: | -                                                      |
+| Name                                       | Status             | Features                                               |
+|:-------------------------------------------|:-------------------|:-------------------------------------------------------|
+| [GitHub](https://github.com/)              | :white_check_mark: | Mentions automatic link. Automatic link to references. |
+| [GitLab](https://about.gitlab.com/)        | :white_check_mark: | Mentions automatic link. Automatic link to references. |
+| [Bitbucket](https://bitbucket.org/product) | :white_check_mark: | Mentions automatic link. Automatic link to references. |
 
-> :memo: Even with styles that are not yet supported, it is possible to make ordinary CHANGELOG.
+> :memo: Even with styles that are not yet supported, it is possible to make
+ordinary CHANGELOG.
 
+## Jira Integration
 
+Jira is a popular project management tool. When a project uses Jira to track
+feature development and bug fixes, it may also want to generate change log based
+information stored in Jira. With embedding a Jira story id in git commit header,
+the git-chglog tool may automatically fetch data of the story from Jira, those
+data then can be used to render the template.
 
+Take the following steps to add Jira integration:
+
+### 1. Change the header parse pattern to recognize Jira issue id in the configure file
+
+__Where Jira issue is identical Jira story.__
+
+The following is a sample pattern:
+
+  ```yaml
+  header:
+    pattern: "^(?:(\\w*)|(?:\\[(.*)\\])?)\\:\\s(.*)$"
+    pattern_maps:
+      - Type
+      - JiraIssueID
+      - Subject
+  ```
+
+This sample pattern can match both forms of commit headers:
+
+- `feat: new feature of something`
+- `[JIRA-ID]: something`
+
+### 2. Add Jira configuration to the configure file
+
+The following is a sample:
+
+  ```yaml
+  jira:
+    info:
+      username: u
+      token: p
+      url: https://jira.com
+    issue:
+      type_maps:
+        Task: fix
+        Story: feat
+      description_pattern: "<changelog>(.*)</changelog>"
+  ```
+
+Here you need to define Jira URL, access username and token (password). If you
+don't want to write your Jira access credential in configure file, you may define
+them with environment variables: `JIRA_URL`, `JIRA_USERNAME` and `JIRA_TOKEN`.
+
+You also needs to define a issue type map. In above sample, Jira issue type `Task`
+will be mapped to `fix` and `Story` will be mapped to `feat`.
+
+As a Jira story's description could be very long, you might not want to include
+the entire description into change log. In that case, you may define `description_pattern`
+like above, so that only content embraced with `<changelog> ... </changelog>`
+will be included.
+
+### 3. Update the template to show Jira data
+
+In the template, if a commit contains a Jira issue id, then you may show Jira
+data. For example:
+
+```markdown
+{{ range .CommitGroups -}}
+### {{ .Title }}
+{{ range .Commits -}}
+- {{ if .Scope }}**{{ .Scope }}:** {{ end }}{{ .Subject }}
+{{ if .JiraIssue }} {{ .JiraIssue.Description }}
+{{ end }}
+{{ end }}
+{{ end -}}
+```
+
+Within a `Commit`, the following Jira data can be used in template:
+
+- `.JiraIssue.Summary` - Summary of the Jira story
+- `.JiraIssue.Description` - Description of the Jira story
+- `.JiraIssue.Type` - Original type of the Jira story, and `.Type` will be mapped type.
+- `.JiraIssue.Labels` - A list of strings, each is a Jira label.
 
 ## FAQ
 
 <details>
   <summary>Why do not you output files by default?</summary>
-  This is not for the purpose of completely automating the generation of CHANGELOG, because it is only for the purpose of assisting generation.
+  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 commit. But actually it is very difficult to do it perfectly.
+  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.
 
-  There are times when you need your hands to write a great CHANGELOG.  
   By displaying it on the standard output, it makes it easy to change the contents.
 </details>
 
+<details>
+  <summary>Can I commit CHANGELOG changes before creating tags?</summary>
 
+  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.
+
+  ```bash
+  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` :+1:
+
+  This is a step that is necessary for project operation in many cases.
+</details>
+
+<details>
+  <summary>Can I generate a CHANGELOG based on certain tags?</summary>
+
+  Yes, it can be solved by use the `--tag-filter-pattern` flag.
+
+  For example, the following command will only include tags starting with "v":
+
+  ```bash
+  git-chglog --tag-filter-pattern '^v'
+  ```
+
+</details>
 
 ## TODO
 
-* [ ] More styles (GitLab, Bitbucket, and others ...)
-* [ ] Snippetization of configuration files (improvement of reusability)
-* [ ] Windows Support
-* [ ] More test test test ... (and example)
-
-
-
+- [x] Windows Support
+- [x] More styles (GitHub, GitLab, Bitbucket :tada:)
+- [ ] Snippetization of configuration files (improvement of reusability)
+- [ ] More test test test ... (and example)
 
 ## Thanks
 
-`git-chglog` is inspired by [conventional-changelog](https://github.com/conventional-changelog/conventional-changelog). Thank you!
-
-
-
+`git-chglog` is inspired by [conventional-changelog]. Thank you!
 
 ## Contributing
 
-We are always welcoming your contribution :clap:
+We always welcome your contributions :clap:
 
+## Development
 
-### Development
-
+1. Use Golang version `>= 1.24`
 1. Fork (https://github.com/git-chglog/git-chglog) :tada:
 1. Create a feature branch :coffee:
 1. Run test suite with the `$ make test` command and confirm that it passes :zap:
+1. Run linters with the `$ make lint` command and confirm it passes :broom:
+   - The project uses [golangci-lint]
 1. Commit your changes :memo:
 1. Rebase your local changes against the `master` branch :bulb:
 1. Create new Pull Request :love_letter:
 
-Bugs, feature requests and comments are more than welcome in the [issues](https://github.com/git-chglog/git-chglog/issues).
+Bugs, feature requests and comments are more than welcome in the [issues].
 
+## Release Process
 
-### Feedback
+There is a `release` target within the Makefile that wraps up the steps to
+release a new version.
 
-I would like to make `git-chglog` a better tool.  
+> NOTE: Pass the `VERSION` variable when running the command to properly set
+> the tag version for the release.
+
+```bash
+$ VERSION=vX.Y.Z make release
+# EXAMPLE:
+$ VERSION=v0.11.3 make release
+```
+
+Once the `tag` has been pushed, the `goreleaser` github action will take care
+of the rest.
+
+## 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.  
+Therefore, your feedback is very useful.
 I am very happy to tell you your opinions on Issues and PR :heart:
 
-
-
-
 ## CHANGELOG
 
 See [CHANGELOG.md](./CHANGELOG.md)
 
-
-
-
 ## Related Projects
 
-* [git-chglog/artwork](https://github.com/git-chglog/artwork) - Assets for `git-chglog`.
-
-
-
+- [git-chglog/artwork] - Assets for `git-chglog`.
 
 ## License
 
 [MIT © tsuyoshiwada](./LICENSE)
 
-
-
-
+[releases page]: https://github.com/git-chglog/git-chglog/releases
+[Commit]: https://godoc.org/github.com/git-chglog/git-chglog#Commit
 [doc-commit]: https://godoc.org/github.com/git-chglog/git-chglog#Commit
-[doc-commit-group]: https://godoc.org/github.com/git-chglog/git-chglog#Commit
+[doc-commit-group]: https://godoc.org/github.com/git-chglog/git-chglog#CommitGroup
 [doc-ref]: https://godoc.org/github.com/git-chglog/git-chglog#Ref
 [doc-render-data]: https://godoc.org/github.com/git-chglog/git-chglog#RenderData
+[conventional-changelog]: https://github.com/conventional-changelog/conventional-changelog
+[golangci-lint]: https://golangci-lint.run/usage/install/#local-installation
+[issues]: https://github.com/git-chglog/git-chglog/issues
+[git-chglog/artwork]: https://github.com/git-chglog/artwork
+[Sprig]: http://masterminds.github.io/sprig

chglog.go

@@ -2,33 +2,48 @@
 package chglog
 
 import (
+	"errors"
 	"fmt"
 	"io"
+	"log"
 	"os"
 	"path/filepath"
+	"strings"
 	"text/template"
 	"time"
 
-	gitcmd "github.com/tsuyoshiwada/go-gitcmd"
+	"github.com/Masterminds/sprig/v3"
+	"github.com/tsuyoshiwada/go-gitcmd"
 )
 
 // Options is an option used to process commits
 type Options struct {
-	Processor            Processor
-	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`)
+	Processor                   Processor
+	NextTag                     string              // Treat unreleased commits as specified tags (EXPERIMENTAL)
+	TagFilterPattern            string              // Filter tag by regexp
+	Sort                        string              // Specify how to sort tags; currently supports "date" (default) or by "semver".
+	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`)
+	CommitGroupTitleOrder       []string            // Predefined sorted list of titles to use for sorting `CommitGroup`. Only if `CommitGroupSortBy` is `Custom`
+	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`)
+	JiraUsername                string
+	JiraToken                   string
+	JiraURL                     string
+	JiraTypeMaps                map[string]string
+	JiraIssueDescriptionPattern string
+	Paths                       []string // Path filter
 }
 
 // Info is metadata related to CHANGELOG
@@ -39,8 +54,9 @@ type Info struct {
 
 // RenderData is the data passed to the template
 type RenderData struct {
-	Info     *Info
-	Versions []*Version
+	Info       *Info
+	Unreleased *Unreleased
+	Versions   []*Version
 }
 
 // Config for generating CHANGELOG
@@ -90,11 +106,13 @@ type Generator struct {
 }
 
 // NewGenerator receives `Config` and create an new `Generator`
-func NewGenerator(config *Config) *Generator {
+func NewGenerator(logger *Logger, config *Config) *Generator {
 	client := gitcmd.New(&gitcmd.Config{
 		Bin: config.Bin,
 	})
 
+	jiraClient := NewJiraClient(config)
+
 	if config.Options.Processor != nil {
 		config.Options.Processor.Bootstrap(config)
 	}
@@ -104,9 +122,9 @@ func NewGenerator(config *Config) *Generator {
 	return &Generator{
 		client:          client,
 		config:          config,
-		tagReader:       newTagReader(client),
+		tagReader:       newTagReader(client, config.Options.TagFilterPattern, config.Options.Sort),
 		tagSelector:     newTagSelector(),
-		commitParser:    newCommitParser(client, config),
+		commitParser:    newCommitParser(logger, client, jiraClient, config),
 		commitExtractor: newCommitExtractor(config.Options),
 	}
 }
@@ -114,43 +132,69 @@ func NewGenerator(config *Config) *Generator {
 // 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`)
+//
+//	<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`)
 func (gen *Generator) Generate(w io.Writer, query string) error {
 	back, err := gen.workdir()
 	if err != nil {
 		return err
 	}
-	defer back()
+	defer func() {
+		if err = back(); err != nil {
+			log.Fatal(err)
+		}
+	}()
 
-	versions, err := gen.readVersions(query)
+	tags, first, err := gen.getTags(query)
 	if err != nil {
 		return err
 	}
 
-	return gen.render(w, versions)
-}
-
-func (gen *Generator) readVersions(query string) ([]*Version, error) {
-	tags, first, err := gen.getTags(query)
+	unreleased, err := gen.readUnreleased(tags)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
+	versions, err := gen.readVersions(tags, first)
+	if err != nil {
+		return err
+	}
+
+	if len(versions) == 0 {
+		return fmt.Errorf("commits corresponding to \"%s\" was not found", query)
+	}
+
+	return gen.render(w, unreleased, versions)
+}
+
+func (gen *Generator) readVersions(tags []*Tag, first string) ([]*Version, error) {
+	next := gen.config.Options.NextTag
 	versions := []*Version{}
 
 	for i, tag := range tags {
-		var rev string
+		var (
+			isNext = next == tag.Name
+			rev    string
+		)
 
-		if i+1 < len(tags) {
-			rev = tags[i+1].Name + ".." + tag.Name
-		} else {
-			if first != "" {
-				rev = first + ".." + tag.Name
+		if isNext {
+			if tag.Previous != nil {
+				rev = tag.Previous.Name + "..HEAD"
 			} else {
-				rev = tag.Name
+				rev = "HEAD"
+			}
+		} else {
+			if i+1 < len(tags) {
+				rev = tags[i+1].Name + ".." + tag.Name
+			} else {
+				if first != "" {
+					rev = first + ".." + tag.Name
+				} else {
+					rev = tag.Name
+				}
 			}
 		}
 
@@ -169,21 +213,82 @@ func (gen *Generator) readVersions(query string) ([]*Version, error) {
 			RevertCommits: revertCommits,
 			NoteGroups:    noteGroups,
 		})
-	}
 
-	if len(versions) == 0 {
-		return nil, fmt.Errorf("a commits corresponding to \"%s\" was not found", query)
+		// Instead of `getTags()`, assign the date to the tag
+		if isNext && len(commits) != 0 {
+			tag.Date = commits[0].Author.Date
+		}
 	}
 
 	return versions, nil
 }
 
+func (gen *Generator) readUnreleased(tags []*Tag) (*Unreleased, error) {
+	if gen.config.Options.NextTag != "" {
+		return &Unreleased{}, nil
+	}
+
+	rev := "HEAD"
+
+	if len(tags) > 0 {
+		rev = tags[0].Name + "..HEAD"
+	}
+
+	commits, err := gen.commitParser.Parse(rev)
+	if err != nil {
+		return nil, err
+	}
+
+	commitGroups, mergeCommits, revertCommits, noteGroups := gen.commitExtractor.Extract(commits)
+
+	unreleased := &Unreleased{
+		CommitGroups:  commitGroups,
+		Commits:       commits,
+		MergeCommits:  mergeCommits,
+		RevertCommits: revertCommits,
+		NoteGroups:    noteGroups,
+	}
+
+	return unreleased, nil
+}
+
 func (gen *Generator) getTags(query string) ([]*Tag, string, error) {
 	tags, err := gen.tagReader.ReadAll()
 	if err != nil {
 		return nil, "", err
 	}
 
+	next := gen.config.Options.NextTag
+	if next != "" {
+		for _, tag := range tags {
+			if next == tag.Name {
+				return nil, "", fmt.Errorf("\"%s\" tag already exists", next)
+			}
+		}
+
+		var previous *RelateTag
+		if len(tags) > 0 {
+			previous = &RelateTag{
+				Name:    tags[0].Name,
+				Subject: tags[0].Subject,
+				Date:    tags[0].Date,
+			}
+		}
+
+		// Assign the date with `readVersions()`
+		tags = append([]*Tag{
+			{
+				Name:     next,
+				Subject:  next,
+				Previous: previous,
+			},
+		}, tags...)
+	}
+
+	if len(tags) == 0 {
+		return nil, "", errors.New("git-tag does not exist")
+	}
+
 	first := ""
 	if query != "" {
 		tags, first, err = gen.tagSelector.Select(tags, query)
@@ -211,23 +316,47 @@ func (gen *Generator) workdir() (func() error, error) {
 	}, nil
 }
 
-func (gen *Generator) render(w io.Writer, versions []*Version) error {
+func (gen *Generator) render(w io.Writer, unreleased *Unreleased, versions []*Version) error {
 	if _, err := os.Stat(gen.config.Template); err != nil {
 		return err
 	}
 
 	fmap := template.FuncMap{
+		// format the input time according to layout
 		"datetime": func(layout string, input time.Time) string {
 			return input.Format(layout)
 		},
+		// upper case the first character of a string
+		"upperFirst": func(s string) string {
+			if len(s) > 0 {
+				return strings.ToUpper(string(s[0])) + s[1:]
+			}
+			return ""
+		},
+		// indent all lines of s n spaces
+		"indent": func(s string, n int) string {
+			if len(s) == 0 {
+				return ""
+			}
+			pad := strings.Repeat(" ", n)
+			return pad + strings.ReplaceAll(s, "\n", "\n"+pad)
+		},
+		// While Sprig provides these functions, they change the standard input
+		// order which leads to a regression. For an example see:
+		// https://github.com/Masterminds/sprig/blob/master/functions.go#L149
+		"contains":  strings.Contains,
+		"hasPrefix": strings.HasPrefix,
+		"hasSuffix": strings.HasSuffix,
+		"replace":   strings.Replace,
 	}
 
 	fname := filepath.Base(gen.config.Template)
 
-	t := template.Must(template.New(fname).Funcs(fmap).ParseFiles(gen.config.Template))
+	t := template.Must(template.New(fname).Funcs(sprig.TxtFuncMap()).Funcs(fmap).ParseFiles(gen.config.Template))
 
 	return t.Execute(w, &RenderData{
-		Info:     gen.config.Info,
-		Versions: versions,
+		Info:       gen.config.Info,
+		Unreleased: unreleased,
+		Versions:   versions,
 	})
 }

chglog_test.go

@@ -13,10 +13,14 @@ import (
 )
 
 var (
-	cwd          string
-	testRepoRoot = ".tmp"
+	cwd                string
+	testRepoRoot       = ".tmp"
+	internalTimeFormat = "2006-01-02 15:04:05"
 )
 
+type commitFunc = func(date, subject, body string)
+type tagFunc = func(name string)
+
 func TestMain(m *testing.M) {
 	cwd, _ = os.Getwd()
 	cleanup()
@@ -25,219 +29,255 @@ func TestMain(m *testing.M) {
 	os.Exit(code)
 }
 
-func setup(dir string, setupRepo func(gitcmd.Client)) {
+func setup(dir string, setupRepo func(commitFunc, tagFunc, gitcmd.Client)) {
 	testDir := filepath.Join(cwd, testRepoRoot, dir)
 
-	os.MkdirAll(testDir, os.ModePerm)
-	os.Chdir(testDir)
+	_ = os.RemoveAll(testDir)
+	_ = os.MkdirAll(testDir, os.ModePerm)
+	_ = os.Chdir(testDir)
 
 	loc, _ := time.LoadLocation("UTC")
 	time.Local = loc
 
 	git := gitcmd.New(nil)
-	git.Exec("init")
-	git.Exec("config", "user.name", "test_user")
-	git.Exec("config", "user.email", "test@example.com")
+	_, _ = git.Exec("init")
+	_, _ = git.Exec("config", "user.name", "test_user")
+	_, _ = git.Exec("config", "user.email", "test@example.com")
 
-	setupRepo(git)
+	var commit = func(date, subject, body string) {
+		msg := subject
+		if body != "" {
+			msg += "\n\n" + body
+		}
+		t, _ := time.Parse(internalTimeFormat, date)
+		d := t.Format("Mon Jan 2 15:04:05 2006 +0000")
+		_, _ = git.Exec("commit", "--allow-empty", "--date", d, "-m", msg)
+	}
 
-	os.Chdir(cwd)
+	var tag = func(name string) {
+		_, _ = git.Exec("tag", name)
+	}
+
+	setupRepo(commit, tag, git)
+
+	_ = os.Chdir(cwd)
 }
 
 func cleanup() {
-	os.Chdir(cwd)
-	os.RemoveAll(filepath.Join(cwd, testRepoRoot))
+	_ = os.Chdir(cwd)
+	_ = os.RemoveAll(filepath.Join(cwd, testRepoRoot))
+}
+
+func TestGeneratorNotFoundTags(t *testing.T) {
+	assert := assert.New(t)
+	testName := "not_found"
+
+	setup(testName, func(commit commitFunc, _ tagFunc, _ gitcmd.Client) {
+		commit("2018-01-01 00:00:00", "feat(*): New feature", "")
+	})
+
+	gen := NewGenerator(NewLogger(os.Stdout, os.Stderr, false, true),
+		&Config{
+			Bin:        "git",
+			WorkingDir: filepath.Join(testRepoRoot, testName),
+			Template:   filepath.Join(cwd, "testdata", testName+".md"),
+			Info: &Info{
+				RepositoryURL: "https://github.com/git-chglog/git-chglog",
+			},
+			Options: &Options{},
+		})
+
+	buf := &bytes.Buffer{}
+	err := gen.Generate(buf, "")
+	expected := strings.TrimSpace(buf.String())
+
+	assert.Error(err)
+	assert.Contains(err.Error(), "git-tag does not exist")
+	assert.Equal("", expected)
 }
 
 func TestGeneratorNotFoundCommits(t *testing.T) {
 	assert := assert.New(t)
 	testName := "not_found"
 
-	setup(testName, func(git gitcmd.Client) {
+	setup(testName, func(commit commitFunc, tag tagFunc, _ gitcmd.Client) {
+		commit("2018-01-01 00:00:00", "feat(*): New feature", "")
+		tag("1.0.0")
 	})
 
-	gen := NewGenerator(&Config{
-		Bin:        "git",
-		WorkingDir: filepath.Join(testRepoRoot, testName),
-		Template:   filepath.Join(cwd, "testdata", testName+".md"),
-		Info: &Info{
-			RepositoryURL: "https://github.com/git-chglog/git-chglog",
-		},
-		Options: &Options{
-			CommitFilters:        map[string][]string{},
-			CommitSortBy:         "Scope",
-			CommitGroupBy:        "Type",
-			CommitGroupSortBy:    "Title",
-			CommitGroupTitleMaps: map[string]string{},
-			HeaderPattern:        "^(\\w*)(?:\\(([\\w\\$\\.\\-\\*\\s]*)\\))?\\:\\s(.*)$",
-			HeaderPatternMaps: []string{
-				"Type",
-				"Scope",
-				"Subject",
+	gen := NewGenerator(NewLogger(os.Stdout, os.Stderr, false, true),
+		&Config{
+			Bin:        "git",
+			WorkingDir: filepath.Join(testRepoRoot, testName),
+			Template:   filepath.Join(cwd, "testdata", testName+".md"),
+			Info: &Info{
+				RepositoryURL: "https://github.com/git-chglog/git-chglog",
 			},
-			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",
-			},
-		},
-	})
+			Options: &Options{},
+		})
 
 	buf := &bytes.Buffer{}
 	err := gen.Generate(buf, "foo")
+	expected := strings.TrimSpace(buf.String())
+
 	assert.Error(err)
-	assert.Equal("", buf.String())
+	assert.Equal("", expected)
 }
 
 func TestGeneratorNotFoundCommitsOne(t *testing.T) {
 	assert := assert.New(t)
 	testName := "not_found"
 
-	setup(testName, func(git gitcmd.Client) {
-		git.Exec("commit", "--allow-empty", "--date", "Mon Jan 1 00:00:00 2018 +0000", "-m", "chore(*): First commit")
+	setup(testName, func(commit commitFunc, tag tagFunc, _ gitcmd.Client) {
+		commit("2018-01-01 00:00:00", "chore(*): First commit", "")
+		tag("1.0.0")
 	})
 
-	gen := NewGenerator(&Config{
-		Bin:        "git",
-		WorkingDir: filepath.Join(testRepoRoot, testName),
-		Template:   filepath.Join(cwd, "testdata", testName+".md"),
-		Info: &Info{
-			RepositoryURL: "https://github.com/git-chglog/git-chglog",
-		},
-		Options: &Options{
-			CommitFilters:        map[string][]string{},
-			CommitSortBy:         "Scope",
-			CommitGroupBy:        "Type",
-			CommitGroupSortBy:    "Title",
-			CommitGroupTitleMaps: map[string]string{},
-			HeaderPattern:        "^(\\w*)(?:\\(([\\w\\$\\.\\-\\*\\s]*)\\))?\\:\\s(.*)$",
-			HeaderPatternMaps: []string{
-				"Type",
-				"Scope",
-				"Subject",
+	gen := NewGenerator(NewLogger(os.Stdout, os.Stderr, false, true),
+		&Config{
+			Bin:        "git",
+			WorkingDir: filepath.Join(testRepoRoot, testName),
+			Template:   filepath.Join(cwd, "testdata", testName+".md"),
+			Info: &Info{
+				RepositoryURL: "https://github.com/git-chglog/git-chglog",
 			},
-			IssuePrefix: []string{
-				"#",
-				"gh-",
+			Options: &Options{
+				CommitFilters:        map[string][]string{},
+				CommitSortBy:         "Scope",
+				CommitGroupBy:        "Type",
+				CommitGroupSortBy:    "Title",
+				CommitGroupTitleMaps: map[string]string{},
+				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",
+				},
 			},
-			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, "foo")
-	assert.Contains(err.Error(), "\"foo\" was not found")
+	expected := strings.TrimSpace(buf.String())
+
 	assert.Error(err)
-	assert.Equal("", buf.String())
+	assert.Contains(err.Error(), "\"foo\" was not found")
+	assert.Equal("", expected)
 }
 
 func TestGeneratorWithTypeScopeSubject(t *testing.T) {
 	assert := assert.New(t)
 	testName := "type_scope_subject"
 
-	setup(testName, func(git gitcmd.Client) {
-		git.Exec("commit", "--allow-empty", "--date", "Mon Jan 1 00:00:00 2018 +0000", "-m", "chore(*): First commit")
-		git.Exec("commit", "--allow-empty", "--date", "Mon Jan 1 00:01:00 2018 +0000", "-m", "feat(core): Add foo bar")
-		git.Exec("commit", "--allow-empty", "--date", "Mon Jan 1 00:02:00 2018 +0000", "-m", "docs(readme): Update usage #123")
+	setup(testName, func(commit commitFunc, tag tagFunc, _ gitcmd.Client) {
+		commit("2018-01-01 00:00:00", "chore(*): First commit", "")
+		commit("2018-01-01 00:01:00", "feat(core): Add foo bar", "")
+		commit("2018-01-01 00:02:00", "docs(readme): Update usage #123", "")
+		tag("1.0.0")
 
-		git.Exec("tag", "1.0.0")
-		git.Exec("commit", "--allow-empty", "--date", "Tue Jan 2 00:00:00 2018 +0000", "-m", "feat(parser): New some super options #333")
-		git.Exec("commit", "--allow-empty", "--date", "Tue Jan 2 00:01:00 2018 +0000", "-m", "Merge pull request #999 from tsuyoshiwada/patch-1")
-		git.Exec("commit", "--allow-empty", "--date", "Tue Jan 2 00:02:00 2018 +0000", "-m", "Merge pull request #1000 from tsuyoshiwada/patch-1")
-		git.Exec("commit", "--allow-empty", "--date", "Tue Jan 2 00:03:00 2018 +0000", "-m", "Revert \"feat(core): Add foo bar @mention and issue #987\"")
+		commit("2018-01-02 00:00:00", "feat(parser): New some super options #333", "")
+		commit("2018-01-02 00:01:00", "Merge pull request #999 from tsuyoshiwada/patch-1", "")
+		commit("2018-01-02 00:02:00", "Merge pull request #1000 from tsuyoshiwada/patch-1", "")
+		commit("2018-01-02 00:03:00", "Revert \"feat(core): Add foo bar @mention and issue #987\"", "")
+		tag("1.1.0")
 
-		git.Exec("tag", "1.1.0")
-		git.Exec("commit", "--allow-empty", "--date", "Wed Jan 3 00:00:00 2018 +0000", "-m", "feat(context): Online breaking change\n\nBREAKING CHANGE: Online breaking change message.")
-		git.Exec("commit", "--allow-empty", "--date", "Wed Jan 3 00:01:00 2018 +0000", "-m", "feat(router): Muliple breaking change\n\nThis is body,\n\nBREAKING CHANGE:\nMultiple\nbreaking\nchange message.")
+		commit("2018-01-03 00:00:00", "feat(context): Online breaking change", "BREAKING CHANGE: Online breaking change message.")
+		commit("2018-01-03 00:01:00", "feat(router): Multiple breaking change", `This is body,
 
-		git.Exec("tag", "2.0.0-beta.0")
-		git.Exec("commit", "--allow-empty", "--date", "Thu Jan 4 00:00:00 2018 +0000", "-m", "refactor(context): gofmt")
-		git.Exec("commit", "--allow-empty", "--date", "Thu Jan 4 00:01:00 2018 +0000", "-m", "fix(core): Fix commit\n\nThis is body message.")
+BREAKING CHANGE:
+Multiple
+breaking
+change message.`)
+		tag("2.0.0-beta.0")
+
+		commit("2018-01-04 00:00:00", "refactor(context): gofmt", "")
+		commit("2018-01-04 00:01:00", "fix(core): Fix commit\n\nThis is body message.", "")
 	})
 
-	gen := NewGenerator(&Config{
-		Bin:        "git",
-		WorkingDir: filepath.Join(testRepoRoot, testName),
-		Template:   filepath.Join(cwd, "testdata", testName+".md"),
-		Info: &Info{
-			Title:         "CHANGELOG Example",
-			RepositoryURL: "https://github.com/git-chglog/git-chglog",
-		},
-		Options: &Options{
-			CommitFilters: map[string][]string{
-				"Type": []string{
-					"feat",
-					"fix",
+	gen := NewGenerator(NewLogger(os.Stdout, os.Stderr, false, true),
+		&Config{
+			Bin:        "git",
+			WorkingDir: filepath.Join(testRepoRoot, testName),
+			Template:   filepath.Join(cwd, "testdata", testName+".md"),
+			Info: &Info{
+				Title:         "CHANGELOG Example",
+				RepositoryURL: "https://github.com/git-chglog/git-chglog",
+			},
+			Options: &Options{
+				Sort: "date",
+				CommitFilters: map[string][]string{
+					"Type": {
+						"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",
 				},
 			},
-			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, "")
+	expected := strings.TrimSpace(buf.String())
 
 	assert.Nil(err)
-	assert.Equal(`<a name="2.0.0-beta.0"></a>
-## 2.0.0-beta.0 (2018-01-03)
+	assert.Equal(`<a name="unreleased"></a>
+## [Unreleased]
 
+### Bug Fixes
+- **core:** Fix commit
+
+
+<a name="2.0.0-beta.0"></a>
+## [2.0.0-beta.0] - 2018-01-03
 ### Features
-
-* **context:** Online breaking change
-* **router:** Muliple breaking change
+- **context:** Online breaking change
+- **router:** Multiple breaking change
 
 ### BREAKING CHANGE
 
@@ -248,28 +288,344 @@ change message.
 Online breaking change message.
 
 
-
 <a name="1.1.0"></a>
-## 1.1.0 (2018-01-02)
-
+## [1.1.0] - 2018-01-02
 ### Features
-
-* **parser:** New some super options #333
+- **parser:** New some super options #333
 
 ### Reverts
-
-* feat(core): Add foo bar @mention and issue #987
+- feat(core): Add foo bar @mention and issue #987
 
 ### Pull Requests
-
-* Merge pull request #1000 from tsuyoshiwada/patch-1
-* Merge pull request #999 from tsuyoshiwada/patch-1
+- Merge pull request #1000 from tsuyoshiwada/patch-1
+- Merge pull request #999 from tsuyoshiwada/patch-1
 
 
 <a name="1.0.0"></a>
-## 1.0.0 (2018-01-01)
-
+## 1.0.0 - 2018-01-01
 ### Features
+- **core:** Add foo bar
+
+
+[Unreleased]: https://github.com/git-chglog/git-chglog/compare/2.0.0-beta.0...HEAD
+[2.0.0-beta.0]: https://github.com/git-chglog/git-chglog/compare/1.1.0...2.0.0-beta.0
+[1.1.0]: https://github.com/git-chglog/git-chglog/compare/1.0.0...1.1.0`, expected)
+}
+
+func TestGeneratorWithNextTag(t *testing.T) {
+	assert := assert.New(t)
+	testName := "type_scope_subject"
+
+	setup(testName, func(commit commitFunc, tag tagFunc, _ gitcmd.Client) {
+		commit("2018-01-01 00:00:00", "feat(core): version 1.0.0", "")
+		tag("1.0.0")
+
+		commit("2018-02-01 00:00:00", "feat(core): version 2.0.0", "")
+		tag("2.0.0")
+
+		commit("2018-03-01 00:00:00", "feat(core): version 3.0.0", "")
+	})
+
+	gen := NewGenerator(NewLogger(os.Stdout, os.Stderr, false, true),
+		&Config{
+			Bin:        "git",
+			WorkingDir: filepath.Join(testRepoRoot, testName),
+			Template:   filepath.Join(cwd, "testdata", testName+".md"),
+			Info: &Info{
+				Title:         "CHANGELOG Example",
+				RepositoryURL: "https://github.com/git-chglog/git-chglog",
+			},
+			Options: &Options{
+				Sort:    "date",
+				NextTag: "3.0.0",
+				CommitFilters: map[string][]string{
+					"Type": {
+						"feat",
+					},
+				},
+				CommitSortBy:      "Scope",
+				CommitGroupBy:     "Type",
+				CommitGroupSortBy: "Title",
+				CommitGroupTitleMaps: map[string]string{
+					"feat": "Features",
+				},
+				HeaderPattern: "^(\\w*)(?:\\(([\\w\\$\\.\\-\\*\\s]*)\\))?\\:\\s(.*)$",
+				HeaderPatternMaps: []string{
+					"Type",
+					"Scope",
+					"Subject",
+				},
+			},
+		})
+
+	buf := &bytes.Buffer{}
+	err := gen.Generate(buf, "")
+	expected := strings.TrimSpace(buf.String())
+
+	assert.Nil(err)
+	assert.Equal(`<a name="unreleased"></a>
+## [Unreleased]
+
+
+<a name="3.0.0"></a>
+## [3.0.0] - 2018-03-01
+### Features
+- **core:** version 3.0.0
+
+
+<a name="2.0.0"></a>
+## [2.0.0] - 2018-02-01
+### Features
+- **core:** version 2.0.0
+
+
+<a name="1.0.0"></a>
+## 1.0.0 - 2018-01-01
+### Features
+- **core:** version 1.0.0
+
+
+[Unreleased]: https://github.com/git-chglog/git-chglog/compare/3.0.0...HEAD
+[3.0.0]: https://github.com/git-chglog/git-chglog/compare/2.0.0...3.0.0
+[2.0.0]: https://github.com/git-chglog/git-chglog/compare/1.0.0...2.0.0`, expected)
+
+	buf = &bytes.Buffer{}
+	err = gen.Generate(buf, "3.0.0")
+	expected = strings.TrimSpace(buf.String())
+
+	assert.Nil(err)
+	assert.Equal(`<a name="unreleased"></a>
+## [Unreleased]
+
+
+<a name="3.0.0"></a>
+## [3.0.0] - 2018-03-01
+### Features
+- **core:** version 3.0.0
+
+
+[Unreleased]: https://github.com/git-chglog/git-chglog/compare/3.0.0...HEAD
+[3.0.0]: https://github.com/git-chglog/git-chglog/compare/2.0.0...3.0.0`, expected)
+}
+
+func TestGeneratorWithTagFiler(t *testing.T) {
+	assert := assert.New(t)
+	testName := "type_scope_subject"
+
+	setup(testName, func(commit commitFunc, tag tagFunc, _ gitcmd.Client) {
+		commit("2018-01-01 00:00:00", "feat(core): version dev-1.0.0", "")
+		tag("dev-1.0.0")
+
+		commit("2018-02-01 00:00:00", "feat(core): version v1.0.0", "")
+		tag("v1.0.0")
+	})
+
+	gen := NewGenerator(NewLogger(os.Stdout, os.Stderr, false, true),
+		&Config{
+			Bin:        "git",
+			WorkingDir: filepath.Join(testRepoRoot, testName),
+			Template:   filepath.Join(cwd, "testdata", testName+".md"),
+			Info: &Info{
+				Title:         "CHANGELOG Example",
+				RepositoryURL: "https://github.com/git-chglog/git-chglog",
+			},
+			Options: &Options{
+				TagFilterPattern: "^v",
+				CommitFilters: map[string][]string{
+					"Type": {
+						"feat",
+					},
+				},
+				CommitSortBy:      "Scope",
+				CommitGroupBy:     "Type",
+				CommitGroupSortBy: "Title",
+				CommitGroupTitleMaps: map[string]string{
+					"feat": "Features",
+				},
+				HeaderPattern: "^(\\w*)(?:\\(([\\w\\$\\.\\-\\*\\s]*)\\))?\\:\\s(.*)$",
+				HeaderPatternMaps: []string{
+					"Type",
+					"Scope",
+					"Subject",
+				},
+			},
+		})
+
+	buf := &bytes.Buffer{}
+	err := gen.Generate(buf, "")
+	expected := strings.TrimSpace(buf.String())
+
+	assert.Nil(err)
+	assert.Equal(`<a name="unreleased"></a>
+## [Unreleased]
+
+
+<a name="v1.0.0"></a>
+## v1.0.0 - 2018-02-01
+### Features
+- **core:** version v1.0.0
+- **core:** version dev-1.0.0
+
+
+[Unreleased]: https://github.com/git-chglog/git-chglog/compare/v1.0.0...HEAD`, expected)
+
+}
+
+func TestGeneratorWithTrimmedBody(t *testing.T) {
+	assert := assert.New(t)
+	testName := "trimmed_body"
+
+	setup(testName, func(commit commitFunc, tag tagFunc, _ gitcmd.Client) {
+		commit("2018-01-01 00:00:00", "feat: single line commit", "")
+		commit("2018-01-01 00:01:00", "feat: multi-line commit", `
+More details about the change and why it went in.
+
+BREAKING CHANGE:
+
+When using .TrimmedBody Notes are not included and can only appear in the Notes section.
+
+Signed-off-by: First Last <first.last@mail.com>
+
+Co-authored-by: dependabot-preview[bot] <27856297+dependabot-preview[bot]@users.noreply.github.com>`)
+
+		commit("2018-01-01 00:00:00", "feat: another single line commit", "")
+		tag("1.0.0")
+	})
+
+	gen := NewGenerator(NewLogger(os.Stdout, os.Stderr, false, true),
+		&Config{
+			Bin:        "git",
+			WorkingDir: filepath.Join(testRepoRoot, testName),
+			Template:   filepath.Join(cwd, "testdata", testName+".md"),
+			Info: &Info{
+				Title:         "CHANGELOG Example",
+				RepositoryURL: "https://github.com/git-chglog/git-chglog",
+			},
+			Options: &Options{
+				CommitFilters: map[string][]string{
+					"Type": {
+						"feat",
+					},
+				},
+				CommitSortBy:      "Scope",
+				CommitGroupBy:     "Type",
+				CommitGroupSortBy: "Title",
+				CommitGroupTitleMaps: map[string]string{
+					"feat": "Features",
+				},
+				HeaderPattern: "^(\\w*)(?:\\(([\\w\\$\\.\\-\\*\\s]*)\\))?\\:\\s(.*)$",
+				HeaderPatternMaps: []string{
+					"Type",
+					"Scope",
+					"Subject",
+				},
+				NoteKeywords: []string{
+					"BREAKING CHANGE",
+				},
+			},
+		})
+
+	buf := &bytes.Buffer{}
+	err := gen.Generate(buf, "")
+	expected := strings.TrimSpace(buf.String())
+
+	assert.Nil(err)
+	assert.Equal(`<a name="unreleased"></a>
+## [Unreleased]
+
+
+<a name="1.0.0"></a>
+## 1.0.0 - 2018-01-01
+### Features
+- another single line commit
+- multi-line commit
+  More details about the change and why it went in.
+- single line commit
+
+### BREAKING CHANGE
+
+When using .TrimmedBody Notes are not included and can only appear in the Notes section.
+
+
+[Unreleased]: https://github.com/git-chglog/git-chglog/compare/1.0.0...HEAD`, expected)
+}
+
+func TestGeneratorWithSprig(t *testing.T) {
+	assert := assert.New(t)
+	testName := "with_sprig"
+
+	setup(testName, func(commit commitFunc, tag tagFunc, _ gitcmd.Client) {
+		commit("2018-01-01 00:00:00", "feat(core): version 1.0.0", "")
+		tag("1.0.0")
+
+		commit("2018-02-01 00:00:00", "feat(core): version 2.0.0", "")
+		tag("2.0.0")
+
+		commit("2018-03-01 00:00:00", "feat(core): version 3.0.0", "")
+	})
+
+	gen := NewGenerator(NewLogger(os.Stdout, os.Stderr, false, true),
+		&Config{
+			Bin:        "git",
+			WorkingDir: filepath.Join(testRepoRoot, testName),
+			Template:   filepath.Join(cwd, "testdata", testName+".md"),
+			Info: &Info{
+				Title:         "CHANGELOG Example",
+				RepositoryURL: "https://github.com/git-chglog/git-chglog",
+			},
+			Options: &Options{
+				Sort:    "date",
+				NextTag: "3.0.0",
+				CommitFilters: map[string][]string{
+					"Type": {
+						"feat",
+					},
+				},
+				CommitSortBy:      "Scope",
+				CommitGroupBy:     "Type",
+				CommitGroupSortBy: "Title",
+				CommitGroupTitleMaps: map[string]string{
+					"feat": "Features",
+				},
+				HeaderPattern: "^(\\w*)(?:\\(([\\w\\$\\.\\-\\*\\s]*)\\))?\\:\\s(.*)$",
+				HeaderPatternMaps: []string{
+					"Type",
+					"Scope",
+					"Subject",
+				},
+			},
+		})
+
+	buf := &bytes.Buffer{}
+	err := gen.Generate(buf, "")
+	expected := strings.TrimSpace(buf.String())
+
+	assert.Nil(err)
+	assert.Equal(`My Changelog
+<a name="unreleased"></a>
+## [Unreleased]
+
+
+<a name="3.0.0"></a>
+## [3.0.0] - 2018-03-01
+### Features
+- **CORE:** version 3.0.0
+
+
+<a name="2.0.0"></a>
+## [2.0.0] - 2018-02-01
+### Features
+- **CORE:** version 2.0.0
+
+
+<a name="1.0.0"></a>
+## 1.0.0 - 2018-01-01
+### Features
+- **CORE:** version 1.0.0
+
+
+[Unreleased]: https://github.com/git-chglog/git-chglog/compare/3.0.0...HEAD
+[3.0.0]: https://github.com/git-chglog/git-chglog/compare/2.0.0...3.0.0
+[2.0.0]: https://github.com/git-chglog/git-chglog/compare/1.0.0...2.0.0`, expected)
 
-* **core:** Add foo bar`, strings.TrimSpace(buf.String()))
 }

cmd/git-chglog/cli.go

@@ -7,6 +7,7 @@ import (
 	"time"
 
 	"github.com/fatih/color"
+
 	chglog "github.com/git-chglog/git-chglog"
 )
 
@@ -14,7 +15,7 @@ import (
 type CLI struct {
 	ctx              *CLIContext
 	fs               FileSystem
-	logger           *Logger
+	logger           *chglog.Logger
 	configLoader     ConfigLoader
 	generator        Generator
 	processorFactory *ProcessorFactory
@@ -34,7 +35,7 @@ func NewCLI(
 	return &CLI{
 		ctx:              ctx,
 		fs:               fs,
-		logger:           NewLogger(ctx.Stdout, ctx.Stderr, silent, ctx.NoEmoji),
+		logger:           chglog.NewLogger(ctx.Stdout, ctx.Stderr, silent, ctx.NoEmoji),
 		configLoader:     configLoader,
 		generator:        generator,
 		processorFactory: NewProcessorFactory(),
@@ -69,7 +70,7 @@ func (c *CLI) Run() int {
 		return ExitCodeError
 	}
 
-	err = c.generator.Generate(w, c.ctx.Query, changelogConfig)
+	err = c.generator.Generate(c.logger, w, c.ctx.Query, changelogConfig)
 	if err != nil {
 		c.logger.Error(err.Error())
 		return ExitCodeError

cmd/git-chglog/cli_test.go

@@ -4,10 +4,13 @@ import (
 	"bytes"
 	"errors"
 	"io"
+	"path/filepath"
+	"regexp"
 	"testing"
 
-	chglog "github.com/git-chglog/git-chglog"
 	"github.com/stretchr/testify/assert"
+
+	chglog "github.com/git-chglog/git-chglog"
 )
 
 func TestCLIForStdout(t *testing.T) {
@@ -34,7 +37,7 @@ func TestCLIForStdout(t *testing.T) {
 			if config.Bin != "/custom/bin/git" {
 				return errors.New("")
 			}
-			w.Write([]byte("success!!"))
+			_, _ = w.Write([]byte("success!!"))
 			return nil
 		},
 	}
@@ -66,13 +69,13 @@ func TestCLIForFile(t *testing.T) {
 
 	mockFS := &mockFileSystem{
 		ReturnMkdirP: func(path string) error {
-			if path != "/dir/to" {
+			if filepath.ToSlash(path) != "/dir/to" {
 				return errors.New("")
 			}
 			return nil
 		},
 		ReturnCreate: func(name string) (File, error) {
-			if name != "/dir/to/CHANGELOG.tpl" {
+			if filepath.ToSlash(name) != "/dir/to/CHANGELOG.tpl" {
 				return nil, errors.New("")
 			}
 			return &mockFile{
@@ -88,7 +91,7 @@ func TestCLIForFile(t *testing.T) {
 
 	configLoader := &mockConfigLoaderImpl{
 		ReturnLoad: func(path string) (*Config, error) {
-			if path != "/.chglog/config.yml" {
+			if filepath.ToSlash(path) != "/.chglog/config.yml" {
 				return nil, errors.New("")
 			}
 			return &Config{
@@ -99,10 +102,10 @@ func TestCLIForFile(t *testing.T) {
 
 	generator := &mockGeneratorImpl{
 		ReturnGenerate: func(w io.Writer, query string, config *chglog.Config) error {
-			if config.Bin != "/custom/bin/git" {
+			if filepath.ToSlash(config.Bin) != "/custom/bin/git" {
 				return errors.New("")
 			}
-			w.Write([]byte("success!!"))
+			_, _ = w.Write([]byte("success!!"))
 			return nil
 		},
 	}
@@ -122,5 +125,6 @@ func TestCLIForFile(t *testing.T) {
 
 	assert.Equal(ExitCodeOK, c.Run())
 	assert.Equal("", stderr.String())
-	assert.Contains(stdout.String(), "Generate of \"/dir/to/CHANGELOG.tpl\"")
+	out := regexp.MustCompile("\x1b\\[[^a-z]*[a-z]").ReplaceAllString(stdout.String(), "")
+	assert.Contains(out, "Generate of \"/dir/to/CHANGELOG.tpl\"")
 }

cmd/git-chglog/config.go

@@ -4,8 +4,9 @@ import (
 	"path/filepath"
 	"strings"
 
-	chglog "github.com/git-chglog/git-chglog"
 	"github.com/imdario/mergo"
+
+	chglog "github.com/git-chglog/git-chglog"
 )
 
 // Info ...
@@ -22,9 +23,10 @@ type CommitOptions struct {
 
 // CommitGroupOptions ...
 type CommitGroupOptions struct {
-	GroupBy   string            `yaml:"group_by"`
-	SortBy    string            `yaml:"sort_by"`
-	TitleMaps map[string]string `yaml:"title_maps"`
+	GroupBy    string            `yaml:"group_by"`
+	SortBy     string            `yaml:"sort_by"`
+	TitleOrder []string          `yaml:"title_order"`
+	TitleMaps  map[string]string `yaml:"title_maps"`
 }
 
 // PatternOptions ...
@@ -48,16 +50,38 @@ type NoteOptions struct {
 	Keywords []string `yaml:"keywords"`
 }
 
+// JiraClientInfoOptions ...
+type JiraClientInfoOptions struct {
+	Username string `yaml:"username"`
+	Token    string `yaml:"token"`
+	URL      string `yaml:"url"`
+}
+
+// JiraIssueOptions ...
+type JiraIssueOptions struct {
+	TypeMaps           map[string]string `yaml:"type_maps"`
+	DescriptionPattern string            `yaml:"description_pattern"`
+}
+
+// JiraOptions ...
+type JiraOptions struct {
+	ClintInfo JiraClientInfoOptions `yaml:"info"`
+	Issue     JiraIssueOptions      `yaml:"issue"`
+}
+
 // Options ...
 type Options struct {
-	Commits      CommitOptions      `yaml:"commits"`
-	CommitGroups CommitGroupOptions `yaml:"commit_groups"`
-	Header       PatternOptions     `yaml:"header"`
-	Issues       IssueOptions       `yaml:"issues"`
-	Refs         RefOptions         `yaml:"refs"`
-	Merges       PatternOptions     `yaml:"merges"`
-	Reverts      PatternOptions     `yaml:"reverts"`
-	Notes        NoteOptions        `yaml:"notes"`
+	TagFilterPattern string             `yaml:"tag_filter_pattern"`
+	Sort             string             `yaml:"sort"`
+	Commits          CommitOptions      `yaml:"commits"`
+	CommitGroups     CommitGroupOptions `yaml:"commit_groups"`
+	Header           PatternOptions     `yaml:"header"`
+	Issues           IssueOptions       `yaml:"issues"`
+	Refs             RefOptions         `yaml:"refs"`
+	Merges           PatternOptions     `yaml:"merges"`
+	Reverts          PatternOptions     `yaml:"reverts"`
+	Notes            NoteOptions        `yaml:"notes"`
+	Jira             JiraOptions        `yaml:"jira"`
 }
 
 // Config ...
@@ -99,6 +123,7 @@ func (config *Config) Normalize(ctx *CLIContext) error {
 	}
 
 	config.normalizeStyle()
+	config.normalizeTagSortBy()
 
 	return nil
 }
@@ -108,6 +133,23 @@ func (config *Config) normalizeStyle() {
 	switch config.Style {
 	case "github":
 		config.normalizeStyleOfGitHub()
+	case "gitlab":
+		config.normalizeStyleOfGitLab()
+	case "bitbucket":
+		config.normalizeStyleOfBitbucket()
+	}
+}
+
+func (config *Config) normalizeTagSortBy() {
+	switch {
+	case config.Options.Sort == "":
+		config.Options.Sort = "date"
+	case strings.EqualFold(config.Options.Sort, "date"):
+		config.Options.Sort = "date"
+	case strings.EqualFold(config.Options.Sort, "semver"):
+		config.Options.Sort = "semver"
+	default:
+		config.Options.Sort = "date"
 	}
 }
 
@@ -147,34 +189,148 @@ func (config *Config) normalizeStyleOfGitHub() {
 	config.Options = opts
 }
 
+// For GitLab
+func (config *Config) normalizeStyleOfGitLab() {
+	opts := config.Options
+
+	if len(opts.Issues.Prefix) == 0 {
+		opts.Issues.Prefix = []string{
+			"#",
+		}
+	}
+
+	if len(opts.Refs.Actions) == 0 {
+		opts.Refs.Actions = []string{
+			"close",
+			"closes",
+			"closed",
+			"closing",
+			"fix",
+			"fixes",
+			"fixed",
+			"fixing",
+			"resolve",
+			"resolves",
+			"resolved",
+			"resolving",
+		}
+	}
+
+	if opts.Merges.Pattern == "" && len(opts.Merges.PatternMaps) == 0 {
+		opts.Merges.Pattern = "^Merge branch '.*' into '(.*)'$"
+		opts.Merges.PatternMaps = []string{
+			"Source",
+		}
+	}
+
+	config.Options = opts
+}
+
+// For Bitbucket
+func (config *Config) normalizeStyleOfBitbucket() {
+	opts := config.Options
+
+	if len(opts.Issues.Prefix) == 0 {
+		opts.Issues.Prefix = []string{
+			"#",
+		}
+	}
+
+	if len(opts.Refs.Actions) == 0 {
+		opts.Refs.Actions = []string{
+			"close",
+			"closes",
+			"closed",
+			"closing",
+			"fix",
+			"fixed",
+			"fixes",
+			"fixing",
+			"resolve",
+			"resolves",
+			"resolved",
+			"resolving",
+			"eopen",
+			"reopens",
+			"reopening",
+			"hold",
+			"holds",
+			"holding",
+			"wontfix",
+			"invalidate",
+			"invalidates",
+			"invalidated",
+			"invalidating",
+			"addresses",
+			"re",
+			"references",
+			"ref",
+			"refs",
+			"see",
+		}
+	}
+
+	if opts.Merges.Pattern == "" && len(opts.Merges.PatternMaps) == 0 {
+		opts.Merges.Pattern = "^Merged in (.*) \\(pull request #(\\d+)\\)$"
+		opts.Merges.PatternMaps = []string{
+			"Source",
+			"Ref",
+		}
+	}
+
+	config.Options = opts
+}
+
+func orValue(str1 string, str2 string) string {
+	if str1 != "" {
+		return str1
+	}
+	return str2
+}
+
 // Convert ...
 func (config *Config) Convert(ctx *CLIContext) *chglog.Config {
 	info := config.Info
 	opts := config.Options
 
+	if ctx.TagFilterPattern == "" {
+		ctx.TagFilterPattern = opts.TagFilterPattern
+	}
+
 	return &chglog.Config{
 		Bin:        config.Bin,
 		WorkingDir: ctx.WorkingDir,
-		Template:   config.Template,
+		Template:   orValue(ctx.Template, config.Template),
 		Info: &chglog.Info{
 			Title:         info.Title,
-			RepositoryURL: info.RepositoryURL,
+			RepositoryURL: orValue(ctx.RepositoryURL, info.RepositoryURL),
 		},
 		Options: &chglog.Options{
-			CommitFilters:        opts.Commits.Filters,
-			CommitSortBy:         opts.Commits.SortBy,
-			CommitGroupBy:        opts.CommitGroups.GroupBy,
-			CommitGroupSortBy:    opts.CommitGroups.SortBy,
-			CommitGroupTitleMaps: opts.CommitGroups.TitleMaps,
-			HeaderPattern:        opts.Header.Pattern,
-			HeaderPatternMaps:    opts.Header.PatternMaps,
-			IssuePrefix:          opts.Issues.Prefix,
-			RefActions:           opts.Refs.Actions,
-			MergePattern:         opts.Merges.Pattern,
-			MergePatternMaps:     opts.Merges.PatternMaps,
-			RevertPattern:        opts.Reverts.Pattern,
-			RevertPatternMaps:    opts.Reverts.PatternMaps,
-			NoteKeywords:         opts.Notes.Keywords,
+			NextTag:                     ctx.NextTag,
+			TagFilterPattern:            ctx.TagFilterPattern,
+			Sort:                        orValue(ctx.Sort, opts.Sort),
+			NoCaseSensitive:             ctx.NoCaseSensitive,
+			Paths:                       ctx.Paths,
+			CommitFilters:               opts.Commits.Filters,
+			CommitSortBy:                opts.Commits.SortBy,
+			CommitGroupBy:               opts.CommitGroups.GroupBy,
+			CommitGroupSortBy:           opts.CommitGroups.SortBy,
+			CommitGroupTitleMaps:        opts.CommitGroups.TitleMaps,
+			CommitGroupTitleOrder:       opts.CommitGroups.TitleOrder,
+			HeaderPattern:               opts.Header.Pattern,
+			HeaderPatternMaps:           opts.Header.PatternMaps,
+			IssuePrefix:                 opts.Issues.Prefix,
+			RefActions:                  opts.Refs.Actions,
+			MergePattern:                opts.Merges.Pattern,
+			MergePatternMaps:            opts.Merges.PatternMaps,
+			RevertPattern:               opts.Reverts.Pattern,
+			RevertPatternMaps:           opts.Reverts.PatternMaps,
+			NoteKeywords:                opts.Notes.Keywords,
+			JiraUsername:                orValue(ctx.JiraUsername, opts.Jira.ClintInfo.Username),
+			JiraToken:                   orValue(ctx.JiraToken, opts.Jira.ClintInfo.Token),
+			JiraURL:                     orValue(ctx.JiraURL, opts.Jira.ClintInfo.URL),
+			JiraTypeMaps:                opts.Jira.Issue.TypeMaps,
+			JiraIssueDescriptionPattern: opts.Jira.Issue.DescriptionPattern,
 		},
 	}
 }

cmd/git-chglog/config_builder.go

@@ -21,8 +21,9 @@ func NewConfigBuilder() ConfigBuilder {
 func (*configBuilderImpl) Build(ans *Answer) (string, error) {
 	var msgFormat *CommitMessageFormat
 
-	for _, f := range formats {
-		if f.Display == ans.CommitMessageFormat {
+	for _, ff := range formats {
+		f, _ := ff.(*CommitMessageFormat)
+		if f.display == ans.CommitMessageFormat {
 			msgFormat = f
 			break
 		}
@@ -45,17 +46,9 @@ info:
 options:
   commits:
     # filters:
-    #   Type:
-    #     - feat
-    #     - fix
-    #     - perf
-    #     - refactor
+    #   Type:%s
   commit_groups:
-    # title_maps:
-    #   feat: Features
-    #   fix: Bug Fixes
-    #   perf: Performance Improvements
-    #   refactor: Code Refactoring
+    # title_maps:%s
   header:
     pattern: "%s"
     pattern_maps:%s
@@ -65,7 +58,9 @@ options:
 		ans.Style,
 		defaultTemplateFilename,
 		repoURL,
-		msgFormat.Pattern,
+		msgFormat.FilterTypesString(),
+		msgFormat.TitleMapsString(),
+		msgFormat.pattern,
 		msgFormat.PatternMapString(),
 	)
 

cmd/git-chglog/config_builder_test.go

@@ -14,21 +14,21 @@ func TestConfigBulider(t *testing.T) {
 	out, err := builder.Build(&Answer{
 		RepositoryURL:       "https://github.com/git-chglog/git-chglog/git-chglog/",
 		Style:               styleNone,
-		CommitMessageFormat: fmtGitBasic.Display,
-		Template:            tplStandard,
+		CommitMessageFormat: fmtGitBasic.display,
+		Template:            tplStandard.display,
 	})
 
 	assert.Nil(err)
 	assert.Contains(out, "style: none")
 	assert.Contains(out, "template: CHANGELOG.tpl.md")
 	assert.Contains(out, "  repository_url: https://github.com/git-chglog/git-chglog/git-chglog")
-	assert.Contains(out, fmt.Sprintf("    pattern: \"%s\"", fmtGitBasic.Pattern))
+	assert.Contains(out, fmt.Sprintf("    pattern: \"%s\"", fmtGitBasic.pattern))
 	assert.Contains(out, fmt.Sprintf(
 		`    pattern_maps:
       - %s
       - %s`,
-		fmtGitBasic.PatternMaps[0],
-		fmtGitBasic.PatternMaps[1],
+		fmtGitBasic.patternMaps[0],
+		fmtGitBasic.patternMaps[1],
 	))
 }
 
@@ -39,8 +39,8 @@ func TestConfigBuliderEmptyRepoURL(t *testing.T) {
 	out, err := builder.Build(&Answer{
 		RepositoryURL:       "",
 		Style:               styleNone,
-		CommitMessageFormat: fmtGitBasic.Display,
-		Template:            tplStandard,
+		CommitMessageFormat: fmtGitBasic.display,
+		Template:            tplStandard.display,
 	})
 
 	assert.Nil(err)
@@ -55,7 +55,7 @@ func TestConfigBuliderInvalidFormat(t *testing.T) {
 		RepositoryURL:       "",
 		Style:               styleNone,
 		CommitMessageFormat: "",
-		Template:            tplStandard,
+		Template:            tplStandard.display,
 	})
 
 	assert.Contains(err.Error(), "invalid commit message format")

cmd/git-chglog/config_loader.go

@@ -1,9 +1,10 @@
 package main
 
 import (
-	"io/ioutil"
+	"os"
+	"path/filepath"
 
-	yaml "gopkg.in/yaml.v2"
+	"gopkg.in/yaml.v2"
 )
 
 // ConfigLoader ...
@@ -20,7 +21,8 @@ func NewConfigLoader() ConfigLoader {
 }
 
 func (loader *configLoaderImpl) Load(path string) (*Config, error) {
-	bytes, err := ioutil.ReadFile(path)
+	fp := filepath.Clean(path)
+	bytes, err := os.ReadFile(fp)
 	if err != nil {
 		return nil, err
 	}

cmd/git-chglog/config_test.go

@@ -1,6 +1,8 @@
 package main
 
 import (
+	"os"
+	"path/filepath"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -17,23 +19,52 @@ func TestConfigNormalize(t *testing.T) {
 	}
 
 	err := config.Normalize(&CLIContext{
-		ConfigPath: "/test/config.yml",
+		ConfigPath: filepath.FromSlash("/test/config.yml"),
 	})
 
 	assert.Nil(err)
 	assert.Equal("git", config.Bin)
 	assert.Equal("https://example.com/foo/bar", config.Info.RepositoryURL)
-	assert.Equal("/test/CHANGELOG.tpl.md", config.Template)
+	assert.Equal("/test/CHANGELOG.tpl.md", filepath.ToSlash(config.Template))
 
 	// abs template
+	cwd, _ := os.Getwd()
+
 	config = &Config{
-		Template: "/CHANGELOG.tpl.md",
+		Template: filepath.Join(cwd, "CHANGELOG.tpl.md"),
 	}
 
 	err = config.Normalize(&CLIContext{
-		ConfigPath: "/test/config.yml",
+		ConfigPath: filepath.Join(cwd, "test", "config.yml"),
 	})
 
 	assert.Nil(err)
-	assert.Equal("/CHANGELOG.tpl.md", config.Template)
+	assert.Equal(filepath.Join(cwd, "CHANGELOG.tpl.md"), config.Template)
+}
+
+func TestConfigConvert(t *testing.T) {
+	var patternInFile = "pattern in config"
+	var patternInArgs = "pattern in cli"
+	assert := assert.New(t)
+	// basic
+	config := &Config{
+		Info: Info{
+			RepositoryURL: "https://example.com/foo/bar/",
+		},
+		Options: Options{TagFilterPattern: patternInFile},
+	}
+	cli := &CLIContext{TagFilterPattern: patternInArgs}
+	cfg := config.Convert(cli)
+	assert.Equal(cfg.Options.TagFilterPattern, patternInArgs)
+
+	config = &Config{
+		Info: Info{
+			RepositoryURL: "https://example.com/foo/bar/",
+		},
+		Options: Options{TagFilterPattern: patternInFile},
+	}
+	cli = &CLIContext{}
+	cfg = config.Convert(cli)
+	assert.Equal(cfg.Options.TagFilterPattern, patternInFile)
+
 }

cmd/git-chglog/context.go

@@ -6,15 +6,25 @@ import (
 
 // CLIContext ...
 type CLIContext struct {
-	WorkingDir string
-	Stdout     io.Writer
-	Stderr     io.Writer
-	ConfigPath string
-	OutputPath string
-	Silent     bool
-	NoColor    bool
-	NoEmoji    bool
-	Query      string
+	WorkingDir       string
+	Stdout           io.Writer
+	Stderr           io.Writer
+	ConfigPath       string
+	Template         string
+	RepositoryURL    string
+	OutputPath       string
+	Silent           bool
+	NoColor          bool
+	NoEmoji          bool
+	NoCaseSensitive  bool
+	Query            string
+	NextTag          string
+	TagFilterPattern string
+	JiraUsername     string
+	JiraToken        string
+	JiraURL          string
+	Paths            []string
+	Sort             string
 }
 
 // InitContext ...

cmd/git-chglog/custom_template_builder.go

@@ -0,0 +1,157 @@
+package main
+
+import "fmt"
+
+type customTemplateBuilderImpl struct{}
+
+// NewCustomTemplateBuilder ...
+func NewCustomTemplateBuilder() TemplateBuilder {
+	return &customTemplateBuilderImpl{}
+}
+
+// Build ...
+func (t *customTemplateBuilderImpl) Build(ans *Answer) (string, error) {
+	// versions
+	tpl := "{{ range .Versions }}\n"
+
+	// version header
+	tpl += t.versionHeader(ans.Style, ans.Template)
+
+	// commits
+	tpl += t.commits(ans.CommitMessageFormat)
+
+	// revert
+	if ans.IncludeReverts {
+		tpl += t.reverts()
+	}
+
+	// merges
+	if ans.IncludeMerges {
+		tpl += t.merges(ans.Style)
+	}
+
+	// notes
+	tpl += t.notes()
+
+	// versions end
+	tpl += "{{ end -}}"
+
+	return tpl, nil
+}
+
+func (*customTemplateBuilderImpl) versionHeader(style, template string) string {
+	var (
+		tpl     string
+		tagName = "{{ .Tag.Name }}"
+		date    = "{{ datetime \"2006-01-02\" .Tag.Date }}"
+	)
+
+	// parts
+	switch style {
+	case styleGitHub, styleGitLab:
+		tpl = templateTagNameAnchor
+		tagName = "{{ if .Tag.Previous }}[{{ .Tag.Name }}]({{ $.Info.RepositoryURL }}/compare/{{ .Tag.Previous.Name }}...{{ .Tag.Name }}){{ else }}{{ .Tag.Name }}{{ end }}"
+	case styleBitbucket:
+		tpl = templateTagNameAnchor
+		tagName = "{{ if .Tag.Previous }}[{{ .Tag.Name }}]({{ $.Info.RepositoryURL }}/compare/{{ .Tag.Name }}..{{ .Tag.Previous.Name }}){{ else }}{{ .Tag.Name }}{{ end }}"
+	}
+
+	// format
+	switch template {
+	case tplStandard.display:
+		tpl = fmt.Sprintf("%s## %s (%s)\n\n",
+			tpl,
+			tagName,
+			date,
+		)
+	case tplCool.display:
+		tpl = fmt.Sprintf("%s## %s\n\n> %s\n\n",
+			tpl,
+			tagName,
+			date,
+		)
+	}
+
+	return tpl
+}
+
+func (*customTemplateBuilderImpl) commits(format string) string {
+	var (
+		header string
+		body   string
+	)
+
+	switch format {
+	case fmtSubject.display:
+		body = `{{ range .Commits -}}
+* {{ .Header }}
+{{ end }}`
+
+	default:
+		if format == fmtTypeScopeSubject.display {
+			header = "{{ if .Scope }}**{{ .Scope }}:** {{ end }}{{ .Subject }}"
+		} else {
+			header = "{{ .Subject }}"
+		}
+
+		body = fmt.Sprintf(`### {{ .Title }}
+
+{{ range .Commits -}}
+* %s
+{{ end }}`, header)
+	}
+
+	return fmt.Sprintf(`{{ range .CommitGroups -}}
+%s
+{{ end -}}
+`, body)
+}
+
+func (*customTemplateBuilderImpl) reverts() string {
+	return `
+{{- if .RevertCommits -}}
+### Reverts
+
+{{ range .RevertCommits -}}
+* {{ .Revert.Header }}
+{{ end }}
+{{ end -}}
+`
+}
+
+func (t *customTemplateBuilderImpl) merges(style string) string {
+	var title string
+
+	switch style {
+	case styleGitHub, styleBitbucket:
+		title = "Pull Requests"
+	case styleGitLab:
+		title = "Merge Requests"
+	default:
+		title = "Merges"
+	}
+
+	return fmt.Sprintf(`
+{{- if .MergeCommits -}}
+### %s
+
+{{ range .MergeCommits -}}
+* {{ .Header }}
+{{ end }}
+{{ end -}}
+`, title)
+}
+
+func (*customTemplateBuilderImpl) notes() string {
+	return `
+{{- if .NoteGroups -}}
+{{ range .NoteGroups -}}
+### {{ .Title }}
+
+{{ range .Notes }}
+{{ .Body }}
+{{ end }}
+{{ end -}}
+{{ end -}}
+`
+}

cmd/git-chglog/custom_template_builder_test.go

@@ -0,0 +1,356 @@
+package main
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCustomTemplateBuilderDefault(t *testing.T) {
+	assert := assert.New(t)
+	builder := NewCustomTemplateBuilder()
+
+	out, err := builder.Build(&Answer{
+		Style:               styleGitHub,
+		CommitMessageFormat: fmtTypeScopeSubject.display,
+		Template:            tplStandard.display,
+		IncludeMerges:       true,
+		IncludeReverts:      true,
+	})
+
+	assert.Nil(err)
+	assert.Equal(`{{ range .Versions }}
+<a name="{{ .Tag.Name }}"></a>
+## {{ if .Tag.Previous }}[{{ .Tag.Name }}]({{ $.Info.RepositoryURL }}/compare/{{ .Tag.Previous.Name }}...{{ .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 -}}`, out)
+}
+
+func TestCustomTemplateBuilderNone(t *testing.T) {
+	assert := assert.New(t)
+	builder := NewCustomTemplateBuilder()
+
+	out, err := builder.Build(&Answer{
+		Style:               styleNone,
+		CommitMessageFormat: fmtTypeScopeSubject.display,
+		Template:            tplStandard.display,
+		IncludeMerges:       true,
+		IncludeReverts:      true,
+	})
+
+	assert.Nil(err)
+	assert.Equal(`{{ range .Versions }}
+## {{ .Tag.Name }} ({{ 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 -}}
+### Merges
+
+{{ range .MergeCommits -}}
+* {{ .Header }}
+{{ end }}
+{{ end -}}
+
+{{- if .NoteGroups -}}
+{{ range .NoteGroups -}}
+### {{ .Title }}
+
+{{ range .Notes }}
+{{ .Body }}
+{{ end }}
+{{ end -}}
+{{ end -}}
+{{ end -}}`, out)
+}
+
+func TestCustomTemplateBuilderSubjectOnly(t *testing.T) {
+	assert := assert.New(t)
+	builder := NewCustomTemplateBuilder()
+
+	out, err := builder.Build(&Answer{
+		Style:               styleNone,
+		CommitMessageFormat: fmtSubject.display,
+		Template:            tplStandard.display,
+		IncludeMerges:       true,
+		IncludeReverts:      true,
+	})
+
+	assert.Nil(err)
+	assert.Equal(`{{ range .Versions }}
+## {{ .Tag.Name }} ({{ datetime "2006-01-02" .Tag.Date }})
+
+{{ range .CommitGroups -}}
+{{ range .Commits -}}
+* {{ .Header }}
+{{ end }}
+{{ end -}}
+
+{{- if .RevertCommits -}}
+### Reverts
+
+{{ range .RevertCommits -}}
+* {{ .Revert.Header }}
+{{ end }}
+{{ end -}}
+
+{{- if .MergeCommits -}}
+### Merges
+
+{{ range .MergeCommits -}}
+* {{ .Header }}
+{{ end }}
+{{ end -}}
+
+{{- if .NoteGroups -}}
+{{ range .NoteGroups -}}
+### {{ .Title }}
+
+{{ range .Notes }}
+{{ .Body }}
+{{ end }}
+{{ end -}}
+{{ end -}}
+{{ end -}}`, out)
+}
+
+func TestCustomTemplateBuilderSubject(t *testing.T) {
+	assert := assert.New(t)
+	builder := NewCustomTemplateBuilder()
+
+	out, err := builder.Build(&Answer{
+		Style:               styleNone,
+		CommitMessageFormat: fmtTypeSubject.display,
+		Template:            tplStandard.display,
+		IncludeMerges:       true,
+		IncludeReverts:      true,
+	})
+
+	assert.Nil(err)
+	assert.Equal(`{{ range .Versions }}
+## {{ .Tag.Name }} ({{ datetime "2006-01-02" .Tag.Date }})
+
+{{ range .CommitGroups -}}
+### {{ .Title }}
+
+{{ range .Commits -}}
+* {{ .Subject }}
+{{ end }}
+{{ end -}}
+
+{{- if .RevertCommits -}}
+### Reverts
+
+{{ range .RevertCommits -}}
+* {{ .Revert.Header }}
+{{ end }}
+{{ end -}}
+
+{{- if .MergeCommits -}}
+### Merges
+
+{{ range .MergeCommits -}}
+* {{ .Header }}
+{{ end }}
+{{ end -}}
+
+{{- if .NoteGroups -}}
+{{ range .NoteGroups -}}
+### {{ .Title }}
+
+{{ range .Notes }}
+{{ .Body }}
+{{ end }}
+{{ end -}}
+{{ end -}}
+{{ end -}}`, out)
+}
+
+func TestCustomTemplateBuilderIgnoreReverts(t *testing.T) {
+	assert := assert.New(t)
+	builder := NewCustomTemplateBuilder()
+
+	out, err := builder.Build(&Answer{
+		Style:               styleNone,
+		CommitMessageFormat: fmtTypeSubject.display,
+		Template:            tplStandard.display,
+		IncludeMerges:       true,
+		IncludeReverts:      false,
+	})
+
+	assert.Nil(err)
+	assert.Equal(`{{ range .Versions }}
+## {{ .Tag.Name }} ({{ datetime "2006-01-02" .Tag.Date }})
+
+{{ range .CommitGroups -}}
+### {{ .Title }}
+
+{{ range .Commits -}}
+* {{ .Subject }}
+{{ end }}
+{{ end -}}
+
+{{- if .MergeCommits -}}
+### Merges
+
+{{ range .MergeCommits -}}
+* {{ .Header }}
+{{ end }}
+{{ end -}}
+
+{{- if .NoteGroups -}}
+{{ range .NoteGroups -}}
+### {{ .Title }}
+
+{{ range .Notes }}
+{{ .Body }}
+{{ end }}
+{{ end -}}
+{{ end -}}
+{{ end -}}`, out)
+}
+
+func TestCustomTemplateBuilderIgnoreMerges(t *testing.T) {
+	assert := assert.New(t)
+	builder := NewCustomTemplateBuilder()
+
+	out, err := builder.Build(&Answer{
+		Style:               styleNone,
+		CommitMessageFormat: fmtTypeSubject.display,
+		Template:            tplStandard.display,
+		IncludeMerges:       false,
+		IncludeReverts:      true,
+	})
+
+	assert.Nil(err)
+	assert.Equal(`{{ range .Versions }}
+## {{ .Tag.Name }} ({{ datetime "2006-01-02" .Tag.Date }})
+
+{{ range .CommitGroups -}}
+### {{ .Title }}
+
+{{ range .Commits -}}
+* {{ .Subject }}
+{{ end }}
+{{ end -}}
+
+{{- if .RevertCommits -}}
+### Reverts
+
+{{ range .RevertCommits -}}
+* {{ .Revert.Header }}
+{{ end }}
+{{ end -}}
+
+{{- if .NoteGroups -}}
+{{ range .NoteGroups -}}
+### {{ .Title }}
+
+{{ range .Notes }}
+{{ .Body }}
+{{ end }}
+{{ end -}}
+{{ end -}}
+{{ end -}}`, out)
+}
+
+func TestCustomTemplateBuilderCool(t *testing.T) {
+	assert := assert.New(t)
+	builder := NewCustomTemplateBuilder()
+
+	out, err := builder.Build(&Answer{
+		Style:               styleNone,
+		CommitMessageFormat: fmtTypeScopeSubject.display,
+		Template:            tplCool.display,
+		IncludeMerges:       true,
+		IncludeReverts:      true,
+	})
+
+	assert.Nil(err)
+	assert.Equal(`{{ range .Versions }}
+## {{ .Tag.Name }}
+
+> {{ 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 -}}
+### Merges
+
+{{ range .MergeCommits -}}
+* {{ .Header }}
+{{ end }}
+{{ end -}}
+
+{{- if .NoteGroups -}}
+{{ range .NoteGroups -}}
+### {{ .Title }}
+
+{{ range .Notes }}
+{{ .Body }}
+{{ end }}
+{{ end -}}
+{{ end -}}
+{{ end -}}`, out)
+}

cmd/git-chglog/fs.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"io"
-	"io/ioutil"
 	"os"
 )
 
@@ -35,15 +34,18 @@ func (*osFileSystem) Exists(path string) bool {
 
 func (*osFileSystem) MkdirP(path string) error {
 	if _, err := os.Stat(path); os.IsNotExist(err) {
+		//nolint:gosec
 		return os.MkdirAll(path, os.ModePerm)
 	}
 	return nil
 }
 
 func (*osFileSystem) Create(name string) (File, error) {
+	//nolint: gosec
 	return os.Create(name)
 }
 
 func (*osFileSystem) WriteFile(path string, content []byte) error {
-	return ioutil.WriteFile(path, content, os.ModePerm)
+	//nolint:gosec
+	return os.WriteFile(path, content, os.ModePerm)
 }

cmd/git-chglog/generator.go

@@ -8,7 +8,7 @@ import (
 
 // Generator ...
 type Generator interface {
-	Generate(io.Writer, string, *chglog.Config) error
+	Generate(*chglog.Logger, io.Writer, string, *chglog.Config) error
 }
 
 type generatorImpl struct{}
@@ -19,6 +19,6 @@ func NewGenerator() Generator {
 }
 
 // Generate ...
-func (*generatorImpl) Generate(w io.Writer, query string, config *chglog.Config) error {
-	return chglog.NewGenerator(config).Generate(w, query)
+func (*generatorImpl) Generate(logger *chglog.Logger, w io.Writer, query string, config *chglog.Config) error {
+	return chglog.NewGenerator(logger, config).Generate(w, query)
 }

cmd/git-chglog/generator_mock.go

@@ -10,6 +10,6 @@ type mockGeneratorImpl struct {
 	ReturnGenerate func(io.Writer, string, *chglog.Config) error
 }
 
-func (m *mockGeneratorImpl) Generate(w io.Writer, query string, config *chglog.Config) error {
+func (m *mockGeneratorImpl) Generate(logger *chglog.Logger, w io.Writer, query string, config *chglog.Config) error {
 	return m.ReturnGenerate(w, query, config)
 }

cmd/git-chglog/initializer.go

@@ -5,18 +5,18 @@ import (
 	"path/filepath"
 
 	"github.com/fatih/color"
-	gitcmd "github.com/tsuyoshiwada/go-gitcmd"
+
+	chglog "github.com/git-chglog/git-chglog"
 )
 
 // Initializer ...
 type Initializer struct {
-	ctx             *InitContext
-	client          gitcmd.Client
-	fs              FileSystem
-	logger          *Logger
-	questioner      Questioner
-	configBuilder   ConfigBuilder
-	templateBuilder TemplateBuilder
+	ctx                    *InitContext
+	fs                     FileSystem
+	logger                 *chglog.Logger
+	questioner             Questioner
+	configBuilder          ConfigBuilder
+	templateBuilderFactory TemplateBuilderFactory
 }
 
 // NewInitializer ...
@@ -25,15 +25,14 @@ func NewInitializer(
 	fs FileSystem,
 	questioner Questioner,
 	configBuilder ConfigBuilder,
-	templateBuilder TemplateBuilder,
-) *Initializer {
+	tplBuilderFactory TemplateBuilderFactory) *Initializer {
 	return &Initializer{
-		ctx:             ctx,
-		fs:              fs,
-		logger:          NewLogger(ctx.Stdout, ctx.Stderr, false, false),
-		questioner:      questioner,
-		configBuilder:   configBuilder,
-		templateBuilder: templateBuilder,
+		ctx:                    ctx,
+		fs:                     fs,
+		logger:                 chglog.NewLogger(ctx.Stdout, ctx.Stderr, false, false),
+		questioner:             questioner,
+		configBuilder:          configBuilder,
+		templateBuilderFactory: tplBuilderFactory,
 	}
 }
 
@@ -86,7 +85,8 @@ func (init *Initializer) generateConfig(ans *Answer) error {
 }
 
 func (init *Initializer) generateTemplate(ans *Answer) error {
-	s, err := init.templateBuilder.Build(ans)
+	templateBuilder := init.templateBuilderFactory(ans.Template)
+	s, err := templateBuilder.Build(ans)
 	if err != nil {
 		return err
 	}

cmd/git-chglog/initializer_test.go

@@ -3,6 +3,7 @@ package main
 import (
 	"bytes"
 	"errors"
+	"path/filepath"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -16,13 +17,13 @@ func TestInitializer(t *testing.T) {
 
 	mockFs := &mockFileSystem{
 		ReturnMkdirP: func(path string) error {
-			if path == "/test/config" {
+			if path == filepath.FromSlash("/test/config") {
 				return nil
 			}
 			return errors.New("")
 		},
 		ReturnWriteFile: func(path string, content []byte) error {
-			if path == "/test/config/config.yml" || path == "/test/config/CHANGELOG.tpl.md" {
+			if path == filepath.FromSlash("/test/config/config.yml") || path == filepath.FromSlash("/test/config/CHANGELOG.tpl.md") {
 				return nil
 			}
 			return errors.New("")
@@ -64,7 +65,9 @@ func TestInitializer(t *testing.T) {
 		mockFs,
 		questioner,
 		configBuilder,
-		tplBuilder,
+		func(t string) TemplateBuilder {
+			return tplBuilder
+		},
 	)
 
 	assert.Equal(ExitCodeOK, init.Run())

cmd/git-chglog/kac_template_builder.go

@@ -0,0 +1,181 @@
+package main
+
+import "fmt"
+
+type kacTemplateBuilderImpl struct{}
+
+// NewKACTemplateBuilder ...
+func NewKACTemplateBuilder() TemplateBuilder {
+	return &kacTemplateBuilderImpl{}
+}
+
+// Build ...
+func (t *kacTemplateBuilderImpl) Build(ans *Answer) (string, error) {
+	// unreleased
+	tpl := t.unreleased(ans.Style, ans.CommitMessageFormat)
+
+	// version start
+	tpl += "\n{{ range .Versions }}\n"
+
+	tpl += t.versionHeader(ans.Style)
+
+	// commits
+	tpl += t.commits(".CommitGroups", ans.CommitMessageFormat)
+
+	// revert
+	if ans.IncludeReverts {
+		tpl += t.reverts()
+	}
+
+	// merges
+	if ans.IncludeMerges {
+		tpl += t.merges(ans.Style)
+	}
+
+	// notes
+	tpl += t.notes()
+
+	// versions end
+	tpl += "\n{{ end -}}"
+
+	// footer (links)
+	tpl += t.footer(ans.Style)
+
+	return tpl, nil
+}
+
+func (t *kacTemplateBuilderImpl) unreleased(style, format string) string {
+	var (
+		id      = ""
+		title   = "Unreleased"
+		commits = t.commits(".Unreleased.CommitGroups", format)
+	)
+
+	switch style {
+	case styleGitHub, styleGitLab, styleBitbucket:
+		id = "<a name=\"unreleased\"></a>\n"
+		title = fmt.Sprintf("[%s]", title)
+	}
+
+	return fmt.Sprintf(`{{ if .Versions -}}
+%s## %s
+
+{{ if .Unreleased.CommitGroups -}}
+%s{{ end -}}
+{{ end -}}
+`, id, title, commits)
+}
+
+func (t *kacTemplateBuilderImpl) versionHeader(style string) string {
+	var (
+		id      = ""
+		tagName = "{{ .Tag.Name }}"
+		date    = "{{ datetime \"2006-01-02\" .Tag.Date }}"
+	)
+
+	switch style {
+	case styleGitHub, styleGitLab, styleBitbucket:
+		id = templateTagNameAnchor
+		tagName = "{{ if .Tag.Previous }}[{{ .Tag.Name }}]{{ else }}{{ .Tag.Name }}{{ end }}"
+	}
+
+	return fmt.Sprintf("%s## %s - %s\n", id, tagName, date)
+}
+
+func (t *kacTemplateBuilderImpl) commits(commitGroups, format string) string {
+	var (
+		body string
+	)
+
+	switch format {
+	case fmtSubject.display:
+		body = `{{ range .Commits -}}
+- {{ .Header }}
+{{ end }}`
+
+	default:
+		body = `### {{ .Title }}
+{{ range .Commits -}}
+- {{ if .Scope }}**{{ .Scope }}:** {{ end }}{{ .Subject }}
+{{ end }}`
+	}
+
+	return fmt.Sprintf(`{{ range %s -}}
+%s
+{{ end -}}
+`, commitGroups, body)
+}
+
+func (t *kacTemplateBuilderImpl) reverts() string {
+	return `
+{{- if .RevertCommits -}}
+### Reverts
+{{ range .RevertCommits -}}
+- {{ .Revert.Header }}
+{{ end }}
+{{ end -}}
+`
+}
+
+func (t *kacTemplateBuilderImpl) merges(style string) string {
+	var title string
+
+	switch style {
+	case styleGitHub, styleBitbucket:
+		title = "Pull Requests"
+	case styleGitLab:
+		title = "Merge Requests"
+	default:
+		title = "Merges"
+	}
+
+	return fmt.Sprintf(`
+{{- if .MergeCommits -}}
+### %s
+{{ range .MergeCommits -}}
+- {{ .Header }}
+{{ end }}
+{{ end -}}
+`, title)
+}
+
+func (*kacTemplateBuilderImpl) notes() string {
+	return `
+{{- if .NoteGroups -}}
+{{ range .NoteGroups -}}
+### {{ .Title }}
+{{ range .Notes }}
+{{ .Body }}
+{{ end }}
+{{ end -}}
+{{ end -}}`
+}
+
+func (*kacTemplateBuilderImpl) footer(style string) string {
+	switch style {
+	case styleGitHub, styleGitLab:
+		return `
+
+{{- 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 -}}`
+	case styleBitbucket:
+		return `
+
+{{- if .Versions }}
+[Unreleased]: {{ .Info.RepositoryURL }}/compare/HEAD..{{ $latest := index .Versions 0 }}{{ $latest.Tag.Name }}
+{{ range .Versions -}}
+{{ if .Tag.Previous -}}
+[{{ .Tag.Name }}]: {{ $.Info.RepositoryURL }}/compare/{{ .Tag.Name }}..{{ .Tag.Previous.Name }}
+{{ end -}}
+{{ end -}}
+{{ end -}}`
+	default:
+		return ""
+	}
+}

cmd/git-chglog/kac_template_builder_test.go

@@ -0,0 +1,196 @@
+package main
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestKACTemplateBuilderDefault(t *testing.T) {
+	assert := assert.New(t)
+	builder := NewKACTemplateBuilder()
+
+	out, err := builder.Build(&Answer{
+		Style:               styleGitHub,
+		CommitMessageFormat: fmtTypeScopeSubject.display,
+		Template:            tplKeepAChangelog.display,
+		IncludeMerges:       true,
+		IncludeReverts:      true,
+	})
+
+	assert.Nil(err)
+	assert.Equal(`{{ 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 -}}`, out)
+}
+
+func TestKACTemplateBuilderNone(t *testing.T) {
+	assert := assert.New(t)
+	builder := NewKACTemplateBuilder()
+
+	out, err := builder.Build(&Answer{
+		Style:               styleNone,
+		CommitMessageFormat: fmtTypeScopeSubject.display,
+		Template:            tplKeepAChangelog.display,
+		IncludeMerges:       true,
+		IncludeReverts:      true,
+	})
+
+	assert.Nil(err)
+	assert.Equal(`{{ if .Versions -}}
+## Unreleased
+
+{{ if .Unreleased.CommitGroups -}}
+{{ range .Unreleased.CommitGroups -}}
+### {{ .Title }}
+{{ range .Commits -}}
+- {{ if .Scope }}**{{ .Scope }}:** {{ end }}{{ .Subject }}
+{{ end }}
+{{ end -}}
+{{ end -}}
+{{ end -}}
+
+{{ range .Versions }}
+## {{ .Tag.Name }} - {{ 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 -}}
+### Merges
+{{ range .MergeCommits -}}
+- {{ .Header }}
+{{ end }}
+{{ end -}}
+
+{{- if .NoteGroups -}}
+{{ range .NoteGroups -}}
+### {{ .Title }}
+{{ range .Notes }}
+{{ .Body }}
+{{ end }}
+{{ end -}}
+{{ end -}}
+{{ end -}}`, out)
+}
+
+func TestKACTemplateBuilderSubject(t *testing.T) {
+	assert := assert.New(t)
+	builder := NewKACTemplateBuilder()
+
+	out, err := builder.Build(&Answer{
+		Style:               styleNone,
+		CommitMessageFormat: fmtSubject.display,
+		Template:            tplKeepAChangelog.display,
+		IncludeMerges:       true,
+		IncludeReverts:      true,
+	})
+
+	assert.Nil(err)
+	assert.Equal(`{{ if .Versions -}}
+## Unreleased
+
+{{ if .Unreleased.CommitGroups -}}
+{{ range .Unreleased.CommitGroups -}}
+{{ range .Commits -}}
+- {{ .Header }}
+{{ end }}
+{{ end -}}
+{{ end -}}
+{{ end -}}
+
+{{ range .Versions }}
+## {{ .Tag.Name }} - {{ datetime "2006-01-02" .Tag.Date }}
+{{ range .CommitGroups -}}
+{{ range .Commits -}}
+- {{ .Header }}
+{{ end }}
+{{ end -}}
+
+{{- if .RevertCommits -}}
+### Reverts
+{{ range .RevertCommits -}}
+- {{ .Revert.Header }}
+{{ end }}
+{{ end -}}
+
+{{- if .MergeCommits -}}
+### Merges
+{{ range .MergeCommits -}}
+- {{ .Header }}
+{{ end }}
+{{ end -}}
+
+{{- if .NoteGroups -}}
+{{ range .NoteGroups -}}
+### {{ .Title }}
+{{ range .Notes }}
+{{ .Body }}
+{{ end }}
+{{ end -}}
+{{ end -}}
+{{ end -}}`, out)
+}

cmd/git-chglog/main.go

@@ -2,14 +2,22 @@ package main
 
 import (
 	"fmt"
+	"io"
+	"log"
 	"os"
 
 	"github.com/fatih/color"
-	gitcmd "github.com/tsuyoshiwada/go-gitcmd"
-	"github.com/urfave/cli"
+	"github.com/mattn/go-colorable"
+	"github.com/tsuyoshiwada/go-gitcmd"
+	"github.com/urfave/cli/v2"
 )
 
-func main() {
+// version is passed in via LDFLAGS main.version
+var version string
+
+// CreateApp creates and initializes CLI application
+// with description, flags, version, etc.
+func CreateApp(actionFunc cli.ActionFunc) *cli.App {
 	ttl := color.New(color.FgYellow).SprintFunc()
 
 	cli.AppHelpTemplate = fmt.Sprintf(`
@@ -51,56 +59,130 @@ func main() {
 
   $ {{.Name}} --config custom/dir/config.yml
 
-    The adove is a command that uses a configuration file placed other than ".chglog/config.yml".
+		The above is a command that uses a configuration file placed other than ".chglog/config.yml".
+
+	$ {{.Name}} --path path/to/my/component --output CHANGELOG.component.md
+
+		Filter commits by specific paths or files in git and output to a component specific changelog.
 `,
 		ttl("USAGE:"),
 		ttl("OPTIONS:"),
 		ttl("EXAMPLE:"),
 	)
 
+	cli.HelpPrinter = func(w io.Writer, templ string, data interface{}) {
+		cli.HelpPrinterCustom(colorable.NewColorableStdout(), templ, data, nil)
+	}
+
 	app := cli.NewApp()
 	app.Name = "git-chglog"
 	app.Usage = "todo usage for git-chglog"
-	app.Version = Version
+	app.Version = version
 
 	app.Flags = []cli.Flag{
 		// init
-		cli.BoolFlag{
+		&cli.BoolFlag{
 			Name:  "init",
 			Usage: "generate the git-chglog configuration file in interactive",
 		},
 
+		// path
+		&cli.StringSliceFlag{
+			Name:  "path",
+			Usage: "Filter commits by path(s). Can use multiple times.",
+		},
+
 		// config
-		cli.StringFlag{
-			Name:  "config, c",
-			Usage: "specifies a different configuration file to pick up",
-			Value: ".chglog/config.yml",
+		&cli.StringFlag{
+			Name:    "config, c",
+			Aliases: []string{"c"},
+			Usage:   "specifies a different configuration file to pick up",
+			Value:   ".chglog/config.yml",
+		},
+
+		// template
+		&cli.StringFlag{
+			Name:    "template",
+			Aliases: []string{"t"},
+			Usage:   "specifies a template file to pick up. If not specified, use the one in config",
+		},
+
+		// repository url
+		&cli.StringFlag{
+			Name:  "repository-url",
+			Usage: "specifies git repo URL. If not specified, use 'repository_url' in config",
 		},
 
 		// output
-		cli.StringFlag{
-			Name:  "output, o",
-			Usage: "output path and filename for the changelogs. If not specified, output to stdout",
+		&cli.StringFlag{
+			Name:    "output",
+			Aliases: []string{"o"},
+			Usage:   "output path and filename for the changelogs. If not specified, output to stdout",
+		},
+
+		&cli.StringFlag{
+			Name:  "next-tag",
+			Usage: "treat unreleased commits as specified tags (EXPERIMENTAL)",
 		},
 
 		// silent
-		cli.BoolFlag{
+		&cli.BoolFlag{
 			Name:  "silent",
 			Usage: "disable stdout output",
 		},
 
 		// no-color
-		cli.BoolFlag{
-			Name:   "no-color",
-			Usage:  "disable color output",
-			EnvVar: "NO_COLOR",
+		&cli.BoolFlag{
+			Name:    "no-color",
+			Usage:   "disable color output",
+			EnvVars: []string{"NO_COLOR"},
 		},
 
 		// no-emoji
-		cli.BoolFlag{
-			Name:   "no-emoji",
-			Usage:  "disable emoji output",
-			EnvVar: "NO_EMOJI",
+		&cli.BoolFlag{
+			Name:    "no-emoji",
+			Usage:   "disable emoji output",
+			EnvVars: []string{"NO_EMOJI"},
+		},
+
+		// no-case
+		&cli.BoolFlag{
+			Name:  "no-case",
+			Usage: "disable case sensitive filters",
+		},
+
+		// tag-filter-pattern
+		&cli.StringFlag{
+			Name:  "tag-filter-pattern",
+			Usage: "Regular expression of tag filter. Is specified, only matched tags will be picked",
+		},
+
+		// jira-url
+		&cli.StringFlag{
+			Name:    "jira-url",
+			Usage:   "Jira URL",
+			EnvVars: []string{"JIRA_URL"},
+		},
+
+		// jira-username
+		&cli.StringFlag{
+			Name:    "jira-username",
+			Usage:   "Jira username",
+			EnvVars: []string{"JIRA_USERNAME"},
+		},
+
+		// jira-token
+		&cli.StringFlag{
+			Name:    "jira-token",
+			Usage:   "Jira token",
+			EnvVars: []string{"JIRA_TOKEN"},
+		},
+
+		// sort
+		&cli.StringFlag{
+			Name:        "sort",
+			Usage:       "Specify how to sort tags; currently supports \"date\" or by \"semver\"",
+			DefaultText: "date",
 		},
 
 		// help & version
@@ -108,57 +190,79 @@ func main() {
 		cli.VersionFlag,
 	}
 
-	app.Action = func(c *cli.Context) error {
-		wd, err := os.Getwd()
-		if err != nil {
-			fmt.Fprintln(os.Stderr, "failed to get working directory", err)
-			os.Exit(ExitCodeError)
-		}
+	app.Action = actionFunc
 
-		// initializer
-		if c.Bool("init") {
-			initializer := NewInitializer(
-				&InitContext{
-					WorkingDir: wd,
-					Stdout:     os.Stdout,
-					Stderr:     os.Stderr,
-				},
-				fs,
-				NewQuestioner(
-					gitcmd.New(&gitcmd.Config{
-						Bin: "git",
-					}),
-					fs,
-				),
-				NewConfigBuilder(),
-				NewTemplateBuilder(),
-			)
+	return app
+}
 
-			os.Exit(initializer.Run())
-		}
-
-		// chglog
-		chglogCLI := NewCLI(
-			&CLIContext{
-				WorkingDir: wd,
-				Stdout:     os.Stdout,
-				Stderr:     os.Stderr,
-				ConfigPath: c.String("config"),
-				OutputPath: c.String("output"),
-				Silent:     c.Bool("silent"),
-				NoColor:    c.Bool("no-color"),
-				NoEmoji:    c.Bool("no-emoji"),
-				Query:      c.Args().First(),
-			},
-			fs,
-			NewConfigLoader(),
-			NewGenerator(),
-		)
-
-		os.Exit(chglogCLI.Run())
-
-		return nil
+// AppAction is a callback function to create initializer
+// and CLIContext and ultimately run the application.
+func AppAction(c *cli.Context) error {
+	wd, err := os.Getwd()
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "failed to get working directory", err)
+		os.Exit(ExitCodeError)
 	}
 
-	app.Run(os.Args)
+	// initializer
+	if c.Bool("init") {
+		initializer := NewInitializer(
+			&InitContext{
+				WorkingDir: wd,
+				Stdout:     colorable.NewColorableStdout(),
+				Stderr:     colorable.NewColorableStderr(),
+			},
+			fs,
+			NewQuestioner(
+				gitcmd.New(&gitcmd.Config{
+					Bin: "git",
+				}),
+				fs,
+			),
+			NewConfigBuilder(),
+			templateBuilderFactory,
+		)
+
+		os.Exit(initializer.Run())
+	}
+
+	// chglog
+	chglogCLI := NewCLI(
+		&CLIContext{
+			WorkingDir:       wd,
+			Stdout:           colorable.NewColorableStdout(),
+			Stderr:           colorable.NewColorableStderr(),
+			ConfigPath:       c.String("config"),
+			Template:         c.String("template"),
+			RepositoryURL:    c.String("repository-url"),
+			OutputPath:       c.String("output"),
+			Silent:           c.Bool("silent"),
+			NoColor:          c.Bool("no-color"),
+			NoEmoji:          c.Bool("no-emoji"),
+			NoCaseSensitive:  c.Bool("no-case"),
+			Query:            c.Args().First(),
+			NextTag:          c.String("next-tag"),
+			TagFilterPattern: c.String("tag-filter-pattern"),
+			JiraUsername:     c.String("jira-username"),
+			JiraToken:        c.String("jira-token"),
+			JiraURL:          c.String("jira-url"),
+			Paths:            c.StringSlice("path"),
+			Sort:             c.String("sort"),
+		},
+		fs,
+		NewConfigLoader(),
+		NewGenerator(),
+	)
+
+	os.Exit(chglogCLI.Run())
+
+	return nil
+}
+
+func main() {
+	app := CreateApp(AppAction)
+	err := app.Run(os.Args)
+	if err != nil {
+		log.Fatal(err)
+	}
 }

cmd/git-chglog/main_test.go

@@ -0,0 +1,45 @@
+package main
+
+import (
+	"log"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/urfave/cli/v2"
+)
+
+var gAssert *assert.Assertions
+
+func mockAppAction(c *cli.Context) error {
+	assert := gAssert
+	assert.Equal("c.yml", c.String("config"))
+	assert.Equal("^v", c.String("tag-filter-pattern"))
+	assert.Equal("o.md", c.String("output"))
+	assert.Equal("v5", c.String("next-tag"))
+	assert.True(c.Bool("silent"))
+	assert.True(c.Bool("no-color"))
+	assert.True(c.Bool("no-emoji"))
+	return nil
+}
+
+func TestCreateApp(t *testing.T) {
+	assert := assert.New(t)
+	assert.True(true)
+	gAssert = assert
+
+	app := CreateApp(mockAppAction)
+	args := []string{
+		"git-chglog",
+		"--silent",
+		"--no-color",
+		"--no-emoji",
+		"--config", "c.yml",
+		"--output", "o.md",
+		"--next-tag", "v5",
+		"--tag-filter-pattern", "^v",
+	}
+	err := app.Run(args)
+	if err != nil {
+		log.Fatal(err)
+	}
+}

cmd/git-chglog/processor_factory.go

@@ -16,7 +16,9 @@ type ProcessorFactory struct {
 func NewProcessorFactory() *ProcessorFactory {
 	return &ProcessorFactory{
 		hostRegistry: map[string]string{
-			"github": "github.com",
+			"github":    "github.com",
+			"gitlab":    "gitlab.com",
+			"bitbucket": "bitbucket.org",
 		},
 	}
 }
@@ -41,6 +43,14 @@ func (factory *ProcessorFactory) Create(config *Config) (chglog.Processor, error
 		return &chglog.GitHubProcessor{
 			Host: fmt.Sprintf("%s://%s", obj.Scheme, obj.Host),
 		}, nil
+	case "gitlab.com":
+		return &chglog.GitLabProcessor{
+			Host: fmt.Sprintf("%s://%s", obj.Scheme, obj.Host),
+		}, nil
+	case "bitbucket.org":
+		return &chglog.BitbucketProcessor{
+			Host: fmt.Sprintf("%s://%s", obj.Scheme, obj.Host),
+		}, nil
 	default:
 		return nil, nil
 	}

cmd/git-chglog/processor_factory_test.go

@@ -3,8 +3,9 @@ package main
 import (
 	"testing"
 
-	chglog "github.com/git-chglog/git-chglog"
 	"github.com/stretchr/testify/assert"
+
+	chglog "github.com/git-chglog/git-chglog"
 )
 
 func TestProcessorFactory(t *testing.T) {
@@ -56,3 +57,75 @@ func TestProcessorFactoryForGitHub(t *testing.T) {
 		processor,
 	)
 }
+
+func TestProcessorFactoryForGitLab(t *testing.T) {
+	assert := assert.New(t)
+	factory := NewProcessorFactory()
+
+	// gitlab.com
+	processor, err := factory.Create(&Config{
+		Info: Info{
+			RepositoryURL: "https://gitlab.com/owner/repo",
+		},
+	})
+
+	assert.Nil(err)
+	assert.Equal(
+		&chglog.GitLabProcessor{
+			Host: "https://gitlab.com",
+		},
+		processor,
+	)
+
+	// self-hosted
+	processor, err = factory.Create(&Config{
+		Style: "gitlab",
+		Info: Info{
+			RepositoryURL: "https://original-gitserver.com/owner/repo",
+		},
+	})
+
+	assert.Nil(err)
+	assert.Equal(
+		&chglog.GitLabProcessor{
+			Host: "https://original-gitserver.com",
+		},
+		processor,
+	)
+}
+
+func TestProcessorFactoryForBitbucket(t *testing.T) {
+	assert := assert.New(t)
+	factory := NewProcessorFactory()
+
+	// bitbucket.org
+	processor, err := factory.Create(&Config{
+		Info: Info{
+			RepositoryURL: "https://bitbucket.org/owner/repo",
+		},
+	})
+
+	assert.Nil(err)
+	assert.Equal(
+		&chglog.BitbucketProcessor{
+			Host: "https://bitbucket.org",
+		},
+		processor,
+	)
+
+	// self-hosted
+	processor, err = factory.Create(&Config{
+		Style: "bitbucket",
+		Info: Info{
+			RepositoryURL: "https://original-gitserver.com/owner/repo",
+		},
+	})
+
+	assert.Nil(err)
+	assert.Equal(
+		&chglog.BitbucketProcessor{
+			Host: "https://original-gitserver.com",
+		},
+		processor,
+	)
+}

cmd/git-chglog/questioner.go

@@ -6,8 +6,8 @@ import (
 	"path/filepath"
 	"strings"
 
-	gitcmd "github.com/tsuyoshiwada/go-gitcmd"
-	survey "gopkg.in/AlecAivazis/survey.v1"
+	"github.com/AlecAivazis/survey/v2"
+	"github.com/tsuyoshiwada/go-gitcmd"
 )
 
 // Answer ...
@@ -52,11 +52,12 @@ func (q *questionerImpl) Ask() (*Answer, error) {
 	t := q.fs.Exists(tpl)
 	msg := ""
 
-	if c && t {
+	switch {
+	case c && t:
 		msg = fmt.Sprintf("\"%s\" and \"%s\" already exists. Do you want to overwrite?", config, tpl)
-	} else if c {
+	case c:
 		msg = fmt.Sprintf("\"%s\" already exists. Do you want to overwrite?", config)
-	} else if t {
+	case t:
 		msg = fmt.Sprintf("\"%s\" already exists. Do you want to overwrite?", tpl)
 	}
 
@@ -77,7 +78,18 @@ func (q *questionerImpl) Ask() (*Answer, error) {
 
 func (q *questionerImpl) ask() (*Answer, error) {
 	ans := &Answer{}
-	fmts := q.getFormats()
+	fmts := q.getPreviewableList(formats)
+	tpls := q.getPreviewableList(templates)
+
+	var previewableTransform = func(ans interface{}) (newAns interface{}) {
+		if s, ok := ans.(survey.OptionAnswer); ok {
+			newAns = survey.OptionAnswer{
+				Value: q.parsePreviewableList(s.Value),
+				Index: s.Index,
+			}
+		}
+		return
+	}
 
 	questions := []*survey.Question{
 		{
@@ -102,20 +114,16 @@ func (q *questionerImpl) ask() (*Answer, error) {
 				Options: fmts,
 				Default: fmts[0],
 			},
-			Transform: func(ans interface{}) (newAns interface{}) {
-				if s, ok := ans.(string); ok {
-					newAns = q.parseFormat(s)
-				}
-				return
-			},
+			Transform: previewableTransform,
 		},
 		{
 			Name: "template",
 			Prompt: &survey.Select{
 				Message: "What is your favorite template style?",
-				Options: templates,
-				Default: templates[0],
+				Options: tpls,
+				Default: tpls[0],
 			},
+			Transform: previewableTransform,
 		},
 		{
 			Name: "include_merges",
@@ -148,29 +156,29 @@ func (q *questionerImpl) ask() (*Answer, error) {
 	return ans, nil
 }
 
-func (*questionerImpl) getFormats() []string {
-	arr := make([]string, len(formats))
+func (*questionerImpl) getPreviewableList(list []Previewable) []string {
+	arr := make([]string, len(list))
 	max := 0
 
-	for _, f := range formats {
-		l := len(f.Display)
+	for _, p := range list {
+		l := len(p.Display())
 		if max < l {
 			max = l
 		}
 	}
 
-	for i, f := range formats {
+	for i, p := range list {
 		arr[i] = fmt.Sprintf(
 			"%s -- %s",
-			f.Display+strings.Repeat(" ", max-len(f.Display)),
-			f.Preview,
+			p.Display()+strings.Repeat(" ", max-len(p.Display())),
+			p.Preview(),
 		)
 	}
 
 	return arr
 }
 
-func (*questionerImpl) parseFormat(input string) string {
+func (*questionerImpl) parsePreviewableList(input string) string {
 	return strings.TrimSpace(strings.Split(input, "--")[0])
 }
 

cmd/git-chglog/template_builder.go

@@ -1,143 +1,20 @@
 package main
 
-import "fmt"
+const templateTagNameAnchor = "<a name=\"{{ .Tag.Name }}\"></a>\n"
 
 // TemplateBuilder ...
 type TemplateBuilder interface {
 	Builder
 }
 
-type templateBuilderImpl struct{}
+// TemplateBuilderFactory ...
+type TemplateBuilderFactory = func(string) TemplateBuilder
 
-// NewTemplateBuilder ...
-func NewTemplateBuilder() TemplateBuilder {
-	return &templateBuilderImpl{}
-}
-
-// Build ...
-func (t *templateBuilderImpl) Build(ans *Answer) (string, error) {
-	// versions
-	tpl := "{{range .Versions}}\n"
-
-	// version header
-	tpl += t.versionHeader(ans.Style, ans.Template)
-
-	// commits
-	tpl += t.commits(ans.Template, ans.CommitMessageFormat)
-
-	// revert
-	if ans.IncludeReverts {
-		tpl += t.reverts()
-	}
-
-	// merges
-	if ans.IncludeMerges {
-		tpl += t.merges(ans.Style)
-	}
-
-	// notes
-	tpl += t.notes()
-
-	// versions end
-	tpl += "\n{{end}}"
-
-	return tpl, nil
-}
-
-func (*templateBuilderImpl) versionHeader(style, template string) string {
-	var (
-		tpl     string
-		tagName string
-		date    = "{{datetime \"2006-01-02\" .Tag.Date}}"
-	)
-
-	// parts
-	switch style {
-	case styleGitHub:
-		tpl = "<a name=\"{{.Tag.Name}}\"></a>\n"
-		tagName = "{{if .Tag.Previous}}[{{.Tag.Name}}]({{$.Info.RepositoryURL}}/compare/{{.Tag.Previous.Name}}...{{.Tag.Name}}){{else}}{{.Tag.Name}}{{end}}"
-	default:
-		tagName = "{{.Tag.Name}}"
-	}
-
-	// format
+func templateBuilderFactory(template string) TemplateBuilder {
 	switch template {
-	case tplStandard:
-		tpl = fmt.Sprintf("%s## %s (%s)\n",
-			tpl,
-			tagName,
-			date,
-		)
-	case tplCool:
-		tpl = fmt.Sprintf("%s## %s\n\n> %s\n",
-			tpl,
-			tagName,
-			date,
-		)
-	}
-
-	return tpl
-}
-
-func (*templateBuilderImpl) commits(template, format string) string {
-	var (
-		header string
-		body   string
-	)
-
-	switch format {
-	case fmtSubject.Display:
-		body = `{{range .Commits}}
-* {{.Header}}{{end}}
-`
-
+	case tplKeepAChangelog.display:
+		return NewKACTemplateBuilder()
 	default:
-		if format == fmtTypeScopeSubject.Display {
-			header = "{{if ne .Scope \"\"}}**{{.Scope}}:** {{end}}{{.Subject}}"
-		} else {
-			header = "{{.Subject}}"
-		}
-
-		body = fmt.Sprintf(`### {{.Title}}
-{{range .Commits}}
-* %s{{end}}
-`, header)
+		return NewCustomTemplateBuilder()
 	}
-
-	return fmt.Sprintf(`{{range .CommitGroups}}
-%s{{end}}`, body)
-}
-
-func (*templateBuilderImpl) reverts() string {
-	return `{{if .RevertCommits}}
-### Reverts
-{{range .RevertCommits}}
-* {{.Revert.Header}}{{end}}
-{{end}}`
-}
-
-func (t *templateBuilderImpl) merges(style string) string {
-	var title string
-
-	switch style {
-	case styleGitHub:
-		title = "Pull Requests"
-	default:
-		title = "Merges"
-	}
-
-	return fmt.Sprintf(`{{if .MergeCommits}}
-### %s
-{{range .MergeCommits}}
-* {{.Header}}{{end}}
-{{end}}`, title)
-}
-
-func (*templateBuilderImpl) notes() string {
-	return `{{range .NoteGroups}}
-### {{.Title}}
-{{range .Notes}}
-{{.Body}}
-{{end}}
-{{end}}`
 }

cmd/git-chglog/template_builder_test.go

@@ -1,253 +0,0 @@
-package main
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestTemplateBuilderDefault(t *testing.T) {
-	assert := assert.New(t)
-	builder := NewTemplateBuilder()
-
-	out, err := builder.Build(&Answer{
-		Style:               styleGitHub,
-		CommitMessageFormat: fmtTypeScopeSubject.Display,
-		Template:            tplStandard,
-		IncludeMerges:       true,
-		IncludeReverts:      true,
-	})
-
-	assert.Nil(err)
-	assert.Equal(`{{range .Versions}}
-<a name="{{.Tag.Name}}"></a>
-## {{if .Tag.Previous}}[{{.Tag.Name}}]({{$.Info.RepositoryURL}}/compare/{{.Tag.Previous.Name}}...{{.Tag.Name}}){{else}}{{.Tag.Name}}{{end}} ({{datetime "2006-01-02" .Tag.Date}})
-{{range .CommitGroups}}
-### {{.Title}}
-{{range .Commits}}
-* {{if ne .Scope ""}}**{{.Scope}}:** {{end}}{{.Subject}}{{end}}
-{{end}}{{if .RevertCommits}}
-### Reverts
-{{range .RevertCommits}}
-* {{.Revert.Header}}{{end}}
-{{end}}{{if .MergeCommits}}
-### Pull Requests
-{{range .MergeCommits}}
-* {{.Header}}{{end}}
-{{end}}{{range .NoteGroups}}
-### {{.Title}}
-{{range .Notes}}
-{{.Body}}
-{{end}}
-{{end}}
-{{end}}`, out)
-}
-
-func TestTemplateBuilderNone(t *testing.T) {
-	assert := assert.New(t)
-	builder := NewTemplateBuilder()
-
-	out, err := builder.Build(&Answer{
-		Style:               styleNone,
-		CommitMessageFormat: fmtTypeScopeSubject.Display,
-		Template:            tplStandard,
-		IncludeMerges:       true,
-		IncludeReverts:      true,
-	})
-
-	assert.Nil(err)
-	assert.Equal(`{{range .Versions}}
-## {{.Tag.Name}} ({{datetime "2006-01-02" .Tag.Date}})
-{{range .CommitGroups}}
-### {{.Title}}
-{{range .Commits}}
-* {{if ne .Scope ""}}**{{.Scope}}:** {{end}}{{.Subject}}{{end}}
-{{end}}{{if .RevertCommits}}
-### Reverts
-{{range .RevertCommits}}
-* {{.Revert.Header}}{{end}}
-{{end}}{{if .MergeCommits}}
-### Merges
-{{range .MergeCommits}}
-* {{.Header}}{{end}}
-{{end}}{{range .NoteGroups}}
-### {{.Title}}
-{{range .Notes}}
-{{.Body}}
-{{end}}
-{{end}}
-{{end}}`, out)
-}
-
-func TestTemplateBuilderCool(t *testing.T) {
-	assert := assert.New(t)
-	builder := NewTemplateBuilder()
-
-	out, err := builder.Build(&Answer{
-		Style:               styleNone,
-		CommitMessageFormat: fmtTypeScopeSubject.Display,
-		Template:            tplCool,
-		IncludeMerges:       true,
-		IncludeReverts:      true,
-	})
-
-	assert.Nil(err)
-	assert.Equal(`{{range .Versions}}
-## {{.Tag.Name}}
-
-> {{datetime "2006-01-02" .Tag.Date}}
-{{range .CommitGroups}}
-### {{.Title}}
-{{range .Commits}}
-* {{if ne .Scope ""}}**{{.Scope}}:** {{end}}{{.Subject}}{{end}}
-{{end}}{{if .RevertCommits}}
-### Reverts
-{{range .RevertCommits}}
-* {{.Revert.Header}}{{end}}
-{{end}}{{if .MergeCommits}}
-### Merges
-{{range .MergeCommits}}
-* {{.Header}}{{end}}
-{{end}}{{range .NoteGroups}}
-### {{.Title}}
-{{range .Notes}}
-{{.Body}}
-{{end}}
-{{end}}
-{{end}}`, out)
-}
-
-func TestTemplateBuilderSubjectOnly(t *testing.T) {
-	assert := assert.New(t)
-	builder := NewTemplateBuilder()
-
-	out, err := builder.Build(&Answer{
-		Style:               styleNone,
-		CommitMessageFormat: fmtSubject.Display,
-		Template:            tplStandard,
-		IncludeMerges:       true,
-		IncludeReverts:      true,
-	})
-
-	assert.Nil(err)
-	assert.Equal(`{{range .Versions}}
-## {{.Tag.Name}} ({{datetime "2006-01-02" .Tag.Date}})
-{{range .CommitGroups}}
-{{range .Commits}}
-* {{.Header}}{{end}}
-{{end}}{{if .RevertCommits}}
-### Reverts
-{{range .RevertCommits}}
-* {{.Revert.Header}}{{end}}
-{{end}}{{if .MergeCommits}}
-### Merges
-{{range .MergeCommits}}
-* {{.Header}}{{end}}
-{{end}}{{range .NoteGroups}}
-### {{.Title}}
-{{range .Notes}}
-{{.Body}}
-{{end}}
-{{end}}
-{{end}}`, out)
-}
-
-func TestTemplateBuilderSubject(t *testing.T) {
-	assert := assert.New(t)
-	builder := NewTemplateBuilder()
-
-	out, err := builder.Build(&Answer{
-		Style:               styleNone,
-		CommitMessageFormat: fmtTypeSubject.Display,
-		Template:            tplStandard,
-		IncludeMerges:       true,
-		IncludeReverts:      true,
-	})
-
-	assert.Nil(err)
-	assert.Equal(`{{range .Versions}}
-## {{.Tag.Name}} ({{datetime "2006-01-02" .Tag.Date}})
-{{range .CommitGroups}}
-### {{.Title}}
-{{range .Commits}}
-* {{.Subject}}{{end}}
-{{end}}{{if .RevertCommits}}
-### Reverts
-{{range .RevertCommits}}
-* {{.Revert.Header}}{{end}}
-{{end}}{{if .MergeCommits}}
-### Merges
-{{range .MergeCommits}}
-* {{.Header}}{{end}}
-{{end}}{{range .NoteGroups}}
-### {{.Title}}
-{{range .Notes}}
-{{.Body}}
-{{end}}
-{{end}}
-{{end}}`, out)
-}
-
-func TestTemplateBuilderIgnoreReverts(t *testing.T) {
-	assert := assert.New(t)
-	builder := NewTemplateBuilder()
-
-	out, err := builder.Build(&Answer{
-		Style:               styleNone,
-		CommitMessageFormat: fmtTypeSubject.Display,
-		Template:            tplStandard,
-		IncludeMerges:       true,
-		IncludeReverts:      false,
-	})
-
-	assert.Nil(err)
-	assert.Equal(`{{range .Versions}}
-## {{.Tag.Name}} ({{datetime "2006-01-02" .Tag.Date}})
-{{range .CommitGroups}}
-### {{.Title}}
-{{range .Commits}}
-* {{.Subject}}{{end}}
-{{end}}{{if .MergeCommits}}
-### Merges
-{{range .MergeCommits}}
-* {{.Header}}{{end}}
-{{end}}{{range .NoteGroups}}
-### {{.Title}}
-{{range .Notes}}
-{{.Body}}
-{{end}}
-{{end}}
-{{end}}`, out)
-}
-
-func TestTemplateBuilderIgnoreMerges(t *testing.T) {
-	assert := assert.New(t)
-	builder := NewTemplateBuilder()
-
-	out, err := builder.Build(&Answer{
-		Style:               styleNone,
-		CommitMessageFormat: fmtTypeSubject.Display,
-		Template:            tplStandard,
-		IncludeMerges:       false,
-		IncludeReverts:      true,
-	})
-
-	assert.Nil(err)
-	assert.Equal(`{{range .Versions}}
-## {{.Tag.Name}} ({{datetime "2006-01-02" .Tag.Date}})
-{{range .CommitGroups}}
-### {{.Title}}
-{{range .Commits}}
-* {{.Subject}}{{end}}
-{{end}}{{if .RevertCommits}}
-### Reverts
-{{range .RevertCommits}}
-* {{.Revert.Header}}{{end}}
-{{end}}{{range .NoteGroups}}
-### {{.Title}}
-{{range .Notes}}
-{{.Body}}
-{{end}}
-{{end}}
-{{end}}`, out)
-}

cmd/git-chglog/utils.go

@@ -7,7 +7,7 @@ import (
 	"strings"
 )
 
-var reSSH = regexp.MustCompile("^\\w+@([\\w\\.\\-]+):([\\w\\.\\-]+)\\/([\\w\\.\\-]+)$")
+var reSSH = regexp.MustCompile(`^\w+@([\w\.\-]+):([\w\.\-]+)\/([\w\.\-]+)$`)
 
 func remoteOriginURLToHTTP(rawurl string) string {
 	if rawurl == "" {

cmd/git-chglog/variables.go

@@ -5,6 +5,12 @@ import (
 	"strings"
 )
 
+// Previewable ...
+type Previewable interface {
+	Display() string
+	Preview() string
+}
+
 // Defaults
 var (
 	defaultConfigDir        = ".chglog"
@@ -14,32 +20,50 @@ var (
 
 // Styles
 var (
-	styleGitHub = "github"
-	styleNone   = "none"
-	styles      = []string{
+	styleGitHub    = "github"
+	styleGitLab    = "gitlab"
+	styleBitbucket = "bitbucket"
+	styleNone      = "none"
+	styles         = []string{
 		styleGitHub,
+		styleGitLab,
+		styleBitbucket,
 		styleNone,
 	}
 )
 
+type typeSample struct {
+	typeName string
+	title    string
+}
+
 // CommitMessageFormat ...
 type CommitMessageFormat struct {
-	Preview     string
-	Display     string
-	Pattern     string
-	PatternMaps []string
+	display     string
+	preview     string
+	pattern     string
+	patternMaps []string
+	typeSamples []typeSample
+}
+
+// Display ...
+func (f *CommitMessageFormat) Display() string {
+	return f.display
+}
+
+// Preview ...
+func (f *CommitMessageFormat) Preview() string {
+	return f.preview
 }
 
 // PatternMapString ...
 func (f *CommitMessageFormat) PatternMapString() string {
-	s := " []"
-	l := len(f.PatternMaps)
-	if l == 0 {
-		return s
+	if len(f.patternMaps) == 0 {
+		return " []"
 	}
 
-	arr := make([]string, l)
-	for i, p := range f.PatternMaps {
+	arr := make([]string, len(f.patternMaps))
+	for i, p := range f.patternMaps {
 		arr[i] = fmt.Sprintf(
 			"%s- %s",
 			strings.Repeat(" ", 6),
@@ -50,45 +74,124 @@ func (f *CommitMessageFormat) PatternMapString() string {
 	return fmt.Sprintf("\n%s", strings.Join(arr, "\n"))
 }
 
+// FilterTypesString ...
+func (f *CommitMessageFormat) FilterTypesString() string {
+	if len(f.typeSamples) == 0 {
+		return " []"
+	}
+
+	arr := make([]string, len(f.typeSamples))
+	for i, t := range f.typeSamples {
+		arr[i] = fmt.Sprintf(
+			"%s#%s- %s",
+			strings.Repeat(" ", 4), strings.Repeat(" ", 5),
+			t.typeName)
+	}
+	return fmt.Sprintf("\n%s", strings.Join(arr, "\n"))
+}
+
+// TitleMapsString ...
+func (f *CommitMessageFormat) TitleMapsString() string {
+	if len(f.typeSamples) == 0 {
+		return " []"
+	}
+
+	arr := make([]string, len(f.typeSamples))
+	for i, t := range f.typeSamples {
+		arr[i] = fmt.Sprintf(
+			"%s#%s%s: %s",
+			strings.Repeat(" ", 4), strings.Repeat(" ", 3),
+			t.typeName, t.title)
+	}
+	return fmt.Sprintf("\n%s", strings.Join(arr, "\n"))
+}
+
 // Formats
 var (
 	fmtTypeScopeSubject = &CommitMessageFormat{
-		Preview:     "feat(core) Add new feature",
-		Display:     "<type>(<scope>): <subject>",
-		Pattern:     `^(\\w*)(?:\\(([\\w\\$\\.\\-\\*\\s]*)\\))?\\:\\s(.*)$`,
-		PatternMaps: []string{"Type", "Scope", "Subject"},
+		display:     "<type>(<scope>): <subject>",
+		preview:     "feat(core): Add new feature",
+		pattern:     `^(\\w*)(?:\\(([\\w\\$\\.\\-\\*\\s]*)\\))?\\:\\s(.*)$`,
+		patternMaps: []string{"Type", "Scope", "Subject"},
+		typeSamples: []typeSample{
+			{"feat", "Features"}, {"fix", "Bug Fixes"},
+			{"perf", "Performance Improvements"}, {"refactor", "Code Refactoring"}},
 	}
 	fmtTypeSubject = &CommitMessageFormat{
-		Preview:     "feat: Add new feature",
-		Display:     "<type>: <subject>",
-		Pattern:     `^(\\w*)\\:\\s(.*)$`,
-		PatternMaps: []string{"Type", "Subject"},
+		display:     "<type>: <subject>",
+		preview:     "feat: Add new feature",
+		pattern:     `^(\\w*)\\:\\s(.*)$`,
+		patternMaps: []string{"Type", "Subject"},
+		typeSamples: []typeSample{
+			{"feat", "Features"}, {"fix", "Bug Fixes"},
+			{"perf", "Performance Improvements"}, {"refactor", "Code Refactoring"}},
 	}
 	fmtGitBasic = &CommitMessageFormat{
-		Preview:     "Add new feature",
-		Display:     "<<type> subject>",
-		Pattern:     `^((\\w+)\\s.*)$`,
-		PatternMaps: []string{"Subject", "Type"},
+		display:     "<<type> subject>",
+		preview:     "Add new feature",
+		pattern:     `^((\\w+)\\s.*)$`,
+		patternMaps: []string{"Subject", "Type"},
+		typeSamples: []typeSample{
+			{"feat", "Features"}, {"fix", "Bug Fixes"},
+			{"perf", "Performance Improvements"}, {"refactor", "Code Refactoring"}},
 	}
 	fmtSubject = &CommitMessageFormat{
-		Preview:     "Add new feature (Not detect `type` field)",
-		Display:     "<subject>",
-		Pattern:     `^(.*)$`,
-		PatternMaps: []string{"Subject"},
+		display:     "<subject>",
+		preview:     "Add new feature (Not detect `type` field)",
+		pattern:     `^(.*)$`,
+		patternMaps: []string{"Subject"},
+		typeSamples: []typeSample{},
 	}
-	formats = []*CommitMessageFormat{
+	fmtCommitEmoji = &CommitMessageFormat{
+		display:     ":<type>: <subject>",
+		preview:     ":sparkles: Add new feature (Commit message with emoji format)",
+		pattern:     `^:(\\w*)\\:\\s(.*)$`,
+		patternMaps: []string{"Type", "Subject"},
+		typeSamples: []typeSample{
+			{"sparkles", "Features"}, {"bug", "Bug Fixes"},
+			{"zap", "Performance Improvements"}, {"recycle", "Code Refactoring"}},
+	}
+	formats = []Previewable{
 		fmtTypeScopeSubject,
 		fmtTypeSubject,
 		fmtGitBasic,
 		fmtSubject,
+		fmtCommitEmoji,
 	}
 )
 
+// TemplateStyleFormat ...
+type TemplateStyleFormat struct {
+	preview string
+	display string
+}
+
+// Display ...
+func (t *TemplateStyleFormat) Display() string {
+	return t.display
+}
+
+// Preview ...
+func (t *TemplateStyleFormat) Preview() string {
+	return t.preview
+}
+
 // Templates
 var (
-	tplStandard = "standard"
-	tplCool     = "cool"
-	templates   = []string{
+	tplKeepAChangelog = &TemplateStyleFormat{
+		display: "keep-a-changelog",
+		preview: "https://github.com/git-chglog/example-type-scope-subject/blob/master/CHANGELOG.kac.md",
+	}
+	tplStandard = &TemplateStyleFormat{
+		display: "standard",
+		preview: "https://github.com/git-chglog/example-type-scope-subject/blob/master/CHANGELOG.standard.md",
+	}
+	tplCool = &TemplateStyleFormat{
+		display: "cool",
+		preview: "https://github.com/git-chglog/example-type-scope-subject/blob/master/CHANGELOG.cool.md",
+	}
+	templates = []Previewable{
+		tplKeepAChangelog,
 		tplStandard,
 		tplCool,
 	}

cmd/git-chglog/variables_test.go

@@ -10,7 +10,7 @@ func TestCommitMessageFormatPatternMaps(t *testing.T) {
 	assert := assert.New(t)
 
 	f := &CommitMessageFormat{
-		PatternMaps: []string{
+		patternMaps: []string{
 			"Type",
 			"Scope",
 			"Subject",
@@ -23,8 +23,54 @@ func TestCommitMessageFormatPatternMaps(t *testing.T) {
       - Subject`, f.PatternMapString())
 
 	f = &CommitMessageFormat{
-		PatternMaps: []string{},
+		patternMaps: []string{},
 	}
 
 	assert.Equal(" []", f.PatternMapString())
 }
+
+func TestCommitMessageFormatFilterTypes(t *testing.T) {
+	assert := assert.New(t)
+
+	f := &CommitMessageFormat{
+		typeSamples: []typeSample{
+			{"feat", "Features"}, {"fix", "Bug Fixes"},
+			{"perf", "Performance Improvements"}, {"refactor", "Code Refactoring"},
+		},
+	}
+
+	assert.Equal(`
+    #     - feat
+    #     - fix
+    #     - perf
+    #     - refactor`, f.FilterTypesString())
+
+	f = &CommitMessageFormat{
+		patternMaps: []string{},
+	}
+
+	assert.Equal(" []", f.FilterTypesString())
+}
+
+func TestCommitMessageFormatTitleMaps(t *testing.T) {
+	assert := assert.New(t)
+
+	f := &CommitMessageFormat{
+		typeSamples: []typeSample{
+			{"feat", "Features"}, {"fix", "Bug Fixes"},
+			{"perf", "Performance Improvements"}, {"refactor", "Code Refactoring"},
+		},
+	}
+
+	assert.Equal(`
+    #   feat: Features
+    #   fix: Bug Fixes
+    #   perf: Performance Improvements
+    #   refactor: Code Refactoring`, f.TitleMapsString())
+
+	f = &CommitMessageFormat{
+		patternMaps: []string{},
+	}
+
+	assert.Equal(" []", f.TitleMapsString())
+}

cmd/git-chglog/version.go

@@ -1,4 +0,0 @@
-package main
-
-// Version of git-chglog cli client
-const Version = "0.1.0"

commit_extractor.go

@@ -21,7 +21,7 @@ func (e *commitExtractor) Extract(commits []*Commit) ([]*CommitGroup, []*Commit,
 	mergeCommits := []*Commit{}
 	revertCommits := []*Commit{}
 
-	filteredCommits := commitFilter(commits, e.opts.CommitFilters)
+	filteredCommits := commitFilter(commits, e.opts.CommitFilters, e.opts.NoCaseSensitive)
 
 	for _, commit := range commits {
 		if commit.Merge != nil {
@@ -37,7 +37,7 @@ func (e *commitExtractor) Extract(commits []*Commit) ([]*CommitGroup, []*Commit,
 
 	for _, commit := range filteredCommits {
 		if commit.Merge == nil && commit.Revert == nil {
-			e.processCommitGroups(&commitGroups, commit)
+			e.processCommitGroups(&commitGroups, commit, e.opts.NoCaseSensitive)
 		}
 
 		e.processNoteGroups(&noteGroups, commit)
@@ -49,14 +49,23 @@ func (e *commitExtractor) Extract(commits []*Commit) ([]*CommitGroup, []*Commit,
 	return commitGroups, mergeCommits, revertCommits, noteGroups
 }
 
-func (e *commitExtractor) processCommitGroups(groups *[]*CommitGroup, commit *Commit) {
+func (e *commitExtractor) processCommitGroups(groups *[]*CommitGroup, commit *Commit, noCaseSensitive bool) {
 	var group *CommitGroup
 
 	// commit group
 	raw, ttl := e.commitGroupTitle(commit)
 
 	for _, g := range *groups {
-		if g.RawTitle == raw {
+		rawTitleTmp := g.RawTitle
+		if noCaseSensitive {
+			rawTitleTmp = strings.ToLower(g.RawTitle)
+		}
+
+		rawTmp := raw
+		if noCaseSensitive {
+			rawTmp = strings.ToLower(raw)
+		}
+		if rawTitleTmp == rawTmp {
 			group = g
 		}
 	}
@@ -110,6 +119,7 @@ func (e *commitExtractor) commitGroupTitle(commit *Commit) (string, string) {
 			if t, ok := e.opts.CommitGroupTitleMaps[v]; ok {
 				ttl = t
 			} else {
+				//nolint:staticcheck
 				ttl = strings.Title(raw)
 			}
 		}
@@ -118,9 +128,27 @@ func (e *commitExtractor) commitGroupTitle(commit *Commit) (string, string) {
 	return raw, ttl
 }
 
-func (e *commitExtractor) sortCommitGroups(groups []*CommitGroup) {
+func (e *commitExtractor) sortCommitGroups(groups []*CommitGroup) { //nolint:gocyclo
+	// NOTE(khos2ow): this function is over our cyclomatic complexity goal.
+	// Be wary when adding branches, and look for functionality that could
+	// be reasonably moved into an injected dependency.
+
+	order := make(map[string]int)
+	if e.opts.CommitGroupSortBy == "Custom" {
+		for i, t := range e.opts.CommitGroupTitleOrder {
+			order[t] = i
+		}
+	}
+
 	// groups
+	// TODO(khos2ow): move the inline sort function to
+	// conceret implementation of sort.Interface in order
+	// to reduce cyclomatic complaxity.
 	sort.Slice(groups, func(i, j int) bool {
+		if e.opts.CommitGroupSortBy == "Custom" {
+			return order[groups[i].RawTitle] < order[groups[j].RawTitle]
+		}
+
 		var (
 			a, b interface{}
 			ok   bool
@@ -145,6 +173,11 @@ func (e *commitExtractor) sortCommitGroups(groups []*CommitGroup) {
 
 	// commits
 	for _, group := range groups {
+		group := group // pin group to avoid potential bugs with passing group to lower functions
+
+		// TODO(khos2ow): move the inline sort function to
+		// conceret implementation of sort.Interface in order
+		// to reduce cyclomatic complaxity.
 		sort.Slice(group.Commits, func(i, j int) bool {
 			var (
 				a, b interface{}
@@ -178,6 +211,7 @@ func (e *commitExtractor) sortNoteGroups(groups []*NoteGroup) {
 
 	// notes
 	for _, group := range groups {
+		group := group // pin group to avoid potential bugs with passing group to lower functions
 		sort.Slice(group.Notes, func(i, j int) bool {
 			return strings.ToLower(group.Notes[i].Title) < strings.ToLower(group.Notes[j].Title)
 		})

commit_extractor_test.go

@@ -20,14 +20,14 @@ func TestCommitExtractor(t *testing.T) {
 
 	fixtures := []*Commit{
 		// [0]
-		&Commit{
+		{
 			Type:   "foo",
 			Scope:  "c",
 			Header: "1",
 			Notes:  []*Note{},
 		},
 		// [1]
-		&Commit{
+		{
 			Type:   "foo",
 			Scope:  "b",
 			Header: "2",
@@ -37,7 +37,7 @@ func TestCommitExtractor(t *testing.T) {
 			},
 		},
 		// [2]
-		&Commit{
+		{
 			Type:   "bar",
 			Scope:  "d",
 			Header: "3",
@@ -47,7 +47,7 @@ func TestCommitExtractor(t *testing.T) {
 			},
 		},
 		// [3]
-		&Commit{
+		{
 			Type:   "foo",
 			Scope:  "a",
 			Header: "4",
@@ -56,7 +56,7 @@ func TestCommitExtractor(t *testing.T) {
 			},
 		},
 		// [4]
-		&Commit{
+		{
 			Type:   "",
 			Scope:  "",
 			Header: "Merge1",
@@ -67,7 +67,7 @@ func TestCommitExtractor(t *testing.T) {
 			},
 		},
 		// [5]
-		&Commit{
+		{
 			Type:   "",
 			Scope:  "",
 			Header: "Revert1",
@@ -81,14 +81,14 @@ func TestCommitExtractor(t *testing.T) {
 	commitGroups, mergeCommits, revertCommits, noteGroups := extractor.Extract(fixtures)
 
 	assert.Equal([]*CommitGroup{
-		&CommitGroup{
+		{
 			RawTitle: "bar",
 			Title:    "BAR",
 			Commits: []*Commit{
 				fixtures[2],
 			},
 		},
-		&CommitGroup{
+		{
 			RawTitle: "foo",
 			Title:    "Foo",
 			Commits: []*Commit{
@@ -108,26 +108,157 @@ func TestCommitExtractor(t *testing.T) {
 	}, revertCommits)
 
 	assert.Equal([]*NoteGroup{
-		&NoteGroup{
+		{
 			Title: "note1-title",
 			Notes: []*Note{
 				fixtures[1].Notes[0],
 				fixtures[2].Notes[0],
 			},
 		},
-		&NoteGroup{
+		{
 			Title: "note2-title",
 			Notes: []*Note{
 				fixtures[1].Notes[1],
 			},
 		},
-		&NoteGroup{
+		{
 			Title: "note3-title",
 			Notes: []*Note{
 				fixtures[2].Notes[1],
 			},
 		},
-		&NoteGroup{
+		{
+			Title: "note4-title",
+			Notes: []*Note{
+				fixtures[3].Notes[0],
+			},
+		},
+	}, noteGroups)
+}
+
+func TestCommitOrderExtractor(t *testing.T) {
+	assert := assert.New(t)
+
+	extractor := newCommitExtractor(&Options{
+		CommitSortBy:          "Scope",
+		CommitGroupBy:         "Type",
+		CommitGroupSortBy:     "Custom",
+		CommitGroupTitleOrder: []string{"foo", "bar"},
+		CommitGroupTitleMaps: map[string]string{
+			"bar": "BAR",
+		},
+	})
+
+	fixtures := []*Commit{
+		// [0]
+		{
+			Type:   "foo",
+			Scope:  "c",
+			Header: "1",
+			Notes:  []*Note{},
+		},
+		// [1]
+		{
+			Type:   "foo",
+			Scope:  "b",
+			Header: "2",
+			Notes: []*Note{
+				{"note1-title", "note1-body"},
+				{"note2-title", "note2-body"},
+			},
+		},
+		// [2]
+		{
+			Type:   "bar",
+			Scope:  "d",
+			Header: "3",
+			Notes: []*Note{
+				{"note1-title", "note1-body"},
+				{"note3-title", "note3-body"},
+			},
+		},
+		// [3]
+		{
+			Type:   "foo",
+			Scope:  "a",
+			Header: "4",
+			Notes: []*Note{
+				{"note4-title", "note4-body"},
+			},
+		},
+		// [4]
+		{
+			Type:   "",
+			Scope:  "",
+			Header: "Merge1",
+			Notes:  []*Note{},
+			Merge: &Merge{
+				Ref:    "123",
+				Source: "merges/merge1",
+			},
+		},
+		// [5]
+		{
+			Type:   "",
+			Scope:  "",
+			Header: "Revert1",
+			Notes:  []*Note{},
+			Revert: &Revert{
+				Header: "REVERT1",
+			},
+		},
+	}
+
+	commitGroups, mergeCommits, revertCommits, noteGroups := extractor.Extract(fixtures)
+
+	assert.Equal([]*CommitGroup{
+		{
+			RawTitle: "foo",
+			Title:    "Foo",
+			Commits: []*Commit{
+				fixtures[3],
+				fixtures[1],
+				fixtures[0],
+			},
+		},
+		{
+			RawTitle: "bar",
+			Title:    "BAR",
+			Commits: []*Commit{
+				fixtures[2],
+			},
+		},
+	}, commitGroups)
+
+	assert.Equal([]*Commit{
+		fixtures[4],
+	}, mergeCommits)
+
+	assert.Equal([]*Commit{
+		fixtures[5],
+	}, revertCommits)
+
+	assert.Equal([]*NoteGroup{
+		{
+			Title: "note1-title",
+			Notes: []*Note{
+				fixtures[1].Notes[0],
+				fixtures[2].Notes[0],
+			},
+		},
+		{
+			Title: "note2-title",
+			Notes: []*Note{
+				fixtures[1].Notes[1],
+			},
+		},
+		{
+			Title: "note3-title",
+			Notes: []*Note{
+				fixtures[2].Notes[1],
+			},
+		},
+		{
 			Title: "note4-title",
 			Notes: []*Note{
 				fixtures[3].Notes[0],

commit_filter.go

@@ -1,6 +1,14 @@
 package chglog
 
-func commitFilter(commits []*Commit, filters map[string][]string) []*Commit {
+import (
+	"strings"
+)
+
+func commitFilter(commits []*Commit, filters map[string][]string, noCaseSensitive bool) []*Commit { //nolint:gocyclo
+	// NOTE(khos2ow): this function is over our cyclomatic complexity goal.
+	// Be wary when adding branches, and look for functionality that could
+	// be reasonably moved into an injected dependency.
+
 	res := []*Commit{}
 
 	for _, commit := range commits {
@@ -23,9 +31,17 @@ func commitFilter(commits []*Commit, filters map[string][]string) []*Commit {
 				break
 			}
 
+			if noCaseSensitive {
+				str = strings.ToLower(str)
+			}
+
 			exist := false
 
 			for _, val := range values {
+				if noCaseSensitive {
+					val = strings.ToLower(val)
+				}
+
 				if str == val {
 					exist = true
 				}

commit_filter_test.go

@@ -18,26 +18,31 @@ func TestCommitFilter(t *testing.T) {
 	}
 
 	fixtures := []*Commit{
-		&Commit{
+		{
 			Type:    "foo",
 			Scope:   "hoge",
 			Subject: "1",
 		},
-		&Commit{
+		{
 			Type:    "foo",
 			Scope:   "fuga",
 			Subject: "2",
 		},
-		&Commit{
+		{
 			Type:    "bar",
 			Scope:   "hoge",
 			Subject: "3",
 		},
-		&Commit{
+		{
 			Type:    "bar",
 			Scope:   "fuga",
 			Subject: "4",
 		},
+		{
+			Type:    "Bar",
+			Scope:   "hogera",
+			Subject: "5",
+		},
 	}
 
 	assert.Equal(
@@ -46,8 +51,9 @@ func TestCommitFilter(t *testing.T) {
 			"2",
 			"3",
 			"4",
+			"5",
 		},
-		pickCommitSubjects(commitFilter(fixtures, map[string][]string{})),
+		pickCommitSubjects(commitFilter(fixtures, map[string][]string{}, false)),
 	)
 
 	assert.Equal(
@@ -59,7 +65,20 @@ func TestCommitFilter(t *testing.T) {
 		},
 		pickCommitSubjects(commitFilter(fixtures, map[string][]string{
 			"Type": {"foo", "bar"},
-		})),
+		}, false)),
+	)
+
+	assert.Equal(
+		[]string{
+			"1",
+			"2",
+			"3",
+			"4",
+			"5",
+		},
+		pickCommitSubjects(commitFilter(fixtures, map[string][]string{
+			"Type": {"foo", "bar"},
+		}, true)),
 	)
 
 	assert.Equal(
@@ -69,7 +88,7 @@ func TestCommitFilter(t *testing.T) {
 		},
 		pickCommitSubjects(commitFilter(fixtures, map[string][]string{
 			"Type": {"foo"},
-		})),
+		}, false)),
 	)
 
 	assert.Equal(
@@ -79,7 +98,18 @@ func TestCommitFilter(t *testing.T) {
 		},
 		pickCommitSubjects(commitFilter(fixtures, map[string][]string{
 			"Type": {"bar"},
-		})),
+		}, false)),
+	)
+
+	assert.Equal(
+		[]string{
+			"3",
+			"4",
+			"5",
+		},
+		pickCommitSubjects(commitFilter(fixtures, map[string][]string{
+			"Type": {"bar"},
+		}, true)),
 	)
 
 	assert.Equal(
@@ -89,7 +119,7 @@ func TestCommitFilter(t *testing.T) {
 		},
 		pickCommitSubjects(commitFilter(fixtures, map[string][]string{
 			"Scope": {"fuga"},
-		})),
+		}, false)),
 	)
 
 	assert.Equal(
@@ -99,7 +129,7 @@ func TestCommitFilter(t *testing.T) {
 		pickCommitSubjects(commitFilter(fixtures, map[string][]string{
 			"Type":  {"bar"},
 			"Scope": {"hoge"},
-		})),
+		}, false)),
 	)
 
 	assert.Equal(
@@ -110,6 +140,6 @@ func TestCommitFilter(t *testing.T) {
 		pickCommitSubjects(commitFilter(fixtures, map[string][]string{
 			"Type":  {"foo"},
 			"Scope": {"fuga", "hoge"},
-		})),
+		}, false)),
 	)
 }

commit_parser.go

@@ -1,12 +1,13 @@
 package chglog
 
 import (
+	"fmt"
 	"regexp"
 	"strconv"
 	"strings"
 	"time"
 
-	gitcmd "github.com/tsuyoshiwada/go-gitcmd"
+	"github.com/tsuyoshiwada/go-gitcmd"
 )
 
 var (
@@ -47,18 +48,23 @@ func joinAndQuoteMeta(list []string, sep string) string {
 }
 
 type commitParser struct {
-	client    gitcmd.Client
-	config    *Config
-	reHeader  *regexp.Regexp
-	reMerge   *regexp.Regexp
-	reRevert  *regexp.Regexp
-	reRef     *regexp.Regexp
-	reIssue   *regexp.Regexp
-	reNotes   *regexp.Regexp
-	reMention *regexp.Regexp
+	logger                 *Logger
+	client                 gitcmd.Client
+	jiraClient             JiraClient
+	config                 *Config
+	reHeader               *regexp.Regexp
+	reMerge                *regexp.Regexp
+	reRevert               *regexp.Regexp
+	reRef                  *regexp.Regexp
+	reIssue                *regexp.Regexp
+	reNotes                *regexp.Regexp
+	reMention              *regexp.Regexp
+	reSignOff              *regexp.Regexp
+	reCoAuthor             *regexp.Regexp
+	reJiraIssueDescription *regexp.Regexp
 }
 
-func newCommitParser(client gitcmd.Client, config *Config) *commitParser {
+func newCommitParser(logger *Logger, client gitcmd.Client, jiraClient JiraClient, config *Config) *commitParser {
 	opts := config.Options
 
 	joinedRefActions := joinAndQuoteMeta(opts.RefActions, "|")
@@ -66,25 +72,38 @@ func newCommitParser(client gitcmd.Client, config *Config) *commitParser {
 	joinedNoteKeywords := joinAndQuoteMeta(opts.NoteKeywords, "|")
 
 	return &commitParser{
-		client:    client,
-		config:    config,
-		reHeader:  regexp.MustCompile(opts.HeaderPattern),
-		reMerge:   regexp.MustCompile(opts.MergePattern),
-		reRevert:  regexp.MustCompile(opts.RevertPattern),
-		reRef:     regexp.MustCompile("(?i)(" + joinedRefActions + ")\\s?([\\w/\\.\\-]+)?(?:" + joinedIssuePrefix + ")(\\d+)"),
-		reIssue:   regexp.MustCompile("(?:" + joinedIssuePrefix + ")(\\d+)"),
-		reNotes:   regexp.MustCompile("^(?i)\\s*(" + joinedNoteKeywords + ")[:\\s]+(.*)"),
-		reMention: regexp.MustCompile("@([\\w-]+)"),
+		logger:                 logger,
+		client:                 client,
+		jiraClient:             jiraClient,
+		config:                 config,
+		reHeader:               regexp.MustCompile(opts.HeaderPattern),
+		reMerge:                regexp.MustCompile(opts.MergePattern),
+		reRevert:               regexp.MustCompile(opts.RevertPattern),
+		reRef:                  regexp.MustCompile("(?i)(" + joinedRefActions + ")\\s?([\\w/\\.\\-]+)?(?:" + joinedIssuePrefix + ")(\\d+)"),
+		reIssue:                regexp.MustCompile("(?:" + joinedIssuePrefix + ")(\\d+)"),
+		reNotes:                regexp.MustCompile("^(?i)\\s*(" + joinedNoteKeywords + ")[:\\s]+(.*)"),
+		reMention:              regexp.MustCompile(`@([\w-]+)`),
+		reSignOff:              regexp.MustCompile(`Signed-off-by:\s+([\p{L}\s\-\[\]]+)\s+<([\w+\-\[\].@]+)>`),
+		reCoAuthor:             regexp.MustCompile(`Co-authored-by:\s+([\p{L}\s\-\[\]]+)\s+<([\w+\-\[\].@]+)>`),
+		reJiraIssueDescription: regexp.MustCompile(opts.JiraIssueDescriptionPattern),
 	}
 }
 
 func (p *commitParser) Parse(rev string) ([]*Commit, error) {
-	out, err := p.client.Exec(
-		"log",
+	paths := p.config.Options.Paths
+
+	args := []string{
 		rev,
 		"--no-decorate",
-		"--pretty="+logFormat,
-	)
+		"--pretty=" + logFormat,
+	}
+
+	if len(paths) > 0 {
+		args = append(args, "--")
+		args = append(args, paths...)
+	}
+
+	out, err := p.client.Exec("log", args...)
 
 	if err != nil {
 		return nil, err
@@ -206,6 +225,41 @@ func (p *commitParser) processHeader(commit *Commit, input string) {
 	// refs & mentions
 	commit.Refs = p.parseRefs(input)
 	commit.Mentions = p.parseMentions(input)
+
+	// Jira
+	if commit.JiraIssueID != "" {
+		p.processJiraIssue(commit, commit.JiraIssueID)
+	}
+}
+
+func (p *commitParser) extractLineMetadata(commit *Commit, line string) bool {
+	meta := false
+
+	refs := p.parseRefs(line)
+	if len(refs) > 0 {
+		meta = true
+		commit.Refs = append(commit.Refs, refs...)
+	}
+
+	mentions := p.parseMentions(line)
+	if len(mentions) > 0 {
+		meta = true
+		commit.Mentions = append(commit.Mentions, mentions...)
+	}
+
+	coAuthors := p.parseCoAuthors(line)
+	if len(coAuthors) > 0 {
+		meta = true
+		commit.CoAuthors = append(commit.CoAuthors, coAuthors...)
+	}
+
+	signers := p.parseSigners(line)
+	if len(signers) > 0 {
+		meta = true
+		commit.Signers = append(commit.Signers, signers...)
+	}
+
+	return meta
 }
 
 func (p *commitParser) processBody(commit *Commit, input string) {
@@ -217,30 +271,29 @@ func (p *commitParser) processBody(commit *Commit, input string) {
 	// notes & refs & mentions
 	commit.Notes = []*Note{}
 	inNote := false
+	trim := false
 	fenceDetector := newMdFenceDetector()
 	lines := strings.Split(input, "\n")
 
+	// body without notes & refs & mentions
+	trimmedBody := make([]string, 0, len(lines))
+
 	for _, line := range lines {
+		if !inNote {
+			trim = false
+		}
 		fenceDetector.Update(line)
 
-		if !fenceDetector.InCodeblock() {
-			refs := p.parseRefs(line)
-			if len(refs) > 0 {
-				inNote = false
-				commit.Refs = append(commit.Refs, refs...)
-			}
-
-			mentions := p.parseMentions(line)
-			if len(mentions) > 0 {
-				inNote = false
-				commit.Mentions = append(commit.Mentions, mentions...)
-			}
+		if !fenceDetector.InCodeblock() && p.extractLineMetadata(commit, line) {
+			trim = true
+			inNote = false
 		}
-
+		// Q: should this check also only be outside of code blocks?
 		res := p.reNotes.FindAllStringSubmatch(line, -1)
 
 		if len(res) > 0 {
 			inNote = true
+			trim = true
 			for _, r := range res {
 				commit.Notes = append(commit.Notes, &Note{
 					Title: r[1],
@@ -251,8 +304,13 @@ func (p *commitParser) processBody(commit *Commit, input string) {
 			last := commit.Notes[len(commit.Notes)-1]
 			last.Body = last.Body + "\n" + line
 		}
+
+		if !trim {
+			trimmedBody = append(trimmedBody, line)
+		}
 	}
 
+	commit.TrimmedBody = strings.TrimSpace(strings.Join(trimmedBody, "\n"))
 	p.trimSpaceInNotes(commit)
 }
 
@@ -297,6 +355,30 @@ func (p *commitParser) parseRefs(input string) []*Ref {
 	return refs
 }
 
+func (p *commitParser) parseSigners(input string) []Contact {
+	res := p.reSignOff.FindAllStringSubmatch(input, -1)
+	contacts := make([]Contact, len(res))
+
+	for i, r := range res {
+		contacts[i].Name = r[1]
+		contacts[i].Email = r[2]
+	}
+
+	return contacts
+}
+
+func (p *commitParser) parseCoAuthors(input string) []Contact {
+	res := p.reCoAuthor.FindAllStringSubmatch(input, -1)
+	contacts := make([]Contact, len(res))
+
+	for i, r := range res {
+		contacts[i].Name = r[1]
+		contacts[i].Email = r[2]
+	}
+
+	return contacts
+}
+
 func (p *commitParser) parseMentions(input string) []string {
 	res := p.reMention.FindAllStringSubmatch(input, -1)
 	mentions := make([]string, len(res))
@@ -344,6 +426,28 @@ func (p *commitParser) uniqMentions(mentions []string) []string {
 	return arr
 }
 
+func (p *commitParser) processJiraIssue(commit *Commit, issueID string) {
+	issue, err := p.jiraClient.GetJiraIssue(commit.JiraIssueID)
+	if err != nil {
+		p.logger.Error(fmt.Sprintf("Failed to parse Jira story %s: %s\n", issueID, err))
+		return
+	}
+	commit.Type = p.config.Options.JiraTypeMaps[issue.Fields.Type.Name]
+	commit.JiraIssue = &JiraIssue{
+		Type:        issue.Fields.Type.Name,
+		Summary:     issue.Fields.Summary,
+		Description: issue.Fields.Description,
+		Labels:      issue.Fields.Labels,
+	}
+
+	if p.config.Options.JiraIssueDescriptionPattern != "" {
+		res := p.reJiraIssueDescription.FindStringSubmatch(commit.JiraIssue.Description)
+		if len(res) > 1 {
+			commit.JiraIssue.Description = res[1]
+		}
+	}
+}
+
 var (
 	fenceTypes = []string{
 		"```",

commit_parser_test.go

@@ -3,11 +3,12 @@ package chglog
 import (
 	"errors"
 	"fmt"
-	"io/ioutil"
+	"os"
 	"path/filepath"
 	"testing"
 	"time"
 
+	agjira "github.com/andygrunwald/go-jira"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -21,62 +22,63 @@ func TestCommitParserParse(t *testing.T) {
 				return "", errors.New("")
 			}
 
-			bytes, _ := ioutil.ReadFile(filepath.Join("testdata", "gitlog.txt"))
+			bytes, _ := os.ReadFile(filepath.Join("testdata", "gitlog.txt"))
 
 			return string(bytes), nil
 		},
 	}
 
-	parser := newCommitParser(mock, &Config{
-		Options: &Options{
-			CommitFilters: map[string][]string{
-				"Type": []string{
-					"feat",
+	parser := newCommitParser(NewLogger(os.Stdout, os.Stderr, false, true),
+		mock, nil, &Config{
+			Options: &Options{
+				CommitFilters: map[string][]string{
+					"Type": {
+						"feat",
+						"fix",
+						"perf",
+						"refactor",
+					},
+				},
+				HeaderPattern: "^(\\w*)(?:\\(([\\w\\$\\.\\-\\*\\s]*)\\))?\\:\\s(.*)$",
+				HeaderPatternMaps: []string{
+					"Type",
+					"Scope",
+					"Subject",
+				},
+				IssuePrefix: []string{
+					"#",
+					"gh-",
+				},
+				RefActions: []string{
+					"close",
+					"closes",
+					"closed",
 					"fix",
-					"perf",
-					"refactor",
+					"fixes",
+					"fixed",
+					"resolve",
+					"resolves",
+					"resolved",
+				},
+				MergePattern: "^Merge pull request #(\\d+) from (.*)$",
+				MergePatternMaps: []string{
+					"Ref",
+					"Source",
+				},
+				RevertPattern: "^Revert \"([\\s\\S]*)\"$",
+				RevertPatternMaps: []string{
+					"Header",
+				},
+				NoteKeywords: []string{
+					"BREAKING CHANGE",
 				},
 			},
-			HeaderPattern: "^(\\w*)(?:\\(([\\w\\$\\.\\-\\*\\s]*)\\))?\\:\\s(.*)$",
-			HeaderPatternMaps: []string{
-				"Type",
-				"Scope",
-				"Subject",
-			},
-			IssuePrefix: []string{
-				"#",
-				"gh-",
-			},
-			RefActions: []string{
-				"close",
-				"closes",
-				"closed",
-				"fix",
-				"fixes",
-				"fixed",
-				"resolve",
-				"resolves",
-				"resolved",
-			},
-			MergePattern: "^Merge pull request #(\\d+) from (.*)$",
-			MergePatternMaps: []string{
-				"Ref",
-				"Source",
-			},
-			RevertPattern: "^Revert \"([\\s\\S]*)\"$",
-			RevertPatternMaps: []string{
-				"Header",
-			},
-			NoteKeywords: []string{
-				"BREAKING CHANGE",
-			},
-		},
-	})
+		})
 
 	commits, err := parser.Parse("HEAD")
 	assert.Nil(err)
 	assert.Equal([]*Commit{
-		&Commit{
+		{
 			Hash: &Hash{
 				Long:  "65cf1add9735dcc4810dda3312b0792236c97c4e",
 				Short: "65cf1add",
@@ -94,21 +96,22 @@ func TestCommitParserParse(t *testing.T) {
 			Merge:  nil,
 			Revert: nil,
 			Refs: []*Ref{
-				&Ref{
+				{
 					Action: "",
 					Ref:    "123",
 					Source: "",
 				},
 			},
-			Notes:    []*Note{},
-			Mentions: []string{},
-			Header:   "feat(*): Add new feature #123",
-			Type:     "feat",
-			Scope:    "*",
-			Subject:  "Add new feature #123",
-			Body:     "",
+			Notes:       []*Note{},
+			Mentions:    []string{},
+			Header:      "feat(*): Add new feature #123",
+			Type:        "feat",
+			Scope:       "*",
+			Subject:     "Add new feature #123",
+			Body:        "",
+			TrimmedBody: "",
 		},
-		&Commit{
+		{
 			Hash: &Hash{
 				Long:  "14ef0b6d386c5432af9292eab3c8314fa3001bc7",
 				Short: "14ef0b6d",
@@ -129,24 +132,24 @@ func TestCommitParserParse(t *testing.T) {
 			},
 			Revert: nil,
 			Refs: []*Ref{
-				&Ref{
+				{
 					Action: "",
 					Ref:    "3",
 					Source: "",
 				},
-				&Ref{
+				{
 					Action: "Fixes",
 					Ref:    "3",
 					Source: "",
 				},
-				&Ref{
+				{
 					Action: "Closes",
 					Ref:    "1",
 					Source: "",
 				},
 			},
 			Notes: []*Note{
-				&Note{
+				{
 					Title: "BREAKING CHANGE",
 					Body:  "This is breaking point message.",
 				},
@@ -163,8 +166,9 @@ Fixes #3
 Closes #1
 
 BREAKING CHANGE: This is breaking point message.`,
+			TrimmedBody: `This is body message.`,
 		},
-		&Commit{
+		{
 			Hash: &Hash{
 				Long:  "809a8280ffd0dadb0f4e7ba9fc835e63c37d6af6",
 				Short: "809a8280",
@@ -197,8 +201,9 @@ BREAKING CHANGE: This is breaking point message.`,
 @tsuyoshiwada
 @hogefuga
 @FooBarBaz`,
+			TrimmedBody: `Has mention body`,
 		},
-		&Commit{
+		{
 			Hash: &Hash{
 				Long:  "74824d6bd1470b901ec7123d13a76a1b8938d8d0",
 				Short: "74824d6b",
@@ -216,19 +221,19 @@ BREAKING CHANGE: This is breaking point message.`,
 			Merge:  nil,
 			Revert: nil,
 			Refs: []*Ref{
-				&Ref{
+				{
 					Action: "Fixes",
 					Ref:    "123",
 					Source: "",
 				},
-				&Ref{
+				{
 					Action: "Closes",
 					Ref:    "456",
 					Source: "username/repository",
 				},
 			},
 			Notes: []*Note{
-				&Note{
+				{
 					Title: "BREAKING CHANGE",
 					Body: fmt.Sprintf(`This is multiline breaking change note.
 It is treated as the body of the Note until a mention or reference appears.
@@ -277,8 +282,9 @@ class MyController extends Controller {
 
 Fixes #123
 Closes username/repository#456`, "```", "```"),
+			TrimmedBody: `This mixed body message.`,
 		},
-		&Commit{
+		{
 			Hash: &Hash{
 				Long:  "123456789735dcc4810dda3312b0792236c97c4e",
 				Short: "12345678",
@@ -297,14 +303,114 @@ Closes username/repository#456`, "```", "```"),
 			Revert: &Revert{
 				Header: "fix(core): commit message",
 			},
-			Refs:     []*Ref{},
-			Notes:    []*Note{},
-			Mentions: []string{},
-			Header:   "Revert \"fix(core): commit message\"",
-			Type:     "",
-			Scope:    "",
-			Subject:  "",
-			Body:     "This reverts commit f755db78dcdf461dc42e709b3ab728ceba353d1d.",
+			Refs:        []*Ref{},
+			Notes:       []*Note{},
+			Mentions:    []string{},
+			Header:      "Revert \"fix(core): commit message\"",
+			Type:        "",
+			Scope:       "",
+			Subject:     "",
+			Body:        "This reverts commit f755db78dcdf461dc42e709b3ab728ceba353d1d.",
+			TrimmedBody: "This reverts commit f755db78dcdf461dc42e709b3ab728ceba353d1d.",
 		},
 	}, commits)
 }
+
+type mockJiraClient struct {
+}
+
+func (jira mockJiraClient) GetJiraIssue(id string) (*agjira.Issue, error) {
+	return &agjira.Issue{
+		ID: id,
+		Fields: &agjira.IssueFields{
+			Expand:                        "",
+			Type:                          agjira.IssueType{Name: "Story"},
+			Project:                       agjira.Project{},
+			Resolution:                    nil,
+			Priority:                      nil,
+			Resolutiondate:                agjira.Time{},
+			Created:                       agjira.Time{},
+			Duedate:                       agjira.Date{},
+			Watches:                       nil,
+			Assignee:                      nil,
+			Updated:                       agjira.Time{},
+			Description:                   fmt.Sprintf("description of %s", id),
+			Summary:                       fmt.Sprintf("summary of %s", id),
+			Creator:                       nil,
+			Reporter:                      nil,
+			Components:                    nil,
+			Status:                        nil,
+			Progress:                      nil,
+			AggregateProgress:             nil,
+			TimeTracking:                  nil,
+			TimeSpent:                     0,
+			TimeEstimate:                  0,
+			TimeOriginalEstimate:          0,
+			Worklog:                       nil,
+			IssueLinks:                    nil,
+			Comments:                      nil,
+			FixVersions:                   nil,
+			AffectsVersions:               nil,
+			Labels:                        []string{"GA"},
+			Subtasks:                      nil,
+			Attachments:                   nil,
+			Epic:                          nil,
+			Sprint:                        nil,
+			Parent:                        nil,
+			AggregateTimeOriginalEstimate: 0,
+			AggregateTimeSpent:            0,
+			AggregateTimeEstimate:         0,
+			Unknowns:                      nil,
+		},
+	}, nil
+}
+
+func TestCommitParserParseWithJira(t *testing.T) {
+	assert := assert.New(t)
+	assert.True(true)
+
+	mock := &mockClient{
+		ReturnExec: func(subcmd string, args ...string) (string, error) {
+			if subcmd != "log" {
+				return "", errors.New("")
+			}
+
+			bytes, _ := os.ReadFile(filepath.Join("testdata", "gitlog_jira.txt"))
+
+			return string(bytes), nil
+		},
+	}
+
+	parser := newCommitParser(NewLogger(os.Stdout, os.Stderr, false, true),
+		mock, mockJiraClient{}, &Config{
+			Options: &Options{
+				CommitFilters: map[string][]string{
+					"Type": {
+						"feat",
+						"fix",
+						"perf",
+						"refactor",
+					},
+				},
+				HeaderPattern: "^(?:(\\w*)|(?:\\[(.*)\\])?)\\:\\s(.*)$",
+				HeaderPatternMaps: []string{
+					"Type",
+					"JiraIssueID",
+					"Subject",
+				},
+				JiraTypeMaps: map[string]string{
+					"Story": "feat",
+				},
+			},
+		})
+
+	commits, err := parser.Parse("HEAD")
+	assert.Nil(err)
+	commit := commits[0]
+	assert.Equal(commit.JiraIssueID, "JIRA-1111")
+	assert.Equal(commit.JiraIssue.Type, "Story")
+	assert.Equal(commit.JiraIssue.Summary, "summary of JIRA-1111")
+	assert.Equal(commit.JiraIssue.Description, "description of JIRA-1111")
+	assert.Equal(commit.JiraIssue.Labels, []string{"GA"})
+	assert.Equal(commit.Type, "feat")
+}

example_test.go

@@ -4,56 +4,58 @@ import (
 	"bytes"
 	"fmt"
 	"log"
+	"os"
 )
 
 func 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",
+	gen := NewGenerator(NewLogger(os.Stdout, os.Stderr, false, true),
+		&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": {
+						"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",
 				},
 			},
-			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, "")

fields.go

@@ -8,6 +8,12 @@ type Hash struct {
 	Short string
 }
 
+// Contact of co-authors and signers
+type Contact struct {
+	Name  string
+	Email string
+}
+
 // Author of commit
 type Author struct {
 	Name  string
@@ -52,21 +58,34 @@ type NoteGroup struct {
 	Notes []*Note
 }
 
+// JiraIssue is information about a jira ticket (type, summary, description, and labels)
+type JiraIssue struct {
+	Type        string
+	Summary     string
+	Description string
+	Labels      []string
+}
+
 // Commit data
 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
+	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
+	CoAuthors   []Contact  // (e.g. `Co-authored-by: user <user@email>`)
+	Signers     []Contact  // (e.g. `Signed-off-by: user <user@email>`)
+	JiraIssue   *JiraIssue // If no issue id found in header, `nil` is assigned
+	Header      string     // (e.g. `feat(core)[RNWY-310]: Add new feature`)
+	Type        string     // (e.g. `feat`)
+	Scope       string     // (e.g. `core`)
+	Subject     string     // (e.g. `Add new feature`)
+	JiraIssueID string     // (e.g. `RNWY-310`)
+	Body        string
+	TrimmedBody string // Body without any Notes/Refs/Mentions/CoAuthors/Signers
 }
 
 // CommitGroup is a collection of commits grouped according to the `CommitGroupBy` option
@@ -103,3 +122,12 @@ type Version struct {
 	RevertCommits []*Commit
 	NoteGroups    []*NoteGroup
 }
+
+// Unreleased is unreleased commit dataset
+type Unreleased struct {
+	CommitGroups  []*CommitGroup
+	Commits       []*Commit
+	MergeCommits  []*Commit
+	RevertCommits []*Commit
+	NoteGroups    []*NoteGroup
+}

go.mod

@@ -0,0 +1,48 @@
+module github.com/git-chglog/git-chglog
+
+go 1.24.1
+
+require (
+	github.com/AlecAivazis/survey/v2 v2.3.7
+	github.com/Masterminds/sprig/v3 v3.3.0
+	github.com/andygrunwald/go-jira v1.16.0
+	github.com/coreos/go-semver v0.3.1
+	github.com/fatih/color v1.18.0
+	github.com/imdario/mergo v0.3.16
+	github.com/kyokomi/emoji/v2 v2.2.13
+	github.com/mattn/go-colorable v0.1.14
+	github.com/stretchr/testify v1.10.0
+	github.com/tsuyoshiwada/go-gitcmd v0.0.0-20180205145712-5f1f5f9475df
+	github.com/urfave/cli/v2 v2.27.6
+	gopkg.in/yaml.v2 v2.3.0
+	gopkg.in/yaml.v3 v3.0.1
+)
+
+require (
+	dario.cat/mergo v1.0.1 // indirect
+	github.com/Masterminds/goutils v1.1.1 // indirect
+	github.com/Masterminds/semver/v3 v3.3.0 // indirect
+	github.com/cpuguy83/go-md2man/v2 v2.0.5 // indirect
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/fatih/structs v1.1.0 // indirect
+	github.com/golang-jwt/jwt/v4 v4.4.2 // indirect
+	github.com/google/go-querystring v1.1.0 // indirect
+	github.com/google/uuid v1.6.0 // indirect
+	github.com/huandu/xstrings v1.5.0 // indirect
+	github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b // indirect
+	github.com/mitchellh/copystructure v1.2.0 // indirect
+	github.com/mitchellh/reflectwalk v1.0.2 // indirect
+	github.com/pkg/errors v0.9.1 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/russross/blackfriday/v2 v2.1.0 // indirect
+	github.com/shopspring/decimal v1.4.0 // indirect
+	github.com/spf13/cast v1.7.0 // indirect
+	github.com/trivago/tgo v1.0.7 // indirect
+	github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1 // indirect
+	golang.org/x/crypto v0.26.0 // indirect
+	golang.org/x/sys v0.29.0 // indirect
+	golang.org/x/term v0.23.0 // indirect
+	golang.org/x/text v0.17.0 // indirect
+)

go.sum

@@ -0,0 +1,135 @@
+dario.cat/mergo v1.0.1 h1:Ra4+bf83h2ztPIQYNP99R6m+Y7KfnARDfID+a+vLl4s=
+dario.cat/mergo v1.0.1/go.mod h1:uNxQE+84aUszobStD9th8a29P2fMDhsBdgRYvZOxGmk=
+github.com/AlecAivazis/survey/v2 v2.3.7 h1:6I/u8FvytdGsgonrYsVn2t8t4QiRnh6QSTqkkhIiSjQ=
+github.com/AlecAivazis/survey/v2 v2.3.7/go.mod h1:xUTIdE4KCOIjsBAE1JYsUPoCqYdZ1reCfTwbto0Fduo=
+github.com/Masterminds/goutils v1.1.1 h1:5nUrii3FMTL5diU80unEVvNevw1nH4+ZV4DSLVJLSYI=
+github.com/Masterminds/goutils v1.1.1/go.mod h1:8cTjp+g8YejhMuvIA5y2vz3BpJxksy863GQaJW2MFNU=
+github.com/Masterminds/semver/v3 v3.3.0 h1:B8LGeaivUe71a5qox1ICM/JLl0NqZSW5CHyL+hmvYS0=
+github.com/Masterminds/semver/v3 v3.3.0/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lprf4nC11bSS5beM=
+github.com/Masterminds/sprig/v3 v3.3.0 h1:mQh0Yrg1XPo6vjYXgtf5OtijNAKJRNcTdOOGZe3tPhs=
+github.com/Masterminds/sprig/v3 v3.3.0/go.mod h1:Zy1iXRYNqNLUolqCpL4uhk6SHUMAOSCzdgBfDb35Lz0=
+github.com/Netflix/go-expect v0.0.0-20220104043353-73e0943537d2 h1:+vx7roKuyA63nhn5WAunQHLTznkw5W8b1Xc0dNjp83s=
+github.com/Netflix/go-expect v0.0.0-20220104043353-73e0943537d2/go.mod h1:HBCaDeC1lPdgDeDbhX8XFpy1jqjK0IBG8W5K+xYqA0w=
+github.com/andygrunwald/go-jira v1.16.0 h1:PU7C7Fkk5L96JvPc6vDVIrd99vdPnYudHu4ju2c2ikQ=
+github.com/andygrunwald/go-jira v1.16.0/go.mod h1:UQH4IBVxIYWbgagc0LF/k9FRs9xjIiQ8hIcC6HfLwFU=
+github.com/coreos/go-semver v0.3.1 h1:yi21YpKnrx1gt5R+la8n5WgS0kCrsPp33dmEyHReZr4=
+github.com/coreos/go-semver v0.3.1/go.mod h1:irMmmIw/7yzSRPWryHsK7EYSg09caPQL03VsM8rvUec=
+github.com/cpuguy83/go-md2man/v2 v2.0.5 h1:ZtcqGrnekaHpVLArFSe4HK5DoKx1T0rq2DwVB0alcyc=
+github.com/cpuguy83/go-md2man/v2 v2.0.5/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/creack/pty v1.1.17 h1:QeVUsEDNrLBW4tMgZHvxy18sKtr6VI492kBhUfhDJNI=
+github.com/creack/pty v1.1.17/go.mod h1:MOBLtS5ELjhRRrroQr9kyvTxUAFNvYEK993ew/Vr4O4=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
+github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
+github.com/fatih/structs v1.1.0 h1:Q7juDM0QtcnhCpeyLGQKyg4TOIghuNXrkL32pHAUMxo=
+github.com/fatih/structs v1.1.0/go.mod h1:9NiDSp5zOcgEDl+j00MP/WkGVPOlPRLejGD8Ga6PJ7M=
+github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
+github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
+github.com/golang-jwt/jwt/v4 v4.4.2 h1:rcc4lwaZgFMCZ5jxF9ABolDcIHdBytAFgqFPbSJQAYs=
+github.com/golang-jwt/jwt/v4 v4.4.2/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0=
+github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.8/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/go-querystring v1.1.0 h1:AnCroh3fv4ZBgVIf1Iwtovgjaw/GiKJo8M8yD/fhyJ8=
+github.com/google/go-querystring v1.1.0/go.mod h1:Kcdr2DB4koayq7X8pmAG4sNG59So17icRSOU623lUBU=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/hinshun/vt10x v0.0.0-20220119200601-820417d04eec h1:qv2VnGeEQHchGaZ/u7lxST/RaJw+cv273q79D81Xbog=
+github.com/hinshun/vt10x v0.0.0-20220119200601-820417d04eec/go.mod h1:Q48J4R4DvxnHolD5P8pOtXigYlRuPLGl6moFx3ulM68=
+github.com/huandu/xstrings v1.5.0 h1:2ag3IFq9ZDANvthTwTiqSSZLjDc+BedvHPAp5tJy2TI=
+github.com/huandu/xstrings v1.5.0/go.mod h1:y5/lhBue+AyNmUVz9RLU9xbLR0o4KIIExikq4ovT0aE=
+github.com/imdario/mergo v0.3.16 h1:wwQJbIsHYGMUyLSPrEq1CT16AhnhNJQ51+4fdHUnCl4=
+github.com/imdario/mergo v0.3.16/go.mod h1:WBLT9ZmE3lPoWsEzCh9LPo3TiwVN+ZKEjmz+hD27ysY=
+github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 h1:Z9n2FFNUXsshfwJMBgNA0RU6/i7WVaAegv3PtuIHPMs=
+github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51/go.mod h1:CzGEWj7cYgsdH8dAjBGEr58BoE7ScuLd+fwFZ44+/x8=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/kyokomi/emoji/v2 v2.2.13 h1:GhTfQa67venUUvmleTNFnb+bi7S3aocF7ZCXU9fSO7U=
+github.com/kyokomi/emoji/v2 v2.2.13/go.mod h1:JUcn42DTdsXJo1SWanHh4HKDEyPaR5CqkmoirZZP9qE=
+github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
+github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
+github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b h1:j7+1HpAFS1zy5+Q4qx1fWh90gTKwiN4QCGoY9TWyyO4=
+github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b/go.mod h1:01TrycV0kFyexm33Z7vhZRXopbI8J3TDReVlkTgMUxE=
+github.com/mitchellh/copystructure v1.2.0 h1:vpKXTN4ewci03Vljg/q9QvCGUDttBOGBIa15WveJJGw=
+github.com/mitchellh/copystructure v1.2.0/go.mod h1:qLl+cE2AmVv+CoeAwDPye/v+N2HKCj9FbZEVFJRxO9s=
+github.com/mitchellh/reflectwalk v1.0.2 h1:G2LzWKi524PWgd3mLHV8Y5k7s6XUvT0Gef6zxSIeXaQ=
+github.com/mitchellh/reflectwalk v1.0.2/go.mod h1:mSTlrgnPZtwu0c4WaC2kGObEpuNDbx0jmZXqmk4esnw=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8=
+github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
+github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
+github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
+github.com/shopspring/decimal v1.4.0 h1:bxl37RwXBklmTi0C79JfXCEBD1cqqHt0bbgBAGFp81k=
+github.com/shopspring/decimal v1.4.0/go.mod h1:gawqmDU56v4yIKSwfBSFip1HdCCXN8/+DMd9qYNcwME=
+github.com/spf13/cast v1.7.0 h1:ntdiHjuueXFgm5nzDRdOS4yfT43P5Fnud6DH50rz/7w=
+github.com/spf13/cast v1.7.0/go.mod h1:ancEpBxwJDODSW/UG4rDrAqiKolqNNh2DX3mk86cAdo=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
+github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/trivago/tgo v1.0.7 h1:uaWH/XIy9aWYWpjm2CU3RpcqZXmX2ysQ9/Go+d9gyrM=
+github.com/trivago/tgo v1.0.7/go.mod h1:w4dpD+3tzNIIiIfkWWa85w5/B77tlvdZckQ+6PkFnhc=
+github.com/tsuyoshiwada/go-gitcmd v0.0.0-20180205145712-5f1f5f9475df h1:Y2l28Jr3vOEeYtxfVbMtVfOdAwuUqWaP9fvNKiBVeXY=
+github.com/tsuyoshiwada/go-gitcmd v0.0.0-20180205145712-5f1f5f9475df/go.mod h1:pnyouUty/nBr/zm3GYwTIt+qFTLWbdjeLjZmJdzJOu8=
+github.com/urfave/cli/v2 v2.27.6 h1:VdRdS98FNhKZ8/Az8B7MTyGQmpIr36O1EHybx/LaZ4g=
+github.com/urfave/cli/v2 v2.27.6/go.mod h1:3Sevf16NykTbInEnD0yKkjDAeZDS0A6bzhBH5hrMvTQ=
+github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1 h1:gEOO8jv9F4OT7lGCjxCBTO/36wtF6j2nSip77qHd4x4=
+github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1/go.mod h1:Ohn+xnUBiLI6FVj/9LpzZWtj1/D6lUovWYBkxHVV3aM=
+github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/crypto v0.26.0 h1:RrRspgV4mU+YwB4FYnuBoKsUapNIL5cohGAmSH3azsw=
+golang.org/x/crypto v0.26.0/go.mod h1:GY7jblb9wI+FOo5y8/S2oY4zWP07AkOJ4+jxCqdqn54=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220330033206-e17cdc41300f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.29.0 h1:TPYlXGxvx1MGTn2GiZDhnjPA9wZzZeGKHHmKhHYvgaU=
+golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210220032956-6a3ed077a48d/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.23.0 h1:F6D4vR+EHoL9/sWAWgAR1H2DcHr4PareCbAaCo1RpuU=
+golang.org/x/term v0.23.0/go.mod h1:DgV24QBUrK6jhZXl+20l6UWznPlwAHm1Q1mGHtydmSk=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.17.0 h1:XtiM5bkSOt+ewxlOE/aE/AKEHibwj/6gvWMl9Rsh0Qc=
+golang.org/x/text v0.17.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v2 v2.3.0 h1:clyUAQHOM3G0M3f5vQj7LuJrETvjVot3Z5el9nffUtU=
+gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
+gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

jira.go

@@ -0,0 +1,38 @@
+package chglog
+
+import (
+	agjira "github.com/andygrunwald/go-jira"
+)
+
+// JiraClient is an HTTP client for Jira
+type JiraClient interface {
+	GetJiraIssue(id string) (*agjira.Issue, error)
+}
+
+type jiraClient struct {
+	username string
+	token    string
+	url      string
+}
+
+// NewJiraClient returns an instance of JiraClient
+func NewJiraClient(config *Config) JiraClient {
+	return jiraClient{
+		username: config.Options.JiraUsername,
+		token:    config.Options.JiraToken,
+		url:      config.Options.JiraURL,
+	}
+}
+
+func (jira jiraClient) GetJiraIssue(id string) (*agjira.Issue, error) {
+	tp := agjira.BasicAuthTransport{
+		Username: jira.username,
+		Password: jira.token,
+	}
+	client, err := agjira.NewClient(tp.Client(), jira.url)
+	if err != nil {
+		return nil, err
+	}
+	issue, _, err := client.Issue.Get(id, nil)
+	return issue, err
+}

jira_test.go

@@ -0,0 +1,43 @@
+package chglog
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestJira(t *testing.T) {
+	assert := assert.New(t)
+
+	config := &Config{
+		Options: &Options{
+			Processor:                   nil,
+			NextTag:                     "",
+			TagFilterPattern:            "",
+			CommitFilters:               nil,
+			CommitSortBy:                "",
+			CommitGroupBy:               "",
+			CommitGroupSortBy:           "",
+			CommitGroupTitleMaps:        nil,
+			HeaderPattern:               "",
+			HeaderPatternMaps:           nil,
+			IssuePrefix:                 nil,
+			RefActions:                  nil,
+			MergePattern:                "",
+			MergePatternMaps:            nil,
+			RevertPattern:               "",
+			RevertPatternMaps:           nil,
+			NoteKeywords:                nil,
+			JiraUsername:                "uuu",
+			JiraToken:                   "ppp",
+			JiraURL:                     "http://jira.com",
+			JiraTypeMaps:                nil,
+			JiraIssueDescriptionPattern: "",
+		},
+	}
+
+	jira := NewJiraClient(config)
+	issue, err := jira.GetJiraIssue("fake")
+	assert.Nil(issue)
+	assert.Error(err)
+}

logger.go

@@ -1,4 +1,4 @@
-package main
+package chglog
 
 import (
 	"fmt"
@@ -7,7 +7,7 @@ import (
 	"regexp"
 
 	"github.com/fatih/color"
-	emoji "gopkg.in/kyokomi/emoji.v1"
+	"github.com/kyokomi/emoji/v2"
 )
 
 // Logger ...
@@ -26,7 +26,7 @@ func NewLogger(stdout, stderr io.Writer, silent, noEmoji bool) *Logger {
 		stderr:  stderr,
 		silent:  silent,
 		noEmoji: noEmoji,
-		reEmoji: regexp.MustCompile(":[\\w\\+_\\-]+:\\s?"),
+		reEmoji: regexp.MustCompile(`:[\w\+_\-]+:\s?`),
 	}
 }
 

logger_test.go

@@ -1,4 +1,4 @@
-package main
+package chglog
 
 import (
 	"bytes"
@@ -6,8 +6,8 @@ import (
 	"testing"
 
 	"github.com/fatih/color"
+	emoji "github.com/kyokomi/emoji/v2"
 	"github.com/stretchr/testify/assert"
-	emoji "gopkg.in/kyokomi/emoji.v1"
 )
 
 func TestLoggerLogSilent(t *testing.T) {
@@ -40,7 +40,7 @@ func TestLoggerLogNoEmoji(t *testing.T) {
 	stderr := &bytes.Buffer{}
 	logger := NewLogger(stdout, stderr, false, true)
 	logger.Log(":+1:Hello, World! :)")
-	assert.Equal(fmt.Sprint("Hello, World! :)\n"), stdout.String())
+	assert.Equal(fmt.Sprint("Hello, World! :)\n"), stdout.String()) //nolint:gosimple
 }
 
 func TestLoggerError(t *testing.T) {

processor.go

@@ -14,8 +14,8 @@ type Processor interface {
 // 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))
+//   - Mentions automatic link (@tsuyoshiwada -> [@tsuyoshiwada](https://github.com/tsuyoshiwada))
+//   - Automatic link to references (#123 -> [#123](https://github.com/owner/repo/issues/123))
 type GitHubProcessor struct {
 	Host      string // Host name used for link destination. Note: You must include the protocol (e.g. "https://github.com")
 	config    *Config
@@ -33,8 +33,8 @@ func (p *GitHubProcessor) Bootstrap(config *Config) {
 		p.Host = strings.TrimRight(p.Host, "/")
 	}
 
-	p.reMention = regexp.MustCompile("@(\\w+)")
-	p.reIssue = regexp.MustCompile("(?i)(#|gh-)(\\d+)")
+	p.reMention = regexp.MustCompile(`@(\w+)`)
+	p.reIssue = regexp.MustCompile(`(?i)(#|gh-)(\d+)`)
 }
 
 // ProcessCommit ...
@@ -65,3 +65,119 @@ func (p *GitHubProcessor) addLinks(input string) string {
 
 	return input
 }
+
+// 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 issues (#123 -> [#123](https://gitlab.com/owner/repo/issues/123))
+//   - Automatic link to references merge request (!123 -> [#123](https://gitlab.com/owner/repo/merge_requests/123))
+type GitLabProcessor struct {
+	Host           string // Host name used for link destination. Note: You must include the protocol (e.g. "https://gitlab.com")
+	config         *Config
+	reMention      *regexp.Regexp
+	reIssue        *regexp.Regexp
+	reMergeRequest *regexp.Regexp
+}
+
+// Bootstrap ...
+func (p *GitLabProcessor) Bootstrap(config *Config) {
+	p.config = config
+
+	if p.Host == "" {
+		p.Host = "https://gitlab.com"
+	} else {
+		p.Host = strings.TrimRight(p.Host, "/")
+	}
+
+	p.reMention = regexp.MustCompile(`@(\w+)`)
+	p.reIssue = regexp.MustCompile(`(?i)#(\d+)`)
+	p.reMergeRequest = regexp.MustCompile(`(?i)!(\d+)`)
+}
+
+// ProcessCommit ...
+func (p *GitLabProcessor) ProcessCommit(commit *Commit) *Commit {
+	commit.Header = p.addLinks(commit.Header)
+	commit.Subject = p.addLinks(commit.Subject)
+	commit.Body = p.addLinks(commit.Body)
+
+	for _, note := range commit.Notes {
+		note.Body = p.addLinks(note.Body)
+	}
+
+	if commit.Revert != nil {
+		commit.Revert.Header = p.addLinks(commit.Revert.Header)
+	}
+
+	return commit
+}
+
+func (p *GitLabProcessor) addLinks(input string) string {
+	repoURL := strings.TrimRight(p.config.Info.RepositoryURL, "/")
+
+	// mentions
+	input = p.reMention.ReplaceAllString(input, "[@$1]("+p.Host+"/$1)")
+
+	// issues
+	input = p.reIssue.ReplaceAllString(input, "[#$1]("+repoURL+"/issues/$1)")
+
+	// merge requests
+	input = p.reMergeRequest.ReplaceAllString(input, "[!$1]("+repoURL+"/merge_requests/$1)")
+
+	return input
+}
+
+// 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/))
+type BitbucketProcessor struct {
+	Host      string // Host name used for link destination. Note: You must include the protocol (e.g. "https://bitbucket.org")
+	config    *Config
+	reMention *regexp.Regexp
+	reIssue   *regexp.Regexp
+}
+
+// Bootstrap ...
+func (p *BitbucketProcessor) Bootstrap(config *Config) {
+	p.config = config
+
+	if p.Host == "" {
+		p.Host = "https://bitbucket.org"
+	} else {
+		p.Host = strings.TrimRight(p.Host, "/")
+	}
+
+	p.reMention = regexp.MustCompile(`@(\w+)`)
+	p.reIssue = regexp.MustCompile(`(?i)#(\d+)`)
+}
+
+// ProcessCommit ...
+func (p *BitbucketProcessor) ProcessCommit(commit *Commit) *Commit {
+	commit.Header = p.addLinks(commit.Header)
+	commit.Subject = p.addLinks(commit.Subject)
+	commit.Body = p.addLinks(commit.Body)
+
+	for _, note := range commit.Notes {
+		note.Body = p.addLinks(note.Body)
+	}
+
+	if commit.Revert != nil {
+		commit.Revert.Header = p.addLinks(commit.Revert.Header)
+	}
+
+	return commit
+}
+
+func (p *BitbucketProcessor) addLinks(input string) string {
+	repoURL := strings.TrimRight(p.config.Info.RepositoryURL, "/")
+
+	// mentions
+	input = p.reMention.ReplaceAllString(input, "[@$1]("+p.Host+"/$1/)")
+
+	// issues
+	input = p.reIssue.ReplaceAllString(input, "[#$1]("+repoURL+"/issues/$1/)")
+
+	return input
+}

processor_test.go

@@ -27,7 +27,7 @@ func TestGitHubProcessor(t *testing.T) {
 multiline [#789](https://example.com/issues/789)
 [@foo](https://github.com/foo), [@bar](https://github.com/bar)`,
 			Notes: []*Note{
-				&Note{
+				{
 					Body: `issue1 [#11](https://example.com/issues/11)
 issue2 [#22](https://example.com/issues/22)
 [gh-56](https://example.com/issues/56) hoge fuga`,
@@ -42,7 +42,7 @@ issue2 [#22](https://example.com/issues/22)
 multiline #789
 @foo, @bar`,
 				Notes: []*Note{
-					&Note{
+					{
 						Body: `issue1 #11
 issue2 #22
 gh-56 hoge fuga`,
@@ -67,3 +67,131 @@ gh-56 hoge fuga`,
 		),
 	)
 }
+
+func TestGitLabProcessor(t *testing.T) {
+	assert := assert.New(t)
+
+	config := &Config{
+		Info: &Info{
+			RepositoryURL: "https://example.com",
+		},
+	}
+
+	processor := &GitLabProcessor{}
+
+	processor.Bootstrap(config)
+
+	assert.Equal(
+		&Commit{
+			Header:  "message [@foo](https://gitlab.com/foo) [#123](https://example.com/issues/123) [!345](https://example.com/merge_requests/345)",
+			Subject: "message [@foo](https://gitlab.com/foo) [#123](https://example.com/issues/123) [!345](https://example.com/merge_requests/345)",
+			Body: `issue [#456](https://example.com/issues/456)
+multiline [#789](https://example.com/issues/789)
+merge request [!345](https://example.com/merge_requests/345)
+[@foo](https://gitlab.com/foo), [@bar](https://gitlab.com/bar)`,
+			Notes: []*Note{
+				{
+					Body: `issue1 [#11](https://example.com/issues/11) [!33](https://example.com/merge_requests/33)
+issue2 [#22](https://example.com/issues/22)
+merge request [!33](https://example.com/merge_requests/33)
+gh-56 hoge fuga`,
+				},
+			},
+		},
+		processor.ProcessCommit(
+			&Commit{
+				Header:  "message @foo #123 !345",
+				Subject: "message @foo #123 !345",
+				Body: `issue #456
+multiline #789
+merge request !345
+@foo, @bar`,
+				Notes: []*Note{
+					{
+						Body: `issue1 #11 !33
+issue2 #22
+merge request !33
+gh-56 hoge fuga`,
+					},
+				},
+			},
+		),
+	)
+
+	assert.Equal(
+		&Commit{
+			Revert: &Revert{
+				Header: "revert header [@mention](https://gitlab.com/mention) [#123](https://example.com/issues/123) [!345](https://example.com/merge_requests/345)",
+			},
+		},
+		processor.ProcessCommit(
+			&Commit{
+				Revert: &Revert{
+					Header: "revert header @mention #123 !345",
+				},
+			},
+		),
+	)
+}
+
+func TestBitbucketProcessor(t *testing.T) {
+	assert := assert.New(t)
+
+	config := &Config{
+		Info: &Info{
+			RepositoryURL: "https://example.com",
+		},
+	}
+
+	processor := &BitbucketProcessor{}
+
+	processor.Bootstrap(config)
+
+	assert.Equal(
+		&Commit{
+			Header:  "message [@foo](https://bitbucket.org/foo/) [#123](https://example.com/issues/123/)",
+			Subject: "message [@foo](https://bitbucket.org/foo/) [#123](https://example.com/issues/123/)",
+			Body: `issue [#456](https://example.com/issues/456/)
+multiline [#789](https://example.com/issues/789/)
+[@foo](https://bitbucket.org/foo/), [@bar](https://bitbucket.org/bar/)`,
+			Notes: []*Note{
+				{
+					Body: `issue1 [#11](https://example.com/issues/11/)
+issue2 [#22](https://example.com/issues/22/)
+gh-56 hoge fuga`,
+				},
+			},
+		},
+		processor.ProcessCommit(
+			&Commit{
+				Header:  "message @foo #123",
+				Subject: "message @foo #123",
+				Body: `issue #456
+multiline #789
+@foo, @bar`,
+				Notes: []*Note{
+					{
+						Body: `issue1 #11
+issue2 #22
+gh-56 hoge fuga`,
+					},
+				},
+			},
+		),
+	)
+
+	assert.Equal(
+		&Commit{
+			Revert: &Revert{
+				Header: "revert header [@mention](https://bitbucket.org/mention/) [#123](https://example.com/issues/123/)",
+			},
+		},
+		processor.ProcessCommit(
+			&Commit{
+				Revert: &Revert{
+					Header: "revert header @mention #123",
+				},
+			},
+		),
+	)
+}

scripts/release.sh

@@ -1,12 +0,0 @@
-#!/bin/bash
-
-REPO_ROOT=$(git rev-parse --show-toplevel)
-
-if [[ "$TRAVIS_BRANCH" == "master" ]] && [[ "$TRAVIS_TAG" != "" ]] && [[ "$TRAVIS_PULL_REQUEST" == "" ]]; then
-  echo "Start release ..."
-  gox -os="darwin linux windows" -arch="amd64 386" -output="$REPO_ROOT/dist/{{.Dir}}_{{.OS}}_{{.Arch}}" ./cmd/git-chglog
-  ghr --username git-chglog --token $GITHUB_TOKEN --replace `grep 'Version =' ./cmd/git-chglog/version.go | sed -E 's/.*"(.+)"$$/\1/'` dist/
-  echo "Released!"
-else
-  echo "Skip release"
-fi

tag_reader.go

@@ -2,23 +2,28 @@ package chglog
 
 import (
 	"fmt"
+	"regexp"
 	"sort"
 	"strings"
 	"time"
 
+	"github.com/coreos/go-semver/semver"
 	gitcmd "github.com/tsuyoshiwada/go-gitcmd"
 )
 
 type tagReader struct {
 	client    gitcmd.Client
-	format    string
 	separator string
+	reFilter  *regexp.Regexp
+	sortBy    string
 }
 
-func newTagReader(client gitcmd.Client) *tagReader {
+func newTagReader(client gitcmd.Client, filterPattern string, sort string) *tagReader {
 	return &tagReader{
 		client:    client,
 		separator: "@@__CHGLOG__@@",
+		reFilter:  regexp.MustCompile(filterPattern),
+		sortBy:    sort,
 	}
 }
 
@@ -33,7 +38,7 @@ func (r *tagReader) ReadAll() ([]*Tag, error) {
 	tags := []*Tag{}
 
 	if err != nil {
-		return tags, fmt.Errorf("failed to get git-tag: %s", err.Error())
+		return tags, fmt.Errorf("failed to get git-tag: %w", err)
 	}
 
 	lines := strings.Split(out, "\n")
@@ -56,6 +61,12 @@ func (r *tagReader) ReadAll() ([]*Tag, error) {
 			date = t
 		}
 
+		if r.reFilter != nil {
+			if !r.reFilter.MatchString(name) {
+				continue
+			}
+		}
+
 		tags = append(tags, &Tag{
 			Name:    name,
 			Subject: subject,
@@ -63,12 +74,33 @@ func (r *tagReader) ReadAll() ([]*Tag, error) {
 		})
 	}
 
-	r.sortTags(tags)
+	switch r.sortBy {
+	case "date":
+		r.sortTags(tags)
+	case "semver":
+		r.filterSemVerTags(&tags)
+		r.sortTagsBySemver(tags)
+	}
 	r.assignPreviousAndNextTag(tags)
 
 	return tags, nil
 }
 
+func (*tagReader) filterSemVerTags(tags *[]*Tag) {
+	// filter out any non-semver tags
+	for i, t := range *tags {
+		// remove leading v, since its so
+		// common.
+		name := strings.TrimPrefix(t.Name, "v")
+
+		// attempt semver parse, if not successful
+		// remove it from tags slice.
+		if _, err := semver.NewVersion(name); err != nil {
+			*tags = append((*tags)[:i], (*tags)[i+1:]...)
+		}
+	}
+}
+
 func (*tagReader) parseRefname(input string) string {
 	return strings.Replace(input, "refs/tags/", "", 1)
 }
@@ -116,3 +148,13 @@ func (*tagReader) sortTags(tags []*Tag) {
 		return !tags[i].Date.Before(tags[j].Date)
 	})
 }
+
+func (*tagReader) sortTagsBySemver(tags []*Tag) {
+	sort.Slice(tags, func(i, j int) bool {
+		semver1 := strings.TrimPrefix(tags[i].Name, "v")
+		semver2 := strings.TrimPrefix(tags[j].Name, "v")
+		v1 := semver.New(semver1)
+		v2 := semver.New(semver2)
+		return v2.LessThan(*v1)
+	})
+}

tag_reader_test.go

@@ -21,6 +21,7 @@ func TestTagReader(t *testing.T) {
 				"refs/tags/v2.0.4-beta.1@@__CHGLOG__@@Release v2.0.4-beta.1@@__CHGLOG__@@Thu Feb 1 00:00:00 2018 +0000@@__CHGLOG__@@",
 				"refs/tags/4.4.3@@__CHGLOG__@@This is tag subject@@__CHGLOG__@@@@__CHGLOG__@@Fri Feb 2 00:00:00 2018 +0000",
 				"refs/tags/4.4.4@@__CHGLOG__@@Release 4.4.4@@__CHGLOG__@@Fri Feb 2 10:00:40 2018 +0000@@__CHGLOG__@@",
+				"refs/tags/v2.0.4-beta.2@@__CHGLOG__@@Release v2.0.4-beta.2@@__CHGLOG__@@Sat Feb 3 12:15:00 2018 +0000@@__CHGLOG__@@",
 				"refs/tags/5.0.0-rc.0@@__CHGLOG__@@Release 5.0.0-rc.0@@__CHGLOG__@@Sat Feb 3 12:30:10 2018 +0000@@__CHGLOG__@@",
 				"refs/tags/hoge_fuga@@__CHGLOG__@@Invalid semver tag name@@__CHGLOG__@@Mon Mar 12 12:30:10 2018 +0000@@__CHGLOG__@@",
 				"hoge@@__CHGLOG__@@",
@@ -28,12 +29,12 @@ func TestTagReader(t *testing.T) {
 		},
 	}
 
-	actual, err := newTagReader(client).ReadAll()
+	actual, err := newTagReader(client, "", "date").ReadAll()
 	assert.Nil(err)
 
 	assert.Equal(
 		[]*Tag{
-			&Tag{
+			{
 				Name:    "hoge_fuga",
 				Subject: "Invalid semver tag name",
 				Date:    time.Date(2018, 3, 12, 12, 30, 10, 0, time.UTC),
@@ -44,7 +45,7 @@ func TestTagReader(t *testing.T) {
 					Date:    time.Date(2018, 2, 3, 12, 30, 10, 0, time.UTC),
 				},
 			},
-			&Tag{
+			{
 				Name:    "5.0.0-rc.0",
 				Subject: "Release 5.0.0-rc.0",
 				Date:    time.Date(2018, 2, 3, 12, 30, 10, 0, time.UTC),
@@ -53,20 +54,35 @@ func TestTagReader(t *testing.T) {
 					Subject: "Invalid semver tag name",
 					Date:    time.Date(2018, 3, 12, 12, 30, 10, 0, time.UTC),
 				},
+				Previous: &RelateTag{
+					Name:    "v2.0.4-beta.2",
+					Subject: "Release v2.0.4-beta.2",
+					Date:    time.Date(2018, 2, 3, 12, 15, 0, 0, time.UTC),
+				},
+			},
+			{
+				Name:    "v2.0.4-beta.2",
+				Subject: "Release v2.0.4-beta.2",
+				Date:    time.Date(2018, 2, 3, 12, 15, 0, 0, time.UTC),
+				Next: &RelateTag{
+					Name:    "5.0.0-rc.0",
+					Subject: "Release 5.0.0-rc.0",
+					Date:    time.Date(2018, 2, 3, 12, 30, 10, 0, time.UTC),
+				},
 				Previous: &RelateTag{
 					Name:    "4.4.4",
 					Subject: "Release 4.4.4",
 					Date:    time.Date(2018, 2, 2, 10, 0, 40, 0, time.UTC),
 				},
 			},
-			&Tag{
+			{
 				Name:    "4.4.4",
 				Subject: "Release 4.4.4",
 				Date:    time.Date(2018, 2, 2, 10, 0, 40, 0, time.UTC),
 				Next: &RelateTag{
-					Name:    "5.0.0-rc.0",
-					Subject: "Release 5.0.0-rc.0",
-					Date:    time.Date(2018, 2, 3, 12, 30, 10, 0, time.UTC),
+					Name:    "v2.0.4-beta.2",
+					Subject: "Release v2.0.4-beta.2",
+					Date:    time.Date(2018, 2, 3, 12, 15, 0, 0, time.UTC),
 				},
 				Previous: &RelateTag{
 					Name:    "4.4.3",
@@ -74,7 +90,7 @@ func TestTagReader(t *testing.T) {
 					Date:    time.Date(2018, 2, 2, 0, 0, 0, 0, time.UTC),
 				},
 			},
-			&Tag{
+			{
 				Name:    "4.4.3",
 				Subject: "This is tag subject",
 				Date:    time.Date(2018, 2, 2, 0, 0, 0, 0, time.UTC),
@@ -89,7 +105,7 @@ func TestTagReader(t *testing.T) {
 					Date:    time.Date(2018, 2, 1, 0, 0, 0, 0, time.UTC),
 				},
 			},
-			&Tag{
+			{
 				Name:    "v2.0.4-beta.1",
 				Subject: "Release v2.0.4-beta.1",
 				Date:    time.Date(2018, 2, 1, 0, 0, 0, 0, time.UTC),
@@ -103,4 +119,110 @@ func TestTagReader(t *testing.T) {
 		},
 		actual,
 	)
+
+	actual, err = newTagReader(client, "", "semver").ReadAll()
+	assert.Nil(err)
+
+	assert.Equal(
+		[]*Tag{
+			{
+				Name:    "5.0.0-rc.0",
+				Subject: "Release 5.0.0-rc.0",
+				Date:    time.Date(2018, 2, 3, 12, 30, 10, 0, time.UTC),
+				Next:    nil,
+				Previous: &RelateTag{
+					Name:    "4.4.4",
+					Subject: "Release 4.4.4",
+					Date:    time.Date(2018, 2, 2, 10, 0, 40, 0, time.UTC),
+				},
+			},
+			{
+				Name:    "4.4.4",
+				Subject: "Release 4.4.4",
+				Date:    time.Date(2018, 2, 2, 10, 0, 40, 0, time.UTC),
+				Next: &RelateTag{
+					Name:    "5.0.0-rc.0",
+					Subject: "Release 5.0.0-rc.0",
+					Date:    time.Date(2018, 2, 3, 12, 30, 10, 0, time.UTC),
+				},
+				Previous: &RelateTag{
+					Name:    "4.4.3",
+					Subject: "This is tag subject",
+					Date:    time.Date(2018, 2, 2, 0, 0, 0, 0, time.UTC),
+				},
+			},
+			{
+				Name:    "4.4.3",
+				Subject: "This is tag subject",
+				Date:    time.Date(2018, 2, 2, 0, 0, 0, 0, time.UTC),
+				Next: &RelateTag{
+					Name:    "4.4.4",
+					Subject: "Release 4.4.4",
+					Date:    time.Date(2018, 2, 2, 10, 0, 40, 0, time.UTC),
+				},
+				Previous: &RelateTag{
+					Name:    "v2.0.4-beta.2",
+					Subject: "Release v2.0.4-beta.2",
+					Date:    time.Date(2018, 2, 3, 12, 15, 0, 0, time.UTC),
+				},
+			},
+			{
+				Name:    "v2.0.4-beta.2",
+				Subject: "Release v2.0.4-beta.2",
+				Date:    time.Date(2018, 2, 3, 12, 15, 0, 0, time.UTC),
+				Next: &RelateTag{
+					Name:    "4.4.3",
+					Subject: "This is tag subject",
+					Date:    time.Date(2018, 2, 2, 0, 0, 0, 0, time.UTC),
+				},
+				Previous: &RelateTag{
+					Name:    "v2.0.4-beta.1",
+					Subject: "Release v2.0.4-beta.1",
+					Date:    time.Date(2018, 2, 1, 0, 0, 0, 0, time.UTC),
+				},
+			},
+			{
+				Name:    "v2.0.4-beta.1",
+				Subject: "Release v2.0.4-beta.1",
+				Date:    time.Date(2018, 2, 1, 0, 0, 0, 0, time.UTC),
+				Next: &RelateTag{
+					Name:    "v2.0.4-beta.2",
+					Subject: "Release v2.0.4-beta.2",
+					Date:    time.Date(2018, 2, 3, 12, 15, 0, 0, time.UTC),
+				},
+				Previous: nil,
+			},
+		},
+		actual,
+	)
+
+	actualFiltered, errFiltered := newTagReader(client, "^v", "date").ReadAll()
+	assert.Nil(errFiltered)
+	assert.Equal(
+		[]*Tag{
+			{
+				Name:    "v2.0.4-beta.2",
+				Subject: "Release v2.0.4-beta.2",
+				Date:    time.Date(2018, 2, 3, 12, 15, 0, 0, time.UTC),
+				Next:    nil,
+				Previous: &RelateTag{
+					Name:    "v2.0.4-beta.1",
+					Subject: "Release v2.0.4-beta.1",
+					Date:    time.Date(2018, 2, 1, 0, 0, 0, 0, time.UTC),
+				},
+			},
+			{
+				Name:    "v2.0.4-beta.1",
+				Subject: "Release v2.0.4-beta.1",
+				Date:    time.Date(2018, 2, 1, 0, 0, 0, 0, time.UTC),
+				Next: &RelateTag{
+					Name:    "v2.0.4-beta.2",
+					Subject: "Release v2.0.4-beta.2",
+					Date:    time.Date(2018, 2, 3, 12, 15, 0, 0, time.UTC),
+				},
+				Previous: nil,
+			},
+		},
+		actualFiltered,
+	)
 }

tag_selector.go

@@ -19,14 +19,16 @@ func (s *tagSelector) Select(tags []*Tag, query string) ([]*Tag, string, error)
 	case 2:
 		old := tokens[0]
 		new := tokens[1]
-		if old == "" && new == "" {
+		switch {
+		case old == "" && new == "":
 			return nil, "", nil
-		} else if old == "" {
+		case old == "":
 			return s.selectBeforeTags(tags, new)
-		} else if new == "" {
+		case new == "":
 			return s.selectAfterTags(tags, old)
+		default:
+			return s.selectRangeTags(tags, tokens[0], tokens[1])
 		}
-		return s.selectRangeTags(tags, tokens[0], tokens[1])
 	}
 
 	return nil, "", errFailedQueryParse
@@ -76,7 +78,8 @@ func (*tagSelector) selectBeforeTags(tags []*Tag, token string) ([]*Tag, string,
 }
 
 func (*tagSelector) selectAfterTags(tags []*Tag, token string) ([]*Tag, string, error) {
-	var (
+	// NOTE(clok): the res slice can range in size based on the token passed in.
+	var ( //nolint:prealloc
 		res  []*Tag
 		from string
 	)

tag_selector_test.go

@@ -12,51 +12,51 @@ func TestTagSelector(t *testing.T) {
 	selector := newTagSelector()
 
 	fixtures := []*Tag{
-		&Tag{Name: "2.2.12-rc.12"},
-		&Tag{Name: "2.1.0"},
-		&Tag{Name: "v2.0.0-beta.1"},
-		&Tag{Name: "v1.2.9"},
-		&Tag{Name: "v1.0.0"},
+		{Name: "2.2.12-rc.12"},
+		{Name: "2.1.0"},
+		{Name: "v2.0.0-beta.1"},
+		{Name: "v1.2.9"},
+		{Name: "v1.0.0"},
 	}
 
 	table := map[string][]string{
 		// Single
-		"2.2.12-rc.12": []string{
+		"2.2.12-rc.12": {
 			"2.2.12-rc.12",
 			"2.1.0",
 		},
-		"v2.0.0-beta.1": []string{
+		"v2.0.0-beta.1": {
 			"v2.0.0-beta.1",
 			"v1.2.9",
 		},
-		"v1.0.0": []string{
+		"v1.0.0": {
 			"v1.0.0",
 			"",
 		},
 		// ~ <tag>
-		"..2.1.0": []string{
+		"..2.1.0": {
 			"2.1.0",
 			"v2.0.0-beta.1",
 			"v1.2.9",
 			"v1.0.0",
 			"",
 		},
-		"..v1.0.0": []string{
+		"..v1.0.0": {
 			"v1.0.0",
 			"",
 		},
 		// <tag> ~
-		"v2.0.0-beta.1..": []string{
+		"v2.0.0-beta.1..": {
 			"2.2.12-rc.12",
 			"2.1.0",
 			"v2.0.0-beta.1",
 			"v1.2.9",
 		},
-		"2.2.12-rc.12..": []string{
+		"2.2.12-rc.12..": {
 			"2.2.12-rc.12",
 			"2.1.0",
 		},
-		"v1.0.0..": []string{
+		"v1.0.0..": {
 			"2.2.12-rc.12",
 			"2.1.0",
 			"v2.0.0-beta.1",
@@ -65,7 +65,7 @@ func TestTagSelector(t *testing.T) {
 			"",
 		},
 		// <tag> ~ <tag>
-		"v1.0.0..2.2.12-rc.12": []string{
+		"v1.0.0..2.2.12-rc.12": {
 			"2.2.12-rc.12",
 			"2.1.0",
 			"v2.0.0-beta.1",
@@ -73,13 +73,13 @@ func TestTagSelector(t *testing.T) {
 			"v1.0.0",
 			"",
 		},
-		"v1.0.0..v2.0.0-beta.1": []string{
+		"v1.0.0..v2.0.0-beta.1": {
 			"v2.0.0-beta.1",
 			"v1.2.9",
 			"v1.0.0",
 			"",
 		},
-		"v1.2.9..2.1.0": []string{
+		"v1.2.9..2.1.0": {
 			"2.1.0",
 			"v2.0.0-beta.1",
 			"v1.2.9",

testdata/gitlog_jira.txt

@@ -0,0 +1 @@
+@@__CHGLOG__@@HASH:65cf1add9735dcc4810dda3312b0792236c97c4e	65cf1add@@__CHGLOG_DELIMITER__@@AUTHOR:tsuyoshi wada	mail@example.com	1514808000@@__CHGLOG_DELIMITER__@@COMMITTER:tsuyoshi wada	mail@example.com	1514808000@@__CHGLOG_DELIMITER__@@SUBJECT:[JIRA-1111]: Add new feature #123@@__CHGLOG_DELIMITER__@@BODY: This is body message.

testdata/trimmed_body.md

@@ -0,0 +1,48 @@
+{{ if .Versions -}}
+<a name="unreleased"></a>
+## [Unreleased]
+
+{{ if .Unreleased.CommitGroups -}}
+{{ range .Unreleased.CommitGroups -}}
+### {{ .Title }}
+{{ range .Commits -}}
+- {{ if .Scope }}**{{ .Scope }}:** {{ end }}{{ .Subject }}
+{{ if .TrimmedBody -}}
+{{ indent .TrimmedBody 2 }}
+{{ end -}}
+{{ 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 }}
+{{ if .TrimmedBody -}}
+{{ indent .TrimmedBody 2 }}
+{{ end -}}
+{{ 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 -}}

testdata/type_scope_subject.md

@@ -1,22 +1,56 @@
-{{range .Versions}}
-<a name="{{urlquery .Tag.Name}}"></a>
-## {{.Tag.Name}} ({{datetime "2006-01-02" .Tag.Date}})
-{{range .CommitGroups}}
-### {{.Title}}
-{{range .Commits}}
-* {{if ne .Scope ""}}**{{.Scope}}:** {{end}}{{.Subject}}{{end}}
-{{end}}{{if .RevertCommits}}
+{{ 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}}
+{{ range .RevertCommits -}}
+- {{ .Revert.Header }}
+{{ end }}
+{{ end -}}
+
+{{- if .MergeCommits -}}
 ### Pull Requests
-{{range .MergeCommits}}
-* {{.Header}}{{end}}
-{{end}}{{range .NoteGroups}}
-### {{.Title}}
-{{range .Notes}}
-{{.Body}}
-{{end}}
-{{end}}
-{{end}}
+{{ 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 -}}

testdata/with_sprig.md

@@ -0,0 +1,57 @@
+{{ title "my changelog" }}
+{{ 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 | upper }}:** {{ 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 -}}

utils.go

@@ -23,6 +23,7 @@ func dotGet(target interface{}, prop string) (interface{}, bool) {
 			value = reflect.ValueOf(target)
 		}
 
+		//nolint:staticcheck
 		field := value.FieldByName(strings.Title(key))
 		if !field.IsValid() {
 			return nil, false

vendor/github.com/davecgh/go-spew/LICENSE

@@ -1,15 +0,0 @@
-ISC License
-
-Copyright (c) 2012-2016 Dave Collins <dave@davec.name>
-
-Permission to use, copy, modify, and distribute this software for any
-purpose with or without fee is hereby granted, provided that the above
-copyright notice and this permission notice appear in all copies.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

vendor/github.com/davecgh/go-spew/spew/bypass.go

@@ -1,152 +0,0 @@
-// Copyright (c) 2015-2016 Dave Collins <dave@davec.name>
-//
-// Permission to use, copy, modify, and distribute this software for any
-// purpose with or without fee is hereby granted, provided that the above
-// copyright notice and this permission notice appear in all copies.
-//
-// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-// NOTE: Due to the following build constraints, this file will only be compiled
-// when the code is not running on Google App Engine, compiled by GopherJS, and
-// "-tags safe" is not added to the go build command line.  The "disableunsafe"
-// tag is deprecated and thus should not be used.
-// +build !js,!appengine,!safe,!disableunsafe
-
-package spew
-
-import (
-	"reflect"
-	"unsafe"
-)
-
-const (
-	// UnsafeDisabled is a build-time constant which specifies whether or
-	// not access to the unsafe package is available.
-	UnsafeDisabled = false
-
-	// ptrSize is the size of a pointer on the current arch.
-	ptrSize = unsafe.Sizeof((*byte)(nil))
-)
-
-var (
-	// offsetPtr, offsetScalar, and offsetFlag are the offsets for the
-	// internal reflect.Value fields.  These values are valid before golang
-	// commit ecccf07e7f9d which changed the format.  The are also valid
-	// after commit 82f48826c6c7 which changed the format again to mirror
-	// the original format.  Code in the init function updates these offsets
-	// as necessary.
-	offsetPtr    = uintptr(ptrSize)
-	offsetScalar = uintptr(0)
-	offsetFlag   = uintptr(ptrSize * 2)
-
-	// flagKindWidth and flagKindShift indicate various bits that the
-	// reflect package uses internally to track kind information.
-	//
-	// flagRO indicates whether or not the value field of a reflect.Value is
-	// read-only.
-	//
-	// flagIndir indicates whether the value field of a reflect.Value is
-	// the actual data or a pointer to the data.
-	//
-	// These values are valid before golang commit 90a7c3c86944 which
-	// changed their positions.  Code in the init function updates these
-	// flags as necessary.
-	flagKindWidth = uintptr(5)
-	flagKindShift = uintptr(flagKindWidth - 1)
-	flagRO        = uintptr(1 << 0)
-	flagIndir     = uintptr(1 << 1)
-)
-
-func init() {
-	// Older versions of reflect.Value stored small integers directly in the
-	// ptr field (which is named val in the older versions).  Versions
-	// between commits ecccf07e7f9d and 82f48826c6c7 added a new field named
-	// scalar for this purpose which unfortunately came before the flag
-	// field, so the offset of the flag field is different for those
-	// versions.
-	//
-	// This code constructs a new reflect.Value from a known small integer
-	// and checks if the size of the reflect.Value struct indicates it has
-	// the scalar field. When it does, the offsets are updated accordingly.
-	vv := reflect.ValueOf(0xf00)
-	if unsafe.Sizeof(vv) == (ptrSize * 4) {
-		offsetScalar = ptrSize * 2
-		offsetFlag = ptrSize * 3
-	}
-
-	// Commit 90a7c3c86944 changed the flag positions such that the low
-	// order bits are the kind.  This code extracts the kind from the flags
-	// field and ensures it's the correct type.  When it's not, the flag
-	// order has been changed to the newer format, so the flags are updated
-	// accordingly.
-	upf := unsafe.Pointer(uintptr(unsafe.Pointer(&vv)) + offsetFlag)
-	upfv := *(*uintptr)(upf)
-	flagKindMask := uintptr((1<<flagKindWidth - 1) << flagKindShift)
-	if (upfv&flagKindMask)>>flagKindShift != uintptr(reflect.Int) {
-		flagKindShift = 0
-		flagRO = 1 << 5
-		flagIndir = 1 << 6
-
-		// Commit adf9b30e5594 modified the flags to separate the
-		// flagRO flag into two bits which specifies whether or not the
-		// field is embedded.  This causes flagIndir to move over a bit
-		// and means that flagRO is the combination of either of the
-		// original flagRO bit and the new bit.
-		//
-		// This code detects the change by extracting what used to be
-		// the indirect bit to ensure it's set.  When it's not, the flag
-		// order has been changed to the newer format, so the flags are
-		// updated accordingly.
-		if upfv&flagIndir == 0 {
-			flagRO = 3 << 5
-			flagIndir = 1 << 7
-		}
-	}
-}
-
-// unsafeReflectValue converts the passed reflect.Value into a one that bypasses
-// the typical safety restrictions preventing access to unaddressable and
-// unexported data.  It works by digging the raw pointer to the underlying
-// value out of the protected value and generating a new unprotected (unsafe)
-// reflect.Value to it.
-//
-// This allows us to check for implementations of the Stringer and error
-// interfaces to be used for pretty printing ordinarily unaddressable and
-// inaccessible values such as unexported struct fields.
-func unsafeReflectValue(v reflect.Value) (rv reflect.Value) {
-	indirects := 1
-	vt := v.Type()
-	upv := unsafe.Pointer(uintptr(unsafe.Pointer(&v)) + offsetPtr)
-	rvf := *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&v)) + offsetFlag))
-	if rvf&flagIndir != 0 {
-		vt = reflect.PtrTo(v.Type())
-		indirects++
-	} else if offsetScalar != 0 {
-		// The value is in the scalar field when it's not one of the
-		// reference types.
-		switch vt.Kind() {
-		case reflect.Uintptr:
-		case reflect.Chan:
-		case reflect.Func:
-		case reflect.Map:
-		case reflect.Ptr:
-		case reflect.UnsafePointer:
-		default:
-			upv = unsafe.Pointer(uintptr(unsafe.Pointer(&v)) +
-				offsetScalar)
-		}
-	}
-
-	pv := reflect.NewAt(vt, upv)
-	rv = pv
-	for i := 0; i < indirects; i++ {
-		rv = rv.Elem()
-	}
-	return rv
-}

vendor/github.com/davecgh/go-spew/spew/bypasssafe.go

@@ -1,38 +0,0 @@
-// Copyright (c) 2015-2016 Dave Collins <dave@davec.name>
-//
-// Permission to use, copy, modify, and distribute this software for any
-// purpose with or without fee is hereby granted, provided that the above
-// copyright notice and this permission notice appear in all copies.
-//
-// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-// NOTE: Due to the following build constraints, this file will only be compiled
-// when the code is running on Google App Engine, compiled by GopherJS, or
-// "-tags safe" is added to the go build command line.  The "disableunsafe"
-// tag is deprecated and thus should not be used.
-// +build js appengine safe disableunsafe
-
-package spew
-
-import "reflect"
-
-const (
-	// UnsafeDisabled is a build-time constant which specifies whether or
-	// not access to the unsafe package is available.
-	UnsafeDisabled = true
-)
-
-// unsafeReflectValue typically converts the passed reflect.Value into a one
-// that bypasses the typical safety restrictions preventing access to
-// unaddressable and unexported data.  However, doing this relies on access to
-// the unsafe package.  This is a stub version which simply returns the passed
-// reflect.Value when the unsafe package is not available.
-func unsafeReflectValue(v reflect.Value) reflect.Value {
-	return v
-}

vendor/github.com/davecgh/go-spew/spew/common.go

@@ -1,341 +0,0 @@
-/*
- * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-package spew
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"reflect"
-	"sort"
-	"strconv"
-)
-
-// Some constants in the form of bytes to avoid string overhead.  This mirrors
-// the technique used in the fmt package.
-var (
-	panicBytes            = []byte("(PANIC=")
-	plusBytes             = []byte("+")
-	iBytes                = []byte("i")
-	trueBytes             = []byte("true")
-	falseBytes            = []byte("false")
-	interfaceBytes        = []byte("(interface {})")
-	commaNewlineBytes     = []byte(",\n")
-	newlineBytes          = []byte("\n")
-	openBraceBytes        = []byte("{")
-	openBraceNewlineBytes = []byte("{\n")
-	closeBraceBytes       = []byte("}")
-	asteriskBytes         = []byte("*")
-	colonBytes            = []byte(":")
-	colonSpaceBytes       = []byte(": ")
-	openParenBytes        = []byte("(")
-	closeParenBytes       = []byte(")")
-	spaceBytes            = []byte(" ")
-	pointerChainBytes     = []byte("->")
-	nilAngleBytes         = []byte("<nil>")
-	maxNewlineBytes       = []byte("<max depth reached>\n")
-	maxShortBytes         = []byte("<max>")
-	circularBytes         = []byte("<already shown>")
-	circularShortBytes    = []byte("<shown>")
-	invalidAngleBytes     = []byte("<invalid>")
-	openBracketBytes      = []byte("[")
-	closeBracketBytes     = []byte("]")
-	percentBytes          = []byte("%")
-	precisionBytes        = []byte(".")
-	openAngleBytes        = []byte("<")
-	closeAngleBytes       = []byte(">")
-	openMapBytes          = []byte("map[")
-	closeMapBytes         = []byte("]")
-	lenEqualsBytes        = []byte("len=")
-	capEqualsBytes        = []byte("cap=")
-)
-
-// hexDigits is used to map a decimal value to a hex digit.
-var hexDigits = "0123456789abcdef"
-
-// catchPanic handles any panics that might occur during the handleMethods
-// calls.
-func catchPanic(w io.Writer, v reflect.Value) {
-	if err := recover(); err != nil {
-		w.Write(panicBytes)
-		fmt.Fprintf(w, "%v", err)
-		w.Write(closeParenBytes)
-	}
-}
-
-// handleMethods attempts to call the Error and String methods on the underlying
-// type the passed reflect.Value represents and outputes the result to Writer w.
-//
-// It handles panics in any called methods by catching and displaying the error
-// as the formatted value.
-func handleMethods(cs *ConfigState, w io.Writer, v reflect.Value) (handled bool) {
-	// We need an interface to check if the type implements the error or
-	// Stringer interface.  However, the reflect package won't give us an
-	// interface on certain things like unexported struct fields in order
-	// to enforce visibility rules.  We use unsafe, when it's available,
-	// to bypass these restrictions since this package does not mutate the
-	// values.
-	if !v.CanInterface() {
-		if UnsafeDisabled {
-			return false
-		}
-
-		v = unsafeReflectValue(v)
-	}
-
-	// Choose whether or not to do error and Stringer interface lookups against
-	// the base type or a pointer to the base type depending on settings.
-	// Technically calling one of these methods with a pointer receiver can
-	// mutate the value, however, types which choose to satisify an error or
-	// Stringer interface with a pointer receiver should not be mutating their
-	// state inside these interface methods.
-	if !cs.DisablePointerMethods && !UnsafeDisabled && !v.CanAddr() {
-		v = unsafeReflectValue(v)
-	}
-	if v.CanAddr() {
-		v = v.Addr()
-	}
-
-	// Is it an error or Stringer?
-	switch iface := v.Interface().(type) {
-	case error:
-		defer catchPanic(w, v)
-		if cs.ContinueOnMethod {
-			w.Write(openParenBytes)
-			w.Write([]byte(iface.Error()))
-			w.Write(closeParenBytes)
-			w.Write(spaceBytes)
-			return false
-		}
-
-		w.Write([]byte(iface.Error()))
-		return true
-
-	case fmt.Stringer:
-		defer catchPanic(w, v)
-		if cs.ContinueOnMethod {
-			w.Write(openParenBytes)
-			w.Write([]byte(iface.String()))
-			w.Write(closeParenBytes)
-			w.Write(spaceBytes)
-			return false
-		}
-		w.Write([]byte(iface.String()))
-		return true
-	}
-	return false
-}
-
-// printBool outputs a boolean value as true or false to Writer w.
-func printBool(w io.Writer, val bool) {
-	if val {
-		w.Write(trueBytes)
-	} else {
-		w.Write(falseBytes)
-	}
-}
-
-// printInt outputs a signed integer value to Writer w.
-func printInt(w io.Writer, val int64, base int) {
-	w.Write([]byte(strconv.FormatInt(val, base)))
-}
-
-// printUint outputs an unsigned integer value to Writer w.
-func printUint(w io.Writer, val uint64, base int) {
-	w.Write([]byte(strconv.FormatUint(val, base)))
-}
-
-// printFloat outputs a floating point value using the specified precision,
-// which is expected to be 32 or 64bit, to Writer w.
-func printFloat(w io.Writer, val float64, precision int) {
-	w.Write([]byte(strconv.FormatFloat(val, 'g', -1, precision)))
-}
-
-// printComplex outputs a complex value using the specified float precision
-// for the real and imaginary parts to Writer w.
-func printComplex(w io.Writer, c complex128, floatPrecision int) {
-	r := real(c)
-	w.Write(openParenBytes)
-	w.Write([]byte(strconv.FormatFloat(r, 'g', -1, floatPrecision)))
-	i := imag(c)
-	if i >= 0 {
-		w.Write(plusBytes)
-	}
-	w.Write([]byte(strconv.FormatFloat(i, 'g', -1, floatPrecision)))
-	w.Write(iBytes)
-	w.Write(closeParenBytes)
-}
-
-// printHexPtr outputs a uintptr formatted as hexidecimal with a leading '0x'
-// prefix to Writer w.
-func printHexPtr(w io.Writer, p uintptr) {
-	// Null pointer.
-	num := uint64(p)
-	if num == 0 {
-		w.Write(nilAngleBytes)
-		return
-	}
-
-	// Max uint64 is 16 bytes in hex + 2 bytes for '0x' prefix
-	buf := make([]byte, 18)
-
-	// It's simpler to construct the hex string right to left.
-	base := uint64(16)
-	i := len(buf) - 1
-	for num >= base {
-		buf[i] = hexDigits[num%base]
-		num /= base
-		i--
-	}
-	buf[i] = hexDigits[num]
-
-	// Add '0x' prefix.
-	i--
-	buf[i] = 'x'
-	i--
-	buf[i] = '0'
-
-	// Strip unused leading bytes.
-	buf = buf[i:]
-	w.Write(buf)
-}
-
-// valuesSorter implements sort.Interface to allow a slice of reflect.Value
-// elements to be sorted.
-type valuesSorter struct {
-	values  []reflect.Value
-	strings []string // either nil or same len and values
-	cs      *ConfigState
-}
-
-// newValuesSorter initializes a valuesSorter instance, which holds a set of
-// surrogate keys on which the data should be sorted.  It uses flags in
-// ConfigState to decide if and how to populate those surrogate keys.
-func newValuesSorter(values []reflect.Value, cs *ConfigState) sort.Interface {
-	vs := &valuesSorter{values: values, cs: cs}
-	if canSortSimply(vs.values[0].Kind()) {
-		return vs
-	}
-	if !cs.DisableMethods {
-		vs.strings = make([]string, len(values))
-		for i := range vs.values {
-			b := bytes.Buffer{}
-			if !handleMethods(cs, &b, vs.values[i]) {
-				vs.strings = nil
-				break
-			}
-			vs.strings[i] = b.String()
-		}
-	}
-	if vs.strings == nil && cs.SpewKeys {
-		vs.strings = make([]string, len(values))
-		for i := range vs.values {
-			vs.strings[i] = Sprintf("%#v", vs.values[i].Interface())
-		}
-	}
-	return vs
-}
-
-// canSortSimply tests whether a reflect.Kind is a primitive that can be sorted
-// directly, or whether it should be considered for sorting by surrogate keys
-// (if the ConfigState allows it).
-func canSortSimply(kind reflect.Kind) bool {
-	// This switch parallels valueSortLess, except for the default case.
-	switch kind {
-	case reflect.Bool:
-		return true
-	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
-		return true
-	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
-		return true
-	case reflect.Float32, reflect.Float64:
-		return true
-	case reflect.String:
-		return true
-	case reflect.Uintptr:
-		return true
-	case reflect.Array:
-		return true
-	}
-	return false
-}
-
-// Len returns the number of values in the slice.  It is part of the
-// sort.Interface implementation.
-func (s *valuesSorter) Len() int {
-	return len(s.values)
-}
-
-// Swap swaps the values at the passed indices.  It is part of the
-// sort.Interface implementation.
-func (s *valuesSorter) Swap(i, j int) {
-	s.values[i], s.values[j] = s.values[j], s.values[i]
-	if s.strings != nil {
-		s.strings[i], s.strings[j] = s.strings[j], s.strings[i]
-	}
-}
-
-// valueSortLess returns whether the first value should sort before the second
-// value.  It is used by valueSorter.Less as part of the sort.Interface
-// implementation.
-func valueSortLess(a, b reflect.Value) bool {
-	switch a.Kind() {
-	case reflect.Bool:
-		return !a.Bool() && b.Bool()
-	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
-		return a.Int() < b.Int()
-	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
-		return a.Uint() < b.Uint()
-	case reflect.Float32, reflect.Float64:
-		return a.Float() < b.Float()
-	case reflect.String:
-		return a.String() < b.String()
-	case reflect.Uintptr:
-		return a.Uint() < b.Uint()
-	case reflect.Array:
-		// Compare the contents of both arrays.
-		l := a.Len()
-		for i := 0; i < l; i++ {
-			av := a.Index(i)
-			bv := b.Index(i)
-			if av.Interface() == bv.Interface() {
-				continue
-			}
-			return valueSortLess(av, bv)
-		}
-	}
-	return a.String() < b.String()
-}
-
-// Less returns whether the value at index i should sort before the
-// value at index j.  It is part of the sort.Interface implementation.
-func (s *valuesSorter) Less(i, j int) bool {
-	if s.strings == nil {
-		return valueSortLess(s.values[i], s.values[j])
-	}
-	return s.strings[i] < s.strings[j]
-}
-
-// sortValues is a sort function that handles both native types and any type that
-// can be converted to error or Stringer.  Other inputs are sorted according to
-// their Value.String() value to ensure display stability.
-func sortValues(values []reflect.Value, cs *ConfigState) {
-	if len(values) == 0 {
-		return
-	}
-	sort.Sort(newValuesSorter(values, cs))
-}

vendor/github.com/davecgh/go-spew/spew/config.go

@@ -1,306 +0,0 @@
-/*
- * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-package spew
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"os"
-)
-
-// ConfigState houses the configuration options used by spew to format and
-// display values.  There is a global instance, Config, that is used to control
-// all top-level Formatter and Dump functionality.  Each ConfigState instance
-// provides methods equivalent to the top-level functions.
-//
-// The zero value for ConfigState provides no indentation.  You would typically
-// want to set it to a space or a tab.
-//
-// Alternatively, you can use NewDefaultConfig to get a ConfigState instance
-// with default settings.  See the documentation of NewDefaultConfig for default
-// values.
-type ConfigState struct {
-	// Indent specifies the string to use for each indentation level.  The
-	// global config instance that all top-level functions use set this to a
-	// single space by default.  If you would like more indentation, you might
-	// set this to a tab with "\t" or perhaps two spaces with "  ".
-	Indent string
-
-	// MaxDepth controls the maximum number of levels to descend into nested
-	// data structures.  The default, 0, means there is no limit.
-	//
-	// NOTE: Circular data structures are properly detected, so it is not
-	// necessary to set this value unless you specifically want to limit deeply
-	// nested data structures.
-	MaxDepth int
-
-	// DisableMethods specifies whether or not error and Stringer interfaces are
-	// invoked for types that implement them.
-	DisableMethods bool
-
-	// DisablePointerMethods specifies whether or not to check for and invoke
-	// error and Stringer interfaces on types which only accept a pointer
-	// receiver when the current type is not a pointer.
-	//
-	// NOTE: This might be an unsafe action since calling one of these methods
-	// with a pointer receiver could technically mutate the value, however,
-	// in practice, types which choose to satisify an error or Stringer
-	// interface with a pointer receiver should not be mutating their state
-	// inside these interface methods.  As a result, this option relies on
-	// access to the unsafe package, so it will not have any effect when
-	// running in environments without access to the unsafe package such as
-	// Google App Engine or with the "safe" build tag specified.
-	DisablePointerMethods bool
-
-	// DisablePointerAddresses specifies whether to disable the printing of
-	// pointer addresses. This is useful when diffing data structures in tests.
-	DisablePointerAddresses bool
-
-	// DisableCapacities specifies whether to disable the printing of capacities
-	// for arrays, slices, maps and channels. This is useful when diffing
-	// data structures in tests.
-	DisableCapacities bool
-
-	// ContinueOnMethod specifies whether or not recursion should continue once
-	// a custom error or Stringer interface is invoked.  The default, false,
-	// means it will print the results of invoking the custom error or Stringer
-	// interface and return immediately instead of continuing to recurse into
-	// the internals of the data type.
-	//
-	// NOTE: This flag does not have any effect if method invocation is disabled
-	// via the DisableMethods or DisablePointerMethods options.
-	ContinueOnMethod bool
-
-	// SortKeys specifies map keys should be sorted before being printed. Use
-	// this to have a more deterministic, diffable output.  Note that only
-	// native types (bool, int, uint, floats, uintptr and string) and types
-	// that support the error or Stringer interfaces (if methods are
-	// enabled) are supported, with other types sorted according to the
-	// reflect.Value.String() output which guarantees display stability.
-	SortKeys bool
-
-	// SpewKeys specifies that, as a last resort attempt, map keys should
-	// be spewed to strings and sorted by those strings.  This is only
-	// considered if SortKeys is true.
-	SpewKeys bool
-}
-
-// Config is the active configuration of the top-level functions.
-// The configuration can be changed by modifying the contents of spew.Config.
-var Config = ConfigState{Indent: " "}
-
-// Errorf is a wrapper for fmt.Errorf that treats each argument as if it were
-// passed with a Formatter interface returned by c.NewFormatter.  It returns
-// the formatted string as a value that satisfies error.  See NewFormatter
-// for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Errorf(format, c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Errorf(format string, a ...interface{}) (err error) {
-	return fmt.Errorf(format, c.convertArgs(a)...)
-}
-
-// Fprint is a wrapper for fmt.Fprint that treats each argument as if it were
-// passed with a Formatter interface returned by c.NewFormatter.  It returns
-// the number of bytes written and any write error encountered.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Fprint(w, c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Fprint(w io.Writer, a ...interface{}) (n int, err error) {
-	return fmt.Fprint(w, c.convertArgs(a)...)
-}
-
-// Fprintf is a wrapper for fmt.Fprintf that treats each argument as if it were
-// passed with a Formatter interface returned by c.NewFormatter.  It returns
-// the number of bytes written and any write error encountered.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Fprintf(w, format, c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
-	return fmt.Fprintf(w, format, c.convertArgs(a)...)
-}
-
-// Fprintln is a wrapper for fmt.Fprintln that treats each argument as if it
-// passed with a Formatter interface returned by c.NewFormatter.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Fprintln(w, c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Fprintln(w io.Writer, a ...interface{}) (n int, err error) {
-	return fmt.Fprintln(w, c.convertArgs(a)...)
-}
-
-// Print is a wrapper for fmt.Print that treats each argument as if it were
-// passed with a Formatter interface returned by c.NewFormatter.  It returns
-// the number of bytes written and any write error encountered.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Print(c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Print(a ...interface{}) (n int, err error) {
-	return fmt.Print(c.convertArgs(a)...)
-}
-
-// Printf is a wrapper for fmt.Printf that treats each argument as if it were
-// passed with a Formatter interface returned by c.NewFormatter.  It returns
-// the number of bytes written and any write error encountered.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Printf(format, c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Printf(format string, a ...interface{}) (n int, err error) {
-	return fmt.Printf(format, c.convertArgs(a)...)
-}
-
-// Println is a wrapper for fmt.Println that treats each argument as if it were
-// passed with a Formatter interface returned by c.NewFormatter.  It returns
-// the number of bytes written and any write error encountered.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Println(c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Println(a ...interface{}) (n int, err error) {
-	return fmt.Println(c.convertArgs(a)...)
-}
-
-// Sprint is a wrapper for fmt.Sprint that treats each argument as if it were
-// passed with a Formatter interface returned by c.NewFormatter.  It returns
-// the resulting string.  See NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Sprint(c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Sprint(a ...interface{}) string {
-	return fmt.Sprint(c.convertArgs(a)...)
-}
-
-// Sprintf is a wrapper for fmt.Sprintf that treats each argument as if it were
-// passed with a Formatter interface returned by c.NewFormatter.  It returns
-// the resulting string.  See NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Sprintf(format, c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Sprintf(format string, a ...interface{}) string {
-	return fmt.Sprintf(format, c.convertArgs(a)...)
-}
-
-// Sprintln is a wrapper for fmt.Sprintln that treats each argument as if it
-// were passed with a Formatter interface returned by c.NewFormatter.  It
-// returns the resulting string.  See NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Sprintln(c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Sprintln(a ...interface{}) string {
-	return fmt.Sprintln(c.convertArgs(a)...)
-}
-
-/*
-NewFormatter returns a custom formatter that satisfies the fmt.Formatter
-interface.  As a result, it integrates cleanly with standard fmt package
-printing functions.  The formatter is useful for inline printing of smaller data
-types similar to the standard %v format specifier.
-
-The custom formatter only responds to the %v (most compact), %+v (adds pointer
-addresses), %#v (adds types), and %#+v (adds types and pointer addresses) verb
-combinations.  Any other verbs such as %x and %q will be sent to the the
-standard fmt package for formatting.  In addition, the custom formatter ignores
-the width and precision arguments (however they will still work on the format
-specifiers not handled by the custom formatter).
-
-Typically this function shouldn't be called directly.  It is much easier to make
-use of the custom formatter by calling one of the convenience functions such as
-c.Printf, c.Println, or c.Printf.
-*/
-func (c *ConfigState) NewFormatter(v interface{}) fmt.Formatter {
-	return newFormatter(c, v)
-}
-
-// Fdump formats and displays the passed arguments to io.Writer w.  It formats
-// exactly the same as Dump.
-func (c *ConfigState) Fdump(w io.Writer, a ...interface{}) {
-	fdump(c, w, a...)
-}
-
-/*
-Dump displays the passed parameters to standard out with newlines, customizable
-indentation, and additional debug information such as complete types and all
-pointer addresses used to indirect to the final value.  It provides the
-following features over the built-in printing facilities provided by the fmt
-package:
-
-	* Pointers are dereferenced and followed
-	* Circular data structures are detected and handled properly
-	* Custom Stringer/error interfaces are optionally invoked, including
-	  on unexported types
-	* Custom types which only implement the Stringer/error interfaces via
-	  a pointer receiver are optionally invoked when passing non-pointer
-	  variables
-	* Byte arrays and slices are dumped like the hexdump -C command which
-	  includes offsets, byte values in hex, and ASCII output
-
-The configuration options are controlled by modifying the public members
-of c.  See ConfigState for options documentation.
-
-See Fdump if you would prefer dumping to an arbitrary io.Writer or Sdump to
-get the formatted result as a string.
-*/
-func (c *ConfigState) Dump(a ...interface{}) {
-	fdump(c, os.Stdout, a...)
-}
-
-// Sdump returns a string with the passed arguments formatted exactly the same
-// as Dump.
-func (c *ConfigState) Sdump(a ...interface{}) string {
-	var buf bytes.Buffer
-	fdump(c, &buf, a...)
-	return buf.String()
-}
-
-// convertArgs accepts a slice of arguments and returns a slice of the same
-// length with each argument converted to a spew Formatter interface using
-// the ConfigState associated with s.
-func (c *ConfigState) convertArgs(args []interface{}) (formatters []interface{}) {
-	formatters = make([]interface{}, len(args))
-	for index, arg := range args {
-		formatters[index] = newFormatter(c, arg)
-	}
-	return formatters
-}
-
-// NewDefaultConfig returns a ConfigState with the following default settings.
-//
-// 	Indent: " "
-// 	MaxDepth: 0
-// 	DisableMethods: false
-// 	DisablePointerMethods: false
-// 	ContinueOnMethod: false
-// 	SortKeys: false
-func NewDefaultConfig() *ConfigState {
-	return &ConfigState{Indent: " "}
-}

vendor/github.com/davecgh/go-spew/spew/doc.go

@@ -1,211 +0,0 @@
-/*
- * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-/*
-Package spew implements a deep pretty printer for Go data structures to aid in
-debugging.
-
-A quick overview of the additional features spew provides over the built-in
-printing facilities for Go data types are as follows:
-
-	* Pointers are dereferenced and followed
-	* Circular data structures are detected and handled properly
-	* Custom Stringer/error interfaces are optionally invoked, including
-	  on unexported types
-	* Custom types which only implement the Stringer/error interfaces via
-	  a pointer receiver are optionally invoked when passing non-pointer
-	  variables
-	* Byte arrays and slices are dumped like the hexdump -C command which
-	  includes offsets, byte values in hex, and ASCII output (only when using
-	  Dump style)
-
-There are two different approaches spew allows for dumping Go data structures:
-
-	* Dump style which prints with newlines, customizable indentation,
-	  and additional debug information such as types and all pointer addresses
-	  used to indirect to the final value
-	* A custom Formatter interface that integrates cleanly with the standard fmt
-	  package and replaces %v, %+v, %#v, and %#+v to provide inline printing
-	  similar to the default %v while providing the additional functionality
-	  outlined above and passing unsupported format verbs such as %x and %q
-	  along to fmt
-
-Quick Start
-
-This section demonstrates how to quickly get started with spew.  See the
-sections below for further details on formatting and configuration options.
-
-To dump a variable with full newlines, indentation, type, and pointer
-information use Dump, Fdump, or Sdump:
-	spew.Dump(myVar1, myVar2, ...)
-	spew.Fdump(someWriter, myVar1, myVar2, ...)
-	str := spew.Sdump(myVar1, myVar2, ...)
-
-Alternatively, if you would prefer to use format strings with a compacted inline
-printing style, use the convenience wrappers Printf, Fprintf, etc with
-%v (most compact), %+v (adds pointer addresses), %#v (adds types), or
-%#+v (adds types and pointer addresses):
-	spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2)
-	spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
-	spew.Fprintf(someWriter, "myVar1: %v -- myVar2: %+v", myVar1, myVar2)
-	spew.Fprintf(someWriter, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
-
-Configuration Options
-
-Configuration of spew is handled by fields in the ConfigState type.  For
-convenience, all of the top-level functions use a global state available
-via the spew.Config global.
-
-It is also possible to create a ConfigState instance that provides methods
-equivalent to the top-level functions.  This allows concurrent configuration
-options.  See the ConfigState documentation for more details.
-
-The following configuration options are available:
-	* Indent
-		String to use for each indentation level for Dump functions.
-		It is a single space by default.  A popular alternative is "\t".
-
-	* MaxDepth
-		Maximum number of levels to descend into nested data structures.
-		There is no limit by default.
-
-	* DisableMethods
-		Disables invocation of error and Stringer interface methods.
-		Method invocation is enabled by default.
-
-	* DisablePointerMethods
-		Disables invocation of error and Stringer interface methods on types
-		which only accept pointer receivers from non-pointer variables.
-		Pointer method invocation is enabled by default.
-
-	* DisablePointerAddresses
-		DisablePointerAddresses specifies whether to disable the printing of
-		pointer addresses. This is useful when diffing data structures in tests.
-
-	* DisableCapacities
-		DisableCapacities specifies whether to disable the printing of
-		capacities for arrays, slices, maps and channels. This is useful when
-		diffing data structures in tests.
-
-	* ContinueOnMethod
-		Enables recursion into types after invoking error and Stringer interface
-		methods. Recursion after method invocation is disabled by default.
-
-	* SortKeys
-		Specifies map keys should be sorted before being printed. Use
-		this to have a more deterministic, diffable output.  Note that
-		only native types (bool, int, uint, floats, uintptr and string)
-		and types which implement error or Stringer interfaces are
-		supported with other types sorted according to the
-		reflect.Value.String() output which guarantees display
-		stability.  Natural map order is used by default.
-
-	* SpewKeys
-		Specifies that, as a last resort attempt, map keys should be
-		spewed to strings and sorted by those strings.  This is only
-		considered if SortKeys is true.
-
-Dump Usage
-
-Simply call spew.Dump with a list of variables you want to dump:
-
-	spew.Dump(myVar1, myVar2, ...)
-
-You may also call spew.Fdump if you would prefer to output to an arbitrary
-io.Writer.  For example, to dump to standard error:
-
-	spew.Fdump(os.Stderr, myVar1, myVar2, ...)
-
-A third option is to call spew.Sdump to get the formatted output as a string:
-
-	str := spew.Sdump(myVar1, myVar2, ...)
-
-Sample Dump Output
-
-See the Dump example for details on the setup of the types and variables being
-shown here.
-
-	(main.Foo) {
-	 unexportedField: (*main.Bar)(0xf84002e210)({
-	  flag: (main.Flag) flagTwo,
-	  data: (uintptr) <nil>
-	 }),
-	 ExportedField: (map[interface {}]interface {}) (len=1) {
-	  (string) (len=3) "one": (bool) true
-	 }
-	}
-
-Byte (and uint8) arrays and slices are displayed uniquely like the hexdump -C
-command as shown.
-	([]uint8) (len=32 cap=32) {
-	 00000000  11 12 13 14 15 16 17 18  19 1a 1b 1c 1d 1e 1f 20  |............... |
-	 00000010  21 22 23 24 25 26 27 28  29 2a 2b 2c 2d 2e 2f 30  |!"#$%&'()*+,-./0|
-	 00000020  31 32                                             |12|
-	}
-
-Custom Formatter
-
-Spew provides a custom formatter that implements the fmt.Formatter interface
-so that it integrates cleanly with standard fmt package printing functions. The
-formatter is useful for inline printing of smaller data types similar to the
-standard %v format specifier.
-
-The custom formatter only responds to the %v (most compact), %+v (adds pointer
-addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb
-combinations.  Any other verbs such as %x and %q will be sent to the the
-standard fmt package for formatting.  In addition, the custom formatter ignores
-the width and precision arguments (however they will still work on the format
-specifiers not handled by the custom formatter).
-
-Custom Formatter Usage
-
-The simplest way to make use of the spew custom formatter is to call one of the
-convenience functions such as spew.Printf, spew.Println, or spew.Printf.  The
-functions have syntax you are most likely already familiar with:
-
-	spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2)
-	spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
-	spew.Println(myVar, myVar2)
-	spew.Fprintf(os.Stderr, "myVar1: %v -- myVar2: %+v", myVar1, myVar2)
-	spew.Fprintf(os.Stderr, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
-
-See the Index for the full list convenience functions.
-
-Sample Formatter Output
-
-Double pointer to a uint8:
-	  %v: <**>5
-	 %+v: <**>(0xf8400420d0->0xf8400420c8)5
-	 %#v: (**uint8)5
-	%#+v: (**uint8)(0xf8400420d0->0xf8400420c8)5
-
-Pointer to circular struct with a uint8 field and a pointer to itself:
-	  %v: <*>{1 <*><shown>}
-	 %+v: <*>(0xf84003e260){ui8:1 c:<*>(0xf84003e260)<shown>}
-	 %#v: (*main.circular){ui8:(uint8)1 c:(*main.circular)<shown>}
-	%#+v: (*main.circular)(0xf84003e260){ui8:(uint8)1 c:(*main.circular)(0xf84003e260)<shown>}
-
-See the Printf example for details on the setup of variables being shown
-here.
-
-Errors
-
-Since it is possible for custom Stringer/error interfaces to panic, spew
-detects them and handles them internally by printing the panic information
-inline with the output.  Since spew is intended to provide deep pretty printing
-capabilities on structures, it intentionally does not return any errors.
-*/
-package spew

vendor/github.com/davecgh/go-spew/spew/dump.go

@@ -1,509 +0,0 @@
-/*
- * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-package spew
-
-import (
-	"bytes"
-	"encoding/hex"
-	"fmt"
-	"io"
-	"os"
-	"reflect"
-	"regexp"
-	"strconv"
-	"strings"
-)
-
-var (
-	// uint8Type is a reflect.Type representing a uint8.  It is used to
-	// convert cgo types to uint8 slices for hexdumping.
-	uint8Type = reflect.TypeOf(uint8(0))
-
-	// cCharRE is a regular expression that matches a cgo char.
-	// It is used to detect character arrays to hexdump them.
-	cCharRE = regexp.MustCompile("^.*\\._Ctype_char$")
-
-	// cUnsignedCharRE is a regular expression that matches a cgo unsigned
-	// char.  It is used to detect unsigned character arrays to hexdump
-	// them.
-	cUnsignedCharRE = regexp.MustCompile("^.*\\._Ctype_unsignedchar$")
-
-	// cUint8tCharRE is a regular expression that matches a cgo uint8_t.
-	// It is used to detect uint8_t arrays to hexdump them.
-	cUint8tCharRE = regexp.MustCompile("^.*\\._Ctype_uint8_t$")
-)
-
-// dumpState contains information about the state of a dump operation.
-type dumpState struct {
-	w                io.Writer
-	depth            int
-	pointers         map[uintptr]int
-	ignoreNextType   bool
-	ignoreNextIndent bool
-	cs               *ConfigState
-}
-
-// indent performs indentation according to the depth level and cs.Indent
-// option.
-func (d *dumpState) indent() {
-	if d.ignoreNextIndent {
-		d.ignoreNextIndent = false
-		return
-	}
-	d.w.Write(bytes.Repeat([]byte(d.cs.Indent), d.depth))
-}
-
-// unpackValue returns values inside of non-nil interfaces when possible.
-// This is useful for data types like structs, arrays, slices, and maps which
-// can contain varying types packed inside an interface.
-func (d *dumpState) unpackValue(v reflect.Value) reflect.Value {
-	if v.Kind() == reflect.Interface && !v.IsNil() {
-		v = v.Elem()
-	}
-	return v
-}
-
-// dumpPtr handles formatting of pointers by indirecting them as necessary.
-func (d *dumpState) dumpPtr(v reflect.Value) {
-	// Remove pointers at or below the current depth from map used to detect
-	// circular refs.
-	for k, depth := range d.pointers {
-		if depth >= d.depth {
-			delete(d.pointers, k)
-		}
-	}
-
-	// Keep list of all dereferenced pointers to show later.
-	pointerChain := make([]uintptr, 0)
-
-	// Figure out how many levels of indirection there are by dereferencing
-	// pointers and unpacking interfaces down the chain while detecting circular
-	// references.
-	nilFound := false
-	cycleFound := false
-	indirects := 0
-	ve := v
-	for ve.Kind() == reflect.Ptr {
-		if ve.IsNil() {
-			nilFound = true
-			break
-		}
-		indirects++
-		addr := ve.Pointer()
-		pointerChain = append(pointerChain, addr)
-		if pd, ok := d.pointers[addr]; ok && pd < d.depth {
-			cycleFound = true
-			indirects--
-			break
-		}
-		d.pointers[addr] = d.depth
-
-		ve = ve.Elem()
-		if ve.Kind() == reflect.Interface {
-			if ve.IsNil() {
-				nilFound = true
-				break
-			}
-			ve = ve.Elem()
-		}
-	}
-
-	// Display type information.
-	d.w.Write(openParenBytes)
-	d.w.Write(bytes.Repeat(asteriskBytes, indirects))
-	d.w.Write([]byte(ve.Type().String()))
-	d.w.Write(closeParenBytes)
-
-	// Display pointer information.
-	if !d.cs.DisablePointerAddresses && len(pointerChain) > 0 {
-		d.w.Write(openParenBytes)
-		for i, addr := range pointerChain {
-			if i > 0 {
-				d.w.Write(pointerChainBytes)
-			}
-			printHexPtr(d.w, addr)
-		}
-		d.w.Write(closeParenBytes)
-	}
-
-	// Display dereferenced value.
-	d.w.Write(openParenBytes)
-	switch {
-	case nilFound == true:
-		d.w.Write(nilAngleBytes)
-
-	case cycleFound == true:
-		d.w.Write(circularBytes)
-
-	default:
-		d.ignoreNextType = true
-		d.dump(ve)
-	}
-	d.w.Write(closeParenBytes)
-}
-
-// dumpSlice handles formatting of arrays and slices.  Byte (uint8 under
-// reflection) arrays and slices are dumped in hexdump -C fashion.
-func (d *dumpState) dumpSlice(v reflect.Value) {
-	// Determine whether this type should be hex dumped or not.  Also,
-	// for types which should be hexdumped, try to use the underlying data
-	// first, then fall back to trying to convert them to a uint8 slice.
-	var buf []uint8
-	doConvert := false
-	doHexDump := false
-	numEntries := v.Len()
-	if numEntries > 0 {
-		vt := v.Index(0).Type()
-		vts := vt.String()
-		switch {
-		// C types that need to be converted.
-		case cCharRE.MatchString(vts):
-			fallthrough
-		case cUnsignedCharRE.MatchString(vts):
-			fallthrough
-		case cUint8tCharRE.MatchString(vts):
-			doConvert = true
-
-		// Try to use existing uint8 slices and fall back to converting
-		// and copying if that fails.
-		case vt.Kind() == reflect.Uint8:
-			// We need an addressable interface to convert the type
-			// to a byte slice.  However, the reflect package won't
-			// give us an interface on certain things like
-			// unexported struct fields in order to enforce
-			// visibility rules.  We use unsafe, when available, to
-			// bypass these restrictions since this package does not
-			// mutate the values.
-			vs := v
-			if !vs.CanInterface() || !vs.CanAddr() {
-				vs = unsafeReflectValue(vs)
-			}
-			if !UnsafeDisabled {
-				vs = vs.Slice(0, numEntries)
-
-				// Use the existing uint8 slice if it can be
-				// type asserted.
-				iface := vs.Interface()
-				if slice, ok := iface.([]uint8); ok {
-					buf = slice
-					doHexDump = true
-					break
-				}
-			}
-
-			// The underlying data needs to be converted if it can't
-			// be type asserted to a uint8 slice.
-			doConvert = true
-		}
-
-		// Copy and convert the underlying type if needed.
-		if doConvert && vt.ConvertibleTo(uint8Type) {
-			// Convert and copy each element into a uint8 byte
-			// slice.
-			buf = make([]uint8, numEntries)
-			for i := 0; i < numEntries; i++ {
-				vv := v.Index(i)
-				buf[i] = uint8(vv.Convert(uint8Type).Uint())
-			}
-			doHexDump = true
-		}
-	}
-
-	// Hexdump the entire slice as needed.
-	if doHexDump {
-		indent := strings.Repeat(d.cs.Indent, d.depth)
-		str := indent + hex.Dump(buf)
-		str = strings.Replace(str, "\n", "\n"+indent, -1)
-		str = strings.TrimRight(str, d.cs.Indent)
-		d.w.Write([]byte(str))
-		return
-	}
-
-	// Recursively call dump for each item.
-	for i := 0; i < numEntries; i++ {
-		d.dump(d.unpackValue(v.Index(i)))
-		if i < (numEntries - 1) {
-			d.w.Write(commaNewlineBytes)
-		} else {
-			d.w.Write(newlineBytes)
-		}
-	}
-}
-
-// dump is the main workhorse for dumping a value.  It uses the passed reflect
-// value to figure out what kind of object we are dealing with and formats it
-// appropriately.  It is a recursive function, however circular data structures
-// are detected and handled properly.
-func (d *dumpState) dump(v reflect.Value) {
-	// Handle invalid reflect values immediately.
-	kind := v.Kind()
-	if kind == reflect.Invalid {
-		d.w.Write(invalidAngleBytes)
-		return
-	}
-
-	// Handle pointers specially.
-	if kind == reflect.Ptr {
-		d.indent()
-		d.dumpPtr(v)
-		return
-	}
-
-	// Print type information unless already handled elsewhere.
-	if !d.ignoreNextType {
-		d.indent()
-		d.w.Write(openParenBytes)
-		d.w.Write([]byte(v.Type().String()))
-		d.w.Write(closeParenBytes)
-		d.w.Write(spaceBytes)
-	}
-	d.ignoreNextType = false
-
-	// Display length and capacity if the built-in len and cap functions
-	// work with the value's kind and the len/cap itself is non-zero.
-	valueLen, valueCap := 0, 0
-	switch v.Kind() {
-	case reflect.Array, reflect.Slice, reflect.Chan:
-		valueLen, valueCap = v.Len(), v.Cap()
-	case reflect.Map, reflect.String:
-		valueLen = v.Len()
-	}
-	if valueLen != 0 || !d.cs.DisableCapacities && valueCap != 0 {
-		d.w.Write(openParenBytes)
-		if valueLen != 0 {
-			d.w.Write(lenEqualsBytes)
-			printInt(d.w, int64(valueLen), 10)
-		}
-		if !d.cs.DisableCapacities && valueCap != 0 {
-			if valueLen != 0 {
-				d.w.Write(spaceBytes)
-			}
-			d.w.Write(capEqualsBytes)
-			printInt(d.w, int64(valueCap), 10)
-		}
-		d.w.Write(closeParenBytes)
-		d.w.Write(spaceBytes)
-	}
-
-	// Call Stringer/error interfaces if they exist and the handle methods flag
-	// is enabled
-	if !d.cs.DisableMethods {
-		if (kind != reflect.Invalid) && (kind != reflect.Interface) {
-			if handled := handleMethods(d.cs, d.w, v); handled {
-				return
-			}
-		}
-	}
-
-	switch kind {
-	case reflect.Invalid:
-		// Do nothing.  We should never get here since invalid has already
-		// been handled above.
-
-	case reflect.Bool:
-		printBool(d.w, v.Bool())
-
-	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
-		printInt(d.w, v.Int(), 10)
-
-	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
-		printUint(d.w, v.Uint(), 10)
-
-	case reflect.Float32:
-		printFloat(d.w, v.Float(), 32)
-
-	case reflect.Float64:
-		printFloat(d.w, v.Float(), 64)
-
-	case reflect.Complex64:
-		printComplex(d.w, v.Complex(), 32)
-
-	case reflect.Complex128:
-		printComplex(d.w, v.Complex(), 64)
-
-	case reflect.Slice:
-		if v.IsNil() {
-			d.w.Write(nilAngleBytes)
-			break
-		}
-		fallthrough
-
-	case reflect.Array:
-		d.w.Write(openBraceNewlineBytes)
-		d.depth++
-		if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) {
-			d.indent()
-			d.w.Write(maxNewlineBytes)
-		} else {
-			d.dumpSlice(v)
-		}
-		d.depth--
-		d.indent()
-		d.w.Write(closeBraceBytes)
-
-	case reflect.String:
-		d.w.Write([]byte(strconv.Quote(v.String())))
-
-	case reflect.Interface:
-		// The only time we should get here is for nil interfaces due to
-		// unpackValue calls.
-		if v.IsNil() {
-			d.w.Write(nilAngleBytes)
-		}
-
-	case reflect.Ptr:
-		// Do nothing.  We should never get here since pointers have already
-		// been handled above.
-
-	case reflect.Map:
-		// nil maps should be indicated as different than empty maps
-		if v.IsNil() {
-			d.w.Write(nilAngleBytes)
-			break
-		}
-
-		d.w.Write(openBraceNewlineBytes)
-		d.depth++
-		if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) {
-			d.indent()
-			d.w.Write(maxNewlineBytes)
-		} else {
-			numEntries := v.Len()
-			keys := v.MapKeys()
-			if d.cs.SortKeys {
-				sortValues(keys, d.cs)
-			}
-			for i, key := range keys {
-				d.dump(d.unpackValue(key))
-				d.w.Write(colonSpaceBytes)
-				d.ignoreNextIndent = true
-				d.dump(d.unpackValue(v.MapIndex(key)))
-				if i < (numEntries - 1) {
-					d.w.Write(commaNewlineBytes)
-				} else {
-					d.w.Write(newlineBytes)
-				}
-			}
-		}
-		d.depth--
-		d.indent()
-		d.w.Write(closeBraceBytes)
-
-	case reflect.Struct:
-		d.w.Write(openBraceNewlineBytes)
-		d.depth++
-		if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) {
-			d.indent()
-			d.w.Write(maxNewlineBytes)
-		} else {
-			vt := v.Type()
-			numFields := v.NumField()
-			for i := 0; i < numFields; i++ {
-				d.indent()
-				vtf := vt.Field(i)
-				d.w.Write([]byte(vtf.Name))
-				d.w.Write(colonSpaceBytes)
-				d.ignoreNextIndent = true
-				d.dump(d.unpackValue(v.Field(i)))
-				if i < (numFields - 1) {
-					d.w.Write(commaNewlineBytes)
-				} else {
-					d.w.Write(newlineBytes)
-				}
-			}
-		}
-		d.depth--
-		d.indent()
-		d.w.Write(closeBraceBytes)
-
-	case reflect.Uintptr:
-		printHexPtr(d.w, uintptr(v.Uint()))
-
-	case reflect.UnsafePointer, reflect.Chan, reflect.Func:
-		printHexPtr(d.w, v.Pointer())
-
-	// There were not any other types at the time this code was written, but
-	// fall back to letting the default fmt package handle it in case any new
-	// types are added.
-	default:
-		if v.CanInterface() {
-			fmt.Fprintf(d.w, "%v", v.Interface())
-		} else {
-			fmt.Fprintf(d.w, "%v", v.String())
-		}
-	}
-}
-
-// fdump is a helper function to consolidate the logic from the various public
-// methods which take varying writers and config states.
-func fdump(cs *ConfigState, w io.Writer, a ...interface{}) {
-	for _, arg := range a {
-		if arg == nil {
-			w.Write(interfaceBytes)
-			w.Write(spaceBytes)
-			w.Write(nilAngleBytes)
-			w.Write(newlineBytes)
-			continue
-		}
-
-		d := dumpState{w: w, cs: cs}
-		d.pointers = make(map[uintptr]int)
-		d.dump(reflect.ValueOf(arg))
-		d.w.Write(newlineBytes)
-	}
-}
-
-// Fdump formats and displays the passed arguments to io.Writer w.  It formats
-// exactly the same as Dump.
-func Fdump(w io.Writer, a ...interface{}) {
-	fdump(&Config, w, a...)
-}
-
-// Sdump returns a string with the passed arguments formatted exactly the same
-// as Dump.
-func Sdump(a ...interface{}) string {
-	var buf bytes.Buffer
-	fdump(&Config, &buf, a...)
-	return buf.String()
-}
-
-/*
-Dump displays the passed parameters to standard out with newlines, customizable
-indentation, and additional debug information such as complete types and all
-pointer addresses used to indirect to the final value.  It provides the
-following features over the built-in printing facilities provided by the fmt
-package:
-
-	* Pointers are dereferenced and followed
-	* Circular data structures are detected and handled properly
-	* Custom Stringer/error interfaces are optionally invoked, including
-	  on unexported types
-	* Custom types which only implement the Stringer/error interfaces via
-	  a pointer receiver are optionally invoked when passing non-pointer
-	  variables
-	* Byte arrays and slices are dumped like the hexdump -C command which
-	  includes offsets, byte values in hex, and ASCII output
-
-The configuration options are controlled by an exported package global,
-spew.Config.  See ConfigState for options documentation.
-
-See Fdump if you would prefer dumping to an arbitrary io.Writer or Sdump to
-get the formatted result as a string.
-*/
-func Dump(a ...interface{}) {
-	fdump(&Config, os.Stdout, a...)
-}

vendor/github.com/davecgh/go-spew/spew/format.go

@@ -1,419 +0,0 @@
-/*
- * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-package spew
-
-import (
-	"bytes"
-	"fmt"
-	"reflect"
-	"strconv"
-	"strings"
-)
-
-// supportedFlags is a list of all the character flags supported by fmt package.
-const supportedFlags = "0-+# "
-
-// formatState implements the fmt.Formatter interface and contains information
-// about the state of a formatting operation.  The NewFormatter function can
-// be used to get a new Formatter which can be used directly as arguments
-// in standard fmt package printing calls.
-type formatState struct {
-	value          interface{}
-	fs             fmt.State
-	depth          int
-	pointers       map[uintptr]int
-	ignoreNextType bool
-	cs             *ConfigState
-}
-
-// buildDefaultFormat recreates the original format string without precision
-// and width information to pass in to fmt.Sprintf in the case of an
-// unrecognized type.  Unless new types are added to the language, this
-// function won't ever be called.
-func (f *formatState) buildDefaultFormat() (format string) {
-	buf := bytes.NewBuffer(percentBytes)
-
-	for _, flag := range supportedFlags {
-		if f.fs.Flag(int(flag)) {
-			buf.WriteRune(flag)
-		}
-	}
-
-	buf.WriteRune('v')
-
-	format = buf.String()
-	return format
-}
-
-// constructOrigFormat recreates the original format string including precision
-// and width information to pass along to the standard fmt package.  This allows
-// automatic deferral of all format strings this package doesn't support.
-func (f *formatState) constructOrigFormat(verb rune) (format string) {
-	buf := bytes.NewBuffer(percentBytes)
-
-	for _, flag := range supportedFlags {
-		if f.fs.Flag(int(flag)) {
-			buf.WriteRune(flag)
-		}
-	}
-
-	if width, ok := f.fs.Width(); ok {
-		buf.WriteString(strconv.Itoa(width))
-	}
-
-	if precision, ok := f.fs.Precision(); ok {
-		buf.Write(precisionBytes)
-		buf.WriteString(strconv.Itoa(precision))
-	}
-
-	buf.WriteRune(verb)
-
-	format = buf.String()
-	return format
-}
-
-// unpackValue returns values inside of non-nil interfaces when possible and
-// ensures that types for values which have been unpacked from an interface
-// are displayed when the show types flag is also set.
-// This is useful for data types like structs, arrays, slices, and maps which
-// can contain varying types packed inside an interface.
-func (f *formatState) unpackValue(v reflect.Value) reflect.Value {
-	if v.Kind() == reflect.Interface {
-		f.ignoreNextType = false
-		if !v.IsNil() {
-			v = v.Elem()
-		}
-	}
-	return v
-}
-
-// formatPtr handles formatting of pointers by indirecting them as necessary.
-func (f *formatState) formatPtr(v reflect.Value) {
-	// Display nil if top level pointer is nil.
-	showTypes := f.fs.Flag('#')
-	if v.IsNil() && (!showTypes || f.ignoreNextType) {
-		f.fs.Write(nilAngleBytes)
-		return
-	}
-
-	// Remove pointers at or below the current depth from map used to detect
-	// circular refs.
-	for k, depth := range f.pointers {
-		if depth >= f.depth {
-			delete(f.pointers, k)
-		}
-	}
-
-	// Keep list of all dereferenced pointers to possibly show later.
-	pointerChain := make([]uintptr, 0)
-
-	// Figure out how many levels of indirection there are by derferencing
-	// pointers and unpacking interfaces down the chain while detecting circular
-	// references.
-	nilFound := false
-	cycleFound := false
-	indirects := 0
-	ve := v
-	for ve.Kind() == reflect.Ptr {
-		if ve.IsNil() {
-			nilFound = true
-			break
-		}
-		indirects++
-		addr := ve.Pointer()
-		pointerChain = append(pointerChain, addr)
-		if pd, ok := f.pointers[addr]; ok && pd < f.depth {
-			cycleFound = true
-			indirects--
-			break
-		}
-		f.pointers[addr] = f.depth
-
-		ve = ve.Elem()
-		if ve.Kind() == reflect.Interface {
-			if ve.IsNil() {
-				nilFound = true
-				break
-			}
-			ve = ve.Elem()
-		}
-	}
-
-	// Display type or indirection level depending on flags.
-	if showTypes && !f.ignoreNextType {
-		f.fs.Write(openParenBytes)
-		f.fs.Write(bytes.Repeat(asteriskBytes, indirects))
-		f.fs.Write([]byte(ve.Type().String()))
-		f.fs.Write(closeParenBytes)
-	} else {
-		if nilFound || cycleFound {
-			indirects += strings.Count(ve.Type().String(), "*")
-		}
-		f.fs.Write(openAngleBytes)
-		f.fs.Write([]byte(strings.Repeat("*", indirects)))
-		f.fs.Write(closeAngleBytes)
-	}
-
-	// Display pointer information depending on flags.
-	if f.fs.Flag('+') && (len(pointerChain) > 0) {
-		f.fs.Write(openParenBytes)
-		for i, addr := range pointerChain {
-			if i > 0 {
-				f.fs.Write(pointerChainBytes)
-			}
-			printHexPtr(f.fs, addr)
-		}
-		f.fs.Write(closeParenBytes)
-	}
-
-	// Display dereferenced value.
-	switch {
-	case nilFound == true:
-		f.fs.Write(nilAngleBytes)
-
-	case cycleFound == true:
-		f.fs.Write(circularShortBytes)
-
-	default:
-		f.ignoreNextType = true
-		f.format(ve)
-	}
-}
-
-// format is the main workhorse for providing the Formatter interface.  It
-// uses the passed reflect value to figure out what kind of object we are
-// dealing with and formats it appropriately.  It is a recursive function,
-// however circular data structures are detected and handled properly.
-func (f *formatState) format(v reflect.Value) {
-	// Handle invalid reflect values immediately.
-	kind := v.Kind()
-	if kind == reflect.Invalid {
-		f.fs.Write(invalidAngleBytes)
-		return
-	}
-
-	// Handle pointers specially.
-	if kind == reflect.Ptr {
-		f.formatPtr(v)
-		return
-	}
-
-	// Print type information unless already handled elsewhere.
-	if !f.ignoreNextType && f.fs.Flag('#') {
-		f.fs.Write(openParenBytes)
-		f.fs.Write([]byte(v.Type().String()))
-		f.fs.Write(closeParenBytes)
-	}
-	f.ignoreNextType = false
-
-	// Call Stringer/error interfaces if they exist and the handle methods
-	// flag is enabled.
-	if !f.cs.DisableMethods {
-		if (kind != reflect.Invalid) && (kind != reflect.Interface) {
-			if handled := handleMethods(f.cs, f.fs, v); handled {
-				return
-			}
-		}
-	}
-
-	switch kind {
-	case reflect.Invalid:
-		// Do nothing.  We should never get here since invalid has already
-		// been handled above.
-
-	case reflect.Bool:
-		printBool(f.fs, v.Bool())
-
-	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
-		printInt(f.fs, v.Int(), 10)
-
-	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
-		printUint(f.fs, v.Uint(), 10)
-
-	case reflect.Float32:
-		printFloat(f.fs, v.Float(), 32)
-
-	case reflect.Float64:
-		printFloat(f.fs, v.Float(), 64)
-
-	case reflect.Complex64:
-		printComplex(f.fs, v.Complex(), 32)
-
-	case reflect.Complex128:
-		printComplex(f.fs, v.Complex(), 64)
-
-	case reflect.Slice:
-		if v.IsNil() {
-			f.fs.Write(nilAngleBytes)
-			break
-		}
-		fallthrough
-
-	case reflect.Array:
-		f.fs.Write(openBracketBytes)
-		f.depth++
-		if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {
-			f.fs.Write(maxShortBytes)
-		} else {
-			numEntries := v.Len()
-			for i := 0; i < numEntries; i++ {
-				if i > 0 {
-					f.fs.Write(spaceBytes)
-				}
-				f.ignoreNextType = true
-				f.format(f.unpackValue(v.Index(i)))
-			}
-		}
-		f.depth--
-		f.fs.Write(closeBracketBytes)
-
-	case reflect.String:
-		f.fs.Write([]byte(v.String()))
-
-	case reflect.Interface:
-		// The only time we should get here is for nil interfaces due to
-		// unpackValue calls.
-		if v.IsNil() {
-			f.fs.Write(nilAngleBytes)
-		}
-
-	case reflect.Ptr:
-		// Do nothing.  We should never get here since pointers have already
-		// been handled above.
-
-	case reflect.Map:
-		// nil maps should be indicated as different than empty maps
-		if v.IsNil() {
-			f.fs.Write(nilAngleBytes)
-			break
-		}
-
-		f.fs.Write(openMapBytes)
-		f.depth++
-		if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {
-			f.fs.Write(maxShortBytes)
-		} else {
-			keys := v.MapKeys()
-			if f.cs.SortKeys {
-				sortValues(keys, f.cs)
-			}
-			for i, key := range keys {
-				if i > 0 {
-					f.fs.Write(spaceBytes)
-				}
-				f.ignoreNextType = true
-				f.format(f.unpackValue(key))
-				f.fs.Write(colonBytes)
-				f.ignoreNextType = true
-				f.format(f.unpackValue(v.MapIndex(key)))
-			}
-		}
-		f.depth--
-		f.fs.Write(closeMapBytes)
-
-	case reflect.Struct:
-		numFields := v.NumField()
-		f.fs.Write(openBraceBytes)
-		f.depth++
-		if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {
-			f.fs.Write(maxShortBytes)
-		} else {
-			vt := v.Type()
-			for i := 0; i < numFields; i++ {
-				if i > 0 {
-					f.fs.Write(spaceBytes)
-				}
-				vtf := vt.Field(i)
-				if f.fs.Flag('+') || f.fs.Flag('#') {
-					f.fs.Write([]byte(vtf.Name))
-					f.fs.Write(colonBytes)
-				}
-				f.format(f.unpackValue(v.Field(i)))
-			}
-		}
-		f.depth--
-		f.fs.Write(closeBraceBytes)
-
-	case reflect.Uintptr:
-		printHexPtr(f.fs, uintptr(v.Uint()))
-
-	case reflect.UnsafePointer, reflect.Chan, reflect.Func:
-		printHexPtr(f.fs, v.Pointer())
-
-	// There were not any other types at the time this code was written, but
-	// fall back to letting the default fmt package handle it if any get added.
-	default:
-		format := f.buildDefaultFormat()
-		if v.CanInterface() {
-			fmt.Fprintf(f.fs, format, v.Interface())
-		} else {
-			fmt.Fprintf(f.fs, format, v.String())
-		}
-	}
-}
-
-// Format satisfies the fmt.Formatter interface. See NewFormatter for usage
-// details.
-func (f *formatState) Format(fs fmt.State, verb rune) {
-	f.fs = fs
-
-	// Use standard formatting for verbs that are not v.
-	if verb != 'v' {
-		format := f.constructOrigFormat(verb)
-		fmt.Fprintf(fs, format, f.value)
-		return
-	}
-
-	if f.value == nil {
-		if fs.Flag('#') {
-			fs.Write(interfaceBytes)
-		}
-		fs.Write(nilAngleBytes)
-		return
-	}
-
-	f.format(reflect.ValueOf(f.value))
-}
-
-// newFormatter is a helper function to consolidate the logic from the various
-// public methods which take varying config states.
-func newFormatter(cs *ConfigState, v interface{}) fmt.Formatter {
-	fs := &formatState{value: v, cs: cs}
-	fs.pointers = make(map[uintptr]int)
-	return fs
-}
-
-/*
-NewFormatter returns a custom formatter that satisfies the fmt.Formatter
-interface.  As a result, it integrates cleanly with standard fmt package
-printing functions.  The formatter is useful for inline printing of smaller data
-types similar to the standard %v format specifier.
-
-The custom formatter only responds to the %v (most compact), %+v (adds pointer
-addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb
-combinations.  Any other verbs such as %x and %q will be sent to the the
-standard fmt package for formatting.  In addition, the custom formatter ignores
-the width and precision arguments (however they will still work on the format
-specifiers not handled by the custom formatter).
-
-Typically this function shouldn't be called directly.  It is much easier to make
-use of the custom formatter by calling one of the convenience functions such as
-Printf, Println, or Fprintf.
-*/
-func NewFormatter(v interface{}) fmt.Formatter {
-	return newFormatter(&Config, v)
-}

vendor/github.com/davecgh/go-spew/spew/spew.go

@@ -1,148 +0,0 @@
-/*
- * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-package spew
-
-import (
-	"fmt"
-	"io"
-)
-
-// Errorf is a wrapper for fmt.Errorf that treats each argument as if it were
-// passed with a default Formatter interface returned by NewFormatter.  It
-// returns the formatted string as a value that satisfies error.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Errorf(format, spew.NewFormatter(a), spew.NewFormatter(b))
-func Errorf(format string, a ...interface{}) (err error) {
-	return fmt.Errorf(format, convertArgs(a)...)
-}
-
-// Fprint is a wrapper for fmt.Fprint that treats each argument as if it were
-// passed with a default Formatter interface returned by NewFormatter.  It
-// returns the number of bytes written and any write error encountered.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Fprint(w, spew.NewFormatter(a), spew.NewFormatter(b))
-func Fprint(w io.Writer, a ...interface{}) (n int, err error) {
-	return fmt.Fprint(w, convertArgs(a)...)
-}
-
-// Fprintf is a wrapper for fmt.Fprintf that treats each argument as if it were
-// passed with a default Formatter interface returned by NewFormatter.  It
-// returns the number of bytes written and any write error encountered.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Fprintf(w, format, spew.NewFormatter(a), spew.NewFormatter(b))
-func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
-	return fmt.Fprintf(w, format, convertArgs(a)...)
-}
-
-// Fprintln is a wrapper for fmt.Fprintln that treats each argument as if it
-// passed with a default Formatter interface returned by NewFormatter.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Fprintln(w, spew.NewFormatter(a), spew.NewFormatter(b))
-func Fprintln(w io.Writer, a ...interface{}) (n int, err error) {
-	return fmt.Fprintln(w, convertArgs(a)...)
-}
-
-// Print is a wrapper for fmt.Print that treats each argument as if it were
-// passed with a default Formatter interface returned by NewFormatter.  It
-// returns the number of bytes written and any write error encountered.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Print(spew.NewFormatter(a), spew.NewFormatter(b))
-func Print(a ...interface{}) (n int, err error) {
-	return fmt.Print(convertArgs(a)...)
-}
-
-// Printf is a wrapper for fmt.Printf that treats each argument as if it were
-// passed with a default Formatter interface returned by NewFormatter.  It
-// returns the number of bytes written and any write error encountered.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Printf(format, spew.NewFormatter(a), spew.NewFormatter(b))
-func Printf(format string, a ...interface{}) (n int, err error) {
-	return fmt.Printf(format, convertArgs(a)...)
-}
-
-// Println is a wrapper for fmt.Println that treats each argument as if it were
-// passed with a default Formatter interface returned by NewFormatter.  It
-// returns the number of bytes written and any write error encountered.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Println(spew.NewFormatter(a), spew.NewFormatter(b))
-func Println(a ...interface{}) (n int, err error) {
-	return fmt.Println(convertArgs(a)...)
-}
-
-// Sprint is a wrapper for fmt.Sprint that treats each argument as if it were
-// passed with a default Formatter interface returned by NewFormatter.  It
-// returns the resulting string.  See NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Sprint(spew.NewFormatter(a), spew.NewFormatter(b))
-func Sprint(a ...interface{}) string {
-	return fmt.Sprint(convertArgs(a)...)
-}
-
-// Sprintf is a wrapper for fmt.Sprintf that treats each argument as if it were
-// passed with a default Formatter interface returned by NewFormatter.  It
-// returns the resulting string.  See NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Sprintf(format, spew.NewFormatter(a), spew.NewFormatter(b))
-func Sprintf(format string, a ...interface{}) string {
-	return fmt.Sprintf(format, convertArgs(a)...)
-}
-
-// Sprintln is a wrapper for fmt.Sprintln that treats each argument as if it
-// were passed with a default Formatter interface returned by NewFormatter.  It
-// returns the resulting string.  See NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Sprintln(spew.NewFormatter(a), spew.NewFormatter(b))
-func Sprintln(a ...interface{}) string {
-	return fmt.Sprintln(convertArgs(a)...)
-}
-
-// convertArgs accepts a slice of arguments and returns a slice of the same
-// length with each argument converted to a default spew Formatter interface.
-func convertArgs(args []interface{}) (formatters []interface{}) {
-	formatters = make([]interface{}, len(args))
-	for index, arg := range args {
-		formatters[index] = NewFormatter(arg)
-	}
-	return formatters
-}

vendor/github.com/fatih/color/LICENSE.md

@@ -1,20 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2013 Fatih Arslan
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software is furnished to do so,
-subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

vendor/github.com/fatih/color/color.go

@@ -1,600 +0,0 @@
-package color
-
-import (
-	"fmt"
-	"io"
-	"os"
-	"strconv"
-	"strings"
-	"sync"
-
-	"github.com/mattn/go-colorable"
-	"github.com/mattn/go-isatty"
-)
-
-var (
-	// NoColor defines if the output is colorized or not. It's dynamically set to
-	// false or true based on the stdout's file descriptor referring to a terminal
-	// or not. This is a global option and affects all colors. For more control
-	// over each color block use the methods DisableColor() individually.
-	NoColor = os.Getenv("TERM") == "dumb" ||
-		(!isatty.IsTerminal(os.Stdout.Fd()) && !isatty.IsCygwinTerminal(os.Stdout.Fd()))
-
-	// Output defines the standard output of the print functions. By default
-	// os.Stdout is used.
-	Output = colorable.NewColorableStdout()
-
-	// colorsCache is used to reduce the count of created Color objects and
-	// allows to reuse already created objects with required Attribute.
-	colorsCache   = make(map[Attribute]*Color)
-	colorsCacheMu sync.Mutex // protects colorsCache
-)
-
-// Color defines a custom color object which is defined by SGR parameters.
-type Color struct {
-	params  []Attribute
-	noColor *bool
-}
-
-// Attribute defines a single SGR Code
-type Attribute int
-
-const escape = "\x1b"
-
-// Base attributes
-const (
-	Reset Attribute = iota
-	Bold
-	Faint
-	Italic
-	Underline
-	BlinkSlow
-	BlinkRapid
-	ReverseVideo
-	Concealed
-	CrossedOut
-)
-
-// Foreground text colors
-const (
-	FgBlack Attribute = iota + 30
-	FgRed
-	FgGreen
-	FgYellow
-	FgBlue
-	FgMagenta
-	FgCyan
-	FgWhite
-)
-
-// Foreground Hi-Intensity text colors
-const (
-	FgHiBlack Attribute = iota + 90
-	FgHiRed
-	FgHiGreen
-	FgHiYellow
-	FgHiBlue
-	FgHiMagenta
-	FgHiCyan
-	FgHiWhite
-)
-
-// Background text colors
-const (
-	BgBlack Attribute = iota + 40
-	BgRed
-	BgGreen
-	BgYellow
-	BgBlue
-	BgMagenta
-	BgCyan
-	BgWhite
-)
-
-// Background Hi-Intensity text colors
-const (
-	BgHiBlack Attribute = iota + 100
-	BgHiRed
-	BgHiGreen
-	BgHiYellow
-	BgHiBlue
-	BgHiMagenta
-	BgHiCyan
-	BgHiWhite
-)
-
-// New returns a newly created color object.
-func New(value ...Attribute) *Color {
-	c := &Color{params: make([]Attribute, 0)}
-	c.Add(value...)
-	return c
-}
-
-// Set sets the given parameters immediately. It will change the color of
-// output with the given SGR parameters until color.Unset() is called.
-func Set(p ...Attribute) *Color {
-	c := New(p...)
-	c.Set()
-	return c
-}
-
-// Unset resets all escape attributes and clears the output. Usually should
-// be called after Set().
-func Unset() {
-	if NoColor {
-		return
-	}
-
-	fmt.Fprintf(Output, "%s[%dm", escape, Reset)
-}
-
-// Set sets the SGR sequence.
-func (c *Color) Set() *Color {
-	if c.isNoColorSet() {
-		return c
-	}
-
-	fmt.Fprintf(Output, c.format())
-	return c
-}
-
-func (c *Color) unset() {
-	if c.isNoColorSet() {
-		return
-	}
-
-	Unset()
-}
-
-func (c *Color) setWriter(w io.Writer) *Color {
-	if c.isNoColorSet() {
-		return c
-	}
-
-	fmt.Fprintf(w, c.format())
-	return c
-}
-
-func (c *Color) unsetWriter(w io.Writer) {
-	if c.isNoColorSet() {
-		return
-	}
-
-	if NoColor {
-		return
-	}
-
-	fmt.Fprintf(w, "%s[%dm", escape, Reset)
-}
-
-// Add is used to chain SGR parameters. Use as many as parameters to combine
-// and create custom color objects. Example: Add(color.FgRed, color.Underline).
-func (c *Color) Add(value ...Attribute) *Color {
-	c.params = append(c.params, value...)
-	return c
-}
-
-func (c *Color) prepend(value Attribute) {
-	c.params = append(c.params, 0)
-	copy(c.params[1:], c.params[0:])
-	c.params[0] = value
-}
-
-// Fprint formats using the default formats for its operands and writes to w.
-// Spaces are added between operands when neither is a string.
-// It returns the number of bytes written and any write error encountered.
-// On Windows, users should wrap w with colorable.NewColorable() if w is of
-// type *os.File.
-func (c *Color) Fprint(w io.Writer, a ...interface{}) (n int, err error) {
-	c.setWriter(w)
-	defer c.unsetWriter(w)
-
-	return fmt.Fprint(w, a...)
-}
-
-// Print formats using the default formats for its operands and writes to
-// standard output. Spaces are added between operands when neither is a
-// string. It returns the number of bytes written and any write error
-// encountered. This is the standard fmt.Print() method wrapped with the given
-// color.
-func (c *Color) Print(a ...interface{}) (n int, err error) {
-	c.Set()
-	defer c.unset()
-
-	return fmt.Fprint(Output, a...)
-}
-
-// Fprintf formats according to a format specifier and writes to w.
-// It returns the number of bytes written and any write error encountered.
-// On Windows, users should wrap w with colorable.NewColorable() if w is of
-// type *os.File.
-func (c *Color) Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
-	c.setWriter(w)
-	defer c.unsetWriter(w)
-
-	return fmt.Fprintf(w, format, a...)
-}
-
-// Printf formats according to a format specifier and writes to standard output.
-// It returns the number of bytes written and any write error encountered.
-// This is the standard fmt.Printf() method wrapped with the given color.
-func (c *Color) Printf(format string, a ...interface{}) (n int, err error) {
-	c.Set()
-	defer c.unset()
-
-	return fmt.Fprintf(Output, format, a...)
-}
-
-// Fprintln formats using the default formats for its operands and writes to w.
-// Spaces are always added between operands and a newline is appended.
-// On Windows, users should wrap w with colorable.NewColorable() if w is of
-// type *os.File.
-func (c *Color) Fprintln(w io.Writer, a ...interface{}) (n int, err error) {
-	c.setWriter(w)
-	defer c.unsetWriter(w)
-
-	return fmt.Fprintln(w, a...)
-}
-
-// Println formats using the default formats for its operands and writes to
-// standard output. Spaces are always added between operands and a newline is
-// appended. It returns the number of bytes written and any write error
-// encountered. This is the standard fmt.Print() method wrapped with the given
-// color.
-func (c *Color) Println(a ...interface{}) (n int, err error) {
-	c.Set()
-	defer c.unset()
-
-	return fmt.Fprintln(Output, a...)
-}
-
-// Sprint is just like Print, but returns a string instead of printing it.
-func (c *Color) Sprint(a ...interface{}) string {
-	return c.wrap(fmt.Sprint(a...))
-}
-
-// Sprintln is just like Println, but returns a string instead of printing it.
-func (c *Color) Sprintln(a ...interface{}) string {
-	return c.wrap(fmt.Sprintln(a...))
-}
-
-// Sprintf is just like Printf, but returns a string instead of printing it.
-func (c *Color) Sprintf(format string, a ...interface{}) string {
-	return c.wrap(fmt.Sprintf(format, a...))
-}
-
-// FprintFunc returns a new function that prints the passed arguments as
-// colorized with color.Fprint().
-func (c *Color) FprintFunc() func(w io.Writer, a ...interface{}) {
-	return func(w io.Writer, a ...interface{}) {
-		c.Fprint(w, a...)
-	}
-}
-
-// PrintFunc returns a new function that prints the passed arguments as
-// colorized with color.Print().
-func (c *Color) PrintFunc() func(a ...interface{}) {
-	return func(a ...interface{}) {
-		c.Print(a...)
-	}
-}
-
-// FprintfFunc returns a new function that prints the passed arguments as
-// colorized with color.Fprintf().
-func (c *Color) FprintfFunc() func(w io.Writer, format string, a ...interface{}) {
-	return func(w io.Writer, format string, a ...interface{}) {
-		c.Fprintf(w, format, a...)
-	}
-}
-
-// PrintfFunc returns a new function that prints the passed arguments as
-// colorized with color.Printf().
-func (c *Color) PrintfFunc() func(format string, a ...interface{}) {
-	return func(format string, a ...interface{}) {
-		c.Printf(format, a...)
-	}
-}
-
-// FprintlnFunc returns a new function that prints the passed arguments as
-// colorized with color.Fprintln().
-func (c *Color) FprintlnFunc() func(w io.Writer, a ...interface{}) {
-	return func(w io.Writer, a ...interface{}) {
-		c.Fprintln(w, a...)
-	}
-}
-
-// PrintlnFunc returns a new function that prints the passed arguments as
-// colorized with color.Println().
-func (c *Color) PrintlnFunc() func(a ...interface{}) {
-	return func(a ...interface{}) {
-		c.Println(a...)
-	}
-}
-
-// SprintFunc returns a new function that returns colorized strings for the
-// given arguments with fmt.Sprint(). Useful to put into or mix into other
-// string. Windows users should use this in conjunction with color.Output, example:
-//
-//	put := New(FgYellow).SprintFunc()
-//	fmt.Fprintf(color.Output, "This is a %s", put("warning"))
-func (c *Color) SprintFunc() func(a ...interface{}) string {
-	return func(a ...interface{}) string {
-		return c.wrap(fmt.Sprint(a...))
-	}
-}
-
-// SprintfFunc returns a new function that returns colorized strings for the
-// given arguments with fmt.Sprintf(). Useful to put into or mix into other
-// string. Windows users should use this in conjunction with color.Output.
-func (c *Color) SprintfFunc() func(format string, a ...interface{}) string {
-	return func(format string, a ...interface{}) string {
-		return c.wrap(fmt.Sprintf(format, a...))
-	}
-}
-
-// SprintlnFunc returns a new function that returns colorized strings for the
-// given arguments with fmt.Sprintln(). Useful to put into or mix into other
-// string. Windows users should use this in conjunction with color.Output.
-func (c *Color) SprintlnFunc() func(a ...interface{}) string {
-	return func(a ...interface{}) string {
-		return c.wrap(fmt.Sprintln(a...))
-	}
-}
-
-// sequence returns a formatted SGR sequence to be plugged into a "\x1b[...m"
-// an example output might be: "1;36" -> bold cyan
-func (c *Color) sequence() string {
-	format := make([]string, len(c.params))
-	for i, v := range c.params {
-		format[i] = strconv.Itoa(int(v))
-	}
-
-	return strings.Join(format, ";")
-}
-
-// wrap wraps the s string with the colors attributes. The string is ready to
-// be printed.
-func (c *Color) wrap(s string) string {
-	if c.isNoColorSet() {
-		return s
-	}
-
-	return c.format() + s + c.unformat()
-}
-
-func (c *Color) format() string {
-	return fmt.Sprintf("%s[%sm", escape, c.sequence())
-}
-
-func (c *Color) unformat() string {
-	return fmt.Sprintf("%s[%dm", escape, Reset)
-}
-
-// DisableColor disables the color output. Useful to not change any existing
-// code and still being able to output. Can be used for flags like
-// "--no-color". To enable back use EnableColor() method.
-func (c *Color) DisableColor() {
-	c.noColor = boolPtr(true)
-}
-
-// EnableColor enables the color output. Use it in conjunction with
-// DisableColor(). Otherwise this method has no side effects.
-func (c *Color) EnableColor() {
-	c.noColor = boolPtr(false)
-}
-
-func (c *Color) isNoColorSet() bool {
-	// check first if we have user setted action
-	if c.noColor != nil {
-		return *c.noColor
-	}
-
-	// if not return the global option, which is disabled by default
-	return NoColor
-}
-
-// Equals returns a boolean value indicating whether two colors are equal.
-func (c *Color) Equals(c2 *Color) bool {
-	if len(c.params) != len(c2.params) {
-		return false
-	}
-
-	for _, attr := range c.params {
-		if !c2.attrExists(attr) {
-			return false
-		}
-	}
-
-	return true
-}
-
-func (c *Color) attrExists(a Attribute) bool {
-	for _, attr := range c.params {
-		if attr == a {
-			return true
-		}
-	}
-
-	return false
-}
-
-func boolPtr(v bool) *bool {
-	return &v
-}
-
-func getCachedColor(p Attribute) *Color {
-	colorsCacheMu.Lock()
-	defer colorsCacheMu.Unlock()
-
-	c, ok := colorsCache[p]
-	if !ok {
-		c = New(p)
-		colorsCache[p] = c
-	}
-
-	return c
-}
-
-func colorPrint(format string, p Attribute, a ...interface{}) {
-	c := getCachedColor(p)
-
-	if !strings.HasSuffix(format, "\n") {
-		format += "\n"
-	}
-
-	if len(a) == 0 {
-		c.Print(format)
-	} else {
-		c.Printf(format, a...)
-	}
-}
-
-func colorString(format string, p Attribute, a ...interface{}) string {
-	c := getCachedColor(p)
-
-	if len(a) == 0 {
-		return c.SprintFunc()(format)
-	}
-
-	return c.SprintfFunc()(format, a...)
-}
-
-// Black is a convenient helper function to print with black foreground. A
-// newline is appended to format by default.
-func Black(format string, a ...interface{}) { colorPrint(format, FgBlack, a...) }
-
-// Red is a convenient helper function to print with red foreground. A
-// newline is appended to format by default.
-func Red(format string, a ...interface{}) { colorPrint(format, FgRed, a...) }
-
-// Green is a convenient helper function to print with green foreground. A
-// newline is appended to format by default.
-func Green(format string, a ...interface{}) { colorPrint(format, FgGreen, a...) }
-
-// Yellow is a convenient helper function to print with yellow foreground.
-// A newline is appended to format by default.
-func Yellow(format string, a ...interface{}) { colorPrint(format, FgYellow, a...) }
-
-// Blue is a convenient helper function to print with blue foreground. A
-// newline is appended to format by default.
-func Blue(format string, a ...interface{}) { colorPrint(format, FgBlue, a...) }
-
-// Magenta is a convenient helper function to print with magenta foreground.
-// A newline is appended to format by default.
-func Magenta(format string, a ...interface{}) { colorPrint(format, FgMagenta, a...) }
-
-// Cyan is a convenient helper function to print with cyan foreground. A
-// newline is appended to format by default.
-func Cyan(format string, a ...interface{}) { colorPrint(format, FgCyan, a...) }
-
-// White is a convenient helper function to print with white foreground. A
-// newline is appended to format by default.
-func White(format string, a ...interface{}) { colorPrint(format, FgWhite, a...) }
-
-// BlackString is a convenient helper function to return a string with black
-// foreground.
-func BlackString(format string, a ...interface{}) string { return colorString(format, FgBlack, a...) }
-
-// RedString is a convenient helper function to return a string with red
-// foreground.
-func RedString(format string, a ...interface{}) string { return colorString(format, FgRed, a...) }
-
-// GreenString is a convenient helper function to return a string with green
-// foreground.
-func GreenString(format string, a ...interface{}) string { return colorString(format, FgGreen, a...) }
-
-// YellowString is a convenient helper function to return a string with yellow
-// foreground.
-func YellowString(format string, a ...interface{}) string { return colorString(format, FgYellow, a...) }
-
-// BlueString is a convenient helper function to return a string with blue
-// foreground.
-func BlueString(format string, a ...interface{}) string { return colorString(format, FgBlue, a...) }
-
-// MagentaString is a convenient helper function to return a string with magenta
-// foreground.
-func MagentaString(format string, a ...interface{}) string {
-	return colorString(format, FgMagenta, a...)
-}
-
-// CyanString is a convenient helper function to return a string with cyan
-// foreground.
-func CyanString(format string, a ...interface{}) string { return colorString(format, FgCyan, a...) }
-
-// WhiteString is a convenient helper function to return a string with white
-// foreground.
-func WhiteString(format string, a ...interface{}) string { return colorString(format, FgWhite, a...) }
-
-// HiBlack is a convenient helper function to print with hi-intensity black foreground. A
-// newline is appended to format by default.
-func HiBlack(format string, a ...interface{}) { colorPrint(format, FgHiBlack, a...) }
-
-// HiRed is a convenient helper function to print with hi-intensity red foreground. A
-// newline is appended to format by default.
-func HiRed(format string, a ...interface{}) { colorPrint(format, FgHiRed, a...) }
-
-// HiGreen is a convenient helper function to print with hi-intensity green foreground. A
-// newline is appended to format by default.
-func HiGreen(format string, a ...interface{}) { colorPrint(format, FgHiGreen, a...) }
-
-// HiYellow is a convenient helper function to print with hi-intensity yellow foreground.
-// A newline is appended to format by default.
-func HiYellow(format string, a ...interface{}) { colorPrint(format, FgHiYellow, a...) }
-
-// HiBlue is a convenient helper function to print with hi-intensity blue foreground. A
-// newline is appended to format by default.
-func HiBlue(format string, a ...interface{}) { colorPrint(format, FgHiBlue, a...) }
-
-// HiMagenta is a convenient helper function to print with hi-intensity magenta foreground.
-// A newline is appended to format by default.
-func HiMagenta(format string, a ...interface{}) { colorPrint(format, FgHiMagenta, a...) }
-
-// HiCyan is a convenient helper function to print with hi-intensity cyan foreground. A
-// newline is appended to format by default.
-func HiCyan(format string, a ...interface{}) { colorPrint(format, FgHiCyan, a...) }
-
-// HiWhite is a convenient helper function to print with hi-intensity white foreground. A
-// newline is appended to format by default.
-func HiWhite(format string, a ...interface{}) { colorPrint(format, FgHiWhite, a...) }
-
-// HiBlackString is a convenient helper function to return a string with hi-intensity black
-// foreground.
-func HiBlackString(format string, a ...interface{}) string {
-	return colorString(format, FgHiBlack, a...)
-}
-
-// HiRedString is a convenient helper function to return a string with hi-intensity red
-// foreground.
-func HiRedString(format string, a ...interface{}) string { return colorString(format, FgHiRed, a...) }
-
-// HiGreenString is a convenient helper function to return a string with hi-intensity green
-// foreground.
-func HiGreenString(format string, a ...interface{}) string {
-	return colorString(format, FgHiGreen, a...)
-}
-
-// HiYellowString is a convenient helper function to return a string with hi-intensity yellow
-// foreground.
-func HiYellowString(format string, a ...interface{}) string {
-	return colorString(format, FgHiYellow, a...)
-}
-
-// HiBlueString is a convenient helper function to return a string with hi-intensity blue
-// foreground.
-func HiBlueString(format string, a ...interface{}) string { return colorString(format, FgHiBlue, a...) }
-
-// HiMagentaString is a convenient helper function to return a string with hi-intensity magenta
-// foreground.
-func HiMagentaString(format string, a ...interface{}) string {
-	return colorString(format, FgHiMagenta, a...)
-}
-
-// HiCyanString is a convenient helper function to return a string with hi-intensity cyan
-// foreground.
-func HiCyanString(format string, a ...interface{}) string { return colorString(format, FgHiCyan, a...) }
-
-// HiWhiteString is a convenient helper function to return a string with hi-intensity white
-// foreground.
-func HiWhiteString(format string, a ...interface{}) string {
-	return colorString(format, FgHiWhite, a...)
-}

vendor/github.com/fatih/color/doc.go

@@ -1,133 +0,0 @@
-/*
-Package color is an ANSI color package to output colorized or SGR defined
-output to the standard output. The API can be used in several way, pick one
-that suits you.
-
-Use simple and default helper functions with predefined foreground colors:
-
-    color.Cyan("Prints text in cyan.")
-
-    // a newline will be appended automatically
-    color.Blue("Prints %s in blue.", "text")
-
-    // More default foreground colors..
-    color.Red("We have red")
-    color.Yellow("Yellow color too!")
-    color.Magenta("And many others ..")
-
-    // Hi-intensity colors
-    color.HiGreen("Bright green color.")
-    color.HiBlack("Bright black means gray..")
-    color.HiWhite("Shiny white color!")
-
-However there are times where custom color mixes are required. Below are some
-examples to create custom color objects and use the print functions of each
-separate color object.
-
-    // Create a new color object
-    c := color.New(color.FgCyan).Add(color.Underline)
-    c.Println("Prints cyan text with an underline.")
-
-    // Or just add them to New()
-    d := color.New(color.FgCyan, color.Bold)
-    d.Printf("This prints bold cyan %s\n", "too!.")
-
-
-    // Mix up foreground and background colors, create new mixes!
-    red := color.New(color.FgRed)
-
-    boldRed := red.Add(color.Bold)
-    boldRed.Println("This will print text in bold red.")
-
-    whiteBackground := red.Add(color.BgWhite)
-    whiteBackground.Println("Red text with White background.")
-
-    // Use your own io.Writer output
-    color.New(color.FgBlue).Fprintln(myWriter, "blue color!")
-
-    blue := color.New(color.FgBlue)
-    blue.Fprint(myWriter, "This will print text in blue.")
-
-You can create PrintXxx functions to simplify even more:
-
-    // Create a custom print function for convenient
-    red := color.New(color.FgRed).PrintfFunc()
-    red("warning")
-    red("error: %s", err)
-
-    // Mix up multiple attributes
-    notice := color.New(color.Bold, color.FgGreen).PrintlnFunc()
-    notice("don't forget this...")
-
-You can also FprintXxx functions to pass your own io.Writer:
-
-    blue := color.New(FgBlue).FprintfFunc()
-    blue(myWriter, "important notice: %s", stars)
-
-    // Mix up with multiple attributes
-    success := color.New(color.Bold, color.FgGreen).FprintlnFunc()
-    success(myWriter, don't forget this...")
-
-
-Or create SprintXxx functions to mix strings with other non-colorized strings:
-
-    yellow := New(FgYellow).SprintFunc()
-    red := New(FgRed).SprintFunc()
-
-    fmt.Printf("this is a %s and this is %s.\n", yellow("warning"), red("error"))
-
-    info := New(FgWhite, BgGreen).SprintFunc()
-    fmt.Printf("this %s rocks!\n", info("package"))
-
-Windows support is enabled by default. All Print functions work as intended.
-However only for color.SprintXXX functions, user should use fmt.FprintXXX and
-set the output to color.Output:
-
-    fmt.Fprintf(color.Output, "Windows support: %s", color.GreenString("PASS"))
-
-    info := New(FgWhite, BgGreen).SprintFunc()
-    fmt.Fprintf(color.Output, "this %s rocks!\n", info("package"))
-
-Using with existing code is possible. Just use the Set() method to set the
-standard output to the given parameters. That way a rewrite of an existing
-code is not required.
-
-    // Use handy standard colors.
-    color.Set(color.FgYellow)
-
-    fmt.Println("Existing text will be now in Yellow")
-    fmt.Printf("This one %s\n", "too")
-
-    color.Unset() // don't forget to unset
-
-    // You can mix up parameters
-    color.Set(color.FgMagenta, color.Bold)
-    defer color.Unset() // use it in your function
-
-    fmt.Println("All text will be now bold magenta.")
-
-There might be a case where you want to disable color output (for example to
-pipe the standard output of your app to somewhere else). `Color` has support to
-disable colors both globally and for single color definition. For example
-suppose you have a CLI app and a `--no-color` bool flag. You can easily disable
-the color output with:
-
-    var flagNoColor = flag.Bool("no-color", false, "Disable color output")
-
-    if *flagNoColor {
-    	color.NoColor = true // disables colorized output
-    }
-
-It also has support for single color definitions (local). You can
-disable/enable color output on the fly:
-
-     c := color.New(color.FgCyan)
-     c.Println("Prints cyan text")
-
-     c.DisableColor()
-     c.Println("This is printed without any color")
-
-     c.EnableColor()
-     c.Println("This prints again cyan...")
-*/
-package color

vendor/github.com/imdario/mergo/LICENSE

@@ -1,28 +0,0 @@
-Copyright (c) 2013 Dario Castañé. All rights reserved.
-Copyright (c) 2012 The Go Authors. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-   * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-   * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
-   * Neither the name of Google Inc. nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

vendor/github.com/imdario/mergo/doc.go

@@ -1,44 +0,0 @@
-// Copyright 2013 Dario Castañé. All rights reserved.
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-/*
-Package mergo merges same-type structs and maps by setting default values in zero-value fields.
-
-Mergo won't merge unexported (private) fields but will do recursively any exported one. It also won't merge structs inside maps (because they are not addressable using Go reflection).
-
-Usage
-
-From my own work-in-progress project:
-
-	type networkConfig struct {
-		Protocol string
-		Address string
-		ServerType string `json: "server_type"`
-		Port uint16
-	}
-
-	type FssnConfig struct {
-		Network networkConfig
-	}
-
-	var fssnDefault = FssnConfig {
-		networkConfig {
-			"tcp",
-			"127.0.0.1",
-			"http",
-			31560,
-		},
-	}
-
-	// Inside a function [...]
-
-	if err := mergo.Merge(&config, fssnDefault); err != nil {
-		log.Fatal(err)
-	}
-
-	// More code [...]
-
-*/
-package mergo

vendor/github.com/imdario/mergo/map.go

@@ -1,174 +0,0 @@
-// Copyright 2014 Dario Castañé. All rights reserved.
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Based on src/pkg/reflect/deepequal.go from official
-// golang's stdlib.
-
-package mergo
-
-import (
-	"fmt"
-	"reflect"
-	"unicode"
-	"unicode/utf8"
-)
-
-func changeInitialCase(s string, mapper func(rune) rune) string {
-	if s == "" {
-		return s
-	}
-	r, n := utf8.DecodeRuneInString(s)
-	return string(mapper(r)) + s[n:]
-}
-
-func isExported(field reflect.StructField) bool {
-	r, _ := utf8.DecodeRuneInString(field.Name)
-	return r >= 'A' && r <= 'Z'
-}
-
-// Traverses recursively both values, assigning src's fields values to dst.
-// The map argument tracks comparisons that have already been seen, which allows
-// short circuiting on recursive types.
-func deepMap(dst, src reflect.Value, visited map[uintptr]*visit, depth int, config *config) (err error) {
-	overwrite := config.overwrite
-	if dst.CanAddr() {
-		addr := dst.UnsafeAddr()
-		h := 17 * addr
-		seen := visited[h]
-		typ := dst.Type()
-		for p := seen; p != nil; p = p.next {
-			if p.ptr == addr && p.typ == typ {
-				return nil
-			}
-		}
-		// Remember, remember...
-		visited[h] = &visit{addr, typ, seen}
-	}
-	zeroValue := reflect.Value{}
-	switch dst.Kind() {
-	case reflect.Map:
-		dstMap := dst.Interface().(map[string]interface{})
-		for i, n := 0, src.NumField(); i < n; i++ {
-			srcType := src.Type()
-			field := srcType.Field(i)
-			if !isExported(field) {
-				continue
-			}
-			fieldName := field.Name
-			fieldName = changeInitialCase(fieldName, unicode.ToLower)
-			if v, ok := dstMap[fieldName]; !ok || (isEmptyValue(reflect.ValueOf(v)) || overwrite) {
-				dstMap[fieldName] = src.Field(i).Interface()
-			}
-		}
-	case reflect.Ptr:
-		if dst.IsNil() {
-			v := reflect.New(dst.Type().Elem())
-			dst.Set(v)
-		}
-		dst = dst.Elem()
-		fallthrough
-	case reflect.Struct:
-		srcMap := src.Interface().(map[string]interface{})
-		for key := range srcMap {
-			srcValue := srcMap[key]
-			fieldName := changeInitialCase(key, unicode.ToUpper)
-			dstElement := dst.FieldByName(fieldName)
-			if dstElement == zeroValue {
-				// We discard it because the field doesn't exist.
-				continue
-			}
-			srcElement := reflect.ValueOf(srcValue)
-			dstKind := dstElement.Kind()
-			srcKind := srcElement.Kind()
-			if srcKind == reflect.Ptr && dstKind != reflect.Ptr {
-				srcElement = srcElement.Elem()
-				srcKind = reflect.TypeOf(srcElement.Interface()).Kind()
-			} else if dstKind == reflect.Ptr {
-				// Can this work? I guess it can't.
-				if srcKind != reflect.Ptr && srcElement.CanAddr() {
-					srcPtr := srcElement.Addr()
-					srcElement = reflect.ValueOf(srcPtr)
-					srcKind = reflect.Ptr
-				}
-			}
-
-			if !srcElement.IsValid() {
-				continue
-			}
-			if srcKind == dstKind {
-				if err = deepMerge(dstElement, srcElement, visited, depth+1, config); err != nil {
-					return
-				}
-			} else if dstKind == reflect.Interface && dstElement.Kind() == reflect.Interface {
-				if err = deepMerge(dstElement, srcElement, visited, depth+1, config); err != nil {
-					return
-				}
-			} else if srcKind == reflect.Map {
-				if err = deepMap(dstElement, srcElement, visited, depth+1, config); err != nil {
-					return
-				}
-			} else {
-				return fmt.Errorf("type mismatch on %s field: found %v, expected %v", fieldName, srcKind, dstKind)
-			}
-		}
-	}
-	return
-}
-
-// Map sets fields' values in dst from src.
-// src can be a map with string keys or a struct. dst must be the opposite:
-// if src is a map, dst must be a valid pointer to struct. If src is a struct,
-// dst must be map[string]interface{}.
-// It won't merge unexported (private) fields and will do recursively
-// any exported field.
-// If dst is a map, keys will be src fields' names in lower camel case.
-// Missing key in src that doesn't match a field in dst will be skipped. This
-// doesn't apply if dst is a map.
-// This is separated method from Merge because it is cleaner and it keeps sane
-// semantics: merging equal types, mapping different (restricted) types.
-func Map(dst, src interface{}, opts ...func(*config)) error {
-	return _map(dst, src, opts...)
-}
-
-// MapWithOverwrite will do the same as Map except that non-empty dst attributes will be overriden by
-// non-empty src attribute values.
-// Deprecated: Use Map(…) with WithOverride
-func MapWithOverwrite(dst, src interface{}, opts ...func(*config)) error {
-	return _map(dst, src, append(opts, WithOverride)...)
-}
-
-func _map(dst, src interface{}, opts ...func(*config)) error {
-	var (
-		vDst, vSrc reflect.Value
-		err        error
-	)
-	config := &config{}
-
-	for _, opt := range opts {
-		opt(config)
-	}
-
-	if vDst, vSrc, err = resolveValues(dst, src); err != nil {
-		return err
-	}
-	// To be friction-less, we redirect equal-type arguments
-	// to deepMerge. Only because arguments can be anything.
-	if vSrc.Kind() == vDst.Kind() {
-		return deepMerge(vDst, vSrc, make(map[uintptr]*visit), 0, config)
-	}
-	switch vSrc.Kind() {
-	case reflect.Struct:
-		if vDst.Kind() != reflect.Map {
-			return ErrExpectedMapAsDestination
-		}
-	case reflect.Map:
-		if vDst.Kind() != reflect.Struct {
-			return ErrExpectedStructAsDestination
-		}
-	default:
-		return ErrNotSupported
-	}
-	return deepMap(vDst, vSrc, make(map[uintptr]*visit), 0, config)
-}

vendor/github.com/imdario/mergo/merge.go

@@ -1,219 +0,0 @@
-// Copyright 2013 Dario Castañé. All rights reserved.
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Based on src/pkg/reflect/deepequal.go from official
-// golang's stdlib.
-
-package mergo
-
-import "reflect"
-
-func hasExportedField(dst reflect.Value) (exported bool) {
-	for i, n := 0, dst.NumField(); i < n; i++ {
-		field := dst.Type().Field(i)
-		if field.Anonymous && dst.Field(i).Kind() == reflect.Struct {
-			exported = exported || hasExportedField(dst.Field(i))
-		} else {
-			exported = exported || len(field.PkgPath) == 0
-		}
-	}
-	return
-}
-
-type config struct {
-	overwrite    bool
-	transformers transformers
-}
-
-type transformers interface {
-	Transformer(reflect.Type) func(dst, src reflect.Value) error
-}
-
-// Traverses recursively both values, assigning src's fields values to dst.
-// The map argument tracks comparisons that have already been seen, which allows
-// short circuiting on recursive types.
-func deepMerge(dst, src reflect.Value, visited map[uintptr]*visit, depth int, config *config) (err error) {
-	overwrite := config.overwrite
-
-	if !src.IsValid() {
-		return
-	}
-	if dst.CanAddr() {
-		addr := dst.UnsafeAddr()
-		h := 17 * addr
-		seen := visited[h]
-		typ := dst.Type()
-		for p := seen; p != nil; p = p.next {
-			if p.ptr == addr && p.typ == typ {
-				return nil
-			}
-		}
-		// Remember, remember...
-		visited[h] = &visit{addr, typ, seen}
-	}
-
-	if config.transformers != nil && !isEmptyValue(dst) {
-		if fn := config.transformers.Transformer(dst.Type()); fn != nil {
-			err = fn(dst, src)
-			return
-		}
-	}
-
-	switch dst.Kind() {
-	case reflect.Struct:
-		if hasExportedField(dst) {
-			for i, n := 0, dst.NumField(); i < n; i++ {
-				if err = deepMerge(dst.Field(i), src.Field(i), visited, depth+1, config); err != nil {
-					return
-				}
-			}
-		} else {
-			if dst.CanSet() && !isEmptyValue(src) && (overwrite || isEmptyValue(dst)) {
-				dst.Set(src)
-			}
-		}
-	case reflect.Map:
-		if len(src.MapKeys()) == 0 && !src.IsNil() && len(dst.MapKeys()) == 0 {
-			dst.Set(reflect.MakeMap(dst.Type()))
-			return
-		}
-		for _, key := range src.MapKeys() {
-			srcElement := src.MapIndex(key)
-			if !srcElement.IsValid() {
-				continue
-			}
-			dstElement := dst.MapIndex(key)
-			switch srcElement.Kind() {
-			case reflect.Chan, reflect.Func, reflect.Map, reflect.Ptr, reflect.Interface, reflect.Slice:
-				if srcElement.IsNil() {
-					continue
-				}
-				fallthrough
-			default:
-				if !srcElement.CanInterface() {
-					continue
-				}
-				switch reflect.TypeOf(srcElement.Interface()).Kind() {
-				case reflect.Struct:
-					fallthrough
-				case reflect.Ptr:
-					fallthrough
-				case reflect.Map:
-					if err = deepMerge(dstElement, srcElement, visited, depth+1, config); err != nil {
-						return
-					}
-				case reflect.Slice:
-					srcSlice := reflect.ValueOf(srcElement.Interface())
-
-					var dstSlice reflect.Value
-					if !dstElement.IsValid() || dstElement.IsNil() {
-						dstSlice = reflect.MakeSlice(srcSlice.Type(), 0, srcSlice.Len())
-					} else {
-						dstSlice = reflect.ValueOf(dstElement.Interface())
-					}
-
-					dstSlice = reflect.AppendSlice(dstSlice, srcSlice)
-					dst.SetMapIndex(key, dstSlice)
-				}
-			}
-			if dstElement.IsValid() && reflect.TypeOf(srcElement.Interface()).Kind() == reflect.Map {
-				continue
-			}
-
-			if !isEmptyValue(srcElement) && (overwrite || (!dstElement.IsValid() || isEmptyValue(dst))) {
-				if dst.IsNil() {
-					dst.Set(reflect.MakeMap(dst.Type()))
-				}
-				dst.SetMapIndex(key, srcElement)
-			}
-		}
-	case reflect.Slice:
-		dst.Set(reflect.AppendSlice(dst, src))
-	case reflect.Ptr:
-		fallthrough
-	case reflect.Interface:
-		if src.IsNil() {
-			break
-		}
-		if src.Kind() != reflect.Interface {
-			if dst.IsNil() || overwrite {
-				if dst.CanSet() && (overwrite || isEmptyValue(dst)) {
-					dst.Set(src)
-				}
-			} else if src.Kind() == reflect.Ptr {
-				if err = deepMerge(dst.Elem(), src.Elem(), visited, depth+1, config); err != nil {
-					return
-				}
-			} else if dst.Elem().Type() == src.Type() {
-				if err = deepMerge(dst.Elem(), src, visited, depth+1, config); err != nil {
-					return
-				}
-			} else {
-				return ErrDifferentArgumentsTypes
-			}
-			break
-		}
-		if dst.IsNil() || overwrite {
-			if dst.CanSet() && (overwrite || isEmptyValue(dst)) {
-				dst.Set(src)
-			}
-		} else if err = deepMerge(dst.Elem(), src.Elem(), visited, depth+1, config); err != nil {
-			return
-		}
-	default:
-		if dst.CanSet() && !isEmptyValue(src) && (overwrite || isEmptyValue(dst)) {
-			dst.Set(src)
-		}
-	}
-	return
-}
-
-// Merge will fill any empty for value type attributes on the dst struct using corresponding
-// src attributes if they themselves are not empty. dst and src must be valid same-type structs
-// and dst must be a pointer to struct.
-// It won't merge unexported (private) fields and will do recursively any exported field.
-func Merge(dst, src interface{}, opts ...func(*config)) error {
-	return merge(dst, src, opts...)
-}
-
-// MergeWithOverwrite will do the same as Merge except that non-empty dst attributes will be overriden by
-// non-empty src attribute values.
-// Deprecated: use Merge(…) with WithOverride
-func MergeWithOverwrite(dst, src interface{}, opts ...func(*config)) error {
-	return merge(dst, src, append(opts, WithOverride)...)
-}
-
-// WithTransformers adds transformers to merge, allowing to customize the merging of some types.
-func WithTransformers(transformers transformers) func(*config) {
-	return func(config *config) {
-		config.transformers = transformers
-	}
-}
-
-// WithOverride will make merge override non-empty dst attributes with non-empty src attributes values.
-func WithOverride(config *config) {
-	config.overwrite = true
-}
-
-func merge(dst, src interface{}, opts ...func(*config)) error {
-	var (
-		vDst, vSrc reflect.Value
-		err        error
-	)
-
-	config := &config{}
-
-	for _, opt := range opts {
-		opt(config)
-	}
-
-	if vDst, vSrc, err = resolveValues(dst, src); err != nil {
-		return err
-	}
-	if vDst.Type() != vSrc.Type() {
-		return ErrDifferentArgumentsTypes
-	}
-	return deepMerge(vDst, vSrc, make(map[uintptr]*visit), 0, config)
-}

vendor/github.com/imdario/mergo/mergo.go

@@ -1,92 +0,0 @@
-// Copyright 2013 Dario Castañé. All rights reserved.
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Based on src/pkg/reflect/deepequal.go from official
-// golang's stdlib.
-
-package mergo
-
-import (
-	"errors"
-	"reflect"
-)
-
-// Errors reported by Mergo when it finds invalid arguments.
-var (
-	ErrNilArguments                = errors.New("src and dst must not be nil")
-	ErrDifferentArgumentsTypes     = errors.New("src and dst must be of same type")
-	ErrNotSupported                = errors.New("only structs and maps are supported")
-	ErrExpectedMapAsDestination    = errors.New("dst was expected to be a map")
-	ErrExpectedStructAsDestination = errors.New("dst was expected to be a struct")
-)
-
-// During deepMerge, must keep track of checks that are
-// in progress.  The comparison algorithm assumes that all
-// checks in progress are true when it reencounters them.
-// Visited are stored in a map indexed by 17 * a1 + a2;
-type visit struct {
-	ptr  uintptr
-	typ  reflect.Type
-	next *visit
-}
-
-// From src/pkg/encoding/json/encode.go.
-func isEmptyValue(v reflect.Value) bool {
-	switch v.Kind() {
-	case reflect.Array, reflect.Map, reflect.Slice, reflect.String:
-		return v.Len() == 0
-	case reflect.Bool:
-		return !v.Bool()
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		return v.Int() == 0
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
-		return v.Uint() == 0
-	case reflect.Float32, reflect.Float64:
-		return v.Float() == 0
-	case reflect.Interface, reflect.Ptr, reflect.Func:
-		return v.IsNil()
-	case reflect.Invalid:
-		return true
-	}
-	return false
-}
-
-func resolveValues(dst, src interface{}) (vDst, vSrc reflect.Value, err error) {
-	if dst == nil || src == nil {
-		err = ErrNilArguments
-		return
-	}
-	vDst = reflect.ValueOf(dst).Elem()
-	if vDst.Kind() != reflect.Struct && vDst.Kind() != reflect.Map {
-		err = ErrNotSupported
-		return
-	}
-	vSrc = reflect.ValueOf(src)
-	// We check if vSrc is a pointer to dereference it.
-	if vSrc.Kind() == reflect.Ptr {
-		vSrc = vSrc.Elem()
-	}
-	return
-}
-
-// Traverses recursively both values, assigning src's fields values to dst.
-// The map argument tracks comparisons that have already been seen, which allows
-// short circuiting on recursive types.
-func deeper(dst, src reflect.Value, visited map[uintptr]*visit, depth int) (err error) {
-	if dst.CanAddr() {
-		addr := dst.UnsafeAddr()
-		h := 17 * addr
-		seen := visited[h]
-		typ := dst.Type()
-		for p := seen; p != nil; p = p.next {
-			if p.ptr == addr && p.typ == typ {
-				return nil
-			}
-		}
-		// Remember, remember...
-		visited[h] = &visit{addr, typ, seen}
-	}
-	return // TODO refactor
-}

vendor/github.com/imdario/mergo/testdata/license.yml

@@ -1,4 +0,0 @@
-import: ../../../../fossene/db/schema/thing.yml
-fields:
-    site: string
-    author: root

vendor/github.com/mattn/go-colorable/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2016 Yasuhiro Matsumoto
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

vendor/github.com/mattn/go-colorable/colorable_appengine.go

@@ -1,29 +0,0 @@
-// +build appengine
-
-package colorable
-
-import (
-	"io"
-	"os"
-
-	_ "github.com/mattn/go-isatty"
-)
-
-// NewColorable return new instance of Writer which handle escape sequence.
-func NewColorable(file *os.File) io.Writer {
-	if file == nil {
-		panic("nil passed instead of *os.File to NewColorable()")
-	}
-
-	return file
-}
-
-// NewColorableStdout return new instance of Writer which handle escape sequence for stdout.
-func NewColorableStdout() io.Writer {
-	return os.Stdout
-}
-
-// NewColorableStderr return new instance of Writer which handle escape sequence for stderr.
-func NewColorableStderr() io.Writer {
-	return os.Stderr
-}

vendor/github.com/mattn/go-colorable/colorable_others.go

@@ -1,30 +0,0 @@
-// +build !windows
-// +build !appengine
-
-package colorable
-
-import (
-	"io"
-	"os"
-
-	_ "github.com/mattn/go-isatty"
-)
-
-// NewColorable return new instance of Writer which handle escape sequence.
-func NewColorable(file *os.File) io.Writer {
-	if file == nil {
-		panic("nil passed instead of *os.File to NewColorable()")
-	}
-
-	return file
-}
-
-// NewColorableStdout return new instance of Writer which handle escape sequence for stdout.
-func NewColorableStdout() io.Writer {
-	return os.Stdout
-}
-
-// NewColorableStderr return new instance of Writer which handle escape sequence for stderr.
-func NewColorableStderr() io.Writer {
-	return os.Stderr
-}

vendor/github.com/mattn/go-colorable/colorable_windows.go

@@ -1,884 +0,0 @@
-// +build windows
-// +build !appengine
-
-package colorable
-
-import (
-	"bytes"
-	"io"
-	"math"
-	"os"
-	"strconv"
-	"strings"
-	"syscall"
-	"unsafe"
-
-	"github.com/mattn/go-isatty"
-)
-
-const (
-	foregroundBlue      = 0x1
-	foregroundGreen     = 0x2
-	foregroundRed       = 0x4
-	foregroundIntensity = 0x8
-	foregroundMask      = (foregroundRed | foregroundBlue | foregroundGreen | foregroundIntensity)
-	backgroundBlue      = 0x10
-	backgroundGreen     = 0x20
-	backgroundRed       = 0x40
-	backgroundIntensity = 0x80
-	backgroundMask      = (backgroundRed | backgroundBlue | backgroundGreen | backgroundIntensity)
-)
-
-type wchar uint16
-type short int16
-type dword uint32
-type word uint16
-
-type coord struct {
-	x short
-	y short
-}
-
-type smallRect struct {
-	left   short
-	top    short
-	right  short
-	bottom short
-}
-
-type consoleScreenBufferInfo struct {
-	size              coord
-	cursorPosition    coord
-	attributes        word
-	window            smallRect
-	maximumWindowSize coord
-}
-
-type consoleCursorInfo struct {
-	size    dword
-	visible int32
-}
-
-var (
-	kernel32                       = syscall.NewLazyDLL("kernel32.dll")
-	procGetConsoleScreenBufferInfo = kernel32.NewProc("GetConsoleScreenBufferInfo")
-	procSetConsoleTextAttribute    = kernel32.NewProc("SetConsoleTextAttribute")
-	procSetConsoleCursorPosition   = kernel32.NewProc("SetConsoleCursorPosition")
-	procFillConsoleOutputCharacter = kernel32.NewProc("FillConsoleOutputCharacterW")
-	procFillConsoleOutputAttribute = kernel32.NewProc("FillConsoleOutputAttribute")
-	procGetConsoleCursorInfo       = kernel32.NewProc("GetConsoleCursorInfo")
-	procSetConsoleCursorInfo       = kernel32.NewProc("SetConsoleCursorInfo")
-	procSetConsoleTitle            = kernel32.NewProc("SetConsoleTitleW")
-)
-
-// Writer provide colorable Writer to the console
-type Writer struct {
-	out     io.Writer
-	handle  syscall.Handle
-	oldattr word
-	oldpos  coord
-}
-
-// NewColorable return new instance of Writer which handle escape sequence from File.
-func NewColorable(file *os.File) io.Writer {
-	if file == nil {
-		panic("nil passed instead of *os.File to NewColorable()")
-	}
-
-	if isatty.IsTerminal(file.Fd()) {
-		var csbi consoleScreenBufferInfo
-		handle := syscall.Handle(file.Fd())
-		procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
-		return &Writer{out: file, handle: handle, oldattr: csbi.attributes, oldpos: coord{0, 0}}
-	}
-	return file
-}
-
-// NewColorableStdout return new instance of Writer which handle escape sequence for stdout.
-func NewColorableStdout() io.Writer {
-	return NewColorable(os.Stdout)
-}
-
-// NewColorableStderr return new instance of Writer which handle escape sequence for stderr.
-func NewColorableStderr() io.Writer {
-	return NewColorable(os.Stderr)
-}
-
-var color256 = map[int]int{
-	0:   0x000000,
-	1:   0x800000,
-	2:   0x008000,
-	3:   0x808000,
-	4:   0x000080,
-	5:   0x800080,
-	6:   0x008080,
-	7:   0xc0c0c0,
-	8:   0x808080,
-	9:   0xff0000,
-	10:  0x00ff00,
-	11:  0xffff00,
-	12:  0x0000ff,
-	13:  0xff00ff,
-	14:  0x00ffff,
-	15:  0xffffff,
-	16:  0x000000,
-	17:  0x00005f,
-	18:  0x000087,
-	19:  0x0000af,
-	20:  0x0000d7,
-	21:  0x0000ff,
-	22:  0x005f00,
-	23:  0x005f5f,
-	24:  0x005f87,
-	25:  0x005faf,
-	26:  0x005fd7,
-	27:  0x005fff,
-	28:  0x008700,
-	29:  0x00875f,
-	30:  0x008787,
-	31:  0x0087af,
-	32:  0x0087d7,
-	33:  0x0087ff,
-	34:  0x00af00,
-	35:  0x00af5f,
-	36:  0x00af87,
-	37:  0x00afaf,
-	38:  0x00afd7,
-	39:  0x00afff,
-	40:  0x00d700,
-	41:  0x00d75f,
-	42:  0x00d787,
-	43:  0x00d7af,
-	44:  0x00d7d7,
-	45:  0x00d7ff,
-	46:  0x00ff00,
-	47:  0x00ff5f,
-	48:  0x00ff87,
-	49:  0x00ffaf,
-	50:  0x00ffd7,
-	51:  0x00ffff,
-	52:  0x5f0000,
-	53:  0x5f005f,
-	54:  0x5f0087,
-	55:  0x5f00af,
-	56:  0x5f00d7,
-	57:  0x5f00ff,
-	58:  0x5f5f00,
-	59:  0x5f5f5f,
-	60:  0x5f5f87,
-	61:  0x5f5faf,
-	62:  0x5f5fd7,
-	63:  0x5f5fff,
-	64:  0x5f8700,
-	65:  0x5f875f,
-	66:  0x5f8787,
-	67:  0x5f87af,
-	68:  0x5f87d7,
-	69:  0x5f87ff,
-	70:  0x5faf00,
-	71:  0x5faf5f,
-	72:  0x5faf87,
-	73:  0x5fafaf,
-	74:  0x5fafd7,
-	75:  0x5fafff,
-	76:  0x5fd700,
-	77:  0x5fd75f,
-	78:  0x5fd787,
-	79:  0x5fd7af,
-	80:  0x5fd7d7,
-	81:  0x5fd7ff,
-	82:  0x5fff00,
-	83:  0x5fff5f,
-	84:  0x5fff87,
-	85:  0x5fffaf,
-	86:  0x5fffd7,
-	87:  0x5fffff,
-	88:  0x870000,
-	89:  0x87005f,
-	90:  0x870087,
-	91:  0x8700af,
-	92:  0x8700d7,
-	93:  0x8700ff,
-	94:  0x875f00,
-	95:  0x875f5f,
-	96:  0x875f87,
-	97:  0x875faf,
-	98:  0x875fd7,
-	99:  0x875fff,
-	100: 0x878700,
-	101: 0x87875f,
-	102: 0x878787,
-	103: 0x8787af,
-	104: 0x8787d7,
-	105: 0x8787ff,
-	106: 0x87af00,
-	107: 0x87af5f,
-	108: 0x87af87,
-	109: 0x87afaf,
-	110: 0x87afd7,
-	111: 0x87afff,
-	112: 0x87d700,
-	113: 0x87d75f,
-	114: 0x87d787,
-	115: 0x87d7af,
-	116: 0x87d7d7,
-	117: 0x87d7ff,
-	118: 0x87ff00,
-	119: 0x87ff5f,
-	120: 0x87ff87,
-	121: 0x87ffaf,
-	122: 0x87ffd7,
-	123: 0x87ffff,
-	124: 0xaf0000,
-	125: 0xaf005f,
-	126: 0xaf0087,
-	127: 0xaf00af,
-	128: 0xaf00d7,
-	129: 0xaf00ff,
-	130: 0xaf5f00,
-	131: 0xaf5f5f,
-	132: 0xaf5f87,
-	133: 0xaf5faf,
-	134: 0xaf5fd7,
-	135: 0xaf5fff,
-	136: 0xaf8700,
-	137: 0xaf875f,
-	138: 0xaf8787,
-	139: 0xaf87af,
-	140: 0xaf87d7,
-	141: 0xaf87ff,
-	142: 0xafaf00,
-	143: 0xafaf5f,
-	144: 0xafaf87,
-	145: 0xafafaf,
-	146: 0xafafd7,
-	147: 0xafafff,
-	148: 0xafd700,
-	149: 0xafd75f,
-	150: 0xafd787,
-	151: 0xafd7af,
-	152: 0xafd7d7,
-	153: 0xafd7ff,
-	154: 0xafff00,
-	155: 0xafff5f,
-	156: 0xafff87,
-	157: 0xafffaf,
-	158: 0xafffd7,
-	159: 0xafffff,
-	160: 0xd70000,
-	161: 0xd7005f,
-	162: 0xd70087,
-	163: 0xd700af,
-	164: 0xd700d7,
-	165: 0xd700ff,
-	166: 0xd75f00,
-	167: 0xd75f5f,
-	168: 0xd75f87,
-	169: 0xd75faf,
-	170: 0xd75fd7,
-	171: 0xd75fff,
-	172: 0xd78700,
-	173: 0xd7875f,
-	174: 0xd78787,
-	175: 0xd787af,
-	176: 0xd787d7,
-	177: 0xd787ff,
-	178: 0xd7af00,
-	179: 0xd7af5f,
-	180: 0xd7af87,
-	181: 0xd7afaf,
-	182: 0xd7afd7,
-	183: 0xd7afff,
-	184: 0xd7d700,
-	185: 0xd7d75f,
-	186: 0xd7d787,
-	187: 0xd7d7af,
-	188: 0xd7d7d7,
-	189: 0xd7d7ff,
-	190: 0xd7ff00,
-	191: 0xd7ff5f,
-	192: 0xd7ff87,
-	193: 0xd7ffaf,
-	194: 0xd7ffd7,
-	195: 0xd7ffff,
-	196: 0xff0000,
-	197: 0xff005f,
-	198: 0xff0087,
-	199: 0xff00af,
-	200: 0xff00d7,
-	201: 0xff00ff,
-	202: 0xff5f00,
-	203: 0xff5f5f,
-	204: 0xff5f87,
-	205: 0xff5faf,
-	206: 0xff5fd7,
-	207: 0xff5fff,
-	208: 0xff8700,
-	209: 0xff875f,
-	210: 0xff8787,
-	211: 0xff87af,
-	212: 0xff87d7,
-	213: 0xff87ff,
-	214: 0xffaf00,
-	215: 0xffaf5f,
-	216: 0xffaf87,
-	217: 0xffafaf,
-	218: 0xffafd7,
-	219: 0xffafff,
-	220: 0xffd700,
-	221: 0xffd75f,
-	222: 0xffd787,
-	223: 0xffd7af,
-	224: 0xffd7d7,
-	225: 0xffd7ff,
-	226: 0xffff00,
-	227: 0xffff5f,
-	228: 0xffff87,
-	229: 0xffffaf,
-	230: 0xffffd7,
-	231: 0xffffff,
-	232: 0x080808,
-	233: 0x121212,
-	234: 0x1c1c1c,
-	235: 0x262626,
-	236: 0x303030,
-	237: 0x3a3a3a,
-	238: 0x444444,
-	239: 0x4e4e4e,
-	240: 0x585858,
-	241: 0x626262,
-	242: 0x6c6c6c,
-	243: 0x767676,
-	244: 0x808080,
-	245: 0x8a8a8a,
-	246: 0x949494,
-	247: 0x9e9e9e,
-	248: 0xa8a8a8,
-	249: 0xb2b2b2,
-	250: 0xbcbcbc,
-	251: 0xc6c6c6,
-	252: 0xd0d0d0,
-	253: 0xdadada,
-	254: 0xe4e4e4,
-	255: 0xeeeeee,
-}
-
-// `\033]0;TITLESTR\007`
-func doTitleSequence(er *bytes.Reader) error {
-	var c byte
-	var err error
-
-	c, err = er.ReadByte()
-	if err != nil {
-		return err
-	}
-	if c != '0' && c != '2' {
-		return nil
-	}
-	c, err = er.ReadByte()
-	if err != nil {
-		return err
-	}
-	if c != ';' {
-		return nil
-	}
-	title := make([]byte, 0, 80)
-	for {
-		c, err = er.ReadByte()
-		if err != nil {
-			return err
-		}
-		if c == 0x07 || c == '\n' {
-			break
-		}
-		title = append(title, c)
-	}
-	if len(title) > 0 {
-		title8, err := syscall.UTF16PtrFromString(string(title))
-		if err == nil {
-			procSetConsoleTitle.Call(uintptr(unsafe.Pointer(title8)))
-		}
-	}
-	return nil
-}
-
-// Write write data on console
-func (w *Writer) Write(data []byte) (n int, err error) {
-	var csbi consoleScreenBufferInfo
-	procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
-
-	er := bytes.NewReader(data)
-	var bw [1]byte
-loop:
-	for {
-		c1, err := er.ReadByte()
-		if err != nil {
-			break loop
-		}
-		if c1 != 0x1b {
-			bw[0] = c1
-			w.out.Write(bw[:])
-			continue
-		}
-		c2, err := er.ReadByte()
-		if err != nil {
-			break loop
-		}
-
-		if c2 == ']' {
-			if err := doTitleSequence(er); err != nil {
-				break loop
-			}
-			continue
-		}
-		if c2 != 0x5b {
-			continue
-		}
-
-		var buf bytes.Buffer
-		var m byte
-		for {
-			c, err := er.ReadByte()
-			if err != nil {
-				break loop
-			}
-			if ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '@' {
-				m = c
-				break
-			}
-			buf.Write([]byte(string(c)))
-		}
-
-		switch m {
-		case 'A':
-			n, err = strconv.Atoi(buf.String())
-			if err != nil {
-				continue
-			}
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
-			csbi.cursorPosition.y -= short(n)
-			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
-		case 'B':
-			n, err = strconv.Atoi(buf.String())
-			if err != nil {
-				continue
-			}
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
-			csbi.cursorPosition.y += short(n)
-			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
-		case 'C':
-			n, err = strconv.Atoi(buf.String())
-			if err != nil {
-				continue
-			}
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
-			csbi.cursorPosition.x += short(n)
-			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
-		case 'D':
-			n, err = strconv.Atoi(buf.String())
-			if err != nil {
-				continue
-			}
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
-			csbi.cursorPosition.x -= short(n)
-			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
-		case 'E':
-			n, err = strconv.Atoi(buf.String())
-			if err != nil {
-				continue
-			}
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
-			csbi.cursorPosition.x = 0
-			csbi.cursorPosition.y += short(n)
-			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
-		case 'F':
-			n, err = strconv.Atoi(buf.String())
-			if err != nil {
-				continue
-			}
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
-			csbi.cursorPosition.x = 0
-			csbi.cursorPosition.y -= short(n)
-			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
-		case 'G':
-			n, err = strconv.Atoi(buf.String())
-			if err != nil {
-				continue
-			}
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
-			csbi.cursorPosition.x = short(n - 1)
-			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
-		case 'H', 'f':
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
-			if buf.Len() > 0 {
-				token := strings.Split(buf.String(), ";")
-				switch len(token) {
-				case 1:
-					n1, err := strconv.Atoi(token[0])
-					if err != nil {
-						continue
-					}
-					csbi.cursorPosition.y = short(n1 - 1)
-				case 2:
-					n1, err := strconv.Atoi(token[0])
-					if err != nil {
-						continue
-					}
-					n2, err := strconv.Atoi(token[1])
-					if err != nil {
-						continue
-					}
-					csbi.cursorPosition.x = short(n2 - 1)
-					csbi.cursorPosition.y = short(n1 - 1)
-				}
-			} else {
-				csbi.cursorPosition.y = 0
-			}
-			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
-		case 'J':
-			n := 0
-			if buf.Len() > 0 {
-				n, err = strconv.Atoi(buf.String())
-				if err != nil {
-					continue
-				}
-			}
-			var count, written dword
-			var cursor coord
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
-			switch n {
-			case 0:
-				cursor = coord{x: csbi.cursorPosition.x, y: csbi.cursorPosition.y}
-				count = dword(csbi.size.x - csbi.cursorPosition.x + (csbi.size.y-csbi.cursorPosition.y)*csbi.size.x)
-			case 1:
-				cursor = coord{x: csbi.window.left, y: csbi.window.top}
-				count = dword(csbi.size.x - csbi.cursorPosition.x + (csbi.window.top-csbi.cursorPosition.y)*csbi.size.x)
-			case 2:
-				cursor = coord{x: csbi.window.left, y: csbi.window.top}
-				count = dword(csbi.size.x - csbi.cursorPosition.x + (csbi.size.y-csbi.cursorPosition.y)*csbi.size.x)
-			}
-			procFillConsoleOutputCharacter.Call(uintptr(w.handle), uintptr(' '), uintptr(count), *(*uintptr)(unsafe.Pointer(&cursor)), uintptr(unsafe.Pointer(&written)))
-			procFillConsoleOutputAttribute.Call(uintptr(w.handle), uintptr(csbi.attributes), uintptr(count), *(*uintptr)(unsafe.Pointer(&cursor)), uintptr(unsafe.Pointer(&written)))
-		case 'K':
-			n := 0
-			if buf.Len() > 0 {
-				n, err = strconv.Atoi(buf.String())
-				if err != nil {
-					continue
-				}
-			}
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
-			var cursor coord
-			var count, written dword
-			switch n {
-			case 0:
-				cursor = coord{x: csbi.cursorPosition.x + 1, y: csbi.cursorPosition.y}
-				count = dword(csbi.size.x - csbi.cursorPosition.x - 1)
-			case 1:
-				cursor = coord{x: csbi.window.left, y: csbi.window.top + csbi.cursorPosition.y}
-				count = dword(csbi.size.x - csbi.cursorPosition.x)
-			case 2:
-				cursor = coord{x: csbi.window.left, y: csbi.window.top + csbi.cursorPosition.y}
-				count = dword(csbi.size.x)
-			}
-			procFillConsoleOutputCharacter.Call(uintptr(w.handle), uintptr(' '), uintptr(count), *(*uintptr)(unsafe.Pointer(&cursor)), uintptr(unsafe.Pointer(&written)))
-			procFillConsoleOutputAttribute.Call(uintptr(w.handle), uintptr(csbi.attributes), uintptr(count), *(*uintptr)(unsafe.Pointer(&cursor)), uintptr(unsafe.Pointer(&written)))
-		case 'm':
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
-			attr := csbi.attributes
-			cs := buf.String()
-			if cs == "" {
-				procSetConsoleTextAttribute.Call(uintptr(w.handle), uintptr(w.oldattr))
-				continue
-			}
-			token := strings.Split(cs, ";")
-			for i := 0; i < len(token); i++ {
-				ns := token[i]
-				if n, err = strconv.Atoi(ns); err == nil {
-					switch {
-					case n == 0 || n == 100:
-						attr = w.oldattr
-					case 1 <= n && n <= 5:
-						attr |= foregroundIntensity
-					case n == 7:
-						attr = ((attr & foregroundMask) << 4) | ((attr & backgroundMask) >> 4)
-					case n == 22 || n == 25:
-						attr |= foregroundIntensity
-					case n == 27:
-						attr = ((attr & foregroundMask) << 4) | ((attr & backgroundMask) >> 4)
-					case 30 <= n && n <= 37:
-						attr &= backgroundMask
-						if (n-30)&1 != 0 {
-							attr |= foregroundRed
-						}
-						if (n-30)&2 != 0 {
-							attr |= foregroundGreen
-						}
-						if (n-30)&4 != 0 {
-							attr |= foregroundBlue
-						}
-					case n == 38: // set foreground color.
-						if i < len(token)-2 && (token[i+1] == "5" || token[i+1] == "05") {
-							if n256, err := strconv.Atoi(token[i+2]); err == nil {
-								if n256foreAttr == nil {
-									n256setup()
-								}
-								attr &= backgroundMask
-								attr |= n256foreAttr[n256]
-								i += 2
-							}
-						} else {
-							attr = attr & (w.oldattr & backgroundMask)
-						}
-					case n == 39: // reset foreground color.
-						attr &= backgroundMask
-						attr |= w.oldattr & foregroundMask
-					case 40 <= n && n <= 47:
-						attr &= foregroundMask
-						if (n-40)&1 != 0 {
-							attr |= backgroundRed
-						}
-						if (n-40)&2 != 0 {
-							attr |= backgroundGreen
-						}
-						if (n-40)&4 != 0 {
-							attr |= backgroundBlue
-						}
-					case n == 48: // set background color.
-						if i < len(token)-2 && token[i+1] == "5" {
-							if n256, err := strconv.Atoi(token[i+2]); err == nil {
-								if n256backAttr == nil {
-									n256setup()
-								}
-								attr &= foregroundMask
-								attr |= n256backAttr[n256]
-								i += 2
-							}
-						} else {
-							attr = attr & (w.oldattr & foregroundMask)
-						}
-					case n == 49: // reset foreground color.
-						attr &= foregroundMask
-						attr |= w.oldattr & backgroundMask
-					case 90 <= n && n <= 97:
-						attr = (attr & backgroundMask)
-						attr |= foregroundIntensity
-						if (n-90)&1 != 0 {
-							attr |= foregroundRed
-						}
-						if (n-90)&2 != 0 {
-							attr |= foregroundGreen
-						}
-						if (n-90)&4 != 0 {
-							attr |= foregroundBlue
-						}
-					case 100 <= n && n <= 107:
-						attr = (attr & foregroundMask)
-						attr |= backgroundIntensity
-						if (n-100)&1 != 0 {
-							attr |= backgroundRed
-						}
-						if (n-100)&2 != 0 {
-							attr |= backgroundGreen
-						}
-						if (n-100)&4 != 0 {
-							attr |= backgroundBlue
-						}
-					}
-					procSetConsoleTextAttribute.Call(uintptr(w.handle), uintptr(attr))
-				}
-			}
-		case 'h':
-			var ci consoleCursorInfo
-			cs := buf.String()
-			if cs == "5>" {
-				procGetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci)))
-				ci.visible = 0
-				procSetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci)))
-			} else if cs == "?25" {
-				procGetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci)))
-				ci.visible = 1
-				procSetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci)))
-			}
-		case 'l':
-			var ci consoleCursorInfo
-			cs := buf.String()
-			if cs == "5>" {
-				procGetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci)))
-				ci.visible = 1
-				procSetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci)))
-			} else if cs == "?25" {
-				procGetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci)))
-				ci.visible = 0
-				procSetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci)))
-			}
-		case 's':
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
-			w.oldpos = csbi.cursorPosition
-		case 'u':
-			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&w.oldpos)))
-		}
-	}
-
-	return len(data), nil
-}
-
-type consoleColor struct {
-	rgb       int
-	red       bool
-	green     bool
-	blue      bool
-	intensity bool
-}
-
-func (c consoleColor) foregroundAttr() (attr word) {
-	if c.red {
-		attr |= foregroundRed
-	}
-	if c.green {
-		attr |= foregroundGreen
-	}
-	if c.blue {
-		attr |= foregroundBlue
-	}
-	if c.intensity {
-		attr |= foregroundIntensity
-	}
-	return
-}
-
-func (c consoleColor) backgroundAttr() (attr word) {
-	if c.red {
-		attr |= backgroundRed
-	}
-	if c.green {
-		attr |= backgroundGreen
-	}
-	if c.blue {
-		attr |= backgroundBlue
-	}
-	if c.intensity {
-		attr |= backgroundIntensity
-	}
-	return
-}
-
-var color16 = []consoleColor{
-	{0x000000, false, false, false, false},
-	{0x000080, false, false, true, false},
-	{0x008000, false, true, false, false},
-	{0x008080, false, true, true, false},
-	{0x800000, true, false, false, false},
-	{0x800080, true, false, true, false},
-	{0x808000, true, true, false, false},
-	{0xc0c0c0, true, true, true, false},
-	{0x808080, false, false, false, true},
-	{0x0000ff, false, false, true, true},
-	{0x00ff00, false, true, false, true},
-	{0x00ffff, false, true, true, true},
-	{0xff0000, true, false, false, true},
-	{0xff00ff, true, false, true, true},
-	{0xffff00, true, true, false, true},
-	{0xffffff, true, true, true, true},
-}
-
-type hsv struct {
-	h, s, v float32
-}
-
-func (a hsv) dist(b hsv) float32 {
-	dh := a.h - b.h
-	switch {
-	case dh > 0.5:
-		dh = 1 - dh
-	case dh < -0.5:
-		dh = -1 - dh
-	}
-	ds := a.s - b.s
-	dv := a.v - b.v
-	return float32(math.Sqrt(float64(dh*dh + ds*ds + dv*dv)))
-}
-
-func toHSV(rgb int) hsv {
-	r, g, b := float32((rgb&0xFF0000)>>16)/256.0,
-		float32((rgb&0x00FF00)>>8)/256.0,
-		float32(rgb&0x0000FF)/256.0
-	min, max := minmax3f(r, g, b)
-	h := max - min
-	if h > 0 {
-		if max == r {
-			h = (g - b) / h
-			if h < 0 {
-				h += 6
-			}
-		} else if max == g {
-			h = 2 + (b-r)/h
-		} else {
-			h = 4 + (r-g)/h
-		}
-	}
-	h /= 6.0
-	s := max - min
-	if max != 0 {
-		s /= max
-	}
-	v := max
-	return hsv{h: h, s: s, v: v}
-}
-
-type hsvTable []hsv
-
-func toHSVTable(rgbTable []consoleColor) hsvTable {
-	t := make(hsvTable, len(rgbTable))
-	for i, c := range rgbTable {
-		t[i] = toHSV(c.rgb)
-	}
-	return t
-}
-
-func (t hsvTable) find(rgb int) consoleColor {
-	hsv := toHSV(rgb)
-	n := 7
-	l := float32(5.0)
-	for i, p := range t {
-		d := hsv.dist(p)
-		if d < l {
-			l, n = d, i
-		}
-	}
-	return color16[n]
-}
-
-func minmax3f(a, b, c float32) (min, max float32) {
-	if a < b {
-		if b < c {
-			return a, c
-		} else if a < c {
-			return a, b
-		} else {
-			return c, b
-		}
-	} else {
-		if a < c {
-			return b, c
-		} else if b < c {
-			return b, a
-		} else {
-			return c, a
-		}
-	}
-}
-
-var n256foreAttr []word
-var n256backAttr []word
-
-func n256setup() {
-	n256foreAttr = make([]word, 256)
-	n256backAttr = make([]word, 256)
-	t := toHSVTable(color16)
-	for i, rgb := range color256 {
-		c := t.find(rgb)
-		n256foreAttr[i] = c.foregroundAttr()
-		n256backAttr[i] = c.backgroundAttr()
-	}
-}

vendor/github.com/mattn/go-colorable/noncolorable.go

@@ -1,55 +0,0 @@
-package colorable
-
-import (
-	"bytes"
-	"io"
-)
-
-// NonColorable hold writer but remove escape sequence.
-type NonColorable struct {
-	out io.Writer
-}
-
-// NewNonColorable return new instance of Writer which remove escape sequence from Writer.
-func NewNonColorable(w io.Writer) io.Writer {
-	return &NonColorable{out: w}
-}
-
-// Write write data on console
-func (w *NonColorable) Write(data []byte) (n int, err error) {
-	er := bytes.NewReader(data)
-	var bw [1]byte
-loop:
-	for {
-		c1, err := er.ReadByte()
-		if err != nil {
-			break loop
-		}
-		if c1 != 0x1b {
-			bw[0] = c1
-			w.out.Write(bw[:])
-			continue
-		}
-		c2, err := er.ReadByte()
-		if err != nil {
-			break loop
-		}
-		if c2 != 0x5b {
-			continue
-		}
-
-		var buf bytes.Buffer
-		for {
-			c, err := er.ReadByte()
-			if err != nil {
-				break loop
-			}
-			if ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '@' {
-				break
-			}
-			buf.Write([]byte(string(c)))
-		}
-	}
-
-	return len(data), nil
-}

vendor/github.com/mattn/go-isatty/LICENSE

@@ -1,9 +0,0 @@
-Copyright (c) Yasuhiro MATSUMOTO <mattn.jp@gmail.com>
-
-MIT License (Expat)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

vendor/github.com/mattn/go-isatty/doc.go

@@ -1,2 +0,0 @@
-// Package isatty implements interface to isatty
-package isatty

vendor/github.com/mattn/go-isatty/isatty_appengine.go

@@ -1,15 +0,0 @@
-// +build appengine
-
-package isatty
-
-// IsTerminal returns true if the file descriptor is terminal which
-// is always false on on appengine classic which is a sandboxed PaaS.
-func IsTerminal(fd uintptr) bool {
-	return false
-}
-
-// IsCygwinTerminal() return true if the file descriptor is a cygwin or msys2
-// terminal. This is also always false on this environment.
-func IsCygwinTerminal(fd uintptr) bool {
-	return false
-}