feat: add logs about prepare, publish, success and fail plugins skipped in dry-run mode

In case multiple plugins with a `analyzeCommits` step are configured, all of them will be executed and the highest release type (`major` > `minor`, `patch`) will be used.

docs/extending/plugins-list.md

@@ -59,3 +59,6 @@
   - `publish`: Submit the generated archives to the webstore for review, and publish the item including release notes
 - [semantic-release-gerrit](https://github.com/pascalMN/semantic-release-gerrit)
   - `generateNotes`: Generate release notes with Gerrit reviews URL
+- [semantic-release-expo](https://github.com/bycedric/semantic-release-expo)
+  - `verifyConditions`: Verify Expo manifest(s) are readable and valid.
+  - `prepare`: Update version, ios build number and android version code in the Expo manifest(s).

docs/support/FAQ.md

@@ -12,7 +12,25 @@ However, the [`@semantic-release/git`](https://github.com/semantic-release/git)
 
 The `package.json`’s version will be updated by the `semantic-release` command just before publishing to [npm](https://www.npmjs.com), therefore it won't be available for scripts ran before the `semantic-release` command.
 
-As semantic-release uses the [npm CLI](https://docs.npmjs.com/cli/npm) to publish, all [npm hook scripts](https://docs.npmjs.com/misc/scripts#hook-scripts) will be executed. Therefore you can run your build script in the [`prepublishOnly`](https://docs.npmjs.com/misc/scripts#prepublish-and-prepare) hook. It will be executed after the `semantic-release` command update the `package.json`’s version and before publishing.
+As the [`@semantic-release/npm`](https://github.com/semantic-release/npm) plugin uses the [npm CLI](https://docs.npmjs.com/cli/npm) to update the `package.json` version and publish the package, all [npm hook scripts](https://docs.npmjs.com/misc/scripts#description) will be executed.
+
+You can run your build script in:
+- the `prepublishOnly` or `prepack` hook so it will be executed during the `publish` step of `@semantic-release/npm`
+- the `postversion` hook so it will be executed during the `prepare` step of `@semantic-release/npm`, which allow for example to update files before committing them with the [`@semantic-release/git`](https://github.com/semantic-release/git) plugin
+
+If using npm hook scripts is not possible, and alternative solution is to [`@semantic-release/exec`](https://github.com/semantic-release/exec) plugin to run your script in the `prepare` step:
+```json
+{
+  "plugins": [
+    "@semantic-release/commit-analyzer",
+    "@semantic-release/release-notes-generator",
+    "@semantic-release/npm",
+    ["@semantic-release/exec", {
+      "prepareCmd": "./my-build-script.sh ${nextRelease.version}",
+    }],
+  ]
+}
+```
 
 ## Is there a way to preview which version would currently get published?
 
@@ -59,28 +77,23 @@ To publish a non-Node package (without a `package.json`) you would need to:
 
 See the [CI configuration recipes](../recipes/README.md#ci-configurations) for more details on specific CI environments.
 
-In addition you will need to configure the **semantic-release** [plugins](../usage/plugins.md#plugins) to:
-- Disable the [`@semantic-release/npm`](https://github.com/semantic-release/npm) plugin
-- Define plugins for the [verifyConditions](../usage/plugins.md#verifyconditions-plugin), [prepare](../usage/plugins.md#prepare-plugin) and [publish](../usage/plugins.md#publish-plugin) steps to release on your package registry. The [`@semantic-release/exec`](https://github.com/semantic-release/exec) plugin is recommended for situation where a release can be done with a shell command.
+In addition you will need to configure the **semantic-release** [plugins](../usage/plugins.md#plugins) to disable the [`@semantic-release/npm`](https://github.com/semantic-release/npm) plugin which is used by default and use a plugin for your project type.
 
-Here is a basic example to create [GitHub releases](https://help.github.com/articles/about-releases) and use shell command to publish:
+If there is no specific plugin for your project type you can use the [`@semantic-release/exec`](https://github.com/semantic-release/exec) plugin to publish the release with a shell command.
+
+Here is a basic example to create [GitHub releases](https://help.github.com/articles/about-releases) and use a shell command to publish:
 
 ```json
 {
-  "verifyConditions": ["@semantic-release/github"],
-  "prepare": [
-    {
-      "path": "@semantic-release/exec",
-      "cmd": "set-version ${nextRelease.version}"
-    }
-  ],
-  "publish": [
+  "plugins": [
+    "@semantic-release/commit-analyzer",
+    "@semantic-release/release-notes-generator",
     "@semantic-release/github",
-    {
-      "path": "@semantic-release/exec",
-      "cmd": "publish-package"
-    }
-  ],
+    ["@semantic-release/exec", {
+      "prepareCmd" : "set-version ${nextRelease.version}",
+      "publishCmd" : "publish-package"
+      }]
+  ]
 }
 ```
 
@@ -114,7 +127,7 @@ See the [GitLab CI recipes](../recipes/gitlab-ci.md#using-semantic-release-with-
 
 ## Can I use semantic-release with any Git hosted environment?
 
-By default **semantic-release** uses the [`@semantic-release/github`](https://github.com/semantic-release/github) plugin to publish a [GitHub release](https://help.github.com/articles/about-releases). For other Git hosted environment the  [`@semantic-release/git`](https://github.com/semantic-release/git) and [`@semantic-release/changelog`](https://github.com/semantic-release/changelog) plugins can be used via [plugins configuration](../usage/plugins.md#configuration).
+By default **semantic-release** uses the [`@semantic-release/github`](https://github.com/semantic-release/github) plugin to publish a [GitHub release](https://help.github.com/articles/about-releases). For other Git hosted environment the  [`@semantic-release/git`](https://github.com/semantic-release/git) and [`@semantic-release/changelog`](https://github.com/semantic-release/changelog) plugins can be used via [plugins configuration](../usage/plugins.md).
 
 See the [`@semantic-release/git`](https://github.com/semantic-release/git#semantic-releasegit) [`@semantic-release/changelog`](https://github.com/semantic-release/changelog#semantic-releasechangelog) plugins documentation for more details.
 

docs/usage/plugins.md

@@ -4,16 +4,18 @@ Each [release step](../../README.md#release-steps) is implemented by configurabl
 
 A plugin is a npm module that can implement one or more of the following steps:
 
-| Step               | Accept multiple | Required | Description                                                                                                                                                                                   |
-|--------------------|-----------------|----------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| `verifyConditions` | Yes             | No       | Responsible for verifying conditions necessary to proceed with the release: configuration is correct, authentication token are valid, etc...                                                  |
-| `analyzeCommits`   | No              | Yes      | Responsible for determining the type of the next release (`major`, `minor` or `patch`).                                                                                                       |
-| `verifyRelease`    | Yes             | No       | Responsible for verifying the parameters (version, type, dist-tag etc...) of the release that is about to be published.                                                                       |
-| `generateNotes`    | Yes             | No       | Responsible for generating the content of the release note. If multiple `generateNotes` plugins are defined, the release notes will be the result of the concatenation of each plugin output. |
-| `prepare`          | Yes             | No       | Responsible for preparing the release, for example creating or updating files such as `package.json`, `CHANGELOG.md`, documentation or compiled assets and pushing a commit.                  |
-| `publish`          | Yes             | No       | Responsible for publishing the release.                                                                                                                                                       |
-| `success`          | Yes             | No       | Responsible for notifying of a new release.                                                                                                                                                   |
-| `fail`             | Yes             | No       | Responsible for notifying of a failed release.                                                                                                                                                |
+| Step               | Required | Description                                                                                                                                                                                                          |
+|--------------------|----------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `verifyConditions` | No       | Responsible for verifying conditions necessary to proceed with the release: configuration is correct, authentication token are valid, etc...                                                                         |
+| `analyzeCommits`   | Yes      | Responsible for determining the type of the next release (`major`, `minor` or `patch`). If multiple plugins with a `analyzeCommits` step are defined, the release type will be the highest one among plugins output. |
+| `verifyRelease`    | No       | Responsible for verifying the parameters (version, type, dist-tag etc...) of the release that is about to be published.                                                                                              |
+| `generateNotes`    | No       | Responsible for generating the content of the release note. If multiple plugins with a `generateNotes` step are defined, the release notes will be the result of the concatenation of each plugin output.            |
+| `prepare`          | No       | Responsible for preparing the release, for example creating or updating files such as `package.json`, `CHANGELOG.md`, documentation or compiled assets and pushing a commit.                                         |
+| `publish`          | No       | Responsible for publishing the release.                                                                                                                                                                              |
+| `success`          | No       | Responsible for notifying of a new release.                                                                                                                                                                          |
+| `fail`             | No       | Responsible for notifying of a failed release.                                                                                                                                                                       |
+
+**Note:** If no plugin with a `analyzeCommits` step is defined `@semantic-release/commit-analyzer` will be used.
 
 See [available plugins](../extending/plugins-list.md).
 

index.js

@@ -24,7 +24,7 @@ async function run(context, plugins) {
   const {isCi, branch: ciBranch, isPr} = envCi({env, cwd});
 
   if (!isCi && !options.dryRun && !options.noCi) {
-    logger.log('This run was not triggered in a known CI environment, running in dry-run mode.');
+    logger.warn('This run was not triggered in a known CI environment, running in dry-run mode.');
     options.dryRun = true;
   } else {
     // When running on CI, set the commits author and commiter info and prevent the `git` CLI to prompt for username/password. See #703.
@@ -52,7 +52,9 @@ async function run(context, plugins) {
     );
     return false;
   }
-  logger.success(`Run automated release from branch ${ciBranch}`);
+  logger[options.dryRun ? 'warn' : 'success'](
+    `Run automated release from branch ${ciBranch}${options.dryRun ? ' in dry-run mode' : ''}`
+  );
 
   await verify(context);
 
@@ -62,14 +64,12 @@ async function run(context, plugins) {
     try {
       await verifyAuth(options.repositoryUrl, options.branch, {cwd, env});
     } catch (error) {
-      console.error('call isBranchUpToDate');
       if (!(await isBranchUpToDate(options.branch, {cwd, env}))) {
         logger.log(
           `The local branch ${options.branch} is behind the remote one, therefore a new version won't be published.`
         );
         return false;
       }
-      console.error('call throw error');
       throw error;
     }
   } catch (error) {
@@ -98,26 +98,30 @@ async function run(context, plugins) {
 
   await plugins.verifyRelease(context);
 
-  if (options.dryRun) {
-    const notes = await plugins.generateNotes(context);
-    logger.log(`Release note for version ${nextRelease.version}:`);
-    if (notes) {
-      context.stdout.write(marked(notes));
-    }
-  } else {
-    nextRelease.notes = await plugins.generateNotes(context);
-    await plugins.prepare(context);
+  nextRelease.notes = await plugins.generateNotes(context);
 
+  await plugins.prepare(context);
+
+  if (options.dryRun) {
+    logger.warn(`Skip ${nextRelease.gitTag} tag creation in dry-run mode`);
+  } else {
     // Create the tag before calling the publish plugins as some require the tag to exists
     await tag(nextRelease.gitTag, {cwd, env});
     await push(options.repositoryUrl, options.branch, {cwd, env});
     logger.success(`Created tag ${nextRelease.gitTag}`);
+  }
 
-    context.releases = await plugins.publish(context);
+  context.releases = await plugins.publish(context);
 
-    await plugins.success(context);
+  await plugins.success(context);
 
-    logger.success(`Published release ${nextRelease.version}`);
+  logger.success(`Published release ${nextRelease.version}`);
+
+  if (options.dryRun) {
+    logger.log(`Release note for version ${nextRelease.version}:`);
+    if (nextRelease.notes) {
+      context.stdout.write(marked(nextRelease.notes));
+    }
   }
 
   return pick(context, ['lastRelease', 'commits', 'nextRelease', 'releases']);
@@ -164,9 +168,7 @@ module.exports = async (opts = {}, {cwd = process.cwd(), env = process.env, stdo
       unhook();
       return result;
     } catch (error) {
-      if (!options.dryRun) {
-        await callFail(context, plugins, error);
-      }
+      await callFail(context, plugins, error);
       throw error;
     }
   } catch (error) {

lib/definitions/constants.js

@@ -1,4 +1,4 @@
-const RELEASE_TYPE = ['major', 'premajor', 'minor', 'preminor', 'patch', 'prepatch', 'prerelease'];
+const RELEASE_TYPE = ['prerelease', 'prepatch', 'patch', 'preminor', 'minor', 'premajor', 'major'];
 
 const FIRST_RELEASE = '1.0.0';
 

lib/definitions/errors.js

@@ -55,13 +55,11 @@ Your configuration for the \`tagFormat\` option is \`${stringify(tagFormat)}\`.`
 
 Your configuration for the \`tagFormat\` option is \`${stringify(tagFormat)}\`.`,
   }),
-  EPLUGINCONF: ({type, multiple, required, pluginConf}) => ({
+  EPLUGINCONF: ({type, required, pluginConf}) => ({
     message: `The \`${type}\` plugin configuration is invalid.`,
     details: `The [${type} plugin configuration](${linkify(`docs/usage/plugins.md#${toLower(type)}-plugin`)}) ${
       required ? 'is required and ' : ''
-    }must be ${
-      multiple ? 'a single or an array of plugins' : 'a single plugin'
-    } definition. A plugin definition is an npm module name, optionnaly wrapped in an array with an object.
+    } must be a single or an array of plugins definition. A plugin definition is an npm module name, optionnaly wrapped in an array with an object.
 
 Your configuration for the \`${type}\` plugin is \`${stringify(pluginConf)}\`.`,
   }),

lib/definitions/plugins.js

@@ -6,29 +6,35 @@ const {RELEASE_TYPE, RELEASE_NOTES_SEPARATOR} = require('./constants');
 
 module.exports = {
   verifyConditions: {
-    multiple: true,
     required: false,
+    dryRun: true,
     pipelineConfig: () => ({settleAll: true}),
   },
   analyzeCommits: {
     default: ['@semantic-release/commit-analyzer'],
-    multiple: false,
     required: true,
+    dryRun: true,
     outputValidator: output => !output || RELEASE_TYPE.includes(output),
     preprocess: ({commits, ...inputs}) => ({
       ...inputs,
       commits: commits.filter(commit => !/\[skip\s+release\]|\[release\s+skip\]/i.test(commit.message)),
     }),
-    postprocess: ([result]) => result,
+    postprocess: results =>
+      RELEASE_TYPE[
+        results.reduce((highest, result) => {
+          const typeIndex = RELEASE_TYPE.indexOf(result);
+          return typeIndex > highest ? typeIndex : highest;
+        }, -1)
+      ],
   },
   verifyRelease: {
-    multiple: true,
     required: false,
+    dryRun: true,
     pipelineConfig: () => ({settleAll: true}),
   },
   generateNotes: {
-    multiple: true,
     required: false,
+    dryRun: true,
     outputValidator: output => !output || isString(output),
     pipelineConfig: () => ({
       getNextInput: ({nextRelease, ...context}, notes) => ({
@@ -42,16 +48,15 @@ module.exports = {
     postprocess: (results, {env}) => hideSensitive(env)(results.filter(Boolean).join(RELEASE_NOTES_SEPARATOR)),
   },
   prepare: {
-    multiple: true,
     required: false,
-    pipelineConfig: ({generateNotes}, logger) => ({
+    dryRun: false,
+    pipelineConfig: ({generateNotes}) => ({
       getNextInput: async context => {
         const newGitHead = await gitHead({cwd: context.cwd});
         // If previous prepare plugin has created a commit (gitHead changed)
         if (context.nextRelease.gitHead !== newGitHead) {
           context.nextRelease.gitHead = newGitHead;
           // Regenerate the release notes
-          logger.log('Call plugin %s', 'generateNotes');
           context.nextRelease.notes = await generateNotes(context);
         }
         // Call the next prepare plugin with the updated `nextRelease`
@@ -60,8 +65,8 @@ module.exports = {
     }),
   },
   publish: {
-    multiple: true,
     required: false,
+    dryRun: false,
     outputValidator: output => !output || isPlainObject(output),
     pipelineConfig: () => ({
       // Add `nextRelease` and plugin properties to published release
@@ -73,14 +78,14 @@ module.exports = {
     }),
   },
   success: {
-    multiple: true,
     required: false,
+    dryRun: false,
     pipelineConfig: () => ({settleAll: true}),
     preprocess: ({releases, env, ...inputs}) => ({...inputs, env, releases: hideSensitiveValues(env, releases)}),
   },
   fail: {
-    multiple: true,
     required: false,
+    dryRun: false,
     pipelineConfig: () => ({settleAll: true}),
     preprocess: ({errors, env, ...inputs}) => ({...inputs, env, errors: hideSensitiveValues(env, errors)}),
   },

lib/get-config.js

@@ -20,7 +20,10 @@ const CONFIG_FILES = [
 
 module.exports = async (context, opts) => {
   const {cwd, env} = context;
-  const {config} = (await cosmiconfig(CONFIG_NAME, {searchPlaces: CONFIG_FILES}).search(cwd)) || {};
+  const {config, filepath} = (await cosmiconfig(CONFIG_NAME, {searchPlaces: CONFIG_FILES}).search(cwd)) || {};
+
+  debug('load config from: %s', filepath);
+
   // Merge config file options and CLI/API options
   let options = {...config, ...opts};
   const pluginsPath = {};

lib/get-git-auth-url.js

@@ -1,6 +1,5 @@
 const {parse, format} = require('url');
 const {isNil} = require('lodash');
-const gitUrlParse = require('git-url-parse');
 const hostedGitInfo = require('hosted-git-info');
 const {verifyAuth} = require('./git');
 
@@ -27,17 +26,14 @@ const GIT_TOKENS = {
  */
 module.exports = async ({cwd, env, options: {repositoryUrl, branch}}) => {
   const info = hostedGitInfo.fromUrl(repositoryUrl, {noGitPlus: true});
+  const {protocol, ...parsed} = parse(repositoryUrl);
 
   if (info && info.getDefaultRepresentation() === 'shortcut') {
     // Expand shorthand URLs (such as `owner/repo` or `gitlab:owner/repo`)
     repositoryUrl = info.https();
-  } else {
-    const {protocols} = gitUrlParse(repositoryUrl);
-
+  } else if (protocol && protocol.includes('http')) {
     // Replace `git+https` and `git+http` with `https` or `http`
-    if (protocols.includes('http') || protocols.includes('https')) {
-      repositoryUrl = format({...parse(repositoryUrl), protocol: protocols.includes('https') ? 'https' : 'http'});
-    }
+    repositoryUrl = format({...parsed, protocol: protocol.includes('https') ? 'https' : 'http', href: null});
   }
 
   // Test if push is allowed without transforming the URL (e.g. is ssh keys are set up)
@@ -46,11 +42,16 @@ module.exports = async ({cwd, env, options: {repositoryUrl, branch}}) => {
   } catch (error) {
     const envVar = Object.keys(GIT_TOKENS).find(envVar => !isNil(env[envVar]));
     const gitCredentials = `${GIT_TOKENS[envVar] || ''}${env[envVar] || ''}`;
-    const {protocols, ...parsed} = gitUrlParse(repositoryUrl);
-    const protocol = protocols.includes('https') ? 'https' : protocols.includes('http') ? 'http' : 'https';
 
-    // If credentials are set via anvironment variables, convert the URL to http/https and add basic auth, otherwise return `repositoryUrl` as is
-    return gitCredentials ? {...parsed, protocols: [protocol], user: gitCredentials}.toString(protocol) : repositoryUrl;
+    if (gitCredentials) {
+      // If credentials are set via anvironment variables, convert the URL to http/https and add basic auth, otherwise return `repositoryUrl` as is
+      const [match, auth, host, path] = /^(?!.+:\/\/)(?:(.*)@)?(.*?):(.*)$/.exec(repositoryUrl) || [];
+      return format({
+        ...parse(match ? `ssh://${auth ? `${auth}@` : ''}${host}/${path}` : repositoryUrl),
+        auth: gitCredentials,
+        protocol: protocol && /http[^s]/.test(protocol) ? 'http' : 'https',
+      });
+    }
   }
 
   return repositoryUrl;

lib/get-logger.js

@@ -3,7 +3,7 @@ const figures = require('figures');
 
 module.exports = ({stdout, stderr}) =>
   new Signale({
-    config: {displayTimestamp: true, underlineMessage: true, displayLabel: false},
+    config: {displayTimestamp: true, underlineMessage: false, displayLabel: false},
     disabled: false,
     interactive: false,
     scope: 'semantic-release',

lib/plugins/index.js

@@ -24,7 +24,7 @@ module.exports = (context, pluginsPath) => {
                   writable: false,
                   enumerable: true,
                 });
-                plugins[type] = [...(PLUGINS_DEFINITIONS[type].multiple ? plugins[type] || [] : []), [func, config]];
+                plugins[type] = [...(plugins[type] || []), [func, config]];
               }
             });
           } else {
@@ -45,10 +45,7 @@ module.exports = (context, pluginsPath) => {
   options = {...plugins, ...options};
 
   const pluginsConf = Object.entries(PLUGINS_DEFINITIONS).reduce(
-    (
-      pluginsConf,
-      [type, {multiple, required, default: def, pipelineConfig, postprocess = identity, preprocess = identity}]
-    ) => {
+    (pluginsConf, [type, {required, default: def, pipelineConfig, postprocess = identity, preprocess = identity}]) => {
       let pluginOpts;
 
       if (isNil(options[type]) && def) {
@@ -56,12 +53,12 @@ module.exports = (context, pluginsPath) => {
       } else {
         // If an object is passed and the path is missing, merge it with step options
         if (isPlainObject(options[type]) && !options[type].path) {
-          options[type] = castArray(plugins[type]).map(
-            plugin => (plugin ? [plugin[0], Object.assign(plugin[1], options[type])] : plugin)
+          options[type] = castArray(plugins[type]).map(plugin =>
+            plugin ? [plugin[0], Object.assign(plugin[1], options[type])] : plugin
           );
         }
-        if (!validateStep({multiple, required}, options[type])) {
-          errors.push(getError('EPLUGINCONF', {type, multiple, required, pluginConf: options[type]}));
+        if (!validateStep({required}, options[type])) {
+          errors.push(getError('EPLUGINCONF', {type, required, pluginConf: options[type]}));
           return pluginsConf;
         }
         pluginOpts = options[type];

lib/plugins/normalize.js

@@ -1,4 +1,5 @@
 const {isPlainObject, isFunction, noop, cloneDeep, omit} = require('lodash');
+const debug = require('debug')('semantic-release:plugins');
 const getError = require('../get-error');
 const {extractErrors} = require('../utils');
 const PLUGINS_DEFINITIONS = require('../definitions/plugins');
@@ -14,6 +15,8 @@ module.exports = (context, type, pluginOpt, pluginsPath) => {
   const pluginName = name.pluginName ? name.pluginName : isFunction(name) ? `[Function: ${name.name}]` : name;
   const plugin = loadPlugin(context, name, pluginsPath);
 
+  debug(`options for ${pluginName}/${type}: %O`, config);
+
   let func;
   if (isFunction(plugin)) {
     func = plugin.bind(null, cloneDeep({...options, ...config}));
@@ -24,20 +27,23 @@ module.exports = (context, type, pluginOpt, pluginsPath) => {
   }
 
   const validator = async input => {
-    const {outputValidator} = PLUGINS_DEFINITIONS[type] || {};
+    const {dryRun, outputValidator} = PLUGINS_DEFINITIONS[type] || {};
     try {
-      logger.log(`Start step "${type}" of plugin "${pluginName}"`);
-      const result = await func({
-        ...cloneDeep(omit(input, ['stdout', 'stderr', 'logger'])),
-        stdout,
-        stderr,
-        logger: logger.scope(logger.scopeName, pluginName),
-      });
-      if (outputValidator && !outputValidator(result)) {
-        throw getError(`E${type.toUpperCase()}OUTPUT`, {result, pluginName});
+      if (!input.options.dryRun || dryRun) {
+        logger.log(`Start step "${type}" of plugin "${pluginName}"`);
+        const result = await func({
+          ...cloneDeep(omit(input, ['stdout', 'stderr', 'logger'])),
+          stdout,
+          stderr,
+          logger: logger.scope(logger.scopeName, pluginName),
+        });
+        if (outputValidator && !outputValidator(result)) {
+          throw getError(`E${type.toUpperCase()}OUTPUT`, {result, pluginName});
+        }
+        logger.success(`Completed step "${type}" of plugin "${pluginName}"`);
+        return result;
       }
-      logger.success(`Completed step "${type}" of plugin "${pluginName}"`);
-      return result;
+      logger.warn(`Skip step "${type}" of plugin "${pluginName}" in dry-run mode`);
     } catch (error) {
       logger.error(`Failed step "${type}" of plugin "${pluginName}"`);
       extractErrors(error).forEach(err => Object.assign(err, {pluginName}));

lib/plugins/utils.js

@@ -2,28 +2,25 @@ const {dirname} = require('path');
 const {isString, isFunction, castArray, isArray, isPlainObject, isNil} = require('lodash');
 const resolveFrom = require('resolve-from');
 
-const validateStepArrayDefinition = conf =>
-  isArray(conf) &&
-  (conf.length === 1 || conf.length === 2) &&
-  (isString(conf[0]) || isFunction(conf[0])) &&
-  (isNil(conf[1]) || isPlainObject(conf[1]));
+const validateSteps = conf => {
+  return conf.every(conf => {
+    if (
+      isArray(conf) &&
+      (conf.length === 1 || conf.length === 2) &&
+      (isString(conf[0]) || isFunction(conf[0])) &&
+      (isNil(conf[1]) || isPlainObject(conf[1]))
+    ) {
+      return true;
+    }
+    conf = castArray(conf);
 
-const validateSingleStep = conf => {
-  if (validateStepArrayDefinition(conf)) {
-    return true;
-  }
-  conf = castArray(conf);
+    if (conf.length !== 1) {
+      return false;
+    }
 
-  if (conf.length !== 1) {
-    return false;
-  }
-
-  const [name, config] = parseConfig(conf[0]);
-  return (isString(name) || isFunction(name)) && isPlainObject(config);
-};
-
-const validateMultipleStep = conf => {
-  return conf.every(conf => validateSingleStep(conf));
+    const [name, config] = parseConfig(conf[0]);
+    return (isString(name) || isFunction(name)) && isPlainObject(config);
+  });
 };
 
 function validatePlugin(conf) {
@@ -37,12 +34,12 @@ function validatePlugin(conf) {
   );
 }
 
-function validateStep({multiple, required}, conf) {
+function validateStep({required}, conf) {
   conf = castArray(conf).filter(Boolean);
   if (required) {
-    return conf.length >= 1 && (multiple ? validateMultipleStep : validateSingleStep)(conf);
+    return conf.length >= 1 && validateSteps(conf);
   }
-  return conf.length === 0 || (multiple ? validateMultipleStep : validateSingleStep)(conf);
+  return conf.length === 0 || validateSteps(conf);
 }
 
 function loadPlugin({cwd}, name, pluginsPath) {

package.json

@@ -23,17 +23,16 @@
     "@semantic-release/error": "^2.2.0",
     "@semantic-release/github": "^5.1.0",
     "@semantic-release/npm": "^5.0.5",
-    "@semantic-release/release-notes-generator": "^7.1.0",
+    "@semantic-release/release-notes-generator": "^7.1.2",
     "aggregate-error": "^1.0.0",
     "cosmiconfig": "^5.0.1",
     "debug": "^4.0.0",
     "env-ci": "^3.0.0",
     "execa": "^1.0.0",
     "figures": "^2.0.0",
-    "find-versions": "^2.0.0",
+    "find-versions": "^3.0.0",
     "get-stream": "^4.0.0",
     "git-log-parser": "^1.2.0",
-    "git-url-parse": "^10.0.1",
     "hook-std": "^1.1.0",
     "hosted-git-info": "^2.7.1",
     "lodash": "^4.17.4",

test/definitions/plugins.test.js

@@ -51,3 +51,13 @@ test('The "generateNotes" plugins output are concatenated with separator and sen
     `Note 1: Exposing token ${SECRET_REPLACEMENT}${RELEASE_NOTES_SEPARATOR}Note 2: Exposing token ${SECRET_REPLACEMENT}`
   );
 });
+
+test('The "analyzeCommits" plugins output are reduced to the highest release type', t => {
+  t.is(plugins.analyzeCommits.postprocess(['major', 'minor']), 'major');
+  t.is(plugins.analyzeCommits.postprocess(['', 'minor']), 'minor');
+  t.is(plugins.analyzeCommits.postprocess([undefined, 'patch']), 'patch');
+  t.is(plugins.analyzeCommits.postprocess([null, 'patch']), 'patch');
+  t.is(plugins.analyzeCommits.postprocess(['wrong_type', 'minor']), 'minor');
+  t.is(plugins.analyzeCommits.postprocess([]), undefined);
+  t.is(plugins.analyzeCommits.postprocess(['wrong_type']), undefined);
+});

test/get-git-auth-url.test.js

@@ -101,6 +101,19 @@ test('Return the "https" formatted URL if "gitCredentials" is defined and reposi
   );
 });
 
+test('Return the "https" formatted URL if "gitCredentials" is defined and repositoryUrl is a "git" URL without user', async t => {
+  const {cwd} = await gitRepo();
+
+  t.is(
+    await getAuthUrl({
+      cwd,
+      env: {...env, GIT_CREDENTIALS: 'user:pass'},
+      options: {branch: 'master', repositoryUrl: 'host.null:owner/repo.git'},
+    }),
+    'https://user:pass@host.null/owner/repo.git'
+  );
+});
+
 test('Return the "https" formatted URL if "gitCredentials" is defined and repositoryUrl is a "https" URL', async t => {
   const {cwd} = await gitRepo();
 

test/index.test.js

@@ -1,5 +1,5 @@
 import test from 'ava';
-import {escapeRegExp, isString} from 'lodash';
+import {escapeRegExp, isString, sortBy} from 'lodash';
 import proxyquire from 'proxyquire';
 import {spy, stub} from 'sinon';
 import {WritableStreamBuffer} from 'stream-buffers';
@@ -25,10 +25,12 @@ test.beforeEach(t => {
   t.context.log = spy();
   t.context.error = spy();
   t.context.success = spy();
+  t.context.warn = spy();
   t.context.logger = {
     log: t.context.log,
     error: t.context.error,
     success: t.context.success,
+    warn: t.context.warn,
     scope: () => t.context.logger,
   };
 });
@@ -375,13 +377,10 @@ test('Log all "verifyConditions" errors', async t => {
     )),
   ];
 
-  t.deepEqual(errors, [error1, error2, error3]);
-  t.deepEqual(t.context.error.args[t.context.error.args.length - 2], ['ERR2 error 2']);
-  t.deepEqual(t.context.error.args[t.context.error.args.length - 1], ['ERR3 error 3']);
-  t.deepEqual(t.context.error.args[t.context.error.args.length - 3], [
-    'An error occurred while running semantic-release: %O',
-    error1,
-  ]);
+  t.deepEqual(sortBy(errors, ['message']), sortBy([error1, error2, error3], ['message']));
+  t.true(t.context.error.calledWith('An error occurred while running semantic-release: %O', error1));
+  t.true(t.context.error.calledWith('ERR2 error 2'));
+  t.true(t.context.error.calledWith('ERR3 error 3'));
   t.true(t.context.error.calledAfter(t.context.log));
   t.is(fail.callCount, 1);
   t.deepEqual(fail.args[0][0], config);
@@ -423,15 +422,15 @@ test('Log all "verifyRelease" errors', async t => {
     )),
   ];
 
-  t.deepEqual(errors, [error1, error2]);
-  t.deepEqual(t.context.error.args[t.context.error.args.length - 2], ['ERR1 error 1']);
-  t.deepEqual(t.context.error.args[t.context.error.args.length - 1], ['ERR2 error 2']);
+  t.deepEqual(sortBy(errors, ['message']), sortBy([error1, error2], ['message']));
+  t.true(t.context.error.calledWith('ERR1 error 1'));
+  t.true(t.context.error.calledWith('ERR2 error 2'));
   t.is(fail.callCount, 1);
   t.deepEqual(fail.args[0][0], config);
   t.deepEqual(fail.args[0][1].errors, [error1, error2]);
 });
 
-test('Dry-run skips publish and success', async t => {
+test('Dry-run skips prepare, publish and success', async t => {
   // Create a git repository, set the current working directory at the root of the repo
   const {cwd, repositoryUrl} = await gitRepo(true);
   // Add commits to the master branch
@@ -449,6 +448,7 @@ test('Dry-run skips publish and success', async t => {
   const analyzeCommits = stub().resolves(nextRelease.type);
   const verifyRelease = stub().resolves();
   const generateNotes = stub().resolves(notes);
+  const prepare = stub().resolves();
   const publish = stub().resolves();
   const success = stub().resolves();
 
@@ -460,7 +460,7 @@ test('Dry-run skips publish and success', async t => {
     analyzeCommits,
     verifyRelease,
     generateNotes,
-    prepare: stub().resolves(),
+    prepare,
     publish,
     success,
   };
@@ -478,13 +478,17 @@ test('Dry-run skips publish and success', async t => {
     })
   );
 
-  t.not(t.context.log.args[0][0], 'This run was not triggered in a known CI environment, running in dry-run mode.');
+  t.not(t.context.warn.args[0][0], 'This run was not triggered in a known CI environment, running in dry-run mode.');
   t.is(verifyConditions.callCount, 1);
   t.is(analyzeCommits.callCount, 1);
   t.is(verifyRelease.callCount, 1);
   t.is(generateNotes.callCount, 1);
+  t.is(prepare.callCount, 0);
+  t.true(t.context.warn.calledWith(`Skip step "prepare" of plugin "[Function: ${prepare.name}]" in dry-run mode`));
   t.is(publish.callCount, 0);
+  t.true(t.context.warn.calledWith(`Skip step "publish" of plugin "[Function: ${publish.name}]" in dry-run mode`));
   t.is(success.callCount, 0);
+  t.true(t.context.warn.calledWith(`Skip step "success" of plugin "[Function: ${success.name}]" in dry-run mode`));
 });
 
 test('Dry-run skips fail', async t => {
@@ -520,10 +524,11 @@ test('Dry-run skips fail', async t => {
     )),
   ];
 
-  t.deepEqual(errors, [error1, error2]);
-  t.deepEqual(t.context.error.args[t.context.error.args.length - 2], ['ERR1 error 1']);
-  t.deepEqual(t.context.error.args[t.context.error.args.length - 1], ['ERR2 error 2']);
+  t.deepEqual(sortBy(errors, ['message']), sortBy([error1, error2], ['message']));
+  t.true(t.context.error.calledWith('ERR1 error 1'));
+  t.true(t.context.error.calledWith('ERR2 error 2'));
   t.is(fail.callCount, 0);
+  t.true(t.context.warn.calledWith(`Skip step "fail" of plugin "[Function: ${fail.name}]" in dry-run mode`));
 });
 
 test('Force a dry-run if not on a CI and "noCi" is not explicitly set', async t => {
@@ -574,7 +579,7 @@ test('Force a dry-run if not on a CI and "noCi" is not explicitly set', async t
     })
   );
 
-  t.is(t.context.log.args[1][0], 'This run was not triggered in a known CI environment, running in dry-run mode.');
+  t.true(t.context.warn.calledWith('This run was not triggered in a known CI environment, running in dry-run mode.'));
   t.is(verifyConditions.callCount, 1);
   t.is(analyzeCommits.callCount, 1);
   t.is(verifyRelease.callCount, 1);
@@ -1089,6 +1094,7 @@ test('Hide sensitive information passed to "success" plugin', async t => {
     verifyConditions: false,
     verifyRelease: false,
     prepare: false,
+    generateNotes: stub().resolves(`Exposing token ${env.MY_TOKEN}`),
     publish: stub().resolves({
       name: `Name: Exposing token ${env.MY_TOKEN}`,
       url: `URL: Exposing token ${env.MY_TOKEN}`,

test/plugins/normalize.test.js

@@ -62,7 +62,7 @@ test('Wrap plugin in a function that add the "pluginName" to the error"', async
     './plugin-error': './test/fixtures',
   });
 
-  const error = await t.throws(plugin());
+  const error = await t.throws(plugin({options: {}}));
 
   t.is(error.pluginName, './plugin-error');
 });
@@ -72,7 +72,7 @@ test('Wrap plugin in a function that add the "pluginName" to multiple errors"',
     './plugin-errors': './test/fixtures',
   });
 
-  const errors = [...(await t.throws(plugin()))];
+  const errors = [...(await t.throws(plugin({options: {}})))];
   for (const error of errors) {
     t.is(error.pluginName, './plugin-errors');
   }
@@ -107,7 +107,7 @@ test('Wrap "analyzeCommits" plugin in a function that validate the output of the
     {}
   );
 
-  const error = await t.throws(plugin());
+  const error = await t.throws(plugin({options: {}}));
 
   t.is(error.code, 'EANALYZECOMMITSOUTPUT');
   t.is(error.name, 'SemanticReleaseError');
@@ -125,7 +125,7 @@ test('Wrap "generateNotes" plugin in a function that validate the output of the
     {}
   );
 
-  const error = await t.throws(plugin());
+  const error = await t.throws(plugin({options: {}}));
 
   t.is(error.code, 'EGENERATENOTESOUTPUT');
   t.is(error.name, 'SemanticReleaseError');
@@ -143,7 +143,7 @@ test('Wrap "publish" plugin in a function that validate the output of the plugin
     {}
   );
 
-  const error = await t.throws(plugin());
+  const error = await t.throws(plugin({options: {}}));
 
   t.is(error.code, 'EPUBLISHOUTPUT');
   t.is(error.name, 'SemanticReleaseError');
@@ -157,7 +157,7 @@ test('Plugin is called with "pluginConfig" (with object definition) and input',
   const pluginConf = {path: pluginFunction, conf: 'confValue'};
   const options = {global: 'globalValue'};
   const plugin = normalize({cwd, options, logger: t.context.logger}, '', pluginConf, {});
-  await plugin({param: 'param'});
+  await plugin({options: {}, param: 'param'});
 
   t.true(
     pluginFunction.calledWithMatch(
@@ -172,7 +172,7 @@ test('Plugin is called with "pluginConfig" (with array definition) and input', a
   const pluginConf = [pluginFunction, {conf: 'confValue'}];
   const options = {global: 'globalValue'};
   const plugin = normalize({cwd, options, logger: t.context.logger}, '', pluginConf, {});
-  await plugin({param: 'param'});
+  await plugin({options: {}, param: 'param'});
 
   t.true(
     pluginFunction.calledWithMatch(
@@ -189,7 +189,7 @@ test('Prevent plugins to modify "pluginConfig"', async t => {
   const pluginConf = {path: pluginFunction, conf: {subConf: 'originalConf'}};
   const options = {globalConf: {globalSubConf: 'originalGlobalConf'}};
   const plugin = normalize({cwd, options, logger: t.context.logger}, '', pluginConf, {});
-  await plugin();
+  await plugin({options: {}});
 
   t.is(pluginConf.conf.subConf, 'originalConf');
   t.is(options.globalConf.globalSubConf, 'originalGlobalConf');
@@ -199,7 +199,7 @@ test('Prevent plugins to modify its input', async t => {
   const pluginFunction = stub().callsFake((pluginConfig, options) => {
     options.param.subParam = 'otherParam';
   });
-  const input = {param: {subParam: 'originalSubParam'}};
+  const input = {param: {subParam: 'originalSubParam'}, options: {}};
   const plugin = normalize({cwd, options: {}, logger: t.context.logger}, '', pluginFunction, {});
   await plugin(input);
 
@@ -220,7 +220,7 @@ test('Always pass a defined "pluginConfig" for plugin defined with string', asyn
     './test/fixtures/plugin-result-config',
     {}
   );
-  const pluginResult = await plugin();
+  const pluginResult = await plugin({options: {}});
 
   t.deepEqual(pluginResult.pluginConfig, {});
 });
@@ -233,7 +233,7 @@ test('Always pass a defined "pluginConfig" for plugin defined with path', async
     {path: './test/fixtures/plugin-result-config'},
     {}
   );
-  const pluginResult = await plugin();
+  const pluginResult = await plugin({options: {}});
 
   t.deepEqual(pluginResult.pluginConfig, {});
 });

test/plugins/plugins.test.js

@@ -63,14 +63,14 @@ test('Export plugins based on "plugins" config (array)', async t => {
     {}
   );
 
-  await plugins.verifyConditions({});
+  await plugins.verifyConditions({options: {}});
   t.true(plugin1.verifyConditions.calledOnce);
   t.true(plugin2.verifyConditions.calledOnce);
 
-  await plugins.publish({});
+  await plugins.publish({options: {}});
   t.true(plugin1.publish.calledOnce);
 
-  await plugins.verifyRelease({});
+  await plugins.verifyRelease({options: {}});
   t.true(plugin2.verifyRelease.notCalled);
 
   // Verify the module returns a function for each plugin
@@ -88,10 +88,10 @@ test('Export plugins based on "plugins" config (single definition)', async t =>
   const plugin1 = {verifyConditions: stub(), publish: stub()};
   const plugins = getPlugins({cwd, logger: t.context.logger, options: {plugins: plugin1}}, {});
 
-  await plugins.verifyConditions({});
+  await plugins.verifyConditions({options: {}});
   t.true(plugin1.verifyConditions.calledOnce);
 
-  await plugins.publish({});
+  await plugins.publish({options: {}});
   t.true(plugin1.publish.calledOnce);
 
   // Verify the module returns a function for each plugin
@@ -105,26 +105,6 @@ test('Export plugins based on "plugins" config (single definition)', async t =>
   t.is(typeof plugins.fail, 'function');
 });
 
-test('Use only last definition of single plugin steps declared in "plugins" config', async t => {
-  const plugin1 = {analyzeCommits: stub()};
-  const plugin2 = {analyzeCommits: stub()};
-  const plugins = getPlugins({cwd, logger: t.context.logger, options: {plugins: [plugin1, plugin2]}}, {});
-
-  await plugins.analyzeCommits({commits: []});
-  t.true(plugin1.analyzeCommits.notCalled);
-  t.true(plugin2.analyzeCommits.calledOnce);
-
-  // Verify the module returns a function for each plugin
-  t.is(typeof plugins.verifyConditions, 'function');
-  t.is(typeof plugins.analyzeCommits, 'function');
-  t.is(typeof plugins.verifyRelease, 'function');
-  t.is(typeof plugins.generateNotes, 'function');
-  t.is(typeof plugins.prepare, 'function');
-  t.is(typeof plugins.publish, 'function');
-  t.is(typeof plugins.success, 'function');
-  t.is(typeof plugins.fail, 'function');
-});
-
 test('Merge global options, "plugins" options and step options', async t => {
   const plugin1 = [{verifyConditions: stub(), publish: stub()}, {pluginOpt1: 'plugin1'}];
   const plugin2 = [{verifyConditions: stub()}, {pluginOpt2: 'plugin2'}];
@@ -138,14 +118,14 @@ test('Merge global options, "plugins" options and step options', async t => {
     {}
   );
 
-  await plugins.verifyConditions({});
+  await plugins.verifyConditions({options: {}});
   t.deepEqual(plugin1[0].verifyConditions.args[0][0], {globalOpt: 'global', pluginOpt1: 'plugin1'});
   t.deepEqual(plugin2[0].verifyConditions.args[0][0], {globalOpt: 'global', pluginOpt2: 'plugin2'});
 
-  await plugins.publish({});
+  await plugins.publish({options: {}});
   t.deepEqual(plugin1[0].publish.args[0][0], {globalOpt: 'global', pluginOpt1: 'plugin1'});
 
-  await plugins.verifyRelease({});
+  await plugins.verifyRelease({options: {}});
   t.deepEqual(plugin3[0].args[0][0], {globalOpt: 'global', pluginOpt3: 'plugin3'});
 });
 
@@ -268,7 +248,7 @@ test('Merge global options with plugin options', async t => {
     {}
   );
 
-  const [result] = await plugins.verifyRelease();
+  const [result] = await plugins.verifyRelease({options: {}});
 
   t.deepEqual(result.pluginConfig, {localOpt: 'local', globalOpt: 'global', otherOpt: 'locally-defined'});
 });

test/plugins/utils.test.js

@@ -25,7 +25,7 @@ test('validatePlugin', t => {
   t.false(validatePlugin({path: 1}), 'Object definition, wrong path');
 });
 
-test('validateStep: multiple/optional plugin configuration', t => {
+test('validateStep: optional plugin configuration', t => {
   const type = {multiple: true, required: false};
 
   // Empty config
@@ -107,8 +107,8 @@ test('validateStep: multiple/optional plugin configuration', t => {
   );
 });
 
-test('validateStep: multiple/required plugin configuration', t => {
-  const type = {multiple: true, required: true};
+test('validateStep: required plugin configuration', t => {
+  const type = {required: true};
 
   // Empty config
   t.false(validateStep(type));
@@ -189,98 +189,6 @@ test('validateStep: multiple/required plugin configuration', t => {
   );
 });
 
-test('validateStep: single/required plugin configuration', t => {
-  const type = {multiple: false, required: true};
-
-  // Empty config
-  t.false(validateStep(type));
-  t.false(validateStep(type, []));
-
-  // Single value definition
-  t.true(validateStep(type, 'plugin-path.js'));
-  t.true(validateStep(type, () => {}));
-  t.true(validateStep(type, ['plugin-path.js']));
-  t.true(validateStep(type, [() => {}]));
-  t.false(validateStep(type, {}));
-  t.false(validateStep(type, [{}]));
-
-  // Array type definition
-  t.true(validateStep(type, [['plugin-path.js']]));
-  t.true(validateStep(type, [['plugin-path.js', {options: 'value'}]]));
-  t.true(validateStep(type, [[() => {}, {options: 'value'}]]));
-  t.false(validateStep(type, [['plugin-path.js', 1]]));
-
-  // Object type definition
-  t.true(validateStep(type, {path: 'plugin-path.js'}));
-  t.true(validateStep(type, {path: 'plugin-path.js', options: 'value'}));
-  t.true(validateStep(type, {path: () => {}, options: 'value'}));
-  t.false(validateStep(type, {path: null}));
-
-  // Considered as one Array definition and not as an Array of 2 definitions in case of single plugin type
-  t.true(validateStep(type, [() => {}, {options: 'value'}]));
-  t.true(validateStep(type, ['plugin-path.js', {options: 'value'}]));
-
-  // Multiple definitions
-  t.false(
-    validateStep(type, [
-      'plugin-path.js',
-      () => {},
-      ['plugin-path.js'],
-      ['plugin-path.js', {options: 'value'}],
-      [() => {}, {options: 'value'}],
-      {path: 'plugin-path.js'},
-      {path: 'plugin-path.js', options: 'value'},
-      {path: () => {}, options: 'value'},
-    ])
-  );
-});
-
-test('validateStep: single/optional plugin configuration', t => {
-  const type = {multiple: false, required: false};
-
-  // Empty config
-  t.true(validateStep(type));
-  t.true(validateStep(type, []));
-
-  // Single value definition
-  t.true(validateStep(type, 'plugin-path.js'));
-  t.true(validateStep(type, () => {}));
-  t.true(validateStep(type, ['plugin-path.js']));
-  t.true(validateStep(type, [() => {}]));
-  t.false(validateStep(type, {}));
-  t.false(validateStep(type, [{}]));
-
-  // Array type definition
-  t.true(validateStep(type, [['plugin-path.js']]));
-  t.true(validateStep(type, [['plugin-path.js', {options: 'value'}]]));
-  t.true(validateStep(type, [[() => {}, {options: 'value'}]]));
-  t.false(validateStep(type, [['plugin-path.js', 1]]));
-
-  // Object type definition
-  t.true(validateStep(type, {path: 'plugin-path.js'}));
-  t.true(validateStep(type, {path: 'plugin-path.js', options: 'value'}));
-  t.true(validateStep(type, {path: () => {}, options: 'value'}));
-  t.false(validateStep(type, {path: null}));
-
-  // Considered as one Array definition and not as an Array of 2 definitions in case of single plugin type
-  t.true(validateStep(type, [() => {}, {options: 'value'}]));
-  t.true(validateStep(type, ['plugin-path.js', {options: 'value'}]));
-
-  // Multiple definitions
-  t.false(
-    validateStep(type, [
-      'plugin-path.js',
-      () => {},
-      ['plugin-path.js'],
-      ['plugin-path.js', {options: 'value'}],
-      [() => {}, {options: 'value'}],
-      {path: 'plugin-path.js'},
-      {path: 'plugin-path.js', options: 'value'},
-      {path: () => {}, options: 'value'},
-    ])
-  );
-});
-
 test('loadPlugin', t => {
   const cwd = process.cwd();
   const func = () => {};