@contrast/contrast 1.0.4 → 1.0.7

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
+};

package/dist/scaAnalysis/python/analysis.js

@@ -0,0 +1,41 @@
+"use strict";
+const multiReplace = require('string-multiple-replace');
+const fs = require('fs');
+const readAndParseProjectFile = projectPath => {
+    const filePath = filePathForWindows(projectPath + '/Pipfile');
+    const pipFile = fs.readFileSync(filePath, 'utf8');
+    const matcherObj = { '"': '' };
+    const sequencer = ['"'];
+    const parsedPipfile = multiReplace(pipFile, matcherObj, sequencer);
+    const pythonArray = parsedPipfile.split('\n');
+    return pythonArray.filter(element => element !== '' && !element.includes('#'));
+};
+const readAndParseLockFile = projectPath => {
+    const filePath = filePathForWindows(projectPath + '/Pipfile.lock');
+    const lockFile = fs.readFileSync(filePath, 'utf8');
+    let parsedPipLock = JSON.parse(lockFile);
+    parsedPipLock['defaults'] = parsedPipLock['default'];
+    return parsedPipLock;
+};
+const getPythonDeps = config => {
+    try {
+        const parseProject = readAndParseProjectFile(config.projectPath);
+        const parsePip = readAndParseLockFile(config.projectPath);
+        return { pipfileLock: parseProject, pipfilDependanceies: parsePip };
+    }
+    catch (err) {
+        console.log(err.message.toString());
+        process.exit(1);
+    }
+};
+const filePathForWindows = path => {
+    if (process.platform === 'win32') {
+        path = path.replace(/\//g, '\\');
+    }
+    return path;
+};
+module.exports = {
+    getPythonDeps,
+    readAndParseProjectFile,
+    readAndParseLockFile
+};

package/dist/scaAnalysis/python/index.js

@@ -0,0 +1,10 @@
+"use strict";
+const { createPythonTSMessage } = require('../common/formatMessage');
+const { getPythonDeps } = require('./analysis');
+const pythonAnalysis = (config, languageFiles) => {
+    const pythonDeps = getPythonDeps(config, languageFiles.PYTHON);
+    return createPythonTSMessage(pythonDeps);
+};
+module.exports = {
+    pythonAnalysis
+};

package/dist/scaAnalysis/ruby/analysis.js

@@ -0,0 +1,226 @@
+"use strict";
+const fs = require('fs');
+const readAndParseGemfile = projectPath => {
+    const fileName = filePathForWindows(projectPath + '/Gemfile');
+    const gemFile = fs.readFileSync(fileName, 'utf8');
+    const rubyArray = gemFile.split('\n');
+    let filteredRubyDep = rubyArray.filter(element => {
+        return (!element.includes('#') &&
+            element.includes('gem') &&
+            !element.includes('source'));
+    });
+    for (let i = 0; i < filteredRubyDep.length; i++) {
+        filteredRubyDep[i] = filteredRubyDep[i].trim();
+    }
+    return filteredRubyDep;
+};
+const readAndParseGemLockFile = projectPath => {
+    const fileName = filePathForWindows(projectPath + '/Gemfile.lock');
+    const lockFile = fs.readFileSync(fileName, 'utf8');
+    const dependencyRegEx = /^\s*([A-Za-z0-9.!@#$%\-^&*_+]*)\s*(\((.*?)\))/;
+    const lines = lockFile.split('\n');
+    return {
+        dependencies: getDirectDependencies(lines, dependencyRegEx),
+        runtimeDetails: getLockFileRuntimeInfo(lines),
+        sources: getSourceArray(lines, dependencyRegEx)
+    };
+};
+const nonDependencyKeys = (line, sourceObject) => {
+    const GEMFILE_KEY_VALUE = /^\s*([^:(]*)\s*\s*(.*)/;
+    let parts = GEMFILE_KEY_VALUE.exec(line);
+    let key = parts[1].trim();
+    let value = parts[2] || '';
+    sourceObject[key] = value;
+    return sourceObject;
+};
+const populateResolveAndPlatform = (version, sourceObject) => {
+    const depArr = version.split('-');
+    sourceObject.resolved = depArr[0];
+    sourceObject.platform = depArr.length > 1 ? depArr[1] : 'UNSPECIFIED';
+    return sourceObject;
+};
+const isUpperCase = str => {
+    return str === str.toUpperCase();
+};
+const getDirectDependencies = (lines, dependencyRegEx) => {
+    const dependencies = {};
+    let depIndex = 0;
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i] === 'DEPENDENCIES') {
+            depIndex = i;
+        }
+    }
+    const getDepArray = lines.slice(depIndex);
+    for (let j = 1; j < getDepArray.length; j++) {
+        const element = getDepArray[j];
+        if (!isUpperCase(element)) {
+            const isDependencyWithVersion = dependencyRegEx.test(element);
+            if (isDependencyWithVersion) {
+                const dependency = dependencyRegEx.exec(element);
+                let name = dependency[1];
+                name = name.replace('!', '');
+                dependencies[name.trim()] = dependency[3];
+            }
+            else {
+                let name = element;
+                name = name.replace('!', ' ');
+                dependencies[name.trim()] = 'UNSPECIFIED';
+            }
+        }
+    }
+    return dependencies;
+};
+const getLockFileRuntimeInfo = lines => {
+    let rubVersionIndex = 0;
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i] === 'RUBY VERSION') {
+            rubVersionIndex = i;
+            break;
+        }
+    }
+    const runtimeDetails = {};
+    if (rubVersionIndex !== 0) {
+        const getRubyVersionArray = lines.slice(rubVersionIndex);
+        for (let element of getRubyVersionArray) {
+            if (!isUpperCase(element)) {
+                runtimeDetails['version'] = getVersion(element);
+                runtimeDetails['patchLevel'] = getPatchLevel(element);
+                if (element.includes('engine')) {
+                    let splitElement = element.split(' ');
+                    runtimeDetails[splitElement[0]] = splitElement[1];
+                }
+            }
+        }
+    }
+    return runtimeDetails;
+};
+const getVersion = element => {
+    const versionRegex = /^([ruby\s0-9.*]+)/;
+    if (versionRegex.test(element)) {
+        let version = versionRegex.exec(element)[0];
+        if (version.includes('ruby')) {
+            return trimWhiteSpace(version.replace('ruby', ''));
+        }
+    }
+};
+const getPatchLevel = element => {
+    const patchLevelRegex = /(p\d+)/;
+    if (patchLevelRegex.test(element)) {
+        return patchLevelRegex.exec(element)[0];
+    }
+};
+const formatSourceArr = sourceArr => {
+    return sourceArr.map(element => {
+        if (element.sourceType === 'GIT') {
+            delete element.specs;
+        }
+        if (element.sourceType === 'GEM') {
+            delete element.branch;
+            delete element.revision;
+            delete element.depthLevel;
+            delete element.specs;
+        }
+        if (element.sourceType === 'PATH') {
+            delete element.branch;
+            delete element.revision;
+            delete element.depthLevel;
+            delete element.specs;
+            delete element.platform;
+        }
+        return element;
+    });
+};
+const getSourceArray = (lines, dependencyRegEx) => {
+    const sourceObject = {
+        dependencies: {}
+    };
+    const whitespaceRegx = /^(\s*)/;
+    let index = 0;
+    let line = 0;
+    const sources = [];
+    while ((line = lines[index++]) !== undefined) {
+        let currentWS = whitespaceRegx.exec(line)[1].length;
+        if (!line.includes(' bundler (')) {
+            if (currentWS === 0 && !line.includes(':') && line !== '') {
+                sourceObject.sourceType = line;
+            }
+            if (currentWS !== 0 && line.includes(':')) {
+                nonDependencyKeys(line, sourceObject);
+            }
+            if (currentWS > 2) {
+                let nexlineWS = whitespaceRegx.exec(lines[index])[1].length;
+                sourceObject.dependencies = buildSourceDependencyWithVersion(whitespaceRegx, dependencyRegEx, line, currentWS, sourceObject.name, sourceObject.dependencies);
+                if (currentWS === 4 && sourceObject.depthLevel === undefined) {
+                    const dependency = dependencyRegEx.exec(line);
+                    sourceObject.name = dependency[1];
+                    sourceObject.depthLevel = currentWS;
+                    populateResolveAndPlatform(dependency[3], sourceObject);
+                }
+                if (currentWS === 4 && sourceObject.depthLevel) {
+                    const dependency = dependencyRegEx.exec(line);
+                    sourceObject.name = dependency[1];
+                    sourceObject.depthLevel = currentWS;
+                    populateResolveAndPlatform(dependency[3], sourceObject);
+                }
+                if ((currentWS === 4 && nexlineWS === 4) ||
+                    (currentWS === 6 && nexlineWS === 4) ||
+                    nexlineWS === '') {
+                    let newObj = {};
+                    newObj = JSON.parse(JSON.stringify(sourceObject));
+                    sources.push(newObj);
+                    sourceObject.dependencies = {};
+                }
+            }
+        }
+    }
+    return formatSourceArr(sources);
+};
+const buildSourceDependencyWithVersion = (whitespaceRegx, dependencyRegEx, line, currentWhiteSpace, name, dependencies) => {
+    const isDependencyWithVersion = dependencyRegEx.test(line);
+    if (currentWhiteSpace === 6) {
+        const dependency = dependencyRegEx.exec(line);
+        if (isDependencyWithVersion) {
+            if (name !== dependency[1]) {
+                dependencies[dependency[1]] = dependency[3];
+            }
+        }
+        else {
+            dependencies[line.trim()] = 'UNSPECIFIED';
+        }
+    }
+    return dependencies;
+};
+const getRubyDeps = config => {
+    try {
+        const parsedGem = readAndParseGemfile(config.projectPath);
+        const parsedLock = readAndParseGemLockFile(config.projectPath);
+        return { gemfilesDependanceies: parsedGem, gemfileLock: parsedLock };
+    }
+    catch (err) {
+        console.log(err.message);
+        process.exit(1);
+    }
+};
+const trimWhiteSpace = string => {
+    return string.replace(/\s+/g, '');
+};
+const filePathForWindows = path => {
+    if (process.platform === 'win32') {
+        path = path.replace(/\//g, '\\');
+    }
+    return path;
+};
+module.exports = {
+    getRubyDeps,
+    readAndParseGemfile,
+    readAndParseGemLockFile,
+    nonDependencyKeys,
+    populateResolveAndPlatform,
+    isUpperCase,
+    getDirectDependencies,
+    getLockFileRuntimeInfo,
+    getVersion,
+    getPatchLevel,
+    formatSourceArr,
+    getSourceArray
+};

package/dist/scaAnalysis/ruby/index.js

@@ -0,0 +1,10 @@
+"use strict";
+const { getRubyDeps } = require('./analysis');
+const { createRubyTSMessage } = require('../common/formatMessage');
+const rubyAnalysis = (config, languageFiles) => {
+    const rubyDeps = getRubyDeps(config, languageFiles.RUBY);
+    return createRubyTSMessage(rubyDeps);
+};
+module.exports = {
+    rubyAnalysis
+};