f1sherman-will_paginate 3.0.pre3

data/lib/will_paginate/view_helpers/link_renderer_base.rb

@@ -0,0 +1,83 @@
+require 'will_paginate/view_helpers'
+
+module WillPaginate
+  module ViewHelpers
+    # This class does the heavy lifting of actually building the pagination
+    # links. It is used by +will_paginate+ helper internally.
+    class LinkRendererBase
+
+      # * +collection+ is a WillPaginate::Collection instance or any other object
+      #   that conforms to that API
+      # * +options+ are forwarded from +will_paginate+ view helper
+      def prepare(collection, options)
+        @collection = collection
+        @options    = options
+
+        # reset values in case we're re-using this instance
+        @total_pages = @param_name = nil
+      end
+      
+      def pagination
+        items = @options[:page_links] ? windowed_page_numbers : []
+        items.unshift :previous_page
+        items.push :next_page
+      end
+
+    protected
+    
+      # Calculates visible page numbers using the <tt>:inner_window</tt> and
+      # <tt>:outer_window</tt> options.
+      def windowed_page_numbers
+        inner_window, outer_window = @options[:inner_window].to_i, @options[:outer_window].to_i
+        window_from = current_page - inner_window
+        window_to = current_page + inner_window
+        
+        # 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
+        end
+        if window_from < 1
+          window_to += 1 - window_from
+          window_from = 1
+          window_to = total_pages if window_to > total_pages
+        end
+        
+        # these are always visible
+        middle = window_from..window_to
+
+        # left window
+        if outer_window + 3 < middle.first # there's a gap
+          left = (1..(outer_window + 1)).to_a
+          left << :gap
+        else # runs into visible pages
+          left = 1...middle.first
+        end
+
+        # right window
+        if total_pages - outer_window - 2 > middle.last # again, gap
+          right = ((total_pages - outer_window)..total_pages).to_a
+          right.unshift :gap
+        else # runs into visible pages
+          right = (middle.last + 1)..total_pages
+        end
+        
+        left.to_a + middle.to_a + right.to_a
+      end
+
+    private
+
+      def current_page
+        @collection.current_page
+      end
+
+      def total_pages
+        @collection.total_pages
+      end
+
+      def param_name
+        @param_name ||= @options[:param_name].to_s
+      end
+    end
+  end
+end

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,4 @@
+#!/usr/bin/env ruby
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+opts = %w[--simple-prompt -rirb/completion -rconsole_fixtures]
+exec 'bundle', 'exec', irb, '-Ilib:spec', *opts

data/spec/console_fixtures.rb

@@ -0,0 +1,29 @@
+require 'bundler'
+Bundler.setup
+
+require 'will_paginate/finders/active_record'
+require 'finders/activerecord_test_connector'
+
+ActiverecordTestConnector.setup
+
+windows = RUBY_PLATFORM =~ /(:?mswin|mingw)/
+# used just for the `color` method
+log_subscriber = ActiveSupport::LogSubscriber.log_subscribers.first
+
+IGNORE_SQL = /\b(sqlite_master|sqlite_version)\b|^CREATE TABLE/
+
+ActiveSupport::Notifications.subscribe(/^sql\./) do |*args|
+  data = args.last
+  unless data[:name] =~ /^Fixture/ or data[:sql] =~ IGNORE_SQL
+    if windows
+      puts data[:sql]
+    else
+      puts log_subscriber.send(:color, data[:sql], :cyan)
+    end
+  end
+end
+
+# load all fixtures
+Fixtures.create_fixtures(ActiverecordTestConnector::FIXTURES_PATH, ActiveRecord::Base.connection.tables)
+
+WillPaginate::Finders::ActiveRecord.enable!

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,377 @@
+require 'spec_helper'
+require 'will_paginate/finders/active_record'
+require File.expand_path('../activerecord_test_connector', __FILE__)
+ActiverecordTestConnector.setup
+
+WillPaginate::Finders::ActiveRecord.enable!
+
+describe WillPaginate::Finders::ActiveRecord do
+  
+  extend ActiverecordTestConnector::FixtureSetup
+  
+  fixtures :topics, :replies, :users, :projects, :developers_projects
+  
+  it "should integrate with ActiveRecord::Base" do
+    ActiveRecord::Base.should respond_to(:paginate)
+  end
+  
+  it "should paginate" do
+    lambda {
+      users = User.paginate(:page => 1, :per_page => 5)
+      users.length.should == 5
+    }.should run_queries(2)
+  end
+  
+  it "should fail when encountering unknown params" do
+    lambda {
+      User.paginate :foo => 'bar', :page => 1, :per_page => 4
+    }.should raise_error(ArgumentError)
+  end
+
+  describe "counting" do
+    it "should not accept :count parameter" do
+      pending
+      lambda {
+        User.paginate :page => 1, :count => {}
+      }.should raise_error(ArgumentError)
+    end
+    
+    it "should guess the total count" do
+      lambda {
+        topics = Topic.paginate :page => 2, :per_page => 3
+        topics.total_entries.should == 4
+      }.should run_queries(1)
+    end
+
+    it "should guess that there are no records" do
+      lambda {
+        topics = Topic.where(:project_id => 999).paginate :page => 1, :per_page => 3
+        topics.total_entries.should == 0
+      }.should run_queries(1)
+    end
+  end
+  
+  it "should not ignore :select parameter when it says DISTINCT" do
+    users = User.select('DISTINCT salary').paginate :page => 2
+    users.total_entries.should == 5
+  end
+  
+  it "should count with scoped select when :select => DISTINCT" do
+    pending
+    Topic.distinct.paginate :page => 2
+  end
+
+  describe "paginate_by_sql" do
+    it "should respond" do
+      User.should respond_to(:paginate_by_sql)
+    end
+
+    it "should paginate" do
+      lambda {
+        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['title'].should be_nil
+      }.should run_queries(2)
+    end
+
+    it "should respect total_entries setting" do
+      lambda {
+        sql = "select content from topics"
+        topics = Topic.paginate_by_sql sql, :page => 1, :per_page => 1, :total_entries => 999
+        topics.total_entries.should == 999
+      }.should run_queries(1)
+    end
+
+    it "should strip the order when counting" do
+      lambda {
+        sql = "select id, title, content from topics order by title"
+        topics = Topic.paginate_by_sql sql, :page => 1, :per_page => 2
+        topics.first.should == topics(:ar)
+      }.should run_queries(2)
+    end
+    
+    it "shouldn't change the original query string" do
+      query = 'select * from topics where 1 = 2'
+      original_query = query.dup
+      Topic.paginate_by_sql(query, :page => 1)
+      query.should == original_query
+    end
+  end
+
+  it "doesn't mangle options" do
+    options = { :page => 1 }
+    options.expects(:delete).never
+    options_before = options.dup
+    
+    Topic.paginate(options)
+    options.should == options_before
+  end
+  
+  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
+  
+  it "should remove :include for count" do
+    lambda {
+      Developer.paginate :page => 1, :per_page => 1, :include => :projects
+      $query_sql.last.should_not include(' JOIN ')
+    }.should run_queries(4)
+  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
+  
+  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.only_recent.paginate(: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 not paginate with dynamic finder" do
+    lambda {
+      Developer.paginate_by_salary(100000, :page => 1, :per_page => 5)
+    }.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
+      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
+  
+  it "should paginate an array of IDs" do
+    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
+  
+  protected
+  
+    def run_queries(num)
+      QueryCountMatcher.new(num)
+    end
+
+end
+
+class QueryCountMatcher
+  def initialize(num)
+    @expected_count = num
+  end
+
+  def matches?(block)
+    $query_count = 0
+    $query_sql = []
+    block.call
+    @queries = $query_sql
+    @count = $query_count
+    @count == @expected_count
+  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