mustermann 0.3.1 → 0.4.0

data/lib/mustermann.rb

@@ -1,43 +1,117 @@
 require 'mustermann/pattern'
+require 'mustermann/composite'
+require 'thread'
 
 # 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
+  # Type to use if no type is given.
+  # @api private
+  DEFAULT_TYPE = :sinatra
+
+  # Creates a new pattern based on input.
+  #
+  # * From {Mustermann::Pattern}: returns given pattern.
+  # * From String: creates a pattern from the string, depending on type option (defaults to {Mustermann::Sinatra})
+  # * From Regexp: creates a {Mustermann::Regular} pattern.
+  # * From Symbol: creates a {Mustermann::Sinatra} pattern with a single named capture named after the input.
+  # * From an Array or multiple inputs: creates a new pattern from each element, combines them to a {Mustermann::Composite}.
+  # * From anything else: Will try to call to_pattern on it or raise a TypeError.
+  #
+  # Note that if the input is a {Mustermann::Pattern}, Regexp or Symbol, the type option is ignored and if to_pattern is
+  # called on the object, the type will be handed on but might be ignored by the input object.
+  #
+  # If you want to enforce the pattern type, you should create them via their expected class.
+  #
+  # @example creating patterns
+  #   require 'mustermann'
+  #
+  #   Mustermann.new("/:name")                    # => #<Mustermann::Sinatra:"/example">
+  #   Mustermann.new("/{name}", type: :template)  # => #<Mustermann::Template:"/{name}">
+  #   Mustermann.new(/.*/)                        # => #<Mustermann::Regular:".*">
+  #   Mustermann.new(:name, capture: :word)       # => #<Mustermann::Sinatra:":name">
+  #   Mustermann.new("/", "/*.jpg", type: :shell) # => #<Mustermann::Composite:(shell:"/" | shell:"/*.jpg")>
+  #
+  # @example using custom #to_pattern
+  #   require 'mustermann'
+  #
+  #   class MyObject
+  #     def to_pattern(**options)
+  #       Mustermann.new("/:name", **options)
+  #     end
+  #   end
+  #
+  #   Mustermann.new(MyObject.new, type: :rails) # => #<Mustermann::Rails:"/:name">
+  #
+  # @example enforcing type
+  #   require 'mustermann/sinatra'
+  #
+  #   Mustermann::Sinatra.new("/:name")
+  #
+  # @param [String, Pattern, Regexp, Symbol, #to_pattern, Array<String, Pattern, Regexp, Symbol, #to_pattern>]
+  #   input The representation of the pattern
   # @param [Hash] options The options hash
   # @return [Mustermann::Pattern] pattern corresponding to string.
   # @raise (see [])
   # @raise (see Mustermann::Pattern.new)
+  # @raise [TypeError] if the passed object cannot be converted to a pattern
   # @see file:README.md#Types_and_Options "Types and Options" in the README
-  def self.new(input, type: :sinatra, **options)
+  def self.new(*input, type: DEFAULT_TYPE, **options)
+    type ||= DEFAULT_TYPE
+    input  = input.first if input.size < 2
     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(type: type, **options)
+    when Symbol  then self[:sinatra].new(input.inspect, **options)
+    when Array   then Composite.new(input, type: type, **options)
+    else
+      pattern = input.to_pattern(type: type, **options) if input.respond_to? :to_pattern
+      raise TypeError, "#{input.class} can't be coerced into Mustermann::Pattern" if pattern.nil?
+      pattern
     end
   end
 
+  @mutex ||= Mutex.new
+  @types ||= {}
+
   # Maps a type to its factory.
   #
   # @example
   #   Mustermann[:sinatra] # => Mustermann::Sinatra
   #
-  # @param [Symbol] key a pattern type identifier
+  # @param [Symbol] name 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)
+  def self.[](name)
+    return name if name.respond_to? :new
+    @types.fetch(normalized = normalized_type(name)) do
+      @mutex.synchronize do
+        error = try_require "mustermann/#{normalized}"
+        @types.fetch(normalized) { raise ArgumentError, "unsupported type %p#{" (#{error.message})" if error}" % name }
+      end
+    end
+  end
+
+  # @return [LoadError, nil]
+  # @!visibility private
+  def self.try_require(path)
+    require(path)
+    nil
+  rescue LoadError => error
+    raise(error) unless error.path == path
+    error
+  end
+
+  # @!visibility private
+  def self.register(name, type)
+    @types[normalized_type(name)] = type
   end
 
   # @!visibility private
-  def self.register(*identifiers, constant: identifiers.first.to_s.capitalize, load: "mustermann/#{identifiers.first}")
-    @register ||= {}
-    identifiers.each { |i| @register[i] = [constant, load] }
-    @register
+  def self.normalized_type(type)
+    type.to_s.gsub('-', '_').downcase
   end
 
   # @!visibility private
@@ -46,12 +120,13 @@ module Mustermann
     require 'mustermann/extension'
     object.register Extension
   end
+end
 
-  register :identity
-  register :rails
-  register :regular, :regexp
-  register :shell
-  register :simple
-  register :sinatra
-  register :template
-end
+# :nocov:
+begin
+  require 'mustermann/visualizer' if defined?(Pry) or defined?(IRB)
+rescue LoadError => error
+  raise error unless error.path == 'mustermann/visualizer'
+  $stderr.puts(error.message) if caller_locations[1].absolute_path =~ %r{/lib/pry/|/irb/|^\((?:irb|pry)\)$}
+end
+# :nocov:

data/lib/mustermann/ast/boundaries.rb

@@ -0,0 +1,44 @@
+require 'mustermann/ast/translator'
+
+module Mustermann
+  module AST
+    # Make sure #start and #stop is set on every node and within its parents #start and #stop.
+    # @!visibility private
+    class Boundaries < Translator
+      # @return [Mustermann::AST::Node] the ast passed as first argument
+      # @!visibility private
+      def self.set_boundaries(ast, string: nil, start: 0, stop: string.length)
+        new.translate(ast, start, stop)
+        ast
+      end
+
+      translate(:node) do |start, stop|
+        t.set_boundaries(node, start, stop)
+        t(payload, node.start, node.stop)
+      end
+
+      translate(:with_look_ahead) do |start, stop|
+        t.set_boundaries(node, start, stop)
+        t(head,    node.start, node.stop)
+        t(payload, node.start, node.stop)
+      end
+
+      translate(Array) do |start, stop|
+        each do |subnode|
+          t(subnode, start, stop)
+          start = subnode.stop
+        end
+      end
+
+      translate(Object) { |*| node }
+
+      # Checks that a node is within the given boundaries.
+      # @!visibility private
+      def set_boundaries(node, start, stop)
+        node.start = start                      if node.start.nil? or node.start < start
+        node.stop  = node.start + node.min_size if node.stop.nil?  or node.stop  < node.start
+        node.stop  = stop                       if node.stop > stop
+      end
+    end
+  end
+end

data/lib/mustermann/ast/compiler.rb

@@ -15,6 +15,10 @@ module Mustermann
       translate(:optional)  { |**o| "(?:%s)?" % t(payload, **o) }
       translate(:char)      { |**o| t.encoded(payload, **o)     }
 
+      translate :union do |**options|
+        "(?:%s)" % payload.map { |e| "(?:%s)" % t(e, **options) }.join(?|)
+      end
+
       translate :expression do |greedy: true, **options|
         t(payload, allow_reserved: operator.allow_reserved, greedy: greedy && !operator.allow_reserved,
           parametric: operator.parametric, separator: operator.separator, **options)
@@ -53,14 +57,14 @@ module Mustermann
         end
 
         private
-          def qualified(string, greedy: true, **options)         "#{string}+#{?? unless greedy}"                                     end
+          def qualified(string, greedy: true, **options)        "#{string}#{qualifier || "+#{?? unless greedy}"}"                    end
           def with_lookahead(string, lookahead: nil, **options)  lookahead ? "(?:(?!#{lookahead})#{string})" : string                end
           def from_hash(hash,     **options)                     pattern(capture: hash[name.to_sym], **options)                      end
           def from_array(array,   **options)                     Regexp.union(*array.map { |e| pattern(capture: e, **options) })     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
+          def default(**options)                                 constraint || "[^/\\?#]"                                            end
       end
 
       # @!visibility private
@@ -69,7 +73,7 @@ module Mustermann
         # splats are always non-greedy
         # @!visibility private
         def pattern(**options)
-          ".*?"
+          constraint || ".*?"
         end
       end
 
@@ -120,7 +124,10 @@ module Mustermann
         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 == " "
+        if char == " "
+          list << encoded('+') if space_matches_plus
+          list << " "
+        end
         "(?:%s)" % list.join("|")
       end
 
@@ -139,9 +146,8 @@ module Mustermann
       #
       # @!visibility private
       def compile(ast, except: nil, **options)
-        except   &&= "(?!#{translate(except, no_captures: true, **options)}\\Z)"
-        expression = "\\A#{except}#{translate(ast, **options)}\\Z"
-        Regexp.new(expression)
+        except &&= "(?!#{translate(except, no_captures: true, **options)}\\Z)"
+        Regexp.new("#{except}#{translate(ast, **options)}")
       end
     end
 

data/lib/mustermann/ast/expander.rb

@@ -10,21 +10,25 @@ module Mustermann
     class Expander < Translator
       raises ExpandError
 
-      translate Array do
+      translate Array do |*args|
         inject(t.pattern) do |pattern, element|
-          t.add_to(pattern, t(element))
+          t.add_to(pattern, t(element, *args))
         end
       end
 
-      translate :capture do
-        t.for_capture(node)
+      translate :capture do |**options|
+        t.for_capture(node, **options)
       end
 
       translate :named_splat, :splat do
         t.pattern + t.for_capture(node)
       end
 
-      translate :root, :group, :expression do
+      translate :expression do
+        t(payload, allow_reserved: operator.allow_reserved)
+      end
+
+      translate :root, :group do
         t(payload)
       end
 
@@ -46,11 +50,15 @@ module Mustermann
         nested
       end
 
+      translate :union do
+        payload.map { |e| t(e) }.inject(:+)
+      end
+
       # helper method for captures
       # @!visibility private
-      def for_capture(node)
+      def for_capture(node, **options)
         name = node.name.to_sym
-        pattern('%s', name, name => /(?!#{pattern_for(node)})./)
+        pattern('%s', name, name => /(?!#{pattern_for(node, **options)})./)
       end
 
       # maps sorted key list to sprintf patterns and filters
@@ -70,7 +78,7 @@ module Mustermann
       def add(ast)
         translate(ast).each do |keys, pattern, filter|
           self.keys.concat(keys).uniq!
-          mappings[keys.uniq.sort] ||= [keys, pattern, filter]
+          mappings[keys.sort] ||= [keys, pattern, filter]
         end
       end
 
@@ -82,10 +90,12 @@ module Mustermann
 
       # @see Mustermann::Pattern#expand
       # @!visibility private
-      def expand(**values)
-        keys, pattern, filters = mappings.fetch(values.keys.sort) { error_for(values) }
+      def expand(values)
+        values = values.each_with_object({}){ |(key, value), new_hash|
+          new_hash[value.instance_of?(Array) ? [key] * value.length : key] = value }
+        keys, pattern, filters = mappings.fetch(values.keys.flatten.sort) { error_for(values) }
         filters.each { |key, filter| values[key] &&= escape(values[key], also_escape: filter) }
-        pattern % values.values_at(*keys)
+        pattern % (values[keys] || values.values_at(*keys))
       end
 
       # @see Mustermann::Pattern#expandable?
@@ -112,7 +122,7 @@ module Mustermann
       # @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
+        # URI::Parser is pretty slow, let's not send every string to it, even if it's unnecessary
         string =~ /\A\w*\Z/ ? string : super
       end
 

data/lib/mustermann/ast/node.rb

@@ -4,14 +4,23 @@ module Mustermann
     # @!visibility private
     class Node
       # @!visibility private
-      attr_accessor :payload
+      attr_accessor :payload, :start, :stop
 
       # @!visibility private
       # @param [Symbol] name of the node
       # @return [Class] factory for the node
       def self.[](name)
-        @names ||= {}
-        @names.fetch(name) { Object.const_get(constant_name(name)) }
+        @names       ||= {}
+        @names[name] ||= begin
+          const_name = constant_name(name)
+          Object.const_get(const_name) if Object.const_defined?(const_name)
+        end
+      end
+
+      # Turns a class name into a node identifier.
+      # @!visibility private
+      def self.type
+        name[/[^:]+$/].split(/(?<=.)(?=[A-Z])/).map(&:downcase).join(?_).to_sym
       end
 
       # @!visibility private
@@ -36,6 +45,12 @@ module Mustermann
         self.payload = payload
       end
 
+      # @!visibility private
+      def is_a?(type)
+        type = Node[type] if type.is_a? Symbol
+        super(type)
+      end
+
       # Double dispatch helper for reading from the buffer into the payload.
       # @!visibility private
       def parse
@@ -58,8 +73,38 @@ module Mustermann
         yield(self) unless called
       end
 
+      # @return [Integer] length of the substring
+      # @!visibility private
+      def length
+        stop - start if start and stop
+      end
+
+      # @return [Integer] minimum size for a node
+      # @!visibility private
+      def min_size
+        0
+      end
+
+      # Turns a class name into a node identifier.
+      # @!visibility private
+      def type
+        self.class.type
+      end
+
       # @!visibility private
       class Capture < Node
+        # @see Mustermann::AST::Compiler::Capture#default
+        # @!visibility private
+        attr_accessor :constraint
+
+        # @see Mustermann::AST::Compiler::Capture#qualified
+        # @!visibility private
+        attr_accessor :qualifier
+
+        # @see Mustermann::AST::Pattern#map_param
+        # @!visibility private
+        attr_accessor :convert
+
         # @see Mustermann::AST::Node#parse
         # @!visibility private
         def parse
@@ -73,6 +118,11 @@ module Mustermann
 
       # @!visibility private
       class Char < Node
+        # @return [Integer] minimum size for a node
+        # @!visibility private
+        def min_size
+          1
+        end
       end
 
       # AST node for template expressions.
@@ -83,13 +133,21 @@ module Mustermann
       end
 
       # @!visibility private
-      class Group < Node
+      class Composition < Node
         # @!visibility private
         def initialize(payload = nil, **options)
           super(Array(payload), **options)
         end
       end
 
+      # @!visibility private
+      class Group < Composition
+      end
+
+      # @!visibility private
+      class Union < Composition
+      end
+
       # @!visibility private
       class Optional < Node
       end
@@ -113,6 +171,11 @@ module Mustermann
 
       # @!visibility private
       class Separator < Node
+        # @return [Integer] minimum size for a node
+        # @!visibility private
+        def min_size
+          1
+        end
       end
 
       # @!visibility private
@@ -144,7 +207,8 @@ module Mustermann
         attr_accessor :head, :at_end
 
         # @!visibility private
-        def initialize(payload, at_end)
+        def initialize(payload, at_end, **options)
+          super(**options)
           self.head, *self.payload = Array(payload)
           self.at_end = at_end
         end