mustermann19 0.3.1

data/lib/mustermann/ast/node.rb

@@ -0,0 +1,160 @@
+module Mustermann
+  # @see Mustermann::AST::Pattern
+  module AST
+    # @!visibility private
+    class Node
+      # @!visibility private
+      attr_accessor :payload
+
+      # @!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.fetch(name) do
+          const_name = constant_name(name)
+          const_name.split("::").inject(Object){|current, const| current.const_get(const) }
+        end
+      end
+
+      # @!visibility private
+      # @param [Symbol] name of the node
+      # @return [String] qualified name of factory for the node
+      def self.constant_name(name)
+        return self.name if name.to_sym == :node
+        name = name.to_s.split(?_).map(&:capitalize).join
+        "#{self.name}::#{name}"
+      end
+
+      # Helper for creating a new instance and calling #parse on it.
+      # @return [Mustermann::AST::Node]
+      # @!visibility private
+      def self.parse(*args, &block)
+        new(*args).tap { |n| n.parse(&block) }
+      end
+
+      # @!visibility private
+      def initialize(payload = nil, options = {})
+        options, payload = payload, nil if payload.is_a?(Hash)
+        options.each { |key, value| public_send("#{key}=", value) }
+        self.payload = payload
+      end
+
+      # Double dispatch helper for reading from the buffer into the payload.
+      # @!visibility private
+      def parse
+        self.payload ||= []
+        while element = yield
+          payload << element
+        end
+      end
+
+      # Loop through all nodes that don't have child nodes.
+      # @!visibility private
+      def each_leaf(&block)
+        return enum_for(__method__) unless block_given?
+        called = false
+        Array(payload).each do |entry|
+          next unless entry.respond_to? :each_leaf
+          entry.each_leaf(&block)
+          called = true
+        end
+        yield(self) unless called
+      end
+
+      # @!visibility private
+      class Capture < Node
+        # @see Mustermann::AST::Node#parse
+        # @!visibility private
+        def parse
+          self.payload ||= ""
+          super
+        end
+
+        # @!visibility private
+        alias_method :name, :payload
+      end
+
+      # @!visibility private
+      class Char < Node
+      end
+
+      # AST node for template expressions.
+      # @!visibility private
+      class Expression < Node
+        # @!visibility private
+        attr_accessor :operator
+      end
+
+      # @!visibility private
+      class Group < Node
+        # @!visibility private
+        def initialize(payload = nil, options = {})
+          options, payload = payload, nil if payload.is_a?(Hash)
+          super(Array(payload), options)
+        end
+      end
+
+      # @!visibility private
+      class Optional < Node
+      end
+
+      # @!visibility private
+      class Root < Node
+        # @!visibility private
+        attr_accessor :pattern
+
+        # Will trigger transform.
+        #
+        # @see Mustermann::AST::Node.parse
+        # @!visibility private
+        def self.parse(string, &block)
+          root         = new
+          root.pattern = string
+          root.parse(&block)
+          root
+        end
+      end
+
+      # @!visibility private
+      class Separator < Node
+      end
+
+      # @!visibility private
+      class Splat < Capture
+        # @see Mustermann::AST::Node::Capture#name
+        # @!visibility private
+        def name
+          "splat"
+        end
+      end
+
+      # @!visibility private
+      class NamedSplat < Splat
+        # @see Mustermann::AST::Node::Capture#name
+        # @!visibility private
+        alias_method :name, :payload
+      end
+
+      # AST node for template variables.
+      # @!visibility private
+      class Variable < Capture
+        # @!visibility private
+        attr_accessor :prefix, :explode
+      end
+
+      # @!visibility private
+      class WithLookAhead < Node
+        # @!visibility private
+        attr_accessor :head, :at_end
+
+        # @!visibility private
+        def initialize(payload, at_end)
+          self.head, *self.payload = Array(payload)
+          self.at_end = at_end
+        end
+      end
+    end
+  end
+end

data/lib/mustermann/ast/parser.rb

@@ -0,0 +1,137 @@
+require 'mustermann/ast/node'
+require 'forwardable'
+require 'strscan'
+
+module Mustermann
+  # @see Mustermann::AST::Pattern
+  module AST
+    # Simple, StringScanner based parser.
+    # @!visibility private
+    class Parser
+      # @param [String] string to be parsed
+      # @return [Mustermann::AST::Node] parse tree for string
+      # @!visibility private
+      def self.parse(string)
+        new.parse(string)
+      end
+
+      # Defines another grammar rule for first character.
+      #
+      # @see Mustermann::Rails
+      # @see Mustermann::Sinatra
+      # @see Mustermann::Template
+      # @!visibility private
+      def self.on(*chars, &block)
+        chars.each do |char|
+          define_method("read %p" % char, &block)
+        end
+      end
+
+      # Defines another grammar rule for a suffix.
+      #
+      # @see Mustermann::Sinatra
+      # @!visibility private
+      def self.suffix(pattern = /./, &block)
+        @suffix ||= []
+        @suffix << [pattern, block] if block
+        @suffix
+      end
+
+      # @!visibility private
+      attr_reader :buffer, :string
+
+      extend Forwardable
+      def_delegators :buffer, :eos?, :getch
+
+      # @param [String] string to be parsed
+      # @return [Mustermann::AST::Node] parse tree for string
+      # @!visibility private
+      def parse(string)
+        @string = string
+        @buffer = StringScanner.new(string)
+        node(:root, string) { read unless eos? }
+      end
+
+      # @example
+      #   node(:char, 'x').compile =~ 'x' # => true
+      #
+      # @param [Symbol] type node type
+      # @return [Mustermann::AST::Node]
+      # @!visibility private
+      def node(type, *args, &block)
+        type = Node[type] unless type.respond_to? :new
+        block ? type.parse(*args, &block) : type.new(*args)
+      end
+
+      # Create a node for a character we don't have an explicit rule for.
+      #
+      # @param [String] char the character
+      # @return [Mustermann::AST::Node] the node
+      # @!visibility private
+      def default_node(char)
+        char == ?/ ? node(:separator, char) : node(:char, char)
+      end
+
+      # Reads the next element from the buffer.
+      # @return [Mustermann::AST::Node] next element
+      # @!visibility private
+      def read
+        char    = getch
+        method  = "read %p" % char
+        element = respond_to?(method) ? send(method, char) : default_node(char)
+        read_suffix(element)
+      end
+
+      # Checks for a potential suffix on the buffer.
+      # @param [Mustermann::AST::Node] element node without suffix
+      # @return [Mustermann::AST::Node] node with suffix
+      # @!visibility private
+      def read_suffix(element)
+        self.class.suffix.inject(element) do |ele, (regexp, callback)|
+          next ele unless payload = scan(regexp)
+          instance_exec(payload, ele, &callback)
+        end
+      end
+
+      # Wrapper around {StringScanner#scan} that turns strings into escaped
+      # regular expressions and returns a MatchData if the regexp has any
+      # named captures.
+      #
+      # @param [Regexp, String] regexp
+      # @see StringScanner#scan
+      # @return [String, MatchData, nil]
+      # @!visibility private
+      def scan(regexp)
+        regexp = Regexp.new(Regexp.escape(regexp)) unless regexp.is_a? Regexp
+        string = buffer.scan(regexp)
+        regexp.names.any? ? regexp.match(string) : string
+      end
+
+      # Asserts a regular expression matches what's next on the buffer.
+      # Will return corresponding MatchData if regexp includes named captures.
+      #
+      # @param [Regexp] regexp expected to match
+      # @return [String, MatchData] the match
+      # @raise [Mustermann::ParseError] if expectation wasn't met
+      # @!visibility private
+      def expect(regexp, options = {})
+        scan(regexp)|| unexpected(options)
+      end
+
+      # Helper for raising an exception for an unexpected character.
+      # Will read character from buffer if buffer is passed in.
+      #
+      # @param [String, nil] char the unexpected character
+      # @raise [Mustermann::ParseError, Exception]
+      # @!visibility private
+      def unexpected(char = getch, options = {})
+        options, char = char, getch if char.is_a?(Hash)
+        exception = options.fetch(:exception, ParseError)
+        char = "space" if char == " "
+        raise exception, "unexpected #{char || "end of string"} while parsing #{string.inspect}"
+      end
+    end
+
+    #private_constant :Parser
+  end
+end

data/lib/mustermann/ast/pattern.rb

@@ -0,0 +1,84 @@
+require 'mustermann/ast/parser'
+require 'mustermann/ast/compiler'
+require 'mustermann/ast/transformer'
+require 'mustermann/ast/validation'
+require 'mustermann/regexp_based'
+require 'mustermann/expander'
+require 'mustermann/equality_map'
+
+module Mustermann
+  # @see Mustermann::AST::Pattern
+  module AST
+    # Superclass for pattern styles that parse an AST from the string pattern.
+    # @abstract
+    class Pattern < Mustermann::RegexpBased
+      supported_options :capture, :except, :greedy, :space_matches_plus
+
+      extend Forwardable, SingleForwardable
+      single_delegate on: :parser, suffix: :parser
+      instance_delegate %w[parser compiler transformer validation].map(&:to_sym) => 'self.class'
+      instance_delegate parse: :parser, transform: :transformer, validate: :validation
+
+      # @api private
+      # @return [#parse] parser object for pattern
+      # @!visibility private
+      def self.parser
+        return Parser if self == AST::Pattern
+        const_set :Parser, Class.new(superclass.parser) unless const_defined? :Parser, false
+        const_get :Parser
+      end
+
+      # @api private
+      # @return [#compile] compiler object for pattern
+      # @!visibility private
+      def self.compiler
+        Compiler
+      end
+
+      # @api private
+      # @return [#transform] compiler object for pattern
+      # @!visibility private
+      def self.transformer
+        Transformer
+      end
+
+      # @api private
+      # @return [#validate] validation object for pattern
+      # @!visibility private
+      def self.validation
+        Validation
+      end
+
+      # @!visibility private
+      def compile(options = {})
+        options[:except] &&= parse options[:except]
+        compiler.compile(to_ast, options)
+      rescue CompileError => error
+        error.message << ": %p" % @string
+        raise error
+      end
+
+      # Internal AST representation of pattern.
+      # @!visibility private
+      def to_ast
+        @ast_cache ||= EqualityMap.new
+        @ast_cache.fetch(@string) { validate(transform(parse(@string))) }
+      end
+
+      # All AST-based pattern implementations support expanding.
+      #
+      # @example (see Mustermann::Pattern#expand)
+      # @param (see Mustermann::Pattern#expand)
+      # @return (see Mustermann::Pattern#expand)
+      # @raise (see Mustermann::Pattern#expand)
+      # @see Mustermann::Pattern#expand
+      # @see Mustermann::Expander
+      def expand(values = {})
+        @expander ||= Mustermann::Expander.new(self)
+        @expander.expand(values)
+      end
+
+      private :compile
+    end
+  end
+end

data/lib/mustermann/ast/transformer.rb

@@ -0,0 +1,129 @@
+require 'mustermann/ast/translator'
+
+module Mustermann
+  module AST
+    # Takes a tree, turns it into an even better tree.
+    # @!visibility private
+    class Transformer < Translator
+
+      # 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(tree)
+        new.translate(tree)
+      end
+
+      translate(:node) { self }
+      translate(:group, :root) do
+        self.payload = t(payload)
+        self
+      end
+
+      # URI expression transformations depending on operator
+      # @!visibility private
+      class ExpressionTransform < NodeTranslator
+        register :expression
+
+        # @!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)
+        }
+
+        # Sets operator and inserts separators in between variables.
+        # @!visibility private
+        def translate
+          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
+      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