@qooxdoo/framework 7.0.0-beta.3 → 7.0.0-beta.7

package/source/class/qx/test/io/jsonrpc/Client.js

@@ -0,0 +1,267 @@
+/* ************************************************************************
+
+   qooxdoo - the new era of web development
+
+   http://qooxdoo.org
+
+   Copyright:
+     2004-2011 1&1 Internet AG, Germany, http://www.1und1.de & contributors
+
+   License:
+     MIT: https://opensource.org/licenses/MIT
+     See the LICENSE file in the project's top-level directory for details.
+
+   Authors:
+     * Tristan Koch (tristankoch)
+     * Christian Boulanger (cboulanger)
+
+************************************************************************ */
+
+/**
+ * Tests for qx.io.jsonrpc.Client with a qx.test.io.request.Xhr transport
+ */
+qx.Class.define("qx.test.io.jsonrpc.Client",
+{
+  extend : qx.dev.unit.TestCase,
+
+  include : [
+    qx.dev.unit.MMock,
+    qx.test.io.MAssert
+  ],
+
+  members : {
+
+    setUp() {
+      this.sinon = qx.dev.unit.Sinon.getSinon();
+      this.setUpRequest();
+      this.setUpFakeTransport();
+      qx.io.jsonrpc.protocol.Request.resetId();
+    },
+
+    setUpRequest: function () {
+      this.req && this.req.dispose();
+      this.req = new qx.io.request.Xhr();
+      this.req.setUrl("url");
+    },
+
+    setUpFakeTransport: function () {
+      if (this.transport && this.transport.send.restore) {
+        return;
+      }
+      this.transport = this.injectStub(qx.io.request.Xhr.prototype, "_createTransport");
+      this.setUpRequest();
+    },
+
+    setUpFakeXhr: function () {
+      // Not fake transport
+      this.getSandbox().restore();
+      this.useFakeXMLHttpRequest();
+      this.setUpRequest();
+    },
+
+    /**
+     * Sets up the fake server and instructs it to send the given response(s)
+     * @param {String} response The server response to the first request
+     */
+    setUpFakeServer: function (response) {
+      // Not fake transport
+      this.getSandbox().restore();
+      this.useFakeServer();
+      this.setUpRequest();
+      this.getServer().respondWith(
+        "POST", /.*/,
+        [200, {"Content-Type": "application/json; charset=utf-8"}, response]
+      );
+      this.getServer().autoRespond = true;
+    },
+
+    /**
+     * Assert that the given exception is thrown on receiving the given result
+     * @param {String} response
+     * @param {Class|Number} exception If class, the exception class, which must
+     * be a subclass of qx.io.exception.Exception. If number, the error number
+     */
+    assertExceptionThrown: function (response, exception) {
+      if (!(qx.lang.Type.isNumber(exception) || qx.Class.isSubClassOf(exception, qx.io.exception.Exception))) {
+        throw new Error("Second argument must be a Number or a subclass of qx.io.exception.Exception");
+      }
+      this.setUpFakeServer(response);
+      const message_out = new qx.io.jsonrpc.protocol.Request("foo",[1,2,3]);
+      const client = new qx.io.jsonrpc.Client("http://jsonrpc");
+      const errorCallback = this.spy(err => {
+        //console.warn(err);
+        if (qx.lang.Type.isNumber(exception)) {
+          if (!(err instanceof qx.io.exception.Exception)) {
+            throw err;
+          }
+          this.assertEquals(exception, err.code,`Error code does not match`);
+        } else {
+          this.assertInstance(err, exception,
+            `Exception class does not match. Expected ${exception.classname}, got ${err}.`);
+        }
+      });
+      // check message promise
+      message_out.getPromise().catch(errorCallback);
+      // check event
+      client.addListener("error", evt => errorCallback(evt.getData()));
+      // check transport promise
+      client.send(message_out).catch(errorCallback);
+      this.wait(100, () => {
+        if (
+          // the request promise will not be called since the promise is already rejected
+          exception === qx.io.exception.Transport.DUPLICATE_ID
+          // or the send promise will not be rejected because we have a server-side error
+          || exception === qx.io.exception.Protocol) {
+          this.assertCalledTwice(errorCallback)
+        } else {
+          // the error handler will be called three times
+          this.assertCalledThrice(errorCallback)
+        }
+      });
+    },
+
+    tearDown: function () {
+      this.getSandbox().restore();
+      this.req.dispose();
+    },
+
+    resetId(){
+      qx.io.jsonrpc.protocol.Request.resetId();
+    },
+
+    //
+    // Auth, should be moved into qx.test.io.request.Xhr
+    //
+
+    "test: Bearer authentication": function () {
+      this.setUpFakeTransport();
+
+      var transport = this.transport, auth, call, key, credentials;
+
+      auth = new qx.io.request.authentication.Bearer("TOKEN");
+      this.req.setAuthentication(auth);
+      this.req.send();
+
+      call = transport.setRequestHeader.getCall(1);
+      key = "Authorization";
+      credentials = /Bearer\s(.*)/.exec(call.args[1])[1];
+      this.assertEquals(key, call.args[0]);
+      this.assertEquals("TOKEN", credentials);
+    },
+
+    //
+    // JSON-RPC
+    //
+
+    "test: throw on invalid response id" : function() {
+      this.resetId();
+      var response = qx.lang.Json.stringify({"jsonrpc": "2.0", "result": 19, "id": 2});
+      this.assertExceptionThrown(response, qx.io.exception.Transport.UNKNOWN_ID);
+    },
+
+    "test: throw on duplicate response id" : function() {
+      this.resetId();
+      var response = qx.lang.Json.stringify([
+        {"jsonrpc": "2.0", "result": 19, "id": 1},
+        {"jsonrpc": "2.0", "result": 19, "id": 1}
+      ]);
+      this.assertExceptionThrown(response, qx.io.exception.Transport.DUPLICATE_ID);
+    },
+
+    "test: call jsonrpc method and receive response with single result" : async function() {
+      this.resetId();
+      let message_out = new qx.io.jsonrpc.protocol.Request("foo", ["bar"]);
+      let result = "Hello World!";
+      let message_in  = new qx.io.jsonrpc.protocol.Result(message_out.getId(), result);
+      this.setUpFakeServer(message_in.toString());
+      const client = new qx.io.jsonrpc.Client("http://jsonrpc");
+      let spy = this.spy(value => this.assertEquals(result, value));
+      message_out.getPromise().then(spy);
+      await client.send(message_out);
+      this.assertCalled(spy);
+    },
+
+    "test: call jsonrpc method and receive batched response" : async function() {
+      this.resetId();
+      let message_out = new qx.io.jsonrpc.protocol.Request("foo", ["bar"]);
+      let result = "Hello World!";
+      let response = (new qx.io.jsonrpc.protocol.Batch())
+        .add(new qx.io.jsonrpc.protocol.Result(message_out.getId(), result))
+        .addRequest("foo", ["bar"])
+        .addNotification("logout")
+        .toString();
+      this.setUpFakeServer(response);
+      const client = new qx.io.jsonrpc.Client("http://jsonrpc");
+      let spy = this.spy(value => this.assertEquals(result, value));
+      message_out.getPromise().then(spy);
+      await client.send(message_out);
+      this.assertCalled(spy);
+    },
+
+    "test: call jsonrpc method and expect error on invalid reponse "() {
+      this.assertExceptionThrown("helloworld!", qx.io.exception.Transport.INVALID_JSON);
+    },
+
+    "test: call jsonrpc method and expect error on invalid reponse - missing result" () {
+      this.assertExceptionThrown("null", qx.io.exception.Transport.NO_DATA);
+    },
+
+    "test: call jsonrpc method and expect error response"() {
+      this.resetId();
+      var response = qx.lang.Json.stringify({"jsonrpc": "2.0", "error" : {"code": -32600, "message": "Division by zero!"}, "id": 1});
+      this.assertExceptionThrown(response, qx.io.exception.Protocol);
+    },
+
+    "test: send batched requests"() {
+      this.resetId();
+      var response = qx.lang.Json.stringify([
+        {"jsonrpc": "2.0", "result": 7, "id": 1},
+        {"jsonrpc": "2.0", "result": "foo", "id": 2},
+        {"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request"}, "id": 3},
+        {"jsonrpc": "2.0", "error": {"code": -32601, "message": "Method not found"}, "id": 4},
+        {"jsonrpc": "2.0", "result": ["hello", 5], "id": 5}]);
+      this.setUpFakeServer(response);
+      var client = new qx.io.jsonrpc.Client("http://jsonrpc");
+      var spies = [];
+      var batch = new qx.io.jsonrpc.protocol.Batch();
+      for( var i=1; i < 6; i++) {
+        spies[i] = { result: this.spy(), error: this.spy() };
+        let request = new qx.io.jsonrpc.protocol.Request("someMethod", []);
+        request.getPromise()
+          .then(spies[i].result)
+          .catch(spies[i].error);
+        batch.add(request);
+      }
+      client.sendBatch(batch).catch(err => {
+        this.assertInstance(err, qx.io.exception.Protocol);
+      });
+      this.wait(100, function(){
+        this.assertCalledWith(spies[1].result, 7);
+        this.assertCalledWith(spies[2].result, "foo");
+        this.assertCalled(spies[3].error);
+        this.assertCalled(spies[4].error);
+        this.assertCalledWith(spies[5].result, ["hello", 5]);
+      },this);
+    },
+
+    "test: receive jsonrpc requests from server" : function() {
+      this.resetId();
+      var response = [
+        {"jsonrpc": "2.0", "method": "clientMethod", "params": ["foo", "bar"], "id": 1},
+        {"jsonrpc": "2.0", "method": "clientNotification", "params": []}
+      ];
+      this.setUpFakeServer(qx.lang.Json.stringify(response));
+      var client = new qx.io.jsonrpc.Client("http://jsonrpc");
+      var spy = this.spy();
+      client.addListener("incomingRequest", evt => {
+        let message = evt.getData().toObject();
+        this.assertDeepEquals(response.shift(), message);
+        spy(message);
+      });
+      client.sendNotification("ping");
+      this.wait(100, function(){
+        this.assertCalledTwice(spy);
+      },this);
+    }
+  }
+});

package/source/class/qx/test/io/jsonrpc/Protocol.js

@@ -0,0 +1,80 @@
+/* ************************************************************************
+
+   qooxdoo - the new era of web development
+
+   http://qooxdoo.org
+
+   Copyright:
+     2020 Christian Boulanger
+
+   License:
+     MIT: https://opensource.org/licenses/MIT
+     See the LICENSE file in the project's top-level directory for details.
+
+   Authors:
+     * Christian Boulanger (cboulanger)
+
+************************************************************************ */
+
+qx.Class.define("qx.test.io.jsonrpc.Protocol",
+{
+  extend : qx.dev.unit.TestCase,
+  include : [qx.test.io.MAssert],
+  construct() {
+    this.base(arguments);
+    this.parser = new qx.io.jsonrpc.protocol.Parser();
+  },
+  members : {
+    "test: JSON-RPC request message object"() {
+      let message = new qx.io.jsonrpc.protocol.Request("foo", ["bar", 1, false]);
+      let expected = {
+        id: 1,
+        jsonrpc: "2.0",
+        method: "foo",
+        params: ["bar", 1, false]
+      };
+      this.assertDeepEquals(expected, message.toObject());
+      // test parser
+      this.assertDeepEquals(expected, this.parser.parse(JSON.stringify(expected)).toObject());
+    },
+
+    "test: JSON-RPC request notification object"() {
+      let message = new qx.io.jsonrpc.protocol.Notification("foo", ["bar", 1, false]);
+      let expected = {
+        jsonrpc: "2.0",
+        method: "foo",
+        params: ["bar", 1, false]
+      };
+      this.assertDeepEquals(expected, message.toObject());
+      // test parser
+      this.assertDeepEquals(expected, this.parser.parse(JSON.stringify(expected)).toObject());
+    },
+
+    "test: JSON-RPC error object"() {
+      let message = new qx.io.jsonrpc.protocol.Error(1, 5, "error!");
+      let expected = {
+        jsonrpc: "2.0",
+        id: 1,
+        error: {
+          code: 5,
+          message: "error!"
+        }
+      };
+      this.assertDeepEquals(expected, message.toObject());
+      // test parser
+      this.assertDeepEquals(expected, this.parser.parse(JSON.stringify(expected)).toObject());
+    },
+
+    "test: JSON-RPC result object"() {
+      let message = new qx.io.jsonrpc.protocol.Error(1, 5, "error!");
+      let expected = {
+        jsonrpc: "2.0", id: 1, error: {
+          code: 5, message: "error!"
+        }
+      };
+      this.assertDeepEquals(expected, message.toObject());
+      // test parser
+      this.assertDeepEquals(expected, this.parser.parse(JSON.stringify(expected)).toObject());
+    }
+  }
+});

package/source/class/qx/test/io/transport/PostMessage.js

@@ -0,0 +1,56 @@
+/* ************************************************************************
+
+   qooxdoo - the new era of web development
+
+   http://qooxdoo.org
+
+   Copyright:
+     2004-2011 1&1 Internet AG, Germany, http://www.1und1.de & contributors
+
+   License:
+     MIT: https://opensource.org/licenses/MIT
+     See the LICENSE file in the project's top-level directory for details.
+
+   Authors:
+     * Tristan Koch (tristankoch)
+     * Christian Boulanger (cboulanger)
+
+************************************************************************ */
+
+/**
+ * Tests for the postMessage transport
+ * @ignore(URL)
+ * @ignore(Worker)
+ * @ignore(self)
+ */
+qx.Class.define("qx.test.io.transport.PostMessage", {
+  extend: qx.dev.unit.TestCase,
+
+  members: {
+
+    setUp() {
+      // see https://medium.com/@dee_bloo/make-multithreading-easier-with-inline-web-workers-a58723428a42
+      function createWorker(fn) {
+        let blob = new Blob(['self.onmessage = ', fn.toString()], { type: 'text/javascript' });
+        return new Worker(URL.createObjectURL(blob));
+      }
+      // create echo server
+      const worker = createWorker(evt => {
+        self.postMessage(evt.data);
+      });
+      this.transport = new qx.io.transport.PostMessage(worker);
+    },
+
+    async "test: send message to worker and check response"() {
+      let message = "Hello World!";
+      await new qx.Promise((resolve, reject) => {
+        this.transport.addListenerOnce("message", evt => {
+          this.assertEquals(message, evt.getData());
+        });
+        this.transport.send(message)
+          .then(resolve)
+          .catch(reject);
+      });
+    }
+  }
+});

package/source/class/qx/test/io/transport/Websocket.js

@@ -0,0 +1,63 @@
+/* ************************************************************************
+
+   qooxdoo - the new era of web development
+
+   http://qooxdoo.org
+
+   Copyright:
+     2004-2011 1&1 Internet AG, Germany, http://www.1und1.de & contributors
+
+   License:
+     MIT: https://opensource.org/licenses/MIT
+     See the LICENSE file in the project's top-level directory for details.
+
+   Authors:
+     * Tristan Koch (tristankoch)
+     * Christian Boulanger (cboulanger)
+
+************************************************************************ */
+
+/**
+ * Tests for the websocket transport
+ */
+qx.Class.define("qx.test.io.transport.Websocket", {
+  extend: qx.dev.unit.TestCase,
+
+  statics: {
+    TEST_ENDPOINT: "echo.websocket.events"
+  },
+
+  members: {
+
+    __hasEndpoint : false,
+    __skipMsg: "Skipping test as endpoint is not available.",
+
+    setUp() {
+      this.transport = new qx.io.transport.Websocket("wss://" + this.constructor.TEST_ENDPOINT);
+    },
+
+    async "test: check endpoint"() {
+      try {
+        await this.transport.send("test");
+        this.__hasEndpoint = true;
+      } catch(e) {
+        console.error(`Endpoint ${this.constructor.TEST_ENDPOINT} is not accessible: ${e.message}`);
+      }
+    },
+
+    async "test: send message to public websocket echo server and check response"() {
+      if (!this.__hasEndpoint) {
+        return this.skip(this.__skipMsg);
+      }
+      let message = "Hello World!";
+      await new qx.Promise((resolve, reject) => {
+        this.transport.addListenerOnce("message", evt => {
+          this.assertEquals(message, evt.getData());
+        });
+        this.transport.send(message)
+          .then(resolve)
+          .catch(reject);
+      });
+    }
+  }
+});

package/source/class/qx/test/ui/embed/Iframe.js

@@ -88,6 +88,7 @@ qx.Class.define("qx.test.ui.embed.Iframe",
       this.wait(10000);
     },
 
+    /** @ignore(require) */
     testSyncSourceAfterDOMMove : function ()
     {
       // This breaks (very) frequently when run under headless chrome on Travis; we can't
@@ -99,7 +100,6 @@ qx.Class.define("qx.test.ui.embed.Iframe",
 
       //  This also breaks on MacOS runners on GitHub with webkit
       try {
-        /** @ignore(require) */
         let CI = require("process").env.CI;
         if (CI && qx.core.Environment.get("browser.name") === "webkit") {
           this.skip("Skipping for Webkit for MacOS");

package/source/class/qx/test/util/DateFormat.js

@@ -805,15 +805,54 @@ qx.Class.define("qx.test.util.DateFormat",
         this._testIsoMasks(date, 'isoDate', 'yyyy-MM-dd');
         this._testIsoMasks(date, 'isoTime', 'HH:mm:ss');
         this._testIsoMasks(date, 'isoDateTime', "yyyy-MM-dd'T'HH:mm:ss");
-
-//        var isodf = new qx.util.format.DateFormat('isoUtcDateTime');
-//        var df = new qx.util.format.DateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'");
-//        var isoDateFormatted = isodf.format(date);
-//        var dateFormatted = df.format(date);
-//        this.assertEquals(isodf.parse(isoDateFormatted).getTime(),df.parse(dateFormatted).getTime());
+        this._testIsoMasks(date, 'isoDateTimeTz', "yyyy-MM-dd'T'HH:mm:ssZ");
+        //this._testIsoMasks(date, 'isoUtcDateTime', "yyyy-MM-dd'T'HH:mm:ss'Z'");
       }
   },
 
+  testIsoTz : function() {
+    var isodf = new qx.util.format.DateFormat('isoDateTimeTz');
+    var parsedDate = isodf.parse("2013-01-01T00:00:00+0000");
+    this.assertEquals(parsedDate.getUTCFullYear(), 2013);
+    this.assertEquals(parsedDate.getUTCMonth(), 0);
+    this.assertEquals(parsedDate.getUTCDate(), 1);
+    this.assertEquals(parsedDate.getUTCHours(), 0);
+    this.assertEquals(parsedDate.getUTCMinutes(), 0);
+    this.assertEquals(parsedDate.getUTCSeconds(), 0);
+    this.assertEquals(parsedDate.getUTCMilliseconds(), 0);
+
+    parsedDate = isodf.parse("2004-04-04T04:04:04-0500")
+    this.assertEquals(parsedDate.getUTCFullYear(), 2004);
+    this.assertEquals(parsedDate.getUTCMonth(), 3);
+    this.assertEquals(parsedDate.getUTCDate(), 3);
+    this.assertEquals(parsedDate.getUTCHours(), 23);
+    this.assertEquals(parsedDate.getUTCMinutes(), 4);
+    this.assertEquals(parsedDate.getUTCSeconds(), 4);
+    this.assertEquals(parsedDate.getUTCMilliseconds(), 0);
+  },
+
+  testUtc : function () {
+    var isodf = new qx.util.format.DateFormat('isoUtcDateTime');
+    var parsedDate = isodf.parse("2013-01-01T00:00:00Z");
+    this.assertEquals(parsedDate.getUTCFullYear(), 2013);
+    this.assertEquals(parsedDate.getUTCMonth(), 0);
+    this.assertEquals(parsedDate.getUTCDate(), 1);
+    this.assertEquals(parsedDate.getUTCHours(), 0);
+    this.assertEquals(parsedDate.getUTCMinutes(), 0);
+    this.assertEquals(parsedDate.getUTCSeconds(), 0);
+    this.assertEquals(parsedDate.getUTCMilliseconds(), 0);
+
+    // checks that UTC hours are calculated correctly
+    parsedDate = isodf.parse("2004-04-04T04:04:04Z");
+    this.assertEquals(parsedDate.getUTCHours(), 4);
+
+    // checks that UTC format does not parse a date with a timezone
+    this.assertException(function() {
+      isodf.parse("2004-04-04T04:04:04+05:00");
+    }, Error);
+
+  },
+
   testChangingLocales : function()
   {
     var manager = qx.locale.Manager.getInstance();

package/source/class/qx/tool/cli/Cli.js

@@ -179,6 +179,7 @@ Version: v${await qx.tool.config.Utils.getQxVersion()}
           "Compile",
           "Config",
           "Deploy",
+          "Es6ify",
           "Package",
           "Pkg", // alias for Package
           "Create",

package/source/class/qx/tool/cli/commands/Compile.js

@@ -128,6 +128,11 @@ qx.Class.define("qx.tool.cli.commands.Compile", {
         type: "boolean",
         default: false
       },
+      "source-map-relative-paths": {
+        "describe": "If true, the source file will be saved in the map file if the target supports it. Can be overridden on a per application basis.",
+        "type": "boolean",
+        default: false
+      },
       "save-unminified": {
         alias: "u",
         describe: "Saves a copy of the unminified version of output files (build target only)",
@@ -571,10 +576,10 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
     createMakersFromConfig: async function(data) {
       const Console = qx.tool.compiler.Console.getInstance();
       var t = this;
-
       if (data.babelOptions) {
-        if (!data.babelConfig) {
-          data.babelConfig = { options: data.babelOptions };
+        if (!data?.babel?.options) {
+          data.babel = data.babel || {};
+          data.babel.options = data.babelOptions;
           qx.tool.compiler.Console.print("qx.tool.cli.compile.deprecatedBabelOptions");
         } else {
           qx.tool.compiler.Console.print("qx.tool.cli.compile.deprecatedBabelOptionsConflicting");
@@ -841,6 +846,11 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
           target.setSaveSourceInMap(saveSourceInMap);
         }
 
+        var sourceMapRelativePaths = chooseValue(targetConfig["source-map-relative-paths"], t.argv["sourceMapRelativePaths"]);
+        if ((typeof sourceMapRelativePaths == "boolean") && (typeof target.setSourceMapRelativePaths == "function")) {
+          target.setSourceMapRelativePaths(sourceMapRelativePaths);
+        }
+
         var saveUnminified = chooseValue(targetConfig["save-unminified"], t.argv["save-unminified"]);
         if (typeof saveUnminified == "boolean" && typeof target.setSaveUnminified == "function") {
           target.setSaveUnminified(saveUnminified);

package/source/class/qx/tool/cli/commands/Es6ify.js

@@ -0,0 +1,93 @@
+/* ************************************************************************
+
+   qooxdoo - the new era of web development
+
+   http://qooxdoo.org
+
+   Copyright:
+     2021 Zenesis Ltd
+
+   License:
+     MIT: https://opensource.org/licenses/MIT
+     See the LICENSE file in the project's top-level directory for details.
+
+   Authors:
+     * John Spackman (john.spackman@zenesis.com, @johnspackman)
+
+************************************************************************ */
+
+const fs = require("fs");
+const path = require("upath");
+
+/**
+ * Migrates code to ES6 (partially)
+ */
+qx.Class.define("qx.tool.cli.commands.Es6ify", {
+  extend: qx.tool.cli.commands.Command,
+  statics: {
+    getYargsCommand: function () {
+      return {
+        command: "es6ify [file]",
+        describe: "help migrate code to ES6",
+        builder: {
+          verbose: {
+            alias: "v",
+            describe: "Verbose logging",
+          },
+          overwrite: {
+            type: "boolean",
+            default: true,
+            describe: "Overwrite source files"
+          },
+          exclude: {
+            type: "array",
+            describe: "Paths to exclude"
+          },
+          arrowFunctions: {
+            choices: [ "never", "always", "careful", "aggressive" ],
+            default: "careful"
+          }
+        }
+      };
+    }
+  },
+
+  members: {
+    async process() {
+      await this.base(arguments);
+      let exclude = this.argv.exclude;
+
+      const processFile = async filename => {
+        if (exclude && filename.startsWith(exclude)) {
+          return;
+        }
+
+        console.log(`Processing ${filename}...`);
+        let ify = new qx.tool.compiler.Es6ify(filename);
+        ify.set({
+          arrowFunctions: this.argv.arrowFunctions,
+          overwrite: this.argv.overwrite
+        });
+        await ify.transform();
+      };
+
+      const scanImpl = async filename => {
+        let basename = path.basename(filename);
+        let stat = await fs.promises.stat(filename);
+
+        if (stat.isFile() && basename.match(/\.js$/)) {
+          await processFile(filename);
+
+        } else if (stat.isDirectory() && (basename == "." || basename[0] != '.')) {
+          let files = await fs.promises.readdir(filename);
+          for (let i = 0; i < files.length; i++) {
+            let subname = path.join(filename, files[i]);
+            await scanImpl(subname);
+          }
+        }
+      };
+
+      await scanImpl(this.argv.file);
+    }
+  }
+});