Add support for runtime data (#32)

Add support for runtime data, more details at: #17

Author: ssutar

package.json

@@ -9,6 +9,7 @@
   "keywords": [
     "codemod-cli"
   ],
+  "license": "MIT",
   "dependencies": {
     "codemod-cli": "ssutar/codemod-cli",
     "minimatch": "^3.0.4",

transforms/ember-object/__testfixtures__/decorators.output.js

@@ -1,4 +1,4 @@
-import { layout, className, classNames, tagName, attribute } from "@ember-decorators/component";
+import { attribute, className, classNames, layout, tagName } from "@ember-decorators/component";
 import { sum as add, overridableReads as enoWay, overridableReads, reads, alias } from "@ember-decorators/object/computed";
 import { get, set } from "@ember/object";
 import { action, readOnly, volatile, computed, observes as watcher } from "@ember-decorators/object";
@@ -36,7 +36,13 @@ class Foo extends EmberObject {
 
   @action
   baz() {
-    super.baz(...arguments);
+    // TODO: This call to super is within an action, and has to refer to the parent
+    // class's actions to be safe. This should be refactored to call a normal method
+    // on the parent class. If the parent class has not been converted to native
+    // classes, it may need to be refactored as well. See
+    // https: //github.com/scalvert/ember-es6-class-codemod/blob/master/README.md
+    // for more details.
+    super.actions.baz.call(this, ...arguments);
   }
 
   @action

transforms/ember-object/__testfixtures__/runtime.data.json

@@ -0,0 +1,17 @@
+{
+  "data": [
+    {
+      "./transforms/ember-object/__testfixtures__/runtime.input.js": {
+        "computedProperties": [],
+        "observedProperties": [],
+        "observerProperties": {},
+        "offProperties": { "offProp": ["prop1", "prop2"] },
+        "overriddenActions": ["overriddenActionMethod"],
+        "overriddenProperties": ["overriddenMethod"],
+        "ownProperties": [],
+        "type": "EmberObject",
+        "unobservedProperties": { "unobservedProp": ["prop3", "prop4"] }
+      }
+    }
+  ]
+}

transforms/ember-object/__testfixtures__/runtime.input.js

@@ -0,0 +1,51 @@
+/**
+ * Program comments
+ */
+const Foo = Test.extend(MyMixin, {
+  /**
+   * Property comments
+   */
+  prop: "defaultValue",
+  boolProp: true,
+  numProp: 123,
+  [MY_VAL]: "val",
+  queryParams: {},
+
+  unobservedProp: null,
+  offProp: null,
+
+  /**
+   * Method comments
+   */
+  method() {
+    // do things
+  },
+
+  otherMethod: function() {},
+
+  get accessor() {
+    return this._value;
+  },
+
+  set accessor(value) {
+    this._value = value;
+  },
+
+  anotherMethod() {
+    this._super(...arguments);
+  },
+
+  overriddenMethod() {
+    this._super(...arguments);
+  },
+
+  actions: {
+    actionMethod() {
+      this._super(...arguments) && this.boolProp;
+    },
+
+    overriddenActionMethod() {
+      this._super(...arguments) && this.boolProp;
+    }
+  }
+});

transforms/ember-object/__testfixtures__/runtime.options.json

@@ -0,0 +1,4 @@
+{
+  "decorators": true,
+  "runtime-config-path": "./transforms/ember-object/__testfixtures__/runtime.data.json"
+}

transforms/ember-object/__testfixtures__/runtime.output.js

@@ -0,0 +1,63 @@
+import { action, off, unobserves } from "@ember-decorators/object";
+
+/**
+ * Program comments
+ */
+class Foo extends Test.extend(MyMixin) {
+  /**
+   * Property comments
+   */
+  prop = "defaultValue";
+
+  boolProp = true;
+  numProp = 123;
+  [MY_VAL] = "val";
+  queryParams = {};
+
+  @unobserves("prop3", "prop4")
+  unobservedProp;
+
+  @off("prop1", "prop2")
+  offProp;
+
+  /**
+   * Method comments
+   */
+  method() {
+    // do things
+  }
+
+  otherMethod() {}
+
+  get accessor() {
+    return this._value;
+  }
+
+  set accessor(value) {
+    this._value = value;
+  }
+
+  anotherMethod() {
+    undefined;
+  }
+
+  overriddenMethod() {
+    super.overriddenMethod(...arguments);
+  }
+
+  @action
+  actionMethod() {
+    undefined && this.boolProp;
+  }
+
+  @action
+  overriddenActionMethod() {
+    // TODO: This call to super is within an action, and has to refer to the parent
+    // class's actions to be safe. This should be refactored to call a normal method
+    // on the parent class. If the parent class has not been converted to native
+    // classes, it may need to be refactored as well. See
+    // https: //github.com/scalvert/ember-es6-class-codemod/blob/master/README.md
+    // for more details.
+    super.actions.overriddenActionMethod.call(this, ...arguments) && this.boolProp;
+  }
+}

transforms/ember-object/index.js

@@ -1,16 +1,23 @@
 const { getOptions } = require("codemod-cli");
 const { replaceEmberObjectExpressions } = require("../helpers/parse-helper");
+const { getRuntimeData } = require("../helpers/util");
 
-module.exports = function transformer(file, api, options) {
+module.exports = function transformer(file, api, opts) {
   const j = api.jscodeshift;
-  const root = j(file.source);
+  const options = Object.assign({}, opts, getOptions());
+  let { source, path } = file;
+  const runtimeConfigPath = options["runtime-config-path"];
 
-  replaceEmberObjectExpressions(
-    j,
-    root,
-    file.path,
-    Object.assign({}, options, getOptions())
-  );
+  if (runtimeConfigPath) {
+    options.runtimeData = getRuntimeData(runtimeConfigPath, path);
+    if (!options.runtimeData) {
+      return;
+    }
+  }
+
+  const root = j(source);
+
+  replaceEmberObjectExpressions(j, root, path, options);
 
   return root.toSource();
 };

transforms/helpers/EOProp.js

@@ -16,6 +16,7 @@ class EOProp {
     this._prop = eoProp;
     this.decoratorNames = [];
     this.modifiers = [];
+    this.decoratorArgs = {};
   }
 
   get value() {
@@ -118,6 +119,18 @@ class EOProp {
     return this.decoratorNames.includes("attribute");
   }
 
+  get hasUnobservesDecorator() {
+    return this.decoratorNames.includes("unobserves");
+  }
+
+  get hasOffDecorator() {
+    return this.decoratorNames.includes("off");
+  }
+
+  get hasRuntimeData() {
+    return !!this.runtimeType;
+  }
+
   setCallExpressionProps() {
     let calleeObject = get(this._prop, "value");
     const modifiers = [getModifier(calleeObject)];
@@ -158,6 +171,36 @@ class EOProp {
       this.value.name = value;
     }
   }
+
+  setRuntimeData({
+    // computedProperties = [],
+    // observedProperties = [],
+    // observerProperties = {},
+    offProperties = {},
+    overriddenActions = [],
+    overriddenProperties = [],
+    // ownProperties = [],
+    type = "",
+    unobservedProperties = {}
+  }) {
+    if (!type) {
+      return;
+    }
+    const name = this.name;
+    if (Object.keys(unobservedProperties).includes(name)) {
+      this.decoratorNames.push("unobserves");
+      this.decoratorArgs["unobserves"] = unobservedProperties[name];
+    }
+    if (Object.keys(offProperties).includes(name)) {
+      this.decoratorNames.push("off");
+      this.decoratorArgs["off"] = offProperties[name];
+    }
+    if (this.isAction) {
+      this.overriddenActions = overriddenActions;
+    }
+    this.isOverridden = overriddenProperties.includes(name);
+    this.runtimeType = type;
+  }
 }
 
 module.exports = EOProp;

transforms/helpers/decorator-helper.js

@@ -65,14 +65,25 @@ function createCallExpressionDecorators(j, decoratorName, instanceProp) {
   );
 }
 
+function createDecoratorsWithArgs(j, identifier, args) {
+  return [
+    j.decorator(
+      j.callExpression(
+        j.identifier(identifier),
+        args.map(arg => j.literal(arg))
+      )
+    )
+  ];
+}
+
 /**
  * Create `@action` decorator
  *
  * @param {Object} j - jscodeshift lib reference
  * @returns {Decorator[]}
  */
-function createActionDecorators(j) {
-  return [j.decorator(j.identifier("action"))];
+function createIdentifierDecorators(j, identifier = "action") {
+  return [j.decorator(j.identifier(identifier))];
 }
 
 /**
@@ -102,25 +113,39 @@ function createBindingDecorators(j, decoratorName, instanceProp) {
  * @returns {Decorator[]}
  */
 function createInstancePropDecorators(j, instanceProp) {
-  return instanceProp.decoratorNames.reduce((decorators, decoratorName) => {
-    if (!decoratorName) {
+  return instanceProp.decoratorNames.reduce((decorators, decorator) => {
+    if (!decorator) {
       return decorators;
     }
-    if (decoratorName === "className" || decoratorName === "attribute") {
+    if (decorator === "className" || decorator === "attribute") {
+      return decorators.concat(
+        createBindingDecorators(j, decorator, instanceProp)
+      );
+    }
+    if (decorator === "off" || decorator === "unobserves") {
       return decorators.concat(
-        createBindingDecorators(j, decoratorName, instanceProp)
+        createDecoratorsWithArgs(
+          j,
+          decorator,
+          instanceProp.decoratorArgs[decorator]
+        )
       );
     }
     return decorators.concat(
-      createCallExpressionDecorators(j, decoratorName, instanceProp)
+      createCallExpressionDecorators(
+        j,
+        decorator,
+        instanceProp,
+        instanceProp.decoratorArgs[decorator]
+      )
     );
   }, []);
 }
 
 module.exports = {
   withDecorators,
   createClassDecorator,
-  createActionDecorators,
+  createIdentifierDecorators,
   createCallExpressionDecorators,
   createInstancePropDecorators
 };

transforms/helpers/parse-helper.js

@@ -34,7 +34,12 @@ const logger = require("./log-helper");
  * @param {ObjectExpression} emberObjectExpression
  * @returns {Object} Object of instance and function properties
  */
-function getEmberObjectProps(j, eoExpression, importedDecoratedProps = {}) {
+function getEmberObjectProps(
+  j,
+  eoExpression,
+  importedDecoratedProps = {},
+  runtimeData = {}
+) {
   const objProps = get(eoExpression, "properties") || [];
 
   const instanceProps = [];
@@ -55,6 +60,7 @@ function getEmberObjectProps(j, eoExpression, importedDecoratedProps = {}) {
       );
     } else {
       prop.setDecorators(importedDecoratedProps);
+      prop.setRuntimeData(runtimeData);
       instanceProps.push(prop);
     }
     if (prop.isLayout) {
@@ -224,6 +230,8 @@ function getDecoratorsToImport(instanceProps, decoratorsMap = {}) {
       tagName: specs.tagName || prop.isTagName,
       className: specs.className || prop.hasClassNameDecorator,
       classNames: specs.classNames || prop.isClassNames,
+      unobserves: specs.unobserves || prop.hasUnobservesDecorator,
+      off: specs.off || prop.hasOffDecorator,
       volatile: specs.volatile || prop.hasVolatile
     };
   }, decoratorsMap);
@@ -513,7 +521,8 @@ function replaceEmberObjectExpressions(j, root, filePath, options = {}) {
     const eoProps = getEmberObjectProps(
       j,
       eoExpression,
-      importedDecoratedProps
+      importedDecoratedProps,
+      options.runtimeData
     );
 
     const errors = hasValidProps(eoProps, getOptions(options));