hanami 2.0.0.beta3 → 2.0.0.rc1

data/lib/hanami/config/logger.rb

@@ -0,0 +1,176 @@
+# 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.o
+      attr_reader :app_name
+
+      # @!attribute [rw] level
+      #   Sets or returns the logger level.
+      #
+      #   Defaults to `:info` for the production environment and `:debug` for all others.
+      #
+      #   @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
+
+      # @!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
+
+      # @!attribute [rw] template
+      #   Sets or returns log entry string template
+      #
+      #   Defaults to `false`.
+      #
+      #   @return [Boolean]
+      #
+      #   @api public
+      #   @since 2.0.0
+      setting :template, default: "[%<progname>s] [%<severity>s] [%<time>s] %<message>s"
+
+      # @!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 `Dry.method(:Logger)`.
+      #
+      #   @api public
+      #   @since 2.0.0
+      setting :logger_constructor, default: Dry.method(:Logger)
+
+      # @!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
+
+        config.level = case env
+                       when :production
+                         :info
+                       else
+                         :debug
+                       end
+
+        config.stream = case env
+                        when :test
+                          File.join("log", "#{env}.log")
+                        else
+                          $stdout
+                        end
+
+        config.formatter = case env
+                           when :production
+                             :json
+                           else
+                             :rack
+                           end
+      end
+
+      # Returns a new instance of the logger.
+      #
+      # @return [logger_class]
+      #
+      # @api public
+      # @since 2.0.0
+      def instance
+        logger_constructor.call(app_name.name, **logger_constructor_opts)
+      end
+
+      private
+
+      # @api private
+      def logger_constructor_opts
+        {stream: stream,
+          level: 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, _incude_all = false)
+        config.respond_to?(name) || super
+      end
+    end
+  end
+end

data/lib/hanami/config/null_config.rb

@@ -0,0 +1,14 @@
+# 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-controller, hanami-router or hanami-view gems are not
+    # loaded)
+    class NullConfig
+      include Dry::Configurable
+    end
+  end
+end

data/lib/hanami/{configuration → config}/router.rb

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

data/lib/hanami/{configuration → config}/views.rb

@@ -4,45 +4,41 @@ require "dry/configurable"
 require "hanami/view"
 
 module Hanami
-  class Configuration
-    # Hanami actions configuration
+  class Config
+    # Hanami views config
     #
-    # @since 2.0.0
+    # This is NOT RELEASED as of 2.0.0.
+    #
+    # @api private
     class Views
       include Dry::Configurable
 
       setting :parts_path, default: "views/parts"
 
-      attr_reader :base_configuration
-      protected :base_configuration
+      attr_reader :base_config
+      protected :base_config
 
+      # @api private
       def initialize(*)
         super
 
-        @base_configuration = Hanami::View.config.dup
+        @base_config = Hanami::View.config.dup
 
         configure_defaults
       end
 
+      # @api private
       def initialize_copy(source)
         super
-        @base_configuration = source.base_configuration.dup
+        @base_config = source.base_config.dup
       end
+      private :initialize_copy
 
-      # Returns the list of available settings
-      #
-      # @return [Set]
-      #
-      # @since 2.0.0
       # @api private
-      def settings
-        self.class.settings + View.settings - NON_FORWARDABLE_METHODS
-      end
-
       def finalize!
         return self if frozen?
 
-        base_configuration.finalize!
+        base_config.finalize!
 
         super
       end
@@ -69,8 +65,8 @@ module Hanami
 
         if config.respond_to?(name)
           config.public_send(name, *args, &block)
-        elsif base_configuration.respond_to?(name)
-          base_configuration.public_send(name, *args, &block)
+        elsif base_config.respond_to?(name)
+          base_config.public_send(name, *args, &block)
         else
           super
         end
@@ -79,7 +75,7 @@ module Hanami
       def respond_to_missing?(name, _include_all = false)
         return false if NON_FORWARDABLE_METHODS.include?(name)
 
-        config.respond_to?(name) || base_configuration.respond_to?(name) || super
+        config.respond_to?(name) || base_config.respond_to?(name) || super
       end
     end
   end

data/lib/hanami/config.rb

@@ -0,0 +1,396 @@
+# frozen_string_literal: true
+
+require "uri"
+require "pathname"
+require "dry/configurable"
+require "dry/inflector"
+
+require_relative "constants"
+
+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.
+    #
+    #   Defaults to `["entities"]`.
+    #
+    #   @return [Array<String>] array of relative paths
+    #
+    #   @api public
+    #   @since 2.0.0
+    setting :no_auto_register_paths, default: %w[entities]
+
+    # @!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) }
+
+    # 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-controller is not bundled.
+    #
+    # @example When hanami-controller is bundled
+    #   config.actions.default_request_format # => :html
+    #
+    # @example When hanami-controller 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 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.
+    #
+    # This is NOT RELEASED as of 2.0.0.
+    #
+    # @api private
+    attr_reader :views
+
+    # Returns the app's assets config.
+    #
+    # This is NOT RELEASED as of 2.0.0.
+    #
+    # @api private
+    attr_reader :assets
+
+    # @api private
+    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
+      load_from_env
+
+      @logger = Config::Logger.new(env: env, app_name: app_name)
+
+      # TODO: Make assets config dependent
+      require "hanami/assets/app_config"
+      @assets = Hanami::Assets::AppConfig.new
+
+      @actions = load_dependent_config("hanami-controller") {
+        require_relative "config/actions"
+        Actions.new
+      }
+
+      @router = load_dependent_config("hanami-router") {
+        require_relative "config/router"
+        @middleware = Slice::Routing::Middleware::Stack.new
+        Router.new(self)
+      }
+
+      @views = load_dependent_config("hanami-view") {
+        require_relative "config/views"
+        Views.new
+      }
+
+      yield self if block_given?
+    end
+
+    # @api private
+    def initialize_copy(source)
+      super
+
+      @app_name = app_name.dup
+
+      @assets = source.assets.dup
+      @actions = source.actions.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!
+      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
+    #
+    # @see #logger_instance
+    #
+    # @api public
+    # @since 2.0.0
+    def logger=(logger_instance)
+      @logger_instance = 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
+
+    # @api private
+    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, _incude_all = false)
+      config.respond_to?(name) || super
+    end
+  end
+end

data/lib/hanami/constants.rb

@@ -13,6 +13,10 @@ module Hanami
   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