elasticsearch-model-extensions 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 91592da0d915c072cdaa65f2a805d94edab055e9
+  data.tar.gz: c9b8c32829eb32ca15d9971fe5dc967b2947b740
+SHA512:
+  metadata.gz: 0900f09019a5451ba338c7b619a3ad23cda124624f9aa902865289f27164c6f7245d2235b77b9ffce6beda2a927cc02e7a26426d2235339bd6ddefb3a0fa44bb
+  data.tar.gz: 523697b1b2836f2033941899db7077edc6ea2c7302b8d317f54745d3339e86bf3286e96065ae9155f1522e1c95ca4d5e095997954b94b7c86e337def1686a54b

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in elasticsearch-model-extensions.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Yusuke KUOKA
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,31 @@
+# Elasticsearch::Model::Extensions
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'elasticsearch-model-extensions'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install elasticsearch-model-extensions
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/elasticsearch-model-extensions/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/elasticsearch-model-extensions.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'elasticsearch/model/extensions/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "elasticsearch-model-extensions"
+  spec.version       = Elasticsearch::Model::Extensions::VERSION
+  spec.authors       = ["Yusuke KUOKA"]
+  spec.email         = ["yusuke.kuoka@crowdworks.co.jp"]
+  spec.summary       = %q{A set of extensions for elasticsearch-model which aims to ease the burden of things like re-indexing, verbose/complex mapping that you may face once you started using elasticsearch seriously.}
+  spec.description   = %q{A set of extensions for elasticsearch-model which aims to ease the burden of things like re-indexing, verbose/complex mapping.}
+  spec.homepage      = "https://github.com/crowdworks/elasticsearch-model-extensions"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

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

@@ -0,0 +1,139 @@
+require_relative 'mapping_reflection'
+
+module Elasticsearch
+  module Model
+    module Extensions
+      module BatchUpdating
+        DEFAULT_BATCH_SIZE = 100
+
+        def self.included(klass)
+          klass.extend ClassMethods
+
+          unless klass.respond_to? :with_indexed_tables_included
+            class << klass
+              def with_indexed_tables_included
+                raise "#{self}.with_indexed_tables_included is not implemented."
+              end
+            end
+          end
+
+          unless klass.respond_to? :elasticsearch_hosts
+            class << klass
+              def elasticsearch_hosts
+                raise "#{self}.elasticsearch_hosts is not implemented."
+              end
+            end
+          end
+        end
+
+        module ClassMethods
+          def split_ids_into(chunk_num, min:nil, max:nil)
+            min ||= minimum(:id)
+            max ||= 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
+
+          def update_index_in_parallel(parallelism:, index: nil, type: nil, min: nil, max: nil, batch_size:DEFAULT_BATCH_SIZE)
+            klass = self
+
+            Parallel.each(klass.split_ids_into(parallelism, min: min, max: max), in_processes: parallelism) do |id_range|
+              @rdb_reconnected ||= klass.connection.reconnect! || true
+              @elasticsearch_reconnected ||= klass.__elasticsearch__.client = Elasticsearch::Client.new(host: klass.elasticsearch_hosts)
+              klass.for_indexing.update_index_for_ids_in_range id_range, index: index, type: type, batch_size: batch_size
+            end
+
+            klass.connection.reconnect!
+          end
+
+          def for_indexing
+            for_batch_indexing
+          end
+
+          def for_batch_indexing
+            with_indexed_tables_included.extending(::Elasticsearch::Model::Extensions::BatchUpdating::Association::Extension)
+          end
+
+          # @param [Fixnum] batch_size
+          def update_index_in_batches(batch_size: DEFAULT_BATCH_SIZE, where: nil, index: nil, type: nil)
+            records_in_scope = if where.nil?
+                                 for_batch_indexing
+                               else
+                                 for_batch_indexing.where(where)
+                               end
+
+            records_in_scope.update_index_in_batches(batch_size: batch_size, index: index, type: type)
+          end
+
+          # @param [Array] records
+          def update_index_in_batch(records, index: nil, type: nil, client: nil)
+            klass = self
+
+            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
+                Rails.logger.warn "One or more error(s) occurred while updating the index #{records} for the type #{type}\n#{JSON.pretty_generate(response)}"
+              end
+            else
+              records.each do |r|
+                client.index index: index, type: type, id: r.id, body: r.as_indexed_json
+              end
+            end
+          end
+        end
+
+        module Association
+          module Extension
+            def update_index_in_chunks(num, index: index)
+              klass.split_ids_into(num).map do |r|
+                if block_given?
+                  yield -> { update_index_for_ids_in_range(r, index: index) }
+                else
+                  update_index_for_ids_in_range(r, index: index)
+                end
+              end
+            end
+
+            def update_index_for_ids_from(from, to:, index: nil, type: nil, batch_size: DEFAULT_BATCH_SIZE)
+              record_id = arel_table[:id]
+
+              conditions = record_id.gteq(from).and(record_id.lteq(to))
+
+              update_index_in_batches(batch_size: batch_size, index: index, type: type, conditions: conditions)
+            end
+
+            def update_index_for_ids_in_range(range, index: nil, type: nil, batch_size: DEFAULT_BATCH_SIZE)
+              update_index_for_ids_from(range.first, to: range.last, type: type, index: index, batch_size: batch_size)
+            end
+
+            def update_index_in_batches(batch_size: DEFAULT_BATCH_SIZE, conditions:nil, index: nil, type: nil)
+              find_in_batches(batch_size: batch_size, conditions: conditions) do |records|
+                klass.update_index_in_batch(records, index: index, type: type)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+require_relative 'configuration'
+
+module Elasticsearch
+  module Model
+    module Extensions
+      class Callback
+        # @param [Configuration] config
+        def initialize(config)
+          @config = config
+        end
+
+        def config
+          @config
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+module Elasticsearch
+  module Model
+    module Extensions
+      class Configuration
+        attr_reader :delayed
+
+        def initialize(active_record_class, parent_class: parent_class, delayed:, if: -> r { true }, records_to_update_documents: nil)
+          @delayed = @delayed
+
+          @active_record_class = active_record_class
+          @parent_class = parent_class
+          @if = binding.local_variable_get(:if)
+          @records_to_update_documents = records_to_update_documents
+        end
+
+        def to_hash
+          @cached_hash ||= build_hash
+        end
+
+        def field_to_update
+          to_hash[:field_to_update]
+        end
+
+        def only_if
+          to_hash[:only_if]
+        end
+
+        def records_to_update_documents
+          to_hash[:records_to_update_documents]
+        end
+
+        def optionally_delayed
+          -> t { delayed ? t.delay : t }
+        end
+
+        private
+
+        def build_hash
+          child_class = @active_record_class
+
+          path = child_class.path_from(@parent_class)
+          parent_to_child_path = path.map(&:name)
+
+          # a has_a b has_a cという関係のとき、cが更新されたらaのフィールドbをupdateする必要がある。
+          # そのとき、
+          # 親aから子cへのパスが[:b, :c]だったら、bだけをupdateすればよいので
+          field_to_update = parent_to_child_path.first
+
+          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))
+
+          custom_if = @if
+
+          update_strategy_class = Elasticsearch::Model::Extensions::OuterDocumentUpdating.strategy_for child_class
+          update_strategy = update_strategy_class.new(from: @parent_class, to: child_class)
+
+          only_if, records_to_update_documents = update_strategy.apply
+
+          {
+            field_to_update: field_to_update,
+            records_to_update_documents: @records_to_update_documents || records_to_update_documents,
+            only_if: -> r { custom_if.call(r) && only_if.call(r) }
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module Elasticsearch
+  module Model
+    module Extensions
+      module DependencyTracking
+        def self.included(base)
+          base.extend ClassMethods
+
+          base.class_eval do
+            before_validation do
+              self.class.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
+
+          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
+
+          def has_dependent_fields?(field)
+            const_get('DEPENDENT_CUSTOM_ATTRIBUTES').any? do |from, to|
+              from.include? field.to_s
+            end
+          end
+
+          def has_association_named?(table_name)
+            reflect_on_all_associations.any? { |a| a.name == table_name }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require_relative 'callback'
+
+module Elasticsearch
+  module Model
+    module Extensions
+      class DestroyCallback < Callback
+        def after_commit(record)
+          field_to_update = config.field_to_update
+          records_to_update_documents = config.records_to_update_documents
+          optionally_delayed = config.optionally_delayed
+          only_if = config.only_if
+
+          record.instance_eval do
+            return unless only_if.call(self)
+
+            target = records_to_update_documents.call(self)
+
+            if target.respond_to? :each
+              target.map(&:reload).map(&optionally_delayed).each do |t|
+                t.partially_update_document(field_to_update)
+              end
+            else
+              optionally_delayed.call(target.reload).partially_update_document(field_to_update)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+module Elasticsearch
+  module Model
+    module Extensions
+      module IndexOperations
+        def self.included(klass)
+          klass.extend ClassMethods
+        end
+
+        module ClassMethods
+          def create_index(name:, force:true)
+            klass = self
+
+            client = __elasticsearch__.client
+
+            indices = client.indices
+
+            if indices.exists(index: name) && force
+              indices.delete index: name
+            end
+
+            indices.create index: name, body: { settings: klass.settings.to_hash, mappings: klass.mappings.to_hash }
+          end
+
+          def delete_index(name:)
+            client = __elasticsearch__.client
+
+            indices = client.indices
+
+            indices.delete index: name
+          end
+
+          def delete_alias(name: nil)
+            name ||= index_name
+
+            client = __elasticsearch__.client
+
+            indices = client.indices
+
+            indices_aliased = indices.get_alias(name: name).keys
+
+            indices_aliased.each do |index|
+              indices.delete name: name, index: index
+            end
+          end
+
+          def prepare_alias(name:, force: true)
+            client = __elasticsearch__.client
+
+            indices = client.indices
+
+            if indices.exists(index: name) && force
+              indices.delete index: name
+            end
+
+            unless indices.exists_alias(name: name)
+              aliased_index_name = "#{index_name}_#{Time.now.to_i}"
+
+              create_index(name: aliased_index_name, force: force)
+
+              indices.put_alias index: aliased_index_name, name: name
+            end
+          end
+
+          def replace_index_for_alias(name:, to:)
+            client = __elasticsearch__.client
+
+            indices = client.indices
+
+            if indices.exists_alias name: name
+              old_index_name = indices.get_alias(name: name).keys.first
+
+              indices.update_aliases body: {
+                actions: [
+                  { remove: { index: old_index_name, alias: name } },
+                  { add: { index: to, alias: name } }
+                ]
+              }
+            else
+              indices.put_alias index: to, name: name
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+require 'shortest_path'
+
+module Elasticsearch
+  module Model
+    module Extensions
+      class MappingNode < ShortestPath::Node
+        def self.from_class(klass)
+          name = klass.document_type.intern
+
+          new(klass: klass, name: name, mapping: klass.mapping.to_hash[name])
+        end
+
+        def initialize(klass:, name:, mapping:, through_class:nil)
+          @klass = klass
+          @name = name
+          @mapping = mapping
+          @through_class = through_class
+        end
+
+        def name
+          @name
+        end
+
+        def relates_to_class?(klass)
+          @klass == klass || @through_class == klass
+        end
+
+        def klass
+          @klass
+        end
+
+        def through_class
+          @through_class
+        end
+
+        def each(&block)
+          associations = @klass.reflect_on_all_associations
+
+          props = @mapping[:properties]
+          fields = props.keys
+
+          edges = fields.map { |f|
+            a = associations.find { |a| a.name == f }
+
+            if a && a.options[:polymorphic] != true
+              through_class = if a.options[:through]
+                                a.options[:through].to_s.classify.constantize
+                              end
+
+              dest = MappingNode.new(klass: a.class_name.constantize, name: f.to_s.pluralize.intern, mapping: props[f], through_class: through_class)
+
+              edge_class.new(name: f, destination: dest)
+            end
+          }.reject(&:nil?)
+
+          if block.nil?
+            edges
+          else
+            edges.each(&block)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+module Elasticsearch
+  module Model
+    module Extensions
+      module MappingReflection
+        def self.included(base)
+          base.extend ClassMethods
+        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
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,175 @@
+require_relative 'mapping_node'
+require_relative 'update_callback'
+require_relative 'destroy_callback'
+
+module Elasticsearch
+  module Model
+    module Extensions
+      module OuterDocumentUpdating
+        def self.included(klass)
+          klass.extend ClassMethods
+        end
+
+        def index_update_required?
+          (previous_changes.keys & self.class.nested_object_fields).size > 0 ||
+            (previous_changes.size > 0 && self.class.has_dependent_fields?)
+        end
+
+        class Update
+          def initialize(from:, to:)
+            @parent_class = from
+            @child_class = to
+          end
+
+          class Default < Update
+            def self.applicable_to?(klass)
+              true
+            end
+
+            def apply
+              parent_class = @parent_class
+              child_class = @child_class
+
+              only_if = -> r { true }
+
+              puts "Parent: #{@parent_class.name}"
+              puts "Child: #{@child_class.name}"
+
+              # 子cから親aへのパスが[:b, :a]のようなパスだったら、c.b.aのようにaを辿れるはずなので
+              records_to_update_documents = begin
+                child_to_parent_path = Elasticsearch::Model::Extensions::OuterDocumentUpdating::ClassMethods::AssociationTraversal.shortest_path(from: child_class, to: parent_class)
+
+                -> updated_record { child_to_parent_path.inject(updated_record) { |d, parent_association| d.send parent_association } }
+              end
+
+              [only_if, records_to_update_documents]
+            end
+          end
+
+          # Configures callbacks to update the index of the model associated through a polymorphic association
+          # @see http://guides.rubyonrails.org/association_basics.html#polymorphic-associations
+          class ThroughPolymorphicAssociation < Update
+            def self.applicable_to?(klass)
+              !! polymorphic_assoc_for(klass)
+            end
+
+            def self.polymorphic_assoc_for(klass)
+              klass.reflect_on_all_associations.find { |a|
+                a.macro == :belongs_to && a.options[:polymorphic]
+              }
+            end
+
+            def apply
+              parent_class = @parent_class
+              child_class = @child_class
+
+              polymorphic_assoc = self.class.polymorphic_assoc_for(child_class)
+              polymorphic_assoc_name = polymorphic_assoc.name
+
+              parent_type_attribute_name = :"#{polymorphic_assoc_name}_type"
+              parent_id_attribute_name = :"#{polymorphic_assoc_name}_id"
+
+              only_if = -> updated_record {
+                updated_record.send(parent_type_attribute_name) == parent_class.name
+              }
+
+              records_to_update_documents = -> updated_record {
+                parent_class.where(id: updated_record.send(parent_id_attribute_name))
+              }
+
+              [only_if, records_to_update_documents]
+            end
+          end
+        end
+
+        STRATEGIES = [Update::ThroughPolymorphicAssociation, Update::Default]
+
+        def self.strategy_for(klass)
+          STRATEGIES.find { |s| s.applicable_to? klass }
+        end
+
+        module ClassMethods
+          def nested_object_fields
+            @nested_object_fields
+          end
+
+          def has_dependent_fields?
+            @has_dependent_fields
+          end
+
+          def path_from(from)
+            Elasticsearch::Model::Extensions::MappingNode.
+              from_class(from).
+              breadth_first_search { |e| e.destination.relates_to_class?(self) }.
+              first
+          end
+
+          def initialize_active_record!(active_record_class, parent_class: parent_class, delayed:, if: -> r { true }, records_to_update_documents: nil)
+            config = Elasticsearch::Model::Extensions::Configuration.new(active_record_class, parent_class: parent_class, delayed: delayed, if: binding.local_variable_get(:if), records_to_update_documents: records_to_update_documents)
+
+            active_record_class.after_commit Elasticsearch::Model::Extensions::UpdateCallback.new(config)
+            active_record_class.after_commit Elasticsearch::Model::Extensions::DestroyCallback.new(config), on: :destroy
+          end
+
+          def partially_updates_document_of(parent_class, delayed:, if: -> r { true }, records_to_update_documents: nil)
+            initialize_active_record!(
+              self,
+              parent_class: parent_class,
+              delayed: delayed,
+              if: binding.local_variable_get(:if),
+              records_to_update_documents: records_to_update_documents
+            )
+          end
+
+          module AssociationTraversal
+            class << self
+              def shortest_path(from:, to:, visited_classes: nil)
+                visited_classes ||= []
+                current_class = from
+                destination_class = to
+
+                paths = []
+
+                current_class.reflect_on_all_associations.each do |association_found|
+
+                  next if association_found.options[:polymorphic]
+
+                  key = association_found.name
+
+                  begin
+                    klass = association_found.class_name.constantize
+                  rescue => e
+                    warn "#{e.message} while reflecting #{current_class.name}\##{key}\n#{e.backtrace[0...1].join("\n")}"
+                    next
+                  end
+
+                  next if visited_classes.include? association_found.class_name
+
+                  if klass == destination_class
+                    return [key]
+                  else
+                    suffix_found = shortest_path(
+                      from: klass,
+                      to: destination_class,
+                      visited_classes: visited_classes.append(association_found.class_name)
+                    )
+
+                    if suffix_found
+                      paths << [key] + suffix_found
+                    end
+                  end
+                end
+
+                if paths.empty?
+                  nil
+                else
+                  paths.min_by { |path| path.size }
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,148 @@
+module Elasticsearch
+  module Model
+    module Extensions
+      module PartialUpdating
+        def self.included(klass)
+          klass.extend ClassMethods
+        end
+
+        def self.build_as_json_options(klass:, props: )
+          indexed_attributes = props.keys
+          associations = klass.reflect_on_all_associations.select { |a| %i| has_one has_many belongs_to |.include? a.macro }
+          association_names = associations.map(&:name)
+          persisted_attributes = klass.attribute_names.map(&:intern)
+
+          nested_attributes = indexed_attributes & association_names
+          method_attributes = indexed_attributes - persisted_attributes - nested_attributes
+          only_attributes = indexed_attributes - nested_attributes
+
+          options = {}
+
+          if only_attributes.size > 1
+            options[:only] = only_attributes
+          elsif only_attributes.size == 1
+            options[:only] = only_attributes.first
+          end
+
+          if method_attributes.size > 1
+            options[:methods] = method_attributes
+          elsif method_attributes.size == 1
+            options[:methods] = method_attributes.first
+          end
+
+          nested_attributes.each do |n|
+            a = associations.find { |a| a.name == n.intern }
+            nested_klass = a.class_name.constantize
+            nested_prop = props[n]
+            if nested_prop.present?
+              options[:include] ||= {}
+              options[:include][n] = build_as_json_options(
+                klass: nested_klass,
+                props: nested_prop[:properties]
+              )
+            end
+          end
+
+          options
+        end
+
+        def as_indexed_json(options={})
+          as_json(options.merge(self.class.as_json_options))
+        end
+
+        # @param [Array<Symbol>] changed_attributes
+        # @param [Proc<Symbol, Hash>] json_options
+        def build_partial_document_for_update(*changed_attributes, json_options: nil)
+          changes = {}
+
+          json_options ||= -> field { self.class.partial_as_json_options(field) || {} }
+
+          self.class.each_field_to_update_according_to_changed_fields(changed_attributes) do |field_to_update|
+            options = json_options.call field_to_update
+
+            json = __send__(:"#{field_to_update}").as_json(options)
+
+            changes[field_to_update] = json
+          end
+
+          changes
+        end
+
+        def partially_update_document(*changed_attributes)
+          if changed_attributes.empty?
+            __elasticsearch__.index_document
+          else
+            begin
+              partial_document = build_partial_document_for_update(*changed_attributes)
+            rescue => e
+              Rails.logger.error "Error in #partially_update_document: #{e.message}\n#{e.backtrace.join("\n")}"
+            end
+
+            update_document(partial_document)
+          end
+        end
+
+        # @param [Hash] partial_document
+        def update_document(partial_document)
+          klass = self.class
+
+          __elasticsearch__.client.update(
+            { index: klass.index_name,
+              type:  klass.document_type,
+              id:    self.id,
+              body:  { doc: partial_document } }
+          ) if partial_document.size > 0
+        end
+
+        module ClassMethods
+          def as_json_options
+            @as_json_options ||= Elasticsearch::Model::Extensions::PartialUpdating.build_as_json_options(
+              klass: self,
+              props: self.mappings.to_hash[self.document_type.intern][:properties]
+            )
+          end
+
+          def partial_as_json_options(field)
+            as_json_options[:include][field]
+          end
+
+          def each_field_to_update_according_to_changed_fields(changed_fields)
+            root_mapping_properties = mappings.to_hash[:"#{document_type}"][:properties]
+
+            changed_fields.each do |changed_field|
+              field_mapping = root_mapping_properties[:"#{changed_field}"]
+
+              next unless field_mapping
+
+              yield changed_field
+            end
+
+            each_dependent_attribute_for(changed_fields.map(&:to_s)) do |a|
+              a_sym = a.intern
+
+              yield a_sym
+            end
+          end
+
+          def fields_to_update_according_to_changed_fields(changed_fields)
+            fields = []
+            each_field_to_update_according_to_changed_fields changed_fields do |field_to_update|
+              fields << field_to_update
+            end
+            fields
+          end
+        end
+
+        module Callbacks
+          def self.included(base)
+            base.class_eval do
+              after_commit lambda { __elasticsearch__.index_document  },  on: :create
+              after_commit lambda { partially_update_document(*previous_changes.keys.map(&:intern)) },  on: :update, if: -> { previous_changes.size != 0 }
+              after_commit lambda { __elasticsearch__.delete_document },  on: :destroy
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require_relative 'callback'
+
+module Elasticsearch
+  module Model
+    module Extensions
+      class UpdateCallback < Callback
+        def after_commit(record)
+          field_to_update = config.field_to_update
+          records_to_update_documents = config.records_to_update_documents
+          optionally_delayed = config.optionally_delayed
+          only_if = config.only_if
+
+          record.instance_eval do
+            return unless only_if.call(self) && index_update_required?
+
+            target = records_to_update_documents.call(self)
+
+            if target.respond_to? :each
+              # `reload` required to ensure that the outer record is up-to-date with changes
+              # when `self` is an instance of a `through` model.
+              #
+              # Imagine the case where we have an association containing:
+              #
+              #   `article has_many comments through article_comments`
+              #
+              # and:
+              #
+              #   `article_comments belongs_to article`
+              #
+              # Here, `article_comment.article` may contain outdated `comments` because `article_comment.article`
+              # won't be notified with changes in `article_comments` thus won't reload `comments` automatically.
+              target.map(&:reload).map(&optionally_delayed).each do |t|
+                t.partially_update_document(field_to_update)
+              end
+            else
+              optionally_delayed.call(target.reload).partially_update_document(field_to_update)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+module Elasticsearch
+  module Model
+    module Extensions
+      VERSION = "0.0.1"
+    end
+  end
+end

data/lib/elasticsearch/model/extensions.rb

@@ -0,0 +1,9 @@
+require "elasticsearch/model/extensions/version"
+
+module Elasticsearch
+  module Model
+    module Extensions
+      # Your code goes here...
+    end
+  end
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: elasticsearch-model-extensions
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Yusuke KUOKA
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: A set of extensions for elasticsearch-model which aims to ease the burden
+  of things like re-indexing, verbose/complex mapping.
+email:
+- yusuke.kuoka@crowdworks.co.jp
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- elasticsearch-model-extensions.gemspec
+- lib/elasticsearch/model/extensions.rb
+- lib/elasticsearch/model/extensions/batch_updating.rb
+- lib/elasticsearch/model/extensions/callback.rb
+- lib/elasticsearch/model/extensions/configuration.rb
+- lib/elasticsearch/model/extensions/dependency_tracking.rb
+- lib/elasticsearch/model/extensions/destroy_callback.rb
+- lib/elasticsearch/model/extensions/index_operations.rb
+- lib/elasticsearch/model/extensions/mapping_node.rb
+- lib/elasticsearch/model/extensions/mapping_reflection.rb
+- lib/elasticsearch/model/extensions/outer_document_updating.rb
+- lib/elasticsearch/model/extensions/partial_updating.rb
+- lib/elasticsearch/model/extensions/update_callback.rb
+- lib/elasticsearch/model/extensions/version.rb
+homepage: https://github.com/crowdworks/elasticsearch-model-extensions
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A set of extensions for elasticsearch-model which aims to ease the burden
+  of things like re-indexing, verbose/complex mapping that you may face once you started
+  using elasticsearch seriously.
+test_files: []