feat: break cyclic graphs when converting into tree

This pr will add support for converting a cyclic graph into a tree
Image example: convert `cyclic-complex-dep-graph.png` into `cyclic-complex-dep-graph-expected-optimized-tree.png`

Author: admons

src/legacy/cycles.ts

@@ -0,0 +1,36 @@
+type NodeId = string;
+type Cycle = NodeId[];
+
+export type Cycles = Cycle[];
+
+export type PartitionedCycles = {
+  cyclesStartWithThisNode: Cycle[];
+  cyclesWithThisNode: Cycle[];
+};
+
+export function getCycle(ancestors: NodeId[], nodeId: NodeId): Cycle | null {
+  if (!ancestors.includes(nodeId)) {
+    return null;
+  }
+
+  // first item is where the cycle starts and ends.
+  return ancestors.slice(ancestors.indexOf(nodeId));
+}
+
+export function partitionCycles(
+  nodeId: NodeId,
+  allCyclesTheNodeIsPartOf: Cycle[],
+): PartitionedCycles {
+  const cyclesStartWithThisNode: Cycle[] = [];
+  const cyclesWithThisNode: Cycle[] = [];
+
+  for (const cycle of allCyclesTheNodeIsPartOf) {
+    const nodeStartsCycle = cycle[0] === nodeId;
+    if (nodeStartsCycle) {
+      cyclesStartWithThisNode.push(cycle);
+    } else {
+      cyclesWithThisNode.push(cycle);
+    }
+  }
+  return { cyclesStartWithThisNode, cyclesWithThisNode };
+}

src/legacy/index.ts

@@ -4,6 +4,8 @@ import { eventLoopSpinner } from 'event-loop-spinner';
 import * as types from '../core/types';
 import { DepGraphBuilder } from '../core/builder';
 import objectHash = require('object-hash');
+import { getCycle, partitionCycles, Cycles } from './cycles';
+import { getMemoizedDepTree, memoize, MemoizationMap } from './memiozation';
 
 export { depTreeToGraph, graphToDepTree, DepTree };
 
@@ -230,12 +232,7 @@ async function graphToDepTree(
 ): Promise<DepTree> {
   const depGraph = depGraphInterface as types.DepGraphInternal;
 
-  // TODO: implement cycles support
-  if (depGraph.hasCycles()) {
-    throw new Error('Conversion to DepTree does not support cyclic graphs yet');
-  }
-
-  const depTree = await buildSubtree(
+  const [depTree] = await buildSubtree(
     depGraph,
     depGraph.rootNodeId,
     opts.deduplicateWithinTopLevelDeps ? null : false,
@@ -286,10 +283,18 @@ async function buildSubtree(
   depGraph: types.DepGraphInternal,
   nodeId: string,
   maybeDeduplicationSet: Set<string> | false | null = false, // false = disabled; null = not in deduplication scope yet
-  memoizationMap: Map<string, DepTree> = new Map(),
-): Promise<DepTree> {
-  if (!maybeDeduplicationSet && memoizationMap.has(nodeId)) {
-    return memoizationMap.get(nodeId)!;
+  ancestors: string[] = [],
+  memoizationMap: MemoizationMap = new Map(),
+): Promise<[DepTree, Cycles | undefined]> {
+  if (!maybeDeduplicationSet) {
+    const memoizedDepTree = getMemoizedDepTree(
+      nodeId,
+      ancestors,
+      memoizationMap,
+    );
+    if (memoizedDepTree) {
+      return [memoizedDepTree, undefined];
+    }
   }
   const isRoot = nodeId === depGraph.rootNodeId;
   const nodePkg = depGraph.getNodePkg(nodeId);
@@ -306,32 +311,46 @@ async function buildSubtree(
 
   const depInstanceIds = depGraph.getNodeDepsNodeIds(nodeId);
   if (!depInstanceIds || depInstanceIds.length === 0) {
-    memoizationMap.set(nodeId, depTree);
-    return depTree;
+    memoizationMap.set(nodeId, { depTree });
+    return [depTree, undefined];
+  }
+
+  const cycle = getCycle(ancestors, nodeId);
+  if (cycle) {
+    // This node starts a cycle and now it's the second visit.
+    addLabel(depTree, 'pruned', 'cyclic');
+    return [depTree, [cycle]];
   }
 
   if (maybeDeduplicationSet) {
     if (maybeDeduplicationSet.has(nodeId)) {
       if (depInstanceIds.length > 0) {
         addLabel(depTree, 'pruned', 'true');
       }
-      return depTree;
+      return [depTree, undefined];
     }
     maybeDeduplicationSet.add(nodeId);
   }
 
+  const cycles: Cycles = [];
   for (const depInstId of depInstanceIds) {
     // Deduplication of nodes occurs only within a scope of a top-level dependency.
     // Therefore, every top-level dep gets an independent set to track duplicates.
     if (isRoot && maybeDeduplicationSet !== false) {
       maybeDeduplicationSet = new Set();
     }
-    const subtree = await buildSubtree(
+    const [subtree, subtreeCycles] = await buildSubtree(
       depGraph,
       depInstId,
       maybeDeduplicationSet,
+      ancestors.concat(nodeId),
       memoizationMap,
     );
+    if (subtreeCycles) {
+      for (const cycle of subtreeCycles) {
+        cycles.push(cycle);
+      }
+    }
     if (!subtree) {
       continue;
     }
@@ -346,8 +365,11 @@ async function buildSubtree(
   if (eventLoopSpinner.isStarving()) {
     await eventLoopSpinner.spin();
   }
-  memoizationMap.set(nodeId, depTree);
-  return depTree;
+
+  const partitionedCycles = partitionCycles(nodeId, cycles);
+  memoize(nodeId, memoizationMap, depTree, partitionedCycles);
+
+  return [depTree, partitionedCycles.cyclesWithThisNode];
 }
 
 function trimAfterLastSep(str: string, sep: string) {

src/legacy/memiozation.ts

@@ -0,0 +1,49 @@
+import { DepTree } from './index';
+import { PartitionedCycles } from './cycles';
+
+type NodeId = string;
+
+export type MemoizationMap = Map<
+  NodeId,
+  {
+    depTree: DepTree;
+
+    // the cycleNodeIds holds the nodes ids in a cycle
+    // i.e. for the cyclic graph "1->2->3->4->2", for nodeId=2 the cycleNodeIds will be "3,4"
+    // if nodeId exists in cycleNodeIds, don't use memoized depTree version
+    cycleNodeIds?: Set<NodeId>;
+  }
+>;
+
+export function memoize(
+  nodeId: NodeId,
+  memoizationMap: MemoizationMap,
+  depTree: DepTree,
+  partitionedCycles: PartitionedCycles,
+) {
+  const { cyclesStartWithThisNode, cyclesWithThisNode } = partitionedCycles;
+  if (cyclesStartWithThisNode.length > 0) {
+    const cycleNodeIds = new Set<NodeId>(...cyclesStartWithThisNode);
+    memoizationMap.set(nodeId, { depTree, cycleNodeIds });
+  } else if (cyclesWithThisNode.length === 0) {
+    memoizationMap.set(nodeId, { depTree });
+  }
+  // Don't memoize nodes in cycles (cyclesWithThisNode.length > 0)
+}
+
+export function getMemoizedDepTree(
+  nodeId: NodeId,
+  ancestors: NodeId[],
+  memoizationMap: MemoizationMap,
+): DepTree | null {
+  if (!memoizationMap.has(nodeId)) return null;
+
+  const { depTree, cycleNodeIds } = memoizationMap.get(nodeId)!;
+  if (!cycleNodeIds) return depTree;
+
+  const ancestorsArePartOfTheCycle = ancestors.some((nodeId) =>
+    cycleNodeIds.has(nodeId),
+  );
+
+  return ancestorsArePartOfTheCycle ? null : depTree;
+}

test/fixtures/cyclic-complex-dep-graph-expected-optimized-tree.png

@@ -0,0 +1,133 @@
+{
+  "// graph image": "cyclic-complex-dep-graph.png",
+  "// expected dep-tree image": "cyclic-complex-dep-graph-expected-optimized-tree.png",
+  "schemaVersion": "1.2.0",
+  "pkgManager": {
+    "name": "pip"
+  },
+  "pkgs": [
+    {
+      "id": "a@1",
+      "info": {
+        "name": "a",
+        "version": "1"
+      }
+    },
+    {
+      "id": "b@2",
+      "info": {
+        "name": "b",
+        "version": "2"
+      }
+    },
+    {
+      "id": "c@3",
+      "info": {
+        "name": "c",
+        "version": "3"
+      }
+    },
+    {
+      "id": "d@4",
+      "info": {
+        "name": "d",
+        "version": "4"
+      }
+    },
+    {
+      "id": "e@5",
+      "info": {
+        "name": "e",
+        "version": "5"
+      }
+    },
+    {
+      "id": "f@6",
+      "info": {
+        "name": "f",
+        "version": "6"
+      }
+    },
+    {
+      "id": "g@7",
+      "info": {
+        "name": "g",
+        "version": "7"
+      }
+    }
+  ],
+  "graph": {
+    "rootNodeId": "root-node",
+    "nodes": [
+      {
+        "nodeId": "root-node",
+        "pkgId": "a@1",
+        "deps": [
+          {
+            "nodeId": "2"
+          },
+          {
+            "nodeId": "3"
+          },
+          {
+            "nodeId": "4"
+          }
+        ]
+      },
+      {
+        "nodeId": "2",
+        "pkgId": "b@2",
+        "deps": [
+          {
+            "nodeId": "5"
+          }
+        ]
+      },
+      {
+        "nodeId": "3",
+        "pkgId": "c@3",
+        "deps": [
+          {
+            "nodeId": "5"
+          }
+        ]
+      },
+      {
+        "nodeId": "4",
+        "pkgId": "d@4",
+        "deps": [
+          {
+            "nodeId": "6"
+          }
+        ]
+      },
+      {
+        "nodeId": "5",
+        "pkgId": "e@5",
+        "deps": [
+          {
+            "nodeId": "6"
+          }
+        ]
+      },
+      {
+        "nodeId": "6",
+        "pkgId": "f@6",
+        "deps": [
+          {
+            "nodeId": "7"
+          }
+        ]
+      },
+      {
+        "nodeId": "7",
+        "pkgId": "g@7",
+        "deps": [
+          {
+            "nodeId": "5"
+          }
+        ]
+      }
+    ]
+  }
+}