will_paginate 3.0.4 → 3.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b3445d24047dd419909e314bc5f1b9eb3fdb7f73
+  data.tar.gz: 2e6ce5705bc95b523bdd8a7ffa9d8e0b35acc36f
+SHA512:
+  metadata.gz: bdc9b0d1f20379dc1df3dc503796834b329976c90a63f4e0f14b77152aef8721bea240f850d0abc0c0171a3e1ad10d5c88a354136e47d4bb933b29a205311d7d
+  data.tar.gz: c35edfea8e81e70fef045d9f1c3c32bea89723a1bd74a6c2edb438c62fc54c3356eb4704329c42b35760178c71a505ee0d86c0109a6f7cd3fdacd5276af4eb74

data/README.md

@@ -5,8 +5,8 @@ will_paginate is a pagination library that integrates with Ruby on Rails, Sinatr
 Installation:
 
 ``` ruby
-## Gemfile for Rails 3, Sinatra, and Merb
-gem 'will_paginate', '~> 3.0'
+## Gemfile for Rails 3+, Sinatra, and Merb
+gem 'will_paginate', '~> 3.0.6'
 ```
 
 See [installation instructions][install] on the wiki for more info.
@@ -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

@@ -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
@@ -78,16 +78,15 @@ 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 = (select_for_count(rel) || :all)
+          rel.count(column_name)
         else
-          super
+          super(*args)
         end
       end
 
@@ -135,24 +134,30 @@ 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
+      
+      def select_for_count(rel)
+        if rel.select_values.present?
+          select = rel.select_values.join(", ")
+          select if select !~ /[,*]/
+        end
+      end
     end
 
     module Pagination
       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/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)

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

@@ -32,14 +32,17 @@ module WillPaginate
     end
 
     def self.add_locale_path(config)
-      config.i18n.railties_load_path.unshift(*WillPaginate::I18n.load_path)
+      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
       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) &&

data/lib/will_paginate/version.rb

@@ -1,8 +1,8 @@
 module WillPaginate #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 3
-    MINOR = 0
-    TINY  = 4
+    MINOR = 1
+    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:
@@ -106,6 +106,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
 

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/spec/database.yml

@@ -8,15 +8,18 @@ mysql:
   database: will_paginate
   username: 
   encoding: utf8
+  socket: <%= ENV["BOXEN_MYSQL_SOCKET"] %>
 
 mysql2:
   adapter: mysql2
   database: will_paginate
   username: 
   encoding: utf8
+  socket: <%= ENV["BOXEN_MYSQL_SOCKET"] %>
 
 postgres:
   adapter: postgresql
   database: will_paginate
-  username: postgres
+  username: <%= "postgres" if ENV["TRAVIS"] %>
   min_messages: warning
+  port: <%= ENV["BOXEN_POSTGRESQL_PORT"] %>

data/spec/fake_rubygems.rb

@@ -0,0 +1,18 @@
+# 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/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 {
@@ -191,6 +175,7 @@ describe WillPaginate::ActiveRecord do
     it "keeps :include for count when they are referenced in :conditions" do
       developers = Developer.paginate(:page => 1, :per_page => 1).includes(:projects)
       with_condition = developers.where('projects.id > 1')
+      with_condition = with_condition.references(:projects) if with_condition.respond_to?(:references)
       with_condition.total_entries.should == 1
 
       $query_sql.last.should =~ /\bJOIN\b/
@@ -199,6 +184,15 @@ describe WillPaginate::ActiveRecord do
     it "should count with group" do
       Developer.group(:salary).page(1).total_entries.should == 4
     end
+    
+    it "should count with select" do
+      Topic.select('title, content').page(1).total_entries.should == 4
+    end
+
+    it "removes :reorder for count with group" do
+      Project.group(:id).reorder(:id).page(1).total_entries
+      $query_sql.last.should_not =~ /\ORDER\b/
+    end
 
     it "should not have zero total_pages when the result set is empty" do
       Developer.where("1 = 2").page(1).total_pages.should == 1
@@ -240,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')
@@ -285,69 +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
-    result = Topic.paginate \
-      :page     => 1, 
-      :include  => :replies,  
-      :conditions => "replies.content LIKE 'Bird%' ", 
-      :per_page => 10
-
-    expected = Topic.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)
-
-      result = project.topics.paginate \
-        :page       => 1, 
-        :include    => :replies,  
-        :conditions => ["replies.content LIKE ?", 'Nice%'],
-        :per_page   => 10
-
-      expected = Topic.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)
@@ -355,8 +288,10 @@ describe WillPaginate::ActiveRecord do
 
       lambda {
         # with association-specified order
-        result = ignore_deprecation { dhh.projects.paginate(:page => 1) }
-        result.should == expected_name_ordered
+        result = ignore_deprecation {
+          dhh.projects.includes(:topics).order('projects.name').paginate(:page => 1)
+        }
+        result.to_a.should == expected_name_ordered
         result.total_entries.should == 2
       }.should run_queries(2)
 
@@ -366,7 +301,7 @@ describe WillPaginate::ActiveRecord do
       result.total_entries.should == 2
 
       lambda {
-        dhh.projects.find(:all, :order => 'projects.id', :limit => 4)
+        dhh.projects.order('projects.id').limit(4).to_a
       }.should_not raise_error
       
       result = dhh.projects.paginate(:page => 1, :per_page => 4).reorder('projects.id')
@@ -396,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)
@@ -406,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)
@@ -416,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
@@ -430,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
@@ -475,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')
@@ -493,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/activerecord_test_connector.rb

@@ -1,15 +1,28 @@
 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 = []
 
 ignore_sql = /
     ^(
-      PRAGMA | SHOW\ max_identifier_length |
+      PRAGMA | SHOW\ (max_identifier_length|search_path) |
       SELECT\ (currval|CAST|@@IDENTITY|@@ROWCOUNT) |
-      SHOW\ (FIELDS|TABLES)
+      SHOW\ ((FULL\ )?FIELDS|TABLES)
     )\b |
     \bFROM\ (sqlite_master|pg_tables|pg_attribute)\b
   /x
@@ -59,8 +72,9 @@ module ActiverecordTestConnector
 
   def setup_connection
     db = ENV['DB'].blank?? 'sqlite3' : ENV['DB']
-    
-    configurations = YAML.load_file(File.expand_path('../../database.yml', __FILE__))
+
+    erb = ERB.new(File.read(File.expand_path('../../database.yml', __FILE__)))
+    configurations = YAML.load(erb.result)
     raise "no configuration for '#{db}'" unless configurations.key? db
     configuration = configurations[db]
     
@@ -68,14 +82,17 @@ module ActiverecordTestConnector
     puts "using #{configuration['adapter']} adapter"
     
     ActiveRecord::Base.configurations = { db => configuration }
-    ActiveRecord::Base.establish_connection(db)
+    ActiveRecord::Base.establish_connection(db.to_sym)
     ActiveRecord::Base.default_timezone = :utc
   end
 
   def load_schema
-    ActiveRecord::Base.silence do
+    begin
+      $stdout = StringIO.new
       ActiveRecord::Migration.verbose = false
       load File.join(FIXTURES_PATH, 'schema.rb')
+    ensure
+      $stdout = STDOUT
     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| }
@@ -90,7 +103,7 @@ describe WillPaginate::DataMapper do
     animals = Animal.all(:limit => 2).page(1)
     array = animals.to_a
     array.size.should == 2
-    array.is_a? WillPaginate::Collection
+    array.should be_kind_of(WillPaginate::Collection)
     array.current_page.should == 1
     array.per_page.should == 2
   end