mirror of https://github.com/embarklabs/embark.git
343 lines
8.5 KiB
JavaScript
343 lines
8.5 KiB
JavaScript
let http = require('follow-redirects').http;
|
|
let https = require('follow-redirects').https;
|
|
|
|
function joinPath() {
|
|
const path = require('path');
|
|
return path.join.apply(path.join, arguments);
|
|
}
|
|
|
|
function dirname() {
|
|
const path = require('path');
|
|
return path.dirname.apply(path.dirname, arguments);
|
|
}
|
|
|
|
function filesMatchingPattern(files) {
|
|
const globule = require('globule');
|
|
return globule.find(files, {nonull: true});
|
|
}
|
|
|
|
function fileMatchesPattern(patterns, intendedPath) {
|
|
const globule = require('globule');
|
|
return globule.isMatch(patterns, intendedPath);
|
|
}
|
|
|
|
function recursiveMerge(target, source) {
|
|
const merge = require('merge');
|
|
return merge.recursive(target, source);
|
|
}
|
|
|
|
function checkIsAvailable(url, callback) {
|
|
http.get(url, function (_res) {
|
|
callback(true);
|
|
}).on('error', function (_res) {
|
|
callback(false);
|
|
});
|
|
}
|
|
|
|
function httpGetRequest(httpObj, url, callback) {
|
|
httpObj.get(url, function(res) {
|
|
let body = '';
|
|
res.on('data', function (d) {
|
|
body += d;
|
|
});
|
|
res.on('end', function () {
|
|
callback(null, body);
|
|
});
|
|
}).on('error', function (err) {
|
|
callback(err);
|
|
});
|
|
}
|
|
|
|
function httpGet(url, callback) {
|
|
httpGetRequest(http, url, callback);
|
|
}
|
|
|
|
function httpsGet(url, callback) {
|
|
httpGetRequest(https, url, callback);
|
|
}
|
|
|
|
function httpGetJson(url, callback) {
|
|
httpGetRequest(http, url, function(err, body) {
|
|
try {
|
|
let parsed = JSON.parse(body);
|
|
return callback(err, parsed);
|
|
} catch(e) {
|
|
return callback(e);
|
|
}
|
|
});
|
|
}
|
|
|
|
function httpsGetJson(url, callback) {
|
|
httpGetRequest(https, url, function(err, body) {
|
|
try {
|
|
let parsed = JSON.parse(body);
|
|
return callback(err, parsed);
|
|
} catch(e) {
|
|
return callback(e);
|
|
}
|
|
});
|
|
}
|
|
|
|
function pingEndpoint(host, port, type, protocol, origin, callback) {
|
|
const options = {
|
|
protocolVersion: 13,
|
|
perMessageDeflate: true,
|
|
origin: origin,
|
|
host: host,
|
|
port: port
|
|
};
|
|
if (type === 'ws') {
|
|
options.headers = {
|
|
'Sec-WebSocket-Version': 13,
|
|
Connection: 'Upgrade',
|
|
Upgrade: 'websocket',
|
|
'Sec-WebSocket-Extensions': 'permessage-deflate; client_max_window_bits',
|
|
Origin: origin
|
|
};
|
|
}
|
|
let req;
|
|
// remove trailing api key from infura, ie rinkeby.infura.io/nmY8WtT4QfEwz2S7wTbl
|
|
if (options.host.indexOf('/') > -1){
|
|
options.host = options.host.split('/')[0];
|
|
}
|
|
if (protocol === 'https') {
|
|
req = require('https').get(options);
|
|
} else {
|
|
req = require('http').get(options);
|
|
}
|
|
|
|
req.on('error', (err) => {
|
|
callback(err);
|
|
});
|
|
|
|
req.on('response', (_response) => {
|
|
callback();
|
|
});
|
|
|
|
req.on('upgrade', (_res, _socket, _head) => {
|
|
callback();
|
|
});
|
|
}
|
|
|
|
function runCmd(cmd, options) {
|
|
const shelljs = require('shelljs');
|
|
let result = shelljs.exec(cmd, options || {silent: true});
|
|
if (result.code !== 0) {
|
|
console.log("error doing.. " + cmd);
|
|
console.log(result.output);
|
|
if (result.stderr !== undefined) {
|
|
console.log(result.stderr);
|
|
}
|
|
exit();
|
|
}
|
|
}
|
|
|
|
function cd(folder) {
|
|
const shelljs = require('shelljs');
|
|
shelljs.cd(folder);
|
|
}
|
|
|
|
function sed(file, pattern, replace) {
|
|
const shelljs = require('shelljs');
|
|
shelljs.sed('-i', pattern, replace, file);
|
|
}
|
|
|
|
function exit(code) {
|
|
process.exit(code);
|
|
}
|
|
|
|
function downloadFile(url, dest, cb) {
|
|
const o_fs = require('fs-extra');
|
|
var file = o_fs.createWriteStream(dest);
|
|
(url.substring(0,5) === 'https' ? https : http).get(url, function(response) {
|
|
response.pipe(file);
|
|
file.on('finish', function() {
|
|
file.close(cb);
|
|
});
|
|
}).on('error', function(err) {
|
|
o_fs.unlink(dest);
|
|
if (cb) cb(err.message);
|
|
});
|
|
}
|
|
|
|
function extractTar(filename, packageDirectory, cb) {
|
|
const o_fs = require('fs-extra');
|
|
const tar = require('tar');
|
|
o_fs.createReadStream(filename).pipe(
|
|
tar.x({
|
|
strip: 1,
|
|
C: packageDirectory
|
|
}).on('end', function() {
|
|
cb();
|
|
})
|
|
);
|
|
}
|
|
|
|
function extractZip(filename, packageDirectory, cb) {
|
|
const decompress = require('decompress');
|
|
|
|
decompress(filename, packageDirectory).then((_files) => {
|
|
cb();
|
|
});
|
|
}
|
|
|
|
function proposeAlternative(word, _dictionary, _exceptions) {
|
|
const propose = require('propose');
|
|
let exceptions = _exceptions || [];
|
|
let dictionary = _dictionary.filter((entry) => {
|
|
return exceptions.indexOf(entry) < 0;
|
|
});
|
|
return propose(word, dictionary, {threshold: 0.3});
|
|
}
|
|
|
|
function pwd() {
|
|
return process.env.PWD || process.cwd();
|
|
}
|
|
|
|
function getExternalContractUrl(file) {
|
|
const constants = require('../constants');
|
|
let url;
|
|
const RAW_URL = 'https://raw.githubusercontent.com/';
|
|
const MALFORMED_ERROR = 'Malformed Github URL for ';
|
|
if (file.startsWith('https://github')) {
|
|
const match = file.match(/https:\/\/github\.[a-z]+\/(.*)/);
|
|
if (!match) {
|
|
console.error(MALFORMED_ERROR + file);
|
|
return null;
|
|
}
|
|
url = `${RAW_URL}${match[1].replace('blob/', '')}`;
|
|
} else if (file.startsWith('git')) {
|
|
// Match values
|
|
// [0] entire input
|
|
// [1] git://
|
|
// [2] user
|
|
// [3] repository
|
|
// [4] path
|
|
// [5] branch
|
|
const match = file.match(
|
|
/(git:\/\/)?github\.[a-z]+\/([-a-zA-Z0-9@:%_+.~#?&=]+)\/([-a-zA-Z0-9@:%_+.~#?&=]+)\/([-a-zA-Z0-9@:%_+.~?\/&=]+)#?([a-zA-Z0-9\/_.-]*)?/
|
|
);
|
|
if (!match) {
|
|
console.error(MALFORMED_ERROR + file);
|
|
return null;
|
|
}
|
|
let branch = match[5];
|
|
if (!branch) {
|
|
branch = 'master';
|
|
}
|
|
url = `${RAW_URL}${match[2]}/${match[3]}/${branch}/${match[4]}`;
|
|
} else if (file.startsWith('http')) {
|
|
url = file;
|
|
} else {
|
|
return null;
|
|
}
|
|
const match = url.match(
|
|
/\.[a-z]+\/([-a-zA-Z0-9@:%_+.~#?&\/=]+)/
|
|
);
|
|
return {
|
|
url,
|
|
filePath: constants.httpContractsDirectory + match[1]
|
|
};
|
|
}
|
|
|
|
function hexToNumber(hex){
|
|
const Web3 = require('web3');
|
|
return Web3.utils.hexToNumber(hex);
|
|
}
|
|
|
|
function decodeParams(typesArray, hexString){
|
|
var Web3EthAbi = require('web3-eth-abi');
|
|
return Web3EthAbi.decodeParameters(typesArray, hexString);
|
|
}
|
|
|
|
function toChecksumAddress(address) {
|
|
const Web3 = require('web3');
|
|
return Web3.utils.toChecksumAddress(address);
|
|
}
|
|
|
|
function sha3(arg) {
|
|
const Web3 = require('web3');
|
|
return Web3.utils.sha3(arg);
|
|
}
|
|
|
|
function normalizeInput(input) {
|
|
let args = Object.values(input);
|
|
if (args.length === 0) {
|
|
return "";
|
|
}
|
|
if (args.length === 1) {
|
|
if (Array.isArray(args[0])) { return args[0].join(','); }
|
|
return args[0] || "";
|
|
}
|
|
return ('[' + args.map((x) => {
|
|
if (x === null) { return "null"; }
|
|
if (x === undefined) { return "undefined"; }
|
|
if (Array.isArray(x)) { return x.join(','); }
|
|
return x;
|
|
}).toString() + ']');
|
|
}
|
|
|
|
/**
|
|
* Builds a URL
|
|
*
|
|
* @param {string} protocol
|
|
* The URL protocol, defaults to http.
|
|
* @param {string} host
|
|
* The URL host, required.
|
|
* @param {string} port
|
|
* The URL port, default to empty string.
|
|
* @returns {string} the constructued URL, with defaults
|
|
*/
|
|
function buildUrl (protocol, host, port){
|
|
if(!host) throw new Error('utils.buildUrl: parameter \'host\' is required');
|
|
if(port) port = ':' + port;
|
|
else port = '';
|
|
return `${protocol || 'http'}://${host}${port}`;
|
|
}
|
|
|
|
/**
|
|
* Builds a URL
|
|
*
|
|
* @param {object} configObj Object containing protocol, host, and port to be used to construct the url.
|
|
* * protocol {String} (optional) The URL protocol, defaults to http.
|
|
* * host {String} (required) The URL host.
|
|
* * port {String} (optional) The URL port, default to empty string.
|
|
* @returns {string} the constructued URL, with defaults
|
|
*/
|
|
function buildUrlFromConfig (configObj){
|
|
if(!configObj) throw new Error('[utils.buildUrlFromConfig]: config object must cannot be null');
|
|
if(!configObj.host) throw new Error('[utils.buildUrlFromConfig]: object must contain a \'host\' property');
|
|
return this.buildUrl(configObj.protocol, configObj.host, configObj.port);
|
|
}
|
|
|
|
module.exports = {
|
|
joinPath: joinPath,
|
|
dirname: dirname,
|
|
filesMatchingPattern: filesMatchingPattern,
|
|
fileMatchesPattern: fileMatchesPattern,
|
|
recursiveMerge: recursiveMerge,
|
|
checkIsAvailable: checkIsAvailable,
|
|
httpGet: httpGet,
|
|
httpsGet: httpsGet,
|
|
httpGetJson: httpGetJson,
|
|
httpsGetJson: httpsGetJson,
|
|
hexToNumber: hexToNumber,
|
|
pingEndpoint,
|
|
decodeParams: decodeParams,
|
|
runCmd: runCmd,
|
|
cd: cd,
|
|
sed: sed,
|
|
exit: exit,
|
|
downloadFile: downloadFile,
|
|
extractTar: extractTar,
|
|
extractZip: extractZip,
|
|
proposeAlternative: proposeAlternative,
|
|
pwd: pwd,
|
|
getExternalContractUrl,
|
|
toChecksumAddress: toChecksumAddress,
|
|
sha3: sha3,
|
|
normalizeInput,
|
|
buildUrl,
|
|
buildUrlFromConfig
|
|
};
|