.github/workflows/basic-validation.yml

@@ -15,3 +15,5 @@ jobs:
   call-basic-validation:
     name: Basic validation
     uses: actions/reusable-workflows/.github/workflows/basic-validation.yml@main
+    with:
+      node-version: '20.x'

.github/workflows/check-dist.yml

@@ -15,3 +15,5 @@ jobs:
   call-check-dist:
     name: Check dist/
     uses: actions/reusable-workflows/.github/workflows/check-dist.yml@main
+    with:
+      node-version: '20.x'

__mocks__/@actions/github.ts

@@ -1,7 +1,13 @@
 export const context = {
   payload: {
     pull_request: {
-      number: 123
+      number: 123,
+      head: {
+        ref: 'head-branch-name'
+      },
+      base: {
+        ref: 'base-branch-name'
+      }
     }
   },
   repo: {

__tests__/branch.test.ts

@@ -0,0 +1,210 @@
+import {
+  getBranchName,
+  checkAnyBranch,
+  checkAllBranch,
+  toBranchMatchConfig,
+  BranchMatchConfig
+} from '../src/branch';
+import * as github from '@actions/github';
+
+jest.mock('@actions/core');
+jest.mock('@actions/github');
+
+describe('getBranchName', () => {
+  describe('when the pull requests base branch is requested', () => {
+    it('returns the base branch name', () => {
+      const result = getBranchName('base');
+      expect(result).toEqual('base-branch-name');
+    });
+  });
+
+  describe('when the pull requests head branch is requested', () => {
+    it('returns the head branch name', () => {
+      const result = getBranchName('head');
+      expect(result).toEqual('head-branch-name');
+    });
+  });
+});
+
+describe('checkAllBranch', () => {
+  beforeEach(() => {
+    github.context.payload.pull_request!.head = {
+      ref: 'test/feature/123'
+    };
+    github.context.payload.pull_request!.base = {
+      ref: 'main'
+    };
+  });
+
+  describe('when a single pattern is provided', () => {
+    describe('and the pattern matches the head branch', () => {
+      it('returns true', () => {
+        const result = checkAllBranch(['^test'], 'head');
+        expect(result).toBe(true);
+      });
+    });
+
+    describe('and the pattern does not match the head branch', () => {
+      it('returns false', () => {
+        const result = checkAllBranch(['^feature/'], 'head');
+        expect(result).toBe(false);
+      });
+    });
+  });
+
+  describe('when multiple patterns are provided', () => {
+    describe('and not all patterns matched', () => {
+      it('returns false', () => {
+        const result = checkAllBranch(['^test/', '^feature/'], 'head');
+        expect(result).toBe(false);
+      });
+    });
+
+    describe('and all patterns match', () => {
+      it('returns true', () => {
+        const result = checkAllBranch(['^test/', '/feature/'], 'head');
+        expect(result).toBe(true);
+      });
+    });
+
+    describe('and no patterns match', () => {
+      it('returns false', () => {
+        const result = checkAllBranch(['^feature/', '/test$'], 'head');
+        expect(result).toBe(false);
+      });
+    });
+  });
+
+  describe('when the branch to check is specified as the base branch', () => {
+    describe('and the pattern matches the base branch', () => {
+      it('returns true', () => {
+        const result = checkAllBranch(['^main$'], 'base');
+        expect(result).toBe(true);
+      });
+    });
+  });
+});
+
+describe('checkAnyBranch', () => {
+  beforeEach(() => {
+    github.context.payload.pull_request!.head = {
+      ref: 'test/feature/123'
+    };
+    github.context.payload.pull_request!.base = {
+      ref: 'main'
+    };
+  });
+
+  describe('when a single pattern is provided', () => {
+    describe('and the pattern matches the head branch', () => {
+      it('returns true', () => {
+        const result = checkAnyBranch(['^test'], 'head');
+        expect(result).toBe(true);
+      });
+    });
+
+    describe('and the pattern does not match the head branch', () => {
+      it('returns false', () => {
+        const result = checkAnyBranch(['^feature/'], 'head');
+        expect(result).toBe(false);
+      });
+    });
+  });
+
+  describe('when multiple patterns are provided', () => {
+    describe('and at least one pattern matches', () => {
+      it('returns true', () => {
+        const result = checkAnyBranch(['^test/', '^feature/'], 'head');
+        expect(result).toBe(true);
+      });
+    });
+
+    describe('and all patterns match', () => {
+      it('returns true', () => {
+        const result = checkAnyBranch(['^test/', '/feature/'], 'head');
+        expect(result).toBe(true);
+      });
+    });
+
+    describe('and no patterns match', () => {
+      it('returns false', () => {
+        const result = checkAnyBranch(['^feature/', '/test$'], 'head');
+        expect(result).toBe(false);
+      });
+    });
+  });
+
+  describe('when the branch to check is specified as the base branch', () => {
+    describe('and the pattern matches the base branch', () => {
+      it('returns true', () => {
+        const result = checkAnyBranch(['^main$'], 'base');
+        expect(result).toBe(true);
+      });
+    });
+  });
+});
+
+describe('toBranchMatchConfig', () => {
+  describe('when there are no branch keys in the config', () => {
+    const config = {'changed-files': [{any: ['testing']}]};
+
+    it('returns an empty object', () => {
+      const result = toBranchMatchConfig(config);
+      expect(result).toEqual({});
+    });
+  });
+
+  describe('when the config contains a head-branch option', () => {
+    const config = {'head-branch': ['testing']};
+
+    it('sets headBranch in the matchConfig', () => {
+      const result = toBranchMatchConfig(config);
+      expect(result).toEqual<BranchMatchConfig>({
+        headBranch: ['testing']
+      });
+    });
+
+    describe('and the matching option is a string', () => {
+      const stringConfig = {'head-branch': 'testing'};
+
+      it('sets headBranch in the matchConfig', () => {
+        const result = toBranchMatchConfig(stringConfig);
+        expect(result).toEqual<BranchMatchConfig>({
+          headBranch: ['testing']
+        });
+      });
+    });
+  });
+
+  describe('when the config contains a base-branch option', () => {
+    const config = {'base-branch': ['testing']};
+    it('sets baseBranch in the matchConfig', () => {
+      const result = toBranchMatchConfig(config);
+      expect(result).toEqual<BranchMatchConfig>({
+        baseBranch: ['testing']
+      });
+    });
+
+    describe('and the matching option is a string', () => {
+      const stringConfig = {'base-branch': 'testing'};
+
+      it('sets baseBranch in the matchConfig', () => {
+        const result = toBranchMatchConfig(stringConfig);
+        expect(result).toEqual<BranchMatchConfig>({
+          baseBranch: ['testing']
+        });
+      });
+    });
+  });
+
+  describe('when the config contains both a base-branch and head-branch option', () => {
+    const config = {'base-branch': ['testing'], 'head-branch': ['testing']};
+    it('sets headBranch and baseBranch in the matchConfig', () => {
+      const result = toBranchMatchConfig(config);
+      expect(result).toEqual<BranchMatchConfig>({
+        baseBranch: ['testing'],
+        headBranch: ['testing']
+      });
+    });
+  });
+});

__tests__/changedFiles.test.ts

@@ -0,0 +1,270 @@
+import {
+  ChangedFilesMatchConfig,
+  checkAllChangedFiles,
+  checkAnyChangedFiles,
+  toChangedFilesMatchConfig,
+  checkIfAnyGlobMatchesAnyFile,
+  checkIfAllGlobsMatchAnyFile,
+  checkIfAnyGlobMatchesAllFiles,
+  checkIfAllGlobsMatchAllFiles
+} from '../src/changedFiles';
+
+jest.mock('@actions/core');
+jest.mock('@actions/github');
+
+describe('checkAllChangedFiles', () => {
+  const changedFiles = ['foo.txt', 'bar.txt'];
+
+  describe('when all given glob pattern configs matched', () => {
+    const globPatternsConfigs = [
+      {anyGlobToAnyFile: ['foo.txt']},
+      {anyGlobToAllFiles: ['*.txt']},
+      {allGlobsToAllFiles: ['**']}
+    ];
+
+    it('returns true', () => {
+      const result = checkAllChangedFiles(
+        changedFiles,
+        globPatternsConfigs,
+        false
+      );
+      expect(result).toBe(true);
+    });
+  });
+
+  describe(`when some given glob pattern config did not match`, () => {
+    const globPatternsConfigs = [
+      {anyGlobToAnyFile: ['*.md']},
+      {anyGlobToAllFiles: ['*.txt']},
+      {allGlobsToAllFiles: ['**']}
+    ];
+
+    it('returns false', () => {
+      const result = checkAllChangedFiles(
+        changedFiles,
+        globPatternsConfigs,
+        false
+      );
+      expect(result).toBe(false);
+    });
+  });
+});
+
+describe('checkAnyChangedFiles', () => {
+  const changedFiles = ['foo.txt', 'bar.txt'];
+
+  describe('when any given glob pattern config matched', () => {
+    const globPatternsConfigs = [
+      {anyGlobToAnyFile: ['*.md']},
+      {anyGlobToAllFiles: ['*.txt']}
+    ];
+
+    it('returns true', () => {
+      const result = checkAnyChangedFiles(
+        changedFiles,
+        globPatternsConfigs,
+        false
+      );
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('when none of the given glob pattern configs matched', () => {
+    const globPatternsConfigs = [
+      {anyGlobToAnyFile: ['*.md']},
+      {anyGlobToAllFiles: ['!*.txt']}
+    ];
+
+    it('returns false', () => {
+      const result = checkAnyChangedFiles(
+        changedFiles,
+        globPatternsConfigs,
+        false
+      );
+      expect(result).toBe(false);
+    });
+  });
+});
+
+describe('toChangedFilesMatchConfig', () => {
+  describe(`when there is no 'changed-files' key in the config`, () => {
+    const config = {'head-branch': 'test'};
+
+    it('returns an empty object', () => {
+      const result = toChangedFilesMatchConfig(config);
+      expect(result).toEqual<ChangedFilesMatchConfig>({});
+    });
+  });
+
+  describe(`when there is a 'changed-files' key in the config`, () => {
+    describe('but the glob pattern config key is not provided', () => {
+      const config = {'changed-files': ['bar']};
+
+      it('throws the error', () => {
+        expect(() => {
+          toChangedFilesMatchConfig(config);
+        }).toThrow(
+          `The "changed-files" section must have a valid config structure. Please read the action documentation for more information`
+        );
+      });
+    });
+
+    describe('but the glob pattern config key is not valid', () => {
+      const config = {'changed-files': [{NotValidConfigKey: ['bar']}]};
+
+      it('throws the error', () => {
+        expect(() => {
+          toChangedFilesMatchConfig(config);
+        }).toThrow(
+          `Unknown config options were under "changed-files": NotValidConfigKey`
+        );
+      });
+    });
+
+    describe('and the glob pattern config key is provided', () => {
+      describe('and the value is an array of strings', () => {
+        const config = {
+          'changed-files': [{'any-glob-to-any-file': ['testing']}]
+        };
+
+        it('sets the value in the config object', () => {
+          const result = toChangedFilesMatchConfig(config);
+          expect(result).toEqual<ChangedFilesMatchConfig>({
+            changedFiles: [{anyGlobToAnyFile: ['testing']}]
+          });
+        });
+      });
+
+      describe('and the value is a string', () => {
+        const config = {'changed-files': [{'any-glob-to-any-file': 'testing'}]};
+
+        it(`sets the string as an array in the config object`, () => {
+          const result = toChangedFilesMatchConfig(config);
+          expect(result).toEqual<ChangedFilesMatchConfig>({
+            changedFiles: [{anyGlobToAnyFile: ['testing']}]
+          });
+        });
+      });
+    });
+  });
+});
+
+describe('checkIfAnyGlobMatchesAnyFile', () => {
+  const changedFiles = ['foo.txt', 'bar.txt'];
+
+  describe('when any given glob pattern matched any file', () => {
+    const globPatterns = ['*.md', 'foo.txt'];
+
+    it('returns true', () => {
+      const result = checkIfAnyGlobMatchesAnyFile(
+        changedFiles,
+        globPatterns,
+        false
+      );
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('when none of the given glob pattern matched any file', () => {
+    const globPatterns = ['*.md', '!*.txt'];
+
+    it('returns false', () => {
+      const result = checkIfAnyGlobMatchesAnyFile(
+        changedFiles,
+        globPatterns,
+        false
+      );
+      expect(result).toBe(false);
+    });
+  });
+});
+
+describe('checkIfAllGlobsMatchAnyFile', () => {
+  const changedFiles = ['foo.txt', 'bar.txt'];
+
+  describe('when all given glob patterns matched any file', () => {
+    const globPatterns = ['**/bar.txt', 'bar.txt'];
+
+    it('returns true', () => {
+      const result = checkIfAllGlobsMatchAnyFile(
+        changedFiles,
+        globPatterns,
+        false
+      );
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('when some of the given glob patterns did not match any file', () => {
+    const globPatterns = ['*.txt', '*.md'];
+
+    it('returns false', () => {
+      const result = checkIfAllGlobsMatchAnyFile(
+        changedFiles,
+        globPatterns,
+        false
+      );
+      expect(result).toBe(false);
+    });
+  });
+});
+
+describe('checkIfAnyGlobMatchesAllFiles', () => {
+  const changedFiles = ['foo.txt', 'bar.txt'];
+
+  describe('when any given glob pattern matched all files', () => {
+    const globPatterns = ['*.md', '*.txt'];
+
+    it('returns true', () => {
+      const result = checkIfAnyGlobMatchesAllFiles(
+        changedFiles,
+        globPatterns,
+        false
+      );
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('when none of the given glob patterns matched all files', () => {
+    const globPatterns = ['*.md', 'bar.txt', 'foo.txt'];
+
+    it('returns false', () => {
+      const result = checkIfAnyGlobMatchesAllFiles(
+        changedFiles,
+        globPatterns,
+        false
+      );
+      expect(result).toBe(false);
+    });
+  });
+});
+
+describe('checkIfAllGlobsMatchAllFiles', () => {
+  const changedFiles = ['foo.txt', 'bar.txt'];
+
+  describe('when all given glob patterns matched all files', () => {
+    const globPatterns = ['*.txt', '**'];
+
+    it('returns true', () => {
+      const result = checkIfAllGlobsMatchAllFiles(
+        changedFiles,
+        globPatterns,
+        false
+      );
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('when some of the given glob patterns did not match all files', () => {
+    const globPatterns = ['**', 'foo.txt'];
+
+    it('returns false', () => {
+      const result = checkIfAllGlobsMatchAllFiles(
+        changedFiles,
+        globPatterns,
+        false
+      );
+      expect(result).toBe(false);
+    });
+  });
+});

__tests__/fixtures/all_options.yml

@@ -0,0 +1,17 @@
+label1:
+  - any:
+      - changed-files:
+          - any-glob-to-any-file: ['glob']
+      - head-branch: ['regexp']
+      - base-branch: ['regexp']
+  - all:
+      - changed-files:
+          - all-globs-to-all-files: ['glob']
+      - head-branch: ['regexp']
+      - base-branch: ['regexp']
+
+label2:
+  - changed-files:
+      - any-glob-to-any-file: ['glob']
+  - head-branch: ['regexp']
+  - base-branch: ['regexp']

__tests__/fixtures/any_and_all.yml

@@ -0,0 +1,8 @@
+tests:
+  - any:
+      - head-branch: ['^tests/', '^test/']
+      - changed-files:
+          - any-glob-to-any-file: ['tests/**/*']
+  - all:
+      - changed-files:
+          - all-globs-to-all-files: ['!tests/requirements.txt']

__tests__/fixtures/branches.yml

@@ -0,0 +1,11 @@
+test-branch:
+  - head-branch: '^test/'
+
+feature-branch:
+  - head-branch: '/feature/'
+
+bug-branch:
+  - head-branch: '^bug/|fix/'
+
+array-branch:
+  - head-branch: ['^array/']

__tests__/fixtures/not_supported.yml

@@ -0,0 +1,3 @@
+label:
+  - all:
+      - unknown: 'this-is-not-supported'

__tests__/fixtures/only_pdfs.yml

@@ -1,2 +1,3 @@
 touched-a-pdf-file:
-  - any: ['*.pdf']
+  - changed-files:
+      - any-glob-to-any-file: ['*.pdf']

__tests__/labeler.test.ts

@@ -1,6 +1,13 @@
-import {checkGlobs} from '../src/labeler';
-
+import * as yaml from 'js-yaml';
 import * as core from '@actions/core';
+import * as fs from 'fs';
+import {checkMatchConfigs} from '../src/labeler';
+import {
+  MatchConfig,
+  toMatchConfig,
+  getLabelConfigMapFromObject,
+  BaseMatchConfig
+} from '../src/api/get-label-configs';
 
 jest.mock('@actions/core');
 
@@ -10,34 +17,145 @@ beforeAll(() => {
   });
 });
 
-const matchConfig = [{any: ['*.txt']}];
+const loadYaml = (filepath: string) => {
+  const loadedFile = fs.readFileSync(filepath);
+  const content = Buffer.from(loadedFile).toString();
+  return yaml.load(content);
+};
 
-describe('checkGlobs', () => {
-  it('returns true when our pattern does match changed files', () => {
-    const changedFiles = ['foo.txt', 'bar.txt'];
-    const result = checkGlobs(changedFiles, matchConfig, false);
+describe('getLabelConfigMapFromObject', () => {
+  const yamlObject = loadYaml('__tests__/fixtures/all_options.yml');
+  const expected = new Map<string, MatchConfig[]>();
+  expected.set('label1', [
+    {
+      any: [
+        {changedFiles: [{anyGlobToAnyFile: ['glob']}]},
+        {baseBranch: undefined, headBranch: ['regexp']},
+        {baseBranch: ['regexp'], headBranch: undefined}
+      ]
+    },
+    {
+      all: [
+        {changedFiles: [{allGlobsToAllFiles: ['glob']}]},
+        {baseBranch: undefined, headBranch: ['regexp']},
+        {baseBranch: ['regexp'], headBranch: undefined}
+      ]
+    }
+  ]);
+  expected.set('label2', [
+    {
+      any: [
+        {changedFiles: [{anyGlobToAnyFile: ['glob']}]},
+        {baseBranch: undefined, headBranch: ['regexp']},
+        {baseBranch: ['regexp'], headBranch: undefined}
+      ]
+    }
+  ]);
 
-    expect(result).toBeTruthy();
+  it('returns a MatchConfig', () => {
+    const result = getLabelConfigMapFromObject(yamlObject);
+    expect(result).toEqual(expected);
   });
+});
+
+describe('toMatchConfig', () => {
+  describe('when all expected config options are present', () => {
+    const config = {
+      'changed-files': [{'any-glob-to-any-file': ['testing-files']}],
+      'head-branch': ['testing-head'],
+      'base-branch': ['testing-base']
+    };
+    const expected: BaseMatchConfig = {
+      changedFiles: [{anyGlobToAnyFile: ['testing-files']}],
+      headBranch: ['testing-head'],
+      baseBranch: ['testing-base']
+    };
+
+    it('returns a MatchConfig object with all options', () => {
+      const result = toMatchConfig(config);
+      expect(result).toEqual(expected);
+    });
 
-  it('returns false when our pattern does not match changed files', () => {
-    const changedFiles = ['foo.docx'];
-    const result = checkGlobs(changedFiles, matchConfig, false);
+    describe('and there are also unexpected options present', () => {
+      config['test-test'] = 'testing';
 
-    expect(result).toBeFalsy();
+      it('does not include the unexpected items in the returned MatchConfig object', () => {
+        const result = toMatchConfig(config);
+        expect(result).toEqual(expected);
+      });
+    });
   });
+});
+
+describe('checkMatchConfigs', () => {
+  describe('when a single match config is provided', () => {
+    const matchConfig: MatchConfig[] = [
+      {any: [{changedFiles: [{anyGlobToAnyFile: ['*.txt']}]}]}
+    ];
+
+    it('returns true when our pattern does match changed files', () => {
+      const changedFiles = ['foo.txt', 'bar.txt'];
+      const result = checkMatchConfigs(changedFiles, matchConfig, false);
+
+      expect(result).toBeTruthy();
+    });
 
-  it('returns false for a file starting with dot if `dot` option is false', () => {
-    const changedFiles = ['.foo.txt'];
-    const result = checkGlobs(changedFiles, matchConfig, false);
+    it('returns false when our pattern does not match changed files', () => {
+      const changedFiles = ['foo.docx'];
+      const result = checkMatchConfigs(changedFiles, matchConfig, false);
 
-    expect(result).toBeFalsy();
+      expect(result).toBeFalsy();
+    });
+
+    it('returns true when either the branch or changed files patter matches', () => {
+      const matchConfig: MatchConfig[] = [
+        {
+          any: [
+            {changedFiles: [{anyGlobToAnyFile: ['*.txt']}]},
+            {headBranch: ['some-branch']}
+          ]
+        }
+      ];
+      const changedFiles = ['foo.txt', 'bar.txt'];
+
+      const result = checkMatchConfigs(changedFiles, matchConfig, false);
+      expect(result).toBe(true);
+    });
+
+    it('returns false for a file starting with dot if `dot` option is false', () => {
+      const changedFiles = ['.foo.txt'];
+      const result = checkMatchConfigs(changedFiles, matchConfig, false);
+
+      expect(result).toBeFalsy();
+    });
+
+    it('returns true for a file starting with dot if `dot` option is true', () => {
+      const changedFiles = ['.foo.txt'];
+      const result = checkMatchConfigs(changedFiles, matchConfig, true);
+
+      expect(result).toBeTruthy();
+    });
   });
 
-  it('returns true for a file starting with dot if `dot` option is true', () => {
-    const changedFiles = ['.foo.txt'];
-    const result = checkGlobs(changedFiles, matchConfig, true);
+  describe('when multiple MatchConfigs are supplied', () => {
+    const matchConfig: MatchConfig[] = [
+      {any: [{changedFiles: [{anyGlobToAnyFile: ['*.txt']}]}]},
+      {any: [{headBranch: ['some-branch']}]}
+    ];
+    const changedFiles = ['foo.txt', 'bar.md'];
+
+    it('returns false when only one config matches', () => {
+      const result = checkMatchConfigs(changedFiles, matchConfig, false);
+      expect(result).toBe(false);
+    });
 
-    expect(result).toBeTruthy();
+    it('returns true when only both config matches', () => {
+      const matchConfig: MatchConfig[] = [
+        {any: [{changedFiles: [{anyGlobToAnyFile: ['*.txt']}]}]},
+        {any: [{headBranch: ['head-branch']}]}
+      ];
+      const result = checkMatchConfigs(changedFiles, matchConfig, false);
+      expect(result).toBe(true);
+    });
   });
 });

__tests__/main.test.ts

@@ -3,7 +3,6 @@ import * as github from '@actions/github';
 import * as core from '@actions/core';
 import path from 'path';
 import fs from 'fs';
-import each from 'jest-each';
 
 jest.mock('@actions/core');
 jest.mock('@actions/github');
@@ -35,7 +34,10 @@ class NotFound extends Error {
 }
 
 const yamlFixtures = {
-  'only_pdfs.yml': fs.readFileSync('__tests__/fixtures/only_pdfs.yml')
+  'branches.yml': fs.readFileSync('__tests__/fixtures/branches.yml'),
+  'only_pdfs.yml': fs.readFileSync('__tests__/fixtures/only_pdfs.yml'),
+  'not_supported.yml': fs.readFileSync('__tests__/fixtures/not_supported.yml'),
+  'any_and_all.yml': fs.readFileSync('__tests__/fixtures/any_and_all.yml')
 };
 
 const configureInput = (
@@ -147,6 +149,121 @@ describe('run', () => {
     expect(setLabelsMock).toHaveBeenCalledTimes(0);
   });
 
+  it('does not add a label when the match config options are not supported', async () => {
+    configureInput({});
+    usingLabelerConfigYaml('not_supported.yml');
+    await run();
+
+    expect(setLabelsMock).toHaveBeenCalledTimes(0);
+  });
+
+  it('adds labels based on the branch names that match the regexp pattern', async () => {
+    configureInput({});
+    github.context.payload.pull_request!.head = {ref: 'test/testing-time'};
+    usingLabelerConfigYaml('branches.yml');
+    await run();
+
+    expect(setLabelsMock).toHaveBeenCalledTimes(1);
+    expect(setLabelsMock).toHaveBeenCalledWith({
+      owner: 'monalisa',
+      repo: 'helloworld',
+      issue_number: 123,
+      labels: ['test-branch']
+    });
+
+    expect(setOutputSpy).toHaveBeenCalledWith('new-labels', 'test-branch');
+    expect(setOutputSpy).toHaveBeenCalledWith('all-labels', 'test-branch');
+  });
+
+  it('adds multiple labels based on branch names that match different regexp patterns', async () => {
+    configureInput({});
+    github.context.payload.pull_request!.head = {
+      ref: 'test/feature/123'
+    };
+    usingLabelerConfigYaml('branches.yml');
+    await run();
+
+    expect(setLabelsMock).toHaveBeenCalledTimes(1);
+    expect(setLabelsMock).toHaveBeenCalledWith({
+      owner: 'monalisa',
+      repo: 'helloworld',
+      issue_number: 123,
+      labels: ['test-branch', 'feature-branch']
+    });
+
+    expect(setOutputSpy).toHaveBeenCalledWith(
+      'new-labels',
+      'test-branch,feature-branch'
+    );
+    expect(setOutputSpy).toHaveBeenCalledWith(
+      'all-labels',
+      'test-branch,feature-branch'
+    );
+  });
+
+  it('can support multiple branches by batching', async () => {
+    configureInput({});
+    github.context.payload.pull_request!.head = {ref: 'fix/123'};
+    usingLabelerConfigYaml('branches.yml');
+    await run();
+
+    expect(setLabelsMock).toHaveBeenCalledTimes(1);
+    expect(setLabelsMock).toHaveBeenCalledWith({
+      owner: 'monalisa',
+      repo: 'helloworld',
+      issue_number: 123,
+      labels: ['bug-branch']
+    });
+
+    expect(setOutputSpy).toHaveBeenCalledWith('new-labels', 'bug-branch');
+    expect(setOutputSpy).toHaveBeenCalledWith('all-labels', 'bug-branch');
+  });
+
+  it('can support multiple branches by providing an array', async () => {
+    configureInput({});
+    github.context.payload.pull_request!.head = {ref: 'array/123'};
+    usingLabelerConfigYaml('branches.yml');
+    await run();
+
+    expect(setLabelsMock).toHaveBeenCalledTimes(1);
+    expect(setLabelsMock).toHaveBeenCalledWith({
+      owner: 'monalisa',
+      repo: 'helloworld',
+      issue_number: 123,
+      labels: ['array-branch']
+    });
+
+    expect(setOutputSpy).toHaveBeenCalledWith('new-labels', 'array-branch');
+    expect(setOutputSpy).toHaveBeenCalledWith('all-labels', 'array-branch');
+  });
+
+  it('adds a label when matching any and all patterns are provided', async () => {
+    configureInput({});
+    usingLabelerConfigYaml('any_and_all.yml');
+    mockGitHubResponseChangedFiles('tests/test.ts');
+    await run();
+
+    expect(setLabelsMock).toHaveBeenCalledTimes(1);
+    expect(setLabelsMock).toHaveBeenCalledWith({
+      owner: 'monalisa',
+      repo: 'helloworld',
+      issue_number: 123,
+      labels: ['tests']
+    });
+
+    expect(setOutputSpy).toHaveBeenCalledWith('new-labels', 'tests');
+    expect(setOutputSpy).toHaveBeenCalledWith('all-labels', 'tests');
+  });
+
+  it('does not add a label when not all any and all patterns are matched', async () => {
+    configureInput({});
+    usingLabelerConfigYaml('any_and_all.yml');
+    mockGitHubResponseChangedFiles('tests/requirements.txt');
+    await run();
+
+    expect(setLabelsMock).toHaveBeenCalledTimes(0);
+  });
+
   it('(with sync-labels: true) it deletes preexisting PR labels that no longer match the glob pattern', async () => {
     configureInput({
       'repo-token': 'foo',
@@ -171,6 +288,7 @@ describe('run', () => {
       issue_number: 123,
       labels: ['manually-added']
     });
+
     expect(setOutputSpy).toHaveBeenCalledWith('new-labels', '');
     expect(setOutputSpy).toHaveBeenCalledWith('all-labels', 'manually-added');
   });
@@ -353,10 +471,10 @@ describe('run', () => {
     expect(reposMock).toHaveBeenCalled();
   });
 
-  each([
+  test.each([
     [new HttpError('Error message')],
     [new NotFound('Error message')]
-  ]).test(
+  ])(
     'should warn if configuration file could not be fetched through the API, log error and fail the action',
     async error => {
       const configFilePath = 'non_existed_path/labeler.yml';

action.yml

@@ -16,7 +16,7 @@ inputs:
     required: false
   dot:
     description: 'Whether or not to auto-include paths starting with dot (e.g. `.github`)'
-    default: false
+    default: true
     required: false
   pr-number:
     description: 'The pull request number(s)'
@@ -28,5 +28,5 @@ outputs:
   all-labels:
     description: 'A comma-separated list of all labels that the PR contains'
 runs:
-  using: 'node16'
+  using: 'node20'
   main: 'dist/index.js'

package.json

@@ -1,6 +1,6 @@
 {
   "name": "labeler",
-  "version": "4.1.0",
+  "version": "5.0.0",
   "description": "Labels pull requests by files altered",
   "main": "lib/main.js",
   "scripts": {
@@ -25,27 +25,28 @@
   "license": "MIT",
   "dependencies": {
     "@actions/core": "^1.10.0",
-    "@actions/github": "^5.1.1",
-    "@octokit/plugin-retry": "^5.0.5",
-    "jest-each": "^29.6.1",
+    "@actions/github": "^6.0.0",
+    "@octokit/plugin-retry": "^6.0.0",
     "js-yaml": "^4.1.0",
-    "minimatch": "^7.4.3"
+    "lodash.isequal": "^4.5.0",
+    "minimatch": "^9.0.3"
   },
   "devDependencies": {
-    "@types/jest": "^27.4.1",
-    "@types/js-yaml": "^4.0.5",
+    "@types/jest": "^29.5.6",
+    "@types/js-yaml": "^4.0.6",
+    "@types/lodash.isequal": "^4.5.6",
     "@types/minimatch": "^5.1.2",
-    "@types/node": "^16.11.7",
-    "@typescript-eslint/eslint-plugin": "^5.61.0",
-    "@typescript-eslint/parser": "^5.61.0",
-    "@vercel/ncc": "^0.36.1",
-    "eslint": "^8.44.0",
-    "eslint-config-prettier": "^8.8.0",
-    "eslint-plugin-jest": "^27.2.2",
+    "@types/node": "^20.8.8",
+    "@typescript-eslint/eslint-plugin": "^6.7.4",
+    "@typescript-eslint/parser": "^6.7.2",
+    "@vercel/ncc": "^0.38.1",
+    "eslint": "^8.51.0",
+    "eslint-config-prettier": "^9.0.0",
+    "eslint-plugin-jest": "^27.4.2",
     "eslint-plugin-node": "^11.1.0",
-    "jest": "^27.5.1",
-    "prettier": "^2.8.8",
-    "ts-jest": "^27.1.3",
-    "typescript": "^4.9.5"
+    "jest": "^29.7.0",
+    "prettier": "^3.0.3",
+    "ts-jest": "^29.1.1",
+    "typescript": "^5.2.2"
   }
 }

src/api/get-changed-files.ts

@@ -0,0 +1,24 @@
+import * as core from '@actions/core';
+import * as github from '@actions/github';
+import {ClientType} from './types';
+
+export const getChangedFiles = async (
+  client: ClientType,
+  prNumber: number
+): Promise<string[]> => {
+  const listFilesOptions = client.rest.pulls.listFiles.endpoint.merge({
+    owner: github.context.repo.owner,
+    repo: github.context.repo.repo,
+    pull_number: prNumber
+  });
+
+  const listFilesResponse = await client.paginate(listFilesOptions);
+  const changedFiles = listFilesResponse.map((f: any) => f.filename);
+
+  core.debug('found changed files:');
+  for (const file of changedFiles) {
+    core.debug('  ' + file);
+  }
+
+  return changedFiles;
+};

src/api/get-changed-pull-requests.ts

@@ -0,0 +1,38 @@
+import * as core from '@actions/core';
+import * as github from '@actions/github';
+import {getChangedFiles} from './get-changed-files';
+import {ClientType} from './types';
+
+export async function* getPullRequests(
+  client: ClientType,
+  prNumbers: number[]
+) {
+  for (const prNumber of prNumbers) {
+    core.debug(`looking for pr #${prNumber}`);
+    let prData: any;
+    try {
+      const result = await client.rest.pulls.get({
+        owner: github.context.repo.owner,
+        repo: github.context.repo.repo,
+        pull_number: prNumber
+      });
+      prData = result.data;
+    } catch (error: any) {
+      core.warning(`Could not find pull request #${prNumber}, skipping`);
+      continue;
+    }
+
+    core.debug(`fetching changed files for pr #${prNumber}`);
+    const changedFiles: string[] = await getChangedFiles(client, prNumber);
+    if (!changedFiles.length) {
+      core.warning(`Pull request #${prNumber} has no changed files, skipping`);
+      continue;
+    }
+
+    yield {
+      data: prData,
+      number: prNumber,
+      changedFiles
+    };
+  }
+}

src/api/get-content.ts

@@ -0,0 +1,16 @@
+import * as github from '@actions/github';
+import {ClientType} from './types';
+
+export const getContent = async (
+  client: ClientType,
+  repoPath: string
+): Promise<string> => {
+  const response: any = await client.rest.repos.getContent({
+    owner: github.context.repo.owner,
+    repo: github.context.repo.repo,
+    path: repoPath,
+    ref: github.context.sha
+  });
+
+  return Buffer.from(response.data.content, response.data.encoding).toString();
+};

src/api/get-label-configs.ts

@@ -0,0 +1,126 @@
+import * as core from '@actions/core';
+import * as yaml from 'js-yaml';
+import fs from 'fs';
+import {ClientType} from './types';
+import {getContent} from './get-content';
+
+import {
+  ChangedFilesMatchConfig,
+  toChangedFilesMatchConfig
+} from '../changedFiles';
+
+import {toBranchMatchConfig, BranchMatchConfig} from '../branch';
+
+export interface MatchConfig {
+  all?: BaseMatchConfig[];
+  any?: BaseMatchConfig[];
+}
+
+export type BaseMatchConfig = BranchMatchConfig & ChangedFilesMatchConfig;
+
+const ALLOWED_CONFIG_KEYS = ['changed-files', 'head-branch', 'base-branch'];
+
+export const getLabelConfigs = (
+  client: ClientType,
+  configurationPath: string
+): Promise<Map<string, MatchConfig[]>> =>
+  Promise.resolve()
+    .then(() => {
+      if (!fs.existsSync(configurationPath)) {
+        core.info(
+          `The configuration file (path: ${configurationPath}) was not found locally, fetching via the api`
+        );
+
+        return getContent(client, configurationPath);
+      }
+
+      core.info(
+        `The configuration file (path: ${configurationPath}) was found locally, reading from the file`
+      );
+
+      return fs.readFileSync(configurationPath, {
+        encoding: 'utf8'
+      });
+    })
+    .catch(error => {
+      if (error.name == 'HttpError' || error.name == 'NotFound') {
+        core.warning(
+          `The config file was not found at ${configurationPath}. Make sure it exists and that this action has the correct access rights.`
+        );
+      }
+      return Promise.reject(error);
+    })
+    .then(configuration => {
+      // loads (hopefully) a `{[label:string]: MatchConfig[]}`, but is `any`:
+      const configObject: any = yaml.load(configuration);
+
+      // transform `any` => `Map<string,MatchConfig[]>` or throw if yaml is malformed:
+      return getLabelConfigMapFromObject(configObject);
+    });
+
+export function getLabelConfigMapFromObject(
+  configObject: any
+): Map<string, MatchConfig[]> {
+  const labelMap: Map<string, MatchConfig[]> = new Map();
+  for (const label in configObject) {
+    const configOptions = configObject[label];
+    if (
+      !Array.isArray(configOptions) ||
+      !configOptions.every(opts => typeof opts === 'object')
+    ) {
+      throw Error(
+        `found unexpected type for label '${label}' (should be array of config options)`
+      );
+    }
+    const matchConfigs = configOptions.reduce<MatchConfig[]>(
+      (updatedConfig, configValue) => {
+        if (!configValue) {
+          return updatedConfig;
+        }
+
+        Object.entries(configValue).forEach(([key, value]) => {
+          // If the top level `any` or `all` keys are provided then set them, and convert their values to
+          // our config objects.
+          if (key === 'any' || key === 'all') {
+            if (Array.isArray(value)) {
+              const newConfigs = value.map(toMatchConfig);
+              updatedConfig.push({[key]: newConfigs});
+            }
+          } else if (ALLOWED_CONFIG_KEYS.includes(key)) {
+            const newMatchConfig = toMatchConfig({[key]: value});
+            // Find or set the `any` key so that we can add these properties to that rule,
+            // Or create a new `any` key and add that to our array of configs.
+            const indexOfAny = updatedConfig.findIndex(mc => !!mc['any']);
+            if (indexOfAny >= 0) {
+              updatedConfig[indexOfAny].any?.push(newMatchConfig);
+            } else {
+              updatedConfig.push({any: [newMatchConfig]});
+            }
+          } else {
+            // Log the key that we don't know what to do with.
+            core.info(`An unknown config option was under ${label}: ${key}`);
+          }
+        });
+
+        return updatedConfig;
+      },
+      []
+    );
+
+    if (matchConfigs.length) {
+      labelMap.set(label, matchConfigs);
+    }
+  }
+
+  return labelMap;
+}
+
+export function toMatchConfig(config: any): BaseMatchConfig {
+  const changedFilesConfig = toChangedFilesMatchConfig(config);
+  const branchConfig = toBranchMatchConfig(config);
+
+  return {
+    ...changedFilesConfig,
+    ...branchConfig
+  };
+}

src/api/index.ts

@@ -0,0 +1,6 @@
+export * from './get-changed-files';
+export * from './get-changed-pull-requests';
+export * from './get-content';
+export * from './get-label-configs';
+export * from './set-labels';
+export * from './types';

src/api/set-labels.ts

@@ -0,0 +1,15 @@
+import * as github from '@actions/github';
+import {ClientType} from './types';
+
+export const setLabels = async (
+  client: ClientType,
+  prNumber: number,
+  labels: string[]
+) => {
+  await client.rest.issues.setLabels({
+    owner: github.context.repo.owner,
+    repo: github.context.repo.repo,
+    issue_number: prNumber,
+    labels: labels
+  });
+};

src/api/types.ts

@@ -0,0 +1,2 @@
+import * as github from '@actions/github';
+export type ClientType = ReturnType<typeof github.getOctokit>;

src/branch.ts

@@ -0,0 +1,98 @@
+import * as core from '@actions/core';
+import * as github from '@actions/github';
+
+export interface BranchMatchConfig {
+  headBranch?: string[];
+  baseBranch?: string[];
+}
+
+type BranchBase = 'base' | 'head';
+
+export function toBranchMatchConfig(config: any): BranchMatchConfig {
+  if (!config['head-branch'] && !config['base-branch']) {
+    return {};
+  }
+
+  const branchConfig = {
+    headBranch: config['head-branch'],
+    baseBranch: config['base-branch']
+  };
+
+  for (const branchName in branchConfig) {
+    if (typeof branchConfig[branchName] === 'string') {
+      branchConfig[branchName] = [branchConfig[branchName]];
+    }
+  }
+
+  return branchConfig;
+}
+
+export function getBranchName(branchBase: BranchBase): string | undefined {
+  const pullRequest = github.context.payload.pull_request;
+  if (!pullRequest) {
+    return undefined;
+  }
+
+  if (branchBase === 'base') {
+    return pullRequest.base?.ref;
+  } else {
+    return pullRequest.head?.ref;
+  }
+}
+
+export function checkAnyBranch(
+  regexps: string[],
+  branchBase: BranchBase
+): boolean {
+  const branchName = getBranchName(branchBase);
+  if (!branchName) {
+    core.debug(`   no branch name`);
+    return false;
+  }
+
+  core.debug(`   checking "branch" pattern against ${branchName}`);
+  const matchers = regexps.map(regexp => new RegExp(regexp));
+  for (const matcher of matchers) {
+    if (matchBranchPattern(matcher, branchName)) {
+      core.debug(`   "branch" patterns matched against ${branchName}`);
+      return true;
+    }
+  }
+
+  core.debug(`   "branch" patterns did not match against ${branchName}`);
+  return false;
+}
+
+export function checkAllBranch(
+  regexps: string[],
+  branchBase: BranchBase
+): boolean {
+  const branchName = getBranchName(branchBase);
+  if (!branchName) {
+    core.debug(`   cannot fetch branch name from the pull request`);
+    return false;
+  }
+
+  core.debug(`   checking "branch" pattern against ${branchName}`);
+  const matchers = regexps.map(regexp => new RegExp(regexp));
+  for (const matcher of matchers) {
+    if (!matchBranchPattern(matcher, branchName)) {
+      core.debug(`   "branch" patterns did not match against ${branchName}`);
+      return false;
+    }
+  }
+
+  core.debug(`   "branch" patterns matched against ${branchName}`);
+  return true;
+}
+
+function matchBranchPattern(matcher: RegExp, branchName: string): boolean {
+  core.debug(`    - ${matcher}`);
+  if (matcher.test(branchName)) {
+    core.debug(`    "branch" pattern matched`);
+    return true;
+  }
+
+  core.debug(`    ${matcher} did not match`);
+  return false;
+}

src/changedFiles.ts

@@ -0,0 +1,360 @@
+import * as core from '@actions/core';
+import * as github from '@actions/github';
+import {Minimatch} from 'minimatch';
+import {printPattern, isObject, kebabToCamel} from './utils';
+
+export interface ChangedFilesMatchConfig {
+  changedFiles?: ChangedFilesGlobPatternsConfig[];
+}
+
+interface ChangedFilesGlobPatternsConfig {
+  anyGlobToAnyFile?: string[];
+  anyGlobToAllFiles?: string[];
+  allGlobsToAnyFile?: string[];
+  allGlobsToAllFiles?: string[];
+}
+
+type ClientType = ReturnType<typeof github.getOctokit>;
+
+const ALLOWED_FILES_CONFIG_KEYS = [
+  'any-glob-to-any-file',
+  'any-glob-to-all-files',
+  'all-globs-to-any-file',
+  'all-globs-to-all-files'
+];
+
+export async function getChangedFiles(
+  client: ClientType,
+  prNumber: number
+): Promise<string[]> {
+  const listFilesOptions = client.rest.pulls.listFiles.endpoint.merge({
+    owner: github.context.repo.owner,
+    repo: github.context.repo.repo,
+    pull_number: prNumber
+  });
+
+  const listFilesResponse = await client.paginate(listFilesOptions);
+  const changedFiles = listFilesResponse.map((f: any) => f.filename);
+
+  core.debug('found changed files:');
+  for (const file of changedFiles) {
+    core.debug('  ' + file);
+  }
+
+  return changedFiles;
+}
+
+export function toChangedFilesMatchConfig(
+  config: any
+): ChangedFilesMatchConfig {
+  if (!config['changed-files'] || !config['changed-files'].length) {
+    return {};
+  }
+  const changedFilesConfigs = Array.isArray(config['changed-files'])
+    ? config['changed-files']
+    : [config['changed-files']];
+
+  const validChangedFilesConfigs: ChangedFilesGlobPatternsConfig[] = [];
+
+  changedFilesConfigs.forEach(changedFilesConfig => {
+    if (!isObject(changedFilesConfig)) {
+      throw new Error(
+        `The "changed-files" section must have a valid config structure. Please read the action documentation for more information`
+      );
+    }
+
+    const changedFilesConfigKeys = Object.keys(changedFilesConfig);
+    const invalidKeys = changedFilesConfigKeys.filter(
+      key => !ALLOWED_FILES_CONFIG_KEYS.includes(key)
+    );
+
+    if (invalidKeys.length) {
+      throw new Error(
+        `Unknown config options were under "changed-files": ${invalidKeys.join(
+          ', '
+        )}`
+      );
+    }
+
+    changedFilesConfigKeys.forEach(key => {
+      validChangedFilesConfigs.push({
+        [kebabToCamel(key)]: Array.isArray(changedFilesConfig[key])
+          ? changedFilesConfig[key]
+          : [changedFilesConfig[key]]
+      });
+    });
+  });
+
+  return {
+    changedFiles: validChangedFilesConfigs
+  };
+}
+
+export function checkAnyChangedFiles(
+  changedFiles: string[],
+  globPatternsConfigs: ChangedFilesGlobPatternsConfig[],
+  dot: boolean
+): boolean {
+  core.debug(`   checking "changed-files" patterns`);
+
+  for (const globPatternsConfig of globPatternsConfigs) {
+    if (globPatternsConfig.anyGlobToAnyFile) {
+      if (
+        checkIfAnyGlobMatchesAnyFile(
+          changedFiles,
+          globPatternsConfig.anyGlobToAnyFile,
+          dot
+        )
+      ) {
+        core.debug(`   "changed-files" matched`);
+        return true;
+      }
+    }
+
+    if (globPatternsConfig.anyGlobToAllFiles) {
+      if (
+        checkIfAnyGlobMatchesAllFiles(
+          changedFiles,
+          globPatternsConfig.anyGlobToAllFiles,
+          dot
+        )
+      ) {
+        core.debug(`   "changed-files" matched`);
+        return true;
+      }
+    }
+
+    if (globPatternsConfig.allGlobsToAnyFile) {
+      if (
+        checkIfAllGlobsMatchAnyFile(
+          changedFiles,
+          globPatternsConfig.allGlobsToAnyFile,
+          dot
+        )
+      ) {
+        core.debug(`   "changed-files" matched`);
+        return true;
+      }
+    }
+
+    if (globPatternsConfig.allGlobsToAllFiles) {
+      if (
+        checkIfAllGlobsMatchAllFiles(
+          changedFiles,
+          globPatternsConfig.allGlobsToAllFiles,
+          dot
+        )
+      ) {
+        core.debug(`   "changed-files" matched`);
+        return true;
+      }
+    }
+  }
+
+  core.debug(`   "changed-files" did not match`);
+  return false;
+}
+
+export function checkAllChangedFiles(
+  changedFiles: string[],
+  globPatternsConfigs: ChangedFilesGlobPatternsConfig[],
+  dot: boolean
+): boolean {
+  core.debug(`   checking "changed-files" patterns`);
+
+  for (const globPatternsConfig of globPatternsConfigs) {
+    if (globPatternsConfig.anyGlobToAnyFile) {
+      if (
+        !checkIfAnyGlobMatchesAnyFile(
+          changedFiles,
+          globPatternsConfig.anyGlobToAnyFile,
+          dot
+        )
+      ) {
+        core.debug(`   "changed-files" did not match`);
+        return false;
+      }
+    }
+
+    if (globPatternsConfig.anyGlobToAllFiles) {
+      if (
+        !checkIfAnyGlobMatchesAllFiles(
+          changedFiles,
+          globPatternsConfig.anyGlobToAllFiles,
+          dot
+        )
+      ) {
+        core.debug(`   "changed-files" did not match`);
+        return false;
+      }
+    }
+
+    if (globPatternsConfig.allGlobsToAnyFile) {
+      if (
+        !checkIfAllGlobsMatchAnyFile(
+          changedFiles,
+          globPatternsConfig.allGlobsToAnyFile,
+          dot
+        )
+      ) {
+        core.debug(`   "changed-files" did not match`);
+        return false;
+      }
+    }
+
+    if (globPatternsConfig.allGlobsToAllFiles) {
+      if (
+        !checkIfAllGlobsMatchAllFiles(
+          changedFiles,
+          globPatternsConfig.allGlobsToAllFiles,
+          dot
+        )
+      ) {
+        core.debug(`   "changed-files" did not match`);
+        return false;
+      }
+    }
+  }
+
+  core.debug(`   "changed-files" patterns matched`);
+  return true;
+}
+
+export function checkIfAnyGlobMatchesAnyFile(
+  changedFiles: string[],
+  globs: string[],
+  dot: boolean
+): boolean {
+  core.debug(`    checking "any-glob-to-any-file" config patterns`);
+  const matchers = globs.map(g => new Minimatch(g, {dot}));
+
+  for (const matcher of matchers) {
+    const matchedFile = changedFiles.find(changedFile => {
+      core.debug(
+        `     checking "${printPattern(
+          matcher
+        )}" pattern against ${changedFile}`
+      );
+
+      return matcher.match(changedFile);
+    });
+
+    if (matchedFile) {
+      core.debug(
+        `     "${printPattern(matcher)}" pattern matched ${matchedFile}`
+      );
+      return true;
+    }
+  }
+
+  core.debug(`    none of the patterns matched any of the files`);
+  return false;
+}
+
+export function checkIfAllGlobsMatchAnyFile(
+  changedFiles: string[],
+  globs: string[],
+  dot: boolean
+): boolean {
+  core.debug(`    checking "all-globs-to-any-file" config patterns`);
+  const matchers = globs.map(g => new Minimatch(g, {dot}));
+
+  for (const changedFile of changedFiles) {
+    const mismatchedGlob = matchers.find(matcher => {
+      core.debug(
+        `     checking "${printPattern(
+          matcher
+        )}" pattern against ${changedFile}`
+      );
+
+      return !matcher.match(changedFile);
+    });
+
+    if (mismatchedGlob) {
+      core.debug(
+        `     "${printPattern(
+          mismatchedGlob
+        )}" pattern did not match ${changedFile}`
+      );
+
+      continue;
+    }
+
+    core.debug(`    all patterns matched ${changedFile}`);
+    return true;
+  }
+
+  core.debug(`    none of the files matched all patterns`);
+  return false;
+}
+
+export function checkIfAnyGlobMatchesAllFiles(
+  changedFiles: string[],
+  globs: string[],
+  dot: boolean
+): boolean {
+  core.debug(`    checking "any-glob-to-all-files" config patterns`);
+  const matchers = globs.map(g => new Minimatch(g, {dot}));
+
+  for (const matcher of matchers) {
+    const mismatchedFile = changedFiles.find(changedFile => {
+      core.debug(
+        `     checking "${printPattern(
+          matcher
+        )}" pattern against ${changedFile}`
+      );
+
+      return !matcher.match(changedFile);
+    });
+
+    if (mismatchedFile) {
+      core.debug(
+        `     "${printPattern(
+          matcher
+        )}" pattern did not match ${mismatchedFile}`
+      );
+
+      continue;
+    }
+
+    core.debug(`    "${printPattern(matcher)}" pattern matched all files`);
+    return true;
+  }
+
+  core.debug(`    none of the patterns matched all files`);
+  return false;
+}
+
+export function checkIfAllGlobsMatchAllFiles(
+  changedFiles: string[],
+  globs: string[],
+  dot: boolean
+): boolean {
+  core.debug(`    checking "all-globs-to-all-files" config patterns`);
+  const matchers = globs.map(g => new Minimatch(g, {dot}));
+
+  for (const changedFile of changedFiles) {
+    const mismatchedGlob = matchers.find(matcher => {
+      core.debug(
+        `     checking "${printPattern(
+          matcher
+        )}" pattern against ${changedFile}`
+      );
+
+      return !matcher.match(changedFile);
+    });
+
+    if (mismatchedGlob) {
+      core.debug(
+        `     "${printPattern(
+          mismatchedGlob
+        )}" pattern did not match ${changedFile}`
+      );
+
+      return false;
+    }
+  }
+
+  core.debug(`    all patterns matched all files`);
+  return true;
+}

src/get-inputs/get-inputs.ts

@@ -0,0 +1,10 @@
+import * as core from '@actions/core';
+import {getPrNumbers} from './get-pr-numbers';
+
+export const getInputs = () => ({
+  token: core.getInput('repo-token'),
+  configPath: core.getInput('configuration-path', {required: true}),
+  syncLabels: core.getBooleanInput('sync-labels'),
+  dot: core.getBooleanInput('dot'),
+  prNumbers: getPrNumbers()
+});

src/get-inputs/get-pr-numbers.ts

@@ -0,0 +1,28 @@
+import * as core from '@actions/core';
+import * as github from '@actions/github';
+
+const getPrNumberFromContext = () =>
+  github.context.payload.pull_request?.number;
+
+export const getPrNumbers = (): number[] => {
+  const prInput = core.getMultilineInput('pr-number');
+
+  if (!prInput?.length) {
+    return [getPrNumberFromContext()].filter(Boolean) as number[];
+  }
+
+  const result: number[] = [];
+
+  for (const line of prInput) {
+    const prNumber = parseInt(line, 10);
+
+    if (isNaN(prNumber) && prNumber <= 0) {
+      core.warning(`'${prNumber}' is not a valid pull request number`);
+      continue;
+    }
+
+    result.push(prNumber);
+  }
+
+  return result;
+};

src/get-inputs/index.ts

@@ -0,0 +1 @@
+export * from './get-inputs';

src/utils.ts

@@ -0,0 +1,13 @@
+import {Minimatch} from 'minimatch';
+
+export const printPattern = (matcher: Minimatch): string => {
+  return (matcher.negate ? '!' : '') + matcher.pattern;
+};
+
+export const kebabToCamel = (str: string): string => {
+  return str.replace(/-./g, m => m.toUpperCase()[1]);
+};
+
+export function isObject(obj: unknown): obj is object {
+  return obj !== null && typeof obj === 'object' && !Array.isArray(obj);
+}