will_paginate 3.1.6 → 4.0.0

data/spec/finders/activerecord_test_connector.rb

@@ -1,127 +0,0 @@
-require 'active_record'
-require 'active_record/fixtures'
-require 'active_support/multibyte' # needed for Ruby 1.9.1
-require 'stringio'
-require 'erb'
-
-# https://travis-ci.org/mislav/will_paginate/jobs/99999001
-require 'active_support/core_ext/string/conversions'
-class String
-  alias to_datetime_without_patch to_datetime
-  def to_datetime
-    to_datetime_without_patch
-  rescue ArgumentError
-    return nil
-  end
-end
-
-$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__)
-
-  Fixtures = defined?(ActiveRecord::FixtureSet) ? ActiveRecord::FixtureSet :
-             defined?(ActiveRecord::Fixtures) ? ActiveRecord::Fixtures :
-             ::Fixtures
-
-  # 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 = 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

@@ -1,114 +0,0 @@
-require 'spec_helper'
-
-if !ENV['SKIP_NONRAILS_TESTS']
-  require 'will_paginate/data_mapper'
-  require File.expand_path('../data_mapper_test_connector', __FILE__)
-  datamapper_loaded = true
-else
-  datamapper_loaded = false
-end
-
-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 "doesn't make normal collections appear paginated" do
-    Animal.all.should_not be_paginated
-  end
-
-  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 "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 "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 "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
-
-  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
-
-  it "has total_pages at 1 for empty collections" do
-    Animal.all(:conditions => ['1=2']).page(1).total_pages.should == 1
-  end
-
-  it "overrides total_entries count with a fixed value" do
-    lambda {
-      animals = Animal.paginate :page => 1, :per_page => 3, :total_entries => 999
-      animals.total_entries.should == 999
-    }.should run_queries(0)
-  end
-
-  it "supports a non-int for total_entries" do
-    topics = Animal.paginate :page => 1, :per_page => 3, :total_entries => "999"
-    topics.total_entries.should == 999
-  end
-
-
-  it "can iterate and then call WP methods" do
-    animals = Animal.all(:limit => 2).page(1)
-    animals.each { |a| }
-    animals.total_entries.should == 3
-  end
-
-  it "augments to_a to return a WP::Collection" do
-    animals = Animal.all(:limit => 2).page(1)
-    array = animals.to_a
-    array.size.should == 2
-    array.should be_kind_of(WillPaginate::Collection)
-    array.current_page.should == 1
-    array.per_page.should == 2
-  end
-
-  it "doesn't have a problem assigning has-one-through relationship" do
-    human = Human.create :name => "Mislav"
-    human.pet = Animal.first
-  end
-
-end if datamapper_loaded

data/spec/finders/data_mapper_test_connector.rb

@@ -1,54 +0,0 @@
-require 'sqlite3'
-require 'dm-core'
-require 'dm-core/support/logger'
-require 'dm-migrations'
-
-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
-
-class Ownership
-  include DataMapper::Resource
-
-  belongs_to :animal, :key => true
-  belongs_to :human, :key => true
-
-  def self.setup
-  end
-end
-
-class Human
-  include DataMapper::Resource
-
-  property :id, Serial
-  property :name, String
-
-  has n, :ownerships
-  has 1, :pet, :model => 'Animal', :through => :ownerships, :via => :animal
-
-  def self.setup
-  end
-end
-
-# Load fixtures
-[Animal, Ownership, Human].each do |klass|
-  klass.auto_migrate!
-  klass.setup
-end
-
-if 'irb' == $0
-  DataMapper.logger.set_log($stdout, :debug)
-  DataMapper.logger.auto_flush = true
-end

data/spec/finders/mongoid_spec.rb

@@ -1,145 +0,0 @@
-require 'spec_helper'
-
-if !ENV['SKIP_NONRAILS_TESTS']
-  if defined?(Rails)
-    old_rails = Rails
-    # Mongoid sees the `Rails` constant and then proceeds to `require "rails"`
-    # from its railtie. This tricks it into believing there is no Rails.
-    Object.send(:remove_const, :Rails)
-  end
-  require 'will_paginate/mongoid'
-  Object.send(:const_set, :Rails, old_rails) if old_rails
-
-  Mongoid.connect_to 'will_paginate_test'
-  class MongoidModel
-    include Mongoid::Document
-  end
-
-  mongoid_loaded = true
-else
-  mongoid_loaded = false
-end
-
-describe WillPaginate::Mongoid do
-  before(:all) do
-    MongoidModel.delete_all
-    4.times { MongoidModel.create! }
-  end
-
-  let(:criteria) { MongoidModel.criteria }
-
-  describe "#page" do
-    it "should forward to the paginate method" do
-      criteria.expects(:paginate).with(:page => 2).returns("itself")
-      criteria.page(2).should == "itself"
-    end
-
-    it "should not override per_page if set earlier in the chain" do
-      criteria.paginate(:per_page => 10).page(1).per_page.should == 10
-      criteria.paginate(:per_page => 20).page(1).per_page.should == 20
-    end
-  end
-
-  describe "#per_page" do
-    it "should set the limit if given an argument" do
-      criteria.per_page(10).options[:limit].should == 10
-    end
-
-    it "should return the current limit if no argument is given" do
-      criteria.per_page.should == nil
-      criteria.per_page(10).per_page.should == 10
-    end
-
-    it "should be interchangable with limit" do
-      criteria.limit(15).per_page.should == 15
-    end
-
-    it "should be nil'able" do
-      criteria.per_page(nil).per_page.should be_nil
-    end
-  end
-
-  describe "#paginate" do
-    it "should use criteria" do
-      criteria.paginate.should be_instance_of(::Mongoid::Criteria)
-    end
-
-    it "should not override page number if set earlier in the chain" do
-      criteria.page(3).paginate.current_page.should == 3
-    end
-
-    it "should limit according to per_page parameter" do
-      criteria.paginate(:per_page => 10).options.should include(:limit => 10)
-    end
-
-    it "should skip according to page and per_page parameters" do
-      criteria.paginate(:page => 2, :per_page => 5).options.should include(:skip => 5)
-    end
-
-    specify "first fallback value for per_page option is the current limit" do
-      criteria.limit(12).paginate.options.should include(:limit => 12)
-    end
-
-    specify "second fallback value for per_page option is WillPaginate.per_page" do
-      criteria.paginate.options.should include(:limit => WillPaginate.per_page)
-    end
-
-    specify "page should default to 1" do
-      criteria.paginate.options.should include(:skip => 0)
-    end
-
-    it "should convert strings to integers" do
-      criteria.paginate(:page => "2", :per_page => "3").options.should include(:limit => 3)
-    end
-
-    describe "collection compatibility" do
-      describe "#total_count" do
-        it "should be calculated correctly" do
-          criteria.paginate(:per_page => 1).total_entries.should == 4
-          criteria.paginate(:per_page => 3).total_entries.should == 4
-        end
-
-        it "should be cached" do
-          criteria.expects(:count).once.returns(123)
-          criteria.paginate
-          2.times { criteria.total_entries.should == 123 }
-        end
-      end
-
-      it "should calculate total_pages" do
-        criteria.paginate(:per_page => 1).total_pages.should == 4
-        criteria.paginate(:per_page => 3).total_pages.should == 2
-        criteria.paginate(:per_page => 10).total_pages.should == 1
-      end
-
-      it "should return per_page" do
-        criteria.paginate(:per_page => 1).per_page.should == 1
-        criteria.paginate(:per_page => 5).per_page.should == 5
-      end
-
-      describe "#current_page" do
-        it "should return current_page" do
-          criteria.paginate(:page => 1).current_page.should == 1
-          criteria.paginate(:page => 3).current_page.should == 3
-        end
-
-        it "should be casted to PageNumber" do
-          page = criteria.paginate(:page => 1).current_page
-          (page.instance_of? WillPaginate::PageNumber).should be
-        end
-      end
-
-      it "should return offset" do
-        criteria.paginate(:page => 1).offset.should == 0
-        criteria.paginate(:page => 2, :per_page => 5).offset.should == 5
-        criteria.paginate(:page => 3, :per_page => 10).offset.should == 20
-      end
-
-      it "should not pollute plain mongoid criterias" do
-        %w(total_entries total_pages current_page).each do |method|
-          criteria.should_not respond_to(method)
-        end
-      end
-    end
-  end
-end if mongoid_loaded

data/spec/finders/sequel_spec.rb

@@ -1,65 +0,0 @@
-require 'spec_helper'
-
-if !ENV['SKIP_NONRAILS_TESTS']
-  require 'will_paginate/sequel'
-  require File.expand_path('../sequel_test_connector', __FILE__)
-  sequel_loaded = true
-else
-  sequel_loaded = false
-end
-
-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.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
-    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
-      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 if sequel_loaded

data/spec/finders/sequel_test_connector.rb

@@ -1,15 +0,0 @@
-require 'sequel'
-
-Symbol.class_eval do
-  # Active Record calculations tries `as` on some objects but chokes when that
-  # object was a Symbol and it gets a Sequel::SQL::AliasedExpression.
-  undef as if method_defined? :as
-end
-
-db = Sequel.sqlite
-
-db.create_table :cars do
-  primary_key :id, :integer, :auto_increment => true
-  column :name, :text
-  column :notes, :text
-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) %>

data/spec/fixtures/user.rb

@@ -1,2 +0,0 @@
-class User < ActiveRecord::Base
-end