Centralized all the operation state into an Operation class

Author: JamesMessinger

src/get-new-version.ts

@@ -1,44 +1,44 @@
 import * as inquirer from "inquirer";
 import * as semver from "semver";
 import { ReleaseType, SemVer } from "semver"; // tslint:disable-line: no-duplicate-imports
-import { BumpRelease, NormalizedOptions } from "./normalize-options";
+import { BumpRelease, PromptRelease } from "./normalize-options";
+import { Operation } from "./operation";
 import { isPrerelease, releaseTypes } from "./release-type";
 
-type Params = NormalizedOptions & { oldVersion: string };
-type VersionAndReleaseType = [string, ReleaseType?];
-
 /**
- * Returns the new version number, possibly by prompting the user for it.
- *
- * @returns - A tuple containing the new version number and the release type (if any)
+ * Determines the new version number, possibly by prompting the user for it.
  */
-export async function getNewVersion(params: Params): Promise<VersionAndReleaseType> {
-  let { release } = params;
+export async function getNewVersion(operation: Operation): Promise<Operation> {
+  let { release } = operation.options;
+  let { oldVersion } = operation.state;
 
   switch (release.type) {
     case "prompt":
-      return promptForNewVersion(params);
+      return promptForNewVersion(operation);
 
     case "version":
       let newSemVer = new SemVer(release.version, true);
-      return [newSemVer.version];
+      return operation.update({
+        newVersion: newSemVer.version,
+      });
 
     default:
-      return [getNextVersion(params), release.type];
+      return operation.update({
+        release: release.type,
+        newVersion: getNextVersion(oldVersion, release),
+      });
   }
 }
 
 /**
  * Returns the next version number of the specified type.
  */
-function getNextVersion({ oldVersion, release }: Params): string {
-  let bump = release as BumpRelease;
-
+function getNextVersion(oldVersion: string, bump: BumpRelease): string {
   let oldSemVer = new SemVer(oldVersion);
-  let newSemVer = oldSemVer.inc(bump.type as ReleaseType, bump.preid);
+  let newSemVer = oldSemVer.inc(bump.type, bump.preid);
 
   if (
-    isPrerelease(release) &&
+    isPrerelease(bump.type) &&
     newSemVer.prerelease.length === 2 &&
     newSemVer.prerelease[0] === bump.preid &&
     String(newSemVer.prerelease[1]) === "0"
@@ -56,12 +56,11 @@ function getNextVersion({ oldVersion, release }: Params): string {
 /**
  * Returns the next version number for all release types.
  */
-function getNextVersions(params: Params): Record<ReleaseType, string> {
-  let release = params.release as BumpRelease;
+function getNextVersions(oldVersion: string, preid: string): Record<ReleaseType, string> {
   let next: Record<string, string> = {};
 
   for (let type of releaseTypes) {
-    next[type] = getNextVersion({ ...params, release: { ...release, type }});
+    next[type] = getNextVersion(oldVersion, { type, preid });
   }
 
   return next;
@@ -72,10 +71,12 @@ function getNextVersions(params: Params): Record<ReleaseType, string> {
  *
  * @returns - A tuple containing the new version number and the release type (if any)
  */
-async function promptForNewVersion(params: Params): Promise<VersionAndReleaseType> {
-  let { oldVersion, interface: ui } = params;
-  let next = getNextVersions(params);
-  let prompts = inquirer.createPromptModule(ui as inquirer.StreamOptions);
+async function promptForNewVersion(operation: Operation): Promise<Operation> {
+  let { oldVersion, oldVersionSource } = operation.state;
+  let release = operation.options.release as PromptRelease;
+  let prompts = inquirer.createPromptModule(operation.options.interface as inquirer.StreamOptions);
+
+  let next = getNextVersions(oldVersion, release.preid);
 
   let answers: {
     release: ReleaseType | "none" | "custom";
@@ -86,7 +87,7 @@ async function promptForNewVersion(params: Params): Promise<VersionAndReleaseTyp
     {
       type: "list",
       name: "release",
-      message: `\nThe current version is ${oldVersion}\nHow would you like to bump it?`,
+      message: `\nThe current version in ${oldVersionSource} is ${oldVersion}\nHow would you like to bump it?`,
       default: "patch",
       pageSize: 10,
       choices: [
@@ -107,7 +108,7 @@ async function promptForNewVersion(params: Params): Promise<VersionAndReleaseTyp
       name: "newVersion",
       message: "Enter the new version number:",
       default: oldVersion,
-      when: ({ release }) => release === "custom",
+      when: (previousAnswer) => previousAnswer.release === "custom",
       filter: semver.clean,
       validate: (newVersion: string) => {
         return semver.valid(newVersion) ? true : "That's not a valid version number";
@@ -117,12 +118,15 @@ async function promptForNewVersion(params: Params): Promise<VersionAndReleaseTyp
 
   switch (answers.release) {
     case "none":
-      return [oldVersion];
+      return operation.update({ newVersion: oldVersion });
 
     case "custom":
-      return [answers.newVersion!];
+      return operation.update({ newVersion: answers.newVersion! });
 
     default:
-      return [next[answers.release], answers.release];
+      return operation.update({
+        release: answers.release,
+        newVersion: next[answers.release],
+      });
   }
 }

src/get-old-version.ts

@@ -1,13 +1,15 @@
 import * as semver from "semver";
 import { readJsonFile } from "./fs";
 import { isManifest } from "./manifest";
-import { NormalizedOptions } from "./normalize-options";
+import { Operation } from "./operation";
 
 /**
- * Returns the current version number from files such as package.json.
+ * Finds the current version number from files such as package.json.
  * An error is thrown if no version number can be found.
  */
-export async function getOldVersion({ files, cwd }: NormalizedOptions): Promise<string> {
+export async function getOldVersion(operation: Operation): Promise<Operation> {
+  let { cwd, files } = operation.options;
+
   // Check all JSON files in the files list
   let filesToCheck = files.filter((file) => file.endsWith(".json"));
 
@@ -21,7 +23,11 @@ export async function getOldVersion({ files, cwd }: NormalizedOptions): Promise<
     let version = await readVersion(file, cwd);
 
     if (version) {
-      return version;
+      // We found the current version number!
+      return operation.update({
+        oldVersionSource: file,
+        oldVersion: version,
+      });
     }
   }
 

src/git.ts

@@ -1,19 +1,17 @@
 import * as ezSpawn from "ez-spawn";
-import { NormalizedOptions } from "./normalize-options";
-
-type Params = NormalizedOptions & { files: string[]; newVersion: string };
+import { Operation } from "./operation";
+import { ProgressEvent } from "./version-bump-progress";
 
 /**
  * Commits the modififed files to Git, if the `commit` option is enabled.
- *
- * @returns - The commit message, or `false` if nothing was committed
  */
-export async function gitCommit({ commit, files, newVersion }: Params): Promise<string | false> {
-  if (!commit) {
-    return false;
+export async function gitCommit(operation: Operation): Promise<Operation> {
+  if (!operation.options.commit) {
+    return operation;
   }
 
-  let { all, noVerify, message } = commit;
+  let { all, noVerify, message } = operation.options.commit;
+  let { files, newVersion } = operation.state;
   let args = [];
 
   if (all) {
@@ -27,60 +25,63 @@ export async function gitCommit({ commit, files, newVersion }: Params): Promise<
   }
 
   // Create the commit message
-  message = formatVersionString(message, newVersion);
-  args.push("--message", message);
+  let commitMessage = formatVersionString(message, newVersion);
+  args.push("--message", commitMessage);
 
   // Append the file names last, as variadic arguments
   if (!all) {
     args = args.concat(files);
   }
 
   await ezSpawn.async("git", ["commit", ...args]);
-  return message;
+
+  return operation.update({ event: ProgressEvent.GitCommit, commitMessage });
 }
 
 /**
  * Tags the Git commit, if the `tag` option is enabled.
- *
- * @returns - The tag name, or `false` if no tag was created
  */
-export async function gitTag({ commit, tag, newVersion }: Params): Promise<string | false> {
-  if (!commit || !tag) {
-    return false;
+export async function gitTag(operation: Operation): Promise<Operation> {
+  if (!operation.options.tag) {
+    return operation;
   }
 
+  let { commit, tag } = operation.options;
+  let { newVersion } = operation.state;
+
   let args = [
     // Create an annotated tag, which is recommended for releases.
     // See https://git-scm.com/docs/git-tag
     "--annotate",
 
     // Use the same commit message for the tag
-    "--message", formatVersionString(commit.message, newVersion),
+    "--message", formatVersionString(commit!.message, newVersion),
   ];
 
   // Create the Tag name
-  let name = formatVersionString(tag.name, newVersion);
-  args.push(name);
+  let tagName = formatVersionString(tag.name, newVersion);
+  args.push(tagName);
 
   await ezSpawn.async("git", ["tag", ...args]);
-  return name;
+
+  return operation.update({ event: ProgressEvent.GitTag, tagName });
 }
 
 /**
  * Pushes the Git commit and tag, if the `push` option is enabled.
  */
-export async function gitPush({ push, tag }: NormalizedOptions): Promise<void> {
-  if (!push) {
-    return;
+export async function gitPush(operation: Operation): Promise<Operation> {
+  if (operation.options.push) {
+    // Push the commit
+    await ezSpawn.async("git", "push");
+
+    if (operation.options.tag) {
+      // Push the tag
+      await ezSpawn.async("git", ["push", "--tags"]);
+    }
   }
 
-  // Push the commit
-  await ezSpawn.async("git", "push");
-
-  if (tag) {
-    // Push the tag
-    await ezSpawn.async("git", ["push", "--tags"]);
-  }
+  return operation.update({ event: ProgressEvent.GitPush });
 }
 
 /**

src/normalize-options.ts

@@ -17,17 +17,25 @@ export interface VersionRelease {
 }
 
 /**
- * A bump release (prompted or otherwise), relative to the current version number.
+ * Prompt the user for the release number.
+ */
+export interface PromptRelease {
+  type: "prompt";
+  preid: string;
+}
+
+/**
+ * A bump release, relative to the current version number.
  */
 export interface BumpRelease {
-  type: "prompt" | ReleaseType;
+  type: ReleaseType;
   preid: string;
 }
 
 /**
  * One of the possible Release types.
  */
-export type Release = VersionRelease | BumpRelease;
+export type Release = VersionRelease | PromptRelease | BumpRelease;
 
 /**
  * Normalized and sanitized options