mermaid/src/diagrams/git/gitGraphAst.js

import _ from 'lodash';

import { logger } from '../../logger';

let commits = {};
let head = null;
let branches = { master: head };
let curBranch = 'master';
let direction = 'LR';
let seq = 0;

function getRandomInt(min, max) {
  return Math.floor(Math.random() * (max - min)) + min;
}

function getId() {
  const pool = '0123456789abcdef';
  let id = '';
  for (let i = 0; i < 7; i++) {
    id += pool[getRandomInt(0, 16)];
  }
  return id;
}

function isfastforwardable(currentCommit, otherCommit) {
  logger.debug('Entering isfastforwardable:', currentCommit.id, otherCommit.id);
  while (currentCommit.seq <= otherCommit.seq && currentCommit !== otherCommit) {
    // only if other branch has more commits
    if (otherCommit.parent == null) break;
    if (Array.isArray(otherCommit.parent)) {
      logger.debug('In merge commit:', otherCommit.parent);
      return (
        isfastforwardable(currentCommit, commits[otherCommit.parent[0]]) ||
        isfastforwardable(currentCommit, commits[otherCommit.parent[1]])
      );
    } else {
      otherCommit = commits[otherCommit.parent];
    }
  }
  logger.debug(currentCommit.id, otherCommit.id);
  return currentCommit.id === otherCommit.id;
}

function isReachableFrom(currentCommit, otherCommit) {
  const currentSeq = currentCommit.seq;
  const otherSeq = otherCommit.seq;
  if (currentSeq > otherSeq) return isfastforwardable(otherCommit, currentCommit);
  return false;
}

export const setDirection = function(dir) {
  direction = dir;
};
let options = {};
export const setOptions = function(rawOptString) {
  logger.debug('options str', rawOptString);
  rawOptString = rawOptString && rawOptString.trim();
  rawOptString = rawOptString || '{}';
  try {
    options = JSON.parse(rawOptString);
  } catch (e) {
    logger.error('error while parsing gitGraph options', e.message);
  }
};

export const getOptions = function() {
  return options;
};

export const commit = function(msg) {
  const commit = {
    id: getId(),
    message: msg,
    seq: seq++,
    parent: head == null ? null : head.id
  };
  head = commit;
  commits[commit.id] = commit;
  branches[curBranch] = commit.id;
  logger.debug('in pushCommit ' + commit.id);
};

export const branch = function(name) {
  branches[name] = head != null ? head.id : null;
  logger.debug('in createBranch');
};

export const merge = function(otherBranch) {
  const currentCommit = commits[branches[curBranch]];
  const otherCommit = commits[branches[otherBranch]];
  if (isReachableFrom(currentCommit, otherCommit)) {
    logger.debug('Already merged');
    return;
  }
  if (isfastforwardable(currentCommit, otherCommit)) {
    branches[curBranch] = branches[otherBranch];
    head = commits[branches[curBranch]];
  } else {
    // create merge commit
    const commit = {
      id: getId(),
      message: 'merged branch ' + otherBranch + ' into ' + curBranch,
      seq: seq++,
      parent: [head == null ? null : head.id, branches[otherBranch]]
    };
    head = commit;
    commits[commit.id] = commit;
    branches[curBranch] = commit.id;
  }
  logger.debug(branches);
  logger.debug('in mergeBranch');
};

export const checkout = function(branch) {
  logger.debug('in checkout');
  curBranch = branch;
  const id = branches[curBranch];
  head = commits[id];
};

export const reset = function(commitRef) {
  logger.debug('in reset', commitRef);
  const ref = commitRef.split(':')[0];
  let parentCount = parseInt(commitRef.split(':')[1]);
  let commit = ref === 'HEAD' ? head : commits[branches[ref]];
  logger.debug(commit, parentCount);
  while (parentCount > 0) {
    commit = commits[commit.parent];
    parentCount--;
    if (!commit) {
      const err = 'Critical error - unique parent commit not found during reset';
      logger.error(err);
      throw err;
    }
  }
  head = commit;
  branches[curBranch] = commit.id;
};

function upsert(arr, key, newval) {
  const index = arr.indexOf(key);
  if (index === -1) {
    arr.push(newval);
  } else {
    arr.splice(index, 1, newval);
  }
}

function prettyPrintCommitHistory(commitArr) {
  const commit = _.maxBy(commitArr, 'seq');
  let line = '';
  commitArr.forEach(function(c) {
    if (c === commit) {
      line += '\t*';
    } else {
      line += '\t|';
    }
  });
  const label = [line, commit.id, commit.seq];
  for (let branch in branches) {
    if (branches[branch] === commit.id) label.push(branch);
  }
  logger.debug(label.join(' '));
  if (Array.isArray(commit.parent)) {
    const newCommit = commits[commit.parent[0]];
    upsert(commitArr, commit, newCommit);
    commitArr.push(commits[commit.parent[1]]);
  } else if (commit.parent == null) {
    return;
  } else {
    const nextCommit = commits[commit.parent];
    upsert(commitArr, commit, nextCommit);
  }
  commitArr = _.uniqBy(commitArr, 'id');
  prettyPrintCommitHistory(commitArr);
}

export const prettyPrint = function() {
  logger.debug(commits);
  const node = getCommitsArray()[0];
  prettyPrintCommitHistory([node]);
};

export const clear = function() {
  commits = {};
  head = null;
  branches = { master: head };
  curBranch = 'master';
  seq = 0;
};

export const getBranchesAsObjArray = function() {
  const branchArr = [];
  for (let branch in branches) {
    branchArr.push({ name: branch, commit: commits[branches[branch]] });
  }
  return branchArr;
};

export const getBranches = function() {
  return branches;
};
export const getCommits = function() {
  return commits;
};
export const getCommitsArray = function() {
  const commitArr = Object.keys(commits).map(function(key) {
    return commits[key];
  });
  commitArr.forEach(function(o) {
    logger.debug(o.id);
  });
  return _.orderBy(commitArr, ['seq'], ['desc']);
};
export const getCurrentBranch = function() {
  return curBranch;
};
export const getDirection = function() {
  return direction;
};
export const getHead = function() {
  return head;
};

export default {
  setDirection,
  setOptions,
  getOptions,
  commit,
  branch,
  merge,
  checkout,
  reset,
  prettyPrint,
  clear,
  getBranchesAsObjArray,
  getBranches,
  getCommits,
  getCommitsArray,
  getCurrentBranch,
  getDirection,
  getHead
};