elasticsearch-model 6.0.0 → 6.1.0

data/lib/elasticsearch/model/response/pagination/kaminari.rb

@@ -0,0 +1,109 @@
+module Elasticsearch
+  module Model
+    module Response
+
+      # Pagination for search results/records
+      #
+      module Pagination
+        # Allow models to be paginated with the "kaminari" gem [https://github.com/amatsuda/kaminari]
+        #
+        module Kaminari
+          def self.included(base)
+            # Include the Kaminari configuration and paging method in response
+            #
+            base.__send__ :include, ::Kaminari::ConfigurationMethods::ClassMethods
+            base.__send__ :include, ::Kaminari::PageScopeMethods
+
+            # Include the Kaminari paging methods in results and records
+            #
+            Elasticsearch::Model::Response::Results.__send__ :include, ::Kaminari::ConfigurationMethods::ClassMethods
+            Elasticsearch::Model::Response::Results.__send__ :include, ::Kaminari::PageScopeMethods
+            Elasticsearch::Model::Response::Records.__send__ :include, ::Kaminari::PageScopeMethods
+
+            Elasticsearch::Model::Response::Results.__send__ :delegate, :limit_value, :offset_value, :total_count, :max_pages, to: :response
+            Elasticsearch::Model::Response::Records.__send__ :delegate, :limit_value, :offset_value, :total_count, :max_pages, to: :response
+
+            base.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              # Define the `page` Kaminari method
+              #
+              def #{::Kaminari.config.page_method_name}(num=nil)
+                @results  = nil
+                @records  = nil
+                @response = nil
+                @page     = [num.to_i, 1].max
+                @per_page ||= __default_per_page
+
+                self.search.definition.update size: @per_page,
+                                              from: @per_page * (@page - 1)
+
+                self
+              end
+            RUBY
+          end
+
+          # Returns the current "limit" (`size`) value
+          #
+          def limit_value
+            case
+            when search.definition[:size]
+              search.definition[:size]
+            else
+              __default_per_page
+            end
+          end
+
+          # Returns the current "offset" (`from`) value
+          #
+          def offset_value
+            case
+            when search.definition[:from]
+              search.definition[:from]
+            else
+              0
+            end
+          end
+
+          # Set the "limit" (`size`) value
+          #
+          def limit(value)
+            return self if value.to_i <= 0
+            @results  = nil
+            @records  = nil
+            @response = nil
+            @per_page = value.to_i
+
+            search.definition.update :size => @per_page
+            search.definition.update :from => @per_page * (@page - 1) if @page
+            self
+          end
+
+          # Set the "offset" (`from`) value
+          #
+          def offset(value)
+            return self if value.to_i < 0
+            @results  = nil
+            @records  = nil
+            @response = nil
+            @page     = nil
+            search.definition.update :from => value.to_i
+            self
+          end
+
+          # Returns the total number of results
+          #
+          def total_count
+            results.total
+          end
+
+          # Returns the models's `per_page` value or the default
+          #
+          # @api private
+          #
+          def __default_per_page
+            klass.respond_to?(:default_per_page) && klass.default_per_page || ::Kaminari.config.default_per_page
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch/model/response/pagination/will_paginate.rb

@@ -0,0 +1,95 @@
+module Elasticsearch
+  module Model
+    module Response
+
+      # Pagination for search results/records
+      #
+      module Pagination
+
+
+        # Allow models to be paginated with the "will_paginate" gem [https://github.com/mislav/will_paginate]
+        #
+        module WillPaginate
+          def self.included(base)
+            base.__send__ :include, ::WillPaginate::CollectionMethods
+
+            # Include the paging methods in results and records
+            #
+            methods = [:current_page, :offset, :length, :per_page, :total_entries, :total_pages, :previous_page, :next_page, :out_of_bounds?]
+            Elasticsearch::Model::Response::Results.__send__ :delegate, *methods, to: :response
+            Elasticsearch::Model::Response::Records.__send__ :delegate, *methods, to: :response
+          end
+
+          def offset
+            (current_page - 1) * per_page
+          end
+
+          def length
+            search.definition[:size]
+          end
+
+          # Main pagination method
+          #
+          # @example
+          #
+          #     Article.search('foo').paginate(page: 1, per_page: 30)
+          #
+          def paginate(options)
+            param_name = options[:param_name] || :page
+            page       = [options[param_name].to_i, 1].max
+            per_page   = (options[:per_page] || __default_per_page).to_i
+
+            search.definition.update size: per_page,
+                                     from: (page - 1) * per_page
+            self
+          end
+
+          # Return the current page
+          #
+          def current_page
+            search.definition[:from] / per_page + 1 if search.definition[:from] && per_page
+          end
+
+          # Pagination method
+          #
+          # @example
+          #
+          #     Article.search('foo').page(2)
+          #
+          def page(num)
+            paginate(page: num, per_page: per_page) # shorthand
+          end
+
+          # Return or set the "size" value
+          #
+          # @example
+          #
+          #     Article.search('foo').per_page(15).page(2)
+          #
+          def per_page(num = nil)
+            if num.nil?
+              search.definition[:size]
+            else
+              paginate(page: current_page, per_page: num) # shorthand
+            end
+          end
+
+          # Returns the total number of results
+          #
+          def total_entries
+            results.total
+          end
+
+          # Returns the models's `per_page` value or the default
+          #
+          # @api private
+          #
+          def __default_per_page
+            klass.respond_to?(:per_page) && klass.per_page || ::WillPaginate.per_page
+          end
+        end
+      end
+
+    end
+  end
+end

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

@@ -46,7 +46,7 @@ module Elasticsearch
 
         # Respond to methods from `@result` or `@result._source`
         #
-        def respond_to?(method_name, include_private = false)
+        def respond_to_missing?(method_name, include_private = false)
           @result.respond_to?(method_name.to_sym) || \
           @result._source && @result._source.respond_to?(method_name.to_sym) || \
           super

data/lib/elasticsearch/model/version.rb

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

data/spec/elasticsearch/model/adapter_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+
+describe Elasticsearch::Model::Adapter do
+
+  before(:all) do
+    class ::DummyAdapterClass; end
+    class ::DummyAdapterClassWithAdapter; end
+    class ::DummyAdapter
+      Records   = Module.new
+      Callbacks = Module.new
+      Importing = Module.new
+    end
+  end
+
+  after(:all) do
+    [DummyAdapterClassWithAdapter, DummyAdapterClass, DummyAdapter].each do |adapter|
+      Elasticsearch::Model::Adapter::Adapter.adapters.delete(adapter)
+    end
+    remove_classes(DummyAdapterClass, DummyAdapterClassWithAdapter, DummyAdapter)
+  end
+
+  describe '#from_class' do
+
+    it 'should return an Adapter instance' do
+      expect(Elasticsearch::Model::Adapter.from_class(DummyAdapterClass)).to be_a(Elasticsearch::Model::Adapter::Adapter)
+    end
+  end
+
+  describe 'register' do
+
+    before do
+      expect(Elasticsearch::Model::Adapter::Adapter).to receive(:register).and_call_original
+      Elasticsearch::Model::Adapter.register(:foo, lambda { |c| false })
+    end
+
+    it 'should register an adapter' do
+      expect(Elasticsearch::Model::Adapter::Adapter.adapters[:foo]).to be_a(Proc)
+    end
+
+    context 'when a specific adapter class is set' do
+
+      before do
+        expect(Elasticsearch::Model::Adapter::Adapter).to receive(:register).and_call_original
+        Elasticsearch::Model::Adapter::Adapter.register(DummyAdapter,
+                                                        lambda { |c| c == DummyAdapterClassWithAdapter })
+      end
+
+      let(:adapter) do
+        Elasticsearch::Model::Adapter::Adapter.new(DummyAdapterClassWithAdapter)
+      end
+
+      it 'should register the adapter' do
+        expect(adapter.adapter).to eq(DummyAdapter)
+      end
+    end
+  end
+
+  describe 'default adapter' do
+
+    let(:adapter) do
+      Elasticsearch::Model::Adapter::Adapter.new(DummyAdapterClass)
+    end
+
+    it 'sets a default adapter' do
+      expect(adapter.adapter).to eq(Elasticsearch::Model::Adapter::Default)
+    end
+  end
+
+  describe '#records_mixin' do
+
+    before do
+      Elasticsearch::Model::Adapter::Adapter.register(DummyAdapter,
+                                                      lambda { |c| c == DummyAdapterClassWithAdapter })
+
+    end
+
+    let(:adapter) do
+      Elasticsearch::Model::Adapter::Adapter.new(DummyAdapterClassWithAdapter)
+    end
+
+    it 'returns a Module' do
+      expect(adapter.records_mixin).to be_a(Module)
+    end
+  end
+
+  describe '#callbacks_mixin' do
+
+    before do
+      Elasticsearch::Model::Adapter::Adapter.register(DummyAdapter,
+                                                      lambda { |c| c == DummyAdapterClassWithAdapter })
+
+    end
+
+    let(:adapter) do
+      Elasticsearch::Model::Adapter::Adapter.new(DummyAdapterClassWithAdapter)
+    end
+
+    it 'returns a Module' do
+      expect(adapter.callbacks_mixin).to be_a(Module)
+    end
+  end
+
+  describe '#importing_mixin' do
+
+    before do
+      Elasticsearch::Model::Adapter::Adapter.register(DummyAdapter,
+                                                      lambda { |c| c == DummyAdapterClassWithAdapter })
+
+    end
+
+    let(:adapter) do
+      Elasticsearch::Model::Adapter::Adapter.new(DummyAdapterClassWithAdapter)
+    end
+
+    it 'returns a Module' do
+      expect(adapter.importing_mixin).to be_a(Module)
+    end
+  end
+end

data/spec/elasticsearch/model/adapters/active_record/associations_spec.rb

@@ -0,0 +1,334 @@
+require 'spec_helper'
+
+describe 'Elasticsearch::Model::Adapter::ActiveRecord Associations' do
+
+  before(:all) do
+    ActiveRecord::Schema.define(version: 1) do
+      create_table :categories do |t|
+        t.string     :title
+        t.timestamps null: false
+      end
+
+      create_table :categories_posts do |t|
+        t.references :post, :category
+      end
+
+      create_table :authors do |t|
+        t.string     :first_name, :last_name
+        t.timestamps null: false
+      end
+
+      create_table :authorships do |t|
+        t.string     :first_name, :last_name
+        t.references :post
+        t.references :author
+        t.timestamps null: false
+      end
+
+      create_table :comments do |t|
+        t.string     :text
+        t.string     :author
+        t.references :post
+        t.timestamps null: false
+      end
+
+      add_index(:comments, :post_id) unless index_exists?(:comments, :post_id)
+
+      create_table :posts do |t|
+        t.string     :title
+        t.text       :text
+        t.boolean    :published
+        t.timestamps null: false
+      end
+    end
+
+    Comment.__send__ :include, Elasticsearch::Model
+    Comment.__send__ :include, Elasticsearch::Model::Callbacks
+  end
+
+  before do
+    clear_tables(:categories, :categories_posts, :authors, :authorships, :comments, :posts)
+    clear_indices(Post)
+    Post.__elasticsearch__.create_index!(force: true)
+    Comment.__elasticsearch__.create_index!(force: true)
+  end
+
+  after do
+    clear_tables(Post, Category)
+    clear_indices(Post)
+  end
+
+  context 'when a document is created' do
+
+    before do
+      Post.create!(title: 'Test')
+      Post.create!(title: 'Testing Coding')
+      Post.create!(title: 'Coding')
+      Post.__elasticsearch__.refresh_index!
+    end
+
+    let(:search_result) do
+      Post.search('title:test')
+    end
+
+    it 'indexes the document' do
+      expect(search_result.results.size).to eq(2)
+      expect(search_result.results.first.title).to eq('Test')
+      expect(search_result.records.size).to eq(2)
+      expect(search_result.records.first.title).to eq('Test')
+    end
+  end
+
+  describe 'has_many_and_belongs_to association' do
+
+      context 'when an association is updated' do
+
+      before do
+        post.categories = [category_a,  category_b]
+        Post.__elasticsearch__.refresh_index!
+      end
+
+      let(:category_a) do
+        Category.where(title: "One").first_or_create!
+      end
+
+      let(:category_b) do
+        Category.where(title: "Two").first_or_create!
+      end
+
+      let(:post) do
+        Post.create! title: "First Post", text: "This is the first post..."
+      end
+
+      let(:search_result) do
+        Post.search(query: {
+            bool: {
+                must: {
+                    multi_match: {
+                        fields: ['title'],
+                        query: 'first'
+                    }
+                },
+                filter: {
+                    terms: {
+                        categories: ['One']
+                    }
+                }
+            }
+        } )
+      end
+
+      it 'applies the update with' do
+        expect(search_result.results.size).to eq(1)
+        expect(search_result.results.first.title).to eq('First Post')
+        expect(search_result.records.size).to eq(1)
+        expect(search_result.records.first.title).to eq('First Post')
+      end
+    end
+
+    context 'when an association is deleted' do
+
+      before do
+        post.categories = [category_a,  category_b]
+        post.categories = [category_b]
+        Post.__elasticsearch__.refresh_index!
+      end
+
+      let(:category_a) do
+        Category.where(title: "One").first_or_create!
+      end
+
+      let(:category_b) do
+        Category.where(title: "Two").first_or_create!
+      end
+
+      let(:post) do
+        Post.create! title: "First Post", text: "This is the first post..."
+      end
+
+      let(:search_result) do
+        Post.search(query: {
+            bool: {
+                must: {
+                    multi_match: {
+                        fields: ['title'],
+                        query: 'first'
+                    }
+                },
+                filter: {
+                    terms: {
+                        categories: ['One']
+                    }
+                }
+            }
+        } )
+      end
+
+      it 'applies the update with a reindex' do
+        expect(search_result.results.size).to eq(0)
+        expect(search_result.records.size).to eq(0)
+      end
+    end
+  end
+
+  describe 'has_many through association' do
+
+    context 'when the association is updated' do
+
+      before do
+        author_a = Author.where(first_name: "John", last_name: "Smith").first_or_create!
+        author_b = Author.where(first_name: "Mary", last_name: "Smith").first_or_create!
+        author_c = Author.where(first_name: "Kobe", last_name: "Griss").first_or_create!
+
+        # Create posts
+        post_1 = Post.create!(title: "First Post", text: "This is the first post...")
+        post_2 = Post.create!(title: "Second Post", text: "This is the second post...")
+        post_3 = Post.create!(title: "Third Post", text: "This is the third post...")
+
+        # Assign authors
+        post_1.authors = [author_a,  author_b]
+        post_2.authors = [author_a]
+        post_3.authors = [author_c]
+
+        Post.__elasticsearch__.refresh_index!
+      end
+
+      context 'if active record is at least 4' do
+
+        let(:search_result) do
+          Post.search('authors.full_name:john')
+        end
+
+        it 'applies the update', if: active_record_at_least_4? do
+          expect(search_result.results.size).to eq(2)
+          expect(search_result.records.size).to eq(2)
+        end
+      end
+
+      context 'if active record is less than 4' do
+
+        let(:search_result) do
+          Post.search('authors.author.full_name:john')
+        end
+
+        it 'applies the update', if: !active_record_at_least_4? do
+          expect(search_result.results.size).to eq(2)
+          expect(search_result.records.size).to eq(2)
+        end
+      end
+    end
+
+    context 'when an association is added', if: active_record_at_least_4? do
+
+      before do
+        author_a = Author.where(first_name: "John", last_name: "Smith").first_or_create!
+        author_b = Author.where(first_name: "Mary", last_name: "Smith").first_or_create!
+
+        # Create posts
+        post_1 = Post.create!(title: "First Post", text: "This is the first post...")
+
+        # Assign authors
+        post_1.authors = [author_a]
+        post_1.authors << author_b
+        Post.__elasticsearch__.refresh_index!
+      end
+
+      let(:search_result) do
+        Post.search('authors.full_name:john')
+      end
+
+      it 'adds the association' do
+        expect(search_result.results.size).to eq(1)
+        expect(search_result.records.size).to eq(1)
+      end
+    end
+  end
+
+  describe 'has_many association' do
+
+    context 'when an association is added', if: active_record_at_least_4? do
+
+      before do
+        # Create posts
+        post_1 = Post.create!(title: "First Post", text: "This is the first post...")
+        post_2 = Post.create!(title: "Second Post", text: "This is the second post...")
+
+        # Add comments
+        post_1.comments.create!(author: 'John', text: 'Excellent')
+        post_1.comments.create!(author: 'Abby', text: 'Good')
+
+        post_2.comments.create!(author: 'John', text: 'Terrible')
+
+        post_1.comments.create!(author: 'John', text: 'Or rather just good...')
+        Post.__elasticsearch__.refresh_index!
+      end
+
+      let(:search_result) do
+        Post.search(query: {
+            nested: {
+                path: 'comments',
+                query: {
+                    bool: {
+                        must: [
+                            { match: { 'comments.author' => 'john' } },
+                            { match: { 'comments.text'   => 'good' } }
+                        ]
+                    }
+                }
+            }
+        })
+      end
+
+      it 'adds the association' do
+        expect(search_result.results.size).to eq(1)
+      end
+    end
+  end
+
+  describe '#touch' do
+
+    context 'when a touch callback is defined on the model' do
+
+      before do
+        # Create categories
+        category_a = Category.where(title: "One").first_or_create!
+
+        # Create post
+        post = Post.create!(title: "First Post", text: "This is the first post...")
+
+        # Assign category
+        post.categories << category_a
+        category_a.update_attribute(:title, "Updated")
+        category_a.posts.each { |p| p.touch }
+
+        Post.__elasticsearch__.refresh_index!
+      end
+
+      it 'executes the callback after #touch' do
+        expect(Post.search('categories:One').size).to eq(0)
+        expect(Post.search('categories:Updated').size).to eq(1)
+      end
+    end
+  end
+
+  describe '#includes' do
+
+    before do
+      post_1 = Post.create(title: 'One')
+      post_2 = Post.create(title: 'Two')
+      post_1.comments.create(text: 'First comment')
+      post_2.comments.create(text: 'Second comment')
+
+      Comment.__elasticsearch__.refresh_index!
+    end
+
+    let(:search_result) do
+      Comment.search('first').records(includes: :post)
+    end
+
+    it 'eager loads associations' do
+      expect(search_result.first.association(:post)).to be_loaded
+      expect(search_result.first.post.title).to eq('One')
+    end
+  end
+end