will_paginate_seo 3.0.4

data/lib/will_paginate/view_helpers/link_renderer_base.rb

@@ -0,0 +1,77 @@
+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 = 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
+        @total_pages ||= @collection.total_pages
+      end
+    end
+  end
+end

data/lib/will_paginate/view_helpers/merb.rb

@@ -0,0 +1,26 @@
+require 'will_paginate/core_ext'
+require 'will_paginate/view_helpers'
+require 'will_paginate/view_helpers/link_renderer'
+
+module WillPaginate
+  module Merb
+    include ViewHelpers
+
+    def will_paginate(collection, options = {}) #:nodoc:
+      options = options.merge(:renderer => LinkRenderer) unless options[:renderer]
+      super(collection, options)
+    end
+
+    class LinkRenderer < ViewHelpers::LinkRenderer
+      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, self)
+  end
+end
+

data/lib/will_paginate/view_helpers/sinatra.rb

@@ -0,0 +1,41 @@
+require 'sinatra/base'
+require 'will_paginate/view_helpers'
+require 'will_paginate/view_helpers/link_renderer'
+
+module WillPaginate
+  module Sinatra
+    module Helpers
+      include ViewHelpers
+
+      def will_paginate(collection, options = {}) #:nodoc:
+        options = options.merge(:renderer => LinkRenderer) unless options[:renderer]
+        super(collection, options)
+      end
+    end
+
+    class LinkRenderer < ViewHelpers::LinkRenderer
+      protected
+
+      def url(page)
+        str = File.join(request.script_name.to_s, request.path_info)
+        params = request.GET.merge(param_name.to_s => page.to_s)
+        params.update @options[:params] if @options[:params]
+        str << '?' << build_query(params)
+      end
+
+      def request
+        @template.request
+      end
+
+      def build_query(params)
+        Rack::Utils.build_nested_query params
+      end
+    end
+
+    def self.registered(app)
+      app.helpers Helpers
+    end
+
+    ::Sinatra.register self
+  end
+end

data/spec/collection_spec.rb

@@ -0,0 +1,139 @@
+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
+
+  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
+
+  describe "out of bounds" do
+    it "is out of bounds when page number is too high" do
+      create(2, 3, 2).should be_out_of_bounds
+    end
+
+    it "isn't out of bounds when inside collection" do
+      create(1, 3, 2).should_not be_out_of_bounds
+    end
+
+    it "isn't out of bounds when the collection is empty" do
+      collection = create(1, 3, 0)
+      collection.should_not be_out_of_bounds
+      collection.total_pages.should == 1
+    end
+  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 not respond to page_count anymore" do
+    Proc.new { create.page_count }.should raise_error(NoMethodError)
+  end
+
+  it "inherits per_page from global value" do
+    collection = described_class.new(1)
+    collection.per_page.should == 30
+  end
+
+  private
+  
+    def create(page = 2, limit = 5, total = nil, &block)
+      if block_given?
+        described_class.create(page, limit, total, &block)
+      else
+        described_class.new(page, limit, total)
+      end
+    end
+
+    def array(size = 3)
+      Array.new(size)
+    end
+end

data/spec/console

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+opts = %w[ --simple-prompt -rirb/completion ]
+if ARGV.include? '-dm'
+  opts << '-rwill_paginate/data_mapper' << '-rfinders/data_mapper_test_connector'
+elsif ARGV.include? '-seq'
+  opts << '-rwill_paginate/sequel' << '-rfinders/sequel_test_connector'
+else
+  opts << '-rconsole_fixtures'
+end
+
+exec 'bundle', 'exec', irb, '-Ilib:spec', *opts

data/spec/console_fixtures.rb

@@ -0,0 +1,28 @@
+require 'bundler'
+Bundler.setup
+
+require 'will_paginate/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|PRAGMA)\b/
+
+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
+ActiverecordTestConnector::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
+
+mysql:
+  adapter: mysql
+  database: will_paginate
+  username: 
+  encoding: utf8
+
+mysql2:
+  adapter: mysql2
+  database: will_paginate
+  username: 
+  encoding: utf8
+
+postgres:
+  adapter: postgresql
+  database: will_paginate
+  username: postgres
+  min_messages: warning

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

@@ -0,0 +1,517 @@
+require 'spec_helper'
+require 'will_paginate/active_record'
+require File.expand_path('../activerecord_test_connector', __FILE__)
+
+ActiverecordTestConnector.setup
+abort unless ActiverecordTestConnector.able_to_connect
+
+describe WillPaginate::ActiveRecord do
+  
+  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).to_a
+      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 "relation" do
+    it "should return a relation" do
+      rel = nil
+      lambda {
+        rel = Developer.paginate(:page => 1)
+        rel.per_page.should == 10
+        rel.current_page.should == 1
+      }.should run_queries(0)
+
+      lambda {
+        rel.total_pages.should == 2
+      }.should run_queries(1)
+    end
+
+    it "should keep per-class per_page number" do
+      rel = Developer.order('id').paginate(:page => 1)
+      rel.per_page.should == 10
+    end
+
+    it "should be able to change per_page number" do
+      rel = Developer.order('id').paginate(:page => 1).limit(5)
+      rel.per_page.should == 5
+    end
+
+    it "remembers pagination in sub-relations" do
+      rel = Topic.paginate(:page => 2, :per_page => 3)
+      lambda {
+        rel.total_entries.should == 4
+      }.should run_queries(1)
+      rel = rel.mentions_activerecord
+      rel.current_page.should == 2
+      rel.per_page.should == 3
+      lambda {
+        rel.total_entries.should == 1
+      }.should run_queries(1)
+    end
+
+    it "supports the page() method" do
+      rel = Developer.page('1').order('id')
+      rel.current_page.should == 1
+      rel.per_page.should == 10
+      rel.offset.should == 0
+
+      rel = rel.limit(5).page(2)
+      rel.per_page.should == 5
+      rel.offset.should == 5
+    end
+
+    it "raises on invalid page number" do
+      lambda {
+        Developer.page('foo')
+      }.should raise_error(ArgumentError)
+    end
+
+    it "supports first limit() then page()" do
+      rel = Developer.limit(3).page(3)
+      rel.offset.should == 6
+    end
+
+    it "supports first page() then limit()" do
+      rel = Developer.page(3).limit(3)
+      rel.offset.should == 6
+    end
+
+    it "supports #first" do
+      rel = Developer.order('id').page(2).per_page(4)
+      rel.first.should == users(:dev_5)
+      rel.first(2).should == users(:dev_5, :dev_6)
+    end
+
+    it "supports #last" do
+      rel = Developer.order('id').page(2).per_page(4)
+      rel.last.should == users(:dev_8)
+      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
+    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
+
+    it "forgets count in sub-relations" do
+      lambda {
+        topics = Topic.paginate :page => 1, :per_page => 3
+        topics.total_entries.should == 4
+        topics.where('1 = 1').total_entries.should == 4
+      }.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 {
+        topics.should_not be_empty
+      }.should run_queries(1)
+    end
+    
+    it "support empty? for grouped queries" do
+      topics = Topic.group(:project_id).paginate :page => 1, :per_page => 3
+      lambda {
+        topics.should_not be_empty
+      }.should run_queries(1)
+    end
+
+    it "supports `size` for grouped queries" do
+      topics = Topic.group(:project_id).paginate :page => 1, :per_page => 3
+      lambda {
+        topics.size.should == {nil=>2, 1=>2}
+      }.should run_queries(1)
+    end
+
+    it "overrides total_entries count with a fixed value" do
+      lambda {
+        topics = Topic.paginate :page => 1, :per_page => 3, :total_entries => 999
+        topics.total_entries.should == 999
+        # value is kept even in sub-relations
+        topics.where('1 = 1').total_entries.should == 999
+      }.should run_queries(0)
+    end
+
+    it "supports a non-int for total_entries" do
+      topics = Topic.paginate :page => 1, :per_page => 3, :total_entries => "999"
+      topics.total_entries.should == 999
+    end
+
+    it "removes :include for count" do
+      lambda {
+        developers = Developer.paginate(:page => 1, :per_page => 1).includes(:projects)
+        developers.total_entries.should == 11
+        $query_sql.last.should_not =~ /\bJOIN\b/
+      }.should run_queries(1)
+    end
+
+    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/
+    end
+
+    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
+    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
+
+  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.attributes.has_key?('title').should be_false
+      }.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 "defaults to page 1" do
+      sql = "select content from topics"
+      topics = Topic.paginate_by_sql sql, :page => nil, :per_page => 1
+      topics.current_page.should == 1
+      topics.size.should == 1
+    end
+
+    it "should strip the order when counting" do
+      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)
+      }.should run_queries(2)
+
+      $query_sql.last.should include('COUNT')
+      $query_sql.last.should_not include('order by topics.title')
+    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.to_a # trigger loading of records
+      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, :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)
+      expected_id_ordered   = projects(:active_record, :action_controller)
+
+      lambda {
+        # with association-specified order
+        result = ignore_deprecation {
+          dhh.projects.includes(:topics).paginate(:page => 1, :order => 'projects.name')
+        }
+        result.to_a.should == expected_name_ordered
+        result.total_entries.should == 2
+      }.should run_queries(2)
+
+      # with explicit order
+      result = dhh.projects.paginate(:page => 1).reorder('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, :per_page => 4).reorder('projects.id')
+      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).reorder('replies.id ASC').should == expected.reverse
+    end
+
+    it "should paginate through association extension" do
+      project = Project.order('id').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.to_a # trigger loading of records
+      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" }).to_a
+      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').to_a
+    }.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 = ignore_deprecation { 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 not paginate an array of IDs" do
+    lambda {
+      Developer.paginate((1..8).to_a, :per_page => 3, :page => 2, :order => 'id')
+    }.should raise_error(ArgumentError)
+  end
+
+  it "errors out for invalid values" do |variable|
+    lambda {
+      # page that results in an offset larger than BIGINT
+      Project.page(307445734561825862)
+    }.should raise_error(WillPaginate::InvalidPage, "invalid offset: 9223372036854775830")
+  end
+ end