mustermann19 0.3.1

data/spec/extension_spec.rb

@@ -0,0 +1,296 @@
+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.set(:pattern, nil)
+        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 :pattern do
+    describe :except do
+      before { app.get('/auth/*', pattern: { except: '/auth/login' }) { 'ok' } }
+      example { get('/auth/dunno').should     be_ok }
+      example { get('/auth/login').should_not be_ok }
+    end
+
+    describe :capture do
+      context 'route local' do
+        before do
+          app.set(:pattern, nil)
+          app.get('/:id', pattern: { 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)?', pattern: { capture: { ext: 'png' }}) { ?a }
+            app.get('/:id',         pattern: { capture: { id: 'foo'  }}) { ?b }
+            app.get('/:id',         pattern: { 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)?', pattern: { capture: { ext: 'png' }}) { params[:slug] }
+            app.get('/:slug', pattern: { 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 :greedy do
+      context 'default' do
+        before { app.get('/:name.:ext') { params[:name] }}
+        example { get('/foo.bar')     .body.should be == 'foo'     }
+        example { get('/foo.bar.baz') .body.should be == 'foo.bar' }
+      end
+
+      context 'enabled' do
+        before { app.get('/:name.:ext', pattern: { greedy: true }) { params[:name] }}
+        example { get('/foo.bar')     .body.should be == 'foo'     }
+        example { get('/foo.bar.baz') .body.should be == 'foo.bar' }
+      end
+
+      context 'disabled' do
+        before { app.get('/:name.:ext', pattern: { greedy: false }) { params[:name] }}
+        example { get('/foo.bar')     .body.should be == 'foo' }
+        example { get('/foo.bar.baz') .body.should be == 'foo' }
+      end
+
+      context 'global' do
+        before do
+          app.set(:pattern, greedy: false)
+          app.get('/:name.:ext') { params[:name] }
+        end
+
+        example { get('/foo.bar')     .body.should be == 'foo' }
+        example { get('/foo.bar.baz') .body.should be == 'foo' }
+      end
+    end
+
+    describe :space_matches_plus do
+      context 'default' do
+        before { app.get('/foo bar') { 'ok' }}
+        example { get('/foo%20bar') .should be_ok }
+        example { get('/foo+bar')   .should be_ok }
+      end
+
+      context 'enabled' do
+        before { app.get('/foo bar', pattern: { space_matches_plus: true }) { 'ok' }}
+        example { get('/foo%20bar') .should be_ok }
+        example { get('/foo+bar')   .should be_ok }
+      end
+
+      context 'disabled' do
+        before { app.get('/foo bar', pattern: { space_matches_plus: false }) { 'ok' }}
+        example { get('/foo%20bar') .should     be_ok }
+        example { get('/foo+bar')   .should_not be_ok }
+      end
+
+      context 'global' do
+        before do
+          app.set(:pattern, space_matches_plus: false)
+          app.get('/foo bar') { 'ok' }
+        end
+
+        example { get('/foo%20bar') .should     be_ok }
+        example { get('/foo+bar')   .should_not be_ok }
+      end
+    end
+
+    describe :uri_decode do
+      context 'default' do
+        before { app.get('/&') { 'ok' }}
+        example { get('/&')   .should be_ok }
+        example { get('/%26') .should be_ok }
+      end
+
+      context 'enabled' do
+        before { app.get('/&', pattern: { uri_decode: true }) { 'ok' }}
+        example { get('/&')   .should be_ok }
+        example { get('/%26') .should be_ok }
+      end
+
+      context 'disabled' do
+        before { app.get('/&', pattern: { uri_decode: false }) { 'ok' }}
+        example { get('/&')   .should     be_ok }
+        example { get('/%26') .should_not be_ok }
+      end
+
+      context 'global' do
+        before do
+          app.set(:pattern, uri_decode: false)
+          app.get('/&') { 'ok' }
+        end
+
+        example { get('/&')   .should     be_ok }
+        example { get('/%26') .should_not 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(nil, skip: true) { get('/foo').should be_ok }
+      example(nil, skip: true) { 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,83 @@
+# -*- encoding: utf-8 -*-
+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/mapper_spec.rb

@@ -0,0 +1,83 @@
+require 'support'
+require 'mustermann/mapper'
+
+describe Mustermann::Mapper do
+  describe :initialize do
+    context 'accepts a block with no arguments, using the return value' do
+      subject(:mapper) { Mustermann::Mapper.new(additional_values: :raise) {{ "/foo" => "/bar" }}}
+      its(:to_h) { should be == { Mustermann.new("/foo") => Mustermann::Expander.new("/bar") } }
+      example { mapper['/foo'].should be == '/bar' }
+      example { mapper['/fox'].should be == '/fox' }
+    end
+
+    context 'accepts a block with argument, passes instance to it' do
+      subject(:mapper) { Mustermann::Mapper.new(additional_values: :raise) { |m| m["/foo"] = "/bar" }}
+      its(:to_h) { should be == { Mustermann.new("/foo") => Mustermann::Expander.new("/bar") } }
+      example { mapper['/foo'].should be == '/bar' }
+      example { mapper['/fox'].should be == '/fox' }
+    end
+
+    context 'accepts mappings followed by options' do
+      subject(:mapper) { Mustermann::Mapper.new("/foo" => "/bar", additional_values: :raise) }
+      its(:to_h) { should be == { Mustermann.new("/foo") => Mustermann::Expander.new("/bar") } }
+      example { mapper['/foo'].should be == '/bar' }
+      example { mapper['/fox'].should be == '/fox' }
+    end
+
+    context 'accepts options followed by mappings' do
+      subject(:mapper) { Mustermann::Mapper.new(additional_values: :raise, "/foo" => "/bar") }
+      its(:to_h) { should be == { Mustermann.new("/foo") => Mustermann::Expander.new("/bar") } }
+      example { mapper['/foo'].should be == '/bar' }
+      example { mapper['/fox'].should be == '/fox' }
+    end
+
+    context 'allows specifying type' do
+      subject(:mapper) { Mustermann::Mapper.new(additional_values: :raise, type: :rails, "/foo" => "/bar") }
+      its(:to_h) { should be == { Mustermann.new("/foo", type: :rails) => Mustermann::Expander.new("/bar", type: :rails) } }
+      example { mapper['/foo'].should be == '/bar' }
+      example { mapper['/fox'].should be == '/fox' }
+    end
+  end
+
+  describe :convert do
+    subject(:mapper) { Mustermann::Mapper.new }
+
+    context 'it maps params' do
+      before { mapper["/:a"] = "/:a.html" }
+      example { mapper["/foo"]      .should be == "/foo.html" }
+      example { mapper["/foo/bar"]  .should be == "/foo/bar"  }
+    end
+
+    context 'it supports named splats' do
+      before { mapper["/*a"] = "/*a.html" }
+      example { mapper["/foo"]      .should be == "/foo.html"     }
+      example { mapper["/foo/bar"]  .should be == "/foo/bar.html" }
+    end
+
+    context 'can map from patterns' do
+      before { mapper[Mustermann.new("/:a")] = "/:a.html" }
+      example { mapper["/foo"]      .should be == "/foo.html" }
+      example { mapper["/foo/bar"]  .should be == "/foo/bar"  }
+    end
+
+    context 'can map to patterns' do
+      before { mapper[Mustermann.new("/:a")] = Mustermann.new("/:a.html") }
+      example { mapper["/foo"]      .should be == "/foo.html" }
+      example { mapper["/foo/bar"]  .should be == "/foo/bar"  }
+    end
+
+    context 'can map to expanders' do
+      before { mapper[Mustermann.new("/:a")] = Mustermann::Expander.new("/:a.html") }
+      example { mapper["/foo"]      .should be == "/foo.html" }
+      example { mapper["/foo/bar"]  .should be == "/foo/bar"  }
+    end
+
+    context 'can map to array' do
+      before { mapper["/:a"] = ["/:a.html", "/:a.:f"] }
+      example { mapper["/foo"]             .should be == "/foo.html" }
+      example { mapper["/foo", "f" => 'x'] .should be == "/foo.x"    }
+      example { mapper["/foo", f: 'x']     .should be == "/foo.x"    }
+      example { mapper["/foo/bar"]         .should be == "/foo/bar"  }
+    end
+  end
+end