chore(package): re-init package with commitizen and standard-release

node_modules/standard-version/lib/lifecycles/bump.js

@@ -0,0 +1,165 @@
+'use strict'
+
+const chalk = require('chalk')
+const checkpoint = require('../checkpoint')
+const conventionalRecommendedBump = require('conventional-recommended-bump')
+const figures = require('figures')
+const fs = require('fs')
+const DotGitignore = require('dotgitignore')
+const path = require('path')
+const runLifecycleScript = require('../run-lifecycle-script')
+const semver = require('semver')
+const writeFile = require('../write-file')
+
+var configsToUpdate = {}
+
+function Bump (args, pkg) {
+  // reset the cache of updated config files each
+  // time we perform the version bump step.
+  configsToUpdate = {}
+
+  if (args.skip.bump) return Promise.resolve()
+  var newVersion = pkg.version
+  return runLifecycleScript(args, 'prebump')
+    .then((stdout) => {
+      if (stdout && stdout.trim().length) args.releaseAs = stdout.trim()
+      return bumpVersion(args.releaseAs)
+    })
+    .then((release) => {
+      if (!args.firstRelease) {
+        var releaseType = getReleaseType(args.prerelease, release.releaseType, pkg.version)
+        newVersion = semver.valid(releaseType) || semver.inc(pkg.version, releaseType, args.prerelease)
+        updateConfigs(args, newVersion)
+      } else {
+        checkpoint(args, 'skip version bump on first release', [], chalk.red(figures.cross))
+      }
+    })
+    .then(() => {
+      return runLifecycleScript(args, 'postbump')
+    })
+    .then(() => {
+      return newVersion
+    })
+}
+
+Bump.getUpdatedConfigs = function () {
+  return configsToUpdate
+}
+
+function getReleaseType (prerelease, expectedReleaseType, currentVersion) {
+  if (isString(prerelease)) {
+    if (isInPrerelease(currentVersion)) {
+      if (shouldContinuePrerelease(currentVersion, expectedReleaseType) ||
+        getTypePriority(getCurrentActiveType(currentVersion)) > getTypePriority(expectedReleaseType)
+      ) {
+        return 'prerelease'
+      }
+    }
+
+    return 'pre' + expectedReleaseType
+  } else {
+    return expectedReleaseType
+  }
+}
+
+function isString (val) {
+  return typeof val === 'string'
+}
+
+/**
+ * if a version is currently in pre-release state,
+ * and if it current in-pre-release type is same as expect type,
+ * it should continue the pre-release with the same type
+ *
+ * @param version
+ * @param expectType
+ * @return {boolean}
+ */
+function shouldContinuePrerelease (version, expectType) {
+  return getCurrentActiveType(version) === expectType
+}
+
+function isInPrerelease (version) {
+  return Array.isArray(semver.prerelease(version))
+}
+
+var TypeList = ['major', 'minor', 'patch'].reverse()
+
+/**
+ * extract the in-pre-release type in target version
+ *
+ * @param version
+ * @return {string}
+ */
+function getCurrentActiveType (version) {
+  var typelist = TypeList
+  for (var i = 0; i < typelist.length; i++) {
+    if (semver[typelist[i]](version)) {
+      return typelist[i]
+    }
+  }
+}
+
+/**
+ * calculate the priority of release type,
+ * major - 2, minor - 1, patch - 0
+ *
+ * @param type
+ * @return {number}
+ */
+function getTypePriority (type) {
+  return TypeList.indexOf(type)
+}
+
+function bumpVersion (releaseAs, callback) {
+  return new Promise((resolve, reject) => {
+    if (releaseAs) {
+      return resolve({
+        releaseType: releaseAs
+      })
+    } else {
+      conventionalRecommendedBump({
+        preset: 'angular'
+      }, function (err, release) {
+        if (err) return reject(err)
+        else return resolve(release)
+      })
+    }
+  })
+}
+
+/**
+ * attempt to update the version # in a collection of common config
+ * files, e.g., package.json, bower.json.
+ *
+ * @param args config object
+ * @param newVersion version # to update to.
+ * @return {string}
+ */
+function updateConfigs (args, newVersion) {
+  const dotgit = DotGitignore()
+  configsToUpdate[path.resolve(process.cwd(), './package.json')] = false
+  configsToUpdate[path.resolve(process.cwd(), './package-lock.json')] = false
+  configsToUpdate[path.resolve(process.cwd(), './npm-shrinkwrap.json')] = false
+  configsToUpdate[path.resolve(process.cwd(), './bower.json')] = false
+  Object.keys(configsToUpdate).forEach(function (configPath) {
+    try {
+      if (dotgit.ignore(configPath)) return
+      var stat = fs.lstatSync(configPath)
+      if (stat.isFile()) {
+        var config = require(configPath)
+        var filename = path.basename(configPath)
+        checkpoint(args, 'bumping version in ' + filename + ' from %s to %s', [config.version, newVersion])
+        config.version = newVersion
+        writeFile(args, configPath, JSON.stringify(config, null, 2) + '\n')
+        // flag any config files that we modify the version # for
+        // as having been updated.
+        configsToUpdate[configPath] = true
+      }
+    } catch (err) {
+      if (err.code !== 'ENOENT') console.warn(err.message)
+    }
+  })
+}
+
+module.exports = Bump

node_modules/standard-version/lib/lifecycles/changelog.js

@@ -0,0 +1,62 @@
+const accessSync = require('fs-access').sync
+const chalk = require('chalk')
+const checkpoint = require('../checkpoint')
+const conventionalChangelog = require('conventional-changelog')
+const fs = require('fs')
+const runLifecycleScript = require('../run-lifecycle-script')
+const writeFile = require('../write-file')
+
+module.exports = function (args, newVersion) {
+  if (args.skip.changelog) return Promise.resolve()
+  return runLifecycleScript(args, 'prechangelog')
+    .then(() => {
+      return outputChangelog(args, newVersion)
+    })
+    .then(() => {
+      return runLifecycleScript(args, 'postchangelog')
+    })
+}
+
+function outputChangelog (args, newVersion) {
+  return new Promise((resolve, reject) => {
+    createIfMissing(args)
+    var header = '# Change Log\n\nAll notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.\n'
+    var oldContent = args.dryRun ? '' : fs.readFileSync(args.infile, 'utf-8')
+    // find the position of the last release and remove header:
+    if (oldContent.indexOf('<a name=') !== -1) {
+      oldContent = oldContent.substring(oldContent.indexOf('<a name='))
+    }
+    var content = ''
+    var context
+    if (args.dryRun) context = {version: newVersion}
+    var changelogStream = conventionalChangelog({
+      preset: 'angular'
+    }, context, {merges: null})
+      .on('error', function (err) {
+        return reject(err)
+      })
+
+    changelogStream.on('data', function (buffer) {
+      content += buffer.toString()
+    })
+
+    changelogStream.on('end', function () {
+      checkpoint(args, 'outputting changes to %s', [args.infile])
+      if (args.dryRun) console.info(`\n---\n${chalk.gray(content.trim())}\n---\n`)
+      else writeFile(args, args.infile, header + '\n' + (content + oldContent).replace(/\n+$/, '\n'))
+      return resolve()
+    })
+  })
+}
+
+function createIfMissing (args) {
+  try {
+    accessSync(args.infile, fs.F_OK)
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      checkpoint(args, 'created %s', [args.infile])
+      args.outputUnreleased = true
+      writeFile(args, args.infile, '\n')
+    }
+  }
+}

node_modules/standard-version/lib/lifecycles/commit.js

@@ -0,0 +1,39 @@
+const bump = require('../lifecycles/bump')
+const checkpoint = require('../checkpoint')
+const formatCommitMessage = require('../format-commit-message')
+const path = require('path')
+const runExec = require('../run-exec')
+const runLifecycleScript = require('../run-lifecycle-script')
+
+module.exports = function (args, newVersion) {
+  if (args.skip.commit) return Promise.resolve()
+  return runLifecycleScript(args, 'precommit')
+    .then((message) => {
+      if (message && message.length) args.message = message
+      return execCommit(args, newVersion)
+    })
+    .then(() => {
+      return runLifecycleScript(args, 'postcommit')
+    })
+}
+
+function execCommit (args, newVersion) {
+  var msg = 'committing %s'
+  var paths = [args.infile]
+  var verify = args.verify === false || args.n ? '--no-verify ' : ''
+  var toAdd = ''
+  // commit any of the config files that we've updated
+  // the version # for.
+  Object.keys(bump.getUpdatedConfigs()).forEach(function (p) {
+    if (bump.getUpdatedConfigs()[p]) {
+      msg += ' and %s'
+      paths.unshift(path.basename(p))
+      toAdd += ' ' + path.relative(process.cwd(), p)
+    }
+  })
+  checkpoint(args, msg, paths)
+  return runExec(args, 'git add' + toAdd + ' ' + args.infile)
+    .then(() => {
+      return runExec(args, 'git commit ' + verify + (args.sign ? '-S ' : '') + (args.commitAll ? '' : (args.infile + toAdd)) + ' -m "' + formatCommitMessage(args.message, newVersion) + '"')
+    })
+}

node_modules/standard-version/lib/lifecycles/tag.js

@@ -0,0 +1,35 @@
+const chalk = require('chalk')
+const checkpoint = require('../checkpoint')
+const figures = require('figures')
+const formatCommitMessage = require('../format-commit-message')
+const runExec = require('../run-exec')
+const runLifecycleScript = require('../run-lifecycle-script')
+
+module.exports = function (newVersion, pkgPrivate, args) {
+  if (args.skip.tag) return Promise.resolve()
+  return runLifecycleScript(args, 'pretag')
+    .then(() => {
+      return execTag(newVersion, pkgPrivate, args)
+    })
+    .then(() => {
+      return runLifecycleScript(args, 'posttag')
+    })
+}
+
+function execTag (newVersion, pkgPrivate, args) {
+  var tagOption
+  if (args.sign) {
+    tagOption = '-s '
+  } else {
+    tagOption = '-a '
+  }
+  checkpoint(args, 'tagging release %s', [newVersion])
+  return runExec(args, 'git tag ' + tagOption + args.tagPrefix + newVersion + ' -m "' + formatCommitMessage(args.message, newVersion) + '"')
+    .then(() => {
+      var message = 'git push --follow-tags origin master'
+      if (pkgPrivate !== true) message += ' && npm publish'
+      if (args.prerelease !== undefined) message += ' --tag prerelease'
+
+      checkpoint(args, 'Run `%s` to publish', [message], chalk.blue(figures.info))
+    })
+}