@contrast/contrast 1.0.5 → 1.0.8

package/dist/scaAnalysis/java/analysis.js

@@ -5,23 +5,20 @@ const i18n = require('i18n');
 const fs = require('fs');
 const MAVEN = 'maven';
 const GRADLE = 'gradle';
-const determineProjectTypeAndCwd = (files, projectPath) => {
+const determineProjectTypeAndCwd = (files, file) => {
     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', '');
     }
+    projectData.cwd = file
+        ? file.replace('pom.xml', '').replace('build.gradle', '')
+        : file;
     return projectData;
 };
-const buildMaven = async (config, projectData, timeout) => {
+const buildMaven = (config, projectData, timeout) => {
     let cmdStdout;
     let mvn_settings = '';
     try {
@@ -35,16 +32,7 @@ const buildMaven = async (config, projectData, timeout) => {
         return cmdStdout.toString();
     }
     catch (err) {
-        try {
-            child_process.execSync('mvn --version', {
-                cwd: projectData.cwd,
-                timeout
-            });
-            throw new Error(i18n.__('mavenDependencyTreeNonZero', projectData.cwd, `${err.message}`));
-        }
-        catch (mvnErr) {
-            throw new Error(i18n.__('mavenNotInstalledError', projectData.cwd, `${mvnErr.message}`));
-        }
+        throw new Error(i18n.__('mavenDependencyTreeNonZero', projectData.cwd, `${err.message}`));
     }
 };
 const buildGradle = (config, projectData, timeout) => {
@@ -78,7 +66,7 @@ const buildGradle = (config, projectData, timeout) => {
                 timeout
             });
         }
-        output.mvnDependancyTreeOutput = cmdStdout.toString();
+        output = cmdStdout.toString();
         return output;
     }
     catch (err) {
@@ -91,16 +79,16 @@ const buildGradle = (config, projectData, timeout) => {
         }
     }
 };
-const getJavaBuildDeps = async (config, files) => {
+const getJavaBuildDeps = (config, files) => {
     const timeout = 960000;
     let output = {
         mvnDependancyTreeOutput: undefined,
         projectType: undefined
     };
     try {
-        const projectData = determineProjectTypeAndCwd(files, config.projectPath);
+        const projectData = determineProjectTypeAndCwd(files, config.file);
         if (projectData.projectType === MAVEN) {
-            output.mvnDependancyTreeOutput = await buildMaven(config, projectData, timeout);
+            output.mvnDependancyTreeOutput = buildMaven(config, projectData, timeout);
         }
         else if (projectData.projectType === GRADLE) {
             output.mvnDependancyTreeOutput = buildGradle(config, projectData, timeout);
@@ -109,6 +97,7 @@ const getJavaBuildDeps = async (config, files) => {
         return output;
     }
     catch (err) {
+        console.log(err.message.toString());
     }
 };
 module.exports = {

package/dist/scaAnalysis/java/index.js

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

package/dist/scaAnalysis/java/javaBuildDepsParser.js

@@ -322,5 +322,18 @@ const parseGradle = (gradleDependencyTreeOutput, config, projectType) => {
     }
 };
 module.exports = {
-    parseBuildDeps
+    parseBuildDeps,
+    shaveOutput,
+    validateIndentation,
+    calculateLevels,
+    lastChild,
+    hasChildren,
+    getElementHeader,
+    createElement,
+    stripElement,
+    checkVersion,
+    computeRelationToLastElement,
+    addIndentation,
+    computeLevel,
+    computeIndentation
 };

package/dist/scaAnalysis/javascript/analysis.js

@@ -0,0 +1,110 @@
+"use strict";
+const fs = require('fs');
+const yarnParser = require('@yarnpkg/lockfile');
+const yaml = require('js-yaml');
+const i18n = require('i18n');
+const { formatKey } = require('../../audit/nodeAnalysisEngine/parseYarn2LockFileContents');
+const readFile = async (config, languageFiles, nameOfFile) => {
+    const index = languageFiles.findIndex(v => v.includes(nameOfFile));
+    if (config.file) {
+        return fs.readFileSync(config.file.concat(languageFiles[index]), 'utf8');
+    }
+    else {
+        console.log('could not find file');
+    }
+};
+const readYarn = async (config, languageFiles, nameOfFile) => {
+    let yarn = {
+        yarnVersion: 1,
+        rawYarnLockFileContents: ''
+    };
+    try {
+        let rawYarnLockFileContents = await readFile(config, languageFiles, nameOfFile);
+        yarn.rawYarnLockFileContents = rawYarnLockFileContents;
+        if (!yarn.rawYarnLockFileContents.includes('lockfile v1') ||
+            yarn.rawYarnLockFileContents.includes('__metadata')) {
+            yarn.rawYarnLockFileContents = yaml.load(rawYarnLockFileContents);
+            yarn.yarnVersion = 2;
+        }
+        return yarn;
+    }
+    catch (err) {
+        console.log(i18n.__('nodeReadYarnLockFileError') + `${err.message}`);
+        return;
+    }
+};
+const parseNpmLockFile = async (js) => {
+    try {
+        js.npmLockFile = JSON.parse(js.rawLockFileContents);
+        if (js.npmLockFile && js.npmLockFile.lockfileVersion > 1) {
+            const listOfTopDep = Object.keys(js.npmLockFile.dependencies);
+            Object.entries(js.npmLockFile.dependencies).forEach(([objKey, value]) => {
+                if (value.requires) {
+                    const listOfRequiresDep = Object.keys(value.requires);
+                    listOfRequiresDep.forEach(dep => {
+                        if (!listOfTopDep.includes(dep)) {
+                            addDepToLockFile(js, value['requires'], dep);
+                        }
+                    });
+                }
+                if (value.dependencies) {
+                    Object.entries(value.dependencies).forEach(([objChildKey, childValue]) => {
+                        if (childValue.requires) {
+                            const listOfRequiresDep = Object.keys(childValue.requires);
+                            listOfRequiresDep.forEach(dep => {
+                                if (!listOfTopDep.includes(dep)) {
+                                    addDepToLockFile(js, childValue['requires'], dep);
+                                }
+                            });
+                        }
+                    });
+                }
+            });
+            return js.npmLockFile;
+        }
+        else {
+            return js.npmLockFile;
+        }
+    }
+    catch (err) {
+        console.log(i18n.__('NodeParseNPM') + `${err.message}`);
+        return;
+    }
+};
+const addDepToLockFile = (js, depObj, key) => {
+    return (js.npmLockFile.dependencies[key] = { version: depObj[key] });
+};
+const parseYarnLockFile = async (js) => {
+    try {
+        js.yarn.yarnLockFile = {};
+        if (js.yarn.yarnVersion === 1) {
+            js.yarn.yarnLockFile = yarnParser.parse(js.yarn.rawYarnLockFileContents);
+            delete js.yarn.rawYarnLockFileContents;
+            return js;
+        }
+        else {
+            js.yarn.yarnLockFile['object'] = js.yarn.rawYarnLockFileContents;
+            delete js.yarn.yarnLockFile['object'].__metadata;
+            js.yarn.yarnLockFile['type'] = 'success';
+            Object.entries(js.yarn.rawYarnLockFileContents).forEach(([key, value]) => {
+                const rawKeyNames = key.split(',');
+                const keyNames = formatKey(rawKeyNames);
+                keyNames.forEach(name => {
+                    js.yarn.yarnLockFile.object[name] = value;
+                });
+            });
+            return js;
+        }
+    }
+    catch (err) {
+        console.log(i18n.__('NodeParseYarn') + `${err.message}`);
+        return;
+    }
+};
+module.exports = {
+    readYarn,
+    parseYarnLockFile,
+    parseNpmLockFile,
+    readFile,
+    formatKey
+};

package/dist/scaAnalysis/javascript/index.js

@@ -0,0 +1,41 @@
+"use strict";
+const analysis = require('./analysis');
+const i18n = require('i18n');
+const formatMessage = require('../common/formatMessage');
+const jsAnalysis = async (config, languageFiles) => {
+    if (languageFiles.JAVASCRIPT.includes('package-lock.json') &&
+        languageFiles.JAVASCRIPT.includes('yarn.lock')) {
+        console.log(i18n.__('languageAnalysisMultipleLanguages1'));
+        return;
+    }
+    return buildNodeTree(config, languageFiles.JAVASCRIPT);
+};
+const buildNodeTree = async (config, files) => {
+    let analysis = await readFiles(config, files);
+    const rawNode = await parseFiles(config, files, analysis);
+    return formatMessage.createJavaScriptTSMessage(rawNode);
+};
+const readFiles = async (config, files) => {
+    let js = {};
+    js.packageJSON = JSON.parse(await analysis.readFile(config, files, 'package.json'));
+    if (files.includes('package-lock.json')) {
+        js.rawLockFileContents = await analysis.readFile(config, files, 'package-lock.json');
+    }
+    if (files.includes('yarn.lock')) {
+        js.yarn = {};
+        js.yarn = await analysis.readYarn(config, files, 'yarn.lock');
+    }
+    return js;
+};
+const parseFiles = async (config, files, js) => {
+    if (files.includes('package-lock.json')) {
+        js.npmLockFile = await analysis.parseNpmLockFile(js);
+    }
+    if (files.includes('yarn.lock')) {
+        js = await analysis.parseYarnLockFile(js);
+    }
+    return js;
+};
+module.exports = {
+    jsAnalysis
+};

package/dist/scaAnalysis/php/analysis.js

@@ -0,0 +1,89 @@
+"use strict";
+const fs = require('fs');
+const i18n = require('i18n');
+const _ = require('lodash');
+let php = {};
+const readProjectFile = (projectPath, customFile) => {
+    const filePath = filePathForWindows(projectPath + customFile);
+    try {
+        php.composerJSON = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        php.composerJSON.dependencies = php.composerJSON.require;
+        php.composerJSON.devDependencies = php.composerJSON['require-dev'];
+        return php;
+    }
+    catch (err) {
+        console.log(err.message.toString());
+    }
+};
+const readAndParseLockFile = (projectPath, customFile) => {
+    const filePath = filePathForWindows(projectPath + customFile);
+    try {
+        php.rawLockFileContents = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        php.lockFile = php.rawLockFileContents;
+        let packages = _.keyBy(php.lockFile.packages, 'name');
+        let packagesDev = _.keyBy(php.lockFile['packages-dev'], 'name');
+        php.lockFile.dependencies = _.merge(packages, packagesDev);
+        const listOfTopDep = Object.keys(php.lockFile.dependencies);
+        Object.entries(php.lockFile.dependencies).forEach(([key, value]) => {
+            if (value.require) {
+                const listOfRequiresDep = Object.keys(value.require);
+                listOfRequiresDep.forEach(dep => {
+                    if (!listOfTopDep.includes(dep)) {
+                        addChildDepToLockFileAsOwnObj(php, value['require'], dep);
+                    }
+                });
+            }
+            if (value['require-dev']) {
+                const listOfRequiresDep = Object.keys(value['require-dev']);
+                listOfRequiresDep.forEach(dep => {
+                    if (!listOfTopDep.includes(dep)) {
+                        addChildDepToLockFileAsOwnObj(php, value['require-dev'], dep);
+                    }
+                });
+            }
+        });
+        formatParentDepToLockFile(php);
+        delete php.rawLockFileContents;
+        return php;
+    }
+    catch (err) {
+        return console.log(i18n.__('phpParseComposerLock', php) + `${err.message}`);
+    }
+};
+const getPhpDeps = (config, files) => {
+    try {
+        return (readProjectFile(config.file, files[0].projectFilename),
+            readAndParseLockFile(config.file, files[1].lockFilename));
+    }
+    catch (err) {
+        console.log(err.message.toString());
+        process.exit(1);
+    }
+};
+const filePathForWindows = path => {
+    if (process.platform === 'win32') {
+        path = path.replace(/\//g, '\\');
+    }
+    return path;
+};
+function addChildDepToLockFileAsOwnObj(php, depObj, key) {
+    php.lockFile.dependencies[key] = { version: depObj[key] };
+}
+function formatParentDepToLockFile(php) {
+    for (const [key, value] of Object.entries(php.lockFile.dependencies)) {
+        let requires = {};
+        for (const [childKey, childValue] of Object.entries(value)) {
+            if (childKey === 'require' || childKey === 'require-dev') {
+                requires = _.merge(requires, childValue);
+                php.lockFile.dependencies[key].requires = requires;
+                delete php.lockFile.dependencies[key].require;
+                delete php.lockFile.dependencies[key]['require-dev'];
+            }
+        }
+    }
+}
+module.exports = {
+    getPhpDeps,
+    readAndParseLockFile,
+    readProjectFile
+};

package/dist/scaAnalysis/php/index.js

@@ -0,0 +1,10 @@
+"use strict";
+const { getPhpDeps } = require('./analysis');
+const { createPhpTSMessage } = require('../common/formatMessage');
+const phpAnalysis = (config, languageFiles) => {
+    const phpDeps = getPhpDeps(config, languageFiles.PHP);
+    return createPhpTSMessage(phpDeps);
+};
+module.exports = {
+    phpAnalysis
+};

package/dist/scaAnalysis/python/analysis.js

@@ -0,0 +1,42 @@
+"use strict";
+const multiReplace = require('string-multiple-replace');
+const fs = require('fs');
+const readAndParseProjectFile = file => {
+    const filePath = filePathForWindows(file + '/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 = file => {
+    const filePath = filePathForWindows(file + '/Pipfile.lock');
+    const lockFile = fs.readFileSync(filePath, 'utf8');
+    let parsedPipLock = JSON.parse(lockFile);
+    parsedPipLock['defaults'] = parsedPipLock['default'];
+    delete parsedPipLock['default'];
+    return parsedPipLock;
+};
+const getPythonDeps = config => {
+    try {
+        const parseProject = readAndParseProjectFile(config.file);
+        const parsePip = readAndParseLockFile(config.file);
+        return { pipfileLock: parsePip, pipfilDependanceies: parseProject };
+    }
+    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 = file => {
+    const fileName = filePathForWindows(file + '/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 = file => {
+    const fileName = filePathForWindows(file + '/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.file);
+        const parsedLock = readAndParseGemLockFile(config.file);
+        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 analysis = require('./analysis');
+const { createRubyTSMessage } = require('../common/formatMessage');
+const rubyAnalysis = (config, languageFiles) => {
+    const rubyDeps = analysis.getRubyDeps(config, languageFiles.RUBY);
+    return createRubyTSMessage(rubyDeps);
+};
+module.exports = {
+    rubyAnalysis
+};