hanami 2.0.0.alpha7.1 → 2.0.0.beta1.1

data/lib/hanami/slice.rb

@@ -1,61 +1,92 @@
 # 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
-    def self.inherited(klass)
+    @_mutex = Mutex.new
+
+    def self.inherited(subclass)
       super
 
-      klass.extend(ClassMethods)
+      subclass.extend(ClassMethods)
 
-      # Eagerly initialize any variables that may be accessed inside the subclass body
-      klass.instance_variable_set(:@application, Hanami.application)
-      klass.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 slice_name
-        inflector.underscore(name.split(MODULE_DELIMITER)[-2]).to_sym
+      def app
+        Hanami.app
       end
 
-      def namespace
-        inflector.constantize(name.split(MODULE_DELIMITER)[0..-2].join(MODULE_DELIMITER))
+      # 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 namespace_path
-        inflector.underscore(namespace)
+      def slice_name
+        @slice_name ||= SliceName.new(self, inflector: method(:inflector))
+      end
+
+      def namespace
+        slice_name.namespace
       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)
@@ -65,7 +96,10 @@ module Hanami
       def boot
         return self if booted?
 
+        prepare
+
         container.finalize!
+        slices.each(&:boot)
 
         @booted = true
 
@@ -73,6 +107,7 @@ module Hanami
       end
 
       def shutdown
+        slices.each(&:shutdown)
         container.shutdown!
         self
       end
@@ -85,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
@@ -121,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
@@ -135,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"
@@ -152,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
@@ -168,85 +268,155 @@ module Hanami
 
         container.use(
           :zeitwerk,
-          loader: application.autoloader,
+          loader: app.autoloader,
           run_setup: false,
           eager_load: false
         )
       end
 
       def prepare_container_base_config
-        container.config.name = slice_name
+        container.config.name = slice_name.to_sym
         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: namespace_path)
-          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(namespace_path, 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(namespace_path, 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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative "errors"
+
+module Hanami
+  # Calls `configure_for_slice(slice)` on the extended class whenever it is first
+  # subclassed within a module namespace corresponding to a slice.
+  #
+  # @example
+  #   class BaseClass
+  #     extend Hanami::SliceConfigurable
+  #   end
+  #
+  #   # slices/main/lib/my_class.rb
+  #   module Main
+  #     class MyClass < BaseClass
+  #       # Will be called with `Main::Slice`
+  #       def self.configure_for_slice(slice)
+  #         # ...
+  #       end
+  #     end
+  #   end
+  #
+  # @api private
+  # @since 2.0.0
+  module SliceConfigurable
+    class << self
+      def extended(klass)
+        slice_for = method(:slice_for)
+
+        inherited_mod = Module.new do
+          define_method(:inherited) do |subclass|
+            unless Hanami.app?
+              raise ComponentLoadError, "Class #{klass} must be defined within an Hanami app"
+            end
+
+            super(subclass)
+
+            slice = slice_for.(subclass)
+            return unless slice
+
+            subclass.configure_for_slice(slice)
+          end
+        end
+
+        klass.singleton_class.prepend(inherited_mod)
+      end
+
+      private
+
+      def slice_for(klass)
+        return unless klass.name
+
+        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
+  end
+end

data/lib/hanami/slice_name.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require_relative "constants"
+
+module Hanami
+  # Represents the name of an {App} or {Slice}.
+  #
+  # @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 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
+    # 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 app object
+    # @param inflector [Proc] Proc returning the app's inflector when called
+    #
+    # @api private
+    def initialize(slice, inflector:)
+      @slice = slice
+      @inflector = inflector
+    end
+
+    # Returns the name of the slice as a downcased, underscored string.
+    #
+    # This is considered the canonical name of the slice.
+    #
+    # @example
+    #   slice_name.name # => "main"
+    #
+    # @return [String] the slice name
+    #
+    # @api public
+    # @since 2.0.0
+    def name
+      inflector.underscore(namespace_name)
+    end
+
+    # @api public
+    # @since 2.0.0
+    alias_method :path, :name
+
+    # Returns the name of the slice's module namespace.
+    #
+    # @example
+    #   slice_name.namespace_name # => "Main"
+    #
+    # @return [String] the namespace name
+    #
+    # @api public
+    # @since 2.0.0
+    def namespace_name
+      slice_name.split(MODULE_DELIMITER)[0..-2].join(MODULE_DELIMITER)
+    end
+
+    # Returns the constant for the slice's module namespace.
+    #
+    # @example
+    #   slice_name.namespace_const # => Main
+    #
+    # @return [Module] the namespace module constant
+    #
+    # @api public
+    # @since 2.0.0
+    def namespace_const
+      inflector.constantize(namespace_name)
+    end
+
+    # @api public
+    # @since 2.0.0
+    alias_method :namespace, :namespace_const
+
+    # @api public
+    # @since 2.0.0
+    alias_method :to_s, :name
+
+    # Returns the name of a slice as a downcased, underscored symbol.
+    #
+    # @example
+    #   slice_name.name # => :main
+    #
+    # @return [Symbol] the slice name
+    #
+    # @see name, to_s
+    #
+    # @api public
+    # @since 2.0.0
+    def to_sym
+      name.to_sym
+    end
+
+    private
+
+    def slice_name
+      @slice.name
+    end
+
+    # The inflector is callable to allow for it to be configured/replaced after this
+    # object has been initialized
+    def inflector
+      @inflector.()
+    end
+  end
+end