toml-rb 1.1.2 → 2.0.0

data/test/example-v0.4.0.toml

@@ -1,244 +0,0 @@
-################################################################################
-## 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

@@ -1,49 +0,0 @@
-# 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

@@ -1,239 +0,0 @@
-# encoding: utf-8
-require_relative 'helper'
-
-class GrammarTest < Minitest::Test
-  def test_comment
-    match = TomlRB::Document.parse(' # A comment', root: :comment)
-    assert_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