kaminari 0.12.4 → 0.13.0

data/lib/kaminari/helpers/paginator.rb

@@ -1,5 +1,8 @@
-require File.join(File.dirname(__FILE__), 'tags')
+require 'active_support/inflector'
+require 'action_view'
+require 'action_view/log_subscriber'
 require 'action_view/context'
+require 'kaminari/helpers/tags'
 
 module Kaminari
   module Helpers
@@ -31,13 +34,28 @@ module Kaminari
       end
 
       # enumerate each page providing PageProxy object as the block parameter
-      def each_page
-        return to_enum(:each_page) unless block_given?
-
-        1.upto(@options[:num_pages]) do |i|
+      # Because of performance reason, this doesn't actually enumerate all pages but pages that are seemingly relevant to the paginator.
+      # "Relevant" pages are:
+      # * pages inside the left outer window plus one for showing the gap tag
+      # * pages inside the inner window plus one on the left plus one on the right for showing the gap tags
+      # * pages inside the right outer window plus one for showing the gap tag
+      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)
         end
       end
+      alias each_page each_relevant_page
+
+      def relevant_pages(options)
+        left_window_plus_one = 1.upto(options[:left] + 1).to_a
+        right_window_plus_one = (options[:num_pages] - options[:right]).upto(options[:num_pages]).to_a
+        inside_window_plus_each_sides = (options[:current_page] - options[:window] - 1).upto(options[:current_page] + options[:window] + 1).to_a
+
+        (left_window_plus_one + inside_window_plus_each_sides + right_window_plus_one).uniq.sort.reject {|x| (x < 1) || (x > options[:num_pages])}
+      end
+      private :relevant_pages
 
       def page_tag(page)
         @last = Page.new @template, @options.merge(:page => page)

data/lib/kaminari/helpers/sinatra_helpers.rb

@@ -0,0 +1,119 @@
+require 'active_support/core_ext/object'
+require 'active_support/core_ext/string'
+
+begin
+
+require 'padrino-helpers'
+module Kaminari::Helpers
+  module SinatraHelpers
+    class << self
+      def registered(app)
+        app.register Padrino::Helpers
+        app.helpers  HelperMethods
+      end
+
+      alias included registered
+    end
+    
+    class ActionViewTemplateProxy
+      def initialize(opts={})
+        @current_path = opts[:current_path]
+        @param_name = (opts[:param_name] || :page).to_sym
+        @current_params = opts[:current_params]
+        @current_params.delete(@param_name)
+      end
+
+      def render(*args)
+        base = ActionView::Base.new.tap do |a|
+          a.view_paths << File.expand_path('../../../../app/views', __FILE__)
+        end
+        base.render(*args)
+      end
+
+      def url_for(params)
+        extra_params = {}
+        if page = params[@param_name] and page != 1
+          extra_params[@param_name] = page
+        end
+        query = @current_params.merge(extra_params)
+        @current_path + (query.empty? ? '' : "?#{query.to_query}")
+      end
+      
+      def params
+        @current_params
+      end
+    end
+  
+    module HelperMethods
+      # A helper that renders the pagination links - for Sinatra.
+      #
+      #   <%= paginate @articles %>
+      #
+      # ==== Options
+      # * <tt>:window</tt> - The "inner window" size (4 by default).
+      # * <tt>:outer_window</tt> - The "outer window" size (0 by default).
+      # * <tt>:left</tt> - The "left outer window" size (0 by default).
+      # * <tt>:right</tt> - The "right outer window" size (0 by default).
+      # * <tt>:params</tt> - url_for parameters for the links (:id, :locale, etc.)
+      # * <tt>:param_name</tt> - parameter name for page number in the links (:page by default)
+      # * <tt>:remote</tt> - Ajax? (false by default)
+      # * <tt>:ANY_OTHER_VALUES</tt> - Any other hash key & values would be directly passed into each tag as :locals value.
+      def paginate(scope, options = {}, &block)
+        current_path = env['PATH_INFO'] rescue nil
+        current_params = Rack::Utils.parse_query(env['QUERY_STRING']).symbolize_keys rescue {}
+        paginator = Kaminari::Helpers::Paginator.new(
+          ActionViewTemplateProxy.new(:current_params => current_params, :current_path => current_path, :param_name => options[:param_name] || Kaminari.config.param_name),
+          options.reverse_merge(:current_page => scope.current_page, :num_pages => scope.num_pages, :per_page => scope.limit_value, :param_name => Kaminari.config.param_name, :remote => false)
+        )
+        paginator.to_s
+      end
+
+      # A simple "Twitter like" pagination link that creates a link to the next page.
+      # Works on Sinatra.
+      #
+      # ==== Examples
+      # Basic usage:
+      #
+      #   <%= link_to_next_page @items, 'Next Page' %>
+      #
+      # Ajax:
+      #
+      #   <%= link_to_next_page @items, 'Next Page', :remote => true %>
+      #
+      # By default, it renders nothing if there are no more results on the next page.
+      # You can customize this output by passing a parameter <tt>:placeholder</tt>.
+      #
+      #   <%= link_to_next_page @items, 'Next Page', :placeholder => %{<span>No More Pages</span>} %>
+      #
+      def link_to_next_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) || ""
+        query = params.merge(param_name => (scope.current_page + 1))
+        unless scope.last_page?
+          link_to name, env['PATH_INFO'] + (query.empty? ? '' : "?#{query.to_query}"), options.merge(:rel => 'next')
+        else
+          placeholder
+        end
+      end
+    end
+  end
+end
+
+if defined? I18n
+  I18n.load_path += Dir.glob(File.expand_path('../../../../config/locales/*.yml', __FILE__))
+end
+
+rescue LoadError
+
+$stderr.puts "[!]You shold 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
+  module SinatraHelper
+    def self.registered(*)
+    end
+  end
+end
+
+end

data/lib/kaminari/hooks.rb

@@ -0,0 +1,35 @@
+module Kaminari
+  class Hooks
+    def self.init!
+      ActiveSupport.on_load(:active_record) do
+        require 'kaminari/models/active_record_extension'
+        ::ActiveRecord::Base.send :include, Kaminari::ActiveRecordExtension
+      end
+
+      if defined? ::Mongoid
+        require 'kaminari/models/mongoid_extension'
+        ::Mongoid::Document.send :include, Kaminari::MongoidExtension::Document
+        ::Mongoid::Criteria.send :include, Kaminari::MongoidExtension::Criteria
+      end
+
+      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
+        ::Plucky::Query.send :include, Kaminari::PageScopeMethods
+      end
+
+      if defined? ::DataMapper
+        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
+      require 'kaminari/models/array_extension'
+
+      ActiveSupport.on_load(:action_view) do
+        ::ActionView::Base.send :include, Kaminari::ActionViewExtension
+      end
+    end
+  end
+end

data/lib/kaminari/models/active_record_extension.rb

@@ -1,24 +1,21 @@
-require File.join(File.dirname(__FILE__), 'active_record_relation_methods')
+require 'kaminari/models/active_record_model_extension'
 
 module Kaminari
   module ActiveRecordExtension
     extend ActiveSupport::Concern
     included do
-      def self.inherited(kls) #:nodoc:
-        super
-
-        kls.class_eval do
-          include Kaminari::ConfigurationMethods
-
-          # Fetch the values at the specified page number
-          #   Model.page(5)
-          scope :page, 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
+      # 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
+      end
+
+      # Existing subclasses pick up the model extension as well
+      self.descendants.each do |kls|
+        kls.send(:include, Kaminari::ActiveRecordModelExtension) if kls.superclass == ActiveRecord::Base
       end
     end
   end

data/lib/kaminari/models/active_record_model_extension.rb

@@ -0,0 +1,20 @@
+require 'kaminari/models/active_record_relation_methods'
+
+module Kaminari
+  module ActiveRecordModelExtension
+    extend ActiveSupport::Concern
+
+    included do
+      self.send(:include, Kaminari::ConfigurationMethods)
+
+      # 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
+    end
+  end
+end

data/lib/kaminari/models/active_record_relation_methods.rb

@@ -1,23 +1,33 @@
 module Kaminari
   module ActiveRecordRelationMethods
-    extend ActiveSupport::Concern
-    module InstanceMethods
-      # 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
-        end
+    # 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
       end
+    end
 
-      def total_count #: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
+    def total_count #: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)
+
+        # a workaround for 3.1.beta1 bug. see: https://github.com/rails/rails/issues/406
+        c = c.reorder nil
+
         # Remove includes only if they are irrelevant
         c = c.except(:includes) unless references_eager_loaded_tables?
-        # .group returns an OrderdHash that responds to #count
-        c = c.count
-        c.respond_to?(:count) ? c.count : c
+
+        # 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
+        else
+          # .group returns an OrderdHash that responds to #count
+          c = c.count
+          c.respond_to?(:count) ? c.count : c
+        end
       end
     end
   end

data/lib/kaminari/models/array_extension.rb

@@ -1,3 +1,4 @@
+require 'active_support/core_ext/module'
 module Kaminari
   # Kind of Array that can paginate
   class PaginatableArray < Array
@@ -5,38 +6,55 @@ module Kaminari
 
     attr_internal_accessor :limit_value, :offset_value
 
-    def initialize(original_array, limit_val = default_per_page, offset_val = 0) #:nodoc:
-      @_original_array, @_limit_value, @_offset_value = original_array, limit_val, offset_val
-      super(original_array[offset_val, limit_val] || [])
+    # ==== Options
+    # * <tt>:limit</tt> - limit
+    # * <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]
+
+      if options[:limit] && options[:offset]
+        class << self
+          include Kaminari::PageScopeMethods
+        end
+      end
+
+      if options[:total_count]
+        super original_array
+      else
+        super(original_array[@_offset_value, @_limit_value] || [])
+      end
     end
 
     # items at the specified "page"
-    def page(num = 1)
-      offset(limit_value * ([num.to_i, 1].max - 1))
-    end
+    class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      def #{Kaminari.config.page_method_name}(num = 1)
+        offset(limit_value * ([num.to_i, 1].max - 1))
+      end
+    RUBY
 
     # returns another chunk of the original array
     def limit(num)
-      self.class.new @_original_array, num, offset_value
+      self.class.new @_original_array, :limit => num, :offset => @_offset_value, :total_count => @_total_count
     end
 
     # total item numbers of the original array
     def total_count
-      @_original_array.count
+      @_total_count || @_original_array.count
     end
 
     # returns another chunk of the original array
     def offset(num)
-      arr = self.class.new @_original_array, limit_value, num
-      class << arr
-        include Kaminari::PageScopeMethods
-      end
-      arr
+      self.class.new @_original_array, :limit => @_limit_value, :offset => num, :total_count => @_total_count
     end
   end
 
   # Wrap an Array object to make it paginatable
-  def self.paginate_array(array)
-    PaginatableArray.new array
+  # ==== Options
+  # * <tt>:limit</tt> - limit
+  # * <tt>:offset</tt> - offset
+  # * <tt>:total_count</tt> - total_count
+  def self.paginate_array(array, options = {})
+    PaginatableArray.new array, options
   end
 end

data/lib/kaminari/models/data_mapper_collection_methods.rb

@@ -0,0 +1,15 @@
+module Kaminari
+  module DataMapperCollectionMethods
+    def limit_value #:nodoc:
+      query.options[:limit] || 0
+    end
+
+    def offset_value #:nodoc:
+      query.options[:offset] || 0
+    end
+
+    def total_count #:nodoc:
+      model.count(query.options.except(:limit, :offset, :order))
+    end
+  end
+end

data/lib/kaminari/models/data_mapper_extension.rb

@@ -0,0 +1,48 @@
+require 'kaminari/models/data_mapper_collection_methods'
+
+module Kaminari
+  module DataMapperExtension
+    module Paginatable
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{Kaminari.config.page_method_name}(num = 1)
+          num = [num.to_i, 1].max - 1
+          all(:limit => default_per_page, :offset => default_per_page * num).extend Paginating
+        end
+      RUBY
+    end
+
+    module Paginating
+      include Kaminari::PageScopeMethods
+
+      def all(options={})
+        super.extend Paginating
+      end
+
+      def per(num)
+        super.extend Paginating
+      end
+    end
+
+    module Collection
+      extend ActiveSupport::Concern
+      included do
+        include Kaminari::ConfigurationMethods::ClassMethods
+        include Kaminari::DataMapperCollectionMethods
+        include Paginatable
+      end
+    end
+
+    module Model
+      include Kaminari::ConfigurationMethods::ClassMethods
+      include Paginatable
+
+      def limit(val)
+        all(:limit => val)
+      end
+
+      def offset(val)
+        all(:offset => val)
+      end
+    end
+  end
+end