toml-rb 0.1.6 → 0.2.0

data/test/dumper_test.rb

@@ -1,14 +1,13 @@
 require_relative 'helper'
 
 class DumperTest < Test::Unit::TestCase
-
   def test_dump_empty
     dumped = TOML.dump({})
     assert_equal('', dumped)
   end
 
   def test_dump_types
-    dumped = TOML.dump(string: %q(TOML "dump"))
+    dumped = TOML.dump(string: 'TOML "dump"')
     assert_equal("string = \"TOML \\\"dump\\\"\"\n", dumped)
 
     dumped = TOML.dump(float: -13.24)
@@ -26,7 +25,7 @@ class DumperTest < Test::Unit::TestCase
     dumped = TOML.dump(array: [1, 2, 3])
     assert_equal("array = [1, 2, 3]\n", dumped)
 
-    dumped = TOML.dump(array: [[1, 2], ['weird', 'one']])
+    dumped = TOML.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))
@@ -34,7 +33,7 @@ class DumperTest < Test::Unit::TestCase
   end
 
   def test_dump_nested_attributes
-    hash = {nested: {hash: { deep: true}}}
+    hash = { nested: { hash: { deep: true } } }
     dumped = TOML.dump(hash)
     assert_equal("[nested.hash]\ndeep = true\n", dumped)
 
@@ -42,15 +41,25 @@ class DumperTest < Test::Unit::TestCase
     dumped = TOML.dump(hash)
     assert_equal("[nested]\nother = 12\n[nested.hash]\ndeep = true\n", dumped)
 
-    hash[:nested].merge!(nest: {again: 'it never ends'})
+    hash[:nested].merge!(nest: { again: 'it never ends' })
     dumped = TOML.dump(hash)
-    toml = "[nested]\n" +
-            "other = 12\n" +
-            "[nested.hash]\n" +
-            "deep = true\n" +
-            "[nested.nest]\n" +
-            "again = \"it never ends\"\n"
+    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 = TOML.dump(hash)
+    assert_equal("[non.\"bare.\\\"keys\\\"\"]\nworks = true\n", dumped)
+
+    hash = { hola: [{ chau: 4 }, { chau: 3 }] }
+    dumped = TOML.dump(hash)
+    assert_equal("[[hola]]\nchau = 4\n[[hola]]\nchau = 3\n", dumped)
   end
 end

data/test/errors_test.rb

@@ -1,10 +1,9 @@
 require_relative 'helper'
 
 class ErrorsTest < Test::Unit::TestCase
-
   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(TOML::ParseError) { TOML.parse(str) }
   end
 
   def test_text_after_string
@@ -12,11 +11,11 @@ class ErrorsTest < Test::Unit::TestCase
     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(TOML::ParseError) { TOML.parse(str) }
   end
 
   def test_multiline_array_bad_string
-    str =<<-EOS
+    str = <<-EOS
     array = [
      "This might most likely happen in multiline arrays",
      Like here,
@@ -25,11 +24,11 @@ class ErrorsTest < Test::Unit::TestCase
      ] End of array comment, forgot the #
     EOS
 
-    assert_raises(TOML::ParseError){ TOML.parse(str) }
+    assert_raises(TOML::ParseError) { TOML.parse(str) }
   end
 
   def test_multiline_array_string_not_ended
-    str =<<-EOS
+    str = <<-EOS
     array = [
      "This might most likely happen in multiline arrays",
      "or here,
@@ -37,11 +36,11 @@ class ErrorsTest < Test::Unit::TestCase
      ] End of array comment, forgot the #
     EOS
 
-    assert_raises(TOML::ParseError){ TOML.parse(str) }
+    assert_raises(TOML::ParseError) { TOML.parse(str) }
   end
 
   def test_text_after_multiline_array
-    str =<<-EOS
+    str = <<-EOS
     array = [
      "This might most likely happen in multiline arrays",
      "or here",
@@ -49,12 +48,11 @@ class ErrorsTest < Test::Unit::TestCase
      ] End of array comment, forgot the #
     EOS
 
-    assert_raises(TOML::ParseError){ TOML.parse(str) }
+    assert_raises(TOML::ParseError) { TOML.parse(str) }
   end
 
   def test_text_after_number
-    str = "number = 3.14 pi <--again forgot the #"
-    assert_raises(TOML::ParseError){ TOML.parse(str) }
+    str = 'number = 3.14 pi <--again forgot the #'
+    assert_raises(TOML::ParseError) { TOML.parse(str) }
   end
-
 end

data/test/example-v0.3.1.toml

@@ -0,0 +1,180 @@
+# Comment
+# I am a comment. Hear me roar. Roar.
+
+# Table
+# Tables (also known as hash tables or dictionaries) are collections of key/value pairs.
+# They appear in square brackets on a line by themselves.
+
+[Table]
+
+key = "value" # Yeah, you can do this.
+
+# Nested tables are denoted by table names with dots in them. Name your tables whatever crap you please, just don't use #, ., [ or ].
+
+[dog.tater]
+type = "pug"
+
+# You don't need to specify all the super-tables if you don't want to. TOML knows how to do it for you.
+
+# [x] you
+# [x.y] don't
+# [x.y.z] need these
+[x.y.z.w] # for this to work
+
+# String
+# There are four ways to express strings: basic, multi-line basic, literal, and multi-line literal.
+# All strings must contain only valid UTF-8 characters.
+
+[String]
+basic = "I'm a string. \"You can quote me\". Name\tJos\u00E9\nLocation\tSF."
+
+[String.Multiline]
+
+# The following strings are byte-for-byte equivalent:
+key1 = "One\nTwo"
+key2 = """One\nTwo"""
+key3 = """
+One
+Two"""
+
+[String.Multilined.Singleline]
+
+# The following strings are byte-for-byte equivalent:
+key1 = "The quick brown fox jumps over the lazy dog."
+
+key2 = """
+The quick brown \
+
+
+  fox jumps over \
+    the lazy dog."""
+
+key3 = """\
+       The quick brown \
+       fox jumps over \
+       the lazy dog.\
+       """
+
+[String.Literal]
+
+# What you see is what you get.
+winpath  = 'C:\Users\nodejs\templates'
+winpath2 = '\\ServerX\admin$\system32\'
+quoted   = 'Tom "Dubs" Preston-Werner'
+regex    = '<\i\c*\s*>'
+
+[String.Literal.Multiline]
+
+regex2 = '''I [dw]on't need \d{2} apples'''
+lines  = '''
+The first newline is
+trimmed in raw strings.
+   All other whitespace
+   is preserved.
+'''
+
+# Integer
+# Integers are whole numbers. Positive numbers may be prefixed with a plus sign.
+# Negative numbers are prefixed with a minus sign.
+
+[Integer]
+key1 = +99
+key2 = 42
+key3 = 0
+key4 = -17
+
+# Float
+# A float consists of an integer part (which may be prefixed with a plus or minus sign)
+# followed by a fractional part and/or an exponent part.
+
+[Float.fractional]
+
+# fractional
+key1 = +1.0
+key2 = 3.1415
+key3 = -0.01
+
+[Float.exponent]
+
+# exponent
+key1 = 5e+22
+key2 = 1e6
+key3 = -2E-2
+
+[Float.both]
+
+# both
+key = 6.626e-34
+
+# Boolean
+# Booleans are just the tokens you're used to. Always lowercase.
+
+[Booleans]
+True = true
+False = false
+
+# Datetime
+# Datetimes are RFC 3339 dates.
+
+[Datetime]
+key1 = 1979-05-27T07:32:00Z
+key2 = 1979-05-27T00:32:00-07:00
+key3 = 1979-05-27T00:32:00.999999-07:00
+
+# Array
+# Arrays are square brackets with other primitives inside. Whitespace is ignored. Elements are separated by commas. Data types may not be mixed.
+
+[Array]
+key1 = [ 1, 2, 3 ]
+key2 = [ "red", "yellow", "green" ]
+key3 = [ [ 1, 2 ], [3, 4, 5] ]
+key4 = [ [ 1, 2 ], ["a", "b", "c"] ] # this is ok
+
+#Arrays can also be multiline. So in addition to ignoring whitespace, arrays also ignore newlines between the brackets.
+# Terminating commas are ok before the closing bracket.
+
+key5 = [
+  1, 2, 3
+]
+key6 = [
+  1,
+  2, # this is ok
+]
+
+# Array of Tables
+# These can be expressed by using a table name in double brackets.
+# Each table with the same double bracketed name will be an element in the array.
+# The tables are inserted in the order encountered.
+
+[[products]]
+name = "Hammer"
+sku = 738594937
+
+[[products]]
+
+[[products]]
+name = "Nail"
+sku = 284758393
+color = "gray"
+
+
+# You can create nested arrays of tables as well.
+
+[[fruit]]
+  name = "apple"
+
+  [fruit.physical]
+    color = "red"
+    shape = "round"
+
+  [[fruit.variety]]
+    name = "red delicious"
+
+  [[fruit.variety]]
+    name = "granny smith"
+
+[[fruit]]
+  name = "banana"
+
+  [[fruit.variety]]
+    name = "plantain"

data/test/grammar_test.rb

@@ -1,12 +1,20 @@
+# encoding: utf-8
 require_relative 'helper'
 
 class GrammarTest < Test::Unit::TestCase
-
   def test_comment
     match = Document.parse(' # A comment', root: :comment)
     assert_equal(nil, match.value)
   end
 
+  def test_key
+    match = Document.parse('bad_key-', root: :key)
+    assert_equal('bad_key-', match.value)
+
+    match = Document.parse('"123.ʎǝʞ.#?"', root: :key)
+    assert_equal('123.ʎǝʞ.#?', match.value)
+  end
+
   def test_keygroup
     indentation_alternatives_for('[akey]') do |str|
       match = Document.parse(str, root: :keygroup)
@@ -15,7 +23,15 @@ class GrammarTest < Test::Unit::TestCase
     end
 
     match = Document.parse('[owner.emancu]', root: :keygroup)
-    assert_equal(['owner', 'emancu'],
+    assert_equal(%w(owner emancu),
+                 match.value.instance_variable_get('@nested_keys'))
+
+    match = Document.parse('["owner.emancu"]', root: :keygroup)
+    assert_equal(%w(owner.emancu),
+                 match.value.instance_variable_get('@nested_keys'))
+
+    match = Document.parse('[ owner . emancu ]', root: :keygroup)
+    assert_equal(%w(owner emancu),
                  match.value.instance_variable_get('@nested_keys'))
   end
 
@@ -35,6 +51,19 @@ class GrammarTest < Test::Unit::TestCase
     assert_equal('TOML-Example, should work.', match.value)
   end
 
+  def test_multiline_string
+    match = Document.parse('"""\tOne\nTwo"""', root: :multiline_string)
+    assert_equal "\tOne\nTwo", match.value
+
+    to_parse = '"""\
+    One \
+    Two\
+    """'
+
+    match = Document.parse(to_parse, root: :multiline_string)
+    assert_equal "One Two", match.value
+  end
+
   def test_special_characters
     match = Document.parse('"\0 \" \t \n \r"', root: :string)
     assert_equal("\0 \" \t \n \r", match.value)
@@ -59,6 +88,12 @@ class GrammarTest < Test::Unit::TestCase
   def test_float
     match = Document.parse('1.69', root: :number)
     assert_equal(1.69, match.value)
+
+    match = Document.parse('1e6', root: :number)
+    assert_equal(1e6, match.value)
+
+    match = Document.parse('1.02e-46', root: :number)
+    assert_equal(1.02e-46, match.value)
   end
 
   def test_signed_numbers
@@ -96,19 +131,35 @@ class GrammarTest < Test::Unit::TestCase
     assert_equal([2.4, 4.72], match.value)
 
     match = Document.parse('[ "hey", "TOML"]', root: :array)
-    assert_equal(['hey', 'TOML'], match.value)
+    assert_equal(%w(hey TOML), match.value)
 
     match = Document.parse('[ ["hey", "TOML"], [2,4] ]', root: :array)
-    assert_equal([['hey', 'TOML'], [2, 4]], match.value)
+    assert_equal([%w(hey TOML), [2, 4]], match.value)
+  end
 
+  def test_multiline_array
     multiline_array = "[ \"hey\",\n   \"ho\",\n\t \"lets\", \"go\",\n ]"
     match = Document.parse(multiline_array, root: :array)
-    assert_equal(['hey', 'ho', 'lets', 'go'], match.value)
+    assert_equal(%w(hey ho lets go), match.value)
+
+    multiline_array = "[\n#1,\n2,\n# 3\n]"
+    match = Document.parse(multiline_array, root: :array)
+    assert_equal([2], match.value)
+
+    multiline_array = "[\n# comment\n#, more comments\n4]"
+    match = Document.parse(multiline_array, root: :array)
+    assert_equal([4], match.value)
   end
 
   def test_datetime
     match = Document.parse('1986-08-28T15:15:00Z', root: :datetime)
     assert_equal(Time.utc(1986, 8, 28, 15, 15), match.value)
+
+    match = Document.parse('1986-08-28T15:15:00-03:00', root: :datetime)
+    assert_equal(Time.utc(1986, 8, 28, 18, 15), match.value)
+
+    match = 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)
   end
 
   private
@@ -120,4 +171,3 @@ class GrammarTest < Test::Unit::TestCase
     end
   end
 end
-

data/test/hard_example.toml

@@ -13,13 +13,15 @@ test_string = "You'll hate me after this - #"          # " Annoying, isn't it?
     harder_test_string = " And when \"'s are in the string, along with # \""   # "and comments are there too"
     # Things will get harder
     
-        [the.hard.bit#]
-        what? = "You don't think some user won't do that?"
+        [the.hard."bit#"]
+        "what?" = "You don't think some user won't do that?"
         multi_line_array = [
             "]",
             # ] Oh yes I did
             ]
 
+[[nested.table.array]]
+
 # Each of the following keygroups/key value pairs should produce an error. Uncomment to them to test
 
 #[error]   if you didn't catch this, your parser is broken
@@ -31,3 +33,4 @@ test_string = "You'll hate me after this - #"          # " Annoying, isn't it?
 #         and here"
 #         ]     End of array comment, forgot the #
 #number = 3.14  pi <--again forgot the #         
+