projen-pipelines 0.0.72 → 0.1.0

package/node_modules/standard-version/index.js

@@ -0,0 +1,80 @@
+const bump = require('./lib/lifecycles/bump')
+const changelog = require('./lib/lifecycles/changelog')
+const commit = require('./lib/lifecycles/commit')
+const fs = require('fs')
+const latestSemverTag = require('./lib/latest-semver-tag')
+const path = require('path')
+const printError = require('./lib/print-error')
+const tag = require('./lib/lifecycles/tag')
+const { resolveUpdaterObjectFromArgument } = require('./lib/updaters')
+
+module.exports = async function standardVersion (argv) {
+  const defaults = require('./defaults')
+  /**
+   * `--message` (`-m`) support will be removed in the next major version.
+   */
+  const message = argv.m || argv.message
+  if (message) {
+    /**
+     * The `--message` flag uses `%s` for version substitutions, we swap this
+     * for the substitution defined in the config-spec for future-proofing upstream
+     * handling.
+     */
+    argv.releaseCommitMessageFormat = message.replace(/%s/g, '{{currentTag}}')
+    if (!argv.silent) {
+      console.warn('[standard-version]: --message (-m) will be removed in the next major release. Use --releaseCommitMessageFormat.')
+    }
+  }
+
+  if (argv.changelogHeader) {
+    argv.header = argv.changelogHeader
+    if (!argv.silent) {
+      console.warn('[standard-version]: --changelogHeader will be removed in the next major release. Use --header.')
+    }
+  }
+
+  if (argv.header && argv.header.search(changelog.START_OF_LAST_RELEASE_PATTERN) !== -1) {
+    throw Error(`custom changelog header must not match ${changelog.START_OF_LAST_RELEASE_PATTERN}`)
+  }
+
+  /**
+   * If an argument for `packageFiles` provided, we include it as a "default" `bumpFile`.
+   */
+  if (argv.packageFiles) {
+    defaults.bumpFiles = defaults.bumpFiles.concat(argv.packageFiles)
+  }
+
+  const args = Object.assign({}, defaults, argv)
+  let pkg
+  for (const packageFile of args.packageFiles) {
+    const updater = resolveUpdaterObjectFromArgument(packageFile)
+    if (!updater) return
+    const pkgPath = path.resolve(process.cwd(), updater.filename)
+    try {
+      const contents = fs.readFileSync(pkgPath, 'utf8')
+      pkg = {
+        version: updater.updater.readVersion(contents),
+        private: typeof updater.updater.isPrivate === 'function' ? updater.updater.isPrivate(contents) : false
+      }
+      break
+    } catch (err) {}
+  }
+  try {
+    let version
+    if (pkg) {
+      version = pkg.version
+    } else if (args.gitTagFallback) {
+      version = await latestSemverTag(args.tagPrefix)
+    } else {
+      throw new Error('no package file found')
+    }
+
+    const newVersion = await bump(args, version)
+    await changelog(args, newVersion)
+    await commit(args, newVersion)
+    await tag(newVersion, pkg ? pkg.private : false, args)
+  } catch (err) {
+    printError(args, err.message)
+    throw err
+  }
+}

package/node_modules/standard-version/lib/checkpoint.js

@@ -0,0 +1,12 @@
+const chalk = require('chalk')
+const figures = require('figures')
+const util = require('util')
+
+module.exports = function (argv, msg, args, figure) {
+  const defaultFigure = args.dryRun ? chalk.yellow(figures.tick) : chalk.green(figures.tick)
+  if (!argv.silent) {
+    console.info((figure || defaultFigure) + ' ' + util.format.apply(util, [msg].concat(args.map(function (arg) {
+      return chalk.bold(arg)
+    }))))
+  }
+}

package/node_modules/standard-version/lib/configuration.js

@@ -0,0 +1,41 @@
+const path = require('path')
+const findUp = require('find-up')
+const { readFileSync } = require('fs')
+
+const CONFIGURATION_FILES = [
+  '.versionrc',
+  '.versionrc.cjs',
+  '.versionrc.json',
+  '.versionrc.js'
+]
+
+module.exports.getConfiguration = function () {
+  let config = {}
+  const configPath = findUp.sync(CONFIGURATION_FILES)
+  if (!configPath) {
+    return config
+  }
+  const ext = path.extname(configPath)
+  if (ext === '.js' || ext === '.cjs') {
+    const jsConfiguration = require(configPath)
+    if (typeof jsConfiguration === 'function') {
+      config = jsConfiguration()
+    } else {
+      config = jsConfiguration
+    }
+  } else {
+    config = JSON.parse(readFileSync(configPath))
+  }
+
+  /**
+   * @todo we could eventually have deeper validation of the configuration (using `ajv`) and
+   * provide a more helpful error.
+   */
+  if (typeof config !== 'object') {
+    throw Error(
+      `[standard-version] Invalid configuration in ${configPath} provided. Expected an object but found ${typeof config}.`
+    )
+  }
+
+  return config
+}

package/node_modules/standard-version/lib/format-commit-message.js

@@ -0,0 +1,4 @@
+module.exports = function (rawMsg, newVersion) {
+  const message = String(rawMsg)
+  return message.replace(/{{currentTag}}/g, newVersion)
+}

package/node_modules/standard-version/lib/latest-semver-tag.js

@@ -0,0 +1,17 @@
+const gitSemverTags = require('git-semver-tags')
+const semver = require('semver')
+
+module.exports = function (tagPrefix = undefined) {
+  return new Promise((resolve, reject) => {
+    gitSemverTags({ tagPrefix }, function (err, tags) {
+      if (err) return reject(err)
+      else if (!tags.length) return resolve('1.0.0')
+      // Respect tagPrefix
+      tags = tags.map(tag => tag.replace(new RegExp('^' + tagPrefix), ''))
+      // ensure that the largest semver tag is at the head.
+      tags = tags.map(tag => { return semver.clean(tag) })
+      tags.sort(semver.rcompare)
+      return resolve(tags[0])
+    })
+  })
+}

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

@@ -0,0 +1,172 @@
+'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 presetLoader = require('../preset-loader')
+const runLifecycleScript = require('../run-lifecycle-script')
+const semver = require('semver')
+const writeFile = require('../write-file')
+const { resolveUpdaterObjectFromArgument } = require('../updaters')
+let configsToUpdate = {}
+
+async function Bump (args, version) {
+  // reset the cache of updated config files each
+  // time we perform the version bump step.
+  configsToUpdate = {}
+
+  if (args.skip.bump) return version
+  let newVersion = version
+  await runLifecycleScript(args, 'prerelease')
+  const stdout = await runLifecycleScript(args, 'prebump')
+  if (stdout && stdout.trim().length) args.releaseAs = stdout.trim()
+  const release = await bumpVersion(args.releaseAs, version, args)
+  if (!args.firstRelease) {
+    const releaseType = getReleaseType(args.prerelease, release.releaseType, version)
+    newVersion = semver.valid(releaseType) || semver.inc(version, releaseType, args.prerelease)
+    updateConfigs(args, newVersion)
+  } else {
+    checkpoint(args, 'skip version bump on first release', [], chalk.red(figures.cross))
+  }
+  await runLifecycleScript(args, 'postbump')
+  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))
+}
+
+const TypeList = ['major', 'minor', 'patch'].reverse()
+
+/**
+ * extract the in-pre-release type in target version
+ *
+ * @param version
+ * @return {string}
+ */
+function getCurrentActiveType (version) {
+  const typelist = TypeList
+  for (let 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, currentVersion, args) {
+  return new Promise((resolve, reject) => {
+    if (releaseAs) {
+      return resolve({
+        releaseType: releaseAs
+      })
+    } else {
+      const presetOptions = presetLoader(args)
+      if (typeof presetOptions === 'object') {
+        if (semver.lt(currentVersion, '1.0.0')) presetOptions.preMajor = true
+      }
+      conventionalRecommendedBump({
+        debug: args.verbose && console.info.bind(console, 'conventional-recommended-bump'),
+        preset: presetOptions,
+        path: args.path,
+        tagPrefix: args.tagPrefix,
+        lernaPackage: args.lernaPackage
+      }, function (err, release) {
+        if (err) return reject(err)
+        else return resolve(release)
+      })
+    }
+  })
+}
+
+/**
+ * attempt to update the version number in provided `bumpFiles`
+ * @param args config object
+ * @param newVersion version number to update to.
+ * @return void
+ */
+function updateConfigs (args, newVersion) {
+  const dotgit = DotGitignore()
+  args.bumpFiles.forEach(function (bumpFile) {
+    const updater = resolveUpdaterObjectFromArgument(bumpFile)
+    if (!updater) {
+      return
+    }
+    const configPath = path.resolve(process.cwd(), updater.filename)
+    try {
+      if (dotgit.ignore(configPath)) return
+      const stat = fs.lstatSync(configPath)
+
+      if (!stat.isFile()) return
+      const contents = fs.readFileSync(configPath, 'utf8')
+      checkpoint(
+        args,
+        'bumping version in ' + updater.filename + ' from %s to %s',
+        [updater.updater.readVersion(contents), newVersion]
+      )
+      writeFile(
+        args,
+        configPath,
+        updater.updater.writeVersion(contents, newVersion)
+      )
+      // flag any config files that we modify the version # for
+      // as having been updated.
+      configsToUpdate[updater.filename] = true
+    } catch (err) {
+      if (err.code !== 'ENOENT') console.warn(err.message)
+    }
+  })
+}
+
+module.exports = Bump

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

@@ -0,0 +1,66 @@
+const chalk = require('chalk')
+const checkpoint = require('../checkpoint')
+const conventionalChangelog = require('conventional-changelog')
+const fs = require('fs')
+const presetLoader = require('../preset-loader')
+const runLifecycleScript = require('../run-lifecycle-script')
+const writeFile = require('../write-file')
+const START_OF_LAST_RELEASE_PATTERN = /(^#+ \[?[0-9]+\.[0-9]+\.[0-9]+|<a name=)/m
+
+async function Changelog (args, newVersion) {
+  if (args.skip.changelog) return
+  await runLifecycleScript(args, 'prechangelog')
+  await outputChangelog(args, newVersion)
+  await runLifecycleScript(args, 'postchangelog')
+}
+
+Changelog.START_OF_LAST_RELEASE_PATTERN = START_OF_LAST_RELEASE_PATTERN
+
+module.exports = Changelog
+
+function outputChangelog (args, newVersion) {
+  return new Promise((resolve, reject) => {
+    createIfMissing(args)
+    const header = args.header
+
+    let oldContent = args.dryRun ? '' : fs.readFileSync(args.infile, 'utf-8')
+    const oldContentStart = oldContent.search(START_OF_LAST_RELEASE_PATTERN)
+    // find the position of the last release and remove header:
+    if (oldContentStart !== -1) {
+      oldContent = oldContent.substring(oldContentStart)
+    }
+    let content = ''
+    const context = { version: newVersion }
+    const changelogStream = conventionalChangelog({
+      debug: args.verbose && console.info.bind(console, 'conventional-changelog'),
+      preset: presetLoader(args),
+      tagPrefix: args.tagPrefix
+    }, context, { merges: null, path: args.path })
+      .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 {
+    fs.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')
+    }
+  }
+}

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

@@ -0,0 +1,69 @@
+const bump = require('../lifecycles/bump')
+const checkpoint = require('../checkpoint')
+const formatCommitMessage = require('../format-commit-message')
+const path = require('path')
+const runExecFile = require('../run-execFile')
+const runLifecycleScript = require('../run-lifecycle-script')
+
+module.exports = async function (args, newVersion) {
+  if (args.skip.commit) return
+  const message = await runLifecycleScript(args, 'precommit')
+  if (message && message.length) args.releaseCommitMessageFormat = message
+  await execCommit(args, newVersion)
+  await runLifecycleScript(args, 'postcommit')
+}
+
+async function execCommit (args, newVersion) {
+  let msg = 'committing %s'
+  let paths = []
+  const verify = args.verify === false || args.n ? ['--no-verify'] : []
+  const sign = args.sign ? ['-S'] : []
+  const toAdd = []
+
+  // only start with a pre-populated paths list when CHANGELOG processing is not skipped
+  if (!args.skip.changelog) {
+    paths = [args.infile]
+    toAdd.push(args.infile)
+  }
+
+  // commit any of the config files that we've updated
+  // the version # for.
+  Object.keys(bump.getUpdatedConfigs()).forEach(function (p) {
+    paths.unshift(p)
+    toAdd.push(path.relative(process.cwd(), p))
+
+    // account for multiple files in the output message
+    if (paths.length > 1) {
+      msg += ' and %s'
+    }
+  })
+
+  if (args.commitAll) {
+    msg += ' and %s'
+    paths.push('all staged files')
+  }
+
+  checkpoint(args, msg, paths)
+
+  // nothing to do, exit without commit anything
+  if (args.skip.changelog && args.skip.bump && toAdd.length === 0) {
+    return
+  }
+
+  await runExecFile(args, 'git', ['add'].concat(toAdd))
+  await runExecFile(
+    args,
+    'git',
+    [
+      'commit'
+    ].concat(
+      verify,
+      sign,
+      args.commitAll ? [] : toAdd,
+      [
+        '-m',
+        `${formatCommitMessage(args.releaseCommitMessageFormat, newVersion)}`
+      ]
+    )
+  )
+}

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

@@ -0,0 +1,39 @@
+const bump = require('../lifecycles/bump')
+const chalk = require('chalk')
+const checkpoint = require('../checkpoint')
+const figures = require('figures')
+const formatCommitMessage = require('../format-commit-message')
+const runExecFile = require('../run-execFile')
+const runLifecycleScript = require('../run-lifecycle-script')
+
+module.exports = async function (newVersion, pkgPrivate, args) {
+  if (args.skip.tag) return
+  await runLifecycleScript(args, 'pretag')
+  await execTag(newVersion, pkgPrivate, args)
+  await runLifecycleScript(args, 'posttag')
+}
+
+async function execTag (newVersion, pkgPrivate, args) {
+  let tagOption
+  if (args.sign) {
+    tagOption = '-s'
+  } else {
+    tagOption = '-a'
+  }
+  checkpoint(args, 'tagging release %s%s', [args.tagPrefix, newVersion])
+  await runExecFile(args, 'git', ['tag', tagOption, args.tagPrefix + newVersion, '-m', `${formatCommitMessage(args.releaseCommitMessageFormat, newVersion)}`])
+  const currentBranch = await runExecFile('', 'git', ['rev-parse', '--abbrev-ref', 'HEAD'])
+  let message = 'git push --follow-tags origin ' + currentBranch.trim()
+  if (pkgPrivate !== true && bump.getUpdatedConfigs()['package.json']) {
+    message += ' && npm publish'
+    if (args.prerelease !== undefined) {
+      if (args.prerelease === '') {
+        message += ' --tag prerelease'
+      } else {
+        message += ' --tag ' + args.prerelease
+      }
+    }
+  }
+
+  checkpoint(args, 'Run `%s` to publish', [message], chalk.blue(figures.info))
+}

package/node_modules/standard-version/lib/preset-loader.js

@@ -0,0 +1,17 @@
+// TODO: this should be replaced with an object we maintain and
+// describe in: https://github.com/conventional-changelog/conventional-changelog-config-spec
+const spec = require('conventional-changelog-config-spec')
+
+module.exports = (args) => {
+  const defaultPreset = require.resolve('conventional-changelog-conventionalcommits')
+  let preset = args.preset || defaultPreset
+  if (preset === defaultPreset) {
+    preset = {
+      name: defaultPreset
+    }
+    Object.keys(spec.properties).forEach(key => {
+      if (args[key] !== undefined) preset[key] = args[key]
+    })
+  }
+  return preset
+}

package/node_modules/standard-version/lib/print-error.js

@@ -0,0 +1,12 @@
+const chalk = require('chalk')
+
+module.exports = function (args, msg, opts) {
+  if (!args.silent) {
+    opts = Object.assign({
+      level: 'error',
+      color: 'red'
+    }, opts)
+
+    console[opts.level](chalk[opts.color](msg))
+  }
+}

package/node_modules/standard-version/lib/run-exec.js

@@ -0,0 +1,18 @@
+const { promisify } = require('util')
+const printError = require('./print-error')
+
+const exec = promisify(require('child_process').exec)
+
+module.exports = async function (args, cmd) {
+  if (args.dryRun) return
+  try {
+    const { stderr, stdout } = await exec(cmd)
+    // If exec returns content in stderr, but no error, print it as a warning
+    if (stderr) printError(args, stderr, { level: 'warn', color: 'yellow' })
+    return stdout
+  } catch (error) {
+    // If exec returns an error, print it and exit with return code 1
+    printError(args, error.stderr || error.message)
+    throw error
+  }
+}

package/node_modules/standard-version/lib/run-execFile.js

@@ -0,0 +1,18 @@
+const { promisify } = require('util')
+const printError = require('./print-error')
+
+const execFile = promisify(require('child_process').execFile)
+
+module.exports = async function (args, cmd, cmdArgs) {
+  if (args.dryRun) return
+  try {
+    const { stderr, stdout } = await execFile(cmd, cmdArgs)
+    // If execFile returns content in stderr, but no error, print it as a warning
+    if (stderr) printError(args, stderr, { level: 'warn', color: 'yellow' })
+    return stdout
+  } catch (error) {
+    // If execFile returns an error, print it and exit with return code 1
+    printError(args, error.stderr || error.message)
+    throw error
+  }
+}

package/node_modules/standard-version/lib/run-lifecycle-script.js

@@ -0,0 +1,13 @@
+const chalk = require('chalk')
+const checkpoint = require('./checkpoint')
+const figures = require('figures')
+const runExec = require('./run-exec')
+
+module.exports = function (args, hookName) {
+  const scripts = args.scripts
+  if (!scripts || !scripts[hookName]) return Promise.resolve()
+  const command = scripts[hookName]
+  checkpoint(args, 'Running lifecycle script "%s"', [hookName])
+  checkpoint(args, '- execute command: "%s"', [command], chalk.blue(figures.info))
+  return runExec(args, command)
+}

package/node_modules/standard-version/lib/updaters/index.js

@@ -0,0 +1,85 @@
+const path = require('path')
+const JSON_BUMP_FILES = require('../../defaults').bumpFiles
+const updatersByType = {
+  json: require('./types/json'),
+  'plain-text': require('./types/plain-text')
+}
+const PLAIN_TEXT_BUMP_FILES = ['VERSION.txt', 'version.txt']
+
+function getUpdaterByType (type) {
+  const updater = updatersByType[type]
+  if (!updater) {
+    throw Error(`Unable to locate updater for provided type (${type}).`)
+  }
+  return updater
+}
+
+function getUpdaterByFilename (filename) {
+  if (JSON_BUMP_FILES.includes(path.basename(filename))) {
+    return getUpdaterByType('json')
+  }
+  if (PLAIN_TEXT_BUMP_FILES.includes(filename)) {
+    return getUpdaterByType('plain-text')
+  }
+  throw Error(
+    `Unsupported file (${filename}) provided for bumping.\n Please specify the updater \`type\` or use a custom \`updater\`.`
+  )
+}
+
+function getCustomUpdaterFromPath (updater) {
+  if (typeof updater === 'string') {
+    return require(path.resolve(process.cwd(), updater))
+  }
+  if (
+    typeof updater.readVersion === 'function' &&
+    typeof updater.writeVersion === 'function'
+  ) {
+    return updater
+  }
+  throw new Error('Updater must be a string path or an object with readVersion and writeVersion methods')
+}
+
+/**
+ * Simple check to determine if the object provided is a compatible updater.
+ */
+function isValidUpdater (obj) {
+  return (
+    typeof obj.readVersion === 'function' &&
+    typeof obj.writeVersion === 'function'
+  )
+}
+
+module.exports.resolveUpdaterObjectFromArgument = function (arg) {
+  /**
+   * If an Object was not provided, we assume it's the path/filename
+   * of the updater.
+   */
+  let updater = arg
+  if (isValidUpdater(updater)) {
+    return updater
+  }
+  if (typeof updater !== 'object') {
+    updater = {
+      filename: arg
+    }
+  }
+  try {
+    if (typeof updater.updater === 'string') {
+      updater.updater = getCustomUpdaterFromPath(updater.updater)
+    } else if (updater.type) {
+      updater.updater = getUpdaterByType(updater.type)
+    } else {
+      updater.updater = getUpdaterByFilename(updater.filename)
+    }
+  } catch (err) {
+    if (err.code !== 'ENOENT') console.warn(`Unable to obtain updater for: ${JSON.stringify(arg)}\n - Error: ${err.message}\n - Skipping...`)
+  }
+  /**
+   * We weren't able to resolve an updater for the argument.
+   */
+  if (!isValidUpdater(updater.updater)) {
+    return false
+  }
+
+  return updater
+}