elasticsearch-model 6.0.0.pre → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 42c06d477404fd7b991c3af477e595f2e9ec662167cf264745ab43dff91d5e19
-  data.tar.gz: 58c05971c219d2cd14a0c91acd1675d20699e55f4944afc5a71d10acb60d3aaa
+  metadata.gz: 726d16096fd6ca31266bab9b42c4f878cba6942eada1649de7fbf946af2575f0
+  data.tar.gz: 8ce1faffcdda9dae38ff2beddab31f0b161853c4fd9919b699cdb5e5a27f2baa
 SHA512:
-  metadata.gz: 5d2b3ffc337dd8083cd4dcb6ea74555add7f427fbd7bf16734d76e46d0e4ad110f1c4f581ec1a23bb6dbb7540c131a9d08b659704e4c796ffa06d0ccc6474a0c
-  data.tar.gz: 3162fbfac4daa561507929333235124f99828c4c845f1bfbe19e18c853b06a8d2210559dc44de93184524e2fe2c09b5e96e7c6186691c2121339a7e8923ff94d
+  metadata.gz: 63904bd61ec508918ee8a0d6cbe7cd089dc0b6df7c6f4d8ea1fef7538b2aea3a88962724e6a5fc486f5ec10146350e4176655b3fbeec868a66b6b3e00e767307
+  data.tar.gz: 36fccab94cf1f3cdfa599ad0a6d74cecc1b503c80da296e73381f3b3f2130244d57a9b51fabaff5e624e7f0955442e3b0e67d7006b6b94f705fdc4249252ac12

data/lib/elasticsearch/model/adapters/active_record.rb

@@ -56,7 +56,10 @@ module Elasticsearch
             # Redefine the `to_a` method to the original one
             #
             sql_records.instance_exec do
-              define_singleton_method(:to_a) do
+              ar_records_method_name = :to_a
+              ar_records_method_name = :records if defined?(::ActiveRecord) && ::ActiveRecord::VERSION::MAJOR >= 5
+
+              define_singleton_method(ar_records_method_name) do
                 if defined?(::ActiveRecord) && ::ActiveRecord::VERSION::MAJOR >= 4
                   self.load
                 else

data/lib/elasticsearch/model/adapters/mongoid.rb

@@ -63,10 +63,17 @@ module Elasticsearch
           # @see https://github.com/karmi/retire/pull/724
           #
           def __find_in_batches(options={}, &block)
-            options[:batch_size] ||= 1_000
+            batch_size = options[:batch_size] || 1_000
+            query = options[:query]
+            named_scope = options[:scope]
+            preprocess = options[:preprocess]
+
+            scope = all
+            scope = scope.send(named_scope) if named_scope
+            scope = query.is_a?(Proc) ? scope.class_exec(&query) : scope.where(query) if query
   
-            all.no_timeout.each_slice(options[:batch_size]) do |items|
-              yield items
+            scope.no_timeout.each_slice(batch_size) do |items|
+              yield (preprocess ? self.__send__(preprocess, items) : items)
             end
           end
 

data/lib/elasticsearch/model/importing.rb

@@ -130,7 +130,7 @@ module Elasticsearch
             errors +=  response['items'].select { |k, v| k.values.first['error'] }
           end
 
-          self.refresh_index! if refresh
+          self.refresh_index! index: target_index if refresh
 
           case return_value
             when 'errors'

data/lib/elasticsearch/model/response.rb

@@ -10,8 +10,7 @@ module Elasticsearch
       # Implements Enumerable and forwards its methods to the {#results} object.
       #
       class Response
-        attr_reader :klass, :search, :response,
-                    :took, :timed_out, :shards
+        attr_reader :klass, :search
 
         include Enumerable
 
@@ -27,9 +26,7 @@ module Elasticsearch
         # @return [Hash]
         #
         def response
-          @response ||= begin
-            HashWrapper.new(search.execute!)
-          end
+          @response ||= HashWrapper.new(search.execute!)
         end
 
         # Returns the collection of "hits" from Elasticsearch
@@ -51,31 +48,35 @@ module Elasticsearch
         # Returns the "took" time
         #
         def took
-          response['took']
+          raw_response['took']
         end
 
         # Returns whether the response timed out
         #
         def timed_out
-          response['timed_out']
+          raw_response['timed_out']
         end
 
         # Returns the statistics on shards
         #
         def shards
-          HashWrapper.new(response['_shards'])
+          @shards ||= HashWrapper.new(raw_response['_shards'])
         end
 
         # Returns a Hashie::Mash of the aggregations
         #
         def aggregations
-          Aggregations.new(response['aggregations'])
+          @aggregations ||= Aggregations.new(raw_response['aggregations'])
         end
 
         # Returns a Hashie::Mash of the suggestions
         #
         def suggestions
-          Suggestions.new(response['suggest'])
+          @suggestions ||= Suggestions.new(raw_response['suggest'])
+        end
+
+        def raw_response
+          @raw_response ||= search.execute!
         end
       end
     end

data/lib/elasticsearch/model/response/aggregations.rb

@@ -2,7 +2,7 @@ module Elasticsearch
   module Model
     module Response
 
-      class Aggregations < Hashie::Mash
+      class Aggregations < HashWrapper
         disable_warnings if respond_to?(:disable_warnings)
 
         def initialize(attributes={})

data/lib/elasticsearch/model/response/base.rb

@@ -4,7 +4,7 @@ module Elasticsearch
       # Common funtionality for classes in the {Elasticsearch::Model::Response} module
       #
       module Base
-        attr_reader :klass, :response
+        attr_reader :klass, :response, :raw_response
 
         # @param klass    [Class] The name of the model class
         # @param response [Hash]  The full response returned from Elasticsearch client
@@ -12,7 +12,8 @@ module Elasticsearch
         #
         def initialize(klass, response, options={})
           @klass     = klass
-          @response  = response
+          @raw_response = response
+          @response = response
         end
 
         # @abstract Implement this method in specific class

data/lib/elasticsearch/model/response/suggestions.rb

@@ -2,7 +2,7 @@ module Elasticsearch
   module Model
     module Response
 
-      class Suggestions < Hashie::Mash
+      class Suggestions < HashWrapper
         disable_warnings if respond_to?(:disable_warnings)
 
         def terms

data/lib/elasticsearch/model/version.rb

@@ -1,5 +1,5 @@
 module Elasticsearch
   module Model
-    VERSION = '6.0.0.pre'
+    VERSION = '6.0.0'
   end
 end

data/test/integration/active_record_basic_test.rb

@@ -223,8 +223,10 @@ module Elasticsearch
 
           if defined?(::ActiveRecord) && ::ActiveRecord::VERSION::MAJOR >= 4
             assert_equal 'Testing Coding', response.records.order(title: :desc).first.title
+            assert_equal 'Testing Coding', response.records.order(title: :desc)[0].title
           else
             assert_equal 'Testing Coding', response.records.order('title DESC').first.title
+            assert_equal 'Testing Coding', response.records.order('title DESC')[0].title
           end
         end
 

data/test/integration/active_record_import_test.rb

@@ -10,21 +10,22 @@ module Elasticsearch
   module Model
     class ActiveRecordImportIntegrationTest < Elasticsearch::Test::IntegrationTestCase
 
-      class ::ImportArticle < ActiveRecord::Base
-        include Elasticsearch::Model
+      context "ActiveRecord importing" do
+        setup do
+          Object.send(:remove_const, :ImportArticle) if defined?(ImportArticle)
+          class ::ImportArticle < ActiveRecord::Base
+            include Elasticsearch::Model
 
-        scope :popular, -> { where('views >= 50') }
+            scope :popular, -> { where('views >= 50') }
 
-        mapping do
-          indexes :title,      type: 'text'
-          indexes :views,      type: 'integer'
-          indexes :numeric,    type: 'integer'
-          indexes :created_at, type: 'date'
-        end
-      end
+            mapping do
+              indexes :title,      type: 'text'
+              indexes :views,      type: 'integer'
+              indexes :numeric,    type: 'integer'
+              indexes :created_at, type: 'date'
+            end
+          end
 
-      context "ActiveRecord importing" do
-        setup do
           ActiveRecord::Schema.define(:version => 1) do
             create_table :import_articles do |t|
               t.string   :title
@@ -110,6 +111,58 @@ module Elasticsearch
         end
       end
 
+      context "ActiveRecord importing when the model has a default scope" do
+
+        setup do
+          Object.send(:remove_const, :ImportArticle) if defined?(ImportArticle)
+          class ::ImportArticle < ActiveRecord::Base
+            include Elasticsearch::Model
+
+            default_scope { where('views >= 8') }
+
+            mapping do
+              indexes :title,      type: 'text'
+              indexes :views,      type: 'integer'
+              indexes :numeric,    type: 'integer'
+              indexes :created_at, type: 'date'
+            end
+          end
+
+          ActiveRecord::Schema.define(:version => 1) do
+            create_table :import_articles do |t|
+              t.string   :title
+              t.integer  :views
+              t.string   :numeric # For the sake of invalid data sent to Elasticsearch
+              t.datetime :created_at, :default => 'NOW()'
+            end
+          end
+
+          ImportArticle.delete_all
+          ImportArticle.__elasticsearch__.delete_index! force: true
+          ImportArticle.__elasticsearch__.create_index! force: true
+          ImportArticle.__elasticsearch__.client.cluster.health wait_for_status: 'yellow'
+
+          10.times { |i| ImportArticle.create! title: "Test #{i}", views: i }
+        end
+
+        should "import only documents from the default scope" do
+          assert_equal 2, ImportArticle.count
+
+          assert_equal 0, ImportArticle.import
+
+          ImportArticle.__elasticsearch__.refresh_index!
+          assert_equal 2, ImportArticle.search('*').results.total
+        end
+
+        should "import only documents from a specific query combined with the default scope" do
+          assert_equal 2, ImportArticle.count
+
+          assert_equal 0, ImportArticle.import(query: -> { where("title = 'Test 9'") })
+
+          ImportArticle.__elasticsearch__.refresh_index!
+          assert_equal 1, ImportArticle.search('*').results.total
+        end
+      end
     end
   end
 end

data/test/integration/mongoid_basic_test.rb

@@ -167,6 +167,70 @@ if MongoDB.available?
               assert response.results.any?, "Search has not returned results: #{response.to_a}"
             end
           end
+
+          context "importing when the model has a default scope" do
+            class ::MongoidArticleWithDefaultScope
+              include Mongoid::Document
+              include Elasticsearch::Model
+
+              default_scope -> { where(status: 'active') }
+
+              field :id, type: String
+              field :title, type: String
+              field :status, type: String, default: 'active'
+
+              attr_accessible :title if respond_to? :attr_accessible
+              attr_accessible :status if respond_to? :attr_accessible
+
+              settings index: { number_of_shards: 1, number_of_replicas: 0 } do
+                mapping do
+                  indexes :title,      type: 'text', analyzer: 'snowball'
+                  indexes :status,     type: 'text'
+                  indexes :created_at, type: 'date'
+                end
+              end
+
+              def as_indexed_json(options={})
+                as_json(except: [:id, :_id])
+              end
+            end
+
+            setup do
+              Elasticsearch::Model::Adapter.register \
+                Elasticsearch::Model::Adapter::Mongoid,
+                lambda { |klass| !!defined?(::Mongoid::Document) && klass.respond_to?(:ancestors) && klass.ancestors.include?(::Mongoid::Document) }
+
+              MongoidArticleWithDefaultScope.__elasticsearch__.create_index! force: true
+
+              MongoidArticleWithDefaultScope.delete_all
+
+              MongoidArticleWithDefaultScope.create! title: 'Test'
+              MongoidArticleWithDefaultScope.create! title: 'Testing Coding'
+              MongoidArticleWithDefaultScope.create! title: 'Coding'
+              MongoidArticleWithDefaultScope.create! title: 'Test legacy code', status: 'removed'
+
+              MongoidArticleWithDefaultScope.__elasticsearch__.refresh_index!
+              MongoidArticleWithDefaultScope.__elasticsearch__.client.cluster.health wait_for_status: 'yellow'
+            end
+
+            should "import only documents from the default scope" do
+              assert_equal 3, MongoidArticleWithDefaultScope.count
+
+              assert_equal 0, MongoidArticleWithDefaultScope.import
+
+              MongoidArticleWithDefaultScope.__elasticsearch__.refresh_index!
+              assert_equal 3, MongoidArticleWithDefaultScope.search('*').results.total
+            end
+
+            should "import only documents from a specific query combined with the default scope" do
+              assert_equal 3, MongoidArticleWithDefaultScope.count
+
+              assert_equal 0, MongoidArticleWithDefaultScope.import(query: -> { where(title: /^Test/) })
+
+              MongoidArticleWithDefaultScope.__elasticsearch__.refresh_index!
+              assert_equal 2, MongoidArticleWithDefaultScope.search('*').results.total
+            end
+          end
         end
 
       end

data/test/unit/adapter_mongoid_test.rb

@@ -98,7 +98,64 @@ class Elasticsearch::Model::AdapterMongoidTest < Test::Unit::TestCase
           assert_equal @transform.call(model), { index: { _id: "1", data: {} } }
         end
       end
-    end
 
+      should "limit the relation to a specific scope" do
+        relation = mock()
+        relation.stubs(:no_timeout).returns(relation)
+        relation.expects(:published).returns(relation)
+        relation.expects(:each_slice).returns([])
+        DummyClassForMongoid.expects(:all).returns(relation)
+
+        DummyClassForMongoid.__send__ :extend, Elasticsearch::Model::Adapter::Mongoid::Importing
+        DummyClassForMongoid.__find_in_batches(scope: :published) do; end
+      end
+
+      context "when limit the relation with proc" do
+        setup do
+          @query = Proc.new { where(color: "red") }
+        end
+        should "query with a specific criteria" do
+          relation = mock()
+          relation.stubs(:no_timeout).returns(relation)
+          relation.expects(:class_exec).returns(relation)
+          relation.expects(:each_slice).returns([])
+          DummyClassForMongoid.expects(:all).returns(relation)
+
+          DummyClassForMongoid.__find_in_batches(query: @query) do; end
+        end
+      end
+
+      context "when limit the relation with hash" do
+        setup do
+          @query = { color: "red" }
+        end
+        should "query with a specific criteria" do
+          relation = mock()
+          relation.stubs(:no_timeout).returns(relation)
+          relation.expects(:where).with(@query).returns(relation)
+          relation.expects(:each_slice).returns([])
+          DummyClassForMongoid.expects(:all).returns(relation)
+
+          DummyClassForMongoid.__find_in_batches(query: @query) do; end
+        end
+      end
+
+      should "preprocess the batch if option provided" do
+        class << DummyClassForMongoid
+          # Updates/transforms the batch while fetching it from the database
+          # (eg. with information from an external system)
+          #
+          def update_batch(batch)
+            batch.collect { |b| b.to_s + '!' }
+          end
+        end
+
+        DummyClassForMongoid.expects(:__find_in_batches).returns( [:a, :b] )
+
+        DummyClassForMongoid.__find_in_batches(preprocess: :update_batch) do |batch|
+          assert_same_elements ["a!", "b!"], batch
+        end
+      end
+    end
   end
 end

data/test/unit/importing_test.rb

@@ -146,6 +146,27 @@ class Elasticsearch::Model::ImportingTest < Test::Unit::TestCase
       end
     end
 
+    context "with the refresh option" do
+      should "refresh the index" do
+        DummyImportingModel.expects(:__find_in_batches).with do |options|
+          assert_equal 'bar', options[:foo]
+          assert_nil   options[:refresh]
+          true
+        end
+
+        DummyImportingModel.expects(:refresh_index!).with do |options|
+          assert_equal 'foo', options[:index]
+          true
+        end
+
+        DummyImportingModel.expects(:index_name).returns('foo')
+        DummyImportingModel.expects(:document_type).returns('foo')
+        DummyImportingModel.stubs(:index_exists?).returns(true)
+
+        DummyImportingModel.import refresh: true, foo: 'bar'
+      end
+    end
+
     should "allow passing a different index / type" do
       Elasticsearch::Model::Adapter.expects(:from_class)
                                    .with(DummyImportingModel)

data/test/unit/response_results_test.rb

@@ -27,5 +27,8 @@ class Elasticsearch::Model::ResultsTest < Test::Unit::TestCase
       assert_equal 'bar', @results.first.foo
     end
 
+    should "provide access to the raw response" do
+      assert_equal RESPONSE, @response.raw_response
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: elasticsearch-model
 version: !ruby/object:Gem::Version
-  version: 6.0.0.pre
+  version: 6.0.0
 platform: ruby
 authors:
 - Karel Minarik
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-08-13 00:00:00.000000000 Z
+date: 2018-09-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: elasticsearch
@@ -428,9 +428,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.7.7