Merge pull request #39 from rwjblue/lazy-assert-messages

Update `assert` to prefix predicate when possible.

Author: chadhietala

README.md

@@ -17,7 +17,9 @@ The plugin takes 5 types options: `envFlags`, `features`, `debugTools`, `externa
       },
       // @required
       debugTools: {
-        source: 'debug-tools'
+        source: 'debug-tools',
+        // @optional
+        assertPredicateIndex: 0
       },
       // @optional
       features: {
@@ -94,6 +96,11 @@ Expands into:
 
 ## `assert` macro expansion
 
+The `assert` macro can expand in a more intelligent way with the correct
+configuration. When `babel-plugin-debug-macros` is provided with the
+`assertPredicateIndex` the predicate is injected in front of the assertion
+in order to avoid costly assertion message generation when not needed.
+
 ```javascript
 import { assert } from 'debug-tools';
 
@@ -102,10 +109,15 @@ assert((() => {
 })(), 'You bad!');
 ```
 
-Expands into:
+With the `debugTools: { assertPredicateIndex: 0 }` configuration the following expansion is done:
 
-```javascript
+```js
+(true && !((() => { return 1 === 1;})()) && console.assert(false, 'this is a warning'));
+```
+
+When `assertPredicateIndex` is not specified, the following expansion is done:
 
+```javascript
 (true && console.assert((() => { return 1 === 1;})(), 'this is a warning'));
 ```
 

fixtures/assert-expansion/expectation.js

@@ -1,2 +1,2 @@
-(true && console.assert((() => true)(), 'This is an assertion'));
-(true && console.assert(false, 'This is an assertion 2'));
+(true && !((() => true)()) && console.assert(false, 'This is an assertion'));
+(true && !(false) && console.assert(false, 'This is an assertion 2'));

fixtures/ember-cli-babel-config/expectation.js

@@ -0,0 +1,13 @@
+
+
+if (true) {
+  doStuff();
+}
+
+(true && Ember.warn('This is a warning'));
+(true && !(foo) && Ember.assert('Hahahaha', false));
+(true && !(true) && Ember.deprecate('This thing is donzo', false, {
+  id: 'donzo',
+  until: '4.0.0',
+  url: 'http://example.com'
+}));

fixtures/ember-cli-babel-config/sample.js

@@ -0,0 +1,16 @@
+import { warn, assert, deprecate } from '@ember/debug';
+import { DEBUG } from '@glimmer/env';
+
+if (DEBUG) {
+  doStuff();
+}
+
+warn('This is a warning');
+
+assert('Hahahaha', foo);
+
+deprecate('This thing is donzo', true, {
+  id: 'donzo',
+  until: '4.0.0',
+  url: 'http://example.com'
+});

fixtures/global-external-helpers/expectation.js

@@ -1,6 +1,6 @@
 (true && __debugHelpers__.warn('This is a warning'));
 (true && __debugHelpers__.assert('Hahahaha', foo));
-(true && !(true) && __debugHelpers__.deprecate('This thing is donzo', true, {
+(true && !(true) && __debugHelpers__.deprecate('This thing is donzo', false, {
   id: 'donzo',
   until: '4.0.0',
   url: 'http://example.com'

fixtures/retain-module-external-helpers/expectation.js

@@ -2,7 +2,7 @@ import { warn, assert, deprecate } from '@ember/debug-tools';
 
 (true && warn('This is a warning'));
 (true && assert('Hahahaha', false));
-(true && !(true) && deprecate('This thing is donzo', true, {
+(true && !(true) && deprecate('This thing is donzo', false, {
   id: 'donzo',
   until: '4.0.0',
   url: 'http://example.com'

src/lib/utils/builder.js

@@ -1,8 +1,9 @@
 export default class Builder {
-  constructor(t, module, global) {
+  constructor(t, options) {
     this.t = t;
-    this.module = module;
-    this.global = global;
+    this.module = options.module;
+    this.global = options.global;
+    this.assertPredicateIndex = options.assertPredicateIndex;
     this.expressions = [];
   }
 
@@ -15,16 +16,40 @@ export default class Builder {
    *
    * ($DEBUG && console.assert($PREDICATE, $MESSAGE));
    *
-   * or
+   * or (when `assertPredicateIndex` specified)
+   *
+   * ($DEBUG && $PREDICATE && console.assert(false, $MESSAGE));
+   *
+   * or (`{ externalizeHelpers: { module: true } }`)
    *
    * ($DEBUG && assert($PREDICATE, $MESSAGE));
    *
-   * or
+   * or (when `{ externalizeHelpers: { module: true }, debugTools: { source: '...', assertPredicateIndex: 0 } }` specified)
+   *
+   * ($DEBUG && $PREDICATE && assert(false, $MESSAGE));
+   *
+   * or (when `{ externalizeHelpers: { global: '$GLOBLA_NS' }` specified)
    *
    * ($DEBUG && $GLOBAL_NS.assert($PREDICATE, $MESSAGE));
+   *
+   * or (when `{ externalizeHelpers: { global: '$GLOBLA_NS' }, debugTools: { source: '...', assertPredicateIndex: 0 } }` specified)
+   *
+   * ($DEBUG && $PREDICATE && $GLOBAL_NS.assert(false, $MESSAGE));
    */
   assert(path) {
-    this._createMacroExpression(path);
+    let predicate;
+    if (this.assertPredicateIndex !== undefined) {
+      predicate = (expression, args) => {
+        let predicate = args[this.assertPredicateIndex];
+        args[this.assertPredicateIndex] = this.t.identifier('false');
+
+        return predicate;
+      };
+    }
+
+    this._createMacroExpression(path, {
+      predicate
+    });
   }
 
   /**
@@ -69,24 +94,40 @@ export default class Builder {
     this._createMacroExpression(path);
   }
 
-  _createMacroExpression(path) {
+  _createMacroExpression(path, _options) {
+    let options = _options || {};
+
     let { t, module, global } = this;
     let expression = path.node.expression;
     let { callee, arguments: args } = expression;
     let callExpression;
 
+    if (options.validate) {
+      options.validate(expression, args);
+    }
+
     if (module || global) {
       if (global) {
         callExpression = this._createGlobalExternalHelper(callee, args, global);
       } else {
         callExpression = expression;
       }
+    } else if (options.buildConsoleAPI) {
+      callExpression = options.buildConsoleAPI(expression, args);
     } else {
-      callExpression = this._createConsoleAPI(callee, args);
+      callExpression = this._createConsoleAPI(options.consoleAPI || callee, args);
     }
 
     let identifiers = this._getIdentifiers(args);
-    this.expressions.push([path, this._buildLogicalExpressions([], callExpression)]);
+    let prefixedIdentifiers = [];
+
+    if (options.predicate) {
+      let predicate = options.predicate(expression, args);
+      let negatedPredicate = t.unaryExpression('!', t.parenthesizedExpression(predicate));
+      prefixedIdentifiers.push(negatedPredicate);
+    }
+
+    this.expressions.push([path, this._buildLogicalExpressions(prefixedIdentifiers, callExpression)]);
   }
 
   /**
@@ -108,41 +149,39 @@ export default class Builder {
    *
    * or
    *
-   * ($DEBUG && $PREDICATE && deprecate($MESSAGE, $PREDICATE, { $ID, $URL, $UNTIL }));
+   * ($DEBUG && $PREDICATE && deprecate($MESSAGE, false, { $ID, $URL, $UNTIL }));
    *
    * or
    *
-   * ($DEBUG && $PREDICATE && $GLOBAL_NS.deprecate($MESSAGE, $PREDICATE, { $ID, $URL, $UNTIL }));
+   * ($DEBUG && $PREDICATE && $GLOBAL_NS.deprecate($MESSAGE, false, { $ID, $URL, $UNTIL }));
    */
   deprecate(path) {
-    let { t, module, global } = this;
-    let expression = path.node.expression;
-    let callee = expression.callee;
-    let args = expression.arguments;
-    let [ message, predicate, meta ] = args;
+    this._createMacroExpression(path, {
+      predicate: (expression, args) => {
+        let [, predicate] = args;
+        args[1] = this.t.identifier('false');
 
-    if (meta && meta.properties && !meta.properties.some( prop =>  prop.key.name === 'id')) {
-      throw new ReferenceError(`deprecate's meta information requires an "id" field.`);
-    }
+        return predicate;
+      },
 
-    if (meta && meta.properties && !meta.properties.some(prop =>  prop.key.name === 'until')) {
-      throw new ReferenceError(`deprecate's meta information requires an "until" field.`);
-    }
+      buildConsoleAPI: (expression, args) => {
+        let [message] = args;
 
-    let deprecate;
-    if (module || global) {
-      if (global) {
-        deprecate = this._createGlobalExternalHelper(callee, args, global);
-      } else {
-        deprecate = expression;
-      }
-    } else {
-      deprecate = this._createConsoleAPI(t.identifier('warn'), [message]);
-    }
+        return this._createConsoleAPI(this.t.identifier('warn'), [message]);
+      },
+
+      validate: (expression, args) => {
+        let [ , , meta ] = args;
 
-    this.expressions.push([path, this._buildLogicalExpressions([
-      t.unaryExpression('!', t.parenthesizedExpression(predicate))
-    ], deprecate)]);
+        if (meta && meta.properties && !meta.properties.some( prop =>  prop.key.name === 'id')) {
+          throw new ReferenceError(`deprecate's meta information requires an "id" field.`);
+        }
+
+        if (meta && meta.properties && !meta.properties.some(prop =>  prop.key.name === 'until')) {
+          throw new ReferenceError(`deprecate's meta information requires an "until" field.`);
+        }
+      }
+    });
   }
 
   /**
@@ -192,4 +231,4 @@ export default class Builder {
       return logicalExpressions;
     }
   }
-}
+}

src/lib/utils/macros.js

@@ -19,8 +19,11 @@ export default class Macros {
     this.svelteVersions = options.svelte;
     this.featureFlags = options.features || [];
     this.debugHelpers = options.externalizeHelpers || {};
-    let { module, global } = this.debugHelpers;
-    this.builder = new Builder(t, module, global);
+    this.builder = new Builder(t, {
+      module: this.debugHelpers.module,
+      global: this.debugHelpers.global,
+      assertPredicateIndex: options.debugTools.assertPredicateIndex
+    });
   }
 
   /**

src/lib/utils/normalize-options.js

@@ -52,10 +52,10 @@ export function normalizeOptions(options) {
     throw new Error('You must specify `debugTools.source`');
   }
 
-  let debugToolsImport;
-  if (debugTools) {
-    debugToolsImport = debugTools.source;
-  }
+  let {
+    source: debugToolsImport,
+    assertPredicateIndex
+  } = debugTools;
 
   let envFlagsImport;
   let _envFlags = {};
@@ -82,7 +82,8 @@ export function normalizeOptions(options) {
       flags: _envFlags
     },
     debugTools: {
-      debugToolsImport
+      debugToolsImport,
+      assertPredicateIndex
     }
   };
-}
+}

src/tests/debug-tools-test.js

@@ -51,7 +51,8 @@ let cases = {
       plugins: [
         [DebugToolsPlugin, {
           debugTools: {
-            source: '@ember/debug-tools'
+            source: '@ember/debug-tools',
+            assertPredicateIndex: 0
           },
           envFlags: {
             source: '@ember/env-flags',
@@ -100,6 +101,31 @@ let cases = {
     fixtures: ['global-external-helpers']
   },
 
+  'ember-cli-babel default configuration': {
+    transformOptions: {
+      presets,
+      plugins: [
+        [DebugToolsPlugin, {
+          externalizeHelpers: {
+            global: 'Ember'
+          },
+          debugTools: {
+            source: '@ember/debug',
+            assertPredicateIndex: 1
+          },
+          envFlags: {
+            source: '@glimmer/env',
+            flags: {
+              DEBUG: true
+            }
+          }
+        }]
+      ]
+    },
+
+    fixtures: ['ember-cli-babel-config']
+  },
+
   'Retain Module External Test Helpers': {
     transformOptions: {
       presets,