mustermann19 0.3.1

data/spec/regexp_based_spec.rb

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

data/spec/regular_spec.rb

@@ -0,0 +1,36 @@
+require 'support'
+require 'mustermann/regular'
+
+describe Mustermann::Regular 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' }
+  end
+end

data/spec/router/rack_spec.rb

@@ -0,0 +1,39 @@
+require 'mustermann/router/rack'
+
+describe Mustermann::Router::Rack do
+  include Rack::Test::Methods
+  subject(:app) { Mustermann::Router::Rack.new }
+
+  context 'matching' do
+    before { app.on('/foo') { [418, {'Content-Type' => 'text/plain'}, 'bar'] } }
+    example { get('/foo').status.should be == 418 }
+    example { get('/bar').status.should be == 404 }
+  end
+
+  context "params" do
+    before { app.on('/:name') { |e| [200, {'Content-Type' => 'text/plain'}, e['mustermann.params']['name']] } }
+    example { get('/foo').body.should be == 'foo' }
+    example { get('/bar').body.should be == 'bar' }
+  end
+
+  context 'X-Cascade: pass' do
+    before do
+      app.on('/') { [200, { 'X-Cascade'    => 'pass'       }, ['a']] }
+      app.on('/') { [200, { 'x-cascade'    => 'pass'       }, ['b']] }
+      app.on('/') { [200, { 'Content-Type' => 'text/plain' }, ['c']] }
+      app.on('/') { [200, { 'Content-Type' => 'text/plain' }, ['d']] }
+    end
+
+    example { get('/').body.should be == 'c' }
+  end
+
+  context 'throw :pass' do
+    before do
+      app.on('/') { throw :pass }
+      app.on('/') { [200, { 'Content-Type' => 'text/plain' }, ['b']] }
+      app.on('/') { [200, { 'Content-Type' => 'text/plain' }, ['c']] }
+    end
+
+    example { get('/').body.should be == 'b' }
+  end
+end

data/spec/router/simple_spec.rb

@@ -0,0 +1,32 @@
+require 'mustermann/router/simple'
+
+describe Mustermann::Router::Simple do
+  describe :initialize do
+    context "with implicit receiver" do
+      subject(:router) { Mustermann::Router::Simple.new { on('/foo') { 'bar' } } }
+      example { router.call('/foo').should be == 'bar' }
+    end
+
+    context "with explicit receiver" do
+      subject(:router) { Mustermann::Router::Simple.new { |r| r.on('/foo') { 'bar' } } }
+      example { router.call('/foo').should be == 'bar' }
+    end
+
+    context "with default" do
+      subject(:router) { Mustermann::Router::Simple.new(default: 'bar') }
+      example { router.call('/foo').should be == 'bar' }
+    end
+  end
+
+  describe :[]= do
+    subject(:router) { Mustermann::Router::Simple.new }
+    before { router['/:name'] = proc { |*a| a } }
+    example { router.call('/foo').should be == ['/foo', "name" => 'foo'] }
+  end
+
+  describe :[] do
+    subject(:router) { Mustermann::Router::Simple.new }
+    before { router.on('/x') { 42 } }
+    example { router['/x'].call.should be == 42 }
+  end
+end

data/spec/shell_spec.rb

@@ -0,0 +1,109 @@
+# -*- encoding: utf-8 -*-
+require 'support'
+require 'mustermann/shell'
+
+describe Mustermann::Shell 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 '/*/bar' do
+    it { should     match('/foo/bar')     }
+    it { should     match('/bar/bar')     }
+    it { should     match('/foo%2Fbar')   }
+    it { should     match('/foo%2fbar')   }
+    it { should_not match('/foo/foo/bar') }
+    it { should_not match('/bar/foo')     }
+  end
+
+  pattern '/**/foo' do
+    it { should match('/a/b/c/foo')   }
+    it { should match('/a/b/c/foo')   }
+    it { should match('/a/.b/c/foo')  }
+    it { should match('/a/.b/c/foo')  }
+  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}' do
+    it(nil, skip: true) { should     match('/foo')    }
+    it(nil, skip: true) { should     match('/bar')    }
+    it { should_not match('/foobar') }
+  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
+
+  describe :=~ do
+    example { '/foo'.should be =~ Mustermann::Shell.new('/foo') }
+  end
+end

data/spec/simple_match_spec.rb

@@ -0,0 +1,10 @@
+require 'support'
+require 'mustermann/simple_match'
+
+describe Mustermann::SimpleMatch do
+  subject { Mustermann::SimpleMatch.new('example') }
+  its(:to_s) { should be == 'example' }
+  its(:names) { should be == [] }
+  its(:captures) { should be == [] }
+  example { subject[1].should be == nil }
+end

data/spec/simple_spec.rb

@@ -0,0 +1,237 @@
+# -*- encoding: utf-8 -*-
+require 'support'
+require 'mustermann/simple'
+
+describe Mustermann::Simple 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/')    }
+  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 match('/hello')       .capturing foo: 'hello', bar: nil     }
+    it { should match('/')            .capturing foo: nil,     bar: nil     }
+    it { should match('')             .capturing foo: nil,     bar: nil     }
+
+    it { should_not match('/hello/world/') }
+  end
+
+  pattern '/*' do
+    it { should match('/')        .capturing splat: '' }
+    it { should match('/foo')     .capturing splat: 'foo' }
+    it { should match('/foo/bar') .capturing splat: 'foo/bar' }
+
+    example { pattern.params('/foo').should be == {"splat" => ["foo"]} }
+  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') }
+
+    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 '/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 '/*/:foo/*/*' 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%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 '/: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?' 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('/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.?' do
+    it { should match('/a.').capturing foo: 'a.' }
+    it { should match('/xy').capturing foo: 'xy' }
+  end
+
+  pattern '/(a)' do
+    it { should     match('/(a)') }
+    it { should_not match('/a') }
+  end
+
+  pattern '/:foo.?', greedy: false do
+    it { should match('/a.').capturing foo: 'a'  }
+    it { should match('/xy').capturing foo: 'xy' }
+  end
+
+  pattern '/foo?', uri_decode: false do
+    it { should     match('/foo')  }
+    it { should     match('/fo')   }
+    it { should_not match('/foo?') }
+  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 'error handling' do
+    example '? at beginning of route' do
+      expect { Mustermann::Simple.new('?foobar') }.
+        to raise_error(Mustermann::ParseError)
+    end
+
+    example 'invalid capture name' do
+      expect { Mustermann::Simple.new('/:1a/') }.
+        to raise_error(Mustermann::CompileError)
+    end
+  end
+end