will_paginate 3.0.12 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 70f44a0574db4ec78958041e6299452b35c6e4bf
-  data.tar.gz: 165a02112371349602d70cca5ce0d5c583e802bb
+  metadata.gz: b3445d24047dd419909e314bc5f1b9eb3fdb7f73
+  data.tar.gz: 2e6ce5705bc95b523bdd8a7ffa9d8e0b35acc36f
 SHA512:
-  metadata.gz: 3e994750be209050697215a4f92b952760ec1be7e1d1bb05afb5fed986e3a3adf6e7417804bc77eeb730a67958d0bb8e02409a072b2b59438bf6e86d4f07d16c
-  data.tar.gz: f7730e8cdf54c6e679cd74ef71c909768927be6ea5e38be32396e5df13fb954787b22b3faa323ef634b857dca1d7bdaa6ae7bab835736019457450cd7d694d78
+  metadata.gz: bdc9b0d1f20379dc1df3dc503796834b329976c90a63f4e0f14b77152aef8721bea240f850d0abc0c0171a3e1ad10d5c88a354136e47d4bb933b29a205311d7d
+  data.tar.gz: c35edfea8e81e70fef045d9f1c3c32bea89723a1bd74a6c2edb438c62fc54c3356eb4704329c42b35760178c71a505ee0d86c0109a6f7cd3fdacd5276af4eb74

data/README.md

@@ -58,4 +58,4 @@ Happy paginating.
 [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

@@ -2,11 +2,6 @@ require 'will_paginate/per_page'
 require 'will_paginate/page_number'
 require 'will_paginate/collection'
 require 'active_record'
-begin
-  require 'active_record/deprecated_finders'
-rescue LoadError
-  # only for Rails 4.1
-end
 
 module WillPaginate
   # = Paginating finders for ActiveRecord models
@@ -26,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
@@ -88,9 +83,6 @@ module WillPaginate
           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
-          
           column_name = (select_for_count(rel) || :all)
           rel.count(column_name)
         else
@@ -142,7 +134,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
       
@@ -158,15 +149,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

data/lib/will_paginate/data_mapper.rb

@@ -21,11 +21,15 @@ module WillPaginate
         options  = options.dup
         pagenum  = options.fetch(:page) { raise ArgumentError, ":page parameter required" }
         per_page = options.delete(:per_page) || self.per_page
+        total    = options.delete(:total_entries)
 
         options.delete(:page)
         options[:limit] = per_page.to_i
 
-        all(options).page(pagenum)
+
+        col = all(options).page(pagenum)
+        col.total_entries = total.to_i unless total.nil? || (total.kind_of?(String) && total.strip.empty?)
+        col
       end
     end
 
@@ -33,6 +37,7 @@ module WillPaginate
       include WillPaginate::CollectionMethods
 
       attr_accessor :current_page
+      attr_writer :total_entries
 
       def paginated?
         !current_page.nil?

data/lib/will_paginate/mongoid.rb

@@ -0,0 +1,46 @@
+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
+        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/railtie.rb

@@ -18,6 +18,8 @@ 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
@@ -29,6 +31,10 @@ module WillPaginate
       ActionController::Base.extend ControllerRescuePatch
     end
 
+    def self.add_locale_path(config)
+      config.i18n.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
@@ -38,15 +44,9 @@ module WillPaginate
         alias_method :status_code, :status_code_with_paginate
       end
       def status_code_with_paginate(exception = @exception)
-        actual_exception = if exception.respond_to?(:cause)
-          exception.cause
-        elsif exception.respond_to?(:original_exception)
-          exception.original_exception
-        else
-          exception
-        end
-
-        if actual_exception.is_a?(WillPaginate::InvalidPage)
+        if exception.is_a?(WillPaginate::InvalidPage) or
+            (exception.respond_to?(:original_exception) &&
+              exception.original_exception.is_a?(WillPaginate::InvalidPage))
           Rack::Utils.status_code(:not_found)
         else
           original_method = method(:status_code_without_paginate)
@@ -69,7 +69,3 @@ module WillPaginate
     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
-    MINOR = 0
-    TINY  = 12
+    MINOR = 1
+    TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/lib/will_paginate/view_helpers/action_view.rb

@@ -99,8 +99,6 @@ module WillPaginate
     class LinkRenderer < ViewHelpers::LinkRenderer
       protected
 
-      GET_PARAMS_BLACKLIST = [:script_name, :original_script_name]
-
       def default_url_params
         {}
       end
@@ -120,7 +118,7 @@ module WillPaginate
 
       def merge_get_params(url_params)
         if @template.respond_to? :request and @template.request and @template.request.get?
-          symbolized_update(url_params, @template.params, GET_PARAMS_BLACKLIST)
+          symbolized_update(url_params, @template.params)
         end
         url_params
       end

data/lib/will_paginate/view_helpers/link_renderer.rb

@@ -108,17 +108,17 @@ module WillPaginate
 
       def rel_value(page)
         case page
-        when @collection.current_page - 1; 'prev'
+        when @collection.current_page - 1; 'prev' + (page == 1 ? ' start' : '')
         when @collection.current_page + 1; 'next'
+        when 1; 'start'
         end
       end
 
-      def symbolized_update(target, other, blacklist = nil)
+      def symbolized_update(target, other)
         other.each do |key, value|
           key = key.to_sym
           existing = target[key]
-          next if blacklist && blacklist.include?(key)
-
+          
           if value.is_a?(Hash) and (existing.is_a?(Hash) or existing.nil?)
             symbolized_update(existing || (target[key] = {}), value)
           else

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 either is out of bounds
+        # adjust lower or upper limit if other is out of bounds
         if window_to > total_pages
           window_from -= window_to - total_pages
           window_to = total_pages

data/spec/database.yml

@@ -3,27 +3,23 @@ sqlite3:
   adapter: sqlite3
   timeout: 500
 
-mysql: &mysql
+mysql:
   adapter: mysql
   database: will_paginate
   username: 
   encoding: utf8
-<% if 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 %>
+  socket: <%= ENV["BOXEN_MYSQL_SOCKET"] %>
 
 mysql2:
-  <<: *mysql
   adapter: mysql2
+  database: will_paginate
+  username: 
+  encoding: utf8
+  socket: <%= ENV["BOXEN_MYSQL_SOCKET"] %>
 
 postgres:
   adapter: postgresql
   database: will_paginate
   username: <%= "postgres" if ENV["TRAVIS"] %>
   min_messages: warning
+  port: <%= ENV["BOXEN_POSTGRESQL_PORT"] %>

data/spec/finders/active_record_spec.rb

@@ -104,13 +104,6 @@ describe WillPaginate::ActiveRecord do
       rel.last(2).should == users(:dev_7, :dev_8)
       rel.page(3).last.should == users(:poor_jamis)
     end
-
-    it "keeps pagination data after 'scoped'" do
-      rel = Developer.page(2).scoped
-      rel.per_page.should == 10
-      rel.offset.should == 10
-      rel.current_page.should == 2
-    end
   end
 
   describe "counting" do
@@ -136,15 +129,6 @@ describe WillPaginate::ActiveRecord do
       }.should run_queries(2)
     end
 
-    it "remembers custom count options in sub-relations" do
-      topics = Topic.paginate :page => 1, :per_page => 3, :count => {:conditions => "title LIKE '%futurama%'"}
-      topics.total_entries.should == 1
-      topics.length.should == 3
-      lambda {
-        topics.order('id').total_entries.should == 1
-      }.should run_queries(1)
-    end
-
     it "supports empty? method" do
       topics = Topic.paginate :page => 1, :per_page => 3
       lambda {
@@ -250,10 +234,11 @@ describe WillPaginate::ActiveRecord do
     end
 
     it "should strip the order when counting" do
+      expected = topics(:ar)
       lambda {
         sql = "select id, title, content from topics order by topics.title"
         topics = Topic.paginate_by_sql sql, :page => 1, :per_page => 2
-        topics.first.should == topics(:ar)
+        topics.first.should == expected
       }.should run_queries(2)
 
       $query_sql.last.should include('COUNT')
@@ -295,78 +280,7 @@ describe WillPaginate::ActiveRecord do
     }.should run_queries(2)
   end
   
-  it "should paginate with :order" do
-    result = Topic.paginate :page => 1, :order => 'created_at DESC'
-    result.should == topics(:futurama, :harvey_birdman, :rails, :ar).reverse
-    result.total_pages.should == 1
-  end
-  
-  it "should paginate with :conditions" do
-    result = Topic.paginate :page => 1, :order => 'id ASC',
-      :conditions => ["created_at > ?", 30.minutes.ago]
-    result.should == topics(:rails, :ar)
-    result.total_pages.should == 1
-  end
-
-  it "should paginate with :include and :conditions" do
-    klass = Topic
-    klass = klass.references(:replies) if klass.respond_to?(:references)
-
-    result = klass.paginate \
-      :page     => 1, 
-      :include  => :replies,  
-      :conditions => "replies.content LIKE 'Bird%' ", 
-      :per_page => 10
-
-    expected = klass.find :all,
-      :include => 'replies', 
-      :conditions => "replies.content LIKE 'Bird%' ", 
-      :limit   => 10
-
-    result.should == expected
-    result.total_entries.should == 1
-  end
-
-  it "should paginate with :include and :order" do
-    result = nil
-    lambda {
-      result = Topic.paginate(:page => 1, :include => :replies, :per_page => 10,
-        :order => 'replies.created_at asc, topics.created_at asc').to_a
-    }.should run_queries(2)
-
-    expected = Topic.find :all, 
-      :include => 'replies', 
-      :order   => 'replies.created_at asc, topics.created_at asc', 
-      :limit   => 10
-
-    result.should == expected
-    result.total_entries.should == 4
-  end
-  
   describe "associations" do
-    it "should paginate with include" do
-      project = projects(:active_record)
-
-      topics = project.topics
-      topics = topics.references(:replies) if topics.respond_to?(:references)
-
-      result = topics.paginate \
-        :page       => 1, 
-        :include    => :replies,  
-        :conditions => ["replies.content LIKE ?", 'Nice%'],
-        :per_page   => 10
-
-      topics = Topic
-      topics = topics.references(:replies) if topics.respond_to?(:references)
-
-      expected = topics.find :all,
-        :include    => 'replies', 
-        :conditions => ["project_id = ? AND replies.content LIKE ?", project.id, 'Nice%'],
-        :limit      => 10
-
-      result.should == expected
-    end
-
     it "should paginate" do
       dhh = users(:david)
       expected_name_ordered = projects(:action_controller, :active_record)
@@ -375,7 +289,7 @@ describe WillPaginate::ActiveRecord do
       lambda {
         # with association-specified order
         result = ignore_deprecation {
-          dhh.projects.includes(:topics).paginate(:page => 1, :order => 'projects.name')
+          dhh.projects.includes(:topics).order('projects.name').paginate(:page => 1)
         }
         result.to_a.should == expected_name_ordered
         result.total_entries.should == 2
@@ -417,7 +331,7 @@ describe WillPaginate::ActiveRecord do
     join_sql = 'LEFT JOIN developers_projects ON users.id = developers_projects.developer_id'
 
     lambda {
-      result = Developer.paginate(:page => 1, :joins => join_sql, :conditions => 'project_id = 1')
+      result = Developer.where('developers_projects.project_id = 1').joins(join_sql).paginate(:page => 1)
       result.to_a # trigger loading of records
       result.size.should == 2
       developer_names = result.map(&:name)
@@ -427,8 +341,7 @@ describe WillPaginate::ActiveRecord do
 
     lambda {
       expected = result.to_a
-      result = Developer.paginate(:page => 1, :joins => join_sql,
-        :conditions => 'project_id = 1', :count => { :select => "users.id" }).to_a
+      result = Developer.where('developers_projects.project_id = 1').joins(join_sql).paginate(:page => 1)
       result.should == expected
       result.total_entries.should == 2
     }.should run_queries(1)
@@ -437,8 +350,8 @@ describe WillPaginate::ActiveRecord do
   it "should paginate with group" do
     result = nil
     lambda {
-      result = Developer.paginate(:page => 1, :per_page => 10,
-        :group => 'salary', :select => 'salary', :order => 'salary').to_a
+      result = Developer.select('salary').order('salary').group('salary').
+        paginate(:page => 1, :per_page => 10).to_a
     }.should run_queries(1)
 
     expected = users(:david, :jamis, :dev_10, :poor_jamis).map(&:salary).sort
@@ -451,12 +364,6 @@ describe WillPaginate::ActiveRecord do
     }.should raise_error(NoMethodError)
   end
 
-  it "should paginate with_scope" do
-    result = Developer.with_poor_ones { Developer.paginate :page => 1 }
-    result.size.should == 2
-    result.total_entries.should == 2
-  end
-
   describe "scopes" do
     it "should paginate" do
       result = Developer.poor.paginate :page => 1, :per_page => 1
@@ -496,12 +403,6 @@ describe WillPaginate::ActiveRecord do
     end
   end
 
-  it "should paginate with :readonly option" do
-    lambda {
-      Developer.paginate :readonly => true, :page => 1
-    }.should_not raise_error
-  end
-  
   it "should not paginate an array of IDs" do
     lambda {
       Developer.paginate((1..8).to_a, :per_page => 3, :page => 2, :order => 'id')
@@ -514,64 +415,4 @@ describe WillPaginate::ActiveRecord do
       Project.page(307445734561825862)
     }.should raise_error(WillPaginate::InvalidPage, "invalid offset: 9223372036854775830")
   end
-  
-  protected
-  
-    def ignore_deprecation
-      ActiveSupport::Deprecation.silence { yield }
-    end
-
-    def run_queries(num)
-      QueryCountMatcher.new(num)
-    end
-
-    def show_queries(&block)
-      counter = QueryCountMatcher.new(nil)
-      counter.run block
-    ensure
-      queries = counter.performed_queries
-      if queries.any?
-        puts queries
-      else
-        puts "no queries"
-      end
-    end
-
-end
-
-class QueryCountMatcher
-  def initialize(num)
-    @expected_count = num
-  end
-
-  def matches?(block)
-    run(block)
-
-    if @expected_count.respond_to? :include?
-      @expected_count.include? @count
-    else
-      @count == @expected_count
-    end
-  end
-
-  def run(block)
-    $query_count = 0
-    $query_sql = []
-    block.call
-  ensure
-    @queries = $query_sql.dup
-    @count = $query_count
-  end
-
-  def performed_queries
-    @queries
-  end
-
-  def failure_message
-    "expected #{@expected_count} queries, got #{@count}\n#{@queries.join("\n")}"
-  end
-
-  def negative_failure_message
-    "expected query count not to be #{@expected_count}"
-  end
-end
+ end

data/spec/finders/data_mapper_spec.rb

@@ -80,6 +80,19 @@ describe WillPaginate::DataMapper 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| }

data/spec/finders/mongoid_spec.rb

@@ -0,0 +1,140 @@
+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/fixtures/developer.rb

@@ -1,13 +1,6 @@
 class Developer < User
   has_and_belongs_to_many :projects, :join_table => 'developers_projects'
 
-  def self.with_poor_ones(&block)
-    options = { :conditions => ['salary <= ?', 80000], :order => 'salary' }
-    with_scope({ :find => options }, :overwrite) do
-      yield
-    end
-  end
-
   scope :poor, lambda {
     where(['salary <= ?', 80000]).order('salary')
   }

data/spec/spec_helper.rb

@@ -19,8 +19,28 @@ RSpec.configure do |config|
     def have_deprecation(msg)
       DeprecationMatcher.new(msg)
     end
+
+    def run_queries(num)
+      QueryCountMatcher.new(num)
+    end
+
+    def ignore_deprecation
+      ActiveSupport::Deprecation.silence { yield }
+    end
+
+    def show_queries(&block)
+      counter = QueryCountMatcher.new(nil)
+      counter.run block
+    ensure
+      queries = counter.performed_queries
+      if queries.any?
+        puts queries
+      else
+        puts "no queries"
+      end
+    end
   }
-  
+
   config.mock_with :mocha
   config.backtrace_clean_patterns << /view_example_group/
 end

data/spec/view_helpers/action_view_spec.rb

@@ -80,9 +80,9 @@ describe WillPaginate::ActionView do
         validate_page_numbers [1,1,3,3], elements
         # test rel attribute values:
         text(elements[0]).should == 'Prev'
-        elements[0]['rel'].should == 'prev'
+        elements[0]['rel'].should == 'prev start'
         text(elements[1]).should == '1'
-        elements[1]['rel'].should == 'prev'
+        elements[1]['rel'].should == 'prev start'
         text(elements[3]).should == 'Next'
         elements[3]['rel'].should == 'next'
       end
@@ -201,13 +201,6 @@ describe WillPaginate::ActionView do
     assert_no_links_match /99/
     assert_no_links_match /ftp/
   end
-
-  it "doesn't allow tampering with script_name" do
-    request.params :script_name => 'p0wned', :original_script_name => 'p0wned'
-    paginate
-    assert_links_match %r{^/foo/bar}
-    assert_no_links_match /p0wned/
-  end
   
   it "should not preserve parameters on POST" do
     request.post
@@ -257,7 +250,7 @@ describe WillPaginate::ActionView do
   end
 
   it "should paginate with custom route page parameter" do
-    request.symbolized_path_parameters.update :controller => 'dummy', :action => 'index'
+    request.symbolized_path_parameters.update :controller => 'dummy', :action => nil
     paginate :per_page => 2 do
       assert_select 'a[href]', 6 do |links|
         assert_links_match %r{/page/(\d+)$}, links, [2, 3, 4, 5, 6, 2]
@@ -275,7 +268,7 @@ describe WillPaginate::ActionView do
   end
 
   it "should paginate with custom route and first page number implicit" do
-    request.symbolized_path_parameters.update :controller => 'ibocorp', :action => 'index'
+    request.symbolized_path_parameters.update :controller => 'ibocorp', :action => nil
     paginate :page => 2, :per_page => 2 do
       assert_select 'a[href]', 7 do |links|
         assert_links_match %r{/ibocorp(?:/(\d+))?$}, links, [nil, nil, 3, 4, 5, 6, 3]

data/spec/view_helpers/view_example_group.rb

@@ -27,7 +27,6 @@ module ViewExampleGroup
   include MiniTest::Assertions if defined? MiniTest
 
   def assert(value, message)
-    message = message.call if message.respond_to?(:call)
     raise message unless value
   end
   
@@ -144,4 +143,4 @@ module HTML
       childless?? '' : super
     end
   end
-end if defined?(HTML)
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: will_paginate
 version: !ruby/object:Gem::Version
-  version: 3.0.12
+  version: 3.1.0
 platform: ruby
 authors:
 - Mislav Marohnić
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-15 00:00:00.000000000 Z
+date: 2016-01-03 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
@@ -31,6 +31,7 @@ files:
 - lib/will_paginate/deprecation.rb
 - lib/will_paginate/i18n.rb
 - lib/will_paginate/locale/en.yml
+- lib/will_paginate/mongoid.rb
 - lib/will_paginate/page_number.rb
 - lib/will_paginate/per_page.rb
 - lib/will_paginate/railtie.rb
@@ -51,6 +52,7 @@ files:
 - 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