hanami-router 2.0.0.beta2 → 2.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 81061c98f91ba599e04ca8e16ac1ae9f8784e8398f3580b552cfa26885218b2e
-  data.tar.gz: cd776fa30375c022808441897e3849ec76ef5a6d5b452b36a444851c10a4f99c
+  metadata.gz: dc0a68636ae47869944fc0c76f262c420356d3fbf10bd12b270692f48d3ea7bb
+  data.tar.gz: cb653be9037e33f02a05bcbf2048109d64e561afafaa03c8ed353b4b3183d672
 SHA512:
-  metadata.gz: 3cdc82d97486a5d74893d8fdff7bd1f337dc5d64d6ff6407133519aef0b8a287b369231d973b62a4da5fdee7d07ecb766d3d0fd39a8e08aa3cd966a425fff238
-  data.tar.gz: ccc62d079fba4374b74dde5b008e3de0d4d5eaf630c9608179bca0ad0ff7ba6b0584713bb320977950f7901d0404b601598b2d6c97ffa218be428e8be47b2380
+  metadata.gz: 4e50ba3c0279d9c26a1ef882127ef7d02ca39cb5ebab25589799ab7190e4562a40e57d0dcbcfe285b1e9dc7ab312dedc0ebf2553d4da3afc921821a8d23cc233
+  data.tar.gz: b6f390eb1750d6e596bb1064573467fbd8d5ceccb3bbf0e34a8ab021dd1162d4fc88a8edee4d36a221d053a8ee3d656114004ac6ebbb9b87fc43636bd8715004

data/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 Rack compatible HTTP router for Ruby
 
+## v2.0.0.rc1 - 2022-11-08
+
+### Fixed
+
+- [Luca Guidi] During routes inspection, ensure to print path prefixes for nested named routes
+
+### Changed
+
+- [Benjamin Klotz] `Hanami::Middleware::BodyParser::Parser#parse` (abstract method) to raise `NoMethodError` instead of `NotImplementedError`
+
+## v2.0.0.beta4 - 2022-10-24
+
+### Changed
+
+- [Peter Solnica] `Hanami::Middleware::BodyParser` can be initialized with one or more formats and additional custom mime types per format (`Hanami::Middleware::BodyParser.new(app, [:json, :xml])` or `Hanami::Middleware::BodyParser.new(app, [json: "application/json+scim"])`) (#230)
+
 ## v2.0.0.beta2 - 2022-08-16
 
 ### Fixed

data/lib/hanami/middleware/app.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "rack/builder"
+require_relative "./trie"
+
+module Hanami
+  module Middleware
+    # Hanami Rack middleware stack
+
+    # @since 2.0.0
+    # @api private
+    class App
+      # @param router [Hanami::Router]
+      # @param mapping [Hash]
+      #
+      # @since 2.0.0
+      # @api private
+      def initialize(router, mapping)
+        @trie = Hanami::Middleware::Trie.new(router)
+
+        mapping.each do |path, stack|
+          builder = Rack::Builder.new
+
+          stack.each do |middleware, args, blk|
+            builder.use(middleware, *args, &blk)
+          end
+
+          builder.run(router)
+
+          @trie.add(path, builder.to_app.freeze)
+        end
+
+        @trie.freeze
+        @inspector = router.inspector.freeze
+      end
+
+      # @since 2.0.0
+      # @api private
+      def call(env)
+        @trie.find(env[::Rack::PATH_INFO]).call(env)
+      end
+
+      # @since 2.0.0
+      # @api private
+      def to_inspect
+        @inspector&.call.to_s
+      end
+    end
+  end
+end

data/lib/hanami/middleware/body_parser/class_interface.rb

@@ -9,15 +9,38 @@ module Hanami
       # @api private
       # @since 1.3.0
       module ClassInterface
+        # Instantiate a new body parser instance and load its parsers
+        #
+        # @example
+        #   Hanami::Middleware::BodyParser.new(->(env) { [200, {}, "app"] }, :json)
+        #
+        #   Hanami::Middleware::BodyParser.new(
+        #     ->(env) { [200, {}, "app"] }, [json: "application/json+scim"]
+        #   )
+        #
+        #   Hanami::Middleware::BodyParser.new(
+        #     ->(env) { [200, {}, "app"] }, [json: ["application/json+scim", "application/ld+json"]]
+        #   )
+        #
+        # @param app [#call]
+        # @param parser_specs [Symbol, Array<Hash>] parser name or name with mime-type(s)
+        #
+        # @api private
+        # @since 2.0.0
+        # @return BodyParser
+        def new(app, parser_specs)
+          super(app, build_parsers(parser_specs))
+        end
+
         # @api private
         # @since 1.3.0
-        def for(parser)
+        def build(parser, **config)
           parser =
             case parser
             when String, Symbol
-              require_parser(parser)
+              build(parser_class(parser), **config)
             when Class
-              parser.new
+              parser.new(**config)
             else
               parser
             end
@@ -27,32 +50,76 @@ module Hanami
           parser
         end
 
+        # @api private
+        # @since 2.0.0
+        def build_parsers(parser_specs, registry = {})
+          return DEFAULT_BODY_PARSERS if parser_specs.empty?
+
+          parsers = Array(parser_specs).flatten(0)
+
+          parsers.each_with_object(registry) do |spec, memo|
+            if spec.is_a?(Hash) && spec.size > 1
+              spec.each do |key, value|
+                build_parsers([key => [value]], memo)
+              end
+            else
+              name, *mime_types = Array(*spec).flatten(0)
+
+              parser = build(name, mime_types: mime_types.flatten)
+
+              parser.mime_types.each do |mime|
+                memo[mime] = parser
+              end
+            end
+          end
+        end
+
         private
 
         # @api private
         # @since 1.3.0
         PARSER_METHODS = %i[mime_types parse].freeze
 
+        # @api private
+        # @since 2.0.0
+        DEFAULT_BODY_PARSERS = {}.freeze
+
         # @api private
         # @since 1.3.0
         def ensure_parser(parser)
-          raise InvalidParserError.new(parser) unless PARSER_METHODS.all? { |method| parser.respond_to?(method) }
+          unless PARSER_METHODS.all? { |method| parser.respond_to?(method) }
+            raise InvalidParserError.new(parser)
+          end
         end
 
         # @api private
         # @since 1.3.0
-        def require_parser(parser)
-          require "hanami/middleware/body_parser/#{parser}_parser"
+        # rubocop:disable Lint/SuppressedException
+        def parser_class(parser_name)
+          parser = nil
+
+          begin
+            require "hanami/middleware/body_parser/#{parser_name}_parser"
+          rescue LoadError; end
+
+          begin
+            parser = load_parser!("#{classify(parser_name)}Parser")
+          rescue NameError; end
 
-          load_parser!("#{classify(parser)}Parser").new
-        rescue LoadError, NameError
-          raise UnknownParserError.new(parser)
+          parser
+        ensure
+          raise UnknownParserError, parser_name unless parser
         end
+        # rubocop:enable Lint/SuppressedException
 
+        # @api private
+        # @since 1.3.0
         def classify(parser)
           parser.to_s.split(/_/).map(&:capitalize).join
         end
 
+        # @api private
+        # @since 1.3.0
         def load_parser!(class_name)
           Hanami::Middleware::BodyParser.const_get(class_name, false)
         end

data/lib/hanami/middleware/body_parser/json_parser.rb

@@ -11,7 +11,7 @@ module Hanami
       class JsonParser < Parser
         # @since 1.3.0
         # @api private
-        def mime_types
+        def self.mime_types
           ["application/json", "application/vnd.api+json"]
         end
 

data/lib/hanami/middleware/body_parser/parser.rb

@@ -7,7 +7,9 @@ module Hanami
       #
       # @since 2.0.0
       class Parser
-        # Declare supported MIME types
+        DEFAULT_MIME_TYPES = [].freeze
+
+        # Return supported mime types
         #
         # @return [Array<String>] supported MIME types
         #
@@ -18,12 +20,15 @@ module Hanami
         #   require "hanami/middleware/body_parser"
         #
         #   class XMLParser < Hanami::Middleware::BodyParser::Parser
-        #     def mime_types
+        #     def self.mime_types
         #       ["application/xml", "text/xml"]
         #     end
         #   end
-        def mime_types
-          raise NotImplementedError
+        attr_reader :mime_types
+
+        # @api private
+        def initialize(mime_types: DEFAULT_MIME_TYPES)
+          @mime_types = self.class.mime_types + mime_types
         end
 
         # Parse raw HTTP request body
@@ -49,8 +54,8 @@ module Hanami
         #       raise Hanami::Middleware::BodyParser::BodyParsingError.new(exception.message)
         #     end
         #   end
-        def parse(body)
-          raise NotImplementedError
+        def parse(body) # rubocop:disable Lint/UnusedMethodArgument
+          raise NoMethodError
         end
       end
     end

data/lib/hanami/middleware/body_parser.rb

@@ -37,7 +37,7 @@ module Hanami
 
       def initialize(app, parsers)
         @app = app
-        @parsers = build_parsers(parsers)
+        @parsers = parsers
       end
 
       def call(env)
@@ -56,19 +56,6 @@ module Hanami
 
       private
 
-      def build_parsers(parser_names)
-        parser_names = Array(parser_names)
-        return {} if parser_names.empty?
-
-        parser_names.each_with_object({}) do |name, parsers|
-          parser = self.class.for(name)
-
-          parser.mime_types.each do |mime|
-            parsers[mime] = parser
-          end
-        end
-      end
-
       # @api private
       def _symbolize(body)
         if body.is_a?(::Hash)

data/lib/hanami/middleware/node.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Middleware
+    # Trie node to register scopes with custom Rack middleware
+    #
+    # @api private
+    # @since 2.0.0
+    class Node
+      # @api private
+      # @since 2.0.0
+      attr_reader :app
+
+      # @api private
+      # @since 2.0.0
+      def initialize
+        @app = nil
+        @children = {}
+      end
+
+      # @api private
+      # @since 2.0.0
+      def freeze
+        @children.freeze
+        super
+      end
+
+      # @api private
+      # @since 2.0.0
+      def put(segment)
+        @children[segment] ||= self.class.new
+      end
+
+      # @api private
+      # @since 2.0.0
+      def get(segment)
+        @children.fetch(segment) { self if leaf? }
+      end
+
+      # @api private
+      # @since 2.0.0
+      def app!(app)
+        @app = app
+      end
+
+      # @api private
+      # @since 2.0.0
+      def app?
+        !@app.nil?
+      end
+
+      # @api private
+      # @since 2.0.0
+      def leaf?
+        @children.empty?
+      end
+    end
+  end
+end

data/lib/hanami/middleware/trie.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative "./node"
+
+module Hanami
+  module Middleware
+    # Trie to register scopes with custom Rack middleware
+    #
+    # @api private
+    # @since 2.0.0
+    class Trie
+      # @api private
+      # @since 2.0.0
+      def initialize(app)
+        @app = app
+        @root = Node.new
+      end
+
+      # @api private
+      # @since 2.0.0
+      def freeze
+        @root.freeze
+        super
+      end
+
+      # @api private
+      # @since 2.0.0
+      def add(path, app)
+        node = @root
+        for_each_segment(path) do |segment|
+          node = node.put(segment)
+        end
+
+        node.app!(app)
+      end
+
+      # @api private
+      # @since 2.0.0
+      def find(path)
+        node = @root
+
+        for_each_segment(path) do |segment|
+          break unless node
+
+          node = node.get(segment)
+        end
+
+        return node.app if node&.app?
+
+        @root.app || @app
+      end
+
+      # @api private
+      # @since 2.0.0
+      def empty?
+        @root.leaf?
+      end
+
+      private
+
+      # @api private
+      # @since 2.0.0
+      def for_each_segment(path, &blk)
+        _, *segments = path.split(/\//)
+        segments.each(&blk)
+      end
+    end
+  end
+end

data/lib/hanami/router/{error.rb → errors.rb}

@@ -2,63 +2,81 @@
 
 module Hanami
   class Router
-    # Base error
+    # Base class for all Hanami::Router errors.
     #
     # @since 0.5.0
+    # @api public
     class Error < StandardError
     end
 
-    # Missing endpoint error. It's raised when the route definition is missing `to:` endpoint and a block.
+    # Error raised when no endpoint is specified for a route.
+    #
+    # Endpoints must be specified by `to:` or a block.
     #
     # @since 2.0.0
+    # @api public
     class MissingEndpointError < Error
+      # @since 2.0.0
+      # @api private
       def initialize(path)
         super("missing endpoint for #{path.inspect}")
       end
     end
 
-    # Invalid route exception. It's raised when the router cannot recognize a route
+    # Error raised when a named route could not be found.
+    #
+    # @see Hanami::Router#path
+    # @see Hanami::Router#url
     #
     # @since 2.0.0
-    class InvalidRouteException < Error
+    # @api public
+    class MissingRouteError < Error
+      # @since 2.0.0
+      # @api private
       def initialize(name)
-        super("No route could be generated for #{name.inspect} - please check given arguments")
+        super("No route could be found with name #{name.inspect}")
       end
     end
 
-    # Invalid route expansion exception. It's raised when the router recognizes
-    # a route but given variables cannot be expanded into a path/url
-    #
-    # @since 2.0.0
+    # Error raised when variables given for route cannot be expanded into a full path.
     #
     # @see Hanami::Router#path
     # @see Hanami::Router#url
-    class InvalidRouteExpansionException < Error
+    #
+    # @since 2.0.0
+    # @api public
+    class InvalidRouteExpansionError < Error
+      # @since 2.0.0
+      # @api private
       def initialize(name, message)
         super("No route could be generated for `#{name.inspect}': #{message}")
       end
     end
 
-    # Handle unknown HTTP status codes
+    # Error raised when an unknown HTTP status code is given.
+    #
+    # @see Hanami::Router#redirect
     #
     # @since 2.0.0
+    # @api public
     class UnknownHTTPStatusCodeError < Error
+      # @since 2.0.0
+      # @api private
       def initialize(code)
         super("Unknown HTTP status code: #{code.inspect}")
       end
     end
 
-    # This error is raised when <tt>#call</tt> is invoked on a non-routable
-    # recognized route.
-    #
-    # @since 0.5.0
+    # Error raised when a recognized route is called but has no callable endpoint.
     #
     # @see Hanami::Router#recognize
-    # @see Hanami::Router::RecognizedRoute
     # @see Hanami::Router::RecognizedRoute#call
-    # @see Hanami::Router::RecognizedRoute#routable?
+    #
+    # @since 0.5.0
+    # @api public
     class NotRoutableEndpointError < Error
       # @since 0.5.0
+      # @api private
       def initialize(env)
         super %(Cannot find routable endpoint for: #{env[::Rack::REQUEST_METHOD]} #{env[::Rack::PATH_INFO]})
       end

data/lib/hanami/router/inspector.rb

@@ -4,34 +4,40 @@ require "hanami/router/formatter/human_friendly"
 
 module Hanami
   class Router
-    # Routes inspector
+    # Builds a representation of an array of routes according to a given formatter.
     #
-    # Builds a representation of an array of routes according to a given
-    # formatter.
+    # @see Router.new
     #
     # @since 2.0.0
+    # @api private
     class Inspector
       # @param routes [Array<Hanami::Route>]
-      # @param formatter [#call] Takes the routes as an argument and returns
-      #   whatever representation it creates. Defaults to
-      #   {Hanami::Router::Formatter::HumanFriendly}.
+      # @param formatter [#call] routes formatter, taking routes as an argument and returning its
+      #   own representation (typically a string). Defaults to {Formatter::HumanFriendly}.
+      #
       # @since 2.0.0
+      # @api public
       def initialize(routes: [], formatter: Formatter::HumanFriendly.new)
         @routes = routes
         @formatter = formatter
       end
 
-      # @param route [Hash] serialized route
+      # Adds a route to be inspected.
+      #
+      # @param route [Route]
       #
-      # @api private
       # @since 2.0.0
+      # @api public
       def add_route(route)
         @routes.push(route)
       end
 
+      # Calls the formatter for all added routes.
+      #
       # @return [Any] Formatted routes
       #
       # @since 2.0.0
+      # @api public
       def call(...)
         @formatter.call(@routes, ...)
       end

data/lib/hanami/router/recognized_route.rb

@@ -4,10 +4,13 @@ module Hanami
   class Router
     # Represents a result of router path recognition.
     #
-    # @since 0.5.0
-    #
     # @see Hanami::Router#recognize
+    #
+    # @since 0.5.0
+    # @api public
     class RecognizedRoute
+      # @since 0.5.0
+      # @api private
       def initialize(endpoint, env)
         @endpoint = endpoint
         @env = env
@@ -54,12 +57,22 @@ module Hanami
         @env[::Rack::PATH_INFO]
       end
 
+      # Returns the route's path params.
+      #
+      # @return [Hash]
+      #
       # @since 0.7.0
       # @api public
       def params
         @env[Router::PARAMS]
       end
 
+      # Returns the route's endpoint object.
+      #
+      # Returns nil if the route is a {#redirect? redirect}.
+      #
+      # @return [Object, nil]
+      #
       # @since 0.7.0
       # @api public
       def endpoint
@@ -68,18 +81,30 @@ module Hanami
         @endpoint
       end
 
+      # Returns true if the route has an {#endpoint}.
+      #
+      # @return [Boolean]
+      #
       # @since 0.7.0
       # @api public
       def routable?
         !@endpoint.nil?
       end
 
+      # Returns true if the route is a redirect.
+      #
+      # @return [Boolean]
+      #
       # @since 0.7.0
       # @api public
       def redirect?
         @endpoint.is_a?(Redirect)
       end
 
+      # Returns the route's redirect path, if it is a redirect, or nil otherwise.
+      #
+      # @return [String, nil]
+      #
       # @since 0.7.0
       # @api public
       def redirection_path

data/lib/hanami/router/route.rb

@@ -8,25 +8,57 @@ module Hanami
     # A route from the router
     #
     # @since 2.0.0
+    # @api public
     class Route
-      # @api private
       # @since 2.0.0
+      # @api private
       ROUTE_CONSTRAINT_SEPARATOR = ", "
       private_constant :ROUTE_CONSTRAINT_SEPARATOR
 
+      # Returns the route's HTTP method.
+      #
+      # @example
+      #   route.http_method # => "GET"
+      #
+      # @return [String]
+      #
       # @since 2.0.0
+      # @api public
       attr_reader :http_method
 
+      # Returns the route's path.
+      #
+      # @example
+      #   route.path # => "/a/b/c"
+      #
+      # @return [String]
+      #
       # @since 2.0.0
+      # @api public
       attr_reader :path
 
+      # Returns the route's Rack endpoint, as given to `to:` when the route was defined.
+      #
+      # @return [Object]
+      #
       # @since 2.0.0
+      # @api public
       attr_reader :to
 
+      # Returns the route's unique name, as given to `as:` when the route was defined.
+      #
+      # @return [Object]
+      #
       # @since 2.0.0
+      # @api public
       attr_reader :as
 
+      # Returns the route's contraints hash for its path variables.
+      #
+      # @return [Hash]
+      #
       # @since 2.0.0
+      # @api public
       attr_reader :constraints
 
       # @api private
@@ -41,22 +73,48 @@ module Hanami
         freeze
       end
 
+      # Returns true if the route is for the HEAD HTTP method.
+      #
+      # @return [Boolean]
+      #
+      # @see #http_method
+      #
       # @since 2.0.0
+      # @api public
       def head?
         http_method == ::Rack::HEAD
       end
 
+      # Returns true if the route has a name.
+      #
+      # @return [Boolean]
+      #
+      # @see #as
+      #
       # @since 2.0.0
+      # @api public
       def as?
         !as.nil?
       end
 
+      # Returns true if the route has any constraints.
+      #
+      # @return [Boolean]
+      #
+      # @see #constraints
+      #
       # @since 2.0.0
+      # @api public
       def constraints?
         constraints.any?
       end
 
+      # Returns a string containing a human-readable representation of the route's {#to} endpoint.
+      #
+      # @return [String]
+      #
       # @since 2.0.0
+      # @api public
       def inspect_to(value = to)
         case value
         when String
@@ -74,14 +132,26 @@ module Hanami
         end
       end
 
+      # Returns a string containing a human-readable representation of the route's {#constraints}.
+      #
+      # @return [String]
+      #
       # @since 2.0.0
+      # @api public
       def inspect_constraints
         @constraints.map do |key, value|
           "#{key}: #{value.inspect}"
         end.join(ROUTE_CONSTRAINT_SEPARATOR)
       end
 
+      # Returns a string containing a human-readable representation of the route's name.
+      #
+      # @return [String]
+      #
+      # @see #as
+      #
       # @since 2.0.0
+      # @api public
       def inspect_as
         as ? as.inspect : Router::EMPTY_STRING
       end

data/lib/hanami/router/url_helpers.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
 
-require "hanami/router/error"
+require "hanami/router/errors"
 require "mustermann/error"
 
 module Hanami
   class Router
-    # URL Helpers
+    # @since 2.0.0
+    # @api private
     class UrlHelpers
       # @since 2.0.0
       # @api private
@@ -21,17 +22,17 @@ module Hanami
       end
 
       # @since 2.0.0
-      # @api public
+      # @api private
       def path(name, variables = {})
         @named.fetch(name.to_sym) do
-          raise InvalidRouteException.new(name)
+          raise MissingRouteError.new(name)
         end.expand(:append, variables)
       rescue Mustermann::ExpandError => exception
-        raise InvalidRouteExpansionException.new(name, exception.message)
+        raise InvalidRouteExpansionError.new(name, exception.message)
       end
 
       # @since 2.0.0
-      # @api public
+      # @api private
       def url(name, variables = {})
         @base_url + path(name, variables)
       end

data/lib/hanami/router/version.rb

@@ -2,8 +2,11 @@
 
 module Hanami
   class Router
-    # @since 0.1.0
+    # Returns the hanami-router version.
+    #
+    # @return [String]
+    #
     # @api public
-    VERSION = "2.0.0.beta2"
+    VERSION = "2.0.0.rc1"
   end
 end

data/lib/hanami/router.rb

@@ -3,13 +3,14 @@
 require "rack"
 require "rack/utils"
 
+# @see Hanami::Router
 module Hanami
   # Rack compatible, lightweight and fast HTTP Router.
   #
   # @since 0.1.0
   class Router
     require "hanami/router/version"
-    require "hanami/router/error"
+    require "hanami/router/errors"
     require "hanami/router/segment"
     require "hanami/router/redirect"
     require "hanami/router/prefix"
@@ -353,6 +354,8 @@ module Hanami
     # @param as [Symbol] a unique name for the route
     # @param code [Integer] a HTTP status code to use for the redirect
     #
+    # @raise [Hanami::Router::UnknownHTTPStatusCodeError] when an unknown redirect code is given
+    #
     # @since 0.1.0
     #
     # @see #get
@@ -434,7 +437,7 @@ module Hanami
     #
     # @return [String]
     #
-    # @raise [Hanami::Routing::InvalidRouteException] when the router fails to
+    # @raise [Hanami::Router::MissingRouteError] when the router fails to
     #   recognize a route, because of the given arguments.
     #
     # @since 0.1.0
@@ -464,7 +467,7 @@ module Hanami
     #
     # @return [String]
     #
-    # @raise [Hanami::Routing::InvalidRouteException] when the router fails to
+    # @raise [Hanami::Router::MissingRouteError] when the router fails to
     #   recognize a route, because of the given arguments.
     #
     # @since 0.1.0
@@ -596,12 +599,11 @@ module Hanami
     #   route.params    # => {:id=>"1"}
     def recognize(env, params = {}, options = {})
       require "hanami/router/recognized_route"
+
       env = env_for(env, params, options)
       endpoint, params = lookup(env)
 
-      RecognizedRoute.new(
-        endpoint, _params(env, params)
-      )
+      RecognizedRoute.new(endpoint, _params(env, params))
     end
 
     # @since 2.0.0
@@ -686,7 +688,7 @@ module Hanami
         begin
           url = path(env, params)
           return env_for(url, params, options) # rubocop:disable Style/RedundantReturn
-        rescue Hanami::Router::InvalidRouteException
+        rescue Hanami::Router::MissingRouteError
           {} # Empty Rack env
         end
       else
@@ -799,7 +801,10 @@ module Hanami
         add_fixed_route(http_method, path, endpoint)
       end
 
-      add_named_route(path, as, constraints) if as
+      if as
+        as = prefixed_name(as)
+        add_named_route(path, as, constraints)
+      end
 
       if inspect?
         @inspector.add_route(
@@ -843,7 +848,7 @@ module Hanami
     # @since 2.0.0
     # @api private
     def add_named_route(path, as, constraints)
-      @url_helpers.add(prefixed_name(as), Segment.fabricate(path, **constraints))
+      @url_helpers.add(as, Segment.fabricate(path, **constraints))
     end
 
     # @since 2.0.0

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hanami-router
 version: !ruby/object:Gem::Version
-  version: 2.0.0.beta2
+  version: 2.0.0.rc1
 platform: ruby
 authors:
 - Luca Guidi
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-08-16 00:00:00.000000000 Z
+date: 2022-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -153,15 +153,18 @@ files:
 - LICENSE.md
 - README.md
 - hanami-router.gemspec
+- lib/hanami/middleware/app.rb
 - lib/hanami/middleware/body_parser.rb
 - lib/hanami/middleware/body_parser/class_interface.rb
 - lib/hanami/middleware/body_parser/errors.rb
 - lib/hanami/middleware/body_parser/json_parser.rb
 - lib/hanami/middleware/body_parser/parser.rb
 - lib/hanami/middleware/error.rb
+- lib/hanami/middleware/node.rb
+- lib/hanami/middleware/trie.rb
 - lib/hanami/router.rb
 - lib/hanami/router/block.rb
-- lib/hanami/router/error.rb
+- lib/hanami/router/errors.rb
 - lib/hanami/router/formatter/csv.rb
 - lib/hanami/router/formatter/human_friendly.rb
 - lib/hanami/router/inspector.rb
@@ -195,7 +198,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.3.3
 signing_key:
 specification_version: 4
 summary: Rack compatible HTTP router for Ruby and Hanami