sugar-rails 1.3.0 → 1.3.1

data/lib/sugar/rails/version.rb

@@ -1,6 +1,6 @@
 module Sugar
   module Rails
-    VERSION = "1.3.0"
-    SUGARJS_VERSION = "1.3"
+    VERSION = "1.3.1"
+    SUGARJS_VERSION = "1.3.1"
   end
 end

data/vendor/assets/javascripts/precompiled/development/array.js

@@ -1,6 +1,5 @@
 
 
-
   /***
    * @package Array
    * @dependency core
@@ -27,9 +26,9 @@
           result = false;
         }
       });
-      return object.keys(match).length > 0 && result;
+      return result;
     } else {
-      return stringify(el) === stringify(match);
+      return isEqual(el, match);
     }
   }
 
@@ -97,12 +96,10 @@
   }
 
   function arrayUnique(arr, map) {
-    var result = [], o = {}, stringified, transformed;
+    var result = [], o = {}, transformed;
     arrayEach(arr, function(el, i) {
       transformed = map ? transformArgument(el, map, arr, [el, i, arr]) : el;
-      stringified = stringify(transformed);
-      if(!arrayObjectExists(o, stringified, el)) {
-        o[stringified] = transformed;
+      if(!checkForElementInHashAndSet(o, transformed)) {
         result.push(el);
       }
     })
@@ -112,15 +109,16 @@
   function arrayIntersect(arr1, arr2, subtract) {
     var result = [], o = {};
     arr2.each(function(el) {
-      o[stringify(el)] = el;
+      checkForElementInHashAndSet(o, el);
     });
     arr1.each(function(el) {
-      var stringified = stringify(el), exists = arrayObjectExists(o, stringified, el);
+      var stringified = stringify(el),
+          isReference = !objectIsMatchedByValue(el);
       // Add the result to the array if:
       // 1. We're subtracting intersections or it doesn't already exist in the result and
       // 2. It exists in the compared array and we're adding, or it doesn't exist and we're removing.
-      if(exists != subtract) {
-        delete o[stringified];
+      if(elementExistsInHash(o, stringified, el, isReference) != subtract) {
+        discardElementFromHash(o, stringified, el, isReference);
         result.push(el);
       }
     });
@@ -149,10 +147,44 @@
     return result;
   }
 
-  function arrayObjectExists(hash, stringified, obj) {
-    return stringified in hash && (typeof obj !== 'function' || obj === hash[stringified]);
+  function elementExistsInHash(hash, key, element, isReference) {
+    var exists = key in hash;
+    if(isReference) {
+      if(!hash[key]) {
+        hash[key] = [];
+      }
+      exists = hash[key].indexOf(element) !== -1;
+    }
+    return exists;
+  }
+
+  function checkForElementInHashAndSet(hash, element) {
+    var stringified = stringify(element),
+        isReference = !objectIsMatchedByValue(element),
+        exists = elementExistsInHash(hash, stringified, element, isReference);
+    if(isReference) {
+      hash[stringified].push(element);
+    } else {
+      hash[stringified] = element;
+    }
+    return exists;
   }
 
+  function discardElementFromHash(hash, key, element, isReference) {
+    var arr, i = 0;
+    if(isReference) {
+      arr = hash[key];
+      while(i < arr.length) {
+        if(arr[i] === element) {
+          arr.splice(i, 1);
+        } else {
+          i += 1;
+        }
+      }
+    } else {
+      delete hash[key];
+    }
+  }
 
   // Support methods
 
@@ -341,8 +373,11 @@
     'create': function() {
       var result = []
       multiArgs(arguments, function(a) {
-        if(a && a.callee) a = multiArgs(a);
-        result = result.concat(a);
+        if(isObjectPrimitive(a)) {
+          result = result.concat(array.prototype.slice.call(a));
+        } else {
+          result.push(a);
+        }
       });
       return result;
     }

data/vendor/assets/javascripts/precompiled/development/core.js

@@ -16,7 +16,7 @@
   // native objects. IE8 does not have defineProperies, however, so this check saves a try/catch block.
   var definePropertySupport = object.defineProperty && object.defineProperties;
 
-  // Class initializers and isClass type helpers
+  // Class initializers and class helpers
 
   var ClassNames = 'Array,Boolean,Date,Function,Number,String,RegExp'.split(',');
 
@@ -30,12 +30,12 @@
 
   function buildClassCheck(type) {
     return function(obj) {
-      return isClass(obj, type);
+      return className(obj) === '[object '+type+']';
     }
   }
 
-  function isClass(obj, str) {
-    return object.prototype.toString.call(obj) === '[object '+str+']';
+  function className(obj) {
+    return object.prototype.toString.call(obj);
   }
 
   function initializeClasses() {
@@ -141,7 +141,9 @@
 
   function isObject(obj) {
     // === on the constructor is not safe across iframes
-    return !!obj && isClass(obj, 'Object') && string(obj.constructor) === string(object);
+    // 'hasOwnProperty' ensures that the object also inherits
+    // from Object, which is false for DOMElements in IE.
+    return !!obj && className(obj) === '[object Object]' && 'hasOwnProperty' in obj;
   }
 
   function hasOwnProperty(obj, key) {
@@ -255,16 +257,20 @@
   // Used by Array#unique and Object.equal
 
   function stringify(thing, stack) {
-    var value, klass, isObject, isArray, arr, i, key, type = typeof thing;
+    var type = typeof thing,
+        thingIsObject,
+        thingIsArray,
+        klass, value,
+        arr, key, i;
 
     // Return quickly if string to save cycles
     if(type === 'string') return thing;
 
-    klass    = object.prototype.toString.call(thing)
-    isObject = klass === '[object Object]';
-    isArray  = klass === '[object Array]';
+    klass         = object.prototype.toString.call(thing)
+    thingIsObject = isObject(thing);
+    thingIsArray  = klass === '[object Array]';
 
-    if(thing != null && isObject || isArray) {
+    if(thing != null && thingIsObject || thingIsArray) {
       // This method for checking for cyclic structures was egregiously stolen from
       // the ingenious method by @kitcambridge from the Underscore script:
       // https://github.com/documentcloud/underscore/issues/240
@@ -283,20 +289,40 @@
       }
       stack.push(thing);
       value = string(thing.constructor);
-      arr = isArray ? thing : object.keys(thing).sort();
+      arr = thingIsArray ? thing : object.keys(thing).sort();
       for(i = 0; i < arr.length; i++) {
-        key = isArray ? i : arr[i];
+        key = thingIsArray ? i : arr[i];
         value += key + stringify(thing[key], stack);
       }
       stack.pop();
     } else if(1 / thing === -Infinity) {
       value = '-0';
     } else {
-      value = string(thing && thing.valueOf());
+      value = string(thing && thing.valueOf ? thing.valueOf() : thing);
     }
     return type + klass + value;
   }
 
+  function isEqual(a, b) {
+    if(objectIsMatchedByValue(a) && objectIsMatchedByValue(b)) {
+      return stringify(a) === stringify(b);
+    } else {
+      return a === b;
+    }
+  }
+
+  function objectIsMatchedByValue(obj) {
+    var klass = className(obj);
+    return klass === '[object Date]'      ||
+           klass === '[object Array]'     ||
+           klass === '[object String]'    ||
+           klass === '[object Number]'    ||
+           klass === '[object RegExp]'    ||
+           klass === '[object Boolean]'   ||
+           klass === '[object Arguments]' ||
+           isObject(obj);
+  }
+
 
   // Used by Array#at and String#at