fix(package): update hosted-git-info to version 2.7.1

`verifyConditions` explanation was wrong previously.

.github/ISSUE_TEMPLATE.md

@@ -1,48 +0,0 @@
-<!--
-Please fill the informations requested or use one of the following url:
-  - Bug report: https://github.com/semantic-release/semantic-release/issues/new?template=bug-report.md
-  - Feature request: https://github.com/semantic-release/semantic-release/issues/new?template=feature-request.md
-  - New plugin request: https://github.com/semantic-release/semantic-release/issues/new?template=plugin-request.md
--->
-
-<!--------------------- FOR BUG REPORT ONLY --------------------->
-
-## Current behavior
-
-<!-- Describe how the issue manifests. -->
-
-## Expected behavior
-
-<!-- Describe what the desired behavior would be. -->
-
-## Environment
-
-- **semantic-release** version: <!-- Version set in package.json devDpendencies -->
-- CI environment: <!-- CI service name -->
-- Plugins used: <!-- List semantic-release plugin used if any -->
-- **semantic-release** configuration: <!-- link to your repository or relevant part of the semantic-release config -->
-- CI logs: <!-- link to your CI logs or semantic-release logs -->
-
-<!--------------------- FOR FEATURE REQUEST ONLY --------------------->
-
-## New feature motivation
-
-<!-- Describe the context, the use-case and the advantages of the feature request. -->
-
-## New feature description
-
-<!-- Describe the functional changes that would have to be made in semantic-release or its plugins. -->
-
-## New feature implementation
-
-<!-- Optionally describe the technical changes to be made in semantic-release or its plugins. -->
-
-<!--------------------- FOR NEW PLUGIN REQUEST ONLY --------------------->
-
-## New plugin motivation
-
-<!-- Describe the reasons to create a new plugin and why it's not covered by the existing ones. -->
-
-## Third-party documentation
-
-<!-- Provide explanation and documentation links for the platform to integrate with. -->

.github/ISSUE_TEMPLATE/01_bug_report.md

@@ -1,17 +1,21 @@
-# Bug report
-
-## Current behavior
-
-<!-- Describe how the issue manifests. -->
-
-## Expected behavior
-
-<!-- Describe what the desired behavior would be. -->
-
-## Environment
-
-- **semantic-release** version: <!-- Version set in package.json devDpendencies -->
-- CI environment: <!-- CI service name -->
-- Plugins used: <!-- List semantic-release plugin used if any -->
-- **semantic-release** configuration: <!-- link to your repository or relevant part of the semantic-release config -->
-- CI logs: <!-- link to your CI logs or semantic-release logs -->
+---
+name: Bug report
+about: Something not working as expected
+
+---
+
+## Current behavior
+
+<!-- Describe how the issue manifests. -->
+
+## Expected behavior
+
+<!-- Describe what the desired behavior would be. -->
+
+## Environment
+
+- **semantic-release** version: <!-- Version set in package.json devDpendencies -->
+- CI environment: <!-- CI service name -->
+- Plugins used: <!-- List semantic-release plugin used if any -->
+- **semantic-release** configuration: <!-- link to your repository or relevant part of the semantic-release config -->
+- CI logs: <!-- link to your CI logs or semantic-release logs -->

.github/ISSUE_TEMPLATE/02_feature_request.md

@@ -1,13 +1,17 @@
-# Feature request
-
-## New feature motivation
-
-<!-- Describe the context, the use-case and the advantages of the feature request. -->
-
-## New feature description
-
-<!-- Describe the functional changes that would have to be made in semantic-release or its plugins. -->
-
-## New feature implementation
-
-<!-- Optionally describe the technical changes to be made in semantic-release or its plugins. -->
+---
+name: Feature request
+about: Wouldn’t it be nice if semantic-release could ...
+
+---
+
+## New feature motivation
+
+<!-- Describe the context, the use-case and the advantages of the feature request. -->
+
+## New feature description
+
+<!-- Describe the functional changes that would have to be made in semantic-release or its plugins. -->
+
+## New feature implementation
+
+<!-- Optionally describe the technical changes to be made in semantic-release or its plugins. -->

.github/ISSUE_TEMPLATE/03_plugin_suggestion.md

@@ -1,9 +1,13 @@
-# New plugin request
-
-## New plugin motivation
-
-<!-- Describe the reasons to create a new plugin and why it's not covered by the existing ones. -->
-
-## Third-party documentation
-
-<!-- Provide explanation and documentation links for the platform to integrate with. -->
+---
+name: New plugin suggestion
+about: Integrate with a new platform, etc
+
+---
+
+## New plugin motivation
+
+<!-- Describe the reasons to create a new plugin and why it's not covered by the existing ones. -->
+
+## Third-party documentation
+
+<!-- Provide explanation and documentation links for the platform to integrate with. -->

.travis.yml

@@ -4,7 +4,7 @@ services:
   - docker
 
 node_js:
-  - 9
+  - 10
   - 8
 
 # Trigger a push build on caribou and greenkeeper branches + PRs build on every branches

README.md

@@ -68,9 +68,9 @@ Here is an example of the release type that will be done based on a commit messa
 
 ### Triggering a release
 
-When pushing new commits to the release branch (i.e. `master`) with `git push` or by merging a pull request or merging from another branch, a CI build is triggered and runs the `semantic-release` command to make a release if there are relevant codebase changes since the last release.
+For each new commits added to the release branch (i.e. `master`) with `git push` or by merging a pull request or merging from another branch, a CI build is triggered and runs the `semantic-release` command to make a release if there are codebase changes since the last release that affect the package functionalities.
 
-By default a release will be done for each push to the release branch that contains relevant code changes. If you need more control over the timing of releases you have a couple of options:
+If you need more control over the timing of releases you have a couple of options:
 - Publish releases on a distribution channel (for example npm’s [dist-tags](https://docs.npmjs.com/cli/dist-tag)). This way you can keep control over what your users end up using by default, and you can decide when to make an automatically released version available to the stable channel, and promote it.
 - Develop on a `dev` branch and merge it to the release branch (i.e. `master`) once you are ready to publish. **semantic-release** will run only on pushes to the release branch.
 
@@ -83,11 +83,11 @@ After running the tests the command `semantic-release` will execute the followin
 | Verify Conditions | Verify all the conditions to proceed with the release with the [verify conditions plugins](docs/usage/plugins.md#verifyconditions-plugin).                            |
 | Get last release  | Obtain the commit corresponding to the last release by analyzing [Git tags](https://git-scm.com/book/en/v2/Git-Basics-Tagging).                                       |
 | Analyze commits   | Determine the type of release with the [analyze commits plugin](docs/usage/plugins.md#analyzecommits-plugin) based on the commits added since the last release.       |
-| Verify release    | Verify the release conformity with the [verify release plugins](docs/usage/plugins.md#verifyrelease-plugin).                                                           |
+| Verify release    | Verify the release conformity with the [verify release plugins](docs/usage/plugins.md#verifyrelease-plugin).                                                          |
 | Generate notes    | Generate release notes with the [generate notes plugin](docs/usage/plugins.md#generatenotes-plugin) for the commits added since the last release.                     |
 | Create Git tag    | Create a Git tag corresponding to the new release version                                                                                                             |
-| Prepare           | Prepare the release with the [prepare plugins](docs/usage/plugins.md#prepare-plugin).                                                                                  |
-| Publish           | Publish the release with the [publish plugins](docs/usage/plugins.md#publish-plugin).                                                                                  |
+| Prepare           | Prepare the release with the [prepare plugins](docs/usage/plugins.md#prepare-plugin).                                                                                 |
+| Publish           | Publish the release with the [publish plugins](docs/usage/plugins.md#publish-plugin).                                                                                 |
 | Notify            | Notify of new releases or errors with the [success](docs/usage/plugins.md#success-plugin) and [fail](docs/usage/plugins.md#fail-plugin) plugins.                      |
 
 ## Documentation

bin/semantic-release.js

@@ -3,11 +3,15 @@
 // Bad news: We have to write plain ES5 in this file
 // Good news: It's the only file of the entire project
 
-/* eslint-disable no-var */
+/* eslint-disable no-var, promise/prefer-await-to-then, prefer-destructuring */
 
 var semver = require('semver');
+var execa = require('execa');
+var findVersions = require('find-versions');
 var pkg = require('../package.json');
 
+var MIN_GIT_VERSION = '2.0.0';
+
 if (!semver.satisfies(process.version, pkg.engines.node)) {
   console.error(
     `[semantic-release]: node version ${pkg.engines.node} is required. Found ${process.version}.
@@ -17,6 +21,21 @@ See https://github.com/semantic-release/semantic-release/blob/caribou/docs/suppo
   process.exit(1);
 }
 
+execa
+  .stdout('git', ['--version'])
+  .then(stdout => {
+    var gitVersion = findVersions(stdout)[0];
+    if (semver.lt(gitVersion, MIN_GIT_VERSION)) {
+      console.error(`[semantic-release]: Git version ${MIN_GIT_VERSION} is required. Found ${gitVersion}.`);
+      process.exit(1);
+    }
+  })
+  .catch(err => {
+    console.error(`[semantic-release]: Git version ${MIN_GIT_VERSION} is required. No git binary found.`);
+    console.error(err);
+    process.exit(1);
+  });
+
 // Node 8+ from this point on
 require('../cli')().catch(() => {
   process.exitCode = 1;

cli.js

@@ -1,5 +1,3 @@
-const {pickBy, isUndefined} = require('lodash');
-
 const stringList = {
   type: 'string',
   array: true,
@@ -13,6 +11,7 @@ module.exports = async () => {
   const cli = require('yargs')
     .command('$0', 'Run automated package publishing', yargs => {
       yargs.demandCommand(0, 0).usage(`Run automated package publishing
+
 Usage:
   semantic-release [options] [plugins]`);
     })
@@ -20,7 +19,7 @@ Usage:
     .option('r', {alias: 'repository-url', describe: 'Git repository URL', type: 'string', group: 'Options'})
     .option('t', {alias: 'tag-format', describe: 'Git tag format', type: 'string', group: 'Options'})
     .option('e', {alias: 'extends', describe: 'Shareable configurations', ...stringList, group: 'Options'})
-    .option('ci', {describe: 'Toggle CI verifications', default: undefined, type: 'boolean', group: 'Options'})
+    .option('ci', {describe: 'Toggle CI verifications', type: 'boolean', group: 'Options'})
     .option('verify-conditions', {...stringList, group: 'Plugins'})
     .option('analyze-commits', {type: 'string', group: 'Plugins'})
     .option('verify-release', {...stringList, group: 'Plugins'})
@@ -29,16 +28,15 @@ Usage:
     .option('publish', {...stringList, group: 'Plugins'})
     .option('success', {...stringList, group: 'Plugins'})
     .option('fail', {...stringList, group: 'Plugins'})
-    .option('debug', {describe: 'Output debugging information', default: undefined, type: 'boolean', group: 'Options'})
-    .option('d', {alias: 'dry-run', describe: 'Skip publishing', default: undefined, type: 'boolean', group: 'Options'})
-    .option('h', {alias: 'help', default: undefined, group: 'Options'})
-    .option('v', {alias: 'version', default: undefined, group: 'Options'})
+    .option('debug', {describe: 'Output debugging information', type: 'boolean', group: 'Options'})
+    .option('d', {alias: 'dry-run', describe: 'Skip publishing', type: 'boolean', group: 'Options'})
+    .option('h', {alias: 'help', group: 'Options'})
+    .option('v', {alias: 'version', group: 'Options'})
     .strict(false)
     .exitProcess(false);
 
   try {
-    // Remove option with undefined values, as yargs sets non defined options as `undefined`
-    const {help, version, ...opts} = pickBy(cli.argv, value => !isUndefined(value));
+    const {help, version, ...opts} = cli.argv;
 
     if (Boolean(help) || Boolean(version)) {
       process.exitCode = 0;

docs/extending/plugins-list.md

@@ -37,8 +37,16 @@
 
 [Open a Pull Request](https://github.com/semantic-release/semantic-release/blob/caribou/CONTRIBUTING.md#submitting-a-pull-request) to add your plugin to the list.
 
-- [semantic-release-docker](https://github.com/felixfbecker/semantic-release-docker) Set of semantic-release plugins for publishing a docker image to Docker Hub (tested on semantic-release **^11.0.0**)
+- [semantic-release-docker](https://github.com/felixfbecker/semantic-release-docker) Set of semantic-release plugins for publishing a docker image to Docker Hub
   - [verifyConditions](https://github.com/felixfbecker/semantic-release-docker#verifyconditions) Verify that all needed configuration is present and login to the Docker registry.
   - [publish](https://github.com/felixfbecker/semantic-release-docker#publish) Tag the image specified by `name` with the new version, push it to Docker Hub and update the latest tag.
+- [semantic-release-vsce](https://github.com/raix/semantic-release-vsce) Set of semantic-release plugins for publishing Visual Studio Code extensions to the marketplace
+  - **verifyConditions** Verify the presence and the validity of the vsce authentication and release configuration
+  - **prepare** Create a `.vsix` for distribution
+  - **publish** Publish the package to the Visual Studio Code marketplace
 - [semantic-release-verify-deps](https://github.com/piercus/semantic-release-verify-deps) 
   - [verifyConditions](https://github.com/piercus/semantic-release-verify-deps) Check the dependencies format against a regexp before a release
+- [semantic-release-chrome](https://github.com/GabrielDuarteM/semantic-release-chrome) Set of semantic-release plugins for publishing a Chrome extension release.
+  - [verifyConditions](https://github.com/GabrielDuarteM/semantic-release-chrome#verifyconditions) Verify the presence of the authentication (set via environment variables).
+  - [prepare](https://github.com/GabrielDuarteM/semantic-release-chrome#prepare) Write the correct version to the manifest.json and creates a zip file of the whole dist folder.
+  - [publish](https://github.com/GabrielDuarteM/semantic-release-chrome#publish) Uploads the generated zip file to the webstore, and publish the item.

docs/recipes/circleci-workflows.md

@@ -59,7 +59,7 @@ A `package.json` is required only for [local](../usage/installation.md#local-ins
 ```json
 {
   "devDependencies": {
-    "semantic-release": "^12.0.0"
+    "semantic-release": "^15.0.0"
   }
 }
 ```

docs/recipes/git-auth-ssh-keys.md

@@ -4,6 +4,8 @@ When using [environment variables](../usage/ci-configuration.md#authentication)
 
 Alternatively the Git repository can be accessed via [SSH](https://git-scm.com/book/en/v2/Git-on-the-Server-The-Protocols#_the_ssh_protocol) by creating SSH keys, adding the public one to your Git hosted account and making the private one available on the CI environment.
 
+**Note:** SSH keys allow to push the [Git release tag](https://git-scm.com/book/en/v2/Git-Basics-Tagging) associated to the released version. Some plugins might also require an API token. See each plugin documentation for additional information.
+
 ## Generating the SSH keys
 
 In your local repository root:

docs/recipes/gitlab-ci.md

@@ -51,7 +51,7 @@ A `package.json` is required only for [local](../usage/installation.md#local-ins
 ```json
 {
   "devDependencies": {
-    "semantic-release": "^12.0.0"
+    "semantic-release": "^15.0.0"
   }
 }
 ```

docs/recipes/travis-build-stages.md

@@ -48,7 +48,7 @@ A `package.json` is required only for [local](../usage/installation.md#local-ins
 ```json
 {
   "devDependencies": {
-    "semantic-release": "^12.0.0"
+    "semantic-release": "^15.0.0"
   }
 }
 ```

docs/recipes/travis.md

@@ -83,8 +83,8 @@ A `package.json` is required only for [local](../usage/installation.md#local-ins
 ```json
 {
   "devDependencies": {
-    "semantic-release": "^12.0.0",
-    "travis-deploy-once": "^4.0.0"
+    "semantic-release": "^15.0.0",
+    "travis-deploy-once": "^5.0.0"
   }
 }
 ```

docs/support/FAQ.md

@@ -164,6 +164,21 @@ You can trigger a release by pushing to your Git repository. You deliberately ca
 
 Yes, every commits that contains `[skip release]` or `[release skip]` in their message will be excluded from the commit analysis and won't participate in the release type determination.
 
+## How can I change the type of commits that trigger a release?
+
+By default **semantic-release** uses the [Angular Commit Message Conventions](https://github.com/angular/angular.js/blob/master/DEVELOPERS.md#-git-commit-guidelines) and triggers releases based on the following rules:
+
+| Commit                      | Release type               |
+|-----------------------------|----------------------------|
+| Commit with breaking change | ~~Major~~ Breaking release |
+| Commit with type `feat`     | ~~Minor~~ Feature release  |
+| Commit with type `fix`      | Patch release              |
+| Commit with type `perf`     | Patch release              |
+
+See the [`@semantic-release/npm`](https://github.com/semantic-release/npm#npm-configuration) plugin documentation for more details.
+
+This is fully customizable with the [`@semantic-release/commit-analyzer`](https://github.com/semantic-release/commit-analyzer) plugin's [`release-rules` option](https://github.com/semantic-release/commit-analyzer#release-rules).
+
 ## Is it *really* a good idea to release on every push?
 
 It is indeed a great idea because it *forces* you to follow best practices. If you don’t feel comfortable releasing every feature or fix on your `master` you might not treat your `master` branch as intended.
@@ -174,6 +189,8 @@ From [Understanding the GitHub Flow](https://guides.github.com/introduction/flow
 
 If you need more control over the timing of releases, see [Triggering a release](../../README.md#triggering-a-release) for different options.
 
+**Note**: Only the codebase changes altering the published package will trigger a release (for example new features, bug fixes or performance improvements would trigger a release while refactoring or changing code style would not). See [How can I change the type of commits that trigger a release?](#how-can-i-change-the-type-of-commits-that-trigger-a-release) for more details.
+
 ## Can I set the initial release version of my package to `0.0.1`?
 
 This is not supported by **semantic-release** as it's not considered a good practice, mostly because [Semantic Versioning](https://semver.org) rules applies differently to major version zero.
@@ -194,7 +211,7 @@ In addition the [verify conditions step](../../README.md#release-steps) verifies
 
 See [Node version requirement](../support/node-version.md#node-version-requirement) for more details and solutions.
 
-# What is npx?
+## What is npx?
 
 [`npx`](https://www.npmjs.com/package/npx) – short for "npm exec" – is a CLI to find and execute npm binaries within the local `node_modules` folder or in the $PATH. If a binary can't be located npx will download the required package and execute it from its cache location.
 The tool is bundled with [npm](https://www.npmjs.com/package/npm) >= 5.2, or can be installed via `npm install -g npx`.

docs/support/troubleshooting.md

@@ -29,3 +29,28 @@ You can recover from that issue by identifying the commit in your branch history
 $ git tag -f v<version of the last release> <commit sha1 corresponding to last release>
 $ git push -f --tags origin <your release branch>
 ```
+
+## You do not have permission to publish 'package-name'
+
+When running semantic-release you may encounter the following error:
+
+```
+An error occurred while running semantic-release: { Error: Command failed: npm publish ./. --registry https://registry.npmjs.org/
+npm ERR! publish Failed PUT 403
+npm ERR! code E403
+npm ERR! You do not have permission to publish "<package-name>". Are you logged in as the correct user? : <package-name>
+```
+
+This message is a little unclear, and might not have anything to with your `NPM_TOKEN` or authentication method. It might instead be related to the package name itself. If there is already a package with the same name as yours or, there is a very close match, it could trigger this error.
+
+Best way to be sure, is to search [npmjs.org](https://www.npmjs.com/)) using your package name. If there is a name conflict, rename your package in your `package.json`
+
+## Squashed commits are ignored by **semantic-release**
+
+**semantic-release** parses commits according to a [commit message convention](https://github.com/semantic-release/semantic-release#commit-message-format) to figure out how they affect the codebase. Commits that doesn't follow the project's commit message convention are simply ignored.
+
+When [squashing commits](https://git-scm.com/book/en/v2/Git-Tools-Rewriting-History#_squashing) most Git tools will by default generate a new commit message with a summary of the squashed commits. This commit message will most likely not be compliant with the project's commit message convention and therefore will be ignored by **semantic-release**.
+
+When squashing commits make sure to rewrite the resulting commit message to be compliant with the project's commit message convention.
+
+**Note**: if the resulting squashed commit would encompasses multiple changes (for example multiple unrelated features or fixes) then it's probably not a good idea to squash those commits together. A commit should contain exactly one self-contained functional change and a functional change should be contained in exactly one commit. See [atomic commits](https://en.wikipedia.org/wiki/Atomic_commit).

docs/usage/ci-configuration.md

@@ -10,13 +10,14 @@ See [CI configuration recipes](../recipes/README.md#ci-configurations) for more
 
 **semantic-release** requires push access to the project Git repository in order to create [Git tags](https://git-scm.com/book/en/v2/Git-Basics-Tagging). The Git authentication can be set with one of the following environment variables:
 
-| Variable                     | Description                                                                                                                   |
-|------------------------------|-------------------------------------------------------------------------------------------------------------------------------|
-| `GH_TOKEN` or `GITHUB_TOKEN` | A GitHub [personal access token](https://help.github.com/articles/creating-a-personal-access-token-for-the-command-line).     |
-| `GL_TOKEN` or `GITLAB_TOKEN` | A GitLab [personal access token](https://docs.gitlab.com/ce/user/profile/personal_access_tokens.html).                        |
-| `GIT_CREDENTIALS`            | [URL encoded basic HTTP Authentication](https://en.wikipedia.org/wiki/Basic_access_authentication#URL_encoding) credentials). |
+| Variable                        | Description                                                                                                                   |
+|---------------------------------|-------------------------------------------------------------------------------------------------------------------------------|
+| `GH_TOKEN` or `GITHUB_TOKEN`    | A GitHub [personal access token](https://help.github.com/articles/creating-a-personal-access-token-for-the-command-line).     |
+| `GL_TOKEN` or `GITLAB_TOKEN`    | A GitLab [personal access token](https://docs.gitlab.com/ce/user/profile/personal_access_tokens.html).                        |
+| `BB_TOKEN` or `BITBUCKET_TOKEN` | A Bitbucket [personal access token](https://confluence.atlassian.com/bitbucketserver/personal-access-tokens-939515499.html).  |
+| `GIT_CREDENTIALS`               | [URL encoded basic HTTP Authentication](https://en.wikipedia.org/wiki/Basic_access_authentication#URL_encoding) credentials). |
 
-`GIT_CREDENTIALS` can be the Git username and password in the format `<username>:<password>` or a token for certain Git providers like [Bitbucket](https://confluence.atlassian.com/bitbucketserver/personal-access-tokens-939515499.html).
+`GIT_CREDENTIALS` must be the Git username and password in the format `<username>:<password>`.
 
 Alternatively the Git authentication can be set up via [SSH keys](../recipes/git-auth-ssh-keys.md).
 

docs/usage/configuration.md

@@ -6,7 +6,7 @@ In order to customize **semantic-release**’s behavior, [options](#options) and
 - A `release` key in the project's `package.json` file
 - CLI arguments
 
-The following two examples are the same.
+The following three examples are the same.
 
 Via CLI argument:
 
@@ -17,7 +17,20 @@ $ semantic-release --branch next
 Via `release` key in the project's `package.json` file:
 
 ```json
-"release": {
+{
+  "release": {
+    "branch": "next"
+  }
+}
+```
+```bash
+$ semantic-release
+```
+
+Via `.releaserc` file:
+
+```json
+{
   "branch": "next"
 }
 ```
@@ -29,6 +42,17 @@ $ semantic-release
 
 **Note**: Plugin options cannot be defined via CLI arguments and must be defined in the configuration file.
 
+**Note**: When configuring via `package.json`, the configuration must be under the `release` property. However, when using a `.releaserc` or a `release.config.js` file, the configuration must be set without a `release` property.
+
+## Environment variables
+
+| Variable              | Description                                                                                                                                                                                                                    | Default                              |
+|-----------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------|
+| `GIT_AUTHOR_NAME`     | The author name associated with the [Git release tag](https://git-scm.com/book/en/v2/Git-Basics-Tagging). See [Git environment variables](https://git-scm.com/book/en/v2/Git-Internals-Environment-Variables#_committing).     | @semantic-release-bot.               |
+| `GIT_AUTHOR_EMAIL`    | The author email associated with the [Git release tag](https://git-scm.com/book/en/v2/Git-Basics-Tagging). See [Git environment variables](https://git-scm.com/book/en/v2/Git-Internals-Environment-Variables#_committing).    | @semantic-release-bot email address. |
+| `GIT_COMMITTER_NAME`  | The committer name associated with the [Git release tag](https://git-scm.com/book/en/v2/Git-Basics-Tagging). See [Git environment variables](https://git-scm.com/book/en/v2/Git-Internals-Environment-Variables#_committing).  | @semantic-release-bot.               |
+| `GIT_COMMITTER_EMAIL` | The committer email associated with the [Git release tag](https://git-scm.com/book/en/v2/Git-Basics-Tagging). See [Git environment variables](https://git-scm.com/book/en/v2/Git-Internals-Environment-Variables#_committing). | @semantic-release-bot email address. |
+
 ## Options
 
 ### extends

docs/usage/installation.md

@@ -24,6 +24,6 @@ For other type of projects we recommend installing **semantic-release** directly
 $ npx semantic-release
 ```
 
-**Note:** For a global installation, it's recommended to specify the major **semantic-release** version to install (for example with with `npx semantic-release@12`, or `npm install -g semantic-release@12`). This way your build will not automatically use the next major **semantic-release** release that could possibly break your build. You will have to upgrade manually when a new major version is released.
+**Note:** For a global installation, it's recommended to specify the major **semantic-release** version to install (for example with with `npx semantic-release@15`, or `npm install -g semantic-release@15`). This way your build will not automatically use the next major **semantic-release** release that could possibly break your build. You will have to upgrade manually when a new major version is released.
 
-**Note:** `npx` is a tool bundled with `npm@>=5.2.0`. It is used to conveniently install the semantic-release binary and to execute it. See [What is npx](../support/FAQ.md#what-is-npx) for more details.
+**Note:** `npx` is a tool bundled with `npm@>=5.2.0`. It is used to conveniently install the semantic-release binary and to execute it. See [What is npx](../support/FAQ.md#what-is-npx) for more details.

docs/usage/plugins.md

@@ -2,6 +2,8 @@
 
 Each [release step](../../README.md#release-steps) is implemented within a plugin or a list of plugins that can be configured. This allows for support of different [commit message formats](../../README.md#commit-message-format), release note generators and publishing platforms.
 
+See [plugins list](../extending/plugins-list.md).
+
 ## Plugin types
 
 ### verifyConditions plugin
@@ -89,7 +91,7 @@ For example:
 With this configuration:
 - the `custom-plugin` npm module will be used to [analyze commits](#analyzecommits-plugin)
 - the `./build/my-plugin.js` script will be used to [generate release notes](#generatenotes-plugin)
-- the [`@semantic-release/exec`](https://github.com/semantic-release/exec),  [`@semantic-release/npm`](https://github.com/semantic-release/npm) and [`@semantic-release/exec`](https://github.com/semantic-release/exec) plugins will be used to [verify conditions](#verifyconditions-plugin)
+- the [`@semantic-release/exec`](https://github.com/semantic-release/exec),  [`@semantic-release/npm`](https://github.com/semantic-release/npm) and [`@semantic-release/github`](https://github.com/semantic-release/github) plugins will be used to [verify conditions](#verifyconditions-plugin)
 - the [`@semantic-release/exec`](https://github.com/semantic-release/exec) plugin will be used to [verify the release](#verifyrelease-plugin)
 - the `cmd` option will be set to `verify-conditions.sh` only for the [`@semantic-release/exec`](https://github.com/semantic-release/exec) plugin used to [verify conditions](#verifyconditions-plugin)
 - the `cmd` option will be set to `verify-release.sh` only for the [`@semantic-release/exec`](https://github.com/semantic-release/exec) plugin used to [verify the release](#verifyrelease-plugin)

docs/usage/shareable-configurations.md

@@ -3,3 +3,5 @@
 A sharable configuration is an [npm](https://www.npmjs.com/) package that exports a **semantic-release** configuration object. It allows for use of the same configuration across several projects.
 
 The shareable configurations to use can be set with the [extends](configuration.md#extends) option.
+
+See [shareable configurations list](../extending/shareable-configurations-list.md).

index.js

@@ -13,8 +13,9 @@ const getLastRelease = require('./lib/get-last-release');
 const {extractErrors} = require('./lib/utils');
 const getGitAuthUrl = require('./lib/get-git-auth-url');
 const logger = require('./lib/logger');
-const {unshallow, verifyAuth, gitHead: getGitHead, tag, push} = require('./lib/git');
+const {fetch, verifyAuth, isBranchUpToDate, gitHead: getGitHead, tag, push} = require('./lib/git');
 const getError = require('./lib/get-error');
+const {COMMIT_NAME, COMMIT_EMAIL} = require('./lib/definitions/constants');
 
 marked.setOptions({renderer: new TerminalRenderer()});
 
@@ -25,9 +26,16 @@ async function run(options, plugins) {
     logger.log('This run was not triggered in a known CI environment, running in dry-run mode.');
     options.dryRun = true;
   } else {
-    // When running on CI, prevent the `git` CLI to prompt for username/password. See #703.
-    process.env.GIT_ASKPASS = 'echo';
-    process.env.GIT_TERMINAL_PROMPT = 0;
+    // When running on CI, set the commits author and commiter info and prevent the `git` CLI to prompt for username/password. See #703.
+    process.env = {
+      GIT_AUTHOR_NAME: COMMIT_NAME,
+      GIT_AUTHOR_EMAIL: COMMIT_EMAIL,
+      GIT_COMMITTER_NAME: COMMIT_NAME,
+      GIT_COMMITTER_EMAIL: COMMIT_EMAIL,
+      ...process.env,
+      GIT_ASKPASS: 'echo',
+      GIT_TERMINAL_PROMPT: 0,
+    };
   }
 
   if (isCi && isPr && !options.noCi) {
@@ -47,7 +55,18 @@ async function run(options, plugins) {
   await verify(options);
 
   options.repositoryUrl = await getGitAuthUrl(options);
-  if (!await verifyAuth(options.repositoryUrl, options.branch)) {
+
+  try {
+    await verifyAuth(options.repositoryUrl, options.branch);
+  } catch (err) {
+    if (!(await isBranchUpToDate(options.repositoryUrl, options.branch))) {
+      logger.log(
+        "The local branch %s is behind the remote one, therefore a new version won't be published.",
+        options.branch
+      );
+      return false;
+    }
+    logger.error(`The command "${err.cmd}" failed with the error message %s.`, err.stderr);
     throw getError('EGITNOPERMISSION', {options});
   }
 
@@ -56,8 +75,7 @@ async function run(options, plugins) {
   logger.log('Call plugin %s', 'verify-conditions');
   await plugins.verifyConditions({options, logger}, {settleAll: true});
 
-  // Unshallow the repo in order to get all the tags
-  await unshallow();
+  await fetch(options.repositoryUrl);
 
   const lastRelease = await getLastRelease(options.tagFormat, logger);
   const commits = await getCommits(lastRelease.gitHead, options.branch, logger);
@@ -158,7 +176,7 @@ async function callFail(plugins, options, error) {
 
 module.exports = async opts => {
   logger.log(`Running %s version %s`, pkg.name, pkg.version);
-  const unhook = hookStd({silent: false}, hideSensitive);
+  const {unhook} = hookStd({silent: false}, hideSensitive);
   try {
     const config = await getConfig(opts, logger);
     const {plugins, options} = config;

lib/definitions/constants.js

@@ -0,0 +1,9 @@
+const RELEASE_TYPE = ['major', 'premajor', 'minor', 'preminor', 'patch', 'prepatch', 'prerelease'];
+
+const FIRST_RELEASE = '1.0.0';
+
+const COMMIT_NAME = 'semantic-release-bot';
+
+const COMMIT_EMAIL = 'semantic-release-bot@martynus.net';
+
+module.exports = {RELEASE_TYPE, FIRST_RELEASE, COMMIT_NAME, COMMIT_EMAIL};

lib/definitions/errors.js

@@ -2,7 +2,7 @@ const url = require('url');
 const {inspect} = require('util');
 const {toLower, isString} = require('lodash');
 const pkg = require('../../package.json');
-const RELEASE_TYPE = require('./release-types');
+const {RELEASE_TYPE} = require('./constants');
 
 const homepage = url.format({...url.parse(pkg.homepage), ...{hash: null}});
 const stringify = obj => (isString(obj) ? obj : inspect(obj, {breakLength: Infinity, depth: 2, maxArrayLength: 5}));
@@ -31,11 +31,13 @@ Please make sure to add the \`repositoryUrl\` to the [semantic-release configura
     message: 'The push permission to the Git repository is required.',
     details: `**semantic-release** cannot push the version tag to the branch \`${
       options.branch
-    }\` on remote Git repository.
+    }\` on remote Git repository with URL \`${options.repositoryUrl}\`.
 
 Please refer to the [authentication configuration documentation](${linkify(
       'docs/usage/ci-configuration.md#authentication'
-    )}) to configure the Git credentials on your CI environment.`,
+    )}) to configure the Git credentials on your CI environment and make sure the [repositoryUrl](${linkify(
+      'docs/usage/configuration.md#repositoryurl'
+    )}) is configured with a [valid Git URL](https://git-scm.com/book/en/v2/Git-on-the-Server-The-Protocols).`,
   }),
   EINVALIDTAGFORMAT: ({tagFormat}) => ({
     message: 'Invalid `tagFormat` option.',

lib/definitions/plugins.js

@@ -1,5 +1,5 @@
 const {isString, isFunction, isArray, isPlainObject} = require('lodash');
-const RELEASE_TYPE = require('./release-types');
+const {RELEASE_TYPE} = require('./constants');
 
 const validatePluginConfig = conf => isString(conf) || isString(conf.path) || isFunction(conf);
 
@@ -45,7 +45,7 @@ module.exports = {
   publish: {
     default: ['@semantic-release/npm', '@semantic-release/github'],
     config: {
-      validator: conf => Boolean(conf) && (isArray(conf) ? conf : [conf]).every(conf => validatePluginConfig(conf)),
+      validator: conf => !conf || (isArray(conf) ? conf : [conf]).every(conf => validatePluginConfig(conf)),
     },
     output: {
       validator: output => !output || isPlainObject(output),

lib/definitions/release-types.js

@@ -1 +0,0 @@
-module.exports = ['major', 'premajor', 'minor', 'preminor', 'patch', 'prepatch', 'prerelease'];

lib/get-config.js

@@ -7,8 +7,19 @@ const {repoUrl} = require('./git');
 const PLUGINS_DEFINITIONS = require('./definitions/plugins');
 const plugins = require('./plugins');
 
+const CONFIG_NAME = 'release';
+const CONFIG_FILES = [
+  'package.json',
+  `.${CONFIG_NAME}rc`,
+  `.${CONFIG_NAME}rc.json`,
+  `.${CONFIG_NAME}rc.yaml`,
+  `.${CONFIG_NAME}rc.yml`,
+  `.${CONFIG_NAME}rc.js`,
+  `${CONFIG_NAME}.config.js`,
+];
+
 module.exports = async (opts, logger) => {
-  const {config} = (await cosmiconfig('release', {rcExtensions: true}).load(process.cwd())) || {};
+  const {config} = (await cosmiconfig(CONFIG_NAME, {searchPlaces: CONFIG_FILES}).search()) || {};
   // Merge config file options and CLI/API options
   let options = {...config, ...opts};
   const pluginsPath = {};

lib/get-git-auth-url.js

@@ -4,7 +4,15 @@ const gitUrlParse = require('git-url-parse');
 const hostedGitInfo = require('hosted-git-info');
 const {verifyAuth} = require('./git');
 
-const GIT_TOKENS = ['GIT_CREDENTIALS', 'GH_TOKEN', 'GITHUB_TOKEN', 'GL_TOKEN', 'GITLAB_TOKEN'];
+const GIT_TOKENS = {
+  GIT_CREDENTIALS: undefined,
+  GH_TOKEN: undefined,
+  GITHUB_TOKEN: undefined,
+  GL_TOKEN: 'gitlab-ci-token:',
+  GITLAB_TOKEN: 'gitlab-ci-token:',
+  BB_TOKEN: 'x-token-auth:',
+  BITBUCKET_TOKEN: 'x-token-auth:',
+};
 
 /**
  * Determine the the git repository URL to use to push, either:
@@ -35,16 +43,17 @@ module.exports = async ({repositoryUrl, branch}) => {
   }
 
   // Test if push is allowed without transforming the URL (e.g. is ssh keys are set up)
-  if (!await verifyAuth(repositoryUrl, branch)) {
-    const envVar = GIT_TOKENS.find(envVar => !isUndefined(process.env[envVar]));
-    const gitCredentials = ['GL_TOKEN', 'GITLAB_TOKEN'].includes(envVar)
-      ? `gitlab-ci-token:${process.env[envVar]}`
-      : process.env[envVar];
+  try {
+    await verifyAuth(repositoryUrl, branch);
+  } catch (err) {
+    const envVar = Object.keys(GIT_TOKENS).find(envVar => !isUndefined(process.env[envVar]));
+    const gitCredentials = `${GIT_TOKENS[envVar] || ''}${process.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, ...{token: gitCredentials}}.toString(protocol) : repositoryUrl;
+    return gitCredentials ? {...parsed, protocols: [protocol], user: gitCredentials}.toString(protocol) : repositoryUrl;
   }
+
   return repositoryUrl;
 };

lib/get-last-release.js

@@ -20,6 +20,7 @@ const {gitTags, isRefInHistory, gitTagHead} = require('./git');
  * - Sort the versions
  * - Retrive the highest version
  *
+ * @param {String} tagFormat Git tag format.
  * @param {Object} logger Global logger.
  * @return {Promise<LastRelease>} The last tagged release or `undefined` if none is found.
  */

lib/get-next-version.js

@@ -1,4 +1,5 @@
 const semver = require('semver');
+const {FIRST_RELEASE} = require('./definitions/constants');
 
 module.exports = (type, lastRelease, logger) => {
   let version;
@@ -6,7 +7,7 @@ module.exports = (type, lastRelease, logger) => {
     version = semver.inc(lastRelease.version, type);
     logger.log('The next release version is %s', version);
   } else {
-    version = '1.0.0';
+    version = FIRST_RELEASE;
     logger.log('There is no previous release, the next release version is %s', version);
   }
 

lib/git.js

@@ -36,17 +36,29 @@ async function gitTags() {
  */
 async function isRefInHistory(ref) {
   try {
-    return (await execa('git', ['merge-base', '--is-ancestor', ref, 'HEAD'])).code === 0;
+    await execa('git', ['merge-base', '--is-ancestor', ref, 'HEAD']);
+    return true;
   } catch (err) {
+    if (err.code === 1) {
+      return false;
+    }
+
     debug(err);
+    throw err;
   }
 }
 
 /**
- * Unshallow the git repository (retriving every commits and tags).
+ * Unshallow the git repository if necessary and fetch all the tags.
+ *
+ * @param {String} repositoryUrl The remote repository URL.
  */
-async function unshallow() {
-  await execa('git', ['fetch', '--unshallow', '--tags'], {reject: false});
+async function fetch(repositoryUrl) {
+  try {
+    await execa('git', ['fetch', '--unshallow', '--tags', repositoryUrl]);
+  } catch (err) {
+    await execa('git', ['fetch', '--tags', repositoryUrl]);
+  }
 }
 
 /**
@@ -61,7 +73,7 @@ async function gitHead() {
  */
 async function repoUrl() {
   try {
-    return await execa.stdout('git', ['remote', 'get-url', 'origin']);
+    return await execa.stdout('git', ['config', '--get', 'remote.origin.url']);
   } catch (err) {
     debug(err);
   }
@@ -81,16 +93,17 @@ async function isGitRepo() {
 /**
  * Verify the write access authorization to remote repository with push dry-run.
  *
- * @param {String} origin The remote repository URL.
+ * @param {String} repositoryUrl The remote repository URL.
  * @param {String} branch The repositoru branch for which to verify write access.
  *
- * @return {Boolean} `true` is authorized to push, falsy otherwise.
+ * @throws {Error} if not authorized to push.
  */
-async function verifyAuth(origin, branch) {
+async function verifyAuth(repositoryUrl, branch) {
   try {
-    return (await execa('git', ['push', '--dry-run', origin, `HEAD:${branch}`])).code === 0;
+    await execa('git', ['push', '--dry-run', repositoryUrl, `HEAD:${branch}`]);
   } catch (err) {
     debug(err);
+    throw err;
   }
 }
 
@@ -107,12 +120,12 @@ async function tag(tagName) {
 /**
  * Push to the remote repository.
  *
- * @param {String} origin The remote repository URL.
+ * @param {String} repositoryUrl The remote repository URL.
  * @param {String} branch The branch to push.
  * @throws {Error} if the push failed.
  */
-async function push(origin, branch) {
-  await execa('git', ['push', '--tags', origin, `HEAD:${branch}`]);
+async function push(repositoryUrl, branch) {
+  await execa('git', ['push', '--tags', repositoryUrl, `HEAD:${branch}`]);
 }
 
 /**
@@ -129,11 +142,29 @@ async function verifyTagName(tagName) {
   }
 }
 
+/**
+ * Verify the local branch is up to date with the remote one.
+ *
+ * @param {String} repositoryUrl The remote repository URL.
+ * @param {String} branch The repository branch for which to verify status.
+ *
+ * @return {Boolean} `true` is the HEAD of the current local branch is the same as the HEAD of the remote branch, falsy otherwise.
+ */
+async function isBranchUpToDate(repositoryUrl, branch) {
+  try {
+    return await isRefInHistory(
+      (await execa.stdout('git', ['ls-remote', '--heads', repositoryUrl, branch])).match(/^(\w+)?/)[1]
+    );
+  } catch (err) {
+    debug(err);
+  }
+}
+
 module.exports = {
   gitTagHead,
   gitTags,
   isRefInHistory,
-  unshallow,
+  fetch,
   gitHead,
   repoUrl,
   isGitRepo,
@@ -141,4 +172,5 @@ module.exports = {
   tag,
   push,
   verifyTagName,
+  isBranchUpToDate,
 };

lib/plugins/normalize.js

@@ -15,9 +15,9 @@ module.exports = (pluginType, pluginsPath, globalOpts, pluginOpts, logger) => {
 
   if (!isFunction(pluginOpts)) {
     if (pluginsPath[path]) {
-      logger.log('Load plugin %s from %s in shareable config %s', pluginType, path, pluginsPath[path]);
+      logger.log('Load plugin "%s" from %s in shareable config %s', pluginType, path, pluginsPath[path]);
     } else {
-      logger.log('Load plugin %s from %s', pluginType, path);
+      logger.log('Load plugin "%s" from %s', pluginType, path);
     }
   }
 
@@ -37,21 +37,20 @@ module.exports = (pluginType, pluginsPath, globalOpts, pluginOpts, logger) => {
     throw getError('EPLUGIN', {pluginType, pluginName});
   }
 
-  return Object.defineProperty(
-    async input => {
-      const definition = PLUGINS_DEFINITIONS[pluginType];
-      try {
-        const result = await func(cloneDeep(input));
-        if (definition && definition.output && !definition.output.validator(result)) {
-          throw getError(PLUGINS_DEFINITIONS[pluginType].output.error, {result, pluginName});
-        }
-        return result;
-      } catch (err) {
-        extractErrors(err).forEach(err => Object.assign(err, {pluginName}));
-        throw err;
+  const validator = async input => {
+    const definition = PLUGINS_DEFINITIONS[pluginType];
+    try {
+      const result = await func(cloneDeep(input));
+      if (definition && definition.output && !definition.output.validator(result)) {
+        throw getError(PLUGINS_DEFINITIONS[pluginType].output.error, {result, pluginName});
       }
-    },
-    'pluginName',
-    {value: pluginName, writable: false, enumerable: true}
-  );
+      return result;
+    } catch (err) {
+      extractErrors(err).forEach(err => Object.assign(err, {pluginName}));
+      throw err;
+    }
+  };
+
+  Reflect.defineProperty(validator, 'pluginName', {value: pluginName, writable: false, enumerable: true});
+  return validator;
 };

lib/verify.js

@@ -6,14 +6,14 @@ const getError = require('./get-error');
 module.exports = async options => {
   const errors = [];
 
-  if (!await isGitRepo()) {
+  if (!(await isGitRepo())) {
     errors.push(getError('ENOGITREPO'));
   } else if (!options.repositoryUrl) {
     errors.push(getError('ENOREPOURL'));
   }
 
   // Verify that compiling the `tagFormat` produce a valid Git tag
-  if (!await verifyTagName(template(options.tagFormat)({version: '0.0.0'}))) {
+  if (!(await verifyTagName(template(options.tagFormat)({version: '0.0.0'})))) {
     errors.push(getError('EINVALIDTAGFORMAT', {tagFormat: options.tagFormat}));
   }
 

package.json

@@ -26,24 +26,25 @@
     "@semantic-release/release-notes-generator": "^6.0.0",
     "aggregate-error": "^1.0.0",
     "chalk": "^2.3.0",
-    "cosmiconfig": "^4.0.0",
+    "cosmiconfig": "^5.0.1",
     "debug": "^3.1.0",
-    "env-ci": "^1.0.0",
+    "env-ci": "^2.0.0",
     "execa": "^0.10.0",
+    "find-versions": "^2.0.0",
     "get-stream": "^3.0.0",
     "git-log-parser": "^1.2.0",
     "git-url-parse": "^9.0.0",
-    "hook-std": "^0.4.0",
-    "hosted-git-info": "^2.6.0",
+    "hook-std": "^1.0.1",
+    "hosted-git-info": "^2.7.1",
     "lodash": "^4.17.4",
-    "marked": "^0.3.9",
-    "marked-terminal": "^2.0.0",
-    "p-locate": "^2.0.0",
+    "marked": "^0.4.0",
+    "marked-terminal": "^3.0.0",
+    "p-locate": "^3.0.0",
     "p-reduce": "^1.0.0",
-    "read-pkg-up": "^3.0.0",
+    "read-pkg-up": "^4.0.0",
     "resolve-from": "^4.0.0",
     "semver": "^5.4.1",
-    "yargs": "^11.0.0"
+    "yargs": "^12.0.0"
   },
   "devDependencies": {
     "ava": "^0.25.0",
@@ -51,20 +52,20 @@
     "codecov": "^3.0.0",
     "commitizen": "^2.9.6",
     "cz-conventional-changelog": "^2.0.0",
-    "delay": "^2.0.0",
+    "delay": "^3.0.0",
     "dockerode": "^2.5.2",
     "file-url": "^2.0.2",
-    "fs-extra": "^5.0.0",
+    "fs-extra": "^6.0.0",
     "got": "^8.0.0",
     "js-yaml": "^3.10.0",
     "mockserver-client": "^5.1.1",
     "nock": "^9.0.2",
-    "nyc": "^11.2.1",
-    "p-retry": "^1.0.0",
+    "nyc": "^12.0.1",
+    "p-retry": "^2.0.0",
     "proxyquire": "^2.0.0",
-    "sinon": "^4.0.0",
+    "sinon": "^6.0.0",
     "tempy": "^0.2.1",
-    "xo": "^0.20.0"
+    "xo": "^0.21.0"
   },
   "engines": {
     "node": ">=8.3"
@@ -104,7 +105,8 @@
     "all": true
   },
   "prettier": {
-    "printWidth": 120
+    "printWidth": 120,
+    "trailingComma": "es5"
   },
   "publishConfig": {
     "tag": "next"

test/cli.test.js

@@ -165,12 +165,12 @@ test.serial('Do not set properties in option for which arg is not in command lin
 
   await cli();
 
-  t.false(Object.prototype.hasOwnProperty.call(run.args[0][0], 'ci'));
-  t.false(Object.prototype.hasOwnProperty.call(run.args[0][0], 'd'));
-  t.false(Object.prototype.hasOwnProperty.call(run.args[0][0], 'dry-run'));
-  t.false(Object.prototype.hasOwnProperty.call(run.args[0][0], 'debug'));
-  t.false(Object.prototype.hasOwnProperty.call(run.args[0][0], 'r'));
-  t.false(Object.prototype.hasOwnProperty.call(run.args[0][0], 't'));
+  t.false(Reflect.apply(Object.prototype.hasOwnProperty, run.args[0][0], ['ci']));
+  t.false(Reflect.apply(Object.prototype.hasOwnProperty, run.args[0][0], ['d']));
+  t.false(Reflect.apply(Object.prototype.hasOwnProperty, run.args[0][0], ['dry-run']));
+  t.false(Reflect.apply(Object.prototype.hasOwnProperty, run.args[0][0], ['debug']));
+  t.false(Reflect.apply(Object.prototype.hasOwnProperty, run.args[0][0], ['r']));
+  t.false(Reflect.apply(Object.prototype.hasOwnProperty, run.args[0][0], ['t']));
 });
 
 test.serial('Set "noCi" options to "true" with "--no-ci"', async t => {

test/definitions/plugins.test.js

@@ -60,9 +60,9 @@ test('The "prepare" plugin, if defined, must be a single or an array of plugins
 test('The "publish" plugin is mandatory, and must be a single or an array of plugins definition', t => {
   t.false(plugins.publish.config.validator({}));
   t.false(plugins.publish.config.validator({path: null}));
-  t.false(plugins.publish.config.validator());
 
   t.true(plugins.publish.config.validator({path: 'plugin-path.js'}));
+  t.true(plugins.publish.config.validator());
   t.true(plugins.publish.config.validator('plugin-path.js'));
   t.true(plugins.publish.config.validator(() => {}));
   t.true(plugins.publish.config.validator([{path: 'plugin-path.js'}, 'plugin-path.js', () => {}]));

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

@@ -13,6 +13,10 @@ test.beforeEach(() => {
   delete process.env.GITHUB_TOKEN;
   delete process.env.GL_TOKEN;
   delete process.env.GITLAB_TOKEN;
+  delete process.env.BB_TOKEN;
+  delete process.env.BITBUCKET_TOKEN;
+  process.env.GIT_ASKPASS = 'echo';
+  process.env.GIT_TERMINAL_PROMPT = 0;
 });
 
 test.afterEach.always(() => {
@@ -150,6 +154,22 @@ test.serial('Return the "https" formatted URL if "gitCredentials" is defined wit
   );
 });
 
+test.serial('Return the "https" formatted URL if "gitCredentials" is defined with "BB_TOKEN"', async t => {
+  process.env.BB_TOKEN = 'token';
+  t.is(
+    await getAuthUrl({repositoryUrl: 'git@host.null:owner/repo.git'}),
+    'https://x-token-auth:token@host.null/owner/repo.git'
+  );
+});
+
+test.serial('Return the "https" formatted URL if "gitCredentials" is defined with "BITBUCKET_TOKEN"', async t => {
+  process.env.BITBUCKET_TOKEN = 'token';
+  t.is(
+    await getAuthUrl({repositoryUrl: 'git@host.null:owner/repo.git'}),
+    'https://x-token-auth:token@host.null/owner/repo.git'
+  );
+});
+
 test.serial('Handle "https" URL with group and subgroup, with "GIT_CREDENTIALS"', async t => {
   process.env.GIT_CREDENTIALS = 'user:pass';
   t.is(

test/git.test.js

@@ -3,7 +3,7 @@ import tempy from 'tempy';
 import {
   gitTagHead,
   isRefInHistory,
-  unshallow,
+  fetch,
   gitHead,
   repoUrl,
   tag,
@@ -11,6 +11,7 @@ import {
   gitTags,
   isGitRepo,
   verifyTagName,
+  isBranchUpToDate,
 } from '../lib/git';
 import {
   gitRepo,
@@ -22,6 +23,8 @@ import {
   gitAddConfig,
   gitCommitTag,
   gitRemoteTagHead,
+  gitPush,
+  gitDetachedHead,
 } from './helpers/git-utils';
 
 // Save the current working diretory
@@ -50,7 +53,7 @@ test.serial('Throw error if the last commit sha cannot be found', async t => {
   await t.throws(gitHead(), Error);
 });
 
-test.serial('Unshallow repository', async t => {
+test.serial('Unshallow and fetch repository', async t => {
   // Create a git repository, set the current working directory at the root of the repo
   const repo = await gitRepo();
   // Add commits to the master branch
@@ -61,7 +64,7 @@ test.serial('Unshallow repository', async t => {
   // Verify the shallow clone contains only one commit
   t.is((await gitGetCommits()).length, 1);
 
-  await unshallow();
+  await fetch(repo);
 
   // Verify the shallow clone contains all the commits
   t.is((await gitGetCommits()).length, 2);
@@ -69,10 +72,27 @@ test.serial('Unshallow repository', async t => {
 
 test.serial('Do not throw error when unshallow a complete repository', async t => {
   // Create a git repository, set the current working directory at the root of the repo
-  await gitRepo();
+  const repo = await gitRepo();
   // Add commits to the master branch
   await gitCommits(['First']);
-  await t.notThrows(unshallow());
+  await t.notThrows(fetch(repo));
+});
+
+test.serial('Fetch all tags on a detached head repository', async t => {
+  const repo = await gitRepo(true);
+
+  await gitCommits(['First']);
+  await gitTagVersion('v1.0.0');
+  await gitCommits(['Second']);
+  await gitTagVersion('v1.0.1');
+  const [commit] = await gitCommits(['Third']);
+  await gitTagVersion('v1.1.0');
+  await gitPush();
+  await gitDetachedHead(repo, commit.hash);
+
+  await fetch(repo);
+
+  t.deepEqual((await gitTags()).sort(), ['v1.0.0', 'v1.0.1', 'v1.1.0'].sort());
 });
 
 test.serial('Verify if the commit `sha` is in the direct history of the current branch', async t => {
@@ -88,6 +108,7 @@ test.serial('Verify if the commit `sha` is in the direct history of the current
 
   t.true(await isRefInHistory(commits[0].hash));
   t.falsy(await isRefInHistory(otherCommits[0].hash));
+  await t.throws(isRefInHistory('non-existant-sha'));
 });
 
 test.serial('Get the commit sha for a given tag or falsy if the tag does not exists', async t => {
@@ -183,3 +204,37 @@ test.serial('Throws error if obtaining the tags fails', async t => {
 
   await t.throws(gitTags());
 });
+
+test.serial('Return "true" if repository is up to date', async t => {
+  const repositoryUrl = await gitRepo(true);
+  await gitCommits(['First']);
+  await gitPush();
+
+  t.true(await isBranchUpToDate(repositoryUrl, 'master'));
+});
+
+test.serial('Return falsy if repository is not up to date', async t => {
+  const repositoryUrl = await gitRepo(true);
+  const repoDir = process.cwd();
+  await gitCommits(['First']);
+  await gitCommits(['Second']);
+  await gitPush();
+
+  t.true(await isBranchUpToDate(repositoryUrl, 'master'));
+
+  await gitShallowClone(repositoryUrl);
+  await gitCommits(['Third']);
+  await gitPush();
+  process.chdir(repoDir);
+
+  t.falsy(await isBranchUpToDate(repositoryUrl, 'master'));
+});
+
+test.serial('Return "true" if local repository is ahead', async t => {
+  const repositoryUrl = await gitRepo(true);
+  await gitCommits(['First']);
+  await gitPush();
+  await gitCommits(['Second']);
+
+  t.true(await isBranchUpToDate(repositoryUrl, 'master'));
+});

test/helpers/git-utils.js

@@ -20,7 +20,7 @@ import getStream from 'get-stream';
  * If `withRemote` is `false`, creates a regular repository and initialize it. Change the current working directory to the repository root.
  *
  * @param {Boolean} withRemote `true` to create a shallow clone of a bare repository.
- * @param {String} [branc='master'] The branch to initialize.
+ * @param {String} [branch='master'] The branch to initialize.
  * @return {String} The path of the clone if `withRemote` is `true`, the path of the repository otherwise.
  */
 export async function gitRepo(withRemote, branch = 'master') {
@@ -46,16 +46,16 @@ export async function gitRepo(withRemote, branch = 'master') {
  * - Create an initial commits
  * - Push to origin
  *
- * @param {String} origin The URL of the bare repository.
+ * @param {String} repositoryUrl The URL of the bare repository.
  * @param {String} [branch='master'] the branch to initialize.
  */
-export async function initBareRepo(origin, branch = 'master') {
+export async function initBareRepo(repositoryUrl, branch = 'master') {
   const clone = tempy.directory();
-  await execa('git', ['clone', '--no-hardlinks', origin, clone]);
+  await execa('git', ['clone', '--no-hardlinks', repositoryUrl, clone]);
   process.chdir(clone);
   await gitCheckout(branch);
   await gitCommits(['Initial commit']);
-  await execa('git', ['push', origin, branch]);
+  await execa('git', ['push', repositoryUrl, branch]);
 }
 
 /**
@@ -98,7 +98,7 @@ export async function gitGetCommits(from) {
  * Checkout a branch on the current git repository.
  *
  * @param {String} branch Branch name.
- * @param {boolean} create `true` to create the branche ans switch, `false` to only switch.
+ * @param {Boolean} create `true` to create the branche ans switch, `false` to only switch.
  */
 export async function gitCheckout(branch, create = true) {
   await execa('git', create ? ['checkout', '-b', branch] : ['checkout', branch]);
@@ -121,40 +121,37 @@ export async function gitTagVersion(tagName, sha) {
   await execa('git', sha ? ['tag', '-f', tagName, sha] : ['tag', tagName]);
 }
 
-export async function gitRemoteTagVersion(origin, tagName, sha = 'HEAD') {
-  await execa('git', ['push', origin, `${sha}:refs/tags/${tagName}`]);
-}
-
 /**
  * Create a shallow clone of a git repository and change the current working directory to the cloned repository root.
  * The shallow will contain a limited number of commit and no tags.
  *
- * @param {String} origin The path of the repository to clone.
+ * @param {String} repositoryUrl The path of the repository to clone.
+ * @param {String} [branch='master'] the branch to clone.
  * @param {Number} [depth=1] The number of commit to clone.
  * @return {String} The path of the cloned repository.
  */
-export async function gitShallowClone(origin, branch = 'master', depth = 1) {
+export async function gitShallowClone(repositoryUrl, branch = 'master', depth = 1) {
   const dir = tempy.directory();
 
   process.chdir(dir);
-  await execa('git', ['clone', '--no-hardlinks', '--no-tags', '-b', branch, '--depth', depth, origin, dir]);
+  await execa('git', ['clone', '--no-hardlinks', '--no-tags', '-b', branch, '--depth', depth, repositoryUrl, dir]);
   return dir;
 }
 
 /**
  * Create a git repo with a detached head from another git repository and change the current working directory to the new repository root.
  *
- * @param {String} origin The path of the repository to clone.
- * @param {Number} head A commit sha of the origin repo that will become the detached head of the new one.
+ * @param {String} repositoryUrl The path of the repository to clone.
+ * @param {Number} head A commit sha of the remote repo that will become the detached head of the new one.
  * @return {String} The path of the new repository.
  */
-export async function gitDetachedHead(origin, head) {
+export async function gitDetachedHead(repositoryUrl, head) {
   const dir = tempy.directory();
 
   process.chdir(dir);
   await execa('git', ['init']);
-  await execa('git', ['remote', 'add', 'origin', origin]);
-  await execa('git', ['fetch']);
+  await execa('git', ['remote', 'add', 'origin', repositoryUrl]);
+  await execa('git', ['fetch', repositoryUrl]);
   await execa('git', ['checkout', head]);
   return dir;
 }
@@ -183,12 +180,12 @@ export async function gitTagHead(tagName) {
 /**
  * Get the first commit sha referenced by the tag `tagName` in the remote repository.
  *
- * @param {String} origin The repository remote URL.
+ * @param {String} repositoryUrl The repository remote URL.
  * @param {String} tagName The tag name to seach for.
  * @return {String} The sha of the commit associated with `tagName` on the remote repository.
  */
-export async function gitRemoteTagHead(origin, tagName) {
-  return (await execa.stdout('git', ['ls-remote', '--tags', origin, tagName]))
+export async function gitRemoteTagHead(repositoryUrl, tagName) {
+  return (await execa.stdout('git', ['ls-remote', '--tags', repositoryUrl, tagName]))
     .split('\n')
     .filter(tag => Boolean(tag))
     .map(tag => tag.match(/^(\S+)/)[1])[0];
@@ -208,10 +205,10 @@ export async function gitCommitTag(gitHead) {
 /**
  * Push to the remote repository.
  *
- * @param {String} origin The remote repository URL.
+ * @param {String} repositoryUrl The remote repository URL.
  * @param {String} branch The branch to push.
  * @throws {Error} if the push failed.
  */
-export async function push(origin, branch) {
-  await execa('git', ['push', '--tags', origin, `HEAD:${branch}`]);
+export async function gitPush(repositoryUrl = 'origin', branch = 'master') {
+  await execa('git', ['push', '--tags', repositoryUrl, `HEAD:${branch}`]);
 }

test/helpers/gitbox.js

@@ -16,8 +16,6 @@ const gitCredential = `${GIT_USERNAME}:${GIT_PASSWORD}`;
 
 /**
  * Download the `gitbox` Docker image, create a new container and start it.
- *
- * @return {Promise} Promise that resolves when the container is started.
  */
 async function start() {
   await getStream(await docker.pull(IMAGE));
@@ -39,8 +37,6 @@ async function start() {
 
 /**
  * Stop and remote the `mockserver` Docker container.
- *
- * @return {Promise} Promise that resolves when the container is stopped.
  */
 async function stop() {
   await container.stop();

test/helpers/mockserver.js

@@ -12,8 +12,6 @@ let container;
 
 /**
  * Download the `mockserver` Docker image, create a new container and start it.
- *
- * @return {Promise} Promise that resolves when the container is started.
  */
 async function start() {
   await getStream(await docker.pull(IMAGE));
@@ -39,8 +37,6 @@ async function start() {
 
 /**
  * Stop and remote the `mockserver` Docker container.
- *
- * @return {Promise} Promise that resolves when the container is stopped.
  */
 async function stop() {
   await container.stop();

test/helpers/npm-registry.js

@@ -16,8 +16,6 @@ let container;
 
 /**
  * Download the `npm-docker-couchdb` Docker image, create a new container and start it.
- *
- * @return {Promise} Promise that resolves when the container is started.
  */
 async function start() {
   await getStream(await docker.pull(IMAGE));
@@ -69,8 +67,6 @@ const authEnv = {
 
 /**
  * Stop and remote the `npm-docker-couchdb` Docker container.
- *
- * @return {Promise} Promise that resolves when the container is stopped.
  */
 async function stop() {
   await container.stop();

test/index.test.js

@@ -5,6 +5,7 @@ import clearModule from 'clear-module';
 import AggregateError from 'aggregate-error';
 import SemanticReleaseError from '@semantic-release/error';
 import DEFINITIONS from '../lib/definitions/plugins';
+import {COMMIT_NAME, COMMIT_EMAIL} from '../lib/definitions/constants';
 import {
   gitHead as getGitHead,
   gitTagHead,
@@ -12,7 +13,7 @@ import {
   gitCommits,
   gitTagVersion,
   gitRemoteTagHead,
-  push,
+  gitPush,
   gitShallowClone,
 } from './helpers/git-utils';
 
@@ -57,6 +58,7 @@ test.serial('Plugins are called with expected values', async t => {
   await gitTagVersion('v1.0.0');
   // Add new commits to the master branch
   commits = (await gitCommits(['Second'])).concat(commits);
+  await gitPush();
 
   const lastRelease = {version: '1.0.0', gitHead: commits[commits.length - 1].hash, gitTag: 'v1.0.0'};
   const nextRelease = {type: 'major', version: '2.0.0', gitHead: await getGitHead(), gitTag: 'v2.0.0'};
@@ -155,6 +157,12 @@ test.serial('Plugins are called with expected values', async t => {
   // Verify the tag has been created on the local and remote repo and reference the gitHead
   t.is(await gitTagHead(nextRelease.gitTag), nextRelease.gitHead);
   t.is(await gitRemoteTagHead(repositoryUrl, nextRelease.gitTag), nextRelease.gitHead);
+
+  // Verify the author/commiter name and email hve been set
+  t.is(process.env.GIT_AUTHOR_NAME, COMMIT_NAME);
+  t.is(process.env.GIT_AUTHOR_EMAIL, COMMIT_EMAIL);
+  t.is(process.env.GIT_COMMITTER_NAME, COMMIT_NAME);
+  t.is(process.env.GIT_COMMITTER_EMAIL, COMMIT_EMAIL);
 });
 
 test.serial('Use custom tag format', async t => {
@@ -162,6 +170,7 @@ test.serial('Use custom tag format', async t => {
   await gitCommits(['First']);
   await gitTagVersion('test-1.0.0');
   await gitCommits(['Second']);
+  await gitPush();
 
   const nextRelease = {type: 'major', version: '2.0.0', gitHead: await getGitHead(), gitTag: 'test-2.0.0'};
   const notes = 'Release notes';
@@ -198,6 +207,7 @@ test.serial('Use new gitHead, and recreate release notes if a prepare plugin cre
   await gitTagVersion('v1.0.0');
   // Add new commits to the master branch
   commits = (await gitCommits(['Second'])).concat(commits);
+  await gitPush();
 
   const nextRelease = {type: 'major', version: '2.0.0', gitHead: await getGitHead(), gitTag: 'v2.0.0'};
   const notes = 'Release notes';
@@ -257,6 +267,7 @@ test.serial('Call all "success" plugins even if one errors out', async t => {
   await gitTagVersion('v1.0.0');
   // Add new commits to the master branch
   await gitCommits(['Second']);
+  await gitPush();
 
   const nextRelease = {type: 'major', version: '2.0.0', gitHead: await getGitHead(), gitTag: 'v2.0.0'};
   const notes = 'Release notes';
@@ -304,6 +315,7 @@ test.serial('Log all "verifyConditions" errors', async t => {
   const repositoryUrl = await gitRepo(true);
   // Add commits to the master branch
   await gitCommits(['First']);
+  await gitPush();
 
   const error1 = new Error('error 1');
   const error2 = new SemanticReleaseError('error 2', 'ERR2');
@@ -346,6 +358,7 @@ test.serial('Log all "verifyRelease" errors', async t => {
   await gitTagVersion('v1.0.0');
   // Add new commits to the master branch
   await gitCommits(['Second']);
+  await gitPush();
 
   const error1 = new SemanticReleaseError('error 1', 'ERR1');
   const error2 = new SemanticReleaseError('error 2', 'ERR2');
@@ -382,6 +395,7 @@ test.serial('Dry-run skips publish and success', async t => {
   await gitTagVersion('v1.0.0');
   // Add new commits to the master branch
   await gitCommits(['Second']);
+  await gitPush();
 
   const nextRelease = {type: 'major', version: '2.0.0', gitHead: await getGitHead(), gitTag: 'v2.0.0'};
   const notes = 'Release notes';
@@ -430,6 +444,7 @@ test.serial('Dry-run skips fail', async t => {
   await gitTagVersion('v1.0.0');
   // Add new commits to the master branch
   await gitCommits(['Second']);
+  await gitPush();
 
   const error1 = new SemanticReleaseError('error 1', 'ERR1');
   const error2 = new SemanticReleaseError('error 2', 'ERR2');
@@ -464,6 +479,7 @@ test.serial('Force a dry-run if not on a CI and "noCi" is not explicitly set', a
   await gitTagVersion('v1.0.0');
   // Add new commits to the master branch
   await gitCommits(['Second']);
+  await gitPush();
 
   const nextRelease = {type: 'major', version: '2.0.0', gitHead: await getGitHead(), gitTag: 'v2.0.0'};
   const notes = 'Release notes';
@@ -513,6 +529,7 @@ test.serial('Allow local releases with "noCi" option', async t => {
   await gitTagVersion('v1.0.0');
   // Add new commits to the master branch
   await gitCommits(['Second']);
+  await gitPush();
 
   const nextRelease = {type: 'major', version: '2.0.0', gitHead: await getGitHead(), gitTag: 'v2.0.0'};
   const notes = 'Release notes';
@@ -566,6 +583,7 @@ test.serial('Accept "undefined" value returned by the "generateNotes" plugins',
   await gitTagVersion('v1.0.0');
   // Add new commits to the master branch
   commits = (await gitCommits(['Second'])).concat(commits);
+  await gitPush();
 
   const lastRelease = {version: '1.0.0', gitHead: commits[commits.length - 1].hash, gitTag: 'v1.0.0'};
   const nextRelease = {type: 'major', version: '2.0.0', gitHead: await getGitHead(), gitTag: 'v2.0.0'};
@@ -623,6 +641,31 @@ test.serial('Returns falsy value if triggered by a PR', async t => {
   );
 });
 
+test.serial('Returns falsy value if triggered on an outdated clone', async t => {
+  // Create a git repository, set the current working directory at the root of the repo
+  const repositoryUrl = await gitRepo(true);
+  const repoDir = process.cwd();
+  // Add commits to the master branch
+  await gitCommits(['First']);
+  await gitCommits(['Second']);
+  await gitPush();
+  await gitShallowClone(repositoryUrl);
+  await gitCommits(['Third']);
+  await gitPush();
+  process.chdir(repoDir);
+
+  const semanticRelease = proxyquire('..', {
+    './lib/logger': t.context.logger,
+    'env-ci': () => ({isCi: true, branch: 'master', isPr: false}),
+  });
+
+  t.falsy(await semanticRelease({repositoryUrl}));
+  t.deepEqual(t.context.log.args[t.context.log.args.length - 1], [
+    "The local branch %s is behind the remote one, therefore a new version won't be published.",
+    'master',
+  ]);
+});
+
 test.serial('Returns falsy value if not running from the configured branch', async t => {
   // Create a git repository, set the current working directory at the root of the repo
   const repositoryUrl = await gitRepo(true);
@@ -656,6 +699,7 @@ test.serial('Returns falsy value if there is no relevant changes', async t => {
   const repositoryUrl = await gitRepo(true);
   // Add commits to the master branch
   await gitCommits(['First']);
+  await gitPush();
 
   const analyzeCommits = stub().resolves();
   const verifyRelease = stub().resolves();
@@ -685,7 +729,10 @@ test.serial('Returns falsy value if there is no relevant changes', async t => {
   t.is(verifyRelease.callCount, 0);
   t.is(generateNotes.callCount, 0);
   t.is(publish.callCount, 0);
-  t.is(t.context.log.args[7][0], 'There are no relevant changes, so no new version is released.');
+  t.is(
+    t.context.log.args[t.context.log.args.length - 1][0],
+    'There are no relevant changes, so no new version is released.'
+  );
 });
 
 test.serial('Exclude commits with [skip release] or [release skip] from analysis', async t => {
@@ -702,6 +749,7 @@ test.serial('Exclude commits with [skip release] or [release skip] from analysis
     'Test commit\n\n commit body\n[skip release]',
     'Test commit\n\n commit body\n[release skip]',
   ]);
+  await gitPush();
   const analyzeCommits = stub().resolves();
   const config = {branch: 'master', repositoryUrl, globalOpt: 'global'};
   const options = {
@@ -826,6 +874,7 @@ test.serial('Throw an Error if plugin returns an unexpected value', async t => {
   await gitTagVersion('v1.0.0');
   // Add new commits to the master branch
   await gitCommits(['Second']);
+  await gitPush();
 
   const verifyConditions = stub().resolves();
   const analyzeCommits = stub().resolves('string');
@@ -854,7 +903,7 @@ test.serial('Get all commits including the ones not in the shallow clone', async
   const repositoryUrl = await gitRepo(true);
   await gitTagVersion('v1.0.0');
   await gitCommits(['First', 'Second', 'Third']);
-  await push(repositoryUrl, 'master');
+  await gitPush(repositoryUrl, 'master');
 
   await gitShallowClone(repositoryUrl);
 

test/integration.test.js

@@ -2,7 +2,7 @@ import test from 'ava';
 import {writeJson, readJson} from 'fs-extra';
 import {stub} from 'sinon';
 import execa from 'execa';
-import {gitHead as getGitHead, gitTagHead, gitRepo, gitCommits, gitRemoteTagHead} from './helpers/git-utils';
+import {gitHead as getGitHead, gitTagHead, gitRepo, gitCommits, gitRemoteTagHead, gitPush} from './helpers/git-utils';
 import gitbox from './helpers/gitbox';
 import mockServer from './helpers/mockserver';
 import npmRegistry from './helpers/npm-registry';
@@ -609,6 +609,7 @@ test.serial('Exit with 1 if missing permission to push to the remote repository'
   /* Initial release */
   t.log('Commit a feature');
   await gitCommits(['feat: Initial commit']);
+  await gitPush();
   t.log('$ semantic-release');
   const {stdout, code} = await execa(
     cli,

test/plugins/normalize.test.js

@@ -14,7 +14,7 @@ test('Normalize and load plugin from string', t => {
 
   t.is(plugin.pluginName, './test/fixtures/plugin-noop');
   t.is(typeof plugin, 'function');
-  t.deepEqual(t.context.log.args[0], ['Load plugin %s from %s', 'verifyConditions', './test/fixtures/plugin-noop']);
+  t.deepEqual(t.context.log.args[0], ['Load plugin "%s" from %s', 'verifyConditions', './test/fixtures/plugin-noop']);
 });
 
 test('Normalize and load plugin from object', t => {
@@ -22,7 +22,7 @@ test('Normalize and load plugin from object', t => {
 
   t.is(plugin.pluginName, './test/fixtures/plugin-noop');
   t.is(typeof plugin, 'function');
-  t.deepEqual(t.context.log.args[0], ['Load plugin %s from %s', 'publish', './test/fixtures/plugin-noop']);
+  t.deepEqual(t.context.log.args[0], ['Load plugin "%s" from %s', 'publish', './test/fixtures/plugin-noop']);
 });
 
 test('Normalize and load plugin from a base file path', t => {
@@ -37,7 +37,7 @@ test('Normalize and load plugin from a base file path', t => {
   t.is(plugin.pluginName, './plugin-noop');
   t.is(typeof plugin, 'function');
   t.deepEqual(t.context.log.args[0], [
-    'Load plugin %s from %s in shareable config %s',
+    'Load plugin "%s" from %s in shareable config %s',
     'verifyConditions',
     './plugin-noop',
     './test/fixtures',
@@ -85,7 +85,7 @@ test('Normalize and load plugin that retuns multiple functions', t => {
   const plugin = normalize('verifyConditions', {}, {}, './test/fixtures/multi-plugin', t.context.logger);
 
   t.is(typeof plugin, 'function');
-  t.deepEqual(t.context.log.args[0], ['Load plugin %s from %s', 'verifyConditions', './test/fixtures/multi-plugin']);
+  t.deepEqual(t.context.log.args[0], ['Load plugin "%s" from %s', 'verifyConditions', './test/fixtures/multi-plugin']);
 });
 
 test('Wrap "analyzeCommits" plugin in a function that validate the output of the plugin', async t => {