opal 0.10.0 → 0.11.0

data/lib/opal/cli_runners/node_modules/chrome-remote-interface/index.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const EventEmitter = require('events');
+
+const devtools = require('./lib/devtools');
+const Chrome = require('./lib/chrome');
+
+module.exports = function (options, callback) {
+    if (typeof options === 'function') {
+        callback = options;
+        options = undefined;
+    }
+    const notifier = new EventEmitter();
+    if (typeof callback === 'function') {
+        // allow to register the error callback later
+        process.nextTick(function () {
+            new Chrome(options, notifier);
+        });
+        return notifier.once('connect', callback);
+    } else {
+        return new Promise(function (fulfill, reject) {
+            notifier.once('connect', fulfill);
+            notifier.once('error', reject);
+            new Chrome(options, notifier);
+        });
+    }
+};
+
+// for backward compatibility
+module.exports.listTabs = devtools.List;
+module.exports.spawnTab = devtools.New;
+module.exports.closeTab = devtools.Close;
+
+module.exports.Protocol = devtools.Protocol;
+module.exports.List = devtools.List;
+module.exports.New = devtools.New;
+module.exports.Activate = devtools.Activate;
+module.exports.Close = devtools.Close;
+module.exports.Version = devtools.Version;

data/lib/opal/cli_runners/node_modules/chrome-remote-interface/lib/api.js

@@ -0,0 +1,84 @@
+'use strict';
+
+function arrayToObject(parameters) {
+    const keyValue = {};
+    parameters.forEach(function (parameter) {
+        const name = parameter.name;
+        delete parameter.name;
+        keyValue[name] = parameter;
+    });
+    return keyValue;
+}
+
+function decorate(to, category, object) {
+    to.category = category;
+    Object.keys(object).forEach(function (field) {
+        // skip the 'name' field as it is part of the function prototype
+        if (field === 'name') {
+            return;
+        }
+        // commands and events have parameters whereas types have properties
+        if (category === 'type' && field === 'properties' ||
+            field === 'parameters') {
+            to[field] = arrayToObject(object[field]);
+        } else {
+            to[field] = object[field];
+        }
+    });
+}
+
+function addCommand(chrome, domainName, command) {
+    const handler = function (params, callback) {
+        return chrome.send(domainName + '.' + command.name, params, callback);
+    };
+    decorate(handler, 'command', command);
+    chrome[domainName][command.name] = handler;
+}
+
+function addEvent(chrome, domainName, event) {
+    const eventName = domainName + '.' + event.name;
+    const handler = function (handler) {
+        if (typeof handler === 'function') {
+            chrome.on(eventName, handler);
+        } else {
+            return new Promise(function (fulfill, reject) {
+                chrome.once(eventName, fulfill);
+            });
+        }
+    };
+    decorate(handler, 'event', event);
+    chrome[domainName][event.name] = handler;
+}
+
+function addType(chrome, domainName, type) {
+    const help = {};
+    decorate(help, 'type', type);
+    chrome[domainName][type.id] = help;
+}
+
+function prepare(protocol) {
+    const chrome = this;
+    return new Promise(function (fulfill, reject) {
+        // assign the protocol and generate the shorthands
+        chrome.protocol = protocol;
+        protocol.domains.forEach(function (domain) {
+            const domainName = domain.domain;
+            chrome[domainName] = {};
+            // add commands
+            (domain.commands || []).forEach(function (command) {
+                addCommand(chrome, domainName, command);
+            });
+            // add events
+            (domain.events || []).forEach(function (event) {
+                addEvent(chrome, domainName, event);
+            });
+            // add types
+            (domain.types || []).forEach(function (type) {
+                addType(chrome, domainName, type);
+            });
+        });
+        fulfill();
+    });
+}
+
+module.exports.prepare = prepare;

data/lib/opal/cli_runners/node_modules/chrome-remote-interface/lib/chrome.js

@@ -0,0 +1,289 @@
+'use strict';
+
+const EventEmitter = require('events');
+const util = require('util');
+
+const WebSocket = require('ws');
+
+const api = require('./api');
+const defaults = require('./defaults');
+const devtools = require('./devtools');
+
+class ProtocolError extends Error {
+    constructor(response) {
+        super(response.message);
+        Object.assign(this, response);
+    }
+}
+
+class Chrome extends EventEmitter {
+    constructor(options, notifier) {
+        super();
+        // options
+        const defaultTarget = function (targets) {
+            // prefer type = 'page' inspectabe targets as they represents
+            // browser tabs (fall back to the first instectable target
+            // otherwise)
+            let backup;
+            let target = targets.find((target) => {
+                if (target.webSocketDebuggerUrl) {
+                    backup = backup || target;
+                    return target.type === 'page';
+                } else {
+                    return false;
+                }
+            });
+            target = target || backup;
+            if (target) {
+                return target;
+            } else {
+                throw new Error('No inspectable targets');
+            }
+        };
+        options = options || {};
+        this.host = options.host || defaults.HOST;
+        this.port = options.port || defaults.PORT;
+        this.secure = !!(options.secure);
+        this.protocol = options.protocol;
+        this.remote = !!(options.remote);
+        this.target = options.target ||
+            /* backward compatibility */ options.tab || options.chooseTab
+            || defaultTarget;
+        // locals
+        EventEmitter.call(this);
+        this._notifier = notifier;
+        this._callbacks = {};
+        this._nextCommandId = 1;
+        // operations
+        start.call(this);
+    }
+}
+
+// avoid misinterpreting protocol's members as custom util.inspect functions
+Chrome.prototype.inspect = function (depth, options) {
+    options.customInspect = false;
+    return util.inspect(this, options);
+};
+
+Chrome.prototype.send = function (method, params, callback) {
+    const chrome = this;
+    if (typeof params === 'function') {
+        callback = params;
+        params = undefined;
+    }
+    // return a promise when a callback is not provided
+    if (typeof callback === 'function') {
+        enqueueCommand.call(chrome, method, params, callback);
+    } else {
+        return new Promise(function (fulfill, reject) {
+            enqueueCommand.call(chrome, method, params, function (error, response) {
+                if (error) {
+                    reject(new ProtocolError(response));
+                } else {
+                    fulfill(response);
+                }
+            });
+        });
+    }
+};
+
+Chrome.prototype.close = function (callback) {
+    const chrome = this;
+    function closeWebSocket(callback) {
+        // don't notify on user-initiated shutdown ('disconnect' event)
+        chrome._ws.removeAllListeners('close');
+        chrome._ws.close();
+        chrome._ws.once('close', function () {
+            chrome._ws.removeAllListeners();
+            callback();
+        });
+    }
+    if (typeof callback === 'function') {
+        closeWebSocket(callback);
+    } else {
+        return new Promise(function (fulfill, reject) {
+            closeWebSocket(fulfill);
+        });
+    }
+};
+
+// send a command to the remote endpoint and register a callback for the reply
+function enqueueCommand(method, params, callback) {
+    const chrome = this;
+    const id = chrome._nextCommandId++;
+    const message = {'id': id, 'method': method, 'params': params || {}};
+    chrome._ws.send(JSON.stringify(message));
+    chrome._callbacks[id] = callback;
+}
+
+// initiate the connection process
+function start() {
+    const chrome = this;
+    const options = {'host': chrome.host, 'port': chrome.port, 'secure': chrome.secure};
+    Promise.all([
+        // fetch the protocol and prepare the API
+        fetchProtocol.call(chrome, options).then(api.prepare.bind(chrome)),
+        // in the meanwhile fetch the WebSocket debugger URL
+        fetchDebuggerURL.call(chrome, options)
+    ]).then(function (values) {
+        // finally connect to the WebSocket
+        const url = values[1];
+        return connectToWebSocket.call(chrome, url);
+    }).then(function () {
+        // since the handler is executed synchronously, the emit() must be
+        // performed in the next tick so that uncaught errors in the client code
+        // are not intercepted by the Promise mechanism and therefore reported
+        // via the 'error' event
+        process.nextTick(function () {
+            chrome._notifier.emit('connect', chrome);
+        });
+    }).catch(function (err) {
+        chrome._notifier.emit('error', err);
+    });
+}
+
+// fetch the protocol according to 'protocol' and 'remote'
+function fetchProtocol(options) {
+    const chrome = this;
+    return new Promise(function (fulfill, reject) {
+        // if a protocol has been provided then use it
+        if (chrome.protocol) {
+            fulfill(chrome.protocol);
+        }
+        // otherwise user either the local or the remote version
+        else {
+            options.remote = chrome.remote;
+            devtools.Protocol(options).then(function (protocol) {
+                fulfill(protocol.descriptor);
+            }).catch(reject);
+        }
+    });
+}
+
+// extract the debugger URL from a target-like object
+function fetchFromObject(fulfill, reject, target) {
+    const url = (target || {}).webSocketDebuggerUrl;
+    if (url) {
+        fulfill(url);
+    } else {
+        const targetStr = JSON.stringify(target, null, 4);
+        const err = new Error('Invalid target ' + targetStr);
+        reject(err);
+    }
+}
+
+// fetch the WebSocket URL according to 'target'
+function fetchDebuggerURL(options) {
+    const chrome = this;
+    return new Promise(function (fulfill, reject) {
+        // note: when DevTools are open or another WebSocket is connected to a
+        // given target the 'webSocketDebuggerUrl' field is not available
+        let userTarget = chrome.target;
+        switch (typeof userTarget) {
+        case 'string':
+            // use default host and port if omitted (and a relative URL is specified)
+            if (userTarget.startsWith('/')) {
+                const prefix = 'ws://' + chrome.host + ':' + chrome.port;
+                userTarget = prefix + userTarget;
+            }
+            // a WebSocket URL is specified by the user (e.g., node-inspector)
+            if (userTarget.match(/^wss?:/i)) {
+                fulfill(userTarget);
+            }
+            // a target id is specified by the user
+            else {
+                devtools.List(options).then(function (targets) {
+                    return targets.find(function (target) {
+                        return target.id === userTarget;
+                    });
+                }).then(function (target) {
+                    fetchFromObject(fulfill, reject, target);
+                }).catch(reject);
+            }
+            break;
+        case 'object':
+            // a target object is specified by the user
+            fetchFromObject(fulfill, reject, userTarget);
+            break;
+        case 'function':
+            // a function is specified by the user
+            devtools.List(options).then(function (targets) {
+                const result = userTarget(targets);
+                if (typeof result === 'number') {
+                    return targets[result];
+                } else {
+                    return result;
+                }
+            }).then(function (target) {
+                fetchFromObject(fulfill, reject, target);
+            }).catch(reject);
+            break;
+        default:
+            reject(new Error('Invalid target argument "' + chrome.target + '"'));
+        }
+    });
+}
+
+// establish the WebSocket connection and start processing user commands
+function connectToWebSocket(url) {
+    const chrome = this;
+    return new Promise(function (fulfill, reject) {
+        // create the WebSocket
+        try {
+            if (chrome.secure) {
+                url = url.replace(/^ws:/i, 'wss:');
+            }
+            chrome._ws = new WebSocket(url);
+        } catch (err) {
+            // handles bad URLs
+            reject(err);
+            return;
+        }
+        // set up event handlers
+        chrome._ws.on('open', function () {
+            fulfill();
+        });
+        chrome._ws.on('message', function (data) {
+            const message = JSON.parse(data);
+            handleMessage.call(chrome, message);
+        });
+        chrome._ws.on('close', function (code) {
+            chrome.emit('disconnect');
+        });
+        chrome._ws.on('error', function (err) {
+            reject(err);
+        });
+    });
+}
+
+// handle the messages read from the WebSocket
+function handleMessage(message) {
+    const chrome = this;
+    // command response
+    if (message.id) {
+        const callback = chrome._callbacks[message.id];
+        if (!callback) {
+            return;
+        }
+        // interpret the lack of both 'error' and 'result' as success
+        // (this may happen with node-inspector)
+        if (message.error) {
+            callback(true, message.error);
+        } else {
+            callback(false, message.result || {});
+        }
+        // unregister command response callback
+        delete chrome._callbacks[message.id];
+        // notify when there are no more pending commands
+        if (Object.keys(chrome._callbacks).length === 0) {
+            chrome.emit('ready');
+        }
+    }
+    // event
+    else if (message.method) {
+        chrome.emit('event', message);
+        chrome.emit(message.method, message.params);
+    }
+}
+
+module.exports = Chrome;

data/lib/opal/cli_runners/node_modules/chrome-remote-interface/lib/defaults.js

@@ -0,0 +1,4 @@
+'use strict';
+
+module.exports.HOST = 'localhost';
+module.exports.PORT = 9222;

data/lib/opal/cli_runners/node_modules/chrome-remote-interface/lib/devtools.js

@@ -0,0 +1,245 @@
+'use strict';
+
+const http = require('http');
+const https = require('https');
+
+const defaults = require('./defaults');
+const externalRequest = require('./external-request');
+
+// callback(err, protocol)
+module.exports.Protocol = promisesWrapper(function (options, callback) {
+    // if the local protocol is requested
+    if (!options.remote) {
+        const localDescriptor = require('./protocol.json');
+        callback(null, {
+            'remote': false,
+            'descriptor': localDescriptor
+        });
+        return;
+    }
+    // try to fecth the browser version information and the protocol (remotely)
+    module.exports.Version(options, function (err, info) {
+        if (err) {
+            callback(err);
+            return;
+        }
+        // fetch the reported browser info (Node.js returns an array)
+        const browser = (info[0] || info).Browser;
+        // use the proper protocol fetcher
+        let fetcher;
+        if (browser.match(/^(Headless)?Chrome\//)) {
+            // https://bugs.chromium.org/p/chromium/issues/detail?id=538300#c10
+            const firstJsonProtocolVersion = '60.0.3097.0';
+            const firstJsonProtocolBuild = explodeChromeVersion(firstJsonProtocolVersion)[2];
+            const chromeBuild = explodeChromeVersion(info.Browser.split('/')[1])[2];
+            if (chromeBuild < firstJsonProtocolBuild) {
+                fetcher = fetchFromChromeRepo;
+            } else {
+                fetcher = fetchFromHttpEndpoint;
+            }
+        } else if (browser.match(/^Microsoft Edge /)) {
+            fetcher = fetchFromHttpEndpoint;
+        } else if (browser.match(/^node.js\//)) {
+            fetcher = fetchFromHttpEndpoint;
+        } else {
+            callback(new Error('Unknown implementation'));
+            return;
+        }
+        fetcher(options, info, function (err, descriptor) {
+            if (err) {
+                callback(err);
+                return;
+            }
+            // use the remotely fetched descriptor
+            callback(null, {
+                'remote': true,
+                'descriptor': descriptor
+            });
+        });
+    });
+});
+
+module.exports.List = promisesWrapper(function (options, callback) {
+    options.path = '/json/list';
+    devToolsInterface(options, function (err, tabs) {
+        if (err) {
+            callback(err);
+        } else {
+            callback(null, JSON.parse(tabs));
+        }
+    });
+});
+
+module.exports.New = promisesWrapper(function (options, callback) {
+    options.path = '/json/new';
+    if (Object.prototype.hasOwnProperty.call(options, 'url')) {
+        options.path += '?' + options.url;
+    }
+    devToolsInterface(options, function (err, tab) {
+        if (err) {
+            callback(err);
+        } else {
+            callback(null, JSON.parse(tab));
+        }
+    });
+});
+
+module.exports.Activate = promisesWrapper(function (options, callback) {
+    options.path = '/json/activate/' + options.id;
+    devToolsInterface(options, function (err) {
+        if (err) {
+            callback(err);
+        } else {
+            callback(null);
+        }
+    });
+});
+
+module.exports.Close = promisesWrapper(function (options, callback) {
+    options.path = '/json/close/' + options.id;
+    devToolsInterface(options, function (err) {
+        if (err) {
+            callback(err);
+        } else {
+            callback(null);
+        }
+    });
+});
+
+module.exports.Version = promisesWrapper(function (options, callback) {
+    options.path = '/json/version';
+    devToolsInterface(options, function (err, versionInfo) {
+        if (err) {
+            callback(err);
+        } else {
+            callback(null, JSON.parse(versionInfo));
+        }
+    });
+});
+
+// options.path must be specified; callback(err, data)
+function devToolsInterface(options, callback) {
+    options.host = options.host || defaults.HOST;
+    options.port = options.port || defaults.PORT;
+    options.secure = !!(options.secure);
+    externalRequest(options.secure ? https : http, options, callback);
+}
+
+// wrapper that allows to return a promise if the callback is omitted, it works
+// for DevTools methods
+function promisesWrapper(func) {
+    return function (options, callback) {
+        // options is an optional argument
+        if (typeof options === 'function') {
+            callback = options;
+            options = undefined;
+        }
+        options = options || {};
+        // just call the function otherwise wrap a promise around its execution
+        if (typeof callback === 'function') {
+            func(options, callback);
+        } else {
+            return new Promise(function (fulfill, reject) {
+                func(options, function (err, result) {
+                    if (err) {
+                        reject(err);
+                    } else {
+                        fulfill(result);
+                    }
+                });
+            });
+        }
+    };
+}
+
+function explodeChromeVersion(v) {
+    return v.split('.').map(function (x) {
+        return parseInt(x);
+    });
+}
+
+// callback(err, descriptor)
+// XXX this function needs a proper refactor but the inconsistency of the
+// fetching process makes it useless for now
+function fetchFromChromeRepo(options, info, callback) {
+    // attempt to fetch the protocol directly from the Chromium repository
+    // according to the current version
+    //
+    // Thanks to Paul Irish.
+    // (see https://github.com/cyrus-and/chrome-remote-interface/issues/10#issuecomment-146032907)
+    const webKitVersion = info['WebKit-Version'];
+    const v8Version = info['V8-Version'];
+    const match = webKitVersion.match(/\s\(@(\b[0-9a-f]{5,40}\b)/);
+    const hash = match[1];
+    const fromChromiumDotOrg = (hash <= 202666);
+    let urls;
+    if (fromChromiumDotOrg) {
+        urls = [`https://src.chromium.org/blink/trunk/Source/devtools/protocol.json?p=${hash}`];
+    } else {
+        const lastBeforeSplitChromeVersion = '53.0.2758.1'; // before the split (https://crbug.com/580337)
+        const lastBeforeV8ChromeVersion = '55.0.2854.3'; // before using the JSON from the V8 repo
+        const chromeVersion = explodeChromeVersion(info.Browser.split('/')[1]);
+        // according to https://www.chromium.org/developers/version-numbers (patch not meaningful)
+        const beforeSplit = (chromeVersion[2] <= explodeChromeVersion(lastBeforeSplitChromeVersion)[2]);
+        const beforeFromV8 = (chromeVersion[2] <= explodeChromeVersion(lastBeforeV8ChromeVersion)[2]);
+        if (beforeSplit) {
+            urls = [`https://chromium.googlesource.com/chromium/src/+/${hash}/third_party/WebKit/Source/devtools/protocol.json?format=TEXT`];
+        } else if (beforeFromV8) {
+            urls = [`https://chromium.googlesource.com/chromium/src/+/${hash}/third_party/WebKit/Source/core/inspector/browser_protocol.json?format=TEXT`,
+                    `https://chromium.googlesource.com/chromium/src/+/${hash}/third_party/WebKit/Source/platform/v8_inspector/js_protocol.json?format=TEXT`];
+        } else if (v8Version) {
+            urls = [`https://chromium.googlesource.com/chromium/src/+/${hash}/third_party/WebKit/Source/core/inspector/browser_protocol.json?format=TEXT`,
+                    `https://chromium.googlesource.com/v8/v8/+/${v8Version}/src/inspector/js_protocol.json?format=TEXT`];
+        } else {
+            console.error('Warning: the protocol might be outdated, see: https://groups.google.com/d/topic/chrome-debugging-protocol/HjyOKainKus/discussion');
+            // releases which do not provide a V8 version get an old version of the V8 protocol
+            urls = [`https://chromium.googlesource.com/chromium/src/+/${hash}/third_party/WebKit/Source/core/inspector/browser_protocol.json?format=TEXT`,
+                    `https://chromium.googlesource.com/chromium/src/+/${lastBeforeV8ChromeVersion}/third_party/WebKit/Source/platform/v8_inspector/js_protocol.json?format=TEXT`];
+        }
+    }
+    const descriptors = [];
+    urls.forEach(function (url) {
+        externalRequest(https, url, function (err, data) {
+            let descriptor;
+            if (!err) {
+                try {
+                    // the file is served base64 encoded from googlesource.com
+                    if (!fromChromiumDotOrg) {
+                        data = new Buffer(data, 'base64').toString();
+                    }
+                    descriptor = JSON.parse(data);
+                } catch (_) {
+                    // abort later
+                }
+            }
+            descriptors.push(descriptor);
+            if (descriptors.length === urls.length) {
+                // all must be defined
+                if (descriptors.indexOf(undefined) !== -1) {
+                    callback(new Error('Cannot fetch from Chromium repo'));
+                    return;
+                }
+                // merge the domains
+                descriptors.forEach(function (descriptor, i) {
+                    if (i === 0) {
+                        return;
+                    }
+                    Array.prototype.push.apply(descriptors[0].domains, descriptor.domains);
+                });
+                callback(null, descriptors[0]);
+            }
+        });
+    });
+}
+
+// callback(err, descriptor)
+function fetchFromHttpEndpoint(options, info, callback) {
+    options.path = '/json/protocol';
+    devToolsInterface(options, function (err, descriptor) {
+        if (err) {
+            callback(err);
+        } else {
+            callback(null, JSON.parse(descriptor));
+        }
+    });
+}

data/lib/opal/cli_runners/node_modules/chrome-remote-interface/lib/external-request.js

@@ -0,0 +1,23 @@
+'use strict';
+
+// callback(err, data)
+function externalRequest(transport, options, callback) {
+    const request = transport.get(options, function (response) {
+        let data = '';
+        response.on('data', function (chunk) {
+            data += chunk;
+        });
+        response.on('end', function () {
+            if (response.statusCode === 200) {
+                callback(null, data);
+            } else {
+                callback(new Error(data));
+            }
+        });
+    });
+    request.on('error', function (err) {
+        callback(err);
+    });
+}
+
+module.exports = externalRequest;