Remove Mustermann leaf matcher to improve performance

lib/hanami/middleware/node.rb

@@ -80,7 +80,7 @@ def leaf?
       # @api private
       # @since 2.0.3
       def variable?(segment)
-        Router::ROUTE_VARIABLE_MATCHER.match?(segment)
+        segment.include?(Router::ROUTE_VARIABLE_INDICATOR)
       end
 
       # @api private

lib/hanami/router.rb

@@ -745,13 +745,21 @@ def env_for(env, params = {}, options = {})
     # @api private
     PARAMS = "router.params"
 
-    # @since 2.0.0
+    # @since 2.2.1
     # @api private
-    ROUTE_VARIABLE_MATCHER = /:/
+    ROUTE_OPTIONAL_INDICATOR = "("
 
-    # @since 2.0.0
+    # @since 2.2.1
+    # @api private
+    ROUTE_VARIABLE_INDICATOR = ":"
+
+    # @since 2.2.1
+    # @api private
+    ROUTE_GLOBBED_INDICATOR = "*"
+
+    # @since 2.2.1
     # @api private
-    ROUTE_GLOBBED_MATCHER = /\*/
+    ROUTE_INNER_PARENTHESES_MATCHER = /\(([^()]*)\)/
 
     # Default response when the route method was not allowed
     #
@@ -793,6 +801,8 @@ def add_route(http_method, path, to, as, constraints, &blk)
 
       if globbed?(path)
         add_globbed_route(http_method, path, endpoint, constraints)
+      elsif optional?(path)
+        add_optional_routes(http_method, path, to, constraints, &blk)
       elsif variable?(path)
         add_variable_route(http_method, path, endpoint, constraints)
       else
@@ -848,16 +858,51 @@ def add_named_route(path, as, constraints)
       @url_helpers.add(as, Segment.fabricate(path, **constraints))
     end
 
+    # @since 2.2.1
+    # @api private
+    def add_optional_routes(http_method, path, to, constraints, &blk)
+      as = nil # avoid creating named routes for all optional permutations
+      optional_paths = [path]
+      derived_paths = []
+
+      optional_paths.each do |optional_path|
+        match_data = ROUTE_INNER_PARENTHESES_MATCHER.match(optional_path)
+
+        if match_data.nil?
+          raise InvalidRouteDefinitionError.new(http_method, path, "unmatched parenthesis in route")
+        end
+
+        [
+          +EMPTY_STRING << match_data.pre_match << match_data[1] << match_data.post_match,
+          +EMPTY_STRING << match_data.pre_match << match_data.post_match
+        ].each do |new_path|
+          if optional?(new_path)
+            optional_paths << new_path
+          else
+            derived_paths << new_path
+          end
+        end
+      end
+
+      derived_paths.each { |derived| add_route(http_method, derived, to, as, constraints, &blk) }
+    end
+
     # @since 2.0.0
     # @api private
     def variable?(path)
-      ROUTE_VARIABLE_MATCHER.match?(path)
+      path.include?(ROUTE_VARIABLE_INDICATOR)
+    end
+
+    # @since 2.2.1
+    # @api private
+    def optional?(path)
+      path.include?(ROUTE_OPTIONAL_INDICATOR)
     end
 
     # @since 2.0.0
     # @api private
     def globbed?(path)
-      ROUTE_GLOBBED_MATCHER.match?(path)
+      path.include?(ROUTE_GLOBBED_INDICATOR)
     end
 
     # @since 2.0.0

lib/hanami/router/errors.rb

@@ -38,6 +38,21 @@ def initialize(name)
       end
     end
 
+    # Error raised when a route definition is invalid
+    #
+    # @see Hanami::Router#path
+    # @see Hanami::Router#url
+    #
+    # @since 2.2.1
+    # @api public
+    class InvalidRouteDefinitionError < Error
+      # @since 2.2.1
+      # @api private
+      def initialize(http_method, path, message)
+        super("Invalid route definition '#{http_method.downcase} #{path}': #{message}")
+      end
+    end
+
     # Error raised when variables given for route cannot be expanded into a full path.
     #
     # @see Hanami::Router#path

lib/hanami/router/leaf.rb

@@ -13,29 +13,29 @@ class Leaf
 
       # @api private
       # @since 2.2.0
-      def initialize(route, to, constraints)
-        @route = route
+      def initialize(param_keys, to, constraints)
+        @param_keys = param_keys.map { |key| key.delete_prefix(":") }.freeze
         @to = to
         @constraints = constraints
         @params = nil
       end
 
       # @api private
       # @since 2.2.0
-      def match(path)
-        match = matcher.match(path)
+      def match(param_values)
+        @params = @param_keys.zip(param_values).to_h
 
-        @params = match.named_captures if match
+        return true if @constraints.empty?
 
-        match
-      end
+        @constraints.all? do |key, constraint|
+          param_value = @params[key.to_s]
 
-      private
+          next true if param_value.nil? # ignore constraints on nonexistent keys
 
-      # @api private
-      # @since 2.2.0
-      def matcher
-        @matcher ||= Mustermann.new(@route, type: :rails, version: "5.0", capture: @constraints)
+          match = constraint.match(param_value)
+
+          match && (match.string == match[0])
+        end
       end
     end
   end

lib/hanami/router/node.rb

@@ -9,10 +9,6 @@ class Router
     # @api private
     # @since 2.0.0
     class Node
-      # @api private
-      # @since 2.0.0
-      attr_reader :to
-
       # @api private
       # @since 2.0.0
       def initialize
@@ -23,8 +19,9 @@ def initialize
 
       # @api private
       # @since 2.0.0
-      def put(segment)
+      def put(segment, param_keys)
         if variable?(segment)
+          param_keys << segment
           @variable ||= self.class.new
         else
           @fixed ||= {}
@@ -34,29 +31,34 @@ def put(segment)
 
       # @api private
       # @since 2.0.0
-      def get(segment)
-        @fixed&.fetch(segment, nil) || @variable
+      def get(segment, param_values)
+        fixed = @fixed&.fetch(segment, nil)
+        return fixed if fixed
+
+        param_values << segment
+
+        @variable
       end
 
       # @api private
       # @since 2.0.0
-      def leaf!(route, to, constraints)
+      def leaf!(param_keys, to, constraints)
         @leaves ||= []
-        @leaves << Leaf.new(route, to, constraints)
+        @leaves << Leaf.new(param_keys, to, constraints)
       end
 
       # @api private
       # @since 2.2.0
-      def match(path)
-        @leaves&.find { |leaf| leaf.match(path) }
+      def match(param_values)
+        @leaves&.find { |leaf| leaf.match(param_values) }
       end
 
       private
 
       # @api private
       # @since 2.0.0
       def variable?(segment)
-        Router::ROUTE_VARIABLE_MATCHER.match?(segment)
+        segment.include?(Router::ROUTE_VARIABLE_INDICATOR)
       end
     end
   end

lib/hanami/router/trie.rb

@@ -22,32 +22,34 @@ def initialize
       # @api private
       # @since 2.0.0
       def add(route, to, constraints)
-        segments = segments_from(route)
+        # segments = segments_from(route)
+        param_keys = []
         node = @root
 
-        segments.each do |segment|
-          node = node.put(segment)
+        segments_from(route).each do |segment|
+          node = node.put(segment, param_keys)
         end
 
-        node.leaf!(route, to, constraints)
+        node.leaf!(param_keys, to, constraints)
       end
 
       # @api private
       # @since 2.0.0
       def find(path)
-        segments = segments_from(path)
+        # segments = segments_from(path)
+        param_values = []
         node = @root
 
-        return unless segments.all? { |segment| node = node.get(segment) }
+        return unless segments_from(path).all? { |segment| node = node.get(segment, param_values) }
 
-        node.match(path)&.then { |found| [found.to, found.params] }
+        node.match(param_values)&.then { |found| [found.to, found.params] }
       end
 
       private
 
       # @api private
       # @since 2.0.0
-      SEGMENT_SEPARATOR = /\//
+      SEGMENT_SEPARATOR = "/"
       private_constant :SEGMENT_SEPARATOR
 
       # @api private

spec/integration/hanami/router/generation_spec.rb

@@ -148,7 +148,7 @@
         end
       end
 
-      xit "generates relative and absolute URLs" do
+      it "generates relative and absolute URLs" do
         runner.run!([
           [:a, "/foo/bar", {var1: "foo", var2: "bar"}],
           [:a, "/foo", {var1: "foo"}]
@@ -177,7 +177,7 @@
         end
       end
 
-      xit "generates relative and absolute URLs" do
+      it "generates relative and absolute URLs" do
         runner.run!([
           [:a, "/var/fooz/baz", {var1: "var", var2: "fooz", var3: "baz"}],
           [:a, "/var/fooz", {var1: "var", var2: "fooz"}],