reviewdog

package module
v0.21.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Sep 13, 2026 License: MIT Imports: 17 Imported by: 19

README

reviewdog - A code review dog who keeps your codebase healthy.


reviewdog provides a way to post review comments to code hosting services, such as GitHub, automatically by integrating with any linter tools with ease. It uses an output of lint tools and posts them as a comment if findings are in the diff of patches to review.

reviewdog also supports running in the local environment to filter the output of lint tools by diff.

design doc

Table of Contents

github-pr-check sample comment in pull-request commit status sample-comment.png reviewdog-local-demo.gif

Installation

# Install the latest version. (Install it into ./bin/ by default).
$ curl -sfL https://raw.githubusercontent.com/reviewdog/reviewdog/fd59714416d6d9a1c0692d872e38e7f8448df4fc/install.sh | sh -s

# Specify installation directory ($(go env GOPATH)/bin/) and version.
$ curl -sfL https://raw.githubusercontent.com/reviewdog/reviewdog/fd59714416d6d9a1c0692d872e38e7f8448df4fc/install.sh | sh -s -- -b $(go env GOPATH)/bin [vX.Y.Z]

# In alpine linux (as it does not come with curl by default)
$ wget -O - -q https://raw.githubusercontent.com/reviewdog/reviewdog/fd59714416d6d9a1c0692d872e38e7f8448df4fc/install.sh | sh -s [vX.Y.Z]

Nightly releases

You can also use nightly reviewdog release to try the latest reviewdog improvements every day!

$ curl -sfL https://raw.githubusercontent.com/reviewdog/nightly/30fccfe9f47f7e6fd8b3c38aa0da11a6c9f04de7/install.sh | sh -s -- -b $(go env GOPATH)/bin

GitHub Action: reviewdog/action-setup

steps:
- uses: reviewdog/action-setup@d8edfce3dd5e1ec6978745e801f9c50b5ef80252 # v1.4.0
  with:
    reviewdog_version: latest # Optional. [latest,nightly,v.X.Y.Z]

homebrew / linuxbrew

You can also install reviewdog using brew:

$ brew install --cask reviewdog/tap/reviewdog
$ brew upgrade --cask reviewdog/tap/reviewdog

Scoop on Windows

> scoop install reviewdog

Build with go install

$ go install github.com/reviewdog/reviewdog/cmd/reviewdog@latest

Input Format

'errorformat'

reviewdog accepts any compiler or linter result from stdin and parses it with scan-f like 'errorformat', which is the port of Vim's errorformat feature.

For example, if the result format is {file}:{line number}:{column number}: {message}, errorformat should be %f:%l:%c: %m and you can pass it as -efm arguments.

$ golint ./...
comment_iowriter.go:11:6: exported type CommentWriter should have comment or be unexported
$ golint ./... | reviewdog -efm="%f:%l:%c: %m" -diff="git diff FETCH_HEAD"
name description
%f file name
%l line number
%c column number
%m error message
%% the single '%' character
... ...

Please see reviewdog/errorformat and :h errorformat if you want to deal with a more complex output. 'errorformat' can handle more complex output like a multi-line error message.

You can also try errorformat on the Playground!

With this 'errorformat' feature, reviewdog can support any tool output with ease.

Available pre-defined 'errorformat'

But, you don't have to write 'errorformat' in many cases. reviewdog supports pre-defined errorformat for major tools.

You can find available errorformat name by reviewdog -list and you can use it with -f={name}.

$ reviewdog -list
golint          linter for Go source code                                       - https://github.com/golang/lint
govet           Vet examines Go source code and reports suspicious problems     - https://golang.org/cmd/vet/
sbt             the interactive build tool                                      - http://www.scala-sbt.org/
...

$ golint ./... | reviewdog -f=golint -diff="git diff FETCH_HEAD"

You can add supported pre-defined 'errorformat' by contributing to reviewdog/errorformat

Reviewdog Diagnostic Format (RDFormat)

reviewdog supports Reviewdog Diagnostic Format (RDFormat) as a generic diagnostic format and it supports both rdjson and rdjsonl formats.

This rdformat supports rich features like multiline ranged comments, severity, rule code with URL, and code suggestions.

$ <linter> | <convert-to-rdjson> | reviewdog -f=rdjson -reporter=github-pr-review
# or
$ <linter> | <convert-to-rdjsonl> | reviewdog -f=rdjsonl -reporter=github-pr-review
Example: ESLint with RDFormat

eslint reviewdog rdjson demo

You can use eslint-formatter-rdjson to output rdjson as eslint output format.

$ npm install --save-dev eslint-formatter-rdjson
$ eslint -f rdjson . | reviewdog -f=rdjson -reporter=github-pr-review

Or you can also use reviewdog/action-eslint for GitHub Actions.

Diff

reviewdog with gofmt example

reviewdog supports diff (unified format) as an input format especially useful for code suggestions. reviewdog can integrate with any code suggestions tools or formatters to report suggestions.

-f.diff.strip: option for -f=diff: strip NUM leading components from diff file names (equivalent to 'patch -p') (default is 1 for git diff) (default 1)

$ <any-code-fixer/formatter> # e.g. eslint --fix, gofmt
$ TMPFILE=$(mktemp)
$ git diff >"${TMPFILE}"
$ git stash -u && git stash drop
$ reviewdog -f=diff -f.diff.strip=1 -reporter=github-pr-review < "${TMPFILE}"

Or you can also use reviewdog/action-suggester for GitHub Actions.

If diagnostic tools support diff output format, you can pipe the diff directly.

$ gofmt -s -d . | reviewdog -name="gofmt" -f=diff -f.diff.strip=0 -reporter=github-pr-review
$ shellcheck -f diff $(shfmt -f .) | reviewdog -f=diff

checkstyle format

reviewdog also accepts checkstyle XML format as well. If the linter supports checkstyle format as a report format, you can use -f=checkstyle instead of using 'errorformat'.

# Local
$ eslint -f checkstyle . | reviewdog -f=checkstyle -diff="git diff"

# CI (overwrite tool name which is shown in review comment by -name arg)
$ eslint -f checkstyle . | reviewdog -f=checkstyle -name="eslint" -reporter=github-check

Also, if you want to pass other Json/XML/etc... format to reviewdog, you can write a converter.

$ <linter> | <convert-to-checkstyle> | reviewdog -f=checkstyle -name="<linter>" -reporter=github-pr-check

SARIF format

reviewdog supports SARIF 2.1.0 JSON format. You can use reviewdog with -f=sarif option.

# Local
$ eslint -f @microsoft/eslint-formatter-sarif . | reviewdog -f=sarif -diff="git diff"

Code Suggestions

eslint reviewdog suggestion demo reviewdog with gofmt example

reviewdog supports code suggestions feature with rdformat or diff input. You can also use reviewdog/action-suggester for GitHub Actions.

reviewdog can suggest code changes along with diagnostic results if a diagnostic tool supports code suggestions data. You can integrate reviewdog with any code fixing tools and any code formatter with diff input as well.

Code Suggestions Support Table

Note that not all reporters provide support for code suggestions.

-reporter Suggestion support
local NO [1]
github-check NO [2]
github-pr-check NO [2]
github-annotations NO [2]
github-pr-annotations NO [2]
github-pr-review OK
gitlab-mr-discussion OK
gitlab-mr-commit NO [2]
gerrit-change-review NO [1]
bitbucket-code-report NO [2]
gitea-pr-review NO [2]
  • [1] The reporter service supports the code suggestion feature, but reviewdog does not support it yet. See #678 for the status.
  • [2] The reporter service itself doesn't support the code suggestion feature.

reviewdog config file

reviewdog can also be controlled via the .reviewdog.yml configuration file instead of "-f" or "-efm" arguments.

With .reviewdog.yml, you can run the same commands for both CI service and local environment including editor integration with ease.

.reviewdog.yml
runner:
  <tool-name>:
    cmd: <command> # (required)
    errorformat: # (optional if you use `format`)
      - <list of errorformat>
    format: <format-name> # (optional if you use `errorformat`. e.g. golint,rdjson,rdjsonl)
    name: <tool-name> # (optional. you can overwrite <tool-name> defined by runner key)
    level: <level> # (optional. same as -level flag. [info,warning,error])

  # examples
  golint:
    cmd: golint ./...
    errorformat:
      - "%f:%l:%c: %m"
    level: warning
  govet:
    cmd: go vet -all .
    format: govet
  your-awesome-linter:
    cmd: awesome-linter run
    format: rdjson
    name: AwesomeLinter

$ reviewdog -diff="git diff FETCH_HEAD"
project/run_test.go:61:28: [golint] error strings should not end with punctuation
project/run.go:57:18: [errcheck]        defer os.Setenv(name, os.Getenv(name))
project/run.go:58:12: [errcheck]        os.Setenv(name, "")
# You can use -runners to run only specified runners.
$ reviewdog -diff="git diff FETCH_HEAD" -runners=golint,govet
project/run_test.go:61:28: [golint] error strings should not end with punctuation
# You can use -conf to specify config file path.
$ reviewdog -conf=./.reviewdog.yml -reporter=github-pr-check

Output format for project config based run is one of the following formats.

  • <file>: [<tool name>] <message>
  • <file>:<lnum>: [<tool name>] <message>
  • <file>:<lnum>:<col>: [<tool name>] <message>

Reporters

reviewdog can report results both in the local environment and review services as continuous integration.

Reporter: Local (-reporter=local) [default]

reviewdog can find newly introduced findings by filtering linter results using diff. You can pass the diff command as -diff arg.

$ golint ./... | reviewdog -f=golint -diff="git diff FETCH_HEAD"

Reporter: GitHub PR Checks (-reporter=github-pr-check)

github-pr-check sample annotation with option 1 github-pr-check sample

github-pr-check reporter reports results to GitHub Checks.

You can change the report level for this reporter by level field in config file or -level flag. You can control GitHub status check results with this feature. (default: error)

Level GitHub Status
info neutral
warning neutral
error failure

There are two options to use this reporter.

Option 1) Run reviewdog from GitHub Actions w/ secrets.GITHUB_TOKEN

Example: .github/workflows/reviewdog.yml

- name: Run reviewdog
  env:
    REVIEWDOG_GITHUB_API_TOKEN: ${{ secrets.GITHUB_TOKEN }}
  run: |
    golint ./... | reviewdog -f=golint -reporter=github-pr-check

See GitHub Actions section too. You can also use public reviewdog GitHub Actions.

Option 2) Install reviewdog GitHub Apps

reviewdog CLI sends a request to reviewdog GitHub App server and the server post results as GitHub Checks, because Check API is only supported for GitHub App and GitHub Actions.

  1. Install reviewdog Apps. https://github.com/apps/reviewdog
  2. Set REVIEWDOG_TOKEN.
  • Get token from https://reviewdog.app/gh/{owner}/{repo-name}.
$ export REVIEWDOG_TOKEN="<token>"
$ reviewdog -reporter=github-pr-check

Caution

As described above, github-pr-check reporter with Option 2 depends on reviewdog GitHub App server. The server is running with haya14busa's pocket money for now and I may break things, so I cannot ensure that the server is running 24h and 365 days.

UPDATE: Started getting support by opencollective and GitHub sponsor. See Supporting reviewdog

You can use github-pr-review reporter or use run reviewdog under GitHub Actions if you don't want to depend on reviewdog server.

Reporter: GitHub Checks (-reporter=github-check)

It's basically the same as -reporter=github-pr-check except it works not only for Pull Request but also for commit.

sample comment outside diff

You can create reviewdog badge for this reporter.

Reporter: GitHub PullRequest review comment (-reporter=github-pr-review)

sample-comment.png

github-pr-review reporter reports results to GitHub PullRequest review comments using GitHub Personal API Access Token. GitHub Enterprise is supported too.

$ export REVIEWDOG_GITHUB_API_TOKEN="<token>"
$ reviewdog -reporter=github-pr-review

For GitHub Enterprise, set the API endpoint by an environment variable.

$ export GITHUB_API="https://example.githubenterprise.com/api/v3/"
$ export REVIEWDOG_INSECURE_SKIP_VERIFY=true # set this as you need to skip verifying SSL

See GitHub Actions section too if you can use GitHub Actions. You can also use public reviewdog GitHub Actions.

Reporter: GitHub Annotations (-reporter=github-annotations)

github-annotations uses the GitHub Actions annotation format to output errors and warnings to stdout e.g.

::error line=11,col=41,file=app/index.md::[vale] reported by reviewdog 🐶%0A[demo.Spelling] Did you really mean 'boobarbaz'?%0A%0ARaw Output:%0A{"message": "[demo.Spelling] Did you really mean 'boobarbaz'?", "location": {"path": "app/index.md", "range": {"start": {"line": 11, "column": 41}}}, "severity": "ERROR"}

This reporter requires a valid GitHub API token to generate a diff, but will not use the token to report errors.

Reporter: GitHub PR Annotations (-reporter=github-pr-annotations)

Same as github-annotations but only works for Pull Requests.

Reporter: GitLab MergeRequest discussions (-reporter=gitlab-mr-discussion)

gitlab-mr-discussion sample

Required GitLab version: >= v10.8.0

gitlab-mr-discussion reporter reports results to GitLab MergeRequest discussions using GitLab Personal API Access token. Get the token with api scope from https://gitlab.com/profile/personal_access_tokens.

$ export REVIEWDOG_GITLAB_API_TOKEN="<token>"
$ reviewdog -reporter=gitlab-mr-discussion

The CI_API_V4_URL environment variable, defined automatically by Gitlab CI (v11.7 onwards), will be used to find out the Gitlab API URL.

Alternatively, GITLAB_API can also be defined, in which case it will take precedence over CI_API_V4_URL.

$ export GITLAB_API="https://example.gitlab.com/api/v4"
$ export REVIEWDOG_INSECURE_SKIP_VERIFY=true # set this as you need to skip verifying SSL

Reporter: GitLab MergeRequest commit (-reporter=gitlab-mr-commit)

gitlab-mr-commit is similar to gitlab-mr-discussion reporter but reports results to each commit in GitLab MergeRequest.

gitlab-mr-discussion is recommended, but you can use gitlab-mr-commit reporter if your GitLab version is under v10.8.0.

$ export REVIEWDOG_GITLAB_API_TOKEN="<token>"
$ reviewdog -reporter=gitlab-mr-commit

Reporter: Gerrit Change review (-reporter=gerrit-change-review)

gerrit-change-review reporter reports results to Gerrit Change using Gerrit Rest APIs.

The reporter supports Basic Authentication and Git-cookie based authentication for reporting results.

Set GERRIT_USERNAME and GERRIT_PASSWORD environment variables for basic authentication, and put GIT_GITCOOKIE_PATH for git cookie-based authentication.

$ export GERRIT_CHANGE_ID=changeID
$ export GERRIT_REVISION_ID=revisionID
$ export GERRIT_BRANCH=master
$ export GERRIT_ADDRESS=http://<gerrit-host>:<gerrit-port>
$ reviewdog -reporter=gerrit-change-review

Reporter: Bitbucket Code Insights Reports (-reporter=bitbucket-code-report)

bitbucket-code-report bitbucket-code-annotations

bitbucket-code-report generates the annotated Bitbucket Code Insights report.

For now, only the no-filter mode is supported, so the whole project is scanned on every run. Reports are stored per commit and can be viewed per commit from Bitbucket Pipelines UI or in Pull Request. In the Pull Request UI affected code lines will be annotated in the diff, as well as you will be able to filter the annotations by This pull request or All.

If running from Bitbucket Pipelines, no additional configuration is needed (even credentials). If running locally or from some other CI system you would need to provide Bitbucket API credentials:

  • For Basic Auth you need to set the following env variables: BITBUCKET_USER and BITBUCKET_PASSWORD
  • For AccessToken Auth you need to set BITBUCKET_ACCESS_TOKEN
$ export BITBUCKET_USER="my_user"
$ export BITBUCKET_PASSWORD="my_password"
$ reviewdog -reporter=bitbucket-code-report

To post a report to the Bitbucket Server use BITBUCKET_SERVER_URL variable:

$ export BITBUCKET_USER="my_user"
$ export BITBUCKET_PASSWORD="my_password"
$ export BITBUCKET_SERVER_URL="https://bitbucket.my-company.com"
$ reviewdog -reporter=bitbucket-code-report

Supported CI services

GitHub Actions

Example: .github/workflows/reviewdog.yml

name: reviewdog
on: [pull_request]
jobs:
  reviewdog:
    name: reviewdog
    runs-on: ubuntu-latest
    steps:
      # ...
      - uses: reviewdog/action-setup@d8edfce3dd5e1ec6978745e801f9c50b5ef80252 # v1.4.0
        with:
          reviewdog_version: latest # Optional. [latest,nightly,v.X.Y.Z]
      - name: Run reviewdog
        env:
          REVIEWDOG_GITHUB_API_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: |
          reviewdog -reporter=github-pr-check -runners=golint,govet
          # or
          reviewdog -reporter=github-pr-review -runners=golint,govet
Example (github-check reporter):

.github/workflows/reviewdog

Only github-check reporter can run on the push event too.

name: reviewdog (github-check)
on:
  push:
    branches:
      - master
  pull_request:

jobs:
  reviewdog:
    name: reviewdog
    runs-on: ubuntu-latest
    steps:
      # ...
      - name: Run reviewdog
        env:
          REVIEWDOG_GITHUB_API_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: |
          reviewdog -reporter=github-check -runners=golint,govet
Public Reviewdog GitHub Actions

You can use public GitHub Actions to start using reviewdog with ease! 🎉 ▶ 🎉

... and more on GitHub Marketplace.

Missing actions? Check out reviewdog/action-template and create a new reviewdog action!

Please open a Pull Request to add your created reviewdog actions here ✨. I can also put your repositories under reviewdog org and co-maintain the actions. Example: action-tflint.

Graceful Degradation for Pull Requests from forked repositories

Graceful Degradation example

GITHUB_TOKEN for Pull Requests from a forked repository doesn't have write access to Check API nor Review API due to GitHub Actions restriction.

Instead, reviewdog uses Logging commands of GitHub Actions to post results as annotations similar to github-pr-check reporter.

Note that there is a limitation for annotations created by logging commands, such as max # of annotations per run. You can check GitHub Actions log to see full results in such cases.

reviewdog badge reviewdog

As github-check reporter support running on commit, we can create reviewdog GitHub Action badge to check the result against master commit for example. 🎉

Example:

<!-- Replace <OWNER> and <REPOSITORY>. It assumes workflow name is "reviewdog" -->
[![reviewdog](https://github.com/<OWNER>/<REPOSITORY>/workflows/reviewdog/badge.svg?branch=master&event=push)](https://github.com/<OWNER>/<REPOSITORY>/actions?query=workflow%3Areviewdog+event%3Apush+branch%3Amaster)

Travis CI

Travis CI (-reporter=github-pr-review)

Store GitHub API token by travis encryption keys.

$ gem install travis
$ travis encrypt REVIEWDOG_GITHUB_API_TOKEN=<token> --add env.global

Example:

env:
  global:
    - secure: <token>

install:
  - mkdir -p ~/bin/ && export PATH="~/bin/:$PATH"
  - curl -sfL https://raw.githubusercontent.com/reviewdog/reviewdog/fd59714416d6d9a1c0692d872e38e7f8448df4fc/install.sh| sh -s -- -b ~/bin

script:
  - >-
    golint ./... | reviewdog -f=golint -reporter=github-pr-review

Examples

Circle CI

Store REVIEWDOG_GITHUB_API_TOKEN (or REVIEWDOG_TOKEN for github-pr-check) in Environment variables - CircleCI

.circleci/config.yml sample
version: 2
jobs:
  build:
    docker:
      - image: golang:latest
    steps:
      - checkout
      - run: curl -sfL https://raw.githubusercontent.com/reviewdog/reviewdog/fd59714416d6d9a1c0692d872e38e7f8448df4fc/install.sh| sh -s -- -b ./bin
      - run: go vet ./... 2>&1 | ./bin/reviewdog -f=govet -reporter=github-pr-review

      # Deprecated: prefer GitHub Actions to use github-pr-check reporter.
      - run: go vet ./... 2>&1 | ./bin/reviewdog -f=govet -reporter=github-pr-check

GitLab CI

Store REVIEWDOG_GITLAB_API_TOKEN in GitLab CI variable.

.gitlab-ci.yml sample
reviewdog:
  script:
    - reviewdog -reporter=gitlab-mr-discussion
    # Or
    - reviewdog -reporter=gitlab-mr-commit

Bitbucket Pipelines

No additional configuration is needed.

bitbucket-pipelines.yml sample
pipelines:
  default:
    - step:
        name: Reviewdog
        image: golangci/golangci-lint:v1.31-alpine
        script:
          - wget -O - -q https://raw.githubusercontent.com/reviewdog/reviewdog/fd59714416d6d9a1c0692d872e38e7f8448df4fc/install.sh | 
              sh -s -- -b $(go env GOPATH)/bin
          - golangci-lint run --out-format=line-number ./... | reviewdog -f=golangci-lint -reporter=bitbucket-code-report

Common (Jenkins, local, etc...)

You can use reviewdog to post review comments from anywhere with following environment variables.

name description
CI_PULL_REQUEST Pull Request number (e.g. 14)
CI_COMMIT SHA1 for the current build
CI_REPO_OWNER repository owner (e.g. "reviewdog" for https://github.com/reviewdog/errorformat)
CI_REPO_NAME repository name (e.g. "errorformat" for https://github.com/reviewdog/errorformat)
CI_BRANCH [optional] branch of the commit 
$ export CI_PULL_REQUEST=14
$ export CI_REPO_OWNER=haya14busa
$ export CI_REPO_NAME=reviewdog
$ export CI_COMMIT=$(git rev-parse HEAD)

and set a token if required.

$ REVIEWDOG_TOKEN="<token>"
$ REVIEWDOG_GITHUB_API_TOKEN="<token>"
$ REVIEWDOG_GITLAB_API_TOKEN="<token>"

If a CI service doesn't provide information such as Pull Request ID - reviewdog can guess it by a branch name and commit SHA. Just pass the flag guess:

$ reviewdog -conf=.reviewdog.yml -reporter=github-pr-check -guess
Jenkins with GitHub pull request builder plugin
$ export CI_PULL_REQUEST=${ghprbPullId}
$ export CI_REPO_OWNER=haya14busa
$ export CI_REPO_NAME=reviewdog
$ export CI_COMMIT=${ghprbActualCommit}
$ export REVIEWDOG_INSECURE_SKIP_VERIFY=true # set this as you need

# To submit via reviewdog server using github-pr-check reporter
$ REVIEWDOG_TOKEN="<token>" reviewdog -reporter=github-pr-check
# Or, to submit directly via API using github-pr-review reporter
$ REVIEWDOG_GITHUB_API_TOKEN="<token>" reviewdog -reporter=github-pr-review
# Or, to submit directly via API using github-pr-check reporter (requires GitHub App Account configured)
$ REVIEWDOG_SKIP_DOGHOUSE=true REVIEWDOG_GITHUB_API_TOKEN="<token>" reviewdog -reporter=github-pr-check

Exit codes

By default (-fail-level=none) reviewdog will return 0 as exit code even if it finds errors. reviewdog will exit with code 1 with -fail-level=[any,info,warning,error] flag if it finds at least 1 issue with severity greater than or equal to the given level. This can be helpful when you are using it as a step in your CI pipeline and want to mark the step failed if any error found by linter.

You can also use -level flag to configure default report revel.

Filter mode

reviewdog filter results by diff and you can control how reviewdog filter results by -filter-mode flag. Available filter modes are as below.

added (default)

Filter results by added/modified lines.

diff_context

Filter results by diff context. i.e. changed lines +-N lines (N=3 for example).

file

Filter results by added/modified file. i.e. reviewdog will report results as long as they are in added/modified file even if the results are not in actual diff.

nofilter

Do not filter any results. Useful for posting results as comments as much as possible and check other results in console at the same time.

-fail-on-error also works with any filter-mode and can catch all results from any linters with nofilter mode.

Example:

$ reviewdog -reporter=github-pr-review -filter-mode=nofilter -fail-on-error

Filter Mode Support Table

Note that not all reporters provide full support for filter mode due to API limitation. e.g. github-pr-review reporter uses GitHub Review API but this API don't support posting comments outside diff context, so reviewdog will use Check annotation as fallback to post those comments [1].

-reporter \ -filter-mode added diff_context file nofilter
local OK OK OK OK
github-check OK OK OK OK
github-pr-check OK OK OK OK
github-pr-review OK OK Partially Supported [1] Partially Supported [1]
github-pr-annotations OK OK OK OK
gitlab-mr-discussion OK OK OK Partially Supported [2]
gitlab-mr-commit OK Partially Supported [2] Partially Supported [2] Partially Supported [2]
gerrit-change-review OK OK? [3] OK? [3] Partially Supported? [2][3]
bitbucket-code-report NO [4] NO [4] NO [4] OK
gitea-pr-review OK OK Partially Supported [5] Partially Supported [5]
  • [1] Report results that are outside the diff file with Check annotation as fallback if it's running in GitHub actions instead of Review API (comments). All results will be reported to console as well.
  • [2] Report results that are outside the diff file to console.
  • [3] It should work, but not been verified yet.
  • [4] Not implemented at the moment
  • [5] Report results that are outside the diff context as pull request comments and results that are outside the diff file with Actions logging commands as fallback if it's running in Gitea Actions. All results will be reported to console as well.

Debugging

Use the -tee flag to show debug info.

reviewdog -filter-mode=nofilter -tee

Articles

🐦 Author

haya14busa GitHub followers

Contributors

Contributors

Supporting reviewdog

Become GitHub Sponsor for each contributor or become a backer or sponsor from opencollective.

Become a backer

Documentation

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func RunFromResult 

func RunFromResult(ctx context.Context, c CommentService, results []*rdf.Diagnostic,
	filediffs []*diff.FileDiff, strip int, toolname string, filterMode filter.Mode, failLevel FailLevel) error

RunFromResult creates a new Reviewdog and runs it with check results.

Types

type BulkCommentService 

type BulkCommentService interface {
	CommentService
	Flush(context.Context) error
}

BulkCommentService posts comments all at once when Flush() is called. Flush() will be called at the end of each reviewdog run.

type Comment 

type Comment struct {
	Result   *filter.FilteredDiagnostic
	ToolName string
}

Comment represents a reported result as a comment.

type CommentService 

type CommentService interface {
	Post(context.Context, *Comment) error
	// If true, prepend Git relative directly to paths in results.
	// Useful for integration with code hosting service.
	ShouldPrependGitRelDir() bool
}

CommentService is an interface which posts Comment.

func MultiCommentService 

func MultiCommentService(services ...CommentService) CommentService

MultiCommentService creates a comment service that duplicates its post to all the provided comment services.

type DiffCmd 

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

func NewDiffCmd 

func NewDiffCmd(cmd *exec.Cmd, strip int) *DiffCmd

func (*DiffCmd) Diff 

func (d *DiffCmd) Diff(_ context.Context) ([]byte, error)

Diff returns diff. It caches the result and can be used more than once.

func (*DiffCmd) Strip 

func (d *DiffCmd) Strip() int

type DiffService 

type DiffService interface {
	Diff(context.Context) ([]byte, error)
	Strip() int
}

DiffService is an interface which get diff.

func NewDiffString 

func NewDiffString(diff string, strip int) DiffService

type DiffString 

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

func (*DiffString) Diff 

func (d *DiffString) Diff(_ context.Context) ([]byte, error)

func (*DiffString) Strip 

func (d *DiffString) Strip() int

type EmptyDiff added in v0.10.0 

type EmptyDiff struct{}

EmptyDiff service return empty diff.

func (*EmptyDiff) Diff added in v0.10.0 

func (*EmptyDiff) Diff(context.Context) ([]byte, error)

func (*EmptyDiff) Strip added in v0.10.0 

func (*EmptyDiff) Strip() int

type FailLevel added in v0.20.2 

type FailLevel int

FailLevel represents enumeration of available filter modes 

const (
	// FailLevelDefault represents default mode, which means users doesn't specify
	// fail-level. Basically, it's same as FailLevelNone.
	FailLevelDefault FailLevel = iota
	// FailLevelNone - Do not fail.
	FailLevelNone
	// FailLevelAny - Fail with any severity.
	FailLevelAny
	// FailLevelInfo - Fail with info or above severity.
	FailLevelInfo
	// FailLevelWarning - Fail with warning or above severity.
	FailLevelWarning
	// FailLevelError - Fail with error or above severity.
	FailLevelError
)

func (*FailLevel) Set added in v0.20.2 

func (failLevel *FailLevel) Set(value string) error

Set implements the flag.Value interface

func (FailLevel) ShouldFail added in v0.20.2 

func (failLevel FailLevel) ShouldFail(severity rdf.Severity) bool

ShouldFail returns true if reviewdog should exit with 1 with given rdf.Severity.

func (*FailLevel) String added in v0.20.2 

func (failLevel *FailLevel) String() string

String implements the flag.Value interface

type FilteredCommentService added in v0.19.0 

type FilteredCommentService interface {
	CommentService
	PostFiltered(context.Context, *Comment) error
}

FilteredCommentService is an interface which support posting filtered Comment.

type FilteredResult added in v0.9.15 

type FilteredResult struct {
	Level              string
	FilteredDiagnostic []*filter.FilteredDiagnostic
}

type FilteredResultMap added in v0.9.15 

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

FilteredResultMap represents a concurrent-safe map to store Diagnostics generated by concurrent jobs.

func (*FilteredResultMap) Len added in v0.9.15 

func (rm *FilteredResultMap) Len() int

Len returns the length of FilteredResultMap count. Len() is not yet officially not supported by Go. (ref: https://github.com/golang/go/issues/20680)

func (*FilteredResultMap) Load added in v0.9.15 

func (rm *FilteredResultMap) Load(key string) (*FilteredResult, error)

Load fetches FilteredResult from FilteredResultMap

func (*FilteredResultMap) Range added in v0.9.15 

func (rm *FilteredResultMap) Range(f func(key string, val *FilteredResult))

Range retrieves `key` and `values` from FilteredResultMap iteratively.

func (*FilteredResultMap) Store added in v0.9.15 

func (rm *FilteredResultMap) Store(key string, r *FilteredResult)

Store saves a new []*FilteredCheckFilteredResult into FilteredResultMap.

type NamedCommentService added in v0.20.2 

type NamedCommentService interface {
	CommentService
	SetTool(toolName string, level string)
}

NamedCommentService can set tool name and level. Useful for update tool name for each reviewdog run with reviewdog project config.

type RDJSONCommentWriter added in v0.19.0 

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

RDJSONCommentWriter

func NewRDJSONCommentWriter added in v0.19.0 

func NewRDJSONCommentWriter(w io.Writer, toolName string) *RDJSONCommentWriter

func (*RDJSONCommentWriter) Flush added in v0.19.0 

func (cw *RDJSONCommentWriter) Flush(_ context.Context) error

func (*RDJSONCommentWriter) Post added in v0.19.0 

func (cw *RDJSONCommentWriter) Post(_ context.Context, c *Comment) error

func (*RDJSONCommentWriter) ShouldPrependGitRelDir added in v0.21.0 

func (*RDJSONCommentWriter) ShouldPrependGitRelDir() bool

type RDJSONLCommentWriter added in v0.19.0 

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

RDJSONLCommentWriter

func NewRDJSONLCommentWriter added in v0.19.0 

func NewRDJSONLCommentWriter(w io.Writer) *RDJSONLCommentWriter

func (*RDJSONLCommentWriter) Post added in v0.19.0 

func (cw *RDJSONLCommentWriter) Post(_ context.Context, c *Comment) error

func (*RDJSONLCommentWriter) ShouldPrependGitRelDir added in v0.21.0 

func (*RDJSONLCommentWriter) ShouldPrependGitRelDir() bool

type RawCommentWriter 

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

RawCommentWriter is comment writer which writes results to given writer without any formatting.

func NewRawCommentWriter 

func NewRawCommentWriter(w io.Writer) *RawCommentWriter

func (*RawCommentWriter) Post 

func (s *RawCommentWriter) Post(_ context.Context, c *Comment) error

func (*RawCommentWriter) ShouldPrependGitRelDir added in v0.21.0 

func (*RawCommentWriter) ShouldPrependGitRelDir() bool

type Result added in v0.9.13 

type Result struct {
	Name        string
	Level       string
	Diagnostics []*rdf.Diagnostic

	// Optional. Report an error of the command execution.
	// Non-nil CmdErr doesn't mean failure and Diagnostics still may have
	// results.
	// It is common that a linter fails with non-zero exit code when it finds
	// lint errors.
	CmdErr error
}

func (*Result) CheckUnexpectedFailure added in v0.10.1 

func (r *Result) CheckUnexpectedFailure() error

CheckUnexpectedFailure returns error on unexpected failure, if any.

type ResultMap 

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

ResultMap represents a concurrent-safe map to store Diagnostics generated by concurrent jobs.

func (*ResultMap) Len 

func (rm *ResultMap) Len() int

Len returns the length of ResultMap count. Len() is not yet officially not supported by Go. (ref: https://github.com/golang/go/issues/20680)

func (*ResultMap) Load 

func (rm *ResultMap) Load(key string) (*Result, error)

Load fetches *Result from ResultMap

func (*ResultMap) Range 

func (rm *ResultMap) Range(f func(key string, val *Result))

Range retrieves `key` and `values` from ResultMap iteratively.

func (*ResultMap) Store 

func (rm *ResultMap) Store(key string, r *Result)

Store saves a new *Result into ResultMap.

type Reviewdog 

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

Reviewdog represents reviewdog application which parses result of compiler or linter, get diff and filter the results by diff, and report filtered results.

Example 
difftext := `diff --git a/golint.old.go b/golint.new.go
index 34cacb9..a727dd3 100644
--- a/golint.old.go
+++ b/golint.new.go
@@ -2,6 +2,12 @@ package test
 
 var V int
 
+var NewError1 int
+
 // invalid func comment
 func F() {
 }
+
+// invalid func comment2
+func F2() {
+}
`
lintresult := `golint.new.go:3:5: exported var V should have comment or be unexported
golint.new.go:5:5: exported var NewError1 should have comment or be unexported
golint.new.go:7:1: comment on exported function F should be of the form "F ..."
golint.new.go:11:1: comment on exported function F2 should be of the form "F2 ..."
`
efm, _ := errorformat.NewErrorformat([]string{`%f:%l:%c: %m`})
p := parser.NewErrorformatParser(efm)
c := NewRawCommentWriter(os.Stdout)
d := NewDiffString(difftext, 1)
app := NewReviewdog("tool name", p, c, d, filter.ModeAdded, FailLevelDefault)
app.Run(context.Background(), strings.NewReader(lintresult))

Output:
golint.new.go:5:5: exported var NewError1 should have comment or be unexported
golint.new.go:11:1: comment on exported function F2 should be of the form "F2 ..."

func NewReviewdog 

func NewReviewdog(toolname string, p parser.Parser, c CommentService, d DiffService, filterMode filter.Mode, failLevel FailLevel) *Reviewdog

NewReviewdog returns a new Reviewdog.

func (*Reviewdog) Run 

func (w *Reviewdog) Run(ctx context.Context, r io.Reader) error

Run runs Reviewdog application.

type SARIFCommentWriter added in v0.19.0 

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

SARIFCommentWriter

func NewSARIFCommentWriter added in v0.19.0 

func NewSARIFCommentWriter(w io.Writer, toolName string) *SARIFCommentWriter

func (*SARIFCommentWriter) Flush added in v0.19.0 

func (cw *SARIFCommentWriter) Flush(_ context.Context) error

func (*SARIFCommentWriter) Post added in v0.19.0 

func (cw *SARIFCommentWriter) Post(_ context.Context, c *Comment) error

func (*SARIFCommentWriter) ShouldPrependGitRelDir added in v0.21.0 

func (*SARIFCommentWriter) ShouldPrependGitRelDir() bool

type UnifiedCommentWriter 

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

UnifiedCommentWriter is comment writer which writes results to given writer in one of following unified formats.

Format:

  • <file>: [<tool name>] <message>
  • <file>:<lnum>: [<tool name>] <message>
  • <file>:<lnum>:<col>: [<tool name>] <message>

where <message> can be multiple lines.

func NewUnifiedCommentWriter 

func NewUnifiedCommentWriter(w io.Writer) *UnifiedCommentWriter

func (*UnifiedCommentWriter) Post 

func (mc *UnifiedCommentWriter) Post(_ context.Context, c *Comment) error

func (*UnifiedCommentWriter) ShouldPrependGitRelDir added in v0.21.0 

func (*UnifiedCommentWriter) ShouldPrependGitRelDir() bool

Source Files

View all Source files

Directories

Path Synopsis
Package cienv provides utility for environment variable in CI services.
 Package cienv provides utility for environment variable in CI services.
cmd
reviewdog command
Package diff provides a utility to parse unified diff.
 Package diff provides a utility to parse unified diff.
appengine command
appengine/statik
Package statik contains static assets.
 Package statik contains static assets.
client
server
server/cookieman
server/storage
Package project provides utility for reviewdog execution based on project config.
 Package project provides utility for reviewdog execution based on project config.
proto
metacomment
rdf
scripts
decode-metacomment command
encode-metacomment command
trigger-depup module
service
bitbucket
commentutil
gerrit
gitea
github
github/githubutils
gitlab
serviceutil

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.