hanami 2.0.0.beta4 → 2.0.0.rc1

data/lib/hanami/slice/router.rb

@@ -1,26 +1,36 @@
 # frozen_string_literal: true
 
 require "hanami/router"
-require_relative "routing/middleware/stack"
 
 module Hanami
   class Slice
-    # Hanami app router
+    # `Hanami::Router` subclass with enhancements for use within Hanami apps.
+    #
+    # This is loaded from Hanami apps and slices and made available as their
+    # {Hanami::Slice::ClassMethods#router router}.
+    #
+    # @api private
     # @since 2.0.0
     class Router < ::Hanami::Router
       # @api private
+      # @since 2.0.0
       attr_reader :middleware_stack
 
+      # @api private
       # @since 2.0.0
+      attr_reader :path_prefix
+
       # @api private
-      def initialize(routes:, middleware_stack: Routing::Middleware::Stack.new, **kwargs, &blk)
+      # @since 2.0.0
+      def initialize(routes:, middleware_stack: Routing::Middleware::Stack.new, prefix: ::Hanami::Router::DEFAULT_PREFIX, **kwargs, &blk)
+        @path_prefix = Hanami::Router::Prefix.new(prefix)
         @middleware_stack = middleware_stack
         instance_eval(&blk)
         super(**kwargs, &routes)
       end
 
-      # @since 2.0.0
       # @api private
+      # @since 2.0.0
       def freeze
         return self if frozen?
 
@@ -28,20 +38,32 @@ module Hanami
         super
       end
 
-      # @since 2.0.0
       # @api private
-      def use(...)
-        middleware_stack.use(...)
-      end
-
       # @since 2.0.0
-      # @api private
-      def scope(*args, &blk)
-        middleware_stack.with(args.first) do
-          super
-        end
+      def use(*args, **kwargs, &blk)
+        middleware_stack.use(*args, **kwargs.merge(path_prefix: path_prefix.to_s), &blk)
       end
 
+      # Yields a block for routes to resolve their action components from the given slice.
+      #
+      # An optional URL prefix may be supplied with `at:`.
+      #
+      # @example
+      #   # config/routes.rb
+      #
+      #   module MyApp
+      #     class Routes < Hanami::Routes
+      #       slice :admin, at: "/admin" do
+      #         # Will route to the "actions.posts.index" component in Admin::Slice
+      #         get "posts", to: "posts.index"
+      #       end
+      #     end
+      #   end
+      #
+      # @param slice_name [Symbol] the slice's name
+      # @param at [String, nil] optional URL prefix for the routes
+      #
+      # @api public
       # @since 2.0.0
       def slice(slice_name, at:, &blk)
         blk ||= @resolver.find_slice(slice_name).routes
@@ -49,13 +71,13 @@ module Hanami
         prev_resolver = @resolver
         @resolver = @resolver.to_slice(slice_name)
 
-        scope(prefixed_path(at), &blk)
+        scope(at, &blk)
       ensure
         @resolver = prev_resolver
       end
 
-      # @since 2.0.0
       # @api private
+      # @since 2.0.0
       def to_rack_app
         middleware_stack.to_rack_app(self)
       end

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

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
+require "hanami/router"
 require "hanami/middleware"
+require "hanami/middleware/app"
 require "hanami/errors"
 
 module Hanami
@@ -11,8 +13,8 @@ module Hanami
       module Middleware
         # Wraps a rack app with a middleware stack
         #
-        # We use this class to add middlewares to the rack application generated
-        # from {Hanami::Slice::Router}.
+        # We use this class to add middlewares to the rack application generated from
+        # {Hanami::Slice::Router}.
         #
         # ```
         # stack = Hanami::Slice::Routing::Middleware::Stack.new
@@ -28,28 +30,31 @@ module Hanami
         # end
         # ```
         #
+        # @see Hanami::Config#middleware
+        #
         # @since 2.0.0
         # @api private
         class Stack
           include Enumerable
 
-          # @since 2.0.0
-          # @api private
-          ROOT_PREFIX = "/"
-          private_constant :ROOT_PREFIX
-
           # @since 2.0.0
           # @api private
           attr_reader :stack
 
-          # @since 2.0.0
+          # Returns an array of Ruby namespaces from which to load middleware classes specified by
+          # symbol names given to {#use}.
+          #
+          # Defaults to `[Hanami::Middleware]`.
+          #
+          # @return [Array<Object>]
+          #
           # @api public
+          # @since 2.0.0
           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
@@ -58,23 +63,44 @@ module Hanami
           # @api private
           def initialize_copy(source)
             super
-            @prefix = source.instance_variable_get(:@prefix).dup
             @stack = stack.dup
             @namespaces = namespaces.dup
           end
 
+          # Adds a middleware to the stack.
+          #
+          # @example
+          #   # Using a symbol name; adds Hanami::Middleware::BodyParser.new([:json])
+          #   middleware.use :body_parser, :json
+          #
+          #   # Using a class name
+          #   middleware.use MyMiddleware
+          #
+          #   # Adding a middleware before or after others
+          #   middleware.use MyMiddleware, before: SomeMiddleware
+          #   middleware.use MyMiddleware, after: OtherMiddleware
+          #
+          # @param spec [Symbol, Class] the middleware name or class name
+          # @param args [Array, nil] Arguments to pass to the middleware's `.new` method
+          # @param before [Class, nil] an optional (already added) middleware class to add the
+          #   middleware before
+          # @param after [Class, nil] an optional (already added) middleware class to add the
+          #   middleware after
+          #
+          # @return [self]
+          #
+          # @api public
           # @since 2.0.0
-          # @api private
-          def use(spec, *args, before: nil, after: nil, &blk)
+          def use(spec, *args, path_prefix: ::Hanami::Router::DEFAULT_PREFIX, before: nil, after: nil, &blk)
             middleware = resolve_middleware_class(spec)
             item = [middleware, args, blk]
 
             if before
-              @stack[@prefix].insert((idx = index_of(before)).zero? ? 0 : idx - 1, item)
+              @stack[path_prefix].insert((idx = index_of(before, path_prefix)).zero? ? 0 : idx - 1, item)
             elsif after
-              @stack[@prefix].insert(index_of(after) + 1, item)
+              @stack[path_prefix].insert(index_of(after, path_prefix) + 1, item)
             else
-              @stack[@prefix].push([middleware, args, blk])
+              @stack[path_prefix].push([middleware, args, blk])
             end
 
             self
@@ -83,22 +109,12 @@ module Hanami
           # @since 2.0.0
           # @api private
           def update(other)
-            other.stack.each do |prefix, items|
-              stack[prefix].concat(items)
+            other.stack.each do |path_prefix, items|
+              stack[path_prefix].concat(items)
             end
             self
           end
 
-          # @since 2.0.0
-          # @api private
-          def with(path)
-            prefix = @prefix
-            @prefix = path
-            yield
-          ensure
-            @prefix = prefix
-          end
-
           # @since 2.0.0
           # @api private
           def to_rack_app(app)
@@ -106,20 +122,17 @@ module Hanami
               raise "Add \"rack\" to your `Gemfile` to run Hanami as a rack app"
             end
 
-            require "rack/builder"
-
-            s = self
+            mapping = to_hash
+            return app if mapping.empty?
 
-            Rack::Builder.new do
-              s.each do |prefix, stack|
-                s.mapped(self, prefix) do
-                  stack.each do |middleware, args, blk|
-                    use(middleware, *args, &blk)
-                  end
-                end
+            Hanami::Middleware::App.new(app, mapping)
+          end
 
-                run app
-              end
+          # @since 2.0.0
+          # @api private
+          def to_hash
+            @stack.each_with_object({}) do |(path, _), result|
+              result[path] = stack_for(path)
             end
           end
 
@@ -138,7 +151,7 @@ module Hanami
           # @since 2.0.0
           # @api private
           def mapped(builder, prefix, &blk)
-            if prefix == ROOT_PREFIX
+            if prefix == ::Hanami::Router::DEFAULT_PREFIX
               builder.instance_eval(&blk)
             else
               builder.map(prefix, &blk)
@@ -148,8 +161,18 @@ module Hanami
           private
 
           # @since 2.0.0
-          def index_of(middleware)
-            @stack[@prefix].index { |(m, *)| m.equal?(middleware) }
+          def index_of(middleware, path_prefix)
+            @stack[path_prefix].index { |(m, *)| m.equal?(middleware) }
+          end
+
+          # @since 2.0.0
+          # @api private
+          def stack_for(current_path)
+            @stack.each_with_object([]) do |(path, stack), result|
+              next unless current_path.start_with?(path)
+
+              result.push(stack)
+            end.flatten(1)
           end
 
           # @since 2.0.0
@@ -173,6 +196,7 @@ module Hanami
             rescue LoadError # rubocop:disable Lint/SuppressedException
             end
 
+            # FIXME: Classify must use App inflector
             class_name = Hanami::Utils::String.classify(spec.to_s)
             namespace = namespaces.detect { |ns| ns.const_defined?(class_name) }
 

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

@@ -1,24 +1,17 @@
 # frozen_string_literal: true
 
+require_relative "../../routes"
+
 module Hanami
   class Slice
+    # @api private
     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
       #
+      # This resolves endpoints objects from a slice container using the strings passed to `to:` as
+      # their container keys.
+      #
+      # @api private
       # @since 2.0.0
       class Resolver
         SLICE_ACTIONS_KEY_NAMESPACE = "actions"
@@ -55,7 +48,7 @@ module Hanami
             end
 
           unless endpoint.respond_to?(:call)
-            raise NotCallableEndpointError.new(endpoint)
+            raise Routes::NotCallableEndpointError.new(endpoint)
           end
 
           endpoint
@@ -79,7 +72,7 @@ module Hanami
           # 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)
+              raise Routes::MissingActionError.new(action_key, slice)
             end
 
             action.call(*args)
@@ -89,7 +82,7 @@ module Hanami
         def ensure_action_in_slice(key)
           return unless slice.booted?
 
-          raise UnknownActionError.new(key) unless slice.key?(key)
+          raise Routes::MissingActionError.new(key, slice) unless slice.key?(key)
         end
       end
     end

data/lib/hanami/slice/view_name_inferrer.rb

@@ -23,7 +23,7 @@ module Hanami
         #   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 action_class_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