extjs-rails 4.1.0.alpha5 → 4.1.0.alpha6

data/app/assets/javascripts/src/core/src/lang/String.js

@@ -1,333 +0,0 @@
-/**
- * @class Ext.String
- *
- * A collection of useful static methods to deal with strings
- * @singleton
- */
-
-Ext.String = (function() {
-    var trimRegex     = /^[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000]+|[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000]+$/g,
-        escapeRe      = /('|\\)/g,
-        formatRe      = /\{(\d+)\}/g,
-        escapeRegexRe = /([-.*+?\^${}()|\[\]\/\\])/g,
-        basicTrimRe   = /^\s+|\s+$/g,
-        whitespaceRe  = /\s+/,
-        varReplace    = /(^[^a-z]*|[^\w])/gi,
-        charToEntity,
-        entityToChar,
-        charToEntityRegex,
-        entityToCharRegex,
-        htmlEncodeReplaceFn = function(match, capture) {
-            return charToEntity[capture];
-        },
-        htmlDecodeReplaceFn = function(match, capture) {
-            return (capture in entityToChar) ? entityToChar[capture] : String.fromCharCode(parseInt(capture.substr(2), 10));
-        };
-
-    return {
-
-        /**
-         * Converts a string of characters into a legal, parseable Javascript `var` name as long as the passed
-         * string contains at least one alphabetic character. Non alphanumeric characters, and *leading* non alphabetic
-         * characters will be removed.
-         * @param {String} s A string to be converted into a `var` name.
-         * @return {String} A legal Javascript `var` name.
-         */
-        createVarName: function(s) {
-            return s.replace(varReplace, '');
-        },
-
-        /**
-         * Convert certain characters (&, <, >, ', and ") to their HTML character equivalents for literal display in web pages.
-         * @param {String} value The string to encode
-         * @return {String} The encoded text
-         * @method
-         */
-        htmlEncode: function(value) {
-            return (!value) ? value : String(value).replace(charToEntityRegex, htmlEncodeReplaceFn);
-        },
-
-        /**
-         * Convert certain characters (&, <, >, ', and ") from their HTML character equivalents.
-         * @param {String} value The string to decode
-         * @return {String} The decoded text
-         * @method
-         */
-        htmlDecode: function(value) {
-            return (!value) ? value : String(value).replace(entityToCharRegex, htmlDecodeReplaceFn);
-        },
-
-        /**
-         * Adds a set of character entity definitions to the set used by
-         * {@link Ext.String#htmlEncode} and {@link Ext.String#htmlDecode}.
-         *
-         * This object should be keyed by the entity name sequence,
-         * with the value being the textual representation of the entity.
-         *
-         *      Ext.String.addCharacterEntities({
-         *          '&amp;Uuml;':'Ü',
-         *          '&amp;ccedil;':'ç',
-         *          '&amp;ntilde;':'ñ',
-         *          '&amp;egrave;':'è'
-         *      });
-         *      var s = Ext.String.htmlEncode("A string with entities: èÜçñ");
-         *
-         * Note: the values of the character entites defined on this object are expected
-         * to be single character values.  As such, the actual values represented by the
-         * characters are sensitive to the character encoding of the javascript source
-         * file when defined in string literal form. Script tasgs referencing server
-         * resources with character entities must ensure that the 'charset' attribute
-         * of the script node is consistent with the actual character encoding of the
-         * server resource.
-         *
-         * The set of character entities may be reset back to the default state by using
-         * the {@link Ext.String#resetCharacterEntities} method
-         *
-         * @param {Object} entities The set of character entities to add to the current
-         * definitions.
-         */
-        addCharacterEntities: function(newEntities) {
-            var charKeys = [],
-                entityKeys = [],
-                key, echar;
-            for (key in newEntities) {
-                echar = newEntities[key];
-                entityToChar[key] = echar;
-                charToEntity[echar] = key;
-                charKeys.push(echar);
-                entityKeys.push(key);
-            }
-            charToEntityRegex = new RegExp('(' + charKeys.join('|') + ')', 'g');
-            entityToCharRegex = new RegExp('(' + entityKeys.join('|') + '|&#[0-9]{1,5};' + ')', 'g');
-        },
-
-        /**
-         * Resets the set of character entity definitions used by
-         * {@link Ext.String#htmlEncode} and {@link Ext.String#htmlDecode} back to the
-         * default state.
-         */
-        resetCharacterEntities: function() {
-            charToEntity = {};
-            entityToChar = {};
-            // add the default set
-            this.addCharacterEntities({
-                '&amp;'     :   '&',
-                '&gt;'      :   '>',
-                '&lt;'      :   '<',
-                '&quot;'    :   '"',
-                '&#39;'     :   "'"
-            });
-        },
-
-        /**
-         * Appends content to the query string of a URL, handling logic for whether to place
-         * a question mark or ampersand.
-         * @param {String} url The URL to append to.
-         * @param {String} string The content to append to the URL.
-         * @return {String} The resulting URL
-         */
-        urlAppend : function(url, string) {
-            if (!Ext.isEmpty(string)) {
-                return url + (url.indexOf('?') === -1 ? '?' : '&') + string;
-            }
-
-            return url;
-        },
-
-        /**
-         * Trims whitespace from either end of a string, leaving spaces within the string intact.  Example:
-         * @example
-    var s = '  foo bar  ';
-    alert('-' + s + '-');         //alerts "- foo bar -"
-    alert('-' + Ext.String.trim(s) + '-');  //alerts "-foo bar-"
-
-         * @param {String} string The string to escape
-         * @return {String} The trimmed string
-         */
-        trim: function(string) {
-            return string.replace(trimRegex, "");
-        },
-
-        /**
-         * Capitalize the given string
-         * @param {String} string
-         * @return {String}
-         */
-        capitalize: function(string) {
-            return string.charAt(0).toUpperCase() + string.substr(1);
-        },
-
-        /**
-         * Uncapitalize the given string
-         * @param {String} string
-         * @return {String}
-         */
-        uncapitalize: function(string) {
-            return string.charAt(0).toLowerCase() + string.substr(1);
-        },
-
-        /**
-         * Truncate a string and add an ellipsis ('...') to the end if it exceeds the specified length
-         * @param {String} value The string to truncate
-         * @param {Number} length The maximum length to allow before truncating
-         * @param {Boolean} word True to try to find a common word break
-         * @return {String} The converted text
-         */
-        ellipsis: function(value, len, word) {
-            if (value && value.length > len) {
-                if (word) {
-                    var vs = value.substr(0, len - 2),
-                    index = Math.max(vs.lastIndexOf(' '), vs.lastIndexOf('.'), vs.lastIndexOf('!'), vs.lastIndexOf('?'));
-                    if (index !== -1 && index >= (len - 15)) {
-                        return vs.substr(0, index) + "...";
-                    }
-                }
-                return value.substr(0, len - 3) + "...";
-            }
-            return value;
-        },
-
-        /**
-         * Escapes the passed string for use in a regular expression
-         * @param {String} string
-         * @return {String}
-         */
-        escapeRegex: function(string) {
-            return string.replace(escapeRegexRe, "\\$1");
-        },
-
-        /**
-         * Escapes the passed string for ' and \
-         * @param {String} string The string to escape
-         * @return {String} The escaped string
-         */
-        escape: function(string) {
-            return string.replace(escapeRe, "\\$1");
-        },
-
-        /**
-         * Utility function that allows you to easily switch a string between two alternating values.  The passed value
-         * is compared to the current string, and if they are equal, the other value that was passed in is returned.  If
-         * they are already different, the first value passed in is returned.  Note that this method returns the new value
-         * but does not change the current string.
-         * <pre><code>
-        // alternate sort directions
-        sort = Ext.String.toggle(sort, 'ASC', 'DESC');
-
-        // instead of conditional logic:
-        sort = (sort == 'ASC' ? 'DESC' : 'ASC');
-           </code></pre>
-         * @param {String} string The current string
-         * @param {String} value The value to compare to the current string
-         * @param {String} other The new value to use if the string already equals the first value passed in
-         * @return {String} The new value
-         */
-        toggle: function(string, value, other) {
-            return string === value ? other : value;
-        },
-
-        /**
-         * Pads the left side of a string with a specified character.  This is especially useful
-         * for normalizing number and date strings.  Example usage:
-         *
-         * <pre><code>
-    var s = Ext.String.leftPad('123', 5, '0');
-    // s now contains the string: '00123'
-           </code></pre>
-         * @param {String} string The original string
-         * @param {Number} size The total length of the output string
-         * @param {String} character (optional) The character with which to pad the original string (defaults to empty string " ")
-         * @return {String} The padded string
-         */
-        leftPad: function(string, size, character) {
-            var result = String(string);
-            character = character || " ";
-            while (result.length < size) {
-                result = character + result;
-            }
-            return result;
-        },
-
-        /**
-         * Allows you to define a tokenized string and pass an arbitrary number of arguments to replace the tokens.  Each
-         * token must be unique, and must increment in the format {0}, {1}, etc.  Example usage:
-         * <pre><code>
-    var cls = 'my-class', text = 'Some text';
-    var s = Ext.String.format('&lt;div class="{0}">{1}&lt;/div>', cls, text);
-    // s now contains the string: '&lt;div class="my-class">Some text&lt;/div>'
-           </code></pre>
-         * @param {String} string The tokenized string to be formatted
-         * @param {String} value1 The value to replace token {0}
-         * @param {String} value2 Etc...
-         * @return {String} The formatted string
-         */
-        format: function(format) {
-            var args = Ext.Array.toArray(arguments, 1);
-            return format.replace(formatRe, function(m, i) {
-                return args[i];
-            });
-        },
-
-        /**
-         * Returns a string with a specified number of repititions a given string pattern.
-         * The pattern be separated by a different string.
-         *
-         *      var s = Ext.String.repeat('---', 4); // = '------------'
-         *      var t = Ext.String.repeat('--', 3, '/'); // = '--/--/--'
-         *
-         * @param {String} pattern The pattern to repeat.
-         * @param {Number} count The number of times to repeat the pattern (may be 0).
-         * @param {String} sep An option string to separate each pattern.
-         */
-        repeat: function(pattern, count, sep) {
-            for (var buf = [], i = count; i--; ) {
-                buf.push(pattern);
-            }
-            return buf.join(sep || '');
-        },
-
-        /**
-         * Splits a string of space separated words into an array, trimming as needed. If the
-         * words are already an array, it is returned.
-         *
-         * @param {String/Array} words
-         */
-        splitWords: function (words) {
-            if (words && typeof words == 'string') {
-                return words.replace(basicTrimRe, '').split(whitespaceRe);
-            }
-            return words || [];
-        }
-    };
-}());
-
-// initialize the default encode / decode entities
-Ext.String.resetCharacterEntities();
-
-/**
- * Old alias to {@link Ext.String#htmlEncode}
- * @deprecated Use {@link Ext.String#htmlEncode} instead
- * @method
- * @member Ext
- * @inheritdoc Ext.String#htmlEncode
- */
-Ext.htmlEncode = Ext.String.htmlEncode;
-
-
-/**
- * Old alias to {@link Ext.String#htmlDecode}
- * @deprecated Use {@link Ext.String#htmlDecode} instead
- * @method
- * @member Ext
- * @inheritdoc Ext.String#htmlDecode
- */
-Ext.htmlDecode = Ext.String.htmlDecode;
-
-/**
- * Old alias to {@link Ext.String#urlAppend}
- * @deprecated Use {@link Ext.String#urlAppend} instead
- * @method
- * @member Ext
- * @inheritdoc Ext.String#urlAppend
- */
-Ext.urlAppend = Ext.String.urlAppend;

data/app/assets/javascripts/src/core/src/misc/JSON.js

@@ -1,236 +0,0 @@
-/**
- * @class Ext.JSON
- * Modified version of Douglas Crockford's JSON.js that doesn't
- * mess with the Object prototype
- * http://www.json.org/js.html
- * @singleton
- */
-Ext.JSON = (new(function() {
-    var me = this,
-    encodingFunction,
-    decodingFunction,
-    useNative = null,
-    useHasOwn = !! {}.hasOwnProperty,
-    isNative = function() {
-        if (useNative === null) {
-            useNative = Ext.USE_NATIVE_JSON && window.JSON && JSON.toString() == '[object JSON]';
-        }
-        return useNative;
-    },
-    pad = function(n) {
-        return n < 10 ? "0" + n : n;
-    },
-    doDecode = function(json) {
-        return eval("(" + json + ')');
-    },
-    doEncode = function(o, newline) {
-        // http://jsperf.com/is-undefined
-        if (o === null || o === undefined) {
-            return "null";
-        } else if (Ext.isDate(o)) {
-            return Ext.JSON.encodeDate(o);
-        } else if (Ext.isString(o)) {
-            return encodeString(o);
-        } else if (typeof o == "number") {
-            //don't use isNumber here, since finite checks happen inside isNumber
-            return isFinite(o) ? String(o) : "null";
-        } else if (Ext.isBoolean(o)) {
-            return String(o);
-        }
-        // Allow custom zerialization by adding a toJSON method to any object type.
-        // Date/String have a toJSON in some environments, so check these first.
-        else if (o.toJSON) {
-            return o.toJSON();
-        } else if (Ext.isArray(o)) {
-            return encodeArray(o, newline);
-        } else if (Ext.isObject(o)) {
-            return encodeObject(o, newline);
-        } else if (typeof o === "function") {
-            return "null";
-        }
-        return 'undefined';
-    },
-    m = {
-        "\b": '\\b',
-        "\t": '\\t',
-        "\n": '\\n',
-        "\f": '\\f',
-        "\r": '\\r',
-        '"': '\\"',
-        "\\": '\\\\',
-        '\x0b': '\\u000b' //ie doesn't handle \v
-    },
-    charToReplace = /[\\\"\x00-\x1f\x7f-\uffff]/g,
-    encodeString = function(s) {
-        return '"' + s.replace(charToReplace, function(a) {
-            var c = m[a];
-            return typeof c === 'string' ? c : '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
-        }) + '"';
-    },
-
-    //<debug>
-    encodeArrayPretty = function(o, newline) {
-        var len = o.length,
-            cnewline = newline + '   ',
-            sep = ',' + cnewline,
-            a = ["[", cnewline], // Note newline in case there are no members
-            i;
-
-        for (i = 0; i < len; i += 1) {
-            a.push(doEncode(o[i], cnewline), sep);
-        }
-
-        // Overwrite trailing comma (or empty string)
-        a[a.length - 1] = newline + ']';
-
-        return a.join('');
-    },
-
-    encodeObjectPretty = function(o, newline) {
-        var cnewline = newline + '   ',
-            sep = ',' + cnewline,
-            a = ["{", cnewline], // Note newline in case there are no members
-            i;
-
-        for (i in o) {
-            if (!useHasOwn || o.hasOwnProperty(i)) {
-                a.push(doEncode(i) + ': ' + doEncode(o[i], cnewline), sep);
-            }
-        }
-
-        // Overwrite trailing comma (or empty string)
-        a[a.length - 1] = newline + '}';
-
-        return a.join('');
-    },
-    //</debug>
-
-    encodeArray = function(o, newline) {
-        //<debug>
-        if (newline) {
-            return encodeArrayPretty(o, newline);
-        }
-        //</debug>
-
-        var a = ["[", ""], // Note empty string in case there are no serializable members.
-            len = o.length,
-            i;
-        for (i = 0; i < len; i += 1) {
-            a.push(doEncode(o[i]), ',');
-        }
-        // Overwrite trailing comma (or empty string)
-        a[a.length - 1] = ']';
-        return a.join("");
-    },
-
-    encodeObject = function(o, newline) {
-        //<debug>
-        if (newline) {
-            return encodeObjectPretty(o, newline);
-        }
-        //</debug>
-
-        var a = ["{", ""], // Note empty string in case there are no serializable members.
-            i;
-        for (i in o) {
-            if (!useHasOwn || o.hasOwnProperty(i)) {
-                a.push(doEncode(i), ":", doEncode(o[i]), ',');
-            }
-        }
-        // Overwrite trailing comma (or empty string)
-        a[a.length - 1] = '}';
-        return a.join("");
-    };
-
-    /**
-     * The function which {@link #encode} uses to encode all javascript values to their JSON representations
-     * when {@link Ext#USE_NATIVE_JSON} is `false`.
-     * 
-     * This is made public so that it can be replaced with a custom implementation.
-     *
-     * @param {Object} o Any javascript value to be converted to its JSON representation
-     * @return {String} The JSON representation of the passed value.
-     * @method
-     */
-    me.encodeValue = doEncode;
-
-    /**
-     * Encodes a Date. This returns the actual string which is inserted into the JSON string as the literal expression.
-     * **The returned value includes enclosing double quotation marks.**
-     *
-     * The default return format is "yyyy-mm-ddThh:mm:ss".
-     *
-     * To override this:
-     *    Ext.JSON.encodeDate = function(d) {
-     *        return Ext.Date.format(d, '"Y-m-d"');
-     *    };
-     *
-     * @param {Date} d The Date to encode
-     * @return {String} The string literal to use in a JSON string.
-     */
-    me.encodeDate = function(o) {
-        return '"' + o.getFullYear() + "-"
-        + pad(o.getMonth() + 1) + "-"
-        + pad(o.getDate()) + "T"
-        + pad(o.getHours()) + ":"
-        + pad(o.getMinutes()) + ":"
-        + pad(o.getSeconds()) + '"';
-    };
-
-    /**
-     * Encodes an Object, Array or other value.
-     * 
-     * If the environment's native JSON encoding is not being used ({@link Ext#USE_NATIVE_JSON} is not set, or the environment does not support it), then 
-     * ExtJS's encoding will be used. This allows the developer to add a `toJSON` method to their classes which need serializing to return a valid
-     * JSON representation of the object.
-     * 
-     * @param {Object} o The variable to encode
-     * @return {String} The JSON string
-     */
-    me.encode = function(o) {
-        if (!encodingFunction) {
-            // setup encoding function on first access
-            encodingFunction = isNative() ? JSON.stringify : me.encodeValue;
-        }
-        return encodingFunction(o);
-    };
-
-    /**
-     * Decodes (parses) a JSON string to an object. If the JSON is invalid, this function throws a SyntaxError unless the safe option is set.
-     * @param {String} json The JSON string
-     * @param {Boolean} safe (optional) Whether to return null or throw an exception if the JSON is invalid.
-     * @return {Object} The resulting object
-     */
-    me.decode = function(json, safe) {
-        if (!decodingFunction) {
-            // setup decoding function on first access
-            decodingFunction = isNative() ? JSON.parse : doDecode;
-        }
-        try {
-            return decodingFunction(json);
-        } catch (e) {
-            if (safe === true) {
-                return null;
-            }
-            Ext.Error.raise({
-                sourceClass: "Ext.JSON",
-                sourceMethod: "decode",
-                msg: "You're trying to decode an invalid JSON String: " + json
-            });
-        }
-    };
-})());
-/**
- * Shorthand for {@link Ext.JSON#encode}
- * @member Ext
- * @method encode
- * @inheritdoc Ext.JSON#encode
- */
-Ext.encode = Ext.JSON.encode;
-/**
- * Shorthand for {@link Ext.JSON#decode}
- * @member Ext
- * @method decode
- * @inheritdoc Ext.JSON#decode
- */
-Ext.decode = Ext.JSON.decode;