will_paginate 2.3.17 → 3.0.pre

data/lib/will_paginate/finder.rb

@@ -1,269 +0,0 @@
-require 'will_paginate/core_ext'
-require 'will_paginate/per_page'
-
-module WillPaginate
-  # A mixin for ActiveRecord::Base. Provides +per_page+ class method
-  # and hooks things up to provide paginating finders.
-  #
-  # Find out more in WillPaginate::Finder::ClassMethods
-  #
-  module Finder
-    def self.included(base)
-      base.extend PerPage
-      base.extend ClassMethods
-      class << base
-        alias_method_chain :method_missing, :paginate
-      end
-    end
-
-    # = 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
-    #
-    # == The importance of the <tt>:order</tt> parameter
-    #
-    # In ActiveRecord finders, <tt>:order</tt> parameter specifies columns for
-    # the <tt>ORDER BY</tt> clause in SQL. It is important to have it, since
-    # pagination only makes sense with ordered sets. Without the <tt>ORDER
-    # BY</tt> clause, databases aren't required to do consistent ordering when
-    # performing <tt>SELECT</tt> queries; this is especially true for
-    # PostgreSQL.
-    #
-    # Therefore, make sure you are doing ordering on a column that makes the
-    # most sense in the current context. Make that obvious to the user, also.
-    # For perfomance reasons you will also want to add an index to that column.
-    module ClassMethods
-      # This is the main paginating finder.
-      #
-      # == Special parameters for paginating finders
-      # * <tt>:page</tt> -- REQUIRED, but defaults to 1 if false or nil
-      # * <tt>:per_page</tt> -- defaults to <tt>CurrentModel.per_page</tt> (which is 30 if not overridden)
-      # * <tt>:total_entries</tt> -- use only if you manually count total entries
-      # * <tt>:count</tt> -- additional options that are passed on to +count+
-      # * <tt>:finder</tt> -- name of the ActiveRecord finder used (default: "find")
-      #
-      # All other options (+conditions+, +order+, ...) are forwarded to +find+
-      # and +count+ calls.
-      def paginate(*args)
-        options = args.pop
-        page, per_page, total_entries = wp_parse_options(options)
-        finder = (options[:finder] || 'find').to_s
-
-        if finder == 'find'
-          # an array of IDs may have been given:
-          total_entries ||= (Array === args.first and args.first.size)
-          # :all is implicit
-          args.unshift(:all) if args.empty?
-        end
-
-        WillPaginate::Collection.create(page, per_page, total_entries) do |pager|
-          count_options = options.except :page, :per_page, :total_entries, :finder
-          find_options = count_options.except(:count).update(:offset => pager.offset, :limit => pager.per_page) 
-          
-          args << find_options
-          # @options_from_last_find = nil
-          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
-        end
-      end
-
-      # Iterates through all records by loading one page at a time. This is useful
-      # for migrations or any other use case where you don't want to load all the
-      # records in memory at once.
-      #
-      # It uses +paginate+ internally; therefore it accepts all of its options.
-      # You can specify a starting page with <tt>:page</tt> (default is 1). Default
-      # <tt>:order</tt> is <tt>"id"</tt>, override if necessary.
-      #
-      # 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 = {})
-        order = scope(:find, :order) || 'id'
-        options = { :order => order, :page => 1 }.merge options
-        options[:page] = options[:page].to_i
-        options[:total_entries] = 0 # skip the individual count queries
-        total = 0
-        
-        begin 
-          collection = paginate(options)
-          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
-        
-        total
-      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
-          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 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
-      end
-
-      def respond_to?(method, include_priv = false) #:nodoc:
-        case method.to_sym
-        when :paginate, :paginate_by_sql
-          true
-        else
-          super || super(method.to_s.sub(/^paginate/, 'find'), include_priv)
-        end
-      end
-
-    protected
-
-      def respond_to_missing?(method, include_private = false)
-        method.to_s.index('paginate') == 0 || super
-      end
-
-      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
-          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
-        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) { |*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
-
-        # 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
-
-        # 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_method?(:references_eager_loaded_tables?) and
-            !klass.send(:references_eager_loaded_tables?, count_options)
-          count_options.delete :include
-        end
-
-        # 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.is_a?(Integer) && count.respond_to?(:length)) ? count.length : count
-      end
-
-      def wp_parse_options(options) #:nodoc:
-        raise ArgumentError, 'parameter hash expected' unless options.respond_to? :symbolize_keys
-        options = options.symbolize_keys
-        raise ArgumentError, ':page parameter required' unless options.key? :page
-        
-        if options[:count] and options[:total_entries]
-          raise ArgumentError, ':count and :total_entries are mutually exclusive'
-        end
-
-        page     = options[:page] || 1
-        per_page = options[:per_page] || self.per_page
-        total    = options[:total_entries]
-        [page, per_page, total]
-      end
-
-    private
-
-      # def find_every_with_paginate(options)
-      #   @options_from_last_find = options
-      #   find_every_without_paginate(options)
-      # end
-    end
-  end
-end

data/lib/will_paginate/i18n.rb

@@ -1,29 +0,0 @@
-module WillPaginate
-  module I18n
-    def self.locale_dir
-      File.expand_path('../locale', __FILE__)
-    end
-
-    def self.load_path
-      Dir["#{locale_dir}/*.{rb,yml}"]
-    end
-
-    def will_paginate_translate(keys, options = {})
-      if defined? ::I18n
-        defaults = Array(keys).dup
-        if block_given?
-          if defined? ::I18n::Backend::Simple::MATCH
-            # procs in defaults array were not supported back then
-            defaults << yield(defaults.first, options)
-          else
-            defaults << Proc.new
-          end
-        end
-        ::I18n.translate(defaults.shift, options.merge(:default => defaults, :scope => :will_paginate))
-      else
-        key = Array === keys ? keys.first : keys
-        yield key, options
-      end
-    end
-  end
-end

data/lib/will_paginate/locale/en.yml

@@ -1,33 +0,0 @@
-en:
-  will_paginate:
-    previous_label: "« Previous"
-    next_label: "Next »"
-    page_gap: "…"
-
-    page_entries_info:
-      single_page:
-        zero:  "No %{model} found"
-        one:   "Displaying 1 %{model}"
-        other: "Displaying all %{count} %{model}"
-      single_page_html:
-        zero:  "No %{model} found"
-        one:   "Displaying <b>1</b> %{model}"
-        other: "Displaying <b>all&nbsp;%{count}</b> %{model}"
-
-      multi_page: "Displaying %{model} %{from} - %{to} of %{count} in total"
-      multi_page_html: "Displaying %{model} <b>%{from}&nbsp;-&nbsp;%{to}</b> of <b>%{count}</b> in total"
-
-    # models:
-    #   entry:
-    #     zero:  entries
-    #     one:   entry
-    #     few:   entries
-    #     other: entries
-
-    # line_item:
-    #   page_entries_info:
-    #     single_page:
-    #       zero:  "Your shopping cart is empty"
-    #       one:   "Displaying one item in your cart"
-    #       other: "Displaying all %{count} items"
-    #     multi_page: "Displaying items %{from} - %{to} of %{count} in total"

data/lib/will_paginate/named_scope.rb

@@ -1,170 +0,0 @@
-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 = {})
-        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) { |*a| yield(*a) if block_given? }
-        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)
-        [options[:extend]].flatten.each { |extension| extend extension } if options[:extend]
-        extend Module.new { |*args| yield(*args) } 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)
-        if scopes.include?(method)
-          scopes[method].call(self, *args)
-        else
-          with_scope :find => proxy_options do
-            proxy_scope.send(method, *args) { |*a| yield(*a) if block_given? }
-          end
-        end
-      end
-
-      def load_found
-        @found = find(:all)
-      end
-    end
-  end
-end