espower - npm Package Compare versions

Comparing version 0.1.1 to 0.1.2

lib/espower.js

@@ -132,3 +132,4 @@ /**
 Instrumentor.prototype.captureRecursively = function (node) {
-    var that = this;
+    var that = this,
+        propLocation;
     switch (node.type) {
@@ -138,3 +139,3 @@ case 'Identifier':
     case 'MemberExpression': // ex: foo.bar.baz
-        var propLocation = that.propertyLocationOf(node);
+        propLocation = that.propertyLocationOf(node);
         node.object = that.captureRecursively(node.object);
@@ -163,9 +164,11 @@ if (node.computed) {
     case 'BinaryExpression':
-        var operatorLocation = that.operatorLocationOf(node); // BK: need to detect operator location before left/right instrumentation
-        node.left = that.captureRecursively(node.left);
-        node.right = that.captureRecursively(node.right);
-        return that.captureBinary(node, operatorLocation);
+        return that.captureExpressionWithInfixOperator(node, 'binary');
     case 'LogicalExpression':
-        node.left = that.captureRecursively(node.left);
-        node.right = that.captureRecursively(node.right);
+        return that.captureExpressionWithInfixOperator(node, 'logical');
+    case 'AssignmentExpression':
+        return that.captureExpressionWithInfixOperator(node, 'assignment');
+    case 'ArrayExpression':
+        node.elements = node.elements.map(function (elem) {
+            return that.captureRecursively(elem);
+        });
         return node;
@@ -177,2 +180,14 @@ default:
 
+Instrumentor.prototype.captureExpressionWithInfixOperator = function (expression, kind) {
+    // BK: need to detect operator location before left/right instrumentation
+    var infixOperatorLocation = this.infixOperatorLocationOf(expression);
+    if (kind !== 'assignment') {
+        // Do not instrument left due to 'Invalid left-hand side in assignment'
+        expression.left = this.captureRecursively(expression.left);
+    }
+    expression.right = this.captureRecursively(expression.right);
+    return this.captureNode(kind, expression, infixOperatorLocation);
+};
+
+// calculate property location of MemberExpression.
 Instrumentor.prototype.propertyLocationOf = function (memberExpression) {
@@ -208,5 +223,6 @@ var that = this,
 
-Instrumentor.prototype.operatorLocationOf = function (binaryExpression) {
+// calculate location of infix operator for BinaryExpression, AssignmentExpression and LogicalExpression.
+Instrumentor.prototype.infixOperatorLocationOf = function (expression) {
     var that = this,
-        n = newNodeWithLocationCopyOf(binaryExpression),
+        n = newNodeWithLocationCopyOf(expression),
         newLocation,
@@ -217,8 +233,8 @@ endOfLeftColumn,
 
-    if (binaryExpression.left.loc.end && binaryExpression.left.loc.end.column) { // esprima
-        endOfLeftColumn = binaryExpression.left.loc.end.column;
-    } else if (binaryExpression.left.range) { // CoffeeScriptRedux
-        endOfLeftColumn = binaryExpression.left.loc.start.column + (binaryExpression.left.range[1] - binaryExpression.left.range[0]);
+    if (expression.left.loc.end && expression.left.loc.end.column) { // esprima
+        endOfLeftColumn = expression.left.loc.end.column;
+    } else if (expression.left.range) { // CoffeeScriptRedux
+        endOfLeftColumn = expression.left.loc.start.column + (expression.left.range[1] - expression.left.range[0]);
     } else {
-        throw new Error('Cannot detect operator location: ' + binaryExpression.operator + ' line: ' + that.line);
+        throw new Error('Cannot detect operator location: ' + expression.operator + ' line: ' + that.line);
     }
@@ -228,3 +244,3 @@ operatorStartColumn = endOfLeftColumn + 1;
     if (that.line) {
-        operatorIndex = that.line.indexOf(binaryExpression.operator, endOfLeftColumn);
+        operatorIndex = that.line.indexOf(expression.operator, endOfLeftColumn);
         if (operatorIndex !== -1) {
@@ -236,3 +252,3 @@ operatorStartColumn = operatorIndex;
     newLocation.loc.start = {
-        line: binaryExpression.left.loc.start.line,
+        line: expression.left.loc.start.line,
         column: operatorStartColumn
@@ -292,6 +308,2 @@ };
 
-Instrumentor.prototype.captureBinary = function (target, location) {
-    return this.captureNode('binary', target, location);
-};
-
 Instrumentor.prototype.captureUnary = function (target, location) {
@@ -415,7 +427,7 @@ return this.captureNode('unary', target, location);
         'CallExpression',
+        'AssignmentExpression',
+        'ArrayExpression',
         'LogicalExpression'
     ];
 //// expressions
-// 'ArrayExpression',
-// 'AssignmentExpression',
 // 'ConditionalExpression',
@@ -422,0 +434,0 @@ // 'FunctionExpression',

package.json

 {
   "name": "espower",
   "description": "Power Assert feature instrumentor based on the Mozilla JavaScript AST",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "keywords": [
@@ -29,3 +29,3 @@ "test",
     "esprima": "1.0.3",
-    "escodegen": "0.0.24",
+    "escodegen": "0.0.26",
     "coffee-script-redux": "2.0.0-beta6",
@@ -39,3 +39,3 @@ "mocha": "1.12.0",
       "type": "MIT",
-      "url": "http://www.opensource.org/licenses/mit-license.php"
+      "url": "https://raw.github.com/twada/espower/master/MIT-LICENSE.txt"
     }
@@ -42,0 +42,0 @@ ],

README.md

@@ -5,2 +5,3 @@ espower
 [![Build Status](https://travis-ci.org/twada/espower.png?branch=master)](https://travis-ci.org/twada/espower)
+[![NPM version](https://badge.fury.io/js/espower.png)](http://badge.fury.io/js/espower)
 
@@ -7,0 +8,0 @@ Power Assert feature instrumentor based on the Mozilla JavaScript AST.

test/instrumentation_test.js

@@ -21,97 +21,133 @@ var espower = require('../lib/espower'),
 
-    inst("assert(falsyStr);",
-         "assert(assert._expr(assert._capt(falsyStr,'ident',{start:{line:1,column:7}}),{start:{line:1,column:7}}));");
+    describe('Identifier', function () {
+        inst("assert(falsyStr);",
+             "assert(assert._expr(assert._capt(falsyStr,'ident',{start:{line:1,column:7}}),{start:{line:1,column:7}}));");
 
-    inst("assert.ok(hoge === fuga, 'comment');",
-         "assert.ok(assert._expr(assert._capt(assert._capt(hoge,'ident',{start:{line:1,column:10}})===assert._capt(fuga,'ident',{start:{line:1,column:19}}),'binary',{start:{line:1,column:15}}),{start:{line:1,column:10}}),'comment');");
+        inst("return assert(falsyStr);",
+             "return assert(assert._expr(assert._capt(falsyStr,'ident',{start:{line:1,column:14}}),{start:{line:1,column:14}}));");
+    });
 
-    inst("return assert(falsyStr);",
-         "return assert(assert._expr(assert._capt(falsyStr,'ident',{start:{line:1,column:14}}),{start:{line:1,column:14}}));");
 
-    inst("assert(!truth);",
-         "assert(assert._expr(assert._capt(!assert._capt(truth,'ident',{start:{line:1,column:8}}),'unary',{start:{line:1,column:7}}),{start:{line:1,column:7}}));");
+    describe('BinaryExpression', function () {
+        inst("assert(4 !== 4);",
+             "assert(assert._expr(assert._capt(4!==4,'binary',{start:{line:1,column:9}}),{start:{line:1,column:7}}));");
 
-    inst("assert(!!some);",
-         "assert(assert._expr(assert._capt(!assert._capt(!assert._capt(some,'ident',{start:{line:1,column:9}}),'unary',{start:{line:1,column:8}}),'unary',{start:{line:1,column:7}}),{start:{line:1,column:7}}));");
+        inst("assert(fuga !== 4);",
+             "assert(assert._expr(assert._capt(assert._capt(fuga,'ident',{start:{line:1,column:7}})!==4,'binary',{start:{line:1,column:12}}),{start:{line:1,column:7}}));");
 
-    inst("assert(!!foo.bar);",
-         "assert(assert._expr(assert._capt(!assert._capt(!assert._capt(assert._capt(foo,'ident',{start:{line:1,column:9}}).bar,'ident',{start:{line:1,column:13}}),'unary',{start:{line:1,column:8}}),'unary',{start:{line:1,column:7}}),{start:{line:1,column:7}}));");
+        inst("assert(fuga === piyo);",
+             "assert(assert._expr(assert._capt(assert._capt(fuga,'ident',{start:{line:1,column:7}})===assert._capt(piyo,'ident',{start:{line:1,column:16}}),'binary',{start:{line:1,column:12}}),{start:{line:1,column:7}}));");
 
-    inst("assert(4 !== 4);",
-         "assert(assert._expr(assert._capt(4!==4,'binary',{start:{line:1,column:9}}),{start:{line:1,column:7}}));");
+        inst("assert(fuga !== piyo);",
+             "assert(assert._expr(assert._capt(assert._capt(fuga,'ident',{start:{line:1,column:7}})!==assert._capt(piyo,'ident',{start:{line:1,column:16}}),'binary',{start:{line:1,column:12}}),{start:{line:1,column:7}}));");
 
-    inst("assert(fuga !== 4);",
-         "assert(assert._expr(assert._capt(assert._capt(fuga,'ident',{start:{line:1,column:7}})!==4,'binary',{start:{line:1,column:12}}),{start:{line:1,column:7}}));");
+        inst("assert.ok(hoge === fuga, 'comment');",
+             "assert.ok(assert._expr(assert._capt(assert._capt(hoge,'ident',{start:{line:1,column:10}})===assert._capt(fuga,'ident',{start:{line:1,column:19}}),'binary',{start:{line:1,column:15}}),{start:{line:1,column:10}}),'comment');");
 
-    inst("assert(fuga === piyo);",
-         "assert(assert._expr(assert._capt(assert._capt(fuga,'ident',{start:{line:1,column:7}})===assert._capt(piyo,'ident',{start:{line:1,column:16}}),'binary',{start:{line:1,column:12}}),{start:{line:1,column:7}}));");
+        inst("assert(ary1.length === ary2.length);",
+             "assert(assert._expr(assert._capt(assert._capt(assert._capt(ary1,'ident',{start:{line:1,column:7}}).length,'ident',{start:{line:1,column:12}})===assert._capt(assert._capt(ary2,'ident',{start:{line:1,column:23}}).length,'ident',{start:{line:1,column:28}}),'binary',{start:{line:1,column:19}}),{start:{line:1,column:7}}));");
+    });
 
-    inst("assert(fuga !== piyo);",
-         "assert(assert._expr(assert._capt(assert._capt(fuga,'ident',{start:{line:1,column:7}})!==assert._capt(piyo,'ident',{start:{line:1,column:16}}),'binary',{start:{line:1,column:12}}),{start:{line:1,column:7}}));");
 
-    inst("assert(typeof foo !== 'undefined');",
-         "assert(assert._expr(assert._capt(assert._capt(typeof foo,'unary',{start:{line:1,column:7}})!=='undefined','binary',{start:{line:1,column:18}}),{start:{line:1,column:7}}));");
+    describe('UnaryExpression', function () {
+        inst("assert(!truth);",
+             "assert(assert._expr(assert._capt(!assert._capt(truth,'ident',{start:{line:1,column:8}}),'unary',{start:{line:1,column:7}}),{start:{line:1,column:7}}));");
 
-    inst("assert(typeof foo.bar !== 'undefined');",
-         "assert(assert._expr(assert._capt(assert._capt(typeof assert._capt(assert._capt(foo,'ident',{start:{line:1,column:14}}).bar,'ident',{start:{line:1,column:18}}),'unary',{start:{line:1,column:7}})!=='undefined','binary',{start:{line:1,column:22}}),{start:{line:1,column:7}}));");
+        inst("assert(!!some);",
+             "assert(assert._expr(assert._capt(!assert._capt(!assert._capt(some,'ident',{start:{line:1,column:9}}),'unary',{start:{line:1,column:8}}),'unary',{start:{line:1,column:7}}),{start:{line:1,column:7}}));");
 
-    inst("assert(delete foo);",
-         "assert(assert._expr(assert._capt(delete foo,'unary',{start:{line:1,column:7}}),{start:{line:1,column:7}}));");
+        inst("assert(!!foo.bar);",
+             "assert(assert._expr(assert._capt(!assert._capt(!assert._capt(assert._capt(foo,'ident',{start:{line:1,column:9}}).bar,'ident',{start:{line:1,column:13}}),'unary',{start:{line:1,column:8}}),'unary',{start:{line:1,column:7}}),{start:{line:1,column:7}}));");
 
-    inst("assert(delete foo.bar);",
-         "assert(assert._expr(assert._capt(delete assert._capt(assert._capt(foo,'ident',{start:{line:1,column:14}}).bar,'ident',{start:{line:1,column:18}}),'unary',{start:{line:1,column:7}}),{start:{line:1,column:7}}));");
+        inst("assert(delete foo);",
+             "assert(assert._expr(assert._capt(delete foo,'unary',{start:{line:1,column:7}}),{start:{line:1,column:7}}));");
 
-    inst("assert(ary1.length === ary2.length);",
-         "assert(assert._expr(assert._capt(assert._capt(assert._capt(ary1,'ident',{start:{line:1,column:7}}).length,'ident',{start:{line:1,column:12}})===assert._capt(assert._capt(ary2,'ident',{start:{line:1,column:23}}).length,'ident',{start:{line:1,column:28}}),'binary',{start:{line:1,column:19}}),{start:{line:1,column:7}}));");
+        inst("assert(delete foo.bar);",
+             "assert(assert._expr(assert._capt(delete assert._capt(assert._capt(foo,'ident',{start:{line:1,column:14}}).bar,'ident',{start:{line:1,column:18}}),'unary',{start:{line:1,column:7}}),{start:{line:1,column:7}}));");
 
-    inst("assert(5 < actual && actual < 13);",
-         "assert(assert._expr(assert._capt(5<assert._capt(actual,'ident',{start:{line:1,column:11}}),'binary',{start:{line:1,column:9}})&&assert._capt(assert._capt(actual,'ident',{start:{line:1,column:21}})<13,'binary',{start:{line:1,column:28}}),{start:{line:1,column:7}}));");
+        inst("assert(typeof foo !== 'undefined');",
+             "assert(assert._expr(assert._capt(assert._capt(typeof foo,'unary',{start:{line:1,column:7}})!=='undefined','binary',{start:{line:1,column:18}}),{start:{line:1,column:7}}));");
 
-    inst("assert.ok(actual < 5 || 13 < actual);",
-         "assert.ok(assert._expr(assert._capt(assert._capt(actual,'ident',{start:{line:1,column:10}})<5,'binary',{start:{line:1,column:17}})||assert._capt(13<assert._capt(actual,'ident',{start:{line:1,column:29}}),'binary',{start:{line:1,column:27}}),{start:{line:1,column:10}}));");
+        inst("assert(typeof foo.bar !== 'undefined');",
+             "assert(assert._expr(assert._capt(assert._capt(typeof assert._capt(assert._capt(foo,'ident',{start:{line:1,column:14}}).bar,'ident',{start:{line:1,column:18}}),'unary',{start:{line:1,column:7}})!=='undefined','binary',{start:{line:1,column:22}}),{start:{line:1,column:7}}));");
+    });
 
-    inst("assert(2 > actual && actual < 13);",
-         "assert(assert._expr(assert._capt(2>assert._capt(actual,'ident',{start:{line:1,column:11}}),'binary',{start:{line:1,column:9}})&&assert._capt(assert._capt(actual,'ident',{start:{line:1,column:21}})<13,'binary',{start:{line:1,column:28}}),{start:{line:1,column:7}}));");
 
-    inst("assert(foo.bar.baz);",
-         "assert(assert._expr(assert._capt(assert._capt(assert._capt(foo,'ident',{start:{line:1,column:7}}).bar,'ident',{start:{line:1,column:11}}).baz,'ident',{start:{line:1,column:15}}),{start:{line:1,column:7}}));");
+    describe('LogicalExpression', function () {
+        inst("assert(5 < actual && actual < 13);",
+             "assert(assert._expr(assert._capt(assert._capt(5<assert._capt(actual,'ident',{start:{line:1,column:11}}),'binary',{start:{line:1,column:9}})&&assert._capt(assert._capt(actual,'ident',{start:{line:1,column:21}})<13,'binary',{start:{line:1,column:28}}),'logical',{start:{line:1,column:18}}),{start:{line:1,column:7}}));");
 
-    inst("assert(foo.bar);",
-         "assert(assert._expr(assert._capt(assert._capt(foo,'ident',{start:{line:1,column:7}}).bar,'ident',{start:{line:1,column:11}}),{start:{line:1,column:7}}));");
+        inst("assert.ok(actual < 5 || 13 < actual);",
+             "assert.ok(assert._expr(assert._capt(assert._capt(assert._capt(actual,'ident',{start:{line:1,column:10}})<5,'binary',{start:{line:1,column:17}})||assert._capt(13<assert._capt(actual,'ident',{start:{line:1,column:29}}),'binary',{start:{line:1,column:27}}),'logical',{start:{line:1,column:21}}),{start:{line:1,column:10}}));");
 
-    inst("assert(foo['bar']);",
-         "assert(assert._expr(assert._capt(assert._capt(foo,'ident',{start:{line:1,column:7}})['bar'],'ident',{start:{line:1,column:10}}),{start:{line:1,column:7}}));");
+        inst("assert(2 > actual && actual < 13);",
+             "assert(assert._expr(assert._capt(assert._capt(2>assert._capt(actual,'ident',{start:{line:1,column:11}}),'binary',{start:{line:1,column:9}})&&assert._capt(assert._capt(actual,'ident',{start:{line:1,column:21}})<13,'binary',{start:{line:1,column:28}}),'logical',{start:{line:1,column:18}}),{start:{line:1,column:7}}));");
+    });
 
-    inst("assert(foo[propName]);",
-         "assert(assert._expr(assert._capt(assert._capt(foo,'ident',{start:{line:1,column:7}})[assert._capt(propName,'ident',{start:{line:1,column:11}})],'ident',{start:{line:1,column:10}}),{start:{line:1,column:7}}));");
 
-    inst("assert(foo[func(key)]);",
-         "assert(assert._expr(assert._capt(assert._capt(foo,'ident',{start:{line:1,column:7}})[assert._capt(func(assert._capt(key,'ident',{start:{line:1,column:16}})),'funcall',{start:{line:1,column:11}})],'ident',{start:{line:1,column:10}}),{start:{line:1,column:7}}));");
+    describe('MemberExpression', function () {
+        inst("assert(foo.bar.baz);",
+             "assert(assert._expr(assert._capt(assert._capt(assert._capt(foo,'ident',{start:{line:1,column:7}}).bar,'ident',{start:{line:1,column:11}}).baz,'ident',{start:{line:1,column:15}}),{start:{line:1,column:7}}));");
 
-    inst("assert(foo[propName]['key'][keys()['name']]);",
-         "assert(assert._expr(assert._capt(assert._capt(assert._capt(assert._capt(foo,'ident',{start:{line:1,column:7}})[assert._capt(propName,'ident',{start:{line:1,column:11}})],'ident',{start:{line:1,column:10}})['key'],'ident',{start:{line:1,column:20}})[assert._capt(assert._capt(keys(),'funcall',{start:{line:1,column:28}})['name'],'ident',{start:{line:1,column:34}})],'ident',{start:{line:1,column:27}}),{start:{line:1,column:7}}));");
+        inst("assert(foo.bar);",
+             "assert(assert._expr(assert._capt(assert._capt(foo,'ident',{start:{line:1,column:7}}).bar,'ident',{start:{line:1,column:11}}),{start:{line:1,column:7}}));");
 
-    inst("assert(func());",
-         "assert(assert._expr(assert._capt(func(),'funcall',{start:{line:1,column:7}}),{start:{line:1,column:7}}));");
+        inst("assert(foo['bar']);",
+             "assert(assert._expr(assert._capt(assert._capt(foo,'ident',{start:{line:1,column:7}})['bar'],'ident',{start:{line:1,column:10}}),{start:{line:1,column:7}}));");
 
-    inst("assert(obj.age());",
-         "assert(assert._expr(assert._capt(assert._capt(obj,'ident',{start:{line:1,column:7}}).age(),'funcall',{start:{line:1,column:11}}),{start:{line:1,column:7}}));");
+        inst("assert(foo[propName]);",
+             "assert(assert._expr(assert._capt(assert._capt(foo,'ident',{start:{line:1,column:7}})[assert._capt(propName,'ident',{start:{line:1,column:11}})],'ident',{start:{line:1,column:10}}),{start:{line:1,column:7}}));");
 
-    inst("assert(isFalsy(positiveInt));",
-         "assert(assert._expr(assert._capt(isFalsy(assert._capt(positiveInt,'ident',{start:{line:1,column:15}})),'funcall',{start:{line:1,column:7}}),{start:{line:1,column:7}}));");
+        inst("assert(foo[func(key)]);",
+             "assert(assert._expr(assert._capt(assert._capt(foo,'ident',{start:{line:1,column:7}})[assert._capt(func(assert._capt(key,'ident',{start:{line:1,column:16}})),'funcall',{start:{line:1,column:11}})],'ident',{start:{line:1,column:10}}),{start:{line:1,column:7}}));");
 
-    inst("assert(sum(one, two, three) === seven);",
-         "assert(assert._expr(assert._capt(assert._capt(sum(assert._capt(one,'ident',{start:{line:1,column:11}}),assert._capt(two,'ident',{start:{line:1,column:16}}),assert._capt(three,'ident',{start:{line:1,column:21}})),'funcall',{start:{line:1,column:7}})===assert._capt(seven,'ident',{start:{line:1,column:32}}),'binary',{start:{line:1,column:28}}),{start:{line:1,column:7}}));");
+        inst("assert(foo[propName]['key'][keys()['name']]);",
+             "assert(assert._expr(assert._capt(assert._capt(assert._capt(assert._capt(foo,'ident',{start:{line:1,column:7}})[assert._capt(propName,'ident',{start:{line:1,column:11}})],'ident',{start:{line:1,column:10}})['key'],'ident',{start:{line:1,column:20}})[assert._capt(assert._capt(keys(),'funcall',{start:{line:1,column:28}})['name'],'ident',{start:{line:1,column:34}})],'ident',{start:{line:1,column:27}}),{start:{line:1,column:7}}));");
+    });
 
-    inst("assert(sum(sum(one, two), three) === sum(sum(two, three), seven));",
-         "assert(assert._expr(assert._capt(assert._capt(sum(assert._capt(sum(assert._capt(one,'ident',{start:{line:1,column:15}}),assert._capt(two,'ident',{start:{line:1,column:20}})),'funcall',{start:{line:1,column:11}}),assert._capt(three,'ident',{start:{line:1,column:26}})),'funcall',{start:{line:1,column:7}})===assert._capt(sum(assert._capt(sum(assert._capt(two,'ident',{start:{line:1,column:45}}),assert._capt(three,'ident',{start:{line:1,column:50}})),'funcall',{start:{line:1,column:41}}),assert._capt(seven,'ident',{start:{line:1,column:58}})),'funcall',{start:{line:1,column:37}}),'binary',{start:{line:1,column:33}}),{start:{line:1,column:7}}));");
 
-    inst("assert(math.calc.sum(one, two, three) === seven);",
-         "assert(assert._expr(assert._capt(assert._capt(assert._capt(assert._capt(math,'ident',{start:{line:1,column:7}}).calc,'ident',{start:{line:1,column:12}}).sum(assert._capt(one,'ident',{start:{line:1,column:21}}),assert._capt(two,'ident',{start:{line:1,column:26}}),assert._capt(three,'ident',{start:{line:1,column:31}})),'funcall',{start:{line:1,column:17}})===assert._capt(seven,'ident',{start:{line:1,column:42}}),'binary',{start:{line:1,column:38}}),{start:{line:1,column:7}}));");
+    describe('CallExpression', function () {
+        inst("assert(func());",
+             "assert(assert._expr(assert._capt(func(),'funcall',{start:{line:1,column:7}}),{start:{line:1,column:7}}));");
 
-    inst("assert((three * (seven * ten)) === three);",
-         "assert(assert._expr(assert._capt(assert._capt(assert._capt(three,'ident',{start:{line:1,column:8}})*assert._capt(assert._capt(seven,'ident',{start:{line:1,column:17}})*assert._capt(ten,'ident',{start:{line:1,column:25}}),'binary',{start:{line:1,column:23}}),'binary',{start:{line:1,column:14}})===assert._capt(three,'ident',{start:{line:1,column:35}}),'binary',{start:{line:1,column:30}}),{start:{line:1,column:7}}));");
+        inst("assert(obj.age());",
+             "assert(assert._expr(assert._capt(assert._capt(obj,'ident',{start:{line:1,column:7}}).age(),'funcall',{start:{line:1,column:11}}),{start:{line:1,column:7}}));");
 
-    inst("assert(!concat(fuga, piyo));",
-         "assert(assert._expr(assert._capt(!assert._capt(concat(assert._capt(fuga,'ident',{start:{line:1,column:15}}),assert._capt(piyo,'ident',{start:{line:1,column:21}})),'funcall',{start:{line:1,column:8}}),'unary',{start:{line:1,column:7}}),{start:{line:1,column:7}}));");
+        inst("assert(isFalsy(positiveInt));",
+             "assert(assert._expr(assert._capt(isFalsy(assert._capt(positiveInt,'ident',{start:{line:1,column:15}})),'funcall',{start:{line:1,column:7}}),{start:{line:1,column:7}}));");
+
+        inst("assert(sum(one, two, three) === seven);",
+             "assert(assert._expr(assert._capt(assert._capt(sum(assert._capt(one,'ident',{start:{line:1,column:11}}),assert._capt(two,'ident',{start:{line:1,column:16}}),assert._capt(three,'ident',{start:{line:1,column:21}})),'funcall',{start:{line:1,column:7}})===assert._capt(seven,'ident',{start:{line:1,column:32}}),'binary',{start:{line:1,column:28}}),{start:{line:1,column:7}}));");
+
+        inst("assert(sum(sum(one, two), three) === sum(sum(two, three), seven));",
+             "assert(assert._expr(assert._capt(assert._capt(sum(assert._capt(sum(assert._capt(one,'ident',{start:{line:1,column:15}}),assert._capt(two,'ident',{start:{line:1,column:20}})),'funcall',{start:{line:1,column:11}}),assert._capt(three,'ident',{start:{line:1,column:26}})),'funcall',{start:{line:1,column:7}})===assert._capt(sum(assert._capt(sum(assert._capt(two,'ident',{start:{line:1,column:45}}),assert._capt(three,'ident',{start:{line:1,column:50}})),'funcall',{start:{line:1,column:41}}),assert._capt(seven,'ident',{start:{line:1,column:58}})),'funcall',{start:{line:1,column:37}}),'binary',{start:{line:1,column:33}}),{start:{line:1,column:7}}));");
+
+        inst("assert(math.calc.sum(one, two, three) === seven);",
+             "assert(assert._expr(assert._capt(assert._capt(assert._capt(assert._capt(math,'ident',{start:{line:1,column:7}}).calc,'ident',{start:{line:1,column:12}}).sum(assert._capt(one,'ident',{start:{line:1,column:21}}),assert._capt(two,'ident',{start:{line:1,column:26}}),assert._capt(three,'ident',{start:{line:1,column:31}})),'funcall',{start:{line:1,column:17}})===assert._capt(seven,'ident',{start:{line:1,column:42}}),'binary',{start:{line:1,column:38}}),{start:{line:1,column:7}}));");
+
+        inst("assert((three * (seven * ten)) === three);",
+             "assert(assert._expr(assert._capt(assert._capt(assert._capt(three,'ident',{start:{line:1,column:8}})*assert._capt(assert._capt(seven,'ident',{start:{line:1,column:17}})*assert._capt(ten,'ident',{start:{line:1,column:25}}),'binary',{start:{line:1,column:23}}),'binary',{start:{line:1,column:14}})===assert._capt(three,'ident',{start:{line:1,column:35}}),'binary',{start:{line:1,column:30}}),{start:{line:1,column:7}}));");
+
+        inst("assert(!concat(fuga, piyo));",
+             "assert(assert._expr(assert._capt(!assert._capt(concat(assert._capt(fuga,'ident',{start:{line:1,column:15}}),assert._capt(piyo,'ident',{start:{line:1,column:21}})),'funcall',{start:{line:1,column:8}}),'unary',{start:{line:1,column:7}}),{start:{line:1,column:7}}));");
+    });
+
+
+    describe('AssignmentExpression', function () {
+        inst("assert(counter += 1);",
+             "assert(assert._expr(assert._capt(counter+=1,'assignment',{start:{line:1,column:15}}),{start:{line:1,column:7}}));");
+
+        inst("assert(dog.age += 1);",
+             "assert(assert._expr(assert._capt(dog.age+=1,'assignment',{start:{line:1,column:15}}),{start:{line:1,column:7}}));");
+    });
+
+
+    describe('ArrayExpression', function () {
+        inst("assert([foo, bar]);",
+             "assert(assert._expr([assert._capt(foo,'ident',{start:{line:1,column:8}}),assert._capt(bar,'ident',{start:{line:1,column:13}})],{start:{line:1,column:7}}));");
+
+        inst("assert(typeof [[foo.bar, baz(moo)], + fourStr] === 'number');",
+             "assert(assert._expr(assert._capt(assert._capt(typeof[[assert._capt(assert._capt(foo,'ident',{start:{line:1,column:16}}).bar,'ident',{start:{line:1,column:20}}),assert._capt(baz(assert._capt(moo,'ident',{start:{line:1,column:29}})),'funcall',{start:{line:1,column:25}})],assert._capt(+assert._capt(fourStr,'ident',{start:{line:1,column:38}}),'unary',{start:{line:1,column:36}})],'unary',{start:{line:1,column:7}})==='number','binary',{start:{line:1,column:47}}),{start:{line:1,column:7}}));");
+    });
+
 });

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

39717

increased by7.07%

Lines of code

739

increased by5.27%

Number of lines in readme file

29

increased by3.57%

No dependency changes