piko-lite-box 0.0.1

data/hanami-3.0.1/lib/hanami/extensions/operation/slice_configured_db_operation.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Extensions
+    module Operation
+      # Extends operations to support the database.
+      #
+      # Add an initializer accepting a `rom:` dependency, which is supplied automatically from the
+      # `"db.rom"` component in the operation's slice.
+      #
+      # @api private
+      class SliceConfiguredDBOperation < Module
+        attr_reader :slice
+
+        def initialize(slice)
+          super()
+          @slice = slice
+        end
+
+        def extended(operation_class)
+          require "dry/operation/extensions/rom"
+          operation_class.include Dry::Operation::Extensions::ROM
+
+          operation_class.include InstanceMethods
+          operation_class.include SliceInstanceMethods.new(slice)
+          define_new
+        end
+
+        def inspect
+          "#<#{self.class.name}[#{slice.name}>"
+        end
+
+        private
+
+        def define_new
+          resolve_rom = method(:resolve_rom)
+
+          define_method(:new) do |**kwargs|
+            super(
+              **kwargs,
+              rom: kwargs.fetch(:rom) { resolve_rom.() },
+            )
+          end
+        end
+
+        def resolve_rom
+          slice["db.rom"] if slice.key?("db.rom")
+        end
+
+        module InstanceMethods
+          attr_reader :rom
+
+          def initialize(rom:, **)
+            super()
+            @rom = rom
+          end
+        end
+
+        class SliceInstanceMethods < Module
+          attr_reader :slice
+
+          def initialize(slice)
+            super()
+            @slice = slice
+          end
+
+          def included(operation_class)
+            define_transaction
+          end
+
+          private
+
+          def define_transaction
+            slice = self.slice
+            define_method(:transaction) do |**kwargs, &block|
+              unless rom
+                msg = <<~TEXT.strip
+                  A configured db for #{slice} is required to run transactions.
+                TEXT
+                raise Hanami::ComponentLoadError, msg
+              end
+
+              super(**kwargs, &block)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "dry/operation"
+
+module Hanami
+  module Extensions
+    # Integrated behavior for `Dry::Operation` classes within Hanami apps.
+    #
+    # @see https://github.com/dry-rb/dry-operation
+    #
+    # @api public
+    # @since 2.2.0
+    module Operation
+      require_relative "operation/slice_configured_db_operation"
+
+      # @api private
+      def self.extended(operation_class)
+        super
+
+        operation_class.extend(Hanami::SliceConfigurable)
+      end
+
+      # private
+
+      # @api private
+      def configure_for_slice(slice)
+        extend SliceConfiguredDBOperation.new(slice) if Hanami.bundled?("hanami-db")
+      end
+    end
+  end
+end
+
+Dry::Operation.extend(Hanami::Extensions::Operation)

data/hanami-3.0.1/lib/hanami/extensions/router/errors.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "hanami/router"
+
+module Hanami
+  class Router
+    # Error raised when a request is made for a missing route.
+    #
+    # Raised only when using hanami-router as part of a full Hanami app. When using hanami-router
+    # standalone, the behavior for such requests is to return a "Not Found" response.
+    #
+    # @api public
+    # @since 2.1.0
+    class NotFoundError < Hanami::Router::Error
+      # @return [Hash] the Rack environment for the request
+      #
+      # @api public
+      # @since 2.1.0
+      attr_reader :env
+
+      def initialize(env)
+        @env = env
+
+        message = "No route found for #{env["REQUEST_METHOD"]} #{env["PATH_INFO"]}"
+        super(message)
+      end
+    end
+
+    # Error raised when a request is made for a route using a HTTP method not allowed on the route.
+    #
+    # Raised only when using hanami-router as part of a full Hanami app. When using hanami-router
+    # standalone, the behavior for such requests is to return a "Method Not Allowed" response.
+    #
+    # @api public
+    # @since 2.1.0
+    class NotAllowedError < Hanami::Router::Error
+      # @return [Hash] the Rack environment for the request
+      #
+      # @api public
+      # @since 2.1.0
+      attr_reader :env
+
+      # @return [Array<String>] the allowed methods for the route
+      #
+      # @api public
+      # @since 2.1.0
+      attr_reader :allowed_methods
+
+      def initialize(env, allowed_methods)
+        @env = env
+        @allowed_methods = allowed_methods
+
+        message = "Only #{allowed_methods.join(', ')} requests are allowed at #{env["PATH_INFO"]}"
+        super(message)
+      end
+    end
+  end
+end

data/hanami-3.0.1/lib/hanami/extensions/view/context.rb

@@ -0,0 +1,298 @@
+# frozen_string_literal: true
+
+require_relative "../../errors"
+require_relative "slice_configured_context"
+
+module Hanami
+  module Extensions
+    module View
+      # View context for views in Hanami apps.
+      #
+      # @api public
+      # @since 2.1.0
+      module Context
+        class << self
+          # Returns a context class for the given slice. If a context class is not defined, defines
+          # a class named `Views::Context` within the slice's namespace.
+          #
+          # @api private
+          # @since 2.1.0
+          def context_class(slice)
+            views_namespace = views_namespace(slice)
+
+            if views_namespace.const_defined?(:Context)
+              return views_namespace.const_get(:Context)
+            end
+
+            views_namespace.const_set(:Context, Class.new(context_superclass(slice)).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
+
+          private
+
+          # @api private
+          # @since 2.1.0
+          def context_superclass(slice)
+            return Hanami::View::Context if Hanami.app.equal?(slice)
+
+            begin
+              slice.inflector.constantize(
+                slice.inflector.camelize("#{slice.app.slice_name.name}/views/context")
+              )
+            rescue NameError => exception
+              raise exception unless %i[Views Context].include?(exception.name)
+
+              Hanami::View::Context
+            end
+          end
+
+          # @api private
+          # @since 2.1.0
+          def views_namespace(slice)
+            # TODO: this could be moved into the top-level Extensions::View
+            if slice.namespace.const_defined?(:Views)
+              slice.namespace.const_get(:Views)
+            else
+              slice.namespace.const_set(:Views, Module.new)
+            end
+          end
+        end
+
+        # @api private
+        # @since 2.1.0
+        module ClassExtension
+          def self.included(context_class)
+            super
+
+            context_class.extend(Hanami::SliceConfigurable)
+            context_class.extend(ClassMethods)
+            context_class.prepend(InstanceMethods)
+          end
+
+          # @api private
+          # @since 2.1.0
+          module ClassMethods
+            # @api private
+            # @since 2.1.0
+            def configure_for_slice(slice)
+              extend SliceConfiguredContext.new(slice)
+            end
+          end
+
+          # @api public
+          # @since 2.1.0
+          module InstanceMethods
+            # Returns the app's inflector.
+            #
+            # @return [Dry::Inflector] the inflector
+            #
+            # @api public
+            # @since 2.1.0
+            attr_reader :inflector
+
+            # @see SliceConfiguredContext#define_new
+            #
+            # @api private
+            # @since 2.1.0
+            def initialize(
+              inflector: nil,
+              routes: nil,
+              assets: nil,
+              request: nil,
+              i18n: nil,
+              **args
+            )
+              @inflector = inflector
+              @routes = routes
+              @assets = assets
+              @request = request
+              @i18n = i18n
+
+              @content_for = {}
+
+              super(**args)
+            end
+
+            # @api private
+            # @since 2.1.0
+            def initialize_copy(source)
+              # The standard implementation of initialize_copy will make shallow copies of all
+              # instance variables from the source. This is fine for most of our ivars.
+              super
+
+              # Dup any objects that will be mutated over a given rendering to ensure no leakage of
+              # state across distinct view renderings.
+              @content_for = source.instance_variable_get(:@content_for).dup
+            end
+
+            # Returns the app's assets.
+            #
+            # @return [Hanami::Assets] the assets
+            #
+            # @raise [Hanami::ComponentLoadError] if the hanami-assets gem is not bundled
+            #
+            # @api public
+            # @since 2.1.0
+            def assets
+              unless @assets
+                msg =
+                  if Hanami.bundled?("hanami-assets")
+                    "Have you put files into your assets directory?"
+                  else
+                    "The hanami-assets gem is required to access assets."
+                  end
+
+                raise Hanami::ComponentLoadError, "Assets not available. #{msg}"
+              end
+
+              @assets
+            end
+
+            # Returns the current request, if the view is rendered from within an action.
+            #
+            # @return [Hanami::Action::Request] the request
+            #
+            # @raise [Hanami::ComponentLoadError] if the view is not rendered from within a request
+            #
+            # @api public
+            # @since 2.1.0
+            def request
+              unless @request
+                raise Hanami::ComponentLoadError, <<~STR
+                  Request not available. Only views rendered from Hanami::Action instances have a request.
+                STR
+              end
+
+              @request
+            end
+
+            # Returns true if the view is rendered from within an action and a request is available.
+            #
+            # @return [Boolean]
+            #
+            # @api public
+            # @since 2.3.0
+            def request?
+              !!@request
+            end
+
+            # Returns the app's routes helper.
+            #
+            # @return [Hanami::Slice::RoutesHelper] the routes helper
+            #
+            # @raise [Hanami::ComponentLoadError] if the hanami-router gem is not bundled or routes
+            #   are not defined
+            #
+            # @api public
+            # @since 2.1.0
+            def routes
+              unless @routes
+                raise Hanami::ComponentLoadError, "the hanami-router gem is required to access routes"
+              end
+
+              @routes
+            end
+
+            # Returns the slice's i18n backend.
+            #
+            # @return [Hanami::Providers::I18n::Backend] the i18n backend
+            #
+            # @raise [Hanami::ComponentLoadError] if the i18n gem is not bundled
+            #
+            # @api public
+            # @since 3.0.0
+            def i18n
+              unless @i18n
+                raise Hanami::ComponentLoadError, "the i18n gem is required to access translations"
+              end
+
+              @i18n
+            end
+
+            # @overload content_for(key, value = nil, &block)
+            #   Stores a string or block of template markup for later use.
+            #
+            #   @param key [Symbol] the content key, for later retrieval
+            #   @param value [String, nil] the content, if no block is given
+            #
+            #   @return [String] the content
+            #
+            #   @example
+            #     content_for(:page_title, "Hello world")
+            #
+            #   @example In a template
+            #     <%= content_for :page_title do %>
+            #       <h1>Hello world</h1>
+            #     <% end %>
+            #
+            # @overload content_for(key)
+            #   Returns the previously stored content for the given key.
+            #
+            #   @param key [Symbol] the content key
+            #
+            #   @return [String, nil] the content, or nil if no content previously stored with the
+            #     key
+            #
+            # @api public
+            # @since 2.1.0
+            def content_for(key, value = nil)
+              if block_given?
+                @content_for[key] = yield
+                nil
+              elsif value
+                @content_for[key] = value
+                nil
+              else
+                @content_for[key]
+              end
+            end
+
+            # Returns the current request's CSRF token.
+            #
+            # @return [String] the token
+            #
+            # @raise [Hanami::ComponentLoadError] if the view is not rendered from within a request
+            # @raise [Hanami::Action::MissingSessionError] if sessions are not enabled
+            #
+            # @api public
+            # @since 2.1.0
+            def csrf_token
+              request.session[Hanami::Action::CSRFProtection::CSRF_TOKEN]
+            end
+
+            # Returns the session for the current request.
+            #
+            # @return [Rack::Session::Abstract::SessionHash] the session hash
+            #
+            # @raise [Hanami::ComponentLoadError] if the view is not rendered from within a request
+            # @raise [Hanami::Action::MissingSessionError] if sessions are not enabled
+            #
+            # @api public
+            # @since 2.1.0
+            def session
+              request.session
+            end
+
+            # Returns the flash hash for the current request.
+            #
+            # @return []
+            #
+            # @raise [Hanami::ComponentLoadError] if the view is not rendered from within a request
+            # @raise [Hanami::Action::MissingSessionError] if sessions are not enabled
+            #
+            # @api public
+            # @since 2.1.0
+            def flash
+              request.flash
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Hanami::View::Context.include(Hanami::Extensions::View::Context::ClassExtension)

data/hanami-3.0.1/lib/hanami/extensions/view/part.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require_relative "standard_helpers"
+require_relative "slice_configured_part"
+
+module Hanami
+  module Extensions
+    module View
+      # @api public
+      # @since 2.1.0
+      module Part
+        # @api private
+        # @since 2.1.0
+        def self.included(part_class)
+          super
+
+          part_class.extend(Hanami::SliceConfigurable)
+          part_class.extend(ClassMethods)
+        end
+
+        # @api private
+        # @since 2.1.0
+        module ClassMethods
+          # @api private
+          # @since 2.1.0
+          def configure_for_slice(slice)
+            extend SliceConfiguredPart.new(slice)
+
+            const_set :PartHelpers, Class.new(PartHelpers) { |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
+        end
+
+        # Returns an object including the default Hanami helpers as well as the user-defined helpers
+        # for the part's slice.
+        #
+        # Use this when you need to access helpers inside your part classes.
+        #
+        # @return [Object] the helpers object
+        #
+        # @api public
+        # @since 2.1.0
+        def helpers
+          @helpers ||= self.class.const_get(:PartHelpers).new(context: _context)
+        end
+      end
+
+      # Standalone helpers class including both {StandardHelpers} as well as the user-defined
+      # helpers for the slice.
+      #
+      # Used where helpers should be addressed via an intermediary object (i.e. in parts),
+      # rather than mixed into a class directly.
+      #
+      # @api private
+      # @since 2.1.0
+      class PartHelpers
+        extend Hanami::SliceConfigurable
+
+        include StandardHelpers
+
+        # @api private
+        # @since 2.1.0
+        def self.configure_for_slice(slice)
+          extend SliceConfiguredHelpers.new(slice)
+        end
+
+        # Returns the context for the current view rendering.
+        #
+        # @return [Hanami::View::Context] the context
+        #
+        # @api public
+        # @since 2.1.0
+        attr_reader :_context
+
+        # @api public
+        # @since 2.1.0
+        alias_method :context, :_context
+
+        # @api private
+        # @since 2.1.0
+        def initialize(context:)
+          @_context = context
+        end
+      end
+    end
+  end
+end
+
+Hanami::View::Part.include(Hanami::Extensions::View::Part)

data/hanami-3.0.1/lib/hanami/extensions/view/scope.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "slice_configured_helpers"
+require_relative "standard_helpers"
+
+module Hanami
+  module Extensions
+    module View
+      # @api private
+      # @since 2.1.0
+      module Scope
+        # @api private
+        # @since 2.1.0
+        def self.included(scope_class)
+          super
+
+          scope_class.extend(Hanami::SliceConfigurable)
+          scope_class.include(StandardHelpers)
+          scope_class.extend(ClassMethods)
+        end
+
+        # @api private
+        # @since 2.1.0
+        module ClassMethods
+          # @api private
+          # @since 2.1.0
+          def configure_for_slice(slice)
+            extend SliceConfiguredHelpers.new(slice)
+          end
+        end
+      end
+    end
+  end
+end
+
+Hanami::View::Scope.include(Hanami::Extensions::View::Scope)

data/hanami-3.0.1/lib/hanami/extensions/view/slice_configured_context.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Extensions
+    module View
+      # Provides slice-specific configuration and behavior for any view context class defined within
+      # a slice's module namespace.
+      #
+      # @api public
+      # @since 2.1.0
+      class SliceConfiguredContext < Module
+        attr_reader :slice
+
+        # @api private
+        # @since 2.1.0
+        def initialize(slice)
+          super()
+          @slice = slice
+        end
+
+        # @api private
+        # @since 2.1.0
+        def extended(_context_class)
+          define_new
+        end
+
+        # @api public
+        # @since 2.1.0
+        def inspect
+          "#<#{self.class.name}[#{slice.name}]>"
+        end
+
+        private
+
+        # Defines a {.new} method on the context class that resolves key components from the app
+        # container and provides them to {#initialize} as injected dependencies.
+        #
+        # This includes the following app components:
+        #   - the configured inflector as `inflector`
+        #   - "routes" from the app container as `routes`
+        #   - "assets" from the app container as `assets`
+        #   - "i18n" from the slice container as `i18n`
+        def define_new
+          inflector = slice.inflector
+          resolve_routes = method(:resolve_routes)
+          resolve_assets = method(:resolve_assets)
+          resolve_i18n = method(:resolve_i18n)
+
+          define_method :new do |**kwargs|
+            kwargs[:inflector] ||= inflector
+            kwargs[:routes] ||= resolve_routes.()
+            kwargs[:assets] ||= resolve_assets.()
+            kwargs[:i18n] ||= resolve_i18n.()
+
+            super(**kwargs)
+          end
+        end
+
+        def resolve_routes
+          slice["routes"] if slice.key?("routes")
+        end
+
+        def resolve_assets
+          slice["assets"] if slice.key?("assets")
+        end
+
+        def resolve_i18n
+          slice["i18n"] if slice.key?("i18n")
+        end
+      end
+    end
+  end
+end