Turn var into const or let

dockers/Screenshotter/screenshotter.js

@@ -1,27 +1,27 @@
 /* eslint no-console:0, prefer-spread:0 */
 "use strict";
 
-var childProcess = require("child_process");
-var fs = require("fs");
-var http = require("http");
-var jspngopt = require("jspngopt");
-var net = require("net");
-var os = require("os");
-var pako = require("pako");
-var path = require("path");
-var selenium = require("selenium-webdriver");
-var firefox = require("selenium-webdriver/firefox");
+const childProcess = require("child_process");
+const fs = require("fs");
+const http = require("http");
+const jspngopt = require("jspngopt");
+const net = require("net");
+const os = require("os");
+const pako = require("pako");
+const path = require("path");
+const selenium = require("selenium-webdriver");
+const firefox = require("selenium-webdriver/firefox");
 
-var app = require("../../server");
-var data = require("../../test/screenshotter/ss_data");
+const app = require("../../server");
+const data = require("../../test/screenshotter/ss_data");
 
-var dstDir = path.normalize(
+const dstDir = path.normalize(
     path.join(__dirname, "..", "..", "test", "screenshotter", "images"));
 
 //////////////////////////////////////////////////////////////////////
 // Process command line arguments
 
-var opts = require("nomnom")
+const opts = require("nomnom")
     .option("browser", {
         abbr: "b",
         "default": "firefox",
@@ -74,25 +74,25 @@ var opts = require("nomnom")
     })
     .parse();
 
-var listOfCases;
+let listOfCases;
 if (opts.include) {
     listOfCases = opts.include.split(",");
 } else {
     listOfCases = Object.keys(data);
 }
 if (opts.exclude) {
-    var exclude = opts.exclude.split(",");
+    const exclude = opts.exclude.split(",");
     listOfCases = listOfCases.filter(function(key) {
         return exclude.indexOf(key) === -1;
     });
 }
 
-var seleniumURL = opts.seleniumURL;
-var seleniumIP = opts.seleniumIP;
-var seleniumPort = opts.seleniumPort;
-var katexURL = opts.katexURL;
-var katexIP = opts.katexIP;
-var katexPort = opts.katexPort;
+let seleniumURL = opts.seleniumURL;
+let seleniumIP = opts.seleniumIP;
+let seleniumPort = opts.seleniumPort;
+let katexURL = opts.katexURL;
+let katexIP = opts.katexIP;
+let katexPort = opts.katexPort;
 
 //////////////////////////////////////////////////////////////////////
 // Work out connection to selenium docker container
@@ -107,15 +107,15 @@ function check(err) {
 }
 
 function cmd() {
-    var args = Array.prototype.slice.call(arguments);
-    var cmd = args.shift();
+    const args = Array.prototype.slice.call(arguments);
+    const cmd = args.shift();
     return childProcess.execFileSync(
         cmd, args, { encoding: "utf-8" }).replace(/\n$/, "");
 }
 
 function guessDockerIPs() {
     if (process.env.DOCKER_MACHINE_NAME) {
-        var machine = process.env.DOCKER_MACHINE_NAME;
+        const machine = process.env.DOCKER_MACHINE_NAME;
         seleniumIP = seleniumIP || cmd("docker-machine", "ip", machine);
         katexIP = katexIP || cmd("docker-machine", "ssh", machine,
             "echo ${SSH_CONNECTION%% *}");
@@ -124,7 +124,7 @@ function guessDockerIPs() {
     try {
         // When using boot2docker, seleniumIP and katexIP are distinct.
         seleniumIP = seleniumIP || cmd("boot2docker", "ip");
-        var config = cmd("boot2docker", "config");
+        let config = cmd("boot2docker", "config");
         config = (/^HostIP = "(.*)"$/m).exec(config);
         if (!config) {
             console.error("Failed to find HostIP");
@@ -142,7 +142,7 @@ function guessDockerIPs() {
         return;
     }
     // Native Docker on Linux or remote Docker daemon or similar
-    var gatewayIP = cmd("docker", "inspect",
+    const gatewayIP = cmd("docker", "inspect",
       "-f", "{{.NetworkSettings.Gateway}}", opts.container);
     seleniumIP = seleniumIP || gatewayIP;
     katexIP = katexIP || gatewayIP;
@@ -165,22 +165,22 @@ if (seleniumURL) {
 }
 
 process.nextTick(startServer);
-var attempts = 0;
+let attempts = 0;
 
 //////////////////////////////////////////////////////////////////////
 // Start up development server
 
-var devServer = null;
-var minPort = 32768;
-var maxPort = 61000;
+let devServer = null;
+const minPort = 32768;
+const maxPort = 61000;
 
 function startServer() {
     if (katexURL || katexPort) {
         process.nextTick(tryConnect);
         return;
     }
-    var port = Math.floor(Math.random() * (maxPort - minPort)) + minPort;
-    var server = http.createServer(app).listen(port);
+    const port = Math.floor(Math.random() * (maxPort - minPort)) + minPort;
+    const server = http.createServer(app).listen(port);
     server.once("listening", function() {
         devServer = server;
         katexPort = port;
@@ -206,7 +206,7 @@ function tryConnect() {
         process.nextTick(buildDriver);
         return;
     }
-    var sock = net.connect({
+    const sock = net.connect({
         host: seleniumIP,
         port: +seleniumPort,
     });
@@ -225,21 +225,21 @@ function tryConnect() {
 //////////////////////////////////////////////////////////////////////
 // Build the web driver
 
-var driver;
+let driver;
 function buildDriver() {
-    var builder = new selenium.Builder().forBrowser(opts.browser);
-    var ffProfile = new firefox.Profile();
+    const builder = new selenium.Builder().forBrowser(opts.browser);
+    const ffProfile = new firefox.Profile();
     ffProfile.setPreference(
         "browser.startup.homepage_override.mstone", "ignore");
     ffProfile.setPreference("browser.startup.page", 0);
-    var ffOptions = new firefox.Options().setProfile(ffProfile);
+    const ffOptions = new firefox.Options().setProfile(ffProfile);
     builder.setFirefoxOptions(ffOptions);
     if (seleniumURL) {
         builder.usingServer(seleniumURL);
     }
     driver = builder.build();
     driver.manage().timeouts().setScriptTimeout(3000).then(function() {
-        var html = '<!DOCTYPE html>' +
+        let html = '<!DOCTYPE html>' +
             '<html><head><style type="text/css">html,body{' +
             'width:100%;height:100%;margin:0;padding:0;overflow:hidden;' +
             '}</style></head><body><p>Test</p></body></html>';
@@ -253,15 +253,15 @@ function buildDriver() {
 //////////////////////////////////////////////////////////////////////
 // Set the screen size
 
-var targetW = 1024;
-var targetH = 768;
+const targetW = 1024;
+const targetH = 768;
 function setSize(reqW, reqH) {
     return driver.manage().window().setSize(reqW, reqH).then(function() {
         return driver.takeScreenshot();
     }).then(function(img) {
         img = imageDimensions(img);
-        var actualW = img.width;
-        var actualH = img.height;
+        const actualW = img.width;
+        const actualH = img.height;
         if (actualW === targetW && actualH === targetH) {
             findHostIP();
             return;
@@ -274,7 +274,7 @@ function setSize(reqW, reqH) {
 }
 
 function imageDimensions(img) {
-    var buf = new Buffer(img, "base64");
+    const buf = new Buffer(img, "base64");
     return {
         buf: buf,
         width: buf.readUInt32BE(16),
@@ -312,13 +312,13 @@ function findHostIP() {
     });
 
     // Next, enumerate all network addresses
-    var ips = [];
-    var devs = os.networkInterfaces();
-    for (var dev in devs) {
+    const ips = [];
+    const devs = os.networkInterfaces();
+    for (const dev in devs) {
         if (devs.hasOwnProperty(dev)) {
-            var addrs = devs[dev];
-            for (var i = 0; i < addrs.length; ++i) {
-                var addr = addrs[i].address;
+            const addrs = devs[dev];
+            for (let i = 0; i < addrs.length; ++i) {
+                let addr = addrs[i].address;
                 if (/:/.test(addr)) {
                     addr = "[" + addr + "]";
                 }
@@ -329,7 +329,7 @@ function findHostIP() {
     console.log("Looking for host IP among " + ips.join(", "));
 
     // Load a data: URI document which attempts to contact each of these IPs
-    var html = "<!doctype html>\n<html><body>\n";
+    let html = "<!doctype html>\n<html><body>\n";
     html += ips.map(function(ip) {
         return '<script src="http://' + ip + ':' + katexPort +
             '/ss-connect.js?ip=' + encodeURIComponent(ip) +
@@ -343,17 +343,17 @@ function findHostIP() {
 //////////////////////////////////////////////////////////////////////
 // Take the screenshots
 
-var countdown = listOfCases.length;
+let countdown = listOfCases.length;
 
-var exitStatus = 0;
-var listOfFailed = [];
+let exitStatus = 0;
+const listOfFailed = [];
 
 function takeScreenshots() {
     listOfCases.forEach(takeScreenshot);
 }
 
 function takeScreenshot(key) {
-    var itm = data[key];
+    const itm = data[key];
     if (!itm) {
         console.error("Test case " + key + " not known!");
         listOfFailed.push(key);
@@ -364,14 +364,14 @@ function takeScreenshot(key) {
         return;
     }
 
-    var file = path.join(dstDir, key + "-" + opts.browser + ".png");
-    var retry = 0;
-    var loadExpected = null;
+    let file = path.join(dstDir, key + "-" + opts.browser + ".png");
+    let retry = 0;
+    let loadExpected = null;
     if (opts.verify) {
         loadExpected = promisify(fs.readFile, file);
     }
 
-    var url = katexURL + "test/screenshotter/test.html?" + itm.query;
+    const url = katexURL + "test/screenshotter/test.html?" + itm.query;
     driver.get(url);
     if (opts.wait) {
         browserSideWait(1000 * opts.wait);
@@ -398,10 +398,10 @@ function takeScreenshot(key) {
                 loadExpected = promisify(fs.readFile, file);
             }
         }
-        var opt = new jspngopt.Optimizer({
+        const opt = new jspngopt.Optimizer({
             pako: pako,
         });
-        var buf = opt.bufferSync(img.buf);
+        const buf = opt.bufferSync(img.buf);
         if (loadExpected) {
             return loadExpected.then(function(expected) {
                 if (!buf.equals(expected)) {
@@ -451,8 +451,8 @@ function browserSideWait(milliseconds) {
 // Second and later arguments are passed to the function named in the
 // first argument, and a callback is added as last argument.
 function promisify(f) {
-    var args = Array.prototype.slice.call(arguments, 1);
-    var deferred = new selenium.promise.Deferred();
+    const args = Array.prototype.slice.call(arguments, 1);
+    const deferred = new selenium.promise.Deferred();
     args.push(function(err, val) {
         if (err) {
             deferred.reject(err);