hanami 2.0.0.alpha4 → 2.0.0.alpha5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2188bc3aee5a164b6610c6bc97fad9f0bba0384bf11a80be27228e7f19dad4e0
-  data.tar.gz: 7fa39987132cf6bfda0b0986a36894d08297c1df06b31354cfbeae934d73a813
+  metadata.gz: 9c8875d3320057cffe3af1a7bb2ff781cd8ad2145c446fc9e9190d344a4a48e6
+  data.tar.gz: c003bc2117815e10f2c15f458fb3bc6d94b480dfe9f2ec98e6458804f8a0d06d
 SHA512:
-  metadata.gz: f7b1aad0186fcdaa94593ba4ff5d01cf4f8d4431aaffba173c3c795c2c0c76993a27da3aa503b0ce59fd67467615c86c50a4ab227986e38dd0986e91c30766a5
-  data.tar.gz: cd2d8b82bc7f98e906686fdab7299282b1c1be4b29278c9ee5b0f9b3cefbb7d31fa83013a840b2b9fa2b8e2b2f3f8c0582ca3587b35ced91f65db6f853d67cf7
+  metadata.gz: 7b133de3c728132ef6255480b10068482d58cf1e2708df395f00cc5981cdccac70cbecdb2c8325cd822298d7c92c0ee0253ab1f8f9d95ddf84b0d6de556e7f3f
+  data.tar.gz: 42b525e3163e7bb73938b5e2fa444ccc15cc38def3e74225086f0e90bb0d805979e0a88a47703fcc73956d68598260ab366a1c155eb94b7114515b8ffc56671e

data/CHANGELOG.md

@@ -1,6 +1,126 @@
 # Hanami
 The web, with simplicity.
 
+## v2.0.0.alpha5 - 2022-01-12
+### Changed
+- [Luca Guidi] Sensible default configuration for application logger, with per-environment defaults:
+
+    The defaults are:
+
+    - In **production**, log for level `info`, send logs to `$stdout` in JSON format without colours
+    - In **development**, log for level `debug`, send logs to `$stdout` in single-line format with colours
+    - In **test**, log for level `debug`, send logs to `log/test.log` in single-line format without colours
+
+    To configure the logger:
+
+    ```ruby
+    module MyApp
+      class Application < Hanami::Application
+        config.logger.level = :info
+
+        config.logger.stream = $stdout
+        config.logger.stream = "/path/to/file"
+        config.logger.stream = StringIO.new
+
+        config.logger.format = :json
+        config.logger.format = MyCustomFormatter.new
+
+        config.logger.color = false # disable coloring
+        config.logger.color = MyCustomColorizer.new
+
+        config.logger.filters << "secret" # add
+        config.logger.filters += ["yet", "another"] # add
+        config.logger.filters = ["foo"] # replace
+
+        # See https://ruby-doc.org/stdlib/libdoc/logger/rdoc/Logger.html
+        config.logger.options = ["daily"] # time based log rotation
+        config.logger.options = [0, 1048576] # size based log rotation
+      end
+    end
+    ```
+
+    To configure the logger for specific environments:
+
+    ```ruby
+    module MyApp
+      class Application < Hanami::Application
+        config.environment(:staging) do
+          config.logger.level = :info
+        end
+      end
+    end
+    ```
+
+    To assign a custom replacement logger object:
+
+    ```ruby
+    module MyApp
+      class Application < Hanami::Application
+        config.logger = MyCustomLogger.new
+      end
+    end
+    ```
+- [Tim Riley] Comprehensive `config.source_dirs` setting
+
+    This replaces the previous `component_dir_paths` setting, and contains two nested settings:
+
+    - `config.source_dirs.component_dirs` (backed by `Dry::System::Config::ComponentDirs`), for directories of source files intended to be registered as components
+    - `config.source_dirs.autoload_paths`, for directories of source files not intended for registration as components, but still to be made accessible by the autoloader
+
+    To add and configure your own additional component dirs:
+
+    ```ruby
+    module MyApp
+      class Application < Hanami::Application
+        # Adding a simple component dir
+        config.source_dirs.component_dirs.add "serializers"
+
+        # Adding a component dir with custom configuration
+        config.source_dirs.component_dirs.add "serializers" do |dir|
+          dir.auto_register = proc { |component|
+            !component.identifier.start_with?("structs")
+          }
+        end
+      end
+    end
+    ```
+
+    To customize the configuration of the default component dirs ("lib", "actions", "repositories", "views"):
+
+    ```ruby
+    module MyApp
+      class Application < Hanami::Application
+        # Customising a default component dir
+        config.source_dirs.component_dirs.dir("lib").auto_register = proc { |component|
+          !component.identifier.start_with?("structs")
+        }
+
+        # Setting default config to apply to all component dirs
+        config.source_dirs.component_dirs.auto_register = proc { |component|
+          !component.identifier.start_with?("entities")
+        }
+
+        # Removing a default component dir
+        config.source_dirs.component_dirs.delete("views")
+      end
+    end
+    ```
+
+    To configure the autoload paths (defaulting to `["entities"]`):
+
+    ```ruby
+    module MyApp
+      class Application < Hanami::Application
+        # Adding your own autoload paths
+        config.source_dirs.autoload_paths << "structs"
+
+        # Or providing a full replacement
+        config.source_dirs.autoload_paths = ["structs"]
+      end
+    end
+    ```
+- [Tim Riley] Application router is lazy loaded (not requiring application to be fully booted) and now available via `Hanami.rack_app` or `Hanami.application.rack_app`, instead of the previous `Hanami.app` (which required the app to be booted first).
+
 ## v2.0.0.alpha4 - 2021-12-07
 ### Added
 - [Luca Guidi] Manage Content Security Policy (CSP) with "zero-defaults" policy. New API to change CSP values and to disable the feature.

data/README.md

@@ -58,7 +58,7 @@ You can give back to Open Source, by supporting Hanami development via a [donati
 
 ### Supporters
 
-  * [Trung Lê](https://github.com/joneslee85)
+  * [Trung Lê](https://github.com/runlevel5)
   * [James Carlson](https://github.com/jxxcarlson)
   * [Creditas](https://www.creditas.com.br/)
 

data/hanami.gemspec

@@ -26,7 +26,7 @@ Gem::Specification.new do |spec| # rubocop:disable Metrics/BlockLength
   spec.add_dependency "dry-core",          "~> 0.4"
   spec.add_dependency "dry-inflector",     "~> 0.2", ">= 0.2.1"
   spec.add_dependency "dry-monitor"
-  spec.add_dependency "dry-system",        "~> 0.19", ">= 0.21.0"
+  spec.add_dependency "dry-system",        "~> 0.22", ">= 0.22.0"
   spec.add_dependency "hanami-cli",        "~> 2.0.alpha"
   spec.add_dependency "hanami-utils",      "~> 2.0.alpha"
   spec.add_dependency "zeitwerk",          "~> 2.4"

data/lib/hanami/application/container/boot/rack_logger.rb

@@ -9,7 +9,7 @@ Hanami.application.register_bootable :rack_logger do |container|
 
     rack_logger = Hanami::Web::RackLogger.new(
       container[:logger],
-      filter_params: Hanami.application.configuration.logger.filter_params
+      filter_params: Hanami.application.configuration.logger.filters
     )
 
     rack_logger.attach container[:rack_monitor]

data/lib/hanami/application/router.rb

@@ -10,8 +10,8 @@ module Hanami
     class Router < ::Hanami::Router
       # @since 2.0.0
       # @api private
-      def initialize(routes:, stack: Routing::Middleware::Stack.new, **kwargs, &blk)
-        @stack = stack
+      def initialize(routes:, middleware_stack: Routing::Middleware::Stack.new, **kwargs, &blk)
+        @middleware_stack = middleware_stack
         instance_eval(&blk)
         super(**kwargs, &routes)
       end
@@ -21,20 +21,20 @@ module Hanami
       def freeze
         return self if frozen?
 
-        remove_instance_variable(:@stack)
+        remove_instance_variable(:@middleware_stack)
         super
       end
 
       # @since 2.0.0
       # @api private
       def use(middleware, *args, &blk)
-        @stack.use(middleware, *args, &blk)
+        @middleware_stack.use(middleware, *args, &blk)
       end
 
       # @since 2.0.0
       # @api private
       def scope(*args, &blk)
-        @stack.with(args.first) do
+        @middleware_stack.with(args.first) do
           super
         end
       end
@@ -50,9 +50,9 @@ module Hanami
       # @since 2.0.0
       # @api private
       def to_rack_app
-        return self if @stack.empty?
+        return self if @middleware_stack.empty?
 
-        @stack.to_rack_app(self)
+        @middleware_stack.to_rack_app(self)
       end
     end
   end

data/lib/hanami/application/routing/router.rb

@@ -0,0 +1,36 @@
+# # frozen_string_literal: true
+
+# require "hanami/application/router"
+
+# Hanami.application.register_bootable :router do
+#   start do
+#     configuration = Hanami.application.configuration
+
+#     routes = begin
+#       require File.join(configuration.root, configuration.router.routes_path)
+#       routes_class = Hanami.application.send(:autodiscover_application_constant, configuration.router.routes_class_name) # WIP private
+#       routes_class.routes
+#     rescue LoadError
+#       proc {}
+#     end
+
+#     resolver = configuration.router.resolver.new(
+#       slices: Hanami.application.slices,
+#       inflector: Hanami.application.inflector # TODO: use container[:inflector]?
+#     )
+
+#     router = Hanami::Application::Router.new(
+#       routes: routes,
+#       resolver: resolver,
+#       **configuration.router.options,
+#     ) do
+#       use Hanami.application[:rack_monitor]
+
+#       Hanami.application.config.for_each_middleware do |m, *args, &block|
+#         use(m, *args, &block)
+#       end
+#     end
+
+#     register :router, router
+#   end
+# end

data/lib/hanami/application.rb

@@ -8,9 +8,6 @@ require "rack"
 require "zeitwerk"
 require_relative "slice"
 require_relative "application/autoloader/inflector_adapter"
-require_relative "application/router"
-require_relative "application/routes"
-require_relative "application/settings"
 
 module Hanami
   # Hanami application class
@@ -24,10 +21,9 @@ module Hanami
         @_mutex.synchronize do
           klass.class_eval do
             @_mutex         = Mutex.new
-            @_configuration = Hanami::Configuration.new(env: Hanami.env)
+            @_configuration = Hanami::Configuration.new(application_name: name, env: Hanami.env)
 
             extend ClassMethods
-            include InstanceMethods
           end
 
           klass.send :prepare_base_load_path
@@ -76,10 +72,31 @@ module Hanami
         self
       end
 
+      def boot(&block)
+        return self if booted?
+
+        init
+
+        container.finalize!(&block)
+
+        slices.values.each(&:boot)
+
+        @booted = true
+        self
+      end
+
+      def shutdown
+        container.shutdown!
+      end
+
       def inited?
         @inited
       end
 
+      def booted?
+        @booted
+      end
+
       def autoloader
         raise "Application not init'ed" unless defined?(@autoloader)
 
@@ -98,6 +115,18 @@ module Hanami
         @deps_module
       end
 
+      def router
+        raise "Application not init'ed" unless inited?
+
+        @_mutex.synchronize do
+          @_router ||= load_router
+        end
+      end
+
+      def rack_app
+        @rack_app ||= router.to_rack_app
+      end
+
       def slices
         @slices ||= {}
       end
@@ -142,38 +171,12 @@ module Hanami
         container.resolve(*args)
       end
 
-      def boot(&block)
-        return self if booted?
-
-        init
-
-        load_router
-
-        container.finalize!(&block)
-
-        slices.values.each(&:boot)
-
-        @booted = true
-        self
-      end
-
-      def booted?
-        @booted
-      end
-
-      def shutdown
-        container.shutdown!
-      end
-
       def settings
         @_settings ||= load_settings
       end
 
-      MODULE_DELIMITER = "::"
-      private_constant :MODULE_DELIMITER
-
       def namespace
-        inflector.constantize(name.split(MODULE_DELIMITER)[0..-2].join(MODULE_DELIMITER))
+        configuration.namespace
       end
 
       def namespace_name
@@ -185,7 +188,7 @@ module Hanami
       end
 
       def application_name
-        inflector.underscore(namespace).to_sym
+        configuration.application_name
       end
 
       def root
@@ -211,41 +214,6 @@ module Hanami
         providers.detect { |provider| component_name.include?(provider.namespace.to_s) }
       end
 
-      def router
-        @_mutex.synchronize do
-          @_router ||= load_router
-        end
-      end
-
-      def load_router
-        Router.new(
-          routes: routes,
-          resolver: resolver,
-          **configuration.router.options,
-        ) do
-          use Hanami.application[:rack_monitor]
-
-          Hanami.application.config.for_each_middleware do |m, *args, &block|
-            use(m, *args, &block)
-          end
-        end
-      end
-
-      def routes
-        require File.join(configuration.root, configuration.router.routes_path)
-        routes_class = autodiscover_application_constant(configuration.router.routes_class_name)
-        routes_class.routes
-      rescue LoadError
-        proc {}
-      end
-
-      def resolver
-        config.router.resolver.new(
-          slices: slices,
-          inflector: inflector
-        )
-      end
-
       private
 
       def prepare_base_load_path
@@ -343,6 +311,8 @@ module Hanami
       # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
       def load_settings
+        require_relative "application/settings"
+
         prepare_base_load_path
         require File.join(configuration.root, configuration.settings_path)
         settings_class = autodiscover_application_constant(configuration.settings_class_name)
@@ -351,27 +321,46 @@ module Hanami
         Settings.new
       end
 
+      MODULE_DELIMITER = "::"
+      private_constant :MODULE_DELIMITER
+
       def autodiscover_application_constant(constants)
         inflector.constantize([namespace_name, *constants].join(MODULE_DELIMITER))
       end
-    end
-    # rubocop:enable Metrics/ModuleLength
 
-    # Application instance interface
-    module InstanceMethods
-      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-      def initialize(application = self.class)
+      def load_router
         require_relative "application/router"
 
-        application.boot
+        Router.new(
+          routes: load_routes,
+          resolver: router_resolver,
+          **configuration.router.options,
+        ) do
+          use Hanami.application[:rack_monitor]
 
-        @app = application.router.to_rack_app
+          Hanami.application.config.for_each_middleware do |m, *args, &block|
+            use(m, *args, &block)
+          end
+        end
+      end
+
+      def load_routes
+        require_relative "application/routes"
+
+        require File.join(configuration.root, configuration.router.routes_path)
+        routes_class = autodiscover_application_constant(configuration.router.routes_class_name)
+        routes_class.routes
+      rescue LoadError
+        proc {}
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
-      def call(env)
-        @app.call(env)
+      def router_resolver
+        config.router.resolver.new(
+          slices: slices,
+          inflector: inflector
+        )
       end
     end
+    # rubocop:enable Metrics/ModuleLength
   end
 end

data/lib/hanami/boot/source_dirs.rb

@@ -0,0 +1,44 @@
+module Hanami
+  module Boot
+    module SourceDirs
+      def self.setup_component_dir!(component_dir, slice, container)
+        # TODO: this `== "lib"` check should be codified into a method somewhere
+        if component_dir.path == "lib"
+          # Expect component files in the root of the lib
+          # component dir to define classes inside the slice's namespace.
+          #
+          # e.g. "lib/foo.rb" should define SliceNamespace::Foo, and will be
+          # registered as "foo"
+          component_dir.namespaces.root(key: nil, const: slice.namespace_path)
+
+          slice.application.autoloader.push_dir(slice.root.join("lib"), namespace: slice.namespace)
+
+          container.config.component_dirs.add(component_dir)
+        else
+          # Expect component files in the root of these component dirs to define
+          # classes inside a namespace matching the dir.
+          #
+          # e.g. "actions/foo.rb" should define SliceNamespace::Actions::Foo, and
+          # will be registered as "actions.foo"
+
+          dir_namespace_path = File.join(slice.namespace_path, component_dir.path)
+
+          autoloader_namespace = begin
+            slice.inflector.constantize(slice.inflector.camelize(dir_namespace_path))
+          rescue NameError
+            slice.namespace.const_set(slice.inflector.camelize(component_dir.path), Module.new)
+          end
+
+          # TODO: do we need to do something special to clear out any previously configured root namespace here?
+          component_dir.namespaces.root(const: dir_namespace_path, key: component_dir.path) # TODO: do we need to swap path delimiters for key delimiters here?
+          container.config.component_dirs.add(component_dir)
+
+          slice.application.autoloader.push_dir(
+            slice.root.join(component_dir.path),
+            namespace: autoloader_namespace
+          )
+        end
+      end
+    end
+  end
+end

data/lib/hanami/configuration/logger.rb

@@ -13,14 +13,58 @@ module Hanami
 
       protected :config
 
+      setting :application_name
+
+      setting :level
+
+      setting :stream
+
+      setting :formatter
+
+      setting :colors
+
+      setting :filters, default: %w[_csrf password password_confirmation].freeze
+
+      setting :options, default: [], constructor: ->(value) { Array(value).flatten }, cloneable: true
+
       setting :logger_class, default: Hanami::Logger
 
-      setting :options, default: {level: :debug}
+      def initialize(env:, application_name:)
+        @env = env
+        @application_name = application_name
+
+        config.level = case env
+                       when :production
+                         :info
+                       else
+                         :debug
+                       end
 
-      # Currently used for logging of Rack requests only.
-      #
-      # TODO: incorporate this into the standard logging some way or another
-      setting :filter_params, default: %w[_csrf password password_confirmation].freeze
+        config.stream = case env
+                        when :test
+                          File.join("log", "#{env}.log")
+                        else
+                          $stdout
+                        end
+
+        config.formatter = case env
+                           when :production
+                             :json
+                           end
+
+        config.colors = case env
+                        when :production, :test
+                          false
+                        end
+      end
+
+      def finalize!
+        config.application_name = @application_name.call
+      end
+
+      def instance
+        logger_class.new(application_name, *options, stream: stream, level: level, formatter: formatter, filter: filters, colorizer: colors)
+      end
 
       private
 

data/lib/hanami/configuration/source_dirs.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "dry/configurable"
+require "dry/system/config/component_dirs"
+
+module Hanami
+  class Configuration
+    # Configuration for slice source dirs
+    #
+    # @since 2.0.0
+    class SourceDirs
+      DEFAULT_COMPONENT_DIR_PATHS = %w[lib actions repositories views].freeze
+      private_constant :DEFAULT_COMPONENT_DIR_PATHS
+
+      include Dry::Configurable
+
+      setting :component_dirs,
+        default: Dry::System::Config::ComponentDirs.new.tap { |dirs|
+          DEFAULT_COMPONENT_DIR_PATHS.each do |path|
+            dirs.add path
+          end
+        },
+        cloneable: true
+
+      setting :autoload_paths, default: %w[entities]
+
+      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/lib/hanami/configuration.rb

@@ -12,6 +12,7 @@ require_relative "configuration/logger"
 require_relative "configuration/middleware"
 require_relative "configuration/router"
 require_relative "configuration/sessions"
+require_relative "configuration/source_dirs"
 
 module Hanami
   # Hanami application configuration
@@ -25,6 +26,9 @@ module Hanami
     DEFAULT_ENVIRONMENTS = Concurrent::Hash.new { |h, k| h[k] = Concurrent::Array.new }
     private_constant :DEFAULT_ENVIRONMENTS
 
+    MODULE_DELIMITER = "::"
+    private_constant :MODULE_DELIMITER
+
     attr_reader :actions
     attr_reader :middleware
     attr_reader :router
@@ -33,7 +37,9 @@ module Hanami
     attr_reader :environments
     private :environments
 
-    def initialize(env:)
+    def initialize(application_name:, env:)
+      @namespace = application_name.split(MODULE_DELIMITER)[0..-2].join(MODULE_DELIMITER)
+
       @environments = DEFAULT_ENVIRONMENTS.clone
       config.env = env
 
@@ -42,6 +48,8 @@ module Hanami
       self.root = Dir.pwd
       self.settings_store = Application::Settings::DotenvStore.new.with_dotenv_loaded
 
+      config.logger = Configuration::Logger.new(env: env, application_name: method(:application_name))
+
       @assets = begin
         require_path = "hanami/assets/application_configuration"
         require require_path
@@ -101,6 +109,14 @@ module Hanami
       super
     end
 
+    def namespace
+      inflector.constantize(@namespace)
+    end
+
+    def application_name
+      inflector.underscore(@namespace).to_sym
+    end
+
     setting :env
 
     def env=(new_env)
@@ -116,14 +132,14 @@ module Hanami
       self.inflector = Dry::Inflector.new(&block)
     end
 
-    setting :logger, default: Configuration::Logger.new, cloneable: true
+    setting :logger, cloneable: true
 
     def logger=(logger_instance)
       @logger_instance = logger_instance
     end
 
     def logger_instance
-      @logger_instance || logger.logger_class.new(**logger.options)
+      @logger_instance || logger.instance
     end
 
     setting :settings_path, default: File.join("config", "settings")
@@ -140,9 +156,7 @@ module Hanami
     # slice, etc.
     setting :slices, default: {}, constructor: :dup.to_proc
 
-    # TODO: turn this into a richer "source dirs" setting that can support enabling
-    # of container component loading as an opt in behvior
-    setting :component_dir_paths, default: %w[actions repositories views]
+    setting :source_dirs, default: Configuration::SourceDirs.new, cloneable: true
 
     def slice(slice_name, &block)
       slices[slice_name] = block

data/lib/hanami/slice.rb

@@ -111,47 +111,69 @@ module Hanami
           config.root = root
           config.bootable_dirs = ["config/boot"]
 
-          # Add the "lib" component dir; all slices will load components from lib
-          if root.join("lib").directory?
-            config.component_dirs.add("lib") do |component_dir|
-              # Expect component files in the root of the lib
-              # component dir to define classes inside the slice's namespace.
-              #
-              # e.g. "lib/foo.rb" should define SliceNamespace::Foo, and will be
-              # registered as "foo"
-              component_dir.namespaces.root(key: nil, const: namespace_path)
+          # Add component dirs for each configured component path
+          application.configuration.source_dirs.component_dirs.each do |component_dir|
+            next unless root.join(component_dir.path).directory?
 
-              application.autoloader.push_dir(root.join("lib"), namespace: namespace)
-            end
-          end
+            component_dir = component_dir.dup
 
-          # Add component dirs for each configured component path
-          application.configuration.component_dir_paths.each do |slice_dir|
-            next unless root.join(slice_dir).directory?
+            # TODO: this `== "lib"` check should be codified into a method somewhere
+            if component_dir.path == "lib"
+              # Expect component files in the root of the lib/ component dir to define
+              # classes inside the slice's namespace.
+              #
+              # e.g. "lib/foo.rb" should define SliceNamespace::Foo, to be registered as
+              # "foo"
+              component_dir.namespaces.delete_root
+              component_dir.namespaces.add_root(key: nil, const: namespace_path)
+
+              config.component_dirs.add(component_dir)
 
-            config.component_dirs.add(slice_dir) do |component_dir|
-              # Expect component files in the root of these component dirs to define
-              # classes inside a namespace matching the dir.
+              application.autoloader.push_dir(root.join("lib"), namespace: namespace)
+            else
+              # Expect component files in the root of non-lib/ component dirs to define
+              # classes inside a namespace matching that dir.
               #
-              # e.g. "actions/foo.rb" should define SliceNamespace::Actions::Foo, and
-              # will be registered as "actions.foo"
+              # e.g. "actions/foo.rb" should define SliceNamespace::Actions::Foo, to be
+              # registered as "actions.foo"
 
-              dir_namespace_path = File.join(namespace_path, slice_dir)
+              dir_namespace_path = File.join(namespace_path, component_dir.path)
 
               autoloader_namespace = begin
                 inflector.constantize(inflector.camelize(dir_namespace_path))
               rescue NameError
-                namespace.const_set(inflector.camelize(slice_dir), Module.new)
+                namespace.const_set(inflector.camelize(component_dir.path), Module.new)
               end
 
-              component_dir.namespaces.root(const: dir_namespace_path, key: slice_dir)
+              component_dir.namespaces.delete_root
+              component_dir.namespaces.add_root(const: dir_namespace_path, key: component_dir.path) # TODO: do we need to swap path delimiters for key delimiters here?
+
+              config.component_dirs.add(component_dir)
 
               application.autoloader.push_dir(
-                container.root.join(slice_dir),
+                container.root.join(component_dir.path),
                 namespace: autoloader_namespace
               )
             end
           end
+
+          # Pass configured autoload dirs to the autoloader
+          application.configuration.source_dirs.autoload_paths.each do |autoload_path|
+            next unless root.join(autoload_path).directory?
+
+            dir_namespace_path = File.join(namespace_path, autoload_path)
+
+            autoloader_namespace = begin
+              inflector.constantize(inflector.camelize(dir_namespace_path))
+            rescue NameError
+              namespace.const_set(inflector.camelize(autoload_path), Module.new)
+            end
+
+            application.autoloader.push_dir(
+              container.root.join(autoload_path),
+              namespace: autoloader_namespace
+            )
+          end
         end
       end
 

data/lib/hanami/version.rb

@@ -8,7 +8,7 @@ module Hanami
   module Version
     # @since 0.9.0
     # @api private
-    VERSION = "2.0.0.alpha4"
+    VERSION = "2.0.0.alpha5"
 
     # @since 0.9.0
     # @api private

data/lib/hanami.rb

@@ -31,20 +31,8 @@ module Hanami
     end
   end
 
-  def self.app
-    @_mutex.synchronize do
-      raise "Hanami.app not configured" unless defined?(@_app)
-
-      @_app
-    end
-  end
-
-  def self.app=(app)
-    @_mutex.synchronize do
-      raise "Hanami.app already configured" if defined?(@_app)
-
-      @_app = app
-    end
+  def self.rack_app
+    application.rack_app
   end
 
   def self.env
@@ -63,14 +51,8 @@ module Hanami
     application.init
   end
 
-  def self.boot(web: true)
-    if defined?(@_app)
-      @_app
-    else
-      application.boot
-
-      @_app = application.new if web
-    end
+  def self.boot
+    application.boot
   end
 
   def self.shutdown

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hanami
 version: !ruby/object:Gem::Version
-  version: 2.0.0.alpha4
+  version: 2.0.0.alpha5
 platform: ruby
 authors:
 - Luca Guidi
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-12-07 00:00:00.000000000 Z
+date: 2022-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -104,20 +104,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.19'
+        version: '0.22'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.21.0
+        version: 0.22.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.19'
+        version: '0.22'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.21.0
+        version: 0.22.0
 - !ruby/object:Gem::Dependency
   name: hanami-cli
   requirement: !ruby/object:Gem::Requirement
@@ -231,11 +231,13 @@ files:
 - lib/hanami/application/routing/resolver.rb
 - lib/hanami/application/routing/resolver/node.rb
 - lib/hanami/application/routing/resolver/trie.rb
+- lib/hanami/application/routing/router.rb
 - lib/hanami/application/settings.rb
 - lib/hanami/application/settings/dotenv_store.rb
 - lib/hanami/assets/application_configuration.rb
 - lib/hanami/assets/configuration.rb
 - lib/hanami/boot.rb
+- lib/hanami/boot/source_dirs.rb
 - lib/hanami/cli/application/cli.rb
 - lib/hanami/cli/application/command.rb
 - lib/hanami/cli/application/commands.rb
@@ -250,6 +252,7 @@ files:
 - lib/hanami/configuration/null_configuration.rb
 - lib/hanami/configuration/router.rb
 - lib/hanami/configuration/sessions.rb
+- lib/hanami/configuration/source_dirs.rb
 - lib/hanami/init.rb
 - lib/hanami/server.rb
 - lib/hanami/setup.rb
@@ -276,7 +279,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubygems_version: 3.2.29
+rubygems_version: 3.2.3
 signing_key:
 specification_version: 4
 summary: The web, with simplicity