Implemented the Git logic

Author: JamesMessinger

src/git.ts

@@ -0,0 +1,98 @@
+import * as ezSpawn from "ez-spawn";
+import { Options } from "./options";
+
+type Params = Options & { files: string[]; newVersion: string };
+
+/**
+ * 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;
+  }
+
+  let { all, noVerify, message } = commit;
+  let args = [];
+
+  if (all) {
+    // Commit ALL files, not just the ones that were bumped
+    args.push("--all");
+  }
+
+  if (noVerify) {
+    // Bypass git commit hooks
+    args.push("--no-verify");
+  }
+
+  // Create the commit message
+  message = formatVersionString(message, newVersion);
+  args.push("--message", message);
+
+  // Append the file names last, as variadic arguments
+  if (!all) {
+    args = args.concat(files);
+  }
+
+  await ezSpawn.async("git", ["commit", ...args]);
+  return message;
+}
+
+/**
+ * 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;
+  }
+
+  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),
+  ];
+
+  // Create the Tag name
+  let name = formatVersionString(tag.name, newVersion);
+  args.push(name);
+
+  await ezSpawn.async("git", ["tag", ...args]);
+  return name;
+}
+
+/**
+ * Pushes the Git commit and tag, if the `push` option is enabled.
+ */
+export async function gitPush({ push, tag }: Options): Promise<void> {
+  if (!push) {
+    return;
+  }
+
+  // Push the commit
+  await ezSpawn.async("git", "push");
+
+  if (tag) {
+    // Push the tag
+    await ezSpawn.async("git", ["push", "--tags"]);
+  }
+}
+
+/**
+ * Accepts a version string template (e.g. "release v" or "This is the %s release").
+ * If the template contains any "%s" placeholders, then they are replaced with the version number;
+ * otherwise, the version number is appended to the string.
+ */
+function formatVersionString(template: string, newVersion: string): string {
+  if (template.includes("%s")) {
+    return template.replace(/%s/g, newVersion);
+  }
+  else {
+    return template + newVersion;
+  }
+}

src/options.ts

@@ -18,13 +18,13 @@ export class Options {
   public preid!: string;
   public commit?: {
     message: string;
+    noVerify: boolean;
+    all: boolean;
   };
   public tag?: {
     name: string;
   };
   public push!: boolean;
-  public all!: boolean;
-  public noVerify!: boolean;
   public files!: string[];
   public cwd!: string;
   public interface!: Interface;
@@ -70,10 +70,10 @@ export class Options {
     // NOTE: This must come AFTER `tag` and `push`, because it relies on them
     let commit;
     if (typeof raw.commit === "string") {
-      commit = { message: raw.commit };
+      commit = { all, noVerify, message: raw.commit };
     }
     else if (raw.commit || tag || push) {
-      commit = { message: "release v" };
+      commit = { all, noVerify, message: "release v" };
     }
 
     let files;
@@ -106,7 +106,7 @@ export class Options {
     }
 
     return new Options({
-      release, preid, commit, tag, push, all, noVerify, files, cwd, interface: ui
+      release, preid, commit, tag, push, files, cwd, interface: ui
     });
   }
 }

src/update-files.ts

@@ -9,7 +9,7 @@ type FileParams = Params & { name: string };
 /**
  * Updates the version number in the specified files.
  *
- * @returns - The files that were actually modified
+ * @returns - The relative paths of the files that were actually modified
  */
 export async function updateFiles(params: Params): Promise<string[]> {
   let { files } = params;

src/version-bump-options.ts

@@ -23,15 +23,19 @@ export interface VersionBumpOptions {
 
   /**
    * Indicates whether to create a git commit. Can be set to a custom commit message string
-   * or `true` to use "release v" (the version number will be appended).
+   * or `true` to use "release v".  Any `%s` placeholders in the message string will be replaced
+   * with the new version number.  If the message string does _not_ contain any `%s` placeholders,
+   * then the new version number will be appended to the message.
    *
    * Defaults to `false`.
    */
   commit?: boolean | string;
 
   /**
    * Indicates whether to tag the git commit. Can be set to a custom tag string
-   * or `true` to use "v" (the version number will be appended).
+   * or `true` to use "v".  Any `%s` placeholders in the tag string will be replaced
+   * with the new version number.  If the tag string does _not_ contain any `%s` placeholders,
+   * then the new version number will be appended to the tag.
    *
    * Defaults to `false`.
    */
@@ -45,15 +49,15 @@ export interface VersionBumpOptions {
   push?: boolean;
 
   /**
-   * Indicates whether the git commit should include ALL files (`git commit -a`)
+   * Indicates whether the git commit should include ALL files (`git commit --all`)
    * rather than just the files that were modified by `versionBump()`.
    *
    * Defaults to `false`.
    */
   all?: boolean;
 
   /**
-   * Indicates whether to bypass git commit hooks (`git commit --noverify`).
+   * Indicates whether to bypass git commit hooks (`git commit --no-verify`).
    *
    * Defaults to `false`.
    */

src/version-bump.ts

@@ -1,5 +1,6 @@
 import { getNewVersion } from "./get-new-version";
 import { getOldVersion } from "./get-old-version";
+import { gitCommit, gitPush, gitTag } from "./git";
 import { Options } from "./options";
 import { updateFiles } from "./update-files";
 import { VersionBumpOptions } from "./version-bump-options";
@@ -39,25 +40,27 @@ export async function versionBump(arg: VersionBumpOptions | string = {}): Promis
     arg = { release: arg };
   }
 
+  // Validate and normalize the options
   let options = await Options.normalize(arg);
+
+  // Get the old and new version numbers
   let oldVersion = await getOldVersion(options);
   let [newVersion, release] = await getNewVersion({ ...options, oldVersion });
-  let files = await updateFiles({ ...options, oldVersion, newVersion });
 
-  if (options.commit) {
-    options.commit.message += newVersion;
-  }
+  // Update the version number in all files
+  let files = await updateFiles({ ...options, oldVersion, newVersion });
 
-  if (options.tag) {
-    options.tag.name += newVersion;
-  }
+  // Git commit, tag, push (if enabled)
+  let commit = await gitCommit({ ...options, files, newVersion });
+  let tag = await gitTag({ ...options, newVersion });
+  await gitPush(options);
 
   return {
     release,
     oldVersion,
     newVersion,
-    commit: options.commit ? options.commit.message : false,
-    tag: options.tag ? options.tag.name : false,
+    commit,
+    tag,
     files,
   };
 }