Merge pull request #3 from groupon/dbushong/feature/master/setup-fix

setup fix & code cleanup

Author: markowsiak

lib/cli.js

@@ -41,26 +41,35 @@ const { UIError, log } = require('./common');
 
 let ranAction = false;
 
+/**
+ * @param {string} cmd
+ * @param {import('./typedefs').ActionFn} fn
+ * @return {(...args: any[]) => void}
+ */
 function wrapAction(cmd, fn) {
+  /** @type {import('./typedefs').CmdDeps} */
   const deps = { git, log };
-  return function wrappedAction() {
+  return (...args) => {
     ranAction = true;
-    const args = [deps].concat(Array.from(arguments));
-    const opts = args[args.length - 1];
+    /** @type {import('./typedefs').CmdOpts} */
+    const opts = args.pop();
     if (opts.parent.yes) {
       deps.forceBool = true;
-      if (opts.parent.no)
+      if (opts.parent.no) {
         throw new UIError('--yes and --no are mutually exclusive');
+      }
     }
     if (opts.parent.no) deps.forceBool = false;
     verifySetup(cmd, deps)
-      .then(() => fn.apply(null, args))
-      .catch(err => {
-        const justMessage = !err.stack || err instanceof UIError;
-        // eslint-disable-next-line no-console
-        console.error(`🚢💥 ${justMessage ? err.message : err.stack}`);
-        process.exit(1);
-      });
+      .then(() => fn({ deps, opts, args }))
+      .catch(
+        /** @param {Error} err */ err => {
+          const justMessage = !err.stack || err instanceof UIError;
+          // eslint-disable-next-line no-console
+          console.error(`🚢💥 ${justMessage ? err.message : err.stack}`);
+          process.exit(1);
+        }
+      );
   };
 }
 

lib/commands/abort.js

@@ -34,7 +34,8 @@
 
 const { featureParent, inferRemote, remoteFromLocal } = require('../common');
 
-async function abortAction({ git, log }) {
+/** @type {import('../typedefs').ActionFn} */
+async function abortAction({ deps: { git, log } }) {
   const { current: feature } = await git.branchLocal();
   const { parent } = await featureParent(git, feature);
 
@@ -61,6 +62,7 @@ async function abortAction({ git, log }) {
   log(`${feature} aborted; last SHA was ${finalSHA.trim()}`);
 }
 
+/** @type {import('../typedefs').Action} */
 module.exports = {
   action: abortAction,
   command(prog, wrapAction) {

lib/commands/cut-release.js

@@ -38,13 +38,14 @@ const { action: mergeBackAction } = require('./merge-back');
 
 const { ghURL, assertNoFork } = require('../common');
 
-async function cutReleaseAction({ git, log }, branch, opts) {
+/** @type {import('../typedefs').ActionFn} */
+async function cutReleaseAction({ deps: { git, log }, args: [branch], opts }) {
   await assertNoFork(git, 'cut-release');
 
   if (!branch) branch = 'master';
 
   log('Ensuring all changes are merged back');
-  await mergeBackAction({ git, log });
+  await mergeBackAction({ deps: { git, log }, opts, args: [] });
 
   log(`Creating PR to fast-forward merge ${branch} onto release`);
   const prURL = await ghURL(git, `/compare/release...${branch}`, {
@@ -55,6 +56,7 @@ async function cutReleaseAction({ git, log }, branch, opts) {
   if (opts.parent.open) await open(prURL);
 }
 
+/** @type {import('../typedefs').Action} */
 module.exports = {
   action: cutReleaseAction,
   command(prog, wrapAction) {

lib/commands/done.js

@@ -34,25 +34,27 @@
 
 const {
   featureParent,
-  prompt,
+  yesNo,
   UIError,
   plural,
   inferRemote,
 } = require('../common');
 
-async function doneAction({ git, log, forceBool }) {
+/** @type {import('../typedefs').ActionFn} */
+async function doneAction({ deps: { git, log, forceBool } }) {
   const { current: feature } = await git.branchLocal();
   const { parent } = await featureParent(git, feature);
 
   log(
     `Switching to detected parent branch '${parent}' and pulling latest commits`
   );
   await git.checkout(parent);
+  // @ts-ignore
   await git.pull({ '--no-rebase': true });
 
   const unmerged = (await git.log([`..${feature}`])).total;
   if (unmerged > 0) {
-    const ok = await prompt(
+    const ok = await yesNo(
       `Feature branch '${feature}' contains ${plural(
         unmerged,
         'commit'
@@ -73,6 +75,7 @@ async function doneAction({ git, log, forceBool }) {
   await git.raw(['remote', 'prune', remote]);
 }
 
+/** @type {import('../typedefs').Action} */
 module.exports = {
   action: doneAction,
   command(prog, wrapAction) {

lib/commands/hotfix.js

@@ -34,19 +34,23 @@
 
 const { assertNoFork } = require('../common');
 
-async function hotfixAction({ git, log }, buildTag) {
+/** @type {import('../typedefs').ActionFn} */
+async function hotfixAction({ deps: { git, log }, args: [buildTag] }) {
   await assertNoFork(git, 'hotfix');
 
   log("Switching to branch 'hotfix' and pulling latest commits and tags");
   await git.checkout('hotfix');
+  // @ts-ignore
   await git.pull({ '--no-rebase': true });
+  // @ts-ignore
   await git.fetch({ '--tags': true });
 
   log(`Fast-forwarding 'hotfix' to '${buildTag}' and pushing`);
   await git.merge([buildTag, '--ff-only']);
   await git.push();
 }
 
+/** @type {import('../typedefs').Action} */
 module.exports = {
   action: hotfixAction,
   command(prog, wrapAction) {

lib/commands/merge-back.js

@@ -35,23 +35,38 @@
 const { action: startAction } = require('./start');
 const { UIError, cmdLine, assertNoFork } = require('../common');
 
+/**
+ * @param {import('../typedefs').CmdDeps} deps
+ * @param {string} from
+ */
 async function createFeatureMerge({ git, log }, from) {
   await git.reset('hard');
-  await startAction({ git, log }, `merge-${from}`);
-  try {
-    await git.merge([from]);
-  } catch (err) {
-    /* */
-  }
+  await startAction({
+    deps: { git, log },
+    args: [`merge-${from}`],
+    opts: { parent: {} },
+  });
+  await git.merge([from]).catch(() => {});
   throw new UIError('When conflicts are resolved, commit and `wf pr`');
 }
 
+/**
+ * @param {import('simple-git/promise').SimpleGit} git
+ * @param {string} branch
+ */
 async function switchAndPull(git, branch) {
   await git.checkout(branch);
+  // @ts-ignore
   await git.pull({ '--no-rebase': true });
 }
 
-async function tryMerge({ git, log }, from, to) {
+/**
+ * @param {import('../typedefs').CmdDeps} deps
+ * @param {string} from
+ * @param {string} to
+ */
+async function tryMerge(deps, from, to) {
+  const { git, log } = deps;
   log(`${to} ← ${from}`);
   await switchAndPull(git, to);
 
@@ -65,7 +80,7 @@ async function tryMerge({ git, log }, from, to) {
     if (/\nCONFLICT /.test(output)) throw new Error(output);
   } catch (err) {
     log('Automated merge failed; creating feature branch for resolution');
-    await createFeatureMerge({ git, log }, from); // will throw
+    await createFeatureMerge(deps, from); // will throw
   }
 
   log(`Merged cleanly; committing & pushing results to ${to} branch`);
@@ -76,7 +91,8 @@ async function tryMerge({ git, log }, from, to) {
   await git.push();
 }
 
-async function mergeBackAction(deps) {
+/** @type {import('../typedefs').ActionFn} */
+async function mergeBackAction({ deps }) {
   const { git, log } = deps;
 
   await assertNoFork(git, 'merge-back');
@@ -94,6 +110,7 @@ async function mergeBackAction(deps) {
   return true;
 }
 
+/** @type {import('../typedefs').Action} */
 module.exports = {
   action: mergeBackAction,
   command(prog, wrapAction) {

lib/commands/pr.js

@@ -42,25 +42,39 @@ const {
   UIError,
 } = require('../common');
 
+/**
+ * @param {string} str
+ */
 function stripNLMPrefix(str) {
   return str.replace(/^(feat|fix|docs|style|refactor|perf|test|chore):\s+/, '');
 }
 
+/**
+ * @param {string[]} subjects
+ */
 function findTitle(subjects) {
   const eligible = subjects.filter(s => !/^(docs|test):\s/.test(s));
   return eligible.length === 1 ? stripNLMPrefix(eligible[0]) : null;
 }
 
 // extracts the organization from the "fork" remote's url
+/**
+ * @param {import('simple-git/promise').SimpleGit} git
+ */
 function forkPrefix(git) {
   return git.getRemotes(true).then(remotes => {
-    const remote = remotes.find(r => r.name === 'fork').refs.fetch;
-    const owner = remote.match(/([\w-]+)\/[^\/]+$/)[1];
-    return `${owner}:`;
+    const forkRemote = remotes.find(r => r.name === 'fork');
+    if (!forkRemote) throw new Error('Could not find fork remote');
+    const ownerMatch = forkRemote.refs.fetch.match(/([\w-]+)\/[^\/]+$/);
+    if (!ownerMatch) {
+      throw new Error(`Could not match owner in ${forkRemote.refs.fetch}`);
+    }
+    return `${ownerMatch[1]}:`;
   });
 }
 
-async function prAction({ git, log }, opts) {
+/** @type {import('../typedefs').ActionFn} */
+async function prAction({ deps: { git, log }, opts }) {
   log('Ensuring all work is pushed to remote');
   try {
     await git.push();
@@ -96,7 +110,7 @@ async function prAction({ git, log }, opts) {
   if (gitLog.total > 1) {
     title =
       findTitle(gitLog.all.map(c => c.subject)) || current.replace(/-/g, ' ');
-    body = gitLog.all
+    body = [...gitLog.all]
       .reverse()
       .map(c => `* ${c.subject}`)
       .join('\n');
@@ -118,6 +132,7 @@ async function prAction({ git, log }, opts) {
   if (opts.parent.open) await open(prURL);
 }
 
+/** @type {import('../typedefs').Action} */
 module.exports = {
   action: prAction,
   command(prog, wrapAction) {

lib/commands/qa.js

@@ -45,27 +45,31 @@ function genBuildTag() {
   return `build-${ts}`;
 }
 
-async function qaAction({ git, log }, branch, opts) {
+/** @type {import('../typedefs').ActionFn} */
+async function qaAction({ deps: { git, log }, args: [branch], opts }) {
   await assertNoFork(git, 'qa');
 
   if (branch) await git.checkout(branch);
   else branch = (await git.branchLocal()).current;
 
   if (branch === 'release' && opts.mergeBack) {
     log('Requiring clean merge-back for release qa');
-    await mergeBackAction({ git, log });
+    await mergeBackAction({ deps: { git, log }, opts, args: [] });
   } else {
     log(`Pulling latest commits for '${branch}'`);
+    // @ts-ignore
     await git.pull({ '--no-rebase': true });
   }
 
   const tag = genBuildTag();
 
   log(`Creating and pushing tag to github: ${tag}`);
   await git.tag([tag]);
+  // @ts-ignore
   await git.push(['origin', 'tag', tag]);
 }
 
+/** @type {import('../typedefs').Action} */
 module.exports = {
   action: qaAction,
   command(prog, wrapAction) {

lib/commands/rename.js

@@ -34,7 +34,8 @@
 
 const { UIError, featureParent, remoteFromLocal } = require('../common');
 
-async function renameAction({ git, log }, newBranch) {
+/** @type {import('../typedefs').ActionFn} */
+async function renameAction({ deps: { git, log }, args: [newBranch] }) {
   const { current } = await git.branchLocal();
 
   const { parent, remote } = await featureParent(git, current);
@@ -49,6 +50,7 @@ async function renameAction({ git, log }, newBranch) {
   }
 
   log(`Fetching ${remote}`);
+  // @ts-ignore
   await git.fetch([remote]);
 
   log(`Creating ${newRemoteBranch} on ${remote}`);
@@ -66,6 +68,7 @@ async function renameAction({ git, log }, newBranch) {
   await git.push(remote, `:${oldRemoteBranch}`);
 }
 
+/** @type {import('../typedefs').Action} */
 module.exports = {
   action: renameAction,
   command(prog, wrapAction) {

lib/commands/start.js

@@ -34,9 +34,8 @@
 
 const { remoteFromLocal, UIError, inferRemote } = require('../common');
 
-async function startAction({ git, log }, branch, opts) {
-  opts = opts || {};
-
+/** @type {import('../typedefs').ActionFn} */
+async function startAction({ deps: { git, log }, args: [branch], opts }) {
   if (!/^[\w-]+$/.test(branch)) {
     throw new UIError('branch must match /^[\\w-]+$/');
   }
@@ -67,6 +66,7 @@ async function startAction({ git, log }, branch, opts) {
   }
 
   log(`Updating current branch '${current}'`);
+  // @ts-ignore
   await git.pull({ '--no-rebase': true });
 
   const pushSpec = `${branch}:${remoteBranch}`;
@@ -80,6 +80,7 @@ async function startAction({ git, log }, branch, opts) {
   }
 }
 
+/** @type {import('../typedefs').Action} */
 module.exports = {
   action: startAction,
   command(prog, wrapAction) {