will_paginate 3.1.5 → 3.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 5b9c92a0ce3f9e697334ea1bf11c0b57bdfd9fe2
-  data.tar.gz: b2794b2de86ceaa34f86d06f2c1952484b5409f9
+SHA256:
+  metadata.gz: 3015c2c4a4d84d48b8a9c60a5ad19297e4ccbd515682df95399badb293386536
+  data.tar.gz: d28dd41a8fe68e9f5e43649978cb8a49b8ff03fc6fcdab303c04fcbe654a6894
 SHA512:
-  metadata.gz: fe7a7e48c35bda6cd6648f5243f3992ebe576f586afd5d140066fa05ecdd83862681245f44e554f5483e5dc4fe9f957e3b84b6208cc91a8e1dd1804c8593a49b
-  data.tar.gz: 5c388ced4fd0b8ad3da2ce6c5e9b2323b4cff1b950fdf3b35cc6e148b1e12509e8b6c0b83156b483d1a732ce4fe2497a4c09553b2650775cc922803699bf4347
+  metadata.gz: b6c6843a2f26883a439520ef4106124c1706c8f5deae59c16d1fee074d74a8eb50e39ef3ea8ae8dc0bd6a18331dd618c0f18079f3834b0ebda45a13f050d3f62
+  data.tar.gz: 5479f100b92648394d8074d2d34be19120008955ce5f5e289073eafac35389890f044d4a66fe0e54d5331fc7d6a82c17497fa800f4fee44c743939560a71af8c

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, Merb, DataMapper and Sequel.
 
 ``` ruby
-## Gemfile for Rails 3+, Sinatra, and Merb
 gem 'will_paginate', '~> 3.1.0'
 ```
 
 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.github.io/will_paginate/

data/lib/will_paginate/active_record.rb

@@ -83,7 +83,10 @@ module WillPaginate
           excluded = [:order, :limit, :offset, :reorder]
           excluded << :includes unless eager_loading?
           rel = self.except(*excluded)
-          column_name = (select_for_count(rel) || :all)
+          column_name = if rel.select_values.present?
+            select = rel.select_values.join(", ")
+            select if select !~ /[,*]/
+          end || :all
           rel.count(column_name)
         else
           super(*args)
@@ -102,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
@@ -136,13 +137,6 @@ module WillPaginate
         other.total_entries = nil if defined? @total_entries_queried
         other
       end
-      
-      def select_for_count(rel)
-        if rel.select_values.present?
-          select = rel.select_values.join(", ")
-          select if select !~ /[,*]/
-        end
-      end
     end
 
     module Pagination
@@ -216,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

@@ -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

@@ -3,6 +3,8 @@ en:
     previous_label: "← Previous"
     next_label: "Next →"
     page_gap: "…"
+    container_aria_label: "Pagination"
+    page_aria_label: "Page %{page}"
 
     page_entries_info:
       single_page:

data/lib/will_paginate/mongoid.rb

@@ -8,6 +8,8 @@ module WillPaginate
         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

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'
@@ -39,7 +38,7 @@ module WillPaginate
       end
       def status_code_with_paginate(exception = @exception)
         actual_exception = if exception.respond_to?(:cause)
-          exception.cause
+          exception.cause || exception
         elsif exception.respond_to?(:original_exception)
           exception.original_exception
         else
@@ -60,11 +59,11 @@ 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

data/lib/will_paginate/version.rb

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

data/lib/will_paginate/view_helpers/action_view.rb

@@ -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

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)
+        aria_label = @template.will_paginate_translate(:page_aria_label, :page => page.to_i) { "Page #{page}" }
         if page == current_page
-          tag(:em, page, :class => 'current')
+          tag(:em, page, :class => 'current', :"aria-label" => aria_label, :"aria-current" => 'page')
         else
-          link(page, page, :rel => rel_value(page))
+          link(page, page, :rel => rel_value(page), :"aria-label" => aria_label)
         end
       end
       
@@ -67,7 +71,7 @@ module WillPaginate
         if page
           link(text, page, :class => classname)
         else
-          tag(:span, text, :class => classname + ' disabled')
+          tag(:span, text, :class => classname + ' disabled', :"aria-disabled" => true)
         end
       end
       
@@ -88,7 +92,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

data/spec/database.yml

@@ -3,27 +3,27 @@ sqlite3:
   adapter: sqlite3
   timeout: 500
 
-mysql: &mysql
-  adapter: mysql
+mysql:
+  adapter: mysql2
   database: will_paginate
-  username: 
+  username: <%= ENV["MYSQL_USER"] || "root" %>
   encoding: utf8
-<% if File.exist?("/var/run/mysql5/mysqld.sock") %>
+<% if ENV["MYSQL_PORT"] %>
+  host: <%= ENV["MYSQL_HOST"] %>
+  port: <%= ENV["MYSQL_PORT"] %>
+<% elsif File.exist?("/var/run/mysql5/mysqld.sock") %>
   host: localhost
   socket: /var/run/mysql5/mysqld.sock
 <% elsif File.exist? "/tmp/mysql.sock" %>
   host: localhost
   socket: /tmp/mysql.sock
-<% else %>
-  host: 127.0.0.1
 <% end %>
 
-mysql2:
-  <<: *mysql
-  adapter: mysql2
-
 postgres:
   adapter: postgresql
   database: will_paginate
-  username: <%= "postgres" if ENV["TRAVIS"] %>
   min_messages: warning
+  username: <%= ENV["POSTGRES_USER"] %>
+  password: <%= ENV["POSTGRES_PASSWORD"] %>
+  host: <%= ENV["POSTGRES_HOST"] %>
+  port: <%= ENV["POSTGRES_PORT"] %>

data/spec/finders/active_record_spec.rb

@@ -3,7 +3,6 @@ require 'will_paginate/active_record'
 require File.expand_path('../activerecord_test_connector', __FILE__)
 
 ActiverecordTestConnector.setup
-abort unless ActiverecordTestConnector.able_to_connect
 
 describe WillPaginate::ActiveRecord do
   
@@ -164,6 +163,13 @@ describe WillPaginate::ActiveRecord do
       topics.total_entries.should == 999
     end
 
+    it "overrides empty? count call with a total_entries fixed value" do
+      lambda {
+        topics = Topic.paginate :page => 1, :per_page => 3, :total_entries => 999
+        topics.should_not be_empty
+      }.should run_queries(0)
+    end
+
     it "removes :include for count" do
       lambda {
         developers = Developer.paginate(:page => 1, :per_page => 1).includes(:projects)
@@ -214,7 +220,7 @@ describe WillPaginate::ActiveRecord do
         sql = "select content from topics where content like '%futurama%'"
         topics = Topic.paginate_by_sql sql, :page => 1, :per_page => 1
         topics.total_entries.should == 1
-        topics.first.attributes.has_key?('title').should be_false
+        topics.first.attributes.has_key?('title').should be(false)
       }.should run_queries(2)
     end
 
@@ -272,12 +278,12 @@ describe WillPaginate::ActiveRecord do
     }.should run_queries(1)
   end
   
-  it "should get second (inexistent) page of Topics, requiring 2 queries" do
+  it "should get second (inexistent) page of Topics, requiring 1 query" do
     lambda {
       result = Topic.paginate :page => 2
       result.total_pages.should == 1
       result.should be_empty
-    }.should run_queries(2)
+    }.should run_queries(1)
   end
   
   describe "associations" do

data/spec/finders/activerecord_test_connector.rb

@@ -1,20 +1,8 @@
 require 'active_record'
 require 'active_record/fixtures'
-require 'active_support/multibyte' # needed for Ruby 1.9.1
 require 'stringio'
 require 'erb'
 
-# https://travis-ci.org/mislav/will_paginate/jobs/99999001
-require 'active_support/core_ext/string/conversions'
-class String
-  alias to_datetime_without_patch to_datetime
-  def to_datetime
-    to_datetime_without_patch
-  rescue ArgumentError
-    return nil
-  end
-end
-
 $query_count = 0
 $query_sql = []
 
@@ -38,29 +26,20 @@ end
 module ActiverecordTestConnector
   extend self
   
-  attr_accessor :able_to_connect
   attr_accessor :connected
 
   FIXTURES_PATH = File.expand_path('../../fixtures', __FILE__)
 
-  Fixtures = defined?(ActiveRecord::FixtureSet) ? ActiveRecord::FixtureSet :
-             defined?(ActiveRecord::Fixtures) ? ActiveRecord::Fixtures :
-             ::Fixtures
-
   # Set our defaults
   self.connected = false
-  self.able_to_connect = true
 
   def setup
-    unless self.connected || !self.able_to_connect
+    unless self.connected
       setup_connection
       load_schema
       add_load_path FIXTURES_PATH
       self.connected = true
     end
-  rescue Exception => e  # errors from ActiveRecord setup
-    $stderr.puts "\nSkipping ActiveRecord tests: #{e}\n\n"
-    self.able_to_connect = false
   end
 
   private
@@ -95,32 +74,28 @@ module ActiverecordTestConnector
       $stdout = STDOUT
     end
   end
-  
+
   module FixtureSetup
     def fixtures(*tables)
       table_names = tables.map { |t| t.to_s }
 
-      fixtures = Fixtures.create_fixtures ActiverecordTestConnector::FIXTURES_PATH, table_names
+      fixtures = ActiveRecord::FixtureSet.create_fixtures(ActiverecordTestConnector::FIXTURES_PATH, table_names)
       @@loaded_fixtures = {}
       @@fixture_cache = {}
 
       unless fixtures.nil?
-        if fixtures.instance_of?(Fixtures)
-          @@loaded_fixtures[fixtures.table_name] = fixtures
-        else
-          fixtures.each { |f| @@loaded_fixtures[f.table_name] = f }
-        end
+        fixtures.each { |f| @@loaded_fixtures[f.table_name] = f }
       end
 
       table_names.each do |table_name|
-        define_method(table_name) do |*fixtures|
+        define_method(table_name) do |*names|
           @@fixture_cache[table_name] ||= {}
 
-          instances = fixtures.map do |fixture|
-            if @@loaded_fixtures[table_name][fixture.to_s]
-              @@fixture_cache[table_name][fixture] ||= @@loaded_fixtures[table_name][fixture.to_s].find
+          instances = names.map do |name|
+            if @@loaded_fixtures[table_name][name.to_s]
+              @@fixture_cache[table_name][name] ||= @@loaded_fixtures[table_name][name.to_s].find
             else
-              raise StandardError, "No fixture with name '#{fixture}' found for table '#{table_name}'"
+              raise StandardError, "No fixture with name '#{name}' found for table '#{table_name}'"
             end
           end
 

data/spec/page_number_spec.rb

@@ -1,5 +1,6 @@
 require 'spec_helper'
 require 'will_paginate/page_number'
+require 'json'
 
 describe WillPaginate::PageNumber do
   describe "valid" do
@@ -23,12 +24,12 @@ describe WillPaginate::PageNumber do
       (num.is_a? Numeric).should be
     end
 
-    it "is a kind of Fixnum" do
-      (num.is_a? Fixnum).should be
+    it "is a kind of Integer" do
+      (num.is_a? Integer).should be
     end
 
-    it "isn't directly a Fixnum" do
-      (num.instance_of? Fixnum).should_not be
+    it "isn't directly a Integer" do
+      (num.instance_of? Integer).should_not be
     end
 
     it "passes the PageNumber=== type check" do |variable|
@@ -37,7 +38,14 @@ describe WillPaginate::PageNumber do
 
     it "passes the Numeric=== type check" do |variable|
       (Numeric === num).should be
-      (Fixnum === num).should be
+    end
+
+    it "fails the Numeric=== type check" do |variable|
+      (Integer === num).should_not be
+    end
+
+    it "serializes as JSON number" do
+      JSON.dump(page: num).should eq('{"page":12}')
     end
   end
 

data/spec/spec_helper.rb

@@ -1,10 +1,5 @@
 require 'rspec'
 require 'view_helpers/view_example_group'
-begin
-  require 'ruby-debug'
-rescue LoadError
-  # no debugger available
-end
 
 Dir[File.expand_path('../matchers/*_matcher.rb', __FILE__)].each { |matcher| require matcher }
 
@@ -42,5 +37,5 @@ RSpec.configure do |config|
   }
 
   config.mock_with :mocha
-  config.backtrace_clean_patterns << /view_example_group/
+  config.backtrace_exclusion_patterns << /view_example_group/
 end

data/spec/view_helpers/action_view_spec.rb

@@ -1,6 +1,5 @@
 # encoding: utf-8
 require 'spec_helper'
-require 'active_support/rescuable' # needed for Ruby 1.9.1
 require 'action_controller'
 require 'action_view'
 require 'will_paginate/view_helpers/action_view'
@@ -14,7 +13,8 @@ Routes.draw do
   get 'ibocorp(/:page)' => 'ibocorp#index',
         :constraints => { :page => /\d+/ }, :defaults => { :page => 1 }
 
-  get ':controller(/:action(/:id(.:format)))'
+  get 'foo/bar' => 'foo#bar'
+  get 'baz/list' => 'baz#list'
 end
 
 describe WillPaginate::ActionView do
@@ -22,6 +22,8 @@ describe WillPaginate::ActionView do
   before(:all) do
     I18n.load_path.concat WillPaginate::I18n.load_path
     I18n.enforce_available_locales = false
+
+    ActionController::Parameters.permit_all_parameters = false
   end
 
   before(:each) do
@@ -38,7 +40,12 @@ describe WillPaginate::ActionView do
   attr_reader :assigns, :controller, :request
   
   def render(locals)
-    @view = ActionView::Base.new([], @assigns, @controller)
+    lookup_context = []
+    lookup_context = ActionView::LookupContext.new(lookup_context)
+
+    klass = ActionView::Base
+    klass = klass.with_empty_template_cache if klass.respond_to?(:with_empty_template_cache)
+    @view = klass.new(lookup_context, @assigns, @controller)
     @view.request = @request
     @view.singleton_class.send(:include, @controller._routes.url_helpers)
     @view.render(:inline => @template, :locals => locals)
@@ -120,16 +127,20 @@ describe WillPaginate::ActionView do
   it "should match expected markup" do
     paginate
     expected = <<-HTML
-      <div class="pagination"><span class="previous_page disabled">&#8592; Previous</span>
-      <em class="current">1</em>
-      <a href="/foo/bar?page=2" rel="next">2</a>
-      <a href="/foo/bar?page=3">3</a>
+      <div class="pagination" role="navigation" aria-label="Pagination"><span class="previous_page disabled" aria-disabled="true">&#8592; Previous</span>
+      <em class="current" aria-label="Page 1" aria-current="page">1</em>
+      <a href="/foo/bar?page=2" aria-label="Page 2" rel="next">2</a>
+      <a href="/foo/bar?page=3" aria-label="Page 3">3</a>
       <a href="/foo/bar?page=2" class="next_page" rel="next">Next &#8594;</a></div>
     HTML
     expected.strip!.gsub!(/\s{2,}/, ' ')
-    expected_dom = parse_html_document(expected).root
+    expected_dom = parse_html_document(expected)
 
-    html_document.root.should == expected_dom
+    if expected_dom.respond_to?(:canonicalize)
+      html_document.canonicalize.should == expected_dom.canonicalize
+    else
+      html_document.root.should == expected_dom.root
+    end
   end
   
   it "should output escaped URLs" do
@@ -358,6 +369,16 @@ describe WillPaginate::ActionView do
     end
   end
 
+  # TODO: re-enable once Rails 6.1.4 ships
+  xit "page_entries_info" do
+    @template = "<%= page_entries_info collection, options %>"
+    output = render(
+      collection: WillPaginate::Collection.new(1, 1, 3),
+      options: {html: false},
+    )
+    output.should == "Displaying entries 1 - 0 of 3 in total"
+  end
+
   private
 
   def translation(data)
@@ -442,11 +463,7 @@ class DummyRequest
 
   def params(more = nil)
     @params.update(more) if more
-    if defined?(ActionController::Parameters)
-      ActionController::Parameters.new(@params)
-    else
-      @params
-    end
+    ActionController::Parameters.new(@params)
   end
   
   def host_with_port
@@ -462,7 +479,3 @@ class DummyRequest
     'http:'
   end
 end
-
-if defined?(ActionController::Parameters)
-  ActionController::Parameters.permit_all_parameters = false
-end

data/spec/view_helpers/view_example_group.rb

@@ -1,30 +1,13 @@
 require 'active_support'
 require 'stringio'
-begin
-  $stderr = StringIO.new
-  require 'minitest/unit'
-rescue LoadError
-  # Fails on Ruby 1.8, but it's OK since we only need MiniTest::Assertions
-  # on Rails 4 which doesn't support 1.8 anyway.
-ensure
-  $stderr = STDERR
-end
-
-begin
-  require 'rails/dom/testing/assertions'
-rescue LoadError
-  require 'action_dispatch/testing/assertions'
-end
+require 'minitest/assertions'
+require 'rails/dom/testing/assertions'
 require 'will_paginate/array'
 
 module ViewExampleGroup
   
-  if defined?(Rails::Dom::Testing::Assertions)
-    include Rails::Dom::Testing::Assertions::SelectorAssertions
-  else
-    include ActionDispatch::Assertions::SelectorAssertions
-  end
-  include MiniTest::Assertions if defined? MiniTest
+  include Rails::Dom::Testing::Assertions::SelectorAssertions
+  include Minitest::Assertions
 
   def assert(value, message)
     raise message unless value
@@ -50,11 +33,7 @@ module ViewExampleGroup
   end
 
   def parse_html_document(html)
-    @html_document ||= if defined?(Rails::Dom::Testing::Assertions)
-      Nokogiri::HTML::Document.parse(html)
-    else
-      HTML::Document.new(html, true, false)
-    end
+    Nokogiri::HTML::Document.parse(html)
   end
 
   def html_document
@@ -124,23 +103,3 @@ RSpec.configure do |config|
     :file_path => %r{spec/view_helpers/}
   }
 end
-
-module HTML
-  Node.class_eval do
-    def inner_text
-      children.map(&:inner_text).join('')
-    end
-  end
-  
-  Text.class_eval do
-    def inner_text
-      self.to_s
-    end
-  end
-
-  Tag.class_eval do
-    def inner_text
-      childless?? '' : super
-    end
-  end
-end if defined?(HTML)

metadata

@@ -1,18 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: will_paginate
 version: !ruby/object:Gem::Version
-  version: 3.1.5
+  version: 3.3.1
 platform: ruby
 authors:
 - Mislav Marohnić
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-10-15 00:00:00.000000000 Z
+date: 2021-08-12 00:00:00.000000000 Z
 dependencies: []
 description: will_paginate provides a simple API for performing paginated queries
   with Active Record, DataMapper and Sequel, and includes helpers for rendering pagination
-  links in Rails, Sinatra and Merb web apps.
+  links in Rails, Sinatra, Hanami, and Merb web apps.
 email: mislav.marohnic@gmail.com
 executables: []
 extensions: []
@@ -39,6 +39,7 @@ files:
 - lib/will_paginate/version.rb
 - lib/will_paginate/view_helpers.rb
 - lib/will_paginate/view_helpers/action_view.rb
+- lib/will_paginate/view_helpers/hanami.rb
 - lib/will_paginate/view_helpers/link_renderer.rb
 - lib/will_paginate/view_helpers/link_renderer_base.rb
 - lib/will_paginate/view_helpers/merb.rb
@@ -47,14 +48,8 @@ files:
 - spec/console
 - spec/console_fixtures.rb
 - spec/database.yml
-- spec/fake_rubygems.rb
 - spec/finders/active_record_spec.rb
 - spec/finders/activerecord_test_connector.rb
-- spec/finders/data_mapper_spec.rb
-- spec/finders/data_mapper_test_connector.rb
-- spec/finders/mongoid_spec.rb
-- spec/finders/sequel_spec.rb
-- spec/finders/sequel_test_connector.rb
 - spec/fixtures/admin.rb
 - spec/fixtures/developer.rb
 - spec/fixtures/developers_projects.yml
@@ -77,11 +72,16 @@ files:
 - spec/view_helpers/base_spec.rb
 - spec/view_helpers/link_renderer_base_spec.rb
 - spec/view_helpers/view_example_group.rb
-homepage: https://github.com/mislav/will_paginate/wiki
+homepage: https://github.com/mislav/will_paginate
 licenses:
 - MIT
-metadata: {}
-post_install_message: 
+metadata:
+  bug_tracker_uri: https://github.com/mislav/will_paginate/issues
+  changelog_uri: https://github.com/mislav/will_paginate/releases/tag/v3.3.1
+  documentation_uri: https://www.rubydoc.info/gems/will_paginate/3.3.1
+  source_code_uri: https://github.com/mislav/will_paginate/tree/v3.3.1
+  wiki_uri: https://github.com/mislav/will_paginate/wiki
+post_install_message:
 rdoc_options:
 - "--main"
 - README.md
@@ -92,16 +92,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
 summary: Pagination plugin for web frameworks and other apps
 test_files: []

data/spec/fake_rubygems.rb

@@ -1,18 +0,0 @@
-# Makes the test suite compatible with Bundler standalone mode (used in CI)
-# because Active Record uses `gem` for loading adapters.
-Kernel.module_eval do
-
-  remove_method :gem if 'method' == defined? gem
-
-  def gem(*args)
-    return if $VERBOSE.nil?
-    $stderr << "warning: gem(#{args.map {|o| o.inspect }.join(', ')}) ignored"
-    $stderr << "; called from:\n  " << caller[0,5].join("\n  ") if $DEBUG
-    $stderr << "\n"
-  end
-
-  private :gem
-
-end
-
-$" << "rubygems.rb"

data/spec/finders/data_mapper_spec.rb

@@ -1,116 +0,0 @@
-require 'spec_helper'
-
-begin
-  require 'will_paginate/data_mapper'
-  require File.expand_path('../data_mapper_test_connector', __FILE__)
-rescue LoadError => error
-  warn "Error running DataMapper specs: #{error.message}"
-  datamapper_loaded = false
-else
-  datamapper_loaded = true
-end
-
-describe WillPaginate::DataMapper do
-
-  it "has per_page" do
-    Animal.per_page.should == 30
-    begin
-      Animal.per_page = 10
-      Animal.per_page.should == 10
-
-      subclass = Class.new(Animal)
-      subclass.per_page.should == 10
-    ensure
-      Animal.per_page = 30
-    end
-  end
-
-  it "doesn't make normal collections appear paginated" do
-    Animal.all.should_not be_paginated
-  end
-
-  it "paginates to first page by default" do
-    animals = Animal.paginate(:page => nil)
-
-    animals.should be_paginated
-    animals.current_page.should == 1
-    animals.per_page.should == 30
-    animals.offset.should == 0
-    animals.total_entries.should == 3
-    animals.total_pages.should == 1
-  end
-
-  it "paginates to first page, explicit limit" do
-    animals = Animal.paginate(:page => 1, :per_page => 2)
-
-    animals.current_page.should == 1
-    animals.per_page.should == 2
-    animals.total_entries.should == 3
-    animals.total_pages.should == 2
-    animals.map {|a| a.name }.should == %w[ Dog Cat ]
-  end
-
-  it "paginates to second page" do
-    animals = Animal.paginate(:page => 2, :per_page => 2)
-
-    animals.current_page.should == 2
-    animals.offset.should == 2
-    animals.map {|a| a.name }.should == %w[ Lion ]
-  end
-
-  it "paginates a collection" do
-    friends = Animal.all(:notes.like => '%friend%')
-    friends.paginate(:page => 1).per_page.should == 30
-    friends.paginate(:page => 1, :per_page => 1).total_entries.should == 2
-  end
-
-  it "paginates a limited collection" do
-    animals = Animal.all(:limit => 2).paginate(:page => 1)
-    animals.per_page.should == 2
-  end
-
-  it "has page() method" do
-    Animal.page(2).per_page.should == 30
-    Animal.page(2).offset.should == 30
-    Animal.page(2).current_page.should == 2
-    Animal.all(:limit => 2).page(2).per_page.should == 2
-  end
-
-  it "has total_pages at 1 for empty collections" do
-    Animal.all(:conditions => ['1=2']).page(1).total_pages.should == 1
-  end
-
-  it "overrides total_entries count with a fixed value" do
-    lambda {
-      animals = Animal.paginate :page => 1, :per_page => 3, :total_entries => 999
-      animals.total_entries.should == 999
-    }.should run_queries(0)
-  end
-
-  it "supports a non-int for total_entries" do
-    topics = Animal.paginate :page => 1, :per_page => 3, :total_entries => "999"
-    topics.total_entries.should == 999
-  end
-
-
-  it "can iterate and then call WP methods" do
-    animals = Animal.all(:limit => 2).page(1)
-    animals.each { |a| }
-    animals.total_entries.should == 3
-  end
-
-  it "augments to_a to return a WP::Collection" do
-    animals = Animal.all(:limit => 2).page(1)
-    array = animals.to_a
-    array.size.should == 2
-    array.should be_kind_of(WillPaginate::Collection)
-    array.current_page.should == 1
-    array.per_page.should == 2
-  end
-
-  it "doesn't have a problem assigning has-one-through relationship" do
-    human = Human.create :name => "Mislav"
-    human.pet = Animal.first
-  end
-
-end if datamapper_loaded

data/spec/finders/data_mapper_test_connector.rb

@@ -1,54 +0,0 @@
-require 'sqlite3'
-require 'dm-core'
-require 'dm-core/support/logger'
-require 'dm-migrations'
-
-DataMapper.setup :default, 'sqlite3::memory:'
-
-# Define models
-class Animal
-  include DataMapper::Resource
-  property :id, Serial
-  property :name, String
-  property :notes, Text
- 
-  def self.setup
-    Animal.create(:name => 'Dog', :notes => "Man's best friend")
-    Animal.create(:name => 'Cat', :notes => "Woman's best friend")
-    Animal.create(:name => 'Lion', :notes => 'King of the Jungle')
-  end
-end
-
-class Ownership
-  include DataMapper::Resource
-
-  belongs_to :animal, :key => true
-  belongs_to :human, :key => true
-
-  def self.setup
-  end
-end
-
-class Human
-  include DataMapper::Resource
-
-  property :id, Serial
-  property :name, String
-
-  has n, :ownerships
-  has 1, :pet, :model => 'Animal', :through => :ownerships, :via => :animal
-
-  def self.setup
-  end
-end
-
-# Load fixtures
-[Animal, Ownership, Human].each do |klass|
-  klass.auto_migrate!
-  klass.setup
-end
-
-if 'irb' == $0
-  DataMapper.logger.set_log($stdout, :debug)
-  DataMapper.logger.auto_flush = true
-end

data/spec/finders/mongoid_spec.rb

@@ -1,140 +0,0 @@
-require 'spec_helper'
-
-begin
-  require 'will_paginate/mongoid'
-rescue LoadError => error
-  warn "Error running Mongoid specs: #{error.message}"
-  mongoid_loaded = false
-else
-  Mongoid.connect_to 'will_paginate_test'
-
-  class MongoidModel
-    include Mongoid::Document
-  end
-
-  mongoid_loaded = true
-end
-
-describe WillPaginate::Mongoid do
-  before(:all) do
-    MongoidModel.delete_all
-    4.times { MongoidModel.create! }
-  end
-
-  let(:criteria) { MongoidModel.criteria }
-
-  describe "#page" do
-    it "should forward to the paginate method" do
-      criteria.expects(:paginate).with(:page => 2).returns("itself")
-      criteria.page(2).should == "itself"
-    end
-
-    it "should not override per_page if set earlier in the chain" do
-      criteria.paginate(:per_page => 10).page(1).per_page.should == 10
-      criteria.paginate(:per_page => 20).page(1).per_page.should == 20
-    end
-  end
-
-  describe "#per_page" do
-    it "should set the limit if given an argument" do
-      criteria.per_page(10).options[:limit].should == 10
-    end
-
-    it "should return the current limit if no argument is given" do
-      criteria.per_page.should == nil
-      criteria.per_page(10).per_page.should == 10
-    end
-
-    it "should be interchangable with limit" do
-      criteria.limit(15).per_page.should == 15
-    end
-
-    it "should be nil'able" do
-      criteria.per_page(nil).per_page.should be_nil
-    end
-  end
-
-  describe "#paginate" do
-    it "should use criteria" do
-      criteria.paginate.should be_instance_of(::Mongoid::Criteria)
-    end
-
-    it "should not override page number if set earlier in the chain" do
-      criteria.page(3).paginate.current_page.should == 3
-    end
-
-    it "should limit according to per_page parameter" do
-      criteria.paginate(:per_page => 10).options.should include(:limit => 10)
-    end
-
-    it "should skip according to page and per_page parameters" do
-      criteria.paginate(:page => 2, :per_page => 5).options.should include(:skip => 5)
-    end
-
-    specify "first fallback value for per_page option is the current limit" do
-      criteria.limit(12).paginate.options.should include(:limit => 12)
-    end
-
-    specify "second fallback value for per_page option is WillPaginate.per_page" do
-      criteria.paginate.options.should include(:limit => WillPaginate.per_page)
-    end
-
-    specify "page should default to 1" do
-      criteria.paginate.options.should include(:skip => 0)
-    end
-
-    it "should convert strings to integers" do
-      criteria.paginate(:page => "2", :per_page => "3").options.should include(:limit => 3)
-    end
-
-    describe "collection compatibility" do
-      describe "#total_count" do
-        it "should be calculated correctly" do
-          criteria.paginate(:per_page => 1).total_entries.should == 4
-          criteria.paginate(:per_page => 3).total_entries.should == 4
-        end
-
-        it "should be cached" do
-          criteria.expects(:count).once.returns(123)
-          criteria.paginate
-          2.times { criteria.total_entries.should == 123 }
-        end
-      end
-
-      it "should calculate total_pages" do
-        criteria.paginate(:per_page => 1).total_pages.should == 4
-        criteria.paginate(:per_page => 3).total_pages.should == 2
-        criteria.paginate(:per_page => 10).total_pages.should == 1
-      end
-
-      it "should return per_page" do
-        criteria.paginate(:per_page => 1).per_page.should == 1
-        criteria.paginate(:per_page => 5).per_page.should == 5
-      end
-
-      describe "#current_page" do
-        it "should return current_page" do
-          criteria.paginate(:page => 1).current_page.should == 1
-          criteria.paginate(:page => 3).current_page.should == 3
-        end
-
-        it "should be casted to PageNumber" do
-          page = criteria.paginate(:page => 1).current_page
-          (page.instance_of? WillPaginate::PageNumber).should be
-        end
-      end
-
-      it "should return offset" do
-        criteria.paginate(:page => 1).offset.should == 0
-        criteria.paginate(:page => 2, :per_page => 5).offset.should == 5
-        criteria.paginate(:page => 3, :per_page => 10).offset.should == 20
-      end
-
-      it "should not pollute plain mongoid criterias" do
-        %w(total_entries total_pages current_page).each do |method|
-          criteria.should_not respond_to(method)
-        end
-      end
-    end
-  end
-end if mongoid_loaded

data/spec/finders/sequel_spec.rb

@@ -1,67 +0,0 @@
-require 'spec_helper'
-
-begin
-  require 'will_paginate/sequel'
-  require File.expand_path('../sequel_test_connector', __FILE__)
-rescue LoadError, ArgumentError => error
-  warn "Error running Sequel specs: #{error.message}"
-  sequel_loaded = false
-else
-  sequel_loaded = true
-end
-
-describe Sequel::Dataset::Pagination, 'extension' do
-  
-  class Car < Sequel::Model
-  end
-
-  it "should have the #paginate method" do
-    Car.should respond_to(:paginate)
-  end
-
-  it "should NOT have the #paginate_by_sql method" do
-    Car.should_not respond_to(:paginate_by_sql)
-  end
-
-  describe 'pagination' do
-    before(:all) do
-      Car.create(:name => 'Shelby', :notes => "Man's best friend")
-      Car.create(:name => 'Aston Martin', :notes => "Woman's best friend")
-      Car.create(:name => 'Corvette', :notes => 'King of the Jungle')
-    end
-
-    it "should imitate WillPaginate::Collection" do
-      result = Car.paginate(1, 2)
-      
-      result.should_not be_empty
-      result.size.should == 2
-      result.length.should == 2
-      result.total_entries.should == 3
-      result.total_pages.should == 2
-      result.per_page.should == 2
-      result.current_page.should == 1
-    end
-    
-    it "should perform" do
-      Car.paginate(1, 2).all.should == [Car[1], Car[2]]
-    end
-
-    it "should be empty" do
-      result = Car.paginate(3, 2)
-      result.should be_empty
-    end
-    
-    it "should perform with #select and #order" do
-      result = Car.select("name as foo".lit).order(:name).paginate(1, 2).all
-      result.size.should == 2
-      result.first.values[:foo].should == "Aston Martin"
-    end
-
-    it "should perform with #filter" do
-      results = Car.filter(:name => 'Shelby').paginate(1, 2).all
-      results.size.should == 1
-      results.first.should == Car.find(:name => 'Shelby')
-    end
-  end
-
-end if sequel_loaded

data/spec/finders/sequel_test_connector.rb

@@ -1,15 +0,0 @@
-require 'sequel'
-
-Symbol.class_eval do
-  # Active Record calculations tries `as` on some objects but chokes when that
-  # object was a Symbol and it gets a Sequel::SQL::AliasedExpression.
-  undef as if method_defined? :as
-end
-
-db = Sequel.sqlite
-
-db.create_table :cars do
-  primary_key :id, :integer, :auto_increment => true
-  column :name, :text
-  column :notes, :text
-end