mustermann19 0.3.1 → 0.3.1.1

data/lib/mustermann/flask.rb

@@ -0,0 +1,204 @@
+require 'mustermann/ast/pattern'
+
+module Mustermann
+  # Flask style pattern implementation.
+  #
+  # @example
+  #   Mustermann.new('/<foo>', type: :flask) === '/bar' # => true
+  #
+  # @see Mustermann::Pattern
+  # @see file:README.md#flask Syntax description in the README
+  class Flask < AST::Pattern
+    on(nil, ?>, ?:) { |c| unexpected(c) }
+
+    on(?<) do |char|
+      converter_name       = expect(/\w+/, char: char)
+      args, opts           = scan(?() ? read_args(?=, ?)) : [[], {}]
+
+      if scan(?:)
+        name = read_escaped(?>)
+      else
+        converter_name, name = 'default', converter_name
+        expect(?>)
+      end
+
+      converter   = pattern.converters.fetch(converter_name) { unexpected("converter %p" % converter_name) }
+      converter   = converter.new(*args, opts)    if converter.respond_to? :new
+      constraint  = converter.constraint          if converter.respond_to? :constraint
+      convert     = converter.convert             if converter.respond_to? :convert
+      qualifier   = converter.qualifier           if converter.respond_to? :qualifier
+      node_type   = converter.node_type           if converter.respond_to? :node_type
+      node_type ||= :capture
+
+      node(node_type, name, convert: convert, constraint: constraint, qualifier: qualifier)
+    end
+
+    # A class for easy creating of converters.
+    # @see Mustermann::Flask#register_converter
+    class Converter
+      # Constraint on the format used for the capture.
+      # Should be a regexp (or a string corresponding to a regexp)
+      # @see Mustermann::Flask#register_converter
+      attr_accessor :constraint
+
+      # Callback
+      # Should be a Proc.
+      # @see Mustermann::Flask#register_converter
+      attr_accessor :convert
+
+      # Constraint on the format used for the capture.
+      # Should be a regexp (or a string corresponding to a regexp)
+      # @see Mustermann::Flask#register_converter
+      # @!visibility private
+      attr_accessor :node_type
+
+      # Constraint on the format used for the capture.
+      # Should be a regexp (or a string corresponding to a regexp)
+      # @see Mustermann::Flask#register_converter
+      # @!visibility private
+      attr_accessor :qualifier
+
+      # @!visibility private
+      def self.create(&block)
+        Class.new(self) do
+          define_method(:initialize) { |*a| o = a.last.kind_of?(Hash) ? a.pop : {}; block[self, *a, o] }
+        end
+      end
+
+      # Makes sure a given value falls inbetween a min and a max.
+      # Uses the passed block to convert the value from a string to whatever
+      # format you'd expect.
+      #
+      # @example
+      #   require 'mustermann/flask'
+      #
+      #   class MyPattern < Mustermann::Flask
+      #     register_converter(:x) { between(5, 15, &:to_i) }
+      #   end
+      #
+      #   pattern = MyPattern.new('<x:id>')
+      #   pattern.params('/12') # => { 'id' => 12 }
+      #   pattern.params('/16') # => { 'id' => 15 }
+      #
+      # @see Mustermann::Flask#register_converter
+      def between(min, max)
+        self.convert = proc do |input|
+          value = yield(input)
+          value = yield(min) if min and value < yield(min)
+          value = yield(max) if max and value > yield(max)
+          value
+        end
+      end
+    end
+
+    # Generally available converters.
+    # @!visibility private
+    def self.converters(inherited = true)
+      return @converters ||= {} unless inherited
+      defaults = superclass.respond_to?(:converters) ? superclass.converters : {}
+      defaults.merge(converters(false))
+    end
+
+    # Allows you to register your own converters.
+    #
+    # It is reommended to use this on a subclass, so to not influence other subsystems
+    # using flask templates.
+    #
+    # The object passed in as converter can implement #convert and/or #constraint.
+    #
+    # It can also instead implement #new, which will then return an object responding
+    # to some of these methods. Arguments from the flask pattern will be passed to #new.
+    #
+    # If passed a block, it will be yielded to with a {Mustermann::Flask::Converter}
+    # instance and any arguments in the flask pattern.
+    #
+    # @example with simple object
+    #   require 'mustermann/flask'
+    #
+    #   MyPattern    = Class.new(Mustermann::Flask)
+    #   up_converter = Struct.new(:convert).new(:upcase.to_proc)
+    #   MyPattern.register_converter(:upper, up_converter)
+    #
+    #   MyPattern.new("/<up:name>").params('/foo') # => { "name" => "FOO" }
+    #
+    # @example with block
+    #   require 'mustermann/flask'
+    #
+    #   MyPattern    = Class.new(Mustermann::Flask)
+    #   MyPattern.register_converter(:upper) { |c| c.convert = :upcase.to_proc }
+    #
+    #   MyPattern.new("/<up:name>").params('/foo') # => { "name" => "FOO" }
+    #
+    # @example with converter class
+    #   require 'mustermann/flasl'
+    #
+    #   class MyPattern < Mustermann::Flask
+    #     class Converter
+    #       attr_reader :convert
+    #       def initialize(send: :to_s)
+    #         @convert = send.to_sym.to_proc
+    #       end
+    #     end
+    #
+    #     register_converter(:t, Converter)
+    #   end
+    #
+    #   MyPattern.new("/<t(send=upcase):name>").params('/Foo')   # => { "name" => "FOO" }
+    #   MyPattern.new("/<t(send=downcase):name>").params('/Foo') # => { "name" => "foo" }
+    #
+    # @param [#to_s] name converter name
+    # @param [#new, #convert, #constraint, nil] converter
+    def self.register_converter(name, converter = nil, &block)
+      converter ||= Converter.create(&block)
+      converters(false)[name.to_s] = converter
+    end
+
+    register_converter(:string) do |converter, options = {}|
+      minlength = options.delete(:minlength)
+      maxlength = options.delete(:maxlength)
+      length    = options.delete(:length)
+      converter.qualifier = "{%s,%s}" % [minlength || 1, maxlength] if minlength or maxlength
+      converter.qualifier = "{%s}"    % length if length
+    end
+
+    register_converter(:int) do |converter, options = {}|
+      min = options.delete(:min)
+      max = options.delete(:max)
+      fixed_digits = options.fetch(:fixed_digits, false)
+      options.delete(:fixed_digits)
+      converter.constraint = /\d/
+      converter.qualifier  = "{#{fixed_digits}}" if fixed_digits
+      converter.between(min, max) { |string| Integer(string) }
+    end
+
+    register_converter(:float) do |converter, options = {}|
+      min = options.delete(:min)
+      max = options.delete(:max)
+      converter.constraint = /\d*\.?\d+/
+      converter.qualifier  = ""
+      converter.between(min, max) { |string| Float(string) }
+    end
+
+    register_converter(:path) do |converter|
+      converter.node_type = :named_splat
+    end
+
+    register_converter(:any) do |converter, *strings|
+      strings              = strings.map { |s| Regexp.escape(s) unless s == {} }.compact
+      converter.qualifier  = ""
+      converter.constraint = Regexp.union(*strings)
+    end
+
+    register_converter(:default, converters['string'])
+
+    supported_options :converters
+    attr_reader :converters
+
+    def initialize(input, options = {})
+      converters = options[:converters] || {}
+      @converters = self.class.converters.dup
+      converters.each { |k,v| @converters[k.to_s] = v } if converters
+      super(input, options)
+    end
+  end
+end

data/lib/mustermann/identity.rb

@@ -1,4 +1,5 @@
 require 'mustermann/pattern'
+require 'mustermann/ast/node'
 
 module Mustermann
   # Matches strings that are identical to the pattern.
@@ -15,5 +16,58 @@ module Mustermann
     def ===(string)
       unescape(string) == @string
     end
+
+    # @param (see Mustermann::Pattern#peek_size)
+    # @return (see Mustermann::Pattern#peek_size)
+    # @see (see Mustermann::Pattern#peek_size)
+    def peek_size(string)
+      return unless unescape(string).start_with? @string
+      return @string.size if string.start_with? @string # optimization
+      @string.each_char.with_index.inject(0) do |count, (char, index)|
+        char_size = 1
+        escaped   = @@uri.escape(char, /./)
+        char_size = escaped.size if string[index, escaped.size].downcase == escaped.downcase
+        count + char_size
+      end
+    end
+
+    # URI templates support generating templates (the logic is quite complex, though).
+    #
+    # @example (see Mustermann::Pattern#to_templates)
+    # @param (see Mustermann::Pattern#to_templates)
+    # @return (see Mustermann::Pattern#to_templates)
+    # @see Mustermann::Pattern#to_templates
+    def to_templates
+      [@@uri.escape(to_s)]
+    end
+
+    # Generates an AST so it's compatible with {Mustermann::AST::Pattern}.
+    # Not used internally by {Mustermann::Identity}.
+    # @!visibility private
+    def to_ast
+      payload = @string.each_char.map { |c| AST::Node[c == ?/ ? :separator : :char].new(c) }
+      AST::Node[:root].new(payload, pattern: @string)
+    end
+
+    # Identity patterns support expanding.
+    #
+    # This implementation does not use {Mustermann::Expander} internally to save memory and
+    # compilation time.
+    #
+    # @example (see Mustermann::Pattern#expand)
+    # @param (see Mustermann::Pattern#expand)
+    # @return (see Mustermann::Pattern#expand)
+    # @raise (see Mustermann::Pattern#expand)
+    # @see Mustermann::Pattern#expand
+    # @see Mustermann::Expander
+    def expand(behavior = nil, values = {})
+      values, behavior = behavior, nil if behavior.kind_of?(Hash)
+      return to_s if values.empty? or behavior == :ignore
+      raise ExpandError,    "cannot expand with keys %p" % values.keys.sort if behavior == :raise
+      raise ArgumentError,  "unknown behavior %p"        % behavior         if behavior != :append
+      params    = values.map { |key, value| @@uri.escape(key.to_s) + "=" + @@uri.escape(value.to_s, /[^\w\d]/) }
+      separator = @string.include?(??) ? ?& : ??
+      @string + separator + params.join(?&)
+    end
   end
 end

data/lib/mustermann/pattern.rb

@@ -8,7 +8,9 @@ module Mustermann
   # @abstract
   class Pattern
     include Mustermann
+    @@uri ||= URI::Parser.new
 
+    PATTERN_METHODS = %w[expand to_templates].map(&:to_sym)
     # List of supported options.
     #
     # @overload supported_options
@@ -28,7 +30,7 @@ module Mustermann
 
     # @param [Symbol] option The option to check.
     # @return [Boolean] Whether or not option is supported.
-    def self.supported?(option)
+    def self.supported?(option, options = {})
       supported_options.include? option
     end
 
@@ -42,7 +44,7 @@ module Mustermann
       ignore_unknown_options = options.fetch(:ignore_unknown_options, false)
       options.delete(:ignore_unknown_options)
       unless ignore_unknown_options
-        unsupported = options.keys.detect { |key| not supported?(key) }
+        unsupported = options.keys.detect { |key| not supported?(key, options) }
         raise ArgumentError, "unsupported option %p for %p" % [unsupported, self] if unsupported
       end
 
@@ -93,13 +95,73 @@ module Mustermann
       raise NotImplementedError, 'subclass responsibility'
     end
 
-    # @return [Array<String>] capture names.
+    # Tries to match the pattern against the beginning of the string (as opposed to the full string).
+    # Will return the count of the matching characters if it matches.
+    #
+    # @example
+    #   pattern = Mustermann.new('/:name')
+    #   pattern.size("/Frank/Sinatra") # => 6
+    #
+    # @param [String] string The string to match against
+    # @return [Integer, nil] the number of characters that match
+    def peek_size(string)
+      # this is a very naive, unperformant implementation
+      string.size.downto(0).detect { |s| self === string[0, s] }
+    end
+
+    # Tries to match the pattern against the beginning of the string (as opposed to the full string).
+    # Will return the substring if it matches.
+    #
+    # @example
+    #   pattern = Mustermann.new('/:name')
+    #   pattern.peek("/Frank/Sinatra") # => "/Frank"
+    #
+    # @param [String] string The string to match against
+    # @return [String, nil] matched subsctring
+    def peek(string)
+      size = peek_size(string)
+      string[0, size] if size
+    end
+
+    # Tries to match the pattern against the beginning of the string (as opposed to the full string).
+    # Will return a MatchData or similar instance for the matched substring.
+    #
+    # @example
+    #   pattern = Mustermann.new('/:name')
+    #   pattern.peek("/Frank/Sinatra") # => #<MatchData "/Frank" name:"Frank">
+    #
+    # @param [String] string The string to match against
+    # @return [MatchData, Mustermann::SimpleMatch, nil] MatchData or similar object if the pattern matches.
+    # @see #peek_params
+    def peek_match(string)
+      matched = peek(string)
+      match(matched) if matched
+    end
+
+    # Tries to match the pattern against the beginning of the string (as opposed to the full string).
+    # Will return a two element Array with the params parsed from the substring as first entry and the length of
+    # the substring as second.
+    #
+    # @example
+    #   pattern   = Mustermann.new('/:name')
+    #   params, _ = pattern.peek_params("/Frank/Sinatra")
+    #
+    #   puts "Hello, #{params['name']}!" # Hello, Frank!
+    #
+    # @param [String] string The string to match against
+    # @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)
+      [params(nil, :captures => match), match.to_s.size] if match
+    end
+
+    # @return [Hash{String: Array<Integer>}] capture names mapped to capture index.
     # @see http://ruby-doc.org/core-2.0/Regexp.html#method-i-named_captures Regexp#named_captures
     def named_captures
       {}
     end
 
-    # @return [Hash{String: Array<Integer>}] capture names mapped to capture index.
+    # @return [Array<String>] capture names.
     # @see http://ruby-doc.org/core-2.0/Regexp.html#method-i-names Regexp#names
     def names
       []
@@ -109,8 +171,8 @@ module Mustermann
     # @return [Hash{String: String, Array<String>}, nil] Sinatra style params if pattern matches.
     def params(string = nil, options = {})
       options, string = string, nil if string.is_a?(Hash)
-      captures = options[:captures]
-      offset   = options[:offset] || 0
+      captures = options.fetch(:captures, nil)
+      offset   = options.fetch(:offset, 0)
       return unless captures ||= match(string)
       params   = named_captures.map do |name, positions|
         values = positions.map { |pos| map_param(name, captures[pos + offset]) }.flatten
@@ -135,20 +197,127 @@ module Mustermann
     #     warn "does not support expanding"
     #   end
     #
-    # @param [Hash{Symbol: #to_s, Array<#to_s>}] values values to use for expansion
+    # Expanding is supported by almost all patterns (notable execptions are {Mustermann::Shell},
+    # {Mustermann::Regular} and {Mustermann::Simple}).
+    #
+    # Union {Mustermann::Composite} patterns (with the | operator) support expanding if all
+    # patterns they are composed of also support it.
+    #
+    # @param (see Mustermann::Expander#expand)
     # @return [String] expanded string
     # @raise [NotImplementedError] raised if expand is not supported.
     # @raise [Mustermann::ExpandError] raised if a value is missing or unknown
     # @see Mustermann::Expander
-    def expand(values = {})
+    def expand(behavior = nil, values = {})
       raise NotImplementedError, "expanding not supported by #{self.class}"
     end
 
+    # @note This method is only implemented by certain subclasses.
+    #
+    # Generates a list of URI template strings representing the pattern.
+    #
+    # Note that this transformation is lossy and the strings matching these
+    # templates might not match the pattern (and vice versa).
+    #
+    # This comes in quite handy since URI templates are not made for pattern matching.
+    # That way you can easily use a more precise template syntax and have it automatically
+    # generate hypermedia links for you.
+    #
+    # @example generating templates
+    #   Mustermann.new("/:name").to_templates                   # => ["/{name}"]
+    #   Mustermann.new("/:foo(@:bar)?/*baz").to_templates       # => ["/{foo}@{bar}/{+baz}", "/{foo}/{+baz}"]
+    #   Mustermann.new("/{name}", type: :template).to_templates # => ["/{name}"]
+    #
+    # @example generating templates from composite patterns
+    #   pattern  = Mustermann.new('/:name')
+    #   pattern |= Mustermann.new('/{name}', type: :template)
+    #   pattern |= Mustermann.new('/example/*nested')
+    #   pattern.to_templates # => ["/{name}", "/example/{+nested}"]
+    #
+    # Template generation is supported by {Mustermann::Sinatra}, {Mustermann::Rails},
+    # {Mustermann::Template} and {Mustermann::Identity} patterns.  Union {Mustermann::Composite}
+    # patterns (with the | operator) support template generation if all patterns they are composed
+    # of also support it.
+    #
+    # @example Checking if a pattern supports expanding
+    #   if pattern.respond_to? :to_templates
+    #     pattern.to_templates
+    #   else
+    #     warn "does not support template generation"
+    #   end
+    #
+    # @return [Array<String>] list of URI templates
+    def to_templates
+      raise NotImplementedError, "template generation not supported by #{self.class}"
+    end
+
+    # @overload |(other)
+    #   Creates a pattern that matches any string matching either one of the patterns.
+    #   If a string is supplied, it is treated as an identity pattern.
+    #   
+    #   @example
+    #     pattern = Mustermann.new('/foo/:name') | Mustermann.new('/:first/:second')
+    #     pattern === '/foo/bar' # => true
+    #     pattern === '/fox/bar' # => true
+    #     pattern === '/foo'     # => false
+    #
+    # @overload &(other)
+    #   Creates a pattern that matches any string matching both of the patterns.
+    #   If a string is supplied, it is treated as an identity pattern.
+    #   
+    #   @example
+    #     pattern = Mustermann.new('/foo/:name') & Mustermann.new('/:first/:second')
+    #     pattern === '/foo/bar' # => true
+    #     pattern === '/fox/bar' # => false
+    #     pattern === '/foo'     # => false
+    #
+    # @overload ^(other)
+    #   Creates a pattern that matches any string matching exactly one of the patterns.
+    #   If a string is supplied, it is treated as an identity pattern.
+    #   
+    #   @example
+    #     pattern = Mustermann.new('/foo/:name') ^ Mustermann.new('/:first/:second')
+    #     pattern === '/foo/bar' # => false
+    #     pattern === '/fox/bar' # => true
+    #     pattern === '/foo'     # => false
+    #
+    # @param [Mustermann::Pattern, String] other the other pattern
+    # @return [Mustermann::Pattern] a composite pattern
+    def |(other)
+      Mustermann.new(self, other, :operator => :|, :type => :identity)
+    end
+
+    def &(other)
+      Mustermann.new(self, other, :operator => :&, :type => :identity)
+    end
+
+    def ^(other)
+      Mustermann.new(self, other, :operator => :^, :type => :identity)
+    end
+
+    # @example
+    #   pattern = Mustermann.new('/:a/:b')
+    #   strings = ["foo/bar", "/foo/bar", "/foo/bar/"]
+    #   strings.detect(&pattern) # => "/foo/bar"
+    #
+    # @return [Proc] proc wrapping {#===}
+    def to_proc
+      @to_proc ||= method(:===).to_proc
+    end
+
     # @!visibility private
     # @return [Boolean]
     # @see Object#respond_to?
     def respond_to?(method, *args)
-      method.to_s == 'expand' ? false : super
+      return super unless PATTERN_METHODS.include? method
+      respond_to_special?(method)
+    end
+
+    # @!visibility private
+    # @return [Boolean]
+    # @see #respond_to?
+    def respond_to_special?(method)
+      method(method).owner != Mustermann::Pattern
     end
 
     # @!visibility private
@@ -156,6 +325,12 @@ module Mustermann
       "#<%p:%p>" % [self.class, @string]
     end
 
+    # @!visibility private
+    def simple_inspect
+      type = self.class.name[/[^:]+$/].downcase
+      "%s:%p" % [type, @string]
+    end
+
     # @!visibility private
     def map_param(key, value)
       unescape(value, true)
@@ -164,8 +339,7 @@ module Mustermann
     # @!visibility private
     def unescape(string, decode = @uri_decode)
       return string unless decode and string
-      @uri ||= URI::Parser.new
-      @uri.unescape(string)
+      @@uri.unescape(string)
     end
 
     # @!visibility private
@@ -176,7 +350,7 @@ module Mustermann
       ALWAYS_ARRAY.include? key
     end
 
-    private :unescape, :map_param
+    private :unescape, :map_param, :respond_to_special?
     #private_constant :ALWAYS_ARRAY
   end
 end

data/lib/mustermann/pattern_cache.rb

@@ -0,0 +1,49 @@
+require 'set'
+require 'thread'
+require 'mustermann'
+
+module Mustermann
+  # A simple, persistent cache for creating repositories.
+  #
+  # @example
+  #   require 'mustermann/pattern_cache'
+  #   cache = Mustermann::PatternCache.new
+  #   
+  #   # use this instead of Mustermann.new
+  #   pattern = cache.create_pattern("/:name", type: :rails)
+  #
+  # @note
+  #   {Mustermann::Pattern.new} (which is used by {Mustermann.new}) will reuse instances that have
+  #   not yet been garbage collected. You only need an extra cache if you do not keep a reference to
+  #   the patterns around.
+  #
+  # @api private
+  class PatternCache
+    # @param [Hash] pattern_options default options used for {#create_pattern}
+    def initialize(pattern_options = {})
+      @cached          = Set.new
+      @mutex           = Mutex.new
+      @pattern_options = pattern_options
+    end
+
+    # @param (see Mustermann.new)
+    # @return (see Mustermann.new)
+    # @raise (see Mustermann.new)
+    # @see Mustermann.new
+    def create_pattern(string, pattern_options = {})
+      pattern = Mustermann.new(string, @pattern_options.merge(pattern_options))
+      @mutex.synchronize { @cached.add(pattern) } unless @cached.include? pattern
+      pattern
+    end
+
+    # Removes all pattern instances from the cache.
+    def clear
+      @mutex.synchronize { @cached.clear }
+    end
+
+    # @return [Integer] number of currently cached patterns
+    def size
+      @mutex.synchronize { @cached.size }
+    end
+  end
+end

data/lib/mustermann/pyramid.rb

@@ -0,0 +1,25 @@
+require 'mustermann/ast/pattern'
+
+module Mustermann
+  # Pyramid style pattern implementation.
+  #
+  # @example
+  #   Mustermann.new('/<foo>', type: :pryamid) === '/bar' # => true
+  #
+  # @see Mustermann::Pattern
+  # @see file:README.md#pryamid Syntax description in the README
+  class Pyramid < AST::Pattern
+    on(nil, ?}) { |c| unexpected(c) }
+
+    on(?{) do |char|
+      name       = expect(/\w+/, char: char)
+      constraint = read_brackets(?{, ?}) if scan(?:)
+      expect(?}) unless constraint
+      node(:capture, name, constraint: constraint)
+    end
+
+    on(?*) do |char|
+      node(:named_splat, expect(/\w+$/, char: char), convert: -> e { e.split(?/) })
+    end
+  end
+end

data/lib/mustermann/regexp_based.rb

@@ -15,7 +15,24 @@ module Mustermann
     # @see (see Mustermann::Pattern#initialize)
     def initialize(string, options = {})
       super
-      @regexp = compile(options)
+      regexp       = compile(options)
+      @peek_regexp = /\A(#{regexp})/
+      @regexp      = /\A#{regexp}\Z/
+    end
+
+    # @param (see Mustermann::Pattern#peek_size)
+    # @return (see Mustermann::Pattern#peek_size)
+    # @see (see Mustermann::Pattern#peek_size)
+    def peek_size(string)
+      return unless match = peek_match(string)
+      match.to_s.size
+    end
+
+    # @param (see Mustermann::Pattern#peek_match)
+    # @return (see Mustermann::Pattern#peek_match)
+    # @see (see Mustermann::Pattern#peek_match)
+    def peek_match(string)
+      @peek_regexp.match(string)
     end
 
     extend Forwardable

data/lib/mustermann/regular.rb

@@ -18,7 +18,7 @@ module Mustermann
     end
 
     def compile(options = {})
-      /\A#{@string}\Z/
+      /#{@string}/
     end
 
     private :compile

data/lib/mustermann/shell.rb

@@ -25,5 +25,13 @@ module Mustermann
     def ===(string)
       File.fnmatch? @string, unescape(string), @flags
     end
+
+    # @param (see Mustermann::Pattern#peek_size)
+    # @return (see Mustermann::Pattern#peek_size)
+    # @see (see Mustermann::Pattern#peek_size)
+    def peek_size(string)
+      @peek_string ||= @string + "{**,/**,/**/*}"
+      super if File.fnmatch? @peek_string, unescape(string), @flags
+    end
   end
 end

data/lib/mustermann/simple.rb

@@ -19,7 +19,7 @@ module Mustermann
       pattern.gsub!(/((:\w+)|\*)/) do |match|
         match == "*" ? "(?<splat>.*?)" : "(?<#{$2[1..-1]}>[^/?#]+#{?? unless greedy})"
       end
-      /\A#{Regexp.new(pattern)}\Z/
+      Regexp.new(pattern)
     rescue SyntaxError, RegexpError => error
       type = error.message["invalid group name"] ? CompileError : ParseError
       raise type, error.message, error.backtrace

data/lib/mustermann/simple_match.rb

@@ -26,5 +26,10 @@ module Mustermann
     def [](*args)
       captures[*args]
     end
+
+    # @return [String] string representation
+    def inspect
+      "#<%p %p>" % [self.class, @string]
+    end
   end
 end