mustermann19 0.3.1

data/Rakefile

@@ -0,0 +1,6 @@
+ENV['JRUBY_OPTS'] = '--2.0 -X-C'
+ENV['RBXOPT'] = '-X20'
+
+task(:spec) { ruby '-w -S rspec' }
+task(:doc_stats) { ruby '-S yard stats' }
+task(default: [:spec, :doc_stats])

data/bench/capturing.rb

@@ -0,0 +1,57 @@
+$:.unshift File.expand_path('../lib', File.dirname(__FILE__))
+
+require 'benchmark'
+require 'mustermann'
+require 'mustermann/regexp_based'
+require 'addressable/template'
+
+
+Mustermann.register(:regexp, Class.new(Mustermann::RegexpBased) {
+  def compile(**options)
+    Regexp.new(@string)
+  end
+}, load: false)
+
+Mustermann.register(:addressable, Class.new(Mustermann::RegexpBased) {
+  def compile(**options)
+    Addressable::Template.new(@string)
+  end
+}, load: false)
+
+list = [
+  [:sinatra,     '/*/:name'                                ],
+  [:rails,       '/*prefix/:name'                          ],
+  [:simple,      '/*/:name'                                ],
+  [:template,    '{/prefix*}/{name}'                       ],
+  [:regexp,      '\A\/(?<splat>.*?)\/(?<name>[^\/\?#]+)\Z' ],
+  [:addressable, '{/prefix*}/{name}'                       ]
+]
+
+def self.assert(value)
+  fail unless value
+end
+
+string = '/a/b/c/d'
+name   = 'd'
+
+GC.disable
+
+puts "Compilation:"
+Benchmark.bmbm do |x|
+  list.each do |type, pattern|
+    x.report(type) { 1_000.times { Mustermann.new(pattern, type: type) } }
+  end
+end
+
+puts "", "Matching with two captures (one splat, one normal):"
+Benchmark.bmbm do |x|
+  list.each do |type, pattern|
+    pattern = Mustermann.new(pattern, type: type)
+    x.report type do
+      10_000.times do
+        match = pattern.match(string)
+        assert match[:name] == name
+      end
+    end
+  end
+end

data/bench/regexp.rb

@@ -0,0 +1,21 @@
+require 'benchmark'
+
+puts " atomic vs normal segments ".center(52, '=')
+
+types = {
+  normal: /\A\/(?:a|%61)\/(?<b>[^\/\?#]+)(?:\/(?<c>[^\/\?#]+))?\Z/,
+  atomic: /\A\/(?:a|%61)\/(?<b>(?>[^\/\?#]+))(?:\/(?<c>(?>[^\/\?#]+)))?\Z/
+}
+
+Benchmark.bmbm do |x|
+  types.each do |name, regexp|
+    string = "/a/" << ?a * 10000 << "/" << ?a * 5000
+    fail unless regexp.match(string)
+    string << "/"
+    fail if regexp.match(string)
+
+    x.report name.to_s do
+      100.times { regexp.match(string) }
+    end
+  end
+end

data/bench/simple_vs_sinatra.rb

@@ -0,0 +1,23 @@
+$:.unshift File.expand_path('../lib', File.dirname(__FILE__))
+
+require 'benchmark'
+require 'mustermann/simple'
+require 'mustermann/sinatra'
+
+[Mustermann::Simple, Mustermann::Sinatra].each do |klass|
+  puts "", " #{klass} ".center(64, '=')
+  Benchmark.bmbm do |x|
+    no_capture = klass.new("/simple")
+    x.report("no captures, match") { 1_000.times { no_capture.match('/simple') } }
+    x.report("no captures, miss") { 1_000.times { no_capture.match('/miss') } }
+
+    simple = klass.new("/:name")
+    x.report("simple, match") { 1_000.times { simple.match('/simple').captures } }
+    x.report("simple, miss") { 1_000.times { simple.match('/mi/ss') } }
+
+    splat = klass.new("/*")
+    x.report("splat, match") { 1_000.times { splat.match("/a/b/c").captures } }
+    x.report("splat, miss") { 1_000.times { splat.match("/a/b/c.miss") } }
+  end
+  puts
+end

data/bench/template_vs_addressable.rb

@@ -0,0 +1,26 @@
+$:.unshift File.expand_path('../lib', File.dirname(__FILE__))
+
+require 'benchmark'
+require 'mustermann/template'
+require 'addressable/template'
+
+[Mustermann::Template, Addressable::Template].each do |klass|
+  puts "", " #{klass} ".center(64, '=')
+  Benchmark.bmbm do |x|
+    no_capture = klass.new("/simple")
+    x.report("no captures, match") { 1_000.times { no_capture.match('/simple') } }
+    x.report("no captures, miss") { 1_000.times { no_capture.match('/miss') } }
+
+    simple = klass.new("/{match}")
+    x.report("simple, match") { 1_000.times { simple.match('/simple').captures } }
+    x.report("simple, miss") { 1_000.times { simple.match('/mi/ss') } }
+
+    explode = klass.new("{/segments*}")
+    x.report("explode, match") { 1_000.times { explode.match("/a/b/c").captures } }
+    x.report("explode, miss") { 1_000.times { explode.match("/a/b/c.miss") } }
+
+    expand = klass.new("/prefix/{foo}/something/{bar}")
+    x.report("expand") { 100.times { expand.expand(foo: 'foo', bar: 'bar').to_s } }
+  end
+  puts
+end

data/internals.md

@@ -0,0 +1,64 @@
+# Internal API
+
+This document describes how to use [Mustermann](README.md)'s internal API.
+
+It is a secondary goal to keep the internal API as stable as possible, in a state where it would well be possible to interface with it.
+However, the internal API is not covered by Semantic Versioning. As a rule of thumb, no backwards incompatible changes should be introduced to the API in minor releases (starting from 1.0.0).
+
+Should the internal API gain widespread/production use, we might consider moving parts of it over into the public API.
+
+Here is a quick example of what you can do with this:
+
+``` ruby
+require 'mustermann/ast/pattern'
+
+class MyPattern < Mustermann::AST::Pattern
+  on("~") { |c| node(:capture,     buffer[1]) if expect(/\{(\w+)\}/) }
+  on("+") { |c| node(:named_splat, buffer[1]) if expect(/\{(\w+)\}/) }
+  on("?") { |c| node(:optional, node(:capture, buffer[1])) if expect(/\{(\w+)\}/) }
+end
+
+pattern = MyPattern.new("/+{prefix}/~{page}/?{optional}")
+pattern.params("/a/")     # => nil
+pattern.params("/a/b/")   # => { "prefix" => "a",   "page" => "b", "optional" => nil }
+pattern.params("/a/b/c")  # => { "prefix" => "a",   "page" => "b", "optional" => "c" }
+pattern.params("/a/b/c/") # => { "prefix" => "a/b", "page" => "c", "optional" => nil }
+
+pattern.expand(prefix: "a",   page: "foo") # => "/a/foo/"
+pattern.expand(prefix: "a/b", page: "c/d") # => "/a/b/c%2Fd/"
+
+require 'mustermann'
+Mustermann.register(:my_pattern, MyPattern, load: false)
+Mustermann.new('/+{prefix}/~{page}/?{optional}', type: :my_pattern) # => #<MyPattern:"/+{prefix}/~{page}/?{optional}">
+
+require 'sinatra/base'
+class MyApp < Sinatra::Base
+  register Mustermann
+  set :pattern, type: :my_pattern
+
+  get '/hello/~{name}' do
+    "Hello #{params[:name].capitalize}!"
+  end
+end
+
+require 'mustermann/ast/tree_renderer'
+ast = MyPattern::Parser.parse(pattern.to_s)
+puts Mustermann::AST::TreeRenderer.render(ast)
+
+```
+
+## Pattern Registration
+
+...
+
+## Build Your Own Pattern
+
+...
+
+## Patterns Based on Regular Expressions
+
+...
+
+## AST-Based Patterns
+
+...

data/lib/mustermann.rb

@@ -0,0 +1,61 @@
+require 'mustermann/pattern'
+
+# Namespace and main entry point for the Mustermann library.
+#
+# Under normal circumstances the only external API entry point you should be using is {Mustermann.new}.
+module Mustermann
+  # @param [String, Pattern, Regexp, #to_pattern] input The representation of the new pattern
+  # @param [Hash] options The options hash
+  # @return [Mustermann::Pattern] pattern corresponding to string.
+  # @raise (see [])
+  # @raise (see Mustermann::Pattern.new)
+  # @see file:README.md#Types_and_Options "Types and Options" in the README
+  def self.new(input, options = {})
+    type = options.delete(:type) || :sinatra
+    case input
+    when Pattern then input
+    when Regexp  then self[:regexp].new(input, options)
+    when String  then self[type].new(input, options)
+    else input.to_pattern(options.merge(type: type))
+    end
+  end
+
+  # Maps a type to its factory.
+  #
+  # @example
+  #   Mustermann[:sinatra] # => Mustermann::Sinatra
+  #
+  # @param [Symbol] key a pattern type identifier
+  # @raise [ArgumentError] if the type is not supported
+  # @return [Class, #new] pattern factory
+  def self.[](key)
+    constant, library = register.fetch(key) { raise ArgumentError, "unsupported type %p" % key }
+    require library if library
+    constant.respond_to?(:new) ? constant : register[key] = const_get(constant)
+  end
+
+  # @!visibility private
+  def self.register(*identifiers)
+    options  = identifiers.last.is_a?(Hash) ? identifiers.pop : {}
+    constant = options[:constant] || identifiers.first.to_s.capitalize
+    load     = options[:load] || "mustermann/#{identifiers.first}"
+    @register ||= {}
+    identifiers.each { |i| @register[i] = [constant, load] }
+    @register
+  end
+
+  # @!visibility private
+  def self.extend_object(object)
+    return super unless defined? ::Sinatra::Base and object.is_a? Class and object < ::Sinatra::Base
+    require 'mustermann/extension'
+    object.register Extension
+  end
+
+  register :identity
+  register :rails
+  register :regular, :regexp
+  register :shell
+  register :simple
+  register :sinatra
+  register :template
+end

data/lib/mustermann/ast/compiler.rb

@@ -0,0 +1,168 @@
+require 'mustermann/ast/translator'
+
+module Mustermann
+  # @see Mustermann::AST::Pattern
+  module AST
+    # Regexp compilation logic.
+    # @!visibility private
+    class Compiler < Translator
+      raises CompileError
+
+      # Trivial compilations
+      translate(Array)      { |o = {}| map { |e| t(e, o) }.join  }
+      translate(:node)      { |o = {}| t(payload, o)             }
+      translate(:separator) { |o = {}| Regexp.escape(payload)    }
+      translate(:optional)  { |o = {}| "(?:%s)?" % t(payload, o) }
+      translate(:char)      { |o = {}| t.encoded(payload, o)     }
+
+      translate :expression do |options = {}|
+        greedy = options.fetch(:greedy, true)
+        t(payload, options.merge(allow_reserved: operator.allow_reserved, greedy: greedy && !operator.allow_reserved,
+          parametric: operator.parametric, separator: operator.separator))
+      end
+
+      translate :with_look_ahead do |options = {}|
+        lookahead = each_leaf.inject("") do |ahead, element|
+          ahead + t(element, options.merge(skip_optional: true, lookahead: ahead, greedy: false, no_captures: true)).to_s
+        end
+        lookahead << (at_end ? '$' : '/')
+        t(head, options.merge(lookahead: lookahead)) + t(payload, options)
+      end
+
+      # Capture compilation is complex. :(
+      # @!visibility private
+      class Capture < NodeTranslator
+        register :capture
+
+        # @!visibility private
+        def translate(options = {})
+          return pattern(options) if options[:no_captures]
+          "(?<#{name}>#{translate(options.merge(no_captures: true))})"
+        end
+
+        # @return [String] regexp without the named capture
+        # @!visibility private
+        def pattern(options = {})
+          capture = options.delete(:capture)
+          case capture
+          when Symbol then from_symbol(capture, options)
+          when Array  then from_array(capture, options)
+          when Hash   then from_hash(capture, options)
+          when String then from_string(capture, options)
+          when nil    then from_nil(options)
+          else capture
+          end
+        end
+
+        private
+          def qualified(string, options = {})
+             greedy = options.fetch(:greedy, true)
+            "#{string}+#{?? unless greedy}"
+          end
+
+          def with_lookahead(string, options = {})
+            lookahead = options.delete(:lookahead)
+            lookahead ? "(?:(?!#{lookahead})#{string})" : string
+          end
+          def from_hash(hash,     options = {})                     pattern(options.merge(capture: hash[name.to_sym]))                      end
+          def from_array(array,   options = {})                     Regexp.union(*array.map { |e| pattern(options.merge(capture: e)) })     end
+          def from_symbol(symbol, options = {})                     qualified(with_lookahead("[[:#{symbol}:]]", options), options)  end
+          def from_string(string, options = {})                     Regexp.new(string.chars.map { |c| t.encoded(c, options) }.join)   end
+          def from_nil(options = {})                                qualified(with_lookahead(default(options), options), options) end
+          def default(options = {}) "[^/\\?#]" end
+      end
+
+      # @!visibility private
+      class Splat < Capture
+        register :splat, :named_splat
+        # splats are always non-greedy
+        # @!visibility private
+        def pattern(options = {})
+          ".*?"
+        end
+      end
+
+      # @!visibility private
+      class Variable < Capture
+        register :variable
+
+        # @!visibility private
+        def translate(options = {})
+          return super(options) if explode or not options[:parametric]
+          parametric super(options.merge(parametric: false))
+        end
+
+        # @!visibility private
+        def pattern(options = {})
+          parametric = options.delete(:parametric) || false
+          separator  = options.delete(:separator)
+          register_param(options.merge(parametric: parametric, separator: separator))
+          pattern = super(options)
+          pattern = parametric(pattern) if parametric
+          pattern = "#{pattern}(?:#{Regexp.escape(separator)}#{pattern})*" if explode and separator
+          pattern
+        end
+
+        # @!visibility private
+        def parametric(string)
+          "#{Regexp.escape(name)}(?:=#{string})?"
+        end
+
+        # @!visibility private
+        def qualified(string, options = {})
+          prefix ? "#{string}{1,#{prefix}}" : super(string, options)
+        end
+
+        # @!visibility private
+        def default(options = {})
+          allow_reserved = options.delete(:allow_reserved) || false
+          allow_reserved ? '[\w\-\.~%\:/\?#\[\]@\!\$\&\'\(\)\*\+,;=]' : '[\w\-\.~%]'
+        end
+
+        # @!visibility private
+        def register_param(options = {})
+          parametric   = options.has_key?(:parametric) ? options.delete(:parametric) : false
+          split_params = options.delete(:split_params)
+          separator    = options.delete(:separator)
+          return unless explode and split_params
+          split_params[name] = { separator: separator, parametric: parametric }
+        end
+      end
+
+      # @return [String] Regular expression for matching the given character in all representations
+      # @!visibility private
+      def encoded(char, options ={})
+        uri_decode         = options.fetch(:uri_decode, true)
+        space_matches_plus = options.fetch(:space_matches_plus, true)
+        return Regexp.escape(char) unless uri_decode
+        encoded = escape(char, escape: /./)
+        list    = [escape(char), encoded.downcase, encoded.upcase].uniq.map { |c| Regexp.escape(c) }
+        list << encoded('+') if space_matches_plus and char == " "
+        "(?:%s)" % list.join("|")
+      end
+
+      # Compiles an AST to a regular expression.
+      # @param [Mustermann::AST::Node] ast the tree
+      # @return [Regexp] corresponding regular expression.
+      #
+      # @!visibility private
+      def self.compile(ast, options = {})
+        new.compile(ast, options)
+      end
+
+      # Compiles an AST to a regular expression.
+      # @param [Mustermann::AST::Node] ast the tree
+      # @return [Regexp] corresponding regular expression.
+      #
+      # @!visibility private
+      def compile(ast, options = {})
+        except = options.delete(:except)
+        except   &&= "(?!#{translate(except, options.merge(no_captures: true))}\\Z)"
+        expression = "\\A#{except}#{translate(ast, options)}\\Z"
+        Regexp.new(expression)
+      end
+    end
+
+    #private_constant :Compiler
+  end
+end

data/lib/mustermann/ast/expander.rb

@@ -0,0 +1,134 @@
+require 'mustermann/ast/translator'
+require 'mustermann/ast/compiler'
+
+module Mustermann
+  module AST
+    # Looks at an AST, remembers the important bits of information to do an
+    # ultra fast expansion.
+    #
+    # @!visibility private
+    class Expander < Translator
+      raises ExpandError
+
+      translate Array do
+        inject(t.pattern) do |pattern, element|
+          t.add_to(pattern, t(element))
+        end
+      end
+
+      translate :capture do
+        t.for_capture(node)
+      end
+
+      translate :named_splat, :splat do
+        t.pattern + t.for_capture(node)
+      end
+
+      translate :root, :group, :expression do
+        t(payload)
+      end
+
+      translate :char do
+        t.pattern(t.escape(payload, also_escape: /[\/\?#\&\=%]/).gsub(?%, "%%"))
+      end
+
+      translate :separator do
+        t.pattern(payload.gsub(?%, "%%"))
+      end
+
+      translate :with_look_ahead do
+        t.add_to(t(head), t(payload))
+      end
+
+      translate :optional do
+        nested = t(payload)
+        nested += t.pattern unless nested.any? { |n| n.first.empty? }
+        nested
+      end
+
+      # helper method for captures
+      # @!visibility private
+      def for_capture(node)
+        name = node.name.to_sym
+        pattern('%s', name, name => /(?!#{pattern_for(node)})./)
+      end
+
+      # maps sorted key list to sprintf patterns and filters
+      # @!visibility private
+      def mappings
+        @mappings ||= {}
+      end
+
+      # all the known keys
+      # @!visibility private
+      def keys
+        @keys ||= []
+      end
+
+      # add a tree for expansion
+      # @!visibility private
+      def add(ast)
+        translate(ast).each do |keys, pattern, filter|
+          self.keys.concat(keys).uniq!
+          mappings[keys.uniq.sort] ||= [keys, pattern, filter]
+        end
+      end
+
+      # helper method for getting a capture's pattern.
+      # @!visibility private
+      def pattern_for(node, options = {})
+        Compiler.new.decorator_for(node).pattern(options)
+      end
+
+      # @see Mustermann::Pattern#expand
+      # @!visibility private
+      def expand(values = {})
+        keys, pattern, filters = mappings.fetch(values.keys.sort) { error_for(values) }
+        filters.each { |key, filter| values[key] &&= escape(values[key], also_escape: filter) }
+        pattern % values.values_at(*keys)
+      end
+
+      # @see Mustermann::Pattern#expandable?
+      # @!visibility private
+      def expandable?(values)
+        values = values.keys if values.respond_to? :keys
+        values = values.sort if values.respond_to? :sort
+        mappings.include? values
+      end
+
+      # @see Mustermann::Expander#with_rest
+      # @!visibility private
+      def expandable_keys(keys)
+        mappings.keys.select { |k| (k - keys).empty? }.max_by(&:size) || keys
+      end
+
+      # helper method for raising an error for unexpandable values
+      # @!visibility private
+      def error_for(values)
+        expansions = mappings.keys.map(&:inspect).join(" or ")
+        raise error_class, "cannot expand with keys %p, possible expansions: %s" % [values.keys.sort, expansions]
+      end
+
+      # @see Mustermann::AST::Translator#expand
+      # @!visibility private
+      def escape(string, *args)
+        # URI::Parser is pretty slow, let's not had every string to it, even if it's unnecessary
+        string =~ /\A\w*\Z/ ? string : super
+      end
+
+      # Turns a sprintf pattern into our secret internal data structure.
+      # @!visibility private
+      def pattern(string = "", *keys)
+        filters = keys.last.is_a?(Hash) ? keys.pop : {}
+        [[keys, string, filters]]
+      end
+
+      # Creates the product of two of our secret internal data structures.
+      # @!visibility private
+      def add_to(list, result)
+        list << [[], ""] if list.empty?
+        list.inject([]) { |l, (k1, p1, f1)| l + result.map { |k2, p2, f2| [k1+k2, p1+p2, f1.merge(f2)] } }
+      end
+    end
+  end
+end