@cmflow/cli 0.65.1

package/src/commands/prompts/branches.js

@@ -0,0 +1,38 @@
+import inquirer from 'inquirer'
+import { git } from '../../common'
+
+function toRemote (branch, origin) {
+  branch = branch.replace(`${origin}/`)
+  return `${origin}/${branch}`
+}
+
+export function branches ({ fromBranch, origin, PRODUCTION_BRANCH, DEVELOP_BRANCH, message = 'Start your branch from:' }) {
+  const currentBranch = git.getBranchName()
+  const originDevelop = `${origin}/${DEVELOP_BRANCH}`
+  const originProduction = `${origin}/${PRODUCTION_BRANCH}`
+
+  let startFromBranches = [
+    originProduction
+  ]
+
+  if (startFromBranches.indexOf(toRemote(currentBranch, origin)) === -1 && git.branchExists(currentBranch, origin)) {
+    startFromBranches = startFromBranches.concat(toRemote(currentBranch, origin))
+  }
+
+  const remoteBranches = git.branchesInfos('-r')
+    .map(info => info.branch)
+    .filter(name => !startFromBranches.includes(name) && ![originDevelop, originProduction].includes(name))
+
+  if (remoteBranches.length) {
+    startFromBranches = startFromBranches.concat(new inquirer.Separator(), remoteBranches)
+  }
+
+  return {
+    type: 'list',
+    name: 'fromBranch',
+    message,
+    default: startFromBranches.indexOf(fromBranch || originProduction),
+    choices: startFromBranches,
+    when: !fromBranch || currentBranch !== DEVELOP_BRANCH
+  }
+}

package/src/commands/publish-pages.js

@@ -0,0 +1,29 @@
+import chalk from 'chalk'
+import figures from 'figures'
+import { ghPagesPublish } from '../semantic-release/utils/ghpages-publish'
+
+export class PublishPages {
+  mapContext (commander, context) {
+    return {
+      ...context
+    }
+  }
+
+  prompt (context) {
+    return []
+  }
+
+  getTasks (context) {
+    return [
+      {
+        title: 'Publish github pages',
+        task: () => ghPagesPublish(context)
+      }
+    ]
+  }
+
+  success (context) {
+    // eslint-disable-next-line no-console
+    console.log(chalk.green(figures.tick), 'Github pages deployed')
+  }
+}

package/src/commands/push.js

@@ -0,0 +1,26 @@
+import chalk from 'chalk'
+import figures from 'figures'
+import { Rebase } from './rebase'
+import { pushBranch } from './tasks/push-branch'
+
+export class Push extends Rebase {
+  mapContext (commander, context) {
+    return {
+      ...super.mapContext(commander, context),
+      force: !!commander.force,
+      checkStatus: true
+    }
+  }
+
+  getTasks (context) {
+    return [
+      ...super.getTasks(context),
+      pushBranch(context)
+    ]
+  }
+
+  success (context) {
+    // eslint-disable-next-line no-console
+    console.log(chalk.green(figures.tick), 'Branch', chalk.green(context.featureBranch), 'rebased and pushed.')
+  }
+}

package/src/commands/rebase.js

@@ -0,0 +1,38 @@
+import chalk from 'chalk'
+import figures from 'figures'
+import { Fetch } from './fetch'
+import { git } from '../common/cli/git'
+import { updateBranch } from './tasks/update-branch'
+import { updateDependencies } from './tasks/update-dependencies'
+import { runTest } from './tasks/run-test'
+
+export class Rebase extends Fetch {
+  mapContext (commander, context) {
+    return {
+      ...context,
+      useYarn: context.HAS_YARN,
+      origin: context.ORIGIN,
+      featureBranch: git.getBranchName(),
+      fromBranch: context.PRODUCTION_BRANCH,
+      checkStatus: commander.force === undefined ? true : !!commander.force,
+      rebase: true,
+      skipTest: !commander.cucumber && !commander.unitTest,
+      skipUnit: !commander.unitTest,
+      skipE2E: context.HAS_E2E ? !commander.cucumber : true
+    }
+  }
+
+  getTasks (context) {
+    return [
+      ...super.getTasks(context),
+      updateBranch(context),
+      updateDependencies(context),
+      ...runTest(context)
+    ]
+  }
+
+  success (context) {
+    // eslint-disable-next-line no-console
+    console.log(chalk.green(figures.tick), `Branch ${chalk.green(context.featureBranch)} rebased from ${chalk.green(context.fromBranch)} HEAD`)
+  }
+}

package/src/commands/release.js

@@ -0,0 +1,36 @@
+const getConfig = require('semantic-release/lib/get-config')
+const getNextVersion = require('semantic-release/lib/get-next-version')
+const { calculateSnapshotVersion } = require('../semantic-release/utils/calculate-snapshot-version')
+
+require.cache[require.resolve('semantic-release/lib/get-config')].exports = async (context, cliOptions) => {
+  context.config = require('../common/get-config').getConfig()
+
+  return getConfig(context, cliOptions)
+}
+
+require.cache[require.resolve('semantic-release/lib/get-next-version')].exports = (context) => {
+  if (context.branch.type === 'prerelease') {
+    return calculateSnapshotVersion(context)
+  }
+
+  return getNextVersion(context)
+}
+
+delete process.env.CIRCLE_PR_NUMBER
+delete process.env.CIRCLE_PULL_REQUEST
+delete process.env.CI_PULL_REQUEST
+
+export function release (options = {}) {
+  require('semantic-release')({
+    dryRun: process.argv.includes('--dry-run'),
+    ci: false,
+    noCi: true,
+    ...options
+  })
+    .then((exitCode) => {
+      process.exitCode = exitCode
+    })
+    .catch(() => {
+      process.exitCode = 1
+    })
+}

package/src/commands/republish.js

@@ -0,0 +1,24 @@
+import chalk from 'chalk'
+import figures from 'figures'
+import { Fetch } from './fetch'
+import { rebaseAllBranches } from './tasks/rebase-all-branches'
+
+export class Republish extends Fetch {
+  mapContext (commander, context) {
+    return {
+      ...super.mapContext(commander, context)
+    }
+  }
+
+  getTasks (context) {
+    return [
+      ...super.getTasks(context),
+      rebaseAllBranches(context)
+    ]
+  }
+
+  success (context) {
+    // eslint-disable-next-line no-console
+    console.log(chalk.green(figures.tick), 'All branches rebased and pushed.')
+  }
+}

package/src/commands/start.js

@@ -0,0 +1,82 @@
+import chalk from 'chalk'
+import figures from 'figures'
+import { git } from '../common/cli/git'
+import { branches } from './prompts/branches'
+import { Fetch } from './fetch'
+
+import { updateDependencies } from './tasks/update-dependencies'
+import { WORKFLOW_CONFIGURATION } from '../workflow'
+
+function sanitize (name) {
+  return name.replace(/[/\\_|. ]/gi, '-').split('-').filter(Boolean).join('-')
+}
+
+export class Start extends Fetch {
+  mapContext (options, context) {
+    options.branchName = options.branchName || ''
+    const type = WORKFLOW_CONFIGURATION
+      .map(({ type }) => type)
+      .find((t) => options.branchName.startsWith(`${t}-`))
+
+    return {
+      ...context,
+      useYarn: context.HAS_YARN,
+      origin: context.ORIGIN,
+      branchName: options.branchName,
+      type
+    }
+  }
+
+  prompt (context) {
+    return [
+      {
+        type: 'list',
+        name: 'type',
+        message: 'Choose the type of your branch:',
+        choices: ['fix', 'feat', 'chore', 'docs', 'tech'],
+        default: context.type,
+        when: !context.type
+      },
+      {
+        type: 'input',
+        name: 'branchName',
+        message: 'What is the branch name ?',
+        validate (branch) {
+          if (!branch.length) {
+            return 'Branch name is required'
+          }
+
+          if (git.branchExists(branch, context.origin)) {
+            return `${branch} already exists`
+          }
+
+          return true
+        },
+
+        when: !context.branchName
+      },
+
+      branches(context)
+    ]
+  }
+
+  getTasks (context) {
+    context.branchName = sanitize(context.branchName)
+    context.featureBranch = context.branchName.includes(context.type + '-') ? context.branchName : `${context.type}-${context.branchName}`
+    context.fromBranch = context.fromBranch || context.PRODUCTION_BRANCH
+
+    return [
+      ...super.getTasks(context),
+      {
+        title: `Create branch from ${chalk.green(context.fromBranch)}`,
+        task: () => git.checkout('--no-track', '-b', context.featureBranch, context.fromBranch).toObservable()
+      },
+      updateDependencies(context)
+    ]
+  }
+
+  success (context) {
+    // eslint-disable-next-line no-console
+    console.log(chalk.green(figures.tick), `New branch ${chalk.green(context.featureBranch)} created from ${chalk.green(context.fromBranch)} HEAD`)
+  }
+}

package/src/commands/tasks/push-branch.js

@@ -0,0 +1,16 @@
+import { git } from '../../common/cli/git'
+
+export function pushBranch ({ origin = 'origin', featureBranch, upstream = true, noVerify = true }) {
+  return ({
+    title: `Push ${featureBranch}`,
+    task: () => {
+      return git.push(...[
+        upstream ? '-u' : '',
+        '-f',
+        origin,
+        featureBranch,
+        noVerify ? '--no-verify' : ''
+      ].filter(Boolean)).toObservable()
+    }
+  })
+}

package/src/commands/tasks/rebase-all-branches.js

@@ -0,0 +1,34 @@
+import { git } from '../../common/cli/git'
+
+export function rebaseAllBranches (context) {
+  const { origin = 'origin', upstream = true, noVerify = true } = context
+  return ({
+    title: 'Rebase all branches',
+    task: async () => {
+      const remoteBranches = git.branches('-r')
+        .filter(b => !new RegExp(`${context.PRODUCTION_BRANCH}|${context.DEVELOP_BRANCH}`).test(b))
+      for (const remoteBranch of remoteBranches) {
+        const branch = remoteBranch.split('/')[1]
+        try {
+          await git.branch('-D', branch)
+        } catch (e) {}
+        try {
+          await git.checkout('--track', remoteBranch)
+          await git.rebase(`${origin}/${context.PRODUCTION_BRANCH}`)
+          await git.push(...[
+            upstream ? '-u' : '',
+            '-f',
+            origin,
+            branch,
+            noVerify ? '--no-verify' : ''
+          ].filter(Boolean))
+        } catch (e) {
+          try {
+            await git.rebase('--abort')
+            await git.reset('--hard')
+          } catch (e) {}
+        }
+      }
+    }
+  })
+}

package/src/commands/tasks/refresh-repository.js

@@ -0,0 +1,33 @@
+import { EMPTY } from 'rxjs'
+import { catchError } from 'rxjs/operators'
+import Listr from 'listr'
+import { git } from '../../common'
+
+function pipe (observable, output) {
+  observable.pipe(catchError((err) => {
+    output.push(err)
+    return EMPTY
+  }))
+
+  observable.subscribe(result => {
+    output.push(result)
+  })
+
+  return observable
+}
+
+export function refreshRepository (context) {
+  const {
+    output = []
+  } = context
+
+  return {
+    title: 'Refresh local repository',
+    task: () => new Listr([
+      {
+        title: 'Git fetch',
+        task: () => pipe(git.fetch('--prune').toObservable(), output)
+      }
+    ])
+  }
+}

package/src/commands/tasks/run-test.js

@@ -0,0 +1,23 @@
+import { git, npm, yarn } from '../../common'
+
+export const runTest = ({ useYarn, skipTest, skipUnit, skipE2E }) => {
+  const manager = useYarn ? yarn : npm
+
+  return [
+    {
+      title: 'Unit test',
+      skip: () => skipTest || skipUnit,
+      task: () => manager.run('test')
+    },
+    {
+      title: 'E2E test',
+      skip: () => skipTest || skipE2E,
+      task: () => manager.run('test_e2e')
+    },
+    {
+      title: 'Reset changes',
+      skip: () => skipTest,
+      task: () => git.reset('--hard') // reset files updated unit test
+    }
+  ]
+}

package/src/commands/tasks/update-branch.js

@@ -0,0 +1,40 @@
+import chalk from 'chalk'
+import Listr from 'listr'
+import { git } from '../../common/cli/git'
+
+async function checkBranchRemoteStatus ({ featureBranch, origin, force }) {
+  const isBranchExists = git.branchExists(featureBranch, origin)
+
+  if (isBranchExists && !force) {
+    const result = git.checkBranchRemoteStatus(featureBranch)
+
+    if (result) {
+      throw new Error('Remote branch changed, check diff before continue')
+    }
+  }
+}
+
+export const updateBranch = ({ origin, featureBranch, fromBranch, force, checkStatus = true, rebase = true }) => {
+  return ({
+    title: 'Rebase branch',
+    task: () => new Listr(
+      [
+        {
+          title: 'Check status',
+          enabled: () => checkStatus,
+          task: () => checkBranchRemoteStatus({
+            force,
+            featureBranch,
+            origin
+          })
+        },
+        {
+          title: `Rebase from ${origin}/${chalk.green(fromBranch)}`,
+          enabled: () => rebase,
+          task: () => git.rebase(`${origin}/${fromBranch}`).toObservable()
+        }
+      ],
+      { concurrent: false }
+    )
+  })
+}

package/src/commands/tasks/update-dependencies.js

@@ -0,0 +1,37 @@
+import { npm, yarn } from '../../common'
+import { refreshMetadata, shouldReinstall } from '../utils/check-install'
+import Listr from 'listr'
+import { catchError } from 'rxjs/operators'
+
+export const updateDependencies = ({ useYarn }) => {
+  const manager = useYarn ? yarn : npm
+  const reinstall = shouldReinstall()
+
+  return ({
+    title: 'Install',
+    enabled: () => reinstall,
+    task: () => new Listr(
+      [
+        {
+          title: `Restore dependencies using ${useYarn ? 'Yarn' : 'Npm'}`,
+          task: () => manager.restore()
+            .toObservable()
+            .pipe(catchError(error => {
+              if (useYarn) {
+                if (error.stderr.startsWith('error Your lockfile needs to be updated')) {
+                  throw new Error('yarn.lock file is outdated. Run yarn, commit the updated lockfile and try again.')
+                }
+              }
+
+              throw error
+            }))
+        },
+        {
+          title: 'Refresh metadata',
+          task: () => refreshMetadata()
+        }
+      ],
+      { concurrency: false }
+    )
+  })
+}

package/src/commands/utils/check-install.js

@@ -0,0 +1,31 @@
+import isEqual from 'lodash/isEqual'
+import { getPackageJson } from '../../common/get-package-json'
+import { git } from '../../common'
+
+function getDeps () {
+  const pkg = getPackageJson()
+  return {
+    dependencies: pkg.dependencies,
+    devDependencies: pkg.devDependencies
+  }
+}
+
+export function getHash () {
+  return Buffer.from(JSON.stringify(getDeps())).toString('base64')
+}
+
+export function getDepsFromHash () {
+  try {
+    return JSON.parse(Buffer.from(git.config('--local', 'npm.hash'), 'base64').toString('utf8'))
+  } catch (er) {
+    return ''
+  }
+}
+
+export function shouldReinstall () {
+  return !isEqual(getDeps(), getDepsFromHash())
+}
+
+export function refreshMetadata () {
+  git.config('--local', 'npm.hash', `${getHash()}`)
+}

package/src/common/cli/cli.js

@@ -0,0 +1,107 @@
+import 'any-observable/register/rxjs-all' // eslint-disable-line import/no-unassigned-import
+import execa from 'execa'
+import streamToObservable from '@samverschueren/stream-to-observable'
+import { filter, merge } from 'rxjs/operators'
+import split from 'split'
+import { spawnSync } from 'child_process'
+
+export class Cli {
+  constructor (cmd) {
+    this.cmd = cmd
+  }
+
+  sync (...args) {
+    return Cli.run(this.cmd, args).sync()
+  }
+
+  run (...args) {
+    return Cli.run(this.cmd, args)
+  }
+
+  get (...args) {
+    return Cli.run(this.cmd, args).get()
+  }
+
+  static run (cmd, args = [], options = {}) {
+    const run = (opt = {}) => {
+      return execa(cmd, args, {
+        cwd: process.cwd(),
+        ...opt,
+        ...options
+      })
+    }
+
+    let isPromise = true
+
+    const promise = new Promise((resolve, reject) => {
+      setTimeout(async () => {
+        if (isPromise) {
+          try {
+            const result = await run({
+              stdio: 'inherit'
+            })
+
+            resolve(result)
+          } catch (err) {
+            // eslint-disable-next-line no-console
+            reject(err)
+          }
+        } else {
+          resolve()
+        }
+      }, 10)
+    })
+
+    promise.toObservable = (opt) => {
+      isPromise = false
+      const cp = run(opt)
+      const stdout = streamToObservable(cp.stdout.pipe(split()), { await: cp })
+      const stderr = streamToObservable(cp.stderr.pipe(split()), { await: cp })
+
+      return stdout.pipe(merge(stderr)).pipe(filter(Boolean))
+    }
+
+    promise.toStream = (opt) => {
+      isPromise = false
+
+      return run(opt)
+    }
+
+    promise.cwd = (cwd) => {
+      options.cwd = cwd
+      return promise
+    }
+
+    promise.sync = (opt) => {
+      isPromise = false
+
+      return execa.sync(cmd, args, {
+        cwd: process.cwd(),
+        stdio: 'inherit',
+        ...options,
+        ...opt
+      })
+    }
+
+    promise.getRaw = (opt) => {
+      isPromise = false
+      return Cli.getRaw(cmd, args, {
+        cwd: process.cwd(),
+        ...options,
+        ...opt
+      })
+    }
+
+    promise.get = promise.getRaw
+
+    return promise
+  }
+
+  static getRaw (cmd, args, options) {
+    return spawnSync(cmd, args, options)
+      .output.filter(o => !!o)
+      .map(o => o.toString())
+      .join('\n')
+      .trim()
+  }
+}

package/src/common/cli/docker.js

@@ -0,0 +1,63 @@
+import axios from 'axios'
+import { Cli } from './cli'
+
+class DockerCli extends Cli {
+  constructor () {
+    super('docker')
+  }
+
+  tag (...args) {
+    return this.get('tag', ...args)
+  }
+
+  login (...args) {
+    return this.sync('login', ...args)
+  }
+
+  push (...args) {
+    return this.run('push', ...args)
+  }
+
+  async getToken (username, password) {
+    const { data: { token } } = await axios({
+      method: 'POST',
+      url: 'https://hub.docker.com/v2/users/login/',
+      headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/json'
+      },
+      data: {
+        username,
+        password
+      }
+    })
+
+    return token
+  }
+
+  async getTags ({ token, repository }) {
+    const { data } = await axios({
+      method: 'GET',
+      url: `https://hub.docker.com/v2/repositories/${repository}/tags/?page=1&page_size=500`,
+      headers: {
+        Accept: 'application/json',
+        Authorization: `JWT ${token}`
+      }
+    })
+
+    return data.results
+  }
+
+  async deleteTag (tag, { token, repository }) {
+    await axios({
+      method: 'DELETE',
+      url: `https://hub.docker.com/v2/repositories/${repository}/tags/${tag}/`,
+      headers: {
+        Accept: 'application/json',
+        Authorization: `JWT ${token}`
+      }
+    })
+  }
+}
+
+export const docker = new DockerCli()