toml-rb 1.1.2 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 1ef52970c82352fb2fa2fedeca2d023122c6b6db
-  data.tar.gz: c9ea0ca9350b7b7ae41ee91a9f135330d51aad74
+SHA256:
+  metadata.gz: cd9c5ba72f17c7f6c080cab4a3f67c478f63cc7660da4962dff12f06ce9abc8f
+  data.tar.gz: adc7291b56ea5a442efe533808f8b7fcfe05494c55f73dc554f5ec0e8bb22769
 SHA512:
-  metadata.gz: a323eeb7e8d9cce983b7ce35897bb9583f164213a45175a91724a9b02743e567c9576ba8753545fe73edd09335d68a1dcc4a34d33dd9f03f91bc0bce9e9a929f
-  data.tar.gz: e5091b85b319f06e742da736213a8586b89dc9f96f4cd41de565eb23e63169d7db6b49922e663c44cf19f0087b9e87ea0021bb0a897bea7f4c528ff3f90707b9
+  metadata.gz: a8be2fbd9046868aee722f5edf17451966be58bce14d1c7cc693a7ff3d1735c461b96a769720a3fa599a8e9de649e451dd8b7d2a9cc179122a50b8a3222cfc55
+  data.tar.gz: aa7de16365bf67d983f1aed345e6ed90614209acd6663b525d9ba6621e39283d9e6312a12607e2c60bfb3205b198502cefe15e390eda6b229cef0f9dddfdd9bb

data/LICENSE

@@ -0,0 +1,19 @@
+The MIT License (MIT)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -1,14 +1,17 @@
+![TOML Logo](https://github.com/toml-lang/toml/blob/master/logos/toml-100.png)
+
+
 toml-rb
 =======
 
 [![Gem Version](https://badge.fury.io/rb/toml-rb.svg)](http://badge.fury.io/rb/toml-rb)
-[![Build Status](https://travis-ci.org/emancu/toml-rb.svg)](https://travis-ci.org/emancu/toml-rb)
+[![Build Status](https://github.com/emancu/toml-rb/actions/workflows/ruby.yml/badge.svg)](https://github.com/emancu/toml-rb/actions/workflows/ruby.yml)
 [![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)
+[![RubyGem](https://img.shields.io/gem/dt/toml-rb.svg)](https://rubygems.org/gems/toml-rb)
 
-A [TomlRB](https://github.com/toml-lang/toml) parser using [Citrus](http://mjackson.github.io/citrus) library.
+A [TOML](https://github.com/toml-lang/toml) parser using [Citrus](http://mjackson.github.io/citrus) library.
 
-TomlRB specs supported: `0.4.0`
+TOML specs supported: `0.5.0`
 
 Installation
 ------------

data/lib/toml-rb/array.rb

@@ -1,14 +1,8 @@
 module TomlRB
   module ArrayParser
     def value
-      elements = captures[:elements].first
-      return [] unless elements
-
-      if elements.captures.key? :string
-        elements.captures[:string].map(&:value)
-      else
-        eval(to_str)
-      end
+      elements = captures[:array_elements].first
+      elements ? elements.value : []
     end
   end
 end

data/lib/toml-rb/datetime.rb

@@ -0,0 +1,38 @@
+module TomlRB
+  module OffsetDateTimeParser
+    def value
+      skeleton = captures[:datetime_skeleton].first
+      year, mon, day, hour, min, sec, sec_frac = skeleton.value
+      offset = captures[:date_offset].first || "+00:00"
+      sec = "#{sec}.#{sec_frac}".to_f
+
+      Time.new(year, mon, day, hour, min, sec, offset.to_s)
+    end
+  end
+
+  module LocalDateTimeParser
+    def value
+      year, mon, day = captures[:date_skeleton].first.value
+      hour, min, sec, sec_frac = captures[:time_skeleton].first.value
+      usec = sec_frac.to_s.ljust(6, "0")
+
+      Time.local(year, mon, day, hour, min, sec, usec)
+    end
+  end
+
+  module LocalDateParser
+    def value
+      year, mon, day = captures[:date_skeleton].first.value
+      Time.local(year, mon, day)
+    end
+  end
+
+  module LocalTimeParser
+    def value
+      hour, min, sec, sec_frac = captures[:time_skeleton].first.value
+      usec = sec_frac.to_s.ljust(6, "0")
+
+      Time.at(3600 * hour.to_i + 60 * min.to_i + sec.to_i, usec.to_i)
+    end
+  end
+end

data/lib/toml-rb/dumper.rb

@@ -1,9 +1,11 @@
+require "date"
+
 module TomlRB
   class Dumper
     attr_reader :toml_str
 
     def initialize(hash)
-      @toml_str = ''
+      @toml_str = ""
 
       visit(hash, [])
     end
@@ -78,15 +80,21 @@ module TomlRB
     end
 
     def print_prefix(prefix, extra_brackets = false)
-      new_prefix = prefix.join('.')
-      new_prefix = '[' + new_prefix + ']' if extra_brackets
+      new_prefix = prefix.join(".")
+      new_prefix = "[" + new_prefix + "]" if extra_brackets
 
       @toml_str += "[" + new_prefix + "]\n"
     end
 
     def to_toml(obj)
-      if obj.is_a? Time
-        obj.strftime('%Y-%m-%dT%H:%M:%SZ')
+      if obj.is_a?(Time) || obj.is_a?(DateTime)
+        obj.strftime("%Y-%m-%dT%H:%M:%SZ")
+      elsif obj.is_a?(Date)
+        obj.strftime("%Y-%m-%d")
+      elsif obj.is_a? Regexp
+        obj.inspect.inspect
+      elsif obj.is_a? String
+        obj.inspect.gsub(/\\(#[$@{])/, '\1')
       else
         obj.inspect
       end

data/lib/toml-rb/grammars/array.citrus

@@ -1,39 +1,37 @@
 grammar TomlRB::Arrays
   include TomlRB::Primitive
-
-  rule array
-    ("[" array_comments (elements)? space ","? array_comments "]" indent?) <TomlRB::ArrayParser>
-  end
-
+  
   rule array_comments
     (indent? (comment indent?)*)
   end
 
-  rule elements
-    float_array | string_array | array_array | integer_array | datetime_array | bool_array
-  end
-
   rule float_array
-    ((exponent | float) (space "," array_comments (exponent | float))*)
+    (float (space "," array_comments float)*) {
+      captures[:float].map(&:value)
+    }
   end
 
   rule string_array
-    (string (space "," array_comments string)*)
-  end
-
-  rule array_array
-    (array (space "," array_comments array)*)
+    (string (space "," array_comments string)*) {
+      captures[:string].map(&:value)
+    }
   end
 
   rule integer_array
-    (integer (space "," array_comments integer)*)
+    (integer (space "," array_comments integer)*) {
+      captures[:integer].map(&:value)
+    }
   end
 
   rule datetime_array
-    (datetime (space "," array_comments datetime)*)
+    (datetime (space "," array_comments datetime)*) {
+      captures[:datetime].map(&:value)
+    }
   end
 
   rule bool_array
-    (bool (space "," array_comments bool)*)
+    (bool (space "," array_comments bool)*) {
+      captures[:bool].map(&:value)
+    }
   end
 end

data/lib/toml-rb/grammars/document.citrus

@@ -3,31 +3,43 @@ grammar TomlRB::Document
   include TomlRB::Arrays
 
   rule document
-    (comment | table_array | keygroup | keyvalue | line_break)*
+    (comment | table_array | table | keyvalue | line_break)*
   end
 
   rule table_array
-    (space? '[[' stripped_key ("." stripped_key)* ']]' comment?) <TomlRB::TableArrayParser>
+    (space? '[[' stripped_key ']]' comment?) <TomlRB::TableArrayParser>
   end
 
-  rule keygroup
-    (space? '[' stripped_key ("." stripped_key)* ']' comment?) <TomlRB::KeygroupParser>
+  rule table
+    (space? '[' stripped_key ']' comment?) <TomlRB::TableParser>
   end
 
   rule keyvalue
-    (stripped_key '=' space? v:(toml_values) comment?) <TomlRB::KeyvalueParser>
+    (stripped_key '=' space? v:(toml_values) comment? space) <TomlRB::KeyvalueParser>
   end
 
   rule inline_table
-    (space? '{' (keyvalue (',' keyvalue)*)? space? '}' ) <TomlRB::InlineTableParser>
+    (space? '{' (keyvalue? (',' keyvalue)*)? space? '}' ) <TomlRB::InlineTableParser>
   end
 
   rule inline_table_array
-    ("[" array_comments inline_table_array_elements space ","? array_comments "]" indent?) <TomlRB::InlineTableArrayParser>
+    (inline_table (space "," array_comments inline_table)*) {
+      captures[:inline_table].map(&:value).map(&:value)
+    }
   end
 
-  rule inline_table_array_elements
-    (inline_table (space "," array_comments inline_table)*)
+  rule array
+    ("[" array_comments (array_elements)? space ","? array_comments "]" indent?) <TomlRB::ArrayParser>
+  end
+
+  rule array_elements
+    inline_table_array | float_array | string_array | array_array | integer_array | datetime_array | bool_array
+  end
+
+  rule array_array
+    (array (space "," array_comments array)*) {
+      captures[:array].map(&:value)
+    }
   end
 
   rule toml_values

data/lib/toml-rb/grammars/helper.citrus

@@ -12,6 +12,6 @@ grammar TomlRB::Helper
   end
 
   rule line_break
-    (space? "\n" | space? "\r\n") { nil }
+    (space "\n" space | space "\r\n" space) { nil }
   end
 end

data/lib/toml-rb/grammars/primitive.citrus

@@ -2,7 +2,7 @@ grammar TomlRB::Primitive
   include TomlRB::Helper
 
   rule primitive
-    string | bool | datetime | number
+    datetime | bool | number | string
   end
 
   ##
@@ -34,50 +34,97 @@ grammar TomlRB::Primitive
   ##
 
   rule datetime
-    ( skeleton:(datetime_skeleton | date_skeleton) ("Z" | date_offset | [,\.] frac:(/\d/1*6) date_offset?)? ) {
-      skeleton = captures[:skeleton].first
-      y,m,d,h,mi,s = skeleton.value
-      offset = captures[:date_offset].first || "+00:00"
-      sec_frac = captures[:frac].first || 0
-      s = "#{s}.#{sec_frac}".to_f
-
-      Time.new(*[y,m,d,h,mi,s,offset.to_s])
-    }
+    offset_datetime | local_datetime | local_date | local_time
+  end
+
+  rule offset_datetime
+    ( skeleton:datetime_skeleton ("Z" | date_offset) ) <TomlRB::OffsetDateTimeParser>
+  end
+
+  rule local_datetime
+    datetime_skeleton <TomlRB::LocalDateTimeParser>
+  end
+
+  rule local_date
+    (date_skeleton space) <TomlRB::LocalDateParser>
+  end
+
+  rule local_time
+    (time_skeleton space) <TomlRB::LocalTimeParser>
   end
 
   rule datetime_skeleton
-    (y:/\d\d\d\d/ "-" m:/\d\d/ "-" d:/\d\d/ "T" h:/\d\d/ ":" mi:/\d\d/ ":" s:/\d\d/) {
-      [:y,:m,:d,:h,:mi,:s].map{ |s| capture(s).value }
+    (date_skeleton ("T"|" ") time_skeleton) {
+      capture(:date_skeleton).value + capture(:time_skeleton).value
     }
   end
 
-  rule date_offset
-    offset:(sign /\d\d/ ":" /\d\d/)
+  rule date_skeleton
+    (year:/\d\d\d\d/ "-" mon:/\d\d/ "-" day:/\d\d/) {
+      [:year,:mon,:day].map{ |s| capture(s).value }
+    }
   end
 
-  rule date_skeleton
-    (y:/\d\d\d\d/ "-" m:/\d\d/ "-" d:/\d\d/) {
-      [:y,:m,:d].map{ |s| capture(s).value } + [0, 0, 0]
+  rule time_skeleton
+    ( hour:([0-2][0-9]) ":" mim:([0-6][0-9]) ":" sec:([0-6][0-9])  ([,\.] sec_frac:(/\d/1*6))? ) {
+      [:hour,:mim,:sec].map{ |s| capture(s).value } + [capture(:sec_frac) || '0']
     }
   end
 
+  rule date_offset
+    offset:(sign /\d\d/ ":" /\d\d/)
+  end
+
   ##
   # Number rules
   ##
 
   rule number
-     exponent | float | integer
+    float | integer
   end
 
   rule float
-    (integer '.' integer) { to_str.to_f }
+    inf | nan | exponential_float | fractional_float
+  end
+
+  rule inf
+    (s:sign? 'inf') {
+      sign = (capture(:s).value != '-') ? 1 : -1
+      sign * Float::INFINITY
+    }
   end
 
-  rule exponent
-    ( (float | integer) [eE] integer) { to_str.to_f }
+  rule nan
+    (sign? 'nan') { Float::NAN }
+  end
+
+  rule exponential_float
+    ((fractional_float | demical_integer) [eE] demical_integer) { to_str.to_f }
+  end
+
+  rule fractional_float
+    (demical_integer '.' [0-9_]+) { 
+      to_str.to_f
+    }
   end
 
   rule integer
+    hexadecimal_integer | octal_integer | binary_integer | demical_integer
+  end
+
+  rule hexadecimal_integer
+    ('0x' [a-fA-F0-9_]+) { to_str.to_i(16) }
+  end
+
+  rule octal_integer
+    ('0o' [0-7_]+) { to_str.to_i(8) }
+  end
+
+  rule binary_integer
+    ('0b' [01_]+) { to_str.to_i(2) }
+  end
+
+  rule demical_integer
     (sign? [0-9_]+) { to_str.to_i }
   end
 
@@ -106,7 +153,7 @@ grammar TomlRB::Primitive
   ##
 
   rule key
-    quoted_key | bare_key
+    dotted_key
   end
 
   rule bare_key
@@ -114,6 +161,16 @@ grammar TomlRB::Primitive
   end
 
   rule quoted_key
-    string
+    basic_string | literal_string 
+  end
+
+  rule single_key
+    quoted_key | bare_key
+  end
+
+  rule dotted_key
+    (space? single_key space?  ("." space? single_key space?)* ) {
+      captures[:single_key].map(&:value)
+    }
   end
 end

data/lib/toml-rb/inline_table.rb

@@ -1,57 +1,21 @@
 module TomlRB
   class InlineTable
-    attr_reader :symbolize_keys
-
     def initialize(keyvalue_pairs)
       @pairs = keyvalue_pairs
-      @symbolize_keys = false
     end
 
-    def value(symbolize_keys = false)
-      if (@symbolize_keys = symbolize_keys)
-        tuple = ->(kv) { [kv.key.to_sym, visit_value(kv.value)] }
-      else
-        tuple = ->(kv) { [kv.key, visit_value(kv.value)] }
-      end
-
-      Hash[@pairs.map(&tuple)]
+    def accept_visitor(keyvalue)
+      value keyvalue.symbolize_keys
     end
 
-    def visit_inline_table(inline_table)
+    def value(symbolize_keys = false)
       result = {}
-
-      inline_table.value(@symbolize_keys).each do |k, v|
-        result[key k] = visit_value v
+      @pairs.each do |kv|
+        update = kv.assign({}, [], symbolize_keys)
+        result.merge!(update) { |key, _, _| fail ValueOverwriteError.new(key) }
       end
-
       result
     end
-
-    def accept_visitor(keyvalue)
-      keyvalue.visit_inline_table self
-    end
-
-    private
-
-    def visit_value(a_value)
-      return a_value unless a_value.respond_to? :accept_visitor
-
-      a_value.accept_visitor self
-    end
-
-    def key(a_key)
-      symbolize_keys ? a_key.to_sym : a_key
-    end
-  end
-
-  class InlineTableArray
-    def initialize(inline_tables)
-      @inline_tables = inline_tables
-    end
-
-    def value(symbolize_keys = false)
-      @inline_tables.map { |it| it.value(symbolize_keys) }
-    end
   end
 
   module InlineTableParser
@@ -59,14 +23,4 @@ module TomlRB
       TomlRB::InlineTable.new captures[:keyvalue].map(&:value)
     end
   end
-
-  module InlineTableArrayParser
-    def value
-      tables = captures[:inline_table_array_elements].map do |x|
-        x.captures[:inline_table]
-      end
-
-      TomlRB::InlineTableArray.new(tables.flatten.map(&:value)).value
-    end
-  end
 end

data/lib/toml-rb/keyvalue.rb

@@ -1,31 +1,39 @@
+require_relative "inline_table"
+
 module TomlRB
   class Keyvalue
-    attr_reader :value, :symbolize_keys
+    attr_reader :dotted_keys, :value, :symbolize_keys
 
-    def initialize(key, value)
-      @key = key
+    def initialize(dotted_keys, value)
+      @dotted_keys = dotted_keys
       @value = value
       @symbolize_keys = false
     end
 
-    def assign(hash, symbolize_keys = false)
+    def assign(hash, fully_defined_keys, symbolize_keys = false)
       @symbolize_keys = symbolize_keys
-      fail ValueOverwriteError.new(key) if hash.key?(key)
-      hash[key] = visit_value @value
-    end
-
-    def visit_inline_table(inline_table)
-      result = {}
-
-      inline_table.value(@symbolize_keys).each do |k, v|
-        result[key k] = visit_value v
+      dotted_keys_str = @dotted_keys.join(".")
+      keys = symbolize_keys ? @dotted_keys.map(&:to_sym) : @dotted_keys
+      update = keys.reverse.inject(visit_value(@value)) { |k1, k2| {k2 => k1} }
+
+      if @value.is_a?(InlineTable)
+        fully_defined_keys << dotted_keys_str
+        hash.merge!(update) { |key, _, _| fail ValueOverwriteError.new(key) }
+      elsif fully_defined_keys.find { |k| update.dig(*k) }
+        hash.merge!(update) { |key, _, _| fail ValueOverwriteError.new(key) }
+      else
+        dotted_key_merge(hash, update)
       end
-
-      result
     end
 
-    def key(a_key = @key)
-      symbolize_keys ? a_key.to_sym : a_key
+    def dotted_key_merge(hash, update)
+      hash.merge!(update) { |key, old, new|
+        if old.is_a?(Hash) && new.is_a?(Hash)
+          dotted_key_merge(old, new)
+        else
+          fail ValueOverwriteError.new(key)
+        end
+      }
     end
 
     def accept_visitor(parser)
@@ -40,6 +48,7 @@ module TomlRB
       a_value.accept_visitor self
     end
   end
+
   # Used in document.citrus
   module KeyvalueParser
     def value

data/lib/toml-rb/parser.rb

@@ -2,11 +2,12 @@ module TomlRB
   class Parser
     attr_reader :hash
 
-    def initialize(content, options = {})
+    def initialize(content, symbolize_keys: false)
       @hash = {}
       @visited_keys = []
+      @fully_defined_keys = []
       @current = @hash
-      @symbolize_keys = options[:symbolize_keys]
+      @symbolize_keys = symbolize_keys
 
       begin
         parsed = TomlRB::Document.parse(content)
@@ -19,18 +20,20 @@ module TomlRB
     # Read about the Visitor pattern
     # http://en.wikipedia.org/wiki/Visitor_pattern
     def visit_table_array(table_array)
+      @fully_defined_keys = []
       table_array_key = table_array.full_key
       @visited_keys.reject! { |k| k.start_with? table_array_key }
 
       @current = table_array.navigate_keys @hash, @symbolize_keys
     end
 
-    def visit_keygroup(keygroup)
-      @current = keygroup.navigate_keys @hash, @visited_keys, @symbolize_keys
+    def visit_table(table)
+      @fully_defined_keys = []
+      @current = table.navigate_keys @hash, @visited_keys, @symbolize_keys
     end
 
     def visit_keyvalue(keyvalue)
-      keyvalue.assign @current, @symbolize_keys
+      keyvalue.assign @current, @fully_defined_keys, @symbolize_keys
     end
   end
 end

data/lib/toml-rb/string.rb

@@ -2,14 +2,14 @@ module TomlRB
   # Used in primitive.citrus
   module BasicString
     SPECIAL_CHARS = {
-      '\\0'  => "\0",
-      '\\t'  => "\t",
-      '\\b'  => "\b",
-      '\\f'  => "\f",
-      '\\n'  => "\n",
-      '\\r'  => "\r",
-      '\\"'  => '"',
-      '\\\\' => '\\'
+      "\\0" => "\0",
+      "\\t" => "\t",
+      "\\b" => "\b",
+      "\\f" => "\f",
+      "\\n" => "\n",
+      "\\r" => "\r",
+      '\\"' => '"',
+      "\\\\" => "\\"
     }.freeze
 
     def value
@@ -21,7 +21,7 @@ module TomlRB
     # Replace the unicode escaped characters with the corresponding character
     # e.g. \u03B4 => ?
     def self.decode_unicode(str)
-      [str[2..-1].to_i(16)].pack('U')
+      [str[2..-1].to_i(16)].pack("U")
     end
 
     def self.transform_escaped_chars(str)
@@ -29,7 +29,7 @@ module TomlRB
         if m.size == 2
           SPECIAL_CHARS[m] || parse_error(m)
         else
-          decode_unicode(m).force_encoding('UTF-8')
+          decode_unicode(m).force_encoding("UTF-8")
         end
       end
     end
@@ -47,11 +47,11 @@ module TomlRB
 
   module MultilineString
     def value
-      return '' if captures[:text].empty?
+      return "" if captures[:text].empty?
       aux = captures[:text].first.value
 
       # Remove spaces on multilined Singleline strings
-      aux.gsub!(/\\\r?\n[\n\t\r ]*/, '')
+      aux.gsub!(/\\\r?\n[\n\t\r ]*/, "")
 
       TomlRB::BasicString.transform_escaped_chars aux
     end
@@ -59,10 +59,10 @@ module TomlRB
 
   module MultilineLiteral
     def value
-      return '' if captures[:text].empty?
+      return "" if captures[:text].empty?
       aux = captures[:text].first.value
 
-      aux.gsub(/\\\r?\n[\n\t\r ]*/, '')
+      aux.gsub(/\\\r?\n[\n\t\r ]*/, "")
     end
   end
 end