Merge branch 'feat-3' into alpha

Author: dominykas

lib/deps.js

@@ -9,10 +9,9 @@ const Tmp = require('tmp');
 const Package = require('./package');
 const Utils = require('./utils');
 
-const internals = {};
-
-
-internals.log = Debug('detect-node-support');
+const internals = {
+    log: Debug('detect-node-support')
+};
 
 
 internals.resolve = async ({ packageJson, lockfile }, options) => {

lib/loader.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const Debug = require('debug');
 const Fs = require('fs');
 const GitUrlParse = require('git-url-parse');
 const Package = require('../package.json');
@@ -9,7 +10,10 @@ const Wreck = require('@hapi/wreck');
 
 const Utils = require('./utils');
 
-const internals = {};
+const internals = {
+    cache: new Map(),
+    log: Debug('detect-node-support-loader')
+};
 
 
 internals.parseRepository = (packument) => {
@@ -85,15 +89,27 @@ internals.createRepositoryLoader = (repository) => {
             }
 
             const url = `https://raw.githubusercontent.com/${parsedRepository.full_name}/HEAD/${filename}`;
+            internals.log('Loading: %s', url);
+
+            if (options === undefined && internals.cache.has(url)) {
+                internals.log('From cache: %s', url);
+                return internals.cache[url];
+            }
 
             try {
                 const { payload } = await Wreck.get(url, options);
 
+                if (options === undefined) {
+                    internals.cache.set(url, payload);
+                }
+
+                internals.log('Loaded: %s', url);
                 return payload;
             }
             catch (err) {
 
                 if (err.output && err.output.statusCode === 404) {
+                    internals.log('Not found: %s', url);
                     const error = new Error(`${repository} does not contain a ${filename}`);
                     error.code = 'ENOENT';
                     throw error;
@@ -152,3 +168,9 @@ exports.create = ({ path, repository, packageName }) => {
 
     return internals.createPathLoader(path);
 };
+
+
+exports.clearCache = () => {
+
+    internals.cache = new Map();
+};

lib/travis/imports.js

@@ -0,0 +1,102 @@
+'use strict';
+
+const Yaml = require('js-yaml');
+
+const Loader = require('../loader');
+const Utils = require('../utils');
+
+const TravisMerge = require('./merge');
+
+
+const internals = {
+    validMergeModes: new Set(['deep_merge_append', 'deep_merge_prepend', 'deep_merge', 'merge'])
+};
+
+
+internals.normalizeImports = (travisYaml, { relativeTo, breadcrumb }) => {
+
+    const context = relativeTo ? relativeTo.source : '.travis.yml';
+
+    return Utils.toArray(travisYaml.import)
+        .map((entry) => {
+
+            if (typeof entry === 'string') {
+                entry = { source: entry };
+            }
+
+            const original = entry.source;
+
+            if (entry.source.startsWith('./')) {
+                entry.source = entry.source.substring(2);
+
+                if (relativeTo) {
+                    const relativeParts = relativeTo.source.split('/');
+                    relativeParts.pop();
+                    relativeParts.push(entry.source);
+                    entry.source = relativeParts.join('/');
+                }
+            }
+
+            if (!entry.mode) {
+                entry.mode = 'deep_merge_append';
+            }
+
+            if (!internals.validMergeModes.has(entry.mode)) {
+                throw new Error(`Invalid merge mode for ${original} in ${context}: ${entry.mode}`);
+            }
+
+            if (original.includes('@')) {
+                throw new Error(`Importing at commitish unsupported in ${context}: ${original}`);
+            }
+
+            const alreadyImported = breadcrumb.indexOf(entry.source);
+            if (alreadyImported >= 0) {
+                throw new Error(`Circular dependency ${entry.source} requested by ${context} (already imported at ${breadcrumb[alreadyImported - 1]})`);
+            }
+
+            return entry;
+        })
+        .filter((entry) => !entry.if); // @todo: log a warning
+};
+
+
+internals.loadSource = async (source, { loadFile }) => {
+
+    let path = source;
+
+    if (source.includes(':')) {
+        const [repository, fileName] = source.split(':');
+        const loader = await Loader.create({ repository: `https://github.com/${repository}` });
+
+        path = fileName;
+        loadFile = loader.loadFile;
+    }
+
+    return loadFile(path);
+};
+
+
+exports.apply = async (yaml, { loadFile, relativeTo, breadcrumb = ['.travis.yml'] }) => {
+
+    if (!yaml.import) {
+        return;
+    }
+
+    const imports = internals.normalizeImports(yaml, { relativeTo, breadcrumb });
+
+    for (const entry of imports) {
+
+        const buffer = await internals.loadSource(entry.source, { loadFile });
+
+        const imported = Yaml.safeLoad(buffer, {
+            schema: Yaml.FAILSAFE_SCHEMA,
+            json: true
+        });
+
+        await exports.apply(imported, { loadFile, relativeTo: entry, breadcrumb: [...breadcrumb, entry.source] });
+
+        delete imported.import;
+
+        TravisMerge[entry.mode](yaml, imported);
+    }
+};

lib/travis.js lib/travis/index.js

@@ -3,39 +3,35 @@
 const Nv = require('@pkgjs/nv');
 const Yaml = require('js-yaml');
 
+const TravisImports = require('./imports');
+const Utils = require('../utils');
+
 
 const internals = {};
 
+
 internals.nodeAliases = {
     latest: 'active',
     node: 'active',
     stable: 'active'
 };
 
 
-internals.toArray = (v) => {
-
-    if (v === undefined) {
-        return [];
-    }
-
-    return Array.isArray(v) ? v : [v];
-};
-
+internals.scan = async (travisYaml, options) => {
 
-internals.scan = async (travisYaml) => {
+    await TravisImports.apply(travisYaml, options);
 
     const rawSet = new Set();
 
-    for (const v of internals.toArray(travisYaml.node_js)) {
+    for (const v of Utils.toArray(travisYaml.node_js)) {
         rawSet.add(v);
     }
 
     if (travisYaml.env) {
 
-        for (const env of internals.toArray(travisYaml.env.matrix)) {
+        for (const env of Utils.toArray(travisYaml.env.matrix)) {
 
-            const matches = env.match(/(?:NODEJS_VER|TRAVIS_NODE_VERSION|NODE_VER)="?(node\/)?(?<version>[\w./*]+)"?/); /* hack syntax highlighter 🤦‍♂️ */
+            const matches = env.match(/(?:NODEJS_VER|TRAVIS_NODE_VERSION|NODE_VER)="?(node\/)?(?<version>[\w./*]+)"?/);
 
             if (matches) {
                 rawSet.add(matches.groups.version);
@@ -45,7 +41,7 @@ internals.scan = async (travisYaml) => {
 
     if (travisYaml.matrix) {
 
-        for (const include of internals.toArray(travisYaml.matrix.include)) {
+        for (const include of Utils.toArray(travisYaml.matrix.include)) {
 
             if (include.node_js) {
                 rawSet.add(include.node_js);
@@ -96,6 +92,6 @@ exports.detect = async ({ loadFile }) => {
     });
 
     return {
-        travis: await internals.scan(travisYaml)
+        travis: await internals.scan(travisYaml, { loadFile })
     };
 };

lib/travis/merge.js

@@ -0,0 +1,65 @@
+'use strict';
+
+// ref: https://github.com/travis-ci/travis-yml/blob/bf82881491134c72a64778f9664a8dd3f97158e7/lib/travis/yml/support/merge.rb
+
+const internals = {};
+
+
+internals.isObject = (arg) => typeof arg === 'object' && !Array.isArray(arg);
+
+
+exports.deep_merge_append = (left, right) => {
+
+    for (const key in right) {
+
+        if (internals.isObject(left[key]) && internals.isObject(right[key])) {
+            exports.deep_merge_append(left[key], right[key]);
+            continue;
+        }
+
+        if (Array.isArray(left[key]) && Array.isArray(right[key])) {
+            left[key].push(...right[key]);
+            continue;
+        }
+
+        left[key] = right[key];
+    }
+};
+
+exports.deep_merge_prepend = (left, right) => {
+
+    for (const key in right) {
+
+        if (internals.isObject(left[key]) && internals.isObject(right[key])) {
+            exports.deep_merge_prepend(left[key], right[key]);
+            continue;
+        }
+
+        if (Array.isArray(left[key]) && Array.isArray(right[key])) {
+            left[key].unshift(...right[key]);
+            continue;
+        }
+
+        left[key] = right[key];
+    }
+};
+
+exports.deep_merge = (left, right) => {
+
+    for (const key in right) {
+
+        if (internals.isObject(left[key]) && internals.isObject(right[key])) {
+            exports.deep_merge(left[key], right[key]);
+            continue;
+        }
+
+        left[key] = right[key];
+    }
+};
+
+exports.merge = (left, right) => {
+
+    for (const key in right) {
+        left[key] = right[key];
+    }
+};

lib/utils.js

@@ -22,3 +22,13 @@ exports.getErrorMessage = (error) => {
 
     return null;
 };
+
+
+exports.toArray = (v) => {
+
+    if (v === undefined) {
+        return [];
+    }
+
+    return Array.isArray(v) ? v : [v];
+};