kdl 1.0.6 → 2.0.1

data/lib/kdl/kdl.yy

@@ -1,7 +1,6 @@
 class KDL::Parser
   options no_result_var
-  token IDENT
-        STRING RAWSTRING
+  token IDENT STRING RAWSTRING
         INTEGER FLOAT TRUE FALSE NULL
         WS NEWLINE
         LBRACE RBRACE
@@ -10,57 +9,66 @@ class KDL::Parser
         SEMICOLON
         EOF
         SLASHDASH
-        ESCLINE
 rule
-  document  : nodes { KDL::Document.new(val[0]) }
-            | linespaces { KDL::Document.new([])}
+  document  : nodes { @output_module::Document.new(val[0]) }
+            | linespaces { @output_module::Document.new([]) }
 
-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
+  nodes          : none                        { [] }
+                 | linespaces node             { [val[1]] }
+                 | linespaces empty_node       { [] }
+                 | nodes node                  { [*val[0], val[1]] }
+                 | nodes empty_node            { val[0] }
+  node           : unterm_node node_term       { val[0] }
+  unterm_node    : untyped_node      { val[0] }
+                 | type untyped_node { val[1].as_type(val[0], @type_parsers.fetch(val[0], nil)) }
+  untyped_node   : node_decl                                                       { val[0].tap { |x| x.children = [] } }
+                 | node_decl ws_plus node_children                                 { val[0].tap { |x| x.children = val[2] } }
+                 | node_decl ws_plus empty_childrens                               { val[0].tap { |x| x.children = [] } }
+                 | node_decl ws_plus empty_childrens node_children                 { val[0].tap { |x| x.children = val[3] } }
+                 | node_decl ws_plus node_children empty_childrens                 { val[0].tap { |x| x.children = val[2] } }
+                 | node_decl ws_plus empty_childrens node_children empty_childrens { val[0].tap { |x| x.children = val[3] } }
+  node_decl      : identifier                           { @output_module::Node.new(val[0]) }
+                 | node_decl ws_plus value              { val[0].tap { |x| x.arguments << val[2] } }
+                 | node_decl ws_plus slashdash value    { val[0] }
+                 | node_decl ws_plus property           { val[0].tap { |x| x.properties[val[2][0]] = val[2][1] } }
+                 | node_decl ws_plus slashdash property { val[0] }
+                 | node_decl ws_plus                    { val[0] }
+  empty_node     : slashdash node
+  node_children  : ws_star LBRACE nodes RBRACE                          { val[2] }
+                 | ws_star LBRACE linespaces RBRACE                     { [] }
+                 | ws_star LBRACE nodes unterm_node ws_star RBRACE      { [*val[2], val[3]] }
+                 | ws_star LBRACE linespaces unterm_node ws_star RBRACE { [val[3]] }
+  empty_children : slashdash node_children
+                 | ws_plus empty_children
+  empty_childrens: empty_children | empty_childrens empty_children
   node_term: linespaces | semicolon_term
   semicolon_term: SEMICOLON | SEMICOLON linespaces
+  slashdash: SLASHDASH | slashdash linespaces
 
-  type : LPAREN identifier RPAREN { val[1] }
+  type : LPAREN ws_star identifier ws_star RPAREN ws_star { val[2] }
 
-  identifier: IDENT     { val[0].value }
-            | STRING    { val[0].value }
-            | RAWSTRING { val[0].value }
+  identifier : IDENT     { val[0].value }
+             | STRING    { val[0].value }
+             | RAWSTRING { val[0].value }
 
-  property: identifier EQUALS value { [val[0], val[2]] }
+  property : identifier EQUALS value { [val[0], val[2]] }
 
   value : untyped_value
         | 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) }
-                | INTEGER    { KDL::Value::Int.new(val[0].value) }
-                | FLOAT      { KDL::Value::Float.new(val[0].value, format: val[0].meta[:format]) }
-                | boolean    { KDL::Value::Boolean.new(val[0]) }
-                | NULL       { KDL::Value::Null }
+  untyped_value : IDENT      { @output_module::Value::String.new(val[0].value) }
+                | STRING     { @output_module::Value::String.new(val[0].value) }
+                | RAWSTRING  { @output_module::Value::String.new(val[0].value) }
+                | INTEGER    { @output_module::Value::Int.new(val[0].value) }
+                | FLOAT      { @output_module::Value::Float.new(val[0].value, format: val[0].meta[:format]) }
+                | boolean    { @output_module::Value::Boolean.new(val[0]) }
+                | NULL       { @output_module::Value::Null }
 
   boolean : TRUE  { true }
           | FALSE { false }
 
-  ws: WS | ESCLINE | WS ESCLINE | ESCLINE WS | WS ESCLINE WS
-  ws_star: none | ws
+  ws_plus: WS | WS ws_plus
+  ws_star: none | ws_plus
   linespace: WS | NEWLINE | EOF
   linespaces: linespace | linespaces linespace
 
@@ -68,18 +76,18 @@ nodes           : none                      { [] }
 
 ---- inner
 
-  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
+  include KDL::ParserCommon
+
+  def initialize(**options)
+    init(**options)
   end
 
-  private
+  def parser_version
+    2
+  end
 
-  def next_token
-    @tokenizer.next_token
+  def parse(str)
+    @tokenizer = ::KDL::Tokenizer.new(str)
+    check_version
+    do_parse
   end

data/lib/kdl/node.rb

@@ -1,32 +1,116 @@
+# frozen_string_literal: true
+
 module KDL
   class Node
+    class Custom < Node
+      def self.call(node, type)
+        new(node.name, arguments: node.arguments, properties: node.properties, children: node.children, type:)
+      end
+
+      def version
+        nil
+      end
+
+      def to_v1
+        self
+      end
+
+      def to_v2
+        self
+      end
+    end
+
+    include Enumerable
+
     attr_accessor :name, :arguments, :properties, :children, :type
 
-    def initialize(name, arguments = [], properties = {}, children = [], type: nil)
+    def initialize(name, _args = [], _props = {}, _children = [],
+      arguments: _args,
+      properties: _props,
+      children: _children,
+      type: nil
+    )
       @name = name
       @arguments = arguments
-      @properties = properties
+      @properties = properties.transform_keys(&:to_s)
       @children = children
       @type = type
     end
 
-    def to_s(level = 0)
+    def [](key)
+      case key
+      when Integer
+        arguments[key]&.value
+      when String, Symbol
+        properties[key.to_s]&.value
+      else
+        raise ArgumentError, "node can only be indexed by Integer, String, or Symbol"
+      end
+    end
+
+    def child(key)
+      case key
+      when Integer
+        children[key]
+      when String, Symbol
+        children.find { _1.name == key.to_s }
+      else
+        raise ArgumentError, "node can only be indexed by Integer, String, or Symbol"
+      end
+    end
+
+    def arg(key)
+      child(key)&.arguments&.first&.value
+    end
+
+    def args(key)
+      child(key)&.arguments&.map(&:value)
+    end
+
+    def each_arg(key, &block)
+      args(key)&.each(&block)
+    end
+
+    def dash_vals(key)
+      child(key)
+        &.children
+        &.select { _1.name == "-" }
+        &.map { _1.arguments.first&.value }
+    end
+
+    def each_dash_val(key, &block)
+      dash_vals(key)&.each(&block)
+    end
+
+    def each(&block)
+      children.each(&block)
+    end
+
+    def <=>(other)
+      name <=> other.name
+    end
+
+    def to_s(level = 0, m = :to_s)
       indent = '    ' * level
-      s = "#{indent}#{type ? "(#{id_to_s type})" : ''}#{id_to_s name}"
+      s = "#{indent}#{type ? "(#{id_to_s type, m })" : ''}#{id_to_s name, m}"
       unless arguments.empty?
-        s += " #{arguments.map(&:to_s).join(' ')}"
+        s << " #{arguments.map(&m).join(' ')}"
       end
       unless properties.empty?
-        s += " #{properties.map { |k, v| "#{id_to_s k}=#{v}" }.join(' ')}"
+        s << " #{properties.map { |k, v| "#{id_to_s k, m}=#{v.public_send(m)}" }.join(' ')}"
       end
       unless children.empty?
-        s += " {\n"
-        s += children.map { |c| "#{c.to_s(level + 1)}\n" }.join("\n")
-        s += "#{indent}}"
+        s << " {\n"
+        s << children.map { |c| "#{c.public_send(m, level + 1)}" }.join("\n")
+        s << "\n#{indent}}"
       end
       s
     end
 
+    def inspect(level = 0)
+      to_s(level, :inspect)
+    end
+
     def ==(other)
       return false unless other.is_a?(Node)
 
@@ -45,18 +129,37 @@ module KDL
 
         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}'"
+        unless result.is_a?(::KDL::Node::Custom)
+          raise ArgumentError, "expected parser to return an instance of ::KDL::Node::Custom, got `#{result.class}'"
         end
 
         result
       end
     end
 
+    def version
+      2
+    end
+
+    def to_v2
+      self
+    end
+
+    def to_v1
+      ::KDL::V1::Node.new(name,
+        arguments: arguments.map(&:to_v1),
+        properties: properties.transform_values(&:to_v1),
+        children: children.map(&:to_v1),
+        type: type
+      )
+    end
+
     private
 
-    def id_to_s(id)
-      StringDumper.stringify_identifier(id)
+    def id_to_s(id, m = :to_s)
+      return id.public_send(m) unless m == :to_s
+
+      StringDumper.call(id.to_s)
     end
   end
 end

data/lib/kdl/parser_common.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module KDL
+  module ParserCommon
+
+    private
+
+    def init(parse_types: true, type_parsers: {}, output_module: ::KDL)
+      @output_module = output_module
+      if parse_types
+        @type_parsers = ::KDL::Types::MAPPING.merge(type_parsers)
+      else
+        @type_parsers = {}
+      end
+    end
+
+    def next_token
+      @tokenizer.next_token
+    end
+
+    def check_version
+      return unless doc_version = @tokenizer.version_directive
+      if doc_version != parser_version
+        raise VersionMismatchError.new("Version mismatch, document specified v#{doc_version}, but this is a v#{parser_version} parser", doc_version, parser_version)
+      end
+    end
+  end
+end

data/lib/kdl/string_dumper.rb

@@ -1,45 +1,44 @@
+# frozen_string_literal: true
+
 module KDL
   module StringDumper
-    class << self
-      def call(string)
-        %("#{string.each_char.map { |char| escape(char) }.join}")
-      end
+    def call(string)
+      return string if bare_identifier?(string)
 
-      def stringify_identifier(ident)
-        if bare_identifier?(ident)
-          ident
-        else
-          call(ident)
-        end
-      end
+      %("#{string.each_char.map { |char| escape(char) }.join}")
+    end
 
-      private
+    private
 
-      def print?(char)
-        ' ' <= char && char <= '\x7e'
-      end
-
-      def escape(char)
-        case char
-        when "\n" then '\n'
-        when "\r" then '\r'
-        when "\t" then '\t'
-        when '\\' then '\\\\'
-        when '"' then '\"'
-        when "\b" then '\b'
-        when "\f" then '\f'
-        else char
-        end
+    def escape(char)
+      case char
+      when "\n" then '\n'
+      when "\r" then '\r'
+      when "\t" then '\t'
+      when '\\' then '\\\\'
+      when '"' then '\"'
+      when "\b" then '\b'
+      when "\f" then '\f'
+      else char
       end
+    end
 
-      def unicode_escape(char)
-        "\\u{#{char.codepoints.first.to_s(16)}}"
-      end
+    FORBIDDEN =
+      Tokenizer::SYMBOLS.keys +
+      Tokenizer::WHITESPACE +
+      Tokenizer::NEWLINES +
+      "()[]/\\\"#".chars +
+      ("\x0".."\x20").to_a
 
-      def bare_identifier?(name)
-        escape_chars = '\\\/(){}<>;\[\]=,"'
-        name =~ /^([^0-9\-+\s#{escape_chars}][^\s#{escape_chars}]*|[\-+](?!true|false|null)[^0-9\s#{escape_chars}][^\s#{escape_chars}]*)$/
+    def bare_identifier?(name)
+      case name
+      when '', 'true', 'fase', 'null', '#true', '#false', '#null', /\A\.?\d/
+        false
+      else
+        !name.each_char.any? { |c| FORBIDDEN.include?(c) }
       end
     end
+
+    extend self
   end
 end