mustermann 4.0.0.alpha3 → 4.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c6a0beea1e6d365356c6444910ec10200dcaf98f1968e88ac2fe91e0a7b23b93
-  data.tar.gz: 1be43d10761af60bbd4cdd5d087214073984825b05f397de8d1475a7f35686d6
+  metadata.gz: a382e55dcc3919ca87dfa480d405b5fc126435c8081ce37e270a63e5907e7517
+  data.tar.gz: 4ec389e09c7a625fc83acf00fa9ff98a08e05cb58c1fb5c43772b14605a92e02
 SHA512:
-  metadata.gz: 710a7afa55bdbd0f6fb17845458572ea9adaf8149674c9b1e54ddba333382be9e05136d37d7680595bead97b21bee76334d129cbf96c320b0f975688b20ad29c
-  data.tar.gz: 64e15b87da6f731fce7d0e50eb4ee13511c175b979765d9a233a066c026026c0c82300e22b8492db8220d2f89995cadb471c78ac00da60ea8be360a22b8290be
+  metadata.gz: 7c8595c1df98b37d768691d0e1b591edd5a7b219aeff7569ee6e7e925b29ef2065125e7845d487e4b3aab68e2b7c06ffc7d696c74433a82b0d6012dd80a1d88e
+  data.tar.gz: 8f4bf30d82cd54534a5f4e31c1843868e1a0fe0112be8656167321b6554baac4d8455e947146c3ec5f9340f8af20ca8edd79499630a571b2a39851ddaef55f38

data/README.md

@@ -455,27 +455,6 @@ set.expand(id: '5')          # => '/users/5'  (first applicable pattern)
 set.expand(:posts, id: '5')  # => '/posts/5'  (patterns for a specific value)
 ```
 
-<a name="-duck-typing"></a>
-## Duck Typing
-
-<a name="-duck-typing-to-pattern"></a>
-### `to_pattern`
-
-All methods converting string input to pattern objects will also accept any arbitrary object that implements `to_pattern`:
-
-``` ruby
-require 'mustermann'
-
-class MyObject
-  def to_pattern(**options)
-    Mustermann.new("/foo", **options)
-  end
-end
-
-object = MyObject.new
-Mustermann.new(object, type: :rails) # => #<Mustermann::Rails:"/foo">
-```
-
 ### Match order
 
 A set can match patterns and values in loose or strict insertion order.
@@ -536,6 +515,27 @@ set.match("/static").value             # => :first
 set.match_all("/static").map(&:value)  # => [:first, :second, :third]
 ```
 
+<a name="-duck-typing"></a>
+## Duck Typing
+
+<a name="-duck-typing-to-pattern"></a>
+### `to_pattern`
+
+All methods converting string input to pattern objects will also accept any arbitrary object that implements `to_pattern`:
+
+``` ruby
+require 'mustermann'
+
+class MyObject
+  def to_pattern(**options)
+    Mustermann.new("/foo", **options)
+  end
+end
+
+object = MyObject.new
+Mustermann.new(object, type: :rails) # => #<Mustermann::Rails:"/foo">
+```
+
 <a name="-duck-typing-respond-to"></a>
 ### `respond_to?`
 
@@ -595,6 +595,99 @@ Mustermann.new('/:id.:ext', capture: { id: /\d+/, ext: ['png', 'jpg'] })
 
 Available POSIX character classes are: `:alnum`, `:alpha`, `:blank`, `:cntrl`, `:digit`, `:graph`, `:lower`, `:print`, `:punct`, `:space`, `:upper`, `:xdigit`, `:word` and `:ascii`.
 
+#### Typed Captures
+
+Certain Ruby classes and named symbols can be passed as a capture value. They constrain what the capture matches **and** automatically convert the captured string in `params` to the appropriate type.
+
+``` ruby
+require 'mustermann'
+require 'date'
+
+# Integer: only matches integers, converts to Integer in params
+pattern = Mustermann.new('/:id', capture: Integer)
+pattern.match('/42')    # matches
+pattern.match('/foo')   # does not match
+pattern.params('/42')   # => { "id" => 42 }
+
+# Float: matches integers and decimals, converts to Float in params
+pattern = Mustermann.new('/:price', capture: Float)
+pattern.params('/3.14') # => { "price" => 3.14 }
+pattern.params('/5')    # => { "price" => 5.0 }
+
+# Symbol: only matches word characters (\w+), converts to Symbol in params
+pattern = Mustermann.new('/:format', capture: Symbol)
+pattern.params('/json')       # => { "format" => :json }
+pattern.match('/with-hyphen') # does not match
+
+# Date: only matches YYYY-MM-DD dates, converts to Date in params
+pattern = Mustermann.new('/:date', capture: Date)
+pattern.params('/2026-04-23') # => { "date" => #<Date: 2026-04-23> }
+pattern.match('/04-23-2026')  # does not match
+
+# Gem::Version: matches version strings, converts to Gem::Version in params
+require 'rubygems/version'
+pattern = Mustermann.new('/:version', capture: Gem::Version)
+pattern.params('/1.2.3') # => { "version" => #<Gem::Version "1.2.3"> }
+```
+
+Lowercase symbol aliases are also available: `:integer`, `:float`, `:symbol`, `:date`, `:version`. They behave identically to their class counterparts:
+
+``` ruby
+pattern = Mustermann.new('/:id', capture: :integer)
+pattern.params('/42') # => { "id" => 42 }
+```
+
+These can be mixed with other capture types in a hash:
+
+``` ruby
+pattern = Mustermann.new('/:id(.:format)?', capture: { id: Integer, format: :slug })
+pattern.params('/42')      # => { "id" => 42, "format" => nil }
+pattern.params('/42.json') # => { "id" => 42, "format" => "json" }
+```
+
+Like all other capture types, these can also be used in an array:
+
+``` ruby
+pattern = Mustermann.new('/score/:score', capture: [Integer, Float])
+pattern.params('/42')   # => { "score" => 42 }
+pattern.params('/3.14') # => { "score" => 3.14 }
+```
+
+#### Other Symbols
+
+The following symbols constrain the capture with a regex but do **not** perform any type conversion — `params` still returns a string:
+
+| Symbol    | Matches |
+|-----------|---------|
+| `:locale` | BCP 47 language tags (`en`, `en-US`, `zh-Hans-CN`) |
+| `:slug`   | Lowercase URL slugs (`hello-world`, `foo-bar-baz`) |
+| `:uuid`   | UUIDs (`f47ac10b-58cc-4372-a567-0e02b2c3d479`, case-insensitive) |
+
+``` ruby
+Mustermann.new('/:lang', capture: :locale).match('/zh-Hans-CN') # matches
+Mustermann.new('/:slug', capture: :slug).match('/Hello')        # does not match
+Mustermann.new('/:id',   capture: :uuid).match('/not-a-uuid')   # does not match
+```
+
+Again, these can be mixed with other capture types in a hash or array:
+
+```ruby
+set = Mustermann::Set.new(capture: { id: [Integer, :uuid], locale: :locale })
+
+set.add("(/:locale)?/:id", :show)
+set.add("/(:locale)?", :index)
+
+# without capture constraints, this would match the :show pattern instead
+match = set.match('/en')
+match.value # => :index
+
+match = set.match('/f47ac10b-58cc-4372-a567-0e02b2c3d479')
+match.value # => :show
+
+match = set.match('/en/12')
+match.value # => :show
+```
+
 <a name="-available-options--except"></a>
 ### `except`
 

data/lib/mustermann/ast/compiler.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'mustermann/ast/translator'
+require 'mustermann/ast/converters'
 
 module Mustermann
   # @see Mustermann::AST::Pattern
@@ -99,46 +100,48 @@ module Mustermann
           when Hash   then from_hash(capture, **options)
           when String then from_string(capture, **options)
           when nil    then from_nil(**options)
-          else capture
+          when Regexp then capture
+          when Class  then from_class(capture, **options)
+          else raise CompileError, "invalid capture constraint %p for %p" % [capture, name]
           end
         end
 
         private
 
-        def qualified(string, greedy: true,
-                      **options) "#{string}#{qualifier || "+#{'?' unless greedy}"}"
+        def qualified(string, greedy: true, **options)
+          "#{string}#{qualifier || "+#{'?' unless greedy}"}"
         end
 
-        def with_lookahead(string, lookahead: nil,
-                           **options) lookahead ? "(?:(?!#{lookahead})#{string})" : string
+        def with_lookahead(string, lookahead: nil, **options)
+          lookahead ? "(?:(?!#{lookahead})#{string})" : string
         end
 
-        def from_hash(hash,
-                      **options) pattern(capture: hash[name.to_sym],
-                                         **options)
+        def from_hash(hash, **options)
+          pattern(capture: hash[name.to_sym], **options)
         end
 
         def from_array(array, **options)
-          Regexp.union(*array.map do |e|
-            pattern(capture: e, **options)
-          end)
+          Regexp.union(*array.map { |e| pattern(capture: e, **options) })
         end
 
-        def from_symbol(symbol,
-                        **options) qualified(with_lookahead("[[:#{symbol}:]]", **options),
-                                             **options)
+        def from_symbol(symbol, **options)
+          capture, _ = CONVERTERS[symbol]
+          return pattern(capture:, **options) if capture
+          qualified(with_lookahead("[[:#{symbol}:]]", **options), **options)
         end
 
         def from_string(string, **options)
-          Regexp.new(string.chars.map do |c|
-            t.encoded(c, **options)
-          end.join)
+          Regexp.new(string.chars.map { |c| t.encoded(c, **options) }.join)
         end
 
         def from_nil(**options)
-          qualified(
-            with_lookahead(default(**options), **options), **options
-          )
+          qualified(with_lookahead(default(**options), **options), **options)
+        end
+
+        def from_class(klass, **options)
+          capture, _ = CONVERTERS[klass.name]
+          raise CompileError, "no converter for class %p" % klass unless capture
+          pattern(capture:, **options)
         end
 
         def default(**options) = constraint || '[^/\\?#]'

data/lib/mustermann/ast/converters.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+require "rubygems/version"
+require "date"
+
+module Mustermann
+  module AST
+    CONVERTERS = {
+      "Integer" => [ /-?\d+/,           :to_i   ],
+      "Symbol"  => [ /\w+/,             :to_sym ],
+      "String"  => [ nil,               :to_s   ],
+      "Float"   => [ /-?\d+(?:\.\d+)?/, :to_f   ],
+
+      "Date"    => [
+        /\d{4}-\d{2}-\d{2}/,
+        ->(string) { Date.parse(string) }
+      ],
+
+      "Gem::Version" => [
+        Regexp.new(Gem::Version::VERSION_PATTERN),
+        ->(string) { Gem::Version.new(string) }
+      ],
+
+      locale: [ /(?:[A-Za-z]{2,3}|i)(-[A-Za-z0-9]{1,8})*/ ],
+      slug:   [ /[a-z0-9]+(?:-[a-z0-9]+)*/ ],
+      uuid:   [ /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i ],
+    }
+
+    CONVERTERS.merge!({
+      integer: CONVERTERS["Integer"],
+      symbol:  CONVERTERS["Symbol"],
+      string:  CONVERTERS["String"],
+      float:   CONVERTERS["Float"],
+      date:    CONVERTERS["Date"],
+      version: CONVERTERS["Gem::Version"],
+    })
+
+    CONVERTERS.freeze
+
+    private_constant :CONVERTERS
+  end
+end

data/lib/mustermann/ast/fast_pattern.rb

@@ -34,7 +34,7 @@ module Mustermann
         return unless match = @regexp.match(string)
         params = match.named_captures
         params.transform_values! { |v| unescape(v) } if string.include?('%')
-        Match.new(self, string, params)
+        Match.new(self, match, params:)
       end
 
       # Public override: fast path for simple patterns, falls through to super otherwise.

data/lib/mustermann/ast/param_scanner.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require 'mustermann/ast/converters'
 require 'mustermann/ast/translator'
 
 module Mustermann
@@ -8,14 +9,45 @@ module Mustermann
     # @see Mustermann::AST::Pattern#to_templates
     class ParamScanner < Translator
       # @!visibility private
-      def self.scan_params(ast)
-        new.translate(ast)
+      def self.scan_params(ast, options)
+        new.translate(ast, options)
       end
 
-      translate(:node)    { t(payload) }
-      translate(Array)    { map { |e| t(e) }.inject(:merge) }
-      translate(Object)   { {} }
-      translate(:capture) { convert ? { name => convert } : {} }
+      translate(:node)             { |o| t(payload, o) }
+      translate(:with_look_ahead)  { |o| t(head, o).merge(t(payload, o)) }
+      translate(Array)             { |o| map { |e| t(e, o) }.inject(:merge) }
+      translate(Object)            { |o| {} }
+
+      class Capture < NodeTranslator
+        register :capture
+
+        def translate(options)
+          return { name => convert } if convert
+          _, converter = converter(options[:capture])
+          converter ? { name => converter } : {}
+        end
+
+        def converter(capture)
+          case capture
+          when Hash   then return converter(capture[name.to_sym])
+          when Class  then regexp, converter = CONVERTERS[capture.name]
+          when Symbol then regexp, converter = CONVERTERS[capture]
+          when Array
+            entries = capture.map { |item| converter(item) }.compact
+            regexp  = Regexp.union(entries.map(&:first))
+
+            entries.map! { |r, c| [/\A#{r}\Z/, c] }
+
+            converter = ->(string) do
+              _, c = entries.find { |r, _| r.match?(string) }
+              c&.call(string) || string
+            end
+          end
+
+          return unless converter
+          [regexp, converter.to_proc]
+        end
+      end
     end
   end
 end

data/lib/mustermann/ast/pattern.rb

@@ -101,13 +101,13 @@ module Mustermann
       # Internal AST representation of pattern.
       # @!visibility private
       def to_ast
-        ast = self.class.ast_cache.fetch(@string) do
+        ast = self.class.ast_cache.fetch([@string, options]) do
           ast   = parse(@string, pattern: self)
           ast &&= transform(ast)
           ast &&= set_boundaries(ast, string: @string)
           validate(ast)
         end
-        @param_converters ||= scan_params(ast) if ast
+        @param_converters ||= scan_params(ast, options) if ast
         ast
       end
 
@@ -143,7 +143,7 @@ module Mustermann
 
       # @!visibility private
       def param_converters
-        @param_converters ||= scan_params(to_ast)
+        @param_converters ||= scan_params(to_ast, options)
       end
 
       # @api private

data/lib/mustermann/ast/transformer.rb

@@ -22,6 +22,13 @@ module Mustermann
         node
       end
 
+      # eliminate redundant optional nodes - this helps avoid regexp warnings
+      translate(:optional) do
+        return t(payload) if payload.is_a? Node[:optional]
+        node.payload = t(payload)
+        node
+      end
+
       # ignore unknown objects on the tree
       translate(Object) { node }
 

data/lib/mustermann/concat.rb

@@ -75,16 +75,21 @@ module Mustermann
 
     # @see Mustermann::Pattern#peek_match
     def peek_match(string)
-      substring = string
-      params = {}
+      post_match      = string
+      params         = {}
+      captures       = []
+      named_captures = {}
 
       patterns.each do |pattern|
-        return unless part = pattern.peek_match(substring)
+        return unless part = pattern.peek_match(post_match)
         params.merge!(part.params)
-        substring = substring[part.to_s.size..-1]
+        named_captures.merge!(part.named_captures)
+        captures.concat(part.captures)
+        post_match = post_match[part.to_s.size..-1]
       end
 
-      Match.new(self, string[0, string.size - substring.size], params, post_match: substring)
+      matched = string[0, string.size - post_match.size]
+      Match.new(self, string, matched:, params:, captures:, named_captures:, post_match:)
     end
 
     # @see Mustermann::Pattern#peek_params

data/lib/mustermann/match.rb

@@ -1,39 +1,136 @@
 # frozen_string_literal: true
 
 module Mustermann
+  # The return value of {Mustermann::Pattern#match}, {Mustermann::Pattern#peek_match}, {Mustermann::Set#match}, and similar methods.
+  # Mimics large parts of the MatchData API, but also provides access to the pattern and params hash.
   class Match
-    attr_reader :pattern, :string, :params, :post_match, :pre_match
-
-    def initialize(pattern, string, params = {}, post_match: '', pre_match: '')
-      @pattern    = pattern
-      @string     = string.freeze
-      @params     = params.freeze
-      @post_match = post_match.freeze
-      @pre_match  = pre_match.freeze
+    # @return [Mustermann::Pattern] the pattern that produced the match
+    attr_reader :pattern
+
+    # @return [String] the string that was matched
+    attr_reader :string
+
+    # @return [Hash] the params hash
+    attr_reader :params
+
+    # @return [Array] the captures array
+    attr_reader :captures
+
+    # @return [Hash] the named captures hash, usually identical to {#params}
+    attr_reader :named_captures
+
+    # @return [String] the post match string
+    attr_reader :post_match
+
+    # @return [String] the pre match string
+    attr_reader :pre_match
+
+    # @return [Regexp, nil] the regular expression that produced the match, if available
+    attr_reader :regexp
+
+    # @overload initialize(pattern, string, **options)
+    #   @param pattern [Mustermann::Pattern] the pattern that produced the match
+    #   @param string [String] the string that was matched
+    #
+    # @overload initialize(match, **options)
+    #   @param match [Mustermann::Match] the match to copy pattern and string from
+    #
+    # @overload initialize(pattern, match, **options)
+    #   @param match [Mustermann::Match, MatchData] the match to copy string from
+    #
+    # @option options [Array]  :captures the captures array
+    # @option options [Hash]   :named_captures the named captures hash
+    # @option options [String] :matched the matched substring (defaults to string for full matches)
+    # @option options [Hash]   :params the params hash
+    # @option options [Regexp] :regexp the regular expression that produced the match
+    # @option options [String] :post_match the post match string
+    # @option options [String] :pre_match the pre match string
+    def initialize(pattern_or_match, string_or_match = nil, matched: nil, params: nil, post_match: nil, pre_match: nil, captures: nil, named_captures: nil, regexp: nil)
+      case pattern_or_match
+      when Mustermann::Match, MatchData then match = pattern_or_match
+      when Mustermann::Pattern          then pattern = pattern_or_match
+      else raise ArgumentError, "first argument must be a Mustermann::Pattern or a MatchData, not #{pattern_or_match.class}"
+      end
+
+      case string_or_match
+      when Mustermann::Match, MatchData then match ||= string_or_match
+      when String                       then string = string_or_match
+      when nil # ignore
+      else raise ArgumentError, "second argument must be a String or a MatchData, not #{string_or_match.class}"
+      end
+
+      @pattern        = pattern        || match&.pattern
+      @string         = string         || match&.string         || ''
+      @params         = params         || match&.params         || {}
+      @post_match     = post_match     || match&.post_match     || ''
+      @pre_match      = pre_match      || match&.pre_match      || ''
+      @captures       = captures       || match&.captures       || @params.values
+      @named_captures = named_captures || match&.named_captures || @params
+      @matched        = matched        || match&.to_s           || @string
+
+      unless @regexp = regexp
+        @regexp = match.regexp if match.respond_to?(:regexp)
+        @regexp ||= pattern.respond_to?(:regexp) ? pattern.regexp : nil
+      end
     end
 
-    def [](key)
+    # @return [Array<String>] the names of the named captures
+    def names = named_captures.keys
+
+    # @overload [](key)
+    #   Access named captures by key.
+    #   @param key [String, Symbol] the key to access
+    #   @return the value of the named capture, or nil if not found
+    #
+    # @overload [](index)
+    #   Access captures by index.
+    #   @param index [Integer] the index to access
+    #   @return the value of the capture, or nil if not found
+    #
+    # @overload [](start, length)
+    #   Access multiple captures by index and length.
+    #   @param start [Integer] the starting index to access
+    #   @param length [Integer] the number of captures to access
+    #   @return [Array] the values of the captures
+    #
+    # @overload [](range)
+    #   Access multiple captures by range.
+    #   @param range [Range] the range of indices to access
+    #   @return [Array] the values of the captures
+    def [](key, length = nil)
       case key
-      when String  then params[key]
-      when Symbol  then params[key.to_s]
-      else raise ArgumentError, "key must be a String or Symbol, not #{key.class}"
+      when String  then named_captures[key]
+      when Symbol  then named_captures[key.to_s]
+      when Integer then length ? captures[key, length] : captures[key]
+      when Range   then captures[key]
+      else raise ArgumentError, "key must be a String, Symbol, Integer, or Range, not #{key.class}"
       end
     end
-    
+
+    # Deconstructs the match into a hash of the given keys. Useful for pattern matching.
+    # @param keys [Array] the keys to deconstruct
+    # @return [Hash] a hash of the given keys and their corresponding values
+    # @see https://docs.ruby-lang.org/en/4.0/syntax/pattern_matching_rdoc.html
     def deconstruct_keys(keys) = keys.to_h { |key| [key, self[key]] }
 
+    # @see Object#hash
     def hash = pattern.hash ^ string.hash ^ params.hash
 
+    # @see Object#eql?
     def eql?(other)
       return false unless other.is_a? self.class
       pattern == other.pattern && string == other.string && params == other.params
     end
 
+    # Returns the values of the given keys as an array.
+    # @params keys [Array<Symbol, String>] the keys to access
+    # @return [Array] the values of the given keys
     def values_at(*keys) = keys.map { |key| self[key] }
 
+    # @return [String] the matched substring (like MatchData#to_s)
+    def to_s = @matched
+
     alias == eql?
-    alias to_s string
     alias to_h params
-
   end
 end

data/lib/mustermann/pattern.rb

@@ -165,7 +165,7 @@ module Mustermann
     # @see #peek_params
     def peek_match(string)
       matched = peek(string)
-      Match.new(self, matched, {}, post_match: string[matched.size..-1]) if matched
+      Match.new(self, string, matched:, params: {}, post_match: string[matched.size..-1]) if matched
     end
 
     # Tries to match the pattern against the beginning of the string (as opposed to the full string).
@@ -182,7 +182,7 @@ module Mustermann
     # @return [Array<Hash, Integer>, nil] Array with params hash and length of substing if matched, nil otherwise
     def peek_params(string)
       match = peek_match(string)
-      match ? [match.params, match.string.size] : nil
+      match ? [match.params, match.to_s.size] : nil
     end
 
     # @param [String] string the string to match against

data/lib/mustermann/regexp_based.rb

@@ -35,10 +35,10 @@ module Mustermann
     # @see (see Mustermann::Pattern#peek_match)
     def peek_match(string) = build_match(@peek_regexp.match(string))
 
-    def match(string)
-      return unless match = @regexp.match(string)
-      Match.new(self, string, build_params(match))
-    end
+    # @param (see Mustermann::Pattern#match)
+    # @return (see Mustermann::Pattern#match)
+    # @see (see Mustermann::Pattern#match)
+    def match(string) = build_match(@regexp.match(string))
 
     extend Forwardable
     def_delegators :regexp, :===, :=~, :names
@@ -47,7 +47,7 @@ module Mustermann
 
     def build_match(match)
       return unless match
-      Match.new(self, match.to_s, build_params(match), post_match: match.post_match, pre_match: match.pre_match)
+      Match.new(self, match, params: build_params(match))
     end
 
     def build_params(match)

data/lib/mustermann/set/linear.rb

@@ -17,9 +17,9 @@ module Mustermann
         result = [] if all
         @patterns.each do |pattern|
           next unless match = peek ? pattern.peek_match(string) : pattern.match(string)
-          return Match.new(match:, value: @set.values_for_pattern(pattern)&.first) unless all
+          return Match.new(match, value: @set.values_for_pattern(pattern)&.first) unless all
           values = @set.values_for_pattern(pattern) || [nil]
-          values.each { |value| result << Match.new(match:, value:) }
+          values.each { |value| result << Match.new(match, value:) }
         end
         result
       end

data/lib/mustermann/set/match.rb

@@ -3,21 +3,21 @@ require 'mustermann/match'
 
 module Mustermann
   class Set
+
+    # Subclass of {Mustermann::Match} that also includes the value associated with the pattern that produced the match.
     class Match < Mustermann::Match
+      # @return the value associated with the pattern that produced the match, if any
       attr_reader :value
 
-      def initialize(pattern = nil, string = nil, params = {}, value: nil, match: nil, post_match: '', pre_match: '')
+      # (see Mustermann::Match#initialize)
+      # @option options [Object] :value the value associated with the pattern that produced the match, if any
+      def initialize(*, value: nil, **)
         @value = value
-        if match
-          @pattern    = match.pattern
-          @string     = match.string
-          @params     = match.params
-          @post_match = match.post_match
-          @pre_match  = match.pre_match
-        else
-          super(pattern, string, params, post_match:, pre_match:)
-        end
+        super(*, **)
       end
+
+      # @see Mustermann::Match#eql?
+      def eql?(other) = super && value == other.value
     end
   end
 end

data/lib/mustermann/set/trie.rb

@@ -148,7 +148,7 @@ module Mustermann
         end
 
         if peek
-          matches = build_matches(string[0, position], params, all:, post_match: string[position..], pre_match: '')
+          matches = build_matches(string, params, all:, matched_length: position, post_match: string[position..], pre_match: '')
           return matches unless all
           result.concat(matches)
         end
@@ -158,17 +158,18 @@ module Mustermann
 
       NIL_VALUES = [nil].freeze
 
-      def build_matches(string, params, all: false, post_match: '', pre_match: '')
+      def build_matches(string, params, all: false, matched_length: string.size, post_match: '', pre_match: '')
         result = [] if all
+        matched = string[0, matched_length]
 
         @patterns.each do |pattern|
-          next if pattern.except_regexp&.match?(string)
+          next if pattern.except_regexp&.match?(matched)
 
           pattern_params = build_pattern_params(pattern, params)
 
           values = @set.values_for_pattern(pattern) || NIL_VALUES
           values.each do |value|
-            match = Set::Match.new(pattern, string, pattern_params, value:, post_match:, pre_match:)
+            match = Set::Match.new(pattern, string, matched:, params: pattern_params, value:, post_match:, pre_match:)
             return match unless all
             result << match
           end

data/lib/mustermann/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Mustermann
-  VERSION ||= '4.0.0.alpha3'
+  VERSION ||= '4.0.0.beta1'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mustermann
 version: !ruby/object:Gem::Version
-  version: 4.0.0.alpha3
+  version: 4.0.0.beta1
 platform: ruby
 authors:
 - Konstantin Haase
@@ -29,6 +29,7 @@ files:
 - lib/mustermann.rb
 - lib/mustermann/ast/boundaries.rb
 - lib/mustermann/ast/compiler.rb
+- lib/mustermann/ast/converters.rb
 - lib/mustermann/ast/expander.rb
 - lib/mustermann/ast/fast_pattern.rb
 - lib/mustermann/ast/node.rb