opal 1.6.1 → 1.7.0

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

@@ -10,11 +10,12 @@ const path = require('path');
 const program = require('commander');
 
 const CDP = require('../');
+const packageInfo = require('../package.json');
 
 function display(object) {
     return util.inspect(object, {
-        'colors': process.stdout.isTTY,
-        'depth': null
+        colors: process.stdout.isTTY,
+        depth: null
     });
 }
 
@@ -22,16 +23,10 @@ function toJSON(object) {
     return JSON.stringify(object, null, 4);
 }
 
-function inheritProperties(from, to) {
-    Object.keys(from).forEach(function (property) {
-        to[property] = from[property];
-    });
-}
-
 ///
 
 function inspect(target, args, options) {
-    options.remote = args.remote;
+    options.local = args.local;
     // otherwise the active target
     if (target) {
         if (args.webSocket) {
@@ -39,9 +34,9 @@ function inspect(target, args, options) {
             options.target = target;
         } else {
             // by target id
-            options.target = function (targets) {
-                return targets.findIndex(function (target) {
-                    return target.id === target;
+            options.target = (targets) => {
+                return targets.findIndex((_target) => {
+                    return _target.id === target;
                 });
             };
         }
@@ -51,21 +46,40 @@ function inspect(target, args, options) {
         options.protocol = JSON.parse(fs.readFileSync(args.protocol));
     }
 
-    CDP(options, function (client) {
-        // keep track of registered events
-        const registeredEvents = {};
-
+    CDP(options, (client) => {
         const cdpRepl = repl.start({
-            'prompt': '\x1b[32m>>>\x1b[0m ',
-            'ignoreUndefined': true,
-            'writer': display
+            prompt: process.stdin.isTTY ? '\x1b[32m>>>\x1b[0m ' : '',
+            ignoreUndefined: true,
+            writer: display
         });
 
+        // XXX always await promises on the REPL
+        const defaultEval = cdpRepl.eval;
+        cdpRepl.eval = (cmd, context, filename, callback) => {
+            defaultEval(cmd, context, filename, async (err, result) => {
+                if (err) {
+                    // propagate errors from the eval
+                    callback(err);
+                } else {
+                    // awaits the promise and either return result or error
+                    try {
+                        callback(null, await Promise.resolve(result));
+                    } catch (err) {
+                        callback(err);
+                    }
+                }
+            });
+        };
+
         const homePath = process.env.HOME || process.env.USERPROFILE;
         const historyFile = path.join(homePath, '.cri_history');
         const historySize = 10000;
 
         function loadHistory() {
+            // only if run from a terminal
+            if (!process.stdin.isTTY) {
+                return;
+            }
             // attempt to open the history file
             let fd;
             try {
@@ -76,117 +90,81 @@ function inspect(target, args, options) {
             // populate the REPL history
             fs.readFileSync(fd, 'utf8')
                 .split('\n')
-                .filter(function (entry) {
+                .filter((entry) => {
                     return entry.trim();
                 })
                 .reverse() // to be compatible with repl.history files
-                .forEach(function (entry) {
+                .forEach((entry) => {
                     cdpRepl.history.push(entry);
                 });
         }
 
         function saveHistory() {
+            // only if run from a terminal
+            if (!process.stdin.isTTY) {
+                return;
+            }
             // only store the last chunk
             const entries = cdpRepl.history.slice(0, historySize).reverse().join('\n');
             fs.writeFileSync(historyFile, entries + '\n');
         }
 
-        function overridePrompt(string) {
-            // hack to get rid of the prompt (clean line and reposition cursor)
-            console.log('\x1b[2K\x1b[G%s', string);
-            cdpRepl.displayPrompt(true);
-        }
-
-        function overrideCommand(command) {
-            // hard code a callback to display the result
-            const override = function (params) {
-                command(params, function (error, response) {
-                    const repr = {};
-                    repr[error ? 'error' : 'result'] = response;
-                    overridePrompt(display(repr));
-                });
-            };
-            // inherit the doc decorations
-            inheritProperties(command, override);
-            return override;
-        }
+        // utility custom command
+        cdpRepl.defineCommand('target', {
+            help: 'Display the current target',
+            action: () => {
+                console.log(client.webSocketUrl);
+                cdpRepl.displayPrompt();
+            }
+        });
 
-        function overrideEvent(client, domainName, itemName) {
-            const event = client[domainName][itemName];
-            const eventName = domainName + '.' + itemName;
-            // hard code a callback to display the event data
-            const override = function (filter) {
-                // remove all the listeners (just one actually) anyway
-                client.removeAllListeners(eventName);
-                const status = {};
-                // a filter will always enable/update the listener
-                if (!filter && registeredEvents[eventName]) {
-                    delete registeredEvents[eventName];
-                    status[eventName] = false;
-                } else {
-                    // use the filter (or true) as a status token
-                    const statusToken = (filter ? filter.toString() : true);
-                    status[eventName] = registeredEvents[eventName] = statusToken;
-                    event(function (params) {
-                        const repr = {};
-                        if (filter) {
-                            params = filter(params);
-                        }
-                        repr[eventName] = params;
-                        overridePrompt(display(repr));
-                    });
-                }
-                // show the registration status to the user
-                return status;
-            };
-            // inherit the doc decorations
-            inheritProperties(event, override);
-            return override;
-        }
+        // utility to purge all the event handlers
+        cdpRepl.defineCommand('reset', {
+            help: 'Remove all the registered event handlers',
+            action: () => {
+                client.removeAllListeners();
+                cdpRepl.displayPrompt();
+            }
+        });
 
         // enable history
         loadHistory();
 
         // disconnect on exit
-        cdpRepl.on('exit', function () {
-            console.log();
+        cdpRepl.on('exit', () => {
+            if (process.stdin.isTTY) {
+                console.log();
+            }
             client.close();
             saveHistory();
         });
 
         // exit on disconnection
-        client.on('disconnect', function () {
+        client.on('disconnect', () => {
             console.error('Disconnected.');
             saveHistory();
             process.exit(1);
         });
 
         // add protocol API
-        client.protocol.domains.forEach(function (domainObject) {
+        for (const domainObject of client.protocol.domains) {
             // walk the domain names
             const domainName = domainObject.domain;
             cdpRepl.context[domainName] = {};
-            Object.keys(client[domainName]).forEach(function (itemName) {
-                // walk the items in the domain and override commands and events
-                let item = client[domainName][itemName];
-                switch (item.category) {
-                case 'command':
-                    item = overrideCommand(item);
-                    break;
-                case 'event':
-                    item = overrideEvent(client, domainName, itemName);
-                    break;
-                }
-                cdpRepl.context[domainName][itemName] = item;
-            });
-        });
-    }).on('error', function (err) {
+            // walk the items in the domain
+            for (const itemName in client[domainName]) {
+                // add CDP object to the REPL context
+                const cdpObject = client[domainName][itemName];
+                cdpRepl.context[domainName][itemName] = cdpObject;
+            }
+        }
+    }).on('error', (err) => {
         console.error('Cannot connect to remote endpoint:', err.toString());
     });
 }
 
 function list(options) {
-    CDP.List(options, function (err, targets) {
+    CDP.List(options, (err, targets) => {
         if (err) {
             console.error(err.toString());
             process.exit(1);
@@ -197,7 +175,7 @@ function list(options) {
 
 function _new(url, options) {
     options.url = url;
-    CDP.New(options, function (err, target) {
+    CDP.New(options, (err, target) => {
         if (err) {
             console.error(err.toString());
             process.exit(1);
@@ -208,7 +186,7 @@ function _new(url, options) {
 
 function activate(args, options) {
     options.id = args;
-    CDP.Activate(options, function (err) {
+    CDP.Activate(options, (err) => {
         if (err) {
             console.error(err.toString());
             process.exit(1);
@@ -218,7 +196,7 @@ function activate(args, options) {
 
 function close(args, options) {
     options.id = args;
-    CDP.Close(options, function (err) {
+    CDP.Close(options, (err) => {
         if (err) {
             console.error(err.toString());
             process.exit(1);
@@ -227,7 +205,7 @@ function close(args, options) {
 }
 
 function version(options) {
-    CDP.Version(options, function (err, info) {
+    CDP.Version(options, (err, info) => {
         if (err) {
             console.error(err.toString());
             process.exit(1);
@@ -237,8 +215,8 @@ function version(options) {
 }
 
 function protocol(args, options) {
-    options.remote = args.remote;
-    CDP.Protocol(options, function (err, protocol) {
+    options.local = args.local;
+    CDP.Protocol(options, (err, protocol) => {
         if (err) {
             console.error(err.toString());
             process.exit(1);
@@ -252,60 +230,62 @@ function protocol(args, options) {
 let action;
 
 program
+    .option('-v, --v', 'Show this module version')
     .option('-t, --host <host>', 'HTTP frontend host')
     .option('-p, --port <port>', 'HTTP frontend port')
-    .option('-s, --secure', 'HTTPS/WSS frontend');
+    .option('-s, --secure', 'HTTPS/WSS frontend')
+    .option('-n, --use-host-name', 'Do not perform a DNS lookup of the host');
 
 program
     .command('inspect [<target>]')
     .description('inspect a target (defaults to the first available target)')
     .option('-w, --web-socket', 'interpret <target> as a WebSocket URL instead of a target id')
-    .option('-j, --protocol <file.json>', 'Chrome Debugging Protocol descriptor (overrides `--remote`)')
-    .option('-r, --remote', 'Attempt to fetch the protocol descriptor remotely')
-    .action(function (target, args) {
+    .option('-j, --protocol <file.json>', 'Chrome Debugging Protocol descriptor (overrides `--local`)')
+    .option('-l, --local', 'Use the local protocol descriptor')
+    .action((target, args) => {
         action = inspect.bind(null, target, args);
     });
 
 program
     .command('list')
     .description('list all the available targets/tabs')
-    .action(function () {
+    .action(() => {
         action = list;
     });
 
 program
     .command('new [<url>]')
     .description('create a new target/tab')
-    .action(function (url) {
+    .action((url) => {
         action = _new.bind(null, url);
     });
 
 program
     .command('activate <id>')
     .description('activate a target/tab by id')
-    .action(function (id) {
+    .action((id) => {
         action = activate.bind(null, id);
     });
 
 program
     .command('close <id>')
     .description('close a target/tab by id')
-    .action(function (id) {
+    .action((id) => {
         action = close.bind(null, id);
     });
 
 program
     .command('version')
     .description('show the browser version')
-    .action(function () {
+    .action(() => {
         action = version;
     });
 
 program
     .command('protocol')
     .description('show the currently available protocol descriptor')
-    .option('-r, --remote', 'Attempt to fetch the protocol descriptor remotely')
-    .action(function (args) {
+    .option('-l, --local', 'Return the local protocol descriptor')
+    .action((args) => {
         action = protocol.bind(null, args);
     });
 
@@ -313,14 +293,19 @@ program.parse(process.argv);
 
 // common options
 const options = {
-    'host': program.host,
-    'port': program.port,
-    'secure': program.secure
+    host: program.host,
+    port: program.port,
+    secure: program.secure,
+    useHostName: program.useHostName
 };
 
 if (action) {
     action(options);
 } else {
-    program.outputHelp();
-    process.exit(1);
+    if (program.v) {
+        console.log(packageInfo.version);
+    } else {
+        program.outputHelp();
+        process.exit(1);
+    }
 }