will_paginate 3.3.1 → 4.0.1

data/spec/finders/active_record_spec.rb

@@ -1,424 +0,0 @@
-require 'spec_helper'
-require 'will_paginate/active_record'
-require File.expand_path('../activerecord_test_connector', __FILE__)
-
-ActiverecordTestConnector.setup
-
-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
-  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 "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 "overrides empty? count call with a total_entries fixed value" do
-      lambda {
-        topics = Topic.paginate :page => 1, :per_page => 3, :total_entries => 999
-        topics.should_not be_empty
-      }.should run_queries(0)
-    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
-      expected = topics(:ar)
-      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 == expected
-      }.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 1 query" do
-    lambda {
-      result = Topic.paginate :page => 2
-      result.total_pages.should == 1
-      result.should be_empty
-    }.should run_queries(1)
-  end
-  
-  describe "associations" do
-    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).order('projects.name').paginate(:page => 1)
-        }
-        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.order('projects.id').limit(4).to_a
-      }.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.where('developers_projects.project_id = 1').joins(join_sql).paginate(:page => 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.where('developers_projects.project_id = 1').joins(join_sql).paginate(:page => 1)
-      result.should == expected
-      result.total_entries.should == 2
-    }.should run_queries(1)
-  end
-
-  it "should paginate with group" do
-    result = nil
-    lambda {
-      result = Developer.select('salary').order('salary').group('salary').
-        paginate(:page => 1, :per_page => 10).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
-
-  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 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

data/spec/finders/activerecord_test_connector.rb

@@ -1,107 +0,0 @@
-require 'active_record'
-require 'active_record/fixtures'
-require 'stringio'
-require 'erb'
-
-$query_count = 0
-$query_sql = []
-
-ignore_sql = /
-    ^(
-      PRAGMA | SHOW\ (max_identifier_length|search_path) |
-      SELECT\ (currval|CAST|@@IDENTITY|@@ROWCOUNT) |
-      SHOW\ ((FULL\ )?FIELDS|TABLES)
-    )\b |
-    \bFROM\ (sqlite_master|pg_tables|pg_attribute)\b
-  /x
-
-ActiveSupport::Notifications.subscribe(/^sql\./) do |*args|
-  payload = args.last
-  unless payload[:name] =~ /^Fixture/ or payload[:sql] =~ ignore_sql
-    $query_count += 1
-    $query_sql << payload[:sql]
-  end
-end
-
-module ActiverecordTestConnector
-  extend self
-  
-  attr_accessor :connected
-
-  FIXTURES_PATH = File.expand_path('../../fixtures', __FILE__)
-
-  # Set our defaults
-  self.connected = false
-
-  def setup
-    unless self.connected
-      setup_connection
-      load_schema
-      add_load_path FIXTURES_PATH
-      self.connected = true
-    end
-  end
-
-  private
-  
-  def add_load_path(path)
-    dep = defined?(ActiveSupport::Dependencies) ? ActiveSupport::Dependencies : ::Dependencies
-    dep.autoload_paths.unshift path
-  end
-
-  def setup_connection
-    db = ENV['DB'].blank?? 'sqlite3' : ENV['DB']
-
-    erb = ERB.new(File.read(File.expand_path('../../database.yml', __FILE__)))
-    configurations = YAML.load(erb.result)
-    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.to_sym)
-    ActiveRecord::Base.default_timezone = :utc
-  end
-
-  def load_schema
-    begin
-      $stdout = StringIO.new
-      ActiveRecord::Migration.verbose = false
-      load File.join(FIXTURES_PATH, 'schema.rb')
-    ensure
-      $stdout = STDOUT
-    end
-  end
-
-  module FixtureSetup
-    def fixtures(*tables)
-      table_names = tables.map { |t| t.to_s }
-
-      fixtures = ActiveRecord::FixtureSet.create_fixtures(ActiverecordTestConnector::FIXTURES_PATH, table_names)
-      @@loaded_fixtures = {}
-      @@fixture_cache = {}
-
-      unless fixtures.nil?
-        fixtures.each { |f| @@loaded_fixtures[f.table_name] = f }
-      end
-
-      table_names.each do |table_name|
-        define_method(table_name) do |*names|
-          @@fixture_cache[table_name] ||= {}
-
-          instances = names.map do |name|
-            if @@loaded_fixtures[table_name][name.to_s]
-              @@fixture_cache[table_name][name] ||= @@loaded_fixtures[table_name][name.to_s].find
-            else
-              raise StandardError, "No fixture with name '#{name}' found for table '#{table_name}'"
-            end
-          end
-
-          instances.size == 1 ? instances.first : instances
-        end
-      end
-    end
-  end
-end

data/spec/fixtures/admin.rb

@@ -1,3 +0,0 @@
-class Admin < User
-  has_many :companies
-end

data/spec/fixtures/developer.rb

@@ -1,9 +0,0 @@
-class Developer < User
-  has_and_belongs_to_many :projects, :join_table => 'developers_projects'
-
-  scope :poor, lambda {
-    where(['salary <= ?', 80000]).order('salary')
-  }
-
-  def self.per_page() 10 end
-end

data/spec/fixtures/developers_projects.yml

@@ -1,13 +0,0 @@
-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

@@ -1,13 +0,0 @@
-class Project < ActiveRecord::Base
-  has_and_belongs_to_many :developers, :join_table => 'developers_projects'
-  
-  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 = {})
-      where(['replies.created_at > ?', 15.minutes.ago])
-    end
-  end
-end

data/spec/fixtures/projects.yml

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

data/spec/fixtures/replies.yml

@@ -1,29 +0,0 @@
-witty_retort:
-  id: 1
-  topic_id: 1
-  content: Birdman is better!
-  created_at: <%= 6.hours.ago.utc.to_s(:db) %>
-  
-another:
-  id: 2
-  topic_id: 2
-  content: Nuh uh!
-  created_at: <%= 1.hour.ago.utc.to_s(:db) %>
-  
-spam:
-  id: 3
-  topic_id: 1
-  content: Nice site!
-  created_at: <%= 1.hour.ago.utc.to_s(:db) %>
-
-decisive:
-  id: 4
-  topic_id: 4
-  content: "I'm getting to the bottom of this"
-  created_at: <%= 30.minutes.ago.utc.to_s(:db) %>
-
-brave:
-  id: 5
-  topic_id: 4
-  content: "AR doesn't scare me a bit"
-  created_at: <%= 10.minutes.ago.utc.to_s(:db) %>

data/spec/fixtures/reply.rb

@@ -1,8 +0,0 @@
-class Reply < ActiveRecord::Base
-  scope :recent, lambda {
-    where(['replies.created_at > ?', 15.minutes.ago]).
-      order('replies.created_at DESC')
-  }
-
-  validates_presence_of :content
-end

data/spec/fixtures/schema.rb

@@ -1,38 +0,0 @@
-ActiveRecord::Schema.define do
-
-  create_table "users", :force => true do |t|
-    t.column "name",       :text
-    t.column "salary",     :integer,  :default => 70000
-    t.column "created_at", :datetime
-    t.column "updated_at", :datetime
-    t.column "type",       :text
-  end
-
-  create_table "projects", :force => true do |t|
-    t.column "name", :text
-  end
-
-  create_table "developers_projects", :id => false, :force => true do |t|
-    t.column "developer_id", :integer, :null => false
-    t.column "project_id",   :integer, :null => false
-    t.column "joined_on",    :date
-    t.column "access_level", :integer, :default => 1
-  end
-
-  create_table "topics", :force => true do |t|
-    t.column "project_id", :integer
-    t.column "title",      :string
-    t.column "subtitle",   :string
-    t.column "content",    :text
-    t.column "created_at", :datetime
-    t.column "updated_at", :datetime
-  end
-
-  create_table "replies", :force => true do |t|
-    t.column "content",    :text
-    t.column "created_at", :datetime
-    t.column "updated_at", :datetime
-    t.column "topic_id",   :integer
-  end
-
-end

data/spec/fixtures/topic.rb

@@ -1,8 +0,0 @@
-class Topic < ActiveRecord::Base
-  has_many :replies, :dependent => :destroy
-  belongs_to :project
-
-  scope :mentions_activerecord, lambda {
-    where(['topics.title LIKE ?', '%ActiveRecord%'])
-  }
-end

data/spec/fixtures/topics.yml

@@ -1,30 +0,0 @@
-futurama:
-  id: 1
-  title: Isnt futurama awesome?
-  subtitle: It really is, isnt it.
-  content: I like futurama
-  created_at: <%= 1.day.ago.utc.to_s(:db) %>
-  updated_at:
-  
-harvey_birdman:
-  id: 2
-  title: Harvey Birdman is the king of all men
-  subtitle: yup
-  content: He really is
-  created_at: <%= 2.hours.ago.utc.to_s(:db) %>
-  updated_at:
-
-rails:
-  id: 3
-  project_id: 1
-  title: Rails is nice
-  subtitle: It makes me happy
-  content: except when I have to hack internals to fix pagination. even then really.
-  created_at: <%= 20.minutes.ago.utc.to_s(:db) %>
-
-ar:
-  id: 4
-  project_id: 1
-  title: ActiveRecord sometimes freaks me out
-  content: "I mean, what's the deal with eager loading?"
-  created_at: <%= 15.minutes.ago.utc.to_s(:db) %>