mustermann19 0.3.1 → 0.3.1.1

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 |options = {}|
         greedy = options.fetch(:greedy, true)
         t(payload, options.merge(allow_reserved: operator.allow_reserved, greedy: greedy && !operator.allow_reserved,
@@ -57,7 +61,7 @@ module Mustermann
         private
           def qualified(string, options = {})
              greedy = options.fetch(:greedy, true)
-            "#{string}+#{?? unless greedy}"
+            "#{string}#{qualifier || "+#{?? unless greedy}"}"
           end
 
           def with_lookahead(string, options = {})
@@ -69,7 +73,7 @@ module Mustermann
           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
@@ -78,7 +82,7 @@ module Mustermann
         # splats are always non-greedy
         # @!visibility private
         def pattern(options = {})
-          ".*?"
+          constraint || ".*?"
         end
       end
 
@@ -137,7 +141,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
 
@@ -157,9 +164,8 @@ module Mustermann
       # @!visibility private
       def compile(ast, options = {})
         except = options.delete(:except)
-        except   &&= "(?!#{translate(except, options.merge(no_captures: true))}\\Z)"
-        expression = "\\A#{except}#{translate(ast, options)}\\Z"
-        Regexp.new(expression)
+        except &&= "(?!#{translate(except, options.merge(no_captures: true))}\\Z)"
+        Regexp.new("#{except}#{translate(ast, options)}")
       end
     end
 

data/lib/mustermann/ast/expander.rb

@@ -46,6 +46,10 @@ module Mustermann
         nested
       end
 
+      translate :union do
+        payload.map { |e| t(e) }.inject(:+)
+      end
+
       # helper method for captures
       # @!visibility private
       def for_capture(node)
@@ -70,7 +74,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 +86,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 +118,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

@@ -18,6 +18,12 @@ module Mustermann
         end
       end
 
+      # @!visibility private
+      def is_a?(type)
+        type = Node[type] if type.is_a? Symbol
+        super(type)
+      end
+
       # @!visibility private
       # @param [Symbol] name of the node
       # @return [String] qualified name of factory for the node
@@ -65,6 +71,18 @@ module Mustermann
 
       # @!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
@@ -88,7 +106,7 @@ module Mustermann
       end
 
       # @!visibility private
-      class Group < Node
+      class Composition < Node
         # @!visibility private
         def initialize(payload = nil, options = {})
           options, payload = payload, nil if payload.is_a?(Hash)
@@ -96,6 +114,14 @@ module Mustermann
         end
       end
 
+      # @!visibility private
+      class Group < Composition
+      end
+
+      # @!visibility private
+      class Union < Composition
+      end
+
       # @!visibility private
       class Optional < Node
       end

data/lib/mustermann/ast/param_scanner.rb

@@ -0,0 +1,20 @@
+require 'mustermann/ast/translator'
+
+module Mustermann
+  module AST
+    # Scans an AST for param converters.
+    # @!visibility private
+    # @see Mustermann::AST::Pattern#to_templates
+    class ParamScanner < Translator
+      # @!visibility private
+      def self.scan_params(ast)
+        new.translate(ast)
+      end
+
+      translate(:node)    { t(payload) }
+      translate(Array)    { map { |e| t(e) }.inject(:merge) }
+      translate(Object)   { {} }
+      translate(:capture) { convert ? { name => convert } : {} }
+    end
+  end
+end

data/lib/mustermann/ast/parser.rb

@@ -11,8 +11,8 @@ module Mustermann
       # @param [String] string to be parsed
       # @return [Mustermann::AST::Node] parse tree for string
       # @!visibility private
-      def self.parse(string)
-        new.parse(string)
+      def self.parse(string, options = {})
+        new(options).parse(string)
       end
 
       # Defines another grammar rule for first character.
@@ -31,24 +31,31 @@ module Mustermann
       #
       # @see Mustermann::Sinatra
       # @!visibility private
-      def self.suffix(pattern = /./, &block)
+      def self.suffix(pattern = /./, options = {}, &block)
+        after = options[:after] || :node
         @suffix ||= []
-        @suffix << [pattern, block] if block
+        @suffix << [pattern, after, block] if block
         @suffix
       end
 
       # @!visibility private
-      attr_reader :buffer, :string
+      attr_reader :buffer, :string, :pattern
 
       extend Forwardable
       def_delegators :buffer, :eos?, :getch
 
+      # @!visibility private
+      def initialize(options = {})
+        pattern = options.delete(:pattern)
+        @pattern = pattern
+      end
+
       # @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)
+        @buffer = ::StringScanner.new(string)
         node(:root, string) { read unless eos? }
       end
 
@@ -87,8 +94,8 @@ module Mustermann
       # @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)
+        self.class.suffix.inject(element) do |ele, (regexp, after, callback)|
+          next ele unless ele.is_a?(after) and payload = scan(regexp)
           instance_exec(payload, ele, &callback)
         end
       end
@@ -102,8 +109,25 @@ module Mustermann
       # @return [String, MatchData, nil]
       # @!visibility private
       def scan(regexp)
+        match_buffer(:scan, regexp)
+      end
+
+      # Wrapper around {StringScanner#check} that turns strings into escaped
+      # regular expressions and returns a MatchData if the regexp has any
+      # named captures.
+      #
+      # @param [Regexp, String] regexp
+      # @see StringScanner#check
+      # @return [String, MatchData, nil]
+      # @!visibility private
+      def check(regexp)
+        match_buffer(:check, regexp)
+      end
+
+      # @!visibility private
+      def match_buffer(method, regexp)
         regexp = Regexp.new(Regexp.escape(regexp)) unless regexp.is_a? Regexp
-        string = buffer.scan(regexp)
+        string = buffer.public_send(method, regexp)
         regexp.names.any? ? regexp.match(string) : string
       end
 
@@ -115,7 +139,99 @@ module Mustermann
       # @raise [Mustermann::ParseError] if expectation wasn't met
       # @!visibility private
       def expect(regexp, options = {})
-        scan(regexp)|| unexpected(options)
+        char = options.delete(:char) || nil
+        scan(regexp) || unexpected(char, options)
+      end
+
+      # Allows to read a string inside brackets. It does not expect the string
+      # to start with an opening bracket.
+      #
+      # @example
+      #   buffer.string = "fo<o>>ba<r>"
+      #   read_brackets(?<, ?>) # => "fo<o>"
+      #   buffer.rest # => "ba<r>"
+      #
+      # @!visibility private
+      def read_brackets(open, close, options = {})
+        char = options.delete(:char) || nil
+        escape = options.delete(:escape) || '\\'
+        quote = options.delete(:quote) || false
+        result = ""
+        escape = false if escape.nil?
+        while current = getch
+          case current
+          when close  then return result
+          when open   then result << open   << read_brackets(open, close) << close
+          when escape then result << escape << getch
+          else result << current
+          end
+        end
+        unexpected(char, options)
+      end
+
+
+      # Reads an argument string of the format arg1,args2,key:value
+      #
+      # @!visibility private
+      def read_args(key_separator, close, options = {})
+        separator = options.delete(:separator) || ?,
+        symbol_keys = options.fetch(:symbol_keys, true)
+        options.delete(:symbol_keys)
+        list, map = [], {}
+        while buffer.peek(1) != close
+          scan(separator)
+          entries = read_list(close, separator, options.merge(separator: key_separator))
+          case entries.size
+          when 1 then list += entries
+          when 2 then map[symbol_keys ? entries.first.to_sym : entries.first] = entries.last
+          else        unexpected(key_separator)
+          end
+          buffer.pos -= 1
+        end
+        expect(close)
+        [list, map]
+      end
+
+      # Reads a separated list with the ability to quote, escape and add spaces.
+      #
+      # @!visibility private
+      #def read_list(*close, separator: ?,, escape: ?\\, quotes: [?", ?'], ignore: " ", options)
+      def read_list(*close)
+        options = close.last.kind_of?(Hash) ? close.pop : {}
+        separator = options.delete(:separator) || ?,
+        escape    = options.delete(:escape) || '\\'
+        quotes    = options.delete(:quotes) || [?", ?']
+        ignore    = options.delete(:ignore) || " "
+        result = []
+        while current = getch
+          element = result.empty? ? result : result.last
+          case current
+          when *close    then return result
+          when ignore    then nil # do nothing
+          when separator then result  << ""
+          when escape    then element << getch
+          when *quotes   then element << read_escaped(current, escape: escape)
+          else element << current
+          end
+        end
+        unexpected(current, options)
+      end
+
+      # Read a string until a terminating character, ignoring escaped versions of said character.
+      #
+      # @!visibility private
+      #def read_escaped(close, escape: ?\\, **options)
+      def read_escaped(close, options = {})
+        escape = options.delete(:escape) || '\\'
+        result = ""
+        while current = getch
+          case current
+          when close  then return result
+          when escape then result << getch
+          else result << current
+          end
+        end
+        unexpected(current, options)
       end
 
       # Helper for raising an exception for an unexpected character.
@@ -124,12 +240,15 @@ module Mustermann
       # @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)
+      def unexpected(char = nil, options = {})
+        options, char = char, nil if char.is_a?(Hash)
+        char ||= getch
         exception = options.fetch(:exception, ParseError)
         char = "space" if char == " "
         raise exception, "unexpected #{char || "end of string"} while parsing #{string.inspect}"
       end
+
+      private :match_buffer
     end
 
     #private_constant :Parser

data/lib/mustermann/ast/pattern.rb

@@ -2,6 +2,8 @@ require 'mustermann/ast/parser'
 require 'mustermann/ast/compiler'
 require 'mustermann/ast/transformer'
 require 'mustermann/ast/validation'
+require 'mustermann/ast/template_generator'
+require 'mustermann/ast/param_scanner'
 require 'mustermann/regexp_based'
 require 'mustermann/expander'
 require 'mustermann/equality_map'
@@ -16,8 +18,9 @@ module Mustermann
 
       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
+      instance_delegate %w[parser compiler transformer validation template_generator param_scanner].map(&:to_sym) => 'self.class'
+      instance_delegate parse: :parser, transform: :transformer, validate: :validation,
+        generate_templates: :template_generator, scan_params: :param_scanner
 
       # @api private
       # @return [#parse] parser object for pattern
@@ -49,6 +52,20 @@ module Mustermann
         Validation
       end
 
+      # @api private
+      # @return [#generate_templates] generates URI templates for pattern
+      # @!visibility private
+      def self.template_generator
+        TemplateGenerator
+      end
+
+      # @api private
+      # @return [#scan_params] param scanner for pattern
+      # @!visibility private
+      def self.param_scanner
+        ParamScanner
+      end
+
       # @!visibility private
       def compile(options = {})
         options[:except] &&= parse options[:except]
@@ -62,7 +79,7 @@ module Mustermann
       # @!visibility private
       def to_ast
         @ast_cache ||= EqualityMap.new
-        @ast_cache.fetch(@string) { validate(transform(parse(@string))) }
+        @ast_cache.fetch(@string) { validate(transform(parse(@string, pattern: self))) }
       end
 
       # All AST-based pattern implementations support expanding.
@@ -73,12 +90,34 @@ module Mustermann
       # @raise (see Mustermann::Pattern#expand)
       # @see Mustermann::Pattern#expand
       # @see Mustermann::Expander
-      def expand(values = {})
+      def expand(behavior = nil, values = {})
         @expander ||= Mustermann::Expander.new(self)
-        @expander.expand(values)
+        @expander.expand(behavior, values)
+      end
+
+      # All AST-based pattern implementations support generating templates.
+      #
+      # @example (see Mustermann::Pattern#to_templates)
+      # @param (see Mustermann::Pattern#to_templates)
+      # @return (see Mustermann::Pattern#to_templates)
+      # @see Mustermann::Pattern#to_templates
+      def to_templates
+        @to_templates ||= generate_templates(to_ast)
+      end
+
+      # @!visibility private
+      # @see Mustermann::Pattern#map_param
+      def map_param(key, value)
+        return super unless param_converters.include? key
+        param_converters[key][super]
+      end
+
+      # @!visibility private
+      def param_converters
+        @param_converters ||= scan_params(to_ast)
       end
 
-      private :compile
+      private :compile, :parse, :transform, :validate, :generate_templates, :param_converters, :scan_params
     end
   end
 end

data/lib/mustermann/ast/template_generator.rb

@@ -0,0 +1,28 @@
+require 'mustermann/ast/translator'
+
+module Mustermann
+  module AST
+    # Turns an AST into an Array of URI templates representing the AST.
+    # @!visibility private
+    # @see Mustermann::AST::Pattern#to_templates
+    class TemplateGenerator < Translator
+      # @!visibility private
+      def self.generate_templates(ast)
+        new.translate(ast).uniq
+      end
+
+      # translate(:expression) is not needed, since template patterns simply call to_s
+      translate(:root, :group)        { t(payload) || [""]            }
+      translate(:separator, :char)    { t.escape(payload)             }
+      translate(:capture)             { "{#{name}}"                   }
+      translate(:optional)            { [t(payload), ""]              }
+      translate(:named_splat, :splat) { "{+#{name}}"                  }
+      translate(:with_look_ahead)     { t([head, payload])            }
+      translate(:union)               { payload.flat_map { |e| t(e) } }
+
+      translate(Array) do
+        map { |e| Array(t(e)) }.inject { |first, second| first.product(second).map(&:join) }
+      end
+    end
+  end
+end

data/lib/mustermann/ast/validation.rb

@@ -21,14 +21,16 @@ module Mustermann
       translate(Object, :splat) {}
       translate(:node) { t(payload) }
       translate(Array) { each { |p| t(p)} }
-      translate(:capture, :variable, :named_splat) { t.check_name(name) }
+      translate(:capture) { t.check_name(name, forbidden: ['captures', 'splat'])}
+      translate(:variable, :named_splat) { t.check_name(name, forbidden: 'captures')}
 
       # @raise [Mustermann::CompileError] if name is not acceptable
       # @!visibility private
-      def check_name(name)
+      def check_name(name, options = {})
+        forbidden = options[:forbidden]
         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, "capture name can't be #{name}" if Array(forbidden).include? name
         raise CompileError, "can't use the same capture name twice" if names.include? name
         names << name
       end

data/lib/mustermann/composite.rb

@@ -0,0 +1,103 @@
+module Mustermann
+  # Class for pattern objects composed of multiple patterns using binary logic.
+  # @see Mustermann::Pattern#&
+  # @see Mustermann::Pattern#|
+  # @see Mustermann::Pattern#^
+  class Composite < Pattern
+    attr_reader :patterns, :operator
+    supported_options :operator, :type
+
+    # @see Mustermann::Pattern.supported?
+    def self.supported?(option, options = {})
+      return true if super
+      options[:type] and Mustermann[options[:type]].supported?(option, options)
+    end
+
+    # @return [Mustermann::Pattern] a new composite pattern
+    def self.new(*patterns)
+      options = patterns.last.kind_of?(Hash) ? patterns.pop : {}
+      patterns = patterns.flatten
+      case patterns.size
+      when 0 then raise ArgumentError, 'cannot create empty composite pattern'
+      when 1 then patterns.first
+      else super(patterns, options)
+      end
+    end
+
+    def initialize(patterns, options = {})
+      operator = options.delete(:operator) || :|
+      @operator = operator.to_sym
+      @patterns = patterns.flat_map { |p| patterns_from(p, options) }
+    end
+
+    # @see Mustermann::Pattern#==
+    def ==(pattern)
+      patterns == patterns_from(pattern)
+    end
+
+    # @see Mustermann::Pattern#===
+    def ===(string)
+      patterns.map { |p| p === string }.inject(operator)
+    end
+
+    # @see Mustermann::Pattern#params
+    def params(string)
+      with_matching(string, :params)
+    end
+
+    # @see Mustermann::Pattern#match
+    def match(string)
+      with_matching(string, :match)
+    end
+
+    # @!visibility private
+    def respond_to_special?(method)
+      return false unless operator == :|
+      patterns.all? { |p| p.respond_to?(method) }
+    end
+
+    # (see Mustermann::Pattern#expand)
+    def expand(behavior = nil, values = {})
+      raise NotImplementedError, 'expanding not supported' unless respond_to? :expand
+      @expander ||= Mustermann::Expander.new(*patterns)
+      @expander.expand(behavior, values)
+    end
+
+    # (see Mustermann::Pattern#expand)
+    def to_templates
+      raise NotImplementedError, 'template generation not supported' unless respond_to? :to_templates
+      patterns.flat_map(&:to_templates).uniq
+    end
+
+    # @return [String] the string representation of the pattern
+    def to_s
+      simple_inspect
+    end
+
+    # @!visibility private
+    def inspect
+      "#<%p:%s>" % [self.class, simple_inspect]
+    end
+
+    # @!visibility private
+    def simple_inspect
+      pattern_strings = patterns.map { |p| p.simple_inspect }
+      "(#{pattern_strings.join(" #{operator} ")})"
+    end
+
+    # @!visibility private
+    def with_matching(string, method)
+      return unless self === string
+      pattern = patterns.detect { |p| p === string }
+      pattern.public_send(method, string) if pattern
+    end
+
+    # @!visibility private
+    def patterns_from(pattern, options = nil)
+      return pattern.patterns if pattern.is_a? Composite and pattern.operator == self.operator
+      [options ? Mustermann.new(pattern, options) : pattern]
+    end
+
+    private :with_matching, :patterns_from
+  end
+end

data/lib/mustermann/expander.rb

@@ -140,7 +140,7 @@ module Mustermann
     # @raise [NotImplementedError] raised if expand is not supported.
     # @raise [Mustermann::ExpandError] raised if a value is missing or unknown
     def expand(behavior = nil, values = {})
-      values, behavior = behavior, nil if behavior.is_a?(Hash)
+      behavior, values = nil, behavior if behavior.is_a? Hash
       values = map_values(values)
 
       case behavior || additional_values

data/lib/mustermann/express.rb

@@ -0,0 +1,34 @@
+require 'mustermann/ast/pattern'
+
+module Mustermann
+  # Express style pattern implementation.
+  #
+  # @example
+  #   Mustermann.new('/:foo', type: :express) === '/bar' # => true
+  #
+  # @see Mustermann::Pattern
+  # @see file:README.md#flask Syntax description in the README
+  class Express < AST::Pattern
+    on(nil, ??, ?+, ?*, ?)) { |c| unexpected(c) }
+    on(?:) { |c| node(:capture) { scan(/\w+/) } }
+    on(?() { |c| node(:splat, constraint: read_brackets(?(, ?))) }
+
+    suffix ??, after: :capture do |char, element|
+      unexpected(char) unless element.is_a? :capture
+      node(:optional, element)
+    end
+
+    suffix ?*, after: :capture do |match, element|
+      node(:named_splat, element.name)
+    end
+
+    suffix ?+, after: :capture do |match, element|
+      node(:named_splat, element.name, constraint: ".+")
+    end
+
+    suffix ?(, after: :capture do |match, element|
+      element.constraint = read_brackets(?(, ?))
+      element
+    end
+  end
+end