ruby_routes 0.2.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2bc2a63fd1cf72287ce09440410f609579ef5a3cdb4a33513187599dcb5b9ed7
-  data.tar.gz: 560ab2b883aeb3e42f74ef20fd675e3a692173724a78451bd5739115803944cf
+  metadata.gz: 02d39aae113654256dae0905438ac98a540854a5d131dea6c4b2b606b51bf4ba
+  data.tar.gz: ba01a85fc21713387e76c183a41e786106f1a053e2485d294895ac36027d94a5
 SHA512:
-  metadata.gz: dc41f27e4af178dd3a76dbed95f8a2df9aed4a041d3af184b76ccb39480a9b7d7facab6e2e30147926a3ca178d6e45b391c942eb9cb6fbdfd2167c794ef7d573
-  data.tar.gz: eafd4d678f45780a7da280e8e91cfddb7f0abe21cadb248fc5f6517e3632c442d7602363b89685baacdff106588a88c1b62c0180670db681af4b7539cd66c1c2
+  metadata.gz: c3b230ef35186d4f96714ba708b933cf7897166a74b7162949a3144aa21dc79aab2446a0b14d1e0504ea30f941146a7e0f1841d5908e6a6175d771a9b4a658ad
+  data.tar.gz: 9d476bdbaf46cef516cd51adb218097137863fb12976e98d87a7c8d7f77e3609421d81ba14ed77d67cd59054d4356690d088b619e8e089964cd4fdd6055225ac

data/README.md

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

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,6 +14,36 @@ module RubyRoutes
       @is_endpoint = false
     end
 
+    # Traverse for a single segment using the matcher registry.
+    # 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
+
+      # 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]
+      end
+
+      # Then wildcard child (consume remainder)
+      if @wildcard_child
+        next_node = @wildcard_child
+        if params
+          params[next_node.param_name.to_s] = segments[index..-1].join('/')
+        end
+        return [next_node, true]
+      end
+
+      # No match at this node
+      [nil, false]
+    end
+
     def add_handler(method, handler)
       @handlers[method.to_s] = handler
       @is_endpoint = true

data/lib/ruby_routes/radix_tree.rb

@@ -1,3 +1,5 @@
+require_relative 'segment'
+
 module RubyRoutes
   class RadixTree
     class << self
@@ -23,47 +25,30 @@ module RubyRoutes
     end
 
     def add(path, methods, handler)
-      segments = split_path(path)
       current = @root
-
-      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
+      parse_segments(path).each do |seg|
+        current = seg.ensure_child(current)
+        break if seg.wildcard?
       end
 
       methods.each { |method| current.add_handler(method, handler) }
     end
 
-    def find(path, method)
+    def parse_segments(path)
+      split_path(path).map { |s| RubyRoutes::Segment.for(s) }
+    end
+
+    def find(path, method, params_out = nil)
       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
-        else
-          return [nil, {}]
-        end
+      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)
+        return [nil, {}] unless next_node
+        current = next_node
+        break if should_break
       end
 
       handler = current.get_handler(method)

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,43 +1,8 @@
 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 = {})
@@ -58,17 +23,29 @@ module RubyRoutes
       !!extract_path_params(request_path)
     end
 
-    def extract_params(request_path)
+    def extract_params(request_path, parsed_qp = nil)
       path_params = extract_path_params(request_path)
       return {} 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) }
+      # Reuse a thread-local hash to reduce allocations; return a dup to callers.
+      tmp = Thread.current[:ruby_routes_params] ||= {}
+      tmp.clear
 
-      validate_constraints!(params)
-      params
+      # 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
     end
 
     def named?
@@ -83,18 +60,21 @@ module RubyRoutes
       !resource?
     end
 
+    def parse_query_params(path)
+      query_params(path)
+    end
+
     # Fast path generator: uses precompiled token list and a small LRU.
     # Avoids unbounded cache growth and skips URI-encoding for safe values.
     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
-      end
+      # 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
 
       missing = compiled_required_params - merged.keys
       raise RubyRoutes::RouteNotFound, "Missing params: #{missing.join(', ')}" unless missing.empty?
@@ -135,13 +115,7 @@ module RubyRoutes
           []
         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
+            RubyRoutes::Constant.segment_descriptor(seg)
           end
         end
       end
@@ -157,7 +131,21 @@ module RubyRoutes
     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('|')
+      # 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
     end
 
     def compiled_param_names
@@ -223,7 +211,7 @@ module RubyRoutes
       qidx = path.index('?')
       return {} unless qidx
       qs = path[(qidx + 1)..-1] || ''
-      Rack::Utils.parse_query(qs).transform_keys(&:to_s)
+      Rack::Utils.parse_query(qs)
     end
 
     def validate_constraints!(params)

data/lib/ruby_routes/route_set.rb

@@ -5,7 +5,10 @@ module RubyRoutes
     def initialize
       @tree = RubyRoutes::RadixTree.new
       @named_routes = {}
-      @routes = []          # keep list for specs / iteration / size
+      @routes = []                  # keep list for specs / iteration / size
+      @recognition_cache = {}       # simple bounded cache: key -> [route, params]
+      @recognition_cache_order = []
+      @recognition_cache_max = 4096
     end
 
     def add_route(route)
@@ -26,19 +29,40 @@ module RubyRoutes
     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)
+      # Normalize method once and attempt recognition cache hit
+      method_up = request_method.to_s.upcase
+      cache_key = "#{method_up}:#{request_path}"
+      if (cached = @recognition_cache[cache_key])
+        # Return cached params (frozen) directly to avoid heavy dup allocations.
+        cached_route, cached_params = cached
+        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)
       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))
-
-      # Note: lightweight constraint checks are performed during RadixTree#find.
-      # Skip full constraint re-validation here to avoid double work.
+      # 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
+      if request_path.include?('?')
+        qp = route.parse_query_params(request_path)
+        qp.each { |k, v| tmp[k] = v } unless qp.empty?
+      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
 
       {
         route: route,
@@ -58,8 +82,8 @@ module RubyRoutes
     end
 
     def generate_path_from_route(route, params = {})
-  # Delegate to Route#generate_path which uses precompiled segments + cache
-  route.generate_path(params)
+      # Delegate to Route#generate_path which uses precompiled segments + cache
+      route.generate_path(params)
     end
 
     def clear!

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.0.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.0.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