extjs-rails 4.1.0.alpha1

data/app/assets/javascripts/extjs-rails/src/core/src/util/Event.js

@@ -0,0 +1,215 @@
+Ext.require('Ext.util.DelayedTask', function() {
+
+    /**
+     * Represents single event type that an Observable object listens to.
+     * All actual listeners are tracked inside here.  When the event fires,
+     * it calls all the registered listener functions.
+     *
+     * @private
+     */
+    Ext.util.Event = Ext.extend(Object, (function() {
+        function createTargeted(handler, listener, o, scope){
+            return function(){
+                if (o.target === arguments[0]){
+                    handler.apply(scope, arguments);
+                }
+            };
+        }
+
+        function createBuffered(handler, listener, o, scope) {
+            listener.task = new Ext.util.DelayedTask();
+            return function() {
+                listener.task.delay(o.buffer, handler, scope, Ext.Array.toArray(arguments));
+            };
+        }
+
+        function createDelayed(handler, listener, o, scope) {
+            return function() {
+                var task = new Ext.util.DelayedTask();
+                if (!listener.tasks) {
+                    listener.tasks = [];
+                }
+                listener.tasks.push(task);
+                task.delay(o.delay || 10, handler, scope, Ext.Array.toArray(arguments));
+            };
+        }
+
+        function createSingle(handler, listener, o, scope) {
+            return function() {
+                var event = listener.ev;
+
+                if (event.removeListener(listener.fn, scope) && event.observable) {
+                    // Removing from a regular Observable-owned, named event (not an anonymous
+                    // event such as Ext's readyEvent): Decrement the listeners count
+                    event.observable.hasListeners[event.name]--;
+                }
+
+                return handler.apply(scope, arguments);
+            };
+        }
+
+        return {
+            /**
+             * @property {Boolean} isEvent
+             * `true` in this class to identify an object as an instantiated Event, or subclass thereof.
+             */
+            isEvent: true,
+
+            constructor: function(observable, name) {
+                this.name = name;
+                this.observable = observable;
+                this.listeners = [];
+            },
+
+            addListener: function(fn, scope, options) {
+                var me = this,
+                    listener;
+                    scope = scope || me.observable;
+
+                //<debug error>
+                if (!fn) {
+                    Ext.Error.raise({
+                        sourceClass: Ext.getClassName(this.observable),
+                        sourceMethod: "addListener",
+                        msg: "The specified callback function is undefined"
+                    });
+                }
+                //</debug>
+
+                if (!me.isListening(fn, scope)) {
+                    listener = me.createListener(fn, scope, options);
+                    if (me.firing) {
+                        // if we are currently firing this event, don't disturb the listener loop
+                        me.listeners = me.listeners.slice(0);
+                    }
+                    me.listeners.push(listener);
+                }
+            },
+
+            createListener: function(fn, scope, o) {
+                o = o || {};
+                scope = scope || this.observable;
+
+                var listener = {
+                        fn: fn,
+                        scope: scope,
+                        o: o,
+                        ev: this
+                    },
+                    handler = fn;
+
+                // The order is important. The 'single' wrapper must be wrapped by the 'buffer' and 'delayed' wrapper
+                // because the event removal that the single listener does destroys the listener's DelayedTask(s)
+                if (o.single) {
+                    handler = createSingle(handler, listener, o, scope);
+                }
+                if (o.target) {
+                    handler = createTargeted(handler, listener, o, scope);
+                }
+                if (o.delay) {
+                    handler = createDelayed(handler, listener, o, scope);
+                }
+                if (o.buffer) {
+                    handler = createBuffered(handler, listener, o, scope);
+                }
+
+                listener.fireFn = handler;
+                return listener;
+            },
+
+            findListener: function(fn, scope) {
+                var listeners = this.listeners,
+                i = listeners.length,
+                listener,
+                s;
+
+                while (i--) {
+                    listener = listeners[i];
+                    if (listener) {
+                        s = listener.scope;
+                        if (listener.fn == fn && (s == scope || s == this.observable)) {
+                            return i;
+                        }
+                    }
+                }
+
+                return - 1;
+            },
+
+            isListening: function(fn, scope) {
+                return this.findListener(fn, scope) !== -1;
+            },
+
+            removeListener: function(fn, scope) {
+                var me = this,
+                    index,
+                    listener,
+                    k;
+                index = me.findListener(fn, scope);
+                if (index != -1) {
+                    listener = me.listeners[index];
+
+                    if (me.firing) {
+                        me.listeners = me.listeners.slice(0);
+                    }
+
+                    // cancel and remove a buffered handler that hasn't fired yet
+                    if (listener.task) {
+                        listener.task.cancel();
+                        delete listener.task;
+                    }
+
+                    // cancel and remove all delayed handlers that haven't fired yet
+                    k = listener.tasks && listener.tasks.length;
+                    if (k) {
+                        while (k--) {
+                            listener.tasks[k].cancel();
+                        }
+                        delete listener.tasks;
+                    }
+
+                    // remove this listener from the listeners array
+                    Ext.Array.erase(me.listeners, index, 1);
+                    return true;
+                }
+
+                return false;
+            },
+
+            // Iterate to stop any buffered/delayed events
+            clearListeners: function() {
+                var listeners = this.listeners,
+                    i = listeners.length;
+
+                while (i--) {
+                    this.removeListener(listeners[i].fn, listeners[i].scope);
+                }
+            },
+
+            fire: function() {
+                var me = this,
+                    listeners = me.listeners,
+                    count = listeners.length,
+                    i,
+                    args,
+                    listener;
+
+                if (count > 0) {
+                    me.firing = true;
+                    for (i = 0; i < count; i++) {
+                        listener = listeners[i];
+                        args = arguments.length ? Array.prototype.slice.call(arguments, 0) : [];
+                        if (listener.o) {
+                            args.push(listener.o);
+                        }
+                        if (listener && listener.fireFn.apply(listener.scope || me.observable, args) === false) {
+                            return (me.firing = false);
+                        }
+                    }
+                }
+                me.firing = false;
+                return true;
+            }
+        };
+    }()));
+});

data/app/assets/javascripts/extjs-rails/src/core/src/util/Format.js

@@ -0,0 +1,551 @@
+/**
+ * @class Ext.util.Format
+
+This class is a centralized place for formatting functions. It includes
+functions to format various different types of data, such as text, dates and numeric values.
+
+__Localization__
+This class contains several options for localization. These can be set once the library has loaded,
+all calls to the functions from that point will use the locale settings that were specified.
+Options include:
+- thousandSeparator
+- decimalSeparator
+- currenyPrecision
+- currencySign
+- currencyAtEnd
+This class also uses the default date format defined here: {@link Ext.Date#defaultFormat}.
+
+__Using with renderers__
+There are two helper functions that return a new function that can be used in conjunction with
+grid renderers:
+
+    columns: [{
+        dataIndex: 'date',
+        renderer: Ext.util.Format.dateRenderer('Y-m-d')
+    }, {
+        dataIndex: 'time',
+        renderer: Ext.util.Format.numberRenderer('0.000')
+    }]
+
+Functions that only take a single argument can also be passed directly:
+    columns: [{
+        dataIndex: 'cost',
+        renderer: Ext.util.Format.usMoney
+    }, {
+        dataIndex: 'productCode',
+        renderer: Ext.util.Format.uppercase
+    }]
+
+__Using with XTemplates__
+XTemplates can also directly use Ext.util.Format functions:
+
+    new Ext.XTemplate([
+        'Date: {startDate:date("Y-m-d")}',
+        'Cost: {cost:usMoney}'
+    ]);
+
+ * @markdown
+ * @singleton
+ */
+(function() {
+    Ext.ns('Ext.util');
+
+    Ext.util.Format = {};
+    var UtilFormat     = Ext.util.Format,
+        stripTagsRE    = /<\/?[^>]+>/gi,
+        stripScriptsRe = /(?:<script.*?>)((\n|\r|.)*?)(?:<\/script>)/ig,
+        nl2brRe        = /\r?\n/g,
+
+        // 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;
+
+    Ext.apply(UtilFormat, {
+        /**
+         * @property {String} thousandSeparator
+         * <p>The character that the {@link #number} function uses as a thousand separator.</p>
+         * <p>This may be overridden in a locale file.</p>
+         */
+        //<locale>
+        thousandSeparator: ',',
+        //</locale>
+
+        /**
+         * @property {String} decimalSeparator
+         * <p>The character that the {@link #number} function uses as a decimal point.</p>
+         * <p>This may be overridden in a locale file.</p>
+         */
+        //<locale>
+        decimalSeparator: '.',
+        //</locale>
+
+        /**
+         * @property {Number} currencyPrecision
+         * <p>The number of decimal places that the {@link #currency} function displays.</p>
+         * <p>This may be overridden in a locale file.</p>
+         */
+        //<locale>
+        currencyPrecision: 2,
+        //</locale>
+
+        /**
+         * @property {String} currencySign
+         * <p>The currency sign that the {@link #currency} function displays.</p>
+         * <p>This may be overridden in a locale file.</p>
+         */
+         //<locale>
+        currencySign: '$',
+        //</locale>
+
+        /**
+         * @property {Boolean} currencyAtEnd
+         * <p>This may be set to <code>true</code> to make the {@link #currency} function
+         * append the currency sign to the formatted value.</p>
+         * <p>This may be overridden in a locale file.</p>
+         */
+        //<locale>
+        currencyAtEnd: false,
+        //</locale>
+
+        /**
+         * Checks a reference and converts it to empty string if it is undefined
+         * @param {Object} value Reference to check
+         * @return {Object} Empty string if converted, otherwise the original value
+         */
+        undef : function(value) {
+            return value !== undefined ? value : "";
+        },
+
+        /**
+         * Checks a reference and converts it to the default value if it's empty
+         * @param {Object} value Reference to check
+         * @param {String} defaultValue The value to insert of it's undefined (defaults to "")
+         * @return {String}
+         */
+        defaultValue : function(value, defaultValue) {
+            return value !== undefined && value !== '' ? value : defaultValue;
+        },
+
+        /**
+         * Returns a substring from within an original string
+         * @param {String} value The original text
+         * @param {Number} start The start index of the substring
+         * @param {Number} length The length of the substring
+         * @return {String} The substring
+         */
+        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);
+        },
+
+        /**
+         * Converts a string to all lower case letters
+         * @param {String} value The text to convert
+         * @return {String} The converted text
+         */
+        lowercase : function(value) {
+            return String(value).toLowerCase();
+        },
+
+        /**
+         * Converts a string to all upper case letters
+         * @param {String} value The text to convert
+         * @return {String} The converted text
+         */
+        uppercase : function(value) {
+            return String(value).toUpperCase();
+        },
+
+        /**
+         * Format a number as US currency
+         * @param {Number/String} value The numeric value to format
+         * @return {String} The formatted currency string
+         */
+        usMoney : function(v) {
+            return UtilFormat.currency(v, '$', 2);
+        },
+
+        /**
+         * Format a number as a currency
+         * @param {Number/String} value The numeric value to format
+         * @param {String} sign The currency sign to use (defaults to {@link #currencySign})
+         * @param {Number} decimals The number of decimals to use for the currency (defaults to {@link #currencyPrecision})
+         * @param {Boolean} end True if the currency sign should be at the end of the string (defaults to {@link #currencyAtEnd})
+         * @return {String} The formatted currency 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 : UtilFormat.currencyPrecision;
+            format += format + (decimals > 0 ? '.' : '');
+            for (; i < decimals; i++) {
+                format += '0';
+            }
+            v = UtilFormat.number(v, format);
+            if ((end || UtilFormat.currencyAtEnd) === true) {
+                return Ext.String.format("{0}{1}{2}", negativeSign, v, currencySign || UtilFormat.currencySign);
+            } else {
+                return Ext.String.format("{0}{1}{2}", negativeSign, currencySign || UtilFormat.currencySign, v);
+            }
+        },
+
+        /**
+         * Formats the passed date using the specified format pattern.
+         * @param {String/Date} value The value to format. If a string is passed, it is converted to a Date by the Javascript
+         * Date object's <a href="http://www.w3schools.com/jsref/jsref_parse.asp">parse()</a> method.
+         * @param {String} format (Optional) Any valid date format string. Defaults to {@link Ext.Date#defaultFormat}.
+         * @return {String} The formatted date 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);
+        },
+
+        /**
+         * Returns a date rendering function that can be reused to apply a date format multiple times efficiently
+         * @param {String} format Any valid date format string. Defaults to {@link Ext.Date#defaultFormat}.
+         * @return {Function} The date formatting function
+         */
+        dateRenderer : function(format) {
+            return function(v) {
+                return UtilFormat.date(v, format);
+            };
+        },
+
+        /**
+         * Strips all HTML tags
+         * @param {Object} value The text from which to strip tags
+         * @return {String} The stripped text
+         */
+        stripTags : function(v) {
+            return !v ? v : String(v).replace(stripTagsRE, "");
+        },
+
+        /**
+         * Strips all script tags
+         * @param {Object} value The text from which to strip script tags
+         * @return {String} The stripped text
+         */
+        stripScripts : function(v) {
+            return !v ? v : String(v).replace(stripScriptsRe, "");
+        },
+
+        /**
+         * Simple format for a file size (xxx bytes, xxx KB, xxx MB)
+         * @param {Number/String} size The numeric value to format
+         * @return {String} The formatted file size
+         */
+        fileSize : function(size) {
+            if (size < 1024) {
+                return size + " bytes";
+            } else if (size < 1048576) {
+                return (Math.round(((size*10) / 1024))/10) + " KB";
+            } else {
+                return (Math.round(((size*10) / 1048576))/10) + " MB";
+            }
+        },
+
+        /**
+         * It does simple math for use in a template, for example:<pre><code>
+         * var tpl = new Ext.Template('{value} * 10 = {value:math("* 10")}');
+         * </code></pre>
+         * @return {Function} A function that operates on the passed value.
+         * @method
+         */
+        math : (function(){
+            var fns = {};
+
+            return function(v, a){
+                if (!fns[a]) {
+                    fns[a] = Ext.functionFactory('v', 'return v ' + a + ';');
+                }
+                return fns[a](v);
+            };
+        }()),
+
+        /**
+         * Rounds the passed number to the required decimal precision.
+         * @param {Number/String} value The numeric value to round.
+         * @param {Number} precision The number of decimal places to which to round the first parameter's value.
+         * @return {Number} The rounded value.
+         */
+        round : function(value, precision) {
+            var result = Number(value);
+            if (typeof precision == 'number') {
+                precision = Math.pow(10, precision);
+                result = Math.round(value * precision) / precision;
+            }
+            return result;
+        },
+
+        /**
+         * <p>Formats the passed number according to the passed format string.</p>
+         * <p>The number of digits after the decimal separator character specifies the number of
+         * decimal places in the resulting string. The <u>local-specific</u> decimal character is used in the result.</p>
+         * <p>The <i>presence</i> of a thousand separator character in the format string specifies that
+         * the <u>locale-specific</u> thousand separator (if any) is inserted separating thousand groups.</p>
+         * <p>By default, "," is expected as the thousand separator, and "." is expected as the decimal separator.</p>
+         * <p><b>New to Ext JS 4</b></p>
+         * <p>Locale-specific characters are always used in the formatted output when inserting
+         * thousand and decimal separators.</p>
+         * <p>The format string must specify separator characters according to US/UK conventions ("," as the
+         * thousand separator, and "." as the decimal separator)</p>
+         * <p>To allow specification of format strings according to local conventions for separator characters, add
+         * the string <code>/i</code> to the end of the format string.</p>
+         * <div style="margin-left:40px">examples (123456.789):
+         * <div style="margin-left:10px">
+         * 0 - (123456) show only digits, no precision<br>
+         * 0.00 - (123456.78) show only digits, 2 precision<br>
+         * 0.0000 - (123456.7890) show only digits, 4 precision<br>
+         * 0,000 - (123,456) show comma and digits, no precision<br>
+         * 0,000.00 - (123,456.78) show comma and digits, 2 precision<br>
+         * 0,0.00 - (123,456.78) shortcut method, show comma and digits, 2 precision<br>
+         * To allow specification of the formatting string using UK/US grouping characters (,) and decimal (.) for international numbers, add /i to the end.
+         * For example: 0.000,00/i
+         * </div></div>
+         * @param {Number} v The number to format.
+         * @param {String} format The way you would like to format this text.
+         * @return {String} The formatted number.
+         */
+        number : function(v, formatString) {
+            if (!formatString) {
+                return v;
+            }
+            v = Ext.Number.from(v, NaN);
+            if (isNaN(v)) {
+                return '';
+            }
+            var comma = UtilFormat.thousandSeparator,
+                dec   = UtilFormat.decimalSeparator,
+                i18n  = false,
+                neg   = v < 0,
+                hasComma,
+                psplit,
+                fnum,
+                cnum,
+                parr,
+                j,
+                m,
+                n,
+                i;
+
+            v = Math.abs(v);
+
+            // 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') {
+                if (!I18NFormatCleanRe) {
+                    I18NFormatCleanRe = new RegExp('[^\\d\\' + UtilFormat.decimalSeparator + ']','g');
+                }
+                formatString = formatString.substr(0, formatString.length - 2);
+                i18n   = true;
+                hasComma = formatString.indexOf(comma) != -1;
+                psplit = formatString.replace(I18NFormatCleanRe, '').split(dec);
+            } else {
+                hasComma = formatString.indexOf(',') != -1;
+                psplit = formatString.replace(formatCleanRe, '').split('.');
+            }
+
+            if (psplit.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 (psplit.length > 1) {
+                v = Ext.Number.toFixed(v, psplit[1].length);
+            } else {
+                v = Ext.Number.toFixed(v, 0);
+            }
+
+            fnum = v.toString();
+
+            psplit = fnum.split('.');
+
+            if (hasComma) {
+                cnum = psplit[0];
+                parr = [];
+                j = cnum.length;
+                m = Math.floor(j / 3);
+                n = cnum.length % 3 || 3;
+
+                for (i = 0; i < j; i += n) {
+                    if (i !== 0) {
+                        n = 3;
+                    }
+
+                    parr[parr.length] = cnum.substr(i, n);
+                    m -= 1;
+                }
+                fnum = parr.join(comma);
+                if (psplit[1]) {
+                    fnum += dec + psplit[1];
+                }
+            } else {
+                if (psplit[1]) {
+                    fnum = psplit[0] + dec + psplit[1];
+                }
+            }
+
+            if (neg) {
+                /*
+                 * Edge case. If we have a very small negative number it will get rounded to 0,
+                 * however the initial check at the top will still report as negative. Replace
+                 * everything but 1-9 and check if the string is empty to determine a 0 value.
+                 */
+                neg = fnum.replace(/[^1-9]/g, '') !== '';
+            }
+
+            return (neg ? '-' : '') + formatString.replace(/[\d,?\.?]+/, fnum);
+        },
+
+        /**
+         * Returns a number rendering function that can be reused to apply a number format multiple times efficiently
+         * @param {String} format Any valid number format string for {@link #number}
+         * @return {Function} The number formatting function
+         */
+        numberRenderer : function(format) {
+            return function(v) {
+                return UtilFormat.number(v, format);
+            };
+        },
+
+        /**
+         * Selectively do a plural form of a word based on a numeric value. For example, in a template,
+         * {commentCount:plural("Comment")}  would result in "1 Comment" if commentCount was 1 or would be "x Comments"
+         * if the value is 0 or greater than 1.
+         * @param {Number} value The value to compare against
+         * @param {String} singular The singular form of the word
+         * @param {String} plural (optional) The plural form of the word (defaults to the singular with an "s")
+         */
+        plural : function(v, s, p) {
+            return v +' ' + (v == 1 ? s : (p ? p : s+'s'));
+        },
+
+        /**
+         * Converts newline characters to the HTML tag &lt;br/>
+         * @param {String} The string value to format.
+         * @return {String} The string with embedded &lt;br/> tags in place of newlines.
+         */
+        nl2br : function(v) {
+            return Ext.isEmpty(v) ? '' : v.replace(nl2brRe, '<br/>');
+        },
+
+        /**
+         * Alias for {@link Ext.String#capitalize}.
+         * @method
+         * @inheritdoc Ext.String#capitalize
+         */
+        capitalize: Ext.String.capitalize,
+
+        /**
+         * Alias for {@link Ext.String#ellipsis}.
+         * @method
+         * @inheritdoc Ext.String#ellipsis
+         */
+        ellipsis: Ext.String.ellipsis,
+
+        /**
+         * Alias for {@link Ext.String#format}.
+         * @method
+         * @inheritdoc Ext.String#format
+         */
+        format: Ext.String.format,
+
+        /**
+         * Alias for {@link Ext.String#htmlDecode}.
+         * @method
+         * @inheritdoc Ext.String#htmlDecode
+         */
+        htmlDecode: Ext.String.htmlDecode,
+
+        /**
+         * Alias for {@link Ext.String#htmlEncode}.
+         * @method
+         * @inheritdoc Ext.String#htmlEncode
+         */
+        htmlEncode: Ext.String.htmlEncode,
+
+        /**
+         * Alias for {@link Ext.String#leftPad}.
+         * @method
+         * @inheritdoc Ext.String#leftPad
+         */
+        leftPad: Ext.String.leftPad,
+
+        /**
+         * Alias for {@link Ext.String#trim}.
+         * @method
+         * @inheritdoc Ext.String#trim
+         */
+        trim : Ext.String.trim,
+
+        /**
+         * Parses a number or string representing margin sizes into an object. Supports CSS-style margin declarations
+         * (e.g. 10, "10", "10 10", "10 10 10" and "10 10 10 10" are all valid options and would return the same result)
+         * @param {Number/String} v The encoded margins
+         * @return {Object} An object with margin sizes for top, right, bottom and left
+         */
+        parseBox : function(box) {
+          box = Ext.isEmpty(box) ? '' : box;
+            if (Ext.isNumber(box)) {
+                box = box.toString();
+            }
+            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
+            };
+        },
+
+        /**
+         * Escapes the passed string for use in a regular expression
+         * @param {String} str
+         * @return {String}
+         */
+        escapeRegex : function(s) {
+            return s.replace(/([\-.*+?\^${}()|\[\]\/\\])/g, "\\$1");
+        }
+    });
+}());