toml-rb-hs 1.1.1

data/test/errors_test.rb

@@ -0,0 +1,94 @@
+unless defined? require_relative
+  def require_relative(path)
+    require path
+  end
+end
+
+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

data/test/example-v0.4.0.toml

@@ -0,0 +1,244 @@
+################################################################################
+## Comment
+
+# Speak your mind with the hash symbol. They go from the symbol to the end of
+# the line.
+
+
+################################################################################
+## 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 ].
+
+[table.subtable]
+
+key = "another value"
+
+# 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
+# [x.y] don't
+# [x.y.z] need these
+[x.y.z.w] # for this to work
+
+
+################################################################################
+## Inline Table
+
+# Inline tables provide a more compact syntax for expressing tables. They are
+# especially useful for grouped data that can otherwise quickly become verbose.
+# Inline tables are enclosed in curly braces `{` and `}`. No newlines are
+# allowed between the curly braces unless they are valid within a value.
+
+[table.inline]
+
+name = { first = "Tom", last = "Preston-Werner" }
+point = { x = 1, y = 2 }
+
+
+################################################################################
+## 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]
+
+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.multiline.continued]
+
+# 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
+
+[integer.underscores]
+
+# For large numbers, you may use underscores to enhance readability. Each
+# underscore must be surrounded by at least one digit.
+key1 = 1_000
+key2 = 5_349_221
+key3 = 1_2_3_4_5     # valid but inadvisable
+
+
+################################################################################
+## 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]
+
+key1 = +1.0
+key2 = 3.1415
+key3 = -0.01
+
+[float.exponent]
+
+key1 = 5e+22
+key2 = 1e6
+key3 = -2E-2
+
+[float.both]
+
+key = 6.626e-34
+
+[float.underscores]
+
+key1 = 9_224_617.445_991_228_313
+key2 = 1e1_000
+
+
+################################################################################
+## Boolean
+
+# Booleans are just the tokens you're used to. Always lowercase.
+
+[boolean]
+
+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/example.toml

@@ -0,0 +1,49 @@
+# This is a TomlRB document. Boom.
+
+title = "TomlRB Example"
+
+[owner]
+name = "Tom Preston-Werner"
+organization = "GitHub"
+bio = "GitHub Cofounder & CEO\nLikes tater tots and beer."
+dob = 1979-05-27T07:32:00Z # First class dates? Why not?
+
+[database]
+server = "192.168.1.1"
+ports = [ 8001, 8001, 8002 ]
+connection_max = 5000
+enabled = true
+
+[servers]
+
+  # You can indent as you please. Tabs or spaces. TomlRB don't care.
+  [servers.alpha]
+  ip = "10.0.0.1"
+  dc = "eqdc10"
+
+  [servers.beta]
+  ip = "10.0.0.2"
+  dc = "eqdc10"
+
+[clients]
+data = [ ["gamma", "delta"], [1, 2] ]
+
+# Line breaks are OK when inside arrays
+hosts = [
+  "alpha",
+  "omega"
+]
+
+[amqp]
+exchange = {durable = true, auto_delete = false}
+
+[[products]]
+name = "Hammer"
+sku = 738594937
+
+[[products]]
+
+[[products]]
+name = "Nail"
+sku = 284758393
+color = "gray"

data/test/grammar_test.rb

@@ -0,0 +1,246 @@
+# encoding: utf-8
+
+unless defined? require_relative
+  def require_relative(path)
+    require path
+  end
+end
+
+require_relative 'helper'
+
+class GrammarTest < Minitest::Test
+  def test_comment
+    match = TomlRB::Document.parse(' # A comment', root: :comment)
+    assert_equal(nil, match.value)
+  end
+
+  def test_key
+    match = TomlRB::Document.parse('bad_key-', root: :key)
+    assert_equal('bad_key-', match.value)
+
+    match = TomlRB::Document.parse('"123.ʎǝʞ.#?"', root: :key)
+    assert_equal('123.ʎǝʞ.#?', match.value)
+  end
+
+  def test_keygroup
+    indentation_alternatives_for('[akey]') do |str|
+      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 = TomlRB::Document.parse('[owner.emancu]', root: :keygroup)
+    assert_equal(%w(owner emancu),
+                 match.value.instance_variable_get('@nested_keys'))
+
+    match = TomlRB::Document.parse('["owner.emancu"]', root: :keygroup)
+    assert_equal(%w(owner.emancu),
+                 match.value.instance_variable_get('@nested_keys'))
+
+    match = TomlRB::Document.parse('["first key"."second key"]', root: :keygroup)
+    assert_equal(['first key', 'second key'],
+                 match.value.instance_variable_get('@nested_keys'))
+
+    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
+      TomlRB::Document.parse('[ owner emancu ]', root: :keygroup)
+    end
+  end
+
+  def test_keyvalue
+    indentation_alternatives_for('key = "value"') do |str|
+      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'))
+      assert_equal('value', keyvalue.instance_variable_get('@value'))
+    end
+  end
+
+  def test_string
+    match = TomlRB::Document.parse('"TomlRB-Example, should work."', root: :string)
+    assert_equal('TomlRB-Example, should work.', match.value)
+  end
+
+  def test_multiline_string
+    match = TomlRB::Document.parse('"""\tOne\nTwo"""', root: :multiline_string)
+    assert_equal "\tOne\nTwo", match.value
+
+    to_parse = '"""\
+    One \
+    Two\
+    """'
+
+    match = TomlRB::Document.parse(to_parse, root: :multiline_string)
+    assert_equal "One Two", match.value
+  end
+
+  def test_empty_multiline_string
+    to_parse = '""""""'
+
+    match = TomlRB::Document.parse(to_parse, root: :multiline_string)
+    assert_equal '', match.value
+  end
+
+  def test_special_characters
+    match = TomlRB::Document.parse('"\0 \" \t \n \r"', root: :string)
+    assert_equal("\0 \" \t \n \r", match.value)
+
+    match = TomlRB::Document.parse('"C:\\\\Documents\\\\nada.exe"', root: :string)
+    assert_equal('C:\\Documents\\nada.exe', match.value)
+  end
+
+  def test_bool
+    match = TomlRB::Document.parse('true', root: :bool)
+    assert_equal(true, match.value)
+
+    match = TomlRB::Document.parse('false', root: :bool)
+    assert_equal(false, match.value)
+  end
+
+  def test_integer
+    match = TomlRB::Document.parse('26', root: :number)
+    assert_equal(26, match.value)
+
+    match = TomlRB::Document.parse('1_200_000_999', root: :number)
+    assert_equal(1_200_000_999, match.value)
+  end
+
+  def test_float
+    match = TomlRB::Document.parse('1.69', root: :number)
+    assert_equal(1.69, match.value)
+
+    match = TomlRB::Document.parse('1_000.69', root: :number)
+    assert_equal(1000.69, match.value)
+
+    match = TomlRB::Document.parse('1e6', root: :number)
+    assert_equal(1e6, match.value)
+
+    match = TomlRB::Document.parse('1.02e-46', root: :number)
+    assert_equal(1.02e-46, match.value)
+
+    match = TomlRB::Document.parse('+1e4_000_000', root: :number)
+    assert_equal(1e4_000_000, match.value)
+  end
+
+  def test_signed_numbers
+    match = TomlRB::Document.parse('+26', root: :number)
+    assert_equal(26, match.value)
+
+    match = TomlRB::Document.parse('-26', root: :number)
+    assert_equal(-26, match.value)
+
+    match = TomlRB::Document.parse('1.69', root: :number)
+    assert_equal(1.69, match.value)
+
+    match = TomlRB::Document.parse('-1.69', root: :number)
+    assert_equal(-1.69, match.value)
+  end
+
+  def test_expressions_with_comments
+    match = TomlRB::Document.parse('[shouldwork] # with comment', root: :keygroup)
+    assert_equal(['shouldwork'],
+                 match.value.instance_variable_get('@nested_keys'))
+
+    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 = TomlRB::Document.parse('[]', root: :array)
+    assert_equal([], match.value)
+
+    match = TomlRB::Document.parse('[ 2, 4]', root: :array)
+    assert_equal([2, 4], match.value)
+
+    match = TomlRB::Document.parse('[ 2.4, 4.72]', root: :array)
+    assert_equal([2.4, 4.72], match.value)
+
+    match = TomlRB::Document.parse('[ "hey", "TomlRB"]', root: :array)
+    assert_equal(%w(hey TomlRB), match.value)
+
+    match = TomlRB::Document.parse('[ ["hey", "TomlRB"], [2,4] ]', root: :array)
+    assert_equal([%w(hey TomlRB), [2, 4]], match.value)
+
+    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 = 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 = 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 = TomlRB::Document.parse(multiline_array, root: :array)
+    assert_equal([2], match.value)
+
+    multiline_array = "[\n# comment\n#, more comments\n4]"
+    match = TomlRB::Document.parse(multiline_array, root: :array)
+    assert_equal([4], match.value)
+
+    multiline_array = "[\n  1,\n  # 2,\n  3 ,\n]"
+    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 = 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 = TomlRB::Document.parse('1986-08-28T15:15:00Z', root: :datetime)
+    assert_equal(Time.utc(1986, 8, 28, 15, 15), match.value)
+
+    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 = 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 = TomlRB::Document.parse('1986-08-28', root: :datetime)
+    assert_equal(Time.utc(1986, 8, 28, 0, 0, 0), match.value)
+
+    match = TomlRB::Document.parse('1986-08-28T15:15:00', root: :datetime)
+    assert_equal(Time.utc(1986, 8, 28, 15, 15), match.value)
+
+    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 = TomlRB::Document.parse('{ }', root: :inline_table)
+    assert_equal({}, match.value.value)
+
+    match = TomlRB::Document.parse('{ simple = true, params = 2 }', root: :inline_table)
+    assert_equal({ 'simple' => true, 'params' => 2 }, match.value.value)
+
+    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))
+  end
+
+  private
+
+  # Creates all the alternatives of valid indentations to test
+  def indentation_alternatives_for(str)
+    [str, "  #{str}", "\t#{str}", "\t\t#{str}"].each do |alternative|
+      yield(alternative)
+    end
+  end
+end