will_paginate-rails3 3.0.pre

data/spec/finders/active_resource_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+require 'will_paginate/finders/active_resource'
+require 'active_resource/http_mock'
+
+class AresProject < ActiveResource::Base
+  self.site = 'http://localhost:4000'
+end
+
+describe WillPaginate::Finders::ActiveResource do
+  
+  before :all do
+    # ActiveResource::HttpMock.respond_to do |mock|      
+    #   mock.get "/ares_projects.xml?page=1&per_page=5", {}, [].to_xml
+    # end
+  end
+  
+  it "should integrate with ActiveResource::Base" do
+    ActiveResource::Base.should respond_to(:paginate)
+  end
+  
+  it "should error when no parameters for #paginate" do
+    lambda { AresProject.paginate }.should raise_error(ArgumentError)
+  end
+  
+  it "should paginate" do
+    AresProject.expects(:find_every).with(:params => { :page => 1, :per_page => 5 }).returns([])
+    AresProject.paginate(:page => 1, :per_page => 5)
+  end
+  
+  it "should have 30 per_page as default" do
+    AresProject.expects(:find_every).with(:params => { :page => 1, :per_page => 30 }).returns([])
+    AresProject.paginate(:page => 1)
+  end
+  
+  it "should support #paginate(:all)" do
+    lambda { AresProject.paginate(:all) }.should raise_error(ArgumentError)
+  end
+  
+  it "should error #paginate(:other)" do
+    lambda { AresProject.paginate(:first) }.should raise_error(ArgumentError)
+  end
+  
+  protected
+  
+    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  
+end

data/spec/finders/activerecord_test_connector.rb

@@ -0,0 +1,114 @@
+require 'active_record'
+require 'active_record/version'
+require 'active_record/fixtures'
+require 'active_support/multibyte' # needed for Ruby 1.9.1
+
+$query_count = $query_sql = nil
+
+class ActiverecordTestConnector
+  cattr_accessor :able_to_connect
+  cattr_accessor :connected
+
+  FIXTURES_PATH = File.expand_path('../../fixtures', __FILE__)
+
+  # Set our defaults
+  self.connected = false
+  self.able_to_connect = true
+
+  def self.setup
+    unless self.connected || !self.able_to_connect
+      setup_connection
+      load_schema
+      add_load_path FIXTURES_PATH
+      self.connected = true
+    end
+  rescue Exception => e  # errors from ActiveRecord setup
+    $stderr.puts "\nSkipping ActiveRecord tests: #{e}\n\n"
+    self.able_to_connect = false
+  end
+
+  private
+  
+  def self.add_load_path(path)
+    dep = defined?(ActiveSupport::Dependencies) ? ActiveSupport::Dependencies : ::Dependencies
+    dep.load_paths.unshift path
+  end
+
+  def self.setup_connection
+    db = ENV['DB'].blank?? 'sqlite3' : ENV['DB']
+    
+    configurations = YAML.load_file(File.expand_path('../../database.yml', __FILE__))
+    raise "no configuration for '#{db}'" unless configurations.key? db
+    configuration = configurations[db]
+    
+    ActiveRecord::Base.logger = Logger.new(STDOUT) if $0 == 'irb'
+    puts "using #{configuration['adapter']} adapter"
+    
+    ActiveRecord::Base.configurations = { db => configuration }
+    ActiveRecord::Base.establish_connection(db)
+    prepare ActiveRecord::Base.connection
+  end
+
+  def self.load_schema
+    ActiveRecord::Base.silence do
+      ActiveRecord::Migration.verbose = false
+      load File.join(FIXTURES_PATH, 'schema.rb')
+    end
+  end
+
+  def self.prepare(conn)
+    class << conn
+      IGNORED_SQL = /^(?:PRAGMA|SELECT (?:currval|CAST|@@IDENTITY|@@ROWCOUNT)|SHOW FIELDS)\b/
+
+      def execute_with_counting(sql, name = nil, &block)
+        if $query_count and IGNORED_SQL !~ sql
+          $query_count += 1
+          $query_sql << sql
+        end
+        execute_without_counting(sql, name, &block)
+      end
+
+      alias_method_chain :execute, :counting
+    end
+  end
+  
+  def self.show_sql
+    ActiveSupport::Notifications.subscribe('active_record.sql') do |*args|
+      puts args.last[:sql]
+    end
+  end
+  
+  module FixtureSetup
+    def fixtures(*tables)
+      table_names = tables.map { |t| t.to_s }
+
+      fixtures = Fixtures.create_fixtures ActiverecordTestConnector::FIXTURES_PATH, table_names
+      @@loaded_fixtures = {}
+      @@fixture_cache = {}
+
+      unless fixtures.nil?
+        if fixtures.instance_of?(Fixtures)
+          @@loaded_fixtures[fixtures.table_name] = fixtures
+        else
+          fixtures.each { |f| @@loaded_fixtures[f.table_name] = f }
+        end
+      end
+
+      table_names.each do |table_name|
+        define_method(table_name) do |*fixtures|
+          @@fixture_cache[table_name] ||= {}
+
+          instances = fixtures.map do |fixture|
+            if @@loaded_fixtures[table_name][fixture.to_s]
+              @@fixture_cache[table_name][fixture] ||= @@loaded_fixtures[table_name][fixture.to_s].find
+            else
+              raise StandardError, "No fixture with name '#{fixture}' found for table '#{table_name}'"
+            end
+          end
+
+          instances.size == 1 ? instances.first : instances
+        end
+      end
+    end
+  end
+end

data/spec/finders/data_mapper_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+require 'will_paginate/finders/data_mapper'
+require File.expand_path('../data_mapper_test_connector', __FILE__)
+
+require 'will_paginate'
+
+describe WillPaginate::Finders::DataMapper do
+    
+  it "should make #paginate available to DM resource classes" do
+    Animal.should respond_to(:paginate)
+  end
+  
+  it "should paginate" do
+    Animal.expects(:all).with(:limit => 5, :offset => 0).returns([])
+    Animal.paginate(:page => 1, :per_page => 5)
+  end
+  
+  it "should NOT to paginate_by_sql" do
+    Animal.should_not respond_to(:paginate_by_sql)
+  end
+  
+  it "should support explicit :all argument" do
+    Animal.expects(:all).with(instance_of(Hash)).returns([])
+    Animal.paginate(:all, :page => nil)
+  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')
+  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
+  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
+  end
+  
+end

data/spec/finders/data_mapper_test_connector.rb

@@ -0,0 +1,20 @@
+require 'dm-core'
+DataMapper.setup :default, 'sqlite3::memory:'
+
+# Define models
+class Animal
+  include DataMapper::Resource
+  property :id, Serial
+  property :name, String
+  property :notes, Text
+ 
+  def self.setup
+    Animal.create(:name => 'Dog', :notes => "Man's best friend")
+    Animal.create(:name => 'Cat', :notes => "Woman's best friend")
+    Animal.create(:name => 'Lion', :notes => 'King of the Jungle')
+  end
+end
+
+# Load fixtures
+Animal.auto_migrate!
+Animal.setup

data/spec/finders/sequel_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+require 'will_paginate/finders/sequel'
+require File.expand_path('../sequel_test_connector', __FILE__)
+
+describe Sequel::Dataset::Pagination, 'extension' do
+  
+  class Car < Sequel::Model
+  end
+
+  it "should have the #paginate method" do
+    Car.should respond_to(:paginate)
+  end
+
+  it "should NOT have the #paginate_by_sql method" do
+    Car.should_not respond_to(:paginate_by_sql)
+  end
+
+  describe 'pagination' do
+    before(:all) do
+      Car.create(:name => 'Shelby', :notes => "Man's best friend")
+      Car.create(:name => 'Aston Martin', :notes => "Woman's best friend")
+      Car.create(:name => 'Corvette', :notes => 'King of the Jungle')
+    end
+
+    it "should imitate WillPaginate::Collection" do
+      result = Car.paginate(1, 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 perform with #select and #order" do
+      result = Car.select("name as foo".lit).order(:name).paginate(1, 2).all
+      result.size.should == 2
+      result.first.values[:foo].should == "Aston Martin"
+    end
+
+    it "should perform with #filter" do
+      results = Car.filter(:name => 'Shelby').paginate(1, 2).all
+      results.size.should == 1
+      results.first.should == Car.find(:name => 'Shelby')
+    end
+  end
+
+end

data/spec/finders/sequel_test_connector.rb

@@ -0,0 +1,9 @@
+require 'sequel'
+
+db = Sequel.sqlite
+
+db.create_table :cars do
+  primary_key :id, :integer, :auto_increment => true
+  column :name, :text
+  column :notes, :text
+end

data/spec/finders_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+require 'will_paginate/finders/base'
+
+class Model
+  extend WillPaginate::Finders::Base
+end
+
+describe WillPaginate::Finders::Base do
+  it "should define default per_page of 30" do
+    Model.per_page.should == 30
+  end
+  
+  it "should allow to set custom per_page" do
+    begin
+      Model.per_page = 25
+      Model.per_page.should == 25
+    ensure
+      Model.per_page = 30
+    end
+  end
+
+  it "should result with WillPaginate::Collection" do
+    Model.expects(:wp_query)
+    Model.paginate(:page => nil).should be_instance_of(WillPaginate::Collection)
+  end
+
+  it "should delegate pagination to wp_query" do
+    Model.expects(:wp_query).with({}, instance_of(WillPaginate::Collection), [])
+    Model.paginate :page => nil
+  end
+
+  it "should complain when no hash parameters given" do
+    lambda {
+      Model.paginate
+    }.should raise_error(ArgumentError, 'parameter hash expected')
+  end
+
+  it "should complain when no :page parameter present" do
+    lambda {
+      Model.paginate :per_page => 6
+    }.should raise_error(ArgumentError, ':page parameter required')
+  end
+
+  it "should complain when both :count and :total_entries are given" do
+    lambda {
+      Model.paginate :page => 1, :count => {}, :total_entries => 1
+    }.should raise_error(ArgumentError, ':count and :total_entries are mutually exclusive')
+  end
+
+  it "should never mangle options" do
+    options = { :page => 1 }
+    options.expects(:delete).never
+    options_before = options.dup
+    
+    Model.expects(:wp_query)
+    Model.paginate(options)
+    
+    options.should == options_before
+  end
+
+  it "should provide paginated_each functionality" do
+    collection = stub('collection', :size => 5, :empty? => false, :per_page => 5)
+    collection.expects(:each).times(2).returns(collection)
+    last_collection = stub('collection', :size => 4, :empty? => false, :per_page => 5)
+    last_collection.expects(:each).returns(last_collection)
+    
+    params = { :order => 'id', :total_entries => 0 }
+    
+    Model.expects(:paginate).with(params.merge(:page => 2)).returns(collection)
+    Model.expects(:paginate).with(params.merge(:page => 3)).returns(collection)
+    Model.expects(:paginate).with(params.merge(:page => 4)).returns(last_collection)
+    
+    total = Model.paginated_each(:page => '2') { }
+    total.should == 14
+  end
+end

data/spec/fixtures/admin.rb

@@ -0,0 +1,3 @@
+class Admin < User
+  has_many :companies, :finder_sql => 'SELECT * FROM companies'
+end

data/spec/fixtures/developer.rb

@@ -0,0 +1,13 @@
+class Developer < User
+  has_and_belongs_to_many :projects, :include => :topics, :order => 'projects.name'
+
+  def self.with_poor_ones(&block)
+    with_scope :find => { :conditions => ['salary <= ?', 80000], :order => 'salary' } do
+      yield
+    end
+  end
+
+  scope :poor, :conditions => ['salary <= ?', 80000], :order => 'salary'
+
+  def self.per_page() 10 end
+end

data/spec/fixtures/developers_projects.yml

@@ -0,0 +1,13 @@
+david_action_controller:
+  developer_id: 1
+  project_id: 2
+  joined_on: 2004-10-10
+
+david_active_record:
+  developer_id: 1
+  project_id: 1
+  joined_on: 2004-10-10
+
+jamis_active_record:
+  developer_id: 2
+  project_id: 1

data/spec/fixtures/project.rb

@@ -0,0 +1,13 @@
+class Project < ActiveRecord::Base
+  has_and_belongs_to_many :developers, :uniq => true
+  
+  has_many :topics
+    # :finder_sql  => 'SELECT * FROM topics WHERE (topics.project_id = #{id})',
+    # :counter_sql => 'SELECT COUNT(*) FROM topics WHERE (topics.project_id = #{id})'
+  
+  has_many :replies, :through => :topics do
+    def only_recent(params = {})
+      scoped.where(['replies.created_at > ?', 15.minutes.ago])
+    end
+  end
+end

data/spec/fixtures/projects.yml

@@ -0,0 +1,6 @@
+active_record:
+  id: 1
+  name: Active Record
+action_controller:
+  id: 2
+  name: Action Controller