warvox - Unnamed repository; edit this file 'description' to name the repositor… | |
Log | |
Files | |
Refs | |
README | |
--- | |
commit 26a2d4eb45574f2a127837abb4966260b652264b | |
parent 0899f9ede192b63614dbf366f0d23a8370a0d5f9 | |
Author: HD Moore <[email protected]> | |
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(-) | |
--- | |
diff --git a/web/vendor/plugins/will_paginate/CHANGELOG.rdoc b/web/vendor/plugi… | |
@@ -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 h… | |
+* 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… | |
+* 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 n… | |
+ | |
+== 2.3.0, released 2008-04-29 | |
+ | |
+* Changed LinkRenderer to receive collection, options and reference to view te… | |
+ constructor, but with the #prepare method. This is a step towards supporting… | |
+ LinkRenderer (or subclass) instances that may be preconfigured in some way | |
+* LinkRenderer now has #page_link and #page_span methods for easier customizat… | |
+ subclasses | |
+* Changed page_entries_info() method to adjust its output according to humaniz… | |
+ 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 a… | |
+ 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 on… | |
+ one page of records at the time | |
+* Rails 2: Rescue from WillPaginate::InvalidPage error with 404 Not Found by | |
+ default | |
diff --git a/web/vendor/plugins/will_paginate/LICENSE b/web/vendor/plugins/will… | |
@@ -0,0 +1,18 @@ | |
+Copyright (c) 2009 Mislav Marohnić | |
+ | |
+Permission is hereby granted, free of charge, to any person obtaining a copy o… | |
+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 … | |
+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, FITNE… | |
+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. | |
diff --git a/web/vendor/plugins/will_paginate/README.rdoc b/web/vendor/plugins/… | |
@@ -0,0 +1,125 @@ | |
+= The will_paginate Ruby library | |
+ | |
+Pagination is just limiting the number of records loaded and displayed. Why sh… | |
+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 specif… | |
+ | |
+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… | |
+* {How to report bugs}[http://github.com/mislav/will_paginate/wikis/report-bug… | |
+* {Watch the will_paginate screencast}[http://railscasts.com/episodes/51] by R… | |
+ | |
+== I'm not using Rails; can I still use will_paginate? | |
+ | |
+Absolutely -- although will_paginate started off as a Rails plugin, now it is … | |
+framework-agnostic</em> library with support for Rails and Merb built-in. The … | |
+have any dependences and you can safely use it in any Ruby code. | |
+ | |
+When will_paginate is loaded in an environment where ActiveRecord and ActionVi… | |
+automatically hooks into these frameworks to provide easy pagination on your m… | |
+views. The same mechanism works for Merb applications, too. But, if no known f… | |
+then you have absolute control over what parts of will_paginate do you want to… | |
+them mixed in. | |
+ | |
+ | |
+== Installation | |
+ | |
+The recommended way is that you get the gem hosted on {gems.github.com}[http:/… | |
+ | |
+ 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 => '~> … | |
+ | |
+If you're using Rails 2.0 or older, or any other Ruby framework, just add a si… | |
+that initializes your application. For example, in Rails you would put this at… | |
+"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 y… | |
+ | |
+<i>There are extensive {installation | |
+instructions}[http://github.com/mislav/will_paginate/wikis/installation] on {t… | |
+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 … | |
+to tell it which page you want, or it will complain! Read more in WillPaginate… | |
+ | |
+Render the posts in your view like you would normally do, and when you need to… | |
+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 calli… | |
++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</… | |
+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 th… | |
+properties. You can use the collection as you would use any other array. WillP… | |
+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 devel… | |
+Marohnić. (The library was completely rewritten since then.) | |
+ | |
+All these people helped making will_paginate what it is now with their code co… | |
+simply awesome ideas: | |
+ | |
+Chris Wanstrath, Dr. Nic Williams, K. Adam Christensen, Mike Garey, Bence Gold… | |
+Charles Brian Quinn, Desi McAdam, James Coglan, Matijs van Zuijlen, Maria, Bre… | |
+Willey, Bryan Helmkamp, Jan Berkel, Lourens Naudé, Rick Olson, Russell Norris… | |
+Eppstein, Brandon Arbini, Denis Barushev, Paul Barry, Ben Pickles, Ken Collins… | |
+Noordhuis. | |
+ | |
+ | |
+== Usable pagination in the UI | |
+ | |
+There are example CSS styles to get you started on the will_paginate project p… | |
+ | |
+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-g… | |
+* {Pagination design pattern}[http://developer.yahoo.com/ypatterns/parent.php?… | |
+ | |
+Want to discuss, request features, ask questions? Join the {Google | |
+group}[http://groups.google.com/group/will_paginate]. | |
+\ No newline at end of file | |
diff --git a/web/vendor/plugins/will_paginate/Rakefile b/web/vendor/plugins/wil… | |
@@ -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 | |
diff --git a/web/vendor/plugins/will_paginate/lib/will_paginate.rb b/web/vendor… | |
@@ -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… | |
+ require "will_paginate/finders/#{adapter}" | |
+ end | |
+end | |
diff --git a/web/vendor/plugins/will_paginate/lib/will_paginate/array.rb b/web/… | |
@@ -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})" un… | |
+ | |
+ WillPaginate::Collection.create options[:page] || 1, | |
+ options[:per_page] || 30, | |
+ options[:total_entries] || self.length do … | |
+ pager.replace self[pager.offset, pager.per_page].to_a | |
+ end | |
+ end | |
+end | |
diff --git a/web/vendor/plugins/will_paginate/lib/will_paginate/collection.rb b… | |
@@ -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 li… | |
+ # 404 Not Found. The hook is in "will_paginate.rb": | |
+ # | |
+ # ActionController::Base.rescue_responses['WillPaginate::InvalidPage'] = :… | |
+ # | |
+ # 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}'… | |
+ end | |
+ end | |
+ | |
+ # = The key to pagination | |
+ # Arrays returned from paginating finds are, in fact, instances of this litt… | |
+ # class. You may think of WillPaginate::Collection as an ordinary array with | |
+ # some extra properties. Those properties are used by view helpers to genera… | |
+ # 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 li… | |
+ # 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_p… | |
+ | |
+ 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.… | |
+ # # 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 pa… | |
+ # 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… | |
+ # 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 exam… | |
+ # 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 le… | |
+ self.total_entries = offset + length | |
+ end | |
+ | |
+ result | |
+ end | |
+ end | |
+end | |
diff --git a/web/vendor/plugins/will_paginate/lib/will_paginate/core_ext.rb b/w… | |
@@ -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 s… | |
+# | |
+# ['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_… | |
+ 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_k… | |
+ 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 | |
diff --git a/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_D… | |
+ 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 | |
diff --git a/web/vendor/plugins/will_paginate/lib/will_paginate/finders.rb b/we… | |
@@ -0,0 +1,9 @@ | |
+require 'will_paginate/core_ext' | |
+ | |
+module WillPaginate | |
+ # Database logic for different ORMs | |
+ # | |
+ # See WillPaginate::Finders::Base | |
+ module Finders | |
+ end | |
+end | |
diff --git a/web/vendor/plugins/will_paginate/lib/will_paginate/finders/active_… | |
@@ -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_… | |
+ # | |
+ # 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 functionalit… | |
+ def self.enable! | |
+ ::ActiveRecord::Base.class_eval do | |
+ extend ActiveRecord | |
+ end | |
+ | |
+ # support pagination on associations and scopes | |
+ [::ActiveRecord::Relation, ::ActiveRecord::Associations::AssociationColl… | |
+ 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 whe… | |
+ # :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.downc… | |
+ 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, :l… | |
+ | |
+ 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 = fin… | |
+ # scope_out adds a 'with_finder' method which acts like with_s… | |
+ # then execute the count with the scoping provided by the with… | |
+ 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_nam… | |
+ 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… | |
+ # 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 … | |
+ 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 cou… | |
+ count_options.delete :include | |
+ end | |
+ | |
+ count_options | |
+ end | |
+ end | |
+end | |
diff --git a/web/vendor/plugins/will_paginate/lib/will_paginate/finders/active_… | |
@@ -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 support… | |
+ 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 = {}… | |
+ if collection.is_a?(Hash) && collection["type"] == "collection" | |
+ collectables = collection.values.find{ |c| c.is_a?(Hash) || c.is_a?(Ar… | |
+ collectables = [collectables].compact unless collectables.kind_of?(Arr… | |
+ instantiated_collection = WillPaginate::Collection.create(collection["… | |
+ pager.replace instantiate_collection_without_collection(collectables… | |
+ 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 | |
diff --git a/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> (wh… | |
+ # * <tt>:total_entries</tt> -- use only if you manually count total entr… | |
+ # * <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 |pag… | |
+ 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 us… | |
+ # for migrations or any other use case where you don't want to load all … | |
+ # 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). De… | |
+ # <tt>:order</tt> is <tt>"id"</tt>, override if necessary. | |
+ # | |
+ # {Jamis Buck describes this}[http://weblog.jamisbuck.org/2007/4/6/fakin… | |
+ # 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 === optio… | |
+ raise ArgumentError, ':page parameter required' unless options.key? … | |
+ | |
+ if options[:count] and options[:total_entries] | |
+ raise ArgumentError, ':count and :total_entries are mutually exclu… | |
+ 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 | |
diff --git a/web/vendor/plugins/will_paginate/lib/will_paginate/finders/data_ma… | |
@@ -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, :l… | |
+ | |
+ 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) | |
diff --git a/web/vendor/plugins/will_paginate/lib/will_paginate/finders/sequel.… | |
@@ -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? :t… | |
+ alias :per_page :page_size unless existing_methods.include_method? :p… | |
+ alias :previous_page :prev_page unless existing_methods.include_method? :p… | |
+ alias :total_entries :pagination_record_count unless existing_methods.includ… | |
+ | |
+ 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 | |
diff --git a/web/vendor/plugins/will_paginate/lib/will_paginate/railtie.rb b/we… | |
@@ -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::Invalid… | |
+ 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 | |
diff --git a/web/vendor/plugins/will_paginate/lib/will_paginate/version.rb b/we… | |
@@ -0,0 +1,9 @@ | |
+module WillPaginate #:nodoc: | |
+ module VERSION #:nodoc: | |
+ MAJOR = 3 | |
+ MINOR = 0 | |
+ TINY = 'pre2' | |
+ | |
+ STRING = [MAJOR, MINOR, TINY].join('.') | |
+ end | |
+end | |
diff --git a/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] = 'Previ… | |
+ # | |
+ # 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-gr… | |
+ :param_name => :page, | |
+ :params => nil, | |
+ :renderer => 'WillPaginate::ViewHelpers::LinkRenderer', | |
+ :page_links => true, | |
+ :container => true | |
+ } | |
+ end | |
+end | |
diff --git a/web/vendor/plugins/will_paginate/lib/will_paginate/view_helpers/ac… | |
@@ -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 add… | |
+ # 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 blo… | |
+ # 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 opt… | |
+ # apply. Don't use the <tt>:id</tt> option; otherwise you'll finish with… | |
+ # 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 em… | |
+ "forget to pass the collection object for will_paginate?" if collect… | |
+ 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 | |
diff --git a/web/vendor/plugins/will_paginate/lib/will_paginate/view_helpers/ba… | |
@@ -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 ob… | |
+ # returned if there is only one page in total; pagination links aren't n… | |
+ # | |
+ # ==== Options | |
+ # * <tt>:class</tt> -- CSS class name for the generated DIV (default: "p… | |
+ # * <tt>:previous_label</tt> -- default: "« Previous" | |
+ # * <tt>:next_label</tt> -- default: "Next »" | |
+ # * <tt>:inner_window</tt> -- how many links are shown around the curren… | |
+ # * <tt>:outer_window</tt> -- how many links are around the first and th… | |
+ # * <tt>:separator</tt> -- string separator for page HTML elements (defa… | |
+ # * <tt>:param_name</tt> -- parameter name for page number in URLs (defa… | |
+ # * <tt>:params</tt> -- additional parameters when generating pagination… | |
+ # (eg. <tt>:controller => "foo", :action => nil</tt>) | |
+ # * <tt>:renderer</tt> -- class name, class or instance of a link render… | |
+ # <tt>WillPaginate::LinkRenderer</tt>) | |
+ # * <tt>:page_links</tt> -- when false, only previous/next links are ren… | |
+ # * <tt>:container</tt> -- toggles rendering of the DIV container for pa… | |
+ # false only when you are rendering your own pagination markup (defaul… | |
+ # * <tt>:id</tt> -- HTML ID for the container (default: nil). Pass +true… | |
+ # automatically generated from the class name of objects in collection… | |
+ # ArticleComment models would yield an ID of "article_comments_paginat… | |
+ # | |
+ # All options beside listed ones are passed as HTML attributes to the co… | |
+ # 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 :… | |
+ 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 =>… | |
+ # | |
+ # 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} … | |
+ collection.offset + 1, | |
+ collection.offset + collection.length, | |
+ collection.total_entries | |
+ ] | |
+ end | |
+ end | |
+ end | |
+ end | |
+end | |
diff --git a/web/vendor/plugins/will_paginate/lib/will_paginate/view_helpers/li… | |
@@ -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 obj… | |
+ # 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 link… | |
+ def container_attributes | |
+ @container_attributes ||= begin | |
+ attributes = @options.except *(WillPaginate::ViewHelpers.pagination_… | |
+ # 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.pluraliz… | |
+ 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_la… | |
+ end | |
+ | |
+ def next_page | |
+ previous_or_next_page(@collection.next_page, @options[:next_label], 'n… | |
+ 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 par… | |
+ # 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 | |
diff --git a/web/vendor/plugins/will_paginate/lib/will_paginate/view_helpers/li… | |
@@ -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 obj… | |
+ # 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[:o… | |
+ 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 | |
diff --git a/web/vendor/plugins/will_paginate/lib/will_paginate/view_helpers/me… | |
@@ -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… | |
+ @template.url(:this, params) | |
+ end | |
+end | |
+ | |
+Merb::AbstractController.send(:include, WillPaginate::ViewHelpers::Base) | |
+\ No newline at end of file | |
diff --git a/web/vendor/plugins/will_paginate/spec/collection_spec.rb b/web/ven… | |
@@ -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_… | |
+ 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… | |
+ 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::InvalidPa… | |
+ 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 | |
diff --git a/web/vendor/plugins/will_paginate/spec/console b/web/vendor/plugins… | |
@@ -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" | |
diff --git a/web/vendor/plugins/will_paginate/spec/console_fixtures.rb b/web/ve… | |
@@ -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, ActiveRecor… | |
+ | |
+ActiverecordTestConnector.show_sql | |
+\ No newline at end of file | |
diff --git a/web/vendor/plugins/will_paginate/spec/database.yml b/web/vendor/pl… | |
@@ -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 | |
diff --git a/web/vendor/plugins/will_paginate/spec/finders/active_record_spec.r… | |
@@ -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_pag… | |
+ 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… | |
+ 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.m… | |
+ 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" … | |
+ Developer.expects(:find).returns([1]) | |
+ Developer.expects(:count).with({ :include => :projects, :conditions => 'pr… | |
+ | |
+ 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 ?… | |
+ :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… | |
+ 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… | |
+ topic.replies.paginate(:page => 1, :order => 'replies.id ASC').should ==… | |
+ 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_project… | |
+ | |
+ lambda { | |
+ result = Developer.paginate :page => 1, :joins => join_sql, :conditions … | |
+ 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 => { :selec… | |
+ 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', :or… | |
+ }.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, :pe… | |
+ 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, :or… | |
+ 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 | |
diff --git a/web/vendor/plugins/will_paginate/spec/finders/active_resource_spec… | |
@@ -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 =… | |
+ 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 =… | |
+ 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 | |
diff --git a/web/vendor/plugins/will_paginate/spec/finders/activerecord_test_co… | |
@@ -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 … | |
+ 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', __F… | |
+ 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)|… | |
+ | |
+ 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_… | |
+ @@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… | |
+ else | |
+ raise StandardError, "No fixture with name '#{fixture}' found fo… | |
+ end | |
+ end | |
+ | |
+ instances.size == 1 ? instances.first : instances | |
+ end | |
+ end | |
+ end | |
+ end | |
+end | |
diff --git a/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 ).retu… | |
+ 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_… | |
+ 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 | |
diff --git a/web/vendor/plugins/will_paginate/spec/finders/data_mapper_test_con… | |
@@ -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 | |
diff --git a/web/vendor/plugins/will_paginate/spec/finders/sequel_spec.rb b/web… | |
@@ -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 | |
diff --git a/web/vendor/plugins/will_paginate/spec/finders/sequel_test_connecto… | |
@@ -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 | |
diff --git a/web/vendor/plugins/will_paginate/spec/finders_spec.rb b/web/vendor… | |
@@ -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::Collectio… | |
+ 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 mutuall… | |
+ 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 =>… | |
+ collection.expects(:each).times(2).returns(collection) | |
+ last_collection = stub('collection', :size => 4, :empty? => false, :per_pa… | |
+ 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_colle… | |
+ | |
+ total = Model.paginated_each(:page => '2') { } | |
+ total.should == 14 | |
+ end | |
+end | |
diff --git a/web/vendor/plugins/will_paginate/spec/fixtures/admin.rb b/web/vend… | |
@@ -0,0 +1,3 @@ | |
+class Admin < User | |
+ has_many :companies, :finder_sql => 'SELECT * FROM companies' | |
+end | |
diff --git a/web/vendor/plugins/will_paginate/spec/fixtures/developer.rb b/web/… | |
@@ -0,0 +1,13 @@ | |
+class Developer < User | |
+ has_and_belongs_to_many :projects, :include => :topics, :order => 'projects.… | |
+ | |
+ def self.with_poor_ones(&block) | |
+ with_scope :find => { :conditions => ['salary <= ?', 80000], :order => 'sa… | |
+ yield | |
+ end | |
+ end | |
+ | |
+ scope :poor, :conditions => ['salary <= ?', 80000], :order => 'salary' | |
+ | |
+ def self.per_page() 10 end | |
+end | |
diff --git a/web/vendor/plugins/will_paginate/spec/fixtures/developers_projects… | |
@@ -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 | |
diff --git a/web/vendor/plugins/will_paginate/spec/fixtures/project.rb b/web/ve… | |
@@ -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 = … | |
+ | |
+ has_many :replies, :through => :topics do | |
+ def only_recent(params = {}) | |
+ scoped.where(['replies.created_at > ?', 15.minutes.ago]) | |
+ end | |
+ end | |
+end | |
diff --git a/web/vendor/plugins/will_paginate/spec/fixtures/projects.yml b/web/… | |
@@ -0,0 +1,6 @@ | |
+active_record: | |
+ id: 1 | |
+ name: Active Record | |
+action_controller: | |
+ id: 2 | |
+ name: Action Controller | |
diff --git a/web/vendor/plugins/will_paginate/spec/fixtures/replies.yml b/web/v… | |
@@ -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) %> | |
diff --git a/web/vendor/plugins/will_paginate/spec/fixtures/reply.rb b/web/vend… | |
@@ -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 | |
diff --git a/web/vendor/plugins/will_paginate/spec/fixtures/schema.rb b/web/ven… | |
@@ -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 | |
diff --git a/web/vendor/plugins/will_paginate/spec/fixtures/topic.rb b/web/vend… | |
@@ -0,0 +1,7 @@ | |
+class Topic < ActiveRecord::Base | |
+ has_many :replies, :dependent => :destroy, :order => 'replies.created_at DES… | |
+ belongs_to :project | |
+ | |
+ scope :mentions_activerecord, :conditions => ['topics.title LIKE ?', '%Activ… | |
+ scope :distinct, :select => "DISTINCT #{table_name}.*" | |
+end | |
diff --git a/web/vendor/plugins/will_paginate/spec/fixtures/topics.yml b/web/ve… | |
@@ -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 r… | |
+ 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) %> | |
diff --git a/web/vendor/plugins/will_paginate/spec/fixtures/user.rb b/web/vendo… | |
@@ -0,0 +1,2 @@ | |
+class User < ActiveRecord::Base | |
+end | |
diff --git a/web/vendor/plugins/will_paginate/spec/fixtures/users.yml b/web/ven… | |
@@ -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 | |
diff --git a/web/vendor/plugins/will_paginate/spec/rcov.opts b/web/vendor/plugi… | |
@@ -0,0 +1,2 @@ | |
+--exclude ^\/,^spec\/,core_ext.rb,deprecation.rb | |
+--no-validator-links | |
+\ No newline at end of file | |
diff --git a/web/vendor/plugins/will_paginate/spec/spec.opts b/web/vendor/plugi… | |
@@ -0,0 +1,2 @@ | |
+--colour | |
+--reverse | |
diff --git a/web/vendor/plugins/will_paginate/spec/spec_helper.rb b/web/vendor/… | |
@@ -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, … | |
+ 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 | |
+ [email protected]? | |
+ 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} raise… | |
+ end | |
+end | |
diff --git a/web/vendor/plugins/will_paginate/spec/tasks.rake b/web/vendor/plug… | |
@@ -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|se… | |
+ 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_map… | |
+ 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_s… | |
+ 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 | |
diff --git a/web/vendor/plugins/will_paginate/spec/view_helpers/action_view_spe… | |
@@ -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 => 'Pr… | |
+ 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, :rend… | |
+ 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">← Pre… | |
+ <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><… | |
+ 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 … | |
+ 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 … | |
+ 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', :actio… | |
+ 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… | |
+ end | |
+ end | |
+ # Routes.recognize_path('/ibocorp/2').should == {:page=>'2', :action=>'ind… | |
+ # Routes.recognize_path('/ibocorp/foo').should == {:action=>'foo', :contro… | |
+ 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::LinkRender… | |
+ 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 | |
diff --git a/web/vendor/plugins/will_paginate/spec/view_helpers/base_spec.rb b/… | |
@@ -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].n… | |
+ 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… | |
+ 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 => 'ProjectTy… | |
+ 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 == "Di… | |
+ info(['a'].paginate(:page => 1, :per_page => 5)).should == "Displaying 1… | |
+ end | |
+ | |
+ it "should display 'no entries found' for empty collections" do | |
+ info([].paginate(:page => 1, :per_page => 5)).should == "No entries foun… | |
+ end | |
+ end | |
+end | |
diff --git a/web/vendor/plugins/will_paginate/spec/view_helpers/link_renderer_b… | |
@@ -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_w… | |
+ 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_w… | |
+ # 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_wi… | |
+ 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_w… | |
+ 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_… | |
+ 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.fir… | |
+ @renderer.send(:windowed_page_numbers).should == pages | |
+ end | |
+ end | |
+ | |
+ protected | |
+ | |
+ def prepare(collection_options, options = {}) | |
+ @renderer.prepare(collection(collection_options), options) | |
+ end | |
+ | |
+end | |
diff --git a/web/vendor/plugins/will_paginate/spec/view_helpers/view_example_gr… | |
@@ -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 }.merg… | |
+ 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_opti… | |
+ 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 |