[FEATURE] Replace dyfactor with puppeteer (#118)

[FEATURE] Replace dyfactor with puppeteer

Co-authored-by: Robert Jackson <[email protected]>

Author: Robert Jackson

.eslintignore

@@ -1 +1,2 @@
-**/__testfixtures__/**/*.js
+**/__testfixtures__/**/*.js
+**/fixtures/**

.eslintrc.js

@@ -1,5 +1,8 @@
 module.exports = {
   root: true,
+  parserOptions: {
+    ecmaVersion: 2017
+  },
   env: {
     node: true,
     es6: true

.travis.yml

@@ -1,7 +1,7 @@
 ---
 language: node_js
 node_js:
-  - "6"
+  - "8"
 
 sudo: false
 dist: trusty
@@ -17,4 +17,4 @@ install:
   - yarn install
 
 script:
-  - yarn test
+  - yarn test

bin/cli.js

@@ -1,8 +1,12 @@
 #!/usr/bin/env node
 "use strict";
 
+const gatherTelemetry = require("../lib/gather-telemetry");
+
+gatherTelemetry(process.argv[2]);
+
 require("codemod-cli").runTransform(
   __dirname,
-  process.argv[2] /* transform name */,
+  "ember-object",
   process.argv.slice(2) /* paths or globs */
 );

bin/temeletry.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+"use strict";
+
+const gatherTelemetry = require("../lib/gather-telemetry");
+
+gatherTelemetry(process.argv[2]);

lib/cache.js

@@ -0,0 +1,7 @@
+const Cache = require("sync-disk-cache");
+const getRepoInfo = require("git-repo-info");
+
+const gitInfo = getRepoInfo();
+const cache = new Cache(`native-class-codemod-${gitInfo.sha}-${process.cwd()}`);
+
+module.exports = cache;

lib/gather-telemetry.js

@@ -0,0 +1,246 @@
+const puppeteer = require("puppeteer");
+const cache = require("./cache");
+
+module.exports = async function gatherTelemetry(url) {
+  const browser = await puppeteer.launch();
+  const page = await browser.newPage();
+
+  await page.goto(url);
+
+  // Get the "viewport" of the page, as reported by the page.
+  const telemetry = await page.evaluate(() => {
+    /* globals window, Ember */
+    let telemetry = {};
+
+    const modules = Object.keys(window.require.entries);
+
+    for (let modulePath of modules) {
+      let module = require(modulePath);
+
+      if (module && module.default && module.default.proto) {
+        let defaultProto = module.default.proto();
+
+        telemetry[modulePath] = parseMeta(Ember.meta(defaultProto));
+      }
+    }
+
+    /**
+     * Compares the object with types of Ember objects
+     *
+     * @param {Object} object
+     * @returns {String} type
+     */
+    function getType(object) {
+      const types = [
+        "Application",
+        "Controller",
+        "Route",
+        "Component",
+        "Service",
+        "Router",
+        "Engine"
+      ];
+      return (
+        types.find(type => Ember[type] && object instanceof Ember[type]) ||
+        "EmberObject"
+      );
+    }
+
+    /**
+     * Parses ember meta data object and collects the runtime information
+     *
+     * @param {Object} meta
+     * @returns {Object} data - Parsed metadata for the ember object
+     * @returns {String[]} data.computedProperties - list of computed properties
+     * @returns {String[]} data.observedProperties - list of observed properties
+     * @returns {Object} data.observerProperties - list of observer properties
+     * @returns {Object} data.offProperties - list of observer properties
+     * @returns {String[]} data.overriddenActions - list of overridden actions
+     * @returns {String[]} data.overriddenProperties - list of overridden properties
+     * @returns {String[]} data.ownProperties - list of object's own properties
+     * @returns {String} data.type - type of ember object
+     * @returns {Object} data.unobservedProperties - list of unobserved properties
+     */
+    function parseMeta(meta = {}) {
+      if (!meta || !meta.source) {
+        return {};
+      }
+      const { source } = meta;
+      const type = getType(source);
+
+      const ownProperties = Object.keys(source).filter(
+        key => !["_super", "actions"].includes(key)
+      );
+
+      const ownActions = source.actions ? Object.keys(source.actions) : [];
+
+      const observedProperties = Object.keys(meta._watching || {});
+
+      const overriddenProperties = ownProperties.filter(key =>
+        isOverridden(meta.parent, key)
+      );
+
+      const overriddenActions = ownActions.filter(key =>
+        isActionOverridden(meta.parent, key)
+      );
+
+      const computedProperties = [];
+      meta.forEachDescriptors((name, desc) => {
+        const descProto = Object.getPrototypeOf(desc) || {};
+        const constructorName = descProto.constructor
+          ? descProto.constructor.name
+          : "";
+        if (
+          desc.enumerable &&
+          ownProperties.includes(name) &&
+          constructorName === "ComputedProperty"
+        ) {
+          computedProperties.push(name);
+        }
+      });
+
+      const { offProperties, unobservedProperties } = ownProperties.reduce(
+        ({ offProperties, unobservedProperties }, key) => {
+          const { type, events } = getListenerData(meta.parent, key);
+          if (type === "event") {
+            offProperties[key] = events;
+          } else if (type === "observer") {
+            unobservedProperties[key] = events;
+          }
+          return { offProperties, unobservedProperties };
+        },
+        {
+          offProperties: {},
+          unobservedProperties: {}
+        }
+      );
+
+      const observerProperties = observedProperties.reduce((acc, oProp) => {
+        const listener = meta.matchingListeners(`${oProp}:change`)[1];
+        acc[listener] = [].concat(acc[listener] || [], [oProp]);
+        return acc;
+      }, {});
+
+      return {
+        computedProperties,
+        observedProperties,
+        observerProperties,
+        offProperties,
+        overriddenActions,
+        overriddenProperties,
+        ownProperties,
+        type,
+        unobservedProperties
+      };
+    }
+
+    /**
+     * Parses the ember meta with passed key
+     *
+     * @param {Ember.meta} map
+     * @param {String} key
+     * @returns {Object} meta - The listener meta data
+     * @returns {String} meta.type - Type of listener can be observer|event
+     * @returns {String[]} meta.events - name of events/properties the listener is registered on
+     */
+    function getListenerData(map, key) {
+      while (map) {
+        let type = "event";
+        const events = parseListeners(map._listeners).reduce(
+          (acc, [event, , method]) => {
+            if (method === key) {
+              const [observedProp, observerEvent] = event.split(":");
+              if (observerEvent) {
+                type = "observer";
+              }
+              acc.push(observedProp);
+            }
+            return acc;
+          },
+          []
+        );
+        if (events.length) {
+          return {
+            type,
+            events
+          };
+        }
+        map = map.parent;
+      }
+      return {};
+    }
+
+    /**
+     * Parse the listeners to a group of array of 4 elements
+     *
+     * @param {Array} listeners
+     * @param {int} size
+     * @returns Array
+     */
+    function parseListeners(listeners = [], size = 4) {
+      var result = [];
+      if (listeners.length) {
+        if (typeof listeners[0] === "object") {
+          result = listeners.map(({ event, target, method, kind }) => [
+            event,
+            target,
+            method,
+            kind
+          ]);
+        } else {
+          const input = listeners.slice(0);
+          while (input.length) {
+            result.push(input.splice(0, size));
+          }
+        }
+      }
+      return result;
+    }
+
+    /**
+     * Checks if passed key is overriding any value from the parent objects
+     *
+     * @param {Object} map
+     * @param {String} key
+     * @returns boolean
+     */
+    function isOverridden(map, key) {
+      while (map) {
+        const value = map.peekValues ? map.peekValues(key) : undefined;
+        if (value !== undefined || (map.source && key in map.source)) {
+          return true;
+        }
+        map = map.parent;
+      }
+      return false;
+    }
+
+    /**
+     * Checks if passed key is overriding any value from the parent objects' actions
+     *
+     * @param {Object} map
+     * @param {String} key
+     * @returns boolean
+     */
+    function isActionOverridden(map, key) {
+      while (map) {
+        const { source } = map;
+        if (source) {
+          const { actions } = source;
+          const value = actions ? actions[key] : undefined;
+          if (value !== undefined) {
+            return true;
+          }
+        }
+        map = map.parent;
+      }
+      return false;
+    }
+
+    return telemetry;
+  });
+
+  cache.set("telemetry", JSON.stringify(telemetry));
+
+  await browser.close();
+};

package.json

@@ -2,24 +2,39 @@
   "name": "ember-es6-class-codemod",
   "version": "0.1.3",
   "scripts": {
-    "test": "eslint . && codemod-cli test",
+    "test": "eslint . && codemod-cli test && node ./test/run-test.js",
     "update-docs": "codemod-cli update-docs"
   },
   "bin": "./bin/cli.js",
   "keywords": [
     "codemod-cli"
   ],
+  "files": [
+    "/bin",
+    "/lib",
+    "/transforms/helpers",
+    "/transforms/ember-object/index.js"
+  ],
   "license": "MIT",
   "dependencies": {
     "codemod-cli": "^0.2.11",
+    "fs-extra": "^8.0.1",
+    "git-repo-info": "^2.1.0",
     "minimatch": "^3.0.4",
+    "puppeteer": "^1.17.0",
+    "sync-disk-cache": "^1.3.3",
+    "walk-sync": "^1.1.3",
     "winston": "^3.2.1"
   },
   "devDependencies": {
     "eslint": "^5.16.0",
     "eslint-config-prettier": "^5.0.0",
     "eslint-plugin-prettier": "^3.1.0",
+    "execa": "^1.0.0",
     "jest": "^24.8.0",
     "prettier": "^1.17.1"
+  },
+  "engines": {
+    "node": "8.* || 10.* || >= 12.*"
   }
 }

test/fixtures/input/.editorconfig

@@ -0,0 +1,20 @@
+# EditorConfig helps developers define and maintain consistent
+# coding styles between different editors and IDEs
+# editorconfig.org
+
+root = true
+
+
+[*]
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+indent_style = space
+indent_size = 2
+
+[*.hbs]
+insert_final_newline = false
+
+[*.{diff,md}]
+trim_trailing_whitespace = false

test/fixtures/input/.ember-cli

@@ -0,0 +1,9 @@
+{
+  /**
+    Ember CLI sends analytics information by default. The data is completely
+    anonymous, but there are times when you might want to disable this behavior.
+
+    Setting `disableAnalytics` to true will prevent any data from being sent.
+  */
+  "disableAnalytics": false
+}