elasticsearch-model 5.1.0 → 6.1.1

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/pagination.rb

@@ -1,192 +1,2 @@
-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
-
-        # 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
+require 'elasticsearch/model/response/pagination/kaminari'
+require 'elasticsearch/model/response/pagination/will_paginate'

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/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/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 ||= 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 ||= @response ? @response.to_hash : search.execute!
         end
       end
     end

data/lib/elasticsearch/model/version.rb

@@ -1,5 +1,5 @@
 module Elasticsearch
   module Model
-    VERSION = "5.1.0"
+    VERSION = '6.1.1'
   end
 end

data/lib/elasticsearch/model.rb

@@ -131,12 +131,6 @@ module Elasticsearch
       end
     end
 
-    # Access the module settings
-    #
-    def self.settings
-      @settings ||= {}
-    end
-
     module ClassMethods
       # Get the client common for all models
       #
@@ -193,7 +187,7 @@ module Elasticsearch
       # @note Inheritance is disabled by default.
       #
       def inheritance_enabled
-        @inheritance_enabled ||= false
+        @settings[:inheritance_enabled] ||= false
       end
 
       # Enable inheritance of index_name and document_type
@@ -203,8 +197,21 @@ module Elasticsearch
       #     Elasticsearch::Model.inheritance_enabled = true
       #
       def inheritance_enabled=(inheritance_enabled)
-        @inheritance_enabled = inheritance_enabled
+        warn STI_DEPRECATION_WARNING if inheritance_enabled
+        @settings[:inheritance_enabled] = inheritance_enabled
+      end
+
+      # Access the module settings
+      #
+      def settings
+        @settings ||= {}
       end
+
+      private
+
+      STI_DEPRECATION_WARNING = "DEPRECATION WARNING: Support for Single Table Inheritance (STI) is deprecated " +
+        "and will be removed in version 7.0.0.\nPlease save different model documents in separate indices and refer " +
+        "to the Elasticsearch documentation for more information.".freeze
     end
     extend ClassMethods
 

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