kaminari 0.14.1 → 0.17.0

data/lib/kaminari/helpers/paginator.rb

@@ -12,6 +12,9 @@ module Kaminari
       include ::ActionView::Context
 
       def initialize(template, options) #:nodoc:
+        ActiveSupport::Deprecation.warn 'num_pages is deprecated and will be removed in Kaminari 1.0. Please use total_pages instead.' if options.has_key? :num_pages
+        options[:num_pages] ||= options[:total_pages]
+
         @window_options = {}.tap do |h|
           h[:window] = options.delete(:window) || options.delete(:inner_window) || Kaminari.config.window
           outer_window = options.delete(:outer_window) || Kaminari.config.outer_window
@@ -21,10 +24,11 @@ module Kaminari
           h[:right] = outer_window if h[:right] == 0
         end
         @template, @options = template, options
-        @theme = @options[:theme] ? "#{@options[:theme]}/" : ''
-        @options[:current_page] = PageProxy.new @window_options.merge(@options), @options[:current_page], nil
-        #FIXME for compatibility. remove num_pages at some time in the future
-        @options[:total_pages] ||= @options[:num_pages]
+        @theme = @options[:theme]
+        @views_prefix = @options[:views_prefix]
+        @window_options.merge! @options
+        @window_options[:current_page] = @options[:current_page] = PageProxy.new(@window_options, @options[:current_page], nil)
+
         @last = nil
         # initialize the output_buffer for Context
         @output_buffer = ActionView::OutputBuffer.new
@@ -45,8 +49,8 @@ module Kaminari
       def each_relevant_page
         return to_enum(:each_relevant_page) unless block_given?
 
-        relevant_pages(@window_options.merge(@options)).each do |i|
-          yield PageProxy.new(@window_options.merge(@options), i, @last)
+        relevant_pages(@window_options).each do |page|
+          yield PageProxy.new(@window_options, page, @last)
         end
       end
       alias each_page each_relevant_page
@@ -74,24 +78,40 @@ module Kaminari
 
       def to_s #:nodoc:
         subscriber = ActionView::LogSubscriber.log_subscribers.detect {|ls| ls.is_a? ActionView::LogSubscriber}
-        return super @window_options.merge(@options).merge :paginator => self unless subscriber
 
-        # dirty hack to suppress logging render_partial
-        class << subscriber
-          alias_method :render_partial_with_logging, :render_partial
-          # do nothing
-          def render_partial(event); end
-        end
+        # There is a logging subscriber
+        # and we don't want it to log render_partial
+        # It is threadsafe, but might not repress logging
+        # consistently in a high-load environment
+        if subscriber
+          unless defined? subscriber.render_partial_with_logging
+            class << subscriber
+              alias_method :render_partial_with_logging, :render_partial
+              attr_accessor :render_without_logging
+              # ugly hack to make a renderer where
+              # we can turn logging on or off
+              def render_partial(event)
+                render_partial_with_logging(event) unless render_without_logging
+              end
+            end
+          end
 
-        ret = super @window_options.merge(@options).merge :paginator => self
+          subscriber.render_without_logging = true
+          ret = super @window_options.merge :paginator => self
+          subscriber.render_without_logging = false
 
-        class << subscriber
-          alias_method :render_partial, :render_partial_with_logging
-          undef :render_partial_with_logging
+          ret
+        else
+          super @window_options.merge :paginator => self
         end
-        ret
       end
 
+      # delegates view helper methods to @template
+      def method_missing(name, *args, &block)
+        @template.respond_to?(name) ? @template.send(name, *args, &block) : super
+      end
+      private :method_missing
+
       # Wraps a "page number" and provides some utility methods
       class PageProxy
         include Comparable

data/lib/kaminari/helpers/sinatra_helpers.rb

@@ -1,5 +1,6 @@
 require 'active_support/core_ext/object'
 require 'active_support/core_ext/string'
+require 'action_dispatch/http/mime_type'
 
 begin
 
@@ -10,6 +11,11 @@ module Kaminari::Helpers
       def registered(app)
         app.register Padrino::Helpers
         app.helpers  HelperMethods
+        @app = app
+      end
+
+      def view_paths
+        @app.views
       end
 
       alias included registered
@@ -31,6 +37,7 @@ module Kaminari::Helpers
 
       def render(*args)
         base = ActionView::Base.new.tap do |a|
+          a.view_paths << SinatraHelpers.view_paths
           a.view_paths << File.expand_path('../../../../app/views', __FILE__)
         end
         base.render(*args)
@@ -87,6 +94,36 @@ module Kaminari::Helpers
         paginator.to_s
       end
 
+      # A simple "Twitter like" pagination link that creates a link to the previous page.
+      # Works on Sinatra.
+      #
+      # ==== Examples
+      # Basic usage:
+      #
+      #   <%= link_to_previous_page @items, 'Previous Page' %>
+      #
+      # Ajax:
+      #
+      #   <%= link_to_previous_page @items, 'Previous Page', :remote => true %>
+      #
+      # By default, it renders nothing if there are no more results on the previous page.
+      # You can customize this output by passing a parameter <tt>:placeholder</tt>.
+      #
+      #   <%= link_to_previous_page @users, 'Previous Page', :placeholder => %{<span>At the Beginning</span>} %>
+      #
+      def link_to_previous_page(scope, name, options = {})
+        params = options.delete(:params) || (Rack::Utils.parse_query(env['QUERY_STRING']).symbolize_keys rescue {})
+        param_name = options.delete(:param_name) || Kaminari.config.param_name
+        placeholder = options.delete(:placeholder)
+
+        unless scope.first_page?
+          query = params.merge(param_name => scope.prev_page)
+          link_to name, env['PATH_INFO'] + (query.empty? ? '' : "?#{query.to_query}"), options.reverse_merge(:rel => 'previous')
+        else
+          placeholder.to_s.html_safe
+        end
+      end
+
       # A simple "Twitter like" pagination link that creates a link to the next page.
       # Works on Sinatra.
       #
@@ -108,11 +145,12 @@ module Kaminari::Helpers
         params = options.delete(:params) || (Rack::Utils.parse_query(env['QUERY_STRING']).symbolize_keys rescue {})
         param_name = options.delete(:param_name) || Kaminari.config.param_name
         placeholder = options.delete(:placeholder)
-        query = params.merge(param_name => (scope.current_page + 1))
+
         unless scope.last_page?
+          query = params.merge(param_name => scope.next_page)
           link_to name, env['PATH_INFO'] + (query.empty? ? '' : "?#{query.to_query}"), options.reverse_merge(:rel => 'next')
         else
-          placeholder
+          placeholder.to_s.html_safe
         end
       end
     end
@@ -125,7 +163,7 @@ end
 
 rescue LoadError
 
-$stderr.puts "[!]You shold install `padrino-helpers' gem if you want to use kaminari's pagination helpers with Sinatra."
+$stderr.puts "[!]You should install `padrino-helpers' gem if you want to use kaminari's pagination helpers with Sinatra."
 $stderr.puts "[!]Kaminari::Helpers::SinatraHelper does nothing now..."
 
 module Kaminari::Helpers

data/lib/kaminari/helpers/tags.rb

@@ -15,17 +15,30 @@ module Kaminari
     class Tag
       def initialize(template, options = {}) #:nodoc:
         @template, @options = template, options.dup
-        @param_name = @options.delete(:param_name)
-        @theme = @options[:theme] ? "#{@options.delete(:theme)}/" : ''
-        @params = @options[:params] ? template.params.merge(@options.delete :params) : template.params
+        @param_name = @options.delete(:param_name) || Kaminari.config.param_name
+        @theme = @options.delete(:theme)
+        @views_prefix = @options.delete(:views_prefix)
+        @params = template.params
+        # @params in Rails 5 no longer inherits from Hash
+        @params = @params.to_unsafe_h if @params.respond_to?(:to_unsafe_h)
+        @params = @params.except(:script_name).merge(@options.delete(:params) || {})
       end
 
       def to_s(locals = {}) #:nodoc:
-        @template.render :partial => "kaminari/#{@theme}#{self.class.name.demodulize.underscore}", :locals => @options.merge(locals)
+        @template.render :partial => partial_path, :locals => @options.merge(locals), :formats => [:html]
       end
 
       def page_url_for(page)
-        @template.url_for @params.merge(@param_name => (page <= 1 ? nil : page))
+        @template.url_for @params.merge(@param_name => (page <= 1 ? nil : page), :only_path => true)
+      end
+
+      def partial_path
+        [
+         @views_prefix,
+         "kaminari",
+         @theme,
+         self.class.name.demodulize.underscore
+        ].compact.join("/")
       end
     end
 

data/lib/kaminari/hooks.rb

@@ -6,26 +6,42 @@ module Kaminari
         ::ActiveRecord::Base.send :include, Kaminari::ActiveRecordExtension
       end
 
-      begin; require 'data_mapper'; rescue LoadError; end
-      if defined? ::DataMapper
-        require 'dm-aggregates'
-        require 'kaminari/models/data_mapper_extension'
-        ::DataMapper::Collection.send :include, Kaminari::DataMapperExtension::Collection
-        ::DataMapper::Model.append_extensions Kaminari::DataMapperExtension::Model
-        # ::DataMapper::Model.send :extend, Kaminari::DataMapperExtension::Model
+      # data_mapper
+      begin
+        require 'kaminari/data_mapper'
+      rescue LoadError
+        begin; require 'data_mapper'; rescue LoadError; end
+        if defined? ::DataMapper
+          require 'dm-aggregates'
+          require 'kaminari/models/data_mapper_extension'
+          ::DataMapper::Collection.send :include, Kaminari::DataMapperExtension::Collection
+          ::DataMapper::Model.append_extensions Kaminari::DataMapperExtension::Model
+          # ::DataMapper::Model.send :extend, Kaminari::DataMapperExtension::Model
+        end
       end
 
-      begin; require 'mongoid'; rescue LoadError; end
-      if defined? ::Mongoid
-        require 'kaminari/models/mongoid_extension'
-        ::Mongoid::Criteria.send :include, Kaminari::MongoidExtension::Criteria
-        ::Mongoid::Document.send :include, Kaminari::MongoidExtension::Document
+      ## mongoid
+      begin
+        require 'kaminari/mongoid'
+      rescue LoadError
+        begin; require 'mongoid'; rescue LoadError; end
+        if defined? ::Mongoid
+          ActiveSupport::Deprecation.warn 'Kaminari Mongoid support has been extracted to a separate gem, and will be removed in the next 1.0 release. Please bundle kaminari-mongoid gem.'
+          require 'kaminari/models/mongoid_extension'
+          ::Mongoid::Document.send :include, Kaminari::MongoidExtension::Document
+        end
       end
 
+      ## mongo_mapper
       ActiveSupport.on_load(:mongo_mapper) do
-        require 'kaminari/models/mongo_mapper_extension'
-        ::MongoMapper::Document.send :include, Kaminari::MongoMapperExtension::Document
-        ::Plucky::Query.send :include, Kaminari::PluckyCriteriaMethods
+        begin
+          require 'kaminari/mongo_mapper'
+        rescue LoadError
+          ActiveSupport::Deprecation.warn 'Kaminari MongoMapper support has been extracted to a separate gem, and will be removed in the next 1.0 release. Please bundle kaminari-mongo_mapper gem.'
+          require 'kaminari/models/mongo_mapper_extension'
+          ::MongoMapper::Document.send :include, Kaminari::MongoMapperExtension::Document
+          ::Plucky::Query.send :include, Kaminari::PluckyCriteriaMethods
+        end
       end
       require 'kaminari/models/array_extension'
 

data/lib/kaminari/models/active_record_extension.rb

@@ -3,19 +3,19 @@ require 'kaminari/models/active_record_model_extension'
 module Kaminari
   module ActiveRecordExtension
     extend ActiveSupport::Concern
-    included do
+
+    module ClassMethods
       # Future subclasses will pick up the model extension
-      class << self
-        def inherited_with_kaminari(kls) #:nodoc:
-          inherited_without_kaminari kls
-          kls.send(:include, Kaminari::ActiveRecordModelExtension) if kls.superclass == ActiveRecord::Base
-        end
-        alias_method_chain :inherited, :kaminari
+      def inherited(kls) #:nodoc:
+        super
+        kls.send(:include, Kaminari::ActiveRecordModelExtension) if kls.superclass == ::ActiveRecord::Base
       end
+    end
 
+    included do
       # Existing subclasses pick up the model extension as well
       self.descendants.each do |kls|
-        kls.send(:include, Kaminari::ActiveRecordModelExtension) if kls.superclass == ActiveRecord::Base
+        kls.send(:include, Kaminari::ActiveRecordModelExtension) if kls.superclass == ::ActiveRecord::Base
       end
     end
   end

data/lib/kaminari/models/active_record_model_extension.rb

@@ -9,12 +9,14 @@ module Kaminari
 
       # Fetch the values at the specified page number
       #   Model.page(5)
-      self.scope Kaminari.config.page_method_name, Proc.new {|num|
-        limit(default_per_page).offset(default_per_page * ([num.to_i, 1].max - 1))
-      } do
-        include Kaminari::ActiveRecordRelationMethods
-        include Kaminari::PageScopeMethods
-      end
+      eval <<-RUBY
+        def self.#{Kaminari.config.page_method_name}(num = nil)
+          limit(default_per_page).offset(default_per_page * ((num = num.to_i - 1) < 0 ? 0 : num)).extending do
+            include Kaminari::ActiveRecordRelationMethods
+            include Kaminari::PageScopeMethods
+          end
+        end
+      RUBY
     end
   end
 end

data/lib/kaminari/models/active_record_relation_methods.rb

@@ -3,12 +3,21 @@ module Kaminari
     # a workaround for AR 3.0.x that returns 0 for #count when page > 1
     # if +limit_value+ is specified, load all the records and count them
     if ActiveRecord::VERSION::STRING < '3.1'
-      def count #:nodoc:
-        limit_value ? length : super
+      def count(column_name = nil, options = {}) #:nodoc:
+        limit_value && !options[:distinct] ? length : super(column_name, options)
       end
     end
 
-    def total_count #:nodoc:
+    def entry_name
+      model_name.human.downcase
+    end
+
+    def reset #:nodoc:
+      @total_count = nil
+      super
+    end
+
+    def total_count(column_name = :all, options = {}) #:nodoc:
       # #count overrides the #select which could include generated columns referenced in #order, so skip #order here, where it's irrelevant to the result anyway
       @total_count ||= begin
         c = except(:offset, :limit, :order)
@@ -16,14 +25,16 @@ module Kaminari
         # Remove includes only if they are irrelevant
         c = c.except(:includes) unless references_eager_loaded_tables?
 
-        # a workaround to count the actual model instances on distinct query because count + distinct returns wrong value in some cases. see https://github.com/amatsuda/kaminari/pull/160
-        uses_distinct_sql_statement = c.to_sql =~ /DISTINCT/i
-        if uses_distinct_sql_statement
-          c.length
+        # Rails 4.1 removes the `options` argument from AR::Relation#count
+        args = [column_name]
+        args << options if ActiveRecord::VERSION::STRING < '4.1.0'
+
+        # .group returns an OrderdHash that responds to #count
+        c = c.count(*args)
+        if c.is_a?(Hash) || c.is_a?(ActiveSupport::OrderedHash)
+          c.count
         else
-          # .group returns an OrderdHash that responds to #count
-          c = c.count
-          c.respond_to?(:count) ? c.count : c
+          c.respond_to?(:count) ? c.count(*args) : c
         end
       end
     end

data/lib/kaminari/models/array_extension.rb

@@ -11,31 +11,37 @@ module Kaminari
     # * <tt>:offset</tt> - offset
     # * <tt>:total_count</tt> - total_count
     def initialize(original_array = [], options = {})
-      @_original_array, @_limit_value, @_offset_value, @_total_count = original_array, (options[:limit] || default_per_page).to_i, options[:offset].to_i, options[:total_count]
+      @_original_array, @_limit_value, @_offset_value, @_total_count, @_padding = original_array, (options[:limit] || default_per_page).to_i, options[:offset].to_i, options[:total_count], options[:padding].to_i
 
       if options[:limit] && options[:offset]
-        class << self
-          include Kaminari::PageScopeMethods
-        end
+        extend Kaminari::PageScopeMethods
       end
 
-      if options[:total_count]
-        super original_array
-      else
-        super(original_array[@_offset_value, @_limit_value] || [])
+      if @_total_count.present? && @_total_count <= original_array.count
+        original_array = original_array.first(@_total_count)[@_offset_value, @_limit_value]
       end
+
+      if @_total_count.nil?
+        original_array = original_array[@_offset_value, @_limit_value]
+      end
+
+      super(original_array || [])
+    end
+
+    def entry_name
+      "entry"
     end
 
     # items at the specified "page"
     class_eval <<-RUBY, __FILE__, __LINE__ + 1
       def #{Kaminari.config.page_method_name}(num = 1)
-        offset(limit_value * ([num.to_i, 1].max - 1))
+        offset(limit_value * ((num = num.to_i - 1) < 0 ? 0 : num))
       end
     RUBY
 
     # returns another chunk of the original array
     def limit(num)
-      self.class.new @_original_array, :limit => num, :offset => @_offset_value, :total_count => @_total_count
+      self.class.new @_original_array, :limit => num, :offset => @_offset_value, :total_count => @_total_count, :padding => @_padding
     end
 
     # total item numbers of the original array
@@ -45,7 +51,7 @@ module Kaminari
 
     # returns another chunk of the original array
     def offset(num)
-      self.class.new @_original_array, :limit => @_limit_value, :offset => num, :total_count => @_total_count
+      self.class.new @_original_array, :limit => @_limit_value, :offset => num, :total_count => @_total_count, :padding => @_padding
     end
   end
 

data/lib/kaminari/models/configuration_methods.rb

@@ -13,7 +13,7 @@ module Kaminari
       # This model's default +per_page+ value
       # returns +default_per_page+ value unless explicitly overridden via <tt>paginates_per</tt>
       def default_per_page
-        @_default_per_page ||= Kaminari.config.default_per_page
+        (defined?(@_default_per_page) && @_default_per_page) || Kaminari.config.default_per_page
       end
 
       # Overrides the max +per_page+ value per model
@@ -27,7 +27,21 @@ module Kaminari
       # This model's max +per_page+ value
       # returns +max_per_page+ value unless explicitly overridden via <tt>max_paginates_per</tt>
       def max_per_page
-        @_max_per_page || Kaminari.config.max_per_page
+        (defined?(@_max_per_page) && @_max_per_page) || Kaminari.config.max_per_page
+      end
+
+      # Overrides the max_pages value per model
+      #   class Article < ActiveRecord::Base
+      #     max_pages_per 100
+      #   end
+      def max_pages_per(val)
+        @_max_pages = val
+      end
+
+      # This model's max_pages value
+      # returns max_pages value unless explicitly overridden via <tt>max_pages_per</tt>
+      def max_pages
+        (defined?(@_max_pages) && @_max_pages) || Kaminari.config.max_pages
       end
     end
   end

data/lib/kaminari/models/data_mapper_collection_methods.rb

@@ -1,5 +1,9 @@
 module Kaminari
   module DataMapperCollectionMethods
+    def entry_name
+      model.model_name.human.downcase
+    end
+
     def limit_value #:nodoc:
       query.options[:limit] || 0
     end

data/lib/kaminari/models/data_mapper_extension.rb

@@ -5,8 +5,10 @@ module Kaminari
     module Paginatable
       class_eval <<-RUBY, __FILE__, __LINE__ + 1
         def #{Kaminari.config.page_method_name}(num = 1)
+          model = self
+          model = self.model if self.is_a? DataMapper::Collection
           num = [num.to_i, 1].max - 1
-          all(:limit => default_per_page, :offset => default_per_page * num).extend Paginating
+          all(:limit => model.default_per_page, :offset => model.default_per_page * num).extend Paginating
         end
       RUBY
     end
@@ -26,9 +28,10 @@ module Kaminari
     module Collection
       extend ActiveSupport::Concern
       included do
-        include Kaminari::ConfigurationMethods::ClassMethods
         include Kaminari::DataMapperCollectionMethods
         include Paginatable
+
+        delegate :default_per_page, :max_per_page, :max_pages, :to => :model
       end
     end
 

data/lib/kaminari/models/mongoid_criteria_methods.rb

@@ -1,5 +1,14 @@
 module Kaminari
   module MongoidCriteriaMethods
+    def initialize_copy(other) #:nodoc:
+      @total_count = nil
+      super
+    end
+
+    def entry_name
+      model_name.human.downcase
+    end
+
     def limit_value #:nodoc:
       options[:limit]
     end
@@ -9,7 +18,15 @@ module Kaminari
     end
 
     def total_count #:nodoc:
-      embedded? ? unpage.count : count
+      @total_count ||= if embedded?
+        unpage.count
+      else
+        if options[:max_scan] && options[:max_scan] < count
+          options[:max_scan]
+        else
+          count
+        end
+      end
     end
 
     private

data/lib/kaminari/models/mongoid_extension.rb

@@ -2,32 +2,25 @@ require 'kaminari/models/mongoid_criteria_methods'
 
 module Kaminari
   module MongoidExtension
-    module Criteria
-      extend ActiveSupport::Concern
-
-      included do
-        class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def #{Kaminari.config.page_method_name}(*args)
-            super(*args).criteria.merge(self)
-          end
-        RUBY
-      end
-    end
-
     module Document
       extend ActiveSupport::Concern
       include Kaminari::ConfigurationMethods
 
       included do
-        # Fetch the values at the specified page number
-        #   Model.page(5)
         scope Kaminari.config.page_method_name, Proc.new {|num|
-          limit(default_per_page).offset(default_per_page * ([num.to_i, 1].max - 1))
+          limit(default_per_page).offset(default_per_page * ((num = num.to_i - 1) < 0 ? 0 : num))
         } do
           include Kaminari::MongoidCriteriaMethods
           include Kaminari::PageScopeMethods
         end
       end
+
+      module ClassMethods
+        def inherited(kls)
+          super
+          kls.send(:include, Kaminari::MongoidExtension::Document.dup)
+        end
+      end if Mongoid::VERSION < '5.0.0'
     end
   end
 end

data/lib/kaminari/models/page_scope_methods.rb

@@ -13,22 +13,49 @@ module Kaminari
     end
 
     def padding(num)
+      @_padding = num
       offset(offset_value + num.to_i)
     end
 
     # Total number of pages
     def total_pages
-      (total_count.to_f / limit_value).ceil
+      count_without_padding = total_count
+      count_without_padding -= @_padding if defined?(@_padding) && @_padding
+      count_without_padding = 0 if count_without_padding < 0
+
+      total_pages_count = (count_without_padding.to_f / limit_value).ceil
+      if max_pages.present? && max_pages < total_pages_count
+        max_pages
+      else
+        total_pages_count
+      end
+    end
+
+    def num_pages
+      ActiveSupport::Deprecation.warn 'num_pages is deprecated and will be removed in Kaminari 1.0. Please use total_pages instead.'
+      total_pages
     end
-    #FIXME for compatibility. remove num_pages at some time in the future
-    alias num_pages total_pages
 
     # Current page number
     def current_page
-      (offset_value / limit_value) + 1
+      offset_without_padding = offset_value
+      offset_without_padding -= @_padding if defined?(@_padding) && @_padding
+      offset_without_padding = 0 if offset_without_padding < 0
+
+      (offset_without_padding / limit_value) + 1
     end
 
-    # First page of the collection ?
+    # Next page number in the collection
+    def next_page
+      current_page + 1 unless last_page?
+    end
+
+    # Previous page number in the collection
+    def prev_page
+      current_page - 1 unless first_page?
+    end
+
+    # First page of the collection?
     def first_page?
       current_page == 1
     end
@@ -37,5 +64,10 @@ module Kaminari
     def last_page?
       current_page >= total_pages
     end
+
+    # Out of range of the collection?
+    def out_of_range?
+      current_page > total_pages
+    end
   end
 end

data/lib/kaminari/models/plucky_criteria_methods.rb

@@ -1,7 +1,12 @@
 module Kaminari
   module PluckyCriteriaMethods
     include Kaminari::PageScopeMethods
-    include Kaminari::ConfigurationMethods::ClassMethods
+
+    delegate :default_per_page, :max_per_page, :max_pages, :to => :model
+
+    def entry_name
+      model.model_name.human.downcase
+    end
 
     def limit_value #:nodoc:
       options[:limit]

data/lib/kaminari/railtie.rb

@@ -1,6 +1,6 @@
 module Kaminari
   class Railtie < ::Rails::Railtie #:nodoc:
-    initializer 'kaminari' do |_app|
+    initializer 'kaminari' do
       Kaminari::Hooks.init
     end
   end

data/lib/kaminari/sinatra.rb

@@ -2,4 +2,6 @@ require 'sinatra/base'
 require 'kaminari'
 require 'kaminari/helpers/sinatra_helpers'
 
+ActiveSupport::Deprecation.warn 'Kaminari Sinatra support has been extracted to a separate gem, and will be removed in the next 1.0 release. Please bundle kaminari-sinatra gem.'
+
 Kaminari::Hooks.init