mustermann 3.0.4 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ffbf76294166044123cd87324aed9709679a8ef4893219bcf75cbefd398d52b7
-  data.tar.gz: 4cbc5a0908b6f0839ad1875543b869da09e59ace62f4be875e259326f3f874f4
+  metadata.gz: a1787d2b11e609844ac6a3085ca8943c1b94e9026b14f7efadded04f63f6d299
+  data.tar.gz: f8fb8748dbd82305d12b23cc4a227c210e3f748cd6e23fdb97b1126ea582c62d
 SHA512:
-  metadata.gz: 88f278df75556096c65cf7148a7a543a2d4620b86568bb58c0bd649e6383caf6257a2417e2d9e6d260c5ac042c54eb91545120301a9d3262d9e9e134857d13f3
-  data.tar.gz: 8052170d96e904511af77ca90d966735b51338186ec9be0e61d10def3e2974a08fdfc62f6dbc9414ae92ffa35fd2102bf546bd0a98c67e53bc91abb1c0a0e1c9
+  metadata.gz: 5a429bddc03f3744c091f8b322c799f71276f35db5e190818ec57890012f52d4d3248c388b1db2997bd7d8c18bdb13fad58808e9961e1cd4accb832d8ddf9251
+  data.tar.gz: ac56fdcb2c30b07578ffa163af51a402190ec9ee75be89378347c2e9954caaadf942340ce15819f291bac4a1139d2e239fab4ff058df35c719777902f521620a

data/LICENSE

@@ -1,5 +1,4 @@
-Copyright (c) 2013-2017 Konstantin Haase
-Copyright (c) 2016-2017 Zachary Scott
+Copyright (c) Konstantin Haase
 
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation

data/README.md

@@ -1,6 +1,6 @@
 # The Amazing Mustermann
 
-*Make sure you view the correct docs: [latest release](http://rubydoc.info/gems/mustermann/frames), [master](http://rubydoc.info/github/rkh/mustermann/master/frames).*
+*Make sure you view the correct docs: [latest release](https://rubydoc.info/gems/mustermann/), [master](http://rubydoc.info/github/sinatra/mustermann).*
 
 Welcome to [Mustermann](http://en.wikipedia.org/wiki/List_of_placeholder_names_by_language#German). Mustermann is your personal string matching expert. As an expert in the field of strings and patterns, Mustermann keeps its runtime dependencies to a minimum and is fully covered with specs and documentation.
 
@@ -41,8 +41,8 @@ pattern.params('/a/b.c') # => { "prefix" => "a", splat => ["b", "c"] }
 
 These features are included in the library, but not loaded by default
 
-* **[Mapper](#-mapper):** A simple tool for mapping one string to another based on patterns.
-* **[Sinatra Integration](#-sinatra-integration):** Mustermann can be used as a [Sinatra](http://www.sinatrarb.com/) extension. Sinatra 2.0 and beyond will use Mustermann by default.
+* **[Pattern Set](#-pattern-set):** A collection of patterns with associated values, designed for building routing tables that dispatch efficiently as the number of routes grows.
+* **Mustermann::Router:** A very basic rack router built on top of `Mustermann::Set` for demonstration purposes or small-footprint routing in Rack middleware. Simple and fast.
 
 <a name="-pattern-types"></a>
 ## Pattern Types
@@ -56,7 +56,7 @@ require 'mustermann'
 pattern = Mustermann.new('/*/**', type: :shell)
 ```
 
-Note that this will use the type as suggestion: When passing in a string argument, it will create a pattern of the given type, but it might choose a different type for other objects (a regular expression argument will always result in a [regexp](#-pattern-details-regexp) pattern, a symbol always in a [sinatra](#-pattern-details-sinatra) pattern, etc).
+Note that this will use the type as suggestion: When passing in a string argument, it will create a pattern of the given type, but it might choose a different type for other objects (a regular expression argument will always result in a [regexp](../docs/patterns/regexp.md) pattern, a symbol always in a [sinatra](../docs/patterns/sinatra.md) pattern, etc).
 
 Alternatively, you can also load and instantiate the pattern type directly:
 
@@ -65,7 +65,7 @@ require 'mustermann/shell'
 pattern = Mustermann::Shell.new('/*/**')
 ```
 
-Mustermann itself includes the [sinatra](#-sinatra-pattern), [identity](#-identity-pattern) and [regexp](#-regexp-pattern) pattern types. Other pattern types are available as separate gems.
+Mustermann itself includes the [sinatra](../docs/patterns/sinatra.md), [identity](../docs/patterns/identity.md) and [regexp](../docs/patterns/regexp.md) pattern types. Other pattern types are available as separate gems.
 
 <a name="-binary-operators"></a>
 ## Binary Operators
@@ -120,19 +120,15 @@ require 'mustermann'
 
 pattern = Mustermann.new('/:page')
 pattern.match('/')     # => nil
-pattern.match('/home') # => #<MatchData "/home" page:"home">
+pattern.match('/home') # => #<Mustermann::Match>
 pattern =~ '/home'     # => 0
 pattern === '/home'    # => true (this allows using it in case statements)
-pattern.names          # => ['page']
-pattern.names          # => {"page"=>[1]}
 
 pattern = Mustermann.new('/home', type: :identity)
 pattern.match('/')     # => nil
-pattern.match('/home') # => #<Mustermann::SimpleMatch "/home">
+pattern.match('/home') # => #<Mustermann::Match ...>
 pattern =~ '/home'     # => 0
 pattern === '/home'    # => true (this allows using it in case statements)
-pattern.names          # => []
-pattern.names          # => {}
 ```
 
 Moreover, patterns based on regular expressions (all but `identity` and `shell`) automatically convert to regular expressions when needed:
@@ -179,7 +175,7 @@ Peeking gives the option to match a pattern against the beginning of a string ra
 
 * `peek` returns the matching substring.
 * `peek_size` returns the number of characters matching.
-* `peek_match` will return a `MatchData` or `Mustermann::SimpleMatch` (just like `match` does for the full string)
+* `peek_match` will return a `Mustermann::Match` (just like `match` does for the full string)
 * `peek_params` will return the `params` hash parsed from the substring and the number of characters.
 
 All of the above will turn `nil` if there was no match.
@@ -311,7 +307,7 @@ require 'mustermann'
 
 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}"
+Mustermann.new("/{name}", type: :template).to_templates # => ["/{name}"]
 ```
 
 Union Composite patterns (with the | operator) support template generation if all patterns they are composed of also support it.
@@ -359,119 +355,165 @@ pattern = Mustermann.new(":name@:domain.:tld")
 email   = list.detect(&pattern) # => "example@email.com"
 ```
 
-<a name="-mapper"></a>
-## Mapper
+<a name="-pattern-set"></a>
+## Pattern Set
 
-
-You can use a mapper to transform strings according to two or more mappings:
+`Mustermann::Set` is a collection of patterns where each pattern is associated with an arbitrary value — typically a handler or action. A single call to `match` returns both the captured parameters and the value for the first matching pattern, making it straightforward to build a routing table.
 
 ``` ruby
-require 'mustermann/mapper'
+require 'mustermann/set'
+
+set = Mustermann::Set.new
+set.add('/users/:id',  :users_show)
+set.add('/posts/:id',  :posts_show)
+set.add('/posts',      :posts_index)
 
-mapper = Mustermann::Mapper.new("/:page(.:format)?" => ["/:page/view.:format", "/:page/view.html"])
-mapper['/foo']     # => "/foo/view.html"
-mapper['/foo.xml'] # => "/foo/view.xml"
-mapper['/foo/bar'] # => "/foo/bar"
+m = set.match('/users/42')
+m.value         # => :users_show
+m.params['id']  # => '42'
+
+set.match('/unknown')  # => nil
 ```
 
-<a name="-sinatra-integration"></a>
-## Sinatra Integration
+You can supply the initial mapping directly to the constructor:
 
-Mustermann is used in Sinatra by default since version 2.0, for previous versions an [extension](https://github.com/sinatra/mustermann-sinatra-extension) is available.
+``` ruby
+set = Mustermann::Set.new(
+  '/users/:id' => :users_show,
+  '/posts/:id' => :posts_show
+)
+```
+
+Or use a block for imperative setup:
 
-### Configuration
+``` ruby
+set = Mustermann::Set.new do |s|
+  s.add('/users/:id', :users_show)
+  s.add('/posts/:id', :posts_show)
+end
+```
 
-You can change what pattern type you want to use for your app via the `pattern` option:
+Pattern options such as `type:` are passed as keyword arguments and apply to all patterns in the set:
 
 ``` ruby
-require 'sinatra/base'
-require 'mustermann'
+set = Mustermann::Set.new(type: :rails)
+set.add('/:controller(/:action(/:id))', :route)
+```
 
-class MyApp < Sinatra::Base
-  register Mustermann
-  set :pattern, type: :shell
+### Values
 
-  get '/images/*.png' do
-    send_file request.path_info
-  end
+Each pattern can be associated with multiple values. `match` returns the first, while `match_all` returns one match per value:
 
-  get '/index{.htm,.html,}' do
-    erb :index
-  end
-end
+``` ruby
+set = Mustermann::Set.new
+set.add('/users/:id', :admin_handler, :user_handler)
+
+set.match('/users/1').value            # => :admin_handler
+set.match_all('/users/1').map(&:value) # => [:admin_handler, :user_handler]
 ```
 
-You can use the same setting for options:
+When no value is given, a match still succeeds but `value` is `nil`:
 
 ``` ruby
-require 'sinatra'
-require 'mustermann'
+set = Mustermann::Set.new
+set.add('/ping')
+set.match('/ping').value  # => nil
+```
 
-register Mustermann
-set :pattern, capture: { ext: %w[png jpg html txt] }
+### Peeking
 
-get '/:slug(.:ext)?' do
-  # slug will be 'foo' for '/foo.png'
-  # slug will be 'foo.bar' for '/foo.bar'
-  # slug will be 'foo.bar' for '/foo.bar.html'
-  params[:slug]
-end
+`peek_match` matches a prefix of the input rather than the full string. The unmatched remainder is available via `post_match`:
+
+``` ruby
+set = Mustermann::Set.new
+set.add('/users/:id', :users)
+
+m = set.peek_match('/users/42/posts')
+m.to_s        # => '/users/42'
+m.post_match  # => '/posts'
+m.value       # => :users
 ```
 
-It is also possible to pass in options to a specific route:
+`peek_match_all` returns every pattern that matches a prefix:
 
 ``` ruby
-require 'sinatra'
-require 'mustermann'
+results = set.peek_match_all('/users/42/posts')
+results.map(&:value)      # => [:users]
+results.map(&:post_match) # => ['/posts']
+```
 
-register Mustermann
+### Expanding
 
-get '/:slug(.:ext)?', pattern: { greedy: false } do
-  # slug will be 'foo' for '/foo.png'
-  # slug will be 'foo' for '/foo.bar'
-  # slug will be 'foo' for '/foo.bar.html'
-  params[:slug]
-end
+A set can generate strings from parameter hashes using the same interface as individual pattern expansion:
+
+``` ruby
+set = Mustermann::Set.new
+set.add('/users/:id', :users)
+set.add('/posts/:id', :posts)
+
+set.expand(id: '5')          # => '/users/5'  (first applicable pattern)
+set.expand(:posts, id: '5')  # => '/posts/5'  (patterns for a specific value)
 ```
 
-Of course, all of the above can be combined.
-Moreover, the `capture` and the `except` option can be passed to route directly.
-And yes, this also works with `before` and `after` filters.
+### Match order
 
-``` ruby
-require 'sinatra/base'
-require 'sinatra/respond_with'
-require 'mustermann'
+A set can match patterns and values in loose or strict insertion order.
 
-class MyApp < Sinatra::Base
-  register Mustermann, Sinatra::RespondWith
-  set :pattern, capture: { id: /\d+/ } # id will only match digits
+You have the following guarantees without strict ordering:
 
-  # only capture extensions known to Rack
-  before '*:ext', capture: Rack::Mime::MIME_TYPES.keys do
-    content_type params[:ext]                 # set Content-Type
-    request.path_info = params[:splat].first  # drop the extension
-  end
+* Patterns with dynamic segments in the same position and equal static parts will always match in the order they were added.
+* Multiple values for the same pattern will retain their insertion order in regards to that pattern.
 
-  get '/:id' do
-    not_found unless page = Page.find params[:id]
-    respond_with(page)
-  end
-end
+Trade-offs without strict ordering:
+
+* Static segments may be favored over dynamic segments. If you want to guarantee this behavior, enable trie-mode proactively.
+* When a pattern has multiple values, these will follow each other directly when using `match_all` or `peek_match_all`.
+
+Strict ordering comes with both a performance overhead and marginally increased memory usage.
+How big the performance overhead is depends on the number of patterns that overlap in the strings they successfully match against.
+It does use Ruby's built-in sorting, which on MRI is based on quicksort. The memory overhead grows linear with the number
+of pattern and value combinations, but is generally small compared to the memory used by the patterns and values themselves.
+
+With strict ordering enabled, patterns and values are guaranteed to occur in insertion order.
+
+Without strict ordering, not using a trie:
+
+```ruby
+set = Mustermann::Set.new(use_trie: false)
+
+set.add("/:path",  :first)
+set.add("/static", :second)
+set.add("/:path",  :third)
+
+set.match("/static").value             # => :first
+set.match_all("/static").map(&:value)  # => [:first, :third, :second]
 ```
 
-### Why would I want this?
+Without strict ordering, using a trie:
+
+```ruby
+set = Mustermann::Set.new(use_trie: true)
 
-* It gives you fine grained control over the pattern matching
-* Allows you to use different pattern styles in your app
-* The default is more robust and powerful than the built-in patterns
-* Sinatra 2.0 will use Mustermann internally
-* Better exceptions for broken route syntax
+set.add("/:path",  :first)
+set.add("/static", :second)
+set.add("/:path",  :third)
+
+set.match("/static").value             # => :second
+set.match_all("/static").map(&:value)  # => [:second, :first, :third]
+```
 
-### Why not include this in Sinatra 1.x?
+With strict ordering enabled, regardless of whether a trie is used or not:
 
-* It would introduce breaking changes, even though these would be minor
-* Like Sinatra 2.0, Mustermann requires Ruby 2.0 or newer
+```ruby
+set = Mustermann::Set.new(strict_order: true)
+
+set.add("/:path",  :first)
+set.add("/static", :second)
+set.add("/:path",  :third)
+
+set.match("/static").value             # => :first
+set.match_all("/static").map(&:value)  # => [:first, :second, :third]
+```
 
 <a name="-duck-typing"></a>
 ## Duck Typing
@@ -494,33 +536,6 @@ object = MyObject.new
 Mustermann.new(object, type: :rails) # => #<Mustermann::Rails:"/foo">
 ```
 
-It might also be that you want to call `to_pattern` yourself instead of `Mustermann.new`. You can load `mustermann/to_pattern` to implement this method for strings, regular expressions and pattern objects:
-
-``` ruby
-require 'mustermann/to_pattern'
-
-"/foo".to_pattern               # => #<Mustermann::Sinatra:"/foo">
-"/foo".to_pattern(type: :rails) # => #<Mustermann::Rails:"/foo">
-%r{/foo}.to_pattern             # => #<Mustermann::Regular:"\\/foo">
-"/foo".to_pattern.to_pattern    # => #<Mustermann::Sinatra:"/foo">
-```
-
-You can also use the `Mustermann::ToPattern` mixin to easily add `to_pattern` to your own objects:
-
-``` ruby
-require 'mustermann/to_pattern'
-
-class MyObject
-  include Mustermann::ToPattern
-
-  def to_s
-    "/foo"
-  end
-end
-
-MyObject.new.to_pattern # => #<Mustermann::Sinatra:"/foo">
-```
-
 <a name="-duck-typing-respond-to"></a>
 ### `respond_to?`
 
@@ -580,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`
 
@@ -615,10 +723,10 @@ Semi-greedy behavior is not specific to dots, it works with all characters or st
 
 ``` ruby
 pattern = Mustermann.new(':a.:b', greedy: true)
-pattern.match('a.b.c.d') # => #<MatchData a:"a.b.c" b:"d">
+pattern.match('a.b.c.d') # => #<Mustermann::Match>
 
 pattern = Mustermann.new(':a.:b', greedy: false)
-pattern.match('a.b.c.d') # => #<MatchData a:"a" b:"b.c.d">
+pattern.match('a.b.c.d') # => #<Mustermann::Match>
 ```
 
 <a name="-available-options--space_matches_plus"></a>
@@ -679,152 +787,21 @@ By setting `ignore_unknown_options` to `true`, it will happily ignore the option
 <a name="-performance"></a>
 ## Performance
 
-It's generally a good idea to reuse pattern objects, since as much computation as possible is happening during object creation, so that the actual matching or expanding is quite fast.
-
-Pattern objects should be treated as immutable. Their internals have been designed for both performance and low memory usage. To reduce pattern compilation, `Mustermann.new` and `Mustermann::Pattern.new` might return the same instance when given the same arguments, if that instance has not yet been garbage collected. However, this is not guaranteed, so do not rely on object identity.
-
-### String Matching
-
-When using a pattern instead of a regular expression for string matching, performance will usually be comparable.
-
-In certain cases, Mustermann might outperform naive, equivalent regular expressions. It achieves this by using look-ahead and atomic groups in ways that work well with a backtracking, NFA-based regular expression engine (such as the Oniguruma/Onigmo engine used by Ruby). It can be difficult and error prone to construct complex regular expressions using these techniques by hand. This only applies to patterns generating an AST internally (all but [identity](#-pattern-details-identity), [shell](#-pattern-details-shell), [simple](#-pattern-details-simple) and [regexp](#-pattern-details-regexp) patterns).
-
-When using a Mustermann pattern as a direct Regexp replacement (ie, via methods like `=~`, `match` or `===`), the overhead will be a single method dispatch, which some Ruby implementations might even eliminate with method inlining. This only applies to patterns using a regular expression internally (all but [identity](#-pattern-details-identity) and [shell](#-pattern-details-shell) patterns).
-
-### Expanding
+Mustermann is designed so that as much work as possible happens at object-creation time, keeping matching and expansion fast at request time. Pattern objects should be treated as immutable; their internals are optimized for both speed and low memory usage.
 
-Pattern expansion significantly outperforms other, widely used Ruby tools for generating URLs from URL patterns in most use cases.
+Key points:
 
-This comes with a few trade-offs:
+* **Pattern caching:** `Mustermann.new` may return the same instance for identical arguments while that instance is still alive. Do not rely on object identity.
+* **Single-pattern matching:** AST-based patterns (sinatra, rails, hybrid, template, flask) use bounded character classes, negative look-ahead, and non-greedy splats to avoid unnecessary backtracking in Ruby's Oniguruma engine. Using a pattern as a `Regexp` replacement adds at most one method-dispatch of overhead.
+* **Routing with `Mustermann::Set`:** Uses a trie (prefix tree) for large tables. Rather than checking every route in sequence, the trie walks the input one character at a time, sharing prefix traversal across all patterns that start with the same characters. Dispatch time grows far more slowly than a linear scan. A `use_trie:` threshold (default 50) controls when the switch happens, and an optional `ObjectSpace::WeakKeyMap` cache avoids re-matching the same string.
+* **Expansion:** Most computation is shifted to compile time. Memory grows linearly with the number of optional-key combinations in a pattern.
 
-* As with pattern compilation, as much computation as possible has been shifted to compiling expansion rules. This will add compilation overhead, which is why patterns only generate these rules on the first invocation to `Mustermann::Pattern#expand`. Create a `Mustermann::Expander` instance yourself to get better control over the point in time this computation should happen.
-* Memory is sacrificed in favor of performance: The size of the expander object will grow linear with the number of possible combination for expansion keys ("/:foo/:bar" has one such combination, but "/(:foo/)?:bar?" has four)
-* Parsing a params hash from a string generated from another params hash might not result in two identical hashes, and vice versa. Specifically, expanding ignores capture constraints, type casting and greediness.
-* Partial expansion is (currently) not supported.
+See **[docs/performance.md](../docs/performance.md)** for a detailed explanation of each optimization, the linear vs. trie trade-off, caching, thread-safety, and benchmark guidance.
 
 ## Details on Pattern Types
 
-<a name="-identity-pattern"></a>
-### `identity`
-
-**Supported options:**
-[`uri_decode`](#-available-options--uri_decode),
-[`ignore_unknown_options`](#-available-options--ignore_unknown_options).
-
-<table>
-  <thead>
-    <tr>
-      <th>Syntax Element</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><i>any character</i></td>
-      <td>Matches exactly that character or a URI escaped version of it.</td>
-    </tr>
-  </tbody>
-</table>
-
-<a name="-regexp-pattern"></a>
-### `regexp`
-
-**Supported options:**
-[`uri_decode`](#-available-options--uri_decode),
-[`ignore_unknown_options`](#-available-options--ignore_unknown_options), `check_anchors`.
-
-The pattern string (or actual Regexp instance) should not contain anchors (`^` outside of square brackets, `$`, `\A`, `\z`, or `\Z`).
-Anchors will be injected where necessary by Mustermann.
-
-By default, Mustermann will raise a `Mustermann::CompileError` if an anchor is encountered.
-If you still want it to contain anchors at your own risk, set the `check_anchors` option to `false`.
-
-Using anchors will break [peeking](#-peeking) and [concatenation](#-concatenation).
-
-<table>
-  <thead>
-    <tr>
-      <th>Syntax Element</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><i>any string</i></td>
-      <td>Interpreted as regular expression.</td>
-    </tr>
-  </tbody>
-</table>
-
-<a name="-sinatra-pattern"></a>
-### `sinatra`
-
-**Supported options:**
-[`capture`](#-available-options--capture),
-[`except`](#-available-options--except),
-[`greedy`](#-available-options--greedy),
-[`space_matches_plus`](#-available-options--space_matches_plus),
-[`uri_decode`](#-available-options--uri_decode),
-[`ignore_unknown_options`](#-available-options--ignore_unknown_options).
-
-<table>
-  <thead>
-    <tr>
-      <th>Syntax Element</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><b>:</b><i>name</i> <i><b>or</b></i> <b>&#123;</b><i>name</i><b>&#125;</b></td>
-      <td>
-        Captures anything but a forward slash in a semi-greedy fashion. Capture is named <i>name</i>.
-        Capture behavior can be modified with <tt>capture</tt> and <tt>greedy</tt> option.
-      </td>
-    </tr>
-    <tr>
-      <td><b>*</b><i>name</i> <i><b>or</b></i> <b>&#123;+</b><i>name</i><b>&#125;</b></td>
-      <td>
-        Captures anything in a non-greedy fashion. Capture is named <i>name</i>.
-      </td>
-    </tr>
-    <tr>
-      <td><b>*</b> <i><b>or</b></i> <b>&#123;+splat&#125;</b></td>
-      <td>
-        Captures anything in a non-greedy fashion. Capture is named splat.
-        It is always an array of captures, as you can use it more than once in a pattern.
-      </td>
-    </tr>
-    <tr>
-      <td><b>(</b><i>expression</i><b>)</b></td>
-      <td>
-        Enclosed <i>expression</i> is a group. Useful when combined with <tt>?</tt> to make it optional,
-        or to separate two elements that would otherwise be parsed as one.
-      </td>
-    </tr>
-    <tr>
-      <td><i>expression</i><b>|</b><i>expression</i><b>|</b><i>...</i></td>
-      <td>
-        Will match anything matching the nested expressions. May contain any other syntax element, including captures.
-      </td>
-    </tr>
-    <tr>
-      <td><i>x</i><b>?</b></td>
-      <td>Makes <i>x</i> optional. For instance, <tt>(foo)?</tt> matches <tt>foo</tt> or an empty string.</td>
-    </tr>
-    <tr>
-      <td><b>/</b></td>
-      <td>
-        Matches forward slash. Does not match URI encoded version of forward slash.
-      </td>
-    </tr>
-    <tr>
-      <td><b>\</b><i>x</i></td>
-      <td>Matches <i>x</i> or URI encoded version of <i>x</i>. For instance <tt>\*</tt> matches <tt>*</tt>.</td>
-    </tr>
-    <tr>
-      <td><i>any other character</i></td>
-      <td>Matches exactly that character or a URI encoded version of it.</td>
-    </tr>
-  </tbody>
-</table>
+- [`identity`](../docs/patterns/identity.md)
+- [`regexp`](../docs/patterns/regexp.md)
+- [`sinatra`](../docs/patterns/sinatra.md)
+- [`rails`](../docs/patterns/rails.md)
+- [`hybrid`](../docs/patterns/hybrid.md)