puppet-lint 2.1.1 → 2.2.0

data/lib/puppet-lint/lexer/token.rb

@@ -77,8 +77,13 @@ class PuppetLint
         when :DQPOST
           "#{@value}\""
         when :VARIABLE
-          if !@prev_code_token.nil? && [:DQPRE, :DQMID].include?(@prev_code_token.type)
-            "${#{@value}}"
+          enclose_token_types = Set[:DQPRE, :DQMID, :HEREDOC_PRE, :HEREDOC_MID].freeze
+          if !@prev_code_token.nil? && enclose_token_types.include?(@prev_code_token.type)
+            if @raw.nil?
+              "${#{@value}}"
+            else
+              "${#{@raw}}"
+            end
           else
             "$#{@value}"
           end
@@ -92,10 +97,90 @@ class PuppetLint
           "/#{@value}/"
         when :MLCOMMENT
           @raw
+        when :HEREDOC_OPEN
+          "@(#{@value})"
+        when :HEREDOC
+          @raw
+        when :HEREDOC_POST
+          @raw
         else
           @value
         end
       end
+
+      # Public: Search from this token to find the next token of a given type.
+      #
+      # type - A Symbol type of the token to find, or an Array of Symbols.
+      # opts - An optional Hash
+      #   :value       - A token value to search for in addition to type
+      #   :skip_blocks - A Boolean to specify whether { } blocks should be
+      #                  skipped over (defaults to true).
+      #
+      # Returns a PuppetLint::Lexer::Token object if a matching token could be
+      # found, otherwise nil.
+      def next_token_of(type, opts = {})
+        find_token_of(:next, type, opts)
+      end
+
+      # Public: Search from this token to find the previous token of a given type.
+      #
+      # type - A Symbol type of the token to find, or an Array of Symbols.
+      # opts - An optional Hash
+      #   :value       - A token value to search for in addition to type
+      #   :skip_blocks - A Boolean to specify whether { } blocks should be
+      #                  skipped over (defaults to true).
+      #
+      # Returns a PuppetLint::Lexer::Token object if a matching token could be
+      # found, otherwise nil.
+      def prev_token_of(type, opts = {})
+        find_token_of(:prev, type, opts)
+      end
+
+      # Internal: Search from this token to find the next token of a given type
+      # in a given direction.
+      #
+      # direction - A Symbol direction to search (:next or :prev).
+      # type      - A Symbol type of the token to find, or an Array of Symbols.
+      # opts      - An optional Hash
+      #   :value       - A token value to search for in addition to type
+      #   :skip_blocks - A Boolean to specify whether { } blocks should be
+      #                  skipped over (defaults to true).
+      #
+      # Returns a PuppetLint::Lexer::Token object if a matching token could be
+      # found, otherwise nil.
+      def find_token_of(direction, type, opts = {})
+        return nil unless [:next, :prev].include?(direction)
+
+        opts[:skip_blocks] ||= true
+        to_find = Array[*type]
+
+        token_iter = self.send("#{direction}_token".to_sym)
+        while !token_iter.nil?
+          if to_find.include? token_iter.type
+            if opts[:value]
+              return token_iter if token_iter.value == opts[:value]
+            else
+              return token_iter
+            end
+          end
+
+          opening_token = direction == :next ? "L" : "R"
+          closing_token = direction == :next ? "R" : "L"
+
+          if opts[:skip_blocks]
+            case token_iter.type
+            when "#{opening_token}BRACE".to_sym
+              token_iter = token_iter.send("#{direction}_token_of".to_sym, ["#{closing_token}BRACE".to_sym, opts])
+            when "#{opening_token}BRACK".to_sym
+              token_iter = token_iter.send("#{direction}_token_of".to_sym, ["#{closing_token}BRACK".to_sym, opts])
+            when "#{opening_token}PAREN".to_sym
+              token_iter = token_iter.send("#{direction}_token_of".to_sym, ["#{closing_token}PAREN".to_sym, opts])
+            end
+          end
+          token_iter = token_iter.send("#{direction}_token".to_sym)
+        end
+        nil
+      end
     end
   end
 end

data/lib/puppet-lint/plugins/check_classes.rb

@@ -14,6 +14,44 @@ PuppetLint.new_check(:right_to_left_relationship) do
   end
 end
 
+# Public: Test the manifest tokens for chaining arrow that is
+# on the line of the left operand when the right operand is on another line.
+#
+# https://docs.puppet.com/guides/style_guide.html#chaining-arrow-syntax
+PuppetLint.new_check(:arrow_on_right_operand_line) do
+  def check
+    tokens.select { |r| Set[:IN_EDGE, :IN_EDGE_SUB].include?(r.type) }.each do |token|
+      if token.next_code_token.line != token.line
+        notify :warning, {
+          :message =>  'arrow should be on the right operand\'s line',
+          :line    => token.line,
+          :column  => token.column,
+          :token   => token,
+        }
+      end
+    end
+  end
+
+  def fix(problem)
+    token = problem[:token]
+    tokens.delete(token)
+    # remove any excessive whitespace on the line
+    temp_token = token.prev_code_token
+    while (temp_token = temp_token.next_token)
+      tokens.delete(temp_token) if whitespace?(temp_token)
+      break if temp_token.type == :NEWLINE
+    end
+
+    index = tokens.index(token.next_code_token)
+    tokens.insert(index, token)
+    tokens.insert(index + 1, PuppetLint::Lexer::Token.new(:WHITESPACE, ' ', 0, 0))
+  end
+
+  def whitespace?(token)
+    Set[:INDENT, :WHITESPACE].include?(token.type)
+  end
+end
+
 # Public: Test the manifest tokens for any classes or defined types that are
 # not in an appropriately named file for the autoloader to detect and record
 # an error of each instance found.
@@ -295,7 +333,7 @@ PuppetLint.new_check(:variable_scope) do
 
       future_parser_scopes = {}
       in_pipe = false
-      temp_scope_vars = []
+      block_params_stack = []
 
       object_tokens.each do |token|
         case token.type
@@ -303,18 +341,28 @@ PuppetLint.new_check(:variable_scope) do
           if token.prev_code_token.type == :VARIABLE
             variables_in_scope << token.prev_code_token.value
           elsif token.prev_code_token.type == :RBRACK
-            temp_token = token.prev_code_token
+            temp_token = token
 
-            until temp_token.type == :LBRACK do
-              if temp_token.type == :VARIABLE
+            brack_depth = 0
+            while temp_token = temp_token.prev_code_token
+              case temp_token.type
+              when :VARIABLE
                 variables_in_scope << temp_token.value
+              when :RBRACK
+                brack_depth += 1
+              when :LBRACK
+                brack_depth -= 1
+                break if brack_depth == 0
+              when :COMMA
+                # ignore
+              else  # unexpected
+                break
               end
-              temp_token = temp_token.prev_code_token
             end
           end
         when :VARIABLE
           if in_pipe
-            temp_scope_vars << token.value
+            block_params_stack[-1] << token.value
           else
             referenced_variables << token
           end
@@ -322,7 +370,7 @@ PuppetLint.new_check(:variable_scope) do
           in_pipe = !in_pipe
 
           if in_pipe
-            temp_scope_vars = []
+            block_params_stack << []
           else
             start_idx = tokens.find_index(token)
             end_token = nil
@@ -341,7 +389,11 @@ PuppetLint.new_check(:variable_scope) do
               end
             end
 
-            future_parser_scopes.merge!(Hash[(token.line..end_token.line).to_a.map { |i| [i, temp_scope_vars] }])
+            params = block_params_stack.pop
+            (token.line..end_token.line).each do |line|
+              future_parser_scopes[line] ||= []
+              future_parser_scopes[line].concat(params)
+            end
           end
         end
       end

data/lib/puppet-lint/plugins/check_nodes.rb

@@ -8,6 +8,16 @@ PuppetLint.new_check(:unquoted_node_name) do
     node_tokens.each do |node|
       node_token_idx = tokens.index(node)
       node_lbrace_tok = tokens[node_token_idx..-1].find { |token| token.type == :LBRACE }
+      if node_lbrace_tok.nil?
+        notify :error, {
+          :check    => :syntax,
+          :message  => 'Syntax error (try running `puppet parser validate <file>`)',
+          :line     => node.line,
+          :column   => node.column,
+        }
+        next
+      end
+
       node_lbrace_idx = tokens.index(node_lbrace_tok)
 
       tokens[node_token_idx..node_lbrace_idx].select { |token|

data/lib/puppet-lint/plugins/check_resources.rb

@@ -47,43 +47,22 @@ PuppetLint.new_check(:ensure_first_param) do
       end
     end
   end
+
   def fix(problem)
-    # We find the first and ensure paramss boundaries
-    first_param_name_token = nil
-    first_param_name_idx = nil
-    first_param_comma_token = nil
-    first_param_comma_idx = nil
-    ensure_param_name_token = nil
-    ensure_param_name_idx = nil
-    ensure_param_comma_token = nil
-    ensure_param_comma_idx = nil
-    tokens[(problem[:resource][:start])..(problem[:resource][:end])].each_with_index do |token, token_idx|
-      if first_param_name_token.nil?
-        if token.type == :NAME
-          first_param_name_token = token
-          first_param_name_idx = problem[:resource][:start] + token_idx
-        end
-      elsif first_param_comma_token.nil?
-        if token.type == :COMMA
-          first_param_comma_token = token
-          first_param_comma_idx = problem[:resource][:start] + token_idx
-        end
-      elsif ensure_param_name_token.nil?
-        if token.type == :NAME and token.value == 'ensure'
-          ensure_param_name_token = token
-          ensure_param_name_idx = problem[:resource][:start] + token_idx
-        end
-      elsif ensure_param_comma_token.nil?
-        if token.type == :COMMA or token.type == :SEMIC
-          ensure_param_comma_token = token
-          ensure_param_comma_idx = problem[:resource][:start] + token_idx
-          break
-        end
-      end
-    end
+    first_param_name_token = tokens[problem[:resource][:start]].next_token_of(:NAME)
+    first_param_comma_token = first_param_name_token.next_token_of(:COMMA)
+    ensure_param_name_token = first_param_comma_token.next_token_of(:NAME, :value => 'ensure')
+    ensure_param_comma_token = ensure_param_name_token.next_token_of([:COMMA, :SEMIC])
+
     if first_param_name_token.nil? or first_param_comma_token.nil? or ensure_param_name_token.nil? or ensure_param_comma_token.nil?
       raise PuppetLint::NoFix
     end
+
+    first_param_name_idx = tokens.index(first_param_name_token)
+    first_param_comma_idx = tokens.index(first_param_comma_token)
+    ensure_param_name_idx = tokens.index(ensure_param_name_token)
+    ensure_param_comma_idx = tokens.index(ensure_param_comma_token)
+
     # Flip params
     prev_token = first_param_name_token.prev_token
     first_param_name_token.prev_token = ensure_param_name_token.prev_token
@@ -191,7 +170,7 @@ end
 PuppetLint.new_check(:file_mode) do
   MSG = 'mode should be represented as a 4 digit octal value or symbolic mode'
   SYM_RE = "([ugoa]*[-=+][-=+rstwxXugo]*)(,[ugoa]*[-=+][-=+rstwxXugo]*)*"
-  IGNORE_TYPES = Set[:VARIABLE, :UNDEF]
+  IGNORE_TYPES = Set[:VARIABLE, :UNDEF, :FUNCTION_NAME]
   MODE_RE = Regexp.new(/\A([0-7]{4}|#{SYM_RE})\Z/)
 
   def check

data/lib/puppet-lint/plugins/check_strings.rb

@@ -10,7 +10,7 @@ PuppetLint.new_check(:double_quoted_strings) do
     }.map { |token|
       [token, token.value.gsub(' '*token.column, "\n")]
     }.select { |token, sane_value|
-      sane_value[/(\\\$|\\"|\\'|'|\r|\t|\\t|\n|\\n)/].nil?
+      sane_value[/(\\\$|\\"|\\'|'|\r|\t|\\t|\n|\\n|\\\\)/].nil?
     }.each do |token, sane_value|
       notify :warning, {
         :message => 'double quoted string containing no variables',

data/lib/puppet-lint/plugins/check_whitespace.rb

@@ -125,8 +125,8 @@ PuppetLint.new_check(:arrow_alignment) do
 
   def check
     resource_indexes.each do |res_idx|
-      indent_depth = [0]
-      indent_depth_idx = 0
+      arrow_column = [0]
+      level_idx = 0
       level_tokens = []
       param_column = [nil]
       resource_tokens = res_idx[:tokens]
@@ -139,11 +139,11 @@ PuppetLint.new_check(:arrow_alignment) do
       last_arrow = resource_tokens.rindex { |r| r.type == :FARROW }
       next if first_arrow.nil?
       next if last_arrow.nil?
-      next unless resource_tokens[first_arrow..last_arrow].any? { |r| r.type == :NEWLINE }
+      next if resource_tokens[first_arrow].line == resource_tokens[last_arrow].line
 
       resource_tokens.each_with_index do |token, idx|
         if token.type == :FARROW
-          (level_tokens[indent_depth_idx] ||= []) << token
+          (level_tokens[level_idx] ||= []) << token
           param_token = token.prev_code_token
 
           if param_token.type == :DQPOST
@@ -158,63 +158,52 @@ PuppetLint.new_check(:arrow_alignment) do
             param_length = param_token.to_manifest.length
           end
 
-          if param_column[indent_depth_idx].nil?
+          if param_column[level_idx].nil?
             if param_token.type == :DQPOST
-              param_column[indent_depth_idx] = iter_token.column
+              param_column[level_idx] = iter_token.column
             else
-              param_column[indent_depth_idx] = param_token.column
+              param_column[level_idx] = param_token.column
             end
           end
 
-          indent_length = param_column[indent_depth_idx] + param_length + 1
+          this_arrow_column = param_column[level_idx] + param_length + 1
 
-          if indent_depth[indent_depth_idx] < indent_length
-            indent_depth[indent_depth_idx] = indent_length
+          if arrow_column[level_idx] < this_arrow_column
+            arrow_column[level_idx] = this_arrow_column
           end
 
         elsif token.type == :LBRACE
-          indent_depth_idx += 1
-          indent_depth << 0
-          level_tokens[indent_depth_idx] ||= []
+          level_idx += 1
+          arrow_column << 0
+          level_tokens[level_idx] ||= []
           param_column << nil
         elsif token.type == :RBRACE || token.type == :SEMIC
-          level_tokens[indent_depth_idx].each do |arrow_tok|
-            unless arrow_tok.column == indent_depth[indent_depth_idx] || level_tokens[indent_depth_idx].size == 1
-              arrows_on_line = level_tokens[indent_depth_idx].select { |t| t.line == arrow_tok.line }
-              notify :warning, {
-                :message        => "indentation of => is not properly aligned (expected in column #{indent_depth[indent_depth_idx]}, but found it in column #{arrow_tok.column})",
-                :line           => arrow_tok.line,
-                :column         => arrow_tok.column,
-                :token          => arrow_tok,
-                :indent_depth   => indent_depth[indent_depth_idx],
-                :newline        => !(arrows_on_line.index(arrow_tok) == 0),
-                :newline_indent => param_column[indent_depth_idx] - 1,
-              }
+          if level_tokens[level_idx].map(&:line).uniq.length > 1
+            level_tokens[level_idx].each do |arrow_tok|
+              unless arrow_tok.column == arrow_column[level_idx] || level_tokens[level_idx].size == 1
+                arrows_on_line = level_tokens[level_idx].select { |t| t.line == arrow_tok.line }
+                notify :warning, {
+                  :message        => "indentation of => is not properly aligned (expected in column #{arrow_column[level_idx]}, but found it in column #{arrow_tok.column})",
+                  :line           => arrow_tok.line,
+                  :column         => arrow_tok.column,
+                  :token          => arrow_tok,
+                  :arrow_column   => arrow_column[level_idx],
+                  :newline        => !(arrows_on_line.index(arrow_tok) == 0),
+                  :newline_indent => param_column[level_idx] - 1,
+                }
+              end
             end
           end
-          indent_depth[indent_depth_idx] = 0
-          level_tokens[indent_depth_idx].clear
-          indent_depth_idx -= 1
+          arrow_column[level_idx] = 0
+          level_tokens[level_idx].clear
+          param_column[level_idx] = nil
+          level_idx -= 1
         end
       end
     end
   end
 
   def fix(problem)
-    param_token = problem[:token].prev_code_token
-    if param_token.type == :DQPOST
-      param_length = 0
-      iter_token = param_token
-      while iter_token.type != :DQPRE do
-        param_length += iter_token.to_manifest.length
-        iter_token = iter_token.prev_token
-      end
-      param_length += iter_token.to_manifest.length
-    else
-      param_length = param_token.to_manifest.length
-    end
-    new_ws_len = (problem[:indent_depth] - (problem[:newline_indent] + param_length + 1))
-    new_ws = ' ' * new_ws_len
     if problem[:newline]
       index = tokens.index(problem[:token].prev_code_token.prev_token)
 
@@ -226,6 +215,12 @@ PuppetLint.new_check(:arrow_alignment) do
       problem[:token].prev_code_token.prev_token.value = ' ' * problem[:newline_indent]
     end
 
+    end_param_idx = tokens.index(problem[:token].prev_code_token)
+    start_param_idx = tokens.index(problem[:token].prev_token_of([:INDENT, :NEWLINE])) + 1
+    param_length = tokens[start_param_idx..end_param_idx].map { |r| r.to_manifest.length }.inject(0) { |sum,x| sum + x }
+    new_ws_len = (problem[:arrow_column] - (problem[:newline_indent] + param_length + 1))
+    new_ws = ' ' * new_ws_len
+
     if problem[:token].prev_token.type == :WHITESPACE
       problem[:token].prev_token.value = new_ws
     else

data/lib/puppet-lint/version.rb

@@ -1,3 +1,3 @@
 class PuppetLint
-  VERSION = '2.1.1'
+  VERSION = '2.2.0'
 end

data/spec/fixtures/test/manifests/unterminated_control_comment.pp

@@ -0,0 +1,5 @@
+jenkins::cli::exec { "create-jenkins-credentials-${title}":
+  # lint:ignore:140chars
+  unless  => "for i in \$(seq 1 ${::jenkins::cli_tries}); do \$HELPER_CMD credential_info ${title} && break || sleep ${::jenkins::cli_try_sleep}; done | grep ${title}",
+  # lint:end
+}