esphinx-rails 1.1.2

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

@@ -0,0 +1,3 @@
+//= require ./main
+//= require_directory ./lib
+//= require_tree .

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

@@ -0,0 +1,51 @@
+var
+    esPhinx;
+
+
+(function($) {
+    "use strict";
+
+
+    $.extend({
+        Collection: {}
+    });
+
+    $.Extender.extend($.Collection, true, {
+        new: function(collection) {
+            var
+                asArray,
+                self = $.Collection,
+                ConstructorReference = self.new,
+
+                callback = function(object1, object2) {
+                    // debugger
+                    // if (Object.classForName(Object.className(object1))
+                    if (object1.constructor
+                        .implementsMethods("compareTo")) {
+                        return object1.compareTo(object2);
+                    }
+                };
+
+            if (!(this instanceof ConstructorReference)) {
+                return new ConstructorReference(collection);
+            }
+
+            if(!(collection instanceof Array)) {
+                asArray = Array.from(Object.asCountableLiteral(collection));
+            } else {
+                asArray = collection;
+            }
+
+            this.sort = function(compareFunction) {
+                if (typeof compareFunction == "function") {
+                    return asArray.sort(compareFunction);
+                } else {
+                    // callback in node1 and node2, based a some (Strategy), objects to compare and sort.
+                    return asArray.sort(callback);
+                }
+            };
+
+        }
+    });
+
+}(esPhinx));

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

@@ -0,0 +1,54 @@
+// var
+//     Comparable;
+
+// (function($) {
+//     "use strict";
+
+//     // callback pode ser definido aqui (static) para ser usado no caso de o tipo dos dois argumentos forem de um tipo incompatível
+
+//     $.extend({
+
+//         Comparable: {
+
+//             compareTo: function (object) {
+//                 if (this) {
+//                     if (Object.getPrototypeOf(this) ==
+//                         Object.getPrototypeOf(object) &&
+//                         this > object) {
+//                         return true;
+//                     }
+//                 } else if (argument[1]) {
+//                     if (Object.getPrototypeOf(object) ==
+//                         Object.getPrototypeOf(argument[1]) &&
+//                         object > argument[1]) {
+//                         return true;
+//                     }
+//                 }
+//             }
+
+//             // compareTo: function (callback) {
+//             //     var
+//             //         clone,
+//             //         collection;
+
+//             //     // não precisa testar se é instância de array, bastaria testar se é iterável e usar Array.from para converter
+//             //     if (this && this instanceof Array) {
+//             //         collection = this;
+//             //     } else if (callback instanceof Array && argument[1] &&
+//             //                typeof argument[1] == "function") {
+//             //         collection = callback;
+//             //         callback = argument[1];
+//             //     }
+
+//             //     clone = collection.clone();
+//             //     clone.sort(function(a, b) {
+//             //         // return callback(a, b);
+//             //         callback(a, b);
+//             //     });
+//             // }
+
+//         }
+
+//     });
+
+// }(window));

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

@@ -0,0 +1,541 @@
+var
+    SearchContext,
+    Search,
+    Iterable;
+
+(function($) {
+    "use strict";
+
+    try {
+        Object.defineProperties($, {
+            flatten: {
+                value: function(linkedList) {
+                    var
+                        iterator,
+                        flattened = [],
+                        allowedPattern = /^(Array|Arguments)$/,
+                        className = Object.className(linkedList),
+
+                        callback = function(item) {
+                            if (!allowedPattern.test(Object.className(item))) {
+                                flattened.push(item);
+                            }
+                        };
+
+                    if (className == "Arguments") {
+                        linkedList = $.from(linkedList);
+                    } else if (!allowedPattern.test(className)) {
+                        return linkedList;
+                    }
+
+                    // this way will treate all as String after run .join
+                    // linkedList = linkedList.join().split(",");
+                    iterator = SearchContext.Proxy
+                        .new(Search.Graphs.BFS.Object.new(linkedList));
+
+                    iterator.research(callback);
+
+                    return flattened;
+                }
+            },
+
+            compact: {
+                value: function(collection) {
+                    var
+
+                        callback = function(item) {
+                            if (typeof item == "string") {
+                                if (item !== "") {
+                                    return true;
+                                }
+                            } else {
+                                if (item !== undefined && item !== null) {
+                                    return true;
+                                }
+                            }
+                        };
+
+                    return collection.filter(callback);
+                }
+            }
+        });
+
+        Object.defineProperties($.prototype, {
+
+            copy: {
+                value: function(startingIndex, finalIndex) {
+                    return this.slice(startingIndex, finalIndex + 1);
+                }
+            },
+
+            clone: {
+                value: function() {
+                    var
+                        clone = [];
+
+                    Object.assign(clone, this);
+
+                    return clone;
+                }
+            },
+
+            intersection: {
+                value: function(set) {
+                    var
+                        smaller,
+                        larger,
+                        all = [this, set],
+
+                        classifier = function(first, second) {
+                            return first.length > second.length;
+                        },
+
+                        callback = function(item) {
+                          return larger.includes(item);
+                        };
+
+                    smaller = (all = all.sort(classifier)).first();
+                    larger = all[1];
+
+                    return smaller.filter(callback).uniq();
+                }
+            },
+
+            intersections: {
+                value: function(sets) {
+                    var
+                        smaller,
+                        self = this,
+                        all = Array.from(arguments),
+
+                        classifier = function(first, second) {
+                            return first.length > second.length;
+                        },
+
+                        callback = function(intersections, set) {
+                            return intersections.intersection(set);
+                        };
+
+                    all.push(self);
+                    all.sort(classifier);
+                    smaller = all.deleteAt(0);
+                    // reduce works with any value and it cans to reduce the list, filter works with true or false to filter values, and map replace the values.
+                    return all.reduce(callback, smaller.intersection(all.first()));
+                }
+            },
+
+            difference: {
+                value: function(sets) {
+                    var
+                        self = this,
+                        differences = self.clone(),
+
+                        iteratorBlock = function(set) {
+                            var
+                                callback = function(item) {
+                                    return !set.includes(item);
+                                };
+
+                            differences = differences.filter(callback);
+                        };
+
+                    sets = Array.from(arguments);
+
+                    if (sets.length < 1) {
+                        return this;
+                    }
+
+                    sets.uniq().forEach(iteratorBlock);
+
+                    return differences;
+                }
+            },
+
+            insertAt: {
+                value: function(values, index) {
+                    var
+                        copy,
+                        self = this,
+                        argumentsAsArray = Array.from(arguments),
+
+                        callback = function(v) {
+                            self.push(v);
+                        };
+
+                    index = argumentsAsArray.last();
+                    copy = self.copy(index, self.lastIndex());
+                    argumentsAsArray.deleteAt(argumentsAsArray.lastIndex());
+                    self.deleteAt(index, self.lastIndex());
+                    Array.prototype.push.apply(self, argumentsAsArray);
+
+                    copy.forEach(callback);
+
+                    return this;
+                }
+            },
+
+            indexOfEquivalence: {
+                // value: function(comparator, startingIndex = 0) {
+                value: function(comparator, startingIndex) {
+                    if(typeof startingIndex != "number") {startingIndex = 0;}
+
+                    var
+                        item,
+                        i = startingIndex;
+
+                    for (i = startingIndex; i < this.length; i++) {
+                        item = this[i];
+                        if (typeof item == "function") {
+                            if (item == comparator) {
+                                return i;
+                            }
+                        } else {
+                            if (item === undefined) {
+                                console.warn("Item to compare is " +
+                                                "undefined!");
+                            }
+
+                            if (Object.areEquivalents(item, comparator)) {
+                                return i;
+                            }
+                        }
+                    }
+
+                    return -1;
+                }
+            },
+
+            uniq: {
+                value: function() {
+                    var
+                        callback = function(reduced, value) {
+                            if (reduced.indexOfEquivalence(value) == -1) {
+                                reduced.push(value);
+                            }
+                            return reduced;
+                        };
+
+                    return this.reduce(callback, []);
+                }
+            },
+
+            // already proposed in ES7
+            // includes: {
+            //     value: function(items) {
+            //         var
+            //             argumentsAsArray = Array.from(arguments).uniq(),
+            //             mainReference = this,
+            //             count = 0,
+
+            //             callback = function(arg) {
+            //                 if (mainReference.indexOfEquivalence(arg) > -1) {
+            //                     count += 1;
+            //                 }
+            //             };
+
+            //         argumentsAsArray.forEach(callback);
+
+            //         return count == argumentsAsArray.length;
+            //     }
+            // },
+
+            deleteAt: {
+                value: function(startingIndex, finalIndex) {
+                    var
+                        value,
+                        count = 1;
+
+                    if (typeof finalIndex == "number") {
+                        count = finalIndex + 1 - startingIndex;
+                    }
+
+                    value = this[startingIndex];
+                    this.splice(startingIndex, count);
+
+                    return value;
+                }
+            },
+
+            delete: {
+                value: function(collection) {
+                    var
+                        amount,
+                        index,
+                        deletedValue,
+                        self = this,
+                        deleted = [],
+                        partsToDelete = Array.from(arguments),
+
+                        callback = function(value) {
+                            amount = self.amount(value);
+                            while (amount-- > 0) {
+                                index = self.indexOfEquivalence(value);
+                                if (index > -1) {
+                                    deletedValue = self[index];
+                                    self.splice(index, 1);
+                                }
+                            }
+
+                            if (index > -1) {
+                                deleted.push(deletedValue);
+                            }
+                        };
+
+                    partsToDelete.forEach(callback);
+
+                    if (deleted.length > 1) {
+                        return deleted;
+                    }
+                    return deleted[0];
+                }
+            },
+
+            without: {
+                value: function(items) {
+                    var
+                        parts = Array.from(arguments),
+                        self = this,
+
+                        callback = function(item) {
+                            return !parts.includes(item);
+                        };
+
+                    return self.filter(callback);
+                }
+            },
+
+            amount: {
+                value: function(item) {
+
+                    var
+                        count = 0,
+                        i = 0;
+
+                    while (true) {
+                        i = this.indexOfEquivalence(item, i);
+                        if (i > -1) {
+                            count++;
+                            if (++i == this.length) {
+                                break;
+                            }
+                        } else {
+                            break;
+                        }
+                    }
+
+                    return count;
+                }
+            },
+
+            empty: {
+                value: function() {
+                    return this.amount() === 0;
+                }
+            },
+
+            firstFromASlice: {
+                value: function(slice, startingIndex, caseSensitive) {
+                    var
+                        regexp,
+                        iterator,
+                        clone = this.clone(),
+                        index = -1,
+
+                        block = function(v, i) {
+                            if (typeof v == "string" && i >= startingIndex) {
+                                if (v.search(regexp) != -1) {
+                                    index = i;
+                                    this.finalize();
+                                }
+                            }
+                        };
+
+                    if (typeof startingIndex != "number") {
+                        if (typeof startingIndex == "boolean") {
+                            caseSensitive = startingIndex;
+                        }
+                        startingIndex = 0;
+                    }
+
+                    if (typeof caseSensitive != "boolean") {
+                        caseSensitive = false;
+                    }
+
+                    if (startingIndex === 0) {
+                        clone = clone.asc();
+                    }
+
+                    slice = slice.trim();
+
+                    if (!caseSensitive) {
+                        regexp = new RegExp(slice, "i");
+                    } else {
+                        regexp = new RegExp(slice);
+                    }
+
+                    iterator = Iterable.Proxy.new(this);
+                    iterator.each(block);
+
+                    return index;
+                }
+            },
+
+            countSlice: {
+                value: function(slice, startingIndex, caseSensitive) {
+                    var
+                        i,
+                        regexp,
+                        clone = this.clone(),
+                        count = 0;
+
+                    if (typeof startingIndex != "number") {
+                        if (typeof startingIndex == "boolean") {
+                            caseSensitive = startingIndex;
+                        }
+                        startingIndex = 0;
+                    }
+
+                    if (typeof caseSensitive != "boolean") {
+                        caseSensitive = false;
+                    }
+
+                    if (startingIndex === 0) {
+                        clone = clone.asc();
+                    }
+
+                    slice = slice.trim();
+
+                    if (!caseSensitive) {
+                        regexp = new RegExp(slice, "i");
+                    } else {
+                        regexp = new RegExp(slice);
+                    }
+
+                    i = parseInt(clone.firstFromASlice(slice, startingIndex,
+                                                     caseSensitive));
+
+                    if (i > -1) {
+                        while (i < this.length) {
+                            if (clone[i].trim().search(regexp) > -1) {
+                                count += 1;
+                                i += 1;
+                            } else {
+                                break;
+                            }
+                        }
+                    }
+
+                    return count;
+                }
+            },
+
+            flatten: {
+                value: function() {
+                    return $.flatten(this);
+                }
+            },
+
+            normalizeToLowerCase: {
+                value: function() {
+                    var
+                        clone = [],
+
+                        callback = function(value) {
+                            if (typeof value == "string") {
+                                clone.push(value.toLowerCase()());
+                            }
+                        };
+
+                    this.forEach(callback);
+
+                    return clone;
+                }
+            },
+
+            capitalize: {
+                value: function() {
+                    var
+                        clone = [],
+
+                        callback = function(value) {
+                            if (typeof value == "string") {
+                                clone.push(value.capitalize());
+                            }
+                        };
+
+                    this.forEach(callback);
+
+                    return clone;
+                }
+            },
+
+            spaceOut: {
+                value: function() {
+                    var
+                        i = 0,
+                        clone = this.clone();
+
+                    while (i < clone.lastIndex()) {
+                        clone[i++] += " ";
+                    }
+
+                    return clone;
+                }
+            },
+
+            compact: {
+                value: function() {
+                    return $.compact(this);
+                }
+            },
+
+            asc: {
+                value: function() {
+                    var
+                        clone = this.clone(),
+                        compareFunction = function(a, b) {
+                            return a > b;
+                        };
+
+                    clone.sort(compareFunction);
+
+                    return clone;
+                }
+            },
+
+            desc: {
+                value: function() {
+                    var
+                        clone = this.clone(),
+                        compareFunction = function(a, b) {
+                            return a < b;
+                        };
+
+                    clone.sort(compareFunction);
+
+                    return clone;
+                }
+            },
+
+            lastIndex: {
+                value: function() {
+                    return this.length - 1;
+                }
+            },
+
+            first: {
+                value: function() {
+                    return this[0];
+                }
+            },
+
+            last: {
+                value: function() {
+                    return this[this.lastIndex()];
+                }
+            }
+
+        });
+    } catch(e) {}
+
+})(Array);