haveno-ui/.github/actions/release-notes/main.js

// TODO: Refactor this action

const { execSync } = require("child_process");

/**
 * Gets the value of an input.  The value is also trimmed.
 *
 * @param     name     name of the input to get
 * @param     options  optional. See InputOptions.
 * @returns   string
 */
function getInput(name, options) {
  const val =
    process.env[`INPUT_${name.replace(/ /g, "_").toUpperCase()}`] || "";
  if (options && options.required && !val) {
    throw new Error(`Input required and not supplied: ${name}`);
  }

  return val.trim();
}

const START_FROM = getInput("from");
const END_TO = getInput("to");
const INCLUDE_COMMIT_BODY = getInput("include-commit-body") === "true";
const INCLUDE_ABBREVIATED_COMMIT =
  getInput("include-abbreviated-commit") === "true";

/**
 * @typedef {Object} ICommit
 * @property {string | undefined} abbreviated_commit
 * @property {string | undefined} subject
 * @property {string | undefined} body
 */

/**
 * @typedef {ICommit & {type: string | undefined, scope: string | undefined}} ICommitExtended
 */

/**
 * Any unique string that is guaranteed not to be used in committee text.
 * Used to split data in the commit line
 * @type {string}
 */
const commitInnerSeparator = "~~~~";

/**
 * Any unique string that is guaranteed not to be used in committee text.
 * Used to split each commit line
 * @type {string}
 */
const commitOuterSeparator = "₴₴₴₴";

/**
 * Commit data to be obtained.
 * @type {Map<string, string>}
 *
 * @see https://git-scm.com/docs/git-log#Documentation/git-log.txt-emnem
 */
const commitDataMap = new Map([
  ["subject", "%s"], // Required
]);

if (INCLUDE_COMMIT_BODY) {
  commitDataMap.set("body", "%b");
}

if (INCLUDE_ABBREVIATED_COMMIT) {
  commitDataMap.set("abbreviated_commit", "%h");
}

/**
 * The type used to group commits that do not comply with the convention
 * @type {string}
 */
const fallbackType = "other";

/**
 * List of all desired commit groups and in what order to display them.
 * @type {string[]}
 */
const supportedTypes = [
  "feat",
  "fix",
  "perf",
  "refactor",
  "style",
  "docs",
  "test",
  "build",
  "ci",
  "chore",
  "revert",
  "deps",
  fallbackType,
];

/**
 * @param {string} commitString
 * @returns {ICommit}
 */
function parseCommit(commitString) {
  /** @type {ICommit} */
  const commitDataObj = {};
  const commitDataArray = commitString
    .split(commitInnerSeparator)
    .map((s) => s.trim());

  for (const [key] of commitDataMap) {
    commitDataObj[key] = commitDataArray.shift();
  }

  return commitDataObj;
}

/**
 * Returns an array of commits since the last git tag
 * @return {ICommit[]}
 */
function getCommits() {
  const format =
    Array.from(commitDataMap.values()).join(commitInnerSeparator) +
    commitOuterSeparator;

  const logs = String(
    execSync(
      `git --no-pager log ${START_FROM}..${END_TO} --pretty=format:"${format}" --reverse`
    )
  );

  return logs
    .trim()
    .split(commitOuterSeparator)
    .filter((r) => !!r.trim()) // Skip empty lines
    .map(parseCommit);
}

/**
 *
 * @param {ICommit} commit
 * @return {ICommitExtended}
 */
function setCommitTypeAndScope(commit) {
  const matchRE = new RegExp(
    `^(?:(${supportedTypes.join("|")})(?:\\((\\S+)\\))?:)?(.*)`,
    "i"
  );

  let [, type, scope, clearSubject] = commit.subject.match(matchRE);

  /**
   * Additional rules for checking committees that do not comply with the convention, but for which it is possible to determine the type.
   */
  // Commits like `revert something`
  if (type === undefined && commit.subject.startsWith("revert")) {
    type = "revert";
  }

  return {
    ...commit,
    type: (type || fallbackType).toLowerCase().trim(),
    scope: (scope || "").toLowerCase().trim(),
    subject: (clearSubject || commit.subject).trim(),
  };
}

class CommitGroup {
  constructor() {
    this.scopes = new Map();
    this.commits = [];
  }

  /**
   *
   * @param {ICommitExtended[]} array
   * @param {ICommitExtended} commit
   */
  static _pushOrMerge(array, commit) {
    const similarCommit = array.find((c) => c.subject === commit.subject);
    if (similarCommit) {
      if (commit.abbreviated_commit !== undefined) {
        similarCommit.abbreviated_commit += `, ${commit.abbreviated_commit}`;
      }
    } else {
      array.push(commit);
    }
  }

  /**
   * @param {ICommitExtended} commit
   */
  push(commit) {
    if (!commit.scope) {
      CommitGroup._pushOrMerge(this.commits, commit);
      return;
    }

    const scope = this.scopes.get(commit.scope) || { commits: [] };
    CommitGroup._pushOrMerge(scope.commits, commit);
    this.scopes.set(commit.scope, scope);
  }

  get isEmpty() {
    return this.commits.length === 0 && this.scopes.size === 0;
  }
}

/**
 * Groups all commits by type and scopes
 * @param {ICommit[]} commits
 * @returns {Map<string, CommitGroup>}
 */
function getGroupedCommits(commits) {
  const parsedCommits = commits.map(setCommitTypeAndScope);

  const types = new Map(supportedTypes.map((id) => [id, new CommitGroup()]));

  for (const parsedCommit of parsedCommits) {
    const typeId = parsedCommit.type;
    const type = types.get(typeId);
    type.push(parsedCommit);
  }

  return types;
}

/**
 * Return markdown list with commits
 * @param {ICommitExtended[]} commits
 * @param {string} pad
 * @returns {string}
 */
function getCommitsList(commits, pad = "") {
  let changelog = "";
  for (const commit of commits) {
    changelog += `${pad}- ${commit.subject}.`;

    if (commit.abbreviated_commit !== undefined) {
      changelog += ` (${commit.abbreviated_commit})`;
    }

    changelog += "\r\n";

    if (commit.body === undefined) {
      continue;
    }

    const body = commit.body.replace("[skip ci]", "").trim();
    if (body !== "") {
      changelog += `${body
        .split(/\r*\n+/)
        .filter((s) => !!s.trim())
        .map((s) => `${pad}  ${s}`)
        .join("\r\n")}${"\r\n"}`;
    }
  }

  return changelog;
}

function replaceHeader(str) {
  switch (str) {
    case "feat":
      return "New Features";
    case "fix":
      return "Bug Fixes";
    case "docs":
      return "Documentation Changes";
    case "build":
      return "Build System";
    case "chore":
      return "Chores";
    case "ci":
      return "Continuous Integration";
    case "refactor":
      return "Refactors";
    case "style":
      return "Code Style Changes";
    case "test":
      return "Tests";
    case "perf":
      return "Performance improvements";
    case "revert":
      return "Reverts";
    case "deps":
      return "Dependency updates";
    case "other":
      return "Other Changes";
    default:
      return str;
  }
}

/**
 * Return markdown string with changelog
 * @param {Map<string, CommitGroup>} groups
 */
function getChangeLog(groups) {
  let changelog = "";

  for (const [typeId, group] of groups) {
    if (group.isEmpty) {
      continue;
    }

    changelog += `### ${replaceHeader(typeId)}${"\r\n"}`;

    for (const [scopeId, scope] of group.scopes) {
      if (scope.commits.length) {
        changelog += `- #### ${replaceHeader(scopeId)}${"\r\n"}`;
        changelog += getCommitsList(scope.commits, "  ");
      }
    }

    if (group.commits.length) {
      changelog += getCommitsList(group.commits);
    }

    changelog += "\r\n" + "\r\n";
  }

  return changelog.trim();
}

function escapeData(s) {
  return String(s)
    .replace(/%/g, "%25")
    .replace(/\r/g, "%0D")
    .replace(/\n/g, "%0A");
}

try {
  const commits = getCommits();
  const grouped = getGroupedCommits(commits);
  const changelog = getChangeLog(grouped);
  process.stdout.write(
    "::set-output name=release-note::" + escapeData(changelog) + "\r\n"
  );
  // require('fs').writeFileSync('../CHANGELOG.md', changelog, {encoding: 'utf-8'})
} catch (e) {
  console.error(e);
  process.exit(1);
}