Adding wrappedRuleResolver to be able to delegate to standard rules offered by commitlint. Will be used by subject and type rules.

Author: danrivett

packages/commitlint-plugin-github-rules/@types/index.d.ts

@@ -1,4 +1,5 @@
 import { When } from 'commitlint-github-utils/@types';
+import { ParsedCommitMessage } from 'commitlint-github-utils';
 
 export type RuleResolverResult = [boolean, string?];
 
@@ -19,6 +20,20 @@ export type BaseParsedCommit = Partial<{
 
 export type RuleResolver<T> = (parsed: BaseParsedCommit, when?: When, value?: T) => RuleResolverResult;
 
+export type WrappedRuleResolver<T> = (
+  baseResolver: RuleResolver<T>,
+  adapter: BaseParsedCommitAdapter,
+  parsed: BaseParsedCommit,
+  when?: When,
+  value?: T,
+) => RuleResolverResult;
+
+export type BaseParsedCommitAdapter = (parsed: ParsedCommitMessage) => BaseParsedCommit;
+
+export type WhenAndValue<T> = [When, T?];
+
+export type WhenAndRequiredValue<T> = [When, T];
+
 export interface CommitlintPluginGitHub {
   rules: {
     [key: string]: unknown;

packages/commitlint-plugin-github-rules/src/rules/utils/tests/wrappedRuleResolver.test.setup.ts

@@ -0,0 +1,44 @@
+import { When } from 'commitlint-github-utils/@types';
+import utils, { ParsedCommitMessage } from 'commitlint-github-utils';
+import { BaseParsedCommitAdapter, RuleResolver, RuleResolverResult } from '../../../../@types';
+import wrappedRuleResolver from '../wrappedRuleResolver';
+import { createBaseParsedCommit } from './utils';
+
+// Mock the parseCommitMessage() method so we can isolate our test to just wrappedRuleResolver
+// (though note we aren't mocking utils.handleWipResult() currently which is called by wrappedRuleResolver)
+const mockedParseCommitMessage: jest.Mock<ParsedCommitMessage> = jest.fn() as jest.Mock<ParsedCommitMessage>;
+utils.parseCommitMessage = mockedParseCommitMessage;
+
+export const EXPECTED_WHEN = When.NEVER;
+export const EXPECTED_VALUE = 'dummy-value';
+export const COMMIT_FROM_ADAPTER = createBaseParsedCommit('DUMMY_COMMIT');
+export const RESULT_FROM_BASE_RESOLVER: RuleResolverResult = [true, 'DUMMY_RESULT'];
+
+export type WrappedRuleResolverResult = {
+  result: RuleResolverResult;
+  baseResolver: RuleResolver<string>;
+  adapter: BaseParsedCommitAdapter;
+};
+
+export const executeFunctionUnderTest = (
+  rawCommitMessage: string,
+  when: When,
+  value: string,
+): WrappedRuleResolverResult => {
+  const baseParsedCommit = createBaseParsedCommit(rawCommitMessage);
+
+  const parsedCommitMessage: ParsedCommitMessage = {
+    issueNumbers: [],
+    isWip: rawCommitMessage === 'WIP',
+    body: [],
+  };
+
+  mockedParseCommitMessage.mockReturnValue(parsedCommitMessage);
+
+  const baseResolver: RuleResolver<string> = jest.fn(() => RESULT_FROM_BASE_RESOLVER);
+  const adapter: BaseParsedCommitAdapter = jest.fn(() => COMMIT_FROM_ADAPTER);
+
+  const result = wrappedRuleResolver(baseResolver, adapter, baseParsedCommit, when, value);
+
+  return { result, baseResolver, adapter };
+};

packages/commitlint-plugin-github-rules/src/rules/utils/tests/wrappedRuleResolver.test.ts

@@ -0,0 +1,57 @@
+import { When } from 'commitlint-github-utils/@types';
+
+import {
+  executeFunctionUnderTest,
+  EXPECTED_WHEN,
+  EXPECTED_VALUE,
+  RESULT_FROM_BASE_RESOLVER,
+  COMMIT_FROM_ADAPTER,
+  WrappedRuleResolverResult,
+} from './wrappedRuleResolver.test.setup';
+
+describe('wrappedRuleResolver', () => {
+  it('should return false if an empty commit message is provided', () => {
+    const results: WrappedRuleResolverResult[] = [
+      executeFunctionUnderTest('', EXPECTED_WHEN, EXPECTED_VALUE),
+      executeFunctionUnderTest('', EXPECTED_WHEN, EXPECTED_VALUE),
+    ];
+
+    results.forEach(execution => {
+      expect(execution.result[0]).toEqual(false);
+      expect(execution.baseResolver).not.toHaveBeenCalled();
+      expect(execution.adapter).not.toHaveBeenCalled();
+    });
+  });
+
+  it('should delegate for non-WIP Commits when validating "always"', () => {
+    const execution: WrappedRuleResolverResult = executeFunctionUnderTest('dummy commit', When.ALWAYS, EXPECTED_VALUE);
+
+    expect(execution.result).toEqual(RESULT_FROM_BASE_RESOLVER);
+    expect(execution.adapter).toHaveBeenCalled();
+    expect(execution.baseResolver).toHaveBeenCalledWith(COMMIT_FROM_ADAPTER, When.ALWAYS, EXPECTED_VALUE);
+  });
+
+  it('should delegate for non-WIP Commits when validating "never"', () => {
+    const execution: WrappedRuleResolverResult = executeFunctionUnderTest('dummy commit', When.NEVER, EXPECTED_VALUE);
+
+    expect(execution.result).toEqual(RESULT_FROM_BASE_RESOLVER);
+    expect(execution.adapter).toHaveBeenCalled();
+    expect(execution.baseResolver).toHaveBeenCalledWith(COMMIT_FROM_ADAPTER, When.NEVER, EXPECTED_VALUE);
+  });
+
+  it('should always return true for WIP Commits when validating "always" and not delegate', () => {
+    const execution: WrappedRuleResolverResult = executeFunctionUnderTest('WIP', When.ALWAYS, EXPECTED_VALUE);
+
+    expect(execution.result[0]).toEqual(true);
+    expect(execution.baseResolver).not.toHaveBeenCalled();
+    expect(execution.adapter).not.toHaveBeenCalled();
+  });
+
+  it('should always return true for WIP Commits when validating "never" and not delegate', () => {
+    const execution: WrappedRuleResolverResult = executeFunctionUnderTest('WIP', When.NEVER, EXPECTED_VALUE);
+
+    expect(execution.result[0]).toEqual(true);
+    expect(execution.baseResolver).not.toHaveBeenCalled();
+    expect(execution.adapter).not.toHaveBeenCalled();
+  });
+});

packages/commitlint-plugin-github-rules/src/rules/utils/wrappedRuleResolver.ts

@@ -0,0 +1,32 @@
+import { When } from 'commitlint-github-utils/@types';
+import utils from 'commitlint-github-utils';
+
+import { BaseParsedCommit, BaseParsedCommitAdapter, RuleResolver, RuleResolverResult } from '../../../@types';
+
+function resolveRuleUsingBaseResolver<T>(
+  baseResolver: RuleResolver<T>,
+  adapter: BaseParsedCommitAdapter,
+  parsed: BaseParsedCommit,
+  whenPassedIn?: When,
+  value?: T,
+): RuleResolverResult {
+  const rawCommitMessage = parsed.raw;
+  if (!rawCommitMessage) return [false, 'Commit message should not be empty'];
+
+  const commitMessage = utils.parseCommitMessage(rawCommitMessage);
+
+  // We short circuit if the When requested is only for non-WIPs and the commit is a WIP
+  const wipHandledResult = utils.handleWipCommits(commitMessage, whenPassedIn);
+  if (wipHandledResult.isWipValidated) {
+    // In that case we just return true immediately
+    return [true];
+  }
+
+  // Otherwise we call the base resolver with the When returned as if it was passed a NON-WIPs one
+  // it has been converted to a standard ALWAYS or NEVER which is suitable for passing to the base resolver
+  // See the docs on handleWipCommits() for more info
+
+  return baseResolver(adapter(commitMessage), wipHandledResult.when, value);
+}
+
+export default resolveRuleUsingBaseResolver;

packages/commitlint-plugin-github-rules/src/tests/index.test.ts

@@ -2,7 +2,7 @@ import commitlintPluginGitHub from '../index';
 
 describe('commitlintPluginGitHub', () => {
   it('should return a valid config', () => {
-    expect(commitlintPluginGitHub).toHaveProperty('rules')
+    expect(commitlintPluginGitHub).toHaveProperty('rules');
     expect(Object.keys(commitlintPluginGitHub.rules).length).toBeGreaterThan(0);
   });
 });