toml-rb-hs 1.1.1

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

@@ -0,0 +1,119 @@
+grammar TomlRB::Primitive
+  include TomlRB::Helper
+
+  rule primitive
+    string | bool | datetime | number
+  end
+
+  ##
+  # String rules
+  ##
+
+  rule string
+    multiline_string | multiline_literal | basic_string | literal_string
+  end
+
+  rule basic_string
+    (/(["])(?:\\?.)*?\1/ space) <TomlRB::BasicString>
+  end
+
+  rule literal_string
+    (/(['])(?:\\?.)*?\1/ space) <TomlRB::LiteralString>
+  end
+
+  rule multiline_string
+    ('"""' line_break* (text:~('"""' !'"')|'') '"""' space) <TomlRB::MultilineString>
+  end
+
+  rule multiline_literal
+    ("'''" line_break* (text:~("'''" !"'")|'') "'''" space) <TomlRB::MultilineLiteral>
+  end
+
+  ##
+  # Date time rules
+  ##
+
+  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])
+    }
+  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 }
+    }
+  end
+
+  rule date_offset
+    offset:(sign /\d\d/ ":" /\d\d/)
+  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]
+    }
+  end
+
+  ##
+  # Number rules
+  ##
+
+  rule number
+     exponent | float | integer
+  end
+
+  rule float
+    (integer '.' integer) { to_str.to_f }
+  end
+
+  rule exponent
+    ( (float | integer) [eE] integer) { to_str.to_f }
+  end
+
+  rule integer
+    (sign? [0-9_]+) { to_str.to_i }
+  end
+
+  rule sign
+    '+' | '-'
+  end
+
+  ##
+  # Boolean rules
+  ##
+
+  rule bool
+    true | false
+  end
+
+  rule true
+    'true' { true }
+  end
+
+  rule false
+    'false' { false }
+  end
+
+  ##
+  # Key rules
+  ##
+
+  rule key
+    quoted_key | bare_key
+  end
+
+  rule bare_key
+    [a-zA-Z0-9_-]+
+  end
+
+  rule quoted_key
+    string
+  end
+end

data/lib/toml-rb/inline_table.rb

@@ -0,0 +1,72 @@
+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 = lambda {|kv| [kv.key.to_sym, visit_value(kv.value)] }
+      else
+        tuple = lambda {|kv| [kv.key, visit_value(kv.value)] }
+      end
+
+      Hash[@pairs.map(&tuple)]
+    end
+
+    def visit_inline_table(inline_table)
+      result = {}
+
+      inline_table.value(@symbolize_keys).each do |k, v|
+        result[key k] = visit_value v
+      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
+    def value
+      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/keygroup.rb

@@ -0,0 +1,41 @@
+module TomlRB
+  class Keygroup
+    def initialize(nested_keys)
+      @nested_keys = nested_keys
+    end
+
+    def navigate_keys(hash, visited_keys, symbolize_keys = false)
+      ensure_key_not_defined(visited_keys)
+      @nested_keys.each do |key|
+        key = symbolize_keys ? key.to_sym : key
+        hash[key] = {} unless hash.key?(key)
+        element = hash[key]
+        hash = element.is_a?(Array) ? element.last : element
+        # check that key has not been defined before as a scalar value
+        fail ValueOverwriteError.new(key) unless hash.is_a?(Hash)
+      end
+      hash
+    end
+
+    # Fail if the key was already defined with a ValueOverwriteError
+    def ensure_key_not_defined(visited_keys)
+      fail ValueOverwriteError.new(full_key) if visited_keys.include?(full_key)
+      visited_keys << full_key
+    end
+
+    def accept_visitor(parser)
+      parser.visit_keygroup self
+    end
+
+    def full_key
+      @nested_keys.join('.')
+    end
+  end
+
+  # Used in document.citrus
+  module KeygroupParser
+    def value
+      TomlRB::Keygroup.new(captures[:stripped_key].map(&:value))
+    end
+  end
+end

data/lib/toml-rb/keyvalue.rb

@@ -0,0 +1,49 @@
+module TomlRB
+  class Keyvalue
+    attr_reader :value, :symbolize_keys
+
+    def initialize(key, value)
+      @key = key
+      @value = value
+      @symbolize_keys = false
+    end
+
+    def assign(hash, 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
+      end
+
+      result
+    end
+
+    def key(a_key = @key)
+      symbolize_keys ? a_key.to_sym : a_key
+    end
+
+    def accept_visitor(parser)
+      parser.visit_keyvalue self
+    end
+
+    private
+
+    def visit_value(a_value)
+      return a_value unless a_value.respond_to? :accept_visitor
+
+      a_value.accept_visitor self
+    end
+  end
+  # Used in document.citrus
+  module KeyvalueParser
+    def value
+      TomlRB::Keyvalue.new(capture(:stripped_key).value, capture(:v).value)
+    end
+  end
+end

data/lib/toml-rb/parser.rb

@@ -0,0 +1,36 @@
+module TomlRB
+  class Parser
+    attr_reader :hash
+
+    def initialize(content, options = {})
+      @hash = {}
+      @visited_keys = []
+      @current = @hash
+      @symbolize_keys = options[:symbolize_keys]
+
+      begin
+        parsed = TomlRB::Document.parse(content)
+        parsed.matches.map(&:value).compact.each { |m| m.accept_visitor(self) }
+      rescue Citrus::ParseError => e
+        raise TomlRB::ParseError.new(e.message)
+      end
+    end
+
+    # Read about the Visitor pattern
+    # http://en.wikipedia.org/wiki/Visitor_pattern
+    def visit_table_array(table_array)
+      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
+    end
+
+    def visit_keyvalue(keyvalue)
+      keyvalue.assign @current, @symbolize_keys
+    end
+  end
+end

data/lib/toml-rb/string.rb

@@ -0,0 +1,68 @@
+module TomlRB
+  # Used in primitive.citrus
+  module BasicString
+    SPECIAL_CHARS = {
+      '\\0'  => "\0",
+      '\\t'  => "\t",
+      '\\b'  => "\b",
+      '\\f'  => "\f",
+      '\\n'  => "\n",
+      '\\r'  => "\r",
+      '\\"'  => '"',
+      '\\\\' => '\\'
+    }.freeze
+
+    def value
+      aux = TomlRB::BasicString.transform_escaped_chars first.value
+
+      aux[1...-1]
+    end
+
+    # 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')
+    end
+
+    def self.transform_escaped_chars(str)
+      str.gsub(/\\(u[\da-fA-F]{4}|U[\da-fA-F]{8}|.)/) do |m|
+        if m.size == 2
+          SPECIAL_CHARS[m] || parse_error(m)
+        else
+          decode_unicode(m).force_encoding('UTF-8')
+        end
+      end
+    end
+
+    def self.parse_error(m)
+      fail ParseError.new "Escape sequence #{m} is reserved"
+    end
+  end
+
+  module LiteralString
+    def value
+      first.value[1...-1]
+    end
+  end
+
+  module MultilineString
+    def value
+      return '' if captures[:text].empty?
+      aux = captures[:text].first.value
+
+      # Remove spaces on multilined Singleline strings
+      aux.gsub!(/\\\r?\n[\n\t\r ]*/, '')
+
+      TomlRB::BasicString.transform_escaped_chars aux
+    end
+  end
+
+  module MultilineLiteral
+    def value
+      return '' if captures[:text].empty?
+      aux = captures[:text].first.value
+
+      aux.gsub(/\\\r?\n[\n\t\r ]*/, '')
+    end
+  end
+end

data/lib/toml-rb/table_array.rb

@@ -0,0 +1,50 @@
+module TomlRB
+  class TableArray
+    def initialize(nested_keys)
+      @nested_keys = nested_keys
+    end
+
+    def navigate_keys(hash, symbolize_keys = false)
+      last_key = @nested_keys.pop
+      last_key = last_key.to_sym if symbolize_keys
+
+      # Go over the parent keys
+      @nested_keys.each do |key|
+        key = symbolize_keys ? key.to_sym : key
+        hash[key] = {} unless hash[key]
+
+        if hash[key].is_a? Array
+          hash[key] << {} if hash[key].empty?
+          hash = hash[key].last
+        else
+          hash = hash[key]
+        end
+      end
+
+      # Define Table Array
+      if hash[last_key].is_a? Hash
+        fail TomlRB::ParseError,
+             "#{last_key} was defined as hash but is now redefined as a table!"
+      end
+      hash[last_key] = [] unless hash[last_key]
+      hash[last_key] << {}
+
+      hash[last_key].last
+    end
+
+    def accept_visitor(parser)
+      parser.visit_table_array self
+    end
+
+    def full_key
+      @nested_keys.join('.')
+    end
+  end
+
+  # Used in document.citrus
+  module TableArrayParser
+    def value
+      TomlRB::TableArray.new(captures[:stripped_key].map(&:value))
+    end
+  end
+end

data/test/dumper_test.rb

@@ -0,0 +1,100 @@
+unless defined? require_relative
+  def require_relative(path)
+    require path
+  end
+end
+
+require_relative 'helper'
+
+class DumperTest < Minitest::Test
+  def test_dump_empty
+    dumped = TomlRB.dump({})
+    assert_equal('', dumped)
+  end
+
+  def test_dump_types
+    dumped = TomlRB.dump(string: 'TomlRB "dump"')
+    assert_equal("string = \"TomlRB \\\"dump\\\"\"\n", dumped)
+
+    dumped = TomlRB.dump(float: -13.24)
+    assert_equal("float = -13.24\n", dumped)
+
+    dumped = TomlRB.dump(int: 1234)
+    assert_equal("int = 1234\n", dumped)
+
+    dumped = TomlRB.dump(true: true)
+    assert_equal("true = true\n", dumped)
+
+    dumped = TomlRB.dump(false: false)
+    assert_equal("false = false\n", dumped)
+
+    dumped = TomlRB.dump(array: [1, 2, 3])
+    assert_equal("array = [1, 2, 3]\n", dumped)
+
+    dumped = TomlRB.dump(array: [[1, 2], %w(weird one)])
+    assert_equal("array = [[1, 2], [\"weird\", \"one\"]]\n", dumped)
+
+    dumped = TomlRB.dump(datetime: Time.utc(1986, 8, 28, 15, 15))
+    assert_equal("datetime = 1986-08-28T15:15:00Z\n", dumped)
+  end
+
+  def test_dump_nested_attributes
+    hash = { nested: { hash: { deep: true } } }
+    dumped = TomlRB.dump(hash)
+    assert_equal("[nested.hash]\ndeep = true\n", dumped)
+
+    hash[:nested].merge!(other: 12)
+    dumped = TomlRB.dump(hash)
+    assert_equal("[nested]\nother = 12\n[nested.hash]\ndeep = true\n", dumped)
+
+    hash[:nested].merge!(nest: { again: 'it never ends' })
+    dumped = TomlRB.dump(hash)
+    toml = <<-EOS.gsub(/^ {6}/, '')
+      [nested]
+      other = 12
+      [nested.hash]
+      deep = true
+      [nested.nest]
+      again = "it never ends"
+    EOS
+
+    assert_equal(toml, dumped)
+
+    hash = { non: { 'bare."keys"' => { "works" => true } } }
+    dumped = TomlRB.dump(hash)
+    assert_equal("[non.\"bare.\\\"keys\\\"\"]\nworks = true\n", dumped)
+
+    hash = { hola: [{ chau: 4 }, { chau: 3 }] }
+    dumped = TomlRB.dump(hash)
+    assert_equal("[[hola]]\nchau = 4\n[[hola]]\nchau = 3\n", dumped)
+  end
+
+  def test_print_empty_tables
+    hash = { plugins: { cpu: { foo: "bar", baz: 1234 }, disk: {}, io: {} } }
+    dumped = TomlRB.dump(hash)
+    toml = <<-EOS.gsub(/^ {6}/, '')
+      [plugins.cpu]
+      baz = 1234
+      foo = "bar"
+      [plugins.disk]
+      [plugins.io]
+    EOS
+
+    assert_equal toml, dumped
+  end
+
+  def test_dump_array_tables
+    hash = { fruit: [{ physical: { color: "red" } }, { physical: { color: "blue" } }] }
+    dumped = TomlRB.dump(hash)
+    toml = <<-EOS.gsub(/^ {6}/, '')
+      [[fruit]]
+      [fruit.physical]
+      color = "red"
+      [[fruit]]
+      [fruit.physical]
+      color = "blue"
+    EOS
+
+    assert_equal toml, dumped
+  end
+end