ES6

* remove unused variables
* move `require`s at the top
* check for prototype built-ins
* run in strict mode
* always check for error values in tests
* make style consistent
* mark Node.js 6 as the minimum supported version in package.json

* Use the arrow return syntax

* logger.js: use `Boolean` to make the intention clearer.

* Use the rest params instead of arguments.

* test/getOptions.js: beautify git data.

* Update logger.js

Remove `hasDebugEnvVariable` function; it's just a `process.env` check

* Create .jshintrc

1 files changed, 423 insertions, 321 deletions

diff --git a/test/getOptions.js b/test/getOptions.js
index e79abc7..8e9e758 100644
--- a/test/getOptions.js
+++ b/test/getOptions.js
@@ -1,608 +1,706 @@
-var should = require('should');
-var index = require('../index');
-var getOptions = index.getOptions;
-var getBaseOptions = index.getBaseOptions;
+'use strict';
 
-describe("getBaseOptions", function(){
-  beforeEach(function(){
-    process.env = {PATH: process.env.PATH};
+const fs = require('fs');
+const path = require('path');
+const should = require('should');
+const yaml = require('js-yaml');
+const index = require('..');
+
+const { getOptions, getBaseOptions } = index;
+
+describe('getBaseOptions', () => {
+  beforeEach(() => {
+    process.env = { PATH: process.env.PATH };
   });
-  it ("should set service_job_id if it exists", function(done){
+  it('should set service_job_id if it exists', done => {
     testServiceJobId(getBaseOptions, done);
   });
-  it ("should set git hash if it exists", function(done){
+  it('should set git hash if it exists', done => {
     testGitHash(getBaseOptions, done);
   });
-  it ("should set git branch if it exists", function(done){
+  it('should set git branch if it exists', done => {
     testGitBranch(getBaseOptions, done);
   });
-  it ("should detect current git hash if not passed in", function(done) {
+  it('should detect current git hash if not passed in', done => {
     testGitHashDetection(getBaseOptions, done);
   });
-  it ("should detect current git branch if not passed in", function(done) {
+  it('should detect current git branch if not passed in', done => {
     testGitBranchDetection(getBaseOptions, done);
   });
-  it ("should detect detached git head if no hash passed in", function(done) {
+  it('should detect detached git head if no hash passed in', done => {
     testGitDetachedHeadDetection(getBaseOptions, done);
   });
-  it ("should fail local Git detection if no .git directory", function(done) {
+  it('should fail local Git detection if no .git directory', done => {
     testNoLocalGit(getBaseOptions, done);
   });
-  it ("should set repo_token if it exists", function(done){
+  it('should set repo_token if it exists', done => {
     testRepoToken(getBaseOptions, done);
   });
-  it ("should detect repo_token if not passed in", function(done){
+  it('should detect repo_token if not passed in', done => {
     testRepoTokenDetection(getBaseOptions, done);
   });
-  it ("should set service_name if it exists", function(done){
+  it('should set service_name if it exists', done => {
     testServiceName(getBaseOptions, done);
   });
-  it ("should set service_name and service_job_id if it's running on travis-ci", function(done){
+  it('should set service_name and service_job_id if it\'s running on travis-ci', done => {
     testTravisCi(getBaseOptions, done);
   });
-  it ("should set service_name and service_job_id if it's running on jenkins", function(done){
+  it('should set service_name and service_job_id if it\'s running on jenkins', done => {
     testJenkins(getBaseOptions, done);
   });
-  it ("should set service_name and service_job_id if it's running on circleci", function(done){
+  it('should set service_name and service_job_id if it\'s running on circleci', done => {
     testCircleCi(getBaseOptions, done);
   });
-  it ("should set service_name and service_job_id if it's running on codeship", function(done){
+  it('should set service_name and service_job_id if it\'s running on codeship', done => {
     testCodeship(getBaseOptions, done);
   });
-  it ("should set service_name and service_job_id if it's running on drone", function(done){
+  it('should set service_name and service_job_id if it\'s running on drone', done => {
     testDrone(getBaseOptions, done);
   });
-  it ("should set service_name and service_job_id if it's running on wercker", function(done){
+  it('should set service_name and service_job_id if it\'s running on wercker', done => {
     testWercker(getBaseOptions, done);
   });
-  it ("should set service_name and service_job_id if it's running on Buildkite", function(done){
+  it('should set service_name and service_job_id if it\'s running on Buildkite', done => {
     testBuildkite(getBaseOptions, done);
   });
-  it ("should set service_name and service_job_id if it's running on Azure Pipelines", function(done){
+  it('should set service_name and service_job_id if it\'s running on Azure Pipelines', done => {
     testAzurePipelines(getBaseOptions, done);
   });
 });
 
-describe("getOptions", function(){
-  beforeEach(function(){
-    process.env = {PATH: process.env.PATH};
+describe('getOptions', () => {
+  beforeEach(() => {
+    process.env = { PATH: process.env.PATH };
   });
-  it ("should require a callback", function(done) {
-    (function() {
+  it('should require a callback', done => {
+    ((() => {
       getOptions();
-    }).should.throw();
+    })).should.throw();
     done();
   });
-  it ("should get a filepath if there is one", function(done){
-    index.options._ = ["somepath"];
-    getOptions(function(err, options){
-      options.filepath.should.equal("somepath");
+  it('should get a filepath if there is one', done => {
+    index.options._ = ['somepath'];
+    getOptions((err, options) => {
+      should.not.exist(err);
+      options.filepath.should.equal('somepath');
       done();
     });
-
   });
-  it ("should get a filepath if there is one, even in verbose mode", function(done){
-    index.options.verbose = "true";
-    index.options._ = ["somepath"];
-    getOptions(function(err, options){
-      options.filepath.should.equal("somepath");
+  it('should get a filepath if there is one, even in verbose mode', done => {
+    index.options.verbose = 'true';
+    index.options._ = ['somepath'];
+    getOptions((err, options) => {
+      should.not.exist(err);
+      options.filepath.should.equal('somepath');
       done();
     });
   });
-  it ("should set service_job_id if it exists", function(done){
+  it('should set service_job_id if it exists', done => {
     testServiceJobId(getOptions, done);
   });
-  it ("should set git hash if it exists", function(done){
+  it('should set git hash if it exists', done => {
     testGitHash(getOptions, done);
   });
-  it ("should set git branch if it exists", function(done){
+  it('should set git branch if it exists', done => {
     testGitBranch(getOptions, done);
   });
-  it ("should detect current git hash if not passed in", function(done) {
+  it('should detect current git hash if not passed in', done => {
     testGitHashDetection(getOptions, done);
   });
-  it ("should detect current git branch if not passed in", function(done) {
+  it('should detect current git branch if not passed in', done => {
     testGitBranchDetection(getOptions, done);
   });
-  it ("should detect detached git head if no hash passed in", function(done) {
+  it('should detect detached git head if no hash passed in', done => {
     testGitDetachedHeadDetection(getOptions, done);
   });
-  it ("should fail local Git detection if no .git directory", function(done) {
+  it('should fail local Git detection if no .git directory', done => {
     testNoLocalGit(getOptions, done);
   });
-  it ("should set repo_token if it exists", function(done){
+  it('should set repo_token if it exists', done => {
     testRepoToken(getOptions, done);
   });
-  it ("should detect repo_token if not passed in", function(done){
+  it('should detect repo_token if not passed in', done => {
     testRepoTokenDetection(getOptions, done);
   });
-  it ("should set paralell if env var set", function(done){
+  it('should set paralell if env let set', done => {
     testParallel(getOptions, done);
   });
-  it ("should set flag_name if it exists", function(done) {
+  it('should set flag_name if it exists', done => {
     testFlagName(getOptions, done);
   });
-  it ("should set service_name if it exists", function(done){
+  it('should set service_name if it exists', done => {
     testServiceName(getOptions, done);
   });
-  it("should set service_pull_request if it exists", function(done){
+  it('should set service_pull_request if it exists', done => {
     testServicePullRequest(getOptions, done);
   });
-  it ("should set service_name and service_job_id if it's running on travis-ci", function(done){
+  it('should set service_name and service_job_id if it\'s running on travis-ci', done => {
     testTravisCi(getOptions, done);
   });
-  it ("should set service_name and service_job_id if it's running on jenkins", function(done){
+  it('should set service_name and service_job_id if it\'s running on jenkins', done => {
     testJenkins(getOptions, done);
   });
-  it ("should set service_name and service_job_id if it's running on circleci", function(done){
+  it('should set service_name and service_job_id if it\'s running on circleci', done => {
     testCircleCi(getOptions, done);
   });
-  it ("should set service_name and service_job_id if it's running on codeship", function(done){
+  it('should set service_name and service_job_id if it\'s running on codeship', done => {
     testCodeship(getOptions, done);
   });
-  it ("should set service_name and service_job_id if it's running on drone", function(done){
+  it('should set service_name and service_job_id if it\'s running on drone', done => {
     testDrone(getBaseOptions, done);
   });
-  it ("should set service_name and service_job_id if it's running on wercker", function(done){
+  it('should set service_name and service_job_id if it\'s running on wercker', done => {
     testWercker(getOptions, done);
   });
-  it ("should set service_name and service_job_id if it's running on Gitlab", function(done){
+  it('should set service_name and service_job_id if it\'s running on Gitlab', done => {
     testGitlab(getOptions, done);
   });
-  it ("should set service_name and service_job_id if it's running via Surf", function(done){
+  it('should set service_name and service_job_id if it\'s running via Surf', done => {
     testSurf(getOptions, done);
   });
-  it ("should set service_name and service_job_id if it's running via Buildkite", function(done){
+  it('should set service_name and service_job_id if it\'s running via Buildkite', done => {
     testBuildkite(getOptions, done);
   });
-  it ("should set service_name and service_job_id if it's running via Semaphore", function(done){
+  it('should set service_name and service_job_id if it\'s running via Semaphore', done => {
     testSemaphore(getOptions, done);
   });
-  it ("should set service_name and service_job_id if it's running via Azure Pipelines", function(done){
+  it('should set service_name and service_job_id if it\'s running via Azure Pipelines', done => {
     testAzurePipelines(getOptions, done);
   });
-  it ("should override set options with user options", function(done){
-    var userOptions = {service_name: 'OVERRIDDEN_SERVICE_NAME'};
-    process.env.COVERALLS_SERVICE_NAME = "SERVICE_NAME";
-    getOptions(function(err, options){
-      options.service_name.should.equal("OVERRIDDEN_SERVICE_NAME");
+  it('should override set options with user options', done => {
+    const userOptions = { service_name: 'OVERRIDDEN_SERVICE_NAME' };
+    process.env.COVERALLS_SERVICE_NAME = 'SERVICE_NAME';
+    getOptions((err, options) => {
+      should.not.exist(err);
+      options.service_name.should.equal('OVERRIDDEN_SERVICE_NAME');
       done();
     }, userOptions);
   });
 });
 
-var testServiceJobId = function(sut, done){
-    process.env.COVERALLS_SERVICE_JOB_ID = "SERVICE_JOB_ID";
-    sut(function(err, options){
-      options.service_job_id.should.equal("SERVICE_JOB_ID");
-      done();
-    });
+const testServiceJobId = (sut, done) => {
+  process.env.COVERALLS_SERVICE_JOB_ID = 'SERVICE_JOB_ID';
+  sut((err, options) => {
+    should.not.exist(err);
+    options.service_job_id.should.equal('SERVICE_JOB_ID');
+    done();
+  });
 };
 
-var testGitHash = function(sut, done){
-  process.env.COVERALLS_GIT_COMMIT = "e3e3e3e3e3e3e3e3e";
-  sut(function(err, options){
-    options.git.head.id.should.equal("e3e3e3e3e3e3e3e3e");
+const testGitHash = (sut, done) => {
+  process.env.COVERALLS_GIT_COMMIT = 'e3e3e3e3e3e3e3e3e';
+  sut((err, options) => {
+    should.not.exist(err);
+    options.git.head.id.should.equal('e3e3e3e3e3e3e3e3e');
     done();
   });
 };
 
-var testGitDetachedHeadDetection = function(sut, done){
-  var localGit = ensureLocalGitContext({ detached: true });
-  sut(function(err, options) {
+const testGitDetachedHeadDetection = (sut, done) => {
+  const localGit = ensureLocalGitContext({ detached: true });
+  sut((err, options) => {
+    should.not.exist(err);
     options.git.head.id.should.equal(localGit.id);
     localGit.wrapUp();
     done();
   });
 };
 
-var testGitHashDetection = function(sut, done){
-  var localGit = ensureLocalGitContext();
-  sut(function(err, options) {
+const testGitHashDetection = (sut, done) => {
+  const localGit = ensureLocalGitContext();
+  sut((err, options) => {
+    should.not.exist(err);
     options.git.head.id.should.equal(localGit.id);
     localGit.wrapUp();
     done();
   });
 };
 
-var testGitBranch = function(sut, done){
-  process.env.COVERALLS_GIT_COMMIT = "e3e3e3e3e3e3e3e3e";
-  process.env.COVERALLS_GIT_BRANCH = "master";
-  sut(function(err, options){
-    options.git.branch.should.equal("master");
+const testGitBranch = (sut, done) => {
+  process.env.COVERALLS_GIT_COMMIT = 'e3e3e3e3e3e3e3e3e';
+  process.env.COVERALLS_GIT_BRANCH = 'master';
+  sut((err, options) => {
+    should.not.exist(err);
+    options.git.branch.should.equal('master');
     done();
   });
 };
 
-var testGitBranchDetection = function(sut, done){
-  var localGit = ensureLocalGitContext();
-  sut(function(err, options) {
-    if (localGit.branch)
+const testGitBranchDetection = (sut, done) => {
+  const localGit = ensureLocalGitContext();
+  sut((err, options) => {
+    should.not.exist(err);
+
+    if (localGit.branch) {
       options.git.branch.should.equal(localGit.branch);
-    else
+    } else {
       options.git.should.not.have.key('branch');
+    }
+
     localGit.wrapUp();
     done();
   });
 };
 
-var testNoLocalGit = function(sut, done){
-  var localGit = ensureLocalGitContext({ noGit: true });
-  sut(function(err, options) {
+const testNoLocalGit = (sut, done) => {
+  const localGit = ensureLocalGitContext({ noGit: true });
+  sut((err, options) => {
+    should.not.exist(err);
     options.should.not.have.property('git');
     localGit.wrapUp();
     done();
   });
 };
 
-var testRepoToken = function(sut, done){
-  process.env.COVERALLS_REPO_TOKEN = "REPO_TOKEN";
-  sut(function(err, options){
-    options.repo_token.should.equal("REPO_TOKEN");
+const testRepoToken = (sut, done) => {
+  process.env.COVERALLS_REPO_TOKEN = 'REPO_TOKEN';
+  sut((err, options) => {
+    should.not.exist(err);
+    options.repo_token.should.equal('REPO_TOKEN');
     done();
   });
 };
 
-var testParallel = function(sut, done){
-  process.env.COVERALLS_PARALLEL = "true";
-  sut(function(err, options){
+const testParallel = (sut, done) => {
+  process.env.COVERALLS_PARALLEL = 'true';
+  sut((err, options) => {
+    should.not.exist(err);
     options.parallel.should.equal(true);
     done();
   });
 };
 
-var testFlagName = function(sut, done){
+const testFlagName = (sut, done) => {
   process.env.COVERALLS_FLAG_NAME = 'test flag';
 
-  sut(function(err, options){
+  sut((err, options) => {
+    should.not.exist(err);
     options.flag_name.should.equal('test flag');
     done();
   });
 };
 
-var testRepoTokenDetection = function(sut, done) {
-  var fs = require('fs');
-  var path = require('path');
+const testRepoTokenDetection = (sut, done) => {
+  const file = path.join(process.cwd(), '.coveralls.yml');
+  let token;
+  let service_name;
+  let synthetic = false;
 
-  var file = path.join(process.cwd(), '.coveralls.yml'), token, service_name, synthetic = false;
   if (fs.existsSync(file)) {
-    var yaml = require('js-yaml');
-    var coveralls_yml_doc = yaml.safeLoad(fs.readFileSync(yml, 'utf8'));
-    token = coveralls_yml_doc.repo_token;
-    if(coveralls_yml_doc.service_name) {
-      service_name = coveralls_yml_doc.service_name;
+    const coverallsYmlDoc = yaml.safeLoad(fs.readFileSync(file, 'utf8'));
+    token = coverallsYmlDoc.repo_token;
+    if (coverallsYmlDoc.service_name) {
+      service_name = coverallsYmlDoc.service_name;
     }
   } else {
     token = 'REPO_TOKEN';
     service_name = 'travis-pro';
-    fs.writeFileSync(file, 'repo_token: ' + token+'\nservice_name: ' + service_name);
+    fs.writeFileSync(file, `repo_token: ${token}\nservice_name: ${service_name}`);
     synthetic = true;
   }
-  sut(function(err, options) {
+
+  sut((err, options) => {
+    should.not.exist(err);
     options.repo_token.should.equal(token);
-    if(service_name) {
+
+    if (service_name) {
       options.service_name.should.equal(service_name);
     }
-    if (synthetic)
+
+    if (synthetic) {
       fs.unlink(file, done);
+    }
   });
 };
 
-var testServiceName = function(sut, done){
-  process.env.COVERALLS_SERVICE_NAME = "SERVICE_NAME";
-  sut(function(err, options){
-    options.service_name.should.equal("SERVICE_NAME");
+const testServiceName = (sut, done) => {
+  process.env.COVERALLS_SERVICE_NAME = 'SERVICE_NAME';
+  sut((err, options) => {
+    should.not.exist(err);
+    options.service_name.should.equal('SERVICE_NAME');
     done();
   });
 };
 
-var testServicePullRequest = function(sut, done){
-  process.env.CI_PULL_REQUEST = "https://github.com/fake/fake/pulls/123";
-  sut(function(err, options){
-    options.service_pull_request.should.equal("123");
+const testServicePullRequest = (sut, done) => {
+  process.env.CI_PULL_REQUEST = 'https://github.com/fake/fake/pulls/123';
+  sut((err, options) => {
+    should.not.exist(err);
+    options.service_pull_request.should.equal('123');
     done();
   });
 };
 
-var testTravisCi = function(sut, done){
-  process.env.TRAVIS = "TRUE";
-  process.env.TRAVIS_JOB_ID = "1234";
-  process.env.TRAVIS_PULL_REQUEST = "123";
-  sut(function(err, options){
-    options.service_name.should.equal("travis-ci");
-    options.service_job_id.should.equal("1234");
-    options.service_pull_request.should.equal("123");
+const testTravisCi = (sut, done) => {
+  process.env.TRAVIS = 'TRUE';
+  process.env.TRAVIS_JOB_ID = '1234';
+  process.env.TRAVIS_PULL_REQUEST = '123';
+  sut((err, options) => {
+    should.not.exist(err);
+    options.service_name.should.equal('travis-ci');
+    options.service_job_id.should.equal('1234');
+    options.service_pull_request.should.equal('123');
     done();
   });
 };
 
-var testJenkins = function(sut, done){
-  process.env.JENKINS_URL = "something";
-  process.env.BUILD_ID = "1234";
-  process.env.GIT_COMMIT = "a12s2d3df4f435g45g45g67h5g6";
-  process.env.GIT_BRANCH = "master";
-  sut(function(err, options){
-    options.service_name.should.equal("jenkins");
-    options.service_job_id.should.equal("1234");
-    options.git.should.eql({ head:
-                               { id: 'a12s2d3df4f435g45g45g67h5g6',
-                                 author_name: 'Unknown Author',
-                                 author_email: '',
-                                 committer_name: 'Unknown Committer',
-                                 committer_email: '',
-                                 message: 'Unknown Commit Message' },
-                              branch: 'master',
-                              remotes: [] });
+const testJenkins = (sut, done) => {
+  process.env.JENKINS_URL = 'something';
+  process.env.BUILD_ID = '1234';
+  process.env.GIT_COMMIT = 'a12s2d3df4f435g45g45g67h5g6';
+  process.env.GIT_BRANCH = 'master';
+
+  const git = {
+    head: {
+      id: 'a12s2d3df4f435g45g45g67h5g6',
+      author_name: 'Unknown Author',
+      author_email: '',
+      committer_name: 'Unknown Committer',
+      committer_email: '',
+      message: 'Unknown Commit Message'
+    },
+    branch: 'master',
+    remotes: []
+  };
+
+  sut((err, options) => {
+    should.not.exist(err);
+    options.service_name.should.equal('jenkins');
+    options.service_job_id.should.equal('1234');
+    options.git.should.eql(git);
     done();
   });
 };
 
-var testCircleCi = function(sut, done){
+const testCircleCi = (sut, done) => {
   process.env.CIRCLECI = true;
-  process.env.CIRCLE_BRANCH = "master";
-  process.env.CIRCLE_BUILD_NUM = "1234";
-  process.env.CIRCLE_SHA1 = "e3e3e3e3e3e3e3e3e";
+  process.env.CIRCLE_BRANCH = 'master';
+  process.env.CIRCLE_BUILD_NUM = '1234';
+  process.env.CIRCLE_SHA1 = 'e3e3e3e3e3e3e3e3e';
   process.env.CI_PULL_REQUEST = 'http://github.com/node-coveralls/pull/3';
-  sut(function(err, options){
-    options.service_name.should.equal("circleci");
-    options.service_job_id.should.equal("1234");
+
+  const git = {
+    head: {
+      id: 'e3e3e3e3e3e3e3e3e',
+      author_name: 'Unknown Author',
+      author_email: '',
+      committer_name: 'Unknown Committer',
+      committer_email: '',
+      message: 'Unknown Commit Message'
+    },
+    branch: 'master',
+    remotes: []
+  };
+
+  sut((err, options) => {
+    should.not.exist(err);
+    options.service_name.should.equal('circleci');
+    options.service_job_id.should.equal('1234');
     options.service_pull_request.should.equal('3');
-    options.git.should.eql({ head:
-                               { id: 'e3e3e3e3e3e3e3e3e',
-                                 author_name: 'Unknown Author',
-                                 author_email: '',
-                                 committer_name: 'Unknown Committer',
-                                 committer_email: '',
-                                 message: 'Unknown Commit Message' },
-                              branch: 'master',
-                              remotes: [] });
+    options.git.should.eql(git);
     done();
   });
 };
 
-var testCodeship = function(sut, done) {
+const testCodeship = (sut, done) => {
   process.env.CI_NAME = 'codeship';
   process.env.CI_BUILD_NUMBER = '1234';
-  process.env.CI_COMMIT_ID = "e3e3e3e3e3e3e3e3e";
-  process.env.CI_BRANCH = "master";
-  process.env.CI_COMMITTER_NAME = "John Doe";
-  process.env.CI_COMMITTER_EMAIL = "[email protected]";
-  process.env.CI_COMMIT_MESSAGE = "adadadadadadadadadad";
-  sut(function(err, options){
-    options.service_name.should.equal("codeship");
-    options.service_job_id.should.equal("1234");
-    options.git.should.eql({ head:
-                               { id: 'e3e3e3e3e3e3e3e3e',
-                                 author_name: 'Unknown Author',
-                                 author_email: '',
-                                 committer_name: 'John Doe',
-                                 committer_email: '[email protected]',
-                                 message: 'adadadadadadadadadad' },
-                              branch: 'master',
-                              remotes: [] });
+  process.env.CI_COMMIT_ID = 'e3e3e3e3e3e3e3e3e';
+  process.env.CI_BRANCH = 'master';
+  process.env.CI_COMMITTER_NAME = 'John Doe';
+  process.env.CI_COMMITTER_EMAIL = '[email protected]';
+  process.env.CI_COMMIT_MESSAGE = 'adadadadadadadadadad';
+
+  const git = {
+    head: {
+      id: 'e3e3e3e3e3e3e3e3e',
+      author_name: 'Unknown Author',
+      author_email: '',
+      committer_name: 'John Doe',
+      committer_email: '[email protected]',
+      message: 'adadadadadadadadadad'
+    },
+    branch: 'master',
+    remotes: []
+  };
+
+  sut((err, options) => {
+    should.not.exist(err);
+    options.service_name.should.equal('codeship');
+    options.service_job_id.should.equal('1234');
+    options.git.should.eql(git);
     done();
   });
 };
 
-var testDrone = function(sut, done) {
+const testDrone = (sut, done) => {
   process.env.DRONE = true;
   process.env.DRONE_BUILD_NUMBER = '1234';
-  process.env.DRONE_COMMIT = "e3e3e3e3e3e3e3e3e";
-  process.env.DRONE_BRANCH = "master";
+  process.env.DRONE_COMMIT = 'e3e3e3e3e3e3e3e3e';
+  process.env.DRONE_BRANCH = 'master';
   process.env.DRONE_PULL_REQUEST = '3';
   process.env.DRONE_COMMIT_AUTHOR = 'john doe';
   process.env.DRONE_COMMIT_AUTHOR_EMAIL = '[email protected]';
   process.env.DRONE_COMMIT_MESSAGE = 'msgmsgmsg';
 
-  sut(function(err, options){
-    options.service_name.should.equal("drone");
-    options.service_job_id.should.equal("1234");
-    options.git.should.eql({ head:
-                               { id: 'e3e3e3e3e3e3e3e3e',
-                                 author_name: 'Unknown Author',
-                                 author_email: '',
-                                 committer_name: 'john doe',
-                                 committer_email: '[email protected]',
-                                 message: 'msgmsgmsg' },
-                              branch: 'master',
-                              remotes: [] });
+  const git = {
+    head: {
+      id: 'e3e3e3e3e3e3e3e3e',
+      author_name: 'Unknown Author',
+      author_email: '',
+      committer_name: 'john doe',
+      committer_email: '[email protected]',
+      message: 'msgmsgmsg'
+    },
+    branch: 'master',
+    remotes: []
+  };
+
+  sut((err, options) => {
+    should.not.exist(err);
+    options.service_name.should.equal('drone');
+    options.service_job_id.should.equal('1234');
+    options.git.should.eql(git);
     done();
   });
 };
 
-var testWercker = function(sut, done) {
+const testWercker = (sut, done) => {
   process.env.WERCKER = true;
   process.env.WERCKER_BUILD_ID = '1234';
-  process.env.WERCKER_GIT_COMMIT = "e3e3e3e3e3e3e3e3e";
-  process.env.WERCKER_GIT_BRANCH = "master";
-  sut(function(err, options){
-    options.service_name.should.equal("wercker");
-    options.service_job_id.should.equal("1234");
-    options.git.should.eql({ head:
-                               { id: 'e3e3e3e3e3e3e3e3e',
-                                 author_name: 'Unknown Author',
-                                 author_email: '',
-                                 committer_name: 'Unknown Committer',
-                                 committer_email: '',
-                                 message: 'Unknown Commit Message' },
-                              branch: 'master',
-                              remotes: [] });
+  process.env.WERCKER_GIT_COMMIT = 'e3e3e3e3e3e3e3e3e';
+  process.env.WERCKER_GIT_BRANCH = 'master';
+
+  const git = {
+    head: {
+      id: 'e3e3e3e3e3e3e3e3e',
+      author_name: 'Unknown Author',
+      author_email: '',
+      committer_name: 'Unknown Committer',
+      committer_email: '',
+      message: 'Unknown Commit Message'
+    },
+    branch: 'master',
+    remotes: []
+  };
+
+  sut((err, options) => {
+    should.not.exist(err);
+    options.service_name.should.equal('wercker');
+    options.service_job_id.should.equal('1234');
+    options.git.should.eql(git);
     done();
   });
 };
 
-var testGitlab = function(sut, done) {
+const testGitlab = (sut, done) => {
   process.env.GITLAB_CI = true;
   process.env.CI_BUILD_NAME = 'spec:one';
-  process.env.CI_BUILD_ID = "1234";
-  process.env.CI_BUILD_REF = "e3e3e3e3e3e3e3e3e";
-  process.env.CI_BUILD_REF_NAME = "feature";
-  process.env.CI_MERGE_REQUEST_IID = "1";
-  sut(function(err, options){
-    options.service_name.should.equal("gitlab-ci");
-    options.service_job_id.should.equal("1234");
-    options.service_pull_request.should.equal("1");
-    options.git.should.eql({ head:
-                               { id: 'e3e3e3e3e3e3e3e3e',
-                                 author_name: 'Unknown Author',
-                                 author_email: '',
-                                 committer_name: 'Unknown Committer',
-                                 committer_email: '',
-                                 message: 'Unknown Commit Message' },
-                              branch: 'feature',
-                              remotes: [] });
+  process.env.CI_BUILD_ID = '1234';
+  process.env.CI_BUILD_REF = 'e3e3e3e3e3e3e3e3e';
+  process.env.CI_BUILD_REF_NAME = 'feature';
+  process.env.CI_MERGE_REQUEST_IID = '1';
+
+  const git = {
+    head: {
+      id: 'e3e3e3e3e3e3e3e3e',
+      author_name: 'Unknown Author',
+      author_email: '',
+      committer_name: 'Unknown Committer',
+      committer_email: '',
+      message: 'Unknown Commit Message'
+    },
+    branch: 'feature',
+    remotes: []
+  };
+
+  sut((err, options) => {
+    should.not.exist(err);
+    options.service_name.should.equal('gitlab-ci');
+    options.service_job_id.should.equal('1234');
+    options.service_pull_request.should.equal('1');
+    options.git.should.eql(git);
     done();
   });
 };
 
-var testSurf = function(sut, done) {
+const testSurf = (sut, done) => {
   process.env.CI_NAME = 'surf';
-  process.env.SURF_SHA1 = "e3e3e3e3e3e3e3e3e";
-  process.env.SURF_REF = "feature";
-  sut(function(err, options){
-    options.service_name.should.equal("surf");
-    options.git.should.eql({ head:
-                               { id: 'e3e3e3e3e3e3e3e3e',
-                                 author_name: 'Unknown Author',
-                                 author_email: '',
-                                 committer_name: 'Unknown Committer',
-                                 committer_email: '',
-                                 message: 'Unknown Commit Message' },
-                              branch: 'feature',
-                              remotes: [] });
+  process.env.SURF_SHA1 = 'e3e3e3e3e3e3e3e3e';
+  process.env.SURF_REF = 'feature';
+
+  const git = {
+    head: {
+      id: 'e3e3e3e3e3e3e3e3e',
+      author_name: 'Unknown Author',
+      author_email: '',
+      committer_name: 'Unknown Committer',
+      committer_email: '',
+      message: 'Unknown Commit Message'
+    },
+    branch: 'feature',
+    remotes: []
+  };
+
+  sut((err, options) => {
+    should.not.exist(err);
+    options.service_name.should.equal('surf');
+    options.git.should.eql(git);
     done();
   });
 };
 
-var testBuildkite = function(sut, done) {
+const testBuildkite = (sut, done) => {
   process.env.BUILDKITE = true;
-  process.env.BUILDKITE_BUILD_NUMBER = "1234";
-  process.env.BUILDKITE_COMMIT = "e3e3e3e3e3e3e3e3e";
-  process.env.BUILDKITE_BRANCH = "feature";
+  process.env.BUILDKITE_BUILD_NUMBER = '1234';
+  process.env.BUILDKITE_COMMIT = 'e3e3e3e3e3e3e3e3e';
+  process.env.BUILDKITE_BRANCH = 'feature';
   process.env.BUILDKITE_BUILD_CREATOR = 'john doe';
   process.env.BUILDKITE_BUILD_CREATOR_EMAIL = '[email protected]';
   process.env.BUILDKITE_MESSAGE = 'msgmsgmsg';
-  sut(function(err, options){
-    options.service_name.should.equal("buildkite");
-    options.git.should.eql({ head:
-                               { id: 'e3e3e3e3e3e3e3e3e',
-                                 author_name: 'Unknown Author',
-                                 author_email: '',
-                                 committer_name: 'john doe',
-                                 committer_email: '[email protected]',
-                                 message: 'msgmsgmsg' },
-                              branch: 'feature',
-                              remotes: [] });
+
+  const git = {
+    head: {
+      id: 'e3e3e3e3e3e3e3e3e',
+      author_name: 'Unknown Author',
+      author_email: '',
+      committer_name: 'john doe',
+      committer_email: '[email protected]',
+      message: 'msgmsgmsg'
+    },
+    branch: 'feature',
+    remotes: []
+  };
+
+  sut((err, options) => {
+    should.not.exist(err);
+    options.service_name.should.equal('buildkite');
+    options.git.should.eql(git);
     done();
   });
 };
 
-
-var testSemaphore = function(sut, done) {
+const testSemaphore = (sut, done) => {
   process.env.SEMAPHORE = true;
   process.env.SEMAPHORE_BUILD_NUMBER = '1234';
-  process.env.REVISION = "e3e3e3e3e3e3e3e3e";
-  process.env.BRANCH_NAME = "master";
-
-  sut(function(err, options){
-    options.service_name.should.equal("semaphore");
-    options.service_job_id.should.equal("1234");
-    options.git.should.eql({ head:
-                               { id: 'e3e3e3e3e3e3e3e3e',
-                                 author_name: 'Unknown Author',
-                                 author_email: '',
-                                 committer_name: 'Unknown Committer',
-                                 committer_email: '',
-                                 message: 'Unknown Commit Message' },
-                              branch: 'master',
-                              remotes: [] });
+  process.env.REVISION = 'e3e3e3e3e3e3e3e3e';
+  process.env.BRANCH_NAME = 'master';
+
+  const git = {
+    head: {
+      id: 'e3e3e3e3e3e3e3e3e',
+      author_name: 'Unknown Author',
+      author_email: '',
+      committer_name: 'Unknown Committer',
+      committer_email: '',
+      message: 'Unknown Commit Message'
+    },
+    branch: 'master',
+    remotes: []
+  };
+
+  sut((err, options) => {
+    should.not.exist(err);
+    options.service_name.should.equal('semaphore');
+    options.service_job_id.should.equal('1234');
+    options.git.should.eql(git);
     done();
   });
 };
 
-var testAzurePipelines = function(sut, done){
-  process.env.TF_BUILD = "true";
-  process.env.BUILD_SOURCEBRANCHNAME = "hotfix";
-  process.env.BUILD_SOURCEVERSION = "e3e3e3e3e3e3e3e3e";
-  process.env.BUILD_BUILDID = "1234";
-  process.env.SYSTEM_PULLREQUEST_PULLREQUESTNUMBER = "123";
-
-  sut(function(err, options){
-    options.service_name.should.equal("Azure Pipelines");
-    options.service_job_id.should.equal("1234");
-    options.service_pull_request.should.equal("123");
-
-    options.git.should.eql({ head:
-      { id: 'e3e3e3e3e3e3e3e3e',
-        author_name: 'Unknown Author',
-        author_email: '',
-        committer_name: 'Unknown Committer',
-        committer_email: '',
-        message: 'Unknown Commit Message' },
-     branch: 'hotfix',
-     remotes: [] });
-
+const testAzurePipelines = (sut, done) => {
+  process.env.TF_BUILD = 'true';
+  process.env.BUILD_SOURCEBRANCHNAME = 'hotfix';
+  process.env.BUILD_SOURCEVERSION = 'e3e3e3e3e3e3e3e3e';
+  process.env.BUILD_BUILDID = '1234';
+  process.env.SYSTEM_PULLREQUEST_PULLREQUESTNUMBER = '123';
+
+  const git = {
+    head: {
+      id: 'e3e3e3e3e3e3e3e3e',
+      author_name: 'Unknown Author',
+      author_email: '',
+      committer_name: 'Unknown Committer',
+      committer_email: '',
+      message: 'Unknown Commit Message'
+    },
+    branch: 'hotfix',
+    remotes: []
+  };
+
+  sut((err, options) => {
+    should.not.exist(err);
+    options.service_name.should.equal('Azure Pipelines');
+    options.service_job_id.should.equal('1234');
+    options.service_pull_request.should.equal('123');
+    options.git.should.eql(git);
     done();
   });
 };
 
-
 function ensureLocalGitContext(options) {
-  var path = require('path');
-  var fs = require('fs');
+  const baseDir = process.cwd();
+  let dir = baseDir;
+  let gitDir;
 
-  var baseDir = process.cwd(), dir = baseDir, gitDir;
   while (path.resolve('/') !== dir) {
     gitDir = path.join(dir, '.git');
-    var existsSync = fs.existsSync || path.existsSync;
-    if (existsSync(path.join(gitDir, 'HEAD')))
+    const existsSync = fs.existsSync || path.existsSync;
+    if (existsSync(path.join(gitDir, 'HEAD'))) {
       break;
+    }
 
     dir = path.dirname(dir);
   }
 
   options = options || {};
-  var synthetic = path.resolve('/') === dir;
-  var gitHead, content, branch, id, wrapUp = function() {};
+  const synthetic = path.resolve('/') === dir;
+  let gitHead;
+  let content;
+  let branch;
+  let id;
+  let wrapUp = () => {};
 
   if (synthetic) {
     branch = 'synthetic';
     id = '424242424242424242';
     gitHead = path.join('.git', 'HEAD');
-    var gitBranch = path.join('.git', 'refs', 'heads', branch);
+    const gitBranch = path.join('.git', 'refs', 'heads', branch);
     fs.mkdirSync('.git');
     if (options.detached) {
       fs.writeFileSync(gitHead, id, { encoding: 'utf8' });
     } else {
       fs.mkdirSync(path.join('.git', 'refs'));
       fs.mkdirSync(path.join('.git', 'refs', 'heads'));
-      fs.writeFileSync(gitHead, "ref: refs/heads/" + branch, { encoding: 'utf8' });
+      fs.writeFileSync(gitHead, `ref: refs/heads/${branch}`, { encoding: 'utf8' });
       fs.writeFileSync(gitBranch, id, { encoding: 'utf8' });
     }
-    wrapUp = function() {
+
+    wrapUp = () => {
       fs.unlinkSync(gitHead);
       if (!options.detached) {
         fs.unlinkSync(gitBranch);
         fs.rmdirSync(path.join('.git', 'refs', 'heads'));
         fs.rmdirSync(path.join('.git', 'refs'));
       }
+
       fs.rmdirSync('.git');
     };
   } else if (options.noGit) {
-    fs.renameSync(gitDir, gitDir + '.bak');
-    wrapUp = function() {
-      fs.renameSync(gitDir + '.bak', gitDir);
+    fs.renameSync(gitDir, `${gitDir}.bak`);
+    wrapUp = () => {
+      fs.renameSync(`${gitDir}.bak`, gitDir);
     };
   } else if (options.detached) {
     gitHead = path.join(gitDir, 'HEAD');
     content = fs.readFileSync(gitHead, 'utf8').trim();
-    var b = (content.match(/^ref: refs\/heads\/(\S+)$/) || [])[1];
+    const b = (content.match(/^ref: refs\/heads\/(\S+)$/) || [])[1];
     if (!b) {
       id = content;
     } else {
       id = fs.readFileSync(path.join(gitDir, 'refs', 'heads', b), 'utf8').trim();
       fs.writeFileSync(gitHead, id, 'utf8');
-      wrapUp = function() {
+      wrapUp = () => {
         fs.writeFileSync(gitHead, content, 'utf8');
       };
     }
@@ -612,5 +710,9 @@ function ensureLocalGitContext(options) {
     id = branch ? fs.readFileSync(path.join(gitDir, 'refs', 'heads', branch), 'utf8').trim() : content;
   }
 
-  return { id: id, branch: branch, wrapUp: wrapUp };
+  return {
+    id,
+    branch,
+    wrapUp
+  };
 }