ruby_routes 1.0.0 → 2.0.0

data/lib/ruby_routes/route_set.rb

@@ -5,71 +5,77 @@ module RubyRoutes
     def initialize
       @tree = RubyRoutes::RadixTree.new
       @named_routes = {}
-      @routes = []                  # keep list for specs / iteration / size
-      @recognition_cache = {}       # simple bounded cache: key -> [route, params]
-      @recognition_cache_order = []
-      @recognition_cache_max = 4096
+      @routes = []
+      # Optimized recognition cache with better data structures
+      @recognition_cache = {}
+      @cache_hits = 0
+      @cache_misses = 0
+      @recognition_cache_max = 8192  # larger for better hit rates
     end
 
     def add_route(route)
       @routes << route
       @tree.add(route.path, route.methods, route)
       @named_routes[route.name] = route if route.named?
+      # Clear recognition cache when routes change
+      @recognition_cache.clear if @recognition_cache.size > 100
       route
     end
 
     def find_route(request_method, request_path)
-      # Return the Route object (or nil) to match spec expectations.
-      handler, _params = @tree.find(request_path, request_method.to_s.upcase)
+      # Optimized: avoid repeated string allocation
+      method_up = request_method.to_s.upcase
+      handler, _params = @tree.find(request_path, method_up)
       handler
     end
 
     def find_named_route(name)
-      @named_routes[name] or raise RouteNotFound, "No route named '#{name}'"
+      route = @named_routes[name]
+      return route if route
+      raise RouteNotFound, "No route named '#{name}'"
     end
 
     def match(request_method, request_path)
-      # Normalize method once and attempt recognition cache hit
-      method_up = request_method.to_s.upcase
-      cache_key = "#{method_up}:#{request_path}"
-      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 }
+      # 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 (cached result includes full structure)
+      if (cached_result = @recognition_cache[cache_key])
+        @cache_hits += 1
+        return cached_result
       end
 
-      # Use a thread-local hash as output for RadixTree to avoid allocating a params Hash
-      tmp = Thread.current[:ruby_routes_params] ||= {}
-      handler, _ = @tree.find(request_path, method_up, tmp)
+      @cache_misses += 1
+
+      # Use thread-local params to avoid allocations
+      params = get_thread_local_params
+      handler, _ = @tree.find(request_path, method_up, params)
       return nil unless handler
-      route = handler
 
-      # tmp now contains path params (filled by RadixTree). Merge defaults and query params in-place.
-      # defaults first (only set missing keys)
-      if route.defaults
-        route.defaults.each { |k, v| tmp[k] = v unless tmp.key?(k) }
-      end
-      if request_path.include?('?')
-        qp = route.parse_query_params(request_path)
-        qp.each { |k, v| tmp[k] = v } unless qp.empty?
-      end
+      route = handler
 
-      params = tmp.dup
+      # Fast path: merge defaults only if they exist
+      merge_defaults(route, params) if route.defaults && !route.defaults.empty?
 
-      # 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)
+      # 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 the complete result
+      result_params = params.dup
+      result = {
         route: route,
-        params: params,
+        params: result_params,
         controller: route.controller,
         action: route.action
-      }
+      }.freeze
+      
+      insert_cache_entry(cache_key, result)
+      result
     end
 
     def recognize_path(path, method = :get)
@@ -77,35 +83,111 @@ module RubyRoutes
     end
 
     def generate_path(name, params = {})
-      route = find_named_route(name)
-      generate_path_from_route(route, params)
+      route = @named_routes[name]
+      if route
+        route.generate_path(params)
+      else
+        raise RouteNotFound, "No route named '#{name}'"
+      end
     end
 
     def generate_path_from_route(route, params = {})
-      # Delegate to Route#generate_path which uses precompiled segments + cache
       route.generate_path(params)
     end
 
     def clear!
       @routes.clear
       @named_routes.clear
+      @recognition_cache.clear
       @tree = RadixTree.new
+      @cache_hits = @cache_misses = 0
     end
 
     def size
       @routes.size
     end
+    alias_method :length, :size
 
     def empty?
       @routes.empty?
     end
 
     def each(&block)
+      return enum_for(:each) unless block_given?
       @routes.each(&block)
     end
 
     def include?(route)
       @routes.include?(route)
     end
+
+    # Performance monitoring
+    def cache_stats
+      total = @cache_hits + @cache_misses
+      hit_rate = total > 0 ? (@cache_hits.to_f / total * 100).round(2) : 0
+      {
+        hits: @cache_hits,
+        misses: @cache_misses,
+        hit_rate: "#{hit_rate}%",
+        size: @recognition_cache.size
+      }
+    end
+
+    private
+
+    # Method lookup table to avoid repeated upcasing 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
+    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
+    end
+
+    def return_params_to_pool(params)
+      # No-op since we're using a single reusable hash per thread
+    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/router.rb

@@ -5,6 +5,7 @@ module RubyRoutes
     def initialize(&block)
       @route_set = RouteSet.new
       @scope_stack = []
+      @concerns = {}
       instance_eval(&block) if block_given?
     end
 
@@ -36,19 +37,20 @@ module RubyRoutes
     # Resources routing (Rails-like)
     def resources(name, options = {}, &block)
       singular = name.to_s.singularize
-      plural = name.to_s.pluralize
+      plural = (options[:path] || name.to_s.pluralize)
+      controller = options[:controller] || plural
 
       # Collection routes
-      get "/#{plural}", options.merge(to: "#{plural}#index")
-      get "/#{plural}/new", options.merge(to: "#{plural}#new")
-      post "/#{plural}", options.merge(to: "#{plural}#create")
+      get "/#{plural}", options.merge(to: "#{controller}#index")
+      get "/#{plural}/new", options.merge(to: "#{controller}#new")
+      post "/#{plural}", options.merge(to: "#{controller}#create")
 
       # Member routes
-      get "/#{plural}/:id", options.merge(to: "#{plural}#show")
-      get "/#{plural}/:id/edit", options.merge(to: "#{plural}#edit")
-      put "/#{plural}/:id", options.merge(to: "#{plural}#update")
-      patch "/#{plural}/:id", options.merge(to: "#{plural}#update")
-      delete "/#{plural}/:id", options.merge(to: "#{plural}#destroy")
+      get "/#{plural}/:id", options.merge(to: "#{controller}#show")
+      get "/#{plural}/:id/edit", options.merge(to: "#{controller}#edit")
+      put "/#{plural}/:id", options.merge(to: "#{controller}#update")
+      patch "/#{plural}/:id", options.merge(to: "#{controller}#update")
+      delete "/#{plural}/:id", options.merge(to: "#{controller}#destroy")
 
       # Nested resources if specified
       if options[:nested]
@@ -63,7 +65,6 @@ module RubyRoutes
         get "/#{plural}/:id/#{nested_plural}/:nested_id/edit", options.merge(to: "#{nested_plural}#edit")
         put "/#{plural}/:id/#{nested_plural}/:nested_id", options.merge(to: "#{nested_plural}#update")
         patch "/#{plural}/:id/#{nested_plural}/:nested_id", options.merge(to: "#{nested_plural}#update")
-        delete "/#{plural}/:id/#{nested_plural}/:nested_id", options.merge(to: "#{nested_plural}#update")
         delete "/#{plural}/:id/#{nested_plural}/:nested_id", options.merge(to: "#{nested_plural}#destroy")
       end
 
@@ -131,7 +132,6 @@ module RubyRoutes
     end
 
     def concern(name, &block)
-      @concerns ||= {}
       @concerns[name] = block
     end
 

data/lib/ruby_routes/url_helpers.rb

@@ -1,3 +1,5 @@
+require 'cgi'
+
 module RubyRoutes
   module UrlHelpers
     def self.included(base)
@@ -33,16 +35,33 @@ module RubyRoutes
 
     def link_to(name, text, params = {})
       path = path_to(name, params)
-      "<a href=\"#{path}\">#{text}</a>"
+      safe_path = CGI.escapeHTML(path.to_s)
+      safe_text = CGI.escapeHTML(text.to_s)
+      "<a href=\"#{safe_path}\">#{safe_text}</a>"
     end
 
     def button_to(name, text, params = {})
-      path = path_to(name, params)
-      method = params.delete(:method) || :post
+      local_params = params ? params.dup : {}
+      method = local_params.delete(:method) || :post
+      method = method.to_s.downcase
+      path = path_to(name, local_params)
+
+      # 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)
+        html += "<input type=\"hidden\" name=\"_method\" value=\"#{safe_method}\">"
+      end
 
-      html = "<form action=\"#{path}\" method=\"#{method}\">"
-      html += "<input type=\"hidden\" name=\"_method\" value=\"#{method}\">" if method != :get
-      html += "<button type=\"submit\">#{text}</button>"
+      safe_text = CGI.escapeHTML(text.to_s)
+      html += "<button type=\"submit\">#{safe_text}</button>"
       html += "</form>"
       html
     end

data/lib/ruby_routes/version.rb

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

data/lib/ruby_routes.rb

@@ -11,6 +11,7 @@ module RubyRoutes
   class Error < StandardError; end
   class RouteNotFound < Error; end
   class InvalidRoute < Error; end
+  class ConstraintViolation < Error; end
 
   # Create a new router instance
   def self.new(&block)

metadata

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