ruby_routes 2.0.0 → 2.2.0

data/lib/ruby_routes/route_set.rb

@@ -1,94 +1,103 @@
+require_relative 'utility/key_builder_utility'
+
 module RubyRoutes
   class RouteSet
     attr_reader :routes
 
+    include RubyRoutes::Utility::KeyBuilderUtility
+
     def initialize
-      @tree = RubyRoutes::RadixTree.new
-      @named_routes = {}
       @routes = []
-      # Optimized recognition cache with better data structures
+      @named_routes = {}
       @recognition_cache = {}
+      @recognition_cache_max = 2048
       @cache_hits = 0
       @cache_misses = 0
-      @recognition_cache_max = 8192  # larger for better hit rates
+      @radix_tree = RadixTree.new
     end
 
-    def add_route(route)
+    def add_to_collection(route)
       @routes << route
-      @tree.add(route.path, route.methods, route)
+      @radix_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)
-      # Optimized: avoid repeated string allocation
-      method_up = request_method.to_s.upcase
-      handler, _params = @tree.find(request_path, method_up)
-      handler
+    alias_method :add_route, :add_to_collection
+
+    def find_route(method, path)
+      route, _ = @radix_tree.find(path, method)
+      route
     end
 
     def find_named_route(name)
       route = @named_routes[name]
-      return route if route
-      raise RouteNotFound, "No route named '#{name}'"
+      raise RouteNotFound.new("No route named '#{name}'") unless route
+      route
     end
 
-    def match(request_method, request_path)
-      # Fast path: normalize method once
-      method_up = method_lookup(request_method)
+    FAST_METHOD_MAP = {
+      get: 'GET', post: 'POST', put: 'PUT', patch: 'PATCH',
+      delete: 'DELETE', head: 'HEAD', options: 'OPTIONS'
+    }.freeze
+
+    def normalize_method_input(method)
+      case method
+      when Symbol
+        FAST_METHOD_MAP[method] || method.to_s.upcase
+      when String
+        # Fast path: assume already correct; fallback only for common lowercase
+        return method if method.length <= 6 && method == method.upcase
+        FAST_METHOD_MAP[method.downcase.to_sym] || method.upcase
+      else
+        s = method.to_s
+        FAST_METHOD_MAP[s.downcase.to_sym] || s.upcase
+      end
+    end
+    private :normalize_method_input
 
-      # Optimized cache key: avoid string interpolation when possible
-      cache_key = build_cache_key(method_up, request_path)
+    def match(method, path)
+      m = normalize_method_input(method)
+      raw = path.to_s
+      cache_key = cache_key_for_request(m, raw)
 
-      # Cache hit: return immediately (cached result includes full structure)
-      if (cached_result = @recognition_cache[cache_key])
+      # Single cache lookup with proper hit accounting
+      if (hit = @recognition_cache[cache_key])
         @cache_hits += 1
-        return cached_result
+        return hit
       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
+      path_without_query, _qs = raw.split('?', 2)
 
-      route = handler
+      # Use normalized method (m) for trie lookup
+      route, params = @radix_tree.find(path_without_query, m)
+      return nil unless route
 
-      # Fast path: merge defaults only if they exist
-      merge_defaults(route, params) if route.defaults && !route.defaults.empty?
+      merge_query_params(route, raw, params)
 
-      # Fast path: parse query params only if needed
-      if request_path.include?('?')
-        merge_query_params(route, request_path, params)
+      if route.respond_to?(:defaults) && route.defaults
+        route.defaults.each { |k,v| params[k.to_s] = v unless params.key?(k.to_s) }
       end
 
-      # Create return hash and cache the complete result
-      result_params = params.dup
       result = {
         route: route,
-        params: result_params,
+        params: params,
         controller: route.controller,
         action: route.action
-      }.freeze
-      
+      }
+
       insert_cache_entry(cache_key, result)
       result
     end
 
-    def recognize_path(path, method = :get)
+    def recognize_path(path, method = 'GET')
       match(method, path)
     end
 
     def generate_path(name, params = {})
-      route = @named_routes[name]
-      if route
-        route.generate_path(params)
-      else
-        raise RouteNotFound, "No route named '#{name}'"
-      end
+      route = find_named_route(name)
+      route.generate_path(params)
     end
 
     def generate_path_from_route(route, params = {})
@@ -99,95 +108,76 @@ module RubyRoutes
       @routes.clear
       @named_routes.clear
       @recognition_cache.clear
-      @tree = RadixTree.new
-      @cache_hits = @cache_misses = 0
+      @cache_hits = 0
+      @cache_misses = 0
+      # Create a new radix tree since we can't clear it
+      @radix_tree = RadixTree.new
     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
+      lookups = @cache_hits + @cache_misses
       {
         hits: @cache_hits,
         misses: @cache_misses,
-        hit_rate: "#{hit_rate}%",
+        hit_rate: lookups.zero? ? 0.0 : (@cache_hits.to_f / lookups * 100.0),
         size: @recognition_cache.size
       }
     end
 
-    private
-
-    # Method lookup table to avoid repeated upcasing with interned strings
-    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 string interpolation which is faster than buffer + dup + freeze
-      # String interpolation creates a new string directly without intermediate allocations
-      "#{method}:#{path}".freeze
+    def each(&block)
+      @routes.each(&block)
     end
 
-    # Get thread-local params hash, reusing when possible
-    def get_thread_local_params
-      # Use single thread-local hash that gets cleared, avoiding pool management overhead
-      hash = Thread.current[:ruby_routes_params_hash] ||= {}
-      hash.clear
-      hash
+    def include?(route)
+      @routes.include?(route)
     end
 
-    def return_params_to_pool(params)
-      # No-op since we're using a single reusable hash per thread
-    end
+    private
 
-    # Fast defaults merging
-    def merge_defaults(route, params)
-      route.defaults.each do |key, value|
-        params[key] = value unless params.key?(key)
+    def insert_cache_entry(key, value)
+      # unchanged cache insert (key already frozen & reusable)
+      if @recognition_cache.size >= @recognition_cache_max
+        @recognition_cache.keys.first(@recognition_cache_max / 4).each { |k| @recognition_cache.delete(k) }
+      end
+      @recognition_cache[key] = value
+    end
+
+    # Add the missing method for merging query params
+    def merge_query_params(route, path, params)
+      # Check for query string
+      if path.to_s.include?('?')
+        if route.respond_to?(:parse_query_params)
+          query_params = route.parse_query_params(path)
+          params.merge!(query_params) if query_params
+        elsif route.respond_to?(:query_params)
+          query_params = route.query_params(path)
+          params.merge!(query_params) if query_params
+        end
       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?
+    # Add thread-local params pool methods
+    def get_thread_local_params
+      thread_params = Thread.current[:ruby_routes_params_pool] ||= []
+      if thread_params.empty?
+        {}
+      else
+        thread_params.pop.clear
       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
+    def return_params_to_pool(params)
+      params.clear
+      thread_pool = Thread.current[:ruby_routes_params_pool] ||= []
+      thread_pool << params if thread_pool.size < 10 # Limit pool size
     end
   end
 end

data/lib/ruby_routes/router.rb

@@ -1,9 +1,12 @@
+require_relative 'utility/route_utility'
+
 module RubyRoutes
   class Router
     attr_reader :route_set
 
     def initialize(&block)
       @route_set = RouteSet.new
+      @route_utils = RubyRoutes::Utility::RouteUtility.new(@route_set)
       @scope_stack = []
       @concerns = {}
       instance_eval(&block) if block_given?
@@ -102,7 +105,14 @@ module RubyRoutes
     end
 
     # Scope support
-    def scope(options = {}, &block)
+    def scope(options_or_path = {}, &block)
+      # Handle the case where the first argument is a string (path)
+      options = if options_or_path.is_a?(String)
+                  { path: options_or_path }
+                else
+                  options_or_path
+                end
+
       @scope_stack.push(options)
 
       if block_given?
@@ -165,14 +175,9 @@ module RubyRoutes
 
     private
 
-    def add_route(path, options = {})
-      # Apply current scope
-      scoped_options = apply_scope(path, options)
-
-      # Create and add the route
-      route = Route.new(scoped_options[:path], scoped_options)
-      @route_set.add_route(route)
-      route
+    def add_route(path, options={})
+      scoped = apply_scope(path, options)
+      @route_utils.define(scoped[:path], scoped)
     end
 
     def apply_scope(path, options)

data/lib/ruby_routes/string_extensions.rb

@@ -14,8 +14,10 @@ class String
     case self
     when /y$/
       self.sub(/y$/, 'ies')
-    when /sh$/, /ch$/, /x$/, /z$/
+    when /sh$/, /ch$/, /x$/
       self + 'es'
+    when /z$/
+      self + 'zes'
     when /s$/
       # Words ending in 's' are already plural
       self

data/lib/ruby_routes/url_helpers.rb

@@ -4,6 +4,7 @@ module RubyRoutes
   module UrlHelpers
     def self.included(base)
       base.extend(ClassMethods)
+      base.include(base.url_helpers)
     end
 
     module ClassMethods
@@ -49,11 +50,11 @@ module RubyRoutes
       # HTML forms only support GET and POST
       # For other methods, use POST with _method hidden field
       form_method = (method == 'get') ? 'get' : 'post'
-      
+
       safe_path = CGI.escapeHTML(path.to_s)
       safe_form_method = CGI.escapeHTML(form_method)
       html = "<form action=\"#{safe_path}\" method=\"#{safe_form_method}\">"
-      
+
       # Add _method hidden field for non-GET/POST methods
       if method != 'get' && method != 'post'
         safe_method = CGI.escapeHTML(method)

data/lib/ruby_routes/utility/key_builder_utility.rb

@@ -0,0 +1,102 @@
+module RubyRoutes
+  module Utility
+    module KeyBuilderUtility
+      # ------------------------------------------------------------------
+      # Fast reusable key storage for "METHOD:PATH" strings.
+      # O(1) insert + O(1) eviction using a fixed-size ring buffer.
+      # Only allocates a new String on the *first* time a (method,path) pair appears.
+      # ------------------------------------------------------------------
+      REQUEST_KEY_CAPACITY = 4096
+
+      @pool      = {}                        # { method_string => { path_string => frozen_key_string } }
+      @ring      = Array.new(REQUEST_KEY_CAPACITY) # ring entries: [method_string, path_string]
+      @ring_pos  = 0
+      @entry_cnt = 0
+
+      class << self
+        attr_reader :pool
+        def fetch_request_key(method, path)
+          # Method & path must be strings already (callers ensure)
+          if (paths = @pool[method])
+            if (key = paths[path])
+              return key
+            end
+          end
+
+            # MISS: build & freeze once
+          key = "#{method}:#{path}".freeze
+          if paths
+            paths[path] = key
+          else
+            @pool[method] = { path => key }
+          end
+
+          # Evict if ring full (overwrite oldest slot)
+          if @entry_cnt < REQUEST_KEY_CAPACITY
+            @ring[@entry_cnt] = [method, path]
+            @entry_cnt += 1
+          else
+            ev_m, ev_p = @ring[@ring_pos]
+            bucket = @pool[ev_m]
+            if bucket&.delete(ev_p) && bucket.empty?
+              @pool.delete(ev_m)
+            end
+            @ring[@ring_pos] = [method, path]
+            @ring_pos += 1
+            @ring_pos = 0 if @ring_pos == REQUEST_KEY_CAPACITY
+          end
+
+          key
+        end
+      end
+
+      # ------------------------------------------------------------------
+      # Public helpers mixed into instances
+      # ------------------------------------------------------------------
+
+      # Generic key (rarely hot): joins parts with delim; single allocation.
+      def build_key(parts, delim = ':')
+        return ''.freeze if parts.empty?
+        buf = Thread.current[:ruby_routes_key_buf] ||= String.new
+        buf.clear
+        i = 0
+        while i < parts.length
+          buf << delim unless i.zero?
+          buf << parts[i].to_s
+          i += 1
+        end
+        buf.dup
+      end
+
+      # HOT: request cache key (reused frozen interned string)
+      def cache_key_for_request(method, path)
+        KeyBuilderUtility.fetch_request_key(method, path.to_s)
+      end
+
+      # HOT: params key – produces a short-lived String (dup, not re-frozen each time).
+      # Callers usually put it into an LRU that duplicates again, so keep it lean.
+      def cache_key_for_params(required_params, merged)
+        return ''.freeze if required_params.nil? || required_params.empty?
+        buf = Thread.current[:ruby_routes_param_key_buf] ||= String.new
+        buf.clear
+        i = 0
+        while i < required_params.length
+          buf << '|' unless i.zero?
+          v = merged[required_params[i]]
+          if v.is_a?(Array)
+            j = 0
+            while j < v.length
+              buf << '/' unless j.zero?
+              buf << v[j].to_s
+              j += 1
+            end
+          else
+            buf << v.to_s
+          end
+          i += 1
+        end
+        buf.dup
+      end
+    end
+  end
+end

data/lib/ruby_routes/utility/path_utility.rb

@@ -0,0 +1,42 @@
+module RubyRoutes
+  module Utility
+    module PathUtility
+      ROOT_PATH = '/'.freeze
+
+      def normalize_path(path)
+        path = path.to_s
+        # Add leading slash if missing
+        path = '/' + path unless path.start_with?('/')
+        # Remove trailing slash if present (unless root)
+        path = path[0..-2] if path.length > 1 && path.end_with?('/')
+        path
+      end
+
+      def split_path(path)
+        # Remove query string before splitting
+        path = path.split('?', 2).first
+        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 join_path_parts(parts)
+        # Pre-calculate the size to avoid buffer resizing
+        size = parts.sum { |p| p.length + 1 } # +1 for slash
+
+        # Use string buffer for better performance
+        result = String.new(capacity: size)
+        result << '/'
+
+        # Join with explicit concatenation rather than array join
+        last_idx = parts.size - 1
+        parts.each_with_index do |part, i|
+          result << part
+          result << '/' unless i == last_idx
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/ruby_routes/utility/route_utility.rb

@@ -0,0 +1,21 @@
+module RubyRoutes
+  module Utility
+    class RouteUtility
+      def initialize(route_set)
+        @route_set = route_set
+      end
+
+      # DSL wants to merge scope, RouteSet wants to add a pre‐built Route,
+      # so we offer two entry points:
+      def define(path, options = {})
+        route = Route.new(path, options)
+        register(route)
+      end
+
+      def register(route)
+        @route_set.add_to_collection(route)
+        route
+      end
+    end
+  end
+end

data/lib/ruby_routes/version.rb

@@ -1,3 +1,3 @@
 module RubyRoutes
-  VERSION = "2.0.0"
+  VERSION = "2.2.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_routes
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Yosef Benny Widyokarsono
@@ -37,6 +37,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -78,6 +92,9 @@ files:
 - lib/ruby_routes/segments/wildcard_segment.rb
 - lib/ruby_routes/string_extensions.rb
 - lib/ruby_routes/url_helpers.rb
+- lib/ruby_routes/utility/key_builder_utility.rb
+- lib/ruby_routes/utility/path_utility.rb
+- lib/ruby_routes/utility/route_utility.rb
 - lib/ruby_routes/version.rb
 homepage: https://github.com/yosefbennywidyo/ruby_routes
 licenses: