opal 1.6.1 → 1.7.0.rc1

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

@@ -2,17 +2,25 @@
 
 const EventEmitter = require('events');
 const util = require('util');
+const formatUrl = require('url').format;
+const parseUrl = require('url').parse;
 
 const WebSocket = require('ws');
 
-const api = require('./api');
-const defaults = require('./defaults');
-const devtools = require('./devtools');
+const api = require('./api.js');
+const defaults = require('./defaults.js');
+const devtools = require('./devtools.js');
 
 class ProtocolError extends Error {
-    constructor(response) {
-        super(response.message);
-        Object.assign(this, response);
+    constructor(request, response) {
+        let {message} = response;
+        if (response.data) {
+            message += ` (${response.data})`;
+        }
+        super(message);
+        // attach the original response as well
+        this.request = request;
+        this.response = response;
     }
 }
 
@@ -20,9 +28,9 @@ 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
+        const defaultTarget = (targets) => {
+            // prefer type = 'page' inspectable targets as they represents
+            // browser tabs (fall back to the first inspectable target
             // otherwise)
             let backup;
             let target = targets.find((target) => {
@@ -44,245 +52,247 @@ class Chrome extends EventEmitter {
         this.host = options.host || defaults.HOST;
         this.port = options.port || defaults.PORT;
         this.secure = !!(options.secure);
+        this.useHostName = !!(options.useHostName);
+        this.alterPath = options.alterPath || ((path) => path);
         this.protocol = options.protocol;
-        this.remote = !!(options.remote);
-        this.target = options.target ||
-            /* backward compatibility */ options.tab || options.chooseTab
-            || defaultTarget;
+        this.local = !!(options.local);
+        this.target = options.target || defaultTarget;
         // locals
-        EventEmitter.call(this);
         this._notifier = notifier;
         this._callbacks = {};
         this._nextCommandId = 1;
+        // properties
+        this.webSocketUrl = undefined;
         // operations
-        start.call(this);
+        this._start();
     }
-}
-
-// 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;
+    // avoid misinterpreting protocol's members as custom util.inspect functions
+    inspect(depth, options) {
+        options.customInspect = false;
+        return util.inspect(this, options);
     }
-    // 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);
-                }
+
+    send(method, params, sessionId, callback) {
+        // handle optional arguments
+        const optionals = Array.from(arguments).slice(1);
+        params = optionals.find(x => typeof x === 'object');
+        sessionId = optionals.find(x => typeof x === 'string');
+        callback = optionals.find(x => typeof x === 'function');
+        // return a promise when a callback is not provided
+        if (typeof callback === 'function') {
+            this._enqueueCommand(method, params, sessionId, callback);
+            return undefined;
+        } else {
+            return new Promise((fulfill, reject) => {
+                this._enqueueCommand(method, params, sessionId, (error, response) => {
+                    if (error) {
+                        const request = {method, params, sessionId};
+                        reject(
+                            error instanceof Error
+                                ? error // low-level WebSocket error
+                                : new ProtocolError(request, 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);
-        });
+    close(callback) {
+        const closeWebSocket = (callback) => {
+            // don't close if it's already closed
+            if (this._ws.readyState === 3) {
+                callback();
+            } else {
+                // don't notify on user-initiated shutdown ('disconnect' event)
+                this._ws.removeAllListeners('close');
+                this._ws.once('close', () => {
+                    this._ws.removeAllListeners();
+                    callback();
+                });
+                this._ws.close();
+            }
+        };
+        if (typeof callback === 'function') {
+            closeWebSocket(callback);
+            return undefined;
+        } else {
+            return new Promise((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);
+    // initiate the connection process
+    async _start() {
+        const options = {
+            host: this.host,
+            port: this.port,
+            secure: this.secure,
+            useHostName: this.useHostName,
+            alterPath: this.alterPath
+        };
+        try {
+            // fetch the WebSocket debugger URL
+            const url = await this._fetchDebuggerURL(options);
+            // allow the user to alter the URL
+            const urlObject = parseUrl(url);
+            urlObject.pathname = options.alterPath(urlObject.pathname);
+            this.webSocketUrl = formatUrl(urlObject);
+            // update the connection parameters using the debugging URL
+            options.host = urlObject.hostname;
+            options.port = urlObject.port || options.port;
+            // fetch the protocol and prepare the API
+            const protocol = await this._fetchProtocol(options);
+            api.prepare(this, protocol);
+            // finally connect to the WebSocket
+            await this._connectToWebSocket();
+            // 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(() => {
+                this._notifier.emit('connect', this);
+            });
+        } catch (err) {
+            this._notifier.emit('error', err);
         }
-    });
-}
-
-// 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;
+    // fetch the WebSocket URL according to 'target'
+    async _fetchDebuggerURL(options) {
+        const userTarget = this.target;
         switch (typeof userTarget) {
-        case 'string':
+        case 'string': {
+            let idOrUrl = userTarget;
             // 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;
+            if (idOrUrl.startsWith('/')) {
+                idOrUrl = `ws://${this.host}:${this.port}${idOrUrl}`;
             }
             // a WebSocket URL is specified by the user (e.g., node-inspector)
-            if (userTarget.match(/^wss?:/i)) {
-                fulfill(userTarget);
+            if (idOrUrl.match(/^wss?:/i)) {
+                return idOrUrl; // done!
             }
             // 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);
+                const targets = await devtools.List(options);
+                const object = targets.find((target) => target.id === idOrUrl);
+                return object.webSocketDebuggerUrl;
             }
-            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;
+        }
+        case 'object': {
+            const object = userTarget;
+            return object.webSocketDebuggerUrl;
+        }
+        case 'function': {
+            const func = userTarget;
+            const targets = await devtools.List(options);
+            const result = func(targets);
+            const object = typeof result === 'number' ? targets[result] : result;
+            return object.webSocketDebuggerUrl;
+        }
         default:
-            reject(new Error('Invalid target argument "' + chrome.target + '"'));
+            throw new Error(`Invalid target argument "${this.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;
+    // fetch the protocol according to 'protocol' and 'local'
+    async _fetchProtocol(options) {
+        // if a protocol has been provided then use it
+        if (this.protocol) {
+            return this.protocol;
         }
-        // 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);
+        // otherwise user either the local or the remote version
+        else {
+            options.local = this.local;
+            return await devtools.Protocol(options);
+        }
+    }
+
+    // establish the WebSocket connection and start processing user commands
+    _connectToWebSocket() {
+        return new Promise((fulfill, reject) => {
+            // create the WebSocket
+            try {
+                if (this.secure) {
+                    this.webSocketUrl = this.webSocketUrl.replace(/^ws:/i, 'wss:');
+                }
+                this._ws = new WebSocket(this.webSocketUrl);
+            } catch (err) {
+                // handles bad URLs
+                reject(err);
+                return;
+            }
+            // set up event handlers
+            this._ws.on('open', () => {
+                fulfill();
+            });
+            this._ws.on('message', (data) => {
+                const message = JSON.parse(data);
+                this._handleMessage(message);
+            });
+            this._ws.on('close', (code) => {
+                this.emit('disconnect');
+            });
+            this._ws.on('error', (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 || {});
+    // handle the messages read from the WebSocket
+    _handleMessage(message) {
+        // command response
+        if (message.id) {
+            const callback = this._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 this._callbacks[message.id];
+            // notify when there are no more pending commands
+            if (Object.keys(this._callbacks).length === 0) {
+                this.emit('ready');
+            }
         }
-        // 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) {
+            const {method, params, sessionId} = message;
+            this.emit('event', message);
+            this.emit(method, params, sessionId);
+            this.emit(`${method}.${sessionId}`, params, sessionId);
         }
     }
-    // event
-    else if (message.method) {
-        chrome.emit('event', message);
-        chrome.emit(message.method, message.params);
+
+    // send a command to the remote endpoint and register a callback for the reply
+    _enqueueCommand(method, params, sessionId, callback) {
+        const id = this._nextCommandId++;
+        const message = {
+            id,
+            method,
+            sessionId,
+            params: params || {}
+        };
+        this._ws.send(JSON.stringify(message), (err) => {
+            if (err) {
+                // handle low-level WebSocket errors
+                if (typeof callback === 'function') {
+                    callback(err);
+                }
+            } else {
+                this._callbacks[id] = callback;
+            }
+        });
     }
 }