* remove bogus support for arbitrary JSON in literal arguments, literal arguments must now be either String or Number

* support using escaped-commas in literal-string arguments: `compute("foo\,bar", zot, 3)`
* support other character escaping which is naturally broken by HTML parser `compute('foo\'bar')`
* test for literal argument _before_ looking for structured args

Author: Scott J Miles

src/standard/effectBuilder.html

@@ -168,14 +168,13 @@
     _parseMethod: function(expression) {
       var m = expression.match(/(\w*)\((.*)\)/);
       if (m) {
-        return this._parseArgs({
-          method: m[1],
-          static: true
-        }, m[2].split(','));
+        // replace escaped commas with comma entity, split on un-escaped commas
+        var args = m[2].replace(/\\,/g, ',').split(',');
+        return this._parseArgs(args, { method: m[1], static: true });
       }
     },
 
-    _parseArgs: function(effect, argList) {
+    _parseArgs: function(argList, effect) {
       effect.args = argList.map(function(rawArg) {
         var arg = this._parseArg(rawArg);
         if (!arg.literal) {
@@ -187,40 +186,43 @@
     },
 
     _parseArg: function(rawArg) {
-      // clean up string
-      var arg = String(rawArg).trim();
+      // clean up whitespace
+      var arg = String(rawArg).trim()
+        // replace comma entity with comma
+        .replace(/,/g, ',')
+        // repair escape sequences
+        .replace(/\\(.)/g, '\$1')
+        ;
       // basic argument descriptor
       var a = {
         name: arg,
         model: this._modelForPath(arg)
       };
-      // detect structured path (has dots)
-      a.structured = arg.indexOf('.') > 0;
-      if (a.structured) {
-        a.wildcard = (arg.slice(-2) == '.*');
-        if (a.wildcard) {
-          a.name = arg.slice(0, -2);
-        }
-      } else {
-        // detect literal value (must be JSON)
-        var fc = arg[0];
-        if (fc >= '0' && fc <= '9') {
-          fc = '#';
-        }
-        switch(fc) {
-          // TODO(sjmiles): single-quote is invalid JSON
-          //case "'":
-          case '"':
-          case '{':
-          case '[':
-          case '#':
-            try {
-              a.value = JSON.parse(arg);
-              a.literal = true;
-            } catch(x) {
-              // warn?
-            }
-            break;
+      // detect literal value (must be String or Number)
+      var fc = arg[0];
+      if (fc >= '0' && fc <= '9') {
+        fc = '#';
+      }
+      switch(fc) {
+        case "'":
+        case '"':
+          a.value = arg.slice(1, -1);
+          a.literal = true;
+          break;
+        case '#':
+          a.value = Number(arg);
+          a.literal = true;
+          break;
+      }
+      // if not literal, look for structured path
+      if (!a.literal) {
+        // detect structured path (has dots)
+        a.structured = arg.indexOf('.') > 0;
+        if (a.structured) {
+          a.wildcard = (arg.slice(-2) == '.*');
+          if (a.wildcard) {
+            a.name = arg.slice(0, -2);
+          }
         }
       }
       return a;

test/unit/bind-elements.html

@@ -15,12 +15,15 @@
     custom-event-value="{{customEventValue::custom}}"
     custom-event-object-value="{{customEventObject.value::change}}"
     computed-from-mixed-literals='{{computeFromLiterals(3, "foo", bool)}}'
-    computed-from-pure-literals='{{computeFromLiterals(3, "foo")}}'
+    computed-from-pure-literals='{{computeFromLiterals( 3, "foo")}}'
+    computed-from-tricky-literals="{{computeFromTrickyLiterals(3, 'tricky\,\'zot\'')}}"
+    computed-from-tricky-literals2='{{computeFromTrickyLiterals(3,"tricky\,\'zot\'" )}}'
     >
     Test
     </div>
     <span id="boundText">{{text}}</span>
     <span idtest id="{{boundId}}"></span>
+    <s id="computedContent">{{computeFromTrickyLiterals(3, 'tricky\,\'zot\'')}}</s>
 </template>
 <script>
   Polymer({
@@ -192,6 +195,9 @@
       assert.equal(num, 3);
       assert.equal(str, 'foo');
       return num + str;
+    },
+    computeFromTrickyLiterals: function(a, b) {
+      return a + b;
     }
   });
 </script>

test/unit/bind.html

@@ -142,6 +142,8 @@
     el.bool = true;
     assert.equal(el.$.boundChild.computedFromMixedLiterals, '3foo', 'Wrong result from mixed literal arg computation');
     assert.equal(el.$.boundChild.computedFromPureLiterals, '3foo', 'Wrong result from pure literal arg computation');
+    assert.equal(el.$.boundChild.computedFromTrickyLiterals, '3tricky,\'zot\'', 'Wrong result from tricky literal arg computation');
+    assert.equal(el.$.computedContent.textContent, '3tricky,\'zot\'', 'Wrong textContent from tricky literal arg computation');
   });
 
   test('no read-only observer called with assignment', function() {