Repository files navigation

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 inthe diff of patches to review.

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

design doc

• Installation
• Input Format
  • 'errorformat'
  • Available pre-defined 'errorformat'
  • Reviewdog Diagnostic Format (RDFormat)
  • Diff
  • checkstyle format
  • SARIF format
• Code Suggestions
• reviewdog config file
• Reporters
  • Reporter: Local (-reporter=local) [default]
  • Reporter: GitHub PR Checks (-reporter=github-pr-check)
  • Reporter: GitHub Checks (-reporter=github-check)
  • Reporter: GitHub PullRequest review comment (-reporter=github-pr-review)
  • Reporter: GitHub Annotations (-reporter=github-annotations)
  • Reporter: GitHub PR Annotations (-reporter=github-pr-annotations)
  • Reporter: GitLab MergeRequest discussions (-reporter=gitlab-mr-discussion)
  • Reporter: GitLab MergeRequest commit (-reporter=gitlab-mr-commit)
  • Reporter: Bitbucket Code Insights Reports (-reporter=bitbucket-code-report)
• Supported CI services
  • GitHub Actions
  • Travis CI
  • Circle CI
  • GitLab CI
  • Bitbucket Pipelines
  • Common (Jenkins, local, etc...)
    • Jenkins with GitHub pull request builder plugin
• Exit codes
• Filter mode
• Articles

# 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]

You can also usenightly reviewdog releaseto 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

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

You can also install reviewdog using brew:

$ brew install reviewdog/tap/reviewdog$ brew upgrade reviewdog/tap/reviewdog

> scoop install reviewdog

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

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

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: exportedtype CommentWriter should have comment or be unexported$ golint ./...| reviewdog -efm="%f:%l:%c: %m" -diff="git diff FETCH_HEAD"

Please seereviewdog/errorformatand:h errorformatif you want to deal with a more complex output. 'errorformat' can handle morecomplex output like a multi-line error message.

You can also try errorformat onthe Playground!

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

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

You can find available errorformat name byreviewdog -list and you can use itwith-f={name}.

$ reviewdog -listgolint          linterfor Gosource code                                       - https://github.com/golang/lintgovet           Vet examines Gosource 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 toreviewdog/errorformat

reviewdog supportsReviewdog Diagnostic Format (RDFormat) as ageneric diagnostic format and it supports bothrdjson andrdjsonl formats.

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

$<linter>|<convert-to-rdjson>| reviewdog -f=rdjson -reporter=github-pr-review# or$<linter>|<convert-to-rdjsonl>| reviewdog -f=rdjsonl -reporter=github-pr-review

You can useeslint-formatter-rdjsonto outputrdjson 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 usereviewdog/action-eslint for GitHub Actions.

reviewdog supports diff (unified format) as an input format especially usefulforcode 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 usereviewdog/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

reviewdog also acceptscheckstyle 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

reviewdog supportsSARIF 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"

reviewdog supportscode suggestions feature withrdformat ordiff input.You can also usereviewdog/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 withdiff input as well.

Note that not all reporters provide support for code suggestions.

• [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 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 localenvironment including editor integration with ease.

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])# examplesgolint:cmd:golint ./...errorformat:      -"%f:%l:%c: %m"level:warninggovet:cmd:go vet -all .format:govetyour-awesome-linter:cmd:awesome-linter runformat:rdjsonname:AwesomeLinter

$ reviewdog -diff="git diff FETCH_HEAD"project/run_test.go:61:28: [golint] error strings should not end with punctuationproject/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,govetproject/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>

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

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

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

github-pr-check reporter reports results toGitHub Checks.

You can change the report level for this reporter bylevel field inconfigfile or-level flag. You can control GitHub statuscheck results with this feature. (default: error)

There are two options to use this reporter.

Example:.github/workflows/reviewdog.yml

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

SeeGitHub Actions section too. You can also use publicreviewdog GitHub Actions.

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

1. Install reviewdog Apps.https://github.com/apps/reviewdog
2. SetREVIEWDOG_TOKEN or run reviewdog CLI in trusted CI providers.

• Get token fromhttps://reviewdog.app/gh/{owner}/{repo-name}.

$export REVIEWDOG_TOKEN="<token>"$ reviewdog -reporter=github-pr-check

Note: Token is not required if you run reviewdog in Travis or AppVeyor.

Caution

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

UPDATE: Started getting support byopencollectiveand GitHub sponsor.SeeSupporting reviewdog

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

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

You can createreviewdog badge for this reporter.

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

• Go tohttps://github.com/settings/tokens and generate a new API token.
• Checkrepo for private repositories orpublic_repo for public repositories.

$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

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

github-annotations uses the GitHub Actions annotation format to output errorsand warnings tostdout 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 notuse the token to report errors.

Same asgithub-annotations but only works for Pull Requests.

Required GitLab version: >= v10.8.0

gitlab-mr-discussion reporter reports results to GitLab MergeRequest discussions usingGitLab Personal API Access token.Get the token withapi scope fromhttps://gitlab.com/profile/personal_access_tokens.

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

TheCI_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 overCI_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

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

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

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

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.

SetGERRIT_USERNAME andGERRIT_PASSWORD environment variables for basic authentication, and putGIT_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

bitbucket-code-report generates the annotatedBitbucket Code Insights report.

For now, only theno-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 orin 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 byThis pull request orAll.

If running fromBitbucket 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 andBITBUCKET_PASSWORD
• For AccessToken Auth you need to setBITBUCKET_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 useBITBUCKET_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

Example:.github/workflows/reviewdog.yml

name:reviewdogon:[pull_request]jobs:reviewdog:name:reviewdogruns-on:ubuntu-lateststeps:# ...      -uses:reviewdog/action-setup@d8edfce3dd5e1ec6978745e801f9c50b5ef80252# v1.4.0with:reviewdog_version:latest# Optional. [latest,nightly,v.X.Y.Z]      -name:Run reviewdogenv: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

name:reviewdog (github-check)on:push:branches:      -masterpull_request:jobs:reviewdog:name:reviewdogruns-on:ubuntu-lateststeps:# ...      -name:Run reviewdogenv:REVIEWDOG_GITHUB_API_TOKEN:${{ secrets.GITHUB_TOKEN }}run:|          reviewdog -reporter=github-check -runners=golint,govet

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

• Common
  • reviewdog/action-misspell - Runmisspell.
  • EPMatt/reviewdog-action-prettier - RunPrettier.
• Text
  • reviewdog/action-alex - Runalex which catches insensitive, inconsiderate writing. (e.g. master/slave)
  • reviewdog/action-languagetool - Runlanguagetool.
  • tsuyoshicho/action-textlint - Runtextlint
  • tsuyoshicho/action-redpen - Runredpen
• Markdown
  • reviewdog/action-markdownlint - Runmarkdownlint
• Docker
  • reviewdog/action-hadolint - Runhadolint to lintDockerfile.
• Env
  • dotenv-linter/action-dotenv-linter - Rundotenv-linter to lint.env files.
• Shell script
  • reviewdog/action-shellcheck - Runshellcheck.
  • reviewdog/action-shfmt - Runshfmt.
• Go
  • reviewdog/action-staticcheck - Runstaticcheck.
  • reviewdog/action-golangci-lint - Rungolangci-lint and supported linters individually by golangci-lint.
• JavaScript
  • reviewdog/action-eslint - Runeslint.
  • mongolyy/reviewdog-action-biome - RunBiome.
• TypeScript
  • EPMatt/reviewdog-action-tsc - Runtsc.
• CSS
  • reviewdog/action-stylelint - Runstylelint.
• Vim script
  • reviewdog/action-vint - Runvint.
  • tsuyoshicho/action-vimlint - Runvim-vimlint
• Terraform
  • reviewdog/action-tflint - Runtflint.
  • reviewdog/action-terraform-validate - Runterraform validate.
• YAML
  • reviewdog/action-yamllint - Runyamllint.
• Ruby
  • reviewdog/action-brakeman - Runbrakeman.
  • reviewdog/action-reek - Runreek.
  • reviewdog/action-rubocop - Runrubocop.
  • vk26/action-fasterer - Runfasterer.
  • PrintReleaf/action-standardrb - Runstandardrb.
  • tk0miya/action-erblint - Runerb-lint
  • tk0miya/action-steep - Runsteep
  • blooper05/action-rails_best_practices - Runrails_best_practices
  • tomferreira/action-bundler-audit - Runbundler-audit
• Python
  • wemake-python-styleguide - Run wemake-python-styleguide
  • tsuyoshicho/action-mypy - Runmypy
  • jordemort/action-pyright - Runpyright
  • dciborow/action-pylint - Runpylint
  • reviewdog/action-black - Runblack
  • brunohaf/action-bandit - Runbandit
• Kotlin
  • ScaCap/action-ktlint - Runktlint.
• Android Lint
  • dvdandroid/action-android-lint - RunAndroid Lint
• Ansible
  • reviewdog/action-ansiblelint - Runansible-lint
• GitHub Actions
  • reviewdog/action-actionlint - Runactionlint
• Protocol Buffers
  • yoheimuta/action-protolint - Runprotolint
• Rego
  • reviewdog/action-regal - RunRegal

... and more onGitHub Marketplace.

Missing actions? Check outreviewdog/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.

GITHUB_TOKEN for Pull Requests from a forked repository doesn't have writeaccess to Check API nor Review API due toGitHub Actionsrestriction.

Instead, reviewdog usesLogging commands of GitHubActionsto post results asannotationssimilar togithub-pr-check reporter.

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

Asgithub-check reporter support running on commit, we can create reviewdogGitHub Action badgeto 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)

If you use -reporter=github-pr-check in Travis CI, you don't need to setREVIEWDOG_TOKEN.

Example:

install:  -mkdir -p ~/bin/ && export PATH="~/bin/:$PATH"  -curl -sfL https://raw.githubusercontent.com/reviewdog/reviewdog/fd59714416d6d9a1c0692d872e38e7f8448df4fc/install.sh| sh -s -- -b ~/binscript:  -reviewdog -conf=.reviewdog.yml -reporter=github-pr-check

Store GitHub API token bytravis 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 ~/binscript:  ->-    golint ./... | reviewdog -f=golint -reporter=github-pr-review

Examples

• https://github.com/azu/textlint-reviewdog-example

StoreREVIEWDOG_GITHUB_API_TOKEN (orREVIEWDOG_TOKEN for github-pr-check) inEnvironment variables - CircleCI

version:2jobs:build:docker:      -image:golang:lateststeps:      -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

StoreREVIEWDOG_GITLAB_API_TOKEN inGitLab CI variable.

reviewdog:script:    -reviewdog -reporter=gitlab-mr-discussion# Or    -reviewdog -reporter=gitlab-mr-commit

No additional configuration is needed.

pipelines:default:    -step:name:Reviewdogimage:golangci/golangci-lint:v1.31-alpinescript:          -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

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

$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 flagguess:

$ reviewdog -conf=.reviewdog.yml -reporter=github-pr-check -guess

• GitHub pull request builder plugin - Jenkins - Jenkins Wiki
• Configuring a GitHub app account - Jenkins - CloudBees - required to use github-pr-check formatter without reviewdog server or GitHub actions.

$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

By default (-fail-level=none) reviewdog will return0 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.

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

Filter results by added/modified lines.

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

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.

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 withnofilter mode.

Example:

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

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

• [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

Use the-tee flag to show debug info.

reviewdog -filter-mode=nofilter -tee

• reviewdog — A code review dog who keeps your codebase healthy
• reviewdog ♡ GitHub Check — improved automated review experience
• Automated Code Review on GitHub Actions with reviewdog for any languages/tools
• GitHub Actions to guard your workflow

haya14busa

Become GitHub Sponsor foreach contributoror become a backer or sponsor fromopencollective.