@qooxdoo/framework 7.9.2 → 8.0.0-beta.1

package/source/class/qx/tool/utils/Debounce.js

@@ -37,7 +37,6 @@ qx.Class.define("qx.tool.utils.Debounce", {
       init: "ignored",
       nullable: false,
       check: ["ignore", "restart", "repeat", "queue"],
-      apply: "_applyRepeatedTrigger",
       event: "changeRepeatedTrgger"
     }
   },

package/source/class/qx/tool/utils/Http.js

@@ -19,7 +19,6 @@
 const fs = require("fs");
 const path = require("path");
 const tmp = require("tmp");
-const http = require("http");
 
 /**
  * Helper methods for HTTP
@@ -28,6 +27,51 @@ qx.Class.define("qx.tool.utils.Http", {
   extend: qx.core.Object,
 
   statics: {
+    async getJson(url) {
+      let http = url.match(/^https/) ? require("https") : require("http");
+      return await new Promise((resolve, reject) => {
+        http.get(
+          url,
+          {
+            headers: {
+              "User-Agent": "Qooxdoo Compiler"
+            }
+          },
+
+          res => {
+            let error;
+            const { statusCode } = res;
+            const contentType = res.headers["content-type"];
+
+            if (statusCode !== 200) {
+              error = new Error(`Request Failed.\nStatus Code: ${statusCode}`);
+            } else if (!contentType.match(/application\/json/)) {
+              error = new Error(
+                `Invalid content-type, received ${contentType}`
+              );
+            }
+
+            if (error) {
+              res.resume();
+              reject(error);
+              return;
+            }
+
+            let strJson = "";
+            res.on("data", chunk => (strJson += chunk));
+            res.on("end", () => {
+              try {
+                let data = JSON.parse(strJson);
+                resolve(data);
+              } catch (ex) {
+                reject(ex);
+              }
+            });
+          }
+        );
+      });
+    },
+
     /**
      * Downloads a URL into a temporary file
      *
@@ -40,29 +84,73 @@ qx.Class.define("qx.tool.utils.Http", {
         tmp.tmpName(cb)
       );
 
+      await qx.tool.utils.Http.downloadToFile(
+        url,
+        tmpFilename,
+        contentTypeRegEx
+      );
+    },
+
+    /**
+     * Downloads a URL into a file
+     *
+     * @param {String} url URL to download
+     * @param {String} filename where to download to
+     * @param {RegEx?} contentTypeRegEx optional regex for the content type
+     */
+    async downloadToFile(url, filename, contentTypeRegEx) {
+      let http = url.match(/^https/) ? require("https") : require("http");
       await new Promise((resolve, reject) => {
-        http.get(url, res => {
-          let error;
-          const { statusCode } = res;
-          const contentType = res.headers["content-type"];
-
-          if (statusCode !== 200) {
-            error = new Error(`Request Failed.\nStatus Code: ${statusCode}`);
-          } else if (contentTypeRegEx && !contentTypeRegEx.test(contentType)) {
-            error = new Error(`Invalid content-type, received ${contentType}`);
-          }
+        http.get(
+          url,
+          {
+            headers: {
+              "User-Agent": "Qooxdoo Compiler"
+            }
+          },
 
-          if (error) {
-            res.resume();
-            reject(error);
-            return;
-          }
+          async res => {
+            let error;
+            const { statusCode } = res;
+            const contentType = res.headers["content-type"];
+
+            if (statusCode == 301 || statusCode == 302) {
+              res.resume();
+              try {
+                let result = await qx.tool.utils.Http.downloadToFile(
+                  res.headers.location,
+                  filename,
+                  contentTypeRegEx
+                );
+
+                resolve(result);
+              } catch (ex) {
+                reject(ex);
+              }
+              return;
+            } else if (statusCode !== 200) {
+              error = new Error(`Request Failed.\nStatus Code: ${statusCode}`);
+            } else if (
+              contentTypeRegEx &&
+              !contentTypeRegEx.test(contentType)
+            ) {
+              error = new Error(
+                `Invalid content-type, received ${contentType}`
+              );
+            }
 
-          let outFile = fs.createWriteStream(tmpFilename);
-          outFile.on("close", () => resolve(tmpFilename));
-          res.on("data", chunk => outFile.write(chunk));
-          res.on("end", () => outFile.end());
-        });
+            if (error) {
+              res.resume();
+              reject(error);
+              return;
+            }
+
+            let outFile = fs.createWriteStream(filename);
+            outFile.on("close", () => resolve(filename));
+            res.on("data", chunk => outFile.write(chunk));
+            res.on("end", () => outFile.end());
+          }
+        );
       });
     }
   }

package/source/class/qx/tool/utils/LogManager.js

@@ -134,6 +134,13 @@ qx.Class.define("qx.tool.utils.LogManager", {
   },
 
   members: {
+    _loggers : undefined,
+    _levels : undefined,
+    _sinks : undefined,
+    _config : undefined,
+    _defaultSink : undefined,
+    _defaultLevel :  undefined,
+
     async loadConfig(config) {
       if (typeof config == "string") {
         config = await qx.tool.utils.Json.loadJsonAsync(config);

package/source/class/qx/tool/utils/Promisify.js

@@ -28,7 +28,7 @@ qx.Class.define("qx.tool.utils.Promisify", {
   statics: {
     MAGIC_KEY: "__isPromisified__",
     IGNORED_PROPS:
-      /^(?:promises|length|name|arguments|caller|callee|prototype|__isPromisified__)$/,
+      /^(?:promises|length|name|arguments|caller|callee|prototype|__isPromisified__|F_OK|R_OK|W_OK|X_OK)$/,
 
     promisifyAll(target, fn) {
       Object.getOwnPropertyNames(target).forEach(key => {
@@ -75,6 +75,17 @@ qx.Class.define("qx.tool.utils.Promisify", {
       return fn;
     },
 
+    /**
+     * Runs `fn` for each item in `arr`,
+     * such that at most `size` instances of fn are executing at any one time.
+     * @param {Array} arr 
+     * @param {number} size 
+     * @param {Callback} fn 
+     * 
+     * @callback Callback
+     * @param {*} item
+     * @returns {Promise}
+     */
     async poolEachOf(arr, size, fn) {
       let index = 0;
       let pool = new PromisePool(() => {

package/source/class/qx/tool/utils/QooxdooVersions.js

@@ -0,0 +1,193 @@
+/* ************************************************************************
+
+   qooxdoo - the new era of web development
+
+   http://qooxdoo.org
+
+   Copyright:
+     2023 Zenesis Limited https://www.zenesis.com
+
+   License:
+     MIT: https://opensource.org/licenses/MIT
+     See the LICENSE file in the project's top-level directory for details.
+
+   Authors:
+     * John Spackman (@johnspackman)
+
+************************************************************************ */
+
+const semver = require("semver");
+const path = require("upath");
+const fs = qx.tool.utils.Promisify.fs;
+
+qx.Class.define("qx.tool.utils.QooxdooVersions", {
+  extend: qx.core.Object,
+
+  construct() {
+    super();
+  },
+
+  members: {
+    /** @type{*} saee GitHub API */
+    __githubTags: null,
+
+    /** @type{*} database of best matches */
+    __db: null,
+
+    /**
+     * Gets the tags from Github so we can find releases
+     *
+     * @returns {*} see GitHub API
+     */
+    async _getTags() {
+      if (!this.__githubTags) {
+        this.__githubTags = await qx.tool.utils.Http.getJson(
+          "https://api.github.com/repos/qooxdoo/qooxdoo/tags"
+        );
+      }
+      return this.__githubTags;
+    },
+
+    /**
+     * Returns the filename for the cache database
+     *
+     * @returns {String}
+     */
+    __getFilename() {
+      return path.join(
+        qx.tool.compiler.cli.ConfigDb.getDirectory(),
+        "versions",
+        "versions.txt"
+      );
+    },
+
+    /**
+     * Opens the cache database if there is one
+     */
+    async _open() {
+      if (this.__db) {
+        return this.__db;
+      }
+
+      try {
+        let data = await fs.promises.readFile(this.__getFilename(), "utf8");
+        this.__db = JSON.parse(data);
+      } catch (ex) {
+        if (ex.errno !== "ENOENT") {
+          throw ex;
+        }
+        this.__db = {};
+      }
+    },
+
+    /**
+     * Saves the database
+     */
+    async save() {
+      if (!this.__db) {
+        await fs.promises.unlink(this.__getFilename());
+      } else {
+        await fs.promises.writeFile(
+          this.__getFilename(),
+          JSON.stringify(this.__db, null, 2),
+          "utf8"
+        );
+      }
+    },
+
+    /**
+     * Erases the database
+     */
+    async clean() {
+      this.__db = {};
+      try {
+        await fs.promises.rm(
+          path.join(qx.tool.compiler.cli.ConfigDb.getDirectory(), "versions"),
+          {
+            recursive: true,
+            force: true
+          }
+        );
+      }catch(ex) {
+        // Nothing - exception is thrown if the directory does not exist
+      }
+    },
+
+    /**
+     * Finds the best version of Qooxdoo which is available, whether it is at Github as a release, or the
+     * default Qooxdoo that is provided by this compiler instance
+     *
+     * @param {String} versionToMatch semver satisfaction sequence, eg "^7.0.0"
+     * @returns {String} the directory where the Qooxdoo installation is
+     */
+    async findBestVersion(versionToMatch) {
+      const Console = qx.tool.compiler.Console.getInstance();
+
+      let defaultVersion = await qx.tool.config.Utils.getQxVersion();
+      if (semver.satisfies(defaultVersion, versionToMatch)) {
+        let qxpath = await this.getQxPath();
+        return qxpath;
+      }
+
+      await this._open();
+      if (this.__db.versions[versionToMatch]) {
+        let dirname = this.__db.versions[versionToMatch];
+        if (fs.existsSync(dirname)) {
+          return dirname;
+        }
+        delete this.__db.versions[versionToMatch];
+      }
+
+      await this._getTags();
+      for (let tag of this.__githubTags) {
+        let match = tag.name.match(/^v([0-9]+\.[0-9]+\.[0-9]+)$/);
+        if (match) {
+          let version = match[1];
+          if (semver.satisfies(version, versionToMatch)) {
+            let dirname = path.join(
+              qx.tool.compiler.cli.ConfigDb.getDirectory(),
+              "versions",
+              "v" + version
+            );
+
+            if (!fs.existsSync(path.join(dirname, ".download-success"))) {
+              await fs.promises.rm(dirname, {
+                recursive: true,
+                force: true
+              });
+
+              let zipFilename = dirname + ".zip";
+              Console.log(
+                `Downloading Qooxdoo v${version} to satisfy ${versionToMatch}...`
+              );
+
+              await qx.tool.utils.Http.downloadToFile(
+                tag.zipball_url,
+                zipFilename
+              );
+
+              await qx.tool.utils.Zip.unzip(zipFilename, null, filename =>
+                filename.replace(
+                  /^qooxdoo-qooxdoo-[a-z0-9]+\//,
+                  dirname + path.sep
+                )
+              );
+
+              await fs.promises.writeFile(
+                path.join(dirname, ".download-success"),
+                new Date().toString(),
+                "utf-8"
+              );
+            }
+            this.__db.versions[versionToMatch] = path.resolve(dirname);
+            await this.save();
+            return dirname;
+          }
+        }
+      }
+      throw new Error(
+        `Cannot find a released version of Qooxdoo which is compatible with ${versionToMatch}`
+      );
+    }
+  }
+});

package/source/class/qx/tool/utils/Utils.js

@@ -129,8 +129,8 @@ qx.Class.define("qx.tool.utils.Utils", {
             made += "/";
           }
           made += seg;
-          fs.exists(made, function (exists) {
-            if (!exists) {
+          fs.access(made, fs.constants.F_OK, function (err) {
+            if (err) {
               fs.mkdir(made, function (err) {
                 if (err && err.code === "EEXIST") {
                   err = null;
@@ -246,6 +246,7 @@ qx.Class.define("qx.tool.utils.Utils", {
       return false;
     },
 
+
     /**
      * Runs the given command and returns an object containing information on the
      * `exitCode`, the `output`, potential `error`s, and additional `messages`.
@@ -291,9 +292,11 @@ qx.Class.define("qx.tool.utils.Utils", {
           env = Object.assign({}, env);
           Object.assign(env, options.env);
         }
-        let proc = child_process.spawn(options.cmd, options.args, {
+        
+        // Use String array for arguments - no shell needed
+        let proc = child_process.spawn(options.cmd, options.args || [], {
           cwd: options.cwd,
-          shell: true,
+          shell: options.shell === true, // Only use shell if explicitly requested
           env: env
         });
 
@@ -498,7 +501,7 @@ qx.Class.define("qx.tool.utils.Utils", {
      */ 
     getTemplateDir() {
       let dir = qx.util.ResourceManager.getInstance().toUri(
-        "qx/tool/cli/templates/template_vars.js"
+        "qx/tool/compiler/cli/templates/template_vars.js"
       );
 
       dir = path.dirname(dir);