tomlrb 1.3.0 → 2.0.4

data/lib/tomlrb/handler.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Tomlrb
   class Handler
     attr_reader :output, :symbolize_keys
@@ -7,17 +9,24 @@ module Tomlrb
       @current = @output
       @stack = []
       @array_names = []
+      @current_table = []
+      @keys = Keys.new
       @symbolize_keys = options[:symbolize_keys]
     end
 
     def set_context(identifiers, is_array_of_tables: false)
+      if identifiers.empty?
+        raise ParseError, 'Array needs a name'
+      end
+
+      @current_table = identifiers.dup
+      @keys.add_table_key identifiers, is_array_of_tables
       @current = @output
 
       deal_with_array_of_tables(identifiers, is_array_of_tables) do |identifierz|
         identifierz.each do |k|
           k = k.to_sym if @symbolize_keys
           if @current[k].is_a?(Array)
-            @current[k] << {} if @current[k].empty?
             @current = @current[k].last
           else
             @current[k] ||= {}
@@ -28,7 +37,6 @@ module Tomlrb
     end
 
     def deal_with_array_of_tables(identifiers, is_array_of_tables)
-      identifiers.map!{|n| n.gsub("\"", '')}
       stringified_identifier = identifiers.join('.')
 
       if is_array_of_tables
@@ -43,20 +51,56 @@ module Tomlrb
       if is_array_of_tables
         last_identifier = last_identifier.to_sym if @symbolize_keys
         @current[last_identifier] ||= []
+        raise ParseError, "Cannot use key #{last_identifier} for both table and array at once" unless @current[last_identifier].respond_to?(:<<)
         @current[last_identifier] << {}
         @current = @current[last_identifier].last
       end
     end
 
     def assign(k)
-      k = k.to_sym if @symbolize_keys
-      @current[k] = @stack.pop
+      @keys.add_pair_key k, @current_table
+      current = @current
+      while (key = k.shift)
+        key = key.to_sym if @symbolize_keys
+        current = assign_key_path(current, key, k.empty?)
+      end
     end
 
     def push(o)
       @stack << o
     end
 
+    def push_inline(inline_arrays)
+      merged_inline = {}
+      keys = Keys.new
+
+      inline_arrays.each do |inline_array|
+        current = merged_inline
+        value = inline_array.pop
+        keys.add_table_key inline_array, value.is_a?(Array)
+
+        inline_array.each_with_index do |inline_key, inline_index|
+          inline_key = inline_key.to_sym if @symbolize_keys
+          last_key = inline_index == inline_array.size - 1
+
+          if last_key
+            if current[inline_key].nil?
+              keys.add_pair_key [inline_key], []
+
+              current[inline_key] = value
+            else
+              raise Key::KeyConflict, "Inline key #{inline_key} is already used"
+            end
+          else
+            current[inline_key] ||= {}
+            current = current[inline_key]
+          end
+        end
+      end
+
+      push(merged_inline)
+    end
+
     def start_(type)
       push([type])
     end
@@ -64,10 +108,172 @@ module Tomlrb
     def end_(type)
       array = []
       while (value = @stack.pop) != [type]
-        raise ParseError, 'Unclosed table' if value.nil?
+        raise ParseError, 'Unclosed table' if @stack.empty?
+
         array.unshift(value)
       end
       array
     end
+
+    def validate_value(value)
+      if value.nil?
+        raise ParseError, 'Value must be present'
+      end
+    end
+
+    private
+
+    def assign_key_path(current, key, key_emptied)
+      existed = current.key?(key)
+      raise ParseError, "Cannot overwrite value with key #{key}" if existed && !current[key].is_a?(Hash)
+      if key_emptied
+        raise ParseError, "Cannot overwrite value with key #{key}" unless current.is_a?(Hash)
+
+        value = @stack.pop
+        raise ParseError, "Cannot overwrite value with key #{key}" if current[key].is_a?(Hash) && !value.is_a?(Hash)
+        current[key] = value
+        return current
+      end
+      current[key] ||= {}
+      current[key]
+    end
+  end
+
+  class Keys
+    def initialize
+      @keys = {}
+    end
+
+    def add_table_key(keys, is_array_of_tables = false)
+      self << [keys, [], is_array_of_tables]
+    end
+
+    def add_pair_key(keys, context)
+      self << [context, keys, false]
+    end
+
+    def <<(keys)
+      table_keys, pair_keys, is_array_of_tables = keys
+      current = @keys
+      current = append_table_keys(current, table_keys, pair_keys.empty?, is_array_of_tables)
+      append_pair_keys(current, pair_keys, table_keys.empty?, is_array_of_tables)
+    end
+
+    private
+
+    def append_table_keys(current, table_keys, pair_keys_empty, is_array_of_tables)
+      table_keys.each_with_index do |key, index|
+        declared = (index == table_keys.length - 1) && pair_keys_empty
+        if index.zero?
+          current = find_or_create_first_table_key(current, key, declared, is_array_of_tables)
+        else
+          current <<= [key, :table, declared, is_array_of_tables]
+        end
+      end
+
+      current.clear_children if is_array_of_tables
+      current
+    end
+
+    def find_or_create_first_table_key(current, key, declared, is_array_of_tables)
+      existed = current[key]
+      if existed && existed.type == :pair
+        raise Key::KeyConflict, "Key #{key} is already used as #{existed.type} key"
+      end
+      if existed && existed.declared? && declared && ! is_array_of_tables
+        raise Key::KeyConflict, "Key #{key} is already used"
+      end
+      k = existed || Key.new(key, :table, declared)
+      k.declared = k.declared? || declared
+      current[key] = k
+      k
+    end
+
+    def append_pair_keys(current, pair_keys, table_keys_empty, is_array_of_tables)
+      pair_keys.each_with_index do |key, index|
+        declared = index == pair_keys.length - 1
+        if index.zero? && table_keys_empty
+          current = find_or_create_first_pair_key(current, key, declared, table_keys_empty)
+        else
+          key = current << [key, :pair, declared, is_array_of_tables]
+          current = key
+        end
+      end
+    end
+
+    def find_or_create_first_pair_key(current, key, declared, table_keys_empty)
+      existed = current[key]
+      if existed && (existed.type == :pair) && declared && table_keys_empty
+        raise Key::KeyConflict, "Key #{key} is already used"
+      end
+      k = Key.new(key, :pair, declared)
+      current[key] = k
+      k
+    end
+  end
+
+  class Key
+    class KeyConflict < ParseError; end
+
+    attr_reader :key, :type
+    attr_writer :declared
+
+    def initialize(key, type, declared = false)
+      @key = key
+      @type = type
+      @declared = declared
+      @children = {}
+    end
+
+    def declared?
+      @declared
+    end
+
+    def <<(key_type_declared)
+      key, type, declared, is_array_of_tables = key_type_declared
+      existed = @children[key]
+      validate_already_declared_as_different_key(type, declared, existed)
+      validate_already_declared_as_non_array_table(type, is_array_of_tables, declared, existed)
+      validate_path_already_created_as_different_type(type, declared, existed)
+      validate_path_already_declared_as_different_type(type, declared, existed)
+      validate_already_declared_as_same_key(declared, existed)
+      @children[key] = existed || self.class.new(key, type, declared)
+    end
+
+    def clear_children
+      @children.clear
+    end
+
+    private
+
+    def validate_already_declared_as_different_key(type, _declared, existed)
+      if existed && existed.declared? && existed.type != type
+        raise KeyConflict, "Key #{existed.key} is already used as #{existed.type} key"
+      end
+    end
+
+    def validate_already_declared_as_non_array_table(type, is_array_of_tables, declared, existed)
+      if declared && type == :table && existed && existed.declared? && !is_array_of_tables
+        raise KeyConflict, "Key #{existed.key} is already used"
+      end
+    end
+
+    def validate_path_already_created_as_different_type(type, declared, existed)
+      if declared && (type == :table) && existed && (existed.type == :pair) && !existed.declared?
+        raise KeyConflict, "Key #{existed.key} is already used as #{existed.type} key"
+      end
+    end
+
+    def validate_path_already_declared_as_different_type(type, declared, existed)
+      if !declared && (type == :pair) && existed && (existed.type == :pair) && existed.declared?
+        raise KeyConflict, "Key #{key} is already used as #{type} key"
+      end
+    end
+
+    def validate_already_declared_as_same_key(declared, existed)
+      if existed && !existed.declared? && declared
+        raise KeyConflict, "Key #{existed.key} is already used as #{existed.type} key"
+      end
+    end
   end
 end

data/lib/tomlrb/local_date.rb

@@ -0,0 +1,36 @@
+# frozen-string-literal: true
+
+require 'forwardable'
+
+module Tomlrb
+  class LocalDate
+    extend Forwardable
+
+    def_delegators :@time, :year, :month, :day
+
+    def initialize(year, month, day)
+      @time = Time.utc(year, month, day, 0, 0, 0)
+      raise ArgumentError, "Invalid Local Date: #{year}-#{month}-#{day}" unless day.to_i == @time.day && month.to_i == @time.month && year.to_i == @time.year
+    end
+
+    # @param offset see {LocalDateTime#to_time}
+    # @return [Time] 00:00:00 of the date
+    def to_time(offset = '-00:00')
+      return @time if offset == '-00:00'
+      Time.new(year, month, day, 0, 0, 0, offset)
+    end
+
+    def to_s
+      @time.strftime('%F')
+    end
+
+    def ==(other)
+      other.is_a?(self.class) &&
+        to_time == other.to_time
+    end
+
+    def inspect
+      "#<#{self.class}: #{self}>"
+    end
+  end
+end

data/lib/tomlrb/local_date_time.rb

@@ -0,0 +1,44 @@
+# frozen-string-literal: true
+
+require 'forwardable'
+
+module Tomlrb
+  class LocalDateTime
+    extend Forwardable
+
+    def_delegators :@time, :year, :month, :day, :hour, :min, :sec, :usec, :nsec
+
+    def initialize(year, month, day, hour, min, sec) # rubocop:disable Metrics/ParameterLists
+      @time = Time.utc(year, month, day, hour, min, sec)
+      raise ArgumentError, "Invalid Local Date-Time: #{year}-#{month}-#{day}T#{hour}:#{min}:#{sec}" unless min.to_i == @time.min && hour.to_i == @time.hour && day.to_i == @time.day && month.to_i == @time.month && year.to_i == @time.year
+
+      @sec = sec
+    end
+
+    # @param offset [String, Symbol, Numeric, nil] time zone offset.
+    #   * when +String+, must be '+HH:MM' format, '-HH:MM' format, 'UTC', 'A'..'I' or 'K'..'Z'. Arguments excluding '+-HH:MM' are supporeted at Ruby >= 2.7.0
+    #   * when +Symbol+, must be +:dst+(for summar time for local) or +:std+(for standard time).
+    #   * when +Numeric+, it is time zone offset in second.
+    #   * when +nil+, local time zone offset is used.
+    # @return [Time]
+    def to_time(offset = '-00:00')
+      return @time if offset == '-00:00'
+      Time.new(year, month, day, hour, min, @sec, offset)
+    end
+
+    def to_s
+      frac = (@sec - sec)
+      frac_str = frac.zero? ? '' : frac.to_s[1..-1]
+      @time.strftime('%FT%T') << frac_str
+    end
+
+    def ==(other)
+      other.is_a?(self.class) &&
+        to_time == other.to_time
+    end
+
+    def inspect
+      "#<#{self.class}: #{self}>"
+    end
+  end
+end

data/lib/tomlrb/local_time.rb

@@ -0,0 +1,41 @@
+# frozen-string-literal: true
+
+require 'forwardable'
+
+module Tomlrb
+  class LocalTime
+    extend Forwardable
+
+    def_delegators :@time, :hour, :min, :sec, :usec, :nsec
+
+    def initialize(hour, min, sec)
+      @time = Time.utc(0, 1, 1, hour, min, sec)
+      raise ArgumentError, "Invalid Local Time: #{hour}-#{min}-#{sec}" unless min.to_i == @time.min && hour.to_i == @time.hour
+      @sec = sec
+    end
+
+    # @param year [Integer]
+    # @param month [Integer]
+    # @param day [Integer]
+    # @param offset see {LocalDateTime#to_time}
+    # @return [Time] the time of the date specified by params
+    def to_time(year, month, day, offset = '-00:00')
+      Time.new(year, month, day, hour, min, @sec, offset)
+    end
+
+    def to_s
+      frac = (@sec - sec)
+      frac_str = frac.zero? ? '' : frac.to_s[1..-1]
+      @time.strftime('%T') << frac_str
+    end
+
+    def ==(other)
+      other.is_a?(self.class) &&
+        @time == other.to_time(0, 1, 1)
+    end
+
+    def inspect
+      "#<#{self.class}: #{self}>"
+    end
+  end
+end

data/lib/tomlrb/parser.rb

@@ -1,4 +1,6 @@
-require "tomlrb/generated_parser"
+# frozen-string-literal: true
+
+require 'tomlrb/generated_parser'
 
 class Tomlrb::Parser < Tomlrb::GeneratedParser
 

data/lib/tomlrb/parser.y

@@ -1,102 +1,226 @@
 class Tomlrb::GeneratedParser
-token IDENTIFIER STRING_MULTI STRING_BASIC STRING_LITERAL_MULTI STRING_LITERAL DATETIME INTEGER FLOAT FLOAT_INF FLOAT_NAN TRUE FALSE
+token IDENTIFIER STRING_MULTI STRING_BASIC STRING_LITERAL_MULTI STRING_LITERAL DATETIME LOCAL_TIME INTEGER NON_DEC_INTEGER FLOAT FLOAT_KEYWORD BOOLEAN NEWLINE EOS
 rule
   expressions
     | expressions expression
+    | expressions EOS
     ;
   expression
     : table
     | assignment
     | inline_table
+    | NEWLINE
     ;
   table
-    : table_start table_continued
+    : table_start table_identifier table_end newlines
+    | table_start table_identifier table_end EOS
+    | table_start table_end newlines
+    | table_start table_end EOS
     ;
   table_start
     : '[' '[' { @handler.start_(:array_of_tables) }
     | '[' { @handler.start_(:table) }
     ;
-  table_continued
-    : ']' ']' { array = @handler.end_(:array_of_tables); @handler.set_context(array, is_array_of_tables: true) }
-    | ']' { array = @handler.end_(:table); @handler.set_context(array) }
-    | table_identifier table_next
     ;
-  table_next
+  table_end
     : ']' ']' { array = @handler.end_(:array_of_tables); @handler.set_context(array, is_array_of_tables: true) }
     | ']' { array = @handler.end_(:table); @handler.set_context(array) }
-    | '.' table_continued
     ;
   table_identifier
-    : IDENTIFIER { @handler.push(val[0]) }
-    | STRING_BASIC { @handler.push(val[0]) }
-    | STRING_LITERAL { @handler.push(val[0]) }
-    | INTEGER { @handler.push(val[0]) }
-    | TRUE { @handler.push(val[0]) }
-    | FALSE { @handler.push(val[0]) }
+    : table_identifier '.' table_identifier_component { @handler.push(val[2]) }
+    | table_identifier '.' FLOAT { val[2].split('.').each { |k| @handler.push(k) } }
+    | FLOAT {
+      keys = val[0].split('.')
+      @handler.start_(:table)
+      keys.each { |key| @handler.push(key) }
+    }
+    | table_identifier_component { @handler.push(val[0]) }
+    ;
+  table_identifier_component
+    : IDENTIFIER
+    | STRING_BASIC { result = StringUtils.replace_escaped_chars(val[0]) }
+    | STRING_LITERAL
+    | INTEGER
+    | NON_DEC_INTEGER
+    | FLOAT_KEYWORD
+    | BOOLEAN
+    | DATETIME { result = val[0][0] }
+    | LOCAL_TIME { result = val[0][0] }
     ;
   inline_table
-    : inline_table_start inline_continued
+    : inline_table_start inline_table_end
+    | inline_table_start inline_continued inline_table_end
     ;
   inline_table_start
     : '{' { @handler.start_(:inline) }
     ;
+  inline_table_end
+    : '}' {
+      array = @handler.end_(:inline)
+      @handler.push_inline(array)
+    }
+    ;
   inline_continued
-    : '}' { array = @handler.end_(:inline); @handler.push(Hash[*array]) }
-    | inline_assignment_key inline_assignment_value inline_next
+    : inline_assignment
+    | inline_assignment inline_next
     ;
   inline_next
-    : '}' {
-      array = @handler.end_(:inline)
-      array.map!.with_index{ |n,i| i.even? ? n.to_sym : n } if @handler.symbolize_keys
-      @handler.push(Hash[*array])
+    : ',' inline_continued
+    ;
+  inline_assignment
+    : inline_assignment_key '=' value {
+      keys = @handler.end_(:inline_keys)
+      @handler.push(keys)
     }
-    | ',' inline_continued
     ;
   inline_assignment_key
-    : IDENTIFIER { @handler.push(val[0]) }
-    ;
-  inline_assignment_value
-    : '=' value
+    : inline_assignment_key '.' assignment_key_component { 
+      @handler.push(val[2]) 
+    }
+    | inline_assignment_key '.' FLOAT { val[2].split('.').each { |k| @handler.push(k) } }
+    | FLOAT {
+      keys = val[0].split('.')
+      @handler.start_(:inline_keys)
+      keys.each { |key| @handler.push(key) }
+    }
+    | assignment_key_component { 
+      @handler.start_(:inline_keys) 
+      @handler.push(val[0]) 
+    }
     ;
   assignment
-    : IDENTIFIER '=' value { @handler.assign(val[0]) }
-    | STRING_BASIC '=' value { @handler.assign(val[0]) }
-    | STRING_LITERAL '=' value { @handler.assign(val[0]) }
-    | INTEGER '=' value { @handler.assign(val[0]) }
-    | TRUE '=' value { @handler.assign(val[0]) }
-    | FALSE '=' value { @handler.assign(val[0]) }
+    : assignment_key '=' value EOS {
+      keys = @handler.end_(:keys)
+      value = keys.pop
+      @handler.validate_value(value)
+      @handler.push(value)
+      @handler.assign(keys)
+    }
+    | assignment_key '=' value NEWLINE {
+      keys = @handler.end_(:keys)
+      value = keys.pop
+      @handler.validate_value(value)
+      @handler.push(value)
+      @handler.assign(keys)
+    }
+    ;
+  assignment_key
+    : assignment_key '.' assignment_key_component { @handler.push(val[2]) }
+    | assignment_key '.' FLOAT { val[2].split('.').each { |k| @handler.push(k) } }
+    | FLOAT {
+      keys = val[0].split('.')
+      @handler.start_(:keys)
+      keys.each { |key| @handler.push(key) }
+    }
+    | assignment_key_component { @handler.start_(:keys); @handler.push(val[0]) }
+    ;
+  assignment_key_component
+    : IDENTIFIER
+    | STRING_BASIC { result = StringUtils.replace_escaped_chars(val[0]) }
+    | STRING_LITERAL
+    | INTEGER
+    | NON_DEC_INTEGER
+    | FLOAT_KEYWORD
+    | BOOLEAN
+    | DATETIME { result = val[0][0] }
+    | LOCAL_TIME { result = val[0][0] }
     ;
   array
-    : start_array array_continued
+    : start_array array_first_value array_values comma end_array
+    | start_array array_first_value array_values end_array
+    | start_array array_first_value comma end_array
+    | start_array array_first_value end_array
+    | start_array end_array
     ;
-  array_continued
-    : ']' { array = @handler.end_(:array); @handler.push(array) }
-    | value array_next
+  array_first_value
+    : newlines non_nil_value
+    | non_nil_value
     ;
-  array_next
-    : ']' { array = @handler.end_(:array); @handler.push(array) }
-    | ',' array_continued
+  array_values
+    : array_values array_value
+    | array_value
+    ;
+  array_value
+    : comma newlines non_nil_value
+    | comma non_nil_value
     ;
   start_array
     : '[' { @handler.start_(:array) }
     ;
+  end_array
+    : newlines ']' { array = @handler.end_(:array); @handler.push(array.compact) }
+    | ']' { array = @handler.end_(:array); @handler.push(array.compact) }
+    ;
+  comma
+    : newlines ','
+    | ','
+    ;
+  newlines
+    : newlines NEWLINE
+    | NEWLINE
+    ;
   value
     : scalar { @handler.push(val[0]) }
     | array
     | inline_table
     ;
+  non_nil_value
+    : non_nil_scalar { @handler.push(val[0]) }
+    | array
+    | inline_table
+    ;
   scalar
     : string
     | literal
     ;
+  non_nil_scalar
+    : string
+    | non_nil_literal
+    ;
   literal
-    | FLOAT { result = val[0].to_f }
-    | FLOAT_INF { result = (val[0][0] == '-' ? -1 : 1) * Float::INFINITY }
-    | FLOAT_NAN { result = Float::NAN }
+    | non_nil_literal
+    ;
+  non_nil_literal
+    : FLOAT { result = val[0].to_f }
+    | FLOAT_KEYWORD {
+      v = val[0]
+      result = if v.end_with?('nan')
+                 Float::NAN
+               else
+                 (v[0] == '-' ? -1 : 1) * Float::INFINITY
+               end
+    }
     | INTEGER { result = val[0].to_i }
-    | TRUE   { result = true }
-    | FALSE  { result = false }
-    | DATETIME { result = Time.new(*val[0])}
+    | NON_DEC_INTEGER {
+      base = case val[0][1]
+             when 'x' then 16
+             when 'o' then 8
+             when 'b' then 2
+             end
+      result = val[0].to_i(base)
+    }
+    | BOOLEAN { result = val[0] == 'true' ? true : false }
+    | DATETIME {
+      _str, year, month, day, hour, min, sec, offset = val[0]
+      result = if offset.nil?
+                 if hour.nil?
+                   LocalDate.new(year, month, day)
+                 else
+                   LocalDateTime.new(year, month, day, hour, min || 0, sec.to_f)
+                 end
+               else
+                 # Patch for 24:00:00 which Ruby parses
+                 if hour.to_i == 24 && min.to_i == 0 && sec.to_i == 0
+                   hour = (hour.to_i + 1).to_s
+                 end
+
+                 time = Time.new(year, month, day, hour || 0, min || 0, sec.to_f, offset)
+                 # Should be out of parser.y?
+                 raise ArgumentError, "Invalid Offset Date-Time: #{year}-#{month}-#{day}T#{hour}:#{min}:#{sec}#{offset}" unless min.to_i == time.min && hour.to_i == time.hour && day.to_i == time.day && month.to_i == time.month && year.to_i == time.year
+                 time
+               end
+    }
+    | LOCAL_TIME { result = LocalTime.new(*val[0][1..-1]) }
     ;
   string
     : STRING_MULTI { result = StringUtils.replace_escaped_chars(StringUtils.multiline_replacements(val[0])) }