esphinx-rails 1.1.2

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

@@ -0,0 +1,308 @@
+var
+    esPhinx,
+    Iterable;
+
+
+(function($) {
+    "use strict";
+
+    // $.prototype.extend(false, {
+    $.prototype.extend({
+
+        value: function(value) {
+            if (value || value === "") {
+                this.property("value", value);
+                return this;
+            } else {
+                value = this.property("value");
+                if (value) {
+                    return value;
+                }
+            }
+
+            return "";
+        },
+
+        data: function(attrName, value) {
+            return this.attribute("data-" + attrName, value);
+        },
+
+        text: function(text) {
+            var
+                first,
+                childNodes,
+
+                callback = function(node) {
+                    first = $(node).childNodes().asNode();
+                    if (first instanceof window.Text) {
+                        first.textContent = text;
+                    } else {
+                        $(node).prepend(window.document
+                                        .createTextNode(text));
+                    }
+                },
+
+                iteratorBlock = function(node) {
+                    if (node instanceof window.Text) {
+                        text += $(node).textContent();
+                    }
+                };
+
+            if (typeof text == "string") {
+                if (this.some()) {
+                    this.each(callback);
+                }
+                return this;
+            } else {
+                text = "";
+                childNodes = this.childNodes();
+                if (childNodes.some()) {
+                    childNodes.each(iteratorBlock);
+
+                    return text.trim();
+                } else {
+                    return "";
+                }
+            }
+        },
+
+        parent: function(query) {
+            var
+                parent,
+                callback,
+                elements = $();
+
+
+            if (query) {
+                // comparator = $(query).asNode();
+                // while (true) {
+                //     if (Object.areEquivalents(parent, comparator)) {
+                //         return $(parent);
+                //     } else if (!parent) {
+                //         break;
+                //     }
+                //     parent = parent.parentNode;
+                // }
+                callback = function(element) {
+                    parent = element.closest(query);
+                    if ($(parent).some()) {
+                        elements.push(parent);
+                    }
+                };
+            } else {
+                callback = function(element) {
+                    elements.push(element.parentNode);
+                };
+            }
+
+            this.each(callback);
+
+            return elements;
+        },
+
+        lastIndex: function() {
+            return this.amount() - 1;
+        },
+
+        childNodes: function() {
+            var
+                childNodes = $(),
+
+                callback = function(node) {
+                    childNodes.concat(true, node.childNodes);
+                };
+
+            this.each(callback);
+
+            return childNodes;
+        },
+
+        childElements: function(comparator) {
+            var
+                node,
+                comparators,
+                children = $(),
+
+                callback = function(element) {
+                    var
+                        iteratorBlock = function(comparator) {
+                            if (element.is(comparator)) {
+                                children.push(comparator);
+                            }
+                        };
+
+                    comparators.each(iteratorBlock);
+                };
+
+            if (this.some()) {
+                node = this.asNode();
+
+                if (comparator) {
+                    comparators = $(comparator);
+
+                    $(node.children).each(callback);
+
+                    return children;
+                }
+
+                return children.concat(this.asNode().children);
+            }
+
+            return $();
+        },
+
+        previousSiblings: function() {
+            var
+                node = this.asNode(),
+                sibling = node,
+                siblings = $();
+
+            sibling = sibling.previousElementSibling;
+            while (sibling) {
+                siblings.push(sibling);
+                sibling = sibling.previousElementSibling;
+            }
+
+            if (siblings.some()) {
+                return siblings;
+            }
+
+            return false;
+        },
+
+        nextSiblings: function() {
+            var
+                node = this.asNode(),
+                sibling = node,
+                siblings = $();
+
+            sibling = sibling.nextElementSibling;
+            while (sibling) {
+                siblings.push(sibling);
+                sibling = sibling.nextElementSibling;
+            }
+
+            if (siblings.some()) {
+                return siblings;
+            }
+
+            return false;
+        },
+
+        width: function(value) {
+            if (this.asNode() == window.document) {
+                return this.asNode().documentElement.offsetWidth;
+            }
+
+            var
+                width = this.css("width"),
+                padding = this.css("padding-left") +
+                this.css("padding-right"),
+                border = this.css("border-left-width") +
+                this.css("border-right-width"),
+
+                callback = function(node) {
+                    node = $(node);
+                    if (Number.isNaN(parseFloat(value))) {
+                        node.css("width", value);
+                    } else {
+                        padding = node.css("padding-left") +
+                          node.css("padding-right");
+                        border = node.css("border-left-width") +
+                          node.css("border-right-width");
+                        value  = parseFloat(value) - (padding + border);
+                        if (value < 0) {
+                            value = 0;
+                        }
+                        node.css("width", value + "px");
+                    }
+                };
+
+            if (value || value === 0) {
+                this.each(callback);
+            } else {
+                if (Number.isNaN(parseFloat(width))) {
+                    return this.asNode().offsetWidth;
+                }
+                return width + padding + border;
+            }
+        },
+
+        height: function(value) {
+            if (this.asNode() == window.document) {
+                return this.asNode().documentElement.offsetHeight;
+            }
+
+            var
+                height = this.css("height"),
+                padding = this.css("padding-top") +
+                this.css("padding-bottom"),
+                border = this.css("border-top-width") +
+                this.css("border-bottom-width"),
+
+                callback = function(node) {
+                    node = $(node);
+                    if (Number.isNaN(parseFloat(value))) {
+                        node.css("height", value);
+                    } else {
+                        padding = node.css("padding-top") +
+                          node.css("padding-bottom");
+                        border = node.css("border-top-width") +
+                          node.css("border-bottom-width");
+                        value  = parseFloat(value) - (padding + border);
+                        if (value < 0) {
+                            value = 0;
+                        }
+                        node.css("height", value + "px");
+                    }
+                };
+
+            if (value || value === 0) {
+                this.each(callback);
+            } else {
+                if (Number.isNaN(parseFloat(height))) {
+                    return this.asNode().offsetHeight;
+                }
+                return height + padding + border;
+            }
+        },
+
+        minWidth: function() {
+            var
+                padding = this.css("padding-left") +
+                this.css("padding-right");
+
+            return this.innerWidth() - padding;
+        },
+
+        innerWidth: function() {
+            var
+                border = this.css("border-left-width") +
+                this.css("border-right-width");
+
+            return this.width() - border;
+        },
+
+        minHeight: function() {
+            var
+                padding = this.css("padding-top") +
+                this.css("padding-bottom");
+
+            return this.innerHeight() - padding;
+        },
+
+        innerHeight: function() {
+            var
+                border = this.css("border-top-width") +
+                this.css("border-bottom-width");
+
+            return this.height() - border;
+        },
+
+        transitionDuration: function() {
+            return this.css("transition-duration") * 1000;
+        }
+
+    });
+
+}(esPhinx));

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

@@ -0,0 +1,347 @@
+var
+    esPhinx;
+
+
+(function($) {
+    "use strict";
+
+    $.prototype.extend({
+
+        empty: function() {
+            return this.length === 0;
+        },
+
+        some: function() {
+            return !this.empty();
+        },
+
+        each: function(callback) {
+            $($.each(this, callback));
+        },
+
+        selectEach: function(callback) {
+            // delegate
+            return $($.select(this, callback));
+        },
+
+        selectInBreadth: function(callback) {
+            return $($.selectInBreadth(this, callback));
+        },
+
+        filter: function(callback) {
+            var
+                self = this,
+                filtered = $(),
+
+                iteratorBlock = function(node, i) {
+                    // if (callback.call($(node), node, i, this)) {
+                    if (callback.call(self, node, i)) {
+                        filtered.push(node);
+                    }
+                };
+
+            this.each(iteratorBlock);
+
+            return filtered;
+        },
+
+        filterInBreadth: function(callback) {
+            var
+                filtered = $(),
+
+                iteratorBlock = function(node, i) {
+                    if (callback.call($(node), node, i, this)) {
+                        filtered.push(node);
+                    }
+                };
+
+            this.selectInBreadth(iteratorBlock);
+
+            return filtered;
+        },
+
+        filterText: function(text) {
+            var
+                callback = function(node) {
+                    return $(node).text().trim() == text.trim();
+                };
+
+            return this.selectInBreadth(callback);
+        },
+
+        asArray: function() {
+            return Array.from(this);
+        },
+
+        sort: function(compareFunction) {
+            return $($.Collection.new(this).sort(compareFunction));
+        },
+
+        orderTextNodeByAsc: function() {
+            var
+                callback = function(node1, node2) {
+                    return $(node1).text() > $(node2).text();
+                };
+
+            return this.sort(callback);
+        },
+
+        orderTextNodeByDesc: function() {
+            var
+                callback = function(node1, node2) {
+                    return $(node1).text() < $(node2).text();
+                };
+
+            return this.sort(callback);
+        },
+
+        push: function() {
+            var
+                index,
+                mainReference = this,
+
+                callback = function(node) {
+                    index = mainReference.lastIndex() + 1;
+                    mainReference[index] = node;
+                };
+
+            Array.from(arguments).forEach(callback);
+
+            this.length = Object.amount(this);
+
+            return this;
+        },
+
+        concat: function(replace) {
+            var
+                concatened,
+                args = Array.from(arguments),
+
+                callback = function(collection) {
+                    var
+                        iteratorBlock = function(node) {
+                            concatened.push(node);
+                        };
+
+                    collection = Array.from(collection);
+                    collection.forEach(iteratorBlock);
+                };
+
+            if (typeof replace == "boolean" && replace) {
+                concatened = this;
+                args = args.slice(1, args.length);
+            } else {
+                concatened = this.copy();
+            }
+
+            args.forEach(callback);
+
+            return concatened;
+        },
+
+        elements: function() {
+            var
+                elements = $(),
+
+                callback = function(node) {
+                    if ($(node).isA(window.Element)) {
+                        elements.push(node);
+                    }
+                };
+
+            this.each(callback);
+
+            return elements;
+        },
+
+        firstNode: function() {
+            var
+                childNodes,
+                firstNodes = $(),
+
+                callback = function(node) {
+                    childNodes = $(node).childNodes();
+                    if (childNodes.some()) {
+                        firstNodes.push(childNodes.asNode());
+                    }
+                };
+
+            this.each(callback);
+
+            return firstNodes;
+        },
+
+        firstElement: function() {
+            var
+                childElements,
+                firstElements = $(),
+
+                callback = function(node) {
+                    childElements = $(node).childElements();
+                    if (childElements.some()) {
+                        firstElements.push(childElements.asNode());
+                    }
+                };
+
+            this.each(callback);
+
+            return firstElements;
+        },
+
+        previous: function(filter) {
+            var
+                query,
+                sibling,
+                siblings = $(),
+
+                iteratorBlock = function(node) {
+                    return $(node).is(query);
+                },
+
+                callback = function(node) {
+                    sibling = node.previousElementSibling;
+                    if (sibling && sibling instanceof window.Node) {
+                        siblings.push(sibling);
+                    }
+                };
+
+            if (filter) {
+                query = this.parent().find(filter);
+
+                if (query.some()) {
+                    siblings = this.previousSiblings()
+                        .filter(iteratorBlock);
+                }
+            } else {
+                this.each(callback);
+            }
+
+            return siblings;
+        },
+
+        next: function(filter) {
+            var
+                query,
+                sibling,
+                siblings = $(),
+
+                iteratorBlock = function(node) {
+                    return $(node).is(query);
+                },
+
+                callback = function(node) {
+                    sibling = node.nextSibling;
+                    if (sibling && sibling instanceof window.Node) {
+                        siblings.push(sibling);
+                    }
+                };
+
+            if (filter) {
+                query = this.parent().find(filter);
+
+                if (query.some()) {
+                    siblings = this.nextSiblings()
+                        .filter(iteratorBlock);
+                }
+            } else {
+                this.each(callback);
+            }
+
+            return siblings;
+        },
+
+        asNode: function() {
+            if (this.some()) {
+                return this.first()[0];
+            }
+            return null;
+        },
+
+        amount: function() {
+            return this.length;
+        },
+
+        find: function(query) {
+            return $(query, this);
+        },
+
+        clone: function(copyChildren) {
+            if (typeof copyChildren != "boolean")  { copyChildren = false; }
+
+            var
+                cloned = $(),
+
+                callback = function(node) {
+                    if (node instanceof window.Element) {
+                        cloned.push(node.cloneNode(copyChildren));
+                    }
+                };
+
+            this.each(callback);
+
+            return cloned;
+        },
+
+        copy: function() {
+            var
+                copy = $();
+
+            Object.assign(copy, this);
+            copy.length = Object.amount(copy);
+
+            return copy;
+        },
+
+        first: function() {
+            return $(this[0]);
+        },
+
+        last: function() {
+            return $(this[this.lastIndex()]);
+        },
+
+        asString: function() {
+            var
+                string = "",
+
+                callback = function(node) {
+                    if (node instanceof window.Element) {
+                        string += node.outerHTML + "\n";
+                    } else if (node instanceof window.Text) {
+                        string += node.wholeText + "\n";
+                    }
+                };
+
+            this.each(callback);
+
+            return string;
+        },
+
+        findHasNotAttr: function(query, attr) {
+            return this.find(query + ":not([" + attr + "])");
+        },
+
+        findByAttr: function(query, attr, value) {
+            return this.find(query + "[" + attr + "=\"" + value + "\"]");
+        },
+
+        textContentsAsArray: function() {
+            var
+                array = [],
+
+                callback = function(node) {
+                    array.push($(node).text().trim());
+                };
+
+            this.each(callback);
+
+            return array;
+        },
+
+        item: function(index) {
+            return $(this[index]);
+        }
+
+    });
+
+}(esPhinx));