dweinand-will_paginate 2.3.4 → 2.3.7

data/CHANGELOG.rdoc

@@ -1,3 +1,13 @@
+== 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).

data/lib/will_paginate.rb

@@ -80,11 +80,7 @@ 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

data/lib/will_paginate/collection.rb

@@ -83,7 +83,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/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
         
@@ -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,13 +181,14 @@ 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]
+        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
@@ -218,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  = 5
 
     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

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 ##
 
@@ -427,6 +433,12 @@ 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?')
       def test_removes_irrelevant_includes_in_count
@@ -444,5 +456,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/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/lib/activerecord_test_connector.rb

@@ -41,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

@@ -42,15 +42,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.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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: dweinand-will_paginate
 version: !ruby/object:Gem::Version 
-  version: 2.3.4
+  version: 2.3.7
 platform: ruby
 authors: 
 - "Mislav Marohni\xC4\x87"
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-09-16 00:00:00 -07:00
+date: 2009-02-10 00:00:00 -08:00
 default_executable: 
 dependencies: []