piko-lite-box 0.0.1

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

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+require "dry/configurable"
+require "dry/logger"
+
+module Hanami
+  class Config
+    # Hanami logger config
+    #
+    # @api public
+    # @since 2.0.0
+    class Logger
+      include Dry::Configurable
+
+      # @return [Hanami::SliceName]
+      #
+      # @api private
+      # @since 2.0.0
+      attr_reader :app_name
+
+      # @return [Symbol]
+      #
+      # @api private
+      # @since 2.0.0
+      attr_reader :env
+
+      # @!attribute [rw] level
+      #   Sets or returns the logger's level.
+      #
+      #   Defaults to `:info` for the production environment and `:debug` for all others.
+      #   Can be set via the `HANAMI_LOG_LEVEL` environment variable.
+      #
+      #   @return [Symbol]
+      #
+      #   @api public
+      #   @since 2.0.0
+      setting :level
+
+      # @!attribute [rw] stream
+      #   Sets or returns the logger's stream.
+      #
+      #   This can be a file path or an `IO`-like object for the logger to write to.
+      #
+      #   Defaults to `"log/test.log"` for the test environment and `$stdout` for all others.
+      #
+      #   @return [String, #write]
+      #
+      #   @api public
+      #   @since 2.0.0
+      setting :stream, default: $stdout
+
+      # @!attribute [rw] formatter
+      #   Sets or returns the logger's formatter.
+      #
+      #   This may be a name that matches a formatter registered with `Dry::Logger`, which includes
+      #   `:string`, `:rack` and `:json`.
+      #
+      #   This may also be an instance of Ruby's built-in `::Logger::Formatter` or any compatible
+      #   object.
+      #
+      #   Defaults to `:json` for the production environment, and `:rack` for all others.
+      #
+      #   @return [Symbol, ::Logger::Formatter]
+      #
+      #   @api public
+      #   @since 2.0.0
+      setting :formatter, default: :string
+
+      # @!attribute [rw] template
+      #   Sets or returns log entry string template
+      #
+      #   Defaults to `false`.
+      #
+      #   @return [Boolean]
+      #
+      #   @api public
+      #   @since 2.0.0
+      setting :template, default: :details
+
+      # @!attribute [rw] filters
+      #   Sets or returns an array of attribute names to filter from logs.
+      #
+      #   Defaults to `["_csrf", "password", "password_confirmation"]`. If you want to preserve
+      #   these defaults, append to this array rather than reassigning it.
+      #
+      #   @return [Array<String>]
+      #
+      #   @api public
+      #   @since 2.0.0
+      setting :filters, default: %w[_csrf password password_confirmation].freeze
+
+      # @!attribute [rw] logger_constructor
+      #   Sets or returns the constructor proc to use for the logger instantiation.
+      #
+      #   Defaults to either `Config#production_logger` or `Config#development_logger`
+      #
+      #   @api public
+      #   @since 2.0.0
+      setting :logger_constructor
+
+      # @!attribute [rw] options
+      #   Sets or returns a hash of options to pass to the {logger_constructor} when initializing
+      #   the logger.
+      #
+      #   Defaults to `{}`
+      #
+      #   @return [Hash]
+      #
+      #   @api public
+      #   @since 2.0.0
+      setting :options, default: {}
+
+      # Returns a new `Logger` config.
+      #
+      # You should not need to initialize this directly, instead use {Hanami::Config#logger}.
+      #
+      # @param env [Symbol] the Hanami env
+      # @param app_name [Hanami::SliceName]
+      #
+      # @api private
+      def initialize(env:, app_name:)
+        @app_name = app_name
+        @env = env
+
+        case env
+        when :development
+          config.level = :debug
+          config.options = {colorize: true}
+          config.logger_constructor = method(:development_logger)
+        when :test
+          config.level = :debug
+          config.stream = File.join("log", "#{env}.log")
+          config.logger_constructor = method(:development_logger)
+        else
+          config.level = :info
+          config.formatter = :json
+          config.logger_constructor = method(:production_logger)
+        end
+      end
+
+      # Returns a new instance of the logger.
+      #
+      # @return [logger_class]
+      #
+      # @api public
+      # @since 2.0.0
+      def instance
+        logger_constructor.call(env, app_name.name, **logger_constructor_options)
+      end
+
+      # Build an instance of a development logger
+      #
+      # This logger is used in both development and test
+      #
+      # @return [Dry::Logger::Dispatcher]
+      # @since 2.0.0
+      # @api private
+      def development_logger(_env, app_name, **options)
+        Dry.Logger(app_name, **options) do |setup|
+          setup
+            .add_backend(log_if: -> entry { !entry.tag?(:rack) && !entry.tag?(:sql) })
+            .add_backend(log_if: -> entry { entry.tag?(:rack) }, formatter: Hanami::Logger::RackFormatter)
+            .add_backend(log_if: -> entry { entry.tag?(:sql) }, formatter: Hanami::Logger::SQLFormatter)
+        end
+      end
+
+      # Build an instance of a production logger
+      #
+      # This logger is used in both development and test
+      #
+      # @return [Dry::Logger::Dispatcher]
+      # @since 2.0.0
+      # @api private
+      def production_logger(_env, app_name, **options)
+        Dry.Logger(app_name, **options)
+      end
+
+      private
+
+      # @api private
+      def logger_constructor_options
+        {
+          stream: stream,
+          level: ENV["HANAMI_LOG_LEVEL"]&.to_sym || level,
+          formatter: formatter,
+          filters: filters,
+          template: template,
+          **options
+        }
+      end
+
+      # @api private
+      def method_missing(name, *args, &block)
+        if config.respond_to?(name)
+          config.public_send(name, *args, &block)
+        else
+          super
+        end
+      end
+
+      # @api private
+      def respond_to_missing?(name, _include_all = false)
+        config.respond_to?(name) || super
+      end
+    end
+  end
+end

data/hanami-3.0.1/lib/hanami/config/null_config.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "dry/configurable"
+
+module Hanami
+  class Config
+    # NullConfig can serve as a fallback config object when out-of-gem config objects are not
+    # available (specifically, when the hanami-action, hanami-router or hanami-view gems are not
+    # loaded)
+    class NullConfig
+      include Dry::Configurable
+
+      def finalize!(*)
+      end
+    end
+  end
+end

data/hanami-3.0.1/lib/hanami/config/router.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "dry/configurable"
+require_relative "../slice/routing/resolver"
+
+module Hanami
+  class Config
+    # Hanami router config
+    #
+    # @since 2.0.0
+    # @api private
+    class Router
+      include Dry::Configurable
+
+      # Base config is provided so router config can include the `base_url`
+      attr_reader :base_config
+      private :base_config
+
+      # @api private
+      # @since 2.0.0
+      def initialize(base_config)
+        @base_config = base_config
+      end
+
+      setting :resolver, default: Slice::Routing::Resolver
+
+      # @api private
+      # @since 2.0.0
+      def options
+        {base_url: base_config.base_url}
+      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

data/hanami-3.0.1/lib/hanami/config/views.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "dry/configurable"
+require "hanami/view"
+
+module Hanami
+  class Config
+    # Hanami views config
+    #
+    # This exposes all the settings from the standalone `Hanami::View` class, pre-configured with
+    # sensible defaults for actions within a full Hanami app. It also provides additional settings
+    # for further integration of views with other full stack app components.
+    #
+    # @since 2.1.0
+    # @api public
+    class Views
+      include Dry::Configurable
+
+      # @!attribute [rw] default_template_engine
+      #   Sets or returns the default template engine to use for generated views.
+      #
+      #   Used by generators when no explicit template engine is specified.
+      #   Supports `erb`, `haml`, and `slim`.
+      #
+      #   Defaults to `"erb"`.
+      #
+      # @example
+      #   config.views.default_template_engine = "slim"
+      #
+      # @return [String] the template engine name
+      #
+      # @api public
+      # @since 2.4.0
+      setting :default_template_engine, default: "erb"
+
+      # @api private
+      # @since 2.1.0
+      attr_reader :base_config
+      protected :base_config
+
+      # @api private
+      # @since 2.1.0
+      def initialize(*)
+        super
+
+        @base_config = Hanami::View.config.dup
+
+        configure_defaults
+      end
+
+      # @api private
+      # @since 2.1.0
+      def initialize_copy(source)
+        super
+        @base_config = source.base_config.dup
+      end
+      private :initialize_copy
+
+      # @api private
+      # @since 2.1.0
+      def finalize!
+        return self if frozen?
+
+        base_config.finalize!
+
+        super
+      end
+
+      private
+
+      def configure_defaults
+        self.layout = "app"
+      end
+
+      # An inflector for views is not configurable via `config.views.inflector` on an
+      # `Hanami::App`. The app-wide inflector is already configurable
+      # there as `config.inflector` and will be used as the default inflector for views.
+      #
+      # A custom inflector may still be provided in an `Hanami::View` subclass, via
+      # `config.inflector=`.
+      NON_FORWARDABLE_METHODS = %i[inflector inflector=].freeze
+      private_constant :NON_FORWARDABLE_METHODS
+
+      def method_missing(name, *args, &block)
+        return super if NON_FORWARDABLE_METHODS.include?(name)
+
+        if config.respond_to?(name)
+          config.public_send(name, *args, &block)
+        elsif base_config.respond_to?(name)
+          base_config.public_send(name, *args, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, _include_all = false)
+        return false if NON_FORWARDABLE_METHODS.include?(name)
+
+        config.respond_to?(name) || base_config.respond_to?(name) || super
+      end
+    end
+  end
+end