shingara-will_paginate 2.3.3 → 2.3.10

data/CHANGELOG.rdoc

@@ -1,3 +1,19 @@
+== 2.3.6, released 2008-10-26
+
+* Rails 2.2 fix: stop using `extract_attribute_names_from_match` inernal AR method, it no longer exists
+
+== 2.3.5, released 2008-10-07
+
+* update the backported named_scope implementation for Rails versions older than 2.1
+* break out of scope of paginated_each() yielded block when used on named scopes
+* fix paginate(:from)
+
+== 2.3.4, released 2008-09-16
+
+* Removed gem dependency to Active Support (causes trouble with vendored rails).
+* Rails 2.1: fix a failing test and a deprecation warning.
+* Cope with scoped :select when counting.
+
 == 2.3.3, released 2008-08-29
 
 * Ensure that paginate_by_sql doesn't change the original SQL query.

data/README.rdoc

@@ -87,7 +87,8 @@ contributions or just simply awesome ideas:
 Chris Wanstrath, Dr. Nic Williams, K. Adam Christensen, Mike Garey, Bence
 Golda, Matt Aimonetti, Charles Brian Quinn, Desi McAdam, James Coglan, Matijs
 van Zuijlen, Maria, Brendan Ribera, Todd Willey, Bryan Helmkamp, Jan Berkel,
-Lourens Naudé, Rick Olson, Russell Norris, Piotr Usewicz, Chris Eppstein.
+Lourens Naudé, Rick Olson, Russell Norris, Piotr Usewicz, Chris Eppstein,
+Denis Barushev, Ben Pickles.
 
 
 == Usable pagination in the UI

data/Rakefile

@@ -32,18 +32,9 @@ desc %{Update ".manifest" with the latest list of project filenames. Respect\
 .gitignore by excluding everything that git ignores. Update `files` and\
 `test_files` arrays in "*.gemspec" file if it's present.}
 task :manifest do
-  list = Dir['**/*'].sort
-  spec_file = Dir['*.gemspec'].first
-  list -= [spec_file] if spec_file
+  list = `git ls-files --full-name --exclude=*.gemspec --exclude=.*`.chomp.split("\n")
   
-  File.read('.gitignore').each_line do |glob|
-    glob = glob.chomp.sub(/^\//, '')
-    list -= Dir[glob]
-    list -= Dir["#{glob}/**/*"] if File.directory?(glob) and !File.symlink?(glob)
-    puts "excluding #{glob}"
-  end
-
-  if spec_file
+  if spec_file = Dir['*.gemspec'].first
     spec = File.read spec_file
     spec.gsub! /^(\s* s.(test_)?files \s* = \s* )( \[ [^\]]* \] | %w\( [^)]* \) )/mx do
       assignment = $1
@@ -51,9 +42,9 @@ task :manifest do
       '%s%%w(%s)' % [assignment, bunch.join(' ')]
     end
       
-    File.open(spec_file,   'w') {|f| f << spec }
+    File.open(spec_file, 'w') { |f| f << spec }
   end
-  File.open('.manifest', 'w') {|f| f << list.join("\n") }
+  File.open('.manifest', 'w') { |f| f << list.join("\n") }
 end
 
 task :examples do

data/lib/will_paginate.rb

@@ -17,7 +17,7 @@ module WillPaginate
     
     # hooks WillPaginate::ViewHelpers into ActionView::Base
     def enable_actionpack
-      return if ActionView::Base.instance_methods.include? 'will_paginate'
+      return if ActionView::Base.instance_methods.include_method? :will_paginate
       require 'will_paginate/view_helpers'
       ActionView::Base.send :include, ViewHelpers
 
@@ -44,6 +44,16 @@ module WillPaginate
         klass.send :include, Finder::ClassMethods
         klass.class_eval { alias_method_chain :method_missing, :paginate }
       end
+      
+      # monkeypatch Rails ticket #2189: "count breaks has_many :through"
+      ActiveRecord::Base.class_eval do
+        protected
+        def self.construct_count_options_from_args(*args)
+          result = super
+          result[0] = '*' if result[0].is_a?(String) and result[0] =~ /\.\*$/
+          result
+        end
+      end
     end
 
     # Enable named_scope, a feature of Rails 2.1, even if you have older Rails
@@ -68,15 +78,12 @@ module WillPaginate
 
     def self.warn(message, callstack = caller)
       message = 'WillPaginate: ' + message.strip.gsub(/\s+/, ' ')
-      behavior.call(message, callstack) if behavior && !silenced?
-    end
-
-    def self.silenced?
-      ActiveSupport::Deprecation.silenced?
+      ActiveSupport::Deprecation.warn(message, callstack)
     end
   end
 end
 
-if defined?(Rails) and defined?(ActiveRecord) and defined?(ActionController)
-  WillPaginate.enable
+if defined? Rails
+  WillPaginate.enable_activerecord if defined? ActiveRecord
+  WillPaginate.enable_actionpack if defined? ActionController
 end

data/lib/will_paginate/collection.rb

@@ -82,7 +82,7 @@ module WillPaginate
     #
     # The Array#paginate API has since then changed, but this still serves as a
     # fine example of WillPaginate::Collection usage.
-    def self.create(page, per_page, total = nil, &block)
+    def self.create(page, per_page, total = nil)
       pager = new(page, per_page, total)
       yield pager
       pager

data/lib/will_paginate/core_ext.rb

@@ -1,7 +1,18 @@
 require 'set'
 require 'will_paginate/array'
 
-unless Hash.instance_methods.include? 'except'
+# 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
+
+unless Hash.instance_methods.include_method? :except
   Hash.class_eval do
     # Returns a new hash without the given keys.
     def except(*keys)
@@ -16,7 +27,7 @@ unless Hash.instance_methods.include? 'except'
   end
 end
 
-unless Hash.instance_methods.include? 'slice'
+unless Hash.instance_methods.include_method? :slice
   Hash.class_eval do
     # Returns a new hash with only the given keys.
     def slice(*keys)

data/lib/will_paginate/finder.rb

@@ -61,7 +61,7 @@ module WillPaginate
       #
       # All other options (+conditions+, +order+, ...) are forwarded to +find+
       # and +count+ calls.
-      def paginate(*args, &block)
+      def paginate(*args)
         options = args.pop
         page, per_page, total_entries = wp_parse_options(options)
         finder = (options[:finder] || 'find').to_s
@@ -79,7 +79,7 @@ module WillPaginate
           
           args << find_options
           # @options_from_last_find = nil
-          pager.replace send(finder, *args, &block)
+          pager.replace(send(finder, *args) { |*a| yield(*a) if block_given? })
           
           # magic counting for user convenience:
           pager.total_entries = wp_count(count_options, args, finder) unless pager.total_entries
@@ -96,7 +96,7 @@ module WillPaginate
       #
       # See {Faking Cursors in ActiveRecord}[http://weblog.jamisbuck.org/2007/4/6/faking-cursors-in-activerecord]
       # where Jamis Buck describes this and a more efficient way for MySQL.
-      def paginated_each(options = {}, &block)
+      def paginated_each(options = {})
         options = { :order => 'id', :page => 1 }.merge options
         options[:page] = options[:page].to_i
         options[:total_entries] = 0 # skip the individual count queries
@@ -104,7 +104,10 @@ module WillPaginate
         
         begin 
           collection = paginate(options)
-          total += collection.each(&block).size
+          with_exclusive_scope(:find => {}) do
+            # using exclusive scope so that the block is yielded in scope-free context
+            total += collection.each { |item| yield item }.size
+          end
           options[:page] += 1
         end until collection.size < collection.per_page
         
@@ -138,7 +141,7 @@ module WillPaginate
             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)
+            unless self.connection.adapter_name =~ /^(oracle|oci$)/i
               count_query << ' AS count_table'
             end
             # perform the count query
@@ -158,10 +161,14 @@ module WillPaginate
 
     protected
       
-      def method_missing_with_paginate(method, *args, &block) #:nodoc:
+      def method_missing_with_paginate(method, *args) #:nodoc:
         # did somebody tried to paginate? if not, let them be
         unless method.to_s.index('paginate') == 0
-          return method_missing_without_paginate(method, *args, &block) 
+          if block_given?
+            return method_missing_without_paginate(method, *args) { |*a| yield(*a) }
+          else
+            return method_missing_without_paginate(method, *args) 
+          end
         end
         
         # paginate finders are really just find_* with limit and offset
@@ -174,14 +181,27 @@ module WillPaginate
         options[:finder] = finder
         args << options
         
-        paginate(*args, &block)
+        paginate(*args) { |*a| yield(*a) if block_given? }
       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)
         excludees = [:count, :order, :limit, :offset, :readonly]
-        unless options[:select] and options[:select] =~ /^\s*DISTINCT\b/i
+        excludees << :from unless ActiveRecord::Calculations::CALCULATIONS_OPTIONS.include?(:from)
+
+        # we may be in a model or an association proxy
+        klass = (@owner and @reflection) ? @reflection.klass : self
+
+        # Use :select from scope if it isn't already present.
+        options[:select] = scope(:find, :select) unless options[:select]
+
+        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}"
+          end
+        else
           excludees << :select # only exclude the select param if it doesn't begin with DISTINCT
         end
 
@@ -191,13 +211,10 @@ module WillPaginate
         # 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]
-        
-        # we may be in a model or an association proxy
-        klass = (@owner and @reflection) ? @reflection.klass : self
-        
+
         # forget about includes if they are irrelevant (Rails 2.1)
         if count_options[:include] and
-            klass.private_methods.include?('references_eager_loaded_tables?') and
+            klass.private_methods.include_method?(:references_eager_loaded_tables?) and
             !klass.send(:references_eager_loaded_tables?, count_options)
           count_options.delete :include
         end
@@ -209,9 +226,9 @@ module WillPaginate
                   # 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 match = /^find_(all_by|by)_([_a-zA-Z]\w*)$/.match(finder)
+                elsif finder =~ /^find_(all_by|by)_([_a-zA-Z]\w*)$/
                   # extract conditions from calls like "paginate_by_foo_and_bar"
-                  attribute_names = extract_attribute_names_from_match(match)
+                  attribute_names = $2.split('_and_')
                   conditions = construct_attributes_from_arguments(attribute_names, args)
                   with_scope(:find => { :conditions => conditions }, &counter)
                 else

data/lib/will_paginate/named_scope.rb

@@ -1,27 +1,22 @@
-## stolen from: http://dev.rubyonrails.org/browser/trunk/activerecord/lib/active_record/named_scope.rb?rev=9084
-
 module WillPaginate
   # This is a feature backported from Rails 2.1 because of its usefullness not only with will_paginate,
   # but in other aspects when managing complex conditions that you want to be reusable.
   module NamedScope
     # All subclasses of ActiveRecord::Base have two named_scopes:
     # * <tt>all</tt>, which is similar to a <tt>find(:all)</tt> query, and
-    # * <tt>scoped</tt>, which allows for the creation of anonymous scopes, on the fly:
-    #
-    #   Shirt.scoped(:conditions => {:color => 'red'}).scoped(:include => :washing_instructions)
+    # * <tt>scoped</tt>, which allows for the creation of anonymous scopes, on the fly: <tt>Shirt.scoped(:conditions => {:color => 'red'}).scoped(:include => :washing_instructions)</tt>
     #
     # These anonymous scopes tend to be useful when procedurally generating complex queries, where passing
     # intermediate values (scopes) around as first-class objects is convenient.
     def self.included(base)
       base.class_eval do
         extend ClassMethods
-        named_scope :all
         named_scope :scoped, lambda { |scope| scope }
       end
     end
 
     module ClassMethods
-      def scopes #:nodoc:
+      def scopes
         read_inheritable_attribute(:scopes) || write_inheritable_attribute(:scopes, {})
       end
 
@@ -46,7 +41,7 @@ module WillPaginate
       # Nested finds and calculations also work with these compositions: <tt>Shirt.red.dry_clean_only.count</tt> returns the number of garments
       # for which these criteria obtain. Similarly with <tt>Shirt.red.dry_clean_only.average(:thread_count)</tt>.
       #
-      # All scopes are available as class methods on the ActiveRecord descendent upon which the scopes were defined. But they are also available to
+      # All scopes are available as class methods on the ActiveRecord::Base descendent upon which the scopes were defined. But they are also available to
       # <tt>has_many</tt> associations. If,
       #
       #   class Person < ActiveRecord::Base
@@ -76,14 +71,27 @@ module WillPaginate
       #     end
       #   end
       #
-      def named_scope(name, options = {}, &block)
+      #
+      # For testing complex named scopes, you can examine the scoping options using the
+      # <tt>proxy_options</tt> method on the proxy itself.
+      #
+      #   class Shirt < ActiveRecord::Base
+      #     named_scope :colored, lambda { |color|
+      #       { :conditions => { :color => color } }
+      #     }
+      #   end
+      #
+      #   expected_options = { :conditions => { :colored => 'red' } }
+      #   assert_equal expected_options, Shirt.colored('red').proxy_options
+      def named_scope(name, options = {})
+        name = name.to_sym
         scopes[name] = lambda do |parent_scope, *args|
           Scope.new(parent_scope, case options
             when Hash
               options
             when Proc
               options.call(*args)
-          end, &block)
+          end) { |*a| yield(*a) if block_given? }
         end
         (class << self; self end).instance_eval do
           define_method name do |*args|
@@ -93,14 +101,20 @@ module WillPaginate
       end
     end
     
-    class Scope #:nodoc:
+    class Scope
       attr_reader :proxy_scope, :proxy_options
-      [].methods.each { |m| delegate m, :to => :proxy_found unless m =~ /(^__|^nil\?|^send|class|extend|find|count|sum|average|maximum|minimum|paginate)/ }
+
+      [].methods.each do |m|
+        unless m =~ /(^__|^nil\?|^send|^object_id$|class|extend|^find$|count|sum|average|maximum|minimum|paginate|first|last|empty\?|respond_to\?)/
+          delegate m, :to => :proxy_found
+        end
+      end
+
       delegate :scopes, :with_scope, :to => :proxy_scope
 
-      def initialize(proxy_scope, options, &block)
+      def initialize(proxy_scope, options)
         [options[:extend]].flatten.each { |extension| extend extension } if options[:extend]
-        extend Module.new(&block) if block_given?
+        extend Module.new { |*args| yield(*args) } if block_given?
         @proxy_scope, @proxy_options = proxy_scope, options.except(:extend)
       end
 
@@ -108,18 +122,42 @@ module WillPaginate
         load_found; self
       end
 
+      def first(*args)
+        if args.first.kind_of?(Integer) || (@found && !args.first.kind_of?(Hash))
+          proxy_found.first(*args)
+        else
+          find(:first, *args)
+        end
+      end
+
+      def last(*args)
+        if args.first.kind_of?(Integer) || (@found && !args.first.kind_of?(Hash))
+          proxy_found.last(*args)
+        else
+          find(:last, *args)
+        end
+      end
+
+      def empty?
+        @found ? @found.empty? : count.zero?
+      end
+
+      def respond_to?(method, include_private = false)
+        super || @proxy_scope.respond_to?(method, include_private)
+      end
+
       protected
       def proxy_found
         @found || load_found
       end
 
       private
-      def method_missing(method, *args, &block)
+      def method_missing(method, *args)
         if scopes.include?(method)
           scopes[method].call(self, *args)
         else
           with_scope :find => proxy_options do
-            proxy_scope.send(method, *args, &block)
+            proxy_scope.send(method, *args) { |*a| yield(*a) if block_given? }
           end
         end
       end

data/lib/will_paginate/named_scope_patch.rb

@@ -1,9 +1,7 @@
-## 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
+  def with_scope(*args)
+    @reflection.klass.send(:with_scope, *args) { |*a| yield(*a) if block_given? }
   end
 end
 
@@ -12,11 +10,11 @@ end
   klass.class_eval do
     protected
     alias :method_missing_without_scopes :method_missing_without_paginate
-    def method_missing_without_paginate(method, *args, &block)
+    def method_missing_without_paginate(method, *args)
       if @reflection.klass.scopes.include?(method)
-        @reflection.klass.scopes[method].call(self, *args, &block)
+        @reflection.klass.scopes[method].call(self, *args) { |*a| yield(*a) if block_given? }
       else
-        method_missing_without_scopes(method, *args, &block)
+        method_missing_without_scopes(method, *args) { |*a| yield(*a) if block_given? }
       end
     end
   end
@@ -25,14 +23,14 @@ end
 # Rails 1.2.6
 ActiveRecord::Associations::HasAndBelongsToManyAssociation.class_eval do
   protected
-  def method_missing(method, *args, &block)
+  def method_missing(method, *args)
     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)
+        @reflection.klass.send(method, *args) { |*a| yield(*a) if block_given? }
       end
     end
   end

data/lib/will_paginate/version.rb

@@ -2,7 +2,7 @@ module WillPaginate
   module VERSION
     MAJOR = 2
     MINOR = 3
-    TINY  = 3
+    TINY  = 10
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/lib/will_paginate/view_helpers.rb

@@ -99,7 +99,7 @@ module WillPaginate
       
       options = options.symbolize_keys.reverse_merge WillPaginate::ViewHelpers.pagination_options
       if options[:prev_label]
-        WillPaginate::Deprecation::warn(":prev_label view parameter is now :previous_label; the old name has been deprecated.")
+        WillPaginate::Deprecation::warn(":prev_label view parameter is now :previous_label; the old name has been deprecated", caller)
         options[:previous_label] = options.delete(:prev_label)
       end
       
@@ -141,8 +141,15 @@ module WillPaginate
     # 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
+      
+      unless ActionView::Base.respond_to? :erb_variable
+        concat pagination
+        yield
+        concat pagination
+      else
+        content = pagination + capture(&block) + pagination
+        concat(content, block.binding)
+      end
     end
 
     # Renders a helpful message with numbers of displayed vs. total entries.
@@ -178,12 +185,11 @@ module WillPaginate
 
     def self.total_pages_for_collection(collection) #:nodoc:
       if collection.respond_to?('page_count') and !collection.respond_to?('total_pages')
-        WillPaginate::Deprecation.warn <<-MSG
+        WillPaginate::Deprecation.warn %{
           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
+          upgrade yours or 3rd-party code that provides the paginated collection}, caller
         class << collection
           def total_pages; page_count; end
         end
@@ -315,8 +321,7 @@ module WillPaginate
         stringified_merge @url_params, @options[:params] if @options[:params]
         
         if complex = param_name.index(/[^\w-]/)
-          page_param = (defined?(CGIMethods) ? CGIMethods : ActionController::AbstractRequest).
-            parse_query_parameters("#{param_name}=#{page}")
+          page_param = parse_query_parameters("#{param_name}=#{page}")
           
           stringified_merge @url_params, page_param
         else
@@ -327,21 +332,21 @@ module WillPaginate
         return url if page_one
         
         if complex
-          @url_string = url.sub(%r!((?:\?|&amp;)#{CGI.escape param_name}=)#{page}!, '\1@')
+          @url_string = url.sub(%r!((?:\?|&amp;)#{CGI.escape param_name}=)#{page}!, "\\1\0")
           return url
         else
           @url_string = url
           @url_params[param_name] = 3
           @template.url_for(@url_params).split(//).each_with_index do |char, i|
             if char == '3' and url[i, 1] == '2'
-              @url_string[i] = '@'
+              @url_string[i] = "\0"
               break
             end
           end
         end
       end
       # finally!
-      @url_string.sub '@', page.to_s
+      @url_string.sub "\0", page.to_s
     end
 
   private
@@ -379,5 +384,21 @@ module WillPaginate
         end
       end
     end
+
+    def parse_query_parameters(params)
+      if defined? Rack::Utils
+        # For Rails > 2.3
+        Rack::Utils.parse_nested_query(params)
+      elsif defined?(ActionController::AbstractRequest)
+        ActionController::AbstractRequest.parse_query_parameters(params)
+      elsif defined?(ActionController::UrlEncodedPairParser)
+        # For Rails > 2.2
+        ActionController::UrlEncodedPairParser.parse_query_parameters(params)
+      elsif defined?(CGIMethods)
+        CGIMethods.parse_query_parameters(params)
+      else
+        raise "unsupported ActionPack version"
+      end
+    end
   end
 end

data/test/collection_test.rb

@@ -2,6 +2,9 @@ require 'helper'
 require 'will_paginate/array'
 
 class ArrayPaginationTest < Test::Unit::TestCase
+  
+  def setup ; end
+  
   def test_simple
     collection = ('a'..'e').to_a
     

data/test/database.yml

@@ -17,6 +17,6 @@ mysql:
 postgres:
   adapter: postgresql
   username: mislav
-  password: mislav
+  password: 
   database: will_paginate_unittest
   min_messages: warning

data/test/finder_test.rb

@@ -261,6 +261,12 @@ class FinderTest < ActiveRecordTestCase
       assert_equal 1, entries.total_entries, 'only one topic should be found'
     end
   end
+  
+  def test_named_scope_with_include
+    project = projects(:active_record)
+    entries = project.topics.with_replies_starting_with('AR ').paginate(:page => 1, :per_page => 1)
+    assert_equal 1, entries.size
+  end
 
   ## misc ##
 
@@ -278,11 +284,11 @@ class FinderTest < ActiveRecordTestCase
   # this functionality is temporarily removed
   def xtest_pagination_defines_method
     pager = "paginate_by_created_at"
-    assert !User.methods.include?(pager), "User methods should not include `#{pager}` method"
+    assert !User.methods.include_method?(pager), "User methods should not include `#{pager}` method"
     # paginate!
     assert 0, User.send(pager, nil, :page => 1).total_entries
     # the paging finder should now be defined
-    assert User.methods.include?(pager), "`#{pager}` method should be defined on User"
+    assert User.methods.include_method?(pager), "`#{pager}` method should be defined on User"
   end
 
   # Is this Rails 2.0? Find out by testing find_all which was removed in [6998]
@@ -340,6 +346,12 @@ class FinderTest < ActiveRecordTestCase
       Developer.paginate :select => 'DISTINCT salary', :page => 2
     end
 
+    def test_count_with_scoped_select_when_distinct
+      Developer.stubs(:find).returns([])
+      Developer.expects(:count).with(:select => 'DISTINCT users.id').returns(0)
+      Developer.distinct.paginate :page => 2
+    end
+
     def test_should_use_scoped_finders_if_present
       # scope-out compatibility
       Topic.expects(:find_best).returns(Array.new(5))
@@ -349,18 +361,15 @@ class FinderTest < ActiveRecordTestCase
     end
 
     def test_paginate_by_sql
-      assert_respond_to Developer, :paginate_by_sql
-      Developer.expects(:find_by_sql).with(regexp_matches(/sql LIMIT 3(,| OFFSET) 3/)).returns([])
-      Developer.expects(:count_by_sql).with('SELECT COUNT(*) FROM (sql) AS count_table').returns(0)
-      
-      entries = Developer.paginate_by_sql 'sql', :page => 2, :per_page => 3
+      sql = "SELECT * FROM users WHERE type = 'Developer' ORDER BY id"
+      entries = Developer.paginate_by_sql(sql, :page => 2, :per_page => 3)
+      assert_equal 11, entries.total_entries
+      assert_equal [users(:dev_4), users(:dev_5), users(:dev_6)], entries
     end
 
     def test_paginate_by_sql_respects_total_entries_setting
-      Developer.expects(:find_by_sql).returns([])
-      Developer.expects(:count_by_sql).never
-      
-      entries = Developer.paginate_by_sql 'sql', :page => 1, :total_entries => 999
+      sql = "SELECT * FROM users"
+      entries = Developer.paginate_by_sql(sql, :page => 1, :total_entries => 999)
       assert_equal 999, entries.total_entries
     end
 
@@ -390,12 +399,11 @@ class FinderTest < ActiveRecordTestCase
 
     def test_paginating_finder_doesnt_mangle_options
       Developer.expects(:find).returns([])
-      options = { :page => 1 }
-      options.expects(:delete).never
+      options = { :page => 1, :per_page => 2, :foo => 'bar' }
       options_before = options.dup
       
       Developer.paginate(options)
-      assert_equal options, options_before
+      assert_equal options_before, options
     end
     
     def test_paginate_by_sql_doesnt_change_original_query
@@ -422,8 +430,14 @@ class FinderTest < ActiveRecordTestCase
       assert_equal 14, Developer.paginated_each(:page => '2') { }
     end
 
+    def test_paginated_each_with_named_scope
+      assert_equal 2, Developer.poor.paginated_each(:per_page => 1) {
+        assert_equal 11, Developer.count
+      }
+    end
+
     # detect ActiveRecord 2.1
-    if ActiveRecord::Base.private_methods.include?('references_eager_loaded_tables?')
+    if ActiveRecord::Base.private_methods.include_method?(:references_eager_loaded_tables?)
       def test_removes_irrelevant_includes_in_count
         Developer.expects(:find).returns([1])
         Developer.expects(:count).with({}).returns(0)
@@ -439,5 +453,21 @@ class FinderTest < ActiveRecordTestCase
           :include => :projects, :conditions => 'projects.id > 2'
       end
     end
+    
+    def test_paginate_from
+      result = Developer.paginate(:from => 'users', :page => 1, :per_page => 1)
+      assert_equal 1, result.size
+    end
+    
+    def test_hmt_with_include
+      # ticket #220
+      reply = projects(:active_record).replies.find(:first, :order => 'replies.id')
+      assert_equal replies(:decisive), reply
+      
+      # ticket #223
+      Project.find(1, :include => :replies)
+      
+      # I cannot reproduce any of the failures from those reports :(
+    end
   end
 end

data/test/fixtures/developer.rb

@@ -7,6 +7,7 @@ class Developer < User
     end
   end
 
+  named_scope :distinct, :select => 'DISTINCT `users`.*'
   named_scope :poor, :conditions => ['salary <= ?', 80000], :order => 'salary'
 
   def self.per_page() 10 end

data/test/fixtures/topic.rb

@@ -3,4 +3,8 @@ class Topic < ActiveRecord::Base
   belongs_to :project
 
   named_scope :mentions_activerecord, :conditions => ['topics.title LIKE ?', '%ActiveRecord%']
+  
+  named_scope :with_replies_starting_with, lambda { |text|
+    { :conditions => "replies.content LIKE '#{text}%' ", :include  => :replies }
+  }
 end

data/test/helper.rb

@@ -29,7 +29,10 @@ end
 
 # Wrap tests that use Mocha and skip if unavailable.
 def uses_mocha(test_name)
-  require 'mocha' unless Object.const_defined?(:Mocha)
+  unless Object.const_defined?(:Mocha)
+    gem 'mocha', '>= 0.9.5'
+    require 'mocha'
+  end
 rescue LoadError => load_error
   $stderr.puts "Skipping #{test_name} tests. `gem install mocha` and try again."
 else

data/test/lib/activerecord_test_case.rb

@@ -1,6 +1,13 @@
 require 'lib/activerecord_test_connector'
 
 class ActiveRecordTestCase < Test::Unit::TestCase
+  if defined?(ActiveSupport::Testing::SetupAndTeardown)
+    include ActiveSupport::Testing::SetupAndTeardown
+  end
+
+  if defined?(ActiveRecord::TestFixtures)
+    include ActiveRecord::TestFixtures
+  end
   # Set our fixture path
   if ActiveRecordTestConnector.able_to_connect
     self.fixture_path = File.join(File.dirname(__FILE__), '..', 'fixtures')

data/test/lib/activerecord_test_connector.rb

@@ -16,16 +16,20 @@ class ActiveRecordTestConnector
     unless self.connected || !self.able_to_connect
       setup_connection
       load_schema
-      Dependencies.load_paths.unshift FIXTURES_PATH
+      add_load_path FIXTURES_PATH
       self.connected = true
     end
   rescue Exception => e  # errors from ActiveRecord setup
-    $stderr.puts "\nSkipping ActiveRecord tests: #{e}"
-    $stderr.puts "Install SQLite3 to run the full test suite for will_paginate.\n\n"
+    $stderr.puts "\nSkipping ActiveRecord tests: #{e}\n\n"
     self.able_to_connect = false
   end
 
   private
+  
+  def self.add_load_path(path)
+    dep = defined?(ActiveSupport::Dependencies) ? ActiveSupport::Dependencies : ::Dependencies
+    dep.load_paths.unshift path
+  end
 
   def self.setup_connection
     db = ENV['DB'].blank?? 'sqlite3' : ENV['DB']
@@ -37,6 +41,8 @@ class ActiveRecordTestConnector
     ActiveRecord::Base.logger = Logger.new(STDOUT) if $0 == 'irb'
     puts "using #{configuration['adapter']} adapter" unless ENV['DB'].blank?
     
+    gem 'sqlite3-ruby' if 'sqlite3' == db
+    
     ActiveRecord::Base.establish_connection(configuration)
     ActiveRecord::Base.configurations = { db => configuration }
     prepare ActiveRecord::Base.connection

data/test/lib/view_test_process.rb

@@ -1,3 +1,4 @@
+require 'will_paginate/core_ext'
 require 'action_controller'
 require 'action_controller/test_process'
 
@@ -17,6 +18,13 @@ end
 ActionController::Base.perform_caching = false
 
 class WillPaginate::ViewTestCase < Test::Unit::TestCase
+  if defined?(ActionController::TestCase::Assertions)
+    include ActionController::TestCase::Assertions
+  end
+  if defined?(ActiveSupport::Testing::Deprecation)
+    include ActiveSupport::Testing::Deprecation
+  end
+
   def setup
     super
     @controller  = DummyController.new
@@ -42,15 +50,21 @@ class WillPaginate::ViewTestCase < Test::Unit::TestCase
 
       locals = { :collection => collection, :options => options }
 
-      if defined? ActionView::InlineTemplate
-        # Rails 2.1
-        args = [ ActionView::InlineTemplate.new(@view, @template, locals) ]
+      unless @view.respond_to? :render_template
+        # Rails 2.2
+        @html_result = ActionView::InlineTemplate.new(@template).render(@view, locals)
       else
-        # older Rails versions
-        args = [nil, @template, nil, locals]
+        if defined? ActionView::InlineTemplate
+          # Rails 2.1
+          args = [ ActionView::InlineTemplate.new(@view, @template, locals) ]
+        else
+          # older Rails versions
+          args = [nil, @template, nil, locals]
+        end
+
+        @html_result = @view.render_template(*args)
       end
       
-      @html_result = @view.render_template(*args)
       @html_document = HTML::Document.new(@html_result, true, false)
 
       if block_given?

data/test/tasks.rake

@@ -35,7 +35,7 @@ task :test_full => %w(test test_mysql test_postgres)
 desc %{Test everything with Rails 2.1.x, 2.0.x & 1.2.x gems}
 task :test_all do
   all = Rake::Task['test_full']
-  versions = %w(2.1.0 2.0.2 1.2.6)
+  versions = %w(2.3.2 2.2.2 2.1.0 2.0.4 1.2.6)
   versions.each do |version|
     ENV['RAILS_VERSION'] = "~> #{version}"
     all.invoke

data/test/view_test.rb

@@ -192,13 +192,15 @@ class ViewTest < WillPaginate::ViewTestCase
       @html_result
   end
 
-  def test_page_entries_info_with_longer_class_name
-    @template = '<%= page_entries_info collection %>'
-    collection = ('a'..'z').to_a.paginate
-    collection.first.stubs(:class).returns(mock('class', :name => 'ProjectType'))
+  uses_mocha 'class name' do
+    def test_page_entries_info_with_longer_class_name
+      @template = '<%= page_entries_info collection %>'
+      collection = ('a'..'z').to_a.paginate
+      collection.first.stubs(:class).returns(mock('class', :name => 'ProjectType'))
     
-    paginate collection
-    assert @html_result.index('project types'), "expected <#{@html_result.inspect}> to mention 'project types'"
+      paginate collection
+      assert @html_result.index('project types'), "expected <#{@html_result.inspect}> to mention 'project types'"
+    end
   end
 
   def test_page_entries_info_with_single_page_collection
@@ -275,6 +277,14 @@ class ViewTest < WillPaginate::ViewTestCase
       end
     end    
   end
+
+  def test_will_paginate_with_atmark_url
+    @request.symbolized_path_parameters[:action] = "@tag"
+    renderer = WillPaginate::LinkRenderer.new
+    
+    paginate({ :page => 1 }, :renderer=>renderer)
+    assert_links_match %r[/foo/@tag\?page=\d]
+  end
   
   def test_complex_custom_page_param
     @request.params :developers => { :page => 2 }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: shingara-will_paginate
 version: !ruby/object:Gem::Version 
-  version: 2.3.3
+  version: 2.3.10
 platform: ruby
 authors: 
 - "Mislav Marohni\xC4\x87"
@@ -10,18 +10,10 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-08-29 00:00:00 -07:00
+date: 2009-05-21 00:00:00 -07:00
 default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: activesupport
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 1.4.4
-    version: 
+dependencies: []
+
 description: The will_paginate library provides a simple, yet powerful and extensible API for ActiveRecord pagination and rendering of pagination links in ActionView templates.
 email: mislav.marohnic@gmail.com
 executables: []
@@ -37,15 +29,12 @@ files:
 - LICENSE
 - README.rdoc
 - Rakefile
-- examples
 - examples/apple-circle.gif
 - examples/index.haml
 - examples/index.html
 - examples/pagination.css
 - examples/pagination.sass
 - init.rb
-- lib
-- lib/will_paginate
 - lib/will_paginate.rb
 - lib/will_paginate/array.rb
 - lib/will_paginate/collection.rb
@@ -55,13 +44,11 @@ files:
 - lib/will_paginate/named_scope_patch.rb
 - lib/will_paginate/version.rb
 - lib/will_paginate/view_helpers.rb
-- test
 - test/boot.rb
 - test/collection_test.rb
 - test/console
 - test/database.yml
 - test/finder_test.rb
-- test/fixtures
 - test/fixtures/admin.rb
 - test/fixtures/developer.rb
 - test/fixtures/developers_projects.yml
@@ -75,7 +62,6 @@ files:
 - test/fixtures/user.rb
 - test/fixtures/users.yml
 - test/helper.rb
-- test/lib
 - test/lib/activerecord_test_case.rb
 - test/lib/activerecord_test_connector.rb
 - test/lib/load_fixtures.rb
@@ -117,7 +103,6 @@ test_files:
 - test/console
 - test/database.yml
 - test/finder_test.rb
-- test/fixtures
 - test/fixtures/admin.rb
 - test/fixtures/developer.rb
 - test/fixtures/developers_projects.yml
@@ -131,7 +116,6 @@ test_files:
 - test/fixtures/user.rb
 - test/fixtures/users.yml
 - test/helper.rb
-- test/lib
 - test/lib/activerecord_test_case.rb
 - test/lib/activerecord_test_connector.rb
 - test/lib/load_fixtures.rb