pagy 4.11.0 → 5.0.0

data/lib/pagy/i18n.rb

@@ -0,0 +1,159 @@
+# See Pagy::I18n API documentation https://ddnexus.github.io/pagy/api/i18n
+# frozen_string_literal: true
+
+require 'yaml'
+
+class Pagy
+  # Pagy i18n implementation, compatible with the I18n gem, just a lot faster and lighter
+  module I18n
+    extend self
+
+    # Pluralization rules
+    module P11n
+      # utility variables
+      from0to1   = [0, 1].freeze
+      from2to4   = [2, 3, 4].freeze
+      from5to9   = [5, 6, 7, 8, 9].freeze
+      from11to14 = [11, 12, 13, 14].freeze
+      from12to14 = [12, 13, 14].freeze
+
+      # Store the proc defining each pluralization RULE
+      # Logic adapted from https://github.com/svenfuchs/rails-i18n
+      RULE = {
+        arabic:
+          lambda do |n = 0|
+            mod100 = n % 100
+            case
+            when n == 0                         then 'zero' # rubocop:disable Style/NumericPredicate
+            when n == 1                         then 'one'
+            when n == 2                         then 'two'
+            when (3..10).to_a.include?(mod100)  then 'few'
+            when (11..99).to_a.include?(mod100) then 'many'
+            else                                     'other'
+            end
+          end,
+
+        east_slavic:
+          lambda do |n = 0|
+            mod10  = n % 10
+            mod100 = n % 100
+            case
+            when mod10 == 1 && mod100 != 11                                            then 'one'
+            when from2to4.include?(mod10) && !from12to14.include?(mod100)              then 'few'
+            when mod10 == 0 || from5to9.include?(mod10) || from11to14.include?(mod100) then 'many' # rubocop:disable Style/NumericPredicate
+            else                                                                            'other'
+            end
+          end,
+
+        one_other:
+          ->(n) { n == 1 ? 'one' : 'other' }, # default RULE
+
+        one_two_other:
+          lambda do |n|
+            case n
+            when 1 then 'one'
+            when 2 then 'two'
+            else        'other'
+            end
+          end,
+
+        one_upto_two_other:
+          ->(n) { n && n >= 0 && n < 2 ? 'one' : 'other' },
+
+        other:
+          ->(*) { 'other' },
+
+        polish:
+          lambda do |n = 0|
+            mod10  = n % 10
+            mod100 = n % 100
+            case
+            when n == 1                                                               then 'one'
+            when from2to4.include?(mod10) && !from12to14.include?(mod100)             then 'few'
+            when (from0to1 + from5to9).include?(mod10) || from12to14.include?(mod100) then 'many'
+            else                                                                           'other'
+            end
+          end,
+
+        west_slavic:
+          lambda do |n|
+            case n
+            when 1         then 'one'
+            when *from2to4 then 'few'
+            else                'other'
+            end
+          end
+
+      }.freeze
+
+      # Store the RULE to apply to each LOCALE
+      # the :one_other RULE is the default for locales missing from this list
+      LOCALE = Hash.new(RULE[:one_other]).tap do |hash|
+                 hash['ar']    = RULE[:arabic]
+                 hash['bs']    = RULE[:east_slavic]
+                 hash['cs']    = RULE[:west_slavic]
+                 hash['id']    = RULE[:other]
+                 hash['fr']    = RULE[:one_upto_two_other]
+                 hash['hr']    = RULE[:east_slavic]
+                 hash['ja']    = RULE[:other]
+                 hash['km']    = RULE[:other]
+                 hash['ko']    = RULE[:other]
+                 hash['pl']    = RULE[:polish]
+                 hash['ru']    = RULE[:east_slavic]
+                 hash['sr']    = RULE[:east_slavic]
+                 hash['sv']    = RULE[:one_two_other]
+                 hash['sv-SE'] = RULE[:one_two_other]
+                 hash['tr']    = RULE[:other]
+                 hash['uk']    = RULE[:east_slavic]
+                 hash['zh-CN'] = RULE[:other]
+                 hash['zh-HK'] = RULE[:other]
+                 hash['zh-TW'] = RULE[:other]
+               end.freeze
+    end
+
+    # Stores the i18n DATA structure for each loaded locale
+    # default on the first locale DATA
+    DATA = Hash.new { |hash, _| hash.first[1] }
+
+    private
+
+    # Create a flat hash with dotted notation keys
+    def flatten(initial, prefix = '')
+      initial.each.reduce({}) do |hash, (key, value)|
+        hash.merge!(value.is_a?(Hash) ? flatten(value, "#{prefix}#{key}.") : { "#{prefix}#{key}" => value })
+      end
+    end
+
+    # Build the DATA hash out of the passed locales
+    def build(*locales)
+      locales.each do |locale|
+        locale[:filepath]  ||= Pagy.root.join('locales', "#{locale[:locale]}.yml")
+        locale[:pluralize] ||= P11n::LOCALE[locale[:locale]]
+        dictionary = YAML.safe_load(File.read(locale[:filepath], encoding: 'UTF-8'))
+        raise VariableError, %(expected :locale "#{locale[:locale]}" not found in :filepath "#{locale[:filepath].inspect}") \
+              unless dictionary.key?(locale[:locale])
+
+        DATA[locale[:locale]] = [flatten(dictionary[locale[:locale]]), locale[:pluralize]]
+      end
+    end
+    # Build the default at require time
+    build(locale: 'en')
+
+    public
+
+    # Public method to configure the locales: overrides the default, build the DATA and freezes it
+    def load(*locales)
+      DATA.clear
+      build(*locales)
+      DATA.freeze
+    end
+
+    # Translate and pluralize the key with the locale DATA
+    def t(locale, key, **opts)
+      data, pluralize = DATA[locale]
+      translation = data[key] || (opts[:count] && data[key += ".#{pluralize.call(opts[:count])}"]) \
+                      or return %([translation missing: "#{key}"])
+      translation.gsub(/%{[^}]+?}/) { |match| opts[:"#{match[2..-2]}"] || match }
+    end
+  end
+end

data/lib/pagy/url_helpers.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class Pagy
+  # Provide the helpers to handle the url in frontend and backend
+  module UrlHelpers
+    # This works with all Rack-based frameworks (Sinatra, Padrino, Rails, ...)
+    def pagy_url_for(pagy, page, absolute: nil)
+      p_vars                            = pagy.vars
+      params                            = request.GET.merge(p_vars[:params])
+      params[p_vars[:page_param].to_s]  = page
+      params[p_vars[:items_param].to_s] = p_vars[:items] if defined?(ItemsExtra)
+      # we rely on Rack by default: use the standalone extra in non rack environments
+      query_string = "?#{Rack::Utils.build_nested_query(pagy_massage_params(params))}" unless params.empty?
+      "#{request.base_url if absolute}#{request.path}#{query_string}#{p_vars[:fragment]}"
+    end
+
+    # Sub-method called only by #pagy_url_for: here for easy customization of params by overriding
+    def pagy_massage_params(params)
+      params
+    end
+  end
+end

data/lib/pagy.rb

@@ -3,58 +3,61 @@
 
 require 'pathname'
 
-# main class
+# Core class
 class Pagy
-  VERSION = '4.11.0'
+  VERSION = '5.0.0'
 
   # Root pathname to get the path of Pagy files like templates or dictionaries
   def self.root
     @root ||= Pathname.new(__dir__).freeze
   end
 
-  # default vars
-  VARS = { page: 1, items: 20, outset: 0, size: [1, 4, 4, 1], page_param: :page,              # rubocop:disable Style/MutableConstant
-           params: {}, fragment: '', link_extra: '', i18n_key: 'pagy.item_name', cycle: false }
+  # Default core vars: constant for easy access, but mutable for customizable defaults
+  DEFAULT = { page:       1, # rubocop:disable Style/MutableConstant
+              items:      20,
+              outset:     0,
+              size:       [1, 4, 4, 1],
+              page_param: :page,
+              params:     {},
+              fragment:   '',
+              link_extra: '',
+              i18n_key:   'pagy.item_name',
+              cycle:      false }
 
-  attr_reader :count, :page, :items, :vars, :pages, :last, :offset, :from, :to, :prev, :next
-
-  INSTANCE_VARS_MIN = { count: 0, items: 1, page: 1, outset: 0 }.freeze
+  attr_reader :count, :page, :items, :vars, :pages, :last, :offset, :in, :from, :to, :prev, :next
 
   # Merge and validate the options, do some simple arithmetic and set the instance variables
   def initialize(vars)
-    @vars = VARS.merge( vars.delete_if{|k,v| VARS.key?(k) && (v.nil? || v == '') } )
-    @vars[:fragment] = Pagy.deprecated_var(:anchor, @vars[:anchor], :fragment, @vars[:fragment]) if @vars[:anchor]
-
-    INSTANCE_VARS_MIN.each do |name,min|
-      raise VariableError.new(self), "expected :#{name} >= #{min}; got #{@vars[name].inspect}" \
-            unless @vars[name] && instance_variable_set(:"@#{name}", @vars[name].to_i) >= min
-    end
-    @pages = @last = [(@count.to_f / @items).ceil, 1].max
+    normalize_vars(vars)
+    setup_vars(count: 0, page: 1, outset: 0)
+    setup_items_var
+    setup_pages_var
     raise OverflowError.new(self), "expected :page in 1..#{@last}; got #{@page.inspect}" \
           if @page > @last
 
-    @offset = @items * (@page - 1) + @outset
-    @items  = @count - ((@pages - 1) * @items) if @page == @last && @count.positive?
-    @from   = @count.zero? ? 0 : @offset + 1 - @outset
-    @to     = @count.zero? ? 0 : @offset + @items - @outset
+    @offset = (@items * (@page - 1)) + @outset
+    @from   = [@offset - @outset + 1, @count].min
+    @to     = [@offset - @outset + @items, @count].min
+    @in     = [@to - @from + 1, @count].min
     @prev   = (@page - 1 unless @page == 1)
     @next   = @page == @last ? (1 if @vars[:cycle]) : @page + 1
   end
 
   # Return the array of page numbers and :gap items e.g. [1, :gap, 7, 8, "9", 10, 11, :gap, 36]
-  def series(size=@vars[:size])
+  def series(size = @vars[:size])
     return [] if size.empty?
     raise VariableError.new(self), "expected 4 items >= 0 in :size; got #{size.inspect}" \
-          unless size.size == 4 && size.all?{ |num| !num.negative? rescue false }  # rubocop:disable Style/RescueModifier
+          unless size.size == 4 && size.all? { |num| !num.negative? rescue false } # rubocop:disable Style/RescueModifier
+
     # This algorithm is up to ~5x faster and ~2.3x lighter than the previous one (pagy < 4.3)
-    left_gap_start  =     1 + size[0]
+    left_gap_start  =     1 + size[0]   # rubocop:disable Layout/ExtraSpacing, Layout/SpaceAroundOperators
     left_gap_end    = @page - size[1] - 1
     right_gap_start = @page + size[2] + 1
     right_gap_end   = @last - size[3]
     left_gap_end    = right_gap_end  if left_gap_end   > right_gap_end
     right_gap_start = left_gap_start if left_gap_start > right_gap_start
-    series = []
-    start  = 1
+    series          = []
+    start           = 1
     if (left_gap_end - left_gap_start).positive?
       series.push(*start..(left_gap_start - 1), :gap)
       start = left_gap_end + 1
@@ -68,9 +71,32 @@ class Pagy
     series
   end
 
+  protected
+
+  # Apply defaults, cleanup blanks and set @vars
+  def normalize_vars(vars)
+    @vars = DEFAULT.merge(vars.delete_if { |k, v| DEFAULT.key?(k) && (v.nil? || v == '') })
+  end
+
+  # Setup and validates the passed vars: var must be present and value.to_i must be >= to min
+  def setup_vars(name_min)
+    name_min.each do |name, min|
+      raise VariableError.new(self), "expected :#{name} >= #{min}; got #{@vars[name].inspect}" \
+            unless @vars[name] && instance_variable_set(:"@#{name}", @vars[name].to_i) >= min
+    end
+  end
+
+  # Setup and validate the items (overridden by the gearbox extra)
+  def setup_items_var
+    setup_vars(items: 1)
+  end
+
+  # Setup and validates the pages (overridden by the gearbox extra)
+  def setup_pages_var
+    @pages = @last = [(@count.to_f / @items).ceil, 1].max
+  end
 end
 
-require 'pagy/deprecation'
 require 'pagy/backend'
 require 'pagy/frontend'
 require 'pagy/exceptions'

data/lib/templates/uikit_nav.html.erb

@@ -9,7 +9,7 @@
 <%   elsif item == :gap        -%>   <li class="uk-disabled"><span><%== pagy_t('pagy.nav.gap') %></span></li>
 <%   end                       -%>
 <% end                         -%>
-<% if pagy.next                -%>   <li><%== link.call(p_next, "<span uk-pagination-next>#{pagy_t('pagy.nav.next')}</span>") %></li>
+<% if pagy.next                -%>   <li><%== link.call(pagy.next, "<span uk-pagination-next>#{pagy_t('pagy.nav.next')}</span>") %></li>
 <% else                        -%>   <li class="uk-disabled"><a href="#"><span uk-pagination-next><%== pagy_t('pagy.nav.next') %></span></a></li>
 <% end                         -%>
 <%#                            -%> </ul>

data/lib/templates/uikit_nav.html.slim

@@ -21,7 +21,7 @@ ul.uk-pagination.uk-flex-center
         span== pagy_t('pagy.nav.gap')
 
   - if pagy.next
-    li== link.call(p_next, "<span uk-pagination-next>#{pagy_t('pagy.nav.next')}</span>")
+    li== link.call(pagy.next, "<span uk-pagination-next>#{pagy_t('pagy.nav.next')}</span>")
   - else
     li.uk-disabled
       a href="#"

metadata

@@ -1,18 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: pagy
 version: !ruby/object:Gem::Version
-  version: 4.11.0
+  version: 5.0.0
 platform: ruby
 authors:
 - Domizio Demichelis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-08-20 00:00:00.000000000 Z
+date: 2021-10-16 00:00:00.000000000 Z
 dependencies: []
-description: 'Agnostic pagination in plain ruby: it works with any framework, ORM
-  and DB type, with all kinds of collections, even pre-paginated, scopes, Arrays,
-  JSON data... Easy, powerful, fast and light.'
+description: Agnostic pagination in plain ruby. It does it all. Better.
 email:
 - dd.nexus@gmail.com
 executables: []
@@ -50,9 +48,6 @@ files:
 - lib/locales/sw.yml
 - lib/locales/tr.yml
 - lib/locales/uk.yml
-- lib/locales/utils/i18n.rb
-- lib/locales/utils/loader.rb
-- lib/locales/utils/p11n.rb
 - lib/locales/zh-CN.yml
 - lib/locales/zh-HK.yml
 - lib/locales/zh-TW.yml
@@ -60,7 +55,6 @@ files:
 - lib/pagy/backend.rb
 - lib/pagy/console.rb
 - lib/pagy/countless.rb
-- lib/pagy/deprecation.rb
 - lib/pagy/exceptions.rb
 - lib/pagy/extras/arel.rb
 - lib/pagy/extras/array.rb
@@ -69,6 +63,7 @@ files:
 - lib/pagy/extras/countless.rb
 - lib/pagy/extras/elasticsearch_rails.rb
 - lib/pagy/extras/foundation.rb
+- lib/pagy/extras/gearbox.rb
 - lib/pagy/extras/headers.rb
 - lib/pagy/extras/i18n.rb
 - lib/pagy/extras/items.rb
@@ -85,6 +80,8 @@ files:
 - lib/pagy/extras/trim.rb
 - lib/pagy/extras/uikit.rb
 - lib/pagy/frontend.rb
+- lib/pagy/i18n.rb
+- lib/pagy/url_helpers.rb
 - lib/templates/bootstrap_nav.html.erb
 - lib/templates/bootstrap_nav.html.haml
 - lib/templates/bootstrap_nav.html.slim
@@ -122,5 +119,5 @@ requirements: []
 rubygems_version: 3.2.3
 signing_key: 
 specification_version: 4
-summary: The Ultimate Pagination Ruby Gem
+summary: The kick-ass pagination ruby gem
 test_files: []

data/lib/locales/utils/i18n.rb

@@ -1,17 +0,0 @@
-# See https://ddnexus.github.io/pagy/api/frontend#i18n
-# frozen_string_literal: true
-
-# this file returns the I18n hash used as default alternative to the i18n gem
-
-Hash.new{|h,_| h.first[1]}.tap do |i18n_hash|   # first loaded locale used as default
-  i18n_hash.define_singleton_method(:load) do |*load_args|
-    # eval: we don't need to keep the loader proc in memory
-    eval(Pagy.root.join('locales', 'utils', 'loader.rb').read).call(i18n_hash, *load_args)   #rubocop:disable Security/Eval
-  end
-  i18n_hash.define_singleton_method(:t) do |locale, key, **opts|
-    data, pluralize = self[locale]
-    translate = data[key] || opts[:count] && data[key+=".#{pluralize.call(opts[:count])}"] or return %([translation missing: "#{key}"])
-    translate.call(opts)
-  end
-  i18n_hash.load(locale: 'en')
-end

data/lib/locales/utils/loader.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-# the whole file will be eval'ed/executed and gc-collected after returning/executing the loader proc
-
-# eval: no need for the whole file in memory
-plurals, = eval Pagy.root.join('locales', 'utils', 'p11n.rb').read   # rubocop:disable Security/Eval
-
-# flatten the dictionary file nested keys
-# convert each value to a simple ruby interpolation proc
-flatten = lambda do |hash, key=''|
-            hash.each.reduce({}) do |h, (k, v)|
-              if v.is_a?(Hash)
-                h.merge! flatten.call(v, "#{key}#{k}.")
-              else
-                code = %({"#{key}#{k}" => lambda{|vars|"#{v.gsub(/%{[^}]+?}/){|m| "\#{vars[:#{m[2..-2]}]||'#{m}'}" }}"}})
-                h.merge! eval(code) # rubocop:disable Security/Eval
-              end
-            end
-          end
-
-# loader proc
-lambda do |i18n, *args|
-  i18n.clear
-  args.each do |arg|
-    arg[:filepath]  ||= Pagy.root.join('locales', "#{arg[:locale]}.yml")
-    arg[:pluralize] ||= plurals[arg[:locale]]
-    hash = YAML.load(File.read(arg[:filepath], encoding: 'UTF-8')) #rubocop:disable Security/YAMLLoad
-    hash.key?(arg[:locale]) or raise VariableError, %(expected :locale "#{arg[:locale]}" not found in :filepath "#{arg[:filepath].inspect}")
-    i18n[arg[:locale]] = [flatten.call(hash[arg[:locale]]), arg[:pluralize]]
-  end
-end

data/lib/locales/utils/p11n.rb

@@ -1,112 +0,0 @@
-# See https://ddnexus.github.io/pagy/api/frontend#i18n
-# frozen_string_literal: true
-
-# This file adds support for multiple built-in plualization types.
-# It defines the pluralization procs and gets eval(ed) and gc-collected at Pagy::I18n.load time.
-
-# utility variables
-from0to1   = [0,1].freeze
-from2to4   = [2,3,4].freeze
-from5to9   = [5,6,7,8,9].freeze
-from11to14 = [11,12,13,14].freeze
-from12to14 = [12,13,14].freeze
-
-# Pluralization (p11n)
-# Compliant with the I18n gem
-# A pluralization proc returns a plural type string based on the passed count
-# Each proc may apply to one or more locales below.
-# Pluralization logic adapted from https://github.com/svenfuchs/rails-i18n
-p11n = {
-  one_other: -> (n){ n == 1 ? 'one' : 'other' },    # default
-
-  arabic: lambda do |n|
-    n ||= 0
-    mod100 = n % 100
-
-    case
-    when n == 0                         then 'zero'      # rubocop:disable Style/NumericPredicate
-    when n == 1                         then 'one'
-    when n == 2                         then 'two'
-    when (3..10).to_a.include?(mod100)  then 'few'
-    when (11..99).to_a.include?(mod100) then 'many'
-    else                                     'other'
-    end
-  end,
-
-  east_slavic: lambda do |n|
-    n ||= 0
-    mod10 = n % 10
-    mod100 = n % 100
-
-    case
-    when mod10 == 1 && mod100 != 11                                            then 'one'
-    when from2to4.include?(mod10) && !from12to14.include?(mod100)              then 'few'
-    when mod10 == 0 || from5to9.include?(mod10) || from11to14.include?(mod100) then 'many' # rubocop:disable Style/NumericPredicate
-    else                                                                            'other'
-    end
-  end,
-
-  one_two_other: lambda do |n|
-    case n
-    when 1 then 'one'
-    when 2 then 'two'
-    else        'other'
-    end
-  end,
-
-  one_upto_two_other: -> (n){ n && n >= 0 && n < 2 ? 'one' : 'other' },
-
-  other: -> (*){ 'other' },
-
-  polish: lambda do |n|
-    n ||= 0
-    mod10  = n % 10
-    mod100 = n % 100
-
-    case
-    when n == 1                                                               then 'one'
-    when from2to4.include?(mod10) && !from12to14.include?(mod100)             then 'few'
-    when (from0to1 + from5to9).include?(mod10) || from12to14.include?(mod100) then 'many'
-    else                                                                           'other'
-    end
-  end,
-
-  west_slavic: lambda do |n|
-    case n
-    when 1       then 'one'
-    when 2, 3, 4 then 'few'
-    else              'other'
-    end
-  end
-
-}
-
-# Hash of locale/pluralization pairs
-# It contains all the entries for all the locales defined as dictionaries.
-# The default pluralization for locales not explicitly listed here
-# is the :one_other pluralization proc (used for English)
-plurals = Hash.new(p11n[:one_other]).tap do |hash|
-  hash['ar']    = p11n[:arabic]
-  hash['bs']    = p11n[:east_slavic]
-  hash['cs']    = p11n[:west_slavic]
-  hash['id']    = p11n[:other]
-  hash['fr']    = p11n[:one_upto_two_other]
-  hash['hr']    = p11n[:east_slavic]
-  hash['ja']    = p11n[:other]
-  hash['km']    = p11n[:other]
-  hash['ko']    = p11n[:other]
-  hash['pl']    = p11n[:polish]
-  hash['ru']    = p11n[:east_slavic]
-  hash['sr']    = p11n[:east_slavic]
-  hash['sv']    = p11n[:one_two_other]
-  hash['sv-SE'] = p11n[:one_two_other]
-  hash['tr']    = p11n[:other]
-  hash['uk']    = p11n[:east_slavic]
-  hash['zh-CN'] = p11n[:other]
-  hash['zh-HK'] = p11n[:other]
-  hash['zh-TW'] = p11n[:other]
-end
-
-[ plurals, p11n ]
-
-# PR for other locales and pluralizations are very welcome. Thanks!

data/lib/pagy/deprecation.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-class Pagy
-  class << self
-
-    # deprecated variables
-    def deprecated_var(var, val, new_var, new_val)
-      value = val || new_val
-      Warning.warn %([PAGY WARNING] deprecated use of '#{var}' var will not be supported in 5.0! Use '#{new_var}: #{value.inspect}' instead.)
-      value
-    end
-
-    # deprecated pagy_url_for argument order
-    def deprecated_order(pagy, page)
-      Warning.warn %([PAGY WARNING] inverted use of pagy/page in pagy_url_for will not be supported in 5.0! Use pagy_url_for(pagy, page) instead.)
-      [page, pagy]
-    end
-
-
-    # deprecated posiitioal arguments
-    def deprecated_arg(arg, val, new_key, new_val)
-      value = val || new_val  # we use the new_val if present
-      Warning.warn %([PAGY WARNING] deprecated use of positional '#{arg}' arg will not be supported in 5.0! Use only the keyword arg '#{new_key}: #{value.inspect}' instead.)
-      value
-    end
-
-  end
-end