mustermann 0.0.1

data/lib/mustermann/version.rb

@@ -0,0 +1,3 @@
+module Mustermann
+  VERSION ||= '0.0.1'
+end

data/mustermann.gemspec

@@ -0,0 +1,28 @@
+$:.unshift File.expand_path("../lib", __FILE__)
+require "mustermann/version"
+
+Gem::Specification.new do |s|
+  s.name                  = "mustermann"
+  s.version               = Mustermann::VERSION
+  s.author                = "Konstantin Haase"
+  s.email                 = "konstantin.mailinglists@googlemail.com"
+  s.homepage              = "https://github.com/rkh/mustermann"
+  s.summary               = %q{use patterns like regular expressions}
+  s.description           = %q{library implementing patterns that behave like regular expressions}
+  s.license               = 'MIT'
+  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.extra_rdoc_files      = %w[README.md]
+  s.require_path          = 'lib'
+  s.required_ruby_version = '>= 2.0.0'
+
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'sinatra', '~> 1.4'
+  s.add_development_dependency 'rack-test'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'yard'
+  s.add_development_dependency 'redcarpet'
+  s.add_development_dependency 'simplecov'
+  s.add_development_dependency 'coveralls'
+end

data/spec/ast_spec.rb

@@ -0,0 +1,8 @@
+require 'support'
+require 'mustermann/ast'
+
+describe Mustermann::AST do
+  it 'raises a NotImplementedError when used directly' do
+    expect { described_class.new("x") === "x" }.to raise_error(NotImplementedError)
+  end
+end

data/spec/extension_spec.rb

@@ -0,0 +1,153 @@
+require 'support'
+require 'mustermann/extension'
+require 'sinatra/base'
+require 'rack/test'
+
+describe Mustermann::Extension do
+  include Rack::Test::Methods
+
+  subject :app do
+    Sinatra.new do
+      set :environment, :test
+      register Mustermann
+    end
+  end
+
+  it 'sets up the extension' do
+    app.should be_a(Mustermann::Extension)
+  end
+
+  context 'uses Sinatra-style patterns by default' do
+    before { app.get('/:slug(.:extension)?') { params[:slug] } }
+    example { get('/foo')     .body.should be == 'foo'  }
+    example { get('/foo.')    .body.should be == 'foo.' }
+    example { get('/foo.bar') .body.should be == 'foo'  }
+    example { get('/a%20b')   .body.should be == 'a b'  }
+  end
+
+  describe :except do
+    before { app.get('/auth/*', except: '/auth/login') { 'ok' } }
+    example { get('/auth/dunno').should     be_ok }
+    example { get('/auth/login').should_not be_ok }
+  end
+
+  describe :capture do
+    context 'global' do
+      before do
+        app.set(:pattern, capture: { ext: %w[png jpg gif] })
+        app.get('/:slug(.:ext)?') { params[:slug] }
+      end
+
+      example { get('/foo.bar').body.should be == 'foo.bar' }
+      example { get('/foo.png').body.should be == 'foo'     }
+    end
+
+    context 'route local' do
+      before do
+        app.get('/:id', capture: /\d+/) { 'ok' }
+      end
+
+      example { get('/42').should be_ok }
+      example { get('/foo').should_not be_ok }
+    end
+
+    context 'global and route local' do
+      context 'global is a hash' do
+        before do
+          app.set(:pattern, capture: { id: /\d+/ })
+          app.get('/:id(.:ext)?', capture: { ext: 'png' }) { ?a }
+          app.get('/:id',         capture: { id: 'foo'  }) { ?b }
+          app.get('/:id',         capture: :alpha)         { ?c }
+        end
+
+        example { get('/20')     .body.should be == ?a }
+        example { get('/20.png') .body.should be == ?a }
+        example { get('/foo')    .body.should be == ?b }
+        example { get('/bar')    .body.should be == ?c }
+      end
+
+      context 'global is not a hash' do
+        before do
+          app.set(:pattern, capture: /\d+/)
+          app.get('/:slug(.:ext)?', capture: { ext: 'png' }) { params[:slug] }
+          app.get('/:slug', capture: :alpha) { 'ok' }
+        end
+
+        example { get('/20.png').should be_ok }
+        example { get('/foo.png').should_not be_ok }
+        example { get('/foo').should be_ok }
+
+        example { get('/20.png') .body.should be == '20' }
+        example { get('/42')     .body.should be == '42' }
+        example { get('/foo')    .body.should be == 'ok' }
+      end
+    end
+  end
+
+  describe :type do
+    describe :identity do
+      before do
+        app.set(:pattern, type: :identity)
+        app.get('/:foo') { 'ok' }
+      end
+
+      example { get('/:foo').should be_ok }
+      example { get('/foo').should_not be_ok }
+    end
+
+    describe :rails do
+      before do
+        app.set(:pattern, type: :rails)
+        app.get('/:slug(.:extension)') { params[:slug] }
+      end
+
+      example { get('/foo')     .body.should be == 'foo'  }
+      example { get('/foo.')    .body.should be == 'foo.' }
+      example { get('/foo.bar') .body.should be == 'foo'  }
+      example { get('/a%20b')   .body.should be == 'a b'  }
+    end
+
+    describe :shell do
+      before do
+        app.set(:pattern, type: :shell)
+        app.get('/{foo,bar}') { 'ok' }
+      end
+
+      example { get('/foo').should be_ok }
+      example { get('/bar').should be_ok }
+    end
+
+    describe :simple do
+      before do
+        app.set(:pattern, type: :simple)
+        app.get('/(a)') { 'ok' }
+      end
+
+      example { get('/(a)').should be_ok }
+      example { get('/a').should_not be_ok }
+    end
+
+    describe :simple do
+      before do
+        app.set(:pattern, type: :template)
+        app.get('/foo{/segments*}{.ext}') { "%p %p" % [params[:segments], params[:ext]] }
+      end
+
+      example { get('/foo/a.png').should be_ok }
+      example { get('/foo/a').should_not be_ok }
+
+      example { get('/foo/a.png').body.should be == '["a"] "png"' }
+      example { get('/foo/a/b.png').body.should be == '["a", "b"] "png"' }
+    end
+  end
+
+  context 'works with filters' do
+    before do
+      app.before('/auth/*', except: '/auth/login') { halt 'auth required' }
+      app.get('/auth/login') { 'please log in' }
+    end
+
+    example { get('/auth/dunno').body.should be == 'auth required' }
+    example { get('/auth/login').body.should be == 'please log in' }
+  end
+end

data/spec/identity_spec.rb

@@ -0,0 +1,82 @@
+require 'support'
+require 'mustermann/identity'
+
+describe Mustermann::Identity do
+  extend Support::Pattern
+
+  pattern '' do
+    it { should     match('')  }
+    it { should_not match('/') }
+  end
+
+  pattern '/' do
+    it { should     match('/')    }
+    it { should_not match('/foo') }
+
+    example { pattern.params('/').should be == {} }
+    example { pattern.params('').should be_nil }
+  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 match('/foo%2Fbar') }
+    it { should 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_not match('/path%2Bwith%2Bspaces') }
+    it { should_not 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 '/foo/bar', uri_decode: false do
+    it { should     match('/foo/bar')   }
+    it { should_not match('/foo%2Fbar') }
+    it { should_not match('/foo%2fbar') }
+  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
+end

data/spec/pattern_spec.rb

@@ -0,0 +1,16 @@
+require 'support'
+require 'mustermann/pattern'
+
+describe Mustermann::Pattern do
+  it 'raises a NotImplementedError when used directly' do
+    expect { described_class.new("") === "" }.to raise_error(NotImplementedError)
+  end
+
+  it 'raises an ArgumentError for unknown options' do
+    expect { described_class.new("", foo: :bar) }.to raise_error(ArgumentError)
+  end
+
+  it 'does not complain about unknown options if ignore_unknown_options is enabled' do
+    expect { described_class.new("", foo: :bar, ignore_unknown_options: true) }.not_to raise_error
+  end
+end

data/spec/rails_spec.rb

@@ -0,0 +1,453 @@
+require 'support'
+require 'mustermann/rails'
+
+describe Mustermann::Rails do
+  extend Support::Pattern
+
+  pattern '' do
+    it { should     match('')  }
+    it { should_not match('/') }
+  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')       .capturing foo: 'foo'       }
+    it { should match('/bar')       .capturing foo: 'bar'       }
+    it { should match('/foo.bar')   .capturing foo: 'foo.bar'   }
+    it { should match('/%0Afoo')    .capturing foo: '%0Afoo'    }
+    it { should match('/foo%2Fbar') .capturing foo: 'foo%2Fbar' }
+
+    it { should_not match('/foo?')    }
+    it { should_not match('/foo/bar') }
+    it { should_not match('/')        }
+    it { should_not match('/foo/')    }
+
+    example { pattern.params('/foo').should be == {"foo" => "foo"} }
+    example { pattern.params('/f%20o').should be == {"foo" => "f o"} }
+    example { pattern.params('').should be_nil }
+  end
+
+  pattern '/föö' do
+    it { should match("/f%C3%B6%C3%B6") }
+  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 }
+  end
+
+  pattern '/hello/:person' do
+    it { should match('/hello/Frank').capturing person: 'Frank' }
+  end
+
+  pattern '/?:foo?/?:bar?' do
+    it { should match('/?hello?/?world?').capturing foo: 'hello', bar: 'world' }
+    it { should_not match('/hello/world/') }
+  end
+
+  pattern '/:foo_bar' do
+    it { should match('/hello').capturing foo_bar: 'hello' }
+  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' }
+  end
+
+  pattern '/:foo/*bar' do
+    it { should match("/foo/bar/baz")     .capturing foo: 'foo',   bar: 'bar/baz'   }
+    it { should match("/foo/")            .capturing foo: 'foo',   bar: ''          }
+    it { should match('/h%20w/h%20a%20y') .capturing foo: 'h%20w', bar: 'h%20a%20y' }
+    it { should_not match('/foo') }
+  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 '/*a/:foo/*b/*c' 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' } }
+  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%2Ejpg') .capturing file: 'pony', ext: 'jpg' }
+    it { should match('/pony%2ejpg') .capturing file: 'pony', ext: 'jpg' }
+
+    it { should match('/pony%E6%AD%A3%2Ejpg') .capturing file: 'pony%E6%AD%A3', ext: 'jpg' }
+    it { should match('/pony%e6%ad%a3%2ejpg') .capturing file: 'pony%e6%ad%a3', ext: 'jpg' }
+    it { should match('/pony正%2Ejpg')        .capturing file: 'pony正',         ext: 'jpg' }
+    it { should match('/pony正%2ejpg')        .capturing file: 'pony正',         ext: 'jpg' }
+    it { should match('/pony正..jpg')         .capturing file: 'pony正.',        ext: 'jpg' }
+
+    it { should_not match('/.jpg') }
+  end
+
+  pattern '/:a(x)' do
+    it { should match('/a')     .capturing a: 'a'   }
+    it { should match('/xa')    .capturing a: 'xa'  }
+    it { should match('/axa')   .capturing a: 'axa' }
+    it { should match('/ax')    .capturing a: 'a'   }
+    it { should match('/axax')  .capturing a: 'axa' }
+    it { should match('/axaxx') .capturing a: 'axax' }
+  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' }
+  end
+
+  pattern '/:file(.:ext)' do
+    it { should match('/pony')           .capturing file: 'pony', ext: nil   }
+    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' }
+    it { should match('/pony.png.jpg')   .capturing file: 'pony.png', ext: 'jpg' }
+    it { should match('/pony.')          .capturing file: 'pony.' }
+    it { should_not match('/.jpg')  }
+  end
+
+  pattern '/:id/test.bar' do
+    it { should match('/3/test.bar')   .capturing id: '3'   }
+    it { should match('/2/test.bar')   .capturing id: '2'   }
+    it { should match('/2E/test.bar')  .capturing id: '2E'  }
+    it { should match('/2e/test.bar')  .capturing id: '2e'  }
+    it { should match('/%2E/test.bar') .capturing id: '%2E' }
+  end
+
+  pattern '/10/:id' do
+    it { should match('/10/test')  .capturing id: 'test'  }
+    it { should match('/10/te.st') .capturing id: 'te.st' }
+  end
+
+  pattern '/10.1/:id' do
+    it { should match('/10.1/test')  .capturing id: 'test'  }
+    it { should match('/10.1/te.st') .capturing id: 'te.st' }
+  end
+
+  pattern '/:foo.:bar/:id' do
+    it { should match('/10.1/te.st')   .capturing foo: "10",   bar: "1", id: "te.st" }
+    it { should match('/10.1.2/te.st') .capturing foo: "10.1", bar: "2", id: "te.st" }
+  end
+
+  pattern '/:a/:b(.)(:c)' do
+    it { should match('/a/b')     .capturing a: 'a',   b: 'b', c: nil }
+    it { should match('/a/b.c')   .capturing a: 'a',   b: 'b', c: 'c' }
+    it { should match('/a.b/c')   .capturing a: 'a.b', b: 'c', c: nil }
+    it { should match('/a.b/c.d') .capturing a: 'a.b', b: 'c', c: 'd' }
+    it { should_not match('/a.b/c.d/e') }
+  end
+
+  pattern '/:a(foo:b)' do
+    it { should match('/barfoobar')       .capturing a: 'bar',       b: 'bar' }
+    it { should match('/barfoobarfoobar') .capturing a: 'barfoobar', b: 'bar' }
+    it { should match('/bar')             .capturing a: 'bar',       b: nil   }
+    it { should_not match('/') }
+  end
+
+  pattern '/fo(o)' do
+    it { should     match('/fo')   }
+    it { should     match('/foo')  }
+    it { should_not match('')      }
+    it { should_not match('/')     }
+    it { should_not match('/f')    }
+    it { should_not match('/fooo') }
+  end
+
+  pattern '/foo?' do
+    it { should     match('/foo?')  }
+    it { should_not match('/foo\?') }
+    it { should_not match('/fo')    }
+    it { should_not match('/foo')   }
+    it { should_not match('')       }
+    it { should_not match('/')      }
+    it { should_not match('/f')     }
+    it { should_not match('/fooo')  }
+  end
+
+  pattern '/:fOO' do
+    it { should match('/a').capturing fOO: 'a' }
+  end
+
+  pattern '/:_X' do
+    it { should match('/a').capturing _X: 'a' }
+  end
+
+  pattern '/:f00' do
+    it { should match('/a').capturing f00: 'a' }
+  end
+
+  pattern '/:foo(/:bar)/:baz' do
+    it { should match('/foo/bar/baz').capturing foo: 'foo', bar: 'bar', baz: 'baz' }
+  end
+
+  pattern '/:foo', capture: /\d+/ do
+    it { should match('/1')   .capturing foo: '1'   }
+    it { should match('/123') .capturing foo: '123' }
+
+    it { should_not match('/')    }
+    it { should_not match('/foo') }
+  end
+
+  pattern '/:foo', capture: /\d+/ do
+    it { should match('/1')   .capturing foo: '1'   }
+    it { should match('/123') .capturing foo: '123' }
+
+    it { should_not match('/')    }
+    it { should_not match('/foo') }
+  end
+
+  pattern '/:foo', capture: '1' do
+    it { should match('/1').capturing foo: '1' }
+
+    it { should_not match('/')    }
+    it { should_not match('/foo') }
+    it { should_not match('/123') }
+  end
+
+  pattern '/:foo', capture: 'a.b' do
+    it { should match('/a.b')   .capturing foo: 'a.b'   }
+    it { should match('/a%2Eb') .capturing foo: 'a%2Eb' }
+    it { should match('/a%2eb') .capturing foo: 'a%2eb' }
+
+    it { should_not match('/ab')   }
+    it { should_not match('/afb')  }
+    it { should_not match('/a1b')  }
+    it { should_not match('/a.bc') }
+  end
+
+  pattern '/:foo(/:bar)', capture: :alpha do
+    it { should match('/abc') .capturing foo: 'abc', bar: nil }
+    it { should match('/a/b') .capturing foo: 'a',   bar: 'b' }
+    it { should match('/a')   .capturing foo: 'a',   bar: nil }
+
+    it { should_not match('/1/2') }
+    it { should_not match('/a/2') }
+    it { should_not match('/1/b') }
+    it { should_not match('/1')   }
+    it { should_not match('/1/')  }
+    it { should_not match('/a/')  }
+    it { should_not match('//a')  }
+  end
+
+  pattern '/:foo', capture: ['foo', 'bar', /\d+/] do
+    it { should match('/1')   .capturing foo: '1'   }
+    it { should match('/123') .capturing foo: '123' }
+    it { should match('/foo') .capturing foo: 'foo' }
+    it { should match('/bar') .capturing foo: 'bar' }
+
+    it { should_not match('/')     }
+    it { should_not match('/baz')  }
+    it { should_not match('/foo1') }
+  end
+
+  pattern '/:foo:bar:baz', capture: { foo: :alpha, bar: /\d+/ } do
+    it { should match('/ab123xy-1') .capturing foo: 'ab', bar: '123', baz: 'xy-1' }
+    it { should match('/ab123')     .capturing foo: 'ab', bar: '12',  baz: '3'    }
+    it { should_not match('/123abcxy-1') }
+    it { should_not match('/abcxy-1')    }
+    it { should_not match('/abc1')       }
+  end
+
+  pattern '/:foo', capture: { foo: ['foo', 'bar', /\d+/] } do
+    it { should match('/1')   .capturing foo: '1'   }
+    it { should match('/123') .capturing foo: '123' }
+    it { should match('/foo') .capturing foo: 'foo' }
+    it { should match('/bar') .capturing foo: 'bar' }
+
+    it { should_not match('/')     }
+    it { should_not match('/baz')  }
+    it { should_not match('/foo1') }
+  end
+
+  pattern '/:file(.:ext)', capture: { ext: ['jpg', 'png'] } do
+    it { should match('/pony')         .capturing file: 'pony',     ext: nil   }
+    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' }
+    it { should match('/pony.png')     .capturing file: 'pony',     ext: 'png' }
+    it { should match('/pony%2Epng')   .capturing file: 'pony',     ext: 'png' }
+    it { should match('/pony%2epng')   .capturing file: 'pony',     ext: 'png' }
+    it { should match('/pony.png.jpg') .capturing file: 'pony.png', ext: 'jpg' }
+    it { should match('/pony.jpg.png') .capturing file: 'pony.jpg', ext: 'png' }
+    it { should match('/pony.gif')     .capturing file: 'pony.gif', ext: nil   }
+    it { should match('/pony.')        .capturing file: 'pony.',    ext: nil   }
+    it { should_not match('.jpg') }
+  end
+
+  pattern '/:file(:ext)', capture: { ext: ['.jpg', '.png', '.tar.gz'] } do
+    it { should match('/pony')         .capturing file: 'pony',     ext: nil       }
+    it { should match('/pony.jpg')     .capturing file: 'pony',     ext: '.jpg'    }
+    it { should match('/pony.png')     .capturing file: 'pony',     ext: '.png'    }
+    it { should match('/pony.png.jpg') .capturing file: 'pony.png', ext: '.jpg'    }
+    it { should match('/pony.jpg.png') .capturing file: 'pony.jpg', ext: '.png'    }
+    it { should match('/pony.tar.gz')  .capturing file: 'pony',     ext: '.tar.gz' }
+    it { should match('/pony.gif')     .capturing file: 'pony.gif', ext: nil       }
+    it { should match('/pony.')        .capturing file: 'pony.',    ext: nil       }
+    it { should_not match('/.jpg')  }
+  end
+
+  pattern '/:a(@:b)', capture: { b: /\d+/ } do
+    it { should match('/a')     .capturing a: 'a',   b: nil }
+    it { should match('/a@1')   .capturing a: 'a',   b: '1' }
+    it { should match('/a@b')   .capturing a: 'a@b', b: nil }
+    it { should match('/a@1@2') .capturing a: 'a@1', b: '2' }
+  end
+
+  pattern '/:a(b)', greedy: false do
+    it { should match('/ab').capturing a: 'a' }
+  end
+
+  pattern '/:file(.:ext)', greedy: false do
+    it { should match('/pony')           .capturing file: 'pony', ext: nil       }
+    it { should match('/pony.jpg')       .capturing file: 'pony', ext: 'jpg'     }
+    it { should match('/pony.png.jpg')   .capturing file: 'pony', ext: 'png.jpg' }
+  end
+
+  pattern '/:controller(/:action(/:id(.:format)))' do
+    it { should match('/content').capturing controller: 'content' }
+  end
+
+  pattern '/fo(o)', uri_decode: false do
+    it { should     match('/foo')   }
+    it { should     match('/fo')    }
+    it { should_not match('/fo(o)') }
+  end
+
+  pattern '/foo/bar', uri_decode: false do
+    it { should     match('/foo/bar')   }
+    it { should_not match('/foo%2Fbar') }
+    it { should_not match('/foo%2fbar') }
+  end
+
+  pattern "/path with spaces", uri_decode: false do
+    it { should     match('/path with spaces')     }
+    it { should_not match('/path%20with%20spaces') }
+    it { should_not match('/path%2Bwith%2Bspaces') }
+    it { should_not match('/path+with+spaces')     }
+  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
+
+  context 'invalid syntax' do
+    example 'unexpected closing parenthesis' do
+      expect { Mustermann::Rails.new('foo)bar') }.
+        to raise_error(Mustermann::ParseError, 'unexpected ) while parsing "foo)bar"')
+    end
+
+    example 'missing closing parenthesis' do
+      expect { Mustermann::Rails.new('foo(bar') }.
+        to raise_error(Mustermann::ParseError, 'unexpected end of string while parsing "foo(bar"')
+    end
+  end
+
+  context 'invalid capture names' do
+    example 'empty name' do
+      expect { Mustermann::Rails.new('/:/') }.
+        to raise_error(Mustermann::CompileError, "capture name can't be empty: \"/:/\"")
+    end
+
+    example 'named splat' do
+      expect { Mustermann::Rails.new('/:splat/') }.
+        to raise_error(Mustermann::CompileError, "capture name can't be splat: \"/:splat/\"")
+    end
+
+    example 'named captures' do
+      expect { Mustermann::Rails.new('/:captures/') }.
+        to raise_error(Mustermann::CompileError, "capture name can't be captures: \"/:captures/\"")
+    end
+
+    example 'with capital letter' do
+      expect { Mustermann::Rails.new('/:Foo/') }.
+        to raise_error(Mustermann::CompileError, "capture name must start with underscore or lower case letter: \"/:Foo/\"")
+    end
+
+    example 'with integer' do
+      expect { Mustermann::Rails.new('/:1a/') }.
+        to raise_error(Mustermann::CompileError, "capture name must start with underscore or lower case letter: \"/:1a/\"")
+    end
+
+    example 'same name twice' do
+      expect { Mustermann::Rails.new('/:foo(/:bar)/:bar') }.
+        to raise_error(Mustermann::CompileError, "can't use the same capture name twice: \"/:foo(/:bar)/:bar\"")
+    end
+  end
+
+  context 'Regexp compatibility' do
+    describe :=== do
+      example('non-matching') { Mustermann::Rails.new("/")     .should_not be === '/foo' }
+      example('matching')     { Mustermann::Rails.new("/:foo") .should     be === '/foo' }
+    end
+
+    describe :=~ do
+      example('non-matching') { Mustermann::Rails.new("/")     .should_not be =~ '/foo' }
+      example('matching')     { Mustermann::Rails.new("/:foo") .should     be =~ '/foo' }
+
+      context 'String#=~' do
+        example('non-matching') { "/foo".should_not be =~ Mustermann::Rails.new("/") }
+        example('matching')     { "/foo".should     be =~ Mustermann::Rails.new("/:foo") }
+      end
+    end
+
+    describe :to_regexp do
+      example('empty pattern') { Mustermann::Rails.new('').to_regexp.should be == /\A\Z/ }
+
+      context 'Regexp.try_convert' do
+        example('empty pattern') { Regexp.try_convert(Mustermann::Rails.new('')).should be == /\A\Z/ }
+      end
+    end
+  end
+end