esphinx-rails 1.1.2

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

@@ -0,0 +1,110 @@
+var
+    esPhinx;
+
+(function($) {
+    "use strict";
+
+    $.extend({
+
+        deleteKeysPattern: function() {
+            var
+                stringPattern = "",
+
+                callback = function(key) {
+                    stringPattern += key + "|";
+                };
+
+            ["Backspace", "Delete"].forEach(callback);
+
+            return stringPattern.slice(0, stringPattern.length -1);
+        },
+
+        functionKeysPattern: function() {
+            var
+                stringPattern = "",
+                i = 0;
+
+            while (i++ <= 11) {
+                if(i < 12) {
+                    stringPattern += "F" + i + "|";
+                } else {
+                    stringPattern += "F" + i;
+                }
+            }
+
+            return stringPattern.slice(0, stringPattern.length -1);
+        },
+
+        editKeysPattern: function() {
+            var
+                stringPattern = "",
+
+                callback = function(key) {
+                    stringPattern += key + "|";
+                };
+
+            ["Enter", "Insert"].forEach(callback);
+
+            return stringPattern.slice(0, stringPattern.length -1);
+        },
+
+        modifierKeysPattern: function() {
+            var
+                stringPattern = "",
+
+                callback = function(key) {
+                    stringPattern += key + "|";
+                };
+
+            ["Shift", "Control", "Alt", "AltGraph"].forEach(callback);
+
+            return stringPattern.slice(0, stringPattern.length -1);
+        },
+
+        navigationKeysPattern: function() {
+            var
+                stringPattern = "",
+
+                directionalIteratorBlock = function(key) {
+                    stringPattern += "Arrow" + key + "|";
+                },
+
+                horizontalDirectionalIteratorBlock = function(key) {
+                    stringPattern += "Page" + key + "|";
+                },
+
+                callback = function(key) {
+                    stringPattern += key + "|";
+                };
+
+            ["Left", "Right", "Up", "Down"].forEach(directionalIteratorBlock);
+
+            ["Up", "Down"].forEach(horizontalDirectionalIteratorBlock);
+
+            ["Home", "End"].forEach(callback);
+
+            return stringPattern.slice(0, stringPattern.length -1);
+        },
+
+        systemKeysPattern: function() {
+            var
+                stringPattern = "",
+
+                callback = function(key) {
+                    stringPattern += key + "|";
+                };
+
+            ["Escape", "Pause"].forEach(callback);
+
+            return stringPattern.slice(0, stringPattern.length -1);
+        },
+
+        nonCharacterKeysPattern: function() {
+            return $.systemKeysPattern() + "|" + $.navigationKeysPattern() +
+              "|" + $.modifierKeysPattern() + "|" + $.editKeysPattern() + "|" +
+              $.functionKeysPattern();
+        }
+
+    });
+
+})(esPhinx);

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

@@ -0,0 +1,84 @@
+// talvez o problema possa ser resolvido com funções assíncronas. Da atual forma não funciona porque linha por linha do arquivo é carregada sem que o outro arquivo chamado por getScript esteja carregado.
+
+var
+    esPhinx;
+
+
+(function($) {
+    "use strict";
+
+    // var
+    //     // aparentemente não será necessário
+    //     promises = [],
+
+    //     promise = function(src) {
+    //         if (promises.indexOf(src) < 0) {
+    //             promises.unshift(src);
+    //         }
+    //     };
+
+
+    $.extend({
+
+        config: {
+            rootPath: "/",
+            loadPath: []
+        },
+
+        getScript: function(src) {
+            var
+                // script,
+                first = $("script").first(),
+
+                // resetLoadPath = function() {
+                //     $.config.loadPath = [];
+                // },
+
+                resolvePath = function(path) {
+                    return path.replace(/^\/*/, "/").replace(/\/+$/, "");
+                },
+
+                joinPaths = function(names) {
+                    var
+                        path = "",
+                        args = Array.from(arguments),
+
+                        callback = function(v) {
+                            path += resolvePath(v);
+                        };
+
+                    args.forEach(callback);
+
+                    return path;
+                },
+
+                withoutExtension = function(src) {
+                    return src.replace(/(\..*)/, "");
+                },
+
+                resolveSrc = function(src) {
+                    if (src.match(/(\.js)$/i)) {
+                        return src;
+                    }
+
+                    return src + ".js";
+                };
+
+            // o loadPath pode ser iterado para fazer a verificação
+            src = joinPaths($.config.rootPath, withoutExtension(src));
+
+            // debugger
+            if (!$("script[src^=\"" + src + "\"]").some()) {
+                // debugger
+                $("<script></script>")
+                // resolver com options
+                    // .attribute("defer", "defer")
+                    .attribute("async", "async")
+                    .attribute("src", resolveSrc(src))
+                    .insertBefore(first);
+            }
+        }
+
+    });
+
+}(esPhinx));

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

@@ -0,0 +1,58 @@
+var
+    esPhinx;
+
+
+(function($) {
+    "use strict";
+
+    $.prototype.extend({
+
+        observe: function(options, callback) {
+            var
+                observer,
+
+                block = function(mutations) {
+                    callback.call(observer, mutations);
+                },
+
+                iteratorBlock = function(node) {
+                    observer = new window.MutationObserver(block);
+
+                    observer.observe(node, options);
+                };
+
+            if (!callback && typeof options == "function") {
+                callback = options;
+            }
+
+            if (options) {
+                if (!options.childList ||
+                    typeof options.childList != "boolean") {
+                    options.childList = true;
+                }
+
+                if (!options.subtree ||
+                    typeof options.subtree != "boolean") {
+                    options.subtree = true;
+                }
+
+                if (!options.characterData ||
+                    typeof options.characterData != "boolean") {
+                    options.characterData = true;
+                }
+
+                // if (!options.attributes ||
+                //     typeof options.attributes != "boolean") {
+                //     options.attributes = false;
+                // }
+
+            }
+
+            this.each(iteratorBlock);
+
+            return this;
+        }
+
+    });
+
+}(esPhinx));

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

@@ -0,0 +1,127 @@
+var
+    esPhinx;
+
+
+(function($) {
+    "use strict";
+
+    $.extend({
+        Promise: {}
+    });
+
+    $.Extender.extend($.Promise, true, {
+        new: function(options, callbackUntil) {
+            var
+                _accomplishResponse,
+                _reject,
+                whenReject,
+                status,
+                promise,
+                currentTimeout,
+                self = this,
+                ConstructorReference = $.Promise.new,
+
+                resolveArguments = function() {
+                    if (typeof options == "function") {
+                        callbackUntil = options;
+                        options = {};
+                    }
+
+                    if (typeof options.onAccomplish != "function") {
+                        options.onAccomplish = function() {};
+                    }
+                },
+
+                accomplish = function(response) {
+                    // "fulfilled"
+                    status = "resolved";
+                    _accomplishResponse = response;
+                },
+
+                start = function(callbackUntil, options) {
+                    if (typeof options.defer != "number") {
+                        options.defer = 0;
+                    }
+
+                    var
+                        loop = function(_accomplish, _reject, callbackUntil,
+                                        options) {
+
+                            currentTimeout = window.setTimeout(function() {
+                                if (typeof callbackUntil != "function" ||
+                                    (options.defer &&
+                                     typeof callbackUntil != "function")) {
+                                    _accomplish();
+                                } else {
+                                    options.defer = 0;
+                                    callbackUntil.call(self, accomplish);
+                                    // returns the control for the user
+                                    switch (status) {
+                                        case "resolved": {
+                                            _accomplish(_accomplishResponse);
+                                        }
+                                        break;
+                                        default: {
+                                            loop(_accomplish, _reject,
+                                                 callbackUntil, options);}
+                                    }
+                                }
+                            }, options.defer);
+                        };
+
+                    promise = new Promise(function(_accomplish, reject) {
+                        _reject = reject;
+                        loop(_accomplish, reject, callbackUntil, options);
+                    });
+
+                    promise.then(
+                        // response comes from original Promise object
+                        function(r) {
+                            options.onAccomplish(r);
+                        },
+
+                        function() {
+                            whenReject();
+                        }
+                    );
+                };
+
+            if (!(this instanceof ConstructorReference)) {
+                return new ConstructorReference(options, callbackUntil);
+            }
+
+            resolveArguments(callbackUntil, options);
+
+            start(callbackUntil, options);
+
+            this.origin = function() {
+                // to work with async functions
+                return promise;
+            };
+
+            this.break = function(run) {
+                if (typeof run != "function") {
+                    run = function(){};
+                }
+
+                whenReject = run;
+
+                clearTimeout(currentTimeout);
+                _reject();
+            };
+
+            this.catchException = function(run) {
+                if (typeof run != "function") {
+                    run = function(){};
+                }
+
+                promise.catch(run);
+
+                return this;
+            };
+
+            return this;
+        }
+    });
+
+})(esPhinx);

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

@@ -0,0 +1,142 @@
+var
+    esPhinx;
+
+
+(function($) {
+    "use strict";
+
+    var
+        _options,
+        _eventCollector,
+
+        isDeleteKey = function(e) {
+            switch (e.key) {
+                case "Backspace":
+                    return true;
+
+                case "Delete":
+                    return true;
+            }
+
+            return false;
+        },
+
+        listener = function(e) {
+            if (typeof _eventCollector == "function") {
+                _eventCollector(e);
+            }
+
+            var
+                i;
+
+            if (_options) {
+                if (_options.acceptDelete == true) {
+                    if (isDeleteKey(e)) {
+                        return false;
+                    }
+                }
+
+                if (_options.exceptions) {
+                    if (isDeleteKey(e)) {
+                        return false;
+                    }
+
+                    if (_options.exceptions
+                        .test(e.key)) {
+                        return false;
+                    }
+                    if (e.shiftKey) {
+                        return false;
+                    }
+                } else {
+                    if (e.shiftKey) {
+                        switch (e.key) {
+                            case ("Insert"):
+                                return false;
+                        }
+                    }
+                }
+            }
+
+            for (i = 1; i <= 12; i++) {
+                if (e.key == ("F" + i)) {
+                    return false;
+                }
+            }
+
+            switch (e.key) {
+                case "ArrowLeft":
+                    return false;
+
+                case "ArrowRight":
+                    return false;
+
+                case "ArrowUp":
+                    return false;
+
+                case "ArrowDown":
+                    return false;
+            }
+
+            switch (e.key) {
+                case "Home":
+                    return false;
+
+                case "End":
+                    return false;
+
+                case "PageUp":
+                    return false;
+
+                case "PageDown":
+                    return false;
+
+                case "AltGraph":
+                    return false;
+
+                case "Enter":
+                    return false;
+            }
+
+            if (e.ctrlKey) {
+                switch (e.key) {
+                    case "a":
+                        return false;
+
+                    case "c":
+                        return false;
+
+                    case "v":
+                        return false;
+                }
+            }
+
+            e.preventDefault();
+        };
+
+    $.prototype.extend(true, {
+
+        preventKeys: function(options, eventCollector) {
+            _options = options || {};
+            _eventCollector = eventCollector;
+
+            var
+                callback = function(node) {
+                    node.removeEventListener("keydown", listener,
+                        (_options.capture || false)
+                    );
+
+                    node.addEventListener("keydown", listener,
+                        (_options.capture || false)
+                    );
+
+                };
+
+            this.each(callback);
+
+            return this;
+        }
+
+    });
+
+}(esPhinx));