djmaze-will_paginate 2.3.13

Sign up to get free protection for your applications and to get access to all the features.
@@ -0,0 +1,37 @@
1
+ ActiveRecord::Associations::AssociationProxy.class_eval do
2
+ protected
3
+ def with_scope(*args)
4
+ @reflection.klass.send(:with_scope, *args) { |*a| yield(*a) if block_given? }
5
+ end
6
+ end
7
+
8
+ [ ActiveRecord::Associations::AssociationCollection,
9
+ ActiveRecord::Associations::HasManyThroughAssociation ].each do |klass|
10
+ klass.class_eval do
11
+ protected
12
+ alias :method_missing_without_scopes :method_missing_without_paginate
13
+ def method_missing_without_paginate(method, *args)
14
+ if @reflection.klass.scopes.include?(method)
15
+ @reflection.klass.scopes[method].call(self, *args) { |*a| yield(*a) if block_given? }
16
+ else
17
+ method_missing_without_scopes(method, *args) { |*a| yield(*a) if block_given? }
18
+ end
19
+ end
20
+ end
21
+ end
22
+
23
+ # Rails 1.2.6
24
+ ActiveRecord::Associations::HasAndBelongsToManyAssociation.class_eval do
25
+ protected
26
+ def method_missing(method, *args)
27
+ if @target.respond_to?(method) || (!@reflection.klass.respond_to?(method) && Class.respond_to?(method))
28
+ super
29
+ elsif @reflection.klass.scopes.include?(method)
30
+ @reflection.klass.scopes[method].call(self, *args)
31
+ else
32
+ @reflection.klass.with_scope(:find => { :conditions => @finder_sql, :joins => @join_sql, :readonly => false }) do
33
+ @reflection.klass.send(method, *args) { |*a| yield(*a) if block_given? }
34
+ end
35
+ end
36
+ end
37
+ end if ActiveRecord::Base.respond_to? :find_first
@@ -0,0 +1,9 @@
1
+ module WillPaginate
2
+ module VERSION
3
+ MAJOR = 2
4
+ MINOR = 3
5
+ TINY = 13
6
+
7
+ STRING = [MAJOR, MINOR, TINY].join('.')
8
+ end
9
+ end
@@ -0,0 +1,408 @@
1
+ require 'will_paginate/core_ext'
2
+
3
+ module WillPaginate
4
+ # = Will Paginate view helpers
5
+ #
6
+ # The main view helper, #will_paginate, renders
7
+ # pagination links for the given collection. The helper itself is lightweight
8
+ # and serves only as a wrapper around LinkRenderer instantiation; the
9
+ # renderer then does all the hard work of generating the HTML.
10
+ #
11
+ # == Global options for helpers
12
+ #
13
+ # Options for pagination helpers are optional and get their default values from the
14
+ # <tt>WillPaginate::ViewHelpers.pagination_options</tt> hash. You can write to this hash to
15
+ # override default options on the global level:
16
+ #
17
+ # WillPaginate::ViewHelpers.pagination_options[:previous_label] = 'Previous page'
18
+ #
19
+ # By putting this into "config/initializers/will_paginate.rb" (or simply environment.rb in
20
+ # older versions of Rails) you can easily translate link texts to previous
21
+ # and next pages, as well as override some other defaults to your liking.
22
+ module ViewHelpers
23
+ # default options that can be overridden on the global level
24
+ @@pagination_options = {
25
+ :class => 'pagination',
26
+ :previous_label => '&laquo; Previous',
27
+ :next_label => 'Next &raquo;',
28
+ :inner_window => 4, # links around the current page
29
+ :outer_window => 1, # links around beginning and end
30
+ :separator => ' ', # single space is friendly to spiders and non-graphic browsers
31
+ :param_name => :page,
32
+ :params => nil,
33
+ :renderer => 'WillPaginate::LinkRenderer',
34
+ :page_links => true,
35
+ :container => true
36
+ }
37
+ mattr_reader :pagination_options
38
+
39
+ # Renders Digg/Flickr-style pagination for a WillPaginate::Collection
40
+ # object. Nil is returned if there is only one page in total; no point in
41
+ # rendering the pagination in that case...
42
+ #
43
+ # ==== Options
44
+ # Display options:
45
+ # * <tt>:previous_label</tt> -- default: "« Previous" (this parameter is called <tt>:prev_label</tt> in versions <b>2.3.2</b> and older!)
46
+ # * <tt>:next_label</tt> -- default: "Next »"
47
+ # * <tt>:page_links</tt> -- when false, only previous/next links are rendered (default: true)
48
+ # * <tt>:inner_window</tt> -- how many links are shown around the current page (default: 4)
49
+ # * <tt>:outer_window</tt> -- how many links are around the first and the last page (default: 1)
50
+ # * <tt>:separator</tt> -- string separator for page HTML elements (default: single space)
51
+ #
52
+ # HTML options:
53
+ # * <tt>:class</tt> -- CSS class name for the generated DIV (default: "pagination")
54
+ # * <tt>:container</tt> -- toggles rendering of the DIV container for pagination links, set to
55
+ # false only when you are rendering your own pagination markup (default: true)
56
+ # * <tt>:id</tt> -- HTML ID for the container (default: nil). Pass +true+ to have the ID
57
+ # automatically generated from the class name of objects in collection: for example, paginating
58
+ # ArticleComment models would yield an ID of "article_comments_pagination".
59
+ #
60
+ # Advanced options:
61
+ # * <tt>:param_name</tt> -- parameter name for page number in URLs (default: <tt>:page</tt>)
62
+ # * <tt>:params</tt> -- additional parameters when generating pagination links
63
+ # (eg. <tt>:controller => "foo", :action => nil</tt>)
64
+ # * <tt>:renderer</tt> -- class name, class or instance of a link renderer (default:
65
+ # <tt>WillPaginate::LinkRenderer</tt>)
66
+ #
67
+ # All options not recognized by will_paginate will become HTML attributes on the container
68
+ # element for pagination links (the DIV). For example:
69
+ #
70
+ # <%= will_paginate @posts, :style => 'font-size: small' %>
71
+ #
72
+ # ... will result in:
73
+ #
74
+ # <div class="pagination" style="font-size: small"> ... </div>
75
+ #
76
+ # ==== Using the helper without arguments
77
+ # If the helper is called without passing in the collection object, it will
78
+ # try to read from the instance variable inferred by the controller name.
79
+ # For example, calling +will_paginate+ while the current controller is
80
+ # PostsController will result in trying to read from the <tt>@posts</tt>
81
+ # variable. Example:
82
+ #
83
+ # <%= will_paginate :id => true %>
84
+ #
85
+ # ... will result in <tt>@post</tt> collection getting paginated:
86
+ #
87
+ # <div class="pagination" id="posts_pagination"> ... </div>
88
+ #
89
+ def will_paginate(collection = nil, options = {})
90
+ options, collection = collection, nil if collection.is_a? Hash
91
+ unless collection or !controller
92
+ collection_name = "@#{controller.controller_name}"
93
+ collection = instance_variable_get(collection_name)
94
+ raise ArgumentError, "The #{collection_name} variable appears to be empty. Did you " +
95
+ "forget to pass the collection object for will_paginate?" unless collection
96
+ end
97
+ # early exit if there is nothing to render
98
+ return nil unless WillPaginate::ViewHelpers.total_pages_for_collection(collection) > 1
99
+
100
+ options = options.symbolize_keys.reverse_merge WillPaginate::ViewHelpers.pagination_options
101
+ if options[:prev_label]
102
+ WillPaginate::Deprecation::warn(":prev_label view parameter is now :previous_label; the old name has been deprecated", caller)
103
+ options[:previous_label] = options.delete(:prev_label)
104
+ end
105
+
106
+ # get the renderer instance
107
+ renderer = case options[:renderer]
108
+ when String
109
+ options[:renderer].to_s.constantize.new
110
+ when Class
111
+ options[:renderer].new
112
+ else
113
+ options[:renderer]
114
+ end
115
+ # render HTML for pagination
116
+ renderer.prepare collection, options, self
117
+ renderer.to_html
118
+ end
119
+
120
+ # Wrapper for rendering pagination links at both top and bottom of a block
121
+ # of content.
122
+ #
123
+ # <% paginated_section @posts do %>
124
+ # <ol id="posts">
125
+ # <% for post in @posts %>
126
+ # <li> ... </li>
127
+ # <% end %>
128
+ # </ol>
129
+ # <% end %>
130
+ #
131
+ # will result in:
132
+ #
133
+ # <div class="pagination"> ... </div>
134
+ # <ol id="posts">
135
+ # ...
136
+ # </ol>
137
+ # <div class="pagination"> ... </div>
138
+ #
139
+ # Arguments are passed to a <tt>will_paginate</tt> call, so the same options
140
+ # apply. Don't use the <tt>:id</tt> option; otherwise you'll finish with two
141
+ # blocks of pagination links sharing the same ID (which is invalid HTML).
142
+ def paginated_section(*args, &block)
143
+ pagination = will_paginate(*args).to_s
144
+
145
+ unless ActionView::Base.respond_to? :erb_variable
146
+ concat pagination
147
+ yield
148
+ concat pagination
149
+ else
150
+ content = pagination + capture(&block) + pagination
151
+ concat(content, block.binding)
152
+ end
153
+ end
154
+
155
+ # Renders a helpful message with numbers of displayed vs. total entries.
156
+ # You can use this as a blueprint for your own, similar helpers.
157
+ #
158
+ # <%= page_entries_info @posts %>
159
+ # #-> Displaying posts 6 - 10 of 26 in total
160
+ #
161
+ # By default, the message will use the humanized class name of objects
162
+ # in collection: for instance, "project types" for ProjectType models.
163
+ # Override this with the <tt>:entry_name</tt> parameter:
164
+ #
165
+ # <%= page_entries_info @posts, :entry_name => 'item' %>
166
+ # #-> Displaying items 6 - 10 of 26 in total
167
+ def page_entries_info(collection, options = {})
168
+ entry_name = options[:entry_name] ||
169
+ (collection.empty?? 'entry' : collection.first.class.name.underscore.sub('_', ' '))
170
+
171
+ if collection.total_pages < 2
172
+ case collection.size
173
+ when 0; "No #{entry_name.pluralize} found"
174
+ when 1; "Displaying <b>1</b> #{entry_name}"
175
+ else; "Displaying <b>all #{collection.size}</b> #{entry_name.pluralize}"
176
+ end
177
+ else
178
+ %{Displaying #{entry_name.pluralize} <b>%d&nbsp;-&nbsp;%d</b> of <b>%d</b> in total} % [
179
+ collection.offset + 1,
180
+ collection.offset + collection.length,
181
+ collection.total_entries
182
+ ]
183
+ end
184
+ end
185
+
186
+ if respond_to? :safe_helper
187
+ safe_helper :will_paginate, :paginated_section, :page_entries_info
188
+ end
189
+
190
+ def self.total_pages_for_collection(collection) #:nodoc:
191
+ if collection.respond_to?('page_count') and !collection.respond_to?('total_pages')
192
+ WillPaginate::Deprecation.warn %{
193
+ You are using a paginated collection of class #{collection.class.name}
194
+ which conforms to the old API of WillPaginate::Collection by using
195
+ `page_count`, while the current method name is `total_pages`. Please
196
+ upgrade yours or 3rd-party code that provides the paginated collection}, caller
197
+ class << collection
198
+ def total_pages; page_count; end
199
+ end
200
+ end
201
+ collection.total_pages
202
+ end
203
+ end
204
+
205
+ # This class does the heavy lifting of actually building the pagination
206
+ # links. It is used by the <tt>will_paginate</tt> helper internally.
207
+ class LinkRenderer
208
+
209
+ # The gap in page links is represented by:
210
+ #
211
+ # <span class="gap">&hellip;</span>
212
+ attr_accessor :gap_marker
213
+
214
+ def initialize
215
+ @gap_marker = '<span class="gap">&hellip;</span>'
216
+ end
217
+
218
+ # * +collection+ is a WillPaginate::Collection instance or any other object
219
+ # that conforms to that API
220
+ # * +options+ are forwarded from +will_paginate+ view helper
221
+ # * +template+ is the reference to the template being rendered
222
+ def prepare(collection, options, template)
223
+ @collection = collection
224
+ @options = options
225
+ @template = template
226
+
227
+ # reset values in case we're re-using this instance
228
+ @total_pages = @param_name = @url_string = nil
229
+ end
230
+
231
+ # Process it! This method returns the complete HTML string which contains
232
+ # pagination links. Feel free to subclass LinkRenderer and change this
233
+ # method as you see fit.
234
+ def to_html
235
+ links = @options[:page_links] ? windowed_links : []
236
+ # previous/next buttons
237
+ links.unshift page_link_or_span(@collection.previous_page, 'disabled prev_page', @options[:previous_label])
238
+ links.push page_link_or_span(@collection.next_page, 'disabled next_page', @options[:next_label])
239
+
240
+ html = links.join(@options[:separator])
241
+ @options[:container] ? @template.content_tag(:div, html, html_attributes) : html
242
+ end
243
+
244
+ # Returns the subset of +options+ this instance was initialized with that
245
+ # represent HTML attributes for the container element of pagination links.
246
+ def html_attributes
247
+ return @html_attributes if @html_attributes
248
+ @html_attributes = @options.except *(WillPaginate::ViewHelpers.pagination_options.keys - [:class])
249
+ # pagination of Post models will have the ID of "posts_pagination"
250
+ if @options[:container] and @options[:id] === true
251
+ @html_attributes[:id] = @collection.first.class.name.underscore.pluralize + '_pagination'
252
+ end
253
+ @html_attributes
254
+ end
255
+
256
+ protected
257
+
258
+ # Collects link items for visible page numbers.
259
+ def windowed_links
260
+ prev = nil
261
+
262
+ visible_page_numbers.inject [] do |links, n|
263
+ # detect gaps:
264
+ links << gap_marker if prev and n > prev + 1
265
+ links << page_link_or_span(n, 'current')
266
+ prev = n
267
+ links
268
+ end
269
+ end
270
+
271
+ # Calculates visible page numbers using the <tt>:inner_window</tt> and
272
+ # <tt>:outer_window</tt> options.
273
+ def visible_page_numbers
274
+ inner_window, outer_window = @options[:inner_window].to_i, @options[:outer_window].to_i
275
+ window_from = current_page - inner_window
276
+ window_to = current_page + inner_window
277
+
278
+ # adjust lower or upper limit if other is out of bounds
279
+ if window_to > total_pages
280
+ window_from -= window_to - total_pages
281
+ window_to = total_pages
282
+ end
283
+ if window_from < 1
284
+ window_to += 1 - window_from
285
+ window_from = 1
286
+ window_to = total_pages if window_to > total_pages
287
+ end
288
+
289
+ visible = (1..total_pages).to_a
290
+ left_gap = (2 + outer_window)...window_from
291
+ right_gap = (window_to + 1)...(total_pages - outer_window)
292
+ visible -= left_gap.to_a if left_gap.last - left_gap.first > 1
293
+ visible -= right_gap.to_a if right_gap.last - right_gap.first > 1
294
+
295
+ visible
296
+ end
297
+
298
+ def page_link_or_span(page, span_class, text = nil)
299
+ text ||= page.to_s
300
+
301
+ if page and page != current_page
302
+ classnames = span_class && span_class.index(' ') && span_class.split(' ', 2).last
303
+ page_link page, text, :rel => rel_value(page), :class => classnames
304
+ else
305
+ page_span page, text, :class => span_class
306
+ end
307
+ end
308
+
309
+ def page_link(page, text, attributes = {})
310
+ @template.link_to text, url_for(page), attributes
311
+ end
312
+
313
+ def page_span(page, text, attributes = {})
314
+ @template.content_tag :span, text, attributes
315
+ end
316
+
317
+ # Returns URL params for +page_link_or_span+, taking the current GET params
318
+ # and <tt>:params</tt> option into account.
319
+ def url_for(page)
320
+ page_one = page == 1
321
+ unless @url_string and !page_one
322
+ @url_params = {}
323
+ # page links should preserve GET parameters
324
+ stringified_merge @url_params, @template.params if @template.request.get?
325
+ stringified_merge @url_params, @options[:params] if @options[:params]
326
+
327
+ if complex = param_name.index(/[^\w-]/)
328
+ page_param = parse_query_parameters("#{param_name}=#{page}")
329
+
330
+ stringified_merge @url_params, page_param
331
+ else
332
+ @url_params[param_name] = page_one ? 1 : 2
333
+ end
334
+
335
+ url = @template.url_for(@url_params)
336
+ return url if page_one
337
+
338
+ if complex
339
+ @url_string = url.sub(%r!((?:\?|&amp;)#{CGI.escape param_name}=)#{page}!, "\\1\0")
340
+ return url
341
+ else
342
+ @url_string = url
343
+ @url_params[param_name] = 3
344
+ @template.url_for(@url_params).split(//).each_with_index do |char, i|
345
+ if char == '3' and url[i, 1] == '2'
346
+ @url_string[i] = "\0"
347
+ break
348
+ end
349
+ end
350
+ end
351
+ end
352
+ # finally!
353
+ @url_string.sub "\0", page.to_s
354
+ end
355
+
356
+ private
357
+
358
+ def rel_value(page)
359
+ case page
360
+ when @collection.previous_page; 'prev' + (page == 1 ? ' start' : '')
361
+ when @collection.next_page; 'next'
362
+ when 1; 'start'
363
+ end
364
+ end
365
+
366
+ def current_page
367
+ @collection.current_page
368
+ end
369
+
370
+ def total_pages
371
+ @total_pages ||= WillPaginate::ViewHelpers.total_pages_for_collection(@collection)
372
+ end
373
+
374
+ def param_name
375
+ @param_name ||= @options[:param_name].to_s
376
+ end
377
+
378
+ # Recursively merge into target hash by using stringified keys from the other one
379
+ def stringified_merge(target, other)
380
+ other.each do |key, value|
381
+ key = key.to_s # this line is what it's all about!
382
+ existing = target[key]
383
+
384
+ if value.is_a?(Hash) and (existing.is_a?(Hash) or existing.nil?)
385
+ stringified_merge(existing || (target[key] = {}), value)
386
+ else
387
+ target[key] = value
388
+ end
389
+ end
390
+ end
391
+
392
+ def parse_query_parameters(params)
393
+ if defined? Rack::Utils
394
+ # For Rails > 2.3
395
+ Rack::Utils.parse_nested_query(params)
396
+ elsif defined?(ActionController::AbstractRequest)
397
+ ActionController::AbstractRequest.parse_query_parameters(params)
398
+ elsif defined?(ActionController::UrlEncodedPairParser)
399
+ # For Rails > 2.2
400
+ ActionController::UrlEncodedPairParser.parse_query_parameters(params)
401
+ elsif defined?(CGIMethods)
402
+ CGIMethods.parse_query_parameters(params)
403
+ else
404
+ raise "unsupported ActionPack version"
405
+ end
406
+ end
407
+ end
408
+ end