hcl-checker 1.6.2 → 2.0.0

data/assets/parse.y

@@ -1,5 +1,6 @@
 class HCL::Checker::Parser
 token BOOL
+      NULL
       FLOAT
       NUMBER
       COMMA
@@ -8,6 +9,25 @@ token BOOL
       EQUAL
       STRING
       MINUS
+      PLUS
+      STAR
+      SLASH
+      PERCENT
+      ANDAND
+      OROR
+      EQEQ
+      NEQ
+      LT
+      GT
+      LE
+      GE
+      BANG
+      QUESTION
+      COLON
+      ARROW
+      FOR
+      IN
+      IF
       LEFTBRACE
       RIGHTBRACE
       LEFTBRACKET
@@ -18,6 +38,18 @@ token BOOL
       EPLUS
       EMINUS
 
+prechigh
+  nonassoc UMINUS
+  right    BANG
+  left     STAR SLASH PERCENT
+  left     PLUS MINUS
+  nonassoc LT GT LE GE
+  nonassoc EQEQ NEQ
+  left     ANDAND
+  left     OROR
+  right    QUESTION COLON
+preclow
+
 rule
   target: top { @result = flatten_objectlist(val[0])}
 
@@ -42,6 +74,15 @@ rule
        { result = flatten_objectlist(val[1]) }
   |  LEFTBRACE RIGHTBRACE
        { return {} }
+  |  LEFTBRACE forobjectexpr RIGHTBRACE
+       { result = val[1] }
+  ;
+
+  forobjectexpr:
+     FOR foriter COLON expr ARROW expr
+       { result = "for #{val[1]} : #{render(val[3])} => #{render(val[5])}" }
+  |  FOR foriter COLON expr ARROW expr IF expr
+       { result = "for #{val[1]} : #{render(val[3])} => #{render(val[5])} if #{render(val[7])}" }
   ;
 
   objectkey:
@@ -49,27 +90,103 @@ rule
        { result = val[0] }
   |  STRING
        { result = val[0] }
+  |  FOR
+       { result = val[0] }
+  |  IN
+       { result = val[0] }
+  |  IF
+       { result = val[0] }
+  |  NULL
+       { result = val[0] }
   ;
 
   objectitem:
-     objectkey EQUAL number
-       { result = val[0], val[2] }
-  |  objectkey EQUAL BOOL
-       { result = val[0], val[2] }
-  |  objectkey EQUAL STRING
-       { result = val[0], val[2] }
-  |  objectkey EQUAL object
-       { result = val[0], val[2] }
-  |  objectkey EQUAL list
-       { result = val[0], val[2] }
-  |  objectkey EQUAL IDENTIFIER LEFTPARENTHESES IDENTIFIER RIGHTPARENTHESES
-       { result = val[0], "#{val[2]}(#{val[4]})" }
-  |  objectkey EQUAL IDENTIFIER
+     objectkey EQUAL expr
        { result = val[0], val[2] }
   |  block
        { result = val[0] }
   ;
 
+  expr:
+     primary
+       { result = val[0] }
+  |  expr PLUS expr
+       { result = "#{render(val[0])} + #{render(val[2])}" }
+  |  expr MINUS expr
+       { result = "#{render(val[0])} - #{render(val[2])}" }
+  |  expr STAR expr
+       { result = "#{render(val[0])} * #{render(val[2])}" }
+  |  expr SLASH expr
+       { result = "#{render(val[0])} / #{render(val[2])}" }
+  |  expr PERCENT expr
+       { result = "#{render(val[0])} % #{render(val[2])}" }
+  |  expr ANDAND expr
+       { result = "#{render(val[0])} && #{render(val[2])}" }
+  |  expr OROR expr
+       { result = "#{render(val[0])} || #{render(val[2])}" }
+  |  expr EQEQ expr
+       { result = "#{render(val[0])} == #{render(val[2])}" }
+  |  expr NEQ expr
+       { result = "#{render(val[0])} != #{render(val[2])}" }
+  |  expr LT expr
+       { result = "#{render(val[0])} < #{render(val[2])}" }
+  |  expr GT expr
+       { result = "#{render(val[0])} > #{render(val[2])}" }
+  |  expr LE expr
+       { result = "#{render(val[0])} <= #{render(val[2])}" }
+  |  expr GE expr
+       { result = "#{render(val[0])} >= #{render(val[2])}" }
+  |  expr QUESTION expr COLON expr
+       { result = "#{render(val[0])} ? #{render(val[2])} : #{render(val[4])}" }
+  |  BANG expr
+       { result = "!#{render(val[1])}" }
+  |  MINUS expr =UMINUS
+       { result = negate(val[1]) }
+  ;
+
+  primary:
+     traversal
+       { result = val[0] }
+  |  number
+       { result = val[0] }
+  |  BOOL
+       { result = val[0] }
+  |  NULL
+       { result = nil }
+  |  STRING
+       { result = val[0] }
+  |  list
+       { result = val[0] }
+  |  object
+       { result = val[0] }
+  |  LEFTPARENTHESES expr RIGHTPARENTHESES
+       { result = "(#{render(val[1])})" }
+  ;
+
+  traversal:
+     IDENTIFIER
+       { result = val[0] }
+  |  traversal PERIOD IDENTIFIER
+       { result = "#{val[0]}.#{val[2]}" }
+  |  traversal PERIOD STAR
+       { result = "#{val[0]}.*" }
+  |  traversal LEFTBRACKET expr RIGHTBRACKET
+       { result = "#{val[0]}[#{render(val[2])}]" }
+  |  traversal LEFTBRACKET STAR RIGHTBRACKET
+       { result = "#{val[0]}[*]" }
+  |  traversal LEFTPARENTHESES RIGHTPARENTHESES
+       { result = "#{val[0]}()" }
+  |  traversal LEFTPARENTHESES arglist RIGHTPARENTHESES
+       { result = "#{val[0]}(#{val[2].map { |a| render(a) }.join(', ')})" }
+  ;
+
+  arglist:
+     expr
+       { result = [val[0]] }
+  |  arglist COMMA expr
+       { result = val[0] << val[2] }
+  ;
+
   block:
      block_id object
        { result = val[0], val[1] }
@@ -82,6 +199,14 @@ rule
        { result = val[0] }
   |  STRING
        { result = val[0] }
+  |  FOR
+       { result = val[0] }
+  |  IN
+       { result = val[0] }
+  |  IF
+       { result = val[0] }
+  |  NULL
+       { result = val[0] }
   ;
 
   list:
@@ -89,6 +214,22 @@ rule
        { result = val[1] }
   |  LEFTBRACKET RIGHTBRACKET
        { return [] }
+  |  LEFTBRACKET forlistexpr RIGHTBRACKET
+       { result = val[1] }
+  ;
+
+  forlistexpr:
+     FOR foriter COLON expr
+       { result = "for #{val[1]} : #{render(val[3])}" }
+  |  FOR foriter COLON expr IF expr
+       { result = "for #{val[1]} : #{render(val[3])} if #{render(val[5])}" }
+  ;
+
+  foriter:
+     IDENTIFIER IN expr
+       { result = "#{val[0]} in #{render(val[2])}" }
+  |  IDENTIFIER COMMA IDENTIFIER IN expr
+       { result = "#{val[0]}, #{val[2]} in #{render(val[4])}" }
   ;
 
   listitems:
@@ -101,15 +242,7 @@ rule
   ;
 
   listitem:
-     number
-       { result = val[0] }
-  |  STRING
-       { result = val[0] }
-  | list
-       { result = val[0] }
-  | object
-       { result = val[0] }
-  | IDENTIFIER
+     expr
        { result = val[0] }
   ;
 
@@ -162,15 +295,21 @@ require_relative 'lexer'
 
 
   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
+    line, column = @current_position
+    message = "Parse error on line #{line}, column #{column}: unexpected #{error_value.inspect}"
+    message += " (after #{value_stack.last.inspect})" unless value_stack.empty?
+
+    raise Racc::ParseError, message
   end
 
 
   def parse(input, duplicate_mode = :array)
     @duplicate_mode = duplicate_mode
-    @lexer = HCL::Checker::Lexer.new.lex(input)
+
+    lexer = HCL::Checker::Lexer.new
+    @lexer = lexer.lex(input)
+    @lexer_positions = lexer.token_positions
+
     do_parse
 
     @result
@@ -178,9 +317,18 @@ require_relative 'lexer'
 
 
   def next_token
+    @current_position = @lexer_positions.shift
     @lexer.shift
   end
 
+  def negate(value)
+    value.is_a?(Numeric) ? -value : "-#{render(value)}"
+  end
+
+  def render(value)
+    value.nil? ? 'null' : value.to_s
+  end
+
   def deep_merge(hash1, hash2)
     hash2.keys.each do |key|
       value1 = hash1[key]

data/bin/setup

@@ -3,6 +3,12 @@ set -euo pipefail
 IFS=$'\n\t'
 set -vx
 
+# Installs gems into ./vendor/bundle instead of the system gem directory.
+# On a Ruby installed via a distro package (e.g. apt's ruby3.3), the system
+# gem directory is usually root-owned, so a plain `bundle install` fails
+# with a Bundler::PermissionError unless this repo is configured to use a
+# local, writable path instead.
+bundle config set --local path 'vendor/bundle'
 bundle install
 
 # Do any other automated setup that you need to do here

data/hcl-checker.gemspec

@@ -17,21 +17,11 @@ Gem::Specification.new do |spec|
     f.match(%r{^(test|spec|features)/})
   end
   spec.require_paths = ['lib']
-  spec.required_ruby_version = '>= 2.5.0'
+  spec.required_ruby_version = '>= 3.3'
 
-  spec.add_development_dependency 'bundler', '~> 2.3.13'
-  spec.add_development_dependency 'racc', '1.5.0'
-  spec.add_development_dependency 'rake', '~> 12.3.3'
-  spec.add_development_dependency 'rex', '2.0.12'
-  spec.add_development_dependency 'rexical', '>= 1.0.7'
+  spec.add_development_dependency 'bundler', '~> 2.4'
+  spec.add_development_dependency 'racc', '~> 1.8'
+  spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'rexical', '>= 1.0.8'
   spec.add_development_dependency 'rspec', '~> 3.0'
-
-  spec.post_install_message = '
-Hello, me again. This version fixes:
-
-- Update dependencies due security issues
-- Support interpolation only expression list
-
-Thank you :)
-'
 end

data/lib/hcl/checker/lexer.rb

@@ -1,6 +1,6 @@
 #--
 # DO NOT MODIFY!!!!
-# This file is automatically generated by rex 1.0.7
+# This file is automatically generated by rex 1.0.8
 # from lexical definition file "./assets/lexer.rex".
 #++
 
@@ -71,17 +71,29 @@ class HCL::Checker::Lexer
                   when (text = @ss.scan(/true|false/))
                      action { [:BOOL,         to_boolean(text)]}
 
-                  when (text = @ss.scan(/\-?\d+\.\d+/))
+                  when (text = @ss.scan(/null(?![a-zA-Z0-9_\-])/))
+                     action { [:NULL,         text]}
+
+                  when (text = @ss.scan(/for(?![a-zA-Z0-9_\-])/))
+                     action { [:FOR,          text]}
+
+                  when (text = @ss.scan(/in(?![a-zA-Z0-9_\-])/))
+                     action { [:IN,           text]}
+
+                  when (text = @ss.scan(/if(?![a-zA-Z0-9_\-])/))
+                     action { [:IF,           text]}
+
+                  when (text = @ss.scan(/\d+(\.\d+)?[eE][-+]?\d+|\d+\.\d+/))
                      action { [:FLOAT,        text.to_f] }
 
-                  when (text = @ss.scan(/-?\d+/))
+                  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] }
+                     action { [:STRING,       consume_heredoc(text.end_with?('-'))] }
 
                   when (text = @ss.scan(/\{/))
                      action { [:LEFTBRACE,        text]}
@@ -104,15 +116,66 @@ class HCL::Checker::Lexer
                   when (text = @ss.scan(/\,/))
                      action { [:COMMA,        text]}
 
-                  when (text = @ss.scan(/[a-zA-Z_][a-zA-Z0-9_\-\.]*/))
+                  when (text = @ss.scan(/[a-zA-Z_][a-zA-Z0-9_\-]*/))
                      action { [:IDENTIFIER,   text]}
 
+                  when (text = @ss.scan(/\=\=/))
+                     action { [:EQEQ,         text]}
+
+                  when (text = @ss.scan(/\!\=/))
+                     action { [:NEQ,          text]}
+
+                  when (text = @ss.scan(/\<\=/))
+                     action { [:LE,           text]}
+
+                  when (text = @ss.scan(/\>\=/))
+                     action { [:GE,           text]}
+
+                  when (text = @ss.scan(/\=\>/))
+                     action { [:ARROW,        text]}
+
+                  when (text = @ss.scan(/\</))
+                     action { [:LT,           text]}
+
+                  when (text = @ss.scan(/\>/))
+                     action { [:GT,           text]}
+
                   when (text = @ss.scan(/\=/))
                      action { [:EQUAL,        text]}
 
                   when (text = @ss.scan(/\-/))
                      action { [:MINUS,        text]}
 
+                  when (text = @ss.scan(/\+/))
+                     action { [:PLUS,         text]}
+
+                  when (text = @ss.scan(/\*/))
+                     action { [:STAR,         text]}
+
+                  when (text = @ss.scan(/\//))
+                     action { [:SLASH,        text]}
+
+                  when (text = @ss.scan(/\%/))
+                     action { [:PERCENT,      text]}
+
+                  when (text = @ss.scan(/\&\&/))
+                     action { [:ANDAND,       text]}
+
+                  when (text = @ss.scan(/\|\|/))
+                     action { [:OROR,         text]}
+
+                  when (text = @ss.scan(/\?/))
+                     action { [:QUESTION,     text]}
+
+                  when (text = @ss.scan(/\:/))
+                     action { [:COLON,        text]}
+
+                  when (text = @ss.scan(/\./))
+                     action { [:PERIOD,       text]}
+
+                  when (text = @ss.scan(/\!/))
+                     action { [:BANG,         text]}
+
           
           else
             text = @ss.string[@ss.pos .. -1]
@@ -125,34 +188,36 @@ class HCL::Checker::Lexer
           token
         end  # def _next_token
 
+  attr_reader :token_positions
   def lex(input)
     scan_setup(input)
     tokens = []
+    @token_positions = []
     while token = next_token
       tokens << token
+      @token_positions << current_position
     end
     tokens
   end
+  def current_position
+    consumed = @ss.string[0...@ss.pos]
+    line = consumed.count("\n") + 1
+    column = consumed.length - (consumed.rindex("\n") || -1)
+    [line, column]
+  end
   def to_boolean(input)
-    case input
-    when /true/
-      true
-    when /false/
-      false
-    else
-      raise "Invalid value for `to_boolean`, expected true/false got #{input}"
-    end
+    input == 'true'
   end
   def consume_comment(input)
     nested = 1
     until nested.zero?
       case(text = @ss.scan_until(%r{/\*|\*/|\z}) )
       when %r{/\*\z}
-        nested =+ 1
+        nested += 1
       when %r{\*/\z}
         nested -= 1
       else
-        break
+        raise ScanError, 'unterminated block comment'
       end
     end
   end
@@ -160,13 +225,17 @@ class HCL::Checker::Lexer
     result = ''
     nested = 0
     loop do
-      case(text = @ss.scan_until(%r{\"|\$\{|\}|\\}))
+      text = @ss.scan_until(%r{\"|\$\{|%\{|\}|\\})
+      raise ScanError, 'unterminated string' if text.nil?
+      case text
       when %r{\$\{\z}
         nested += 1
+      when %r{%\{\z}
+        nested += 1
       when %r{\}\z}
         nested -= 1 if nested.positive?
       when %r{\\\z}
-        result += text.chop + @ss.getch
+        result += text.chop + decode_escape
         next
       end
       result += text.to_s
@@ -174,9 +243,38 @@ class HCL::Checker::Lexer
     end
     result.chop
   end
-  def consume_heredoc
-      token = Regexp.new @ss.scan_until(%r{\n})
-      document = @ss.scan_until(token)
-      document.chop
+  def decode_escape
+    char = @ss.getch
+    case char
+    when 'n' then "\n"
+    when 't' then "\t"
+    when 'r' then "\r"
+    when '"' then '"'
+    when '\\' then '\\'
+    when 'u'
+      hex = @ss.scan(/[0-9a-fA-F]{4}/)
+      hex ? [hex.to_i(16)].pack('U') : 'u'
+    when 'U'
+      hex = @ss.scan(/[0-9a-fA-F]{8}/)
+      hex ? [hex.to_i(16)].pack('U') : 'U'
+    else
+      char.to_s
+    end
+  end
+  def consume_heredoc(indented)
+    marker_line = @ss.scan_until(%r{\n})
+    raise ScanError, 'unterminated heredoc: missing marker' if marker_line.nil?
+    marker = marker_line.strip
+    closing = /^[ \t]*#{Regexp.escape(marker)}[ \t]*(?:\n|\z)/
+    raw = @ss.scan_until(closing)
+    raise ScanError, "unterminated heredoc: missing closing marker '#{marker}'" if raw.nil?
+    content = raw.sub(closing, '')
+    indented ? dedent(content) : content
+  end
+  def dedent(text)
+    lines = text.split("\n", -1)
+    indents = lines.reject { |line| line.strip.empty? }.map { |line| line[/\A[ \t]*/].length }
+    indent = indents.min || 0
+    lines.map { |line| line.strip.empty? ? line : line[indent..] }.join("\n")
   end
 end # class