esphinx-rails 1.1.2

data/lib/assets/javascripts/esphinx/samples/sort.js

@@ -0,0 +1,30 @@
+// var
+//         self = this.copy(),
+//         i = 0,
+//         count = 0,
+//         aux;
+
+//     while (true) {
+//         if (count === self.length - 1) { break; }
+//         while (true) {
+//             i = count;
+//             if (self[i] > self[i + 1]) { //0, 1
+//                 aux = self[i];
+//                 self[i] = self[i + 1];
+//                 self[i + 1] = aux;
+//                 while (true) {
+//                     if (i === 0 || self[i] > self[i - 1]) { break; }
+//                     aux = self[i];
+//                     self[i] = self[i - 1];
+//                     self[i - 1] = aux;
+//                     i -= 1;
+//                 }
+//             }
+//             if (i === 0 || self[i] < self[i + 1]) {
+//                 break;
+//             }
+//         }
+//         count += 1;
+//     }
+
+//     return self;

data/lib/assets/javascripts/esphinx/style.js

@@ -0,0 +1,342 @@
+var
+    esPhinx,
+    Iterable;
+
+(function($) {
+    "use strict";
+
+    var
+        displayObjects = [];
+
+    $.prototype.extend({
+
+        // css: function(property, value, delay = 0) {
+        css: function(property, value, delay) {
+            if (typeof delay != "number") {delay = 0;}
+            var
+                properties,
+                number,
+                computedStyle,
+                propertyPriority,
+                callback,
+                propertiesIteratorBlock,
+                self = this,
+                node = this.asNode(),
+                offsetPattern = /\b(width|height|top|left)\b/,
+                originalProperties = {},
+
+                visibilityPropertiesCollection = {
+                    position: "absolute",
+                    visibility: "hidden",
+                    display: "block"
+                },
+
+                visibilityPropertiesList = [
+                    "position",
+                    "visibility",
+                    "display"
+                ],
+
+                nonexistentProperties = [],
+
+                recordOriginalPropertiesIteratorBlock = function(p) {
+                    if(!node.style[p]) {
+                        nonexistentProperties.push(p);
+                    }
+                    originalProperties[p] = node.style[p] ||
+                        computedStyle[p];
+                    node.style.setProperty(p, visibilityPropertiesCollection[p],
+                                           "important");
+                },
+
+                toRevertPropertiesIteratorBlock = function(p) {
+                    node.style.setProperty(p, originalProperties[p], node.style
+                                           .getPropertyPriority(p));
+                },
+
+                nonexistentPropertiesIteratorBlock = function(p) {
+                    node.style.removeProperty(p);
+                };
+
+            if (value === 0) {
+                value = value.toString();
+            }
+
+            // (key, value)
+            if (!value && !Object.belongToClass(property, Object)) {
+                property = property.strikeCase();
+                computedStyle = window.getComputedStyle(node);
+                value = computedStyle.getPropertyValue(property);
+
+                if (node.style[property]) {
+                    value = node.style[property];
+                } else if (computedStyle.display == "none" &&
+                           offsetPattern.test(property)) {
+                    visibilityPropertiesList
+                        .forEach(recordOriginalPropertiesIteratorBlock);
+
+                    value = computedStyle.getPropertyValue(property);
+
+                    // remove
+                    nonexistentProperties
+                        .forEach(nonexistentPropertiesIteratorBlock);
+
+                    // revert
+                    visibilityPropertiesList.difference(nonexistentProperties)
+                        .forEach(toRevertPropertiesIteratorBlock);
+                }
+
+                number = parseFloat(value);
+
+                if (Number.isNaN(number)) {
+                    return value;
+                } else {
+                    return number;
+                }
+            }
+
+
+            if (Object.belongToClass(property, Object)) {
+
+                if (typeof value == "number") { delay = value; }
+
+                properties = property;
+
+                callback = function(node) {
+                    computedStyle = window.getComputedStyle(node);
+
+                    propertiesIteratorBlock = function(value, property) {
+                        property = property.strikeCase();
+                        propertyPriority = computedStyle
+                            .getPropertyPriority(property);
+                        node.style.setProperty(property, value,
+                                               propertyPriority);
+                    };
+
+                    $.each(properties, propertiesIteratorBlock);
+                };
+
+            } else {
+                callback = function(node) {
+                    computedStyle = window.getComputedStyle(node);
+                    property = property.strikeCase();
+                    propertyPriority = computedStyle
+                        .getPropertyPriority(property);
+                    node.style.setProperty(property, value, propertyPriority);
+                };
+            }
+
+            if (delay)  {
+                window.setTimeout(function() {
+                    self.each(callback);
+                }, delay);
+            } else {
+                self.each(callback);
+            }
+
+            return this;
+        },
+
+        centralizeAt: function(reference) {
+            var
+                self = this,
+                parent,
+
+                centralize = function(reference) {
+                    this.css("position", "absolute");
+
+                    this.css({
+                        top: (reference.height() / 2) -
+                            (this.height() / 2) + "px",
+                        left: (reference.width() / 2) -
+                          (this.width() / 2) + "px"
+                    });
+                };
+
+            if (!Object.hasSameClass(reference, this)) {
+                reference = $(reference);
+            }
+
+            centralize.call(this, reference);
+
+            if (reference.isA(window.Element)) {
+                parent = reference;
+            } else {
+                parent = $().push(window);
+            }
+
+            parent.on("resize", function() {
+                centralize.call(self, reference);
+            });
+
+            return this;
+        },
+
+        // hide: function(delay = 0) {
+        hide: function(delay) {
+            if (typeof delay != "number") {delay = 0;}
+
+            var
+                exists,
+                iterator,
+                node = this.asNode(),
+
+                callback = function(hash) {
+                    if (hash.element == node) {
+                        exists = true;
+                        this.finalize();
+                    }
+                };
+
+            if (node instanceof window.Element) {
+                if ($(node).css("display") != "none") {
+                    iterator = Iterable.Proxy.new(displayObjects);
+                    iterator.each(callback);
+
+                    if (!exists && this.css("display")) {
+                        displayObjects.push({
+                            element: node,
+                            display: this.css("display")
+                        });
+                    }
+                }
+
+            }
+
+            this.css("display", "none", delay);
+
+            return this;
+        },
+
+        show: function() {
+            var
+                style,
+                inlineDisplay,
+                display,
+                iterator,
+                node = this.asNode(),
+
+                callback = function(hash) {
+                    if (hash.element == node) {
+                        display = hash.display;
+                        this.finalize();
+                    }
+                };
+
+            if (node instanceof window.Element) {
+                style = node.style;
+                inlineDisplay = style.display;
+            }
+
+            if (this.css("display") == "none") {
+                iterator = Iterable.Proxy.new(displayObjects);
+                iterator.each(callback);
+
+                if (display) {
+                    this.css("display", display);
+                } else if (inlineDisplay) {
+                    style.display = null;
+                    if (this.css("display") == "none") {
+                        this.css("display", "block");
+                    }
+                } else {
+                    this.css("display", "block");
+                }
+            }
+
+            return this;
+        },
+
+        // horizontalToggle: function(initialMargin = 0) {
+        horizontalToggle: function(initialMargin, callback) {
+            initialMargin = initialMargin || 0;
+            if (typeof initialMargin == "function") {
+                callback = initialMargin;
+                initialMargin = 0;
+            }
+
+            var
+                width,
+                margin,
+                marginRight,
+                marginLeft,
+                duration,
+
+                iteratorBlock = function(node) {
+                    node = $(node);
+
+                    width = Math.round(node.width());
+                    marginLeft = Math.abs(node.css("margin-left"));
+                    marginRight = Math.abs(node.css("margin-right"));
+                    duration = node.transitionDuration();
+
+                    if (typeof duration != "number") {
+                        duration = 0;
+                    }
+
+                    // discovering more criteria to know if align on right (||)
+                    if (node.css("float") == "right") {
+                        margin = Math.abs(Math.round(node.css("margin-right")));
+                        if (margin != (width + marginLeft)) {
+                            node.css("margin-right", - (width + marginLeft) +
+                                     "px");
+                        } else {
+                            node.css("margin-right", initialMargin + "px");
+                        }
+                    } else {
+                        margin = Math.abs(Math.round(node.css("margin-left")));
+                        if (margin != (width + marginRight)) {
+                            node.css("margin-left", - (width + marginRight) +
+                                     "px");
+                        } else {
+                            node.css("margin-left", initialMargin + "px");
+                        }
+                    }
+
+                    window.setTimeout(function() {
+                        callback.call(node);
+                    }, duration);
+
+                };
+
+            this.each(iteratorBlock);
+
+            return this;
+        },
+
+        toggleClass: function(classList, changeTo) {
+            var
+                callback = function(node) {
+                    if ($(node).hasClass(classList)) {
+                        $(node).removeClass(classList);
+                        if (changeTo) {
+                            $(node).addClass(changeTo);
+                        }
+                    } else if (changeTo) {
+                        if ($(node).hasClass(changeTo)) {
+                            $(node).removeClass(changeTo);
+                            $(node).addClass(classList);
+                        } else {
+                            $(node).addClass(classList);
+                        }
+                    } else {
+                        $(node).addClass(classList);
+                    }
+                };
+
+            this.each(callback);
+
+            return this;
+        },
+
+        toggle: function() {
+            if (this.css("display") == "none") {
+                this.show();
+            } else {
+                this.hide();
+            }
+        }
+
+    });
+
+}(esPhinx));

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

@@ -0,0 +1,152 @@
+var
+    esPhinx;
+
+
+(function($) {
+    "use strict";
+
+    $.extend({
+        Ajax: {}
+    });
+
+    $.Extender.extend($.Ajax, true, {
+        new: function(URL) {
+            var
+                promise,
+                progressEvent,
+                ifRaiseException,
+                ConstructorReference = $.Ajax.new,
+                _options = {},
+                callback = function() {},
+                xhr = new window.XMLHttpRequest(),
+
+                setRequestHeaders = function(xhr, headers) {
+                    if (headers) {
+                        $.each(headers, function(value, header) {
+                            if (value) {
+                                xhr.setRequestHeader(header, value);
+                            }
+                        });
+                    }
+                },
+
+                resolveOptions = function(options) {
+                    // abstract events
+                    // _error = options.error || callback,
+                    _options.abort = options.abort || callback;
+
+                    // loadstart
+                    _options.start = options.start || callback;
+
+                    // progress
+                    _options.progress = options.progress || callback;
+
+                    // loadend
+                    _options.complete = options.complete || callback;
+
+                    _options.success = options.success || callback;
+                },
+
+                start = function(xhr, type, URL, options) {
+                    // async false raise warning of deprecated
+                    xhr.open(type, URL, true, options.user, options.password);
+
+                    xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
+
+                    setRequestHeaders(xhr, options.headers);
+                },
+
+                get = function(xhr, URL, options) {
+                    var
+                        composed = "";
+
+                    if (options.URLParemeters) {
+                        $.each(options.URLParemeters, function(value, key) {
+                            if (Object.belongToClass(value, Object)) {
+                                value = JSON.stringify(value);
+                            }
+
+                            composed += key + "=" + value + "&";
+                        });
+
+                        composed = composed.slice(0, composed.length - 1);
+                        URL += "?" + encodeURI(composed);
+                    }
+
+                    start(xhr, "GET", URL, options);
+
+                    // request
+                    xhr.send(null);
+                };
+
+
+            if (!(this instanceof ConstructorReference)) {
+                return new ConstructorReference(URL);
+            }
+
+            xhr.addEventListener("abort", function() {
+                _options.abort();
+            });
+
+            // readyState == 1 or xhr.OPENED
+            xhr.addEventListener("loadstart", function() {
+                _options.start(xhr);
+            });
+
+            // readyState == 3 or xhr.LOADING
+            xhr.addEventListener("progress", function(e) {
+                _options.progress(e);
+                progressEvent = e;
+            });
+            promise = $.Promise.new({
+                onAccomplish: function(response) {
+                    // binary or text file, different of executable script
+                    if (/^application/
+                        .test(xhr.getResponseHeader("Content-Type")) ||
+                        (/^text/.test(xhr.getResponseHeader("Content-Type")) &&
+                         !/\/(javascript|ecmascript)/.test(xhr
+                            .getResponseHeader("Content-Type")))) {
+                        _options.success(response);
+                    } else {
+                        // script
+                        if (/\/(javascript|ecmascript)/.test(xhr
+                            .getResponseHeader("Content-Type"))) {
+                            eval.call(window, response);
+                        // URL to video, audio or picture
+                        } else {
+                            _options.success(URL);
+                        }
+                    }
+                }
+            }, function(accomplish) {
+                if (progressEvent && (!progressEvent.lengthComputable ||
+                    progressEvent.loaded == progressEvent.total)) {
+                    accomplish(xhr.response);
+                }
+            });
+
+            // readyState == 4 or xhr.DONE
+            xhr.addEventListener("loadend", function() {
+                _options.complete(xhr);
+            });
+
+            this.abort = function(callback) {
+                xhr.abort();
+                promise.reject(callback);
+            };
+
+            this.catch = function(callback) {
+                ifRaiseException = callback;
+                promise.catch(callback);
+            };
+
+            this.get = function(options) {
+                resolveOptions(options);
+                get(xhr, URL, options);
+            };
+
+            return this;
+        }
+    });
+
+}(esPhinx));