sugar-rails 1.2.5.1 → 1.3.0

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

@@ -0,0 +1,222 @@
+
+  /***
+   * @package Function
+   * @dependency core
+   * @description Lazy, throttled, and memoized functions, delayed functions and handling of timers, argument currying.
+   *
+   ***/
+
+  function setDelay(fn, ms, after, scope, args) {
+    if(!fn.timers) fn.timers = [];
+    if(!isNumber(ms)) ms = 0;
+    fn.timers.push(setTimeout(function(){
+      fn.timers.splice(index, 1);
+      after.apply(scope, args || []);
+    }, ms));
+    var index = fn.timers.length;
+  }
+
+  extend(Function, true, false, {
+
+     /***
+     * @method lazy([ms] = 1, [limit] = Infinity)
+     * @returns Function
+     * @short Creates a lazy function that, when called repeatedly, will queue execution and wait [ms] milliseconds to execute again.
+     * @extra Lazy functions will always execute as many times as they are called up to [limit], after which point subsequent calls will be ignored (if it is set to a finite number). Compare this to %throttle%, which will execute only once per [ms] milliseconds. %lazy% is useful when you need to be sure that every call to a function is executed, but in a non-blocking manner. Calling %cancel% on a lazy function will clear the entire queue. Note that [ms] can also be a fraction.
+     * @example
+     *
+     *   (function() {
+     *     // Executes immediately.
+     *   }).lazy()();
+     *   (3).times(function() {
+     *     // Executes 3 times, with each execution 20ms later than the last.
+     *   }.lazy(20));
+     *   (100).times(function() {
+     *     // Executes 50 times, with each execution 20ms later than the last.
+     *   }.lazy(20, 50));
+     *
+     ***/
+    'lazy': function(ms, limit) {
+      var fn = this, queue = [], lock = false, execute, rounded, perExecution;
+      ms = ms || 1;
+      limit = limit || Infinity;
+      rounded = ceil(ms);
+      perExecution = round(rounded / ms);
+      execute = function() {
+        if(lock || queue.length == 0) return;
+        var max = math.max(queue.length - perExecution, 0);
+        while(queue.length > max) {
+          // Getting uber-meta here...
+          Function.prototype.apply.apply(fn, queue.shift());
+        }
+        setDelay(lazy, rounded, function() {
+          lock = false;
+          execute();
+        });
+        lock = true;
+      }
+      function lazy() {
+        // The first call is immediate, so having 1 in the queue
+        // implies two calls have already taken place.
+        if(lock && queue.length > limit - 2) return;
+        queue.push([this, arguments]);
+        execute();
+      }
+      return lazy;
+    },
+
+     /***
+     * @method delay([ms] = 0, [arg1], ...)
+     * @returns Function
+     * @short Executes the function after <ms> milliseconds.
+     * @extra Returns a reference to itself. %delay% is also a way to execute non-blocking operations that will wait until the CPU is free. Delayed functions can be canceled using the %cancel% method. Can also curry arguments passed in after <ms>.
+     * @example
+     *
+     *   (function(arg1) {
+     *     // called 1s later
+     *   }).delay(1000, 'arg1');
+     *
+     ***/
+    'delay': function(ms) {
+      var fn = this;
+      var args = multiArgs(arguments).slice(1);
+      setDelay(fn, ms, fn, fn, args);
+      return fn;
+    },
+
+     /***
+     * @method throttle(<ms>)
+     * @returns Function
+     * @short Creates a "throttled" version of the function that will only be executed once per <ms> milliseconds.
+     * @extra This is functionally equivalent to calling %lazy% with a [limit] of %1%. %throttle% is appropriate when you want to make sure a function is only executed at most once for a given duration. Compare this to %lazy%, which will queue rapid calls and execute them later.
+     * @example
+     *
+     *   (3).times(function() {
+     *     // called only once. will wait 50ms until it responds again
+     *   }.throttle(50));
+     *
+     ***/
+    'throttle': function(ms) {
+      return this.lazy(ms, 1);
+    },
+
+     /***
+     * @method debounce(<ms>)
+     * @returns Function
+     * @short Creates a "debounced" function that postpones its execution until after <ms> milliseconds have passed.
+     * @extra This method is useful to execute a function after things have "settled down". A good example of this is when a user tabs quickly through form fields, execution of a heavy operation should happen after a few milliseconds when they have "settled" on a field.
+     * @example
+     *
+     *   var fn = (function(arg1) {
+     *     // called once 50ms later
+     *   }).debounce(50); fn() fn() fn();
+     *
+     ***/
+    'debounce': function(ms) {
+      var fn = this;
+      return function() {
+        fn.cancel();
+        setDelay(fn, ms, fn, this, arguments);
+      }
+    },
+
+     /***
+     * @method cancel()
+     * @returns Function
+     * @short Cancels a delayed function scheduled to be run.
+     * @extra %delay%, %lazy%, %throttle%, and %debounce% can all set delays.
+     * @example
+     *
+     *   (function() {
+     *     alert('hay'); // Never called
+     *   }).delay(500).cancel();
+     *
+     ***/
+    'cancel': function() {
+      if(isArray(this.timers)) {
+        while(this.timers.length > 0) {
+          clearTimeout(this.timers.shift());
+        }
+      }
+      return this;
+    },
+
+     /***
+     * @method after([num] = 1)
+     * @returns Function
+     * @short Creates a function that will execute after [num] calls.
+     * @extra %after% is useful for running a final callback after a series of asynchronous operations, when the order in which the operations will complete is unknown.
+     * @example
+     *
+     *   var fn = (function() {
+     *     // Will be executed once only
+     *   }).after(3); fn(); fn(); fn();
+     *
+     ***/
+    'after': function(num) {
+      var fn = this, counter = 0, storedArguments = [];
+      if(!isNumber(num)) {
+        num = 1;
+      } else if(num === 0) {
+        fn.call();
+        return fn;
+      }
+      return function() {
+        var ret;
+        storedArguments.push(multiArgs(arguments));
+        counter++;
+        if(counter == num) {
+          ret = fn.call(this, storedArguments);
+          counter = 0;
+          storedArguments = [];
+          return ret;
+        }
+      }
+    },
+
+     /***
+     * @method once()
+     * @returns Function
+     * @short Creates a function that will execute only once and store the result.
+     * @extra %once% is useful for creating functions that will cache the result of an expensive operation and use it on subsequent calls. Also it can be useful for creating initialization functions that only need to be run once.
+     * @example
+     *
+     *   var fn = (function() {
+     *     // Will be executed once only
+     *   }).once(); fn(); fn(); fn();
+     *
+     ***/
+    'once': function() {
+      var fn = this;
+      return function() {
+        return hasOwnProperty(fn, 'memo') ? fn['memo'] : fn['memo'] = fn.apply(this, arguments);
+      }
+    },
+
+     /***
+     * @method fill(<arg1>, <arg2>, ...)
+     * @returns Function
+     * @short Returns a new version of the function which when called will have some of its arguments pre-emptively filled in, also known as "currying".
+     * @extra Arguments passed to a "filled" function are generally appended to the curried arguments. However, if %undefined% is passed as any of the arguments to %fill%, it will be replaced, when the "filled" function is executed. This allows currying of arguments even when they occur toward the end of an argument list (the example demonstrates this much more clearly).
+     * @example
+     *
+     *   var delayOneSecond = setTimeout.fill(undefined, 1000);
+     *   delayOneSecond(function() {
+     *     // Will be executed 1s later
+     *   });
+     *
+     ***/
+    'fill': function() {
+      var fn = this, curried = multiArgs(arguments);
+      return function() {
+        var args = multiArgs(arguments);
+        curried.forEach(function(arg, index) {
+          if(arg != null || index >= args.length) args.splice(index, 0, arg);
+        });
+        return fn.apply(this, args);
+      }
+    }
+
+
+  });
+

data/vendor/assets/javascripts/{sugar-inflections.js → precompiled/development/inflections.js}

@@ -1,4 +1,11 @@
-(function(context) {
+
+  /***
+   *
+   * @package Inflections
+   * @dependency string
+   * @description Pluralization similar to ActiveSupport including uncountable words and acronyms. Humanized and URL-friendly strings.
+   *
+   ***/
 
   /***
    * String module
@@ -6,23 +13,26 @@
    ***/
 
 
-  var globalContext,
-      plurals      = [],
+  var plurals      = [],
       singulars    = [],
       uncountables = [],
       humans       = [],
       acronyms     = {},
       Downcased,
-      Normalize,
       Inflector;
 
-  globalContext = typeof global !== 'undefined' ? global : context;
+  function removeFromArray(arr, find) {
+    var index = arr.indexOf(find);
+    if(index > -1) {
+      arr.splice(index, 1);
+    }
+  }
 
   function removeFromUncountablesAndAddTo(arr, rule, replacement) {
-    if(Object.isString(rule)) {
-      uncountables.remove(rule);
+    if(isString(rule)) {
+      removeFromArray(uncountables, rule);
     }
-    uncountables.remove(replacement)
+    removeFromArray(uncountables, replacement);
     arr.unshift({ rule: rule, replacement: replacement })
   }
 
@@ -31,13 +41,13 @@
   }
 
   function isUncountable(word) {
-    return uncountables.any(function(uncountable) {
-      return new RegExp('\\b' + uncountable + '$', 'i').test(word);
+    return uncountables.some(function(uncountable) {
+      return new regexp('\\b' + uncountable + '$', 'i').test(word);
     });
   }
 
   function inflect(word, pluralize) {
-    word = Object.isString(word) ? word.toString() : '';
+    word = isString(word) ? word.toString() : '';
     if(word.isBlank() || isUncountable(word)) {
       return word;
     } else {
@@ -46,7 +56,7 @@
   }
 
   function runReplacements(word, table) {
-    table.each(function(inflection) {
+    iterateOverObject(table, function(i, inflection) {
       if(word.match(inflection.rule)) {
         word = word.replace(inflection.rule, inflection.replacement);
         return false;
@@ -113,7 +123,10 @@
      */
     'acronym': function(word) {
       acronyms[word.toLowerCase()] = word;
-      Inflector.acronymRegExp = new RegExp(Object.values(acronyms).join('|'), 'g');
+      var all = object.keys(acronyms).map(function(key) {
+        return acronyms[key];
+      });
+      Inflector.acronymRegExp = regexp(all.join('|'), 'g');
     },
 
     /*
@@ -149,19 +162,19 @@
           pluralFirstLower   = pluralFirst.toLowerCase(),
           singularFirstUpper = singularFirst.toUpperCase(),
           singularFirstLower = singularFirst.toLowerCase();
-      uncountables.remove(singular)
-      uncountables.remove(plural)
+      removeFromArray(uncountables, singular);
+      removeFromArray(uncountables, plural);
       if(singularFirstUpper == pluralFirstUpper) {
-        Inflector.plural(new RegExp('({1}){2}$'.assign(singularFirst, singularRest), 'i'), '$1' + pluralRest);
-        Inflector.plural(new RegExp('({1}){2}$'.assign(pluralFirst, pluralRest), 'i'), '$1' + pluralRest);
-        Inflector.singular(new RegExp('({1}){2}$'.assign(pluralFirst, pluralRest), 'i'), '$1' + singularRest);
+        Inflector.plural(new regexp('({1}){2}$'.assign(singularFirst, singularRest), 'i'), '$1' + pluralRest);
+        Inflector.plural(new regexp('({1}){2}$'.assign(pluralFirst, pluralRest), 'i'), '$1' + pluralRest);
+        Inflector.singular(new regexp('({1}){2}$'.assign(pluralFirst, pluralRest), 'i'), '$1' + singularRest);
       } else {
-        Inflector.plural(new RegExp('{1}{2}$'.assign(singularFirstUpper, singularRest)), pluralFirstUpper + pluralRest);
-        Inflector.plural(new RegExp('{1}{2}$'.assign(singularFirstLower, singularRest)), pluralFirstLower + pluralRest);
-        Inflector.plural(new RegExp('{1}{2}$'.assign(pluralFirstUpper, pluralRest)), pluralFirstUpper + pluralRest);
-        Inflector.plural(new RegExp('{1}{2}$'.assign(pluralFirstLower, pluralRest)), pluralFirstLower + pluralRest);
-        Inflector.singular(new RegExp('{1}{2}$'.assign(pluralFirstUpper, pluralRest)), singularFirstUpper + singularRest);
-        Inflector.singular(new RegExp('{1}{2}$'.assign(pluralFirstLower, pluralRest)), singularFirstLower + singularRest);
+        Inflector.plural(new regexp('{1}{2}$'.assign(singularFirstUpper, singularRest)), pluralFirstUpper + pluralRest);
+        Inflector.plural(new regexp('{1}{2}$'.assign(singularFirstLower, singularRest)), pluralFirstLower + pluralRest);
+        Inflector.plural(new regexp('{1}{2}$'.assign(pluralFirstUpper, pluralRest)), pluralFirstUpper + pluralRest);
+        Inflector.plural(new regexp('{1}{2}$'.assign(pluralFirstLower, pluralRest)), pluralFirstLower + pluralRest);
+        Inflector.singular(new regexp('{1}{2}$'.assign(pluralFirstUpper, pluralRest)), singularFirstUpper + singularRest);
+        Inflector.singular(new regexp('{1}{2}$'.assign(pluralFirstLower, pluralRest)), singularFirstLower + singularRest);
       }
     },
 
@@ -173,8 +186,9 @@
      *   String.Inflector.uncountable('money', 'information')
      *   String.Inflector.uncountable(['money', 'information', 'rice'])
      */
-    'uncountable': function() {
-      uncountables.add(Array.create(arguments).flatten());
+    'uncountable': function(first) {
+      var add = array.isArray(first) ? first : multiArgs(arguments);
+      uncountables = uncountables.concat(add);
     },
 
     /*
@@ -215,95 +229,6 @@
     'with', 'for'
   ];
 
-  Normalize = {
-    'A':  /[AⒶＡÀÁÂẦẤẪẨÃĀĂẰẮẴẲȦǠÄǞẢÅǺǍȀȂẠẬẶḀĄȺⱯ]/g,
-    'B':  /[BⒷＢḂḄḆɃƂƁ]/g,
-    'C':  /[CⒸＣĆĈĊČÇḈƇȻꜾ]/g,
-    'D':  /[DⒹＤḊĎḌḐḒḎĐƋƊƉꝹ]/g,
-    'E':  /[EⒺＥÈÉÊỀẾỄỂẼĒḔḖĔĖËẺĚȄȆẸỆȨḜĘḘḚƐƎ]/g,
-    'F':  /[FⒻＦḞƑꝻ]/g,
-    'G':  /[GⒼＧǴĜḠĞĠǦĢǤƓꞠꝽꝾ]/g,
-    'H':  /[HⒽＨĤḢḦȞḤḨḪĦⱧⱵꞍ]/g,
-    'I':  /[IⒾＩÌÍÎĨĪĬİÏḮỈǏȈȊỊĮḬƗ]/g,
-    'J':  /[JⒿＪĴɈ]/g,
-    'K':  /[KⓀＫḰǨḲĶḴƘⱩꝀꝂꝄꞢ]/g,
-    'L':  /[LⓁＬĿĹĽḶḸĻḼḺŁȽⱢⱠꝈꝆꞀ]/g,
-    'M':  /[MⓂＭḾṀṂⱮƜ]/g,
-    'N':  /[NⓃＮǸŃÑṄŇṆŅṊṈȠƝꞐꞤ]/g,
-    'O':  /[OⓄＯÒÓÔỒỐỖỔÕṌȬṎŌṐṒŎȮȰÖȪỎŐǑȌȎƠỜỚỠỞỢỌỘǪǬØǾƆƟꝊꝌ]/g,
-    'P':  /[PⓅＰṔṖƤⱣꝐꝒꝔ]/g,
-    'Q':  /[QⓆＱꝖꝘɊ]/g,
-    'R':  /[RⓇＲŔṘŘȐȒṚṜŖṞɌⱤꝚꞦꞂ]/g,
-    'S':  /[SⓈＳẞŚṤŜṠŠṦṢṨȘŞⱾꞨꞄ]/g,
-    'T':  /[TⓉＴṪŤṬȚŢṰṮŦƬƮȾꞆ]/g,
-    'U':  /[UⓊＵÙÚÛŨṸŪṺŬÜǛǗǕǙỦŮŰǓȔȖƯỪỨỮỬỰỤṲŲṶṴɄ]/g,
-    'V':  /[VⓋＶṼṾƲꝞɅ]/g,
-    'W':  /[WⓌＷẀẂŴẆẄẈⱲ]/g,
-    'X':  /[XⓍＸẊẌ]/g,
-    'Y':  /[YⓎＹỲÝŶỸȲẎŸỶỴƳɎỾ]/g,
-    'Z':  /[ZⓏＺŹẐŻŽẒẔƵȤⱿⱫꝢ]/g,
-    'a':  /[aⓐａẚàáâầấẫẩãāăằắẵẳȧǡäǟảåǻǎȁȃạậặḁąⱥɐ]/g,
-    'b':  /[bⓑｂḃḅḇƀƃɓ]/g,
-    'c':  /[cⓒｃćĉċčçḉƈȼꜿↄ]/g,
-    'd':  /[dⓓｄḋďḍḑḓḏđƌɖɗꝺ]/g,
-    'e':  /[eⓔｅèéêềếễểẽēḕḗĕėëẻěȅȇẹệȩḝęḙḛɇɛǝ]/g,
-    'f':  /[fⓕｆḟƒꝼ]/g,
-    'g':  /[gⓖｇǵĝḡğġǧģǥɠꞡᵹꝿ]/g,
-    'h':  /[hⓗｈĥḣḧȟḥḩḫẖħⱨⱶɥ]/g,
-    'i':  /[iⓘｉìíîĩīĭïḯỉǐȉȋịįḭɨı]/g,
-    'j':  /[jⓙｊĵǰɉ]/g,
-    'k':  /[kⓚｋḱǩḳķḵƙⱪꝁꝃꝅꞣ]/g,
-    'l':  /[lⓛｌŀĺľḷḹļḽḻſłƚɫⱡꝉꞁꝇ]/g,
-    'm':  /[mⓜｍḿṁṃɱɯ]/g,
-    'n':  /[nⓝｎǹńñṅňṇņṋṉƞɲʼnꞑꞥ]/g,
-    'o':  /[oⓞｏòóôồốỗổõṍȭṏōṑṓŏȯȱöȫỏőǒȍȏơờớỡởợọộǫǭøǿɔꝋꝍɵ]/g,
-    'p':  /[pⓟｐṕṗƥᵽꝑꝓꝕ]/g,
-    'q':  /[qⓠｑɋꝗꝙ]/g,
-    'r':  /[rⓡｒŕṙřȑȓṛṝŗṟɍɽꝛꞧꞃ]/g,
-    's':  /[sⓢｓśṥŝṡšṧṣṩșşȿꞩꞅẛ]/g,
-    't':  /[tⓣｔṫẗťṭțţṱṯŧƭʈⱦꞇ]/g,
-    'u':  /[uⓤｕùúûũṹūṻŭüǜǘǖǚủůűǔȕȗưừứữửựụṳųṷṵʉ]/g,
-    'v':  /[vⓥｖṽṿʋꝟʌ]/g,
-    'w':  /[wⓦｗẁẃŵẇẅẘẉⱳ]/g,
-    'x':  /[xⓧｘẋẍ]/g,
-    'y':  /[yⓨｙỳýŷỹȳẏÿỷẙỵƴɏỿ]/g,
-    'z':  /[zⓩｚźẑżžẓẕƶȥɀⱬꝣ]/g,
-    'AA': /[Ꜳ]/g,
-    'AE': /[ÆǼǢ]/g,
-    'AO': /[Ꜵ]/g,
-    'AU': /[Ꜷ]/g,
-    'AV': /[ꜸꜺ]/g,
-    'AY': /[Ꜽ]/g,
-    'DZ': /[DZDŽ]/g,
-    'Dz': /[DzDž]/g,
-    'LJ': /[LJ]/g,
-    'Lj': /[Lj]/g,
-    'NJ': /[NJ]/g,
-    'Nj': /[Nj]/g,
-    'OI': /[Ƣ]/g,
-    'OO': /[Ꝏ]/g,
-    'OU': /[Ȣ]/g,
-    'TZ': /[Ꜩ]/g,
-    'VY': /[Ꝡ]/g,
-    'aa': /[ꜳ]/g,
-    'ae': /[æǽǣ]/g,
-    'ao': /[ꜵ]/g,
-    'au': /[ꜷ]/g,
-    'av': /[ꜹꜻ]/g,
-    'ay': /[ꜽ]/g,
-    'dz': /[dzdž]/g,
-    'hv': /[ƕ]/g,
-    'lj': /[lj]/g,
-    'nj': /[nj]/g,
-    'oi': /[ƣ]/g,
-    'ou': /[ȣ]/g,
-    'oo': /[ꝏ]/g,
-    'ss':  /[ß]/g,
-    'tz': /[ꜩ]/g,
-    'vy': /[ꝡ]/
-  };
-
-
   Inflector.plural(/$/, 's');
   Inflector.plural(/s$/gi, 's');
   Inflector.plural(/(ax|test)is$/gi, '$1es');
@@ -328,7 +253,7 @@
   Inflector.plural(/(quiz)$/gi, '$1zes');
   Inflector.plural(/(phot|cant|hom|zer|pian|portic|pr|quart|kimon)o$/gi, '$1os');
   Inflector.plural(/(craft)$/gi, '$1');
-  Inflector.plural(/[eo]{2}(th?)$/gi, 'ee$1');
+  Inflector.plural(/([ft])[eo]{2}(th?)$/gi, '$1ee$2');
 
   Inflector.singular(/s$/gi, '');
   Inflector.singular(/([pst][aiu]s)$/gi, '$1');
@@ -372,7 +297,7 @@
   Inflector.uncountable('equipment,information,rice,money,species,series,fish,sheep,jeans'.split(','));
 
 
-  String.extend({
+  extend(string, true, false, {
 
     /***
      * @method pluralize()
@@ -447,7 +372,7 @@
         hasPunctuation = fullStopPunctuation.test(word);
         isFirstOrLast = index == 0 || index == words.length - 1 || hasPunctuation || lastHadPunctuation;
         lastHadPunctuation = hasPunctuation;
-        if(isFirstOrLast || !Downcased.any(word)) {
+        if(isFirstOrLast || Downcased.indexOf(word) === -1) {
           return capitalize(word);
         } else {
           return word;
@@ -455,24 +380,6 @@
       }).join(' ');
     },
 
-    /***
-     * @method namespace()
-     * @returns Mixed
-     * @short Tries to find the namespace or property with the name specified in the string.
-     * @extra Namespacing begins at the global level and operates on every "." in the string. If any level returns %undefined% the result will be %undefined%.
-     * @example
-     *
-     *   'Path.To.Namespace'.namespace() -> Path.To.Namespace
-     *
-     ***/
-    'namespace': function() {
-      var spaces = this.split('.'), scope = globalContext;
-      spaces.each(function(s) {
-        return !!(scope = scope[s]);
-      });
-      return scope;
-    },
-
     /***
      * @method parameterize()
      * @returns String
@@ -483,38 +390,20 @@
      *
      ***/
     'parameterize': function(separator) {
+      var str = this;
       if(separator === undefined) separator = '-';
-      var str = this.normalize();
+      if(str.normalize) {
+        str = str.normalize();
+      }
       str = str.replace(/[^a-z0-9\-_]+/gi, separator)
       if(separator) {
-        str = str.replace(new RegExp('^{sep}+|{sep}+$|({sep}){sep}+'.assign({ 'sep': RegExp.escape(separator) }), 'g'), '$1');
+        str = str.replace(new regexp('^{sep}+|{sep}+$|({sep}){sep}+'.assign({ 'sep': escapeRegExp(separator) }), 'g'), '$1');
       }
-      return str.toLowerCase();
-    },
-
-    /***
-     * @method normalize()
-     * @returns String
-     * @short Returns the string with accented and non-standard Latin-based characters converted into ASCII approximate equivalents.
-     * @example
-     *
-     *   'á'.normalize()                  -> 'a'
-     *   'Ménage à trois'.normalize()     -> 'Menage a trois'
-     *   'Volkswagen'.normalize()         -> 'Volkswagen'
-     *   'ＦＵＬＬＷＩＤＴＨ'.normalize() -> 'FULLWIDTH'
-     *
-     ***/
-    'normalize': function() {
-      var str = this.toString();
-      Object.each(Normalize, function(base, reg) {
-        str = str.replace(reg, base);
-      });
-      return str;
+      return encodeURI(str.toLowerCase());
     }
 
   });
 
-  String.Inflector = Inflector;
-  String.Inflector.acronyms = acronyms;
+  string.Inflector = Inflector;
+  string.Inflector.acronyms = acronyms;
 
-})(this);