esphinx-rails 1.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d566d1cefa1a1296f58f60c5b5d7a952f1663e53
+  data.tar.gz: 199f1ca54abde4caf59ce392d24418df7c16d76d
+SHA512:
+  metadata.gz: 475e105cfc42966a10f63b1024f75dbb50f5567a9b0423af7f4af10deecfcbe37e749048a1ffe4efee5394d1428b9439a59f2a0900f134b6da7d8aa79a062e1e
+  data.tar.gz: d9e01840069b9c4b94804c4f0eaa69ddf97b3885134ec19f04d0e16be331baf709dca1012138c5d02895e3a46ad4e36322ab14b045bc0f6d5e4ae62efffd8399

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2014 YOURNAME
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,21 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'esphinx-rails'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/config/environments/production.rb

@@ -0,0 +1 @@
+Rails.application.config.assets.precompile += %w( esphinx.js )

data/config/environments/staging.rb

@@ -0,0 +1 @@
+Rails.application.config.assets.precompile += %w( esphinx.js )

data/config/initializers/assets.rb

@@ -0,0 +1,7 @@
+# See what's difference between .application and .application.egine, if there is a effective difference.
+# Rails.application.engine.config.assets.compile += ...
+
+# Configs to Production
+
+# precompilation on deploy. Basicaly, must be precompile the assets that contains "//= require_tree .", that mount all files in one.
+Rails.application.config.assets.precompile += %w( esphinx.js )

data/esphinx.gemspec

@@ -0,0 +1,19 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+require "esphinx/rails/version"
+
+Gem::Specification.new do |s|
+  s.name        = "esphinx-rails"
+  s.version     = ESphinx::Rails::VERSION
+  s.authors     = ["rplaurindo"]
+  s.email       = ["rafaelplaurindo@gmail.com"]
+  s.homepage    = "https://rubygems.org/gems/esphinx-rails"
+  s.summary     = %q{Summary of ESphinx}
+  s.description = %q{Abstraction helpers for Javascript.}
+  s.license     = "MIT"
+  s.test_files  = Dir["test/**/*"]
+
+  s.files = Dir["{config,lib,vendor}/**/*", "MIT-LICENSE", "Rakefile", "README.md", "esphinx.gemspec"]
+  s.require_paths = %w{config lib vendor}
+
+end

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

@@ -0,0 +1,256 @@
+var
+    esPhinx;
+
+
+(function($) {
+    "use strict";
+
+    $.prototype.extend({
+
+        // TODO
+        // selectText: function(start = 0, end) {
+        selectText: function(start, end) {
+            if (isNaN(start)) {start = 0;}
+
+            var
+                mainReference = this,
+                node = mainReference.asNode(),
+                aux,
+                text;
+
+            // selectionStart and selectionEnd only exists for input elements
+            if (node instanceof window.HTMLInputElement) {
+                text = $(node).value();
+
+                if (!start || start != "number") {
+                    $.reverseEach(text, node.selectionStart,
+                                  function(c, i) {
+                        // debugger
+                        if (c == " ") {
+                            start = i;
+                            this.finalize();
+                        }
+                    });
+                }
+
+                if (!end || typeof end != "number") {
+                    $.reverseEach(text, node.selectionEnd,
+                                  function(c, i) {
+                        if (c == " ") {
+                            end = i;
+                            this.finalizeOnReverse();
+                        }
+                    });
+                }
+
+                if (end < start) {
+                    aux = start;
+                    start = end;
+                    end = aux;
+                }
+
+                node.setSelectionRange(start, end);
+                mainReference.focus();
+
+                return mainReference;
+            }
+
+        },
+
+        attribute: function(attrName, value) {
+            var
+                attr,
+                node = this.asNode(),
+
+                block = function(node) {
+                    node.setAttribute(attrName, value);
+                };
+
+            if (this.length === 0) {
+                return this;
+            }
+
+            if (typeof value == "boolean" || value || value === "") {
+                this.each(block);
+
+                return this;
+            } else {
+                attr = node.getAttribute(attrName);
+                if (attr) {
+                    return attr;
+                }
+            }
+
+            return undefined;
+        },
+
+        property: function(propertyName, value) {
+            var
+                node = this.asNode(),
+
+                block = function(node) {
+                    node[propertyName] = value;
+                };
+
+            if (this.length === 0) {
+                return this;
+            }
+
+            if (typeof value == "boolean" || value || value === "") {
+                this.each(block);
+
+                return this;
+            } else {
+                if (node[propertyName] ||
+                    typeof node[propertyName] == "boolean") {
+                    return node[propertyName];
+                }
+            }
+
+            return undefined;
+        },
+
+        tagName: function() {
+            if (this.some() && this.asNode() instanceof window.Element) {
+                return this.property("tagName").toLowerCase();
+            }
+
+            return "";
+        },
+
+        focus: function() {
+            this.asNode().focus();
+            return this;
+        },
+
+        select: function() {
+            return this.property("selected", true);
+        },
+
+        selected: function() {
+            return this.property("selected");
+        },
+
+        unselect: function() {
+            return this.property("selected", false);
+        },
+
+        removeClass: function(classList) {
+            var
+                currentClassList,
+                pattern,
+                removed,
+
+                block = function(node) {
+                    currentClassList = $(node).attribute("class");
+                    removed = currentClassList.replace(pattern, "");
+                    $(node).attribute("class", removed.replace(/(  )+/g, " ")
+                        .trim());
+                };
+
+            if (arguments.length > 1) {
+                classList = Array.from(arguments);
+                pattern = new RegExp("\\b((" + classList
+                    .join(")|(")  + "))(?=(\\b| ))", "g");
+            } else {
+                pattern = new RegExp("\\b((" + classList.split(" ")
+                    .join(")|(") + "))(?=(\\b| ))", "g");
+            }
+
+            this.each(block);
+
+            return this;
+        },
+
+        addClass: function(classList) {
+            var
+                currentClassList,
+                asString,
+
+                block = function(node) {
+                    currentClassList = $(node).attribute("class") || "";
+                    $(node).attribute("class", (currentClassList + " " +
+                                                asString).trim());
+                };
+
+            if (arguments.length > 1) {
+                classList = Array.from(arguments);
+                asString = classList.join(" ");
+            } else if (typeof classList == "string") {
+                asString = classList;
+            }
+
+            this.each(block);
+
+            return this;
+        },
+
+        check: function() {
+            return this.property("checked", true);
+        },
+
+        checked: function() {
+            return this.property("checked");
+        },
+
+        uncheck: function() {
+            return this.property("checked", false);
+        },
+
+        visible: function() {
+            var
+                asIterable,
+                iterator,
+                visible = true,
+
+                callback = function(element) {
+                    element = $(element);
+                    if (element.css("display") == "none" ||
+                        element.css("visibility") == "hidden" ||
+                        element.css("opacity") === 0) {
+                        visible = false;
+                    } else {
+                        visible = true;
+                        iterator.finalize();
+                    }
+                };
+
+            if (this.some()) {
+                asIterable = this.asArray();
+                iterator = Iterable.Proxy.new(asIterable);
+                iterator.each(callback);
+            }
+
+            return visible;
+        },
+
+        removeAttr: function(attrName) {
+            var
+                block = function(node) {
+                    node.removeAttribute(attrName);
+                };
+
+            this.each(block);
+
+            return this;
+        },
+
+        html: function(content) {
+            var
+                callback = function(element) {
+                    element.innerHTML = content;
+                };
+
+            if (typeof content == "string") {
+                this.elements().selectEach(callback);
+            } else {
+                this.clean();
+                this.append(content);
+            }
+
+            return this;
+        }
+
+    });
+
+}(esPhinx));

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

@@ -0,0 +1,227 @@
+var
+    esPhinx;
+
+
+(function($) {
+    "use strict";
+
+    var
+        nodes = [],
+        mappedListeners = {},
+
+        mapped = function(node) {
+            var
+                index = nodes.indexOfEquivalence(node);
+
+            return mappedListeners[index];
+        },
+
+        mapEventListener = function(node, eventName, runOnListener) {
+            var
+                index,
+                mappedNode = mapped(node),
+                map = {};
+
+            if (runOnListener) {
+                map[eventName] = [runOnListener];
+                if (mappedNode) {
+                    if (mappedNode[eventName]) {
+                        mappedNode[eventName].push(runOnListener);
+                    } else {
+                        mappedNode[eventName] = map[eventName];
+                    }
+                    return mappedNode[eventName];
+                } else {
+                    nodes.push(node);
+                    index = nodes.length - 1;
+                    mappedListeners[index] = map;
+                    return mappedListeners[index][eventName];
+                }
+            } else {
+                if (mappedNode) {
+                    return mappedNode[eventName];
+                } else {
+                    return [];
+                }
+            }
+        },
+
+        removeListener = function(node, eventName, runOnListener) {
+            var
+                mappedNode = mapped(node),
+                callbacks = mappedNode[eventName];
+
+            callbacks.delete(runOnListener);
+        },
+
+        removeListeners = function(node, eventName) {
+            var
+                mappedNode = mapped(node);
+
+            delete mappedNode[eventName];
+        },
+
+        mapEach = function(eventName, runOnListener, callback) {
+            var
+                iteratorBlock = function(node) {
+                    if (node instanceof window.Node || node == window) {
+                        mapEventListener(node, eventName, runOnListener);
+                        callback.call(node);
+                    }
+                };
+
+            this.each(iteratorBlock);
+        },
+
+        // qual seria o evento neste caso, para, por exemplo, usar o stopPropagation?
+        onChangeNode = function(runOnListener) {
+            var
+                added,
+                self = this,
+
+                callback = function(mutation) {
+                    added = $(mutation.addedNodes).elements();
+                    if (added.some()) {
+                        runOnListener.call(self, added.asArray());
+                    }
+                },
+
+                observeCallback = function(mutations) {
+                    mutations.forEach(callback);
+
+                };
+
+
+            mapEach.call(self, "changeNode", runOnListener,
+                         function() {
+                            $(this).observe(observeCallback);
+                        }
+            );
+
+        },
+
+        // will see how to unbind the node event
+        // offChangeNode = function(runOnListener) {
+        //     // disconnect
+        // },
+
+        on = function(eventName, capture, runOnListener) {
+            var
+                cloned,
+                runOnLoad,
+                imgs,
+                self = this,
+                html = $("html"),
+                clone = self.clone(true),
+
+                callback = function(node) {
+                    cloned = $(node);
+                    cloned.hide();
+                    html.prepend(node);
+
+                    node.addEventListener(eventName, runOnLoad, capture);
+                },
+
+                iteratorBlock = function(node) {
+                    node.removeEventListener(eventName, runOnLoad, capture);
+                };
+
+            if (typeof capture == "function") {
+                runOnListener = capture;
+                capture = false;
+            } else if (typeof capture != "boolean") {
+                capture = false;
+            }
+
+            switch (eventName) {
+                case "changeNode":
+                    return onChangeNode.call(self, runOnListener);
+                case "load":
+                    imgs = clone.find("img");
+                    if (imgs.some()) {
+                        clone = imgs;
+                    }
+
+                    runOnLoad = function(e) {
+                        runOnListener.call(this, e);
+                        html.remove(clone);
+
+                        clone.each(iteratorBlock);
+                    };
+
+                    clone.each(callback);
+                break;
+
+                default:
+                    mapEach.call(self, eventName, runOnListener,
+                                 function() {
+                        this.addEventListener(eventName, runOnListener,
+                                              capture);
+                    });
+            }
+        };
+
+
+    $.prototype.extend(true, {
+
+        on: function(eventName, capture, runOnListener) {
+            on.call(this, eventName, capture, runOnListener);
+
+            return this;
+        },
+
+        off: function(eventName, capture, runOnListener) {
+            var
+                callback,
+                node,
+
+                iteratorBlock = function(runOnListener) {
+                    var
+                        booleanIteratorBlock = function(capture) {
+                            node.removeEventListener(eventName, runOnListener,
+                                                     capture);
+                        };
+
+                    [true, false].forEach(booleanIteratorBlock);
+                    removeListeners(node, eventName);
+                };
+
+            if (typeof capture == "function") {
+                runOnListener = capture;
+                capture = false;
+            } else if (typeof capture != "boolean") {
+                capture = false;
+            }
+
+            if (runOnListener) {
+                callback = function(n) {
+                    node = n;
+                    node.removeEventListener(eventName, runOnListener, capture);
+                    removeListener(node, eventName, runOnListener);
+                };
+            } else {
+                callback = function(n) {
+                    node = n;
+                    if (mapped(node)) {
+                        mapEventListener(node, eventName)
+                            .forEach(iteratorBlock);
+                    }
+                };
+            }
+
+            this.each(callback);
+
+            return this;
+        },
+
+        attachedEvent: function(eventName) {
+            if (mapped(this.asNode())[eventName]) {
+                return true;
+            }
+
+            return false;
+        }
+
+    });
+
+})(esPhinx);