toml-rb 4.2.1 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6d198202b34da88436ce3d0e3cb8841bc1a6ff433a0d9397303c0870c6fed1d5
-  data.tar.gz: 916c15730aebc6974a1e7fd04e7c793a3b1321312657f370cae8c9c0a63e6f54
+  metadata.gz: d7514edd12c127a9f4ff3343e7590d4e526a15ebf3b13594d4d9683aea9fa1d0
+  data.tar.gz: a689fab092b24d2aadcecd046462af6d0cc741cdec8d4461372c65f6d249411b
 SHA512:
-  metadata.gz: acf22dc79ffa1f4b4650e1979eaf7b3d3a04bc894c68e752008e87dbdf695d5ab4ad2c4e835b8d7a5b0aab151c802cd6cfc403ecd361a2cad125c32cf2cb42b3
-  data.tar.gz: 1bdedac516138288dcb97ce4cf59153d03d5fdc8f48a93eca7afbd3ab2931f9ca1dd73eb104decca1e1a6bc7dbc3771d575cfe6a81429e3590e3f41d4048c959
+  metadata.gz: e58611d93fbb27112dd505c43edc135500661c088e33cae0b50d6419bf30f814c94d389cc3a71f85072996a61492e74b9b9e9fce00477df5c3cd8e14691980a4
+  data.tar.gz: 4c5dff3f4537f96ba315410482dee6100463538be2cefe8c19fd8a1fcbce0db614870c9b0e83d52bc269fce28ef9872e8d9b78317b25fcae1b92a12b28c20cca

data/README.md

@@ -9,15 +9,19 @@ toml-rb
 [![Code Climate](https://codeclimate.com/github/emancu/toml-rb/badges/gpa.svg)](https://codeclimate.com/github/emancu/toml-rb)
 [![RubyGem](https://img.shields.io/gem/dt/toml-rb.svg)](https://rubygems.org/gems/toml-rb)
 
-A [TOML](https://github.com/toml-lang/toml) parser using [Citrus](http://mjackson.github.io/citrus) library.
+A pure Ruby [TOML](https://github.com/toml-lang/toml) parser and dumper with no runtime dependencies.
 
-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
 ------------
 
     $ gem install toml-rb
 
+Or add this line to your Gemfile:
+
+    gem "toml-rb", "~> 6.0"
+
 Parser Usage
 ------------
 
@@ -42,6 +46,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 +92,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,38 +1,54 @@
+require "date"
+
 module TomlRB
-  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
-
-      Time.new(year, mon, day, hour, min, sec, offset.to_s)
+  LocalDateTime = Class.new(Time)
+  LocalDate = Class.new(Time)
+  LocalTime = Class.new(Time)
+
+  module DatetimeParser
+    module_function
+
+    def offset_datetime(year, mon, day, hour, min, sec, sec_frac, offset)
+      validate_date(year, mon, day)
+      validate_time(hour, min, sec)
+      offset = "+00:00" if offset.casecmp?("Z")
+      unless offset[1, 2].to_i.between?(0, 23) && offset[4, 2].to_i.between?(0, 59)
+        raise ParseError, "Invalid UTC offset: #{offset}"
+      end
+
+      Time.new(year, mon, day, hour, min, seconds(sec, sec_frac), offset)
     end
-  end
 
-  module LocalDateTimeParser
-    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")
+    def local_datetime(year, mon, day, hour, min, sec, sec_frac)
+      validate_date(year, mon, day)
+      validate_time(hour, min, sec)
+      LocalDateTime.utc(year, mon, day, hour, min, seconds(sec, sec_frac))
+    end
 
-      Time.local(year, mon, day, hour, min, sec, usec)
+    def local_date(year, mon, day)
+      validate_date(year, mon, day)
+      LocalDate.utc(year, mon, day)
     end
-  end
 
-  module LocalDateParser
-    def value
-      year, mon, day = captures[:date_skeleton].first.value
-      Time.local(year, mon, day)
+    def local_time(hour, min, sec, sec_frac)
+      validate_time(hour, min, sec)
+      LocalTime.utc(1970, 1, 1, hour, min, seconds(sec, sec_frac))
     end
-  end
 
-  module LocalTimeParser
-    def value
-      hour, min, sec, sec_frac = captures[:time_skeleton].first.value
-      usec = sec_frac.to_s.ljust(6, "0")
+    def validate_date(year, mon, day)
+      unless Date.valid_date?(year.to_i, mon.to_i, day.to_i, Date::GREGORIAN)
+        raise ParseError, "Invalid date: #{year}-#{mon}-#{day}"
+      end
+    end
+
+    def validate_time(hour, min, sec)
+      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 || 0}"
+      end
+    end
 
-      Time.at(3600 * hour.to_i + 60 * min.to_i + sec.to_i, usec.to_i)
+    def seconds(sec, sec_frac)
+      "#{sec || 0}.#{sec_frac || 0}".to_r
     end
   end
 end

data/lib/toml-rb/dumper.rb

@@ -19,7 +19,7 @@ module TomlRB
     attr_reader :toml_str
 
     def initialize(hash)
-      @toml_str = ""
+      @toml_str = +""
 
       visit(hash, [])
     end
@@ -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
@@ -67,7 +78,7 @@ module TomlRB
     def dump_simple_pairs(simple_pairs)
       simple_pairs.each do |key, val|
         key = quote_key(key) unless bare_key? key
-        @toml_str += "#{key} = #{to_toml(val)}\n"
+        @toml_str << "#{key} = #{to_toml(val)}\n"
       end
     end
 
@@ -97,20 +108,34 @@ module TomlRB
       new_prefix = prefix.join(".")
       new_prefix = "[" + new_prefix + "]" if extra_brackets
 
-      @toml_str += "[" + new_prefix + "]\n"
+      @toml_str << "[" + new_prefix + "]\n"
     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/inline_table.rb

@@ -10,17 +10,9 @@ 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
-
-  module InlineTableParser
-    def value
-      TomlRB::InlineTable.new(captures[:keyvalue].map(&:value))
-    end
-  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,16 +36,10 @@ 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
     end
   end
-
-  # Used in document.citrus
-  module KeyvalueParser
-    def value
-      TomlRB::Keyvalue.new(capture(:stripped_key).value, capture(:v).value)
-    end
-  end
 end

data/lib/toml-rb/parser.rb

@@ -1,19 +1,38 @@
+# frozen_string_literal: true
+
+require "strscan"
+
 module TomlRB
   class Parser
+    BASIC_STRING = /(?:[^"\\\x00-\x08\x0a-\x1f\x7f]|\\.)*/
+    LITERAL_STRING = /[^'\x00-\x08\x0a-\x1f\x7f]*/
+    MULTILINE_STRING = /(?:[^"\\\x00-\x08\x0b-\x1f\x7f]|\r\n|\\(?:[^\r]|\r\n)|"{1,2}(?!"))*(?:"{0,2}(?="""))?/
+    MULTILINE_LITERAL = /(?:[^'\x00-\x08\x0b-\x1f\x7f]|\r\n|'{1,2}(?!'))*(?:'{0,2}(?='''))?/
+    # A UTF-8 regexp raises Encoding::CompatibilityError on binary input with high bytes.
+    COMMENT = /[^\x00-\x08\x0a-\x1f\x7f]*/u
+    DATETIME = /(\d{4})-(\d\d)-(\d\d)(?:[Tt ]([0-2]\d):([0-6]\d)(?::([0-6]\d)(?:\.(\d{1,9})\d*)?)?([Zz]|[+-]\d\d:\d\d)?)?/
+    TIME = /([0-2]\d):([0-6]\d)(?::([0-6]\d)(?:\.(\d{1,9})\d*)?)?/
+    PREFIXED_INTEGER = /0x[0-9a-fA-F](?:_?[0-9a-fA-F])*|0o[0-7](?:_?[0-7])*|0b[01](?:_?[01])*/
+    DECIMAL = /[+-]?(?:0|[1-9](?:_?\d)*)(\.\d(?:_?\d)*(?:[eE][+-]?\d(?:_?\d)*)?|[eE][+-]?\d(?:_?\d)*)?/
+    MAX_NESTING = 100
+
     attr_reader :hash
 
     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
+      @depth = 0
 
       begin
-        parsed = TomlRB::Document.parse(content)
-        parsed.matches.map(&:value).compact.each { |m| m.accept_visitor(self) }
-      rescue Citrus::ParseError => e
-        raise TomlRB::ParseError.new(e.message)
+        @scanner = StringScanner.new(source_text(content))
+        # The visitor runs after the whole document is parsed, so a syntax
+        # error wins over a key or table that the visitor rejects.
+        document.each { |statement| statement.accept_visitor(self) }
       rescue Encoding::CompatibilityError => e
         raise TomlRB::ParseError.new("Encoding error: #{e.message}")
       rescue ArgumentError => e
@@ -28,20 +47,250 @@ 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
+
+    private
+
+    def source_text(source)
+      if source.respond_to?(:to_path)
+        File.read(source.to_path)
+      elsif source.respond_to?(:read)
+        source.read
+      elsif source.respond_to?(:to_str)
+        source.to_str
+      else
+        raise ArgumentError, "Unable to parse from #{source}"
+      end
+    end
+
+    def document
+      statements = []
+      loop do
+        @scanner.skip(/(?:[ \t]*\r?\n)*[ \t]*/)
+        return statements if @scanner.eos?
+
+        statements << statement unless @scanner.match?(/#/)
+        line_end
+      end
+    end
+
+    def statement
+      if @scanner.match?(/\[/)
+        @scanner.match?(/\[\[/) ? table_array : table
+      else
+        keyvalue
+      end
+    end
+
+    def table_array
+      @scanner.skip(/\[\[[ \t]*/)
+      keys = key
+      expect(/[ \t]*\]\]/, "']]'")
+      TableArray.new(keys)
+    end
+
+    def table
+      @scanner.skip(/\[[ \t]*/)
+      keys = key
+      expect(/[ \t]*\]/, "']'")
+      Table.new(keys)
+    end
+
+    def keyvalue
+      keys = key
+      expect(/[ \t]*=[ \t]*/, "'='")
+      Keyvalue.new(keys, value)
+    end
+
+    def key
+      keys = [simple_key]
+      keys << simple_key while @scanner.skip(/[ \t]*\.[ \t]*/)
+      keys
+    end
+
+    def simple_key
+      if (bare = @scanner.scan(/[A-Za-z0-9_-]+/))
+        bare
+      elsif @scanner.match?(/"/)
+        basic_string
+      elsif @scanner.match?(/'/)
+        literal_string
+      else
+        syntax_error("a key")
+      end
+    end
+
+    def value
+      case @scanner.peek(1)
+      when '"'
+        @scanner.match?(/"""/) ? multiline_string : basic_string
+      when "'"
+        @scanner.match?(/'''/) ? multiline_literal : literal_string
+      when "["
+        nested { array }
+      when "{"
+        nested { inline_table }
+      when "t"
+        expect(/true/, "a value")
+        true
+      when "f"
+        expect(/false/, "a value")
+        false
+      else
+        datetime || local_time || number
+      end
+    end
+
+    def basic_string
+      @scanner.skip(/"/)
+      text = @scanner.scan(BASIC_STRING)
+      expect(/"/, %('"'))
+      unescape(text)
+    end
+
+    def literal_string
+      @scanner.skip(/'/)
+      text = @scanner.scan(LITERAL_STRING)
+      expect(/'/, %("'"))
+      text
+    end
+
+    def multiline_string
+      start = @scanner.pos
+      @scanner.skip(/"""(?:\r?\n)?/)
+      text = @scanner.scan(MULTILINE_STRING)
+      @scanner.skip(/"""/) || syntax_error(%('"""' to close the string at #{location(start)}))
+      unescape(text)
+    end
+
+    def multiline_literal
+      start = @scanner.pos
+      @scanner.skip(/'''(?:\r?\n)?/)
+      text = @scanner.scan(MULTILINE_LITERAL)
+      @scanner.skip(/'''/) || syntax_error(%("'''" to close the string at #{location(start)}))
+      text
+    end
+
+    def unescape(text)
+      text.include?("\\") ? BasicString.transform_escaped_chars(text) : text
+    end
+
+    def datetime
+      return unless @scanner.skip(DATETIME)
+
+      year, mon, day, hour, min, sec, sec_frac, offset = @scanner.values_at(1, 2, 3, 4, 5, 6, 7, 8)
+      if hour.nil?
+        DatetimeParser.local_date(year, mon, day)
+      elsif offset
+        DatetimeParser.offset_datetime(year, mon, day, hour, min, sec, sec_frac, offset)
+      else
+        DatetimeParser.local_datetime(year, mon, day, hour, min, sec, sec_frac)
+      end
+    end
+
+    def local_time
+      DatetimeParser.local_time(*@scanner.values_at(1, 2, 3, 4)) if @scanner.skip(TIME)
+    end
+
+    def number
+      if (text = @scanner.scan(PREFIXED_INTEGER))
+        Integer(text)
+      elsif (text = @scanner.scan(DECIMAL))
+        @scanner[1] ? text.to_f : text.to_i
+      elsif (text = @scanner.scan(/[+-]?inf/))
+        text.start_with?("-") ? -Float::INFINITY : Float::INFINITY
+      elsif @scanner.skip(/[+-]?nan/)
+        Float::NAN
+      else
+        syntax_error("a value")
+      end
+    end
+
+    def array
+      @scanner.skip(/\[/)
+      values = []
+      loop do
+        skip_whitespace_and_comments
+        return values if @scanner.skip(/\]/)
+
+        values << value
+        skip_whitespace_and_comments
+        return values if @scanner.skip(/\]/)
+
+        expect(/,/, "',' or ']'")
+      end
+    end
+
+    def inline_table
+      @scanner.skip(/\{/)
+      pairs = []
+      loop do
+        skip_whitespace_and_comments
+        return InlineTable.new(pairs) if @scanner.skip(/\}/)
+
+        pairs << keyvalue
+        skip_whitespace_and_comments
+        return InlineTable.new(pairs) if @scanner.skip(/\}/)
+
+        expect(/,/, "',' or '}'")
+      end
+    end
+
+    # Each nested array or inline table recurses, so the limit stops a deep
+    # document before it exhausts the stack.
+    def nested
+      @depth += 1
+      syntax_error("at most #{MAX_NESTING} nested arrays and inline tables") if @depth > MAX_NESTING
+      yield
+    ensure
+      @depth -= 1
+    end
+
+    def line_end
+      return if @scanner.skip(/[ \t]*\r?\n/)
+
+      @scanner.skip(/[ \t]*/)
+      @scanner.skip(COMMENT) if @scanner.skip(/#/)
+      new_line
+    end
+
+    def skip_whitespace_and_comments
+      @scanner.skip(/[ \t\r\n]*/)
+      while @scanner.skip(/#/)
+        @scanner.skip(COMMENT)
+        new_line
+        @scanner.skip(/[ \t\r\n]*/)
+      end
+    end
+
+    def new_line
+      @scanner.skip(/\r?\n/) || @scanner.eos? || syntax_error("a new line")
+    end
+
+    def expect(pattern, expected)
+      @scanner.skip(pattern) || syntax_error(expected)
+    end
+
+    def syntax_error(expected)
+      @scanner.skip(/[ \t]*/)
+      found = @scanner.eos? ? "end of input" : @scanner.check(/./m).inspect
+      raise ParseError, "Unexpected #{found} at #{location(@scanner.pos)}: expected #{expected}"
+    end
+
+    def location(pos)
+      consumed = @scanner.string.byteslice(0, pos)
+      line = consumed.count("\n") + 1
+      column = consumed.length - (consumed.rindex("\n") || -1)
+      "line #{line}, column #{column}"
     end
   end
 end

data/lib/toml-rb/string.rb

@@ -1,10 +1,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",
@@ -12,21 +11,22 @@ module TomlRB
       "\\\\" => "\\"
     }.freeze
 
-    def value
-      aux = TomlRB::BasicString.transform_escaped_chars first.value
-
-      aux[1...-1]
-    end
-
     # 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")
@@ -38,31 +38,4 @@ module TomlRB
       fail ParseError.new "Escape sequence #{m} is reserved"
     end
   end
-
-  module LiteralString
-    def value
-      first.value[1...-1]
-    end
-  end
-
-  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
-    end
-  end
-
-  module MultilineLiteral
-    def value
-      return "" if captures[:text].empty?
-      aux = captures[:text].first.value
-
-      aux.gsub(/\\\r?\n[\n\t\r ]*/, "")
-    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,20 +30,5 @@ 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
-  module TableParser
-    def value
-      TomlRB::Table.new(captures[:stripped_key].map(&:value).first)
-    end
   end
 end

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,25 +25,19 @@ 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
-  module TableArrayParser
-    def value
-      TomlRB::TableArray.new(captures[:stripped_key].map(&:value).first)
-    end
   end
 end

data/lib/toml-rb/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TomlRB
-  VERSION = "4.2.1"
+  VERSION = "6.0.0"
 end

data/lib/toml-rb.rb

@@ -1,7 +1,4 @@
-require "citrus"
-
 require_relative "toml-rb/errors"
-require_relative "toml-rb/array"
 require_relative "toml-rb/string"
 require_relative "toml-rb/datetime"
 require_relative "toml-rb/table"
@@ -11,12 +8,6 @@ require_relative "toml-rb/keyvalue"
 require_relative "toml-rb/parser"
 require_relative "toml-rb/dumper"
 
-File.dirname(File.expand_path(__FILE__)).tap do |root|
-  Citrus.load "#{root}/toml-rb/grammars/helper.citrus"
-  Citrus.load "#{root}/toml-rb/grammars/primitive.citrus"
-  Citrus.load "#{root}/toml-rb/grammars/document.citrus"
-end
-
 module TomlRB
   # Public: Returns a hash from *TomlRB* content.
   #
@@ -67,7 +58,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,49 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: toml-rb
 version: !ruby/object:Gem::Version
-  version: 4.2.1
+  version: 6.0.0
 platform: ruby
 authors:
 - Emiliano Mancuso
 - Lucas Tolchinsky
 bindir: bin
 cert_chain: []
-date: 2026-07-31 00:00:00.000000000 Z
+date: 2026-09-28 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: citrus
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-    - - ">"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-    - - ">"
-      - !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
@@ -86,7 +52,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 'A Toml parser using Citrus parsing library. '
+description: A TOML 1.1.0 parser and dumper.
 email:
 - emiliano.mancuso@gmail.com
 - lucas.tolchinsky@gmail.com
@@ -97,13 +63,9 @@ files:
 - LICENSE
 - README.md
 - lib/toml-rb.rb
-- lib/toml-rb/array.rb
 - lib/toml-rb/datetime.rb
 - lib/toml-rb/dumper.rb
 - lib/toml-rb/errors.rb
-- lib/toml-rb/grammars/document.citrus
-- lib/toml-rb/grammars/helper.citrus
-- lib/toml-rb/grammars/primitive.citrus
 - lib/toml-rb/inline_table.rb
 - lib/toml-rb/keyvalue.rb
 - lib/toml-rb/parser.rb

data/lib/toml-rb/array.rb

@@ -1,8 +0,0 @@
-module TomlRB
-  module ArrayParser
-    def value
-      elements = captures[:array_elements].first
-      elements ? elements.value : []
-    end
-  end
-end

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

@@ -1,57 +0,0 @@
-grammar TomlRB::Document
-  include TomlRB::Primitive
-
-  rule document
-    (comment | table_array | table | keyvalue | line_break)*
-  end
-
-  rule table_array
-    (space? '[[' stripped_key ']]' comment?) <TomlRB::TableArrayParser>
-  end
-
-  rule table
-    (space? '[' stripped_key ']' comment?) <TomlRB::TableParser>
-  end
-
-  rule keyvalue
-    (stripped_key '=' space? v:(toml_values) comment? space) <TomlRB::KeyvalueParser>
-  end
-
-  ### Values
-
-  rule inline_table
-    (space? '{' array_comments (keyvalue (array_comments ',' array_comments keyvalue)* (array_comments ',')?)? array_comments '}' ) <TomlRB::InlineTableParser>
-  end
-
-  rule array
-    ("[" array_comments (array_elements)? space ","? array_comments "]" indent?) <TomlRB::ArrayParser>
-  end
-
-  rule array_array
-    (array (space "," array_comments array)*) {
-      captures[:array].map(&:value)
-    }
-  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
-    }
-  end
-
-  ### Helpers
-
-  rule stripped_key
-    (space? key space?) { captures[:key].first.value }
-  end
-
-  rule array_comments
-    (indent? (comment indent?)*)
-  end
-
-  rule toml_values
-    primitive | inline_table | array
-  end
-end

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

@@ -1,17 +0,0 @@
-grammar TomlRB::Helper
-  rule comment
-    (space? "#" (~line_break)* line_break?) { nil }
-  end
-
-  rule space
-    [ \t]*
-  end
-
-  rule indent
-    [ \t\r\n]*
-  end
-
-  rule line_break
-    (space "\n" space | space "\r\n" space) { nil }
-  end
-end

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

@@ -1,176 +0,0 @@
-grammar TomlRB::Primitive
-  include TomlRB::Helper
-
-  rule primitive
-    datetime | bool | number | string
-  end
-
-  ##
-  # String rules
-  ##
-
-  rule string
-    multiline_string | multiline_literal | basic_string | literal_string
-  end
-
-  rule basic_string
-    (/(["])(?:\\?.)*?\1/ space) <TomlRB::BasicString>
-  end
-
-  rule literal_string
-    (/(['])(?:\\?.)*?\1/ space) <TomlRB::LiteralString>
-  end
-
-  rule multiline_string
-    ('"""' line_break* (text:~('"""' !'"')|'') '"""' space) <TomlRB::MultilineString>
-  end
-
-  rule multiline_literal
-    ("'''" line_break* (text:~("'''" !"'")|'') "'''" space) <TomlRB::MultilineLiteral>
-  end
-
-  ##
-  # Date time rules
-  ##
-
-  rule datetime
-    offset_datetime | local_datetime | local_date | local_time
-  end
-
-  rule offset_datetime
-    ( skeleton:datetime_skeleton ("Z" | date_offset) ) <TomlRB::OffsetDateTimeParser>
-  end
-
-  rule local_datetime
-    datetime_skeleton <TomlRB::LocalDateTimeParser>
-  end
-
-  rule local_date
-    (date_skeleton space) <TomlRB::LocalDateParser>
-  end
-
-  rule local_time
-    (time_skeleton space) <TomlRB::LocalTimeParser>
-  end
-
-  rule datetime_skeleton
-    (date_skeleton ("T"|" ") 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 }
-    }
-  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']
-    }
-  end
-
-  rule date_offset
-    offset:(sign /\d\d/ ":" /\d\d/)
-  end
-
-  ##
-  # Number rules
-  ##
-
-  rule number
-    float | integer
-  end
-
-  rule float
-    inf | nan | exponential_float | fractional_float
-  end
-
-  rule inf
-    (s:sign? 'inf') {
-      sign = (capture(:s).value != '-') ? 1 : -1
-      sign * Float::INFINITY
-    }
-  end
-
-  rule nan
-    (sign? 'nan') { Float::NAN }
-  end
-
-  rule exponential_float
-    ((fractional_float | decimal_integer) [eE] decimal_integer) { to_str.to_f }
-  end
-
-  rule fractional_float
-    (decimal_integer '.' [0-9] ([0-9] | '_' [0-9])*) {
-      to_str.to_f
-    }
-  end
-
-  rule integer
-    hexadecimal_integer | octal_integer | binary_integer | decimal_integer
-  end
-
-  rule hexadecimal_integer
-    ('0x' [a-fA-F0-9] ([a-fA-F0-9] | '_' [a-fA-F0-9])*) { to_str.to_i(16) }
-  end
-
-  rule octal_integer
-    ('0o' [0-7] ([0-7] | '_' [0-7])*) { to_str.to_i(8) }
-  end
-
-  rule binary_integer
-    ('0b' [01] ([01] | '_' [01])*) { to_str.to_i(2) }
-  end
-
-  rule decimal_integer
-    (sign? [0-9] ([0-9] | '_' [0-9])*) { to_str.to_i }
-  end
-
-  rule sign
-    '+' | '-'
-  end
-
-  ##
-  # Boolean rules
-  ##
-
-  rule bool
-    true | false
-  end
-
-  rule true
-    'true' { true }
-  end
-
-  rule false
-    'false' { false }
-  end
-
-  ##
-  # Key rules
-  ##
-
-  rule key
-    dotted_key
-  end
-
-  rule bare_key
-    [a-zA-Z0-9_-]+
-  end
-
-  rule quoted_key
-    basic_string | literal_string
-  end
-
-  rule single_key
-    quoted_key | bare_key
-  end
-
-  rule dotted_key
-    (space? single_key space?  ("." space? single_key space?)* ) {
-      captures[:single_key].map(&:value)
-    }
-  end
-end