ruby_routes 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9f05718781115fc2cc1d8851ddea52d0af3fa46f7a937335398b518ea0116e9
-  data.tar.gz: 12b51d5138dbbdec4b46d66f20489e167a721f67f58ed80652add4a2e9aa606b
+  metadata.gz: 2bc2a63fd1cf72287ce09440410f609579ef5a3cdb4a33513187599dcb5b9ed7
+  data.tar.gz: 560ab2b883aeb3e42f74ef20fd675e3a692173724a78451bd5739115803944cf
 SHA512:
-  metadata.gz: 32c7fab4ab209b6c2c1a5d50531d9f248f8413fb1409c6ebec9173eb538149c2a5f358e6bad85c0ed6993ed6b91a62a46f8d3551881ffaba4551b80df79c13a2
-  data.tar.gz: dd96665fc956cf1a76444e75287c2661b3629c0d0cc5546f44ed464533a50b8ff830e354d1caa83782c53855446f6e0043039ae09489fef8b5f33eeaa73329c0
+  metadata.gz: dc41f27e4af178dd3a76dbed95f8a2df9aed4a041d3af184b76ccb39480a9b7d7facab6e2e30147926a3ca178d6e45b391c942eb9cb6fbdfd2167c794ef7d573
+  data.tar.gz: eafd4d678f45780a7da280e8e91cfddb7f0abe21cadb248fc5f6517e3632c442d7602363b89685baacdff106588a88c1b62c0180670db681af4b7539cd66c1c2

data/lib/ruby_routes/node.rb

@@ -0,0 +1,24 @@
+module RubyRoutes
+  class Node
+    attr_accessor :static_children, :dynamic_child, :wildcard_child,
+                  :handlers, :param_name, :is_endpoint
+
+    def initialize
+      @static_children = {}
+      @dynamic_child = nil
+      @wildcard_child = nil
+      @handlers = {}
+      @param_name = nil
+      @is_endpoint = false
+    end
+
+    def add_handler(method, handler)
+      @handlers[method.to_s] = handler
+      @is_endpoint = true
+    end
+
+    def get_handler(method)
+      @handlers[method.to_s]
+    end
+  end
+end

data/lib/ruby_routes/radix_tree.rb

@@ -0,0 +1,134 @@
+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()
+        end
+      end
+    end
+
+    def initialize
+      @root = Node.new
+      @_split_cache = {}           # simple LRU: key -> [value, age]
+      @split_cache_order = []      # track order for eviction
+      @split_cache_max = 1024
+    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
+      end
+
+      methods.each { |method| current.add_handler(method, 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
+        else
+          return [nil, {}]
+        end
+      end
+
+      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
+      end
+
+      [handler, params]
+    end
+
+    private
+
+    # faster, lower-allocation trim + split
+    def split_path(path)
+      @split_cache ||= {}
+      return [''] if path == '/'
+      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('/')
+
+      # simple LRU insert
+      @split_cache[path] = segs
+      @split_cache_order << path
+      if @split_cache_order.size > @split_cache_max
+        oldest = @split_cache_order.shift
+        @split_cache.delete(oldest)
+      end
+
+      segs
+    end
+
+    # constraints match helper (non-raising, lightweight)
+    def constraints_match?(constraints, params)
+      constraints.each do |param, constraint|
+        value = params[param.to_s] || params[param]
+        next unless value
+
+        case constraint
+        when Regexp
+          return false unless constraint.match?(value)
+        when Proc
+          return false unless constraint.call(value)
+        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)
+        end
+      end
+      true
+    end
+  end
+end

data/lib/ruby_routes/route.rb

@@ -1,5 +1,43 @@
+require 'uri'
+
 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 = {})
@@ -9,16 +47,15 @@ module RubyRoutes
       @action = options[:action] || extract_action(options[:to])
       @name = options[:as]
       @constraints = options[:constraints] || {}
-      @defaults = options[:defaults] || {}
+      # pre-normalize defaults to string keys to avoid per-request transform_keys
+      @defaults = (options[:defaults] || {}).transform_keys(&:to_s)
 
       validate_route!
     end
 
     def match?(request_method, request_path)
       return false unless methods.include?(request_method.to_s.upcase)
-
-      path_params = extract_path_params(request_path)
-      path_params != nil
+      !!extract_path_params(request_path)
     end
 
     def extract_params(request_path)
@@ -26,9 +63,11 @@ module RubyRoutes
       return {} unless path_params
 
       params = path_params.dup
-      # Convert symbol keys to string keys for consistency
-      string_defaults = defaults.transform_keys(&:to_s)
-      params.merge!(string_defaults)
+      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
     end
 
@@ -44,13 +83,100 @@ module RubyRoutes
       !resource?
     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
+
+      missing = compiled_required_params - merged.keys
+      raise RubyRoutes::RouteNotFound, "Missing params: #{missing.join(', ')}" unless missing.empty?
+
+      @gen_cache ||= SmallLru.new(256)
+      cache_key = cache_key_for(merged)
+      if (cached = @gen_cache.get(cache_key))
+        return cached
+      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
+      end
+
+      out = '/' + parts.join('/')
+      out = '/' if out == ''
+
+      @gen_cache.set(cache_key, out)
+      out
+    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
+    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
+      names.map { |n| merged[n].to_s }.join('|')
+    end
+
+    def compiled_param_names
+      @compiled_param_names ||= compiled_segments.map { |s| s[:name] if s[:type] != :static }.compact
+    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)
+    end
+
     def normalize_path(path)
-      path = "/#{path}" unless path.start_with?('/')
-      # Remove trailing slash unless it's the root path
-      path = path.chomp('/') unless path == '/'
-      path
+      p = path.to_s
+      p = "/#{p}" unless p.start_with?('/')
+      p = p.chomp('/') unless p == '/'
+      p
     end
 
     def extract_controller(options)
@@ -67,26 +193,58 @@ module RubyRoutes
     end
 
     def extract_path_params(request_path)
-      route_parts = path.split('/')
-      request_parts = request_path.split('/')
+      segs = compiled_segments # memoized compiled route tokens
+      return nil if segs.empty? && request_path != '/'
 
-      return nil if route_parts.length != request_parts.length
+      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('/')
+
+      return nil if segs.size != request_parts.size
 
       params = {}
-      route_parts.each_with_index do |route_part, index|
-        request_part = request_parts[index]
-
-        if route_part.start_with?(':')
-          param_name = route_part[1..-1]
-          params[param_name] = request_part
-        elsif route_part != request_part
-          return nil
+      segs.each_with_index do |seg, idx|
+        case seg[:type]
+        when :static
+          return nil unless seg[:value] == request_parts[idx]
+        when :param
+          params[seg[:name]] = request_parts[idx]
+        when :splat
+          params[seg[:name]] = request_parts[idx..-1].join('/')
+          break
         end
       end
 
       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)
+    end
+
+    def validate_constraints!(params)
+      constraints.each do |param, constraint|
+        value = params[param.to_s]
+        next unless value
+
+        case constraint
+        when Regexp
+          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
+        end
+      end
+    end
+
     def validate_route!
       raise InvalidRoute, "Controller is required" if controller.nil?
       raise InvalidRoute, "Action is required" if action.nil?

data/lib/ruby_routes/route_set.rb

@@ -3,18 +3,22 @@ module RubyRoutes
     attr_reader :routes
 
     def initialize
-      @routes = []
+      @tree = RubyRoutes::RadixTree.new
       @named_routes = {}
+      @routes = []          # keep list for specs / iteration / size
     end
 
     def add_route(route)
       @routes << route
+      @tree.add(route.path, route.methods, route)
       @named_routes[route.name] = route if route.named?
       route
     end
 
     def find_route(request_method, request_path)
-      @routes.find { |route| route.match?(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)
+      handler
     end
 
     def find_named_route(name)
@@ -22,12 +26,23 @@ module RubyRoutes
     end
 
     def match(request_method, request_path)
-      route = find_route(request_method, request_path)
-      return nil unless route
+      # 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)
+      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.
 
       {
         route: route,
-        params: route.extract_params(request_path),
+        params: params,
         controller: route.controller,
         action: route.action
       }
@@ -43,22 +58,14 @@ module RubyRoutes
     end
 
     def generate_path_from_route(route, params = {})
-      path = route.path.dup
-
-      params.each do |key, value|
-        path.gsub!(":#{key}", value.to_s)
-      end
-
-      # Remove any remaining :param placeholders
-      path.gsub!(/\/:[^\/]+/, '')
-      path.gsub!(/\/$/, '') if path != '/'
-
-      path
+  # Delegate to Route#generate_path which uses precompiled segments + cache
+  route.generate_path(params)
     end
 
     def clear!
       @routes.clear
       @named_routes.clear
+      @tree = RadixTree.new
     end
 
     def size

data/lib/ruby_routes/version.rb

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

data/lib/ruby_routes.rb

@@ -4,6 +4,8 @@ require_relative "ruby_routes/route"
 require_relative "ruby_routes/route_set"
 require_relative "ruby_routes/url_helpers"
 require_relative "ruby_routes/router"
+require_relative "ruby_routes/radix_tree"
+require_relative "ruby_routes/node"
 
 module RubyRoutes
   class Error < StandardError; end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_routes
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Yosef Benny Widyokarsono
@@ -62,6 +62,8 @@ files:
 - LICENSE
 - README.md
 - lib/ruby_routes.rb
+- lib/ruby_routes/node.rb
+- lib/ruby_routes/radix_tree.rb
 - lib/ruby_routes/route.rb
 - lib/ruby_routes/route_set.rb
 - lib/ruby_routes/router.rb