Merge lp:~methanal-developers/methanal/coerce-MockHTMLSelectElement-value into lp:methanal

[Jonathan Jacobs]

[Tristan Seligmann (mithrandi)]

review: Approve

=== modified file 'methanal/js/Methanal/Tests/MockBrowser.js'
--- methanal/js/Methanal/Tests/MockBrowser.js	2010-01-09 13:29:56 +0000
+++ methanal/js/Methanal/Tests/MockBrowser.js	2010-07-14 12:14:42 +0000
@@ -31,6 +31,17 @@
 
 /**
  * HTMLSelectElement mock implementation.
+ *
+ * Assigning to the C{'value'} attribute tries to follow the behaviour of HTML5
+ * (which is generally the behaviour that Firefox (as of 3.6.7) follows too)::
+ *     The value IDL attribute, on getting, must return the value of the first option
+ *     element in the list of options in tree order that has its selectedness set to
+ *     true, if any. If there isn't one, then it must return the empty string.
+ *
+ *     On setting, the value attribute must set the selectedness of all the option
+ *     elements in the list of options to false, and then first the option element in
+ *     the list of options, in tree order, whose value is equal to the given new
+ *     value, if any, must have its selectedness set to true.
  */
 Methanal.Tests.MockBrowser.Element.subclass(
     Methanal.Tests.MockBrowser, 'MockHTMLSelectElement').methods(
@@ -38,6 +49,29 @@
         Methanal.Tests.MockBrowser.MockHTMLSelectElement.upcall(
             self, '__init__', 'select');
         self.options = [];
+
+        Methanal.Tests.Util.defineGetter(self, 'value', function () {
+            for (var i = 0; i < self.options.length; ++i) {
+                var option = self.options[i];
+                if (option.selected) {
+                    return option.value;
+                }
+            }
+            return '';
+        });
+
+        Methanal.Tests.Util.defineSetter(self, 'value', function (v) {
+            var found = false;
+            for (var i = 0; i < self.options.length; ++i) {
+                var option = self.options[i];
+                if (found === false && v == option.value) {
+                    option.selected = true;
+                    found = true;
+                } else {
+                    option.selected = false;
+                }
+            }
+        });
     },
 
 
@@ -58,6 +92,49 @@
 
 
 /**
+ * HTMLOptionElement mock implementation.
+ *
+ * Assignments to the C{'value'} attribute try to follow the behaviour of
+ * Firefox (as of 3.6.7), generally this means the value is coerced to a
+ * C{String}.
+ */
+Methanal.Tests.MockBrowser.Element.subclass(
+    Methanal.Tests.MockBrowser, 'MockHTMLOptionElement').methods(
+    function __init__(self) {
+        Methanal.Tests.MockBrowser.MockHTMLOptionElement.upcall(
+            self, '__init__', 'option');
+        self.selected = false;
+        self._value = '';
+
+        Methanal.Tests.Util.defineGetter(self, 'value', function () {
+            return self._value;
+        });
+
+        Methanal.Tests.Util.defineSetter(self, 'value', function (v) {
+            if (v === undefined) {
+                /* Seriously, this is real (Firefox 3.6.7):
+                 *  >>> o
+                 *  <option value="">
+                 *  >>> o.value = undefined;
+                 *  >>> o.value
+                 *  "undefined"
+                 *  >>> o.value = null;
+                 *  >>> o.value
+                 *  ""
+                 */
+                v = 'undefined';
+            } else if (v === null) {
+                v = '';
+            } else {
+                v = v.toString();
+            }
+            self._value = v;
+        });
+    });
+
+
+
+/**
  * HTMLTableRowElement mock implementation.
  */
 Methanal.Tests.MockBrowser.Element.subclass(
@@ -191,6 +268,8 @@
         document.registerElementTag(
             'select', Methanal.Tests.MockBrowser.MockHTMLSelectElement);
         document.registerElementTag(
+            'option', Methanal.Tests.MockBrowser.MockHTMLOptionElement);
+        document.registerElementTag(
             'table', Methanal.Tests.MockBrowser.MockHTMLTableElement);
         document.registerElementTag(
             'thead', Methanal.Tests.MockBrowser.MockHTMLTableSectionElement);

=== modified file 'methanal/js/Methanal/Tests/TestView.js'
--- methanal/js/Methanal/Tests/TestView.js	2010-07-14 10:13:31 +0000
+++ methanal/js/Methanal/Tests/TestView.js	2010-07-14 12:14:42 +0000
@@ -421,10 +421,9 @@
                 control.append(1, 'd2');
                 control.setValue('1');
                 self.assertIdentical(control.inputNode.value, '1');
-                // XXX: This should work, but the mock DOM stuff doesn't coerce
-                // the values of select inputs.
-                //control.setValue(1);
-                //self.assertIdentical(control.inputNode.value, '1');
+                // Coerce values of select inputs and options.
+                control.setValue(1);
+                self.assertIdentical(control.inputNode.value, '1');
             });
     },
 

=== modified file 'methanal/js/Methanal/Tests/Util.js'
--- methanal/js/Methanal/Tests/Util.js	2010-07-02 20:46:39 +0000
+++ methanal/js/Methanal/Tests/Util.js	2010-07-14 12:14:42 +0000
@@ -63,3 +63,50 @@
     form.node.appendChild(actions.node);
     document.body.appendChild(form.node);
 };
+
+
+
+/**
+ * Create an accessor descriptor for a setter or getter property.
+ */
+Methanal.Tests.Util.accessorDescriptor =
+function accessorDescriptor(field, fun) {
+    var desc = {
+        enumerable: true,
+        configurable: true};
+    desc[field] = fun;
+    return desc;
+}
+
+
+
+/**
+ * Define a getter property for an attribute named C{prop} on C{obj} with the
+ * function C{get}.
+ */
+Methanal.Tests.Util.defineGetter = function defineGetter(obj, prop, get) {
+    if (Object.defineProperty) {
+        return Object.defineProperty(
+            obj, prop, Methanal.Tests.Util.accessorDescriptor('get', get));
+    }
+    if (Object.prototype.__defineGetter__) {
+        return obj.__defineGetter__(prop, get);
+    }
+    throw new Error('Getter properties not supported!');
+}
+
+
+/**
+ * Define a setter property for an attribute named C{prop} on C{obj} with the
+ * function C{set}.
+ */
+Methanal.Tests.Util.defineSetter = function defineSetter(obj, prop, set) {
+    if (Object.defineProperty) {
+        return Object.defineProperty(
+            obj, prop, Methanal.Tests.Util.accessorDescriptor('set', set));
+    }
+    if (Object.prototype.__defineSetter__) {
+        return obj.__defineSetter__(prop, set);
+    }
+    throw new Error('Setter properties not supported!');
+}