hanami 2.0.0.alpha8 → 2.0.0.beta1

data/lib/hanami/{application → slice}/view_name_inferrer.rb

@@ -3,7 +3,7 @@
 require_relative "../constants"
 
 module Hanami
-  class Application
+  class Slice
     # Infers a view name for automatically rendering within actions.
     #
     # @api private
@@ -28,8 +28,8 @@ module Hanami
         #
         # @return [Array<string>] array of paired view container keys
         def call(action_class_name:, slice:)
-          action_key_base = slice.application.config.actions.name_inference_base
-          view_key_base = slice.application.config.actions.view_name_inference_base
+          action_key_base = slice.config.actions.name_inference_base
+          view_key_base = slice.config.actions.view_name_inference_base
 
           action_name_key = action_name_key(action_class_name, slice, action_key_base)
 

data/lib/hanami/slice.rb

@@ -1,29 +1,68 @@
 # frozen_string_literal: true
 
 require "dry/system/container"
-require "hanami/errors"
-require "pathname"
 require_relative "constants"
+require_relative "errors"
 require_relative "slice_name"
+require_relative "slice_registrar"
 
 module Hanami
-  # Distinct area of concern within an Hanami application
+  # A slice represents any distinct area of concern within an Hanami app.
+  #
+  # For smaller apps, a slice may encompass the whole app itself (see
+  # {Hanami::App}), whereas larger apps may consist of many slices.
+  #
+  # Each slice corresponds a single module namespace and a single root directory of source
+  # files for loading as components into its container.
+  #
+  # Each slice has its own configuration, and may optionally have its own settings,
+  # routes, as well as other nested slices.
+  #
+  # Slices expect an Hanami app to be defined (which itself is a slice). They will
+  # initialize their configuration as a copy of the app's, and will also configure
+  # certain components
+  #
+  # Slices must be _prepared_ and optionally _booted_ before they can be used (see
+  # {ClassMethods.prepare} and {ClassMethods.boot}). A prepared slice will lazily load its
+  # components and nested slices (useful for minimising initial load time), whereas a
+  # booted slice will eagerly load all its components and nested slices, then freeze its
+  # container.
   #
   # @since 2.0.0
   class Slice
+    @_mutex = Mutex.new
+
     def self.inherited(subclass)
       super
 
       subclass.extend(ClassMethods)
 
-      # Eagerly initialize any variables that may be accessed inside the subclass body
-      subclass.instance_variable_set(:@application, Hanami.application)
-      subclass.instance_variable_set(:@container, Class.new(Dry::System::Container))
+      @_mutex.synchronize do
+        subclass.class_eval do
+          @_mutex = Mutex.new
+          @container = Class.new(Dry::System::Container)
+        end
+      end
     end
 
     # rubocop:disable Metrics/ModuleLength
     module ClassMethods
-      attr_reader :application, :container
+      attr_reader :parent, :container
+
+      def app
+        Hanami.app
+      end
+
+      # A slice's configuration is copied from the app configuration at time of
+      # first access. The app should have its configuration completed before
+      # slices are loaded.
+      def configuration
+        @configuration ||= app.configuration.dup.tap do |config|
+          # Remove specific values from app that will not apply to this slice
+          config.root = nil
+        end
+      end
+      alias_method :config, :configuration
 
       def slice_name
         @slice_name ||= SliceName.new(self, inflector: method(:inflector))
@@ -34,25 +73,20 @@ module Hanami
       end
 
       def root
-        application.root.join(SLICES_DIR, slice_name.to_s)
+        configuration.root
       end
 
       def inflector
-        application.inflector
+        configuration.inflector
       end
 
       def prepare(provider_name = nil)
-        container.prepare(provider_name) and return self if provider_name
-
-        return self if prepared?
-
-        ensure_slice_name
-        ensure_slice_consts
-
-        prepare_all
-
-        @prepared = true
-        self
+        if provider_name
+          container.prepare(provider_name)
+          self
+        else
+          prepare_slice
+        end
       end
 
       def prepare_container(&block)
@@ -62,7 +96,10 @@ module Hanami
       def boot
         return self if booted?
 
+        prepare
+
         container.finalize!
+        slices.each(&:boot)
 
         @booted = true
 
@@ -70,6 +107,7 @@ module Hanami
       end
 
       def shutdown
+        slices.each(&:shutdown)
         container.shutdown!
         self
       end
@@ -82,6 +120,14 @@ module Hanami
         !!@booted
       end
 
+      def slices
+        @slices ||= SliceRegistrar.new(self)
+      end
+
+      def register_slice(...)
+        slices.register(...)
+      end
+
       def register(...)
         container.register(...)
       end
@@ -118,12 +164,12 @@ module Hanami
         # TODO: This should be handled via dry-system (see dry-rb/dry-system#228)
         raise "Cannot import after booting" if booted?
 
-        application = self.application
+        slice = self
 
         container.after(:configure) do
           if from.is_a?(Symbol) || from.is_a?(String)
             slice_name = from
-            from = application.slices[from.to_sym].container
+            from = slice.parent.slices[from.to_sym].container
           end
 
           as = kwargs[:as] || slice_name
@@ -132,8 +178,55 @@ module Hanami
         end
       end
 
+      def settings
+        @settings ||= load_settings
+      end
+
+      def routes
+        @routes ||= load_routes
+      end
+
+      def router(inspector: nil)
+        raise SliceLoadError, "#{self} must be prepared before loading the router" unless prepared?
+
+        @_mutex.synchronize do
+          @_router ||= load_router(inspector: inspector)
+        end
+      end
+
+      def rack_app
+        return unless router
+
+        @rack_app ||= router.to_rack_app
+      end
+
+      def call(...)
+        rack_app.call(...)
+      end
+
       private
 
+      # rubocop:disable Metrics/AbcSize
+
+      def prepare_slice
+        return self if prepared?
+
+        configuration.finalize!
+
+        ensure_slice_name
+        ensure_slice_consts
+        ensure_root
+
+        prepare_all
+
+        instance_exec(container, &@prepare_container_block) if @prepare_container_block
+        container.configured!
+
+        @prepared = true
+
+        self
+      end
+
       def ensure_slice_name
         unless name
           raise SliceLoadError, "Slice must have a class name before it can be prepared"
@@ -149,15 +242,25 @@ module Hanami
         end
       end
 
+      def ensure_root
+        unless configuration.root
+          raise SliceLoadError, "Slice must have a `config.root` before it can be prepared"
+        end
+      end
+
       def prepare_all
+        # Load settings first, to fail early in case of missing/unexpected values
+        settings
+
+        prepare_container_consts
         prepare_container_plugins
         prepare_container_base_config
         prepare_container_component_dirs
-        prepare_autoloader
         prepare_container_imports
-        prepare_container_consts
-        instance_exec(container, &@prepare_container_block) if @prepare_container_block
-        container.configured!
+        prepare_container_providers
+        prepare_autoloader
+
+        prepare_slices
       end
 
       def prepare_container_plugins
@@ -165,7 +268,7 @@ module Hanami
 
         container.use(
           :zeitwerk,
-          loader: application.autoloader,
+          loader: app.autoloader,
           run_setup: false,
           eager_load: false
         )
@@ -176,74 +279,144 @@ module Hanami
         container.config.root = root
         container.config.provider_dirs = [File.join("config", "providers")]
 
-        container.config.env = application.configuration.env
-        container.config.inflector = application.configuration.inflector
+        container.config.env = configuration.env
+        container.config.inflector = configuration.inflector
       end
 
-      def prepare_container_component_dirs # rubocop:disable Metrics/AbcSize
-        return unless root&.directory?
+      def prepare_container_component_dirs
+        return unless root.directory?
 
-        # 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?
+        # Component files in both the root and `lib/` define classes in the slice's
+        # namespace
 
-          component_dir = component_dir.dup
+        if root.join(LIB_DIR)&.directory?
+          container.config.component_dirs.add(LIB_DIR) do |dir|
+            dir.namespaces.add_root(key: nil, const: slice_name.name)
+          end
+        end
 
-          if component_dir.path == LIB_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, to be registered as
-            # "foo"
-            component_dir.namespaces.delete_root
-            component_dir.namespaces.add_root(key: nil, const: slice_name.name)
-          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, to be
-            # registered as "actions.foo"
+        # When auto-registering components in the root, ignore files in `config/` (this is
+        # for framework config only), `lib/` (these will be auto-registered as above), as
+        # well as the configured no_auto_register_paths
+        no_auto_register_paths = ([LIB_DIR, CONFIG_DIR] + configuration.no_auto_register_paths)
+          .map { |path|
+            path.end_with?(File::SEPARATOR) ? path : "#{path}#{File::SEPARATOR}"
+          }
+
+        # TODO: Change `""` (signifying the root) once dry-rb/dry-system#238 is resolved
+        container.config.component_dirs.add("") do |dir|
+          dir.namespaces.add_root(key: nil, const: slice_name.name)
+          dir.auto_register = -> component {
+            relative_path = component.file_path.relative_path_from(root).to_s
+            !relative_path.start_with?(*no_auto_register_paths)
+
+          }
+        end
+      end
 
-            dir_namespace_path = File.join(slice_name.name, component_dir.path)
+      def prepare_container_imports
+        import(
+          keys: config.slices.shared_component_keys,
+          from: app.container,
+          as: nil
+        )
+      end
 
-            component_dir.namespaces.delete_root
-            component_dir.namespaces.add_root(const: dir_namespace_path, key: component_dir.path)
-          end
+      def prepare_container_providers
+        # Check here for the `routes` definition only, not `router` itself, because the
+        # `router` requires the slice to be prepared before it can be loaded, and at this
+        # point we're still in the process of preparing.
+        if routes
+          require_relative "providers/routes"
+          register_provider(:routes, source: Hanami::Providers::Routes.for_slice(self))
+        end
 
-          container.config.component_dirs.add(component_dir)
+        if settings
+          require_relative "providers/settings"
+          register_provider(:settings, source: Hanami::Providers::Settings.for_slice(self))
         end
       end
 
-      def prepare_autoloader # rubocop:disable Metrics/AbcSize
-        return unless root&.directory?
+      def prepare_autoloader
+        # Everything in the slice directory can be autoloaded _except_ `config/`, which is
+        # where we keep files loaded specially by the framework as part of slice setup.
+        if root.join(CONFIG_DIR)&.directory?
+          container.config.autoloader.ignore(root.join(CONFIG_DIR))
+        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?
+      def prepare_container_consts
+        namespace.const_set :Container, container
+        namespace.const_set :Deps, container.injector
+      end
 
-          dir_namespace_path = File.join(slice_name.name, autoload_path)
+      def prepare_slices
+        slices.load_slices.each(&:prepare)
+        slices.freeze
+      end
+
+      def load_settings
+        if root.directory?
+          settings_require_path = File.join(root, SETTINGS_PATH)
 
-          autoloader_namespace = begin
-            inflector.constantize(inflector.camelize(dir_namespace_path))
-          rescue NameError
-            namespace.const_set(inflector.camelize(autoload_path), Module.new)
+          begin
+            require_relative "./settings"
+            require settings_require_path
+          rescue LoadError => e
+            raise e unless e.path == settings_require_path
           end
+        end
 
-          container.config.autoloader.push_dir(
-            container.root.join(autoload_path),
-            namespace: autoloader_namespace
-          )
+        begin
+          settings_class = namespace.const_get(SETTINGS_CLASS_NAME)
+          settings_class.new(configuration.settings_store)
+        rescue NameError => e
+          raise e unless e.name == SETTINGS_CLASS_NAME.to_sym
         end
       end
 
-      def prepare_container_imports
-        container.import from: application.container, as: :application
+      def load_routes
+        if root.directory?
+          routes_require_path = File.join(root, ROUTES_PATH)
+
+          begin
+            require_relative "./routes"
+            require routes_require_path
+          rescue LoadError => e
+            raise e unless e.path == routes_require_path
+          end
+        end
+
+        begin
+          routes_class = namespace.const_get(ROUTES_CLASS_NAME)
+          routes_class.routes
+        rescue NameError => e
+          raise e unless e.name == ROUTES_CLASS_NAME.to_sym
+        end
       end
 
-      def prepare_container_consts
-        namespace.const_set :Container, container
-        namespace.const_set :Deps, container.injector
+      def load_router(inspector:)
+        return unless routes
+
+        require_relative "slice/router"
+
+        config = configuration
+        rack_monitor = self["rack.monitor"]
+
+        Slice::Router.new(
+          inspector: inspector,
+          routes: routes,
+          resolver: configuration.router.resolver.new(slice: self),
+          **configuration.router.options
+        ) do
+          use(rack_monitor)
+          use(*config.sessions.middleware) if config.sessions.enabled?
+
+          middleware_stack.update(config.middleware_stack)
+        end
       end
+
+      # rubocop:enable Metrics/AbcSize
     end
     # rubocop:enable Metrics/ModuleLength
   end

data/lib/hanami/slice_configurable.rb

@@ -30,21 +30,16 @@ module Hanami
 
         inherited_mod = Module.new do
           define_method(:inherited) do |subclass|
-            unless Hanami.application?
-              raise ComponentLoadError, "Class #{klass} must be defined within an Hanami application"
+            unless Hanami.app?
+              raise ComponentLoadError, "Class #{klass} must be defined within an Hanami app"
             end
 
             super(subclass)
 
-            subclass.instance_variable_set(:@configured_for_slices, configured_for_slices.dup)
-
             slice = slice_for.(subclass)
             return unless slice
 
-            unless subclass.configured_for_slice?(slice)
-              subclass.configure_for_slice(slice)
-              subclass.configured_for_slices << slice
-            end
+            subclass.configure_for_slice(slice)
           end
         end
 
@@ -56,20 +51,12 @@ module Hanami
       def slice_for(klass)
         return unless klass.name
 
-        slices = Hanami.application.slices.to_a + [Hanami.application]
+        slices = Hanami.app.slices.to_a + [Hanami.app]
 
         slices.detect { |slice| klass.name.include?(slice.namespace.to_s) }
       end
     end
 
     def configure_for_slice(slice); end
-
-    def configured_for_slice?(slice)
-      configured_for_slices.include?(slice)
-    end
-
-    def configured_for_slices
-      @configured_for_slices ||= []
-    end
   end
 end

data/lib/hanami/slice_name.rb

@@ -3,24 +3,24 @@
 require_relative "constants"
 
 module Hanami
-  # Represents the name of an {Application} or {Slice}.
+  # Represents the name of an {App} or {Slice}.
   #
-  # @see Application::ClassMethods#application_name
   # @see Slice::ClassMethods#slice_name
+  # @see App::ClassMethods#app_name
   #
   # @api public
   # @since 2.0.0
   class SliceName
-    # Returns a new SliceName for the slice or application.
+    # Returns a new SliceName for the slice or app.
     #
     # You must provide an inflector for the manipulation of the name into various formats.
     # This should be given in the form of a Proc that returns the inflector when called.
     # The reason for this is that the inflector may be replaced by the user during the
-    # application configuration phase, so the proc should ensure that the current instance
+    # app configuration phase, so the proc should ensure that the current instance
     # of the inflector is returned whenever needed.
     #
-    # @param slice [#name] the slice or application object
-    # @param inflector [Proc] Proc returning the application's inflector when called
+    # @param slice [#name] the slice or app object
+    # @param inflector [Proc] Proc returning the app's inflector when called
     #
     # @api private
     def initialize(slice, inflector:)

data/lib/hanami/slice_registrar.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require_relative "constants"
+require_relative "slice"
+
+module Hanami
+  # @api private
+  class SliceRegistrar
+    attr_reader :parent, :slices
+    private :parent, :slices
+
+    def initialize(parent)
+      @parent = parent
+      @slices = {}
+    end
+
+    def register(name, slice_class = nil, &block)
+      if slices.key?(name.to_sym)
+        raise SliceLoadError, "Slice '#{name}' is already registered"
+      end
+
+      # TODO: raise error unless name meets format (i.e. single level depth only)
+
+      slice = slice_class || build_slice(name, &block)
+
+      configure_slice(name, slice)
+
+      slices[name.to_sym] = slice
+    end
+
+    def [](name)
+      slices.fetch(name) do
+        raise SliceLoadError, "Slice '#{name}' not found"
+      end
+    end
+
+    def freeze
+      slices.freeze
+      super
+    end
+
+    def load_slices
+      return self unless root
+
+      slice_configs = Dir[root.join(CONFIG_DIR, SLICES_DIR, "*#{RB_EXT}")]
+        .map { |file| File.basename(file, RB_EXT) }
+
+      slice_dirs = Dir[File.join(root, SLICES_DIR, "*")]
+        .select { |path| File.directory?(path) }
+        .map { |path| File.basename(path) }
+
+      (slice_dirs + slice_configs).uniq.sort.each do |slice_name|
+        load_slice(slice_name)
+      end
+
+      self
+    end
+
+    def each(&block)
+      slices.each_value(&block)
+    end
+
+    def to_a
+      slices.values
+    end
+
+    private
+
+    # Runs when a slice file has been found at `config/slices/[slice_name].rb`, or a slice
+    # directory at `slices/[slice_name]`. Attempts to require the slice class, if defined,
+    # or generates a new slice class for the given slice name.
+    def load_slice(slice_name)
+      slice_const_name = inflector.camelize(slice_name)
+      slice_require_path = root.join(CONFIG_DIR, SLICES_DIR, slice_name).to_s
+
+      begin
+        require(slice_require_path)
+      rescue LoadError => e
+        raise e unless e.path == slice_require_path
+      end
+
+      slice_class =
+        begin
+          inflector.constantize("#{slice_const_name}::Slice")
+        rescue NameError => e
+          raise e unless e.name.to_s == slice_const_name || e.name.to_s == :Slice
+        end
+
+      register(slice_name, slice_class)
+    end
+
+    def build_slice(slice_name, &block)
+      slice_module =
+        begin
+          slice_module_name = inflector.camelize(slice_name.to_s)
+          inflector.constantize(slice_module_name)
+        rescue NameError
+          Object.const_set(inflector.camelize(slice_module_name), Module.new)
+        end
+
+      slice_module.const_set(:Slice, Class.new(Hanami::Slice, &block))
+    end
+
+    def configure_slice(slice_name, slice)
+      slice.instance_variable_set(:@parent, parent)
+
+      # Slices require a root, so provide a sensible default based on the slice's parent
+      slice.config.root ||= root.join(SLICES_DIR, slice_name.to_s)
+    end
+
+    def root
+      parent.root
+    end
+
+    def inflector
+      parent.inflector
+    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.alpha8"
+    VERSION = "2.0.0.beta1"
 
     # @since 0.9.0
     # @api private

data/lib/hanami/web/rack_logger.rb

@@ -2,7 +2,7 @@
 
 module Hanami
   module Web
-    # Rack logger for Hanami applications
+    # Rack logger for Hanami apps
     class RackLogger
       REQUEST_METHOD = "REQUEST_METHOD"
       private_constant :REQUEST_METHOD