toml-rb 0.3.15 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 001f3b29b58b8061a3e848a7df1e69302eec7bad
-  data.tar.gz: 6b8f4784ad8d116206460183734341cb1a470c09
+  metadata.gz: ac69523887231de77fcd7f39324df5eb7e372056
+  data.tar.gz: aa219d97002259cc6c73ddee1acef86776dfa365
 SHA512:
-  metadata.gz: 4de41bfb466539b49cdf5a75d6dc4c7d3080eda80a018026d35d0a3ba2ea6336ae2ee10f65fd5cfddfe57918953c64d13fba5f0e48005f8bcbc418de849e5dbf
-  data.tar.gz: 1e3d121f04784c614301bcc60913718f6b2b7dd818e83dbe8191e0644b9ea9f50d552326b370c99608e79c4bb4e5175502f841d43e659e1336d172a3e72e7ab8
+  metadata.gz: 87a4601c420d0455d4a3aff4b1f825c7fe34d41125b636de125862a47c6adcf8f8387fe9d8eb76232aa3f03d5a8a008ae460a9be4a459f7292916d36f9df6360
+  data.tar.gz: 172e265a83e3aaa2a4750959eaf66f00e41fb01c316f17a6e16bdb60f163d66aef055f123b58933a9c657e92cb1234eef709d07a2b290ce32acc6903a83bb7f4

data/README.md

@@ -6,9 +6,9 @@ toml-rb
 [![Code Climate](https://codeclimate.com/github/emancu/toml-rb/badges/gpa.svg)](https://codeclimate.com/github/emancu/toml-rb)
 [![Dependency Status](https://gemnasium.com/emancu/toml-rb.svg)](https://gemnasium.com/emancu/toml-rb)
 
-A [TOML](https://github.com/toml-lang/toml) parser using [Citrus](http://mjackson.github.io/citrus) library.
+A [TomlRB](https://github.com/toml-lang/toml) parser using [Citrus](http://mjackson.github.io/citrus) library.
 
-TOML specs supported: `0.4.0`
+TomlRB specs supported: `0.4.0`
 
 Installation
 ------------
@@ -23,7 +23,7 @@ require 'toml'
 
 # From a file!
 path = File.join(File.dirname(__FILE__), 'path', 'to', 'file')
-TOML.load_file(path)
+TomlRB.load_file(path)
 
 # From a stream!
 stream = <<-EOS
@@ -33,12 +33,12 @@ stream = <<-EOS
     you    = true
     others = false
 EOS
-TOML.parse(stream)
+TomlRB.parse(stream)
 # => {"title"=>"wow!", "awesome"=>{"you"=>true, "others"=>false}}
 
 # You want symbols as your keys? No problem!
-TOML.load_file(path, symbolize_keys: true) 
-# Works the same for TOML.parse
+TomlRB.load_file(path, symbolize_keys: true) 
+# Works the same for TomlRB.parse
 ```
 
 Dumper Usage
@@ -48,7 +48,7 @@ Dumper Usage
 require 'toml'
 
 # Simple example
-TOML.dump( simple: true)
+TomlRB.dump( simple: true)
 # => "simple = true\n"
 
 
@@ -61,7 +61,7 @@ hash = {
     }
 }
 
-TOML.dump(hash)
+TomlRB.dump(hash)
 # => "title = \"wow!\"\n[awesome]\nothers = false\nyou = true\n"
 ```
 

data/init.rb

@@ -2,17 +2,17 @@ require 'citrus'
 
 ROOT = File.dirname(File.expand_path(__FILE__))
 
-require "#{ROOT}/lib/toml/errors"
-require "#{ROOT}/lib/toml/array"
-require "#{ROOT}/lib/toml/string"
-require "#{ROOT}/lib/toml/table_array"
-require "#{ROOT}/lib/toml/inline_table"
-require "#{ROOT}/lib/toml/keyvalue"
-require "#{ROOT}/lib/toml/keygroup"
-require "#{ROOT}/lib/toml/parser"
-require "#{ROOT}/lib/toml/dumper"
+require "#{ROOT}/lib/toml-rb/errors"
+require "#{ROOT}/lib/toml-rb/array"
+require "#{ROOT}/lib/toml-rb/string"
+require "#{ROOT}/lib/toml-rb/table_array"
+require "#{ROOT}/lib/toml-rb/inline_table"
+require "#{ROOT}/lib/toml-rb/keyvalue"
+require "#{ROOT}/lib/toml-rb/keygroup"
+require "#{ROOT}/lib/toml-rb/parser"
+require "#{ROOT}/lib/toml-rb/dumper"
 
-Citrus.load "#{ROOT}/lib/toml/grammars/helper.citrus"
-Citrus.load "#{ROOT}/lib/toml/grammars/primitive.citrus"
-Citrus.load "#{ROOT}/lib/toml/grammars/array.citrus"
-Citrus.load "#{ROOT}/lib/toml/grammars/document.citrus"
+Citrus.load "#{ROOT}/lib/toml-rb/grammars/helper.citrus"
+Citrus.load "#{ROOT}/lib/toml-rb/grammars/primitive.citrus"
+Citrus.load "#{ROOT}/lib/toml-rb/grammars/array.citrus"
+Citrus.load "#{ROOT}/lib/toml-rb/grammars/document.citrus"

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

@@ -1,68 +1,68 @@
 require_relative '../init'
 
-module TOML
-  # Public: Returns a hash from *TOML* content.
+module TomlRB
+  # Public: Returns a hash from *TomlRB* content.
   #
-  # content - TOML string to be parsed.
+  # content - TomlRB string to be parsed.
   # options - The Hash options used to refine the parser (default: {}):
   #           :symbolize_keys - true|false (optional).
   #
   #
   # Examples
   #
-  #   TOML.parse('[group]')
+  #   TomlRB.parse('[group]')
   #   # => {"group"=>{}}
   #
-  #   TOML.parse('title = "TOML parser"')
-  #   # => {"title"=>"TOML parser"}
+  #   TomlRB.parse('title = "TomlRB parser"')
+  #   # => {"title"=>"TomlRB parser"}
   #
-  #   TOML.parse('[group]', symbolize_keys: true)
+  #   TomlRB.parse('[group]', symbolize_keys: true)
   #   # => {group: {}}
   #
-  #   TOML.parse('title = "TOML parser"', symbolize_keys: true)
-  #   # => {title: "TOML parser"}
+  #   TomlRB.parse('title = "TomlRB parser"', symbolize_keys: true)
+  #   # => {title: "TomlRB parser"}
   #
   #
-  # Returns a Ruby hash representation of the content according to TOML spec.
+  # Returns a Ruby hash representation of the content according to TomlRB spec.
   # Raises ValueOverwriteError if a key is overwritten.
-  # Raises ParseError if the content has invalid TOML.
+  # Raises ParseError if the content has invalid TomlRB.
   def self.parse(content, options = {})
     Parser.new(content, options).hash
   end
 
-  # Public: Returns a hash from a *TOML* file.
+  # Public: Returns a hash from a *TomlRB* file.
   #
-  # path    - TOML File path
+  # path    - TomlRB File path
   # options - The Hash options used to refine the parser (default: {}):
   #           :symbolize_keys - true|false (optional).
   #
   #
   # Examples
   #
-  #   TOML.load_file('/tmp/simple.toml')
+  #   TomlRB.load_file('/tmp/simple.toml')
   #   # => {"group"=>{}}
   #
-  #   TOML.load_file('/tmp/simple.toml', symbolize_keys: true)
+  #   TomlRB.load_file('/tmp/simple.toml', symbolize_keys: true)
   #   # => {group: {}}
   #
   #
   # Returns a Ruby hash representation of the content.
   # Raises ValueOverwriteError if a key is overwritten.
-  # Raises ParseError if the content has invalid TOML.
+  # Raises ParseError if the content has invalid TomlRB.
   # Raises Errno::ENOENT if the file cannot be found.
   # Raises Errno::EACCES if the file cannot be accessed.
   def self.load_file(path, options = {})
-    TOML.parse(File.read(path), options)
+    TomlRB.parse(File.read(path), options)
   end
 
-  # Public: Returns a *TOML* string from a Ruby Hash.
+  # Public: Returns a *TomlRB* string from a Ruby Hash.
   #
-  # hash - Ruby Hash to be dumped into *TOML*
+  # hash - Ruby Hash to be dumped into *TomlRB*
   #
   #
   # Examples
   #
-  #   TOML.dump(title: 'TOML dump')
+  #   TomlRB.dump(title: 'TomlRB dump')
   #   # => "simple = true\n"
   #
   #   hash = {
@@ -73,11 +73,11 @@ module TOML
   #     }
   #   }
   #
-  #   TOML.dump(hash)
+  #   TomlRB.dump(hash)
   #   # => "title = \"wow!\"\n[awesome]\nothers = false\nyou = true\n"
   #
   #
-  # Returns a TOML string representing the hash.
+  # Returns a TomlRB string representing the hash.
   def self.dump(hash)
     Dumper.new(hash).toml_str
   end

data/lib/{toml → toml-rb}/array.rb

@@ -1,4 +1,4 @@
-module TOML
+module TomlRB
   module ArrayParser
     def value
       elements = captures[:elements].first

data/lib/{toml → toml-rb}/dumper.rb

@@ -1,4 +1,4 @@
-module TOML
+module TomlRB
   class Dumper
     attr_reader :toml_str
 

data/lib/{toml → toml-rb}/errors.rb

@@ -1,5 +1,5 @@
-module TOML
-  # Parent class for all TOML errors
+module TomlRB
+  # Parent class for all TomlRB errors
   Error = Class.new(StandardError)
 
   # Error related to parsing.

data/lib/{toml → toml-rb}/grammars/array.citrus

@@ -1,8 +1,8 @@
-grammar TOML::Arrays
-  include TOML::Primitive
+grammar TomlRB::Arrays
+  include TomlRB::Primitive
 
   rule array
-    ("[" array_comments (elements)? space ","? array_comments "]" indent?) <TOML::ArrayParser>
+    ("[" array_comments (elements)? space ","? array_comments "]" indent?) <TomlRB::ArrayParser>
   end
 
   rule array_comments

data/lib/{toml → toml-rb}/grammars/document.citrus

@@ -1,29 +1,29 @@
-grammar TOML::Document
-  include TOML::Primitive
-  include TOML::Arrays
+grammar TomlRB::Document
+  include TomlRB::Primitive
+  include TomlRB::Arrays
 
   rule document
     (comment | table_array | keygroup | keyvalue | line_break)*
   end
 
   rule table_array
-    (space? '[[' stripped_key ("." stripped_key)* ']]' comment?) <TOML::TableArrayParser>
+    (space? '[[' stripped_key ("." stripped_key)* ']]' comment?) <TomlRB::TableArrayParser>
   end
 
   rule keygroup
-    (space? '[' stripped_key ("." stripped_key)* ']' comment?) <TOML::KeygroupParser>
+    (space? '[' stripped_key ("." stripped_key)* ']' comment?) <TomlRB::KeygroupParser>
   end
 
   rule keyvalue
-    (stripped_key '=' space? v:(toml_values) comment?) <TOML::KeyvalueParser>
+    (stripped_key '=' space? v:(toml_values) comment?) <TomlRB::KeyvalueParser>
   end
 
   rule inline_table
-    (space? '{' (keyvalue (',' keyvalue)*)? space? '}' ) <TOML::InlineTableParser>
+    (space? '{' (keyvalue (',' keyvalue)*)? space? '}' ) <TomlRB::InlineTableParser>
   end
 
   rule inline_table_array
-    ("[" array_comments inline_table_array_elements space ","? array_comments "]" indent?) <TOML::InlineTableArrayParser>
+    ("[" array_comments inline_table_array_elements space ","? array_comments "]" indent?) <TomlRB::InlineTableArrayParser>
   end
 
   rule inline_table_array_elements

data/lib/{toml → toml-rb}/grammars/helper.citrus

@@ -1,4 +1,4 @@
-grammar TOML::Helper
+grammar TomlRB::Helper
   rule comment
     (space? "#" (~line_break)* line_break?) { nil }
   end

data/lib/{toml → toml-rb}/grammars/primitive.citrus

@@ -1,5 +1,5 @@
-grammar TOML::Primitive
-  include TOML::Helper
+grammar TomlRB::Primitive
+  include TomlRB::Helper
 
   rule primitive
     string | bool | datetime | number
@@ -14,19 +14,19 @@ grammar TOML::Primitive
   end
 
   rule basic_string
-    (/(["])(?:\\?.)*?\1/ space) <TOML::BasicString>
+    (/(["])(?:\\?.)*?\1/ space) <TomlRB::BasicString>
   end
 
   rule literal_string
-    (/(['])(?:\\?.)*?\1/ space) <TOML::LiteralString>
+    (/(['])(?:\\?.)*?\1/ space) <TomlRB::LiteralString>
   end
 
   rule multiline_string
-    ('"""' line_break* (text:~('"""' !'"')|'') '"""' space) <TOML::MultilineString>
+    ('"""' line_break* (text:~('"""' !'"')|'') '"""' space) <TomlRB::MultilineString>
   end
 
   rule multiline_literal
-    ("'''" line_break* (text:~("'''" !"'")|'') "'''" space) <TOML::MultilineLiteral>
+    ("'''" line_break* (text:~("'''" !"'")|'') "'''" space) <TomlRB::MultilineLiteral>
   end
 
   ##

data/lib/{toml → toml-rb}/inline_table.rb

@@ -1,4 +1,4 @@
-module TOML
+module TomlRB
   class InlineTable
     attr_reader :symbolize_keys
 
@@ -56,7 +56,7 @@ module TOML
 
   module InlineTableParser
     def value
-      TOML::InlineTable.new captures[:keyvalue].map(&:value)
+      TomlRB::InlineTable.new captures[:keyvalue].map(&:value)
     end
   end
 
@@ -66,7 +66,7 @@ module TOML
         x.captures[:inline_table]
       end
 
-      TOML::InlineTableArray.new(tables.flatten.map(&:value)).value
+      TomlRB::InlineTableArray.new(tables.flatten.map(&:value)).value
     end
   end
 end

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

@@ -1,4 +1,4 @@
-module TOML
+module TomlRB
   class Keygroup
     def initialize(nested_keys)
       @nested_keys = nested_keys
@@ -35,7 +35,7 @@ module TOML
   # Used in document.citrus
   module KeygroupParser
     def value
-      TOML::Keygroup.new(captures[:stripped_key].map(&:value))
+      TomlRB::Keygroup.new(captures[:stripped_key].map(&:value))
     end
   end
 end

data/lib/{toml → toml-rb}/keyvalue.rb

@@ -1,4 +1,4 @@
-module TOML
+module TomlRB
   class Keyvalue
     attr_reader :value, :symbolize_keys
 
@@ -43,7 +43,7 @@ module TOML
   # Used in document.citrus
   module KeyvalueParser
     def value
-      TOML::Keyvalue.new(capture(:stripped_key).value, capture(:v).value)
+      TomlRB::Keyvalue.new(capture(:stripped_key).value, capture(:v).value)
     end
   end
 end

data/lib/{toml → toml-rb}/parser.rb

@@ -1,4 +1,4 @@
-module TOML
+module TomlRB
   class Parser
     attr_reader :hash
 
@@ -9,10 +9,10 @@ module TOML
       @symbolize_keys = options[:symbolize_keys]
 
       begin
-        parsed = TOML::Document.parse(content)
+        parsed = TomlRB::Document.parse(content)
         parsed.matches.map(&:value).compact.each { |m| m.accept_visitor(self) }
       rescue Citrus::ParseError => e
-        raise TOML::ParseError.new(e.message)
+        raise TomlRB::ParseError.new(e.message)
       end
     end
 

data/lib/{toml → toml-rb}/string.rb

@@ -1,4 +1,4 @@
-module TOML
+module TomlRB
   # Used in primitive.citrus
   module BasicString
     SPECIAL_CHARS = {
@@ -13,7 +13,7 @@ module TOML
     }.freeze
 
     def value
-      aux = TOML::BasicString.transform_escaped_chars first.value
+      aux = TomlRB::BasicString.transform_escaped_chars first.value
 
       aux[1...-1]
     end
@@ -53,7 +53,7 @@ module TOML
       # Remove spaces on multilined Singleline strings
       aux.gsub!(/\\\r?\n[\n\t\r ]*/, '')
 
-      TOML::BasicString.transform_escaped_chars aux
+      TomlRB::BasicString.transform_escaped_chars aux
     end
   end
 

data/lib/{toml → toml-rb}/table_array.rb

@@ -1,4 +1,4 @@
-module TOML
+module TomlRB
   class TableArray
     def initialize(nested_keys)
       @nested_keys = nested_keys
@@ -22,7 +22,7 @@ module TOML
 
       # Define Table Array
       if hash[last_key].is_a? Hash
-        fail TOML::ParseError,
+        fail TomlRB::ParseError,
              "#{last_key} was defined as hash but is now redefined as a table!"
       end
       hash[last_key] = [] unless hash[last_key]
@@ -43,7 +43,7 @@ module TOML
   # Used in document.citrus
   module TableArrayParser
     def value
-      TOML::TableArray.new(captures[:stripped_key].map(&:value))
+      TomlRB::TableArray.new(captures[:stripped_key].map(&:value))
     end
   end
 end

data/test/dumper_test.rb

@@ -2,47 +2,47 @@ require_relative 'helper'
 
 class DumperTest < Minitest::Test
   def test_dump_empty
-    dumped = TOML.dump({})
+    dumped = TomlRB.dump({})
     assert_equal('', dumped)
   end
 
   def test_dump_types
-    dumped = TOML.dump(string: 'TOML "dump"')
-    assert_equal("string = \"TOML \\\"dump\\\"\"\n", dumped)
+    dumped = TomlRB.dump(string: 'TomlRB "dump"')
+    assert_equal("string = \"TomlRB \\\"dump\\\"\"\n", dumped)
 
-    dumped = TOML.dump(float: -13.24)
+    dumped = TomlRB.dump(float: -13.24)
     assert_equal("float = -13.24\n", dumped)
 
-    dumped = TOML.dump(int: 1234)
+    dumped = TomlRB.dump(int: 1234)
     assert_equal("int = 1234\n", dumped)
 
-    dumped = TOML.dump(true: true)
+    dumped = TomlRB.dump(true: true)
     assert_equal("true = true\n", dumped)
 
-    dumped = TOML.dump(false: false)
+    dumped = TomlRB.dump(false: false)
     assert_equal("false = false\n", dumped)
 
-    dumped = TOML.dump(array: [1, 2, 3])
+    dumped = TomlRB.dump(array: [1, 2, 3])
     assert_equal("array = [1, 2, 3]\n", dumped)
 
-    dumped = TOML.dump(array: [[1, 2], %w(weird one)])
+    dumped = TomlRB.dump(array: [[1, 2], %w(weird one)])
     assert_equal("array = [[1, 2], [\"weird\", \"one\"]]\n", dumped)
 
-    dumped = TOML.dump(datetime: Time.utc(1986, 8, 28, 15, 15))
+    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 = TOML.dump(hash)
+    dumped = TomlRB.dump(hash)
     assert_equal("[nested.hash]\ndeep = true\n", dumped)
 
     hash[:nested].merge!(other: 12)
-    dumped = TOML.dump(hash)
+    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 = TOML.dump(hash)
+    dumped = TomlRB.dump(hash)
     toml = <<-EOS.gsub(/^ {6}/, '')
       [nested]
       other = 12
@@ -55,17 +55,17 @@ class DumperTest < Minitest::Test
     assert_equal(toml, dumped)
 
     hash = { non: { 'bare."keys"' => { "works" => true } } }
-    dumped = TOML.dump(hash)
+    dumped = TomlRB.dump(hash)
     assert_equal("[non.\"bare.\\\"keys\\\"\"]\nworks = true\n", dumped)
 
     hash = { hola: [{ chau: 4 }, { chau: 3 }] }
-    dumped = TOML.dump(hash)
+    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 = TOML.dump(hash)
+    dumped = TomlRB.dump(hash)
     toml = <<-EOS.gsub(/^ {6}/, '')
       [plugins.cpu]
       baz = 1234
@@ -79,7 +79,7 @@ class DumperTest < Minitest::Test
 
   def test_dump_array_tables
     hash = { fruit: [{ physical: { color: "red" } }, { physical: { color: "blue" } }] }
-    dumped = TOML.dump(hash)
+    dumped = TomlRB.dump(hash)
     toml = <<-EOS.gsub(/^ {6}/, '')
       [[fruit]]
       [fruit.physical]

data/test/errors_test.rb

@@ -3,7 +3,7 @@ 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(TOML::ParseError) { TOML.parse(str) }
+    assert_raises(TomlRB::ParseError) { TomlRB.parse(str) }
   end
 
   def test_text_after_string
@@ -11,7 +11,7 @@ class ErrorsTest < Minitest::Test
     str += 'keygroup or key value pair has ended should produce an error '
     str += 'unless it is a comment" like this'
 
-    assert_raises(TOML::ParseError) { TOML.parse(str) }
+    assert_raises(TomlRB::ParseError) { TomlRB.parse(str) }
   end
 
   def test_multiline_array_bad_string
@@ -24,7 +24,7 @@ class ErrorsTest < Minitest::Test
      ] End of array comment, forgot the #
     EOS
 
-    assert_raises(TOML::ParseError) { TOML.parse(str) }
+    assert_raises(TomlRB::ParseError) { TomlRB.parse(str) }
   end
 
   def test_multiline_array_string_not_ended
@@ -36,7 +36,7 @@ class ErrorsTest < Minitest::Test
      ] End of array comment, forgot the #
     EOS
 
-    assert_raises(TOML::ParseError) { TOML.parse(str) }
+    assert_raises(TomlRB::ParseError) { TomlRB.parse(str) }
   end
 
   def test_text_after_multiline_array
@@ -48,41 +48,41 @@ class ErrorsTest < Minitest::Test
      ] End of array comment, forgot the #
     EOS
 
-    assert_raises(TOML::ParseError) { TOML.parse(str) }
+    assert_raises(TomlRB::ParseError) { TomlRB.parse(str) }
   end
 
   def test_text_after_number
     str = 'number = 3.14 pi <--again forgot the #'
-    assert_raises(TOML::ParseError) { TOML.parse(str) }
+    assert_raises(TomlRB::ParseError) { TomlRB.parse(str) }
   end
 
   def test_value_overwrite
     str = "a = 1\na = 2"
-    e = assert_raises(TOML::ValueOverwriteError) { TOML.parse(str) }
+    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(TOML::ValueOverwriteError) { TOML.parse(str) }
+    assert_raises(TomlRB::ValueOverwriteError) { TomlRB.parse(str) }
   end
 
   def test_table_overwrite
     str = "[a]\nb=1\n[a]\nc=2"
-    e = assert_raises(TOML::ValueOverwriteError) { TOML.parse(str) }
+    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(TOML::ValueOverwriteError) { TOML.parse(str) }
+    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(TOML::ValueOverwriteError) { TOML.parse(str) }
+    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(TOML::ValueOverwriteError) { TOML.parse(str) }
+    e = assert_raises(TomlRB::ValueOverwriteError) { TomlRB.parse(str) }
     assert_equal "Key \"b\" is defined more than once", e.message
   end
 end

data/test/example-v0.4.0.toml

@@ -22,7 +22,7 @@ key = "value" # Yeah, you can do this.
 
 key = "another value"
 
-# You don't need to specify all the super-tables if you don't want to. TOML
+# You don't need to specify all the super-tables if you don't want to. TomlRB
 # knows how to do it for you.
 
 # [x] you

data/test/example.toml

@@ -1,6 +1,6 @@
-# This is a TOML document. Boom.
+# This is a TomlRB document. Boom.
 
-title = "TOML Example"
+title = "TomlRB Example"
 
 [owner]
 name = "Tom Preston-Werner"
@@ -16,7 +16,7 @@ enabled = true
 
 [servers]
 
-  # You can indent as you please. Tabs or spaces. TOML don't care.
+  # You can indent as you please. Tabs or spaces. TomlRB don't care.
   [servers.alpha]
   ip = "10.0.0.1"
   dc = "eqdc10"

data/test/grammar_test.rb

@@ -3,50 +3,50 @@ require_relative 'helper'
 
 class GrammarTest < Minitest::Test
   def test_comment
-    match = TOML::Document.parse(' # A comment', root: :comment)
+    match = TomlRB::Document.parse(' # A comment', root: :comment)
     assert_equal(nil, match.value)
   end
 
   def test_key
-    match = TOML::Document.parse('bad_key-', root: :key)
+    match = TomlRB::Document.parse('bad_key-', root: :key)
     assert_equal('bad_key-', match.value)
 
-    match = TOML::Document.parse('"123.ʎǝʞ.#?"', root: :key)
+    match = TomlRB::Document.parse('"123.ʎǝʞ.#?"', root: :key)
     assert_equal('123.ʎǝʞ.#?', match.value)
   end
 
   def test_keygroup
     indentation_alternatives_for('[akey]') do |str|
-      match = TOML::Document.parse(str, root: :keygroup)
-      assert_equal(TOML::Keygroup, match.value.class)
+      match = TomlRB::Document.parse(str, root: :keygroup)
+      assert_equal(TomlRB::Keygroup, match.value.class)
       assert_equal(['akey'], match.value.instance_variable_get('@nested_keys'))
     end
 
-    match = TOML::Document.parse('[owner.emancu]', root: :keygroup)
+    match = TomlRB::Document.parse('[owner.emancu]', root: :keygroup)
     assert_equal(%w(owner emancu),
                  match.value.instance_variable_get('@nested_keys'))
 
-    match = TOML::Document.parse('["owner.emancu"]', root: :keygroup)
+    match = TomlRB::Document.parse('["owner.emancu"]', root: :keygroup)
     assert_equal(%w(owner.emancu),
                  match.value.instance_variable_get('@nested_keys'))
 
-    match = TOML::Document.parse('["first key"."second key"]', root: :keygroup)
+    match = TomlRB::Document.parse('["first key"."second key"]', root: :keygroup)
     assert_equal(['first key', 'second key'],
                  match.value.instance_variable_get('@nested_keys'))
 
-    match = TOML::Document.parse('[ owner . emancu ]', root: :keygroup)
+    match = TomlRB::Document.parse('[ owner . emancu ]', root: :keygroup)
     assert_equal(%w(owner emancu),
                  match.value.instance_variable_get('@nested_keys'))
 
     assert_raises Citrus::ParseError do
-      TOML::Document.parse('[ owner emancu ]', root: :keygroup)
+      TomlRB::Document.parse('[ owner emancu ]', root: :keygroup)
     end
   end
 
   def test_keyvalue
     indentation_alternatives_for('key = "value"') do |str|
-      match = TOML::Document.parse(str, root: :keyvalue)
-      assert_equal(TOML::Keyvalue, match.value.class)
+      match = TomlRB::Document.parse(str, root: :keyvalue)
+      assert_equal(TomlRB::Keyvalue, match.value.class)
 
       keyvalue = match.value
       assert_equal('key', keyvalue.instance_variable_get('@key'))
@@ -55,12 +55,12 @@ class GrammarTest < Minitest::Test
   end
 
   def test_string
-    match = TOML::Document.parse('"TOML-Example, should work."', root: :string)
-    assert_equal('TOML-Example, should work.', match.value)
+    match = TomlRB::Document.parse('"TomlRB-Example, should work."', root: :string)
+    assert_equal('TomlRB-Example, should work.', match.value)
   end
 
   def test_multiline_string
-    match = TOML::Document.parse('"""\tOne\nTwo"""', root: :multiline_string)
+    match = TomlRB::Document.parse('"""\tOne\nTwo"""', root: :multiline_string)
     assert_equal "\tOne\nTwo", match.value
 
     to_parse = '"""\
@@ -68,161 +68,161 @@ class GrammarTest < Minitest::Test
     Two\
     """'
 
-    match = TOML::Document.parse(to_parse, root: :multiline_string)
+    match = TomlRB::Document.parse(to_parse, root: :multiline_string)
     assert_equal "One Two", match.value
   end
 
   def test_empty_multiline_string
     to_parse = '""""""'
 
-    match = TOML::Document.parse(to_parse, root: :multiline_string)
+    match = TomlRB::Document.parse(to_parse, root: :multiline_string)
     assert_equal '', match.value
   end
 
   def test_special_characters
-    match = TOML::Document.parse('"\0 \" \t \n \r"', root: :string)
+    match = TomlRB::Document.parse('"\0 \" \t \n \r"', root: :string)
     assert_equal("\0 \" \t \n \r", match.value)
 
-    match = TOML::Document.parse('"C:\\\\Documents\\\\nada.exe"', root: :string)
+    match = TomlRB::Document.parse('"C:\\\\Documents\\\\nada.exe"', root: :string)
     assert_equal('C:\\Documents\\nada.exe', match.value)
   end
 
   def test_bool
-    match = TOML::Document.parse('true', root: :bool)
+    match = TomlRB::Document.parse('true', root: :bool)
     assert_equal(true, match.value)
 
-    match = TOML::Document.parse('false', root: :bool)
+    match = TomlRB::Document.parse('false', root: :bool)
     assert_equal(false, match.value)
   end
 
   def test_integer
-    match = TOML::Document.parse('26', root: :number)
+    match = TomlRB::Document.parse('26', root: :number)
     assert_equal(26, match.value)
 
-    match = TOML::Document.parse('1_200_000_999', root: :number)
+    match = TomlRB::Document.parse('1_200_000_999', root: :number)
     assert_equal(1_200_000_999, match.value)
   end
 
   def test_float
-    match = TOML::Document.parse('1.69', root: :number)
+    match = TomlRB::Document.parse('1.69', root: :number)
     assert_equal(1.69, match.value)
 
-    match = TOML::Document.parse('1_000.69', root: :number)
+    match = TomlRB::Document.parse('1_000.69', root: :number)
     assert_equal(1000.69, match.value)
 
-    match = TOML::Document.parse('1e6', root: :number)
+    match = TomlRB::Document.parse('1e6', root: :number)
     assert_equal(1e6, match.value)
 
-    match = TOML::Document.parse('1.02e-46', root: :number)
+    match = TomlRB::Document.parse('1.02e-46', root: :number)
     assert_equal(1.02e-46, match.value)
 
-    match = TOML::Document.parse('+1e4_000_000', root: :number)
+    match = TomlRB::Document.parse('+1e4_000_000', root: :number)
     assert_equal(1e4_000_000, match.value)
   end
 
   def test_signed_numbers
-    match = TOML::Document.parse('+26', root: :number)
+    match = TomlRB::Document.parse('+26', root: :number)
     assert_equal(26, match.value)
 
-    match = TOML::Document.parse('-26', root: :number)
+    match = TomlRB::Document.parse('-26', root: :number)
     assert_equal(-26, match.value)
 
-    match = TOML::Document.parse('1.69', root: :number)
+    match = TomlRB::Document.parse('1.69', root: :number)
     assert_equal(1.69, match.value)
 
-    match = TOML::Document.parse('-1.69', root: :number)
+    match = TomlRB::Document.parse('-1.69', root: :number)
     assert_equal(-1.69, match.value)
   end
 
   def test_expressions_with_comments
-    match = TOML::Document.parse('[shouldwork] # with comment', root: :keygroup)
+    match = TomlRB::Document.parse('[shouldwork] # with comment', root: :keygroup)
     assert_equal(['shouldwork'],
                  match.value.instance_variable_get('@nested_keys'))
 
-    match = TOML::Document.parse('works = true # with comment', root: :keyvalue).value
+    match = TomlRB::Document.parse('works = true # with comment', root: :keyvalue).value
     assert_equal('works', match.instance_variable_get('@key'))
     assert_equal(true, match.instance_variable_get('@value'))
   end
 
   def test_array
-    match = TOML::Document.parse('[]', root: :array)
+    match = TomlRB::Document.parse('[]', root: :array)
     assert_equal([], match.value)
 
-    match = TOML::Document.parse('[ 2, 4]', root: :array)
+    match = TomlRB::Document.parse('[ 2, 4]', root: :array)
     assert_equal([2, 4], match.value)
 
-    match = TOML::Document.parse('[ 2.4, 4.72]', root: :array)
+    match = TomlRB::Document.parse('[ 2.4, 4.72]', root: :array)
     assert_equal([2.4, 4.72], match.value)
 
-    match = TOML::Document.parse('[ "hey", "TOML"]', root: :array)
-    assert_equal(%w(hey TOML), match.value)
+    match = TomlRB::Document.parse('[ "hey", "TomlRB"]', root: :array)
+    assert_equal(%w(hey TomlRB), match.value)
 
-    match = TOML::Document.parse('[ ["hey", "TOML"], [2,4] ]', root: :array)
-    assert_equal([%w(hey TOML), [2, 4]], match.value)
+    match = TomlRB::Document.parse('[ ["hey", "TomlRB"], [2,4] ]', root: :array)
+    assert_equal([%w(hey TomlRB), [2, 4]], match.value)
 
-    match = TOML::Document.parse('[ { one = 1 }, { two = 2, three = 3} ]',
+    match = TomlRB::Document.parse('[ { one = 1 }, { two = 2, three = 3} ]',
                                  root: :inline_table_array)
     assert_equal([{ 'one' => 1 }, { 'two' => 2, 'three' => 3 }], match.value)
   end
 
   def test_empty_array
     # test that [] is parsed as array and not as inline table array
-    match = TOML::Document.parse("a = []", root: :keyvalue).value
+    match = TomlRB::Document.parse("a = []", root: :keyvalue).value
     assert_equal [], match.value
   end
 
   def test_multiline_array
     multiline_array = "[ \"hey\",\n   \"ho\",\n\t \"lets\", \"go\",\n ]"
-    match = TOML::Document.parse(multiline_array, root: :array)
+    match = TomlRB::Document.parse(multiline_array, root: :array)
     assert_equal(%w(hey ho lets go), match.value)
 
     multiline_array = "[\n#1,\n2,\n# 3\n]"
-    match = TOML::Document.parse(multiline_array, root: :array)
+    match = TomlRB::Document.parse(multiline_array, root: :array)
     assert_equal([2], match.value)
 
     multiline_array = "[\n# comment\n#, more comments\n4]"
-    match = TOML::Document.parse(multiline_array, root: :array)
+    match = TomlRB::Document.parse(multiline_array, root: :array)
     assert_equal([4], match.value)
 
     multiline_array = "[\n  1,\n  # 2,\n  3 ,\n]"
-    match = TOML::Document.parse(multiline_array, root: :array)
+    match = TomlRB::Document.parse(multiline_array, root: :array)
     assert_equal([1, 3], match.value)
 
     multiline_array = "[\n  1 , # useless comment\n  # 2,\n  3 #other comment\n]"
-    match = TOML::Document.parse(multiline_array, root: :array)
+    match = TomlRB::Document.parse(multiline_array, root: :array)
     assert_equal([1, 3], match.value)
   end
 
   # Dates are really hard to test from JSON, due the imposibility to represent
   # datetimes without quotes.
   def test_datetime
-    match = TOML::Document.parse('1986-08-28T15:15:00Z', root: :datetime)
+    match = TomlRB::Document.parse('1986-08-28T15:15:00Z', root: :datetime)
     assert_equal(Time.utc(1986, 8, 28, 15, 15), match.value)
 
-    match = TOML::Document.parse('1986-08-28T15:15:00-03:00', root: :datetime)
+    match = TomlRB::Document.parse('1986-08-28T15:15:00-03:00', root: :datetime)
     assert_equal(Time.utc(1986, 8, 28, 18, 15), match.value)
 
-    match = TOML::Document.parse('1986-08-28T15:15:00.123-03:00', root: :datetime)
+    match = TomlRB::Document.parse('1986-08-28T15:15:00.123-03:00', root: :datetime)
     assert_equal(Time.utc(1986, 8, 28, 18, 15, 0.123), match.value)
 
-    match = TOML::Document.parse('1986-08-28', root: :datetime)
+    match = TomlRB::Document.parse('1986-08-28', root: :datetime)
     assert_equal(Time.utc(1986, 8, 28, 0, 0, 0), match.value)
 
-    match = TOML::Document.parse('1986-08-28T15:15:00', root: :datetime)
+    match = TomlRB::Document.parse('1986-08-28T15:15:00', root: :datetime)
     assert_equal(Time.utc(1986, 8, 28, 15, 15), match.value)
 
-    match = TOML::Document.parse('1986-08-28T15:15:00.999999', root: :datetime)
+    match = TomlRB::Document.parse('1986-08-28T15:15:00.999999', root: :datetime)
     assert_equal(Time.utc(1986, 8, 28, 15, 15, 0.999999), match.value)
   end
 
   def test_inline_table
-    match = TOML::Document.parse('{ }', root: :inline_table)
+    match = TomlRB::Document.parse('{ }', root: :inline_table)
     assert_equal({}, match.value.value)
 
-    match = TOML::Document.parse('{ simple = true, params = 2 }', root: :inline_table)
+    match = TomlRB::Document.parse('{ simple = true, params = 2 }', root: :inline_table)
     assert_equal({ 'simple' => true, 'params' => 2 }, match.value.value)
 
-    match = TOML::Document.parse('{ nest = { really = { hard = true } } }',
+    match = TomlRB::Document.parse('{ nest = { really = { hard = true } } }',
                                  root: :inline_table)
     assert_equal({ 'nest' => { 'really' => { 'hard' => true } } }, match.value.value)
     assert_equal({ nest: { really: { hard: true } } }, match.value.value(true))

data/test/hard_example.toml

@@ -1,5 +1,5 @@
-# Test file for TOML
-# Only this one tries to emulate a TOML file written by a user of the kind of parser writers probably hate
+# Test file for TomlRB
+# Only this one tries to emulate a TomlRB file written by a user of the kind of parser writers probably hate
 # This part you'll really hate
 
 [the]

data/test/helper.rb

@@ -1,2 +1,2 @@
 require 'minitest/autorun'
-require_relative '../lib/toml'
+require_relative '../lib/toml-rb'

data/test/toml_examples.rb

@@ -1,4 +1,4 @@
-class TOML::Examples
+class TomlRB::Examples
   def self.example_v_0_4_0
     {
       "table" => {
@@ -129,7 +129,7 @@ class TOML::Examples
 
   def self.example
     {
-      'title' => 'TOML Example',
+      'title' => 'TomlRB Example',
       'owner' => {
         'name' => 'Tom Preston-Werner',
         'organization' => 'GitHub',

data/test/toml_test.rb

@@ -5,8 +5,8 @@ require 'json'
 class TomlTest < Minitest::Test
   def test_file_v_0_4_0
     path = File.join(File.dirname(__FILE__), 'example-v0.4.0.toml')
-    parsed = TOML.load_file(path)
-    hash = TOML::Examples.example_v_0_4_0
+    parsed = TomlRB.load_file(path)
+    hash = TomlRB::Examples.example_v_0_4_0
 
     assert_equal hash['Array'], parsed['Array']
     assert_equal hash['Booleans'], parsed['Booleans']
@@ -21,24 +21,24 @@ class TomlTest < Minitest::Test
 
   def test_file
     path = File.join(File.dirname(__FILE__), 'example.toml')
-    parsed = TOML.load_file(path)
+    parsed = TomlRB.load_file(path)
 
-    assert_equal TOML::Examples.example, parsed
+    assert_equal TomlRB::Examples.example, parsed
   end
 
   def test_hard_example
     path = File.join(File.dirname(__FILE__), 'hard_example.toml')
-    parsed = TOML.load_file(path)
+    parsed = TomlRB.load_file(path)
 
-    assert_equal TOML::Examples.hard_example, parsed
+    assert_equal TomlRB::Examples.hard_example, parsed
   end
 
   def test_symbolize_keys
     path = File.join(File.dirname(__FILE__), 'example.toml')
-    parsed = TOML.load_file(path, symbolize_keys: true)
+    parsed = TomlRB.load_file(path, symbolize_keys: true)
 
     hash = {
-      title: 'TOML Example',
+      title: 'TomlRB Example',
 
       owner: {
         name: 'Tom Preston-Werner',
@@ -82,7 +82,7 @@ class TomlTest < Minitest::Test
   end
 
   def test_line_break
-    parsed = TOML.parse("hello = 'world'\r\nline_break = true")
+    parsed = TomlRB.parse("hello = 'world'\r\nline_break = true")
     assert_equal({ 'hello' => 'world', 'line_break' => true }, parsed)
   end
 
@@ -92,8 +92,8 @@ class TomlTest < Minitest::Test
       toml_file = File.join(File.dirname(json_file),
                             File.basename(json_file, '.json')) + '.toml'
       begin
-        toml = TOML.load_file(toml_file)
-      rescue TOML::Error => e
+        toml = TomlRB.load_file(toml_file)
+      rescue TomlRB::Error => e
         assert false, "Error: #{e} in #{toml_file}"
       end
       json = JSON.parse(File.read(json_file))
@@ -110,8 +110,8 @@ class TomlTest < Minitest::Test
   def test_invalid_cases
     file = '*'
     Dir["test/examples/invalid/#{file}.toml"].each do |toml_file|
-      assert_raises(TOML::Error, "For file #{toml_file}") do
-        TOML.load_file(toml_file)
+      assert_raises(TomlRB::Error, "For file #{toml_file}") do
+        TomlRB.load_file(toml_file)
       end
     end
   end

data/toml-rb.gemspec

@@ -1,9 +1,9 @@
 Gem::Specification.new do |s|
   s.name        = 'toml-rb'
-  s.version     = '0.3.15'
+  s.version     = '1.0.0'
   s.date        = Time.now.strftime('%Y-%m-%d')
-  s.summary     = 'TOML parser in ruby, for ruby.'
-  s.description = 'A TOML parser using Citrus parsing library. '
+  s.summary     = 'Toml parser in ruby, for ruby.'
+  s.description = 'A Toml parser using Citrus parsing library. '
   s.authors     = ['Emiliano Mancuso', 'Lucas Tolchinsky']
   s.email       = ['emiliano.mancuso@gmail.com', 'lucas.tolchinsky@gmail.com']
   s.homepage    = 'http://github.com/emancu/toml-rb'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: toml-rb
 version: !ruby/object:Gem::Version
-  version: 0.3.15
+  version: 1.0.0
 platform: ruby
 authors:
 - Emiliano Mancuso
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-22 00:00:00.000000000 Z
+date: 2017-06-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: citrus
@@ -31,7 +31,7 @@ dependencies:
     - - ">"
       - !ruby/object:Gem::Version
         version: '3.0'
-description: 'A TOML parser using Citrus parsing library. '
+description: 'A Toml parser using Citrus parsing library. '
 email:
 - emiliano.mancuso@gmail.com
 - lucas.tolchinsky@gmail.com
@@ -42,20 +42,20 @@ files:
 - README.md
 - Rakefile
 - init.rb
-- lib/toml.rb
-- lib/toml/array.rb
-- lib/toml/dumper.rb
-- lib/toml/errors.rb
-- lib/toml/grammars/array.citrus
-- lib/toml/grammars/document.citrus
-- lib/toml/grammars/helper.citrus
-- lib/toml/grammars/primitive.citrus
-- lib/toml/inline_table.rb
-- lib/toml/keygroup.rb
-- lib/toml/keyvalue.rb
-- lib/toml/parser.rb
-- lib/toml/string.rb
-- lib/toml/table_array.rb
+- lib/toml-rb.rb
+- lib/toml-rb/array.rb
+- lib/toml-rb/dumper.rb
+- lib/toml-rb/errors.rb
+- lib/toml-rb/grammars/array.citrus
+- 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/keygroup.rb
+- lib/toml-rb/keyvalue.rb
+- lib/toml-rb/parser.rb
+- lib/toml-rb/string.rb
+- lib/toml-rb/table_array.rb
 - test/dumper_test.rb
 - test/errors_test.rb
 - test/example-v0.4.0.toml
@@ -89,5 +89,5 @@ rubyforge_project:
 rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
-summary: TOML parser in ruby, for ruby.
+summary: Toml parser in ruby, for ruby.
 test_files: []