RubyGems - yui-rails-asset - Versions diffs - 2.8.1 - Mend

yui-rails-asset 2.8.1

Files changed (398) hide show

data/vendor/assets/javascripts/yui-2.8.1/build/history/assets/blank.html ADDED

	@@ -0,0 +1 @@
1	+ <html><head><title>bhm</title></head><body> </body></html>

data/vendor/assets/javascripts/yui-2.8.1/build/history/history-debug.js ADDED

@@ -0,0 +1,808 @@
+/*
+Copyright (c) 2010, Yahoo! Inc. All rights reserved.
+Code licensed under the BSD License:
+http://developer.yahoo.com/yui/license.html
+version: 2.8.1
+*/
+/**
+ * The Browser History Manager provides the ability to use the back/forward
+ * navigation buttons in a DHTML application. It also allows a DHTML
+ * application to be bookmarked in a specific state.
+ *
+ * This library requires the following static markup:
+ *
+ * &lt;iframe id="yui-history-iframe" src="path-to-real-asset-in-same-domain"&gt;&lt;/iframe&gt;
+ * &lt;input id="yui-history-field" type="hidden"&gt;
+ *
+ * @module history
+ * @requires yahoo,event
+ * @namespace YAHOO.util
+ * @title Browser History Manager
+ */
+/**
+ * The History class provides the ability to use the back/forward navigation
+ * buttons in a DHTML application. It also allows a DHTML application to
+ * be bookmarked in a specific state.
+ *
+ * @class History
+ * @constructor
+ */
+YAHOO.util.History = (function () {
+    /**
+     * Our hidden IFrame used to store the browsing history.
+     *
+     * @property _histFrame
+     * @type HTMLIFrameElement
+     * @default null
+     * @private
+     */
+    var _histFrame = null;
+    /**
+     * INPUT field (with type="hidden" or type="text") or TEXTAREA.
+     * This field keeps the value of the initial state, current state
+     * the list of all states across pages within a single browser session.
+     *
+     * @property _stateField
+     * @type HTMLInputElement|HTMLTextAreaElement
+     * @default null
+     * @private
+     */
+    var _stateField = null;
+    /**
+     * Flag used to tell whether YAHOO.util.History.initialize has been called.
+     *
+     * @property _initialized
+     * @type boolean
+     * @default false
+     * @private
+     */
+    var _initialized = false;
+    /**
+     * List of registered modules.
+     *
+     * @property _modules
+     * @type array
+     * @default []
+     * @private
+     */
+    var _modules = [];
+    /**
+     * List of fully qualified states. This is used only by Safari.
+     *
+     * @property _fqstates
+     * @type array
+     * @default []
+     * @private
+     */
+    var _fqstates = [];
+    /**
+     * location.hash is a bit buggy on Opera. I have seen instances where
+     * navigating the history using the back/forward buttons, and hence
+     * changing the URL, would not change location.hash. That's ok, the
+     * implementation of an equivalent is trivial.
+     *
+     * @method _getHash
+     * @return {string} The hash portion of the document's location
+     * @private
+     */
+    function _getHash() {
+        var i, href;
+        href = top.location.href;
+        i = href.indexOf("#");
+        return i >= 0 ? href.substr(i + 1) : null;
+    }
+    /**
+     * Stores all the registered modules' initial state and current state.
+     * On Safari, we also store all the fully qualified states visited by
+     * the application within a single browser session. The storage takes
+     * place in the form field specified during initialization.
+     *
+     * @method _storeStates
+     * @private
+     */
+    function _storeStates() {
+        var moduleName, moduleObj, initialStates = [], currentStates = [];
+        for (moduleName in _modules) {
+            if (YAHOO.lang.hasOwnProperty(_modules, moduleName)) {
+                moduleObj = _modules[moduleName];
+                initialStates.push(moduleName + "=" + moduleObj.initialState);
+                currentStates.push(moduleName + "=" + moduleObj.currentState);
+            }
+        }
+        _stateField.value = initialStates.join("&") + "|" + currentStates.join("&");
+        if (YAHOO.env.ua.webkit) {
+            _stateField.value += "|" + _fqstates.join(",");
+        }
+    }
+    /**
+     * Sets the new currentState attribute of all modules depending on the new
+     * fully qualified state. Also notifies the modules which current state has
+     * changed.
+     *
+     * @method _handleFQStateChange
+     * @param {string} fqstate Fully qualified state
+     * @private
+     */
+    function _handleFQStateChange(fqstate) {
+        var i, len, moduleName, moduleObj, modules, states, tokens, currentState;
+        if (!fqstate) {
+            // Notifies all modules
+            for (moduleName in _modules) {
+                if (YAHOO.lang.hasOwnProperty(_modules, moduleName)) {
+                    moduleObj = _modules[moduleName];
+                    moduleObj.currentState = moduleObj.initialState;
+                    moduleObj.onStateChange(unescape(moduleObj.currentState));
+                }
+            }
+            return;
+        }
+        modules = [];
+        states = fqstate.split("&");
+        for (i = 0, len = states.length; i < len; i++) {
+            tokens = states[i].split("=");
+            if (tokens.length === 2) {
+                moduleName = tokens[0];
+                currentState = tokens[1];
+                modules[moduleName] = currentState;
+            }
+        }
+        for (moduleName in _modules) {
+            if (YAHOO.lang.hasOwnProperty(_modules, moduleName)) {
+                moduleObj = _modules[moduleName];
+                currentState = modules[moduleName];
+                if (!currentState || moduleObj.currentState !== currentState) {
+                    moduleObj.currentState = currentState || moduleObj.initialState;
+                    moduleObj.onStateChange(unescape(moduleObj.currentState));
+                }
+            }
+        }
+    }
+    /**
+     * Update the IFrame with our new state.
+     *
+     * @method _updateIFrame
+     * @private
+     * @return {boolean} true if successful. false otherwise.
+     */
+    function _updateIFrame (fqstate) {
+        var html, doc;
+        html = '<html><body><div id="state">' +
+                   fqstate.replace(/&/g,'&amp;').
+                           replace(/</g,'&lt;').
+                           replace(/>/g,'&gt;').
+                           replace(/"/g,'&quot;') +
+               '</div></body></html>';
+        try {
+            doc = _histFrame.contentWindow.document;
+            doc.open();
+            doc.write(html);
+            doc.close();
+            return true;
+        } catch (e) {
+            return false;
+        }
+    }
+    /**
+     * Periodically checks whether our internal IFrame is ready to be used.
+     *
+     * @method _checkIframeLoaded
+     * @private
+     */
+    function _checkIframeLoaded() {
+        var doc, elem, fqstate, hash;
+        if (!_histFrame.contentWindow || !_histFrame.contentWindow.document) {
+            // Check again in 10 msec...
+            setTimeout(_checkIframeLoaded, 10);
+            return;
+        }
+        // Start the thread that will have the responsibility to
+        // periodically check whether a navigate operation has been
+        // requested on the main window. This will happen when
+        // YAHOO.util.History.navigate has been called or after
+        // the user has hit the back/forward button.
+        doc = _histFrame.contentWindow.document;
+        elem = doc.getElementById("state");
+        // We must use innerText, and not innerHTML because our string contains
+        // the "&" character (which would end up being escaped as "&amp;") and
+        // the string comparison would fail...
+        fqstate = elem ? elem.innerText : null;
+        hash = _getHash();
+        setInterval(function () {
+            var newfqstate, states, moduleName, moduleObj, newHash, historyLength;
+            doc = _histFrame.contentWindow.document;
+            elem = doc.getElementById("state");
+            // See my comment above about using innerText instead of innerHTML...
+            newfqstate = elem ? elem.innerText : null;
+            newHash = _getHash();
+            if (newfqstate !== fqstate) {
+                fqstate = newfqstate;
+                _handleFQStateChange(fqstate);
+                if (!fqstate) {
+                    states = [];
+                    for (moduleName in _modules) {
+                        if (YAHOO.lang.hasOwnProperty(_modules, moduleName)) {
+                            moduleObj = _modules[moduleName];
+                            states.push(moduleName + "=" + moduleObj.initialState);
+                        }
+                    }
+                    newHash = states.join("&");
+                } else {
+                    newHash = fqstate;
+                }
+                // Allow the state to be bookmarked by setting the top window's
+                // URL fragment identifier. Note that here, we are on IE, and
+                // IE does not touch the browser history when setting the hash
+                // (unlike all the other browsers). I used to write:
+                //     top.location.replace( "#" + hash );
+                // but this had a side effect when the page was not the top frame.
+                top.location.hash = newHash;
+                hash = newHash;
+                _storeStates();
+            } else if (newHash !== hash) {
+                // The hash has changed. The user might have clicked on a link,
+                // or modified the URL directly, or opened the same application
+                // bookmarked in a specific state using a bookmark. However, we
+                // know the hash change was not caused by a hit on the back or
+                // forward buttons, or by a call to navigate() (because it would
+                // have been handled above) We must handle these cases, which is
+                // why we also need to keep track of hash changes on IE!
+                // Note that IE6 has some major issues with this kind of user
+                // interaction (the history stack gets completely messed up)
+                // but it seems to work fine on IE7.
+                hash = newHash;
+                // Now, store a new history entry. The following will cause the
+                // code above to execute, doing all the dirty work for us...
+                _updateIFrame(newHash);
+            }
+        }, 50);
+        _initialized = true;
+        YAHOO.util.History.onLoadEvent.fire();
+    }
+    /**
+     * Finish up the initialization of the Browser History Manager.
+     *
+     * @method _initialize
+     * @private
+     */
+    function _initialize() {
+        var i, len, parts, tokens, moduleName, moduleObj, initialStates, initialState, currentStates, currentState, counter, hash;
+        // Decode the content of our storage field...
+        parts = _stateField.value.split("|");
+        if (parts.length > 1) {
+            initialStates = parts[0].split("&");
+            for (i = 0, len = initialStates.length; i < len; i++) {
+                tokens = initialStates[i].split("=");
+                if (tokens.length === 2) {
+                    moduleName = tokens[0];
+                    initialState = tokens[1];
+                    moduleObj = _modules[moduleName];
+                    if (moduleObj) {
+                        moduleObj.initialState = initialState;
+                    }
+                }
+            }
+            currentStates = parts[1].split("&");
+            for (i = 0, len = currentStates.length; i < len; i++) {
+                tokens = currentStates[i].split("=");
+                if (tokens.length >= 2) {
+                    moduleName = tokens[0];
+                    currentState = tokens[1];
+                    moduleObj = _modules[moduleName];
+                    if (moduleObj) {
+                        moduleObj.currentState = currentState;
+                    }
+                }
+            }
+        }
+        if (parts.length > 2) {
+            _fqstates = parts[2].split(",");
+        }
+        if (YAHOO.env.ua.ie) {
+            if (typeof document.documentMode === "undefined" || document.documentMode < 8) {
+                // IE < 8 or IE8 in quirks mode or IE7 standards mode
+                _checkIframeLoaded();
+            } else {
+                // IE8 in IE8 standards mode
+                YAHOO.util.Event.on(top, "hashchange",
+                    function () {
+                        var hash = _getHash();
+                        _handleFQStateChange(hash);
+                        _storeStates();
+                    });
+                _initialized = true;
+                YAHOO.util.History.onLoadEvent.fire();
+            }
+        } else {
+            // Start the thread that will have the responsibility to
+            // periodically check whether a navigate operation has been
+            // requested on the main window. This will happen when
+            // YAHOO.util.History.navigate has been called or after
+            // the user has hit the back/forward button.
+            // On Safari 1.x and 2.0, the only way to catch a back/forward
+            // operation is to watch history.length... We basically exploit
+            // what I consider to be a bug (history.length is not supposed
+            // to change when going back/forward in the history...) This is
+            // why, in the following thread, we first compare the hash,
+            // because the hash thing will be fixed in the next major
+            // version of Safari. So even if they fix the history.length
+            // bug, all this will still work!
+            counter = history.length;
+            // On Gecko and Opera, we just need to watch the hash...
+            hash = _getHash();
+            setInterval(function () {
+                var state, newHash, newCounter;
+                newHash = _getHash();
+                newCounter = history.length;
+                if (newHash !== hash) {
+                    hash = newHash;
+                    counter = newCounter;
+                    _handleFQStateChange(hash);
+                    _storeStates();
+                } else if (newCounter !== counter && YAHOO.env.ua.webkit) {
+                    hash = newHash;
+                    counter = newCounter;
+                    state = _fqstates[counter - 1];
+                    _handleFQStateChange(state);
+                    _storeStates();
+                }
+            }, 50);
+            _initialized = true;
+            YAHOO.util.History.onLoadEvent.fire();
+        }
+    }
+    return {
+        /**
+         * Fired when the Browser History Manager is ready. If you subscribe to
+         * this event after the Browser History Manager has been initialized,
+         * it will not fire. Therefore, it is recommended to use the onReady
+         * method instead.
+         *
+         * @event onLoadEvent
+         * @see onReady
+         */
+        onLoadEvent: new YAHOO.util.CustomEvent("onLoad"),
+        /**
+         * Executes the supplied callback when the Browser History Manager is
+         * ready. This will execute immediately if called after the Browser
+         * History Manager onLoad event has fired.
+         *
+         * @method onReady
+         * @param {function} fn what to execute when the Browser History Manager is ready.
+         * @param {object} obj an optional object to be passed back as a parameter to fn.
+         * @param {boolean|object} overrideContext If true, the obj passed in becomes fn's execution scope.
+         * @see onLoadEvent
+         */
+        onReady: function (fn, obj, overrideContext) {
+            if (_initialized) {
+                setTimeout(function () {
+                    var ctx = window;
+                    if (overrideContext) {
+                        if (overrideContext === true) {
+                            ctx = obj;
+                        } else {
+                            ctx = overrideContext;
+                        }
+                    }
+                    fn.call(ctx, "onLoad", [], obj);
+                }, 0);
+            } else {
+                YAHOO.util.History.onLoadEvent.subscribe(fn, obj, overrideContext);
+            }
+        },
+        /**
+         * Registers a new module.
+         *
+         * @method register
+         * @param {string} module Non-empty string uniquely identifying the
+         *     module you wish to register.
+         * @param {string} initialState The initial state of the specified
+         *     module corresponding to its earliest history entry.
+         * @param {function} onStateChange Callback called when the
+         *     state of the specified module has changed.
+         * @param {object} obj An arbitrary object that will be passed as a
+         *     parameter to the handler.
+         * @param {boolean} overrideContext If true, the obj passed in becomes the
+         *     execution scope of the listener.
+         */
+        register: function (module, initialState, onStateChange, obj, overrideContext) {
+            var scope, wrappedFn;
+            if (typeof module !== "string" || YAHOO.lang.trim(module) === "" ||
+                typeof initialState !== "string" ||
+                typeof onStateChange !== "function") {
+                throw new Error("Missing or invalid argument");
+            }
+            if (_modules[module]) {
+                // Here, we used to throw an exception. However, users have
+                // complained about this behavior, so we now just return.
+                return;
+            }
+            // Note: A module CANNOT be registered after calling
+            // YAHOO.util.History.initialize. Indeed, we set the initial state
+            // of each registered module in YAHOO.util.History.initialize.
+            // If you could register a module after initializing the Browser
+            // History Manager, you would not read the correct state using
+            // YAHOO.util.History.getCurrentState when coming back to the
+            // page using the back button.
+            if (_initialized) {
+                throw new Error("All modules must be registered before calling YAHOO.util.History.initialize");
+            }
+            // Make sure the strings passed in do not contain our separators "," and "|"
+            module = escape(module);
+            initialState = escape(initialState);
+            // If the user chooses to override the scope, we use the
+            // custom object passed in as the execution scope.
+            scope = null;
+            if (overrideContext === true) {
+                scope = obj;
+            } else {
+                scope = overrideContext;
+            }
+            wrappedFn = function (state) {
+                return onStateChange.call(scope, state, obj);
+            };
+            _modules[module] = {
+                name: module,
+                initialState: initialState,
+                currentState: initialState,
+                onStateChange: wrappedFn
+            };
+        },
+        /**
+         * Initializes the Browser History Manager. Call this method
+         * from a script block located right after the opening body tag.
+         *
+         * @method initialize
+         * @param {string|HTML Element} stateField <input type="hidden"> used
+         *     to store application states. Must be in the static markup.
+         * @param {string|HTML Element} histFrame IFrame used to store
+         *     the history (only required on Internet Explorer)
+         * @public
+         */
+        initialize: function (stateField, histFrame) {
+            if (_initialized) {
+                // The browser history manager has already been initialized.
+                return;
+            }
+            if (YAHOO.env.ua.opera && typeof history.navigationMode !== "undefined") {
+                // Disable Opera's fast back/forward navigation mode and puts
+                // it in compatible mode. This makes anchor-based history
+                // navigation work after the page has been navigated away
+                // from and re-activated, at the cost of slowing down
+                // back/forward navigation to and from that page.
+                history.navigationMode = "compatible";
+            }
+            if (typeof stateField === "string") {
+                stateField = document.getElementById(stateField);
+            }
+            if (!stateField ||
+                stateField.tagName.toUpperCase() !== "TEXTAREA" &&
+                (stateField.tagName.toUpperCase() !== "INPUT" ||
+                 stateField.type !== "hidden" &&
+                 stateField.type !== "text")) {
+                throw new Error("Missing or invalid argument");
+            }
+            _stateField = stateField;
+            // IE < 8 or IE8 in quirks mode or IE7 standards mode
+            if (YAHOO.env.ua.ie && (typeof document.documentMode === "undefined" || document.documentMode < 8)) {
+                if (typeof histFrame === "string") {
+                    histFrame = document.getElementById(histFrame);
+                }
+                if (!histFrame || histFrame.tagName.toUpperCase() !== "IFRAME") {
+                    throw new Error("Missing or invalid argument");
+                }
+                _histFrame = histFrame;
+            }
+            // Note that the event utility MUST be included inline in the page.
+            // If it gets loaded later (which you may want to do to improve the
+            // loading speed of your site), the onDOMReady event never fires,
+            // and the history library never gets fully initialized.
+            YAHOO.util.Event.onDOMReady(_initialize);
+        },
+        /**
+         * Call this method when you want to store a new entry in the browser's history.
+         *
+         * @method navigate
+         * @param {string} module Non-empty string representing your module.
+         * @param {string} state String representing the new state of the specified module.
+         * @return {boolean} Indicates whether the new state was successfully added to the history.
+         * @public
+         */
+        navigate: function (module, state) {
+            var states;
+            if (typeof module !== "string" || typeof state !== "string") {
+                throw new Error("Missing or invalid argument");
+            }
+            states = {};
+            states[module] = state;
+            return YAHOO.util.History.multiNavigate(states);
+        },
+        /**
+         * Call this method when you want to store a new entry in the browser's history.
+         *
+         * @method multiNavigate
+         * @param {object} states Associative array of module-state pairs to set simultaneously.
+         * @return {boolean} Indicates whether the new state was successfully added to the history.
+         * @public
+         */
+        multiNavigate: function (states) {
+            var currentStates, moduleName, moduleObj, currentState, fqstate;
+            if (typeof states !== "object") {
+                throw new Error("Missing or invalid argument");
+            }
+            if (!_initialized) {
+                throw new Error("The Browser History Manager is not initialized");
+            }
+            for (moduleName in states) {
+                if (!_modules[moduleName]) {
+                    throw new Error("The following module has not been registered: " + moduleName);
+                }
+            }
+            // Generate our new full state string mod1=xxx&mod2=yyy
+            currentStates = [];
+            for (moduleName in _modules) {
+                if (YAHOO.lang.hasOwnProperty(_modules, moduleName)) {
+                    moduleObj = _modules[moduleName];
+                    if (YAHOO.lang.hasOwnProperty(states, moduleName)) {
+                        currentState = states[unescape(moduleName)];
+                    } else {
+                        currentState = unescape(moduleObj.currentState);
+                    }
+                    // Make sure the strings passed in do not contain our separators "," and "|"
+                    moduleName = escape(moduleName);
+                    currentState = escape(currentState);
+                    currentStates.push(moduleName + "=" + currentState);
+                }
+            }
+            fqstate = currentStates.join("&");
+            if (YAHOO.env.ua.ie && (typeof document.documentMode === "undefined" || document.documentMode < 8)) {
+                return _updateIFrame(fqstate);
+            } else {
+                // Known bug: On Safari 1.x and 2.0, if you have tab browsing
+                // enabled, Safari will show an endless loading icon in the
+                // tab. This has apparently been fixed in recent WebKit builds.
+                // One work around found by Dav Glass is to submit a form that
+                // points to the same document. This indeed works on Safari 1.x
+                // and 2.0 but creates bigger problems on WebKit. So for now,
+                // we'll consider this an acceptable bug, and hope that Apple
+                // comes out with their next version of Safari very soon.
+                top.location.hash = fqstate;
+                if (YAHOO.env.ua.webkit) {
+                    // The following two lines are only useful for Safari 1.x
+                    // and 2.0. Recent nightly builds of WebKit do not require
+                    // that, but unfortunately, it is not easy to differentiate
+                    // between the two. Once Safari 2.0 departs the A-grade
+                    // list, we can remove the following two lines...
+                    _fqstates[history.length] = fqstate;
+                    _storeStates();
+                }
+                return true;
+            }
+        },
+        /**
+         * Returns the current state of the specified module.
+         *
+         * @method getCurrentState
+         * @param {string} module Non-empty string representing your module.
+         * @return {string} The current state of the specified module.
+         * @public
+         */
+        getCurrentState: function (module) {
+            var moduleObj;
+            if (typeof module !== "string") {
+                throw new Error("Missing or invalid argument");
+            }
+            if (!_initialized) {
+                throw new Error("The Browser History Manager is not initialized");
+            }
+            moduleObj = _modules[module];
+            if (!moduleObj) {
+                throw new Error("No such registered module: " + module);
+            }
+            return unescape(moduleObj.currentState);
+        },
+        /**
+         * Returns the state of a module according to the URL fragment
+         * identifier. This method is useful to initialize your modules
+         * if your application was bookmarked from a particular state.
+         *
+         * @method getBookmarkedState
+         * @param {string} module Non-empty string representing your module.
+         * @return {string} The bookmarked state of the specified module.
+         * @public
+         */
+        getBookmarkedState: function (module) {
+            var i, len, idx, hash, states, tokens, moduleName;
+            if (typeof module !== "string") {
+                throw new Error("Missing or invalid argument");
+            }
+            // Use location.href instead of location.hash which is already
+            // URL-decoded, which creates problems if the state value
+            // contained special characters...
+            idx = top.location.href.indexOf("#");
+            if (idx >= 0) {
+                hash = top.location.href.substr(idx + 1);
+                states = hash.split("&");
+                for (i = 0, len = states.length; i < len; i++) {
+                    tokens = states[i].split("=");
+                    if (tokens.length === 2) {
+                        moduleName = tokens[0];
+                        if (moduleName === module) {
+                            return unescape(tokens[1]);
+                        }
+                    }
+                }
+            }
+            return null;
+        },
+        /**
+         * Returns the value of the specified query string parameter.
+         * This method is not used internally by the Browser History Manager.
+         * However, it is provided here as a helper since many applications
+         * using the Browser History Manager will want to read the value of
+         * url parameters to initialize themselves.
+         *
+         * @method getQueryStringParameter
+         * @param {string} paramName Name of the parameter we want to look up.
+         * @param {string} queryString Optional URL to look at. If not specified,
+         *     this method uses the URL in the address bar.
+         * @return {string} The value of the specified parameter, or null.
+         * @public
+         */
+        getQueryStringParameter: function (paramName, url) {
+            var i, len, idx, queryString, params, tokens;
+            url = url || top.location.href;
+            idx = url.indexOf("?");
+            queryString = idx >= 0 ? url.substr(idx + 1) : url;
+            // Remove the hash if any
+            idx = queryString.lastIndexOf("#");
+            queryString = idx >= 0 ? queryString.substr(0, idx) : queryString;
+            params = queryString.split("&");
+            for (i = 0, len = params.length; i < len; i++) {
+                tokens = params[i].split("=");
+                if (tokens.length >= 2) {
+                    if (tokens[0] === paramName) {
+                        return unescape(tokens[1]);
+                    }
+                }
+            }
+            return null;
+        }
+    };
+})();
+YAHOO.register("history", YAHOO.util.History, {version: "2.8.1", build: "19"});