mustermann 1.0.3 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 0f9565d31c5b29a990840eb04f933be370358de6
-  data.tar.gz: 5f4dc020bd50b6d11f787dc555e0fcab6252d486
+SHA256:
+  metadata.gz: ea330a8bf09165e676628df2668f0afa5d8fd32372bb7b07ed6a286cf274f74c
+  data.tar.gz: 58b0252ef3ba1d5bd06b3dceab50c06ba011d98b9e2bc54c6caa314443fa722b
 SHA512:
-  metadata.gz: 7bf3d61ccac65e24d83b5551188ae5d9836b7664dad722fd077264d9b1b6e3097bc57b474c09acc3b250c009bd7852378b3049ee5630c28706335111ec651e60
-  data.tar.gz: b4ab4965dd93dae14ddf44c60116711a488ead67e0bf1109582c79ed86bf81c70315c1b9b4b6258978093515f4813e8f01d0aeca302de883289d65ccbcf5e870
+  metadata.gz: f9e8638a1cb73cf39256c6cb422d4d1a4601a2d9348aba8361d31083103e0495a843d595b579f08d2614ba1b665b41959a79eaffd869348551a2cb558c1cf1ea
+  data.tar.gz: 5b569063e6dd7d3beb3bdd983d4f5c30a9d12ce7b5e06d0f1f215e56004ba678011df824d26a94d5dc136d957c7835e5bcc38081cbbda2d838cfe78b3ca00ec7

data/README.md

@@ -377,30 +377,7 @@ mapper['/foo/bar'] # => "/foo/bar"
 <a name="-sinatra-integration"></a>
 ## Sinatra Integration
 
-All patterns implement `match`, which means they can be dropped into Sinatra and other Rack routers:
-
-``` ruby
-require 'sinatra'
-require 'mustermann'
-
-get Mustermann.new('/:foo') do
-  params[:foo]
-end
-```
-
-In fact, since using this with Sinatra is the main use case, it comes with a build-in extension for **Sinatra 1.x**.
-
-``` ruby
-require 'sinatra'
-require 'mustermann'
-
-register Mustermann
-
-# this will use Mustermann rather than the built-in pattern matching
-get '/:slug(.ext)?' do
-  params[:slug]
-end
-```
+Mustermann is used in Sinatra by default since version 2.0, for previous versions an [extension](https://github.com/sinatra/mustermann-sinatra-extension) is available.
 
 ### Configuration
 

data/lib/mustermann/ast/compiler.rb

@@ -40,7 +40,7 @@ module Mustermann
 
         # @!visibility private
         def translate(**options)
-          return pattern(options) if options[:no_captures]
+          return pattern(**options) if options[:no_captures]
           "(?<#{name}>#{translate(no_captures: true, **options)})"
         end
 

data/lib/mustermann/ast/expander.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 require 'mustermann/ast/translator'
 require 'mustermann/ast/compiler'
+require 'ruby2_keywords'
 
 module Mustermann
   module AST
@@ -11,11 +12,11 @@ module Mustermann
     class Expander < Translator
       raises ExpandError
 
-      translate Array do |*args|
+      translate(Array, &-> (*args) do
         inject(t.pattern) do |pattern, element|
           t.add_to(pattern, t(element, *args))
         end
-      end
+      end.ruby2_keywords)
 
       translate :capture do |**options|
         t.for_capture(node, **options)
@@ -92,11 +93,11 @@ module Mustermann
       # @see Mustermann::Pattern#expand
       # @!visibility private
       def expand(values)
-        values = values.each_with_object({}){ |(key, value), new_hash|
+        adjusted = values.each_with_object({}){ |(key, value), new_hash|
           new_hash[value.instance_of?(Array) ? [key] * value.length : key] = value }
-        keys, pattern, filters = mappings.fetch(values.keys.flatten.sort) { error_for(values) }
-        filters.each { |key, filter| values[key] &&= escape(values[key], also_escape: filter) }
-        pattern % (values[keys] || values.values_at(*keys))
+        keys, pattern, filters = mappings.fetch(adjusted.keys.flatten.sort) { error_for(values) }
+        filters.each { |key, filter| adjusted[key] &&= escape(adjusted[key], also_escape: filter) }
+        pattern % (adjusted[keys] || adjusted.values_at(*keys))
       end
 
       # @see Mustermann::Pattern#expandable?
@@ -122,7 +123,9 @@ module Mustermann
 
       # @see Mustermann::AST::Translator#expand
       # @!visibility private
-      def escape(string, *args)
+      ruby2_keywords def escape(string, *args)
+        return super unless string.respond_to?(:=~)
+
         # URI::Parser is pretty slow, let's not send every string to it, even if it's unnecessary
         string =~ /\A\w*\Z/ ? string : super
       end
@@ -137,7 +140,7 @@ module Mustermann
       # @!visibility private
       def add_to(list, result)
         list << [[], ""] if list.empty?
-        list.inject([]) { |l, (k1, p1, f1)| l + result.map { |k2, p2, f2| [k1+k2, p1+p2, **f1, **f2] } }
+        list.inject([]) { |l, (k1, p1, f1)| l + result.map { |k2, p2, f2| [k1+k2, p1+p2, f1.merge(f2)] } }
       end
     end
   end

data/lib/mustermann/ast/node.rb

@@ -35,8 +35,8 @@ module Mustermann
       # Helper for creating a new instance and calling #parse on it.
       # @return [Mustermann::AST::Node]
       # @!visibility private
-      def self.parse(*args, &block)
-        new(*args).tap { |n| n.parse(&block) }
+      def self.parse(payload = nil, **options, &block)
+        new(payload, **options).tap { |n| n.parse(&block) }
       end
 
       # @!visibility private
@@ -108,7 +108,7 @@ module Mustermann
         # @see Mustermann::AST::Node#parse
         # @!visibility private
         def parse
-          self.payload ||= ""
+          self.payload ||= String.new
           super
         end
 

data/lib/mustermann/ast/parser.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 require 'mustermann/ast/node'
 require 'forwardable'
+require 'ruby2_keywords'
 require 'strscan'
 
 module Mustermann
@@ -64,7 +65,7 @@ module Mustermann
       # @param [Symbol] type node type
       # @return [Mustermann::AST::Node]
       # @!visibility private
-      def node(type, *args, &block)
+      ruby2_keywords def node(type, *args, &block)
         type  = Node[type] unless type.respond_to? :new
         start = pos
         node  = block ? type.parse(*args, &block) : type.new(*args)
@@ -153,7 +154,7 @@ module Mustermann
       def read_brackets(open, close, char: nil, escape: ?\\, quote: false, **options)
         result = String.new
         escape = false if escape.nil?
-        while current = getch
+        while (current = getch)
           case current
           when close  then return result
           when open   then result << open   << read_brackets(open, close) << close

data/lib/mustermann/ast/translator.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 require 'mustermann/ast/node'
 require 'mustermann/error'
+require 'ruby2_keywords'
 require 'delegate'
 
 module Mustermann
@@ -36,7 +37,7 @@ module Mustermann
 
         # shorthand for translating a nested object
         # @!visibility private
-        def t(*args, &block)
+        ruby2_keywords def t(*args, &block)
           return translator unless args.any?
           translator.translate(*args, &block)
         end
@@ -109,7 +110,7 @@ module Mustermann
 
       # Start the translation dance for a (sub)tree.
       # @!visibility private
-      def translate(node, *args, &block)
+      ruby2_keywords def translate(node, *args, &block)
         result = decorator_for(node).translate(*args, &block)
         result = result.node while result.is_a? NodeTranslator
         result
@@ -119,7 +120,7 @@ module Mustermann
       # @!visibility private
       def escape(char, parser: URI::DEFAULT_PARSER, escape: parser.regexp[:UNSAFE], also_escape: nil)
         escape = Regexp.union(also_escape, escape) if also_escape
-        char =~ escape ? parser.escape(char, Regexp.union(*escape)) : char
+        char.to_s =~ escape ? parser.escape(char, Regexp.union(*escape)) : char
       end
     end
   end

data/lib/mustermann/composite.rb

@@ -102,9 +102,9 @@ module Mustermann
     end
 
     # @!visibility private
-    def patterns_from(pattern, options = nil)
+    def patterns_from(pattern, **options)
       return pattern.patterns if pattern.is_a? Composite and pattern.operator == self.operator
-      [options ? Mustermann.new(pattern, **options) : pattern]
+      [options.empty? && pattern.is_a?(Pattern) ? pattern : Mustermann.new(pattern, **options)]
     end
 
     private :with_matching, :patterns_from

data/lib/mustermann/concat.rb

@@ -40,7 +40,7 @@ module Mustermann
 
     # Should not be used directly.
     # @!visibility private
-    def initialize(*)
+    def initialize(*, **)
       super
       AST::Validation.validate(combined_ast) if respond_to? :expand
     end

data/lib/mustermann/extension.rb

@@ -1,50 +1,3 @@
 # frozen_string_literal: true
-require 'sinatra/version'
-fail "no need to load the Mustermann extension for #{::Sinatra::VERSION}" if ::Sinatra::VERSION >= '2.0.0'
 
-require 'mustermann'
-
-module Mustermann
-  # Sinatra 1.x extension switching default pattern parsing over to Mustermann.
-  #
-  # @example With classic Sinatra application
-  #   require 'sinatra'
-  #   require 'mustermann'
-  #
-  #   register Mustermann
-  #   get('/:id', capture: /\d+/) { ... }
-  #
-  # @example With modular Sinatra application
-  #   require 'sinatra/base'
-  #   require 'mustermann'
-  #
-  #   class MyApp < Sinatra::Base
-  #     register Mustermann
-  #     get('/:id', capture: /\d+/) { ... }
-  #   end
-  #
-  # @see file:README.md#Sinatra_Integration "Sinatra Integration" in the README
-  module Extension
-    def compile!(verb, path, block, except: nil, capture: nil, pattern: { }, **options)
-      if path.respond_to? :to_str
-        pattern[:except]  = except  if except
-        pattern[:capture] = capture if capture
-
-        if settings.respond_to? :pattern and settings.pattern?
-          pattern.merge! settings.pattern do |key, local, global|
-            next local unless local.is_a? Hash
-            next global.merge(local) if global.is_a? Hash
-            Hash.new(global).merge! local
-          end
-        end
-
-        path = Mustermann.new(path, **pattern)
-        condition { params.merge! path.params(captures: Array(params[:captures]), offset: -1) }
-      end
-
-      super(verb, path, block, options)
-    end
-
-    private :compile!
-  end
-end
+fail "Mustermann extension for Sinatra has been extracted into its own gem. More information at https://github.com/sinatra/mustermann-sinatra-extension"

data/lib/mustermann/mapper.rb

@@ -40,11 +40,7 @@ module Mustermann
     #
     #   @example map before options
     #     require 'mustermann/mapper'
-    #     Mustermann::Mapper.new("/:foo" => "/:foo.html", type: :rails)
-    #
-    #   @example map after options
-    #     require 'mustermann/mapper'
-    #     Mustermann::Mapper.new(type: :rails, "/:foo" => "/:foo.html")
+    #     Mustermann::Mapper.new({"/:foo" => "/:foo.html"}, type: :rails)
     def initialize(map = {}, additional_values: :ignore, **options, &block)
       @map               = []
       @options           = options

data/lib/mustermann/pattern.rb

@@ -56,7 +56,7 @@ module Mustermann
       end
 
       @map ||= EqualityMap.new
-      @map.fetch([string, options]) { super(string, options) { options } }
+      @map.fetch([string, options]) { super(string, **options) { options } }
     end
 
     supported_options :uri_decode, :ignore_unknown_options

data/lib/mustermann/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Mustermann
-  VERSION ||= '1.0.3'
+  VERSION ||= '3.0.0'
 end

data/lib/mustermann.rb

@@ -75,8 +75,8 @@ module Mustermann
     end
   end
 
-  @mutex ||= Mutex.new
-  @types ||= {}
+  @mutex = Mutex.new
+  @types = {}
 
   # Maps a type to its factory.
   #
@@ -120,7 +120,6 @@ module Mustermann
   def self.extend_object(object)
     return super unless defined? ::Sinatra::Base and object.is_a? Class and object < ::Sinatra::Base
     require 'mustermann/extension'
-    object.register Extension
   end
 end
 

data/mustermann.gemspec

@@ -10,8 +10,9 @@ Gem::Specification.new do |s|
   s.summary               = %q{Your personal string matching expert.}
   s.description           = %q{A library implementing patterns that behave like regular expressions.}
   s.license               = 'MIT'
-  s.required_ruby_version = '>= 2.2.0'
+  s.required_ruby_version = '>= 2.6.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_runtime_dependency('ruby2_keywords', '~> 0.0.1')
 end

data/spec/expander_spec.rb

@@ -64,6 +64,8 @@ describe Mustermann::Expander do
       example { expander.expand(a: ?a).should be == '/a' }
       example { expander.expand(a: ?a, b: ?b).should be == '/a' }
       example { expect { expander.expand(b: ?b) }.to raise_error(Mustermann::ExpandError) }
+      example { expect { expander.expand(b: ?b, c: []) }.to raise_error(Mustermann::ExpandError) }
+      example { expect { expander.expand(b: ?b, c: [], d: ?d) }.to raise_error(Mustermann::ExpandError) }
     end
 
     context :append do

data/spec/mapper_spec.rb

@@ -19,21 +19,14 @@ describe Mustermann::Mapper do
     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") }
+      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 'allows specifying type' do
-      subject(:mapper) { Mustermann::Mapper.new(additional_values: :raise, type: :rails, "/foo" => "/bar") }
+      subject(:mapper) { Mustermann::Mapper.new({ "/foo" => "/bar" }, additional_values: :raise, type: :rails) }
       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' }

data/spec/mustermann_spec.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 require 'support'
 require 'mustermann'
-require 'mustermann/extension'
 require 'sinatra/base'
 
 describe Mustermann do
@@ -70,11 +69,9 @@ describe Mustermann do
   describe :extend_object do
     context 'special behavior for Sinatra only' do
       example { Object  .new.extend(Mustermann).should     be_a(Mustermann)            }
-      example { Object  .new.extend(Mustermann).should_not be_a(Mustermann::Extension) }
       example { Class   .new.extend(Mustermann).should     be_a(Mustermann)            }
-      example { Class   .new.extend(Mustermann).should_not be_a(Mustermann::Extension) }
-      example { Sinatra .new.extend(Mustermann).should_not be_a(Mustermann)            }
-      example { Sinatra .new.extend(Mustermann).should     be_a(Mustermann::Extension) }
+
+      example { expect { Sinatra.new.extend(Mustermann) }.to raise_error(RuntimeError, "Mustermann extension for Sinatra has been extracted into its own gem. More information at https://github.com/sinatra/mustermann-sinatra-extension") }
     end
   end
 

metadata

@@ -1,16 +1,30 @@
 --- !ruby/object:Gem::Specification
 name: mustermann
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 3.0.0
 platform: ruby
 authors:
 - Konstantin Haase
 - Zachary Scott
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2018-08-16 00:00:00.000000000 Z
-dependencies: []
+date: 2022-07-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ruby2_keywords
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.1
 description: A library implementing patterns that behave like regular expressions.
 email: sinatrarb@googlegroups.com
 executables: []
@@ -62,7 +76,6 @@ files:
 - spec/concat_spec.rb
 - spec/equality_map_spec.rb
 - spec/expander_spec.rb
-- spec/extension_spec.rb
 - spec/identity_spec.rb
 - spec/mapper_spec.rb
 - spec/mustermann_spec.rb
@@ -76,7 +89,7 @@ homepage: https://github.com/sinatra/mustermann
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -84,16 +97,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.2.0
+      version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.8
-signing_key: 
+rubygems_version: 3.0.3.1
+signing_key:
 specification_version: 4
 summary: Your personal string matching expert.
 test_files:
@@ -102,7 +114,6 @@ test_files:
 - spec/concat_spec.rb
 - spec/equality_map_spec.rb
 - spec/expander_spec.rb
-- spec/extension_spec.rb
 - spec/identity_spec.rb
 - spec/mapper_spec.rb
 - spec/mustermann_spec.rb

data/spec/extension_spec.rb

@@ -1,297 +0,0 @@
-# frozen_string_literal: true
-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 { 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