mustermann 0.0.1 → 0.1.0

data/lib/mustermann/ast/transformer.rb

@@ -0,0 +1,121 @@
+require 'mustermann/ast/translator'
+
+module Mustermann
+  module AST
+    # Takes a tree, turns it into an even better tree.
+    # @!visibility private
+    class Transformer < Translator
+      # @!visibility private
+      Operator  ||= Struct.new(:separator, :allow_reserved, :prefix, :parametric)
+
+      # Operators available for expressions.
+      # @!visibility private
+      OPERATORS ||= {
+        nil => Operator.new(?,, false, false, false), ?+  => Operator.new(?,, true,  false, false),
+        ?#  => Operator.new(?,, true,  ?#,    false), ?.  => Operator.new(?., false, ?.,    false),
+        ?/  => Operator.new(?/, false, ?/,    false), ?;  => Operator.new(?;, false, ?;,    true),
+        ??  => Operator.new(?&, false, ??,    true),  ?&  => Operator.new(?&, false, ?&,    true)
+      }
+
+      # Transforms a tree.
+      # @note might mutate handed in tree instead of creating a new one
+      # @param [Mustermann::AST::Node] tree to be transformed
+      # @return [Mustermann::AST::Node] transformed tree
+      # @!visibility private
+      def self.transform(ast)
+        new.translate(ast)
+      end
+
+      translate(:node) { self }
+
+      translate(:expression) do
+        self.operator = OPERATORS.fetch(operator) { raise CompileError, "#{operator} operator not supported" }
+        separator     = Node[:separator].new(operator.separator)
+        prefix        = Node[:separator].new(operator.prefix)
+        self.payload  = Array(payload.inject { |list, element| Array(list) << t(separator) << t(element) })
+        payload.unshift(prefix) if operator.prefix
+        self
+      end
+
+      translate(:group, :root) do
+        self.payload = t(payload)
+        self
+      end
+
+      # Inserts with_look_ahead nodes wherever appropriate
+      # @!visibility private
+      class ArrayTransform < NodeTranslator
+        register Array
+
+        # the new array
+        # @!visibility private
+        def payload
+          @payload ||= []
+        end
+
+        # buffer for potential look ahead
+        # @!visibility private
+        def lookahead_buffer
+          @lookahead_buffer ||= []
+        end
+
+        # transform the array
+        # @!visibility private
+        def translate
+          each { |e| track t(e) }
+          payload.concat create_lookahead(lookahead_buffer, true)
+        end
+
+        # handle a single element from the array
+        # @!visibility private
+        def track(element)
+          return list_for(element) << element if lookahead_buffer.empty?
+          return lookahead_buffer  << element if lookahead? element
+
+          lookahead = lookahead_buffer.dup
+          lookahead = create_lookahead(lookahead, false) if element.is_a? Node[:separator]
+          lookahead_buffer.clear
+
+          payload.concat(lookahead) << element
+        end
+
+        # turn look ahead buffer into look ahead node
+        # @!visibility private
+        def create_lookahead(elements, *args)
+          return elements unless elements.size > 1
+          [Node[:with_look_ahead].new(elements, *args)]
+        end
+
+        # can the given element be used in a look-ahead?
+        # @!visibility private
+        def lookahead?(element, in_lookahead = false)
+          case element
+          when Node[:char]     then in_lookahead
+          when Node[:group]    then lookahead_payload?(element.payload, in_lookahead)
+          when Node[:optional] then lookahead?(element.payload, true) or expect_lookahead?(element.payload)
+          end
+        end
+
+        # does the list of elements look look-ahead-ish to you?
+        # @!visibility private
+        def lookahead_payload?(payload, in_lookahead)
+          return unless payload[0..-2].all? { |e| lookahead?(e, in_lookahead) }
+          expect_lookahead?(payload.last) or lookahead?(payload.last, in_lookahead)
+        end
+
+        # can the current element deal with a look-ahead?
+        # @!visibility private
+        def expect_lookahead?(element)
+          return element.class == Node[:capture] unless element.is_a? Node[:group]
+          element.payload.all? { |e| expect_lookahead?(e) }
+        end
+
+        # helper method for deciding where to put an element for now
+        # @!visibility private
+        def list_for(element)
+          expect_lookahead?(element) ? lookahead_buffer : payload
+        end
+      end
+    end
+  end
+end

data/lib/mustermann/ast/translator.rb

@@ -0,0 +1,111 @@
+require 'mustermann/ast/node'
+require 'mustermann/error'
+require 'delegate'
+
+module Mustermann
+  module AST
+    # Implements translator pattern
+    #
+    # @abstract
+    # @!visibility private
+    class Translator
+      # Encapsulates a single node translation
+      # @!visibility private
+      class NodeTranslator < DelegateClass(Node)
+        # @param [Array<Symbol, Class>] list of types to register for.
+        # @!visibility private
+        def self.register(*types)
+          types.each do |type|
+            type = Node.constant_name(type) if type.is_a? Symbol
+            translator.dispatch_table[type.to_s] = self
+          end
+        end
+
+        # @param node [Mustermann::AST::Node, Object]
+        # @param translator [Mustermann::AST::Translator]
+        #
+        # @!visibility private
+        def initialize(node, translator)
+          @translator = translator
+          super(node)
+        end
+
+        # @!visibility private
+        attr_reader :translator
+
+        # shorthand for translating a nested object
+        # @!visibility private
+        def t(*args, &block)
+          return translator unless args.any?
+          translator.translate(*args, &block)
+        end
+
+        # @!visibility private
+        alias_method :node, :__getobj__
+      end
+
+      # maps types to translations
+      # @!visibility private
+      def self.dispatch_table
+        @dispatch_table ||= {}
+      end
+
+      # some magic sauce so {NodeTranslator}s know whom to talk to for {#register}
+      # @!visibility private
+      def self.inherited(subclass)
+        node_translator = Class.new(NodeTranslator)
+        node_translator.define_singleton_method(:translator) { subclass }
+        subclass.const_set(:NodeTranslator, node_translator)
+        super
+      end
+
+      # DSL-ish method for specifying the exception class to use.
+      # @!visibility private
+      def self.raises(error)
+        define_method(:error_class) { error }
+      end
+
+      # DSL method for defining single method translations.
+      # @!visibility private
+      def self.translate(*types, &block)
+        Class.new(const_get(:NodeTranslator)) do
+          register(*types)
+          define_method(:translate, &block)
+        end
+      end
+
+      raises Mustermann::Error
+
+      # @param [Mustermann::AST::Node, Object] object to translate
+      # @return decorator encapsulating translation
+      #
+      # @!visibility private
+      def decorator_for(node)
+        factory = node.class.ancestors.inject(nil) { |d,a| d || self.class.dispatch_table[a.name] }
+        raise error_class, "#{self.class}: Cannot translate #{node.class}" unless factory
+        factory.new(node, self)
+      end
+
+      # Start the translation dance for a (sub)tree.
+      # @!visibility private
+      def translate(node, *args, &block)
+        result = decorator_for(node).translate(*args, &block)
+        result = result.node while result.is_a? NodeTranslator
+        result
+      end
+
+      # Reusing URI::Parser instance gives > 50% performance boost for some operations, like expanding.
+      # @!visibility private
+      def uri_parser
+        @uri_parser ||= URI::Parser.new
+      end
+
+      # @return [String] escaped character
+      # @!visibility private
+      def escape(char, parser: uri_parser, escape: parser.regexp[:UNSAFE], also_escape: nil)
+        escape = Regexp.union(also_escape, escape) if also_escape
+        char =~ escape ? parser.escape(char, Regexp.union(*escape)) : char
+      end
+    end
+  end
+end

data/lib/mustermann/ast/tree_renderer.rb

@@ -0,0 +1,29 @@
+require 'mustermann/ast/translator'
+
+module Mustermann
+  module AST
+    # Turns an AST into a human readable string.
+    # @!visibility private
+    class TreeRenderer < Translator
+      # @example
+      #   Mustermann::AST::TreeRenderer.render Mustermann::Sinatra::Parser.parse('/foo')
+      #
+      # @!visibility private
+      def self.render(ast)
+        new.translate(ast)
+      end
+
+      translate(Object) { inspect }
+      translate(Array) { map { |e| "\n" << t(e) }.join.gsub("\n", "\n  ") }
+      translate(:node) { "#{t.type(node)} #{t(payload)}" }
+      translate(:with_look_ahead) { "#{t.type(node)} #{t(head)} #{t(payload)}" }
+
+      # Turns a class name into a node identifier.
+      #
+      # @!visibility private
+      def type(node)
+        node.class.name[/[^:]+$/].split(/(?<=.)(?=[A-Z])/).map(&:downcase).join(?_)
+      end
+    end
+  end
+end

data/lib/mustermann/ast/validation.rb

@@ -0,0 +1,40 @@
+require 'mustermann/ast/translator'
+
+module Mustermann
+  module AST
+    # Checks the AST for certain validations, like correct capture names.
+    #
+    # Internally a poor man's visitor (abusing translator to not have to impelment a visitor).
+    # @!visibility private
+    class Validation < Translator
+      # Runs validations.
+      #
+      # @param [Mustermann::AST::Node] ast to be validated
+      # @return [Mustermann::AST::Node] the validated ast
+      # @raises [Mustermann::AST::CompileError] if validation fails
+      # @!visibility private
+      def self.validate(ast)
+        new.translate(ast)
+        ast
+      end
+
+      translate(Object, :splat) {}
+      translate(:node) { t(payload) }
+      translate(Array) { each { |p| t(p)} }
+
+      translate(:capture, :variable, :named_splat) do
+        raise CompileError, "capture name can't be empty" if name.nil? or name.empty?
+        raise CompileError, "capture name must start with underscore or lower case letter" unless name =~ /^[a-z_]/
+        raise CompileError, "capture name can't be #{name}" if name == "splat" or name == "captures"
+        raise CompileError, "can't use the same capture name twice" if t.names.include? name
+        t.names << name
+      end
+
+      # @return [Array<String>] list of capture names in tree
+      # @!visibility private
+      def names
+        @names ||= []
+      end
+    end
+  end
+end

data/lib/mustermann/error.rb

@@ -1,14 +1,6 @@
 module Mustermann
-  # Raised if anything goes wrong while generating a {Pattern}.
-  class Error < StandardError; end
-
-  # Raised if anything goes wrong while compiling a {Pattern}.
-  class CompileError < Error; end
-
-  # Raised if anything goes wrong while parsing a {Pattern}.
-  class ParseError < Error; end
-
-  #@!visibility private
-  class UnexpectedClosingGroup < ParseError; end
-  private_constant :UnexpectedClosingGroup
+  Error        ||= Class.new(StandardError) # Raised if anything goes wrong while generating a {Pattern}.
+  CompileError ||= Class.new(Error)         # Raised if anything goes wrong while compiling a {Pattern}.
+  ParseError   ||= Class.new(Error)         # Raised if anything goes wrong while parsing a {Pattern}.
+  ExpandError  ||= Class.new(Error)         # Raised if anything goes wrong while expanding a {Pattern}.
 end

data/lib/mustermann/extension.rb

@@ -29,8 +29,8 @@ module Mustermann
         pattern[:except]  = except  if except
         pattern[:capture] = capture if capture
 
-        if settings.respond_to? :pattern
-          pattern.merge!(settings.pattern || {}) do |key, local, global|
+        if settings.respond_to? :pattern and settings.pattern?
+          pattern.merge! settings.pattern do |key, local, global|
             next local unless local.is_a? Hash
             next global.merge(local) if global.is_a? Hash
             Hash.new(global).merge! local
@@ -38,10 +38,7 @@ module Mustermann
         end
 
         path = Mustermann.new(path, **pattern)
-
-        if defined? Template and path.is_a? Template
-          condition { params.merge! path.params(request.path_info) }
-        end
+        condition { params.merge! path.params(captures: Array(params[:captures]), offset: -1) }
       end
 
       super(verb, path, block, options)

data/lib/mustermann/identity.rb

@@ -6,12 +6,12 @@ module Mustermann
   # @example
   #   Mustermann.new('/:foo', type: :identity) === '/bar' # => false
   #
-  # @see Pattern
+  # @see Mustermann::Pattern
   # @see file:README.md#identity Syntax description in the README
   class Identity < Pattern
-    # @param (see Pattern#===)
-    # @return (see Pattern#===)
-    # @see (see Pattern#===)
+    # @param (see Mustermann::Pattern#===)
+    # @return (see Mustermann::Pattern#===)
+    # @see (see Mustermann::Pattern#===)
     def ===(string)
       unescape(string) == @string
     end

data/lib/mustermann/pattern.rb

@@ -33,7 +33,7 @@ module Mustermann
     # @param (see #initialize)
     # @raise (see #initialize)
     # @raise [ArgumentError] if some option is not supported
-    # @return [Pattern] a new instance of Pattern
+    # @return [Mustermann::Pattern] a new instance of Mustermann::Pattern
     # @see #initialize
     def self.new(string, ignore_unknown_options: false, **options)
       unless ignore_unknown_options
@@ -47,7 +47,7 @@ module Mustermann
     supported_options :uri_decode, :ignore_unknown_options
 
     # @overload initialize(string, **options)
-    # @param [String] string the string repesentation of the pattern
+    # @param [String] string the string representation of the pattern
     # @param [Hash] options options for fine-tuning the pattern behavior
     # @raise [Mustermann::Error] if the pattern can't be generated from the string
     # @see file:README.md#Types_and_Options "Types and Options" in the README
@@ -66,7 +66,7 @@ module Mustermann
     # @return [MatchData, Mustermann::SimpleMatch, nil] MatchData or similar object if the pattern matches.
     # @see http://ruby-doc.org/core-2.0/Regexp.html#method-i-match Regexp#match
     # @see http://ruby-doc.org/core-2.0/MatchData.html MatchData
-    # @see SimpleMatch
+    # @see Mustermann::SimpleMatch
     def match(string)
       SimpleMatch.new(string) if self === string
     end
@@ -100,10 +100,10 @@ module Mustermann
 
     # @param [String] string the string to match against
     # @return [Hash{String: String, Array<String>}, nil] Sinatra style params if pattern matches.
-    def params(string = nil, captures: nil)
+    def params(string = nil, captures: nil, offset: 0)
       return unless captures ||= match(string)
       params   = named_captures.map do |name, positions|
-        values = positions.map { |pos| map_param(name, captures[pos]) }.flatten
+        values = positions.map { |pos| map_param(name, captures[pos + offset]) }.flatten
         values = values.first if values.size < 2 and not always_array? name
         [name, values]
       end
@@ -111,6 +111,35 @@ module Mustermann
       Hash[params]
     end
 
+    # @note This method is only implemented by certain subclasses.
+    #
+    # @example Expanding a pattern
+    #   pattern = Mustermann.new('/:name(.:ext)?')
+    #   pattern.expand(name: 'hello')             # => "/hello"
+    #   pattern.expand(name: 'hello', ext: 'png') # => "/hello.png"
+    #
+    # @example Checking if a pattern supports expanding
+    #   if pattern.respond_to? :expand
+    #     pattern.expand(name: "foo")
+    #   else
+    #     warn "does not support expanding"
+    #   end
+    #
+    # @param [Hash{Symbol: #to_s, Array<#to_s>}] **values values to use for expansion
+    # @return [String] expanded string
+    # @raise [NotImplementedError] raised if expand is not supported.
+    # @raise [ArgumentError] raised if a value is missing or unknown
+    def expand(**values)
+      raise NotImplementedError, "expanding not supported by #{self.class}"
+    end
+
+    # @!visibility private
+    # @return [Boolean]
+    # @see Object#respond_to?
+    def respond_to?(method, *args)
+      method.to_s == 'expand' ? false : super
+    end
+
     # @!visibility private
     def inspect
       "#<%p:%p>" % [self.class, @string]

data/lib/mustermann/rails.rb

@@ -1,4 +1,4 @@
-require 'mustermann/ast'
+require 'mustermann/ast/pattern'
 
 module Mustermann
   # Rails style pattern implementation.
@@ -6,21 +6,12 @@ module Mustermann
   # @example
   #   Mustermann.new('/:foo', type: :rails) === '/bar' # => true
   #
-  # @see Pattern
+  # @see Mustermann::Pattern
   # @see file:README.md#rails Syntax description in the README
-  class Rails < AST
-    def parse_element(buffer)
-      case char = buffer.getch
-      when nil then unexpected("end of string")
-      when ?)  then unexpected(char, exception: UnexpectedClosingGroup)
-      when ?*  then NamedSplat.parse { buffer.scan(/\w+/) }
-      when ?/  then Separator.new(char)
-      when ?(  then Optional.new(Group.parse { parse_buffer(buffer) })
-      when ?:  then Capture.parse { buffer.scan(/\w+/) }
-      else Char.new(char)
-      end
-    end
-
-    private :parse_element
+  class Rails < AST::Pattern
+    on(nil, ?)) { |c| unexpected(c) }
+    on(?*)      { |c| node(:named_splat) { scan(/\w+/) } }
+    on(?()      { |c| node(:optional, node(:group) { read unless scan(?)) }) }
+    on(?:)      { |c| node(:capture) { scan(/\w+/) } }
   end
 end