pagy 3.8.2 → 9.4.0

data/lib/pagy/i18n.rb

@@ -0,0 +1,167 @@
+# See Pagy::I18n API documentation https://ddnexus.github.io/pagy/docs/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
+      # Pluralization variables
+      from0to1   = (0..1).to_a.freeze
+      from2to4   = (2..4).to_a.freeze
+      from3to10  = (3..10).to_a.freeze
+      from5to9   = (5..9).to_a.freeze
+      from11to14 = (11..14).to_a.freeze
+      from11to99 = (11..99).to_a.freeze
+      from12to14 = (12..14).to_a.freeze
+
+      from0to1_from5to9 = from0to1 + from5to9
+
+      # 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 from3to10.include?(mod100)  then 'few'
+            when from11to99.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['be']    = RULE[:east_slavic]
+                 hash['bs']    = RULE[:east_slavic]
+                 hash['ckb']   = RULE[:other]
+                 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['sk']    = RULE[:west_slavic]
+                 hash['sr']    = RULE[:east_slavic]
+                 hash['tr']    = RULE[:other]
+                 hash['uk']    = RULE[:east_slavic]
+                 hash['vi']    = RULE[:other]
+                 hash['zh-CN'] = RULE[:other]
+                 hash['zh-HK'] = RULE[:other]
+                 hash['zh-TW'] = RULE[:other]
+                 hash['dz']    = 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 I18nError, %(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 translate(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
+    alias t translate
+  end
+end

data/lib/pagy/keyset/active_record.rb

@@ -0,0 +1,44 @@
+# See Pagy API documentation: https://ddnexus.github.io/pagy/docs/api/keyset
+# frozen_string_literal: true
+
+class Pagy
+  class Keyset
+    # Keyset adapter for ActiveRecord
+    class ActiveRecord < Keyset
+      protected
+
+      # Get the keyset attributes from the record
+      def keyset_attributes_from(record) = record.slice(*@keyset.keys)
+
+      # Get the hash of quoted keyset identifiers
+      def quoted_identifiers(table)
+        connection = @set.connection
+        @keyset.to_h { |column| [column, "#{connection.quote_table_name(table)}.#{connection.quote_column_name(column)}"] }
+      end
+
+      # Extract the keyset from the set
+      def extract_keyset
+        @set.order_values.each_with_object({}) do |node, keyset|
+          keyset[node.value.name.to_sym] = node.direction
+        end
+      end
+
+      # Filter the newest records
+      def filter_newest = @set.where(filter_newest_query, **@latest)
+
+      # Append the missing keyset keys if the set is restricted by select
+      def apply_select
+        @set.select(*@keyset.keys)
+      end
+
+      # Set with selected columns?
+      def select? = !@set.select_values.empty?
+
+      # Typecast the latest attributes
+      def typecast_latest(latest)
+        @set.model.new(latest).slice(latest.keys)
+            .to_hash.transform_keys(&:to_sym)
+      end
+    end
+  end
+end

data/lib/pagy/keyset/sequel.rb

@@ -0,0 +1,57 @@
+# See Pagy API documentation: https://ddnexus.github.io/pagy/docs/api/keyset
+# frozen_string_literal: true
+
+class Pagy
+  class Keyset
+    # Keyset adapter for sequel
+    class Sequel < Keyset
+      protected
+
+      # Get the keyset attributes from the record
+      def keyset_attributes_from(record) = record.to_hash.slice(*@keyset.keys)
+
+      # Get the hash of quoted keyset identifiersAdd commentMore actions
+      def quoted_identifiers(table)
+        db = @set.db
+        @keyset.to_h { |column| [column, "#{db.quote_identifier(table)}.#{db.quote_identifier(column)}"] }
+      end
+
+      # Extract the keyset from the set
+      def extract_keyset
+        return {} unless @set.opts[:order]
+
+        @set.opts[:order].each_with_object({}) do |item, keyset|
+          case item
+          when Symbol
+            keyset[item] = :asc
+          when ::Sequel::SQL::OrderedExpression
+            keyset[item.expression] = item.descending ? :desc : :asc
+          else
+            raise TypeError, "#{item.class.inspect} is not a supported Sequel::SQL::OrderedExpression"
+          end
+        end
+      end
+
+      # Filter the newest records
+      def filter_newest = @set.where(::Sequel.lit(filter_newest_query, **@latest))
+
+      # Append the missing keyset keys if the set is restricted by select
+      def apply_select
+        selected = @set.opts[:select]
+        @set.select_append(*@keyset.keys.reject { |c| selected.include?(c) })
+      end
+
+      # Set with selected columns?
+      def select? = !@set.opts[:select].nil?
+
+      # Typecast the latest attributes
+      def typecast_latest(latest)
+        model = @set.opts[:model]
+        model.unrestrict_primary_key if (restricted_pk = model.restrict_primary_key?)
+        latest = model.new(latest).to_hash.slice(*latest.keys.map(&:to_sym))
+        model.restrict_primary_key if restricted_pk
+        latest
+      end
+    end
+  end
+end

data/lib/pagy/keyset.rb

@@ -0,0 +1,118 @@
+# See Pagy API documentation: https://ddnexus.github.io/pagy/docs/api/keyset
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'b64'
+require_relative 'shared_methods'
+
+class Pagy
+  # Implement wicked-fast keyset pagination for big data
+  class Keyset
+    class TypeError < ::TypeError; end
+
+    include SharedMethods
+
+    # Pick the right adapter for the set
+    def self.new(set, **vars)
+      if self == Pagy::Keyset
+        if defined?(::ActiveRecord) && set.is_a?(::ActiveRecord::Relation)
+          ActiveRecord
+        elsif defined?(::Sequel) && set.is_a?(::Sequel::Dataset)
+          Sequel
+        else
+          raise TypeError, "expected set to be an instance of ActiveRecord::Relation or Sequel::Dataset; got #{set.class}"
+        end.new(set, **vars)
+      else
+        allocate.tap { |instance| instance.send(:initialize, set, **vars) }
+      end
+    end
+
+    attr_reader :latest  # Other readers from SharedMethods
+
+    def initialize(set, **vars)
+      default = DEFAULT.slice(:limit, :page_param,                    # from pagy
+                              :headers,                               # from headers extra
+                              :jsonapi,                               # from jsonapi extra
+                              :limit_param, :limit_max, :limit_extra) # from limit_extra
+      assign_vars({ **default, page: nil }, vars)
+      assign_limit
+      @set    = set
+      @page   = @vars[:page]
+      @keyset = extract_keyset
+      raise InternalError, 'the set must be ordered' if @keyset.empty?
+      return unless @page
+
+      latest  = JSON.parse(B64.urlsafe_decode(@page)).transform_keys(&:to_sym)
+      @latest = typecast_latest(latest)
+      raise InternalError, 'page and keyset are not consistent' \
+            unless @latest.keys == @keyset.keys
+    end
+
+    # Return the next page
+    def next
+      records
+      return unless @more
+
+      @next ||= begin
+                  hash = keyset_attributes_from(@records.last)
+                  json = @vars[:jsonify_keyset_attributes]&.(hash) || hash.to_json
+                  B64.urlsafe_encode(json)
+                end
+    end
+
+    # Fetch the array of records for the current page
+    def records
+      @records ||= begin
+                     @set = apply_select if select?
+                     if @latest
+                       # :nocov:
+                       @set = @vars[:after_latest]&.(@set, @latest) || # deprecated
+                              # :nocov:
+                              @vars[:filter_newest]&.(@set, @latest, @keyset) ||
+                              filter_newest
+                     end
+                     records = @set.limit(@limit + 1).to_a
+                     @more   = records.size > @limit && !records.pop.nil?
+                     records
+                   end
+    end
+
+    protected
+
+    # Prepare the literal query string (complete with the placeholders for value interpolation)
+    # used to filter the newest records.
+    # For example:
+    # With a set like Pet.order(animal: :asc, name: :desc, id: :asc) it returns the following string:
+    # ( "pets"."animal" = :animal AND "pets"."name" = :name AND "pets"."id" > :id ) OR
+    # ( "pets"."animal" = :animal AND "pets"."name" < :name ) OR
+    # ( "pets"."animal" > :animal )
+    # When :tuple_comparison is enabled, and if the order is all :asc or all :desc,
+    # with a set like Pet.order(:animal, :name, :id) it returns the following string:
+    # ( "pets"."animal", "pets"."name", "pets"."id" ) > ( :animal, :name, :id )
+    def filter_newest_query
+      operator = { asc: '>', desc: '<' }
+      directions = @keyset.values
+      name = quoted_identifiers(@set.model.table_name)
+
+      if @vars[:tuple_comparison] && (directions.all?(:asc) || directions.all?(:desc))
+        placeholders = @keyset.keys.map { |column| ":#{column}" }.join(', ')
+        "( #{name.values.join(', ')} ) #{operator[directions.first]} ( #{placeholders} )"
+      else
+        keyset = @keyset.to_a
+        where  = []
+        until keyset.empty?
+          last_column, last_direction = keyset.pop
+          query = +'( '
+          query << (keyset.map { |column, _d| "#{name[column]} = :#{column}" } \
+                    << "#{name[last_column]} #{operator[last_direction]} :#{last_column}").join(' AND ')
+          query << ' )'
+          where << query
+        end
+        where.join(' OR ')
+      end
+    end
+  end
+end
+
+require_relative 'keyset/active_record'
+require_relative 'keyset/sequel'

data/lib/pagy/shared_methods.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+class Pagy
+  # Shared with Keyset
+  module SharedMethods
+    attr_reader :page, :limit, :vars
+
+    # Validates and assign the passed vars: var must be present and value.to_i must be >= to min
+    def assign_and_check(name_min)
+      name_min.each do |name, min|
+        raise VariableError.new(self, name, ">= #{min}", @vars[name]) \
+              unless @vars[name]&.respond_to?(:to_i) && instance_variable_set(:"@#{name}", @vars[name].to_i) >= min
+      end
+    end
+
+    # Assign @limit (overridden by the gearbox extra)
+    def assign_limit
+      assign_and_check(limit: 1)
+    end
+
+    # Assign @vars
+    def assign_vars(default, vars)
+      @vars = { **default, **vars.delete_if { |k, v| default.key?(k) && (v.nil? || v == '') } }
+    end
+  end
+end

data/lib/pagy/url_helpers.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+class Pagy
+  # Provide the helpers to handle the url in frontend and backend
+  module UrlHelpers
+    # Return the URL for the page, relying on the params method and Rack by default.
+    # It supports all Rack-based frameworks (Sinatra, Padrino, Rails, ...).
+    # For non-rack environments you can use the standalone extra
+    def pagy_url_for(pagy, page, absolute: false, fragment: nil, **_)
+      vars         = pagy.vars
+      query_params = request.GET.clone(freeze: false)
+      query_params.merge!(vars[:params].transform_keys(&:to_s)) if vars[:params].is_a?(Hash)
+      pagy_set_query_params(page, vars, query_params)
+      query_params = vars[:params].(query_params) if vars[:params].is_a?(Proc)
+      query_string = "?#{Rack::Utils.build_nested_query(query_params)}"
+      "#{request.base_url if absolute}#{vars[:request_path] || request.path}#{query_string}#{fragment}"
+    end
+
+    # Add the page and limit params
+    # Overridable by the jsonapi extra
+    def pagy_set_query_params(page, vars, query_params)
+      query_params[vars[:page_param].to_s]  = page
+      query_params[vars[:limit_param].to_s] = vars[:limit] if vars[:limit_extra]
+    end
+  end
+end

data/lib/pagy.rb

@@ -1,52 +1,106 @@
-# See Pagy API documentation: https://ddnexus.github.io/pagy/api/pagy
-# encoding: utf-8
+# See Pagy API documentation: https://ddnexus.github.io/pagy/docs/api/pagy
 # frozen_string_literal: true
 
 require 'pathname'
+require_relative 'pagy/shared_methods'
 
-class Pagy ; VERSION = '3.8.2'
+# Top superclass: it should define only what's common to all the subclasses
+class Pagy
+  VERSION = '9.4.0'
 
-  # Root pathname to get the path of Pagy files like templates or dictionaries
-  def self.root; @root ||= Pathname.new(__FILE__).dirname.freeze end
+  # Core default: constant for easy access, but mutable for customizable defaults
+  DEFAULT = { count_args: [:all], # rubocop:disable Style/MutableConstant
+              ends:       true,
+              limit:      20,
+              outset:     0,
+              page:       1,
+              page_param: :page,
+              size:       7 }  # AR friendly
 
-  # default vars
-  VARS = { page:1, items:20, outset:0, size:[1,4,4,1], page_param: :page, params:{}, anchor:'', link_extra:'', i18n_key:'pagy.item_name', cycle:false }
+  # Gem root pathname to get the path of Pagy files stylesheets, javascripts, apps, locales, etc.
+  def self.root
+    @root ||= Pathname.new(__dir__).parent.freeze
+  end
+
+  include SharedMethods
 
-  attr_reader :count, :page, :items, :vars, :pages, :last, :offset, :from, :to, :prev, :next
+  attr_reader :count, :from, :in, :last, :next, :offset, :prev, :to
+  alias pages last
 
   # Merge and validate the options, do some simple arithmetic and set the instance variables
-  def initialize(vars)
-    @vars = VARS.merge(vars.delete_if{|_,v| v.nil? || v == '' })               # default vars + cleaned vars
-    { count:0, items:1, outset:0, page:1 }.each do |k,min|                     # validate instance variables
-      (@vars[k] && instance_variable_set(:"@#{k}", @vars[k].to_i) >= min) \
-         or raise(VariableError.new(self), "expected :#{k} >= #{min}; got #{@vars[k].inspect}")
-    end
-    @pages = @last = [(@count.to_f / @items).ceil, 1].max                      # cardinal and ordinal meanings
-    @page <= @last or raise(OverflowError.new(self), "expected :page in 1..#{@last}; got #{@page.inspect}")
-    @offset = @items * (@page - 1) + @outset                                   # pagination offset + outset (initial offset)
-    @items  = @count - ((@pages-1) * @items) if @page == @last && @count > 0   # adjust items for last non-empty page
-    @from   = @count == 0 ? 0 : @offset+1 - @outset                            # page begins from item
-    @to     = @count == 0 ? 0 : @offset + @items - @outset                     # page ends to item
-    @prev   = (@page-1 unless @page == 1)                                      # nil if no prev page
-    @next   = @page == @last ? (1 if @vars[:cycle]) : @page+1                  # nil if no next page, 1 if :cycle
+  def initialize(**vars)
+    assign_vars(DEFAULT, vars)
+    assign_and_check(count: 0, page: 1, outset: 0)
+    assign_limit
+    assign_offset
+    assign_last
+    check_overflow
+    @from = [@offset - @outset + 1, @count].min
+    @to   = [@offset - @outset + @limit, @count].min
+    @in   = [@to - @from + 1, @count].min
+    assign_prev_and_next
+  end
+
+  # Setup @last (overridden by the gearbox extra)
+  def assign_last
+    @last = [(@count.to_f / @limit).ceil, 1].max
+    @last = @vars[:max_pages] if @vars[:max_pages] && @last > vars[:max_pages]
+  end
+
+  # Assign @offset (overridden by the gearbox extra)
+  def assign_offset
+    @offset = (@limit * (@page - 1)) + @outset  # may be already set from gear_box
   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])
-    (series = []) and size.empty? and return series
-    4.times{|i| (size[i]>=0 rescue nil) or raise(VariableError.new(self), "expected 4 items >= 0 in :size; got #{size.inspect}")}
-    [*0..size[0], *@page-size[1]..@page+size[2], *@last-size[3]+1..@last+1].sort!.each_cons(2) do |a, b|
-      if    a<0 || a==b || a>@last                                        # skip out of range and duplicates
-      elsif a+1 == b; series.push(a)                                      # no gap     -> no additions
-      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                                                                   # shift the start boundary (0) and
-    series.shift; series[series.index(@page)] = @page.to_s; series        # convert the current page to String
+  # Assign @prev and @next
+  def assign_prev_and_next
+    @prev = (@page - 1 unless @page == 1)
+    @next = @page == @last ? (1 if @vars[:cycle]) : @page + 1
   end
 
+  # Checks the @page <= @last
+  def check_overflow
+    raise OverflowError.new(self, :page, "in 1..#{@last}", @page) if @page > @last
+  end
+
+  # Label for the current page. Allow the customization of the output (overridden by the calendar extra)
+  def label = @page.to_s
+
+  # Label for any page. Allow the customization of the output (overridden by the calendar extra)
+  def label_for(page) = page.to_s
+
+  # Return the array of page numbers and :gap e.g. [1, :gap, 8, "9", 10, :gap, 36]
+  def series(size: @vars[:size], **_)
+    raise VariableError.new(self, :size, 'to be an Integer >= 0', size) \
+    unless size.is_a?(Integer) && size >= 0
+    return [] if size.zero?
+
+    [].tap do |series|
+      if size >= @last
+        series.push(*1..@last)
+      else
+        left  = ((size - 1) / 2.0).floor             # left half might be 1 page shorter for even size
+        start = if @page <= left                     # beginning pages
+                  1
+                elsif @page > (@last - size + left)  # end pages
+                  @last - size + 1
+                else                                 # intermediate pages
+                  @page - left
+                end
+        series.push(*start...(start + size))
+        # Set first and last pages plus gaps when needed, respecting the size
+        if vars[:ends] && size >= 7
+          series[0]  = 1
+          series[1]  = :gap  unless series[1]  == 2
+          series[-2] = :gap  unless series[-2] == @last - 1
+          series[-1] = @last
+        end
+      end
+      series[series.index(@page)] = @page.to_s
+    end
+  end
 end
 
-require 'pagy/backend'
-require 'pagy/frontend'
-require 'pagy/exceptions'
+require_relative 'pagy/backend'
+require_relative 'pagy/frontend'
+require_relative 'pagy/exceptions'

data/locales/ar.yml

@@ -0,0 +1,29 @@
+# :arabic pluralization (see https://github.com/ddnexus/pagy/blob/master/gem/lib/pagy/i18n.rb)
+ar:
+  pagy:
+    aria_label:
+      nav:
+        zero: "لا يوجد صفحات"
+        one: "صفحة"
+        two: "صفحتين"
+        few: "صفحات"
+        many: "صفحات"
+        other: "صفحات"
+      prev: "السابق"
+      next: "التالي"
+    prev: "<"
+    next: ">"
+    gap: "…"
+    item_name:
+      zero: "صفر"
+      one: "عنصر"
+      two: "عنصرين"
+      few: "قليل"
+      many: "كثير"
+      other: "عناصر"
+    info:
+      no_items: "لا يوجد %{item_name}"
+      single_page: "عرض %{count} %{item_name}"
+      multiple_pages: "عرض %{item_name} %{from}-%{to} من اجمالي %{count}"
+    combo_nav_js: "الصفحة %{page_input} من %{pages}"
+    limit_selector_js: "عرض %{limit_input} %{item_name} لكل صفحة"

data/locales/be.yml

@@ -0,0 +1,25 @@
+# :east_slavic pluralization (see https://github.com/ddnexus/pagy/blob/master/gem/lib/pagy/i18n.rb)
+be:
+  pagy:
+    aria_label:
+      nav:
+        one: "Старонка"
+        few: "Старонкi"
+        many: "Старонкi"
+        other: "Старонкi"
+      prev: "Назад"
+      next: "Наперад"
+    prev: "<"
+    next: ">"
+    gap: "…"
+    item_name:
+      one: "запіс"
+      few: "запісы"
+      many: "запісаў"
+      other: "запісаў"
+    info:
+      no_items: "Пакуль %{item_name} няма"
+      single_page: "%{count} %{item_name}"
+      multiple_pages: "Усяго %{count} %{item_name}, паказаны з %{from} па %{to}"
+    combo_nav_js: "Старонка %{page_input} з %{pages}"
+    limit_selector_js: "Паказаць %{limit_input} %{item_name} на старонцы"

data/locales/bg.yml

@@ -0,0 +1,21 @@
+# :one_other pluralization (see https://github.com/ddnexus/pagy/blob/master/gem/lib/pagy/i18n.rb)
+bg:
+  pagy:
+    aria_label:
+      nav:
+        one: "Страница"
+        other: "Страници"
+      prev: "Предишна"
+      next: "Следваща"
+    prev: "<"
+    next: ">"
+    gap: "…"
+    item_name:
+      one: "резултат"
+      other: "резултати"
+    info:
+      no_items: "Няма намерени %{item_name}"
+      single_page: "Показани са %{count} %{item_name}"
+      multiple_pages: "Показани са %{item_name} %{from}-%{to} от %{count} общо"
+    combo_nav_js: "Страница %{page_input} от %{pages}"
+    limit_selector_js: "Покажи %{limit_input} %{item_name} на страница"