@form8ion/project 22.0.0-beta.2 → 22.0.0-beta.20

package/README.md

@@ -71,45 +71,89 @@ a wrapper.
 #### Import
 
 ```javascript
-import {lift, questionNames, scaffold} from '@form8ion/project';
+import {ungroupObject} from '@form8ion/core';
+import {lift, promptConstants, scaffold} from '@form8ion/project';
 ```
 
 #### Execute
 
 ```javascript
-await scaffold({
-  decisions: {
-    [questionNames.PROJECT_NAME]: 'my-project',
-    [questionNames.LICENSE]: 'MIT',
-    [questionNames.VISIBILITY]: 'Public',
-    [questionNames.DESCRIPTION]: 'My project',
-    [questionNames.GIT_REPO]: false,
-    [questionNames.COPYRIGHT_HOLDER]: 'John Smith',
-    [questionNames.COPYRIGHT_YEAR]: '2022',
-    [questionNames.PROJECT_LANGUAGE]: 'foo'
+const plugins = {
+  dependencyUpdaters: {
+    bar: {scaffold: options => options}
   },
-  plugins: {
-    dependencyUpdaters: {
-      bar: {scaffold: options => options}
-    },
-    languages: {
-      foo: {scaffold: options => options}
-    },
-    vcsHosts: {
-      baz: {
-        scaffold: options => options,
-        prompt: () => ({repoOwner: 'form8ion'})
-      }
+  languages: {
+    foo: {scaffold: options => options}
+  },
+  vcsHosts: {
+    baz: {
+      scaffold: options => options,
+      prompt: () => ({repoOwner: 'form8ion'})
     }
   }
-});
+};
+const logger = {
+  info: () => undefined,
+  success: () => undefined,
+  warn: () => undefined,
+  error: () => undefined
+};
+
+await scaffold(
+  {plugins},
+  {
+    prompt: async ({id}) => {
+      const {questionNames, ids} = promptConstants;
+      const {
+        BASE_DETAILS: baseDetailsPromptId,
+        GIT_REPOSITORY: gitRepositoryPromptId,
+        PROJECT_LANGUAGE: projectLanguagePromptId
+      } = ids;
+
+      switch (id) {
+        case baseDetailsPromptId: {
+          const {
+            PROJECT_NAME,
+            LICENSE,
+            VISIBILITY,
+            DESCRIPTION,
+            COPYRIGHT_HOLDER,
+            COPYRIGHT_YEAR
+          } = questionNames[baseDetailsPromptId];
+
+          return {
+            [PROJECT_NAME]: 'my-project',
+            [LICENSE]: 'MIT',
+            [VISIBILITY]: 'OSS',
+            [DESCRIPTION]: 'My project',
+            [COPYRIGHT_HOLDER]: 'John Smith',
+            [COPYRIGHT_YEAR]: '2022'
+          };
+        }
+        case gitRepositoryPromptId: {
+          const {GIT_REPO} = questionNames[gitRepositoryPromptId];
+
+          return {[GIT_REPO]: false};
+        }
+        case projectLanguagePromptId: {
+          const {PROJECT_LANGUAGE} = questionNames[projectLanguagePromptId];
+
+          return {[PROJECT_LANGUAGE]: 'foo'};
+        }
+        default:
+          throw new Error(`Unknown prompt with ID: ${id}`);
+      }
+    },
+    logger
+  }
+);
 
 await lift({
   projectRoot: process.cwd(),
   results: {},
-  enhancers: {foo: {test: () => true, lift: () => ({})}},
+  enhancers: ungroupObject(plugins),
   vcs: {}
-});
+}, {logger});
 ```
 
 ### API

package/lib/index.js

@@ -1,14 +1,11 @@
-import { fileExists, questionsForBaseDetails, optionsSchemas, validateOptions, applyEnhancers, questionNames as questionNames$2 } from '@form8ion/core';
 import deepmerge from 'deepmerge';
 import { execa } from 'execa';
-import { reportResults } from '@form8ion/results-reporter';
+import { questionNames as questionNames$1, fileExists, questionsForBaseDetails, optionsSchemas, validateOptions, applyEnhancers } from '@form8ion/core';
 import { lift as lift$1, scaffold as scaffold$2 } from '@form8ion/readme';
-import { warn, info } from '@travi/cli-messages';
-import { prompt } from '@form8ion/overridable-prompts';
 import * as gitPlugin from '@form8ion/git';
 import { test, scaffold as scaffold$1 } from '@form8ion/git';
 import { simpleGit } from 'simple-git';
-import hostedGitInfo from 'hosted-git-info';
+import parseGitUrl from 'git-url-parse';
 import { promises } from 'fs';
 import wrap from 'word-wrap';
 import mustache from 'mustache';
@@ -18,25 +15,46 @@ import { promises as promises$1 } from 'node:fs';
 import { resolve } from 'path';
 import filedirname from 'filedirname';
 
-const questionNames$1 = {
-  GIT_REPO: 'gitRepo',
-  REPO_HOST: 'repoHost',
-  REPO_OWNER: 'repoOwner',
-  PROJECT_LANGUAGE: 'projectLanguage',
-  DEPENDENCY_UPDATER: 'dependencyUpdater'
+const questionNames = {
+  BASE_DETAILS: questionNames$1,
+  GIT_REPOSITORY: {
+    GIT_REPO: 'gitRepo'
+  },
+  REPOSITORY_HOST: {
+    REPO_HOST: 'repoHost',
+    REPO_OWNER: 'repoOwner'
+  },
+  PROJECT_LANGUAGE: {
+    PROJECT_LANGUAGE: 'projectLanguage'
+  },
+  DEPENDENCY_UPDATER: {
+    DEPENDENCY_UPDATER: 'dependencyUpdater'
+  },
+  CI_PROVIDER: {
+    CI_PROVIDER: 'ciProvider'
+  }
 };
 
-function promptForLanguageDetails (languages, decisions) {
-  return prompt([{
-    name: questionNames$1.PROJECT_LANGUAGE,
-    type: 'list',
-    message: 'What type of project is this?',
-    choices: [...Object.keys(languages), 'Other']
-  }], decisions);
+const PROJECT_LANGUAGE_PROMPT_ID = 'PROJECT_LANGUAGE';
+
+const {PROJECT_LANGUAGE: PROJECT_LANGUAGE$1} = questionNames.PROJECT_LANGUAGE;
+
+function promptForProjectLanguage(languages, {prompt}) {
+  return prompt({
+    id: PROJECT_LANGUAGE_PROMPT_ID,
+    questions: [{
+      name: PROJECT_LANGUAGE$1,
+      type: 'list',
+      message: 'What type of project is this?',
+      choices: [...Object.keys(languages), 'Other']
+    }]
+  });
 }
 
-async function scaffoldLanguage (languagePlugins, decisions, options) {
-  const {[questionNames$1.PROJECT_LANGUAGE]: chosenLanguage} = await promptForLanguageDetails(languagePlugins, decisions);
+const {PROJECT_LANGUAGE} = questionNames.PROJECT_LANGUAGE;
+
+async function scaffoldLanguage(languagePlugins, options, {prompt}) {
+  const {[PROJECT_LANGUAGE]: chosenLanguage} = await promptForProjectLanguage(languagePlugins, {prompt});
 
   const plugin = languagePlugins[chosenLanguage];
 
@@ -45,16 +63,20 @@ async function scaffoldLanguage (languagePlugins, decisions, options) {
   return undefined;
 }
 
-async function promptForRepoCreation(decisions) {
-  const {[questionNames$1.GIT_REPO]: gitRepoShouldBeCreated} = await prompt(
-    [{
-      name: questionNames$1.GIT_REPO,
+const GIT_REPOSITORY_PROMPT_ID = 'GIT_REPOSITORY';
+
+const {GIT_REPO} = questionNames.GIT_REPOSITORY;
+
+async function promptForRepoCreation({prompt}) {
+  const {[GIT_REPO]: gitRepoShouldBeCreated} = await prompt({
+    id: GIT_REPOSITORY_PROMPT_ID,
+    questions: [{
+      name: GIT_REPO,
       type: 'confirm',
       default: true,
       message: 'Should a git repository be initialized?'
-    }],
-    decisions
-  );
+    }]
+  });
 
   return gitRepoShouldBeCreated;
 }
@@ -74,14 +96,14 @@ async function getExistingRemotes(git) {
 async function determineExistingVcsDetails({projectRoot}) {
   const git = simpleGit({baseDir: projectRoot});
   const remoteOrigin = await git.remote(['get-url', 'origin']);
-  const {user, project, type} = hostedGitInfo.fromUrl(remoteOrigin);
+  const {owner, name, host} = parseGitUrl(remoteOrigin.trimEnd());
 
-  return {vcs: {owner: user, name: project, host: type}};
+  return {vcs: {owner, name, host}};
 }
 
-async function defineRemoteOrigin(projectRoot, sshUrl) {
+async function defineRemoteOrigin(projectRoot, sshUrl, {logger}) {
   if (!sshUrl) {
-    warn('URL not available to configure remote `origin`');
+    logger.warn('URL not available to configure remote `origin`');
 
     return {nextSteps: []};
   }
@@ -90,7 +112,7 @@ async function defineRemoteOrigin(projectRoot, sshUrl) {
   const existingRemotes = await getExistingRemotes(git);
 
   if (existingRemotes.includes('origin')) {
-    warn('The `origin` remote is already defined for this repository');
+    logger.warn('The `origin` remote is already defined for this repository');
 
     return {nextSteps: []};
   }
@@ -107,20 +129,29 @@ async function defineRemoteOrigin(projectRoot, sshUrl) {
   return {nextSteps: [{summary: 'Set local `master` branch to track upstream `origin/master`'}]};
 }
 
-async function promptForVcsHostDetails (hosts, decisions) {
-  const answers = await prompt([{
-    name: questionNames$1.REPO_HOST,
-    type: 'list',
-    message: 'Where will the repository be hosted?',
-    choices: Object.keys(hosts)
-  }], decisions);
-  const host = hosts[answers[questionNames$1.REPO_HOST]];
+const REPOSITORY_HOST_PROMPT_ID = 'REPOSITORY_HOST';
+
+const {REPO_HOST: REPO_HOST$1} = questionNames.REPOSITORY_HOST;
+
+async function promptForVcsHostChoice(hosts, {prompt}) {
+  const answers = await prompt({
+    id: REPOSITORY_HOST_PROMPT_ID,
+    questions: [{
+      name: REPO_HOST$1,
+      type: 'list',
+      message: 'Where will the repository be hosted?',
+      choices: Object.keys(hosts)
+    }]
+  });
+  const host = hosts[answers[REPO_HOST$1]];
 
   return {...answers, ...host};
 }
 
-async function scaffoldVcsHost(hosts, decisions, options) {
-  const {[questionNames$1.REPO_HOST]: chosenHost} = await promptForVcsHostDetails(hosts, decisions);
+const {REPO_HOST} = questionNames.REPOSITORY_HOST;
+
+async function scaffoldVcsHost(hosts, options, {prompt}) {
+  const {[REPO_HOST]: chosenHost} = await promptForVcsHostChoice(hosts, {prompt});
 
   const lowercasedHosts = Object.fromEntries(
     Object.entries(hosts).map(([name, details]) => [name.toLowerCase(), details])
@@ -132,24 +163,23 @@ async function scaffoldVcsHost(hosts, decisions, options) {
   return {vcs: {}};
 }
 
-async function scaffoldVcs({projectRoot, projectName, decisions, vcsHosts, visibility, description}) {
-  if (await promptForRepoCreation(decisions)) {
+async function scaffoldVcs(
+  {projectRoot, projectName, vcsHosts, visibility, description},
+  {prompt, logger}
+) {
+  if (await promptForRepoCreation({prompt})) {
     if (await test({projectRoot})) {
-      info('Git repository already exists');
+      logger.info('Git repository already exists');
 
-      return {vcs: await determineExistingVcsDetails({projectRoot})};
+      return determineExistingVcsDetails({projectRoot});
     }
 
     const [{vcs: {host, owner, name, sshUrl}}] = await Promise.all([
-      scaffoldVcsHost(
-        vcsHosts,
-        decisions,
-        {projectName, projectRoot, description, visibility}
-      ),
+      scaffoldVcsHost(vcsHosts, {projectName, projectRoot, description, visibility}, {prompt}),
       scaffold$1({projectRoot})
     ]);
 
-    const remoteOriginResults = await defineRemoteOrigin(projectRoot, sshUrl);
+    const remoteOriginResults = await defineRemoteOrigin(projectRoot, sshUrl, {logger});
 
     return {
       vcs: {host, owner, name},
@@ -160,9 +190,9 @@ async function scaffoldVcs({projectRoot, projectName, decisions, vcsHosts, visib
   return {};
 }
 
-async function scaffoldLicense ({projectRoot, license, copyright}) {
+async function scaffoldLicense({projectRoot, license, copyright}, {logger}) {
   if (license) {
-    info('Generating License');
+    logger.info('Generating License');
 
     const licenseContent = spdxLicenseList[license].licenseText;
 
@@ -178,7 +208,7 @@ async function scaffoldLicense ({projectRoot, license, copyright}) {
   return {};
 }
 
-function tester ({projectRoot}) {
+function licenseDefined({projectRoot}) {
   return fileExists(`${projectRoot}/LICENSE`);
 }
 
@@ -186,7 +216,7 @@ function repositoryIsHostedOnGithub(vcs) {
   return vcs && 'github' === vcs.host;
 }
 
-function lifter ({vcs}) {
+function liftLicense({vcs}) {
   return {
     ...repositoryIsHostedOnGithub(vcs) && {
       badges: {
@@ -204,25 +234,34 @@ function lifter ({vcs}) {
 
 var licensePlugin = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  lift: lifter,
+  lift: liftLicense,
   scaffold: scaffoldLicense,
-  test: tester
+  test: licenseDefined
 });
 
-async function promptForDependencyUpdaterChoice(updaters, decisions) {
-  return prompt([{
-    name: questionNames$1.DEPENDENCY_UPDATER,
-    type: 'list',
-    message: 'Which dependency-update service do you want to manage this project?',
-    choices: [...Object.keys(updaters), 'Other']
-  }], decisions);
+const DEPENDENCY_UPDATER_PROMPT_ID = 'DEPENDENCY_UPDATER';
+
+const {DEPENDENCY_UPDATER: DEPENDENCY_UPDATER$1} = questionNames.DEPENDENCY_UPDATER;
+
+async function promptForDependencyUpdaterChoice(updaters, {prompt}) {
+  return prompt({
+    id: DEPENDENCY_UPDATER_PROMPT_ID,
+    questions: [{
+      name: DEPENDENCY_UPDATER$1,
+      type: 'list',
+      message: 'Which dependency-update service do you want to manage this project?',
+      choices: [...Object.keys(updaters), 'Other']
+    }]
+  });
 }
 
-async function scaffoldDependencyUpdater (plugins, decisions, options) {
+const {DEPENDENCY_UPDATER} = questionNames.DEPENDENCY_UPDATER;
+
+async function scaffoldDependencyUpdater(plugins, options, {prompt}) {
   if (!Object.keys(plugins).length) return undefined;
 
   const plugin = plugins[
-    (await promptForDependencyUpdaterChoice(plugins, decisions))[questionNames$1.DEPENDENCY_UPDATER]
+    (await promptForDependencyUpdaterChoice(plugins, {prompt}))[DEPENDENCY_UPDATER]
   ];
 
   if (plugin) return plugin.scaffold(options);
@@ -230,8 +269,54 @@ async function scaffoldDependencyUpdater (plugins, decisions, options) {
   return undefined;
 }
 
-function promptForBaseDetails(projectRoot, decisions) {
-  return prompt(questionsForBaseDetails(decisions, projectRoot), decisions);
+const CI_PROVIDER_PROMPT_ID = 'CI_PROVIDER';
+
+const {CI_PROVIDER: CI_PROVIDER$1} = questionNames.CI_PROVIDER;
+
+function promptForCiProvider(providers, {prompt}) {
+  return prompt({
+    id: CI_PROVIDER_PROMPT_ID,
+    questions: [{
+      name: CI_PROVIDER$1,
+      type: 'list',
+      message: 'Which CI service do you want use with this project?',
+      choices: [...Object.keys(providers), 'Other']
+    }]
+  });
+}
+
+const {CI_PROVIDER} = questionNames.CI_PROVIDER;
+
+async function scaffoldCiProvider(plugins, options, {prompt}) {
+  if (!Object.keys(plugins).length) return undefined;
+
+  const {projectRoot} = options;
+
+  const qualifiedPlugins = Object.fromEntries(
+    (await Promise.all(
+      Object.entries(plugins).map(async ([name, plugin]) => [
+        name,
+        plugin,
+        plugin.qualify ? await plugin.qualify({projectRoot}) : true
+      ])
+    )).filter(([, , qualified]) => qualified).map(([name, plugin]) => [name, plugin])
+  );
+
+  const chosen = (await promptForCiProvider(qualifiedPlugins, {prompt}))[CI_PROVIDER];
+  const plugin = qualifiedPlugins[chosen];
+
+  if (plugin) return plugin.scaffold(options);
+
+  return {};
+}
+
+const BASE_DETAILS_PROMPT_ID = 'BASE_DETAILS';
+
+function promptForBaseDetails(projectRoot, {prompt}) {
+  return prompt({
+    id: BASE_DETAILS_PROMPT_ID,
+    questions: questionsForBaseDetails(projectRoot)
+  });
 }
 
 var languagePluginsSchema = joi.object().pattern(/^/, optionsSchemas.form8ionPlugin).default({});
@@ -240,31 +325,35 @@ var vcsHostPluginsSchema = joi.object().pattern(/^/, optionsSchemas.form8ionPlug
 
 var dependencyUpdaterPluginsSchema = joi.object().pattern(joi.string(), optionsSchemas.form8ionPlugin).default({});
 
-const decisionsSchema = joi.object();
+var ciProviderPluginsSchema = joi.object().pattern(joi.string(), optionsSchemas.form8ionPlugin).default({});
 
 function validate(options) {
   return validateOptions(joi.object({
-    decisions: decisionsSchema,
     plugins: joi.object({
       dependencyUpdaters: dependencyUpdaterPluginsSchema,
       languages: languagePluginsSchema,
-      vcsHosts: vcsHostPluginsSchema
+      vcsHosts: vcsHostPluginsSchema,
+      ciProviders: ciProviderPluginsSchema
     })
   }), options) || {};
 }
 
-function determinePathToTemplateFile (fileName) {
+function determinePathToTemplate(fileName) {
   const [, __dirname] = filedirname();
 
   return resolve(__dirname, '..', 'templates', fileName);
 }
 
-function scaffoldEditorConfig ({projectRoot}) {
-  return promises$1.copyFile(determinePathToTemplateFile('editorconfig.ini'), `${projectRoot}/.editorconfig`);
+function scaffoldEditorConfig({projectRoot}) {
+  return promises$1.copyFile(determinePathToTemplate('editorconfig.ini'), `${projectRoot}/.editorconfig`);
 }
 
-function scaffoldContributing ({visibility}) {
-  if ('Public' === visibility) {
+function editorconfigInUse({projectRoot}) {
+  return fileExists(`${projectRoot}/.editorconfig`);
+}
+
+function scaffoldContribution({visibility}) {
+  if (['OSS', 'ISS'].includes(visibility)) {
     return {
       badges: {
         contribution: {
@@ -281,7 +370,11 @@ function scaffoldContributing ({visibility}) {
   return {};
 }
 
-async function lift ({projectRoot, results, enhancers, vcs, dependencies}) {
+async function lift({projectRoot, results, enhancers, vcs}, dependencies) {
+  if (!await editorconfigInUse({projectRoot})) {
+    await scaffoldEditorConfig({projectRoot});
+  }
+
   const enhancerResults = await applyEnhancers({
     results,
     enhancers: {...enhancers, gitPlugin, licensePlugin},
@@ -294,38 +387,40 @@ async function lift ({projectRoot, results, enhancers, vcs, dependencies}) {
   return enhancerResults;
 }
 
-async function scaffold(options) {
+async function scaffold(options, dependencies) {
   const projectRoot = process.cwd();
-  const {decisions, plugins: {dependencyUpdaters, languages, vcsHosts = {}}} = validate(options);
+  const {plugins: {dependencyUpdaters, ciProviders, languages, vcsHosts = {}}} = validate(options);
+  const {prompt, logger} = dependencies;
 
   const {
-    [questionNames$2.PROJECT_NAME]: projectName,
-    [questionNames$2.LICENSE]: chosenLicense,
-    [questionNames$2.VISIBILITY]: visibility,
-    [questionNames$2.DESCRIPTION]: description,
-    [questionNames$2.COPYRIGHT_YEAR]: copyrightYear,
-    [questionNames$2.COPYRIGHT_HOLDER]: copyHolder
-  } = await promptForBaseDetails(projectRoot, decisions);
+    [questionNames$1.PROJECT_NAME]: projectName,
+    [questionNames$1.LICENSE]: chosenLicense,
+    [questionNames$1.VISIBILITY]: visibility,
+    [questionNames$1.DESCRIPTION]: description,
+    [questionNames$1.COPYRIGHT_YEAR]: copyrightYear,
+    [questionNames$1.COPYRIGHT_HOLDER]: copyHolder
+  } = await promptForBaseDetails(projectRoot, {prompt});
   const copyright = {year: copyrightYear, holder: copyHolder};
 
   const [vcsResults, contributing, license] = await Promise.all([
-    scaffoldVcs({projectRoot, projectName, decisions, vcsHosts, visibility, description}),
-    scaffoldContributing({visibility}),
-    scaffoldLicense({projectRoot, license: chosenLicense, copyright}),
+    scaffoldVcs({projectRoot, projectName, vcsHosts, visibility, description}, {prompt, logger}),
+    scaffoldContribution({visibility}),
+    scaffoldLicense({projectRoot, license: chosenLicense, copyright}, {logger}),
     scaffold$2({projectName, projectRoot, description}),
     scaffoldEditorConfig({projectRoot})
   ]);
 
-  const dependencyUpdaterResults = vcsResults.vcs && await scaffoldDependencyUpdater(
-    dependencyUpdaters,
-    decisions,
-    {projectRoot}
-  );
+  const [dependencyUpdaterResults] = vcsResults.vcs
+    ? await Promise.all([
+      scaffoldDependencyUpdater(dependencyUpdaters, {projectRoot}, {prompt}),
+      scaffoldCiProvider(ciProviders, {projectRoot}, {prompt})
+    ])
+    : [];
 
   const language = await scaffoldLanguage(
     languages,
-    decisions,
-    {projectRoot, projectName, vcs: vcsResults.vcs, visibility, license: chosenLicense || 'UNLICENSED', description}
+    {projectRoot, projectName, vcs: vcsResults.vcs, visibility, license: chosenLicense || 'UNLICENSED', description},
+    {prompt}
   );
 
   const mergedResults = deepmerge.all([
@@ -341,23 +436,29 @@ async function scaffold(options) {
     vcs: vcsResults.vcs,
     results: mergedResults,
     enhancers: {...dependencyUpdaters, ...languages, ...vcsHosts}
-  });
+  }, dependencies);
 
   if (language && language.verificationCommand) {
-    info('Verifying the generated project');
+    logger.info('Verifying the generated project');
 
     const subprocess = execa(language.verificationCommand, {shell: true});
     subprocess.stdout.pipe(process.stdout);
     await subprocess;
   }
 
-  reportResults(mergedResults);
+  return mergedResults;
 }
 
-const questionNames = {
-  ...questionNames$2,
-  ...questionNames$1
+const ids = {
+  BASE_DETAILS: BASE_DETAILS_PROMPT_ID,
+  GIT_REPOSITORY: GIT_REPOSITORY_PROMPT_ID,
+  REPOSITORY_HOST: REPOSITORY_HOST_PROMPT_ID,
+  PROJECT_LANGUAGE: PROJECT_LANGUAGE_PROMPT_ID,
+  DEPENDENCY_UPDATER: DEPENDENCY_UPDATER_PROMPT_ID,
+  CI_PROVIDER: CI_PROVIDER_PROMPT_ID
 };
 
-export { lift, questionNames, scaffold };
+const constants = {ids, questionNames};
+
+export { lift, constants as promptConstants, scaffold };
 //# sourceMappingURL=index.js.map