toml-rb 4.2.2 → 5.0.0.rc.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cee703f8a66e85b3edc5e6a8bc4011cef1e170dce1ac8f6e6364b4d7952ea189
-  data.tar.gz: ba24eb31557a9411f88e18030f9cccf2a736054a490facb7161698c2f144e408
+  metadata.gz: deb05c1f85b54d08dda1640e125ecdbbeff043acbe1b753b7c537ca9260a8caf
+  data.tar.gz: 5c135ebaab7f60c0c88c3283f5c6a4db5ba6b79e672e362adf81c11becdd2ca7
 SHA512:
-  metadata.gz: 129c26a9e6dbdaaa75818ed6c8fd6aa7d1d0525e99c32d91b2c9923a7f8ddfc6ef4a254061e54d71948bc142dcb0b35b2f98ccd1595a57e874085320e20eb082
-  data.tar.gz: dea826c02f430769b2e760b302192698d83f407c1383d916486edaa97e771692da5de7c467688fbe2e56cffae09e96de42def754c140ba01c890dc82dcc1e926
+  metadata.gz: a33c28b6a6ec07a22260bce3d517374e9f09121e527a36e4319da46f888ab6ed4d8f5b48aebb6c7e3705009b4729e9255764c0fd3c2b4869771263e84ce5f9d9
+  data.tar.gz: b3e67a5f28e98de500e67eac01c921c8e5eb6e2ced829b46942eadf48f79a45f1881dc12a80f48b514efed52b2fdce707f705a2adc3d76d9f332ea30e90c15e1

data/README.md

@@ -11,7 +11,7 @@ toml-rb
 
 A [TOML](https://github.com/toml-lang/toml) parser using [Citrus](http://mjackson.github.io/citrus) library.
 
-TOML specs supported: `1.0.0`
+toml-rb implements [TOML 1.1.0](https://toml.io/en/v1.1.0) and passes all [toml-test](https://github.com/toml-lang/toml-test) v2.2.0 decoder tests for that version.
 
 Installation
 ------------
@@ -42,6 +42,16 @@ TomlRB.parse(stream)
 # You want symbols as your keys? No problem!
 TomlRB.load_file(path, symbolize_keys: true) 
 # Works the same for TomlRB.parse
+
+# Local datetimes, dates and times are subclasses of Time. Offset datetimes are Time.
+times = <<-EOS
+  odt = 1979-05-27T07:32:00Z
+  ldt = 1979-05-27T07:32:00
+  ld  = 1979-05-27
+  lt  = 07:32:00
+EOS
+TomlRB.parse(times).transform_values(&:class)
+# => {"odt"=>Time, "ldt"=>TomlRB::LocalDateTime, "ld"=>TomlRB::LocalDate, "lt"=>TomlRB::LocalTime}
 ```
 
 Dumper Usage
@@ -78,11 +88,13 @@ TOML 1.0.0 and TOML 1.1.0. The harness lives in:
 - `tool/toml-test-decoder` — toml-test decoder shim.
 - `.github/workflows/conformance.yml` — CI workflow (per-version matrix).
 - `.github/toml-test-skip-1.0.txt` and `.github/toml-test-skip-1.1.txt` —
-  skip-lists of currently-failing tests.
+  skip-lists of toml-test names for each spec version.
 
-The skip-lists are a living gap report: every entry is a known limitation in
-the current parser. The goal for v5.0.0 is **empty skip-lists** — full
-conformance against both spec versions.
+The TOML 1.1.0 skip-list is empty. The TOML 1.0.0 skip-list has 9 tests with
+documents that TOML 1.0.0 forbids and TOML 1.1.0 allows. `toml-rb` accepts
+TOML 1.1.0 syntax and has no option to select the spec version, so these tests
+fail. CI runs toml-test with `-skip-must-err`, so the run fails when a skipped
+test passes.
 
 Contributing
 ------------

data/lib/toml-rb/datetime.rb

@@ -1,12 +1,41 @@
+require "date"
+
 module TomlRB
+  LocalDateTime = Class.new(Time)
+  LocalDate = Class.new(Time)
+  LocalTime = Class.new(Time)
+
+  module DateSkeletonParser
+    def value
+      year, mon, day = [:year, :mon, :day].map { |s| capture(s).value }
+      unless Date.valid_date?(year.to_i, mon.to_i, day.to_i, Date::GREGORIAN)
+        raise ParseError, "Invalid date: #{year}-#{mon}-#{day}"
+      end
+      [year, mon, day]
+    end
+  end
+
+  module TimeSkeletonParser
+    def value
+      hour, min, sec = [:hour, :mim, :sec].map { |s| capture(s)&.value || "0" }
+      unless hour.to_i.between?(0, 23) && min.to_i.between?(0, 59) && sec.to_i.between?(0, 60)
+        raise ParseError, "Invalid time: #{hour}:#{min}:#{sec}"
+      end
+      [hour, min, sec, capture(:sec_frac) || "0"]
+    end
+  end
+
   module OffsetDateTimeParser
     def value
       skeleton = captures[:datetime_skeleton].first
       year, mon, day, hour, min, sec, sec_frac = skeleton.value
-      offset = captures[:date_offset].first || "+00:00"
-      sec = "#{sec}.#{sec_frac}".to_f
+      offset = (captures[:date_offset].first || "+00:00").to_s
+      unless offset[1, 2].to_i.between?(0, 23) && offset[4, 2].to_i.between?(0, 59)
+        raise ParseError, "Invalid UTC offset: #{offset}"
+      end
+      sec = "#{sec}.#{sec_frac}".to_r
 
-      Time.new(year, mon, day, hour, min, sec, offset.to_s)
+      Time.new(year, mon, day, hour, min, sec, offset)
     end
   end
 
@@ -14,25 +43,25 @@ module TomlRB
     def value
       year, mon, day = captures[:date_skeleton].first.value
       hour, min, sec, sec_frac = captures[:time_skeleton].first.value
-      usec = sec_frac.to_s.ljust(6, "0")
+      sec = "#{sec}.#{sec_frac}".to_r
 
-      Time.local(year, mon, day, hour, min, sec, usec)
+      LocalDateTime.local(year, mon, day, hour, min, sec)
     end
   end
 
   module LocalDateParser
     def value
       year, mon, day = captures[:date_skeleton].first.value
-      Time.local(year, mon, day)
+      LocalDate.local(year, mon, day)
     end
   end
 
   module LocalTimeParser
     def value
       hour, min, sec, sec_frac = captures[:time_skeleton].first.value
-      usec = sec_frac.to_s.ljust(6, "0")
+      sec = "#{sec}.#{sec_frac}".to_r
 
-      Time.at(3600 * hour.to_i + 60 * min.to_i + sec.to_i, usec.to_i)
+      LocalTime.utc(1970, 1, 1, hour, min, sec)
     end
   end
 end

data/lib/toml-rb/dumper.rb

@@ -41,13 +41,13 @@ module TomlRB
       simple_pairs = []
       table_array_pairs = []
 
-      hash.keys.sort.each do |key|
+      sorted_keys(hash).each do |key|
         val = hash[key]
         element = [key, val]
 
         if val.is_a? Hash
           nested_pairs << element
-        elsif val.is_a?(Array) && val.first.is_a?(Hash)
+        elsif val.is_a?(Array) && !val.empty? && val.all?(Hash)
           table_array_pairs << element
         else
           simple_pairs << element
@@ -57,6 +57,17 @@ module TomlRB
       [simple_pairs, nested_pairs, table_array_pairs]
     end
 
+    def sorted_keys(hash)
+      keys = hash.keys
+      raise Error, "Cannot dump keys with duplicate names: #{keys.inspect}" if keys.map(&:to_s).uniq!
+
+      begin
+        keys.sort
+      rescue ArgumentError
+        keys.sort_by(&:to_s)
+      end
+    end
+
     def dump_pairs(simple, nested, table_array, prefix = [])
       # First add simple pairs, under the prefix
       dump_simple_pairs simple
@@ -101,16 +112,30 @@ module TomlRB
     end
 
     def to_toml(obj)
-      if obj.is_a?(Time) || obj.is_a?(DateTime)
-        obj.strftime("%Y-%m-%dT%H:%M:%SZ")
+      if obj.is_a?(LocalDate)
+        obj.strftime("%Y-%m-%d")
+      elsif obj.is_a?(LocalTime)
+        obj.strftime("%H:%M:%S") + sec_fraction(obj)
+      elsif obj.is_a?(LocalDateTime)
+        obj.strftime("%Y-%m-%dT%H:%M:%S") + sec_fraction(obj)
+      elsif obj.is_a?(Time) || obj.is_a?(DateTime)
+        zone = obj.strftime("%:z").sub("+00:00", "Z")
+        obj.strftime("%Y-%m-%dT%H:%M:%S") + sec_fraction(obj) + zone
       elsif obj.is_a?(Date)
         obj.strftime("%Y-%m-%d")
       elsif obj.is_a?(Regexp)
-        obj.inspect.inspect
-      elsif obj.is_a?(String)
-        escape_string(obj)
+        escape_string(obj.inspect)
+      elsif obj.is_a?(String) || obj.is_a?(Symbol)
+        escape_string(obj.to_s)
       elsif obj.is_a?(Array)
         "[" + obj.map(&method(:to_toml)).join(", ") + "]"
+      elsif obj.is_a?(Hash)
+        pairs = sorted_keys(obj).map do |key|
+          val = obj[key]
+          key = quote_key(key) unless bare_key? key
+          "#{key} = #{to_toml(val)}"
+        end
+        "{" + pairs.join(", ") + "}"
       elsif obj.is_a?(Float) && (obj.nan? || obj.infinite?)
         # Ruby renders these as Infinity/-Infinity/NaN, which are invalid TOML.
         if obj.nan?
@@ -120,8 +145,13 @@ module TomlRB
         else
           "inf"
         end
-      else
+      elsif obj.is_a?(Integer) || obj.is_a?(Float) || obj == true || obj == false
+        obj.inspect
+      elsif defined?(BigDecimal) && obj.is_a?(BigDecimal) && obj.finite?
+        # BigDecimal#inspect is a valid TOML float, for example 0.15e1.
         obj.inspect
+      else
+        raise Error, "Cannot dump #{obj.class} to TOML"
       end
     end
 
@@ -135,7 +165,8 @@ module TomlRB
     end
 
     # Serialize a Ruby string as a TOML basic string. Ruby's String#inspect
-    # emits \a \v \e for 0x07/0x0B/0x1B, which TOML (and this parser) reject.
+    # emits \a and \v, which are not TOML escapes, and \e, which is not a TOML 1.0
+    # escape. Write ESC as \u001B to keep the output valid TOML 1.0.
     def escape_string(str)
       escaped = str.gsub(/[\x00-\x1f\x7f"\\]/) do |char|
         BASIC_ESCAPES[char] || format('\\u%04X', char.ord)
@@ -143,5 +174,9 @@ module TomlRB
 
       "\"#{escaped}\""
     end
+
+    def sec_fraction(time)
+      time.strftime(".%9N").sub(/\.?0+\z/, "")
+    end
   end
 end

data/lib/toml-rb/grammars/document.citrus

@@ -2,19 +2,23 @@ grammar TomlRB::Document
   include TomlRB::Primitive
 
   rule document
-    (comment | table_array | table | keyvalue | line_break)*
+    (comment | table_array | table | keyvalue_line | line_break | trailing_space)*
   end
 
   rule table_array
-    (space? '[[' stripped_key ']]' comment?) <TomlRB::TableArrayParser>
+    (space? '[[' stripped_key ']]' line_end) <TomlRB::TableArrayParser>
   end
 
   rule table
-    (space? '[' stripped_key ']' comment?) <TomlRB::TableParser>
+    (space? '[' stripped_key ']' line_end) <TomlRB::TableParser>
+  end
+
+  rule keyvalue_line
+    (keyvalue line_end) { capture(:keyvalue).value }
   end
 
   rule keyvalue
-    (stripped_key '=' space? v:(toml_values) comment? space) <TomlRB::KeyvalueParser>
+    (stripped_key '=' space? v:(toml_values) space) <TomlRB::KeyvalueParser>
   end
 
   ### Values
@@ -24,7 +28,7 @@ grammar TomlRB::Document
   end
 
   rule array
-    ("[" array_comments (array_elements)? space ","? array_comments "]" indent?) <TomlRB::ArrayParser>
+    ("[" array_comments (array_elements (array_comments ",")?)? array_comments "]") <TomlRB::ArrayParser>
   end
 
   rule array_array
@@ -34,15 +38,21 @@ grammar TomlRB::Document
   end
 
   rule array_elements
-    (toml_values (indent? "," array_comments toml_values)*) {
-      captures[:toml_values].map(&:value).map do |v|
-        v.respond_to?(:value) ? v.value : v
-      end
+    (toml_values (array_comments "," array_comments toml_values)*) {
+      captures[:toml_values].map(&:value)
     }
   end
 
   ### Helpers
 
+  rule line_end
+    (space (comment | line_break | !.))
+  end
+
+  rule trailing_space
+    ([ \t]+ !.) { nil }
+  end
+
   rule stripped_key
     (space? key space?) { captures[:key].first.value }
   end

data/lib/toml-rb/grammars/helper.citrus

@@ -1,6 +1,6 @@
 grammar TomlRB::Helper
   rule comment
-    (space? "#" /[^\n]*/u line_break?) { nil }
+    (space? "#" /[^\x00-\x08\x0a-\x1f\x7f]*(?=\r?\n|\z)/u line_break?) { nil }
   end
 
   rule space

data/lib/toml-rb/grammars/primitive.citrus

@@ -14,19 +14,19 @@ grammar TomlRB::Primitive
   end
 
   rule basic_string
-    (/"(?:[^"\\\n]|\\.)*"/ space) <TomlRB::BasicString>
+    (/"(?:[^"\\\x00-\x08\x0a-\x1f\x7f]|\\.)*"/ space) <TomlRB::BasicString>
   end
 
   rule literal_string
-    (/'[^'\n]*'/ space) <TomlRB::LiteralString>
+    (/'[^'\x00-\x08\x0a-\x1f\x7f]*'/ space) <TomlRB::LiteralString>
   end
 
   rule multiline_string
-    ('"""' line_break* (text:~('"""' !'"')|'') '"""' space) <TomlRB::MultilineString>
+    ('"""' /\r?\n/? text:/(?:[^"\\\x00-\x08\x0b-\x1f\x7f]|\r\n|\\(?:[^\r]|\r\n)|"{1,2}(?!"))*"{0,2}(?=""")/ '"""' space) <TomlRB::MultilineString>
   end
 
   rule multiline_literal
-    ("'''" line_break* (text:~("'''" !"'")|'') "'''" space) <TomlRB::MultilineLiteral>
+    ("'''" /\r?\n/? text:/(?:[^'\x00-\x08\x0b-\x1f\x7f]|\r\n|'{1,2}(?!'))*'{0,2}(?=''')/ "'''" space) <TomlRB::MultilineLiteral>
   end
 
   ##
@@ -38,7 +38,7 @@ grammar TomlRB::Primitive
   end
 
   rule offset_datetime
-    ( skeleton:datetime_skeleton ("Z" | date_offset) ) <TomlRB::OffsetDateTimeParser>
+    ( skeleton:datetime_skeleton ([Zz] | date_offset) ) <TomlRB::OffsetDateTimeParser>
   end
 
   rule local_datetime
@@ -54,21 +54,17 @@ grammar TomlRB::Primitive
   end
 
   rule datetime_skeleton
-    (date_skeleton ("T"|" ") time_skeleton) {
+    (date_skeleton ([Tt]|" ") time_skeleton) {
       capture(:date_skeleton).value + capture(:time_skeleton).value
     }
   end
 
   rule date_skeleton
-    (year:/\d\d\d\d/ "-" mon:/\d\d/ "-" day:/\d\d/) {
-      [:year,:mon,:day].map{ |s| capture(s).value }
-    }
+    (year:/\d\d\d\d/ "-" mon:/\d\d/ "-" day:/\d\d/) <TomlRB::DateSkeletonParser>
   end
 
   rule time_skeleton
-    ( hour:([0-2][0-9]) ":" mim:([0-6][0-9]) ":" sec:([0-6][0-9])  ([,\.] sec_frac:(/\d/1*6))? ) {
-      [:hour,:mim,:sec].map{ |s| capture(s).value } + [capture(:sec_frac) || '0']
-    }
+    ( hour:([0-2][0-9]) ":" mim:([0-6][0-9]) (":" sec:([0-6][0-9])  ("." sec_frac:(/\d/1*9) /\d/*)?)? ) <TomlRB::TimeSkeletonParser>
   end
 
   rule date_offset
@@ -99,7 +95,11 @@ grammar TomlRB::Primitive
   end
 
   rule exponential_float
-    ((fractional_float | decimal_integer) [eE] decimal_integer) { to_str.to_f }
+    ((fractional_float | decimal_integer) [eE] exponent) { to_str.to_f }
+  end
+
+  rule exponent
+    sign? [0-9] ([0-9] | '_' [0-9])*
   end
 
   rule fractional_float
@@ -125,7 +125,7 @@ grammar TomlRB::Primitive
   end
 
   rule decimal_integer
-    (sign? [0-9] ([0-9] | '_' [0-9])*) { to_str.to_i }
+    (sign? ('0' | [1-9] ([0-9] | '_' [0-9])*)) { to_str.to_i }
   end
 
   rule sign

data/lib/toml-rb/inline_table.rb

@@ -10,10 +10,8 @@ module TomlRB
 
     def value(symbolize_keys = false)
       result = {}
-      @pairs.each do |kv|
-        update = kv.assign({}, [], symbolize_keys)
-        result.merge!(update) { |key, _, _| fail ValueOverwriteError.new(key) }
-      end
+      tables = {}.compare_by_identity
+      @pairs.each { |kv| kv.assign(result, tables, symbolize_keys) }
       result
     end
   end

data/lib/toml-rb/keyvalue.rb

@@ -10,36 +10,23 @@ module TomlRB
       @symbolize_keys = false
     end
 
-    def assign(hash, fully_defined_paths, symbolize_keys = false)
+    def assign(hash, tables, symbolize_keys = false)
       @symbolize_keys = symbolize_keys
-      keys = symbolize_keys ? @dotted_keys.map(&:to_sym) : @dotted_keys
-      depth = @dotted_keys.size
-      update = keys.reverse.inject(visit_value(@value)) { |k1, k2| {k2 => k1} }
+      *keys, last_key = symbolize_keys ? @dotted_keys.map(&:to_sym) : @dotted_keys
 
-      parent_inline_table = fully_defined_paths.find { |k| k.size < depth && @dotted_keys.first(k.size) == k }
-      fail ValueOverwriteError.new(@dotted_keys.first) if parent_inline_table
-
-      if @value.is_a?(InlineTable)
-        child_keys_exist = fully_defined_paths.find { |k| k.size > depth && k.first(depth) == @dotted_keys }
-        fail ValueOverwriteError.new(@dotted_keys.first) if child_keys_exist
-
-        existing_hash = hash.dig(*keys)
-        fail ValueOverwriteError.new(@dotted_keys.first) if existing_hash.is_a?(Hash) && !existing_hash.empty?
+      keys.each do |key|
+        unless hash.key?(key)
+          hash[key] = {}
+          tables[hash[key]] = :dotted
+        end
+        hash = hash[key]
+        fail ValueOverwriteError.new(key) unless [:implicit, :dotted].include?(tables[hash])
 
-        fully_defined_paths << @dotted_keys
+        tables[hash] = :dotted
       end
+      fail ValueOverwriteError.new(last_key) if hash.key?(last_key)
 
-      dotted_key_merge(hash, update)
-    end
-
-    def dotted_key_merge(hash, update)
-      hash.merge!(update) do |key, old, new|
-        if old.is_a?(Hash) && new.is_a?(Hash)
-          dotted_key_merge(old, new)
-        else
-          fail ValueOverwriteError.new(key)
-        end
-      end
+      hash[last_key] = visit_value(@value)
     end
 
     def accept_visitor(parser)
@@ -49,6 +36,7 @@ module TomlRB
     private
 
     def visit_value(a_value)
+      return a_value.map { |v| visit_value(v) } if a_value.is_a?(Array)
       return a_value unless a_value.respond_to? :accept_visitor
 
       a_value.accept_visitor self

data/lib/toml-rb/parser.rb

@@ -4,8 +4,10 @@ module TomlRB
 
     def initialize(content, symbolize_keys: false)
       @hash = {}
-      @visited_keys = []
-      @fully_defined_paths = []
+      # Tables and arrays of tables that headers or dotted keys made, by identity:
+      # :implicit (super-table of a header), :explicit (header) or :dotted (dotted key).
+      # Inline tables and static arrays are absent, so no header or dotted key can enter them.
+      @tables = {}.compare_by_identity
       @current = @hash
       @symbolize_keys = symbolize_keys
 
@@ -28,20 +30,15 @@ module TomlRB
     # Read about the Visitor pattern
     # http://en.wikipedia.org/wiki/Visitor_pattern
     def visit_table_array(table_array)
-      @fully_defined_paths = []
-      table_array_key = table_array.full_key
-      @visited_keys.reject! { |k| k.start_with? table_array_key }
-
-      @current = table_array.navigate_keys @hash, @symbolize_keys
+      @current = table_array.navigate_keys @hash, @tables, @symbolize_keys
     end
 
     def visit_table(table)
-      @fully_defined_paths = []
-      @current = table.navigate_keys @hash, @visited_keys, @symbolize_keys
+      @current = table.navigate_keys @hash, @tables, @symbolize_keys
     end
 
     def visit_keyvalue(keyvalue)
-      keyvalue.assign @current, @fully_defined_paths, @symbolize_keys
+      keyvalue.assign @current, @tables, @symbolize_keys
     end
   end
 end

data/lib/toml-rb/string.rb

@@ -2,9 +2,9 @@ module TomlRB
   # Used in primitive.citrus
   module BasicString
     SPECIAL_CHARS = {
-      "\\0" => "\0",
       "\\t" => "\t",
       "\\b" => "\b",
+      "\\e" => "\e",
       "\\f" => "\f",
       "\\n" => "\n",
       "\\r" => "\r",
@@ -21,12 +21,19 @@ module TomlRB
     # Replace the unicode escaped characters with the corresponding character
     # e.g. \u03B4 => ?
     def self.decode_unicode(str)
-      [str[2..-1].to_i(16)].pack("U")
+      code = str[2..-1].to_i(16)
+      if code.between?(0xD800, 0xDFFF) || code > 0x10FFFF
+        fail ParseError.new "Escape sequence #{str} is not a Unicode scalar value"
+      end
+
+      [code].pack("U")
     end
 
     def self.transform_escaped_chars(str)
-      str.gsub(/\\(u[\da-fA-F]{4}|U[\da-fA-F]{8}|.)/) do |m|
-        if m.size == 2
+      str.gsub(/\\(x[\da-fA-F]{2}|u[\da-fA-F]{4}|U[\da-fA-F]{8}|[ \t]*\r?\n[ \t\r\n]*|.)/) do |m|
+        if m.include?("\n")
+          ""
+        elsif m.size == 2
           SPECIAL_CHARS[m] || parse_error(m)
         else
           decode_unicode(m).force_encoding("UTF-8")
@@ -47,22 +54,13 @@ module TomlRB
 
   module MultilineString
     def value
-      return "" if captures[:text].empty?
-      aux = captures[:text].first.value
-
-      # Remove spaces on multilined Singleline strings
-      aux.gsub!(/\\\r?\n[\n\t\r ]*/, "")
-
-      TomlRB::BasicString.transform_escaped_chars aux
+      TomlRB::BasicString.transform_escaped_chars captures[:text].first.value
     end
   end
 
   module MultilineLiteral
     def value
-      return "" if captures[:text].empty?
-      aux = captures[:text].first.value
-
-      aux.gsub(/\\\r?\n[\n\t\r ]*/, "")
+      captures[:text].first.value
     end
   end
 end

data/lib/toml-rb/table.rb

@@ -4,24 +4,22 @@ module TomlRB
       @dotted_keys = dotted_keys
     end
 
-    def navigate_keys(hash, visited_keys, symbolize_keys = false)
-      ensure_key_not_defined(visited_keys)
+    def navigate_keys(hash, tables, symbolize_keys = false)
       current = hash
       keys = symbolize_keys ? @dotted_keys.map(&:to_sym) : @dotted_keys
-      keys.each_with_index do |key, index|
-        current[key] = {} unless current.key?(key)
-        element = current[key]
-
-        # If this is the final key and it's already an array (from [[key]]), that's invalid
-        is_final_key = (index == keys.length - 1)
-        if is_final_key && element.is_a?(Array)
-          fail ValueOverwriteError.new(key)
+      keys.each do |key|
+        unless current.key?(key)
+          current[key] = {}
+          tables[current[key]] = :implicit
         end
+        element = current[key]
+        fail ValueOverwriteError.new(key) unless tables.key?(element)
 
         current = element.is_a?(Array) ? element.last : element
-        # check that key has not been defined before as a scalar value
-        fail ValueOverwriteError.new(key) unless current.is_a?(Hash)
       end
+      fail ValueOverwriteError.new(full_key) unless tables[current] == :implicit
+
+      tables[current] = :explicit
       current
     end
 
@@ -32,14 +30,6 @@ module TomlRB
     def full_key
       @dotted_keys.join(".")
     end
-
-    private
-
-    # Fail if the key was already defined with a ValueOverwriteError
-    def ensure_key_not_defined(visited_keys)
-      fail ValueOverwriteError.new(full_key) if visited_keys.include?(full_key)
-      visited_keys << full_key
-    end
   end
 
   # Used in document.citrus

data/lib/toml-rb/table_array.rb

@@ -4,21 +4,20 @@ module TomlRB
       @dotted_keys = dotted_keys
     end
 
-    def navigate_keys(hash, symbolize_keys = false)
+    def navigate_keys(hash, tables, symbolize_keys = false)
       current = hash
-      keys = symbolize_keys ? @dotted_keys.map(&:to_sym) : @dotted_keys
-      last_key = keys.pop
+      *keys, last_key = symbolize_keys ? @dotted_keys.map(&:to_sym) : @dotted_keys
 
       # Go over the parent keys
       keys.each do |key|
-        current[key] = {} unless current[key]
-
-        if current[key].is_a? Array
-          current[key] << {} if current[key].empty?
-          current = current[key].last
-        else
-          current = current[key]
+        unless current.key?(key)
+          current[key] = {}
+          tables[current[key]] = :implicit
         end
+        element = current[key]
+        fail ValueOverwriteError.new(key) unless tables.key?(element)
+
+        current = element.is_a?(Array) ? element.last : element
       end
 
       # Define Table Array
@@ -26,19 +25,20 @@ module TomlRB
         fail TomlRB::ParseError,
           "#{last_key} was defined as hash but is now redefined as a table!"
       end
-      current[last_key] = [] unless current[last_key]
-      current[last_key] << {}
+      unless current.key?(last_key)
+        current[last_key] = []
+        tables[current[last_key]] = :explicit
+      end
+      fail ValueOverwriteError.new(last_key) unless tables.key?(current[last_key])
 
+      current[last_key] << {}
+      tables[current[last_key].last] = :explicit
       current[last_key].last
     end
 
     def accept_visitor(parser)
       parser.visit_table_array self
     end
-
-    def full_key
-      @dotted_keys.join(".")
-    end
   end
 
   # Used in document.citrus

data/lib/toml-rb/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TomlRB
-  VERSION = "4.2.2"
+  VERSION = "5.0.0.rc.1"
 end

data/lib/toml-rb.rb

@@ -67,7 +67,7 @@ module TomlRB
   # Raises Errno::ENOENT if the file cannot be found.
   # Raises Errno::EACCES if the file cannot be accessed.
   def self.load_file(path, symbolize_keys: false)
-    TomlRB.parse(File.read(path), symbolize_keys: symbolize_keys)
+    TomlRB.parse(File.read(path, encoding: "UTF-8"), symbolize_keys: symbolize_keys)
   end
 
   # Public: Returns a *TomlRB* string from a Ruby Hash.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: toml-rb
 version: !ruby/object:Gem::Version
-  version: 4.2.2
+  version: 5.0.0.rc.1
 platform: ruby
 authors:
 - Emiliano Mancuso
@@ -30,20 +30,6 @@ dependencies:
     - - ">"
       - !ruby/object:Gem::Version
         version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: racc
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.7'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.7'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement