feat: added commitlint plugin

Author: webdeveric

src/index.ts

@@ -1,3 +1,14 @@
-export function demo(): boolean {
-  return true;
-}
+import { properties, type PluginRuleEntry } from './types.js';
+import { makeRule } from './utils.js';
+
+import type { Plugin } from '@commitlint/types';
+
+const ruleEntries: PluginRuleEntry[] = properties.map((property) => {
+  return [`cspell/${property}`, makeRule(property)];
+});
+
+const plugin: Plugin = {
+  rules: Object.fromEntries(ruleEntries),
+};
+
+export default plugin;

src/types.ts

@@ -0,0 +1,16 @@
+import type { Plugin } from '@commitlint/types';
+import type { RemoveIndex } from '@webdeveric/utils/types/records';
+
+export type CommitLintRule = Plugin['rules'][string];
+
+export type RuleParameters = Parameters<CommitLintRule>;
+
+export type Commit = RuleParameters[0];
+
+export type CommitBase = RemoveIndex<RuleParameters[0]>;
+
+export const properties = ['body', 'footer', 'header', 'scope', 'subject', 'type'] satisfies (keyof CommitBase)[];
+
+export type CommitProperty = (typeof properties)[number];
+
+export type PluginRuleEntry = [ruleName: `cspell/${CommitProperty}`, ruleFn: CommitLintRule];

src/utils.ts

@@ -0,0 +1,40 @@
+import { spellCheckDocument, type ValidationIssue } from 'cspell-lib';
+
+import type { CommitProperty, CommitLintRule } from './types.js';
+
+export async function checkSpelling(text: string | null | undefined): Promise<ValidationIssue[]> {
+  if (!text) {
+    return [];
+  }
+
+  const results = await spellCheckDocument(
+    {
+      text,
+      uri: '',
+      languageId: 'plaintext',
+      locale: 'en',
+    },
+    {
+      generateSuggestions: false,
+    },
+    {},
+  );
+
+  return results.issues;
+}
+
+export function makeMessage(property: CommitProperty, issues: ValidationIssue[]): string | undefined {
+  if (issues.length) {
+    const misspelledWords = issues.map((issue) => issue.text);
+
+    return `Spelling error found in ${property}: ${misspelledWords.join(', ')}`;
+  }
+}
+
+export function makeRule(property: CommitProperty): CommitLintRule {
+  return async (parsed) => {
+    const issues = await checkSpelling(parsed[property]);
+
+    return [!issues.length, makeMessage(property, issues)];
+  };
+}

test/index.test.ts

@@ -1,9 +1,12 @@
 import { describe, expect, it } from 'vitest';
 
-import { demo } from '../src/index.js';
+import plugin from '../src/index.js';
+import { properties } from '../src/types.js';
 
-describe('demo()', () => {
-  it('Does a thing', () => {
-    expect(demo()).toBeTruthy();
+describe('default export', () => {
+  it('Is a Plugin with cspell rules', () => {
+    expect(Object.keys(plugin.rules)).toEqual(
+      expect.arrayContaining(properties.map((property) => expect.stringMatching(`cspell/${property}`))),
+    );
   });
 });

test/utils.test.ts

@@ -0,0 +1,79 @@
+// cSpell:ignore Speling
+import { describe, expect, it } from 'vitest';
+
+import { checkSpelling, makeMessage, makeRule } from '../src/utils.js';
+
+import type { Commit } from '../src/types.js';
+
+describe('checkSpelling()', () => {
+  it('Returns spelling issues', async () => {
+    await expect(checkSpelling('Speling')).resolves.toEqual([
+      expect.objectContaining({
+        text: 'Speling',
+      }),
+    ]);
+
+    await expect(checkSpelling(null)).resolves.toHaveLength(0);
+    await expect(checkSpelling(undefined)).resolves.toHaveLength(0);
+  });
+});
+
+describe('makeMessage()', () => {
+  it('Returns an error message or undefined', () => {
+    expect(makeMessage('subject', [])).toBeUndefined();
+
+    expect(
+      makeMessage('subject', [
+        {
+          isFlagged: false,
+          isFound: false,
+          length: 7,
+          line: {
+            offset: 0,
+            text: 'Speling',
+          },
+          offset: 0,
+          text: 'Speling',
+        },
+      ]),
+    ).toEqual(expect.stringContaining('Speling'));
+  });
+});
+
+describe('makeRule()', () => {
+  it('Returns a commitlint rule function', async () => {
+    const ruleFn = makeRule('subject');
+
+    expect(ruleFn).instanceOf(Function);
+
+    await expect(
+      ruleFn({
+        merge: 'merge',
+        header: 'header',
+        body: 'body',
+        footer: 'footer',
+        revert: null,
+        scope: 'testing',
+        subject: 'subject',
+        notes: [],
+        references: [],
+        mentions: [],
+      } as unknown as Commit),
+    ).resolves.toEqual([true, undefined]);
+
+    await expect(
+      ruleFn({
+        merge: 'merge',
+        header: 'header',
+        body: 'body',
+        footer: 'footer',
+        revert: null,
+        scope: 'testing',
+        subject: 'Speling',
+        notes: [],
+        references: [],
+        mentions: [],
+      } as unknown as Commit),
+    ).resolves.toEqual([false, expect.stringContaining('Speling')]);
+  });
+});