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

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

@@ -64,7 +64,7 @@ qx.Class.define("qx.tool.cli.commands.package.Install", {
           },
           "save": {
             alias: "s",
-            default: true,
+            default: false,
             describe: "Save the libraries as permanent dependencies"
           },
           "from-path": {

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

@@ -99,6 +99,14 @@ qx.Class.define("qx.tool.cli.commands.package.Publish", {
       };
     }
   },
+  events: {
+    /**
+     * Fired before commit happens. Data is an object with
+     *   version: new_version,
+     *   argv: this.argv
+    */
+    "beforeCommit": "qx.event.type.Data"
+  },
 
   members: {
 
@@ -337,6 +345,12 @@ qx.Class.define("qx.tool.cli.commands.package.Publish", {
         }
       }
 
+      await this.fireDataEventAsync("beforeCommit", {
+        version: new_version,
+        argv: this.argv
+      });
+
+
       if (argv.dryrun) {
         qx.tool.compiler.Console.info(`Dry run: not creating tag and release '${tag}' of ${repo_name}...`);
         return;

package/source/class/qx/tool/compiler/ClassFile.js

@@ -43,6 +43,9 @@ function collapseMemberExpression(node) {
     if (node.type == "ThisExpression") {
       return "this";
     }
+    if (node.type == "Super") {
+      return "super";
+    }
     if (node.type == "Identifier") {
       return node.name;
     }
@@ -362,7 +365,10 @@ qx.Class.define("qx.tool.compiler.ClassFile", {
               [ require.resolve("@babel/preset-typescript") ],
               [ require.resolve("@babel/preset-react"), qx.tool.compiler.ClassFile.JSX_OPTIONS ]
             ],
-            parserOpts: { sourceType: "script" },
+            parserOpts: { 
+              allowSuperOutsideMethod: true,
+              sourceType: "script" 
+            },
             passPerPreset: true
           };
           if (extraPreset[0].plugins.length) {
@@ -780,7 +786,9 @@ qx.Class.define("qx.tool.compiler.ClassFile", {
         return meta;
       }
 
+      var es6ClassDeclarations = 0;
       var needsQxCoreEnvironment = false;
+
       var COLLECT_CLASS_NAMES_VISITOR = {
         MemberExpression(path) {
           var self = this;
@@ -794,6 +802,15 @@ qx.Class.define("qx.tool.compiler.ClassFile", {
       };
 
       const CODE_ELIMINATION_VISITOR = {
+        ClassBody: {
+          enter(path) {
+            es6ClassDeclarations++;
+          },
+          exit(path) {
+            es6ClassDeclarations--;
+          }
+        },
+
         CallExpression(path) {
           const name = collapseMemberExpression(path.node.callee);
 
@@ -921,8 +938,12 @@ qx.Class.define("qx.tool.compiler.ClassFile", {
           let nextJsonPath = jsonPath ? jsonPath + "." : "";
           node.properties.forEach(function(prop) {
             var key = prop.key.name;
-            var value = collectJson(prop.value, isProperties, nextJsonPath + key);
-            result[key] = value;
+            if (prop.type == "ObjectMethod") {
+              result[key] = "[[ ObjectMethod Function ]]";
+            } else {
+              var value = collectJson(prop.value, isProperties, nextJsonPath + key);
+              result[key] = value;
+            }
           });
         } else if (node.type == "Literal" ||
             node.type == "StringLiteral" ||
@@ -1080,6 +1101,15 @@ qx.Class.define("qx.tool.compiler.ClassFile", {
       }
 
       var CLASS_DEF_VISITOR = {
+        ClassBody: {
+          enter(path) {
+            es6ClassDeclarations++;
+          },
+          exit(path) {
+            es6ClassDeclarations--;
+          }
+        },
+
         ObjectMethod(path) {
           if (path.parentPath.parentPath != this.classDefPath) {
             path.skip();
@@ -1304,6 +1334,16 @@ qx.Class.define("qx.tool.compiler.ClassFile", {
           }
         },
 
+        // Babel seems to be suppressing ClassDeclarations...
+        ClassBody: {
+          enter(path) {
+            es6ClassDeclarations++;
+          },
+          exit(path) {
+            es6ClassDeclarations--;
+          }
+        },
+
         Literal(path) {
           if (typeof path.node.value == "string") {
             path.node.value = t.encodePrivate(path.node.value, false, path.loc);
@@ -1420,7 +1460,7 @@ qx.Class.define("qx.tool.compiler.ClassFile", {
               }
             }
 
-            if (types.isMemberExpression(path.node.callee)) {
+            if (types.isMemberExpression(path.node.callee) || (es6ClassDeclarations == 0 && (path.node.callee.object?.type == "Super" || path.node.callee.type == "Super"))) {
               let name = collapseMemberExpression(path.node.callee);
               let thisAlias = null;
 
@@ -1431,7 +1471,7 @@ qx.Class.define("qx.tool.compiler.ClassFile", {
               //    var that = this, args = arguments;
               //    (function() { that.base(args); })();
               //    ```
-              if (path.node.callee.object.type == "Identifier") {
+              if (path.node.callee.object?.type == "Identifier") {
                 let originalAlias = path.node.callee.object.name;
                 let alias = originalAlias;
                 let aliasIsThis = false;
@@ -1536,7 +1576,7 @@ qx.Class.define("qx.tool.compiler.ClassFile", {
                 path.skip();
                 path.traverse(VISITOR);
 
-              } else if (name == "this.base") {
+              } else if (name == "this.base" || (es6ClassDeclarations == 0 && (name == "super" || name.startsWith("super.")))) {
                 let expr;
 
                 // For mixins, there is never a valid time to call this.base() in the constructor; but it is
@@ -1558,10 +1598,11 @@ qx.Class.define("qx.tool.compiler.ClassFile", {
                 } else {
                   expr = expandMemberExpression(t.__classMeta.superClass + ".prototype." + t.__classMeta.functionName + ".call");
                 }
-                if (thisAlias) {
-                  path.node.arguments[0] = types.identifier(thisAlias);
+                let thisArgument = thisAlias ? types.identifier(thisAlias) : types.thisExpression();
+                if (name.startsWith("super")) {
+                  path.node.arguments.unshift(thisArgument);
                 } else {
-                  path.node.arguments[0] = types.thisExpression();
+                  path.node.arguments[0] = thisArgument;
                 }
                 let callExpr = types.callExpression(expr, path.node.arguments);
                 path.replaceWith(callExpr);
@@ -1727,25 +1768,24 @@ qx.Class.define("qx.tool.compiler.ClassFile", {
         },
 
         ObjectMethod(path) {
-          if (t.__classMeta) {
-            // Methods within a top level object (ie "members" or "statics"), record the method name and meta data
-            if (t.__classMeta._topLevel &&
-                t.__classMeta._topLevel.path == path.parentPath.parentPath) {
-              t.__classMeta.functionName = getKeyName(path.node.key);
-              makeMeta(t.__classMeta._topLevel.keyName, t.__classMeta.functionName, path.node);
-              path.skip();
-              enterFunction(path);
-              path.traverse(VISITOR);
-              exitFunction(path);
-              t.__classMeta.functionName = null;
+          // Methods within a top level object (ie "members" or "statics"), record the method name and meta data
+          if (t.__classMeta &&
+              t.__classMeta._topLevel &&
+              t.__classMeta._topLevel.path == path.parentPath.parentPath) {
+            t.__classMeta.functionName = getKeyName(path.node.key);
+            makeMeta(t.__classMeta._topLevel.keyName, t.__classMeta.functionName, path.node);
+            path.skip();
+            enterFunction(path);
+            path.traverse(VISITOR);
+            exitFunction(path);
+            t.__classMeta.functionName = null;
 
-            // Otherwise traverse method as normal
-            } else {
-              path.skip();
-              enterFunction(path);
-              path.traverse(VISITOR);
-              exitFunction(path);
-            }
+          // Otherwise traverse method as normal
+          } else {
+            path.skip();
+            enterFunction(path);
+            path.traverse(VISITOR);
+            exitFunction(path);
           }
         },
 

package/source/class/qx/tool/compiler/Es6ify.js

@@ -0,0 +1,368 @@
+/* ************************************************************************
+
+   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("path");
+const babelCore = require("@babel/core");
+
+const types = require("@babel/types");
+const babylon = require("@babel/parser");
+const prettier = require("prettier");
+
+/**
+ * Helper method that collapses the MemberExpression into a string
+ * @param node
+ * @returns {string}
+ */
+ function collapseMemberExpression(node) {
+  var done = false;
+  function doCollapse(node) {
+    if (node.type == "ThisExpression") {
+      return "this";
+    }
+    if (node.type == "Identifier") {
+      return node.name;
+    }
+    if (node.type == "ArrayExpression") {
+      var result = [];
+      node.elements.forEach(element => result.push(doCollapse(element)));
+      return result;
+    }
+    if (node.type != "MemberExpression") {
+      return "(" + node.type + ")";
+    }
+    if (types.isIdentifier(node.object)) {
+      let str = node.object.name;
+      if (node.property.name) {
+        str += "." + node.property.name;
+      } else {
+        done = true;
+      }
+      return str;
+    }
+    var str;
+    if (node.object.type == "ArrayExpression") {
+      str = "[]";
+    } else {
+      str = doCollapse(node.object);
+    }
+    if (done) {
+      return str;
+    }
+    // `computed` is set if the expression is a subscript, eg `abc[def]`
+    if (node.computed) {
+      done = true;
+    } else if (node.property.name) {
+      str += "." + node.property.name;
+    } else {
+      done = true;
+    }
+    return str;
+  }
+
+  return doCollapse(node);
+}
+
+/**
+ * Processes a .js source file and tries to upgrade to ES6 syntax
+ * 
+ * This is a reliable but fairly unintrusive upgrade, provided that `arrowFunctions` property is
+ * `careful`.  The issue is that this code: `setTimeout(function() { something(); })` can be 
+ * changed to `setTimeout(() => something())` and that is often desirable, but it also means that
+ * the `this` will be different because an arrow function always has the `this` from where the 
+ * code is written.
+ * 
+ * However, if you use an API which changes `this` then the switch to arrow functions will break 
+ * your code.  Mostly, in Qooxdoo, changes to `this` are done via an explicit API (eg 
+ * `obj.addListener("changeXyx", function() {}, this)`) and so those known APIs can be translated,
+ * but there are places which do not work this way (eg the unit tests `qx.dev.unit.TestCase.resume()`).
+ * Third party integrations are of course completely unknown.
+ * 
+ * If `arrowFunctions` is set to aggressive, then all functions are switched to arrow functions except
+ * where there is a known API that does not support it (eg any call to `.resume` in a test class); this
+ * could break your code.
+ * 
+ * If `arrowFunctions is set to `careful` (the default), then functions are only switched to arrow 
+ * functions where the API is known  (eg `.addListener`).
+ * 
+ * The final step is that the ES6ify will use https://prettier.io/ to reformat the code, and will use
+ * the nearest `prettierrc.json` for configuration
+ */
+qx.Class.define("qx.tool.compiler.Es6ify", {
+  extend: qx.core.Object,
+
+  construct(filename) {
+    this.base(arguments);
+    this.__filename = filename;
+  },
+
+  properties: {
+    /** Whether to convert functions to arrow functions; careful means only on things like addListener callbacks */
+    arrowFunctions: {
+      init: "careful",
+      check: [ "never", "always", "careful", "aggressive" ],
+      nullable: true
+    },
+
+    /** Whether to overwrite the original file */
+    overwrite: {
+      init: false,
+      check: "Boolean"
+    }
+  },
+
+  members: {
+    __filename: null,
+
+    async transform() {
+      let src = await fs.promises.readFile(this.__filename, "utf8");
+
+      let babelConfig = {};
+      let options = qx.lang.Object.clone(babelConfig.options || {}, true);
+      options.modules = false;
+      let plugins = [
+        require("@babel/plugin-syntax-jsx"),
+        this.__pluginFunctionExpressions()
+      ];
+      if (this.getArrowFunctions() != "never") {
+        plugins.push(this.__pluginArrowFunctions());
+      }
+      plugins.push(this.__pluginRemoveUnnecessaryThis());
+      plugins.push(this.__pluginSwitchToSuper());
+      var config = {
+        ast: true,
+        babelrc: false,
+        sourceFileName: this.__filename,
+        filename: this.__filename,
+        sourceMaps: false,
+        presets: [
+          [
+            {
+              plugins: plugins
+            }
+          ]
+        ],
+        parserOpts: { 
+          allowSuperOutsideMethod: true,
+          sourceType: "script" 
+        },
+        generatorOpts: {
+          retainLines: true
+        },
+        passPerPreset: true
+      };
+      let result = babelCore.transform(src, config);
+
+      let prettierConfig = await prettier.resolveConfig(this.__filename, { editorConfig: true })||{};
+      prettierConfig.parser = "babel";
+      let prettyCode = prettier.format(result.code, prettierConfig);
+      
+      let outname = this.__filename + (this.isOverwrite() ? "" : ".es6ify");
+      await fs.promises.writeFile(outname, prettyCode, "utf8");
+    },
+
+    /**
+     * Plugin that converts object properties which are functions into object methods, eg
+     * ```
+     * {
+     *   myMethod: function() {}
+     * }
+     * ```
+     * becomes
+     * ```
+     * {
+     *   myMethod() {}
+     * }
+     * ```
+     * @returns 
+     */
+    __pluginFunctionExpressions() {
+      return {
+        visitor: {
+          ObjectExpression(path) {
+            for (let i = 0; i < path.node.properties.length; i++) {
+              let propNode = path.node.properties[i];
+              if (
+                propNode.type == "ObjectProperty" &&
+                propNode.value.type == "FunctionExpression"
+              ) {
+                let replacement = types.objectMethod(
+                  "method",
+                  propNode.key,
+                  propNode.value.params,
+                  propNode.value.body,
+                  propNode.value.computed,
+                  propNode.value.generator,
+                  propNode.value.async
+                );
+                replacement.loc = propNode.loc;
+                replacement.start = propNode.start;
+                replacement.end = propNode.end;
+                replacement.leadingComments = propNode.leadingComments;
+                path.node.properties[i] = replacement;
+              }
+            }
+          }
+        }
+      };
+    },
+
+    __toArrowExpression(argNode) {
+      let body = argNode.body;
+      if (body.body.length == 1 && body.body[0].type == "ReturnStatement") {
+        body = body.body[0].argument;
+      }
+      let replacement = types.arrowFunctionExpression(
+        argNode.params,
+        body,
+        argNode.async
+      );
+      replacement.loc = argNode.loc;
+      replacement.start = argNode.start;
+      replacement.end = argNode.end;
+      replacement.leadingComments = argNode.leadingComments;
+      return replacement;
+    },
+
+    /**
+     * Tries to convert functions into arrow functions
+     * @returns 
+     */
+    __pluginArrowFunctions() {
+      let t = this;
+      const isTest = this.__filename.indexOf("/test/") > -1;
+      let arrowFunctions = this.getArrowFunctions();
+
+      return {
+        visitor: {
+          CallExpression(path) {
+            if (path.node.callee.type == "MemberExpression") {
+              let callee = collapseMemberExpression(path.node.callee);
+              if (arrowFunctions == "careful") {
+                if (!callee.endsWith(".addListener")) {
+                  return;
+                }
+                if (
+                  path.node.arguments.length != 3 ||
+                  path.node.arguments[0].type != "StringLiteral" ||
+                  path.node.arguments[1].type != "ArrowFunctionExpression" ||
+                  path.node.arguments[2].type != "ThisExpression"
+                ) {
+                  return;
+                }
+    
+              } else if (arrowFunctions == "aggressive") {
+                if (callee == "qx.event.GlobalError.observeMethod" || 
+                    callee == "this.assertException" || 
+                    callee == "this.assertEventFired" || 
+                    callee == "qx.core.Assert.assertEventFired" ||
+                    (isTest && callee.endsWith(".resume"))) {
+                  return;
+                }
+              }
+            } else if (arrowFunctions == "careful") {
+              return;
+            }
+            for (let i = 0; i < path.node.arguments.length; i++){
+              let argNode = path.node.arguments[i];
+              if (argNode.type == "FunctionExpression") {
+                path.node.arguments[i] = t.__toArrowExpression(argNode);
+              }
+            }
+          }
+        }
+      }
+    },
+
+    /**
+     * Where a function has been translated into an arrow function, the this binding is not needed
+     * and can be removed
+     * @returns 
+     */
+    __pluginRemoveUnnecessaryThis() {
+      return {
+        visitor: {
+          CallExpression(path) {
+            if (
+              path.node.callee.type == "MemberExpression" &&
+              path.node.callee.object.type == "ThisExpression" &&
+              path.node.callee.property.type == "Identifier" &&
+              path.node.callee.property.name == "addListener" &&
+              path.node.arguments.length == 3 &&
+              path.node.arguments[0].type == "StringLiteral" &&
+              path.node.arguments[1].type == "ArrowFunctionExpression" &&
+              path.node.arguments[2].type == "ThisExpression"
+            ) {
+              qx.lang.Array.removeAt(path.node.arguments, 2);
+            }
+          }
+        }
+      }
+    },
+
+    /**
+     * Translates `this.base(arguments...)` into `super`
+     * @returns 
+     */
+    __pluginSwitchToSuper() {
+      let methodNameStack = [];
+      function peekMethodName() {
+        for (let i = methodNameStack.length - 1; i >= 0; i--) {
+          let methodName = methodNameStack[i];
+          if (methodName) {
+            return methodName;
+          }
+        }
+        return null;
+      }
+      return {
+        visitor: {
+          ObjectMethod: {
+            enter(path) {
+              methodNameStack.push(path.node.key.name||null);
+            },
+            exit(path) {
+              methodNameStack.pop();
+            }
+          },
+          CallExpression(path) {
+            if (
+              path.node.callee.type == "MemberExpression" &&
+              path.node.callee.object.type == "ThisExpression" &&
+              path.node.callee.property.type == "Identifier" &&
+              path.node.callee.property.name == "base" &&
+              path.node.arguments.length >= 1
+            ) {
+              let args = qx.lang.Array.clone(path.node.arguments);
+              args.shift();
+              let methodName = peekMethodName();
+              if (methodName == "construct") {
+                path.node.callee = types.super();
+                path.node.arguments = args;
+              } else if (methodName) {
+                let replacement = types.memberExpression(types.super(), types.identifier(methodName), false, false);
+                path.node.callee = replacement;
+                path.node.arguments = args;
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+});

package/source/class/qx/tool/compiler/makers/AppMaker.js

@@ -86,7 +86,8 @@ qx.Class.define("qx.tool.compiler.makers.AppMaker", {
         },
         this.getEnvironment(),
         target.getDefaultEnvironment(),
-        target.getEnvironment());
+        target.getEnvironment()
+      );
 
       let preserve = target.getPreserveEnvironment();
       if (preserve) {