hcl-rb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5112fcbbb036a494cf40ca905f073e0390d49d9c2bc6a09631b6f565cc42b1a1
+  data.tar.gz: 04bca627bf636706076f49c19b6bfbf8a2146b690c2eed1e76f6ee8d8be6d917
+SHA512:
+  metadata.gz: bf9fd4abdf12d5467a38079d41b4c002bd01cc00d9f1f264d79d7237649f67179b58a352d98efe82037262dfbd4e4a17d463c62843dda0e90cc0f0434e9bbf1c
+  data.tar.gz: c4a391a9ef43ab2c9f18fbd1aaa5816162e2640e263b7e2418e7b5196b77f39fbf8eb71d49aaa833eea37a982d3f60da9d0f4853203cced9dd89e2f666a4a834

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "hcl"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/hcl/ast_visitor.rb

@@ -0,0 +1,28 @@
+class HCL::ASTVisitor
+  @@types = [
+    :document,
+    :kv_key,
+    :string,
+    :key_string,
+    :object,
+    :comment,
+    :integer,
+    :boolean,
+    :float,
+    :heredoc,
+    :list,
+    :object
+  ]
+
+  def visit(ast)
+    return nil unless ast
+
+    raise "AST object must be Hash" unless Hash === ast
+
+    type = @@types.find { |type| ast.key? type }
+    raise "Couldn't determine AST object type" unless type
+
+    method_name = "visit_#{type}"
+    send(method_name, ast)
+  end
+end

data/lib/hcl/decoder.rb

@@ -0,0 +1,469 @@
+class HCL::Decoder < HCL::ASTVisitor
+  def initialize
+  end
+
+  def decode(ast)
+    visit(ast)
+  end
+
+  def visit_document(ast)
+    doc = ast[:document]
+    if Array === doc
+      visit({object: doc})
+    else
+      doc
+    end || {}
+  end
+
+  def conv_key(key)
+    if Hash === key
+      if key.key? :string
+	key[:string]
+      elsif Hash === key[:key]
+	key[:key][:string]
+      else
+	key[:key]
+      end
+    else
+      key
+    end.to_s
+  end
+
+  def visit_kv_key(ast)
+    key = conv_key(ast[:kv_key])
+    value = visit(ast[:value])
+
+    extra_keys = ast[:keys]
+    if extra_keys.nil? || extra_keys == []
+      { key => value }
+    else
+      rest = extra_keys.reverse.inject(value) do |h, k|
+	{ conv_key(k) => h }
+      end
+      { key => rest }
+    end
+  end
+
+  def newline?(b)
+    b == "\n".ord || b == "\r".ord
+  end
+
+  SIMPLE_ESCAPES = [
+    ["a", "\a"],
+    ["b", "\b"],
+    ["f", "\f"],
+    ["n", "\n"],
+    ["r", "\r"],
+    ["t", "\t"],
+    ["v", "\v"],
+    ["\\", "\\"],
+    ["'", "'"],
+    ["\"", "\""]
+  ].map { |a, b| [a.ord, b] }.to_h
+
+  def undump(str)
+    chunks = nil
+    chunk_start = 0
+    braces = 0
+    dollar = false
+    hil = false
+    bytes = str.bytes
+
+    io = StringIO.new(str)
+    b = io.getbyte
+
+    until b.nil?
+      if braces == 0 and dollar and b == "{".ord
+	braces += 1
+	hil = true
+      elsif braces > 0 and b == "{".ord
+	braces += 1
+      end
+
+      if braces > 0 and b == "}".ord
+	braces -= 1
+      end
+
+      dollar = false
+      if braces == 0 and b == "$".ord
+	dollar = true
+      end
+
+      if b == "\\".ord
+	chunks = [] if chunks.nil?
+
+	if chunk_start != io.pos-1
+	  chunks << str[chunk_start..io.pos-2]
+	end
+
+	s = nil
+
+	b = io.getbyte
+
+	escape = SIMPLE_ESCAPES[b]
+
+	if escape != nil
+	  b = io.getbyte
+	  s = escape
+	elsif newline? b
+	  raise "string literal not terminated" if braces == 0
+	  b = io.getbyte while newline? b
+	  s = "\n"
+	elsif b == "x".ord
+	  c1 = nil
+	  c2 = nil
+
+	  b = io.getbyte || 0
+
+	  c1 = b.chr.hex
+	  raise "invalid hexadecimal escape sequence" if c1.zero?
+
+	  b = io.getbyte || 0
+
+	  c2 = b.chr.hex
+	  raise "invalid hexadecimal escape sequence" if c2.zero?
+
+	  b = io.getbyte
+	  s = (c1*16 + c2).to_s(16)
+	elsif b == "u".ord || b == "U".ord
+	  size = if b == "U".ord then 8 else 4 end
+
+	  b = io.getbyte # Skip "u".
+
+	  codepoint = 0
+	  hexdigits = 0
+	  while hexdigits < size
+	    hex = b && b.chr.hex
+	    raise "UTF-8 escape sequence contained invalid character:(#{b.chr})" unless hex
+
+	    hexdigits += 1
+	    codepoint = codepoint * 16 + hex
+
+	    raise "UTF-8 escape sequence too large" if codepoint > 0x10FFFF
+
+	    b = io.getbyte
+	  end
+
+	  s = codepoint.chr(Encoding::UTF_8)
+	else
+	  cb = b && b.chr.to_i
+
+	  raise "invalid escape sequence" if cb.nil?
+
+	  b = io.getbyte
+
+	  if b != nil
+	    c2 = b.chr.to_i
+
+	    if b == "0".ord || c2 != 0
+	      cb = 10 * cb + c2
+	      b = io.getbyte
+
+	      if b != nil
+		c3 = b.chr.to_i
+
+		if b == "0".ord || c3 != 0
+		  cb = 10 * cb + c3
+
+		  raise "invalid decimal escape sequence" if cb > 255
+
+		  b = io.getbyte
+		end
+	      end
+	    end
+	  end
+
+	  s = cb.chr
+	end
+
+	chunks << s if s != nil
+
+	chunk_start = if b.nil? then io.pos else io.pos - 1 end
+      elsif b.nil? || (newline? b && braces == 0)
+	raise "unfinished string"
+      else
+	b = io.getbyte
+      end
+    end
+
+    raise "expected terminating brace" if b.nil? and braces != 0
+
+    if chunks != nil
+      # Put last chunk into buffer.
+      if chunk_start != io.pos
+	chunks << str[chunk_start..io.pos-1]
+      end
+
+      chunks.join
+    else
+      # There were no escape sequences.
+      str
+    end
+  end
+
+  def visit_string(ast)
+    string = ast[:string]
+    if string == []
+      ""
+    else
+      undump(string.to_s)
+    end
+  end
+
+  def visit_key_string(ast)
+    ast[:key_string].to_s
+  end
+
+  def visit_comment(ast)
+  end
+
+  def visit_integer(ast)
+    ast[:integer].to_i
+  end
+
+  def visit_boolean(ast)
+    case ast[:boolean]
+    when "true" then
+      true
+    when "false"
+      false
+    else raise "unknown boolean #{ast}"
+    end
+  end
+
+  def visit_float(ast)
+    ast[:float].to_f
+  end
+
+  def visit_heredoc(ast)
+    doc = ast[:heredoc]
+    tag = doc[:tag]
+    content = doc[:doc].to_s.gsub(/#{tag}$/, "")[1..-1]
+
+    case doc[:backticks].to_s
+    when "<<" then
+      content
+    when "<<-" then
+      # We need to unindent each line based on the indentation level of the marker
+      lines = content.split("\n")
+      indent = lines.last
+
+      indented = true
+      lines.each do |line|
+	if indent.size > line.size
+	  indented = false
+	  break
+	end
+
+	prefix_found = line.delete_prefix(indent) != line
+
+	unless prefix_found
+	  indented = false
+	  break
+	end
+      end
+
+      # If all lines are not at least as indented as the terminating mark, return the
+      # heredoc as is, but trim the leading space from the marker on the final line.
+      unless indented
+	return content.sub(/\s+\Z/, "") + "\n"
+      end
+
+      unindented_lines = []
+      lines.each do |line|
+	unindented_lines << line.delete_prefix(indent)
+      end
+      unindented_lines.join("\n")
+    else raise "unknown backticks #{backticks}"
+    end
+  end
+
+  def visit_list(ast)
+    return [] if ast[:list].nil?
+
+    list = if Hash === ast[:list]
+	     [ast[:list]]
+	   else
+	     ast[:list]
+	   end
+
+    list.map do |a|
+      value = a[:value]
+      value = if Array === value
+		it = value.reject { |i| i.key? :comment }
+		raise "extra list value" unless it.size == 1
+		it.first
+	      else
+		value
+	      end
+      visit(value)
+    end.reject(&:nil?)
+  end
+
+  def recurse_objects(a, b, keys)
+    a_child = a.dup
+    b_child = b.dup
+
+    keys.each do |key|
+      a_child = a_child[key]
+      b_child = b_child[key]
+    end
+
+    return a_child, b_child
+  end
+
+  def hash_or_array(obj)
+    Hash === obj or Array === obj
+  end
+
+  def common_nested_keys(a, b)
+    a_child = a
+    b_child = b
+
+    keys = []
+    finished = false
+
+    until finished
+      break if Array === a_child or Array === b_child
+      break if a_child.nil? or b_child.nil?
+      break if a_child.length > 1 or b_child.length > 1
+
+      a_child.each do |k, v|
+	finished = true if b_child[k].nil?
+	finished = true if (not hash_or_array(a_child[k]) or not hash_or_array(b_child[k]))
+	break if finished
+
+	keys << k
+	a_child = a_child[k]
+	b_child = b_child[k]
+	break
+      end
+    end
+
+    return keys, a_child, b_child
+  end
+
+  def objects_share_keys?(a, b, keys)
+    b.each_key do |k|
+      return true if a.key? k
+    end
+
+    false
+  end
+
+  def set_object_nested(this, value, keys)
+    raise "no keys" unless keys.size > 0
+
+    if keys.size == 1
+      this[keys.last] = value
+      return
+    end
+
+    this_parent = this[keys.first]
+
+    keys.drop(1).each do |key|
+      this_parent = this_parent[key]
+    end
+
+    this_parent[keys.last] = value
+  end
+
+  def expand_objects(this, other, keys)
+    this_child, other_child = recurse_objects(this, other, keys)
+
+    set_object_nested(this, [this_child, other_child], keys)
+  end
+
+  def merge_object_lists(this, other, keys)
+    this_child, other_child = recurse_objects(this, other, keys)
+
+    if Hash === this_child && Array === other_child
+      object = this_child
+      list = other_child
+    elsif Array === this_child && Hash === other_child
+      object = other_child
+      list = this_child
+    else
+      raise "not both lists" unless Array === this_child && Array == other_child
+    end
+
+    if list.nil?
+      this_child.each_value do |v|
+	other_child << v
+      end
+
+      set_object_nested(this, other_child, keys)
+    else
+      list << object
+      set_object_nested(this, list, keys)
+    end
+  end
+
+  def merge_objects(this, other)
+    raise "merge_objects was called on the same object" if this == other
+    raise "merge_objects was called with non-objects" unless Hash === this && Hash === other
+
+    other.each do |k, v|
+      tmp = this[k]
+      if tmp != nil
+	if Hash === tmp and Hash === v
+	  merge_objects(tmp, v)
+	else
+	  this[k] = v
+	end
+      else
+	this[k] = v
+      end
+    end
+  end
+
+  def visit_object(ast)
+    object = ast[:object]
+    return {} if object == ""
+
+    pairs = ast[:object].map { |a| visit(a) }.reject(&:nil?)
+
+    pairs.inject({}) do |result, object|
+      first_key = object.sort.first[0]
+      existing = result[first_key]
+      value = object[first_key]
+      expand = false
+
+      if existing != nil
+	if Array === existing
+	  existing << value
+	else
+	  if Hash === existing
+	    if not Hash === existing
+	      expand = true
+	    else
+	      keys, a, b = common_nested_keys(existing, value)
+	      if Array === a or Array === b
+		merge_object_lists(existing, value, keys)
+	      elsif objects_share_keys?(a, b, keys)
+		if keys.size == 0
+		  expand = true
+		else
+		  expand_objects(existing, value, keys)
+		end
+	      else
+		merge_objects(existing, value)
+		result[first_key] = existing
+	      end
+	    end
+	  else
+	    expand = true
+	  end
+
+	  if expand
+	    result[first_key] = [existing, value]
+	  end
+	end
+      else
+	result[first_key] = value
+      end
+
+      result
+    end
+  end
+end

data/lib/hcl/generator.rb

@@ -0,0 +1,26 @@
+class HCL::Generator
+  attr_reader :body, :doc
+
+  def initialize(doc)
+    # Ensure all the to_hcl methods are injected into the base Ruby classes
+    # used by HCL.
+    self.class.inject!
+
+    @doc = doc
+    @body = doc.to_hcl
+
+    return @body
+  end
+
+  # Whether or not the injections have already been done.
+  @@injected = false
+  # Inject to_hcl methods into the Ruby classes used by HCL (booleans,
+  # String, Numeric, Array). You can add to_hcl methods to your own classes
+  # to allow them to be easily serialized by the generator (and it will shout
+  # if something doesn't have a to_hcl method).
+  def self.inject!
+    return if @@injected
+    require 'hcl/monkey_patch'
+    @@injected = true
+  end
+end

data/lib/hcl/monkey_patch.rb

@@ -0,0 +1,91 @@
+module HCL
+  def self.escape_key(key)
+    str = key.to_s
+    pos = str =~ /[^a-zA-Z0-9_\-]/
+
+    return str if pos.nil?
+
+    str.dump
+  end
+end
+
+class Object
+  def hcl_object?
+    self.kind_of?(Hash)
+  end
+  def hcl_list?
+    self.kind_of?(Array) && self.first.hcl_object?
+  end
+end
+
+class Hash
+  def to_hcl(indent = 0)
+    return "" if self.empty?
+    hcl = ""
+    spaces = " " * indent
+
+    self.each do |k, v|
+      next if v.hcl_object?
+      next if v.hcl_list? and v.size > 0 and v.first.hcl_object?
+
+      hcl << spaces
+      hcl << HCL.escape_key(k) << " = "
+      hcl << v.to_hcl(indent + 4)
+      hcl << "\n"
+    end
+
+    self.each do |k, v|
+      if v.hcl_object?
+	key = HCL.escape_key(k)
+	hcl << spaces
+	hcl << key << " {\n"
+	hcl << v.to_hcl(indent + 4)
+	hcl << spaces << "}\n"
+      end
+      if v.hcl_list? and v.size > 0 and v.first.hcl_object?
+	key = HCL.escape_key(k)
+	hcl << spaces
+	hcl << key << " = ["
+	v.each do |i|
+	  if i.hcl_object?
+	    hcl << "\n" << spaces << "{\n"
+	  else
+	    hcl << spaces
+	  end
+	  hcl << i.to_hcl(indent + 4)
+	  if i.hcl_object?
+	    hcl << spaces << "},\n"
+	  end
+	end
+	hcl << spaces << "]\n"
+      end
+    end
+
+    hcl
+  end
+end
+class Array
+  def to_hcl(indent = 0)
+    "[" + self.map {|v| v.to_hcl(indent) }.join(", ") + "]"
+  end
+end
+class TrueClass
+  def to_hcl(indent = 0); "true"; end
+end
+class FalseClass
+  def to_hcl(indent = 0); "false"; end
+end
+class String
+  def to_hcl(indent = 0); self.inspect; end
+end
+class Numeric
+  def to_hcl(indent = 0); self.to_s; end
+end
+class Symbol
+  def to_hcl(indent = 0); HCL.escape_key(self.to_s); end
+end
+class DateTime
+  def to_hcl(indent = 0)
+    self.to_time.utc.strftime("%Y-%m-%dT%H:%M:%SZ")
+  end
+end

data/lib/hcl/parser.rb

@@ -0,0 +1,17 @@
+class HCL::Parser
+  def initialize(src)
+    @src = src
+    @parslet = HCL::Parslet.new
+  end
+
+  def parse
+    ast = begin
+	    @parslet.parse(@src)
+	  rescue Parslet::ParseFailed => error
+	    puts error.parse_failure_cause.ascii_tree
+	    raise
+	  end
+
+    HCL::Decoder.new.decode(ast)
+  end
+end

data/lib/hcl/parslet.rb

@@ -0,0 +1,162 @@
+require "parslet"
+
+class HCL::Parslet < Parslet::Parser
+  rule(:document) {
+    all_space >>
+    ((key_value >> all_space) | comment_line).repeat.as(:document) >>
+    all_space
+  }
+  root :document
+
+  rule(:value) {
+    boolean.as(:boolean) |
+    list |
+    object |
+    float.as(:float) |
+    scientific.as(:float) |
+    integer.as(:integer) |
+    string |
+    key.as(:key_string) |
+    heredoc.as(:heredoc)
+  }
+
+  rule(:trailing_comma?) {
+    (all_space >> str(",").maybe).maybe
+  }
+
+  rule (:dood) {
+  }
+
+  rule(:object) {
+    str("{") >> list_comments >> all_space >>
+      ( ( key_value >> list_comments >> all_space ).repeat ).maybe.as(:object) >>
+      str("}") >> list_comments
+  }
+
+  rule(:sign) { str("-") }
+  rule(:sign?) { sign.maybe }
+
+  rule(:integer) {
+    str("0") | sign? >>
+      (match["1-9"] >> match["0-9"].repeat)
+  }
+
+  rule(:exponent) {
+    match["eE"] >> match["+\\-"].maybe >> match["0-9"].repeat
+  }
+
+  rule(:scientific) {
+    sign? >>
+      (match["0-9"] >> match["0-9"].repeat) >> exponent
+  }
+
+  rule(:float) {
+    sign? >>
+      (match["0-9"] >> match["0-9"].repeat).maybe >> str(".") >>
+      (match["0-9"] >> match["0-9"].repeat) >> exponent.maybe
+  }
+
+  rule(:key) {
+    string | (match["\\w_\\-"] >> match["\\w\\d_\\-.:"].repeat)
+  }
+
+  rule(:key_value) {
+    space >> key.as(:kv_key) >> space >>
+      ((key.as(:key) >> space).repeat.as(:keys) >> object.as(:value) | (str("=") >> space >> value.as(:value))) >> trailing_comma?
+  }
+
+  rule (:sq_string) {
+    str("'") >> match["^'\\n"].repeat.maybe.as(:string) >> str("'")
+  }
+
+  rule (:string_inner) {
+    match["^\"\\\\"] | escape
+  }
+
+  rule(:dq_string) {
+    str('"') >> (hil | (str("${").absent? >> string_inner)).repeat.as(:string) >> str('"')
+  }
+
+  rule(:string) {
+    sq_string | dq_string
+  }
+
+  rule(:hil_inner) {
+    brace | match["^\\\\}"] | escape
+  }
+
+  rule(:hil) {
+    str("${") >> hil_inner.repeat.maybe >> str("}")
+  }
+
+  rule (:brace) {
+    str("{") >> hil_inner.repeat.maybe >> str("}")
+  }
+
+  rule(:heredoc)  {
+    space >>
+      backticks.as(:backticks) >>
+      tag.capture(:tag).as(:tag) >> doc.as(:doc)
+  }
+
+  rule(:hex) {
+    match["0-9a-fA-F"]
+  }
+
+  rule(:escape) {
+    str("\\") >> (match["bfnrt\"\\\\"] |
+                  (str("u") >> hex.repeat(4,4)) |
+                   (str("U") >> hex.repeat(8,8)))
+  }
+
+  # the tag that delimits the heredoc
+  rule(:tag) { match['\\w\\d'].repeat(1) }
+  # the doc itself, ends when tag is found at start of line
+  rule(:doc) { gobble_eol >> doc_line }
+  # a doc_line is either the stop tag followed by nothing
+  # or just any kind of line.
+  rule(:doc_line) {
+    ((space >> end_tag).absent? >> gobble_eol).repeat >> space >> end_tag
+  }
+  rule(:end_tag) { dynamic { |s,c| str(c.captures[:tag]) } }
+  # eats anything until an end of line is found
+  rule(:gobble_eol) { (newline.absent? >> any).repeat >> newline }
+
+  rule(:backticks) { str('<<') >> str("-").maybe }
+
+  rule(:boolean) { str("true") | str("false") }
+
+  rule(:space) { match[" \t"].repeat }
+  rule(:all_space) { match[" \t\r\n"].repeat }
+  rule(:newline) { str("\r").maybe >> str("\n") | str("\r") >> str("\n").maybe }
+  rule(:eof) { any.absent? }
+  rule(:newline_or_eof) { newline | eof }
+
+  rule(:comment_line) { comment >> all_space }
+  rule(:single_comment) { (str("#") | str("//")) >> match["^\n"].repeat >> newline_or_eof }
+  rule(:multiline_comment) { str("/*") >> (str("*/").absent? >> any).repeat >> str("*/") }
+  rule(:comment) { (single_comment | multiline_comment).as(:comment) }
+
+  # Finding comments in multiline lists requires accepting a bunch of
+  # possible newlines and stuff before the comment
+  rule(:list_comments) { (all_space >> comment_line).repeat }
+
+  rule(:list) {
+    str("[") >> all_space >> list_comments >>
+    ( list_comments >> # Match any comments on first line
+     dood >>
+      (all_space >> str(",")).maybe >> # possible trailing comma
+      all_space >> list_comments # Grab any remaining comments just in case
+    ).maybe.as(:list) >> str("]")
+  }
+
+  rule (:dood) {
+      all_space >> (value >> list_comments).as(:value) >>
+      (
+        # Separator followed by any comments
+        all_space >> str(",") >> (list_comments >>
+        # Value followed by any comments
+        all_space >> value).as(:value) >> list_comments >> all_space
+      ).repeat
+  }
+end

data/lib/hcl/version.rb

@@ -0,0 +1,3 @@
+module HCL
+  VERSION = "0.1.0"
+end

data/lib/hcl.rb

@@ -0,0 +1,16 @@
+require "hcl/version"
+require "hcl/ast_visitor"
+require "hcl/decoder"
+require "hcl/generator"
+require "hcl/parser"
+require "hcl/parslet"
+
+module HCL
+  def self.load(source)
+    HCL::Parser.new(source).parse
+  end
+
+  def self.load_file(path)
+    HCL::Parser.new(File.read(path)).parse
+  end
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: hcl-rb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ruin0x11
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-05-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+description: 
+email:
+- ipickering2@gmail.com
+executables:
+- console
+- setup
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/console
+- bin/setup
+- lib/hcl.rb
+- lib/hcl/ast_visitor.rb
+- lib/hcl/decoder.rb
+- lib/hcl/generator.rb
+- lib/hcl/monkey_patch.rb
+- lib/hcl/parser.rb
+- lib/hcl/parslet.rb
+- lib/hcl/version.rb
+homepage: https://www.github.com/Ruin0x11/hcl-rb
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://www.github.com/Ruin0x11/hcl-rb
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: A ruby parser for HCL (Hashicorp Configuration Language).
+test_files: []