/**
 * @class Ext.util.Format
 *  
 * このクラスは関数をフォーマットするために集中化された場所です。これには、テキスト、日付、数値などのさまざまな種類のデータをフォーマットするための関数が含まれています。
 *  
 * ##ローカリゼーション
 *
 * このクラスには、ローカリゼーション用の複数のオプションが含まれています。ライブラリがロードすると、これらを設定できるようになり、そのポイントからの関数へのすべての呼び出しで、指定されたロケール設定が使用されます。
 *
 * オプションには、以下のものが含まれます。
 *
 * - thousandSeparator
 * - decimalSeparator
 * - currenyPrecision
 * - currencySign
 * - currencyAtEnd
 *
 * このクラスでは、次の場所で定義されるデフォルトの日付フォーマットが使用されます：{@link Ext.Date#defaultFormat}。
 *
 * ##レンダラーと一緒に使用
 *
 * 2つのhelper関数が存在します。これらは、グリッドレンダラ―と共に使用できる新しい関数を返します。
 *  
 *     columns: [{
 *         dataIndex: 'date',
 *         renderer: Ext.util.Format.dateRenderer('Y-m-d')
 *     }, {
 *         dataIndex: 'time',
 *         renderer: Ext.util.Format.numberRenderer('0.000')
 *     }]
 *  
 * 単一の引数のみを取得する関数を直接渡すこともできます。
 *
 *     columns: [{
 *         dataIndex: 'cost',
 *         renderer: Ext.util.Format.usMoney
 *     }, {
 *         dataIndex: 'productCode',
 *         renderer: Ext.util.Format.uppercase
 *     }]
 *  
 * ##XTemplateと一緒に使用
 *
 * XTemplateは、Ext.util.Format関数を直接使用することもできます。
 *  
 *     new Ext.XTemplate([
 *         'Date: {startDate:date("Y-m-d")}',
 *         'Cost: {cost:usMoney}'
 *     ]);
 *
 * @singleton
 */
Ext.define('Ext.util.Format', function () {
    var me; // holds our singleton instance

    return {
        requires: [
            'Ext.Error',
            'Ext.Number',
            'Ext.String',
            'Ext.Date'
        ],

        singleton: true,

        /**
         * グローバルなデフォルトの日付フォーマット。
         */
        defaultDateFormat: 'm/d/Y',

        //<locale>
        /**
         * @property {String} thousandSeparator
         * {@link #number}関数が3桁区切りとして使用する文字。
         *
         * ロケールファイルによってオーバーライドされることがあります。
         */
        thousandSeparator: ',',
        //</locale>

        //<locale>
        /**
         * @property {String} decimalSeparator
         * {@link #number}関数が小数点として使用する文字。
         *
         * ロケールファイルによってオーバーライドされることがあります。
         */
        decimalSeparator: '.',
        //</locale>

        //<locale>
        /**
         * @property {Number} currencyPrecision
         * {@link #currency}関数が表示する小数点以下の桁数。
         *
         * ロケールファイルによってオーバーライドされることがあります。
         */
        currencyPrecision: 2,
        //</locale>

         //<locale>
        /**
         * @property {String} currencySign
         * {@link #currency}関数が表示する通貨記号。
         *
         * ロケールファイルによってオーバーライドされることがあります。
         */
        currencySign: '$',
        //</locale>

        /**
         * @property {String} percentSign
         * {@link #percent}関数が表示するパーセント記号。
         *
         * ロケールファイルによってオーバーライドされることがあります。
         */
        percentSign: '%',

        //<locale>
        /**
         * @property {Boolean} currencyAtEnd
         * これを<code>true</code>に設定すると、{@link #currency}関数がフォーマットされた値に通過記号を追加できるようになります。
         *
         * ロケールファイルによってオーバーライドされることがあります。
         */
        currencyAtEnd: false,
        //</locale>

        stripTagsRe: /<\/?[^>]+>/gi,
        stripScriptsRe: /(?:<script.*?>)((\n|\r|.)*?)(?:<\/script>)/ig,
        nl2brRe: /\r?\n/g,
        hashRe: /#+$/,
        allHashes: /^#+$/,

        // Match a format string characters to be able to detect remaining "literal" characters
        formatPattern: /[\d,\.#]+/,

        // A RegExp to remove from a number format string, all characters except digits and '.'
        formatCleanRe: /[^\d\.#]/g,

        // A RegExp to remove from a number format string, all characters except digits and the local decimal separator.
        // Created on first use. The local decimal separator character must be initialized for this to be created.
        I18NFormatCleanRe: null,

        // Cache ofg number formatting functions keyed by format string
        formatFns: {},

        constructor: function () {
            me = this; // we are a singleton, so cache our this pointer in scope
        },

        /**
         * 参照を確認し、未定義(undefined)の場合、空の文字列に変換します。
         * @param {Object} value チェックする参照
         * @return {Object} 変換された場合は空の文字列、そうでない場合は元の値
         */
        undef : function(value) {
            return value !== undefined ? value : "";
        },

        /**
         * 参照を確認し、空である場合にデフォルト値に変換します。
         * @param {Object} value チェックする参照
         * @param {String} [defaultValue=""] undefinedに挿入する値。
         * @return {String}

         */
        defaultValue : function(value, defaultValue) {
            return value !== undefined && value !== '' ? value : defaultValue;
        },

        /**
         * 元の文字列からのサブストリングを返します。
         * @param {String} value 元のテキスト
         * @param {Number} start サブストリングの開始インデックス
         * @param {Number} length サブストリングの長さ
         * @return {String} サブストリング
         * @method
         */
        substr : 'ab'.substr(-1) != 'b'
        ? function (value, start, length) {
            var str = String(value);
            return (start < 0)
                ? str.substr(Math.max(str.length + start, 0), length)
                : str.substr(start, length);
        }
        : function(value, start, length) {
            return String(value).substr(start, length);
        },

        /**
         * 文字をすべて小文字に変換します。
         * @param {String} value 変換するテキスト
         * @return {String} 変換されたテキスト
         */
        lowercase : function(value) {
            return String(value).toLowerCase();
        },

        /**
         * 文字列をすべて大文字に変換します。
         * @param {String} value 変換するテキスト
         * @return {String} 変換されたテキスト
         */
        uppercase : function(value) {
            return String(value).toUpperCase();
        },

        /**
         * 数値をUS通貨の形式にフォーマットします。
         * @param {Number/String} value フォーマットする数値
         * @return {String} フォーマットされた通貨文字列
         */
        usMoney : function(v) {
            return me.currency(v, '$', 2);
        },

        /**
         * 数値を通貨としてフォーマットします。
         * @param {Number/String} value フォーマットする数値
         * @param {String} [sign] 使用する通貨記号（デフォルトは{@link #currencySign}）
         * @param {Number} [decimals] 通貨に使用する小数の数（デフォルトは{@link #currencyPrecision}）
         * @param {Boolean} [end] 通貨記号が文字列の最後にある場合はtrue（デフォルトは{@link #currencyAtEnd}）
         * @return {String} フォーマットされた通貨文字列
         */
        currency: function(v, currencySign, decimals, end) {
            var negativeSign = '',
                format = ",0",
                i = 0;
            v = v - 0;
            if (v < 0) {
                v = -v;
                negativeSign = '-';
            }
            decimals = Ext.isDefined(decimals) ? decimals : me.currencyPrecision;
            format += (decimals > 0 ? '.' : '');
            for (; i < decimals; i++) {
                format += '0';
            }
            v = me.number(v, format);
            if ((end || me.currencyAtEnd) === true) {
                return Ext.String.format("{0}{1}{2}", negativeSign, v, currencySign || me.currencySign);
            } else {
                return Ext.String.format("{0}{1}{2}", negativeSign, currencySign || me.currencySign, v);
            }
        },

        /**
         * 指定されたフォーマットパターンを使用して渡された日付をフォーマットします。ネイティブJavascript Date.parse()メソッドを使用するため、その特異性に左右されることに注意してください。ほとんどのフォーマットは、指定のない限り、地域のタイムゾーンになります。例外は'YYYY-MM-DD'（ダッシュに注意）で、一般にはUTCと解釈され、日付のずれが発生する可能性があります。
         * 
         * @param {String/Date} value フォーマットする値。文字列は、JavaScriptのDateオブジェクトの[parse() method](http://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/parse)が想定するフォーマットに準じることが必要です。
         * @param {String} [format] 有効な日付フォーマット文字列。デフォルトは{@link Ext.Date#defaultFormat}です。
         * @return {String} フォーマットされた日付文字列。
         */
        date: function(v, format) {
            if (!v) {
                return "";
            }
            if (!Ext.isDate(v)) {
                v = new Date(Date.parse(v));
            }
            return Ext.Date.dateFormat(v, format || Ext.Date.defaultFormat);
        },
        /* TODO - reconcile with Touch version:
        date: function(value, format) {
            var date = value;
            if (!value) {
                return "";
            }
            if (!Ext.isDate(value)) {
                date = new Date(Date.parse(value));
                if (isNaN(date)) {
                    // Dates with ISO 8601 format are not well supported by mobile devices, this can work around the issue.
                    if (this.iso8601TestRe.test(value)) {
                        // Fix for older android browsers to properly implement ISO 8601 formatted dates with timezone
                        if (Ext.os.is.Android && Ext.os.version.isLessThan("3.0")) {

                             //* This code is modified from the following source: <https://github.com/csnover/js-iso8601>
                             //* © 2011 Colin Snover <http://zetafleet.com>
                             //* Released under MIT license.

                            var potentialUndefinedKeys = [ 1, 4, 5, 6, 7, 10, 11 ];
                            var dateParsed, minutesOffset = 0;

                            // Capture Groups
                            // 1 YYYY (optional)
                            // 2 MM
                            // 3 DD
                            // 4 HH
                            // 5 mm (optional)
                            // 6 ss (optional)
                            // 7 msec (optional)
                            // 8 Z (optional)
                            // 9 ± (optional)
                            // 10 tzHH (optional)
                            // 11 tzmm (optional)
                            if ((dateParsed = /^(\d{4}|[+\-]\d{6})(?:-(\d{2})(?:-(\d{2}))?)?(?:T(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{3}))?)?(?:(Z)|([+\-])(\d{2})(?::(\d{2}))?)?)?$/.exec(value))) {

                                //Set any undefined values needed for Date to 0
                                for (var i = 0, k; (k = potentialUndefinedKeys[i]); ++i) {
                                    dateParsed[k] = +dateParsed[k] || 0;
                                }

                                // Fix undefined month and decrement
                                dateParsed[2] = (+dateParsed[2] || 1) - 1;
                                //fix undefined days
                                dateParsed[3] = +dateParsed[3] || 1;

                                // Correct for timezone
                                if (dateParsed[8] !== 'Z' && dateParsed[9] !== undefined) {
                                    minutesOffset = dateParsed[10] * 60 + dateParsed[11];

                                    if (dateParsed[9] === '+') {
                                        minutesOffset = 0 - minutesOffset;
                                    }
                                }

                                // Calculate valid date
                                date = new Date(Date.UTC(dateParsed[1], dateParsed[2], dateParsed[3], dateParsed[4], dateParsed[5] + minutesOffset, dateParsed[6], dateParsed[7]));
                            }
                        } else {
                            date = value.split(this.iso8601SplitRe);
                            date = new Date(date[0], date[1] - 1, date[2], date[3], date[4], date[5]);
                        }
                    }
                }
                if (isNaN(date)) {
                    // Dates with the format "2012-01-20" fail, but "2012/01/20" work in some browsers. We'll try and
                    // get around that.
                    date = new Date(Date.parse(value.replace(this.dashesRe, "/")));
                    //<debug>
                    if (isNaN(date)) {
                        Ext.Logger.error("Cannot parse the passed value " + value + " into a valid date");
                    }
                    //</debug>
                }
                value = date;
            }
            return Ext.Date.format(value, format || Ext.util.Format.defaultDateFormat);
        },
        */

        /**
         * 複数回日付フォーマットを適用する場合に効率的な、日付レンダリング関数を返します。
         * @param {String} format 有効な日付フォーマット文字列。デフォルトは{@link Ext.Date#defaultFormat}です。
         * @return {Function} 日付をフォーマットする関数
         */
        dateRenderer : function(format) {
            return function(v) {
                return me.date(v, format);
            };
        },

        /**
         * 渡された数字を最小でも`digits`を長さとするbase 16文字列として返します。数字がdigitsより小さい場合は0が必要に応じて先頭に追加されます。`digits`が負の場合、絶対値が戻り値の*正確な*桁数となります。この場合、数字の桁がdigitsより大きい場合、最小桁数のみが返されます。
         *
         *      expect(Ext.util.Format.hex(0x12e4, 2)).toBe('12e4');
         *      expect(Ext.util.Format.hex(0x12e4, -2)).toBe('e4');
         *      expect(Ext.util.Format.hex(0x0e, 2)).toBe('0e');
         *
         * @param {Number} value 16進でフォーマットする数字。
         * @param {Number} digits
         * @returns {string}
         */
        hex: function (value, digits) {
            var s = parseInt(value || 0, 10).toString(16);
            if (digits) {
                if (digits < 0) {
                    digits = -digits;
                    if (s.length > digits) {
                        s = s.substring(s.length - digits);
                    }
                }
                while (s.length < digits) {
                    s = '0' + s;
                }
            }
            return s;
        },

        /**
         * 次の結果を返します：
         *
         *      value || orValue
         *
         * このフォーマッターメソッドはテンプレートにおいて有用性を発揮します。例：
         *
         *      {foo:or("bar")}
         *
         * @param {Boolean} value 「if」値。
         * @param {Mixed} orValue
         */
        or: function (value, orValue) {
            return value || orValue;
        },

        /**
         * `value`が数字の場合、そのインデックスの引数を返します。例
         *
         *      var s = Ext.util.Format.pick(2, 'zero', 'one', 'two');
         *      // s === 'two'
         *
         * それ以外は、`value`は「真」/「偽」を意味するものとして、次のように扱われます。
         *
         *      var s = Ext.util.Format.pick(null, 'first', 'second');
         *      // s === 'first'
         *
         *      s = Ext.util.Format.pick({}, 'first', 'second');
         *      // s === 'second'
         *
         * このフォーマッターメソッドはテンプレートにおいて有用性を発揮します。例：
         *
         *      {foo:pick("F","T")}
         *
         *      {bar:pick("first","second","third")}
         *
         * @param {Boolean} value 「if」値。
         * @param {Mixed} firstValue
         * @param {Mixed} secondValue
         */
        pick: function (value, firstValue, secondValue) {
            if (Ext.isNumber(value)) {
                var ret = arguments[value + 1];
                if (ret) {
                    return ret;
                }
            }
            return value ? secondValue : firstValue;
        },

        /**
         * すべてのHTMLタグを取り除きます。
         * @param {Object} value タグが取り除かれたテキスト
         * @return {String} 取り除かれたテキスト
         */
        stripTags : function(v) {
            return !v ? v : String(v).replace(me.stripTagsRe, "");
        },

        /**
         * scriptタグを取り除きます。
         * @param {Object} value スクリプトタグが取り除かれたテキスト
         * @return {String} 取り除かれたテキスト
         */
        stripScripts : function(v) {
            return !v ? v : String(v).replace(me.stripScriptsRe, "");
        },

        /**
         * ファイルサイズのためのシンプルなフォーマット(xxx bytes, xxx KB, xxx MB)
         * @param {Number/String} size フォーマットする数値
         * @return {String} フォーマットされたファイルサイズ
         */
        fileSize : (function(){
            var byteLimit = 1024,
                kbLimit = 1048576,
                mbLimit = 1073741824;
                
            return function(size) {
                var out;
                if (size < byteLimit) {
                    if (size === 1) {
                        out = '1 byte';    
                    } else {
                        out = size + ' bytes';
                    }
                } else if (size < kbLimit) {
                    out = (Math.round(((size*10) / byteLimit))/10) + ' KB';
                } else if (size < mbLimit) {
                    out = (Math.round(((size*10) / kbLimit))/10) + ' MB';
                } else {
                    out = (Math.round(((size*10) / mbLimit))/10) + ' GB';
                }
                return out;
            };
        })(),

        /**
         * テンプレートで使用するための簡単な計算を行います。
         *
         *     var tpl = new Ext.Template('{value} * 10 = {value:math("* 10")}');
         *
         * @return {Function} 渡された値で操作する関数。
         * @method
         */
        math : (function(){
            var fns = {};

            return function(v, a){
                if (!fns[a]) {
                    fns[a] = Ext.functionFactory('v', 'return v ' + a + ';');
                }
                return fns[a](v);
            };
        }()),

        /**
         * 指定する小数の桁数まで渡された数字を丸めます。
         * @param {Number/String} value 丸める数値
         * @param {Number} [precision] 最初のパラメータの値を丸める小数点以下の桁数。`undefined`の場合、`value`は`Math.round`に渡されます。その他の場合は、値が変更されずに返されます。
         * @return {Number} 丸められた値。
         */
        round : function(value, precision) {
            var result = Number(value);
            if (typeof precision === 'number') {
                precision = Math.pow(10, precision);
                result = Math.round(value * precision) / precision;
            } else if (precision === undefined) {
                result = Math.round(result);
            }
            return result;
        },

        /**
         * 渡されたフォーマット文字列に応じて渡された数をフォーマットします。
         *
         * 小数点記号の後の桁数によって、出来上がった文字列の小数点以下の桁数が指定されます。結果、*地域固有*の小数点記号が使用されます。
         *
         * フォーマット文字列内に3桁区切り文字が*存在*している場合、*地域固有*の3桁区切り文字（もしあれば）が分かれている3桁グループに挿入されることが指定されます。
         *
         * デフォルトでは、","は3桁区切り文字であることが要求され、"."は小数点記号であることが要求されます。
         *
         * 3桁区切り文字や小数点記号を挿入する際、地域固有の文字は常にフォーマットされた出力で使用されます。これらは{@link #thousandSeparator}および{@link #decimalSeparator}オプションを使用して設定できます。
         *
         * フォーマット文字列では、各文字や各記号をUS／UK規則に則り指定する必要があります（","は3桁区切り文字として、"."は小数点記号として）。
         *
         * フォーマット文字列の仕様を各文字や各記号の地域における規則に則り許可するには、文字列の`/i`をフォーマット文字列の最後に追加します。このフォーマットは{@link #thousandSeparator}および{@link #decimalSeparator}オプションによって決まります。たとえば、ヨーロッパスタイルの区切り文字を使用している場合、フォーマットの文字列は`'0.000,00'`と指定できます。これは、米国スタイルのフォーマットを使用している場合の`'0,000.00'`に相当します。
         *
         * 例（123456.789）:
         * 
         * - `0` - （123457）数字のみ表示します。精度は0桁です。
         * - `0.00` - （123456.79）数字のみ表示します。精度は2桁です。
         * - `0.0000` - （123456.7890）数字のみ表示します。精度は4桁です。
         * - `0,000` - （123,457）コンマおよび数字を表示します。精度は0桁です。
         * - `0,000.00` - （123,456.79）コンマおよび数字を表示します。精度は2桁です。
         * - `0,0.00` - （123,456.79）ショートカットメソッドです。コンマおよび数字を表示します。精度は2桁です。
         * - `0.####`- （123,456.789）最大小数第4位まで許可しますが、0を持つパッドを正しい位置に戻しません。
         * - `0.00##` - （123456.789） 少なくとも小数第2位まで表示し、最大では第4位まで表示しますが、0で右側を埋めることはしません。
         *
         * @param {Number} v フォーマットする数字。
         * @param {String} formatString このテキストをフォーマットする方法。
         * @return {String} フォーマットされた数字。
         */
        number : function(v, formatString) {
            if (!formatString) {
                return v;
            }
            if (isNaN(v)) {
                return '';
            }
            
            var formatFn = me.formatFns[formatString];

            // Generate formatting function to be cached and reused keyed by the format string.
            // This results in a 100% performance increase over analyzing the format string each invocation.
            if (!formatFn) {

                var originalFormatString = formatString,
                    comma = me.thousandSeparator,
                    decimalSeparator = me.decimalSeparator,
                    precision = 0,
                    trimPart = '',
                    hasComma,
                    splitFormat,
                    extraChars,
                    trimTrailingZeroes,
                    code, len;

                // The "/i" suffix allows caller to use a locale-specific formatting string.
                // Clean the format string by removing all but numerals and the decimal separator.
                // Then split the format string into pre and post decimal segments according to *what* the
                // decimal separator is. If they are specifying "/i", they are using the local convention in the format string.
                if (formatString.substr(formatString.length - 2) === '/i') {
                    // In a vast majority of cases, the separator will never change over the lifetime of the application.
                    // So we'll only regenerate this if we really need to
                    if (!me.I18NFormatCleanRe || me.lastDecimalSeparator !== decimalSeparator) {
                        me.I18NFormatCleanRe = new RegExp('[^\\d\\' + decimalSeparator + ']','g');
                        me.lastDecimalSeparator = decimalSeparator;
                    }
                    formatString = formatString.substr(0, formatString.length - 2);
                    hasComma = formatString.indexOf(comma) !== -1;
                    splitFormat = formatString.replace(me.I18NFormatCleanRe, '').split(decimalSeparator);
                } else {
                    hasComma = formatString.indexOf(',') !== -1;
                    splitFormat = formatString.replace(me.formatCleanRe, '').split('.');
                }
                extraChars = formatString.replace(me.formatPattern, '');

                if (splitFormat.length > 2) {
                    //<debug>
                    Ext.Error.raise({
                        sourceClass: "Ext.util.Format",
                        sourceMethod: "number",
                        value: v,
                        formatString: formatString,
                        msg: "Invalid number format, should have no more than 1 decimal"
                    });
                    //</debug>
                } else if (splitFormat.length === 2) {
                    precision = splitFormat[1].length;

                    // Formatting ending in .##### means maximum 5 trailing significant digits
                    trimTrailingZeroes = splitFormat[1].match(me.hashRe);
                    if (trimTrailingZeroes) {
                        len = trimTrailingZeroes[0].length;
                        // Need to escape, since this will be '.' by default
                        trimPart = 'trailingZeroes=new RegExp(Ext.String.escapeRegex(utilFormat.decimalSeparator) + "*0{0,' + len + '}$")';
                    }
                }
                
                // 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.
                code = [
                    'var utilFormat=Ext.util.Format,extNumber=Ext.Number,neg,absVal,fnum,parts' +
                        (hasComma ? ',thousandSeparator,thousands=[],j,n,i' : '') +
                        (extraChars  ? ',formatString="' + formatString + '",formatPattern=/[\\d,\\.#]+/' : '') +
                        ',trailingZeroes;' +
                    'return function(v){' +
                    'if(typeof v!=="number"&&isNaN(v=extNumber.from(v,NaN)))return"";' +
                    'neg=v<0;',
                    'absVal=Math.abs(v);',
                    'fnum=Ext.Number.toFixed(absVal, ' + precision + ');',
                    trimPart, ';'
                ];

                if (hasComma) {
                    // If we have to insert commas...
                    
                    // split the string up into whole and decimal parts if there are decimals
                    if (precision) {
                        code[code.length] = 'parts=fnum.split(".");';
                        code[code.length] = 'fnum=parts[0];';
                    }
                    code[code.length] =
                        'if(absVal>=1000) {';
                            code[code.length] = 'thousandSeparator=utilFormat.thousandSeparator;' +
                            'thousands.length=0;' +
                            'j=fnum.length;' +
                            'n=fnum.length%3||3;' +
                            'for(i=0;i<j;i+=n){' +
                                'if(i!==0){' +
                                    'n=3;' +
                                '}' +
                                'thousands[thousands.length]=fnum.substr(i,n);' +
                            '}' +
                            'fnum=thousands.join(thousandSeparator);' + 
                        '}';
                    if (precision) {
                        code[code.length] = 'fnum += utilFormat.decimalSeparator+parts[1];';
                    }
                    
                } else if (precision) {
                    // If they are using a weird decimal separator, split and concat using it
                    code[code.length] = 'if(utilFormat.decimalSeparator!=="."){' +
                        'parts=fnum.split(".");' +
                        'fnum=parts[0]+utilFormat.decimalSeparator+parts[1];' +
                    '}';
                }

                if (trimTrailingZeroes) {
                    code[code.length] = 'fnum=fnum.replace(trailingZeroes,"");';
                }

                /*
                 * エッジケース。非常に小さな負の数を持っている場合、その数は0に丸められます。ただし、上位での最初のチェックでは依然、負として報告されます。1-9以外はすべて置き換え、文字列が0値を決定するために空になっているかをチェックします。
                 */
                code[code.length] = 'if(neg&&fnum!=="' + (precision ? '0.' + Ext.String.repeat('0', precision) : '0') + '")fnum="-"+fnum;';

                code[code.length] = 'return ';

                // If there were extra characters around the formatting string, replace the format string part with the formatted number.
                if (extraChars) {
                    code[code.length] = 'formatString.replace(formatPattern, fnum);';
                } else {
                    code[code.length] = 'fnum;';
                }
                code[code.length] = '};';

                formatFn = me.formatFns[originalFormatString] = Ext.functionFactory('Ext', code.join(''))(Ext);
            }
            return formatFn(v);
        },

        /**
         * 数字をレンダリングする関数を返します。 適用する数字のフォーマットを何度も行う場合に効率的に、再利用できる関数です。
         *
         * @param {String} format {@link #number}の有効な数字フォーマット文字列
         * @return {Function} 数字をフォーマットする関数
         */
        numberRenderer : function(format) {
            return function(v) {
                return me.number(v, format);
            };
        },

        /**
         * 渡されたフォーマット文字列に応じて渡された数をパーセンテージでフォーマットします。数字は0～1の間で、0%～100%を表現するものであることが必要です。
         *
         * @param {Number} value フォーマットするパーセンテージ。
         * @param {String} [formatString="0"] 詳細は{@link #number}を参照してください。
         * @return {String} フォーマットされたパーセンテージ。
         */
        percent: function (value, formatString) {
            return me.number(value * 100, formatString || '0') + me.percentSign;
        },

        /**
         * テキストのマークアップ作成時の使用に適したHTML要素の属性値として、名前の値のプロパティのオブジェクトをフォーマットします。
         * @param {Object} attributes HTML属性をプロパティとして含んでいるオブジェクト。例：`{height:40, vAlign:'top'}。`
         */
        attributes: function(attributes) {
            if (typeof attributes === 'object') {
                var result = [],
                    name;

                for (name in attributes) {
                    if (attributes.hasOwnProperty(name)) {
                        result.push(name, '="', name === 'style' ? 
                                Ext.DomHelper.generateStyles(attributes[name], null, true) :
                                Ext.htmlEncode(attributes[name]), '" ');
                    }
                }
                attributes = result.join('');
            }
            return attributes || '';
        },

        /**
         * 数値に基づいて、単語を複数形にします。たとえば、テンプレートでは、 `{commentCount:plural("Comment")}`はcommentCountが1の場合、`"1 Comment"`となります。 また、commentCountが0または、1より大きい場合は、`"x Comments"`となります。
         *
         * @param {Number} value 比較する値
         * @param {String} singular 単語の単数形
         * @param {String} [plural] 単語の複数形(デフォルトは、単数形に"s"を追加)
         */
        plural : function(v, s, p) {
            return v +' ' + (v === 1 ? s : (p ? p : s+'s'));
        },

        /**
         * 改行文字をHTMLタグの`<br/>`に変換します。
         *
         * @param {String} v フォーマットする文字列。
         * @return {String} 改行文字の代わりに`<br/>`タグが入った文字列。
         */
        nl2br : function(v) {
            return Ext.isEmpty(v) ? '' : v.replace(me.nl2brRe, '<br/>');
        },

        /**
         * {@link Ext.String#capitalize}のエイリアスです。
         * @method
         * @inheritdoc Ext.String#capitalize
         */
        capitalize: Ext.String.capitalize,

        /**
         * {@link Ext.String#uncapitalize}のエイリアス。
         * @method
         * @inheritdoc Ext.String#uncapitalize
         */
        uncapitalize: Ext.String.uncapitalize,

        /**
         * {@link Ext.String#ellipsis}のエイリアスです。
         * @method
         * @inheritdoc Ext.String#ellipsis
         */
        ellipsis: Ext.String.ellipsis,

        /**
         * {@link Ext.String#escape}のエイリアス。
         * @method
         * @inheritdoc Ext.String#escape
         */
        escape: Ext.String.escape,

        /**
         * {@link Ext.String#escapeRegex}のエイリアス。
         * @method
         * @inheritdoc Ext.String#escapeRegex
         */
        escapeRegex : Ext.String.escapeRegex,

        /**
         * {@link Ext.String#htmlDecode}用のエイリアス。
         * @method
         * @inheritdoc Ext.String#htmlDecode
         */
        htmlDecode: Ext.String.htmlDecode,

        /**
         * {@link Ext.String#htmlEncode}用のエイリアス。
         * @method
         * @inheritdoc Ext.String#htmlEncode
         */
        htmlEncode: Ext.String.htmlEncode,

        /**
         * {@link Ext.String#leftPad}のエイリアスです。
         * @method
         * @inheritdoc Ext.String#leftPad
         */
        leftPad: Ext.String.leftPad,

        /**
         * {@link Ext.String#toggle}のエイリアス。
         * @method
         * @inheritdoc Ext.String#toggle
         */
        toggle: Ext.String.toggle,

        /**
         * {@link Ext.String#trim}のエイリアスです。
         * @method
         * @inheritdoc Ext.String#trim
         */
        trim : Ext.String.trim,

        /**
         * マージンのサイズを表現している数値または文字列をオブジェクトにパースします。CSSのマージン(margin)をサポートしています(例: 10 や "10"、"10 10"、"10 10 10"、"10 10 10 10" などに有効で、これらは、同じ結果を返します。 )。
         *
         * @param {Number/String} box エンコードされたマージン
         * @return {Object} top、right、bottom、leftのマージンのサイズを持つオブジェクト。
         */
        parseBox : function(box) {
            box = box || 0;

            if (typeof box === 'number') {
                return {
                    top   : box,
                    right : box,
                    bottom: box,
                    left  : box
                };
             }

            var parts  = box.split(' '),
                ln = parts.length;

            if (ln === 1) {
                parts[1] = parts[2] = parts[3] = parts[0];
            }
            else if (ln === 2) {
                parts[2] = parts[0];
                parts[3] = parts[1];
            }
            else if (ln === 3) {
                parts[3] = parts[1];
            }

            return {
                top   :parseInt(parts[0], 10) || 0,
                right :parseInt(parts[1], 10) || 0,
                bottom:parseInt(parts[2], 10) || 0,
                left  :parseInt(parts[3], 10) || 0
            };
        }
    };
});