will_paginate 3.0.4 → 4.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 95d6a838948c59686c5768a47e8e7e52b99c55868775645285022bc0d7c0e280
+  data.tar.gz: c92449392a8191a656e19d5e722314a2f2c1c50d646f5d98359b0d8193539dd2
+SHA512:
+  metadata.gz: 4511c22cbbf023ab6e32fc457c487ec393c2fdf6f8a3910ee0c0d8385061a98307b6a8a8f02a25af33f9f648f735c5d20d942412b3a7ff5a40d2d7ba67491917
+  data.tar.gz: a062b0bce8e25a24b818b926957b98f970e86b79f89fbb1e2cdfbce382a030d02b3f02800cce6dd1671d84d3251e33879095a1bbe669a7348df90a3664be95ec

data/README.md

@@ -1,25 +1,23 @@
 # will_paginate
 
-will_paginate is a pagination library that integrates with Ruby on Rails, Sinatra, Merb, DataMapper and Sequel.
-
-Installation:
+will_paginate is a pagination library that integrates with Ruby on Rails, Sinatra, Hanami::View, and Sequel.
 
 ``` ruby
-## Gemfile for Rails 3, Sinatra, and Merb
-gem 'will_paginate', '~> 3.0'
+gem 'will_paginate', '~> 3.3'
 ```
 
 See [installation instructions][install] on the wiki for more info.
 
+ℹ️ will_paginate is now in _maintenance mode_ and it will not be receiving new features. [See alternatives](https://www.ruby-toolbox.com/categories/pagination)
 
 ## Basic will_paginate use
 
 ``` ruby
 ## perform a paginated query:
-@posts = Post.paginate(:page => params[:page])
+@posts = Post.paginate(page: params[:page])
 
 # or, use an explicit "per page" limit:
-Post.paginate(:page => params[:page], :per_page => 30)
+Post.paginate(page: params[:page], per_page: 30)
 
 ## render page links in the view:
 <%= will_paginate @posts %>
@@ -49,13 +47,12 @@ Post.where(:published => true).paginate(:page => params[:page]).order('id DESC')
 Post.page(params[:page]).order('created_at DESC')
 ```
 
-See [the wiki][wiki] for more documentation. [Ask on the group][group] if you have usage questions. [Report bugs][issues] on GitHub.
+See [the wiki][wiki] for more documentation. [Report bugs][issues] on GitHub.
 
 Happy paginating.
 
 
 [wiki]: https://github.com/mislav/will_paginate/wiki
 [install]: https://github.com/mislav/will_paginate/wiki/Installation "will_paginate installation"
-[group]: http://groups.google.com/group/will_paginate "will_paginate discussion and support group"
 [issues]: https://github.com/mislav/will_paginate/issues
-[css]: http://mislav.uniqpath.com/will_paginate/
+[css]: http://mislav.github.io/will_paginate/

data/lib/will_paginate/active_record.rb

@@ -21,7 +21,7 @@ module WillPaginate
       include WillPaginate::CollectionMethods
 
       attr_accessor :current_page
-      attr_writer :total_entries, :wp_count_options
+      attr_writer :total_entries
 
       def per_page(value = nil)
         if value.nil? then limit_value
@@ -51,8 +51,8 @@ module WillPaginate
       end
 
       # fix for Rails 3.0
-      def find_last
-        if !loaded? and offset_value || limit_value
+      def find_last(*args)
+        if !loaded? && args.empty? && (offset_value || limit_value)
           @last ||= to_a.last
         else
           super
@@ -78,16 +78,18 @@ module WillPaginate
         end
       end
 
-      def count
+      def count(*args)
         if limit_value
-          excluded = [:order, :limit, :offset]
+          excluded = [:order, :limit, :offset, :reorder]
           excluded << :includes unless eager_loading?
           rel = self.except(*excluded)
-          # TODO: hack. decide whether to keep
-          rel = rel.apply_finder_options(@wp_count_options) if defined? @wp_count_options
-          rel.count
+          column_name = if rel.select_values.present?
+            select = rel.select_values.join(", ")
+            select if select !~ /[,*]/
+          end || :all
+          rel.count(column_name)
         else
-          super
+          super(*args)
         end
       end
 
@@ -103,9 +105,7 @@ module WillPaginate
       # overloaded to be pagination-aware
       def empty?
         if !loaded? and offset_value
-          result = count
-          result = result.size if result.respond_to?(:size) and !result.is_a?(Integer)
-          result <= offset_value
+          total_entries <= offset_value
         else
           super
         end
@@ -135,7 +135,6 @@ module WillPaginate
       def copy_will_paginate_data(other)
         other.current_page = current_page unless other.current_page
         other.total_entries = nil if defined? @total_entries_queried
-        other.wp_count_options = @wp_count_options if defined? @wp_count_options
         other
       end
     end
@@ -144,15 +143,15 @@ module WillPaginate
       def paginate(options)
         options  = options.dup
         pagenum  = options.fetch(:page) { raise ArgumentError, ":page parameter required" }
+        options.delete(:page)
         per_page = options.delete(:per_page) || self.per_page
         total    = options.delete(:total_entries)
 
-        count_options = options.delete(:count)
-        options.delete(:page)
+        if options.any?
+          raise ArgumentError, "unsupported parameters: %p" % options.keys
+        end
 
         rel = limit(per_page.to_i).page(pagenum)
-        rel = rel.apply_finder_options(options) if options.any?
-        rel.wp_count_options = count_options    if count_options
         rel.total_entries = total.to_i          unless total.blank?
         rel
       end
@@ -211,6 +210,8 @@ module WillPaginate
                 WHERE rownum <= #{pager.offset + pager.per_page}
               ) WHERE rnum >= #{pager.offset}
             SQL
+          elsif (self.connection.adapter_name =~ /^sqlserver/i)
+            query << " OFFSET #{pager.offset} ROWS FETCH NEXT #{pager.per_page} ROWS ONLY"
           else
             query << " LIMIT #{pager.per_page} OFFSET #{pager.offset}"
           end

data/lib/will_paginate/deprecation.rb

@@ -10,7 +10,7 @@ module WillPaginate::Deprecation
     private
 
     def rails_logger
-      defined?(Rails) && Rails.logger
+      defined?(Rails.logger) && Rails.logger
     end
 
     def origin_of_call(stack)
@@ -31,8 +31,8 @@ module WillPaginate::Deprecation
       super
     end
 
-    def deprecate_key(*keys)
-      message = block_given? ? Proc.new : keys.pop
+    def deprecate_key(*keys, &block)
+      message = block_given? ? block : keys.pop
       Array(keys).each { |key| @deprecated[key] = message }
     end
 

data/lib/will_paginate/i18n.rb

@@ -8,11 +8,11 @@ module WillPaginate
       Dir["#{locale_dir}/*.{rb,yml}"]
     end
 
-    def will_paginate_translate(keys, options = {})
+    def will_paginate_translate(keys, options = {}, &block)
       if defined? ::I18n
         defaults = Array(keys).dup
-        defaults << Proc.new if block_given?
-        ::I18n.translate(defaults.shift, options.merge(:default => defaults, :scope => :will_paginate))
+        defaults << block if block_given?
+        ::I18n.translate(defaults.shift, **options.merge(:default => defaults, :scope => :will_paginate))
       else
         key = Array === keys ? keys.first : keys
         yield key, options

data/lib/will_paginate/locale/en.yml

@@ -1,8 +1,12 @@
 en:
   will_paginate:
     previous_label: "← Previous"
+    previous_aria_label: "Previous page"
     next_label: "Next →"
+    next_aria_label: "Next page"
     page_gap: "…"
+    container_aria_label: "Pagination"
+    page_aria_label: "Page %{page}"
 
     page_entries_info:
       single_page:

data/lib/will_paginate/mongoid.rb

@@ -0,0 +1,48 @@
+require 'mongoid'
+require 'will_paginate/collection'
+
+module WillPaginate
+  module Mongoid
+    module CriteriaMethods
+      def paginate(options = {})
+        extend CollectionMethods
+        @current_page = WillPaginate::PageNumber(options[:page] || @current_page || 1)
+        @page_multiplier = current_page - 1
+        @total_entries = options.delete(:total_entries)
+
+        pp = (options[:per_page] || per_page || WillPaginate.per_page).to_i
+        limit(pp).skip(@page_multiplier * pp)
+      end
+
+      def per_page(value = :non_given)
+        if value == :non_given
+          options[:limit] == 0 ? nil : options[:limit] # in new Mongoid versions a nil limit is saved as 0
+        else
+          limit(value)
+        end
+      end
+
+      def page(page)
+        paginate(:page => page)
+      end
+    end
+
+    module CollectionMethods
+      attr_reader :current_page
+
+      def total_entries
+        @total_entries ||= count
+      end
+
+      def total_pages
+        (total_entries / per_page.to_f).ceil
+      end
+
+      def offset
+        @page_multiplier * per_page
+      end
+    end
+
+    ::Mongoid::Criteria.send(:include, CriteriaMethods)
+  end
+end

data/lib/will_paginate/page_number.rb

@@ -1,4 +1,3 @@
-require 'delegate'
 require 'forwardable'
 
 module WillPaginate
@@ -6,7 +5,7 @@ module WillPaginate
   module InvalidPage; end
 
   # integer representing a page number
-  class PageNumber < DelegateClass(Integer)
+  class PageNumber < Numeric
     # a value larger than this is not supported in SQL queries
     BIGINT = 9223372036854775807
 
@@ -18,13 +17,17 @@ module WillPaginate
         raise RangeError, "invalid #{name}: #{value.inspect}"
       end
       @name = name
-      super(value)
+      @value = value
     rescue ArgumentError, TypeError, RangeError => error
       error.extend InvalidPage
       raise error
     end
 
-    alias_method :to_i, :__getobj__
+    def to_i
+      @value
+    end
+
+    def_delegators :@value, :coerce, :==, :<=>, :to_s, :+, :-, :*, :/, :to_json
 
     def inspect
       "#{@name} #{to_i}"
@@ -40,13 +43,6 @@ module WillPaginate
     alias is_a? kind_of?
   end
 
-  # Ultrahax: makes `Fixnum === current_page` checks pass
-  Numeric.extend Module.new {
-    def ===(obj)
-      obj.instance_of? PageNumber or super
-    end
-  }
-
   # An idemptotent coercion method
   def self.PageNumber(value, name = 'page')
     case value

data/lib/will_paginate/railtie.rb

@@ -1,4 +1,3 @@
-require 'will_paginate'
 require 'will_paginate/page_number'
 require 'will_paginate/collection'
 require 'will_paginate/i18n'
@@ -18,8 +17,6 @@ module WillPaginate
         require 'will_paginate/view_helpers/action_view'
       end
 
-      self.class.add_locale_path config
-
       # early access to ViewHelpers.pagination_options
       require 'will_paginate/view_helpers'
     end
@@ -31,19 +28,24 @@ module WillPaginate
       ActionController::Base.extend ControllerRescuePatch
     end
 
-    def self.add_locale_path(config)
-      config.i18n.railties_load_path.unshift(*WillPaginate::I18n.load_path)
-    end
-
     # Extending the exception handler middleware so it properly detects
     # WillPaginate::InvalidPage regardless of it being a tag module.
     module ShowExceptionsPatch
       extend ActiveSupport::Concern
-      included { alias_method_chain :status_code, :paginate }
+      included do
+        alias_method :status_code_without_paginate, :status_code
+        alias_method :status_code, :status_code_with_paginate
+      end
       def status_code_with_paginate(exception = @exception)
-        if exception.is_a?(WillPaginate::InvalidPage) or
-            (exception.respond_to?(:original_exception) &&
-              exception.original_exception.is_a?(WillPaginate::InvalidPage))
+        actual_exception = if exception.respond_to?(:cause)
+          exception.cause || exception
+        elsif exception.respond_to?(:original_exception)
+          exception.original_exception
+        else
+          exception
+        end
+
+        if actual_exception.is_a?(WillPaginate::InvalidPage)
           Rack::Utils.status_code(:not_found)
         else
           original_method = method(:status_code_without_paginate)
@@ -57,12 +59,16 @@ module WillPaginate
     end
 
     module ControllerRescuePatch
-      def rescue_from(*args, &block)
+      def rescue_from(*args, **kwargs, &block)
         if idx = args.index(WillPaginate::InvalidPage)
           args[idx] = args[idx].name
         end
-        super(*args, &block)
+        super(*args, **kwargs, &block)
       end
     end
   end
 end
+
+ActiveSupport.on_load :i18n do
+  I18n.load_path.concat(WillPaginate::I18n.load_path)
+end

data/lib/will_paginate/version.rb

@@ -1,8 +1,8 @@
 module WillPaginate #:nodoc:
   module VERSION #:nodoc:
-    MAJOR = 3
+    MAJOR = 4
     MINOR = 0
-    TINY  = 4
+    TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/lib/will_paginate/view_helpers/action_view.rb

@@ -30,7 +30,7 @@ module WillPaginate
       options = options.symbolize_keys
       options[:renderer] ||= LinkRenderer
 
-      super(collection, options).try(:html_safe)
+      super(collection, options)
     end
 
     def page_entries_info(collection = nil, options = {}) #:nodoc:
@@ -43,7 +43,7 @@ module WillPaginate
     # Wrapper for rendering pagination links at both top and bottom of a block
     # of content.
     # 
-    #   <% paginated_section @posts do %>
+    #   <%= paginated_section @posts do %>
     #     <ol id="posts">
     #       <% for post in @posts %>
     #         <li> ... </li>
@@ -80,7 +80,7 @@ module WillPaginate
           defaults = nil
           key = keys
         end
-        translate(key, options.merge(:default => defaults, :scope => :will_paginate))
+        translate(key, **options.merge(:default => defaults, :scope => :will_paginate))
       else
         super
       end
@@ -99,6 +99,8 @@ module WillPaginate
     class LinkRenderer < ViewHelpers::LinkRenderer
       protected
 
+      GET_PARAMS_BLACKLIST = [:script_name, :original_script_name]
+
       def default_url_params
         {}
       end
@@ -106,6 +108,7 @@ module WillPaginate
       def url(page)
         @base_url_params ||= begin
           url_params = merge_get_params(default_url_params)
+          url_params[:only_path] = true
           merge_optional_params(url_params)
         end
 
@@ -116,8 +119,12 @@ module WillPaginate
       end
 
       def merge_get_params(url_params)
-        if @template.respond_to? :request and @template.request and @template.request.get?
-          symbolized_update(url_params, @template.params)
+        if @template.respond_to?(:request) and @template.request
+          if @template.request.get?
+            symbolized_update(url_params, @template.params, GET_PARAMS_BLACKLIST)
+          elsif @template.request.respond_to?(:query_parameters)
+            symbolized_update(url_params, @template.request.query_parameters, GET_PARAMS_BLACKLIST)
+          end
         end
         url_params
       end

data/lib/will_paginate/view_helpers/hanami.rb

@@ -0,0 +1,41 @@
+require 'hanami/view'
+require 'will_paginate/view_helpers'
+require 'will_paginate/view_helpers/link_renderer'
+
+module WillPaginate
+  module Hanami
+    module Helpers
+      include ViewHelpers
+
+      def will_paginate(collection, options = {}) #:nodoc:
+        options = options.merge(:renderer => LinkRenderer) unless options[:renderer]
+        str = super(collection, options)
+        str && raw(str)
+      end
+    end
+
+    class LinkRenderer < ViewHelpers::LinkRenderer
+      protected
+
+      def url(page)
+        str = File.join(request_env['SCRIPT_NAME'].to_s, request_env['PATH_INFO'])
+        params = request_env['rack.request.query_hash'].merge(param_name.to_s => page.to_s)
+        params.update @options[:params] if @options[:params]
+        str << '?' << build_query(params)
+      end
+
+      def request_env
+        @template.params.env
+      end
+
+      def build_query(params)
+        Rack::Utils.build_nested_query params
+      end
+    end
+
+    def self.included(base)
+      base.include Helpers
+    end
+
+  end
+end

data/lib/will_paginate/view_helpers/link_renderer.rb

@@ -24,7 +24,7 @@ module WillPaginate
       # method as you see fit.
       def to_html
         html = pagination.map do |item|
-          item.is_a?(Fixnum) ?
+          item.is_a?(Integer) ?
             page_number(item) :
             send(item)
         end.join(@options[:link_separator])
@@ -35,16 +35,20 @@ module WillPaginate
       # Returns the subset of +options+ this instance was initialized with that
       # represent HTML attributes for the container element of pagination links.
       def container_attributes
-        @container_attributes ||= @options.except(*(ViewHelpers.pagination_options.keys + [:renderer] - [:class]))
+        @container_attributes ||= {
+          :role => 'navigation',
+          :"aria-label" => @template.will_paginate_translate(:container_aria_label) { 'Pagination' }
+        }.update @options.except(*(ViewHelpers.pagination_options.keys + [:renderer] - [:class]))
       end
       
     protected
     
       def page_number(page)
-        unless page == current_page
-          link(page, page, :rel => rel_value(page))
+        aria_label = @template.will_paginate_translate(:page_aria_label, :page => page.to_i) { "Page #{page}" }
+        if page == current_page
+          tag(:em, page, :class => 'current', :"aria-label" => aria_label, :"aria-current" => 'page')
         else
-          tag(:em, page, :class => 'current')
+          link(page, page, :rel => rel_value(page), :"aria-label" => aria_label)
         end
       end
       
@@ -55,19 +59,21 @@ module WillPaginate
       
       def previous_page
         num = @collection.current_page > 1 && @collection.current_page - 1
-        previous_or_next_page(num, @options[:previous_label], 'previous_page')
+        aria_label = @template.will_paginate_translate(:previous_aria_label) { "Previous page" }
+        previous_or_next_page(num, @options[:previous_label], 'previous_page', aria_label)
       end
       
       def next_page
         num = @collection.current_page < total_pages && @collection.current_page + 1
-        previous_or_next_page(num, @options[:next_label], 'next_page')
+        aria_label = @template.will_paginate_translate(:next_aria_label) { "Next page" }
+        previous_or_next_page(num, @options[:next_label], 'next_page', aria_label)
       end
       
-      def previous_or_next_page(page, text, classname)
+      def previous_or_next_page(page, text, classname, aria_label = nil)
         if page
-          link(text, page, :class => classname)
+          link(text, page, :class => classname, :'aria-label' => aria_label)
         else
-          tag(:span, text, :class => classname + ' disabled')
+          tag(:span, text, :class => classname + ' disabled', :'aria-label' => aria_label)
         end
       end
       
@@ -88,7 +94,7 @@ module WillPaginate
       end
 
       def link(text, target, attributes = {})
-        if target.is_a? Fixnum
+        if target.is_a?(Integer)
           attributes[:rel] = rel_value(target)
           target = url(target)
         end
@@ -108,18 +114,18 @@ module WillPaginate
 
       def rel_value(page)
         case page
-        when @collection.current_page - 1; 'prev' + (page == 1 ? ' start' : '')
+        when @collection.current_page - 1; 'prev'
         when @collection.current_page + 1; 'next'
-        when 1; 'start'
         end
       end
 
-      def symbolized_update(target, other)
-        other.each do |key, value|
+      def symbolized_update(target, other, blacklist = nil)
+        other.each_pair do |key, value|
           key = key.to_sym
           existing = target[key]
-          
-          if value.is_a?(Hash) and (existing.is_a?(Hash) or existing.nil?)
+          next if blacklist && blacklist.include?(key)
+
+          if value.respond_to?(:each_pair) and (existing.is_a?(Hash) or existing.nil?)
             symbolized_update(existing || (target[key] = {}), value)
           else
             target[key] = value

data/lib/will_paginate/view_helpers/link_renderer_base.rb

@@ -30,7 +30,7 @@ module WillPaginate
         window_from = current_page - inner_window
         window_to = current_page + inner_window
         
-        # adjust lower or upper limit if other is out of bounds
+        # adjust lower or upper limit if either is out of bounds
         if window_to > total_pages
           window_from -= window_to - total_pages
           window_to = total_pages

data/lib/will_paginate/view_helpers.rb

@@ -91,7 +91,9 @@ module WillPaginate
       end
       # render HTML for pagination
       renderer.prepare collection, options, self
-      renderer.to_html
+      output = renderer.to_html
+      output = output.html_safe if output.respond_to?(:html_safe)
+      output
     end
 
     # Renders a message containing number of displayed vs. total entries.

data/lib/will_paginate.rb

@@ -8,18 +8,6 @@ elsif defined?(Rails::Initializer)
   raise "will_paginate 3.0 is not compatible with Rails 2.3 or older"
 end
 
-if defined?(Merb::AbstractController)
-  require 'will_paginate/view_helpers/merb'
-
-  Merb::BootLoader.before_app_loads do
-    adapters = { :datamapper => 'data_mapper', :activerecord => 'active_record', :sequel => 'sequel' }
-    # auto-load the right ORM adapter
-    if adapter = adapters[Merb.orm]
-      require "will_paginate/#{adapter}"
-    end
-  end
-end
-
 if defined?(Sinatra) and Sinatra.respond_to? :register
   require 'will_paginate/view_helpers/sinatra'
 end