piko-lite-box 0.0.1

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

@@ -0,0 +1,564 @@
+# frozen_string_literal: true
+
+require "uri"
+require "pathname"
+require "dry/configurable"
+require "dry/inflector"
+
+require_relative "constants"
+require_relative "universal_logger"
+
+module Hanami
+  # Hanami app config
+  #
+  # @since 2.0.0
+  class Config
+    include Dry::Configurable
+
+    # @!attribute [rw] root
+    #   Sets the root for the app or slice.
+    #
+    #   For the app, this defaults to `Dir.pwd`. For slices detected in `slices/` `config/slices/`,
+    #   this defaults to `slices/[slice_name]/`.
+    #
+    #   Accepts a string path and will return a `Pathname`.
+    #
+    #   @return [Pathname]
+    #
+    #   @api public
+    #   @since 2.0.0
+    setting :root, constructor: ->(path) { Pathname(path) if path }
+
+    # @!attribute [rw] inflector
+    #   Sets the app's inflector.
+    #
+    #   This expects a `Dry::Inflector` (or compatible) inflector instance.
+    #
+    #   To configure custom inflection rules without having to assign a whole inflector, see
+    #   {#inflections}.
+    #
+    #   @return [Dry::Inflector]
+    #
+    #   @see #inflections
+    #
+    #   @api public
+    #   @since 2.0.0
+    setting :inflector, default: Dry::Inflector.new
+
+    # @!attribute [rw] settings_store
+    #   Sets the store used to retrieve {Hanami::Settings} values.
+    #
+    #   Defaults to an instance of {Hanami::Settings::EnvStore}.
+    #
+    #   @return [#fetch]
+    #
+    #   @see Hanami::Settings
+    #   @see Hanami::Settings::EnvStore#fetch
+    #
+    #   @api public
+    #   @since 2.0.0
+    setting :settings_store, default: Hanami::Settings::EnvStore.new
+
+    # @!attribute [rw] slices
+    #   Sets the slices to load when the app is preared or booted.
+    #
+    #   Defaults to `nil`, which will load all slices. Set this to an array of slice names to load
+    #   only those slices.
+    #
+    #   This attribute is also populated from the `HANAMI_SLICES` environment variable.
+    #
+    #   @example
+    #     config.slices = ["admin", "search"]
+    #
+    #   @example
+    #     ENV["HANAMI_SLICES"] # => "admin,search"
+    #     config.slices # => ["admin", "search"]
+    #
+    #   @return [Array<String>, nil]
+    #
+    #   @api public
+    #   @since 2.0.0
+    setting :slices
+
+    # @!attribute [rw] shared_app_component_keys
+    #   Sets the keys for the components to be imported from the app into all other slices.
+    #
+    #   You should append items to this array, since the default shared components are essential for
+    #   slices to operate within the app.
+    #
+    #   @example
+    #     config.shared_app_component_keys += ["shared_component_a", "shared_component_b"]
+    #
+    #   @return [Array<String>]
+    #
+    #   @api public
+    #   @since 2.0.0
+    setting :shared_app_component_keys, default: %w[
+      inflector
+      logger
+      notifications
+      rack.monitor
+      routes
+      settings
+    ]
+
+    # @!attribute [rw] no_auto_register_paths
+    #   Sets the paths to skip from container auto-registration.
+    #
+    #   Paths are relative to `/app` or a slice root.
+    #
+    #   Defaults to `["db", "entities", "relations", "structs"]`.
+    #
+    #   @return [Array<String>] array of relative paths
+    #
+    #   @api public
+    #   @since 2.0.0
+    setting :no_auto_register_paths, default: [
+      "db",
+      "entities",
+      "relations",
+      "structs"
+    ]
+
+    # @!attribute [rw] no_memoize
+    #   Sets the components that should not be memoized in the container.
+    #
+    #   All auto-registered components are memoized by default, meaning each component is resolved
+    #   only once, with the same instance returned on every subsequent resolution.
+    #
+    #   Use this setting to opt specific components out of memoization. It accepts an array of key
+    #   prefixes (strings) for the simple case, or a proc for full control. The proc receives a
+    #   `Dry::System::Component` and should return `true` for components that should _not_ be
+    #   memoized.
+    #
+    #   Individual components can also opt out by adding a `# memoize: false` magic comment at the
+    #   top of their source file.
+    #
+    #   Defaults to `[]` (all components memoized).
+    #
+    #   @example Opt out by key prefix
+    #     config.no_memoize = ["workers", "jobs"]
+    #
+    #   @example Opt out with a proc
+    #     config.no_memoize = ->(component) {
+    #       component.key.start_with?("workers")
+    #     }
+    #
+    #   @return [Array<String>, Proc]
+    #
+    #   @api public
+    #   @since 2.3.0
+    setting :no_memoize, default: []
+
+    # @!attribute [rw] base_url
+    #   Sets the base URL for app's web server.
+    #
+    #   This is passed to the {Slice::ClassMethods#router router} and used for generating links.
+    #
+    #   Defaults to `"http://0.0.0.0:2300"`. String values passed are turned into `URI` instances.
+    #
+    #   @return [URI]
+    #
+    #   @see Slice::ClassMethods#router
+    #
+    #   @api public
+    #   @since 2.0.0
+    setting :base_url, default: "http://0.0.0.0:2300", constructor: ->(url) { URI(url) }
+
+    # @!attribute [rw] render_errors
+    #   Sets whether to catch exceptions and render error pages.
+    #
+    #   For HTML responses, these error pages are in `public/{404,500}.html`.
+    #
+    #   Defaults to `true` in production mode, `false` in all others.
+    #
+    #   @return [Boolean]
+    #
+    #   @api public
+    #   @since 2.1.0
+    setting :render_errors, default: false
+
+    # @!attribute [rw] render_detailed_errors
+    #   Sets whether to catch exceptions and render detailed, interactive error pages.
+    #
+    #   Requires the hanami-webconsole gem to be available.
+    #
+    #   Defaults to `false` in production mode, `true` in all others.
+    #
+    #   @return [Boolean]
+    #
+    #   @api public
+    #   @since 2.1.0
+    setting :render_detailed_errors, default: false
+
+    # @!attribute [rw] render_error_responses
+    #   Sets a mapping of exception class names (as strings) to symbolic response status codes used
+    #   for rendering error responses.
+    #
+    #   The response status codes will be passed to `Rack::Utils.status_code`.
+    #
+    #   In ordinary usage, you should not replace this hash. Instead, add keys and values for the
+    #   errors you want handled.
+    #
+    #   @example
+    #     config.render_error_responses
+    #     # => {"Hanami::Router::NotFoundError" => :not_found}
+    #
+    #     config.render_error_responses["MyNotFoundError"] = :not_found
+    #
+    #   @return [Hash{String => Symbol}]
+    #
+    #   @see #render_errors
+    #
+    #   @api public
+    #   @since 2.1.0
+    setting :render_error_responses, default: Hash.new(:internal_server_error).merge!(
+      "Hanami::Router::NotAllowedError" => :not_found,
+      "Hanami::Router::NotFoundError" => :not_found
+    )
+
+    # @!attribute [rw] console
+    #   Returns the app's console config
+    #
+    #   @example
+    #     config.console.engine # => :irb
+    #
+    #   @return [Hanami::Config::Console]
+    #
+    #   @api public
+    #   @since 2.3.0
+    setting :console, default: Hanami::Config::Console.new
+
+    # Returns the app or slice's {Hanami::SliceName slice_name}.
+    #
+    # This is useful for default config values that depend on this name.
+    #
+    # @return [Hanami::SliceName]
+    #
+    # @api private
+    # @since 2.0.0
+    attr_reader :app_name
+
+    # Returns the app's environment.
+    #
+    # @example
+    #   config.env # => :development
+    #
+    # @return [Symbol]
+    #
+    # @see #environment
+    #
+    # @api private
+    # @since 2.0.0
+    attr_reader :env
+
+    # Returns the app's actions config, or a null config if hanami-action is not bundled.
+    #
+    # @example When hanami-action is bundled
+    #   config.actions.default_request_format # => :html
+    #
+    # @example When hanami-action is not bundled
+    #   config.actions.default_request_format # => NoMethodError
+    #
+    # @return [Hanami::Config::Actions, Hanami::Config::NullConfig]
+    #
+    # @api public
+    # @since 2.0.0
+    attr_reader :actions
+
+    # Returns the app's db config, or a null config if hanami-db is not bundled.
+    #
+    # @example When hanami-db is bundled
+    #   config.db.import_from_parent # => false
+    #
+    # @example When hanami-db is not bundle
+    #   config.db.import_from_parent # => NoMethodError
+    #
+    # @return [Hanami::Config::DB, Hanami::Config::NullConfig]
+    #
+    # @api public
+    # @since 2.2.0
+    attr_reader :db
+
+    # Returns the app's i18n config, or a null config if i18n is not bundled.
+    #
+    # @example When i18n is bundled
+    #   config.i18n.default_locale # => :en
+    #
+    # @example When i18n is not bundled
+    #   config.i18n.default_locale # => NoMethodError
+    #
+    # @return [Hanami::Config::I18n, Hanami::Config::NullConfig]
+    #
+    # @api public
+    # @since 2.2.0
+    attr_reader :i18n
+
+    # Returns the app's middleware stack, or nil if hanami-router is not bundled.
+    #
+    # Use this to configure middleware that should apply to all routes.
+    #
+    # @example
+    #   config.middleware.use :body_parser, :json
+    #   config.middleware.use MyCustomMiddleware
+    #
+    # @return [Hanami::Slice::Routing::Middleware::Stack, nil]
+    #
+    # @api public
+    # @since 2.0.0
+    attr_reader :middleware
+
+    # @api private
+    # @since 2.0.0
+    alias_method :middleware_stack, :middleware
+
+    # Returns the app's router config, or a null config if hanami-router is not bundled.
+    #
+    # @example When hanami-router is bundled
+    #   config.router.resolver # => Hanami::Slice::Routing::Resolver
+    #
+    # @example When hanami-router is not bundled
+    #   config.router.resolver # => NoMethodError
+    #
+    # @return [Hanami::Config::Router, Hanami::Config::NullConfig]
+    #
+    # @api public
+    # @since 2.0.0
+    attr_reader :router
+
+    # Returns the app's views config, or a null config if hanami-view is not bundled.
+    #
+    # @example When hanami-view is bundled
+    #   config.views.paths # => [...]
+    #
+    # @example When hanami-view is not bundled
+    #   config.views.paths # => NoMethodError
+    #
+    # @return [Hanami::Config::Views, Hanami::Config::NullConfig]
+    #
+    # @api public
+    # @since 2.1.0
+    attr_reader :views
+
+    # Returns the app's views config, or a null config if hanami-view is not bundled.
+    #
+    # @example When hanami-view is bundled
+    #   config.views.paths # => [...]
+    #
+    # @example When hanami-view is not bundled
+    #   config.views.paths # => NoMethodError
+    #
+    # @return [Hanami::Config::Assets, Hanami::Config::NullConfig]
+    #
+    # @api public
+    # @since 2.1.0
+    attr_reader :assets
+
+    # @api private
+    # rubocop:disable Metrics/AbcSize
+    def initialize(app_name:, env:)
+      @app_name = app_name
+      @env = env
+
+      # Apply default values that are only knowable at initialize-time (vs require-time)
+      self.root = Dir.pwd
+      self.render_errors = (env == :production)
+      self.render_detailed_errors = (env == :development)
+      load_from_env
+
+      @actions = load_dependent_config("hanami-action") {
+        require_relative "config/actions"
+        Actions.new
+      }
+
+      @assets = load_dependent_config("hanami-assets") {
+        require_relative "config/assets"
+        Hanami::Config::Assets.new
+      }
+
+      @db = load_dependent_config("hanami-db") { DB.new }
+
+      @i18n = load_dependent_config("i18n") {
+        require_relative "config/i18n"
+        I18n.new
+      }
+
+      @logger = Config::Logger.new(env: env, app_name: app_name)
+
+      @middleware = load_dependent_config("hanami-router") {
+        require_relative "slice/routing/middleware/stack"
+        Slice::Routing::Middleware::Stack.new
+      }
+
+      @router = load_dependent_config("hanami-router") {
+        require_relative "config/router"
+        Router.new(self)
+      }
+
+      @views = load_dependent_config("hanami-view") {
+        require_relative "config/views"
+        Views.new
+      }
+
+      yield self if block_given?
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    # @api private
+    def initialize_copy(source)
+      super
+
+      @app_name = app_name.dup
+
+      @actions = source.actions.dup
+      @assets = source.assets.dup
+      @db = source.db.dup
+      @i18n = source.i18n.dup
+      @logger = source.logger.dup
+      @middleware = source.middleware.dup
+      @router = source.router.dup.tap do |router|
+        router.instance_variable_set(:@base_config, self)
+      end
+      @views = source.views.dup
+    end
+    private :initialize_copy
+
+    # Finalizes the config.
+    #
+    # This is called when the app or slice is prepared. After this, no further changes to config can
+    # be made.
+    #
+    # @api private
+    def finalize!
+      # Finalize nested configs
+      assets.finalize!
+      actions.finalize!(self)
+      views.finalize!
+      logger.finalize!
+      router.finalize!
+
+      super
+    end
+
+    # Configures the app's custom inflections.
+    #
+    # You should call this one time only. Subsequent calls will override previously configured
+    # inflections.
+    #
+    # @example
+    #   config.inflections do |inflections|
+    #     inflections.acronym "WNBA"
+    #   end
+    #
+    # @see https://dry-rb.org/gems/dry-inflector
+    #
+    # @return [Dry::Inflector] the configured inflector
+    #
+    # @api public
+    # @since 2.0.0
+    def inflections(&block)
+      self.inflector = Dry::Inflector.new(&block)
+    end
+
+    # Disabling this to permit distinct documentation for `#logger` vs `#logger=`
+    #
+    # rubocop:disable Style/TrivialAccessors
+
+    # Returns the logger config.
+    #
+    # Use this to configure various options for the default `Dry::Logger::Dispatcher` logger instance.
+    #
+    # @example
+    #   config.logger.level = :debug
+    #
+    # @return [Hanami::Config::Logger]
+    #
+    # @see Hanami::Config::Logger
+    #
+    # @api public
+    # @since 2.0.0
+    def logger
+      @logger
+    end
+
+    # Sets the app's logger instance.
+    #
+    # This entirely replaces the default `Dry::Logger::Dispatcher` instance that would have been
+    # configured via {#logger}.
+    #
+    # The provided logger will be wrapped with {Hanami::UniversalLogger} if it doesn't support both
+    # keyword arguments and `#tagged` logging, ensuring compatibility with Hanami's logging
+    # interface.
+    #
+    # @see #logger_instance
+    # @see Hanami::UniversalLogger
+    #
+    # @api public
+    # @since 2.0.0
+    def logger=(logger_instance)
+      @logger_instance = Hanami::UniversalLogger[logger_instance]
+    end
+
+    # rubocop:enable Style/TrivialAccessors
+
+    # Returns the configured logger instance.
+    #
+    # Unless you've replaced the logger with {#logger=}, this returns a `Dry::Logger::Dispatcher` configured
+    # with the options configured through {#logger}.
+    #
+    # This configured logger is registered in all app and slice containers as `"logger"`. For
+    # typical usage, you should access the logger via this component, not directly from config.
+    #
+    # @example Accessing the logger component
+    #   Hanami.app["logger"] # => #<Dry::Logger::Dispatcher>
+    #
+    # @example Injecting the logger as a dependency
+    #   module MyApp
+    #     class MyClass
+    #       include Deps["logger"]
+    #
+    #       def my_method
+    #         logger.info("hello")
+    #       end
+    #     end
+    #   end
+    #
+    # @return [Dry::Logger::Dispatcher]
+    #
+    # @see #logger
+    # @see Hanami::Config::Logger
+    #
+    # @api public
+    # @since 2.0.0
+    def logger_instance
+      @logger_instance || logger.instance
+    end
+
+    private
+
+    def load_from_env
+      self.slices = ENV["HANAMI_SLICES"]&.split(",")&.map(&:strip)
+    end
+
+    def load_dependent_config(gem_name)
+      if Hanami.bundled?(gem_name)
+        yield
+      else
+        require_relative "config/null_config"
+        NullConfig.new
+      end
+    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

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Hanami
+  # @api private
+  CONTAINER_KEY_DELIMITER = "."
+  private_constant :CONTAINER_KEY_DELIMITER
+
+  # @api private
+  MODULE_DELIMITER = "::"
+  private_constant :MODULE_DELIMITER
+
+  # @api private
+  PATH_DELIMITER = "/"
+  private_constant :PATH_DELIMITER
+
+  # @api private
+  APP_PATH = "config/app.rb"
+  private_constant :APP_PATH
+
+  # @api private
+  CONFIG_DIR = "config"
+  private_constant :CONFIG_DIR
+
+  # @api private
+  APP_DIR = "app"
+  private_constant :APP_DIR
+
+  # @api private
+  LIB_DIR = "lib"
+  private_constant :LIB_DIR
+
+  # @api private
+  SLICES_DIR = "slices"
+  private_constant :SLICES_DIR
+
+  # @api private
+  ROUTES_PATH = File.join(CONFIG_DIR, "routes")
+  private_constant :ROUTES_PATH
+
+  # @api private
+  ROUTES_CLASS_NAME = "Routes"
+  private_constant :ROUTES_CLASS_NAME
+
+  # @api private
+  SETTINGS_PATH = File.join(CONFIG_DIR, "settings")
+  private_constant :SETTINGS_PATH
+
+  # @api private
+  SETTINGS_CLASS_NAME = "Settings"
+  private_constant :SETTINGS_CLASS_NAME
+
+  # @api private
+  RB_EXT = ".rb"
+  private_constant :RB_EXT
+
+  # @api private
+  RB_EXT_REGEXP = %r{.rb$}
+  private_constant :RB_EXT_REGEXP
+
+  # @api private
+  CONTENT_SECURITY_POLICY_NONCE_REQUEST_KEY = "hanami.content_security_policy_nonce"
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Env
+    # @since 2.0.1
+    # @api private
+    @_loaded = false
+
+    # Uses [dotenv](https://github.com/bkeepers/dotenv) (if available) to populate `ENV` from
+    # various `.env` files.
+    #
+    # For a given `HANAMI_ENV` environment, the `.env` files are looked up in the following order:
+    #
+    # - .env.{environment}.local
+    # - .env.local (unless the environment is `test`)
+    # - .env.{environment}
+    # - .env
+    #
+    # If dotenv is unavailable, the method exits and does nothing.
+    #
+    # @since 2.0.1
+    # @api private
+    def self.load(env = Hanami.env)
+      return unless Hanami.bundled?("dotenv")
+      return if loaded?
+
+      dotenv_files = [
+        ".env.#{env}.local",
+        (".env.local" unless env == :test),
+        ".env.#{env}",
+        ".env"
+      ].compact
+
+      require "dotenv"
+      Dotenv.load(*dotenv_files)
+
+      loaded!
+    end
+
+    # @since 2.0.1
+    # @api private
+    def self.loaded?
+      @_loaded
+    end
+
+    # @since 2.0.1
+    # @api private
+    def self.loaded!
+      @_loaded = true
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Hanami
+  # Base class for all Hanami errors.
+  #
+  # @api public
+  # @since 2.0.0
+  Error = Class.new(StandardError)
+
+  # Error raised when {Hanami::App} fails to load.
+  #
+  # @api public
+  # @since 2.0.0
+  AppLoadError = Class.new(Error)
+
+  # Error raised when an {Hanami::Slice} fails to load.
+  #
+  # @api public
+  # @since 2.0.0
+  SliceLoadError = Class.new(Error)
+
+  # Error raised when an individual component fails to load.
+  #
+  # @api public
+  # @since 2.0.0
+  ComponentLoadError = Class.new(Error)
+
+  # Error raised when there are no routes defined.
+  #
+  # @api public
+  # @since 2.4.0
+  NoRoutesDefinedError = Class.new(Error)
+
+  # Error raised when unsupported middleware configuration is given.
+  #
+  # @see Hanami::Slice::Routing::Middleware::Stack#use
+  #
+  # @api public
+  # @since 2.0.0
+  UnsupportedMiddlewareSpecError = Class.new(Error)
+end