Merge branch 'master' of github.com:sstephenson/prototype

Author: savetheclocktower

src/prototype/ajax/request.js

@@ -49,7 +49,7 @@
  *  status-specific callback is defined, it gets invoked. Otherwise, if
  *  `onSuccess` is defined and the response is deemed a success (see below), it
  *  is invoked. Otherwise, if `onFailure` is defined and the response is *not*
- *  deemed a sucess, it is invoked. Only after that potential first callback is
+ *  deemed a success, it is invoked. Only after that potential first callback is
  *  `onComplete` called.
  *  
  *  ##### A note on portability
@@ -259,8 +259,10 @@ Ajax.Request = Class.create(Ajax.Base, {
         $H(extras).each(function(pair) { headers[pair.key] = pair.value });
     }
 
+    // skip null or undefined values
     for (var name in headers)
-      this.transport.setRequestHeader(name, headers[name]);
+      if (headers[name] != null)
+        this.transport.setRequestHeader(name, headers[name]);
   },
 
   /**

src/prototype/dom/dom.js

@@ -1486,6 +1486,7 @@
 
   /**
    *  Element.siblings(@element) -> [Element...]
+   *
    *  Collects all of element's siblings and returns them as an [[Array]] of
    *  elements.
    *
@@ -1793,6 +1794,7 @@
    *      // -> undefined
   **/
   function down(element, expression, index) {
+    if (arguments.length === 1) return firstDescendant(element);
     element = $(element), expression = expression || 0, index = index || 0;
 
     if (Object.isNumber(expression))
@@ -2369,7 +2371,7 @@
       name = table.names[attr] || attr;
       value = attributes[attr];
       if (table.values[attr])
-        name = table.values[attr](element, value);
+        name = table.values[attr](element, value) || name;
       if (value === false || value === null)
         element.removeAttribute(name);
       else if (value === true)
@@ -2928,7 +2930,7 @@
   }
 
   function hasLayout_IE(element) {
-    if (!element.currentStyle.hasLayout)
+    if (!element.currentStyle || !element.currentStyle.hasLayout)
       element.style.zoom = 1;
     return element;
   }
@@ -3016,7 +3018,7 @@
     var filter = Element.getStyle(element, 'filter');
     if (filter.length === 0) return 1.0;
     var match = (filter || '').match(/alpha\(opacity=(.*)\)/);
-    if (match[1]) return parseFloat(match[1]) / 100;
+    if (match && match[1]) return parseFloat(match[1]) / 100;
     return 1.0;
   }
 
@@ -3484,5 +3486,14 @@
   }
 
   Element.addMethods(methods);
-  
-})(this);
+
+  // Prevent IE leaks on DIV and ELEMENT_CACHE
+  function destroyCache_IE() {
+    DIV = null;
+    ELEMENT_CACHE = null;
+  }
+
+  if (window.attachEvent)
+    window.attachEvent('onunload', destroyCache_IE);
+
+})(this);

src/prototype/dom/event.js

@@ -244,10 +244,7 @@
 
     // Fix a Safari bug where a text node gets passed as the target of an
     // anchor click rather than the anchor itself.
-    if (node.nodeType == Node.TEXT_NODE)
-      node = node.parentNode;
-
-    return Element.extend(node);
+    return node.nodeType == Node.TEXT_NODE ? node.parentNode : node;
   }
 
   /**
@@ -260,8 +257,7 @@
    *  its ancestor chain. If `expression` is not given, the element which fired
    *  the event is returned.
    *  
-   *  *If no matching element is found, the document itself (`HTMLDocument` node)
-   *  is returned.*
+   *  *If no matching element is found, `undefined` is returned.*
    *  
    *  ##### Example
    *  
@@ -270,15 +266,15 @@
    *  
    *      document.observe('click', function(event) {
    *        var element = event.findElement('p');
-   *        if (element != document)
+   *        if (element)
    *          $(element).hide();
    *      });
   **/
   function findElement(event, expression) {
-    var element = _element(event), match = Prototype.Selector.match;
+    var element = _element(event), selector = Prototype.Selector;
     if (!expression) return Element.extend(element);
     while (element) {
-      if (Object.isElement(element) && match(element, expression))
+      if (Object.isElement(element) && selector.match(element, expression))
         return Element.extend(element);
       element = element.parentNode;
     }
@@ -898,14 +894,17 @@
   // for bulk removal of event listeners. We use them rather than recurse
   // back into `stopObserving` to avoid touching the registry more often than
   // necessary.
-  
+
   // Stop observing _all_ listeners on an element.
   function stopObservingElement(element) {
-    var uid = getUniqueElementID(element),
-     registry = getRegistryForElement(element, uid);
-    
+    // Do a manual registry lookup because we don't want to create a registry
+    // if one doesn't exist.
+    var uid = getUniqueElementID(element), registry = GLOBAL.Event.cache[uid];
+    // This way we can return early if there is no registry.
+    if (!registry) return;
+
     destroyRegistryForElement(element, uid);
-    
+
     var entries, i;
     for (var eventName in registry) {
       // Explicitly skip elements so we don't accidentally find one with a
@@ -1276,7 +1275,7 @@
     stopObserving: stopObserving.methodize(),
 
     /**
-     *  Element.on(@element, eventName[, selector], callback) -> Event.Handler
+     *  document.on(@element, eventName[, selector], callback) -> Event.Handler
      *  
      *  See [[Event.on]].
     **/
@@ -1331,17 +1330,17 @@
       return createMouseEnterLeaveResponder(uid, eventName, handler);
 
     return function(event) {
-      var cacheEntry = Event.cache[uid];
-      var element = cacheEntry.element;
-
+      if (!Event.cache) return;
+      
+      var element = Event.cache[uid].element;
       Event.extend(event, element);
       handler.call(element, event);
     };
   }
 
   function createResponderForCustomEvent(uid, eventName, handler) {
     return function(event) {
-      var cacheEntry = Event.cache[uid], element = cacheEntry.element;
+      var element = Event.cache[uid].element;
 
       if (Object.isUndefined(event.eventName))
         return false;
@@ -1356,8 +1355,8 @@
 
   function createMouseEnterLeaveResponder(uid, eventName, handler) {
     return function(event) {
-      var cacheEntry = Event.cache[uid], element = cacheEntry.element;
-
+      var element = Event.cache[uid].element;
+      
       Event.extend(event, element);
       var parent = event.relatedTarget;
 
@@ -1408,6 +1407,15 @@
 
     fireContentLoadedEvent();
   }
+
+
+  if (document.readyState === 'complete') {
+    // We must have been loaded asynchronously, because the DOMContentLoaded
+    // event has already fired. We can just fire `dom:loaded` and be done
+    // with it.
+    fireContentLoadedEvent();
+    return;
+  }
 
   if (document.addEventListener) {
     // All browsers that support DOM L2 Events support DOMContentLoaded,

src/prototype/dom/form.js

@@ -113,22 +113,27 @@ var Form = {
       accumulator = function(result, key, value) {
         if (key in result) {
           if (!Object.isArray(result[key])) result[key] = [result[key]];
-          result[key].push(value);
+          result[key] = result[key].concat(value);
         } else result[key] = value;
         return result;
       };
     } else {
       initial = '';
-      accumulator = function(result, key, value) {
-        // Normalize newlines as \r\n because the HTML spec says newlines should
-        // be encoded as CRLFs.
-        value = value.gsub(/(\r)?\n/, '\r\n');
-        value = encodeURIComponent(value);
-        // Likewise, according to the spec, spaces should be '+' rather than
-        // '%20'.
-        value = value.gsub(/%20/, '+');
-        return result + (result ? '&' : '') + encodeURIComponent(key) + '=' + value;
-      }
+      accumulator = function(result, key, values) {
+        if (!Object.isArray(values)) {values = [values];}
+        if (!values.length) {return result;}
+        // According to the spec, spaces should be '+' rather than '%20'.
+        var encodedKey = encodeURIComponent(key).gsub(/%20/, '+');
+        return result + (result ? "&" : "") + values.map(function (value) {
+          // Normalize newlines as \r\n because the HTML spec says newlines should
+          // be encoded as CRLFs.
+          value = value.gsub(/(\r)?\n/, '\r\n');
+          value = encodeURIComponent(value);
+          // According to the spec, spaces should be '+' rather than '%20'.
+          value = value.gsub(/%20/, '+');
+          return encodedKey + "=" + value;
+        }).join("&");
+      };
     }
 
     return elements.inject(initial, function(result, element) {

src/prototype/dom/layout.js

@@ -1144,7 +1144,8 @@
   function viewportOffset(forElement) {
     var valueT = 0, valueL = 0, docBody = document.body;
 
-    var element = $(forElement);
+    forElement = $(forElement);
+    var element = forElement;
     do {
       valueT += element.offsetTop  || 0;
       valueL += element.offsetLeft || 0;
@@ -1187,10 +1188,11 @@
     var layout = element.getLayout();    
 
     element.store('prototype_absolutize_original_styles', {
-      left:   element.getStyle('left'),
-      top:    element.getStyle('top'),
-      width:  element.getStyle('width'),
-      height: element.getStyle('height')
+      position: element.getStyle('position'),
+      left:     element.getStyle('left'),
+      top:      element.getStyle('top'),
+      width:    element.getStyle('width'),
+      height:   element.getStyle('height')
     });
 
     element.setStyle({

src/prototype/lang/array.js

@@ -647,16 +647,15 @@ Array.from = $A;
   }
 
   /**
-   *  Array#some([iterator = Prototype.K[, context]]) -> Array
+   *  Array#some([iterator = Prototype.K[, context]]) -> Boolean
    *  - iterator (Function): An optional function to use to evaluate each
    *    element in the enumeration; the function should return the value to
    *    test. If this is not provided, the element itself is tested.
    *  - context (Object): An optional object to use as `this` within
    *    calls to the iterator.
    *
-   *  Returns the result of applying `iterator` to each item in the array. If
-   *  no iterator is provided, the elements are simply copied to the returned
-   *  array.
+   *  Determines whether at least one element is truthy (boolean-equivalent to
+   *  `true`), either directly or through computation by the provided iterator.
    *
    *  `Array#some` acts as an ECMAScript 5 [polyfill](http://remysharp.com/2010/10/08/what-is-a-polyfill/).
    *  It is only defined if not already present in the user's browser, and it
@@ -692,7 +691,7 @@ Array.from = $A;
    *  - context (Object): An optional object to use as `this` within
    *    calls to the iterator.
    *
-   *  Determines whether at least one element is truthy (boolean-equivalent to
+   *  Determines whether all elements are truthy (boolean-equivalent to
    *  `true`), either directly or through computation by the provided iterator.
    *
    *  `Array#every` acts as an ECMAScript 5 [polyfill](http://remysharp.com/2010/10/08/what-is-a-polyfill/).

src/prototype/lang/enumerable.js

@@ -5,7 +5,7 @@
  *  objects that act as collections of values. It is a cornerstone of
  *  Prototype.
  *
- *  [[Enumerable]] is a _mixin_: a set of methods intended not for standaone
+ *  [[Enumerable]] is a _mixin_: a set of methods intended not for standalone
  *  use, but for incorporation into other objects.
  *
  *  Prototype mixes [[Enumerable]] into several classes. The most visible cases
@@ -30,7 +30,42 @@
  *
  *  If there is no `context` argument, the iterator function will execute in
  *  the scope from which the [[Enumerable]] method itself was called.
- *
+ *  
+ *  ##### Flow control
+ *  
+ *  You might find yourself missing the `break` and `continue` keywords that
+ *  are available in ordinary `for` loops. If you need to break out of an
+ *  enumeration before it's done, you can throw a special object named
+ *  `$break`:
+ *  
+ *      var myObject = {};
+ * 
+ *      ['foo', 'bar', 'baz', 'thud'].each( function(name, index) {
+ *        if (name === 'baz') throw $break;
+ *        myObject[name] = index;
+ *      });
+ *  
+ *      myObject;
+ *      // -> { foo: 0, bar: 1 }
+ *  
+ *  Though we're technically throwing an exception, the `each` method knows
+ *  to catch a thrown `$break` object and treat it as a command to stop
+ *  iterating. (_Any_ exception thrown within an iterator will stop
+ *  iteration, but only `$break` will be caught and suppressed.)
+ *  
+ *  If you need `continue`-like behavior, you can simply return early from
+ *  your iterator:
+ *  
+ *      var myObject = {};
+ *  
+ *      ['foo', 'bar', 'baz', 'thud'].each( function(name, index) {
+ *        if (name === 'baz') return;
+ *        myObject[name] = index;
+ *      });
+ *  
+ *      myObject;
+ *      // -> { foo: 0, bar: 1, thud: 3 }
+ *  
  *  ##### Mixing [[Enumerable]] into your own objects
  *
  *  So, let's say you've created your very own collection-like object (say,
@@ -367,8 +402,8 @@ var Enumerable = (function() {
    *      // -> true ('3' == 3)
   **/
   function include(object) {
-    if (Object.isFunction(this.indexOf))
-      if (this.indexOf(object) != -1) return true;
+    if (Object.isFunction(this.indexOf) && this.indexOf(object) != -1)
+      return true;
 
     var found = false;
     this.each(function(value) {

src/prototype/lang/function.js

@@ -123,7 +123,7 @@ Object.extend(Function.prototype, (function() {
     var __method = this, args = slice.call(arguments, 1);
 
     var bound = function() {
-      var a = merge(args, arguments), c = context;
+      var a = merge(args, arguments);
       // Ignore the supplied context when the bound function is called with
       // the "new" keyword.
       var c = this instanceof bound ? this : context;

src/prototype/lang/hash.js

@@ -94,11 +94,13 @@ var Hash = Class.create(Enumerable, (function() {
 
   // Our _internal_ each
   function _each(iterator, context) {
+    var i = 0;
     for (var key in this._object) {
       var value = this._object[key], pair = [key, value];
       pair.key = key;
       pair.value = value;
-      iterator.call(context, pair);
+      iterator.call(context, pair, i);
+      i++;
     }
   }
 
@@ -289,7 +291,7 @@ var Hash = Class.create(Enumerable, (function() {
   function toQueryPair(key, value) {
     if (Object.isUndefined(value)) return key;
 
-    var value = String.interpret(value);
+    value = String.interpret(value);
 
     // Normalize newlines as \r\n because the HTML spec says newlines should
     // be encoded as CRLFs.