mustermann19 0.3.1 → 0.3.1.1

data/spec/rails_spec.rb

@@ -11,6 +11,11 @@ describe Mustermann::Rails do
 
     it { should expand.to('') }
     it { should_not expand(a: 1) }
+
+    it { should generate_template('') }
+
+    it { should respond_to(:expand)       }
+    it { should respond_to(:to_templates) }
   end
 
   pattern '/' do
@@ -62,6 +67,8 @@ describe Mustermann::Rails do
     it { should_not expand(foo: 'foo', bar: 'bar') }
     it { should_not expand(bar: 'bar') }
     it { should_not expand }
+
+    it { should generate_template('/{foo}') }
   end
 
   pattern '/föö' do
@@ -86,23 +93,29 @@ describe Mustermann::Rails do
     it { should expand(foo: 'foo', bar: 'bar').to('/foo/bar') }
     it { should_not expand(foo: 'foo') }
     it { should_not expand(bar: 'bar') }
+
+    it { should generate_template('/{foo}/{bar}') }
   end
 
   pattern '/hello/:person' do
     it { should match('/hello/Frank').capturing person: 'Frank' }
     it { should expand(person: 'Frank')   .to '/hello/Frank'    }
     it { should expand(person: 'Frank?')  .to '/hello/Frank%3F' }
+
+    it { should generate_template('/hello/{person}') }
   end
 
   pattern '/?:foo?/?:bar?' do
     it { should match('/?hello?/?world?').capturing foo: 'hello', bar: 'world' }
     it { should_not match('/hello/world/') }
     it { should expand(foo: 'hello', bar: 'world').to('/%3Fhello%3F/%3Fworld%3F') }
+    it { should generate_template('/?{foo}?/?{bar}?') }
   end
 
   pattern '/:foo_bar' do
     it { should match('/hello').capturing foo_bar: 'hello' }
     it { should expand(foo_bar: 'hello').to('/hello') }
+    it { should generate_template('/{foo_bar}') }
   end
 
   pattern '/*foo' do
@@ -116,6 +129,15 @@ describe Mustermann::Rails do
     it { should expand(foo: 'foo')      .to('/foo')     }
     it { should expand(foo: 'foo/bar')  .to('/foo/bar') }
     it { should expand(foo: 'foo.bar')  .to('/foo.bar') }
+
+    it { should generate_template('/{+foo}') }
+  end
+
+  pattern '/*splat' do
+    it { should match('/')        .capturing splat: '' }
+    it { should match('/foo')     .capturing splat: 'foo' }
+    it { should match('/foo/bar') .capturing splat: 'foo/bar' }
+    it { should generate_template('/{+splat}') }
   end
 
   pattern '/:foo/*bar' do
@@ -129,6 +151,8 @@ describe Mustermann::Rails do
     it { should expand(foo: 'foo',     bar: 'bar')     .to('/foo/bar')       }
     it { should expand(foo: 'foo',     bar: 'foo/bar') .to('/foo/foo/bar')   }
     it { should expand(foo: 'foo/bar', bar: 'bar')     .to('/foo%2Fbar/bar') }
+
+    it { should generate_template('/{foo}/{+bar}') }
   end
 
   pattern '/test$/' do
@@ -148,6 +172,8 @@ describe Mustermann::Rails do
     it { should match('/path%2Bwith%2Bspaces')     }
     it { should match('/path+with+spaces')         }
     it { should expand.to('/path%20with%20spaces') }
+
+    it { should generate_template('/path%20with%20spaces') }
   end
 
   pattern '/foo&bar' do
@@ -158,6 +184,7 @@ describe Mustermann::Rails do
     it { should match('/bar/foo/bling/baz/boom').capturing a: 'bar', foo: 'foo', b: 'bling', c: 'baz/boom'  }
     example { pattern.params('/bar/foo/bling/baz/boom').should be == { "a" => 'bar', "foo" => 'foo', "b" => 'bling', "c" => 'baz/boom' } }
     it { should expand(a: 'bar', foo: 'foo', b: 'bling', c: 'baz/boom').to('/bar/foo/bling/baz/boom') }
+    it { should generate_template('/{+a}/{foo}/{+b}/{+c}') }
   end
 
   pattern '/test.bar' do
@@ -189,6 +216,9 @@ describe Mustermann::Rails do
     it { should match('/axaxx') .capturing a: 'axax' }
     it { should expand(a: 'x').to('/xx') }
     it { should expand(a: 'a').to('/ax') }
+
+    it { should generate_template('/{a}x') }
+    it { should generate_template('/{a}')  }
   end
 
   pattern '/:user(@:host)' do
@@ -198,6 +228,9 @@ describe Mustermann::Rails do
 
     it { should expand(user: 'foo')              .to('/foo')     }
     it { should expand(user: 'foo', host: 'bar') .to('/foo@bar') }
+
+    it { should generate_template('/{user}')        }
+    it { should generate_template('/{user}@{host}') }
   end
 
   pattern '/:file(.:ext)' do
@@ -211,6 +244,9 @@ describe Mustermann::Rails do
 
     it { should expand(file: 'pony')              .to('/pony')     }
     it { should expand(file: 'pony', ext: 'jpg')  .to('/pony.jpg') }
+
+    it { should generate_template('/{file}')       }
+    it { should generate_template('/{file}.{ext}') }
   end
 
   pattern '/:id/test.bar' do
@@ -245,6 +281,10 @@ describe Mustermann::Rails do
 
     it { should expand(a: ?a, b: ?b)        .to('/a/b.')  }
     it { should expand(a: ?a, b: ?b, c: ?c) .to('/a/b.c') }
+
+    it { should generate_template('/{a}/{b}')      }
+    it { should generate_template('/{a}/{b}.')     }
+    it { should generate_template('/{a}/{b}.{c}')  }
   end
 
   pattern '/:a(foo:b)' do
@@ -255,6 +295,10 @@ describe Mustermann::Rails do
 
     it { should expand(a: ?a)        .to('/a')     }
     it { should expand(a: ?a, b: ?b) .to('/afoob') }
+
+    it { should     generate_template('/{a}foo{b}') }
+    it { should     generate_template('/{a}')       }
+    it { should_not generate_template('/{a}foo')    }
   end
 
   pattern '/fo(o)' do
@@ -512,11 +556,41 @@ describe Mustermann::Rails do
     end
 
     describe :to_regexp do
-      example('empty pattern') { Mustermann::Rails.new('').to_regexp.should be == /\A\Z/ }
+      example('empty pattern') { Mustermann::Rails.new('').to_regexp.should be == /\A(?-mix:)\Z/ }
 
       context 'Regexp.try_convert' do
-        example('empty pattern') { Regexp.try_convert(Mustermann::Rails.new('')).should be == /\A\Z/ }
+        example('empty pattern') { Regexp.try_convert(Mustermann::Rails.new('')).should be == /\A(?-mix:)\Z/ }
       end
     end
   end
+
+  context 'Proc compatibility' do
+    describe :to_proc do
+      example { Mustermann::Rails.new("/").to_proc.should be_a(Proc) }
+      example('non-matching') { Mustermann::Rails.new("/")     .to_proc.call('/foo').should be == false }
+      example('matching')     { Mustermann::Rails.new("/:foo") .to_proc.call('/foo').should be == true  }
+    end
+  end
+
+  context "peeking" do
+    subject(:pattern) { Mustermann::Rails.new(":name") }
+
+    describe :peek_size do
+      example { pattern.peek_size("foo bar/blah")   .should be == "foo bar".size }
+      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 bar/blah")   .to_s .should be == "foo bar" }
+      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 bar/blah")   .should be == [{"name" => "foo bar"}, "foo bar".size] }
+      example { pattern.peek_params("foo%20bar/blah") .should be == [{"name" => "foo bar"}, "foo%20bar".size] }
+      example { pattern.peek_params("/foo bar")       .should be_nil }
+    end
+  end
 end

data/spec/regular_spec.rb

@@ -7,6 +7,9 @@ describe Mustermann::Regular do
   pattern '' do
     it { should     match('')  }
     it { should_not match('/') }
+
+    it { should_not respond_to(:expand)       }
+    it { should_not respond_to(:to_templates) }
   end
 
   pattern '/' do
@@ -33,4 +36,26 @@ describe Mustermann::Regular do
     it { should match('/%0Afoo')    .capturing foo: '%0Afoo'    }
     it { should match('/foo%2Fbar') .capturing foo: 'foo%2Fbar' }
   end
+
+  context "peeking" do
+    subject(:pattern) { Mustermann::Regular.new("(?<name>[^/]+)") }
+
+    describe :peek_size do
+      example { pattern.peek_size("foo bar/blah")   .should be == "foo bar".size }
+      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 bar/blah")   .to_s .should be == "foo bar" }
+      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 bar/blah")   .should be == [{"name" => "foo bar"}, "foo bar".size] }
+      example { pattern.peek_params("foo%20bar/blah") .should be == [{"name" => "foo bar"}, "foo%20bar".size] }
+      example { pattern.peek_params("/foo bar")       .should be_nil }
+    end
+  end
 end

data/spec/shell_spec.rb

@@ -8,6 +8,9 @@ describe Mustermann::Shell do
   pattern '' do
     it { should     match('')  }
     it { should_not match('/') }
+
+    it { should_not respond_to(:expand)       }
+    it { should_not respond_to(:to_templates) }
   end
 
   pattern '/' do
@@ -106,4 +109,34 @@ describe Mustermann::Shell do
   describe :=~ do
     example { '/foo'.should be =~ Mustermann::Shell.new('/foo') }
   end
+
+  context "peeking", :skip => true do
+    subject(:pattern) { Mustermann::Shell.new("foo*/") }
+
+    describe :peek_size do
+      example { pattern.peek_size("foo bar/blah")   .should be == "foo bar/".size }
+      example { pattern.peek_size("foo%20bar/blah") .should be == "foo%20bar/".size }
+      example { pattern.peek_size("/foo bar")       .should be_nil }
+
+      context 'with just * as pattern' do
+        subject(:pattern) { Mustermann::Shell.new('*') }
+        example { pattern.peek_size('foo')              .should be == 3 }
+        example { pattern.peek_size('foo/bar')          .should be == 3 }
+        example { pattern.peek_size('foo/bar/baz')      .should be == 3 }
+        example { pattern.peek_size('foo/bar/baz/blah') .should be == 3 }
+      end
+    end
+
+    describe :peek_match do
+      example { pattern.peek_match("foo bar/blah")   .to_s .should be == "foo bar/" }
+      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 bar/blah")   .should be == [{}, "foo bar/".size] }
+      example { pattern.peek_params("foo%20bar/blah") .should be == [{}, "foo%20bar/".size] }
+      example { pattern.peek_params("/foo bar")       .should be_nil }
+    end
+  end
 end

data/spec/simple_spec.rb

@@ -8,6 +8,9 @@ describe Mustermann::Simple do
   pattern '' do
     it { should     match('')  }
     it { should_not match('/') }
+
+    it { should_not respond_to(:expand)       }
+    it { should_not respond_to(:to_templates) }
   end
 
   pattern '/' do
@@ -234,4 +237,26 @@ describe Mustermann::Simple do
         to raise_error(Mustermann::CompileError)
     end
   end
+
+  context "peeking" do
+    subject(:pattern) { Mustermann::Simple.new(":name") }
+
+    describe :peek_size do
+      example { pattern.peek_size("foo bar/blah")   .should be == "foo bar".size }
+      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 bar/blah")   .to_s .should be == "foo bar" }
+      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 bar/blah")   .should be == [{"name" => "foo bar"}, "foo bar".size] }
+      example { pattern.peek_params("foo%20bar/blah") .should be == [{"name" => "foo bar"}, "foo%20bar".size] }
+      example { pattern.peek_params("/foo bar")       .should be_nil }
+    end
+  end
 end

data/spec/sinatra_spec.rb

@@ -8,6 +8,11 @@ describe Mustermann::Sinatra do
   pattern '' do
     it { should     match('')  }
     it { should_not match('/') }
+
+    it { should generate_template('') }
+
+    it { should respond_to(:expand)       }
+    it { should respond_to(:to_templates) }
   end
 
   pattern '/' do
@@ -44,6 +49,8 @@ describe Mustermann::Sinatra do
     it { should_not match('/foo/bar') }
     it { should_not match('/')        }
     it { should_not match('/foo/')    }
+
+    it { should generate_template('/{foo}') }
   end
 
   pattern '/föö' do
@@ -62,10 +69,34 @@ describe Mustermann::Sinatra do
 
     example { pattern.params('/bar/foo').should be == {"foo" => "bar", "bar" => "foo"} }
     example { pattern.params('').should be_nil }
+
+    it { should generate_template('/{foo}/{bar}') }
+  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('/user@example.com/name') .capturing foo: 'user@example.com', bar: 'name'    }
+    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') }
+
+    example { pattern.params('/bar/foo').should be == {"foo" => "bar", "bar" => "foo"} }
+    example { pattern.params('').should be_nil }
+
+    it { should generate_template('/{foo}/{bar}') }
   end
 
   pattern '/hello/:person' do
     it { should match('/hello/Frank').capturing person: 'Frank' }
+    it { should generate_template('/hello/{person}') }
+  end
+
+  pattern '/hello/{person}' do
+    it { should match('/hello/Frank').capturing person: 'Frank' }
+    it { should generate_template('/hello/{person}') }
   end
 
   pattern '/?:foo?/?:bar?' do
@@ -74,23 +105,40 @@ describe Mustermann::Sinatra do
     it { should match('/')            .capturing foo: nil,     bar: nil     }
     it { should match('')             .capturing foo: nil,     bar: nil     }
 
-    it { should_not match('/hello/world/') }
+    it { should expand(foo: 'hello')               .to('/hello/')      }
+    it { should expand(foo: 'hello', bar: 'world') .to('/hello/world') }
+    it { should expand(bar: 'world')               .to('//world')      }
+    it { should expand                             .to('//')           }
+    it { should_not expand(baz: '') }
 
-    # it { should expand(foo: 'hello')               .to('/hello')       }
-    # it { should expand(foo: 'hello', bar: 'world') .to('/hello/world') }
-    # it { should expand(bar: 'world')               .to('//world')      }
-    # it { should expand                             .to('')             }
-    # it { should_not expand(baz: '') }
+    it { should_not match('/hello/world/') }
+    it { should generate_templates("", "/", "//", "//{bar}", "/{bar}", "/{foo}", "/{foo}/", "/{foo}/{bar}", "/{foo}{bar}", "{bar}", "{foo}", "{foo}/", "{foo}/{bar}", "{foo}{bar}") }
   end
 
   pattern '/:foo_bar' do
     it { should match('/hello').capturing foo_bar: 'hello' }
+    it { should generate_template('/{foo_bar}') }
+  end
+
+  pattern '/{foo.bar}' do
+    it { should match('/hello').capturing :"foo.bar" => 'hello' }
+    it { should generate_template('/{foo.bar}') }
   end
 
   pattern '/*' do
     it { should match('/')        .capturing splat: '' }
     it { should match('/foo')     .capturing splat: 'foo' }
     it { should match('/foo/bar') .capturing splat: 'foo/bar' }
+    it { should generate_template('/{+splat}') }
+
+    example { pattern.params('/foo').should be == {"splat" => ["foo"]} }
+  end
+
+  pattern '/{+splat}' do
+    it { should match('/')        .capturing splat: '' }
+    it { should match('/foo')     .capturing splat: 'foo' }
+    it { should match('/foo/bar') .capturing splat: 'foo/bar' }
+    it { should generate_template('/{+splat}') }
 
     example { pattern.params('/foo').should be == {"splat" => ["foo"]} }
   end
@@ -99,6 +147,17 @@ describe Mustermann::Sinatra do
     it { should match('/')        .capturing foo: ''        }
     it { should match('/foo')     .capturing foo: 'foo'     }
     it { should match('/foo/bar') .capturing foo: 'foo/bar' }
+    it { should generate_template('/{+foo}') }
+
+    example { pattern.params('/foo')     .should be == {"foo" => "foo"     } }
+    example { pattern.params('/foo/bar') .should be == {"foo" => "foo/bar" } }
+  end
+
+  pattern '/{+foo}' do
+    it { should match('/')        .capturing foo: ''        }
+    it { should match('/foo')     .capturing foo: 'foo'     }
+    it { should match('/foo/bar') .capturing foo: 'foo/bar' }
+    it { should generate_template('/{+foo}') }
 
     example { pattern.params('/foo')     .should be == {"foo" => "foo"     } }
     example { pattern.params('/foo/bar') .should be == {"foo" => "foo/bar" } }
@@ -106,6 +165,12 @@ describe Mustermann::Sinatra do
 
   pattern '/*foo/*bar' do
     it { should match('/foo/bar') .capturing foo: 'foo', bar: 'bar' }
+    it { should generate_template('/{+foo}/{+bar}') }
+  end
+
+  pattern '/{+foo}/{+bar}' do
+    it { should match('/foo/bar') .capturing foo: 'foo', bar: 'bar' }
+    it { should generate_template('/{+foo}/{+bar}') }
   end
 
   pattern '/:foo/*' do
@@ -113,6 +178,18 @@ describe Mustermann::Sinatra do
     it { should match("/foo/")            .capturing foo: 'foo',   splat: ''          }
     it { should match('/h%20w/h%20a%20y') .capturing foo: 'h%20w', splat: 'h%20a%20y' }
     it { should_not match('/foo') }
+    it { should generate_template('/{foo}/{+splat}') }
+
+    example { pattern.params('/bar/foo').should be == {"splat" => ["foo"], "foo" => "bar"} }
+    example { pattern.params('/bar/foo/f%20o').should be == {"splat" => ["foo/f o"], "foo" => "bar"} }
+  end
+
+  pattern '/{foo}/*' do
+    it { should match("/foo/bar/baz")     .capturing foo: 'foo',   splat: 'bar/baz'   }
+    it { should match("/foo/")            .capturing foo: 'foo',   splat: ''          }
+    it { should match('/h%20w/h%20a%20y') .capturing foo: 'h%20w', splat: 'h%20a%20y' }
+    it { should_not match('/foo') }
+    it { should generate_template('/{foo}/{+splat}') }
 
     example { pattern.params('/bar/foo').should be == {"splat" => ["foo"], "foo" => "bar"} }
     example { pattern.params('/bar/foo/f%20o').should be == {"splat" => ["foo/f o"], "foo" => "bar"} }
@@ -132,12 +209,18 @@ describe Mustermann::Sinatra do
     it { should match('/path%20with%20spaces') }
     it { should match('/path%2Bwith%2Bspaces') }
     it { should match('/path+with+spaces')     }
+
+    it { should generate_template('/path%20with%20spaces') }
   end
 
   pattern '/foo&bar' do
     it { should match('/foo&bar') }
   end
 
+  pattern '/foo\{bar' do
+    it { should match('/foo%7Bbar') }
+  end
+
   pattern '/*/:foo/*/*' do
     it { should match('/bar/foo/bling/baz/boom') }
 
@@ -154,13 +237,29 @@ describe Mustermann::Sinatra do
     end
   end
 
+  pattern '/{+splat}/{foo}/{+splat}/{+splat}' do
+    it { should match('/bar/foo/bling/baz/boom') }
+
+    it "should capture all splat parts" do
+      match = pattern.match('/bar/foo/bling/baz/boom')
+      match.captures.should be == ['bar', 'foo', 'bling', 'baz/boom']
+      match.names.should be == ['splat', 'foo']
+    end
+
+    it 'should map to proper params' do
+      pattern.params('/bar/foo/bling/baz/boom').should be == {
+        "foo" => "foo", "splat" => ['bar', 'bling', 'baz/boom']
+      }
+    end
+  end
+
   pattern '/test.bar' do
     it { should     match('/test.bar') }
     it { should_not match('/test0bar') }
   end
 
   pattern '/:file.:ext' do
-    it { should match('/pony.jpg')    .capturing file: 'pony', ext: 'jpg' }
+    it { should match('/pony.jpg')   .capturing file: 'pony', ext: 'jpg' }
     it { should match('/pony%2Ejpg') .capturing file: 'pony', ext: 'jpg' }
     it { should match('/pony%2ejpg') .capturing file: 'pony', ext: 'jpg' }
 
@@ -180,12 +279,18 @@ describe Mustermann::Sinatra do
     it { should match('/ax')    .capturing a: 'a'   }
     it { should match('/axax')  .capturing a: 'axa' }
     it { should match('/axaxx') .capturing a: 'axax' }
+
+    it { should generate_template('/{a}x') }
+    it { should generate_template('/{a}')  }
   end
 
   pattern '/:user(@:host)?' do
     it { should match('/foo@bar')     .capturing user: 'foo',     host: 'bar'     }
     it { should match('/foo.foo@bar') .capturing user: 'foo.foo', host: 'bar'     }
     it { should match('/foo@bar.bar') .capturing user: 'foo',     host: 'bar.bar' }
+
+    it { should generate_template('/{user}')        }
+    it { should generate_template('/{user}@{host}') }
   end
 
   pattern '/:file(.:ext)?' do
@@ -196,6 +301,10 @@ describe Mustermann::Sinatra do
     it { should match('/pony.png.jpg')   .capturing file: 'pony.png', ext: 'jpg' }
     it { should match('/pony.')          .capturing file: 'pony.' }
     it { should_not match('/.jpg')  }
+
+    it { should     generate_template('/{file}')       }
+    it { should     generate_template('/{file}.{ext}') }
+    it { should_not generate_template('/{file}.')      }
   end
 
   pattern '/:id/test.bar' do
@@ -324,6 +433,37 @@ describe Mustermann::Sinatra do
     it { should match('/foo/bar/baz').capturing foo: 'foo', bar: 'bar', baz: 'baz' }
   end
 
+  pattern "/(foo|bar)" do
+    it { should match("/foo") }
+    it { should match("/bar") }
+
+    it { should generate_template('/foo') }
+    it { should generate_template('/bar') }
+  end
+
+  pattern "/(foo\\|bar)" do
+    it { should match             "/foo%7Cbar" }
+    it { should generate_template "/foo%7Cbar" }
+
+    it { should_not match("/foo") }
+    it { should_not match("/bar") }
+
+    it { should_not generate_template('/foo') }
+    it { should_not generate_template('/bar') }
+  end
+
+  pattern "/(:a/:b|:c)" do
+    it { should match("/foo")     .capturing c: 'foo'           }
+    it { should match("/foo/bar") .capturing a: 'foo', b: 'bar' }
+
+    it { should generate_template('/{a}/{b}') }
+    it { should generate_template('/{c}')     }
+
+    it { should expand(a: 'foo', b: 'bar') .to('/foo/bar') }
+    it { should expand(c: 'foo')           .to('/foo')     }
+    it { should_not expand(a: 'foo', b: 'bar', c: 'baz')   }
+  end
+
   pattern '/:foo', capture: /\d+/ do
     it { should match('/1')   .capturing foo: '1'   }
     it { should match('/123') .capturing foo: '123' }
@@ -509,6 +649,11 @@ describe Mustermann::Sinatra do
         to raise_error(Mustermann::ParseError, 'unexpected ? while parsing "foo??bar"')
     end
 
+    example '| outside of group' do
+      expect { Mustermann::Sinatra.new('foo|bar') }.
+        to raise_error(Mustermann::ParseError, 'unexpected | while parsing "foo|bar"')
+    end
+
     example 'dangling escape' do
       expect { Mustermann::Sinatra.new('foo\\') }.
         to raise_error(Mustermann::ParseError, 'unexpected end of string while parsing "foo\\\\"')
@@ -564,11 +709,41 @@ describe Mustermann::Sinatra do
     end
 
     describe :to_regexp do
-      example('empty pattern') { Mustermann::Sinatra.new('').to_regexp.should be == /\A\Z/ }
+      example('empty pattern') { Mustermann::Sinatra.new('').to_regexp.should be == /\A(?-mix:)\Z/ }
 
       context 'Regexp.try_convert' do
-        example('empty pattern') { Regexp.try_convert(Mustermann::Sinatra.new('')).should be == /\A\Z/ }
+        example('empty pattern') { Regexp.try_convert(Mustermann::Sinatra.new('')).should be == /\A(?-mix:)\Z/ }
       end
     end
   end
+
+  context 'Proc compatibility' do
+    describe :to_proc do
+      example { Mustermann::Sinatra.new("/").to_proc.should be_a(Proc) }
+      example('non-matching') { Mustermann::Sinatra.new("/")     .to_proc.call('/foo').should be == false }
+      example('matching')     { Mustermann::Sinatra.new("/:foo") .to_proc.call('/foo').should be == true  }
+    end
+  end
+
+  context "peeking" do
+    subject(:pattern) { Mustermann::Sinatra.new(":name") }
+
+    describe :peek_size do
+      example { pattern.peek_size("foo bar/blah")   .should be == "foo bar".size }
+      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 bar/blah")   .to_s .should be == "foo bar" }
+      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 bar/blah")   .should be == [{"name" => "foo bar"}, "foo bar".size] }
+      example { pattern.peek_params("foo%20bar/blah") .should be == [{"name" => "foo bar"}, "foo%20bar".size] }
+      example { pattern.peek_params("/foo bar")       .should be_nil }
+    end
+  end
 end