piko-lite-box 0.0.1

data/hanami-3.0.1/lib/hanami/logger/sql_logger.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Logger
+    # SQL query logger that integrates with the Hanami logger using structured, tagged logging.
+    #
+    # Subscribes to `:sql` notification events (emitted by ROM via the Hanami app's
+    # `"notifications"` component) and logs each query as a structured payload. The log entries are
+    # tagged as `:sql`, which allows Dry Logger backends to route them to a dedicated formatter (see
+    # {SQLFormatter}), in the same way that rack log entries are routed using the `:rack` tag.
+    #
+    # @see SQLFormatter
+    # @see Hanami::Providers::DBLogging
+    #
+    # @api private
+    class SQLLogger
+      attr_reader :logger, :level
+
+      # @param logger [#tagged, #info] a Hanami-compatible logger (typically a
+      #   Dry::Logger::Dispatcher or a {Hanami::UniversalLogger}-wrapped logger)
+      def initialize(logger, level: :debug)
+        @logger = logger
+        @level = level
+      end
+
+      # Subscribes to `:sql` notification events.
+      #
+      # @param notifications [Dry::Monitor::Notifications] the notifications bus
+      # @return [void]
+      def subscribe(notifications)
+        notifications.subscribe(:sql) { |params| log_query(**params) }
+      end
+
+      # Log a SQL query with structured data.
+      #
+      # @param time [Numeric] elapsed time in milliseconds
+      # @param name [Symbol] database adapter name (e.g. `:sqlite`, `:postgres`)
+      # @param query [String] the SQL query string
+      def log_query(time:, name:, query:)
+        logger.tagged(:sql) do
+          logger.public_send(@level) do
+            {query:, db: name, elapsed: time.round(3), elapsed_unit: "ms"}
+          end
+        end
+      end
+    end
+  end
+end

data/hanami-3.0.1/lib/hanami/middleware/assets.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "rack/static"
+
+module Hanami
+  module Middleware
+    class Assets < Rack::Static
+      def initialize(app, options = {}, config: Hanami.app.config)
+        root = config.actions.public_directory
+        urls = [config.assets.path_prefix]
+
+        defaults = {
+          root: root,
+          urls: urls
+        }
+
+        super(app, defaults.merge(options))
+      end
+    end
+  end
+end

data/hanami-3.0.1/lib/hanami/middleware/content_security_policy_nonce.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "rack"
+require "securerandom"
+require_relative "../constants"
+
+module Hanami
+  module Middleware
+    # Generates a random per request nonce value like `mSMnSwfVZVe+LyQy1SPCGw==`, stores it as
+    # `"hanami.content_security_policy_nonce"` in the Rack environment, and replaces all occurrences
+    # of `'nonce'` in the `Content-Security-Policy header with the actual nonce value for the
+    # request, e.g. `'nonce-mSMnSwfVZVe+LyQy1SPCGw=='`.
+    #
+    # @see Hanami::Middleware::ContentSecurityPolicyNonce
+    #
+    # @api private
+    # @since 2.3.0
+    class ContentSecurityPolicyNonce
+      # @api private
+      # @since 2.3.0
+      def initialize(app)
+        @app = app
+      end
+
+      # @api private
+      # @since 2.3.0
+      def call(env)
+        return @app.call(env) unless Hanami.app.config.actions.content_security_policy?
+
+        args = nonce_generator.arity == 1 ? [Rack::Request.new(env)] : []
+        request_nonce = nonce_generator.call(*args)
+
+        env[CONTENT_SECURITY_POLICY_NONCE_REQUEST_KEY] = request_nonce
+
+        _, headers, _ = response = @app.call(env)
+
+        headers["Content-Security-Policy"] = sub_nonce(headers["Content-Security-Policy"], request_nonce)
+
+        response
+      end
+
+      private
+
+      def nonce_generator
+        Hanami.app.config.actions.content_security_policy_nonce_generator
+      end
+
+      def sub_nonce(string, nonce)
+        string&.gsub("'nonce'", "'nonce-#{nonce}'")
+      end
+    end
+  end
+end

data/hanami-3.0.1/lib/hanami/middleware/public_errors_app.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "rack"
+
+module Hanami
+  module Middleware
+    # The errors app given to {Hanami::Middleware::RenderErrors}, which renders error responses
+    # from HTML pages kept in `public/` as simple JSON structures.
+    #
+    # @see Hanami::Middleware::RenderErrors
+    #
+    # @api private
+    # @since 2.1.0
+    class PublicErrorsApp
+      # @api private
+      # @since 2.1.0
+      attr_reader :public_path
+
+      # @api private
+      # @since 2.1.0
+      def initialize(public_path)
+        @public_path = public_path
+      end
+
+      # @api private
+      # @since 2.1.0
+      def call(env)
+        request = Rack::Request.new(env)
+        status = request.path_info[1..].to_i
+        content_type = request.get_header("HTTP_ACCEPT")
+
+        default_body = {
+          status: status,
+          error: Rack::Utils::HTTP_STATUS_CODES.fetch(status, Rack::Utils::HTTP_STATUS_CODES[500])
+        }
+
+        render(status, content_type, default_body)
+      end
+
+      private
+
+      def render(status, content_type, default_body)
+        body, rendered_content_type = render_content(status, content_type, default_body)
+
+        [
+          status,
+          {
+            "Content-Type" => "#{rendered_content_type}; charset=utf-8",
+            "Content-Length" => body.bytesize.to_s
+          },
+          [body]
+        ]
+      end
+
+      def render_content(status, content_type, default_body)
+        if content_type.to_s.start_with?("application/json")
+          require "json"
+          [JSON.generate(default_body), "application/json"]
+        else
+          [render_html_content(status, default_body), "text/html"]
+        end
+      end
+
+      def render_html_content(status, default_body)
+        path = "#{public_path}/#{status}.html"
+
+        if File.exist?(path)
+          File.read(path)
+        else
+          default_body[:error]
+        end
+      end
+    end
+  end
+end

data/hanami-3.0.1/lib/hanami/middleware/render_errors.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "rack"
+
+# rubocop:disable Lint/RescueException
+
+module Hanami
+  module Middleware
+    # Rack middleware that rescues errors raised by the app renders friendly error responses, via a
+    # given "errors app".
+    #
+    # By default, this is enabled only in production mode.
+    #
+    # @see Hanami::Config#render_errors
+    # @see Hanani::Middleware::PublicErrorsApp
+    #
+    # @api private
+    # @since 2.1.0
+    class RenderErrors
+      # @api private
+      # @since 2.1.0
+      class RenderableException
+        attr_reader :exception
+        attr_reader :responses
+
+        # @api private
+        # @since 2.1.0
+        def initialize(exception, responses:)
+          @exception = exception
+          @responses = responses
+        end
+
+        # @api private
+        # @since 2.1.0
+        def rescue_response?
+          responses.key?(exception.class.name)
+        end
+
+        # @api private
+        # @since 2.1.0
+        def status_code
+          Rack::Utils.status_code(responses[exception.class.name])
+        end
+      end
+
+      # @api private
+      # @since 2.1.0
+      def initialize(app, config, errors_app)
+        @app = app
+        @config = config
+        @errors_app = errors_app
+      end
+
+      # @api private
+      # @since 2.1.0
+      def call(env)
+        @app.call(env)
+      rescue Exception => exception
+        raise unless @config.render_errors
+
+        render_exception(env, exception)
+      end
+
+      private
+
+      def render_exception(env, exception)
+        request = Rack::Request.new(env)
+        renderable = RenderableException.new(exception, responses: @config.render_error_responses)
+
+        status = renderable.status_code
+        request.path_info = "/#{status}"
+        request.set_header(Rack::REQUEST_METHOD, "GET")
+
+        @errors_app.call(request.env)
+      rescue Exception => exception
+        # rubocop:disable Style/StderrPuts
+        $stderr.puts "Error during exception rendering: #{exception}\n  #{exception.backtrace * "\n  "}"
+        # rubocop:enable Style/StderrPuts
+
+        [
+          500,
+          {"Content-Type" => "text/plain; charset=utf-8"},
+          ["Internal Server Error"]
+        ]
+      end
+    end
+  end
+end
+
+# rubocop:enable Lint/RescueException

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Hanami
+  # @since 2.0.1
+  # @api private
+  module Port
+    # @since 2.0.1
+    # @api private
+    DEFAULT = 2300
+
+    # @since 2.0.1
+    # @api private
+    ENV_VAR = "HANAMI_PORT"
+
+    # @since 2.0.1
+    # @api private
+    def self.call(value, env = ENV.fetch(ENV_VAR, nil))
+      return Integer(value) if !value.nil? && !default?(value)
+      return Integer(env) unless env.nil?
+      return Integer(value) unless value.nil?
+
+      DEFAULT
+    end
+
+    # @since 2.0.1
+    # @api private
+    def self.call!(value)
+      return if default?(value)
+
+      ENV[ENV_VAR] = value.to_s
+    end
+
+    # @since 2.0.1
+    # @api private
+    def self.default?(value)
+      value.to_i == DEFAULT
+    end
+
+    class << self
+      # @since 2.0.1
+      # @api private
+      alias_method :[], :call
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "setup"
+
+Hanami.prepare

data/hanami-3.0.1/lib/hanami/provider/source.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Provider
+    class Source < Dry::System::Provider::Source
+      attr_reader :slice
+
+      def initialize(slice:, **options, &block)
+        @slice = slice
+        super(**options, &block)
+      end
+
+      def target_container = slice
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 2.2.0
+module Hanami
+  class ProviderRegistrar < Dry::System::ProviderRegistrar
+    def self.for_slice(slice)
+      Class.new(self) do
+        define_singleton_method(:new) do |container|
+          super(container, slice)
+        end
+      end
+    end
+
+    attr_reader :slice
+
+    def initialize(container, slice)
+      super(container)
+      @slice = slice
+    end
+
+    def provider_source_class = Hanami::Provider::Source
+
+    def provider_source_options
+      {slice: slice}
+    end
+  end
+end

data/hanami-3.0.1/lib/hanami/providers/assets.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Hanami
+  # @api private
+  module Providers
+    # Provider source to register routes helper component in Hanami slices.
+    #
+    # @see Hanami::Slice::RoutesHelper
+    #
+    # @api private
+    # @since 2.0.0
+    class Assets < Hanami::Provider::Source
+      # @api private
+      def prepare
+        require "hanami/assets"
+      end
+
+      # @api private
+      def start
+        root = slice.app.root.join("public", "assets", Hanami::Assets.public_assets_dir(target).to_s)
+
+        assets = Hanami::Assets.new(config: slice.config.assets, root: root)
+
+        register(:assets, assets)
+      end
+    end
+  end
+end

data/hanami-3.0.1/lib/hanami/providers/db/adapter.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "dry/configurable"
+
+module Hanami
+  module Providers
+    class DB < Hanami::Provider::Source
+      # @api public
+      # @since 2.2.0
+      class Adapter
+        include Dry::Configurable
+
+        # @api public
+        # @since 2.2.0
+        setting :plugins, mutable: true
+
+        # @api private
+        def initialize(...)
+          @skip_defaults = Hash.new(false)
+        end
+
+        # @api public
+        # @since 2.2.0
+        def skip_defaults(setting_name = nil)
+          @skip_defaults[setting_name] = true
+        end
+
+        # @api private
+        private def skip_defaults?(setting_name = nil)
+          @skip_defaults[setting_name]
+        end
+
+        # @api private
+        def configure_from_adapter(other_adapter)
+          return if skip_defaults?
+
+          plugins.concat(other_adapter.plugins).uniq! unless skip_defaults?(:plugins)
+        end
+
+        # @api private
+        def configure_for_database(database_url)
+        end
+
+        # @api public
+        # @since 2.2.0
+        def plugin(**plugin_spec, &config_block)
+          plugins << [plugin_spec, config_block]
+        end
+
+        # @api public
+        # @since 2.2.0
+        def plugins
+          config.plugins ||= []
+        end
+
+        # @api private
+        def gateway_cache_keys
+          gateway_options
+        end
+
+        # @api private
+        def gateway_options
+          {}
+        end
+
+        # @api public
+        # @since 2.2.0
+        def clear
+          config.plugins = nil
+          self
+        end
+      end
+    end
+  end
+end

data/hanami-3.0.1/lib/hanami/providers/db/adapters.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Providers
+    class DB < Hanami::Provider::Source
+      # @api public
+      # @since 2.2.0
+      class Adapters
+        # @api private
+        # @since 2.2.0
+        ADAPTER_CLASSES = Hash.new(Adapter).update(
+          sql: SQLAdapter
+        ).freeze
+        private_constant :ADAPTER_CLASSES
+
+        extend Forwardable
+
+        def_delegators :adapters, :[], :[]=, :each, :to_h
+
+        # @api private
+        # @since 2.2.0
+        def self.new_adapter(name)
+          ADAPTER_CLASSES[name].new
+        end
+
+        # @api private
+        # @since 2.2.0
+        attr_reader :adapters
+
+        # @api private
+        # @since 2.2.0
+        def initialize
+          @adapters = {}
+        end
+
+        # @api private
+        # @since 2.2.0
+        def initialize_copy(source)
+          @adapters = source.adapters.dup
+
+          source.adapters.each do |key, val|
+            @adapters[key] = val.dup
+          end
+        end
+
+        # @api private
+        # @since 2.2.0
+        def adapter(key)
+          adapters[key] ||= new(key)
+        end
+
+        # @api private
+        # @since 2.2.0
+        def find(key)
+          adapters.fetch(key) { new(key) }
+        end
+
+        # @api private
+        # @since 2.2.0
+        def new(key)
+          self.class.new_adapter(key)
+        end
+      end
+    end
+  end
+end

data/hanami-3.0.1/lib/hanami/providers/db/config.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "dry/core"
+
+module Hanami
+  module Providers
+    class DB < Hanami::Provider::Source
+      # @api public
+      # @since 2.2.0
+      class Config < Dry::Configurable::Config
+        include Dry::Core::Constants
+
+        # @api public
+        # @since 2.2.0
+        def gateway(key)
+          gateway = (gateways[key] ||= Gateway.new)
+          yield gateway if block_given?
+          gateway
+        end
+
+        # @api public
+        # @since 2.2.0
+        def adapter(name)
+          adapter = adapters.adapter(name)
+          yield adapter if block_given?
+          adapter
+        end
+
+        # @api private
+        def each_plugin
+          return to_enum(__method__) unless block_given?
+
+          gateways.values.group_by(&:adapter_name).each do |adapter_name, adapter_gateways|
+            per_adapter_plugins = adapter_gateways.map { _1.adapter.plugins }.flatten(1).uniq
+
+            per_adapter_plugins.each do |plugin_spec, config_block|
+              yield adapter_name, plugin_spec, config_block
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/hanami-3.0.1/lib/hanami/providers/db/gateway.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "dry/configurable"
+require "dry/core"
+
+module Hanami
+  module Providers
+    class DB < Hanami::Provider::Source
+      # @api public
+      # @since 2.2.0
+      class Gateway
+        include Dry::Core::Constants
+        include Dry::Configurable
+
+        setting :database_url
+        setting :adapter_name, default: :sql
+        setting :adapter, mutable: true
+        setting :connection_options, default: {}
+
+        # @api public
+        # @since 2.2.0
+        def adapter(name = Undefined)
+          return config.adapter if name.eql?(Undefined)
+
+          if block_given?
+            # If a block is given, explicitly configure the gateway's adapter
+            config.adapter_name = name
+            adapter = (config.adapter ||= Adapters.new_adapter(name))
+            yield adapter
+            adapter
+          else
+            # If an adapter name is given without a block, use the default adapter configured with
+            # the same name
+            config.adapter_name = adapter_name
+          end
+        end
+
+        # @api public
+        # @since 2.2.0
+        def connection_options(**options)
+          if options.any?
+            config.connection_options.merge!(options)
+          end
+
+          config.connection_options
+        end
+
+        # @api public
+        # @since 2.2.0
+        def options
+          {**connection_options, **config.adapter.gateway_options}
+        end
+
+        # @api private
+        def configure_adapter(default_adapters)
+          default_adapter = default_adapters.find(config.adapter_name)
+          config.adapter ||= default_adapter.dup
+
+          config.adapter.configure_from_adapter(default_adapter)
+
+          config.adapter.configure_for_database(config.database_url)
+
+          self
+        end
+
+        # @api private
+        def cache_keys
+          [config.database_url, config.connection_options, config.adapter.gateway_cache_keys]
+        end
+
+        private
+
+        def method_missing(name, *args, &block)
+          if config.respond_to?(name)
+            config.public_send(name, *args, &block)
+          else
+            super
+          end
+        end
+
+        def respond_to_missing?(name, _include_all = false)
+          config.respond_to?(name) || super
+        end
+      end
+    end
+  end
+end