Allow optional arguments in complex expressions.

Author: kaste

src/lib/annotations/annotations.html

@@ -90,7 +90,7 @@
     },
 
     _bindingRegex: (function() {
-      var IDENT  = '(?:' + '[a-zA-Z_$][\\w.:$\\-*]*' + ')';
+      var IDENT  = '(?:' + '[?]?[a-zA-Z_$][\\w.:$\\-*]*' + ')';
       var NUMBER = '(?:' + '[-+]?[0-9]*\\.?[0-9]+(?:[eE][-+]?[0-9]+)?' + ')';
       var SQUOTE_STRING = '(?:' + '\'(?:[^\'\\\\]|\\\\.)*\'' + ')';
       var DQUOTE_STRING = '(?:' + '"(?:[^"\\\\]|\\\\.)*"' + ')';

src/lib/bind/effects.html

@@ -133,7 +133,7 @@
         } else {
           v = model[name];
         }
-        if (bailoutEarly && v === undefined) {
+        if (!arg.optional && bailoutEarly && v === undefined) {
           return;
         }
         if (arg.wildcard) {

src/standard/effectBuilder.html

@@ -289,6 +289,10 @@
       }
       // if not literal, look for structured path
       if (!a.literal) {
+        if (arg[0] === '?') {
+          a.optional = true;
+          a.name = arg = arg.slice(1);
+        }
         a.model = this._modelForPath(arg);
         // detect structured path (has dots)
         a.structured = arg.indexOf('.') > 0;

test/unit/bind-elements.html

@@ -682,3 +682,20 @@
     })
   </script>
 </dom-module>
+
+<dom-module id="x-optional-argument-on-computed-annotation">
+  <template>
+    <div id="check" prop="[[compute(?foo.bar, 'literal')]]"></div>
+  </template>
+  <script>
+    Polymer({
+      is: 'x-optional-argument-on-computed-annotation',
+      properties: {
+        foo: Object,
+      },
+      compute: function(bar, literal) {
+        return bar + literal;
+      }
+    })
+  </script>
+</dom-module>

test/unit/bind.html

@@ -398,17 +398,10 @@
 
   var el;
 
-  setup(function() {
-    el = document.createElement('x-undefined-default-for-computeds');
-    document.body.appendChild(el);
-  });
-
-  teardown(function() {
-    document.body.removeChild(el);
-  });
-
   test('if an argument becomes unreachable, set undefined (annotation)',
        function() {
+    el = document.createElement('x-undefined-default-for-computeds');
+
     el.foo = {bar: 'quux'};
     assert.equal(el.$.check.prop, 'quuxliteral');
 
@@ -418,13 +411,51 @@
 
   test('if an argument becomes unreachable, set undefined (computed)',
        function() {
+    el = document.createElement('x-undefined-default-for-computeds');
+
     el.foo = {bar: 'quux'};
     assert.equal(el.computed, 'quuxliteral');
 
     el.foo = {baz: 'quod'};
     assert.equal(el.computed, undefined);
   });
 
+  test('optional arguments can be undefined', function() {
+    var called = 0;
+    var calledWith;
+    Polymer({
+      is: 'optional-arguments-can-be-undefined',
+      properties: {
+        foo: Object
+      },
+      observers: ['compute(?foo.bar, "literal")'],
+
+      compute: function(bar, literal) {
+        called += 1;
+        calledWith = [bar, literal];
+      }
+    });
+
+    el = document.createElement('optional-arguments-can-be-undefined');
+
+    el.foo = {bar: 'quux'};
+    assert.equal(called, 1);
+    assert.deepEqual(calledWith, ['quux', 'literal']);
+
+    el.foo = {baz: 'quod'};
+    assert.equal(called, 2);
+    assert.deepEqual(calledWith, [undefined, 'literal']);
+  });
+
+  test('check that optional arguments work on annotations', function() {
+    el = document.createElement("x-optional-argument-on-computed-annotation");
+
+    el.foo = {bar: 'quux'};
+    assert.equal(el.$.check.prop, 'quuxliteral');
+
+    el.foo = {baz: 'quod'};
+    assert.equal(el.$.check.prop, 'undefinedliteral');
+  });
 });
 
 </script>