sugar-rails 1.2.5.1 → 1.3.0

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

@@ -0,0 +1,348 @@
+
+  /***
+   * @package Object
+   * @dependency core
+   * @description Object manipulation, type checking (isNumber, isString, ...), extended objects with hash-like methods available as instance methods.
+   *
+   * Much thanks to kangax for his informative aricle about how problems with instanceof and constructor
+   * http://perfectionkills.com/instanceof-considered-harmful-or-how-to-write-a-robust-isarray/
+   *
+   ***/
+
+  var ObjectTypeMethods = 'isObject,isNaN'.split(',');
+  var ObjectHashMethods = 'keys,values,each,merge,clone,equal,watch,tap,has'.split(',');
+
+  function setParamsObject(obj, param, value, deep) {
+    var reg = /^(.+?)(\[.*\])$/, paramIsArray, match, allKeys, key;
+    if(deep !== false && (match = param.match(reg))) {
+      key = match[1];
+      allKeys = match[2].replace(/^\[|\]$/g, '').split('][');
+      allKeys.forEach(function(k) {
+        paramIsArray = !k || k.match(/^\d+$/);
+        if(!key && isArray(obj)) key = obj.length;
+        if(!obj[key]) {
+          obj[key] = paramIsArray ? [] : {};
+        }
+        obj = obj[key];
+        key = k;
+      });
+      if(!key && paramIsArray) key = obj.length.toString();
+      setParamsObject(obj, key, value);
+    } else if(value.match(/^[\d.]+$/)) {
+      obj[param] = parseFloat(value);
+    } else if(value === 'true') {
+      obj[param] = true;
+    } else if(value === 'false') {
+      obj[param] = false;
+    } else {
+      obj[param] = value;
+    }
+  }
+
+
+  /***
+   * @method Object.is[Type](<obj>)
+   * @returns Boolean
+   * @short Returns true if <obj> is an object of that type.
+   * @extra %isObject% will return false on anything that is not an object literal, including instances of inherited classes. Note also that %isNaN% will ONLY return true if the object IS %NaN%. It does not mean the same as browser native %isNaN%, which returns true for anything that is "not a number".
+   *
+   * @set
+   *   isArray
+   *   isObject
+   *   isBoolean
+   *   isDate
+   *   isFunction
+   *   isNaN
+   *   isNumber
+   *   isString
+   *   isRegExp
+   *
+   * @example
+   *
+   *   Object.isArray([1,2,3])            -> true
+   *   Object.isDate(3)                   -> false
+   *   Object.isRegExp(/wasabi/)          -> true
+   *   Object.isObject({ broken:'wear' }) -> true
+   *
+   ***/
+  function buildTypeMethods() {
+    extendSimilar(object, false, false, ClassNames, function(methods, name) {
+      var method = 'is' + name;
+      ObjectTypeMethods.push(method);
+      methods[method] = function(obj) {
+        return isClass(obj, name);
+      }
+    });
+  }
+
+  function buildObjectExtend() {
+    extend(object, false, function(){ return arguments.length === 0; }, {
+      'extend': function() {
+        buildObjectInstanceMethods(ObjectTypeMethods.concat(ObjectHashMethods), object);
+      }
+    });
+  }
+
+  extend(object, false, true, {
+      /***
+       * @method watch(<obj>, <prop>, <fn>)
+       * @returns Nothing
+       * @short Watches a property of <obj> and runs <fn> when it changes.
+       * @extra <fn> is passed three arguments: the property <prop>, the old value, and the new value. The return value of [fn] will be set as the new value. This method is useful for things such as validating or cleaning the value when it is set. Warning: this method WILL NOT work in browsers that don't support %Object.defineProperty%. This notably includes IE 8 and below, and Opera. This is the only method in Sugar that is not fully compatible with all browsers. %watch% is available as an instance method on extended objects.
+       * @example
+       *
+       *   Object.watch({ foo: 'bar' }, 'foo', function(prop, oldVal, newVal) {
+       *     // Will be run when the property 'foo' is set on the object.
+       *   });
+       *   Object.extended().watch({ foo: 'bar' }, 'foo', function(prop, oldVal, newVal) {
+       *     // Will be run when the property 'foo' is set on the object.
+       *   });
+       *
+       ***/
+    'watch': function(obj, prop, fn) {
+      if(!definePropertySupport) return;
+      var value = obj[prop];
+      object.defineProperty(obj, prop, {
+        'enumerable'  : true,
+        'configurable': true,
+        'get': function() {
+          return value;
+        },
+        'set': function(to) {
+          value = fn.call(obj, prop, value, to);
+        }
+      });
+    }
+  });
+
+  extend(object, false, function(arg1, arg2) { return isFunction(arg2); }, {
+
+    /***
+     * @method keys(<obj>, [fn])
+     * @returns Array
+     * @short Returns an array containing the keys in <obj>. Optionally calls [fn] for each key.
+     * @extra This method is provided for browsers that don't support it natively, and additionally is enhanced to accept the callback [fn]. Returned keys are in no particular order. %keys% is available as an instance method on extended objects.
+     * @example
+     *
+     *   Object.keys({ broken: 'wear' }) -> ['broken']
+     *   Object.keys({ broken: 'wear' }, function(key, value) {
+     *     // Called once for each key.
+     *   });
+     *   Object.extended({ broken: 'wear' }).keys() -> ['broken']
+     *
+     ***/
+    'keys': function(obj, fn) {
+      var keys = object.keys(obj);
+      keys.forEach(function(key) {
+        fn.call(obj, key, obj[key]);
+      });
+      return keys;
+    }
+
+  });
+
+  extend(object, false, false, {
+
+    'isObject': function(obj) {
+      return isObject(obj);
+    },
+
+    'isNaN': function(obj) {
+      // This is only true of NaN
+      return isNumber(obj) && obj.valueOf() !== obj.valueOf();
+    },
+
+    /***
+     * @method equal(<a>, <b>)
+     * @returns Boolean
+     * @short Returns true if <a> and <b> are equal.
+     * @extra %equal% in Sugar is "egal", meaning the values are equal if they are "not observably distinguishable". Note that on extended objects the name is %equals% for readability.
+     * @example
+     *
+     *   Object.equal({a:2}, {a:2}) -> true
+     *   Object.equal({a:2}, {a:3}) -> false
+     *   Object.extended({a:2}).equals({a:3}) -> false
+     *
+     ***/
+    'equal': function(a, b) {
+      return stringify(a) === stringify(b);
+    },
+
+    /***
+     * @method Object.extended(<obj> = {})
+     * @returns Extended object
+     * @short Creates a new object, equivalent to %new Object()% or %{}%, but with extended methods.
+     * @extra See extended objects for more.
+     * @example
+     *
+     *   Object.extended()
+     *   Object.extended({ happy:true, pappy:false }).keys() -> ['happy','pappy']
+     *   Object.extended({ happy:true, pappy:false }).values() -> [true, false]
+     *
+     ***/
+    'extended': function(obj) {
+      return new Hash(obj);
+    },
+
+    /***
+     * @method merge(<target>, <source>, [deep] = false, [resolve] = true)
+     * @returns Merged object
+     * @short Merges all the properties of <source> into <target>.
+     * @extra Merges are shallow unless [deep] is %true%. Properties of <source> will win in the case of conflicts, unless [resolve] is %false%. [resolve] can also be a function that resolves the conflict. In this case it will be passed 3 arguments, %key%, %targetVal%, and %sourceVal%, with the context set to <source>. This will allow you to solve conflict any way you want, ie. adding two numbers together, etc. %merge% is available as an instance method on extended objects.
+     * @example
+     *
+     *   Object.merge({a:1},{b:2}) -> { a:1, b:2 }
+     *   Object.merge({a:1},{a:2}, false, false) -> { a:1 }
+     +   Object.merge({a:1},{a:2}, false, function(key, a, b) {
+     *     return a + b;
+     *   }); -> { a:3 }
+     *   Object.extended({a:1}).merge({b:2}) -> { a:1, b:2 }
+     *
+     ***/
+    'merge': function(target, source, deep, resolve) {
+      var key, val;
+      // Strings cannot be reliably merged thanks to
+      // their properties not being enumerable in < IE8.
+      if(target && typeof source != 'string') {
+        for(key in source) {
+          if(!hasOwnProperty(source, key) || !target) continue;
+          val = source[key];
+          // Conflict!
+          if(isDefined(target[key])) {
+            // Do not merge.
+            if(resolve === false) {
+              continue;
+            }
+            // Use the result of the callback as the result.
+            if(isFunction(resolve)) {
+              val = resolve.call(source, key, target[key], source[key])
+            }
+          }
+          // Deep merging.
+          if(deep === true && val && isObjectPrimitive(val)) {
+            if(isDate(val)) {
+              val = new date(val.getTime());
+            } else if(isRegExp(val)) {
+              val = new regexp(val.source, getRegExpFlags(val));
+            } else {
+              if(!target[key]) target[key] = array.isArray(val) ? [] : {};
+              object.merge(target[key], source[key], deep, resolve);
+              continue;
+            }
+          }
+          target[key] = val;
+        }
+      }
+      return target;
+    },
+
+    /***
+     * @method values(<obj>, [fn])
+     * @returns Array
+     * @short Returns an array containing the values in <obj>. Optionally calls [fn] for each value.
+     * @extra Returned values are in no particular order. %values% is available as an instance method on extended objects.
+     * @example
+     *
+     *   Object.values({ broken: 'wear' }) -> ['wear']
+     *   Object.values({ broken: 'wear' }, function(value) {
+     *     // Called once for each value.
+     *   });
+     *   Object.extended({ broken: 'wear' }).values() -> ['wear']
+     *
+     ***/
+    'values': function(obj, fn) {
+      var values = [];
+      iterateOverObject(obj, function(k,v) {
+        values.push(v);
+        if(fn) fn.call(obj,v);
+      });
+      return values;
+    },
+
+    /***
+     * @method clone(<obj> = {}, [deep] = false)
+     * @returns Cloned object
+     * @short Creates a clone (copy) of <obj>.
+     * @extra Default is a shallow clone, unless [deep] is true. %clone% is available as an instance method on extended objects.
+     * @example
+     *
+     *   Object.clone({foo:'bar'})            -> { foo: 'bar' }
+     *   Object.clone()                       -> {}
+     *   Object.extended({foo:'bar'}).clone() -> { foo: 'bar' }
+     *
+     ***/
+    'clone': function(obj, deep) {
+      if(!isObjectPrimitive(obj)) return obj;
+      if(array.isArray(obj)) return obj.concat();
+      var target = obj instanceof Hash ? new Hash() : {};
+      return object.merge(target, obj, deep);
+    },
+
+    /***
+     * @method Object.fromQueryString(<str>, [deep] = true)
+     * @returns Object
+     * @short Converts the query string of a URL into an object.
+     * @extra If [deep] is %false%, conversion will only accept shallow params (ie. no object or arrays with %[]% syntax) as these are not universally supported.
+     * @example
+     *
+     *   Object.fromQueryString('foo=bar&broken=wear') -> { foo: 'bar', broken: 'wear' }
+     *   Object.fromQueryString('foo[]=1&foo[]=2')     -> { foo: [1,2] }
+     *
+     ***/
+    'fromQueryString': function(str, deep) {
+      var result = object.extended(), split;
+      str = str && str.toString ? str.toString() : '';
+      decodeURIComponent(str.replace(/^.*?\?/, '')).split('&').forEach(function(p) {
+        var split = p.split('=');
+        if(split.length !== 2) return;
+        setParamsObject(result, split[0], split[1], deep);
+      });
+      return result;
+    },
+
+    /***
+     * @method tap(<obj>, <fn>)
+     * @returns Object
+     * @short Runs <fn> and returns <obj>.
+     * @extra  A string can also be used as a shortcut to a method. This method is used to run an intermediary function in the middle of method chaining. As a standalone method on the Object class it doesn't have too much use. The power of %tap% comes when using extended objects or modifying the Object prototype with Object.extend().
+     * @example
+     *
+     *   Object.extend();
+     *   [2,4,6].map(Math.exp).tap(function(){ arr.pop(); }).map(Math.round); ->  [7,55]
+     *   [2,4,6].map(Math.exp).tap('pop').map(Math.round); ->  [7,55]
+     *
+     ***/
+    'tap': function(obj, arg) {
+      var fn = arg;
+      if(!isFunction(arg)) {
+        fn = function() {
+          if(arg) obj[arg]();
+        }
+      }
+      fn.call(obj, obj);
+      return obj;
+    },
+
+    /***
+     * @method has(<obj>, <key>)
+     * @returns Boolean
+     * @short Checks if <obj> has <key> using hasOwnProperty from Object.prototype.
+     * @extra This method is considered safer than %Object#hasOwnProperty% when using objects as hashes. See http://www.devthought.com/2012/01/18/an-object-is-not-a-hash/ for more.
+     * @example
+     *
+     *   Object.has({ foo: 'bar' }, 'foo') -> true
+     *   Object.has({ foo: 'bar' }, 'baz') -> false
+     *   Object.has({ hasOwnProperty: true }, 'foo') -> false
+     *
+     ***/
+    'has': function (obj, key) {
+      return hasOwnProperty(obj, key);
+    }
+
+  });
+
+
+  buildTypeMethods();
+  buildObjectExtend();
+  buildObjectInstanceMethods(ObjectHashMethods, Hash);
+

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

@@ -0,0 +1,92 @@
+
+  /***
+   * @package RegExp
+   * @dependency core
+   * @description Escaping regexes and manipulating their flags.
+   *
+   * Note here that methods on the RegExp class like .exec and .test will fail in the current version of SpiderMonkey being
+   * used by CouchDB when using shorthand regex notation like /foo/. This is the reason for the intermixed use of shorthand
+   * and compiled regexes here. If you're using JS in CouchDB, it is safer to ALWAYS compile your regexes from a string.
+   *
+   ***/
+
+  function uniqueRegExpFlags(flags) {
+    return flags.split('').sort().join('').replace(/([gimy])\1+/g, '$1');
+  }
+
+  extend(regexp, false, false, {
+
+   /***
+    * @method RegExp.escape(<str> = '')
+    * @returns String
+    * @short Escapes all RegExp tokens in a string.
+    * @example
+    *
+    *   RegExp.escape('really?')      -> 'really\?'
+    *   RegExp.escape('yes.')         -> 'yes\.'
+    *   RegExp.escape('(not really)') -> '\(not really\)'
+    *
+    ***/
+    'escape': function(str) {
+      return escapeRegExp(str);
+    }
+
+  });
+
+  extend(regexp, true, false, {
+
+   /***
+    * @method getFlags()
+    * @returns String
+    * @short Returns the flags of the regex as a string.
+    * @example
+    *
+    *   /texty/gim.getFlags('testy') -> 'gim'
+    *
+    ***/
+    'getFlags': function() {
+      return getRegExpFlags(this);
+    },
+
+   /***
+    * @method setFlags(<flags>)
+    * @returns RegExp
+    * @short Sets the flags on a regex and retuns a copy.
+    * @example
+    *
+    *   /texty/.setFlags('gim') -> now has global, ignoreCase, and multiline set
+    *
+    ***/
+    'setFlags': function(flags) {
+      return regexp(this.source, flags);
+    },
+
+   /***
+    * @method addFlag(<flag>)
+    * @returns RegExp
+    * @short Adds <flag> to the regex.
+    * @example
+    *
+    *   /texty/.addFlag('g') -> now has global flag set
+    *
+    ***/
+    'addFlag': function(flag) {
+      return this.setFlags(getRegExpFlags(this, flag));
+    },
+
+   /***
+    * @method removeFlag(<flag>)
+    * @returns RegExp
+    * @short Removes <flag> from the regex.
+    * @example
+    *
+    *   /texty/g.removeFlag('g') -> now has global flag removed
+    *
+    ***/
+    'removeFlag': function(flag) {
+      return this.setFlags(getRegExpFlags(this).replace(flag, ''));
+    }
+
+  });
+
+

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

@@ -0,0 +1,871 @@
+
+  /***
+   * @package String
+   * @dependency core
+   * @description String manupulation, escaping, encoding, truncation, and:conversion.
+   *
+   ***/
+
+  function getAcronym(word) {
+    var inflector = string.Inflector;
+    var word = inflector && inflector.acronyms[word];
+    if(isString(word)) {
+      return word;
+    }
+  }
+
+  function padString(str, p, left, right) {
+    var padding = string(p);
+    if(padding != p) {
+      padding = '';
+    }
+    if(!isNumber(left))  left = 1;
+    if(!isNumber(right)) right = 1;
+    return padding.repeat(left) + str + padding.repeat(right);
+  }
+
+  function chr(num) {
+    return string.fromCharCode(num);
+  }
+
+  var btoa, atob;
+
+  function buildBase64(key) {
+    if(this.btoa) {
+      btoa = this.btoa;
+      atob = this.atob;
+      return;
+    }
+    var base64reg = /[^A-Za-z0-9\+\/\=]/g;
+    btoa = function(str) {
+      var output = '';
+      var chr1, chr2, chr3;
+      var enc1, enc2, enc3, enc4;
+      var i = 0;
+      do {
+        chr1 = str.charCodeAt(i++);
+        chr2 = str.charCodeAt(i++);
+        chr3 = str.charCodeAt(i++);
+        enc1 = chr1 >> 2;
+        enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
+        enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
+        enc4 = chr3 & 63;
+        if (isNaN(chr2)) {
+          enc3 = enc4 = 64;
+        } else if (isNaN(chr3)) {
+          enc4 = 64;
+        }
+        output = output + key.charAt(enc1) + key.charAt(enc2) + key.charAt(enc3) + key.charAt(enc4);
+        chr1 = chr2 = chr3 = '';
+        enc1 = enc2 = enc3 = enc4 = '';
+      } while (i < str.length);
+      return output;
+    }
+    atob = function(input) {
+      var output = '';
+      var chr1, chr2, chr3;
+      var enc1, enc2, enc3, enc4;
+      var i = 0;
+      if(input.match(base64reg)) {
+        throw new Error('String contains invalid base64 characters');
+      }
+      input = input.replace(/[^A-Za-z0-9\+\/\=]/g, '');
+      do {
+        enc1 = key.indexOf(input.charAt(i++));
+        enc2 = key.indexOf(input.charAt(i++));
+        enc3 = key.indexOf(input.charAt(i++));
+        enc4 = key.indexOf(input.charAt(i++));
+        chr1 = (enc1 << 2) | (enc2 >> 4);
+        chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
+        chr3 = ((enc3 & 3) << 6) | enc4;
+        output = output + chr(chr1);
+        if (enc3 != 64) {
+          output = output + chr(chr2);
+        }
+        if (enc4 != 64) {
+          output = output + chr(chr3);
+        }
+        chr1 = chr2 = chr3 = '';
+        enc1 = enc2 = enc3 = enc4 = '';
+      } while (i < input.length);
+      return output;
+    }
+  }
+
+
+
+  extend(string, true, false, {
+
+     /***
+      * @method escapeRegExp()
+      * @returns String
+      * @short Escapes all RegExp tokens in the string.
+      * @example
+      *
+      *   'really?'.escapeRegExp()       -> 'really\?'
+      *   'yes.'.escapeRegExp()         -> 'yes\.'
+      *   '(not really)'.escapeRegExp() -> '\(not really\)'
+      *
+      ***/
+    'escapeRegExp': function() {
+      return escapeRegExp(this);
+    },
+
+     /***
+      * @method escapeURL([param] = false)
+      * @returns String
+      * @short Escapes characters in a string to make a valid URL.
+      * @extra If [param] is true, it will also escape valid URL characters for use as a URL parameter.
+      * @example
+      *
+      *   'http://foo.com/"bar"'.escapeURL()     -> 'http://foo.com/%22bar%22'
+      *   'http://foo.com/"bar"'.escapeURL(true) -> 'http%3A%2F%2Ffoo.com%2F%22bar%22'
+      *
+      ***/
+    'escapeURL': function(param) {
+      return param ? encodeURIComponent(this) : encodeURI(this);
+    },
+
+     /***
+      * @method unescapeURL([partial] = false)
+      * @returns String
+      * @short Restores escaped characters in a URL escaped string.
+      * @extra If [partial] is true, it will only unescape non-valid URL characters. [partial] is included here for completeness, but should very rarely be needed.
+      * @example
+      *
+      *   'http%3A%2F%2Ffoo.com%2Fthe%20bar'.unescapeURL()     -> 'http://foo.com/the bar'
+      *   'http%3A%2F%2Ffoo.com%2Fthe%20bar'.unescapeURL(true) -> 'http%3A%2F%2Ffoo.com%2Fthe bar'
+      *
+      ***/
+    'unescapeURL': function(param) {
+      return param ? decodeURI(this) : decodeURIComponent(this);
+    },
+
+     /***
+      * @method escapeHTML()
+      * @returns String
+      * @short Converts HTML characters to their entity equivalents.
+      * @example
+      *
+      *   '<p>some text</p>'.escapeHTML() -> '&lt;p&gt;some text&lt;/p&gt;'
+      *   'one & two'.escapeHTML()        -> 'one &amp; two'
+      *
+      ***/
+    'escapeHTML': function() {
+      return this.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+    },
+
+     /***
+      * @method unescapeHTML([partial] = false)
+      * @returns String
+      * @short Restores escaped HTML characters.
+      * @example
+      *
+      *   '&lt;p&gt;some text&lt;/p&gt;'.unescapeHTML() -> '<p>some text</p>'
+      *   'one &amp; two'.unescapeHTML()                -> 'one & two'
+      *
+      ***/
+    'unescapeHTML': function() {
+      return this.replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&amp;/g, '&');
+    },
+
+     /***
+      * @method encodeBase64()
+      * @returns String
+      * @short Encodes the string into base64 encoding.
+      * @extra This method wraps the browser native %btoa% when available, and uses a custom implementation when not available.
+      * @example
+      *
+      *   'gonna get encoded!'.encodeBase64()  -> 'Z29ubmEgZ2V0IGVuY29kZWQh'
+      *   'http://twitter.com/'.encodeBase64() -> 'aHR0cDovL3R3aXR0ZXIuY29tLw=='
+      *
+      ***/
+    'encodeBase64': function() {
+      return btoa(this);
+    },
+
+     /***
+      * @method decodeBase64()
+      * @returns String
+      * @short Decodes the string from base64 encoding.
+      * @extra This method wraps the browser native %atob% when available, and uses a custom implementation when not available.
+      * @example
+      *
+      *   'aHR0cDovL3R3aXR0ZXIuY29tLw=='.decodeBase64() -> 'http://twitter.com/'
+      *   'anVzdCBnb3QgZGVjb2RlZA=='.decodeBase64()     -> 'just got decoded!'
+      *
+      ***/
+    'decodeBase64': function() {
+      return atob(this);
+    },
+
+    /***
+     * @method each([search] = single character, [fn])
+     * @returns Array
+     * @short Runs callback [fn] against each occurence of [search].
+     * @extra Returns an array of matches. [search] may be either a string or regex, and defaults to every character in the string.
+     * @example
+     *
+     *   'jumpy'.each() -> ['j','u','m','p','y']
+     *   'jumpy'.each(/[r-z]/) -> ['u','y']
+     *   'jumpy'.each(/[r-z]/, function(m) {
+     *     // Called twice: "u", "y"
+     *   });
+     *
+     ***/
+    'each': function(search, fn) {
+      var match, i;
+      if(isFunction(search)) {
+        fn = search;
+        search = /[\s\S]/g;
+      } else if(!search) {
+        search = /[\s\S]/g
+      } else if(isString(search)) {
+        search = regexp(escapeRegExp(search), 'gi');
+      } else if(isRegExp(search)) {
+        search = regexp(search.source, getRegExpFlags(search, 'g'));
+      }
+      match = this.match(search) || [];
+      if(fn) {
+        for(i = 0; i < match.length; i++) {
+          match[i] = fn.call(this, match[i], i, match) || match[i];
+        }
+      }
+      return match;
+    },
+
+    /***
+     * @method shift(<n>)
+     * @returns Array
+     * @short Shifts each character in the string <n> places in the character map.
+     * @example
+     *
+     *   'a'.shift(1)  -> 'b'
+     *   'ク'.shift(1) -> 'グ'
+     *
+     ***/
+    'shift': function(n) {
+      var result = '';
+      n = n || 0;
+      this.codes(function(c) {
+        result += chr(c + n);
+      });
+      return result;
+    },
+
+    /***
+     * @method codes([fn])
+     * @returns Array
+     * @short Runs callback [fn] against each character code in the string. Returns an array of character codes.
+     * @example
+     *
+     *   'jumpy'.codes() -> [106,117,109,112,121]
+     *   'jumpy'.codes(function(c) {
+     *     // Called 5 times: 106, 117, 109, 112, 121
+     *   });
+     *
+     ***/
+    'codes': function(fn) {
+      var codes = [];
+      for(var i=0; i<this.length; i++) {
+        var code = this.charCodeAt(i);
+        codes.push(code);
+        if(fn) fn.call(this, code, i);
+      }
+      return codes;
+    },
+
+    /***
+     * @method chars([fn])
+     * @returns Array
+     * @short Runs callback [fn] against each character in the string. Returns an array of characters.
+     * @example
+     *
+     *   'jumpy'.chars() -> ['j','u','m','p','y']
+     *   'jumpy'.chars(function(c) {
+     *     // Called 5 times: "j","u","m","p","y"
+     *   });
+     *
+     ***/
+    'chars': function(fn) {
+      return this.each(fn);
+    },
+
+    /***
+     * @method words([fn])
+     * @returns Array
+     * @short Runs callback [fn] against each word in the string. Returns an array of words.
+     * @extra A "word" here is defined as any sequence of non-whitespace characters.
+     * @example
+     *
+     *   'broken wear'.words() -> ['broken','wear']
+     *   'broken wear'.words(function(w) {
+     *     // Called twice: "broken", "wear"
+     *   });
+     *
+     ***/
+    'words': function(fn) {
+      return this.trim().each(/\S+/g, fn);
+    },
+
+    /***
+     * @method lines([fn])
+     * @returns Array
+     * @short Runs callback [fn] against each line in the string. Returns an array of lines.
+     * @example
+     *
+     *   'broken wear\nand\njumpy jump'.lines() -> ['broken wear','and','jumpy jump']
+     *   'broken wear\nand\njumpy jump'.lines(function(l) {
+     *     // Called three times: "broken wear", "and", "jumpy jump"
+     *   });
+     *
+     ***/
+    'lines': function(fn) {
+      return this.trim().each(/^.*$/gm, fn);
+    },
+
+    /***
+     * @method paragraphs([fn])
+     * @returns Array
+     * @short Runs callback [fn] against each paragraph in the string. Returns an array of paragraphs.
+     * @extra A paragraph here is defined as a block of text bounded by two or more line breaks.
+     * @example
+     *
+     *   'Once upon a time.\n\nIn the land of oz...'.paragraphs() -> ['Once upon a time.','In the land of oz...']
+     *   'Once upon a time.\n\nIn the land of oz...'.paragraphs(function(p) {
+     *     // Called twice: "Once upon a time.", "In teh land of oz..."
+     *   });
+     *
+     ***/
+    'paragraphs': function(fn) {
+      var paragraphs = this.trim().split(/[\r\n]{2,}/);
+      paragraphs = paragraphs.map(function(p) {
+        if(fn) var s = fn.call(p);
+        return s ? s : p;
+      });
+      return paragraphs;
+    },
+
+    /***
+     * @method startsWith(<find>, [case] = true)
+     * @returns Boolean
+     * @short Returns true if the string starts with <find>.
+     * @extra <find> may be either a string or regex. Case sensitive if [case] is true.
+     * @example
+     *
+     *   'hello'.startsWith('hell')        -> true
+     *   'hello'.startsWith(/[a-h]/)       -> true
+     *   'hello'.startsWith('HELL')        -> false
+     *   'hello'.startsWith('HELL', false) -> true
+     *
+     ***/
+    'startsWith': function(reg, c) {
+      if(isUndefined(c)) c = true;
+      var source = isRegExp(reg) ? reg.source.replace('^', '') : escapeRegExp(reg);
+      return regexp('^' + source, c ? '' : 'i').test(this);
+    },
+
+    /***
+     * @method endsWith(<find>, [case] = true)
+     * @returns Boolean
+     * @short Returns true if the string ends with <find>.
+     * @extra <find> may be either a string or regex. Case sensitive if [case] is true.
+     * @example
+     *
+     *   'jumpy'.endsWith('py')         -> true
+     *   'jumpy'.endsWith(/[q-z]/)      -> true
+     *   'jumpy'.endsWith('MPY')        -> false
+     *   'jumpy'.endsWith('MPY', false) -> true
+     *
+     ***/
+    'endsWith': function(reg, c) {
+      if(isUndefined(c)) c = true;
+      var source = isRegExp(reg) ? reg.source.replace('$', '') : escapeRegExp(reg);
+      return regexp(source + '$', c ? '' : 'i').test(this);
+    },
+
+    /***
+     * @method isBlank()
+     * @returns Boolean
+     * @short Returns true if the string has a length of 0 or contains only whitespace.
+     * @example
+     *
+     *   ''.isBlank()      -> true
+     *   '   '.isBlank()   -> true
+     *   'noway'.isBlank() -> false
+     *
+     ***/
+    'isBlank': function() {
+      return this.trim().length === 0;
+    },
+
+    /***
+     * @method has(<find>)
+     * @returns Boolean
+     * @short Returns true if the string matches <find>.
+     * @extra <find> may be a string or regex.
+     * @example
+     *
+     *   'jumpy'.has('py')     -> true
+     *   'broken'.has(/[a-n]/) -> true
+     *   'broken'.has(/[s-z]/) -> false
+     *
+     ***/
+    'has': function(find) {
+      return this.search(isRegExp(find) ? find : escapeRegExp(find)) !== -1;
+    },
+
+
+    /***
+     * @method add(<str>, [index] = length)
+     * @returns String
+     * @short Adds <str> at [index]. Negative values are also allowed.
+     * @extra %insert% is provided as an alias, and is generally more readable when using an index.
+     * @example
+     *
+     *   'schfifty'.add(' five')      -> schfifty five
+     *   'dopamine'.insert('e', 3)       -> dopeamine
+     *   'spelling eror'.insert('r', -3) -> spelling error
+     *
+     ***/
+    'add': function(str, index) {
+      index = isUndefined(index) ? this.length : index;
+      return this.slice(0, index) + str + this.slice(index);
+    },
+
+    /***
+     * @method remove(<f>)
+     * @returns String
+     * @short Removes any part of the string that matches <f>.
+     * @extra <f> can be a string or a regex.
+     * @example
+     *
+     *   'schfifty five'.remove('f')     -> 'schity ive'
+     *   'schfifty five'.remove(/[a-f]/g) -> 'shity iv'
+     *
+     ***/
+    'remove': function(f) {
+      return this.replace(f, '');
+    },
+
+    /***
+     * @method reverse()
+     * @returns String
+     * @short Reverses the string.
+     * @example
+     *
+     *   'jumpy'.reverse()        -> 'ypmuj'
+     *   'lucky charms'.reverse() -> 'smrahc ykcul'
+     *
+     ***/
+    'reverse': function() {
+      return this.split('').reverse().join('');
+    },
+
+    /***
+     * @method compact()
+     * @returns String
+     * @short Compacts all white space in the string to a single space and trims the ends.
+     * @example
+     *
+     *   'too \n much \n space'.compact() -> 'too much space'
+     *   'enough \n '.compact()           -> 'enought'
+     *
+     ***/
+    'compact': function() {
+      return this.trim().replace(/([\r\n\s　])+/g, function(match, whitespace){
+        return whitespace === '　' ? whitespace : ' ';
+      });
+    },
+
+    /***
+     * @method at(<index>, [loop] = true)
+     * @returns String or Array
+     * @short Gets the character(s) at a given index.
+     * @extra When [loop] is true, overshooting the end of the string (or the beginning) will begin counting from the other end. As an alternate syntax, passing multiple indexes will get the characters at those indexes.
+     * @example
+     *
+     *   'jumpy'.at(0)               -> 'j'
+     *   'jumpy'.at(2)               -> 'm'
+     *   'jumpy'.at(5)               -> 'j'
+     *   'jumpy'.at(5, false)        -> ''
+     *   'jumpy'.at(-1)              -> 'y'
+     *   'lucky charms'.at(2,4,6,8) -> ['u','k','y',c']
+     *
+     ***/
+    'at': function() {
+      return entryAtIndex(this, arguments, true);
+    },
+
+    /***
+     * @method from([index] = 0)
+     * @returns String
+     * @short Returns a section of the string starting from [index].
+     * @example
+     *
+     *   'lucky charms'.from()   -> 'lucky charms'
+     *   'lucky charms'.from(7)  -> 'harms'
+     *
+     ***/
+    'from': function(num) {
+      return this.slice(num);
+    },
+
+    /***
+     * @method to([index] = end)
+     * @returns String
+     * @short Returns a section of the string ending at [index].
+     * @example
+     *
+     *   'lucky charms'.to()   -> 'lucky charms'
+     *   'lucky charms'.to(7)  -> 'lucky ch'
+     *
+     ***/
+    'to': function(num) {
+      if(isUndefined(num)) num = this.length;
+      return this.slice(0, num);
+    },
+
+    /***
+     * @method dasherize()
+     * @returns String
+     * @short Converts underscores and camel casing to hypens.
+     * @example
+     *
+     *   'a_farewell_to_arms'.dasherize() -> 'a-farewell-to-arms'
+     *   'capsLock'.dasherize()           -> 'caps-lock'
+     *
+     ***/
+    'dasherize': function() {
+      return this.underscore().replace(/_/g, '-');
+    },
+
+    /***
+     * @method underscore()
+     * @returns String
+     * @short Converts hyphens and camel casing to underscores.
+     * @example
+     *
+     *   'a-farewell-to-arms'.underscore() -> 'a_farewell_to_arms'
+     *   'capsLock'.underscore()           -> 'caps_lock'
+     *
+     ***/
+    'underscore': function() {
+      return this
+        .replace(/[-\s]+/g, '_')
+        .replace(string.Inflector && string.Inflector.acronymRegExp, function(acronym, index) {
+          return (index > 0 ? '_' : '') + acronym.toLowerCase();
+        })
+        .replace(/([A-Z\d]+)([A-Z][a-z])/g,'$1_$2')
+        .replace(/([a-z\d])([A-Z])/g,'$1_$2')
+        .toLowerCase();
+    },
+
+    /***
+     * @method camelize([first] = true)
+     * @returns String
+     * @short Converts underscores and hyphens to camel case. If [first] is true the first letter will also be capitalized.
+     * @extra If the Inflections package is included acryonyms can also be defined that will be used when camelizing.
+     * @example
+     *
+     *   'caps_lock'.camelize()              -> 'CapsLock'
+     *   'moz-border-radius'.camelize()      -> 'MozBorderRadius'
+     *   'moz-border-radius'.camelize(false) -> 'mozBorderRadius'
+     *
+     ***/
+    'camelize': function(first) {
+      return this.underscore().replace(/(^|_)([^_]+)/g, function(match, pre, word, index) {
+        var acronym = getAcronym(word), capitalize = first !== false || index > 0;
+        if(acronym) return capitalize ? acronym : acronym.toLowerCase();
+        return capitalize ? word.capitalize() : word;
+      });
+    },
+
+    /***
+     * @method spacify()
+     * @returns String
+     * @short Converts camel case, underscores, and hyphens to a properly spaced string.
+     * @example
+     *
+     *   'camelCase'.spacify()                         -> 'camel case'
+     *   'an-ugly-string'.spacify()                    -> 'an ugly string'
+     *   'oh-no_youDid-not'.spacify().capitalize(true) -> 'something else'
+     *
+     ***/
+    'spacify': function() {
+      return this.underscore().replace(/_/g, ' ');
+    },
+
+    /***
+     * @method stripTags([tag1], [tag2], ...)
+     * @returns String
+     * @short Strips all HTML tags from the string.
+     * @extra Tags to strip may be enumerated in the parameters, otherwise will strip all.
+     * @example
+     *
+     *   '<p>just <b>some</b> text</p>'.stripTags()    -> 'just some text'
+     *   '<p>just <b>some</b> text</p>'.stripTags('p') -> 'just <b>some</b> text'
+     *
+     ***/
+    'stripTags': function() {
+      var str = this, args = arguments.length > 0 ? arguments : [''];
+      multiArgs(args, function(tag) {
+        str = str.replace(regexp('<\/?' + escapeRegExp(tag) + '[^<>]*>', 'gi'), '');
+      });
+      return str;
+    },
+
+    /***
+     * @method removeTags([tag1], [tag2], ...)
+     * @returns String
+     * @short Removes all HTML tags and their contents from the string.
+     * @extra Tags to remove may be enumerated in the parameters, otherwise will remove all.
+     * @example
+     *
+     *   '<p>just <b>some</b> text</p>'.removeTags()    -> ''
+     *   '<p>just <b>some</b> text</p>'.removeTags('b') -> '<p>just text</p>'
+     *
+     ***/
+    'removeTags': function() {
+      var str = this, args = arguments.length > 0 ? arguments : ['\\S+'];
+      multiArgs(args, function(t) {
+        var reg = regexp('<(' + t + ')[^<>]*(?:\\/>|>.*?<\\/\\1>)', 'gi');
+        str = str.replace(reg, '');
+      });
+      return str;
+    },
+
+    /***
+     * @method truncate(<length>, [split] = true, [from] = 'right', [ellipsis] = '...')
+     * @returns Object
+     * @short Truncates a string.
+     * @extra If [split] is %false%, will not split words up, and instead discard the word where the truncation occurred. [from] can also be %"middle"% or %"left"%.
+     * @example
+     *
+     *   'just sittin on the dock of the bay'.truncate(20)                 -> 'just sittin on the do...'
+     *   'just sittin on the dock of the bay'.truncate(20, false)          -> 'just sittin on the...'
+     *   'just sittin on the dock of the bay'.truncate(20, true, 'middle') -> 'just sitt...of the bay'
+     *   'just sittin on the dock of the bay'.truncate(20, true, 'left')   -> '...the dock of the bay'
+     *
+     ***/
+    'truncate': function(length, split, from, ellipsis) {
+      var pos,
+        prepend = '',
+        append = '',
+        str = this.toString(),
+        chars = '[' + getTrimmableCharacters() + ']+',
+        space = '[^' + getTrimmableCharacters() + ']*',
+        reg = regexp(chars + space + '$');
+      ellipsis = isUndefined(ellipsis) ? '...' : string(ellipsis);
+      if(str.length <= length) {
+        return str;
+      }
+      switch(from) {
+        case 'left':
+          pos = str.length - length;
+          prepend = ellipsis;
+          str = str.slice(pos);
+          reg = regexp('^' + space + chars);
+          break;
+        case 'middle':
+          pos    = floor(length / 2);
+          append = ellipsis + str.slice(str.length - pos).trimLeft();
+          str    = str.slice(0, pos);
+          break;
+        default:
+          pos = length;
+          append = ellipsis;
+          str = str.slice(0, pos);
+      }
+      if(split === false && this.slice(pos, pos + 1).match(/\S/)) {
+        str = str.remove(reg);
+      }
+      return prepend + str + append;
+    },
+
+    /***
+     * @method pad[Side](<padding> = '', [num] = 1)
+     * @returns String
+     * @short Pads either/both sides of the string.
+     * @extra [num] is the number of characters on each side, and [padding] is the character to pad with.
+     *
+     * @set
+     *   pad
+     *   padLeft
+     *   padRight
+     *
+     * @example
+     *
+     *   'wasabi'.pad('-')         -> '-wasabi-'
+     *   'wasabi'.pad('-', 2)      -> '--wasabi--'
+     *   'wasabi'.padLeft('-', 2)  -> '--wasabi'
+     *   'wasabi'.padRight('-', 2) -> 'wasabi--'
+     *
+     ***/
+    'pad': function(padding, num) {
+      return repeatString(num, padding) + this + repeatString(num, padding);
+    },
+
+    'padLeft': function(padding, num) {
+      return repeatString(num, padding) + this;
+    },
+
+    'padRight': function(padding, num) {
+      return this + repeatString(num, padding);
+    },
+
+    /***
+     * @method first([n] = 1)
+     * @returns String
+     * @short Returns the first [n] characters of the string.
+     * @example
+     *
+     *   'lucky charms'.first()   -> 'l'
+     *   'lucky charms'.first(3)  -> 'luc'
+     *
+     ***/
+    'first': function(num) {
+      if(isUndefined(num)) num = 1;
+      return this.substr(0, num);
+    },
+
+    /***
+     * @method last([n] = 1)
+     * @returns String
+     * @short Returns the last [n] characters of the string.
+     * @example
+     *
+     *   'lucky charms'.last()   -> 's'
+     *   'lucky charms'.last(3)  -> 'rms'
+     *
+     ***/
+    'last': function(num) {
+      if(isUndefined(num)) num = 1;
+      var start = this.length - num < 0 ? 0 : this.length - num;
+      return this.substr(start);
+    },
+
+    /***
+     * @method repeat([num] = 0)
+     * @returns String
+     * @short Returns the string repeated [num] times.
+     * @example
+     *
+     *   'jumpy'.repeat(2) -> 'jumpyjumpy'
+     *   'a'.repeat(5)     -> 'aaaaa'
+     *
+     ***/
+    'repeat': function(num) {
+      var str = '', i = 0;
+      if(isNumber(num) && num > 0) {
+        while(i < num) {
+          str += this;
+          i++;
+        }
+      }
+      return str;
+    },
+
+    /***
+     * @method toNumber([base] = 10)
+     * @returns Number
+     * @short Converts the string into a number.
+     * @extra Any value with a "." fill be converted to a floating point value, otherwise an integer.
+     * @example
+     *
+     *   '153'.toNumber()    -> 153
+     *   '12,000'.toNumber() -> 12000
+     *   '10px'.toNumber()   -> 10
+     *   'ff'.toNumber(16)   -> 255
+     *
+     ***/
+    'toNumber': function(base) {
+      var str = this.replace(/,/g, '');
+      return str.match(/\./) ? parseFloat(str) : parseInt(str, base || 10);
+    },
+
+    /***
+     * @method capitalize([all] = false)
+     * @returns String
+     * @short Capitalizes the first character in the string.
+     * @extra If [all] is true, all words in the string will be capitalized.
+     * @example
+     *
+     *   'hello'.capitalize()           -> 'Hello'
+     *   'hello kitty'.capitalize()     -> 'Hello kitty'
+     *   'hello kitty'.capitalize(true) -> 'Hello Kitty'
+     *
+     *
+     ***/
+    'capitalize': function(all) {
+      var lastResponded;
+      return this.toLowerCase().replace(all ? /[\s\S]/g : /^\S/, function(lower) {
+        var upper = lower.toUpperCase(), result;
+        result = lastResponded ? lower : upper;
+        lastResponded = upper !== lower;
+        return result;
+      });
+    },
+
+    /***
+     * @method assign(<obj1>, <obj2>, ...)
+     * @returns String
+     * @short Assigns variables to tokens in a string.
+     * @extra If an object is passed, it's properties can be assigned using the object's keys. If a non-object (string, number, etc.) is passed it can be accessed by the argument number beginning with 1 (as with regex tokens). Multiple objects can be passed and will be merged together (original objects are unaffected).
+     * @example
+     *
+     *   'Welcome, Mr. {name}.'.assign({ name: 'Franklin' })   -> 'Welcome, Mr. Franklin.'
+     *   'You are {1} years old today.'.assign(14)             -> 'You are 14 years old today.'
+     *   '{n} and {r}'.assign({ n: 'Cheech' }, { r: 'Chong' }) -> 'Cheech and Chong'
+     *
+     ***/
+    'assign': function() {
+      var assign = {};
+      multiArgs(arguments, function(a, i) {
+        if(isObject(a)) {
+          simpleMerge(assign, a);
+        } else {
+          assign[i + 1] = a;
+        }
+      });
+      return this.replace(/\{([^{]+?)\}/g, function(m, key) {
+        return hasOwnProperty(assign, key) ? assign[key] : m;
+      });
+    },
+
+    /***
+     * @method namespace([init] = global)
+     * @returns Mixed
+     * @short Finds the namespace or property indicated by the string.
+     * @extra [init] can be passed to provide a starting context, otherwise the global context will be used. If any level returns a falsy value, that will be the final result.
+     * @example
+     *
+     *   'Path.To.Namespace'.namespace() -> Path.To.Namespace
+     *   '$.fn'.namespace()              -> $.fn
+     *
+     ***/
+    'namespace': function(context) {
+      context = context || globalContext;
+      iterateOverObject(this.split('.'), function(i,s) {
+          return !!(context = context[s]);
+      });
+      return context;
+    }
+
+  });
+
+
+  // Aliases
+
+  extend(string, true, false, {
+
+    /***
+     * @method insert()
+     * @alias add
+     *
+     ***/
+    'insert': string.prototype.add
+  });
+
+  buildBase64('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=');
+