Merge pull request #2 from pkgjs/detect

Detect node versions from .travis.yml

Author: dominykas

README.md

@@ -33,10 +33,10 @@ const result = await require('node-support').detect({ path });
 `path` should be a folder in the local file system. When the path is not a git repository - tries to read the git repository from `package.json` and tries to detect the versions listed in the repository as well. 
 
 ```
-const result = await require('node-support').detect({ package });
+const result = await require('node-support').detect({ packageName });
 ```
 
-`package` is a string name for the package in the registry. 
+`packageName` is a string name for the package in the registry. 
 
 ```
 const result = await require('node-support').detect({ repository });
@@ -47,40 +47,47 @@ const result = await require('node-support').detect({ repository });
 ### Result
 
 - Throws if the `path` / `repository` does not have a `package.json`
-- Throws if `package` does not exist in the registry
+- Throws if `packageName` does not exist in the registry
+- Throws when unable to detect a git repository for the package
 
 Otherwise returns an object with:
 
 ```javascript
 const result = {
 
-    // the "name" field of the `package.json`
-    name: "package-name",    
+    // the `name` field of the `package.json`
+    "name": "package-name",    
 
-    // the "version" field of the `package.json` when used with `path` / `repository`,
+    // the `version` field of the `package.json` when used with `path` / `repository`,
     // the `latest` dist-tag version when used with `package`
-    version: "0.0.0",
+    "version": "0.0.0",
 
     // the current time when the result is returned
-    timestamp: 1577115956099,
+    "timestamp": 1577115956099,
 
     // git commit hash of the repository HEAD at the time of scanning
-    // will be left out when no git repository detected
-    commit: "2de28c8c4ab8ac998d403509123736929131908c",
+    "commit": "2de28c8c4ab8ac998d403509123736929131908c",
 
     // will be left out when not present in the `package.json`
     // a copy of the `engines.node` field from the `package.json` if present
-    engines: ">=x.y.z", 
+    "engines": ">=x.y.z", 
 
     // will be left out when `.travis.yml` file is not present
-    travis: {
+    "travis": {
         // the list of versions as detected by inspecting `node_js` / `matrix` configuration
         // will be an empty array when no versions are detected or the project is not a Node.js project
         // will contain "latest" when `language: node_js` specified, but no explicit versions detected
-        raw: ["8", "10", "lts/*"],
-
-        // raw version specifiers and keywords resolved to exact Node.js versions
-        resolved: ["8.17.0", "10.18.0", "12.14.0"]
+        "raw": ["8", "10", "lts/*", "invalid-specifier"],
+
+        // raw version specifiers and keywords (as keys) resolved to exact Node.js versions (as values)
+        // the value will be `false` when the specifier/keyword is unrecognized
+        // will be an empty object when the `raw` array is empty
+        "resolved": {
+            "8": "8.17.0", 
+            "10": "10.18.0", 
+            "lts/*": "12.14.0",
+            "invalid-specifier": false
+        }       
     }
 }
 ```

bin/node-support

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+
+'use strict';
+
+const Fs = require('fs');
+const NodeSupport = require('..');
+const { URL } = require('url');
+
+
+const internals = {};
+
+
+internals.autoDetect = (what) => {
+
+    if (!what) {
+        return NodeSupport.detect({ path: '.' });
+    }
+
+    try {
+        var url = new URL(what);
+    }
+    catch (err) {
+        if (err.code !== 'ERR_INVALID_URL') {
+            throw err;
+        }
+    }
+
+    if (url) {
+        return NodeSupport.detect({ repository: url.href });
+    }
+
+    if (Fs.existsSync(what)) {
+        return NodeSupport.detect({ path: what });
+    }
+
+    if (what.includes('/') && !what.startsWith('@')) {
+        return  NodeSupport.detect({ repository: `https://github.com/${what}` });
+    }
+
+    return NodeSupport.detect({ packageName: what });
+};
+
+exports.main = async (nodeBin, thisBin, what) => {
+
+    const result = await internals.autoDetect(what);
+
+    console.log(result);
+};
+
+exports.main(...process.argv)
+    .catch((err) => {
+
+        console.error(err);
+        process.exit(1);
+    });

lib/engines.js

@@ -0,0 +1,11 @@
+'use strict';
+
+exports.detect = ({ engines }) => {
+
+    if (engines) {
+
+        return {
+            engines: engines.node
+        };
+    }
+};

lib/index.js

@@ -1,6 +1,24 @@
 'use strict';
 
-module.exports = () => {
+const Engines = require('./engines');
+const Package = require('./package');
+const Travis = require('./travis');
 
-    throw new Error('Not implemented');
+exports.detect = async ({ path, repository, packageName }) => {
+
+    const packageInfo = await Package.detect({ path, repository, packageName });
+
+    const result = {};
+
+    result.name = packageInfo.name;
+    result.version = packageInfo.version;
+    result.commit = await packageInfo.getCommit();
+    result.timestamp = Date.now();
+
+    const travis = await Travis.detect(packageInfo);
+    const engines = await Engines.detect(packageInfo);
+
+    Object.assign(result, travis, engines);
+
+    return result;
 };

lib/loader.js

@@ -0,0 +1,156 @@
+'use strict';
+
+const Fs = require('fs');
+const GitUrlParse = require('git-url-parse');
+const Package = require('../package.json');
+const Pacote = require('pacote');
+const Path = require('path');
+const Wreck = require('@hapi/wreck');
+
+const Utils = require('./utils');
+
+const internals = {};
+
+
+internals.parseRepository = (packument) => {
+
+    if (typeof packument.repository === 'string') {
+        return packument.repository;
+    }
+
+    if (!packument.repository || !packument.repository.url) {
+        throw new Error(`Unable to determine the git repository for ${packument.name}`);
+    }
+
+    return packument.repository.url;
+};
+
+
+internals.createPackageLoader = async (packageName) => {
+
+    try {
+        const packument = await Pacote.packument(packageName + '@latest', {
+            'fullMetadata': true,
+            'user-agent': `${Package.name}@${Package.version}, see ${Package.homepage}`
+        });
+
+        const repository = internals.parseRepository(packument);
+
+        const repositoryLoader = internals.createRepositoryLoader(repository);
+
+        return {
+            ...repositoryLoader,
+            loadFile: async (filename, options) => {
+
+                const result = await repositoryLoader.loadFile(filename, options);
+
+                if (filename === 'package.json' && result.name !== packageName) {
+                    throw new Error(`${repository} does not contain ${packageName}`);
+                }
+
+                return result;
+            }
+        };
+    }
+    catch (err) {
+
+        if (err.statusCode === 404) {
+            throw new Error(`Package ${packageName} does not exist`);
+        }
+
+        throw err;
+
+    }
+};
+
+
+internals.createRepositoryLoader = (repository) => {
+
+    const parsedRepository = GitUrlParse(repository);
+
+    return {
+        getCommit: async () => {
+
+            const simpleGit = Utils.simpleGit();
+            const httpRepository = GitUrlParse.stringify(parsedRepository, 'http');
+            const result = await simpleGit.listRemote([httpRepository, 'HEAD']);
+            const [head] = result.split(/\s+/);
+
+            return head;
+        },
+        loadFile: async (filename, options) => {
+
+            if (parsedRepository.source !== 'github.com') {
+                throw new Error('Only github.com paths supported, feel free to PR at https://github.com/pkgjs/node-support');
+            }
+
+            const url = `https://raw.githubusercontent.com/${parsedRepository.full_name}/HEAD/${filename}`;
+
+            try {
+                const { payload } = await Wreck.get(url, options);
+
+                return payload;
+            }
+            catch (err) {
+
+                if (err.output && err.output.statusCode === 404) {
+                    throw new Error(`${repository} does not contain a ${filename}`);
+                }
+
+                throw err;
+            }
+        }
+    };
+};
+
+
+internals.createPathLoader = async (path) => {
+
+    const simpleGit = Utils.simpleGit(path);
+    const isRepo = await simpleGit.checkIsRepo();
+
+    if (!isRepo) {
+        throw new Error(`${path} is not a git repository`);
+    }
+
+    if (!Fs.existsSync(Path.join(path, 'package.json'))) {
+        throw new Error(`${path} does not contain a package.json`);
+    }
+
+    return {
+        getCommit: () => {
+
+            return simpleGit.revparse(['HEAD']);
+        },
+        loadFile: (filename, options = {}) => {
+
+            const fullPath = Path.join(path, filename);
+
+            if (!Fs.existsSync(fullPath)) {
+                return;
+            }
+
+            const buffer = Fs.readFileSync(fullPath);
+
+            if (options.json) {
+                return JSON.parse(buffer.toString());
+            }
+
+            return buffer;
+        }
+    };
+};
+
+
+exports.create = ({ path, repository, packageName }) => {
+
+    if (repository) {
+        return internals.createRepositoryLoader(repository);
+    }
+
+    if (packageName) {
+        return internals.createPackageLoader(packageName);
+    }
+
+    return internals.createPathLoader(path);
+};

lib/package.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const Loader = require('./loader');
+
+
+exports.detect = async ({ path, repository, packageName }) => {
+
+    const { loadFile, getCommit } = await Loader.create({ path, repository, packageName });
+
+    const packageJson = await loadFile('package.json', { json: 'force' });
+
+    const { name, version, engines } = packageJson;
+
+    return {
+        name,
+        version,
+        engines,
+
+        getCommit,
+        loadFile
+    };
+};