[wip] git node land prototype

Author: joyeecheung

components/git/git-node-land

@@ -5,7 +5,9 @@ const CLI = require('../../lib/cli');
 const cli = new CLI(process.stderr);
 const Request = require('../../lib/request');
 const req = new Request();
-const { runPromise, runAsync, runSync } = require('../../lib/run');
+const {
+  runPromise, runAsync, runSync, forceRunAsync
+} = require('../../lib/run');
 const Session = require('../../lib/landing_session');
 const dir = process.cwd();
 const args = process.argv.slice(2);
@@ -40,8 +42,23 @@ if (result.length) {
 }
 
 async function main(state, args) {
+  let session;
+
+  try {
+    session = Session.restore(dir);
+  } catch (err) { // JSON error?
+    if (state === ABORT) {
+      session = new Session(dir);
+      await abort(session);
+      return;
+    }
+    cli.warn(
+      'Failed to detect previous session. ' +
+      'please run `git node land --abort`');
+    return;
+  }
+
   if (state === START) {
-    let session = Session.restore(dir);
     if (session.hasStarted()) {
       cli.warn(
         'Previous `git node land` session for ' +
@@ -52,19 +69,14 @@ async function main(state, args) {
     session = new Session(dir, parseInt(args[0]));
     await start(session);
   } else if (state === APPLY) {
-    const session = Session.restore(dir);
     await apply(session);
   } else if (state === AMEND) {
-    const session = Session.restore(dir);
     await amend(session);
   } else if (state === FINAL) {
-    const session = Session.restore(dir);
     await final(session);
   } else if (state === ABORT) {
-    const session = Session.restore(dir);
-    session.abort();
+    await abort(session);
   } else if (state === CONTINUE) {
-    const session = Session.restore(dir);
     await continueSession(session);
   }
 }
@@ -78,35 +90,109 @@ async function start(session) {
   const response = await cli.prompt(
     `This PR ${status} to land, do you want to continue?`);
   if (response) {
-    session.saveMetadata(status);
+    session.saveMetadata(result);
     session.startApplying();
     return apply(session);
   } else {
-    session.abort();
-    cli.log('Landing session aborted');
+    await abort(session);
     process.exit();
   }
 }
 
+function getNotYetPushedCommits(session, verbose) {
+  const upstream = session.upstream;
+  const branch = session.branch;
+  var revs;
+  if (verbose) {
+    revs = runSync('git',
+      ['log', '--oneline', `${upstream}/${branch}...HEAD`]);
+  } else {
+    revs = runSync('git', ['rev-list', `${upstream}/${branch}...HEAD`]);
+  }
+
+  if (!revs.trim()) {
+    return [];
+  }
+  return revs.trim().split('\n');
+}
+
+async function tryAbortAm(session, cli) {
+  if (session.amInProgress()) {
+    const shouldAbortAm = await cli.prompt(
+      'Abort previous git am sessions?');
+    if (shouldAbortAm) {
+      await forceRunAsync('git', ['am', '--abort']);
+      cli.ok('Aborted previous git am sessions');
+    }
+  } else {
+    cli.ok('No git am in progress');
+  }
+}
+
+async function tryAbortRebase(session, cli) {
+  if (session.rebaseInProgress()) {
+    const shouldAbortRebase = await cli.prompt(
+      'Abort previous git rebase sessions?');
+    if (shouldAbortRebase) {
+      await forceRunAsync('git', ['rebase', '--abort']);
+      cli.ok('Aborted previous git rebase sessions');
+    }
+  } else {
+    cli.ok('No git rebase in progress');
+  }
+}
+
+async function tryResetHead(session, cli) {
+  const branch = `${session.upstream}/${session.branch}`;
+  cli.startSpinner(`Bringing ${branch} up to date`);
+  await runAsync('git',
+    ['fetch', session.upstream, session.branch]);
+  cli.stopSpinner(`${branch} is now up-to-date`);
+  const notYetPushed = getNotYetPushedCommits(session, true);
+  if (notYetPushed.length) {
+    const branch = `${session.upstream}/${session.branch}`;
+    cli.log(`Found strayed commits in ${branch}:\n` +
+      ` - ${notYetPushed.join('\n - ')}`);
+    const shouldReset = await cli.prompt(`Reset to ${branch}?`);
+    if (shouldReset) {
+      await runAsync('git', ['reset', '--hard', branch]);
+      cli.ok(`Reset to ${branch}`);
+    }
+  }
+}
+
+async function tryResetBranch(session, cli) {
+  await tryAbortAm(session, cli);
+  await tryAbortRebase(session, cli);
+
+  const branch = `${session.upstream}/${session.branch}`;
+  const shouldResetHead = await cli.prompt(
+    `Do you want to try reset the branch to ${branch}?`);
+  if (shouldResetHead) {
+    await tryResetHead(session, cli);
+  }
+}
+
+async function abort(session) {
+  session.abort();
+  await tryResetBranch(session, cli);
+  cli.log(`Aborted \`git node land\` session in ${session.ncuDir}`);
+}
+
 async function apply(session) {
   if (!session.readyToApply()) {
     cli.warn('This session can not proceed to apply patches, ' +
       'run `git node land --abort`');
     return;
   }
 
-  if (session.hasAM()) {
-    const shouldAbortAm = await cli.prompt('Abort previous git am sessions?');
-    if (shouldAbortAm) {
-      await runAsync('git', ['am', '--abort']);
-    }
-  }
+  await tryResetBranch(session, cli);
 
   const { repo, owner, prid } = session;
   // TODO: restore previously downloaded patches
   cli.startSpinner(`Downloading patch for ${prid}`);
   const patch = await req.promise({
-    url: `https://github.com/nodejs/${owner}/${repo}/${prid}.patch`
+    url: `https://github.com/${owner}/${repo}/pull/${prid}.patch`
   });
   session.savePatch(patch);
   cli.stopSpinner(`Downloaded patch to ${session.patchPath}`);
@@ -118,14 +204,29 @@ async function apply(session) {
   session.startAmending();
   if (/Subject: \[PATCH\]/.test(patch)) {
     const shouldAmend = await cli.prompt(
-      'There is only one patch to apply.\n' +
+      'There is only one commit in this PR.\n' +
       'do you want to amend the commit message?');
     if (shouldAmend) {
       const canFinal = await amend(session);
       if (canFinal) {
         return final(session);
       }
     }
+  } else {
+    const re = /Subject: \[PATCH 1\/(\d+)\]/;
+    const match = patch.match(re);
+    if (!match) {
+      cli.warn('Cannot get number of commits in the patch. ' +
+        'It seems to be malformed');
+      return;
+    }
+    const upstream = session.upstream;
+    const branch = session.branch;
+    cli.log(
+      `There are ${match[1]} commits in the PR.\n` +
+      `Please run \`git rebase ${upstream}/${branch} -i\` ` +
+      'and use `git node land --amend` to amend the commit messages');
+    // TODO: do git rebase automatically?
   }
 }
 
@@ -136,16 +237,18 @@ async function amend(session) {
   }
 
   const rev = runSync('git', ['rev-parse', 'HEAD']);
-  const original = runSync('git', ['show', rev, '-s', '--format=%B']);
-  const metadata = session.metadata.split('\n');
+  const original = runSync('git', ['show', 'HEAD', '-s', '--format=%B']).trim();
+  const metadata = session.metadata.trim().split('\n');
   const amended = original.split('\n');
-  if (amended[amended.length - 1] !== '\n') {
-    amended.push('\n');
+  if (amended[amended.length - 1] !== '') {
+    amended.push('');
   }
 
   for (const line of metadata) {
     if (original.includes(line)) {
-      cli.warn(`Found ${line}, skipping..`);
+      if (line) {
+        cli.warn(`Found ${line}, skipping..`);
+      }
     } else {
       amended.push(line);
     }
@@ -154,15 +257,16 @@ async function amend(session) {
   const message = amended.join('\n') + '\n';
   const messageFile = session.saveMessage(rev, message);
   cli.separator('New Message');
-  cli.log(message);
+  cli.log(message.trim());
+  cli.separator();
   const takeMessage = await cli.prompt('Use this message?');
   if (takeMessage) {
     await runAsync('git', ['commit', '--amend', '-F', messageFile]);
-    session.markAsAmended(rev);
+    // session.markAsAmended(rev);
     return true;
   }
 
-  cli.log(`Please manually edit ${messageFile}, then run ` +
+  cli.log(`Please manually edit ${messageFile}, then run\n` +
     `\`git commit --amend -F ${messageFile}\` to finish amending the message`);
   return false;
 };
@@ -172,13 +276,16 @@ async function final(session) {
     cli.warn('Not yet ready to final');
     return;
   }
-
   const upstream = session.upstream;
   const branch = session.branch;
-  const notYetPushed = runSync('git',
-    ['rev-list', `${upstream}/${branch}...HEAD`]).split('\n');
+  const notYetPushed = getNotYetPushedCommits(session);
+  const notYetPushedVerbose = getNotYetPushedCommits(session, true);
   await runAsync('core-validate-commit', notYetPushed);
-  cli.log('This session is ready to be completed.');
+  cli.separator();
+  cli.log('The following commits are ready to be pushed to ' +
+    `${upstream}/${branch}`);
+  cli.log(`- ${notYetPushedVerbose.join('\n- ')}`);
+  cli.separator();
   cli.log(`run \`git push ${upstream} ${branch}\` to finish landing`);
   const shouldClean = await cli.prompt('Clean up generated temporary files?');
   if (shouldClean) {

lib/cli.js

@@ -6,6 +6,7 @@ const {
 const ora = require('ora');
 const { EOL } = require('os');
 const chalk = require('chalk');
+const read = require('read');
 
 const warning = chalk.yellow(warningRaw);
 const error = chalk.red(cross);
@@ -31,6 +32,28 @@ class CLI {
     this.spinner = ora({ stream });
   }
 
+  prompt(question, defaultAnswer = true) {
+    const option =
+      `[${(defaultAnswer ? 'Y' : 'y')}/${(defaultAnswer ? 'n' : 'N')}]`;
+    return new Promise((resolve, reject) => {
+      read({prompt: `${question} ${option} `}, (err, answer) => {
+        if (err) {
+          reject(err);
+        }
+        if (answer === undefined || answer === null) {
+          reject(new Error('__ignore__'));
+        }
+        const trimmed = answer.toLowerCase().trim();
+        if (!trimmed) {
+          resolve(defaultAnswer);
+        } else if (trimmed === 'y') {
+          resolve(true);
+        }
+        resolve(false);
+      });
+    });
+  }
+
   startSpinner(text) {
     this.spinner.text = text;
     this.spinner.start();