parsejs-rails 1.2.2.0 → 1.2.7.0

data/vendor/assets/javascripts/parse.js

@@ -1,7 +1,7 @@
 /*!
  * Parse JavaScript SDK
- * Version: 1.2.2
- * Built: Tue Mar 05 2013 13:27:37
+ * Version: 1.2.7
+ * Built: Wed Apr 17 2013 14:48:27
  * http://parse.com
  *
  * Copyright 2013 Parse, Inc.
@@ -13,17 +13,12 @@
  */
 (function(root) {
   root.Parse = root.Parse || {};
-  root.Parse.VERSION = "js1.2.2";
+  root.Parse.VERSION = "js1.2.7";
 }(this));
-
-
-//     Underscore.js 1.3.3
-//     (c) 2009-2012 Jeremy Ashkenas, DocumentCloud Inc.
-//     Underscore is freely distributable under the MIT license.
-//     Portions of Underscore are inspired or borrowed from Prototype,
-//     Oliver Steele's Functional, and John Resig's Micro-Templating.
-//     For all details and documentation:
-//     http://documentcloud.github.com/underscore
+//     Underscore.js 1.4.4
+//     http://underscorejs.org
+//     (c) 2009-2013 Jeremy Ashkenas, DocumentCloud Inc.
+//     Underscore may be freely distributed under the MIT license.
 
 (function() {
 
@@ -43,8 +38,9 @@
   var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;
 
   // Create quick reference variables for speed access to core prototypes.
-  var slice            = ArrayProto.slice,
-      unshift          = ArrayProto.unshift,
+  var push             = ArrayProto.push,
+      slice            = ArrayProto.slice,
+      concat           = ArrayProto.concat,
       toString         = ObjProto.toString,
       hasOwnProperty   = ObjProto.hasOwnProperty;
 
@@ -65,7 +61,11 @@
     nativeBind         = FuncProto.bind;
 
   // Create a safe reference to the Underscore object for use below.
-  var _ = function(obj) { return new wrapper(obj); };
+  var _ = function(obj) {
+    if (obj instanceof _) return obj;
+    if (!(this instanceof _)) return new _(obj);
+    this._wrapped = obj;
+  };
 
   // Export the Underscore object for **Node.js**, with
   // backwards-compatibility for the old `require()` API. If we're in
@@ -77,11 +77,11 @@
     }
     exports._ = _;
   } else {
-    root['_'] = _;
+    root._ = _;
   }
 
   // Current version.
-  _.VERSION = '1.3.3';
+  _.VERSION = '1.4.4';
 
   // Collection Functions
   // --------------------
@@ -95,7 +95,7 @@
       obj.forEach(iterator, context);
     } else if (obj.length === +obj.length) {
       for (var i = 0, l = obj.length; i < l; i++) {
-        if (i in obj && iterator.call(context, obj[i], i, obj) === breaker) return;
+        if (iterator.call(context, obj[i], i, obj) === breaker) return;
       }
     } else {
       for (var key in obj) {
@@ -115,10 +115,11 @@
     each(obj, function(value, index, list) {
       results[results.length] = iterator.call(context, value, index, list);
     });
-    if (obj.length === +obj.length) results.length = obj.length;
     return results;
   };
 
+  var reduceError = 'Reduce of empty array with no initial value';
+
   // **Reduce** builds up a single result from a list of values, aka `inject`,
   // or `foldl`. Delegates to **ECMAScript 5**'s native `reduce` if available.
   _.reduce = _.foldl = _.inject = function(obj, iterator, memo, context) {
@@ -136,7 +137,7 @@
         memo = iterator.call(context, memo, value, index, list);
       }
     });
-    if (!initial) throw new TypeError('Reduce of empty array with no initial value');
+    if (!initial) throw new TypeError(reduceError);
     return memo;
   };
 
@@ -149,9 +150,22 @@
       if (context) iterator = _.bind(iterator, context);
       return initial ? obj.reduceRight(iterator, memo) : obj.reduceRight(iterator);
     }
-    var reversed = _.toArray(obj).reverse();
-    if (context && !initial) iterator = _.bind(iterator, context);
-    return initial ? _.reduce(reversed, iterator, memo, context) : _.reduce(reversed, iterator);
+    var length = obj.length;
+    if (length !== +length) {
+      var keys = _.keys(obj);
+      length = keys.length;
+    }
+    each(obj, function(value, index, list) {
+      index = keys ? keys[--length] : --length;
+      if (!initial) {
+        memo = obj[index];
+        initial = true;
+      } else {
+        memo = iterator.call(context, memo, obj[index], index, list);
+      }
+    });
+    if (!initial) throw new TypeError(reduceError);
+    return memo;
   };
 
   // Return the first value which passes a truth test. Aliased as `detect`.
@@ -181,18 +195,16 @@
 
   // Return all the elements for which a truth test fails.
   _.reject = function(obj, iterator, context) {
-    var results = [];
-    if (obj == null) return results;
-    each(obj, function(value, index, list) {
-      if (!iterator.call(context, value, index, list)) results[results.length] = value;
-    });
-    return results;
+    return _.filter(obj, function(value, index, list) {
+      return !iterator.call(context, value, index, list);
+    }, context);
   };
 
   // Determine whether all of the elements match a truth test.
   // Delegates to **ECMAScript 5**'s native `every` if available.
   // Aliased as `all`.
   _.every = _.all = function(obj, iterator, context) {
+    iterator || (iterator = _.identity);
     var result = true;
     if (obj == null) return result;
     if (nativeEvery && obj.every === nativeEvery) return obj.every(iterator, context);
@@ -216,23 +228,22 @@
     return !!result;
   };
 
-  // Determine if a given value is included in the array or object using `===`.
-  // Aliased as `contains`.
-  _.include = _.contains = function(obj, target) {
-    var found = false;
-    if (obj == null) return found;
+  // Determine if the array or object contains a given value (using `===`).
+  // Aliased as `include`.
+  _.contains = _.include = function(obj, target) {
+    if (obj == null) return false;
     if (nativeIndexOf && obj.indexOf === nativeIndexOf) return obj.indexOf(target) != -1;
-    found = any(obj, function(value) {
+    return any(obj, function(value) {
       return value === target;
     });
-    return found;
   };
 
   // Invoke a method (with arguments) on every item in a collection.
   _.invoke = function(obj, method) {
     var args = slice.call(arguments, 2);
+    var isFunc = _.isFunction(method);
     return _.map(obj, function(value) {
-      return (_.isFunction(method) ? method || value : value[method]).apply(value, args);
+      return (isFunc ? method : value[method]).apply(value, args);
     });
   };
 
@@ -241,11 +252,33 @@
     return _.map(obj, function(value){ return value[key]; });
   };
 
+  // Convenience version of a common use case of `filter`: selecting only objects
+  // containing specific `key:value` pairs.
+  _.where = function(obj, attrs, first) {
+    if (_.isEmpty(attrs)) return first ? null : [];
+    return _[first ? 'find' : 'filter'](obj, function(value) {
+      for (var key in attrs) {
+        if (attrs[key] !== value[key]) return false;
+      }
+      return true;
+    });
+  };
+
+  // Convenience version of a common use case of `find`: getting the first object
+  // containing specific `key:value` pairs.
+  _.findWhere = function(obj, attrs) {
+    return _.where(obj, attrs, true);
+  };
+
   // Return the maximum element or (element-based computation).
+  // Can't optimize arrays of integers longer than 65,535 elements.
+  // See: https://bugs.webkit.org/show_bug.cgi?id=80797
   _.max = function(obj, iterator, context) {
-    if (!iterator && _.isArray(obj) && obj[0] === +obj[0]) return Math.max.apply(Math, obj);
+    if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) {
+      return Math.max.apply(Math, obj);
+    }
     if (!iterator && _.isEmpty(obj)) return -Infinity;
-    var result = {computed : -Infinity};
+    var result = {computed : -Infinity, value: -Infinity};
     each(obj, function(value, index, list) {
       var computed = iterator ? iterator.call(context, value, index, list) : value;
       computed >= result.computed && (result = {value : value, computed : computed});
@@ -255,9 +288,11 @@
 
   // Return the minimum element (or element-based computation).
   _.min = function(obj, iterator, context) {
-    if (!iterator && _.isArray(obj) && obj[0] === +obj[0]) return Math.min.apply(Math, obj);
+    if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) {
+      return Math.min.apply(Math, obj);
+    }
     if (!iterator && _.isEmpty(obj)) return Infinity;
-    var result = {computed : Infinity};
+    var result = {computed : Infinity, value: Infinity};
     each(obj, function(value, index, list) {
       var computed = iterator ? iterator.call(context, value, index, list) : value;
       computed < result.computed && (result = {value : value, computed : computed});
@@ -267,67 +302,96 @@
 
   // Shuffle an array.
   _.shuffle = function(obj) {
-    var shuffled = [], rand;
-    each(obj, function(value, index, list) {
-      rand = Math.floor(Math.random() * (index + 1));
-      shuffled[index] = shuffled[rand];
+    var rand;
+    var index = 0;
+    var shuffled = [];
+    each(obj, function(value) {
+      rand = _.random(index++);
+      shuffled[index - 1] = shuffled[rand];
       shuffled[rand] = value;
     });
     return shuffled;
   };
 
+  // An internal function to generate lookup iterators.
+  var lookupIterator = function(value) {
+    return _.isFunction(value) ? value : function(obj){ return obj[value]; };
+  };
+
   // Sort the object's values by a criterion produced by an iterator.
-  _.sortBy = function(obj, val, context) {
-    var iterator = _.isFunction(val) ? val : function(obj) { return obj[val]; };
+  _.sortBy = function(obj, value, context) {
+    var iterator = lookupIterator(value);
     return _.pluck(_.map(obj, function(value, index, list) {
       return {
         value : value,
+        index : index,
         criteria : iterator.call(context, value, index, list)
       };
     }).sort(function(left, right) {
-      var a = left.criteria, b = right.criteria;
-      if (a === void 0) return 1;
-      if (b === void 0) return -1;
-      return a < b ? -1 : a > b ? 1 : 0;
+      var a = left.criteria;
+      var b = right.criteria;
+      if (a !== b) {
+        if (a > b || a === void 0) return 1;
+        if (a < b || b === void 0) return -1;
+      }
+      return left.index < right.index ? -1 : 1;
     }), 'value');
   };
 
-  // Groups the object's values by a criterion. Pass either a string attribute
-  // to group by, or a function that returns the criterion.
-  _.groupBy = function(obj, val) {
+  // An internal function used for aggregate "group by" operations.
+  var group = function(obj, value, context, behavior) {
     var result = {};
-    var iterator = _.isFunction(val) ? val : function(obj) { return obj[val]; };
+    var iterator = lookupIterator(value || _.identity);
     each(obj, function(value, index) {
-      var key = iterator(value, index);
-      (result[key] || (result[key] = [])).push(value);
+      var key = iterator.call(context, value, index, obj);
+      behavior(result, key, value);
     });
     return result;
   };
 
-  // Use a comparator function to figure out at what index an object should
-  // be inserted so as to maintain order. Uses binary search.
-  _.sortedIndex = function(array, obj, iterator) {
-    iterator || (iterator = _.identity);
+  // Groups the object's values by a criterion. Pass either a string attribute
+  // to group by, or a function that returns the criterion.
+  _.groupBy = function(obj, value, context) {
+    return group(obj, value, context, function(result, key, value) {
+      (_.has(result, key) ? result[key] : (result[key] = [])).push(value);
+    });
+  };
+
+  // Counts instances of an object that group by a certain criterion. Pass
+  // either a string attribute to count by, or a function that returns the
+  // criterion.
+  _.countBy = function(obj, value, context) {
+    return group(obj, value, context, function(result, key) {
+      if (!_.has(result, key)) result[key] = 0;
+      result[key]++;
+    });
+  };
+
+  // Use a comparator function to figure out the smallest index at which
+  // an object should be inserted so as to maintain order. Uses binary search.
+  _.sortedIndex = function(array, obj, iterator, context) {
+    iterator = iterator == null ? _.identity : lookupIterator(iterator);
+    var value = iterator.call(context, obj);
     var low = 0, high = array.length;
     while (low < high) {
-      var mid = (low + high) >> 1;
-      iterator(array[mid]) < iterator(obj) ? low = mid + 1 : high = mid;
+      var mid = (low + high) >>> 1;
+      iterator.call(context, array[mid]) < value ? low = mid + 1 : high = mid;
     }
     return low;
   };
 
   // Safely convert anything iterable into a real, live array.
   _.toArray = function(obj) {
-    if (!obj)                                     return [];
-    if (_.isArray(obj))                           return slice.call(obj);
-    if (_.isArguments(obj))                       return slice.call(obj);
-    if (obj.toArray && _.isFunction(obj.toArray)) return obj.toArray();
+    if (!obj) return [];
+    if (_.isArray(obj)) return slice.call(obj);
+    if (obj.length === +obj.length) return _.map(obj, _.identity);
     return _.values(obj);
   };
 
   // Return the number of elements in an object.
   _.size = function(obj) {
-    return _.isArray(obj) ? obj.length : _.keys(obj).length;
+    if (obj == null) return 0;
+    return (obj.length === +obj.length) ? obj.length : _.keys(obj).length;
   };
 
   // Array Functions
@@ -337,10 +401,11 @@
   // values in the array. Aliased as `head` and `take`. The **guard** check
   // allows it to work with `_.map`.
   _.first = _.head = _.take = function(array, n, guard) {
+    if (array == null) return void 0;
     return (n != null) && !guard ? slice.call(array, 0, n) : array[0];
   };
 
-  // Returns everything but the last entry of the array. Especcialy useful on
+  // Returns everything but the last entry of the array. Especially useful on
   // the arguments object. Passing **n** will return all the values in
   // the array, excluding the last N. The **guard** check allows it to work with
   // `_.map`.
@@ -351,6 +416,7 @@
   // Get the last element of an array. Passing **n** will return the last N
   // values in the array. The **guard** check allows it to work with `_.map`.
   _.last = function(array, n, guard) {
+    if (array == null) return void 0;
     if ((n != null) && !guard) {
       return slice.call(array, Math.max(array.length - n, 0));
     } else {
@@ -358,26 +424,34 @@
     }
   };
 
-  // Returns everything but the first entry of the array. Aliased as `tail`.
-  // Especially useful on the arguments object. Passing an **index** will return
-  // the rest of the values in the array from that index onward. The **guard**
+  // Returns everything but the first entry of the array. Aliased as `tail` and `drop`.
+  // Especially useful on the arguments object. Passing an **n** will return
+  // the rest N values in the array. The **guard**
   // check allows it to work with `_.map`.
-  _.rest = _.tail = function(array, index, guard) {
-    return slice.call(array, (index == null) || guard ? 1 : index);
+  _.rest = _.tail = _.drop = function(array, n, guard) {
+    return slice.call(array, (n == null) || guard ? 1 : n);
   };
 
   // Trim out all falsy values from an array.
   _.compact = function(array) {
-    return _.filter(array, function(value){ return !!value; });
+    return _.filter(array, _.identity);
+  };
+
+  // Internal implementation of a recursive `flatten` function.
+  var flatten = function(input, shallow, output) {
+    each(input, function(value) {
+      if (_.isArray(value)) {
+        shallow ? push.apply(output, value) : flatten(value, shallow, output);
+      } else {
+        output.push(value);
+      }
+    });
+    return output;
   };
 
   // Return a completely flattened version of an array.
   _.flatten = function(array, shallow) {
-    return _.reduce(array, function(memo, value) {
-      if (_.isArray(value)) return memo.concat(shallow ? value : _.flatten(value));
-      memo[memo.length] = value;
-      return memo;
-    }, []);
+    return flatten(array, shallow, []);
   };
 
   // Return a version of the array that does not contain the specified value(s).
@@ -388,30 +462,33 @@
   // Produce a duplicate-free version of the array. If the array has already
   // been sorted, you have the option of using a faster algorithm.
   // Aliased as `unique`.
-  _.uniq = _.unique = function(array, isSorted, iterator) {
-    var initial = iterator ? _.map(array, iterator) : array;
+  _.uniq = _.unique = function(array, isSorted, iterator, context) {
+    if (_.isFunction(isSorted)) {
+      context = iterator;
+      iterator = isSorted;
+      isSorted = false;
+    }
+    var initial = iterator ? _.map(array, iterator, context) : array;
     var results = [];
-    // The `isSorted` flag is irrelevant if the array only contains two elements.
-    if (array.length < 3) isSorted = true;
-    _.reduce(initial, function (memo, value, index) {
-      if (isSorted ? _.last(memo) !== value || !memo.length : !_.include(memo, value)) {
-        memo.push(value);
+    var seen = [];
+    each(initial, function(value, index) {
+      if (isSorted ? (!index || seen[seen.length - 1] !== value) : !_.contains(seen, value)) {
+        seen.push(value);
         results.push(array[index]);
       }
-      return memo;
-    }, []);
+    });
     return results;
   };
 
   // Produce an array that contains the union: each distinct element from all of
   // the passed-in arrays.
   _.union = function() {
-    return _.uniq(_.flatten(arguments, true));
+    return _.uniq(concat.apply(ArrayProto, arguments));
   };
 
   // Produce an array that contains every item shared between all the
-  // passed-in arrays. (Aliased as "intersect" for back-compat.)
-  _.intersection = _.intersect = function(array) {
+  // passed-in arrays.
+  _.intersection = function(array) {
     var rest = slice.call(arguments, 1);
     return _.filter(_.uniq(array), function(item) {
       return _.every(rest, function(other) {
@@ -423,8 +500,8 @@
   // Take the difference between one array and a number of other arrays.
   // Only the elements present in just the first array will remain.
   _.difference = function(array) {
-    var rest = _.flatten(slice.call(arguments, 1), true);
-    return _.filter(array, function(value){ return !_.include(rest, value); });
+    var rest = concat.apply(ArrayProto, slice.call(arguments, 1));
+    return _.filter(array, function(value){ return !_.contains(rest, value); });
   };
 
   // Zip together multiple lists into a single array -- elements that share
@@ -433,10 +510,28 @@
     var args = slice.call(arguments);
     var length = _.max(_.pluck(args, 'length'));
     var results = new Array(length);
-    for (var i = 0; i < length; i++) results[i] = _.pluck(args, "" + i);
+    for (var i = 0; i < length; i++) {
+      results[i] = _.pluck(args, "" + i);
+    }
     return results;
   };
 
+  // Converts lists into objects. Pass either a single array of `[key, value]`
+  // pairs, or two parallel arrays of the same length -- one of keys, and one of
+  // the corresponding values.
+  _.object = function(list, values) {
+    if (list == null) return {};
+    var result = {};
+    for (var i = 0, l = list.length; i < l; i++) {
+      if (values) {
+        result[list[i]] = values[i];
+      } else {
+        result[list[i][0]] = list[i][1];
+      }
+    }
+    return result;
+  };
+
   // If the browser doesn't supply us with indexOf (I'm looking at you, **MSIE**),
   // we need this function. Return the position of the first occurrence of an
   // item in an array, or -1 if the item is not included in the array.
@@ -445,22 +540,29 @@
   // for **isSorted** to use binary search.
   _.indexOf = function(array, item, isSorted) {
     if (array == null) return -1;
-    var i, l;
+    var i = 0, l = array.length;
     if (isSorted) {
-      i = _.sortedIndex(array, item);
-      return array[i] === item ? i : -1;
+      if (typeof isSorted == 'number') {
+        i = (isSorted < 0 ? Math.max(0, l + isSorted) : isSorted);
+      } else {
+        i = _.sortedIndex(array, item);
+        return array[i] === item ? i : -1;
+      }
     }
-    if (nativeIndexOf && array.indexOf === nativeIndexOf) return array.indexOf(item);
-    for (i = 0, l = array.length; i < l; i++) if (i in array && array[i] === item) return i;
+    if (nativeIndexOf && array.indexOf === nativeIndexOf) return array.indexOf(item, isSorted);
+    for (; i < l; i++) if (array[i] === item) return i;
     return -1;
   };
 
   // Delegates to **ECMAScript 5**'s native `lastIndexOf` if available.
-  _.lastIndexOf = function(array, item) {
+  _.lastIndexOf = function(array, item, from) {
     if (array == null) return -1;
-    if (nativeLastIndexOf && array.lastIndexOf === nativeLastIndexOf) return array.lastIndexOf(item);
-    var i = array.length;
-    while (i--) if (i in array && array[i] === item) return i;
+    var hasIndex = from != null;
+    if (nativeLastIndexOf && array.lastIndexOf === nativeLastIndexOf) {
+      return hasIndex ? array.lastIndexOf(item, from) : array.lastIndexOf(item);
+    }
+    var i = (hasIndex ? from : array.length);
+    while (i--) if (array[i] === item) return i;
     return -1;
   };
 
@@ -489,25 +591,23 @@
   // Function (ahem) Functions
   // ------------------
 
-  // Reusable constructor function for prototype setting.
-  var ctor = function(){};
-
   // Create a function bound to a given object (assigning `this`, and arguments,
-  // optionally). Binding with arguments is also known as `curry`.
-  // Delegates to **ECMAScript 5**'s native `Function.bind` if available.
-  // We check for `func.bind` first, to fail fast when `func` is undefined.
-  _.bind = function bind(func, context) {
-    var bound, args;
+  // optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if
+  // available.
+  _.bind = function(func, context) {
     if (func.bind === nativeBind && nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));
-    if (!_.isFunction(func)) throw new TypeError;
-    args = slice.call(arguments, 2);
-    return bound = function() {
-      if (!(this instanceof bound)) return func.apply(context, args.concat(slice.call(arguments)));
-      ctor.prototype = func.prototype;
-      var self = new ctor;
-      var result = func.apply(self, args.concat(slice.call(arguments)));
-      if (Object(result) === result) return result;
-      return self;
+    var args = slice.call(arguments, 2);
+    return function() {
+      return func.apply(context, args.concat(slice.call(arguments)));
+    };
+  };
+
+  // Partially apply a function by creating a version that has had some of its
+  // arguments pre-filled, without changing its dynamic `this` context.
+  _.partial = function(func) {
+    var args = slice.call(arguments, 1);
+    return function() {
+      return func.apply(this, args.concat(slice.call(arguments)));
     };
   };
 
@@ -515,7 +615,7 @@
   // all callbacks defined on an object belong to it.
   _.bindAll = function(obj) {
     var funcs = slice.call(arguments, 1);
-    if (funcs.length == 0) funcs = _.functions(obj);
+    if (funcs.length === 0) funcs = _.functions(obj);
     each(funcs, function(f) { obj[f] = _.bind(obj[f], obj); });
     return obj;
   };
@@ -546,23 +646,26 @@
   // Returns a function, that, when invoked, will only be triggered at most once
   // during a given window of time.
   _.throttle = function(func, wait) {
-    var context, args, timeout, throttling, more, result;
-    var whenDone = _.debounce(function(){ more = throttling = false; }, wait);
+    var context, args, timeout, result;
+    var previous = 0;
+    var later = function() {
+      previous = new Date;
+      timeout = null;
+      result = func.apply(context, args);
+    };
     return function() {
-      context = this; args = arguments;
-      var later = function() {
+      var now = new Date;
+      var remaining = wait - (now - previous);
+      context = this;
+      args = arguments;
+      if (remaining <= 0) {
+        clearTimeout(timeout);
         timeout = null;
-        if (more) func.apply(context, args);
-        whenDone();
-      };
-      if (!timeout) timeout = setTimeout(later, wait);
-      if (throttling) {
-        more = true;
-      } else {
+        previous = now;
         result = func.apply(context, args);
+      } else if (!timeout) {
+        timeout = setTimeout(later, remaining);
       }
-      whenDone();
-      throttling = true;
       return result;
     };
   };
@@ -572,16 +675,18 @@
   // N milliseconds. If `immediate` is passed, trigger the function on the
   // leading edge, instead of the trailing.
   _.debounce = function(func, wait, immediate) {
-    var timeout;
+    var timeout, result;
     return function() {
       var context = this, args = arguments;
       var later = function() {
         timeout = null;
-        if (!immediate) func.apply(context, args);
+        if (!immediate) result = func.apply(context, args);
       };
-      if (immediate && !timeout) func.apply(context, args);
+      var callNow = immediate && !timeout;
       clearTimeout(timeout);
       timeout = setTimeout(later, wait);
+      if (callNow) result = func.apply(context, args);
+      return result;
     };
   };
 
@@ -592,7 +697,9 @@
     return function() {
       if (ran) return memo;
       ran = true;
-      return memo = func.apply(this, arguments);
+      memo = func.apply(this, arguments);
+      func = null;
+      return memo;
     };
   };
 
@@ -601,7 +708,8 @@
   // conditionally execute the original function.
   _.wrap = function(func, wrapper) {
     return function() {
-      var args = [func].concat(slice.call(arguments, 0));
+      var args = [func];
+      push.apply(args, arguments);
       return wrapper.apply(this, args);
     };
   };
@@ -623,7 +731,9 @@
   _.after = function(times, func) {
     if (times <= 0) return func();
     return function() {
-      if (--times < 1) { return func.apply(this, arguments); }
+      if (--times < 1) {
+        return func.apply(this, arguments);
+      }
     };
   };
 
@@ -641,7 +751,23 @@
 
   // Retrieve the values of an object's properties.
   _.values = function(obj) {
-    return _.map(obj, _.identity);
+    var values = [];
+    for (var key in obj) if (_.has(obj, key)) values.push(obj[key]);
+    return values;
+  };
+
+  // Convert an object into a list of `[key, value]` pairs.
+  _.pairs = function(obj) {
+    var pairs = [];
+    for (var key in obj) if (_.has(obj, key)) pairs.push([key, obj[key]]);
+    return pairs;
+  };
+
+  // Invert the keys and values of an object. The values must be serializable.
+  _.invert = function(obj) {
+    var result = {};
+    for (var key in obj) if (_.has(obj, key)) result[obj[key]] = key;
+    return result;
   };
 
   // Return a sorted list of the function names available on the object.
@@ -657,8 +783,10 @@
   // Extend a given object with all the properties in passed-in object(s).
   _.extend = function(obj) {
     each(slice.call(arguments, 1), function(source) {
-      for (var prop in source) {
-        obj[prop] = source[prop];
+      if (source) {
+        for (var prop in source) {
+          obj[prop] = source[prop];
+        }
       }
     });
     return obj;
@@ -666,18 +794,31 @@
 
   // Return a copy of the object only containing the whitelisted properties.
   _.pick = function(obj) {
-    var result = {};
-    each(_.flatten(slice.call(arguments, 1)), function(key) {
-      if (key in obj) result[key] = obj[key];
+    var copy = {};
+    var keys = concat.apply(ArrayProto, slice.call(arguments, 1));
+    each(keys, function(key) {
+      if (key in obj) copy[key] = obj[key];
     });
-    return result;
+    return copy;
+  };
+
+   // Return a copy of the object without the blacklisted properties.
+  _.omit = function(obj) {
+    var copy = {};
+    var keys = concat.apply(ArrayProto, slice.call(arguments, 1));
+    for (var key in obj) {
+      if (!_.contains(keys, key)) copy[key] = obj[key];
+    }
+    return copy;
   };
 
   // Fill in a given object with default properties.
   _.defaults = function(obj) {
     each(slice.call(arguments, 1), function(source) {
-      for (var prop in source) {
-        if (obj[prop] == null) obj[prop] = source[prop];
+      if (source) {
+        for (var prop in source) {
+          if (obj[prop] == null) obj[prop] = source[prop];
+        }
       }
     });
     return obj;
@@ -697,19 +838,16 @@
     return obj;
   };
 
-  // Internal recursive comparison function.
-  function eq(a, b, stack) {
+  // Internal recursive comparison function for `isEqual`.
+  var eq = function(a, b, aStack, bStack) {
     // Identical objects are equal. `0 === -0`, but they aren't identical.
     // See the Harmony `egal` proposal: http://wiki.ecmascript.org/doku.php?id=harmony:egal.
     if (a === b) return a !== 0 || 1 / a == 1 / b;
     // A strict comparison is necessary because `null == undefined`.
     if (a == null || b == null) return a === b;
     // Unwrap any wrapped objects.
-    if (a._chain) a = a._wrapped;
-    if (b._chain) b = b._wrapped;
-    // Invoke a custom `isEqual` method if one is provided.
-    if (a.isEqual && _.isFunction(a.isEqual)) return a.isEqual(b);
-    if (b.isEqual && _.isFunction(b.isEqual)) return b.isEqual(a);
+    if (a instanceof _) a = a._wrapped;
+    if (b instanceof _) b = b._wrapped;
     // Compare `[[Class]]` names.
     var className = toString.call(a);
     if (className != toString.call(b)) return false;
@@ -739,14 +877,15 @@
     if (typeof a != 'object' || typeof b != 'object') return false;
     // Assume equality for cyclic structures. The algorithm for detecting cyclic
     // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.
-    var length = stack.length;
+    var length = aStack.length;
     while (length--) {
       // Linear search. Performance is inversely proportional to the number of
       // unique nested structures.
-      if (stack[length] == a) return true;
+      if (aStack[length] == a) return bStack[length] == b;
     }
     // Add the first object to the stack of traversed objects.
-    stack.push(a);
+    aStack.push(a);
+    bStack.push(b);
     var size = 0, result = true;
     // Recursively compare objects and arrays.
     if (className == '[object Array]') {
@@ -756,20 +895,24 @@
       if (result) {
         // Deep compare the contents, ignoring non-numeric properties.
         while (size--) {
-          // Ensure commutative equality for sparse arrays.
-          if (!(result = size in a == size in b && eq(a[size], b[size], stack))) break;
+          if (!(result = eq(a[size], b[size], aStack, bStack))) break;
         }
       }
     } else {
-      // Objects with different constructors are not equivalent.
-      if ('constructor' in a != 'constructor' in b || a.constructor != b.constructor) return false;
+      // Objects with different constructors are not equivalent, but `Object`s
+      // from different frames are.
+      var aCtor = a.constructor, bCtor = b.constructor;
+      if (aCtor !== bCtor && !(_.isFunction(aCtor) && (aCtor instanceof aCtor) &&
+                               _.isFunction(bCtor) && (bCtor instanceof bCtor))) {
+        return false;
+      }
       // Deep compare objects.
       for (var key in a) {
         if (_.has(a, key)) {
           // Count the expected number of properties.
           size++;
           // Deep compare each member.
-          if (!(result = _.has(b, key) && eq(a[key], b[key], stack))) break;
+          if (!(result = _.has(b, key) && eq(a[key], b[key], aStack, bStack))) break;
         }
       }
       // Ensure that both objects contain the same number of properties.
@@ -781,13 +924,14 @@
       }
     }
     // Remove the first object from the stack of traversed objects.
-    stack.pop();
+    aStack.pop();
+    bStack.pop();
     return result;
-  }
+  };
 
   // Perform a deep comparison to check if two objects are equal.
   _.isEqual = function(a, b) {
-    return eq(a, b, []);
+    return eq(a, b, [], []);
   };
 
   // Is a given array, string, or object empty?
@@ -801,7 +945,7 @@
 
   // Is a given value a DOM element?
   _.isElement = function(obj) {
-    return !!(obj && obj.nodeType == 1);
+    return !!(obj && obj.nodeType === 1);
   };
 
   // Is a given value an array?
@@ -815,40 +959,36 @@
     return obj === Object(obj);
   };
 
-  // Is a given variable an arguments object?
-  _.isArguments = function(obj) {
-    return toString.call(obj) == '[object Arguments]';
-  };
+  // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp.
+  each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp'], function(name) {
+    _['is' + name] = function(obj) {
+      return toString.call(obj) == '[object ' + name + ']';
+    };
+  });
+
+  // Define a fallback version of the method in browsers (ahem, IE), where
+  // there isn't any inspectable "Arguments" type.
   if (!_.isArguments(arguments)) {
     _.isArguments = function(obj) {
       return !!(obj && _.has(obj, 'callee'));
     };
   }
 
-  // Is a given value a function?
-  _.isFunction = function(obj) {
-    return toString.call(obj) == '[object Function]';
-  };
-
-  // Is a given value a string?
-  _.isString = function(obj) {
-    return toString.call(obj) == '[object String]';
-  };
-
-  // Is a given value a number?
-  _.isNumber = function(obj) {
-    return toString.call(obj) == '[object Number]';
-  };
+  // Optimize `isFunction` if appropriate.
+  if (typeof (/./) !== 'function') {
+    _.isFunction = function(obj) {
+      return typeof obj === 'function';
+    };
+  }
 
   // Is a given object a finite number?
   _.isFinite = function(obj) {
-    return _.isNumber(obj) && isFinite(obj);
+    return isFinite(obj) && !isNaN(parseFloat(obj));
   };
 
-  // Is the given value `NaN`?
+  // Is the given value `NaN`? (NaN is the only number which does not equal itself).
   _.isNaN = function(obj) {
-    // `NaN` is the only value for which `===` is not reflexive.
-    return obj !== obj;
+    return _.isNumber(obj) && obj != +obj;
   };
 
   // Is a given value a boolean?
@@ -856,16 +996,6 @@
     return obj === true || obj === false || toString.call(obj) == '[object Boolean]';
   };
 
-  // Is a given value a date?
-  _.isDate = function(obj) {
-    return toString.call(obj) == '[object Date]';
-  };
-
-  // Is the given value a regular expression?
-  _.isRegExp = function(obj) {
-    return toString.call(obj) == '[object RegExp]';
-  };
-
   // Is a given value equal to null?
   _.isNull = function(obj) {
     return obj === null;
@@ -876,7 +1006,8 @@
     return obj === void 0;
   };
 
-  // Has own property?
+  // Shortcut function for checking if an object has a given property directly
+  // on itself (in other words, not on a prototype).
   _.has = function(obj, key) {
     return hasOwnProperty.call(obj, key);
   };
@@ -897,15 +1028,50 @@
   };
 
   // Run a function **n** times.
-  _.times = function (n, iterator, context) {
-    for (var i = 0; i < n; i++) iterator.call(context, i);
+  _.times = function(n, iterator, context) {
+    var accum = Array(n);
+    for (var i = 0; i < n; i++) accum[i] = iterator.call(context, i);
+    return accum;
   };
 
-  // Escape a string for HTML interpolation.
-  _.escape = function(string) {
-    return (''+string).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&#x27;').replace(/\//g,'&#x2F;');
+  // Return a random integer between min and max (inclusive).
+  _.random = function(min, max) {
+    if (max == null) {
+      max = min;
+      min = 0;
+    }
+    return min + Math.floor(Math.random() * (max - min + 1));
+  };
+
+  // List of HTML entities for escaping.
+  var entityMap = {
+    escape: {
+      '&': '&amp;',
+      '<': '&lt;',
+      '>': '&gt;',
+      '"': '&quot;',
+      "'": '&#x27;',
+      '/': '&#x2F;'
+    }
+  };
+  entityMap.unescape = _.invert(entityMap.escape);
+
+  // Regexes containing the keys and values listed immediately above.
+  var entityRegexes = {
+    escape:   new RegExp('[' + _.keys(entityMap.escape).join('') + ']', 'g'),
+    unescape: new RegExp('(' + _.keys(entityMap.unescape).join('|') + ')', 'g')
   };
 
+  // Functions for escaping and unescaping strings to/from HTML interpolation.
+  _.each(['escape', 'unescape'], function(method) {
+    _[method] = function(string) {
+      if (string == null) return '';
+      return ('' + string).replace(entityRegexes[method], function(match) {
+        return entityMap[method][match];
+      });
+    };
+  });
+
   // If the value of the named property is a function then invoke it;
   // otherwise, return it.
   _.result = function(object, property) {
@@ -914,11 +1080,15 @@
     return _.isFunction(value) ? value.call(object) : value;
   };
 
-  // Add your own custom functions to the Underscore object, ensuring that
-  // they're correctly added to the OOP wrapper as well.
+  // Add your own custom functions to the Underscore object.
   _.mixin = function(obj) {
     each(_.functions(obj), function(name){
-      addToWrapper(name, _[name] = obj[name]);
+      var func = _[name] = obj[name];
+      _.prototype[name] = function() {
+        var args = [this._wrapped];
+        push.apply(args, arguments);
+        return result.call(this, func.apply(_, args));
+      };
     });
   };
 
@@ -926,7 +1096,7 @@
   // Useful for temporary DOM ids.
   var idCounter = 0;
   _.uniqueId = function(prefix) {
-    var id = idCounter++;
+    var id = ++idCounter + '';
     return prefix ? prefix + id : id;
   };
 
@@ -941,72 +1111,78 @@
   // When customizing `templateSettings`, if you don't want to define an
   // interpolation, evaluation or escaping regex, we need one that is
   // guaranteed not to match.
-  var noMatch = /.^/;
+  var noMatch = /(.)^/;
 
   // Certain characters need to be escaped so that they can be put into a
   // string literal.
   var escapes = {
-    '\\': '\\',
-    "'": "'",
-    'r': '\r',
-    'n': '\n',
-    't': '\t',
-    'u2028': '\u2028',
-    'u2029': '\u2029'
+    "'":      "'",
+    '\\':     '\\',
+    '\r':     'r',
+    '\n':     'n',
+    '\t':     't',
+    '\u2028': 'u2028',
+    '\u2029': 'u2029'
   };
 
-  for (var p in escapes) escapes[escapes[p]] = p;
   var escaper = /\\|'|\r|\n|\t|\u2028|\u2029/g;
-  var unescaper = /\\(\\|'|r|n|t|u2028|u2029)/g;
-
-  // Within an interpolation, evaluation, or escaping, remove HTML escaping
-  // that had been previously added.
-  var unescape = function(code) {
-    return code.replace(unescaper, function(match, escape) {
-      return escapes[escape];
-    });
-  };
 
   // JavaScript micro-templating, similar to John Resig's implementation.
   // Underscore templating handles arbitrary delimiters, preserves whitespace,
   // and correctly escapes quotes within interpolated code.
   _.template = function(text, data, settings) {
-    settings = _.defaults(settings || {}, _.templateSettings);
-
-    // Compile the template source, taking care to escape characters that
-    // cannot be included in a string literal and then unescape them in code
-    // blocks.
-    var source = "__p+='" + text
-      .replace(escaper, function(match) {
-        return '\\' + escapes[match];
-      })
-      .replace(settings.escape || noMatch, function(match, code) {
-        return "'+\n_.escape(" + unescape(code) + ")+\n'";
-      })
-      .replace(settings.interpolate || noMatch, function(match, code) {
-        return "'+\n(" + unescape(code) + ")+\n'";
-      })
-      .replace(settings.evaluate || noMatch, function(match, code) {
-        return "';\n" + unescape(code) + "\n;__p+='";
-      }) + "';\n";
+    var render;
+    settings = _.defaults({}, settings, _.templateSettings);
+
+    // Combine delimiters into one regular expression via alternation.
+    var matcher = new RegExp([
+      (settings.escape || noMatch).source,
+      (settings.interpolate || noMatch).source,
+      (settings.evaluate || noMatch).source
+    ].join('|') + '|$', 'g');
+
+    // Compile the template source, escaping string literals appropriately.
+    var index = 0;
+    var source = "__p+='";
+    text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {
+      source += text.slice(index, offset)
+        .replace(escaper, function(match) { return '\\' + escapes[match]; });
+
+      if (escape) {
+        source += "'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'";
+      }
+      if (interpolate) {
+        source += "'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'";
+      }
+      if (evaluate) {
+        source += "';\n" + evaluate + "\n__p+='";
+      }
+      index = offset + match.length;
+      return match;
+    });
+    source += "';\n";
 
     // If a variable is not specified, place data values in local scope.
     if (!settings.variable) source = 'with(obj||{}){\n' + source + '}\n';
 
-    source = "var __p='';" +
-      "var print=function(){__p+=Array.prototype.join.call(arguments, '')};\n" +
+    source = "var __t,__p='',__j=Array.prototype.join," +
+      "print=function(){__p+=__j.call(arguments,'');};\n" +
       source + "return __p;\n";
 
-    var render = new Function(settings.variable || 'obj', '_', source);
+    try {
+      render = new Function(settings.variable || 'obj', '_', source);
+    } catch (e) {
+      e.source = source;
+      throw e;
+    }
+
     if (data) return render(data, _);
     var template = function(data) {
       return render.call(this, data, _);
     };
 
-    // Provide the compiled function source as a convenience for build time
-    // precompilation.
-    template.source = 'function(' + (settings.variable || 'obj') + '){\n' +
-      source + '}';
+    // Provide the compiled function source as a convenience for precompilation.
+    template.source = 'function(' + (settings.variable || 'obj') + '){\n' + source + '}';
 
     return template;
   };
@@ -1016,29 +1192,15 @@
     return _(obj).chain();
   };
 
-  // The OOP Wrapper
+  // OOP
   // ---------------
-
   // If Underscore is called as a function, it returns a wrapped object that
   // can be used OO-style. This wrapper holds altered versions of all the
   // underscore functions. Wrapped objects may be chained.
-  var wrapper = function(obj) { this._wrapped = obj; };
-
-  // Expose `wrapper.prototype` as `_.prototype`
-  _.prototype = wrapper.prototype;
 
   // Helper function to continue chaining intermediate results.
-  var result = function(obj, chain) {
-    return chain ? _(obj).chain() : obj;
-  };
-
-  // A method to easily add functions to the OOP wrapper.
-  var addToWrapper = function(name, func) {
-    wrapper.prototype[name] = function() {
-      var args = slice.call(arguments);
-      unshift.call(args, this._wrapped);
-      return result(func.apply(_, args), this._chain);
-    };
+  var result = function(obj) {
+    return this._chain ? _(obj).chain() : obj;
   };
 
   // Add all of the Underscore functions to the wrapper object.
@@ -1047,38 +1209,42 @@
   // Add all mutator Array functions to the wrapper.
   each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {
     var method = ArrayProto[name];
-    wrapper.prototype[name] = function() {
-      var wrapped = this._wrapped;
-      method.apply(wrapped, arguments);
-      var length = wrapped.length;
-      if ((name == 'shift' || name == 'splice') && length === 0) delete wrapped[0];
-      return result(wrapped, this._chain);
+    _.prototype[name] = function() {
+      var obj = this._wrapped;
+      method.apply(obj, arguments);
+      if ((name == 'shift' || name == 'splice') && obj.length === 0) delete obj[0];
+      return result.call(this, obj);
     };
   });
 
   // Add all accessor Array functions to the wrapper.
   each(['concat', 'join', 'slice'], function(name) {
     var method = ArrayProto[name];
-    wrapper.prototype[name] = function() {
-      return result(method.apply(this._wrapped, arguments), this._chain);
+    _.prototype[name] = function() {
+      return result.call(this, method.apply(this._wrapped, arguments));
     };
   });
 
-  // Start chaining a wrapped Underscore object.
-  wrapper.prototype.chain = function() {
-    this._chain = true;
-    return this;
-  };
+  _.extend(_.prototype, {
 
-  // Extracts the result from a wrapped and chained object.
-  wrapper.prototype.value = function() {
-    return this._wrapped;
-  };
+    // Start chaining a wrapped Underscore object.
+    chain: function() {
+      this._chain = true;
+      return this;
+    },
+
+    // Extracts the result from a wrapped and chained object.
+    value: function() {
+      return this._wrapped;
+    }
+
+  });
 
 }).call(this);
 
-/*global _: false, $: false, localStorage: false, XMLHttpRequest: false,
- XDomainRequest: false, exports: false, require: false */
+/*global _: false, $: false, localStorage: false, process: true,
+  XMLHttpRequest: false, XDomainRequest: false, exports: false,
+  require: false */
 (function(root) {
   root.Parse = root.Parse || {};
   /**
@@ -1167,13 +1333,25 @@
   // Set the server for Parse to talk to.
   Parse.serverURL = "https://api.parse.com";
 
+  // Check whether we are running in Node.js.
+  if (typeof(process) !== "undefined" &&
+      process.versions &&
+      process.versions.node) {
+    Parse._isNode = true;
+  }
+
   /**
    * Call this method first to set up your authentication tokens for Parse.
    * You can get your keys from the Data Browser on parse.com.
    * @param {String} applicationId Your Parse Application ID.
    * @param {String} javaScriptKey Your Parse JavaScript Key.
+   * @param {String} masterKey (optional) Your Parse Master Key. (Node.js only!)
    */
-  Parse.initialize = function(applicationId, javaScriptKey) {
+  Parse.initialize = function(applicationId, javaScriptKey, masterKey) {
+    if (masterKey) {
+      throw "Parse.initialize() was passed a Master Key, which is only " +
+        "allowed from within Node.js.";
+    }
     Parse._initialize(applicationId, javaScriptKey);
   };
 
@@ -1191,6 +1369,23 @@
     Parse._useMasterKey = false;
   };
 
+  // If we're running in node.js, allow using the master key.
+  if (Parse._isNode) {
+    Parse.initialize = Parse._initialize;
+
+    Parse.Cloud = Parse.Cloud || {};
+    /**
+     * Switches the Parse SDK to using the Master key.  The Master key grants
+     * priveleged access to the data in Parse and can be used to bypass ACLs and
+     * other restrictions that are applied to the client SDKs.
+     * <p><strong><em>Available in Cloud Code and Node.js only.</em></strong>
+     * </p>
+     */
+    Parse.Cloud.useMasterKey = function() {
+      Parse._useMasterKey = true;
+    };
+  }
+
   /**
    * Returns prefix for localStorage keys used by this instance of Parse.
    * @param {String} path The relative suffix to append to it.
@@ -1266,7 +1461,7 @@
     return new Date(Date.UTC(year, month, day, hour, minute, second, milli));
   };
 
-  Parse._ajaxIE8 = function(method, url, data, success, error) {
+  Parse._ajaxIE8 = function(method, url, data) {
     var promise = new Parse.Promise();
     var xdr = new XDomainRequest();
     xdr.onload = function() {
@@ -1274,22 +1469,13 @@
       try {
         response = JSON.parse(xdr.responseText);
       } catch (e) {
-        if (error) {
-          error(xdr);
-        }
         promise.reject(e);
       }
       if (response) {
-        if (success) {
-          success(response, xdr);
-        }
         promise.resolve(response);
       }
     };
     xdr.onerror = xdr.ontimeout = function() {
-      if (error) {
-        error(xdr);
-      }
       promise.reject(xdr);
     };
     xdr.onprogress = function() {};
@@ -1298,9 +1484,15 @@
     return promise;
   };
 
+  
   Parse._ajax = function(method, url, data, success, error) {
+    var options = {
+      success: success,
+      error: error
+    };
+
     if (typeof(XDomainRequest) !== "undefined") {
-      return Parse._ajaxIE8(method, url, data, success, error);
+      return Parse._ajaxIE8(method, url, data)._thenRunCallbacks(options);
     }
 
     var promise = new Parse.Promise();
@@ -1319,29 +1511,26 @@
           try {
             response = JSON.parse(xhr.responseText);
           } catch (e) {
-            if (error) {
-              error(xhr);
-            }
             promise.reject(e);
           }
           if (response) {
-            if (success) {
-              success(response, xhr.status, xhr);
-            }
             promise.resolve(response, xhr.status, xhr);
           }
         } else {
-          if (error) {
-            error(xhr);
-          }
           promise.reject(xhr);
         }
       }
     };
     xhr.open(method, url, true);
     xhr.setRequestHeader("Content-Type", "text/plain");  // avoid pre-flight.
+    if (Parse._isNode) {
+      // Add a special user agent just for request from node.js.
+      xhr.setRequestHeader("User-Agent",
+                           "Parse/" + Parse.VERSION +
+                           " (NodeJS " + process.versions.node + ")");
+    }
     xhr.send(data);
-    return promise;
+    return promise._thenRunCallbacks(options);
   };
 
   // A self-propagating extend function.
@@ -1356,11 +1545,9 @@
    * objectId is null if there is no associated objectId.
    * method is the http method for the REST API.
    * dataObject is the payload as an object, or null if there is none.
-   * options is just a success/error callback hash.
    * @ignore
    */
-  Parse._request = function(route, className, objectId, method, dataObject,
-                            options) {
+  Parse._request = function(route, className, objectId, method, dataObject) {
     if (!Parse.applicationId) {
       throw "You must specify your applicationId using Parse.initialize";
     }
@@ -1372,6 +1559,7 @@
     
     if (route !== "batch" &&
         route !== "classes" &&
+        route !== "files" &&
         route !== "functions" &&
         route !== "login" &&
         route !== "push" &&
@@ -1397,6 +1585,7 @@
       dataObject._method = method;
       method = "POST";
     }
+
     dataObject._ApplicationId = Parse.applicationId;
     if (!Parse._useMasterKey) {
       dataObject._JavaScriptKey = Parse.javaScriptKey;
@@ -1413,8 +1602,25 @@
     }
     var data = JSON.stringify(dataObject);
 
-    options = options || {};
-    return Parse._ajax(method, url, data, options.success, options.error);
+    return Parse._ajax(method, url, data).then(null, function(response) {
+      // Transform the error into an instance of Parse.Error by trying to parse
+      // the error string as JSON.
+      var error;
+      if (response && response.responseText) {
+        try {
+          var errorJSON = JSON.parse(response.responseText);
+          if (errorJSON) {
+            error = new Parse.Error(errorJSON.code, errorJSON.error);
+          }
+        } catch (e) {
+          // If we fail to parse the error text, that's okay.
+        }
+      }
+      error = error || new Parse.Error(-1, response.responseText);
+      // By explicitly returning a rejected Promise, this will work with
+      // either jQuery or Promises/A semantics.
+      return Parse.Promise.error(error);
+    });
   };
 
   // Helper function to get a value from a Backbone object as a property
@@ -1443,39 +1649,56 @@
       }
       if (!seenObjects || _.include(seenObjects, value) || !value._hasData) {
         return value._toPointer();
-      } else if (!value.dirty()) {
+      }
+      if (!value.dirty()) {
         seenObjects = seenObjects.concat(value);
         return Parse._encode(value._toFullJSON(seenObjects),
                              seenObjects,
                              disallowObjects);
-      } else {
-        throw "Can't fully embed a dirty object";
       }
-    } else if (value instanceof Parse.ACL) {
+      throw "Tried to save an object with a pointer to a new, unsaved object.";
+    }
+    if (value instanceof Parse.ACL) {
       return value.toJSON();
-    } else if (_.isDate(value)) {
+    }
+    if (_.isDate(value)) {
       return { "__type": "Date", "iso": value.toJSON() };
-    } else if (value instanceof Parse.GeoPoint) {
+    }
+    if (value instanceof Parse.GeoPoint) {
       return value.toJSON();
-    } else if (_.isArray(value)) {
+    }
+    if (_.isArray(value)) {
       return _.map(value, function(x) {
         return Parse._encode(x, seenObjects, disallowObjects);
       });
-    } else if (_.isRegExp(value)) {
+    }
+    if (_.isRegExp(value)) {
       return value.source;
-    } else if (value instanceof Parse.Relation) {
+    }
+    if (value instanceof Parse.Relation) {
       return value.toJSON();
-    } else if (value instanceof Parse.Op) {
+    }
+    if (value instanceof Parse.Op) {
       return value.toJSON();
-    } else if (value instanceof Object) {
+    }
+    if (value instanceof Parse.File) {
+      if (!value.url()) {
+        throw "Tried to save an object containing an unsaved file.";
+      }
+      return {
+        __type: "File",
+        name: value.name(),
+        url: value.url()
+      };
+    }
+    if (_.isObject(value)) {
       var output = {};
-      Parse._each(value, function(v, k) {
+      Parse._objectEach(value, function(v, k) {
         output[k] = Parse._encode(v, seenObjects, disallowObjects);
       });
       return output;
-    } else {
-      return value;
     }
+    return value;
   };
 
   /**
@@ -1486,23 +1709,31 @@
     var _ = Parse._;
     if (!_.isObject(value)) {
       return value;
-    } else if (_.isArray(value)) {
-      Parse._each(value, function(v, k) {
+    }
+    if (_.isArray(value)) {
+      Parse._arrayEach(value, function(v, k) {
         value[k] = Parse._decode(k, v);
       });
       return value;
-    } else if (value instanceof Parse.Object) {
+    }
+    if (value instanceof Parse.Object) {
+      return value;
+    }
+    if (value instanceof Parse.File) {
       return value;
-    } else if (value instanceof Parse.Op) {
+    }
+    if (value instanceof Parse.Op) {
       return value;
-    } else if (value.__op) {
-      // Must be a Op.
+    }
+    if (value.__op) {
       return Parse.Op._decode(value);
-    } else if (value.__type === "Pointer") {
+    }
+    if (value.__type === "Pointer") {
       var pointer = Parse.Object._create(value.className);
       pointer._finishFetch({ objectId: value.objectId }, false);
       return pointer;
-    } else if (value.__type === "Object") {
+    }
+    if (value.__type === "Object") {
       // It's an Object included in a query result.
       var className = value.className;
       delete value.__type;
@@ -1510,69 +1741,83 @@
       var object = Parse.Object._create(className);
       object._finishFetch(value, true);
       return object;
-    } else if (value.__type === "Date") {
+    }
+    if (value.__type === "Date") {
       return Parse._parseDate(value.iso);
-    } else if (value.__type === "GeoPoint") {
+    }
+    if (value.__type === "GeoPoint") {
       return new Parse.GeoPoint({
         latitude: value.latitude,
         longitude: value.longitude
       });
-    } else if (key === "ACL") {
+    }
+    if (key === "ACL") {
       if (value instanceof Parse.ACL) {
         return value;
-      } else {
-        return new Parse.ACL(value);
       }
-    } else if (value.__type === "Relation") {
+      return new Parse.ACL(value);
+    }
+    if (value.__type === "Relation") {
       var relation = new Parse.Relation(null, key);
       relation.targetClassName = value.className;
       return relation;
-    } else {
-      Parse._each(value, function(v, k) {
-        value[k] = Parse._decode(k, v);
-      });
-     return value;
     }
+    if (value.__type === "File") {
+      var file = new Parse.File(value.name);
+      file._url = value.url;
+      return file;
+    }
+    Parse._objectEach(value, function(v, k) {
+      value[k] = Parse._decode(k, v);
+    });
+    return value;
   };
 
+  Parse._arrayEach = Parse._.each;
+
   /**
-   * Does a deep traversal of every item in object, calling func on all
-   * instances of Parse.Object.
+   * Does a deep traversal of every item in object, calling func on every one.
    * @param {Object} object The object or array to traverse deeply.
-   * @param {Function} func The function to call for every Parse.Object. It will
-   *     be passed the Parse Object. If it returns a truthy value, that value
-   *     will replace the object in its parent container.
-   * @returns {} Undefined, unless object is a Parse.Object, in which case it
-   *     returns the result of calling func on that object.
+   * @param {Function} func The function to call for every item. It will
+   *     be passed the item as an argument. If it returns a truthy value, that
+   *     value will replace the item in its parent container.
+   * @returns {} the result of calling func on the top-level object itself.
    */
-  Parse._traverse = function(object, func) {
+  Parse._traverse = function(object, func, seen) {
     if (object instanceof Parse.Object) {
-      Parse._traverse(object.attributes, func);
+      seen = seen || [];
+      if (Parse._.indexOf(seen, object) >= 0) {
+        // We've already visited this object in this call.
+        return;
+      }
+      seen.push(object);
+      Parse._traverse(object.attributes, func, seen);
       return func(object);
     }
     if (object instanceof Parse.Relation) {
       // Nothing needs to be done, but we don't want to recurse into the
       // relation's parent infinitely, so we catch this case.
-      return;
+      return func(object);
     }
     if (Parse._.isArray(object)) {
       Parse._.each(object, function(child, index) {
-        var newChild = Parse._traverse(child, func);
+        var newChild = Parse._traverse(child, func, seen);
         if (newChild) {
           object[index] = newChild;
         }
       });
-      return;
+      return func(object);
     }
     if (Parse._.isObject(object)) {
       Parse._each(object, function(child, key) {
-        var newChild = Parse._traverse(child, func);
+        var newChild = Parse._traverse(child, func, seen);
         if (newChild) {
           object[key] = newChild;
         }
       });
-      return;
+      return func(object);
     }
+    return func(object);
   };
 
   /**
@@ -1580,7 +1825,7 @@
    * * it doesn't work for so-called array-like objects,
    * * it does work for dictionaries with a "length" attribute.
    */
-  Parse._each = function(obj, callback) {
+  Parse._objectEach = Parse._each = function(obj, callback) {
     var _ = Parse._;
     if (_.isObject(obj)) {
       _.each(_.keys(obj), function(key) {
@@ -2196,20 +2441,18 @@
    * @param {Object} options An object with success and error callbacks.
    */
   Parse.GeoPoint.current = function(options) {
-    var success = function(location) {
-      if (options.success) {
-        options.success(new Parse.GeoPoint({
-          latitude: location.coords.latitude,
-          longitude: location.coords.longitude
-        }));
-      }
-    };
-    var error = function(e) {
-      if (options.error) {
-        options.error(e);
-      }
-    };
-    navigator.geolocation.getCurrentPosition(success, error);
+    var promise = new Parse.Promise();
+    navigator.geolocation.getCurrentPosition(function(location) {
+      promise.resolve(new Parse.GeoPoint({
+        latitude: location.coords.latitude,
+        longitude: location.coords.longitude
+      }));
+
+    }, function(error) {
+      promise.reject(error);
+    });
+
+    return promise._thenRunCallbacks(options);
   };
 
   Parse.GeoPoint.prototype = {
@@ -2302,12 +2545,12 @@
         if (_.isFunction(arg1)) {
           throw "Parse.ACL() called with a function.  Did you forget ()?";
         }
-        Parse._each(arg1, function(accessList, userId) {
+        Parse._objectEach(arg1, function(accessList, userId) {
           if (!_.isString(userId)) {
             throw "Tried to create an ACL with an invalid userId.";
           }
           self.permissionsById[userId] = {};
-          Parse._each(accessList, function(allowed, permission) {
+          Parse._objectEach(accessList, function(allowed, permission) {
             if (permission !== "read" && permission !== "write") {
               throw "Tried to create an ACL with an invalid permission type.";
             }
@@ -2591,7 +2834,7 @@
    */
   Parse.Op._registerDecoder("Batch", function(json) {
     var op = null;
-    _.each(json.ops, function(nextOp) {
+    Parse._arrayEach(json.ops, function(nextOp) {
       nextOp = Parse.Op._decode(nextOp);
       op = nextOp._mergeWithPrevious(op);
     });
@@ -2877,7 +3120,7 @@
       } else {
         var newValue = _.difference(oldValue, this.objects());
         // If there are saved Parse Objects being removed, also remove them.
-        _.each(this.objects(), function(obj) {
+        Parse._arrayEach(this.objects(), function(obj) {
           if (obj instanceof Parse.Object && obj.id) {
             newValue = _.reject(newValue, function(other) {
               return (other instanceof Parse.Object) && (other.id === obj.id);
@@ -3245,7 +3488,7 @@
         }
       };
 
-      _.each(objects, function(object, i) {
+      Parse._arrayEach(objects, function(object, i) {
         if (Parse.Promise.is(object)) {
           object.then(function(result) {
             results[i] = result;
@@ -3295,7 +3538,7 @@
       this._resolved = true;
       this._result = arguments;
       var results = arguments;
-      _.each(this._resolvedCallbacks, function(resolvedCallback) {
+      Parse._arrayEach(this._resolvedCallbacks, function(resolvedCallback) {
         resolvedCallback.apply(this, results);
       });
       this._resolvedCallbacks = [];
@@ -3313,7 +3556,7 @@
       }
       this._rejected = true;
       this._error = error;
-      _.each(this._rejectedCallbacks, function(rejectedCallback) {
+      Parse._arrayEach(this._rejectedCallbacks, function(rejectedCallback) {
         rejectedCallback(error);
       });
       this._resolvedCallbacks = [];
@@ -3395,10 +3638,12 @@
      * @param optionsOrCallback {} A Backbone-style options callback, or a
      * callback function. If this is an options object and contains a "model"
      * attributes, that will be passed to error callbacks as the first argument.
+     * @param model {} If truthy, this will be passed as the first result of
+     * error callbacks. This is for Backbone-compatability.
      * @return {Parse.Promise} A promise that will be resolved after the
      * callbacks are run, with the same result as this.
      */
-    _thenRunCallbacks: function(optionsOrCallback) {
+    _thenRunCallbacks: function(optionsOrCallback, model) {
       var options;
       if (_.isFunction(optionsOrCallback)) {
         var callback = optionsOrCallback;
@@ -3417,38 +3662,423 @@
 
       return this.then(function(result) {
         if (options.success) {
-          options.success(result);
+          options.success.apply(this, arguments);
+        } else if (model) {
+          // When there's no callback, a sync event should be triggered.
+          model.trigger('sync', model, result, options);
         }
-        return result;
+        return Parse.Promise.as.apply(Parse.Promise, arguments);
       }, function(error) {
         if (options.error) {
-          if (options.model) {
-            options.error(options.model, error);
+          if (!_.isUndefined(model)) {
+            options.error(model, error);
           } else {
             options.error(error);
           }
+        } else if (model) {
+          // When there's no error callback, an error event should be triggered.
+          model.trigger('error', model, error, options);
         }
+        // By explicitly returning a rejected Promise, this will work with
+        // either jQuery or Promises/A semantics.
         return Parse.Promise.error(error);
       });
     },
 
     /**
-     * Adds a callback function that should be called regardless of whether
-     * this promise failed or succeeded. The callback will be given either the
-     * array of results for its first argument, or the error as its second,
-     * depending on whether this Promise was rejected or resolved. Returns a
-     * new Promise, like "then" would.
-     * @param {Function} continuation the callback.
+     * Adds a callback function that should be called regardless of whether
+     * this promise failed or succeeded. The callback will be given either the
+     * array of results for its first argument, or the error as its second,
+     * depending on whether this Promise was rejected or resolved. Returns a
+     * new Promise, like "then" would.
+     * @param {Function} continuation the callback.
+     */
+    _continueWith: function(continuation) {
+      return this.then(function() {
+        return continuation(arguments, null);
+      }, function(error) {
+        return continuation(null, error);
+      });
+    }
+
+  });
+
+}(this));
+
+/*jshint bitwise:false *//*global FileReader: true, File: true */
+(function(root) {
+  root.Parse = root.Parse || {};
+  var Parse = root.Parse;
+  var _ = Parse._;
+
+  var b64Digit = function(number) {
+    if (number < 26) {
+      return String.fromCharCode(65 + number);
+    }
+    if (number < 52) {
+      return String.fromCharCode(97 + (number - 26));
+    }
+    if (number < 62) {
+      return String.fromCharCode(48 + (number - 52));
+    }
+    if (number === 62) {
+      return "+";
+    }
+    if (number === 63) {
+      return "/";
+    }
+    throw "Tried to encode large digit " + number + " in base64.";
+  };
+
+  var encodeBase64 = function(array) {
+    var chunks = [];
+    chunks.length = Math.ceil(array.length / 3);
+    _.times(chunks.length, function(i) {
+      var b1 = array[i * 3];
+      var b2 = array[i * 3 + 1] || 0;
+      var b3 = array[i * 3 + 2] || 0;
+
+      var has2 = (i * 3 + 1) < array.length;
+      var has3 = (i * 3 + 2) < array.length;
+
+      chunks[i] = [
+        b64Digit((b1 >> 2) & 0x3F),
+        b64Digit(((b1 << 4) & 0x30) | ((b2 >> 4) & 0x0F)),
+        has2 ? b64Digit(((b2 << 2) & 0x3C) | ((b3 >> 6) & 0x03)) : "=",
+        has3 ? b64Digit(b3 & 0x3F) : "="
+      ].join("");
+    });
+    return chunks.join("");
+  };
+
+  
+  // A list of file extensions to mime types as found here:
+  // http://stackoverflow.com/questions/58510/using-net-how-can-you-find-the-
+  //     mime-type-of-a-file-based-on-the-file-signature
+  var mimeTypes = {
+    ai: "application/postscript",
+    aif: "audio/x-aiff",
+    aifc: "audio/x-aiff",
+    aiff: "audio/x-aiff",
+    asc: "text/plain",
+    atom: "application/atom+xml",
+    au: "audio/basic",
+    avi: "video/x-msvideo",
+    bcpio: "application/x-bcpio",
+    bin: "application/octet-stream",
+    bmp: "image/bmp",
+    cdf: "application/x-netcdf",
+    cgm: "image/cgm",
+    "class": "application/octet-stream",
+    cpio: "application/x-cpio",
+    cpt: "application/mac-compactpro",
+    csh: "application/x-csh",
+    css: "text/css",
+    dcr: "application/x-director",
+    dif: "video/x-dv",
+    dir: "application/x-director",
+    djv: "image/vnd.djvu",
+    djvu: "image/vnd.djvu",
+    dll: "application/octet-stream",
+    dmg: "application/octet-stream",
+    dms: "application/octet-stream",
+    doc: "application/msword",
+    docx: "application/vnd.openxmlformats-officedocument.wordprocessingml." +
+          "document",
+    dotx: "application/vnd.openxmlformats-officedocument.wordprocessingml." +
+          "template",
+    docm: "application/vnd.ms-word.document.macroEnabled.12",
+    dotm: "application/vnd.ms-word.template.macroEnabled.12",
+    dtd: "application/xml-dtd",
+    dv: "video/x-dv",
+    dvi: "application/x-dvi",
+    dxr: "application/x-director",
+    eps: "application/postscript",
+    etx: "text/x-setext",
+    exe: "application/octet-stream",
+    ez: "application/andrew-inset",
+    gif: "image/gif",
+    gram: "application/srgs",
+    grxml: "application/srgs+xml",
+    gtar: "application/x-gtar",
+    hdf: "application/x-hdf",
+    hqx: "application/mac-binhex40",
+    htm: "text/html",
+    html: "text/html",
+    ice: "x-conference/x-cooltalk",
+    ico: "image/x-icon",
+    ics: "text/calendar",
+    ief: "image/ief",
+    ifb: "text/calendar",
+    iges: "model/iges",
+    igs: "model/iges",
+    jnlp: "application/x-java-jnlp-file",
+    jp2: "image/jp2",
+    jpe: "image/jpeg",
+    jpeg: "image/jpeg",
+    jpg: "image/jpeg",
+    js: "application/x-javascript",
+    kar: "audio/midi",
+    latex: "application/x-latex",
+    lha: "application/octet-stream",
+    lzh: "application/octet-stream",
+    m3u: "audio/x-mpegurl",
+    m4a: "audio/mp4a-latm",
+    m4b: "audio/mp4a-latm",
+    m4p: "audio/mp4a-latm",
+    m4u: "video/vnd.mpegurl",
+    m4v: "video/x-m4v",
+    mac: "image/x-macpaint",
+    man: "application/x-troff-man",
+    mathml: "application/mathml+xml",
+    me: "application/x-troff-me",
+    mesh: "model/mesh",
+    mid: "audio/midi",
+    midi: "audio/midi",
+    mif: "application/vnd.mif",
+    mov: "video/quicktime",
+    movie: "video/x-sgi-movie",
+    mp2: "audio/mpeg",
+    mp3: "audio/mpeg",
+    mp4: "video/mp4",
+    mpe: "video/mpeg",
+    mpeg: "video/mpeg",
+    mpg: "video/mpeg",
+    mpga: "audio/mpeg",
+    ms: "application/x-troff-ms",
+    msh: "model/mesh",
+    mxu: "video/vnd.mpegurl",
+    nc: "application/x-netcdf",
+    oda: "application/oda",
+    ogg: "application/ogg",
+    pbm: "image/x-portable-bitmap",
+    pct: "image/pict",
+    pdb: "chemical/x-pdb",
+    pdf: "application/pdf",
+    pgm: "image/x-portable-graymap",
+    pgn: "application/x-chess-pgn",
+    pic: "image/pict",
+    pict: "image/pict",
+    png: "image/png", 
+    pnm: "image/x-portable-anymap",
+    pnt: "image/x-macpaint",
+    pntg: "image/x-macpaint",
+    ppm: "image/x-portable-pixmap",
+    ppt: "application/vnd.ms-powerpoint",
+    pptx: "application/vnd.openxmlformats-officedocument.presentationml." +
+          "presentation",
+    potx: "application/vnd.openxmlformats-officedocument.presentationml." +
+          "template",
+    ppsx: "application/vnd.openxmlformats-officedocument.presentationml." +
+          "slideshow",
+    ppam: "application/vnd.ms-powerpoint.addin.macroEnabled.12",
+    pptm: "application/vnd.ms-powerpoint.presentation.macroEnabled.12",
+    potm: "application/vnd.ms-powerpoint.template.macroEnabled.12",
+    ppsm: "application/vnd.ms-powerpoint.slideshow.macroEnabled.12",
+    ps: "application/postscript",
+    qt: "video/quicktime",
+    qti: "image/x-quicktime",
+    qtif: "image/x-quicktime",
+    ra: "audio/x-pn-realaudio",
+    ram: "audio/x-pn-realaudio",
+    ras: "image/x-cmu-raster",
+    rdf: "application/rdf+xml",
+    rgb: "image/x-rgb",
+    rm: "application/vnd.rn-realmedia",
+    roff: "application/x-troff",
+    rtf: "text/rtf",
+    rtx: "text/richtext",
+    sgm: "text/sgml",
+    sgml: "text/sgml",
+    sh: "application/x-sh",
+    shar: "application/x-shar",
+    silo: "model/mesh",
+    sit: "application/x-stuffit",
+    skd: "application/x-koan",
+    skm: "application/x-koan",
+    skp: "application/x-koan",
+    skt: "application/x-koan",
+    smi: "application/smil",
+    smil: "application/smil",
+    snd: "audio/basic",
+    so: "application/octet-stream",
+    spl: "application/x-futuresplash",
+    src: "application/x-wais-source",
+    sv4cpio: "application/x-sv4cpio",
+    sv4crc: "application/x-sv4crc",
+    svg: "image/svg+xml",
+    swf: "application/x-shockwave-flash",
+    t: "application/x-troff",
+    tar: "application/x-tar",
+    tcl: "application/x-tcl",
+    tex: "application/x-tex",
+    texi: "application/x-texinfo",
+    texinfo: "application/x-texinfo",
+    tif: "image/tiff",
+    tiff: "image/tiff",
+    tr: "application/x-troff",
+    tsv: "text/tab-separated-values",
+    txt: "text/plain",
+    ustar: "application/x-ustar",
+    vcd: "application/x-cdlink",
+    vrml: "model/vrml",
+    vxml: "application/voicexml+xml",
+    wav: "audio/x-wav",
+    wbmp: "image/vnd.wap.wbmp",
+    wbmxl: "application/vnd.wap.wbxml",
+    wml: "text/vnd.wap.wml",
+    wmlc: "application/vnd.wap.wmlc",
+    wmls: "text/vnd.wap.wmlscript",
+    wmlsc: "application/vnd.wap.wmlscriptc",
+    wrl: "model/vrml",
+    xbm: "image/x-xbitmap",
+    xht: "application/xhtml+xml",
+    xhtml: "application/xhtml+xml",
+    xls: "application/vnd.ms-excel",
+    xml: "application/xml",
+    xpm: "image/x-xpixmap",
+    xsl: "application/xml",
+    xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    xltx: "application/vnd.openxmlformats-officedocument.spreadsheetml." +
+          "template",
+    xlsm: "application/vnd.ms-excel.sheet.macroEnabled.12",
+    xltm: "application/vnd.ms-excel.template.macroEnabled.12",
+    xlam: "application/vnd.ms-excel.addin.macroEnabled.12",
+    xlsb: "application/vnd.ms-excel.sheet.binary.macroEnabled.12",
+    xslt: "application/xslt+xml",
+    xul: "application/vnd.mozilla.xul+xml",
+    xwd: "image/x-xwindowdump",
+    xyz: "chemical/x-xyz",
+    zip: "application/zip"
+  };
+
+  /**
+   * Reads a File using a FileReader.
+   * @param file {File} the File to read.
+   * @param type {String} (optional) the mimetype to override with.
+   * @return {Parse.Promise} A Promise that will be fulfilled with a
+   *     base64-encoded string of the data and its mime type.
+   */
+  var readAsync = function(file, type) {
+    var promise = new Parse.Promise();
+
+    if (typeof(FileReader) === "undefined") {
+      return Parse.Promise.error(new Parse.Error(
+          -1, "Attempted to use a FileReader on an unsupported browser."));
+    }
+
+    var reader = new FileReader();
+    reader.onloadend = function() {
+      if (reader.readyState !== 2) {
+        promise.reject(new Parse.Error(-1, "Error reading file."));
+        return;
+      }
+
+      var dataURL = reader.result;
+      var matches = /^data:([^;]*);base64,(.*)$/.exec(dataURL);
+      if (!matches) {
+        promise.reject(
+            new Parse.Error(-1, "Unable to interpret data URL: " + dataURL));
+        return;
+      }
+
+      promise.resolve(matches[2], type || matches[1]);
+    };
+    reader.readAsDataURL(file);
+    return promise;
+  };
+
+  /**
+   * A Parse.File is a local representation of a file that is saved to the Parse
+   * cloud.
+   * @param name {String} The file's name. This will change to a unique value
+   *     once the file has finished saving.
+   * @param data {Array} The data for the file, as either:
+   *     1. an Array of byte value Numbers, or
+   *     2. an Object like { base64: "..." } with a base64-encoded String.
+   *     3. a File object selected with a file upload control. (3) only works
+   *        in Firefox 3.6+, Safari 6.0.2+, Chrome 7+, and IE 10+.
+   *        For example:<pre>
+   * var fileUploadControl = $("#profilePhotoFileUpload")[0];
+   * if (fileUploadControl.files.length > 0) {
+   *   var file = fileUploadControl.files[0];
+   *   var name = "photo.jpg";
+   *   var parseFile = new Parse.File(name, file);
+   *   parseFile.save().then(function() {
+   *     // The file has been saved to Parse.
+   *   }, function(error) {
+   *     // The file either could not be read, or could not be saved to Parse.
+   *   });
+   * }</pre>
+   * @param type {String} Optional Content-Type header to use for the file. If
+   *     this is omitted, the content type will be inferred from the name's
+   *     extension.
+   */
+  Parse.File = function(name, data, type) {
+    this._name = name;
+
+    // Guess the content type from the extension if we need to.
+    var extension = /\.([^.]*)$/.exec(name);
+    if (extension) {
+      extension = extension[1].toLowerCase();
+    }
+    var guessedType = type || mimeTypes[extension] || "text/plain";
+
+    if (_.isArray(data)) {
+      this._source = Parse.Promise.as(encodeBase64(data), guessedType);
+    } else if (data && data.base64) {
+      this._source = Parse.Promise.as(data.base64, guessedType);
+    } else if (typeof(File) !== "undefined" && data instanceof File) {
+      this._source = readAsync(data, type);
+    } else if (_.isString(data)) {
+      throw "Creating a Parse.File from a String is not yet supported.";
+    }
+  };
+
+  Parse.File.prototype = {
+
+    /**
+     * Gets the name of the file. Before save is called, this is the filename
+     * given by the user. After save is called, that name gets prefixed with a
+     * unique identifier.
+     */
+    name: function() {
+      return this._name;
+    },
+
+    /**
+     * Gets the url of the file. It is only available after you save the file or
+     * after you get the file from a Parse.Object.
+     * @return {String}
      */
-    _continueWith: function(continuation) {
-      return this.then(function() {
-        return continuation(arguments, null);
-      }, function(error) {
-        return continuation(null, error);
-      });
-    }
+    url: function() {
+      return this._url;
+    },
 
-  });
+    /**
+     * Saves the file to the Parse cloud.
+     * @param {Object} options A Backbone-style options object.
+     * @return {Parse.Promise} Promise that is resolved when the save finishes.
+     */
+    save: function(options) {
+      var self = this;
+      if (!self._previousSave) {
+        self._previousSave = self._source.then(function(base64, type) {
+          var data = {
+            base64: base64,
+            _ContentType: type
+          };
+          return Parse._request("files", self._name, null, 'POST', data);
+
+        }).then(function(response) {
+          self._name = response.name;
+          self._url = response.url;
+          return self;
+        });
+      }
+      return self._previousSave._thenRunCallbacks(options);
+    }
+  };
 
 }(this));
 
@@ -3580,17 +4210,17 @@
      */
     toJSON: function() {
       var json = this._toFullJSON();
-      _.each(["__type", "className"],
-             function(key) { delete json[key]; });
+      Parse._arrayEach(["__type", "className"],
+                       function(key) { delete json[key]; });
       return json;
     },
 
     _toFullJSON: function(seenObjects) {
       var json = _.clone(this.attributes);
-      Parse._each(json, function(val, key) {
+      Parse._objectEach(json, function(val, key) {
         json[key] = Parse._encode(val, seenObjects);
       });
-      Parse._each(this._operations, function(val, key) {
+      Parse._objectEach(this._operations, function(val, key) {
         json[key] = val;
       });
 
@@ -3623,7 +4253,11 @@
      */
     _refreshCache: function() {
       var self = this;
-      Parse._each(this.attributes, function(value, key) {
+      if (self._refreshingCache) {
+        return;
+      }
+      self._refreshingCache = true;
+      Parse._objectEach(this.attributes, function(value, key) {
         if (value instanceof Parse.Object) {
           value._refreshCache();
         } else if (_.isObject(value)) {
@@ -3632,6 +4266,7 @@
           }
         }
       });
+      delete self._refreshingCache;
     },
 
     /**
@@ -3732,7 +4367,8 @@
     _mergeMagicFields: function(attrs) {
       // Check for changes of magic fields.
       var model = this;
-      _.each(["id", "objectId", "createdAt", "updatedAt"], function(attr) {
+      var specialFields = ["id", "objectId", "createdAt", "updatedAt"];
+      Parse._arrayEach(specialFields, function(attr) {
         if (attrs[attr]) {
           if (attr === "objectId") {
             model.id = attrs[attr];
@@ -3771,7 +4407,7 @@
       var failedChanges = _.first(this._opSetQueue);
       this._opSetQueue = _.rest(this._opSetQueue);
       var nextChanges = _.first(this._opSetQueue);
-      Parse._each(failedChanges, function(op, key) {
+      Parse._objectEach(failedChanges, function(op, key) {
         var op1 = failedChanges[key];
         var op2 = nextChanges[key];
         if (op1 && op2) {
@@ -3795,7 +4431,7 @@
       // same object, but that's a risk we have to take.
       var fetchedObjects = {};
       Parse._traverse(this.attributes, function(object) {
-        if (object.id && object._hasData) {
+        if (object instanceof Parse.Object && object.id && object._hasData) {
           fetchedObjects[object.id] = object;
         }
       });
@@ -3805,13 +4441,13 @@
       this._applyOpSet(savedChanges, this._serverData);
       this._mergeMagicFields(serverData);
       var self = this;
-      Parse._each(serverData, function(value, key) {
+      Parse._objectEach(serverData, function(value, key) {
         self._serverData[key] = Parse._decode(key, value);
 
         // Look for any objects that might have become unfetched and fix them
         // by replacing their values with the previously observed values.
         var fetched = Parse._traverse(self._serverData[key], function(object) {
-          if (fetchedObjects[object.id]) {
+          if (object instanceof Parse.Object && fetchedObjects[object.id]) {
             return fetchedObjects[object.id];
           }
         });
@@ -3834,7 +4470,7 @@
       // Bring in all the new server data.
       this._mergeMagicFields(serverData);
       var self = this;
-      Parse._each(serverData, function(value, key) {
+      Parse._objectEach(serverData, function(value, key) {
         self._serverData[key] = Parse._decode(key, value);
       });
 
@@ -3853,7 +4489,7 @@
      */
     _applyOpSet: function(opSet, target) {
       var self = this;
-      Parse._.each(opSet, function(change, key) {
+      Parse._objectEach(opSet, function(change, key) {
         target[key] = change._estimate(target[key], self, key);
         if (target[key] === Parse.Op._UNSET) {
           delete target[key];
@@ -3867,7 +4503,9 @@
      */
     _resetCacheForKey: function(key) {
       var value = this.attributes[key];
-      if (_.isObject(value) && !(value instanceof Parse.Object)) {
+      if (_.isObject(value) &&
+          !(value instanceof Parse.Object) &&
+          !(value instanceof Parse.File)) {
         value = value.toJSON ? value.toJSON() : value;
         var json = JSON.stringify(value);
         if (this._hashedJSON[key] !== json) {
@@ -3889,7 +4527,7 @@
       if (this._serverData[key]) {
         this.attributes[key] = this._serverData[key];
       }
-      _.each(this._opSetQueue, function(opSet) {
+      Parse._arrayEach(this._opSetQueue, function(opSet) {
         var op = opSet[key];
         if (op) {
           self.attributes[key] = op._estimate(self.attributes[key], self, key);
@@ -3913,20 +4551,20 @@
       var previousAttributes = _.clone(this.attributes);
 
       this.attributes = _.clone(this._serverData);
-      _.each(this._opSetQueue, function(opSet) {
+      Parse._arrayEach(this._opSetQueue, function(opSet) {
         self._applyOpSet(opSet, self.attributes);
-        _.each(opSet, function(op, key) {
+        Parse._objectEach(opSet, function(op, key) {
           self._resetCacheForKey(key);
         });
       });
 
       // Trigger change events for anything that changed because of the fetch.
-      _.each(previousAttributes, function(oldValue, key) {
+      Parse._objectEach(previousAttributes, function(oldValue, key) {
         if (self.attributes[key] !== oldValue) {
           self.trigger('change:' + key, self, self.attributes[key], {});
         }
       });
-      _.each(this.attributes, function(newValue, key) {
+      Parse._objectEach(this.attributes, function(newValue, key) {
         if (!_.has(previousAttributes, key)) {
           self.trigger('change:' + key, self, newValue, {});
         }
@@ -3969,7 +4607,7 @@
       var attrs, attr;
       if (_.isObject(key) || Parse._isNullOrUndefined(key)) {
         attrs = key;
-        Parse._each(attrs, function(v, k) {
+        Parse._objectEach(attrs, function(v, k) {
           attrs[k] = Parse._decode(k, v);
         });
         options = value;
@@ -3989,7 +4627,7 @@
 
       // If the unset option is used, every attribute should be a Unset.
       if (options.unset) {
-        Parse._each(attrs, function(unused_value, key) {
+        Parse._objectEach(attrs, function(unused_value, key) {
           attrs[key] = new Parse.Op.Unset();
         });
       }
@@ -3997,7 +4635,7 @@
       // Apply all the attributes to get the estimated values.
       var dataToValidate = _.clone(attrs);
       var self = this;
-      Parse._each(dataToValidate, function(value, key) {
+      Parse._objectEach(dataToValidate, function(value, key) {
         if (value instanceof Parse.Op) {
           dataToValidate[key] = value._estimate(self.attributes[key],
                                                 self, key);
@@ -4019,7 +4657,7 @@
       var prev = this._previousAttributes || {};
 
       // Update attributes.
-      Parse._each(_.keys(attrs), function(attr) {
+      Parse._arrayEach(_.keys(attrs), function(attr) {
         var val = attrs[attr];
 
         // If this is a relation object we need to set the parent correctly,
@@ -4158,7 +4796,7 @@
      */
     _getSaveJSON: function() {
       var json = _.clone(_.first(this._opSetQueue));
-      Parse._each(json, function(op, key) {
+      Parse._objectEach(json, function(op, key) {
         json[key] = op.toJSON();
       });
       return json;
@@ -4179,22 +4817,12 @@
      *     completes.
      */
     fetch: function(options) {
-      var promise = new Parse.Promise();
-      options = options ? _.clone(options) : {};
-      var model = this;
-      var success = options.success;
-      options.success = function(resp, status, xhr) {
-        model._finishFetch(model.parse(resp, status, xhr), true);
-        if (success) {
-          success(model, resp);
-        }
-        promise.resolve(model);
-      };
-      options.error = Parse.Object._wrapError(options.error, model, options,
-                                              promise);
-      Parse._request(
-          "classes", model.className, model.id, 'GET', null, options);
-      return promise;
+      var self = this;
+      var request = Parse._request("classes", this.className, this.id, 'GET');
+      return request.then(function(response, status, xhr) {
+        self._finishFetch(self.parse(response, status, xhr), true);
+        return self;
+      })._thenRunCallbacks(options, this);
     },
 
     /**
@@ -4236,8 +4864,6 @@
      * @see Parse.Error
      */
     save: function(arg1, arg2, arg3) {
-      var promise = new Parse.Promise();
-
       var i, attrs, current, options, saved;
       if (_.isObject(arg1) || Parse._isNullOrUndefined(arg1)) {
         attrs = arg1;
@@ -4269,25 +4895,22 @@
         }
       }
 
-      options = options ? _.clone(options) : {};
+      options = _.clone(options) || {};
       if (options.wait) {
         current = _.clone(this.attributes);
       }
-      var setOptions = _.clone(options);
+
+      var setOptions = _.clone(options) || {};
       if (setOptions.wait) {
         setOptions.silent = true;
       }
+      var setError;
       setOptions.error = function(model, error) {
-        if (options.error) {
-          options.error.apply(this, arguments);
-        }
-        promise.reject(error);
+        setError = error;
       };
       if (attrs && !this.set(attrs, setOptions)) {
-        return promise;
+        return Parse.Promise.error(setError)._thenRunCallbacks(options, this);
       }
-      var oldOptions = options;  // Psuedonym more accurate in some contexts.
-      var newOptions = _.clone(options);
 
       var model = this;
 
@@ -4296,53 +4919,24 @@
 
       
 
-      var unsavedChildren = Parse.Object._findUnsavedChildren(model.attributes);
-      if (unsavedChildren.length > 0) {
+      var unsavedChildren = [];
+      var unsavedFiles = [];
+      Parse.Object._findUnsavedChildren(model.attributes,
+                                        unsavedChildren,
+                                        unsavedFiles);
+      if (unsavedChildren.length + unsavedFiles.length > 0) {
         return Parse.Object._deepSaveAsync(this.attributes).then(function() {
-          return model.save(null, oldOptions);
+          return model.save(null, options);
         }, function(error) {
-          if (options.error) {
-            options.error.apply(this, arguments);
-          }
-          return Parse.Promise.error(error);
+          return Parse.Promise.error(error)._thenRunCallbacks(options, model);
         });
       }
 
-      /** ignore */
-      newOptions.success = function(resp, status, xhr) {
-        var serverAttrs = model.parse(resp, status, xhr);
-        if (newOptions.wait) {
-          serverAttrs = _.extend(attrs || {}, serverAttrs);
-        }
-
-        model._finishSave(serverAttrs);
-
-        if (oldOptions.success) {
-          oldOptions.success(model, resp);
-        } else {
-          model.trigger('sync', model, resp, newOptions);
-        }
-
-        promise.resolve(model);
-      };
-
-      newOptions.error = function(model, error) {
-        model._cancelSave();
-        if (oldOptions.error) {
-          oldOptions.error.apply(this, arguments);
-        }
-
-        promise.reject(error);
-      };
-
-      newOptions.error = Parse.Object._wrapError(newOptions.error, model,
-                                                 newOptions);
-
       this._startSave();
       this._saving = (this._saving || 0) + 1;
 
       this._allPreviousSaves = this._allPreviousSaves || Parse.Promise.as();
-      this._allPreviousSaves._continueWith(function() {
+      this._allPreviousSaves = this._allPreviousSaves._continueWith(function() {
         var method = model.id ? 'PUT' : 'POST';
 
         var json = model._getSaveJSON();
@@ -4354,17 +4948,28 @@
           route = "users";
           className = null;
         }
-        var request =
-          Parse._request(route, className, model.id, method, json, newOptions);
-        if (newOptions.wait) {
-          model.set(current, setOptions);
-        }
-        return request;
+        var request = Parse._request(route, className, model.id, method, json);
 
-      });
-      this._allPreviousSaves = promise;
+        request = request.then(function(resp, status, xhr) {
+          var serverAttrs = model.parse(resp, status, xhr);
+          if (options.wait) {
+            serverAttrs = _.extend(attrs || {}, serverAttrs);
+          }
+          model._finishSave(serverAttrs);
+          if (options.wait) {
+            model.set(current, setOptions);
+          }
+          return model;
 
-      return promise;
+        }, function(error) {
+          model._cancelSave();
+          return Parse.Promise.error(error);
+
+        })._thenRunCallbacks(options, model);
+
+        return request;
+      });
+      return this._allPreviousSaves;
     },
 
     /**
@@ -4377,10 +4982,8 @@
      *     completes.
      */
     destroy: function(options) {
-      var promise = new Parse.Promise();
-      options = options ? _.clone(options) : {};
+      options = options || {};
       var model = this;
-      var success = options.success;
 
       var triggerDestroy = function() {
         model.trigger('destroy', model, model.collection, options);
@@ -4389,27 +4992,19 @@
       if (!this.id) {
         return triggerDestroy();
       }
-      /** ignore */
-      options.success = function(resp) {
-        if (options.wait) {
-          triggerDestroy();
-        }
-        if (success) {
-          success(model, resp);
-        } else {
-          model.trigger('sync', model, resp, options);
-        }
-        promise.resolve(model);
-      };
-      options.error = Parse.Object._wrapError(options.error, model, options,
-                                              promise);
 
-      Parse._request("classes", this.className, this.id, 'DELETE', null,
-                    options);
       if (!options.wait) {
         triggerDestroy();
       }
-      return promise;
+
+      var request =
+          Parse._request("classes", this.className, this.id, 'DELETE');
+      return request.then(function() {
+        if (options.wait) {
+          triggerDestroy();
+        }
+        return model;
+      })._thenRunCallbacks(options, this);
     },
 
     /**
@@ -4460,14 +5055,14 @@
 
       // Silent changes become pending changes.
       var self = this;
-      Parse._each(this._silent, function(attr) {
+      Parse._objectEach(this._silent, function(attr) {
         self._pending[attr] = true;
       });
 
       // Silent changes are triggered.
       var changes = _.extend({}, options.changes, this._silent);
       this._silent = {};
-      Parse._each(changes, function(unused_value, attr) {
+      Parse._objectEach(changes, function(unused_value, attr) {
         self.trigger('change:' + attr, self, self.get(attr), options);
       });
       if (changing) {
@@ -4486,7 +5081,7 @@
         this._pending = {};
         this.trigger('change', this, options);
         // Pending and silent changes still remain.
-        Parse._each(this.changed, deleteChanged);
+        Parse._objectEach(this.changed, deleteChanged);
         self._previousAttributes = _.clone(this.attributes);
       }
 
@@ -4531,7 +5126,7 @@
       }
       var changed = {};
       var old = this._previousAttributes;
-      Parse._each(diff, function(diffVal, attr) {
+      Parse._objectEach(diff, function(diffVal, attr) {
         if (!_.isEqual(old[attr], diffVal)) {
           changed[attr] = diffVal;
         }
@@ -4732,41 +5327,23 @@
     return NewClassObject;
   };
 
-  /**
-   * Wrap an optional error callback with a fallback error event.
-   */
-  Parse.Object._wrapError = function(onError, originalModel, options, promise) {
-    return function(model, response) {
-      if (model !== originalModel) {
-        response = model;
-      }
-      var error = new Parse.Error(-1, response.responseText);
-      if (response.responseText) {
-        var errorJSON = JSON.parse(response.responseText);
-        if (errorJSON) {
-          error = new Parse.Error(errorJSON.code, errorJSON.error);
+  Parse.Object._findUnsavedChildren = function(object, children, files) {
+    Parse._traverse(object, function(object) {
+      if (object instanceof Parse.Object) {
+        object._refreshCache();
+        if (object.dirty()) {
+          children.push(object);
         }
+        return;
       }
-      if (onError) {
-        onError(originalModel, error, options);
-      } else {
-        originalModel.trigger('error', originalModel, error, options);
-      }
-      if (promise) {
-        promise.reject(error);
-      }
-    };
-  };
 
-  Parse.Object._findUnsavedChildren = function(object) {
-    var results = [];
-    Parse._traverse(object, function(object) {
-      object._refreshCache();
-      if (object.dirty()) {
-        results.push(object);
+      if (object instanceof Parse.File) {
+        if (!object.url()) {
+          files.push(object);
+        }
+        return;
       }
     });
-    return results;
   };
 
   Parse.Object._canBeSerializedAsValue = function(object) {
@@ -4776,14 +5353,14 @@
       canBeSerializedAsValue = !!object.id;
 
     } else if (_.isArray(object)) {
-      _.each(object, function(child) {
+      Parse._arrayEach(object, function(child) {
         if (!Parse.Object._canBeSerializedAsValue(child)) {
           canBeSerializedAsValue = false;
         }
       });
 
     } else if (_.isObject(object)) {
-      Parse._each(object, function(child) {
+      Parse._objectEach(object, function(child) {
         if (!Parse.Object._canBeSerializedAsValue(child)) {
           canBeSerializedAsValue = false;
         }
@@ -4794,97 +5371,108 @@
   };
 
   Parse.Object._deepSaveAsync = function(object) {
-    var objects = _.uniq(Parse.Object._findUnsavedChildren(object));
+    var unsavedChildren = [];
+    var unsavedFiles = [];
+    Parse.Object._findUnsavedChildren(object, unsavedChildren, unsavedFiles);
+
+    var promise = Parse.Promise.as();
+    _.each(unsavedFiles, function(file) {
+      promise = promise.then(function() {
+        return file.save();
+      });
+    });
+
+    var objects = _.uniq(unsavedChildren);
     var remaining = _.uniq(objects);
 
-    return Parse.Promise._continueWhile(function() {
-      return remaining.length > 0;
-    }, function() {
-
-      // Gather up all the objects that can be saved in this batch.
-      var batch = [];
-      var newRemaining = [];
-      _.each(remaining, function(object) {
-        // Limit batches to 20 objects.
-        if (batch.length > 20) {
-          newRemaining.push(object);
-          return;
-        }
+    return promise.then(function() {
+      return Parse.Promise._continueWhile(function() {
+        return remaining.length > 0;
+      }, function() {
+
+        // Gather up all the objects that can be saved in this batch.
+        var batch = [];
+        var newRemaining = [];
+        Parse._arrayEach(remaining, function(object) {
+          // Limit batches to 20 objects.
+          if (batch.length > 20) {
+            newRemaining.push(object);
+            return;
+          }
 
-        if (object._canBeSerialized()) {
-          batch.push(object);
-        } else {
-          newRemaining.push(object);
-        }
-      });
-      remaining = newRemaining;
+          if (object._canBeSerialized()) {
+            batch.push(object);
+          } else {
+            newRemaining.push(object);
+          }
+        });
+        remaining = newRemaining;
 
-      // If we can't save any objects, there must be a circular reference.
-      if (batch.length === 0) {
-        return Parse.Promise.error(
-          new Parse.Error(Parse.Error.OTHER_CAUSE,
-                          "Tried to save a batch with a cycle."));
-      }
+        // If we can't save any objects, there must be a circular reference.
+        if (batch.length === 0) {
+          return Parse.Promise.error(
+            new Parse.Error(Parse.Error.OTHER_CAUSE,
+                            "Tried to save a batch with a cycle."));
+        }
 
-      // Reserve a spot in every object's save queue.
-      var readyToStart = Parse.Promise.when(_.map(batch, function(object) {
-        return object._allPreviousSaves || Parse.Promise.as();
-      }));
-      var batchFinished = new Parse.Promise();
-      _.each(batch, function(object) {
-        object._allPreviousSaves = batchFinished;
-      });
+        // Reserve a spot in every object's save queue.
+        var readyToStart = Parse.Promise.when(_.map(batch, function(object) {
+          return object._allPreviousSaves || Parse.Promise.as();
+        }));
+        var batchFinished = new Parse.Promise();
+        Parse._arrayEach(batch, function(object) {
+          object._allPreviousSaves = batchFinished;
+        });
 
-      // Save a single batch, whether previous saves succeeded or failed.
-      return readyToStart._continueWith(function() {
-        return Parse._request("batch", null, null, "POST", {
-          requests: _.map(batch, function(object) {
-            var json = object._getSaveJSON();
-            var method = "POST";
-
-            var path = "/1/classes/" + object.className;
-            if (object.id) {
-              path = path + "/" + object.id;
-              method = "PUT";
+        // Save a single batch, whether previous saves succeeded or failed.
+        return readyToStart._continueWith(function() {
+          return Parse._request("batch", null, null, "POST", {
+            requests: _.map(batch, function(object) {
+              var json = object._getSaveJSON();
+              var method = "POST";
+
+              var path = "/1/classes/" + object.className;
+              if (object.id) {
+                path = path + "/" + object.id;
+                method = "PUT";
+              }
+
+              object._startSave();
+
+              return {
+                method: method,
+                path: path,
+                body: json
+              };
+            })
+
+          }).then(function(response, status, xhr) {
+            var error;
+            Parse._arrayEach(batch, function(object, i) {
+              if (response[i].success) {
+                object._finishSave(
+                  object.parse(response[i].success, status, xhr));
+              } else {
+                error = error || response[i].error;
+                object._cancelSave();
+              }
+            });
+            if (error) {
+              return Parse.Promise.error(
+                new Parse.Error(error.code, error.error));
             }
 
-            object._startSave();
-
-            return {
-              method: method,
-              path: path,
-              body: json
-            };
-          })
-
-        }).then(function(response, status, xhr) {
-          var error;
-          _.each(batch, function(object, i) {
-            if (response[i].success) {
-              object._finishSave(
-                object.parse(response[i].success, status, xhr));
-            } else {
-              error = error || response[i].error;
-              object._cancelSave();
-            }
+          }).then(function(results) {
+            batchFinished.resolve(results);
+            return results;
+          }, function(error) {
+            batchFinished.reject(error);
+            return Parse.Promise.error(error);
           });
-          if (error) {
-            return Parse.Promise.error(
-              new Parse.Error(error.code, error.error));
-          }
-
-        }).then(function(results) {
-          batchFinished.resolve(results);
-          return results;
-        }, function(error) {
-          batchFinished.reject(error);
-          return Parse.Promise.error(error);
-
         });
       });
     }).then(function() {
       return object;
-
     });
   };
 
@@ -5237,7 +5825,7 @@
       var self = this;
       models = models || [];
       options = options || {};
-      _.each(this.models, function(model) {
+      Parse._arrayEach(this.models, function(model) {
         self._removeReference(model);
       });
       this._reset();
@@ -5254,26 +5842,20 @@
      * models to the collection instead of resetting.
      */
     fetch: function(options) {
-      options = options ? _.clone(options) : {};
+      options = _.clone(options) || {};
       if (options.parse === undefined) {
         options.parse = true;
       }
       var collection = this;
-      var success = options.success;
-      options.success = function(results, resp) {
+      var query = this.query || new Parse.Query(this.model);
+      return query.find().then(function(results) {
         if (options.add) {
           collection.add(results, options);
         } else {
           collection.reset(results, options);
         }
-        if (success) {
-          success(collection, resp);
-        }
-      };
-      options.error = Parse.Object._wrapError(options.error, collection,
-                                              options);
-      var query = this.query || new Parse.Query(this.model);
-      query.find(options);
+        return collection;
+      })._thenRunCallbacks(options, this);
     },
 
     /**
@@ -5391,7 +5973,7 @@
     'shuffle', 'lastIndexOf', 'isEmpty', 'groupBy'];
 
   // Mix in each Underscore method as a proxy to `Collection#models`.
-  _.each(methods, function(method) {
+  Parse._arrayEach(methods, function(method) {
     Parse.Collection.prototype[method] = function() {
       return _[method].apply(_, [this.models].concat(_.toArray(arguments)));
     };
@@ -5556,7 +6138,7 @@
       }
       this.undelegateEvents();
       var self = this;
-      Parse._each(events, function(method, key) {
+      Parse._objectEach(events, function(method, key) {
         if (!_.isFunction(method)) {
           method = self[events[key]];
         }
@@ -5679,7 +6261,7 @@
       if (!authData) {
         return;
       }
-      _.each(this.get('authData'), function(value, key) {
+      Parse._objectEach(this.get('authData'), function(value, key) {
         if (!authData[key]) {
           delete authData[key];
         }
@@ -5696,7 +6278,7 @@
       }
 
       var self = this;
-      _.each(this.get('authData'), function(value, key) {
+      Parse._objectEach(this.get('authData'), function(value, key) {
         self._synchronizeAuthData(key);
       });
     },
@@ -5760,7 +6342,7 @@
         this.set('authData', authData);
 
         // Overridden so that the user can be made the current user.
-        var newOptions = _.clone(options);
+        var newOptions = _.clone(options) || {};
         newOptions.success = function(model) {
           model._handleSaveResult(true);
           if (options.success) {
@@ -5770,20 +6352,25 @@
         return this.save({'authData': authData}, newOptions);
       } else {
         var self = this;
-        return provider.authenticate({
+        var promise = new Parse.Promise();
+        provider.authenticate({
           success: function(provider, result) {
             self._linkWith(provider, {
               authData: result,
               success: options.success,
               error: options.error
+            }).then(function() {
+              promise.resolve(self);
             });
           },
           error: function(provider, error) {
             if (options.error) {
               options.error(self, error);
             }
+            promise.reject(error);
           }
         });
+        return promise;
       }
     },
 
@@ -5833,7 +6420,7 @@
         return;
       }
       var self = this;
-      _.each(this.get('authData'), function(value, key) {
+      Parse._objectEach(this.get('authData'), function(value, key) {
         self._logOutWith(key);
       });
     },
@@ -5922,24 +6509,14 @@
      *     the login is complete.
      */
     logIn: function(options) {
-      var promise = new Parse.Promise();
       var model = this;
-      var newOptions = options ? _.clone(options) : {};
-      newOptions.success = function(resp, status, xhr) {
+      var request = Parse._request("login", null, null, "GET", this.toJSON());
+      return request.then(function(resp, status, xhr) {
         var serverAttrs = model.parse(resp, status, xhr);
         model._finishFetch(serverAttrs);
         model._handleSaveResult(true);
-        if (options && options.success) {
-          options.success(model, resp);
-        } else {
-          model.trigger('sync', model, resp, newOptions);
-        }
-        promise.resolve(model);
-      };
-      newOptions.error = Parse.Object._wrapError(newOptions.error, model,
-                                                 newOptions, promise);
-      Parse._request("login", null, null, "GET", this.toJSON(), newOptions);
-      return promise;
+        return model;
+      })._thenRunCallbacks(options, this);
     },
 
     /**
@@ -5971,10 +6548,10 @@
      * @see Parse.Object#fetch
      */
     fetch: function(options) {
-      var newOptions = _.clone(options);
+      var newOptions = options ? _.clone(options) : {};
       newOptions.success = function(model) {
         model._handleSaveResult(false);
-        if (options.success) {
+        if (options && options.success) {
           options.success.apply(this, arguments);
         }
       };
@@ -6142,8 +6719,9 @@
      */
     requestPasswordReset: function(email, options) {
       var json = { email: email };
-      options.error = Parse.Query._wrapError(options.error, options);
-      Parse._request("requestPasswordReset", null, null, "POST", json, options);
+      var request = Parse._request("requestPasswordReset", null, null, "POST",
+                                   json);
+      return request._thenRunCallbacks(options);
     },
 
     /**
@@ -6313,7 +6891,7 @@
   Parse.Query.or = function() {
     var queries = _.toArray(arguments);
     var className = null;
-    _.each(queries, function(q) {
+    Parse._arrayEach(queries, function(q) {
       if (_.isNull(className)) {
         className = q.className;
       }
@@ -6338,32 +6916,18 @@
      */
     get: function(objectId, options) {
       var self = this;
-      var success = options.success || function() {};
-      var error = options.error || function() {};
-      var promise = new Parse.Promise();
+      self.equalTo('objectId', objectId);
 
-      /** ignore */
-      var ajaxOptions = {
-        error: function(errorObject) {
-          error(null, errorObject);
-          promise.reject(errorObject);
-        },
-        success: function(response) {
-          if (response) {
-            success(response);
-            promise.resolve(response);
-          } else {
-            var errorObject = new Parse.Error(Parse.Error.OBJECT_NOT_FOUND,
-                                              "Object not found.");
-            error(null, errorObject);
-            promise.reject(errorObject);
-          }
+      return self.first().then(function(response) {
+        if (response) {
+          return response;
         }
-      };
 
-      self.equalTo('objectId', objectId);
-      self.first(ajaxOptions);
-      return promise;
+        var errorObject = new Parse.Error(Parse.Error.OBJECT_NOT_FOUND,
+                                          "Object not found.");
+        return Parse.Promise.error(errorObject);
+
+      })._thenRunCallbacks(options, null);
     },
 
     /**
@@ -6378,6 +6942,9 @@
       if (this._include.length > 0) {
         params.include = this._include.join(",");
       }
+      if (this._select) {
+        params.keys = this._select.join(",");
+      }
       if (this._limit >= 0) {
         params.limit = this._limit;
       }
@@ -6388,7 +6955,7 @@
         params.order = this._order;
       }
 
-      Parse._each(this._extraOptions, function(v, k) {
+      Parse._objectEach(this._extraOptions, function(v, k) {
         params[k] = v;
       });
 
@@ -6406,35 +6973,22 @@
      */
     find: function(options) {
       var self = this;
-      options = options || {};
-      var success = options.success || function() {};
-      var promise = new Parse.Promise();
 
-      /** ignore */
-      var ajaxOptions = {
-        error: options.error,
-        success: function(response) {
-          var results = _.map(response.results, function(json) {
-            var obj;
-            if (response.className) {
-              obj = new Parse.Object(response.className);
-            } else {
-              obj = new self.objectClass();
-            }
-            obj._finishFetch(json, true);
-            return obj;
-          });
-          success(results);
-          promise.resolve(results);
-        }
-      };
+      var request = Parse._request("classes", this.className, null, "GET",
+                                   this.toJSON());
 
-      var params = this.toJSON();
-      ajaxOptions.error = Parse.Query._wrapError(options.error, ajaxOptions,
-                                                 promise);
-      Parse._request("classes", this.className, null, "GET", params,
-                     ajaxOptions);
-      return promise;
+      return request.then(function(response) {
+        return _.map(response.results, function(json) {
+          var obj;
+          if (response.className) {
+            obj = new Parse.Object(response.className);
+          } else {
+            obj = new self.objectClass();
+          }
+          obj._finishFetch(json, true);
+          return obj;
+        });
+      })._thenRunCallbacks(options);
     },
 
     /**
@@ -6447,28 +7001,15 @@
      * the query completes.
      */
     count: function(options) {
-      var self = this;
-      options = options || {};
-      var success = options.success || function() {};
-      var promise = new Parse.Promise();
-
-      /** ignore */
-      var ajaxOptions = {
-        error: options.error,
-        success: function(response) {
-          success(response.count);
-          promise.resolve(response.count);
-        }
-      };
-
       var params = this.toJSON();
       params.limit = 0;
       params.count = 1;
-      ajaxOptions.error = Parse.Query._wrapError(options.error, ajaxOptions,
-                                                 promise);
-      Parse._request("classes", this.className, null, "GET", params,
-                     ajaxOptions);
-      return promise;
+      var request = Parse._request("classes", this.className, null, "GET",
+                                   params);
+
+      return request.then(function(response) {
+        return response.count;
+      })._thenRunCallbacks(options);
     },
 
     /**
@@ -6483,31 +7024,19 @@
      */
     first: function(options) {
       var self = this;
-      options = options || {};
-      var success = options.success || function() {};
-      var promise = new Parse.Promise();
-
-      /** ignore */
-      var ajaxOptions = {
-        error: options.error,
-        success: function(response) {
-          var result = _.map(response.results, function(json) {
-            var obj = new self.objectClass();
-            obj._finishFetch(json, true);
-            return obj;
-          })[0];
-          success(result);
-          promise.resolve(result);
-        }
-      };
 
       var params = this.toJSON();
       params.limit = 1;
-      ajaxOptions.error = Parse.Query._wrapError(options.error, ajaxOptions,
-                                                 promise);
-      Parse._request("classes", this.className, null, "GET", params,
-                     ajaxOptions);
-      return promise;
+      var request = Parse._request("classes", this.className, null, "GET",
+                                   params);
+
+      return request.then(function(response) {
+        return _.map(response.results, function(json) {
+          var obj = new self.objectClass();
+          obj._finishFetch(json, true);
+          return obj;
+        })[0];
+      })._thenRunCallbacks(options);
     },
 
     /**
@@ -6944,45 +7473,108 @@
      * @param {String} key The name of the key to include.
      * @return {Parse.Query} Returns the query, so you can chain this call.
      */
-    include: function(key) {
-      if (_.isArray(key)) {
-        this._include = this._include.concat(key);
-      } else {
-        this._include.push(key);
-      }
+    include: function() {
+      var self = this;
+      Parse._arrayEach(arguments, function(key) {
+        if (_.isArray(key)) {
+          self._include = self._include.concat(key);
+        } else {
+          self._include.push(key);
+        }
+      });
       return this;
-    }
-  };
+    },
 
-  // Wrap an optional error callback with a fallback error event.
-  Parse.Query._wrapError = function(onError, options, promise) {
-    return function(response) {
-      var error;
-      if (response.responseText) {
-        var errorJSON = JSON.parse(response.responseText);
-        if (errorJSON) {
-          error = new Parse.Error(errorJSON.code, errorJSON.error);
+    /**
+     * Restrict the fields of the returned Parse.Objects to include only the
+     * provided keys.  If this is called multiple times, then all of the keys
+     * specified in each of the calls will be included.
+     * @param {Array} keys The names of the keys to include.
+     * @return {Parse.Query} Returns the query, so you can chain this call.
+     */
+    select: function() {
+      var self = this;
+      this._select = this._select || [];
+      Parse._arrayEach(arguments, function(key) {
+        if (_.isArray(key)) {
+          self._select = self._select.concat(key);
+        } else {
+          self._select.push(key);
         }
+      });
+      return this;
+    },
+
+    /**
+     * Iterates over each result of a query, calling a callback for each one. If
+     * the callback returns a promise, the iteration will not continue until
+     * that promise has been fulfilled. If the callback returns a rejected
+     * promise, then iteration will stop with that error. The items are
+     * processed in an unspecified order. The query may not have any sort order,
+     * and may not use limit or skip.
+     * @param callback {Function} Callback that will be called with each result
+     *     of the query.
+     * @param options {Object} An optional Backbone-like options object with
+     *     success and error callbacks that will be invoked once the iteration
+     *     has finished.
+     * @return {Parse.Promise} A promise that will be fulfilled once the
+     *     iteration has completed.
+     */
+    each: function(callback, options) {
+      options = options || {};
+
+      if (this._order || this._skip || (this._limit >= 0)) {
+        var error =
+          "Cannot iterate on a query with sort, skip, or limit.";
+        return Parse.Promise.error(error)._thenRunCallbacks(options);
       }
-      error = error || new Parse.Error(-1, response.responseText);
-      if (onError) {
-        onError(error, options);
-      }
-      if (promise) {
-        promise.reject(error);
-      }
-    };
+
+      var promise = new Parse.Promise();
+
+      var query = new Parse.Query(this.objectClass);
+      // We can override the batch size from the options.
+      // This is undocumented, but useful for testing.
+      query._limit = options.batchSize || 100;
+      query._where = _.clone(this._where);
+      query._include = _.clone(this._include);
+
+      query.ascending('objectId');
+
+      var finished = false;
+      return Parse.Promise._continueWhile(function() {
+        return !finished;
+
+      }, function() {
+        return query.find().then(function(results) {
+          var callbacksDone = Parse.Promise.as();
+          Parse._.each(results, function(result) {
+            callbacksDone = callbacksDone.then(function() {
+              return callback(result);
+            });
+          });
+
+          return callbacksDone.then(function() {
+            if (results.length >= query._limit) {
+              query.greaterThan("objectId", results[results.length - 1].id);
+            } else {
+              finished = true;
+            }
+          });
+        });
+      })._thenRunCallbacks(options);
+    }
   };
+
 }(this));
 
-/*global FB: false */
+/*global FB: false , console: false*/
 (function(root) {
   root.Parse = root.Parse || {};
   var Parse = root.Parse;
   var _ = Parse._;
 
   var PUBLIC_KEY = "*";
-  
+
   var initialized = false;
   var requestedPermissions;
   var initOptions;
@@ -7018,6 +7610,9 @@
         };
         var newOptions = _.clone(initOptions);
         newOptions.authResponse = authResponse;
+
+        // Suppress checks for login status from the browser.
+        newOptions.status = false;
         FB.init(newOptions);
       }
       return true;
@@ -7049,18 +7644,28 @@
      * @param {Object} options Facebook options argument as described here:
      *   <a href=
      *   "https://developers.facebook.com/docs/reference/javascript/FB.init/">
-     *   FB.init()</a>
+     *   FB.init()</a>. The status flag will be coerced to 'false' because it
+     *   interferes with Parse Facebook integration. Call FB.getLoginStatus()
+     *   explicitly if this behavior is required by your application.
      */
     init: function(options) {
       if (typeof(FB) === 'undefined') {
-        throw "The Javascript Facebook SDK must be loaded before calling init.";
+        throw "The Facebook JavaScript SDK must be loaded before calling init.";
       } 
-      initOptions = _.clone(options);
+      initOptions = _.clone(options) || {};
+      if (initOptions.status && typeof(console) !== "undefined") {
+        var warn = console.warn || console.log || function() {};
+        warn.call(console, "The 'status' flag passed into" +
+          " FB.init, when set to true, can interfere with Parse Facebook" +
+          " integration, so it has been suppressed. Please call" +
+          " FB.getLoginStatus() explicitly if you require this behavior.");
+      }
+      initOptions.status = false;
       FB.init(initOptions);
       Parse.User._registerAuthenticationProvider(provider);
       initialized = true;
     },
-    
+
     /**
      * Gets whether the user has their account linked to Facebook.
      * 
@@ -7072,7 +7677,7 @@
     isLinked: function(user) {
       return user._isLinked("facebook");
     },
-    
+
     /**
      * Logs in a user using Facebook. This method delegates to the Facebook
      * SDK to authenticate the user, and then automatically logs in (or
@@ -7094,12 +7699,12 @@
         requestedPermissions = permissions;
         return Parse.User._logInWith("facebook", options);
       } else {
-        var newOptions = _.clone(options);
+        var newOptions = _.clone(options) || {};
         newOptions.authData = permissions;
         return Parse.User._logInWith("facebook", newOptions);
       }
     },
-    
+
     /**
      * Links Facebook to an existing PFUser. This method delegates to the
      * Facebook SDK to authenticate the user, and then automatically links
@@ -7123,12 +7728,12 @@
         requestedPermissions = permissions;
         return user._linkWith("facebook", options);
       } else {
-        var newOptions = _.clone(options);
+        var newOptions = _.clone(options) || {};
         newOptions.authData = permissions;
         return user._linkWith("facebook", newOptions);
       }
     },
-    
+
     /**
      * Unlinks the Parse.User from a Facebook account. 
      * 
@@ -7323,7 +7928,7 @@
         this.navigate(current);
       }
       if (!this.loadUrl()) {
-       this.loadUrl(this.getHash());
+        this.loadUrl(this.getHash());
       }
     },
 
@@ -7537,15 +8142,15 @@
   var _ = Parse._;
 
   /**
-   * 
-   *
    * @namespace Contains functions for calling and declaring
    * <a href="/docs/cloud_code_guide#functions">cloud functions</a>.
    * <p><strong><em>
    *   Some functions are only available from Cloud Code.
    * </em></strong></p>
    */
-  Parse.Cloud = {
+  Parse.Cloud = Parse.Cloud || {};
+
+  _.extend(Parse.Cloud, /** @lends Parse.Cloud */ {
     /**
      * Makes a call to a cloud function.
      * @param {String} name The function name.
@@ -7555,41 +8160,18 @@
      * call to a cloud function.  options.error should be a function that
      * handles an error running the cloud function.  Both functions are
      * optional.  Both functions take a single argument.
+     * @return {Parse.Promise} A promise that will be resolved with the result
+     * of the function.
      */
     run: function(name, data, options) {
-      var oldOptions = options;
-      var newOptions = _.clone(options);
-      newOptions.success = function(resp) {
-        var results = Parse._decode(null, resp);
-        if (oldOptions.success) {
-          oldOptions.success(results.result);
-        }
-      };
+      var request = Parse._request("functions", name, null, 'POST',
+                                   Parse._encode(data, null, true));
 
-      newOptions.error = Parse.Cloud._wrapError(oldOptions.error, options);
-      Parse._request("functions",
-                     name,
-                     null,
-                     'POST',
-                     Parse._encode(data, null, true),
-                     newOptions);
-    },
-
-    _wrapError: function(onError, options) {
-      return function(response) {
-        if (onError) {
-          var error = new Parse.Error(-1, response.responseText);
-          if (response.responseText) {
-            var errorJSON = JSON.parse(response.responseText);
-            if (errorJSON) {
-              error = new Parse.Error(errorJSON.code, errorJSON.error);
-            }
-          }
-          onError(error, options);
-        }
-      };
+      return request.then(function(resp) {
+        return Parse._decode(null, resp).result;
+      })._thenRunCallbacks(options);
     }
-  };
+  });
 }(this));
 
 (function(root) {
@@ -7640,11 +8222,8 @@
     if (data.expiration_time && data.expiration_time_interval) {
       throw "Both expiration_time and expiration_time_interval can't be set";
     }
-    var ajaxOptions = {
-      error: options.error,
-      success: options.success
-    };
-    ajaxOptions.error = Parse.Query._wrapError(options.error, ajaxOptions);
-    Parse._request('push', null, null, 'POST', data, ajaxOptions);
+
+    var request = Parse._request('push', null, null, 'POST', data);
+    return request._thenRunCallbacks(options);
   };
 }(this));