refactor: Simplify file tree

lib/debug.js

@@ -0,0 +1,9 @@
+function debugShell(message, shell, debug) {
+  debug(message);
+  debug('cmd: %O', shell.cmd);
+  debug('stdout: %O', shell.stdout);
+  debug('stderr: %O', shell.stderr);
+  debug('code: %O', shell.code);
+}
+
+module.exports = {debugShell};

lib/get-commits.js

@@ -0,0 +1,109 @@
+const execa = require('execa');
+const gitLogParser = require('git-log-parser');
+const getStream = require('get-stream');
+const debug = require('debug')('semantic-release:get-commits');
+const getVersionHead = require('./get-version-head');
+const {debugShell} = require('./debug');
+const logger = require('./logger');
+
+/**
+ * Commit message.
+ *
+ * @typedef {Object} Commit
+ * @property {string} hash The commit hash.
+ * @property {string} message The commit message.
+ */
+
+/**
+ * Last release.
+ *
+ * @typedef {Object} LastRelease
+ * @property {string} version The version number of the last release.
+ * @property {string} [gitHead] The commit sha used to make the last release.
+ */
+
+/**
+ * Result object.
+ *
+ * @typedef {Object} Result
+ * @property {Array<Commit>} commits The list of commits since the last release.
+ * @property {LastRelease} lastRelease The updated lastRelease.
+ */
+
+/**
+ * Retrieve the list of commits on the current branch since the last released version, or all the commits of the current branch if there is no last released version.
+ *
+ * The commit correspoding to the last released version is determined as follow:
+ * - Use `lastRelease.gitHead` if defined and present in `branch` history.
+ * - If `lastRelease.gitHead` is not in the `branch` history, unshallow the repository and try again.
+ * - If `lastRelease.gitHead` is still not in the `branch` history, search for a tag named `v<version>` or `<version>` and verify if it's associated commit sha is present in `branch` history.
+ *
+ * @param {LastRelease} lastRelease The lastRelease object obtained from the getLastRelease plugin.
+ * @param {string} branch The branch to release from.
+ * @param {Object} logger Global logger.
+ *
+ * @return {Promise<Result>} The list of commits on the branch `branch` since the last release and the updated lastRelease with the gitHead used to retrieve the commits.
+ *
+ * @throws {SemanticReleaseError} with code `ENOTINHISTORY` if `lastRelease.gitHead` or the commit sha derived from `config.lastRelease.version` is not in the direct history of `branch`.
+ * @throws {SemanticReleaseError} with code `ENOGITHEAD` if `lastRelease.gitHead` is undefined and no commit sha can be found for the `config.lastRelease.version`.
+ */
+module.exports = async ({version, gitHead}, branch) => {
+  if (gitHead || version) {
+    try {
+      gitHead = await getVersionHead(gitHead, version, branch);
+    } catch (err) {
+      if (err.code === 'ENOTINHISTORY') {
+        logger.error(notInHistoryMessage(err.gitHead, branch, version));
+      } else {
+        logger.error(noGitHeadMessage(branch, version));
+      }
+      throw err;
+    }
+    logger.log('Retrieving commits since %s, corresponding to version %s', gitHead, version);
+  } else {
+    logger.log('No previous release found, retrieving all commits');
+    // If there is no gitHead nor a version, there is no previous release. Unshallow the repo in order to retrieve all commits
+    const shell = await execa('git', ['fetch', '--unshallow', '--tags'], {reject: false});
+    debugShell('Unshallow repo', shell, debug);
+  }
+
+  Object.assign(gitLogParser.fields, {hash: 'H', message: 'B', gitTags: 'd', committerDate: {key: 'ci', type: Date}});
+  const commits = (await getStream.array(gitLogParser.parse({_: `${gitHead ? gitHead + '..' : ''}HEAD`}))).map(
+    commit => {
+      commit.message = commit.message.trim();
+      commit.gitTags = commit.gitTags.trim();
+      return commit;
+    }
+  );
+  logger.log('Found %s commits since last release', commits.length);
+  debug('Parsed commits: %o', commits);
+  return {commits, lastRelease: {version, gitHead}};
+};
+
+function noGitHeadMessage(branch, version) {
+  return `The commit the last release of this package was derived from cannot be determined from the release metadata nor from the repository tags.
+This means semantic-release can not extract the commits between now and then.
+This is usually caused by releasing from outside the repository directory or with innaccessible git metadata.
+
+You can recover from this error by creating a tag for the version "${
+    version
+  }" on the commit corresponding to this release:
+$ git tag -f v${version} <commit sha1 corresponding to last release>
+$ git push -f --tags origin ${branch}
+`;
+}
+
+function notInHistoryMessage(gitHead, branch, version) {
+  return `The commit the last release of this package was derived from is not in the direct history of the "${
+    branch
+  }" branch.
+This means semantic-release can not extract the commits between now and then.
+This is usually caused by force pushing, releasing from an unrelated branch, or using an already existing package name.
+
+You can recover from this error by restoring the commit "${gitHead}" or by creating a tag for the version "${
+    version
+  }" on the commit corresponding to this release:
+$ git tag -f v${version || '<version>'} <commit sha1 corresponding to last release>
+$ git push -f --tags origin ${branch}
+`;
+}

lib/get-config.js

@@ -0,0 +1,43 @@
+const url = require('url');
+const {readJson} = require('fs-extra');
+const {defaults} = require('lodash');
+const npmConf = require('npm-conf');
+const normalizeData = require('normalize-package-data');
+const debug = require('debug')('semantic-release:config');
+const logger = require('./logger');
+const getPlugins = require('./plugins');
+const getRegistry = require('./get-registry');
+
+module.exports = async opts => {
+  const pkg = await readJson('./package.json');
+  const {GH_TOKEN, GITHUB_TOKEN, GH_URL} = process.env;
+  normalizeData(pkg);
+  const options = defaults(opts, pkg.release, {
+    branch: 'master',
+    fallbackTags: {next: 'latest'},
+    githubToken: GH_TOKEN || GITHUB_TOKEN,
+    githubUrl: GH_URL,
+  });
+  debug('branch: %O', options.branch);
+  debug('fallbackTags: %O', options.fallbackTags);
+  debug('analyzeCommits: %O', options.analyzeCommits);
+  debug('generateNotes: %O', options.generateNotes);
+  debug('verifyConditions: %O', options.verifyConditions);
+  debug('verifyRelease: %O', options.verifyRelease);
+
+  const plugins = await getPlugins(options);
+  const conf = npmConf();
+  const npm = {
+    auth: {token: process.env.NPM_TOKEN},
+    registry: getRegistry(pkg, conf),
+    tag: (pkg.publishConfig || {}).tag || conf.get('tag'),
+    conf,
+  };
+
+  // normalize trailing slash
+  npm.registry = url.format(url.parse(npm.registry));
+
+  debug('npm registry: %O', npm.registry);
+  debug('npm tag: %O', npm.tag);
+  return {env: process.env, pkg, options, plugins, npm, logger};
+};

lib/get-next-version.js

@@ -0,0 +1,19 @@
+const semver = require('semver');
+const SemanticReleaseError = require('@semantic-release/error');
+const logger = require('./logger');
+
+module.exports = (type, lastRelease) => {
+  let version;
+  if (!lastRelease.version) {
+    version = '1.0.0';
+    logger.log('There is no previous release, the next release version is %s', version);
+  } else {
+    version = semver.inc(lastRelease.version, type);
+    if (!version) {
+      throw new SemanticReleaseError(`Invalid release type ${type}`, 'EINVALIDTYPE');
+    }
+    logger.log('The next release version is %s', version);
+  }
+
+  return version;
+};

lib/get-registry.js

@@ -0,0 +1,11 @@
+module.exports = ({publishConfig, name}, conf) => {
+  if (publishConfig && publishConfig.registry) {
+    return publishConfig.registry;
+  }
+
+  if (name[0] !== '@') {
+    return conf.get('registry') || 'https://registry.npmjs.org/';
+  }
+
+  return conf.get(`${name.split('/')[0]}/registry`) || conf.get('registry') || 'https://registry.npmjs.org/';
+};

lib/get-version-head.js

@@ -0,0 +1,86 @@
+const execa = require('execa');
+const debug = require('debug')('semantic-release:get-version-head');
+const SemanticReleaseError = require('@semantic-release/error');
+const {debugShell} = require('./debug');
+
+/**
+ * Get the commit sha for a given tag.
+ *
+ * @param {string} tagName Tag name for which to retrieve the commit sha.
+ *
+ * @return {string} The commit sha of the tag in parameter or `null`.
+ */
+async function gitTagHead(tagName) {
+  try {
+    const shell = await execa('git', ['rev-list', '-1', '--tags', tagName]);
+    debugShell('Get git tag head', shell, debug);
+    return shell.stdout;
+  } catch (err) {
+    debug(err);
+    return null;
+  }
+}
+
+/**
+ * Verify if the commist `sha` is in the direct history of the current branch.
+ *
+ * @param {string} sha The sha of the commit to look for.
+ *
+ * @return {boolean} `true` if the commit `sha` is in the history of the current branch, `false` otherwise.
+ */
+async function isCommitInHistory(sha) {
+  const shell = await execa('git', ['merge-base', '--is-ancestor', sha, 'HEAD'], {reject: false});
+  debugShell('Check if commit is in history', shell, debug);
+  return shell.code === 0;
+}
+
+/**
+ * Get the commit sha for a given version, if it's contained in the given branch.
+ *
+ * @param {string} gitHead The commit sha to look for.
+ * @param {string} version The version corresponding to the commit sha to look for. Used to search in git tags.
+ *
+ * @return {Promise<string>} A Promise that resolves to the commit sha of the version, either `gitHead` of the commit associated with the `version` tag.
+ *
+ * @throws {SemanticReleaseError} with code `ENOTINHISTORY` if `gitHead` or the commit sha dereived from `version` is not in the direct history of `branch`.
+ * @throws {SemanticReleaseError} with code `ENOGITHEAD` if `gitHead` is undefined and no commit sha can be found for the `version`.
+ */
+module.exports = async (gitHead, version) => {
+  // Check if gitHead is defined and exists in release branch
+  if (gitHead && (await isCommitInHistory(gitHead))) {
+    debug('Use gitHead: %s', gitHead);
+    return gitHead;
+  }
+
+  // Ushallow the repository
+  const shell = await execa('git', ['fetch', '--unshallow', '--tags'], {reject: false});
+  debugShell('Unshallow repo', shell, debug);
+
+  // Check if gitHead is defined and exists in release branch again
+  if (gitHead && (await isCommitInHistory(gitHead))) {
+    debug('Use gitHead: %s', gitHead);
+    return gitHead;
+  }
+
+  let tagHead;
+  if (version) {
+    // If a version is defined search a corresponding tag
+    tagHead = (await gitTagHead(`v${version}`)) || (await gitTagHead(version));
+
+    // Check if tagHead is found and exists in release branch again
+    if (tagHead && (await isCommitInHistory(tagHead))) {
+      debug('Use tagHead: %s', tagHead);
+      return tagHead;
+    }
+  }
+
+  // Either gitHead is defined or a tagHead has been found but none is in the branch history
+  if (gitHead || tagHead) {
+    const error = new SemanticReleaseError('Commit not in history', 'ENOTINHISTORY');
+    error.gitHead = gitHead || tagHead;
+    throw error;
+  }
+
+  // There is no gitHead in the last release and there is no tags correponsing to the last release version
+  throw new SemanticReleaseError('There is no commit associated with last release', 'ENOGITHEAD');
+};

lib/github-release.js

@@ -0,0 +1,36 @@
+const {promisify} = require('util');
+const url = require('url');
+const gitHead = require('git-head');
+const GitHubApi = require('github');
+const parseSlug = require('parse-github-repo-url');
+const debug = require('debug')('semantic-release:github-release');
+
+module.exports = async (pkg, notes, version, {branch, githubUrl, githubToken, githubApiPathPrefix}) => {
+  const [owner, repo] = parseSlug(pkg.repository.url);
+  let {port, protocol, hostname: host} = githubUrl ? url.parse(githubUrl) : {};
+  protocol = (protocol || '').split(':')[0] || null;
+  const pathPrefix = githubApiPathPrefix || null;
+  const github = new GitHubApi({port, protocol, host, pathPrefix});
+  debug('Github host: %o', host);
+  debug('Github port: %o', port);
+  debug('Github protocol: %o', protocol);
+  debug('Github pathPrefix: %o', pathPrefix);
+
+  github.authenticate({type: 'token', token: githubToken});
+
+  const name = `v${version}`;
+  const release = {owner, repo, tag_name: name, name, target_commitish: branch, body: notes};
+  debug('release owner: %o', owner);
+  debug('release repo: %o', repo);
+  debug('release name: %o', name);
+  debug('release branch: %o', branch);
+
+  const sha = await promisify(gitHead)();
+  const ref = `refs/tags/${name}`;
+
+  debug('Create git tag %o with commit %o', ref, sha);
+  await github.gitdata.createReference({owner, repo, ref, sha});
+  const {data: {html_url: releaseUrl}} = await github.repos.createRelease(release);
+
+  return releaseUrl;
+};

lib/logger.js

@@ -0,0 +1,23 @@
+const chalk = require('chalk');
+
+/**
+ * Logger with `log` and `error` function.
+ */
+module.exports = {
+  log(...args) {
+    const [format, ...rest] = args;
+    console.log(
+      `${chalk.grey('[Semantic release]:')}${
+        typeof format === 'string' ? ` ${format.replace(/%[^%]/g, seq => chalk.magenta(seq))}` : ''
+      }`,
+      ...(typeof format === 'string' ? [] : [format]).concat(rest)
+    );
+  },
+  error(...args) {
+    const [format, ...rest] = args;
+    console.error(
+      `${chalk.grey('[Semantic release]:')}${typeof format === 'string' ? ` ${chalk.red(format)}` : ''}`,
+      ...(typeof format === 'string' ? [] : [format]).concat(rest)
+    );
+  },
+};

lib/plugin-noop.js

@@ -0,0 +1,3 @@
+module.exports = (config, options, cb) => {
+  cb(null);
+};

lib/plugins.js

@@ -0,0 +1,45 @@
+const {promisify} = require('util');
+const relative = require('require-relative');
+const pSeries = require('p-series');
+const logger = require('./logger');
+
+module.exports = options => {
+  const plugins = {
+    analyzeCommits: normalize(options.analyzeCommits, '@semantic-release/commit-analyzer'),
+    generateNotes: normalize(options.generateNotes, '@semantic-release/release-notes-generator'),
+    getLastRelease: normalize(options.getLastRelease, '@semantic-release/last-release-npm'),
+  };
+  ['verifyConditions', 'verifyRelease'].forEach(plugin => {
+    if (!Array.isArray(options[plugin])) {
+      plugins[plugin] = normalize(
+        options[plugin],
+        plugin === 'verifyConditions' ? '@semantic-release/condition-travis' : './plugin-noop'
+      );
+    } else {
+      plugins[plugin] = async pluginOptions => {
+        return pSeries(
+          options[plugin].map(step => {
+            return () => normalize(step, './plugin-noop')(pluginOptions);
+          })
+        );
+      };
+    }
+  });
+
+  return plugins;
+};
+
+const normalize = (pluginConfig, fallback) => {
+  if (typeof pluginConfig === 'string') {
+    logger.log('Load plugin %s', pluginConfig);
+    return promisify(relative(pluginConfig).bind(null, {}));
+  }
+
+  if (pluginConfig && typeof pluginConfig.path === 'string') {
+    logger.log('Load plugin %s', pluginConfig.path);
+    return promisify(relative(pluginConfig.path).bind(null, pluginConfig));
+  }
+  return promisify(require(fallback).bind(null, pluginConfig || {}));
+};
+
+module.exports.normalize = normalize;

lib/publish-npm.js

@@ -0,0 +1,35 @@
+const {appendFile, readJson, writeJson, pathExists} = require('fs-extra');
+const execa = require('execa');
+const nerfDart = require('nerf-dart');
+const debug = require('debug')('semantic-release:publish-npm');
+const {debugShell} = require('./debug');
+const logger = require('./logger');
+
+module.exports = async (pkg, {conf, registry, auth}, {version}) => {
+  const pkgFile = await readJson('./package.json');
+
+  if (await pathExists('./npm-shrinkwrap.json')) {
+    const shrinkwrap = await readJson('./npm-shrinkwrap.json');
+    shrinkwrap.version = version;
+    await writeJson('./npm-shrinkwrap.json', shrinkwrap);
+    logger.log('Wrote version %s to npm-shrinkwrap.json', version);
+  }
+
+  await writeJson('./package.json', Object.assign(pkgFile, {version}));
+  logger.log('Wrote version %s to package.json', version);
+
+  if (process.env.NPM_OLD_TOKEN && process.env.NPM_EMAIL) {
+    // Using the old auth token format is not considered part of the public API
+    // This might go away anytime (i.e. once we have a better testing strategy)
+    await appendFile('./.npmrc', `_auth = \${NPM_OLD_TOKEN}\nemail = \${NPM_EMAIL}`);
+    logger.log('Wrote NPM_OLD_TOKEN and NPM_EMAIL to .npmrc.');
+  } else {
+    await appendFile('./.npmrc', `${nerfDart(registry)}:_authToken = \${NPM_TOKEN}`);
+    logger.log('Wrote NPM_TOKEN to .npmrc.');
+  }
+
+  logger.log('Publishing version %s to npm registry %s', version, registry);
+  const shell = await execa('npm', ['publish']);
+  console.log(shell.stdout);
+  debugShell('Publishing on npm', shell, debug);
+};

lib/verify-auth.js

@@ -0,0 +1,11 @@
+const SemanticReleaseError = require('@semantic-release/error');
+
+module.exports = (options, env) => {
+  if (!options.githubToken) {
+    throw new SemanticReleaseError('No github token specified.', 'ENOGHTOKEN');
+  }
+
+  if (!(env.NPM_TOKEN || (env.NPM_OLD_TOKEN && env.NPM_EMAIL))) {
+    throw new SemanticReleaseError('No npm token specified.', 'ENONPMTOKEN');
+  }
+};

lib/verify-pkg.js

@@ -0,0 +1,11 @@
+const SemanticReleaseError = require('@semantic-release/error');
+
+module.exports = pkg => {
+  if (!pkg.name) {
+    throw new SemanticReleaseError('No "name" found in package.json.', 'ENOPKGNAME');
+  }
+
+  if (!pkg.repository || !pkg.repository.url) {
+    throw new SemanticReleaseError('No "repository" found in package.json.', 'ENOPKGREPO');
+  }
+};