engine: Centralized leafnode-related code in one place

Author: genieCS

packages/analysis-engine/src/commit.util.spec.ts

@@ -0,0 +1,204 @@
+import { buildCommitDict, getLeafNodes, isLeafNode } from "./commit.util";
+import type { CommitDict,CommitRaw } from "./types";
+
+describe("getLeafNodes", () => {
+  const createMockCommitRaw = (
+    id: string,
+    branches: string[] = [],
+    overrides: Partial<CommitRaw> = {}
+  ): CommitRaw => ({
+    sequence: 1,
+    id,
+    parents: [],
+    branches,
+    tags: [],
+    author: { name: "Test Author", email: "test@example.com" },
+    authorDate: new Date("2023-01-01"),
+    committer: { name: "Test Committer", email: "test@example.com" },
+    committerDate: new Date("2023-01-01"),
+    message: "Test commit message",
+    differenceStatistic: {
+      totalInsertionCount: 0,
+      totalDeletionCount: 0,
+      fileDictionary: {},
+    },
+    commitMessageType: "",
+    ...overrides,
+  });
+
+  describe("normal cases", () => {
+    it("should return nodes with branches as leaf nodes", () => {
+      const commits: CommitRaw[] = [
+        createMockCommitRaw("commit1", ["main"]),
+        createMockCommitRaw("commit2", ["develop"]),
+        createMockCommitRaw("commit3", ["feature/test"]),
+      ];
+      const commitDict: CommitDict = buildCommitDict(commits);
+
+      const leafNodes = getLeafNodes(commitDict);
+
+      expect(leafNodes).toHaveLength(3);
+      expect(leafNodes.map(node => node.commit.id)).toEqual(
+        expect.arrayContaining(["commit1", "commit2", "commit3"])
+      );
+    });
+
+    it("should return nodes with multiple branches as leaf nodes", () => {
+      const commits: CommitRaw[] = [
+        createMockCommitRaw("commit1", ["main", "develop"]),
+      ];
+      const commitDict: CommitDict = buildCommitDict(commits);
+
+      const leafNodes = getLeafNodes(commitDict);
+
+      expect(leafNodes).toHaveLength(1);
+      expect(leafNodes[0].commit.id).toBe("commit1");
+      expect(leafNodes[0].commit.branches).toEqual(["main", "develop"]);
+    });
+  });
+
+  describe("edge cases", () => {
+    it("should return empty array for empty CommitDict", () => {
+      const commitDict: CommitDict = new Map();
+
+      const leafNodes = getLeafNodes(commitDict);
+
+      expect(leafNodes).toEqual([]);
+    });
+
+    it("should not return nodes without branches as leaf nodes", () => {
+      const commits: CommitRaw[] = [
+        createMockCommitRaw("commit1", []),
+        createMockCommitRaw("commit2", []),
+      ];
+      const commitDict: CommitDict = buildCommitDict(commits);
+
+      const leafNodes = getLeafNodes(commitDict);
+
+      expect(leafNodes).toEqual([]);
+    });
+
+    it("should return only nodes with branches when mixed", () => {
+      const commits: CommitRaw[] = [
+        createMockCommitRaw("commit1", ["main"]),
+        createMockCommitRaw("commit2", []),
+        createMockCommitRaw("commit3", ["develop"]),
+        createMockCommitRaw("commit4", []),
+      ];
+      const commitDict: CommitDict = buildCommitDict(commits);
+
+      const leafNodes = getLeafNodes(commitDict);
+
+      expect(leafNodes).toHaveLength(2);
+      expect(leafNodes.map(node => node.commit.id)).toEqual(
+        expect.arrayContaining(["commit1", "commit3"])
+      );
+    });
+  });
+
+  describe("type validation", () => {
+    it("should return array elements with CommitNode type", () => {
+      const commits: CommitRaw[] = [
+        createMockCommitRaw("commit1", ["main"]),
+      ];
+      const commitDict: CommitDict = buildCommitDict(commits);
+
+      const leafNodes = getLeafNodes(commitDict);
+
+      expect(leafNodes[0]).toHaveProperty("commit");
+      expect(leafNodes[0].commit).toHaveProperty("id");
+      expect(leafNodes[0].commit).toHaveProperty("branches");
+      expect(Array.isArray(leafNodes[0].commit.branches)).toBe(true);
+    });
+  });
+
+  describe("real-world scenarios", () => {
+    it("should correctly find leaf nodes in git-like history", () => {
+      const commits: CommitRaw[] = [
+        createMockCommitRaw("abc123", ["main"], {
+          message: "feat: add new feature",
+          author: { name: "Developer 1", email: "dev1@example.com" },
+        }),
+        createMockCommitRaw("def456", [], {
+          message: "fix: bug fix",
+          author: { name: "Developer 2", email: "dev2@example.com" },
+        }),
+        createMockCommitRaw("ghi789", ["develop", "feature/branch"], {
+          message: "refactor: code cleanup",
+          author: { name: "Developer 3", email: "dev3@example.com" },
+        }),
+      ];
+      const commitDict: CommitDict = buildCommitDict(commits);
+
+      const leafNodes = getLeafNodes(commitDict);
+
+      expect(leafNodes).toHaveLength(2);
+      expect(leafNodes.map(node => node.commit.id)).toEqual(
+        expect.arrayContaining(["abc123", "ghi789"])
+      );
+      
+      const mainBranchNode = leafNodes.find(node => node.commit.id === "abc123");
+      expect(mainBranchNode?.commit.message).toBe("feat: add new feature");
+      expect(mainBranchNode?.commit.branches).toEqual(["main"]);
+    });
+  });
+});
+
+describe("isLeafNode", () => {
+  const createMockCommitRaw = (
+    id: string,
+    branches: string[] = [],
+    overrides: Partial<CommitRaw> = {}
+  ): CommitRaw => ({
+    sequence: 1,
+    id,
+    parents: [],
+    branches,
+    tags: [],
+    author: { name: "Test Author", email: "test@example.com" },
+    authorDate: new Date("2023-01-01"),
+    committer: { name: "Test Committer", email: "test@example.com" },
+    committerDate: new Date("2023-01-01"),
+    message: "Test commit message",
+    differenceStatistic: {
+      totalInsertionCount: 0,
+      totalDeletionCount: 0,
+      fileDictionary: {},
+    },
+    commitMessageType: "",
+    ...overrides,
+  });
+
+  it("should return true for nodes with branches", () => {
+    const node = { commit: createMockCommitRaw("test1", ["main"]) };
+
+    expect(isLeafNode(node)).toBe(true);
+  });
+
+  it("should return true for nodes with multiple branches", () => {
+    const node = { commit: createMockCommitRaw("test1", ["main", "develop"]) };
+
+    expect(isLeafNode(node)).toBe(true);
+  });
+
+  it("should return false for nodes without branches", () => {
+    const node = { commit: createMockCommitRaw("test1", []) };
+
+    expect(isLeafNode(node)).toBe(false);
+  });
+
+  it("should be determined by branches regardless of stemId", () => {
+    const nodeWithoutBranches = { 
+      stemId: "stem1", 
+      commit: createMockCommitRaw("test1", []) 
+    };
+    
+    const nodeWithBranches = { 
+      stemId: "stem1", 
+      commit: createMockCommitRaw("test2", ["main"]) 
+    };
+
+    expect(isLeafNode(nodeWithoutBranches)).toBe(false);
+    expect(isLeafNode(nodeWithBranches)).toBe(true);
+  });
+});

packages/analysis-engine/src/commit.util.ts

@@ -6,14 +6,23 @@ import {
   type CommitRaw,
 } from "./types";
 
+export const isLeafNode = (node: CommitNode): boolean => node.commit.branches.length > 0;
+
+export const latestFirstComparator = (a: CommitNode, b: CommitNode): number => {
+  // branches 값 존재하는 노드 => leaf / main / HEAD 노드.
+  // 이 노드는 큐에 들어올 때 순서가 정해져 있기 때문에 순서를 바꾸지 않음.
+  if (isLeafNode(a) || isLeafNode(b)) {
+    return 0;
+  }
+  return new Date(b.commit.committerDate).getTime() - new Date(a.commit.committerDate).getTime();
+};
+
 export function buildCommitDict(commits: CommitRaw[]): CommitDict {
   return new Map(commits.map((commit) => [commit.id, { commit } as CommitNode]));
 }
 
 export function getLeafNodes(commitDict: CommitDict): CommitNode[] {
-  const leafNodes: CommitNode[] = [];
-  commitDict.forEach((node) => node.commit.branches.length && leafNodes.push(node));
-  return leafNodes;
+  return [...commitDict.values()].filter(isLeafNode);
 }
 
 export function getCommitMessageType(message: string): CommitMessageType {

packages/analysis-engine/src/stem.spec.ts

@@ -1,4 +1,5 @@
-import { buildCommitDict, getLeafNodes } from "./commit.util";
+import Queue from "../src/queue";
+import { buildCommitDict, getLeafNodes, latestFirstComparator } from "./commit.util";
 import { buildStemDict } from "./stem";
 import type { CommitNode, CommitRaw } from "./types";
 
@@ -173,3 +174,150 @@ describe("stem", () => {
     expect(stemDict.get("implicit-1")?.nodes.map((node) => node.commit.id)).toEqual(expectedStemDict["implicit-1"]);
   });
 });
+
+describe("stem module", () => {
+  const createMockCommitRaw = (
+    id: string,
+    branches: string[] = [],
+    parents: string[] = [],
+    committerDate: string = "2023-01-01",
+    overrides: Partial<CommitRaw> = {}
+  ): CommitRaw => ({
+    sequence: 1,
+    id,
+    parents,
+    branches,
+    tags: [],
+    author: { name: "Test Author", email: "test@example.com" },
+    authorDate: new Date(committerDate),
+    committer: { name: "Test Committer", email: "test@example.com" },
+    committerDate: new Date(committerDate),
+    message: "Test commit message",
+    differenceStatistic: {
+      totalInsertionCount: 0,
+      totalDeletionCount: 0,
+      fileDictionary: {},
+    },
+    commitMessageType: "",
+    ...overrides,
+  });
+
+  const createCommitNode = (commit: CommitRaw, stemId?: string): CommitNode => ({
+    commit,
+    stemId,
+  });
+
+  describe("latestFirstComparator", () => {
+    it("should maintain order for leaf nodes", () => {
+      const leafNode1 = createCommitNode(
+        createMockCommitRaw("leaf1", ["main"], [], "2023-01-01")
+      );
+      const leafNode2 = createCommitNode(
+        createMockCommitRaw("leaf2", ["develop"], [], "2023-01-02")
+      );
+
+      const queue = new Queue<CommitNode>(latestFirstComparator);
+      
+      queue.push(leafNode1);
+      queue.push(leafNode2);
+
+      const first = queue.pop();
+      const second = queue.pop();
+      
+      expect(first?.commit.id).toBe("leaf1");
+      expect(second?.commit.id).toBe("leaf2");
+    });
+
+    it("should sort non-leaf nodes by commit time with latest first", () => {
+      const commit1 = createCommitNode(
+        createMockCommitRaw("commit-2023-01-01", [], [], "2023-01-01T10:00:00Z")
+      );
+      const commit2 = createCommitNode(
+        createMockCommitRaw("commit-2023-01-02", [], [], "2023-01-02T10:00:00Z")
+      );
+      const commit3 = createCommitNode(
+        createMockCommitRaw("commit-2023-01-03", [], [], "2023-01-03T10:00:00Z")
+      );
+
+      const queue = new Queue<CommitNode>(latestFirstComparator);
+      
+      queue.push(commit1);
+      queue.push(commit2);
+      queue.push(commit3);
+
+      const first = queue.pop();
+      const second = queue.pop();
+      const third = queue.pop();
+      
+      expect(first?.commit.id).toBe("commit-2023-01-03");
+      expect(second?.commit.id).toBe("commit-2023-01-02");
+      expect(third?.commit.id).toBe("commit-2023-01-01");
+    });
+
+    it("should prioritize latest commits regardless of insertion order", () => {
+      const olderCommit = createCommitNode(
+        createMockCommitRaw("older-commit", [], [], "2023-01-01T10:00:00Z")
+      );
+      const newerCommit = createCommitNode(
+        createMockCommitRaw("newer-commit", [], [], "2023-01-10T10:00:00Z")
+      );
+      const latestCommit = createCommitNode(
+        createMockCommitRaw("latest-commit", [], [], "2023-01-15T10:00:00Z")
+      );
+
+      const queue = new Queue<CommitNode>(latestFirstComparator);
+      
+      queue.push(latestCommit);
+      queue.push(olderCommit);
+      queue.push(newerCommit);
+
+      const first = queue.pop();
+      const second = queue.pop();
+      const third = queue.pop();
+      
+      expect(first?.commit.id).toBe("latest-commit");
+      expect(second?.commit.id).toBe("newer-commit");
+      expect(third?.commit.id).toBe("older-commit");
+    });
+
+    it("should handle mixed leaf and non-leaf nodes", () => {
+      const leafNode = createCommitNode(
+        createMockCommitRaw("leaf", ["main"], [], "2023-01-01")
+      );
+      const nonLeafNode = createCommitNode(
+        createMockCommitRaw("nonLeaf", [], [], "2023-01-02")
+      );
+
+      const queue = new Queue<CommitNode>(latestFirstComparator);
+      
+      queue.push(nonLeafNode);
+      queue.push(leafNode);
+
+      const first = queue.pop();
+      const second = queue.pop();
+      
+      expect(first?.commit.id).toBe("nonLeaf");
+      expect(second?.commit.id).toBe("leaf");
+    });
+
+    it("should handle mixed leaf and non-leaf nodes with different insertion order", () => {
+      const leafNode = createCommitNode(
+        createMockCommitRaw("leaf", ["main"], [], "2023-01-01")
+      );
+      const nonLeafNode = createCommitNode(
+        createMockCommitRaw("nonLeaf", [], [], "2023-01-02")
+      );
+
+      const queue = new Queue<CommitNode>(latestFirstComparator);
+      
+      queue.push(leafNode);
+      queue.push(nonLeafNode);
+
+      const first = queue.pop();
+      const second = queue.pop();
+      
+      expect(first?.commit.id).toBe("leaf");
+      expect(second?.commit.id).toBe("nonLeaf");
+    });
+  });
+});