will_paginate 3.1.8 → 4.0.0

data/spec/collection_spec.rb

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

@@ -1,12 +0,0 @@
-#!/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

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

@@ -1,29 +0,0 @@
-sqlite3:
-  database: ":memory:"
-  adapter: sqlite3
-  timeout: 500
-
-mysql: &mysql
-  adapter: mysql
-  database: will_paginate
-  username: root
-  encoding: utf8
-<% if File.exist?("/var/run/mysql5/mysqld.sock") %>
-  host: localhost
-  socket: /var/run/mysql5/mysqld.sock
-<% elsif File.exist? "/tmp/mysql.sock" %>
-  host: localhost
-  socket: /tmp/mysql.sock
-<% else %>
-  host: 127.0.0.1
-<% end %>
-
-mysql2:
-  <<: *mysql
-  adapter: mysql2
-
-postgres:
-  adapter: postgresql
-  database: will_paginate
-  username: <%= "postgres" if ENV["TRAVIS"] %>
-  min_messages: warning

data/spec/fake_rubygems.rb

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

@@ -1,417 +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 "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 2 queries" do
-    lambda {
-      result = Topic.paginate :page => 2
-      result.total_pages.should == 1
-      result.should be_empty
-    }.should run_queries(2)
-  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