@form8ion/project 21.0.1 → 21.0.3

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

@@ -0,0 +1,46 @@
+import {validateOptions} from '@form8ion/core';
+
+import {describe, expect, it} from 'vitest';
+import any from '@travi/any';
+
+import vcsHostSchema from './schema.js';
+
+describe('vcs-host plugins schema', () => {
+  const key = any.word();
+
+  it('should return the validated options', () => {
+    const options = any.objectWithKeys(
+      any.listOf(any.string),
+      {
+        factory: () => ({
+          scaffold: foo => foo,
+          prompt: () => undefined,
+          public: any.boolean(),
+          private: any.boolean()
+        })
+      }
+    );
+
+    expect(validateOptions(vcsHostSchema, options)).toEqual(options);
+  });
+
+  it('should require options to be provided as an object', () => {
+    expect(() => validateOptions(vcsHostSchema, {[key]: []}))
+      .toThrowError(`"${key}" must be of type object`);
+  });
+
+  it('should require a `scaffold` to be included', () => {
+    expect(() => validateOptions(vcsHostSchema, {[key]: {}}))
+      .toThrowError(`"${key}.scaffold" is required`);
+  });
+
+  it('should require `scaffold` to be a function', () => {
+    expect(() => validateOptions(vcsHostSchema, {[key]: {scaffold: any.word()}}))
+      .toThrowError(`"${key}.scaffold" must be of type function`);
+  });
+
+  it('should require the scaffold to accept a single argument', () => {
+    expect(() => validateOptions(vcsHostSchema, {[key]: {scaffold: () => undefined}}))
+      .toThrowError(`"${key}.scaffold" must have an arity greater or equal to 1`);
+  });
+});

package/src/vcs/index.js

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

package/src/vcs/prompt.js

@@ -0,0 +1,17 @@
+import {prompt} from '@form8ion/overridable-prompts';
+
+import {questionNames} from '../prompts/question-names.js';
+
+export default async function promptForRepoCreation(decisions) {
+  const {[questionNames.GIT_REPO]: gitRepoShouldBeCreated} = await prompt(
+    [{
+      name: questionNames.GIT_REPO,
+      type: 'confirm',
+      default: true,
+      message: 'Should a git repository be initialized?'
+    }],
+    decisions
+  );
+
+  return gitRepoShouldBeCreated;
+}

package/src/vcs/prompt.test.js

@@ -0,0 +1,27 @@
+import {prompt} from '@form8ion/overridable-prompts';
+
+import {describe, vi, it, expect} from 'vitest';
+import {when} from 'vitest-when';
+import any from '@travi/any';
+
+import {questionNames} from '../prompts/question-names.js';
+import promptForRepoCreation from './prompt.js';
+
+vi.mock('@form8ion/overridable-prompts');
+
+describe('git prompt', () => {
+  it('should ask whether a repository should be created', async () => {
+    const decisions = any.simpleObject();
+    const repoShouldBeCreated = any.boolean();
+    when(prompt)
+      .calledWith([{
+        name: questionNames.GIT_REPO,
+        type: 'confirm',
+        default: true,
+        message: 'Should a git repository be initialized?'
+      }], decisions)
+      .thenResolve({[questionNames.GIT_REPO]: repoShouldBeCreated});
+
+    expect(await promptForRepoCreation(decisions)).toBe(repoShouldBeCreated);
+  });
+});

package/src/vcs/scaffolder.js

@@ -0,0 +1,34 @@
+import {info} from '@travi/cli-messages';
+import {scaffold as scaffoldGit, test as alreadyVersionedByGit} from '@form8ion/git';
+
+import repositoryShouldBeCreated from './prompt.js';
+import {determineExistingVcsDetails, defineRemoteOrigin} from './git/index.js';
+import {scaffold as scaffoldVcsHost} from './host/index.js';
+
+export default async function scaffoldVcs({projectRoot, projectName, decisions, vcsHosts, visibility, description}) {
+  if (await repositoryShouldBeCreated(decisions)) {
+    if (await alreadyVersionedByGit({projectRoot})) {
+      info('Git repository already exists');
+
+      return {vcs: await determineExistingVcsDetails({projectRoot})};
+    }
+
+    const [{vcs: {host, owner, name, sshUrl}}] = await Promise.all([
+      scaffoldVcsHost(
+        vcsHosts,
+        decisions,
+        {projectName, projectRoot, description, visibility}
+      ),
+      scaffoldGit({projectRoot})
+    ]);
+
+    const remoteOriginResults = await defineRemoteOrigin(projectRoot, sshUrl);
+
+    return {
+      vcs: {host, owner, name},
+      nextSteps: [{summary: 'Commit scaffolded files'}, ...remoteOriginResults.nextSteps]
+    };
+  }
+
+  return {};
+}

package/src/vcs/scaffolder.test.js

@@ -0,0 +1,60 @@
+import {test as alreadyVersionedByGit, scaffold as scaffoldGit} from '@form8ion/git';
+
+import {describe, expect, it, vi} from 'vitest';
+import {when} from 'vitest-when';
+import any from '@travi/any';
+
+import {scaffold as scaffoldVcsHost} from './host/index.js';
+import {determineExistingVcsDetails, defineRemoteOrigin} from './git/index.js';
+import promptForRepoCreation from './prompt.js';
+import scaffoldVcs from './scaffolder.js';
+
+vi.mock('@form8ion/git');
+vi.mock('./git/index.js');
+vi.mock('./host/index.js');
+vi.mock('./prompt.js');
+
+describe('vcs scaffolder', () => {
+  const projectRoot = any.string();
+  const decisions = any.simpleObject();
+
+  it('should scaffold the repository and vcs host details', async () => {
+    const host = any.word();
+    const owner = any.word();
+    const name = any.word();
+    const vcsHosts = any.simpleObject();
+    const visibility = any.word();
+    const projectName = any.word();
+    const description = any.sentence();
+    const vcsHostDetails = {host, owner, name};
+    const sshUrl = any.url();
+    const remoteOriginNextSteps = any.listOf(any.simpleObject);
+    when(promptForRepoCreation).calledWith(decisions).thenResolve(true);
+    when(alreadyVersionedByGit).calledWith({projectRoot}).thenResolve(false);
+    when(scaffoldVcsHost)
+      .calledWith(vcsHosts, decisions, {projectName, projectRoot, description, visibility})
+      .thenResolve({vcs: {...vcsHostDetails, sshUrl, ...any.simpleObject()}});
+    when(defineRemoteOrigin).calledWith(projectRoot, sshUrl).thenResolve({nextSteps: remoteOriginNextSteps});
+
+    expect(await scaffoldVcs({projectRoot, projectName, decisions, vcsHosts, visibility, description})).toEqual({
+      vcs: vcsHostDetails,
+      nextSteps: [{summary: 'Commit scaffolded files'}, ...remoteOriginNextSteps]
+    });
+    expect(scaffoldGit).toHaveBeenCalledWith({projectRoot});
+  });
+
+  it('should not scaffold a repository or vcs host details when the project is already versioned by git', async () => {
+    const existingVcsDetails = any.simpleObject();
+    when(promptForRepoCreation).calledWith(decisions).thenResolve(true);
+    when(alreadyVersionedByGit).calledWith({projectRoot}).thenResolve(true);
+    when(determineExistingVcsDetails).calledWith({projectRoot}).thenResolve(existingVcsDetails);
+
+    expect(await scaffoldVcs({projectRoot, decisions})).toEqual({vcs: existingVcsDetails});
+  });
+
+  it('should not scaffold a repository or vcs host details when a repository should not be created', async () => {
+    when(promptForRepoCreation).calledWith(decisions).thenResolve(false);
+
+    expect(await scaffoldVcs({projectRoot, decisions})).toEqual({});
+  });
+});