pagy 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b23ad1b8bfd60d555fd55e0b5534c34b29055447c41116454f73892ffc7eef73
+  data.tar.gz: 0a8d532508344459576ab5d3c89e772ef0ee626cd3671d56fa21b611815f8d11
+SHA512:
+  metadata.gz: d035e9a3319e63353dd743ef0da6c05b995f5f66c5effea233cdecb52bae17bee7f50730a18ed4ccda818b0e29b52ab79db48e37db9f7dfe9c719908c6ebd1b8
+  data.tar.gz: d487d610feef6697c625677d4332b474a3f8876a434edfcefa321c371838ef6552ad7bc246cbcb0a5340dc55302d4d9f728032e823ce964c04cc09a577817a04

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017-2018 Domizio Demichelis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,31 @@
+# Pagy
+
+Dead simple pagination in pure ruby. Easy, fast and very light. No restrictions imposed: use it with any MVC framework, any ORM, any DB type, any templating system or none at all. Use the built-in templates or create yours the way you want.
+
+## Alpha Version!
+
+This gem is still missing documentation. TBD... soon ;).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'pagy'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install pagy
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ddnexus/pagy.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/locales/pagy.yml

@@ -0,0 +1,25 @@
+# Pagy uses an internal I18n-like :pagy_t helper that lookup
+# into this file at Pagy.root.join('locale', 'pagy.yml')
+# If you want to customize it you should set:
+# Pagy::Opts.i18n_file = 'path/to/your/file.yaml'
+
+# If you need to use this method with pluralization different than english
+# (i.e. not 'zero', 'one', 'other' plurals) then you should define the
+# Pagy::Opts.i18n_plurals proc to return the plural key based on the passed count.
+
+en:
+  pagy:
+    nav:
+      prev: "‹ Prev"
+      next: "Next ›"
+      gap: "…"
+    info:
+      single_page:
+        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>"
+      item:
+        zero: "items"
+        one: "item"
+        other: "items"

data/lib/pagy/backend.rb

@@ -0,0 +1,42 @@
+class Pagy
+  # Including this module (usually in your controller) is handy but totally optional.
+  # It basically just encapsulates a couple of verbose statement in one single slick
+  # #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
+  # 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:
+  #
+  # def pagy(scope, opts={})
+  #   pagy = Pagy.new scope.count, page: params[:page], **opts
+  #   return pagy, scope.offset(pagy.offset).limit(pagy.limit)
+  # end
+
+  module Backend ; private         # the whole module is private so no problem including it in a controller
+
+    def pagy(obj, opts={})
+      pagy = Pagy.new(count: pagy_get_count(obj), page: pagy_get_page, i18n_key: pagy_get_i18n_key(obj), **opts)
+      return pagy, pagy_get_items(obj, pagy)
+    end
+
+    def pagy_get_count(obj)
+      obj.count
+    end
+
+    def pagy_get_page
+      params[:page]
+    end
+
+    def pagy_get_i18n_key(obj) end
+
+    # this should work with ActiveRecord, Sequel, Mongoid...
+    # override it if obj does not implement it that way
+    def pagy_get_items(obj, pagy)
+      obj.offset(pagy.offset).limit(pagy.limit)
+    end
+
+  end
+end

data/lib/pagy/frontend.rb

@@ -0,0 +1,155 @@
+require 'yaml'
+class Pagy
+  # This module supplies a few methods to deal with the navigation aspect of the pagination.
+  # You will usually include it in some helper module, eventually overriding the #pagy_url_for
+  # 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_linker_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_linker_proc is tens of times faster and uses a very small fraction of the 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! ;)
+
+  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>'        % linker.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 ; linker = pagy_linker_proc(pagy) ; tags = []  # init all vars
+
+      tags << (pagy.prev ? %(<span class="page prev">#{linker.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">#{linker.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">#{linker.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>)
+    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 ; linker = pagy_linker_proc(pagy) ; tags = []  # init all vars
+
+      tags << (pagy.prev ? %(<li class="page-item prev">#{linker.call pagy.prev, pagy_t('pagy.nav.prev'.freeze), 'class="page-link" 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">#{linker.call item, item, 'class="page-link"'.freeze}</li>)                           # page link
+                  when String ; %(<li class="page-item active">#{linker.call item, item, 'class="page-link"'.freeze}</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">#{linker.call pagy.next, pagy_t('pagy.nav.next'.freeze), 'class="page-link" 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>)
+    end
+
+
+    # return examples: "Displaying items 41-60 of 324"  or "Displaying Products 41-60 of 324"
+    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)
+      key  = pagy.pages == 1 ? 'single_page'.freeze : 'multiple_pages'.freeze
+      pagy_t "pagy.info.#{key}", item_name: name, count: pagy.count, from: pagy.from, to: pagy.to
+    end
+
+
+    # this works with all Rack-based frameworks (Sinatra, Padrino, Rails, ...)
+    def pagy_url_for(n)
+      url    = File.join(request.script_name.to_s, request.path_info)
+      params = request.GET.merge('page' => n.to_s)
+      url << '?' << Rack::Utils.build_nested_query(params)
+    end
+
+    # The :pagy_t method is the internal implementation of I18n.t, used when I18n is missing or
+    # 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.
+    #
+    # 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
+    # Pagy::Opts.i18n_plurals proc to return the plural key based on the passed count.
+    #
+    # If you need full I18n functionality, you should override this method with something like:
+    #    def pagy_t(*a); I18n.t(*a) end
+    # 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
+
+    # 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))
+      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])
+        value.has_key?(plural) or return %(invalid pluralization data: "#{path}" cannot be used with count: #{vars[:count]}; key "#{plural}" is missing.)
+        value = value[plural]
+      end
+      value or return %(translation missing: "#{path}")
+      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: 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"'
+    #
+    # 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!
+
+    MARKER = "-pagy-#{'pagy'.hash}-".freeze
+
+    def pagy_linker_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>"}
+    end
+
+  end
+end

data/lib/pagy.rb

@@ -0,0 +1,61 @@
+require 'pathname'
+require 'ostruct'
+
+# This class takes a few integers (such as collection-count, page-number,
+# items-per-page-limit, etc.), does some simple aritmetic and creates a very
+# small object (~3k) with all is needed for pagination and navigation.
+# 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.3.0'
+
+  autoload :Backend,  'pagy/backend'
+  autoload :Frontend, 'pagy/frontend'
+
+  class OutOfRangeError < StandardError; end
+
+  # root pathname to get the path of pagy files like templates or locales
+  def self.root; Pathname.new(__FILE__).dirname end
+
+  # default options
+  # limit:         max items per page: it gets adjusted for the last page,
+  #                so it will pull the right items if the collection was pre-limit(ed)
+  # offset:        the initial offset of the whole collection before pagination
+  #                set it only if the collection was pre-offset(ted): it gets added to the final offset
+  # initial/final: max pages to show from the first/last page
+  # before/after:  max pages before/after the current page
+  Opts = OpenStruct.new(limit:20, offset:0, initial:1, before:4, after:4, final:1)
+
+  attr_reader :count, :page, :limit, :opts, :pages, :last, :offset, :from, :to, :prev, :next, :series
+
+  # merge and validate the options, do some simple aritmetic and set the instance variables
+  def initialize(opts)
+    @opts        = Opts.to_h.merge!(opts)                                 # global opts + instance opts (bang faster)
+    @opts[:page] = (@opts[:page]||1).to_i                                 # set page to 1 if nil
+    [:count, :limit, :offset, :initial, :before, :page, :after, :final].each do |k|
+      @opts[k] >= 0 rescue nil || raise(ArgumentError, "expected #{k} >= 0; got #{@opts[k].inspect}")
+      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}")
+    @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
+    @to      = @offset + @limit                                           # page ends to item
+    @prev    = (@page-1 unless @page == 1)                                # nil if no prev page
+    @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
+    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)
+    end
+    @series.shift                                                         # remove the left boundary (0)
+    @series[@series.index(@page)] = @page.to_s                            # convert the current page to String
+  end
+
+end

data/lib/templates/bootstrap-no-dep.html.haml

@@ -0,0 +1,28 @@
+-# This template uses only the pagy_url_for helper, no dependency on any framework
+-# No special optimization for speed and memory. Use the pagy helpers if speed and memory are important.
+
+- rel = { pagy.prev => 'prev', pagy.next => 'next' }
+
+%nav.pagination{"aria-label" => "pager", :role => "navigation"}
+
+  %ul.pagination
+
+    %li.page-item.prev{:class => ('disabled' unless pagy.prev)}
+      %a.page-link{:href => (pagy.prev ? pagy_url_for(pagy.prev) : '#'), :rel => "prev", "aria-label"=>"previous"}!= pagy_t('pagy.nav.prev')
+
+    - 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
+            %a.page-link{:href => pagy_url_for(item), :rel => rel[item]}= item
+
+        - when String # current page
+          %li.page-item.active
+            %a.page-link{:href => pagy_url_for(item)}= item
+
+        - when :gap # page gap
+          %li.page-item.disabled.gap
+            %a.page-link{:href => "#"}!= pagy_t('pagy.nav.gap')
+
+    %li.page-item.next{:class => ('disabled' unless pagy.next)}
+      %a.page-link{:href => (pagy.next ? pagy_url_for(pagy.next) : '#'), :rel => "next", "aria-label"=>"next"}!= pagy_t('pagy.nav.next')

data/lib/templates/bootstrap-no-dep.html.slim

@@ -0,0 +1,37 @@
+/ This template uses only the pagy_url_for helper, no dependency on any framework
+/ No special optimization for speed and memory. Use the pagy helpers if speed and memory are important.
+
+- rel = { pagy.prev => 'prev', pagy.next => 'next' }
+
+nav.pagination role="navigation" aria-label="pager"
+
+  ul.pagination
+
+    - if pagy.prev
+      li.page-item.prev
+        a.page-link href=pagy_url_for(pagy.prev) rel="prev" aria-label="previous" == pagy_t('pagy.nav.prev')
+    - else
+      li.page-item.prev.disabled
+        a.page-link href="#" == pagy_t('pagy.nav.prev')
+
+    - 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
+            a.page-link href=(pagy_url_for(item)) rel=(rel[item]) == item
+
+        - when String # current page
+          li.page-item.active
+            a.page-link href=(pagy_url_for(item)) == 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
+        a.page-link href=pagy_url_for(pagy.next) rel="next" aria-label="next" == pagy_t('pagy.nav.next')
+    - else
+      li.page-item.next.disabled
+        a.page-link href="#" == pagy_t('pagy.nav.next')

data/lib/templates/bootstrap-rails-dep.html.erb

@@ -0,0 +1,46 @@
+<%#
+  This template uses only the pagy_url_for helper from pagy and link_to from rails
+  No special optimization for speed and memory. Use the pagy helpers if speed and memory are important.
+-%>
+<% rel = { pagy.prev => 'prev', pagy.next => 'next' } %>
+
+<nav aria-label="pager"  class="pagination" role="navigation">
+  <ul class="pagination">
+
+    <% if pagy.prev -%>
+      <li class="page-item prev">
+        <%= link_to pagy_t('pagy.nav.prev').html_safe, pagy_url_for(pagy.prev), rel: 'prev', class: 'page-link', 'aria-label': "previous" %>
+      </li>
+    <% else -%>
+      <li class="page-item prev disabled">
+        <%= link_to pagy_t('pagy.nav.prev').html_safe, pagy_url_for('#'), class: 'page-link'%>
+      </li>
+    <% end -%>
+
+
+    <% pagy.series.each do |item| # series example: [1, :gap, 7, 8, "9", 10, 11, :gap, 36] -%>
+      <% case item
+           when Integer -%>
+          <li class="page-item"><%== link_to item, pagy_url_for(item), rel: rel[item], class: 'page-link' %></li>
+
+        <% when String -%>
+          <li class="page-item active"><%== link_to item, pagy_url_for(item), class: 'page-link'%></li>
+
+        <% when :gap -%>
+          <li class="page-item disabled gap"><%== link_to pagy_t('pagy.nav.gap').html_safe, '#', class: 'page-link'%></li>
+
+      <% end -%>
+    <% end -%>
+
+    <% if pagy.next -%>
+      <li class="page-item next">
+        <%= link_to pagy_t('pagy.nav.next').html_safe, pagy_url_for(pagy.next), rel: 'next', class: 'page-link', 'aria-label': "next" %>
+      </li>
+    <% else -%>
+      <li class="page-item next disabled">
+        <%= link_to pagy_t('pagy.nav.next').html_safe, pagy_url_for('#'), class: 'page-link'%>
+      </li>
+    <% end -%>
+
+  </ul>
+</nav>

data/lib/templates/default-no-dep.html.haml

@@ -0,0 +1,31 @@
+-# This template uses only the pagy_url_for helper, no dependency on any framework
+-# No special optimization for speed and memory. Use the pagy helpers if speed and memory are important.
+
+- rel = { pagy.prev => 'prev', pagy.next => 'next' }
+
+%nav.pagination{"aria-label" => "pager", :role => "navigation"}
+
+  %span{:class => "page prev #{'disabled' unless pagy.prev}"}
+    - if pagy.prev
+      %a{:href => pagy_url_for(pagy.prev), :rel => "prev", "aria-label"=>"previous"}!= pagy_t('pagy.nav.prev')
+    - else
+      != pagy_t('pagy.nav.prev')
+
+  - pagy.series.each do |item| # series example: [1, :gap, 7, 8, "9", 10, 11, :gap, 36]
+    - case item
+
+      - when Integer        # page link
+        %span.page
+          %a{:href => pagy_url_for(item), :rel => rel[item]}= item
+
+      - when String         # current page
+        %span.page.current= item
+
+      - when :gap           # page gap
+        %span.page.gap!= pagy_t('pagy.nav.gap')
+
+  %span{:class => "page next #{'disabled' unless pagy.next}"}
+    - if pagy.next
+      %a{:href => pagy_url_for(pagy.next), :rel => "next", "aria-label"=>"next"}!= pagy_t('pagy.nav.next')
+    - else
+      != pagy_t('pagy.nav.next')

data/lib/templates/default-no-dep.html.slim

@@ -0,0 +1,30 @@
+/ This template uses only the pagy_url_for helper, no dependency on any framework
+/ No special optimization for speed and memory. Use the pagy helpers if speed and memory are important.
+
+- rel = { pagy.prev => 'prev', pagy.next => 'next' }
+
+nav.pagination role="navigation" aria-label="pager"
+
+  span.page.prev> class=('disabled' unless pagy.prev)
+    - if pagy.prev
+      a href=(pagy_url_for(pagy.prev)) rel="prev" aria-label="previous" == pagy_t('pagy.nav.prev')
+    - else
+      == pagy_t('pagy.nav.prev')
+
+  - pagy.series.each do |item|      # series example: [1, :gap, 7, 8, "9", 10, 11, :gap, 36]
+    - case item
+      - when Integer     # page link
+        span.page>
+          a href=(pagy_url_for(item)) rel=(rel[item]) == item
+
+      - when String      # current page
+        span.page.current ==> item
+
+      - when :gap        # page gap
+        span.page.gap ==> pagy_t('pagy.nav.gap')
+
+  span.page.next class=('disabled' unless pagy.next)
+    - if pagy.next
+      a href=(pagy_url_for(pagy.next)) rel="next" aria-label="next" == pagy_t('pagy.nav.next')
+    - else
+      == pagy_t('pagy.nav.next')

data/lib/templates/default-rails-dep.html.erb

@@ -0,0 +1,32 @@
+<%#
+  This template uses only the pagy_url_for helper from pagy and link_to/link_to_if from rails
+  No special optimization for speed and memory. Use the pagy helpers if speed and memory are important.
+-%>
+<% rel = { pagy.prev => 'prev', pagy.next => 'next' } %>
+
+<nav aria-label="pager" class="pagination" role="navigation">
+
+  <span class="page prev <%= 'disabled' unless pagy.prev %>">
+    <%= link_to_if pagy.prev, pagy_t('pagy.nav.prev').html_safe, pagy_url_for(pagy.prev), rel: 'prev', 'aria-label': "previous" %>
+  </span>
+
+  <% pagy.series.each do |item| # series example: [1, :gap, 7, 8, "9", 10, 11, :gap, 36] -%>
+    <% case item
+
+       when Integer -%>
+        <span class="page"><%= link_to item, pagy_url_for(item), rel: rel[item] %></span>
+
+      <% when String  -%>
+        <span class="page current"><%= item %></span>
+
+      <% when :gap    -%>
+        <span class="page gap"><%== pagy_t('pagy.nav.gap') %></span>
+
+    <% end -%>
+  <% end -%>
+
+  <span class="page next <%= 'disabled' unless pagy.next %>">
+    <%= link_to_if pagy.next, pagy_t('pagy.nav.next').html_safe, pagy_url_for(pagy.next), rel: 'next', 'aria-label': "next"  %>
+  </span>
+
+</nav>

data/lib/templates/default-rails-dep.html.haml

@@ -0,0 +1,24 @@
+-# This template uses only the pagy_url_for helper from pagy and link_to/link_to_if from rails
+-# No special optimization for speed and memory. Use the pagy helpers if speed and memory are important.
+
+- rel = { pagy.prev => 'prev', pagy.next => 'next' }
+
+%nav.pagination{"aria-label" => "pager", :role => "navigation"}
+
+  %span{:class => "page prev #{'disabled' unless pagy.prev}"}
+    = link_to_if pagy.prev, pagy_t('pagy.nav.prev').html_safe, pagy_url_for(pagy.prev), rel: 'prev', 'aria-label': "previous"
+
+  - pagy.series.each do |item| # series example: [1, :gap, 7, 8, "9", 10, 11, :gap, 36]
+    - case item
+
+      - when Integer        # page link
+        %span.page= link_to item, pagy_url_for(item), rel: rel[item]
+
+      - when String         # current page
+        %span.page.current= item
+
+      - when :gap           # page gap
+        %span.page.gap!= pagy_t('pagy.nav.gap')
+
+  %span{:class => "page next #{'disabled' unless pagy.next}"}
+    = link_to_if pagy.next, pagy_t('pagy.nav.next').html_safe, pagy_url_for(pagy.next), rel: 'next', 'aria-label': "next"

data/lib/templates/default-rails-dep.html.slim

@@ -0,0 +1,23 @@
+/ This template uses only the pagy_url_for helper from pagy and link_to/link_to_if from rails
+/ No special optimization for speed and memory. Use the pagy helpers if speed and memory are important.
+
+- rel = { pagy.prev => 'prev', pagy.next => 'next' }
+
+nav.pagination role="navigation" aria-label="pager"
+
+  span.page.prev> class=('disabled' unless pagy.prev)
+    == link_to_if pagy.prev, pagy_t('pagy.nav.prev').html_safe, pagy_url_for(pagy.prev), rel: 'prev', 'aria-label': "previous"
+
+  - pagy.series.each do |item|      # series example: [1, :gap, 7, 8, "9", 10, 11, :gap, 36]
+    - case item
+      - when Integer     # page link
+        span.page ==> link_to item, pagy_url_for(item), rel: rel[item]
+
+      - when String      # current page
+        span.page.current ==> item
+
+      - when :gap        # page gap
+        span.page.gap ==> pagy_t('pagy.nav.gap')
+
+  span.page.next class=('disabled' unless pagy.next)
+    == link_to_if pagy.next, pagy_t('pagy.nav.next').html_safe, pagy_url_for(pagy.next), rel: 'next', 'aria-label': "next"

data/pagy.gemspec

@@ -0,0 +1,32 @@
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pagy'
+require 'date'
+
+Gem::Specification.new do |s|
+  s.name          = 'pagy'
+  s.version       = Pagy::VERSION
+  s.authors       = ['Domizio Demichelis']
+  s.email         = ['dd.nexus@gmail.com']
+  s.date          = Date.today.to_s
+
+  s.summary       = %q{Because pagination should not suck!}
+  s.description   = %q{Dead simple pagination in pure ruby. Easy, fast and very light. No restrictions imposed: use it with any MVC framework, any ORM, any DB type, any templating system or none at all. Use the built-in templates or create yours the way you want.}
+  s.homepage      = 'https://github.com/ddnexus/pagy'
+  s.license       = 'MIT'
+  s.require_paths = ['lib']
+
+  s.files         = `git ls-files -z`.split("\x0")
+                                     .reject{|f| f.start_with? '.', 'test', 'Gemfile', 'Rakefile' }
+
+  s.add_development_dependency 'bundler',  '~> 1.16'
+  s.add_development_dependency 'rake',     '~> 10.0'
+  s.add_development_dependency 'minitest', '~> 5.0'
+  s.add_development_dependency 'slim'
+  s.add_development_dependency 'haml'
+  s.add_development_dependency 'benchmark-ips'
+  s.add_development_dependency 'kalibera'
+  s.add_development_dependency 'memory_profiler'
+
+end

metadata

@@ -0,0 +1,173 @@
+--- !ruby/object:Gem::Specification
+name: pagy
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Domizio Demichelis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-02-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: slim
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: haml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: benchmark-ips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: kalibera
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: memory_profiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 'Dead simple pagination in pure ruby. Easy, fast and very light. No restrictions
+  imposed: use it with any MVC framework, any ORM, any DB type, any templating system
+  or none at all. Use the built-in templates or create yours the way you want.'
+email:
+- dd.nexus@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/locales/pagy.yml
+- lib/pagy.rb
+- lib/pagy/backend.rb
+- lib/pagy/frontend.rb
+- lib/templates/bootstrap-no-dep.html.haml
+- lib/templates/bootstrap-no-dep.html.slim
+- lib/templates/bootstrap-rails-dep.html.erb
+- lib/templates/default-no-dep.html.haml
+- lib/templates/default-no-dep.html.slim
+- lib/templates/default-rails-dep.html.erb
+- lib/templates/default-rails-dep.html.haml
+- lib/templates/default-rails-dep.html.slim
+- pagy.gemspec
+homepage: https://github.com/ddnexus/pagy
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.4
+signing_key: 
+specification_version: 4
+summary: Because pagination should not suck!
+test_files: []