hcl-checker 1.0.6 → 1.4.0

data/lib/hcl/parser.rb

@@ -10,7 +10,7 @@ require_relative './lexer'
 
 class HCLParser < Racc::Parser
 
-module_eval(<<'...end parse.y/module_eval...', 'parse.y', 115)
+module_eval(<<'...end parse.y/module_eval...', 'parse.y', 123)
   #//
   #//       HCL is unclear on what one should do when duplicate
   #//       keys are encountered.
@@ -21,7 +21,7 @@ module_eval(<<'...end parse.y/module_eval...', 'parse.y', 115)
   #//       from object.go:  there is a flattened list structure
   #//
   def flatten_objectlist(list)
-    list.each_with_object({}) do |a, h|
+    (list || {}).each_with_object({}) do |a, h|
       h[a.first] =
         case a.last
         when Hash
@@ -69,45 +69,47 @@ module_eval(<<'...end parse.y/module_eval...', 'parse.y', 115)
 ##### State transition tables begin ###
 
 racc_action_table = [
-    20,    26,    25,    36,    26,    25,     5,    21,     6,    13,
-    33,    24,    35,    26,    25,    30,     5,    18,     6,    33,
-     5,    28,     6,    12,    16,    34,    17,     5,    13,     6,
-    -9,    -8,    10 ]
+    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 = [
-    12,    12,    12,    29,    24,    24,     0,    12,     0,    12,
-    24,    12,    29,    36,    36,    24,    13,    10,    13,    36,
-    27,    13,    27,     7,     9,    27,     9,     3,     9,     3,
-     6,     5,     1 ]
+    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,    32,   nil,    20,   nil,    23,    22,    15,   nil,    17,
-    17,   nil,    -2,     9,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,     1,   nil,   nil,    13,   nil,    -2,
-   nil,   nil,   nil,   nil,   nil,   nil,    10,   nil ]
+    -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,   -29,    -1,    -3,    -4,   -18,   -19,   -29,   -15,   -29,
-   -29,    -5,   -29,   -29,   -16,   -17,   -18,   -19,    38,   -10,
-   -11,   -12,   -13,   -14,   -29,   -27,   -28,   -29,    -7,   -29,
-   -21,   -22,   -25,   -26,    -6,   -20,   -24,   -23 ]
+    -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,    14,    31,    15,    22,    29,    19,     2,     1,
-    23,   nil,   nil,   nil,    27,    37,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,    11 ]
+    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,     5,    12,     9,     5,    11,     7,     2,     1,
-     8,   nil,   nil,   nil,     3,    12,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,     4 ]
+     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,     9,     8,     1,    -3,    -7,   nil,    -5,    -2,    -5,
-   nil,   -18,   -21 ]
+   nil,     4,     5,     1,    -3,    -6,   nil,    -7,    -5,     0,
+   nil,   -16,   -24 ]
 
 racc_goto_default = [
-   nil,   nil,   nil,   nil,     4,   nil,     7,    32,   nil,     8,
+   nil,   nil,   nil,   nil,     4,    37,     7,    34,    36,     8,
      9,   nil,   nil ]
 
 racc_reduce_table = [
@@ -115,35 +117,39 @@ racc_reduce_table = [
   1, 19, :_reduce_1,
   0, 20, :_reduce_2,
   1, 20, :_reduce_none,
-  1, 21, :_reduce_4,
-  2, 21, :_reduce_5,
-  3, 23, :_reduce_6,
-  2, 23, :_reduce_7,
-  1, 24, :_reduce_8,
-  1, 24, :_reduce_9,
-  3, 22, :_reduce_10,
-  3, 22, :_reduce_11,
+  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,
-  1, 22, :_reduce_15,
-  2, 27, :_reduce_16,
-  2, 27, :_reduce_17,
-  1, 28, :_reduce_18,
-  1, 28, :_reduce_19,
-  3, 26, :_reduce_20,
-  2, 26, :_reduce_21,
-  1, 29, :_reduce_22,
-  3, 29, :_reduce_23,
-  2, 29, :_reduce_24,
-  1, 30, :_reduce_25,
-  1, 30, :_reduce_26,
-  1, 25, :_reduce_27,
-  1, 25, :_reduce_28 ]
-
-racc_reduce_n = 29
-
-racc_shift_n = 38
+  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,
@@ -249,49 +255,49 @@ module_eval(<<'.,.,', 'parse.y', 29)
 
 module_eval(<<'.,.,', 'parse.y', 31)
   def _reduce_5(val, _values, result)
-     result = val[0] << val[1]  
+     result = [val[0]] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parse.y', 36)
+module_eval(<<'.,.,', 'parse.y', 33)
   def _reduce_6(val, _values, result)
-     result = flatten_objectlist(val[1]) 
+     result = val[0] << val[1]  
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parse.y', 38)
+module_eval(<<'.,.,', 'parse.y', 35)
   def _reduce_7(val, _values, result)
-     return 
+     result = val[0] << val[1]  
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parse.y', 43)
+module_eval(<<'.,.,', 'parse.y', 40)
   def _reduce_8(val, _values, result)
-     result = val[0] 
+     result = flatten_objectlist(val[1]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parse.y', 45)
+module_eval(<<'.,.,', 'parse.y', 42)
   def _reduce_9(val, _values, result)
-     result = val[0] 
+     return 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parse.y', 50)
+module_eval(<<'.,.,', 'parse.y', 47)
   def _reduce_10(val, _values, result)
-     result = val[0], val[2] 
+     result = val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parse.y', 52)
+module_eval(<<'.,.,', 'parse.y', 49)
   def _reduce_11(val, _values, result)
-     result = val[0], val[2] 
+     result = val[0] 
     result
   end
 .,.,
@@ -319,102 +325,130 @@ module_eval(<<'.,.,', 'parse.y', 58)
 
 module_eval(<<'.,.,', 'parse.y', 60)
   def _reduce_15(val, _values, result)
-     result = val[0] 
+     result = val[0], val[2] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parse.y', 65)
+module_eval(<<'.,.,', 'parse.y', 62)
   def _reduce_16(val, _values, result)
-     result = val[0], val[1] 
+     result = val[0], val[2] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parse.y', 67)
+module_eval(<<'.,.,', 'parse.y', 64)
   def _reduce_17(val, _values, result)
-     result = val[0], {val[1][0] => val[1][1]} 
+     result = val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parse.y', 72)
+module_eval(<<'.,.,', 'parse.y', 69)
   def _reduce_18(val, _values, result)
-     result = val[0] 
+     result = val[0], val[1] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parse.y', 74)
+module_eval(<<'.,.,', 'parse.y', 71)
   def _reduce_19(val, _values, result)
-     result = val[0] 
+     result = val[0], {val[1][0] => val[1][1]} 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parse.y', 79)
+module_eval(<<'.,.,', 'parse.y', 76)
   def _reduce_20(val, _values, result)
-     result = val[1] 
+     result = val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parse.y', 81)
+module_eval(<<'.,.,', 'parse.y', 78)
   def _reduce_21(val, _values, result)
-     return 
+     result = val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parse.y', 86)
+module_eval(<<'.,.,', 'parse.y', 83)
   def _reduce_22(val, _values, result)
-     result = [val[0]] 
+     result = val[1] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parse.y', 88)
+module_eval(<<'.,.,', 'parse.y', 85)
   def _reduce_23(val, _values, result)
-     result = val[0] << val[2] 
+     return 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'parse.y', 90)
   def _reduce_24(val, _values, result)
-     result = val[0] 
+     result = [val[0]] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parse.y', 95)
+module_eval(<<'.,.,', 'parse.y', 92)
   def _reduce_25(val, _values, result)
-     result = val[0] 
+     result = val[0] << val[2] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parse.y', 97)
+module_eval(<<'.,.,', 'parse.y', 94)
   def _reduce_26(val, _values, result)
      result = val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parse.y', 102)
+module_eval(<<'.,.,', 'parse.y', 99)
   def _reduce_27(val, _values, result)
      result = val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parse.y', 104)
+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

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