Add pr-filter (#21)

Author: IlyaKhD

common/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "common",
+  "version": "0.1.0",
+  "author": "Developer Express Inc.",
+  "license": "MIT",
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "main": "lib/index.js",
+  "scripts": {
+    "clean": "rimraf lib",
+    "build": "tsc",
+    "test": "jest --config ../jest.config.js"
+  },
+  "devDependencies": {
+    "minimatch": "^10.0.1"
+  }
+}

common/src/common-utils.ts

@@ -0,0 +1,11 @@
+import { getExecOutput } from '@actions/exec'
+
+export async function execCommand(command: string): Promise<string> {
+  const { stdout, stderr, exitCode } = await getExecOutput(command)
+
+  if (exitCode !== 0) {
+    throw new Error(`Command "${command}" has been failed with error: ${stderr}`)
+  }
+
+  return stdout.trim()
+}

common/src/index.ts

@@ -0,0 +1,3 @@
+export * from './common-utils';
+export * from './path-utils';
+export * from './pr-utils';

common/src/path-utils.test.ts

@@ -0,0 +1,92 @@
+import { filterPaths } from "./path-utils";
+
+describe('path utils', () => {
+
+    describe('filterPaths', () => {
+        test.each([
+            {
+                paths: [],
+                patterns: [],
+                expected: []
+            },
+            {
+                paths: ['a.ts', 'a.js', 'b.md'],
+                patterns: ['b*.*'],
+                expected: ['b.md']
+            },
+            {
+                paths: ['a.ts', 'b.md'],
+                patterns: ['**'],
+                expected: ['a.ts', 'b.md']
+            },
+            {
+                paths: ['a.ts', 'a.js', 'x/a.ts', 'x/a.js', 'x/y/a.ts', 'x/z/a.js'],
+                patterns: ['*.ts'],
+                expected: ['a.ts']
+            },
+            {
+                paths: ['a.ts', 'a.js', 'x/a.ts', 'x/a.js', 'x/y/a.ts', 'x/z/a.js'],
+                patterns: ['**/*.ts'],
+                expected: ['a.ts', 'x/a.ts', 'x/y/a.ts']
+            },
+            {
+                paths: ['a.ts', 'a.js', 'x/a.ts', 'x/a.js', 'x/y/a.ts', 'x/z/a.js'],
+                patterns: ['**/y/*.*'],
+                expected: ['x/y/a.ts']
+            },
+        ])('basic cases [%#]', ({ paths, patterns, expected }) => {
+            expect(filterPaths(paths, patterns)).toEqual(expected);
+        });
+    });
+
+    describe('filterPaths', () => {
+        test.each([
+            // #region cases with negation
+            {
+                paths: ['a.ts', 'a.js', 'b.md'],
+                patterns: ['**', '!*.md'],
+                expected: ['a.ts', 'a.js']
+            },
+            {
+                paths: ['a.ts', 'a.js', 'b.md'],
+                patterns: ['**', '!b*'],
+                expected: ['a.ts', 'a.js']
+            },
+            {
+                paths: ['a.ts', 'a.js', 'x/a.ts', 'x/a.js', 'x/y/a.ts', 'x/z/a.js'],
+                patterns: ['**', '!*.js'],
+                expected: ['a.ts', 'x/a.ts', 'x/a.js', 'x/y/a.ts', 'x/z/a.js']
+            },
+            {
+                paths: ['a.ts', 'a.js', 'x/a.ts', 'x/a.js', 'x/y/a.ts', 'x/z/a.js'],
+                patterns: ['**', '!**/*.js'],
+                expected: ['a.ts', 'x/a.ts', 'x/y/a.ts']
+            },
+            {
+                paths: ['a.ts', 'a.js', 'x/a.ts', 'x/a.js', 'x/y/a.ts', 'x/z/a.js'],
+                patterns: ['**', '!**/{y,z}/*.*'],
+                expected: ['a.ts', 'a.js', 'x/a.ts', 'x/a.js',]
+            },
+            // #endregion
+        ])('negation cases [%#]', ({ paths, patterns, expected }) => {
+            expect(filterPaths(paths, patterns)).toEqual(expected);
+        });
+    });
+
+    describe('filterPaths', () => {
+        test.each([
+            { // starting with dot
+                paths: ['.a/b.ts'],
+                patterns: ['**'],
+                expected: ['.a/b.ts']
+            },
+            {   // backslash
+                paths: ['a\\b\\c.ts'],
+                patterns: ['**/b/*.*'],
+                expected: ['a\\b\\c.ts']
+            },
+        ])('specific cases [%#]', ({ paths, patterns, expected }) => {
+            expect(filterPaths(paths, patterns)).toEqual(expected);
+        });
+    });
+});

common/src/path-utils.ts

@@ -0,0 +1,23 @@
+import { MinimatchOptions, minimatch } from "minimatch";
+
+const NEGATION = '!';
+const matchOptions: MinimatchOptions = {
+    dot: true,
+}
+
+function match(path: string, pattern: string): boolean {
+    return minimatch(path.replace(/\\/g, '/'), pattern, matchOptions);
+}
+
+export function filterPaths(
+    paths: string[],
+    patterns: string[],
+): string[] {
+    return paths.filter(path => {
+        return patterns.reduce((prevResult, pattern) => {
+            return pattern.startsWith(NEGATION)
+                ? prevResult && !match(path, pattern.substring(1))
+                : prevResult || match(path, pattern);
+        }, false);
+    });
+}

common/src/pr-utils.ts

@@ -0,0 +1,44 @@
+
+import * as core from '@actions/core'
+import { context } from '@actions/github'
+import { execCommand } from './common-utils';
+
+export async function getPrRevisionRange(): Promise<{
+    head: string;
+    base: string;
+}> {
+    return getRange().then((r) => {
+        core.info(`Base commit: ${r.base}`);
+        core.info(`Head commit: ${r.head}`);
+        return r;
+    });
+}
+
+function normalizeCommit(commit: string) {
+    return commit === '0000000000000000000000000000000000000000' ? 'HEAD^' : commit;
+}
+
+export async function getRange(): Promise<{
+    head: string;
+    base: string;
+}> {
+    switch (context.eventName) {
+        case 'pull_request':
+            const baseBranch = context.payload.pull_request?.base?.ref;
+            await execCommand(`git fetch origin`);
+
+            return {
+                base: await execCommand(`git rev-parse origin/${baseBranch}`),
+                head: context.payload.pull_request?.head?.sha,
+            };
+
+        case 'push':
+
+            return {
+                base: normalizeCommit(context.payload.before),
+                head: context.payload.after,
+            };
+        default:
+            throw new Error(`This action only supports pull requests and pushes, ${context.eventName} events are not supported.`);
+    }
+}

common/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "./lib",
+    "declaration": true
+  }
+}

package-lock.json

@@ -38,6 +38,8 @@
     "typescript": "^4.9.5"
   },
   "workspaces": [
+    "common",
+    "pr-filter",
     "send-teams-notification",
     "verify-version-change"
   ]

package.json

@@ -0,0 +1,15 @@
+name: pr-filter
+description: Checks if PR meets certian criteria
+
+inputs:
+  paths:
+    description: Semicolon separated globs
+    required: false
+
+runs:
+  using: node16
+  main: dist/index.js
+
+outputs:
+  result:
+    description: true if all criteria met, otherwise false