uchi 0.1.2 → 0.1.4

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

data/lib/uchi/repository/translate.rb

@@ -0,0 +1,284 @@
+# frozen_string_literal: true
+
+module Uchi
+  class Repository
+    class Translate
+      attr_reader :repository
+
+      # Returns the breadcrumb label for the given page.
+      #
+      # Example translation key:
+      #   uchi.repository.author.breadcrumb.edit.label
+      def breadcrumb_label(page, record: nil)
+        return breadcrumb_label_for_index if page.to_sym == :index
+
+        default = {
+          show: title_for_record(record)
+        }[page.to_sym].presence
+        default ||= translate("common.#{page}", default: page.to_s.capitalize)
+
+        translate(
+          "label",
+          default: default,
+          model: singular_name,
+          record: title_for_record(record),
+          scope: i18n_scope("breadcrumb.#{page}")
+        )
+      end
+
+      # Returns the breadcrumb label for the index page.
+      #
+      # Returns the first of the following that is present:
+      # 1. Translation from "uchi.repository.author.breadcrumb.index.label"
+      # 2. Translation from "uchi.repository.author.index.title"
+      # 3. plural name of the model
+      # 4. Translation from "common.index"
+      # 5. Capitalized page name ("Index")
+      def breadcrumb_label_for_index
+        first_present_value(
+          translate(i18n_scope("breadcrumb.index.label"), default: nil),
+          translate(i18n_scope("index.title"), default: nil),
+          plural_name,
+          translate("common.index"),
+          "Index"
+        )
+      end
+
+      # Returns a description for the given page, or nil if none is found.
+      # This description is intended to provide additional context for the page
+      # being shown.
+      def description(page, record: nil)
+        translate(
+          "description",
+          default: nil,
+          model: singular_name,
+          record: record,
+          scope: i18n_scope(page)
+        )
+      end
+
+      # Returns a title for a dialog with the given name, e.g. :destroy.
+      # The title may include interpolation keys such as %{record}.
+      #
+      # Example translation key:
+      #   uchi.repository.author.dialog.destroy.title
+      #
+      # Example default value:
+      #   Are you sure you want to delete %{record}?
+      #
+      # Note that the default value itself is also looked up in the "common"
+      # scope, so that it can be shared across repositories.
+      #
+      # Example fallback translation key:
+      #   common.dialog.destroy.title
+      #
+      # Example fallback default value:
+      #   Are you sure you want to delete this record?
+      def destroy_dialog_title(record = nil)
+        translate(
+          "dialog.destroy.title",
+          default: translate(
+            "common.dialog.destroy.title",
+            default: "Are you sure?",
+            record: repository.title(record)
+          ),
+          record: repository.title(record),
+          scope: "uchi.repository.#{i18n_key}"
+        )
+      end
+
+      def failed_destroy
+        translate(
+          "destroy.failure",
+          default: translate(
+            "destroy.failure",
+            default: "The record could not be deleted",
+            scope: "common"
+          ),
+          scope: "uchi.repository.#{i18n_key}"
+        )
+      end
+
+      def initialize(repository:)
+        @repository = repository
+      end
+
+      # Returns the label for the given field.
+      def field_label(field)
+        translate(
+          "label",
+          default: model.human_attribute_name(field.name),
+          scope: i18n_scope("field.#{field.name}")
+        )
+      end
+
+      # Returns the hint for the given field, or nil if none is found.
+      def field_hint(field)
+        translate(
+          "hint",
+          default: nil,
+          scope: i18n_scope("field.#{field.name}")
+        )
+      end
+
+      def link_to_cancel
+        translate("common.cancel", default: "Cancel")
+      end
+
+      def link_to_destroy(record)
+        translate(
+          "link_to_destroy",
+          default: "Delete",
+          model: singular_name,
+          record: repository.title(record),
+          scope: i18n_scope("button")
+        )
+      end
+
+      def link_to_edit(record)
+        translate(
+          "link_to_edit",
+          default: "Edit",
+          model: singular_name,
+          record: repository.title(record),
+          scope: i18n_scope("button")
+        )
+      end
+
+      # Returns the text for the "new" action link.
+      def link_to_new
+        translate(
+          "link_to_new",
+          default: "New %{model}", # rubocop:disable Style/FormatStringToken
+          model: singular_name,
+          scope: i18n_scope("button")
+        )
+      end
+
+      def loading_message
+        translate("loading", default: "Loading...", scope: "uchi.repository.common")
+      end
+
+      # Returns the localized, human-readable plural name of the model this
+      # repository manages.
+      def plural_name
+        ::I18n.translate(
+          "uchi.repository.#{i18n_key}.model",
+          count: 2,
+          default: model.model_name.plural.humanize
+        )
+      end
+
+      def no_records_found
+        translate("no_records_found", default: "No records found", scope: "uchi.common")
+      end
+
+      def search_label
+        translate("common.search", default: "Search")
+      end
+
+      def search_button
+        translate("common.search", default: "Search")
+      end
+
+      # Returns the label for a generic submit button
+      def submit_button
+        translate("common.save", default: "Save")
+      end
+
+      def successful_create
+        translate(
+          "create.success",
+          default: translate(
+            "create.success",
+            default: "Your changes have been saved",
+            scope: "common"
+          ),
+          scope: "uchi.repository.#{i18n_key}"
+        )
+      end
+
+      def successful_destroy
+        translate(
+          "destroy.success",
+          default: translate(
+            "destroy.success",
+            default: "The record has been deleted",
+            scope: "common"
+          ),
+          scope: "uchi.repository.#{i18n_key}"
+        )
+      end
+
+      def successful_update
+        translate(
+          "update.success",
+          default: translate(
+            "update.success",
+            default: "Your changes have been saved",
+            scope: "common"
+          ),
+          scope: "uchi.repository.#{i18n_key}"
+        )
+      end
+
+      # Returns the title for the given page.
+      def title(page, record: nil)
+        return repository.title(record) if record && page == :show
+
+        translate(
+          "title",
+          default: plural_name,
+          model: singular_name,
+          record: record,
+          scope: i18n_scope(page)
+        )
+      end
+
+      private
+
+      # Returns the first translation that yields a present value by looking
+      # through each key in keys in order.
+      def first_present_value(*values)
+        values.find(&:presence)
+      end
+
+      # Returns the segment of the i18n key specific to this repository.
+      def i18n_key
+        @repository.model.model_name.i18n_key
+      end
+
+      def i18n_scope(section = nil)
+        [
+          "uchi.repository",
+          i18n_key,
+          section
+        ].compact.join(".")
+      end
+
+      def model
+        @model ||= repository.model
+      end
+
+      # Returns the localized, human-readable singular name of the model this
+      # repository manages.
+      def singular_name
+        ::I18n.translate(
+          "uchi.repository.#{i18n_key}.model",
+          count: 1,
+          default: model.model_name.human(count: 1)
+        )
+      end
+
+      def title_for_record(record)
+        return nil unless record
+
+        repository.title(record)
+      end
+
+      def translate(key, **options)
+        Uchi::I18n.translate(key, **options)
+      end
+    end
+  end
+end

data/lib/uchi/repository.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require_relative "repository/routes"
+
+module Uchi
+  class Repository
+    class << self
+      # Returns all defined Uchi::Repository classes
+      def all
+        Uchi::Repositories.constants.map { |const_name|
+          Uchi::Repositories.const_get(const_name)
+        }
+      end
+
+      # Returns the repository for the given model, or nil if none is found.
+      def for_model(model)
+        all.find { |repository| repository.model.to_s == model.to_s }
+      end
+
+      # Returns the model class this repository manages.
+      def model
+        @model ||= name.demodulize.constantize
+      end
+    end
+
+    # Returns a new, unsaved instance of the model this repository manages.
+    def build(attributes = {})
+      model.new(attributes)
+    end
+
+    # Returns the "name" of the controller that handles requests for this
+    # repository. Note that this is different from the controllers class name
+    # and is intended for generating URLs.
+    def controller_name
+      model_param_key.pluralize
+    end
+
+    def default_sort_order
+      SortOrder.new(:id, :asc)
+    end
+
+    # Returns an array of fields to show on the edit page.
+    def fields_for_edit
+      fields.select { |field| field.on.include?(:edit) }.each { |field| field.repository = self }
+    end
+
+    # Returns an array of fields to show on the index page.
+    def fields_for_index
+      fields.select { |field| field.on.include?(:index) }.each { |field| field.repository = self }
+    end
+
+    # Returns an array of fields to show on the show page.
+    def fields_for_show
+      fields.select { |field| field.on.include?(:show) }.each { |field| field.repository = self }
+    end
+
+    def find_all(search: nil, scope: model.all, sort_order: default_sort_order)
+      scope ||= model.all
+      query = scope.includes(includes)
+      query = apply_search(query, search)
+      apply_sort_order(query, sort_order)
+    end
+
+    def find(id)
+      model.find(id)
+    end
+
+    # Returns the list of associations to include when querying for records.
+    #
+    # See
+    # https://api.rubyonrails.org/classes/ActiveRecord/QueryMethods.html#method-i-includes
+    # for further details.
+    def includes
+      []
+    end
+
+    def model
+      self.class.model
+    end
+
+    def model_param_key
+      model.model_name.param_key
+    end
+
+    # Returns an instance of Uchi::Repository::Routes for this repository,
+    # which can be used to generate paths and URLs.
+    #
+    # @return [Uchi::Repository::Routes]
+    def routes
+      @routes ||= Routes.new(self)
+    end
+
+    # Returns true if this repository has at least one searchable field.
+    #
+    # @return [Boolean]
+    def searchable?
+      searchable_fields.any?
+    end
+
+    # Returns the title to show for a given record. By default, this method
+    # returns the value of the first of the following methods that exist:
+    #
+    # 1. `name`
+    # 2. `title`
+    # 3. `to_s`
+    #
+    # You can override this method in your repository subclass to provide
+    # custom logic.
+    def title(record)
+      return nil unless record
+
+      [:name, :title, :to_s].each do |method|
+        if record.respond_to?(method)
+          return record.public_send(method)
+        end
+      end
+    end
+
+    # Provides access to translation helpers specific to this repository.
+    def translate
+      @translate ||= Translate.new(repository: self)
+    end
+
+    private
+
+    def apply_search(query, search)
+      return query unless search.present?
+      return query if searchable_fields.empty?
+
+      search = search.strip
+      conditions = searchable_fields.map { |field|
+        arel_field = model.arel_table[field.name]
+        Arel::Nodes::NamedFunction.new(
+          "CAST",
+          [arel_field.as(Arel::Nodes::SqlLiteral.new("VARCHAR"))]
+        ).matches("%#{search}%")
+      }
+      query.where(conditions.inject(:or))
+    end
+
+    def apply_sort_order(query, sort_order)
+      field_to_sort_by = fields.find { |field| field.name == sort_order.name }
+      return query unless field_to_sort_by
+
+      if field_to_sort_by.sortable.respond_to?(:call)
+        field_to_sort_by.sortable.call(query, sort_order.direction)
+      else
+        sort_order.apply(query)
+      end
+    end
+
+    def searchable_fields
+      @searchable_fields ||= fields.select { |field| field.searchable? }
+    end
+  end
+end

data/lib/uchi/sort_order.rb

@@ -0,0 +1,35 @@
+module Uchi
+  class SortOrder
+    attr_reader :name, :direction
+
+    class << self
+      def from_params(params)
+        sort_params = params[:sort] || {}
+        return nil if sort_params.empty?
+
+        by = sort_params[:by]
+        return by unless by
+
+        direction = sort_params[:direction] || :asc
+        new(by, direction)
+      end
+    end
+
+    def ascending?
+      direction == :asc
+    end
+
+    def apply(query)
+      query.order(name => direction)
+    end
+
+    def descending?
+      direction == :desc
+    end
+
+    def initialize(name, direction)
+      @name = name.to_sym
+      @direction = direction.to_sym
+    end
+  end
+end

data/lib/uchi/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Uchi
+  VERSION = "0.1.4"
+end