uchi 0.1.3 → 0.1.5

data/lib/uchi/pagy/modules/abilities/linkable.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module Uchi
+  class Pagy
+    # Provide the helpers to handle the url and anchor
+    module Linkable
+      module QueryUtils
+        module_function
+
+        # Extracted from Rack::Utils and reformatted for rubocop
+        # Add the 'unescaped' param, and use it for simple and safe url-templating.
+        # All string keyed hashes
+        def build_nested_query(value, prefix = nil, unescaped = [])
+          case value
+          when Array
+            value.map { |v| build_nested_query(v, "#{prefix}[]", unescaped) }.join('&')
+          when Hash
+            value.map do |k, v|
+              new_k = prefix ? "#{prefix}[#{escape(k)}]" : escape(k)
+              unescaped[unescaped.find_index(k)] = new_k if unescaped.size.positive? && new_k != k && unescaped.include?(k)
+              build_nested_query(v, new_k, unescaped)
+            end.delete_if(&:empty?).join('&')
+          when nil
+            escape(prefix)
+          else
+            raise ArgumentError, 'value must be a Hash' if prefix.nil?
+            return "#{escape(prefix)}=#{value}" if unescaped.include?(prefix)
+
+            "#{escape(prefix)}=#{escape(value)}"
+          end
+        end
+
+        def escape(str)
+          URI.encode_www_form_component(str)
+        end
+      end
+
+      protected
+
+      # Return the URL for the page, relying on the Pagy::Request
+      def compose_page_url(page, limit_token: nil, **options)
+        jsonapi, page_key, limit_key, limit, client_max_limit, querify, absolute, path, fragment =
+          @options.merge(options)
+                  .values_at(:jsonapi, :page_key, :limit_key, :limit, :client_max_limit, :querify, :absolute, :path, :fragment)
+        query = @request.query.clone(freeze: false)
+        query.delete(jsonapi ? 'page' : page_key)
+        factors = {}.tap do |h|
+                    h[page_key]  = countless? ? "#{page || 1}+#{@last}" : page
+                    h[limit_key] = limit_token || limit if client_max_limit
+                  end.compact # No empty params
+        query.merge!(jsonapi ? { 'page' => factors } : factors) if factors.size.positive?
+        querify&.(query) # Must modify the query: the returned value is ignored
+        query_string = QueryUtils.build_nested_query(query, nil, [page_key, limit_key])
+        query_string = "?#{query_string}" unless query_string.empty?
+        fragment   &&= %(##{fragment}) unless fragment&.start_with?('#')
+        "#{@request.base_url if absolute}#{path || @request.path}#{query_string}#{fragment}"
+      end
+    end
+  end
+end

data/lib/uchi/pagy/modules/abilities/rangeable.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Uchi
+  class Pagy
+    # Add method supporting range checking, range error and rescue
+    module Rangeable
+      # Check if in range
+      def in_range?
+        return @in_range if defined?(@in_range) || (@in_range = yield)
+        raise RangeError.new(self, :page, "in 1..#{@last}", @page) if @options[:raise_range_error]
+
+        assign_empty_page_variables
+        false
+      end
+    end
+  end
+end

data/lib/uchi/pagy/modules/abilities/shiftable.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Uchi
+  class Pagy
+    module Shiftable
+      protected
+
+      def assign_previous_and_next
+        @previous = @page - 1 unless @page == 1
+        @next     = @page + 1 unless @page == @last
+      end
+    end
+  end
+end

data/lib/uchi/pagy/modules/console.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Uchi
+  class Pagy
+    # Provide a ready to use pagy environment when included in irb/rails console
+    module Console
+      class Request
+        attr_accessor :base_url, :path, :params
+
+        def initialize
+          @base_url = 'http://www.example.com'
+          @path     = '/path'
+          @params   = { example: '123' }
+        end
+
+        def GET = @params  # rubocop:disable Naming/MethodName
+
+        def cookies = {}
+      end
+
+      class Collection < Array
+        def initialize(arr = Array(1..1000))
+          super
+          @collection = clone
+        end
+
+        def offset(value) = tap { @collection = self[value..] }
+        def limit(value)  = @collection[0, value]
+        def count(*)      = size
+      end
+
+      include Method
+
+      # Direct reference to request.params via a method
+      def params     = request.params
+      def request    = @request ||= Request.new
+      def collection = Collection
+    end
+  end
+end

data/lib/uchi/pagy/toolbox/helpers/loader.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Uchi
+  class Pagy
+    module Loader
+      paths = { public:    { page_url:                'page_url' } }.freeze
+
+      paths.each do |visibility, methods|
+        send(visibility)
+        # Load the method, overriding its own alias. Next requests will call the method directly.
+        define_method(:"load_#{visibility}") do |*args, **kwargs|
+          require_relative methods[__callee__]
+          send(__callee__, *args, **kwargs)
+        end
+        methods.each_key { |method| alias_method method, :"load_#{visibility}" }
+      end
+    end
+  end
+end

data/lib/uchi/pagy/toolbox/helpers/page_url.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Uchi
+  class Pagy
+    # Return the page url for any page
+    # :nocov:
+    def page_url(page, **)
+      case page
+      when :first
+        compose_page_url(nil, **)
+      when :current
+        compose_page_url(@page, **) if @page
+      when :previous
+        compose_page_url(@previous, **) if @previous
+      when :next
+        compose_page_url(@next, **) if @next
+      when :last
+        compose_page_url(@last, **) if @last
+      when Integer, String
+        compose_page_url(page, **)
+      end
+    end
+    # :nocov:
+  end
+end

data/lib/uchi/pagy/toolbox/paginators/method.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative '../../classes/request'
+
+module Uchi
+  class Pagy
+    paginators = { offset:              :OffsetPaginator }.freeze
+
+    path = Pathname.new(__dir__)
+    paginators.each { |symbol, name| autoload name, path.join(symbol.to_s) }
+
+    # Defines the pagy method. Include in the app controller/view.
+    Method = Module.new do
+              protected
+
+              define_method :pagy do |paginator = :offset, collection, **options|
+                Pagy.const_get(paginators[paginator]).paginate(self, collection, **Pagy.options, **options)
+              end
+            end
+  end
+end

data/lib/uchi/pagy/toolbox/paginators/offset.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Uchi
+  class Pagy
+    module OffsetPaginator
+      module_function
+
+      # Return instance and page of results
+      def paginate(context, collection, **options)
+        context.instance_eval do
+          request = Request.new(options[:request] || self.request, options)
+          options[:page]  ||= request.resolve_page(options)
+          options[:limit]   = request.resolve_limit(options)
+          options[:count] ||= collection.instance_of?(Array) ? collection.size : OffsetPaginator.get_count(collection, options)
+          pagy = Offset.new(**options, request:)
+          [pagy, collection.instance_of?(Array) ? collection[pagy.offset, pagy.limit] : pagy.records(collection)]
+        end
+      end
+
+      # Get the collection count
+      def get_count(collection, options)
+        return collection.count unless defined?(::ActiveRecord) && collection.is_a?(::ActiveRecord::Relation)
+
+        count = if options[:count_over] && !collection.group_values.empty?
+                  # COUNT(*) OVER ()
+                  sql = Arel.star.count.over(Arel::Nodes::Grouping.new([]))
+                  collection.unscope(:order).pick(sql).to_i
+                else
+                  collection.count(:all)
+                end
+        count.is_a?(Hash) ? count.size : count
+      end
+    end
+  end
+end

data/lib/uchi/pagy.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require_relative 'pagy/classes/exceptions'
+require_relative 'pagy/modules/abilities/linkable'
+require_relative 'pagy/modules/abilities/configurable'
+require_relative 'pagy/toolbox/helpers/loader'
+
+module Uchi
+  # Top superclass: it defines only what's common to all the subclasses
+  class Pagy
+    VERSION     = '43.0.0.rc4'
+    ROOT        = Pathname.new(__dir__).parent.freeze
+    DEFAULT     = { limit: 20, limit_key: 'limit', page_key: 'page' }.freeze
+    PAGE_TOKEN  = 'P '
+    LIMIT_TOKEN = 'L '
+    LABEL_TOKEN = 'L'
+    A_TAG       = '<a style="display: none;">#</a>'
+
+    path = Pathname.new(__FILE__).sub_ext('')
+    autoload :Method,             path.join('toolbox/paginators/method')
+    autoload :I18n,               path.join('modules/i18n/i18n')
+    autoload :Console,            path.join('modules/console')
+    autoload :Offset,             path.join('classes/offset/offset')
+
+    def self.options = @options ||= {}
+
+    extend Configurable
+    include Linkable
+    include Loader
+
+    attr_reader :page, :next, :in, :limit, :options
+
+    protected
+
+    # Define the hierarchical identity methods, overridden by the respective classes
+    def offset?    = false
+    def countless? = false
+
+    # Validates and assign the passed options: 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 OptionError.new(self, name, ">= #{min}", @options[name]) \
+              unless @options[name].respond_to?(:to_i) && instance_variable_set(:"@#{name}", @options[name].to_i) >= min
+      end
+    end
+
+    # Merge all the DEFAULT constants of the class hierarchy with the options
+    def assign_options(**options)
+      @request = options.delete(:request) # internal object
+      default  = {}
+      current  = self.class
+      begin
+        default = current::DEFAULT.merge(default)
+        current = current.superclass
+      end until current == Object  # rubocop:disable Lint/Loop  -- see https://github.com/rubocop/rubocop-performance/issues/362
+      @options = default.merge!(options.delete_if { |k, v| default.key?(k) && (v.nil? || v == '') }).freeze
+    end
+  end
+end

data/lib/uchi/repository/routes.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Uchi
+  class Repository
+    class Routes
+      attr_reader :plural, :repository, :singular
+
+      def initialize(repository)
+        @repository = repository
+        @singular = repository.controller_name.singularize
+        @plural = repository.controller_name.pluralize
+      end
+
+      def path_for(action, **options)
+        action = action.to_sym
+        case action
+        when :destroy, :edit, :new, :show, :update
+          singular_path_for(action, **options)
+        else
+          plural_path_for(action, **options)
+        end
+      end
+
+      def root_path
+        "/#{uchi_namespace}/"
+      end
+
+      private
+
+      def call_url_helper_in_main_app(parts, **options)
+        url_helper_name = parts.join("_")
+        Rails.application.routes.url_helpers.send(url_helper_name, **options)
+      end
+
+      def plural_path_for(_action, **options)
+        parts = [
+          uchi_namespace,
+          plural,
+          "path"
+        ].compact
+        call_url_helper_in_main_app(parts, **options)
+      end
+
+      def singular_path_for(action, **options)
+        action = nil if action == :show
+        action = nil if action == :update
+        action = nil if action == :destroy
+        parts = [
+          action,
+          uchi_namespace,
+          singular,
+          "path"
+        ].compact
+        call_url_helper_in_main_app(parts, **options)
+      end
+
+      def uchi_namespace
+        :uchi
+      end
+    end
+  end
+end