underscore-source 0.1.1 → 0.2.0

data/lib/underscore-source/version.rb

@@ -1,5 +1,5 @@
 module Underscore
   module Source
-    VERSION = "0.1.1"
+    VERSION = "0.2.0"
   end
 end

data/vendor/assets/javascripts/underscore.js

@@ -5,17 +5,22 @@
 // Oliver Steele's Functional, And John Resig's Micro-Templating.
 // For all details and documentation:
 // http://documentcloud.github.com/underscore/
-window.Underscore = {
+
+(function() {
+  
+  var root = (typeof window != 'undefined') ? window : exports;
   
-  VERSION : '0.1.1',
+  var previousUnderscore = root._;
   
-  PREVIOUS_UNDERSCORE : window._,
+  var _ = root._ = {};
   
+  _.VERSION = '0.2.0';
+      
   /*------------------------ Collection Functions: ---------------------------*/
     
   // The cornerstone, an each implementation.
   // Handles objects implementing forEach, each, arrays, and raw objects.
-  each : function(obj, iterator, context) {
+  _.each = function(obj, iterator, context) {
     var index = 0;
     try {
       if (obj.forEach) {
@@ -37,30 +42,30 @@ window.Underscore = {
       if (e != '__break__') throw e;
     }
     return obj;
-  },
+  };
   
   // Return the results of applying the iterator to each element. Use Javascript
   // 1.6's version of map, if possible.
-  map : function(obj, iterator, context) {
+  _.map = function(obj, iterator, context) {
     if (obj && obj.map) return obj.map(iterator, context);
     var results = [];
     _.each(obj, function(value, index) {
       results.push(iterator.call(context, value, index));
     });
     return results;
-  },
+  };
   
-  // Inject builds up a single result from a list of values. Also known as
-  // reduce, or foldl.
-  inject : function(obj, memo, iterator, context) {
+  // Reduce builds up a single result from a list of values. Also known as
+  // inject, or foldl.
+  _.reduce = function(obj, memo, iterator, context) {
     _.each(obj, function(value, index) {
       memo = iterator.call(context, memo, value, index);
     });
     return memo;
-  },
+  };
   
   // Return the first value which passes a truth test.
-  detect : function(obj, iterator, context) {
+  _.detect = function(obj, iterator, context) {
     var result;
     _.each(obj, function(value, index) {
       if (iterator.call(context, value, index)) {
@@ -69,31 +74,31 @@ window.Underscore = {
       }
     });
     return result;
-  },
+  };
   
   // Return all the elements that pass a truth test. Use Javascript 1.6's
   // filter(), if it exists.
-  select : function(obj, iterator, context) {
+  _.select = function(obj, iterator, context) {
     if (obj.filter) return obj.filter(iterator, context);
     var results = [];
     _.each(obj, function(value, index) {
       if (iterator.call(context, value, index)) results.push(value);
     });
     return results;
-  },
+  };
   
   // Return all the elements for which a truth test fails.
-  reject : function(obj, iterator, context) {
+  _.reject = function(obj, iterator, context) {
     var results = [];
     _.each(obj, function(value, index) {
       if (!iterator.call(context, value, index)) results.push(value);
     });
     return results;
-  },
+  };
   
   // Determine whether all of the elements match a truth test. Delegate to
   // Javascript 1.6's every(), if it is present.
-  all : function(obj, iterator, context) {
+  _.all = function(obj, iterator, context) {
     iterator = iterator || function(v){ return v; };
     if (obj.every) return obj.every(iterator, context);
     var result = true;
@@ -102,11 +107,11 @@ window.Underscore = {
       if (!result) throw '__break__';
     });
     return result;
-  },
+  };
   
   // Determine if at least one element in the object matches a truth test. Use
   // Javascript 1.6's some(), if it exists.
-  any : function(obj, iterator, context) {
+  _.any = function(obj, iterator, context) {
     iterator = iterator || function(v) { return v; };
     if (obj.some) return obj.some(iterator, context);
     var result = false;
@@ -114,11 +119,11 @@ window.Underscore = {
       if (result = !!iterator.call(context, value, index)) throw '__break__';
     });
     return result;
-  },
+  };
   
   // Determine if a given value is included in the array or object, 
   // based on '==='.
-  include : function(obj, target) {
+  _.include = function(obj, target) {
     if (_.isArray(obj)) return _.indexOf(obj, target) != -1;
     var found = false;
     _.each(obj, function(pair) {
@@ -128,25 +133,25 @@ window.Underscore = {
       }
     });
     return found;
-  },
+  };
   
   // Invoke a method with arguments on every item in a collection.
-  invoke : function(obj, method) {
+  _.invoke = function(obj, method) {
     var args = _.toArray(arguments).slice(2);
     return _.map(obj, function(value) {
       return (method ? value[method] : value).apply(value, args);
     });
-  },
+  };
   
   // Optimized version of a common use case of map: fetching a property.
-  pluck : function(obj, key) {
+  _.pluck = function(obj, key) {
     var results = [];
     _.each(obj, function(value){ results.push(value[key]); });
     return results;
-  },
+  };
   
   // Return the maximum item or (item-based computation).
-  max : function(obj, iterator, context) {
+  _.max = function(obj, iterator, context) {
     if (!iterator && _.isArray(obj)) return Math.max.apply(Math, obj);
     var result;
     _.each(obj, function(value, index) {
@@ -154,10 +159,10 @@ window.Underscore = {
       if (result == null || computed >= result.computed) result = {value : value, computed : computed};
     });
     return result.value;
-  },
+  };
   
   // Return the minimum element (or element-based computation).
-  min : function(obj, iterator, context) {
+  _.min = function(obj, iterator, context) {
     if (!iterator && _.isArray(obj)) return Math.min.apply(Math, obj);
     var result;
     _.each(obj, function(value, index) {
@@ -165,10 +170,10 @@ window.Underscore = {
       if (result == null || computed < result.computed) result = {value : value, computed : computed};
     });
     return result.value;
-  },
+  };
   
   // Sort the object's values by a criteria produced by an iterator.
-  sortBy : function(obj, iterator, context) {
+  _.sortBy = function(obj, iterator, context) {
     return _.pluck(_.map(obj, function(value, index) {
       return {
         value : value,
@@ -178,11 +183,11 @@ window.Underscore = {
       var a = left.criteria, b = right.criteria;
       return a < b ? -1 : a > b ? 1 : 0;
     }), 'value');
-  },
+  };
   
   // 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) {
+  _.sortedIndex = function(array, obj, iterator) {
     iterator = iterator || function(val) { return val; };
     var low = 0, high = array.length;
     while (low < high) {
@@ -190,163 +195,182 @@ window.Underscore = {
       iterator(array[mid]) < iterator(obj) ? low = mid + 1 : high = mid;
     }
     return low;
-  },
+  };
   
   // Convert anything iterable into a real, live array.
-  toArray : function(iterable) {
+  _.toArray = function(iterable) {
     if (!iterable) return [];
     if (_.isArray(iterable)) return iterable;
     return _.map(iterable, function(val){ return val; });
-  },
+  };
   
   // Return the number of elements in an object.
-  size : function(obj) {
+  _.size = function(obj) {
     return _.toArray(obj).length;
-  },
+  };
   
   /*-------------------------- Array Functions: ------------------------------*/
   
   // Get the first element of an array.
-  first : function(array) {
+  _.first = function(array) {
     return array[0];
-  },
+  };
   
   // Get the last element of an array.
-  last : function(array) {
+  _.last = function(array) {
     return array[array.length - 1];
-  },
+  };
   
   // Trim out all falsy values from an array.
-  compact : function(array) {
+  _.compact = function(array) {
     return _.select(array, function(value){ return !!value; });
-  },
+  };
   
   // Return a completely flattened version of an array.
-  flatten : function(array) {
-    return _.inject(array, [], function(memo, value) {
+  _.flatten = function(array) {
+    return _.reduce(array, [], function(memo, value) {
       if (_.isArray(value)) return memo.concat(_.flatten(value));
       memo.push(value);
       return memo;
     });
-  },
+  };
   
   // Return a version of the array that does not contain the specified value(s).
-  without : function(array) {
+  _.without = function(array) {
     var values = array.slice.call(arguments, 0);
     return _.select(array, function(value){ return !_.include(values, value); });
-  },
+  };
   
   // Produce a duplicate-free version of the array. If the array has already
   // been sorted, you have the option of using a faster algorithm.
-  uniq : function(array, isSorted) {
-    return _.inject(array, [], function(memo, el, i) {
+  _.uniq = function(array, isSorted) {
+    return _.reduce(array, [], function(memo, el, i) {
       if (0 == i || (isSorted ? _.last(memo) != el : !_.include(memo, el))) memo.push(el);
       return memo;
     });
-  },
+  };
   
   // Produce an array that contains every item shared between all the 
   // passed-in arrays.
-  intersect : function(array) {
+  _.intersect = function(array) {
     var rest = _.toArray(arguments).slice(1);
     return _.select(_.uniq(array), function(item) {
       return _.all(rest, function(other) { 
         return _.indexOf(other, item) >= 0;
       });
     });
-  },
+  };
   
   // Zip together multiple lists into a single array -- elements that share
   // an index go together.
-  zip : function() {
+  _.zip = function() {
     var args = _.toArray(arguments);
     var length = _.max(_.pluck(args, 'length'));
     var results = new Array(length);
     for (var i=0; i<length; i++) results[i] = _.pluck(args, String(i));
     return results;
-  },
+  };
   
   // 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 occurence of an 
   // item in an array, or -1 if the item is not included in the array.
-  indexOf : function(array, item) {
+  _.indexOf = function(array, item) {
     if (array.indexOf) return array.indexOf(item);
-    var length = array.length;
-    for (i=0; i<length; i++) if (array[i] === item) return i;
+    for (i=0; i<array.length; i++) if (array[i] === item) return i;
+    return -1;
+  };
+  
+  // Provide Javascript 1.6's lastIndexOf, delegating to the native function,
+  // if possible.
+  _.lastIndexOf = function(array, item) {
+    if (array.lastIndexOf) return array.lastIndexOf(item);
+    for (i=array.length - 1; i>=0; i--) if (array[i] === item) return i;
     return -1;
-  },
+  };
   
   /* ----------------------- Function Functions: -----------------------------*/
   
   // Create a function bound to a given object (assigning 'this', and arguments,
   // optionally). Binding with arguments is also known as 'curry'.
-  bind : function(func, context) {
+  _.bind = function(func, context) {
     if (!context) return func;
     var args = _.toArray(arguments).slice(2);
     return function() {
       var a = args.concat(_.toArray(arguments));
       return func.apply(context, a);
     };
-  },
+  };
   
   // 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() {
+  _.bindAll = function() {
     var args = _.toArray(arguments);
     var context = args.pop();
     _.each(args, function(methodName) {
       context[methodName] = _.bind(context[methodName], context);
     });
-  },
+  };
   
   // Delays a function for the given number of milliseconds, and then calls
   // it with the arguments supplied.
-  delay : function(func, wait) {
+  _.delay = function(func, wait) {
     var args = _.toArray(arguments).slice(2);
-    return window.setTimeout(function(){ return func.apply(func, args); }, wait);
-  },
+    return setTimeout(function(){ return func.apply(func, args); }, wait);
+  };
   
   // Defers a function, scheduling it to run after the current call stack has 
   // cleared.
-  defer : function(func) {
+  _.defer = function(func) {
     return _.delay.apply(_, [func, 1].concat(_.toArray(arguments).slice(1)));
-  },
+  };
   
   // 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) {
+  _.wrap = function(func, wrapper) {
     return function() {
       var args = [func].concat(_.toArray(arguments));
       return wrapper.apply(wrapper, 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 = _.toArray(arguments);
+    return function() {
+      for (var i=funcs.length-1; i >= 0; i--) {
+        arguments = [funcs[i].apply(this, arguments)];
+      }
+      return arguments[0];
+    };
+  };
   
   /* ------------------------- Object Functions: ---------------------------- */
   
   // Retrieve the names of an object's properties.
-  keys : function(obj) {
+  _.keys = function(obj) {
     return _.pluck(obj, 'key');
-  },
+  };
   
   // Retrieve the values of an object's properties.
-  values : function(obj) {
+  _.values = function(obj) {
     return _.pluck(obj, 'value');
-  },
+  };
   
   // Extend a given object with all of the properties in a source object.
-  extend : function(destination, source) {
+  _.extend = function(destination, source) {
     for (var property in source) destination[property] = source[property];
     return destination;
-  },
+  };
   
   // Create a (shallow-cloned) duplicate of an object.
-  clone : function(obj) {
+  _.clone = function(obj) {
     return _.extend({}, obj);
-  },
+  };
   
   // Perform a deep comparison to check if two objects are equal.
-  isEqual : function(a, b) {
+  _.isEqual = function(a, b) {
     // Check object identity.
     if (a === b) return true;
     // Different types?
@@ -365,47 +389,47 @@ window.Underscore = {
     // Recursive comparison of contents.
     for (var key in a) if (!_.isEqual(a[key], b[key])) return false;
     return true;
-  },
+  };
   
   // Is a given value a DOM element?
-  isElement : function(obj) {
+  _.isElement = function(obj) {
     return !!(obj && obj.nodeType == 1);
-  },
+  };
   
   // Is a given value a real Array?
-  isArray : function(obj) {
+  _.isArray = function(obj) {
     return Object.prototype.toString.call(obj) == '[object Array]';
-  },
+  };
   
   // Is a given value a Function?
-  isFunction : function(obj) {
+  _.isFunction = function(obj) {
     return typeof obj == 'function';
-  },
+  };
   
   // Is a given variable undefined?
-  isUndefined : function(obj) {
+  _.isUndefined = function(obj) {
     return typeof obj == 'undefined';
-  },
+  };
   
   /* -------------------------- Utility Functions: -------------------------- */
   
   // Run Underscore.js in noConflict mode, returning the '_' variable to its
   // previous owner. Returns a reference to the Underscore object.
-  noConflict : function() {
-    window._ = Underscore.PREVIOUS_UNDERSCORE;
+  _.noConflict = function() {
+    root._ = previousUnderscore;
     return this;
-  },
+  };
   
   // Generate a unique integer id (unique within the entire client session).
   // Useful for temporary DOM ids.
-  uniqueId : function(prefix) {
+  _.uniqueId = function(prefix) {
     var id = this._idCounter = (this._idCounter || 0) + 1;
     return prefix ? prefix + id : id;
-  },
+  };
   
   // Javascript templating a-la ERB, pilfered from John Resig's 
   // "Secrets of the Javascript Ninja", page 83.
-  template : function(str, data) {
+  _.template = function(str, data) {
     var fn = new Function('obj', 
       'var p=[],print=function(){p.push.apply(p,arguments);};' +
       'with(obj){p.push(\'' +
@@ -419,8 +443,18 @@ window.Underscore = {
         .split("\r").join("\\'") 
     + "');}return p.join('');");
     return data ? fn(data) : fn;  
-  }
+  };
+  
+  /*------------------------------- Aliases ----------------------------------*/
+
+  _.forEach  = _.each;
+  _.inject   = _.reduce;
+  _.filter   = _.select;
+  _.every    = _.all;
+  _.some     = _.any;
+  
+  /*------------------------- Export for ServerJS ----------------------------*/
   
-};
+  if (!_.isUndefined(exports)) exports = _;
 
-window._ = Underscore;
+})();

metadata

@@ -2,7 +2,7 @@
 name: underscore-source
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors: 
 - Daniel X. Moore