will_paginate 2.3.16 → 3.0.pre

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/{test → spec}/fixtures/developer.rb

@@ -7,8 +7,7 @@ class Developer < User
     end
   end
 
-  named_scope :distinct, :select => 'DISTINCT `users`.*'
-  named_scope :poor, :conditions => ['salary <= ?', 80000], :order => 'salary'
+  scope :poor, :conditions => ['salary <= ?', 80000], :order => 'salary'
 
-  self.per_page = 10
+  def self.per_page() 10 end
 end

data/{test → spec}/fixtures/project.rb

@@ -6,12 +6,8 @@ class Project < ActiveRecord::Base
     # :counter_sql => 'SELECT COUNT(*) FROM topics WHERE (topics.project_id = #{id})'
   
   has_many :replies, :through => :topics do
-    def find_recent(params = {})
-      with_scope :find => { :conditions => ['replies.created_at > ?', 15.minutes.ago] } do
-        find :all, params
-      end
+    def only_recent(params = {})
+      scoped.where(['replies.created_at > ?', 15.minutes.ago])
     end
   end
-
-  has_many :unique_replies, :through => :topics, :source => :replies, :uniq => true
 end

data/{test → spec}/fixtures/projects.yml

@@ -3,4 +3,4 @@ active_record:
   name: Active Record
 action_controller:
   id: 2
-  name: Active Controller
+  name: Action Controller

data/{test → spec}/fixtures/reply.rb

@@ -1,7 +1,7 @@
 class Reply < ActiveRecord::Base
   belongs_to :topic, :include => [:replies]
 
-  named_scope :recent, :conditions => ['replies.created_at > ?', 15.minutes.ago]
+  scope :recent, :conditions => ['replies.created_at > ?', 15.minutes.ago]
   
   validates_presence_of :content
 end

data/spec/fixtures/topic.rb

@@ -0,0 +1,7 @@
+class Topic < ActiveRecord::Base
+  has_many :replies, :dependent => :destroy, :order => 'replies.created_at DESC'
+  belongs_to :project
+
+  scope :mentions_activerecord, :conditions => ['topics.title LIKE ?', '%ActiveRecord%']
+  scope :distinct, :select => "DISTINCT #{table_name}.*"
+end

data/spec/rcov.opts

@@ -0,0 +1,2 @@
+--exclude ^\/,^spec\/,core_ext.rb,deprecation.rb
+--no-validator-links

data/spec/spec.opts

@@ -0,0 +1,2 @@
+--colour
+--reverse

data/spec/spec_helper.rb

@@ -0,0 +1,74 @@
+require 'spec/autorun'
+
+module MyExtras
+  protected
+  
+  def include_phrase(string)
+    PhraseMatcher.new(string)
+  end
+
+  def collection(params = {})
+    if params[:total_pages]
+      params[:per_page] = 1
+      params[:total_entries] = params[:total_pages]
+    end
+    WillPaginate::Collection.new(params[:page] || 1, params[:per_page] || 30, params[:total_entries])
+  end
+  
+  def have_deprecation
+    DeprecationMatcher.new
+  end
+end
+
+Spec::Runner.configure do |config|
+  # config.include My::Pony, My::Horse, :type => :farm
+  config.include MyExtras
+  # config.predicate_matchers[:swim] = :can_swim?
+  
+  config.mock_with :mocha
+end
+
+class PhraseMatcher
+  def initialize(string)
+    @string = string
+    @pattern = /\b#{string}\b/
+  end
+
+  def matches?(actual)
+    @actual = actual.to_s
+    @actual =~ @pattern
+  end
+
+  def failure_message
+    "expected #{@actual.inspect} to contain phrase #{@string.inspect}"
+  end
+
+  def negative_failure_message
+    "expected #{@actual.inspect} not to contain phrase #{@string.inspect}"
+  end
+end
+
+class DeprecationMatcher
+  def initialize
+    @old_behavior = WillPaginate::Deprecation.behavior
+    @messages = []
+    WillPaginate::Deprecation.behavior = lambda { |message, callstack|
+      @messages << message
+    }
+  end
+
+  def matches?(block)
+    block.call
+    !@messages.empty?
+  ensure
+    WillPaginate::Deprecation.behavior = @old_behavior
+  end
+
+  def failure_message
+    "expected block to raise a deprecation warning"
+  end
+
+  def negative_failure_message
+    "expected block not to raise deprecation warnings, #{@messages.size} raised"
+  end
+end

data/spec/tasks.rake

@@ -0,0 +1,60 @@
+require 'spec/rake/spectask'
+
+spec_opts = 'spec/spec.opts'
+
+desc 'Run framework-agnostic specs'
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.libs << 'spec'
+  t.spec_opts = ['--options', spec_opts]
+  t.spec_files = FileList.new('spec/**/*_spec.rb') do |files|
+    files.exclude(/\b(active_record|active_resource|action_view|data_mapper|sequel)_/)
+  end
+end
+
+namespace :spec do
+  desc 'Run specs for core, ActiveRecord and ActionView'
+  Spec::Rake::SpecTask.new(:rails) do |t|
+    t.libs << 'spec'
+    t.spec_opts = ['--options', spec_opts]
+    t.spec_files = FileList.new('spec/**/*_spec.rb') do |files|
+      files.exclude(/\b(data_mapper|sequel)_/)
+    end
+  end
+  
+  desc 'Run specs for DataMapper'
+  Spec::Rake::SpecTask.new(:datamapper) do |t|
+    t.libs << 'spec'
+    t.spec_opts = ['--options', spec_opts]
+    t.spec_files = FileList.new('spec/finders_spec.rb', 'spec/finders/data_mapper_spec.rb')
+  end
+  
+  desc 'Run specs for Sequel'
+  Spec::Rake::SpecTask.new(:sequel) do |t|
+    t.libs << 'spec'
+    t.spec_opts = ['--options', spec_opts]
+    t.spec_files = FileList.new('spec/finders_spec.rb', 'spec/finders/sequel_spec.rb')
+  end
+  
+  desc 'Analyze spec coverage with RCov'
+  Spec::Rake::SpecTask.new(:rcov) do |t|
+    t.libs << 'spec'
+    t.spec_opts = ['--options', spec_opts]
+    t.rcov = true
+    t.rcov_opts = lambda do
+      IO.readlines('spec/rcov.opts').map { |l| l.chomp.split(" ") }.flatten
+    end
+  end
+  
+  desc 'Print Specdoc for all specs'
+  Spec::Rake::SpecTask.new(:doc) do |t|
+    t.libs << 'spec'
+    t.spec_opts = ['--format', 'specdoc', '--dry-run']
+  end
+  
+  desc 'Generate HTML report'
+  Spec::Rake::SpecTask.new(:html) do |t|
+    t.libs << 'spec'
+    t.spec_opts = ['--format', 'html:doc/spec_results.html', '--diff']
+    t.fail_on_error = false
+  end
+end