backlog 0.37.2 → 0.41.4

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

@@ -1,181 +0,0 @@
-require 'will_paginate/core_ext'
-
-module WillPaginate
-  # A mixin for ActiveRecord::Base. Provides +per_page+ class method
-  # and makes +paginate+ finders possible with some method_missing magic.
-  #
-  # Find out more in WillPaginate::Finder::ClassMethods
-  #
-  module Finder
-    def self.included(base)
-      base.extend ClassMethods
-      class << base
-        alias_method_chain :method_missing, :paginate
-        define_method(:per_page) { 30 } unless respond_to?(:per_page)
-      end
-    end
-
-    # = Paginating finders for ActiveRecord models
-    # 
-    # WillPaginate doesn't really add extra methods to your ActiveRecord models
-    # (except +per_page+ unless it's already available). It simply intercepts
-    # the calls to paginating finders such as +paginate+, +paginate_by_user_id+
-    # (and so on) and translates them to ordinary finders: +find+,
-    # +find_by_user_id+, etc. It does so with some +method_missing+ magic, but
-    # you don't need to care for that. You simply use paginating finders same
-    # way you used ordinary ones. You only need to specify what page do you want:
-    #
-    #   @posts = Post.paginate :page => params[:page]
-    # 
-    # In paginating finders, "all" is implicit. No sense in paginating a single
-    # record, right? So:
-    # 
-    #   Post.paginate                  => Post.find :all
-    #   Post.paginate_all_by_something => Post.find_all_by_something
-    #   Post.paginate_by_something     => Post.find_all_by_something
-    #
-    # Don't forget to pass the +page+ parameter! Without it, paginating finders
-    # will raise an error.
-    #
-    # == Options 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+
-    # 
-    module ClassMethods
-      # This methods 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)
-          options.update :offset => pager.offset, :limit => pager.per_page
-          
-          original_query = query.dup
-          add_limit! query, options
-          # 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}) AS count_table"
-            # perform the count query
-            pager.total_entries = count_by_sql(count_query)
-          end
-        end
-      end
-
-      def respond_to?(method, include_priv = false)
-        case method.to_sym
-        when :paginate, :paginate_by_sql
-          true
-        else
-          super(method.to_s.sub(/^paginate/, 'find'), include_priv)
-        end
-      end
-
-    protected
-      
-      def method_missing_with_paginate(method, *args, &block)
-        # 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
-
-        options = args.pop
-        page, per_page, total_entries = wp_parse_options!(options)
-        # an array of IDs may have been given:
-        total_entries ||= (Array === args.first and args.first.size)
-        
-        # paginate finders are really just find_* with limit and offset
-        finder = method.to_s.sub /^paginate/, 'find'
-
-        # :all is implicit
-        if finder == 'find'
-          args.unshift(:all) if args.empty?
-        elsif finder.index('find_by_') == 0
-          finder.sub! /^find/, 'find_all'
-        end
-
-        WillPaginate::Collection.create(page, per_page, total_entries) do |pager|
-          args << options.except(:count).merge(:offset => pager.offset, :limit => pager.per_page)
-          pager.replace send(finder, *args)
-          
-          # magic counting for user convenience:
-          pager.total_entries = wp_count!(options, args, finder) unless pager.total_entries
-        end
-      end
-
-      def wp_count!(options, args, finder)
-        excludees = [:count, :order, :limit, :offset]
-        unless options[:select] and options[:select] =~ /^\s*DISTINCT/i
-          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.delete(:count) || {}) if options.key? :count
-
-        # we may have to scope ...
-        counter = Proc.new { count(count_options) }
-
-        # we may be in a model or an association proxy!
-        klass = (@owner and @reflection) ? @reflection.klass : self
-
-        count = if finder =~ /^find_/ 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 conditions = wp_extract_finder_conditions(finder, args)
-                  # extracted the conditions from calls like "paginate_by_foo_and_bar"
-                  with_scope(:find => { :conditions => conditions }, &counter)
-                else
-                  counter.call
-                end
-
-        count.respond_to?(:length) ? count.length : count
-      end
-
-      def wp_parse_options!(options)
-        raise ArgumentError, 'hash parameters expected' unless options.respond_to? :symbolize_keys!
-        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 parameters'
-        end
-
-        page     = options.delete(:page) || 1
-        per_page = options.delete(:per_page) || self.per_page
-        total    = options.delete(:total_entries)
-        [page, per_page, total]
-      end
-
-    private
-
-      # thanks to active record for making us duplicate this code
-      def wp_extract_finder_conditions(finder, arguments)
-        return unless match = /^find_(all_by|by)_([_a-zA-Z]\w*)$/.match(finder.to_s)
-
-        attribute_names = extract_attribute_names_from_match(match)
-        unless all_attributes_exists?(attribute_names)
-          raise "I can't make sense of `#{finder}`. Try doing the count manually"
-        end
-        construct_attributes_from_arguments(attribute_names, arguments)
-      end
-    end
-  end
-end

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

@@ -1,206 +0,0 @@
-require 'will_paginate/core_ext'
-
-module WillPaginate
-  # = Will Paginate view helpers
-  #
-  # Currently there is only one view helper: +will_paginate+. It renders the
-  # pagination links for the given collection. The helper itself is lightweight
-  # and serves only as a wrapper around link renderer 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
-  # WillPaginate::ViewHelpers.pagination_options hash. You can write to this hash to
-  # override default options on the global level:
-  #
-  #   WillPaginate::ViewHelpers.pagination_options[:prev_label] = 'Previous page'
-  #
-  # By putting this into your environment.rb 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',
-      :prev_label   => '« Previous',
-      :next_label   => 'Next »',
-      :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
-    # * <tt>:class</tt> -- CSS class name for the generated DIV (default: "pagination")
-    # * <tt>:prev_label</tt> -- default: "« Previous"
-    # * <tt>:next_label</tt> -- default: "Next »"
-    # * <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)
-    # * <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 of the link renderer (default: WillPaginate::LinkRenderer)
-    # * <tt>:page_links</tt> -- when false, only previous/next links are rendered (default: true)
-    # * <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".
-    #
-    # All options beside listed ones are passed as HTML attributes to the container
-    # element for pagination links (the DIV). For example:
-    # 
-    #   <%= will_paginate @posts, :id => 'wp_posts' %>
-    #
-    # ... will result in:
-    #
-    #   <div class="pagination" id="wp_posts"> ... </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 specify the collection object for will_paginate?" unless collection
-      end
-      # early exit if there is nothing to render
-      return nil unless collection.page_count > 1
-      options = options.symbolize_keys.reverse_merge WillPaginate::ViewHelpers.pagination_options
-      # create the renderer instance
-      renderer_class = options[:renderer].to_s.constantize
-      renderer = renderer_class.new collection, options, self
-      # render HTML for pagination
-      renderer.to_html
-    end
-  end
-
-  # This class does the heavy lifting of actually building the pagination
-  # links. It is used by +will_paginate+ helper internally, but avoid using it
-  # directly (for now) because its API is not set in stone yet.
-  class LinkRenderer
-
-    def initialize(collection, options, template)
-      @collection = collection
-      @options    = options
-      @template   = template
-    end
-
-    def to_html
-      links = @options[:page_links] ? windowed_paginator : []
-      # previous/next buttons
-      links.unshift page_link_or_span(@collection.previous_page, 'disabled', @options[:prev_label])
-      links.push    page_link_or_span(@collection.next_page,     'disabled', @options[:next_label])
-      
-      html = links.join(@options[:separator])
-      @options[:container] ? @template.content_tag(:div, html, html_attributes) : html
-    end
-
-    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
-
-    def windowed_paginator
-      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
-      elsif window_from < 1
-        window_to += 1 - window_from
-        window_from = 1
-      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
-      
-      links, prev = [], 0
-
-      visible.each do |n|
-        unless n - prev > 1
-          prev = n
-          links << page_link_or_span(n)
-        else
-          # ellipsis represents the gap between windows
-          prev = n - 1
-          links << '...'
-          redo
-        end
-      end
-      
-      links
-    end
-
-    def page_link_or_span(page, span_class = 'current', text = nil)
-      text ||= page.to_s
-      if page and page != current_page
-        @template.link_to text, url_options(page)
-      else
-        @template.content_tag :span, text, :class => span_class
-      end
-    end
-
-    def url_options(page)
-      options = { param_name => page }
-      # page links should preserve GET parameters
-      options = params.merge(options) if @template.request.get?
-      options.rec_merge!(@options[:params]) if @options[:params]
-      return options
-    end
-
-  private
-
-    def current_page
-      @collection.current_page
-    end
-
-    def total_pages
-      @collection.page_count
-    end
-
-    def param_name
-      @param_name ||= @options[:param_name].to_sym
-    end
-
-    def params
-      @params ||= @template.params.to_hash.symbolize_keys
-    end
-  end
-end

data/vendor/plugins/will_paginate/test/array_pagination_test.rb

@@ -1,131 +0,0 @@
-require File.dirname(__FILE__) + '/helper'
-require 'will_paginate/core_ext'
-
-class ArrayPaginationTest < Test::Unit::TestCase
-  def test_simple
-    collection = ('a'..'e').to_a
-    
-    [{ :page => 1,  :per_page => 3,  :expected => %w( a b c ) },
-     { :page => 2,  :per_page => 3,  :expected => %w( d e ) },
-     { :page => 1,  :per_page => 5,  :expected => %w( a b c d e ) },
-     { :page => 3,  :per_page => 5,  :expected => [] },
-    ].
-    each do |conditions|
-      assert_equal conditions[:expected], collection.paginate(conditions.slice(:page, :per_page))
-    end
-  end
-
-  def test_defaults
-    result = (1..50).to_a.paginate
-    assert_equal 1, result.current_page
-    assert_equal 30, result.size
-  end
-
-  def test_deprecated_api
-    assert_deprecated 'paginate API' do
-      result = (1..50).to_a.paginate(2, 10)
-      assert_equal 2, result.current_page
-      assert_equal (11..20).to_a, result
-      assert_equal 50, result.total_entries
-    end
-    
-    assert_deprecated { [].paginate nil }
-  end
-
-  def test_total_entries_has_precedence
-    result = %w(a b c).paginate :total_entries => 5
-    assert_equal 5, result.total_entries
-  end
-
-  def test_argument_error_with_params_and_another_argument
-    assert_raise ArgumentError do
-      [].paginate({}, 5)
-    end
-  end
-
-  def test_paginated_collection
-    entries = %w(a b c)
-    collection = create(2, 3, 10) do |pager|
-      assert_equal entries, pager.replace(entries)
-    end
-
-    assert_equal entries, collection
-    assert_respond_to_all collection, %w(page_count each offset size current_page per_page total_entries)
-    assert_kind_of Array, collection
-    assert_instance_of Array, collection.entries
-    assert_equal 3, collection.offset
-    assert_equal 4, collection.page_count
-    assert !collection.out_of_bounds?
-  end
-
-  def test_out_of_bounds
-    entries = create(2, 3, 2){}
-    assert entries.out_of_bounds?
-    
-    entries = create(1, 3, 2){}
-    assert !entries.out_of_bounds?
-  end
-
-  def test_guessing_total_count
-    entries = create do |pager|
-      # collection is shorter than limit
-      pager.replace array
-    end
-    assert_equal 8, entries.total_entries
-    
-    entries = create(2, 5, 10) do |pager|
-      # collection is shorter than limit, but we have an explicit count
-      pager.replace array
-    end
-    assert_equal 10, entries.total_entries
-    
-    entries = create do |pager|
-      # collection is the same as limit; we can't guess
-      pager.replace array(5)
-    end
-    assert_equal nil, entries.total_entries
-    
-    entries = create do |pager|
-      # collection is empty; we can't guess
-      pager.replace array(0)
-    end
-    assert_equal nil, entries.total_entries
-  end
-
-  def test_invalid_page
-    bad_input = [0, -1, nil, '', 'Schnitzel']
-
-    bad_input.each do |bad|
-      assert_raise(WillPaginate::InvalidPage) { create(bad) }
-    end
-  end
-
-  def test_invalid_per_page_setting
-    assert_raise(ArgumentError) { create(1, -1) }
-  end
-
-  private
-    def create(page = 2, limit = 5, total = nil, &block)
-      if block_given?
-        WillPaginate::Collection.create(page, limit, total, &block)
-      else
-        WillPaginate::Collection.new(page, limit, total)
-      end
-    end
-
-    def array(size = 3)
-      Array.new(size)
-    end
-    
-    def collect_deprecations
-      old_behavior = WillPaginate::Deprecation.behavior
-      deprecations = []
-      WillPaginate::Deprecation.behavior = Proc.new do |message, callstack|
-        deprecations << message
-      end
-      result = yield
-      [result, deprecations]
-    ensure
-      WillPaginate::Deprecation.behavior = old_behavior
-    end
-end