@cmflow/cli 0.65.1

package/src/common/cli/yarn.js

@@ -0,0 +1,33 @@
+import { Cli } from './cli'
+
+class YarnCli extends Cli {
+  constructor () {
+    super('yarn')
+  }
+
+  newVersion (version) {
+    return this.version('--no-git-tag-version', '--new-version', version)
+  }
+
+  version (...args) {
+    return this.sync('version', ...args)
+  }
+
+  run (...args) {
+    return super.run(...args)
+  }
+
+  install (...args) {
+    return super.run('add', ...args)
+  }
+
+  /**
+   * Reinstall dependencies without yarn.lock mutation
+   * @returns {Promise<unknown>}
+   */
+  restore () {
+    return super.run('install', '--frozen-lockfile', '--production=false')
+  }
+}
+
+export const yarn = new YarnCli()

package/src/common/cli/yarn.test.js

@@ -0,0 +1,48 @@
+import execa from 'execa'
+import { yarn } from './yarn'
+import { Cli } from './cli'
+
+jest.mock('execa')
+
+execa.sync.mockImplementation((...args) => {
+  return {
+    stdout: `CMD: ${[].concat(...args.filter(arg => typeof arg === 'string' || Array.isArray(arg))).join(' ')}`
+  }
+})
+
+execa.mockReturnValue({})
+
+describe('YarnCli', () => {
+  beforeEach(() => {
+    jest.spyOn(Cli, 'getRaw').mockImplementation((...args) => {
+      return `CMD: ${[].concat(...args.filter(arg => typeof arg === 'string' || Array.isArray(arg))).join(' ')}`
+    })
+  })
+  describe('newVersion', () => {
+    it('should run newVersion cmd', () => {
+      const result = yarn.newVersion('1.0.0')
+
+      expect(result.stdout).toEqual('CMD: yarn version --no-git-tag-version --new-version 1.0.0')
+    })
+  })
+  describe('run', () => {
+    it('should run "run" cmd', async () => {
+      await yarn.run('run-arg')
+
+      expect(execa).toHaveBeenCalledWith('yarn', ['run-arg'], {
+        cwd: process.cwd(),
+        stdio: 'inherit'
+      })
+    })
+  })
+  describe('install', () => {
+    it('should run "install" cmd', async () => {
+      await yarn.install('install-arg')
+
+      expect(execa).toHaveBeenCalledWith('yarn', ['add', 'install-arg'], {
+        cwd: process.cwd(),
+        stdio: 'inherit'
+      })
+    })
+  })
+})

package/src/common/configure-git-workspace.js

@@ -0,0 +1,27 @@
+import { git } from './cli/git'
+
+export function configureGitWorkspace (context) {
+  const {
+    logger,
+    config: {
+      GH_TOKEN,
+      REPOSITORY_URL,
+      ORIGIN,
+      GIT_USER_NAME,
+      GIT_USER_EMAIL
+    }
+  } = context
+
+  if (GIT_USER_NAME && GIT_USER_EMAIL) {
+    git.config('--global', 'user.name', `"${GIT_USER_NAME}"`)
+    git.config('--global', 'user.email', `"${GIT_USER_EMAIL}"`)
+  }
+
+  if (GH_TOKEN) {
+    const repository = REPOSITORY_URL.replace('https://', '')
+
+    logger.info(`Configure remote repository ${repository}`)
+    git.remote('remove', ORIGIN).sync()
+    git.remote('add', ORIGIN, `https://${GH_TOKEN}@${repository}`).sync()
+  }
+}

package/src/common/get-config.js

@@ -0,0 +1,135 @@
+import hasYarn from 'has-yarn'
+import { get } from 'lodash'
+import { git } from './cli/git'
+import { getPackageJson } from './get-package-json'
+
+const toBool = (value) => {
+  if (value === 'false') return false
+  if (value === '0') return false
+
+  return !!value
+}
+
+export function getCI () {
+  const { env } = process
+  const { GIT_USER_NAME, GIT_USER_EMAIL } = env
+  if (env.CI) {
+    if (env.TRAVIS) {
+      const { TRAVIS_BUILD_NUMBER, TRAVIS_COMMIT, TRAVIS_PULL_REQUEST, TRAVIS_BRANCH } = env
+
+      return {
+        CI_NAME: 'Travis CI',
+        USER: GIT_USER_NAME || 'Travis CI',
+        EMAIL: GIT_USER_EMAIL || 'travis@travis-ci.org',
+        BUILD_NUMBER: TRAVIS_BUILD_NUMBER,
+        CI_ORIGIN: 'origin-git',
+        REF_COMMIT: TRAVIS_COMMIT,
+        IS_PULL_REQUEST: TRAVIS_PULL_REQUEST && TRAVIS_PULL_REQUEST !== 'false',
+        BRANCH_NAME: TRAVIS_BRANCH
+      }
+    }
+
+    if (env.GITLAB_CI) {
+      const { CI_BUILD_ID, CI_JOB_ID, CI_COMMIT_SHA, CI_COMMIT_BRANCH } = env
+
+      return {
+        CI_NAME: 'GitLab CI',
+        USER: GIT_USER_NAME || 'GitLab CI',
+        EMAIL: GIT_USER_EMAIL || 'gitlab@gitlab.com',
+        BUILD_NUMBER: CI_BUILD_ID || CI_JOB_ID,
+        CI_ORIGIN: 'origin-git',
+        REF_COMMIT: CI_COMMIT_SHA,
+        IS_PULL_REQUEST: false,
+        BRANCH_NAME: CI_COMMIT_BRANCH
+      }
+    }
+
+    if (env.CIRCLECI) {
+      const { CIRCLE_BUILD_NUM, CIRCLE_SHA1, CIRCLE_PULL_REQUEST, CIRCLE_BRANCH } = env
+      return {
+        CI_NAME: 'Circle CI',
+        USER: GIT_USER_NAME || 'Circle CI',
+        EMAIL: GIT_USER_EMAIL || 'circle@circleci.com',
+        BUILD_NUMBER: CIRCLE_BUILD_NUM,
+        CI_ORIGIN: 'origin-git',
+        REF_COMMIT: CIRCLE_SHA1,
+        IS_PULL_REQUEST: CIRCLE_PULL_REQUEST && CIRCLE_PULL_REQUEST !== 'false',
+        BRANCH_NAME: CIRCLE_BRANCH
+      }
+    }
+    return {
+      NAME: 'Unsupported CI',
+      BUILD_NUMBER: '',
+      CI_ORIGIN: 'origin-git',
+      IS_PULL_REQUEST: false,
+      BRANCH_NAME: git.getBranchName()
+    }
+  }
+  // / local
+  return {
+    NAME: 'LOCAL',
+    BUILD_NUMBER: '1',
+    CI_ORIGIN: 'origin-git',
+    BRANCH_NAME: git.getBranchName()
+  }
+}
+
+export function getConfig () {
+  const pkg = getPackageJson()
+  const [owner, projectName] = pkg.name.replace(/^@/, '').split('/')
+  const {
+    PROJECT_NAME,
+    DOCKER_HUB_ID,
+    DOCKER_HUB_PWD,
+    REF_COMMIT,
+    GH_TOKEN,
+    HEROKU_APP,
+    SKIP_DEPLOY,
+    SKIP_GITHUB_PUBLISH,
+    GITHUB_PAGES_PATH,
+    REPOSITORY_URL,
+    GIT_USER_NAME,
+    GIT_USER_EMAIL
+  } = process.env
+
+  return {
+    PROJECT_NAME: PROJECT_NAME || projectName,
+    HAS_YARN: hasYarn(),
+    HAS_LERNA: pkg.dependencies.lerna || pkg.devDependencies.lerna,
+    HAS_BUILD: pkg.scripts.build,
+    HAS_E2E: pkg.scripts.test_e2e,
+    HAS_BUILD_CHANGELOG: pkg.scripts.build_changelog,
+    get DEPLOY_ON_DOCKER () {
+      return toBool(process.env.DEPLOY_ON_DOCKER) && DOCKER_HUB_ID && DOCKER_HUB_PWD
+    },
+    DEPLOY_ON_HEROKU: !!HEROKU_APP,
+    CI_SKIP: '[ci skip]',
+    RELEASE_CANDIDATE_TAG: '[MEP]',
+    ORIGIN: 'origin',
+    get PRODUCTION_BRANCH () {
+      return process.env.PRODUCTION_BRANCH || 'production'
+    },
+    get DEVELOP_BRANCH () {
+      return process.env.DEVELOP_BRANCH || 'master'
+    },
+    get OWNER () {
+      return process.env.OWNER || owner
+    },
+    get DOCKER_REPOSITORY () {
+      const { DOCKER_REPOSITORY, OWNER, PROJECT_NAME } = process.env
+      return DOCKER_REPOSITORY || `${OWNER || owner}/${PROJECT_NAME || projectName}`
+    },
+    DOCKER_HUB_ID,
+    DOCKER_HUB_PWD,
+    HEROKU_APP,
+    REF_COMMIT,
+    GH_TOKEN,
+    REPOSITORY_URL: get(pkg, 'repository.url', get(pkg, 'repository', REPOSITORY_URL)),
+    SKIP_DEPLOY,
+    SKIP_GITHUB_PUBLISH,
+    GITHUB_PAGES_PATH,
+    GIT_USER_NAME,
+    GIT_USER_EMAIL,
+    ...getCI()
+  }
+}

package/src/common/get-package-json.js

@@ -0,0 +1,7 @@
+import fs from 'fs'
+
+export function getPackageJson () {
+  const content = fs.readFileSync(`${process.cwd()}/package.json`, { encoding: 'utf8' })
+
+  return JSON.parse(content)
+}

package/src/common/get-release-config.js

@@ -0,0 +1,7 @@
+export function getReleaseConfig () {
+  try {
+    return require(`${process.cwd()}/release.config.js`)
+  } catch (er) {
+    return {}
+  }
+}

package/src/common/index.js

@@ -0,0 +1,10 @@
+export * from './cli/cli'
+export * from './cli/docker'
+export * from './cli/git'
+export * from './cli/lerna'
+export * from './cli/npm'
+export * from './cli/yarn'
+export * from './get-config'
+export * from './configure-git-workspace'
+export * from './get-package-json'
+export * from './run-command'

package/src/common/run-command.js

@@ -0,0 +1,61 @@
+import chalk from 'chalk'
+import figures from 'figures'
+import inquirer from 'inquirer'
+import Listr from 'listr'
+import { getReleaseConfig } from './get-release-config'
+import { getConfig } from './get-config'
+
+function createTasksRunner (tasks, ctx) {
+  return new Listr(tasks, {
+    concurrent: false,
+    renderer: !ctx.verbose ? 'default' : 'verbose'
+  }).run(ctx)
+}
+
+export async function runCommand (klass, commander) {
+  try {
+    let context = {
+      ...getReleaseConfig(),
+      ...getConfig(),
+      verbose: commander.verbose
+    }
+
+    // eslint-disable-next-line new-cap
+    const command = new klass()
+
+    // Map context from commander and current context
+    if (command.mapContext) {
+      context = command.mapContext(commander, context)
+    }
+
+    // show prompts
+    if (command.prompt) {
+      context = {
+        ...context,
+        ...await inquirer.prompt(command.prompt(context))
+      }
+    }
+
+    // Verify conditions
+    command.verifyConditions && command.verifyConditions(context)
+
+    // Get tasks
+    const tasks = command.getTasks(context)
+
+    // Run tasks
+    await createTasksRunner(tasks, context)
+
+    command.success && command.success(context)
+  } catch (er) {
+    // eslint-disable-next-line no-console
+    console.error(chalk.red(figures.cross + ' ' + String(er)))
+    if (commander.verbose) {
+      // eslint-disable-next-line no-console
+      console.error(String(er.stack).replace(String(er), ''))
+    }
+  }
+}
+
+process.on('unhandledRejection', (reason, p) => {
+  // avoid extra promise rejection when using toObservable
+})

package/src/common/run-command.test.js

@@ -0,0 +1,63 @@
+import Listr from 'listr'
+import { runCommand } from './run-command'
+
+jest.mock('listr')
+
+describe('runCommand', () => {
+  beforeEach(() => {
+    Listr.mockReturnValue({
+      run () {
+      }
+    })
+  })
+  it('should call runCommand', async () => {
+    class Cmd {
+      mapContext (ctx) {
+        return {
+          ...ctx,
+          test: true
+        }
+      }
+
+      getTasks () {
+        return []
+      }
+    }
+
+    jest.spyOn(Cmd.prototype, 'mapContext')
+    jest.spyOn(Cmd.prototype, 'getTasks')
+
+    await runCommand(Cmd, {
+      prop: '1'
+    })
+
+    expect(Cmd.prototype.mapContext).toHaveBeenCalledWith({ prop: '1' }, expect.any(Object))
+    expect(Cmd.prototype.getTasks).toHaveBeenCalledWith({
+      prop: '1',
+      test: true
+    })
+  })
+  it('should call runCommand and catch error', async () => {
+    class Cmd {
+      mapContext (ctx) {
+        return {
+          ...ctx,
+          test: true
+        }
+      }
+
+      getTasks () {
+        throw new Error('Error')
+      }
+    }
+
+    jest.spyOn(console, 'error').mockReturnValue(undefined)
+
+    await runCommand(Cmd, {
+      prop: '1'
+    })
+
+    // eslint-disable-next-line no-console
+    expect(console.error).toHaveBeenCalled()
+  })
+})

package/src/index.js

@@ -0,0 +1 @@
+module.exports = require('esm')(module)('./main.js')

package/src/main.js

@@ -0,0 +1,10 @@
+import * as commands from './commands'
+
+export * from './workflow'
+export * from './common'
+export * from './commands/release'
+export * from './semantic-release/get-semantic-config'
+
+export {
+  commands
+}

package/src/semantic-release/actions/analyze-commits.js

@@ -0,0 +1,9 @@
+import commitAnalyzerPlugins from '@semantic-release/commit-analyzer'
+
+export function analyzeCommits (pluginConfig, context) {
+  if (context.branch && context.branch.type !== 'prerelease') {
+    return commitAnalyzerPlugins.analyzeCommits(pluginConfig, context)
+  }
+
+  return 'patch' // always trigger patch for prerelease
+}

package/src/semantic-release/actions/fail.js

@@ -0,0 +1,16 @@
+import githubPlugins from '@semantic-release/github'
+import { git } from '../../common'
+
+export async function fail (pluginConfig, context) {
+  if (context.branch && context.branch.type !== 'prerelease') {
+    const { tagFormat, config: { ORIGIN } } = context
+
+    try {
+      // eslint-disable-next-line no-template-curly-in-string
+      await git.push('--delete', ORIGIN, tagFormat.replace('${version}', context.nextRelease.version))
+    } catch (er) {
+    }
+
+    await githubPlugins.fail(pluginConfig, context)
+  }
+}

package/src/semantic-release/actions/generate-notes.js

@@ -0,0 +1,11 @@
+import releaseNotesPlugins from '@semantic-release/release-notes-generator'
+import { npm, yarn } from '../../common'
+
+export async function generateNotes (pluginConfig, context) {
+  if (context.branch.type === 'release' && !context.config.SKIP_GITHUB_PUBLISH) {
+    if (context.config.HAS_BUILD_CHANGELOG) {
+      await (context.config.HAS_YARN ? yarn : npm).run('build_changelog')
+    }
+    return releaseNotesPlugins.generateNotes(pluginConfig, context)
+  }
+}

package/src/semantic-release/actions/index.js

@@ -0,0 +1,8 @@
+export * from './verify-conditions'
+export * from './analyze-commits'
+export * from './verify-release'
+export * from './generate-notes'
+export * from './prepare'
+export * from './publish'
+export * from './success'
+export * from './fail'

package/src/semantic-release/actions/prepare.js

@@ -0,0 +1,101 @@
+import { dockerPublish } from '../utils/docker-publish'
+import { git, lerna, npm, yarn, configureGitWorkspace } from '../../common'
+
+async function gitMep (context) {
+  const { logger, branch, config: { PRODUCTION_BRANCH, ORIGIN } } = context
+
+  logger.info(`Branch ${branch.name} is candidate to MEP`)
+
+  git.reset('--hard')
+  git.clean('-f', '-d').sync()
+
+  logger.start('Checkout production branch')
+
+  git.config('--replace-all', 'remote.origin.fetch', '+refs/heads/*:refs/remotes/origin/*')
+  git.fetch().sync()
+  git.fetch('--tags').sync()
+  git.checkout('-qf', PRODUCTION_BRANCH).sync()
+
+  logger.success(`Current branch: ${PRODUCTION_BRANCH}`)
+
+  const building = git.getLastCommitMsg()
+  logger.info('Last commit message on production', building)
+
+  logger.start(`Merge ${branch.name} into ${PRODUCTION_BRANCH} branch`)
+  git.merge('--no-ff', '-m', `${branch.name}`, branch.name)
+  logger.success(`${branch.name} merged into ${PRODUCTION_BRANCH} branch`)
+
+  configureGitWorkspace(context)
+
+  logger.start(`Push ${PRODUCTION_BRANCH} branch`)
+  await git.push(ORIGIN, PRODUCTION_BRANCH)
+  logger.success(`${PRODUCTION_BRANCH} branch pushed`)
+
+  logger.start(`Remove ${ORIGIN}/${branch.name} branch`)
+  await git.push(ORIGIN, ':' + branch.name)
+  logger.success(`${ORIGIN}/${branch.name} branch correctly removed`)
+}
+
+async function gitPrepareRelease (pluginConfig, context) {
+  const { logger, config: { CI_NAME, BUILD_NUMBER } } = context
+
+  logger.info('Adding files to commit')
+  git.add('-A').sync()
+
+  logger.info('Get commit stage status')
+  git.status()
+
+  const revisionMessage = `${CI_NAME} build: ${context.branch.name} ${BUILD_NUMBER} ${context.nextRelease.gitTag} [ci skip]`
+
+  logger.info('Commit changes with revision message: ')
+  logger.info(revisionMessage)
+
+  git.commit('-m', revisionMessage).sync()
+
+  logger.success('Change committed')
+}
+
+export async function prepare (pluginConfig, context) {
+  const { branch, config: { RELEASE_CANDIDATE_TAG, HAS_BUILD, HAS_E2E, SKIP_DEPLOY, SKIP_GITHUB_PUBLISH }, logger } = context
+  const pkgManager = context.config.HAS_YARN ? yarn : npm
+
+  pkgManager.newVersion(context.nextRelease.version)
+
+  if (context.config.HAS_LERNA) { // support project based on lerna
+    await lerna.newVersion(context.nextRelease.version)
+  }
+
+  if (HAS_BUILD && !SKIP_DEPLOY) {
+    logger.info('Start build task')
+    await pkgManager.run('build')
+    logger.info('Build task finished with success...')
+  }
+
+  if (HAS_E2E && !SKIP_DEPLOY) {
+    logger.info('Start test_e2e task')
+    await pkgManager.run('test_e2e')
+    logger.info('test_e2e task finished with success...')
+  }
+
+  if (!SKIP_GITHUB_PUBLISH) {
+    if (branch.type === 'release') {
+      logger.info('Prepare release')
+      configureGitWorkspace(context)
+      return gitPrepareRelease(pluginConfig, context)
+    }
+
+    const lastCommitMessage = git.getLastCommitMsg()
+
+    logger.info('Last commit message:', lastCommitMessage)
+    if (lastCommitMessage.includes(RELEASE_CANDIDATE_TAG)) {
+      await gitMep(context)
+      process.exit(0)
+    }
+  }
+
+  if (!SKIP_DEPLOY) {
+    await dockerPublish(context)
+  }
+  // avoid next semantic-release steps when is a prerelease or release branch with SKIP_GITHUB_PUBLISH
+  process.exit(0)
+}

package/src/semantic-release/actions/publish.js

@@ -0,0 +1,17 @@
+import githubPlugins from '@semantic-release/github'
+import { dockerPublish } from '../utils/docker-publish'
+import { ghPagesPublish } from '../utils/ghpages-publish'
+
+export async function publish (pluginConfig, context) {
+  const { branch, env: { SKIP_GITHUB_PUBLISH, GITHUB_PAGES_PATH } } = context
+
+  if (!SKIP_GITHUB_PUBLISH && branch.type === 'release') {
+    await githubPlugins.publish(pluginConfig, context)
+  }
+
+  if (GITHUB_PAGES_PATH && branch.type === 'release') {
+    await ghPagesPublish(context)
+  }
+
+  await dockerPublish(context)
+}

package/src/semantic-release/actions/success.js

@@ -0,0 +1,30 @@
+import githubPlugins from '@semantic-release/github'
+import { dockerCleanTags } from '../utils/docker-clean-tags'
+import { git } from '../../common'
+
+async function githubSuccess (pluginConfig, context) {
+  const { logger, config: { PRODUCTION_BRANCH, ORIGIN, DEVELOP_BRANCH } } = context
+  await git.push('--quiet', '--set-upstream', ORIGIN, PRODUCTION_BRANCH)
+
+  if (PRODUCTION_BRANCH !== DEVELOP_BRANCH) {
+    logger.start(`Reset HEAD of ${ORIGIN}/${DEVELOP_BRANCH} branch to HEAD of  ${ORIGIN}/${PRODUCTION_BRANCH} `)
+    await git.push('-f', ORIGIN, `refs/remotes/${ORIGIN}/${PRODUCTION_BRANCH}:refs/heads/${DEVELOP_BRANCH}`)
+    logger.success(`${ORIGIN}/${DEVELOP_BRANCH} branch correctly updated`)
+  }
+
+  await githubPlugins.success(pluginConfig, context)
+}
+
+export async function success (pluginConfig, context) {
+  const { branch, config: { SKIP_GITHUB_PUBLISH } } = context
+
+  if (branch.type !== 'prerelease' && !SKIP_GITHUB_PUBLISH) {
+    await githubSuccess(pluginConfig, context)
+  }
+
+  try {
+    await dockerCleanTags(context)
+  } catch (er) {
+    context.logger.warn(er)
+  }
+}

package/src/semantic-release/actions/verify-conditions.js

@@ -0,0 +1,30 @@
+import chalk from 'chalk'
+import githubPlugins from '@semantic-release/github'
+import { git } from '../../common'
+
+export function verifyConditions (pluginConfig, context) {
+  if (pluginConfig.dryRun) {
+    return
+  }
+
+  const { branch, config: { USER, EMAIL, ORIGIN } } = context
+
+  if (USER && EMAIL) {
+    context.logger.info('Configure git with username')
+
+    git.config('--global', 'user.name', USER)
+    git.config('--global', 'user.email', EMAIL)
+
+    context.logger.info('Configure git branch')
+    context.logger.success('Workspace is correctly configured')
+  } else {
+    context.logger.error(chalk.red('Ignore git configuration (Empty GIT_USER_EMAIL or/and GIT_USER_NAME variables)'))
+    process.exit(1)
+  }
+
+  git.fetch().sync()
+  git.checkout(branch.name).sync()
+  git.branch(`--set-upstream-to=${ORIGIN}/${branch.name}`, branch.name).sync()
+
+  return githubPlugins.verifyConditions(pluginConfig, context)
+}

package/src/semantic-release/actions/verify-release.js

@@ -0,0 +1,7 @@
+import { displayPackageInfo } from '../utils/display-package-info'
+import { displayReleaseInfo } from '../utils/display-release-info'
+
+export function verifyRelease (pluginConfig, context) {
+  displayPackageInfo(context)
+  displayReleaseInfo(context)
+}