elasticsearch-model-extensions 0.2.2 → 0.3.0

data/lib/elasticsearch/model/extensions/batch_updating/batch_updater.rb

@@ -0,0 +1,68 @@
+module Elasticsearch
+  module Model
+    module Extensions
+      module BatchUpdating
+        class BatchUpdater
+          def initialize(klass)
+            @klass = klass
+          end
+
+          def klass
+            @klass
+          end
+
+          def reconnect!
+            klass.connection.reconnect!
+            klass.__elasticsearch__.client = Elasticsearch::Client.new(host: klass.elasticsearch_hosts)
+          end
+
+          # @param [Array] records
+          def update_index_in_batch(records, index: nil, type: nil, client: nil)
+            client ||= klass.__elasticsearch__.client
+            index ||= klass.index_name
+            type ||= klass.document_type
+
+            if records.size > 1
+              response = client.bulk \
+                             index:   index,
+                             type:    type,
+                             body:    records.map { |r| { index: { _id: r.id, data: r.as_indexed_json } } }
+
+              one_or_more_errors_occurred = response["errors"]
+
+              if one_or_more_errors_occurred
+                if defined? ::Rails
+                  ::Rails.logger.warn "One or more error(s) occurred while updating the index #{records} for the type #{type}\n#{JSON.pretty_generate(response)}"
+                else
+                  warn "One or more error(s) occurred while updating the index #{records} for the type #{type}\n#{JSON.pretty_generate(response)}"
+                end
+              end
+            else
+              records.each do |r|
+                client.index index: index, type: type, id: r.id, body: r.as_indexed_json
+              end
+            end
+          end
+
+          def split_ids_into(chunk_num, min:nil, max:nil)
+            min ||= klass.minimum(:id)
+            max ||= klass.maximum(:id)
+            chunk_num.times.inject([]) do |r,i|
+              chunk_size = ((max-min+1)/chunk_num.to_f).ceil
+              first = chunk_size * i
+
+              last = if i == chunk_num - 1
+                       max
+                     else
+                       chunk_size * (i + 1) - 1
+                     end
+
+              r << (first..last)
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch/model/extensions/configuration.rb

@@ -1,3 +1,5 @@
+require_relative 'association_path_finding/association_path_finder'
+
 module Elasticsearch
   module Model
     module Extensions
@@ -39,13 +41,40 @@ module Elasticsearch
           to_hash[:block]
         end
 
+        # TODO Document what is in the Array
+        # @return [Array]
+        def nested_object_fields
+          @nested_object_fields
+        end
+
+        # @return [Boolean]
+        def has_dependent_fields?
+          @has_dependent_fields
+        end
+
+        # @param [ActiveRecord::Base] record the updated record we are unsure
+        # whether it must be also updated in elasticsearch or not
+        # @return [Boolean] true if we have to update the document for the record indexed in Elasticsearch
+        def index_update_required?(record)
+          previous_changes = record.previous_changes
+
+          defined?(record.index_update_required?) && record.index_update_required? ||
+            (previous_changes.keys & nested_object_fields).size > 0 ||
+            (previous_changes.size > 0 && has_dependent_fields?)
+        end
+
         private
 
+        # @return [Elasticsearch::Model::Extensions::AssociationPathFinding::AssociationPathFinder]
+        def association_path_finder
+          @association_path_finder ||= Elasticsearch::Model::Extensions::AssociationPathFinding::AssociationPathFinder.new
+        end
+
         def build_hash
           child_class = @active_record_class
 
           field_to_update = @field_to_update || begin
-            path = child_class.path_from(@parent_class)
+            path = association_path_finder.find_path(from: @parent_class, to: child_class)
             parent_to_child_path = path.map(&:name)
 
             # a has_a b has_a cという関係のとき、cが更新されたらaのフィールドbをupdateする必要がある。
@@ -58,10 +87,9 @@ module Elasticsearch
 
           puts "#{child_class.name} updates #{@parent_class.name}'s #{field_to_update}"
 
-          # TODO 勝手にインスタンスの状態を書き換えていて、相当いまいち。インスタンス外に出す。
-          child_class.instance_variable_set :@nested_object_fields, @parent_class.nested_object_fields_for(parent_to_child_path).map(&:to_s)
-          child_class.instance_variable_set :@has_dependent_fields, @parent_class.has_dependent_fields?(field_to_update) ||
-            (path.first.destination.through_class == child_class && @parent_class.has_association_named?(field_to_update) && @parent_class.has_document_field_named?(field_to_update))
+          @nested_object_fields = @parent_class.__mapping_reflector__.nested_object_fields_for(parent_to_child_path).map(&:to_s)
+          @has_dependent_fields = @parent_class.__dependency_tracker__.has_dependent_fields?(field_to_update) ||
+            (path.first.destination.through_class == child_class && @parent_class.__dependency_tracker__.has_association_named?(field_to_update) && @parent_class.__mapping_reflector__.has_document_field_named?(field_to_update))
 
           custom_if = @if
 

data/lib/elasticsearch/model/extensions/dependency_tracking.rb

@@ -1,3 +1,5 @@
+require_relative 'dependency_tracking/dependency_tracker'
+
 module Elasticsearch
   module Model
     module Extensions
@@ -5,40 +7,34 @@ module Elasticsearch
         def self.included(base)
           base.extend ClassMethods
 
+          dependency_tracker = DependencyTracker.new(base)
+
           base.class_eval do
             before_validation do
-              self.class.each_dependent_attribute_for(changes) do |a|
+              dependency_tracker.each_dependent_attribute_for(changes) do |a|
                 attribute_will_change! a
               end
             end
           end
-        end
 
-        module ClassMethods
-          def tracks_attributes_dependencies(dependencies)
-            const_set 'DEPENDENT_CUSTOM_ATTRIBUTES', dependencies.dup.freeze
-          end
+          # TODO Assert that @__dependency_tracker__ is nil to prevent users from facing terrible bugs
+          # trying to include this module multiple times
 
-          def each_dependent_attribute_for(changed_attributes)
-            const_get('DEPENDENT_CUSTOM_ATTRIBUTES').each do |attributes, dependent_attributes|
-              dependent_attributes.each do |dependent_attribute|
-                attributes.each do |a|
-                  yield dependent_attribute if changed_attributes.include? a
-                end
-              end
-            end
-          end
+          base.instance_variable_set :@__dependency_tracker__, dependency_tracker
+        end
 
-          def has_dependent_fields?(field)
-            const_get('DEPENDENT_CUSTOM_ATTRIBUTES').any? do |from, to|
-              from.include? field.to_s
-            end
+        module ClassMethods
+          # @return [DependencyTracker]
+          def __dependency_tracker__
+            @__dependency_tracker__
           end
 
-          def has_association_named?(table_name)
-            reflect_on_all_associations.any? { |a| a.name == table_name }
+          # @param [Hash[Array<String>, Array<String>]] dependencies
+          def tracks_attributes_dependencies(dependencies)
+            __dependency_tracker__.dependent_custom_attributes = dependencies.dup.freeze
           end
         end
+
       end
     end
   end

data/lib/elasticsearch/model/extensions/dependency_tracking/dependency_tracker.rb

@@ -0,0 +1,52 @@
+module Elasticsearch
+  module Model
+    module Extensions
+      module DependencyTracking
+        class DependencyTracker
+          def initialize(base)
+            @base = base
+          end
+
+          def base
+            @base
+          end
+
+          # @return [Hash<Array<String>, Array<String>>]
+          def dependent_custom_attributes
+            @dependent_custom_attributes
+          end
+
+          # @param [Hash<Array<String>, Array<String>>] new_value
+          def dependent_custom_attributes=(new_value)
+            @dependent_custom_attributes = new_value
+          end
+
+          # @param [Array<String>] changed_attributes
+          def each_dependent_attribute_for(changed_attributes)
+            dependent_custom_attributes.each do |attributes, dependent_attributes|
+              dependent_attributes.each do |dependent_attribute|
+                attributes.each do |a|
+                  yield dependent_attribute if changed_attributes.include? a
+                end
+              end
+            end
+          end
+
+          # @param [String|Symbol] field
+          def has_dependent_fields?(field)
+            dependent_custom_attributes.any? do |from, to|
+              from.include? field.to_s
+            end
+          end
+
+          # @param [Symbol] table_name
+          def has_association_named?(table_name)
+            # TODO call `reflect_on_all_associations` through a proxy object
+            base.reflect_on_all_associations.any? { |a| a.name == table_name }
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/elasticsearch/model/extensions/mapping_reflection.rb

@@ -1,94 +1,21 @@
+require_relative 'mapping_reflection/mapping_reflector'
+
 module Elasticsearch
   module Model
     module Extensions
       module MappingReflection
         def self.included(base)
           base.extend ClassMethods
+
+          base.instance_variable_set :@__mapping_reflector__, MappingReflector.new(base)
         end
 
         module ClassMethods
-          # @param [Class] destination_class
-          def path_in_mapping_to_class(destination_class, current_properties: nil, current_class: nil, visited_classes: nil)
-            current_properties ||= mappings.to_hash[:"#{self.document_type}"][:properties]
-            visited_classes ||= []
-            current_class ||= self
-
-            # Recurse only on associations
-            current_properties.keys.each do |key|
-              association_found = current_class.reflect_on_all_associations.find { |a| a.name == key }
-
-              next unless association_found
-              next if visited_classes.include? association_found.klass
-
-              if association_found.klass == destination_class
-                return [key]
-              else
-                suffix_found = path_in_mapping_to_class(
-                  destination_class,
-                  current_properties: current_properties[key][:properties],
-                  current_class: association_found.klass,
-                  visited_classes: visited_classes.dup.append(association_found.klass)
-                )
-
-                if suffix_found
-                  return [key] + suffix_found
-                end
-              end
-            end
-
-            nil
-          end
-
-          # @param [Symbol] nested_object_name
-          # @return [Array<Symbol>]
-          def path_in_mapping_to(nested_object_name, root_properties: nil)
-            root_properties ||= mappings.to_hash[:"#{self.document_type}"][:properties]
-
-            keys = root_properties.keys
-
-            keys.each do |key|
-              if key == nested_object_name
-                return [key]
-              end
-
-              next if root_properties[key][:type] != 'object'
-
-              suffix = path_in_mapping_to(nested_object_name, root_properties: root_properties[key][:properties])
-
-              if suffix.include? nested_object_name
-                return [key] + suffix
-              end
-            end
-            []
-          end
-
-          def document_field_named(field_name)
-            root_properties ||= mappings.to_hash[:"#{self.document_type}"][:properties]
-            root_properties[field_name]
-          end
-
-          def has_document_field_named?(field_name)
-            !! document_field_named(field_name)
-          end
-
-          # @param [Array<Symbol>] path
-          def nested_object_fields_for(path, root_properties: nil)
-            root_properties ||= mappings.to_hash[:"#{self.document_type}"][:properties]
-
-            keys = root_properties.keys
-
-            suffix, *postfix = path
-
-            return root_properties.keys if suffix.nil?
-
-            keys.each do |key|
-              if key == suffix
-                result = nested_object_fields_for(postfix, root_properties: root_properties[key][:properties])
-                return result if result
-              end
-            end
+          def __mapping_reflector__
+            @__mapping_reflector__
           end
         end
+
       end
     end
   end

data/lib/elasticsearch/model/extensions/mapping_reflection/mapping_reflector.rb

@@ -0,0 +1,107 @@
+module Elasticsearch
+  module Model
+    module Extensions
+      module MappingReflection
+        class MappingReflector
+          # @param [Class] base A class extending ActiveRecord::Base
+          def initialize(base)
+            @base = base
+          end
+
+          def base
+            @base
+          end
+
+          # @param [Class] destination_class
+          def path_in_mapping_to_class(destination_class, current_properties: nil, current_class: nil, visited_classes: nil)
+            current_properties ||= default_root_properties
+            visited_classes ||= []
+            current_class ||= self
+
+            # Recurse only on associations
+            current_properties.keys.each do |key|
+              association_found = current_class.reflect_on_all_associations.find { |a| a.name == key }
+
+              next unless association_found
+              next if visited_classes.include? association_found.klass
+
+              if association_found.klass == destination_class
+                return [key]
+              else
+                suffix_found = path_in_mapping_to_class(
+                  destination_class,
+                  current_properties: current_properties[key][:properties],
+                  current_class: association_found.klass,
+                  visited_classes: visited_classes.dup.append(association_found.klass)
+                )
+
+                if suffix_found
+                  return [key] + suffix_found
+                end
+              end
+            end
+
+            nil
+          end
+
+          # @param [Symbol] nested_object_name
+          # @return [Array<Symbol>]
+          def path_in_mapping_to(nested_object_name, root_properties: nil)
+            root_properties ||= default_root_properties
+
+            keys = root_properties.keys
+
+            keys.each do |key|
+              if key == nested_object_name
+                return [key]
+              end
+
+              next if root_properties[key][:type] != 'object'
+
+              suffix = path_in_mapping_to(nested_object_name, root_properties: root_properties[key][:properties])
+
+              if suffix.include? nested_object_name
+                return [key] + suffix
+              end
+            end
+            []
+          end
+
+          def has_document_field_named?(field_name)
+            !! document_field_named(field_name)
+          end
+
+          # @param [Array<Symbol>] path
+          def nested_object_fields_for(path, root_properties: nil)
+            root_properties ||= default_root_properties
+
+            keys = root_properties.keys
+
+            suffix, *postfix = path
+
+            return root_properties.keys if suffix.nil?
+
+            keys.each do |key|
+              if key == suffix
+                result = nested_object_fields_for(postfix, root_properties: root_properties[key][:properties])
+                return result if result
+              end
+            end
+          end
+
+          protected
+
+          def default_root_properties
+            base.mappings.to_hash[:"#{base.document_type}"][:properties]
+          end
+
+          def document_field_named(field_name)
+            root_properties ||= default_root_properties
+            root_properties[field_name]
+          end
+        end
+
+      end
+    end
+  end
+end