esphinx-rails 1.1.2

data/lib/assets/javascripts/esphinx/lib/extensions/function.js

@@ -0,0 +1,46 @@
+var
+    Flyweight;
+
+
+(function($) {
+    "use strict";
+
+
+    try {
+
+        Object.defineProperties($.prototype, {
+            buildConstructor: {
+                value: function(args) {
+                    // this won't be more necessary with Ecam Script 6
+                    if (!(args instanceof Array)) {
+                        args = Array.from(args);
+                    }
+
+                    // "bind" is a instance method of Function. It creates a new
+                    // function for be called after.
+                    // Apply calls the bind method
+                    return $.prototype.bind.apply(this, [null].concat(args)
+                                                  .flatten());
+                }
+            },
+
+            functionalSingleton: {
+                value: function() {
+                    // delegator = Delegator.apply(this);
+                    // delegator.object(Singleton.new);
+                    return Flyweight.Factory.new.apply(this, Array
+                                                       .from(arguments));
+                }
+            },
+
+            implementsMethods: {
+                value: function(name) {
+                    return Object.implementsMethods(this, name);
+                }
+            }
+
+        });
+
+    } catch(e) {}
+
+})(Function);

data/lib/assets/javascripts/esphinx/lib/extensions/index.js

@@ -0,0 +1 @@
+//= require_directory .

data/lib/assets/javascripts/esphinx/lib/extensions/location.js

@@ -0,0 +1,111 @@
+var
+    Location;
+
+
+(function($) {
+    "use strict";
+
+    var
+        self = window.location,
+
+        escape = function(parameter) {
+            return parameter.replace(/\$/, "\\$");
+        },
+
+        pattern = function(parameter) {
+            parameter = escape(parameter);
+            // better solution for now in JS, but select the catch (?, &)
+            // (?:[?&])foo(?:=([^&#]+))?\b
+            return new RegExp("(?:[?&])" + parameter +
+                              "(?:=([^&#]+))?\\b", "g");
+        },
+
+        separator = function(captured) {
+            return captured[0] ? captured[0] : "?";
+        },
+
+        clean = function(parameter) {
+            return self.search.replace(pattern(parameter), function(captured) {
+                return separator(captured) + parameter;
+            });
+        };
+
+
+    try {
+
+        Object.defineProperties($.prototype, {
+            queryParameter: {
+                value: function(parameter, value) {
+                    if (parameter) parameter = parameter.trim();
+
+                    var
+                        uri = self.href,
+                        search = self.search,
+                        results,
+                        regexp = pattern(parameter),
+
+                        set = function(parameter, value) {
+                            value = encodeURIComponent(value.toString().trim());
+
+                            if (regexp.test(search)) {
+                                if (value) {
+                                    search = search.replace(regexp,
+                                    function(captured, i, string) {
+                                        return separator(captured) + parameter +
+                                        "=" + value;
+                                    });
+                                } else {
+                                    search = clean(parameter);
+                                }
+                                uri = self.origin + self
+                                    .pathname + search + self.hash;
+                            } else {
+                                uri = window.location.origin + window.location
+                                    .pathname + window.location.search +
+                                    separator(search) + parameter + "=" +
+                                    value + window.location.hash;
+                            }
+
+                            window.history.pushState("", "", uri);
+                        };
+
+                    if (value || typeof value == "string") {
+                        set(parameter, value);
+                        return self;
+                    }
+
+                    results = regexp.exec(search);
+                    if (!results) return null;
+                    return decodeURIComponent(results[1].replace(/\+/g, " "));
+                }
+            },
+
+            unsetParameter: {
+                value: function(parameter) {
+                    var
+                        uri = self.href,
+                        search = self.search;
+
+                    if (parameter) parameter = parameter.trim();
+
+                    if (pattern(parameter).test(search)) {
+                        search = clean(parameter);
+                        uri = self.origin + self
+                            .pathname + search + self.hash;
+                    }
+
+                    window.history.pushState("", "", uri);
+
+                    return self;
+                }
+            }
+        });
+
+    } catch(e) {}
+
+})(Location);
+
+// the solution with positive lookbehind. Works in Python.
+// (?<=(?:[?&]))foo(?:=[^&#]+)?\b
+// the string for test
+// ?foo=bar&foo=bar&foo&nonfoo=bar&nonfoo&foo#foo=bar

data/lib/assets/javascripts/esphinx/lib/extensions/map.js

@@ -0,0 +1,29 @@
+(function($) {
+    "use strict";
+
+    try {
+
+        Object.defineProperties($.prototype, {
+
+            hasEquivalence: {
+                value: function(key) {
+                    var
+                        iterator = this.keys(),
+                        tuple = iterator.next();
+
+                    while (!tuple.done) {
+                        if (Object.areEquivalents(tuple.value, key)) {
+                            return true;
+                        }
+
+                        tuple = iterator.next();
+                    }
+
+                    return false;
+                }
+            }
+
+        });
+    } catch(e) {}
+
+})(Map);

data/lib/assets/javascripts/esphinx/lib/extensions/number.js

@@ -0,0 +1,42 @@
+(function($) {
+    "use strict";
+
+
+    try {
+
+        Object.defineProperties($, {
+            unit: {
+                value: function(number) {
+                    var
+                        pattern = /[^0-9\.]+/;
+
+                    return number.match(pattern)[0];
+                }
+            }
+        });
+
+        Object.defineProperties($.prototype, {
+            // usage: (m)[".."](n)
+            '..': {
+                value: function(until, step) {
+                    if (typeof step != "number") {step = 1;}
+
+                    var
+                        range = [],
+                        self = this;
+
+                    while (self <= until) {
+                        range.push(self);
+                        self += step;
+                    }
+
+                    return range;
+                }
+            }
+        });
+
+    } catch(e) {}
+
+})(Number);
+
+// console.log((0)[".."](5, 0.5))

data/lib/assets/javascripts/esphinx/lib/extensions/object.js

@@ -0,0 +1,502 @@
+//= require ./array
+
+
+var
+    Iterable;
+
+
+(function($) {
+    "use strict";
+
+
+    var
+        areEquivalents = function(object1, object2) {
+            var
+                object1Attributes,
+                object2Attributes,
+                object1Methods,
+                object2Methods,
+                object1AttributeValue,
+                object2AttributeValue,
+                iterator,
+                amount = 0,
+                primitiveTypes =
+                    /(number|string|boolean|null|undefined|symbol)/,
+
+                callback = function(attribute) {
+                    object1AttributeValue = object1[attribute];
+                    object2AttributeValue = object2[attribute];
+
+                    if ($.hasSameClass(object1AttributeValue,
+                        object2AttributeValue)) {
+                        if (typeof object1AttributeValue ==
+                            "object") {
+                            // recursivity
+                            if ($.areEquivalents(
+                                object1AttributeValue,
+                                object2AttributeValue)) {
+                                amount += 1;
+                            }
+                        } else
+                            if (object1AttributeValue ==
+                            object2AttributeValue) {
+                            amount += 1;
+                        }
+                    }
+                };
+
+            if (object1 === object2) {
+                return true;
+            } else if ($.hasSameClass(object1, object2)) {
+                if (typeof object1 == "object") {
+                    if (object1 instanceof Node) {
+                        if (object1.isEqualNode(object2)) {
+                            return true;
+                        }
+                    } else {
+                        object1Attributes = $.attributes(object1);
+                        object2Attributes = $.attributes(object2);
+                        object1Methods = $.methods(object1);
+                        object2Methods = $.methods(object2);
+
+                        // if doesn't have attributes
+                        if (!object1Attributes.length) {
+                            if (object1Methods.length ==
+                                object2Methods.length &&
+                                // recursivity
+                                $.areEquivalents(object1Methods,
+                                                 object2Methods)) {
+                                return true;
+                            }
+                        } else if (object1Attributes.length ==
+                            object2Attributes.length) {
+
+                            iterator = Iterable.Proxy.new(object1Attributes);
+
+                            iterator.each(callback);
+
+                            return amount == object1Attributes.length;
+                        }
+                    }
+                } else {
+                    if (primitiveTypes.test(typeof object1)) {
+                        return object1 === object2;
+                    }
+                }
+            }
+
+            return false;
+        };
+
+
+    try {
+        $.defineProperties($, {
+
+            clone: {
+                value: function(object, includeNonEnumerable) {
+                    if (typeof includeNonEnumerable != "boolean") {
+                        includeNonEnumerable = true;
+                    }
+
+                    var
+                        clone = {},
+                        properties = $.getOwnPropertyNames(object),
+
+                        callback = function(p) {
+                            clone[p] = object[p];
+                        };
+
+                    if (!includeNonEnumerable) {
+                        return Object.assign(clone, object);
+                    }
+
+                    try {
+                        properties.forEach(callback);
+                    } catch(e) {}
+
+                    return clone;
+                }
+            },
+
+            className: {
+                value: function(object) {
+                    var
+                        pattern = /[a-zA-Z$_][^\]]+/g,
+                        string = $.prototype.toString.call(object);
+
+                    if (typeof object == "object" &&
+                        $.implementsMethods(object, "toString")) {
+                        // if implements, then calls it
+                        string = object.toString();
+                    }
+
+                    return pattern.exec(string)[0].split(" ")[1];
+                }
+            },
+
+            classForName: {
+                value: function(name) {
+                    return window[name];
+                }
+            },
+
+            hasSameClass: {
+                value: function(objects) {
+                    var
+                        argumentsAsArray = Array.from(arguments),
+                        compared = argumentsAsArray[0],
+                        amount = 0,
+
+                        callback = function(object) {
+                            if (!object) {
+                                if ($.className(object) ==
+                                    $.className(compared)) {
+                                    amount++;
+                                }
+                            } else if ($.getPrototypeOf(compared) ==
+                                $.getPrototypeOf(object)) {
+                                amount++;
+                            }
+                        };
+
+                    argumentsAsArray = argumentsAsArray.slice(1,
+                        argumentsAsArray.length);
+                    argumentsAsArray.forEach(callback);
+
+                    return amount == argumentsAsArray.length;
+                }
+            },
+
+            belongToClass: {
+                value: function(objects, classFunction) {
+                    var
+                        iterator,
+                        argumentsAsArray = Array.from(arguments),
+                        amount = 0,
+
+                        callback = function(object) {
+                            if ($.classForName($.className(object)) ==
+                                classFunction) {
+                                amount++;
+                            }
+                        };
+
+                    classFunction = argumentsAsArray.last();
+                    argumentsAsArray.pop();
+
+                    iterator = Iterable.Proxy.new(argumentsAsArray);
+                    iterator.each(callback);
+
+                    return amount == argumentsAsArray.length;
+                }
+            },
+
+            firstKey: {
+                value: function(object) {
+                    var
+                        // Object: javascript literal object
+                        keys = Object.keys(object);
+
+
+                    return keys[0];
+                }
+            },
+
+            lastKey: {
+                value: function(object) {
+                    var
+                        keys = Object.keys(object);
+
+
+                    return keys[keys.length - 1];
+                }
+            },
+
+            normalizedAsLowerCase: {
+                value: function(object) {
+                    var
+                        iterator,
+                        attributes = Object.attributes(object),
+                        clone = {},
+
+                        callback = function(v, k) {
+                            if (typeof v == "string") {
+                                clone[k] = v.toLowerCase();
+                            }
+                        };
+
+                    Object.assign(clone, object);
+                    object.length = attributes.length;
+                    iterator = Iterable.Proxy.new(clone);
+
+                    iterator.each(callback);
+
+                    return clone;
+                }
+            },
+
+            firstFromASlice: {
+                value: function(object, slice, startingIndex, caseSensitive) {
+                    var
+                        iterator,
+                        key,
+                        regexp,
+                        attributes = Object.attributes(object),
+
+                        callback = function(k, i) {
+                            if (!isNaN(i)) {
+                                if (typeof object[k] == "string" &&
+                                    i >= startingIndex) {
+                                    if (object[k].search(regexp) != -1) {
+                                        key = k;
+                                        this.finalize();
+                                    }
+                                }
+                            } else if (typeof object[k] == "string") {
+                                if (object[k].search(regexp) != -1) {
+                                    key = k;
+                                    this.finalize();
+                                }
+                            }
+                        };
+
+                    if (typeof startingIndex != "number") {
+                        if (typeof startingIndex == "boolean") {
+                            caseSensitive = startingIndex;
+                        } else if (!caseSensitive || typeof caseSensitive !=
+                                   "boolean") {
+                            caseSensitive = false;
+                        }
+
+                        startingIndex = 0;
+                    }
+
+                    slice = slice.trim();
+
+                    if (!caseSensitive) {
+                        regexp = new RegExp(slice, "i");
+                    } else {
+                        regexp = new RegExp(slice);
+                    }
+
+                    iterator = Iterable.Proxy.new(attributes);
+                    iterator.each(callback);
+
+                    if (key) {
+                        return key;
+                    }
+
+                    return undefined;
+                }
+            },
+
+            asCountableLiteral: {
+                value: function(collection) {
+                    return Iterable.parse(collection);
+                }
+            },
+
+            // The keys of associative arrays in JS only can be of integer or string kind. The associations that keys are of Integer kind, the items is sorted according the keys (works as HashSet of the Java); the associations that keys are String kind, works as LinkedHashMap, it implements a associative array and maintains the order of entrance on iterate.
+            // TreeMap implements a structure based red-black tree (binary search).
+            indexOf: {
+                value: function(object, value) {
+                    var
+                        key,
+                        iterator,
+                        properties = $.keys(object),
+
+                        callback = function(p) {
+                            if ($.areEquivalents(object[p], value)) {
+                                key = p;
+                                this.finalize();
+                            }
+                        };
+
+                    iterator = Iterable.Proxy.new(properties);
+                    iterator.each(callback);
+
+                    if (key) {
+                        return key;
+                    }
+
+                    return undefined;
+                }
+            },
+
+            amount: {
+                value: function(object, item) {
+                    var
+                        amount;
+
+                    if (item) {
+                        amount = $.values(object).amount(item);
+                    } else {
+                        amount = $.keys(object).length;
+                    }
+
+                    return amount;
+                }
+            },
+
+            empty: {
+                value: function(object) {
+                    return $.amount(object) === 0;
+                }
+            },
+
+            some: {
+                value: function(object) {
+                    return !$.empty(object);
+                }
+            },
+
+            delete: {
+                value: function(index, object) {
+                    if (delete object[index]) {
+                        if (object.hasOwnProperty("length")) {
+                            object.length -= 1;
+                        }
+
+                        return true;
+                    }
+
+                    return false;
+                }
+            },
+
+            reverse: {
+                value: function(object) {
+                    var
+                        newObject = {},
+
+                        callback = function(k) {
+                            newObject[k] = object[k];
+                        };
+
+                    $.keys(object).reverse().forEach(callback);
+
+                    return newObject;
+                }
+            },
+
+            attributes: {
+                value: function(object, includeNonEnumerable) {
+                    if (typeof includeNonEnumerable != "boolean") {
+                        includeNonEnumerable = false;
+                    }
+
+                    var
+                        clone,
+                        properties,
+                        attributes = [],
+
+                        callback = function(p) {
+                            return typeof object[p] != "function";
+                        };
+
+                    if (!object) {
+                        return [];
+                    }
+
+                    clone = Object.clone(object, includeNonEnumerable);
+
+                    if (typeof object != "object" &&
+                        typeof object != "function" &&
+                        Object.getPrototypeOf(object)) {
+                        clone = Object.getPrototypeOf(object);
+                    }
+
+                    properties = $.keys(clone);
+
+                    if (includeNonEnumerable) {
+                        properties = $.getOwnPropertyNames(clone);
+                    }
+
+                    try {
+                        attributes = properties.filter(callback);
+                    } catch(e) {}
+
+                    return attributes;
+                }
+            },
+
+            methods: {
+                value: function(object, includeNonEnumerable) {
+                    if (typeof includeNonEnumerable != "boolean") {
+                        includeNonEnumerable = true;
+                    }
+
+                    var
+                        clone,
+                        properties;
+
+                    // otherwise it will give a cascade error
+                    if (!object) {
+                        return [];
+                    }
+
+                    clone = Object.clone(object, includeNonEnumerable);
+
+                    if (typeof object != "object" &&
+                        typeof object != "function" &&
+                        Object.getPrototypeOf(object)) {
+                        clone = Object.getPrototypeOf(object);
+                    }
+
+                    properties = $.keys(clone);
+
+                    if (includeNonEnumerable) {
+                        properties = $.getOwnPropertyNames(clone);
+                    }
+
+                    return properties.difference($.attributes(object, true));
+                }
+            },
+
+            hasAttributes: {
+                value: function(object, attributes) {
+                    var
+                        amount = 0,
+                        argumentsAsArray = Array.from(arguments),
+                        researchedAttributes = argumentsAsArray
+                            .slice(1, argumentsAsArray.length);
+
+                    attributes = $.attributes(object, true);
+
+                    researchedAttributes.forEach(function(attribute) {
+                        if (attributes.includes(attribute)) {
+                            amount++;
+                        }
+                    });
+
+                    return amount == researchedAttributes.length;
+                }
+            },
+
+            implementsMethods: {
+                value: function(object, methods) {
+                    var
+                        amount = 0,
+                        argumentsAsArray = Array.from(arguments),
+                        researchedMethods = argumentsAsArray
+                            .slice(1, argumentsAsArray.length);
+
+                    methods = $.methods(object);
+                    researchedMethods.forEach(function(method) {
+                        if (methods.includes(method)) {
+                            amount++;
+                        }
+                    });
+
+                    return amount == researchedMethods.length;
+                }
+            },
+
+            areEquivalents: {
+                value: areEquivalents
+            }
+
+        });
+    } catch(e) {}
+
+})(Object);