toby 1.0.0.pre.rc2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f1e0acda45cfe119c3d8d9eccf8219e20483f45edf9b03f512d6cbed270bf11c
+  data.tar.gz: 107c270acc1369b4573a55288355ea14fd391560af8263a65d153544109382f8
+SHA512:
+  metadata.gz: 1aa4a9b1d89719d9fbc70853a8f1ba9b2d2d2a77e40f6f1111ef82bcfbd686a7ef2d94cb0fe220b2c44e2ed169128352e84751771930bba03ed80ce06ea6a631
+  data.tar.gz: b6e7b8136f32fd4a7c64b4eb04a52b036593d25b7238a788c318e5b0e8d33a87b3803daeb4ebbbcfc2c280db194a19f7efab900341f4edd8ebb7e494b9367733

data/lib/toby.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'citrus'
+require 'delegate'
+require 'stringio'
+require 'json'
+
+# Contains all of the code for the Toby gem.
+module Toby; end
+
+module Toby
+  # Contains all of code for TOML objects.
+  module TOML; end
+end
+
+module Toby
+  # Contains all of the code used for parsing TOML files.
+  # @api private
+  module Parser; end
+end
+
+require_relative 'toby/toml/array'
+require_relative 'toby/toml/inline_table'
+require_relative 'toby/toml/key_value'
+require_relative 'toby/toml/table'
+require_relative 'toby/toml/toml_file'
+
+require_relative 'toby/parser/string'
+require_relative 'toby/parser/datetime'
+require_relative 'toby/parser/match_modules'
+require_relative 'toby/parser/numbers'
+
+# The root directory of Toby
+ROOT = File.dirname(File.expand_path(__FILE__))
+Citrus.load "#{ROOT}/toby/grammars/helper.citrus"
+Citrus.load "#{ROOT}/toby/grammars/primitive.citrus"
+Citrus.load "#{ROOT}/toby/grammars/document.citrus"

data/lib/toby/grammars/document.citrus

@@ -0,0 +1,49 @@
+grammar Toby::Document
+  include Toby::Primitive
+
+  rule document
+    (comment | table_array | table | keyvalue | line_break)*
+  end
+
+  rule table_array
+    (space? '[[' stripped_key ']]' comment?) <Toby::Parser::Match::ArrayTable>
+  end
+
+  rule table
+    (space? '[' stripped_key ']' comment?) <Toby::Parser::Match::Table>
+  end
+
+  rule keyvalue
+    (stripped_key '=' space? v:(toml_values) comment?) <Toby::Parser::Match::KeyValue>
+  end
+
+  rule inline_table
+    (space? '{' (keyvalue? (',' keyvalue)*)? space? '}' ) <Toby::Parser::Match::InlineTable>
+  end
+
+  rule array_comments
+    (indent? (comment indent?)*)
+  end
+
+  rule array
+    ("[" array_comments (array_elements)? space ","? array_comments "]" indent?) <Toby::Parser::Match::Array>
+  end
+
+  rule array_element
+    primitive | inline_table | array
+  end
+
+  rule array_elements
+    (array_element (space "," array_comments array_element)*) {
+      captures[:array_element].map(&:value)
+    }
+  end
+
+  rule toml_values
+    primitive | inline_table | array
+  end
+
+  rule stripped_key
+    (space? key space?) { captures[:key].first.value }
+  end
+end

data/lib/toby/grammars/helper.citrus

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

data/lib/toby/grammars/primitive.citrus

@@ -0,0 +1,176 @@
+grammar Toby::Primitive
+  include Toby::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) <Toby::Parser::BasicString>
+  end
+
+  rule literal_string
+    (/(['])(?:\\?.)*?\1/ space) <Toby::Parser::LiteralString>
+  end
+
+  rule multiline_string
+    ('"""' line_break* (text:~('"""' !'"')|'') '"""' space) <Toby::Parser::MultilineString>
+  end
+
+  rule multiline_literal
+    ("'''" line_break* (text:~("'''" !"'")|'') "'''" space) <Toby::Parser::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) ) <Toby::Parser::Match::OffsetDateTime>
+  end
+
+  rule local_datetime
+    datetime_skeleton <Toby::Parser::Match::LocalDateTime>
+  end
+
+  rule local_date
+    (date_skeleton space) <Toby::Parser::Match::LocalDate>
+  end
+
+  rule local_time
+    (time_skeleton space) <Toby::Parser::Match::LocalTime>
+  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 | demical_integer) [eE] demical_integer) { to_str.to_f }
+  end
+
+  rule fractional_float
+    (demical_integer '.' [0-9_]+) { 
+      to_str.to_f
+    }
+  end
+
+  rule integer
+    hexadecimal_integer | octal_integer | binary_integer | demical_integer
+  end
+
+  rule hexadecimal_integer
+    ('0x' [a-fA-F0-9_]+) <Toby::Parser::Match::Hexadecimal>
+  end
+
+  rule octal_integer
+    ('0o' [0-7_]+) <Toby::Parser::Match::Octal>
+  end
+
+  rule binary_integer
+    ('0b' [01_]+) <Toby::Parser::Match::Binary>
+  end
+
+  rule demical_integer
+    (sign? [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

data/lib/toby/parser/datetime.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Toby
+  module Parser
+    # @see https://toml.io/en/v1.0.0-rc.3#offset-date-time
+    class OffsetDateTime < Time
+      def to_s
+        strftime('%Y-%m-%dT%H:%M:%S%z')
+      end
+    end
+
+    # @see https://toml.io/en/v1.0.0-rc.3#local-date-time
+    class LocalDateTime < Time
+      def to_s
+        strftime('%Y-%m-%dT%H:%M:%S')
+      end
+    end
+
+    # @see https://toml.io/en/v1.0.0-rc.3#local-date
+    class LocalDate < Time
+      def to_s
+        strftime('%Y-%m-%d')
+      end
+    end
+
+    # @see https://toml.io/en/v1.0.0-rc.3#local-time
+    class LocalTime < Time
+      def to_s
+        utc.strftime('%H:%M:%S.%L')
+      end
+    end
+
+    module Match
+      # @see https://toml.io/en/v1.0.0-rc.3#offset-date-time
+      module OffsetDateTime
+        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
+
+          Toby::Parser::OffsetDateTime.new(year, mon, day, hour, min, sec, offset.to_s)
+        end
+      end
+
+      # @see https://toml.io/en/v1.0.0-rc.3#local-date-time
+      module LocalDateTime
+        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')
+
+          Toby::LocalDateTime.local(year, mon, day, hour, min, sec, usec)
+        end
+      end
+
+      # @see https://toml.io/en/v1.0.0-rc.3#local-date
+      module LocalDate
+        def value
+          year, mon, day = captures[:date_skeleton].first.value
+          Toby::Parser::LocalDate.local(year, mon, day)
+        end
+      end
+
+      # @see https://toml.io/en/v1.0.0-rc.3#local-time
+      module LocalTime
+        def value
+          hour, min, sec, sec_frac = captures[:time_skeleton].first.value
+          usec = sec_frac.to_s.ljust(6, '0')
+
+          Toby::Parser::LocalTime.at(3600 * hour.to_i + 60 * min.to_i + sec.to_i, usec.to_i)
+        end
+      end
+    end
+  end
+end

data/lib/toby/parser/match_modules.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Toby
+  module Parser
+    module Match
+      # @see https://toml.io/en/v1.0.0-rc.3#inline-table
+      module InlineTable
+        def value
+          kv_array = []
+
+          captures(:keyvalue).each do |kv|
+            kv_array << Toby::TOML::KeyValue.new(kv.keys, kv.value, nil)
+          end
+
+          Toby::TOML::InlineTable.new kv_array
+        end
+      end
+
+      # @see https://toml.io/en/v1.0.0-rc.3#array
+      module Array
+        def value
+          Toby::TOML::Array.new capture(:array_elements).value
+        end
+      end
+
+      # @see https://toml.io/en/v1.0.0-rc.3#keyvalue-pair
+      module KeyValue
+        def keys
+          capture(:stripped_key).value
+        end
+
+        def value
+          capture(:v).value
+        end
+
+        def comment
+          capture(:comment)&.stripped_comment
+        end
+
+        def toml_object
+          Toby::TOML::KeyValue.new(
+            keys,
+            value,
+            comment
+          )
+        end
+      end
+
+      # @see https://toml.io/en/v1.0.0-rc.3#table
+      module Table
+        def toml_object
+          Toby::TOML::Table.new(
+            capture(:stripped_key).value,
+            capture(:comment)&.stripped_comment,
+            false
+          )
+        end
+      end
+
+      # @see https://toml.io/en/v1.0.0-rc.3#array-of-tables
+      module ArrayTable
+        def toml_object
+          Toby::TOML::Table.new(
+            capture(:stripped_key).value,
+            capture(:comment)&.stripped_comment,
+            true
+          )
+        end
+      end
+
+      # @see https://toml.io/en/v1.0.0-rc.3#comment
+      module Comment
+        def stripped_comment
+          value.sub('#', '').strip!
+        end
+      end
+    end
+  end
+end

data/lib/toby/parser/numbers.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Toby
+  module Parser
+    # @see https://toml.io/en/v1.0.0-rc.3#integer
+    class Hexadecimal < DelegateClass(Integer)
+      def to_s
+        hex = to_i.to_s(16)
+        "0x#{hex}"
+      end
+
+      def inspect
+        to_s
+      end
+    end
+
+    # @see https://toml.io/en/v1.0.0-rc.3#integer
+    class Binary < DelegateClass(Integer)
+      def to_s
+        binary = to_i.to_s(2)
+        "0b#{binary}"
+      end
+
+      def inspect
+        to_s
+      end
+    end
+
+    # @see https://toml.io/en/v1.0.0-rc.3#integer
+    class Octal < DelegateClass(Integer)
+      def to_s
+        octal = to_i.to_s(8)
+        "0b#{octal}"
+      end
+
+      def inspect
+        to_s
+      end
+    end
+
+    module Match
+      # @see https://toml.io/en/v1.0.0-rc.3#integer
+      module Hexadecimal
+        def value
+          Toby::Parser::Hexadecimal.new(to_str.to_i(16))
+        end
+      end
+
+      # @see https://toml.io/en/v1.0.0-rc.3#integer
+      module Binary
+        def value
+          Toby::Parser::Binary.new(to_str.to_i(2))
+        end
+      end
+
+      # @see https://toml.io/en/v1.0.0-rc.3#integer
+      module Octal
+        def value
+          Toby::Parser::Octal.new(to_str.to_i(8))
+        end
+      end
+    end
+  end
+end

data/lib/toby/parser/string.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Toby
+  module Parser
+    # Used in primitive.citrus
+    module BasicString
+      SPECIAL_CHARS = {
+        '\\0' => "\0",
+        '\\t' => "\t",
+        '\\b' => "\b",
+        '\\f' => "\f",
+        '\\n' => "\n",
+        '\\r' => "\r",
+        '\\"' => '"',
+        '\\\\' => '\\'
+      }.freeze
+
+      def value
+        aux = Toby::Parser::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')
+      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
+            SPECIAL_CHARS[m] || parse_error(m)
+          else
+            decode_unicode(m).force_encoding('UTF-8')
+          end
+        end
+      end
+
+      def self.parse_error(sequence)
+        raise ParseError, "Escape sequence #{sequence} is reserved"
+      end
+    end
+
+    # @see https://toml.io/en/v1.0.0-rc.3#string
+    module LiteralString
+      def value
+        first.value[1...-1]
+      end
+    end
+
+    # @see https://toml.io/en/v1.0.0-rc.3#string
+    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 ]*/, '')
+
+        Toby::Parser::BasicString.transform_escaped_chars aux
+      end
+    end
+
+    # @see https://toml.io/en/v1.0.0-rc.3#string
+    module MultilineLiteral
+      def value
+        return '' if captures[:text].empty?
+
+        aux = captures[:text].first.value
+
+        aux.gsub(/\\\r?\n[\n\t\r ]*/, '')
+      end
+    end
+  end
+end

data/lib/toby/toml/array.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: false
+
+module Toby
+  module TOML
+    # Represents an array value
+    # @see https://toml.io/en/v1.0.0-rc.3#array
+    class Array < ::Array
+      # @return [String] Array in valid TOML format
+      def dump
+        output = StringIO.new
+
+        output.print '[ '
+
+        dumped_array = map do |val|
+          val.respond_to?(:dump) ? val.dump : val
+        end
+
+        output.print dumped_array.join(', ')
+        output.print ' ]'
+
+        output.string
+      end
+
+      # @param options [Hash] The options hash for the object's #to_hash method when applicable
+      #   (see Toby::TOML::TOMLFile#to_hash)
+      # @return [Array] Returns the value of #value, the value of #to_hash,
+      #   or the object itself for every object in the Toby::TOML::Array
+      def to_hash(options = {})
+        map do |obj|
+          if obj.respond_to?(:value)
+            obj.value
+          elsif obj.respond_to?(:to_hash)
+            obj.to_hash(options)
+          else
+            obj
+          end
+        end
+      end
+    end
+  end
+end

data/lib/toby/toml/inline_table.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: false
+
+module Toby
+  module TOML
+    # Represents an inline-table value
+    # @see https://toml.io/en/v1.0.0-rc.3#inline-table
+    class InlineTable < Array
+      # @return [String] Inline table in valid TOML format
+      def dump
+        output = StringIO.new
+
+        output.print '{'
+
+        each do |kv|
+          dumped_value = kv.value.respond_to?(:dump) ? kv.value.dump : kv.value
+
+          dotted_keys = kv.split_keys.map { |key| kv.bare_key?(key) ? key : kv.quote_key(key) }.join('.')
+
+          output.print " #{dotted_keys} = #{dumped_value},"
+        end
+
+        output.string.gsub(/,$/, ' }')
+      end
+
+      # @return [Hash] TOML table represented as a hash.
+      # @option options [TrueClass, FalseClass]  :dotted_keys (false) If true, dotted keys are not expanded/nested.
+      # @example
+      #   Given the following TOML:
+      #   table = {a.b.c = 123}
+      #
+      #   #to_hash returns { "table" => {"a" => { "b" => { "c" => 123 } } } }
+      #   #to_hash(dotted_keys: true) returns {'some.dotted.keys' => {'some.value'} => 123}
+      def to_hash(options = {})
+        if options[:dotted_keys]
+          to_dotted_keys_hash
+        else
+          to_split_keys_hash
+        end
+      end
+
+      private
+
+      # @api private
+      def to_split_keys_hash
+        output_hash = {}
+
+        last_hash = output_hash
+        last_last_hash = nil
+
+        each do |kv|
+          kv.split_keys.each_with_index do |key, i|
+            last_last_hash = last_hash
+
+            if i < (kv.split_keys.size - 1) # not the last key
+              last_hash[key] ||= {}
+              last_last_hash = last_hash
+              last_hash = last_hash[key]
+            else
+              last_hash[key] = kv.value.respond_to?(:to_hash) ? kv.value.to_hash(options) : kv.value
+            end
+          end
+        end
+
+        output_hash
+      end
+
+      # @api private
+      def to_dotted_keys_hash
+        output_hash = {}
+
+        each do |kv|
+          output_hash[kv.key] = kv.value.respond_to?(:to_hash) ? kv.value.to_hash(options) : kv.value
+        end
+
+        output_hash
+      end
+    end
+  end
+end

data/lib/toby/toml/key_value.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: false
+
+module Toby
+  module TOML
+    # Represents a TOML key-value pair
+    # @see https://toml.io/en/v1.0.0-rc.3#keyvalue-pair
+    class KeyValue
+      # @return [String] The key of the key-value pair.
+      attr_reader :key
+
+      # @return [::Array] The dotted keys of the key-value pair.
+      attr_reader :split_keys
+
+      # @return [String, Integer, Float, Time, Toby::TOML::Array, Toby::TOML::InlineTable] The value of the
+      #   key-value pair.
+      attr_accessor :value
+
+      # @return [Toby::TOML::Table] The table the key-value pair belongs to.
+      attr_accessor :table
+
+      # @return [::Array<String>] The header comments above the key-value pair.
+      attr_accessor :header_comments
+
+      # @return [String] The comment in-line with the key-value pair
+      attr_accessor :inline_comment
+
+      # @param split_keys [::Array] Dotted keys of the key-value pair.
+      # @param value [String, Integer, Float, Time, Toby::TOML::Array, Toby::TOML::InlineTable] The value of the
+      #   key-value pair.
+      # @param inline_comment [String] The comment in-line with the key-value pair.
+      def initialize(split_keys, value, inline_comment)
+        @split_keys = split_keys
+        @key = split_keys.join('.')
+
+        @value = value
+        @header_comments = []
+        @inline_comment = inline_comment
+        @table = table
+      end
+
+      # @return [String] The key-value pair in valid TOML
+      def dump
+        output = StringIO.new
+
+        dumped_value = value.respond_to?(:dump) ? value.dump : value
+
+        dotted_keys = split_keys.map { |key| bare_key?(key) ? key : quote_key(key) }.join('.')
+
+        output.puts "\n##{header_comments.join("\n#")}" unless header_comments.empty?
+
+        output.puts "#{dotted_keys} = #{dumped_value}#{" ##{inline_comment}" if inline_comment}"
+
+        output.string
+      end
+
+      # @api private
+      # from toml-rb
+      # https://github.com/emancu/toml-rb/blob/ca5bf9563f1ef2c467bd43eec1d035e83b61ac88/lib/toml-rb/dumper.rb
+      def bare_key?(key)
+        !!key.to_s.match(/^[a-zA-Z0-9_-]*$/)
+      end
+
+      # @api private
+      # from toml-rb
+      # https://github.com/emancu/toml-rb/blob/ca5bf9563f1ef2c467bd43eec1d035e83b61ac88/lib/toml-rb/dumper.rb
+      def quote_key(key)
+        "\"#{key.gsub('"', '\\"')}\""
+      end
+    end
+  end
+end

data/lib/toby/toml/table.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: false
+
+module Toby
+  module TOML
+    # Represents a TOML table
+    # @see https://toml.io/en/v1.0.0-rc.3#table
+    # @see https://toml.io/en/v1.0.0-rc.3#array-of-tables
+    class Table
+      # @return [::Array] The dotted keys of the table name.
+      attr_reader :split_keys
+
+      # @return [String] The name of table.
+      attr_reader :name
+
+      # @return [::Array<Toby::TOML::KeyValue>] The key-value pairs within the table.
+      attr_accessor :key_values
+
+      # @return [::Array<String>] The header comments above the table.
+      attr_accessor :header_comments
+
+      # @return [String] The comment in-line with the table name.
+      attr_accessor :inline_comment
+
+      # @param split_keys [::Array] Dotted keys of the table name.
+      # @param inline_comment [String] The comment in-line with the key-value pair.
+      # @param is_array_table [TrueClass, FalseClass] Whether the table is an array-table or not
+      def initialize(split_keys, inline_comment, is_array_table)
+        @split_keys = split_keys
+        @name = split_keys&.join('.')
+        @inline_comment = inline_comment
+        @is_array_table = is_array_table
+
+        @header_comments = []
+        @key_values = []
+      end
+
+      # @return [TrueClass, FalseClass] Whether the table is an array-table or not
+      def array_table?
+        @is_array_table
+      end
+
+      # @return [Hash] TOML table represented as a hash.
+      # @option options [TrueClass, FalseClass]  :dotted_keys (false) If true, dotted keys are not expanded/nested.
+      # @example
+      #   Given the following TOML:
+      #   [some.dotted.keys]
+      #   some.value = 123
+      #
+      #   #to_hash returns {'some' => {'dotted' => {'keys' => {'some' => {'value' => 123} } } } } }
+      #   #to_hash(dotted_keys: true) returns in {'some.dotted.keys' => {'some.value'} => 123}
+      def to_hash(options = {})
+        if options[:dotted_keys]
+          to_dotted_keys_hash(options)
+        else
+          to_split_keys_hash(options)
+        end
+      end
+
+      # @return [String] Table in valid TOML format
+      def dump
+        output = StringIO.new
+
+        dotted_keys = split_keys.map { |key| bare_key?(key) ? key : quote_key(key) }.join('.')
+
+        output.puts "\n##{header_comments.join("\n#")}" unless header_comments.empty?
+
+        if array_table?
+          output.puts "[[#{dotted_keys}]]#{" ##{inline_comment}" if inline_comment}"
+        else
+          output.puts "[#{dotted_keys}]#{" ##{inline_comment}" if inline_comment}"
+        end
+
+        key_values.each do |kv|
+          output.puts kv.dump
+        end
+
+        output.string
+      end
+
+      # @api private
+      # from toml-rb
+      # https://github.com/emancu/toml-rb/blob/ca5bf9563f1ef2c467bd43eec1d035e83b61ac88/lib/toml-rb/dumper.rb
+      def bare_key?(key)
+        !!key.to_s.match(/^[a-zA-Z0-9_-]*$/)
+      end
+
+      # @api private
+      # from toml-rb
+      # https://github.com/emancu/toml-rb/blob/ca5bf9563f1ef2c467bd43eec1d035e83b61ac88/lib/toml-rb/dumper.rb
+      def quote_key(key)
+        "\"#{key.gsub('"', '\\"')}\""
+      end
+
+      private
+
+      # @api private
+      def to_dotted_keys_hash(options)
+        output_hash = {}
+
+        key_values.each do |kv|
+          output_hash[kv.key] = kv.value.respond_to?(:to_hash) ? kv.value.to_hash(options) : kv.value
+        end
+
+        output_hash
+      end
+
+      # @api private
+      def to_split_keys_hash(options)
+        output_hash = {}
+
+        key_values.each do |kv|
+          last_hash = output_hash
+
+          kv.split_keys.each_with_index do |key, i|
+            if i < (kv.split_keys.size - 1) # not the last key
+              last_hash[key] ||= {}
+              last_hash = last_hash[key]
+            else
+              last_hash[key] = kv.value.respond_to?(:to_hash) ? kv.value.to_hash(options) : kv.value
+            end
+          end
+        end
+
+        output_hash
+      end
+    end
+  end
+end

data/lib/toby/toml/toml_file.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: false
+
+module Toby
+  module TOML
+    # Represents an entire TOML file
+    # @see https://toml.io/en/v1.0.0-rc.3
+    class TOMLFile < Toby::TOML::Table
+      # @return [Array<Toby::TOML::Table>] The tables in the TOML file
+      attr_reader :tables
+
+      # @param input_string [String] The TOML file to parse.
+      def initialize(input_string)
+        super(nil, '', false)
+
+        @tables = [self]
+        matches = Toby::Document.parse(input_string).matches
+
+        @comment_buffer = []
+
+        matches.each do |m|
+          if m.respond_to? :toml_object
+            toml_object_handler(m.toml_object)
+
+          elsif m.respond_to? :stripped_comment
+            @comment_buffer << m.stripped_comment
+
+          end
+        end
+      end
+
+      # @return [Hash] TOML table represented as a hash.
+      # @option options [TrueClass, FalseClass]  :dotted_keys (false) If true, dotted keys are not expanded/nested.
+      # @example
+      #   Given the following TOML:
+      #   [some.dotted.keys]
+      #   some.value = 123
+      #
+      #   #to_hash returns {'some' => {'dotted' => {'keys' => {'some' => {'value' => 123} } } } } }
+      #   #to_hash(dotted_keys: true) returns {'some.dotted.keys' => {'some.value'} => 123}
+      def to_hash(options = {})
+        if options[:dotted_keys]
+          to_dotted_keys_hash(options)
+        else
+          to_split_keys_hash(options)
+        end
+      end
+
+      # @return [String] The entire TOML file in valid TOML format.
+      def dump
+        output = StringIO.new
+
+        key_values.each do |kv|
+          output.puts kv.dump
+        end
+
+        tables.each do |table|
+          next if table.is_a? Toby::TOML::TOMLFile
+
+          output.puts table.dump
+        end
+
+        output.string
+      end
+
+      # @return [String] The TOML file in valid JSON in accordance with the TOML spec
+      def to_json(*_args)
+        to_hash.to_json
+      end
+
+      # @return [NilClass] A file can't have an inline comment, so this will always return nil
+      def inline_comment
+        nil
+      end
+
+      private
+
+      # @api private
+      def to_dotted_keys_hash(options)
+        output_hash = {}
+
+        tables.each do |tbl|
+          if tbl.name.nil?
+            output_hash = super
+
+          elsif tbl.array_table?
+            output_hash[tbl.name] ||= []
+            output_hash[tbl.name] << tbl.to_hash(options)
+
+          else
+            output_hash[tbl.name] = tbl.to_hash(options)
+          end
+        end
+
+        output_hash
+      end
+
+      # @api private
+      def to_split_keys_hash(options)
+        output_hash = {}
+
+        tables.each do |tbl|
+          if tbl.name.nil?
+            output_hash = super
+
+          elsif tbl.array_table?
+            last_hash = output_hash
+
+            tbl.split_keys.each_with_index do |key, i|
+              if i < (tbl.split_keys.size - 1) # not the last key
+                last_hash[key] ||= {}
+                last_hash = last_hash[key]
+              elsif last_hash.is_a? ::Array
+                last_hash.last[key] ||= []
+                last_hash.last[key] << tbl.to_hash(options)
+              else
+                last_hash[key] ||= []
+                last_hash[key] << tbl.to_hash(options)
+              end
+            end
+
+          else
+
+            last_hash = output_hash
+            last_last_hash = nil
+
+            tbl.split_keys.each_with_index do |key, i|
+              last_last_hash = last_hash
+              if i < (tbl.split_keys.size - 1) # not the last key
+                last_hash[key] ||= {}
+                last_last_hash = last_hash
+                last_hash = last_hash[key]
+              elsif last_hash.is_a? ::Array
+                last_last_hash.last[key] = tbl.to_hash(options)
+              else
+                last_hash[key] = tbl.to_hash(options)
+              end
+            end
+          end
+        end
+
+        output_hash
+      end
+
+      # @api private
+      def toml_object_handler(obj)
+        if obj.respond_to?(:header_comments) && !@comment_buffer.empty?
+          obj.header_comments = @comment_buffer
+          @comment_buffer = []
+        end
+
+        case obj
+        when Toby::TOML::Table
+          @tables << obj
+
+        when Toby::TOML::KeyValue
+          @tables.last.key_values << obj
+
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: toby
+version: !ruby/object:Gem::Version
+  version: 1.0.0.pre.rc2
+platform: ruby
+authors:
+- Joe Polny
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-01-31 00:00:00.000000000 Z
+dependencies: []
+description: Toby is a TOML 1.0.0 parser for Ruby that allows the parsing, editing,
+  and dumping of the TOML file format (including comments). Toby also supports conversion
+  from TOML to a Ruby Hash or JSON.
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/toby.rb
+- lib/toby/grammars/document.citrus
+- lib/toby/grammars/helper.citrus
+- lib/toby/grammars/primitive.citrus
+- lib/toby/parser/datetime.rb
+- lib/toby/parser/match_modules.rb
+- lib/toby/parser/numbers.rb
+- lib/toby/parser/string.rb
+- lib/toby/toml/array.rb
+- lib/toby/toml/inline_table.rb
+- lib/toby/toml/key_value.rb
+- lib/toby/toml/table.rb
+- lib/toby/toml/toml_file.rb
+homepage: https://github.com/joe-p/toby
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/joe-p/toby
+  bug_tracker_uri: https://github.com/joe-p/toby/issues
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.1.4
+signing_key:
+specification_version: 4
+summary: A TOML Parser for Ruby. TOML + Ruby = Toby.
+test_files: []