hcl-checker 1.3.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 247e05cab60fd6767963cf61fe8f2ad29eaf0b846188190abbfad18622a0ed24
-  data.tar.gz: b21ba731c3f5900733d6558a14f88f2a58f09c9bea0f1e679a08f771cced6678
+  metadata.gz: 195128a0325ac3b7fa3add01a739dbe3ce0aeb5b3314edfc74d195caa3a0aa61
+  data.tar.gz: ab84f84386083bdbb9aaea917716ea7e8462eaed2b89a2ab4f887fb4c3b2ee93
 SHA512:
-  metadata.gz: ad59851141be917a28be85d9d18ca41ce436a966b37a6cf9e71ee81b67e24d456d909d89a0785066eb23b740bc6319321b5d7f0aa38212486ca1b82ed2196d32
-  data.tar.gz: 7e5446473d11b96397c9c3d7471de1c165f279109e5f84005dada493ddb939443f2fa345f17c5490b39137761a9c61dfdf2af65008e141b62f28c5ff0c4517ba
+  metadata.gz: b53587ad90fa9ed3cf6c2fbfd5cad15f6b526e62e5c63298fbd963a1629d6283a0bac0ab7276674acba8a1d67e38bc2118fe8f9a0a11a5d362afef4957cc745a
+  data.tar.gz: 4d908d23f548138a2e4e876709cda19321650203d13219f8ac8fe3748cd1427e628f9cb834f80bf684252a7d06d9a97d72663f3ac6c19699a0149593e3450a0d

data/Gemfile.lock

@@ -1,21 +1,21 @@
 PATH
   remote: .
   specs:
-    hcl-checker (1.3.0)
+    hcl-checker (1.4.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    diff-lcs (1.3)
+    diff-lcs (1.4.4)
     filesize (0.2.0)
     jsobfu (0.4.2)
       rkelly-remix
-    json (2.3.0)
+    json (2.3.1)
     metasm (1.0.4)
     mini_portile2 (2.4.0)
-    nokogiri (1.10.9)
+    nokogiri (1.10.10)
       mini_portile2 (~> 2.4.0)
-    racc (1.4.14)
+    racc (1.5.0)
     rake (12.3.3)
     rb-readline (0.5.5)
     rex (2.0.12)
@@ -31,15 +31,15 @@ GEM
       rspec-core (~> 3.9.0)
       rspec-expectations (~> 3.9.0)
       rspec-mocks (~> 3.9.0)
-    rspec-core (3.9.1)
-      rspec-support (~> 3.9.1)
-    rspec-expectations (3.9.1)
+    rspec-core (3.9.2)
+      rspec-support (~> 3.9.3)
+    rspec-expectations (3.9.2)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.9.0)
     rspec-mocks (3.9.1)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.9.0)
-    rspec-support (3.9.2)
+    rspec-support (3.9.3)
 
 PLATFORMS
   ruby
@@ -48,7 +48,7 @@ DEPENDENCIES
   bundler (~> 2.1.4)
   hcl-checker!
   nokogiri (>= 1.10.8)
-  racc (= 1.4.14)
+  racc (= 1.5.0)
   rake (~> 12.3.3)
   rex (= 2.0.12)
   rexical (>= 1.0.7)

data/README.md

@@ -1,10 +1,10 @@
 # Hcl::Checker
 
-**Hashicorp Configuration Language** syntax checker and parser. 
+**Hashicorp Configuration Language** syntax checker and parser.
 
 Parser originally created by [Sikula](https://github.com/sikula) and available
 at [Ruby HCL Repository](https://github.com/sikula/ruby-hcl). Only works with
-[HCL Version 1](https://github.com/hashicorp/hcl). 
+[HCL Version 1](https://github.com/hashicorp/hcl).
 
 ## Installation
 
@@ -47,21 +47,21 @@ You can validate the `hcl_string` contents with `valid?` method. This will
 return `true` if is a valid HCL or `false` if not.
 
 ```
-2.3.2 :014 > HCL::Checker.valid? hcl_string
+2.3.2 :014 > HCL1::Checker.valid? hcl_string
  => true
 ```
 
 You can parse the `hcl_string` into a `Hash` with `parse` method.
 
 ```
-2.3.2 :015 > HCL::Checker.parse(hcl_string)
+2.3.2 :015 > HCL1::Checker.parse(hcl_string)
  => {"provider"=>{"aws"=>{"region"=>"${var.aws_region}", "access_key"=>"${var.aws_access_key}", "secret_key"=>"${var.aws_secret_key}"}}, "resource"=>{"aws_vpc"=>{"default"=>{"cidr_block"=>"10.0.0.0/16", "enable_dns_hostnames"=>true, "tags"=>{"Name"=>"Event Store VPC"}}}}}
 ```
 
 If after a `parse` you got `false` you can check `last_error` with:
 
 ```
-2.4.2 :063 > HCL::Checker.last_error
+2.4.2 :063 > HCL1::Checker.last_error
  => "Parse error at  \"eec8b16c-ee89-4ea0-bdcc-d094300a42e8\" , (invalid token: ,)"
 ```
 
@@ -84,7 +84,7 @@ $ bundle exec rake build_grammar
 Building Lexer....done
 Building Parser....done
 ```
-  
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at
@@ -96,5 +96,3 @@ to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
 The gem is available as open source under the terms of the [MIT
 License](https://opensource.org/licenses/MIT).
-
-

data/hcl-checker.gemspec

@@ -6,7 +6,7 @@ Gem::Specification.new do |spec|
   spec.name          = 'hcl-checker'
   spec.version       = HCL::Checker::VERSION
   spec.authors       = ['Marcelo Castellani']
-  spec.email         = ['marcelofc.rock@gmail.com']
+  spec.email         = ['marcelo@linux.com']
 
   spec.summary       = 'Hashicorp Configuration Language parser for Ruby'
   spec.description   = 'Hashicorp Configuration Language parser and checker for Ruby'
@@ -21,8 +21,32 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'bundler', '~> 2.1.4'
   spec.add_development_dependency 'rake', '~> 12.3.3'
   spec.add_development_dependency 'rspec', '~> 3.0'
-  spec.add_development_dependency 'racc', '1.4.14'
+  spec.add_development_dependency 'racc', '1.5.0'
   spec.add_development_dependency 'rex', '2.0.12'
   spec.add_development_dependency 'rexical', '>= 1.0.7'
 
+  spec.post_install_message = %q{
+Hello, I am updating this Gem to support version 2.0 of the HCL.
+
+In the meantime, it is important that you know that there will be a
+compatibility break with the current version, for Gem to support both
+versions.
+
+Therefore, instead of using just HCL::Checker you must tell which
+version you are using, like this:
+
+HCL1::Checker
+
+Or
+
+HCL2::Checker
+
+At the moment both HCL::Checker and HCL1::Checker will work, but with
+the release of support for version 2 the HCL::Checker syntax will no
+longer work.
+
+So, update your code.
+
+Thank you :)
+}
 end

data/lib/hcl/checker/version.rb

@@ -1,5 +1,5 @@
 module HCL
   module Checker
-    VERSION = '1.3.0'
+    VERSION = '1.4.0'
   end
 end

data/lib/hcl1/checker.rb

@@ -0,0 +1,21 @@
+require 'hcl/checker/version'
+require_relative 'lexer'
+require_relative 'parser'
+
+module HCL1
+  module Checker
+    def self.valid?(value)
+      ret = HCLParser.new.parse(value)
+      return true if ret.is_a? Hash
+      false
+    rescue
+      false
+    end
+
+    def self.parse(value)
+      HCLParser.new.parse(value)
+    rescue Racc::ParseError => e
+      return e.message
+    end
+  end
+end

data/lib/hcl1/checker/version.rb

@@ -0,0 +1,5 @@
+module HCL1
+  module Checker
+    VERSION = '1.4.0'
+  end
+end

data/lib/hcl1/lexer.rb

@@ -0,0 +1,175 @@
+#--
+# DO NOT MODIFY!!!!
+# This file is automatically generated by rex 1.0.7
+# from lexical definition file "./assets/lexer.rex".
+#++
+
+
+class HCLLexer
+      require 'strscan'
+
+      class ScanError < StandardError ; end
+
+      attr_reader   :lineno
+      attr_reader   :filename
+      attr_accessor :state
+
+      def scan_setup(str)
+        @ss = StringScanner.new(str)
+        @lineno =  1
+        @state  = nil
+      end
+
+      def action
+        yield
+      end
+
+      def scan_str(str)
+        scan_setup(str)
+        do_parse
+      end
+      alias :scan :scan_str
+
+      def load_file( filename )
+        @filename = filename
+        File.open(filename, "r") do |f|
+          scan_setup(f.read)
+        end
+      end
+
+      def scan_file( filename )
+        load_file(filename)
+        do_parse
+      end
+
+
+        def next_token
+          return if @ss.eos?
+
+          # skips empty actions
+          until token = _next_token or @ss.eos?; end
+          token
+        end
+
+        def _next_token
+          text = @ss.peek(1)
+          @lineno  +=  1  if text == "\n"
+          token = case @state
+            when nil
+          case
+                  when (text = @ss.scan(/\s+/))
+                    ;
+
+                  when (text = @ss.scan(/\#.*|\/\/.*$/))
+                    ;
+
+                  when (text = @ss.scan(/\n|\r/))
+                    ;
+
+                  when (text = @ss.scan(/\/\*/))
+                     action { consume_comment(text) }
+
+                  when (text = @ss.scan(/true|false/))
+                     action { [:BOOL,         to_boolean(text)]}
+
+                  when (text = @ss.scan(/\-?\d+\.\d+/))
+                     action { [:FLOAT,        text.to_f] }
+
+                  when (text = @ss.scan(/-?\d+/))
+                     action { [:NUMBER,       text.to_i] }
+
+                  when (text = @ss.scan(/\"/))
+                     action { [:STRING,       consume_string(text)] }
+
+                  when (text = @ss.scan(/\<<\-?/))
+                     action { [:STRING,       consume_heredoc] }
+
+                  when (text = @ss.scan(/\{/))
+                     action { [:LEFTBRACE,    text]}
+
+                  when (text = @ss.scan(/\}/))
+                     action { [:RIGHTBRACE,   text]}
+
+                  when (text = @ss.scan(/\[/))
+                     action { [:LEFTBRACKET,  text]}
+
+                  when (text = @ss.scan(/\]/))
+                     action { [:RIGHTBRACKET, text]}
+
+                  when (text = @ss.scan(/\,/))
+                     action { [:COMMA,        text]}
+
+                  when (text = @ss.scan(/[a-zA-Z_][a-zA-Z0-9_\-\.]*/))
+                     action { [:IDENTIFIER,   text]}
+
+                  when (text = @ss.scan(/\=/))
+                     action { [:EQUAL,        text]}
+
+                  when (text = @ss.scan(/\-/))
+                     action { [:MINUS,        text]}
+
+          
+          else
+            text = @ss.string[@ss.pos .. -1]
+            raise  ScanError, "can not match: '" + text + "'"
+          end  # if
+
+        else
+          raise  ScanError, "undefined state: '" + state.to_s + "'"
+        end  # case state
+          token
+        end  # def _next_token
+
+  def lex(input)
+    scan_setup(input)
+    tokens = []
+    while token = next_token
+      tokens << token
+    end
+    tokens
+  end
+  def to_boolean(input)
+    input =
+      if input =~ /true/
+        true
+      elsif input =~ /false/
+        false
+      end
+    return input
+  end
+  def consume_comment(input)
+    nested = 1
+    until nested.zero?
+      case(text = @ss.scan_until(%r{/\*|\*/|\z}) )
+      when %r{/\*\z}
+        nested =+ 1
+      when %r{\*/\z}
+        nested -= 1
+      else
+        break
+      end
+    end
+  end
+  def consume_string(input)
+    result = ''
+    nested = 0
+    begin
+      case(text = @ss.scan_until(%r{\"|\$\{|\}|\\}))
+      when %r{\$\{\z}
+        nested += 1
+      when %r{\}\z}
+        nested -= 1 if nested > 0
+      when %r{\\\z}
+        result += text.chop + @ss.getch
+        next
+      end
+      result += text.to_s
+    end until nested == 0 && text =~ %r{\"\z}
+    result.chop
+  end
+  def consume_heredoc
+      token = Regexp.new @ss.scan_until(%r{\n})
+      document = @ss.scan_until(token)
+      document.chop
+  end
+end # class

data/lib/hcl1/parser.rb

@@ -0,0 +1,456 @@
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by Racc 1.4.14
+# from Racc grammer file "".
+#
+
+require 'racc/parser.rb'
+
+require_relative './lexer'
+
+class HCLParser < Racc::Parser
+
+module_eval(<<'...end parse.y/module_eval...', 'parse.y', 123)
+  #//
+  #//       HCL is unclear on what one should do when duplicate
+  #//       keys are encountered.
+  #//
+  #//       from decoder.go: if we're at the root or we're directly within
+  #//                        a list, decode  to hashes, otherwise lists
+  #//
+  #//       from object.go:  there is a flattened list structure
+  #//
+  def flatten_objectlist(list)
+    (list || {}).each_with_object({}) do |a, h|
+      h[a.first] =
+        case a.last
+        when Hash
+          deep_merge(h[a.first] || {}, a.last)
+        else
+          h[a.first] = a.last
+        end
+    end
+  end
+
+
+  def on_error(error_token_id, error_value, value_stack)
+    error_message = value_stack.to_s.split(',').last.gsub(']', '')
+    header = "Parse error at #{error_message} #{error_value} (invalid token: #{error_value})"
+    raise Racc::ParseError, header
+  end
+
+
+  def parse(input)
+    @lexer = HCLLexer.new.lex(input)
+    do_parse
+    return @result
+  end
+
+
+  def next_token
+    @lexer.shift
+  end
+
+  def deep_merge(hash1, hash2)
+    hash2.keys.each do |key|
+      value1 = hash1[key]
+      value2 = hash2[key]
+
+      if value1.is_a?(Hash) && value2.is_a?(Hash)
+        hash1[key] = deep_merge(value1, value2)
+      else
+        hash1[key] = value2
+      end
+    end
+
+    hash1
+  end
+...end parse.y/module_eval...
+##### State transition tables begin ###
+
+racc_action_table = [
+    22,    28,    27,    10,    28,    27,     5,    23,     6,    14,
+    35,    26,    14,    12,    26,    32,    28,    27,    40,     5,
+   -10,     6,    35,     5,    14,     6,    26,    39,    30,     5,
+   -11,     6,    13,    17,    38,    18,    19,    14,    20 ]
+
+racc_action_check = [
+    13,    13,    13,     1,    26,    26,     0,    13,     0,    13,
+    26,    13,    26,     4,    26,    26,    40,    40,    31,     3,
+     5,     3,    40,    14,    40,    14,    40,    31,    14,    29,
+     6,    29,     7,     9,    29,     9,    10,     9,    11 ]
+
+racc_action_pointer = [
+    -1,     3,   nil,    12,     8,    12,    22,    24,   nil,    26,
+    36,    33,   nil,    -2,    16,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,     1,   nil,   nil,    22,
+   nil,    13,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+    13,   nil ]
+
+racc_action_default = [
+    -2,   -33,    -1,    -3,    -5,   -20,   -21,   -33,   -17,   -33,
+   -33,    -7,    -4,   -33,   -33,   -18,   -19,   -20,   -21,    42,
+    -6,   -12,   -13,   -14,   -15,   -16,   -33,   -31,   -32,   -33,
+    -9,   -33,   -23,   -24,   -27,   -28,   -29,   -30,    -8,   -22,
+   -26,   -25 ]
+
+racc_goto_table = [
+    11,     3,    33,    15,     1,     2,    21,    24,    25,    16,
+    31,   nil,   nil,   nil,   nil,    29,    41,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,    11 ]
+
+racc_goto_check = [
+     4,     3,    12,     5,     1,     2,     7,     5,     8,     9,
+    11,   nil,   nil,   nil,   nil,     3,    12,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,     4 ]
+
+racc_goto_pointer = [
+   nil,     4,     5,     1,    -3,    -6,   nil,    -7,    -5,     0,
+   nil,   -16,   -24 ]
+
+racc_goto_default = [
+   nil,   nil,   nil,   nil,     4,    37,     7,    34,    36,     8,
+     9,   nil,   nil ]
+
+racc_reduce_table = [
+  0, 0, :racc_error,
+  1, 19, :_reduce_1,
+  0, 20, :_reduce_2,
+  1, 20, :_reduce_none,
+  2, 21, :_reduce_4,
+  1, 21, :_reduce_5,
+  3, 21, :_reduce_6,
+  2, 21, :_reduce_7,
+  3, 23, :_reduce_8,
+  2, 23, :_reduce_9,
+  1, 24, :_reduce_10,
+  1, 24, :_reduce_11,
+  3, 22, :_reduce_12,
+  3, 22, :_reduce_13,
+  3, 22, :_reduce_14,
+  3, 22, :_reduce_15,
+  3, 22, :_reduce_16,
+  1, 22, :_reduce_17,
+  2, 27, :_reduce_18,
+  2, 27, :_reduce_19,
+  1, 28, :_reduce_20,
+  1, 28, :_reduce_21,
+  3, 26, :_reduce_22,
+  2, 26, :_reduce_23,
+  1, 29, :_reduce_24,
+  3, 29, :_reduce_25,
+  2, 29, :_reduce_26,
+  1, 30, :_reduce_27,
+  1, 30, :_reduce_28,
+  1, 30, :_reduce_29,
+  1, 30, :_reduce_30,
+  1, 25, :_reduce_31,
+  1, 25, :_reduce_32 ]
+
+racc_reduce_n = 33
+
+racc_shift_n = 42
+
+racc_token_table = {
+  false => 0,
+  :error => 1,
+  :BOOL => 2,
+  :FLOAT => 3,
+  :NUMBER => 4,
+  :COMMA => 5,
+  :COMMAEND => 6,
+  :IDENTIFIER => 7,
+  :EQUAL => 8,
+  :STRING => 9,
+  :MINUS => 10,
+  :LEFTBRACE => 11,
+  :RIGHTBRACE => 12,
+  :LEFTBRACKET => 13,
+  :RIGHTBRACKET => 14,
+  :PERIOD => 15,
+  :EPLUS => 16,
+  :EMINUS => 17 }
+
+racc_nt_base = 18
+
+racc_use_result_var = true
+
+Racc_arg = [
+  racc_action_table,
+  racc_action_check,
+  racc_action_default,
+  racc_action_pointer,
+  racc_goto_table,
+  racc_goto_check,
+  racc_goto_default,
+  racc_goto_pointer,
+  racc_nt_base,
+  racc_reduce_table,
+  racc_token_table,
+  racc_shift_n,
+  racc_reduce_n,
+  racc_use_result_var ]
+
+Racc_token_to_s_table = [
+  "$end",
+  "error",
+  "BOOL",
+  "FLOAT",
+  "NUMBER",
+  "COMMA",
+  "COMMAEND",
+  "IDENTIFIER",
+  "EQUAL",
+  "STRING",
+  "MINUS",
+  "LEFTBRACE",
+  "RIGHTBRACE",
+  "LEFTBRACKET",
+  "RIGHTBRACKET",
+  "PERIOD",
+  "EPLUS",
+  "EMINUS",
+  "$start",
+  "target",
+  "top",
+  "objectlist",
+  "objectitem",
+  "object",
+  "objectkey",
+  "number",
+  "list",
+  "block",
+  "block_id",
+  "listitems",
+  "listitem" ]
+
+Racc_debug_parser = false
+
+##### State transition tables end #####
+
+# reduce 0 omitted
+
+module_eval(<<'.,.,', 'parse.y', 19)
+  def _reduce_1(val, _values, result)
+     @result = flatten_objectlist(val[0])
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parse.y', 22)
+  def _reduce_2(val, _values, result)
+     result = val[0] 
+    result
+  end
+.,.,
+
+# reduce 3 omitted
+
+module_eval(<<'.,.,', 'parse.y', 29)
+  def _reduce_4(val, _values, result)
+     result = [val[0]] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parse.y', 31)
+  def _reduce_5(val, _values, result)
+     result = [val[0]] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parse.y', 33)
+  def _reduce_6(val, _values, result)
+     result = val[0] << val[1]  
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parse.y', 35)
+  def _reduce_7(val, _values, result)
+     result = val[0] << val[1]  
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parse.y', 40)
+  def _reduce_8(val, _values, result)
+     result = flatten_objectlist(val[1]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parse.y', 42)
+  def _reduce_9(val, _values, result)
+     return 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parse.y', 47)
+  def _reduce_10(val, _values, result)
+     result = val[0] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parse.y', 49)
+  def _reduce_11(val, _values, result)
+     result = val[0] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parse.y', 54)
+  def _reduce_12(val, _values, result)
+     result = val[0], val[2] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parse.y', 56)
+  def _reduce_13(val, _values, result)
+     result = val[0], val[2] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parse.y', 58)
+  def _reduce_14(val, _values, result)
+     result = val[0], val[2] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parse.y', 60)
+  def _reduce_15(val, _values, result)
+     result = val[0], val[2] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parse.y', 62)
+  def _reduce_16(val, _values, result)
+     result = val[0], val[2] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parse.y', 64)
+  def _reduce_17(val, _values, result)
+     result = val[0] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parse.y', 69)
+  def _reduce_18(val, _values, result)
+     result = val[0], val[1] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parse.y', 71)
+  def _reduce_19(val, _values, result)
+     result = val[0], {val[1][0] => val[1][1]} 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parse.y', 76)
+  def _reduce_20(val, _values, result)
+     result = val[0] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parse.y', 78)
+  def _reduce_21(val, _values, result)
+     result = val[0] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parse.y', 83)
+  def _reduce_22(val, _values, result)
+     result = val[1] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parse.y', 85)
+  def _reduce_23(val, _values, result)
+     return 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parse.y', 90)
+  def _reduce_24(val, _values, result)
+     result = [val[0]] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parse.y', 92)
+  def _reduce_25(val, _values, result)
+     result = val[0] << val[2] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parse.y', 94)
+  def _reduce_26(val, _values, result)
+     result = val[0] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parse.y', 99)
+  def _reduce_27(val, _values, result)
+     result = val[0] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parse.y', 101)
+  def _reduce_28(val, _values, result)
+     result = val[0] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parse.y', 103)
+  def _reduce_29(val, _values, result)
+     result = val[0] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parse.y', 105)
+  def _reduce_30(val, _values, result)
+     result = val[0] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parse.y', 110)
+  def _reduce_31(val, _values, result)
+     result = val[0] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parse.y', 112)
+  def _reduce_32(val, _values, result)
+     result = val[0] 
+    result
+  end
+.,.,
+
+def _reduce_none(val, _values, result)
+  val[0]
+end
+
+end   # class HCLParser

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hcl-checker
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.4.0
 platform: ruby
 authors:
 - Marcelo Castellani
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-18 00:00:00.000000000 Z
+date: 2020-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.4.14
+        version: 1.5.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.4.14
+        version: 1.5.0
 - !ruby/object:Gem::Dependency
   name: rex
   requirement: !ruby/object:Gem::Requirement
@@ -96,7 +96,7 @@ dependencies:
         version: 1.0.7
 description: Hashicorp Configuration Language parser and checker for Ruby
 email:
-- marcelofc.rock@gmail.com
+- marcelo@linux.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -119,11 +119,38 @@ files:
 - lib/hcl/checker/version.rb
 - lib/hcl/lexer.rb
 - lib/hcl/parser.rb
+- lib/hcl1/checker.rb
+- lib/hcl1/checker/version.rb
+- lib/hcl1/lexer.rb
+- lib/hcl1/parser.rb
 homepage: https://github.com/mfcastellani/hcl-checker
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message: |2
+
+  Hello, I am updating this Gem to support version 2.0 of the HCL.
+
+  In the meantime, it is important that you know that there will be a
+  compatibility break with the current version, for Gem to support both
+  versions.
+
+  Therefore, instead of using just HCL::Checker you must tell which
+  version you are using, like this:
+
+  HCL1::Checker
+
+  Or
+
+  HCL2::Checker
+
+  At the moment both HCL::Checker and HCL1::Checker will work, but with
+  the release of support for version 2 the HCL::Checker syntax will no
+  longer work.
+
+  So, update your code.
+
+  Thank you :)
 rdoc_options: []
 require_paths:
 - lib
@@ -138,7 +165,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.1
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Hashicorp Configuration Language parser for Ruby