elasticsearch-model-extensions 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cc88b24aa703c53b9c35f7f0dfc72c291299d861
-  data.tar.gz: 8ee00b4d40f76173ec408ea6068d4a697a3fb9b0
+  metadata.gz: fdacb9b2813cbdf61813171273ec16c3626a40cd
+  data.tar.gz: a47ded66adef66a3ac2cba15e802ee5443ed50f1
 SHA512:
-  metadata.gz: 181f6efceba36b6a0b032f06a9e612e51d8a371f3c88cc780b641262b7a59149ebbf2dd1528c6bf4f864823c7e6bd6773a4a4f9fada2eccc6e5d7e4248c364d5
-  data.tar.gz: 139e8c22de2c2be86dc885b1a54552f940aac3725ec88bc7d6a137efd50cd253c890f37268a2da7e78ddcd79d75b4f8972855cffa674fb73a17361bbdb074aca
+  metadata.gz: d2373b26f5f54d52b89ad22270cf7e076cafd31eea7f69042f0cf695fda8bfb3676d89be631c6f649819dbe17698ee8d7053e55dc1f263b143b8a9cd72333bec
+  data.tar.gz: b354472253b3a6b61501aaecf67afc31cd69e99a6b3ce4b6e1651153c7ab09b2e4780444c98da1a944351a4171fe02b21e3a8967d95a07a39674ddb95381ed60

data/.travis.yml

@@ -4,6 +4,9 @@ rvm:
 - 2.1.2
 - 2.1.3
 - ruby-head
+gemfile:
+- Gemfile
+- gemfiles/rails41.gemfile
 matrix:
   allow_failures:
   - rvm: ruby-head

data/Gemfile

@@ -1,12 +1,13 @@
 source 'https://rubygems.org'
 
 # Specify your gem's dependencies in elasticsearch-model-extensions.gemspec
-gemspec
+gemspec path: File.dirname(__FILE__)
 
 group :test do
   gem 'rspec', '~> 3.1.0'
   gem 'database_cleaner'
   gem 'coveralls', require: false
+  gem 'parallel'
 end
 
 group :test, :development do

data/README.md

@@ -34,6 +34,11 @@ With Elasticsearch installed, you can run examples configured with an ES instanc
     (A bunch of log output here)
     irb(main):001:0> Article.search('Comment1')
 
+To run the same example with Rails 4.1.x:
+
+    $ BUNDLE_GEMFILE=gemfiles/rails41.gemfile bundle exec irb -I spec -r example/articles_with_comments
+
+
 ## Contributing
 
 1. Fork it ( https://github.com/[my-github-username]/elasticsearch-model-extensions/fork )

data/gemfiles/rails41.gemfile

@@ -0,0 +1,11 @@
+eval_gemfile File.expand_path(File.join(File.dirname(__FILE__), '../Gemfile'))
+
+ignored_gems = %w(activerecord)
+
+dependencies.delete_if do |g|
+  ignored_gems.include?(g.name)
+end
+
+group :test, :development do
+  gem 'activerecord', '~> 4.1.4'
+end

data/gemfiles/rails41.gemfile.lock

@@ -0,0 +1,109 @@
+PATH
+  remote: /Users/mumoshu/Repositories/elasticsearch-model-extensions
+  specs:
+    elasticsearch-model-extensions (0.2.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (4.1.8)
+      activesupport (= 4.1.8)
+      builder (~> 3.1)
+    activerecord (4.1.8)
+      activemodel (= 4.1.8)
+      activesupport (= 4.1.8)
+      arel (~> 5.0.0)
+    activesupport (4.1.8)
+      i18n (~> 0.6, >= 0.6.9)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.1)
+      tzinfo (~> 1.1)
+    ansi (1.4.3)
+    arel (5.0.1.20140414130214)
+    builder (3.2.2)
+    coveralls (0.7.2)
+      multi_json (~> 1.3)
+      rest-client (= 1.6.7)
+      simplecov (>= 0.7)
+      term-ansicolor (= 1.2.2)
+      thor (= 0.18.1)
+    database_cleaner (1.3.0)
+    delayed_job (4.0.6)
+      activesupport (>= 3.0, < 5.0)
+    delayed_job_active_record (4.0.3)
+      activerecord (>= 3.0, < 5.0)
+      delayed_job (>= 3.0, < 4.1)
+    diff-lcs (1.2.5)
+    docile (1.1.5)
+    elasticsearch (1.0.6)
+      elasticsearch-api (= 1.0.6)
+      elasticsearch-transport (= 1.0.6)
+    elasticsearch-api (1.0.6)
+      multi_json
+    elasticsearch-extensions (0.0.17)
+      ansi
+      ruby-prof
+    elasticsearch-model (0.1.6)
+      activesupport (> 3)
+      elasticsearch (> 0.4)
+      hashie
+    elasticsearch-transport (1.0.6)
+      faraday
+      multi_json
+    faraday (0.9.0)
+      multipart-post (>= 1.2, < 3)
+    hashie (3.3.2)
+    i18n (0.7.0)
+    json (1.8.1)
+    mime-types (2.4.3)
+    minitest (5.5.0)
+    multi_json (1.10.1)
+    multipart-post (2.0.0)
+    parallel (1.3.3)
+    rake (10.4.2)
+    rest-client (1.6.7)
+      mime-types (>= 1.16)
+    rspec (3.1.0)
+      rspec-core (~> 3.1.0)
+      rspec-expectations (~> 3.1.0)
+      rspec-mocks (~> 3.1.0)
+    rspec-core (3.1.7)
+      rspec-support (~> 3.1.0)
+    rspec-expectations (3.1.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.1.0)
+    rspec-mocks (3.1.3)
+      rspec-support (~> 3.1.0)
+    rspec-support (3.1.2)
+    ruby-prof (0.15.2)
+    simplecov (0.9.1)
+      docile (~> 1.1.0)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.8.0)
+    simplecov-html (0.8.0)
+    sqlite3 (1.3.10)
+    term-ansicolor (1.2.2)
+      tins (~> 0.8)
+    thor (0.18.1)
+    thread_safe (0.3.4)
+    tins (0.13.2)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord (~> 4.1.4)
+  bundler (~> 1.7)
+  coveralls
+  database_cleaner
+  delayed_job_active_record (~> 4.0.1)
+  elasticsearch-extensions
+  elasticsearch-model
+  elasticsearch-model-extensions!
+  parallel
+  rake (~> 10.0)
+  rspec (~> 3.1.0)
+  sqlite3

data/lib/elasticsearch/model/extensions/association_path_finding/association_path_finder.rb

@@ -0,0 +1,19 @@
+require_relative 'mapping_node'
+
+module Elasticsearch
+  module Model
+    module Extensions
+      module AssociationPathFinding
+        class AssociationPathFinder
+          def find_path(from:, to:)
+            MappingNode.
+              from_class(from).
+              breadth_first_search { |e| e.destination.relates_to_class?(to) }.
+              first
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+require_relative 'shortest_path'
+
+module Elasticsearch
+  module Model
+    module Extensions
+      module AssociationPathFinding
+        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
+end

data/lib/elasticsearch/model/extensions/association_path_finding/shortest_path.rb

@@ -0,0 +1,108 @@
+module Elasticsearch
+  module Model
+    module Extensions
+      module AssociationPathFinding
+        class ShortestPath
+          MAX_DEPTH = 5
+
+          class Node
+            include Enumerable
+
+            def each(&block)
+              raise "A required method #{self.class}#each is not implemented."
+            end
+
+            def name
+              raise "A required method #{self.class}#name is not implemented."
+            end
+
+            def each_with_name(&block)
+              iterator = each.lazy.map do |edge|
+                [edge, edge.name]
+              end
+
+              if block.nil?
+                iterator
+              else
+                iterator.each(&block)
+              end
+            end
+
+            def hash
+              name.hash
+            end
+
+            def eql?(other)
+              self.class == other.class && (name.eql? other.name)
+            end
+
+            def edge_class
+              ShortestPath::Edge
+            end
+
+            def breadth_first_search(&block)
+              ShortestPath.breadth_first_search self, &block
+            end
+          end
+
+          class Edge
+            def initialize(name:, destination:)
+              @name = name
+              @destination = destination
+            end
+
+            def name
+              @name
+            end
+
+            def destination
+              @destination
+            end
+          end
+
+          module ClassMethods
+            def breadth_first_search(node, &block)
+              original_paths = node.each.map { |e| [e] }
+              paths = original_paths
+
+              depth = 0
+
+              loop {
+                a = paths.select { |p|
+                  if block.call(p.last)
+                    p
+                  end
+                }
+
+                return a if a.size != 0
+                raise RuntimeError, 'Maximum depth exceeded while calculating the shortest path' if depth >= Elasticsearch::Model::Extensions::ShortestPath::MAX_DEPTH
+
+                paths = paths.flat_map { |p|
+                  p.last.destination.each.map { |e|
+                    p + [e]
+                  }
+                }
+
+                depth += 1
+              }
+            end
+
+            def depth_first_search(node, &block)
+              node.each.select do |edge|
+                if block.call(edge)
+                  [[edge]]
+                else
+                  depth_first_search(edge.destination, &block).map do |path|
+                    [edge] + path
+                  end
+                end
+              end
+            end
+          end
+
+          extend ClassMethods
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,5 @@
 require_relative 'mapping_reflection'
+require_relative 'batch_updating/batch_updater'
 
 module Elasticsearch
   module Model
@@ -27,29 +28,15 @@ module Elasticsearch
         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
+          def __batch_updater__
+            @__batch_updater__ ||= ::Elasticsearch::Model::Extensions::BatchUpdating::BatchUpdater.new(self)
           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)
+            Parallel.each(__batch_updater__.split_ids_into(parallelism, min: min, max: max), in_processes: parallelism) do |id_range|
+              __batch_updater__.reconnect!
               klass.for_indexing.update_index_for_ids_in_range id_range, index: index, type: type, batch_size: batch_size
             end
 
@@ -74,36 +61,6 @@ module Elasticsearch
 
             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
-                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
         end
 
         module Association
@@ -123,16 +80,16 @@ module Elasticsearch
 
               conditions = record_id.gteq(from).and(record_id.lteq(to))
 
-              update_index_in_batches(batch_size: batch_size, index: index, type: type, conditions: conditions)
+              where(conditions).update_index_in_batches(batch_size: batch_size, index: index, type: type)
             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)
+            def update_index_in_batches(batch_size: DEFAULT_BATCH_SIZE, index: nil, type: nil)
+              find_in_batches(batch_size: batch_size) do |records|
+                __batch_updater__.update_index_in_batch(records, index: index, type: type)
               end
             end
           end