release

#!/usr/bin/env node
(function () {
  'use strict';

  const REPO_TITLE   = 'Angular Flex-Layout';
  const SOURCE_REPO  = 'flex-layout';         // Source repository with Demo-app and wiki docs
  const BUILD_REPO   = 'flex-layout-builds';  // Build repository used for npm publish and travis CI
  const NPM_RELEASES = 'scripts/release/releases.json';

  var lineWidth      = 80;
  var defaultOptions = { encoding: 'utf-8' };
  var colors         = require('colors');
  var strip          = require('cli-color/strip');
  var fs             = require('fs');
  var prompt         = require('prompt-sync')();
  var child_process  = require('child_process');
  var releases       = require(`./${NPM_RELEASES}`);
  var oldVersion     = require('./package.json').version;

  var cleanupCmds    = [];
  var pushCmds       = [ 'rm ./abort ./push' ];
  var abortCmds      = [ 'rm ./abort ./push', 'git reset --hard', 'git checkout master' ];

  var origin         = 'git@github.com:angular/flex-layout.git';
  var newVersion     = "";
  var lastMajorVer   = releases.latest;
  var isYes          = matches.bind(this, "yes");
  var isDryRun       = isYes(prompt(`Is this a dry-run? ${"[yes/no]".cyan} `));
  var skipOnDryRun           = isDryRun ? '## -- ' : '';

  let msg = `What would you like the old version to be? (default: ${oldVersion.cyan}) `;
  oldVersion = prompt(msg) || oldVersion;
  newVersion = getNewVersion();

  let validated = isDryRun || validate();
  if ( validated ) {
    build();
  }

  // ********************************************************
  // Scripts and Utils
  // ********************************************************

  /** start the build script */

  function build () {
    let hint = "git add CHANGELOG.md; git commit --amend --no-edit;";

    line();

    checkoutVersionBranch();
    updateVersion();
    createChangelog();
    commitChanges();
    tagRelease();
    cloneDeployRepo();
    generateLatestBuild();
    updateMaster();
    writeScript('abort', abortCmds.concat(cleanupCmds));
    writeScript('push', pushCmds.concat(cleanupCmds));

    line();

    log(`Your repo is ${"ready".cyan} to be pushed.`);
    log(`Please look over ${"CHANGELOG.md".cyan} and make any changes.`);
    log(`! ------------ `);
    log(`! NOTE: If you make changes to the CHANGELOG, use `);
    log(`!   ${hint.red} `);
    log(`! before proceeding with "${"./push".cyan}"`);
    log(`! ------------ `);
    log(`If you would like to cancel this release, please run "${"./abort".cyan}"`);
    log(`When you are ready, please run "${"./push".cyan}" to finish the process.`);
  }


  /** confirms that you will be able to perform the release before attempting */
  function validate () {
    return true;

    if (exec('npm whoami') !== 'angular') {
      err('You must be authenticated with npm as "angular" to perform a release.');
    } else if (exec('git rev-parse --abbrev-ref HEAD') !== 'staging') {
      err('Releases must be performed from a "staging" branch.');
      err('Please checkout the lastest source: `git checkout -B staging`.');
    } else {
      return true;
    }
    function err (msg) {
      var str = 'Error: ' + msg;
      log(str.red);
    }
  }

  /**
   * Confirm case-insensitive prompt() response partially matches
   * one of the options.
   */
  function matches(options, value) {
    value = value.toLowerCase();
    if ( typeof options === 'string' ) options = [options];
    options = [' '].concat(options);

    return options.reduce((prev, curr)=>{
      return !prev ? curr.indexOf(value) > -1 : true;
    },false);
  }

  /** creates the version branch and adds abort steps */
  function checkoutVersionBranch () {
    exec(`git branch -q -D release/${newVersion}`);
    exec(`git checkout -q -b release/${newVersion}`);

    pushCmds.push(`# build release/${newVersion} branch...`);
    abortCmds.push('git checkout staging -q');
  }

  /** writes the new version to package.json */
  function updateVersion() {
    start(`Updating ${"package.json".cyan} version from ${oldVersion.cyan} to ${newVersion.cyan}...`);
    updatePackageVersions();
    done();
  }

  /** generates the changelog from the commits since the last release */
  function createChangelog () {
    start(`Generating changelog from ${oldVersion.cyan} to ${newVersion.cyan}...`);

    // Use the current CHANGELOG.md (that is on #master and now this branch)
    exec(`./scripts/release/changelog.js`);
    done();

    abortCmds.push('git checkout CHANGELOG.md');
  }

  function updateReleasesJson () {
    const RELEASE_PATH = './scripts/release/releases.json';
    const config = require( RELEASE_PATH );

        config.versions.unshift(newVersion);
        config.latest = newVersion;

    require('fs').writeFileSync(RELEASE_PATH, JSON.stringify(config, null, 2));
  }

  /** utility method for clearing the terminal */
  function clear () {
    write("\u001b[2J\u001b[0;0H");
  }

  /** prompts the user for the new version */
  function getNewVersion () {
    var options = getVersionOptions(oldVersion), key, type, version;

    header();
    log(`The current version is ${oldVersion.cyan}.`);
    log('');
    log('What should the next version be?');
    for (key in options) { log((+key + 1) + ') ' + options[ key ].cyan); }
    log('');
    type = prompt('Please select a new version: ');

    if (options[ type - 1 ]) version = options[ type - 1 ];
    else if (type.match(/^\d+\.\d+\.\d+(-rc\.?\d+)?$/)) version = type;
    else throw new Error('Your entry was invalid.');

    log('');
    log('The new version will be ' + version.cyan + '.');
    return isYes(prompt(`Is this correct? ${"[yes/no]".cyan} `)) ? version : getNewVersion();

    function getVersionOptions (version) {
      return version.match(/-alpha\.?\d+$/) ? [ increment(version, 'alpha'), addBeta(increment(version, 'minor')) ] :
             version.match(/-beta\.?\d+$/) ? [ increment(version, 'beta'), increment(version, 'rc') ] :
             version.match(/-rc\.?\d+$/) ? [ increment(version, 'rc'), increment(version, 'patch') ] :
             [ increment(version, 'patch'), increment(version, 'minor') ];

      function increment (versionString, type) {
        var version = parseVersion(versionString);
        switch (type) {
          case 'alpha':
          case 'beta' :
          case 'rc'   :
          case 'patch':
          case 'minor':
            ++version[type];
            break;
        }
        resetVersionParts(type);

        return buildVersionString(version);

        function parseVersion (version) {
          var hasBeta = version.indexOf("-beta") > -1;
          var parts = version.split(/\-beta\.|\-rc\.|\./g);
          return {
            string: version,
            major:  parts[ 0 ],
            minor:  parts[ 1 ],
            patch:  parts[ 2 ],
            rc   :  hasBeta ? 0 : (parts[ 3 ] || 0),
            beta :  hasBeta ? (parts[ 3 ] || 0) : 0,
          };
        }

        function buildVersionString (version) {
          var  str = version.major + '.' + version.minor + '.' + version.patch;
              str += version.rc    ? `-rc.${version.rc}`       :
                     version.beta  ? `-beta.${version.beta}`   :
                     version.alpha ? `-alpha.${version.alpha}` : "";
          return str;
        }

        function resetVersionParts() {
          switch (type) {
            case 'minor' : version.patch = 0;
            case 'patch' : version.rc    = 0;
            case 'rc'    : version.beta  = 0;
            case 'beta'  : version.alpha = 0;
          }
        }
      }

      function addRC (str) {
        return str + '-rc.1';
      }
      function addBeta (str) {
        return str + '-beta.1';
      }
    }
  }

  /** adds git tag for release and pushes to github */
  function tagRelease () {

    pushCmds.push(
        `git tag v${newVersion} -f`,
        `${skipOnDryRun} git push --tags ${origin}`
    );

  }

  /** amends the commit to include local changes (ie. changelog) */
  function commitChanges () {
    start('Committing changes...');
    exec(`git commit -am "build(release): version ${newVersion}"`);
    done();

    // Now any other changes (on the release branch will
    // be amended to the last commit
    // !! NOTE: Typically this is not needed.
    //pushCmds.push('git commit --amend --no-edit');
  }

  /** utility method for cloning github repos */
  function cloneDeployRepo () {
    let path = "./"+BUILD_REPO;
    start(`Cloning ${path.cyan} from Github...`);
    exec(`rm -Rf ${path}`);
    exec(`git clone git@github.com:angular/${BUILD_REPO}.git --depth=1`);
    done();

    cleanupCmds.push(
      'rm -rf dist',
      `${skipOnDryRun} rm -Rf ${path}`,
      `${skipOnDryRun} git branch -D release/${newVersion}`
    );

  }

  /** writes an array of commands to a bash script */
  function writeScript (name, cmds) {
    fs.writeFileSync(name, '#!/usr/bin/env bash\n\n' + cmds.join('\n'));
    exec('chmod +x ' + name);
  }

  /** updates the version for flex-layout-builds in package.json  */
  function generateLatestBuild () {
    start('Building deployed files...');
    exec([
      'rm -rf dist',
      'gulp flex-layout:build-release:clean'
     ]);
    done();

    // Execute the next commands relative to the flex-layout-builds repo
    let options = {cwd: "./"+BUILD_REPO};

    start(`Copy files into ${options.cwd.cyan} repo...`);

    exec([
      'cp -Rf ../dist/@angular/flex-layout/* ./',                   // local build output dir
      'cp -f ../CHANGELOG.md .',                                    // always over the CHANGELOG
      'git add -A',
      `git commit -m "build(deploy): release version ${newVersion}"`
    ], options);
    done();

    // These actions occur AFTER pause and the `./push`
    pushCmds.push(
      comment(`push to angular/${BUILD_REPO} (master and tag) and publish to npm`),
      `cd ./${BUILD_REPO}`,
      `node -e "var newVersion = '${newVersion}'; ${stringifyFunction(updatePackageVersions)}"`,
      'git add package.json',
      'cp -f ../CHANGELOG.md .',                  // Copy Changelog from root (if changed)
      'git add CHANGELOG.md',                     // re-add to the commit
      'git commit --amend --no-edit',
      `git tag -f v${newVersion}`,            // Tag and update @angular/flex-layout-builds
      'git pull --rebase --strategy=ours',
      `${skipOnDryRun} git push`,
      `${skipOnDryRun} git push --tags`,
      comment(!isDryRun ? '' : `Publishing @angular/flex-layout ${newVersion} to npm`),
      `${skipOnDryRun} npm publish`,
      'cd ../',

    );

    function stringifyFunction (method) {
      return method
          .toString()
          .split('\n')
          .slice(1, -1)
          .map((line) => line.trim() )
          .join(' ')
          .replace(/"/g, '\\"');
    }
  }

  /**
   * When updating the 'master' branch, update both the source repository 'package.json',
   * and also the npm version that is used when deploying the releases to npm.
   * FYI -
   *  ./package.json == package for the source repo
   *  ./scripts/release/package.json == package for the deployed npm build
   */
  function updatePackageVersions () {
    [ './package.json'].forEach(filePath => {
      let json = require(filePath);
          json.version = newVersion;
      require('fs').writeFileSync(filePath, JSON.stringify(json, null, 2));
    });
  }

  /**
   *  copies the changelog back over to master branch
   *  FYI -
   *    ./package.json == package for the source repo
   *    ./src/lib/package.json == package for the deployed npm build
   *    ./scripts/release/releases.json == version list used by release script getNewVersion()
   */
  function updateMaster () {
    pushCmds.push(
        comment('update package.json in master'),
        'git checkout master -q',
        `git checkout release/${newVersion} -- CHANGELOG.md`,
        `node -e "var newVersion = '${newVersion}'; ${stringifyFunction(updatePackageVersions)}"`,
        'git add package.json',
        `node -e "var newVersion = '${newVersion}'; ${stringifyFunction(updateReleasesJson)}"`,
        `git add ${NPM_RELEASES}`,
        `git commit -m "chore(version): update version number in package.json to ${newVersion}"`,
        `${skipOnDryRun} git push ${origin} master`
    );

    function stringifyFunction (method) {
      return method
          .toString()
          .split('\n')
          .slice(1, -1)
          .map((line) => line.trim() )
          .join(' ')
          .replace(/"/g, '\\"');
    }
  }

  /** utility method to output header */
  function header () {
    clear();
    line();
    log(center(`${REPO_TITLE} : NPM Release`));
    line();
  }

  /** outputs a centered message in the terminal */
  function center (msg) {
    msg        = ' ' + msg.trim() + ' ';
    var length = msg.length;
    var spaces = Math.floor((lineWidth - length) / 2);
    return Array(spaces + 1).join('-') + msg.green + Array(lineWidth - msg.length - spaces + 1).join('-');
  }

  /** outputs done text when a task is completed */
  function done () {
    log('done'.green);
  }

  /** utility method for executing terminal commands */
  function exec (cmd, userOptions) {
    if (cmd instanceof Array) {
      return cmd.map( (cmd) => exec(cmd, userOptions) );
    }
    try {
      var options = Object.create(defaultOptions);
      for (var key in userOptions) options[ key ] = userOptions[ key ];
      return child_process.execSync(cmd + ' 2> /dev/null', options).toString().trim();
    } catch (err) {
      return err;
    }
  }

  /** returns a commented message for use in bash scripts */
  function comment (msg) {
    return '\n# ' + msg + '\n';
  }

  /** prints the left side of a task while it is being performed */
  function start (msg) {
    var msgLength = strip(msg).length,
        diff      = lineWidth - 4 - msgLength;
    write(msg + Array(diff + 1).join(' '));
  }

  /** outputs to the terminal with string variable replacement */
  function log (msg) {
    msg = msg || '';
    console.log(msg);
  }

  /** writes a message without a newline */
  function write (msg) {
    process.stdout.write(msg);
  }

  /** prints a horizontal line to the terminal */
  function line () {
    log(Array(lineWidth + 1).join('-'));
  }
})();