will_paginate 3.0.pre2 → 3.0.pre4

data/README.rdoc

@@ -31,23 +31,9 @@ them mixed in.
 
 == Installation
 
-The recommended way is that you get the gem hosted on {gems.github.com}[http://gems.github.com/]:
+In your Gemfile (if using Bundler):
 
-  gem install mislav-will_paginate
-
-In <b>Rails 2.1</b>, add a gem dependency:
-
-  # for Rails 2.1 and newer
-  config.gem 'mislav-will_paginate', :lib => 'will_paginate', :version => '~> 3.0'
-
-If you're using Rails 2.0 or older, or any other Ruby framework, just add a simple require to a file
-that initializes your application. For example, in Rails you would put this at the end of
-"config/environment.rb".
-
-  gem 'mislav-will_paginate', '~> 3.0'
-  require 'will_paginate'
-
-That's it. Remember to install the gem on <strong>all</strong> machines that you are deploying to.
+  gem 'will_paginate', '~> 3.0.beta'
 
 <i>There are extensive {installation
 instructions}[http://github.com/mislav/will_paginate/wikis/installation] on {the

data/Rakefile

@@ -1,10 +1,20 @@
 require 'rake/rdoctask'
+require 'rspec/core/rake_task'
 
-load 'spec/tasks.rake'
-
-desc 'Default: run specs.'
 task :default => :spec
 
+desc 'Run ALL OF the specs'
+RSpec::Core::RakeTask.new(:spec) do |t|
+  # t.ruby_opts = '-w'
+end
+
+namespace :spec do
+  desc "Run Rails specs"
+  RSpec::Core::RakeTask.new(:rails) do |t|
+    t.pattern = %w'spec/finders/active_record_spec.rb spec/view_helpers/action_view_spec.rb'
+  end
+end
+
 desc 'Generate RDoc documentation for the will_paginate plugin.'
 Rake::RDocTask.new(:rdoc) do |rdoc|
   rdoc.rdoc_files.include('README.rdoc', 'LICENSE', 'CHANGELOG.rdoc').

data/lib/will_paginate/core_ext.rb

@@ -1,20 +1,9 @@
 require 'set'
 require 'will_paginate/array'
 
-# helper to check for method existance in ruby 1.8- and 1.9-compatible way
-# because `methods`, `instance_methods` and others return strings in 1.8 and symbols in 1.9
-#
-#   ['foo', 'bar'].include_method?(:foo) # => true
-class Array
-  def include_method?(name)
-    name = name.to_sym
-    !!(find { |item| item.to_sym == name })
-  end
-end
-
-## everything below copied from ActiveSupport so we don't depend on it ##
+# copied from ActiveSupport so we don't depend on it
 
-unless Hash.instance_methods.include_method? :except
+unless Hash.method_defined? :except
   Hash.class_eval do
     # Returns a new hash without the given keys.
     def except(*keys)
@@ -29,7 +18,7 @@ unless Hash.instance_methods.include_method? :except
   end
 end
 
-unless Hash.instance_methods.include_method? :slice
+unless Hash.method_defined? :slice
   Hash.class_eval do
     # Returns a new hash with only the given keys.
     def slice(*keys)
@@ -44,7 +33,7 @@ unless Hash.instance_methods.include_method? :slice
   end
 end
 
-unless String.instance_methods.include_method? :constantize
+unless String.method_defined? :constantize
   String.class_eval do
     def constantize
       unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ self
@@ -56,7 +45,7 @@ unless String.instance_methods.include_method? :constantize
   end
 end
 
-unless String.instance_methods.include_method? :underscore
+unless String.method_defined? :underscore
   String.class_eval do
     def underscore
       self.to_s.gsub(/::/, '/').

data/lib/will_paginate/finders/active_record.rb

@@ -5,154 +5,163 @@ module WillPaginate::Finders
   # = Paginating finders for ActiveRecord models
   # 
   # WillPaginate adds +paginate+, +per_page+ and other methods to
-  # ActiveRecord::Base class methods and associations. It also hooks into
-  # +method_missing+ to intercept pagination calls to dynamic finders such as
-  # +paginate_by_user_id+ and translate them to ordinary finders
-  # (+find_all_by_user_id+ in this case).
+  # ActiveRecord::Base class methods and associations.
   # 
   # In short, paginating finders are equivalent to ActiveRecord finders; the
   # only difference is that we start with "paginate" instead of "find" and
   # that <tt>:page</tt> is required parameter:
   #
   #   @posts = Post.paginate :all, :page => params[:page], :order => 'created_at DESC'
-  # 
-  # In paginating finders, "all" is implicit. There is no sense in paginating
-  # a single record, right? So, you can drop the <tt>:all</tt> argument:
-  # 
-  #   Post.paginate(...)              =>  Post.find :all
-  #   Post.paginate_all_by_something  =>  Post.find_all_by_something
-  #   Post.paginate_by_something      =>  Post.find_all_by_something
   #
   module ActiveRecord
-    include WillPaginate::Finders::Base
-    
     # In Rails, this is automatically called to mix-in pagination functionality to ActiveRecord.
     def self.enable!
-      ::ActiveRecord::Base.class_eval do
-        extend ActiveRecord
+      ::ActiveRecord::Base.extend Base
+      ::ActiveRecord::Base.extend ActiveRecord::Pagination
+      ::ActiveRecord::Base.extend ActiveRecord::BaseMethods
+
+      klasses = [::ActiveRecord::Relation]
+      if defined? ::ActiveRecord::Associations::CollectionProxy
+        klasses << ::ActiveRecord::Associations::CollectionProxy
+      else
+        klasses << ::ActiveRecord::Associations::AssociationCollection
       end
 
       # support pagination on associations and scopes
-      [::ActiveRecord::Relation, ::ActiveRecord::Associations::AssociationCollection].each do |klass|
-        klass.send(:include, ActiveRecord)
-      end
+      klasses.each { |klass| klass.send(:include, ActiveRecord::Pagination) }
     end
-    
-    # Wraps +find_by_sql+ by simply adding LIMIT and OFFSET to your SQL string
-    # based on the params otherwise used by paginating finds: +page+ and
-    # +per_page+.
-    #
-    # Example:
-    # 
-    #   @developers = Developer.paginate_by_sql ['select * from developers where salary > ?', 80000],
-    #                          :page => params[:page], :per_page => 3
-    #
-    # A query for counting rows will automatically be generated if you don't
-    # supply <tt>:total_entries</tt>. If you experience problems with this
-    # generated SQL, you might want to perform the count manually in your
-    # application.
-    # 
-    def paginate_by_sql(sql, options)
-      WillPaginate::Collection.create(*wp_parse_options(options)) do |pager|
-        query = sanitize_sql(sql.dup)
-        original_query = query.dup
-        # add limit, offset
-        query << " LIMIT #{pager.per_page} OFFSET #{pager.offset}"
-        # perfom the find
-        pager.replace find_by_sql(query)
-        
-        unless pager.total_entries
-          count_query = original_query.sub /\bORDER\s+BY\s+[\w`,\s]+$/mi, ''
-          count_query = "SELECT COUNT(*) FROM (#{count_query})"
-          
-          unless ['oracle', 'oci'].include?(self.connection.adapter_name.downcase)
-            count_query << ' AS count_table'
-          end
-          # perform the count query
-          pager.total_entries = count_by_sql(count_query)
+
+    # makes a Relation look like WillPaginate::Collection
+    module RelationMethods
+      attr_accessor :current_page
+      attr_writer :total_entries, :wp_count_options
+
+      def per_page(value = nil)
+        if value.nil? then limit_value
+        else limit(value)
         end
       end
-    end
 
-  protected
+      # TODO: solve with less relation clones and code dups
+      def limit(num)
+        rel = super
+        if rel.current_page
+          rel.offset((rel.current_page-1) * rel.limit_value)
+        else
+          rel
+        end
+      end
 
-    def wp_query(options, pager, args, &block) #:nodoc:
-      finder = (options.delete(:finder) || 'find').to_s
-      find_options = options.except(:count).update(:offset => pager.offset, :limit => pager.per_page) 
+      def offset(value = nil)
+        if value.nil? then offset_value
+        else super(value)
+        end
+      end
 
-      if finder == 'find'
-        if Array === args.first and !pager.total_entries
-          pager.total_entries = args.first.size
+      def total_entries
+        @total_entries ||= begin
+          if loaded? and size < limit_value and (current_page == 1 or size > 0)
+            offset_value + size
+          else
+            excluded = [:order, :limit, :offset]
+            excluded << :includes unless eager_loading?
+            rel = self.except(*excluded)
+            # TODO: hack. decide whether to keep
+            rel = rel.apply_finder_options(@wp_count_options) if defined? @wp_count_options
+            rel.count
+          end
         end
-        args << :all if args.empty?
       end
-      
-      args << find_options
-      pager.replace send(finder, *args, &block)
-      
-      unless pager.total_entries
-        # magic counting
-        pager.total_entries = wp_count(options, args, finder) 
+
+      # workaround for Active Record 3.0
+      def size
+        if !loaded? and limit_value
+          [super, limit_value].min
+        else
+          super
+        end
+      end
+
+      def total_pages
+        (total_entries / limit_value.to_f).ceil
+      end
+
+      def clone
+        other = super
+        other.current_page = current_page unless other.current_page
+        other.total_entries = nil
+        other
+      end
+
+      def to_a
+        if current_page.nil? then super # workaround for Active Record 3.0
+        else
+          ::WillPaginate::Collection.create(current_page, limit_value) do |col|
+            col.replace super
+            col.total_entries ||= total_entries
+          end
+        end
       end
     end
 
-    # Does the not-so-trivial job of finding out the total number of entries
-    # in the database. It relies on the ActiveRecord +count+ method.
-    def wp_count(options, args, finder) #:nodoc:
-      # find out if we are in a model or an association proxy
-      klass = (@owner and @reflection) ? @reflection.klass : self
-      count_options = wp_parse_count_options(options, klass)
-
-      # we may have to scope ...
-      counter = Proc.new { count(count_options) }
-
-      count = if finder.index('find_') == 0 and klass.respond_to?(scoper = finder.sub('find', 'with'))
-                # scope_out adds a 'with_finder' method which acts like with_scope, if it's present
-                # then execute the count with the scoping provided by the with_finder
-                send(scoper, &counter)
-              elsif finder =~ /^find_(all_by|by)_([_a-zA-Z]\w*)$/
-                # extract conditions from calls like "paginate_by_foo_and_bar"
-                attribute_names = $2.split('_and_')
-                conditions = construct_attributes_from_arguments(attribute_names, args)
-                with_scope(:find => { :conditions => conditions }, &counter)
-              else
-                counter.call
-              end
-
-      count.respond_to?(:length) ? count.length : count
+    module Pagination
+      def paginate(options)
+        pagenum, per_page, total = wp_parse_options(options)
+        count_options = options[:count]
+        options = options.except(:page, :per_page, :total_entries, :count)
+        rel = limit(per_page).page(pagenum)
+        rel = rel.apply_finder_options(options) if options.any?
+        rel.wp_count_options = count_options    if count_options
+        rel
+      end
+
+      def page(num)
+        pagenum = num.nil? ? 1 : num.to_i
+        raise ::WillPaginate::InvalidPage, num, pagenum if pagenum < 1
+        rel = scoped.extending(RelationMethods)
+        rel = rel.offset((pagenum-1) * (rel.limit_value || per_page))
+        rel = rel.limit(per_page) unless rel.limit_value
+        rel.current_page = pagenum
+        rel
+      end
     end
-    
-    def wp_parse_count_options(options, klass) #:nodoc:
-      excludees = [:count, :order, :limit, :offset, :readonly]
-      
-      # Use :select from scope if it isn't already present.
-      # FIXME: this triggers extra queries when going through associations
-      # if options[:select].blank? && current_scoped_methods && current_scoped_methods.select_values.present?
-      #   options[:select] = current_scoped_methods.select_values.join(", ")
-      # end
-      
-      if options[:select] and options[:select] =~ /^\s*DISTINCT\b/i
-        # Remove quoting and check for table_name.*-like statement.
-        if options[:select].gsub('`', '') =~ /\w+\.\*/
-          options[:select] = "DISTINCT #{klass.table_name}.#{klass.primary_key}"
+
+    module BaseMethods
+      # Wraps +find_by_sql+ by simply adding LIMIT and OFFSET to your SQL string
+      # based on the params otherwise used by paginating finds: +page+ and
+      # +per_page+.
+      #
+      # Example:
+      # 
+      #   @developers = Developer.paginate_by_sql ['select * from developers where salary > ?', 80000],
+      #                          :page => params[:page], :per_page => 3
+      #
+      # A query for counting rows will automatically be generated if you don't
+      # supply <tt>:total_entries</tt>. If you experience problems with this
+      # generated SQL, you might want to perform the count manually in your
+      # application.
+      # 
+      def paginate_by_sql(sql, options)
+        WillPaginate::Collection.create(*wp_parse_options(options)) do |pager|
+          query = sanitize_sql(sql.dup)
+          original_query = query.dup
+          # add limit, offset
+          query << " LIMIT #{pager.per_page} OFFSET #{pager.offset}"
+          # perfom the find
+          pager.replace find_by_sql(query)
+
+          unless pager.total_entries
+            count_query = original_query.sub /\bORDER\s+BY\s+[\w`,\s]+$/mi, ''
+            count_query = "SELECT COUNT(*) FROM (#{count_query})"
+
+            unless self.connection.adapter_name =~ /^(oracle|oci$)/i
+              count_query << ' AS count_table'
+            end
+            # perform the count query
+            pager.total_entries = count_by_sql(count_query)
+          end
         end
-      else
-        excludees << :select
-      end
-      
-      # count expects (almost) the same options as find
-      count_options = options.except *excludees
-
-      # merge the hash found in :count
-      # this allows you to specify :select, :order, or anything else just for the count query
-      count_options.update options[:count] if options[:count]
-      
-      # forget about includes if they are irrelevant when counting
-      if count_options[:include] and count_options[:conditions].blank? and count_options[:group].blank?
-        count_options.delete :include
       end
-      
-      count_options
     end
   end
 end

data/lib/will_paginate/railtie.rb

@@ -3,22 +3,20 @@ require 'will_paginate/collection'
 
 module WillPaginate
   class Railtie < Rails::Railtie
-    initializer "will_paginate.active_record" do |app|
-      if defined? ::ActiveRecord
+    initializer "will_paginate" do |app|
+      ActiveSupport.on_load :active_record do
         require 'will_paginate/finders/active_record'
         WillPaginate::Finders::ActiveRecord.enable!
       end
-    end
-    
-    initializer "will_paginate.action_dispatch" do |app|
-      if defined? ::ActionDispatch::ShowExceptions
+
+      ActiveSupport.on_load :action_controller do
         ActionDispatch::ShowExceptions.rescue_responses['WillPaginate::InvalidPage'] = :not_found
       end
-    end
-    
-    initializer "will_paginate.action_view" do |app|
-      require 'will_paginate/view_helpers/action_view'
-      ActionView::Base.send(:include, WillPaginate::ViewHelpers::ActionView)
+
+      ActiveSupport.on_load :action_view do
+        require 'will_paginate/view_helpers/action_view'
+        include WillPaginate::ViewHelpers::ActionView
+      end
     end
   end
 end

data/lib/will_paginate/version.rb

@@ -2,7 +2,7 @@ module WillPaginate #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 3
     MINOR = 0
-    TINY  = 'pre2'
+    TINY  = 'pre4'
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/lib/will_paginate/view_helpers/action_view.rb

@@ -1,6 +1,4 @@
 require 'will_paginate/view_helpers/base'
-require 'action_view'
-require 'action_pack/version'
 require 'will_paginate/view_helpers/link_renderer'
 
 module WillPaginate
@@ -63,8 +61,12 @@ module WillPaginate
       # apply. Don't use the <tt>:id</tt> option; otherwise you'll finish with two
       # blocks of pagination links sharing the same ID (which is invalid HTML).
       def paginated_section(*args, &block)
-        pagination = will_paginate(*args).to_s
-        pagination + capture(&block) + pagination
+        pagination = will_paginate(*args)
+        if pagination
+          pagination + capture(&block) + pagination
+        else
+          capture(&block)
+        end
       end
       
     protected
@@ -86,7 +88,7 @@ WillPaginate::ViewHelpers::LinkRenderer.class_eval do
   protected
   
   def default_url_params
-    { :escape => false }
+    {}
   end
   
   def url(page)
@@ -131,4 +133,4 @@ WillPaginate::ViewHelpers::LinkRenderer.class_eval do
   def parse_query_parameters(params)
     Rack::Utils.parse_nested_query(params)
   end
-end
+end

data/lib/will_paginate/view_helpers/link_renderer.rb

@@ -59,11 +59,13 @@ module WillPaginate
       end
       
       def previous_page
-        previous_or_next_page(@collection.previous_page, @options[:previous_label], 'previous_page')
+        num = @collection.current_page > 1 && @collection.current_page - 1
+        previous_or_next_page(num, @options[:previous_label], 'previous_page')
       end
       
       def next_page
-        previous_or_next_page(@collection.next_page, @options[:next_label], 'next_page')
+        num = @collection.current_page < @collection.total_pages && @collection.current_page + 1
+        previous_or_next_page(num, @options[:next_label], 'next_page')
       end
       
       def previous_or_next_page(page, text, classname)
@@ -107,8 +109,8 @@ module WillPaginate
 
       def rel_value(page)
         case page
-        when @collection.previous_page; 'prev' + (page == 1 ? ' start' : '')
-        when @collection.next_page; 'next'
+        when @collection.current_page - 1; 'prev' + (page == 1 ? ' start' : '')
+        when @collection.current_page + 1; 'next'
         when 1; 'start'
         end
       end

data/spec/console

@@ -1,8 +1,4 @@
 #!/usr/bin/env ruby
 irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
-libs = []
-
-libs << 'irb/completion'
-libs << 'console_fixtures'
-
-exec "#{irb} -Ilib:spec#{libs.map{ |l| " -r #{l}" }.join} --simple-prompt"
+opts = %w[--simple-prompt -rirb/completion -rconsole_fixtures]
+exec 'bundle', 'exec', irb, '-Ilib:spec', *opts

data/spec/console_fixtures.rb

@@ -1,8 +1,30 @@
+require 'bundler'
+Bundler.setup
+
 require 'will_paginate/finders/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
-Fixtures.create_fixtures(ActiverecordTestConnector::FIXTURES_PATH, ActiveRecord::Base.connection.tables)
+ActiverecordTestConnector::Fixtures.create_fixtures \
+  ActiverecordTestConnector::FIXTURES_PATH, ActiveRecord::Base.connection.tables
 
-ActiverecordTestConnector.show_sql
+WillPaginate::Finders::ActiveRecord.enable!

data/spec/finders/active_record_spec.rb

@@ -17,7 +17,7 @@ describe WillPaginate::Finders::ActiveRecord do
   
   it "should paginate" do
     lambda {
-      users = User.paginate(:page => 1, :per_page => 5)
+      users = User.paginate(:page => 1, :per_page => 5).to_a
       users.length.should == 5
     }.should run_queries(2)
   end
@@ -28,6 +28,58 @@ describe WillPaginate::Finders::ActiveRecord do
     }.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 "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
+  end
+
   describe "counting" do
     it "should not accept :count parameter" do
       pending
@@ -111,6 +163,7 @@ describe WillPaginate::Finders::ActiveRecord do
   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
@@ -156,11 +209,8 @@ describe WillPaginate::Finders::ActiveRecord do
   it "should paginate with :include and :order" do
     result = nil
     lambda {
-      result = Topic.paginate \
-        :page     => 1, 
-        :include  => :replies,  
-        :order    => 'replies.created_at asc, topics.created_at asc', 
-        :per_page => 10
+      result = Topic.paginate(:page => 1, :include => :replies, :per_page => 10,
+        :order => 'replies.created_at asc, topics.created_at asc').to_a
     }.should run_queries(2)
 
     expected = Topic.find :all, 
@@ -174,17 +224,19 @@ describe WillPaginate::Finders::ActiveRecord do
   
   it "should remove :include for count" do
     lambda {
-      Developer.paginate :page => 1, :per_page => 1, :include => :projects
-      $query_sql.last.should_not include(' JOIN ')
-    }.should run_queries(4)
+      Developer.paginate(:page => 1, :per_page => 1, :include => :projects).to_a
+      $query_sql.last.should_not =~ /\bJOIN\b/
+    }.should run_queries(3..4)
   end
 
   it "should keep :include for count when they are referenced in :conditions" do
-    Developer.expects(:find).returns([1])
-    Developer.expects(:count).with({ :include => :projects, :conditions => 'projects.id > 2' }).returns(0)
+    Developer.paginate(
+      :page => 1, :per_page => 1,
+      :include => :projects,
+      :conditions => 'projects.id > 2'
+    ).to_a
 
-    Developer.paginate :page => 1, :per_page => 1,
-      :include => :projects, :conditions => 'projects.id > 2'
+    $query_sql.last.should =~ /\bJOIN\b/
   end
   
   describe "associations" do
@@ -199,7 +251,7 @@ describe WillPaginate::Finders::ActiveRecord do
 
       expected = Topic.find :all, 
         :include    => 'replies', 
-        :conditions => ["project_id = #{project.id} AND replies.content LIKE ?", 'Nice%'],
+        :conditions => ["project_id = ? AND replies.content LIKE ?", project.id, 'Nice%'],
         :limit      => 10
 
       result.should == expected
@@ -218,7 +270,7 @@ describe WillPaginate::Finders::ActiveRecord do
       }.should run_queries(2)
 
       # with explicit order
-      result = dhh.projects.paginate(:page => 1, :order => 'projects.id')
+      result = dhh.projects.paginate(:page => 1).reorder('projects.id')
       result.should == expected_id_ordered
       result.total_entries.should == 2
 
@@ -226,7 +278,7 @@ describe WillPaginate::Finders::ActiveRecord do
         dhh.projects.find(:all, :order => 'projects.id', :limit => 4)
       }.should_not raise_error
       
-      result = dhh.projects.paginate(:page => 1, :order => 'projects.id', :per_page => 4)
+      result = dhh.projects.paginate(:page => 1, :per_page => 4).reorder('projects.id')
       result.should == expected_id_ordered
 
       # has_many with implicit order
@@ -234,7 +286,7 @@ describe WillPaginate::Finders::ActiveRecord do
       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, :order => 'replies.id ASC').should == expected.reverse
+      topic.replies.paginate(:page => 1).reorder('replies.id ASC').should == expected.reverse
     end
 
     it "should paginate through association extension" do
@@ -253,7 +305,8 @@ describe WillPaginate::Finders::ActiveRecord do
     join_sql = 'LEFT JOIN developers_projects ON users.id = developers_projects.developer_id'
 
     lambda {
-      result = Developer.paginate :page => 1, :joins => join_sql, :conditions => 'project_id = 1'
+      result = Developer.paginate(:page => 1, :joins => join_sql, :conditions => 'project_id = 1')
+      result.to_a # trigger loading of records
       result.size.should == 2
       developer_names = result.map(&:name)
       developer_names.should include('David')
@@ -262,8 +315,8 @@ describe WillPaginate::Finders::ActiveRecord do
 
     lambda {
       expected = result.to_a
-      result = Developer.paginate :page => 1, :joins => join_sql,
-                           :conditions => 'project_id = 1', :count => { :select => "users.id" }
+      result = Developer.paginate(:page => 1, :joins => join_sql,
+        :conditions => 'project_id = 1', :count => { :select => "users.id" }).to_a
       result.should == expected
       result.total_entries.should == 2
     }.should run_queries(1)
@@ -272,8 +325,8 @@ describe WillPaginate::Finders::ActiveRecord do
   it "should paginate with group" do
     result = nil
     lambda {
-      result = Developer.paginate :page => 1, :per_page => 10,
-                                  :group => 'salary', :select => 'salary', :order => 'salary'
+      result = Developer.paginate(:page => 1, :per_page => 10,
+        :group => 'salary', :select => 'salary', :order => 'salary').to_a
     }.should run_queries(1)
 
     expected = users(:david, :jamis, :dev_10, :poor_jamis).map(&:salary).sort
@@ -337,12 +390,10 @@ describe WillPaginate::Finders::ActiveRecord do
     }.should_not raise_error
   end
   
-  it "should paginate an array of IDs" do
+  it "should not paginate an array of IDs" do
     lambda {
-      result = Developer.paginate((1..8).to_a, :per_page => 3, :page => 2, :order => 'id')
-      result.map(&:id).should == (4..6).to_a
-      result.total_entries.should == 8
-    }.should run_queries(1)
+      Developer.paginate((1..8).to_a, :per_page => 3, :page => 2, :order => 'id')
+    }.should raise_error(ArgumentError)
   end
   
   protected
@@ -351,6 +402,18 @@ describe WillPaginate::Finders::ActiveRecord do
       QueryCountMatcher.new(num)
     end
 
+    def show_queries(&block)
+      counter = QueryCountMatcher.new(nil)
+      counter.run block
+    ensure
+      queries = counter.performed_queries
+      if queries.any?
+        puts queries
+      else
+        puts "no queries"
+      end
+    end
+
 end
 
 class QueryCountMatcher
@@ -359,12 +422,26 @@ class QueryCountMatcher
   end
 
   def matches?(block)
+    run(block)
+
+    if @expected_count.respond_to? :include?
+      @expected_count.include? @count
+    else
+      @count == @expected_count
+    end
+  end
+
+  def run(block)
     $query_count = 0
     $query_sql = []
     block.call
-    @queries = $query_sql
+  ensure
+    @queries = $query_sql.dup
     @count = $query_count
-    @count == @expected_count
+  end
+
+  def performed_queries
+    @queries
   end
 
   def failure_message
@@ -372,6 +449,6 @@ class QueryCountMatcher
   end
 
   def negative_failure_message
-    "expected query count not to be #{$expected_count}"
+    "expected query count not to be #{@expected_count}"
   end
 end

data/spec/finders/activerecord_test_connector.rb

@@ -1,21 +1,35 @@
 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
+$query_count = 0
+$query_sql = []
 
-class ActiverecordTestConnector
-  cattr_accessor :able_to_connect
-  cattr_accessor :connected
+ignore_sql = /^(?:PRAGMA|SELECT (?:currval|CAST|@@IDENTITY|@@ROWCOUNT)|SHOW FIELDS)\b|\bFROM sqlite_master\b/
+
+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 :able_to_connect
+  attr_accessor :connected
 
   FIXTURES_PATH = File.expand_path('../../fixtures', __FILE__)
 
+  Fixtures = defined?(ActiveRecord::Fixtures) ? ActiveRecord::Fixtures : ::Fixtures
+
   # Set our defaults
   self.connected = false
   self.able_to_connect = true
 
-  def self.setup
+  def setup
     unless self.connected || !self.able_to_connect
       setup_connection
       load_schema
@@ -29,54 +43,31 @@ class ActiverecordTestConnector
 
   private
   
-  def self.add_load_path(path)
+  def add_load_path(path)
     dep = defined?(ActiveSupport::Dependencies) ? ActiveSupport::Dependencies : ::Dependencies
     dep.autoload_paths.unshift path
   end
 
-  def self.setup_connection
+  def 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'
+    # 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
+  def 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)

data/spec/finders/data_mapper_spec.rb

@@ -1,8 +1,14 @@
 require 'spec_helper'
-require 'will_paginate/finders/data_mapper'
-require File.expand_path('../data_mapper_test_connector', __FILE__)
 
-require 'will_paginate'
+begin
+  require 'will_paginate/finders/data_mapper'
+  require File.expand_path('../data_mapper_test_connector', __FILE__)
+rescue LoadError => error
+  warn "Error running DataMapper specs: #{error.message}"
+  datamapper_loaded = false
+else
+  datamapper_loaded = true
+end
 
 describe WillPaginate::Finders::DataMapper do
     
@@ -59,4 +65,4 @@ describe WillPaginate::Finders::DataMapper do
     end
   end
   
-end
+end if datamapper_loaded

data/spec/finders/data_mapper_test_connector.rb

@@ -1,4 +1,6 @@
 require 'dm-core'
+require 'dm-migrations'
+
 DataMapper.setup :default, 'sqlite3::memory:'
 
 # Define models

data/spec/finders/sequel_spec.rb

@@ -1,6 +1,14 @@
 require 'spec_helper'
-require 'will_paginate/finders/sequel'
-require File.expand_path('../sequel_test_connector', __FILE__)
+
+begin
+  require 'will_paginate/finders/sequel'
+  require File.expand_path('../sequel_test_connector', __FILE__)
+rescue LoadError, ArgumentError => error
+  warn "Error running Sequel specs: #{error.message}"
+  sequel_loaded = false
+else
+  sequel_loaded = true
+end
 
 describe Sequel::Dataset::Pagination, 'extension' do
   
@@ -50,4 +58,4 @@ describe Sequel::Dataset::Pagination, 'extension' do
     end
   end
 
-end
+end if sequel_loaded

data/spec/fixtures/replies.yml

@@ -2,28 +2,28 @@ witty_retort:
   id: 1
   topic_id: 1
   content: Birdman is better!
-  created_at: <%= 6.hours.ago.to_s(:db) %>
+  created_at: <%= 6.hours.ago.utc.to_s(:db) %>
   
 another:
   id: 2
   topic_id: 2
   content: Nuh uh!
-  created_at: <%= 1.hour.ago.to_s(:db) %>
+  created_at: <%= 1.hour.ago.utc.to_s(:db) %>
   
 spam:
   id: 3
   topic_id: 1
   content: Nice site!
-  created_at: <%= 1.hour.ago.to_s(:db) %>
+  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.to_s(:db) %>
+  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.to_s(:db) %>
+  created_at: <%= 10.minutes.ago.utc.to_s(:db) %>

data/spec/fixtures/reply.rb

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

data/spec/fixtures/topics.yml

@@ -3,7 +3,7 @@ futurama:
   title: Isnt futurama awesome?
   subtitle: It really is, isnt it.
   content: I like futurama
-  created_at: <%= 1.day.ago.to_s(:db) %>
+  created_at: <%= 1.day.ago.utc.to_s(:db) %>
   updated_at:
   
 harvey_birdman:
@@ -11,7 +11,7 @@ harvey_birdman:
   title: Harvey Birdman is the king of all men
   subtitle: yup
   content: He really is
-  created_at: <%= 2.hours.ago.to_s(:db) %>
+  created_at: <%= 2.hours.ago.utc.to_s(:db) %>
   updated_at:
 
 rails:
@@ -20,11 +20,11 @@ rails:
   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.to_s(:db) %>
+  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.to_s(:db) %>
+  created_at: <%= 15.minutes.ago.utc.to_s(:db) %>

data/spec/spec_helper.rb

@@ -1,6 +1,5 @@
-require 'rubygems'
-require 'bundler'
-require 'spec/autorun'
+require 'rspec'
+require File.expand_path('../view_helpers/view_example_group', __FILE__)
 
 module MyExtras
   protected
@@ -22,7 +21,7 @@ module MyExtras
   end
 end
 
-Spec::Runner.configure do |config|
+RSpec.configure do |config|
   # config.include My::Pony, My::Horse, :type => :farm
   config.include MyExtras
   # config.predicate_matchers[:swim] = :can_swim?

data/spec/view_helpers/action_view_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 require 'active_support/rescuable' # needed for Ruby 1.9.1
 require 'action_controller'
-require 'view_helpers/view_example_group'
 require 'will_paginate/view_helpers/action_view'
 require 'will_paginate/collection'
 
@@ -311,6 +310,14 @@ class DummyController
   def params
     @request.params
   end
+
+  def env
+    {}
+  end
+
+  def _prefixes
+    []
+  end
 end
 
 class IbocorpController < DummyController
@@ -349,6 +356,11 @@ class DummyRequest
   def host_with_port
     'example.com'
   end
+  alias host host_with_port
+
+  def optional_port
+    ''
+  end
   
   def protocol
     'http:'

data/spec/view_helpers/view_example_group.rb

@@ -1,6 +1,7 @@
+require 'active_support'
 require 'action_dispatch/testing/assertions'
 
-class ViewExampleGroup < Spec::Example::ExampleGroup
+module ViewExampleGroup
   
   include ActionDispatch::Assertions::SelectorAssertions
   
@@ -38,8 +39,8 @@ class ViewExampleGroup < Spec::Example::ExampleGroup
   def validate_page_numbers(expected, links, param_name = :page)
     param_pattern = /\W#{Regexp.escape(param_name.to_s)}=([^&]*)/
     
-    links.map { |e|
-      e['href'] =~ param_pattern
+    links.map { |el|
+      unescape_href(el) =~ param_pattern
       $1 ? $1.to_i : $1
     }.should == expected
   end
@@ -52,9 +53,10 @@ class ViewExampleGroup < Spec::Example::ExampleGroup
     pages = [] if numbers
     
     links.each do |el|
-      el['href'].should =~ pattern
+      href = unescape_href(el)
+      href.should =~ pattern
       if numbers
-        el['href'] =~ pattern
+        href =~ pattern
         pages << ($1.nil?? nil : $1.to_i)
       end
     end
@@ -65,10 +67,14 @@ class ViewExampleGroup < Spec::Example::ExampleGroup
   def assert_no_links_match(pattern)
     assert_select 'div.pagination a[href]' do |elements|
       elements.each do |el|
-        el['href'] !~ pattern
+        unescape_href(el).should_not =~ pattern
       end
     end
   end
+
+  def unescape_href(el)
+    CGI.unescape CGI.unescapeHTML(el['href'])
+  end
   
   def build_message(message, pattern, *args)
     built_message = pattern.dup
@@ -80,7 +86,11 @@ class ViewExampleGroup < Spec::Example::ExampleGroup
   
 end
 
-Spec::Example::ExampleGroupFactory.register(:view_helpers, ViewExampleGroup)
+RSpec.configure do |config|
+  config.include ViewExampleGroup, :type => :view, :example_group => {
+    :file_path => %r{spec/view_helpers/}
+  }
+end
 
 module HTML
   Node.class_eval do

metadata

@@ -1,13 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: will_paginate
 version: !ruby/object:Gem::Version 
-  hash: -1876988247
-  prerelease: true
-  segments: 
-  - 3
-  - 0
-  - pre2
-  version: 3.0.pre2
+  prerelease: 4
+  version: 3.0.pre4
 platform: ruby
 authors: 
 - "Mislav Marohni\xC4\x87"
@@ -15,8 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-05 00:00:00 +01:00
-default_executable: 
+date: 2010-02-05 00:00:00 Z
 dependencies: []
 
 description: The will_paginate library provides a simple, yet powerful and extensible API for pagination and rendering of page links in web application templates.
@@ -74,10 +68,7 @@ files:
 - spec/fixtures/topics.yml
 - spec/fixtures/user.rb
 - spec/fixtures/users.yml
-- spec/rcov.opts
-- spec/spec.opts
 - spec/spec_helper.rb
-- spec/tasks.rake
 - spec/view_helpers/action_view_spec.rb
 - spec/view_helpers/base_spec.rb
 - spec/view_helpers/link_renderer_base_spec.rb
@@ -85,7 +76,6 @@ files:
 - README.rdoc
 - LICENSE
 - CHANGELOG.rdoc
-has_rdoc: true
 homepage: http://github.com/mislav/will_paginate/wikis
 licenses: []
 
@@ -101,25 +91,17 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
   - - ">"
     - !ruby/object:Gem::Version 
-      hash: 25
-      segments: 
-      - 1
-      - 3
-      - 1
       version: 1.3.1
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.8.5
 signing_key: 
 specification_version: 3
 summary: Adaptive pagination plugin for web frameworks and other applications

data/spec/rcov.opts

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

data/spec/spec.opts

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

data/spec/tasks.rake

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