mustermann 0.4.0 → 1.0.0.beta2

data/lib/mustermann/equality_map.rb

@@ -0,0 +1,60 @@
+module Mustermann
+  # A simple wrapper around ObjectSpace::WeakMap that allows matching keys by equality rather than identity.
+  # Used for caching. Note that `fetch` is not guaranteed to return the object, even if it has not been
+  # garbage collected yet, especially when used concurrently. Therefore, the block passed to `fetch` has to
+  # be idempotent.
+  #
+  # @example
+  #   class ExpensiveComputation
+  #     @map = Mustermann::EqualityMap.new
+  #
+  #     def self.new(*args)
+  #       @map.fetch(*args) { super }
+  #     end
+  #   end
+  #
+  # @see #fetch
+  class EqualityMap
+    attr_reader :map
+
+    def self.new
+      defined?(ObjectSpace::WeakMap) ? super : {}
+    end
+
+    def initialize
+      @keys = {}
+      @map  = ObjectSpace::WeakMap.new
+    end
+
+    # @param [Array<#hash>] key for caching
+    # @yield block that will be called to populate entry if missing (has to be idempotent)
+    # @return value stored in map or result of block
+    def fetch(*key)
+      identity = @keys[key.hash]
+      key      = identity == key ? identity : key
+
+      # it is ok that this is not thread-safe, worst case it has double cost in
+      # generating, object equality is not guaranteed anyways
+      @map[key] ||= track(key, yield)
+    end
+
+    # @param [#hash] key for identifying the object
+    # @param [Object] object to be stored
+    # @return [Object] same as the second parameter
+    def track(key, object)
+      ObjectSpace.define_finalizer(object, finalizer(key.hash))
+      @keys[key.hash] = key
+      object
+    end
+
+    # Finalizer proc needs to be generated in different scope so it doesn't keep a reference to the object.
+    #
+    # @param [Fixnum] hash for key
+    # @return [Proc] finalizer callback
+    def finalizer(hash)
+      proc { @keys.delete(hash) }
+    end
+
+    private :track, :finalizer
+  end
+end

data/lib/mustermann/expander.rb

@@ -17,7 +17,7 @@ module Mustermann
     # @param [Array<#to_str, Mustermann::Pattern>] patterns list of patterns to expand, see {#add}.
     # @param [Symbol] additional_values behavior when encountering additional values, see {#expand}.
     # @param [Hash] options used when creating/expanding patterns, see {Mustermann.new}.
-    def initialize(*patterns, additional_values: :raise, **options)
+    def initialize(*patterns, additional_values: :raise, **options, &block)
       unless additional_values == :raise or additional_values == :ignore or additional_values == :append
         raise ArgumentError, "Illegal value %p for additional_values" % additional_values
       end
@@ -26,8 +26,8 @@ module Mustermann
       @api_expander      = AST::Expander.new
       @additional_values = additional_values
       @options           = options
-      @caster            = Caster.new(Caster::Nil)
-      add(*patterns)
+      @caster            = Caster.new
+      add(*patterns, &block)
     end
 
     # Add patterns to expand.
@@ -42,8 +42,12 @@ module Mustermann
     def add(*patterns)
       patterns.each do |pattern|
         pattern = Mustermann.new(pattern, **@options)
-        raise NotImplementedError, "expanding not supported for #{pattern.class}" unless pattern.respond_to? :to_ast
-        @api_expander.add(pattern.to_ast)
+        if block_given?
+          @api_expander.add(yield(pattern))
+        else
+          raise NotImplementedError, "expanding not supported for #{pattern.class}" unless pattern.respond_to? :to_ast
+          @api_expander.add(pattern.to_ast)
+        end
         @patterns << pattern
       end
       self
@@ -196,7 +200,7 @@ module Mustermann
     def map_values(values)
       values = values.dup
       @api_expander.keys.each { |key| values[key] ||= values.delete(key.to_s) if values.include? key.to_s }
-      caster.cast(values)
+      caster.cast(values).delete_if { |k, v| v.nil? }
     end
 
     private :with_rest, :slice, :append, :caster, :map_values, :split_values

data/lib/mustermann/identity.rb

@@ -11,6 +11,7 @@ module Mustermann
   # @see Mustermann::Pattern
   # @see file:README.md#identity Syntax description in the README
   class Identity < Pattern
+    include Concat::Native
     register :identity
 
     # @param (see Mustermann::Pattern#===)

data/lib/mustermann/pattern.rb

@@ -1,6 +1,6 @@
 require 'mustermann/error'
 require 'mustermann/simple_match'
-require 'tool/equality_map'
+require 'mustermann/equality_map'
 require 'uri'
 
 module Mustermann
@@ -47,16 +47,23 @@ module Mustermann
     # @return [Mustermann::Pattern] a new instance of Mustermann::Pattern
     # @see #initialize
     def self.new(string, ignore_unknown_options: false, **options)
-      unless ignore_unknown_options
+      if ignore_unknown_options
+        options = options.select { |key, value| supported?(key, **options) if key != :ignore_unknown_options }
+      else
         unsupported = options.keys.detect { |key| not supported?(key, **options) }
         raise ArgumentError, "unsupported option %p for %p" % [unsupported, self] if unsupported
       end
 
-      @map ||= Tool::EqualityMap.new
-      @map.fetch(string, options) { super(string, options) }
+      @map ||= EqualityMap.new
+      @map.fetch(string, options) { super(string, options) { options } }
     end
 
     supported_options :uri_decode, :ignore_unknown_options
+    attr_reader :uri_decode
+
+    # options hash passed to new (with unsupported options removed)
+    # @!visibility private
+    attr_reader :options
 
     # @overload initialize(string, **options)
     # @param [String] string the string representation of the pattern
@@ -67,6 +74,7 @@ module Mustermann
     def initialize(string, uri_decode: true, **options)
       @uri_decode = uri_decode
       @string     = string.to_s.dup
+      @options    = yield.freeze if block_given?
     end
 
     # @return [String] the string representation of the pattern
@@ -98,6 +106,26 @@ module Mustermann
       raise NotImplementedError, 'subclass responsibility'
     end
 
+    # Used by Ruby internally for hashing.
+    # @return [Fixnum] same has value for patterns that are equal
+    def hash
+      self.class.hash | @string.hash | options.hash
+    end
+
+    # Two patterns are considered equal if they are of the same type, have the same pattern string
+    # and the same options.
+    # @return [true, false]
+    def ==(other)
+      other.class == self.class and other.to_s == @string and other.options == options
+    end
+
+    # Two patterns are considered equal if they are of the same type, have the same pattern string
+    # and the same options.
+    # @return [true, false]
+    def eql?(other)
+      other.class.eql?(self.class) and other.to_s.eql?(@string) and other.options.eql?(options)
+    end
+
     # Tries to match the pattern against the beginning of the string (as opposed to the full string).
     # Will return the count of the matching characters if it matches.
     #
@@ -234,7 +262,7 @@ module Mustermann
     #   pattern |= Mustermann.new('/example/*nested')
     #   pattern.to_templates # => ["/{name}", "/example/{+nested}"]
     #
-    # Template generation is supported by almost all patterns (notable execptions are
+    # Template generation is supported by almost all patterns (notable exceptions are
     # {Mustermann::Shell}, {Mustermann::Regular} and {Mustermann::Simple}).
     # Union {Mustermann::Composite} patterns (with the | operator) support template generation
     # if all patterns they are composed of also support it.
@@ -284,12 +312,30 @@ module Mustermann
     # @param [Mustermann::Pattern, String] other the other pattern
     # @return [Mustermann::Pattern] a composite pattern
     def |(other)
-      Mustermann.new(self, other, operator: __callee__, type: :identity)
+      Mustermann::Composite.new(self, other, operator: __callee__, type: :identity)
     end
 
     alias_method :&, :|
     alias_method :^, :|
 
+    # @example
+    #   require 'mustermann'
+    #   prefix = Mustermann.new("/:prefix")
+    #   about  = prefix + "/about"
+    #   about.params("/main/about") # => {"prefix" => "main"}
+    #
+    # Creates a concatenated pattern by combingin self with the other pattern supplied.
+    # Patterns of different types can be mixed. The availability of `to_templates` and
+    # `expand` depends on the patterns being concatenated.
+    #
+    # String input is treated as identity pattern.
+    #
+    # @param [Mustermann::Pattern, String] other pattern to be appended
+    # @return [Mustermann::Pattern] concatenated pattern
+    def +(other)
+       Concat.new(self, other, type: :identity)
+    end
+
     # @example
     #   pattern = Mustermann.new('/:a/:b')
     #   strings = ["foo/bar", "/foo/bar", "/foo/bar/"]
@@ -332,7 +378,7 @@ module Mustermann
     end
 
     # @!visibility private
-    def unescape(string, decode = @uri_decode)
+    def unescape(string, decode = uri_decode)
       return string unless decode and string
       @@uri.unescape(string)
     end

data/lib/mustermann/regexp_based.rb

@@ -16,7 +16,7 @@ module Mustermann
     def initialize(string, **options)
       super
       regexp       = compile(**options)
-      @peek_regexp = /\A(#{regexp})/
+      @peek_regexp = /\A#{regexp}/
       @regexp      = /\A#{regexp}\Z/
     end
 

data/lib/mustermann/regular.rb

@@ -1,5 +1,6 @@
 require 'mustermann'
 require 'mustermann/regexp_based'
+require 'strscan'
 
 module Mustermann
   # Regexp pattern implementation.
@@ -10,20 +11,34 @@ module Mustermann
   # @see Mustermann::Pattern
   # @see file:README.md#simple Syntax description in the README
   class Regular < RegexpBased
+    include Concat::Native
     register :regexp, :regular
+    supported_options :check_anchors
 
     # @param (see Mustermann::Pattern#initialize)
     # @return (see Mustermann::Pattern#initialize)
     # @see (see Mustermann::Pattern#initialize)
-    def initialize(string, **options)
+    def initialize(string, check_anchors: true, **options)
       string = $1 if string.to_s =~ /\A\(\?\-mix\:(.*)\)\Z/ && string.inspect == "/#$1/"
+      @check_anchors = check_anchors
       super(string, **options)
     end
 
     def compile(**options)
+      if @check_anchors
+        scanner = ::StringScanner.new(@string)
+        check_anchors(scanner) until scanner.eos?
+      end
+
       /#{@string}/
     end
 
-    private :compile
+    def check_anchors(scanner)
+      return scanner.scan_until(/\]/) if scanner.scan(/\[/)
+      return scanner.scan(/\\?./) unless illegal = scanner.scan(/\\[AzZ]|[\^\$]/)
+      raise CompileError, "regular expression should not contain %s: %p" % [illegal.to_s, @string]
+    end
+
+    private :compile, :check_anchors
   end
 end

data/lib/mustermann/simple_match.rb

@@ -3,8 +3,10 @@ module Mustermann
   # @see http://ruby-doc.org/core-2.0/MatchData.html MatchData
   class SimpleMatch
     # @api private
-    def initialize(string)
-      @string = string.dup
+    def initialize(string = "", names: [], captures: [])
+      @string   = string.dup
+      @names    = names
+      @captures = captures
     end
 
     # @return [String] the string that was matched against
@@ -14,17 +16,28 @@ module Mustermann
 
     # @return [Array<String>] empty array for imitating MatchData interface
     def names
-      []
+      @names.dup
     end
 
     # @return [Array<String>] empty array for imitating MatchData interface
     def captures
-      []
+      @captures.dup
     end
 
     # @return [nil] imitates MatchData interface
     def [](*args)
-      captures[*args]
+      args.map! do |arg|
+        next arg unless arg.is_a? Symbol or arg.is_a? String
+        names.index(arg.to_s)
+      end
+      @captures[*args]
+    end
+
+    # @!visibility private
+    def +(other)
+      SimpleMatch.new(@string + other.to_s,
+          names:    @names    + other.names,
+          captures: @captures + other.captures)
     end
 
     # @return [String] string representation

data/lib/mustermann/sinatra.rb

@@ -1,5 +1,9 @@
 require 'mustermann'
+require 'mustermann/identity'
 require 'mustermann/ast/pattern'
+require 'mustermann/sinatra/parser'
+require 'mustermann/sinatra/safe_renderer'
+require 'mustermann/sinatra/try_convert'
 
 module Mustermann
   # Sinatra 2.0 style pattern implementation.
@@ -10,30 +14,74 @@ module Mustermann
   # @see Mustermann::Pattern
   # @see file:README.md#sinatra Syntax description in the README
   class Sinatra < AST::Pattern
+    include Concat::Native
     register :sinatra
 
-    on(nil, ??, ?), ?|) { |c| unexpected(c) }
+    # Takes a string and espaces any characters that have special meaning for Sinatra patterns.
+    #
+    # @example
+    #   require 'mustermann/sinatra'
+    #   Mustermann::Sinatra.escape("/:name") # => "/\\:name"
+    #
+    # @param [#to_s] string the input string
+    # @return [String] the escaped string
+    def self.escape(string)
+      string.to_s.gsub(/[\?\(\)\*:\\\|\{\}]/) { |c| "\\#{c}" }
+    end
 
-    on(?*)  { |c| scan(/\w+/) ? node(:named_splat, buffer.matched) : node(:splat) }
-    on(?:)  { |c| node(:capture) { scan(/\w+/) } }
-    on(?\\) { |c| node(:char, expect(/./)) }
+    # Tries to convert the given input object to a Sinatra pattern with the given options, without
+    # changing its parsing semantics.
+    # @return [Mustermann::Sinatra, nil] the converted pattern, if possible
+    # @!visibility private
+    def self.try_convert(input, **options)
+      TryConvert.convert(input, **options)
+    end
 
-    on ?( do |char|
-      groups = []
-      groups << node(:group) { read unless check(?)) or scan(?|) } until scan(?))
-      groups.size == 1 ? groups.first : node(:union, groups)
+    # Creates a pattern that matches any string matching either one of the patterns.
+    # If a string is supplied, it is treated as a fully escaped Sinatra pattern.
+    #
+    # If the other pattern is also a Sintara pattern, it might join the two to a third
+    # sinatra pattern instead of generating a composite for efficency reasons.
+    #
+    # This only happens if the sinatra pattern behaves exactly the same as a composite
+    # would in regards to matching, parsing, expanding and template generation.
+    #
+    # @example
+    #   pattern = Mustermann.new('/foo/:name') | Mustermann.new('/:first/:second')
+    #   pattern === '/foo/bar' # => true
+    #   pattern === '/fox/bar' # => true
+    #   pattern === '/foo'     # => false
+    #
+    # @param [Mustermann::Pattern, String] other the other pattern
+    # @return [Mustermann::Pattern] a composite pattern
+    # @see Mustermann::Pattern#|
+    def |(other)
+      return super unless converted = self.class.try_convert(other, **options)
+      return super unless converted.names.empty? or names.empty?
+      self.class.new(safe_string + "|" + converted.safe_string, **options)
     end
 
-    on ?{ do |char|
-      type = scan(?+) ? :named_splat : :capture
-      name = expect(/[\w\.]+/)
-      type = :splat if type == :named_splat and name == 'splat'
-      expect(?})
-      node(type, name)
+    # Generates a string represenation of the pattern that can safely be used for def interpolation
+    # without changing its semantics.
+    #
+    # @example
+    #   require 'mustermann'
+    #   unsafe = Mustermann.new("/:name")
+    #
+    #   Mustermann.new("#{unsafe}bar").params("/foobar") # => { "namebar" => "foobar" }
+    #   Mustermann.new("#{unsafe.safe_string}bar").params("/foobar") # => { "name" => "bar" }
+    #
+    # @return [String] string representatin of the pattern
+    def safe_string
+      @safe_string ||= SafeRenderer.translate(to_ast)
     end
 
-    suffix ?? do |char, element|
-      node(:optional, element)
+    # @!visibility private
+    def native_concat(other)
+      return unless converted = self.class.try_convert(other, **options)
+      safe_string + converted.safe_string
     end
+
+    private :native_concat
   end
 end

data/lib/mustermann/sinatra/parser.rb

@@ -0,0 +1,45 @@
+module Mustermann
+  class Sinatra < AST::Pattern
+    # Sinatra syntax definition.
+    # @!visibility private
+    class Parser < AST::Parser
+      on(nil, ??, ?)) { |c| unexpected(c) }
+
+      on(?*)  { |c| scan(/\w+/) ? node(:named_splat, buffer.matched) : node(:splat) }
+      on(?:)  { |c| node(:capture) { scan(/\w+/) } }
+      on(?\\) { |c| node(:char, expect(/./)) }
+      on(?()  { |c| node(:group) { read unless scan(?)) } }
+      on(?|)  { |c| node(:or) }
+
+      on ?{ do |char|
+        current_pos = buffer.pos
+        type = scan(?+) ? :named_splat : :capture
+        name = expect(/[\w\.]+/)
+        if type == :capture && scan(?|)
+          buffer.pos = current_pos
+          capture = proc do
+            start = pos
+            match = expect(/(?<capture>[^\|}]+)/)
+            node(:capture, match[:capture], start: start)
+          end
+          grouped_captures = node(:group, [capture[]]) do
+            if scan(?|)
+              [min_size(pos - 1, pos, node(:or)), capture[]]
+            end
+          end
+          grouped_captures if expect(?})
+        else
+          type = :splat if type == :named_splat and name == 'splat'
+          expect(?})
+          node(type, name)
+        end
+      end
+
+      suffix ?? do |char, element|
+        node(:optional, element)
+      end
+    end
+
+    private_constant :Parser
+  end
+end