ruby_routes 2.5.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,22 @@ module RubyRoutes
       # @param entry [Hash] The cache entry.
       # @return [void]
       def insert_cache_entry(cache_key, entry)
-        @cache_mutex ||= Mutex.new
         @cache_mutex.synchronize do
           if @recognition_cache.size >= @recognition_cache_max
-            @recognition_cache.keys.first(@recognition_cache_max / 4).each do |evict_key|
-              @recognition_cache.delete(evict_key)
-            end
+            # 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

data/lib/ruby_routes/route_set/collection_helpers.rb

@@ -12,7 +12,7 @@ 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.
@@ -21,7 +21,7 @@ module RubyRoutes
         return route if @routes.include?(route) # Prevent duplicate insertion
 
         @named_routes[route.name] = route if route.named?
-        @radix_tree.add(route.path, route.methods, route)
+        @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,19 +69,17 @@ 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!
-        @cache_mutex ||= Mutex.new
+      def clear_routes_and_caches!
         @cache_mutex.synchronize do
           @routes.clear
           @named_routes.clear
           @recognition_cache.clear
-          @cache_hits = 0
-          @cache_misses = 0
-          @radix_tree = RadixTree.new
+          @small_lru.clear_counters!
+          @strategy = @strategy_class.new
           RubyRoutes::Utility::KeyBuilderUtility.clear!
         end
       end

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,25 +92,19 @@ module RubyRoutes
       route.generate_path(params)
     end
 
+    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.
@@ -117,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.
@@ -157,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

@@ -17,12 +17,6 @@ module RubyRoutes
       def build
         router = Router.new
         validate_calls(@recorded_calls)
-        RubyRoutes::Constant::RECORDED_METHODS.each do |method_name|
-          define_method(method_name) do |*arguments, &definition_block|
-            @recorded_calls << [__method__, arguments, definition_block]
-            nil
-          end
-        end
         router.finalize!
         router
       end
@@ -95,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,6 +32,18 @@ module RubyRoutes
     class Builder
       include RubyRoutes::Router::BuildHelpers
 
+      # Initialize the Builder.
+      #
+      # This method initializes the `@recorded_calls` array and optionally
+      # evaluates the provided block in the context of the Builder instance.
+      #
+      # @yield [definition_block] Runs the routing DSL in a recording context (optional).
+      # @return [void]
+      def initialize(&definition_block)
+        @recorded_calls = []
+        instance_eval(&definition_block) if definition_block
+      end
+
       # Array of recorded calls: [method_symbol, args_array, block].
       #
       # Each tuple contains:
@@ -48,18 +60,6 @@ module RubyRoutes
           .freeze
       end
 
-      # Initialize the Builder.
-      #
-      # This method initializes the `@recorded_calls` array and optionally
-      # evaluates the provided block in the context of the Builder instance.
-      #
-      # @yield [definition_block] Runs the routing DSL in a recording context (optional).
-      # @return [void]
-      def initialize(&definition_block)
-        @recorded_calls = []
-        instance_eval(&definition_block) if definition_block
-      end
-
       # ---- DSL Recording -------------------------------------------------
       # Dynamically define methods for all DSL methods specified in
       # `RubyRoutes::Constant::RECORDED_METHODS`. Each method records its

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.

data/lib/ruby_routes/router/resource_helpers.rb

@@ -25,33 +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
 
       private
 
-      # Prepare options by removing the `:to` key if present.
+      # 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.
@@ -103,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