@form8ion/project 21.0.1 → 21.0.3

package/src/editorconfig/scaffolder.test.js

@@ -0,0 +1,26 @@
+import {promises as fs} from 'node:fs';
+import {resolve} from 'node:path';
+
+import {afterEach, describe, expect, it, vi} from 'vitest';
+import any from '@travi/any';
+
+import scaffoldEditorconfig from './scaffolder.js';
+
+vi.mock('fs');
+
+describe('editorconfig scaffolder', () => {
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should create the config file', async () => {
+    const projectRoot = any.string();
+
+    await scaffoldEditorconfig({projectRoot});
+
+    expect(fs.copyFile).toHaveBeenCalledWith(
+      resolve(__dirname, '..', '..', 'templates', 'editorconfig.ini'),
+      `${projectRoot}/.editorconfig`
+    );
+  });
+});

package/src/index.js

@@ -0,0 +1,9 @@
+import {questionNames as coreQuestionNames} from '@form8ion/core';
+import {questionNames as projectScaffolderQuestionNames} from './prompts/question-names.js';
+
+export * from './scaffolder.js';
+export {default as lift} from './lift.js';
+export const questionNames = {
+  ...coreQuestionNames,
+  ...projectScaffolderQuestionNames
+};

package/src/language/index.js

@@ -0,0 +1,2 @@
+export {default as scaffold} from './scaffolder.js';
+export {default as prompt} from './prompt.js';

package/src/language/prompt.js

@@ -0,0 +1,12 @@
+import {prompt} from '@form8ion/overridable-prompts';
+
+import {questionNames} from '../prompts/question-names.js';
+
+export default function (languages, decisions) {
+  return prompt([{
+    name: questionNames.PROJECT_LANGUAGE,
+    type: 'list',
+    message: 'What type of project is this?',
+    choices: [...Object.keys(languages), 'Other']
+  }], decisions);
+}

package/src/language/prompt.test.js

@@ -0,0 +1,30 @@
+import {prompt} from '@form8ion/overridable-prompts';
+
+import {afterEach, describe, expect, it, vi} from 'vitest';
+import any from '@travi/any';
+import {when} from 'vitest-when';
+
+import {questionNames} from '../prompts/question-names.js';
+import promptForLanguageDetails from './prompt.js';
+
+vi.mock('@form8ion/overridable-prompts');
+
+describe('language prompt', () => {
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should prompt for the language details', async () => {
+    const answers = any.simpleObject();
+    const decisions = any.simpleObject();
+    const languages = any.simpleObject();
+    when(prompt).calledWith([{
+      name: questionNames.PROJECT_LANGUAGE,
+      type: 'list',
+      message: 'What type of project is this?',
+      choices: [...Object.keys(languages), 'Other']
+    }], decisions).thenResolve(answers);
+
+    expect(await promptForLanguageDetails(languages, decisions)).toEqual(answers);
+  });
+});

package/src/language/scaffolder.js

@@ -0,0 +1,12 @@
+import {questionNames} from '../prompts/question-names.js';
+import promptForLanguageDetails from './prompt.js';
+
+export default async function (languagePlugins, decisions, options) {
+  const {[questionNames.PROJECT_LANGUAGE]: chosenLanguage} = await promptForLanguageDetails(languagePlugins, decisions);
+
+  const plugin = languagePlugins[chosenLanguage];
+
+  if (plugin) return plugin.scaffold(options);
+
+  return undefined;
+}

package/src/language/scaffolder.test.js

@@ -0,0 +1,32 @@
+import {describe, expect, it, vi} from 'vitest';
+import any from '@travi/any';
+import {when} from 'vitest-when';
+
+import * as languagePrompt from './prompt.js';
+import {questionNames} from '../prompts/question-names.js';
+import scaffold from './scaffolder.js';
+
+vi.mock('./prompt.js');
+
+describe('language scaffolder', () => {
+  it('should scaffold the chosen language', async () => {
+    const options = any.simpleObject();
+    const chosenLanguage = any.word();
+    const scaffolderResult = any.simpleObject();
+    const decisions = any.simpleObject();
+    const chosenLanguageScaffolder = vi.fn();
+    const plugins = {...any.simpleObject(), [chosenLanguage]: {scaffold: chosenLanguageScaffolder}};
+    when(languagePrompt.default)
+      .calledWith(plugins, decisions)
+      .thenResolve({[questionNames.PROJECT_LANGUAGE]: chosenLanguage});
+    when(chosenLanguageScaffolder).calledWith(options).thenResolve(scaffolderResult);
+
+    expect(await scaffold(plugins, decisions, options)).toEqual(scaffolderResult);
+  });
+
+  it('should not result in an error when choosing a language without a defined scaffolder', async () => {
+    languagePrompt.default.mockResolvedValue({[questionNames.PROJECT_LANGUAGE]: any.word()});
+
+    await scaffold(any.simpleObject(), any.simpleObject(), any.simpleObject());
+  });
+});

package/src/language/schema.js

@@ -0,0 +1,4 @@
+import joi from 'joi';
+import {optionsSchemas} from '@form8ion/core';
+
+export default joi.object().pattern(/^/, optionsSchemas.form8ionPlugin).default({});

package/src/language/schema.test.js

@@ -0,0 +1,43 @@
+import {validateOptions} from '@form8ion/core';
+
+import {describe, expect, it} from 'vitest';
+import any from '@travi/any';
+
+import languageSchema from './schema.js';
+
+describe('language plugins schema', () => {
+  const key = any.word();
+
+  it('should return the validated options', () => {
+    const options = any.objectWithKeys(
+      any.listOf(any.string),
+      {factory: () => ({scaffold: foo => foo})}
+    );
+
+    expect(validateOptions(languageSchema, options)).toEqual(options);
+  });
+
+  it('should require options to be provided as an object', () => {
+    expect(() => validateOptions(languageSchema, {[key]: []}))
+      .toThrowError(`"${key}" must be of type object`);
+  });
+
+  it('should require a `scaffold` property to be included', () => {
+    expect(() => validateOptions(languageSchema, {[key]: {}}))
+      .toThrowError(`"${key}.scaffold" is required`);
+  });
+
+  it('should require `scaffold` to be a function', () => {
+    expect(() => validateOptions(languageSchema, {[key]: {scaffold: any.word()}}))
+      .toThrowError(`"${key}.scaffold" must be of type function`);
+  });
+
+  it('should require the scaffolder to accept a single argument', () => {
+    expect(() => validateOptions(languageSchema, {[key]: {scaffold: () => undefined}}))
+      .toThrowError(`"${key}.scaffold" must have an arity greater or equal to 1`);
+  });
+
+  it('should default to an empty map when no updaters are provided', () => {
+    expect(validateOptions(languageSchema)).toEqual({});
+  });
+});

package/src/license/index.js

@@ -0,0 +1,3 @@
+export {default as scaffold} from './scaffolder.js';
+export {default as test} from './tester.js';
+export {default as lift} from './lifter.js';

package/src/license/lifter.js

@@ -0,0 +1,19 @@
+function repositoryIsHostedOnGithub(vcs) {
+  return vcs && 'github' === vcs.host;
+}
+
+export default function ({vcs}) {
+  return {
+    ...repositoryIsHostedOnGithub(vcs) && {
+      badges: {
+        consumer: {
+          license: {
+            link: 'LICENSE',
+            img: `https://img.shields.io/github/license/${vcs.owner}/${vcs.name}.svg?logo=opensourceinitiative`,
+            text: 'license'
+          }
+        }
+      }
+    }
+  };
+}

package/src/license/lifter.test.js

@@ -0,0 +1,30 @@
+import any from '@travi/any';
+import {describe, expect, it} from 'vitest';
+
+import lift from './lifter.js';
+
+describe('license lifter', () => {
+  it('should provide the badge if the repository is hosted on GitHub', async () => {
+    const vcsOwner = any.word();
+    const vcsName = any.word();
+    const {badges} = await lift({vcs: {host: 'github', owner: vcsOwner, name: vcsName}});
+
+    expect(badges.consumer.license).toEqual({
+      link: 'LICENSE',
+      img: `https://img.shields.io/github/license/${vcsOwner}/${vcsName}.svg?logo=opensourceinitiative`,
+      text: 'license'
+    });
+  });
+
+  it('should not provide the badge if the repository is not hosted on GitHub', async () => {
+    const {badges} = await lift({vcs: {host: any.word()}});
+
+    expect(badges).toBe(undefined);
+  });
+
+  it('should not provide the badge if the project is not under version control', async () => {
+    const {badges} = await lift({});
+
+    expect(badges).toBe(undefined);
+  });
+});

package/src/license/scaffolder.js

@@ -0,0 +1,24 @@
+import {promises as fs} from 'fs';
+import wrap from 'word-wrap';
+import mustache from 'mustache';
+// eslint-disable-next-line import/extensions
+import spdxLicenseList from 'spdx-license-list/full.js';
+import {info} from '@travi/cli-messages';
+
+export default async function ({projectRoot, license, copyright}) {
+  if (license) {
+    info('Generating License');
+
+    const licenseContent = spdxLicenseList[license].licenseText;
+
+    await fs.writeFile(
+      `${projectRoot}/LICENSE`,
+      `${wrap(
+        mustache.render(licenseContent, {year: copyright.year, 'copyright holders': copyright.holder}, {}, ['<', '>']),
+        {width: 80, indent: ''}
+      )}\n`
+    );
+  }
+
+  return {};
+}

package/src/license/scaffolder.test.js

@@ -0,0 +1,60 @@
+import {promises as fs} from 'fs';
+import wrap from 'word-wrap';
+import spdxLicenseListWithContent from 'spdx-license-list/full';
+import spdxLicenseList from 'spdx-license-list/simple';
+
+import {afterEach, describe, expect, it, vi} from 'vitest';
+import any from '@travi/any';
+
+import scaffoldLicense from './scaffolder.js';
+
+vi.mock('fs');
+
+describe('license', () => {
+  const license = any.fromList(Array.from(spdxLicenseList));
+  const year = any.word();
+  const copyrightHolders = any.sentence();
+  const copyright = {year, holder: copyrightHolders};
+  const projectRoot = any.string();
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should not generate a license file when no license was chosen', async () => {
+    await scaffoldLicense({});
+
+    expect(fs.writeFile).not.toHaveBeenCalled();
+  });
+
+  it('should write the contents for the chosen license to LICENSE', async () => {
+    expect(await scaffoldLicense({projectRoot, license, copyright, vcs: {}})).toEqual({});
+
+    expect(fs.writeFile).toHaveBeenCalledWith(
+      `${projectRoot}/LICENSE`,
+      `${wrap(
+        `${spdxLicenseListWithContent[license].licenseText}\n`
+          .replace(/<\s*year\s*>/gm, year)
+          .replace(/<copyright holders>/gm, copyrightHolders)
+          .replace(/<(.+?)>/gm, ''),
+        {width: 80, indent: ''}
+      )}\n`
+    );
+  });
+
+  it('should write the common version of the MIT license to LICENSE, when chosen', async () => {
+    expect(await scaffoldLicense({projectRoot, license: 'MIT', copyright, vcs: {}})).toEqual({});
+
+    expect(fs.writeFile).toHaveBeenCalledWith(
+      `${projectRoot}/LICENSE`,
+      `${wrap(
+        spdxLicenseListWithContent.MIT.licenseText
+          .replace('(including the next paragraph) ', '')
+          .replace(/<\s*year\s*>/gm, year)
+          .replace(/<copyright holders>/gm, copyrightHolders)
+          .replace(/<(.+?)>/gm, ''),
+        {width: 80, indent: ''}
+      )}\n`
+    );
+  });
+});

package/src/license/tester.js

@@ -0,0 +1,5 @@
+import {fileExists} from '@form8ion/core';
+
+export default function ({projectRoot}) {
+  return fileExists(`${projectRoot}/LICENSE`);
+}

package/src/license/tester.test.js

@@ -0,0 +1,25 @@
+import {fileExists} from '@form8ion/core';
+
+import {when} from 'vitest-when';
+import {expect, it, describe, vi} from 'vitest';
+import any from '@travi/any';
+
+import projectIsLicensed from './tester.js';
+
+vi.mock('@form8ion/core');
+
+describe('license predicate', () => {
+  const projectRoot = any.string();
+
+  it('should return `true` when a `LICENSE` file exists', async () => {
+    when(fileExists).calledWith(`${projectRoot}/LICENSE`).thenResolve(true);
+
+    expect(await projectIsLicensed({projectRoot})).toBe(true);
+  });
+
+  it('should return `false` when a `LICENSE` does not file exist', async () => {
+    when(fileExists).calledWith(`${projectRoot}/LICENSE`).thenResolve(false);
+
+    expect(await projectIsLicensed({projectRoot})).toBe(false);
+  });
+});

package/src/lift.js

@@ -0,0 +1,18 @@
+import {applyEnhancers} from '@form8ion/core';
+import {lift as liftReadme} from '@form8ion/readme';
+import * as gitPlugin from '@form8ion/git';
+
+import * as licensePlugin from './license/index.js';
+
+export default async function ({projectRoot, results, enhancers, vcs, dependencies}) {
+  const enhancerResults = await applyEnhancers({
+    results,
+    enhancers: {...enhancers, gitPlugin, licensePlugin},
+    options: {projectRoot, vcs},
+    dependencies
+  });
+
+  await liftReadme({projectRoot, results: enhancerResults});
+
+  return enhancerResults;
+}

package/src/lift.test.js

@@ -0,0 +1,40 @@
+import * as core from '@form8ion/core';
+import * as readme from '@form8ion/readme';
+import * as gitPlugin from '@form8ion/git';
+
+import {afterEach, describe, expect, it, vi} from 'vitest';
+import any from '@travi/any';
+import {when} from 'vitest-when';
+
+import * as licensePlugin from './license/index.js';
+import lift from './lift.js';
+
+vi.mock('deepmerge');
+vi.mock('@form8ion/core');
+vi.mock('@form8ion/readme');
+
+describe('lift', () => {
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should lift the README based on the provided results', async () => {
+    const projectRoot = any.string();
+    const enhancers = any.simpleObject();
+    const dependencies = any.simpleObject();
+    const vcs = any.simpleObject();
+    const results = any.simpleObject();
+    const enhancerResults = any.simpleObject();
+    when(core.applyEnhancers)
+      .calledWith({
+        results,
+        enhancers: {...enhancers, gitPlugin, licensePlugin},
+        options: {projectRoot, vcs},
+        dependencies
+      })
+      .thenResolve(enhancerResults);
+
+    expect(await lift({projectRoot, results, enhancers, vcs, dependencies})).toEqual(enhancerResults);
+    expect(readme.lift).toHaveBeenCalledWith({projectRoot, results: enhancerResults});
+  });
+});

package/src/options-schemas.js

@@ -0,0 +1,3 @@
+import joi from 'joi';
+
+export const decisionsSchema = joi.object();

package/src/options-schemas.test.js

@@ -0,0 +1,20 @@
+import {validateOptions} from '@form8ion/core';
+
+import {describe, expect, it} from 'vitest';
+import any from '@travi/any';
+
+import {decisionsSchema} from './options-schemas.js';
+
+describe('generic options schemas', () => {
+  describe('decisions', () => {
+    it('should return the validated options', () => {
+      const options = any.simpleObject();
+
+      expect(validateOptions(decisionsSchema, options)).toEqual(options);
+    });
+
+    it('should require the decisions to be defined as a map', () => {
+      expect(() => validateOptions(decisionsSchema, any.word())).toThrowError('must be of type object');
+    });
+  });
+});

package/src/options-validator.js

@@ -0,0 +1,18 @@
+import {validateOptions} from '@form8ion/core';
+import joi from 'joi';
+
+import languagePluginsSchema from './language/schema.js';
+import vcsHostPluginsSchema from './vcs/host/schema.js';
+import dependencyUpdaterPluginsSchema from './dependency-updater/schema.js';
+import {decisionsSchema} from './options-schemas.js';
+
+export function validate(options) {
+  return validateOptions(joi.object({
+    decisions: decisionsSchema,
+    plugins: joi.object({
+      dependencyUpdaters: dependencyUpdaterPluginsSchema,
+      languages: languagePluginsSchema,
+      vcsHosts: vcsHostPluginsSchema
+    })
+  }), options) || {};
+}

package/src/options-validator.test.js

@@ -0,0 +1,50 @@
+import joi from 'joi';
+import * as core from '@form8ion/core';
+
+import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest';
+import any from '@travi/any';
+import {when} from 'vitest-when';
+
+import languagePluginsSchema from './language/schema.js';
+import {decisionsSchema} from './options-schemas.js';
+import vcsHostPluginsSchema from './vcs/host/schema.js';
+import dependencyUpdaterPluginsSchema from './dependency-updater/schema.js';
+import {validate} from './options-validator.js';
+
+vi.mock('@form8ion/core', async () => ({
+  validateOptions: vi.fn(),
+  optionsSchemas: {form8ionPlugin: joi.object()}
+}));
+vi.mock('./vcs/host/schema.js');
+
+describe('options validator', () => {
+  beforeEach(() => {
+    vi.spyOn(joi, 'object');
+    vi.spyOn(joi, 'string');
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should build the full schema and call the base validator', () => {
+    const options = any.simpleObject();
+    const pluginsSchema = any.simpleObject();
+    const fullSchema = any.simpleObject();
+    const validatedOptions = any.simpleObject();
+    when(joi.object)
+      .calledWith({
+        dependencyUpdaters: dependencyUpdaterPluginsSchema,
+        languages: languagePluginsSchema,
+        vcsHosts: vcsHostPluginsSchema
+      })
+      .thenReturn(pluginsSchema);
+    when(joi.object).calledWith({
+      decisions: decisionsSchema,
+      plugins: pluginsSchema
+    }).thenReturn(fullSchema);
+    when(core.validateOptions).calledWith(fullSchema, options).thenReturn(validatedOptions);
+
+    expect(validate(options)).toEqual(validatedOptions);
+  });
+});

package/src/prompts/conditionals.js

@@ -0,0 +1,13 @@
+import {questionNames} from './question-names.js';
+
+export function unlicensedConfirmationShouldBePresented(answers) {
+  return 'Private' === answers[questionNames.VISIBILITY];
+}
+
+export function licenseChoicesShouldBePresented(answers) {
+  return 'Public' === answers[questionNames.VISIBILITY] || !answers[questionNames.UNLICENSED];
+}
+
+export function copyrightInformationShouldBeRequested(answers) {
+  return !!answers[questionNames.LICENSE];
+}

package/src/prompts/conditionals.test.js

@@ -0,0 +1,51 @@
+import {describe, expect, it} from 'vitest';
+import any from '@travi/any';
+
+import {questionNames} from './question-names.js';
+import {
+  copyrightInformationShouldBeRequested,
+  licenseChoicesShouldBePresented,
+  unlicensedConfirmationShouldBePresented
+} from './conditionals.js';
+
+describe('prompt conditionals', () => {
+  describe('unlicensed confirmation', () => {
+    it('should show the unlicensed confirmation for a private project', () => {
+      expect(unlicensedConfirmationShouldBePresented({[questionNames.VISIBILITY]: 'Private'})).toBe(true);
+    });
+
+    it('should not show the unlicensed confirmation for a public project', () => {
+      expect(unlicensedConfirmationShouldBePresented({[questionNames.VISIBILITY]: 'Public'})).toBe(false);
+    });
+  });
+
+  describe('license choices', () => {
+    it('should show the license choices for a public project', () => {
+      expect(licenseChoicesShouldBePresented({[questionNames.VISIBILITY]: 'Public'})).toBe(true);
+    });
+
+    it('should show the license choices for a private project that is not unlicensed', () => {
+      expect(licenseChoicesShouldBePresented({
+        [questionNames.VISIBILITY]: 'Private',
+        [questionNames.UNLICENSED]: false
+      })).toBe(true);
+    });
+
+    it('should not show the license choices for a private project that is unlicensed', () => {
+      expect(licenseChoicesShouldBePresented({
+        [questionNames.VISIBILITY]: 'Private',
+        [questionNames.UNLICENSED]: true
+      })).toBe(false);
+    });
+  });
+
+  describe('copyright', () => {
+    it('should request the copyright information when the project is licensed', () => {
+      expect(copyrightInformationShouldBeRequested({[questionNames.LICENSE]: any.string()})).toBe(true);
+    });
+
+    it('should not request the copyright information when the project is not licensed', () => {
+      expect(copyrightInformationShouldBeRequested({[questionNames.LICENSE]: undefined})).toBe(false);
+    });
+  });
+});

package/src/prompts/question-names.js

@@ -0,0 +1,7 @@
+export const questionNames = {
+  GIT_REPO: 'gitRepo',
+  REPO_HOST: 'repoHost',
+  REPO_OWNER: 'repoOwner',
+  PROJECT_LANGUAGE: 'projectLanguage',
+  DEPENDENCY_UPDATER: 'dependencyUpdater'
+};

package/src/prompts/questions.js

@@ -0,0 +1,6 @@
+import {questionsForBaseDetails} from '@form8ion/core';
+import {prompt} from '@form8ion/overridable-prompts';
+
+export function promptForBaseDetails(projectRoot, decisions) {
+  return prompt(questionsForBaseDetails(decisions, projectRoot), decisions);
+}

package/src/prompts/questions.test.js

@@ -0,0 +1,25 @@
+import * as core from '@form8ion/core';
+import * as prompts from '@form8ion/overridable-prompts';
+
+import {describe, expect, it, vi} from 'vitest';
+import any from '@travi/any';
+import {when} from 'vitest-when';
+
+import {promptForBaseDetails} from './questions.js';
+
+vi.mock('@form8ion/core');
+vi.mock('@form8ion/overridable-prompts');
+
+describe('base details prompt', () => {
+  const projectPath = any.string();
+  const answers = any.simpleObject();
+  const decisions = any.simpleObject();
+  const questions = any.listOf(any.simpleObject);
+
+  it('should prompt for the necessary details', async () => {
+    when(core.questionsForBaseDetails).calledWith(decisions, projectPath).thenReturn(questions);
+    when(prompts.prompt).calledWith(questions, decisions).thenResolve(answers);
+
+    expect(await promptForBaseDetails(projectPath, decisions)).toEqual(answers);
+  });
+});

package/src/prompts/terminal-prompt.js

@@ -0,0 +1,5 @@
+import {prompt} from '@form8ion/overridable-prompts';
+
+export default function (decisions) {
+  return ({questions}) => prompt(questions, decisions);
+}

package/src/prompts/terminal-prompt.test.js

@@ -0,0 +1,20 @@
+import {prompt as promptWithInquirer} from '@form8ion/overridable-prompts';
+
+import {when} from 'vitest-when';
+import {describe, it, vi, expect} from 'vitest';
+import any from '@travi/any';
+
+import prompt from './terminal-prompt.js';
+
+vi.mock('@form8ion/overridable-prompts');
+
+describe('terminal prompt', () => {
+  it('should present the provided questions using inquirer', async () => {
+    const questions = any.listOf(any.simpleObject);
+    const decisions = any.simpleObject();
+    const answers = any.simpleObject();
+    when(promptWithInquirer).calledWith(questions, decisions).thenResolve(answers);
+
+    expect(await prompt(decisions)({questions})).toEqual(answers);
+  });
+});