piko-lite-box 0.0.1

data/hanami-3.0.1/lib/hanami/extensions/action/i18n_helper.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Extensions
+    module Action
+      # Action translation and localization helpers.
+      #
+      # These helpers are automatically available on `Hanami::Action` when the `i18n` gem is
+      # bundled.
+      #
+      # When relative translation keys (with a leading dot) are given, they are expanded against a
+      # the action's name. For example, `t(".not_found")` within `Main::Actions::Posts::Show`
+      # becomes `"posts.show.not_found"`.
+      #
+      # @example Basic translation in an action
+      #   module Main
+      #     module Actions
+      #       module Posts
+      #         class Create < Main::Action
+      #           def handle(req, res)
+      #             res.flash[:notice] = t("messages.post_created")
+      #             res.redirect_to routes.path(:posts)
+      #           end
+      #         end
+      #       end
+      #     end
+      #   end
+      #
+      # @example Relative key lookup
+      #   # In Main::Actions::Posts::Show, this looks up "posts.show.not_found"
+      #   t(".not_found")
+      #
+      # @see Hanami::Helpers::I18nHelper::Methods
+      #
+      # @api public
+      # @since 3.0.0
+      module I18nHelper
+        include Hanami::Helpers::I18nHelper::Methods
+
+        private
+
+        def _i18n
+          i18n
+        end
+
+        def _resolve_i18n_key(key)
+          return key unless key.to_s.start_with?(".")
+
+          key_base = self.class.config.i18n_key_base
+
+          unless key_base
+            raise(
+              ::I18n::ArgumentError,
+              "Cannot use relative translation key #{key.inspect} outside of a slice-configured action. " \
+              "Use an absolute key (without a leading dot) instead."
+            )
+          end
+
+          "#{key_base}#{key}"
+        end
+      end
+    end
+  end
+end

data/hanami-3.0.1/lib/hanami/extensions/action/name_inferrer.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Extensions
+    module Action
+      # Infers an action's name (e.g. `posts.show`) from its class name relative to its slice
+      # namespace.
+      #
+      # @api private
+      class NameInferrer
+        class << self
+          # @example
+          #   NameInferrer.call(action_class_name: "Main::Actions::Posts::Show", slice: Main::Slice)
+          #   # => "posts.show"
+          #
+          # @param action_class_name [String, nil] the action class name
+          # @param slice [Hanami::Slice] the slice the action belongs to
+          #
+          # @return [String, nil] the inferred name, or nil if `action_class_name` is nil
+          def call(action_class_name:, slice:)
+            return nil unless action_class_name
+
+            slice
+              .inflector
+              .underscore(action_class_name)
+              .sub(%r{^#{slice.slice_name.path}#{PATH_DELIMITER}}, "")
+              .sub(%r{^#{slice.config.actions.name_inference_base}#{PATH_DELIMITER}}, "")
+              .gsub("/", CONTAINER_KEY_DELIMITER)
+          end
+        end
+      end
+    end
+  end
+end

data/hanami-3.0.1/lib/hanami/extensions/action/slice_configured_action.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Extensions
+    module Action
+      require_relative "name_inferrer"
+
+      # Provides slice-specific configuration and behavior for any action class defined
+      # within a slice's module namespace.
+      #
+      # @api private
+      class SliceConfiguredAction < Module
+        attr_reader :slice
+
+        def initialize(slice)
+          super()
+          @slice = slice
+        end
+
+        def extended(action_class)
+          configure_action(action_class)
+          configure_action_i18n(action_class)
+          extend_behavior(action_class)
+          define_inherited
+          define_new
+        end
+
+        def inspect
+          "#<#{self.class.name}[#{slice.name}]>"
+        end
+
+        private
+
+        # @see Hanami::Extensions::Action::InstanceMethods#initialize
+        def define_new
+          resolve_view = method(:resolve_paired_view)
+          view_context_class = method(:view_context_class)
+          resolve_routes = method(:resolve_routes)
+          resolve_rack_monitor = method(:resolve_rack_monitor)
+          resolve_i18n = method(:resolve_i18n)
+
+          define_method(:new) do |**kwargs|
+            super(
+              view: kwargs.fetch(:view) { resolve_view.(self) },
+              view_context_class: kwargs.fetch(:view_context_class) { view_context_class.() },
+              routes: kwargs.fetch(:routes) { resolve_routes.() },
+              rack_monitor: kwargs.fetch(:rack_monitor) { resolve_rack_monitor.() },
+              i18n: kwargs.fetch(:i18n) { resolve_i18n.() },
+              **kwargs,
+            )
+          end
+        end
+
+        # Defines an `inherited` hook on this module so each subclass of the slice-configured
+        # action gets its own `config.i18n_key_base`, inferred from its class name. Mirrors the
+        # approach used by `SliceConfiguredView` for `config.template`.
+        def define_inherited
+          configure_action_i18n = method(:configure_action_i18n)
+
+          define_method(:inherited) do |subclass|
+            super(subclass)
+            configure_action_i18n.call(subclass)
+          end
+        end
+
+        def configure_action(action_class)
+          action_class.settings.each do |setting|
+            # Configure the action from config on the slice, _unless it has already been configured
+            # by a parent slice_, and re-configuring it for this slice would make no change.
+            #
+            # In the case of most slices, its actions config is likely to be the same as its parent
+            # (since each slice copies its `config` from its parent), and if we re-apply the config
+            # here, then it may possibly overwrite config customisations explicitly made in parent
+            # action classes.
+            #
+            # For example, given an app-level base action class, with custom config:
+            #
+            #   module MyApp
+            #     class Action < Hanami::Action
+            #       config.format :json
+            #     end
+            #   end
+            #
+            # And then an action in a slice inheriting from it:
+            #
+            #   module MySlice
+            #     module Actions
+            #       class SomeAction < MyApp::Action
+            #       end
+            #     end
+            #   end
+            #
+            # In this case, `SliceConfiguredAction` will be extended two times:
+            #
+            # 1. When `MyApp::Action` is defined
+            # 2. Again when `MySlice::Actions::SomeAction` is defined
+            #
+            # If we blindly re-configure all action settings each time `SliceConfiguredAction` is
+            # extended, then at the point of (2) above, we'd end up overwriting the custom
+            # `config.default_response_format` explicitly configured in the `MyApp::Action` base
+            # class, leaving `MySlice::Actions::SomeAction` with `config.default_response_format` of
+            # `:html` (the default at `Hanami.app.config.actions.default_response_format`), and not
+            # the `:json` value configured in its immediate superclass.
+            #
+            # This would be surprising behavior, and we want to avoid it.
+            slice_value = slice.config.actions.public_send(setting.name)
+            parent_value = slice.parent.config.actions.public_send(setting.name) if slice.parent
+
+            next if slice.parent && slice_value == parent_value
+
+            action_class.config.public_send(
+              :"#{setting.name}=",
+              setting.mutable? ? slice_value.dup : slice_value
+            )
+          end
+        end
+
+        def configure_action_i18n(action_class)
+          return unless action_class.config.respond_to?(:i18n_key_base=)
+
+          action_class.config.i18n_key_base = NameInferrer.call(
+            action_class_name: action_class.name, slice:
+          )
+        end
+
+        def extend_behavior(action_class)
+          if actions_config.sessions.enabled?
+            require "hanami/action/session"
+            action_class.include Hanami::Action::Session
+          end
+
+          if actions_config.csrf_protection
+            require "hanami/action/csrf_protection"
+            action_class.include Hanami::Action::CSRFProtection
+          end
+
+          if actions_config.cookies.enabled?
+            require "hanami/action/cookies"
+            action_class.include Hanami::Action::Cookies
+          end
+        end
+
+        def resolve_paired_view(action_class)
+          view_identifiers = actions_config.view_name_inferrer.call(
+            action_class_name: action_class.name,
+            slice: slice
+          )
+
+          view_identifiers.each do |identifier|
+            return slice[identifier] if slice.key?(identifier)
+          end
+
+          nil
+        end
+
+        def view_context_class
+          if Hanami.bundled?("hanami-view")
+            return Extensions::View::Context.context_class(slice)
+          end
+
+          # If hanami-view isn't bundled, try and find a possible third party context class with the
+          # same `Views::Context` name (but don't fall back to automatically defining one).
+          if slice.namespace.const_defined?(:Views)
+            views_namespace = slice.namespace.const_get(:Views)
+
+            if views_namespace.const_defined?(:Context)
+              views_namespace.const_get(:Context)
+            end
+          end
+        end
+
+        def resolve_routes
+          slice.app["routes"] if slice.app.key?("routes")
+        end
+
+        def resolve_rack_monitor
+          slice.app["rack.monitor"] if slice.app.key?("rack.monitor")
+        end
+
+        def resolve_i18n
+          slice["i18n"] if slice.key?("i18n")
+        end
+
+        def actions_config
+          slice.config.actions
+        end
+      end
+    end
+  end
+end

data/hanami-3.0.1/lib/hanami/extensions/action.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require "hanami/action"
+require_relative "action/slice_configured_action"
+
+module Hanami
+  # @api private
+  module Extensions
+    # Integrated behavior for `Hanami::Action` classes within Hanami apps.
+    #
+    # @see InstanceMethods
+    # @see https://github.com/hanami/hanami-action
+    #
+    # @api public
+    # @since 2.0.0
+    module Action
+      # @api private
+      def self.included(action_class)
+        super
+
+        action_class.extend(Hanami::SliceConfigurable)
+        action_class.extend(ClassMethods)
+        action_class.prepend(InstanceMethods)
+      end
+
+      # Class methods for app-integrated actions.
+      #
+      # @since 2.0.0
+      module ClassMethods
+        # @api private
+        def configure_for_slice(slice)
+          extend SliceConfiguredAction.new(slice)
+        end
+      end
+
+      # Instance methods for app-integrated actions.
+      #
+      # @since 2.0.0
+      module InstanceMethods
+        # @api private
+        attr_reader :view
+
+        # @api private
+        attr_reader :view_context_class
+
+        # Returns the slice's {Hanami::Slice::RoutesHelper RoutesHelper}.
+        #
+        # @return [Hanami::Slice::RoutesHelper]
+        #
+        # @api public
+        # @since 2.0.0
+        attr_reader :routes
+
+        # Returns the slice's `Dry::Monitor::Rack::Middleware`.
+        #
+        # @return [Dry::Monitor::Rack::Middleware]
+        #
+        # @api public
+        # @since 2.0.0
+        attr_reader :rack_monitor
+
+        # Returns the slice's i18n backend.
+        #
+        # @return [Hanami::Providers::I18n::Backend]
+        #
+        # @api public
+        # @since x.x.x
+        attr_reader :i18n
+
+        # @overload def initialize(routes: nil, **kwargs)
+        #   Returns a new `Hanami::Action` with app components injected as dependencies.
+        #
+        #   These dependencies are injected automatically so that a call to `.new` (with no
+        #   arguments) returns a fully integrated action.
+        #
+        #   @param routes [Hanami::Slice::RoutesHelper]
+        #
+        #   @api public
+        #   @since 2.0.0
+        def initialize(view: nil, view_context_class: nil, rack_monitor: nil, routes: nil, i18n: nil, **kwargs)
+          @view = view
+          @view_context_class = view_context_class
+          @routes = routes
+          @rack_monitor = rack_monitor
+          @i18n = i18n
+
+          super(**kwargs)
+        end
+
+        private
+
+        # @api private
+        def build_response(**options)
+          options = options.merge(view_options: method(:view_options))
+          super(**options)
+        end
+
+        # @api private
+        def finish(req, res, halted)
+          res.render(view, **req.params) if !halted && auto_render?(res)
+          super
+        end
+
+        # @api private
+        def _handle_exception(request, _response, _exception)
+          super
+        rescue StandardError => exception
+          rack_monitor&.instrument(:error, exception: exception, env: request.env)
+
+          raise
+        end
+
+        # @api private
+        def view_options(request, response)
+          {context: view_context_class&.new(**view_context_options(request, response))}.compact
+        end
+
+        # @api private
+        def view_context_options(request, response)
+          {request: request}
+        end
+
+        # Returns true if a view should automatically be rendered onto the response body.
+        #
+        # This may be overridden to enable or disable automatic rendering.
+        #
+        # @param res [Hanami::Action::Response]
+        #
+        # @return [Boolean]
+        #
+        # @since 2.0.0
+        # @api public
+        def auto_render?(res)
+          view && res.body.empty?
+        end
+      end
+    end
+  end
+end
+
+Hanami::Action.include(Hanami::Extensions::Action)
+
+if Hanami.bundled?("i18n")
+  require_relative "action/i18n_helper"
+  Hanami::Action.setting(:i18n_key_base)
+  Hanami::Action.include(Hanami::Extensions::Action::I18nHelper)
+end

data/hanami-3.0.1/lib/hanami/extensions/db/repo.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "hanami/db"
+
+module Hanami
+  module Extensions
+    # @api private
+    # @since 2.2.0
+    module DB
+      # @api private
+      # @since 2.2.0
+      module Repo
+        def self.included(repo_class)
+          super
+
+          repo_class.extend(Hanami::SliceConfigurable)
+          repo_class.extend(ClassMethods)
+        end
+
+        # @api private
+        # @since 2.2.0
+        module ClassMethods
+          def configure_for_slice(slice)
+            extend SliceConfiguredRepo.new(slice)
+          end
+        end
+      end
+
+      # @api private
+      # @since 2.2.0
+      class SliceConfiguredRepo < Module
+        attr_reader :slice
+
+        def initialize(slice)
+          super()
+          @slice = slice
+        end
+
+        def extended(repo_class)
+          define_inherited
+          configure_repo(repo_class)
+          define_new
+        end
+
+        def inspect
+          "#<#{self.class.name}[#{slice.name}]>"
+        end
+
+        private
+
+        def define_inherited
+          root_for_repo_class = method(:root_for_repo_class)
+
+          define_method(:inherited) do |subclass|
+            super(subclass)
+
+            unless subclass.root
+              root = root_for_repo_class.(subclass)
+              subclass.root root if root
+            end
+          end
+        end
+
+        def configure_repo(repo_class)
+          repo_class.struct_namespace struct_namespace
+        end
+
+        def define_new
+          resolve_rom = method(:resolve_rom)
+
+          define_method(:new) do |**kwargs|
+            container = kwargs.delete(:container) || resolve_rom.()
+            super(container: container, **kwargs)
+          end
+        end
+
+        def resolve_rom
+          slice["db.rom"]
+        end
+
+        REPO_CLASS_NAME_REGEX = /^(?<name>.+)_(repo|repository)$/
+
+        def root_for_repo_class(repo_class)
+          repo_class_name = slice.inflector.demodulize(repo_class)
+            .then { slice.inflector.underscore(_1) }
+
+          repo_class_match = repo_class_name.match(REPO_CLASS_NAME_REGEX)
+          return unless repo_class_match
+
+          repo_class_match[:name]
+            .then { slice.inflector.pluralize(_1) }
+            .then(&:to_sym)
+        end
+
+        def struct_namespace
+          @struct_namespace ||=
+            if slice.namespace.const_defined?(:Structs)
+              slice.namespace.const_get(:Structs)
+            else
+              slice.namespace.const_set(:Structs, Module.new)
+            end
+        end
+      end
+    end
+  end
+end
+
+Hanami::DB::Repo.include(Hanami::Extensions::DB::Repo)

data/hanami-3.0.1/lib/hanami/extensions/mailer/slice_configured_mailer.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Extensions
+    module Mailer
+      # Provides slice-specific configuration and behavior for any mailer class defined within a
+      # slice's module namespace.
+      #
+      # This injects the slice's `"mailers.delivery_method"` component into mailer instances, and
+      # points the mailer's view at a slice-configured view class so that mailer templates behave
+      # like regular Hanami view templates — sharing the slice's view context, parts, scopes and
+      # helpers (including i18n). The only behavior not available to mailer views is
+      # request-related state (`request`/`session`/`flash`/`csrf_token`), since mailers are not
+      # rendered from a request.
+      #
+      # @api private
+      class SliceConfiguredMailer < Module
+        attr_reader :slice
+
+        def initialize(slice)
+          super()
+          @slice = slice
+        end
+
+        def extended(mailer_class)
+          configure_mailer(mailer_class)
+          define_new
+          define_inherited
+        end
+
+        def inspect
+          "#<#{self.class.name}[#{slice.name}]>"
+        end
+
+        private
+
+        def define_new
+          resolve_delivery_method = method(:resolve_delivery_method)
+
+          define_method(:new) do |**kwargs|
+            super(
+              delivery_method: kwargs.fetch(:delivery_method) { resolve_delivery_method.() },
+              **kwargs
+            )
+          end
+        end
+
+        # Reconfigures the template name for each subclass.
+        def define_inherited
+          template_name = method(:template_name)
+
+          define_method(:inherited) do |subclass|
+            super(subclass)
+
+            if Hanami.bundled?("hanami-view") && (template = template_name.(subclass))
+              subclass.config.template = template
+            end
+          end
+        end
+
+        def resolve_delivery_method
+          slice["mailers.delivery_method"] if slice.key?("mailers.delivery_method")
+        end
+
+        def configure_mailer(mailer_class)
+          return unless Hanami.bundled?("hanami-view")
+
+          # Build the mailer's view from a slice-configured view class, so it inherits the slice's
+          # context, parts, scopes, paths and helpers. The mailer only needs to supply its own
+          # template name.
+          mailer_class.config.view_class = mailer_view_class
+
+          if (template = template_name(mailer_class))
+            mailer_class.config.template = template
+          end
+        end
+
+        # Returns the view class that mailer views are built from, defining a `Mailers::View` within
+        # the slice if one is not already present.
+        #
+        # This mirrors how the view extension defines a `Views::Context`: because the class is
+        # defined within the slice's namespace, it is configured automatically (paths, context,
+        # parts, scopes, helpers) just like any other view in the slice. A user may define their own
+        # `<Slice>::Mailers::View` to customize mailer rendering; it is used when present.
+        def mailer_view_class
+          namespace = mailers_namespace
+
+          if namespace.const_defined?(:View, _inherit = false)
+            namespace.const_get(:View)
+          else
+            namespace.const_set(:View, define_mailer_view)
+          end
+        end
+
+        # Defines and configures a view class for the slice's mailers, inheriting from the slice's
+        # own base view class if present, otherwise from the plain `Hanami::View`.
+        def define_mailer_view
+          superclass =
+            begin
+              slice.inflector.constantize("#{slice.namespace.name}::View")
+            rescue NameError
+              Hanami::View
+            end
+
+          Class.new(superclass).tap { |klass|
+            # Call configure_for_slice explicitly, since this is an anonymous class at this point,
+            # so the slice cannot be inferred from its name.
+            klass.configure_for_slice(slice)
+          }
+        end
+
+        def mailers_namespace
+          if slice.namespace.const_defined?(:Mailers, _inherit = false)
+            slice.namespace.const_get(:Mailers)
+          else
+            slice.namespace.const_set(:Mailers, Module.new)
+          end
+        end
+
+        # Returns the template name for the mailer, retaining the `mailers/` segment from the
+        # mailer's namespace so templates resolve under `templates/mailers/` within the slice.
+        #
+        # For example, `App::Mailers::Welcome` will use template `"mailers/welcome"`.
+        def template_name(mailer_class)
+          return unless mailer_class.name
+
+          slice.inflector
+            .underscore(mailer_class.name)
+            .sub(/^#{slice.slice_name.path}\//, "")
+        end
+      end
+    end
+  end
+end

data/hanami-3.0.1/lib/hanami/extensions/mailer.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "hanami/mailer"
+require_relative "mailer/slice_configured_mailer"
+
+module Hanami
+  module Extensions
+    # Integrated behavior for `Hanami::Mailer` classes within Hanami apps.
+    #
+    # @api private
+    module Mailer
+      def self.included(mailer_class)
+        super
+
+        mailer_class.extend(Hanami::SliceConfigurable)
+        mailer_class.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def configure_for_slice(slice)
+          extend SliceConfiguredMailer.new(slice)
+        end
+      end
+    end
+  end
+end
+
+Hanami::Mailer.include(Hanami::Extensions::Mailer)