piko-lite-box 0.0.1

data/hanami-3.0.1/lib/hanami/slice_configurable.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative "constants"
+require_relative "errors"
+
+module Hanami
+  # Calls `configure_for_slice(slice)` on the extended class whenever it is first
+  # subclassed within a module namespace corresponding to a slice.
+  #
+  # @example
+  #   class BaseClass
+  #     extend Hanami::SliceConfigurable
+  #   end
+  #
+  #   # slices/main/lib/my_class.rb
+  #   module Main
+  #     class MyClass < BaseClass
+  #       # Will be called with `Main::Slice`
+  #       def self.configure_for_slice(slice)
+  #         # ...
+  #       end
+  #     end
+  #   end
+  #
+  # @api private
+  # @since 2.0.0
+  module SliceConfigurable
+    class << self
+      def extended(klass)
+        slice_for = method(:slice_for)
+
+        inherited_mod = Module.new do
+          define_method(:inherited) do |subclass|
+            unless Hanami.app?
+              raise ComponentLoadError, "Class #{klass} must be defined within an Hanami app"
+            end
+
+            super(subclass)
+
+            subclass.instance_variable_set(:@configured_for_slices, configured_for_slices.dup)
+
+            slice = slice_for.(subclass)
+            return unless slice
+
+            unless subclass.configured_for_slice?(slice)
+              subclass.configure_for_slice(slice) if subclass.respond_to?(:configure_for_slice)
+              subclass.configured_for_slices << slice
+            end
+          end
+        end
+
+        klass.singleton_class.prepend(inherited_mod)
+      end
+
+      private
+
+      def slice_for(klass)
+        return unless klass.name
+
+        Hanami.app.with_slices.detect { |slice| klass.name.start_with?("#{slice.namespace}#{MODULE_DELIMITER}") }
+      end
+    end
+
+    def configured_for_slice?(slice)
+      configured_for_slices.include?(slice)
+    end
+
+    def configured_for_slices
+      @configured_for_slices ||= []
+    end
+  end
+end

data/hanami-3.0.1/lib/hanami/slice_name.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require_relative "constants"
+
+module Hanami
+  # Represents the name of an {App} or {Slice}.
+  #
+  # @see Slice::ClassMethods#slice_name
+  # @see App::ClassMethods#app_name
+  #
+  # @api public
+  # @since 2.0.0
+  class SliceName
+    # Returns a new SliceName for the slice or app.
+    #
+    # You must provide an inflector for the manipulation of the name into various formats.
+    # This should be given in the form of a Proc that returns the inflector when called.
+    # The reason for this is that the inflector may be replaced by the user during the
+    # app configuration phase, so the proc should ensure that the current instance
+    # of the inflector is returned whenever needed.
+    #
+    # @param slice [#name] the slice or app object
+    # @param inflector [Proc] Proc returning the app's inflector when called
+    #
+    # @api private
+    def initialize(slice, inflector:)
+      @slice = slice
+      @inflector = inflector
+    end
+
+    # Returns the name of the slice as a downcased, underscored string.
+    #
+    # This is considered the canonical name of the slice.
+    #
+    # @example
+    #   slice_name.name # => "main"
+    #
+    # @return [String] the slice name
+    #
+    # @api public
+    # @since 2.0.0
+    def name
+      inflector.underscore(namespace_name)
+    end
+
+    # @api public
+    # @since 2.0.0
+    alias_method :path, :name
+
+    # Returns the name of the slice's module namespace.
+    #
+    # @example
+    #   slice_name.namespace_name # => "Main"
+    #
+    # @return [String] the namespace name
+    #
+    # @api public
+    # @since 2.0.0
+    def namespace_name
+      slice_name.split(MODULE_DELIMITER)[0..-2].join(MODULE_DELIMITER)
+    end
+
+    # Returns the constant for the slice's module namespace.
+    #
+    # @example
+    #   slice_name.namespace_const # => Main
+    #
+    # @return [Module] the namespace module constant
+    #
+    # @api public
+    # @since 2.0.0
+    def namespace_const
+      inflector.constantize(namespace_name)
+    end
+
+    # @api public
+    # @since 2.0.0
+    alias_method :namespace, :namespace_const
+
+    # @api public
+    # @since 2.0.0
+    alias_method :to_s, :name
+
+    # Returns the name of a slice as a downcased, underscored symbol.
+    #
+    # @example
+    #   slice_name.name # => :main
+    #
+    # @return [Symbol] the slice name
+    #
+    # @see name, to_s
+    #
+    # @api public
+    # @since 2.0.0
+    def to_sym
+      name.to_sym
+    end
+
+    private
+
+    def slice_name
+      @slice.name
+    end
+
+    # The inflector is callable to allow for it to be configured/replaced after this
+    # object has been initialized
+    def inflector
+      @inflector.()
+    end
+  end
+end

data/hanami-3.0.1/lib/hanami/slice_registrar.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+require_relative "constants"
+
+module Hanami
+  # @api private
+  class SliceRegistrar
+    VALID_SLICE_NAME_RE = /^[a-z][a-z0-9_]*$/
+    SLICE_DELIMITER = CONTAINER_KEY_DELIMITER
+
+    attr_reader :parent, :slices
+    private :parent, :slices
+
+    def initialize(parent)
+      @parent = parent
+      @slices = {}
+    end
+
+    def register(name, slice_class = nil, &block)
+      unless name.to_s =~ VALID_SLICE_NAME_RE
+        raise ArgumentError, "slice name #{name.inspect} must be lowercase alphanumeric text and underscores only"
+      end
+
+      return unless filter_slice_names([name]).any?
+
+      if slices.key?(name.to_sym)
+        raise SliceLoadError, "Slice '#{name}' is already registered"
+      end
+
+      slice = slice_class || build_slice(name, &block)
+
+      configure_slice(name, slice)
+
+      slices[name.to_sym] = slice
+    end
+
+    def [](name)
+      slices.fetch(name) do
+        raise SliceLoadError, "Slice '#{name}' not found"
+      end
+    end
+
+    def freeze
+      slices.freeze
+      super
+    end
+
+    def load_slices
+      slice_configs = root.join(CONFIG_DIR, SLICES_DIR).glob("*#{RB_EXT}")
+        .map { _1.basename(RB_EXT) }
+
+      slice_dirs = root.join(SLICES_DIR).glob("*")
+        .select(&:directory?)
+        .map { _1.basename }
+
+      (slice_dirs + slice_configs).uniq.sort
+        .then { filter_slice_names(_1) }
+        .each(&method(:load_slice))
+
+      self
+    end
+
+    def each(&block)
+      slices.each_value(&block)
+    end
+
+    def keys
+      slices.keys
+    end
+
+    def to_a
+      slices.values
+    end
+
+    def with_nested
+      to_a.flat_map { |slice|
+        # Return nested slices first so that their more specific namespaces may be picked up first
+        # by SliceConfigurable#slice_for
+        slice.slices.with_nested + [slice]
+      }
+    end
+
+    private
+
+    def root
+      parent.root
+    end
+
+    def inflector
+      parent.inflector
+    end
+
+    def parent_slice_namespace
+      parent.eql?(parent.app) ? Object : parent.namespace
+    end
+
+    # Runs when a slice file has been found inside the app at `config/slices/[slice_name].rb`,
+    # or when a slice directory exists at `slices/[slice_name]`.
+    #
+    # If a slice definition file is found by `find_slice_require_path`, then `load_slice` will
+    # require the file before registering the slice class.
+    #
+    # If a slice class is not found, registering the slice will generate the slice class.
+    def load_slice(slice_name)
+      slice_require_path = find_slice_require_path(slice_name)
+      require slice_require_path if slice_require_path
+
+      slice_class =
+        begin
+          inflector.constantize("#{slice_module_name(slice_name)}#{MODULE_DELIMITER}Slice")
+        rescue NameError => exception
+          raise exception unless exception.name.to_s == inflector.camelize(slice_name) || exception.name.to_s == :Slice
+        end
+
+      register(slice_name, slice_class)
+    end
+
+    # Finds the path to the slice's definition file, if it exists, in the following order:
+    #
+    # 1. `config/slices/[slice_name].rb`
+    # 2. `slices/[parent_slice_name]/config/[slice_name].rb` (unless parent is the app)
+    # 3. `slices/[slice_name]/config/slice.rb`
+    #
+    # If the slice is nested under another slice then it will look in the following order:
+    #
+    # 1. `config/slices/[parent_slice_name]/[slice_name].rb`
+    # 2. `slices/[parent_slice_name]/config/[slice_name].rb`
+    # 3. `slices/[parent_slice_name]/[slice_name]/config/slice.rb`
+    def find_slice_require_path(slice_name)
+      app_slice_file_path = [slice_name]
+      app_slice_file_path.prepend(parent.slice_name) unless parent.eql?(parent.app)
+      ancestors = [
+        parent.app.root.join(CONFIG_DIR, SLICES_DIR, app_slice_file_path.join(File::SEPARATOR)),
+        parent.root.join(CONFIG_DIR, SLICES_DIR, slice_name),
+        root.join(SLICES_DIR, slice_name, CONFIG_DIR, "slice")
+      ]
+
+      ancestors
+        .uniq
+        .find { _1.sub_ext(RB_EXT).file? }
+        &.to_s
+    end
+
+    def build_slice(slice_name, &block)
+      slice_module =
+        begin
+          inflector.constantize(slice_module_name(slice_name))
+        rescue NameError
+          parent_slice_namespace.const_set(inflector.camelize(slice_name), Module.new)
+        end
+
+      slice_module.const_set(:Slice, Class.new(Hanami::Slice, &block))
+    end
+
+    def slice_module_name(slice_name)
+      inflector.camelize("#{parent_slice_namespace.name}#{PATH_DELIMITER}#{slice_name}")
+    end
+
+    def configure_slice(slice_name, slice)
+      slice.instance_variable_set(:@parent, parent)
+
+      # Slices require a root, so provide a sensible default based on the slice's parent
+      slice.config.root ||= root.join(SLICES_DIR, slice_name.to_s)
+
+      slice.config.slices = child_slice_names(slice_name, parent.config.slices)
+    end
+
+    # Returns a filtered array of slice names based on the parent's `config.slices`
+    #
+    # This works with both singular slice names (e.g. `"admin"`) as well as dot-delimited nested
+    # slice names (e.g. `"admin.shop"`).
+    #
+    # It will consider only the base names of the slices (since in this case, a parent slice must be
+    # loaded in order for its children to be loaded).
+    #
+    # @example
+    #   parent.config.slices # => ["admin.shop"]
+    #   filter_slice_names(["admin", "main"]) # => ["admin"]
+    #
+    #   parent.config.slices # => ["admin"]
+    #   filter_slice_names(["admin", "main"]) # => ["admin"]
+    def filter_slice_names(slice_names)
+      slice_names = slice_names.map(&:to_s)
+
+      if parent.config.slices
+        slice_names & parent.config.slices.map { base_slice_name(_1) }
+      else
+        slice_names
+      end
+    end
+
+    # Returns the base slice name from an (optionally) dot-delimited nested slice name.
+    #
+    # @example
+    #   base_slice_name("admin") # => "admin"
+    #   base_slice_name("admin.users") # => "admin"
+    def base_slice_name(name)
+      name.to_s.split(SLICE_DELIMITER).first
+    end
+
+    # Returns an array of slice names specific to the given child slice.
+    #
+    # @example
+    #   child_local_slice_names("admin", ["main", "admin.users"]) # => ["users"]
+    def child_slice_names(parent_slice_name, slice_names)
+      slice_names
+        &.select { |name|
+          name.include?(SLICE_DELIMITER) && name.split(SLICE_DELIMITER)[0] == parent_slice_name.to_s
+        }
+        &.map { |name|
+          name.split(SLICE_DELIMITER)[1..].join(SLICE_DELIMITER) # which version of Ruby supports this?
+        }
+    end
+  end
+end

data/hanami-3.0.1/lib/hanami/universal_logger.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Hanami
+  # An adapter that optionally wraps the logger configured for a Hanami app. Ensures that both
+  # structured and tagged logging can be used across the Hanami framework.
+  #
+  # Provides `.call` as its main entrypoint, expecting a logger object. If a compatible logger is
+  # given (such as the Dry Logger instance provided by default in Hanami apps), then that logger is
+  # returned directly and not wrapped.
+  #
+  # If a non-compatible logger is given, then it will be wrapped by an instance of UniversalLogger,
+  # which adapts a structured and tagged logging API to the given logger.
+  #
+  # This leads to two levels of logger enhancement:
+  #
+  # 1. Structured-capable loggers (accepts keyword arguments, but no `#tagged` method): tags are are
+  #    provided as a `:tags` keyword argument when logging.
+  # 2. Legacy loggers (such as the Ruby standard `Logger`, no keyword arguments, no `#tagged`
+  #    method): messages are logged as JSON, with tags under a `"tags"` key.
+  #
+  # This adapter is used for all loggers configured in Hanami apps.
+  #
+  # @api public
+  # @since 3.0.0
+  class UniversalLogger
+    class << self
+      # Wrap a logger if needed, or return it as-is if fully compatible.
+      #
+      # @param logger [Object] the logger to wrap
+      # @return [Object, UniversalLogger] the original logger or wrapped logger
+      #
+      # @api private
+      def call(logger)
+        return logger if compatible_logger?(logger)
+
+        new(logger)
+      end
+
+      # @api private
+      alias_method :[], :call
+
+      # @api private
+      def compatible_logger?(logger)
+        structured_logger?(logger) && tagged_logger?(logger)
+      end
+
+      # @api private
+      def tagged_logger?(logger)
+        logger.respond_to?(:tagged)
+      end
+
+      # @api private
+      def structured_logger?(logger)
+        logger.respond_to?(:info) &&
+          logger.method(:info).parameters.any? { |(type, _)| type == :keyrest }
+      end
+    end
+
+    # @api public
+    # @since 3.0.0
+    attr_reader :logger
+
+    # @api private
+    def initialize(logger)
+      @logger = logger
+      @structured_logger = self.class.structured_logger?(logger)
+      @tags_thread_key = :"hanami_universal_logger_tags_#{object_id}"
+    end
+
+    # @api private
+    LOG_LEVEL_METHODS = %i[debug info warn error fatal unknown].freeze
+    private_constant :LOG_LEVEL_METHODS
+
+    # @!method debug(message = nil, **payload, &blk)
+    #   Logs a debug message.
+    #
+    #   @param message [String, nil] the log message
+    #   @param payload [Hash] structured data to include in the log entry
+    #   @yieldreturn [Hash] additional payload data to merge
+    #   @return [void]
+    #
+    #   @api public
+    #   @since 3.0.0
+
+    # @!method info(message = nil, **payload, &blk)
+    #   Logs an info message.
+    #
+    #   @param message [String, nil] the log message
+    #   @param payload [Hash] structured data to include in the log entry
+    #   @yieldreturn [Hash] additional payload data to merge
+    #   @return [void]
+    #   @api public
+    #   @since 3.0.0
+
+    # @!method warn(message = nil, **payload, &blk)
+    #   Logs a warning message.
+    #
+    #   @param message [String, nil] the log message
+    #   @param payload [Hash] structured data to include in the log entry
+    #   @yieldreturn [Hash] additional payload data to merge
+    #   @return [void]
+    #
+    #   @api public
+    #   @since 3.0.0
+
+    # @!method error(message = nil, **payload, &blk)
+    #   Logs an error message.
+    #
+    #   @param message [String, nil] the log message
+    #   @param payload [Hash] structured data to include in the log entry
+    #   @yieldreturn [Hash] additional payload data to merge
+    #   @return [void]
+    #
+    #   @api public
+    #   @since 3.0.0
+
+    # @!method fatal(message = nil, **payload, &blk)
+    #   Logs a fatal message.
+    #
+    #   @param message [String, nil] the log message
+    #   @param payload [Hash] structured data to include in the log entry
+    #   @yieldreturn [Hash] additional payload data to merge
+    #   @return [void]
+    #
+    #   @api public
+    #   @since 3.0.0
+
+    # @!method unknown(message = nil, **payload, &blk)
+    #   Logs a message with unknown severity.
+    #
+    #   @param message [String, nil] the log message
+    #   @param payload [Hash] structured data to include in the log entry
+    #   @yieldreturn [Hash] additional payload data to merge
+    #   @return [void]
+    #
+    #   @api public
+    #   @since 3.0.0
+
+    LOG_LEVEL_METHODS.each do |level|
+      define_method(level) do |message = nil, **payload, &blk|
+        _log(level, message, payload, &blk)
+      end
+    end
+
+    # @api public
+    # @since 3.0.0
+    def add(severity, message = nil, progname = nil, &blk)
+      # Convert severity to a level symbol if it's an integer (the standard Logger uses integers).
+      level = _severity_to_level(severity)
+
+      payload = {}
+      payload[:progname] = progname if progname
+
+      _log(level, message, payload, &blk)
+    end
+
+    # @api public
+    # @since 3.0.0
+    alias_method :log, :add
+
+    # @api public
+    # @since 3.0.0
+    def tagged(*tags)
+      previous_tags = _current_tags
+      self._current_tags = tags
+      begin
+        yield
+      ensure
+        self._current_tags = previous_tags
+      end
+    end
+
+    private
+
+    # Delegates any other methods to the wrapped logger.
+    def method_missing(method, ...)
+      if logger.respond_to?(method)
+        logger.public_send(method, ...)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      logger.respond_to?(method, include_private) || super
+    end
+
+    # Maps a standard Logger severity integer (e.g. 1) to a level name (`:info`).
+    #
+    # We need this be able to support the basic `Logger#log` and `#add` methods in addition to the
+    # named severity methods.
+    def _severity_to_level(severity)
+      return severity if severity.is_a?(Symbol)
+
+      SEVERITY_MAP.fetch(severity, :unknown)
+    end
+
+    SEVERITY_MAP = {
+      0 => :debug,   # Logger::DEBUG
+      1 => :info,    # Logger::INFO
+      2 => :warn,    # Logger::WARN
+      3 => :error,   # Logger::ERROR
+      4 => :fatal,   # Logger::FATAL
+      5 => :unknown  # Logger::UNKNOWN
+    }.freeze
+    private_constant :SEVERITY_MAP
+
+    def _log(level, message, payload, &blk)
+      if @structured_logger
+        _log_structured(level, message, payload, &blk)
+      else
+        _log_json(level, message, payload, &blk)
+      end
+    end
+
+    def _log_structured(method, message, payload)
+      payload = payload.merge(yield) if block_given?
+
+      tags = _current_tags
+      payload[:tags] = tags if tags && !tags.empty?
+
+      logger.public_send(method, message, **payload)
+    end
+
+    def _log_json(method, message, payload)
+      json_data =
+        if block_given?
+          yield
+        else
+          payload[:message] = message if message
+          payload
+        end
+
+      tags = _current_tags
+      json_data[:tags] = tags if tags && !tags.empty?
+
+      logger.public_send(method, JSON.generate(json_data))
+    end
+
+    def _current_tags
+      Thread.current[@tags_thread_key]
+    end
+
+    def _current_tags=(tags)
+      Thread.current[@tags_thread_key] = tags
+    end
+  end
+end

data/hanami-3.0.1/lib/hanami/version.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Hanami
+  # Hanami version
+  #
+  # @since 0.9.0
+  # @api private
+  module Version
+    # @api public
+    VERSION = "3.0.1"
+
+    # @since 0.9.0
+    # @api private
+    def self.version
+      VERSION
+    end
+
+    # @since 0.9.0
+    # @api private
+    def self.gem_requirement
+      if prerelease?
+        version
+      else
+        "~> #{major_minor}"
+      end
+    end
+
+    # @since 0.9.0
+    # @api private
+    def self.prerelease?
+      version =~ /alpha|beta|rc/
+    end
+
+    # @since 0.9.0
+    # @api private
+    def self.major_minor
+      version.scan(/\A\d{1,2}\.\d{1,2}/).first
+    end
+  end
+
+  # Defines the full version
+  #
+  # @since 0.1.0
+  VERSION = Version.version
+end