@qooxdoo/framework 7.9.2 → 8.0.0-beta.1

package/source/class/qx/tool/{cli/commands → compiler/cli}/Command.js

@@ -23,66 +23,120 @@ const process = require("process");
 /**
  * Base class for commands
  */
-qx.Class.define("qx.tool.cli.commands.Command", {
+qx.Class.define("qx.tool.compiler.cli.Command", {
   extend: qx.core.Object,
+  statics: {
+    /**
+     * abstract factory to create the command
+     * @returns {qx.tool.cli.Command} the created command
+     */
+    async createCliCommand(clazz = this) {
+      let cmd = new qx.tool.cli.Command("");
+      let cls = new clazz();
+      cmd.setRun(async cmd => {
+        let { argv } = cmd.getValues();
+        argv.$cmd = cmd.getName();
+        await qx.tool.compiler.cli.ConfigLoader.getInstance().getCompilerApi().setCommandAsync(cls);
+        await cls.setCompilerApi(qx.tool.compiler.cli.ConfigLoader.getInstance().getCompilerApi());
+        qx.tool.compiler.Console.getInstance().setVerbose(
+          argv.verbose || false
+        );
+        qx.log.Logger.setLevel(argv.loglevel);
+        cls.argv = argv;
+        let res = await cls.process();
+        await cls.getCompilerApi().afterProcessFinished(cls, res);
+        return res;
+      });
+      cmd.addFlag(
+        new qx.tool.cli.Flag("verbose").set({
+          shortCode: "v",
+          description: "enables additional progress output to console",
+          type: "boolean",
+          value: false
+        })
+      );
+
+      cmd.addFlag(
+        new qx.tool.cli.Flag("config-file").set({
+          description: "Specify the config file to use",
+          type: "string",
+          shortCode: "c"
+        })
+      );
+
+      cmd.addFlag(
+        new qx.tool.cli.Flag("loglevel").set({
+          description: "sets the log level",
+          value: "info",
+          type: ["debug", "info", "warn", "error"],
+        })
+      );
+
+      cmd.addFlag(
+        new qx.tool.cli.Flag("quiet").set({
+          shortCode: "q",
+          description: "suppresses normal progress output to console",
+          type: "boolean",
+          value: false
+        })
+      );
+
+      cmd.addFlag(
+        new qx.tool.cli.Flag("force").set({
+          description: "Override warnings",
+          type: "boolean",
+          value: false,
+          shortCode: "F"
+        })
+      );
+
+      cmd.addFlag(
+        new qx.tool.cli.Flag("colorize").set({
+          description:
+            "colorize log output to the console using ANSI color codes",
+          value: true,
+          type: "boolean"
+        })
+      );
 
-  construct(argv) {
+      return cmd;
+    },
+
+    async addSubcommands(rootCmd, rootClass) {
+      for await (const cls of Object.keys(rootClass)) {
+        let c = rootClass[cls];
+        if (!c) {
+          continue;
+        }
+        if (!c.createCliCommand) {
+          continue;
+        }
+        let cmd = await rootClass[cls].createCliCommand();
+        rootCmd.addSubcommand(cmd);
+      }
+    }
+  },
+
+  construct() {
     super();
-    this.argv = argv;
   },
 
   properties: {
     /**
      * A reference to the current compilerApi instance
-     * @var {qx.tool.cli.api.CompilerApi}
+     * @var {qx.tool.compiler.cli.api.CompilerApi}
      */
     compilerApi: {
-      check: "qx.tool.cli.api.CompilerApi",
+      check: "qx.tool.compiler.cli.api.CompilerApi",
       nullable: true
     }
   },
 
   members: {
     argv: null,
-    compileJs: null,
 
     async process() {
-      let argv = this.argv;
-      if (argv.set) {
-        let configDb = await qx.tool.cli.ConfigDb.getInstance();
-        argv.set.forEach(function (kv) {
-          var m = kv.match(/^([^=\s]+)(=(.+))?$/);
-          if (m) {
-            var key = m[1];
-            var value = m[3];
-            configDb.setOverride(key, value);
-          } else {
-            throw new qx.tool.utils.Utils.UserError(
-              `Failed to parse environment setting commandline option '--set ${kv}'`
-            );
-          }
-        });
-      }
-    },
-
-    /**
-     * This is to notify the commands after loading the full args.
-     * The commands can overload special arg arguments here.
-     * e.g. Deploy will will overload the target.
-     *
-     * @param {*} argv : args to process
-     *
-     */
-    processArgs(argv) {
-      // Nothing
-    },
-
-    /**
-     * Returns the parsed command line arguments
-     * @return {Object}
-     */
-    getArgs() {
-      return this.argv;
+      throw new Error("Abstract method call");
     },
 
     /**
@@ -109,13 +163,13 @@ qx.Class.define("qx.tool.cli.commands.Command", {
           dryRun: true
         });
 
-        let { pending, applied } = await runner.runMigrations();
+        let { pending } = await runner.runMigrations();
         await fsp.unlink(semaphore);
         if (pending) {
           qx.tool.compiler.Console.warn(
             `*** There are ${pending} pending migrations. \n` +
-              `*** Please run '(npx) qx migrate --dry-run --verbose' for details, \n` +
-              `*** and '(npx) qx migrate' to apply the changes.`
+            `*** Please run '(npx) qx migrate --dry-run --verbose' for details, \n` +
+            `*** and '(npx) qx migrate' to apply the changes.`
           );
 
           if (!process.env.IGNORE_MIGRATION_WARNING) {

package/source/class/qx/tool/{cli → compiler/cli}/ConfigDb.js

@@ -21,7 +21,7 @@ const path = require("path");
 /**
  * Controls access to the local configuration
  */
-qx.Class.define("qx.tool.cli.ConfigDb", {
+qx.Class.define("qx.tool.compiler.cli.ConfigDb", {
   extend: qx.core.Object,
 
   construct() {
@@ -45,7 +45,7 @@ qx.Class.define("qx.tool.cli.ConfigDb", {
      * Apply for path property
      * @returns
      */
-    async _applyPath(value, oldValue) {
+    _applyPath(value, oldValue) {
       this.__db = {};
     },
 
@@ -131,11 +131,11 @@ qx.Class.define("qx.tool.cli.ConfigDb", {
      * @returns {ConfigDb}
      */
     async getInstance() {
-      let db = qx.tool.cli.ConfigDb.__instance;
+      let db = qx.tool.compiler.cli.ConfigDb.__instance;
       if (!db) {
-        db = qx.tool.cli.ConfigDb.__instance = new qx.tool.cli.ConfigDb();
+        db = qx.tool.compiler.cli.ConfigDb.__instance = new qx.tool.compiler.cli.ConfigDb();
         db.setPath(
-          path.join(qx.tool.cli.ConfigDb.getDirectory(), "config.json")
+          path.join(qx.tool.compiler.cli.ConfigDb.getDirectory(), "config.json")
         );
 
         await db.load();
@@ -153,10 +153,10 @@ qx.Class.define("qx.tool.cli.ConfigDb", {
     /**
      * Wrapper for non-static version of db
      *
-     * @see qx.tool.cli.ConfigDb.db
+     * @see qx.tool.compiler.cli.ConfigDb.db
      */
     db(path, defaultValue) {
-      return qx.tool.cli.ConfigDb.getInstance().db(path, defaultValue);
+      return qx.tool.compiler.cli.ConfigDb.getInstance().db(path, defaultValue);
     }
   }
 });

package/source/class/qx/tool/compiler/cli/ConfigLoader.js

@@ -0,0 +1,272 @@
+/* ************************************************************************
+
+   qooxdoo - the new era of web development
+
+   http://qooxdoo.org
+
+   Copyright:
+     2019 The qooxdoo developers
+
+   License:
+     MIT: https://opensource.org/licenses/MIT
+     See the LICENSE file in the project's top-level directory for details.
+
+   Authors:
+     *    Henner Kollmann (Henner.Kollmann@gmx.de, @hkollmann)
+
+************************************************************************ */
+const semver = require("semver");
+const path = require("upath");
+const fs = qx.tool.utils.Promisify.fs;
+
+/**
+ * preloading of configurations
+ */
+qx.Class.define("qx.tool.compiler.cli.ConfigLoader", {
+  extend: qx.core.Object,
+  type: "singleton",
+
+  members: {
+    /** @type {CompilerApi} the CompilerApi instance */
+    __compilerApi: null,
+
+    async load() {
+      let cmd = await qx.tool.compiler.cli.Command.createCliCommand();
+      cmd.parseRoot();
+      let argv = cmd.getValues().argv;
+      /*
+       * Detect and load compile.json and compile.js
+       */
+      let defaultConfigFilename = qx.tool.config.Compile.config.fileName;
+      if (argv.configFile) {
+        process.chdir(path.dirname(argv.configFile));
+        argv.configFile = path.basename(argv.configFile);
+        defaultConfigFilename = argv.configFile;
+      }
+
+      var lockfileContent = {
+        version: qx.tool.config.Lockfile.getInstance().getVersion()
+      };
+
+      let compileJsFilename = "compile.js";
+      let compileJsonFilename = qx.tool.config.Compile.config.fileName;
+      if (defaultConfigFilename) {
+        if (defaultConfigFilename.match(/\.js$/)) {
+          compileJsFilename = defaultConfigFilename;
+        } else {
+          compileJsonFilename = defaultConfigFilename;
+        }
+      }
+
+      if (await fs.existsAsync(compileJsonFilename)) {
+        this._compileJsonFilename = compileJsonFilename;
+      }
+
+      /*
+       * Create a CompilerAPI
+       */
+
+      let CompilerApi = qx.tool.compiler.cli.api.CompilerApi;
+      if (await fs.existsAsync(compileJsFilename)) {
+        let compileJs = await this.__loadJs(compileJsFilename);
+        this._compileJsFilename = compileJsFilename;
+        if (compileJs.CompilerApi) {
+          CompilerApi = compileJs.CompilerApi;
+        }
+      }
+      let compilerApi = (this.__compilerApi = new CompilerApi().set({
+        rootDir: ".",
+        configFilename: compileJsonFilename
+      }));
+      compilerApi.addListener("changeCommand", this.__notifyLibraries, this);
+      
+      // Boot the compiler API, load the compile.json and create configuration data
+      await compilerApi.load();
+      let config = compilerApi.getConfiguration();
+
+      // Validate configuration data against the schema
+      await qx.tool.config.Compile.getInstance().load(config);
+
+      /*
+       * Open the lockfile and check versions
+       */
+      if (defaultConfigFilename) {
+        let lockfile = qx.tool.config.Lockfile.config.fileName;
+        try {
+          var name = path.join(path.dirname(defaultConfigFilename), lockfile);
+          lockfileContent =
+            (await qx.tool.utils.Json.loadJsonAsync(name)) || lockfileContent;
+        } catch (ex) {
+          // Nothing
+        }
+        // check semver-type compatibility (i.e. compatible as long as major version stays the same)
+        let schemaVersion = semver.coerce(
+          qx.tool.config.Lockfile.getInstance().getVersion(),
+          true
+        ).raw;
+        let fileVersion =
+          lockfileContent && lockfileContent.version
+            ? semver.coerce(lockfileContent.version, true).raw
+            : "1.0.0";
+        if (semver.major(schemaVersion) > semver.major(fileVersion)) {
+          if (argv.force) {
+            let config = {
+              verbose: argv.verbose,
+              quiet: argv.quiet,
+              save: false
+            };
+
+            const installer = new qx.tool.compiler.cli.commands.package.Install();
+            installer.argv = config;
+            let filepath = installer.getLockfilePath();
+            let backup = filepath + ".old";
+            await fs.copyFileAsync(filepath, backup);
+            if (!argv.quiet) {
+              qx.tool.compiler.Console.warn(
+                `*** A backup of ${lockfile} has been saved to ${backup}, in case you need to revert to it. ***`
+              );
+            }
+            await installer.deleteLockfile();
+            for (let lib of lockfileContent.libraries) {
+              if (!(await installer.isInstalled(lib.uri, lib.repo_tag))) {
+                if (lib.repo_tag) {
+                  await installer.install(lib.uri, lib.repo_tag);
+                } else if (lib.path && fs.existsSync(lib.path)) {
+                  await installer.installFromLocaPath(lib.path, lib.uri);
+                }
+              } else if (argv.verbose) {
+                qx.tool.compiler.Console.info(
+                  `>>> ${lib.uri}@${lib.repo_tag} is already installed.`
+                );
+              }
+            }
+            lockfileContent = await installer.getLockfileData();
+          } else {
+            throw new qx.tool.utils.Utils.UserError(
+              `*** Warning ***\n` +
+                `The schema of '${lockfile}' has changed. Execute 'qx clean && qx compile --force' to delete and regenerate it.\n` +
+                `You might have to re-apply manual modifications to '${lockfile}'.`
+            );
+          }
+        }
+      }
+
+      /*
+       * Locate and load libraries
+       */
+      if (!config.libraries) {
+        if (fs.existsSync("Manifest.json")) {
+          config.libraries = ["."];
+        }
+      }
+
+      if (lockfileContent.libraries) {
+        config.packages = {};
+        lockfileContent.libraries.forEach(function (library) {
+          config.libraries.push(library.path);
+          config.packages[library.uri] = library.path;
+        });
+      }
+      // check if we need to load libraries, needs more robust test
+      let needLibraries = !argv.clean;
+      // check if libraries are loaded
+      if (config.libraries && needLibraries) {
+        let neededLibraries = config.libraries.filter(
+          libData => !fs.existsSync(libData + "/Manifest.json")
+        );
+
+        if (neededLibraries.length) {
+          if (!fs.existsSync(qx.tool.config.Manifest.config.fileName)) {
+            qx.tool.compiler.Console.error(
+              "Libraries are missing and there is no Manifest.json in the current directory so we cannot attempt to install them; the missing libraries are: \n     " +
+                neededLibraries.join("\n     ")
+            );
+
+            process.exit(1);
+          }
+          qx.tool.compiler.Console.info(
+            "One or more libraries not found - trying to install them from library repository..."
+          );
+
+          const installer = new qx.tool.compiler.cli.commands.package.Install();
+
+          await installer.process({
+            quiet: true,
+            save: false
+          });
+        }
+
+        for (const aPath of config.libraries) {
+          let libCompileJsFilename = path.join(aPath, "compile.js");
+
+          let LibraryApi = qx.tool.compiler.cli.api.LibraryApi;
+          if (await fs.existsAsync(libCompileJsFilename)) {
+            let compileJs = await this.__loadJs(libCompileJsFilename);
+            if (compileJs.LibraryApi) {
+              LibraryApi = compileJs.LibraryApi;
+            }
+          }
+
+          let libraryApi = new LibraryApi().set({
+            rootDir: aPath,
+            compilerApi: compilerApi
+          });
+          compilerApi.addLibraryApi(libraryApi);
+        }
+      }
+    },
+
+    /**
+     * Loads a .js file using `require`, handling exceptions as best as possible
+     *
+     * @param aPath {String} the file to load
+     * @return {Object} the module
+     */
+    async __loadJs(aPath) {
+      try {
+        let module = require(path.resolve(aPath));
+        return module;
+      } catch (e) {
+        let lines = e.stack.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+          if (lines[i].match(/^\s+at/)) {
+            lines.splice(i);
+          }
+        }
+        let lineNumber = lines[0].split("evalmachine.<anonymous>:")[1];
+        if (lineNumber !== undefined) {
+          lines.shift();
+          throw new Error(
+            "Error while reading " +
+              aPath +
+              " at line " +
+              lineNumber +
+              "\n" +
+              lines.join("\n")
+          );
+        } else {
+          throw new Error(
+            "Error while reading " + aPath + "\n" + lines.join("\n")
+          );
+        }
+      }
+    },
+
+    async __notifyLibraries() {
+      let arr = this.getCompilerApi().getLibraryApis();
+      for (const libraryApi of arr) {
+         await libraryApi.load();
+      }
+      this.getCompilerApi().afterLibrariesLoaded();
+    },
+
+    /**
+     * Returns the CompilerApi instance
+     *
+     * @return {CompilerApi}
+     */
+    getCompilerApi() {
+      return this.__compilerApi;
+    }
+  }
+});

package/source/class/qx/tool/{cli → compiler/cli}/LibraryApplication.js

@@ -20,10 +20,10 @@
  * This is the main application class of the compiler; it does nothing
  * during startup so that it can be used as a library
  *
- * @asset(qx/tool/*)
- * @use qx.tool.cli.Cli
+ * @asset(qx/tool/compiler/*)
+ * @use qx.tool.compiler.cli.Cli
  */
-qx.Class.define("qx.tool.cli.LibraryApplication", {
+qx.Class.define("qx.tool.compiler.cli.LibraryApplication", {
   extend: qx.application.Basic,
   members: {
     main() {

package/source/class/qx/tool/compiler/cli/RootCommand.js

@@ -0,0 +1,63 @@
+/* ************************************************************************
+
+   qooxdoo - the new era of web development
+
+   http://qooxdoo.org
+
+   Copyright:
+     2017 Christian Boulanger and others
+
+   License:
+     MIT: https://opensource.org/licenses/MIT
+     See the LICENSE file in the project's top-level directory for details.
+
+   Authors:
+     * Henner Kollmann (hkollmann)
+
+************************************************************************ */
+
+/**
+ * The main command
+ */
+qx.Class.define("qx.tool.compiler.cli.RootCommand", {
+  extend: qx.tool.compiler.cli.Command,
+  statics: {
+    async createCliCommand(clazz = this) {
+      let cmd = await qx.tool.compiler.cli.Command.createCliCommand(clazz);
+      cmd.addFlag(
+        new qx.tool.cli.Flag("version").set({
+          description: " Show version number",
+          type: "boolean",
+          value: false
+        })
+      );
+
+      return cmd;
+    }
+  },
+
+  members: {
+    async process() {
+      if (this.argv.version) {
+        let title = `
+Version: v${await qx.tool.config.Utils.getQxVersion()}
+        `;
+        console.log(title);
+        return;
+      }
+
+      let title = "qooxdoo command line interface";
+      title = "\n" + title + "\n" + "=".repeat(title.length);
+
+      title += `
+Version: v${await qx.tool.config.Utils.getQxVersion()}
+`;
+      title += "\n";
+      title += `Typical usage:
+        qx <commands> [options]
+
+      Type qx <command> --help for options and subcommands.`;
+      console.log(title);
+    }
+  }
+});