refactor: improve commit message functionality

lib/types/commit-message-json.ts

@@ -0,0 +1,5 @@
+export interface CommitMessageJSON {
+  body?: string;
+  footer?: string;
+  subject?: string;
+}

lib/types/index.ts

@@ -1,3 +1,4 @@
+export type { CommitMessageJSON } from './commit-message-json';
 export * from './host-rules';
 export * from './skip-reason';
 export * from './versioning';

lib/workers/repository/model/commit-message-factory.ts

@@ -0,0 +1,51 @@
+import type { RenovateSharedConfig } from '../../../config/types';
+import type { CommitMessage } from './commit-message';
+import { CustomCommitMessage } from './custom-commit-message';
+import { SemanticCommitMessage } from './semantic-commit-message';
+
+type CommitMessageConfig = Pick<
+  RenovateSharedConfig,
+  | 'commitMessagePrefix'
+  | 'semanticCommits'
+  | 'semanticCommitScope'
+  | 'semanticCommitType'
+>;
+
+export class CommitMessageFactory {
+  readonly #config: CommitMessageConfig;
+
+  constructor(config: CommitMessageConfig) {
+    this.#config = config;
+  }
+
+  create(): CommitMessage {
+    const message = this.areSemanticCommitsEnabled
+      ? this.createSemanticCommitMessage()
+      : this.createCustomCommitMessage();
+
+    return message;
+  }
+
+  private createSemanticCommitMessage(): SemanticCommitMessage {
+    const message = new SemanticCommitMessage();
+
+    message.type = this.#config.semanticCommitType ?? '';
+    message.scope = this.#config.semanticCommitScope ?? '';
+
+    return message;
+  }
+
+  private createCustomCommitMessage(): CustomCommitMessage {
+    const message = new CustomCommitMessage();
+    message.prefix = this.#config.commitMessagePrefix ?? '';
+
+    return message;
+  }
+
+  private get areSemanticCommitsEnabled(): boolean {
+    return (
+      !this.#config.commitMessagePrefix &&
+      this.#config.semanticCommits === 'enabled'
+    );
+  }
+}

lib/workers/repository/model/commit-message.ts

@@ -1,54 +1,87 @@
-export class CommitMessage {
-  public static readonly SEPARATOR: string = ':';
+import type { CommitMessageJSON } from '../../../types';
 
-  private message = '';
+/**
+ * @see https://git-scm.com/docs/git-commit#_discussion
+ *
+ * [optional prefix]: <suject>
+ * [optional body]
+ * [optional footer]
+ */
+export abstract class CommitMessage {
+  static readonly #SEPARATOR: string = ':';
+  static readonly #EXTRA_WHITESPACES = /\s+/g;
 
-  private prefix = '';
+  #body = '';
+  #footer = '';
+  #subject = '';
 
-  constructor(message = '') {
-    this.setMessage(message);
-  }
-
-  public static formatPrefix(prefix: string): string {
+  static formatPrefix(prefix: string): string {
     if (!prefix) {
       return '';
     }
 
-    if (prefix.endsWith(CommitMessage.SEPARATOR)) {
+    if (prefix.endsWith(CommitMessage.#SEPARATOR)) {
       return prefix;
     }
 
-    return `${prefix}${CommitMessage.SEPARATOR}`;
+    return `${prefix}${CommitMessage.#SEPARATOR}`;
   }
 
-  public setMessage(message: string): void {
-    this.message = (message || '').trim();
+  toJSON(): CommitMessageJSON {
+    return {
+      body: this.#body,
+      footer: this.#footer,
+      subject: this.#subject,
+    };
   }
 
-  public setCustomPrefix(prefix?: string): void {
-    this.prefix = (prefix ?? '').trim();
+  toString(): string {
+    const parts: ReadonlyArray<string | undefined> = [
+      this.title,
+      this.#body,
+      this.#footer,
+    ];
+
+    return parts.filter(Boolean).join('\n\n');
   }
 
-  public setSemanticPrefix(type?: string, scope?: string): void {
-    this.prefix = (type ?? '').trim();
+  get title(): string {
+    return [CommitMessage.formatPrefix(this.prefix), this.formatSubject()]
+      .join(' ')
+      .trim();
+  }
 
-    if (scope?.trim()) {
-      this.prefix += `(${scope.trim()})`;
-    }
+  set body(value: string) {
+    this.#body = this.normalizeInput(value);
   }
 
-  public toString(): string {
-    const prefix = CommitMessage.formatPrefix(this.prefix);
-    const message = this.formatMessage();
+  set footer(value: string) {
+    this.#footer = this.normalizeInput(value);
+  }
 
-    return [prefix, message].join(' ').trim();
+  set subject(value: string) {
+    this.#subject = this.normalizeInput(value);
+    this.#subject = this.#subject?.replace(
+      CommitMessage.#EXTRA_WHITESPACES,
+      ' '
+    );
   }
 
-  private formatMessage(): string {
+  formatSubject(): string {
+    if (!this.#subject) {
+      return '';
+    }
+
     if (this.prefix) {
-      return this.message;
+      return this.#subject.charAt(0).toLowerCase() + this.#subject.slice(1);
     }
 
-    return this.message.charAt(0).toUpperCase() + this.message.slice(1);
+    return this.#subject.charAt(0).toUpperCase() + this.#subject.slice(1);
+  }
+
+  protected abstract get prefix(): string;
+
+  protected normalizeInput(value?: string | null): string {
+    return value?.trim() ?? '';
   }
 }

lib/workers/repository/model/custom-commit-message.spec.ts

@@ -0,0 +1,51 @@
+import { CustomCommitMessage } from './custom-commit-message';
+
+describe('workers/repository/model/custom-commit-message', () => {
+  describe('CustomCommitMessage', () => {
+    const TEST_CASES: ReadonlyArray<
+      [message: string, prefix: string | undefined, result: string]
+    > = [
+      ['test', '', 'Test'],
+      ['  test  ', '  ', 'Test'],
+      ['test', 'fix', 'fix: test'],
+      ['test', 'fix:', 'fix: test'],
+      [
+        'Message    With   Extra  Whitespaces   ',
+        '  refactor   ',
+        'refactor: message With Extra Whitespaces',
+      ],
+    ];
+
+    it.each(TEST_CASES)(
+      'given %p and %p as arguments, returns %p',
+      (subject, prefix, result) => {
+        const commitMessage = new CustomCommitMessage();
+        commitMessage.subject = subject;
+        commitMessage.prefix = prefix;
+
+        expect(commitMessage.toString()).toEqual(result);
+      }
+    );
+
+    it('should provide ability to set body and footer', () => {
+      const commitMessage = new CustomCommitMessage();
+      commitMessage.subject = 'subject';
+      commitMessage.body = 'body';
+      commitMessage.footer = 'footer';
+
+      expect(commitMessage.toJSON()).toEqual({
+        body: 'body',
+        footer: 'footer',
+        prefix: '',
+        subject: 'subject',
+      });
+      expect(commitMessage.toString()).toBe('Subject\n\nbody\n\nfooter');
+    });
+
+    it('should remove empty subject by default', () => {
+      const commitMessage = new CustomCommitMessage();
+
+      expect(commitMessage.formatSubject()).toBe('');
+    });
+  });
+});

lib/workers/repository/model/custom-commit-message.ts

@@ -0,0 +1,27 @@
+import type { CommitMessageJSON } from '../../../types';
+import { CommitMessage } from './commit-message';
+
+export interface CustomCommitMessageJSON extends CommitMessageJSON {
+  prefix?: string;
+}
+
+export class CustomCommitMessage extends CommitMessage {
+  #prefix = '';
+
+  get prefix(): string {
+    return this.#prefix;
+  }
+
+  set prefix(value: string) {
+    this.#prefix = this.normalizeInput(value);
+  }
+
+  override toJSON(): CustomCommitMessageJSON {
+    const json = super.toJSON();
+
+    return {
+      ...json,
+      prefix: this.#prefix,
+    };
+  }
+}

lib/workers/repository/model/semantic-commit-message.spec.ts

@@ -0,0 +1,73 @@
+import { SemanticCommitMessage } from './semantic-commit-message';
+
+describe('workers/repository/model/semantic-commit-message', () => {
+  it('should format message without prefix', () => {
+    const message = new SemanticCommitMessage();
+    message.subject = 'test';
+
+    expect(message.toString()).toBe('Test');
+  });
+
+  it('should format sematic type', () => {
+    const message = new SemanticCommitMessage();
+    message.subject = 'test';
+    message.type = ' fix ';
+
+    expect(message.toString()).toBe('fix: test');
+  });
+
+  it('should format sematic prefix with scope', () => {
+    const message = new SemanticCommitMessage();
+    message.subject = 'test';
+    message.type = ' fix ';
+    message.scope = ' scope ';
+
+    expect(message.toString()).toBe('fix(scope): test');
+  });
+
+  it('should create instance from string without scope', () => {
+    const instance = SemanticCommitMessage.fromString('feat: ticket 123');
+
+    expect(SemanticCommitMessage.is(instance)).toBeTrue();
+    expect(instance.toJSON()).toEqual({
+      body: '',
+      footer: '',
+      scope: '',
+      subject: 'ticket 123',
+      type: 'feat',
+    });
+  });
+
+  it('should create instance from string with scope', () => {
+    const instance = SemanticCommitMessage.fromString(
+      'fix(dashboard): ticket 123'
+    );
+
+    expect(SemanticCommitMessage.is(instance)).toBeTrue();
+    expect(instance.toJSON()).toEqual({
+      body: '',
+      footer: '',
+      scope: 'dashboard',
+      subject: 'ticket 123',
+      type: 'fix',
+    });
+  });
+
+  it('should create instance from string with empty description', () => {
+    const instance = SemanticCommitMessage.fromString('fix(deps): ');
+
+    expect(SemanticCommitMessage.is(instance)).toBeTrue();
+    expect(instance.toJSON()).toEqual({
+      body: '',
+      footer: '',
+      scope: 'deps',
+      subject: '',
+      type: 'fix',
+    });
+  });
+
+  it('should return undefined for invalid string', () => {
+    const instance = SemanticCommitMessage.fromString('test');
+    expect(instance).toBeUndefined();
+  });
+});