hanami 2.0.0.alpha7 → 2.0.0.beta1

data/lib/hanami/settings.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "dry/configurable"
+require "dry/core/constants"
+
+module Hanami
+  # App settings
+  #
+  # Users are expected to inherit from this class to define their app settings.
+  #
+  # @example
+  #   # config/settings.rb
+  #   # frozen_string_literal: true
+  #
+  #   require "hanami/settings"
+  #   require "my_app/types"
+  #
+  #   module MyApp
+  #     class Settings < Hanami::Settings
+  #       setting :database_url
+  #       setting :feature_flag, default: false, constructor: Types::Params::Bool
+  #     end
+  #   end
+  #
+  # Settings are defined with
+  # [dry-configurable](https://dry-rb.org/gems/dry-configurable/), so you can
+  # take a look there to see the supported syntax.
+  #
+  # Users work with an instance of this class made available within the
+  # `settings` key in the container. The instance gets its settings populated
+  # from a configurable store, which defaults to
+  # {Hanami::Settings::DotenvStore}.
+  #
+  # A different store can be set through the `settings_store` Hanami
+  # configuration option. All it needs to do is implementing a `#fetch` method
+  # with the same signature as `Hash#fetch`.
+  #
+  # @see Hanami::Settings::DotenvStore
+  # @since 2.0.0
+  class Settings
+    # Exception for errors in the definition of settings.
+    #
+    # Its message collects all the individual errors that can be raised for
+    # each setting.
+    InvalidSettingsError = Class.new(StandardError) do
+      def initialize(errors)
+        @errors = errors
+      end
+
+      def to_s
+        <<~STR.strip
+          Could not initialize settings. The following settings were invalid:
+
+          #{@errors.map { |setting, message| "#{setting}: #{message}" }.join("\n")}
+        STR
+      end
+    end
+
+    # @api private
+    EMPTY_STORE = Dry::Core::Constants::EMPTY_HASH
+
+    include Dry::Configurable
+
+    # @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
+      rescue => e # rubocop:disable Style/RescueStandardError
+        errs.merge(name => e)
+      end
+
+      raise InvalidSettingsError, errors if errors.any?
+    end
+
+    private
+
+    def method_missing(name, *args, &block)
+      if config.respond_to?(name)
+        config.send(name, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(name, _include_all = false)
+      config.respond_to?(name) || super
+    end
+  end
+end

data/lib/hanami/setup.rb

@@ -4,6 +4,8 @@ require "bundler/setup"
 require "hanami"
 
 begin
-  require File.join(Dir.pwd, "config/application")
-rescue LoadError # rubocop:disable Lint/SuppressedException
+  app_require_path = File.join(Dir.pwd, "config/app")
+  require app_require_path
+rescue LoadError => e
+  raise e unless e.path == app_require_path
 end

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

@@ -1,13 +1,16 @@
 # frozen_string_literal: true
 
 require "hanami/router"
-require "hanami/application/routing/middleware/stack"
+require_relative "routing/middleware/stack"
 
 module Hanami
-  class Application
-    # Hanami application router
+  class Slice
+    # Hanami app router
     # @since 2.0.0
     class Router < ::Hanami::Router
+      # @api private
+      attr_reader :middleware_stack
+
       # @since 2.0.0
       # @api private
       def initialize(routes:, middleware_stack: Routing::Middleware::Stack.new, **kwargs, &blk)
@@ -27,32 +30,34 @@ module Hanami
 
       # @since 2.0.0
       # @api private
-      def use(middleware, *args, &blk)
-        @middleware_stack.use(middleware, *args, &blk)
+      def use(...)
+        middleware_stack.use(...)
       end
 
       # @since 2.0.0
       # @api private
       def scope(*args, &blk)
-        @middleware_stack.with(args.first) do
+        middleware_stack.with(args.first) do
           super
         end
       end
 
       # @since 2.0.0
-      def slice(name, at:, &blk)
-        path = prefixed_path(at)
-        @resolver.register_slice_at_path(name, path)
+      def slice(slice_name, at:, &blk)
+        blk ||= @resolver.find_slice(slice_name).routes
 
-        scope(path, &blk)
+        prev_resolver = @resolver
+        @resolver = @resolver.to_slice(slice_name)
+
+        scope(prefixed_path(at), &blk)
+      ensure
+        @resolver = prev_resolver
       end
 
       # @since 2.0.0
       # @api private
       def to_rack_app
-        return self if @middleware_stack.empty?
-
-        @middleware_stack.to_rack_app(self)
+        middleware_stack.to_rack_app(self)
       end
     end
   end

data/lib/hanami/slice/routes_helper.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Hanami
+  class Slice
+    # Hanami app routes helpers
+    #
+    # An instance of this class will be registered with slice (at the "routes" key). You
+    # can use it to access the route helpers for your app.
+    #
+    # @example
+    #   MyApp::App["routes"].path(:root) # => "/"
+    #
+    # @see Hanami::Router::UrlHelpers
+    # @since 2.0.0
+    class RoutesHelper
+      # @since 2.0.0
+      # @api private
+      def initialize(router)
+        @router = router
+      end
+
+      # @see Hanami::Router::UrlHelpers#path
+      def path(...)
+        router.path(...)
+      end
+
+      # @see Hanami::Router::UrlHelpers#url
+      def url(...)
+        router.url(...)
+      end
+
+      private
+
+      attr_reader :router
+    end
+  end
+end

data/lib/hanami/{application → slice}/routing/middleware/stack.rb

@@ -3,7 +3,7 @@
 require "rack/builder"
 
 module Hanami
-  class Application
+  class Slice
     module Routing
       # Hanami::Applicatione::Router middleware stack
       #
@@ -20,6 +20,10 @@ module Hanami
           ROOT_PREFIX = "/"
           private_constant :ROOT_PREFIX
 
+          # @since 2.0.0
+          # @api private
+          attr_reader :stack
+
           # @since 2.0.0
           # @api private
           def initialize
@@ -29,8 +33,35 @@ module Hanami
 
           # @since 2.0.0
           # @api private
-          def use(middleware, *args, &blk)
-            @stack[@prefix].push([middleware, args, blk])
+          def initialize_copy(source)
+            super
+            @prefix = source.instance_variable_get(:@prefix).dup
+            @stack = stack.dup
+          end
+
+          # @since 2.0.0
+          # @api private
+          def use(middleware, *args, before: nil, after: nil, &blk)
+            item = [middleware, args, blk]
+
+            if before
+              @stack[@prefix].insert((idx = index_of(before)).zero? ? 0 : idx - 1, item)
+            elsif after
+              @stack[@prefix].insert(index_of(after) + 1, item)
+            else
+              @stack[@prefix].push([middleware, args, blk])
+            end
+
+            self
+          end
+
+          # @since 2.0.0
+          # @api private
+          def update(other)
+            other.stack.each do |prefix, items|
+              stack[prefix].concat(items)
+            end
+            self
           end
 
           # @since 2.0.0
@@ -45,7 +76,7 @@ module Hanami
 
           # @since 2.0.0
           # @api private
-          def to_rack_app(app) # rubocop:disable Metrics/MethodLength
+          def to_rack_app(app)
             s = self
 
             Rack::Builder.new do
@@ -58,7 +89,7 @@ module Hanami
 
                 run app
               end
-            end.to_app
+            end
           end
 
           # @since 2.0.0
@@ -82,6 +113,13 @@ module Hanami
               builder.map(prefix, &blk)
             end
           end
+
+          private
+
+          # @since 2.0.0
+          def index_of(middleware)
+            @stack[@prefix].index { |(m, *)| m.equal?(middleware) }
+          end
         end
       end
     end

data/lib/hanami/slice/routing/resolver.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Hanami
+  class Slice
+    module Routing
+      # @since 2.0.0
+      class UnknownActionError < Hanami::Error
+        def initialize(identifier)
+          super("unknown action referenced in router: `#{identifier.inspect}'")
+        end
+      end
+
+      # @since 2.0.0
+      class NotCallableEndpointError < StandardError
+        def initialize(endpoint)
+          super("#{endpoint.inspect} is not compatible with Rack. Please make sure it implements #call.")
+        end
+      end
+
+      # Hanami app router endpoint resolver
+      #
+      # @since 2.0.0
+      class Resolver
+        SLICE_ACTIONS_KEY_NAMESPACE = "actions"
+
+        # @api private
+        # @since 2.0.0
+        def initialize(slice:)
+          @slice = slice
+        end
+
+        # @api private
+        # @since 2.0.0
+        def find_slice(slice_name)
+          slice.slices[slice_name]
+        end
+
+        # @api private
+        # @since 2.0.0
+        def to_slice(slice_name)
+          self.class.new(slice: find_slice(slice_name))
+        end
+
+        # @api private
+        # @since 2.0.0
+        def call(_path, endpoint)
+          endpoint =
+            case endpoint
+            when String
+              resolve_slice_action(endpoint)
+            when Class
+              endpoint.respond_to?(:call) ? endpoint : endpoint.new
+            else
+              endpoint
+            end
+
+          unless endpoint.respond_to?(:call)
+            raise NotCallableEndpointError.new(endpoint)
+          end
+
+          endpoint
+        end
+
+        private
+
+        # @api private
+        # @since 2.0.0
+        attr_reader :slice
+
+        # @api private
+        # @since 2.0.0
+        def resolve_slice_action(key)
+          action_key = "#{SLICE_ACTIONS_KEY_NAMESPACE}.#{key}"
+
+          ensure_action_in_slice(action_key)
+
+          # Lazily resolve action from the slice to reduce router initialization time, and
+          # circumvent endless loops from the action requiring access to router-related
+          # concerns (which may not be fully loaded at the time of reading the routes)
+          -> (*args) {
+            action = slice.resolve(action_key) do
+              raise UnknownActionError.new(key)
+            end
+
+            action.call(*args)
+          }
+        end
+
+        def ensure_action_in_slice(key)
+          return unless slice.booted?
+
+          raise UnknownActionError.new(key) unless slice.key?(key)
+        end
+      end
+    end
+  end
+end

data/lib/hanami/slice/view_name_inferrer.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "../constants"
+
+module Hanami
+  class Slice
+    # Infers a view name for automatically rendering within actions.
+    #
+    # @api private
+    # @since 2.0.0
+    class ViewNameInferrer
+      ALTERNATIVE_NAMES = {
+        "create" => "new",
+        "update" => "edit"
+      }.freeze
+
+      class << self
+        # Returns an array of container keys for views matching the given action.
+        #
+        # Also provides alternative view keys for common RESTful actions.
+        #
+        # @example
+        #   ViewNameInferrer.call(action_name: "Main::Actions::Posts::Create", slice: Main::Slice)
+        #   # => ["views.posts.create", "views.posts.new"]
+        #
+        # @param action_name [String] action class name
+        # @param slice [Hanami::Slice, Hanami::Application] Hanami slice containing the action
+        #
+        # @return [Array<string>] array of paired view container keys
+        def call(action_class_name:, slice:)
+          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)
+
+          view_key = [view_key_base, action_name_key].compact.join(CONTAINER_KEY_DELIMITER)
+
+          [view_key, alternative_view_key(view_key)].compact
+        end
+
+        private
+
+        def action_name_key(action_name, slice, key_base)
+          slice
+            .inflector
+            .underscore(action_name)
+            .sub(%r{^#{slice.slice_name.path}#{PATH_DELIMITER}}, "")
+            .sub(%r{^#{key_base}#{PATH_DELIMITER}}, "")
+            .gsub("/", CONTAINER_KEY_DELIMITER)
+        end
+
+        def alternative_view_key(view_key)
+          parts = view_key.split(CONTAINER_KEY_DELIMITER)
+
+          alternative_name = ALTERNATIVE_NAMES[parts.last]
+          return unless alternative_name
+
+          [parts[0..-2], alternative_name].join(CONTAINER_KEY_DELIMITER)
+        end
+      end
+    end
+  end
+end