mongoid-elasticsearch 0.8.1 → 0.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4454671c943c79d336b9168b45489f56f15003e9
-  data.tar.gz: 85177ec0a09180202a6806dcdb109a97bf695372
+  metadata.gz: 6ab2a507244af6596bf9c5770642ff8e0437018d
+  data.tar.gz: 7cc3aa09ebab9cf69d471ddab31ec2f3f6e041ad
 SHA512:
-  metadata.gz: bf7055626940afc1012839353043a415248550a348db6f14dc3b22d1b83b8044a96da62c1a09c0c0f118221fda3d1fd41099325257800ae8883acc6628c61fcc
-  data.tar.gz: d9ccd3b35a09e281aa2059abda0a91c2fc80eb32c729ab019e35bef50341a45ca05469f0a1f8fd0138660c4310f241989c5321cef5226ec72301ed08744c6426
+  metadata.gz: a3f54a1d33748829d1bd94f5ac9c05ffb0c926a217e2568de570a45225cff7bf30a53a964c9bed295c2391fb679706196e76338137b90110bf0f2d12ef7679fa
+  data.tar.gz: e878bfa26f9274669d554914be9a462d34f0d55dc607ea48aa4c875a4bd2cc4471ae28f4038a8692444294a3160fd686b01cb3b3ed0e08308c8ea3b6209adc7c

data/.ruby-version

@@ -1 +1 @@
-2.1.1
+2.1.2

data/lib/mongoid/elasticsearch/pagination.rb

@@ -54,7 +54,7 @@ module Mongoid
       end
 
       def last_page?
-        current_page == total_pages
+        total_pages == 0 || current_page == total_pages
       end
 
 

data/lib/mongoid/elasticsearch/version.rb

@@ -1,5 +1,5 @@
 module Mongoid
   module Elasticsearch
-    VERSION = "0.8.1"
+    VERSION = "0.8.2"
   end
 end

data/spec/mongoid_elasticsearch_spec.rb

@@ -4,27 +4,27 @@ require "spec_helper"
 
 describe Article do
   it 'properly uses options' do
-    Article.es_index_name.should eq 'mongoid_es_news'
-    Article.es.index.name.should eq 'mongoid_es_news'
-    Article.es.index.type.should eq 'article'
-    Article.es_wrapper.should eq :load
-    Article.es_client_options.should eq(DEFAULT_OPT)
+    expect(Article.es_index_name).to eq 'mongoid_es_news'
+    expect(Article.es.index.name).to eq 'mongoid_es_news'
+    expect(Article.es.index.type).to eq 'article'
+    expect(Article.es_wrapper).to eq :load
+    expect(Article.es_client_options).to eq(DEFAULT_OPT)
   end
 
   context 'index operations' do
     it 'creates and destroys index' do
-      Article.es.index.exists?.should be_true
+      expect(Article.es.index.exists?).to be_truthy
       Article.es.index.delete
-      Article.es.index.exists?.should be_false
+      expect(Article.es.index.exists?).to be_falsey
       Article.es.index.create
-      Article.es.index.exists?.should be_true
+      expect(Article.es.index.exists?).to be_truthy
     end
   end
 
   context 'adding to index' do
     it 'successfuly saves mongoid document' do
       article = Article.new(name: 'test article name')
-      article.save.should be_true
+      expect(article.save).to be_truthy
     end
   end
 
@@ -32,11 +32,11 @@ describe Article do
     it 'deletes document from index when model is destroyed' do
       Article.create(name: 'test article name')
       Article.es.index.refresh
-      Article.es.all.count.should eq 1
+      expect(Article.es.all.count).to eq 1
 
       Article.first.destroy
       Article.es.index.refresh
-      Article.es.all.count.should eq 0
+      expect(Article.es.all.count).to eq 0
     end
   end
 
@@ -60,22 +60,22 @@ describe Article do
 
     it 'searches and returns models' do
       results = Article.es.search q: 'likely'
-      results.count.should eq 1
-      results.to_a.count.should eq 1
-      results.first.id.should eq @article_2.id
-      results.first.name.should eq @article_2.name
+      expect(results.count).to eq 1
+      expect(results.to_a.count).to eq 1
+      expect(results.first.id).to eq @article_2.id
+      expect(results.first.name).to eq @article_2.name
     end
 
     it 'mongoid_slug with wrapper: :load' do
       results = Article.es.search q: 'likely'
       expect(Article).to receive(:find).once.with([@article_2.id.to_s]).and_call_original
-      results.first.slug.should eq @article_2.name.to_url
-      results.first.to_param.should eq @article_2.name.to_url
+      expect(results.first.slug).to eq @article_2.name.to_url
+      expect(results.first.to_param).to eq @article_2.name.to_url
     end
 
     it 'mongoid_slug with sort and wrapper: :load' do
       results = Article.es.search body: { query: { match_all: {} }, sort: { 'name.raw' => 'desc' } }
-      results.map( &:id ).should eq Article.all.desc( :name ).map( &:id )
+      expect(results.map( &:id )).to eq Article.all.desc( :name ).map( &:id )
     end
 
     it 'mongoid_slug with wrapper: :model' do
@@ -83,26 +83,26 @@ describe Article do
       results = Article.es.search 'likely', wrapper: :model
       sleep 3
       allow(Article).to receive(:find)
-      results.first.slug.should eq @article_2.name.to_url
-      results.first.to_param.should eq @article_2.name.to_url
+      expect(results.first.slug).to eq @article_2.name.to_url
+      expect(results.first.to_param).to eq @article_2.name.to_url
       expect(Article).to_not have_received(:find)
     end
 
     it 'restores BSON::ObjectId with wrapper :model' do
       results = Post.es.search 'object_id'
       if defined?(Moped::BSON)
-        results.first.my_object_id.should be_kind_of(Moped::BSON::ObjectId)
+        expect(results.first.my_object_id).to be_kind_of(Moped::BSON::ObjectId)
       else
-        results.first.my_object_id.should be_kind_of(BSON::ObjectId)
+        expect(results.first.my_object_id).to be_kind_of(BSON::ObjectId)
       end
       
-      results.first.my_object_id.should eq(@post_1.my_object_id)
+      expect(results.first.my_object_id).to eq(@post_1.my_object_id)
     end
 
 
     if Article.es.completion_supported?
       it 'completion' do
-        Article.es.completion('te', 'name.suggest').should eq [
+        expect(Article.es.completion('te', 'name.suggest')).to eq [
           {"text"=>"test article name likes", "score"=>1.0},
           {"text"=>"tests likely an another article title", "score"=>1.0}
         ]
@@ -121,35 +121,49 @@ describe Article do
     end
 
     it '#search' do
-      Article.es.search('test', per_page: 7, page: 2).to_a.size.should eq 3
+      expect(Article.es.search('test', per_page: 7, page: 2).to_a.size).to eq 3
+    end
+
+    it 'paging works with empty results' do
+      result = Article.es.search('bad_request', per_page: 7, page: 1)
+      p result
+      expect(result.num_pages).to eq 0
+      expect(result.current_page).to eq 1
+      expect(result.total_entries).to eq 0
+      expect(result.previous_page).to be_nil
+      expect(result.next_page).to be_nil
+      expect(result.to_a.size).to eq 0
+      expect(result.out_of_bounds?).to be_truthy
+      expect(result.first_page?).to be_truthy
+      expect(result.last_page?).to be_truthy
     end
 
     it '#all' do
       result = Article.es.all(per_page: 7, page: 2)
-      result.num_pages.should eq 2
-      result.current_page.should eq 2
-      result.total_entries.should eq 10
-      result.previous_page.should eq 1
-      result.next_page.should be_nil
-      result.to_a.size.should eq 3
-      result.out_of_bounds?.should be_false
-      result.first_page?.should be_false
-      result.last_page?.should be_true
+      expect(result.num_pages).to eq 2
+      expect(result.current_page).to eq 2
+      expect(result.total_entries).to eq 10
+      expect(result.previous_page).to eq 1
+      expect(result.next_page).to be_nil
+      expect(result.to_a.size).to eq 3
+      expect(result.out_of_bounds?).to be_falsey
+      expect(result.first_page?).to be_falsey
+      expect(result.last_page?).to be_truthy
       
       p1 = Article.es.all(per_page: 7, page: 1)
-      p1.out_of_bounds?.should be_false
-      p1.first_page?.should be_true
-      p1.last_page?.should be_false
-      p1.current_page.should eq 1
-      p1.next_page.should eq 2
+      expect(p1.out_of_bounds?).to be_falsey
+      expect(p1.first_page?).to be_truthy
+      expect(p1.last_page?).to be_falsey
+      expect(p1.current_page).to eq 1
+      expect(p1.next_page).to eq 2
 
       p3 = Article.es.all(per_page: 7, page: 3)
-      p3.out_of_bounds?.should be_true
+      expect(p3.out_of_bounds?).to be_truthy
 
-      p1.length.should eq 7
+      expect(p1.length).to eq 7
       all = (result.to_a + p1.to_a).map(&:id).map(&:to_s).sort
-      all.length.should eq 10
-      all.should eq @articles.map(&:id).map(&:to_s).sort
+      expect(all.length).to eq 10
+      expect(all).to eq @articles.map(&:id).map(&:to_s).sort
     end
   end
 
@@ -160,16 +174,16 @@ describe Article do
       Article.es.index.refresh
     end
     it '#destroy' do
-      Article.es.all.count.should eq 10
+      expect(Article.es.all.count).to eq 10
       @articles[0].destroy
       Article.es.index.refresh
-      Article.es.all.count.should eq 9
+      expect(Article.es.all.count).to eq 9
     end
     it '#destroy_all' do
-      Article.es.all.count.should eq 10
+      expect(Article.es.all.count).to eq 10
       Article.destroy_all
       Article.es.index.refresh
-      Article.es.all.count.should eq 0
+      expect(Article.es.all.count).to eq 0
     end
   end
 end
@@ -177,28 +191,28 @@ end
 
 describe Post do
   it 'properly uses options' do
-    Post.es_index_name.should eq 'mongoid_es_test_posts'
-    Post.es_wrapper.should eq :model
-    Post.es_client_options.should eq(DEFAULT_OPT)
+    expect(Post.es_index_name).to eq 'mongoid_es_test_posts'
+    expect(Post.es_wrapper).to eq :model
+    expect(Post.es_client_options).to eq(DEFAULT_OPT)
   end
 
   context 'index operations' do
     it 'does not create index with empty definition (ES will do it for us)' do
-      Post.es.index.exists?.should be_false
+      expect(Post.es.index.exists?).to be_falsey
       Post.es.index.create
-      Post.es.index.exists?.should be_false
+      expect(Post.es.index.exists?).to be_falsey
     end
     it 'ES autocreates index on first index' do
-      Post.es.index.exists?.should be_false
+      expect(Post.es.index.exists?).to be_falsey
       Post.create!(name: 'test post')
-      Post.es.index.exists?.should be_true
+      expect(Post.es.index.exists?).to be_truthy
     end
   end
 
   context 'adding to index' do
     it 'successfuly saves mongoid document' do
       article = Post.new(name: 'test article name')
-      article.save.should be_true
+      expect(article.save).to be_truthy
     end
   end
 
@@ -210,11 +224,11 @@ describe Post do
     end
 
     it 'searches and returns models' do
-      Post.es.search('article').first.class.should eq Post
+      expect(Post.es.search('article').first.class).to eq Post
       sleep 1
-      Post.es.search('article').count.should eq 2
-      Post.es.search('another').count.should eq 1
-      Post.es.search('another').first.id.should eq @post_2.id
+      expect(Post.es.search('article').count).to eq 2
+      expect(Post.es.search('another').count).to eq 1
+      expect(Post.es.search('another').first.id).to eq @post_2.id
     end
   end
 
@@ -225,21 +239,21 @@ describe Post do
     end
 
     it '#search' do
-      Post.es.search('test').size.should eq 10
-      Post.es.search('test', per_page: 7, page: 2).to_a.size.should eq 3
+      expect(Post.es.search('test').size).to eq 10
+      expect(Post.es.search('test', per_page: 7, page: 2).to_a.size).to eq 3
     end
 
     it '#all' do
-      Post.es.all.size.should eq 10
-      Post.es.all(per_page: 7, page: 2).to_a.size.should eq 3
+      expect(Post.es.all.size).to eq 10
+      expect(Post.es.all(per_page: 7, page: 2).to_a.size).to eq 3
     end
   end
 end
 
 describe Nowrapper do
   it 'properly uses options' do
-    Nowrapper.es_index_name.should eq 'mongoid_es_test_nowrappers'
-    Nowrapper.es_wrapper.should eq :none
+    expect(Nowrapper.es_index_name).to eq 'mongoid_es_test_nowrappers'
+    expect(Nowrapper.es_wrapper).to eq :none
   end
 
   context 'searching' do
@@ -251,10 +265,10 @@ describe Nowrapper do
 
     it 'searches and returns hashes' do
       # #count uses _count
-      Nowrapper.es.search('article').count.should eq 2
+      expect(Nowrapper.es.search('article').count).to eq 2
       # #size and #length fetch results
-      Nowrapper.es.search('article').length.should eq 2
-      Nowrapper.es.search('article').first.class.should eq Hash
+      expect(Nowrapper.es.search('article').length).to eq 2
+      expect(Nowrapper.es.search('article').first.class).to eq Hash
     end
   end
 end
@@ -278,50 +292,50 @@ describe "Multisearch" do
     #pp response.results
     #pp response.raw_response
     #pp @article_1
-    response.length.should eq 4
-    response.to_a.map(&:class).map(&:name).uniq.sort.should eq ['Article', 'Namespaced::Model', 'Post']
-    response.select { |r| r.class == Article && r.id == @article_1.id }.first.should_not be_nil
+    expect(response.length).to eq 4
+    expect(response.to_a.map(&:class).map(&:name).uniq.sort).to eq ['Article', 'Namespaced::Model', 'Post']
+    expect(response.select { |r| r.class == Article && r.id == @article_1.id }.first).not_to be_nil
   end
 
   it '#multi_with_load' do
     response = Mongoid::Elasticsearch.search 'test', wrapper: :load
-    response.length.should eq 4
-    response.to_a.map(&:class).map(&:name).uniq.sort.should eq ['Article', 'Namespaced::Model', 'Post']
-    response.select { |r| r.class == Article && r.id == @article_1.id }.first.should_not be_nil
+    expect(response.length).to eq 4
+    expect(response.to_a.map(&:class).map(&:name).uniq.sort).to eq ['Article', 'Namespaced::Model', 'Post']
+    expect(response.select { |r| r.class == Article && r.id == @article_1.id }.first).not_to be_nil
   end
 end
 
 describe Namespaced::Model do
   it 'properly uses options' do
-    Namespaced::Model.es_index_name.should eq 'mongoid_es_test_namespaced_models'
-    Namespaced::Model.es.index.name.should eq 'mongoid_es_test_namespaced_models'
-    Namespaced::Model.es.index.type.should eq 'namespaced/model'
-    Namespaced::Model.es_wrapper.should eq :model
-    Namespaced::Model.es_client_options.should eq(DEFAULT_OPT)
+    expect(Namespaced::Model.es_index_name).to eq 'mongoid_es_test_namespaced_models'
+    expect(Namespaced::Model.es.index.name).to eq 'mongoid_es_test_namespaced_models'
+    expect(Namespaced::Model.es.index.type).to eq 'namespaced/model'
+    expect(Namespaced::Model.es_wrapper).to eq :model
+    expect(Namespaced::Model.es_client_options).to eq(DEFAULT_OPT)
   end
 
   context 'index operations' do
     it 'creates and destroys index' do
-      Namespaced::Model.es.index.exists?.should be_true
+      expect(Namespaced::Model.es.index.exists?).to be_truthy
       Namespaced::Model.es.index.delete
-      Namespaced::Model.es.index.exists?.should be_false
+      expect(Namespaced::Model.es.index.exists?).to be_falsey
       Namespaced::Model.es.index.create
-      Namespaced::Model.es.index.exists?.should be_true
+      expect(Namespaced::Model.es.index.exists?).to be_truthy
     end
   end
 
   context 'adding to index' do
     it 'successfuly saves mongoid document' do
       article = Namespaced::Model.new(name: 'test article name')
-      article.save.should be_true
+      expect(article.save).to be_truthy
     end
     it 'successfuly destroys mongoid document' do
       article = Namespaced::Model.create(name: 'test article name')
       Namespaced::Model.es.index.refresh
-      Namespaced::Model.es.all.count.should eq 1
+      expect(Namespaced::Model.es.all.count).to eq 1
       article.destroy
       Namespaced::Model.es.index.refresh
-      Namespaced::Model.es.all.count.should eq 0
+      expect(Namespaced::Model.es.all.count).to eq 0
     end
   end
 
@@ -335,10 +349,10 @@ describe Namespaced::Model do
 
     it 'searches and returns models' do
       results = Namespaced::Model.es.search q: 'likely'
-      results.count.should eq 1
-      results.to_a.count.should eq 1
-      results.first.id.should eq @article_2.id
-      results.first.name.should eq @article_2.name
+      expect(results.count).to eq 1
+      expect(results.to_a.count).to eq 1
+      expect(results.first.id).to eq @article_2.id
+      expect(results.first.name).to eq @article_2.name
     end
   end
 
@@ -353,60 +367,60 @@ describe Namespaced::Model do
     end
 
     it '#search ignores irrelevant' do
-      Namespaced::Model.es.search('irrelevant').to_a.size.should eq 1
-      Namespaced::Model.es.search('test', per_page: 30).to_a.size.should eq 20
+      expect(Namespaced::Model.es.search('irrelevant').to_a.size).to eq 1
+      expect(Namespaced::Model.es.search('test', per_page: 30).to_a.size).to eq 20
     end
 
     it '#search dynamic wrapper' do
-      Namespaced::Model.es.search('test', wrapper: :hash).map(&:class).map(&:name).uniq.should eq ['Hash']
-      Namespaced::Model.es.search('test', wrapper: :mash).map(&:class).map(&:name).uniq.should eq ['Hashie::Mash']
-      Namespaced::Model.es.search('test', wrapper: :mash).first.name.should eq 'test'
+      expect(Namespaced::Model.es.search('test', wrapper: :hash).map(&:class).map(&:name).uniq).to eq ['Hash']
+      expect(Namespaced::Model.es.search('test', wrapper: :mash).map(&:class).map(&:name).uniq).to eq ['Hashie::Mash']
+      expect(Namespaced::Model.es.search('test', wrapper: :mash).first.name).to eq 'test'
     end
 
     it '#search' do
-      Namespaced::Model.es.search('test', per_page: 10, page: 2).to_a.size.should eq 10
-      Namespaced::Model.es.search('test', per_page: 30, page: 2).to_a.size.should eq 0
-      Namespaced::Model.es.search('test', per_page: 2, page: 2).to_a.size.should eq 2
-      Namespaced::Model.es.search(body: {query: {query_string: {query: 'test'}}}, size: 50).to_a.length.should eq 20
+      expect(Namespaced::Model.es.search('test', per_page: 10, page: 2).to_a.size).to eq 10
+      expect(Namespaced::Model.es.search('test', per_page: 30, page: 2).to_a.size).to eq 0
+      expect(Namespaced::Model.es.search('test', per_page: 2, page: 2).to_a.size).to eq 2
+      expect(Namespaced::Model.es.search(body: {query: {query_string: {query: 'test'}}}, size: 50).to_a.length).to eq 20
     end
 
     it 'bulk index' do
       Namespaced::Model.es.index.reset
       Namespaced::Model.es.index_all
       Namespaced::Model.es.index.refresh
-      Namespaced::Model.es.search('test', per_page: 10, page: 2).to_a.size.should eq 10
-      Namespaced::Model.es.search('test', per_page: 30, page: 2).to_a.size.should eq 0
-      Namespaced::Model.es.search('test', per_page: 2, page: 2).to_a.size.should eq 2
-      Namespaced::Model.es.search(body: {query: {query_string: {query: 'test'}}}, size: 50).to_a.length.should eq 20
+      expect(Namespaced::Model.es.search('test', per_page: 10, page: 2).to_a.size).to eq 10
+      expect(Namespaced::Model.es.search('test', per_page: 30, page: 2).to_a.size).to eq 0
+      expect(Namespaced::Model.es.search('test', per_page: 2, page: 2).to_a.size).to eq 2
+      expect(Namespaced::Model.es.search(body: {query: {query_string: {query: 'test'}}}, size: 50).to_a.length).to eq 20
     end
 
 
     it '#all' do
       result = Namespaced::Model.es.all(per_page: 7, page: 3)
-      result.num_pages.should eq 4
-      result.to_a.size.should eq 7
+      expect(result.num_pages).to eq 4
+      expect(result.to_a.size).to eq 7
       p1 = Namespaced::Model.es.all(per_page: 7, page: 1).to_a
       p2 = Namespaced::Model.es.all(per_page: 7, page: 2).to_a
       p4 = Namespaced::Model.es.all(per_page: 7, page: 4).to_a
-      p1.length.should eq 7
-      p2.length.should eq 7
-      p4.length.should eq 1
+      expect(p1.length).to eq 7
+      expect(p2.length).to eq 7
+      expect(p4.length).to eq 1
       all = (p1 + p2 + result.to_a + p4).map(&:id).map(&:to_s).sort
-      all.length.should eq 22
-      all.should eq (@articles + [@a1, @a2]).map(&:id).map(&:to_s).sort
+      expect(all.length).to eq 22
+      expect(all).to eq (@articles + [@a1, @a2]).map(&:id).map(&:to_s).sort
     end
   end
 end
 
 describe 'utils' do
   it 'doesnt strip non-ascii text' do
-    Mongoid::Elasticsearch::Utils.clean('тест {{').should eq 'тест'
+    expect(Mongoid::Elasticsearch::Utils.clean('тест {{')).to eq 'тест'
   end
   it 'doesnt strip good white space' do
-    Mongoid::Elasticsearch::Utils.clean('test test').should eq 'test test'
+    expect(Mongoid::Elasticsearch::Utils.clean('test test')).to eq 'test test'
   end
   it 'strip extra white space' do
-    Mongoid::Elasticsearch::Utils.clean('    test     test    ').should eq 'test test'
+    expect(Mongoid::Elasticsearch::Utils.clean('    test     test    ')).to eq 'test test'
   end
 end
 
@@ -414,13 +428,13 @@ end
 describe 'no autocreate' do
   it "desn't create index automatically" do
     NoAutocreate.es.index.delete
-    NoAutocreate.es.index.exists?.should be_false
+    expect(NoAutocreate.es.index.exists?).to be_falsey
     
     Mongoid::Elasticsearch.create_all_indexes!
-    NoAutocreate.es.index.exists?.should be_false
+    expect(NoAutocreate.es.index.exists?).to be_falsey
     
     NoAutocreate.es.index.force_create
-    NoAutocreate.es.index.exists?.should be_true
+    expect(NoAutocreate.es.index.exists?).to be_truthy
     
     NoAutocreate.es.index.delete
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mongoid-elasticsearch
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.8.2
 platform: ruby
 authors:
 - glebtv
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-02 00:00:00.000000000 Z
+date: 2014-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mongoid