pagy 9.3.3 → 43.0.0.rc1

data/lib/pagy/i18n.rb

@@ -1,166 +0,0 @@
-# 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['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

@@ -1,38 +0,0 @@
-# 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)
-
-      # 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

@@ -1,51 +0,0 @@
-# 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)
-
-      # 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

@@ -1,118 +0,0 @@
-# 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
-      table      = @set.model.table_name
-      name       = @keyset.to_h { |column| [column, %("#{table}"."#{column}")] }
-      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

@@ -1,26 +0,0 @@
-# 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

@@ -1,26 +0,0 @@
-# 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/stylesheets/pagy.scss

@@ -1,48 +0,0 @@
-.pagy {
-  display: flex;
-  font-family: sans-serif;
-  font-size: 0.875rem;
-  line-height: 1.25rem;
-  font-weight: 600;
-  color: rgb(107 114 128);
-  & > :not([hidden]) ~ :not([hidden]) {
-    --space-reverse: 0;
-    margin-right: calc(0.25rem * var(--space-reverse));
-    margin-left: calc(0.25rem * calc(1 - var(--space-reverse)));
-  }
-
-  a:not(.gap) {
-    display: block;
-    text-decoration: none;
-    border-radius: 0.5rem;
-    background-color: rgb(229 231 235);
-    padding: 0.25rem 0.75rem;
-    color: inherit;
-    &:hover {
-      background-color: rgb(209 213 219);
-    }
-    &:not([href]) { /* disabled links */
-      cursor: default;
-      background-color: rgb(243 244 246);
-      color: rgb(209 213 219);
-    }
-    &.current {
-      background-color: rgb(156 163 175);
-      color: rgb(255 255 255);
-    }
-  }
-
-  label {
-    white-space: nowrap;
-    display: inline-block;
-    border-radius: 0.5rem;
-    background-color: rgb(229 231 235);
-    padding: 0.125rem 0.75rem;
-    input {
-      line-height: 1.5rem;
-      border-radius: 0.375rem;
-      border-style: none;
-      background-color: rgb(243 244 246);
-    }
-  }
-}

data/stylesheets/pagy.tailwind.css

@@ -1,21 +0,0 @@
-.pagy {
-  @apply flex space-x-1 font-semibold text-sm text-gray-500;
-  a:not(.gap) {
-    @apply block rounded-lg px-3 py-1 bg-gray-200;
-    &:hover {
-      @apply bg-gray-300;
-    }
-    &:not([href]) { /* disabled links */
-      @apply text-gray-300 bg-gray-100 cursor-default;
-    }
-    &.current {
-      @apply text-white bg-gray-400;
-    }
-  }
-  label {
-    @apply inline-block whitespace-nowrap bg-gray-200 rounded-lg px-3 py-0.5;
-    input {
-      @apply bg-gray-100 border-none rounded-md;
-    }
-  }
-}