piko-lite-box 0.0.1

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

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require "dry/configurable"
+require "hanami/action"
+
+module Hanami
+  class Config
+    # Hanami actions config
+    #
+    # This exposes all the settings from the standalone `Hanami::Action` class, pre-configured with
+    # sensible defaults for actions within a full Hanami app. It also provides additional settings
+    # for further integration of actions with other full stack app components.
+    #
+    # @since 2.0.0
+    # @api public
+    class Actions
+      include Dry::Configurable
+
+      # @!attribute [rw] cookies
+      #   Sets or returns a hash of cookie options for actions.
+      #
+      #   The hash is wrapped by {Hanami::Config::Actions::Cookies}, which also provides an
+      #   `enabled?` method, returning true in the case of any options provided.
+      #
+      #   @example
+      #     config.actions.cookies = {max_age: 300}
+      #
+      #   @return [Hanami::Config::Actions::Cookies]
+      #
+      #   @api public
+      #   @since 2.0.0
+      setting :cookies, default: {}, constructor: -> options { Cookies.new(options) }
+
+      # @!attribute [rw] sessions
+      #   Sets or returns the session store (and its options) for actions.
+      #
+      #   The given values are taken as an argument list to be passed to {Config::Sessions#initialize}.
+      #
+      #   The configured session store is used when setting up the app or slice
+      #   {Slice::ClassMethods#router router}.
+      #
+      #   @example
+      #     config.actions.sessions = :cookie, {secret: "xyz"}
+      #
+      #   @return [Config::Sessions]
+      #
+      #   @see Config::Sessions
+      #   @see Slice::ClassMethods#router
+      #
+      #   @api public
+      #   @since 2.0.0
+      setting :sessions, constructor: proc { |storage, *options| Sessions.new(storage, *options) }
+
+      # @!attribute [rw] csrf_protection
+      #   Sets or returns whether CSRF protection should be enabled for action classes.
+      #
+      #   Defaults to true if {#sessions} is enabled. You can override this by explicitly setting a
+      #   true or false value.
+      #
+      #   When true, this will include `Hanami::Action::CSRFProtection` in all action classes.
+      #
+      #   @return [Boolean]
+      #
+      #   @api public
+      #   @since 2.0.0
+      setting :csrf_protection
+
+      # Returns the Content Security Policy config for actions.
+      #
+      # The resulting policy is set as a default `"Content-Security-Policy"` response header.
+      #
+      # @return [Hanami::Config::Actions::ContentSecurityPolicy]
+      #
+      # @api public
+      # @since 2.0.0
+      attr_accessor :content_security_policy
+
+      # Returns the proc to generate Content Security Policy nonce values.
+      #
+      # The current Rack request object is provided as an optional argument
+      # to the proc, enabling the generation of nonces based on session IDs.
+      #
+      # @example Independent random nonce (default)
+      #   -> { SecureRandom.urlsafe_base64(16) }
+      #
+      # @example Session dependent nonce
+      #   ->(request) { Digest::SHA256.base64digest(request.session[:uuid])[0, 16] }
+      #
+      # @return [Proc]
+      #
+      # @api public
+      # @since 2.3.0
+      setting :content_security_policy_nonce_generator, default: -> { SecureRandom.urlsafe_base64(16) }
+
+      # @!attribute [rw] method_override
+      #   Sets or returns whether HTTP method override should be enabled for action classes.
+      #
+      #   Defaults to true. You can override this by explicitly setting a
+      #   true or false value.
+      #
+      #   When true, this will mount `Rack::MethodOverride` in the Rack middleware stack of the App.
+      #
+      #   @return [Boolean]
+      #
+      #   @api public
+      #   @since 2.1.0
+      setting :method_override, default: true
+
+      # @!attribute [rw] name_inference_base
+      #   @api private
+      #   @since 2.1.0
+      setting :name_inference_base, default: "actions"
+
+      # @!attribute [rw] view_name_inferrer
+      #   @api private
+      #   @since 2.1.0
+      setting :view_name_inferrer, default: Slice::ViewNameInferrer
+
+      # @!attribute [rw] view_name_inference_base
+      #   @api private
+      #   @since 2.1.0
+      setting :view_name_inference_base, default: "views"
+
+      # @api private
+      attr_reader :base_config
+      protected :base_config
+
+      # @api private
+      def initialize(*, **options)
+        super()
+
+        @base_config = Hanami::Action.config.dup
+        @content_security_policy = ContentSecurityPolicy.new
+
+        configure_defaults
+      end
+
+      # @api private
+      def initialize_copy(source)
+        super
+        @base_config = source.base_config.dup
+        @content_security_policy = source.content_security_policy.dup
+      end
+      private :initialize_copy
+
+      # @api private
+      def finalize!(app_config)
+        @base_config.root_directory = app_config.root
+
+        # A nil value for `csrf_protection` means it has not been explicitly configured
+        # (neither true nor false), so we can default it to whether sessions are enabled
+        self.csrf_protection = sessions.enabled? if csrf_protection.nil?
+
+        if content_security_policy
+          default_headers["Content-Security-Policy"] = content_security_policy.to_s
+        end
+      end
+
+      # @api public
+      # @since 2.3.0
+      def content_security_policy? = !!@content_security_policy
+
+      private
+
+      # Apply defaults for base config
+      def configure_defaults
+        self.default_headers = {
+          "X-Frame-Options" => "DENY",
+          "X-Content-Type-Options" => "nosniff",
+          "X-XSS-Protection" => "1; mode=block"
+        }
+      end
+
+      def method_missing(name, *args, &block)
+        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)
+        config.respond_to?(name) || base_config.respond_to?(name) || super
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "dry/configurable"
+require "hanami/assets"
+
+module Hanami
+  class Config
+    # Hanami assets config
+    #
+    # This exposes all the settings from the standalone `Hanami::Assets` class, pre-configured with
+    # sensible defaults for actions within a full Hanami app. It also provides additional settings
+    # for further integration of assets with other full stack app components.
+    #
+    # @since 2.1.0
+    # @api public
+    class Assets
+      include Dry::Configurable
+
+      # @!attribute [rw] serve
+      #   Serve static assets.
+      #
+      #   When this is `true`, the app will serve static assets.
+      #
+      #   If not set, this will:
+      #
+      #     * Check if the `HANAMI_SERVE_ASSETS` environment variable is set to `"true"`.
+      #     * If not, it will check if the app is running in the `development` or `test` environment.
+      #
+      #   @example
+      #     config.assets.serve = true
+      #
+      #   @return [Hanami::Config::Actions::Cookies]
+      #
+      #   @api public
+      #   @since 2.1.0
+      setting :serve
+
+      # @api private
+      attr_reader :base_config
+      protected :base_config
+
+      # @api private
+      def initialize(*, **options)
+        super()
+
+        @base_config = Hanami::Assets::Config.new(**options)
+
+        configure_defaults
+      end
+
+      # @api private
+      def initialize_copy(source)
+        super
+        @base_config = source.base_config.dup
+      end
+      private :initialize_copy
+
+      private
+
+      def configure_defaults
+        self.serve =
+          if ENV.key?("HANAMI_SERVE_ASSETS")
+            ENV["HANAMI_SERVE_ASSETS"] == "true"
+          else
+            Hanami.env?(:development, :test)
+          end
+      end
+
+      def method_missing(name, *args, &block)
+        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)
+        config.respond_to?(name) || base_config.respond_to?(name) || super
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "dry/configurable"
+
+module Hanami
+  class Config
+    # Hanami console config
+    #
+    # @since 2.3.0
+    # @api public
+    class Console
+      include Dry::Configurable
+
+      # @!attribute [rw] engine
+      #  Sets or returns the interactive console engine to be used by `hanami console`.
+      #  Supported values are `:irb` (default) and `:pry`.
+      #
+      #  @example
+      #    config.console.engine = :pry
+      #
+      #  @return [Symbol]
+      #
+      #  @api public
+      #  @since 2.3.0
+      setting :engine, default: :irb
+
+      # Returns the complete list of extensions to be used in the console
+      #
+      # @example
+      #   config.console.include MyExtension, OtherExtension
+      #   config.console.include ThirdExtension
+      #
+      #   config.console.extensions
+      #   # => [MyExtension, OtherExtension, ThirdExtension]
+      #
+      # @return [Array<Module>]
+      #
+      # @api public
+      # @since 2.3.0
+      def extensions = @extensions.dup.freeze
+
+      # Define a module extension to be included in the console
+      #
+      # @param mod [Module] one or more modules to be included in the console
+      # @return [void]
+      #
+      # @api public
+      # @since 2.3.0
+      def include(*mod)
+        @extensions.concat(mod).uniq!
+      end
+
+      # @api private
+      def initialize
+        @extensions = []
+      end
+
+      private
+
+      # @api private
+      def initialize_copy(source)
+        super
+        @extensions = [*source.extensions]
+      end
+
+      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/db.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "dry/configurable"
+
+module Hanami
+  class Config
+    # Hanami DB config
+    #
+    # @since 2.2.0
+    # @api public
+    class DB
+      include Dry::Configurable
+
+      setting :configure_from_parent, default: true
+
+      setting :import_from_parent, default: false
+
+      setting :log_level, default: :debug
+
+      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/i18n.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "dry/configurable"
+require_relative "../providers/i18n"
+
+module Hanami
+  class Config
+    # Hanami I18n config
+    #
+    # @api public
+    # @since 3.0.0
+    class I18n
+      include Dry::Configurable
+
+      # @!attribute [rw] default_locale
+      #   Sets or returns the default locale to use for translations.
+      #
+      #   Defaults to `:en`.
+      #
+      #   @return [Symbol]
+      #
+      #   @example
+      #     config.i18n.default_locale = :fr
+      #
+      #   @api public
+      #   @since 3.0.0
+      setting :default_locale, default: Providers::I18n::DEFAULT_LOCALE
+
+      # @!attribute [rw] available_locales
+      #   Sets or returns the array of available locales for the application.
+      #
+      #   When set, only these locales will be considered available, even if translation files exist
+      #   for other locales. When empty or not set, all locales from loaded translation files are
+      #   available.
+      #
+      #   Defaults to `[]` (all loaded locales are available).
+      #
+      #   @return [Array<Symbol>]
+      #
+      #   @example Restrict to specific locales
+      #     config.i18n.available_locales = [:en, :fr, :de]
+      #
+      #   @api public
+      #   @since 3.0.0
+      setting :available_locales, default: Providers::I18n::DEFAULT_AVAILABLE_LOCALES
+
+      # @!attribute [rw] load_path
+      #   Sets or returns the array of file path patterns for loading per-slice translation files.
+      #
+      #   Patterns can be:
+      #
+      #   - Relative paths/globs (resolved against the slice's own root)
+      #   - Absolute paths (used as-is)
+      #
+      #   Defaults to `["config/i18n/**/*.{yml,yaml,json,rb}"]`.
+      #
+      #   See {#shared_load_path} for common translations that should be loaded into every slice.
+      #
+      #   @return [Array<String>]
+      #
+      #   @example Append custom paths
+      #     config.i18n.load_path += ["config/custom_translations/**/*.yml"]
+      #
+      #   @example Replace default paths
+      #     config.i18n.load_path = ["translations/**/*.yml"]
+      #
+      #   @api public
+      #   @since 3.0.0
+      setting :load_path, default: Providers::I18n::DEFAULT_LOAD_PATH
+
+      # @!attribute [rw] shared_load_path
+      #   Sets or returns the array of file path patterns for loading translation files that
+      #   should be shared across every slice in the app.
+      #
+      #   Relative patterns are resolved against the **app root**, regardless of which slice is
+      #   being loaded. Absolute paths are used as-is. Files matched by these patterns are loaded
+      #   into every slice's i18n backend before that slice's own {#load_path} files, so
+      #   slice-specific translations override shared ones on key conflicts.
+      #
+      #   This is the recommended place for foundational translation data needed by every slice,
+      #   such as the `date.*` and `time.*` keys used by `localize`.
+      #
+      #   Defaults to `["config/i18n/shared/**/*.{yml,yaml,json,rb}"]`.
+      #
+      #   @return [Array<String>]
+      #
+      #   @example Disable shared translations
+      #     config.i18n.shared_load_path = []
+      #
+      #   @example Add another shared source
+      #     config.i18n.shared_load_path += ["vendor/translations/**/*.yml"]
+      #
+      #   @api public
+      #   @since 3.0.0
+      setting :shared_load_path, default: Providers::I18n::DEFAULT_SHARED_LOAD_PATH
+
+      # @!attribute [rw] fallbacks
+      #   Sets or returns the locale fallbacks configuration for missing translations.
+      #
+      #   When enabled, the i18n backend will fall back to other locales when a translation is
+      #   missing in the requested locale.
+      #
+      #   This can be set to `true` to enable default fallbacks, a hash to configure explicit
+      #   fallback chains per locale, or an array to set a default fallback locale for all locales.
+      #
+      #   Defaults to `nil` (fallbacks disabled).
+      #
+      #   @return [Boolean, Hash, Array, nil]
+      #
+      #   @example Enable default fallbacks
+      #     config.i18n.fallbacks = true
+      #
+      #   @example Configure fallbacks with a hash
+      #     config.i18n.fallbacks = {de: [:de, :en], fr: [:fr, :en]}
+      #
+      #   @example Configure a default fallback locale
+      #     config.i18n.fallbacks = [:en]
+      #
+      #   @api public
+      #   @since 3.0.0
+      setting :fallbacks
+
+      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