mesos-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From "Mattmann, Chris A (388J)" <chris.a.mattm...@jpl.nasa.gov>
Subject Re: svn commit: r1449845 - in /incubator/mesos/trunk/src: ./ webui/master/static/
Date Sun, 03 Mar 2013 00:23:08 GMT
Thanks for the heads up :) Committing them on this part is still good though, and I want to applaud you both,
hence me copying mesos-dev@incubator.apache.org here.

Nothing private about praise! :)

Cheers,
Chris

From: Benjamin Mahler <bmahler@twitter.com<mailto:bmahler@twitter.com>>
Date: Saturday, March 2, 2013 3:30 PM
To: jpluser <chris.a.mattmann@jpl.nasa.gov<mailto:chris.a.mattmann@jpl.nasa.gov>>
Subject: Re: svn commit: r1449845 - in /incubator/mesos/trunk/src: ./ webui/master/static/

These are my changes, committed by vinod ;)


On Sat, Mar 2, 2013 at 3:25 PM, Mattmann, Chris A (388J) <chris.a.mattmann@jpl.nasa.gov<mailto:chris.a.mattmann@jpl.nasa.gov>> wrote:
Jeez, who says Ben Hindman is the "lead developer" of Mesos :)

You are doing a pretty good job yourself here Vinod.

BTW, I had a great talk with Ben at ApacheCon and he made this same
comment so I feel OK making it :)

Take care and keep it up!

Cheers,
Chris


On 2/25/13 11:45 AM, "vinodkone@apache.org<mailto:vinodkone@apache.org>" <vinodkone@apache.org<mailto:vinodkone@apache.org>> wrote:

>Author: vinodkone
>Date: Mon Feb 25 19:45:45 2013
>New Revision: 1449845
>
>URL: http://svn.apache.org/r1449845
>Log:
>Resource Monitoring 11: Upgraded underscore.js (to use _.object).
>
>From: Ben Mahler <benjamin.mahler@gmail.com<mailto:benjamin.mahler@gmail.com>>
>Review: https://reviews.apache.org/r/9267
>
>Added:
>    incubator/mesos/trunk/src/webui/master/static/underscore-1.4.3.js
>    incubator/mesos/trunk/src/webui/master/static/underscore-1.4.3.min.js
>Removed:
>    incubator/mesos/trunk/src/webui/master/static/underscore-1.3.3.min.js
>Modified:
>    incubator/mesos/trunk/src/Makefile.am
>    incubator/mesos/trunk/src/webui/master/static/index.html
>    incubator/mesos/trunk/src/webui/master/static/pailer.html
>
>Modified: incubator/mesos/trunk/src/Makefile.am
>URL:
>http://svn.apache.org/viewvc/incubator/mesos/trunk/src/Makefile.am?rev=144
>9845&r1=1449844&r2=1449845&view=diff
>==========================================================================
>====
>--- incubator/mesos/trunk/src/Makefile.am (original)
>+++ incubator/mesos/trunk/src/Makefile.am Mon Feb 25 19:45:45 2013
>@@ -395,7 +395,8 @@ nobase_dist_webui_DATA += webui/master/s
> nobase_dist_webui_DATA +=                                             \
>   webui/master/static/angular-1.0.0rc8.js                             \
>   webui/master/static/angular-1.0.0rc8.min.js                         \
>-  webui/master/static/underscore-1.3.3.min.js                         \
>+  webui/master/static/underscore-1.4.3.js                             \
>+  webui/master/static/underscore-1.4.3.min.js                         \
>   webui/master/static/cubism.v1.js                                    \
>   webui/master/static/cubism.v1.min.js                                        \
>   webui/master/static/d3.v2.js                                                \
>
>Modified: incubator/mesos/trunk/src/webui/master/static/index.html
>URL:
>http://svn.apache.org/viewvc/incubator/mesos/trunk/src/webui/master/static
>/index.html?rev=1449845&r1=1449844&r2=1449845&view=diff
>==========================================================================
>====
>--- incubator/mesos/trunk/src/webui/master/static/index.html (original)
>+++ incubator/mesos/trunk/src/webui/master/static/index.html Mon Feb 25
>19:45:45 2013
>@@ -89,7 +89,7 @@
>     <script src="/static/bootstrap/js/jquery-1.7.1.min.js"></script>
>     <script src="/static/bootstrap/js/bootstrap.min.js"></script>
>
>-    <script src="/static/underscore-1.3.3.min.js"></script>
>+    <script src="/static/underscore-1.4.3.min.js"></script>
>     <script src="/static/angular-1.0.0rc8.min.js"></script>
>     <script src="/static/d3.v2.min.js"></script>
>     <script src="/static/cubism.v1.min.js"></script>
>
>Modified: incubator/mesos/trunk/src/webui/master/static/pailer.html
>URL:
>http://svn.apache.org/viewvc/incubator/mesos/trunk/src/webui/master/static
>/pailer.html?rev=1449845&r1=1449844&r2=1449845&view=diff
>==========================================================================
>====
>--- incubator/mesos/trunk/src/webui/master/static/pailer.html (original)
>+++ incubator/mesos/trunk/src/webui/master/static/pailer.html Mon Feb 25
>19:45:45 2013
>@@ -28,7 +28,7 @@
>
>     <script src="/static/bootstrap/js/jquery-1.7.1.min.js"></script>
>
>-    <script src="/static/underscore-1.3.3.min.js"></script>
>+    <script src="/static/underscore-1.4.3.min.js"></script>
>
>     <script src="/static/jquery.pailer.js"></script>
>
>
>Added: incubator/mesos/trunk/src/webui/master/static/underscore-1.4.3.js
>URL:
>http://svn.apache.org/viewvc/incubator/mesos/trunk/src/webui/master/static
>/underscore-1.4.3.js?rev=1449845&view=auto
>==========================================================================
>====
>--- incubator/mesos/trunk/src/webui/master/static/underscore-1.4.3.js
>(added)
>+++ incubator/mesos/trunk/src/webui/master/static/underscore-1.4.3.js Mon
>Feb 25 19:45:45 2013
>@@ -0,0 +1,1221 @@
>+//     Underscore.js 1.4.3
>+//     http://underscorejs.org
>+//     (c) 2009-2012 Jeremy Ashkenas, DocumentCloud Inc.
>+//     Underscore may be freely distributed under the MIT license.
>+
>+(function() {
>+
>+  // Baseline setup
>+  // --------------
>+
>+  // Establish the root object, `window` in the browser, or `global` on
>the server.
>+  var root = this;
>+
>+  // Save the previous value of the `_` variable.
>+  var previousUnderscore = root._;
>+
>+  // Establish the object that gets returned to break out of a loop
>iteration.
>+  var breaker = {};
>+
>+  // Save bytes in the minified (but not gzipped) version:
>+  var ArrayProto = Array.prototype, ObjProto = Object.prototype,
>FuncProto = Function.prototype;
>+
>+  // Create quick reference variables for speed access to core
>prototypes.
>+  var push             = ArrayProto.push,
>+      slice            = ArrayProto.slice,
>+      concat           = ArrayProto.concat,
>+      toString         = ObjProto.toString,
>+      hasOwnProperty   = ObjProto.hasOwnProperty;
>+
>+  // All **ECMAScript 5** native function implementations that we hope
>to use
>+  // are declared here.
>+  var
>+    nativeForEach      = ArrayProto.forEach,
>+    nativeMap          = ArrayProto.map,
>+    nativeReduce       = ArrayProto.reduce,
>+    nativeReduceRight  = ArrayProto.reduceRight,
>+    nativeFilter       = ArrayProto.filter,
>+    nativeEvery        = ArrayProto.every,
>+    nativeSome         = ArrayProto.some,
>+    nativeIndexOf      = ArrayProto.indexOf,
>+    nativeLastIndexOf  = ArrayProto.lastIndexOf,
>+    nativeIsArray      = Array.isArray,
>+    nativeKeys         = Object.keys,
>+    nativeBind         = FuncProto.bind;
>+
>+  // Create a safe reference to the Underscore object for use below.
>+  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
>+  // the browser, add `_` as a global object via a string identifier,
>+  // for Closure Compiler "advanced" mode.
>+  if (typeof exports !== 'undefined') {
>+    if (typeof module !== 'undefined' && module.exports) {
>+      exports = module.exports = _;
>+    }
>+    exports._ = _;
>+  } else {
>+    root._ = _;
>+  }
>+
>+  // Current version.
>+  _.VERSION = '1.4.3';
>+
>+  // Collection Functions
>+  // --------------------
>+
>+  // The cornerstone, an `each` implementation, aka `forEach`.
>+  // Handles objects with the built-in `forEach`, arrays, and raw
>objects.
>+  // Delegates to **ECMAScript 5**'s native `forEach` if available.
>+  var each = _.each = _.forEach = function(obj, iterator, context) {
>+    if (obj == null) return;
>+    if (nativeForEach && obj.forEach === nativeForEach) {
>+      obj.forEach(iterator, context);
>+    } else if (obj.length === +obj.length) {
>+      for (var i = 0, l = obj.length; i < l; i++) {
>+        if (iterator.call(context, obj[i], i, obj) === breaker) return;
>+      }
>+    } else {
>+      for (var key in obj) {
>+        if (_.has(obj, key)) {
>+          if (iterator.call(context, obj[key], key, obj) === breaker)
>return;
>+        }
>+      }
>+    }
>+  };
>+
>+  // Return the results of applying the iterator to each element.
>+  // Delegates to **ECMAScript 5**'s native `map` if available.
>+  _.map = _.collect = function(obj, iterator, context) {
>+    var results = [];
>+    if (obj == null) return results;
>+    if (nativeMap && obj.map === nativeMap) return obj.map(iterator,
>context);
>+    each(obj, function(value, index, list) {
>+      results[results.length] = iterator.call(context, value, index,
>list);
>+    });
>+    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)
>{
>+    var initial = arguments.length > 2;
>+    if (obj == null) obj = [];
>+    if (nativeReduce && obj.reduce === nativeReduce) {
>+      if (context) iterator = _.bind(iterator, context);
>+      return initial ? obj.reduce(iterator, memo) : obj.reduce(iterator);
>+    }
>+    each(obj, function(value, index, list) {
>+      if (!initial) {
>+        memo = value;
>+        initial = true;
>+      } else {
>+        memo = iterator.call(context, memo, value, index, list);
>+      }
>+    });
>+    if (!initial) throw new TypeError(reduceError);
>+    return memo;
>+  };
>+
>+  // The right-associative version of reduce, also known as `foldr`.
>+  // Delegates to **ECMAScript 5**'s native `reduceRight` if available.
>+  _.reduceRight = _.foldr = function(obj, iterator, memo, context) {
>+    var initial = arguments.length > 2;
>+    if (obj == null) obj = [];
>+    if (nativeReduceRight && obj.reduceRight === nativeReduceRight) {
>+      if (context) iterator = _.bind(iterator, context);
>+      return initial ? obj.reduceRight(iterator, memo) :
>obj.reduceRight(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`.
>+  _.find = _.detect = function(obj, iterator, context) {
>+    var result;
>+    any(obj, function(value, index, list) {
>+      if (iterator.call(context, value, index, list)) {
>+        result = value;
>+        return true;
>+      }
>+    });
>+    return result;
>+  };
>+
>+  // Return all the elements that pass a truth test.
>+  // Delegates to **ECMAScript 5**'s native `filter` if available.
>+  // Aliased as `select`.
>+  _.filter = _.select = function(obj, iterator, context) {
>+    var results = [];
>+    if (obj == null) return results;
>+    if (nativeFilter && obj.filter === nativeFilter) return
>obj.filter(iterator, context);
>+    each(obj, function(value, index, list) {
>+      if (iterator.call(context, value, index, list))
>results[results.length] = value;
>+    });
>+    return results;
>+  };
>+
>+  // Return all the elements for which a truth test fails.
>+  _.reject = function(obj, iterator, context) {
>+    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);
>+    each(obj, function(value, index, list) {
>+      if (!(result = result && iterator.call(context, value, index,
>list))) return breaker;
>+    });
>+    return !!result;
>+  };
>+
>+  // Determine if at least one element in the object matches a truth
>test.
>+  // Delegates to **ECMAScript 5**'s native `some` if available.
>+  // Aliased as `any`.
>+  var any = _.some = _.any = function(obj, iterator, context) {
>+    iterator || (iterator = _.identity);
>+    var result = false;
>+    if (obj == null) return result;
>+    if (nativeSome && obj.some === nativeSome) return obj.some(iterator,
>context);
>+    each(obj, function(value, index, list) {
>+      if (result || (result = iterator.call(context, value, index,
>list))) return breaker;
>+    });
>+    return !!result;
>+  };
>+
>+  // 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;
>+    return any(obj, function(value) {
>+      return value === target;
>+    });
>+  };
>+
>+  // Invoke a method (with arguments) on every item in a collection.
>+  _.invoke = function(obj, method) {
>+    var args = slice.call(arguments, 2);
>+    return _.map(obj, function(value) {
>+      return (_.isFunction(method) ? method :
>value[method]).apply(value, args);
>+    });
>+  };
>+
>+  // Convenience version of a common use case of `map`: fetching a
>property.
>+  _.pluck = function(obj, key) {
>+    return _.map(obj, function(value){ return value[key]; });
>+  };
>+
>+  // Convenience version of a common use case of `filter`: selecting
>only objects
>+  // with specific `key:value` pairs.
>+  _.where = function(obj, attrs) {
>+    if (_.isEmpty(attrs)) return [];
>+    return _.filter(obj, function(value) {
>+      for (var key in attrs) {
>+        if (attrs[key] !== value[key]) return false;
>+      }
>+      return 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] && obj.length
>< 65535) {
>+      return Math.max.apply(Math, obj);
>+    }
>+    if (!iterator && _.isEmpty(obj)) return -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});
>+    });
>+    return result.value;
>+  };
>+
>+  // Return the minimum element (or element-based computation).
>+  _.min = function(obj, iterator, context) {
>+    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, 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});
>+    });
>+    return result.value;
>+  };
>+
>+  // Shuffle an array.
>+  _.shuffle = function(obj) {
>+    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, 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;
>+      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');
>+  };
>+
>+  // An internal function used for aggregate "group by" operations.
>+  var group = function(obj, value, context, behavior) {
>+    var result = {};
>+    var iterator = lookupIterator(value || _.identity);
>+    each(obj, function(value, index) {
>+      var key = iterator.call(context, value, index, obj);
>+      behavior(result, key, value);
>+    });
>+    return result;
>+  };
>+
>+  // 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.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 (obj.length === +obj.length) return _.map(obj, _.identity);
>+    return _.values(obj);
>+  };
>+
>+  // Return the number of elements in an object.
>+  _.size = function(obj) {
>+    if (obj == null) return 0;
>+    return (obj.length === +obj.length) ? obj.length :
>_.keys(obj).length;
>+  };
>+
>+  // Array Functions
>+  // ---------------
>+
>+  // Get the first element of an array. Passing **n** will return the
>first N
>+  // 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. 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`.
>+  _.initial = function(array, n, guard) {
>+    return slice.call(array, 0, array.length - ((n == null) || guard ? 1
>: n));
>+  };
>+
>+  // 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 {
>+      return array[array.length - 1];
>+    }
>+  };
>+
>+  // 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 = _.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, _.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 flatten(array, shallow, []);
>+  };
>+
>+  // Return a version of the array that does not contain the specified
>value(s).
>+  _.without = function(array) {
>+    return _.difference(array, slice.call(arguments, 1));
>+  };
>+
>+  // 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, context) {
>+    if (_.isFunction(isSorted)) {
>+      context = iterator;
>+      iterator = isSorted;
>+      isSorted = false;
>+    }
>+    var initial = iterator ? _.map(array, iterator, context) : array;
>+    var results = [];
>+    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 results;
>+  };
>+
>+  // Produce an array that contains the union: each distinct element
>from all of
>+  // the passed-in arrays.
>+  _.union = function() {
>+    return _.uniq(concat.apply(ArrayProto, arguments));
>+  };
>+
>+  // Produce an array that contains every item shared between all the
>+  // passed-in arrays.
>+  _.intersection = function(array) {
>+    var rest = slice.call(arguments, 1);
>+    return _.filter(_.uniq(array), function(item) {
>+      return _.every(rest, function(other) {
>+        return _.indexOf(other, item) >= 0;
>+      });
>+    });
>+  };
>+
>+  // 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 = 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
>+  // an index go together.
>+  _.zip = function() {
>+    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);
>+    }
>+    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.
>+  // Delegates to **ECMAScript 5**'s native `indexOf` if available.
>+  // If the array is large and already in sort order, pass `true`
>+  // for **isSorted** to use binary search.
>+  _.indexOf = function(array, item, isSorted) {
>+    if (array == null) return -1;
>+    var i = 0, l = array.length;
>+    if (isSorted) {
>+      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, 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, from) {
>+    if (array == null) return -1;
>+    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;
>+  };
>+
>+  // Generate an integer Array containing an arithmetic progression. A
>port of
>+  // the native Python `range()` function. See
>+  // [the Python
>documentation](http://docs.python.org/library/functions.html#range).
>+  _.range = function(start, stop, step) {
>+    if (arguments.length <= 1) {
>+      stop = start || 0;
>+      start = 0;
>+    }
>+    step = arguments[2] || 1;
>+
>+    var len = Math.max(Math.ceil((stop - start) / step), 0);
>+    var idx = 0;
>+    var range = new Array(len);
>+
>+    while(idx < len) {
>+      range[idx++] = start;
>+      start += step;
>+    }
>+
>+    return range;
>+  };
>+
>+  // 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(func, context) {
>+    var args, bound;
>+    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;
>+      ctor.prototype = null;
>+      var result = func.apply(self, args.concat(slice.call(arguments)));
>+      if (Object(result) === result) return result;
>+      return self;
>+    };
>+  };
>+
>+  // Bind all of an object's methods to that object. Useful for ensuring
>that
>+  // 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);
>+    each(funcs, function(f) { obj[f] = _.bind(obj[f], obj); });
>+    return obj;
>+  };
>+
>+  // Memoize an expensive function by storing its results.
>+  _.memoize = function(func, hasher) {
>+    var memo = {};
>+    hasher || (hasher = _.identity);
>+    return function() {
>+      var key = hasher.apply(this, arguments);
>+      return _.has(memo, key) ? memo[key] : (memo[key] =
>func.apply(this, arguments));
>+    };
>+  };
>+
>+  // Delays a function for the given number of milliseconds, and then
>calls
>+  // it with the arguments supplied.
>+  _.delay = function(func, wait) {
>+    var args = slice.call(arguments, 2);
>+    return setTimeout(function(){ return func.apply(null, args); },
>wait);
>+  };
>+
>+  // Defers a function, scheduling it to run after the current call
>stack has
>+  // cleared.
>+  _.defer = function(func) {
>+    return _.delay.apply(_, [func, 1].concat(slice.call(arguments, 1)));
>+  };
>+
>+  // 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, result;
>+    var previous = 0;
>+    var later = function() {
>+      previous = new Date;
>+      timeout = null;
>+      result = func.apply(context, args);
>+    };
>+    return function() {
>+      var now = new Date;
>+      var remaining = wait - (now - previous);
>+      context = this;
>+      args = arguments;
>+      if (remaining <= 0) {
>+        clearTimeout(timeout);
>+        timeout = null;
>+        previous = now;
>+        result = func.apply(context, args);
>+      } else if (!timeout) {
>+        timeout = setTimeout(later, remaining);
>+      }
>+      return result;
>+    };
>+  };
>+
>+  // Returns a function, that, as long as it continues to be invoked,
>will not
>+  // be triggered. The function will be called after it stops being
>called for
>+  // N milliseconds. If `immediate` is passed, trigger the function on
>the
>+  // leading edge, instead of the trailing.
>+  _.debounce = function(func, wait, immediate) {
>+    var timeout, result;
>+    return function() {
>+      var context = this, args = arguments;
>+      var later = function() {
>+        timeout = null;
>+        if (!immediate) result = func.apply(context, args);
>+      };
>+      var callNow = immediate && !timeout;
>+      clearTimeout(timeout);
>+      timeout = setTimeout(later, wait);
>+      if (callNow) result = func.apply(context, args);
>+      return result;
>+    };
>+  };
>+
>+  // Returns a function that will be executed at most one time, no
>matter how
>+  // often you call it. Useful for lazy initialization.
>+  _.once = function(func) {
>+    var ran = false, memo;
>+    return function() {
>+      if (ran) return memo;
>+      ran = true;
>+      memo = func.apply(this, arguments);
>+      func = null;
>+      return memo;
>+    };
>+  };
>+
>+  // Returns the first function passed as an argument to the second,
>+  // allowing you to adjust arguments, run code before and after, and
>+  // conditionally execute the original function.
>+  _.wrap = function(func, wrapper) {
>+    return function() {
>+      var args = [func];
>+      push.apply(args, arguments);
>+      return wrapper.apply(this, args);
>+    };
>+  };
>+
>+  // Returns a function that is the composition of a list of functions,
>each
>+  // consuming the return value of the function that follows.
>+  _.compose = function() {
>+    var funcs = arguments;
>+    return function() {
>+      var args = arguments;
>+      for (var i = funcs.length - 1; i >= 0; i--) {
>+        args = [funcs[i].apply(this, args)];
>+      }
>+      return args[0];
>+    };
>+  };
>+
>+  // Returns a function that will only be executed after being called N
>times.
>+  _.after = function(times, func) {
>+    if (times <= 0) return func();
>+    return function() {
>+      if (--times < 1) {
>+        return func.apply(this, arguments);
>+      }
>+    };
>+  };
>+
>+  // Object Functions
>+  // ----------------
>+
>+  // Retrieve the names of an object's properties.
>+  // Delegates to **ECMAScript 5**'s native `Object.keys`
>+  _.keys = nativeKeys || function(obj) {
>+    if (obj !== Object(obj)) throw new TypeError('Invalid object');
>+    var keys = [];
>+    for (var key in obj) if (_.has(obj, key)) keys[keys.length] = key;
>+    return keys;
>+  };
>+
>+  // Retrieve the values of an object's properties.
>+  _.values = function(obj) {
>+    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.
>+  // Aliased as `methods`
>+  _.functions = _.methods = function(obj) {
>+    var names = [];
>+    for (var key in obj) {
>+      if (_.isFunction(obj[key])) names.push(key);
>+    }
>+    return names.sort();
>+  };
>+
>+  // Extend a given object with all the properties in passed-in
>object(s).
>+  _.extend = function(obj) {
>+    each(slice.call(arguments, 1), function(source) {
>+      if (source) {
>+        for (var prop in source) {
>+          obj[prop] = source[prop];
>+        }
>+      }
>+    });
>+    return obj;
>+  };
>+
>+  // Return a copy of the object only containing the whitelisted
>properties.
>+  _.pick = function(obj) {
>+    var copy = {};
>+    var keys = concat.apply(ArrayProto, slice.call(arguments, 1));
>+    each(keys, function(key) {
>+      if (key in obj) copy[key] = obj[key];
>+    });
>+    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) {
>+      if (source) {
>+        for (var prop in source) {
>+          if (obj[prop] == null) obj[prop] = source[prop];
>+        }
>+      }
>+    });
>+    return obj;
>+  };
>+
>+  // Create a (shallow-cloned) duplicate of an object.
>+  _.clone = function(obj) {
>+    if (!_.isObject(obj)) return obj;
>+    return _.isArray(obj) ? obj.slice() : _.extend({}, obj);
>+  };
>+
>+  // Invokes interceptor with the obj, and then returns obj.
>+  // The primary purpose of this method is to "tap into" a method chain,
>in
>+  // order to perform operations on intermediate results within the
>chain.
>+  _.tap = function(obj, interceptor) {
>+    interceptor(obj);
>+    return obj;
>+  };
>+
>+  // 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 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;
>+    switch (className) {
>+      // Strings, numbers, dates, and booleans are compared by value.
>+      case '[object String]':
>+        // Primitives and their corresponding object wrappers are
>equivalent; thus, `"5"` is
>+        // equivalent to `new String("5")`.
>+        return a == String(b);
>+      case '[object Number]':
>+        // `NaN`s are equivalent, but non-reflexive. An `egal`
>comparison is performed for
>+        // other numeric values.
>+        return a != +a ? b != +b : (a == 0 ? 1 / a == 1 / b : a == +b);
>+      case '[object Date]':
>+      case '[object Boolean]':
>+        // Coerce dates and booleans to numeric primitive values. Dates
>are compared by their
>+        // millisecond representations. Note that invalid dates with
>millisecond representations
>+        // of `NaN` are not equivalent.
>+        return +a == +b;
>+      // RegExps are compared by their source patterns and flags.
>+      case '[object RegExp]':
>+        return a.source == b.source &&
>+               a.global == b.global &&
>+               a.multiline == b.multiline &&
>+               a.ignoreCase == b.ignoreCase;
>+    }
>+    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 = aStack.length;
>+    while (length--) {
>+      // Linear search. Performance is inversely proportional to the
>number of
>+      // unique nested structures.
>+      if (aStack[length] == a) return bStack[length] == b;
>+    }
>+    // Add the first object to the stack of traversed objects.
>+    aStack.push(a);
>+    bStack.push(b);
>+    var size = 0, result = true;
>+    // Recursively compare objects and arrays.
>+    if (className == '[object Array]') {
>+      // Compare array lengths to determine if a deep comparison is
>necessary.
>+      size = a.length;
>+      result = size == b.length;
>+      if (result) {
>+        // Deep compare the contents, ignoring non-numeric properties.
>+        while (size--) {
>+          if (!(result = eq(a[size], b[size], aStack, bStack))) break;
>+        }
>+      }
>+    } else {
>+      // 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], aStack,
>bStack))) break;
>+        }
>+      }
>+      // Ensure that both objects contain the same number of properties.
>+      if (result) {
>+        for (key in b) {
>+          if (_.has(b, key) && !(size--)) break;
>+        }
>+        result = !size;
>+      }
>+    }
>+    // Remove the first object from the stack of traversed objects.
>+    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, [], []);
>+  };
>+
>+  // Is a given array, string, or object empty?
>+  // An "empty" object has no enumerable own-properties.
>+  _.isEmpty = function(obj) {
>+    if (obj == null) return true;
>+    if (_.isArray(obj) || _.isString(obj)) return obj.length === 0;
>+    for (var key in obj) if (_.has(obj, key)) return false;
>+    return true;
>+  };
>+
>+  // Is a given value a DOM element?
>+  _.isElement = function(obj) {
>+    return !!(obj && obj.nodeType === 1);
>+  };
>+
>+  // Is a given value an array?
>+  // Delegates to ECMA5's native Array.isArray
>+  _.isArray = nativeIsArray || function(obj) {
>+    return toString.call(obj) == '[object Array]';
>+  };
>+
>+  // Is a given variable an object?
>+  _.isObject = function(obj) {
>+    return obj === Object(obj);
>+  };
>+
>+  // 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'));
>+    };
>+  }
>+
>+  // 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 isFinite(obj) && !isNaN(parseFloat(obj));
>+  };
>+
>+  // Is the given value `NaN`? (NaN is the only number which does not
>equal itself).
>+  _.isNaN = function(obj) {
>+    return _.isNumber(obj) && obj != +obj;
>+  };
>+
>+  // Is a given value a boolean?
>+  _.isBoolean = function(obj) {
>+    return obj === true || obj === false || toString.call(obj) ==
>'[object Boolean]';
>+  };
>+
>+  // Is a given value equal to null?
>+  _.isNull = function(obj) {
>+    return obj === null;
>+  };
>+
>+  // Is a given variable undefined?
>+  _.isUndefined = function(obj) {
>+    return obj === void 0;
>+  };
>+
>+  // 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);
>+  };
>+
>+  // Utility Functions
>+  // -----------------
>+
>+  // Run Underscore.js in *noConflict* mode, returning the `_` variable
>to its
>+  // previous owner. Returns a reference to the Underscore object.
>+  _.noConflict = function() {
>+    root._ = previousUnderscore;
>+    return this;
>+  };
>+
>+  // Keep the identity function around for default iterators.
>+  _.identity = function(value) {
>+    return value;
>+  };
>+
>+  // Run a function **n** times.
>+  _.times = function(n, iterator, context) {
>+    var accum = Array(n);
>+    for (var i = 0; i < n; i++) accum[i] = iterator.call(context, i);
>+    return accum;
>+  };
>+
>+  // Return a random integer between min and max (inclusive).
>+  _.random = function(min, max) {
>+    if (max == null) {
>+      max = min;
>+      min = 0;
>+    }
>+    return min + (0 | 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) {
>+    if (object == null) return null;
>+    var value = object[property];
>+    return _.isFunction(value) ? value.call(object) : value;
>+  };
>+
>+  // Add your own custom functions to the Underscore object.
>+  _.mixin = function(obj) {
>+    each(_.functions(obj), function(name){
>+      var func = _[name] = obj[name];
>+      _.prototype[name] = function() {
>+        var args = [this._wrapped];
>+        push.apply(args, arguments);
>+        return result.call(this, func.apply(_, args));
>+      };
>+    });
>+  };
>+
>+  // Generate a unique integer id (unique within the entire client
>session).
>+  // Useful for temporary DOM ids.
>+  var idCounter = 0;
>+  _.uniqueId = function(prefix) {
>+    var id = '' + ++idCounter;
>+    return prefix ? prefix + id : id;
>+  };
>+
>+  // By default, Underscore uses ERB-style template delimiters, change
>the
>+  // following template settings to use alternative delimiters.
>+  _.templateSettings = {
>+    evaluate    : /<%([\s\S]+?)%>/g,
>+    interpolate : /<%=([\s\S]+?)%>/g,
>+    escape      : /<%-([\s\S]+?)%>/g
>+  };
>+
>+  // 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 = /(.)^/;
>+
>+  // 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'
>+  };
>+
>+  var escaper = /\\|'|\r|\n|\t|\u2028|\u2029/g;
>+
>+  // 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);
>+
>+    // 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 __t,__p='',__j=Array.prototype.join," +
>+      "print=function(){__p+=__j.call(arguments,'');};\n" +
>+      source + "return __p;\n";
>+
>+    try {
>+      var 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
>precompilation.
>+    template.source = 'function(' + (settings.variable || 'obj') +
>'){\n' + source + '}';
>+
>+    return template;
>+  };
>+
>+  // Add a "chain" function, which will delegate to the wrapper.
>+  _.chain = function(obj) {
>+    return _(obj).chain();
>+  };
>+
>+  // 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.
>+
>+  // Helper function to continue chaining intermediate results.
>+  var result = function(obj) {
>+    return this._chain ? _(obj).chain() : obj;
>+  };
>+
>+  // Add all of the Underscore functions to the wrapper object.
>+  _.mixin(_);
>+
>+  // Add all mutator Array functions to the wrapper.
>+  each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'],
>function(name) {
>+    var method = ArrayProto[name];
>+    _.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];
>+    _.prototype[name] = function() {
>+      return result.call(this, method.apply(this._wrapped, arguments));
>+    };
>+  });
>+
>+  _.extend(_.prototype, {
>+
>+    // 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);
>
>Added:
>incubator/mesos/trunk/src/webui/master/static/underscore-1.4.3.min.js
>URL:
>http://svn.apache.org/viewvc/incubator/mesos/trunk/src/webui/master/static
>/underscore-1.4.3.min.js?rev=1449845&view=auto
>==========================================================================
>====
>--- incubator/mesos/trunk/src/webui/master/static/underscore-1.4.3.min.js
>(added)
>+++ incubator/mesos/trunk/src/webui/master/static/underscore-1.4.3.min.js
>Mon Feb 25 19:45:45 2013
>@@ -0,0 +1 @@
>+(function(){var
>n=this,t=n._,r={},e=Array.prototype,u=Object.prototype,i=Function.prototyp
>e,a=e.push,o=e.slice,c=e.concat,l=u.toString,f=u.hasOwnProperty,s=e.forEac
>h,p=e.map,v=e.reduce,h=e.reduceRight,g=e.filter,d=e.every,m=e.some,y=e.ind
>exOf,b=e.lastIndexOf,x=Array.isArray,_=Object.keys,j=i.bind,w=function(n){
>return n instanceof w?n:this instanceof w?(this._wrapped=n,void 0):new
>w(n)};"undefined"!=typeof exports?("undefined"!=typeof
>module&&module.exports&&(exports=module.exports=w),exports._=w):n._=w,w.VE
>RSION="1.4.3";var
>A=w.each=w.forEach=function(n,t,e){if(null!=n)if(s&&n.forEach===s)n.forEac
>h(t,e);else if(n.length===+n.length){for(var
>u=0,i=n.length;i>u;u++)if(t.call(e,n[u],u,n)===r)return}else for(var a in
>n)if(w.has(n,a)&&t.call(e,n[a],a,n)===r)return};w.map=w.collect=function(n
>,t,r){var e=[];return
>null==n?e:p&&n.map===p?n.map(t,r):(A(n,function(n,u,i){e[e.length]=t.call(
>r,n,u,i)}),e)};var O="Reduce of empty array with no initial
>value";w.reduce=w.foldl=w.inject=fun
> ction(n,t,r,e){var
>u=arguments.length>2;if(null==n&&(n=[]),v&&n.reduce===v)return
>e&&(t=w.bind(t,e)),u?n.reduce(t,r):n.reduce(t);if(A(n,function(n,i,a){u?r=
>t.call(e,r,n,i,a):(r=n,u=!0)}),!u)throw new TypeError(O);return
>r},w.reduceRight=w.foldr=function(n,t,r,e){var
>u=arguments.length>2;if(null==n&&(n=[]),h&&n.reduceRight===h)return
>e&&(t=w.bind(t,e)),u?n.reduceRight(t,r):n.reduceRight(t);var
>i=n.length;if(i!==+i){var
>a=w.keys(n);i=a.length}if(A(n,function(o,c,l){c=a?a[--i]:--i,u?r=t.call(e,
>r,n[c],c,l):(r=n[c],u=!0)}),!u)throw new TypeError(O);return
>r},w.find=w.detect=function(n,t,r){var e;return
>E(n,function(n,u,i){return t.call(r,n,u,i)?(e=n,!0):void
>0}),e},w.filter=w.select=function(n,t,r){var e=[];return
>null==n?e:g&&n.filter===g?n.filter(t,r):(A(n,function(n,u,i){t.call(r,n,u,
>i)&&(e[e.length]=n)}),e)},w.reject=function(n,t,r){return
>w.filter(n,function(n,e,u){return!t.call(r,n,e,u)},r)},w.every=w.all=funct
>ion(n,t,e){t||(t=w.identity);var u=!0;return null==n?u:d&&n.ever
>
>y===d?n.every(t,e):(A(n,function(n,i,a){return(u=u&&t.call(e,n,i,a))?void
>0:r}),!!u)};var E=w.some=w.any=function(n,t,e){t||(t=w.identity);var
>u=!1;return
>null==n?u:m&&n.some===m?n.some(t,e):(A(n,function(n,i,a){return
>u||(u=t.call(e,n,i,a))?r:void
>0}),!!u)};w.contains=w.include=function(n,t){return
>null==n?!1:y&&n.indexOf===y?-1!=n.indexOf(t):E(n,function(n){return
>n===t})},w.invoke=function(n,t){var r=o.call(arguments,2);return
>w.map(n,function(n){return(w.isFunction(t)?t:n[t]).apply(n,r)})},w.pluck=f
>unction(n,t){return w.map(n,function(n){return
>n[t]})},w.where=function(n,t){return
>w.isEmpty(t)?[]:w.filter(n,function(n){for(var r in
>t)if(t[r]!==n[r])return!1;return!0})},w.max=function(n,t,r){if(!t&&w.isArr
>ay(n)&&n[0]===+n[0]&&65535>n.length)return
>Math.max.apply(Math,n);if(!t&&w.isEmpty(n))return-1/0;var
>e={computed:-1/0,value:-1/0};return A(n,function(n,u,i){var
>a=t?t.call(r,n,u,i):n;a>=e.computed&&(e={value:n,computed:a})}),e.value},w
>.min=function(n,t,r){if(!t&&w.isArra
> y(n)&&n[0]===+n[0]&&65535>n.length)return
>Math.min.apply(Math,n);if(!t&&w.isEmpty(n))return 1/0;var
>e={computed:1/0,value:1/0};return A(n,function(n,u,i){var
>a=t?t.call(r,n,u,i):n;e.computed>a&&(e={value:n,computed:a})}),e.value},w.
>shuffle=function(n){var t,r=0,e=[];return
>A(n,function(n){t=w.random(r++),e[r-1]=e[t],e[t]=n}),e};var
>F=function(n){return w.isFunction(n)?n:function(t){return
>t[n]}};w.sortBy=function(n,t,r){var e=F(t);return
>w.pluck(w.map(n,function(n,t,u){return{value:n,index:t,criteria:e.call(r,n
>,t,u)}}).sort(function(n,t){var
>r=n.criteria,e=t.criteria;if(r!==e){if(r>e||void 0===r)return
>1;if(e>r||void 0===e)return-1}return n.index<t.index?-1:1}),"value")};var
>k=function(n,t,r,e){var u={},i=F(t||w.identity);return
>A(n,function(t,a){var
>o=i.call(r,t,a,n);e(u,o,t)}),u};w.groupBy=function(n,t,r){return
>k(n,t,r,function(n,t,r){(w.has(n,t)?n[t]:n[t]=[]).push(r)})},w.countBy=fun
>ction(n,t,r){return
>k(n,t,r,function(n,t){w.has(n,t)||(n[t]=0),n[t]++})},w.sortedIndex=fu
> nction(n,t,r,e){r=null==r?w.identity:F(r);for(var
>u=r.call(e,t),i=0,a=n.length;a>i;){var
>o=i+a>>>1;u>r.call(e,n[o])?i=o+1:a=o}return
>i},w.toArray=function(n){return
>n?w.isArray(n)?o.call(n):n.length===+n.length?w.map(n,w.identity):w.values
>(n):[]},w.size=function(n){return
>null==n?0:n.length===+n.length?n.length:w.keys(n).length},w.first=w.head=w
>.take=function(n,t,r){return null==n?void
>0:null==t||r?n[0]:o.call(n,0,t)},w.initial=function(n,t,r){return
>o.call(n,0,n.length-(null==t||r?1:t))},w.last=function(n,t,r){return
>null==n?void
>0:null==t||r?n[n.length-1]:o.call(n,Math.max(n.length-t,0))},w.rest=w.tail
>=w.drop=function(n,t,r){return
>o.call(n,null==t||r?1:t)},w.compact=function(n){return
>w.filter(n,w.identity)};var R=function(n,t,r){return
>A(n,function(n){w.isArray(n)?t?a.apply(r,n):R(n,t,r):r.push(n)}),r};w.flat
>ten=function(n,t){return R(n,t,[])},w.without=function(n){return
>w.difference(n,o.call(arguments,1))},w.uniq=w.unique=function(n,t,r,e){w.i
>sFunction(t)&&(e=r,r=t,t=!
> 1);var u=r?w.map(n,r,e):n,i=[],a=[];return
>A(u,function(r,e){(t?e&&a[a.length-1]===r:w.contains(a,r))||(a.push(r),i.p
>ush(n[e]))}),i},w.union=function(){return
>w.uniq(c.apply(e,arguments))},w.intersection=function(n){var
>t=o.call(arguments,1);return w.filter(w.uniq(n),function(n){return
>w.every(t,function(t){return
>w.indexOf(t,n)>=0})})},w.difference=function(n){var
>t=c.apply(e,o.call(arguments,1));return
>w.filter(n,function(n){return!w.contains(t,n)})},w.zip=function(){for(var
>n=o.call(arguments),t=w.max(w.pluck(n,"length")),r=Array(t),e=0;t>e;e++)r[
>e]=w.pluck(n,""+e);return
>r},w.object=function(n,t){if(null==n)return{};for(var
>r={},e=0,u=n.length;u>e;e++)t?r[n[e]]=t[e]:r[n[e][0]]=n[e][1];return
>r},w.indexOf=function(n,t,r){if(null==n)return-1;var
>e=0,u=n.length;if(r){if("number"!=typeof r)return
>e=w.sortedIndex(n,t),n[e]===t?e:-1;e=0>r?Math.max(0,u+r):r}if(y&&n.indexOf
>===y)return n.indexOf(t,r);for(;u>e;e++)if(n[e]===t)return
>e;return-1},w.lastIndexOf=function(n,t,r){if(nul
> l==n)return-1;var e=null!=r;if(b&&n.lastIndexOf===b)return
>e?n.lastIndexOf(t,r):n.lastIndexOf(t);for(var
>u=e?r:n.length;u--;)if(n[u]===t)return
>u;return-1},w.range=function(n,t,r){1>=arguments.length&&(t=n||0,n=0),r=ar
>guments[2]||1;for(var
>e=Math.max(Math.ceil((t-n)/r),0),u=0,i=Array(e);e>u;)i[u++]=n,n+=r;return
>i};var I=function(){};w.bind=function(n,t){var
>r,e;if(n.bind===j&&j)return
>j.apply(n,o.call(arguments,1));if(!w.isFunction(n))throw new
>TypeError;return r=o.call(arguments,2),e=function(){if(!(this instanceof
>e))return
>n.apply(t,r.concat(o.call(arguments)));I.prototype=n.prototype;var u=new
>I;I.prototype=null;var i=n.apply(u,r.concat(o.call(arguments)));return
>Object(i)===i?i:u}},w.bindAll=function(n){var
>t=o.call(arguments,1);return
>0==t.length&&(t=w.functions(n)),A(t,function(t){n[t]=w.bind(n[t],n)}),n},w
>.memoize=function(n,t){var r={};return t||(t=w.identity),function(){var
>e=t.apply(this,arguments);return
>w.has(r,e)?r[e]:r[e]=n.apply(this,arguments)}},w.delay=fun
> ction(n,t){var r=o.call(arguments,2);return setTimeout(function(){return
>n.apply(null,r)},t)},w.defer=function(n){return
>w.delay.apply(w,[n,1].concat(o.call(arguments,1)))},w.throttle=function(n,
>t){var r,e,u,i,a=0,o=function(){a=new Date,u=null,i=n.apply(r,e)};return
>function(){var c=new Date,l=t-(c-a);return
>r=this,e=arguments,0>=l?(clearTimeout(u),u=null,a=c,i=n.apply(r,e)):u||(u=
>setTimeout(o,l)),i}},w.debounce=function(n,t,r){var e,u;return
>function(){var
>i=this,a=arguments,o=function(){e=null,r||(u=n.apply(i,a))},c=r&&!e;return
>
>clearTimeout(e),e=setTimeout(o,t),c&&(u=n.apply(i,a)),u}},w.once=function(
>n){var t,r=!1;return function(){return
>r?t:(r=!0,t=n.apply(this,arguments),n=null,t)}},w.wrap=function(n,t){retur
>n function(){var r=[n];return
>a.apply(r,arguments),t.apply(this,r)}},w.compose=function(){var
>n=arguments;return function(){for(var
>t=arguments,r=n.length-1;r>=0;r--)t=[n[r].apply(this,t)];return
>t[0]}},w.after=function(n,t){return 0>=n?t():function(){return 1>--n
> ?t.apply(this,arguments):void
>0}},w.keys=_||function(n){if(n!==Object(n))throw new TypeError("Invalid
>object");var t=[];for(var r in n)w.has(n,r)&&(t[t.length]=r);return
>t},w.values=function(n){var t=[];for(var r in
>n)w.has(n,r)&&t.push(n[r]);return t},w.pairs=function(n){var t=[];for(var
>r in n)w.has(n,r)&&t.push([r,n[r]]);return t},w.invert=function(n){var
>t={};for(var r in n)w.has(n,r)&&(t[n[r]]=r);return
>t},w.functions=w.methods=function(n){var t=[];for(var r in
>n)w.isFunction(n[r])&&t.push(r);return
>t.sort()},w.extend=function(n){return
>A(o.call(arguments,1),function(t){if(t)for(var r in
>t)n[r]=t[r]}),n},w.pick=function(n){var
>t={},r=c.apply(e,o.call(arguments,1));return A(r,function(r){r in
>n&&(t[r]=n[r])}),t},w.omit=function(n){var
>t={},r=c.apply(e,o.call(arguments,1));for(var u in
>n)w.contains(r,u)||(t[u]=n[u]);return t},w.defaults=function(n){return
>A(o.call(arguments,1),function(t){if(t)for(var r in
>t)null==n[r]&&(n[r]=t[r])}),n},w.clone=function(n){return w.isObje
>
>ct(n)?w.isArray(n)?n.slice():w.extend({},n):n},w.tap=function(n,t){return
>t(n),n};var S=function(n,t,r,e){if(n===t)return
>0!==n||1/n==1/t;if(null==n||null==t)return n===t;n instanceof
>w&&(n=n._wrapped),t instanceof w&&(t=t._wrapped);var
>u=l.call(n);if(u!=l.call(t))return!1;switch(u){case"[object
>String]":return n==t+"";case"[object Number]":return
>n!=+n?t!=+t:0==n?1/n==1/t:n==+t;case"[object Date]":case"[object
>Boolean]":return+n==+t;case"[object RegExp]":return
>n.source==t.source&&n.global==t.global&&n.multiline==t.multiline&&n.ignore
>Case==t.ignoreCase}if("object"!=typeof n||"object"!=typeof
>t)return!1;for(var i=r.length;i--;)if(r[i]==n)return
>e[i]==t;r.push(n),e.push(t);var a=0,o=!0;if("[object
>Array]"==u){if(a=n.length,o=a==t.length)for(;a--&&(o=S(n[a],t[a],r,e)););}
>else{var c=n.constructor,f=t.constructor;if(c!==f&&!(w.isFunction(c)&&c
>instanceof c&&w.isFunction(f)&&f instanceof f))return!1;for(var s in
>n)if(w.has(n,s)&&(a++,!(o=w.has(t,s)&&S(n[s],t[s],r,e))))break;if(o)
> {for(s in t)if(w.has(t,s)&&!a--)break;o=!a}}return
>r.pop(),e.pop(),o};w.isEqual=function(n,t){return
>S(n,t,[],[])},w.isEmpty=function(n){if(null==n)return!0;if(w.isArray(n)||w
>.isString(n))return 0===n.length;for(var t in
>n)if(w.has(n,t))return!1;return!0},w.isElement=function(n){return!(!n||1!=
>=n.nodeType)},w.isArray=x||function(n){return"[object
>Array]"==l.call(n)},w.isObject=function(n){return
>n===Object(n)},A(["Arguments","Function","String","Number","Date","RegExp"
>],function(n){w["is"+n]=function(t){return l.call(t)=="[object
>"+n+"]"}}),w.isArguments(arguments)||(w.isArguments=function(n){return!(!n
>||!w.has(n,"callee"))}),w.isFunction=function(n){return"function"==typeof
>n},w.isFinite=function(n){return
>isFinite(n)&&!isNaN(parseFloat(n))},w.isNaN=function(n){return
>w.isNumber(n)&&n!=+n},w.isBoolean=function(n){return
>n===!0||n===!1||"[object
>Boolean]"==l.call(n)},w.isNull=function(n){return
>null===n},w.isUndefined=function(n){return void
>0===n},w.has=function(n,t){return
>  f.call(n,t)},w.noConflict=function(){return
>n._=t,this},w.identity=function(n){return
>n},w.times=function(n,t,r){for(var
>e=Array(n),u=0;n>u;u++)e[u]=t.call(r,u);return
>e},w.random=function(n,t){return
>null==t&&(t=n,n=0),n+(0|Math.random()*(t-n+1))};var
>T={escape:{"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#x27;","/"
>:"&#x2F;"}};T.unescape=w.invert(T.escape);var
>M={escape:RegExp("["+w.keys(T.escape).join("")+"]","g"),unescape:RegExp("(
>"+w.keys(T.unescape).join("|")+")","g")};w.each(["escape","unescape"],func
>tion(n){w[n]=function(t){return
>null==t?"":(""+t).replace(M[n],function(t){return
>T[n][t]})}}),w.result=function(n,t){if(null==n)return null;var
>r=n[t];return
>w.isFunction(r)?r.call(n):r},w.mixin=function(n){A(w.functions(n),function
>(t){var r=w[t]=n[t];w.prototype[t]=function(){var
>n=[this._wrapped];return
>a.apply(n,arguments),z.call(this,r.apply(w,n))}})};var
>N=0;w.uniqueId=function(n){var t=""+ ++N;return
>n?n+t:t},w.templateSettings={evaluate:/<%([\s\S]+?)%>/g,
> interpolate:/<%=([\s\S]+?)%>/g,escape:/<%-([\s\S]+?)%>/g};var
>q=/(.)^/,B={"'":"'","\\":"\\","\r":"r","\n":"n","      ":"t","\u2028":"u2028","
>\u2029":"u2029"},D=/\\|'|\r|\n|\t|\u2028|\u2029/g;w.template=function(n,t,
>r){r=w.defaults({},r,w.templateSettings);var
>e=RegExp([(r.escape||q).source,(r.interpolate||q).source,(r.evaluate||q).s
>ource].join("|")+"|$","g"),u=0,i="__p+='";n.replace(e,function(t,r,e,a,o){
>return
>i+=n.slice(u,o).replace(D,function(n){return"\\"+B[n]}),r&&(i+="'+\n((__t=
>("+r+"))==null?'':_.escape(__t))+\n'"),e&&(i+="'+\n((__t=("+e+"))==null?''
>:__t)+\n'"),a&&(i+="';\n"+a+"\n__p+='"),u=o+t.length,t}),i+="';\n",r.varia
>ble||(i="with(obj||{}){\n"+i+"}\n"),i="var
>__t,__p='',__j=Array.prototype.join,print=function(){__p+=__j.call(argumen
>ts,'');};\n"+i+"return __p;\n";try{var
>a=Function(r.variable||"obj","_",i)}catch(o){throw
>o.source=i,o}if(t)return a(t,w);var c=function(n){return
>a.call(this,n,w)};return
>c.source="function("+(r.variable||"obj")+"){\n"+i+"}",c},w.chain=fun
> ction(n){return w(n).chain()};var z=function(n){return
>this._chain?w(n).chain():n};w.mixin(w),A(["pop","push","reverse","shift","
>sort","splice","unshift"],function(n){var
>t=e[n];w.prototype[n]=function(){var r=this._wrapped;return
>t.apply(r,arguments),"shift"!=n&&"splice"!=n||0!==r.length||delete
>r[0],z.call(this,r)}}),A(["concat","join","slice"],function(n){var
>t=e[n];w.prototype[n]=function(){return
>z.call(this,t.apply(this._wrapped,arguments))}}),w.extend(w.prototype,{cha
>in:function(){return this._chain=!0,this},value:function(){return
>this._wrapped}})}).call(this);
>\ No newline at end of file
>
>



Mime
  • Unnamed multipart/alternative (inline, None, 0 bytes)
View raw message