feat(commitlint): enable migrating js config to json

Author: travi

src/commitlint/lifter.js

@@ -1,3 +1,21 @@
-export default function () {
+import {promises as fs} from 'node:fs';
+
+import {fileExists} from '@form8ion/core';
+
+import scaffoldCommitlint from './scaffolder.js';
+
+export default async function ({projectRoot, configs}) {
+  if (await fileExists(`${projectRoot}/.commitlintrc.js`)) {
+    await fs.unlink(`${projectRoot}/.commitlintrc.js`);
+
+    return scaffoldCommitlint({projectRoot, config: configs.commitlint});
+  }
+
+  if (await fileExists(`${projectRoot}/.commitlintrc.cjs`)) {
+    await fs.unlink(`${projectRoot}/.commitlintrc.cjs`);
+
+    return scaffoldCommitlint({projectRoot, config: configs.commitlint});
+  }
+
   return {};
 }

src/commitlint/lifter.test.js

@@ -1,9 +1,49 @@
-import {describe, expect, it} from 'vitest';
+import {promises as fs} from 'node:fs';
+import {fileExists} from '@form8ion/core';
 
+import {describe, expect, it, vi} from 'vitest';
+import any from '@travi/any';
+import {when} from 'jest-when';
+
+import scaffoldCommitlint from './scaffolder.js';
 import liftCommitlint from './lifter.js';
 
+vi.mock('node:fs');
+vi.mock('@form8ion/core');
+vi.mock('./scaffolder.js');
+
 describe('commitlint lifter', () => {
+  const projectRoot = any.string();
+  const commitlintConfig = any.simpleObject();
+  const configs = {commitlint: commitlintConfig};
+
   it('should return an empty result when config does not need the format to be changed', async () => {
-    expect(await liftCommitlint()).toEqual({});
+    when(fileExists).calledWith(`${projectRoot}/.commitlintrc.js`).mockResolvedValue(false);
+    when(fileExists).calledWith(`${projectRoot}/.commitlintrc.cjs`).mockResolvedValue(false);
+
+    expect(await liftCommitlint({projectRoot, configs})).toEqual({});
+
+    expect(scaffoldCommitlint).not.toHaveBeenCalled();
+    expect(fs.unlink).not.toHaveBeenCalled();
+  });
+
+  it('should migrate the config to json format if currently using js format', async () => {
+    const scaffoldResult = any.simpleObject();
+    when(fileExists).calledWith(`${projectRoot}/.commitlintrc.js`).mockResolvedValue(true);
+    when(fileExists).calledWith(`${projectRoot}/.commitlintrc.cjs`).mockResolvedValue(false);
+    when(scaffoldCommitlint).calledWith({projectRoot, config: commitlintConfig}).mockResolvedValue(scaffoldResult);
+
+    expect(await liftCommitlint({projectRoot, configs})).toEqual(scaffoldResult);
+    expect(fs.unlink).toHaveBeenCalledWith(`${projectRoot}/.commitlintrc.js`);
+  });
+
+  it('should migrate the config to json format if currently using cjs format', async () => {
+    const scaffoldResult = any.simpleObject();
+    when(fileExists).calledWith(`${projectRoot}/.commitlintrc.js`).mockResolvedValue(false);
+    when(fileExists).calledWith(`${projectRoot}/.commitlintrc.cjs`).mockResolvedValue(true);
+    when(scaffoldCommitlint).calledWith({projectRoot, config: commitlintConfig}).mockResolvedValue(scaffoldResult);
+
+    expect(await liftCommitlint({projectRoot, configs})).toEqual(scaffoldResult);
+    expect(fs.unlink).toHaveBeenCalledWith(`${projectRoot}/.commitlintrc.cjs`);
   });
 });

src/lifter.js

@@ -3,9 +3,9 @@ import {applyEnhancers} from '@form8ion/core';
 import * as semanticReleasePlugin from './semantic-release/index.js';
 import * as commitlintPlugin from './commitlint/index.js';
 
-export default async function ({projectRoot}) {
+export default async function ({projectRoot, configs}) {
   return applyEnhancers({
-    options: {projectRoot},
+    options: {projectRoot, configs},
     enhancers: {
       'semantic-release': semanticReleasePlugin,
       commitlint: commitlintPlugin

src/lifter.test.js

@@ -13,17 +13,18 @@ vi.mock('@form8ion/core');
 describe('lifter', () => {
   it('should apply the enhancers', async () => {
     const projectRoot = any.string();
+    const configs = any.simpleObject();
     const enhancerResults = any.simpleObject();
     when(applyEnhancers)
       .calledWith({
-        options: {projectRoot},
+        options: {projectRoot, configs},
         enhancers: {
           'semantic-release': semanticReleasePlugin,
           commitlint: commitlintPlugin
         }
       })
       .mockResolvedValue(enhancerResults);
 
-    expect(await lift({projectRoot})).toEqual(enhancerResults);
+    expect(await lift({projectRoot, configs})).toEqual(enhancerResults);
   });
 });

src/tester-test.js

@@ -3,6 +3,7 @@ import any from '@travi/any';
 import sinon from 'sinon';
 
 import * as semanticReleaseTester from './semantic-release/tester.js';
+import * as commitlintTester from './commitlint/tester.js';
 import testForCommitConvention from './tester.js';
 
 suite('predicate', () => {
@@ -14,18 +15,28 @@ suite('predicate', () => {
     sandbox = sinon.createSandbox();
 
     sandbox.stub(semanticReleaseTester, 'default');
+    sandbox.stub(commitlintTester, 'default');
   });
 
   teardown(() => sandbox.restore());
 
   test('that `true` is returned when semantic-release use is detected', async () => {
     semanticReleaseTester.default.withArgs({projectRoot}).resolves(true);
+    commitlintTester.default.withArgs({projectRoot}).resolves(false);
 
     assert.isTrue(await testForCommitConvention({projectRoot}));
   });
 
-  test('that `false` is returned when semantic-release use is not detected', async () => {
+  test('that `true` is returned when commitlint use is detected', async () => {
     semanticReleaseTester.default.withArgs({projectRoot}).resolves(false);
+    commitlintTester.default.withArgs({projectRoot}).resolves(true);
+
+    assert.isTrue(await testForCommitConvention({projectRoot}));
+  });
+
+  test('that `false` is returned when neither semantic-release nor commitlint use is detected', async () => {
+    semanticReleaseTester.default.withArgs({projectRoot}).resolves(false);
+    commitlintTester.default.withArgs({projectRoot}).resolves(false);
 
     assert.isFalse(await testForCommitConvention({projectRoot}));
   });

src/tester.js

@@ -1,5 +1,6 @@
 import {test as semanticReleaseIsInUse} from './semantic-release/index.js';
+import {test as commitlintIsInUse} from './commitlint/index.js';
 
-export default function ({projectRoot}) {
-  return semanticReleaseIsInUse({projectRoot});
+export default async function ({projectRoot}) {
+  return await semanticReleaseIsInUse({projectRoot}) || commitlintIsInUse({projectRoot});
 }

test/integration/features/lift/commitlint.feature

@@ -1,13 +1,11 @@
 Feature: Lift Commitlint
 
-  @wip
   Scenario: js config exists
     Given commitlint is configured with a "js" extension
     When the project is lifted
     Then commitlint will be configured
     But other commitlint config formats do not exist
 
-  @wip
   Scenario: cjs config exists
     Given commitlint is configured with a "cjs" extension
     When the project is lifted

test/integration/features/step_definitions/common-steps.js

@@ -103,7 +103,7 @@ When('the project is lifted', async function () {
   });
 
   if (await test({projectRoot: this.projectRoot})) {
-    await lift({projectRoot: this.projectRoot});
+    await lift({projectRoot: this.projectRoot, configs: {commitlint: {name: this.commilintConfigName}}});
   }
 });