@form8ion/project 22.0.0-beta.13 → 22.0.0-beta.15

package/src/ci-provider/prompt.js

@@ -0,0 +1,17 @@
+import {questionNames} from '../prompts/question-names.js';
+
+export const CI_PROVIDER_PROMPT_ID = 'CI_PROVIDER';
+
+const {CI_PROVIDER} = questionNames.CI_PROVIDER;
+
+export default function promptForCiProvider(providers, {prompt}) {
+  return prompt({
+    id: CI_PROVIDER_PROMPT_ID,
+    questions: [{
+      name: CI_PROVIDER,
+      type: 'list',
+      message: 'Which CI service do you want use with this project?',
+      choices: [...Object.keys(providers), 'Other']
+    }]
+  });
+}

package/src/ci-provider/prompt.test.js

@@ -0,0 +1,27 @@
+import {describe, it, expect, vi} from 'vitest';
+import any from '@travi/any';
+import {when} from 'vitest-when';
+
+import promptForCiProvider, {CI_PROVIDER_PROMPT_ID} from './prompt.js';
+import {questionNames} from '../prompts/index.js';
+
+const {CI_PROVIDER} = questionNames.CI_PROVIDER;
+
+describe('ci-provider-prompt', () => {
+  it('should prompt for the provider choice', async () => {
+    const prompt = vi.fn();
+    const answers = any.simpleObject();
+    const providers = any.simpleObject();
+    when(prompt).calledWith({
+      id: CI_PROVIDER_PROMPT_ID,
+      questions: [{
+        name: CI_PROVIDER,
+        type: 'list',
+        message: 'Which CI service do you want use with this project?',
+        choices: [...Object.keys(providers), 'Other']
+      }]
+    }).thenResolve(answers);
+
+    expect(await promptForCiProvider(providers, {prompt})).toEqual(answers);
+  });
+});

package/src/ci-provider/scaffolder.js

@@ -0,0 +1,23 @@
+import {questionNames} from '../prompts/question-names.js';
+import promptForCiProvider from './prompt.js';
+
+const {CI_PROVIDER} = questionNames.CI_PROVIDER;
+
+export default 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, await plugin.qualify({projectRoot})])
+    )).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 {};
+}

package/src/ci-provider/scaffolder.test.js

@@ -0,0 +1,55 @@
+import {describe, expect, it, vi} from 'vitest';
+import any from '@travi/any';
+import {when} from 'vitest-when';
+
+import promptForCiProvider from './prompt.js';
+import scaffoldCiProvider from './scaffolder.js';
+import {questionNames} from '../prompts/index.js';
+
+vi.mock('./prompt.js');
+
+const {CI_PROVIDER} = questionNames.CI_PROVIDER;
+
+describe('ci-provider scaffolder', () => {
+  const prompt = () => undefined;
+  const projectRoot = any.string();
+  const options = {projectRoot};
+
+  it('should qualify each plugin and prompt only with those that qualify', async () => {
+    const qualifiedProviderName = any.word();
+    const unqualifiedProviderName = any.word();
+    const qualifiedScaffolder = vi.fn();
+    const qualifiedPlugin = {qualify: vi.fn(), scaffold: qualifiedScaffolder};
+    const unqualifiedPlugin = {qualify: vi.fn(), scaffold: vi.fn()};
+    const scaffolderResult = any.simpleObject();
+    when(qualifiedPlugin.qualify).calledWith({projectRoot}).thenResolve(true);
+    when(unqualifiedPlugin.qualify).calledWith({projectRoot}).thenResolve(false);
+    when(promptForCiProvider)
+      .calledWith({[qualifiedProviderName]: qualifiedPlugin}, {prompt})
+      .thenResolve({[CI_PROVIDER]: qualifiedProviderName});
+    when(qualifiedScaffolder).calledWith(options).thenResolve(scaffolderResult);
+
+    expect(await scaffoldCiProvider(
+      {[qualifiedProviderName]: qualifiedPlugin, [unqualifiedProviderName]: unqualifiedPlugin},
+      options,
+      {prompt}
+    )).toEqual(scaffolderResult);
+  });
+
+  it('should not present a prompt when no plugins are registered', async () => {
+    expect(await scaffoldCiProvider({}, options, {prompt})).toBe(undefined);
+    expect(promptForCiProvider).not.toHaveBeenCalled();
+  });
+
+  it('should return undefined when Other is chosen', async () => {
+    const providerName = any.word();
+    const plugin = {qualify: vi.fn(), scaffold: vi.fn()};
+    when(plugin.qualify).calledWith({projectRoot}).thenResolve(true);
+    when(promptForCiProvider)
+      .calledWith({[providerName]: plugin}, {prompt})
+      .thenResolve({[CI_PROVIDER]: 'Other'});
+
+    expect(await scaffoldCiProvider({[providerName]: plugin}, options, {prompt})).toEqual({});
+    expect(plugin.scaffold).not.toHaveBeenCalled();
+  });
+});

package/src/contributing/scaffolder.js

@@ -1,4 +1,4 @@
-export default function ({visibility}) {
+export default function scaffoldContribution({visibility}) {
   if ('Public' === visibility) {
     return {
       badges: {

package/src/dependency-updater/prompt.js

@@ -2,11 +2,13 @@ import {questionNames} from '../prompts/question-names.js';
 
 export const DEPENDENCY_UPDATER_PROMPT_ID = 'DEPENDENCY_UPDATER';
 
+const {DEPENDENCY_UPDATER} = questionNames.DEPENDENCY_UPDATER;
+
 export async function promptForDependencyUpdaterChoice(updaters, {prompt}) {
   return prompt({
     id: DEPENDENCY_UPDATER_PROMPT_ID,
     questions: [{
-      name: questionNames.DEPENDENCY_UPDATER,
+      name: DEPENDENCY_UPDATER,
       type: 'list',
       message: 'Which dependency-update service do you want to manage this project?',
       choices: [...Object.keys(updaters), 'Other']

package/src/dependency-updater/prompt.test.js

@@ -3,10 +3,12 @@ import any from '@travi/any';
 import {when} from 'vitest-when';
 
 import {DEPENDENCY_UPDATER_PROMPT_ID, promptForDependencyUpdaterChoice} from './prompt.js';
-import {questionNames} from '../index.js';
+import {questionNames} from '../prompts/index.js';
 
 vi.mock('@form8ion/overridable-prompts');
 
+const {DEPENDENCY_UPDATER} = questionNames.DEPENDENCY_UPDATER;
+
 describe('dependency updater prompt', () => {
   it('should enable choosing the preferred updater', async () => {
     const prompt = vi.fn();
@@ -15,7 +17,7 @@ describe('dependency updater prompt', () => {
     when(prompt).calledWith({
       id: DEPENDENCY_UPDATER_PROMPT_ID,
       questions: [{
-        name: questionNames.DEPENDENCY_UPDATER,
+        name: DEPENDENCY_UPDATER,
         type: 'list',
         message: 'Which dependency-update service do you want to manage this project?',
         choices: [...Object.keys(updaters), 'Other']

package/src/dependency-updater/scaffolder.js

@@ -1,11 +1,13 @@
 import {questionNames} from '../prompts/question-names.js';
 import {promptForDependencyUpdaterChoice} from './prompt.js';
 
-export default async function (plugins, options, {prompt}) {
+const {DEPENDENCY_UPDATER} = questionNames.DEPENDENCY_UPDATER;
+
+export default async function scaffoldDependencyUpdater(plugins, options, {prompt}) {
   if (!Object.keys(plugins).length) return undefined;
 
   const plugin = plugins[
-    (await promptForDependencyUpdaterChoice(plugins, {prompt}))[questionNames.DEPENDENCY_UPDATER]
+    (await promptForDependencyUpdaterChoice(plugins, {prompt}))[DEPENDENCY_UPDATER]
   ];
 
   if (plugin) return plugin.scaffold(options);

package/src/dependency-updater/scaffolder.test.js

@@ -4,10 +4,12 @@ import {when} from 'vitest-when';
 
 import {promptForDependencyUpdaterChoice} from './prompt.js';
 import scaffoldUpdater from './scaffolder.js';
-import {questionNames} from '../index.js';
+import {questionNames} from '../prompts/index.js';
 
 vi.mock('./prompt.js');
 
+const {DEPENDENCY_UPDATER} = questionNames.DEPENDENCY_UPDATER;
+
 describe('dependency-updater scaffolder', () => {
   const prompt = () => undefined;
 
@@ -19,7 +21,7 @@ describe('dependency-updater scaffolder', () => {
     const scaffolderResult = any.simpleObject();
     when(promptForDependencyUpdaterChoice)
       .calledWith(plugins, {prompt})
-      .thenResolve({[questionNames.DEPENDENCY_UPDATER]: chosenUpdater});
+      .thenResolve({[DEPENDENCY_UPDATER]: chosenUpdater});
     when(chosenUpdaterScaffolder).calledWith(options).thenResolve(scaffolderResult);
 
     expect(await scaffoldUpdater(plugins, options, {prompt})).toEqual(scaffolderResult);
@@ -31,8 +33,13 @@ describe('dependency-updater scaffolder', () => {
   });
 
   it('should not result in an error when choosing an updater without a defined scaffolder', async () => {
-    promptForDependencyUpdaterChoice.mockResolvedValue({[questionNames.DEPENDENCY_UPDATER]: any.word()});
+    const plugins = any.simpleObject();
+    const options = any.simpleObject();
+    const context = {prompt: undefined};
+    when(promptForDependencyUpdaterChoice)
+      .calledWith(plugins, context)
+      .thenResolve({[DEPENDENCY_UPDATER]: any.word()});
 
-    expect(await scaffoldUpdater(any.simpleObject(), any.simpleObject(), any.simpleObject())).toBe(undefined);
+    expect(await scaffoldUpdater(plugins, options, context)).toBe(undefined);
   });
 });

package/src/editorconfig/scaffolder.js

@@ -2,6 +2,6 @@ import {promises as fs} from 'node:fs';
 
 import determinePathToTemplateFile from '../template-path.js';
 
-export default function ({projectRoot}) {
+export default function scaffoldEditorConfig({projectRoot}) {
   return fs.copyFile(determinePathToTemplateFile('editorconfig.ini'), `${projectRoot}/.editorconfig`);
 }

package/src/index.js

@@ -1,7 +1,3 @@
-import {ids} from './prompts/index.js';
-
 export * from './scaffolder.js';
 export {default as lift} from './lift.js';
-export const promptConstants = {ids};
-
-export {questionNames} from './prompts/index.js';
+export {constants as promptConstants} from './prompts/index.js';

package/src/language/prompt.js

@@ -2,11 +2,13 @@ import {questionNames} from '../prompts/question-names.js';
 
 export const PROJECT_LANGUAGE_PROMPT_ID = 'PROJECT_LANGUAGE';
 
+const {PROJECT_LANGUAGE} = questionNames.PROJECT_LANGUAGE;
+
 export default function promptForProjectLanguage(languages, {prompt}) {
   return prompt({
     id: PROJECT_LANGUAGE_PROMPT_ID,
     questions: [{
-      name: questionNames.PROJECT_LANGUAGE,
+      name: PROJECT_LANGUAGE,
       type: 'list',
       message: 'What type of project is this?',
       choices: [...Object.keys(languages), 'Other']

package/src/language/prompt.test.js

@@ -7,6 +7,8 @@ import promptForLanguageDetails, {PROJECT_LANGUAGE_PROMPT_ID} from './prompt.js'
 
 vi.mock('@form8ion/overridable-prompts');
 
+const {PROJECT_LANGUAGE} = questionNames.PROJECT_LANGUAGE;
+
 describe('language prompt', () => {
   it('should prompt for the language details', async () => {
     const prompt = vi.fn();
@@ -15,7 +17,7 @@ describe('language prompt', () => {
     when(prompt).calledWith({
       id: PROJECT_LANGUAGE_PROMPT_ID,
       questions: [{
-        name: questionNames.PROJECT_LANGUAGE,
+        name: PROJECT_LANGUAGE,
         type: 'list',
         message: 'What type of project is this?',
         choices: [...Object.keys(languages), 'Other']

package/src/language/scaffolder.js

@@ -1,8 +1,10 @@
 import {questionNames} from '../prompts/question-names.js';
 import promptForLanguageDetails from './prompt.js';
 
-export default async function (languagePlugins, options, {prompt}) {
-  const {[questionNames.PROJECT_LANGUAGE]: chosenLanguage} = await promptForLanguageDetails(languagePlugins, {prompt});
+const {PROJECT_LANGUAGE} = questionNames.PROJECT_LANGUAGE;
+
+export default async function scaffoldLanguage(languagePlugins, options, {prompt}) {
+  const {[PROJECT_LANGUAGE]: chosenLanguage} = await promptForLanguageDetails(languagePlugins, {prompt});
 
   const plugin = languagePlugins[chosenLanguage];
 

package/src/language/scaffolder.test.js

@@ -2,12 +2,14 @@ import {describe, expect, it, vi} from 'vitest';
 import any from '@travi/any';
 import {when} from 'vitest-when';
 
-import * as languagePrompt from './prompt.js';
+import promptForProjectLanguage from './prompt.js';
 import {questionNames} from '../prompts/question-names.js';
 import scaffold from './scaffolder.js';
 
 vi.mock('./prompt.js');
 
+const {PROJECT_LANGUAGE} = questionNames.PROJECT_LANGUAGE;
+
 describe('language scaffolder', () => {
   it('should scaffold the chosen language', async () => {
     const options = any.simpleObject();
@@ -16,17 +18,20 @@ describe('language scaffolder', () => {
     const prompt = () => undefined;
     const chosenLanguageScaffolder = vi.fn();
     const plugins = {...any.simpleObject(), [chosenLanguage]: {scaffold: chosenLanguageScaffolder}};
-    when(languagePrompt.default)
+    when(promptForProjectLanguage)
       .calledWith(plugins, {prompt})
-      .thenResolve({[questionNames.PROJECT_LANGUAGE]: chosenLanguage});
+      .thenResolve({[PROJECT_LANGUAGE]: chosenLanguage});
     when(chosenLanguageScaffolder).calledWith(options).thenResolve(scaffolderResult);
 
     expect(await scaffold(plugins, options, {prompt})).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()});
+    const plugins = any.simpleObject();
+    const options = any.simpleObject();
+    const dependencies = {prompt: undefined};
+    when(promptForProjectLanguage).calledWith(plugins, dependencies).thenResolve({[PROJECT_LANGUAGE]: any.word()});
 
-    await scaffold(any.simpleObject(), any.simpleObject(), any.simpleObject());
+    await scaffold(plugins, options, dependencies);
   });
 });

package/src/license/lifter.js

@@ -2,7 +2,7 @@ function repositoryIsHostedOnGithub(vcs) {
   return vcs && 'github' === vcs.host;
 }
 
-export default function ({vcs}) {
+export default function liftLicense({vcs}) {
   return {
     ...repositoryIsHostedOnGithub(vcs) && {
       badges: {

package/src/license/tester.js

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

package/src/prompts/index.js

@@ -1,21 +1,20 @@
-import {questionNames as coreQuestionNames} from '@form8ion/core';
-
 import {BASE_DETAILS_PROMPT_ID} from './questions.js';
 import {GIT_REPOSITORY_PROMPT_ID} from '../vcs/prompt.js';
 import {PROJECT_LANGUAGE_PROMPT_ID} from '../language/prompt.js';
 import {REPOSITORY_HOST_PROMPT_ID} from '../vcs/host/prompt.js';
 import {DEPENDENCY_UPDATER_PROMPT_ID} from '../dependency-updater/prompt.js';
-import {questionNames as projectScaffolderQuestionNames} from './question-names.js';
+import {CI_PROVIDER_PROMPT_ID} from '../ci-provider/prompt.js';
+import {questionNames} from './question-names.js';
 
 export 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
+  DEPENDENCY_UPDATER: DEPENDENCY_UPDATER_PROMPT_ID,
+  CI_PROVIDER: CI_PROVIDER_PROMPT_ID
 };
 
-export const questionNames = {
-  ...coreQuestionNames,
-  ...projectScaffolderQuestionNames
-};
+export {questionNames};
+
+export const constants = {ids, questionNames};

package/src/prompts/question-names.js

@@ -1,7 +1,21 @@
+import {questionNames as coreQuestionNames} from '@form8ion/core';
+
 export const questionNames = {
-  GIT_REPO: 'gitRepo',
-  REPO_HOST: 'repoHost',
-  REPO_OWNER: 'repoOwner',
-  PROJECT_LANGUAGE: 'projectLanguage',
-  DEPENDENCY_UPDATER: 'dependencyUpdater'
+  BASE_DETAILS: coreQuestionNames,
+  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'
+  }
 };

package/src/scaffolder.js

@@ -7,6 +7,7 @@ import {scaffold as scaffoldLanguage} from './language/index.js';
 import {scaffold as scaffoldVcs} from './vcs/index.js';
 import {scaffold as scaffoldLicense} from './license/index.js';
 import scaffoldDependencyUpdater from './dependency-updater/scaffolder.js';
+import {scaffold as scaffoldCiProvider} from './ci-provider/index.js';
 import {promptForBaseDetails} from './prompts/questions.js';
 import {validate} from './options-validator.js';
 import {scaffold as scaffoldEditorConfig} from './editorconfig/index.js';
@@ -15,7 +16,7 @@ import lift from './lift.js';
 
 export async function scaffold(options, {prompt, logger}) {
   const projectRoot = process.cwd();
-  const {plugins: {dependencyUpdaters, languages, vcsHosts = {}}} = validate(options);
+  const {plugins: {dependencyUpdaters, ciProviders, languages, vcsHosts = {}}} = validate(options);
 
   const {
     [coreQuestionNames.PROJECT_NAME]: projectName,
@@ -35,11 +36,12 @@ export async function scaffold(options, {prompt, logger}) {
     scaffoldEditorConfig({projectRoot})
   ]);
 
-  const dependencyUpdaterResults = vcsResults.vcs && await scaffoldDependencyUpdater(
-    dependencyUpdaters,
-    {projectRoot},
-    {prompt}
-  );
+  const [dependencyUpdaterResults] = vcsResults.vcs
+    ? await Promise.all([
+      scaffoldDependencyUpdater(dependencyUpdaters, {projectRoot}, {prompt}),
+      scaffoldCiProvider(ciProviders, {projectRoot}, {prompt})
+    ])
+    : [];
 
   const language = await scaffoldLanguage(
     languages,

package/src/scaffolder.test.js

@@ -11,6 +11,7 @@ import {scaffold as scaffoldVcs} from './vcs/index.js';
 import * as licenseScaffolder from './license/scaffolder.js';
 import scaffoldLanguage from './language/scaffolder.js';
 import * as dependencyUpdaterScaffolder from './dependency-updater/scaffolder.js';
+import {scaffold as scaffoldCiProvider} from './ci-provider/index.js';
 import * as optionsValidator from './options-validator.js';
 import * as prompts from './prompts/questions.js';
 import {questionNames} from './prompts/question-names.js';
@@ -27,12 +28,15 @@ vi.mock('./vcs/index.js');
 vi.mock('./license/scaffolder');
 vi.mock('./language/scaffolder');
 vi.mock('./dependency-updater/scaffolder');
+vi.mock('./ci-provider/index.js');
 vi.mock('./options-validator');
 vi.mock('./prompts/questions');
 vi.mock('./editorconfig');
 vi.mock('./contributing');
 vi.mock('./lift.js');
 
+const {GIT_REPO} = questionNames.GIT_REPOSITORY;
+
 describe('project scaffolder', () => {
   const originalProcessCwd = process.cwd;
   const options = any.simpleObject();
@@ -71,6 +75,7 @@ describe('project scaffolder', () => {
     const holder = any.sentence();
     const copyright = {year, holder};
     const dependencyUpdaters = any.simpleObject();
+    const ciProviders = any.simpleObject();
     const dependencyUpdaterNextSteps = any.listOf(any.simpleObject);
     const dependencyUpdaterContributionBadges = any.simpleObject();
     const dependencyUpdaterResults = {
@@ -95,7 +100,7 @@ describe('project scaffolder', () => {
     ]);
     when(optionsValidator.validate)
       .calledWith(options)
-      .thenReturn({plugins: {dependencyUpdaters, languages, vcsHosts}});
+      .thenReturn({plugins: {dependencyUpdaters, ciProviders, languages, vcsHosts}});
     when(prompts.promptForBaseDetails)
       .calledWith(projectPath, {prompt})
       .thenResolve({
@@ -122,6 +127,11 @@ describe('project scaffolder', () => {
 
     expect(scaffoldReadme).toHaveBeenCalledWith({projectName, projectRoot: projectPath, description});
     expect(scaffoldEditorconfig).toHaveBeenCalledWith({projectRoot: projectPath});
+    expect(scaffoldCiProvider).toHaveBeenCalledWith(
+      ciProviders,
+      {projectRoot: projectPath},
+      {prompt}
+    );
     expect(lift).toHaveBeenCalledWith({
       projectRoot: projectPath,
       vcs,
@@ -157,7 +167,7 @@ describe('project scaffolder', () => {
       .calledWith(projectPath, {prompt})
       .thenResolve({
         [coreQuestionNames.DESCRIPTION]: description,
-        [questionNames.GIT_REPO]: true,
+        [GIT_REPO]: true,
         [coreQuestionNames.PROJECT_NAME]: projectName,
         [coreQuestionNames.VISIBILITY]: visibility
       });
@@ -174,13 +184,14 @@ describe('project scaffolder', () => {
 
   it('should not scaffold the git repo if not requested', async () => {
     when(optionsValidator.validate).calledWith(options).thenReturn({plugins: {}});
-    prompts.promptForBaseDetails.mockResolvedValue({[questionNames.GIT_REPO]: false});
+    prompts.promptForBaseDetails.mockResolvedValue({[GIT_REPO]: false});
     scaffoldReadme.mockResolvedValue();
     scaffoldVcs.mockResolvedValue({});
 
     await scaffold(options, {prompt});
 
     expect(dependencyUpdaterScaffolder.default).not.toHaveBeenCalled();
+    expect(scaffoldCiProvider).not.toHaveBeenCalled();
   });
 
   it('should scaffold the details of the chosen language plugin', async () => {
@@ -208,7 +219,7 @@ describe('project scaffolder', () => {
     prompts.promptForBaseDetails.mockResolvedValue({
       [coreQuestionNames.PROJECT_NAME]: projectName,
       [coreQuestionNames.VISIBILITY]: visibility,
-      [questionNames.GIT_REPO]: true,
+      [GIT_REPO]: true,
       [coreQuestionNames.LICENSE]: license,
       [coreQuestionNames.DESCRIPTION]: description
     });
@@ -239,7 +250,7 @@ describe('project scaffolder', () => {
     prompts.promptForBaseDetails.mockResolvedValue({
       [coreQuestionNames.PROJECT_NAME]: projectName,
       [coreQuestionNames.VISIBILITY]: visibility,
-      [questionNames.GIT_REPO]: true,
+      [GIT_REPO]: true,
       [coreQuestionNames.LICENSE]: license,
       [coreQuestionNames.DESCRIPTION]: description
     });

package/src/template-path.js

@@ -1,7 +1,7 @@
 import {resolve} from 'path';
 import filedirname from 'filedirname';
 
-export default function (fileName) {
+export default function determinePathToTemplate(fileName) {
   const [, __dirname] = filedirname();
 
   return resolve(__dirname, '..', 'templates', fileName);

package/src/vcs/host/prompt.js

@@ -2,17 +2,19 @@ import {questionNames} from '../../prompts/question-names.js';
 
 export const REPOSITORY_HOST_PROMPT_ID = 'REPOSITORY_HOST';
 
+const {REPO_HOST} = questionNames.REPOSITORY_HOST;
+
 export default async function promptForVcsHostChoice(hosts, {prompt}) {
   const answers = await prompt({
     id: REPOSITORY_HOST_PROMPT_ID,
     questions: [{
-      name: questionNames.REPO_HOST,
+      name: REPO_HOST,
       type: 'list',
       message: 'Where will the repository be hosted?',
       choices: Object.keys(hosts)
     }]
   });
-  const host = hosts[answers[questionNames.REPO_HOST]];
+  const host = hosts[answers[REPO_HOST]];
 
   return {...answers, ...host};
 }

package/src/vcs/host/prompt.test.js

@@ -8,6 +8,8 @@ import promptForVcsHostDetails, {REPOSITORY_HOST_PROMPT_ID} from './prompt.js';
 vi.mock('@form8ion/overridable-prompts');
 vi.mock('../../prompts/conditionals');
 
+const {REPO_HOST} = questionNames.REPOSITORY_HOST;
+
 describe('vcs host details prompt', () => {
   let prompt;
   const answers = any.simpleObject();
@@ -20,11 +22,11 @@ describe('vcs host details prompt', () => {
     const host = any.string();
     const hostNames = [...any.listOf(any.string), host];
     const hosts = any.objectWithKeys(hostNames, {factory: () => ({})});
-    const answersWithHostChoice = {...answers, [questionNames.REPO_HOST]: host};
+    const answersWithHostChoice = {...answers, [REPO_HOST]: host};
     when(prompt).calledWith({
       id: REPOSITORY_HOST_PROMPT_ID,
       questions: [{
-        name: questionNames.REPO_HOST,
+        name: REPO_HOST,
         type: 'list',
         message: 'Where will the repository be hosted?',
         choices: hostNames
@@ -35,11 +37,11 @@ describe('vcs host details prompt', () => {
   });
 
   it('should not throw an error when `Other` is chosen as the host', async () => {
-    const answersWithHostChoice = {...answers, [questionNames.REPO_HOST]: 'Other'};
+    const answersWithHostChoice = {...answers, [REPO_HOST]: 'Other'};
     when(prompt).calledWith({
       id: REPOSITORY_HOST_PROMPT_ID,
       questions: [{
-        name: questionNames.REPO_HOST,
+        name: REPO_HOST,
         type: 'list',
         message: 'Where will the repository be hosted?',
         choices: []

package/src/vcs/host/scaffolder.js

@@ -1,8 +1,10 @@
 import {questionNames} from '../../prompts/question-names.js';
 import promptForVcsHostDetails from './prompt.js';
 
+const {REPO_HOST} = questionNames.REPOSITORY_HOST;
+
 export default async function scaffoldVcsHost(hosts, options, {prompt}) {
-  const {[questionNames.REPO_HOST]: chosenHost} = await promptForVcsHostDetails(hosts, {prompt});
+  const {[REPO_HOST]: chosenHost} = await promptForVcsHostDetails(hosts, {prompt});
 
   const lowercasedHosts = Object.fromEntries(
     Object.entries(hosts).map(([name, details]) => [name.toLowerCase(), details])

package/src/vcs/host/scaffolder.test.js

@@ -8,6 +8,8 @@ import scaffoldVcsHost from './scaffolder.js';
 
 vi.mock('./prompt');
 
+const {REPO_HOST, REPO_OWNER} = questionNames.REPOSITORY_HOST;
+
 describe('vcs host scaffolder', () => {
   const options = any.simpleObject();
   const prompt = () => undefined;
@@ -20,7 +22,7 @@ describe('vcs host scaffolder', () => {
     const owner = any.word;
     when(promptForVcsHostDetails)
       .calledWith(hostPlugins, {prompt})
-      .thenResolve({[questionNames.REPO_HOST]: chosenHost, [questionNames.REPO_OWNER]: owner});
+      .thenResolve({[REPO_HOST]: chosenHost, [REPO_OWNER]: owner});
     when(chosenHostScaffolder).calledWith(options).thenResolve(results);
 
     expect(await scaffoldVcsHost(hostPlugins, options, {prompt})).toEqual(results);
@@ -30,7 +32,7 @@ describe('vcs host scaffolder', () => {
     const hostPlugins = any.simpleObject();
     when(promptForVcsHostDetails)
       .calledWith(hostPlugins, {prompt})
-      .thenResolve({[questionNames.REPO_HOST]: any.word()});
+      .thenResolve({[REPO_HOST]: any.word()});
 
     expect(await scaffoldVcsHost(hostPlugins, options, {prompt})).toEqual({vcs: {}});
   });