warvox - VoIP based wardialing tool, forked from rapid7/warvox.
DIR Log
DIR Files
DIR Refs
DIR README
---
DIR commit 26a2d4eb45574f2a127837abb4966260b652264b
DIR parent 0899f9ede192b63614dbf366f0d23a8370a0d5f9
HTML Author: HD Moore <hd_moore@rapid7.com>
Date: Wed, 23 Feb 2011 20:37:35 +0000
Diffstat:
A web/vendor/plugins/will_paginate/C… | 105 +++++++++++++++++++++++++++++++
A web/vendor/plugins/will_paginate/L… | 18 ++++++++++++++++++
A web/vendor/plugins/will_paginate/R… | 126 +++++++++++++++++++++++++++++++
A web/vendor/plugins/will_paginate/R… | 32 +++++++++++++++++++++++++++++++
A web/vendor/plugins/will_paginate/l… | 23 +++++++++++++++++++++++
A web/vendor/plugins/will_paginate/l… | 33 +++++++++++++++++++++++++++++++
A web/vendor/plugins/will_paginate/l… | 145 +++++++++++++++++++++++++++++++
A web/vendor/plugins/will_paginate/l… | 69 ++++++++++++++++++++++++++++++
A web/vendor/plugins/will_paginate/l… | 50 +++++++++++++++++++++++++++++++
A web/vendor/plugins/will_paginate/l… | 9 +++++++++
A web/vendor/plugins/will_paginate/l… | 158 +++++++++++++++++++++++++++++++
A web/vendor/plugins/will_paginate/l… | 52 +++++++++++++++++++++++++++++++
A web/vendor/plugins/will_paginate/l… | 112 +++++++++++++++++++++++++++++++
A web/vendor/plugins/will_paginate/l… | 30 ++++++++++++++++++++++++++++++
A web/vendor/plugins/will_paginate/l… | 24 ++++++++++++++++++++++++
A web/vendor/plugins/will_paginate/l… | 24 ++++++++++++++++++++++++
A web/vendor/plugins/will_paginate/l… | 9 +++++++++
A web/vendor/plugins/will_paginate/l… | 42 +++++++++++++++++++++++++++++++
A web/vendor/plugins/will_paginate/l… | 135 +++++++++++++++++++++++++++++++
A web/vendor/plugins/will_paginate/l… | 126 +++++++++++++++++++++++++++++++
A web/vendor/plugins/will_paginate/l… | 130 +++++++++++++++++++++++++++++++
A web/vendor/plugins/will_paginate/l… | 83 +++++++++++++++++++++++++++++++
A web/vendor/plugins/will_paginate/l… | 14 ++++++++++++++
A web/vendor/plugins/will_paginate/s… | 147 +++++++++++++++++++++++++++++++
A web/vendor/plugins/will_paginate/s… | 8 ++++++++
A web/vendor/plugins/will_paginate/s… | 9 +++++++++
A web/vendor/plugins/will_paginate/s… | 22 ++++++++++++++++++++++
A web/vendor/plugins/will_paginate/s… | 377 +++++++++++++++++++++++++++++++
A web/vendor/plugins/will_paginate/s… | 52 +++++++++++++++++++++++++++++++
A web/vendor/plugins/will_paginate/s… | 114 +++++++++++++++++++++++++++++++
A web/vendor/plugins/will_paginate/s… | 62 +++++++++++++++++++++++++++++++
A web/vendor/plugins/will_paginate/s… | 21 +++++++++++++++++++++
A web/vendor/plugins/will_paginate/s… | 53 ++++++++++++++++++++++++++++++
A web/vendor/plugins/will_paginate/s… | 9 +++++++++
A web/vendor/plugins/will_paginate/s… | 76 +++++++++++++++++++++++++++++++
A web/vendor/plugins/will_paginate/s… | 3 +++
A web/vendor/plugins/will_paginate/s… | 13 +++++++++++++
A web/vendor/plugins/will_paginate/s… | 14 ++++++++++++++
A web/vendor/plugins/will_paginate/s… | 13 +++++++++++++
A web/vendor/plugins/will_paginate/s… | 6 ++++++
A web/vendor/plugins/will_paginate/s… | 29 +++++++++++++++++++++++++++++
A web/vendor/plugins/will_paginate/s… | 7 +++++++
A web/vendor/plugins/will_paginate/s… | 38 +++++++++++++++++++++++++++++++
A web/vendor/plugins/will_paginate/s… | 7 +++++++
A web/vendor/plugins/will_paginate/s… | 30 ++++++++++++++++++++++++++++++
A web/vendor/plugins/will_paginate/s… | 2 ++
A web/vendor/plugins/will_paginate/s… | 35 +++++++++++++++++++++++++++++++
A web/vendor/plugins/will_paginate/s… | 3 +++
A web/vendor/plugins/will_paginate/s… | 2 ++
A web/vendor/plugins/will_paginate/s… | 76 +++++++++++++++++++++++++++++++
A web/vendor/plugins/will_paginate/s… | 60 +++++++++++++++++++++++++++++++
A web/vendor/plugins/will_paginate/s… | 356 +++++++++++++++++++++++++++++++
A web/vendor/plugins/will_paginate/s… | 64 +++++++++++++++++++++++++++++++
A web/vendor/plugins/will_paginate/s… | 84 +++++++++++++++++++++++++++++++
A web/vendor/plugins/will_paginate/s… | 103 +++++++++++++++++++++++++++++++
55 files changed, 3444 insertions(+), 0 deletions(-)
---
DIR diff --git a/web/vendor/plugins/will_paginate/CHANGELOG.rdoc b/web/vendor/plugins/will_paginate/CHANGELOG.rdoc
@@ -0,0 +1,105 @@
+== "agnostic" branch
+
+* added Sequel support
+* added an initialization hook for Merb
+* refactored URL generation
+* BACKWARDS INCOMPATIBLE: refactored LinkRenderer; also markup changes
+ <span class="current">1</span> is now <em>1</em>
+ a.prev_page -> a.previous_page (for consistency)
+* "prev_label" -> "previous_label"
+* ported view tests to specs
+* setup Autotest
+* added per_page=(limit) attribute writer to set default per_page
+* Remove :include option from count_all query when possible (Rails 2.1)
+* added WP::ViewHelpers::ActionView and LinkRenderer
+* specs for ViewHelpers::Base and LinkRendererBase
+* created LinkRendererBase that implements windowed visible page numbers logic
+* created WP::ViewHelpers::Base abstract module that implements generic view helpers
+* ported finder tests to specs
+* added WP::Finders::DataMapper
+* added WP::Finders::ActiveRecord mixin for ActiveRecord::Base
+* created WP::Finders::Base abstract module that implements generic pagination logic
+* removed dependency to ActiveSupport
+
+== 2.3.1, released 2008-05-04
+
+* Fixed page numbers not showing with custom routes and implicit first page
+* Try to use Hanna for documentation (falls back to default RDoc template if not)
+
+== 2.3.0, released 2008-04-29
+
+* Changed LinkRenderer to receive collection, options and reference to view template NOT in
+ constructor, but with the #prepare method. This is a step towards supporting passing of
+ LinkRenderer (or subclass) instances that may be preconfigured in some way
+* LinkRenderer now has #page_link and #page_span methods for easier customization of output in
+ subclasses
+* Changed page_entries_info() method to adjust its output according to humanized class name of
+ collection items. Override this with :entry_name parameter (singular).
+
+ page_entries_info(@posts)
+ #-> "Displaying all 12 posts"
+ page_entries_info(@posts, :entry_name => 'item')
+ #-> "Displaying all 12 items"
+
+== 2.2.3, released 2008-04-26
+
+* will_paginate gem is no longer published on RubyForge, but on
+ gems.github.com:
+
+ gem sources -a http://gems.github.com/ (you only need to do this once)
+ gem install mislav-will_paginate
+
+* extract reusable pagination testing stuff into WillPaginate::View
+* rethink the page URL construction mechanism to be more bulletproof when
+ combined with custom routing for page parameter
+* test that anchor parameter can be used in pagination links
+
+== 2.2.2, released 2008-04-21
+
+* Add support for page parameter in custom routes like "/foo/page/2"
+* Change output of "page_entries_info" on single-page collection and erroneous
+ output with empty collection as reported by Tim Chater
+
+== 2.2.1, released 2008-04-08
+
+* take less risky path when monkeypatching named_scope; fix that it no longer
+ requires ActiveRecord::VERSION
+* use strings in "respond_to?" calls to work around a bug in acts_as_ferret
+ stable (ugh)
+* add rake release task
+
+
+== 2.2.0, released 2008-04-07
+
+=== API changes
+* Rename WillPaginate::Collection#page_count to "total_pages" for consistency.
+ If you implemented this interface, change your implementation accordingly.
+* Remove old, deprecated style of calling Array#paginate as "paginate(page,
+ per_page)". If you want to specify :page, :per_page or :total_entries, use a
+ parameter hash.
+* Rename LinkRenderer#url_options to "url_for" and drastically optimize it
+
+=== View changes
+* Added "prev_page" and "next_page" CSS classes on previous/next page buttons
+* Add examples of pagination links styling in "examples/index.html"
+* Change gap in pagination links from "..." to
+ "<span class="gap">…</span>".
+* Add "paginated_section", a block helper that renders pagination both above and
+ below content in the block
+* Add rel="prev|next|start" to page links
+
+=== Other
+
+* Add ability to opt-in for Rails 2.1 feature "named_scope" by calling
+ WillPaginate.enable_named_scope (tested in Rails 1.2.6 and 2.0.2)
+* Support complex page parameters like "developers[page]"
+* Move Array#paginate definition to will_paginate/array.rb. You can now easily
+ use pagination on arrays outside of Rails:
+
+ gem 'will_paginate'
+ require 'will_paginate/array'
+
+* Add "paginated_each" method for iterating through every record by loading only
+ one page of records at the time
+* Rails 2: Rescue from WillPaginate::InvalidPage error with 404 Not Found by
+ default
DIR diff --git a/web/vendor/plugins/will_paginate/LICENSE b/web/vendor/plugins/will_paginate/LICENSE
@@ -0,0 +1,18 @@
+Copyright (c) 2009 Mislav Marohnić
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
DIR diff --git a/web/vendor/plugins/will_paginate/README.rdoc b/web/vendor/plugins/will_paginate/README.rdoc
@@ -0,0 +1,125 @@
+= The will_paginate Ruby library
+
+Pagination is just limiting the number of records loaded and displayed. Why should you let it get in
+your way while developing?
+
+This is how you paginate on an ActiveRecord model:
+
+ Post.paginate :page => 1, :order => 'created_at DESC'
+
+Most of the time it's as simple as replacing "find" with "paginate" and specifying the page you want.
+
+Some resources to get you started:
+
+* The {will_paginate project page}[http://mislav.github.com/will_paginate/];
+* Your mind reels with questions? Join our {Google group}[http://groups.google.com/group/will_paginate];
+* {How to report bugs}[http://github.com/mislav/will_paginate/wikis/report-bugs];
+* {Watch the will_paginate screencast}[http://railscasts.com/episodes/51] by Ryan Bates.
+
+== I'm not using Rails; can I still use will_paginate?
+
+Absolutely -- although will_paginate started off as a Rails plugin, now it is a <em>completely
+framework-agnostic</em> library with support for Rails and Merb built-in. The core library doesn't
+have any dependences and you can safely use it in any Ruby code.
+
+When will_paginate is loaded in an environment where ActiveRecord and ActionView are present, it
+automatically hooks into these frameworks to provide easy pagination on your models and in your
+views. The same mechanism works for Merb applications, too. But, if no known framework is present
+then you have absolute control over what parts of will_paginate do you want to load and where you want
+them mixed in.
+
+
+== Installation
+
+The recommended way is that you get the gem hosted on {gems.github.com}[http://gems.github.com/]:
+
+ gem install mislav-will_paginate
+
+In <b>Rails 2.1</b>, add a gem dependency:
+
+ # for Rails 2.1 and newer
+ config.gem 'mislav-will_paginate', :lib => 'will_paginate', :version => '~> 3.0'
+
+If you're using Rails 2.0 or older, or any other Ruby framework, just add a simple require to a file
+that initializes your application. For example, in Rails you would put this at the end of
+"config/environment.rb".
+
+ gem 'mislav-will_paginate', '~> 3.0'
+ require 'will_paginate'
+
+That's it. Remember to install the gem on <strong>all</strong> machines that you are deploying to.
+
+<i>There are extensive {installation
+instructions}[http://github.com/mislav/will_paginate/wikis/installation] on {the
+wiki}[http://github.com/mislav/will_paginate/wikis].</i>
+
+
+== Example usage
+
+Typical usage involves a paginating find in the controller:
+
+ @posts = Post.paginate :page => params[:page], :order => 'updated_at DESC'
+
+It's true: +paginate+ works just like +find+ -- it just doesn't fetch all the records. Don't forget
+to tell it which page you want, or it will complain! Read more in WillPaginate::Finders.
+
+Render the posts in your view like you would normally do, and when you need to render pagination,
+just stick this in:
+
+ <%= will_paginate @posts %>
+
+You're done. Read more in WillPaginate::ViewHelpers::Base.
+
+How does it know how much items to fetch per page? It asks your model by calling its
++per_page+ class method. You can define it like this:
+
+ class Post < ActiveRecord::Base
+ self.per_page = 50
+ end
+
+... or don't worry about it at all. WillPaginate defines it to be <strong>30</strong> by default. You can
+always specify the count explicitly when calling +paginate+:
+
+ Post.paginate :page => params[:page], :per_page => 50
+
+The +paginate+ finder wraps the original finder and returns your result set that now has some new
+properties. You can use the collection as you would use any other array. WillPaginate view helpers
+also need that collection object to be able to render pagination:
+
+ <ol>
+ <% for post in @posts -%>
+ <li>Render `post` in some nice way.</li>
+ <% end -%>
+ </ol>
+
+ <p>Now let's render us some pagination!</p>
+ <%= will_paginate @posts %>
+
+
+== Authors and credits
+
+The original author of will_paginate was PJ Hyett, who later handed over development to Mislav
+Marohnić. (The library was completely rewritten since then.)
+
+All these people helped making will_paginate what it is now with their code contributions or just
+simply awesome ideas:
+
+Chris Wanstrath, Dr. Nic Williams, K. Adam Christensen, Mike Garey, Bence Golda, Matt Aimonetti,
+Charles Brian Quinn, Desi McAdam, James Coglan, Matijs van Zuijlen, Maria, Brendan Ribera, Todd
+Willey, Bryan Helmkamp, Jan Berkel, Lourens Naudé, Rick Olson, Russell Norris, Piotr Usewicz, Chris
+Eppstein, Brandon Arbini, Denis Barushev, Paul Barry, Ben Pickles, Ken Collins, Lida Tang and Pieter
+Noordhuis.
+
+
+== Usable pagination in the UI
+
+There are example CSS styles to get you started on the will_paginate project page.
+
+More reading about pagination as design pattern:
+
+* {Pagination 101}[http://kurafire.net/log/archive/2007/06/22/pagination-101];
+* {Pagination gallery}[http://www.smashingmagazine.com/2007/11/16/pagination-gallery-examples-and-good-practices/] featured on Smashing Magazine;
+* {Pagination design pattern}[http://developer.yahoo.com/ypatterns/parent.php?pattern=pagination] on Yahoo Design Pattern Library.
+
+Want to discuss, request features, ask questions? Join the {Google
+group}[http://groups.google.com/group/will_paginate].
+\ No newline at end of file
DIR diff --git a/web/vendor/plugins/will_paginate/Rakefile b/web/vendor/plugins/will_paginate/Rakefile
@@ -0,0 +1,32 @@
+require 'rake/rdoctask'
+
+load 'spec/tasks.rake'
+
+desc 'Default: run specs.'
+task :default => :spec
+
+desc 'Generate RDoc documentation for the will_paginate plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+ rdoc.rdoc_files.include('README.rdoc', 'LICENSE', 'CHANGELOG.rdoc').
+ include('lib/**/*.rb').
+ exclude('lib/will_paginate/finders/active_record/named_scope*').
+ exclude('lib/will_paginate/finders/sequel.rb').
+ exclude('lib/will_paginate/view_helpers/merb.rb').
+ exclude('lib/will_paginate/deprecation.rb').
+ exclude('lib/will_paginate/core_ext.rb').
+ exclude('lib/will_paginate/version.rb')
+
+ rdoc.main = "README.rdoc" # page to start on
+ rdoc.title = "will_paginate documentation"
+
+ rdoc.rdoc_dir = 'doc' # rdoc output folder
+ rdoc.options << '--inline-source' << '--charset=UTF-8'
+ rdoc.options << '--webcvs=http://github.com/mislav/will_paginate/tree/master/'
+end
+
+task :website do
+ Dir.chdir('website') do
+ %x(haml index.haml index.html)
+ %x(sass pagination.sass pagination.css)
+ end
+end
DIR diff --git a/web/vendor/plugins/will_paginate/lib/will_paginate.rb b/web/vendor/plugins/will_paginate/lib/will_paginate.rb
@@ -0,0 +1,23 @@
+require 'will_paginate/deprecation'
+
+# = You *will* paginate!
+#
+# First read about WillPaginate::Finders::Base, then see
+# WillPaginate::ViewHelpers. The magical array you're handling in-between is
+# WillPaginate::Collection.
+#
+# Happy paginating!
+module WillPaginate
+end
+
+if defined?(::Rails::Railtie)
+ require 'will_paginate/railtie'
+end
+
+if defined?(::Merb::Plugins)
+ require 'will_paginate/view_helpers/merb'
+ # auto-load the right ORM adapter
+ if adapter = { :datamapper => 'data_mapper', :activerecord => 'active_record', :sequel => 'sequel' }[Merb.orm]
+ require "will_paginate/finders/#{adapter}"
+ end
+end
DIR diff --git a/web/vendor/plugins/will_paginate/lib/will_paginate/array.rb b/web/vendor/plugins/will_paginate/lib/will_paginate/array.rb
@@ -0,0 +1,33 @@
+require 'will_paginate/collection'
+
+class Array
+ # Paginates a static array (extracting a subset of it). The result is a
+ # WillPaginate::Collection instance, which is an array with a few more
+ # properties about its paginated state.
+ #
+ # Parameters:
+ # * <tt>:page</tt> - current page, defaults to 1
+ # * <tt>:per_page</tt> - limit of items per page, defaults to 30
+ # * <tt>:total_entries</tt> - total number of items in the array, defaults to
+ # <tt>array.length</tt> (obviously)
+ #
+ # Example:
+ # arr = ['a', 'b', 'c', 'd', 'e']
+ # paged = arr.paginate(:per_page => 2) #-> ['a', 'b']
+ # paged.total_entries #-> 5
+ # arr.paginate(:page => 2, :per_page => 2) #-> ['c', 'd']
+ # arr.paginate(:page => 3, :per_page => 2) #-> ['e']
+ #
+ # This method was originally {suggested by Desi
+ # McAdam}[http://www.desimcadam.com/archives/8] and later proved to be the
+ # most useful method of will_paginate library.
+ def paginate(options = {})
+ raise ArgumentError, "parameter hash expected (got #{options.inspect})" unless Hash === options
+
+ WillPaginate::Collection.create options[:page] || 1,
+ options[:per_page] || 30,
+ options[:total_entries] || self.length do |pager|
+ pager.replace self[pager.offset, pager.per_page].to_a
+ end
+ end
+end
DIR diff --git a/web/vendor/plugins/will_paginate/lib/will_paginate/collection.rb b/web/vendor/plugins/will_paginate/lib/will_paginate/collection.rb
@@ -0,0 +1,145 @@
+module WillPaginate
+ # = Invalid page number error
+ # This is an ArgumentError raised in case a page was requested that is either
+ # zero or negative number. You should decide how do deal with such errors in
+ # the controller.
+ #
+ # If you're using Rails 2, then this error will automatically get handled like
+ # 404 Not Found. The hook is in "will_paginate.rb":
+ #
+ # ActionController::Base.rescue_responses['WillPaginate::InvalidPage'] = :not_found
+ #
+ # If you don't like this, use your preffered method of rescuing exceptions in
+ # public from your controllers to handle this differently. The +rescue_from+
+ # method is a nice addition to Rails 2.
+ #
+ # This error is *not* raised when a page further than the last page is
+ # requested. Use <tt>WillPaginate::Collection#out_of_bounds?</tt> method to
+ # check for those cases and manually deal with them as you see fit.
+ class InvalidPage < ArgumentError
+ def initialize(page, page_num) #:nodoc:
+ super "#{page.inspect} given as value, which translates to '#{page_num}' as page number"
+ end
+ end
+
+ # = The key to pagination
+ # Arrays returned from paginating finds are, in fact, instances of this little
+ # class. You may think of WillPaginate::Collection as an ordinary array with
+ # some extra properties. Those properties are used by view helpers to generate
+ # correct page links.
+ #
+ # WillPaginate::Collection also assists in rolling out your own pagination
+ # solutions: see +create+.
+ #
+ # If you are writing a library that provides a collection which you would like
+ # to conform to this API, you don't have to copy these methods over; simply
+ # make your plugin/gem dependant on the "will_paginate" gem:
+ #
+ # gem 'will_paginate'
+ # require 'will_paginate/collection'
+ #
+ # # now use WillPaginate::Collection directly or subclass it
+ class Collection < Array
+ attr_reader :current_page, :per_page, :total_entries, :total_pages
+
+ # Arguments to the constructor are the current page number, per-page limit
+ # and the total number of entries. The last argument is optional because it
+ # is best to do lazy counting; in other words, count *conditionally* after
+ # populating the collection using the +replace+ method.
+ def initialize(page, per_page, total = nil)
+ @current_page = page.to_i
+ raise InvalidPage.new(page, @current_page) if @current_page < 1
+ @per_page = per_page.to_i
+ raise ArgumentError, "`per_page` setting cannot be less than 1 (#{@per_page} given)" if @per_page < 1
+
+ self.total_entries = total if total
+ end
+
+ # Just like +new+, but yields the object after instantiation and returns it
+ # afterwards. This is very useful for manual pagination:
+ #
+ # @entries = WillPaginate::Collection.create(1, 10) do |pager|
+ # result = Post.find(:all, :limit => pager.per_page, :offset => pager.offset)
+ # # inject the result array into the paginated collection:
+ # pager.replace(result)
+ #
+ # unless pager.total_entries
+ # # the pager didn't manage to guess the total count, do it manually
+ # pager.total_entries = Post.count
+ # end
+ # end
+ #
+ # The possibilities with this are endless. For another example, here is how
+ # WillPaginate used to define pagination for Array instances:
+ #
+ # Array.class_eval do
+ # def paginate(page = 1, per_page = 15)
+ # WillPaginate::Collection.create(page, per_page, size) do |pager|
+ # pager.replace self[pager.offset, pager.per_page].to_a
+ # end
+ # end
+ # end
+ #
+ # 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)
+ pager = new(page, per_page, total)
+ yield pager
+ pager
+ end
+
+ # Helper method that is true when someone tries to fetch a page with a
+ # larger number than the last page. Can be used in combination with flashes
+ # and redirecting.
+ def out_of_bounds?
+ current_page > total_pages
+ end
+
+ # Current offset of the paginated collection. If we're on the first page,
+ # it is always 0. If we're on the 2nd page and there are 30 entries per page,
+ # the offset is 30. This property is useful if you want to render ordinals
+ # besides your records: simply start with offset + 1.
+ def offset
+ (current_page - 1) * per_page
+ end
+
+ # current_page - 1 or nil if there is no previous page
+ def previous_page
+ current_page > 1 ? (current_page - 1) : nil
+ end
+
+ # current_page + 1 or nil if there is no next page
+ def next_page
+ current_page < total_pages ? (current_page + 1) : nil
+ end
+
+ def total_entries=(number)
+ @total_entries = number.to_i
+ @total_pages = (@total_entries / per_page.to_f).ceil
+ end
+
+ # This is a magic wrapper for the original Array#replace method. It serves
+ # for populating the paginated collection after initialization.
+ #
+ # Why magic? Because it tries to guess the total number of entries judging
+ # by the size of given array. If it is shorter than +per_page+ limit, then we
+ # know we're on the last page. This trick is very useful for avoiding
+ # unnecessary hits to the database to do the counting after we fetched the
+ # data for the current page.
+ #
+ # However, after using +replace+ you should always test the value of
+ # +total_entries+ and set it to a proper value if it's +nil+. See the example
+ # in +create+.
+ def replace(array)
+ result = super
+
+ # The collection is shorter then page limit? Rejoice, because
+ # then we know that we are on the last page!
+ if total_entries.nil? and length < per_page and (current_page == 1 or length > 0)
+ self.total_entries = offset + length
+ end
+
+ result
+ end
+ end
+end
DIR diff --git a/web/vendor/plugins/will_paginate/lib/will_paginate/core_ext.rb b/web/vendor/plugins/will_paginate/lib/will_paginate/core_ext.rb
@@ -0,0 +1,69 @@
+require 'set'
+require 'will_paginate/array'
+
+# helper to check for method existance in ruby 1.8- and 1.9-compatible way
+# because `methods`, `instance_methods` and others return strings in 1.8 and symbols in 1.9
+#
+# ['foo', 'bar'].include_method?(:foo) # => true
+class Array
+ def include_method?(name)
+ name = name.to_sym
+ !!(find { |item| item.to_sym == name })
+ end
+end
+
+## everything below copied from ActiveSupport so we don't depend on it ##
+
+unless Hash.instance_methods.include_method? :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_method? :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_method? :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_method? :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
DIR diff --git a/web/vendor/plugins/will_paginate/lib/will_paginate/deprecation.rb b/web/vendor/plugins/will_paginate/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)
+ 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
DIR diff --git a/web/vendor/plugins/will_paginate/lib/will_paginate/finders.rb b/web/vendor/plugins/will_paginate/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
DIR diff --git a/web/vendor/plugins/will_paginate/lib/will_paginate/finders/active_record.rb b/web/vendor/plugins/will_paginate/lib/will_paginate/finders/active_record.rb
@@ -0,0 +1,158 @@
+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
+
+ # In Rails, this is automatically called to mix-in pagination functionality to ActiveRecord.
+ def self.enable!
+ ::ActiveRecord::Base.class_eval do
+ extend ActiveRecord
+ end
+
+ # support pagination on associations and scopes
+ [::ActiveRecord::Relation, ::ActiveRecord::Associations::AssociationCollection].each do |klass|
+ klass.send(:include, ActiveRecord)
+ end
+ 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
+ query << " LIMIT #{pager.per_page} OFFSET #{pager.offset}"
+ # 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
+
+ protected
+
+ 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]
+
+ # Use :select from scope if it isn't already present.
+ # FIXME: this triggers extra queries when going through associations
+ # if options[:select].blank? && current_scoped_methods && current_scoped_methods.select_values.present?
+ # options[:select] = current_scoped_methods.select_values.join(", ")
+ # end
+
+ 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 when counting
+ if count_options[:include] and count_options[:conditions].blank? and count_options[:group].blank?
+ count_options.delete :include
+ end
+
+ count_options
+ end
+ end
+end
DIR diff --git a/web/vendor/plugins/will_paginate/lib/will_paginate/finders/active_resource.rb b/web/vendor/plugins/will_paginate/lib/will_paginate/finders/active_resource.rb
@@ -0,0 +1,51 @@
+require 'will_paginate/finders/base'
+require 'active_resource'
+
+module WillPaginate::Finders
+ # Paginate your ActiveResource models.
+ #
+ # @posts = Post.paginate :all, :params => {
+ # :page => params[:page], :order => 'created_at DESC'
+ # }
+ #
+ module ActiveResource
+ include WillPaginate::Finders::Base
+
+ protected
+
+ def wp_query(options, pager, args, &block) #:nodoc:
+ unless args.empty? or args.first == :all
+ raise ArgumentError, "finder arguments other than :all are not supported for pagination (#{args.inspect} given)"
+ end
+ params = (options[:params] ||= {})
+ params[:page] = pager.current_page
+ params[:per_page] = pager.per_page
+
+ pager.replace find_every(options, &block)
+ end
+
+ # Takes the format that Hash.from_xml produces out of an unknown type
+ # (produced by WillPaginate::Collection#to_xml_with_collection_type),
+ # parses it into a WillPaginate::Collection,
+ # and forwards the result to the former +instantiate_collection+ method.
+ # It only does this for hashes that have a :type => "collection".
+ def instantiate_collection_with_collection(collection, prefix_options = {}) #:nodoc:
+ if collection.is_a?(Hash) && collection["type"] == "collection"
+ collectables = collection.values.find{ |c| c.is_a?(Hash) || c.is_a?(Array) }
+ collectables = [collectables].compact unless collectables.kind_of?(Array)
+ instantiated_collection = WillPaginate::Collection.create(collection["current_page"], collection["per_page"], collection["total_entries"]) do |pager|
+ pager.replace instantiate_collection_without_collection(collectables, prefix_options)
+ end
+ else
+ instantiate_collection_without_collection(collection, prefix_options)
+ end
+ end
+ end
+end
+
+ActiveResource::Base.class_eval do
+ extend WillPaginate::Finders::ActiveResource
+ class << self
+ # alias_method_chain :instantiate_collection, :collection
+ end
+end
+\ No newline at end of file
DIR diff --git a/web/vendor/plugins/will_paginate/lib/will_paginate/finders/base.rb b/web/vendor/plugins/will_paginate/lib/will_paginate/finders/base.rb
@@ -0,0 +1,112 @@
+require 'will_paginate/core_ext'
+
+module WillPaginate
+ module Finders
+ # = Database-agnostic finder module
+ #
+ # Out of the box, will_paginate supports hooking in several ORMs to
+ # provide paginating finders based on their API. As of this writing, the
+ # supported libraries are:
+ #
+ # * ActiveRecord
+ # * DataMapper
+ # * Sequel
+ #
+ # It's easy to write your own adapter for anything that can load data with
+ # explicit limit and offset settings. DataMapper adapter is a nice and
+ # compact example of writing an adapter to bring the +paginate+ method to
+ # DataMapper models.
+ #
+ # == The importance of SQL's <tt>ORDER BY</tt>
+ #
+ # In most ORMs, <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 order clause,
+ # databases aren't required to do consistent ordering when performing
+ # <tt>SELECT</tt> queries.
+ #
+ # Ordering by a field for which many records share the same value (e.g.
+ # "status") can still result in incorrect ordering with some databases (MS
+ # SQL and Postgres for instance). With these databases it's recommend that
+ # you order by primary key as well. That is, instead of ordering by
+ # "status DESC", use the alternative "status DESC, id DESC" and this will
+ # yield consistent results.
+ #
+ # 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 Base
+ def per_page
+ @per_page ||= 30
+ end
+
+ def per_page=(limit)
+ @per_page = limit.to_i
+ end
+
+ # 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 finder method to use (default: "find")
+ #
+ # All other options (+conditions+, +order+, ...) are forwarded to +find+
+ # and +count+ calls.
+ def paginate(*args, &block)
+ options = args.pop
+ page, per_page, total_entries = wp_parse_options(options)
+
+ WillPaginate::Collection.create(page, per_page, total_entries) do |pager|
+ query_options = options.except :page, :per_page, :total_entries
+ wp_query(query_options, pager, args, &block)
+ 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.
+ #
+ # {Jamis Buck describes this}[http://weblog.jamisbuck.org/2007/4/6/faking-cursors-in-activerecord]
+ # and also uses a more efficient way for MySQL.
+ def paginated_each(options = {}, &block)
+ options = { :order => 'id', :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)
+ total += collection.each(&block).size
+ options[:page] += 1
+ end until collection.size < collection.per_page
+
+ total
+ end
+
+ protected
+
+ def wp_parse_options(options) #:nodoc:
+ raise ArgumentError, 'parameter hash expected' unless Hash === options
+ 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]
+
+ return [page, per_page, total]
+ end
+
+ end
+ end
+end
DIR diff --git a/web/vendor/plugins/will_paginate/lib/will_paginate/finders/data_mapper.rb b/web/vendor/plugins/will_paginate/lib/will_paginate/finders/data_mapper.rb
@@ -0,0 +1,30 @@
+require 'will_paginate/finders/base'
+require 'dm-core'
+
+module WillPaginate::Finders
+ module DataMapper
+ include WillPaginate::Finders::Base
+
+ protected
+
+ def wp_query(options, pager, args, &block) #:nodoc
+ find_options = options.except(:count).update(:offset => pager.offset, :limit => pager.per_page)
+
+ pager.replace all(find_options, &block)
+
+ unless pager.total_entries
+ pager.total_entries = wp_count(options)
+ end
+ end
+
+ def wp_count(options) #:nodoc
+ count_options = options.except(:count, :order)
+ # merge the hash found in :count
+ count_options.update options[:count] if options[:count]
+
+ count_options.empty?? count() : count(count_options)
+ end
+ end
+end
+
+DataMapper::Model.send(:include, WillPaginate::Finders::DataMapper)
DIR diff --git a/web/vendor/plugins/will_paginate/lib/will_paginate/finders/sequel.rb b/web/vendor/plugins/will_paginate/lib/will_paginate/finders/sequel.rb
@@ -0,0 +1,23 @@
+require 'will_paginate/core_ext'
+require 'sequel'
+require 'sequel/extensions/pagination'
+
+existing_methods = Sequel::Dataset::Pagination.instance_methods
+
+Sequel::Dataset::Pagination.module_eval do
+ # it should quack like a WillPaginate::Collection
+
+ alias :total_pages :page_count unless existing_methods.include_method? :total_pages
+ alias :per_page :page_size unless existing_methods.include_method? :per_page
+ alias :previous_page :prev_page unless existing_methods.include_method? :previous_page
+ alias :total_entries :pagination_record_count unless existing_methods.include_method? :total_entries
+
+ def out_of_bounds?
+ current_page > total_pages
+ end
+
+ # Current offset of the paginated collection
+ def offset
+ (current_page - 1) * per_page
+ end
+end
+\ No newline at end of file
DIR diff --git a/web/vendor/plugins/will_paginate/lib/will_paginate/railtie.rb b/web/vendor/plugins/will_paginate/lib/will_paginate/railtie.rb
@@ -0,0 +1,24 @@
+require 'will_paginate'
+require 'will_paginate/collection'
+
+module WillPaginate
+ class Railtie < Rails::Railtie
+ initializer "will_paginate.active_record" do |app|
+ if defined? ::ActiveRecord
+ require 'will_paginate/finders/active_record'
+ WillPaginate::Finders::ActiveRecord.enable!
+ end
+ end
+
+ initializer "will_paginate.action_dispatch" do |app|
+ if defined? ::ActionDispatch::ShowExceptions
+ ActionDispatch::ShowExceptions.rescue_responses['WillPaginate::InvalidPage'] = :not_found
+ end
+ end
+
+ initializer "will_paginate.action_view" do |app|
+ require 'will_paginate/view_helpers/action_view'
+ ActionView::Base.send(:include, WillPaginate::ViewHelpers::ActionView)
+ end
+ end
+end
DIR diff --git a/web/vendor/plugins/will_paginate/lib/will_paginate/version.rb b/web/vendor/plugins/will_paginate/lib/will_paginate/version.rb
@@ -0,0 +1,9 @@
+module WillPaginate #:nodoc:
+ module VERSION #:nodoc:
+ MAJOR = 3
+ MINOR = 0
+ TINY = 'pre2'
+
+ STRING = [MAJOR, MINOR, TINY].join('.')
+ end
+end
DIR diff --git a/web/vendor/plugins/will_paginate/lib/will_paginate/view_helpers.rb b/web/vendor/plugins/will_paginate/lib/will_paginate/view_helpers.rb
@@ -0,0 +1,42 @@
+require 'will_paginate/deprecation'
+
+module WillPaginate
+ # = Will Paginate view helpers
+ #
+ # The main view helper is +will_paginate+. It renders the 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.
+ #
+ # Read more in WillPaginate::ViewHelpers::Base
+ module ViewHelpers
+ # ==== 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[:previous_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.
+ def self.pagination_options() @pagination_options; end
+ # Overrides the default +pagination_options+
+ def self.pagination_options=(value) @pagination_options = value; end
+
+ self.pagination_options = {
+ :class => 'pagination',
+ :previous_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::ViewHelpers::LinkRenderer',
+ :page_links => true,
+ :container => true
+ }
+ end
+end
DIR diff --git a/web/vendor/plugins/will_paginate/lib/will_paginate/view_helpers/action_view.rb b/web/vendor/plugins/will_paginate/lib/will_paginate/view_helpers/action_view.rb
@@ -0,0 +1,134 @@
+require 'will_paginate/view_helpers/base'
+require 'action_view'
+require 'action_pack/version'
+require 'will_paginate/view_helpers/link_renderer'
+
+module WillPaginate
+ module ViewHelpers
+ # = ActionView helpers
+ #
+ # This module serves for availability in ActionView templates. It also adds a new
+ # view helper: +paginated_section+.
+ #
+ # == 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>
+ #
+ module ActionView
+ include WillPaginate::ViewHelpers::Base
+
+ def will_paginate(collection = nil, options = {}) #:nodoc:
+ options, collection = collection, nil if collection.is_a? Hash
+ collection ||= infer_collection_from_controller
+
+ super(collection, options.symbolize_keys).try(:html_safe)
+ end
+
+ def page_entries_info(collection = nil, options = {}) #:nodoc:
+ options, collection = collection, nil if collection.is_a? Hash
+ collection ||= infer_collection_from_controller
+
+ super(collection, options.symbolize_keys).try(:html_safe)
+ 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
+ pagination + capture(&block) + pagination
+ end
+
+ protected
+
+ def infer_collection_from_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?" if collection.nil?
+ collection
+ end
+ end
+ end
+end
+
+# :stopdoc:
+
+WillPaginate::ViewHelpers::LinkRenderer.class_eval do
+ protected
+
+ def default_url_params
+ { :escape => false }
+ end
+
+ def url(page)
+ @base_url_params ||= begin
+ url_params = base_url_params
+ merge_optional_params(url_params)
+ url_params
+ end
+
+ url_params = @base_url_params.dup
+ add_current_page_param(url_params, page)
+
+ @template.url_for(url_params)
+ end
+
+ def base_url_params
+ url_params = default_url_params
+ # page links should preserve GET parameters
+ symbolized_update(url_params, @template.params) if get_request?
+ url_params
+ end
+
+ def merge_optional_params(url_params)
+ symbolized_update(url_params, @options[:params]) if @options[:params]
+ end
+
+ def add_current_page_param(url_params, page)
+ unless param_name.index(/[^\w-]/)
+ url_params[param_name.to_sym] = page
+ else
+ page_param = parse_query_parameters("#{param_name}=#{page}")
+ symbolized_update(url_params, page_param)
+ end
+ end
+
+ def get_request?
+ @template.request.get?
+ end
+
+ private
+
+ def parse_query_parameters(params)
+ Rack::Utils.parse_nested_query(params)
+ end
+end
+\ No newline at end of file
DIR diff --git a/web/vendor/plugins/will_paginate/lib/will_paginate/view_helpers/base.rb b/web/vendor/plugins/will_paginate/lib/will_paginate/view_helpers/base.rb
@@ -0,0 +1,126 @@
+require 'will_paginate/core_ext'
+require 'will_paginate/view_helpers'
+
+module WillPaginate
+ module ViewHelpers
+ # = The main view helpers module
+ #
+ # This is the base module which provides the +will_paginate+ view helper.
+ module Base
+ # Renders Digg/Flickr-style pagination for a WillPaginate::Collection object. Nil is
+ # returned if there is only one page in total; pagination links aren't needed in that case.
+ #
+ # ==== Options
+ # * <tt>:class</tt> -- CSS class name for the generated DIV (default: "pagination")
+ # * <tt>:previous_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, class or instance of a link renderer (default:
+ # <tt>WillPaginate::LinkRenderer</tt>)
+ # * <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>
+ #
+ def will_paginate(collection, options = {})
+ # early exit if there is nothing to render
+ return nil unless collection.total_pages > 1
+
+ options = WillPaginate::ViewHelpers.pagination_options.merge(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].constantize.new
+ when Class
+ options[:renderer].new
+ else
+ options[:renderer]
+ end
+ # render HTML for pagination
+ renderer.prepare collection, options, self
+ renderer.to_html
+ 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 to your liking with the <tt>:entry_name</tt> parameter:
+ #
+ # <%= page_entries_info @posts, :entry_name => 'item' %>
+ # #-> Displaying items 6 - 10 of 26 in total
+ #
+ # Entry name is entered in singular and pluralized with
+ # <tt>String#pluralize</tt> method from ActiveSupport. If it isn't
+ # loaded, specify plural with <tt>:plural_name</tt> parameter:
+ #
+ # <%= page_entries_info @posts, :entry_name => 'item', :plural_name => 'items' %>
+ #
+ # By default, this method produces HTML output. You can trigger plain
+ # text output by passing <tt>:html => false</tt> in options.
+ def page_entries_info(collection, options = {})
+ entry_name = options[:entry_name] || (collection.empty?? 'entry' :
+ collection.first.class.name.underscore.gsub('_', ' '))
+
+ plural_name = if options[:plural_name]
+ options[:plural_name]
+ elsif entry_name == 'entry'
+ plural_name = 'entries'
+ elsif entry_name.respond_to? :pluralize
+ plural_name = entry_name.pluralize
+ else
+ entry_name + 's'
+ end
+
+ unless options[:html] == false
+ b = '<b>'
+ eb = '</b>'
+ sp = ' '
+ else
+ b = eb = ''
+ sp = ' '
+ end
+
+ if collection.total_pages < 2
+ case collection.size
+ when 0; "No #{plural_name} found"
+ when 1; "Displaying #{b}1#{eb} #{entry_name}"
+ else; "Displaying #{b}all #{collection.size}#{eb} #{plural_name}"
+ end
+ else
+ %{Displaying #{plural_name} #{b}%d#{sp}-#{sp}%d#{eb} of #{b}%d#{eb} in total} % [
+ collection.offset + 1,
+ collection.offset + collection.length,
+ collection.total_entries
+ ]
+ end
+ end
+ end
+ end
+end
DIR diff --git a/web/vendor/plugins/will_paginate/lib/will_paginate/view_helpers/link_renderer.rb b/web/vendor/plugins/will_paginate/lib/will_paginate/view_helpers/link_renderer.rb
@@ -0,0 +1,130 @@
+require 'cgi'
+require 'will_paginate/core_ext'
+require 'will_paginate/view_helpers/link_renderer_base'
+
+module WillPaginate
+ module ViewHelpers
+ # This class does the heavy lifting of actually building the pagination
+ # links. It is used by +will_paginate+ helper internally.
+ class LinkRenderer < LinkRendererBase
+
+ # * +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)
+ super(collection, options)
+ @template = template
+ @container_attributes = @base_url_params = 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
+ html = pagination.map do |item|
+ item.is_a?(Fixnum) ?
+ page_number(item) :
+ send(item)
+ end.join(@options[:separator])
+
+ @options[:container] ? html_container(html) : html
+ end
+
+ # Returns the subset of +options+ this instance was initialized with that
+ # represent HTML attributes for the container element of pagination links.
+ def container_attributes
+ @container_attributes ||= begin
+ 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
+ attributes[:id] = @collection.first.class.name.underscore.pluralize + '_pagination'
+ end
+ attributes
+ end
+ end
+
+ protected
+
+ def page_number(page)
+ unless page == current_page
+ link(page, page, :rel => rel_value(page))
+ else
+ tag(:em, page)
+ end
+ end
+
+ def gap
+ '<span class="gap">…</span>'
+ end
+
+ def previous_page
+ previous_or_next_page(@collection.previous_page, @options[:previous_label], 'previous_page')
+ end
+
+ def next_page
+ previous_or_next_page(@collection.next_page, @options[:next_label], 'next_page')
+ end
+
+ def previous_or_next_page(page, text, classname)
+ if page
+ link(text, page, :class => classname)
+ else
+ tag(:span, text, :class => classname + ' disabled')
+ end
+ end
+
+ def html_container(html)
+ tag(:div, html, container_attributes)
+ end
+
+ # Returns URL params for +page_link_or_span+, taking the current GET params
+ # and <tt>:params</tt> option into account.
+ def url(page)
+ raise NotImplementedError
+ end
+
+ private
+
+ def link(text, target, attributes = {})
+ if target.is_a? Fixnum
+ attributes[:rel] = rel_value(target)
+ target = url(target)
+ end
+ attributes[:href] = target
+ tag(:a, text, attributes)
+ end
+
+ def tag(name, value, attributes = {})
+ string_attributes = attributes.inject('') do |attrs, pair|
+ unless pair.last.nil?
+ attrs << %( #{pair.first}="#{CGI::escapeHTML(pair.last.to_s)}")
+ end
+ attrs
+ end
+ "<#{name}#{string_attributes}>#{value}</#{name}>"
+ end
+
+ 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 symbolized_update(target, other)
+ other.each do |key, value|
+ key = key.to_sym
+ existing = target[key]
+
+ if value.is_a?(Hash) and (existing.is_a?(Hash) or existing.nil?)
+ symbolized_update(existing || (target[key] = {}), value)
+ else
+ target[key] = value
+ end
+ end
+ end
+ end
+ end
+end
DIR diff --git a/web/vendor/plugins/will_paginate/lib/will_paginate/view_helpers/link_renderer_base.rb b/web/vendor/plugins/will_paginate/lib/will_paginate/view_helpers/link_renderer_base.rb
@@ -0,0 +1,83 @@
+require 'will_paginate/view_helpers'
+
+module WillPaginate
+ module ViewHelpers
+ # This class does the heavy lifting of actually building the pagination
+ # links. It is used by +will_paginate+ helper internally.
+ class LinkRendererBase
+
+ # * +collection+ is a WillPaginate::Collection instance or any other object
+ # that conforms to that API
+ # * +options+ are forwarded from +will_paginate+ view helper
+ def prepare(collection, options)
+ @collection = collection
+ @options = options
+
+ # reset values in case we're re-using this instance
+ @total_pages = @param_name = nil
+ end
+
+ def pagination
+ items = @options[:page_links] ? windowed_page_numbers : []
+ items.unshift :previous_page
+ items.push :next_page
+ end
+
+ protected
+
+ # Calculates visible page numbers using the <tt>:inner_window</tt> and
+ # <tt>:outer_window</tt> options.
+ def windowed_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
+
+ # these are always visible
+ middle = window_from..window_to
+
+ # left window
+ if outer_window + 3 < middle.first # there's a gap
+ left = (1..(outer_window + 1)).to_a
+ left << :gap
+ else # runs into visible pages
+ left = 1...middle.first
+ end
+
+ # right window
+ if total_pages - outer_window - 2 > middle.last # again, gap
+ right = ((total_pages - outer_window)..total_pages).to_a
+ right.unshift :gap
+ else # runs into visible pages
+ right = (middle.last + 1)..total_pages
+ end
+
+ left.to_a + middle.to_a + right.to_a
+ end
+
+ private
+
+ def current_page
+ @collection.current_page
+ end
+
+ def total_pages
+ @collection.total_pages
+ end
+
+ def param_name
+ @param_name ||= @options[:param_name].to_s
+ end
+ end
+ end
+end
DIR diff --git a/web/vendor/plugins/will_paginate/lib/will_paginate/view_helpers/merb.rb b/web/vendor/plugins/will_paginate/lib/will_paginate/view_helpers/merb.rb
@@ -0,0 +1,13 @@
+require 'will_paginate/view_helpers/base'
+require 'will_paginate/view_helpers/link_renderer'
+
+WillPaginate::ViewHelpers::LinkRenderer.class_eval do
+ protected
+
+ def url(page)
+ params = @template.request.params.except(:action, :controller).merge(param_name => page)
+ @template.url(:this, params)
+ end
+end
+
+Merb::AbstractController.send(:include, WillPaginate::ViewHelpers::Base)
+\ No newline at end of file
DIR diff --git a/web/vendor/plugins/will_paginate/spec/collection_spec.rb b/web/vendor/plugins/will_paginate/spec/collection_spec.rb
@@ -0,0 +1,147 @@
+require 'will_paginate/array'
+require 'spec_helper'
+
+describe WillPaginate::Collection do
+
+ before :all do
+ @simple = ('a'..'e').to_a
+ end
+
+ it "should be a subset of original collection" do
+ @simple.paginate(:page => 1, :per_page => 3).should == %w( a b c )
+ end
+
+ it "can be shorter than per_page if on last page" do
+ @simple.paginate(:page => 2, :per_page => 3).should == %w( d e )
+ end
+
+ it "should include whole collection if per_page permits" do
+ @simple.paginate(:page => 1, :per_page => 5).should == @simple
+ end
+
+ it "should be empty if out of bounds" do
+ @simple.paginate(:page => 2, :per_page => 5).should be_empty
+ end
+
+ it "should default to 1 as current page and 30 per-page" do
+ result = (1..50).to_a.paginate
+ result.current_page.should == 1
+ result.size.should == 30
+ end
+
+ describe "old API" do
+ it "should fail with numeric params" do
+ Proc.new { [].paginate(2) }.should raise_error(ArgumentError)
+ Proc.new { [].paginate(2, 10) }.should raise_error(ArgumentError)
+ end
+
+ it "should fail with both options and numeric param" do
+ Proc.new { [].paginate({}, 5) }.should raise_error(ArgumentError)
+ end
+ end
+
+ it "should give total_entries precedence over actual size" do
+ %w(a b c).paginate(:total_entries => 5).total_entries.should == 5
+ end
+
+ it "should be an augmented Array" do
+ entries = %w(a b c)
+ collection = create(2, 3, 10) do |pager|
+ pager.replace(entries).should == entries
+ end
+
+ collection.should == entries
+ for method in %w(total_pages each offset size current_page per_page total_entries)
+ collection.should respond_to(method)
+ end
+ collection.should be_kind_of(Array)
+ collection.entries.should be_instance_of(Array)
+ # TODO: move to another expectation:
+ collection.offset.should == 3
+ collection.total_pages.should == 4
+ collection.should_not be_out_of_bounds
+ end
+
+ describe "previous/next pages" do
+ it "should have previous_page nil when on first page" do
+ collection = create(1, 1, 3)
+ collection.previous_page.should be_nil
+ collection.next_page.should == 2
+ end
+
+ it "should have both prev/next pages" do
+ collection = create(2, 1, 3)
+ collection.previous_page.should == 1
+ collection.next_page.should == 3
+ end
+
+ it "should have next_page nil when on last page" do
+ collection = create(3, 1, 3)
+ collection.previous_page.should == 2
+ collection.next_page.should be_nil
+ end
+ end
+
+ it "should show out of bounds when page number is too high" do
+ create(2, 3, 2).should be_out_of_bounds
+ end
+
+ it "should not show out of bounds when inside collection" do
+ create(1, 3, 2).should_not be_out_of_bounds
+ end
+
+ describe "guessing total count" do
+ it "can guess when collection is shorter than limit" do
+ collection = create { |p| p.replace array }
+ collection.total_entries.should == 8
+ end
+
+ it "should allow explicit total count to override guessed" do
+ collection = create(2, 5, 10) { |p| p.replace array }
+ collection.total_entries.should == 10
+ end
+
+ it "should not be able to guess when collection is same as limit" do
+ collection = create { |p| p.replace array(5) }
+ collection.total_entries.should be_nil
+ end
+
+ it "should not be able to guess when collection is empty" do
+ collection = create { |p| p.replace array(0) }
+ collection.total_entries.should be_nil
+ end
+
+ it "should be able to guess when collection is empty and this is the first page" do
+ collection = create(1) { |p| p.replace array(0) }
+ collection.total_entries.should == 0
+ end
+ end
+
+ it "should raise WillPaginate::InvalidPage on invalid input" do
+ for bad_input in [0, -1, nil, '', 'Schnitzel']
+ Proc.new { create bad_input }.should raise_error(WillPaginate::InvalidPage)
+ end
+ end
+
+ it "should raise Argument error on invalid per_page setting" do
+ Proc.new { create(1, -1) }.should raise_error(ArgumentError)
+ end
+
+ it "should not respond to page_count anymore" do
+ Proc.new { create.page_count }.should raise_error(NoMethodError)
+ 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
+end
DIR diff --git a/web/vendor/plugins/will_paginate/spec/console b/web/vendor/plugins/will_paginate/spec/console
@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+libs = []
+
+libs << 'irb/completion'
+libs << 'console_fixtures'
+
+exec "#{irb} -Ilib:spec#{libs.map{ |l| " -r #{l}" }.join} --simple-prompt"
DIR diff --git a/web/vendor/plugins/will_paginate/spec/console_fixtures.rb b/web/vendor/plugins/will_paginate/spec/console_fixtures.rb
@@ -0,0 +1,8 @@
+require 'will_paginate/finders/active_record'
+require 'finders/activerecord_test_connector'
+ActiverecordTestConnector.setup
+
+# load all fixtures
+Fixtures.create_fixtures(ActiverecordTestConnector::FIXTURES_PATH, ActiveRecord::Base.connection.tables)
+
+ActiverecordTestConnector.show_sql
+\ No newline at end of file
DIR diff --git a/web/vendor/plugins/will_paginate/spec/database.yml b/web/vendor/plugins/will_paginate/spec/database.yml
@@ -0,0 +1,22 @@
+sqlite3:
+ database: ":memory:"
+ adapter: sqlite3
+ timeout: 500
+
+sqlite2:
+ database: ":memory:"
+ adapter: sqlite2
+
+mysql:
+ adapter: mysql
+ username: rails
+ password: mislav
+ encoding: utf8
+ database: will_paginate_unittest
+
+postgres:
+ adapter: postgresql
+ username: mislav
+ password: mislav
+ database: will_paginate_unittest
+ min_messages: warning
DIR diff --git a/web/vendor/plugins/will_paginate/spec/finders/active_record_spec.rb b/web/vendor/plugins/will_paginate/spec/finders/active_record_spec.rb
@@ -0,0 +1,377 @@
+require 'spec_helper'
+require 'will_paginate/finders/active_record'
+require File.expand_path('../activerecord_test_connector', __FILE__)
+ActiverecordTestConnector.setup
+
+WillPaginate::Finders::ActiveRecord.enable!
+
+describe WillPaginate::Finders::ActiveRecord do
+
+ extend ActiverecordTestConnector::FixtureSetup
+
+ fixtures :topics, :replies, :users, :projects, :developers_projects
+
+ it "should integrate with ActiveRecord::Base" do
+ ActiveRecord::Base.should respond_to(:paginate)
+ end
+
+ it "should paginate" do
+ lambda {
+ users = User.paginate(:page => 1, :per_page => 5)
+ users.length.should == 5
+ }.should run_queries(2)
+ end
+
+ it "should fail when encountering unknown params" do
+ lambda {
+ User.paginate :foo => 'bar', :page => 1, :per_page => 4
+ }.should raise_error(ArgumentError)
+ end
+
+ describe "counting" do
+ it "should not accept :count parameter" do
+ pending
+ lambda {
+ User.paginate :page => 1, :count => {}
+ }.should raise_error(ArgumentError)
+ end
+
+ it "should guess the total count" do
+ lambda {
+ topics = Topic.paginate :page => 2, :per_page => 3
+ topics.total_entries.should == 4
+ }.should run_queries(1)
+ end
+
+ it "should guess that there are no records" do
+ lambda {
+ topics = Topic.where(:project_id => 999).paginate :page => 1, :per_page => 3
+ topics.total_entries.should == 0
+ }.should run_queries(1)
+ end
+ end
+
+ it "should not ignore :select parameter when it says DISTINCT" do
+ users = User.select('DISTINCT salary').paginate :page => 2
+ users.total_entries.should == 5
+ end
+
+ it "should count with scoped select when :select => DISTINCT" do
+ pending
+ Topic.distinct.paginate :page => 2
+ end
+
+ describe "paginate_by_sql" do
+ it "should respond" do
+ User.should respond_to(:paginate_by_sql)
+ end
+
+ it "should paginate" do
+ lambda {
+ sql = "select content from topics where content like '%futurama%'"
+ topics = Topic.paginate_by_sql sql, :page => 1, :per_page => 1
+ topics.total_entries.should == 1
+ topics.first['title'].should be_nil
+ }.should run_queries(2)
+ end
+
+ it "should respect total_entries setting" do
+ lambda {
+ sql = "select content from topics"
+ topics = Topic.paginate_by_sql sql, :page => 1, :per_page => 1, :total_entries => 999
+ topics.total_entries.should == 999
+ }.should run_queries(1)
+ end
+
+ it "should strip the order when counting" do
+ lambda {
+ sql = "select id, title, content from topics order by title"
+ topics = Topic.paginate_by_sql sql, :page => 1, :per_page => 2
+ topics.first.should == topics(:ar)
+ }.should run_queries(2)
+ end
+
+ it "shouldn't change the original query string" do
+ query = 'select * from topics where 1 = 2'
+ original_query = query.dup
+ Topic.paginate_by_sql(query, :page => 1)
+ query.should == original_query
+ end
+ end
+
+ it "doesn't mangle options" do
+ options = { :page => 1 }
+ options.expects(:delete).never
+ options_before = options.dup
+
+ Topic.paginate(options)
+ options.should == options_before
+ end
+
+ it "should get first page of Topics with a single query" do
+ lambda {
+ result = Topic.paginate :page => nil
+ result.current_page.should == 1
+ result.total_pages.should == 1
+ result.size.should == 4
+ }.should run_queries(1)
+ end
+
+ it "should get second (inexistent) page of Topics, requiring 2 queries" do
+ lambda {
+ result = Topic.paginate :page => 2
+ result.total_pages.should == 1
+ result.should be_empty
+ }.should run_queries(2)
+ end
+
+ it "should paginate with :order" do
+ result = Topic.paginate :page => 1, :order => 'created_at DESC'
+ result.should == topics(:futurama, :harvey_birdman, :rails, :ar).reverse
+ result.total_pages.should == 1
+ end
+
+ it "should paginate with :conditions" do
+ result = Topic.paginate :page => 1, :conditions => ["created_at > ?", 30.minutes.ago]
+ result.should == topics(:rails, :ar)
+ result.total_pages.should == 1
+ end
+
+ it "should paginate with :include and :conditions" do
+ result = Topic.paginate \
+ :page => 1,
+ :include => :replies,
+ :conditions => "replies.content LIKE 'Bird%' ",
+ :per_page => 10
+
+ expected = Topic.find :all,
+ :include => 'replies',
+ :conditions => "replies.content LIKE 'Bird%' ",
+ :limit => 10
+
+ result.should == expected
+ result.total_entries.should == 1
+ end
+
+ it "should paginate with :include and :order" do
+ result = nil
+ lambda {
+ result = Topic.paginate \
+ :page => 1,
+ :include => :replies,
+ :order => 'replies.created_at asc, topics.created_at asc',
+ :per_page => 10
+ }.should run_queries(2)
+
+ expected = Topic.find :all,
+ :include => 'replies',
+ :order => 'replies.created_at asc, topics.created_at asc',
+ :limit => 10
+
+ result.should == expected
+ result.total_entries.should == 4
+ end
+
+ it "should remove :include for count" do
+ lambda {
+ Developer.paginate :page => 1, :per_page => 1, :include => :projects
+ $query_sql.last.should_not include(' JOIN ')
+ }.should run_queries(4)
+ end
+
+ it "should keep :include for count when they are referenced in :conditions" do
+ Developer.expects(:find).returns([1])
+ Developer.expects(:count).with({ :include => :projects, :conditions => 'projects.id > 2' }).returns(0)
+
+ Developer.paginate :page => 1, :per_page => 1,
+ :include => :projects, :conditions => 'projects.id > 2'
+ end
+
+ describe "associations" do
+ it "should paginate with include" do
+ project = projects(:active_record)
+
+ result = project.topics.paginate \
+ :page => 1,
+ :include => :replies,
+ :conditions => ["replies.content LIKE ?", 'Nice%'],
+ :per_page => 10
+
+ expected = Topic.find :all,
+ :include => 'replies',
+ :conditions => ["project_id = #{project.id} AND replies.content LIKE ?", 'Nice%'],
+ :limit => 10
+
+ result.should == expected
+ end
+
+ it "should paginate" do
+ dhh = users(:david)
+ expected_name_ordered = projects(:action_controller, :active_record)
+ expected_id_ordered = projects(:active_record, :action_controller)
+
+ lambda {
+ # with association-specified order
+ result = dhh.projects.paginate(:page => 1)
+ result.should == expected_name_ordered
+ result.total_entries.should == 2
+ }.should run_queries(2)
+
+ # with explicit order
+ result = dhh.projects.paginate(:page => 1, :order => 'projects.id')
+ result.should == expected_id_ordered
+ result.total_entries.should == 2
+
+ lambda {
+ dhh.projects.find(:all, :order => 'projects.id', :limit => 4)
+ }.should_not raise_error
+
+ result = dhh.projects.paginate(:page => 1, :order => 'projects.id', :per_page => 4)
+ result.should == expected_id_ordered
+
+ # has_many with implicit order
+ topic = Topic.find(1)
+ expected = replies(:spam, :witty_retort)
+ # FIXME: wow, this is ugly
+ topic.replies.paginate(:page => 1).map(&:id).sort.should == expected.map(&:id).sort
+ topic.replies.paginate(:page => 1, :order => 'replies.id ASC').should == expected.reverse
+ end
+
+ it "should paginate through association extension" do
+ project = Project.find(:first)
+ expected = [replies(:brave)]
+
+ lambda {
+ result = project.replies.only_recent.paginate(:page => 1)
+ result.should == expected
+ }.should run_queries(1)
+ end
+ end
+
+ it "should paginate with joins" do
+ result = nil
+ join_sql = 'LEFT JOIN developers_projects ON users.id = developers_projects.developer_id'
+
+ lambda {
+ result = Developer.paginate :page => 1, :joins => join_sql, :conditions => 'project_id = 1'
+ result.size.should == 2
+ developer_names = result.map(&:name)
+ developer_names.should include('David')
+ developer_names.should include('Jamis')
+ }.should run_queries(1)
+
+ lambda {
+ expected = result.to_a
+ result = Developer.paginate :page => 1, :joins => join_sql,
+ :conditions => 'project_id = 1', :count => { :select => "users.id" }
+ result.should == expected
+ result.total_entries.should == 2
+ }.should run_queries(1)
+ end
+
+ it "should paginate with group" do
+ result = nil
+ lambda {
+ result = Developer.paginate :page => 1, :per_page => 10,
+ :group => 'salary', :select => 'salary', :order => 'salary'
+ }.should run_queries(1)
+
+ expected = users(:david, :jamis, :dev_10, :poor_jamis).map(&:salary).sort
+ result.map(&:salary).should == expected
+ end
+
+ it "should not paginate with dynamic finder" do
+ lambda {
+ Developer.paginate_by_salary(100000, :page => 1, :per_page => 5)
+ }.should raise_error(NoMethodError)
+ end
+
+ it "should paginate with_scope" do
+ result = Developer.with_poor_ones { Developer.paginate :page => 1 }
+ result.size.should == 2
+ result.total_entries.should == 2
+ end
+
+ describe "scopes" do
+ it "should paginate" do
+ result = Developer.poor.paginate :page => 1, :per_page => 1
+ result.size.should == 1
+ result.total_entries.should == 2
+ end
+
+ it "should paginate on habtm association" do
+ project = projects(:active_record)
+ lambda {
+ result = project.developers.poor.paginate :page => 1, :per_page => 1
+ result.size.should == 1
+ result.total_entries.should == 1
+ }.should run_queries(2)
+ end
+
+ it "should paginate on hmt association" do
+ project = projects(:active_record)
+ expected = [replies(:brave)]
+
+ lambda {
+ result = project.replies.recent.paginate :page => 1, :per_page => 1
+ result.should == expected
+ result.total_entries.should == 1
+ }.should run_queries(2)
+ end
+
+ it "should paginate on has_many association" do
+ project = projects(:active_record)
+ expected = [topics(:ar)]
+
+ lambda {
+ result = project.topics.mentions_activerecord.paginate :page => 1, :per_page => 1
+ result.should == expected
+ result.total_entries.should == 1
+ }.should run_queries(2)
+ end
+ end
+
+ it "should paginate with :readonly option" do
+ lambda {
+ Developer.paginate :readonly => true, :page => 1
+ }.should_not raise_error
+ end
+
+ it "should paginate an array of IDs" do
+ lambda {
+ result = Developer.paginate((1..8).to_a, :per_page => 3, :page => 2, :order => 'id')
+ result.map(&:id).should == (4..6).to_a
+ result.total_entries.should == 8
+ }.should run_queries(1)
+ end
+
+ protected
+
+ def run_queries(num)
+ QueryCountMatcher.new(num)
+ end
+
+end
+
+class QueryCountMatcher
+ def initialize(num)
+ @expected_count = num
+ end
+
+ def matches?(block)
+ $query_count = 0
+ $query_sql = []
+ block.call
+ @queries = $query_sql
+ @count = $query_count
+ @count == @expected_count
+ end
+
+ def failure_message
+ "expected #{@expected_count} queries, got #{@count}\n#{@queries.join("\n")}"
+ end
+
+ def negative_failure_message
+ "expected query count not to be #{$expected_count}"
+ end
+end
DIR diff --git a/web/vendor/plugins/will_paginate/spec/finders/active_resource_spec.rb b/web/vendor/plugins/will_paginate/spec/finders/active_resource_spec.rb
@@ -0,0 +1,52 @@
+require 'spec_helper'
+require 'will_paginate/finders/active_resource'
+require 'active_resource/http_mock'
+
+class AresProject < ActiveResource::Base
+ self.site = 'http://localhost:4000'
+end
+
+describe WillPaginate::Finders::ActiveResource do
+
+ before :all do
+ # ActiveResource::HttpMock.respond_to do |mock|
+ # mock.get "/ares_projects.xml?page=1&per_page=5", {}, [].to_xml
+ # end
+ end
+
+ it "should integrate with ActiveResource::Base" do
+ ActiveResource::Base.should respond_to(:paginate)
+ end
+
+ it "should error when no parameters for #paginate" do
+ lambda { AresProject.paginate }.should raise_error(ArgumentError)
+ end
+
+ it "should paginate" do
+ AresProject.expects(:find_every).with(:params => { :page => 1, :per_page => 5 }).returns([])
+ AresProject.paginate(:page => 1, :per_page => 5)
+ end
+
+ it "should have 30 per_page as default" do
+ AresProject.expects(:find_every).with(:params => { :page => 1, :per_page => 30 }).returns([])
+ AresProject.paginate(:page => 1)
+ end
+
+ it "should support #paginate(:all)" do
+ lambda { AresProject.paginate(:all) }.should raise_error(ArgumentError)
+ end
+
+ it "should error #paginate(:other)" do
+ lambda { AresProject.paginate(:first) }.should raise_error(ArgumentError)
+ end
+
+ protected
+
+ 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
+end
DIR diff --git a/web/vendor/plugins/will_paginate/spec/finders/activerecord_test_connector.rb b/web/vendor/plugins/will_paginate/spec/finders/activerecord_test_connector.rb
@@ -0,0 +1,114 @@
+require 'active_record'
+require 'active_record/version'
+require 'active_record/fixtures'
+require 'active_support/multibyte' # needed for Ruby 1.9.1
+
+$query_count = $query_sql = nil
+
+class ActiverecordTestConnector
+ cattr_accessor :able_to_connect
+ cattr_accessor :connected
+
+ FIXTURES_PATH = File.expand_path('../../fixtures', __FILE__)
+
+ # Set our defaults
+ self.connected = false
+ self.able_to_connect = true
+
+ def self.setup
+ unless self.connected || !self.able_to_connect
+ setup_connection
+ load_schema
+ add_load_path FIXTURES_PATH
+ self.connected = true
+ end
+ rescue Exception => e # errors from ActiveRecord setup
+ $stderr.puts "\nSkipping ActiveRecord tests: #{e}\n\n"
+ self.able_to_connect = false
+ end
+
+ private
+
+ def self.add_load_path(path)
+ dep = defined?(ActiveSupport::Dependencies) ? ActiveSupport::Dependencies : ::Dependencies
+ dep.autoload_paths.unshift path
+ end
+
+ def self.setup_connection
+ db = ENV['DB'].blank?? 'sqlite3' : ENV['DB']
+
+ configurations = YAML.load_file(File.expand_path('../../database.yml', __FILE__))
+ raise "no configuration for '#{db}'" unless configurations.key? db
+ configuration = configurations[db]
+
+ ActiveRecord::Base.logger = Logger.new(STDOUT) if $0 == 'irb'
+ puts "using #{configuration['adapter']} adapter"
+
+ ActiveRecord::Base.configurations = { db => configuration }
+ ActiveRecord::Base.establish_connection(db)
+ prepare ActiveRecord::Base.connection
+ end
+
+ def self.load_schema
+ ActiveRecord::Base.silence do
+ ActiveRecord::Migration.verbose = false
+ load File.join(FIXTURES_PATH, 'schema.rb')
+ end
+ end
+
+ def self.prepare(conn)
+ class << conn
+ IGNORED_SQL = /^(?:PRAGMA|SELECT (?:currval|CAST|@@IDENTITY|@@ROWCOUNT)|SHOW FIELDS)\b/
+
+ def execute_with_counting(sql, name = nil, &block)
+ if $query_count and IGNORED_SQL !~ sql
+ $query_count += 1
+ $query_sql << sql
+ end
+ execute_without_counting(sql, name, &block)
+ end
+
+ alias_method_chain :execute, :counting
+ end
+ end
+
+ def self.show_sql
+ ActiveSupport::Notifications.subscribe('active_record.sql') do |*args|
+ puts args.last[:sql]
+ end
+ end
+
+ module FixtureSetup
+ def fixtures(*tables)
+ table_names = tables.map { |t| t.to_s }
+
+ fixtures = Fixtures.create_fixtures ActiverecordTestConnector::FIXTURES_PATH, table_names
+ @@loaded_fixtures = {}
+ @@fixture_cache = {}
+
+ unless fixtures.nil?
+ if fixtures.instance_of?(Fixtures)
+ @@loaded_fixtures[fixtures.table_name] = fixtures
+ else
+ fixtures.each { |f| @@loaded_fixtures[f.table_name] = f }
+ end
+ end
+
+ table_names.each do |table_name|
+ define_method(table_name) do |*fixtures|
+ @@fixture_cache[table_name] ||= {}
+
+ instances = fixtures.map do |fixture|
+ if @@loaded_fixtures[table_name][fixture.to_s]
+ @@fixture_cache[table_name][fixture] ||= @@loaded_fixtures[table_name][fixture.to_s].find
+ else
+ raise StandardError, "No fixture with name '#{fixture}' found for table '#{table_name}'"
+ end
+ end
+
+ instances.size == 1 ? instances.first : instances
+ end
+ end
+ end
+ end
+end
DIR diff --git a/web/vendor/plugins/will_paginate/spec/finders/data_mapper_spec.rb b/web/vendor/plugins/will_paginate/spec/finders/data_mapper_spec.rb
@@ -0,0 +1,62 @@
+require 'spec_helper'
+require 'will_paginate/finders/data_mapper'
+require File.expand_path('../data_mapper_test_connector', __FILE__)
+
+require 'will_paginate'
+
+describe WillPaginate::Finders::DataMapper do
+
+ it "should make #paginate available to DM resource classes" do
+ Animal.should respond_to(:paginate)
+ end
+
+ it "should paginate" do
+ Animal.expects(:all).with(:limit => 5, :offset => 0).returns([])
+ Animal.paginate(:page => 1, :per_page => 5)
+ end
+
+ it "should NOT to paginate_by_sql" do
+ Animal.should_not respond_to(:paginate_by_sql)
+ end
+
+ it "should support explicit :all argument" do
+ Animal.expects(:all).with(instance_of(Hash)).returns([])
+ Animal.paginate(:all, :page => nil)
+ end
+
+ it "should support conditional pagination" do
+ filtered_result = Animal.paginate(:all, :name => 'Dog', :page => nil)
+ filtered_result.size.should == 1
+ filtered_result.first.should == Animal.first(:name => 'Dog')
+ end
+
+ it "should leave extra parameters intact" do
+ Animal.expects(:all).with(:name => 'Dog', :limit => 4, :offset => 0 ).returns(Array.new(5))
+ Animal.expects(:count).with({:name => 'Dog'}).returns(1)
+
+ Animal.paginate :name => 'Dog', :page => 1, :per_page => 4
+ end
+
+ describe "counting" do
+ it "should ignore nil in :count parameter" do
+ lambda { Animal.paginate :page => nil, :count => nil }.should_not raise_error
+ end
+
+ it "should guess the total count" do
+ Animal.expects(:all).returns(Array.new(2))
+ Animal.expects(:count).never
+
+ result = Animal.paginate :page => 2, :per_page => 4
+ result.total_entries.should == 6
+ end
+
+ it "should guess that there are no records" do
+ Animal.expects(:all).returns([])
+ Animal.expects(:count).never
+
+ result = Animal.paginate :page => 1, :per_page => 4
+ result.total_entries.should == 0
+ end
+ end
+
+end
DIR diff --git a/web/vendor/plugins/will_paginate/spec/finders/data_mapper_test_connector.rb b/web/vendor/plugins/will_paginate/spec/finders/data_mapper_test_connector.rb
@@ -0,0 +1,20 @@
+require 'dm-core'
+DataMapper.setup :default, 'sqlite3::memory:'
+
+# Define models
+class Animal
+ include DataMapper::Resource
+ property :id, Serial
+ property :name, String
+ property :notes, Text
+
+ def self.setup
+ Animal.create(:name => 'Dog', :notes => "Man's best friend")
+ Animal.create(:name => 'Cat', :notes => "Woman's best friend")
+ Animal.create(:name => 'Lion', :notes => 'King of the Jungle')
+ end
+end
+
+# Load fixtures
+Animal.auto_migrate!
+Animal.setup
+\ No newline at end of file
DIR diff --git a/web/vendor/plugins/will_paginate/spec/finders/sequel_spec.rb b/web/vendor/plugins/will_paginate/spec/finders/sequel_spec.rb
@@ -0,0 +1,53 @@
+require 'spec_helper'
+require 'will_paginate/finders/sequel'
+require File.expand_path('../sequel_test_connector', __FILE__)
+
+describe Sequel::Dataset::Pagination, 'extension' do
+
+ class Car < Sequel::Model
+ end
+
+ it "should have the #paginate method" do
+ Car.should respond_to(:paginate)
+ end
+
+ it "should NOT have the #paginate_by_sql method" do
+ Car.should_not respond_to(:paginate_by_sql)
+ end
+
+ describe 'pagination' do
+ before(:all) do
+ Car.create(:name => 'Shelby', :notes => "Man's best friend")
+ Car.create(:name => 'Aston Martin', :notes => "Woman's best friend")
+ Car.create(:name => 'Corvette', :notes => 'King of the Jungle')
+ end
+
+ it "should imitate WillPaginate::Collection" do
+ result = Car.paginate(1, 2)
+
+ result.total_entries.should == 3
+ result.total_pages.should == 2
+ result.per_page.should == 2
+ result.current_page.should == 1
+ result.previous_page.should be_nil
+ result.next_page.should == 2
+ end
+
+ it "should perform" do
+ Car.paginate(1, 2).all.should == [Car[1], Car[2]]
+ end
+
+ it "should perform with #select and #order" do
+ result = Car.select("name as foo".lit).order(:name).paginate(1, 2).all
+ result.size.should == 2
+ result.first.values[:foo].should == "Aston Martin"
+ end
+
+ it "should perform with #filter" do
+ results = Car.filter(:name => 'Shelby').paginate(1, 2).all
+ results.size.should == 1
+ results.first.should == Car.find(:name => 'Shelby')
+ end
+ end
+
+end
DIR diff --git a/web/vendor/plugins/will_paginate/spec/finders/sequel_test_connector.rb b/web/vendor/plugins/will_paginate/spec/finders/sequel_test_connector.rb
@@ -0,0 +1,9 @@
+require 'sequel'
+
+db = Sequel.sqlite
+
+db.create_table :cars do
+ primary_key :id, :integer, :auto_increment => true
+ column :name, :text
+ column :notes, :text
+end
DIR diff --git a/web/vendor/plugins/will_paginate/spec/finders_spec.rb b/web/vendor/plugins/will_paginate/spec/finders_spec.rb
@@ -0,0 +1,76 @@
+require 'spec_helper'
+require 'will_paginate/finders/base'
+
+class Model
+ extend WillPaginate::Finders::Base
+end
+
+describe WillPaginate::Finders::Base do
+ it "should define default per_page of 30" do
+ Model.per_page.should == 30
+ end
+
+ it "should allow to set custom per_page" do
+ begin
+ Model.per_page = 25
+ Model.per_page.should == 25
+ ensure
+ Model.per_page = 30
+ end
+ end
+
+ it "should result with WillPaginate::Collection" do
+ Model.expects(:wp_query)
+ Model.paginate(:page => nil).should be_instance_of(WillPaginate::Collection)
+ end
+
+ it "should delegate pagination to wp_query" do
+ Model.expects(:wp_query).with({}, instance_of(WillPaginate::Collection), [])
+ Model.paginate :page => nil
+ end
+
+ it "should complain when no hash parameters given" do
+ lambda {
+ Model.paginate
+ }.should raise_error(ArgumentError, 'parameter hash expected')
+ end
+
+ it "should complain when no :page parameter present" do
+ lambda {
+ Model.paginate :per_page => 6
+ }.should raise_error(ArgumentError, ':page parameter required')
+ end
+
+ it "should complain when both :count and :total_entries are given" do
+ lambda {
+ Model.paginate :page => 1, :count => {}, :total_entries => 1
+ }.should raise_error(ArgumentError, ':count and :total_entries are mutually exclusive')
+ end
+
+ it "should never mangle options" do
+ options = { :page => 1 }
+ options.expects(:delete).never
+ options_before = options.dup
+
+ Model.expects(:wp_query)
+ Model.paginate(options)
+
+ options.should == options_before
+ end
+
+ it "should provide paginated_each functionality" do
+ collection = stub('collection', :size => 5, :empty? => false, :per_page => 5)
+ collection.expects(:each).times(2).returns(collection)
+ last_collection = stub('collection', :size => 4, :empty? => false, :per_page => 5)
+ last_collection.expects(:each).returns(last_collection)
+
+ params = { :order => 'id', :total_entries => 0 }
+
+ Model.expects(:paginate).with(params.merge(:page => 2)).returns(collection)
+ Model.expects(:paginate).with(params.merge(:page => 3)).returns(collection)
+ Model.expects(:paginate).with(params.merge(:page => 4)).returns(last_collection)
+
+ total = Model.paginated_each(:page => '2') { }
+ total.should == 14
+ end
+end
DIR diff --git a/web/vendor/plugins/will_paginate/spec/fixtures/admin.rb b/web/vendor/plugins/will_paginate/spec/fixtures/admin.rb
@@ -0,0 +1,3 @@
+class Admin < User
+ has_many :companies, :finder_sql => 'SELECT * FROM companies'
+end
DIR diff --git a/web/vendor/plugins/will_paginate/spec/fixtures/developer.rb b/web/vendor/plugins/will_paginate/spec/fixtures/developer.rb
@@ -0,0 +1,13 @@
+class Developer < User
+ has_and_belongs_to_many :projects, :include => :topics, :order => 'projects.name'
+
+ def self.with_poor_ones(&block)
+ with_scope :find => { :conditions => ['salary <= ?', 80000], :order => 'salary' } do
+ yield
+ end
+ end
+
+ scope :poor, :conditions => ['salary <= ?', 80000], :order => 'salary'
+
+ def self.per_page() 10 end
+end
DIR diff --git a/web/vendor/plugins/will_paginate/spec/fixtures/developers_projects.yml b/web/vendor/plugins/will_paginate/spec/fixtures/developers_projects.yml
@@ -0,0 +1,13 @@
+david_action_controller:
+ developer_id: 1
+ project_id: 2
+ joined_on: 2004-10-10
+
+david_active_record:
+ developer_id: 1
+ project_id: 1
+ joined_on: 2004-10-10
+
+jamis_active_record:
+ developer_id: 2
+ project_id: 1
+\ No newline at end of file
DIR diff --git a/web/vendor/plugins/will_paginate/spec/fixtures/project.rb b/web/vendor/plugins/will_paginate/spec/fixtures/project.rb
@@ -0,0 +1,13 @@
+class Project < ActiveRecord::Base
+ has_and_belongs_to_many :developers, :uniq => true
+
+ has_many :topics
+ # :finder_sql => 'SELECT * FROM topics WHERE (topics.project_id = #{id})',
+ # :counter_sql => 'SELECT COUNT(*) FROM topics WHERE (topics.project_id = #{id})'
+
+ has_many :replies, :through => :topics do
+ def only_recent(params = {})
+ scoped.where(['replies.created_at > ?', 15.minutes.ago])
+ end
+ end
+end
DIR diff --git a/web/vendor/plugins/will_paginate/spec/fixtures/projects.yml b/web/vendor/plugins/will_paginate/spec/fixtures/projects.yml
@@ -0,0 +1,6 @@
+active_record:
+ id: 1
+ name: Active Record
+action_controller:
+ id: 2
+ name: Action Controller
DIR diff --git a/web/vendor/plugins/will_paginate/spec/fixtures/replies.yml b/web/vendor/plugins/will_paginate/spec/fixtures/replies.yml
@@ -0,0 +1,29 @@
+witty_retort:
+ id: 1
+ topic_id: 1
+ content: Birdman is better!
+ created_at: <%= 6.hours.ago.to_s(:db) %>
+
+another:
+ id: 2
+ topic_id: 2
+ content: Nuh uh!
+ created_at: <%= 1.hour.ago.to_s(:db) %>
+
+spam:
+ id: 3
+ topic_id: 1
+ content: Nice site!
+ created_at: <%= 1.hour.ago.to_s(:db) %>
+
+decisive:
+ id: 4
+ topic_id: 4
+ content: "I'm getting to the bottom of this"
+ created_at: <%= 30.minutes.ago.to_s(:db) %>
+
+brave:
+ id: 5
+ topic_id: 4
+ content: "AR doesn't scare me a bit"
+ created_at: <%= 10.minutes.ago.to_s(:db) %>
DIR diff --git a/web/vendor/plugins/will_paginate/spec/fixtures/reply.rb b/web/vendor/plugins/will_paginate/spec/fixtures/reply.rb
@@ -0,0 +1,7 @@
+class Reply < ActiveRecord::Base
+ belongs_to :topic, :include => [:replies]
+
+ scope :recent, :conditions => ['replies.created_at > ?', 15.minutes.ago]
+
+ validates_presence_of :content
+end
DIR diff --git a/web/vendor/plugins/will_paginate/spec/fixtures/schema.rb b/web/vendor/plugins/will_paginate/spec/fixtures/schema.rb
@@ -0,0 +1,38 @@
+ActiveRecord::Schema.define do
+
+ create_table "users", :force => true do |t|
+ t.column "name", :text
+ t.column "salary", :integer, :default => 70000
+ t.column "created_at", :datetime
+ t.column "updated_at", :datetime
+ t.column "type", :text
+ end
+
+ create_table "projects", :force => true do |t|
+ t.column "name", :text
+ end
+
+ create_table "developers_projects", :id => false, :force => true do |t|
+ t.column "developer_id", :integer, :null => false
+ t.column "project_id", :integer, :null => false
+ t.column "joined_on", :date
+ t.column "access_level", :integer, :default => 1
+ end
+
+ create_table "topics", :force => true do |t|
+ t.column "project_id", :integer
+ t.column "title", :string
+ t.column "subtitle", :string
+ t.column "content", :text
+ t.column "created_at", :datetime
+ t.column "updated_at", :datetime
+ end
+
+ create_table "replies", :force => true do |t|
+ t.column "content", :text
+ t.column "created_at", :datetime
+ t.column "updated_at", :datetime
+ t.column "topic_id", :integer
+ end
+
+end
DIR diff --git a/web/vendor/plugins/will_paginate/spec/fixtures/topic.rb b/web/vendor/plugins/will_paginate/spec/fixtures/topic.rb
@@ -0,0 +1,7 @@
+class Topic < ActiveRecord::Base
+ has_many :replies, :dependent => :destroy, :order => 'replies.created_at DESC'
+ belongs_to :project
+
+ scope :mentions_activerecord, :conditions => ['topics.title LIKE ?', '%ActiveRecord%']
+ scope :distinct, :select => "DISTINCT #{table_name}.*"
+end
DIR diff --git a/web/vendor/plugins/will_paginate/spec/fixtures/topics.yml b/web/vendor/plugins/will_paginate/spec/fixtures/topics.yml
@@ -0,0 +1,30 @@
+futurama:
+ id: 1
+ title: Isnt futurama awesome?
+ subtitle: It really is, isnt it.
+ content: I like futurama
+ created_at: <%= 1.day.ago.to_s(:db) %>
+ updated_at:
+
+harvey_birdman:
+ id: 2
+ title: Harvey Birdman is the king of all men
+ subtitle: yup
+ content: He really is
+ created_at: <%= 2.hours.ago.to_s(:db) %>
+ updated_at:
+
+rails:
+ id: 3
+ project_id: 1
+ title: Rails is nice
+ subtitle: It makes me happy
+ content: except when I have to hack internals to fix pagination. even then really.
+ created_at: <%= 20.minutes.ago.to_s(:db) %>
+
+ar:
+ id: 4
+ project_id: 1
+ title: ActiveRecord sometimes freaks me out
+ content: "I mean, what's the deal with eager loading?"
+ created_at: <%= 15.minutes.ago.to_s(:db) %>
DIR diff --git a/web/vendor/plugins/will_paginate/spec/fixtures/user.rb b/web/vendor/plugins/will_paginate/spec/fixtures/user.rb
@@ -0,0 +1,2 @@
+class User < ActiveRecord::Base
+end
DIR diff --git a/web/vendor/plugins/will_paginate/spec/fixtures/users.yml b/web/vendor/plugins/will_paginate/spec/fixtures/users.yml
@@ -0,0 +1,35 @@
+david:
+ id: 1
+ name: David
+ salary: 80000
+ type: Developer
+
+jamis:
+ id: 2
+ name: Jamis
+ salary: 150000
+ type: Developer
+
+<% for digit in 3..10 %>
+dev_<%= digit %>:
+ id: <%= digit %>
+ name: fixture_<%= digit %>
+ salary: 100000
+ type: Developer
+<% end %>
+
+poor_jamis:
+ id: 11
+ name: Jamis
+ salary: 9000
+ type: Developer
+
+admin:
+ id: 12
+ name: admin
+ type: Admin
+
+goofy:
+ id: 13
+ name: Goofy
+ type: Admin
DIR diff --git a/web/vendor/plugins/will_paginate/spec/rcov.opts b/web/vendor/plugins/will_paginate/spec/rcov.opts
@@ -0,0 +1,2 @@
+--exclude ^\/,^spec\/,core_ext.rb,deprecation.rb
+--no-validator-links
+\ No newline at end of file
DIR diff --git a/web/vendor/plugins/will_paginate/spec/spec.opts b/web/vendor/plugins/will_paginate/spec/spec.opts
@@ -0,0 +1,2 @@
+--colour
+--reverse
DIR diff --git a/web/vendor/plugins/will_paginate/spec/spec_helper.rb b/web/vendor/plugins/will_paginate/spec/spec_helper.rb
@@ -0,0 +1,76 @@
+require 'rubygems'
+require 'bundler'
+require 'spec/autorun'
+
+module MyExtras
+ protected
+
+ def include_phrase(string)
+ PhraseMatcher.new(string)
+ end
+
+ def collection(params = {})
+ if params[:total_pages]
+ params[:per_page] = 1
+ params[:total_entries] = params[:total_pages]
+ end
+ WillPaginate::Collection.new(params[:page] || 1, params[:per_page] || 30, params[:total_entries])
+ end
+
+ def have_deprecation
+ DeprecationMatcher.new
+ end
+end
+
+Spec::Runner.configure do |config|
+ # config.include My::Pony, My::Horse, :type => :farm
+ config.include MyExtras
+ # config.predicate_matchers[:swim] = :can_swim?
+
+ config.mock_with :mocha
+end
+
+class PhraseMatcher
+ def initialize(string)
+ @string = string
+ @pattern = /\b#{string}\b/
+ end
+
+ def matches?(actual)
+ @actual = actual.to_s
+ @actual =~ @pattern
+ end
+
+ def failure_message
+ "expected #{@actual.inspect} to contain phrase #{@string.inspect}"
+ end
+
+ def negative_failure_message
+ "expected #{@actual.inspect} not to contain phrase #{@string.inspect}"
+ end
+end
+
+class DeprecationMatcher
+ def initialize
+ @old_behavior = WillPaginate::Deprecation.behavior
+ @messages = []
+ WillPaginate::Deprecation.behavior = lambda { |message, callstack|
+ @messages << message
+ }
+ end
+
+ def matches?(block)
+ block.call
+ !@messages.empty?
+ ensure
+ WillPaginate::Deprecation.behavior = @old_behavior
+ end
+
+ def failure_message
+ "expected block to raise a deprecation warning"
+ end
+
+ def negative_failure_message
+ "expected block not to raise deprecation warnings, #{@messages.size} raised"
+ end
+end
DIR diff --git a/web/vendor/plugins/will_paginate/spec/tasks.rake b/web/vendor/plugins/will_paginate/spec/tasks.rake
@@ -0,0 +1,60 @@
+require 'spec/rake/spectask'
+
+spec_opts = 'spec/spec.opts'
+
+desc 'Run framework-agnostic specs'
+Spec::Rake::SpecTask.new(:spec) do |t|
+ t.libs << 'spec'
+ t.spec_opts = ['--options', spec_opts]
+ t.spec_files = FileList.new('spec/**/*_spec.rb') do |files|
+ files.exclude(/\b(active_record|active_resource|action_view|data_mapper|sequel)_/)
+ end
+end
+
+namespace :spec do
+ desc 'Run specs for core, ActiveRecord and ActionView'
+ Spec::Rake::SpecTask.new(:rails) do |t|
+ t.libs << 'spec'
+ t.spec_opts = ['--options', spec_opts]
+ t.spec_files = FileList.new('spec/**/*_spec.rb') do |files|
+ files.exclude(/\b(data_mapper|sequel)_/)
+ end
+ end
+
+ desc 'Run specs for DataMapper'
+ Spec::Rake::SpecTask.new(:datamapper) do |t|
+ t.libs << 'spec'
+ t.spec_opts = ['--options', spec_opts]
+ t.spec_files = FileList.new('spec/finders_spec.rb', 'spec/finders/data_mapper_spec.rb')
+ end
+
+ desc 'Run specs for Sequel'
+ Spec::Rake::SpecTask.new(:sequel) do |t|
+ t.libs << 'spec'
+ t.spec_opts = ['--options', spec_opts]
+ t.spec_files = FileList.new('spec/finders_spec.rb', 'spec/finders/sequel_spec.rb')
+ end
+
+ desc 'Analyze spec coverage with RCov'
+ Spec::Rake::SpecTask.new(:rcov) do |t|
+ t.libs << 'spec'
+ t.spec_opts = ['--options', spec_opts]
+ t.rcov = true
+ t.rcov_opts = lambda do
+ IO.readlines('spec/rcov.opts').map { |l| l.chomp.split(" ") }.flatten
+ end
+ end
+
+ desc 'Print Specdoc for all specs'
+ Spec::Rake::SpecTask.new(:doc) do |t|
+ t.libs << 'spec'
+ t.spec_opts = ['--format', 'specdoc', '--dry-run']
+ end
+
+ desc 'Generate HTML report'
+ Spec::Rake::SpecTask.new(:html) do |t|
+ t.libs << 'spec'
+ t.spec_opts = ['--format', 'html:doc/spec_results.html', '--diff']
+ t.fail_on_error = false
+ end
+end
DIR diff --git a/web/vendor/plugins/will_paginate/spec/view_helpers/action_view_spec.rb b/web/vendor/plugins/will_paginate/spec/view_helpers/action_view_spec.rb
@@ -0,0 +1,356 @@
+require 'spec_helper'
+require 'active_support/rescuable' # needed for Ruby 1.9.1
+require 'action_controller'
+require 'view_helpers/view_example_group'
+require 'will_paginate/view_helpers/action_view'
+require 'will_paginate/collection'
+
+ActionView::Base.send(:include, WillPaginate::ViewHelpers::ActionView)
+
+Routes = ActionDispatch::Routing::RouteSet.new
+
+Routes.draw do
+ match 'dummy/page/:page' => 'dummy#index'
+ match 'dummy/dots/page.:page' => 'dummy#dots'
+ match 'ibocorp(/:page)' => 'ibocorp#index',
+ :constraints => { :page => /\d+/ }, :defaults => { :page => 1 }
+
+ match ':controller(/:action(/:id(.:format)))'
+end
+
+describe WillPaginate::ViewHelpers::ActionView do
+ before(:each) do
+ @assigns = {}
+ @controller = DummyController.new
+ @request = @controller.request
+ @template = '<%= will_paginate collection, options %>'
+ end
+
+ attr_reader :assigns, :controller, :request
+
+ def render(locals)
+ @view = ActionView::Base.new([], @assigns, @controller)
+ @view.request = @request
+ @view.singleton_class.send(:include, @controller._routes.url_helpers)
+ @view.render(:inline => @template, :locals => locals)
+ end
+
+ ## basic pagination ##
+
+ it "should render" do
+ paginate do |pagination|
+ assert_select 'a[href]', 3 do |elements|
+ validate_page_numbers [2,3,2], elements
+ assert_select elements.last, ':last-child', "Next →"
+ end
+ assert_select 'span', 1
+ assert_select 'span.disabled:first-child', '← Previous'
+ assert_select 'em', '1'
+ pagination.first.inner_text.should == '← Previous 1 2 3 Next →'
+ end
+ end
+
+ it "should render nothing when there is only 1 page" do
+ paginate(:per_page => 30).should be_empty
+ end
+
+ it "should paginate with options" do
+ paginate({ :page => 2 }, :class => 'will_paginate', :previous_label => 'Prev', :next_label => 'Next') do
+ assert_select 'a[href]', 4 do |elements|
+ validate_page_numbers [1,1,3,3], elements
+ # test rel attribute values:
+ assert_select elements[1], 'a', '1' do |link|
+ link.first['rel'].should == 'prev start'
+ end
+ assert_select elements.first, 'a', "Prev" do |link|
+ link.first['rel'].should == 'prev start'
+ end
+ assert_select elements.last, 'a', "Next" do |link|
+ link.first['rel'].should == 'next'
+ end
+ end
+ assert_select 'em', '2'
+ end
+ end
+
+ it "should paginate using a custom renderer class" do
+ paginate({}, :renderer => AdditionalLinkAttributesRenderer) do
+ assert_select 'a[default=true]', 3
+ end
+ end
+
+ it "should paginate using a custom renderer instance" do
+ renderer = WillPaginate::ViewHelpers::LinkRenderer.new
+ def renderer.gap() '<span class="my-gap">~~</span>' end
+
+ paginate({ :per_page => 2 }, :inner_window => 0, :outer_window => 0, :renderer => renderer) do
+ assert_select 'span.my-gap', '~~'
+ end
+
+ renderer = AdditionalLinkAttributesRenderer.new(:title => 'rendered')
+ paginate({}, :renderer => renderer) do
+ assert_select 'a[title=rendered]', 3
+ end
+ end
+
+ it "should have classnames on previous/next links" do
+ paginate do |pagination|
+ assert_select 'span.disabled.previous_page:first-child'
+ assert_select 'a.next_page[href]:last-child'
+ end
+ end
+
+ it "should warn about :prev_label being deprecated" do
+ lambda {
+ paginate({ :page => 2 }, :prev_label => 'Deprecated') do
+ assert_select 'a[href]:first-child', 'Deprecated'
+ end
+ }.should have_deprecation
+ end
+
+ it "should match expected markup" do
+ paginate
+ expected = <<-HTML
+ <div class="pagination"><span class="previous_page disabled">← Previous</span>
+ <em>1</em>
+ <a href="/foo/bar?page=2" rel="next">2</a>
+ <a href="/foo/bar?page=3">3</a>
+ <a href="/foo/bar?page=2" class="next_page" rel="next">Next →</a></div>
+ HTML
+ expected.strip!.gsub!(/\s{2,}/, ' ')
+ expected_dom = HTML::Document.new(expected).root
+
+ html_document.root.should == expected_dom
+ end
+
+ it "should output escaped URLs" do
+ paginate({:page => 1, :per_page => 1, :total_entries => 2},
+ :page_links => false, :params => { :tag => '<br>' })
+
+ assert_select 'a[href]', 1 do |links|
+ query = links.first['href'].split('?', 2)[1]
+ query.split('&').sort.should == %w(page=2 tag=%3Cbr%3E)
+ end
+ end
+
+ ## advanced options for pagination ##
+
+ it "should be able to render without container" do
+ paginate({}, :container => false)
+ assert_select 'div.pagination', 0, 'main DIV present when it shouldn\'t'
+ assert_select 'a[href]', 3
+ end
+
+ it "should be able to render without page links" do
+ paginate({ :page => 2 }, :page_links => false) do
+ assert_select 'a[href]', 2 do |elements|
+ validate_page_numbers [1,3], elements
+ end
+ end
+ end
+
+ it "should have magic HTML ID for the container" do
+ paginate do |div|
+ div.first['id'].should be_nil
+ end
+
+ # magic ID
+ paginate({}, :id => true) do |div|
+ div.first['id'].should == 'fixnums_pagination'
+ end
+
+ # explicit ID
+ paginate({}, :id => 'custom_id') do |div|
+ div.first['id'].should == 'custom_id'
+ end
+ end
+
+ ## other helpers ##
+
+ it "should render a paginated section" do
+ @template = <<-ERB
+ <%= paginated_section collection, options do %>
+ <%= content_tag :div, '', :id => "developers" %>
+ <% end %>
+ ERB
+
+ paginate
+ assert_select 'div.pagination', 2
+ assert_select 'div.pagination + div#developers', 1
+ end
+
+ ## parameter handling in page links ##
+
+ it "should preserve parameters on GET" do
+ request.params :foo => { :bar => 'baz' }
+ paginate
+ assert_links_match /foo\[bar\]=baz/
+ end
+
+ it "should not preserve parameters on POST" do
+ request.post
+ request.params :foo => 'bar'
+ paginate
+ assert_no_links_match /foo=bar/
+ end
+
+ it "should add additional parameters to links" do
+ paginate({}, :params => { :foo => 'bar' })
+ assert_links_match /foo=bar/
+ end
+
+ it "should add anchor parameter" do
+ paginate({}, :params => { :anchor => 'anchor' })
+ assert_links_match /#anchor$/
+ end
+
+ it "should remove arbitrary parameters" do
+ request.params :foo => 'bar'
+ paginate({}, :params => { :foo => nil })
+ assert_no_links_match /foo=bar/
+ end
+
+ it "should override default route parameters" do
+ paginate({}, :params => { :controller => 'baz', :action => 'list' })
+ assert_links_match %r{\Wbaz/list\W}
+ end
+
+ it "should paginate with custom page parameter" do
+ paginate({ :page => 2 }, :param_name => :developers_page) do
+ assert_select 'a[href]', 4 do |elements|
+ validate_page_numbers [1,1,3,3], elements, :developers_page
+ end
+ end
+ end
+
+ it "should paginate with complex custom page parameter" do
+ request.params :developers => { :page => 2 }
+
+ paginate({ :page => 2 }, :param_name => 'developers[page]') do
+ assert_select 'a[href]', 4 do |links|
+ assert_links_match /\?developers\[page\]=\d+$/, links
+ validate_page_numbers [1,1,3,3], links, 'developers[page]'
+ end
+ end
+ end
+
+ it "should paginate with custom route page parameter" do
+ request.symbolized_path_parameters.update :controller => 'dummy', :action => nil
+ paginate :per_page => 2 do
+ assert_select 'a[href]', 6 do |links|
+ assert_links_match %r{/page/(\d+)$}, links, [2, 3, 4, 5, 6, 2]
+ end
+ end
+ end
+
+ it "should paginate with custom route with dot separator page parameter" do
+ request.symbolized_path_parameters.update :controller => 'dummy', :action => 'dots'
+ paginate :per_page => 2 do
+ assert_select 'a[href]', 6 do |links|
+ assert_links_match %r{/page\.(\d+)$}, links, [2, 3, 4, 5, 6, 2]
+ end
+ end
+ end
+
+ it "should paginate with custom route and first page number implicit" do
+ request.symbolized_path_parameters.update :controller => 'ibocorp', :action => nil
+ paginate :page => 2, :per_page => 2 do
+ assert_select 'a[href]', 7 do |links|
+ assert_links_match %r{/ibocorp(?:/(\d+))?$}, links, [nil, nil, 3, 4, 5, 6, 3]
+ end
+ end
+ # Routes.recognize_path('/ibocorp/2').should == {:page=>'2', :action=>'index', :controller=>'ibocorp'}
+ # Routes.recognize_path('/ibocorp/foo').should == {:action=>'foo', :controller=>'ibocorp'}
+ end
+
+ ## internal hardcore stuff ##
+
+ it "should be able to guess the collection name" do
+ collection = mock
+ collection.expects(:total_pages).returns(1)
+
+ @template = '<%= will_paginate options %>'
+ controller.controller_name = 'developers'
+ assigns['developers'] = collection
+
+ paginate(nil)
+ end
+
+ it "should fail if the inferred collection is nil" do
+ @template = '<%= will_paginate options %>'
+ controller.controller_name = 'developers'
+
+ lambda {
+ paginate(nil)
+ }.should raise_error(ActionView::TemplateError, /@developers/)
+ end
+end
+
+class AdditionalLinkAttributesRenderer < WillPaginate::ViewHelpers::LinkRenderer
+ def initialize(link_attributes = nil)
+ super()
+ @additional_link_attributes = link_attributes || { :default => 'true' }
+ end
+
+ def link(text, target, attributes = {})
+ super(text, target, attributes.merge(@additional_link_attributes))
+ end
+end
+
+class DummyController
+ attr_reader :request
+ attr_accessor :controller_name
+
+ include ActionController::UrlFor
+ include Routes.url_helpers
+
+ def initialize
+ @request = DummyRequest.new
+ end
+
+ def params
+ @request.params
+ end
+end
+
+class IbocorpController < DummyController
+end
+
+class DummyRequest
+ attr_accessor :symbolized_path_parameters
+
+ def initialize
+ @get = true
+ @params = {}
+ @symbolized_path_parameters = { :controller => 'foo', :action => 'bar' }
+ end
+
+ def get?
+ @get
+ end
+
+ def post
+ @get = false
+ end
+
+ def relative_url_root
+ ''
+ end
+
+ def script_name
+ ''
+ end
+
+ def params(more = nil)
+ @params.update(more) if more
+ @params
+ end
+
+ def host_with_port
+ 'example.com'
+ end
+
+ def protocol
+ 'http:'
+ end
+end
DIR diff --git a/web/vendor/plugins/will_paginate/spec/view_helpers/base_spec.rb b/web/vendor/plugins/will_paginate/spec/view_helpers/base_spec.rb
@@ -0,0 +1,64 @@
+require 'spec_helper'
+require 'will_paginate/view_helpers/base'
+require 'will_paginate/array'
+
+describe WillPaginate::ViewHelpers::Base do
+
+ include WillPaginate::ViewHelpers::Base
+
+ describe "will_paginate" do
+ it "should render" do
+ collection = WillPaginate::Collection.new(1, 2, 4)
+ renderer = mock 'Renderer'
+ renderer.expects(:prepare).with(collection, instance_of(Hash), self)
+ renderer.expects(:to_html).returns('<PAGES>')
+
+ will_paginate(collection, :renderer => renderer).should == '<PAGES>'
+ end
+
+ it "should return nil for single-page collections" do
+ collection = mock 'Collection', :total_pages => 1
+ will_paginate(collection).should be_nil
+ end
+ end
+
+ describe "page_entries_info" do
+ before :all do
+ @array = ('a'..'z').to_a
+ end
+
+ def info(params, options = {})
+ options[:html] ||= false unless options.key?(:html) and options[:html].nil?
+ collection = Hash === params ? @array.paginate(params) : params
+ page_entries_info collection, options
+ end
+
+ it "should display middle results and total count" do
+ info(:page => 2, :per_page => 5).should == "Displaying strings 6 - 10 of 26 in total"
+ end
+
+ it "should output HTML by default" do
+ info({ :page => 2, :per_page => 5 }, :html => nil).should ==
+ "Displaying strings <b>6 - 10</b> of <b>26</b> in total"
+ end
+
+ it "should display shortened end results" do
+ info(:page => 7, :per_page => 4).should include_phrase('strings 25 - 26')
+ end
+
+ it "should handle longer class names" do
+ collection = @array.paginate(:page => 2, :per_page => 5)
+ collection.first.stubs(:class).returns(mock('Class', :name => 'ProjectType'))
+ info(collection).should include_phrase('project types')
+ end
+
+ it "should adjust output for single-page collections" do
+ info(('a'..'d').to_a.paginate(:page => 1, :per_page => 5)).should == "Displaying all 4 strings"
+ info(['a'].paginate(:page => 1, :per_page => 5)).should == "Displaying 1 string"
+ end
+
+ it "should display 'no entries found' for empty collections" do
+ info([].paginate(:page => 1, :per_page => 5)).should == "No entries found"
+ end
+ end
+end
DIR diff --git a/web/vendor/plugins/will_paginate/spec/view_helpers/link_renderer_base_spec.rb b/web/vendor/plugins/will_paginate/spec/view_helpers/link_renderer_base_spec.rb
@@ -0,0 +1,84 @@
+require 'spec_helper'
+require 'will_paginate/view_helpers/link_renderer_base'
+require 'will_paginate/collection'
+
+describe WillPaginate::ViewHelpers::LinkRendererBase do
+
+ before do
+ @renderer = WillPaginate::ViewHelpers::LinkRendererBase.new
+ end
+
+ it "should raise error when unprepared" do
+ lambda {
+ @renderer.send :param_name
+ }.should raise_error
+ end
+
+ it "should prepare with collection and options" do
+ prepare({}, :param_name => 'mypage')
+ @renderer.send(:current_page).should == 1
+ @renderer.send(:param_name).should == 'mypage'
+ end
+
+ it "should have total_pages accessor" do
+ prepare :total_pages => 42
+ lambda {
+ @renderer.send(:total_pages).should == 42
+ }.should_not have_deprecation
+ end
+
+ it "should clear old cached values when prepared" do
+ prepare({ :total_pages => 1 }, :param_name => 'foo')
+ @renderer.send(:total_pages).should == 1
+ @renderer.send(:param_name).should == 'foo'
+ # prepare with different object and options:
+ prepare({ :total_pages => 2 }, :param_name => 'bar')
+ @renderer.send(:total_pages).should == 2
+ @renderer.send(:param_name).should == 'bar'
+ end
+
+ it "should have pagination definition" do
+ prepare({ :total_pages => 1 }, :page_links => true)
+ @renderer.pagination.should == [:previous_page, 1, :next_page]
+ end
+
+ describe "visible page numbers" do
+ it "should calculate windowed visible links" do
+ prepare({ :page => 6, :total_pages => 11 }, :inner_window => 1, :outer_window => 1)
+ showing_pages 1, 2, :gap, 5, 6, 7, :gap, 10, 11
+ end
+
+ it "should eliminate small gaps" do
+ prepare({ :page => 6, :total_pages => 11 }, :inner_window => 2, :outer_window => 1)
+ # pages 4 and 8 appear instead of the gap
+ showing_pages 1..11
+ end
+
+ it "should support having no windows at all" do
+ prepare({ :page => 4, :total_pages => 7 }, :inner_window => 0, :outer_window => 0)
+ showing_pages 1, :gap, 4, :gap, 7
+ end
+
+ it "should adjust upper limit if lower is out of bounds" do
+ prepare({ :page => 1, :total_pages => 10 }, :inner_window => 2, :outer_window => 1)
+ showing_pages 1, 2, 3, 4, 5, :gap, 9, 10
+ end
+
+ it "should adjust lower limit if upper is out of bounds" do
+ prepare({ :page => 10, :total_pages => 10 }, :inner_window => 2, :outer_window => 1)
+ showing_pages 1, 2, :gap, 6, 7, 8, 9, 10
+ end
+
+ def showing_pages(*pages)
+ pages = pages.first.to_a if Array === pages.first or Range === pages.first
+ @renderer.send(:windowed_page_numbers).should == pages
+ end
+ end
+
+ protected
+
+ def prepare(collection_options, options = {})
+ @renderer.prepare(collection(collection_options), options)
+ end
+
+end
DIR diff --git a/web/vendor/plugins/will_paginate/spec/view_helpers/view_example_group.rb b/web/vendor/plugins/will_paginate/spec/view_helpers/view_example_group.rb
@@ -0,0 +1,103 @@
+require 'action_dispatch/testing/assertions'
+
+class ViewExampleGroup < Spec::Example::ExampleGroup
+
+ include ActionDispatch::Assertions::SelectorAssertions
+
+ def assert(value, message)
+ raise message unless value
+ end
+
+ def paginate(collection = {}, options = {}, &block)
+ if collection.instance_of? Hash
+ page_options = { :page => 1, :total_entries => 11, :per_page => 4 }.merge(collection)
+ collection = [1].paginate(page_options)
+ end
+
+ locals = { :collection => collection, :options => options }
+
+ @render_output = render(locals)
+ @html_document = nil
+
+ if block_given?
+ classname = options[:class] || WillPaginate::ViewHelpers.pagination_options[:class]
+ assert_select("div.#{classname}", 1, 'no main DIV', &block)
+ end
+
+ @render_output
+ end
+
+ def html_document
+ @html_document ||= HTML::Document.new(@render_output, true, false)
+ end
+
+ def response_from_page_or_rjs
+ html_document.root
+ end
+
+ def validate_page_numbers(expected, links, param_name = :page)
+ param_pattern = /\W#{Regexp.escape(param_name.to_s)}=([^&]*)/
+
+ links.map { |e|
+ e['href'] =~ param_pattern
+ $1 ? $1.to_i : $1
+ }.should == expected
+ end
+
+ def assert_links_match(pattern, links = nil, numbers = nil)
+ links ||= assert_select 'div.pagination a[href]' do |elements|
+ elements
+ end
+
+ pages = [] if numbers
+
+ links.each do |el|
+ el['href'].should =~ pattern
+ if numbers
+ el['href'] =~ pattern
+ pages << ($1.nil?? nil : $1.to_i)
+ end
+ end
+
+ pages.should == numbers if numbers
+ end
+
+ def assert_no_links_match(pattern)
+ assert_select 'div.pagination a[href]' do |elements|
+ elements.each do |el|
+ el['href'] !~ pattern
+ end
+ end
+ end
+
+ def build_message(message, pattern, *args)
+ built_message = pattern.dup
+ for value in args
+ built_message.sub! '?', value.inspect
+ end
+ built_message
+ end
+
+end
+
+Spec::Example::ExampleGroupFactory.register(:view_helpers, ViewExampleGroup)
+
+module HTML
+ Node.class_eval do
+ def inner_text
+ children.map(&:inner_text).join('')
+ end
+ end
+
+ Text.class_eval do
+ def inner_text
+ self.to_s
+ end
+ end
+
+ Tag.class_eval do
+ def inner_text
+ childless?? '' : super
+ end
+ end
+end