engine.js

/* eslint-disable functional/immutable-data */
/* eslint-disable object-shorthand */
/* eslint-disable no-unneeded-ternary */
/* eslint-disable no-unused-vars */
/* eslint-disable eqeqeq */
/* eslint-disable no-param-reassign */
/* eslint-disable prefer-template */
/* eslint-disable no-empty */
/* eslint-disable vars-on-top */
/* eslint-disable func-names */
/* eslint-disable radix */
/* eslint-disable no-var */

'format cjs';

var wrap = require('word-wrap');
var chalk = require('chalk');
var branchName = require('current-git-branch');

var longest = function (arr) {
  if (!Array.isArray(arr)) {
    throw new TypeError('expected an array');
  }

  var len = arr.length;
  if (len === 0) {
    return undefined;
  }

  var val = arr[0];
  if (typeof val === 'number') {
    val = String(val);
  }

  var longest = val.length;
  var idx = 0;

  while (++idx < len) {
    var ele = arr[idx];
    if (ele == null) {
      continue;
    }

    if (typeof ele === 'number') {
      ele = String(ele);
    }

    var elen = ele.length;
    if (typeof elen !== 'number') {
      continue;
    }

    if (elen > longest) {
      longest = elen;
      val = ele;
    }
  }
  return val;
};

var objectMap = (object, mapFn) => {
  return Object.keys(object).map(function (key) {
    return mapFn(object[key], key);
  });
};

var headerLength = function (answers) {
  return (
    answers.ticket.length +
    3 +
    answers.type.length +
    2 +
    (answers.scope ? answers.scope.length + 2 : 0)
  );
};

var maxSummaryLength = function (options, answers) {
  return options.maxHeaderWidth - headerLength(answers);
};

var filterSubject = function (subject) {
  subject = subject.trim();
  if (subject.charAt(0).toLowerCase() !== subject.charAt(0)) {
    subject =
      subject.charAt(0).toLowerCase() + subject.slice(1, subject.length);
  }
  while (subject.endsWith('.')) {
    subject = subject.slice(0, subject.length - 1);
  }
  return subject;
};

// This can be any kind of SystemJS compatible module.
// We use Commonjs here, but ES6 or AMD would do just
// fine.
module.exports = function (options) {
  var types = options.types;

  var length = longest(Object.keys(types)).length + 1;
  var choices = objectMap(types, function (type, key) {
    return {
      // name: rightPad(key + ':', length) + ' ' + type.description,
      name: key.padEnd(length, ' ') + ':' + ' ' + type.description,
      value: key,
    };
  });

  return {
    // When a user runs `git cz`, prompter will
    // be executed. We pass you cz, which currently
    // is just an instance of inquirer.js. Using
    // this you can ask questions and get answers.
    //
    // The commit callback should be executed when
    // you're ready to send back a commit template
    // to git.
    //
    // By default, we'll de-indent your commit
    // template and will keep empty lines.
    prompter: function (cz, commit) {
      // Let's ask some questions of the user
      // so that we can populate our commit
      // template.
      //
      // See inquirer.js docs for specifics.
      // You can also opt to use another input
      // collection library if you prefer.
      cz.prompt([
        {
          type: 'input',
          name: 'ticket',
          message: 'Enter the relevant JIRA ticket (e.g. TASK-666):',
          default: branchName() || 'TASK-',
          validate: function (ticket) {
            return /^[A-Z]+-[0-9]+$/.test(ticket);
          },
          transformer: function (ticket) {
            return ticket.toUpperCase();
          },
        },
        {
          type: 'list',
          name: 'type',
          message: "Select the type of change that you're committing:",
          choices: choices,
          default: options.defaultType,
        },
        {
          type: 'input',
          name: 'subject',
          message: function (answers) {
            return (
              'Write a short, imperative tense description of the change (max ' +
              maxSummaryLength(options, answers) +
              ' chars):\n'
            );
          },
          default: options.defaultSubject,
          validate: function (subject, answers) {
            var filteredSubject = filterSubject(subject);
            return filteredSubject.length == 0
              ? 'subject is required'
              : filteredSubject.length <= maxSummaryLength(options, answers)
              ? true
              : 'Subject length must be less than or equal to ' +
                maxSummaryLength(options, answers) +
                ' characters. Current length is ' +
                filteredSubject.length +
                ' characters.';
          },
          transformer: function (subject, answers) {
            var filteredSubject = filterSubject(subject);
            var color =
              filteredSubject.length <= maxSummaryLength(options, answers)
                ? chalk.green
                : chalk.red;
            return color('(' + filteredSubject.length + ') ' + subject);
          },
          filter: function (subject) {
            return filterSubject(subject);
          },
        },
        {
          type: 'input',
          name: 'body',
          message:
            'Provide a longer description of the change: (press enter to skip)\n',
          default: options.defaultBody,
        },
        {
          type: 'confirm',
          name: 'isBreaking',
          message: 'Are there any breaking changes?',
          default: false,
        },
        {
          type: 'input',
          name: 'breakingBody',
          default: '-',
          message:
            'A BREAKING CHANGE commit requires a body. Please enter a longer description of the commit:\n',
          when: function (answers) {
            return answers.isBreaking && !answers.body;
          },
          validate: function (breakingBody, answers) {
            return (
              breakingBody.trim().length > 0 ||
              'Body is required for BREAKING CHANGE'
            );
          },
        },
        {
          type: 'input',
          name: 'breaking',
          message: 'Describe the breaking changes:\n',
          when: function (answers) {
            return answers.isBreaking;
          },
        },
      ]).then(function (answers) {
        var wrapOptions = {
          trim: true,
          cut: false,
          newline: '\n',
          indent: '',
          width: options.maxLineWidth,
        };

        var ticket = '[' + answers.ticket + ']';

        // parentheses are only needed when a scope is present
        var scope = answers.scope ? '(' + answers.scope + ')' : '';

        // Hard limit this line in the validate
        var head = answers.type + scope + ': ' + ticket + ' ' + answers.subject;

        // Wrap these lines at options.maxLineWidth characters
        var body = answers.body ? wrap(answers.body, wrapOptions) : false;

        // Apply breaking change prefix, removing it if already present
        var breaking = answers.breaking ? answers.breaking.trim() : '';
        breaking = breaking
          ? 'BREAKING CHANGE: ' + breaking.replace(/^BREAKING CHANGE: /, '')
          : '';
        breaking = breaking ? wrap(breaking, wrapOptions) : false;

        var issues = answers.issues ? wrap(answers.issues, wrapOptions) : false;

        commit(
          [head, body, breaking, issues]
            .filter(function (x) {
              return x;
            })
            .join('\n\n')
        );
      });
    },
  };
};