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

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/editorconfig/tester.js

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

package/src/editorconfig/tester.test.js

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

package/src/index.js

@@ -1,9 +1,3 @@
-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
-};
+export {constants as promptConstants} from './prompts/index.js';

package/src/language/prompt.js

@@ -1,12 +1,17 @@
-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);
+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: PROJECT_LANGUAGE,
+      type: 'list',
+      message: 'What type of project is this?',
+      choices: [...Object.keys(languages), 'Other']
+    }]
+  });
 }

package/src/language/prompt.test.js

@@ -1,30 +1,29 @@
-import {prompt} from '@form8ion/overridable-prompts';
-
-import {afterEach, describe, expect, it, vi} from 'vitest';
+import {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';
+import promptForLanguageDetails, {PROJECT_LANGUAGE_PROMPT_ID} from './prompt.js';
 
 vi.mock('@form8ion/overridable-prompts');
 
-describe('language prompt', () => {
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
+const {PROJECT_LANGUAGE} = questionNames.PROJECT_LANGUAGE;
 
+describe('language prompt', () => {
   it('should prompt for the language details', async () => {
+    const prompt = vi.fn();
     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);
+    when(prompt).calledWith({
+      id: PROJECT_LANGUAGE_PROMPT_ID,
+      questions: [{
+        name: PROJECT_LANGUAGE,
+        type: 'list',
+        message: 'What type of project is this?',
+        choices: [...Object.keys(languages), 'Other']
+      }]
+    }).thenResolve(answers);
 
-    expect(await promptForLanguageDetails(languages, decisions)).toEqual(answers);
+    expect(await promptForLanguageDetails(languages, {prompt})).toEqual(answers);
   });
 });

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, decisions, options) {
-  const {[questionNames.PROJECT_LANGUAGE]: chosenLanguage} = await promptForLanguageDetails(languagePlugins, decisions);
+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,31 +2,36 @@ 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();
     const chosenLanguage = any.word();
     const scaffolderResult = any.simpleObject();
-    const decisions = any.simpleObject();
+    const prompt = () => undefined;
     const chosenLanguageScaffolder = vi.fn();
     const plugins = {...any.simpleObject(), [chosenLanguage]: {scaffold: chosenLanguageScaffolder}};
-    when(languagePrompt.default)
-      .calledWith(plugins, decisions)
-      .thenResolve({[questionNames.PROJECT_LANGUAGE]: chosenLanguage});
+    when(promptForProjectLanguage)
+      .calledWith(plugins, {prompt})
+      .thenResolve({[PROJECT_LANGUAGE]: chosenLanguage});
     when(chosenLanguageScaffolder).calledWith(options).thenResolve(scaffolderResult);
 
-    expect(await scaffold(plugins, decisions, options)).toEqual(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/scaffolder.js

@@ -3,11 +3,10 @@ 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}) {
+export default async function scaffoldLicense({projectRoot, license, copyright}, {logger}) {
   if (license) {
-    info('Generating License');
+    logger.info('Generating License');
 
     const licenseContent = spdxLicenseList[license].licenseText;
 

package/src/license/scaffolder.test.js

@@ -3,7 +3,7 @@ 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 {describe, expect, it, vi} from 'vitest';
 import any from '@travi/any';
 
 import scaffoldLicense from './scaffolder.js';
@@ -16,19 +16,16 @@ describe('license', () => {
   const copyrightHolders = any.sentence();
   const copyright = {year, holder: copyrightHolders};
   const projectRoot = any.string();
-
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
+  const logger = {info: () => {}};
 
   it('should not generate a license file when no license was chosen', async () => {
-    await scaffoldLicense({});
+    await scaffoldLicense({}, {logger});
 
     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(await scaffoldLicense({projectRoot, license, copyright, vcs: {}}, {logger})).toEqual({});
 
     expect(fs.writeFile).toHaveBeenCalledWith(
       `${projectRoot}/LICENSE`,
@@ -43,7 +40,7 @@ describe('license', () => {
   });
 
   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(await scaffoldLicense({projectRoot, license: 'MIT', copyright, vcs: {}}, {logger})).toEqual({});
 
     expect(fs.writeFile).toHaveBeenCalledWith(
       `${projectRoot}/LICENSE`,

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/lift.js

@@ -1,13 +1,19 @@
 import {applyEnhancers} from '@form8ion/core';
 import {lift as liftReadme} from '@form8ion/readme';
 import * as gitPlugin from '@form8ion/git';
+import * as misePlugin from '@form8ion/mise';
 
+import {scaffold as scaffoldEditorconfig, test as editorconfigInUse} from './editorconfig/index.js';
 import * as licensePlugin from './license/index.js';
 
-export default async function ({projectRoot, results, enhancers, vcs, dependencies}) {
+export default async function lift({projectRoot, results, enhancers, vcs}, dependencies) {
+  if (!await editorconfigInUse({projectRoot})) {
+    await scaffoldEditorconfig({projectRoot});
+  }
+
   const enhancerResults = await applyEnhancers({
     results,
-    enhancers: {...enhancers, gitPlugin, licensePlugin},
+    enhancers: {...enhancers, gitPlugin, licensePlugin, misePlugin},
     options: {projectRoot, vcs},
     dependencies
   });

package/src/lift.test.js

@@ -1,40 +1,53 @@
 import * as core from '@form8ion/core';
 import * as readme from '@form8ion/readme';
 import * as gitPlugin from '@form8ion/git';
+import * as misePlugin from '@form8ion/mise';
 
-import {afterEach, describe, expect, it, vi} from 'vitest';
+import {beforeEach, describe, expect, it, vi} from 'vitest';
 import any from '@travi/any';
 import {when} from 'vitest-when';
 
+import {scaffold as scaffoldEditorconfig, test as editorconfigInUse} from './editorconfig/index.js';
 import * as licensePlugin from './license/index.js';
 import lift from './lift.js';
 
 vi.mock('deepmerge');
 vi.mock('@form8ion/core');
 vi.mock('@form8ion/readme');
+vi.mock('./editorconfig/index.js');
 
 describe('lift', () => {
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
+  const projectRoot = any.string();
+  const results = any.simpleObject();
+  const enhancers = any.simpleObject();
+  const vcs = any.simpleObject();
+  const dependencies = any.simpleObject();
+  const enhancerResults = any.simpleObject();
 
-  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();
+  beforeEach(() => {
     when(core.applyEnhancers)
       .calledWith({
         results,
-        enhancers: {...enhancers, gitPlugin, licensePlugin},
+        enhancers: {...enhancers, gitPlugin, licensePlugin, misePlugin},
         options: {projectRoot, vcs},
         dependencies
       })
       .thenResolve(enhancerResults);
+  });
+
+  it('should lift the README based on the provided results', async () => {
+    when(editorconfigInUse).calledWith({projectRoot}).thenResolve(true);
 
-    expect(await lift({projectRoot, results, enhancers, vcs, dependencies})).toEqual(enhancerResults);
+    expect(await lift({projectRoot, results, enhancers, vcs}, dependencies)).toEqual(enhancerResults);
     expect(readme.lift).toHaveBeenCalledWith({projectRoot, results: enhancerResults});
+    expect(scaffoldEditorconfig).not.toHaveBeenCalled();
+  });
+
+  it('should scaffold editorconfig when it isnt already in use', async () => {
+    when(editorconfigInUse).calledWith({projectRoot}).thenResolve(false);
+
+    await lift({projectRoot, results, enhancers, vcs, dependencies});
+
+    expect(scaffoldEditorconfig).toHaveBeenCalledWith({projectRoot});
   });
 });

package/src/options-validator.js

@@ -4,15 +4,15 @@ 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';
+import ciProviderPluginsSchema from './ci-provider/schema.js';
 
 export function validate(options) {
   return validateOptions(joi.object({
-    decisions: decisionsSchema,
     plugins: joi.object({
       dependencyUpdaters: dependencyUpdaterPluginsSchema,
       languages: languagePluginsSchema,
-      vcsHosts: vcsHostPluginsSchema
+      vcsHosts: vcsHostPluginsSchema,
+      ciProviders: ciProviderPluginsSchema
     })
   }), options) || {};
 }

package/src/options-validator.test.js

@@ -5,8 +5,8 @@ import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest';
 import any from '@travi/any';
 import {when} from 'vitest-when';
 
+import ciProviderPluginsSchema from './ci-provider/schema.js';
 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';
@@ -36,13 +36,11 @@ describe('options validator', () => {
       .calledWith({
         dependencyUpdaters: dependencyUpdaterPluginsSchema,
         languages: languagePluginsSchema,
-        vcsHosts: vcsHostPluginsSchema
+        vcsHosts: vcsHostPluginsSchema,
+        ciProviders: ciProviderPluginsSchema
       })
       .thenReturn(pluginsSchema);
-    when(joi.object).calledWith({
-      decisions: decisionsSchema,
-      plugins: pluginsSchema
-    }).thenReturn(fullSchema);
+    when(joi.object).calledWith({plugins: pluginsSchema}).thenReturn(fullSchema);
     when(core.validateOptions).calledWith(fullSchema, options).thenReturn(validatedOptions);
 
     expect(validate(options)).toEqual(validatedOptions);

package/src/prompts/index.js

@@ -0,0 +1,20 @@
+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 {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,
+  CI_PROVIDER: CI_PROVIDER_PROMPT_ID
+};
+
+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/prompts/questions.js

@@ -1,6 +1,10 @@
 import {questionsForBaseDetails} from '@form8ion/core';
-import {prompt} from '@form8ion/overridable-prompts';
 
-export function promptForBaseDetails(projectRoot, decisions) {
-  return prompt(questionsForBaseDetails(decisions, projectRoot), decisions);
+export const BASE_DETAILS_PROMPT_ID = 'BASE_DETAILS';
+
+export function promptForBaseDetails(projectRoot, {prompt}) {
+  return prompt({
+    id: BASE_DETAILS_PROMPT_ID,
+    questions: questionsForBaseDetails(projectRoot)
+  });
 }

package/src/prompts/questions.test.js

@@ -1,11 +1,10 @@
 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';
+import {promptForBaseDetails, BASE_DETAILS_PROMPT_ID} from './questions.js';
 
 vi.mock('@form8ion/core');
 vi.mock('@form8ion/overridable-prompts');
@@ -13,13 +12,13 @@ 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);
+  const prompt = vi.fn();
 
   it('should prompt for the necessary details', async () => {
-    when(core.questionsForBaseDetails).calledWith(decisions, projectPath).thenReturn(questions);
-    when(prompts.prompt).calledWith(questions, decisions).thenResolve(answers);
+    when(core.questionsForBaseDetails).calledWith(projectPath).thenReturn(questions);
+    when(prompt).calledWith({id: BASE_DETAILS_PROMPT_ID, questions}).thenResolve(answers);
 
-    expect(await promptForBaseDetails(projectPath, decisions)).toEqual(answers);
+    expect(await promptForBaseDetails(projectPath, {prompt})).toEqual(answers);
   });
 });

package/src/scaffolder.js

@@ -1,23 +1,23 @@
 import deepmerge from 'deepmerge';
 import {execa} from 'execa';
 import {questionNames as coreQuestionNames} from '@form8ion/core';
-import {reportResults} from '@form8ion/results-reporter';
 import {scaffold as scaffoldReadme} from '@form8ion/readme';
-import {info} from '@travi/cli-messages';
 
 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';
 import {scaffold as scaffoldContributing} from './contributing/index.js';
 import lift from './lift.js';
 
-export async function scaffold(options) {
+export 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 {
     [coreQuestionNames.PROJECT_NAME]: projectName,
@@ -26,27 +26,28 @@ export async function scaffold(options) {
     [coreQuestionNames.DESCRIPTION]: description,
     [coreQuestionNames.COPYRIGHT_YEAR]: copyrightYear,
     [coreQuestionNames.COPYRIGHT_HOLDER]: copyHolder
-  } = await promptForBaseDetails(projectRoot, decisions);
+  } = await promptForBaseDetails(projectRoot, {prompt});
   const copyright = {year: copyrightYear, holder: copyHolder};
 
   const [vcsResults, contributing, license] = await Promise.all([
-    scaffoldVcs({projectRoot, projectName, decisions, vcsHosts, visibility, description}),
+    scaffoldVcs({projectRoot, projectName, vcsHosts, visibility, description}, {prompt, logger}),
     scaffoldContributing({visibility}),
-    scaffoldLicense({projectRoot, license: chosenLicense, copyright}),
+    scaffoldLicense({projectRoot, license: chosenLicense, copyright}, {logger}),
     scaffoldReadme({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([
@@ -62,15 +63,15 @@ export 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;
 }