@contrast/contrast 1.0.3 → 1.0.6

package/dist/scaAnalysis/go/goParseDeps.js

@@ -0,0 +1,158 @@
+"use strict";
+const crypto = require('crypto');
+const parseGoDependencies = goDeps => {
+    return parseGo(goDeps);
+};
+const parseGo = modGraphOutput => {
+    let splitLines = splitAllLinesIntoArray(modGraphOutput);
+    const directDepNames = getDirectDepNames(splitLines);
+    const uniqueTransitiveDepNames = getAllUniqueTransitiveDepNames(splitLines, directDepNames);
+    let rootNodes = createRootNodes(splitLines);
+    createTransitiveDeps(uniqueTransitiveDepNames, splitLines, rootNodes);
+    return rootNodes;
+};
+const splitAllLinesIntoArray = modGraphOutput => {
+    return modGraphOutput.split(/\r\n|\r|\n/);
+};
+const getAllDepsOfADepAsEdge = (dep, deps) => {
+    let edges = {};
+    const depRows = deps.filter(line => {
+        return line.startsWith(dep);
+    });
+    depRows.forEach(dep => {
+        const edgeName = dep.split(' ')[1];
+        edges[edgeName] = edgeName;
+    });
+    return edges;
+};
+const getAllDepsOfADepAsName = (dep, deps) => {
+    let edges = [];
+    const depRows = deps.filter(line => {
+        return line.startsWith(dep);
+    });
+    depRows.forEach(dep => {
+        const edgeName = dep.split(' ')[1];
+        edges.push(edgeName);
+    });
+    return edges;
+};
+const createRootNodes = deps => {
+    let rootDep = {};
+    const rootDeps = getRootDeps(deps);
+    const edges = rootDeps.map(dep => {
+        return dep.split(' ')[1];
+    });
+    rootDep[rootDeps[0].split(' ')[0]] = {};
+    edges.forEach(edge => {
+        const splitEdge = edge.split('@');
+        const splitGroupName = splitEdge[0].split('/');
+        const name = splitGroupName.pop();
+        const lastSlash = splitEdge[0].lastIndexOf('/');
+        let group = splitEdge[0].substring(0, lastSlash);
+        const hash = getHash(splitEdge[0]);
+        group = checkGroupExists(group, name);
+        const edgesOfDep = getAllDepsOfADepAsEdge(edge, deps);
+        rootDep[rootDeps[0].split(' ')[0]][edge] = {
+            artifactID: name,
+            group: group,
+            version: splitEdge[1],
+            scope: '"compile',
+            type: 'direct',
+            hash: hash,
+            edges: edgesOfDep
+        };
+    });
+    return rootDep;
+};
+const getRootDeps = deps => {
+    const rootDeps = deps.filter(dep => {
+        const parentDep = dep.split(' ')[0];
+        if (parentDep.split('@v').length === 1) {
+            return dep;
+        }
+    });
+    return rootDeps;
+};
+const getHash = library => {
+    let shaSum = crypto.createHash('sha1');
+    shaSum.update(library);
+    return shaSum.digest('hex');
+};
+const getDirectDepNames = deps => {
+    const directDepNames = [];
+    deps.forEach(dep => {
+        const parentDep = dep.split(' ')[0];
+        if (parentDep.split('@v').length === 1) {
+            dep.split(' ')[1] !== undefined
+                ? directDepNames.push(dep.split(' ')[1])
+                : null;
+        }
+    });
+    return directDepNames;
+};
+const getAllUniqueTransitiveDepNames = (deps, directDepNames) => {
+    let uniqueDeps = [];
+    deps.forEach(dep => {
+        const parentDep = dep.split(' ')[0];
+        if (parentDep.split('@v').length !== 1) {
+            if (!directDepNames.includes(parentDep)) {
+                if (!uniqueDeps.includes(parentDep)) {
+                    parentDep.length > 1 ? uniqueDeps.push(parentDep) : null;
+                }
+            }
+        }
+    });
+    return uniqueDeps;
+};
+const checkGroupExists = (group, name) => {
+    if (group === null || group === '') {
+        return name;
+    }
+    return group;
+};
+const createTransitiveDeps = (transitiveDeps, splitLines, rootNodes) => {
+    transitiveDeps.forEach(dep => {
+        const splitEdge = dep.split('@');
+        const splitGroupName = splitEdge[0].split('/');
+        const name = splitGroupName.pop();
+        const lastSlash = splitEdge[0].lastIndexOf('/');
+        let group = splitEdge[0].substring(0, lastSlash);
+        const hash = getHash(splitEdge[0]);
+        group = checkGroupExists(group, name);
+        const transitiveDep = {
+            artifactID: name,
+            group: group,
+            version: splitEdge[1],
+            scope: 'compile',
+            type: 'transitive',
+            hash: hash,
+            edges: {}
+        };
+        const edges = getAllDepsOfADepAsEdge(dep, splitLines);
+        transitiveDep.edges = edges;
+        const edgesAsName = getAllDepsOfADepAsName(dep, splitLines);
+        edgesAsName.forEach(dep => {
+            const splitEdge = dep.split('@');
+            const splitGroupName = splitEdge[0].split('/');
+            const name = splitGroupName.pop();
+            const lastSlash = splitEdge[0].lastIndexOf('/');
+            let group = splitEdge[0].substring(0, lastSlash);
+            const hash = getHash(splitEdge[0]);
+            group = checkGroupExists(group, name);
+            const transitiveDep = {
+                artifactID: name,
+                group: group,
+                version: splitEdge[1],
+                scope: 'compile',
+                type: 'transitive',
+                hash: hash,
+                edges: {}
+            };
+            rootNodes[Object.keys(rootNodes)[0]][dep] = transitiveDep;
+        });
+        rootNodes[Object.keys(rootNodes)[0]][dep] = transitiveDep;
+    });
+};
+module.exports = {
+    parseGoDependencies
+};

package/dist/scaAnalysis/go/goReadDepFile.js

@@ -0,0 +1,23 @@
+"use strict";
+const child_process = require('child_process');
+const i18n = require('i18n');
+const getGoDependencies = config => {
+    let cmdStdout;
+    let cwd = config.projectPath
+        ? config.projectPath.replace('go.mod', '')
+        : process.cwd();
+    try {
+        cmdStdout = child_process.execSync('go mod graph', { cwd });
+        return cmdStdout.toString();
+    }
+    catch (err) {
+        if (err.message === 'spawnSync /bin/sh ENOENT') {
+            err.message =
+                '\n\n*************** No transitive dependencies ***************\n\nWe are unable to build a dependency tree view from your repository as there were no transitive dependencies found.';
+        }
+        console.log(i18n.__('goReadProjectFile', cwd, `${err.message ? err.message : ''}`));
+    }
+};
+module.exports = {
+    getGoDependencies
+};

package/dist/scaAnalysis/java/analysis.js

@@ -0,0 +1,108 @@
+"use strict";
+const child_process = require('child_process');
+const path = require('path');
+const i18n = require('i18n');
+const fs = require('fs');
+const MAVEN = 'maven';
+const GRADLE = 'gradle';
+const determineProjectTypeAndCwd = (files, projectPath) => {
+    const projectData = {};
+    if (files[0].includes('pom.xml')) {
+        projectData.projectType = MAVEN;
+        projectData.cwd = projectPath
+            ? projectPath
+            : files[0].replace('pom.xml', '');
+    }
+    else if (files[0].includes('build.gradle')) {
+        projectData.projectType = GRADLE;
+        projectData.cwd = projectPath
+            ? projectPath
+            : files[0].replace('pom.xml', '');
+    }
+    return projectData;
+};
+const buildMaven = (config, projectData, timeout) => {
+    let cmdStdout;
+    let mvn_settings = '';
+    try {
+        if (config.mavenSettingsPath) {
+            mvn_settings = ' -s ' + config.mavenSettingsPath;
+        }
+        cmdStdout = child_process.execSync('mvn dependency:tree -B' + mvn_settings, {
+            cwd: projectData.cwd,
+            timeout
+        });
+        return cmdStdout.toString();
+    }
+    catch (err) {
+        throw new Error(i18n.__('mavenDependencyTreeNonZero', projectData.cwd, `${err.message}`));
+    }
+};
+const buildGradle = (config, projectData, timeout) => {
+    let cmdStdout;
+    let output = {};
+    try {
+        if (config.subProject) {
+            cmdStdout = child_process.execSync('.' +
+                path.sep +
+                'gradlew :' +
+                config.subProject +
+                ':dependencies --configuration runtimeClasspath', {
+                cwd: projectData.cwd,
+                timeout
+            });
+        }
+        else {
+            cmdStdout = child_process.execSync('.' +
+                path.sep +
+                'gradlew dependencies --configuration runtimeClasspath', {
+                cwd: projectData.cwd,
+                timeout
+            });
+        }
+        if (cmdStdout
+            .toString()
+            .includes("runtimeClasspath - Runtime classpath of source set 'main'.\n" +
+            'No dependencies')) {
+            cmdStdout = child_process.execSync('.' + path.sep + 'gradlew dependencies', {
+                cwd: projectData.cwd,
+                timeout
+            });
+        }
+        output = cmdStdout.toString();
+        return output;
+    }
+    catch (err) {
+        if (fs.existsSync(projectData.cwd + 'gradlew') ||
+            fs.existsSync(projectData.cwd + 'gradlew.bat')) {
+            throw new Error(i18n.__('gradleDependencyTreeNonZero', projectData.cwd, `${err.message}`));
+        }
+        else {
+            throw new Error(i18n.__('gradleWrapperUnavailable', projectData.cwd, `${err.message}`));
+        }
+    }
+};
+const getJavaBuildDeps = (config, files) => {
+    const timeout = 960000;
+    let output = {
+        mvnDependancyTreeOutput: undefined,
+        projectType: undefined
+    };
+    try {
+        const projectData = determineProjectTypeAndCwd(files, config.projectPath);
+        if (projectData.projectType === MAVEN) {
+            output.mvnDependancyTreeOutput = buildMaven(config, projectData, timeout);
+        }
+        else if (projectData.projectType === GRADLE) {
+            output.mvnDependancyTreeOutput = buildGradle(config, projectData, timeout);
+        }
+        output.projectType = projectData.projectType;
+        return output;
+    }
+    catch (err) {
+        console.log(err.message.toString());
+    }
+};
+module.exports = {
+    getJavaBuildDeps
+};

package/dist/scaAnalysis/java/index.js

@@ -0,0 +1,18 @@
+"use strict";
+const analysis = require('./analysis');
+const { parseBuildDeps } = require('./javaBuildDepsParser');
+const { createJavaTSMessage } = require('../common/formatMessage');
+const javaAnalysis = (config, languageFiles) => {
+    languageFiles.java.forEach(file => {
+        file.replace('build.gradle.kts', 'build.gradle');
+    });
+    const javaDeps = buildJavaTree(config, languageFiles.java);
+    return createJavaTSMessage(javaDeps);
+};
+const buildJavaTree = (config, files) => {
+    const javaBuildDeps = analysis.getJavaBuildDeps(config, files);
+    return parseBuildDeps(config, javaBuildDeps);
+};
+module.exports = {
+    javaAnalysis
+};

package/dist/scaAnalysis/java/javaBuildDepsParser.js

@@ -0,0 +1,339 @@
+"use strict";
+const i18n = require('i18n');
+const StringBuilder = require('string-builder');
+let sb = new StringBuilder();
+const parseBuildDeps = (config, input) => {
+    const { mvnDependancyTreeOutput, projectType } = input;
+    try {
+        return parseGradle(mvnDependancyTreeOutput, config, projectType);
+    }
+    catch (err) {
+        throw new Error(i18n.__('javaParseProjectFile') + `${err.message}`);
+    }
+};
+const preParser = shavedOutput => {
+    let obj = [];
+    for (let dep in shavedOutput) {
+        obj.push(shavedOutput[dep]
+            .replace('+-', '+---')
+            .replace('[INFO]', '')
+            .replace('\\-', '\\---')
+            .replace(':jar:', ':')
+            .replace(':test', '')
+            .replace(':compile', '')
+            .replace(' +', '+')
+            .replace(' |', '|')
+            .replace(' \\', '\\')
+            .replace(':runtime', ''));
+    }
+    let depTree = [];
+    for (let x in obj) {
+        let nodeLevel = computeRelationToLastElement(obj[x]);
+        let notLastLevel = obj[x].startsWith('|') ||
+            obj[x].startsWith('+') ||
+            obj[x].startsWith('\\');
+        if (notLastLevel) {
+            if (nodeLevel === 0) {
+                depTree.push(obj[x]);
+            }
+            else {
+                let level = computeLevel(nodeLevel);
+                let validatedLevel = addIndentation(nodeLevel === 2 ? 5 : level, obj[x]);
+                depTree.push(validatedLevel);
+            }
+        }
+        else {
+            let level = computeLevel(nodeLevel);
+            let validatedLevel = addIndentation(nodeLevel === 3 ? 5 : level, obj[x]);
+            depTree.push(validatedLevel);
+        }
+    }
+    return depTree;
+};
+const shaveOutput = (gradleDependencyTreeOutput, projectType) => {
+    let shavedOutput = gradleDependencyTreeOutput.split('\n');
+    if (projectType === 'maven') {
+        shavedOutput = preParser(shavedOutput);
+    }
+    let obj = [];
+    for (let key in shavedOutput) {
+        if (shavedOutput[key].includes('project :')) {
+        }
+        else if (shavedOutput[key].includes('+---') ||
+            shavedOutput[key].includes('\\---')) {
+            obj.push(shavedOutput[key]);
+        }
+    }
+    return obj;
+};
+const computeIndentation = element => {
+    let hasPlus = element.includes('+');
+    let hasSlash = element.includes('\\');
+    if (hasPlus) {
+        return element.substring(element.indexOf('+'));
+    }
+    if (hasSlash) {
+        return element.substring(element.indexOf('\\'));
+    }
+};
+const computeLevel = nodeLevel => {
+    let num = [5, 8, 11, 14, 17, 20];
+    for (let z in num) {
+        if (num[z] === nodeLevel) {
+            let n = parseInt(z);
+            return 5 * (n + 2);
+        }
+    }
+};
+const addIndentation = (number, str) => {
+    str = computeIndentation(str);
+    sb.clear();
+    for (let j = 0; j < number; j++) {
+        sb.append(' ');
+    }
+    sb.append(str);
+    return sb.toString();
+};
+const computeRelationToLastElement = element => {
+    let hasPlus = element.includes('+---');
+    let hasSlash = element.includes('\\---');
+    if (hasPlus) {
+        return element.split('+---')[0].length;
+    }
+    if (hasSlash) {
+        return element.split('\\---')[0].length;
+    }
+};
+const stripElement = element => {
+    return element
+        .replace(/[|]/g, '')
+        .replace('+---', '')
+        .replace('\\---', '')
+        .replace(/[' ']/g, '')
+        .replace('(c)', '')
+        .replace('->', '@')
+        .replace('(*)', '');
+};
+const checkVersion = element => {
+    let version = element.split(':');
+    return version[version.length - 1];
+};
+const createElement = (element, isRoot) => {
+    let tree;
+    let cleanElement = stripElement(element);
+    let splitGroupName = cleanElement.split(':');
+    let validateVersion = false;
+    if (!element.includes('->')) {
+        validateVersion = true;
+    }
+    tree = {
+        artifactID: splitGroupName[1],
+        group: splitGroupName[0],
+        version: validateVersion
+            ? checkVersion(cleanElement)
+            : splitGroupName[splitGroupName.length - 1],
+        scope: 'compile',
+        type: isRoot ? 'direct' : 'transitive',
+        edges: {}
+    };
+    return tree;
+};
+const getElementHeader = element => {
+    let elementHeader = stripElement(element);
+    elementHeader = elementHeader.replace(':', '/');
+    elementHeader = elementHeader.replace(':', '@');
+    return elementHeader;
+};
+const buildElement = (element, rootElement, parentOfCurrent, tree, isRoot) => {
+    let childElement = createElement(element, isRoot);
+    let elementHeader = getElementHeader(element);
+    let levelsArray = [rootElement, parentOfCurrent];
+    const treeNode = getNestedObject(tree, levelsArray);
+    const rootNode = getNestedObject(tree, [rootElement]);
+    if (!rootNode.hasOwnProperty(elementHeader)) {
+        tree[rootElement][elementHeader] = childElement;
+    }
+    treeNode.edges[elementHeader] = elementHeader;
+};
+const hasChildren = (nextNodeLevel, nodeLevel) => {
+    if (nextNodeLevel > nodeLevel) {
+        return true;
+    }
+};
+const lastChild = (nextNodeLevel, nodeLevel) => {
+    if (nextNodeLevel < nodeLevel) {
+        return true;
+    }
+};
+const calculateLevels = (nextNodeLevel, nodeLevel) => {
+    return (nodeLevel - nextNodeLevel) / 5;
+};
+const buildTree = shavedOutput => {
+    let tree = {};
+    let rootElement;
+    let levelNodes = [];
+    shavedOutput.forEach((element, index) => {
+        if (index === 0) {
+            let cleanElement = stripElement(element);
+            let elementHeader = getElementHeader(cleanElement);
+            let splitElement = element.split(' ');
+            let splitGroupName = splitElement[1].split(':');
+            let validateVersion = false;
+            if (!element.includes('->')) {
+                validateVersion = true;
+            }
+            tree[splitGroupName[0]] = {};
+            tree[splitGroupName[0]][elementHeader] = {
+                artifactID: splitGroupName[1],
+                group: splitGroupName[0],
+                version: validateVersion
+                    ? checkVersion(cleanElement)
+                    : splitElement[splitElement.length - 1],
+                scope: 'compile',
+                type: 'direct',
+                edges: {}
+            };
+            rootElement = splitGroupName[0];
+            levelNodes.push(elementHeader);
+        }
+        if (shavedOutput.length - 1 === index) {
+            const parentOfCurrent = levelNodes[levelNodes.length - 1];
+            let nodeLevel = computeRelationToLastElement(element);
+            let validateVersion = false;
+            if (!element.includes('->')) {
+                validateVersion = true;
+            }
+            if (nodeLevel === 0) {
+                let cleanElement = stripElement(element);
+                let elementHeader = getElementHeader(cleanElement);
+                let splitElement = element.split(' ');
+                let splitGroupName = splitElement[1].split(':');
+                tree[rootElement][elementHeader] = {
+                    artifactID: splitGroupName[1],
+                    group: splitGroupName[0],
+                    version: validateVersion
+                        ? checkVersion(cleanElement)
+                        : splitElement[splitElement.length - 1],
+                    scope: 'compile',
+                    type: 'direct',
+                    edges: {}
+                };
+            }
+            else {
+                buildElement(element, rootElement, parentOfCurrent, tree);
+            }
+        }
+        if (index >= 1 && index < shavedOutput.length - 1) {
+            let nodeLevel = computeRelationToLastElement(element);
+            let nextNodeLevel = computeRelationToLastElement(shavedOutput[index + 1]);
+            const parentOfCurrent = levelNodes[levelNodes.length - 1];
+            let isRoot = false;
+            if (nodeLevel === 0) {
+                isRoot = true;
+            }
+            if (isRoot) {
+                let cleanElement = stripElement(element);
+                let elementHeader = getElementHeader(cleanElement);
+                let splitElement = element.split(' ');
+                let splitGroupName = splitElement[1].split(':');
+                let validateVersion = false;
+                if (!element.includes('->')) {
+                    validateVersion = true;
+                }
+                tree[rootElement][elementHeader] = {
+                    artifactID: splitGroupName[1],
+                    group: splitGroupName[0],
+                    version: validateVersion
+                        ? checkVersion(cleanElement)
+                        : splitElement[splitElement.length - 1],
+                    scope: 'compile',
+                    type: 'direct',
+                    edges: {}
+                };
+                levelNodes.push(elementHeader);
+                return;
+            }
+            let elementHeader = getElementHeader(element);
+            buildElement(element, rootElement, parentOfCurrent, tree, isRoot);
+            if (hasChildren(nextNodeLevel, nodeLevel)) {
+                buildElement(element, rootElement, parentOfCurrent, tree, isRoot);
+                levelNodes.push(elementHeader);
+            }
+            if (lastChild(nextNodeLevel, nodeLevel)) {
+                let levelDifference = calculateLevels(nextNodeLevel, nodeLevel);
+                if (levelDifference === 0) {
+                    levelNodes.pop();
+                }
+                else {
+                    let i;
+                    for (i = 0; i < levelDifference; i++) {
+                        levelNodes.pop();
+                    }
+                }
+            }
+        }
+    });
+    return tree;
+};
+const getNestedObject = (nestedObj, pathArr) => {
+    return pathArr.reduce((obj, key) => (obj && obj[key] !== 'undefined' ? obj[key] : undefined), nestedObj);
+};
+const parseSubProject = shavedOutput => {
+    let obj = [];
+    for (let key in shavedOutput) {
+        if (!shavedOutput[key].includes('project')) {
+            obj.push(shavedOutput[key]);
+        }
+    }
+    return obj;
+};
+const validateIndentation = shavedOutput => {
+    let validatedTree = [];
+    shavedOutput.forEach((element, index) => {
+        let nextNodeLevel;
+        let nodeLevel = computeRelationToLastElement(element);
+        if (shavedOutput[index + 1] !== undefined) {
+            nextNodeLevel = computeRelationToLastElement(shavedOutput[index + 1]);
+        }
+        if (index === 0) {
+            validatedTree.push(shavedOutput[index]);
+            validatedTree.push(shavedOutput[index + 1]);
+        }
+        else if (nextNodeLevel > nodeLevel + 5) {
+            return;
+        }
+        else {
+            validatedTree.push(shavedOutput[index + 1]);
+        }
+    });
+    validatedTree.pop();
+    return validatedTree;
+};
+const parseGradle = (gradleDependencyTreeOutput, config, projectType) => {
+    let shavedOutput = shaveOutput(gradleDependencyTreeOutput, projectType);
+    if (config.subProject) {
+        let subProject = parseSubProject(shavedOutput);
+        let validatedOutput = validateIndentation(subProject);
+        return buildTree(validatedOutput);
+    }
+    else {
+        let validatedOutput = validateIndentation(shavedOutput);
+        return buildTree(validatedOutput);
+    }
+};
+module.exports = {
+    parseBuildDeps,
+    shaveOutput,
+    validateIndentation,
+    calculateLevels,
+    lastChild,
+    hasChildren,
+    getElementHeader,
+    createElement,
+    stripElement,
+    checkVersion,
+    computeRelationToLastElement,
+    addIndentation,
+    computeLevel,
+    computeIndentation
+};