toml-rb 1.1.2 → 2.0.0

data/lib/toml-rb/keyvalue.rb

@@ -1,31 +1,39 @@
+require_relative "inline_table"
+
 module TomlRB
   class Keyvalue
-    attr_reader :value, :symbolize_keys
+    attr_reader :dotted_keys, :value, :symbolize_keys
 
-    def initialize(key, value)
-      @key = key
+    def initialize(dotted_keys, value)
+      @dotted_keys = dotted_keys
       @value = value
       @symbolize_keys = false
     end
 
-    def assign(hash, symbolize_keys = false)
+    def assign(hash, fully_defined_keys, symbolize_keys = false)
       @symbolize_keys = symbolize_keys
-      fail ValueOverwriteError.new(key) if hash.key?(key)
-      hash[key] = visit_value @value
-    end
-
-    def visit_inline_table(inline_table)
-      result = {}
-
-      inline_table.value(@symbolize_keys).each do |k, v|
-        result[key k] = visit_value v
+      dotted_keys_str = @dotted_keys.join(".")
+      keys = symbolize_keys ? @dotted_keys.map(&:to_sym) : @dotted_keys
+      update = keys.reverse.inject(visit_value @value) { |k1, k2| { k2 => k1 } }
+
+      if @value.is_a?(InlineTable)
+        fully_defined_keys << dotted_keys_str
+        hash.merge!(update) { |key, _, _| fail ValueOverwriteError.new(key) }
+      elsif fully_defined_keys.find{|k| update.dig(*k)}
+        hash.merge!(update) { |key, _, _| fail ValueOverwriteError.new(key) }
+      else
+        dotted_key_merge(hash, update)
       end
-
-      result
     end
 
-    def key(a_key = @key)
-      symbolize_keys ? a_key.to_sym : a_key
+    def dotted_key_merge(hash, update)
+      hash.merge!(update) { |key, old, new|
+        if old.is_a?(Hash) && new.is_a?(Hash)
+          dotted_key_merge(old, new)
+        else
+          fail ValueOverwriteError.new(key)
+        end
+      }
     end
 
     def accept_visitor(parser)

data/lib/toml-rb/parser.rb

@@ -5,6 +5,7 @@ module TomlRB
     def initialize(content, options = {})
       @hash = {}
       @visited_keys = []
+      @fully_defined_keys = []
       @current = @hash
       @symbolize_keys = options[:symbolize_keys]
 
@@ -19,18 +20,20 @@ module TomlRB
     # Read about the Visitor pattern
     # http://en.wikipedia.org/wiki/Visitor_pattern
     def visit_table_array(table_array)
+      @fully_defined_keys = []
       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
     end
 
-    def visit_keygroup(keygroup)
-      @current = keygroup.navigate_keys @hash, @visited_keys, @symbolize_keys
+    def visit_table(table)
+      @fully_defined_keys = []
+      @current = table.navigate_keys @hash, @visited_keys, @symbolize_keys
     end
 
     def visit_keyvalue(keyvalue)
-      keyvalue.assign @current, @symbolize_keys
+      keyvalue.assign @current, @fully_defined_keys, @symbolize_keys
     end
   end
 end

data/lib/toml-rb/{keygroup.rb → table.rb}

@@ -1,20 +1,21 @@
 module TomlRB
-  class Keygroup
-    def initialize(nested_keys)
-      @nested_keys = nested_keys
+  class Table
+    def initialize(dotted_keys)
+      @dotted_keys = dotted_keys
     end
 
     def navigate_keys(hash, visited_keys, symbolize_keys = false)
       ensure_key_not_defined(visited_keys)
-      @nested_keys.each do |key|
-        key = symbolize_keys ? key.to_sym : key
-        hash[key] = {} unless hash.key?(key)
-        element = hash[key]
-        hash = element.is_a?(Array) ? element.last : element
+      current = hash
+      keys = symbolize_keys ? @dotted_keys.map(&:to_sym) : @dotted_keys
+      keys.each do |key|
+        current[key] = {} unless current.key?(key)
+        element = current[key]
+        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 hash.is_a?(Hash)
+        fail ValueOverwriteError.new(key) unless current.is_a?(Hash)
       end
-      hash
+      current
     end
 
     # Fail if the key was already defined with a ValueOverwriteError
@@ -24,18 +25,18 @@ module TomlRB
     end
 
     def accept_visitor(parser)
-      parser.visit_keygroup self
+      parser.visit_table self
     end
 
     def full_key
-      @nested_keys.join('.')
+      @dotted_keys.join('.')
     end
   end
 
   # Used in document.citrus
-  module KeygroupParser
+  module TableParser
     def value
-      TomlRB::Keygroup.new(captures[:stripped_key].map(&:value))
+      TomlRB::Table.new(captures[:stripped_key].map(&:value).first)
     end
   end
 end

data/lib/toml-rb/table_array.rb

@@ -1,35 +1,35 @@
 module TomlRB
   class TableArray
-    def initialize(nested_keys)
-      @nested_keys = nested_keys
+    def initialize(dotted_keys)
+      @dotted_keys = dotted_keys
     end
 
     def navigate_keys(hash, symbolize_keys = false)
-      last_key = @nested_keys.pop
-      last_key = last_key.to_sym if symbolize_keys
+      current = hash 
+      keys = symbolize_keys ? @dotted_keys.map(&:to_sym) : @dotted_keys
+      last_key = keys.pop
 
       # Go over the parent keys
-      @nested_keys.each do |key|
-        key = symbolize_keys ? key.to_sym : key
-        hash[key] = {} unless hash[key]
+      keys.each do |key|
+        current[key] = {} unless current[key]
 
-        if hash[key].is_a? Array
-          hash[key] << {} if hash[key].empty?
-          hash = hash[key].last
+        if current[key].is_a? Array
+          current[key] << {} if current[key].empty?
+          current = current[key].last
         else
-          hash = hash[key]
+          current = current[key]
         end
       end
 
       # Define Table Array
-      if hash[last_key].is_a? Hash
+      if current[last_key].is_a? Hash
         fail TomlRB::ParseError,
              "#{last_key} was defined as hash but is now redefined as a table!"
       end
-      hash[last_key] = [] unless hash[last_key]
-      hash[last_key] << {}
+      current[last_key] = [] unless current[last_key]
+      current[last_key] << {}
 
-      hash[last_key].last
+      current[last_key].last
     end
 
     def accept_visitor(parser)
@@ -37,14 +37,14 @@ module TomlRB
     end
 
     def full_key
-      @nested_keys.join('.')
+      @dotted_keys.join('.')
     end
   end
 
   # Used in document.citrus
   module TableArrayParser
     def value
-      TomlRB::TableArray.new(captures[:stripped_key].map(&:value))
+      TomlRB::TableArray.new(captures[:stripped_key].map(&:value).first)
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: toml-rb
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 2.0.0
 platform: ruby
 authors:
 - Emiliano Mancuso
@@ -9,26 +9,26 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-08-16 00:00:00.000000000 Z
+date: 2019-10-25 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'
 description: 'A Toml parser using Citrus parsing library. '
@@ -39,10 +39,11 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- LICENSE
 - README.md
-- Rakefile
 - 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/array.citrus
@@ -50,22 +51,12 @@ files:
 - lib/toml-rb/grammars/helper.citrus
 - lib/toml-rb/grammars/primitive.citrus
 - lib/toml-rb/inline_table.rb
-- lib/toml-rb/keygroup.rb
 - lib/toml-rb/keyvalue.rb
 - lib/toml-rb/parser.rb
 - lib/toml-rb/string.rb
+- lib/toml-rb/table.rb
 - lib/toml-rb/table_array.rb
-- test/dumper_test.rb
-- test/errors_test.rb
-- test/example-v0.4.0.toml
-- test/example.toml
-- test/grammar_test.rb
-- test/hard_example.toml
-- test/helper.rb
-- test/toml_examples.rb
-- test/toml_test.rb
-- toml-rb.gemspec
-homepage: http://github.com/emancu/toml-rb
+homepage: https://github.com/emancu/toml-rb
 licenses:
 - MIT
 metadata: {}
@@ -77,15 +68,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '1.9'
+      version: '2.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.14.1
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Toml parser in ruby, for ruby.

data/Rakefile

@@ -1,6 +0,0 @@
-require 'rake/testtask'
-
-Rake::TestTask.new do |t|
-  t.pattern = 'test/*_test.rb'
-end
-task default: :test

data/test/dumper_test.rb

@@ -1,94 +0,0 @@
-require_relative 'helper'
-
-class DumperTest < Minitest::Test
-  def test_dump_empty
-    dumped = TomlRB.dump({})
-    assert_equal('', dumped)
-  end
-
-  def test_dump_types
-    dumped = TomlRB.dump(string: 'TomlRB "dump"')
-    assert_equal("string = \"TomlRB \\\"dump\\\"\"\n", dumped)
-
-    dumped = TomlRB.dump(float: -13.24)
-    assert_equal("float = -13.24\n", dumped)
-
-    dumped = TomlRB.dump(int: 1234)
-    assert_equal("int = 1234\n", dumped)
-
-    dumped = TomlRB.dump(true: true)
-    assert_equal("true = true\n", dumped)
-
-    dumped = TomlRB.dump(false: false)
-    assert_equal("false = false\n", dumped)
-
-    dumped = TomlRB.dump(array: [1, 2, 3])
-    assert_equal("array = [1, 2, 3]\n", dumped)
-
-    dumped = TomlRB.dump(array: [[1, 2], %w(weird one)])
-    assert_equal("array = [[1, 2], [\"weird\", \"one\"]]\n", dumped)
-
-    dumped = TomlRB.dump(datetime: Time.utc(1986, 8, 28, 15, 15))
-    assert_equal("datetime = 1986-08-28T15:15:00Z\n", dumped)
-  end
-
-  def test_dump_nested_attributes
-    hash = { nested: { hash: { deep: true } } }
-    dumped = TomlRB.dump(hash)
-    assert_equal("[nested.hash]\ndeep = true\n", dumped)
-
-    hash[:nested].merge!(other: 12)
-    dumped = TomlRB.dump(hash)
-    assert_equal("[nested]\nother = 12\n[nested.hash]\ndeep = true\n", dumped)
-
-    hash[:nested].merge!(nest: { again: 'it never ends' })
-    dumped = TomlRB.dump(hash)
-    toml = <<-EOS.gsub(/^ {6}/, '')
-      [nested]
-      other = 12
-      [nested.hash]
-      deep = true
-      [nested.nest]
-      again = "it never ends"
-    EOS
-
-    assert_equal(toml, dumped)
-
-    hash = { non: { 'bare."keys"' => { "works" => true } } }
-    dumped = TomlRB.dump(hash)
-    assert_equal("[non.\"bare.\\\"keys\\\"\"]\nworks = true\n", dumped)
-
-    hash = { hola: [{ chau: 4 }, { chau: 3 }] }
-    dumped = TomlRB.dump(hash)
-    assert_equal("[[hola]]\nchau = 4\n[[hola]]\nchau = 3\n", dumped)
-  end
-
-  def test_print_empty_tables
-    hash = { plugins: { cpu: { foo: "bar", baz: 1234 }, disk: {}, io: {} } }
-    dumped = TomlRB.dump(hash)
-    toml = <<-EOS.gsub(/^ {6}/, '')
-      [plugins.cpu]
-      baz = 1234
-      foo = "bar"
-      [plugins.disk]
-      [plugins.io]
-    EOS
-
-    assert_equal toml, dumped
-  end
-
-  def test_dump_array_tables
-    hash = { fruit: [{ physical: { color: "red" } }, { physical: { color: "blue" } }] }
-    dumped = TomlRB.dump(hash)
-    toml = <<-EOS.gsub(/^ {6}/, '')
-      [[fruit]]
-      [fruit.physical]
-      color = "red"
-      [[fruit]]
-      [fruit.physical]
-      color = "blue"
-    EOS
-
-    assert_equal toml, dumped
-  end
-end

data/test/errors_test.rb

@@ -1,88 +0,0 @@
-require_relative 'helper'
-
-class ErrorsTest < Minitest::Test
-  def test_text_after_keygroup
-    str = "[error] if you didn't catch this, your parser is broken"
-    assert_raises(TomlRB::ParseError) { TomlRB.parse(str) }
-  end
-
-  def test_text_after_string
-    str = 'string = "Anything other than tabs, spaces and newline after a '
-    str += 'keygroup or key value pair has ended should produce an error '
-    str += 'unless it is a comment" like this'
-
-    assert_raises(TomlRB::ParseError) { TomlRB.parse(str) }
-  end
-
-  def test_multiline_array_bad_string
-    str = <<-EOS
-    array = [
-     "This might most likely happen in multiline arrays",
-     Like here,
-     "or here,
-     and here"
-     ] End of array comment, forgot the #
-    EOS
-
-    assert_raises(TomlRB::ParseError) { TomlRB.parse(str) }
-  end
-
-  def test_multiline_array_string_not_ended
-    str = <<-EOS
-    array = [
-     "This might most likely happen in multiline arrays",
-     "or here,
-     and here"
-     ] End of array comment, forgot the #
-    EOS
-
-    assert_raises(TomlRB::ParseError) { TomlRB.parse(str) }
-  end
-
-  def test_text_after_multiline_array
-    str = <<-EOS
-    array = [
-     "This might most likely happen in multiline arrays",
-     "or here",
-     "and here"
-     ] End of array comment, forgot the #
-    EOS
-
-    assert_raises(TomlRB::ParseError) { TomlRB.parse(str) }
-  end
-
-  def test_text_after_number
-    str = 'number = 3.14 pi <--again forgot the #'
-    assert_raises(TomlRB::ParseError) { TomlRB.parse(str) }
-  end
-
-  def test_value_overwrite
-    str = "a = 1\na = 2"
-    e = assert_raises(TomlRB::ValueOverwriteError) { TomlRB.parse(str) }
-    assert_equal "Key \"a\" is defined more than once", e.message
-    assert_equal "a", e.key
-
-    str = "a = false\na = true"
-    assert_raises(TomlRB::ValueOverwriteError) { TomlRB.parse(str) }
-  end
-
-  def test_table_overwrite
-    str = "[a]\nb=1\n[a]\nc=2"
-    e = assert_raises(TomlRB::ValueOverwriteError) { TomlRB.parse(str) }
-    assert_equal "Key \"a\" is defined more than once", e.message
-
-    str = "[a]\nb=1\n[a]\nb=1"
-    e = assert_raises(TomlRB::ValueOverwriteError) { TomlRB.parse(str) }
-    assert_equal "Key \"a\" is defined more than once", e.message
-  end
-
-  def test_value_overwrite_with_table
-    str = "[a]\nb=1\n[a.b]\nc=2"
-    e = assert_raises(TomlRB::ValueOverwriteError) { TomlRB.parse(str) }
-    assert_equal "Key \"b\" is defined more than once", e.message
-
-    str = "[a]\nb=1\n[a.b.c]\nd=3"
-    e = assert_raises(TomlRB::ValueOverwriteError) { TomlRB.parse(str) }
-    assert_equal "Key \"b\" is defined more than once", e.message
-  end
-end