esphinx-rails 1.1.2

data/lib/assets/javascripts/esphinx/util/autocomplete.js

@@ -0,0 +1,356 @@
+var
+    esPhinx,
+    Iterable;
+
+
+(function($) {
+    "use strict";
+
+    $.prototype.extend({
+
+        autocomplete: function(elementsList, options, callback) {
+            var
+                completeOften,
+                searchTextBox = this,
+                nonCharacterKeysPattern = new RegExp($
+                    .nonCharacterKeysPattern()),
+                inline = false,
+                elements2Recovery = [],
+                afterAmountCharacters = options.afterAmountCharacters,
+
+                complete2Recovery = function(object, times) {
+                    var
+                        i = 0;
+
+                    while (i++ < times) {
+                        elements2Recovery.push(object);
+                    }
+                },
+
+                resolveArguments = function(options) {
+                    if (!Object.belongToClass(options, Object)) {
+                        options = {};
+                    }
+
+                    if (typeof options.caseSensitive != "boolean") {
+                        options.caseSensitive = false;
+                    }
+
+                    if (typeof options.orderlySearch != "boolean") {
+                        options.orderlySearch = false;
+                    }
+
+                    if (typeof afterAmountCharacters != "number") {
+                        afterAmountCharacters = 1;
+                    }
+
+                },
+
+                inlineSearch = function(element, options) {
+                    var
+                        eventListenerMethod,
+                        previousSearchText = searchTextBox.value();
+
+                    if (typeof eventListenerMethod == "function") {
+                        searchTextBox.off("input", eventListenerMethod);
+                    }
+
+                    eventListenerMethod = function(e) {
+                        var
+                            resolvedList,
+                            foundElements,
+                            startingIndex,
+                            finalIndex,
+                            foundElement,
+                            previousElement = element,
+                            parent = element.clone(),
+                            searchTextLength = searchTextBox.value().length,
+                            searchTextDifference = previousSearchText.length -
+                                    searchTextLength,
+                            searchTextAmount = (searchTextLength -
+                                                afterAmountCharacters) + 1,
+
+                            replaceLast = function(object) {
+                                elements2Recovery.pop();
+                                complete2Recovery(object);
+                            };
+
+                        if (searchTextBox.value()) {
+                            startingIndex = searchTextBox.cursorPosition() - 2;
+
+                            if (startingIndex < 0) {
+                                startingIndex = 0;
+                            }
+                            finalIndex = startingIndex + searchTextDifference -
+                                1;
+
+                            // when delete
+                            if (searchTextLength < previousSearchText.length &&
+                                searchTextLength >= afterAmountCharacters) {
+
+                                if (startingIndex === 0) {
+                                    elements2Recovery.deleteAt(startingIndex,
+                                        finalIndex);
+                                } else {
+                                    elements2Recovery.deleteAt(startingIndex,
+                                        elements2Recovery.lastIndex());
+                                }
+
+                                previousElement = elements2Recovery[
+                                        elements2Recovery.lastIndex()];
+                            }
+
+                            resolvedList = resolveList(previousElement,
+                                options.order);
+                            foundElements = resolvedList.elements;
+
+                            if (foundElements.some() ||
+                                elements2Recovery.length < searchTextAmount) {
+                                if (searchTextDifference < 0) {
+                                    completeOften = Math
+                                        .abs(searchTextDifference);
+                                } else {
+                                    completeOften = searchTextAmount -
+                                        elements2Recovery.length;
+                                }
+
+                                if (foundElements.some()) {
+                                    foundElement = parent.append(foundElements);
+                                    previousElement = foundElement;
+                                }
+
+                                complete2Recovery(previousElement,
+                                                   completeOften);
+                            } else {
+                                replaceLast(previousElement);
+                            }
+
+                            previousSearchText = searchTextBox.value();
+                            callback.call($(this), foundElements, resolvedList
+                                          .maps, e);
+                        } else {
+                            // reset
+                            elements2Recovery = [];
+                            previousSearchText = "";
+                            previousElement = element;
+                            callback.call($(this), $(), e);
+                        }
+
+                    };
+
+                    searchTextBox.on("input", eventListenerMethod);
+                },
+
+                remoteSearch = function(options) {
+                    var
+                        word,
+                        prevText,
+                        nextText,
+                        element,
+                        URLParameters,
+                        resolvedList,
+                        clipboardData,
+
+                        request = function(e) {
+                            if (options.remote.URLParameters) {
+                                URLParameters = options.remote.URLParameters
+                                    .call(searchTextBox);
+                            }
+
+                            $.Ajax.new(options.remote.url.call(searchTextBox))
+                                .get({
+                                    URLParameters: URLParameters,
+                                    progress: function(xhr) {
+                                        if (options.remote.loading) {
+                                            options.remote
+                                                .loading(xhr, e);
+                                        }
+                                    },
+                                    complete: function() {
+                                        $(e.target).off("keypress");
+                                    },
+                                    success: function(r) {
+                                        element = $(r);
+
+                                        if (element.some()) {
+                                            completeOften = (searchTextBox
+                                                .value().length -
+                                                afterAmountCharacters) + 1;
+
+                                            complete2Recovery(element,
+                                                           completeOften);
+                                        }
+
+                                        resolvedList = resolveList(element,
+                                                                options.order);
+                                        callback.call(searchTextBox,
+                                            resolvedList.elements,
+                                            resolvedList.maps, e);
+                                        if (element.length) {
+                                            inlineSearch(element, options);
+                                        }
+                                    }
+                                });
+                        };
+
+                    searchTextBox.on("keyup", function(e) {
+                        word = searchTextBox.value();
+
+                        if (word.length > afterAmountCharacters) {
+                            inline = true;
+                        } else if (word.length < afterAmountCharacters) {
+                            inline = false;
+                        }
+
+                        if (word.length == afterAmountCharacters &&
+                            !nonCharacterKeysPattern.test(e.key) &&
+                            !inline &&
+                            options.remote) {
+                            $(e.target).on("keypress", function(e) {
+                                e.preventDefault();
+                            });
+
+                            request(e);
+                        }
+
+                    });
+
+                    searchTextBox.on("paste", function(e) {
+                        word = searchTextBox.value();
+                        prevText = word
+                            .slice(0, searchTextBox.cursorPosition());
+                        nextText = word
+                            .slice(searchTextBox.selectionEnd(), word.length);
+
+                        clipboardData = e.clipboardData.getData("text");
+
+                        if (word.length >= afterAmountCharacters) {
+                            inline = true;
+                        } else {
+                            inline = false;
+                        }
+
+                        word = prevText + clipboardData + nextText;
+
+                        if (word.length >= afterAmountCharacters &&
+                            !inline &&
+                            options.remote) {
+                            searchTextBox.value(word);
+
+                            request(e);
+                            e.preventDefault();
+                        }
+                    });
+
+                },
+
+                mapIf = function(searchTextAsArray, textNodeAsArray) {
+                    var
+                        iterator,
+                        sliceIndex,
+                        regexp,
+                        textNodeHashSet = Object
+                            .asCountableLiteral(textNodeAsArray),
+                        mapped = {},
+                        amount = 0,
+                        index = 0,
+                        previousIndex = -1,
+
+                        callback = function(slice) {
+                            slice = slice.trim();
+                            index = Object.firstFromASlice(textNodeHashSet,
+                                                             slice, index,
+                                                             options
+                                                             .caseSensitive);
+
+                            if (index && ((options.orderlySearch &&
+                                index > previousIndex) ||
+                                !options.orderlySearch) &&
+                                textNodeAsArray.countSlice(slice,
+                                    options.caseSensitive) >=
+                                    searchTextAsArray.amount(slice)) {
+
+                                previousIndex = index;
+
+                                if (options.caseSensitive) {
+                                    regexp = new RegExp(slice);
+                                } else {
+                                    regexp = new RegExp(slice, "i");
+                                }
+
+                                sliceIndex = textNodeAsArray[index]
+                                    .search(regexp);
+                                mapped[index] = textNodeAsArray[index]
+                                    .slice(sliceIndex, sliceIndex + slice
+                                           .length);
+                                Object.delete(index, textNodeHashSet);
+                                amount += 1;
+                            } else {
+                                this.finalize();
+                            }
+                        };
+
+                    if (textNodeHashSet.length >= searchTextAsArray.length) {
+                        iterator = Iterable.Proxy.new(searchTextAsArray);
+                        iterator.each(callback);
+
+                        if (amount == searchTextAsArray.length) {
+                            return mapped;
+                        }
+                    }
+
+                    return false;
+                },
+
+                // resolveList = function(list, order = "desc") {
+                resolveList = function(list, order) {
+                    if (order != "asc") {order = "desc";}
+                    var
+                        textNode,
+                        mapped,
+                        textNodeAsArray,
+                        sorted,
+                        found = {elements: $(), maps: []},
+                        textBoxContentArr = searchTextBox.value().split(" ")
+                            .compact(),
+
+                        callback = function(element) {
+                            textNode = $(element).textContent().trim();
+                            textNodeAsArray = textNode.split(" ");
+                            mapped = mapIf(textBoxContentArr, textNodeAsArray);
+                            if (mapped) {
+                                found.elements.push(element);
+                                found.maps.push(mapped);
+                            }
+                        };
+
+                    if (list.elements().amount() == 1 &&
+                        list.isA(window.Element)) {
+                        list = list.childElements().clone(true);
+                    }
+
+                    if (order == "desc") {
+                        sorted = list.orderTextNodeByDesc();
+                    } else {
+                        sorted = list.orderTextNodeByAsc();
+                    }
+
+                    sorted.each(callback);
+
+                    return found;
+                };
+
+            resolveArguments(options);
+
+            // init
+            if (!Object.belongToClass(elementsList, Object)) {
+                inlineSearch(elementsList, options);
+            } else {
+                options = elementsList;
+                remoteSearch(options);
+            }
+        }
+
+    });
+
+})(esPhinx);

data/lib/assets/javascripts/esphinx/util/browser.js

@@ -0,0 +1,66 @@
+var
+    esPhinx,
+    window;
+
+(function($) {
+    "use strict";
+
+    var init = function() {
+
+        var
+            nav = window.navigator.userAgent,
+            out = {};
+
+        if (/OPR\//gi.test(nav)) {
+            out.name = "Opera";
+            out.codeName = null;
+            out.fullVersion = nav.match(/OPR\/[0-9]+[\.\[0-9]+\]*/)
+                .toString().match(/[0-9]+[\.\[0-9]+\]*/).toString();
+        } else if (/Opera\//gi.test(nav)) {
+            out.name = "Opera";
+            out.codeName = null;
+            out.fullVersion = nav.match(/Version\/[0-9]+[\.\[0-9]+\]*/)
+                .toString().match(/[0-9]+[\.\[0-9]+\]*/).toString();
+        } else if (/(Firefox\/[0-9]+[\.\[0-9]+\]*)$/gi.test(nav)) {
+            out.name = "Firefox";
+            out.codeName = "FF";
+            out.fullVersion = nav.match(/[Firefox\/\[0-9]+[\.\[0-9]+\]*$/gi)
+                .toString().match("[0-9]+[\\.[0-9]+]*").toString();
+        } else if (/Chrome\/[0-9]+[\.\[0-9]+\]*/gi.test(nav)) {
+            out.name = "Google Chrome";
+            out.codeName = "GC";
+            out.fullVersion = nav.match(/Chrome\/[0-9]+[\.\[0-9]+\]*/)
+                .toString().match(/[0-9]+[\.\[0-9]+\]*/).toString();
+        } else if (/MSIE\//gi.test(nav)) {
+            out.name = "Internet Explorer";
+            out.codeName = "IE";
+            out.fullVersion = nav.match(/MSIE [0-9]+[\.\[0-9]+\]*/)
+                .toString().match(/[0-9]+[\.\[0-9]+\]*/).toString();
+        } else if (/\.NET\//gi.test(nav)) {
+            out.name = "Internet Explorer";
+            out.codeName = "IE";
+        } else if (/Safari\//gi.test(nav) && /Version\//gi.test(nav)) {
+            out.name = "Safari";
+        }
+
+        return out;
+    };
+
+    $.extend(true, {
+        Browser: {
+            fullVersion: function() {
+                return init().fullVersion;
+            },
+
+            name: function() {
+                return init().name;
+            },
+
+            codeName: function() {
+                return init().codeName;
+            }
+        }
+
+    });
+
+})(esPhinx);

data/lib/assets/javascripts/esphinx/util/cookie.js

@@ -0,0 +1,167 @@
+var
+    esPhinx;
+
+
+(function($) {
+    "use strict";
+
+    $.extend({
+        Cookie: {}
+    });
+
+    $.Extender.extend($.Cookie, true, {
+
+        set: function(key, value, options) {
+            var
+                expiresAt,
+
+                getResolvedOptions = function(options) {
+                    var
+                        duration;
+
+                    if (!options || !Object.belongToClass(options, Object)) {
+                        options = {};
+                    }
+
+                    // duration
+                    if (!options.duration ||
+                        Object.belongToClass(options.duration, Object)) {
+                        options.duration = {};
+                    }
+
+                    duration = options.duration;
+
+                    if (!duration.seconds) {
+                        duration.seconds = 0;
+                    }
+
+                    if (!duration.minutes) {
+                        duration.minutes = 0;
+                    }
+
+                    if (!duration.hours) {
+                        duration.hours = 0;
+                    }
+
+                    if (!duration.days) {
+                        duration.days = 0;
+                    }
+
+                    if (!duration.months) {
+                        duration.months = 0;
+                    }
+
+                    if (!duration.years) {
+                        duration.years = 0;
+                    }
+
+                    // path
+                    if (!options.path) {
+                        options.path = "/";
+                    }
+
+                    // max-age
+                    if (!options.maxAge) {
+                        if (duration.seconds) {
+                            options.maxAge = duration.seconds;
+                        } else if (duration.minutes) {
+                            options.maxAge = duration.minutes * 60;
+                        } else if (duration.hours) {
+                            options.maxAge = optdurationons.hours * 60 * 60;
+                        } else if (duration.days) {
+                            options.maxAge = duration.days * 24 * 60 * 60;
+                        }
+                    }
+
+                    if (typeof options.secure != "boolean") {
+                        options.secure = false;
+                    }
+
+                    return options;
+                },
+
+                getDuration = function(durationOptions) {
+                    var
+                        date = new Date();
+
+                    date.setSeconds(date.getSeconds() +
+                                    durationOptions.seconds);
+                    date.setMinutes(date.getMinutes() +
+                                    durationOptions.minutes);
+                    date.setHours(date.getHours() + durationOptions.hours);
+                    date.setDate(date.getDate() + durationOptions.days);
+                    date.setMonth(date.getMonth() + durationOptions.months);
+                    date.setFullYear(date.getFullYear() +
+                                     durationOptions.years);
+
+                    return date.toString();
+                },
+
+                getCompost = function(options) {
+                    var
+                        compost = "";
+
+                    compost += key + "=" + value +
+                        ";path=" + options.path;
+
+                    if (options.domain) {
+                        // test woth document.location.host
+                        compost += ";domain=" + options.domain;
+                    }
+
+                    if (options.maxAge) {
+                        compost += ";max-age=" + options.maxAge;
+                    }
+
+                    if (options.expires) {
+                        expiresAt = getDuration(options.duration);
+                        compost += ";expires=" + expiresAt;
+                    }
+
+                    if (options.secure) {
+                        compost += ";secure";
+                    }
+
+                    return compost;
+                };
+
+            options = getResolvedOptions(options);
+
+            document.cookie = getCompost(options);
+
+            return this;
+        },
+
+        get: function(key) {
+            var
+                collection,
+                length,
+                pattern = new RegExp("(?:;*)" + key + "=([^;]*)", "g");
+
+            if (document.cookie) {
+                collection = pattern.exec(document.cookie);
+                length = collection.length;
+
+                if (length) {
+                    return collection[1];
+                }
+            }
+
+            return "";
+        },
+
+        reset: function(key, durationOptions) {
+
+        },
+
+        delete: function(key) {
+
+        },
+
+        restart: function(key) {
+
+        }
+
+    });
+
+}(esPhinx));