hanami 2.0.0.beta3 → 2.0.0.beta4

data/lib/hanami/settings.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
+require "dry/core"
 require "dry/configurable"
-require "dry/core/constants"
 
 module Hanami
   # App settings
@@ -33,11 +33,72 @@ module Hanami
   # needs to do is implementing a `#fetch` method with the same signature as `Hash#fetch`.
   #
   # @see Hanami::Settings::DotenvStore
+  #
+  # @api public
   # @since 2.0.0
   class Settings
+    class << self
+      def inherited(subclass)
+        super
+
+        if Hanami.bundled?("dry-types")
+          require "dry/types"
+          subclass.const_set(:Types, Dry.Types())
+        end
+      end
+
+      # Loads the settings for a slice.
+      #
+      # Returns nil if no settings class is defined.
+      #
+      # @return [Settings, nil]
+      #
+      # @api private
+      def load_for_slice(slice)
+        return unless settings_defined?(slice)
+
+        require_slice_settings(slice) unless slice_settings_class?(slice)
+
+        slice_settings_class(slice).new(slice.config.settings_store)
+      end
+
+      private
+
+      # Returns true if settings are defined for the slice.
+      #
+      # Settings are considered defined if a `Settings` class is already defined in the slice
+      # namespace, or a `config/settings.rb` exists under the slice root.
+      def settings_defined?(slice)
+        slice.namespace.const_defined?(SETTINGS_CLASS_NAME) ||
+          slice.root.join("#{SETTINGS_PATH}#{RB_EXT}").file?
+      end
+
+      def slice_settings_class?(slice)
+        slice.namespace.const_defined?(SETTINGS_CLASS_NAME)
+      end
+
+      def slice_settings_class(slice)
+        slice.namespace.const_get(SETTINGS_CLASS_NAME)
+      end
+
+      def require_slice_settings(slice)
+        require "hanami/settings"
+
+        slice_settings_require_path = File.join(slice.root, SETTINGS_PATH)
+
+        begin
+          require slice_settings_require_path
+        rescue LoadError => e
+          raise e unless e.path == slice_settings_require_path
+        end
+      end
+    end
+
     # Exception for errors in the definition of settings.
     #
     # Its message collects all the individual errors that can be raised for each setting.
+    #
+    # @api public
     InvalidSettingsError = Class.new(StandardError) do
       def initialize(errors)
         @errors = errors
@@ -52,6 +113,9 @@ module Hanami
       end
     end
 
+    # @api private
+    Undefined = Dry::Core::Constants::Undefined
+
     # @api private
     EMPTY_STORE = Dry::Core::Constants::EMPTY_HASH
 
@@ -59,14 +123,32 @@ module Hanami
 
     # @api private
     def initialize(store = EMPTY_STORE)
-      errors = config._settings.map(&:name).reduce({}) do |errs, name|
-        public_send("#{name}=", store.fetch(name) { Dry::Core::Constants::Undefined })
-        errs
+      errors = config._settings.map(&:name).each_with_object({}) do |name, errs|
+        value = store.fetch(name, Undefined)
+
+        if value.eql?(Undefined)
+          # When a key is missing entirely from the store, _read_ its value from the config instead,
+          # which ensures its setting constructor runs (with a `nil` argument given) and raises any
+          # necessary errors.
+          public_send(name)
+        else
+          public_send("#{name}=", value)
+        end
       rescue => e # rubocop:disable Style/RescueStandardError
-        errs.merge(name => e)
+        errs[name] = e
       end
 
       raise InvalidSettingsError, errors if errors.any?
+
+      config.finalize!
+    end
+
+    def inspect
+      "#<#{self.class.to_s} [#{config._settings.map(&:name).join(", ")}]>"
+    end
+
+    def inspect_values
+      "#<#{self.class.to_s} #{config._settings.map { |setting| "#{setting.name}=#{config[setting.name].inspect}" }.join(" ")}>"
     end
 
     private

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

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "hanami/middleware"
+require "hanami/errors"
+
 module Hanami
   class Slice
     module Routing
@@ -39,11 +42,16 @@ module Hanami
           # @api private
           attr_reader :stack
 
+          # @since 2.0.0
+          # @api public
+          attr_reader :namespaces
+
           # @since 2.0.0
           # @api private
           def initialize
             @prefix = ROOT_PREFIX
             @stack = Hash.new { |hash, key| hash[key] = [] }
+            @namespaces = [Hanami::Middleware]
           end
 
           # @since 2.0.0
@@ -52,11 +60,13 @@ module Hanami
             super
             @prefix = source.instance_variable_get(:@prefix).dup
             @stack = stack.dup
+            @namespaces = namespaces.dup
           end
 
           # @since 2.0.0
           # @api private
-          def use(middleware, *args, before: nil, after: nil, &blk)
+          def use(spec, *args, before: nil, after: nil, &blk)
+            middleware = resolve_middleware_class(spec)
             item = [middleware, args, blk]
 
             if before
@@ -141,6 +151,40 @@ module Hanami
           def index_of(middleware)
             @stack[@prefix].index { |(m, *)| m.equal?(middleware) }
           end
+
+          # @since 2.0.0
+          def resolve_middleware_class(spec)
+            case spec
+            when Symbol then load_middleware_class(spec)
+            when Class, Module then spec
+            else
+              if spec.respond_to?(:call)
+                spec
+              else
+                raise UnsupportedMiddlewareSpecError, spec
+              end
+            end
+          end
+
+          # @since 2.0.0
+          def load_middleware_class(spec)
+            begin
+              require "hanami/middleware/#{spec}"
+            rescue LoadError # rubocop:disable Lint/SuppressedException
+            end
+
+            class_name = Hanami::Utils::String.classify(spec.to_s)
+            namespace = namespaces.detect { |ns| ns.const_defined?(class_name) }
+
+            if namespace
+              namespace.const_get(class_name)
+            else
+              raise(
+                UnsupportedMiddlewareSpecError,
+                "Failed to find corresponding middleware class for `#{spec}` in #{namespaces.join(', ')}"
+              )
+            end
+          end
         end
       end
     end

data/lib/hanami/slice.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
-require "dry/system/container"
 require "zeitwerk"
+require "dry/system"
+
+require_relative "../hanami"
 require_relative "constants"
 require_relative "errors"
+require_relative "settings"
 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.
@@ -17,12 +19,11 @@ module Hanami
   # 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.
+  # Each slice has its own config, 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 expect an Hanami app to be defined (which itself is a slice). They will initialize their
+  # config 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
@@ -56,15 +57,14 @@ module Hanami
         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|
+      # A slice's config is copied from the app config at time of first access. The app should have
+      # its config completed before slices are loaded.
+      def config
+        @config ||= app.config.dup.tap do |slice_config|
           # Remove specific values from app that will not apply to this slice
-          config.root = nil
+          slice_config.root = nil
         end
       end
-      alias_method :config, :configuration
 
       def slice_name
         @slice_name ||= SliceName.new(self, inflector: method(:inflector))
@@ -75,11 +75,22 @@ module Hanami
       end
 
       def root
-        configuration.root
+        # Provide a best guess for a root when it is not yet configured.
+        #
+        # This is particularly useful for user-defined slice classes that access `settings` inside
+        # the class body (since the root needed to find the settings file). In this case,
+        # `configuration.root` may be nil when `settings` is called, since the root is configured by
+        # `SliceRegistrar#configure_slice` _after_ the class is loaded.
+        #
+        # In common cases, this best guess will be correct since most Hanami slices will be expected
+        # to live in the app SLICES_DIR. For advanced cases, the correct slice root should be
+        # explicitly configured at the beginning of the slice class body, before any calls to
+        # `settings`.
+        config.root || app.root.join(SLICES_DIR, slice_name.to_s)
       end
 
       def inflector
-        configuration.inflector
+        config.inflector
       end
 
       def prepare(provider_name = nil)
@@ -180,6 +191,12 @@ module Hanami
         end
       end
 
+      def settings
+        return @settings if instance_variable_defined?(:@settings)
+
+        @settings = Settings.load_for_slice(self)
+      end
+
       def routes
         @routes ||= load_routes
       end
@@ -209,7 +226,7 @@ module Hanami
       def prepare_slice
         return self if prepared?
 
-        configuration.finalize!
+        config.finalize!
 
         ensure_slice_name
         ensure_slice_consts
@@ -222,8 +239,6 @@ module Hanami
 
         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)
@@ -250,17 +265,13 @@ module Hanami
       end
 
       def ensure_root
-        unless configuration.root
+        unless config.root
           raise SliceLoadError, "Slice must have a `config.root` before it can be prepared"
         end
       end
 
-      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_settings
         prepare_container_consts
         prepare_container_plugins
         prepare_container_base_config
@@ -269,6 +280,15 @@ module Hanami
         prepare_container_providers
       end
 
+      def prepare_settings
+        container.register(:settings, settings) if settings
+      end
+
+      def prepare_container_consts
+        namespace.const_set :Container, container
+        namespace.const_set :Deps, container.injector
+      end
+
       def prepare_container_plugins
         container.use(:env, inferrer: -> { Hanami.env })
 
@@ -285,8 +305,8 @@ module Hanami
         container.config.root = root
         container.config.provider_dirs = [File.join("config", "providers")]
 
-        container.config.env = configuration.env
-        container.config.inflector = configuration.inflector
+        container.config.env = config.env
+        container.config.inflector = config.inflector
       end
 
       def prepare_container_component_dirs
@@ -304,7 +324,7 @@ module Hanami
         # 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)
+        no_auto_register_paths = ([LIB_DIR, CONFIG_DIR] + config.no_auto_register_paths)
           .map { |path|
             path.end_with?(File::SEPARATOR) ? path : "#{path}#{File::SEPARATOR}"
           }
@@ -335,8 +355,6 @@ module Hanami
           require_relative "providers/routes"
           register_provider(:routes, source: Providers::Routes.for_slice(self))
         end
-
-        Providers::Settings.register_with_slice(self)
       end
 
       def prepare_autoloader
@@ -358,17 +376,14 @@ module Hanami
         autoloader.setup
       end
 
-      def prepare_container_consts
-        namespace.const_set :Container, container
-        namespace.const_set :Deps, container.injector
-      end
-
       def prepare_slices
         slices.load_slices.each(&:prepare)
         slices.freeze
       end
 
       def load_routes
+        return false unless Hanami.bundled?("hanami-router")
+
         if root.directory?
           routes_require_path = File.join(root, ROUTES_PATH)
 
@@ -393,14 +408,14 @@ module Hanami
 
         require_relative "slice/router"
 
-        config = configuration
+        config = self.config
         rack_monitor = self["rack.monitor"]
 
         Slice::Router.new(
           inspector: inspector,
           routes: routes,
-          resolver: configuration.router.resolver.new(slice: self),
-          **configuration.router.options
+          resolver: config.router.resolver.new(slice: self),
+          **config.router.options
         ) do
           use(rack_monitor)
           use(*config.sessions.middleware) if config.sessions.enabled?

data/lib/hanami/slice_configurable.rb

@@ -56,7 +56,7 @@ module Hanami
       def slice_for(klass)
         return unless klass.name
 
-        slices = Hanami.app.slices.to_a + [Hanami.app]
+        slices = Hanami.app.slices.with_nested + [Hanami.app]
 
         slices.detect { |slice| klass.name.include?(slice.namespace.to_s) }
       end

data/lib/hanami/slice_registrar.rb

@@ -75,6 +75,12 @@ module Hanami
       slices.values
     end
 
+    def with_nested
+      to_a.flat_map { |slice|
+        [slice] + slice.slices.with_nested
+      }
+    end
+
     private
 
     def root

data/lib/hanami/version.rb

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

data/lib/hanami.rb

@@ -114,7 +114,6 @@ module Hanami
     @_mutex.synchronize do
       @_bundled[gem_name] ||= begin
         gem(gem_name)
-        true
       rescue Gem::LoadError
         false
       end

data/spec/integration/container/prepare_container_spec.rb

@@ -23,6 +23,8 @@ RSpec.describe "Container / prepare_container", :app_integration do
 
     # The prepare_container block is called when the slice is prepared
     slice.prepare
+
+    autoloaders_teardown!
   end
 
   describe "in app", :in_prepare_container do

data/spec/integration/rack_app/body_parser_spec.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "rack/test"
+
+RSpec.describe "Hanami web app", :app_integration do
+  include Rack::Test::Methods
+
+  let(:app) { Hanami.app }
+
+  around do |example|
+    with_tmp_directory(Dir.mktmpdir, &example)
+  end
+
+  specify "Setting middlewares in the config" do
+    write "config/app.rb", <<~RUBY
+      require "hanami"
+
+      module TestApp
+        class App < Hanami::App
+          config.middleware.use :body_parser, :json
+        end
+      end
+    RUBY
+
+    write "config/routes.rb", <<~RUBY
+      module TestApp
+        class Routes < Hanami::Routes
+          post "/users", to: "users.create"
+        end
+      end
+    RUBY
+
+    write "app/actions/users/create.rb", <<~RUBY
+      module TestApp
+        module Actions
+          module Users
+            class Create < Hanami::Action
+              accept :json
+
+              def handle(req, res)
+                res.body = req.params[:users].join("-")
+              end
+            end
+          end
+        end
+      end
+    RUBY
+
+    require "hanami/boot"
+
+    post(
+      "/users",
+      JSON.dump("users" => %w[jane john jade joe]),
+      "CONTENT_TYPE" => "application/json"
+    )
+
+    expect(last_response).to be_successful
+    expect(last_response.body).to eql("jane-john-jade-joe")
+  end
+
+  specify "Configuring custom mime-types and body parser" do
+    write "config/app.rb", <<~RUBY
+      require "hanami"
+
+      module TestApp
+        class App < Hanami::App
+          config.actions.formats["application/json+scim"] = :json
+          config.middleware.use :body_parser, [json: "application/json+scim"]
+        end
+      end
+    RUBY
+
+    write "config/routes.rb", <<~RUBY
+      module TestApp
+        class Routes < Hanami::Routes
+          post "/users", to: "users.create"
+        end
+      end
+    RUBY
+
+    write "app/actions/users/create.rb", <<~RUBY
+      module TestApp
+        module Actions
+          module Users
+            class Create < Hanami::Action
+              accept :json
+
+              def handle(req, res)
+                res.body = req.params[:users].join("-")
+              end
+            end
+          end
+        end
+      end
+    RUBY
+
+    require "hanami/boot"
+
+    post(
+      "/users",
+      JSON.dump("users" => %w[jane john jade joe]),
+      "CONTENT_TYPE" => "application/json+scim"
+    )
+
+    expect(last_response).to be_successful
+    expect(last_response.body).to eql("jane-john-jade-joe")
+  end
+end

data/spec/integration/rack_app/middleware_spec.rb

@@ -206,4 +206,32 @@ RSpec.describe "Hanami web app", :app_integration do
     expect(last_response).to be_successful
     expect(last_response.body).to eql("yes")
   end
+
+  context "Using module as a middleware" do
+    it "sets the module as the middleware" do
+      mod = Module.new
+      app = Class.new(Hanami::App) { config.middleware.use(mod) }
+
+      expect(app.config.middleware.stack["/"][0]).to include(mod)
+    end
+  end
+
+  context "Setting an unsupported middleware" do
+    it "raises meaningful error when an unsupported middleware spec was passed" do
+      expect {
+        Class.new(Hanami::App) do
+          config.middleware.use("oops")
+        end
+      }.to raise_error(Hanami::UnsupportedMiddlewareSpecError)
+    end
+
+    it "raises meaningful error when corresponding file failed to load" do
+      expect {
+        Class.new(Hanami::App) do
+          config.middleware.namespaces.delete(Hanami::Middleware)
+          config.middleware.use(:body_parser)
+        end
+      }.to raise_error(Hanami::UnsupportedMiddlewareSpecError)
+    end
+  end
 end

data/spec/integration/settings/access_in_slice_class_body_spec.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+RSpec.describe "Settings / Access within slice class bodies", :app_integration do
+  before do
+    @env = ENV.to_h
+  end
+
+  after do
+    ENV.replace(@env)
+  end
+
+  context "app class" do
+    it "provides access to the settings inside the class body" do
+      with_directory(make_tmp_directory) do
+        write "config/app.rb", <<~'RUBY'
+          require "hanami"
+
+          module TestApp
+            class App < Hanami::App
+              @some_flag = settings.some_flag
+            end
+          end
+        RUBY
+
+        write ".env", <<~'TEXT'
+          SOME_FLAG=true
+        TEXT
+
+        write "config/settings.rb", <<~'RUBY'
+          module TestApp
+            class Settings < Hanami::Settings
+              setting :some_flag
+            end
+          end
+        RUBY
+
+        require "hanami/setup"
+
+        expect(Hanami.app.instance_variable_get(:@some_flag)).to eq "true"
+      end
+    end
+  end
+
+  context "slice class" do
+    it "provides access to the settings inside the class body" do
+      with_directory(make_tmp_directory) do
+        write "config/app.rb", <<~'RUBY'
+          require "hanami"
+
+          module TestApp
+            class App < Hanami::App
+            end
+          end
+        RUBY
+
+        write "config/slices/main.rb", <<~'RUBY'
+          module Main
+            class Slice < Hanami::Slice
+              @some_flag = settings.some_flag
+            end
+          end
+        RUBY
+
+        write ".env", <<~'TEXT'
+          SOME_FLAG=true
+        TEXT
+
+        write "slices/main/config/settings.rb", <<~'RUBY'
+          module Main
+            class Settings < Hanami::Settings
+              setting :some_flag
+            end
+          end
+        RUBY
+
+        require "hanami/prepare"
+
+        expect(Main::Slice.instance_variable_get(:@some_flag)).to eq "true"
+      end
+    end
+  end
+end