@qooxdoo/framework 7.9.2 → 8.0.0-beta.2

package/source/class/qx/tool/compiler/cli/commands/Prettier.js

@@ -0,0 +1,278 @@
+/* ************************************************************************
+
+   qooxdoo - the new era of web development
+
+   http://qooxdoo.org
+
+   Copyright:
+     2025 Henner Kollmann 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 (Henner.Kollmann@gmx.de, @hkollmann)
+
+************************************************************************ */
+
+const fs = require("fs");
+const path = require("upath");
+const prettier = require("prettier");
+const ignore = require("ignore");
+
+/**
+ * Formats code using Prettier
+ */
+qx.Class.define("qx.tool.compiler.cli.commands.Prettier", {
+  extend: qx.tool.compiler.cli.Command,
+
+  statics: {
+    async createCliCommand(clazz = this) {
+      let cmd = await qx.tool.compiler.cli.Command.createCliCommand(clazz);
+      cmd.set({
+        name: "prettier",
+        description: "formats code using Prettier"
+      });
+
+      cmd.addArgument(
+        new qx.tool.cli.Argument("files").set({
+          description: "files to format",
+          array: true,
+          type: "string"
+        })
+      );
+
+      cmd.addFlag(
+        new qx.tool.cli.Flag("check").set({
+          description: "Check if files are formatted (don't write)",
+          type: "boolean",
+          value: false
+        })
+      );
+
+      cmd.addFlag(
+        new qx.tool.cli.Flag("write").set({
+          description: "Write formatted files",
+          type: "boolean",
+          value: true
+        })
+      );
+
+      cmd.addFlag(
+        new qx.tool.cli.Flag("gitPreCommit").set({
+          description: "When used as a Git pre-commit hook",
+          type: "boolean",
+          value: false
+        })
+      );
+
+      return cmd;
+    }
+  },
+
+  members: {
+    async process() {
+      const ignoreFileName = ".prettierignore";
+      const ig = ignore();
+
+      // Load .prettierignore file if it exists
+      try {
+        const ignoreContent = await fs.promises.readFile(ignoreFileName, "utf8");
+        ig.add(ignoreContent);
+      } catch (err) {
+        if (err.code !== "ENOENT") {
+          throw err;
+        }
+      }
+
+      // Track formatting results
+      let totalFiles = 0;
+      let formattedFiles = 0;
+      let unformattedFiles = [];
+
+      /**
+       * Process a single file with Prettier
+       */
+      const processFile = async filename => {
+        // Get relative path for ignore checking
+        const relativePath = path.relative(process.cwd(), filename);
+
+        // Check if file should be ignored (only for files within project)
+        if (!relativePath.startsWith("..") && ig.ignores(relativePath)) {
+          if (this.argv.verbose) {
+            qx.tool.compiler.Console.info(`Ignoring ${relativePath}`);
+          }
+          return;
+        }
+
+        totalFiles++;
+
+        try {
+          // Read file content
+          const content = await fs.promises.readFile(filename, "utf8");
+
+          // Resolve prettier configuration
+          let prettierConfig = await prettier.resolveConfig(filename, {
+            editorConfig: true
+          });
+
+          if (!prettierConfig) {
+            prettierConfig = {};
+          }
+
+          // Determine parser based on file extension
+          const ext = path.extname(filename);
+          if (ext === ".js") {
+            prettierConfig.parser = "babel";
+          } else if (ext === ".json") {
+            prettierConfig.parser = "json";
+          } else if (ext === ".md") {
+            prettierConfig.parser = "markdown";
+          }
+
+          // Check if file is already formatted
+          const isFormatted = await prettier.check(content, prettierConfig);
+
+          if (!isFormatted) {
+            unformattedFiles.push(filename);
+
+            if (this.argv.check) {
+              qx.tool.compiler.Console.warn(`${filename} is not formatted`);
+            } else if (this.argv.write) {
+              // Format and write the file
+              const formatted = await prettier.format(content, prettierConfig);
+              await fs.promises.writeFile(filename, formatted, "utf8");
+              formattedFiles++;
+              qx.tool.compiler.Console.info(`Formatted ${filename}`);
+            }
+          } else if (this.argv.verbose) {
+            qx.tool.compiler.Console.info(`${filename} is already formatted`);
+          }
+        } catch (err) {
+          qx.tool.compiler.Console.error(`Error processing ${filename}: ${err.message}`);
+          throw err;
+        }
+      };
+
+      /**
+       * Recursively scan directories for JavaScript files
+       */
+      const scanImpl = async filename => {
+        try {
+          const stat = await fs.promises.stat(filename);
+          const basename = path.basename(filename);
+
+          if (stat.isFile() && basename.match(/\.js$/)) {
+            await processFile(filename);
+          } else if (
+            stat.isDirectory() &&
+            (basename === "." || basename[0] !== ".")
+          ) {
+            const files = await fs.promises.readdir(filename);
+            for (let i = 0; i < files.length; i++) {
+              const subname = path.join(filename, files[i]);
+              await scanImpl(subname);
+            }
+          }
+        } catch (err) {
+          if (err.code !== "ENOENT") {
+            throw err;
+          }
+        }
+      };
+
+      // Handle git pre-commit hook mode
+      if (this.argv.gitPreCommit) {
+        let result = await qx.tool.utils.Utils.runCommand(
+          process.cwd(),
+          "git",
+          "diff",
+          "--cached",
+          "--name-only",
+          "--diff-filter=ACMR"
+        );
+
+        if (result.exitCode !== 0) {
+          qx.tool.compiler.Console.error(
+            `Failed to run 'git diff': ${JSON.stringify(result, null, 2)}`
+          );
+          process.exit(1);
+          return;
+        }
+
+        const lines = result.output
+          .split(/\n/)
+          .filter(str => !!str.match(/^source\/class\/.*\.js$/));
+
+        for (let filename of lines) {
+          await processFile(filename);
+
+          if (!this.argv.check && this.argv.write) {
+            // Add formatted file back to git staging
+            result = await qx.tool.utils.Utils.runCommand(
+              process.cwd(),
+              "git",
+              "add",
+              filename
+            );
+
+            if (result.exitCode !== 0) {
+              qx.tool.compiler.Console.error(
+                `Failed to run 'git add ${filename}': ${JSON.stringify(
+                  result,
+                  null,
+                  2
+                )}`
+              );
+              process.exit(1);
+              return;
+            }
+          }
+        }
+
+        // Exit with error if in check mode and files are unformatted
+        if (this.argv.check && unformattedFiles.length > 0) {
+          process.exit(1);
+        } else {
+          process.exit(0);
+        }
+      }
+
+      // Process files from arguments or default to source directory
+      let files = this.argv.files || [];
+      if (files.length === 0) {
+        files.push("source");
+      }
+
+      for (const file of files) {
+        await scanImpl(file);
+      }
+
+      // Print summary
+      qx.tool.compiler.Console.info(`\nProcessed ${totalFiles} file(s)`);
+
+      if (this.argv.check) {
+        if (unformattedFiles.length > 0) {
+          qx.tool.compiler.Console.error(
+            `${unformattedFiles.length} file(s) are not formatted:`
+          );
+          for (const file of unformattedFiles) {
+            qx.tool.compiler.Console.error(`  - ${file}`);
+          }
+          throw new qx.tool.utils.Utils.UserError(
+            `${unformattedFiles.length} file(s) need formatting`
+          );
+        } else {
+          qx.tool.compiler.Console.info("All files are formatted!");
+        }
+      } else if (this.argv.write) {
+        if (formattedFiles > 0) {
+          qx.tool.compiler.Console.info(`Formatted ${formattedFiles} file(s)`);
+        } else {
+          qx.tool.compiler.Console.info("All files were already formatted!");
+        }
+      }
+    }
+  }
+});

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

@@ -22,37 +22,41 @@ const process = require("process");
 /**
  * Runs a server application
  */
-qx.Class.define("qx.tool.cli.commands.Run", {
-  extend: qx.tool.cli.commands.Compile,
+qx.Class.define("qx.tool.compiler.cli.commands.Run", {
+  extend: qx.tool.compiler.cli.commands.Compile,
 
   statics: {
-    YARGS_BUILDER: {
-      inspect: {
-        describe:
-          "Whether to start node for debugging (ie with the --inspect argument)",
-        type: "boolean",
-        default: false
-      },
+    async createCliCommand(clazz = this) {
+      let cmd = await qx.tool.compiler.cli.commands.Compile.createCliCommand(clazz);
+      cmd.set({
+        name: "run",
+        description: "runs a server application (written in node) with continuous compilation, using compile.json"
+      });
 
-      "inspect-brk": {
-        describe:
-          "Whether to start node for debugging and break immediately (ie with the --inspect-brk argument)",
-        type: "boolean",
-        default: false
-      }
-    },
-
-    getYargsCommand() {
-      return {
-        command: "run [configFile]",
-        describe:
-          "runs a server application (written in node) with continuous compilation, using compile.json",
-        builder: Object.assign(
-          {},
-          qx.tool.cli.commands.Compile.YARGS_BUILDER,
-          qx.tool.cli.commands.Run.YARGS_BUILDER
-        )
-      };
+      cmd.addArgument(
+        new qx.tool.cli.Argument("configFile").set({
+          description: "config file to use",
+          type: "string"
+        })
+      );
+
+      cmd.addFlag(
+        new qx.tool.cli.Flag("inspect").set({
+          description: "Whether to start node for debugging (ie with the --inspect argument)",
+          type: "boolean",
+          value: false
+        })
+      );
+
+      cmd.addFlag(
+        new qx.tool.cli.Flag("inspect-brk").set({
+          description: "Whether to start node for debugging and break immediately (ie with the --inspect-brk argument)",
+          type: "boolean",
+          value: false
+        })
+      );
+
+      return cmd;
     }
   },
 
@@ -67,12 +71,12 @@ qx.Class.define("qx.tool.cli.commands.Run", {
       await super.process();
       let config = this.getCompilerApi().getConfiguration();
       if (!config.run) {
-        qx.tool.compiler.Console.print("qx.tool.cli.run.noRunConfig");
+        qx.tool.compiler.Console.print("qx.tool.compiler.cli.run.noRunConfig");
         process.exit(1);
       }
 
       if (!config.run.application) {
-        qx.tool.compiler.Console.print("qx.tool.cli.run.noAppName");
+        qx.tool.compiler.Console.print("qx.tool.compiler.cli.run.noAppName");
         process.exit(1);
       }
 
@@ -84,12 +88,12 @@ qx.Class.define("qx.tool.cli.commands.Run", {
           .filter(app => app.getName() == config.run.application);
         if (apps.length) {
           if (maker) {
-            qx.tool.compiler.Console.print("qx.tool.cli.run.tooManyMakers");
+            qx.tool.compiler.Console.print("qx.tool.compiler.cli.run.tooManyMakers");
             process.exit(1);
           }
           if (apps.length != 1) {
             qx.tool.compiler.Console.print(
-              "qx.tool.cli.run.tooManyApplications"
+              "qx.tool.compiler.cli.run.tooManyApplications"
             );
 
             process.exit(1);
@@ -99,11 +103,11 @@ qx.Class.define("qx.tool.cli.commands.Run", {
         }
       });
       if (!app) {
-        qx.tool.compiler.Console.print("qx.tool.cli.run.noAppName");
+        qx.tool.compiler.Console.print("qx.tool.compiler.cli.run.noAppName");
         process.exit(1);
       }
       if (app.getType() != "node") {
-        qx.tool.compiler.Console.print("qx.tool.cli.run.mustBeNode");
+        qx.tool.compiler.Console.print("qx.tool.compiler.cli.run.mustBeNode");
         process.exit(1);
       }
 
@@ -169,15 +173,15 @@ qx.Class.define("qx.tool.cli.commands.Run", {
   defer(statics) {
     qx.tool.compiler.Console.addMessageIds(
       {
-        "qx.tool.cli.run.noRunConfig":
+        "qx.tool.compiler.cli.run.noRunConfig":
           "Cannot run anything because the config.json does not have a `run` configuration",
-        "qx.tool.cli.run.noAppName":
+        "qx.tool.compiler.cli.run.noAppName":
           "Cannot run anything because the config.json does not specify a unique application name",
-        "qx.tool.cli.run.mustBeNode":
+        "qx.tool.compiler.cli.run.mustBeNode":
           "The application %1 is not a node application (only node applications are supported)",
-        "qx.tool.cli.run.tooManyMakers":
+        "qx.tool.compiler.cli.run.tooManyMakers":
           "Cannot run anything because multiple targets are detected",
-        "qx.tool.cli.run.tooManyApplications":
+        "qx.tool.compiler.cli.run.tooManyApplications":
           "Cannot run anything because multiple applications are detected"
       },
 

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

@@ -25,51 +25,49 @@ require("app-module-path").addPath(process.cwd() + "/node_modules");
 /**
  * Compiles the project and serves it up as a web page
  */
-qx.Class.define("qx.tool.cli.commands.Serve", {
-  extend: qx.tool.cli.commands.Compile,
+qx.Class.define("qx.tool.compiler.cli.commands.Serve", {
+  extend: qx.tool.compiler.cli.commands.Compile,
 
   statics: {
-    YARGS_BUILDER: {
-      "listen-port": {
-        alias: "p",
-        describe: "The port for the web browser to listen on",
-        type: "number",
-        default: 8080
-      },
-
-      "show-startpage": {
-        alias: "S",
-        describe:
-          "Show the startpage with the list of applications and additional information",
-        type: "boolean",
-        default: null
-      },
-
-      "rebuild-startpage": {
-        alias: "R",
-        describe:
-          "Rebuild the startpage with the list of applications and additional information",
-        type: "boolean",
-        default: false
-      }
-    },
+    async createCliCommand(clazz = this) {
+      let cmd = await qx.tool.compiler.cli.commands.Compile.createCliCommand(clazz);
+      cmd.set({
+        name: "serve",
+        description: "runs a webserver to run the current application with continuous compilation, using compile.json"
+      });
 
-    getYargsCommand() {
-      return {
-        command: "serve",
-        describe:
-          "runs a webserver to run the current application with continuous compilation, using compile.json",
-        builder: (() => {
-          let res = Object.assign(
-            {},
-            qx.tool.cli.commands.Compile.YARGS_BUILDER,
-            qx.tool.cli.commands.Serve.YARGS_BUILDER
-          );
+      // Remove watch flag since serve doesn't use it
+      cmd.removeFlag("watch");
+
+      // Add serve-specific flags
+      cmd.addFlag(
+        new qx.tool.cli.Flag("listen-port").set({
+          shortCode: "p",
+          description: "The port for the web browser to listen on",
+          type: "integer",
+          value: 8080
+        })
+      );
+
+      cmd.addFlag(
+        new qx.tool.cli.Flag("show-startpage").set({
+          shortCode: "S",
+          description: "Show the startpage with the list of applications and additional information",
+          type: "boolean",
+          value: false
+        })
+      );
 
-          delete res.watch;
-          return res;
-        })()
-      };
+      cmd.addFlag(
+        new qx.tool.cli.Flag("rebuild-startpage").set({
+          shortCode: "R",
+          description: "Rebuild the startpage with additional information",
+          type: "boolean",
+          value: false
+        })
+      );
+
+      return cmd;
     }
   },
 
@@ -97,14 +95,18 @@ qx.Class.define("qx.tool.cli.commands.Serve", {
       this.argv.watch = true;
       this.argv["machine-readable"] = false;
       this.argv["feedback"] = false;
-
-      // build website if it hasn't been built yet.
-      const website = new qx.tool.utils.Website();
-      if (!(await fs.existsAsync(website.getTargetDir()))) {
-        qx.tool.compiler.Console.info(">>> Building startpage...");
-        await website.rebuildAll();
-      } else if (this.argv.rebuildStartpage) {
-        website.startWatcher();
+      this.__website = new qx.tool.utils.Website();
+      if (this.argv.rebuildStartpage) {
+          qx.tool.compiler.Console.info(">>> Building startpage and exit...");
+          await this.__website.generateSite();
+          return;
+      }
+      if (this.argv["show-startpage"]) {
+        // build website if it hasn't been built yet or if rebuild is requested
+        if (!(await fs.existsAsync(this.__website.getTargetDir()))) {
+          qx.tool.compiler.Console.info(">>> Building startpage...");
+          await this.__website.generateSite();
+        }
       }
       this.addListenerOnce("made", () => {
         this.runWebServer();
@@ -153,7 +155,6 @@ qx.Class.define("qx.tool.cli.commands.Serve", {
       if (this.__showStartpage === undefined || this.__showStartpage === null) {
         this.__showStartpage = defaultMaker === null;
       }
-      let config = this.getCompilerApi().getConfiguration();
       const app = express();
       app.use((req, res, next) => {
         res.set({
@@ -167,7 +168,6 @@ qx.Class.define("qx.tool.cli.commands.Serve", {
 
         next();
       });
-      const website = new qx.tool.utils.Website();
       if (!this.__showStartpage) {
         app.use("/", express.static(defaultMaker.getTarget().getOutputDir()));
       } else {
@@ -177,7 +177,7 @@ qx.Class.define("qx.tool.cli.commands.Serve", {
         }
         app.use("/docs", express.static(path.join(s, "docs")));
         app.use("/apps", express.static(path.join(s, "apps")));
-        app.use("/", express.static(website.getTargetDir()));
+        app.use("/", express.static(this.__website.getTargetDir()));
         var appsData = [];
         makers.forEach(maker => {
           let target = maker.getTarget();
@@ -208,6 +208,8 @@ qx.Class.define("qx.tool.cli.commands.Serve", {
           res.send(JSON.stringify(appsData, null, 2));
         });
       }
+      let config = this.getCompilerApi().getConfiguration();
+      let listenPort = this.argv.listenPort ?? config?.serve?.listenPort;
       let server = http.createServer(app);
       this.fireDataEvent("beforeStart", {
         server: server,
@@ -217,32 +219,32 @@ qx.Class.define("qx.tool.cli.commands.Serve", {
       server.on("error", e => {
         if (e.code === "EADDRINUSE") {
           qx.tool.compiler.Console.print(
-            "qx.tool.cli.serve.webAddrInUse",
-            config.serve.listenPort
+            "qx.tool.compiler.cli.serve.webAddrInUse",
+            listenPort
           );
-
           process.exit(1);
         } else {
           qx.tool.compiler.Console.log("Error when starting web server: " + e);
         }
       });
-      server.listen(config.serve.listenPort, () => {
+      server.listen(listenPort, () => {
         qx.tool.compiler.Console.print(
-          "qx.tool.cli.serve.webStarted",
-          "http://localhost:" + config.serve.listenPort
+          "qx.tool.compiler.cli.serve.webStarted",
+          "http://localhost:" + listenPort
         );
 
         this.fireEvent("afterStart");
       });
     },
 
-    __showStartpage: null
+    __showStartpage: null,
+    __website: null
   },
 
   defer(statics) {
     qx.tool.compiler.Console.addMessageIds({
-      "qx.tool.cli.serve.webStarted": "Web server started, please browse to %1",
-      "qx.tool.cli.serve.webAddrInUse":
+      "qx.tool.compiler.cli.serve.webStarted": "Web server started, please browse to %1",
+      "qx.tool.compiler.cli.serve.webAddrInUse":
         "Web server cannot start because port %1 is already in use"
     });
   }