kdl 1.0.0.rc1 → 1.0.2

data/lib/kdl/kdl.yy

@@ -10,29 +10,31 @@ class KDL::Parser
         SEMICOLON
         EOF
         SLASHDASH
+        ESCLINE
 rule
   document  : nodes { KDL::Document.new(val[0]) }
             | linespaces { KDL::Document.new([])}
 
-  nodes     : none                      { [] }
-            | linespace_star node       { [val[1]] }
-            | linespace_star empty_node { [] }
-            | nodes node                { [*val[0], val[1]] }
-            | nodes empty_node          { val[0] }
-  node      : node_decl node_term                                 { val[0].tap { |x| x.children = nil } }
-            | node_decl node_children node_term                   { val[0].tap { |x| x.children = val[1] } }
-            | node_decl empty_children node_term                  { val[0].tap { |x| x.children = nil } }
-  node_decl : identifier                              { KDL::Node.new(val[0]) }
-            | type identifier                         { KDL::Node.new(val[1], type: val[0]) }
-            | node_decl WS value                      { val[0].tap { |x| x.arguments << val[2] } }
-            | node_decl WS SLASHDASH ws_star value    { val[0] }
-            | node_decl WS property                   { val[0].tap { |x| x.properties[val[2][0]] = val[2][1] } }
-            | node_decl WS SLASHDASH ws_star property { val[0] }
-  empty_node: SLASHDASH ws_star node
-  node_children: ws_star LBRACE nodes RBRACE { val[2] }
-               | ws_star LBRACE linespace_star RBRACE { [] }
+nodes           : none                      { [] }
+                | linespaces node       { [val[1]] }
+                | linespaces empty_node { [] }
+                | nodes node                { [*val[0], val[1]] }
+                | nodes empty_node          { val[0] }
+  node          : untyped_node      { val[0] }
+                | type untyped_node { val[1].as_type(val[0], @type_parsers.fetch(val[0], nil)) }
+  untyped_node  : node_decl node_term                { val[0].tap { |x| x.children = [] } }
+                | node_decl node_children node_term  { val[0].tap { |x| x.children = val[1] } }
+                | node_decl empty_children node_term { val[0].tap { |x| x.children = [] } }
+  node_decl     : identifier                              { KDL::Node.new(val[0]) }
+                | node_decl ws value                      { val[0].tap { |x| x.arguments << val[2] } }
+                | node_decl ws SLASHDASH ws_star value    { val[0] }
+                | node_decl ws property                   { val[0].tap { |x| x.properties[val[2][0]] = val[2][1] } }
+                | node_decl ws SLASHDASH ws_star property { val[0] }
+  empty_node    : SLASHDASH ws_star node
+  node_children : ws_star LBRACE nodes RBRACE { val[2] }
+                | ws_star LBRACE linespaces RBRACE { [] }
   empty_children: SLASHDASH node_children
-                | WS empty_children
+                | ws empty_children
   node_term: linespaces | semicolon_term
   semicolon_term: SEMICOLON | SEMICOLON linespaces
 
@@ -45,7 +47,7 @@ rule
   property: identifier EQUALS value { [val[0], val[2]] }
 
   value : untyped_value
-        | type untyped_value { val[1].as_type(val[0]) }
+        | type untyped_value { val[1].as_type(val[0], @type_parsers.fetch(val[0], nil)) }
 
   untyped_value : STRING     { KDL::Value::String.new(val[0].value) }
                 | RAWSTRING  { KDL::Value::String.new(val[0].value) }
@@ -57,15 +59,21 @@ rule
   boolean : TRUE  { true }
           | FALSE { false }
 
-  ws_star: none | WS
+  ws: WS | ESCLINE | WS ESCLINE | ESCLINE WS | WS ESCLINE WS
+  ws_star: none | ws
   linespace: WS | NEWLINE | EOF
   linespaces: linespace | linespaces linespace
-  linespace_star: none | linespaces
 
   none: { nil }
 
 ---- inner
-  def parse(str)
+
+  def parse(str, options = {})
+    if options.fetch(:parse_types, true)
+      @type_parsers = ::KDL::Types::MAPPING.merge(options.fetch(:type_parsers, {}))
+    else
+      @type_parsers = {}
+    end
     @tokenizer = ::KDL::Tokenizer.new(str)
     do_parse
   end

data/lib/kdl/node.rb

@@ -2,7 +2,7 @@ module KDL
   class Node
     attr_accessor :name, :arguments, :properties, :children, :type
 
-    def initialize(name, arguments = [], properties = {}, children = nil, type: nil)
+    def initialize(name, arguments = [], properties = {}, children = [], type: nil)
       @name = name
       @arguments = arguments
       @properties = properties
@@ -19,11 +19,9 @@ module KDL
       unless properties.empty?
         s += " #{properties.map { |k, v| "#{id_to_s k}=#{v}" }.join(' ')}"
       end
-      unless children.nil?
+      unless children.empty?
         s += " {\n"
-        unless children.empty?
-          s += children.map { |c| "#{c.to_s(level + 1)}\n" }.join("\n")
-        end
+        s += children.map { |c| "#{c.to_s(level + 1)}\n" }.join("\n")
         s += "#{indent}}"
       end
       s
@@ -38,6 +36,23 @@ module KDL
       children   == other.children
     end
 
+    def as_type(type, parser = nil)
+      if parser.nil?
+        @type = type
+        self
+      else
+        result = parser.call(self, type)
+
+        return self.as_type(type) if result.nil?
+
+        unless result.is_a?(::KDL::Node)
+          raise ArgumentError, "expected parser to return an instance of ::KDL::Node, got `#{result.class}'"
+        end
+
+        result
+      end
+    end
+
     private
 
     def id_to_s(id)

data/lib/kdl/tokenizer.rb

@@ -67,6 +67,7 @@ module KDL
       @line = 1
       @column = 1
       @type_context = false
+      @last_token = nil
     end
 
     def next_token
@@ -124,15 +125,13 @@ module KDL
             end
           when '\\'
             t = Tokenizer.new(@str, @index + 1)
-            la = t.next_token[0]
-            if la == :NEWLINE
-              @index = t.index
-              new_line
-            elsif la == :WS && (lan = t.next_token[0]) == :NEWLINE
+            la = t.next_token
+            if la[0] == :NEWLINE || la[0] == :EOF || (la[0] == :WS && (lan = t.next_token[0]) == :NEWLINE || lan == :EOF)
               @index = t.index
               new_line
+              return token(:ESCLINE, "\\#{la[1].value}")
             else
-              raise_error "Unexpected '\\'"
+              raise_error "Unexpected '\\' (#{la[0]})"
             end
           when *SYMBOLS.keys
             return token(SYMBOLS[c], c).tap { traverse(1) }
@@ -292,18 +291,6 @@ module KDL
           if WHITEPACE.include?(c)
             traverse(1)
             @buffer += c
-          elsif c == "\\"
-            t = Tokenizer.new(@str, @index + 1)
-            la = t.next_token[0]
-            if la == :NEWLINE
-              @index = t.index
-              new_line
-            elsif (la == :WS && (lan = t.next_token[0]) == :NEWLINE)
-              @index = t.index
-              new_line
-            else
-              raise_error "Unexpected '\\'"
-            end
           elsif c == "/" && @str[@index + 1] == '*'
             self.context = :multi_line_comment
             @comment_nesting = 1
@@ -357,7 +344,7 @@ module KDL
     end
 
     def parse_float(s)
-      match, whole, fraction, exponent = *s.match(/^([-+]?[\d_]+)(?:\.(\d+))?(?:[eE]([-+]?[\d_]+))?$/)
+      match, _, fraction, exponent = *s.match(/^([-+]?[\d_]+)(?:\.([\d_]+))?(?:[eE]([-+]?[\d_]+))?$/)
       raise_error "Invalid floating point value #{s}" if match.nil?
 
       s = munch_underscores(s)

data/lib/kdl/types/base64.rb

@@ -0,0 +1,21 @@
+require 'base64'
+
+module KDL
+  module Types
+    class Base64 < Value
+      RGX = /^[A-Za-z0-9+\/=]+$/.freeze
+
+      def self.call(value, type = 'base64')
+        return nil unless value.is_a? ::KDL::Value::String
+
+        unless RGX.match?(value.value)
+            raise ArgumentError, "invalid base64: #{value.value}"
+        end
+
+        data = ::Base64.decode64(value.value)
+        new(data, type: type)
+      end
+    end
+    MAPPING['base64'] = Base64
+  end
+end