pagy 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0479a6de6806589108454c59ca39a6446ee0d339c5b111c19eddb69fcd9a4285'
-  data.tar.gz: 26bf5f952a06f4f874ec489adb337207b1b7664a3be70f95440656b55dcbb189
+  metadata.gz: 45ce91ee38e0d07518e33c4f2a16cc19c65c2848193ad545fbec38ebee5be5d9
+  data.tar.gz: b340e01c042fbefd0874c88395a5c9a93e020dc422725d700a21ea996287b907
 SHA512:
-  metadata.gz: d7cee6202f84b11adff3f04edffb9a367bb881f391a9f7635e191ebef9231d10d94628f98ef11cdda279a79808003e90689d47881158ea26443319745dac470e
-  data.tar.gz: 410ce77476e24ec9f8069b4723824f69ec1f8966ddcc0e2989a79acfc56def0a53ef7b20383c393fbdaad32d93c503d7136b819d8503587a242c387fd062d73a
+  metadata.gz: e3639fa6a75f4204277281c49e0579dc02304a3e11d32029508b81e624dba6a494ad90af1440d15db884e84015282e61bd2e3497c7cb2354197dda95e037f452
+  data.tar.gz: b406ef5bad8f0bd50d2065ffce5c04673ad0858eb293337bdaa03057aa80abef014550279db963a27e757e1393de13fa7f77e8a350bb7a8c04d00c4784afe8c3

data/lib/locales/pagy.yml

@@ -18,7 +18,7 @@ en:
         zero: "No %{item_name} found"
         one: "Displaying <b>1</b> %{item_name}"
         other: "Displaying <b>all %{count}</b> %{item_name}"
-      multiple_pages: "Displaying %{item_name} <b>%{from}-%{to}</b> of <b>%{count}</b>"
+      multiple_pages: "Displaying %{item_name} <b>%{from}-%{to}</b> of <b>%{count}</b> in total"
       item:
         zero: "items"
         one: "item"

data/lib/pagy.rb

@@ -7,7 +7,7 @@ require 'ostruct'
 # Notice that it doesn't actually do any pagination, nor navigation... that is
 # done with a few helpers in the Pagy::Backend and Pagy::Frontend modules.
 
-class Pagy ; VERSION = '0.4.0'
+class Pagy ; VERSION = '0.4.1'
 
   autoload :Backend,  'pagy/backend'
   autoload :Frontend, 'pagy/frontend'
@@ -37,7 +37,7 @@ class Pagy ; VERSION = '0.4.0'
       instance_variable_set(:"@#{k}", @opts.delete(k))                    # set all the metrics variables
     end
     @pages   = @last = [(@count.to_f / @limit).ceil, 1].max               # cardinal and ordinal meanings
-    (1..@last).cover?(@page) || raise(OutOfRangeError, "expected :page in 1..#{last}; got #{@page.inspect}")
+    (1..@last).cover?(@page) || raise(OutOfRangeError, "expected :page in 1..#{@last}; got #{@page.inspect}")
     @offset += @limit * (@page - 1)                                       # initial offset + offset for pagination
     @limit   = @count % @limit if @page == @last                          # adjust limit for last page (for pre-limit(ed) collection)
     @from    = @count.zero? ? 0 : @offset+1                               # page begins from item
@@ -46,15 +46,15 @@ class Pagy ; VERSION = '0.4.0'
     @next    = (@page+1 unless @page == @last)                            # nil if no next page
     @series  = []                                                         # e.g. [1, :gap, 7, 8, "9", 10, 11, :gap, 36]
     all      = (0..@last+1)                                               # page range with boundaries
-    arund    = ([@page-@before, 1].max .. [@page+@after, @last].min).to_a # before..after pages
-    row      = (all.first(@initial+1) | arund | all.last(@final+1)).sort  # pages with boundaries
+    around   = ([@page-@before, 1].max .. [@page+@after, @last].min).to_a # before..after pages
+    row      = (all.first(@initial+1) | around | all.last(@final+1)).sort # row of pages with boundaries
     row.each_cons(2) do |a, b|                                            # loop in consecutive pairs
       if    a+1 == b; @series.push(a)                                     # no gap     -> no additions
-      elsif a+2 == b; @series.push(a, a+1)                                # 1 page gap -> fill with next page
-      else            @series.push(a, :gap)                               # larger gap -> add :gap
-      end                                                                 # skip the right boundary (last+1)
+      elsif a+2 == b; @series.push(a, a+1)                                # 1 page gap -> fill with missing page
+      else            @series.push(a, :gap)                               # n page gap -> add :gap
+      end                                                                 # skip the end-boundary (last+1)
     end
-    @series.shift                                                         # remove the left boundary (0)
+    @series.shift                                                         # remove the start-boundary (0)
     @series[@series.index(@page)] = @page.to_s                            # convert the current page to String
   end
 

data/lib/pagy/backend.rb

@@ -4,11 +4,11 @@ class Pagy
   # #pagy method, but it does not add any functionality on its own.
   #
   # Using the module allows you to have a predefined method and a few sub-methods
-  # (i.e. methods called only by the predefine method) handy if you need to override
+  # (i.e. methods called only by the predefined method) handy if you need to override
   # some aspect of the predefined #pagy method.
   #
   # However, you can just explicitly write your own pagy method in just a couple of
-  # lines of code, specially if you need to override two or more methods. For example:
+  # lines, specially if you need to override two or more methods. For example:
   #
   # def pagy(scope, opts={})
   #   pagy = Pagy.new scope.count, page: params[:page], **opts

data/lib/pagy/frontend.rb

@@ -5,82 +5,53 @@ class Pagy
   # in order to fit its behavior with your app needs (e.g.: removing and adding some param or
   # allowing fancy routes, etc.)
   #
-  # All the code has been optimized for speed and low memory usage.
-  # In particular there are a couple of very specialized methods (pagy_t and pagy_link_proc)
-  # that can be used in place of the equivalent (but general-purpose) framework helpers,
-  # in order to dramatically boost speed and reduce memory usage.
-  #
-  # For example if you use the rails link_to in order to link each page in the pagination bar,
-  # you will call 10 or 20 times the same method that has to do a lot of things again and again
-  # just to get you (almost) the same string repeated with just the page number replaced.
-  # Since pagination is a very specialized process, it is possible to do the same by using
-  # a one-line proc that uses just one single string interpolation. Compared to the general-purpose
-  # link_to method, the pagy_link_proc benchmark gives a 20 times faster score and 12 times less memory.
-  #
-  # Notice: The code in this module may not look very pretty (as most code dealing with many long strings),
-  # but its performance makes it very sexy! ;)
-
+  # All the code here has been optimized for performance: it may not look very pretty
+  # (as most code dealing with many long strings), but its performance makes it very sexy! ;)
   module Frontend
 
-    # Notice: Each long tag-string of the nav methods is written on one single line with a long
-    # interpolation in the middle for performance and... (hard to believe) readability reasons.
-    #
-    # Performance:
-    # using the '%' method like in the following example:
-    #
-    # case item
-    #   when Integer; '<span class="page">%s</span>'        % link.call(item)
-    #   when String ; '<span class="page active">%s</span>' % item
-    #   when :gap   ; '<span class="page gap">%s</span>'    % pagy_t('pagy.nav.gap')
-    # end
-    #
-    # would look a lot better but the benchmark really sucks! :/
-    #
-    # Readability:
-    # If you disable soft-wrapping in your editor, you can focus on the very simple ruby logic
-    # unfolding at the beginning of the lines, without any string-distraction.
-    # For the strings: each tag-string has only one interpolation, so at the end they are
-    # simple to deal with, even if they look a bit ugly.
-
     # Generic pagination: it returns the html with the series of links to the pages
     def pagy_nav(pagy, opts=nil)
-      pagy.opts.merge!(opts) if opts ; link = pagy_link_proc(pagy) ; tags = []  # init all vars
+      opts = opts ? pagy.opts.merge(opts) : pagy.opts
+      link = pagy_link_proc(pagy)
+      tags = []
 
       tags << (pagy.prev ? %(<span class="page prev">#{link.call pagy.prev, pagy_t('pagy.nav.prev'.freeze), 'aria-label="previous"'.freeze}</span>)
                          : %(<span class="page prev disabled">#{pagy_t('pagy.nav.prev'.freeze)}</span>))
       pagy.series.each do |item|  # series example: [1, :gap, 7, 8, "9", 10, 11, :gap, 36]
         tags << case item
-                  when Integer; %(<span class="page">#{link.call item}</span>)                  # page link
+                  when Integer; %(<span class="page">#{link.call item}</span>)                    # page link
                   when String ; %(<span class="page active">#{item}</span>)                       # current page
                   when :gap   ; %(<span class="page gap">#{pagy_t('pagy.nav.gap'.freeze)}</span>) # page gap
                 end
       end
       tags << (pagy.next ? %(<span class="page next">#{link.call pagy.next, pagy_t('pagy.nav.next'.freeze), 'aria-label="next"'.freeze}</span>)
                          : %(<span class="page next disabled">#{pagy_t('pagy.nav.next'.freeze)}</span>))
-      %(<nav class="#{pagy.opts[:class]||'pagination'.freeze}" role="navigation" aria-label="pager">#{tags.join(pagy.opts[:separator]||' '.freeze)}</nav>)
+      %(<nav class="#{opts[:class]||'pagination'.freeze}" role="navigation" aria-label="pager">#{tags.join(opts[:separator]||' '.freeze)}</nav>)
     end
 
 
     # Pagination for bootstrap: it returns the html with the series of links to the pages
     def pagy_nav_bootstrap(pagy, opts=nil)
-      pagy.opts.merge!(opts) if opts ; link = pagy_link_proc(pagy) ; tags = []  # init all vars
+      opts = opts ? pagy.opts.merge(opts) : pagy.opts
+      link = pagy_link_proc(pagy, 'class="page-link"'.freeze)
+      tags = []
 
-      tags << (pagy.prev ? %(<li class="page-item prev">#{link.call pagy.prev, pagy_t('pagy.nav.prev'.freeze), 'class="page-link" aria-label="previous"'.freeze}</li>)
+      tags << (pagy.prev ? %(<li class="page-item prev">#{link.call pagy.prev, pagy_t('pagy.nav.prev'.freeze), 'aria-label="previous"'.freeze}</li>)
                          : %(<li class="page-item prev disabled"><a href="#" class="page-link">#{pagy_t('pagy.nav.prev'.freeze)}</a></li>))
       pagy.series.each do |item| # series example: [1, :gap, 7, 8, "9", 10, 11, :gap, 36]
         tags << case item
-                  when Integer; %(<li class="page-item">#{link.call item, item, 'class="page-link"'.freeze}</li>)                           # page link
-                  when String ; %(<li class="page-item active">#{link.call item, item, 'class="page-link"'.freeze}</li>)                    # active page
+                  when Integer; %(<li class="page-item">#{link.call item}</li>)                                                               # page link
+                  when String ; %(<li class="page-item active">#{link.call item}</li>)                                                        # active page
                   when :gap   ; %(<li class="page-item gap disabled"><a href="#" class="page-link">#{pagy_t('pagy.nav.gap'.freeze)}</a></li>) # page gap
                 end
       end
-      tags << (pagy.next ? %(<li class="page-item next">#{link.call pagy.next, pagy_t('pagy.nav.next'.freeze), 'class="page-link" aria-label="next"'.freeze}</li>)
+      tags << (pagy.next ? %(<li class="page-item next">#{link.call pagy.next, pagy_t('pagy.nav.next'.freeze), 'aria-label="next"'.freeze}</li>)
                          : %(<li class="page-item next disabled"><a href="#" class="page-link">#{pagy_t('pagy.nav.next'.freeze)}</a></li>))
-      %(<nav class="#{pagy.opts[:class]||'pagination'.freeze}" role="navigation" aria-label="pager"><ul class="pagination">#{tags.join}</ul></nav>)
+      %(<nav class="#{opts[:class]||'pagination'.freeze}" role="navigation" aria-label="pager"><ul class="pagination">#{tags.join}</ul></nav>)
     end
 
 
-    # return examples: "Displaying items 41-60 of 324"  or "Displaying Products 41-60 of 324"
+    # return examples: "Displaying items 41-60 of 324 in total"  or "Displaying Products 41-60 of 324 in total"
     def pagy_info(pagy, vars=nil)
       name = vars && vars[:item_name] || pagy_t(pagy.opts[:i18n_key] || 'pagy.info.item'.freeze, count: pagy.count)
       name = pagy_t('pagy.info.item'.freeze, count: pagy.count) if name.start_with?('translation missing:'.freeze)
@@ -100,7 +71,7 @@ class Pagy
     # not needed (for example when your application is a single-locale app, e.g. only 'en', or only 'fr'...).
     #
     # It implements only the very basic functionality of the I18n.t method
-    # but it is a lot faster, it uses less memory and it's still good enough for the limited Pagy's needs.
+    # but it's still good enough for the limited Pagy's needs and it is faster.
     #
     # You can still use this method with a pluralization different than English
     # (i.e. not 'zero', 'one', 'other' plurals). In that case you should define the
@@ -111,14 +82,14 @@ class Pagy
     # and add your translations to the I18n usual locales files
 
     hash = YAML.load_file Opts.i18n_file || Pagy.root.join('locales', 'pagy.yml')
-    DATA = hash[hash.keys.first].freeze
+    I18N = hash[hash.keys.first].freeze
 
     # Similar to I18n.t for interpolation and pluralization, with the following constraints:
     # - the path/keys option is supported only in dot-separated string or symbol format
     # - the :scope and :default options are not supported
     # - no exception are raised: the errors are returned as translated strings
     def pagy_t(path, vars={})
-      value = DATA.dig(*path.to_s.split('.'.freeze))
+      value = I18N.dig(*path.to_s.split('.'.freeze))
       if value.is_a?(Hash)
         vars.has_key?(:count) or return value
         plural = (Opts.i18n_plurals ||= -> (c) {c==0 && 'zero' || c==1 && 'one' || 'other'}).call(vars[:count])
@@ -129,26 +100,63 @@ class Pagy
       sprintf value, Hash.new{|h,k| "%{#{k}}"}.merge!(vars)    # interpolation
     end
 
-    # This method returns a very efficient proc to produce the page links.
-    # The proc is somewhat similar to link_to, but it works a lot faster
-    # with a simple one-string-only interpolation.
-    # The proc also adds the eventual :link_extra string option to the link tag
+    # NOTICE: This method is used internally, so you need to know about it only if you
+    # are going to override a *_nav helper or a template AND changing the link tags.
+    #
+    # You call this method in order to get a proc that you will call to produce the page links.
+    # The reasaon it is a 2 step process instead of a single method call is performance.
+    #
+    # Call the method to get the proc (once):
+    #   link = pagy_link_proc( pagy [, extra_attributes_string ])
+    #
+    # Call the proc to get the links (multiple times):
+    #   link.call( page_number [, label [, extra_attributes_string ]])
+    #
+    # You can pass extra attribute strings to get inserted in the link tags at many different levels.
+    # Depending by the scope you want your attributes to be added, (from wide to narrow) you can:
+    #
+    # 1. For all pagy objects: set the global option :link_extra:
+    #
+    #     Pagy::Opts.extra_link = 'data-remote="true"'
+    #     link.call(page_number=2)
+    #     #=> <a href="...?page=2" data-remote="true">2</a>
+    #
+    # 2. For one pagy object: pass a :link_extra option to a pagy constructor (Pagy.new or pagy controller method):
+    #
+    #     @pagy, @records = pagy(my_scope, extra_link: 'data-remote="true"')
+    #     link.call(page_number)
+    #     #=> <a href="...?page=2" data-remote="true">2</a>
+    #
+    # 3. For one pagy_nav render: pass a :link_extra option to a *_nav method:
+    #
+    #      pagy_nav(@pagy,  extra_link: 'data-remote="true"')   #
+    #      link.call(page_number)
+    #      #=> <a href="...?page=2" data-remote="true">2</a>
+    #
+    # 4. For all the calls to the returned pagy_link_proc: pass an extra attributes string when you get the proc:
+    #
+    #      link = pagy_link_proc(pagy, 'class="page-link"')
+    #      link.call(page_number)
+    #      #=> <a href="...?page=2" data-remote="true" class="page-link">2</a>
+    #
+    # 5. For a single link.call: pass an extra attributes string  when you call the proc:
     #
-    # Notice: all the rendering methods in this module use only strings for fast performance,
-    # so use the :link_extra option to add string-formatted attributes like for example:
-    # :link_extra => 'data-remote="true" class="special"'
+    #      link.call(page_number, 'aria-label="my-label"')
+    #      #=> <a href="...?page=2" data-remote="true" class="page-link" aria-label="my-label">2</a>
     #
-    # This method calls the (possibly overridden and slow) pagy_url_for only once to get the url
-    # with the MARKER in place of the page number, then it splits the beginning tag-string at the MARKER
-    # and defines a proc that interpolates the two fragments around the real page number with the rest of the tag.
-    # Tricky but very fast!
+    # WARNING: since we use only strings for performance, the attribute strings get concatenated, not merged!
+    # Be careful not to pass the same attribute at different levels multiple times. That would generate a duplicated
+    # attribute which is illegal html (although handled by all mayor browsers by ignoring all the duplicates but the first)
 
     MARKER = "-pagy-#{'pagy'.hash}-".freeze
 
-    def pagy_link_proc(pagy)
-      rel  = { pagy.prev=>' rel="prev"'.freeze, pagy.next=>' rel="next"'.freeze }
-      a, b = %(<a href="#{pagy_url_for(MARKER)}" #{pagy.opts[:link_extra]}).split(MARKER)
-      -> (n, name=n.to_s, extra=''.freeze) { "#{a}#{n}#{b}#{rel[n]||''.freeze} #{extra}>#{name}</a>"}
+    def pagy_link_proc(pagy, lx=''.freeze)  # link extra
+      p_prev, p_next, p_lx = pagy.prev, pagy.next, pagy.opts[:link_extra]
+      a, b = %(<a href="#{pagy_url_for(MARKER)}"#{p_lx ? %( #{p_lx}) : ''.freeze}#{lx.empty? ? lx : %( #{lx})}).split(MARKER)
+      -> (n, text=n, x=''.freeze) { "#{a}#{n}#{b}#{ if    n == p_prev; ' rel="prev"'.freeze
+                                                    elsif n == p_next; ' rel="next"'.freeze
+                                                    else                          ''.freeze
+                                                    end }#{x.empty? ? x : %( #{x})}>#{text}</a>" }
     end
 
   end

data/lib/templates/bootstrap.html.erb

@@ -2,39 +2,31 @@
   This template is i18n-ready: if you don't use i18n, then you can replace the pagy_t
   calls with the actual strings ("‹ Prev", "Next ›", "…").
 
-  This template uses the pagy_link_proc helper for high speed (+20x) and low memory (-12x).
-  Usage: link.call(page_number[, label[,extra_attributes_string]])
+  The link variable is set to a proc that returns the link tag.
+  Usage: link.call( page_number [, text [, extra_attributes_string ]])
 -%>
-<% link = pagy_link_proc(pagy) %>
-
+<% link = pagy_link_proc(pagy, 'class="page-link"') -%>
 <nav aria-label="pager"  class="pagination" role="navigation">
   <ul class="pagination">
-
     <% if pagy.prev -%>
-      <li class="page-item prev"><%== link.call(pagy.prev, pagy_t('pagy.nav.prev'), 'class="page-link" aria-label="previous"') %></li>
+      <li class="page-item prev"><%== link.call(pagy.prev, pagy_t('pagy.nav.prev'), 'aria-label="previous"') %></li>
     <% else -%>
       <li class="page-item prev disabled"><a href="#" class="page-link"><%== pagy_t('pagy.nav.prev') %></a></li>
     <% end -%>
-
     <% pagy.series.each do |item| # series example: [1, :gap, 7, 8, "9", 10, 11, :gap, 36] -%>
       <% case item
            when Integer    # page link -%>
-          <li class="page-item"><%== link.call(item, item, 'class="page-link"') %></li>
-
+          <li class="page-item"><%== link.call(item) %></li>
         <% when String     # current page -%>
-          <li class="page-item active"><%== link.call(item, item, 'class="page-link"') %></li>
-
+          <li class="page-item active"><%== link.call(item) %></li>
         <% when :gap       # page gap -%>
           <li class="page-item disabled gap"><a href="#" class="page-link"><%== pagy_t('pagy.nav.gap') %></a></li>
-
       <% end -%>
     <% end -%>
-
     <% if pagy.next -%>
-      <li class="page-item next"><%== link.call(pagy.next, pagy_t('pagy.nav.next'), 'class="page-link" aria-label="next"') %></li>
+      <li class="page-item next"><%== link.call(pagy.next, pagy_t('pagy.nav.next'), 'aria-label="next"') %></li>
     <% else -%>
       <li class="page-item next disabled"><a href="#" class="page-link"><%== pagy_t('pagy.nav.next') %></a></li>
     <% end -%>
-
   </ul>
 </nav>

data/lib/templates/bootstrap.html.haml

@@ -1,17 +1,17 @@
 -# This template is i18n-ready: if you don't use i18n, then you can replace the pagy_t
 -# calls with the actual strings ("‹ Prev", "Next ›", "…").
 
--# This template uses the pagy_link_proc helper for high speed (+20x) and low memory (-12x).
--# Usage: link.call(page_number[, label[,extra_attributes_string]])
+-# The link variable is set to a proc that returns the link tag.
+-# Usage: link.call( page_number [, text [, extra_attributes_string ]])
 
-- link = pagy_link_proc(pagy)
+- link = pagy_link_proc(pagy, 'class="page-link"')
 
 %nav.pagination{"aria-label" => "pager", :role => "navigation"}
 
   %ul.pagination
 
     - if pagy.prev
-      %li.page-item.prev!= link.call(pagy.prev, pagy_t('pagy.nav.prev'), 'class="page-link" aria-label="previous"')
+      %li.page-item.prev!= link.call(pagy.prev, pagy_t('pagy.nav.prev'), 'aria-label="previous"')
     - else
       %li.page-item.prev.disabled
         %a.page-link{:href => '#'}!= pagy_t('pagy.nav.prev')
@@ -19,17 +19,17 @@
     - pagy.series.each do |item| # series example: [1, :gap, 7, 8, "9", 10, 11, :gap, 36]
       - case item
         - when Integer           # page link
-          %li.page-item!= link.call(item, item, 'class="page-link"')
+          %li.page-item!= link.call(item)
 
         - when String            # current page
-          %li.page-item.active!= link.call(item, item, 'class="page-link"')
+          %li.page-item.active!= link.call(item)
 
         - when :gap              # page gap
           %li.page-item.disabled.gap
             %a.page-link{:href => "#"}!= pagy_t('pagy.nav.gap')
 
     - if pagy.next
-      %li.page-item.next!= link.call(pagy.next, pagy_t('pagy.nav.next'), 'class="page-link" aria-label="next"')
+      %li.page-item.next!= link.call(pagy.next, pagy_t('pagy.nav.next'), 'aria-label="next"')
     - else
       %li.page-item.next.disabled
         %a.page-link{:href => '#'}!= pagy_t('pagy.nav.next')

data/lib/templates/bootstrap.html.slim

@@ -1,17 +1,17 @@
 / This template is i18n-ready: if you don't use i18n, then you can replace the pagy_t
 / calls with the actual strings ("‹ Prev", "Next ›", "…").
 
-/ This template uses the pagy_link_proc helper for high speed (+20x) and low memory (-12x).
-/ Usage: link.call(page_number[, label[,extra_attributes_string]])
+/ The link variable is set to a proc that returns the link tag.
+/ Usage: link.call( page_number [, text [, extra_attributes_string ]])
 
-- link = pagy_link_proc(pagy)
+- link = pagy_link_proc(pagy, 'class="page-link"')
 
 nav.pagination role="navigation" aria-label="pager"
 
   ul.pagination
 
     - if pagy.prev
-      li.page-item.prev == link.call(pagy.prev, pagy_t('pagy.nav.prev'), 'class="page-link" aria-label="previous"')
+      li.page-item.prev == link.call(pagy.prev, pagy_t('pagy.nav.prev'), 'aria-label="previous"')
     - else
       li.page-item.prev.disabled
         a.page-link href="#" == pagy_t('pagy.nav.prev')
@@ -20,17 +20,17 @@ nav.pagination role="navigation" aria-label="pager"
       - case item
 
         - when Integer # page link
-          li.page-item == link.call(item, item, 'class="page-link"')
+          li.page-item == link.call(item)
 
         - when String # current page
-          li.page-item.active == link.call(item, item, 'class="page-link"')
+          li.page-item.active == link.call(item)
 
         - when :gap # page gap
           li.page-item.disabled.gap
             a.page-link href="#" == pagy_t('pagy.nav.gap')
 
     - if pagy.next
-      li.page-item.next == link.call(pagy.next, pagy_t('pagy.nav.next'), 'class="page-link" aria-label="next"')
+      li.page-item.next == link.call(pagy.next, pagy_t('pagy.nav.next'), 'aria-label="next"')
     - else
       li.page-item.next.disabled
         a.page-link href="#" == pagy_t('pagy.nav.next')

data/lib/templates/default.html.erb

@@ -2,38 +2,29 @@
   This template is i18n-ready: if you don't use i18n, then you can replace the pagy_t
   calls with the actual strings ("‹ Prev", "Next ›", "…").
 
-  This template uses the pagy_link_proc helper for high speed (+20x) and low memory (-12x).
-  Usage: link.call(page_number[, label[,extra_attributes_string]])
--%>
+  The link variable is set to a proc that returns the link tag.
+  Usage: link.call( page_number [, text [, extra_attributes_string ]])
+ -%>
 <% link = pagy_link_proc(pagy) -%>
-
 <nav aria-label="pager" class="pagination" role="navigation">
-
   <% if pagy.prev -%>
     <span class="page prev"><%== link.call(pagy.prev, pagy_t('pagy.nav.prev'), 'aria-label="previous"') %></span>
   <% else -%>
     <span class="page prev disabled"><%== pagy_t('pagy.nav.prev') %></span>
   <% end -%>
-
   <% pagy.series.each do |item| # series example: [1, :gap, 7, 8, "9", 10, 11, :gap, 36] -%>
     <% case item
-
        when Integer      # page link -%>
         <span class="page"><%== link.call(item) %></span>
-
       <% when String     # current page -%>
         <span class="page current"><%= item %></span>
-
       <% when :gap       # page gap -%>
         <span class="page gap"><%== pagy_t('pagy.nav.gap') %></span>
-
     <% end -%>
   <% end -%>
-
   <% if pagy.next -%>
     <span class="page next"><%== link.call(pagy.next, pagy_t('pagy.nav.next'), 'aria-label="next"') %></span>
   <% else -%>
     <span class="page next disabled"><%== pagy_t('pagy.nav.next') %></span>
   <% end -%>
-
 </nav>

data/lib/templates/default.html.haml

@@ -1,8 +1,8 @@
 -# This template is i18n-ready: if you don't use i18n, then you can replace the pagy_t
 -# calls with the actual strings ("‹ Prev", "Next ›", "…").
 
--# This template uses the pagy_link_proc helper for high speed (+20x) and low memory (-12x).
--# Usage: link.call(page_number[, label[,extra_attributes_string]])
+-# The link variable is set to a proc that returns the link tag.
+-# Usage: link.call( page_number [, text [, extra_attributes_string ]])
 
 - link = pagy_link_proc(pagy)
 

data/lib/templates/default.html.slim

@@ -1,8 +1,8 @@
 / This template is i18n-ready: if you don't use i18n, then you can replace the pagy_t
 / calls with the actual strings ("‹ Prev", "Next ›", "…").
 
-/ This template uses the pagy_link_proc helper for high speed (+20x) and low memory (-12x).
-/ Usage: link.call(page_number[, label[,extra_attributes_string]])
+/ The link variable is set to a proc that returns the link tag.
+/ Usage: link.call( page_number [, text [, extra_attributes_string ]])
 
 - link = pagy_link_proc(pagy)
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pagy
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Domizio Demichelis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-15 00:00:00.000000000 Z
+date: 2018-02-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler