mustermann19 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7c18eae7550233eced7217aec1439b9a51737fc1
-  data.tar.gz: e242e2fc80b76b0fd6842c6e801b69aa79958354
+  metadata.gz: b657d781342db968ae5f3aa2870ae038b2dcbe6d
+  data.tar.gz: 7e3f3769de07852525cf560cc1b053f31ff90be9
 SHA512:
-  metadata.gz: a201dc17c06299c6b7f49749e7ec6add20bea0db6efe5c438044e72209ad0be2f394ac5b59d1eca9b6c9706b73b9dd7dde61c951c37fba8396b5ed30940fc435
-  data.tar.gz: e60038818b219dcf23c58334df578d0d101ce49f609c0cc93e950f0eb804e38a8cccc9835014cee05c1d91b49bb522d35549923aef32238bff620015b7d70aae
+  metadata.gz: 82059db05fce899ea10ec6d729d4411a7d5073052c66dba13710df0f17a7472fc79d0345225f1b760bd9cf16c3d4e32d822502fe8271e2efd78bac449d7acbcc
+  data.tar.gz: ddab562925edbfe2f4fe85af92d7e86945077965b6407cce6960796945fad76234b1c158dca4dd06442fd3dc66f805fef532005f8007613d1251dc652832985e

data/README.md

@@ -1007,6 +1007,17 @@ This comes with a few trade-offs:
 [`uri_decode`](#-available-options--uri_decode),
 [`ignore_unknown_options`](#-available-options--ignore_unknown_options).
 
+<a name="-pattern-details-grape"></a>
+### `grape`
+
+**Supported options:**
+[`capture`](#-available-options--capture),
+[`except`](#-available-options--except),
+[`greedy`](#-available-options--greedy),
+[`space_matches_plus`](#-available-options--space_matches_plus),
+[`uri_decode`](#-available-options--uri_decode),
+[`ignore_unknown_options`](#-available-options--ignore_unknown_options).
+
 <a name="-pattern-details-rails"></a>
 ### `rails`
 

data/lib/mustermann/grape.rb

@@ -0,0 +1,34 @@
+require 'mustermann/ast/pattern'
+
+module Mustermann
+  # Grape style pattern implementation.
+  #
+  # @example
+  #   Mustermann.new('/:foo', type: :grape) === '/bar' # => true
+  #
+  # @see Mustermann::Pattern
+  # @see file:README.md#grape Syntax description in the README
+  class Grape < AST::Pattern
+    register :grape
+
+    on(nil, ??, ?)) { |c| unexpected(c) }
+
+    on(?*)  { |c| scan(/\w+/) ? node(:named_splat, buffer.matched) : node(:splat) }
+    on(?:)  { |c| node(:capture) { scan(/\w+/) } }
+    on(?\\) { |c| node(:char, expect(/./)) }
+    on(?()  { |c| node(:optional, node(:group) { read unless scan(?)) }) }
+    on(?|)  { |c| node(:or) }
+
+    on ?{ do |char|
+      type = scan(?+) ? :named_splat : :capture
+      name = expect(/[\w\.]+/)
+      type = :splat if type == :named_splat and name == 'splat'
+      expect(?})
+      node(type, name)
+    end
+
+    suffix ?? do |char, element|
+      node(:optional, element)
+    end
+  end
+end

data/lib/mustermann/version.rb

@@ -1,3 +1,3 @@
 module Mustermann
-  VERSION ||= '0.4.0'
+  VERSION ||= '0.4.1'
 end

data/spec/grape_spec.rb

@@ -0,0 +1,747 @@
+# -*- encoding: utf-8 -*-
+require 'support'
+require 'mustermann/grape'
+
+describe Mustermann::Grape do
+  extend Support::Pattern
+
+  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
+    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\/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')       .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/')    }
+
+    it { should generate_template('/{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 }
+
+    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
+    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 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
+
+  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" } }
+  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" } }
+  end
+
+  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
+    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"} }
+  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"} }
+  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')     }
+
+    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') }
+
+    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 '/{+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%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 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
+    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')  }
+
+    it { should     generate_template('/{file}')       }
+    it { should     generate_template('/{file}.{ext}') }
+    it { should_not generate_template('/{file}.')      }
+  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 '/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('/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('/foo%5c') }
+    it { should     match('/foo')    }
+    it { should_not match('/foo\?')  }
+    it { should_not match('/fo')     }
+    it { should_not match('')        }
+    it { should_not match('/')       }
+    it { should_not match('/f')      }
+    it { should_not match('/fooo')   }
+  end
+
+  pattern '/\(' do
+    it { should match('/(') }
+  end
+
+  pattern '/\(?' do
+    it { should match('/(') }
+    it { should match('/')  }
+  end
+
+  pattern '/(\()?' do
+    it { should match('/(') }
+    it { should match('/')  }
+  end
+
+  pattern '/(\(\))?' do
+    it { should     match('/')   }
+    it { should     match('/()') }
+    it { should_not match('/(')  }
+  end
+
+  pattern '/\(\)?' do
+    it { should     match('/(')  }
+    it { should     match('/()') }
+    it { should_not match('/')   }
+  end
+
+  pattern '/\*' do
+    it { should     match('/*') }
+    it { should_not match('/a') }
+  end
+
+  pattern '/\*/*' do
+    it { should     match('/*/b/c') }
+    it { should_not match('/a/b/c') }
+  end
+
+  pattern '/\:foo' do
+    it { should     match('/:foo') }
+    it { should_not match('/foo')  }
+  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|bar)" do
+    it { should match("/foo") }
+    it { should match("/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 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 "/: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' }
+
+    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 '/auth/*', except: '/auth/login' do
+    it { should     match('/auth/admin')  }
+    it { should     match('/auth/foobar') }
+    it { should_not match('/auth/login')  }
+  end
+
+  pattern '/:foo/:bar', except: '/:bar/20' do
+    it { should match('/foo/bar').capturing foo: 'foo', bar: 'bar' }
+    it { should_not match('/20/20') }
+  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 'invalid syntax' do
+    example 'unexpected closing parenthesis' do
+      expect { Mustermann::Grape.new('foo)bar') }.
+        to raise_error(Mustermann::ParseError, 'unexpected ) while parsing "foo)bar"')
+    end
+
+    example 'missing closing parenthesis' do
+      expect { Mustermann::Grape.new('foo(bar') }.
+        to raise_error(Mustermann::ParseError, 'unexpected end of string while parsing "foo(bar"')
+    end
+
+    example 'missing unescaped closing parenthesis' do
+      expect { Mustermann::Grape.new('foo(bar\)') }.
+        to raise_error(Mustermann::ParseError, 'unexpected end of string while parsing "foo(bar\\\\)"')
+    end
+
+    example '? at beginning of route' do
+      expect { Mustermann::Grape.new('?foobar') }.
+        to raise_error(Mustermann::ParseError, 'unexpected ? while parsing "?foobar"')
+    end
+
+    example 'double ?' do
+      expect { Mustermann::Grape.new('foo??bar') }.
+        to raise_error(Mustermann::ParseError, 'unexpected ? while parsing "foo??bar"')
+    end
+
+    example 'dangling escape' do
+      expect { Mustermann::Grape.new('foo\\') }.
+        to raise_error(Mustermann::ParseError, 'unexpected end of string while parsing "foo\\\\"')
+    end
+  end
+
+  context 'invalid capture names' do
+    example 'empty name' do
+      expect { Mustermann::Grape.new('/:/') }.
+        to raise_error(Mustermann::CompileError, "capture name can't be empty: \"/:/\"")
+    end
+
+    example 'named splat' do
+      expect { Mustermann::Grape.new('/:splat/') }.
+        to raise_error(Mustermann::CompileError, "capture name can't be splat: \"/:splat/\"")
+    end
+
+    example 'named captures' do
+      expect { Mustermann::Grape.new('/:captures/') }.
+        to raise_error(Mustermann::CompileError, "capture name can't be captures: \"/:captures/\"")
+    end
+
+    example 'with capital letter' do
+      expect { Mustermann::Grape.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::Grape.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::Grape.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::Grape.new("/")     .should_not be === '/foo' }
+      example('matching')     { Mustermann::Grape.new("/:foo") .should     be === '/foo' }
+    end
+
+    describe :=~ do
+      example('non-matching') { Mustermann::Grape.new("/")     .should_not be =~ '/foo' }
+      example('matching')     { Mustermann::Grape.new("/:foo") .should     be =~ '/foo' }
+
+      context 'String#=~' do
+        example('non-matching') { "/foo".should_not be =~ Mustermann::Grape.new("/") }
+        example('matching')     { "/foo".should     be =~ Mustermann::Grape.new("/:foo") }
+      end
+    end
+
+    describe :to_regexp do
+      example('empty pattern') { Mustermann::Grape.new('').to_regexp.should be == /\A(?-mix:)\Z/ }
+
+      context 'Regexp.try_convert' do
+        example('empty pattern') { Regexp.try_convert(Mustermann::Grape.new('')).should be == /\A(?-mix:)\Z/ }
+      end
+    end
+  end
+
+  context 'Proc compatibility' do
+    describe :to_proc do
+      example { Mustermann::Grape.new("/").to_proc.should be_a(Proc) }
+      example('non-matching') { Mustermann::Grape.new("/")     .to_proc.call('/foo').should be == false }
+      example('matching')     { Mustermann::Grape.new("/:foo") .to_proc.call('/foo').should be == true  }
+    end
+  end
+
+  context "peeking" do
+    subject(:pattern) { Mustermann::Grape.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

metadata

@@ -1,167 +1,168 @@
 --- !ruby/object:Gem::Specification
 name: mustermann19
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Konstantin Haase
 - namusyaka
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-29 00:00:00.000000000 Z
+date: 2016-02-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
+  name: enumerable-lazy
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  name: enumerable-lazy
-  prerelease: false
   type: :runtime
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  name: rspec
-  prerelease: false
   type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
+  name: rspec-its
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  name: rspec-its
-  prerelease: false
   type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
+  name: addressable
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  name: addressable
-  prerelease: false
   type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
+  name: sinatra
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.4'
-  name: sinatra
-  prerelease: false
   type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.4'
 - !ruby/object:Gem::Dependency
+  name: rack-test
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  name: rack-test
-  prerelease: false
   type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  name: rake
-  prerelease: false
   type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
+  name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  name: yard
-  prerelease: false
   type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
+  name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  name: simplecov
-  prerelease: false
   type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
+  name: coveralls
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  name: coveralls
-  prerelease: false
   type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: library implementing patterns that behave like regular expressions for use in Ruby 1.9
+description: library implementing patterns that behave like regular expressions for
+  use in Ruby 1.9
 email: namusyaka@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files:
 - README.md
 files:
-- .gitignore
-- .rspec
-- .travis.yml
-- .yardopts
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- ".yardopts"
 - Gemfile
 - LICENSE
 - README.md
@@ -191,6 +192,7 @@ files:
 - lib/mustermann/express.rb
 - lib/mustermann/extension.rb
 - lib/mustermann/flask.rb
+- lib/mustermann/grape.rb
 - lib/mustermann/identity.rb
 - lib/mustermann/mapper.rb
 - lib/mustermann/pattern.rb
@@ -223,6 +225,7 @@ files:
 - spec/extension_spec.rb
 - spec/flask_spec.rb
 - spec/flask_subclass_spec.rb
+- spec/grape_spec.rb
 - spec/identity_spec.rb
 - spec/mapper_spec.rb
 - spec/mustermann_spec.rb
@@ -252,24 +255,24 @@ homepage: https://github.com/namusyaka/mustermann
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project:
-rubygems_version: 2.1.9
-signing_key:
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
 specification_version: 4
 summary: use patterns like regular expressions
 test_files:
@@ -280,6 +283,7 @@ test_files:
 - spec/extension_spec.rb
 - spec/flask_spec.rb
 - spec/flask_subclass_spec.rb
+- spec/grape_spec.rb
 - spec/identity_spec.rb
 - spec/mapper_spec.rb
 - spec/mustermann_spec.rb
@@ -305,4 +309,4 @@ test_files:
 - spec/support/scan_matcher.rb
 - spec/template_spec.rb
 - spec/to_pattern_spec.rb
-has_rdoc:
+has_rdoc: