mustermann-rails 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8a27c18c01c4a2db8f22534ae77959dead448a8d
+  data.tar.gz: fa2947e67a353ffec312ab8f8524c036b00558dd
+SHA512:
+  metadata.gz: 84a6f98b7795648592d926b759a92516e383778c479672f4754bcc6a37e3dae73e45435c4bbad08276cc4688cf87abd268c6e9621b48070f783ab58add2e4a68
+  data.tar.gz: 659bf9f1296199b8f152599228ceec43ce9a28a08177af7a720816acb5e2be8cdd5f8aaa2257d8dda1f41ff6c602bc6599f9541bd25f77d69bf0e814c5445eba

data/README.md

@@ -0,0 +1,103 @@
+# Rails Syntax for Mustermann
+
+This gem implements the `rails` pattern type for Mustermann. It is compatible with [Ruby on Rails](http://rubyonrails.org/), [Journey](https://github.com/rails/journey), the [http_router gem](https://github.com/joshbuddy/http_router), [Lotus](http://lotusrb.org/) and [Scalatra](http://www.scalatra.org/) (if [configured](http://www.scalatra.org/2.3/guides/http/routes.html#toc_248))</td>
+
+## Overview
+
+**Supported options:**
+`capture`, `except`, `greedy`, `space_matches_plus`, `uri_decode`, `version`, and `ignore_unknown_options`.
+
+**External documentation:**
+[Ruby on Rails Guides: Routing](http://guides.rubyonrails.org/routing.html).
+
+``` ruby
+require 'mustermann'
+
+pattern = Mustermann.new('/:example', type: :rails)
+pattern === "/foo.bar"     # => true
+pattern === "/foo/bar"     # => false
+pattern.params("/foo.bar") # => { "example" => "foo.bar" }
+pattern.params("/foo/bar") # => nil
+
+pattern = Mustermann.new('/:example(/:optional)', type: :rails)
+pattern === "/foo.bar"     # => true
+pattern === "/foo/bar"     # => true
+pattern.params("/foo.bar") # => { "example" => "foo.bar", "optional" => nil   }
+pattern.params("/foo/bar") # => { "example" => "foo",     "optional" => "bar" }
+
+pattern = Mustermann.new('/*example', type: :rails)
+pattern === "/foo.bar"     # => true
+pattern === "/foo/bar"     # => true
+pattern.params("/foo.bar") # => { "example" => "foo.bar" }
+pattern.params("/foo/bar") # => { "example" => "foo/bar" }
+```
+
+## Rails Compatibility
+
+Rails syntax changed over time. You can target different Ruby on Rails versions by setting the `version` option to the desired Rails version.
+
+The default is `4.2`. Versions prior to `2.3` are not supported.
+
+``` ruby
+require 'mustermann'
+Mustermann.new('/', type: :rails, version: "2.3")
+Mustermann.new('/', type: :rails, version: "3.0.0")
+
+require 'rails'
+Mustermann.new('/', type: :rails, version: Rails::VERSION::STRING)
+```
+
+## Syntax
+
+<table>
+  <thead>
+    <tr>
+      <th>Syntax Element</th>
+      <th>Description</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td><b>:</b><i>name</i></td>
+      <td>
+        Captures anything but a forward slash in a semi-greedy fashion. Capture is named <i>name</i>.
+        Capture behavior can be modified with tt>capture</tt> and <tt>greedy</tt> option.
+      </td>
+    </tr>
+    <tr>
+      <td><b>*</b><i>name</i></td>
+      <td>
+        Captures anything in a non-greedy fashion. Capture is named <i>name</i>.
+      </td>
+    </tr>
+    <tr>
+      <td><b>(</b><i>expression</i><b>)</b></td>
+      <td>Enclosed <i>expression</i> is optional. Not available in 2.3 compatibility mode.</td>
+    </tr>
+    <tr>
+      <td><b>/</b></td>
+      <td>
+        Matches forward slash. Does not match URI encoded version of forward slash.
+      </td>
+    </tr>
+    <tr>
+      <td><b>\</b><i>x</i></td>
+      <td>
+        In 3.x compatibility mode and starting with 4.2:
+        Matches <i>x</i> or URI encoded version of <i>x</i>. For instance <tt>\*</tt> matches <tt>*</tt>.<br>
+        In 4.0 or 4.1 compatibility mode:
+        <b>\</b> is ignored, <i>x</i> is parsed normally.<br>
+      </td>
+    </tr>
+    <tr>
+      <td><b>|</b></td>
+      <td>
+        Starting with 3.2 compatibility mode, this will raise a `Mustermann::ParseError`. While Ruby on Rails happily parses this character, it will result in broken routes due to a buggy implementation.
+      </td>
+    </tr>
+    <tr>
+      <td><i>any other character</i></td>
+      <td>Matches exactly that character or a URI encoded version of it.</td>
+    </tr>
+  </tbody>
+</table>

data/lib/mustermann/rails.rb

@@ -0,0 +1,43 @@
+require 'mustermann'
+require 'mustermann/ast/pattern'
+require 'mustermann/versions'
+
+module Mustermann
+  # Rails style pattern implementation.
+  #
+  # @example
+  #   Mustermann.new('/:foo', type: :rails) === '/bar' # => true
+  #
+  # @see Mustermann::Pattern
+  # @see file:README.md#rails Syntax description in the README
+  class Rails < AST::Pattern
+    extend Versions
+    register :rails
+
+    # first parser, no optional parts
+    version('2.3') do
+      on(nil) { |c| unexpected(c) }
+      on(?*)  { |c| node(:named_splat) { scan(/\w+/) } }
+      on(?:)  { |c| node(:capture) { scan(/\w+/) } }
+    end
+
+    # rack-mount
+    version('3.0', '3.1') do
+      on(?))  { |c| unexpected(c) }
+      on(?()  { |c| node(:optional, node(:group) { read unless scan(?)) }) }
+      on(?\\) { |c| node(:char, expect(/./)) }
+    end
+
+    # stand-alone journey
+    version('3.2') do
+      on(?|)  { |c| raise ParseError, "the implementation of | is broken in ActionDispatch, cannot compile compatible pattern" }
+      on(?\\) { |c| node(:char, c) }
+    end
+
+    # embedded journey, broken (ignored) escapes
+    version('4.0', '4.1') { on(?\\) { |c| read } }
+
+    # escapes got fixed in 4.2
+    version('4.2') { on(?\\) { |c| node(:char, expect(/./)) } }
+  end
+end

data/lib/mustermann/versions.rb

@@ -0,0 +1,46 @@
+module Mustermann
+  # Mixin that adds support for multiple versions of the same type.
+  # @see Mustermann::Rails
+  # @!visibility private
+  module Versions
+    # Checks if class has mulitple versions available and picks one that matches the version option.
+    # @!visibility private
+    def new(*args, version: nil, **options)
+      return super(*args, **options) unless versions.any?
+      self[version].new(*args, **options)
+    end
+
+    # @return [Hash] version to subclass mapping.
+    # @!visibility private
+    def versions
+      @versions ||= {}
+    end
+
+    # Defines a new version.
+    # @!visibility private
+    def version(*list, inherit_from: nil, &block)
+      superclass = self[inherit_from] || self
+      subclass   = Class.new(superclass, &block)
+      list.each { |v| versions[v] = subclass }
+    end
+
+    # Resolve a subclass for a given version string.
+    # @!visibility private
+    def [](version)
+      return versions.values.last unless version
+      detected = versions.detect { |v,_| version.start_with?(v) }
+      raise ArgumentError, 'unsupported version %p' % version unless detected
+      detected.last
+    end
+
+    # @!visibility private
+    def name
+      super || superclass.name
+    end
+
+    # @!visibility private
+    def inspect
+      name
+    end
+  end
+end

data/mustermann-rails.gemspec

@@ -0,0 +1,18 @@
+$:.unshift File.expand_path("../../mustermann/lib", __FILE__)
+require "mustermann/version"
+
+Gem::Specification.new do |s|
+  s.name                  = "mustermann-rails"
+  s.version               = Mustermann::VERSION
+  s.author                = "Konstantin Haase"
+  s.email                 = "konstantin.mailinglists@googlemail.com"
+  s.homepage              = "https://github.com/rkh/mustermann"
+  s.summary               = %q{Rails syntax for Mustermann}
+  s.description           = %q{Adds Rails style patterns to Mustermman}
+  s.license               = 'MIT'
+  s.required_ruby_version = '>= 2.1.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_dependency 'mustermann', Mustermann::VERSION
+end

data/spec/rails_spec.rb

@@ -0,0 +1,640 @@
+require 'support'
+require 'mustermann/rails'
+
+describe Mustermann::Rails do
+  extend Support::Pattern
+
+  pattern '' do
+    it { should     match('')  }
+    it { should_not match('/') }
+
+    it { should expand.to('') }
+    it { should_not expand(a: 1) }
+
+    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') }
+
+    it { should expand.to('/') }
+    it { should_not expand(a: 1) }
+  end
+
+  pattern '/foo' do
+    it { should     match('/foo')     }
+    it { should_not match('/bar')     }
+    it { should_not match('/foo.bar') }
+
+    it { should expand.to('/foo') }
+    it { should_not expand(a: 1) }
+  end
+
+  pattern '/foo/bar' do
+    it { should     match('/foo/bar')   }
+    it { should_not match('/foo%2Fbar') }
+    it { should_not match('/foo%2fbar') }
+
+    it { should expand.to('/foo/bar') }
+    it { should_not expand(a: 1) }
+  end
+
+  pattern '/:foo' do
+    it { should match('/foo')       .capturing foo: 'foo'       }
+    it { should match('/bar')       .capturing foo: 'bar'       }
+    it { should match('/foo.bar')   .capturing foo: 'foo.bar'   }
+    it { should match('/%0Afoo')    .capturing foo: '%0Afoo'    }
+    it { should match('/foo%2Fbar') .capturing foo: 'foo%2Fbar' }
+
+    it { should_not match('/foo?')    }
+    it { should_not match('/foo/bar') }
+    it { should_not match('/')        }
+    it { should_not match('/foo/')    }
+
+    example { pattern.params('/foo')   .should be == {"foo" => "foo"} }
+    example { pattern.params('/f%20o') .should be == {"foo" => "f o"} }
+    example { pattern.params('').should be_nil }
+
+    it { should expand(foo: 'bar')     .to('/bar')       }
+    it { should expand(foo: 'b r')     .to('/b%20r')     }
+    it { should expand(foo: 'foo/bar') .to('/foo%2Fbar') }
+
+    it { should_not expand(foo: 'foo', bar: 'bar') }
+    it { should_not expand(bar: 'bar') }
+    it { should_not expand }
+
+    it { should generate_template('/{foo}') }
+  end
+
+  pattern '/föö' do
+    it { should match("/f%C3%B6%C3%B6") }
+    it { should expand.to("/f%C3%B6%C3%B6") }
+    it { should_not expand(a: 1) }
+  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 expand(foo: 'foo', bar: 'bar').to('/foo/bar') }
+    it { should_not expand(foo: 'foo') }
+    it { should_not expand(bar: 'bar') }
+
+    it { should generate_template('/{foo}/{bar}') }
+  end
+
+  pattern '/hello/:person' do
+    it { should match('/hello/Frank').capturing person: 'Frank' }
+    it { should expand(person: 'Frank')   .to '/hello/Frank'    }
+    it { should expand(person: 'Frank?')  .to '/hello/Frank%3F' }
+
+    it { should generate_template('/hello/{person}') }
+  end
+
+  pattern '/?:foo?/?:bar?' do
+    it { should match('/?hello?/?world?').capturing foo: 'hello', bar: 'world' }
+    it { should_not match('/hello/world/') }
+    it { should expand(foo: 'hello', bar: 'world').to('/%3Fhello%3F/%3Fworld%3F') }
+    it { should generate_template('/?{foo}?/?{bar}?') }
+  end
+
+  pattern '/:foo_bar' do
+    it { should match('/hello').capturing foo_bar: 'hello' }
+    it { should expand(foo_bar: 'hello').to('/hello') }
+    it { should generate_template('/{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 expand                  .to('/')        }
+    it { should expand(foo:  nil)       .to('/')        }
+    it { should expand(foo:  '')        .to('/')        }
+    it { should expand(foo: 'foo')      .to('/foo')     }
+    it { should expand(foo: 'foo/bar')  .to('/foo/bar') }
+    it { should expand(foo: 'foo.bar')  .to('/foo.bar') }
+
+    it { should generate_template('/{+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}') }
+  end
+
+  pattern '/:foo/*bar' do
+    it { should match("/foo/bar/baz")     .capturing foo: 'foo',       bar: 'bar/baz'   }
+    it { should match("/foo%2Fbar/baz")   .capturing foo: 'foo%2Fbar', bar: 'baz'       }
+    it { should match("/foo/")            .capturing foo: 'foo',       bar: ''          }
+    it { should match('/h%20w/h%20a%20y') .capturing foo: 'h%20w',     bar: 'h%20a%20y' }
+    it { should_not match('/foo') }
+
+    it { should expand(foo: 'foo')                     .to('/foo/')          }
+    it { should expand(foo: 'foo',     bar: 'bar')     .to('/foo/bar')       }
+    it { should expand(foo: 'foo',     bar: 'foo/bar') .to('/foo/foo/bar')   }
+    it { should expand(foo: 'foo/bar', bar: 'bar')     .to('/foo%2Fbar/bar') }
+
+    it { should generate_template('/{foo}/{+bar}') }
+  end
+
+  pattern '/test$/' do
+    it { should match('/test$/') }
+    it { should expand.to('/test$/') }
+  end
+
+  pattern '/te+st/' do
+    it { should     match('/te+st/') }
+    it { should_not match('/test/')  }
+    it { should_not match('/teest/') }
+    it { should expand.to('/te+st/') }
+  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 expand.to('/path%20with%20spaces') }
+
+    it { should generate_template('/path%20with%20spaces') }
+  end
+
+  pattern '/foo&bar' do
+    it { should match('/foo&bar') }
+  end
+
+  pattern '/*a/:foo/*b/*c' do
+    it { should match('/bar/foo/bling/baz/boom').capturing a: 'bar', foo: 'foo', b: 'bling', c: 'baz/boom'  }
+    example { pattern.params('/bar/foo/bling/baz/boom').should be == { "a" => 'bar', "foo" => 'foo', "b" => 'bling', "c" => 'baz/boom' } }
+    it { should expand(a: 'bar', foo: 'foo', b: 'bling', c: 'baz/boom').to('/bar/foo/bling/baz/boom') }
+    it { should generate_template('/{+a}/{foo}/{+b}/{+c}') }
+  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') }
+    it { should expand(file: 'pony', ext: 'jpg').to('/pony.jpg') }
+  end
+
+  pattern '/:a(x)' do
+    it { should match('/a')     .capturing a: 'a'   }
+    it { should match('/xa')    .capturing a: 'xa'  }
+    it { should match('/axa')   .capturing a: 'axa' }
+    it { should match('/ax')    .capturing a: 'a'   }
+    it { should match('/axax')  .capturing a: 'axa' }
+    it { should match('/axaxx') .capturing a: 'axax' }
+    it { should expand(a: 'x').to('/xx') }
+    it { should expand(a: 'a').to('/ax') }
+
+    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 expand(user: 'foo')              .to('/foo')     }
+    it { should expand(user: 'foo', host: 'bar') .to('/foo@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 expand(file: 'pony')              .to('/pony')     }
+    it { should expand(file: 'pony', ext: 'jpg')  .to('/pony.jpg') }
+
+    it { should generate_template('/{file}')       }
+    it { should generate_template('/{file}.{ext}') }
+  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') }
+
+    it { should expand(a: ?a, b: ?b)        .to('/a/b.')  }
+    it { should expand(a: ?a, b: ?b, c: ?c) .to('/a/b.c') }
+
+    it { should generate_template('/{a}/{b}')      }
+    it { should generate_template('/{a}/{b}.')     }
+    it { should generate_template('/{a}/{b}.{c}')  }
+  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('/') }
+
+    it { should expand(a: ?a)        .to('/a')     }
+    it { should expand(a: ?a, b: ?b) .to('/afoob') }
+
+    it { should     generate_template('/{a}foo{b}') }
+    it { should     generate_template('/{a}')       }
+    it { should_not generate_template('/{a}foo')    }
+  end
+
+  pattern '/fo(o)' do
+    it { should     match('/fo')   }
+    it { should     match('/foo')  }
+    it { should_not match('')      }
+    it { should_not match('/')     }
+    it { should_not match('/f')    }
+    it { should_not match('/fooo') }
+
+    it { should expand.to('/foo') }
+  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')  }
+
+    it { should expand.to('/foo%3F') }
+  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' }
+    it { should expand(foo: ?a, baz: ?b)          .to('/a/b')   }
+    it { should expand(foo: ?a, baz: ?b, bar: ?x) .to('/a/x/b') }
+  end
+
+  pattern '/:foo', capture: /\d+/ do
+    it { should match('/1')   .capturing foo: '1'   }
+    it { should match('/123') .capturing foo: '123' }
+
+    it { should_not match('/')    }
+    it { should_not match('/foo') }
+  end
+
+  pattern '/:foo', capture: /\d+/ do
+    it { should match('/1')   .capturing foo: '1'   }
+    it { should match('/123') .capturing foo: '123' }
+
+    it { should_not match('/')    }
+    it { should_not match('/foo') }
+  end
+
+  pattern '/:foo', capture: '1' do
+    it { should match('/1').capturing foo: '1' }
+
+    it { should_not match('/')    }
+    it { should_not match('/foo') }
+    it { should_not match('/123') }
+  end
+
+  pattern '/:foo', capture: 'a.b' do
+    it { should match('/a.b')   .capturing foo: 'a.b'   }
+    it { should match('/a%2Eb') .capturing foo: 'a%2Eb' }
+    it { should match('/a%2eb') .capturing foo: 'a%2eb' }
+
+    it { should_not match('/ab')   }
+    it { should_not match('/afb')  }
+    it { should_not match('/a1b')  }
+    it { should_not match('/a.bc') }
+  end
+
+  pattern '/:foo(/:bar)', capture: :alpha do
+    it { should match('/abc') .capturing foo: 'abc', bar: nil }
+    it { should match('/a/b') .capturing foo: 'a',   bar: 'b' }
+    it { should match('/a')   .capturing foo: 'a',   bar: nil }
+
+    it { should_not match('/1/2') }
+    it { should_not match('/a/2') }
+    it { should_not match('/1/b') }
+    it { should_not match('/1')   }
+    it { should_not match('/1/')  }
+    it { should_not match('/a/')  }
+    it { should_not match('//a')  }
+  end
+
+  pattern '/:foo', capture: ['foo', 'bar', /\d+/] do
+    it { should match('/1')   .capturing foo: '1'   }
+    it { should match('/123') .capturing foo: '123' }
+    it { should match('/foo') .capturing foo: 'foo' }
+    it { should match('/bar') .capturing foo: 'bar' }
+
+    it { should_not match('/')     }
+    it { should_not match('/baz')  }
+    it { should_not match('/foo1') }
+  end
+
+  pattern '/:foo:bar:baz', capture: { foo: :alpha, bar: /\d+/ } do
+    it { should match('/ab123xy-1') .capturing foo: 'ab', bar: '123', baz: 'xy-1' }
+    it { should match('/ab123')     .capturing foo: 'ab', bar: '12',  baz: '3'    }
+    it { should_not match('/123abcxy-1') }
+    it { should_not match('/abcxy-1')    }
+    it { should_not match('/abc1')       }
+  end
+
+  pattern '/:foo', capture: { foo: ['foo', 'bar', /\d+/] } do
+    it { should match('/1')   .capturing foo: '1'   }
+    it { should match('/123') .capturing foo: '123' }
+    it { should match('/foo') .capturing foo: 'foo' }
+    it { should match('/bar') .capturing foo: 'bar' }
+
+    it { should_not match('/')     }
+    it { should_not match('/baz')  }
+    it { should_not match('/foo1') }
+  end
+
+  pattern '/:file(.:ext)', capture: { ext: ['jpg', 'png'] } do
+    it { should match('/pony')         .capturing file: 'pony',     ext: nil   }
+    it { should match('/pony.jpg')     .capturing file: 'pony',     ext: 'jpg' }
+    it { should match('/pony%2Ejpg')   .capturing file: 'pony',     ext: 'jpg' }
+    it { should match('/pony%2ejpg')   .capturing file: 'pony',     ext: 'jpg' }
+    it { should match('/pony.png')     .capturing file: 'pony',     ext: 'png' }
+    it { should match('/pony%2Epng')   .capturing file: 'pony',     ext: 'png' }
+    it { should match('/pony%2epng')   .capturing file: 'pony',     ext: 'png' }
+    it { should match('/pony.png.jpg') .capturing file: 'pony.png', ext: 'jpg' }
+    it { should match('/pony.jpg.png') .capturing file: 'pony.jpg', ext: 'png' }
+    it { should match('/pony.gif')     .capturing file: 'pony.gif', ext: nil   }
+    it { should match('/pony.')        .capturing file: 'pony.',    ext: nil   }
+    it { should_not match('.jpg') }
+  end
+
+  pattern '/:file(:ext)', capture: { ext: ['.jpg', '.png', '.tar.gz'] } do
+    it { should match('/pony')         .capturing file: 'pony',     ext: nil       }
+    it { should match('/pony.jpg')     .capturing file: 'pony',     ext: '.jpg'    }
+    it { should match('/pony.png')     .capturing file: 'pony',     ext: '.png'    }
+    it { should match('/pony.png.jpg') .capturing file: 'pony.png', ext: '.jpg'    }
+    it { should match('/pony.jpg.png') .capturing file: 'pony.jpg', ext: '.png'    }
+    it { should match('/pony.tar.gz')  .capturing file: 'pony',     ext: '.tar.gz' }
+    it { should match('/pony.gif')     .capturing file: 'pony.gif', ext: nil       }
+    it { should match('/pony.')        .capturing file: 'pony.',    ext: nil       }
+    it { should_not match('/.jpg')  }
+  end
+
+  pattern '/:a(@:b)', capture: { b: /\d+/ } do
+    it { should match('/a')     .capturing a: 'a',   b: nil }
+    it { should match('/a@1')   .capturing a: 'a',   b: '1' }
+    it { should match('/a@b')   .capturing a: 'a@b', b: nil }
+    it { should match('/a@1@2') .capturing a: 'a@1', b: '2' }
+  end
+
+  pattern '/:a(b)', greedy: false do
+    it { should match('/ab').capturing a: 'a' }
+  end
+
+  pattern '/:file(.:ext)', greedy: false do
+    it { should match('/pony')           .capturing file: 'pony', ext: nil       }
+    it { should match('/pony.jpg')       .capturing file: 'pony', ext: 'jpg'     }
+    it { should match('/pony.png.jpg')   .capturing file: 'pony', ext: 'png.jpg' }
+  end
+
+  pattern '/:controller(/:action(/:id(.:format)))' do
+    it { should match('/content').capturing controller: 'content' }
+  end
+
+  pattern '/fo(o)', uri_decode: false do
+    it { should     match('/foo')   }
+    it { should     match('/fo')    }
+    it { should_not match('/fo(o)') }
+  end
+
+  pattern '/foo/bar', uri_decode: false do
+    it { should     match('/foo/bar')   }
+    it { should_not match('/foo%2Fbar') }
+    it { should_not match('/foo%2fbar') }
+  end
+
+  pattern "/path with spaces", uri_decode: false do
+    it { should     match('/path with spaces')     }
+    it { should_not match('/path%20with%20spaces') }
+    it { should_not match('/path%2Bwith%2Bspaces') }
+    it { should_not match('/path+with+spaces')     }
+  end
+
+  pattern "/path with spaces", space_matches_plus: false do
+    it { should     match('/path%20with%20spaces') }
+    it { should_not match('/path%2Bwith%2Bspaces') }
+    it { should_not match('/path+with+spaces')     }
+  end
+
+  context 'invalid syntax' do
+    example 'unexpected closing parenthesis' do
+      expect { Mustermann::Rails.new('foo)bar') }.
+        to raise_error(Mustermann::ParseError, 'unexpected ) while parsing "foo)bar"')
+    end
+
+    example 'missing closing parenthesis' do
+      expect { Mustermann::Rails.new('foo(bar') }.
+        to raise_error(Mustermann::ParseError, 'unexpected end of string while parsing "foo(bar"')
+    end
+  end
+
+  context 'invalid capture names' do
+    example 'empty name' do
+      expect { Mustermann::Rails.new('/:/') }.
+        to raise_error(Mustermann::CompileError, "capture name can't be empty: \"/:/\"")
+    end
+
+    example 'named splat' do
+      expect { Mustermann::Rails.new('/:splat/') }.
+        to raise_error(Mustermann::CompileError, "capture name can't be splat: \"/:splat/\"")
+    end
+
+    example 'named captures' do
+      expect { Mustermann::Rails.new('/:captures/') }.
+        to raise_error(Mustermann::CompileError, "capture name can't be captures: \"/:captures/\"")
+    end
+
+    example 'with capital letter' do
+      expect { Mustermann::Rails.new('/:Foo/') }.
+        to raise_error(Mustermann::CompileError, "capture name must start with underscore or lower case letter: \"/:Foo/\"")
+    end
+
+    example 'with integer' do
+      expect { Mustermann::Rails.new('/:1a/') }.
+        to raise_error(Mustermann::CompileError, "capture name must start with underscore or lower case letter: \"/:1a/\"")
+    end
+
+    example 'same name twice' do
+      expect { Mustermann::Rails.new('/:foo(/:bar)/:bar') }.
+        to raise_error(Mustermann::CompileError, "can't use the same capture name twice: \"/:foo(/:bar)/:bar\"")
+    end
+  end
+
+  context 'Regexp compatibility' do
+    describe :=== do
+      example('non-matching') { Mustermann::Rails.new("/")     .should_not be === '/foo' }
+      example('matching')     { Mustermann::Rails.new("/:foo") .should     be === '/foo' }
+    end
+
+    describe :=~ do
+      example('non-matching') { Mustermann::Rails.new("/")     .should_not be =~ '/foo' }
+      example('matching')     { Mustermann::Rails.new("/:foo") .should     be =~ '/foo' }
+
+      context 'String#=~' do
+        example('non-matching') { "/foo".should_not be =~ Mustermann::Rails.new("/") }
+        example('matching')     { "/foo".should     be =~ Mustermann::Rails.new("/:foo") }
+      end
+    end
+
+    describe :to_regexp do
+      example('empty pattern') { Mustermann::Rails.new('').to_regexp.should be == /\A(?-mix:)\Z/ }
+
+      context 'Regexp.try_convert' do
+        example('empty pattern') { Regexp.try_convert(Mustermann::Rails.new('')).should be == /\A(?-mix:)\Z/ }
+      end
+    end
+  end
+
+  context 'Proc compatibility' do
+    describe :to_proc do
+      example { Mustermann::Rails.new("/").to_proc.should be_a(Proc) }
+      example('non-matching') { Mustermann::Rails.new("/")     .to_proc.call('/foo').should be == false }
+      example('matching')     { Mustermann::Rails.new("/:foo") .to_proc.call('/foo').should be == true  }
+    end
+  end
+
+  context "peeking" do
+    subject(:pattern) { Mustermann::Rails.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
+
+  context 'version compatibility' do
+    context '2.3' do
+      pattern '(foo)', version: '2.3' do
+        it { should_not match("")      }
+        it { should_not match("foo")   }
+        it { should     match("(foo)") }
+      end
+
+      pattern '\\:name', version: '2.3' do
+        it { should match('%5cfoo').capturing(name: 'foo') }
+      end
+    end
+
+    context '3.0' do
+      pattern '(foo)', version: '3.0' do
+        it { should match("")      }
+        it { should match("foo")   }
+      end
+
+      pattern '\\:name', version: '3.0' do
+        it { should     match(':name') }
+        it { should_not match(':foo')  }
+      end
+    end
+
+    context '3.2' do
+      pattern '\\:name', version: '3.2' do
+        it { should match('%5cfoo').capturing(name: 'foo') }
+      end
+    end
+
+    context '4.0' do
+      pattern '\\:name', version: '4.0' do
+        it { should match('foo').capturing(name: 'foo') }
+      end
+    end
+
+    context '4.2' do
+      pattern '\\:name', version: '4.2' do
+        it { should     match(':name') }
+        it { should_not match(':foo')  }
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: mustermann-rails
+version: !ruby/object:Gem::Version
+  version: 0.4.0
+platform: ruby
+authors:
+- Konstantin Haase
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mustermann
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+description: Adds Rails style patterns to Mustermman
+email: konstantin.mailinglists@googlemail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/mustermann/rails.rb
+- lib/mustermann/versions.rb
+- mustermann-rails.gemspec
+- spec/rails_spec.rb
+homepage: https://github.com/rkh/mustermann
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.3
+signing_key: 
+specification_version: 4
+summary: Rails syntax for Mustermann
+test_files:
+- spec/rails_spec.rb
+has_rdoc: