ruby_routes 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 02d39aae113654256dae0905438ac98a540854a5d131dea6c4b2b606b51bf4ba
-  data.tar.gz: ba01a85fc21713387e76c183a41e786106f1a053e2485d294895ac36027d94a5
+  metadata.gz: 15debcef313430cfc799afcb9ba0b6f9bd8292226d023d7e854afc608d5ede64
+  data.tar.gz: 1d7c971980a984738c6239cc1727376b74ab61ae824ee054a92f254451574bcf
 SHA512:
-  metadata.gz: c3b230ef35186d4f96714ba708b933cf7897166a74b7162949a3144aa21dc79aab2446a0b14d1e0504ea30f941146a7e0f1841d5908e6a6175d771a9b4a658ad
-  data.tar.gz: 9d476bdbaf46cef516cd51adb218097137863fb12976e98d87a7c8d7f77e3609421d81ba14ed77d67cd59054d4356690d088b619e8e089964cd4fdd6055225ac
+  metadata.gz: 8f272672f91127b65fab8ed4ae2eacfb95fe55310fc4bcd017b5656a0eb475e05255884f19416520ce8b36ec6ff51602561b6f9519befc1f7cf7448bca4ab3f9
+  data.tar.gz: c3cc386c128531ef9bb268bb904c806e1632c3d88609fd3de5077d8143f0fa56a1089ea0915de3bf2e1116c0d0d812402877480d6edc702f8923d3ee3252ef9a

data/README.md

@@ -62,7 +62,6 @@ end
 ```
 
 This creates the following routes:
-
 - `GET /users` → `users#index`
 - `GET /users/new` → `users#new`
 - `POST /users` → `users#create`

data/lib/ruby_routes/node.rb

@@ -14,43 +14,52 @@ module RubyRoutes
       @is_endpoint = false
     end
 
-    # Traverse for a single segment using the matcher registry.
+    # Fast traversal: minimal allocations, streamlined branching
     # Returns [next_node_or_nil, should_break_bool] or [nil, false] if no match.
     def traverse_for(segment, index, segments, params)
-      # Prefer static children first (exact match).
-      if @static_children.key?(segment)
-        return [@static_children[segment], false]
-      end
+      # Static match: O(1) hash lookup
+      child = @static_children[segment]
+      return [child, false] if child
 
-      # Then dynamic param child (single segment)
-      if @dynamic_child
-        next_node = @dynamic_child
-        if params
-          params[next_node.param_name.to_s] = segment
-        end
-        return [next_node, false]
+      # Dynamic match: single segment capture
+      if (dyn = @dynamic_child)
+        params[dyn.param_name] = segment if params
+        return [dyn, false]
       end
 
-      # Then wildcard child (consume remainder)
-      if @wildcard_child
-        next_node = @wildcard_child
+      # Wildcard match: consume remainder (last resort)
+      if (wild = @wildcard_child)
         if params
-          params[next_node.param_name.to_s] = segments[index..-1].join('/')
+          # Build remainder path without intermediate array allocation
+          remainder = segments[index..-1]
+          params[wild.param_name] = remainder.size == 1 ? remainder[0] : remainder.join('/')
         end
-        return [next_node, true]
+        return [wild, true]
       end
 
-      # No match at this node
+      # No match
       [nil, false]
     end
 
+    # Pre-cache param names as strings to avoid repeated .to_s calls
+    def param_name
+      @param_name_str ||= @param_name&.to_s
+    end
+
+    def param_name=(name)
+      @param_name = name
+      @param_name_str = nil  # invalidate cache
+    end
+
+    # Normalize method once and cache string keys
     def add_handler(method, handler)
-      @handlers[method.to_s] = handler
+      method_key = method.to_s.upcase
+      @handlers[method_key] = handler
       @is_endpoint = true
     end
 
     def get_handler(method)
-      @handlers[method.to_s]
+      @handlers[method]  # assume already normalized upstream
     end
   end
 end

data/lib/ruby_routes/radix_tree.rb

@@ -4,12 +4,8 @@ module RubyRoutes
   class RadixTree
     class << self
       # Allow RadixTree.new(path, options...) to act as a convenience factory
-      # returning a Route (this matches test usage where specs call
-      # RadixTree.new('/path', to: 'controller#action')).
-      # Calling RadixTree.new with no arguments returns an actual RadixTree instance.
       def new(*args, &block)
         if args.any?
-          # Delegate to Route initializer when args are provided
           RubyRoutes::Route.new(*args, &block)
         else
           super()
@@ -19,47 +15,85 @@ module RubyRoutes
 
     def initialize
       @root = Node.new
-      @_split_cache = {}           # simple LRU: key -> [value, age]
-      @split_cache_order = []      # track order for eviction
-      @split_cache_max = 1024
+      @split_cache = {}
+      @split_cache_order = []
+      @split_cache_max = 2048      # larger cache for better hit rates
+      @empty_segments = [].freeze  # reuse for root path
     end
 
     def add(path, methods, handler)
       current = @root
-      parse_segments(path).each do |seg|
+      segments = split_path_raw(path)
+
+      segments.each do |raw_seg|
+        seg = RubyRoutes::Segment.for(raw_seg)
         current = seg.ensure_child(current)
         break if seg.wildcard?
       end
 
-      methods.each { |method| current.add_handler(method, handler) }
-    end
-
-    def parse_segments(path)
-      split_path(path).map { |s| RubyRoutes::Segment.for(s) }
+      # Normalize methods once during registration
+      Array(methods).each { |method| current.add_handler(method.to_s.upcase, handler) }
     end
 
     def find(path, method, params_out = nil)
-      segments = split_path(path)
+      # Fast path: root route
+      if path == '/' || path.empty?
+        handler = @root.get_handler(method)
+        if @root.is_endpoint && handler
+          return [handler, params_out || {}]
+        else
+          return [nil, {}]
+        end
+      end
+
+      segments = split_path_cached(path)
       current = @root
       params = params_out || {}
       params.clear if params_out
 
-      segments.each_with_index do |text, idx|
-        next_node, should_break = current.traverse_for(text, idx, segments, params)
+      # Unrolled traversal for common case (1-3 segments)
+      case segments.size
+      when 1
+        next_node, _ = current.traverse_for(segments[0], 0, segments, params)
+        current = next_node
+      when 2
+        next_node, should_break = current.traverse_for(segments[0], 0, segments, params)
+        return [nil, {}] unless next_node
+        current = next_node
+        unless should_break
+          next_node, _ = current.traverse_for(segments[1], 1, segments, params)
+          current = next_node
+        end
+      when 3
+        next_node, should_break = current.traverse_for(segments[0], 0, segments, params)
         return [nil, {}] unless next_node
         current = next_node
-        break if should_break
+        unless should_break
+          next_node, should_break = current.traverse_for(segments[1], 1, segments, params)
+          return [nil, {}] unless next_node
+          current = next_node
+          unless should_break
+            next_node, _ = current.traverse_for(segments[2], 2, segments, params)
+            current = next_node
+          end
+        end
+      else
+        # General case for longer paths
+        segments.each_with_index do |text, idx|
+          next_node, should_break = current.traverse_for(text, idx, segments, params)
+          return [nil, {}] unless next_node
+          current = next_node
+          break if should_break
+        end
       end
 
+      return [nil, {}] unless current
       handler = current.get_handler(method)
       return [nil, {}] unless current.is_endpoint && handler
 
-      # lightweight constraint checks: reject early if route constraints don't match
-      route = handler
-      if route.respond_to?(:constraints) && route.constraints.any?
-        unless constraints_match?(route.constraints, params)
-          return [nil, {}]
-        end
+      # Fast constraint check
+      if handler.respond_to?(:constraints) && !handler.constraints.empty?
+        return [nil, {}] unless constraints_match_fast(handler.constraints, params)
       end
 
       [handler, params]
@@ -67,34 +101,48 @@ module RubyRoutes
 
     private
 
-    # faster, lower-allocation trim + split
-    def split_path(path)
-      @split_cache ||= {}
-      return [''] if path == '/'
+    # Cached path splitting with optimized common cases
+    def split_path_cached(path)
+      return @empty_segments if path == '/' || path.empty?
+
       if (cached = @split_cache[path])
         return cached
       end
 
-      p = path
-      p = p[1..-1] if p.start_with?('/')
-      p = p[0...-1] if p.end_with?('/')
-      segs = p.split('/')
+      result = split_path_raw(path)
 
-      # simple LRU insert
-      @split_cache[path] = segs
+      # Cache with simple LRU eviction
+      @split_cache[path] = result
       @split_cache_order << path
       if @split_cache_order.size > @split_cache_max
         oldest = @split_cache_order.shift
         @split_cache.delete(oldest)
       end
 
-      segs
+      result
+    end
+
+    # Raw path splitting without caching (for registration)
+    def split_path_raw(path)
+      return [] if path == '/' || path.empty?
+
+      # Optimized trimming: avoid string allocations when possible
+      start_idx = path.start_with?('/') ? 1 : 0
+      end_idx = path.end_with?('/') ? -2 : -1
+
+      if start_idx == 0 && end_idx == -1
+        path.split('/')
+      else
+        path[start_idx..end_idx].split('/')
+      end
     end
 
-    # constraints match helper (non-raising, lightweight)
-    def constraints_match?(constraints, params)
+    # Optimized constraint matching with fast paths
+    def constraints_match_fast(constraints, params)
       constraints.each do |param, constraint|
-        value = params[param.to_s] || params[param]
+        # Try both string and symbol keys (common pattern)
+        value = params[param.to_s]
+        value ||= params[param] if param.respond_to?(:to_s)
         next unless value
 
         case constraint
@@ -102,15 +150,16 @@ module RubyRoutes
           return false unless constraint.match?(value)
         when Proc
           return false unless constraint.call(value)
+        when :int
+          # Fast integer check without regex
+          return false unless value.is_a?(String) && value.match?(/\A\d+\z/)
+        when :uuid
+          # Fast UUID check
+          return false unless value.is_a?(String) && value.length == 36 &&
+                             value.match?(/\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i)
         when Symbol
-          case constraint
-          when :int then return false unless value.match?(/^\d+$/)
-          when :uuid then return false unless value.match?(/^[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}$/i)
-          else
-            # unknown symbol constraint — be conservative and allow
-          end
-        else
-          # unknown constraint type — allow (Route will validate later if needed)
+          # Handle other symbolic constraints
+          next  # unknown symbol constraint — allow
         end
       end
       true

data/lib/ruby_routes/route.rb

@@ -7,199 +7,217 @@ module RubyRoutes
 
     def initialize(path, options = {})
       @path = normalize_path(path)
-      @methods = Array(options[:via] || :get).map(&:to_s).map(&:upcase)
+      # Pre-normalize and freeze methods at creation time
+      raw_methods = Array(options[:via] || :get)
+      @methods = raw_methods.map { |m| normalize_method(m) }.freeze
+      @methods_set = @methods.to_set.freeze
       @controller = extract_controller(options)
       @action = options[:action] || extract_action(options[:to])
       @name = options[:as]
       @constraints = options[:constraints] || {}
-      # pre-normalize defaults to string keys to avoid per-request transform_keys
-      @defaults = (options[:defaults] || {}).transform_keys(&:to_s)
+      # Pre-normalize defaults to string keys and freeze
+      @defaults = (options[:defaults] || {}).transform_keys(&:to_s).freeze
 
+      # Pre-compile everything at initialization
+      precompile_route_data
       validate_route!
     end
 
     def match?(request_method, request_path)
-      return false unless methods.include?(request_method.to_s.upcase)
-      !!extract_path_params(request_path)
+      # Fast method check: use frozen Set for O(1) lookup
+      return false unless @methods_set.include?(request_method.to_s.upcase)
+      !!extract_path_params_fast(request_path)
     end
 
     def extract_params(request_path, parsed_qp = nil)
-      path_params = extract_path_params(request_path)
-      return {} unless path_params
+      path_params = extract_path_params_fast(request_path)
+      return EMPTY_HASH unless path_params
 
-      # Reuse a thread-local hash to reduce allocations; return a dup to callers.
-      tmp = Thread.current[:ruby_routes_params] ||= {}
-      tmp.clear
-
-      # start with path params (they take precedence)
-      path_params.each { |k, v| tmp[k] = v }
-
-      # use provided parsed_qp if available, otherwise parse lazily only if needed
-      qp = parsed_qp
-      if qp.nil? && request_path.include?('?')
-        qp = query_params(request_path)
-      end
-      qp.each { |k, v| tmp[k] = v } if qp && !qp.empty?
-
-      # only set defaults for keys not already present
-      defaults.each { |k, v| tmp[k] = v unless tmp.key?(k) } if defaults
-
-      validate_constraints!(tmp)
-      tmp.dup
+      # Use optimized param building
+      build_params_hash(path_params, request_path, parsed_qp)
     end
 
     def named?
-      !name.nil?
+      !@name.nil?
     end
 
     def resource?
-      path.match?(/\/:id$/) || path.match?(/\/:id\./)
+      @is_resource
     end
 
     def collection?
-      !resource?
+      !@is_resource
     end
 
     def parse_query_params(path)
-      query_params(path)
+      query_params_fast(path)
     end
 
-    # Fast path generator: uses precompiled token list and a small LRU.
-    # Avoids unbounded cache growth and skips URI-encoding for safe values.
+    # Optimized path generation with better caching and fewer allocations
     def generate_path(params = {})
-      return '/' if path == '/'
+      return ROOT_PATH if @path == ROOT_PATH
 
-      # build merged for only relevant param names, reusing a thread-local hash
-      tmp = Thread.current[:ruby_routes_merged] ||= {}
-      tmp.clear
-      defaults.each { |k, v| tmp[k] = v } if defaults
-      params.each { |k, v| tmp[k.to_s] = v } if params
-      merged = tmp
+      # Fast path: empty params and no required params
+      if params.empty? && @required_params.empty?
+        return @static_path if @static_path
+      end
 
-      missing = compiled_required_params - merged.keys
-      raise RubyRoutes::RouteNotFound, "Missing params: #{missing.join(', ')}" unless missing.empty?
+      # Build merged params efficiently
+      merged = build_merged_params(params)
 
-      @gen_cache ||= SmallLru.new(256)
-      cache_key = cache_key_for(merged)
-      if (cached = @gen_cache.get(cache_key))
-        return cached
+      # Check required params (fast Set operation)
+      missing_params = @required_params_set - merged.keys
+      unless missing_params.empty?
+        raise RubyRoutes::RouteNotFound, "Missing params: #{missing_params.to_a.join(', ')}"
       end
 
-      parts = compiled_segments.map do |seg|
-        case seg[:type]
-        when :static
-          seg[:value]
-        when :param
-          v = merged.fetch(seg[:name]).to_s
-          safe_encode_segment(v)
-        when :splat
-          v = merged.fetch(seg[:name], '')
-          arr = v.is_a?(Array) ? v : v.to_s.split('/')
-          arr.map { |p| safe_encode_segment(p.to_s) }.join('/')
-        end
+      # Cache lookup
+      cache_key = build_cache_key_fast(merged)
+      if (cached = @gen_cache.get(cache_key))
+        return cached
       end
 
-      out = '/' + parts.join('/')
-      out = '/' if out == ''
+      # Generate path using string buffer (avoid array allocations)
+      path_str = generate_path_string(merged)
+      @gen_cache.set(cache_key, path_str)
+      path_str
+    end
 
-      @gen_cache.set(cache_key, out)
-      out
+    # Fast query params method (cached and optimized)
+    def query_params(request_path)
+      query_params_fast(request_path)
     end
 
     private
 
-    # compile helpers (memoize)
-    def compiled_segments
-      @compiled_segments ||= begin
-        if path == '/'
-          []
-        else
-          path.split('/').reject(&:empty?).map do |seg|
-            RubyRoutes::Constant.segment_descriptor(seg)
-          end
-        end
-      end
+    # Constants for performance
+    EMPTY_HASH = {}.freeze
+    ROOT_PATH = '/'.freeze
+    UNRESERVED_RE = /\A[a-zA-Z0-9\-._~]+\z/.freeze
+    QUERY_CACHE_SIZE = 128
+
+    # Fast method normalization
+    def normalize_method(method)
+      case method
+      when :get then 'GET'
+      when :post then 'POST'
+      when :put then 'PUT'
+      when :patch then 'PATCH'
+      when :delete then 'DELETE'
+      when :head then 'HEAD'
+      when :options then 'OPTIONS'
+      else method.to_s.upcase
+      end.freeze
     end
 
-    def compiled_required_params
-      @compiled_required_params ||= compiled_segments.select { |s| s[:type] != :static }
-                                                  .map { |s| s[:name] }.uniq
-                                                  .reject { |n| defaults.to_s.include?(n) }
-    end
-
-    # Cache key: deterministic param-order key (fast, stable)
-    def cache_key_for(merged)
-      # build key in route token order (parameters & splat) to avoid sorting/inspect
-      names = compiled_param_names
-      # build with single string buffer to avoid temporary arrays
-      buf = +""
-      names.each_with_index do |n, i|
-        val = merged[n]
-        part = if val.nil?
-                 ''
-               elsif val.is_a?(Array)
-                 val.map!(&:to_s) && val.join('/')
-               else
-                 val.to_s
-               end
-        buf << '|' unless i.zero?
-        buf << part
-      end
-      buf
+    # Pre-compile all route data at initialization
+    def precompile_route_data
+      @is_resource = @path.match?(/\/:id(?:$|\.)/)
+      @gen_cache = SmallLru.new(512)  # larger cache
+      @query_cache = SmallLru.new(QUERY_CACHE_SIZE)
+
+      compile_segments
+      compile_required_params
+      check_static_path
     end
 
-    def compiled_param_names
-      @compiled_param_names ||= compiled_segments.map { |s| s[:name] if s[:type] != :static }.compact
+    def compile_segments
+      @compiled_segments = if @path == ROOT_PATH
+                             EMPTY_ARRAY
+                           else
+                             @path.split('/').reject(&:empty?).map do |seg|
+                               RubyRoutes::Constant.segment_descriptor(seg)
+                             end.freeze
+                           end
     end
 
-    # Only URI-encode a segment when it contains unsafe chars.
-    UNRESERVED_RE = /\A[a-zA-Z0-9\-._~]+\z/
-    def safe_encode_segment(str)
-      # leave slash handling to splat logic (splats already split)
-      return str if UNRESERVED_RE.match?(str)
-      URI.encode_www_form_component(str)
+    def compile_required_params
+      param_names = @compiled_segments.filter_map { |s| s[:name] if s[:type] != :static }
+      @param_names = param_names.freeze
+      @required_params = param_names.reject { |n| @defaults.key?(n) }.freeze
+      @required_params_set = @required_params.to_set.freeze
     end
 
-    def normalize_path(path)
-      p = path.to_s
-      p = "/#{p}" unless p.start_with?('/')
-      p = p.chomp('/') unless p == '/'
-      p
+    def check_static_path
+      # Pre-generate static paths (no params)
+      if @required_params.empty?
+        @static_path = generate_static_path
+      end
     end
 
-    def extract_controller(options)
-      if options[:to]
-        options[:to].to_s.split('#').first
-      else
-        options[:controller]
+    def generate_static_path
+      return ROOT_PATH if @compiled_segments.empty?
+
+      parts = @compiled_segments.map { |seg| seg[:value] }
+      "/#{parts.join('/')}"
+    end
+
+    # Optimized param building
+    def build_params_hash(path_params, request_path, parsed_qp)
+      # Use pre-allocated hash when possible
+      result = get_thread_local_hash
+
+      # Path params first (highest priority)
+      result.update(path_params)
+
+      # Query params (if needed)
+      if parsed_qp
+        result.merge!(parsed_qp)
+      elsif request_path.include?('?')
+        qp = query_params_fast(request_path)
+        result.merge!(qp) unless qp.empty?
       end
+
+      # Defaults (lowest priority)
+      merge_defaults_fast(result) unless @defaults.empty?
+
+      # Validate constraints efficiently
+      validate_constraints_fast!(result) unless @constraints.empty?
+
+      result.dup
     end
 
-    def extract_action(to)
-      return nil unless to
-      to.to_s.split('#').last
+    def get_thread_local_hash
+      hash = Thread.current[:ruby_routes_params] ||= {}
+      hash.clear
+      hash
+    end
+
+    def merge_defaults_fast(result)
+      @defaults.each { |k, v| result[k] = v unless result.key?(k) }
     end
 
-    def extract_path_params(request_path)
-      segs = compiled_segments # memoized compiled route tokens
-      return nil if segs.empty? && request_path != '/'
+    # Fast path parameter extraction
+    def extract_path_params_fast(request_path)
+      return EMPTY_HASH if @compiled_segments.empty? && request_path == ROOT_PATH
+      return nil if @compiled_segments.empty?
 
-      req = request_path
-      req = req[1..-1] if req.start_with?('/')
-      req = req[0...-1] if req.end_with?('/') && req != '/'
-      request_parts = req == '' ? [] : req.split('/')
+      # Fast path normalization
+      path_parts = split_path_fast(request_path)
+      return nil if @compiled_segments.size != path_parts.size
 
-      return nil if segs.size != request_parts.size
+      extract_params_from_parts(path_parts)
+    end
+
+    def split_path_fast(request_path)
+      # Optimized path splitting
+      path = request_path
+      path = path[1..-1] if path.start_with?('/')
+      path = path[0...-1] if path.end_with?('/') && path != ROOT_PATH
+      path.empty? ? [] : path.split('/')
+    end
 
+    def extract_params_from_parts(path_parts)
       params = {}
-      segs.each_with_index do |seg, idx|
+
+      @compiled_segments.each_with_index do |seg, idx|
         case seg[:type]
         when :static
-          return nil unless seg[:value] == request_parts[idx]
+          return nil unless seg[:value] == path_parts[idx]
         when :param
-          params[seg[:name]] = request_parts[idx]
+          params[seg[:name]] = path_parts[idx]
         when :splat
-          params[seg[:name]] = request_parts[idx..-1].join('/')
+          params[seg[:name]] = path_parts[idx..-1].join('/')
           break
         end
       end
@@ -207,15 +225,128 @@ module RubyRoutes
       params
     end
 
-    def query_params(path)
-      qidx = path.index('?')
-      return {} unless qidx
-      qs = path[(qidx + 1)..-1] || ''
-      Rack::Utils.parse_query(qs)
+    # Optimized merged params building
+    def build_merged_params(params)
+      return @defaults if params.empty?
+
+      merged = get_thread_local_merged_hash
+      merged.update(@defaults) unless @defaults.empty?
+
+      # Convert param keys to strings efficiently
+      params.each { |k, v| merged[k.to_s] = v }
+      merged
+    end
+
+    def get_thread_local_merged_hash
+      hash = Thread.current[:ruby_routes_merged] ||= {}
+      hash.clear
+      hash
     end
 
-    def validate_constraints!(params)
-      constraints.each do |param, constraint|
+    # Fast cache key building with minimal allocations
+    def build_cache_key_fast(merged)
+      # Use instance variable buffer to avoid repeated allocations
+      @cache_key_buffer ||= String.new(capacity: 128)
+      @cache_key_buffer.clear
+
+      return @cache_key_buffer.dup if @required_params.empty?
+
+      @required_params.each_with_index do |name, idx|
+        @cache_key_buffer << '|' unless idx.zero?
+        value = merged[name]
+        @cache_key_buffer << (value.is_a?(Array) ? value.join('/') : value.to_s) if value
+      end
+      @cache_key_buffer.dup
+    end
+
+    # Optimized path generation
+    def generate_path_string(merged)
+      return ROOT_PATH if @compiled_segments.empty?
+
+      buffer = String.new(capacity: 128)
+      buffer << '/'
+
+      @compiled_segments.each_with_index do |seg, idx|
+        buffer << '/' unless idx.zero?
+
+        case seg[:type]
+        when :static
+          buffer << seg[:value]
+        when :param
+          value = merged.fetch(seg[:name]).to_s
+          buffer << encode_segment_fast(value)
+        when :splat
+          value = merged.fetch(seg[:name], '')
+          append_splat_value(buffer, value)
+        end
+      end
+
+      buffer == '/' ? ROOT_PATH : buffer
+    end
+
+    def append_splat_value(buffer, value)
+      case value
+      when Array
+        value.each_with_index do |part, idx|
+          buffer << '/' unless idx.zero?
+          buffer << encode_segment_fast(part.to_s)
+        end
+      when String
+        parts = value.split('/')
+        parts.each_with_index do |part, idx|
+          buffer << '/' unless idx.zero?
+          buffer << encode_segment_fast(part)
+        end
+      else
+        buffer << encode_segment_fast(value.to_s)
+      end
+    end
+
+    # Fast segment encoding
+    def encode_segment_fast(str)
+      return str if UNRESERVED_RE.match?(str)
+      URI.encode_www_form_component(str)
+    end
+
+    # Optimized query params with caching
+    def query_params_fast(path)
+      query_start = path.index('?')
+      return EMPTY_HASH unless query_start
+
+      query_string = path[(query_start + 1)..-1]
+      return EMPTY_HASH if query_string.empty?
+
+      # Cache query param parsing
+      if (cached = @query_cache.get(query_string))
+        return cached
+      end
+
+      result = Rack::Utils.parse_query(query_string)
+      @query_cache.set(query_string, result)
+      result
+    end
+
+    def normalize_path(path)
+      path_str = path.to_s
+      path_str = "/#{path_str}" unless path_str.start_with?('/')
+      path_str = path_str.chomp('/') unless path_str == ROOT_PATH
+      path_str
+    end
+
+    def extract_controller(options)
+      to = options[:to]
+      return options[:controller] unless to
+      to.to_s.split('#', 2).first
+    end
+
+    def extract_action(to)
+      return nil unless to
+      to.to_s.split('#', 2).last
+    end
+
+    # Optimized constraint validation
+    def validate_constraints_fast!(params)
+      @constraints.each do |param, constraint|
         value = params[param.to_s]
         next unless value
 
@@ -224,19 +355,23 @@ module RubyRoutes
           raise ConstraintViolation unless constraint.match?(value)
         when Proc
           raise ConstraintViolation unless constraint.call(value)
-        when Symbol
-          case constraint
-          when :int then raise ConstraintViolation unless value.match?(/^\d+$/)
-          when :uuid then raise ConstraintViolation unless value.match?(/^[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}$/i)
-          end
+        when :int
+          raise ConstraintViolation unless value.match?(/\A\d+\z/)
+        when :uuid
+          raise ConstraintViolation unless value.length == 36 &&
+                 value.match?(/\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i)
         end
       end
     end
 
     def validate_route!
-      raise InvalidRoute, "Controller is required" if controller.nil?
-      raise InvalidRoute, "Action is required" if action.nil?
-      raise InvalidRoute, "Invalid HTTP method: #{methods}" if methods.empty?
+      raise InvalidRoute, "Controller is required" if @controller.nil?
+      raise InvalidRoute, "Action is required" if @action.nil?
+      raise InvalidRoute, "Invalid HTTP method: #{@methods}" if @methods.empty?
     end
+
+    # Additional constants
+    EMPTY_ARRAY = [].freeze
+    EMPTY_STRING = ''.freeze
   end
-end
+ end

data/lib/ruby_routes/route_set.rb

@@ -5,68 +5,80 @@ module RubyRoutes
     def initialize
       @tree = RubyRoutes::RadixTree.new
       @named_routes = {}
-      @routes = []                  # keep list for specs / iteration / size
-      @recognition_cache = {}       # simple bounded cache: key -> [route, params]
-      @recognition_cache_order = []
-      @recognition_cache_max = 4096
+      @routes = []
+      # Optimized recognition cache with better data structures
+      @recognition_cache = {}
+      @cache_hits = 0
+      @cache_misses = 0
+      @recognition_cache_max = 8192  # larger for better hit rates
     end
 
     def add_route(route)
       @routes << route
       @tree.add(route.path, route.methods, route)
       @named_routes[route.name] = route if route.named?
+      # Clear recognition cache when routes change
+      @recognition_cache.clear if @recognition_cache.size > 100
       route
     end
 
     def find_route(request_method, request_path)
-      # Return the Route object (or nil) to match spec expectations.
-      handler, _params = @tree.find(request_path, request_method.to_s.upcase)
+      # Optimized: avoid repeated string allocation
+      method_up = request_method.to_s.upcase
+      handler, _params = @tree.find(request_path, method_up)
       handler
     end
 
     def find_named_route(name)
-      @named_routes[name] or raise RouteNotFound, "No route named '#{name}'"
+      route = @named_routes[name]
+      return route if route
+      raise RouteNotFound, "No route named '#{name}'"
     end
 
     def match(request_method, request_path)
-      # Normalize method once and attempt recognition cache hit
-      method_up = request_method.to_s.upcase
-      cache_key = "#{method_up}:#{request_path}"
+      # Fast path: normalize method once
+      method_up = method_lookup(request_method)
+
+      # Optimized cache key: avoid string interpolation when possible
+      cache_key = build_cache_key(method_up, request_path)
+
+      # Cache hit: return immediately
       if (cached = @recognition_cache[cache_key])
-        # Return cached params (frozen) directly to avoid heavy dup allocations.
+        @cache_hits += 1
         cached_route, cached_params = cached
-        return { route: cached_route, params: cached_params, controller: cached_route.controller, action: cached_route.action }
+        return {
+          route: cached_route,
+          params: cached_params,
+          controller: cached_route.controller,
+          action: cached_route.action
+        }
       end
 
-      # Use a thread-local hash as output for RadixTree to avoid allocating a params Hash
-      tmp = Thread.current[:ruby_routes_params] ||= {}
-      handler, _ = @tree.find(request_path, method_up, tmp)
+      @cache_misses += 1
+
+      # Use thread-local params to avoid allocations
+      params = get_thread_local_params
+      handler, _ = @tree.find(request_path, method_up, params)
       return nil unless handler
+
       route = handler
 
-      # tmp now contains path params (filled by RadixTree). Merge defaults and query params in-place.
-      # defaults first (only set missing keys)
-      if route.defaults
-        route.defaults.each { |k, v| tmp[k] = v unless tmp.key?(k) }
-      end
+      # Fast path: merge defaults only if they exist
+      merge_defaults(route, params) if route.defaults && !route.defaults.empty?
+
+      # Fast path: parse query params only if needed
       if request_path.include?('?')
-        qp = route.parse_query_params(request_path)
-        qp.each { |k, v| tmp[k] = v } unless qp.empty?
+        merge_query_params(route, request_path, params)
       end
 
-      params = tmp.dup
-
-      # insert into bounded recognition cache (store frozen params to reduce accidental mutation)
-      @recognition_cache[cache_key] = [route, params.freeze]
-      @recognition_cache_order << cache_key
-      if @recognition_cache_order.size > @recognition_cache_max
-        oldest = @recognition_cache_order.shift
-        @recognition_cache.delete(oldest)
-      end
+      # Create return hash and cache entry
+      result_params = params.dup
+      cache_entry = [route, result_params.freeze]
+      insert_cache_entry(cache_key, cache_entry)
 
       {
         route: route,
-        params: params,
+        params: result_params,
         controller: route.controller,
         action: route.action
       }
@@ -77,35 +89,119 @@ module RubyRoutes
     end
 
     def generate_path(name, params = {})
-      route = find_named_route(name)
-      generate_path_from_route(route, params)
+      route = @named_routes[name]
+      if route
+        route.generate_path(params)
+      else
+        raise RouteNotFound, "No route named '#{name}'"
+      end
     end
 
     def generate_path_from_route(route, params = {})
-      # Delegate to Route#generate_path which uses precompiled segments + cache
       route.generate_path(params)
     end
 
     def clear!
       @routes.clear
       @named_routes.clear
+      @recognition_cache.clear
       @tree = RadixTree.new
+      @cache_hits = @cache_misses = 0
     end
 
     def size
       @routes.size
     end
+    alias_method :length, :size
 
     def empty?
       @routes.empty?
     end
 
     def each(&block)
+      return enum_for(:each) unless block_given?
       @routes.each(&block)
     end
 
     def include?(route)
       @routes.include?(route)
     end
+
+    # Performance monitoring
+    def cache_stats
+      total = @cache_hits + @cache_misses
+      hit_rate = total > 0 ? (@cache_hits.to_f / total * 100).round(2) : 0
+      {
+        hits: @cache_hits,
+        misses: @cache_misses,
+        hit_rate: "#{hit_rate}%",
+        size: @recognition_cache.size
+      }
+    end
+
+    private
+
+    # Method lookup table to avoid repeated upcasing
+    def method_lookup(method)
+      @method_cache ||= Hash.new { |h, k| h[k] = k.to_s.upcase.freeze }
+      @method_cache[method]
+    end
+
+    # Optimized cache key building - avoid string interpolation
+    def build_cache_key(method, path)
+      # Use frozen string concatenation to avoid allocations
+      @cache_key_buffer ||= String.new(capacity: 256)
+      @cache_key_buffer.clear
+      @cache_key_buffer << method << ':' << path
+      @cache_key_buffer.dup.freeze
+    end
+
+    # Get thread-local params hash, reusing when possible
+    def get_thread_local_params
+      # Use object pool to reduce GC pressure
+      @params_pool ||= []
+      if @params_pool.empty?
+        {}
+      else
+        hash = @params_pool.pop
+        hash.clear
+        hash
+      end
+    end
+
+    def return_params_to_pool(params)
+      @params_pool ||= []
+      @params_pool.push(params) if @params_pool.size < 10
+    end
+
+    # Fast defaults merging
+    def merge_defaults(route, params)
+      route.defaults.each do |key, value|
+        params[key] = value unless params.key?(key)
+      end
+    end
+
+    # Fast query params merging
+    def merge_query_params(route, request_path, params)
+      if route.respond_to?(:parse_query_params)
+        qp = route.parse_query_params(request_path)
+        params.merge!(qp) unless qp.empty?
+      elsif route.respond_to?(:query_params)
+        qp = route.query_params(request_path)
+        params.merge!(qp) unless qp.empty?
+      end
+    end
+
+    # Efficient cache insertion with LRU eviction
+    def insert_cache_entry(cache_key, cache_entry)
+      @recognition_cache[cache_key] = cache_entry
+
+      # Simple eviction: clear cache when it gets too large
+      if @recognition_cache.size > @recognition_cache_max
+        # Keep most recently used half
+        keys_to_delete = @recognition_cache.keys[0...(@recognition_cache_max / 2)]
+        keys_to_delete.each { |k| @recognition_cache.delete(k) }
+      end
+    end
   end
 end

data/lib/ruby_routes/version.rb

@@ -1,3 +1,3 @@
 module RubyRoutes
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_routes
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Yosef Benny Widyokarsono