esphinx-rails 1.1.2

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

@@ -0,0 +1,276 @@
+var
+    esPhinx,
+    Iterable;
+
+
+(function($) {
+    "use strict";
+
+    $.extend({
+        text: function(text) {
+            return $(window.document.createTextNode(text));
+        }
+    });
+
+    $.prototype.extend({
+
+        // <br>|<br\/>
+        // text: function() {
+        // },
+
+        insertAfter: function(element) {
+            var
+                elements = $(element),
+
+                callback = function(element2Insert) {
+                    var
+                        iteratorBlock = function(element) {
+                            // element = $(element);
+                            // sibling = element.next();
+                            // debugger
+                            // if (sibling.some()) {
+                            //     $(element).insertBefore(sibling);
+                            // } else {
+                            //     element.parent().append(element);
+                            // }
+                            element.parentNode.insertBefore(element2Insert,
+                                                            element.nextSibling);
+                        };
+
+                    elements.each(iteratorBlock);
+                };
+
+            this.each(callback);
+
+            return this;
+        },
+
+        insertBefore: function(element) {
+            var
+                elements = $(element),
+
+                callback = function(element2Insert) {
+                    var
+                        iteratorBlock = function(element) {
+                            element.parentNode.insertBefore(element2Insert, element);
+                        };
+
+                    elements.each(iteratorBlock);
+                };
+
+            this.each(callback);
+
+            return this;
+        },
+
+        append: function(node) {
+            var
+                nodes,
+
+                callback = function(element) {
+                    var
+                        iteratorBlock = function(node) {
+                            element.appendChild(node);
+                        };
+
+                    nodes.each(iteratorBlock);
+                };
+
+            nodes = $(node);
+            if (nodes.empty()) {
+                nodes = $(window.document.createTextNode(node));
+            }
+
+            this.each(callback);
+
+            return this;
+        },
+
+        prepend: function(node) {
+            var
+                firstNode,
+
+                callback = function(element) {
+                    firstNode = $(element).firstNode();
+                    if (firstNode.some()) {
+                        node.insertBefore(firstNode);
+                    } else {
+                        $(element).append(node);
+                    }
+                };
+
+            node = $(node);
+            if (node.empty()) {
+                node = $(window.document.createTextNode(node));
+            }
+
+            this.each(callback);
+
+            return this;
+        },
+
+        textContent: function() {
+            var
+                tagName = this.tagName(),
+                node = this.asNode();
+
+            if (tagName != "pre") {
+                return node.textContent.replace(/\n[ \t]*/g, "")
+                    .replace(/(\n){2,}/g, "");
+            }
+
+            return node.textContent;
+        },
+
+        // "extends?" would make more sense in the relationship between classes
+        isA: function(constructor) {
+            return this.asNode() instanceof constructor;
+        },
+
+        // remove: function(object, delay = 0) {
+        remove: function(object, delay) {
+            if (typeof delay != "number") {delay = 0;}
+
+            var
+                self = this,
+
+                remove = function(element) {
+                    element.remove();
+                },
+
+                resolveArguments = function() {
+                    if (typeof object == "number") {
+                        delay = object;
+                        object = undefined;
+                    } else if (typeof delay != "number") {
+                        delay = 0;
+                    }
+                };
+
+            resolveArguments();
+
+            if (object) {
+                // recursivity
+                $(object).remove(delay);
+            } else {
+                if (delay) {
+                    window.setTimeout(function() {
+                        self.each(remove);
+                    }, delay);
+                } else {
+                    self.each(remove);
+                }
+            }
+
+
+            return self;
+        },
+
+        clean: function() {
+            var
+                callback = function(element) {
+                    element.innerHTML = null;
+                };
+
+            this.each(callback);
+
+            return this;
+        },
+
+        hasClass: function(classList) {
+            var
+                element = $(this.asNode()),
+                pattern;
+
+            if (arguments.length > 1) {
+                classList = Array.from(arguments);
+                pattern = new RegExp("(?=.*(\\b" + classList
+                    .join("(?=(\\b| ))))(?=.*(\\b") +
+                                     "(?=(\\b| )))).*", "g");
+            } else {
+                pattern = new RegExp("(?=.*(\\b" + classList.split(" ")
+                    .join("(?=(\\b| ))))(?=.*(\\b") +
+                                     "(?=(\\b| )))).*", "g");
+            }
+
+            return pattern.test(element.attribute("class"));
+        },
+
+        is: function(comparedNode) {
+            var
+                asIterable,
+                comparedAsIterable,
+                asIterableIterator,
+                comparedAsIterableIterator,
+                response = false,
+
+                callback = function(node) {
+                    var
+                        iteratorBlock = function(compared) {
+                            if (node.isEqualNode(compared)) {
+                                response = true;
+                                this.finalize();
+                                asIterableIterator.finalize();
+                            }
+                        };
+
+                    if (comparedNode.some()) {
+                        comparedAsIterable = Array.from(comparedNode);
+                        comparedAsIterableIterator = Iterable.Proxy
+                            .new(comparedAsIterable);
+                        comparedAsIterableIterator
+                            .each(iteratorBlock);
+                    }
+                };
+
+            if (Object.hasSameClass(comparedNode, this) ||
+                typeof comparedNode == "string" ||
+                comparedNode instanceof window.Node ||
+                comparedNode instanceof Array) {
+                comparedNode = $(comparedNode);
+            }
+
+            if (this.some()) {
+                asIterable = this.asArray();
+
+                asIterableIterator = Iterable.Proxy.new(asIterable);
+                asIterableIterator.each(callback);
+            }
+
+            return response;
+        }
+
+    });
+
+}(esPhinx));
+
+/*$.prototype.ancestors = function(nodeName) {
+    var _parents = []
+        ,parent = null
+    ;
+    collection.forEach(function(e) {
+        parent = e.parentNode;
+        if (nodeName) {
+            if (parent.nodeName.toLowerCase() == nodeName) {
+                _parents.push(parent);
+            } else {
+                while (true) {
+                    parent = parent.parentNode;
+                    if(parent){
+                        if(parent.nodeName.toLowerCase() == nodeName) {
+                            _parents.push(parent);
+                            break;
+                        }
+                    } else {
+                        break;
+                    }
+                }
+            }
+        } else {
+            if(parent){
+                _parents.push(parent);
+            }
+        }
+    });
+    return _parents;
+}*/

data/lib/assets/javascripts/esphinx/properties/forms.js

@@ -0,0 +1,161 @@
+var
+    esPhinx;
+
+
+(function($) {
+    "use strict";
+
+
+    $.prototype.extend({
+
+        // params: function () {
+        //     var
+        //         resolvedParams = {},
+        //         // numbersOnlyPattern = /^[0-9]+(?!.)/,
+        //         trailPattern = /^[^[]+|[^[]+(?=\])/g,
+        //         // trailWithoutIndexPattern = /^[^[]+|(?![0-9])[^[]+(?=\])/g,
+        //         count,
+        //         trail,
+        //         trailWithoutIndex,
+        //         //objectName,
+        //         //nestedObjectName,
+        //         index,
+        //         name,
+        //         param,
+        //         key,
+        //         //merged,
+        //         attr,
+        //         nested_attr,
+        //         attributeName,
+
+        //         resolveParam = function (name, value) {
+        //             value = value || "";
+
+        //             var
+        //                 structure = name,
+        //                 parsed;
+
+        //             index = structure.split(/\[([0-9]+)/)[1];
+
+        //             structure = "{\"" + structure;
+        //             // object[nested_object][0-9+][indexed_attr_collection_type][]
+        //             if (/.+\[.+\]\[[0-9]+\]\[.+\]\[\](?!.)/.test(name)) {
+        //                 structure = structure
+        //                     .replace(/(\]\[(?=.)(?!\]))|(\[(?!\]))/g,
+        //                     "\":{\"").replace(/(\]\[\])$/, "\":[\"" + value +
+        //                                       "\"]}}}}");
+        //             // obj[nested_object][][attr_collection_type][]
+        //             } else if (/.+\[.+\]\[\]\[.+\]\[\](?!.)/.test(name)) {
+        //                 structure = structure
+        //                     .replace(/\]\[\]\[/, "\":[{\"")
+        //                     .replace(/\[(?![\{\]])/, "\":{\"")
+        //                     .replace(/\]\[\]/, "\":[\"" + value +
+        //                              "\"]}]}}");
+        //             // below the two more used
+        //             // obj[nested_object][0-9+][indexed_attr]
+        //             } else if (/.+\[.+\]\[[0-9]+\]\[.+\](?!.)/.test(name)) {
+        //                 structure = structure
+        //                     .replace(/\]\[(?=.)(?!\])|\[(?!\])/g, "\":{\"")
+        //                     .replace(/\]$/, "\":\"" + value + "\"}}}}");
+        //             // obj[nested_object][][attr]
+        //             } else if (/.+\[.+\]\[\]\[.+\](?!.)/.test(name)) {
+        //                 structure = structure
+        //                     .replace(/\]\[\]\[/, "\":[{\"")
+        //                     .replace(/\[(?![\{])/g, "\":{\"")
+        //                     .replace(/\]$/g, "\":\"" + value + "\"}]}}");
+        //             // indexed_attr_collection_type[0-9+][]
+        //             } else if (/.+\[[0-9]+\]\[\](?!.)/.test(name)) {
+        //                 structure = structure
+        //                     .replace(/(\]\[(?=.)(?!\]))|(\[(?!\]))/g,
+        //                     "\":{\"").replace(/\]\[\]/, "\":[\"" + value +
+        //                                       "\"]}}");
+        //             // obj[attr_collection_type][]
+        //             } else if (/.+\[.+\]\[\](?!.)/.test(name)) {
+        //                 structure = structure
+        //                     .replace(/\]\[/, "\":[\"")
+        //                     .replace(/\[(?!\")/g, "\":{\"")
+        //                     .replace(/\]$/g, value + "\"]}}");
+        //             // obj[attr]
+        //             } else if (/.+\[.+\](?!.)/.test(name)) {
+        //                 structure = structure
+        //                     .replace(/\[/, "\":{\"")
+        //                     .replace(/\]$/, "\":\"" + value + "\"}}");
+        //             // attr_collection_type[]
+        //             } else if (/.+\[\](?!.)/.test(name)) {
+        //                 structure = structure
+        //                     .replace(/\[\]/, "\":[\"" + value + "\"]}");
+        //             // attr
+        //             } else {
+        //                 structure += "\":\"" + value + "\"}";
+        //             }
+
+        //             parsed = JSON.parse(structure);
+        //             if (parsed) {
+        //                 return parsed;
+        //             }
+        //             return false;
+        //         };
+
+        //     // debugger
+
+        //     // to adapt to:
+        //     // obj[nested_attr][0-9+][indexed_attr_collection_type][]
+        //     // obj[nested_attr][][attr_collection_type][]
+        //     // obj[attr_collection_type][]
+        //     // attr_collection_type[]
+        //     this.each(function (form) {
+        //         if (form instanceof HTMLFormElement) {
+        //             $.each(form.elements, function (e, i) {
+        //                 name = e.name;
+        //                 if (name) {
+
+        //                     count = name.match(trailPattern).length;
+
+        //                     if (trailWithoutIndex.length === 1) {
+        //                         attributeName = trail.first();
+        //                     }
+
+        //                     param = resolveParam(e.name, e.value);
+        //                     if (param) {
+        //                         key = Object.keys(param)[0];
+        //                         if (resolvedParams[key]) {
+        //                             // talvez seja interessante iterar usando Iterator.each e ir verificando o tipo de objeto que está sendo retornado pelo iterador
+        //                             attr = Object.keys(param[key])[0];
+        //                             if (resolvedParams[key][attr] instanceof
+        //                                 Array) {
+
+        //                                 index = Object
+        //                                     .keys(resolvedParams[key][attr])
+        //                                         .last();
+
+        //                                 nested_attr = Object
+        //                                     .keys(param[key][attr][0])[0];
+
+        //                                 if (resolvedParams[key][attr][index][nested_attr]) {
+        //                                     param[key][attr] = resolvedParams[key][attr]
+        //                                         .concat(param[key][attr]);
+        //                                 } else {
+        //                                     resolvedParams[key][attr][index] = Object.merge(resolvedParams[key][attr][index], param[key][attr][0]);
+        //                                     param[key][attr] = resolvedParams[key][attr];
+        //                                 }
+        //                             } else if (resolvedParams[key]
+        //                                        [attr] instanceof Object) {
+        //                                 param[key][attr][index] = $.Object.merge(resolvedParams[key][attr][index], param[key][attr][index]);
+        //                                 param[key][attr] = $.Object.merge(resolvedParams[key][attr], param[key][attr]);
+        //                             }
+        //                             param[key] = Object
+        //                                 .merge(resolvedParams[key], param[key]);
+        //                         }
+        //                         resolvedParams = $.Object.merge(resolvedParams, param);
+        //                     }
+        //                 }
+        //             });
+        //         }
+        //     });
+
+        //     return resolvedParams;
+        // }
+
+    });
+
+}(esPhinx));

data/lib/assets/javascripts/esphinx/properties/inputs/text.js

@@ -0,0 +1,29 @@
+var
+    esPhinx;
+
+
+(function($) {
+    "use strict";
+
+
+    $.prototype.extend({
+
+        selectionStart: function() {
+            if (this.isA(window.HTMLInputElement)) {
+                return this.asNode().selectionStart;
+            }
+        },
+
+        selectionEnd: function() {
+            if (this.isA(window.HTMLInputElement)) {
+                return this.asNode().selectionEnd;
+            }
+        },
+
+        cursorPosition: function() {
+            return this.selectionStart();
+        }
+
+    });
+
+}(esPhinx));