Merge pull request #122 from yassun4dev/support_toml_v0.5.0

Support toml v0.5.0

lib/toml-rb.rb

@@ -3,10 +3,11 @@
 require_relative "toml-rb/errors"
 require_relative "toml-rb/array"
 require_relative "toml-rb/string"
+require_relative "toml-rb/datetime"
+require_relative "toml-rb/table"
 require_relative "toml-rb/table_array"
 require_relative "toml-rb/inline_table"
 require_relative "toml-rb/keyvalue"
-require_relative "toml-rb/keygroup"
 require_relative "toml-rb/parser"
 require_relative "toml-rb/dumper"
 

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
+      return elements ? elements.value : []
     end
   end
 end

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

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

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>
   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

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,14 +153,24 @@ grammar TomlRB::Primitive
   ##
 
   rule key
-    quoted_key | bare_key
+    dotted_key
   end
 
   rule bare_key
     [a-zA-Z0-9_-]+
   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