ruby_routes 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9f05718781115fc2cc1d8851ddea52d0af3fa46f7a937335398b518ea0116e9
-  data.tar.gz: 12b51d5138dbbdec4b46d66f20489e167a721f67f58ed80652add4a2e9aa606b
+  metadata.gz: 02d39aae113654256dae0905438ac98a540854a5d131dea6c4b2b606b51bf4ba
+  data.tar.gz: ba01a85fc21713387e76c183a41e786106f1a053e2485d294895ac36027d94a5
 SHA512:
-  metadata.gz: 32c7fab4ab209b6c2c1a5d50531d9f248f8413fb1409c6ebec9173eb538149c2a5f358e6bad85c0ed6993ed6b91a62a46f8d3551881ffaba4551b80df79c13a2
-  data.tar.gz: dd96665fc956cf1a76444e75287c2661b3629c0d0cc5546f44ed464533a50b8ff830e354d1caa83782c53855446f6e0043039ae09489fef8b5f33eeaa73329c0
+  metadata.gz: c3b230ef35186d4f96714ba708b933cf7897166a74b7162949a3144aa21dc79aab2446a0b14d1e0504ea30f941146a7e0f1841d5908e6a6175d771a9b4a658ad
+  data.tar.gz: 9d476bdbaf46cef516cd51adb218097137863fb12976e98d87a7c8d7f77e3609421d81ba14ed77d67cd59054d4356690d088b619e8e089964cd4fdd6055225ac

data/README.md

@@ -62,6 +62,7 @@ end
 ```
 
 This creates the following routes:
+
 - `GET /users` → `users#index`
 - `GET /users/new` → `users#new`
 - `POST /users` → `users#create`

data/lib/ruby_routes/constant.rb

@@ -0,0 +1,57 @@
+require_relative 'segments/dynamic_segment'
+require_relative 'segments/static_segment'
+require_relative 'segments/wildcard_segment'
+require_relative 'lru_strategies/hit_strategy'
+require_relative 'lru_strategies/miss_strategy'
+
+module RubyRoutes
+  module Constant
+    SEGMENTS = {
+      42 => RubyRoutes::Segments::WildcardSegment,   # '*'
+      58 => RubyRoutes::Segments::DynamicSegment,    # ':'
+      :default => RubyRoutes::Segments::StaticSegment
+    }.freeze
+
+    SEGMENT_MATCHERS = {
+      static: lambda do |node, segment, _idx, _segments, _params|
+        child = node.static_children[segment]
+        child ? [child, false] : nil
+      end,
+
+      dynamic: lambda do |node, segment, _idx, _segments, params|
+        return nil unless node.dynamic_child
+        nxt = node.dynamic_child
+        params[nxt.param_name.to_s] = segment if params && nxt.param_name
+        [nxt, false]
+      end,
+
+      wildcard: lambda do |node, _segment, idx, segments, params|
+        return nil unless node.wildcard_child
+        nxt = node.wildcard_child
+        params[nxt.param_name.to_s] = segments[idx..-1].join('/') if params && nxt.param_name
+        [nxt, true]
+      end,
+
+      # default returns nil (no match). RadixTree#find will then return [nil, {}].
+      default: lambda { |_node, _segment, _idx, _segments, _params| nil }
+    }.freeze
+
+    # singleton instances to avoid per-LRU allocations
+    LRU_HIT_STRATEGY = RubyRoutes::LruStrategies::HitStrategy.new.freeze
+    LRU_MISS_STRATEGY = RubyRoutes::LruStrategies::MissStrategy.new.freeze
+
+    # Descriptor factories for segment classification (O(1) dispatch by first byte).
+    DESCRIPTOR_FACTORIES = {
+      42 => ->(s) { { type: :splat,  name: (s[1..-1] || 'splat') } }, # '*'
+      58 => ->(s) { { type: :param,  name:   s[1..-1] } },             # ':'
+      :default => ->(s) { { type: :static, value:  s } }
+    }.freeze
+
+    def self.segment_descriptor(raw)
+      s = raw.to_s
+      key = s.empty? ? :default : s.getbyte(0)
+      factory = DESCRIPTOR_FACTORIES[key] || DESCRIPTOR_FACTORIES[:default]
+      factory.call(s)
+    end
+  end
+end

data/lib/ruby_routes/lru_strategies/hit_strategy.rb

@@ -0,0 +1,13 @@
+module RubyRoutes
+  module LruStrategies
+    class HitStrategy
+      def call(lru, key)
+        lru.increment_hits
+        h = lru.instance_variable_get(:@h)
+        val = h.delete(key)
+        h[key] = val
+        val
+      end
+    end
+  end
+end

data/lib/ruby_routes/lru_strategies/miss_strategy.rb

@@ -0,0 +1,10 @@
+module RubyRoutes
+  module LruStrategies
+    class MissStrategy
+      def call(lru, _key)
+        lru.increment_misses
+        nil
+      end
+    end
+  end
+end

data/lib/ruby_routes/node.rb

@@ -0,0 +1,56 @@
+require_relative 'segment'
+
+module RubyRoutes
+  class Node
+    attr_accessor :static_children, :dynamic_child, :wildcard_child,
+                  :handlers, :param_name, :is_endpoint
+
+    def initialize
+      @static_children = {}
+      @dynamic_child = nil
+      @wildcard_child = nil
+      @handlers = {}
+      @param_name = nil
+      @is_endpoint = false
+    end
+
+    # Traverse for a single segment using the matcher registry.
+    # Returns [next_node_or_nil, should_break_bool] or [nil, false] if no match.
+    def traverse_for(segment, index, segments, params)
+      # Prefer static children first (exact match).
+      if @static_children.key?(segment)
+        return [@static_children[segment], false]
+      end
+
+      # Then dynamic param child (single segment)
+      if @dynamic_child
+        next_node = @dynamic_child
+        if params
+          params[next_node.param_name.to_s] = segment
+        end
+        return [next_node, false]
+      end
+
+      # Then wildcard child (consume remainder)
+      if @wildcard_child
+        next_node = @wildcard_child
+        if params
+          params[next_node.param_name.to_s] = segments[index..-1].join('/')
+        end
+        return [next_node, true]
+      end
+
+      # No match at this node
+      [nil, false]
+    end
+
+    def add_handler(method, handler)
+      @handlers[method.to_s] = handler
+      @is_endpoint = true
+    end
+
+    def get_handler(method)
+      @handlers[method.to_s]
+    end
+  end
+end

data/lib/ruby_routes/radix_tree.rb

@@ -0,0 +1,119 @@
+require_relative 'segment'
+
+module RubyRoutes
+  class RadixTree
+    class << self
+      # Allow RadixTree.new(path, options...) to act as a convenience factory
+      # returning a Route (this matches test usage where specs call
+      # RadixTree.new('/path', to: 'controller#action')).
+      # Calling RadixTree.new with no arguments returns an actual RadixTree instance.
+      def new(*args, &block)
+        if args.any?
+          # Delegate to Route initializer when args are provided
+          RubyRoutes::Route.new(*args, &block)
+        else
+          super()
+        end
+      end
+    end
+
+    def initialize
+      @root = Node.new
+      @_split_cache = {}           # simple LRU: key -> [value, age]
+      @split_cache_order = []      # track order for eviction
+      @split_cache_max = 1024
+    end
+
+    def add(path, methods, handler)
+      current = @root
+      parse_segments(path).each do |seg|
+        current = seg.ensure_child(current)
+        break if seg.wildcard?
+      end
+
+      methods.each { |method| current.add_handler(method, handler) }
+    end
+
+    def parse_segments(path)
+      split_path(path).map { |s| RubyRoutes::Segment.for(s) }
+    end
+
+    def find(path, method, params_out = nil)
+      segments = split_path(path)
+      current = @root
+      params = params_out || {}
+      params.clear if params_out
+
+      segments.each_with_index do |text, idx|
+        next_node, should_break = current.traverse_for(text, idx, segments, params)
+        return [nil, {}] unless next_node
+        current = next_node
+        break if should_break
+      end
+
+      handler = current.get_handler(method)
+      return [nil, {}] unless current.is_endpoint && handler
+
+      # lightweight constraint checks: reject early if route constraints don't match
+      route = handler
+      if route.respond_to?(:constraints) && route.constraints.any?
+        unless constraints_match?(route.constraints, params)
+          return [nil, {}]
+        end
+      end
+
+      [handler, params]
+    end
+
+    private
+
+    # faster, lower-allocation trim + split
+    def split_path(path)
+      @split_cache ||= {}
+      return [''] if path == '/'
+      if (cached = @split_cache[path])
+        return cached
+      end
+
+      p = path
+      p = p[1..-1] if p.start_with?('/')
+      p = p[0...-1] if p.end_with?('/')
+      segs = p.split('/')
+
+      # simple LRU insert
+      @split_cache[path] = segs
+      @split_cache_order << path
+      if @split_cache_order.size > @split_cache_max
+        oldest = @split_cache_order.shift
+        @split_cache.delete(oldest)
+      end
+
+      segs
+    end
+
+    # constraints match helper (non-raising, lightweight)
+    def constraints_match?(constraints, params)
+      constraints.each do |param, constraint|
+        value = params[param.to_s] || params[param]
+        next unless value
+
+        case constraint
+        when Regexp
+          return false unless constraint.match?(value)
+        when Proc
+          return false unless constraint.call(value)
+        when Symbol
+          case constraint
+          when :int then return false unless value.match?(/^\d+$/)
+          when :uuid then return false unless value.match?(/^[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}$/i)
+          else
+            # unknown symbol constraint — be conservative and allow
+          end
+        else
+          # unknown constraint type — allow (Route will validate later if needed)
+        end
+      end
+      true
+    end
+  end
+end

data/lib/ruby_routes/route/small_lru.rb

@@ -0,0 +1,43 @@
+module RubyRoutes
+  class Route
+    # small LRU used for path generation cache
+    class SmallLru
+      attr_reader :hits, :misses, :evictions
+
+      # larger default to reduce eviction likelihood in benchmarks
+      def initialize(max_size = 1024)
+        @max_size = max_size
+        @h = {}
+        @hits = 0
+        @misses = 0
+        @evictions = 0
+
+        @hit_strategy = RubyRoutes::Constant::LRU_HIT_STRATEGY
+        @miss_strategy = RubyRoutes::Constant::LRU_MISS_STRATEGY
+      end
+
+      def get(key)
+        strategy = @h.key?(key) ? @hit_strategy : @miss_strategy
+        strategy.call(self, key)
+      end
+
+      def set(key, val)
+        @h.delete(key) if @h.key?(key)
+        @h[key] = val
+        if @h.size > @max_size
+          @h.shift
+          @evictions += 1
+        end
+        val
+      end
+
+      def increment_hits
+        @hits += 1
+      end
+
+      def increment_misses
+        @misses += 1
+      end
+    end
+  end
+end

data/lib/ruby_routes/route.rb

@@ -1,3 +1,6 @@
+require 'uri'
+require_relative 'route/small_lru'
+
 module RubyRoutes
   class Route
     attr_reader :path, :methods, :controller, :action, :name, :constraints, :defaults
@@ -9,27 +12,40 @@ module RubyRoutes
       @action = options[:action] || extract_action(options[:to])
       @name = options[:as]
       @constraints = options[:constraints] || {}
-      @defaults = options[:defaults] || {}
+      # pre-normalize defaults to string keys to avoid per-request transform_keys
+      @defaults = (options[:defaults] || {}).transform_keys(&:to_s)
 
       validate_route!
     end
 
     def match?(request_method, request_path)
       return false unless methods.include?(request_method.to_s.upcase)
-
-      path_params = extract_path_params(request_path)
-      path_params != nil
+      !!extract_path_params(request_path)
     end
 
-    def extract_params(request_path)
+    def extract_params(request_path, parsed_qp = nil)
       path_params = extract_path_params(request_path)
       return {} unless path_params
 
-      params = path_params.dup
-      # Convert symbol keys to string keys for consistency
-      string_defaults = defaults.transform_keys(&:to_s)
-      params.merge!(string_defaults)
-      params
+      # Reuse a thread-local hash to reduce allocations; return a dup to callers.
+      tmp = Thread.current[:ruby_routes_params] ||= {}
+      tmp.clear
+
+      # start with path params (they take precedence)
+      path_params.each { |k, v| tmp[k] = v }
+
+      # use provided parsed_qp if available, otherwise parse lazily only if needed
+      qp = parsed_qp
+      if qp.nil? && request_path.include?('?')
+        qp = query_params(request_path)
+      end
+      qp.each { |k, v| tmp[k] = v } if qp && !qp.empty?
+
+      # only set defaults for keys not already present
+      defaults.each { |k, v| tmp[k] = v unless tmp.key?(k) } if defaults
+
+      validate_constraints!(tmp)
+      tmp.dup
     end
 
     def named?
@@ -44,13 +60,111 @@ module RubyRoutes
       !resource?
     end
 
+    def parse_query_params(path)
+      query_params(path)
+    end
+
+    # Fast path generator: uses precompiled token list and a small LRU.
+    # Avoids unbounded cache growth and skips URI-encoding for safe values.
+    def generate_path(params = {})
+      return '/' if path == '/'
+
+      # build merged for only relevant param names, reusing a thread-local hash
+      tmp = Thread.current[:ruby_routes_merged] ||= {}
+      tmp.clear
+      defaults.each { |k, v| tmp[k] = v } if defaults
+      params.each { |k, v| tmp[k.to_s] = v } if params
+      merged = tmp
+
+      missing = compiled_required_params - merged.keys
+      raise RubyRoutes::RouteNotFound, "Missing params: #{missing.join(', ')}" unless missing.empty?
+
+      @gen_cache ||= SmallLru.new(256)
+      cache_key = cache_key_for(merged)
+      if (cached = @gen_cache.get(cache_key))
+        return cached
+      end
+
+      parts = compiled_segments.map do |seg|
+        case seg[:type]
+        when :static
+          seg[:value]
+        when :param
+          v = merged.fetch(seg[:name]).to_s
+          safe_encode_segment(v)
+        when :splat
+          v = merged.fetch(seg[:name], '')
+          arr = v.is_a?(Array) ? v : v.to_s.split('/')
+          arr.map { |p| safe_encode_segment(p.to_s) }.join('/')
+        end
+      end
+
+      out = '/' + parts.join('/')
+      out = '/' if out == ''
+
+      @gen_cache.set(cache_key, out)
+      out
+    end
+
     private
 
+    # compile helpers (memoize)
+    def compiled_segments
+      @compiled_segments ||= begin
+        if path == '/'
+          []
+        else
+          path.split('/').reject(&:empty?).map do |seg|
+            RubyRoutes::Constant.segment_descriptor(seg)
+          end
+        end
+      end
+    end
+
+    def compiled_required_params
+      @compiled_required_params ||= compiled_segments.select { |s| s[:type] != :static }
+                                                  .map { |s| s[:name] }.uniq
+                                                  .reject { |n| defaults.to_s.include?(n) }
+    end
+
+    # Cache key: deterministic param-order key (fast, stable)
+    def cache_key_for(merged)
+      # build key in route token order (parameters & splat) to avoid sorting/inspect
+      names = compiled_param_names
+      # build with single string buffer to avoid temporary arrays
+      buf = +""
+      names.each_with_index do |n, i|
+        val = merged[n]
+        part = if val.nil?
+                 ''
+               elsif val.is_a?(Array)
+                 val.map!(&:to_s) && val.join('/')
+               else
+                 val.to_s
+               end
+        buf << '|' unless i.zero?
+        buf << part
+      end
+      buf
+    end
+
+    def compiled_param_names
+      @compiled_param_names ||= compiled_segments.map { |s| s[:name] if s[:type] != :static }.compact
+    end
+
+    # Only URI-encode a segment when it contains unsafe chars.
+    UNRESERVED_RE = /\A[a-zA-Z0-9\-._~]+\z/
+    def safe_encode_segment(str)
+      # leave slash handling to splat logic (splats already split)
+      return str if UNRESERVED_RE.match?(str)
+      URI.encode_www_form_component(str)
+    end
+
     def normalize_path(path)
-      path = "/#{path}" unless path.start_with?('/')
-      # Remove trailing slash unless it's the root path
-      path = path.chomp('/') unless path == '/'
-      path
+      p = path.to_s
+      p = "/#{p}" unless p.start_with?('/')
+      p = p.chomp('/') unless p == '/'
+      p
     end
 
     def extract_controller(options)
@@ -67,26 +181,58 @@ module RubyRoutes
     end
 
     def extract_path_params(request_path)
-      route_parts = path.split('/')
-      request_parts = request_path.split('/')
+      segs = compiled_segments # memoized compiled route tokens
+      return nil if segs.empty? && request_path != '/'
+
+      req = request_path
+      req = req[1..-1] if req.start_with?('/')
+      req = req[0...-1] if req.end_with?('/') && req != '/'
+      request_parts = req == '' ? [] : req.split('/')
 
-      return nil if route_parts.length != request_parts.length
+      return nil if segs.size != request_parts.size
 
       params = {}
-      route_parts.each_with_index do |route_part, index|
-        request_part = request_parts[index]
-
-        if route_part.start_with?(':')
-          param_name = route_part[1..-1]
-          params[param_name] = request_part
-        elsif route_part != request_part
-          return nil
+      segs.each_with_index do |seg, idx|
+        case seg[:type]
+        when :static
+          return nil unless seg[:value] == request_parts[idx]
+        when :param
+          params[seg[:name]] = request_parts[idx]
+        when :splat
+          params[seg[:name]] = request_parts[idx..-1].join('/')
+          break
         end
       end
 
       params
     end
 
+    def query_params(path)
+      qidx = path.index('?')
+      return {} unless qidx
+      qs = path[(qidx + 1)..-1] || ''
+      Rack::Utils.parse_query(qs)
+    end
+
+    def validate_constraints!(params)
+      constraints.each do |param, constraint|
+        value = params[param.to_s]
+        next unless value
+
+        case constraint
+        when Regexp
+          raise ConstraintViolation unless constraint.match?(value)
+        when Proc
+          raise ConstraintViolation unless constraint.call(value)
+        when Symbol
+          case constraint
+          when :int then raise ConstraintViolation unless value.match?(/^\d+$/)
+          when :uuid then raise ConstraintViolation unless value.match?(/^[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}$/i)
+          end
+        end
+      end
+    end
+
     def validate_route!
       raise InvalidRoute, "Controller is required" if controller.nil?
       raise InvalidRoute, "Action is required" if action.nil?

data/lib/ruby_routes/route_set.rb

@@ -3,18 +3,25 @@ module RubyRoutes
     attr_reader :routes
 
     def initialize
-      @routes = []
+      @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
     end
 
     def add_route(route)
       @routes << route
+      @tree.add(route.path, route.methods, route)
       @named_routes[route.name] = route if route.named?
       route
     end
 
     def find_route(request_method, request_path)
-      @routes.find { |route| route.match?(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)
+      handler
     end
 
     def find_named_route(name)
@@ -22,12 +29,44 @@ module RubyRoutes
     end
 
     def match(request_method, request_path)
-      route = find_route(request_method, request_path)
-      return nil unless route
+      # 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 }
+      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)
+      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
+
+      params = tmp.dup
+
+      # 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)
+      end
 
       {
         route: route,
-        params: route.extract_params(request_path),
+        params: params,
         controller: route.controller,
         action: route.action
       }
@@ -43,22 +82,14 @@ module RubyRoutes
     end
 
     def generate_path_from_route(route, params = {})
-      path = route.path.dup
-
-      params.each do |key, value|
-        path.gsub!(":#{key}", value.to_s)
-      end
-
-      # Remove any remaining :param placeholders
-      path.gsub!(/\/:[^\/]+/, '')
-      path.gsub!(/\/$/, '') if path != '/'
-
-      path
+      # Delegate to Route#generate_path which uses precompiled segments + cache
+      route.generate_path(params)
     end
 
     def clear!
       @routes.clear
       @named_routes.clear
+      @tree = RadixTree.new
     end
 
     def size

data/lib/ruby_routes/segment.rb

@@ -0,0 +1,20 @@
+require_relative 'segments/base_segment'
+require_relative 'segments/dynamic_segment'
+require_relative 'segments/static_segment'
+require_relative 'segments/wildcard_segment'
+require_relative 'constant'
+
+module RubyRoutes
+  class Segment
+    def self.for(text)
+      t = text.to_s
+      key = t.empty? ? :default : t.getbyte(0)
+      segment = RubyRoutes::Constant::SEGMENTS[key] || RubyRoutes::Constant::SEGMENTS[:default]
+      segment.new(t)
+    end
+
+    def wildcard?
+      false
+    end
+  end
+end

data/lib/ruby_routes/segments/base_segment.rb

@@ -0,0 +1,21 @@
+module RubyRoutes
+  module Segments
+    class BaseSegment
+      def initialize(text = nil)
+        @text = text.to_s if text
+      end
+
+      def wildcard?
+        false
+      end
+
+      def ensure_child(current)
+        raise NotImplementedError, "#{self.class}#ensure_child must be implemented"
+      end
+
+      def match(_node, _text, _idx, _segments, _params)
+        raise NotImplementedError, "#{self.class}#match must be implemented"
+      end
+    end
+  end
+end

data/lib/ruby_routes/segments/dynamic_segment.rb

@@ -0,0 +1,23 @@
+module RubyRoutes
+  module Segments
+    class DynamicSegment < BaseSegment
+      def initialize(text)
+        @name = text[1..-1]
+      end
+
+      def ensure_child(current)
+        current.dynamic_child ||= Node.new
+        current = current.dynamic_child
+        current.param_name = @name
+        current
+      end
+
+      def match(node, text, _idx, _segments, params)
+        return [nil, false] unless node.dynamic_child
+        nxt = node.dynamic_child
+        params[nxt.param_name.to_s] = text if params
+        [nxt, false]
+      end
+    end
+  end
+end

data/lib/ruby_routes/segments/static_segment.rb

@@ -0,0 +1,18 @@
+module RubyRoutes
+  module Segments
+    class StaticSegment < BaseSegment
+      def initialize(text)
+        @text = text
+      end
+
+      def ensure_child(current)
+        current.static_children[@text] ||= Node.new
+        current.static_children[@text]
+      end
+
+      def match(node, text, _idx, _segments, _params)
+        [node.static_children[text], false]
+      end
+    end
+  end
+end

data/lib/ruby_routes/segments/wildcard_segment.rb

@@ -0,0 +1,27 @@
+module RubyRoutes
+  module Segments
+    class WildcardSegment < BaseSegment
+      def initialize(text)
+        @name = (text[1..-1] || 'splat')
+      end
+
+      def ensure_child(current)
+        current.wildcard_child ||= Node.new
+        current = current.wildcard_child
+        current.param_name = @name
+        current
+      end
+
+      def wildcard?
+        true
+      end
+
+      def match(node, _text, idx, segments, params)
+        return [nil, false] unless node.wildcard_child
+        nxt = node.wildcard_child
+        params[nxt.param_name.to_s] = segments[idx..-1].join('/') if params
+        [nxt, true]
+      end
+    end
+  end
+end

data/lib/ruby_routes/version.rb

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

data/lib/ruby_routes.rb

@@ -4,6 +4,8 @@ require_relative "ruby_routes/route"
 require_relative "ruby_routes/route_set"
 require_relative "ruby_routes/url_helpers"
 require_relative "ruby_routes/router"
+require_relative "ruby_routes/radix_tree"
+require_relative "ruby_routes/node"
 
 module RubyRoutes
   class Error < StandardError; end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_routes
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Yosef Benny Widyokarsono
@@ -62,9 +62,20 @@ files:
 - LICENSE
 - README.md
 - lib/ruby_routes.rb
+- lib/ruby_routes/constant.rb
+- lib/ruby_routes/lru_strategies/hit_strategy.rb
+- lib/ruby_routes/lru_strategies/miss_strategy.rb
+- lib/ruby_routes/node.rb
+- lib/ruby_routes/radix_tree.rb
 - lib/ruby_routes/route.rb
+- lib/ruby_routes/route/small_lru.rb
 - lib/ruby_routes/route_set.rb
 - lib/ruby_routes/router.rb
+- lib/ruby_routes/segment.rb
+- lib/ruby_routes/segments/base_segment.rb
+- lib/ruby_routes/segments/dynamic_segment.rb
+- lib/ruby_routes/segments/static_segment.rb
+- lib/ruby_routes/segments/wildcard_segment.rb
 - lib/ruby_routes/string_extensions.rb
 - lib/ruby_routes/url_helpers.rb
 - lib/ruby_routes/version.rb