ruby_routes 0.2.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2bc2a63fd1cf72287ce09440410f609579ef5a3cdb4a33513187599dcb5b9ed7
-  data.tar.gz: 560ab2b883aeb3e42f74ef20fd675e3a692173724a78451bd5739115803944cf
+  metadata.gz: 15debcef313430cfc799afcb9ba0b6f9bd8292226d023d7e854afc608d5ede64
+  data.tar.gz: 1d7c971980a984738c6239cc1727376b74ab61ae824ee054a92f254451574bcf
 SHA512:
-  metadata.gz: dc41f27e4af178dd3a76dbed95f8a2df9aed4a041d3af184b76ccb39480a9b7d7facab6e2e30147926a3ca178d6e45b391c942eb9cb6fbdfd2167c794ef7d573
-  data.tar.gz: eafd4d678f45780a7da280e8e91cfddb7f0abe21cadb248fc5f6517e3632c442d7602363b89685baacdff106588a88c1b62c0180670db681af4b7539cd66c1c2
+  metadata.gz: 8f272672f91127b65fab8ed4ae2eacfb95fe55310fc4bcd017b5656a0eb475e05255884f19416520ce8b36ec6ff51602561b6f9519befc1f7cf7448bca4ab3f9
+  data.tar.gz: c3cc386c128531ef9bb268bb904c806e1632c3d88609fd3de5077d8143f0fa56a1089ea0915de3bf2e1116c0d0d812402877480d6edc702f8923d3ee3252ef9a

data/lib/ruby_routes/constant.rb

@@ -0,0 +1,57 @@
+require_relative 'segments/dynamic_segment'
+require_relative 'segments/static_segment'
+require_relative 'segments/wildcard_segment'
+require_relative 'lru_strategies/hit_strategy'
+require_relative 'lru_strategies/miss_strategy'
+
+module RubyRoutes
+  module Constant
+    SEGMENTS = {
+      42 => RubyRoutes::Segments::WildcardSegment,   # '*'
+      58 => RubyRoutes::Segments::DynamicSegment,    # ':'
+      :default => RubyRoutes::Segments::StaticSegment
+    }.freeze
+
+    SEGMENT_MATCHERS = {
+      static: lambda do |node, segment, _idx, _segments, _params|
+        child = node.static_children[segment]
+        child ? [child, false] : nil
+      end,
+
+      dynamic: lambda do |node, segment, _idx, _segments, params|
+        return nil unless node.dynamic_child
+        nxt = node.dynamic_child
+        params[nxt.param_name.to_s] = segment if params && nxt.param_name
+        [nxt, false]
+      end,
+
+      wildcard: lambda do |node, _segment, idx, segments, params|
+        return nil unless node.wildcard_child
+        nxt = node.wildcard_child
+        params[nxt.param_name.to_s] = segments[idx..-1].join('/') if params && nxt.param_name
+        [nxt, true]
+      end,
+
+      # default returns nil (no match). RadixTree#find will then return [nil, {}].
+      default: lambda { |_node, _segment, _idx, _segments, _params| nil }
+    }.freeze
+
+    # singleton instances to avoid per-LRU allocations
+    LRU_HIT_STRATEGY = RubyRoutes::LruStrategies::HitStrategy.new.freeze
+    LRU_MISS_STRATEGY = RubyRoutes::LruStrategies::MissStrategy.new.freeze
+
+    # Descriptor factories for segment classification (O(1) dispatch by first byte).
+    DESCRIPTOR_FACTORIES = {
+      42 => ->(s) { { type: :splat,  name: (s[1..-1] || 'splat') } }, # '*'
+      58 => ->(s) { { type: :param,  name:   s[1..-1] } },             # ':'
+      :default => ->(s) { { type: :static, value:  s } }
+    }.freeze
+
+    def self.segment_descriptor(raw)
+      s = raw.to_s
+      key = s.empty? ? :default : s.getbyte(0)
+      factory = DESCRIPTOR_FACTORIES[key] || DESCRIPTOR_FACTORIES[:default]
+      factory.call(s)
+    end
+  end
+end

data/lib/ruby_routes/lru_strategies/hit_strategy.rb

@@ -0,0 +1,13 @@
+module RubyRoutes
+  module LruStrategies
+    class HitStrategy
+      def call(lru, key)
+        lru.increment_hits
+        h = lru.instance_variable_get(:@h)
+        val = h.delete(key)
+        h[key] = val
+        val
+      end
+    end
+  end
+end

data/lib/ruby_routes/lru_strategies/miss_strategy.rb

@@ -0,0 +1,10 @@
+module RubyRoutes
+  module LruStrategies
+    class MissStrategy
+      def call(lru, _key)
+        lru.increment_misses
+        nil
+      end
+    end
+  end
+end

data/lib/ruby_routes/node.rb

@@ -1,3 +1,5 @@
+require_relative 'segment'
+
 module RubyRoutes
   class Node
     attr_accessor :static_children, :dynamic_child, :wildcard_child,
@@ -12,13 +14,52 @@ module RubyRoutes
       @is_endpoint = false
     end
 
+    # 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)
+      # Static match: O(1) hash lookup
+      child = @static_children[segment]
+      return [child, false] if child
+
+      # Dynamic match: single segment capture
+      if (dyn = @dynamic_child)
+        params[dyn.param_name] = segment if params
+        return [dyn, false]
+      end
+
+      # Wildcard match: consume remainder (last resort)
+      if (wild = @wildcard_child)
+        if params
+          # Build remainder path without intermediate array allocation
+          remainder = segments[index..-1]
+          params[wild.param_name] = remainder.size == 1 ? remainder[0] : remainder.join('/')
+        end
+        return [wild, true]
+      end
+
+      # 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

@@ -1,13 +1,11 @@
+require_relative 'segment'
+
 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()
@@ -17,64 +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)
-      segments = split_path(path)
       current = @root
+      segments = split_path_raw(path)
 
-      segments.each do |segment|
-        if segment.start_with?('*')
-          current.wildcard_child ||= Node.new
-          current = current.wildcard_child
-          current.param_name = segment[1..-1] || 'splat'
-          break
-        elsif segment.start_with?(':')
-          current.dynamic_child ||= Node.new
-          current = current.dynamic_child
-          current.param_name = segment[1..-1]
-        else
-          current.static_children[segment] ||= Node.new
-          current = current.static_children[segment]
-        end
+      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) }
+      # Normalize methods once during registration
+      Array(methods).each { |method| current.add_handler(method.to_s.upcase, handler) }
     end
 
-    def find(path, method)
-      segments = split_path(path)
-      current = @root
-      params = {}
-
-      segments.each_with_index do |segment, index|
-        if current.static_children.key?(segment)
-          current = current.static_children[segment]
-        elsif current.dynamic_child
-          current = current.dynamic_child
-          # keep string keys to avoid symbol allocations and extra conversions later
-          params[current.param_name.to_s] = segment
-        elsif current.wildcard_child
-          current = current.wildcard_child
-          params[current.param_name.to_s] = segments[index..-1].join('/')
-          break
+    def find(path, method, params_out = nil)
+      # 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
+
+      # 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
+        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]
@@ -82,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
@@ -117,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/small_lru.rb

@@ -0,0 +1,43 @@
+module RubyRoutes
+  class Route
+    # small LRU used for path generation cache
+    class SmallLru
+      attr_reader :hits, :misses, :evictions
+
+      # larger default to reduce eviction likelihood in benchmarks
+      def initialize(max_size = 1024)
+        @max_size = max_size
+        @h = {}
+        @hits = 0
+        @misses = 0
+        @evictions = 0
+
+        @hit_strategy = RubyRoutes::Constant::LRU_HIT_STRATEGY
+        @miss_strategy = RubyRoutes::Constant::LRU_MISS_STRATEGY
+      end
+
+      def get(key)
+        strategy = @h.key?(key) ? @hit_strategy : @miss_strategy
+        strategy.call(self, key)
+      end
+
+      def set(key, val)
+        @h.delete(key) if @h.key?(key)
+        @h[key] = val
+        if @h.size > @max_size
+          @h.shift
+          @evictions += 1
+        end
+        val
+      end
+
+      def increment_hits
+        @hits += 1
+      end
+
+      def increment_misses
+        @misses += 1
+      end
+    end
+  end
+end

data/lib/ruby_routes/route.rb

@@ -1,217 +1,223 @@
 require 'uri'
+require_relative 'route/small_lru'
 
 module RubyRoutes
   class Route
-    # small LRU used for path generation cache
-    class SmallLru
-      attr_reader :hits, :misses, :evictions
-
-      # larger default to reduce eviction likelihood in benchmarks
-      def initialize(max_size = 1024)
-        @max_size = max_size
-        @h = {}
-        @hits = 0
-        @misses = 0
-        @evictions = 0
-      end
-
-      def get(key)
-        if @h.key?(key)
-          @hits += 1
-          val = @h.delete(key)
-          @h[key] = val
-          val
-        else
-          @misses += 1
-          nil
-        end
-      end
-
-      def set(key, val)
-        @h.delete(key) if @h.key?(key)
-        @h[key] = val
-        if @h.size > @max_size
-          @h.shift
-          @evictions += 1
-        end
-        val
-      end
-    end
-
     attr_reader :path, :methods, :controller, :action, :name, :constraints, :defaults
 
     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)
-      path_params = extract_path_params(request_path)
-      return {} unless path_params
+    def extract_params(request_path, parsed_qp = nil)
+      path_params = extract_path_params_fast(request_path)
+      return EMPTY_HASH unless path_params
 
-      params = path_params.dup
-      params.merge!(query_params(request_path)) # query_params returns string-keyed hash below
-      # defaults already string keys, only merge keys that aren't present
-      defaults.each { |k, v| params[k] = v unless params.key?(k) }
-
-      validate_constraints!(params)
-      params
+      # 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_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 == '/'
-
-      # build merged for only relevant param names
-      merged = {}
-      defaults.each { |k, v| merged[k] = v } # defaults already string keys
-      params.each do |k, v|
-        ks = k.to_s
-        merged[ks] = v
+      return ROOT_PATH if @path == ROOT_PATH
+
+      # 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|
-            if seg.start_with?(':')
-              { type: :param, name: seg[1..-1] }
-            elsif seg.start_with?('*')
-              { type: :splat, name: (seg[1..-1] || 'splat') }
-            else
-              { type: :static, value: seg }
-            end
-          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) }
+    # 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
 
-    # 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
-      names.map { |n| merged[n].to_s }.join('|')
+    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
 
-    def compiled_param_names
-      @compiled_param_names ||= compiled_segments.map { |s| s[:name] if s[:type] != :static }.compact
+    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
 
-    # 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 check_static_path
+      # Pre-generate static paths (no params)
+      if @required_params.empty?
+        @static_path = generate_static_path
+      end
     end
 
-    def normalize_path(path)
-      p = path.to_s
-      p = "/#{p}" unless p.start_with?('/')
-      p = p.chomp('/') unless p == '/'
-      p
+    def generate_static_path
+      return ROOT_PATH if @compiled_segments.empty?
+
+      parts = @compiled_segments.map { |seg| seg[:value] }
+      "/#{parts.join('/')}"
     end
 
-    def extract_controller(options)
-      if options[:to]
-        options[:to].to_s.split('#').first
-      else
-        options[:controller]
+    # 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?
+
+      # Fast path normalization
+      path_parts = split_path_fast(request_path)
+      return nil if @compiled_segments.size != path_parts.size
 
-      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('/')
+      extract_params_from_parts(path_parts)
+    end
 
-      return nil if segs.size != request_parts.size
+    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
@@ -219,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).transform_keys(&:to_s)
+    # 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
+
+    # 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
 
-    def validate_constraints!(params)
-      constraints.each do |param, constraint|
+    # Optimized constraint validation
+    def validate_constraints_fast!(params)
+      @constraints.each do |param, constraint|
         value = params[param.to_s]
         next unless value
 
@@ -236,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,44 +5,80 @@ module RubyRoutes
     def initialize
       @tree = RubyRoutes::RadixTree.new
       @named_routes = {}
-      @routes = []          # keep list for specs / iteration / size
+      @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)
-      # Use RadixTree lookup and the path params it returns (avoid reparsing the path)
-      handler, path_params = @tree.find(request_path, request_method.to_s.upcase)
+      # 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])
+        @cache_hits += 1
+        cached_route, cached_params = cached
+        return {
+          route: cached_route,
+          params: cached_params,
+          controller: cached_route.controller,
+          action: cached_route.action
+        }
+      end
+
+      @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
 
-      # path_params are already string-keyed in RadixTree; merge defaults + query params
-      params = (path_params || {}).dup
-      params = route.defaults.transform_keys(&:to_s).merge(params)
-      params.merge!(route.send(:query_params, request_path))
+      # Fast path: merge defaults only if they exist
+      merge_defaults(route, params) if route.defaults && !route.defaults.empty?
 
-      # Note: lightweight constraint checks are performed during RadixTree#find.
-      # Skip full constraint re-validation here to avoid double work.
+      # Fast path: parse query params only if needed
+      if request_path.include?('?')
+        merge_query_params(route, request_path, params)
+      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
       }
@@ -53,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)
+      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/segment.rb

@@ -0,0 +1,20 @@
+require_relative 'segments/base_segment'
+require_relative 'segments/dynamic_segment'
+require_relative 'segments/static_segment'
+require_relative 'segments/wildcard_segment'
+require_relative 'constant'
+
+module RubyRoutes
+  class Segment
+    def self.for(text)
+      t = text.to_s
+      key = t.empty? ? :default : t.getbyte(0)
+      segment = RubyRoutes::Constant::SEGMENTS[key] || RubyRoutes::Constant::SEGMENTS[:default]
+      segment.new(t)
+    end
+
+    def wildcard?
+      false
+    end
+  end
+end

data/lib/ruby_routes/segments/base_segment.rb

@@ -0,0 +1,21 @@
+module RubyRoutes
+  module Segments
+    class BaseSegment
+      def initialize(text = nil)
+        @text = text.to_s if text
+      end
+
+      def wildcard?
+        false
+      end
+
+      def ensure_child(current)
+        raise NotImplementedError, "#{self.class}#ensure_child must be implemented"
+      end
+
+      def match(_node, _text, _idx, _segments, _params)
+        raise NotImplementedError, "#{self.class}#match must be implemented"
+      end
+    end
+  end
+end

data/lib/ruby_routes/segments/dynamic_segment.rb

@@ -0,0 +1,23 @@
+module RubyRoutes
+  module Segments
+    class DynamicSegment < BaseSegment
+      def initialize(text)
+        @name = text[1..-1]
+      end
+
+      def ensure_child(current)
+        current.dynamic_child ||= Node.new
+        current = current.dynamic_child
+        current.param_name = @name
+        current
+      end
+
+      def match(node, text, _idx, _segments, params)
+        return [nil, false] unless node.dynamic_child
+        nxt = node.dynamic_child
+        params[nxt.param_name.to_s] = text if params
+        [nxt, false]
+      end
+    end
+  end
+end

data/lib/ruby_routes/segments/static_segment.rb

@@ -0,0 +1,18 @@
+module RubyRoutes
+  module Segments
+    class StaticSegment < BaseSegment
+      def initialize(text)
+        @text = text
+      end
+
+      def ensure_child(current)
+        current.static_children[@text] ||= Node.new
+        current.static_children[@text]
+      end
+
+      def match(node, text, _idx, _segments, _params)
+        [node.static_children[text], false]
+      end
+    end
+  end
+end

data/lib/ruby_routes/segments/wildcard_segment.rb

@@ -0,0 +1,27 @@
+module RubyRoutes
+  module Segments
+    class WildcardSegment < BaseSegment
+      def initialize(text)
+        @name = (text[1..-1] || 'splat')
+      end
+
+      def ensure_child(current)
+        current.wildcard_child ||= Node.new
+        current = current.wildcard_child
+        current.param_name = @name
+        current
+      end
+
+      def wildcard?
+        true
+      end
+
+      def match(node, _text, idx, segments, params)
+        return [nil, false] unless node.wildcard_child
+        nxt = node.wildcard_child
+        params[nxt.param_name.to_s] = segments[idx..-1].join('/') if params
+        [nxt, true]
+      end
+    end
+  end
+end

data/lib/ruby_routes/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_routes
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Yosef Benny Widyokarsono
@@ -62,11 +62,20 @@ files:
 - LICENSE
 - README.md
 - lib/ruby_routes.rb
+- lib/ruby_routes/constant.rb
+- lib/ruby_routes/lru_strategies/hit_strategy.rb
+- lib/ruby_routes/lru_strategies/miss_strategy.rb
 - lib/ruby_routes/node.rb
 - lib/ruby_routes/radix_tree.rb
 - lib/ruby_routes/route.rb
+- lib/ruby_routes/route/small_lru.rb
 - lib/ruby_routes/route_set.rb
 - lib/ruby_routes/router.rb
+- lib/ruby_routes/segment.rb
+- lib/ruby_routes/segments/base_segment.rb
+- lib/ruby_routes/segments/dynamic_segment.rb
+- lib/ruby_routes/segments/static_segment.rb
+- lib/ruby_routes/segments/wildcard_segment.rb
 - lib/ruby_routes/string_extensions.rb
 - lib/ruby_routes/url_helpers.rb
 - lib/ruby_routes/version.rb