mustermann-uri-template 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8d99fdcae417aa135df269a93872d1abec9ba1f3
+  data.tar.gz: 33eaef99d2e9442396c2456d16a5df1c40960079
+SHA512:
+  metadata.gz: 83b7c599cd1a1a8c599f28e1a99ff9958739ae989688c8b666b3f621282d1f1035adf527ec4aba76e3912b520b13a30c597505d0db88235b09a537667aadccbe
+  data.tar.gz: 306ebd2de32b51d42eb0fad5893e5bb87def3f40213b3198da50fc73c09726b421b2d4c0030b237a3a418fb35ed0ff0290d07aa2a8c65ac072033420fe7401f7

data/README.md

@@ -0,0 +1,84 @@
+# URI Template Syntax for Mustermann
+
+This gem implements the `uri-template` (or `template`) pattern type for Mustermann. It is compatible with [RFC 6570](https://tools.ietf.org/html/rfc6570) (level 4), [JSON API](http://jsonapi.org/), [JSON Home Documents](http://tools.ietf.org/html/draft-nottingham-json-home-02) and [many more](https://code.google.com/p/uri-templates/wiki/Implementations)
+
+## Overview
+
+**Supported options:**
+`capture`, `except`, `greedy`, `space_matches_plus`, `uri_decode`, and `ignore_unknown_options`.
+
+Please keep the following in mind:
+
+> "Some URI Templates can be used in reverse for the purpose of variable matching: comparing the template to a fully formed URI in order to extract the variable parts from that URI and assign them to the named variables.  Variable matching only works well if the template expressions are delimited by the beginning or end of the URI or by characters that cannot be part of the expansion, such as reserved characters surrounding a simple string expression.  In general, regular expression languages are better suited for variable matching."
+> — *RFC 6570, Sec 1.5: "Limitations"*
+
+``` ruby
+require 'mustermann'
+
+pattern = Mustermann.new('/{example}', type: :template)
+pattern === "/foo.bar"     # => true
+pattern === "/foo/bar"     # => false
+pattern.params("/foo.bar") # => { "example" => "foo.bar" }
+pattern.params("/foo/bar") # => nil
+
+pattern = Mustermann.new("{/segments*}/{page}{.ext,cmpr:2}", type: :template)
+pattern.params("/a/b/c.tar.gz") # => {"segments"=>["a","b"], "page"=>"c", "ext"=>"tar", "cmpr"=>"gz"}
+```
+
+## Generating URI Templates
+
+You do not need to use URI templates (and this gem) if all you want is reusing them for hypermedia links. Most other pattern types support generating these (via `#to_pattern`):
+
+``` ruby
+require 'mustermann'
+
+Mustermann.new('/:name').to_templates # => ['/{name}']
+```
+
+Moreover, Mustermann's default pattern type implements a subset of URI templates (`{capture}` and `{+capture}`) and can therefore also be used for simple templates/
+
+``` ruby
+require 'mustermann'
+
+Mustermann.new('/{name}').expand(name: "example") # => "/example"
+```
+
+## Syntax
+
+<table>
+  <thead>
+    <tr>
+      <th>Syntax Element</th>
+      <th>Description</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td><b>&#123;</b><i>o</i> <i>var</i> <i>m</i><b>,</b> <i>var</i> <i>m</i><b>,</b> ...<b>&#125;</b></td>
+      <td>
+        Captures expansion.
+        Operator <i>o</i>: <code>+ # . / ; ? &amp;</tt> or none.
+        Modifier <i>m</i>: <code>:num *</tt> or none.
+      </td>
+    </tr>
+    <tr>
+      <td><b>/</b></td>
+      <td>
+        Matches forward slash. Does not match URI encoded version of forward slash.
+      </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>
+
+The operators `+` and `#` will always match non-greedy, whereas all other operators match semi-greedy by default.
+All modifiers and operators are supported. However, it does not parse lists as single values without the *explode* modifier (aka *star*).
+Parametric operators (`;`, `?` and `&`) currently only match parameters in given order.
+
+Note that it differs from URI templates in that it takes the unescaped version of special character instead of the escaped version.
+
+If you reuse the exact same templates and expose them via an external API meant for expansion,
+you should set `uri_decode` to `false` in order to conform with the specification.

data/lib/mustermann/template.rb

@@ -0,0 +1,61 @@
+require 'mustermann'
+require 'mustermann/ast/pattern'
+
+module Mustermann
+  # URI template pattern implementation.
+  #
+  # @example
+  #   Mustermann.new('/{foo}') === '/bar' # => true
+  #
+  # @see Mustermann::Pattern
+  # @see file:README.md#template Syntax description in the README
+  # @see http://tools.ietf.org/html/rfc6570 RFC 6570
+  class Template < AST::Pattern
+    register :template, :uri_template
+
+    on ?{ do |char|
+      variable = proc do
+        start  = pos
+        match  = expect(/(?<name>\w+)(?:\:(?<prefix>\d{1,4})|(?<explode>\*))?/)
+        node(:variable, match[:name], prefix: match[:prefix], explode: match[:explode], start: start)
+      end
+
+      operator   = buffer.scan(/[\+\#\.\/;\?\&\=\,\!\@\|]/)
+      expression = node(:expression, [variable[]], operator: operator) { variable[] if scan(?,) }
+      expression if expect(?})
+    end
+
+    on(?}) { |c| unexpected(c) }
+
+    # @!visibility private
+    def compile(*args, **options)
+      @split_params = {}
+      super(*args, split_params: @split_params, **options)
+    end
+
+    # @!visibility private
+    def map_param(key, value)
+      return super unless variable = @split_params[key]
+      value = value.split variable[:separator]
+      value.map! { |e| e.sub(/\A#{key}=/, '') } if variable[:parametric]
+      value.map! { |e| super(key, e) }
+    end
+
+    # @!visibility private
+    def always_array?(key)
+      @split_params.include? key
+    end
+
+    # Identity patterns 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
+      [to_s]
+    end
+
+    private :compile, :map_param, :always_array?
+  end
+end

data/lib/mustermann/uri_template.rb

@@ -0,0 +1 @@
+require 'mustermann/template'

data/mustermann-uri-template.gemspec

@@ -0,0 +1,18 @@
+$:.unshift File.expand_path("../../mustermann/lib", __FILE__)
+require "mustermann/version"
+
+Gem::Specification.new do |s|
+  s.name                  = "mustermann-uri-template"
+  s.version               = Mustermann::VERSION
+  s.author                = "Konstantin Haase"
+  s.email                 = "konstantin.mailinglists@googlemail.com"
+  s.homepage              = "https://github.com/rkh/mustermann"
+  s.summary               = %q{URI template syntax for Mustermann}
+  s.description           = %q{Adds URI template style patterns to Mustermman}
+  s.license               = 'MIT'
+  s.required_ruby_version = '>= 2.1.0'
+  s.files                 = `git ls-files`.split("\n")
+  s.test_files            = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables           = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.add_dependency 'mustermann', Mustermann::VERSION
+end

data/spec/template_spec.rb

@@ -0,0 +1,841 @@
+require 'support'
+require 'mustermann/template'
+
+describe Mustermann::Template do
+  extend Support::Pattern
+
+  pattern '' do
+    it { should     match('')  }
+    it { should_not match('/') }
+
+    it { should respond_to(:expand)       }
+    it { should respond_to(:to_templates) }
+  end
+
+  pattern '/' do
+    it { should     match('/')    }
+    it { should_not match('/foo') }
+  end
+
+  pattern '/foo' do
+    it { should     match('/foo')     }
+    it { should_not match('/bar')     }
+    it { should_not match('/foo.bar') }
+  end
+
+  pattern '/foo/bar' do
+    it { should     match('/foo/bar')   }
+    it { should_not match('/foo%2Fbar') }
+    it { should_not match('/foo%2fbar') }
+  end
+
+  pattern '/:foo' do
+    it { should     match('/:foo')    }
+    it { should     match('/%3Afoo')  }
+    it { should_not match('/foo')     }
+    it { should_not match('/foo?')    }
+    it { should_not match('/foo/bar') }
+    it { should_not match('/')        }
+    it { should_not match('/foo/')    }
+  end
+
+  pattern '/föö' do
+    it { should match("/f%C3%B6%C3%B6") }
+  end
+
+  pattern '/test$/' do
+    it { should match('/test$/') }
+  end
+
+  pattern '/te+st/' do
+    it { should     match('/te+st/') }
+    it { should_not match('/test/')  }
+    it { should_not match('/teest/') }
+  end
+
+  pattern "/path with spaces" do
+    it { should match('/path%20with%20spaces') }
+    it { should match('/path%2Bwith%2Bspaces') }
+    it { should match('/path+with+spaces')     }
+  end
+
+  pattern '/foo&bar' do
+    it { should match('/foo&bar') }
+  end
+
+  pattern '/test.bar' do
+    it { should     match('/test.bar') }
+    it { should_not match('/test0bar') }
+  end
+
+  pattern "/path with spaces", space_matches_plus: false do
+    it { should     match('/path%20with%20spaces') }
+    it { should_not match('/path%2Bwith%2Bspaces') }
+    it { should_not match('/path+with+spaces')     }
+  end
+
+  pattern "/path with spaces", uri_decode: false do
+    it { should_not match('/path%20with%20spaces') }
+    it { should_not match('/path%2Bwith%2Bspaces') }
+    it { should_not match('/path+with+spaces')     }
+  end
+
+  context 'level 1' do
+    context 'without operator' do
+      pattern '/hello/{person}' do
+        it { should match('/hello/Frank').capturing person: 'Frank' }
+        it { should match('/hello/a_b~c').capturing person: 'a_b~c' }
+        it { should match('/hello/a.%20').capturing person: 'a.%20' }
+
+        it { should_not match('/hello/:') }
+        it { should_not match('/hello//') }
+        it { should_not match('/hello/?') }
+        it { should_not match('/hello/#') }
+        it { should_not match('/hello/[') }
+        it { should_not match('/hello/]') }
+        it { should_not match('/hello/@') }
+        it { should_not match('/hello/!') }
+        it { should_not match('/hello/*') }
+        it { should_not match('/hello/+') }
+        it { should_not match('/hello/,') }
+        it { should_not match('/hello/;') }
+        it { should_not match('/hello/=') }
+
+        example { pattern.params('/hello/Frank').should be == {'person' => 'Frank'} }
+      end
+
+      pattern "/{foo}/{bar}" do
+        it { should match('/foo/bar')         .capturing foo: 'foo',     bar: 'bar'     }
+        it { should match('/foo.bar/bar.foo') .capturing foo: 'foo.bar', bar: 'bar.foo' }
+        it { should match('/10.1/te.st')      .capturing foo: '10.1',    bar: 'te.st'   }
+        it { should match('/10.1.2/te.st')    .capturing foo: '10.1.2',  bar: 'te.st'   }
+
+        it { should_not match('/foo%2Fbar') }
+        it { should_not match('/foo%2fbar') }
+      end
+    end
+  end
+
+  context 'level 2' do
+    context 'operator +' do
+      pattern '/hello/{+person}' do
+        it { should match('/hello/Frank') .capturing person: 'Frank' }
+        it { should match('/hello/a_b~c') .capturing person: 'a_b~c' }
+        it { should match('/hello/a.%20') .capturing person: 'a.%20' }
+        it { should match('/hello/a/%20') .capturing person: 'a/%20' }
+        it { should match('/hello/:')     .capturing person: ?:      }
+        it { should match('/hello//')     .capturing person: ?/      }
+        it { should match('/hello/?')     .capturing person: ??      }
+        it { should match('/hello/#')     .capturing person: ?#      }
+        it { should match('/hello/[')     .capturing person: ?[      }
+        it { should match('/hello/]')     .capturing person: ?]      }
+        it { should match('/hello/@')     .capturing person: ?@      }
+        it { should match('/hello/!')     .capturing person: ?!      }
+        it { should match('/hello/*')     .capturing person: ?*      }
+        it { should match('/hello/+')     .capturing person: ?+      }
+        it { should match('/hello/,')     .capturing person: ?,      }
+        it { should match('/hello/;')     .capturing person: ?;      }
+        it { should match('/hello/=')     .capturing person: ?=      }
+      end
+
+      pattern "/{+foo}/{bar}" do
+        it { should match('/foo/bar')         .capturing foo: 'foo',     bar: 'bar'     }
+        it { should match('/foo.bar/bar.foo') .capturing foo: 'foo.bar', bar: 'bar.foo' }
+        it { should match('/foo/bar/bar.foo') .capturing foo: 'foo/bar', bar: 'bar.foo' }
+        it { should match('/10.1/te.st')      .capturing foo: '10.1',    bar: 'te.st'   }
+        it { should match('/10.1.2/te.st')    .capturing foo: '10.1.2',  bar: 'te.st'   }
+
+        it { should_not match('/foo%2Fbar') }
+        it { should_not match('/foo%2fbar') }
+      end
+    end
+
+    context 'operator #' do
+      pattern '/hello/{#person}' do
+        it { should match('/hello/#Frank') .capturing person: 'Frank' }
+        it { should match('/hello/#a_b~c') .capturing person: 'a_b~c' }
+        it { should match('/hello/#a.%20') .capturing person: 'a.%20' }
+        it { should match('/hello/#a/%20') .capturing person: 'a/%20' }
+        it { should match('/hello/#:')     .capturing person: ?:      }
+        it { should match('/hello/#/')     .capturing person: ?/      }
+        it { should match('/hello/#?')     .capturing person: ??      }
+        it { should match('/hello/##')     .capturing person: ?#      }
+        it { should match('/hello/#[')     .capturing person: ?[      }
+        it { should match('/hello/#]')     .capturing person: ?]      }
+        it { should match('/hello/#@')     .capturing person: ?@      }
+        it { should match('/hello/#!')     .capturing person: ?!      }
+        it { should match('/hello/#*')     .capturing person: ?*      }
+        it { should match('/hello/#+')     .capturing person: ?+      }
+        it { should match('/hello/#,')     .capturing person: ?,      }
+        it { should match('/hello/#;')     .capturing person: ?;      }
+        it { should match('/hello/#=')     .capturing person: ?=      }
+
+
+        it { should_not match('/hello/Frank') }
+        it { should_not match('/hello/a_b~c') }
+        it { should_not match('/hello/a.%20') }
+
+        it { should_not match('/hello/:') }
+        it { should_not match('/hello//') }
+        it { should_not match('/hello/?') }
+        it { should_not match('/hello/#') }
+        it { should_not match('/hello/[') }
+        it { should_not match('/hello/]') }
+        it { should_not match('/hello/@') }
+        it { should_not match('/hello/!') }
+        it { should_not match('/hello/*') }
+        it { should_not match('/hello/+') }
+        it { should_not match('/hello/,') }
+        it { should_not match('/hello/;') }
+        it { should_not match('/hello/=') }
+
+
+        example { pattern.params('/hello/#Frank').should be == {'person' => 'Frank'} }
+      end
+
+      pattern "/{+foo}/{#bar}" do
+        it { should match('/foo/#bar')         .capturing foo: 'foo',     bar: 'bar'     }
+        it { should match('/foo.bar/#bar.foo') .capturing foo: 'foo.bar', bar: 'bar.foo' }
+        it { should match('/foo/bar/#bar.foo') .capturing foo: 'foo/bar', bar: 'bar.foo' }
+        it { should match('/10.1/#te.st')      .capturing foo: '10.1',    bar: 'te.st'   }
+        it { should match('/10.1.2/#te.st')    .capturing foo: '10.1.2',  bar: 'te.st'   }
+
+        it { should_not match('/foo%2F#bar') }
+        it { should_not match('/foo%2f#bar') }
+
+        example { pattern.params('/hello/#Frank').should be == {'foo' => 'hello', 'bar' => 'Frank'} }
+      end
+    end
+  end
+
+  context 'level 3' do
+    context 'without operator' do
+      pattern "{a,b,c}" do
+        it { should match("~x,42,_").capturing a: '~x', b: '42', c: '_' }
+        it { should_not match("~x,42")      }
+        it { should_not match("~x/42")      }
+        it { should_not match("~x#42")      }
+        it { should_not match("~x,42,_#42") }
+
+        example { pattern.params('d,f,g').should be == {'a' => 'd', 'b' => 'f', 'c' => 'g'} }
+      end
+    end
+
+    context 'operator +' do
+      pattern "{+a,b,c}" do
+        it { should match("~x,42,_")     .capturing a: '~x', b: '42', c: '_'     }
+        it { should match("~x,42,_#42")  .capturing a: '~x', b: '42', c: '_#42'  }
+        it { should match("~/x,42,_/42") .capturing a: '~/x', b: '42', c: '_/42' }
+
+        it { should_not match("~x,42")      }
+        it { should_not match("~x/42")      }
+        it { should_not match("~x#42")      }
+      end
+    end
+
+    context 'operator #' do
+      pattern "{#a,b,c}" do
+        it { should match("#~x,42,_")     .capturing a: '~x', b: '42', c: '_'     }
+        it { should match("#~x,42,_#42")  .capturing a: '~x', b: '42', c: '_#42'  }
+        it { should match("#~/x,42,_#42") .capturing a: '~/x', b: '42', c: '_#42' }
+
+        it { should_not match("~x,42,_")     }
+        it { should_not match("~x,42,_#42")  }
+        it { should_not match("~/x,42,_#42") }
+
+        it { should_not match("~x,42")      }
+        it { should_not match("~x/42")      }
+        it { should_not match("~x#42")      }
+      end
+    end
+
+    context 'operator .' do
+      pattern '/hello/{.person}' do
+        it { should match('/hello/.Frank') .capturing person: 'Frank' }
+        it { should match('/hello/.a_b~c') .capturing person: 'a_b~c' }
+
+        it { should_not match('/hello/.:') }
+        it { should_not match('/hello/./') }
+        it { should_not match('/hello/.?') }
+        it { should_not match('/hello/.#') }
+        it { should_not match('/hello/.[') }
+        it { should_not match('/hello/.]') }
+        it { should_not match('/hello/.@') }
+        it { should_not match('/hello/.!') }
+        it { should_not match('/hello/.*') }
+        it { should_not match('/hello/.+') }
+        it { should_not match('/hello/.,') }
+        it { should_not match('/hello/.;') }
+        it { should_not match('/hello/.=') }
+
+        it { should_not match('/hello/Frank')  }
+        it { should_not match('/hello/a_b~c')  }
+        it { should_not match('/hello/a.%20')  }
+
+        it { should_not match('/hello/:') }
+        it { should_not match('/hello//') }
+        it { should_not match('/hello/?') }
+        it { should_not match('/hello/#') }
+        it { should_not match('/hello/[') }
+        it { should_not match('/hello/]') }
+        it { should_not match('/hello/@') }
+        it { should_not match('/hello/!') }
+        it { should_not match('/hello/*') }
+        it { should_not match('/hello/+') }
+        it { should_not match('/hello/,') }
+        it { should_not match('/hello/;') }
+        it { should_not match('/hello/=') }
+      end
+
+      pattern "{.a,b,c}" do
+        it { should match(".~x.42._").capturing a: '~x', b: '42', c: '_' }
+        it { should_not match(".~x,42")   }
+        it { should_not match(".~x/42")   }
+        it { should_not match(".~x#42")   }
+        it { should_not match(".~x,42,_") }
+        it { should_not match("~x.42._")  }
+      end
+    end
+
+    context 'operator /' do
+      pattern '/hello{/person}' do
+        it { should match('/hello/Frank') .capturing person: 'Frank' }
+        it { should match('/hello/a_b~c') .capturing person: 'a_b~c' }
+
+        it { should_not match('/hello//:') }
+        it { should_not match('/hello///') }
+        it { should_not match('/hello//?') }
+        it { should_not match('/hello//#') }
+        it { should_not match('/hello//[') }
+        it { should_not match('/hello//]') }
+        it { should_not match('/hello//@') }
+        it { should_not match('/hello//!') }
+        it { should_not match('/hello//*') }
+        it { should_not match('/hello//+') }
+        it { should_not match('/hello//,') }
+        it { should_not match('/hello//;') }
+        it { should_not match('/hello//=') }
+
+        it { should_not match('/hello/:') }
+        it { should_not match('/hello//') }
+        it { should_not match('/hello/?') }
+        it { should_not match('/hello/#') }
+        it { should_not match('/hello/[') }
+        it { should_not match('/hello/]') }
+        it { should_not match('/hello/@') }
+        it { should_not match('/hello/!') }
+        it { should_not match('/hello/*') }
+        it { should_not match('/hello/+') }
+        it { should_not match('/hello/,') }
+        it { should_not match('/hello/;') }
+        it { should_not match('/hello/=') }
+      end
+
+      pattern "{/a,b,c}" do
+        it { should match("/~x/42/_").capturing a: '~x', b: '42', c: '_' }
+        it { should_not match("/~x,42")   }
+        it { should_not match("/~x.42")   }
+        it { should_not match("/~x#42")   }
+        it { should_not match("/~x,42,_") }
+        it { should_not match("~x/42/_")  }
+      end
+    end
+
+    context 'operator ;' do
+      pattern '/hello/{;person}' do
+        it { should match('/hello/;person=Frank') .capturing person: 'Frank' }
+        it { should match('/hello/;person=a_b~c') .capturing person: 'a_b~c' }
+        it { should match('/hello/;person')       .capturing person: nil     }
+
+        it { should_not match('/hello/;persona=Frank') }
+        it { should_not match('/hello/;persona=a_b~c') }
+
+        it { should_not match('/hello/;person=:') }
+        it { should_not match('/hello/;person=/') }
+        it { should_not match('/hello/;person=?') }
+        it { should_not match('/hello/;person=#') }
+        it { should_not match('/hello/;person=[') }
+        it { should_not match('/hello/;person=]') }
+        it { should_not match('/hello/;person=@') }
+        it { should_not match('/hello/;person=!') }
+        it { should_not match('/hello/;person=*') }
+        it { should_not match('/hello/;person=+') }
+        it { should_not match('/hello/;person=,') }
+        it { should_not match('/hello/;person=;') }
+        it { should_not match('/hello/;person==') }
+
+        it { should_not match('/hello/;Frank')  }
+        it { should_not match('/hello/;a_b~c')  }
+        it { should_not match('/hello/;a.%20')  }
+
+        it { should_not match('/hello/:') }
+        it { should_not match('/hello//') }
+        it { should_not match('/hello/?') }
+        it { should_not match('/hello/#') }
+        it { should_not match('/hello/[') }
+        it { should_not match('/hello/]') }
+        it { should_not match('/hello/@') }
+        it { should_not match('/hello/!') }
+        it { should_not match('/hello/*') }
+        it { should_not match('/hello/+') }
+        it { should_not match('/hello/,') }
+        it { should_not match('/hello/;') }
+        it { should_not match('/hello/=') }
+      end
+
+      pattern "{;a,b,c}" do
+        it { should match(";a=~x;b=42;c=_") .capturing a: '~x', b: '42', c: '_' }
+        it { should match(";a=~x;b;c=_")    .capturing a: '~x', b: nil,  c: '_' }
+
+        it { should_not match(";a=~x;c=_;b=42").capturing a: '~x', b: '42', c: '_' }
+
+        it { should_not match(";a=~x;b=42")     }
+        it { should_not match("a=~x;b=42")      }
+        it { should_not match(";a=~x;b=#42;c")  }
+        it { should_not match(";a=~x,b=42,c=_") }
+        it { should_not match("~x;b=42;c=_")    }
+      end
+    end
+
+    context 'operator ?' do
+      pattern '/hello/{?person}' do
+        it { should match('/hello/?person=Frank') .capturing person: 'Frank' }
+        it { should match('/hello/?person=a_b~c') .capturing person: 'a_b~c' }
+        it { should match('/hello/?person')       .capturing person: nil     }
+
+        it { should_not match('/hello/?persona=Frank') }
+        it { should_not match('/hello/?persona=a_b~c') }
+
+        it { should_not match('/hello/?person=:') }
+        it { should_not match('/hello/?person=/') }
+        it { should_not match('/hello/?person=?') }
+        it { should_not match('/hello/?person=#') }
+        it { should_not match('/hello/?person=[') }
+        it { should_not match('/hello/?person=]') }
+        it { should_not match('/hello/?person=@') }
+        it { should_not match('/hello/?person=!') }
+        it { should_not match('/hello/?person=*') }
+        it { should_not match('/hello/?person=+') }
+        it { should_not match('/hello/?person=,') }
+        it { should_not match('/hello/?person=;') }
+        it { should_not match('/hello/?person==') }
+
+        it { should_not match('/hello/?Frank')  }
+        it { should_not match('/hello/?a_b~c')  }
+        it { should_not match('/hello/?a.%20')  }
+
+        it { should_not match('/hello/:') }
+        it { should_not match('/hello//') }
+        it { should_not match('/hello/?') }
+        it { should_not match('/hello/#') }
+        it { should_not match('/hello/[') }
+        it { should_not match('/hello/]') }
+        it { should_not match('/hello/@') }
+        it { should_not match('/hello/!') }
+        it { should_not match('/hello/*') }
+        it { should_not match('/hello/+') }
+        it { should_not match('/hello/,') }
+        it { should_not match('/hello/;') }
+        it { should_not match('/hello/=') }
+      end
+
+      pattern "{?a,b,c}" do
+        it { should match("?a=~x&b=42&c=_") .capturing a: '~x', b: '42', c: '_' }
+        it { should match("?a=~x&b&c=_")    .capturing a: '~x', b: nil,  c: '_' }
+
+        it { should_not match("?a=~x&c=_&b=42").capturing a: '~x', b: '42', c: '_' }
+
+        it { should_not match("?a=~x&b=42")     }
+        it { should_not match("a=~x&b=42")      }
+        it { should_not match("?a=~x&b=#42&c")  }
+        it { should_not match("?a=~x,b=42,c=_") }
+        it { should_not match("~x&b=42&c=_")    }
+      end
+    end
+
+    context 'operator &' do
+      pattern '/hello/{&person}' do
+        it { should match('/hello/&person=Frank') .capturing person: 'Frank' }
+        it { should match('/hello/&person=a_b~c') .capturing person: 'a_b~c' }
+        it { should match('/hello/&person')       .capturing person: nil     }
+
+        it { should_not match('/hello/&persona=Frank') }
+        it { should_not match('/hello/&persona=a_b~c') }
+
+        it { should_not match('/hello/&person=:') }
+        it { should_not match('/hello/&person=/') }
+        it { should_not match('/hello/&person=?') }
+        it { should_not match('/hello/&person=#') }
+        it { should_not match('/hello/&person=[') }
+        it { should_not match('/hello/&person=]') }
+        it { should_not match('/hello/&person=@') }
+        it { should_not match('/hello/&person=!') }
+        it { should_not match('/hello/&person=*') }
+        it { should_not match('/hello/&person=+') }
+        it { should_not match('/hello/&person=,') }
+        it { should_not match('/hello/&person=;') }
+        it { should_not match('/hello/&person==') }
+
+        it { should_not match('/hello/&Frank')  }
+        it { should_not match('/hello/&a_b~c')  }
+        it { should_not match('/hello/&a.%20')  }
+
+        it { should_not match('/hello/:') }
+        it { should_not match('/hello//') }
+        it { should_not match('/hello/?') }
+        it { should_not match('/hello/#') }
+        it { should_not match('/hello/[') }
+        it { should_not match('/hello/]') }
+        it { should_not match('/hello/@') }
+        it { should_not match('/hello/!') }
+        it { should_not match('/hello/*') }
+        it { should_not match('/hello/+') }
+        it { should_not match('/hello/,') }
+        it { should_not match('/hello/;') }
+        it { should_not match('/hello/=') }
+      end
+
+      pattern "{&a,b,c}" do
+        it { should match("&a=~x&b=42&c=_") .capturing a: '~x', b: '42', c: '_' }
+        it { should match("&a=~x&b&c=_")    .capturing a: '~x', b: nil,  c: '_' }
+
+        it { should_not match("&a=~x&c=_&b=42").capturing a: '~x', b: '42', c: '_' }
+
+        it { should_not match("&a=~x&b=42")     }
+        it { should_not match("a=~x&b=42")      }
+        it { should_not match("&a=~x&b=#42&c")  }
+        it { should_not match("&a=~x,b=42,c=_") }
+        it { should_not match("~x&b=42&c=_")    }
+      end
+    end
+  end
+
+  context 'level 4' do
+    context 'without operator' do
+      context 'prefix' do
+        pattern '{a:3}/bar' do
+          it { should match('foo/bar') .capturing a: 'foo' }
+          it { should match('fo/bar')  .capturing a: 'fo'  }
+          it { should match('f/bar')   .capturing a: 'f'   }
+          it { should_not match('fooo/bar') }
+        end
+
+        pattern '{a:3}{b}' do
+          it { should match('foobar') .capturing a: 'foo', b: 'bar' }
+        end
+      end
+
+      context 'expand' do
+        pattern '{a*}' do
+          it { should match('a')     .capturing a: 'a'     }
+          it { should match('a,b')   .capturing a: 'a,b'   }
+          it { should match('a,b,c') .capturing a: 'a,b,c' }
+          it { should_not match('a,b/c') }
+          it { should_not match('a,') }
+
+          example { pattern.params('a').should be == { 'a' => ['a'] }}
+          example { pattern.params('a,b').should be == { 'a' => ['a', 'b'] }}
+        end
+
+        pattern '{a*},{b}' do
+          it { should match('a,b')   .capturing a: 'a',   b: 'b' }
+          it { should match('a,b,c') .capturing a: 'a,b', b: 'c' }
+          it { should_not match('a,b/c') }
+          it { should_not match('a,') }
+
+          example { pattern.params('a,b').should be == { 'a' => ['a'], 'b' => 'b' }}
+          example { pattern.params('a,b,c').should be == { 'a' => ['a', 'b'], 'b' => 'c' }}
+        end
+
+        pattern '{a*,b}' do
+          it { should match('a,b')   .capturing a: 'a',   b: 'b' }
+          it { should match('a,b,c') .capturing a: 'a,b', b: 'c' }
+          it { should_not match('a,b/c') }
+          it { should_not match('a,') }
+
+          example { pattern.params('a,b').should be == { 'a' => ['a'], 'b' => 'b' }}
+          example { pattern.params('a,b,c').should be == { 'a' => ['a', 'b'], 'b' => 'c' }}
+        end
+      end
+    end
+
+    context 'operator +' do
+      pattern '/{a}/{+b}' do
+        it { should match('/foo/bar/baz').capturing(a: 'foo', b: 'bar/baz') }
+        it { should expand(a: 'foo/bar', b: 'foo/bar').to('/foo%2Fbar/foo/bar') }
+      end
+
+      context 'prefix' do
+        pattern '{+a:3}/bar' do
+          it { should match('foo/bar') .capturing a: 'foo' }
+          it { should match('fo/bar')  .capturing a: 'fo'  }
+          it { should match('f/bar')   .capturing a: 'f'   }
+          it { should_not match('fooo/bar') }
+        end
+
+        pattern '{+a:3}{b}' do
+          it { should match('foobar') .capturing a: 'foo', b: 'bar' }
+        end
+      end
+
+      context 'expand' do
+        pattern '{+a*}' do
+          it { should match('a')     .capturing a: 'a'     }
+          it { should match('a,b')   .capturing a: 'a,b'   }
+          it { should match('a,b,c') .capturing a: 'a,b,c' }
+          it { should match('a,b/c') .capturing a: 'a,b/c' }
+        end
+
+        pattern '{+a*},{b}' do
+          it { should match('a,b')   .capturing a: 'a',   b: 'b' }
+          it { should match('a,b,c') .capturing a: 'a,b', b: 'c' }
+          it { should_not match('a,b/c') }
+          it { should_not match('a,') }
+
+          example { pattern.params('a,b').should be == { 'a' => ['a'], 'b' => 'b' }}
+          example { pattern.params('a,b,c').should be == { 'a' => ['a', 'b'], 'b' => 'c' }}
+        end
+      end
+    end
+
+    context 'operator #' do
+      context 'prefix' do
+        pattern '{#a:3}/bar' do
+          it { should match('#foo/bar') .capturing a: 'foo' }
+          it { should match('#fo/bar')  .capturing a: 'fo'  }
+          it { should match('#f/bar')   .capturing a: 'f'   }
+          it { should_not match('#fooo/bar') }
+        end
+
+        pattern '{#a:3}{b}' do
+          it { should match('#foobar') .capturing a: 'foo', b: 'bar' }
+        end
+      end
+
+      context 'expand' do
+        pattern '{#a*}' do
+          it { should match('#a')     .capturing a: 'a'     }
+          it { should match('#a,b')   .capturing a: 'a,b'   }
+          it { should match('#a,b,c') .capturing a: 'a,b,c' }
+          it { should match('#a,b/c') .capturing a: 'a,b/c' }
+
+          example { pattern.params('#a,b').should be == { 'a' => ['a', 'b'] }}
+          example { pattern.params('#a,b,c').should be == { 'a' => ['a', 'b', 'c'] }}
+        end
+
+        pattern '{#a*,b}' do
+          it { should match('#a,b')   .capturing a: 'a',   b: 'b' }
+          it { should match('#a,b,c') .capturing a: 'a,b', b: 'c' }
+          it { should_not match('#a,') }
+
+          example { pattern.params('#a,b').should be == { 'a' => ['a'], 'b' => 'b' }}
+          example { pattern.params('#a,b,c').should be == { 'a' => ['a', 'b'], 'b' => 'c' }}
+        end
+      end
+    end
+
+    context 'operator .' do
+      context 'prefix' do
+        pattern '{.a:3}/bar' do
+          it { should match('.foo/bar') .capturing a: 'foo' }
+          it { should match('.fo/bar')  .capturing a: 'fo'  }
+          it { should match('.f/bar')   .capturing a: 'f'   }
+          it { should_not match('.fooo/bar') }
+        end
+
+        pattern '{.a:3}{b}' do
+          it { should match('.foobar') .capturing a: 'foo', b: 'bar' }
+        end
+      end
+
+      context 'expand' do
+        pattern '{.a*}' do
+          it { should match('.a')     .capturing a: 'a'     }
+          it { should match('.a.b')   .capturing a: 'a.b'   }
+          it { should match('.a.b.c') .capturing a: 'a.b.c' }
+          it { should_not match('.a.b,c') }
+          it { should_not match('.a,') }
+        end
+
+        pattern '{.a*,b}' do
+          it { should match('.a.b')   .capturing a: 'a',   b: 'b' }
+          it { should match('.a.b.c') .capturing a: 'a.b', b: 'c' }
+          it { should_not match('.a.b/c') }
+          it { should_not match('.a.') }
+
+          example { pattern.params('.a.b').should be == { 'a' => ['a'], 'b' => 'b' }}
+          example { pattern.params('.a.b.c').should be == { 'a' => ['a', 'b'], 'b' => 'c' }}
+        end
+      end
+    end
+
+    context 'operator /' do
+      context 'prefix' do
+        pattern '{/a:3}/bar' do
+          it { should match('/foo/bar') .capturing a: 'foo' }
+          it { should match('/fo/bar')  .capturing a: 'fo'  }
+          it { should match('/f/bar')   .capturing a: 'f'   }
+          it { should_not match('/fooo/bar') }
+        end
+
+        pattern '{/a:3}{b}' do
+          it { should match('/foobar') .capturing a: 'foo', b: 'bar' }
+        end
+      end
+
+      context 'expand' do
+        pattern '{/a*}' do
+          it { should match('/a')     .capturing a: 'a'     }
+          it { should match('/a/b')   .capturing a: 'a/b'   }
+          it { should match('/a/b/c') .capturing a: 'a/b/c' }
+          it { should_not match('/a/b,c') }
+          it { should_not match('/a,') }
+        end
+
+        pattern '{/a*,b}' do
+          it { should match('/a/b')   .capturing a: 'a',   b: 'b' }
+          it { should match('/a/b/c') .capturing a: 'a/b', b: 'c' }
+          it { should_not match('/a/b,c') }
+          it { should_not match('/a/') }
+
+          example { pattern.params('/a/b').should be == { 'a' => ['a'], 'b' => 'b' }}
+          example { pattern.params('/a/b/c').should be == { 'a' => ['a', 'b'], 'b' => 'c' }}
+        end
+      end
+    end
+
+    context 'operator ;' do
+      context 'prefix' do
+        pattern '{;a:3}/bar' do
+          it { should match(';a=foo/bar') .capturing a: 'foo' }
+          it { should match(';a=fo/bar')  .capturing a: 'fo'  }
+          it { should match(';a=f/bar')   .capturing a: 'f'   }
+          it { should_not match(';a=fooo/bar') }
+        end
+
+        pattern '{;a:3}{b}' do
+          it { should match(';a=foobar') .capturing a: 'foo', b: 'bar' }
+        end
+      end
+
+      context 'expand' do
+        pattern '{;a*}' do
+          it { should match(';a=1')         .capturing a: 'a=1'         }
+          it { should match(';a=1;a=2')     .capturing a: 'a=1;a=2'     }
+          it { should match(';a=1;a=2;a=3') .capturing a: 'a=1;a=2;a=3' }
+          it { should_not match(';a=1;a=2;b=3') }
+          it { should_not match(';a=1;a=2;a=3,') }
+        end
+
+        pattern '{;a*,b}' do
+          it { should match(';a=1;b')       .capturing a: 'a=1',     b: nil }
+          it { should match(';a=2;a=2;b=1') .capturing a: 'a=2;a=2', b: '1' }
+          it { should_not match(';a;b;c') }
+          it { should_not match(';a;') }
+
+          example { pattern.params(';a=2;a=2;b').should be == { 'a' => ['2', '2'], 'b' => nil }}
+        end
+      end
+    end
+
+    context 'operator ?' do
+      context 'prefix' do
+        pattern '{?a:3}/bar' do
+          it { should match('?a=foo/bar') .capturing a: 'foo' }
+          it { should match('?a=fo/bar')  .capturing a: 'fo'  }
+          it { should match('?a=f/bar')   .capturing a: 'f'   }
+          it { should_not match('?a=fooo/bar') }
+        end
+
+        pattern '{?a:3}{b}' do
+          it { should match('?a=foobar') .capturing a: 'foo', b: 'bar' }
+        end
+      end
+
+      context 'expand' do
+        pattern '{?a*}' do
+          it { should match('?a=1')         .capturing a: 'a=1'         }
+          it { should match('?a=1&a=2')     .capturing a: 'a=1&a=2'     }
+          it { should match('?a=1&a=2&a=3') .capturing a: 'a=1&a=2&a=3' }
+          it { should_not match('?a=1&a=2&b=3') }
+          it { should_not match('?a=1&a=2&a=3,') }
+        end
+
+        pattern '{?a*,b}' do
+          it { should match('?a=1&b')       .capturing a: 'a=1',     b: nil }
+          it { should match('?a=2&a=2&b=1') .capturing a: 'a=2&a=2', b: '1' }
+          it { should_not match('?a&b&c') }
+          it { should_not match('?a&') }
+
+          example { pattern.params('?a=2&a=2&b').should be == { 'a' => ['2', '2'], 'b' => nil }}
+        end
+      end
+    end
+
+    context 'operator &' do
+      context 'prefix' do
+        pattern '{&a:3}/bar' do
+          it { should match('&a=foo/bar') .capturing a: 'foo' }
+          it { should match('&a=fo/bar')  .capturing a: 'fo'  }
+          it { should match('&a=f/bar')   .capturing a: 'f'   }
+          it { should_not match('&a=fooo/bar') }
+        end
+
+        pattern '{&a:3}{b}' do
+          it { should match('&a=foobar') .capturing a: 'foo', b: 'bar' }
+        end
+      end
+
+      context 'expand' do
+        pattern '{&a*}' do
+          it { should match('&a=1')         .capturing a: 'a=1'         }
+          it { should match('&a=1&a=2')     .capturing a: 'a=1&a=2'     }
+          it { should match('&a=1&a=2&a=3') .capturing a: 'a=1&a=2&a=3' }
+          it { should_not match('&a=1&a=2&b=3') }
+          it { should_not match('&a=1&a=2&a=3,') }
+        end
+
+        pattern '{&a*,b}' do
+          it { should match('&a=1&b')       .capturing a: 'a=1',     b: nil }
+          it { should match('&a=2&a=2&b=1') .capturing a: 'a=2&a=2', b: '1' }
+          it { should_not match('&a&b&c') }
+          it { should_not match('&a&') }
+
+          example { pattern.params('&a=2&a=2&b').should be == { 'a' => ['2', '2'], 'b' => nil }}
+          example { pattern.params('&a=2&a=%20&b').should be == { 'a' => ['2', ' '], 'b' => nil }}
+        end
+      end
+    end
+  end
+
+  context 'invalid syntax' do
+    example 'unexpected closing bracket' do
+      expect { Mustermann::Template.new('foo}bar') }.
+        to raise_error(Mustermann::ParseError, 'unexpected } while parsing "foo}bar"')
+    end
+
+    example 'missing closing bracket' do
+      expect { Mustermann::Template.new('foo{bar') }.
+        to raise_error(Mustermann::ParseError, 'unexpected end of string while parsing "foo{bar"')
+    end
+  end
+
+  context "peeking" do
+    subject(:pattern) { Mustermann::Template.new("{name}bar") }
+
+    describe :peek_size do
+      example { pattern.peek_size("foo%20bar/blah") .should be == "foo%20bar".size }
+      example { pattern.peek_size("/foo bar")       .should be_nil }
+    end
+
+    describe :peek_match do
+      example { pattern.peek_match("foo%20bar/blah") .to_s .should be == "foo%20bar" }
+      example { pattern.peek_match("/foo bar")             .should be_nil }
+    end
+
+    describe :peek_params do
+      example { pattern.peek_params("foo%20bar/blah") .should be == [{"name" => "foo "}, "foo%20bar".size] }
+      example { pattern.peek_params("/foo bar")       .should be_nil }
+    end
+  end
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: mustermann-uri-template
+version: !ruby/object:Gem::Version
+  version: 0.4.0
+platform: ruby
+authors:
+- Konstantin Haase
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mustermann
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+description: Adds URI template style patterns to Mustermman
+email: konstantin.mailinglists@googlemail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/mustermann/template.rb
+- lib/mustermann/uri_template.rb
+- mustermann-uri-template.gemspec
+- spec/template_spec.rb
+homepage: https://github.com/rkh/mustermann
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.3
+signing_key: 
+specification_version: 4
+summary: URI template syntax for Mustermann
+test_files:
+- spec/template_spec.rb
+has_rdoc: