feat: Convert codebase to TypeScript and add some types

lib/index.js → lib/index.ts

@@ -1,24 +1,16 @@
-var parse = require('./parse-mvn');
-var fs = require('fs');
-var path = require('path');
-var subProcess = require('./sub-process');
+import {parseTree} from './parse-mvn';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as subProcess from './sub-process';
 
-module.exports = {
-  inspect: inspect,
-};
-
-module.exports.__tests = {
-  buildArgs: buildArgs,
-};
-
-function inspect(root, targetFile, options) {
+export function inspect(root, targetFile, options) {
   if (!options) {
     options = {dev: false};
   }
-  var mvnArgs = buildArgs(root, targetFile, options.args);
+  const mvnArgs = buildArgs(root, targetFile, options.args);
   return subProcess.execute('mvn', mvnArgs, {cwd: root})
-    .then(function(result) {
-      var parseResult = parse(result, options.dev);
+    .then((result) => {
+      const parseResult = parseTree(result, options.dev);
       return {
         plugin: {
           name: 'bundled:maven',
@@ -27,7 +19,7 @@ function inspect(root, targetFile, options) {
         package: parseResult.data,
       };
     })
-    .catch(function(error) {
+    .catch((error) => {
       error.message = error.message + '\n\n' +
         'Please make sure that Apache Maven Dependency Plugin ' +
         'version 2.2 or above is installed, and that ' +
@@ -39,9 +31,9 @@ function inspect(root, targetFile, options) {
     });
 }
 
-function buildArgs(root, targetFile, mavenArgs) {
+export function buildArgs(root, targetFile, mavenArgs) {
   // Requires Maven >= 2.2
-  var args = ['dependency:tree', '-DoutputType=dot'];
+  let args = ['dependency:tree', '-DoutputType=dot'];
   if (targetFile) {
     if (!fs.existsSync(path.resolve(root, targetFile))) {
       throw new Error('File not found: "' + targetFile + '"');

lib/parse-mvn.ts

@@ -0,0 +1,126 @@
+import {DepTree} from './types';
+import * as _ from 'lodash';
+
+const newline = /[\r\n]+/g;
+const logLabel = /^\[\w+\]\s*/gm;
+const digraph = /digraph([\s\S]*?)\}/g;
+const errorLabel = /^\[ERROR\]/gm;
+
+// Parse the output from 'mvn dependency:tree -DoutputType=dot'
+export function parseTree(text, withDev) {
+  // check for errors in mvn output
+  if (errorLabel.test(text)) {
+    throw new Error('Failed to execute an `mvn` command.');
+  }
+
+  // clear all labels
+  text = text.replace(logLabel, '');
+
+  // extract deps
+  const data = getRootProject(text, withDev);
+
+  return {ok: true, data};
+}
+
+function getRootProject(text, withDev) {
+  const projects = text.match(digraph);
+  if (!projects) {
+    throw new Error('Cannot find dependency information.');
+  }
+  const rootProject = getProject(projects[0], withDev);
+  const defaultRoot: DepTree =  {
+    name: 'no-name',
+    version: '0.0.0',
+    dependencies: {},
+    packageFormatVersion: 'mvn:0.0.1',
+  };
+
+  const root = {
+    ...defaultRoot,
+    ...rootProject,
+  };
+
+  // Add any subsequent projects to the root as dependencies
+  for (let i = 1; i < projects.length; i++) {
+    const project: DepTree | null = getProject(projects[i], withDev);
+    if (project && project.name) {
+      root.dependencies = {};
+      root.dependencies[project.name] = project;
+    }
+  }
+  return root;
+}
+
+function getProject(projectDump, withDev) {
+  const lines = projectDump.split(newline);
+  const identity = dequote(lines[0]);
+  const deps = {};
+  for (let i = 1; i < lines.length - 1; i++) {
+    const line = lines[i];
+    const nodes = line.trim().split('->');
+    const source = dequote(nodes[0]);
+    const target = dequote(nodes[1]);
+    deps[source] = deps[source] || [];
+    deps[source].push(target);
+  }
+  return assemblePackage(identity, deps, withDev);
+}
+
+function assemblePackage(source, projectDeps, withDev): DepTree | null {
+  const sourcePackage: DepTree = createPackage(source);
+  if (sourcePackage.scope === 'test' && !withDev) {
+    // skip a test dependency if it's not asked for
+    return null;
+  }
+  const sourceDeps = projectDeps[source];
+  if (sourceDeps) {
+    sourcePackage.dependencies = {};
+    for (const dep of sourceDeps) {
+      const pkg: DepTree | null = assemblePackage(
+        dep, projectDeps, withDev);
+      if (pkg) {
+        sourcePackage.dependencies[pkg.name] = pkg;
+      }
+    }
+  }
+  return sourcePackage;
+}
+
+function createPackage(pkgStr) {
+  const range = getConstraint(pkgStr);
+
+  if (range) {
+    pkgStr = pkgStr.substring(0, pkgStr.indexOf(' '));
+  }
+
+  const parts = pkgStr.split(':');
+  const result: DepTree = {
+    version: parts[3],
+    name: parts[0] + ':' + parts[1],
+    dependencies: {},
+  };
+
+  if (parts.length >= 5) {
+    result.scope = parts[parts.length - 1];
+    result.version = parts[parts.length - 2];
+  }
+
+  // TODO: This is likely obsolete, remove
+  if (range) {
+    result.dep = range;
+  }
+
+  return result;
+}
+
+function dequote(str) {
+  return str.slice(str.indexOf('"') + 1, str.lastIndexOf('"'));
+}
+
+function getConstraint(str) {
+  const index = str.indexOf('selected from constraint');
+  if (index === -1) {
+    return null;
+  }
+  return str.slice(index + 25, str.lastIndexOf(')'));
+}

lib/sub-process.ts

@@ -0,0 +1,31 @@
+import * as childProcess from 'child_process';
+
+export function execute(command, args, options) {
+  const spawnOptions: {
+    shell: boolean;
+    cwd?: string;
+  } = {shell: true};
+  if (options && options.cwd) {
+    spawnOptions.cwd = options.cwd;
+  }
+
+  return new Promise((resolve, reject) => {
+    let stdout = '';
+    let stderr = '';
+
+    const proc = childProcess.spawn(command, args, spawnOptions);
+    proc.stdout.on('data', (data) => {
+      stdout = stdout + data;
+    });
+    proc.stderr.on('data', (data) => {
+      stderr = stderr + data;
+    });
+
+    proc.on('close', (code) => {
+      if (code !== 0) {
+        return reject(new Error(stdout || stderr));
+      }
+      resolve(stdout || stderr);
+    });
+  });
+}

lib/types.ts

@@ -0,0 +1,25 @@
+
+export interface PluginMetadata {
+  name: string;
+  runtime: string;
+  targetFile?: string;
+}
+
+export interface DepDict {
+  [name: string]: DepTree;
+}
+
+export interface DepRoot {
+  depTree: DepTree;
+  targetFile?: string;
+
+  meta?: any;
+}
+export interface DepTree {
+  name: string;
+  version: string;
+  dependencies?: DepDict;
+  packageFormatVersion?: string;
+  scope?: string; // TODO: is it needed on the Tree?
+  dep?: string; // TODO: is it needed on the Tree?
+}

package.json

@@ -17,7 +17,7 @@
     "build": "tsc",
     "lint": "tslint --project tsconfig.json --format stylish",
     "prepare": "npm run build",
-    "test": "npm run lint && npm run test-functional && npm run test-system",
+    "test": "npm run prepare && npm run lint && npm run test-functional && npm run test-system",
     "test-functional": "tap -R spec ./test/functional/*.test.[tj]s",
     "test-system": "tap -R spec --timeout=180 ./test/system/*.test.[tj]s",
     "semantic-release": "semantic-release"
@@ -33,6 +33,7 @@
     "tslint": "5.16.0"
   },
   "dependencies": {
+    "lodash": "4.17.11",
     "tslib": "1.9.3"
   }
 }