will_paginate 3.0.pre4 → 3.0.0

data/spec/collection_spec.rb

@@ -29,17 +29,6 @@ describe WillPaginate::Collection do
     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
@@ -117,27 +106,22 @@ describe WillPaginate::Collection do
     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
 
+  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?
-        WillPaginate::Collection.create(page, limit, total, &block)
+        described_class.create(page, limit, total, &block)
       else
-        WillPaginate::Collection.new(page, limit, total)
+        described_class.new(page, limit, total)
       end
     end
 

data/spec/console

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

@@ -1,7 +1,7 @@
 require 'bundler'
 Bundler.setup
 
-require 'will_paginate/finders/active_record'
+require 'will_paginate/active_record'
 require 'finders/activerecord_test_connector'
 
 ActiverecordTestConnector.setup
@@ -26,5 +26,3 @@ end
 # load all fixtures
 ActiverecordTestConnector::Fixtures.create_fixtures \
   ActiverecordTestConnector::FIXTURES_PATH, ActiveRecord::Base.connection.tables
-
-WillPaginate::Finders::ActiveRecord.enable!

data/spec/database.yml

@@ -3,20 +3,20 @@ sqlite3:
   adapter: sqlite3
   timeout: 500
 
-sqlite2:
-  database: ":memory:"
-  adapter: sqlite2
-
 mysql:
   adapter: mysql
-  username: rails
-  password: mislav
+  database: will_paginate
+  username: 
+  encoding: utf8
+
+mysql2:
+  adapter: mysql2
+  database: will_paginate
+  username: 
   encoding: utf8
-  database: will_paginate_unittest
 
 postgres:
   adapter: postgresql
-  username: mislav
-  password: mislav
-  database: will_paginate_unittest
+  database: will_paginate
+  username: postgres
   min_messages: warning

data/spec/finders/active_record_spec.rb

@@ -1,11 +1,11 @@
 require 'spec_helper'
-require 'will_paginate/finders/active_record'
+require 'will_paginate/active_record'
 require File.expand_path('../activerecord_test_connector', __FILE__)
-ActiverecordTestConnector.setup
 
-WillPaginate::Finders::ActiveRecord.enable!
+ActiverecordTestConnector.setup
+abort unless ActiverecordTestConnector.able_to_connect
 
-describe WillPaginate::Finders::ActiveRecord do
+describe WillPaginate::ActiveRecord do
   
   extend ActiverecordTestConnector::FixtureSetup
   
@@ -52,6 +52,19 @@ describe WillPaginate::Finders::ActiveRecord do
       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
@@ -81,13 +94,6 @@ describe WillPaginate::Finders::ActiveRecord do
   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
@@ -101,6 +107,64 @@ describe WillPaginate::Finders::ActiveRecord do
         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 "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.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
   end
   
   it "should not ignore :select parameter when it says DISTINCT" do
@@ -222,23 +286,6 @@ describe WillPaginate::Finders::ActiveRecord do
     result.total_entries.should == 4
   end
   
-  it "should remove :include for count" do
-    lambda {
-      Developer.paginate(:page => 1, :per_page => 1, :include => :projects).to_a
-      $query_sql.last.should_not =~ /\bJOIN\b/
-    }.should run_queries(3..4)
-  end
-
-  it "should keep :include for count when they are referenced in :conditions" do
-    Developer.paginate(
-      :page => 1, :per_page => 1,
-      :include => :projects,
-      :conditions => 'projects.id > 2'
-    ).to_a
-
-    $query_sql.last.should =~ /\bJOIN\b/
-  end
-  
   describe "associations" do
     it "should paginate with include" do
       project = projects(:active_record)
@@ -395,6 +442,13 @@ describe WillPaginate::Finders::ActiveRecord do
       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
   
   protected
   

data/spec/finders/activerecord_test_connector.rb

@@ -5,7 +5,14 @@ require 'active_support/multibyte' # needed for Ruby 1.9.1
 $query_count = 0
 $query_sql = []
 
-ignore_sql = /^(?:PRAGMA|SELECT (?:currval|CAST|@@IDENTITY|@@ROWCOUNT)|SHOW FIELDS)\b|\bFROM sqlite_master\b/
+ignore_sql = /
+    ^(
+      PRAGMA | SHOW\ max_identifier_length |
+      SELECT\ (currval|CAST|@@IDENTITY|@@ROWCOUNT) |
+      SHOW\ (FIELDS|TABLES)
+    )\b |
+    \bFROM\ (sqlite_master|pg_tables|pg_attribute)\b
+  /x
 
 ActiveSupport::Notifications.subscribe(/^sql\./) do |*args|
   payload = args.last
@@ -60,6 +67,7 @@ module ActiverecordTestConnector
     
     ActiveRecord::Base.configurations = { db => configuration }
     ActiveRecord::Base.establish_connection(db)
+    ActiveRecord::Base.default_timezone = :utc
   end
 
   def load_schema

data/spec/finders/data_mapper_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 begin
-  require 'will_paginate/finders/data_mapper'
+  require 'will_paginate/data_mapper'
   require File.expand_path('../data_mapper_test_connector', __FILE__)
 rescue LoadError => error
   warn "Error running DataMapper specs: #{error.message}"
@@ -10,59 +10,70 @@ else
   datamapper_loaded = true
 end
 
-describe WillPaginate::Finders::DataMapper do
-    
-  it "should make #paginate available to DM resource classes" do
-    Animal.should respond_to(:paginate)
+describe WillPaginate::DataMapper do
+
+  it "has per_page" do
+    Animal.per_page.should == 30
+    begin
+      Animal.per_page = 10
+      Animal.per_page.should == 10
+
+      subclass = Class.new(Animal)
+      subclass.per_page.should == 10
+    ensure
+      Animal.per_page = 30
+    end
   end
-  
-  it "should paginate" do
-    Animal.expects(:all).with(:limit => 5, :offset => 0).returns([])
-    Animal.paginate(:page => 1, :per_page => 5)
+
+  it "doesn't make normal collections appear paginated" do
+    Animal.all.should_not be_paginated
   end
-  
-  it "should NOT to paginate_by_sql" do
-    Animal.should_not respond_to(:paginate_by_sql)
+
+  it "paginates to first page by default" do
+    animals = Animal.paginate(:page => nil)
+
+    animals.should be_paginated
+    animals.current_page.should == 1
+    animals.per_page.should == 30
+    animals.offset.should == 0
+    animals.total_entries.should == 3
+    animals.total_pages.should == 1
   end
-  
-  it "should support explicit :all argument" do
-    Animal.expects(:all).with(instance_of(Hash)).returns([])
-    Animal.paginate(:all, :page => nil)
+
+  it "paginates to first page, explicit limit" do
+    animals = Animal.paginate(:page => 1, :per_page => 2)
+
+    animals.current_page.should == 1
+    animals.per_page.should == 2
+    animals.total_entries.should == 3
+    animals.total_pages.should == 2
+    animals.map {|a| a.name }.should == %w[ Dog Cat ]
   end
-  
-  it "should support conditional pagination" do
-    filtered_result = Animal.paginate(:all, :name => 'Dog', :page => nil)
-    filtered_result.size.should == 1
-    filtered_result.first.should == Animal.first(:name => 'Dog')
+
+  it "paginates to second page" do
+    animals = Animal.paginate(:page => 2, :per_page => 2)
+
+    animals.current_page.should == 2
+    animals.offset.should == 2
+    animals.map {|a| a.name }.should == %w[ Lion ]
   end
-  
-  it "should leave extra parameters intact" do
-    Animal.expects(:all).with(:name => 'Dog', :limit => 4, :offset => 0 ).returns(Array.new(5))
-    Animal.expects(:count).with({:name => 'Dog'}).returns(1)
-  
-    Animal.paginate :name => 'Dog', :page => 1, :per_page => 4
+
+  it "paginates a collection" do
+    friends = Animal.all(:notes.like => '%friend%')
+    friends.paginate(:page => 1).per_page.should == 30
+    friends.paginate(:page => 1, :per_page => 1).total_entries.should == 2
   end
 
-  describe "counting" do
-    it "should ignore nil in :count parameter" do
-      lambda { Animal.paginate :page => nil, :count => nil }.should_not raise_error
-    end
-    
-    it "should guess the total count" do
-      Animal.expects(:all).returns(Array.new(2))
-      Animal.expects(:count).never
-  
-      result = Animal.paginate :page => 2, :per_page => 4
-      result.total_entries.should == 6
-    end
-  
-    it "should guess that there are no records" do
-      Animal.expects(:all).returns([])
-      Animal.expects(:count).never
-  
-      result = Animal.paginate :page => 1, :per_page => 4
-      result.total_entries.should == 0
-    end
+  it "paginates a limited collection" do
+    animals = Animal.all(:limit => 2).paginate(:page => 1)
+    animals.per_page.should == 2
+  end
+
+  it "has page() method" do
+    Animal.page(2).per_page.should == 30
+    Animal.page(2).offset.should == 30
+    Animal.page(2).current_page.should == 2
+    Animal.all(:limit => 2).page(2).per_page.should == 2
   end
-  
+
 end if datamapper_loaded

data/spec/finders/data_mapper_test_connector.rb

@@ -1,4 +1,6 @@
+require 'sqlite3'
 require 'dm-core'
+require 'dm-core/support/logger'
 require 'dm-migrations'
 
 DataMapper.setup :default, 'sqlite3::memory:'
@@ -19,4 +21,9 @@ end
 
 # Load fixtures
 Animal.auto_migrate!
-Animal.setup
+Animal.setup
+
+if 'irb' == $0
+  DataMapper.logger.set_log($stdout, :debug)
+  DataMapper.logger.auto_flush = true
+end

data/spec/finders/sequel_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 begin
-  require 'will_paginate/finders/sequel'
+  require 'will_paginate/sequel'
   require File.expand_path('../sequel_test_connector', __FILE__)
 rescue LoadError, ArgumentError => error
   warn "Error running Sequel specs: #{error.message}"
@@ -33,17 +33,23 @@ describe Sequel::Dataset::Pagination, 'extension' do
     it "should imitate WillPaginate::Collection" do
       result = Car.paginate(1, 2)
       
+      result.should_not be_empty
+      result.size.should == 2
+      result.length.should == 2
       result.total_entries.should == 3
       result.total_pages.should == 2
       result.per_page.should == 2
       result.current_page.should == 1
-      result.previous_page.should be_nil
-      result.next_page.should == 2
     end
     
     it "should perform" do
       Car.paginate(1, 2).all.should == [Car[1], Car[2]]
     end
+
+    it "should be empty" do
+      result = Car.paginate(3, 2)
+      result.should be_empty
+    end
     
     it "should perform with #select and #order" do
       result = Car.select("name as foo".lit).order(:name).paginate(1, 2).all