hanami 2.0.0.beta1.1 → 2.0.0.beta2

data/lib/hanami/slice/routing/middleware/stack.rb

@@ -1,20 +1,35 @@
 # frozen_string_literal: true
 
-require "rack/builder"
-
 module Hanami
   class Slice
     module Routing
-      # Hanami::Applicatione::Router middleware stack
-      #
       # @since 2.0.0
       # @api private
       module Middleware
-        # Middleware stack
+        # Wraps a rack app with a middleware stack
+        #
+        # We use this class to add middlewares to the rack application generated
+        # from {Hanami::Slice::Router}.
+        #
+        # ```
+        # stack = Hanami::Slice::Routing::Middleware::Stack.new
+        # stack.use(Rack::ContentType, "text/html")
+        # stack.to_rack_app(a_rack_app)
+        # ```
+        #
+        # Middlewares can be mounted on specific paths:
+        #
+        # ```
+        # stack.with("/api") do
+        #   stack.use(Rack::ContentType, "application/json")
+        # end
+        # ```
         #
         # @since 2.0.0
         # @api private
         class Stack
+          include Enumerable
+
           # @since 2.0.0
           # @api private
           ROOT_PREFIX = "/"
@@ -77,6 +92,12 @@ module Hanami
           # @since 2.0.0
           # @api private
           def to_rack_app(app)
+            unless Hanami.bundled?("rack")
+              raise "Add \"rack\" to your `Gemfile` to run Hanami as a rack app"
+            end
+
+            require "rack/builder"
+
             s = self
 
             Rack::Builder.new do

data/lib/hanami/slice.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
 require "dry/system/container"
+require "zeitwerk"
 require_relative "constants"
 require_relative "errors"
 require_relative "slice_name"
 require_relative "slice_registrar"
+require_relative "providers/settings"
 
 module Hanami
   # A slice represents any distinct area of concern within an Hanami app.
@@ -40,6 +42,7 @@ module Hanami
       @_mutex.synchronize do
         subclass.class_eval do
           @_mutex = Mutex.new
+          @autoloader = Zeitwerk::Loader.new
           @container = Class.new(Dry::System::Container)
         end
       end
@@ -47,15 +50,14 @@ module Hanami
 
     # rubocop:disable Metrics/ModuleLength
     module ClassMethods
-      attr_reader :parent, :container
+      attr_reader :parent, :autoloader, :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.
+      # 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
@@ -178,10 +180,6 @@ module Hanami
         end
       end
 
-      def settings
-        @settings ||= load_settings
-      end
-
       def routes
         @routes ||= load_routes
       end
@@ -222,6 +220,15 @@ module Hanami
         instance_exec(container, &@prepare_container_block) if @prepare_container_block
         container.configured!
 
+        prepare_autoloader
+
+        ensure_prepared
+
+        # Load child slices last, ensuring their parent is fully prepared beforehand
+        # (useful e.g. for slices that may wish to access constants defined in the
+        # parent's autoloaded directories)
+        prepare_slices
+
         @prepared = true
 
         self
@@ -248,19 +255,18 @@ module Hanami
         end
       end
 
-      def prepare_all
-        # Load settings first, to fail early in case of missing/unexpected values
-        settings
+      def ensure_prepared
+        # Load settings so we can fail early in case of non-conformant values
+        self[:settings] if key?(:settings)
+      end
 
+      def prepare_all
         prepare_container_consts
         prepare_container_plugins
         prepare_container_base_config
         prepare_container_component_dirs
         prepare_container_imports
         prepare_container_providers
-        prepare_autoloader
-
-        prepare_slices
       end
 
       def prepare_container_plugins
@@ -268,7 +274,7 @@ module Hanami
 
         container.use(
           :zeitwerk,
-          loader: app.autoloader,
+          loader: autoloader,
           run_setup: false,
           eager_load: false
         )
@@ -309,14 +315,13 @@ module Hanami
           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
 
       def prepare_container_imports
         import(
-          keys: config.slices.shared_component_keys,
+          keys: config.shared_app_component_keys,
           from: app.container,
           as: nil
         )
@@ -328,21 +333,29 @@ module Hanami
         # 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))
+          register_provider(:routes, source: Providers::Routes.for_slice(self))
         end
 
-        if settings
-          require_relative "providers/settings"
-          register_provider(:settings, source: Hanami::Providers::Settings.for_slice(self))
-        end
+        Providers::Settings.register_with_slice(self)
       end
 
       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.
+        # Component dirs are automatically pushed to the autoloader by dry-system's
+        # zeitwerk plugin. This method adds other dirs that are not otherwise configured
+        # as component dirs.
+
+        # Everything in the slice root can be autoloaded except `config/` and `slices/`,
+        # which are framework-managed directories
+
         if root.join(CONFIG_DIR)&.directory?
-          container.config.autoloader.ignore(root.join(CONFIG_DIR))
+          autoloader.ignore(root.join(CONFIG_DIR))
+        end
+
+        if root.join(SLICES_DIR)&.directory?
+          autoloader.ignore(root.join(SLICES_DIR))
         end
+
+        autoloader.setup
       end
 
       def prepare_container_consts
@@ -355,26 +368,6 @@ module Hanami
         slices.freeze
       end
 
-      def load_settings
-        if root.directory?
-          settings_require_path = File.join(root, SETTINGS_PATH)
-
-          begin
-            require_relative "./settings"
-            require settings_require_path
-          rescue LoadError => e
-            raise e unless e.path == settings_require_path
-          end
-        end
-
-        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 load_routes
         if root.directory?
           routes_require_path = File.join(root, ROUTES_PATH)

data/lib/hanami/slice_configurable.rb

@@ -36,10 +36,15 @@ module Hanami
 
             super(subclass)
 
+            subclass.instance_variable_set(:@configured_for_slices, configured_for_slices.dup)
+
             slice = slice_for.(subclass)
             return unless slice
 
-            subclass.configure_for_slice(slice)
+            unless subclass.configured_for_slice?(slice)
+              subclass.configure_for_slice(slice)
+              subclass.configured_for_slices << slice # WIP
+            end
           end
         end
 
@@ -58,5 +63,13 @@ module Hanami
     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_registrar.rb

@@ -6,6 +6,8 @@ require_relative "slice"
 module Hanami
   # @api private
   class SliceRegistrar
+    SLICE_DELIMITER = CONTAINER_KEY_DELIMITER
+
     attr_reader :parent, :slices
     private :parent, :slices
 
@@ -15,6 +17,8 @@ module Hanami
     end
 
     def register(name, slice_class = nil, &block)
+      return unless filter_slice_names([name]).any?
+
       if slices.key?(name.to_sym)
         raise SliceLoadError, "Slice '#{name}' is already registered"
       end
@@ -49,7 +53,10 @@ module Hanami
         .select { |path| File.directory?(path) }
         .map { |path| File.basename(path) }
 
-      (slice_dirs + slice_configs).uniq.sort.each do |slice_name|
+      slice_names = (slice_dirs + slice_configs).uniq.sort
+        .then { filter_slice_names(_1) }
+
+      slice_names.each do |slice_name|
         load_slice(slice_name)
       end
 
@@ -60,12 +67,24 @@ module Hanami
       slices.each_value(&block)
     end
 
+    def keys
+      slices.keys
+    end
+
     def to_a
       slices.values
     end
 
     private
 
+    def root
+      parent.root
+    end
+
+    def inflector
+      parent.inflector
+    end
+
     # 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.
@@ -106,14 +125,55 @@ module Hanami
 
       # 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)
+
+      slice.config.slices = child_slice_names(slice_name, parent.config.slices)
     end
 
-    def root
-      parent.root
+    # Returns a filtered array of slice names based on the parent's `config.slices`
+    #
+    # This works with both singular slice names (e.g. `"admin"`) as well as dot-delimited nested
+    # slice names (e.g. `"admin.shop"`).
+    #
+    # It will consider only the base names of the slices (since in this case, a parent slice must be
+    # loaded in order for its children to be loaded).
+    #
+    # @example
+    #   parent.config.slices # => ["admin.shop"]
+    #   filter_slice_names(["admin", "main"]) # => ["admin"]
+    #
+    #   parent.config.slices # => ["admin"]
+    #   filter_slice_names(["admin", "main"]) # => ["admin"]
+    def filter_slice_names(slice_names)
+      slice_names = slice_names.map(&:to_s)
+
+      if parent.config.slices
+        slice_names & parent.config.slices.map { base_slice_name(_1) }
+      else
+        slice_names
+      end
     end
 
-    def inflector
-      parent.inflector
+    # Returns the base slice name from an (optionally) dot-delimited nested slice name.
+    #
+    # @example
+    #   base_slice_name("admin") # => "admin"
+    #   base_slice_name("admin.users") # => "admin"
+    def base_slice_name(name)
+      name.to_s.split(SLICE_DELIMITER).first
+    end
+
+    # Returns an array of slice names specific to the given child slice.
+    #
+    # @example
+    #   child_local_slice_names("admin", ["main", "admin.users"]) # => ["users"]
+    def child_slice_names(parent_slice_name, slice_names)
+      slice_names
+        &.select { |name|
+          name.include?(SLICE_DELIMITER) && name.split(SLICE_DELIMITER)[0] == parent_slice_name.to_s
+        }
+        &.map { |name|
+          name.split(SLICE_DELIMITER)[1..].join(SLICE_DELIMITER) # which version of Ruby supports this?
+        }
     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.beta1.1"
+    VERSION = "2.0.0.beta2"
 
     # @since 0.9.0
     # @api private

data/lib/hanami.rb

@@ -9,6 +9,57 @@ module Hanami
   @_mutex = Mutex.new
   @_bundled = {}
 
+  # Finds and loads the Hanami app file (`config/app.rb`).
+  #
+  # Raises an exception if the app file cannot be found.
+  #
+  # @return [Hanami::App] the loaded app class
+  #
+  # @api public
+  # @since 2.0.0
+  def self.setup(raise_exception: true)
+    return app if app?
+
+    app_path = self.app_path
+
+    if app_path
+      require(app_path)
+      app
+    elsif raise_exception
+      raise(
+        AppLoadError,
+        "Could not locate your Hanami app file.\n\n" \
+        "Your app file should be at `config/app.rb` in your project's root directory."
+      )
+    end
+  end
+
+  # Finds and returns the absolute path for the Hanami app file (`config/app.rb`).
+  #
+  # Searches within the given directory, then searches upwards through parent directories until the
+  # app file can be found.
+  #
+  # @param dir [String] The directory from which to start searching. Defaults to the current
+  #   directory.
+  #
+  # @return [String, nil] the app file path, or nil if not found.
+  #
+  # @api public
+  # @since 2.0.0
+  def self.app_path(dir = Dir.pwd)
+    dir = Pathname(dir).expand_path
+    path = dir.join(APP_PATH)
+
+    if path.file?
+      path.to_s
+    elsif !dir.root?
+      app_path(dir.parent)
+    end
+  end
+
+  APP_PATH = "config/app.rb"
+  private_constant :APP_PATH
+
   def self.app
     @_mutex.synchronize do
       unless defined?(@_app)
@@ -22,12 +73,12 @@ module Hanami
   end
 
   def self.app?
-    defined?(@_app)
+    instance_variable_defined?(:@_app)
   end
 
   def self.app=(klass)
     @_mutex.synchronize do
-      if defined?(@_app)
+      if instance_variable_defined?(:@_app)
         raise AppLoadError, "Hanami.app is already configured."
       end