Merge pull request #7 from snyk/feat/count-paths

feat: method to count all paths from pkg to root

Author: michael-go

src/core/dep-graph.ts

@@ -24,6 +24,8 @@ class DepGraphImpl implements types.DepGraphInternal {
   private _rootNodeId: string;
   private _rootPkgId: string;
 
+  private _countNodePathsToRootCache: Map<string, number> = new Map();
+
   public constructor(
     graph: graphlib.Graph,
     rootNodeId: string,
@@ -104,18 +106,28 @@ class DepGraphImpl implements types.DepGraphInternal {
     }
 
     const pathsToRoot: types.PkgInfo[][] = [];
-
-    const nodeIds = this.getPkgNodeIds(pkg);
-    if (nodeIds) {
-      for (const id of nodeIds) {
-        pathsToRoot.push(...this.pathsFromNodeToRoot(id));
-      }
+    for (const id of this.getPkgNodeIds(pkg)) {
+      pathsToRoot.push(...this.pathsFromNodeToRoot(id));
     }
     // note: sorting to get shorter paths first -
     //  it's nicer - and better resembles older behaviour
     return pathsToRoot.sort((a, b) => a.length - b.length);
   }
 
+  public countPathsToRoot(pkg: types.Pkg): number {
+    // TODO: implement cycles support
+    if (this.hasCycles()) {
+      throw new Error('countPathsToRoot does not support cyclic graphs yet');
+    }
+
+    let count = 0;
+    for (const nodeId of this.getPkgNodeIds(pkg)) {
+      count += this.countNodePathsToRoot(nodeId);
+    }
+
+    return count;
+  }
+
   public toJSON(): types.DepGraphData {
     const nodeIds = this._graph.nodes();
 
@@ -153,14 +165,34 @@ class DepGraphImpl implements types.DepGraphInternal {
     if (parentNodesIds.length === 0) {
       return [[this.getNodePkg(nodeId)]];
     }
+
     const allPaths: types.PkgInfo[][] = [];
     parentNodesIds.map((id) => {
       const out = this.pathsFromNodeToRoot(id).map((path) => {
         return [this.getNodePkg(nodeId)].concat(path);
       });
       allPaths.push(...out);
     });
+
     return allPaths;
   }
 
+  private countNodePathsToRoot(nodeId: string): number {
+    if (this._countNodePathsToRootCache.has(nodeId)) {
+      return this._countNodePathsToRootCache.get(nodeId);
+    }
+
+    const parentNodesIds = this.getNodeParentsNodeIds(nodeId);
+    if (parentNodesIds.length === 0) {
+      this._countNodePathsToRootCache.set(nodeId, 1);
+      return 1;
+    }
+
+    const count = parentNodesIds.reduce((acc, parentNodeId) => {
+      return acc + this.countNodePathsToRoot(parentNodeId);
+    }, 0);
+
+    this._countNodePathsToRootCache.set(nodeId, count);
+    return count;
+  }
 }

src/core/types.ts

@@ -72,6 +72,7 @@ export interface DepGraph {
   getPkgs(): PkgInfo[];
   toJSON(): DepGraphData;
   pkgPathsToRoot(pkg: Pkg): PkgInfo[][];
+  countPathsToRoot(pkg: Pkg): number;
 }
 
 // NOTE/TODO(shaun): deferring any/all design decisions here

test/core/create-from-json.test.ts

@@ -31,12 +31,16 @@ describe('fromJSON simple', () => {
 
   test('getPathsToRoot', async () => {
     expect(graph.pkgPathsToRoot({ name: 'd', version: '0.0.1' })).toHaveLength(1);
+    expect(graph.countPathsToRoot({ name: 'd', version: '0.0.1' })).toBe(1);
 
     expect(graph.pkgPathsToRoot({ name: 'd', version: '0.0.2' })).toHaveLength(1);
+    expect(graph.countPathsToRoot({ name: 'd', version: '0.0.2' })).toBe(1);
 
     expect(graph.pkgPathsToRoot({ name: 'c', version: '1.0.0' })).toHaveLength(2);
+    expect(graph.countPathsToRoot({ name: 'c', version: '1.0.0' })).toBe(2);
 
     expect(graph.pkgPathsToRoot({ name: 'e', version: '5.0.0' })).toHaveLength(2);
+    expect(graph.countPathsToRoot({ name: 'e', version: '5.0.0' })).toBe(2);
 
     expect(graph.pkgPathsToRoot({ name: 'e', version: '5.0.0' })).toEqual([
       [
@@ -135,6 +139,7 @@ test('fromJSON a pkg and a node share same id', async () => {
     { name: 'foo', version: '2' },
     { name: 'toor', version: '1.0.0' },
   ]]);
+  expect(depGraph.countPathsToRoot({ name: 'foo', version: '2' })).toBe(1);
 });
 
 test('fromJSON no deps', async () => {

test/legacy/from-dep-tree.test.ts

@@ -67,12 +67,16 @@ describe('createFromDepTree simple dysmorphic', () => {
 
   test('getPathsToRoot', async () => {
     expect(depGraph.pkgPathsToRoot({ name: 'd', version: '0.0.1' })).toHaveLength(1);
+    expect(depGraph.countPathsToRoot({ name: 'd', version: '0.0.1' })).toBe(1);
 
     expect(depGraph.pkgPathsToRoot({ name: 'd', version: '0.0.2' })).toHaveLength(1);
+    expect(depGraph.countPathsToRoot({ name: 'd', version: '0.0.2' })).toBe(1);
 
     expect(depGraph.pkgPathsToRoot({ name: 'c', version: '1.0.0' })).toHaveLength(2);
+    expect(depGraph.countPathsToRoot({ name: 'c', version: '1.0.0' })).toBe(2);
 
     expect(depGraph.pkgPathsToRoot({ name: 'e', version: '5.0.0' })).toHaveLength(2);
+    expect(depGraph.countPathsToRoot({ name: 'e', version: '5.0.0' })).toBe(2);
 
     expect(depGraph.pkgPathsToRoot({ name: 'e', version: '5.0.0' })).toEqual([
       [
@@ -141,7 +145,7 @@ describe('createFromDepTree goof', () => {
   const depTree = helpers.loadFixture('goof-dep-tree.json');
   const expectedGraph = helpers.loadFixture('goof-graph.json');
 
-  let depGraph;
+  let depGraph: types.DepGraph;
   test('create', async () => {
     depGraph = await depGraphLib.legacy.depTreeToGraph(depTree, 'npm');
 
@@ -152,19 +156,33 @@ describe('createFromDepTree goof', () => {
     const depGraphInternal = depGraph as types.DepGraphInternal;
 
     const stripAnsiPkg = {name: 'strip-ansi', version: '3.0.1'};
-    const stripAnsiNodes = depGraph.getPkgNodeIds(stripAnsiPkg);
+    const stripAnsiNodes = depGraphInternal.getPkgNodeIds(stripAnsiPkg);
     expect(stripAnsiNodes).toHaveLength(2);
 
     const stripAnsiPaths = depGraph.pkgPathsToRoot(stripAnsiPkg);
     expect(stripAnsiPaths).toHaveLength(6);
+    expect(depGraph.countPathsToRoot(stripAnsiPkg)).toBe(6);
 
     expect(depGraph.pkgPathsToRoot({name: 'ansi-regex', version: '2.0.0'})).toHaveLength(4);
+    expect(depGraph.countPathsToRoot({name: 'ansi-regex', version: '2.0.0'})).toBe(4);
     expect(depGraph.pkgPathsToRoot({name: 'ansi-regex', version: '2.1.1'})).toHaveLength(3);
+    expect(depGraph.countPathsToRoot({name: 'ansi-regex', version: '2.1.1'})).toBe(3);
+    expect(depGraph.pkgPathsToRoot({name: 'wrappy', version: '1.0.2'})).toHaveLength(22);
+    expect(depGraph.countPathsToRoot({name: 'wrappy', version: '1.0.2'})).toBe(22);
 
     const expressNodes = depGraphInternal.getPkgNodeIds({name: 'express', version: '4.12.4'});
     expect(expressNodes).toHaveLength(1);
   });
 
+  test('count paths to root', async () => {
+    for (const pkg of depGraph.getPkgs()) {
+      const firstResult = depGraph.countPathsToRoot(pkg);
+      const secondResult = depGraph.countPathsToRoot(pkg);
+      expect(secondResult).toEqual(firstResult);
+      expect(secondResult).toEqual(depGraph.pkgPathsToRoot(pkg).length);
+    }
+  });
+
   test('compare to expected fixture', async () => {
     expect(depGraph.toJSON()).toEqual(expectedGraph);
   });