indexes 0.0.1 → 4.0.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: faa93cb564f7f71a3010f4916dc4d92f81fd594f
-  data.tar.gz: 39befa425667065d4a45ce753f99ecce58258833
+  metadata.gz: b5563006cc938b7b0590e7979fc6c4ef5da6ef18
+  data.tar.gz: 64a3d9f1ced530ead478aae6354d4b374341bbfa
 SHA512:
-  metadata.gz: ce9a43f8196973a30f58699bc301cad72335aea1d11f2b69ca1a8e6aceab80bd5654044ce2f081cea2ffcd2de4923abfcabbd730c25e8fdc21e77e059fc85aec
-  data.tar.gz: f3ed34a51d459a4b49ca7848d422db677971e33cd7fb3fc4804c107bfc3a886cfaa8015d38ec5ac53c58c937e5b5eca0e36351de42059d2e712ca7996d7286cb
+  metadata.gz: fd39393556426f5ffcde4aa3281089dd681b5dfd6eb52ef34270a99ed7a2d12fea661caab391bd32a23f33605aa9fe11c29f5e3add2f34f54d7fadd5b673e0be
+  data.tar.gz: 2e8fb3183fe2713156897df745e5fc392b35f303890639a2112fe9abe35eedd7a47cfc89c0fdd9dddc18ec5c6c6c3c38d8b0c3d9a2c302db53133032ef9e1f5e

data/README.md

@@ -38,7 +38,7 @@ NOTE: This gem is tested agains version 2.4.
 
 ## Configuration
 
-Run the install generator:
+Generate the configuration file:
 ```
 $ bundle exec rails g indexes:install
 ```
@@ -70,43 +70,17 @@ Indexes.configure do |config|
     end
   end
 
-  config.analysis do
-    filter do
-      ngram do
-        type 'nGram'
-        min_gram 2
-        max_gram 20
-      end
-    end
-  end
-
-  config.suggestions do |name, term, options={}|
-    type = name.to_s.singularize
-    text (term || '')
-    completion do
-      field "#{type}_suggestions"
-    end
-  end
-
-  config.add_computed_sort :price do |direction|
-    _script do
-      type 'number'
-      script do
-        inline "if (_source.currency == 'UYU') { doc['price'].value * 30 }"
-      end
-      order direction
-    end
-  end
-
 end
 ```
 
+### Definitions
+
 Generate an index:
 ```
-$ bundle exec rails g indexes:index products
+$ bundle exec rails g index products
 ```
 
-Define the index:
+Define the mappings, serialization and search in the index:
 ```ruby
 Indexes.define :products do
 
@@ -114,8 +88,8 @@ Indexes.define :products do
     properties :name, :category, :price, :product_suggestions
   end
 
-  serializer do |record|
-    set record, :name, :category, :price
+  serialization do |record|
+    extract record, :name, :category, :price
     product_suggestions do
       input [record.name, transliterate(record.name)].uniq
       output record.name
@@ -141,97 +115,143 @@ Indexes.define :products do
 end
 ```
 
-## Usage
+If you need to personalize the analysis, you have to add it to the configuration:
+
+```ruby
+Indexes.configure do |config|
+
+  config.analysis do
+    filter do
+      ngram do
+        type 'nGram'
+        min_gram 2
+        max_gram 20
+      end
+    end
+    analyzer do
+      ngram do
+        type 'custom'
+        tokenizer 'standard'
+        filter %w(lowercase ngram)
+      end
+    end
+  end
+
+end
+```
 
 ### Indexing
 
-Ocurrs everytime you create, update or destroy a record:
+The index will be updated every time a record is created, updated or destroyed:
 ```ruby
 product = Product.create(name: 'Les Paul', category: 'Gibson')
 ```
 
-You can force it manually by:
+You can force this actions manually with:
 ```ruby
 product.index
 product.reindex
 product.unindex
 ```
 
-At any time you can force a full rebuild:
-```
-$ bundle exec rake indexes:rebuild
-```
+### Rake tasks
 
-Or if you need just a build:
+At any time you can build/rebuild your indexes using:
 ```
 $ bundle exec rake indexes:build
+$ bundle exec rake indexes:rebuild
 ```
 
 ### Search
 
-The search parameters are sent to previous configured block:
+Use the included search method in the model:
 ```ruby
-products = Product.search(name: 'Test')
+products = Product.search('Les Paul')
 ```
 
-You can use the returned value as a collection in views:
+The result can be used as a collection in views:
 ```erb
 <%= render products %>
 ```
 
 ### Includes
 
-Same as using activerecord relations:
+Similar to using activerecod:
 ```ruby
-Product.search(includes: :shop)
+Product.search.includes(:shop)
 ```
 
 ### With / Without
 
 You can force a record to be part of the results by id:
 ```ruby
-Product.search(with: 4)
+Products.search.with(4)
 ```
 
 Or the opposite:
 ```ruby
-Product.search(without: 4)
+Products.search.without(4)
 ```
 
 ### Pagination
 
 Works the same as [pagers gem](https://github.com/mmontossi/pagers):
 ```ruby
-products.page 1, padding: 4, length: 30
+Products.search.page(1, padding: 4, length: 30)
 ```
 
-And you can send the collection directly to the helper in views:
+And you can send the collection directly to the view helper:
 ```erb
 <%= paginate products %>
 ```
 
 ### Order
 
-Works the same as in relations:
+Same as using activerecord:
 ```ruby
-products.order(name: :asc)
+Product.search.order(name: :asc)
 ```
 
-To use a computed_sort:
+You can use a computed sort by declare it in the configuration:
 ```ruby
-products.order(price: :asc)
-```
+Indexes.configure do |config|
 
-NOTE: To sort by a string column, you must declare the mapping raw.
+  config.computed_sort :price do |direction|
+    _script do
+      type 'number'
+      script do
+        inline "if (_source.currency == 'UYU') { doc['price'].value * 30 }"
+      end
+      order direction
+    end
+  end
+
+end
+```
 
 ### Suggestions
 
-The suggestion parameters are sent to previous configured block:
+You need to first define the logic in the configuration:
+```ruby
+Indexes.configure do |config|
+
+  config.suggestions do |name, term, options={}|
+    type = name.to_s.singularize
+    text (term || '')
+    completion do
+      field "#{type}_suggestions"
+    end
+  end
+
+end
+```
+
+Then you can get suggestions using the suggest method:
 ```ruby
 Indexes.suggest :products, 'gibson'
 ```
 
-Returns array of hashes with a text property:
+The result is an array of hashes with a text property:
 ```ruby
 [{ text: 'Les Paul' }, ...]
 ```

data/lib/generators/{indexes → index}/index_generator.rb

@@ -2,7 +2,7 @@ require 'rails/generators'
 
 module Indexes
   module Generators
-    class IndexGenerator < Rails::Generators::NamedBase
+    class IndexGenerator < ::Rails::Generators::NamedBase
 
       source_root File.expand_path('../templates', __FILE__)
 

data/lib/generators/{indexes → index}/templates/index.rb

@@ -3,7 +3,7 @@ Indexes.define :<%= table_name %> do
   mappings do
   end
 
-  serializer do |record|
+  serialization do |record|
   end
 
   search do |*args|

data/lib/generators/indexes/{install_generator.rb → install/install_generator.rb}

@@ -2,7 +2,7 @@ require 'rails/generators'
 
 module Indexes
   module Generators
-    class InstallGenerator < Rails::Generators::Base
+    class InstallGenerator < ::Rails::Generators::Base
 
       source_root File.expand_path('../templates', __FILE__)
 

data/lib/indexes.rb

@@ -1,16 +1,15 @@
-require 'generators/indexes/index_generator'
-require 'generators/indexes/install_generator'
 require 'indexes/dsl/api'
 require 'indexes/dsl/mappings'
 require 'indexes/dsl/search'
-require 'indexes/dsl/serializer'
+require 'indexes/dsl/serialization'
+require 'indexes/collection'
 require 'indexes/concern'
 require 'indexes/configuration'
+require 'indexes/definitions'
 require 'indexes/index'
 require 'indexes/pagination'
 require 'indexes/proxy'
 require 'indexes/railtie'
-require 'indexes/collection'
 require 'indexes/version'
 
 module Indexes
@@ -41,22 +40,12 @@ module Indexes
       @configuration ||= Configuration.new
     end
 
-    def define(*args, &block)
-      Proxy.new *args, &block
-    end
-
-    def add(*args)
-      index = Index.new(*args)
-      registry[index.name] = index
+    def definitions
+      @definitions ||= Definitions.new
     end
 
-    def find(name)
-      registry[name]
-    end
-    alias_method :[], :find
-
-    def each(&block)
-      registry.values.sort.each &block
+    def define(*args, &block)
+      Proxy.new *args, &block
     end
 
     def build
@@ -66,11 +55,7 @@ module Indexes
           body: { settings: configuration.analysis }
         )
       end
-      each &:build
-    end
-
-    def exist?(type)
-      client.indices.exists? index: namespace, type: type
+      definitions.each &:build
     end
 
     def rebuild
@@ -78,6 +63,10 @@ module Indexes
       build
     end
 
+    def exist?(type)
+      client.indices.exists? index: namespace, type: type
+    end
+
     def destroy
       if client.indices.exists?(index: namespace)
         client.indices.delete index: namespace
@@ -92,11 +81,5 @@ module Indexes
       response['suggestions'].first['options'].map &:symbolize_keys
     end
 
-    private
-
-    def registry
-      @registry ||= {}
-    end
-
   end
 end

data/lib/indexes/collection.rb

@@ -8,17 +8,29 @@ module Indexes
 
     alias_method :to_ary, :to_a
 
-    def initialize(index, *args, &block)
+    def initialize(index, args=[], options={}, &block)
       @loaded = false
       @index = index
-      @options = args.extract_options!
       @args = args
+      @options = options
       @block = block
     end
 
+    def with(ids)
+      chain with: ids
+    end
+
+    def without(ids)
+      chain without: ids
+    end
+
+    def includes(*args)
+      chain includes: args
+    end
+
     def page(number, options={})
-      length = (fetch_option(options, :length) || 10)
-      padding = (fetch_option(options, :padding) || 0)
+      length = page_option(options, :length, 10)
+      padding = page_option(options, :padding, 0)
       current_page = [number.to_i, 1].max
       values = Module.new do
         define_method :page_length do
@@ -31,32 +43,28 @@ module Indexes
           current_page
         end
       end
-      overrides = {
+      chain(
+        Pagination,
+        values,
         from: ((length * (current_page - 1)) + padding),
         size: length
-      }
-      %i(with without).each do |name|
-        if options.has_key?(name)
-          overrides[name] = options[name]
-        end
-      end
-      chain Pagination, values, overrides
+      )
     end
 
     def order(options)
       mappings = Indexes.configuration.mappings
-      sort = []
+      values = []
       options.each do |property, direction|
         if block = Indexes.configuration.computed_sorts[property]
-          sort << Dsl::Api.new(direction, &block).to_h
+          values << Dsl::Api.new(direction, &block).to_h
         elsif property == :id
-          sort << { _uid: { order: direction } }
+          values << { _uid: { order: direction } }
         elsif mappings.has_key?(property) && mappings[property][:type] == 'string'
-          sort << { "#{property}.raw" => { order: direction } }
+          values << { "#{property}.raw" => { order: direction } }
         end
       end
-      if sort.any?
-        chain sort: sort
+      if values.any?
+        chain sort: values
       else
         chain
       end
@@ -75,7 +83,7 @@ module Indexes
       @query ||= begin
         pagination = options.slice(:from, :size, :sort)
         without_ids = fetch_ids(options[:without])
-        body = Dsl::Search.new(args.append(options), &block).to_h[:query]
+        body = Dsl::Search.new(args, &block).to_h[:query]
         request = Dsl::Search.new do
           if without_ids.any?
             query do
@@ -97,9 +105,9 @@ module Indexes
           else
             query body
           end
-          %i(from size).each do |option|
-            if pagination.has_key?(option)
-              send option, pagination[option]
+          %i(from size).each do |name|
+            if pagination.has_key?(name)
+              send name, pagination[name]
             end
           end
           if pagination.has_key?(:sort)
@@ -122,47 +130,30 @@ module Indexes
 
     def records
       @records ||= begin
+        hit_ids = response['hits']['hits'].map{ |hit| hit['_id'].to_i }
+        missing_ids = (fetch_ids(options[:with]) - hit_ids)
         if missing_ids.any?
           last_index = -(missing_ids.length + 1)
           ids = (missing_ids.sort.reverse + hit_ids.to(last_index))
         else
           ids = hit_ids
         end
+        includes = options.fetch(:includes, [])
         index.model.includes(includes).where(id: ids).sort do |a,b|
           ids.index(a.id) <=> ids.index(b.id)
         end
       end
     end
 
-    def with_ids
-      @with_ids ||= fetch_ids(options[:with])
-    end
-
-    def hit_ids
-      @hit_ids ||= response['hits']['hits'].map{ |hit| hit['_id'].to_i }
-    end
-
-    def missing_ids
-      @missing_ids ||= (with_ids - hit_ids)
-    end
-
-    def includes
-      @inclues ||= begin
-        if options.has_key?(:includes)
-          Array options[:includes]
-        else
-          []
-        end
-      end
-    end
-
-    def fetch_option(options, name)
-      options[name] || begin
+    def page_option(source, name, default)
+      source[name] || begin
         if Rails.configuration.cache_classes == false
           Rails.application.eager_load!
         end
         if defined?(Pagers)
-          Pagers.config[name]
+          Pagers.configuration.send name
+        else
+          default
         end
       end
     end
@@ -184,11 +175,11 @@ module Indexes
 
     def chain(*extensions)
       overrides = extensions.extract_options!
-      Collection.new(index, *args.append(options.merge(overrides)), &block).tap do |collection|
-        extensions.each do |extension|
-          collection.extend extension
-        end
+      collection = Collection.new(index, args, options.merge(overrides), &block)
+      extensions.each do |extension|
+        collection.extend extension
       end
+      collection
     end
 
   end