add extjs 6.0.1 sources

[extjs.git] / extjs / packages / core / src / util / Format.js

/**\r
 * @class Ext.util.Format\r
 *  \r
 * This class is a centralized place for formatting functions. It includes\r
 * functions to format various different types of data, such as text, dates and numeric values.\r
 *  \r
 * ## Localization\r
 *\r
 * This class contains several options for localization. These can be set once the library has loaded,\r
 * all calls to the functions from that point will use the locale settings that were specified.\r
 *\r
 * Options include:\r
 *\r
 * - thousandSeparator\r
 * - decimalSeparator\r
 * - currenyPrecision\r
 * - currencySign\r
 * - currencyAtEnd\r
 *\r
 * This class also uses the default date format defined here: {@link Ext.Date#defaultFormat}.\r
 *\r
 * ## Using with renderers\r
 *\r
 * There are two helper functions that return a new function that can be used in conjunction with\r
 * grid renderers:\r
 *  \r
 *     columns: [{\r
 *         dataIndex: 'date',\r
 *         renderer: Ext.util.Format.dateRenderer('Y-m-d')\r
 *     }, {\r
 *         dataIndex: 'time',\r
 *         renderer: Ext.util.Format.numberRenderer('0.000')\r
 *     }]\r
 *  \r
 * Functions that only take a single argument can also be passed directly:\r
 *\r
 *     columns: [{\r
 *         dataIndex: 'cost',\r
 *         renderer: Ext.util.Format.usMoney\r
 *     }, {\r
 *         dataIndex: 'productCode',\r
 *         renderer: Ext.util.Format.uppercase\r
 *     }]\r
 *  \r
 * ## Using with XTemplates\r
 *\r
 * XTemplates can also directly use Ext.util.Format functions:\r
 *  \r
 *     new Ext.XTemplate([\r
 *         'Date: {startDate:date("Y-m-d")}',\r
 *         'Cost: {cost:usMoney}'\r
 *     ]);\r
 *\r
 * @singleton\r
 */\r
Ext.define('Ext.util.Format', function () {\r
    var me; // holds our singleton instance\r
\r
    return {\r
        requires: [\r
            'Ext.Error',\r
            'Ext.Number',\r
            'Ext.String',\r
            'Ext.Date'\r
        ],\r
\r
        singleton: true,\r
\r
        /**\r
         * The global default date format.\r
         */\r
        defaultDateFormat: 'm/d/Y',\r
\r
        //<locale>\r
        /**\r
         * @property {String} thousandSeparator\r
         * The character that the {@link #number} function uses as a thousand separator.\r
         *\r
         * This may be overridden in a locale file.\r
         */\r
        thousandSeparator: ',',\r
        //</locale>\r
\r
        //<locale>\r
        /**\r
         * @property {String} decimalSeparator\r
         * The character that the {@link #number} function uses as a decimal point.\r
         *\r
         * This may be overridden in a locale file.\r
         */\r
        decimalSeparator: '.',\r
        //</locale>\r
\r
        //<locale>\r
        /**\r
         * @property {Number} currencyPrecision\r
         * The number of decimal places that the {@link #currency} function displays.\r
         *\r
         * This may be overridden in a locale file.\r
         */\r
        currencyPrecision: 2,\r
        //</locale>\r
\r
         //<locale>\r
        /**\r
         * @property {String} currencySign\r
         * The currency sign that the {@link #currency} function displays.\r
         *\r
         * This may be overridden in a locale file.\r
         */\r
        currencySign: '$',\r
        //</locale>\r
\r
        /**\r
         * @property {String} percentSign\r
         * The percent sign that the {@link #percent} function displays.\r
         *\r
         * This may be overridden in a locale file.\r
         */\r
        percentSign: '%',\r
\r
        //<locale>\r
        /**\r
         * @property {Boolean} currencyAtEnd\r
         * This may be set to <code>true</code> to make the {@link #currency} function\r
         * append the currency sign to the formatted value.\r
         *\r
         * This may be overridden in a locale file.\r
         */\r
        currencyAtEnd: false,\r
        //</locale>\r
\r
        stripTagsRe: /<\/?[^>]+>/gi,\r
        stripScriptsRe: /(?:<script.*?>)((\n|\r|.)*?)(?:<\/script>)/ig,\r
        nl2brRe: /\r?\n/g,\r
        hashRe: /#+$/,\r
        allHashes: /^#+$/,\r
\r
        // Match a format string characters to be able to detect remaining "literal" characters\r
        formatPattern: /[\d,\.#]+/,\r
\r
        // A RegExp to remove from a number format string, all characters except digits and '.'\r
        formatCleanRe: /[^\d\.#]/g,\r
\r
        // A RegExp to remove from a number format string, all characters except digits and the local decimal separator.\r
        // Created on first use. The local decimal separator character must be initialized for this to be created.\r
        I18NFormatCleanRe: null,\r
\r
        // Cache ofg number formatting functions keyed by format string\r
        formatFns: {},\r
\r
        constructor: function () {\r
            me = this; // we are a singleton, so cache our this pointer in scope\r
        },\r
\r
        /**\r
         * Checks a reference and converts it to empty string if it is undefined.\r
         * @param {Object} value Reference to check\r
         * @return {Object} Empty string if converted, otherwise the original value\r
         */\r
        undef : function(value) {\r
            return value !== undefined ? value : "";\r
        },\r
\r
        /**\r
         * Checks a reference and converts it to the default value if it's empty.\r
         * @param {Object} value Reference to check\r
         * @param {String} [defaultValue=""] The value to insert of it's undefined.\r
         * @return {String}\r
         */\r
        defaultValue : function(value, defaultValue) {\r
            return value !== undefined && value !== '' ? value : defaultValue;\r
        },\r
\r
        /**\r
         * Returns a substring from within an original string.\r
         * @param {String} value The original text\r
         * @param {Number} start The start index of the substring\r
         * @param {Number} length The length of the substring\r
         * @return {String} The substring\r
         * @method\r
         */\r
        substr : 'ab'.substr(-1) != 'b'\r
        ? function (value, start, length) {\r
            var str = String(value);\r
            return (start < 0)\r
                ? str.substr(Math.max(str.length + start, 0), length)\r
                : str.substr(start, length);\r
        }\r
        : function(value, start, length) {\r
            return String(value).substr(start, length);\r
        },\r
\r
        /**\r
         * Converts a string to all lower case letters.\r
         * @param {String} value The text to convert\r
         * @return {String} The converted text\r
         */\r
        lowercase : function(value) {\r
            return String(value).toLowerCase();\r
        },\r
\r
        /**\r
         * Converts a string to all upper case letters.\r
         * @param {String} value The text to convert\r
         * @return {String} The converted text\r
         */\r
        uppercase : function(value) {\r
            return String(value).toUpperCase();\r
        },\r
\r
        /**\r
         * Format a number as US currency.\r
         * @param {Number/String} value The numeric value to format\r
         * @return {String} The formatted currency string\r
         */\r
        usMoney : function(v) {\r
            return me.currency(v, '$', 2);\r
        },\r
\r
        /**\r
         * Format a number as a currency.\r
         * @param {Number/String} value The numeric value to format\r
         * @param {String} [sign] The currency sign to use (defaults to {@link #currencySign})\r
         * @param {Number} [decimals] The number of decimals to use for the currency\r
         * (defaults to {@link #currencyPrecision})\r
         * @param {Boolean} [end] True if the currency sign should be at the end of the string\r
         * (defaults to {@link #currencyAtEnd})\r
         * @return {String} The formatted currency string\r
         */\r
        currency: function(v, currencySign, decimals, end) {\r
            var negativeSign = '',\r
                format = ",0",\r
                i = 0;\r
            v = v - 0;\r
            if (v < 0) {\r
                v = -v;\r
                negativeSign = '-';\r
            }\r
            decimals = Ext.isDefined(decimals) ? decimals : me.currencyPrecision;\r
            format += (decimals > 0 ? '.' : '');\r
            for (; i < decimals; i++) {\r
                format += '0';\r
            }\r
            v = me.number(v, format);\r
            if ((end || me.currencyAtEnd) === true) {\r
                return Ext.String.format("{0}{1}{2}", negativeSign, v, currencySign || me.currencySign);\r
            } else {\r
                return Ext.String.format("{0}{1}{2}", negativeSign, currencySign || me.currencySign, v);\r
            }\r
        },\r
\r
        /**\r
         * Formats the passed date using the specified format pattern.\r
         * Note that this uses the native Javascript Date.parse() method and is therefore subject to its idiosyncrasies.\r
         * Most formats assume the local timezone unless specified. One notable exception is 'YYYY-MM-DD' (note the dashes)\r
         * which is typically interpreted in UTC and can cause date shifting.\r
         * \r
         * @param {String/Date} value The value to format. Strings must conform to the format\r
         * expected by the JavaScript Date object's\r
         * [parse() method](http://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/parse).\r
         * @param {String} [format] Any valid date format string. Defaults to {@link Ext.Date#defaultFormat}.\r
         * @return {String} The formatted date string.\r
         */\r
        date: function(v, format) {\r
            if (!v) {\r
                return "";\r
            }\r
            if (!Ext.isDate(v)) {\r
                v = new Date(Date.parse(v));\r
            }\r
            return Ext.Date.dateFormat(v, format || Ext.Date.defaultFormat);\r
        },\r
\r
        /**\r
         * Returns a date rendering function that can be reused to apply a date format multiple times efficiently.\r
         * @param {String} format Any valid date format string. Defaults to {@link Ext.Date#defaultFormat}.\r
         * @return {Function} The date formatting function\r
         */\r
        dateRenderer : function(format) {\r
            return function(v) {\r
                return me.date(v, format);\r
            };\r
        },\r
\r
        /**\r
         * Returns the given number as a base 16 string at least `digits` in length. If\r
         * the number is fewer digits, 0's are prepended as necessary. If `digits` is\r
         * negative, the absolute value is the *exact* number of digits to return. In this\r
         * case, if then number has more digits, only the least significant digits are\r
         * returned.\r
         *\r
         *      expect(Ext.util.Format.hex(0x12e4, 2)).toBe('12e4');\r
         *      expect(Ext.util.Format.hex(0x12e4, -2)).toBe('e4');\r
         *      expect(Ext.util.Format.hex(0x0e, 2)).toBe('0e');\r
         *\r
         * @param {Number} value The number to format in hex.\r
         * @param {Number} digits\r
         * @return {string}\r
         */\r
        hex: function (value, digits) {\r
            var s = parseInt(value || 0, 10).toString(16);\r
            if (digits) {\r
                if (digits < 0) {\r
                    digits = -digits;\r
                    if (s.length > digits) {\r
                        s = s.substring(s.length - digits);\r
                    }\r
                }\r
                while (s.length < digits) {\r
                    s = '0' + s;\r
                }\r
            }\r
            return s;\r
        },\r
\r
        /**\r
         * Returns this result:\r
         *\r
         *      value || orValue\r
         *\r
         * The usefulness of this formatter method is in templates. For example:\r
         *\r
         *      {foo:or("bar")}\r
         *\r
         * @param {Boolean} value The "if" value.\r
         * @param {Mixed} orValue\r
         */\r
        or: function (value, orValue) {\r
            return value || orValue;\r
        },\r
\r
        /**\r
         * If `value` is a number, returns the argument from that index. For example\r
         *\r
         *      var s = Ext.util.Format.pick(2, 'zero', 'one', 'two');\r
         *      // s === 'two'\r
         *\r
         * Otherwise, `value` is treated in a truthy/falsey manner like so:\r
         *\r
         *      var s = Ext.util.Format.pick(null, 'first', 'second');\r
         *      // s === 'first'\r
         *\r
         *      s = Ext.util.Format.pick({}, 'first', 'second');\r
         *      // s === 'second'\r
         *\r
         * The usefulness of this formatter method is in templates. For example:\r
         *\r
         *      {foo:pick("F","T")}\r
         *\r
         *      {bar:pick("first","second","third")}\r
         *\r
         * @param {Boolean} value The "if" value.\r
         * @param {Mixed} firstValue\r
         * @param {Mixed} secondValue\r
         */\r
        pick: function (value, firstValue, secondValue) {\r
            if (Ext.isNumber(value)) {\r
                var ret = arguments[value + 1];\r
                if (ret) {\r
                    return ret;\r
                }\r
            }\r
            return value ? secondValue : firstValue;\r
        },\r
\r
        /**\r
         * Strips all HTML tags.\r
         * @param {Object} value The text from which to strip tags\r
         * @return {String} The stripped text\r
         */\r
        stripTags: function(v) {\r
            return !v ? v : String(v).replace(me.stripTagsRe, "");\r
        },\r
\r
        /**\r
         * Strips all script tags.\r
         * @param {Object} value The text from which to strip script tags\r
         * @return {String} The stripped text\r
         */\r
        stripScripts : function(v) {\r
            return !v ? v : String(v).replace(me.stripScriptsRe, "");\r
        },\r
\r
        /**\r
         * @method\r
         * Simple format for a file size (xxx bytes, xxx KB, xxx MB).\r
         * @param {Number/String} size The numeric value to format\r
         * @return {String} The formatted file size\r
         */\r
        fileSize : (function(){\r
            var byteLimit = 1024,\r
                kbLimit = 1048576,\r
                mbLimit = 1073741824;\r
                \r
            return function(size) {\r
                var out;\r
                if (size < byteLimit) {\r
                    if (size === 1) {\r
                        out = '1 byte';    \r
                    } else {\r
                        out = size + ' bytes';\r
                    }\r
                } else if (size < kbLimit) {\r
                    out = (Math.round(((size*10) / byteLimit))/10) + ' KB';\r
                } else if (size < mbLimit) {\r
                    out = (Math.round(((size*10) / kbLimit))/10) + ' MB';\r
                } else {\r
                    out = (Math.round(((size*10) / mbLimit))/10) + ' GB';\r
                }\r
                return out;\r
            };\r
        })(),\r
\r
        /**\r
         * It does simple math for use in a template, for example:\r
         *\r
         *     var tpl = new Ext.Template('{value} * 10 = {value:math("* 10")}');\r
         *\r
         * @return {Function} A function that operates on the passed value.\r
         * @method\r
         */\r
        math : (function(){\r
            var fns = {};\r
\r
            return function(v, a){\r
                if (!fns[a]) {\r
                    fns[a] = Ext.functionFactory('v', 'return v ' + a + ';');\r
                }\r
                return fns[a](v);\r
            };\r
        }()),\r
\r
        /**\r
         * Rounds the passed number to the required decimal precision.\r
         * @param {Number/String} value The numeric value to round.\r
         * @param {Number} [precision] The number of decimal places to which to round the\r
         * first parameter's value. If `undefined` the `value` is passed to `Math.round`\r
         * otherwise the value is returned unmodified.\r
         * @return {Number} The rounded value.\r
         */\r
        round : function(value, precision) {\r
            var result = Number(value);\r
            if (typeof precision === 'number') {\r
                precision = Math.pow(10, precision);\r
                result = Math.round(value * precision) / precision;\r
            } else if (precision === undefined) {\r
                result = Math.round(result);\r
            }\r
            return result;\r
        },\r
\r
        /**\r
         * Formats the passed number according to the passed format string.\r
         *\r
         * The number of digits after the decimal separator character specifies the number of\r
         * decimal places in the resulting string. The *local-specific* decimal character is\r
         * used in the result.\r
         *\r
         * The *presence* of a thousand separator character in the format string specifies that\r
         * the *locale-specific* thousand separator (if any) is inserted separating thousand groups.\r
         *\r
         * By default, "," is expected as the thousand separator, and "." is expected as the decimal separator.\r
         *\r
         * Locale-specific characters are always used in the formatted output when inserting\r
         * thousand and decimal separators. These can be set using the {@link #thousandSeparator} and\r
         * {@link #decimalSeparator} options.\r
         *\r
         * The format string must specify separator characters according to US/UK conventions ("," as the\r
         * thousand separator, and "." as the decimal separator)\r
         *\r
         * To allow specification of format strings according to local conventions for separator characters, add\r
         * the string `/i` to the end of the format string. This format depends on the {@link #thousandSeparator} and\r
         * {@link #decimalSeparator} options. For example, if using European style separators, then the format string\r
         * can be specified as `'0.000,00'`. This would be equivalent to using `'0,000.00'` when using US style formatting.\r
         *\r
         * Examples (123456.789):\r
         * \r
         * - `0` - (123457) show only digits, no precision\r
         * - `0.00` - (123456.79) show only digits, 2 precision\r
         * - `0.0000` - (123456.7890) show only digits, 4 precision\r
         * - `0,000` - (123,457) show comma and digits, no precision\r
         * - `0,000.00` - (123,456.79) show comma and digits, 2 precision\r
         * - `0,0.00` - (123,456.79) shortcut method, show comma and digits, 2 precision\r
         * - `0.####` - (123,456.789) Allow maximum 4 decimal places, but do not right pad with zeroes\r
         * - `0.00##` - (123456.789) Show at least 2 decimal places, maximum 4, but do not right pad with zeroes\r
         *\r
         * @param {Number} v The number to format.\r
         * @param {String} formatString The way you would like to format this text.\r
         * @return {String} The formatted number.\r
         */\r
        number : function(v, formatString) {\r
            if (!formatString) {\r
                return v;\r
            }\r
            if (isNaN(v)) {\r
                return '';\r
            }\r
            \r
            var formatFn = me.formatFns[formatString];\r
\r
            // Generate formatting function to be cached and reused keyed by the format string.\r
            // This results in a 100% performance increase over analyzing the format string each invocation.\r
            if (!formatFn) {\r
\r
                var originalFormatString = formatString,\r
                    comma = me.thousandSeparator,\r
                    decimalSeparator = me.decimalSeparator,\r
                    precision = 0,\r
                    trimPart = '',\r
                    hasComma,\r
                    splitFormat,\r
                    extraChars,\r
                    trimTrailingZeroes,\r
                    code, len;\r
\r
                // The "/i" suffix allows caller to use a locale-specific formatting string.\r
                // Clean the format string by removing all but numerals and the decimal separator.\r
                // Then split the format string into pre and post decimal segments according to *what* the\r
                // decimal separator is. If they are specifying "/i", they are using the local convention in the format string.\r
                if (formatString.substr(formatString.length - 2) === '/i') {\r
                    // In a vast majority of cases, the separator will never change over the lifetime of the application.\r
                    // So we'll only regenerate this if we really need to\r
                    if (!me.I18NFormatCleanRe || me.lastDecimalSeparator !== decimalSeparator) {\r
                        me.I18NFormatCleanRe = new RegExp('[^\\d\\' + decimalSeparator + '#]','g');\r
                        me.lastDecimalSeparator = decimalSeparator;\r
                    }\r
                    formatString = formatString.substr(0, formatString.length - 2);\r
                    hasComma = formatString.indexOf(comma) !== -1;\r
                    splitFormat = formatString.replace(me.I18NFormatCleanRe, '').split(decimalSeparator);\r
                } else {\r
                    hasComma = formatString.indexOf(',') !== -1;\r
                    splitFormat = formatString.replace(me.formatCleanRe, '').split('.');\r
                }\r
                extraChars = formatString.replace(me.formatPattern, '');\r
\r
                if (splitFormat.length > 2) {\r
                    //<debug>\r
                    Ext.raise({\r
                        sourceClass: "Ext.util.Format",\r
                        sourceMethod: "number",\r
                        value: v,\r
                        formatString: formatString,\r
                        msg: "Invalid number format, should have no more than 1 decimal"\r
                    });\r
                    //</debug>\r
                } else if (splitFormat.length === 2) {\r
                    precision = splitFormat[1].length;\r
\r
                    // Formatting ending in .##### means maximum 5 trailing significant digits\r
                    trimTrailingZeroes = splitFormat[1].match(me.hashRe);\r
                    if (trimTrailingZeroes) {\r
                        len = trimTrailingZeroes[0].length;\r
                        // Need to escape, since this will be '.' by default\r
                        trimPart = 'trailingZeroes=new RegExp(Ext.String.escapeRegex(utilFormat.decimalSeparator) + "*0{0,' + len + '}$")';\r
                    }\r
                }\r
                \r
                // The function we create is called immediately and returns a closure which has access to vars and some fixed values; RegExes and the format string.\r
                code = [\r
                    'var utilFormat=Ext.util.Format,extNumber=Ext.Number,neg,absVal,fnum,parts' +\r
                        (hasComma ? ',thousandSeparator,thousands=[],j,n,i' : '') +\r
                        (extraChars  ? ',formatString="' + formatString + '",formatPattern=/[\\d,\\.#]+/' : '') +\r
                        ',trailingZeroes;' +\r
                    'return function(v){' +\r
                    'if(typeof v!=="number"&&isNaN(v=extNumber.from(v,NaN)))return"";' +\r
                    'neg=v<0;',\r
                    'absVal=Math.abs(v);',\r
                    'fnum=Ext.Number.toFixed(absVal, ' + precision + ');',\r
                    trimPart, ';'\r
                ];\r
\r
                if (hasComma) {\r
                    // If we have to insert commas...\r
                    \r
                    // split the string up into whole and decimal parts if there are decimals\r
                    if (precision) {\r
                        code[code.length] = 'parts=fnum.split(".");';\r
                        code[code.length] = 'fnum=parts[0];';\r
                    }\r
                    code[code.length] =\r
                        'if(absVal>=1000) {';\r
                            code[code.length] = 'thousandSeparator=utilFormat.thousandSeparator;' +\r
                            'thousands.length=0;' +\r
                            'j=fnum.length;' +\r
                            'n=fnum.length%3||3;' +\r
                            'for(i=0;i<j;i+=n){' +\r
                                'if(i!==0){' +\r
                                    'n=3;' +\r
                                '}' +\r
                                'thousands[thousands.length]=fnum.substr(i,n);' +\r
                            '}' +\r
                            'fnum=thousands.join(thousandSeparator);' + \r
                        '}';\r
                    if (precision) {\r
                        code[code.length] = 'fnum += utilFormat.decimalSeparator+parts[1];';\r
                    }\r
                    \r
                } else if (precision) {\r
                    // If they are using a weird decimal separator, split and concat using it\r
                    code[code.length] = 'if(utilFormat.decimalSeparator!=="."){' +\r
                        'parts=fnum.split(".");' +\r
                        'fnum=parts[0]+utilFormat.decimalSeparator+parts[1];' +\r
                    '}';\r
                }\r
\r
                /*\r
                 * Edge case. If we have a very small negative number it will get rounded to 0,\r
                 * however the initial check at the top will still report as negative. Replace\r
                 * everything but 1-9 and check if the string is empty to determine a 0 value.\r
                 */\r
                code[code.length] = 'if(neg&&fnum!=="' + (precision ? '0.' + Ext.String.repeat('0', precision) : '0') + '") { fnum="-"+fnum; }';\r
\r
                if (trimTrailingZeroes) {\r
                    code[code.length] = 'fnum=fnum.replace(trailingZeroes,"");';\r
                }\r
\r
                code[code.length] = 'return ';\r
\r
                // If there were extra characters around the formatting string, replace the format string part with the formatted number.\r
                if (extraChars) {\r
                    code[code.length] = 'formatString.replace(formatPattern, fnum);';\r
                } else {\r
                    code[code.length] = 'fnum;';\r
                }\r
                code[code.length] = '};';\r
\r
                formatFn = me.formatFns[originalFormatString] = Ext.functionFactory('Ext', code.join(''))(Ext);\r
            }\r
            return formatFn(v);\r
        },\r
\r
        /**\r
         * Returns a number rendering function that can be reused to apply a number format multiple\r
         * times efficiently.\r
         *\r
         * @param {String} format Any valid number format string for {@link #number}\r
         * @return {Function} The number formatting function\r
         */\r
        numberRenderer : function(format) {\r
            return function(v) {\r
                return me.number(v, format);\r
            };\r
        },\r
\r
        /**\r
         * Formats the passed number as a percentage according to the passed format string.\r
         * The number should be between 0 and 1 to represent 0% to 100%.\r
         *\r
         * @param {Number} value The percentage to format.\r
         * @param {String} [formatString="0"] See {@link #number} for details.\r
         * @return {String} The formatted percentage.\r
         */\r
        percent: function (value, formatString) {\r
            return me.number(value * 100, formatString || '0') + me.percentSign;\r
        },\r
\r
        /**\r
         * Formats an object of name value properties as HTML element attribute values suitable for using when creating textual markup.\r
         * @param {Object} attributes An object containing the HTML attributes as properties eg: `{height:40, vAlign:'top'}`\r
         */\r
        attributes: function(attributes) {\r
            if (typeof attributes === 'object') {\r
                var result = [],\r
                    name;\r
\r
                for (name in attributes) {\r
                    if (attributes.hasOwnProperty(name)) {\r
                        result.push(name, '="', name === 'style' ? \r
                                Ext.DomHelper.generateStyles(attributes[name], null, true) :\r
                                Ext.htmlEncode(attributes[name]), '" ');\r
                    }\r
                }\r
                attributes = result.join('');\r
            }\r
            return attributes || '';\r
        },\r
\r
        /**\r
         * Selectively return the plural form of a word based on a numeric value.\r
         * \r
         * For example, the following template would result in "1 Comment".  If the \r
         * value of `count` was 0 or greater than 1, the result would be "x Comments".\r
         * \r
         *     var tpl = new Ext.XTemplate('{count:plural("Comment")}');\r
         *     \r
         *     tpl.apply({\r
         *         count: 1\r
         *     }); // returns "1 Comment"\r
         * \r
         * Examples using the static `plural` method call:\r
         * \r
         *     Ext.util.Format.plural(2, 'Comment');\r
         *     // returns "2 Comments"\r
         * \r
         *     Ext.util.Format.plural(4, 'person', 'people');\r
         *     // returns "4 people"\r
         *\r
         * @param {Number} value The value to compare against\r
         * @param {String} singular The singular form of the word\r
         * @param {String} [plural] The plural form of the word (defaults to the \r
         * singular form with an "s" appended)\r
         * @return {String} output The pluralized output of the passed singular form\r
         */\r
        plural : function(v, s, p) {\r
            return v +' ' + (v === 1 ? s : (p ? p : s+'s'));\r
        },\r
\r
        /**\r
         * Converts newline characters to the HTML tag `<br/>`\r
         *\r
         * @param {String} v The string value to format.\r
         * @return {String} The string with embedded `<br/>` tags in place of newlines.\r
         */\r
        nl2br : function(v) {\r
            return Ext.isEmpty(v) ? '' : v.replace(me.nl2brRe, '<br/>');\r
        },\r
\r
        /**\r
         * Alias for {@link Ext.String#capitalize}.\r
         * @method\r
         * @inheritdoc Ext.String#capitalize\r
         */\r
        capitalize: Ext.String.capitalize,\r
\r
        /**\r
         * Alias for {@link Ext.String#uncapitalize}.\r
         * @method\r
         * @inheritdoc Ext.String#uncapitalize\r
         */\r
        uncapitalize: Ext.String.uncapitalize,\r
\r
        /**\r
         * Alias for {@link Ext.String#ellipsis}.\r
         * @method\r
         * @inheritdoc Ext.String#ellipsis\r
         */\r
        ellipsis: Ext.String.ellipsis,\r
\r
        /**\r
         * Alias for {@link Ext.String#escape}.\r
         * @method\r
         * @inheritdoc Ext.String#escape\r
         */\r
        escape: Ext.String.escape,\r
\r
        /**\r
         * Alias for {@link Ext.String#escapeRegex}.\r
         * @method\r
         * @inheritdoc Ext.String#escapeRegex\r
         */\r
        escapeRegex : Ext.String.escapeRegex,\r
\r
        /**\r
         * Alias for {@link Ext.String#htmlDecode}.\r
         * @method\r
         * @inheritdoc Ext.String#htmlDecode\r
         */\r
        htmlDecode: Ext.String.htmlDecode,\r
\r
        /**\r
         * Alias for {@link Ext.String#htmlEncode}.\r
         * @method\r
         * @inheritdoc Ext.String#htmlEncode\r
         */\r
        htmlEncode: Ext.String.htmlEncode,\r
\r
        /**\r
         * Alias for {@link Ext.String#leftPad}.\r
         * @method\r
         * @inheritdoc Ext.String#leftPad\r
         */\r
        leftPad: Ext.String.leftPad,\r
\r
        /**\r
         * Alias for {@link Ext.String#toggle}.\r
         * @method\r
         * @inheritdoc Ext.String#toggle\r
         */\r
        toggle: Ext.String.toggle,\r
\r
        /**\r
         * Alias for {@link Ext.String#trim}.\r
         * @method\r
         * @inheritdoc Ext.String#trim\r
         */\r
        trim : Ext.String.trim,\r
\r
        /**\r
         * Parses a number or string representing margin sizes into an object.\r
         * Supports CSS-style margin declarations (e.g. 10, "10", "10 10", "10 10 10" and\r
         * "10 10 10 10" are all valid options and would return the same result).\r
         *\r
         * @param {Number/String} box The encoded margins\r
         * @return {Object} An object with margin sizes for top, right, bottom and left\r
         */\r
        parseBox : function(box) {\r
            box = box || 0;\r
\r
            if (typeof box === 'number') {\r
                return {\r
                    top   : box,\r
                    right : box,\r
                    bottom: box,\r
                    left  : box\r
                };\r
             }\r
\r
            var parts  = box.split(' '),\r
                ln = parts.length;\r
\r
            if (ln === 1) {\r
                parts[1] = parts[2] = parts[3] = parts[0];\r
            }\r
            else if (ln === 2) {\r
                parts[2] = parts[0];\r
                parts[3] = parts[1];\r
            }\r
            else if (ln === 3) {\r
                parts[3] = parts[1];\r
            }\r
\r
            return {\r
                top   :parseInt(parts[0], 10) || 0,\r
                right :parseInt(parts[1], 10) || 0,\r
                bottom:parseInt(parts[2], 10) || 0,\r
                left  :parseInt(parts[3], 10) || 0\r
            };\r
        }\r
    };\r
});\r