toml-rb 0.3.5 → 0.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9a98aa52600a975ad1758363c0c21585444b67cd
-  data.tar.gz: c9d03ddf95c5a6f8b6775dbc9acdece8d1e96630
+  metadata.gz: 763a2531f36107f17c09cf4b60399de4487fce09
+  data.tar.gz: 891ced2d3c3dcd42baab838a0586c12b47976c2b
 SHA512:
-  metadata.gz: eaaa1515c6fe4681cf2c75000b5bfa303b3b4e1fe468647d00f320baf75646f4169d17a5a19711dd3cc828624da972c1796b85b045b957c8894ecda7b035f09e
-  data.tar.gz: d761b9378f9d0e0d0310958f42bf28a9e8a81f3c29b1b0ce1e0e12dfa3ac3cb4d0810c68344d3d7e720f20a662851e7aa8143c50750da0c175088a811b24cf82
+  metadata.gz: d8683b77c2b7dcdfc38c11af8d79ec376e6de7702cb977f3a53c0be0d2aa87151a1541eb54d3d91eef9730bcf8d011aee01820bf7185b6b4a3ba2705c94f53da
+  data.tar.gz: fe95e0553af526da664b7e8de0581a8c9b9f4eb0e1c1c636743cab830b59a555222c16e3518558bd9efe6e76eed9c29695bdb5b44c31660921d7564eeaf6d39a

data/lib/toml/grammars/array.citrus

@@ -1,5 +1,5 @@
-grammar TomlArray
-  include Primitive
+grammar TOML::Arrays
+  include TOML::Primitive
 
   rule array
     ("[" array_comments (elements)? space ","? array_comments "]" indent?) { eval(to_str) }

data/lib/toml/grammars/document.citrus

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

data/lib/toml/grammars/helper.citrus

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

data/lib/toml/grammars/primitive.citrus

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

data/lib/toml/inline_table.rb

@@ -8,7 +8,7 @@ module TOML
     end
 
     def value(symbolize_keys = false)
-      if @symbolize_keys = symbolize_keys
+      if (@symbolize_keys = symbolize_keys)
         tuple = ->(kv) { [kv.key.to_sym, visit_value(kv.value)] }
       else
         tuple = ->(kv) { [kv.key, visit_value(kv.value)] }
@@ -53,18 +53,20 @@ module TOML
       @inline_tables.map { |it| it.value(symbolize_keys) }
     end
   end
-end
 
-module InlineTable
-  def value
-    TOML::InlineTable.new captures[:keyvalue].map(&:value)
+  module InlineTableParser
+    def value
+      TOML::InlineTable.new captures[:keyvalue].map(&:value)
+    end
   end
-end
 
-module InlineTableArray
-  def value
-    tables = captures[:inline_table_array_elements].map { |x| x.captures[:inline_table] }
+  module InlineTableArrayParser
+    def value
+      tables = captures[:inline_table_array_elements].map do |x|
+        x.captures[:inline_table]
+      end
 
-    TOML::InlineTableArray.new(tables.flatten.map(&:value)).value
+      TOML::InlineTableArray.new(tables.flatten.map(&:value)).value
+    end
   end
 end

data/lib/toml/keygroup.rb

@@ -26,11 +26,10 @@ module TOML
       parser.visit_keygroup self
     end
   end
-end
-
-# Used in document.citrus
-module Keygroup
-  def value
-    TOML::Keygroup.new(captures[:key].map(&:value))
+  # Used in document.citrus
+  module KeygroupParser
+    def value
+      TOML::Keygroup.new(captures[:key].map(&:value))
+    end
   end
 end

data/lib/toml/keyvalue.rb

@@ -12,7 +12,9 @@ module TOML
     attr_reader :value, :symbolize_keys
 
     def initialize(key, value)
-      @key, @value, @symbolize_keys = key, value, false
+      @key = key
+      @value = value
+      @symbolize_keys = false
     end
 
     def assign(hash, symbolize_keys = false)
@@ -47,11 +49,10 @@ module TOML
       a_value.accept_visitor self
     end
   end
-end
-
-# Used in document.citrus
-module Keyvalue
-  def value
-    TOML::Keyvalue.new(capture(:key).value, capture(:v).value)
+  # Used in document.citrus
+  module KeyvalueParser
+    def value
+      TOML::Keyvalue.new(capture(:key).value, capture(:v).value)
+    end
   end
 end

data/lib/toml/parser.rb

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

data/lib/toml/string.rb

@@ -1,43 +1,44 @@
-# Used in primitive.citrus
-module TomlBasicString
-  def value
-    aux = TomlBasicString.transform_escaped_chars first.value
-
-    aux[1...-1]
-  end
-
-  def self.transform_escaped_chars(str)
-    str
-      .gsub(/\\0/, "\0")
-      .gsub(/\\t/, "\t")
-      .gsub(/\\n/, "\n")
-      .gsub(/\\\"/, '"')
-      .gsub(/\\r/, "\r")
-      .gsub(/\\\\/, '\\')
+module TOML
+  # Used in primitive.citrus
+  module BasicString
+    def value
+      aux = TOML::BasicString.transform_escaped_chars first.value
+
+      aux[1...-1]
+    end
+
+    def self.transform_escaped_chars(str)
+      str.gsub(/\\0/, "\0")
+        .gsub(/\\t/, "\t")
+        .gsub(/\\n/, "\n")
+        .gsub(/\\\"/, '"')
+        .gsub(/\\r/, "\r")
+        .gsub(/\\\\/, '\\')
+    end
   end
-end
 
-module TomlLiteralString
-  def value
-    first.value[1...-1]
+  module LiteralString
+    def value
+      first.value[1...-1]
+    end
   end
-end
 
-module TomlMultilineString
-  def value
-    aux = captures[:text].first.value
+  module MultilineString
+    def value
+      aux = captures[:text].first.value
 
-    # Remove spaces on multilined Singleline strings
-    aux.gsub!(/\\\r?\n[\n\t\r ]*/, '')
+      # Remove spaces on multilined Singleline strings
+      aux.gsub!(/\\\r?\n[\n\t\r ]*/, '')
 
-    TomlBasicString.transform_escaped_chars aux
+      TOML::BasicString.transform_escaped_chars aux
+    end
   end
-end
 
-module TomlMultilineLiteral
-  def value
-    aux = captures[:text].first.value
+  module MultilineLiteral
+    def value
+      aux = captures[:text].first.value
 
-    aux.gsub(/\\\r?\n[\n\t\r ]*/, '')
+      aux.gsub(/\\\r?\n[\n\t\r ]*/, '')
+    end
   end
 end

data/lib/toml/table_array.rb

@@ -31,11 +31,11 @@ module TOML
       parser.visit_table_array self
     end
   end
-end
 
-# Used in document.citrus
-module TableArray
-  def value
-    TOML::TableArray.new(captures[:key].map(&:value))
+  # Used in document.citrus
+  module TableArrayParser
+    def value
+      TOML::TableArray.new(captures[:key].map(&:value))
+    end
   end
 end

data/test/grammar_test.rb

@@ -3,41 +3,41 @@ require_relative 'helper'
 
 class GrammarTest < Test::Unit::TestCase
   def test_comment
-    match = Document.parse(' # A comment', root: :comment)
+    match = TOML::Document.parse(' # A comment', root: :comment)
     assert_equal(nil, match.value)
   end
 
   def test_key
-    match = Document.parse('bad_key-', root: :key)
+    match = TOML::Document.parse('bad_key-', root: :key)
     assert_equal('bad_key-', match.value)
 
-    match = Document.parse('"123.ʎǝʞ.#?"', root: :key)
+    match = TOML::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)
+      match = TOML::Document.parse(str, root: :keygroup)
       assert_equal(TOML::Keygroup, match.value.class)
       assert_equal(['akey'], match.value.instance_variable_get('@nested_keys'))
     end
 
-    match = Document.parse('[owner.emancu]', root: :keygroup)
+    match = TOML::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)
+    match = TOML::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)
+    match = TOML::Document.parse('[ owner . emancu ]', root: :keygroup)
     assert_equal(%w(owner emancu),
                  match.value.instance_variable_get('@nested_keys'))
   end
 
   def test_keyvalue
     indentation_alternatives_for('key = "value"') do |str|
-      match = Document.parse(str, root: :keyvalue)
+      match = TOML::Document.parse(str, root: :keyvalue)
       assert_equal(TOML::Keyvalue, match.value.class)
 
       keyvalue = match.value
@@ -47,12 +47,12 @@ class GrammarTest < Test::Unit::TestCase
   end
 
   def test_string
-    match = Document.parse('"TOML-Example, should work."', root: :string)
+    match = TOML::Document.parse('"TOML-Example, should work."', root: :string)
     assert_equal('TOML-Example, should work.', match.value)
   end
 
   def test_multiline_string
-    match = Document.parse('"""\tOne\nTwo"""', root: :multiline_string)
+    match = TOML::Document.parse('"""\tOne\nTwo"""', root: :multiline_string)
     assert_equal "\tOne\nTwo", match.value
 
     to_parse = '"""\
@@ -60,143 +60,144 @@ class GrammarTest < Test::Unit::TestCase
     Two\
     """'
 
-    match = Document.parse(to_parse, root: :multiline_string)
+    match = TOML::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)
+    match = TOML::Document.parse('"\0 \" \t \n \r"', root: :string)
     assert_equal("\0 \" \t \n \r", match.value)
 
-    match = Document.parse('"C:\\Documents\\virus.exe"', root: :string)
+    match = TOML::Document.parse('"C:\\Documents\\virus.exe"', root: :string)
     assert_equal('C:\\Documents\\virus.exe', match.value)
   end
 
   def test_bool
-    match = Document.parse('true', root: :bool)
+    match = TOML::Document.parse('true', root: :bool)
     assert_equal(true, match.value)
 
-    match = Document.parse('false', root: :bool)
+    match = TOML::Document.parse('false', root: :bool)
     assert_equal(false, match.value)
   end
 
   def test_integer
-    match = Document.parse('26', root: :number)
+    match = TOML::Document.parse('26', root: :number)
     assert_equal(26, match.value)
 
-    match = Document.parse('1_200_000_999', root: :number)
+    match = TOML::Document.parse('1_200_000_999', root: :number)
     assert_equal(1_200_000_999, match.value)
   end
 
   def test_float
-    match = Document.parse('1.69', root: :number)
+    match = TOML::Document.parse('1.69', root: :number)
     assert_equal(1.69, match.value)
 
-    match = Document.parse('1_000.69', root: :number)
+    match = TOML::Document.parse('1_000.69', root: :number)
     assert_equal(1000.69, match.value)
 
-    match = Document.parse('1e6', root: :number)
+    match = TOML::Document.parse('1e6', root: :number)
     assert_equal(1e6, match.value)
 
-    match = Document.parse('1.02e-46', root: :number)
+    match = TOML::Document.parse('1.02e-46', root: :number)
     assert_equal(1.02e-46, match.value)
 
-    match = Document.parse('+1e4_000_000', root: :number)
+    match = TOML::Document.parse('+1e4_000_000', root: :number)
     assert_equal(1e4_000_000, match.value)
   end
 
   def test_signed_numbers
-    match = Document.parse('+26', root: :number)
+    match = TOML::Document.parse('+26', root: :number)
     assert_equal(26, match.value)
 
-    match = Document.parse('-26', root: :number)
+    match = TOML::Document.parse('-26', root: :number)
     assert_equal(-26, match.value)
 
-    match = Document.parse('1.69', root: :number)
+    match = TOML::Document.parse('1.69', root: :number)
     assert_equal(1.69, match.value)
 
-    match = Document.parse('-1.69', root: :number)
+    match = TOML::Document.parse('-1.69', root: :number)
     assert_equal(-1.69, match.value)
   end
 
   def test_expressions_with_comments
-    match = Document.parse('[shouldwork] # with comment', root: :keygroup)
+    match = TOML::Document.parse('[shouldwork] # with comment', root: :keygroup)
     assert_equal(['shouldwork'],
                  match.value.instance_variable_get('@nested_keys'))
 
-    match = Document.parse('works = true # with comment', root: :keyvalue).value
+    match = TOML::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 = Document.parse('[]', root: :array)
+    match = TOML::Document.parse('[]', root: :array)
     assert_equal([], match.value)
 
-    match = Document.parse('[ 2, 4]', root: :array)
+    match = TOML::Document.parse('[ 2, 4]', root: :array)
     assert_equal([2, 4], match.value)
 
-    match = Document.parse('[ 2.4, 4.72]', root: :array)
+    match = TOML::Document.parse('[ 2.4, 4.72]', root: :array)
     assert_equal([2.4, 4.72], match.value)
 
-    match = Document.parse('[ "hey", "TOML"]', root: :array)
+    match = TOML::Document.parse('[ "hey", "TOML"]', root: :array)
     assert_equal(%w(hey TOML), match.value)
 
-    match = Document.parse('[ ["hey", "TOML"], [2,4] ]', root: :array)
+    match = TOML::Document.parse('[ ["hey", "TOML"], [2,4] ]', root: :array)
     assert_equal([%w(hey TOML), [2, 4]], match.value)
 
-    match = Document.parse('[ { one = 1 }, { two = 2, three = 3} ]',
+    match = TOML::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 = Document.parse("a = []", root: :keyvalue).value
+    match = TOML::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 = Document.parse(multiline_array, root: :array)
+    match = TOML::Document.parse(multiline_array, root: :array)
     assert_equal(%w(hey ho lets go), match.value)
 
     multiline_array = "[\n#1,\n2,\n# 3\n]"
-    match = Document.parse(multiline_array, root: :array)
+    match = TOML::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)
+    match = TOML::Document.parse(multiline_array, root: :array)
     assert_equal([4], match.value)
 
     multiline_array = "[\n  1,\n  # 2,\n  3 ,\n]"
-    match = Document.parse(multiline_array, root: :array)
+    match = TOML::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 = Document.parse(multiline_array, root: :array)
+    match = TOML::Document.parse(multiline_array, root: :array)
     assert_equal([1, 3], match.value)
   end
 
   def test_datetime
-    match = Document.parse('1986-08-28T15:15:00Z', root: :datetime)
+    match = TOML::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)
+    match = TOML::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)
+    match = TOML::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
 
   def test_inline_table
-    match = Document.parse('{ }', root: :inline_table)
+    match = TOML::Document.parse('{ }', root: :inline_table)
     assert_equal({}, match.value.value)
 
-    match = Document.parse('{ simple = true, params = 2 }', root: :inline_table)
+    match = TOML::Document.parse('{ simple = true, params = 2 }', root: :inline_table)
     assert_equal({ 'simple' => true, 'params' => 2 }, match.value.value)
 
-    match = Document.parse('{ nest = { really = { hard = true } } }', root: :inline_table)
+    match = TOML::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

data/test/toml_examples.rb

@@ -1,4 +1,4 @@
-class TomlExamples
+class TOML::Examples
   def self.example_v_0_4_0
     {
       "table" => {

data/test/toml_test.rb

@@ -5,7 +5,7 @@ class TomlTest < Test::Unit::TestCase
   def test_file_v_0_4_0
     path = File.join(File.dirname(__FILE__), 'example-v0.4.0.toml')
     parsed = TOML.load_file(path)
-    hash = TomlExamples.example_v_0_4_0
+    hash = TOML::Examples.example_v_0_4_0
 
     assert_equal hash['Array'], parsed['Array']
     assert_equal hash['Booleans'], parsed['Booleans']
@@ -22,14 +22,14 @@ class TomlTest < Test::Unit::TestCase
     path = File.join(File.dirname(__FILE__), 'example.toml')
     parsed = TOML.load_file(path)
 
-    assert_equal TomlExamples.example, parsed
+    assert_equal TOML::Examples.example, parsed
   end
 
   def test_hard_example
     path = File.join(File.dirname(__FILE__), 'hard_example.toml')
     parsed = TOML.load_file(path)
 
-    assert_equal TomlExamples.hard_example, parsed
+    assert_equal TOML::Examples.hard_example, parsed
   end
 
   def test_symbolize_keys

data/toml-rb.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name        = 'toml-rb'
-  s.version     = '0.3.5'
+  s.version     = '0.3.6'
   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. '

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: toml-rb
 version: !ruby/object:Gem::Version
-  version: 0.3.5
+  version: 0.3.6
 platform: ruby
 authors:
 - Emiliano Mancuso
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-14 00:00:00.000000000 Z
+date: 2015-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: citrus