will_paginate 2.1.0 → 2.2.0

data/lib/will_paginate/named_scope_patch.rb

@@ -0,0 +1,50 @@
+## based on http://dev.rubyonrails.org/changeset/9084
+
+ActiveRecord::Associations::AssociationProxy.class_eval do
+  protected
+  def with_scope(*args, &block)
+    @reflection.klass.send :with_scope, *args, &block
+  end
+end
+
+[ ActiveRecord::Associations::AssociationCollection,
+    ActiveRecord::Associations::HasManyThroughAssociation ].each do |klass|
+  klass.class_eval do
+    protected
+    def method_missing_without_paginate(method, *args)
+      if @target.respond_to?(method) || (!@reflection.klass.respond_to?(method) && Class.respond_to?(method))
+        if block_given?
+          super { |*block_args| yield(*block_args) }
+        else
+          super
+        end
+      elsif @reflection.klass.scopes.include?(method)
+        @reflection.klass.scopes[method].call(self, *args)
+      else
+        with_scope construct_scope do
+          if block_given?
+            @reflection.klass.send(method, *args) { |*block_args| yield(*block_args) }
+          else
+            @reflection.klass.send(method, *args)
+          end
+        end
+      end
+    end
+  end
+end
+
+# Rails 1.2.6
+ActiveRecord::Associations::HasAndBelongsToManyAssociation.class_eval do
+  protected
+  def method_missing(method, *args, &block)
+    if @target.respond_to?(method) || (!@reflection.klass.respond_to?(method) && Class.respond_to?(method))
+      super
+    elsif @reflection.klass.scopes.include?(method)
+      @reflection.klass.scopes[method].call(self, *args)
+    else
+      @reflection.klass.with_scope(:find => { :conditions => @finder_sql, :joins => @join_sql, :readonly => false }) do
+        @reflection.klass.send(method, *args, &block)
+      end
+    end
+  end
+end if ActiveRecord::VERSION::MAJOR < 2

data/lib/will_paginate/version.rb

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

data/lib/will_paginate/view_helpers.rb

@@ -85,10 +85,11 @@ module WillPaginate
         collection_name = "@#{controller.controller_name}"
         collection = instance_variable_get(collection_name)
         raise ArgumentError, "The #{collection_name} variable appears to be empty. Did you " +
-          "forget to specify the collection object for will_paginate?" unless collection
+          "forget to pass the collection object for will_paginate?" unless collection
       end
       # early exit if there is nothing to render
-      return nil unless collection.page_count > 1
+      return nil unless WillPaginate::ViewHelpers.total_pages_for_collection(collection) > 1
+      
       options = options.symbolize_keys.reverse_merge WillPaginate::ViewHelpers.pagination_options
       # create the renderer instance
       renderer_class = options[:renderer].to_s.constantize
@@ -96,6 +97,34 @@ module WillPaginate
       # render HTML for pagination
       renderer.to_html
     end
+    
+    # Wrapper for rendering pagination links at both top and bottom of a block
+    # of content.
+    # 
+    #   <% paginated_section @posts do %>
+    #     <ol id="posts">
+    #       <% for post in @posts %>
+    #         <li> ... </li>
+    #       <% end %>
+    #     </ol>
+    #   <% end %>
+    #
+    # will result in:
+    #
+    #   <div class="pagination"> ... </div>
+    #   <ol id="posts">
+    #     ...
+    #   </ol>
+    #   <div class="pagination"> ... </div>
+    #
+    # Arguments are passed to a <tt>will_paginate</tt> call, so the same options
+    # 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
+      content = pagination + capture(&block) + pagination
+      concat content, block.binding
+    end
 
     # Renders a helpful message with numbers of displayed vs. total entries.
     # You can use this as a blueprint for your own, similar helpers.
@@ -109,28 +138,51 @@ module WillPaginate
         collection.total_entries
       ]
     end
+
+    def self.total_pages_for_collection(collection) #:nodoc:
+      if collection.respond_to? :page_count and !collection.respond_to? :total_pages
+        WillPaginate::Deprecation.warn <<-MSG
+          You are using a paginated collection of class #{collection.class.name}
+          which conforms to the old API of WillPaginate::Collection by using
+          `page_count`, while the current method name is `total_pages`. Please
+          upgrade yours or 3rd-party code that provides the paginated collection.
+        MSG
+        class << collection
+          def total_pages; page_count; end
+        end
+      end
+      collection.total_pages
+    end
   end
 
   # This class does the heavy lifting of actually building the pagination
   # links. It is used by +will_paginate+ helper internally.
   class LinkRenderer
-
+    # * +collection+ is a WillPaginate::Collection instance or any other object
+    #   that conforms to that API
+    # * +options+ are forwarded from +will_paginate+ view helper
+    # * +template+ is the reference to the template being rendered
     def initialize(collection, options, template)
       @collection = collection
       @options    = options
       @template   = template
     end
 
+    # Process it! This method returns the complete HTML string which contains
+    # pagination links. Feel free to subclass LinkRenderer and change this
+    # method as you see fit.
     def to_html
       links = @options[:page_links] ? windowed_links : []
       # previous/next buttons
-      links.unshift page_link_or_span(@collection.previous_page, 'disabled', @options[:prev_label])
-      links.push    page_link_or_span(@collection.next_page,     'disabled', @options[:next_label])
+      links.unshift page_link_or_span(@collection.previous_page, %w(disabled prev_page), @options[:prev_label])
+      links.push    page_link_or_span(@collection.next_page,     %w(disabled next_page), @options[:next_label])
       
       html = links.join(@options[:separator])
       @options[:container] ? @template.content_tag(:div, html, html_attributes) : html
     end
 
+    # Returns the subset of +options+ this instance was initialized with that
+    # represent HTML attributes for the container element of pagination links.
     def html_attributes
       return @html_attributes if @html_attributes
       @html_attributes = @options.except *(WillPaginate::ViewHelpers.pagination_options.keys - [:class])
@@ -143,20 +195,28 @@ module WillPaginate
     
   protected
 
-    def gap_marker; '...'; end
+    # The gap in page links is represented by:
+    #
+    #   <span class="gap">&hellip;</span>
+    def gap_marker
+      '<span class="gap">&hellip;</span>'
+    end
     
+    # Collects link items for visible page numbers.
     def windowed_links
       prev = nil
 
       visible_page_numbers.inject [] do |links, n|
         # detect gaps:
         links << gap_marker if prev and n > prev + 1
-        links << page_link_or_span(n)
+        links << page_link_or_span(n, 'current')
         prev = n
         links
       end
     end
 
+    # Calculates visible page numbers using the <tt>:inner_window</tt> and
+    # <tt>:outer_window</tt> options.
     def visible_page_numbers
       inner_window, outer_window = @options[:inner_window].to_i, @options[:outer_window].to_i
       window_from = current_page - inner_window
@@ -166,9 +226,11 @@ module WillPaginate
       if window_to > total_pages
         window_from -= window_to - total_pages
         window_to = total_pages
-      elsif window_from < 1
+      end
+      if window_from < 1
         window_to += 1 - window_from
         window_from = 1
+        window_to = total_pages if window_to > total_pages
       end
       
       visible   = (1..total_pages).to_a
@@ -180,39 +242,79 @@ module WillPaginate
       visible
     end
     
-    def page_link_or_span(page, span_class = 'current', text = nil)
+    def page_link_or_span(page, span_class, text = nil)
       text ||= page.to_s
+      classnames = Array[*span_class]
+      
       if page and page != current_page
-        @template.link_to text, url_options(page)
+        @template.link_to text, url_for(page), :rel => rel_value(page), :class => classnames[1]
       else
-        @template.content_tag :span, text, :class => span_class
+        @template.content_tag :span, text, :class => classnames.join(' ')
       end
     end
 
-    def url_options(page)
-      options = { param_name => page }
-      # page links should preserve GET parameters
-      options = params.merge(options) if @template.request.get?
-      options.rec_merge!(@options[:params]) if @options[:params]
-      return options
+    # Returns URL params for +page_link_or_span+, taking the current GET params
+    # and <tt>:params</tt> option into account.
+    def url_for(page)
+      unless @url_string
+        @url_params = { :escape => false }
+        # page links should preserve GET parameters
+        stringified_merge @url_params, @template.params if @template.request.get?
+        stringified_merge @url_params, @options[:params] if @options[:params]
+        
+        if param_name.index(/[^\w-]/)
+          page_param = (defined?(CGIMethods) ? CGIMethods : ActionController::AbstractRequest).
+            parse_query_parameters("#{param_name}=#{page}")
+          
+          stringified_merge @url_params, page_param
+        else
+          @url_params[param_name] = page
+        end
+
+        url = @template.url_for(@url_params)
+        @url_string = url.sub(/([?&]#{CGI.escape param_name}=)#{page}/, '\1@')
+        return url
+      end
+      @url_string.sub '@', page.to_s
     end
 
   private
 
+    def rel_value(page)
+      case page
+      when @collection.previous_page; 'prev' + (page == 1 ? ' start' : '')
+      when @collection.next_page; 'next'
+      when 1; 'start'
+      end
+    end
+
     def current_page
       @collection.current_page
     end
 
     def total_pages
-      @collection.page_count
+      @total_pages ||= WillPaginate::ViewHelpers.total_pages_for_collection(@collection)
     end
 
     def param_name
-      @param_name ||= @options[:param_name].to_sym
+      @param_name ||= @options[:param_name].to_s
     end
 
-    def params
-      @params ||= @template.params.to_hash.symbolize_keys
+    def stringified_merge(target, other)
+      other.each do |key, value|
+        key = key.to_s
+        existing = target[key]
+
+        if value.is_a?(Hash)
+          target[key] = existing = {} if existing.nil?
+          if existing.is_a?(Hash)
+            stringified_merge(existing, value)
+            return
+          end
+        end
+        
+        target[key] = value
+      end
     end
   end
 end

data/test/boot.rb

@@ -19,5 +19,3 @@ else
     gem 'activerecord'
   end
 end
-
-$:.unshift "#{plugin_root}/lib"

data/test/{array_pagination_test.rb → collection_test.rb}

@@ -1,5 +1,5 @@
-require File.dirname(__FILE__) + '/helper'
-require 'will_paginate/core_ext'
+require 'helper'
+require 'will_paginate/array'
 
 class ArrayPaginationTest < Test::Unit::TestCase
   def test_simple
@@ -11,7 +11,8 @@ class ArrayPaginationTest < Test::Unit::TestCase
      { :page => 3,  :per_page => 5,  :expected => [] },
     ].
     each do |conditions|
-      assert_equal conditions[:expected], collection.paginate(conditions.slice(:page, :per_page))
+      expected = conditions.delete :expected
+      assert_equal expected, collection.paginate(conditions)
     end
   end
 
@@ -22,14 +23,8 @@ class ArrayPaginationTest < Test::Unit::TestCase
   end
 
   def test_deprecated_api
-    assert_deprecated 'paginate API' do
-      result = (1..50).to_a.paginate(2, 10)
-      assert_equal 2, result.current_page
-      assert_equal (11..20).to_a, result
-      assert_equal 50, result.total_entries
-    end
-    
-    assert_deprecated { [].paginate nil }
+    assert_raise(ArgumentError) { [].paginate(2) }
+    assert_raise(ArgumentError) { [].paginate(2, 10) }
   end
 
   def test_total_entries_has_precedence
@@ -50,14 +45,28 @@ class ArrayPaginationTest < Test::Unit::TestCase
     end
 
     assert_equal entries, collection
-    assert_respond_to_all collection, %w(page_count each offset size current_page per_page total_entries)
+    assert_respond_to_all collection, %w(total_pages each offset size current_page per_page total_entries)
     assert_kind_of Array, collection
     assert_instance_of Array, collection.entries
     assert_equal 3, collection.offset
-    assert_equal 4, collection.page_count
+    assert_equal 4, collection.total_pages
     assert !collection.out_of_bounds?
   end
 
+  def test_previous_next_pages
+    collection = create(1, 1, 3)
+    assert_nil collection.previous_page
+    assert_equal 2, collection.next_page
+    
+    collection = create(2, 1, 3)
+    assert_equal 1, collection.previous_page
+    assert_equal 3, collection.next_page
+    
+    collection = create(3, 1, 3)
+    assert_equal 2, collection.previous_page
+    assert_nil collection.next_page
+  end
+
   def test_out_of_bounds
     entries = create(2, 3, 2){}
     assert entries.out_of_bounds?
@@ -90,13 +99,20 @@ class ArrayPaginationTest < Test::Unit::TestCase
       pager.replace array(0)
     end
     assert_equal nil, entries.total_entries
+    
+    entries = create(1) do |pager|
+      # collection is empty and we're on page 1,
+      # so the whole thing must be empty, too
+      pager.replace array(0)
+    end
+    assert_equal 0, entries.total_entries
   end
 
   def test_invalid_page
-    bad_input = [0, -1, nil, '', 'Schnitzel']
+    bad_inputs = [0, -1, nil, '', 'Schnitzel']
 
-    bad_input.each do |bad|
-      assert_raise(WillPaginate::InvalidPage) { create(bad) }
+    bad_inputs.each do |bad|
+      assert_raise(WillPaginate::InvalidPage) { create bad }
     end
   end
 
@@ -104,6 +120,11 @@ class ArrayPaginationTest < Test::Unit::TestCase
     assert_raise(ArgumentError) { create(1, -1) }
   end
 
+  def test_page_count_was_removed
+    assert_raise(NoMethodError) { create.page_count }
+    # It's `total_pages` now.
+  end
+
   private
     def create(page = 2, limit = 5, total = nil, &block)
       if block_given?
@@ -116,16 +137,4 @@ class ArrayPaginationTest < Test::Unit::TestCase
     def array(size = 3)
       Array.new(size)
     end
-    
-    def collect_deprecations
-      old_behavior = WillPaginate::Deprecation.behavior
-      deprecations = []
-      WillPaginate::Deprecation.behavior = Proc.new do |message, callstack|
-        deprecations << message
-      end
-      result = yield
-      [result, deprecations]
-    ensure
-      WillPaginate::Deprecation.behavior = old_behavior
-    end
 end

data/test/console

@@ -1,9 +1,8 @@
 #!/usr/bin/env ruby
 irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
 libs = []
-dirname = File.dirname(__FILE__)
 
 libs << 'irb/completion'
-libs << File.join(dirname, 'lib', 'load_fixtures')
+libs << File.join('lib', 'load_fixtures')
 
-exec "#{irb}#{libs.map{ |l| " -r #{l}" }.join} --simple-prompt"
+exec "#{irb} -Ilib:test#{libs.map{ |l| " -r #{l}" }.join} --simple-prompt"

data/test/database.yml

@@ -0,0 +1,22 @@
+sqlite3:
+  database: ":memory:"
+  adapter: sqlite3
+  timeout: 500
+
+sqlite2:
+  database: ":memory:"
+  adapter: sqlite2
+
+mysql:
+  adapter: mysql
+  username: rails
+  password: mislav
+  encoding: utf8
+  database: will_paginate_unittest
+
+postgres:
+  adapter: postgresql
+  username: mislav
+  password: mislav
+  database: will_paginate_unittest
+  min_messages: warning