merb_paginate 0.9.0

data/lib/will_paginate/core_ext.rb

@@ -0,0 +1,58 @@
+require 'set'
+require 'will_paginate/array'
+
+## Everything below blatantly stolen from ActiveSupport  :o
+
+unless Hash.instance_methods.include? 'except'
+  Hash.class_eval do
+    # Returns a new hash without the given keys.
+    def except(*keys)
+      rejected = Set.new(respond_to?(:convert_key) ? keys.map { |key| convert_key(key) } : keys)
+      reject { |key,| rejected.include?(key) }
+    end
+ 
+    # Replaces the hash without only the given keys.
+    def except!(*keys)
+      replace(except(*keys))
+    end
+  end
+end
+
+unless Hash.instance_methods.include? 'slice'
+  Hash.class_eval do
+    # Returns a new hash with only the given keys.
+    def slice(*keys)
+      allowed = Set.new(respond_to?(:convert_key) ? keys.map { |key| convert_key(key) } : keys)
+      reject { |key,| !allowed.include?(key) }
+    end
+
+    # Replaces the hash with only the given keys.
+    def slice!(*keys)
+      replace(slice(*keys))
+    end
+  end
+end
+
+unless String.instance_methods.include? 'constantize'
+  String.class_eval do
+    def constantize
+      unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ self
+        raise NameError, "#{self.inspect} is not a valid constant name!"
+      end
+
+      Object.module_eval("::#{$1}", __FILE__, __LINE__)
+    end
+  end
+end
+
+unless String.instance_methods.include? 'underscore'
+  String.class_eval do
+    def underscore
+      self.to_s.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+    end
+  end
+end

data/lib/will_paginate/deprecation.rb

@@ -0,0 +1,50 @@
+# borrowed from ActiveSupport::Deprecation
+module WillPaginate
+  module Deprecation
+    def self.debug() @debug; end
+    def self.debug=(value) @debug = value; end
+    self.debug = false
+
+    # Choose the default warn behavior according to RAILS_ENV.
+    # Ignore deprecation warnings in production.
+    BEHAVIORS = {
+      'test'        => Proc.new { |message, callstack|
+                         $stderr.puts(message)
+                         $stderr.puts callstack.join("\n  ") if debug
+                       },
+      'development' => Proc.new { |message, callstack|
+                         logger = defined?(::RAILS_DEFAULT_LOGGER) ? ::RAILS_DEFAULT_LOGGER : Logger.new($stderr)
+                         logger.warn message
+                         logger.debug callstack.join("\n  ") if debug
+                       }
+    }
+
+    def self.warn(message, callstack = caller)
+      if behavior
+        message = 'WillPaginate: ' + message.strip.gsub(/\s+/, ' ')
+        behavior.call(message, callstack)
+      end
+    end
+
+    def self.default_behavior
+      if defined?(RAILS_ENV)
+        BEHAVIORS[RAILS_ENV.to_s]
+      else
+        BEHAVIORS['test']
+      end
+    end
+
+    # Behavior is a block that takes a message argument.
+    def self.behavior() @behavior; end
+    def self.behavior=(value) @behavior = value; end
+    self.behavior = default_behavior
+
+    def self.silence
+      old_behavior = self.behavior
+      self.behavior = nil
+      yield
+    ensure
+      self.behavior = old_behavior
+    end
+  end
+end

data/lib/will_paginate/finders.rb

@@ -0,0 +1,9 @@
+require 'will_paginate/core_ext'
+
+module WillPaginate
+  # Database logic for different ORMs
+  #
+  # See WillPaginate::Finders::Base
+  module Finders
+  end
+end

data/lib/will_paginate/finders/active_record.rb

@@ -0,0 +1,192 @@
+require 'will_paginate/finders/base'
+require 'active_record'
+
+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).
+  # 
+  # 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
+    
+    # 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
+        add_limit! query, :offset => pager.offset, :limit => pager.per_page
+        # 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)
+        end
+      end
+    end
+
+    def respond_to?(method, include_priv = false) #:nodoc:
+      super(method.to_s.sub(/^paginate/, 'find'), include_priv)
+    end
+
+  protected
+    
+    def method_missing_with_paginate(method, *args, &block) #: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) 
+      end
+      
+      # paginate finders are really just find_* with limit and offset
+      finder = method.to_s.sub('paginate', 'find')
+      finder.sub!('find', 'find_all') if finder.index('find_by_') == 0
+      
+      options = args.pop
+      raise ArgumentError, 'parameter hash expected' unless options.respond_to? :symbolize_keys
+      options = options.dup
+      options[:finder] = finder
+      args << options
+      
+      paginate(*args, &block)
+    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) 
+
+      if finder == 'find'
+        if Array === args.first and !pager.total_entries
+          pager.total_entries = args.first.size
+        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) 
+      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
+    end
+    
+    def wp_parse_count_options(options, klass) #:nodoc:
+      excludees = [:count, :order, :limit, :offset, :readonly]
+      
+      unless ::ActiveRecord::Calculations::CALCULATIONS_OPTIONS.include?(:from)
+        # :from parameter wasn't supported in count() before this change
+        excludees << :from
+      end
+      
+      # 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
+      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 (Rails 2.1)
+      if count_options[:include] and
+          klass.private_methods.include?('references_eager_loaded_tables?') and
+          !klass.send(:references_eager_loaded_tables?, count_options)
+        count_options.delete :include
+      end
+      
+      count_options
+    end
+  end
+end
+
+ActiveRecord::Base.class_eval do
+  extend WillPaginate::Finders::ActiveRecord
+  class << self
+    alias_method_chain :method_missing, :paginate
+  end
+end
+
+# support pagination on associations
+a = ActiveRecord::Associations
+returning([ a::AssociationCollection ]) { |classes|
+  # detect http://dev.rubyonrails.org/changeset/9230
+  unless a::HasManyThroughAssociation.superclass == a::HasManyAssociation
+    classes << a::HasManyThroughAssociation
+  end
+}.each do |klass|
+  klass.send :include, WillPaginate::Finders::ActiveRecord
+  klass.class_eval { alias_method_chain :method_missing, :paginate }
+end

data/lib/will_paginate/finders/active_record/named_scope.rb

@@ -0,0 +1,170 @@
+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: <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 :scoped, lambda { |scope| scope }
+      end
+    end
+
+    module ClassMethods
+      def scopes
+        read_inheritable_attribute(:scopes) || write_inheritable_attribute(:scopes, {})
+      end
+
+      # Adds a class method for retrieving and querying objects. A scope represents a narrowing of a database query,
+      # such as <tt>:conditions => {:color => :red}, :select => 'shirts.*', :include => :washing_instructions</tt>.
+      #
+      #   class Shirt < ActiveRecord::Base
+      #     named_scope :red, :conditions => {:color => 'red'}
+      #     named_scope :dry_clean_only, :joins => :washing_instructions, :conditions => ['washing_instructions.dry_clean_only = ?', true]
+      #   end
+      # 
+      # The above calls to <tt>named_scope</tt> define class methods <tt>Shirt.red</tt> and <tt>Shirt.dry_clean_only</tt>. <tt>Shirt.red</tt>, 
+      # in effect, represents the query <tt>Shirt.find(:all, :conditions => {:color => 'red'})</tt>.
+      #
+      # Unlike Shirt.find(...), however, the object returned by <tt>Shirt.red</tt> is not an Array; it resembles the association object
+      # constructed by a <tt>has_many</tt> declaration. For instance, you can invoke <tt>Shirt.red.find(:first)</tt>, <tt>Shirt.red.count</tt>,
+      # <tt>Shirt.red.find(:all, :conditions => {:size => 'small'})</tt>. Also, just
+      # as with the association objects, name scopes acts like an Array, implementing Enumerable; <tt>Shirt.red.each(&block)</tt>,
+      # <tt>Shirt.red.first</tt>, and <tt>Shirt.red.inject(memo, &block)</tt> all behave as if Shirt.red really were an Array.
+      #
+      # These named scopes are composable. For instance, <tt>Shirt.red.dry_clean_only</tt> will produce all shirts that are both red and dry clean only.
+      # 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::Base descendent upon which the scopes were defined. But they are also available to
+      # <tt>has_many</tt> associations. If,
+      #
+      #   class Person < ActiveRecord::Base
+      #     has_many :shirts
+      #   end
+      #
+      # then <tt>elton.shirts.red.dry_clean_only</tt> will return all of Elton's red, dry clean
+      # only shirts.
+      #
+      # Named scopes can also be procedural.
+      #
+      #   class Shirt < ActiveRecord::Base
+      #     named_scope :colored, lambda { |color|
+      #       { :conditions => { :color => color } }
+      #     }
+      #   end
+      #
+      # In this example, <tt>Shirt.colored('puce')</tt> finds all puce shirts.
+      #
+      # Named scopes can also have extensions, just as with <tt>has_many</tt> declarations:
+      #
+      #   class Shirt < ActiveRecord::Base
+      #     named_scope :red, :conditions => {:color => 'red'} do
+      #       def dom_id
+      #         'red_shirts'
+      #       end
+      #     end
+      #   end
+      #
+      #
+      # 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 = {}, &block)
+        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
+        (class << self; self end).instance_eval do
+          define_method name do |*args|
+            scopes[name].call(self, *args)
+          end
+        end
+      end
+    end
+    
+    class Scope
+      attr_reader :proxy_scope, :proxy_options
+
+      [].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)
+        [options[:extend]].flatten.each { |extension| extend extension } if options[:extend]
+        extend Module.new(&block) if block_given?
+        @proxy_scope, @proxy_options = proxy_scope, options.except(:extend)
+      end
+
+      def reload
+        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)
+        if scopes.include?(method)
+          scopes[method].call(self, *args)
+        else
+          with_scope :find => proxy_options do
+            proxy_scope.send(method, *args, &block)
+          end
+        end
+      end
+
+      def load_found
+        @found = find(:all)
+      end
+    end
+  end
+end