chore: cleanup

Author: martinmcwhorter

src/engine.ts

@@ -7,7 +7,7 @@ import { footerMaker } from './prompts/footer-maker';
 import { bodyMaker } from './prompts/body-maker';
 import { scopeMaker } from './prompts/scope-maker';
 import { subjectMaker } from './prompts/subject-maker';
-import { Question } from './commit-template';
+import { Question, commitTemplate } from './commit-template';
 
 function buildQuestions(rules: Rules) {
   const combinedQuestions = pipeWith<Question[]>(
@@ -24,7 +24,10 @@ function buildQuestions(rules: Rules) {
 
 export async function engine(config: CommitlintConfig, prompt: PromptModule, commit: Commit) {
   const questions = buildQuestions(config.rules);
+
   const answers = await prompt(questions);
 
-  console.log(JSON.stringify(answers));
+  const message = commitTemplate(answers);
+
+  return commit(message);
 }

src/index.ts

@@ -8,4 +8,9 @@ export async function prompter(cz: { prompt: PromptModule }, commit: Commit) {
   engine(clConfig, cz.prompt, commit);
 }
 
-prompter({ prompt }, value => console.log(value));
+/**
+ * Hacking
+ *
+ * Uncomment the following line for simplified local development without commitizen.
+ */
+// prompter({ prompt }, value => console.log(value));

src/prompts/footer-maker.ts

@@ -1,41 +1,83 @@
 import { Rules } from '@commitlint/load';
-import { DistinctQuestion, Answers } from 'inquirer';
-import { valueFromRule } from '../utils';
-import { PromptAnswers } from '../commit-template';
+import { valueFromRule, maxLengthTransformerFactory, pipeWith } from '../utils';
+import { Answers, Question } from '../commit-template';
 import { validate, maxLengthValidator, minLengthValidator } from '../validators';
+import { leadingBlankFilter, maxLineLengthFilter } from '../filters';
 
 export function validatorFactory(rules: Rules) {
-  return (value: string) =>
-    validate([
+  return (value: string, answers: Answers) => {
+    const breaking = answers.breaking ?? '';
+
+    return validate([
       {
-        value,
+        value: value + breaking,
         rule: rules['footer-max-length'],
         validator: maxLengthValidator,
-        message: length => `Body maximum length of ${length} has been exceeded`
+        message: length => 'Footer maximum length of ${length} has been exceeded'
       },
       {
-        value,
+        value: value + breaking,
         rule: rules['footer-min-length'],
         validator: minLengthValidator,
-        message: length => `Subject minimum length of ${length} has not been met`
+        message: length => `Footer minimum length of ${length} has not been met`
       }
     ]);
+  };
+}
+
+export function filterFactory(rules: Rules) {
+  return (value: string): string =>
+    pipeWith<string>(
+      value,
+      v => leadingBlankFilter(v, rules['footer-leading-blank']),
+      v => maxLineLengthFilter(v, rules['footer-max-line-length'])
+    );
 }
 
-function breakingChangeMessageFactory(rules: Rules) {
-  return (answers: Answers) => {
+export function breakingChangeMessageFactory(rules: Rules) {
+  return () => {
     const maxLength = valueFromRule(rules['footer-max-length']);
 
     if (!maxLength) {
-      return `Describe the breaking changes:\n:\n`;
+      return `Describe the breaking changes:\n`;
     }
 
     return `Describe the breaking changes:\n (max ${maxLength} chars):\n`;
   };
 }
 
-export function footerMaker(questions: DistinctQuestion[], rules: Rules): DistinctQuestion[] {
-  const breakingQuestions: DistinctQuestion<PromptAnswers>[] = [
+export function issuesMessageFactory(rules: Rules) {
+  return () => {
+    const maxLength = valueFromRule(rules['footer-max-length']);
+
+    if (!maxLength) {
+      return `List issues fixed:\n`;
+    }
+
+    return `List issues fixed:\n (max ${maxLength} chars):\n`;
+  };
+}
+
+function isFixCommit(answers: Answers) {
+  return answers?.type == 'fix' ?? false;
+}
+
+export function issuesTransformerFactory(rules: Rules) {
+  return (value: string, answers: Answers) => {
+    const breaking = answers.breaking ?? '';
+
+    const footerMaxLength = valueFromRule(rules['footer-max-length']);
+
+    if (footerMaxLength) {
+      return maxLengthTransformerFactory(footerMaxLength - breaking.length)(value);
+    }
+
+    return value;
+  };
+}
+
+export function footerMaker(questions: Question[], rules: Rules): Question[] {
+  const breakingQuestions: Question[] = [
     {
       type: 'confirm',
       name: 'isBreaking',
@@ -44,10 +86,28 @@ export function footerMaker(questions: DistinctQuestion[], rules: Rules): Distin
     },
     {
       type: 'input',
-      name: 'beaking',
+      name: 'breaking',
       message: breakingChangeMessageFactory(rules),
       when: answers => !!answers.isBreaking,
-      validate: validatorFactory(rules)
+      validate: validatorFactory(rules),
+      transformer: maxLengthTransformerFactory(valueFromRule(rules['footer-max-length'])),
+      filter: filterFactory(rules)
+    },
+    {
+      type: 'confirm',
+      name: 'isIssue',
+      message: 'Does this fix any issues?',
+      when: answers => !isFixCommit(answers),
+      default: false
+    },
+    {
+      type: 'input',
+      name: 'issue',
+      message: issuesMessageFactory(rules),
+      when: answers => isFixCommit(answers) || !!answers.isIssue,
+      validate: validatorFactory(rules),
+      transformer: issuesTransformerFactory(rules),
+      filter: filterFactory(rules)
     }
   ];
 

src/prompts/subject-maker.test.ts

@@ -1,12 +1,12 @@
 import { Rules, Level } from '@commitlint/load';
 
 import { green, red } from 'chalk';
-import { PromptAnswers } from '../commit-template';
+import { Answers } from '../commit-template';
 import { validatorFactory, filterFactory, messageFactory, transformerFactory, subjectMaker } from './subject-maker';
 
 describe('subject-maker', () => {
   describe('validatorFactory', () => {
-    test.each<[Rules, string, PromptAnswers, string | true]>([
+    test.each<[Rules, string, Answers, string | true]>([
       [
         { 'header-max-length': [Level.Error, 'always', 3] },
         'too long',
@@ -52,7 +52,7 @@ describe('subject-maker', () => {
   });
 
   describe('messageFactory', () => {
-    test.each<[Rules, PromptAnswers, string]>([
+    test.each<[Rules, Answers, string]>([
       [
         { 'header-max-length': [Level.Error, 'always', 72] },
         { type: 'feat', scope: 'foo' },
@@ -69,7 +69,7 @@ describe('subject-maker', () => {
   });
 
   describe('transformerFactory', () => {
-    test.each<[Rules, string, PromptAnswers, string]>([
+    test.each<[Rules, string, Answers, string]>([
       [{ 'header-max-length': [Level.Error, 'always', 14] }, 'foo', { type: 'feat', scope: 'bar' }, green('(3) foo')],
       [{ 'header-max-length': [Level.Error, 'always', 13] }, 'foo', { type: 'feat', scope: 'bar' }, red('(3) foo')],
       [{ 'subject-max-length': [Level.Error, 'always', 3] }, 'foo', {}, green('(3) foo')],

src/prompts/subject-maker.ts

@@ -3,10 +3,10 @@ import { red, green } from 'chalk';
 import { pipeWith, valueFromRule } from '../utils';
 import { caseValidator, emptyValidator, maxLengthValidator, minLengthValidator, validate } from '../validators';
 import { fullStopFilter, wordCaseFilter } from '../filters';
-import { headerTemplate, PromptAnswers, Question } from '../commit-template';
+import { headerTemplate, Answers, Question } from '../commit-template';
 
 export function validatorFactory(rules: Rules) {
-  return (value: string, answers: PromptAnswers) => {
+  return (value: string, answers: Answers) => {
     const headerValue = headerTemplate(answers.type, answers.scope, value);
 
     return validate([
@@ -54,7 +54,7 @@ export function filterFactory(rules: Rules) {
 }
 
 export function messageFactory(rules: Rules) {
-  return (answers: PromptAnswers) => {
+  return (answers: Answers) => {
     const maxLength = valueFromRule(rules['header-max-length']);
 
     if (!maxLength) {
@@ -69,7 +69,7 @@ export function messageFactory(rules: Rules) {
 export function transformerFactory(rules: Rules) {
   const filter = filterFactory(rules);
 
-  return (value: string, answers: PromptAnswers) => {
+  return (value: string, answers: Answers) => {
     const headerMaxLength = valueFromRule(rules['header-max-length']);
 
     if (headerMaxLength) {

src/prompts/type-maker.ts

@@ -1,11 +1,11 @@
 import { Rules } from '@commitlint/load';
-import { ChoiceOptions, DistinctQuestion, ListQuestion } from 'inquirer';
+import { ChoiceOptions, ListQuestion } from 'inquirer';
 import { types, CommitType } from 'conventional-commit-types';
 import { getLongest } from '../utils';
 import { caseValidator, emptyValidator, maxLengthValidator, minLengthValidator, validate } from '../validators';
 import { whenFactory } from '../when';
 import { wordCaseFilter } from '../filters';
-import { Question, PromptAnswers } from '../commit-template';
+import { Question, Answers } from '../commit-template';
 
 export function validatorFactory(rules: Rules) {
   return (value: string) => {
@@ -59,7 +59,7 @@ export function choicesFactory(rules: Rules, commitTypes: CommitType) {
 }
 
 export function typeMaker(questions: Question[], rules: Rules): Question[] {
-  const question: ListQuestion<PromptAnswers> = {
+  const question: ListQuestion<Answers> = {
     name: 'type',
     message: "Select the type of change you're committing:\n",
     type: 'list',

src/typings.d.ts

@@ -31,6 +31,7 @@ declare module '@commitlint/load' {
     'footer-leading-blank'?: Rule<undefined>;
     'footer-max-length'?: Rule<number>;
     'footer-min-length'?: Rule<number>;
+    'footer-max-line-length'?: Rule<number>;
     'header-case'?: Rule<Case>;
     'header-full-stop'?: Rule<string>;
     'header-max-length'?: Rule<number>;