agnostic-will_paginate 3.0.0

data/lib/will_paginate/view_helpers/merb.rb

@@ -0,0 +1,13 @@
+require 'will_paginate/view_helpers/base'
+require 'will_paginate/view_helpers/link_renderer'
+
+WillPaginate::ViewHelpers::LinkRenderer.class_eval do
+  protected
+
+  def url(page)
+    params = @template.request.params.except(:action, :controller).merge(param_name => page)
+    @template.url(:this, params)
+  end
+end
+
+Merb::AbstractController.send(:include, WillPaginate::ViewHelpers::Base)

data/spec/collection_spec.rb

@@ -0,0 +1,147 @@
+require 'will_paginate/array'
+require 'spec_helper'
+
+describe WillPaginate::Collection do
+
+  before :all do
+    @simple = ('a'..'e').to_a
+  end
+
+  it "should be a subset of original collection" do
+    @simple.paginate(:page => 1, :per_page => 3).should == %w( a b c )
+  end
+
+  it "can be shorter than per_page if on last page" do
+    @simple.paginate(:page => 2, :per_page => 3).should == %w( d e )
+  end
+
+  it "should include whole collection if per_page permits" do
+    @simple.paginate(:page => 1, :per_page => 5).should == @simple
+  end
+
+  it "should be empty if out of bounds" do
+    @simple.paginate(:page => 2, :per_page => 5).should be_empty
+  end
+  
+  it "should default to 1 as current page and 30 per-page" do
+    result = (1..50).to_a.paginate
+    result.current_page.should == 1
+    result.size.should == 30
+  end
+
+  describe "old API" do
+    it "should fail with numeric params" do
+      Proc.new { [].paginate(2) }.should raise_error(ArgumentError)
+      Proc.new { [].paginate(2, 10) }.should raise_error(ArgumentError)
+    end
+
+    it "should fail with both options and numeric param" do
+      Proc.new { [].paginate({}, 5) }.should raise_error(ArgumentError)
+    end
+  end
+
+  it "should give total_entries precedence over actual size" do
+    %w(a b c).paginate(:total_entries => 5).total_entries.should == 5
+  end
+
+  it "should be an augmented Array" do
+    entries = %w(a b c)
+    collection = create(2, 3, 10) do |pager|
+      pager.replace(entries).should == entries
+    end
+
+    collection.should == entries
+    for method in %w(total_pages each offset size current_page per_page total_entries)
+      collection.should respond_to(method)
+    end
+    collection.should be_kind_of(Array)
+    collection.entries.should be_instance_of(Array)
+    # TODO: move to another expectation:
+    collection.offset.should == 3
+    collection.total_pages.should == 4
+    collection.should_not be_out_of_bounds
+  end
+
+  describe "previous/next pages" do
+    it "should have previous_page nil when on first page" do
+      collection = create(1, 1, 3)
+      collection.previous_page.should be_nil
+      collection.next_page.should == 2
+    end
+    
+    it "should have both prev/next pages" do
+      collection = create(2, 1, 3)
+      collection.previous_page.should == 1
+      collection.next_page.should == 3
+    end
+    
+    it "should have next_page nil when on last page" do
+      collection = create(3, 1, 3)
+      collection.previous_page.should == 2
+      collection.next_page.should be_nil
+    end
+  end
+
+  it "should show out of bounds when page number is too high" do
+    create(2, 3, 2).should be_out_of_bounds
+  end
+    
+  it "should not show out of bounds when inside collection" do
+    create(1, 3, 2).should_not be_out_of_bounds
+  end
+
+  describe "guessing total count" do
+    it "can guess when collection is shorter than limit" do
+      collection = create { |p| p.replace array }
+      collection.total_entries.should == 8
+    end
+    
+    it "should allow explicit total count to override guessed" do
+      collection = create(2, 5, 10) { |p| p.replace array }
+      collection.total_entries.should == 10
+    end
+    
+    it "should not be able to guess when collection is same as limit" do
+      collection = create { |p| p.replace array(5) }
+      collection.total_entries.should be_nil
+    end
+    
+    it "should not be able to guess when collection is empty" do
+      collection = create { |p| p.replace array(0) }
+      collection.total_entries.should be_nil
+    end
+    
+    it "should be able to guess when collection is empty and this is the first page" do
+      collection = create(1) { |p| p.replace array(0) }
+      collection.total_entries.should == 0
+    end
+  end
+
+  it "should raise WillPaginate::InvalidPage on invalid input" do
+    for bad_input in [0, -1, nil, '', 'Schnitzel']
+      Proc.new { create bad_input }.should raise_error(WillPaginate::InvalidPage)
+    end
+  end
+
+  it "should raise Argument error on invalid per_page setting" do
+    Proc.new { create(1, -1) }.should raise_error(ArgumentError)
+  end
+
+  it "should not respond to page_count anymore" do
+    Proc.new { create.page_count }.should raise_error(NoMethodError)
+  end
+
+  private
+  
+    def create(page = 2, limit = 5, total = nil, &block)
+      if block_given?
+        WillPaginate::Collection.create(page, limit, total, &block)
+      else
+        WillPaginate::Collection.new(page, limit, total)
+      end
+    end
+
+    def array(size = 3)
+      Array.new(size)
+    end
+end

data/spec/console

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+libs = []
+
+libs << 'irb/completion'
+libs << 'console_fixtures'
+
+exec "#{irb} -Ilib:spec#{libs.map{ |l| " -r #{l}" }.join} --simple-prompt"

data/spec/console_fixtures.rb

@@ -0,0 +1,8 @@
+require 'will_paginate/finders/active_record'
+require 'finders/activerecord_test_connector'
+ActiverecordTestConnector.setup
+
+# load all fixtures
+Fixtures.create_fixtures(ActiverecordTestConnector::FIXTURES_PATH, ActiveRecord::Base.connection.tables)
+
+

data/spec/database.yml

@@ -0,0 +1,22 @@
+sqlite3:
+  database: ":memory:"
+  adapter: sqlite3
+  timeout: 500
+
+sqlite2:
+  database: ":memory:"
+  adapter: sqlite2
+
+mysql:
+  adapter: mysql
+  username: rails
+  password: mislav
+  encoding: utf8
+  database: will_paginate_unittest
+
+postgres:
+  adapter: postgresql
+  username: mislav
+  password: mislav
+  database: will_paginate_unittest
+  min_messages: warning

data/spec/finders/active_record_spec.rb

@@ -0,0 +1,461 @@
+require 'spec_helper'
+require 'will_paginate/finders/active_record'
+require File.dirname(__FILE__) + '/activerecord_test_connector'
+
+require 'will_paginate'
+WillPaginate::enable_named_scope
+
+class ArProject < ActiveRecord::Base
+  def self.column_names
+    ["id"]
+  end
+  
+  named_scope :distinct, :select => "DISTINCT #{table_name}.*"
+end
+
+gem 'sqlite3-ruby'
+ActiverecordTestConnector.setup
+
+describe WillPaginate::Finders::ActiveRecord do
+  
+  extend ActiverecordTestConnector::FixtureSetup
+  
+  it "should integrate with ActiveRecord::Base" do
+    ActiveRecord::Base.should respond_to(:paginate)
+  end
+  
+  it "should paginate" do
+    ArProject.expects(:find).with(:all, { :limit => 5, :offset => 0 }).returns([])
+    ArProject.paginate(:page => 1, :per_page => 5)
+  end
+  
+  it "should respond to paginate_by_sql" do
+    ArProject.should respond_to(:paginate_by_sql)
+  end
+  
+  it "should support explicit :all argument" do
+    ArProject.expects(:find).with(:all, instance_of(Hash)).returns([])
+    ArProject.paginate(:all, :page => nil)
+  end
+  
+  it "should put implicit all in dynamic finders" do
+    ArProject.expects(:find_all_by_foo).returns([])
+    ArProject.expects(:count).returns(0)
+    ArProject.paginate_by_foo :page => 2
+  end
+  
+  it "should leave extra parameters intact" do
+    ArProject.expects(:find).with(:all, {:foo => 'bar', :limit => 4, :offset => 0 }).returns(Array.new(5))
+    ArProject.expects(:count).with({:foo => 'bar'}).returns(1)
+
+    ArProject.paginate :foo => 'bar', :page => 1, :per_page => 4
+  end
+
+  describe "counting" do
+    it "should ignore nil in :count parameter" do
+      ArProject.expects(:find).returns([])
+      lambda { ArProject.paginate :page => nil, :count => nil }.should_not raise_error
+    end
+    
+    it "should guess the total count" do
+      ArProject.expects(:find).returns(Array.new(2))
+      ArProject.expects(:count).never
+
+      result = ArProject.paginate :page => 2, :per_page => 4
+      result.total_entries.should == 6
+    end
+
+    it "should guess that there are no records" do
+      ArProject.expects(:find).returns([])
+      ArProject.expects(:count).never
+
+      result = ArProject.paginate :page => 1, :per_page => 4
+      result.total_entries.should == 0
+    end
+  end
+  
+  it "should not ignore :select parameter when it says DISTINCT" do
+    ArProject.stubs(:find).returns([])
+    ArProject.expects(:count).with(:select => 'DISTINCT salary').returns(0)
+    ArProject.paginate :select => 'DISTINCT salary', :page => 2
+  end
+  
+  it "should count with scoped select when :select => DISTINCT" do
+    ArProject.stubs(:find).returns([])
+    ArProject.expects(:count).with(:select => 'DISTINCT ar_projects.id').returns(0)
+    ArProject.distinct.paginate :page => 2
+  end
+
+  it "should use :with_foo for scope-out compatibility" do
+    ArProject.expects(:find_best).returns(Array.new(5))
+    ArProject.expects(:with_best).returns(1)
+    
+    ArProject.paginate_best :page => 1, :per_page => 4
+  end
+
+  describe "paginate_by_sql" do
+    it "should paginate" do
+      ArProject.expects(:find_by_sql).with(regexp_matches(/sql LIMIT 3(,| OFFSET) 3/)).returns([])
+      ArProject.expects(:count_by_sql).with('SELECT COUNT(*) FROM (sql) AS count_table').returns(0)
+    
+      ArProject.paginate_by_sql 'sql', :page => 2, :per_page => 3
+    end
+
+    it "should respect total_entrier setting" do
+      ArProject.expects(:find_by_sql).returns([])
+      ArProject.expects(:count_by_sql).never
+    
+      entries = ArProject.paginate_by_sql 'sql', :page => 1, :total_entries => 999
+      entries.total_entries.should == 999
+    end
+
+    it "should strip the order when counting" do
+      ArProject.expects(:find_by_sql).returns([])
+      ArProject.expects(:count_by_sql).with("SELECT COUNT(*) FROM (sql\n ) AS count_table").returns(0)
+    
+      ArProject.paginate_by_sql "sql\n ORDER\nby foo, bar, `baz` ASC", :page => 2
+    end
+    
+    it "shouldn't change the original query string" do
+      query = 'SQL QUERY'
+      original_query = query.dup
+      ArProject.expects(:find_by_sql).returns([])
+      
+      ArProject.paginate_by_sql(query, :page => 1)
+      query.should == original_query
+    end
+  end
+
+  # TODO: counts would still be wrong!
+  it "should be able to paginate custom finders" do
+    # acts_as_taggable defines find_tagged_with(tag, options)
+    ArProject.expects(:find_tagged_with).with('will_paginate', :offset => 5, :limit => 5).returns([])
+    ArProject.expects(:count).with({}).returns(0)
+    
+    ArProject.paginate_tagged_with 'will_paginate', :page => 2, :per_page => 5
+  end
+
+  it "should not skip count when given an array argument to a finder" do
+    ids = (1..8).to_a
+    ArProject.expects(:find_all_by_id).returns([])
+    ArProject.expects(:count).returns(0)
+    
+    ArProject.paginate_by_id(ids, :per_page => 3, :page => 2, :order => 'id')
+  end
+
+  it "doesn't mangle options" do
+    ArProject.expects(:find).returns([])
+    options = { :page => 1 }
+    options.expects(:delete).never
+    options_before = options.dup
+    
+    ArProject.paginate(options)
+    options.should == options_before
+  end
+  
+  if ::ActiveRecord::Calculations::CALCULATIONS_OPTIONS.include?(:from)
+    # for ActiveRecord 2.1 and newer
+    it "keeps the :from parameter in count" do
+      ArProject.expects(:find).returns([1])
+      ArProject.expects(:count).with {|options| options.key?(:from) }.returns(0)
+      ArProject.paginate(:page => 2, :per_page => 1, :from => 'projects')
+    end
+  else
+    it "excludes :from parameter from count" do
+      ArProject.expects(:find).returns([1])
+      ArProject.expects(:count).with {|options| !options.key?(:from) }.returns(0)
+      ArProject.paginate(:page => 2, :per_page => 1, :from => 'projects')
+    end
+  end
+  
+  if ActiverecordTestConnector.able_to_connect
+    fixtures :topics, :replies, :users, :projects, :developers_projects
+    
+    it "should get first page of Topics with a single query" do
+      lambda {
+        result = Topic.paginate :page => nil
+        result.current_page.should == 1
+        result.total_pages.should == 1
+        result.size.should == 4
+      }.should run_queries(1)
+    end
+    
+    it "should get second (inexistent) page of Topics, requiring 2 queries" do
+      lambda {
+        result = Topic.paginate :page => 2
+        result.total_pages.should == 1
+        result.should be_empty
+      }.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, :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,  
+          :order    => 'replies.created_at asc, topics.created_at asc', 
+          :per_page => 10
+      }.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
+    
+    # detect ActiveRecord 2.1
+    if ActiveRecord::Base.private_methods.include_method?(:references_eager_loaded_tables?)
+      it "should remove :include for count" do
+        Developer.expects(:find).returns([1])
+        Developer.expects(:count).with({}).returns(0)
+    
+        Developer.paginate :page => 1, :per_page => 1, :include => :projects
+      end
+    
+      it "should keep :include for count when they are referenced in :conditions" do
+        Developer.expects(:find).returns([1])
+        Developer.expects(:count).with({ :include => :projects, :conditions => 'projects.id > 2' }).returns(0)
+    
+        Developer.paginate :page => 1, :per_page => 1,
+          :include => :projects, :conditions => 'projects.id > 2'
+      end
+    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 = #{project.id} AND replies.content LIKE ?", 'Nice%'],
+          :limit      => 10
+
+        result.should == expected
+      end
+
+      it "should paginate" do
+        dhh = users(:david)
+        expected_name_ordered = projects(:action_controller, :active_record)
+        expected_id_ordered   = projects(:active_record, :action_controller)
+
+        lambda {
+          # with association-specified order
+          result = dhh.projects.paginate(:page => 1)
+          result.should == expected_name_ordered
+          result.total_entries.should == 2
+        }.should run_queries(2)
+
+        # with explicit order
+        result = dhh.projects.paginate(:page => 1, :order => 'projects.id')
+        result.should == expected_id_ordered
+        result.total_entries.should == 2
+
+        lambda {
+          dhh.projects.find(:all, :order => 'projects.id', :limit => 4)
+        }.should_not raise_error
+        
+        result = dhh.projects.paginate(:page => 1, :order => 'projects.id', :per_page => 4)
+        result.should == expected_id_ordered
+
+        # has_many with implicit order
+        topic = Topic.find(1)
+        expected = replies(:spam, :witty_retort)
+        # FIXME: wow, this is ugly
+        topic.replies.paginate(:page => 1).map(&:id).sort.should == expected.map(&:id).sort
+        topic.replies.paginate(:page => 1, :order => 'replies.id ASC').should == expected.reverse
+      end
+
+      it "should paginate through association extension" do
+        project = Project.find(:first)
+        expected = [replies(:brave)]
+
+        lambda {
+          result = project.replies.paginate_recent :page => 1
+          result.should == expected
+        }.should run_queries(1)
+      end
+    end
+    
+    it "should paginate with joins" do
+      result = nil
+      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.size.should == 2
+        developer_names = result.map(&:name)
+        developer_names.should include('David')
+        developer_names.should include('Jamis')
+      }.should run_queries(1)
+
+      lambda {
+        expected = result.to_a
+        result = Developer.paginate :page => 1, :joins => join_sql,
+                             :conditions => 'project_id = 1', :count => { :select => "users.id" }
+        result.should == expected
+        result.total_entries.should == 2
+      }.should run_queries(1)
+    end
+
+    it "should paginate with group" do
+      result = nil
+      lambda {
+        result = Developer.paginate :page => 1, :per_page => 10,
+                                    :group => 'salary', :select => 'salary', :order => 'salary'
+      }.should run_queries(1)
+
+      expected = users(:david, :jamis, :dev_10, :poor_jamis).map(&:salary).sort
+      result.map(&:salary).should == expected
+    end
+
+    it "should paginate with dynamic finder" do
+      expected = replies(:witty_retort, :spam)
+      Reply.paginate_by_topic_id(1, :page => 1).should == expected
+
+      result = Developer.paginate :conditions => { :salary => 100000 }, :page => 1, :per_page => 5
+      result.total_entries.should == 8
+      Developer.paginate_by_salary(100000, :page => 1, :per_page => 5).should == result
+    end
+
+    it "should paginate with dynamic finder and conditions" do
+      result = Developer.paginate_by_salary(100000, :page => 1, :conditions => ['id > ?', 6])
+      result.total_entries.should == 4
+      result.map(&:id).should == (7..10).to_a
+    end
+
+    it "should raise error when dynamic finder is not recognized" do
+      lambda {
+        Developer.paginate_by_inexistent_attribute 100000, :page => 1
+      }.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 "named_scope" do
+      it "should paginate" do
+        result = Developer.poor.paginate :page => 1, :per_page => 1
+        result.size.should == 1
+        result.total_entries.should == 2
+      end
+
+      it "should paginate on habtm association" do
+        project = projects(:active_record)
+        lambda {
+          result = project.developers.poor.paginate :page => 1, :per_page => 1
+          result.size.should == 1
+          result.total_entries.should == 1
+        }.should run_queries(2)
+      end
+
+      it "should paginate on hmt association" do
+        project = projects(:active_record)
+        expected = [replies(:brave)]
+
+        lambda {
+          result = project.replies.recent.paginate :page => 1, :per_page => 1
+          result.should == expected
+          result.total_entries.should == 1
+        }.should run_queries(2)
+      end
+
+      it "should paginate on has_many association" do
+        project = projects(:active_record)
+        expected = [topics(:ar)]
+
+        lambda {
+          result = project.topics.mentions_activerecord.paginate :page => 1, :per_page => 1
+          result.should == expected
+          result.total_entries.should == 1
+        }.should run_queries(2)
+      end
+    end
+
+    it "should paginate with :readonly option" do
+      lambda { Developer.paginate :readonly => true, :page => 1 }.should_not raise_error
+    end
+    
+    # detect ActiveRecord 2.0
+    unless ActiveRecord::Base.respond_to? :find_all
+      it "should paginate array of IDs" do
+        # AR finders also accept arrays of IDs
+        # (this was broken in Rails before [6912])
+        lambda {
+          result = Developer.paginate((1..8).to_a, :per_page => 3, :page => 2, :order => 'id')
+          result.map(&:id).should == (4..6).to_a
+          result.total_entries.should == 8
+        }.should run_queries(1)
+      end
+    end
+    
+  end
+  
+  protected
+  
+    def run_queries(num)
+      QueryCountMatcher.new(num)
+    end
+
+end
+
+class QueryCountMatcher
+  def initialize(num)
+    @queries = num
+    @old_query_count = $query_count
+  end
+
+  def matches?(block)
+    block.call
+    @queries_run = $query_count - @old_query_count
+    @queries == @queries_run
+  end
+
+  def failure_message
+    "expected #{@queries} queries, got #{@queries_run}"
+  end
+
+  def negative_failure_message
+    "expected query count not to be #{$queries}"
+  end
+end