mustermann 0.0.1 → 0.1.0

data/lib/mustermann/ast/expander.rb

@@ -0,0 +1,112 @@
+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
+
+      # add a tree for expansion
+      # @!visibility private
+      def add(ast)
+        translate(ast).each do |keys, pattern, filter|
+          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
+
+      # 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 uneccessary
+        string =~ /\A\w*\Z/ ? string : super
+      end
+
+      # Turns a sprintf pattern into our secret internal data strucutre.
+      # @!visibility private
+      def pattern(string = "", *keys, **filters)
+        [[keys, string, filters]]
+      end
+
+      # Creates the product of two of our secret internal data strucutres.
+      # @!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, **f2] } }
+      end
+    end
+  end
+end

data/lib/mustermann/ast/node.rb

@@ -0,0 +1,155 @@
+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)) }
+      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.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)
+          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.transform
+          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,136 @@
+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
+      # @param [Hash] **options parse options
+      # @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 explicite 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 |element, (regexp, callback)|
+          next element unless payload = scan(regexp)
+          instance_exec(payload, element, &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 unexcpected character
+      # @raise [Mustermann::ParseError, Exception]
+      # @!visibility private
+      def unexpected(char = getch, 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,89 @@
+require 'mustermann/ast/parser'
+require 'mustermann/ast/compiler'
+require 'mustermann/ast/transformer'
+require 'mustermann/ast/validation'
+require 'mustermann/ast/expander'
+require 'mustermann/regexp_based'
+
+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 %i[parser compiler transformer validation expander_class] => 'self.class'
+      instance_delegate parse: :parser, transform: :transformer, validate: :validation
+
+      # @api private
+      # @return [#expand] expander object for pattern
+      # @!visibility private
+      attr_accessor :expander
+
+      # @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
+
+      # @api private
+      # @return [#new] expander factory for pattern
+      # @!visibility private
+      def self.expander_class
+        Expander
+      end
+
+      # @!visibility private
+      def compile(string, **options)
+        self.expander      = expander_class.new
+        options[:except] &&= parse options[:except]
+        ast                = validate(transform(parse(string)))
+        expander.add(ast)
+        compiler.compile(ast, **options)
+      rescue CompileError => error
+        error.message << ": %p" % string
+        raise error
+      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
+      def expand(**values)
+        expander.expand(**values)
+      end
+
+      private :compile
+    end
+  end
+end