ruby_routes 2.3.0 → 2.5.0

data/lib/ruby_routes/router/scope_helpers.rb

@@ -61,7 +61,21 @@ module RubyRoutes
       # @param scoped_path [String] The path to prepend the scope's path to.
       # @return [void]
       def apply_path_scope(scope, scoped_path)
-        scoped_path.prepend(scope[:path]) if scope[: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
+
+        # Normalize: Ensure the final path starts with '/'
+        scoped_path.prepend('/') unless scoped_path.start_with?('/')
       end
 
       # Apply the module from a scope to the given options.
@@ -73,13 +87,17 @@ module RubyRoutes
       # @param scoped_options [Hash] The options to update with the module.
       # @return [void]
       def apply_module_scope(scope, scoped_options)
-        return unless scope[:module]
+        module_string = scope[:module]&.to_s
+        return if module_string.nil? || module_string.empty?
 
-        if scoped_options[:to]
-          controller, action = scoped_options[:to].to_s.split('#', 2)
-          scoped_options[:to] = "#{scope[:module]}/#{controller}##{action}"
-        elsif scoped_options[:controller]
-          scoped_options[:controller].prepend("#{scope[:module]}/")
+        if (to_val = scoped_options[:to])
+          controller, action = to_val.to_s.split('#', 2)
+          return if controller.nil? || controller.empty?
+          scoped_options[:to] = action && !action.empty? ? "#{module_string}/#{controller}##{action}" : "#{module_string}/#{controller}"
+        elsif (controller = scoped_options[:controller])
+          controller_string = controller.to_s
+          return if controller_string.empty?
+          scoped_options[:controller] = "#{module_string}/#{controller_string}"
         end
       end
 
@@ -91,7 +109,7 @@ module RubyRoutes
       def apply_defaults_scope(scope, scoped_options)
         return unless scope[:defaults]
 
-        scoped_options[:defaults] = (scoped_options[:defaults] || {}).merge(scope[:defaults])
+        scoped_options[:defaults] = scope[:defaults].merge(scoped_options[:defaults] || {})
       end
 
       # Apply the constraints from a scope to the given options.
@@ -102,7 +120,7 @@ module RubyRoutes
       def apply_constraints_scope(scope, scoped_options)
         return unless scope[:constraints]
 
-        scoped_options[:constraints] = (scoped_options[:constraints] || {}).merge(scope[:constraints])
+        scoped_options[:constraints] = scope[:constraints].merge(scoped_options[:constraints] || {})
       end
     end
   end

data/lib/ruby_routes/router.rb

@@ -3,7 +3,9 @@
 require_relative 'utility/inflector_utility'
 require_relative 'utility/route_utility'
 require_relative 'router/http_helpers'
-
+require_relative 'router/resource_helpers'
+require_relative 'constant'
+require_relative 'route_set'
 module RubyRoutes
   # RubyRoutes::Router
   #
@@ -86,11 +88,16 @@ module RubyRoutes
       return self if @frozen
 
       @frozen = true
+      if @route_set.respond_to?(:finalize!)
+        @route_set.finalize!
+      else
+        @route_set.freeze
+      end
+      @route_utils.freeze if @route_utils.respond_to?(:freeze)
       @scope_stack.freeze
       @concerns.freeze
       self
     end
-
     # Check if the router is frozen.
     #
     # @return [Boolean] `true` if the router is frozen, `false` otherwise.
@@ -98,12 +105,17 @@ module RubyRoutes
       !!@frozen
     end
 
-    # Define a root route.
+    # Define the root route.
     #
     # @param options [Hash] The options for the root route.
     # @return [Router] self.
     def root(options = {})
-      add_route('/', build_route_options(options, :get))
+      ensure_unfrozen!
+      if options[:to]
+        add_route('/', via: [:get], **options)
+      else
+        add_route('/', controller: 'root', action: :index, via: [:get], **options)
+      end
       self
     end
 
@@ -116,7 +128,9 @@ module RubyRoutes
     # @param nested_block [Proc] The block for nested routes.
     # @return [Router] self.
     def resources(resource_name, options = {}, &nested_block)
+      ensure_unfrozen!
       define_resource_routes(resource_name, options, &nested_block)
+      self
     end
 
     # Define a singular resource.
@@ -125,6 +139,7 @@ module RubyRoutes
     # @param options [Hash] The options for the resource.
     # @return [Router] self.
     def resource(resource_name, options = {})
+      ensure_unfrozen!
       singular   = RubyRoutes::Utility::InflectorUtility.singularize(resource_name.to_s)
       controller = options[:controller] || singular
       define_singular_routes(singular, controller, options)
@@ -139,6 +154,7 @@ module RubyRoutes
     # @param block [Proc] The block for nested routes.
     # @return [Router] self.
     def namespace(namespace_name, options = {}, &block)
+      ensure_unfrozen!
       push_scope({ path: "/#{namespace_name}", module: namespace_name }.merge(options)) do
         instance_eval(&block) if block
       end
@@ -150,6 +166,7 @@ module RubyRoutes
     # @param block [Proc] The block for nested routes.
     # @return [Router] self.
     def scope(options_or_path = {}, &block)
+      ensure_unfrozen!
       scope_entry = options_or_path.is_a?(String) ? { path: options_or_path } : options_or_path
       push_scope(scope_entry) { instance_eval(&block) if block }
     end
@@ -160,6 +177,7 @@ module RubyRoutes
     # @param block [Proc] The block for nested routes.
     # @return [Router] self.
     def constraints(constraints_hash = {}, &block)
+      ensure_unfrozen!
       push_scope(constraints: constraints_hash) { instance_eval(&block) if block }
     end
 
@@ -169,6 +187,7 @@ module RubyRoutes
     # @param block [Proc] The block for nested routes.
     # @return [Router] self.
     def defaults(defaults_hash = {}, &block)
+      ensure_unfrozen!
       push_scope(defaults: defaults_hash) { instance_eval(&block) if block }
     end
 
@@ -190,6 +209,7 @@ module RubyRoutes
     # @param block [Proc] The block for additional routes.
     # @return [void]
     def concerns(*concern_names, &block)
+      ensure_unfrozen!
       concern_names.each do |name|
         concern_block = @concerns[name]
         raise "Concern '#{name}' not found" unless concern_block

data/lib/ruby_routes/segments/wildcard_segment.rb

@@ -39,7 +39,9 @@ module RubyRoutes
       def ensure_child(parent_node)
         parent_node.wildcard_child ||= Node.new
         wildcard_child_node = parent_node.wildcard_child
-        wildcard_child_node.param_name = @param_name
+        if wildcard_child_node.param_name.nil?
+          wildcard_child_node.param_name = @param_name
+        end
         wildcard_child_node
       end
 

data/lib/ruby_routes/utility/key_builder_utility.rb

@@ -14,9 +14,7 @@ module RubyRoutes
     # Design goals:
     # - Zero garbage on hot cache hits.
     # - Bounded memory (REQUEST_KEY_CAPACITY ring).
-    # - Thread safety not required (intended for single request thread use).
-    #
-    # @module RubyRoutes::Utility::KeyBuilderUtility
+    # - Thread-safe for concurrent access across multiple threads.
     module KeyBuilderUtility
       # @!visibility private
       # { "GET" => { "/users" => "GET:/users" } }
@@ -28,12 +26,21 @@ module RubyRoutes
       @ring_index  = 0
       # @!visibility private
       @entry_count = 0
+      # @!visibility private
+      @mutex = Mutex.new
 
       class << self
-        # Expose pool for diagnostics (read‑only).
+        # Clear all cached request keys.
         #
-        # @return [Hash] A shallow copy of the request key pool for diagnostics.
-        attr_reader :request_key_pool
+        # @return [void]
+        def clear!
+          @mutex.synchronize do
+            @request_key_pool.clear
+            @request_key_ring.fill(nil)
+            @entry_count = 0
+            @ring_index = 0
+          end
+        end
 
         # Fetch (or create) a frozen "METHOD:PATH" composite key.
         #
@@ -46,12 +53,14 @@ module RubyRoutes
         # @param request_path [String] The request path (e.g., "/users").
         # @return [String] A frozen canonical key.
         def fetch_request_key(http_method, request_path)
-          method_key, path_key = prepare_keys(http_method, request_path)
+          @mutex.synchronize do
+            method_key, path_key = prepare_keys(http_method, request_path)
 
-          bucket = @request_key_pool[method_key] ||= {}
-          return bucket[path_key] if bucket[path_key]
+            bucket = @request_key_pool[method_key] ||= {}
+            return bucket[path_key] if bucket[path_key]
 
-          handle_cache_miss(bucket, method_key, path_key)
+            handle_cache_miss(bucket, method_key, path_key)
+          end
         end
 
         private
@@ -116,7 +125,7 @@ module RubyRoutes
 
       # Build a generic delimited key from components (non‑hot path).
       #
-      # Uses a thread‑local mutable buffer to avoid transient objects.
+      # Simple join; acceptable for non‑hot paths.
       #
       # @param components [Array<#to_s>] The components to join into a key.
       # @param delimiter [String] The separator (default is ':').
@@ -159,8 +168,16 @@ module RubyRoutes
       # @param buffer [String] The buffer to build the key into.
       # @return [void]
       def build_param_key_buffer(required_params, merged, buffer)
-        key_components = required_params.map { |param| format_param_value(merged[param]) }
-        buffer << key_components.join('|')
+        first = true
+        required_params.each do |param|
+          value = format_param_value(merged[param])
+          if first
+            buffer << value
+            first = false
+          else
+            buffer << '|' << value
+          end
+        end
       end
 
       # Format a parameter value for inclusion in the key.

data/lib/ruby_routes/utility/method_utility.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../constant'
+require_relative '../route/small_lru'
 
 module RubyRoutes
   module Utility
@@ -38,15 +39,10 @@ module RubyRoutes
       }.freeze
 
       # Cache for non‑predefined or previously seen method tokens.
-      # Keys: original `String` or `Symbol`
-      # Values: frozen uppercase `String`
+      # Now uses SmallLru for LRU eviction instead of simple clearing.
       #
-      # Note: This is intentionally mutable for caching purposes.
-      #
-      # @return [Hash{(String,Symbol) => String}]
-      # rubocop:disable Style/MutableConstant
-      METHOD_CACHE = {} # Intentionally mutable for caching
-      # rubocop:enable Style/MutableConstant
+      # @return [SmallLru]
+      METHOD_CACHE = RubyRoutes::Route::SmallLru.new(RubyRoutes::Constant::METHOD_CACHE_MAX_SIZE)
 
       # Normalize an HTTP method‑like input to a canonical uppercase `String`.
       #
@@ -78,10 +74,11 @@ module RubyRoutes
       # @param method_input [String] The HTTP method input.
       # @return [String] The normalized HTTP method.
       def normalize_string_method(method_input)
-        key = method_input
-        return key if already_upper_ascii?(key)
+        return method_input if already_upper_ascii?(method_input)
 
-        METHOD_CACHE[key] ||= ascii_upcase(key).freeze
+        # Use SmallLru for LRU eviction, freeze key to prevent mutation
+        key = method_input.dup.freeze
+        METHOD_CACHE.get(key) || METHOD_CACHE.set(key, ascii_upcase(method_input.dup).freeze)
       end
 
       # Normalize a `Symbol` HTTP method.
@@ -89,7 +86,10 @@ module RubyRoutes
       # @param method_input [Symbol] The HTTP method input.
       # @return [String] The normalized HTTP method.
       def normalize_symbol_method(method_input)
-        SYMBOL_MAP[method_input] || (METHOD_CACHE[method_input] ||= ascii_upcase(method_input.to_s).freeze)
+        SYMBOL_MAP[method_input] || begin
+          key = method_input.to_s.freeze
+          METHOD_CACHE.get(key) || METHOD_CACHE.set(key, ascii_upcase(method_input.to_s).freeze)
+        end
       end
 
       # Normalize an arbitrary HTTP method input.
@@ -98,10 +98,11 @@ module RubyRoutes
       # @return [String] The normalized HTTP method.
       def normalize_other_method(method_input)
         coerced = method_input.to_s
-        key = coerced
-        return key if already_upper_ascii?(key)
+        return coerced if already_upper_ascii?(coerced)
 
-        METHOD_CACHE[key] ||= ascii_upcase(key).freeze
+        # Use SmallLru for LRU eviction, freeze key to prevent mutation
+        key = coerced.dup.freeze
+        METHOD_CACHE.get(key) || METHOD_CACHE.set(key, ascii_upcase(coerced.dup).freeze)
       end
 
       # Determine if a `String` consists solely of uppercase ASCII (`A–Z`) or non‑letters.

data/lib/ruby_routes/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubyRoutes
-  VERSION = '2.3.0'
+  VERSION = '2.5.0'
 end

metadata

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