elastic_record 4.0.0 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 95195e9bd6f65e35a24b3ed7d8a3d8ee4170a214
-  data.tar.gz: 65331f5fec26898efe80717794ef0a5ca897895e
+  metadata.gz: d074472d548bd216e7bfb7d92c9bebae0c396570
+  data.tar.gz: a3ec5801c91b65775d27d59d7eaf57fc13adb131
 SHA512:
-  metadata.gz: d151b8500473e3634658de2f8b1869bc25a480c081faf6a48a952312ff6f5db7409c3b26a04424750ddf36611f45fbb659440c32a0e52deeb3147670668ac86c
-  data.tar.gz: 27171232b4f59a2f290e323c5742b24034926f1231275f6258cb6463e1f8bea9c217e07a3f16530d96791d8d4fbe11812967aa27b2e9fc99bbd137de33af3319
+  metadata.gz: b611bc325d5b09e2adac8f34450898c32a23a4eb50050a23673efcee27a44b1ea938c2034fe92d2c29104e9068295df4c2c3abda6d28a813e5e7afe4d11c2365
+  data.tar.gz: 5ac3ce49becf9c7d1d13fd12ee5396375c16c37df7ba0339be1f9bae57a88f58f5fc5e2823e2872cc6e185cd7422baacd92c983c439a064e316f093921b003b0

data/.travis.yml

@@ -1,14 +1,11 @@
-rvm:
-- 2.4.1
+rvm: 2.4.1
 cache: bundler
-# Not using Trusty containers because of:
-# https://github.com/travis-ci/travis-ci/issues/6842
-sudo: required
+sudo: false
 dist: trusty
 addons:
   apt:
     sources:
-    - elasticsearch-2.x
+    - elasticsearch-5.x
     packages:
     - elasticsearch
 before_script:

data/Gemfile

@@ -3,10 +3,8 @@ source 'https://rubygems.org'
 gemspec
 
 gem 'dotenv-rails'
-# gem 'mysql2'
 gem 'oj'
 gem 'pg'
 gem 'rails'
 gem 'rake', '~> 10.5.0'
 gem 'webmock', require: false
-gem 'arelastic'

data/README.md

@@ -153,26 +153,42 @@ end
 Product.filter(color: 'red').increase_prices
 ```
 
-## Index Configuration
+## Percolators ##
+
+ElasticRecord supports representing query documents as a model.  Queries are registered and unregistered as query models are created and destroyed.
 
-While elastic search automatically maps fields, you may wish to override the defaults:
+First, include `ElasticRecord::PercolatorModel` into your model.  Specify the target model to percolate and how the model should be indexed as an ElasticSearch query.
 
 ```ruby
-class Product < ActiveRecord::Base
-  elastic_index.configure do
-    property :status, type: "string", index: "not_analyzed"
+class ProductQuery
+  include ElasticRecord::PercolatorModel
+
+  self.percolates_model = Product
+
+  def as_search_document
+    Product.filter(status: status).as_elastic
   end
 end
 ```
 
-You can also directly access Product.elastic_index.mapping and Product.elastic_index.settings:
+Use the `percolate` method to find records with queries that match.
+
+```
+  product = Product.new(price: 5.99)
+  matching_product_queries = ProductQuery.percolate(product)
+```
+
+## Index Configuration
+
+To avoid elasticsearch dynamically mapping fields, you can directly configure Product.doctype.mapping
+and Product.elastic_index.settings:
 
 ```ruby
 class Product
-  elastic_index.mapping = {
+  doctype.mapping = {
     properties: {
-      name: {type: "string", index: "analyzed"}
-      status: {type: "string", index: "not_analyzed"}
+      name: {type: "text"},
+      status: {type: "keyword"}
     }
   }
 end

data/elastic_record.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = 'elastic_record'
-  s.version = '4.0.0'
+  s.version = '4.1.0'
   s.summary = 'An Elasticsearch querying ORM'
   s.description = 'Find your records with Elasticsearch'
 

data/lib/elastic_record/as_document.rb

@@ -0,0 +1,41 @@
+module ElasticRecord
+  module AsDocument
+    def as_search_document
+      doctype.mapping[:properties].each_with_object({}) do |(field, mapping), result|
+        value = elastic_search_value field, mapping
+
+        unless value.nil?
+          result[field] = value
+        end
+      end
+    end
+
+    def as_partial_update_document
+      mappings = doctype.mapping[:properties]
+
+      changed.each_with_object({}) do |field, result|
+        if field_mapping = mappings[field]
+          result[field] = elastic_search_value field, field_mapping
+        end
+      end
+    end
+
+    def elastic_search_value(field, mapping)
+      value = try field
+      return if value.nil?
+
+      value = case mapping[:type]
+              when :object
+                value.as_search_document
+              when :nested
+                value.map(&:as_search_document)
+              else
+                value
+              end
+
+      if value.present? || value == false
+        value
+      end
+    end
+  end
+end

data/lib/elastic_record/callbacks.rb

@@ -4,71 +4,26 @@ module ElasticRecord
       return unless base.respond_to?(:after_save) &&  base.respond_to?(:after_destroy)
 
       base.class_eval do
-        after_create do
-          self.class.elastic_index.index_record self
-        end
-
-        after_update if: :changed? do
-          method = self.class.elastic_index.partial_updates ? :update_record : :index_record
-          self.class.elastic_index.send(method, self)
-        end
-
-        after_destroy do
-          self.class.elastic_index.delete_document id
-        end
+        after_create :create_index_document
+        after_update :update_index_document, if: :changed?
+        after_destroy :delete_index_document
       end
     end
 
-    def as_search
-      json = {}
+    private
 
-      elastic_index.mapping[:properties].each do |field, mapping|
-        value = elastic_search_value field, mapping
-
-        unless value.nil?
-          json[field] = value
-        end
+      def create_index_document
+        self.class.elastic_index.index_record self
       end
 
-      amend_as_search(json) if respond_to?(:amend_as_search)
+      def update_index_document
+        method = self.class.elastic_index.partial_updates ? :update_record : :index_record
 
-      json
-    end
-
-    def as_partial_update_document
-      json = {}
-
-      mappings = elastic_index.mapping[:properties]
-      changed.each do |field|
-        if field_mapping = mappings[field]
-          json[field] = elastic_search_value field, field_mapping
-        end
+        self.class.elastic_index.send(method, self)
       end
 
-      amend_partial_update_document(json) if respond_to?(:amend_partial_update_document)
-
-      json
-    end
-
-    def elastic_search_value(field, mapping)
-      value = try field
-      return if value.nil?
-
-      value = case mapping[:type]
-        when :object
-          value.as_search
-        when :nested
-          value.map(&:as_search)
-        else
-          value
-        end
-
-      if value.present? || value == false
-        value
+      def delete_index_document
+        self.class.elastic_index.delete_document id
       end
-
-    rescue
-      raise "Field not found for #{field.inspect}"
-    end
   end
 end

data/lib/elastic_record/connection.rb

@@ -76,7 +76,7 @@ module ElasticRecord
       delete: Net::HTTP::Delete
     }
     def new_request(method, path, body)
-      request = METHODS[method].new(path)
+      request = METHODS[method].new(path.starts_with?('/') ? path : "/#{path}")
       request.basic_auth(options[:username], options[:password]) if options[:username].present?
       request.body = body
       request.content_type = 'application/json'

data/lib/elastic_record/doctype.rb

@@ -0,0 +1,43 @@
+module ElasticRecord
+  class Doctype
+    attr_accessor :name, :mapping, :analysis
+
+    DEFAULT_MAPPING = {
+      properties: {
+      },
+      _all: {
+        enabled: false
+      }
+    }
+
+    PERCOLATOR_MAPPING = {
+      "properties" => {
+        "query" => {
+          "type" => "percolator"
+        }
+      }
+    }
+
+    def self.percolator_doctype
+      new('queries', PERCOLATOR_MAPPING)
+    end
+
+    def initialize(name, mapping = DEFAULT_MAPPING.deep_dup)
+      @name = name
+      @mapping = mapping
+      @analysis = {}
+    end
+
+    def mapping=(custom_mapping)
+      mapping.deep_merge!(custom_mapping)
+    end
+
+    def analysis=(custom_analysis)
+      analysis.deep_merge!(custom_analysis)
+    end
+
+    def ==(other)
+      name == other.name && mapping == other.mapping && analysis == other.analysis
+    end
+  end
+end

data/lib/elastic_record/index/deferred.rb

@@ -14,9 +14,8 @@ module ElasticRecord
         attr_accessor :bulk_stack
 
         def initialize(index)
-          self.index = index
-          self.bulk_stack = []
-          @deferring_enabled = false
+          @index = index
+          @bulk_stack = []
           reset!
         end
 
@@ -34,30 +33,29 @@ module ElasticRecord
           self.writes_made = false
         end
 
-        def flush!
-          deferred_actions.each do |queued_action|
-            self.writes_made = true
-            queued_action.run(index.real_connection)
-          end
-          deferred_actions.clear
-        end
-
         private
           READ_METHODS = [:json_get, :head]
           def method_missing(method, *args, &block)
             super unless index.real_connection.respond_to?(method)
 
             if READ_METHODS.include?(method)
-              flush!
-              index.real_connection.json_post("/#{index.alias_name}/_refresh") if requires_refresh?(method, *args)
+              flush_deferred_actions!
+              if method == :json_get && args.first =~ /^\/(.*)\/_search/
+                index.real_connection.json_post("/#{$1.partition('/').first}/_refresh")
+              end
+
               index.real_connection.send(method, *args, &block)
             else
               deferred_actions << DeferredAction.new(method, args, block)
             end
           end
 
-          def requires_refresh?(method, *args)
-            method == :json_get && args.first =~ /_search/
+          def flush_deferred_actions!
+            deferred_actions.each do |queued_action|
+              self.writes_made = true
+              queued_action.run(index.real_connection)
+            end
+            deferred_actions.clear
           end
       end
 

data/lib/elastic_record/index/documents.rb

@@ -53,58 +53,68 @@ module ElasticRecord
     module Documents
       def index_record(record, index_name: alias_name)
         unless disabled
-          index_document(record.send(record.class.primary_key), record.as_search, index_name: index_name)
+          index_document(
+            record.send(record.class.primary_key),
+            record.as_search_document,
+            doctype: record.doctype,
+            index_name: index_name
+          )
         end
       end
 
       def update_record(record, index_name: alias_name)
         unless disabled
-          update_document(record.send(record.class.primary_key), record.as_partial_update_document, index_name: index_name)
+          update_document(
+            record.send(record.class.primary_key),
+            record.as_partial_update_document,
+            doctype: record.doctype,
+            index_name: index_name
+          )
         end
       end
 
-      def index_document(id, document, parent: nil, index_name: alias_name)
+      def index_document(id, document, doctype: model.doctype, parent: nil, index_name: alias_name)
         if batch = current_bulk_batch
-          instructions = { _index: index_name, _type: type, _id: id }
+          instructions = { _index: index_name, _type: doctype.name, _id: id }
           instructions[:parent] = parent if parent
 
           batch << { index: instructions }
           batch << document
         else
-          path = "/#{index_name}/#{type}/#{id}"
+          path = "/#{index_name}/#{doctype.name}/#{id}"
           path << "?parent=#{parent}" if parent
 
           connection.json_put path, document
         end
       end
 
-      def update_document(id, document, parent: nil, index_name: alias_name)
+      def update_document(id, document, doctype: model.doctype, parent: nil, index_name: alias_name)
         params = {doc: document, doc_as_upsert: true}
 
         if batch = current_bulk_batch
-          instructions = { _index: index_name, _type: type, _id: id, _retry_on_conflict: 3 }
+          instructions = { _index: index_name, _type: doctype.name, _id: id, _retry_on_conflict: 3 }
           instructions[:parent] = parent if parent
 
           batch << { update: instructions }
           batch << params
         else
-          path = "/#{index_name}/#{type}/#{id}/_update?retry_on_conflict=3"
+          path = "/#{index_name}/#{doctype.name}/#{id}/_update?retry_on_conflict=3"
           path << "&parent=#{parent}" if parent
 
           connection.json_post path, params
         end
       end
 
-      def delete_document(id,  parent: nil, index_name: alias_name)
+      def delete_document(id, doctype: model.doctype, parent: nil, index_name: alias_name)
         raise "Cannot delete document with empty id" if id.blank?
         index_name ||= alias_name
 
         if batch = current_bulk_batch
-          instructions = { _index: index_name, _type: type, _id: id, _retry_on_conflict: 3 }
+          instructions = { _index: index_name, _type: doctype.name, _id: id, _retry_on_conflict: 3 }
           instructions[:parent] = parent if parent
           batch << { delete: instructions }
         else
-          path = "/#{index_name}/#{type}/#{id}"
+          path = "/#{index_name}/#{doctype.name}/#{id}"
           path << "&parent=#{parent}" if parent
 
           connection.json_delete path
@@ -122,7 +132,7 @@ module ElasticRecord
       end
 
       def record_exists?(id)
-        get(id)['found']
+        get(id, model.doctype)['found']
       end
 
       def search(elastic_query, options = {})
@@ -131,7 +141,7 @@ module ElasticRecord
           url += "?#{options.to_query}"
         end
 
-        get url, elastic_query
+        get url, model.doctype, elastic_query
       end
 
       def explain(id, elastic_query)

data/lib/elastic_record/index/manage.rb

@@ -9,9 +9,7 @@ module ElasticRecord
 
       def create(index_name = new_index_name)
         connection.json_put "/#{index_name}", {
-          "mappings" => {
-            type => mapping
-          },
+          "mappings" => mapping_body,
           "settings" => settings
         }
         index_name
@@ -31,8 +29,8 @@ module ElasticRecord
         connection.head("/#{index_name}") == '200'
       end
 
-      def type_exists?(index_name = alias_name)
-        connection.head("/#{index_name}/#{type}") == '200'
+      def type_exists?(index_name = alias_name, type = model.doctype.name)
+        connection.head("/#{index_name}/_mapping/#{type}") == '200'
       end
 
       def deploy(index_name)
@@ -78,7 +76,7 @@ module ElasticRecord
       end
 
       def all_names
-        connection.json_get("/#{alias_name}/_mapping/#{type}/").keys
+        connection.json_get("/#{alias_name}/_mapping/#{model.doctype.name}/").keys
       rescue
         # TODO: In ES 1.4, this returns empty rather than a 404
         []