typo 5.3 → 5.4

data/vendor/plugins/will_paginate/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 = {}, &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

data/vendor/plugins/will_paginate/lib/will_paginate/named_scope_patch.rb

@@ -1,37 +0,0 @@
-ActiveRecord::Associations::AssociationProxy.class_eval do
-  protected
-  def with_scope(*args, &block)
-    @reflection.klass.send :with_scope, *args, &block
-  end
-end
-
-[ ActiveRecord::Associations::AssociationCollection,
-    ActiveRecord::Associations::HasManyThroughAssociation ].each do |klass|
-  klass.class_eval do
-    protected
-    alias :method_missing_without_scopes :method_missing_without_paginate
-    def method_missing_without_paginate(method, *args, &block)
-      if @reflection.klass.scopes.include?(method)
-        @reflection.klass.scopes[method].call(self, *args, &block)
-      else
-        method_missing_without_scopes(method, *args, &block)
-      end
-    end
-  end
-end
-
-# Rails 1.2.6
-ActiveRecord::Associations::HasAndBelongsToManyAssociation.class_eval do
-  protected
-  def method_missing(method, *args, &block)
-    if @target.respond_to?(method) || (!@reflection.klass.respond_to?(method) && Class.respond_to?(method))
-      super
-    elsif @reflection.klass.scopes.include?(method)
-      @reflection.klass.scopes[method].call(self, *args)
-    else
-      @reflection.klass.with_scope(:find => { :conditions => @finder_sql, :joins => @join_sql, :readonly => false }) do
-        @reflection.klass.send(method, *args, &block)
-      end
-    end
-  end
-end if ActiveRecord::Base.respond_to? :find_first

data/vendor/plugins/will_paginate/lib/will_paginate/version.rb

@@ -1,9 +0,0 @@
-module WillPaginate
-  module VERSION
-    MAJOR = 2
-    MINOR = 3
-    TINY  = 5
-
-    STRING = [MAJOR, MINOR, TINY].join('.')
-  end
-end

data/vendor/plugins/will_paginate/lib/will_paginate/view_helpers.rb

@@ -1,383 +0,0 @@
-require 'will_paginate/core_ext'
-
-module WillPaginate
-  # = Will Paginate view helpers
-  #
-  # The main view helper, #will_paginate, renders
-  # pagination links for the given collection. The helper itself is lightweight
-  # and serves only as a wrapper around LinkRenderer instantiation; the
-  # renderer then does all the hard work of generating the HTML.
-  # 
-  # == Global options for helpers
-  #
-  # Options for pagination helpers are optional and get their default values from the
-  # <tt>WillPaginate::ViewHelpers.pagination_options</tt> hash. You can write to this hash to
-  # override default options on the global level:
-  #
-  #   WillPaginate::ViewHelpers.pagination_options[:previous_label] = 'Previous page'
-  #
-  # By putting this into "config/initializers/will_paginate.rb" (or simply environment.rb in
-  # older versions of Rails) you can easily translate link texts to previous
-  # and next pages, as well as override some other defaults to your liking.
-  module ViewHelpers
-    # default options that can be overridden on the global level
-    @@pagination_options = {
-      :class          => 'pagination',
-      :previous_label => '&laquo; Previous',
-      :next_label     => 'Next &raquo;',
-      :inner_window   => 4, # links around the current page
-      :outer_window   => 1, # links around beginning and end
-      :separator      => ' ', # single space is friendly to spiders and non-graphic browsers
-      :param_name     => :page,
-      :params         => nil,
-      :renderer       => 'WillPaginate::LinkRenderer',
-      :page_links     => true,
-      :container      => true
-    }
-    mattr_reader :pagination_options
-
-    # Renders Digg/Flickr-style pagination for a WillPaginate::Collection
-    # object. Nil is returned if there is only one page in total; no point in
-    # rendering the pagination in that case...
-    # 
-    # ==== Options
-    # Display options:
-    # * <tt>:previous_label</tt> -- default: "« Previous" (this parameter is called <tt>:prev_label</tt> in versions <b>2.3.2</b> and older!)
-    # * <tt>:next_label</tt> -- default: "Next »"
-    # * <tt>:page_links</tt> -- when false, only previous/next links are rendered (default: true)
-    # * <tt>:inner_window</tt> -- how many links are shown around the current page (default: 4)
-    # * <tt>:outer_window</tt> -- how many links are around the first and the last page (default: 1)
-    # * <tt>:separator</tt> -- string separator for page HTML elements (default: single space)
-    # 
-    # HTML options:
-    # * <tt>:class</tt> -- CSS class name for the generated DIV (default: "pagination")
-    # * <tt>:container</tt> -- toggles rendering of the DIV container for pagination links, set to
-    #   false only when you are rendering your own pagination markup (default: true)
-    # * <tt>:id</tt> -- HTML ID for the container (default: nil). Pass +true+ to have the ID
-    #   automatically generated from the class name of objects in collection: for example, paginating
-    #   ArticleComment models would yield an ID of "article_comments_pagination".
-    #
-    # Advanced options:
-    # * <tt>:param_name</tt> -- parameter name for page number in URLs (default: <tt>:page</tt>)
-    # * <tt>:params</tt> -- additional parameters when generating pagination links
-    #   (eg. <tt>:controller => "foo", :action => nil</tt>)
-    # * <tt>:renderer</tt> -- class name, class or instance of a link renderer (default:
-    #   <tt>WillPaginate::LinkRenderer</tt>)
-    #
-    # All options not recognized by will_paginate will become HTML attributes on the container
-    # element for pagination links (the DIV). For example:
-    # 
-    #   <%= will_paginate @posts, :style => 'font-size: small' %>
-    #
-    # ... will result in:
-    #
-    #   <div class="pagination" style="font-size: small"> ... </div>
-    #
-    # ==== Using the helper without arguments
-    # If the helper is called without passing in the collection object, it will
-    # try to read from the instance variable inferred by the controller name.
-    # For example, calling +will_paginate+ while the current controller is
-    # PostsController will result in trying to read from the <tt>@posts</tt>
-    # variable. Example:
-    #
-    #   <%= will_paginate :id => true %>
-    #
-    # ... will result in <tt>@post</tt> collection getting paginated:
-    #
-    #   <div class="pagination" id="posts_pagination"> ... </div>
-    #
-    def will_paginate(collection = nil, options = {})
-      options, collection = collection, nil if collection.is_a? Hash
-      unless collection or !controller
-        collection_name = "@#{controller.controller_name}"
-        collection = instance_variable_get(collection_name)
-        raise ArgumentError, "The #{collection_name} variable appears to be empty. Did you " +
-          "forget to pass the collection object for will_paginate?" unless collection
-      end
-      # early exit if there is nothing to render
-      return nil unless WillPaginate::ViewHelpers.total_pages_for_collection(collection) > 1
-      
-      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.")
-        options[:previous_label] = options.delete(:prev_label)
-      end
-      
-      # get the renderer instance
-      renderer = case options[:renderer]
-      when String
-        options[:renderer].to_s.constantize.new
-      when Class
-        options[:renderer].new
-      else
-        options[:renderer]
-      end
-      # render HTML for pagination
-      renderer.prepare collection, options, self
-      renderer.to_html
-    end
-    
-    # Wrapper for rendering pagination links at both top and bottom of a block
-    # of content.
-    # 
-    #   <% paginated_section @posts do %>
-    #     <ol id="posts">
-    #       <% for post in @posts %>
-    #         <li> ... </li>
-    #       <% end %>
-    #     </ol>
-    #   <% end %>
-    #
-    # will result in:
-    #
-    #   <div class="pagination"> ... </div>
-    #   <ol id="posts">
-    #     ...
-    #   </ol>
-    #   <div class="pagination"> ... </div>
-    #
-    # Arguments are passed to a <tt>will_paginate</tt> call, so the same options
-    # apply. Don't use the <tt>:id</tt> option; otherwise you'll finish with two
-    # blocks of pagination links sharing the same ID (which is invalid HTML).
-    def paginated_section(*args, &block)
-      pagination = will_paginate(*args).to_s
-      content = pagination + capture(&block) + pagination
-      concat content, block.binding
-    end
-
-    # Renders a helpful message with numbers of displayed vs. total entries.
-    # You can use this as a blueprint for your own, similar helpers.
-    #
-    #   <%= page_entries_info @posts %>
-    #   #-> Displaying posts 6 - 10 of 26 in total
-    #
-    # By default, the message will use the humanized class name of objects
-    # in collection: for instance, "project types" for ProjectType models.
-    # Override this with the <tt>:entry_name</tt> parameter:
-    #
-    #   <%= page_entries_info @posts, :entry_name => 'item' %>
-    #   #-> Displaying items 6 - 10 of 26 in total
-    def page_entries_info(collection, options = {})
-      entry_name = options[:entry_name] ||
-        (collection.empty?? 'entry' : collection.first.class.name.underscore.sub('_', ' '))
-      
-      if collection.total_pages < 2
-        case collection.size
-        when 0; "No #{entry_name.pluralize} found"
-        when 1; "Displaying <b>1</b> #{entry_name}"
-        else;   "Displaying <b>all #{collection.size}</b> #{entry_name.pluralize}"
-        end
-      else
-        %{Displaying #{entry_name.pluralize} <b>%d&nbsp;-&nbsp;%d</b> of <b>%d</b> in total} % [
-          collection.offset + 1,
-          collection.offset + collection.length,
-          collection.total_entries
-        ]
-      end
-    end
-
-    def self.total_pages_for_collection(collection) #:nodoc:
-      if collection.respond_to?('page_count') and !collection.respond_to?('total_pages')
-        WillPaginate::Deprecation.warn <<-MSG
-          You are using a paginated collection of class #{collection.class.name}
-          which conforms to the old API of WillPaginate::Collection by using
-          `page_count`, while the current method name is `total_pages`. Please
-          upgrade yours or 3rd-party code that provides the paginated collection.
-        MSG
-        class << collection
-          def total_pages; page_count; end
-        end
-      end
-      collection.total_pages
-    end
-  end
-
-  # This class does the heavy lifting of actually building the pagination
-  # links. It is used by the <tt>will_paginate</tt> helper internally.
-  class LinkRenderer
-
-    # The gap in page links is represented by:
-    #
-    #   <span class="gap">&hellip;</span>
-    attr_accessor :gap_marker
-    
-    def initialize
-      @gap_marker = '<span class="gap">&hellip;</span>'
-    end
-    
-    # * +collection+ is a WillPaginate::Collection instance or any other object
-    #   that conforms to that API
-    # * +options+ are forwarded from +will_paginate+ view helper
-    # * +template+ is the reference to the template being rendered
-    def prepare(collection, options, template)
-      @collection = collection
-      @options    = options
-      @template   = template
-
-      # reset values in case we're re-using this instance
-      @total_pages = @param_name = @url_string = nil
-    end
-
-    # Process it! This method returns the complete HTML string which contains
-    # pagination links. Feel free to subclass LinkRenderer and change this
-    # method as you see fit.
-    def to_html
-      links = @options[:page_links] ? windowed_links : []
-      # previous/next buttons
-      links.unshift page_link_or_span(@collection.previous_page, 'disabled prev_page', @options[:previous_label])
-      links.push    page_link_or_span(@collection.next_page,     'disabled next_page', @options[:next_label])
-      
-      html = links.join(@options[:separator])
-      @options[:container] ? @template.content_tag(:div, html, html_attributes) : html
-    end
-
-    # Returns the subset of +options+ this instance was initialized with that
-    # represent HTML attributes for the container element of pagination links.
-    def html_attributes
-      return @html_attributes if @html_attributes
-      @html_attributes = @options.except *(WillPaginate::ViewHelpers.pagination_options.keys - [:class])
-      # pagination of Post models will have the ID of "posts_pagination"
-      if @options[:container] and @options[:id] === true
-        @html_attributes[:id] = @collection.first.class.name.underscore.pluralize + '_pagination'
-      end
-      @html_attributes
-    end
-    
-  protected
-
-    # Collects link items for visible page numbers.
-    def windowed_links
-      prev = nil
-
-      visible_page_numbers.inject [] do |links, n|
-        # detect gaps:
-        links << gap_marker if prev and n > prev + 1
-        links << page_link_or_span(n, 'current')
-        prev = n
-        links
-      end
-    end
-
-    # Calculates visible page numbers using the <tt>:inner_window</tt> and
-    # <tt>:outer_window</tt> options.
-    def visible_page_numbers
-      inner_window, outer_window = @options[:inner_window].to_i, @options[:outer_window].to_i
-      window_from = current_page - inner_window
-      window_to = current_page + inner_window
-      
-      # adjust lower or upper limit if other is out of bounds
-      if window_to > total_pages
-        window_from -= window_to - total_pages
-        window_to = total_pages
-      end
-      if window_from < 1
-        window_to += 1 - window_from
-        window_from = 1
-        window_to = total_pages if window_to > total_pages
-      end
-      
-      visible   = (1..total_pages).to_a
-      left_gap  = (2 + outer_window)...window_from
-      right_gap = (window_to + 1)...(total_pages - outer_window)
-      visible  -= left_gap.to_a  if left_gap.last - left_gap.first > 1
-      visible  -= right_gap.to_a if right_gap.last - right_gap.first > 1
-
-      visible
-    end
-    
-    def page_link_or_span(page, span_class, text = nil)
-      text ||= page.to_s
-      
-      if page and page != current_page
-        classnames = span_class && span_class.index(' ') && span_class.split(' ', 2).last
-        page_link page, text, :rel => rel_value(page), :class => classnames
-      else
-        page_span page, text, :class => span_class
-      end
-    end
-
-    def page_link(page, text, attributes = {})
-      @template.link_to text, url_for(page), attributes
-    end
-
-    def page_span(page, text, attributes = {})
-      @template.content_tag :span, text, attributes
-    end
-
-    # Returns URL params for +page_link_or_span+, taking the current GET params
-    # and <tt>:params</tt> option into account.
-    def url_for(page)
-      page_one = page == 1
-      unless @url_string and !page_one
-        @url_params = {}
-        # page links should preserve GET parameters
-        stringified_merge @url_params, @template.params if @template.request.get?
-        stringified_merge @url_params, @options[:params] if @options[:params]
-        
-        if complex = param_name.index(/[^\w-]/)
-          page_param = (defined?(CGIMethods) ? CGIMethods : ActionController::AbstractRequest).
-            parse_query_parameters("#{param_name}=#{page}")
-          
-          stringified_merge @url_params, page_param
-        else
-          @url_params[param_name] = page_one ? 1 : 2
-        end
-
-        url = @template.url_for(@url_params)
-        return url if page_one
-        
-        if complex
-          @url_string = url.sub(%r!((?:\?|&amp;)#{CGI.escape param_name}=)#{page}!, '\1@')
-          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] = '@'
-              break
-            end
-          end
-        end
-      end
-      # finally!
-      @url_string.sub '@', page.to_s
-    end
-
-  private
-
-    def rel_value(page)
-      case page
-      when @collection.previous_page; 'prev' + (page == 1 ? ' start' : '')
-      when @collection.next_page; 'next'
-      when 1; 'start'
-      end
-    end
-
-    def current_page
-      @collection.current_page
-    end
-
-    def total_pages
-      @total_pages ||= WillPaginate::ViewHelpers.total_pages_for_collection(@collection)
-    end
-
-    def param_name
-      @param_name ||= @options[:param_name].to_s
-    end
-
-    # Recursively merge into target hash by using stringified keys from the other one
-    def stringified_merge(target, other)
-      other.each do |key, value|
-        key = key.to_s # this line is what it's all about!
-        existing = target[key]
-
-        if value.is_a?(Hash) and (existing.is_a?(Hash) or existing.nil?)
-          stringified_merge(existing || (target[key] = {}), value)
-        else
-          target[key] = value
-        end
-      end
-    end
-  end
-end