mustermann-flask 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3711353dec9fd3af110d0e77f5bec7a991b17a9b
+  data.tar.gz: 7ac3a0d796f83314f7ec0306594e411639db6493
+SHA512:
+  metadata.gz: c04ab10704006935895cfeccb302867731393f794c53e130f1b9ab85ee57df4cf3d37bf0e29c0715a24d508636017f108436cce7909d2d7e77abe74a8b845ef6
+  data.tar.gz: acaa0a0b96dabb337e96284a3503fab35e1c0d8fb44ed6e2834fae3698a8f704dd9c6309322a5ba5ee36de3b23e545f508be34c5a1c5b4ea28dd559283e36555

data/README.md

@@ -0,0 +1,246 @@
+# Flask Syntax for Mustermann
+
+This gem implements the `flask` pattern type for Mustermann. It is compatible with [Flask](http://flask.pocoo.org/) and [Werkzeug](http://werkzeug.pocoo.org/).
+
+## Overview
+
+**Supported options:**
+`capture`, `except`, `greedy`, `space_matches_plus`, `uri_decode`, `converters` and `ignore_unknown_options`
+
+**External documentation:**
+[Werkzeug: URL Routing](http://werkzeug.pocoo.org/docs/0.9/routing/)
+
+``` ruby
+require 'mustermann/flask'
+
+Mustermann.new('/<prefix>/<path:page>', type: :flask).params('/a/b/c') # => { prefix: 'a', page: 'b/c' }
+
+pattern = Mustermann.new('/<name>', type: :flask)
+
+pattern.respond_to? :expand # => true
+pattern.expand(name: 'foo') # => '/foo'
+
+pattern.respond_to? :to_templates # => true
+pattern.to_templates              # => ['/{name}']
+```
+
+## Syntax
+
+<table>
+  <thead>
+    <tr>
+      <th>Syntax Element</th>
+      <th>Description</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td><b>&lt;</b><i>name</i><b>&gt;</b></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>&lt;</b><i>converter</i><b>:</b><i>name</i><b>&gt;</b></td>
+      <td>
+        Captures depending on the converter constraint. Capture is named <i>name</i>.
+        Capture behavior can be modified with <tt>capture</tt> and <tt>greedy</tt> option.
+        See below.
+      </td>
+    </tr>
+    <tr>
+      <td><b>&lt;</b><i>converter</i><b>(</b><i>arguments</i><b>):</b><i>name</i><b>&gt;</b></td>
+      <td>
+        Captures depending on the converter constraint. Capture is named <i>name</i>.
+        Capture behavior can be modified with <tt>capture</tt> and <tt>greedy</tt> option.
+        Arguments are separated by comma. An argument can be a simple string, a string enclosed
+        in single or double quotes, or a key value pair (keys and values being separated by an
+        equal sign). See below.
+      </td>
+    </tr>
+    <tr>
+      <td><b>/</b></td>
+      <td>
+        Matches forward slash. Does not match URI encoded version of forward slash.
+      </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>
+
+## Converters
+
+### Builtin Converters
+
+#### `string`
+
+Possible arguments: `minlength`, `maxlength`, `length`
+
+Captures anything but a forward slash in a semi-greedy fashion.
+Capture behavior can be modified with <tt>capture</tt> and <tt>greedy</tt> option.
+
+This is also the default converter.
+
+Examples:
+
+```
+<name>
+<string:name>
+<string(minlength=3,maxlength=10):slug>
+<string(length=10):slug>
+```
+
+#### `int`
+
+Possible arguments: `min`, `max`, `fixed_digits`
+
+Captures digits.
+Captured value will be converted to an Integer.
+
+Examples:
+
+```
+<int:id>
+<int(min=1,max=5):page>
+<int(fixed_digits=16):uuid>
+```
+
+#### `float`
+
+Possible arguments: `min`, `max`
+
+Captures digits with a dot.
+Captured value will be converted to an Float.
+
+Examples:
+
+```
+<float:precision>
+<float(min=0,max=1):precision>
+```
+
+#### `path`
+
+Captures anything in a non-greedy fashion.
+
+Example:
+
+```
+<path:rest>
+```
+
+#### `any`
+
+Possible arguments: List of accepted strings.
+
+Captures anything that matches one of the arguments exactly.
+
+Example:
+
+```
+<any(home,search,contact):page>
+```
+
+### Custom Converters
+
+[Flask patterns](#-pattern-details-flask) support registering custom converters.
+
+A converter object may implement any of the following methods:
+
+* `convert`: Should return a block converting a string value to whatever value should end up in the `params` hash.
+* `constraint`: Should return a regular expression limiting which input string will match the capture.
+* `new`: Returns an object that may respond to `convert` and/or `constraint` as described above. Any arguments used for the converter inside the pattern will be passed to `new`.
+
+``` ruby
+require 'mustermann/flask'
+
+SimpleConverter = Struct.new(:constraint, :convert)
+id_converter    = SimpleConverter.new(/\d/, -> s { s.to_i })
+
+class NumConverter
+  def initialize(base: 10)
+    @base = Integer(base)
+  end
+
+  def convert
+    -> s { s.to_i(@base) }
+  end
+
+  def constraint
+    @base > 10 ? /[\da-#{(@base-1).to_s(@base)}]/ : /[0-#{@base-1}]/
+  end
+end
+
+pattern = Mustermann.new('/<id:id>/<num(base=8):oct>/<num(base=16):hex>',
+  type: :flask, converters: { id: id_converter, num: NumConverter})
+
+pattern.params('/10/12/f1') # => {"id"=>10, "oct"=>10, "hex"=>241}
+```
+
+### Global Converters
+
+It is also possible to register a converter for all flask patterns, using `register_converter`:
+
+``` ruby
+Mustermann::Flask.register_converter(:id,  id_converter)
+Mustermann::Flask.register_converter(:num, NumConverter)
+
+pattern = Mustermann.new('/<id:id>/<num(base=8):oct>/<num(base=16):hex>', type: :flask)
+pattern.params('/10/12/f1') # => {"id"=>10, "oct"=>10, "hex"=>241}
+```
+
+There is a handy syntax for quickly creating new converter classes: When you pass a block instead of a converter object, it will yield a generic converter with setters and getters for `convert` and `constraint`, and any arguments passed to the converter.
+
+``` ruby
+require 'mustermann/flask'
+
+Mustermann::Flask.register_converter(:id) do |converter|
+  converter.constraint = /\d/
+  converter.convert    = -> s { s.to_i }
+end
+
+Mustermann::Flask.register_converter(:num) do |converter, base: 10|
+  converter.constraint = base > 10 ? /[\da-#{(@base-1).to_s(base)}]/ : /[0-#{base-1}]/
+  converter.convert    = -> s { s.to_i(base) }
+end
+
+pattern = Mustermann.new('/<id:id>/<num(base=8):oct>/<num(base=16):hex>', type: :flask)
+pattern.params('/10/12/f1') # => {"id"=>10, "oct"=>10, "hex"=>241}
+```
+
+### Subclassing
+
+Registering global converters will make these available for all Flask patterns. It might even override already registered converters. This global state might break unrelated code.
+
+It is therefore recommended that, if you don't want to pass in the converters option for every pattern, you create your own subclass of `Mustermann::Flask`.
+
+``` ruby
+require 'mustermann/flask'
+
+MyFlask = Class.new(Mustermann::Flask)
+
+MyFlask.register_converter(:id) do |converter|
+  converter.constraint = /\d/
+  converter.convert    = -> s { s.to_i }
+end
+
+MyFlask.register_converter(:num) do |converter, base: 10|
+  converter.constraint = base > 10 ? /[\da-#{(@base-1).to_s(base)}]/ : /[0-#{base-1}]/
+  converter.convert    = -> s { s.to_i(base) }
+end
+
+pattern = MyFlask.new('/<id:id>/<num(base=8):oct>/<num(base=16):hex>')
+pattern.params('/10/12/f1') # => {"id"=>10, "oct"=>10, "hex"=>241}
+```
+
+You can even register this type for usage with `Mustermann.new`:
+
+``` ruby
+Mustermann.register(:my_flask, MyFlask)
+pattern = Mustermann.new('/<id:id>/<num(base=8):oct>/<num(base=16):hex>', type: :my_flask)
+pattern.params('/10/12/f1') # => {"id"=>10, "oct"=>10, "hex"=>241}
+```

data/lib/mustermann/flask.rb

@@ -0,0 +1,197 @@
+require 'mustermann'
+require 'mustermann/ast/pattern'
+
+module Mustermann
+  # Flask style pattern implementation.
+  #
+  # @example
+  #   Mustermann.new('/<foo>', type: :flask) === '/bar' # => true
+  #
+  # @see Mustermann::Pattern
+  # @see file:README.md#flask Syntax description in the README
+  class Flask < AST::Pattern
+    register :flask
+
+    on(nil, ?>, ?:) { |c| unexpected(c) }
+
+    on(?<) do |char|
+      converter_name       = expect(/\w+/, char: char)
+      args, opts           = scan(?() ? read_args(?=, ?)) : [[], {}]
+
+      if scan(?:)
+        name = read_escaped(?>)
+      else
+        converter_name, name = 'default', converter_name
+        expect(?>)
+      end
+
+      converter   = pattern.converters.fetch(converter_name) { unexpected("converter %p" % converter_name) }
+      converter   = converter.new(*args, **opts)  if converter.respond_to? :new
+      constraint  = converter.constraint          if converter.respond_to? :constraint
+      convert     = converter.convert             if converter.respond_to? :convert
+      qualifier   = converter.qualifier           if converter.respond_to? :qualifier
+      node_type   = converter.node_type           if converter.respond_to? :node_type
+      node_type ||= :capture
+
+      node(node_type, name, convert: convert, constraint: constraint, qualifier: qualifier)
+    end
+
+    # A class for easy creating of converters.
+    # @see Mustermann::Flask#register_converter
+    class Converter
+      # Constraint on the format used for the capture.
+      # Should be a regexp (or a string corresponding to a regexp)
+      # @see Mustermann::Flask#register_converter
+      attr_accessor :constraint
+
+      # Callback
+      # Should be a Proc.
+      # @see Mustermann::Flask#register_converter
+      attr_accessor :convert
+
+      # Constraint on the format used for the capture.
+      # Should be a regexp (or a string corresponding to a regexp)
+      # @see Mustermann::Flask#register_converter
+      # @!visibility private
+      attr_accessor :node_type
+
+      # Constraint on the format used for the capture.
+      # Should be a regexp (or a string corresponding to a regexp)
+      # @see Mustermann::Flask#register_converter
+      # @!visibility private
+      attr_accessor :qualifier
+
+      # @!visibility private
+      def self.create(&block)
+        Class.new(self) do
+          define_method(:initialize) { |*a, **o| block[self, *a, **o] }
+        end
+      end
+
+      # Makes sure a given value falls inbetween a min and a max.
+      # Uses the passed block to convert the value from a string to whatever
+      # format you'd expect.
+      #
+      # @example
+      #   require 'mustermann/flask'
+      #
+      #   class MyPattern < Mustermann::Flask
+      #     register_converter(:x) { between(5, 15, &:to_i) }
+      #   end
+      #
+      #   pattern = MyPattern.new('<x:id>')
+      #   pattern.params('/12') # => { 'id' => 12 }
+      #   pattern.params('/16') # => { 'id' => 15 }
+      #
+      # @see Mustermann::Flask#register_converter
+      def between(min, max)
+        self.convert = proc do |input|
+          value = yield(input)
+          value = yield(min) if min and value < yield(min)
+          value = yield(max) if max and value > yield(max)
+          value
+        end
+      end
+    end
+
+    # Generally available converters.
+    # @!visibility private
+    def self.converters(inherited = true)
+      return @converters ||= {} unless inherited
+      defaults = superclass.respond_to?(:converters) ? superclass.converters : {}
+      defaults.merge(converters(false))
+    end
+
+    # Allows you to register your own converters.
+    #
+    # It is reommended to use this on a subclass, so to not influence other subsystems
+    # using flask templates.
+    #
+    # The object passed in as converter can implement #convert and/or #constraint.
+    #
+    # It can also instead implement #new, which will then return an object responding
+    # to some of these methods. Arguments from the flask pattern will be passed to #new.
+    #
+    # If passed a block, it will be yielded to with a {Mustermann::Flask::Converter}
+    # instance and any arguments in the flask pattern.
+    #
+    # @example with simple object
+    #   require 'mustermann/flask'
+    #
+    #   MyPattern    = Class.new(Mustermann::Flask)
+    #   up_converter = Struct.new(:convert).new(:upcase.to_proc)
+    #   MyPattern.register_converter(:upper, up_converter)
+    #
+    #   MyPattern.new("/<up:name>").params('/foo') # => { "name" => "FOO" }
+    #
+    # @example with block
+    #   require 'mustermann/flask'
+    #
+    #   MyPattern    = Class.new(Mustermann::Flask)
+    #   MyPattern.register_converter(:upper) { |c| c.convert = :upcase.to_proc }
+    #
+    #   MyPattern.new("/<up:name>").params('/foo') # => { "name" => "FOO" }
+    #
+    # @example with converter class
+    #   require 'mustermann/flasl'
+    #
+    #   class MyPattern < Mustermann::Flask
+    #     class Converter
+    #       attr_reader :convert
+    #       def initialize(send: :to_s)
+    #         @convert = send.to_sym.to_proc
+    #       end
+    #     end
+    #
+    #     register_converter(:t, Converter)
+    #   end
+    #
+    #   MyPattern.new("/<t(send=upcase):name>").params('/Foo')   # => { "name" => "FOO" }
+    #   MyPattern.new("/<t(send=downcase):name>").params('/Foo') # => { "name" => "foo" }
+    #
+    # @param [#to_s] name converter name
+    # @param [#new, #convert, #constraint, nil] converter
+    def self.register_converter(name, converter = nil, &block)
+      converter ||= Converter.create(&block)
+      converters(false)[name.to_s] = converter
+    end
+
+    register_converter(:string) do |converter, minlength: nil, maxlength: nil, length: nil|
+      converter.qualifier = "{%s,%s}" % [minlength || 1, maxlength] if minlength or maxlength
+      converter.qualifier = "{%s}"    % length if length
+    end
+
+    register_converter(:int) do |converter, min: nil, max: nil, fixed_digits: false|
+      converter.constraint = /\d/
+      converter.qualifier  = "{#{fixed_digits}}" if fixed_digits
+      converter.between(min, max) { |string| Integer(string) }
+    end
+
+    register_converter(:float) do |converter, min: nil, max: nil|
+      converter.constraint = /\d*\.?\d+/
+      converter.qualifier  = ""
+      converter.between(min, max) { |string| Float(string) }
+    end
+
+    register_converter(:path) do |converter|
+      converter.node_type = :named_splat
+    end
+
+    register_converter(:any) do |converter, *strings|
+      strings              = strings.map { |s| Regexp.escape(s) unless s == {} }.compact
+      converter.qualifier  = ""
+      converter.constraint = Regexp.union(*strings)
+    end
+
+    register_converter(:default, converters['string'])
+
+    supported_options :converters
+    attr_reader :converters
+
+    def initialize(input, converters: {}, **options)
+      @converters = self.class.converters.dup
+      converters.each { |k,v| @converters[k.to_s] = v } if converters
+      super(input, **options)
+    end
+  end
+end

data/mustermann-flask.gemspec

@@ -0,0 +1,18 @@
+$:.unshift File.expand_path("../../mustermann/lib", __FILE__)
+require "mustermann/version"
+
+Gem::Specification.new do |s|
+  s.name                  = "mustermann-flask"
+  s.version               = Mustermann::VERSION
+  s.author                = "Konstantin Haase"
+  s.email                 = "konstantin.mailinglists@googlemail.com"
+  s.homepage              = "https://github.com/rkh/mustermann"
+  s.summary               = %q{Flask syntax for Mustermann}
+  s.description           = %q{Adds Flask 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/flask_spec.rb

@@ -0,0 +1,361 @@
+require 'support'
+require 'mustermann/flask'
+
+describe Mustermann::Flask 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 '/<string: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 '/<string(minlength=2):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('/f')       }
+    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 '/<string(maxlength=3):foo>' do
+    it { should match('/f')   .capturing foo: 'f'   }
+    it { should match('/fo')  .capturing foo: 'fo'  }
+    it { should match('/foo') .capturing foo: 'foo' }
+    it { should match('/bar') .capturing foo: 'bar' }
+
+    it { should_not match('/fooo')    }
+    it { should_not match('/foo.bar') }
+    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 '/<string(length=3):foo>' do
+    it { should match('/foo') .capturing foo: 'foo' }
+    it { should match('/bar') .capturing foo: 'bar' }
+
+    it { should_not match('/f')       }
+    it { should_not match('/fo')      }
+    it { should_not match('/fooo')    }
+    it { should_not match('/foo.bar') }
+    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 '/<int:foo>' do
+    it { should match('/42').capturing foo: '42' }
+
+    it { should_not match('/1.0')       }
+    it { should_not match('/.5')        }
+    it { should_not match('/foo')       }
+    it { should_not match('/bar')       }
+    it { should_not match('/foo.bar')   }
+    it { should_not match('/%0Afoo')    }
+    it { should_not match('/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('/42').should be == {"foo" => 42} }
+    it { should expand(foo: 12).to('/12') }
+    it { should generate_template('/{foo}') }
+  end
+
+  pattern '/<int:foo>' do
+    it { should match('/42').capturing foo: '42' }
+
+    it { should_not match('/1.0')       }
+    it { should_not match('/.5')        }
+    it { should_not match('/foo')       }
+    it { should_not match('/bar')       }
+    it { should_not match('/foo.bar')   }
+    it { should_not match('/%0Afoo')    }
+    it { should_not match('/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('/42').should be == {"foo" => 42} }
+    it { should expand(foo: 12).to('/12') }
+    it { should generate_template('/{foo}') }
+  end
+
+  pattern '/<any(foo,bar):foo>' do
+    it { should match('/foo') .capturing foo: 'foo' }
+    it { should match('/bar') .capturing foo: 'bar' }
+
+    it { should_not match('/f')       }
+    it { should_not match('/fo')      }
+    it { should_not match('/fooo')    }
+    it { should_not match('/foo.bar') }
+    it { should_not match('/foo?')    }
+    it { should_not match('/foo/bar') }
+    it { should_not match('/')        }
+    it { should_not match('/foo/')    }
+    it { should_not match('/baz')     }
+
+    it { should generate_template('/{foo}') }
+  end
+
+  pattern '/<any( foo, bar ):foo>' do
+    it { should match('/foo') .capturing foo: 'foo' }
+    it { should match('/bar') .capturing foo: 'bar' }
+
+    it { should_not match('/f')       }
+    it { should_not match('/fo')      }
+    it { should_not match('/fooo')    }
+    it { should_not match('/foo.bar') }
+    it { should_not match('/foo?')    }
+    it { should_not match('/foo/bar') }
+    it { should_not match('/')        }
+    it { should_not match('/foo/')    }
+    it { should_not match('/baz')     }
+
+    it { should generate_template('/{foo}') }
+  end
+
+  pattern '/<any(foo, bar, "foo,bar"):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_not match('/f')       }
+    it { should_not match('/fo')      }
+    it { should_not match('/fooo')    }
+    it { should_not match('/foo.bar') }
+    it { should_not match('/foo?')    }
+    it { should_not match('/foo/bar') }
+    it { should_not match('/')        }
+    it { should_not match('/foo/')    }
+    it { should_not match('/baz')     }
+
+    it { should generate_template('/{foo}') }
+  end
+
+  pattern '/<any(foo, bar, foo\,bar):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_not match('/f')       }
+    it { should_not match('/fo')      }
+    it { should_not match('/fooo')    }
+    it { should_not match('/foo.bar') }
+    it { should_not match('/foo?')    }
+    it { should_not match('/foo/bar') }
+    it { should_not match('/')        }
+    it { should_not match('/foo/')    }
+    it { should_not match('/baz')     }
+
+    it { should generate_template('/{foo}') }
+  end
+
+  pattern '/<any(foo, bar, "foo\,bar"):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_not match('/f')       }
+    it { should_not match('/fo')      }
+    it { should_not match('/fooo')    }
+    it { should_not match('/foo.bar') }
+    it { should_not match('/foo?')    }
+    it { should_not match('/foo/bar') }
+    it { should_not match('/')        }
+    it { should_not match('/foo/')    }
+    it { should_not match('/baz')     }
+
+    it { should generate_template('/{foo}') }
+  end
+
+  pattern '/<int(min=5,max=50):foo>' do
+    example { pattern.params('/42').should be == {"foo" => 42} }
+    example { pattern.params('/52').should be == {"foo" => 50} }
+    example { pattern.params('/2').should  be == {"foo" =>  5} }
+  end
+
+  pattern '/<float(min=5,max=50.5):foo>' do
+    example { pattern.params('/42.5').should be == {"foo" => 42.5} }
+    example { pattern.params('/52.5').should be == {"foo" => 50.5} }
+    example { pattern.params('/2.5').should  be == {"foo" =>  5.0} }
+  end
+
+  pattern '/<prefix>/<float:foo>/<int:bar>' do
+    it { should match('/foo/42/42') .capturing foo: '42',  bar: '42'  }
+    it { should match('/foo/1.0/1') .capturing foo: '1.0', bar: '1'   }
+    it { should match('/foo/.5/0')  .capturing foo: '.5',  bar: '0'   }
+
+    it { should_not match('/foo/1/1.0')   }
+    it { should_not match('/foo/1.0/1.0') }
+
+    it { should generate_template('/{prefix}/{foo}/{bar}') }
+
+    example do
+       pattern.params('/foo/1.0/1').should be == {
+         "prefix" => "foo",
+         "foo"    => 1.0,
+         "bar"    => 1
+       }
+    end
+  end
+
+  pattern '/<path: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
+
+  converter = Struct.new(:convert).new(:upcase.to_proc)
+  pattern '/<foo:bar>', converters: { foo: converter } do
+    it { should match('/foo').capturing bar: 'foo' }
+    example { pattern.params('/foo').should be == {"bar" => "FOO"} }
+  end
+
+  context 'invalid syntax' do
+    example 'unexpected end of capture' do
+      expect { Mustermann::Flask.new('foo>bar') }.
+        to raise_error(Mustermann::ParseError, 'unexpected > while parsing "foo>bar"')
+    end
+
+    example 'missing end of capture' do
+      expect { Mustermann::Flask.new('foo<bar') }.
+        to raise_error(Mustermann::ParseError, 'unexpected end of string while parsing "foo<bar"')
+    end
+
+    example 'unknown converter' do
+      expect { Mustermann::Flask.new('foo<bar:name>') }.
+        to raise_error(Mustermann::ParseError, 'unexpected converter "bar" while parsing "foo<bar:name>"')
+    end
+
+    example 'broken argument synax' do
+      expect { Mustermann::Flask.new('<string(length=3=2):foo>') }.
+        to raise_error(Mustermann::ParseError, 'unexpected = while parsing "<string(length=3=2):foo>"')
+    end
+
+    example 'missing )' do
+      expect { Mustermann::Flask.new('<string(foo') }.
+        to raise_error(Mustermann::ParseError, 'unexpected end of string while parsing "<string(foo"')
+    end
+
+    example 'missing ""' do
+      expect { Mustermann::Flask.new('<string("foo') }.
+        to raise_error(Mustermann::ParseError, 'unexpected end of string while parsing "<string(\\"foo"')
+    end
+  end
+end

data/spec/flask_subclass_spec.rb

@@ -0,0 +1,368 @@
+require 'support'
+require 'mustermann/flask'
+
+FlaskSubclass ||= Class.new(Mustermann::Flask)
+FlaskSubclass.register_converter(:foo) {} 
+
+describe FlaskSubclass 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 '/<string: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 '/<string(minlength=2):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('/f')       }
+    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 '/<string(maxlength=3):foo>' do
+    it { should match('/f')   .capturing foo: 'f'   }
+    it { should match('/fo')  .capturing foo: 'fo'  }
+    it { should match('/foo') .capturing foo: 'foo' }
+    it { should match('/bar') .capturing foo: 'bar' }
+
+    it { should_not match('/fooo')    }
+    it { should_not match('/foo.bar') }
+    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 '/<string(length=3):foo>' do
+    it { should match('/foo') .capturing foo: 'foo' }
+    it { should match('/bar') .capturing foo: 'bar' }
+
+    it { should_not match('/f')       }
+    it { should_not match('/fo')      }
+    it { should_not match('/fooo')    }
+    it { should_not match('/foo.bar') }
+    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 '/<int:foo>' do
+    it { should match('/42').capturing foo: '42' }
+
+    it { should_not match('/1.0')       }
+    it { should_not match('/.5')        }
+    it { should_not match('/foo')       }
+    it { should_not match('/bar')       }
+    it { should_not match('/foo.bar')   }
+    it { should_not match('/%0Afoo')    }
+    it { should_not match('/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('/42').should be == {"foo" => 42} }
+    it { should expand(foo: 12).to('/12') }
+    it { should generate_template('/{foo}') }
+  end
+
+  pattern '/<int:foo>' do
+    it { should match('/42').capturing foo: '42' }
+
+    it { should_not match('/1.0')       }
+    it { should_not match('/.5')        }
+    it { should_not match('/foo')       }
+    it { should_not match('/bar')       }
+    it { should_not match('/foo.bar')   }
+    it { should_not match('/%0Afoo')    }
+    it { should_not match('/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('/42').should be == {"foo" => 42} }
+    it { should expand(foo: 12).to('/12') }
+    it { should generate_template('/{foo}') }
+  end
+
+  pattern '/<any(foo,bar):foo>' do
+    it { should match('/foo') .capturing foo: 'foo' }
+    it { should match('/bar') .capturing foo: 'bar' }
+
+    it { should_not match('/f')       }
+    it { should_not match('/fo')      }
+    it { should_not match('/fooo')    }
+    it { should_not match('/foo.bar') }
+    it { should_not match('/foo?')    }
+    it { should_not match('/foo/bar') }
+    it { should_not match('/')        }
+    it { should_not match('/foo/')    }
+    it { should_not match('/baz')     }
+
+    it { should generate_template('/{foo}') }
+  end
+
+  pattern '/<any( foo, bar ):foo>' do
+    it { should match('/foo') .capturing foo: 'foo' }
+    it { should match('/bar') .capturing foo: 'bar' }
+
+    it { should_not match('/f')       }
+    it { should_not match('/fo')      }
+    it { should_not match('/fooo')    }
+    it { should_not match('/foo.bar') }
+    it { should_not match('/foo?')    }
+    it { should_not match('/foo/bar') }
+    it { should_not match('/')        }
+    it { should_not match('/foo/')    }
+    it { should_not match('/baz')     }
+
+    it { should generate_template('/{foo}') }
+  end
+
+  pattern '/<any(foo, bar, "foo,bar"):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_not match('/f')       }
+    it { should_not match('/fo')      }
+    it { should_not match('/fooo')    }
+    it { should_not match('/foo.bar') }
+    it { should_not match('/foo?')    }
+    it { should_not match('/foo/bar') }
+    it { should_not match('/')        }
+    it { should_not match('/foo/')    }
+    it { should_not match('/baz')     }
+
+    it { should generate_template('/{foo}') }
+  end
+
+  pattern '/<any(foo, bar, foo\,bar):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_not match('/f')       }
+    it { should_not match('/fo')      }
+    it { should_not match('/fooo')    }
+    it { should_not match('/foo.bar') }
+    it { should_not match('/foo?')    }
+    it { should_not match('/foo/bar') }
+    it { should_not match('/')        }
+    it { should_not match('/foo/')    }
+    it { should_not match('/baz')     }
+
+    it { should generate_template('/{foo}') }
+  end
+
+  pattern '/<any(foo, bar, "foo\,bar"):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_not match('/f')       }
+    it { should_not match('/fo')      }
+    it { should_not match('/fooo')    }
+    it { should_not match('/foo.bar') }
+    it { should_not match('/foo?')    }
+    it { should_not match('/foo/bar') }
+    it { should_not match('/')        }
+    it { should_not match('/foo/')    }
+    it { should_not match('/baz')     }
+
+    it { should generate_template('/{foo}') }
+  end
+
+  pattern '/<int(min=5,max=50):foo>' do
+    example { pattern.params('/42').should be == {"foo" => 42} }
+    example { pattern.params('/52').should be == {"foo" => 50} }
+    example { pattern.params('/2').should  be == {"foo" =>  5} }
+  end
+
+  pattern '/<float(min=5,max=50.5):foo>' do
+    example { pattern.params('/42.5').should be == {"foo" => 42.5} }
+    example { pattern.params('/52.5').should be == {"foo" => 50.5} }
+    example { pattern.params('/2.5').should  be == {"foo" =>  5.0} }
+  end
+
+  pattern '/<prefix>/<float:foo>/<int:bar>' do
+    it { should match('/foo/42/42') .capturing foo: '42',  bar: '42'  }
+    it { should match('/foo/1.0/1') .capturing foo: '1.0', bar: '1'   }
+    it { should match('/foo/.5/0')  .capturing foo: '.5',  bar: '0'   }
+
+    it { should_not match('/foo/1/1.0')   }
+    it { should_not match('/foo/1.0/1.0') }
+
+    it { should generate_template('/{prefix}/{foo}/{bar}') }
+
+    example do
+       pattern.params('/foo/1.0/1').should be == {
+         "prefix" => "foo",
+         "foo"    => 1.0,
+         "bar"    => 1
+       }
+    end
+  end
+
+  pattern '/<path: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 '/<foo:bar>' do
+    it { should match('/foo').capturing bar: 'foo' }
+    it { should generate_template('/{bar}') }
+
+    example do
+      expect { Mustermann::Flask.new('/<foo:bar>') }.to \
+        raise_error(Mustermann::ParseError, 'unexpected converter "foo" while parsing "/<foo:bar>"')
+    end
+  end
+
+  context 'invalid syntax' do
+    example 'unexpected end of capture' do
+      expect { FlaskSubclass.new('foo>bar') }.
+        to raise_error(Mustermann::ParseError, 'unexpected > while parsing "foo>bar"')
+    end
+
+    example 'missing end of capture' do
+      expect { FlaskSubclass.new('foo<bar') }.
+        to raise_error(Mustermann::ParseError, 'unexpected end of string while parsing "foo<bar"')
+    end
+
+    example 'unknown converter' do
+      expect { FlaskSubclass.new('foo<bar:name>') }.
+        to raise_error(Mustermann::ParseError, 'unexpected converter "bar" while parsing "foo<bar:name>"')
+    end
+
+    example 'broken argument synax' do
+      expect { FlaskSubclass.new('<string(length=3=2):foo>') }.
+        to raise_error(Mustermann::ParseError, 'unexpected = while parsing "<string(length=3=2):foo>"')
+    end
+
+    example 'missing )' do
+      expect { FlaskSubclass.new('<string(foo') }.
+        to raise_error(Mustermann::ParseError, 'unexpected end of string while parsing "<string(foo"')
+    end
+
+    example 'missing ""' do
+      expect { FlaskSubclass.new('<string("foo') }.
+        to raise_error(Mustermann::ParseError, 'unexpected end of string while parsing "<string(\\"foo"')
+    end
+  end
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: mustermann-flask
+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 Flask style patterns to Mustermman
+email: konstantin.mailinglists@googlemail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/mustermann/flask.rb
+- mustermann-flask.gemspec
+- spec/flask_spec.rb
+- spec/flask_subclass_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: Flask syntax for Mustermann
+test_files:
+- spec/flask_spec.rb
+- spec/flask_subclass_spec.rb
+has_rdoc: