build(deps-dev): bump @types/node from 14.11.8 to 14.11.10 (#114)

Bumps [@types/node](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/HEAD/types/node) from 14.11.8 to 14.11.10.
- [Release notes](https://github.com/DefinitelyTyped/DefinitelyTyped/releases)
- [Commits](https://github.com/DefinitelyTyped/DefinitelyTyped/commits/HEAD/types/node)

Signed-off-by: dependabot[bot] <support@github.com>

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

.github/dependabot.yml

@@ -0,0 +1,14 @@
+version: 2
+updates:
+  - package-ecosystem: github-actions
+    directory: "/"
+    schedule:
+      interval: weekly
+    reviewers:
+      - "golangci/team"
+  - package-ecosystem: npm
+    directory: "/"
+    schedule:
+      interval: weekly
+    reviewers:
+      - "golangci/team"

.github/workflows/codeql.yaml

@@ -0,0 +1,44 @@
+name: "Code Scanning - Action"
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ master ]
+  schedule:
+    - cron: '0 17 * * 5'
+
+jobs:
+  codeQL:
+    # CodeQL runs on ubuntu-latest, windows-latest, and macos-latest
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v2
+        with:
+          # Must fetch at least the immediate parents so that if this is
+          # a pull request then we can checkout the head of the pull request.
+          # Only include this option if you are running this workflow on pull requests.
+          fetch-depth: 2
+
+      # If this run was triggered by a pull request event then checkout
+      # the head of the pull request instead of the merge commit.
+      # Only include this step if you are running this workflow on pull requests.
+      - run: git checkout HEAD^2
+        if: ${{ github.event_name == 'pull_request' }}
+
+      # Initializes the CodeQL tools for scanning.
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@v1
+        # Override language selection by uncommenting this and choosing your languages
+        with:
+          language: 'javascript'
+
+      - run: |
+          npm install
+          npm run all
+
+      - name: Perform CodeQL Analysis
+        uses: github/codeql-action/analyze@v1

.github/workflows/test.yml

@@ -1,27 +1,48 @@
-name: "build-test"
+name: "build-and-test"
 on: # rebuild any PRs and main branch changes
   pull_request:
   push:
     branches:
       - master
-      - 'releases/*'
+      - "releases/*"
 
 jobs:
   build: # make sure build/ci work properly
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v1
-    - run: |
-        npm install
-        npm run prepare-deps
-        npm run all
-        git diff && git diff --cached
+      - uses: actions/checkout@v2
+      - run: |
+          npm install
+          npm run all
   test: # make sure the action works on a clean machine without building
-    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        os:
+          - ubuntu-latest
+          - macos-latest
+          - windows-latest
+    runs-on: ${{ matrix.os }}
     steps:
-    - uses: actions/checkout@v1
-    - uses: ./
-      with:
-        version: v1.26
-        args: --issues-exit-code=0 ./sample/...
-        github-token: ${{ secrets.GOLANGCI_LINT_GITHUB_TOKEN }}
+      - uses: actions/checkout@v2
+      - uses: ./
+        with:
+          version: latest
+          args: --issues-exit-code=0 ./sample/...
+          only-new-issues: true
+
+  # Test with full version vX.Y.Z
+  test-full-version:
+    strategy:
+      matrix:
+        os:
+          - ubuntu-latest
+          - macos-latest
+          - windows-latest
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v2
+      - uses: ./
+        with:
+          version: v1.28.3
+          args: --issues-exit-code=0 ./sample/...
+          only-new-issues: true

Dockerfile

@@ -1,5 +0,0 @@
-FROM golangci/golangci-lint:v1.26
-
-COPY entrypoint.sh /entrypoint.sh
-
-ENTRYPOINT ["/entrypoint.sh"]

README.md

@@ -1,16 +1,21 @@
 # golangci-lint-action
 
-[![Build Status](https://github.com/golangci/golangci-lint-action/workflows/test/badge.svg)](https://github.com/golangci/golangci-lint-action/actions)
+[![Build Status](https://github.com/golangci/golangci-lint-action/workflows/build-and-test/badge.svg)](https://github.com/golangci/golangci-lint-action/actions)
+
+It's the official GitHub action for [golangci-lint](https://github.com/golangci/golangci-lint) from it's authors.
+The action runs [golangci-lint](https://github.com/golangci/golangci-lint) and reports issues from linters.
 
 ![GitHub Annotations](./static/annotations.png)
 
-The action that runs [golangci-lint](https://github.com/golangci/golangci-lint) and reports issues from linters.
+## Compatibility
+
+* `v2.0.0+` works with `golangci-lint` version >= `v1.28.3`
+* `v1.2.2` is deprecated due to we forgot to change the minimum version of `golangci-lint` to `v1.28.3` ([issue](https://github.com/golangci/golangci-lint-action/issues/39))
+* `v1.2.1` works with `golangci-lint` version >= `v1.14.0` ([issue](https://github.com/golangci/golangci-lint-action/issues/39))
 
 ## How to use
 
-1. Create a [GitHub token](https://github.com/settings/tokens/new) with scope `repo.public_repo`.
-2. Add it to a [repository secrets](https://help.github.com/en/actions/configuring-and-managing-workflows/creating-and-storing-encrypted-secrets#creating-encrypted-secrets): repository -> `Settings` -> `Secrets`.
-3. Add `.github/workflows/golangci-lint.yml` with the following contents:
+Add `.github/workflows/golangci-lint.yml` with the following contents:
 
 ```yaml
 name: golangci-lint
@@ -20,6 +25,7 @@ on:
       - v*
     branches:
       - master
+      - main
   pull_request:
 jobs:
   golangci:
@@ -28,16 +34,67 @@ jobs:
     steps:
       - uses: actions/checkout@v2
       - name: golangci-lint
-        uses: golangci/golangci-lint-action@v1
+        uses: golangci/golangci-lint-action@v2
         with:
           # Required: the version of golangci-lint is required and must be specified without patch version: we always use the latest patch version.
-          version: v1.26
+          version: v1.29
+
+          # Optional: working directory, useful for monorepos
+          # working-directory: somedir
 
           # Optional: golangci-lint command line arguments.
-          # args: ./the-only-dir-to-analyze/...
+          # args: --issues-exit-code=0
 
-          # Required: GitHub token with scope `repo.public_repo`. Used for fetching a list of releases of golangci-lint.
-          github-token: ${{ secrets.GOLANGCI_LINT_GITHUB_TOKEN }}
+          # Optional: show only new issues if it's a pull request. The default value is `false`.
+          # only-new-issues: true
+```
+
+We recommend running this action in a job separate from other jobs (`go test`, etc)
+because different jobs [run in parallel](https://help.github.com/en/actions/getting-started-with-github-actions/core-concepts-for-github-actions#job).
+
+### Multiple OS Support
+
+If you need to run linters for specific operating systems, you will need to use `v2` of the action.  Here is a sample configuration file:
+
+```yaml
+name: golangci-lint
+on:
+  push:
+    tags:
+      - v*
+    branches:
+      - master
+      - main
+  pull_request:
+jobs:
+  golangci:
+    strategy:
+      matrix:
+        go-version: [1.15.x]
+        os: [macos-latest, windows-latest]
+    name: lint
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v2
+      - name: golangci-lint
+        uses: golangci/golangci-lint-action@v2
+        with:
+          # Required: the version of golangci-lint is required and must be specified without patch version: we always use the latest patch version.
+          version: v1.29
+          # Optional: working directory, useful for monorepos
+          # working-directory: somedir
+
+          # Optional: golangci-lint command line arguments.
+          # args: --issues-exit-code=0
+
+          # Optional: show only new issues if it's a pull request. The default value is `false`.
+          # only-new-issues: true
+```
+
+You will also likely need to add the following `.gitattributes` file to ensure that line endings for windows builds are properly formatted:
+
+```.gitattributes
+*.go text eol=lf 
 ```
 
 ## Comments and Annotations
@@ -49,27 +106,52 @@ The restrictions of annotations are the following:
 1. Currently, they don't support markdown formatting (see the [feature request](https://github.community/t5/GitHub-API-Development-and/Checks-Ability-to-include-Markdown-in-line-annotations/m-p/56704))
 2. They aren't shown in list of comments like it was with [golangci.com](https://golangci.com). If you would like to have comments - please, up-vote [the issue](https://github.com/golangci/golangci-lint-action/issues/5).
 
+## Performance
+
+The action was implemented with performance in mind:
+
+1. We cache data by [@actions/cache](https://github.com/actions/toolkit/tree/master/packages/cache) between builds: Go build cache, Go modules cache, golangci-lint analysis cache.
+2. We don't use Docker because image pulling is slow.
+3. We do as much as we can in parallel, e.g. we download cache, go and golangci-lint binary in parallel.
+
+For example, in a repository of [golangci-lint](https://github.com/golangci/golangci-lint) running this action without the cache takes 50s, but with cache takes 14s:
+  * in parallel:
+    * 13s to download Go
+    * 4s to restore 50 MB of cache
+    * 1s to find and install `golangci-lint`
+  * 1s to run `golangci-lint` (it takes 35s without cache)
+
 ## Internals
 
 We use JavaScript-based action. We don't use Docker-based action because:
 
 1. docker pulling is slow currently
-2. it's easier to use caching from [@actions/cache](https://github.com/actions/cache) until GitHub team hasn't supported reusing actions from actions
+2. it's easier to use caching from [@actions/cache](https://github.com/actions/toolkit/tree/master/packages/cache)
+
+We support different platforms, such as `ubuntu`, `macos` and `windows` with `x32` and `x64` archs.
 
 Inside our action we perform 3 steps:
 
 1. Setup environment running in parallel:
-  * restore [cache](https://github.com/actions/cache) of previous analyzes into `$HOME/.cache/golangci-lint`
-  * list [releases of golangci-lint](https://github.com/golangci/golangci-lint/releases) and find the latest patch version
-    for needed version (users of this action can specify only minor version). After that install [golangci-lint](https://github.com/golangci/golangci-lint) using [@actions/tool-cache](https://github.com/actions/toolkit/tree/master/packages/tool-cache)
+  * restore [cache](https://github.com/actions/cache) of previous analyzes
+  * fetch [action config](https://github.com/golangci/golangci-lint/blob/master/assets/github-action-config.json) and find the latest `golangci-lint` patch version
+    for needed version (users of this action can specify only minor version of `golangci-lint`). After that install [golangci-lint](https://github.com/golangci/golangci-lint) using [@actions/tool-cache](https://github.com/actions/toolkit/tree/master/packages/tool-cache)
   * install the latest Go 1.x version using [@actions/setup-go](https://github.com/actions/setup-go)
 2. Run `golangci-lint` with specified by user `args`
-3. Save cache from `$HOME/.cache/golangci-lint` for later builds
+3. Save cache for later builds
+
+### Caching internals
+
+1. We save and restore the following directories: `~/.cache/golangci-lint`, `~/.cache/go-build`, `~/go/pkg`.
+2. The primary caching key looks like `golangci-lint.cache-{platform-arch}-{interval_number}-{go.mod_hash}`. Interval number ensures that we periodically invalidate
+   our cache (every 7 days). `go.mod` hash ensures that we invalidate the cache early - as soon as dependencies have changed.
+3. We use [restore keys](https://help.github.com/en/actions/configuring-and-managing-workflows/caching-dependencies-to-speed-up-workflows#matching-a-cache-key): `golangci-lint.cache-{interval_number}-`, `golangci-lint.cache-`. GitHub matches keys by prefix if we have no exact match for the primary cache.
+
+This scheme is basic and needs improvements. Pull requests and ideas are welcome.
 
 ## Development of this action
 
 1. Install [act](https://github.com/nektos/act#installation)
 2. Make a symlink for `act` to work properly: `ln -s . golangci-lint-action`
-3. Get a [GitHub token](https://github.com/settings/tokens/new) with the scope `repo.public_repo`. Export it by `export GITHUB_TOKEN=YOUR_TOKEN`.
-4. Prepare deps once: `npm run prepare-deps`
-5. Run `npm run local` after any change to test it
+3. Prepare deps once: `npm run prepare-deps`
+4. Run `npm run local` after any change to test it

action.yml

@@ -1,23 +1,31 @@
 ---
-name: 'Run golangci-lint'
-description: 'Run golangci-lint (WIP)'
-author: 'golangci'
+name: "Run golangci-lint"
+description: "Official golangci-lint action with line-attached annotations for found issues, caching and parallel execution."
+author: "golangci"
 inputs:
   version:
-    description: 'version of golangci-lint to use in form of v1.2.3'
-    required: true
+    description: "version of golangci-lint to use in form of v1.2 or v1.2.3 or `latest` to use the latest version"
+    required: false
   args:
-    description: 'golangci-lint command line arguments'
-    default: ''
+    description: "golangci-lint command line arguments"
+    default: ""
+    required: false
+  working-directory:
+    description: "golangci-lint working directory, default is project root"
     required: false
   github-token:
-    description: 'GitHub token with scope `repo.public_repo`. Used for fetching a list of releases of golangci-lint.'
+    description: "the token is used for fetching patch of a pull request to show only new issues"
+    default: ${{ github.token }}
+    required: true
+  only-new-issues:
+    description: "if set to true and the action runs on a pull request - the action outputs only newly found issues"
+    default: false
     required: true
 
 runs:
-  using: 'node12'
-  main: 'dist/run/index.js'
-  post: 'dist/post_run/index.js'
+  using: "node12"
+  main: "dist/run/index.js"
+  post: "dist/post_run/index.js"
 branding:
-  icon: 'check-circle'
-  color: 'blue'
+  icon: "shield"
+  color: "yellow"

dist/matchers.json

@@ -1,7 +1,7 @@
 {
     "problemMatcher": [
         {
-            "owner": "golangci-lint-action",
+            "owner": "go",
             "pattern": [
                 {
                     "regexp": "^\\s*(\\.{0,2}[\\/\\\\].+\\.go):(?:(\\d+):(\\d+):)? (.*)",

entrypoint.sh

@@ -1,10 +0,0 @@
-#!/bin/bash
-
-echo 'golangci-lint-action: start'
-echo " flags:  ${INPUT_FLAGS}"
-echo " format: ${INPUT_FORMAT}"
-
-cd "${GITHUB_WORKSPACE}/${INPUT_DIRECTORY}" || exit 1
-
-# shellcheck disable=SC2086
-golangci-lint run --out-format ${INPUT_FORMAT} ${INPUT_FLAGS}

go.mod

@@ -0,0 +1,3 @@
+module github.com/golangci/golangci-lint-action
+
+go 1.14

package.json

@@ -1,49 +1,53 @@
 {
   "name": "golanci-lint-action",
-  "version": "1.1.2",
+  "version": "2.0.0",
   "private": true,
   "description": "golangci-lint github action",
   "main": "dist/main.js",
   "scripts": {
     "prepare-setup-go": "cd node_modules/setup-go && npm run build",
-    "prepare-cache": "cd node_modules/cache && npm run build",
-    "prepare-deps": "npm run prepare-setup-go && npm run prepare-cache",
+    "prepare-deps": "npm run prepare-setup-go",
     "build": "tsc && ncc build -o dist/run/ src/main.ts && ncc build -o dist/post_run/ src/post_main.ts",
+    "watched_build_main": "tsc && ncc build -w -o dist/run/ src/main.ts",
+    "watched_build_post_main": "tsc && ncc build -w -o dist/post_run/ src/post_main.ts",
     "type-check": "tsc",
-    "lint": "eslint **/*.ts --cache",
+    "lint": "eslint --max-warnings 1 **/*.ts --cache",
     "lint-fix": "eslint **/*.ts --cache --fix",
     "format": "prettier --write **/*.ts",
     "format-check": "prettier --check **/*.ts",
-    "all": "npm run build && npm run format-check && npm run lint",
-    "local": "npm run build && act -j test -s GOLANGCI_LINT_GITHUB_TOKEN=$GITHUB_TOKEN"
+    "all": "npm run prepare-deps && npm run build && npm run format-check && npm run lint",
+    "local": "npm run build && act -j test -b",
+    "local-full-version": "npm run build && act -j test-full-version -b"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/golangci/golangci-lint-action.git"
   },
-  "author": "GitHub",
+  "author": "golangci",
   "license": "MIT",
   "dependencies": {
-    "@actions/core": "^1.2.0",
+    "@actions/cache": "^1.0.2",
+    "@actions/core": "^1.2.6",
     "@actions/exec": "^1.0.1",
-    "@actions/github": "^2.1.1",
-    "@actions/tool-cache": "^1.3.4",
-    "@types/semver": "^7.1.0",
-    "cache": "git+https://github.com/golangci/cache.git",
-    "setup-go": "git+https://github.com/actions/setup-go.git"
+    "@actions/github": "^4.0.0",
+    "@actions/tool-cache": "^1.6.0",
+    "@types/semver": "^7.3.4",
+    "@types/tmp": "^0.2.0",
+    "setup-go": "git+https://github.com/actions/setup-go.git#v2.1.3",
+    "tmp": "^0.2.1"
   },
   "devDependencies": {
-    "@types/node": "^12.0.4",
-    "@types/uuid": "^3.4.5",
-    "@typescript-eslint/eslint-plugin": "^2.7.0",
-    "@typescript-eslint/parser": "^2.7.0",
-    "@zeit/ncc": "^0.20.5",
+    "@types/node": "^14.11.10",
+    "@types/uuid": "^8.3.0",
+    "@typescript-eslint/eslint-plugin": "^2.34.0",
+    "@typescript-eslint/parser": "^2.34.0",
+    "@zeit/ncc": "^0.22.3",
     "eslint": "^6.6.0",
-    "eslint-config-prettier": "^6.5.0",
-    "eslint-plugin-import": "^2.18.2",
-    "eslint-plugin-prettier": "^3.1.1",
+    "eslint-config-prettier": "^6.13.0",
+    "eslint-plugin-import": "^2.22.1",
+    "eslint-plugin-prettier": "^3.1.4",
     "eslint-plugin-simple-import-sort": "^5.0.2",
-    "prettier": "^1.19.1",
-    "typescript": "^3.8.3"
+    "prettier": "^2.1.2",
+    "typescript": "^4.0.3"
   }
 }

sample/sample.go

@@ -4,11 +4,23 @@ package sample
 import (
 	"crypto/md5"
 	"encoding/hex"
+	"errors"
 )
 
 // Hash~
 func Hash(data string) string {
+	retError()
+	retError2()
+
 	h := md5.New()
 	h.Write([]byte(data))
 	return hex.EncodeToString(h.Sum(nil))
 }
+
+func retError() error {
+	return errors.New("err")
+}
+
+func retError2() error {
+	return errors.New("err2")
+}

src/cache.ts

@@ -1,29 +1,136 @@
+import * as cache from "@actions/cache"
 import * as core from "@actions/core"
-import restore from "cache/lib/restore"
-import save from "cache/lib/save"
+import * as crypto from "crypto"
+import * as fs from "fs"
+import path from "path"
 
-// TODO: ensure dir exists, have access, etc
-const getCacheDir = (): string => `${process.env.HOME}/.cache/golangci-lint`
+import { Events, State } from "./constants"
+import * as utils from "./utils/actionUtils"
 
-const setCacheInputs = (): void => {
-  process.env.INPUT_KEY = `golangci-lint.analysis-cache`
-  process.env.INPUT_PATH = getCacheDir()
+function checksumFile(hashName: string, path: string): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const hash = crypto.createHash(hashName)
+    const stream = fs.createReadStream(path)
+    stream.on("error", (err) => reject(err))
+    stream.on("data", (chunk) => hash.update(chunk))
+    stream.on("end", () => resolve(hash.digest("hex")))
+  })
+}
+
+const pathExists = async (path: string): Promise<boolean> => !!(await fs.promises.stat(path).catch(() => false))
+
+const getLintCacheDir = (): string => {
+  return path.resolve(`${process.env.HOME}/.cache/golangci-lint`)
+}
+
+const getCacheDirs = (): string[] => {
+  // Not existing dirs are ok here: it works.
+  return [getLintCacheDir(), path.resolve(`${process.env.HOME}/.cache/go-build`), path.resolve(`${process.env.HOME}/go/pkg`)]
+}
+
+const getIntervalKey = (invalidationIntervalDays: number): string => {
+  const now = new Date()
+  const secondsSinceEpoch = now.getTime() / 1000
+  const intervalNumber = Math.floor(secondsSinceEpoch / (invalidationIntervalDays * 86400))
+  return intervalNumber.toString()
+}
+
+async function buildCacheKeys(): Promise<string[]> {
+  const keys = []
+  let cacheKey = `golangci-lint.cache-`
+  keys.push(cacheKey)
+
+  // Periodically invalidate a cache because a new code being added.
+  // TODO: configure it via inputs.
+  cacheKey += `${getIntervalKey(7)}-`
+  keys.push(cacheKey)
+
+  if (await pathExists(`go.mod`)) {
+    // Add checksum to key to invalidate a cache when dependencies change.
+    cacheKey += await checksumFile(`sha1`, `go.mod`)
+  } else {
+    cacheKey += `nogomod`
+  }
+  keys.push(cacheKey)
+
+  return keys
 }
 
 export async function restoreCache(): Promise<void> {
+  if (!utils.isValidEvent()) {
+    utils.logWarning(
+      `Event Validation Error: The event type ${process.env[Events.Key]} is not supported because it's not tied to a branch or tag ref.`
+    )
+    return
+  }
+
   const startedAt = Date.now()
-  setCacheInputs()
+
+  const keys = await buildCacheKeys()
+  const primaryKey = keys.pop()
+  const restoreKeys = keys.reverse()
 
   // Tell golangci-lint to use our cache directory.
-  process.env.GOLANGCI_LINT_CACHE = getCacheDir()
+  process.env.GOLANGCI_LINT_CACHE = getLintCacheDir()
 
-  await restore()
-  core.info(`Restored golangci-lint analysis cache in ${Date.now() - startedAt}ms`)
+  if (!primaryKey) {
+    utils.logWarning(`Invalid primary key`)
+    return
+  }
+  core.saveState(State.CachePrimaryKey, primaryKey)
+  try {
+    const cacheKey = await cache.restoreCache(getCacheDirs(), primaryKey, restoreKeys)
+    if (!cacheKey) {
+      core.info(`Cache not found for input keys: ${[primaryKey, ...restoreKeys].join(", ")}`)
+      return
+    }
+    // Store the matched cache key
+    utils.setCacheState(cacheKey)
+    core.info(`Restored cache for golangci-lint from key '${primaryKey}' in ${Date.now() - startedAt}ms`)
+  } catch (error) {
+    if (error.name === cache.ValidationError.name) {
+      throw error
+    } else {
+      core.warning(error.message)
+    }
+  }
 }
 
 export async function saveCache(): Promise<void> {
+  // Validate inputs, this can cause task failure
+  if (!utils.isValidEvent()) {
+    utils.logWarning(
+      `Event Validation Error: The event type ${process.env[Events.Key]} is not supported because it's not tied to a branch or tag ref.`
+    )
+    return
+  }
+
   const startedAt = Date.now()
-  setCacheInputs()
-  await save()
-  core.info(`Saved golangci-lint analysis cache in ${Date.now() - startedAt}ms`)
+
+  const cacheDirs = getCacheDirs()
+  const primaryKey = core.getState(State.CachePrimaryKey)
+  if (!primaryKey) {
+    utils.logWarning(`Error retrieving key from state.`)
+    return
+  }
+
+  const state = utils.getCacheState()
+
+  if (utils.isExactKeyMatch(primaryKey, state)) {
+    core.info(`Cache hit occurred on the primary key ${primaryKey}, not saving cache.`)
+    return
+  }
+
+  try {
+    await cache.saveCache(cacheDirs, primaryKey)
+    core.info(`Saved cache for golangci-lint from paths '${cacheDirs.join(`, `)}' in ${Date.now() - startedAt}ms`)
+  } catch (error) {
+    if (error.name === cache.ValidationError.name) {
+      throw error
+    } else if (error.name === cache.ReserveCacheError.name) {
+      core.info(error.message)
+    } else {
+      core.info(`[warning] ${error.message}`)
+    }
+  }
 }

src/constants.ts

@@ -0,0 +1,18 @@
+export enum Inputs {
+  Key = "key",
+  Path = "path",
+  RestoreKeys = "restore-keys",
+}
+
+export enum State {
+  CachePrimaryKey = "CACHE_KEY",
+  CacheMatchedKey = "CACHE_RESULT",
+}
+
+export enum Events {
+  Key = "GITHUB_EVENT_NAME",
+  Push = "push",
+  PullRequest = "pull_request",
+}
+
+export const RefKey = "GITHUB_REF"

src/install.ts

@@ -1,19 +1,55 @@
 import * as core from "@actions/core"
 import * as tc from "@actions/tool-cache"
+import os from "os"
 import path from "path"
 import { run as setupGo } from "setup-go/lib/main"
 
-import { stringifyVersion, Version } from "./version"
+import { VersionConfig } from "./version"
+
+const downloadURL = "https://github.com/golangci/golangci-lint/releases/download"
+
+const getAssetURL = (versionConfig: VersionConfig): string => {
+  let ext = "tar.gz"
+  let platform = os.platform().toString()
+  switch (platform) {
+    case "win32":
+      platform = "windows"
+      ext = "zip"
+      break
+  }
+  let arch = os.arch()
+  switch (arch) {
+    case "x64":
+      arch = "amd64"
+      break
+    case "x32":
+    case "ia32":
+      arch = "386"
+      break
+  }
+  const noPrefix = versionConfig.TargetVersion.slice(1)
+
+  return `${downloadURL}/${versionConfig.TargetVersion}/golangci-lint-${noPrefix}-${platform}-${arch}.${ext}`
+}
 
 // The installLint returns path to installed binary of golangci-lint.
-export async function installLint(ver: Version): Promise<string> {
-  core.info(`Installing golangci-lint ${stringifyVersion(ver)}...`)
+export async function installLint(versionConfig: VersionConfig): Promise<string> {
+  core.info(`Installing golangci-lint ${versionConfig.TargetVersion}...`)
   const startedAt = Date.now()
-  const dirName = `golangci-lint-${ver.major}.${ver.minor}.${ver.patch}-linux-amd64`
-  const assetUrl = `https://github.com/golangci/golangci-lint/releases/download/${stringifyVersion(ver)}/${dirName}.tar.gz`
+  const assetURL = getAssetURL(versionConfig)
+  core.info(`Downloading ${assetURL} ...`)
+  const archivePath = await tc.downloadTool(assetURL)
+  let extractedDir = ""
+  let repl = /\.tar\.gz$/
+  if (assetURL.endsWith("zip")) {
+    extractedDir = await tc.extractZip(archivePath, process.env.HOME)
+    repl = /\.zip$/
+  } else {
+    extractedDir = await tc.extractTar(archivePath, process.env.HOME)
+  }
 
-  const tarGzPath = await tc.downloadTool(assetUrl)
-  const extractedDir = await tc.extractTar(tarGzPath, process.env.HOME)
+  const urlParts = assetURL.split(`/`)
+  const dirName = urlParts[urlParts.length - 1].replace(repl, ``)
   const lintPath = path.join(extractedDir, dirName, `golangci-lint`)
   core.info(`Installed golangci-lint into ${lintPath} in ${Date.now() - startedAt}ms`)
   return lintPath

src/run.ts

@@ -1,5 +1,9 @@
 import * as core from "@actions/core"
-import { exec } from "child_process"
+import * as github from "@actions/github"
+import { exec, ExecOptions } from "child_process"
+import * as fs from "fs"
+import * as path from "path"
+import { dir } from "tmp"
 import { promisify } from "util"
 
 import { restoreCache, saveCache } from "./cache"
@@ -7,26 +11,90 @@ import { installGo, installLint } from "./install"
 import { findLintVersion } from "./version"
 
 const execShellCommand = promisify(exec)
+const writeFile = promisify(fs.writeFile)
+const createTempDir = promisify(dir)
 
 async function prepareLint(): Promise<string> {
-  const lintVersion = await findLintVersion()
-  return await installLint(lintVersion)
+  const versionConfig = await findLintVersion()
+  return await installLint(versionConfig)
 }
 
-async function prepareEnv(): Promise<string> {
+async function fetchPatch(): Promise<string> {
+  const onlyNewIssues = core.getInput(`only-new-issues`, { required: true }).trim()
+  if (onlyNewIssues !== `false` && onlyNewIssues !== `true`) {
+    throw new Error(`invalid value of "only-new-issues": "${onlyNewIssues}", expected "true" or "false"`)
+  }
+  if (onlyNewIssues === `false`) {
+    return ``
+  }
+
+  const ctx = github.context
+  if (ctx.eventName !== `pull_request`) {
+    core.info(`Not fetching patch for showing only new issues because it's not a pull request context: event name is ${ctx.eventName}`)
+    return ``
+  }
+  const pull = ctx.payload.pull_request
+  if (!pull) {
+    core.warning(`No pull request in context`)
+    return ``
+  }
+  const octokit = github.getOctokit(core.getInput(`github-token`, { required: true }))
+  let patch: string
+  try {
+    const patchResp = await octokit.pulls.get({
+      owner: ctx.repo.owner,
+      repo: ctx.repo.repo,
+      [`pull_number`]: pull.number,
+      mediaType: {
+        format: `diff`,
+      },
+    })
+
+    if (patchResp.status !== 200) {
+      core.warning(`failed to fetch pull request patch: response status is ${patchResp.status}`)
+      return `` // don't fail the action, but analyze without patch
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    patch = patchResp.data as any
+  } catch (err) {
+    console.warn(`failed to fetch pull request patch:`, err)
+    return `` // don't fail the action, but analyze without patch
+  }
+
+  try {
+    const tempDir = await createTempDir()
+    const patchPath = path.join(tempDir, "pull.patch")
+    core.info(`Writing patch to ${patchPath}`)
+    await writeFile(patchPath, patch)
+    return patchPath
+  } catch (err) {
+    console.warn(`failed to save pull request patch:`, err)
+    return `` // don't fail the action, but analyze without patch
+  }
+}
+
+type Env = {
+  lintPath: string
+  patchPath: string
+}
+
+async function prepareEnv(): Promise<Env> {
   const startedAt = Date.now()
 
   // Prepare cache, lint and go in parallel.
   const restoreCachePromise = restoreCache()
   const prepareLintPromise = prepareLint()
   const installGoPromise = installGo()
+  const patchPromise = fetchPatch()
 
   const lintPath = await prepareLintPromise
   await installGoPromise
   await restoreCachePromise
+  const patchPath = await patchPromise
 
   core.info(`Prepared env in ${Date.now() - startedAt}ms`)
-  return lintPath
+  return { lintPath, patchPath }
 }
 
 type ExecRes = {
@@ -43,23 +111,62 @@ const printOutput = (res: ExecRes): void => {
   }
 }
 
-async function runLint(lintPath: string): Promise<void> {
+async function runLint(lintPath: string, patchPath: string): Promise<void> {
   const debug = core.getInput(`debug`)
   if (debug.split(`,`).includes(`cache`)) {
     const res = await execShellCommand(`${lintPath} cache status`)
     printOutput(res)
   }
 
-  const args = core.getInput(`args`)
-  if (args.includes(`-out-format`)) {
+  const userArgs = core.getInput(`args`)
+  const addedArgs: string[] = []
+
+  const userArgNames = new Set<string>()
+  userArgs
+    .split(/\s/)
+    .map((arg) => arg.split(`=`)[0])
+    .filter((arg) => arg.startsWith(`-`))
+    .forEach((arg) => {
+      userArgNames.add(arg.replace(`-`, ``))
+    })
+
+  if (userArgNames.has(`out-format`)) {
     throw new Error(`please, don't change out-format for golangci-lint: it can be broken in a future`)
   }
+  addedArgs.push(`--out-format=github-actions`)
 
-  const cmd = `${lintPath} run ${args}`.trimRight()
-  core.info(`Running [${cmd}] ...`)
+  if (patchPath) {
+    if (userArgNames.has(`new`) || userArgNames.has(`new-from-rev`) || userArgNames.has(`new-from-patch`)) {
+      throw new Error(`please, don't specify manually --new* args when requesting only new issues`)
+    }
+    addedArgs.push(`--new-from-patch=${patchPath}`)
+
+    // Override config values.
+    addedArgs.push(`--new=false`)
+    addedArgs.push(`--new-from-rev=`)
+  }
+
+  const workingDirectory = core.getInput(`working-directory`)
+  const cmdArgs: ExecOptions = {}
+  if (workingDirectory) {
+    if (patchPath) {
+      // TODO: make them compatible
+      throw new Error(`options working-directory and only-new-issues aren't compatible`)
+    }
+    if (!fs.existsSync(workingDirectory) || !fs.lstatSync(workingDirectory).isDirectory()) {
+      throw new Error(`working-directory (${workingDirectory}) was not a path`)
+    }
+    if (!userArgNames.has(`path-prefix`)) {
+      addedArgs.push(`--path-prefix=${workingDirectory}`)
+    }
+    cmdArgs.cwd = path.resolve(workingDirectory)
+  }
+
+  const cmd = `${lintPath} run ${addedArgs.join(` `)} ${userArgs}`.trimRight()
+  core.info(`Running [${cmd}] in [${cmdArgs.cwd || ``}] ...`)
   const startedAt = Date.now()
   try {
-    const res = await execShellCommand(cmd)
+    const res = await execShellCommand(cmd, cmdArgs)
     printOutput(res)
     core.info(`golangci-lint found no issues`)
   } catch (exc) {
@@ -79,8 +186,8 @@ async function runLint(lintPath: string): Promise<void> {
 
 export async function run(): Promise<void> {
   try {
-    const lintPath = await core.group(`prepare environment`, prepareEnv)
-    await core.group(`run golangci-lint`, () => runLint(lintPath))
+    const { lintPath, patchPath } = await core.group(`prepare environment`, prepareEnv)
+    await core.group(`run golangci-lint`, () => runLint(lintPath, patchPath))
   } catch (error) {
     core.error(`Failed to run: ${error}, ${error.stack}`)
     core.setFailed(error.message)

src/utils/actionUtils.ts

@@ -0,0 +1,37 @@
+import * as core from "@actions/core"
+
+import { RefKey, State } from "../constants"
+
+export function isExactKeyMatch(key: string, cacheKey?: string): boolean {
+  return !!(
+    cacheKey &&
+    cacheKey.localeCompare(key, undefined, {
+      sensitivity: "accent",
+    }) === 0
+  )
+}
+
+export function setCacheState(state: string): void {
+  core.saveState(State.CacheMatchedKey, state)
+}
+
+export function getCacheState(): string | undefined {
+  const cacheKey = core.getState(State.CacheMatchedKey)
+  if (cacheKey) {
+    core.debug(`Cache state/key: ${cacheKey}`)
+    return cacheKey
+  }
+
+  return undefined
+}
+
+export function logWarning(message: string): void {
+  const warningPrefix = "[warning]"
+  core.info(`${warningPrefix}${message}`)
+}
+
+// Cache token authorized for all events that are tied to a ref
+// See GitHub Context https://help.github.com/actions/automating-your-workflow-with-github-actions/contexts-and-expression-syntax-for-github-actions#github-context
+export function isValidEvent(): boolean {
+  return RefKey in process.env && Boolean(process.env[RefKey])
+}

src/version.ts

@@ -1,35 +1,19 @@
 import * as core from "@actions/core"
-import * as github from "@actions/github"
-import { Octokit } from "@actions/github/node_modules/@octokit/rest"
-
-async function performResilientGitHubRequest<T>(opName: string, execFn: () => Promise<Octokit.Response<T>>): Promise<T> {
-  let lastError = ``
-  for (let i = 0; i < 3; i++) {
-    // TODO: configurable params, timeouts, random jitters, exponential back-off, etc
-    try {
-      const res = await execFn()
-      if (res.status === 200) {
-        return res.data
-      }
-      lastError = `GitHub returned HTTP code ${res.status}`
-    } catch (exc) {
-      lastError = exc.message
-    }
-  }
-
-  throw new Error(`failed to execute github operation '${opName}': ${lastError}`)
-}
+import * as httpm from "@actions/http-client"
 
 // TODO: make a class
 export type Version = {
   major: number
   minor: number
   patch: number | null
-}
+} | null
 
 const versionRe = /^v(\d+)\.(\d+)(?:\.(\d+))?$/
 
 const parseVersion = (s: string): Version => {
+  if (s == "latest" || s == "") {
+    return null
+  }
   const match = s.match(versionRe)
   if (!match) {
     throw new Error(`invalid version string '${s}', expected format v1.2 or v1.2.3`)
@@ -42,37 +26,40 @@ const parseVersion = (s: string): Version => {
   }
 }
 
-export const stringifyVersion = (v: Version): string => `v${v.major}.${v.minor}${v.patch !== null ? `.${v.patch}` : ``}`
+export const stringifyVersion = (v: Version): string => {
+  if (v == null) {
+    return "latest"
+  }
+  return `v${v.major}.${v.minor}${v.patch !== null ? `.${v.patch}` : ``}`
+}
 
 const minVersion = {
   major: 1,
-  minor: 14,
-  patch: 0,
+  minor: 28,
+  patch: 3,
 }
 
 const isLessVersion = (a: Version, b: Version): boolean => {
+  if (a == null) {
+    return true
+  }
+  if (b == null) {
+    return false
+  }
   if (a.major != b.major) {
     return a.major < b.major
   }
 
-  if (a.minor != b.minor) {
-    return a.minor < b.minor
-  }
-
-  if (a.patch === null || b.patch === null) {
-    return true
-  }
-
-  return a.patch < b.patch
+  // Do not compare patch parts because if the min version has a non zero value
+  // then it returns false, since the patch version of requested is always zero
+  return a.minor < b.minor
 }
 
 const getRequestedLintVersion = (): Version => {
-  const requestedLintVersion = core.getInput(`version`, { required: true })
+  const requestedLintVersion = core.getInput(`version`)
   const parsedRequestedLintVersion = parseVersion(requestedLintVersion)
-  if (parsedRequestedLintVersion.patch !== null) {
-    throw new Error(
-      `requested golangci-lint version '${requestedLintVersion}' was specified with the patch version, need specify only minor version`
-    )
+  if (parsedRequestedLintVersion == null) {
+    return null
   }
   if (isLessVersion(parsedRequestedLintVersion, minVersion)) {
     throw new Error(
@@ -84,40 +71,71 @@ const getRequestedLintVersion = (): Version => {
   return parsedRequestedLintVersion
 }
 
-export async function findLintVersion(): Promise<Version> {
-  core.info(`Finding needed golangci-lint version...`)
-  const startedAt = Date.now()
-  const reqLintVersion = getRequestedLintVersion()
-
-  const githubToken = core.getInput(`github-token`, { required: true })
-  const octokit = new github.GitHub(githubToken)
-
-  // TODO: fetch all pages, not only the first one.
-  const releasesPage = await performResilientGitHubRequest(`fetch releases of golangci-lint`, function() {
-    return octokit.repos.listReleases({ owner: `golangci`, repo: `golangci-lint`, [`per_page`]: 100 })
-  })
-
-  // TODO: use semver and semver.satisfies
-  let latestPatchVersion: number | null = null
-  for (const rel of releasesPage) {
-    const ver = parseVersion(rel.tag_name)
-    if (ver.patch === null) {
-      // < minVersion
-      continue
-    }
-
-    if (ver.major == reqLintVersion.major && ver.minor == reqLintVersion.minor) {
-      latestPatchVersion = latestPatchVersion !== null ? Math.max(latestPatchVersion, ver.patch) : ver.patch
-    }
-  }
-
-  if (latestPatchVersion === null) {
-    throw new Error(
-      `requested golangci-lint lint version ${stringifyVersion(reqLintVersion)} doesn't exist in list of golangci-lint releases`
-    )
-  }
-
-  const neededVersion = { ...reqLintVersion, patch: latestPatchVersion }
-  core.info(`Calculated needed golangci-lint version ${stringifyVersion(neededVersion)} in ${Date.now() - startedAt}ms`)
-  return neededVersion
+export type VersionConfig = {
+  Error?: string
+  TargetVersion: string
+  AssetURL: string
+}
+
+type Config = {
+  MinorVersionToConfig: {
+    [minorVersion: string]: VersionConfig
+  }
+}
+
+const getConfig = async (): Promise<Config> => {
+  const http = new httpm.HttpClient(`golangci/golangci-lint-action`, [], {
+    allowRetries: true,
+    maxRetries: 5,
+  })
+  try {
+    const url = `https://raw.githubusercontent.com/golangci/golangci-lint/master/assets/github-action-config.json`
+    const response: httpm.HttpClientResponse = await http.get(url)
+    if (response.message.statusCode !== 200) {
+      throw new Error(`failed to download from "${url}". Code(${response.message.statusCode}) Message(${response.message.statusMessage})`)
+    }
+
+    const body = await response.readBody()
+    return JSON.parse(body)
+  } catch (exc) {
+    throw new Error(`failed to get action config: ${exc.message}`)
+  }
+}
+
+export async function findLintVersion(): Promise<VersionConfig> {
+  core.info(`Finding needed golangci-lint version...`)
+  const reqLintVersion = getRequestedLintVersion()
+  // if the patched version is passed, just use it
+  if (reqLintVersion?.major !== null && reqLintVersion?.minor != null && reqLintVersion?.patch !== null) {
+    return new Promise((resolve) => {
+      const versionWithoutV = `${reqLintVersion.major}.${reqLintVersion.minor}.${reqLintVersion.patch}`
+      resolve({
+        TargetVersion: `v${versionWithoutV}`,
+        AssetURL: `https://github.com/golangci/golangci-lint/releases/download/v${versionWithoutV}/golangci-lint-${versionWithoutV}-linux-amd64.tar.gz`,
+      })
+    })
+  }
+  const startedAt = Date.now()
+
+  const config = await getConfig()
+  if (!config.MinorVersionToConfig) {
+    core.warning(JSON.stringify(config))
+    throw new Error(`invalid config: no MinorVersionToConfig field`)
+  }
+
+  const versionConfig = config.MinorVersionToConfig[stringifyVersion(reqLintVersion)]
+  if (!versionConfig) {
+    throw new Error(`requested golangci-lint version '${stringifyVersion(reqLintVersion)}' doesn't exist`)
+  }
+
+  if (versionConfig.Error) {
+    throw new Error(`failed to use requested golangci-lint version '${stringifyVersion(reqLintVersion)}': ${versionConfig.Error}`)
+  }
+
+  core.info(
+    `Requested golangci-lint '${stringifyVersion(reqLintVersion)}', using '${versionConfig.TargetVersion}', calculation took ${
+      Date.now() - startedAt
+    }ms`
+  )
+  return versionConfig
 }