selenium-webdriver 4.0.0-alpha.7 → 4.0.0-beta.3

package/io/exec.js

@@ -15,10 +15,9 @@
 // specific language governing permissions and limitations
 // under the License.
 
-'use strict';
-
-const childProcess = require('child_process');
+'use strict'
 
+const childProcess = require('child_process')
 
 /**
  * Options for configuring an executed command.
@@ -31,7 +30,7 @@ class Options {
      * Command line arguments for the child process, if any.
      * @type (!Array<string>|undefined)
      */
-    this.args;
+    this.args
 
     /**
      * Environment variables for the spawned process. If unspecified, the
@@ -39,7 +38,7 @@ class Options {
      *
      * @type {(!Object<string, string>|undefined)}
      */
-    this.env;
+    this.env
 
     /**
      * IO conifguration for the spawned server child process. If unspecified,
@@ -49,11 +48,10 @@ class Options {
      *           undefined)}
      * @see <https://nodejs.org/dist/latest-v8.x/docs/api/child_process.html#child_process_options_stdio>
      */
-    this.stdio;
+    this.stdio
   }
 }
 
-
 /**
  * Describes a command's termination conditions.
  */
@@ -66,21 +64,20 @@ class Result {
    */
   constructor(code, signal) {
     /** @type {?number} */
-    this.code = code;
+    this.code = code
 
     /** @type {?string} */
-    this.signal = signal;
+    this.signal = signal
   }
 
   /** @override */
   toString() {
-    return `Result(code=${this.code}, signal=${this.signal})`;
+    return `Result(code=${this.code}, signal=${this.signal})`
   }
 }
 
-
-const COMMAND_RESULT = /** !WeakMap<!Command, !Promise<!Result>> */new WeakMap;
-const KILL_HOOK = /** !WeakMap<!Command, function(string)> */new WeakMap;
+const COMMAND_RESULT = /** !WeakMap<!Command, !Promise<!Result>> */ new WeakMap()
+const KILL_HOOK = /** !WeakMap<!Command, function(string)> */ new WeakMap()
 
 /**
  * Represents a command running in a sub-process.
@@ -92,8 +89,8 @@ class Command {
    *     is called.
    */
   constructor(result, onKill) {
-    COMMAND_RESULT.set(this, result);
-    KILL_HOOK.set(this, onKill);
+    COMMAND_RESULT.set(this, result)
+    KILL_HOOK.set(this, onKill)
   }
 
   /**
@@ -101,7 +98,7 @@ class Command {
    *     command.
    */
   result() {
-    return /** @type {!Promise<!Result>} */(COMMAND_RESULT.get(this));
+    return /** @type {!Promise<!Result>} */ (COMMAND_RESULT.get(this))
   }
 
   /**
@@ -109,14 +106,12 @@ class Command {
    * @param {string=} opt_signal The signal to send; defaults to `SIGTERM`.
    */
   kill(opt_signal) {
-    KILL_HOOK.get(this)(opt_signal || 'SIGTERM');
+    KILL_HOOK.get(this)(opt_signal || 'SIGTERM')
   }
 }
 
-
 // PUBLIC API
 
-
 /**
  * Spawns a child process. The returned {@link Command} may be used to wait
  * for the process result or to send signals to the process.
@@ -126,42 +121,42 @@ class Command {
  * @return {!Command} The launched command.
  */
 module.exports = function exec(command, opt_options) {
-  var options = opt_options || {};
+  const options = opt_options || {}
 
-  var proc = childProcess.spawn(command, options.args || [], {
+  let proc = childProcess.spawn(command, options.args || [], {
     env: options.env || process.env,
-    stdio: options.stdio || 'ignore'
-  });
+    stdio: options.stdio || 'ignore',
+  })
 
   // This process should not wait on the spawned child, however, we do
   // want to ensure the child is killed when this process exits.
-  proc.unref();
-  process.once('exit', onProcessExit);
+  proc.unref()
+  process.once('exit', onProcessExit)
 
-  let result = new Promise(resolve => {
+  const result = new Promise((resolve) => {
     proc.once('exit', (code, signal) => {
-      proc = null;
-      process.removeListener('exit', onProcessExit);
-      resolve(new Result(code, signal));
-    });
-  });
-  return new Command(result, killCommand);
+      proc = null
+      process.removeListener('exit', onProcessExit)
+      resolve(new Result(code, signal))
+    })
+  })
+  return new Command(result, killCommand)
 
   function onProcessExit() {
-    killCommand('SIGTERM');
+    killCommand('SIGTERM')
   }
 
   function killCommand(signal) {
-    process.removeListener('exit', onProcessExit);
+    process.removeListener('exit', onProcessExit)
     if (proc) {
-      proc.kill(signal);
-      proc = null;
+      proc.kill(signal)
+      proc = null
     }
   }
-};
+}
 
 // Exported to improve generated API documentation.
 
-module.exports.Command = Command;
-module.exports.Options = Options;
-module.exports.Result = Result;
+module.exports.Command = Command
+module.exports.Options = Options
+module.exports.Result = Result

package/io/index.js

@@ -15,13 +15,12 @@
 // specific language governing permissions and limitations
 // under the License.
 
-'use strict';
-
-var fs = require('fs'),
-    path = require('path'),
-    rimraf = require('rimraf'),
-    tmp = require('tmp');
+'use strict'
 
+const fs = require('fs')
+const path = require('path')
+const rimraf = require('rimraf')
+const tmp = require('tmp')
 
 /**
  * @param {!Function} fn .
@@ -33,23 +32,19 @@ function checkedCall(fn) {
     try {
       fn((err, value) => {
         if (err) {
-          reject(err);
+          reject(err)
         } else {
-          resolve(value);
+          resolve(value)
         }
-      });
+      })
     } catch (e) {
-      reject(e);
+      reject(e)
     }
-  });
+  })
 }
 
-
-
 // PUBLIC API
 
-
-
 /**
  * Recursively removes a directory and all of its contents. This is equivalent
  * to {@code rm -rf} on a POSIX system.
@@ -57,27 +52,26 @@ function checkedCall(fn) {
  * @return {!Promise} A promise to be resolved when the operation has
  *     completed.
  */
-exports.rmDir = function(dirPath) {
-  return new Promise(function(fulfill, reject) {
-    var numAttempts = 0;
-    attemptRm();
+exports.rmDir = function (dirPath) {
+  return new Promise(function (fulfill, reject) {
+    var numAttempts = 0
+    attemptRm()
     function attemptRm() {
-      numAttempts += 1;
-      rimraf(dirPath, function(err) {
+      numAttempts += 1
+      rimraf(dirPath, function (err) {
         if (err) {
           if (err.code && err.code === 'ENOTEMPTY' && numAttempts < 2) {
-            attemptRm();
-            return;
+            attemptRm()
+            return
           }
-          reject(err);
+          reject(err)
         } else {
-          fulfill();
+          fulfill()
         }
-      });
+      })
     }
-  });
-};
-
+  })
+}
 
 /**
  * Copies one file to another.
@@ -85,19 +79,18 @@ exports.rmDir = function(dirPath) {
  * @param {string} dst The destination file.
  * @return {!Promise<string>} A promise for the copied file's path.
  */
-exports.copy = function(src, dst) {
-  return new Promise(function(fulfill, reject) {
-    var rs = fs.createReadStream(src);
-    rs.on('error', reject);
+exports.copy = function (src, dst) {
+  return new Promise(function (fulfill, reject) {
+    var rs = fs.createReadStream(src)
+    rs.on('error', reject)
 
-    var ws = fs.createWriteStream(dst);
-    ws.on('error', reject);
-    ws.on('close', () => fulfill(dst));
-
-    rs.pipe(ws);
-  });
-};
+    var ws = fs.createWriteStream(dst)
+    ws.on('error', reject)
+    ws.on('close', () => fulfill(dst))
 
+    rs.pipe(ws)
+  })
+}
 
 /**
  * Recursively copies the contents of one directory to another.
@@ -109,63 +102,62 @@ exports.copy = function(src, dst) {
  * @return {!Promise<string>} A promise for the destination
  *     directory's path once all files have been copied.
  */
-exports.copyDir = function(src, dst, opt_exclude) {
-  var predicate = opt_exclude;
+exports.copyDir = function (src, dst, opt_exclude) {
+  var predicate = opt_exclude
   if (opt_exclude && typeof opt_exclude !== 'function') {
-    predicate = function(p) {
-      return !opt_exclude.test(p);
-    };
+    predicate = function (p) {
+      return !opt_exclude.test(p)
+    }
   }
 
   // TODO(jleyba): Make this function completely async.
   if (!fs.existsSync(dst)) {
-    fs.mkdirSync(dst);
+    fs.mkdirSync(dst)
   }
 
-  var files = fs.readdirSync(src);
-  files = files.map(function(file) {
-    return path.join(src, file);
-  });
+  var files = fs.readdirSync(src)
+  files = files.map(function (file) {
+    return path.join(src, file)
+  })
 
   if (predicate) {
-    files = files.filter(/** @type {function(string): boolean} */(predicate));
+    files = files.filter(/** @type {function(string): boolean} */ (predicate))
   }
 
-  var results = [];
-  files.forEach(function(file) {
-    var stats = fs.statSync(file);
-    var target = path.join(dst, path.basename(file));
+  var results = []
+  files.forEach(function (file) {
+    var stats = fs.statSync(file)
+    var target = path.join(dst, path.basename(file))
 
     if (stats.isDirectory()) {
       if (!fs.existsSync(target)) {
-        fs.mkdirSync(target, stats.mode);
+        fs.mkdirSync(target, stats.mode)
       }
-      results.push(exports.copyDir(file, target, predicate));
+      results.push(exports.copyDir(file, target, predicate))
     } else {
-      results.push(exports.copy(file, target));
+      results.push(exports.copy(file, target))
     }
-  });
-
-  return Promise.all(results).then(() => dst);
-};
+  })
 
+  return Promise.all(results).then(() => dst)
+}
 
 /**
  * Tests if a file path exists.
  * @param {string} aPath The path to test.
  * @return {!Promise<boolean>} A promise for whether the file exists.
  */
-exports.exists = function(aPath) {
-  return new Promise(function(fulfill, reject) {
-    let type = typeof aPath;
+exports.exists = function (aPath) {
+  return new Promise(function (fulfill, reject) {
+    let type = typeof aPath
     if (type !== 'string') {
-      reject(TypeError(`expected string path, but got ${type}`));
+      reject(TypeError(`expected string path, but got ${type}`))
     } else {
-      fs.exists(aPath, fulfill);
+      // eslint-disable-next-line node/no-deprecated-api
+      fs.exists(aPath, fulfill)
     }
-  });
-};
-
+  })
+}
 
 /**
  * Calls `stat(2)`.
@@ -173,9 +165,8 @@ exports.exists = function(aPath) {
  * @return {!Promise<!fs.Stats>} A promise for the file stats.
  */
 exports.stat = function stat(aPath) {
-  return checkedCall(callback => fs.stat(aPath, callback));
-};
-
+  return checkedCall((callback) => fs.stat(aPath, callback))
+}
 
 /**
  * Deletes a name from the filesystem and possibly the file it refers to. Has
@@ -183,47 +174,44 @@ exports.stat = function stat(aPath) {
  * @param {string} aPath The path to remove.
  * @return {!Promise} A promise for when the file has been removed.
  */
-exports.unlink = function(aPath) {
-  return new Promise(function(fulfill, reject) {
-    fs.exists(aPath, function(exists) {
+exports.unlink = function (aPath) {
+  return new Promise(function (fulfill, reject) {
+    // eslint-disable-next-line node/no-deprecated-api
+    fs.exists(aPath, function (exists) {
       if (exists) {
-        fs.unlink(aPath, function(err) {
-          err && reject(err) || fulfill();
-        });
+        fs.unlink(aPath, function (err) {
+          ;(err && reject(err)) || fulfill()
+        })
       } else {
-        fulfill();
+        fulfill()
       }
-    });
-  });
-};
-
+    })
+  })
+}
 
 /**
  * @return {!Promise<string>} A promise for the path to a temporary directory.
  * @see https://www.npmjs.org/package/tmp
  */
-exports.tmpDir = function() {
-  return checkedCall(callback => tmp.dir({ unsafeCleanup : true }, callback));
-};
-
+exports.tmpDir = function () {
+  return checkedCall((callback) => tmp.dir({ unsafeCleanup: true }, callback))
+}
 
 /**
  * @param {{postfix: string}=} opt_options Temporary file options.
  * @return {!Promise<string>} A promise for the path to a temporary file.
  * @see https://www.npmjs.org/package/tmp
  */
-exports.tmpFile = function(opt_options) {
-  return checkedCall(callback => {
-    // |tmp.file| checks arguments length to detect options rather than doing a
-    // truthy check, so we must only pass options if there are some to pass.
-    if (opt_options) {
-      tmp.file(opt_options, callback);
-    } else {
-      tmp.file(callback);
-    }
-  });
-};
-
+exports.tmpFile = function (opt_options) {
+  return checkedCall((callback) => {
+    /**  check fixed in v > 0.2.1 if
+     * (typeof options === 'function') {
+     *     return [{}, options];
+     * }
+     */
+    tmp.file(opt_options, callback)
+  })
+}
 
 /**
  * Searches the {@code PATH} environment variable for the given file.
@@ -234,26 +222,25 @@ exports.tmpFile = function(opt_options) {
  * @return {?string} Path to the located file, or {@code null} if it could
  *     not be found.
  */
-exports.findInPath = function(file, opt_checkCwd) {
-  let dirs = [];
+exports.findInPath = function (file, opt_checkCwd) {
+  const dirs = []
   if (opt_checkCwd) {
-    dirs.push(process.cwd());
+    dirs.push(process.cwd())
   }
-  dirs.push.apply(dirs, process.env['PATH'].split(path.delimiter));
+  dirs.push.apply(dirs, process.env['PATH'].split(path.delimiter))
 
-  let foundInDir = dirs.find(dir => {
-    let tmp = path.join(dir, file);
+  let foundInDir = dirs.find((dir) => {
+    let tmp = path.join(dir, file)
     try {
-      let stats = fs.statSync(tmp);
-      return stats.isFile() && !stats.isDirectory();
+      let stats = fs.statSync(tmp)
+      return stats.isFile() && !stats.isDirectory()
     } catch (ex) {
-      return false;
+      return false
     }
-  });
-
-  return foundInDir ? path.join(foundInDir, file) : null;
-};
+  })
 
+  return foundInDir ? path.join(foundInDir, file) : null
+}
 
 /**
  * Reads the contents of the given file.
@@ -262,10 +249,9 @@ exports.findInPath = function(file, opt_checkCwd) {
  * @return {!Promise<!Buffer>} A promise that will resolve with a buffer of the
  *     file contents.
  */
-exports.read = function(aPath) {
-  return checkedCall(callback => fs.readFile(aPath, callback));
-};
-
+exports.read = function (aPath) {
+  return checkedCall((callback) => fs.readFile(aPath, callback))
+}
 
 /**
  * Writes to a file.
@@ -275,10 +261,9 @@ exports.read = function(aPath) {
  * @return {!Promise} A promise that will resolve when the operation has
  *     completed.
  */
-exports.write = function(aPath, data) {
-  return checkedCall(callback => fs.writeFile(aPath, data, callback));
-};
-
+exports.write = function (aPath, data) {
+  return checkedCall((callback) => fs.writeFile(aPath, data, callback))
+}
 
 /**
  * Creates a directory.
@@ -287,18 +272,17 @@ exports.write = function(aPath, data) {
  * @return {!Promise<string>} A promise that will resolve with the path of the
  *     created directory.
  */
-exports.mkdir = function(aPath) {
-  return checkedCall(callback => {
-    fs.mkdir(aPath, undefined, err => {
+exports.mkdir = function (aPath) {
+  return checkedCall((callback) => {
+    fs.mkdir(aPath, undefined, (err) => {
       if (err && err.code !== 'EEXIST') {
-        callback(err);
+        callback(err)
       } else {
-        callback(null, aPath);
+        callback(null, aPath)
       }
-    });
-  });
-};
-
+    })
+  })
+}
 
 /**
  * Recursively creates a directory and any ancestors that do not yet exist.
@@ -308,29 +292,31 @@ exports.mkdir = function(aPath) {
  *     created directory.
  */
 exports.mkdirp = function mkdirp(dir) {
-  return checkedCall(callback => {
-    fs.mkdir(dir, undefined, err => {
+  return checkedCall((callback) => {
+    fs.mkdir(dir, undefined, (err) => {
       if (!err) {
-        callback(null, dir);
-        return;
+        callback(null, dir)
+        return
       }
 
       switch (err.code) {
         case 'EEXIST':
-          callback(null, dir);
-          return;
+          callback(null, dir)
+          return
         case 'ENOENT':
           return mkdirp(path.dirname(dir))
-              .then(() => mkdirp(dir))
-              .then(() => callback(null, dir), err => callback(err));
+            .then(() => mkdirp(dir))
+            .then(
+              () => callback(null, dir),
+              (err) => callback(err)
+            )
         default:
-          callback(err);
-          return;
+          callback(err)
+          return
       }
-    });
-  });
-};
-
+    })
+  })
+}
 
 /**
  * Recursively walks a directory, returning a promise that will resolve with
@@ -341,19 +327,22 @@ exports.mkdirp = function mkdirp(dir) {
  *     resolve with a list of entries seen. For each entry, the recorded path
  *     will be relative to `rootPath`.
  */
-exports.walkDir = function(rootPath) {
-  let seen = [];
+exports.walkDir = function (rootPath) {
+  const seen = []
   return (function walk(dir) {
-    return checkedCall(callback => fs.readdir(dir, callback))
-        .then(files => Promise.all(files.map(file => {
-          file = path.join(dir, file);
-          return checkedCall(cb => fs.stat(file, cb)).then(stats => {
+    return checkedCall((callback) => fs.readdir(dir, callback)).then((files) =>
+      Promise.all(
+        files.map((file) => {
+          file = path.join(dir, file)
+          return checkedCall((cb) => fs.stat(file, cb)).then((stats) => {
             seen.push({
               path: path.relative(rootPath, file),
-              dir: stats.isDirectory()
-            });
-            return stats.isDirectory() && walk(file);
-          });
-        })));
-  })(rootPath).then(() => seen);
-};
+              dir: stats.isDirectory(),
+            })
+            return stats.isDirectory() && walk(file)
+          })
+        })
+      )
+    )
+  })(rootPath).then(() => seen)
+}