ruby_routes 2.4.0 → 2.6.0

data/lib/ruby_routes/route_set/cache_helpers.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative '../route/small_lru'
+
 module RubyRoutes
   class RouteSet
     # CacheHelpers: extracted cache, request-key, and eviction logic to reduce
@@ -8,6 +10,8 @@ module RubyRoutes
     # This module provides methods for managing caches, request keys, and
     # implementing eviction policies for route recognition.
     module CacheHelpers
+
+      attr_reader :named_routes, :small_lru
       # Recognition cache statistics.
       #
       # @return [Hash] A hash containing:
@@ -16,11 +20,11 @@ module RubyRoutes
       #   - `:hit_rate` [Float] The cache hit rate as a percentage.
       #   - `:size` [Integer] The current size of the recognition cache.
       def cache_stats
-        total_requests = @cache_hits + @cache_misses
+        total_requests = @small_lru.hits + @small_lru.misses
         {
-          hits: @cache_hits,
-          misses: @cache_misses,
-          hit_rate: total_requests.zero? ? 0.0 : (@cache_hits.to_f / total_requests * 100.0),
+          hits: @small_lru.hits,
+          misses: @small_lru.misses,
+          hit_rate: total_requests.zero? ? 0.0 : (@small_lru.hits.to_f / total_requests * 100.0),
           size: @recognition_cache.size
         }
       end
@@ -37,9 +41,11 @@ module RubyRoutes
         @routes = []
         @named_routes = {}
         @recognition_cache = {}
-        @recognition_cache_max = 2048
-        @cache_hits = 0
-        @cache_misses = 0
+        @recognition_cache_max = RubyRoutes::Constant::CACHE_SIZE
+        @small_lru = RubyRoutes::Route::SmallLru.new(RubyRoutes::Constant::CACHE_SIZE)
+        @gen_cache = RubyRoutes::Route::SmallLru.new(RubyRoutes::Constant::CACHE_SIZE)
+        @query_cache = RubyRoutes::Route::SmallLru.new(RubyRoutes::Constant::CACHE_SIZE)
+        @cache_mutex = Mutex.new
       end
 
       # Fetch cached recognition entry while updating hit counter.
@@ -48,10 +54,10 @@ module RubyRoutes
       # @return [Hash, nil] The cached recognition entry, or `nil` if not found.
       def fetch_cached_recognition(lookup_key)
         if (cached_result = @recognition_cache[lookup_key])
-          @cache_hits += 1
+          @small_lru.increment_hits
           return cached_result
         end
-        @cache_misses += 1
+        @small_lru.increment_misses
         nil
       end
 
@@ -64,12 +70,25 @@ module RubyRoutes
       # @param entry [Hash] The cache entry.
       # @return [void]
       def insert_cache_entry(cache_key, entry)
-        if @recognition_cache.size >= @recognition_cache_max
-          @recognition_cache.keys.first(@recognition_cache_max / 4).each do |evict_key|
-            @recognition_cache.delete(evict_key)
+        @cache_mutex.synchronize do
+          if @recognition_cache.size >= @recognition_cache_max
+            # Calculate how many to keep (3/4 of max, rounded down)
+            keep_count = (@recognition_cache_max * 3 / 4).to_i
+
+            # Get the keys to keep (newest 75%, assuming insertion order)
+            keys_to_keep = @recognition_cache.keys.last(keep_count)
+
+            # Get the entries to keep
+            entries_to_keep = @recognition_cache.slice(*keys_to_keep)
+
+            # Clear the entire cache (evicts the oldest 25%)
+            @recognition_cache.clear
+
+            # Re-add the kept entries (3/4)
+            @recognition_cache.merge!(entries_to_keep)
           end
+          @recognition_cache[cache_key] = entry
         end
-        @recognition_cache[cache_key] = entry
       end
     end
   end

data/lib/ruby_routes/route_set/collection_helpers.rb

@@ -12,16 +12,16 @@ module RubyRoutes
       # Add a route object to internal structures.
       #
       # This method adds a route to the internal route collection, updates the
-      # radix tree for fast path/method lookups, and registers the route in the
+      # matching strategy for fast path/method lookups, and registers the route in the
       # named routes collection if it has a name.
       #
       # @param route [Route] The route to add.
       # @return [Route] The added route.
       def add_to_collection(route)
-        @named_routes[route.name] = route if route.named?
-        @radix_tree.add(route.path, route.methods, route)
         return route if @routes.include?(route) # Prevent duplicate insertion
 
+        @named_routes[route.name] = route if route.named?
+        @strategy.add(route)
         @routes << route
         route
       end
@@ -40,14 +40,14 @@ module RubyRoutes
 
       # Find any route (no params) for a method/path.
       #
-      # This method searches the radix tree for a route matching the given HTTP
+      # This method searches the matching strategy for a route matching the given HTTP
       # method and path.
       #
       # @param http_method [String, Symbol] The HTTP method (e.g., `:get`, `:post`).
       # @param path [String] The path to match.
       # @return [Route, nil] The matching route, or `nil` if no match is found.
       def find_route(http_method, path)
-        route, _params = @radix_tree.find(path, http_method)
+        route, _params = @strategy.find(path, http_method)
         route
       end
 
@@ -69,18 +69,19 @@ module RubyRoutes
       # Clear all routes and caches.
       #
       # This method clears the internal route collection, named routes, recognition
-      # cache, and radix tree. It also resets cache hit/miss counters and clears
+      # cache, and matching strategy. It also resets cache hit/miss counters and clears
       # the global request key cache.
       #
       # @return [void]
-      def clear!
-        @routes.clear
-        @named_routes.clear
-        @recognition_cache.clear
-        @cache_hits = 0
-        @cache_misses = 0
-        @radix_tree = RadixTree.new
-        RubyRoutes::Utility::KeyBuilderUtility.clear!
+      def clear_routes_and_caches!
+        @cache_mutex.synchronize do
+          @routes.clear
+          @named_routes.clear
+          @recognition_cache.clear
+          @small_lru.clear_counters!
+          @strategy = @strategy_class.new
+          RubyRoutes::Utility::KeyBuilderUtility.clear!
+        end
       end
 
       # Get the number of routes.

data/lib/ruby_routes/route_set.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
 
-require_relative 'radix_tree'
+require_relative 'strategies'
 require_relative 'utility/key_builder_utility'
 require_relative 'utility/method_utility'
 require_relative 'route_set/cache_helpers'
 require_relative 'route_set/collection_helpers'
 require_relative 'route/param_support'
+require_relative 'route/path_generation'
 
 module RubyRoutes
   # RouteSet
@@ -17,7 +18,7 @@ module RubyRoutes
   # - Index named routes.
   # - Provide fast recognition (method + path → route, params) with
   #   a small in‑memory recognition cache.
-  # - Delegate structural path matching to an internal RadixTree.
+  # - Delegate structural path matching to a configurable strategy.
   #
   # Thread Safety:
   # - RouteSet instances are not fully thread-safe for modifications.
@@ -33,14 +34,16 @@ module RubyRoutes
     include RubyRoutes::Utility::MethodUtility
     include RubyRoutes::RouteSet::CacheHelpers
     include RubyRoutes::Route::ParamSupport
+    include RubyRoutes::Route::PathGeneration
     include RubyRoutes::RouteSet::CollectionHelpers
 
     # Initialize empty collection and caches.
     #
+    # @param strategy [Class] The matching strategy to use.
     # @return [void]
-    def initialize
+    def initialize(strategy: Strategies::HybridStrategy)
       setup_caches
-      setup_radix_tree
+      setup_strategy(strategy)
     end
 
     # Recognize a request (method + path) returning route + params.
@@ -49,7 +52,7 @@ module RubyRoutes
     # @param path [String] The request path.
     # @return [Hash, nil] A hash containing the matched route and parameters, or `nil` if no match is found.
     def match(http_method, path)
-      normalized_method = normalize_method_for_match(http_method)
+      normalized_method = normalize_http_method(http_method)
       raw_path = path.to_s
       lookup_key = cache_key_for_request(normalized_method, raw_path)
 
@@ -77,8 +80,7 @@ module RubyRoutes
     # @param params [Hash] The parameters for path generation.
     # @return [String] The generated path.
     def generate_path(name, params = {})
-      route = find_named_route(name)
-      route.generate_path(params)
+      generate_path_from_route(find_named_route(name), params)
     end
 
     # Generate path from a direct route reference.
@@ -90,37 +92,19 @@ module RubyRoutes
       route.generate_path(params)
     end
 
-    # Replay recorded calls on the router instance.
-    #
-    # This method replays all the recorded route definitions and other
-    # configuration calls on the given router instance.
-    #
-    # @param router [Router] The router instance to replay calls on.
-    # @return [void]
-    def replay_recorded_calls(router)
-      # Placeholder for actual implementation
-      # Iterate over recorded calls and apply them to the router
+    def clear_counters!
+      clear_routes_and_caches!
     end
 
     private
 
-    # Set up the radix tree for structural path matching.
+    # Set up the matching strategy.
     #
+    # @param strategy [Class] The matching strategy class.
     # @return [void]
-    def setup_radix_tree
-      @radix_tree = RadixTree.new
-    end
-
-    # Normalize the HTTP method for matching.
-    #
-    # @param http_method [String, Symbol] The HTTP method.
-    # @return [String] The normalized HTTP method.
-    def normalize_method_for_match(http_method)
-      if http_method.is_a?(String) && normalize_http_method(http_method).equal?(http_method)
-        http_method
-      else
-        normalize_http_method(http_method)
-      end
+    def setup_strategy(strategy)
+      @strategy_class = strategy
+      @strategy = @strategy_class.new
     end
 
     # Perform the route matching process.
@@ -129,31 +113,28 @@ module RubyRoutes
     # @param raw_path [String] The raw request path.
     # @return [Hash, nil] A hash containing the matched route and parameters, or `nil` if no match is found.
     def perform_match(normalized_method, raw_path)
-      path_without_query, _query = raw_path.split('?', 2)
-      matched_route, extracted_params = @radix_tree.find(path_without_query, normalized_method)
+      matched_route, path_params = @strategy.find(raw_path, normalized_method)
       return nil unless matched_route
 
-      # Ensure we have a mutable hash for merging defaults / query params.
-      if extracted_params.nil?
-        extracted_params = {}
-      elsif extracted_params.frozen?
-        extracted_params = extracted_params.dup
-      end
-
-      merge_query_params(matched_route, raw_path, extracted_params)
-      merge_defaults(matched_route, extracted_params)
-      build_match_result(matched_route, extracted_params)
+      final_params = build_final_params(matched_route, path_params, raw_path)
+      build_match_result(matched_route, final_params)
     end
 
-    # Merge default parameters into the extracted parameters.
+    # Build the final parameters hash by merging path, query, and default params.
     #
     # @param matched_route [Route] The matched route.
-    # @param extracted_params [Hash] The extracted parameters.
-    # @return [void]
-    def merge_defaults(matched_route, extracted_params)
-      return unless matched_route.respond_to?(:defaults) && matched_route.defaults
-
-      matched_route.defaults.each { |key, value| extracted_params[key] = value unless extracted_params.key?(key) }
+    # @param path_params [Hash] The parameters extracted from the path.
+    # @param raw_path [String] The full request path including query string.
+    # @return [Hash] The final, merged parameters hash.
+    def build_final_params(matched_route, path_params, raw_path)
+      # Optimized merge order: defaults -> path -> query
+      # Start with defaults, which have the lowest precedence.
+      final_params = matched_route.defaults.dup
+      # Merge path parameters, which override defaults.
+      final_params.merge!(path_params) if path_params
+      matched_route.merge_query_params_into_hash(final_params, raw_path, nil)
+
+      final_params
     end
 
     # Build the match result hash.
@@ -169,23 +150,5 @@ module RubyRoutes
         action: matched_route.action
       }
     end
-
-    # Obtain a pooled hash for temporary parameters.
-    #
-    # @return [Hash] A thread-local hash for temporary parameter storage.
-    def thread_local_params
-      thread_params = Thread.current[:ruby_routes_params_pool] ||= []
-      thread_params.empty? ? {} : thread_params.pop.clear
-    end
-
-    # Return a parameters hash to the thread-local pool.
-    #
-    # @param params [Hash] The parameters hash to return.
-    # @return [void]
-    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/build_helpers.rb

@@ -89,7 +89,7 @@ module RubyRoutes
       def validate_calls(recorded_calls)
         allowed_router_methods = RubyRoutes::Constant::RECORDED_METHODS
         recorded_calls.each do |(router_method, _arguments, _definition_block)|
-          unless router_method.is_a?(Symbol) && allowed_router_methods.include?(router_method)
+          unless allowed_router_methods.include?(router_method)
             raise ArgumentError, "Invalid router method: #{router_method.inspect}"
           end
         end

data/lib/ruby_routes/router/builder.rb

@@ -32,19 +32,6 @@ module RubyRoutes
     class Builder
       include RubyRoutes::Router::BuildHelpers
 
-      # Array of recorded calls: [method_symbol, args_array, block].
-      #
-      # Each tuple contains:
-      # - The method name (as a Symbol).
-      # - The arguments (as an Array).
-      # - The block (as a Proc or `nil`).
-      #
-      # @return [Array<Array(Symbol, Array, Proc|NilClass)>]
-      #   A snapshot of the recorded calls to avoid external mutation.
-      def recorded_calls
-        @recorded_calls.dup.freeze
-      end
-
       # Initialize the Builder.
       #
       # This method initializes the `@recorded_calls` array and optionally
@@ -57,6 +44,22 @@ module RubyRoutes
         instance_eval(&definition_block) if definition_block
       end
 
+      # Array of recorded calls: [method_symbol, args_array, block].
+      #
+      # Each tuple contains:
+      # - The method name (as a Symbol).
+      # - The arguments (as an Array).
+      # - The block (as a Proc or `nil`).
+      #
+      # @return [Array<Array(Symbol, Array, Proc|NilClass)>]
+      #   A snapshot of the recorded calls to avoid external mutation.
+      def recorded_calls
+        # Deep-copy each recorded call’s args array and freeze the result to prevent mutation
+        @recorded_calls
+          .map { |(method_name, args, block)| [method_name, args.dup.freeze, block] }
+          .freeze
+      end
+
       # ---- DSL Recording -------------------------------------------------
       # Dynamically define methods for all DSL methods specified in
       # `RubyRoutes::Constant::RECORDED_METHODS`. Each method records its
@@ -72,26 +75,6 @@ module RubyRoutes
           nil
         end
       end
-
-      private
-
-      # Validate the recorded calls.
-      #
-      # This method ensures that all recorded calls use valid router methods
-      # as defined in `RubyRoutes::Constant::RECORDED_METHODS`.
-      #
-      # @param recorded_calls [Array<Array(Symbol, Array, Proc|NilClass)>]
-      #   The recorded calls to validate.
-      # @raise [ArgumentError] If any recorded call uses an invalid method.
-      # @return [void]
-      def validate_calls(recorded_calls)
-        allowed_router_methods = RubyRoutes::Constant::RECORDED_METHODS
-        recorded_calls.each do |(router_method, _arguments, _definition_block)|
-          unless router_method.is_a?(Symbol) && allowed_router_methods.include?(router_method)
-            raise ArgumentError, "Invalid router method: #{router_method.inspect}"
-          end
-        end
-      end
     end
   end
 end

data/lib/ruby_routes/router/http_helpers.rb

@@ -22,54 +22,13 @@ module RubyRoutes
 
       # ---- HTTP Verb Helpers -------------------------------------------------
 
-      # Define a GET route.
-      #
-      # @param path [String] The path for the route.
-      # @param options [Hash] The options for the route.
-      # @return [Router] Returns self for chaining.
-      def get(path, options = {})
-        add_route(path, build_route_options(options, :get))
-        self
-      end
-
-      # Define a POST route.
-      #
-      # @param path [String] The path for the route.
-      # @param options [Hash] The options for the route.
-      # @return [Router] Returns self for chaining.
-      def post(path, options = {})
-        add_route(path, build_route_options(options, :post))
-        self
-      end
-
-      # Define a PUT route.
-      #
-      # @param path [String] The path for the route.
-      # @param options [Hash] The options for the route.
-      # @return [Router] Returns self for chaining.
-      def put(path, options = {})
-        add_route(path, build_route_options(options, :put))
-        self
-      end
-
-      # Define a PATCH route.
-      #
-      # @param path [String] The path for the route.
-      # @param options [Hash] The options for the route.
-      # @return [Router] Returns self for chaining.
-      def patch(path, options = {})
-        add_route(path, build_route_options(options, :patch))
-        self
-      end
-
-      # Define a DELETE route.
-      #
-      # @param path [String] The path for the route.
-      # @param options [Hash] The options for the route.
-      # @return [Router] Returns self for chaining.
-      def delete(path, options = {})
-        add_route(path, build_route_options(options, :delete))
-        self
+      # Metaprogram `get`, `post`, `put`, `patch`, `delete` for DRYness.
+      # These methods define a route for a specific HTTP verb.
+      %i[get post put patch delete].each do |verb|
+        define_method(verb) do |path, options = {}|
+          add_route(path, build_route_options(options, verb))
+          self
+        end
       end
 
       # Define a route for multiple HTTP methods.
@@ -83,7 +42,12 @@ module RubyRoutes
         via = options[:via]
         raise ArgumentError, 'match requires :via (e.g., via: [:get, :post])' if via.nil? || Array(via).empty?
 
-        add_route(path, options)
+        normalized_via = Array(via)
+        opts = options.dup
+        # Keep :via in opts only if BuildHelpers expects it; otherwise delete.
+        # If BuildHelpers infers from the second arg, delete it:
+        opts.delete(:via)
+        add_route(path, build_route_options(opts, normalized_via))
         self
       end
 

data/lib/ruby_routes/router/resource_helpers.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'build_helpers'
+require_relative '../utility/inflector_utility'
 
 module RubyRoutes
   class Router
@@ -13,8 +14,6 @@ module RubyRoutes
     module ResourceHelpers
       include RubyRoutes::Router::BuildHelpers
 
-      private
-
       # Define RESTful routes for a resource.
       #
       # @param resource_name [Symbol, String] The name of the resource.
@@ -26,31 +25,43 @@ module RubyRoutes
       # @return [void]
       def define_resource_routes(resource_name, options = {}, &nested_block)
         meta = resource_meta(resource_name, options)
-        opts = prepare_options(options)
+        resource_opts = prepare_resource_options(options)
 
         push_scope(path: "/#{meta[:resource_path]}") do
-          build_routes(opts, meta)
-          handle_nested_option(options, opts)
+          define_resource_actions(resource_opts, meta[:controller])
+          handle_nested_option(options, resource_opts)
           apply_nested_block(nested_block)
         end
       end
 
-      # Prepare options by removing the `:to` key if present.
+      private
+
+      # Prepare options for resource routes, removing the `:to` key to avoid conflicts.
+      # This avoids creating a new hash if it's not necessary.
       #
       # @param options [Hash] The options hash.
       # @return [Hash] The prepared options.
-      def prepare_options(options)
-        options.key?(:to) ? options.dup.tap { |h| h.delete(:to) } : options
+      def prepare_resource_options(options)
+        options.key?(:to) ? options.except(:to) : options
       end
 
-      # Build collection and member routes for a resource.
+      # Defines the seven standard RESTful actions for a resource.
+      # This method is data-driven to reduce duplication and improve clarity.
       #
-      # @param opts [Hash] The options hash.
-      # @param meta [Hash] The resource metadata.
+      # @param resource_opts [Hash] The options for the resource routes.
+      # @param controller [String] The controller name for the actions.
+      # @param member_param [String] The parameter name for member routes (e.g., ':id').
       # @return [void]
-      def build_routes(opts, meta)
-        build_collection_routes(opts, meta[:to_index], meta[:to_new], meta[:to_create])
-        build_member_routes(opts, meta[:to_show], meta[:to_edit], meta[:to_update], meta[:to_destroy])
+      def define_resource_actions(resource_opts, controller, member_param: ':id')
+        # Collection routes
+        add_route('',     build_route_options(resource_opts, :get,    "#{controller}#index"))
+        add_route('/new', build_route_options(resource_opts, :get,    "#{controller}#new"))
+        add_route('',     build_route_options(resource_opts, :post,   "#{controller}#create"))
+        # Member routes
+        add_route("/#{member_param}",      build_route_options(resource_opts, :get,    "#{controller}#show"))
+        add_route("/#{member_param}/edit", build_route_options(resource_opts, :get,    "#{controller}#edit"))
+        add_route("/#{member_param}",      resource_opts.merge(via: %i[put patch], to: "#{controller}#update"))
+        add_route("/#{member_param}",      build_route_options(resource_opts, :delete, "#{controller}#destroy"))
       end
 
       # Apply a nested block of routes within the scope of a resource.
@@ -102,36 +113,12 @@ module RubyRoutes
 
         nested_name = options[:nested].to_s
         nested_path = RubyRoutes::Utility::InflectorUtility.pluralize(nested_name)
-        build_nested_routes(nested_path, opts)
-      end
-
-      # Build nested resource routes.
-      #
-      # @param nested_path [String] The path for the nested resource.
-      # @param opts [Hash] The options hash.
-      # @return [void]
-      def build_nested_routes(nested_path, opts)
         push_scope(path: '/:id') do
           push_scope(path: "/#{nested_path}") do
-            add_nested_routes(nested_path, opts)
+            define_resource_actions(opts, nested_path, member_param: ':nested_id')
           end
         end
       end
-
-      # Add routes for a nested resource.
-      #
-      # @param nested_path [String] The path for the nested resource.
-      # @param opts [Hash] The options hash.
-      # @return [void]
-      def add_nested_routes(nested_path, opts)
-        add_route('',                 build_route_options(opts, :get,    "#{nested_path}#index"))
-        add_route('/new',             build_route_options(opts, :get,    "#{nested_path}#new"))
-        add_route('',                 build_route_options(opts, :post,   "#{nested_path}#create"))
-        add_route('/:nested_id',      build_route_options(opts, :get,    "#{nested_path}#show"))
-        add_route('/:nested_id/edit', build_route_options(opts, :get,    "#{nested_path}#edit"))
-        add_route('/:nested_id',      opts.merge(via: %i[put patch], to: "#{nested_path}#update"))
-        add_route('/:nested_id',      build_route_options(opts, :delete, "#{nested_path}#destroy"))
-      end
     end
   end
 end

data/lib/ruby_routes/router/scope_helpers.rb

@@ -61,21 +61,11 @@ module RubyRoutes
       # @param scoped_path [String] The path to prepend the scope's path to.
       # @return [void]
       def apply_path_scope(scope, scoped_path)
-        path = scope[:path]&.to_s
-        return if path.nil? || path.empty?
-
-        if path.end_with?('/')
-          if scoped_path.start_with?('/')
-            scoped_path.prepend(path.chomp('/'))
-          else
-            scoped_path.prepend(path)
-          end
-        else
-          scoped_path.prepend(scoped_path.start_with?('/') ? path : "#{path}/")
-        end
+        scope_path = scope[:path]&.to_s
+        return if scope_path.nil? || scope_path.empty?
 
-        # Normalize: Ensure the final path starts with '/'
-        scoped_path.prepend('/') unless scoped_path.start_with?('/')
+        parts = [scope_path, scoped_path].map { |p| p.to_s.gsub(%r{^/|/$}, '') }.reject(&:empty?)
+        scoped_path.replace("/#{parts.join('/')}")
       end
 
       # Apply the module from a scope to the given options.
@@ -122,6 +112,28 @@ module RubyRoutes
 
         scoped_options[:constraints] = scope[:constraints].merge(scoped_options[:constraints] || {})
       end
+
+      # Get the current merged scope from the scope stack
+      #
+      # @return [Hash] The merged scope with combined namespaces
+      def current_scope
+        merged = {}
+        namespace_parts = []
+
+        @scope_stack.each do |scope|
+          if scope[:namespace]
+            namespace_parts << scope[:namespace].to_s
+          end
+          merged.merge!(scope)
+        end
+
+        # Combine namespaces for nested namespace support
+        if namespace_parts.any?
+          merged[:namespace] = namespace_parts.join('/')
+        end
+
+        merged
+      end
     end
   end
 end