puppet-lint 2.4.0 → 2.5.2

data/lib/puppet-lint/data.rb

@@ -171,21 +171,21 @@ class PuppetLint::Data
         tokens.select { |t| t.type == :COLON }.each do |colon_token|
           next unless colon_token.next_code_token && colon_token.next_code_token.type != :LBRACE
 
-          start_idx = tokens.index(colon_token)
-          next if start_idx < marker
+          rel_start_idx = tokens[marker..-1].index(colon_token)
+          break if rel_start_idx.nil?
+          start_idx = rel_start_idx + marker
           end_token = colon_token.next_token_of([:SEMIC, :RBRACE])
-          end_idx = tokens.index(end_token)
-
-          raise PuppetLint::SyntaxError, colon_token if end_idx.nil?
+          rel_end_idx = tokens[start_idx..-1].index(end_token)
+          raise PuppetLint::SyntaxError, colon_token if rel_end_idx.nil?
+          marker = rel_end_idx + start_idx
 
           result << {
             :start        => start_idx + 1,
-            :end          => end_idx,
-            :tokens       => tokens[start_idx..end_idx],
+            :end          => marker,
+            :tokens       => tokens[start_idx..marker],
             :type         => find_resource_type_token(start_idx),
-            :param_tokens => find_resource_param_tokens(tokens[start_idx..end_idx]),
+            :param_tokens => find_resource_param_tokens(tokens[start_idx..marker]),
           }
-          marker = end_idx
         end
         result
       end

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

@@ -37,11 +37,11 @@ class PuppetLint
             end_interp
           elsif unenclosed_variable?
             unenclosed_variable
-          elsif scanner.match?(ESC_DQUOTE_PATTERN)
-            @segment << scanner.scan(ESC_DQUOTE_PATTERN)
           elsif scanner.match?(END_STRING_PATTERN)
             end_string
             break if interp_stack.empty?
+          elsif scanner.match?(ESC_DQUOTE_PATTERN)
+            @segment << scanner.scan(ESC_DQUOTE_PATTERN)
           else
             read_char
           end
@@ -60,7 +60,7 @@ class PuppetLint
 
       def parse_heredoc(heredoc_tag)
         heredoc_name = heredoc_tag[%r{\A"?(.+?)"?(:.+?)?#{PuppetLint::Lexer::WHITESPACE_RE}*(/.*)?\Z}, 1]
-        end_heredoc_pattern = %r{\A\|?\s*-?\s*#{Regexp.escape(heredoc_name)}}
+        end_heredoc_pattern = %r{^\|?\s*-?\s*#{Regexp.escape(heredoc_name)}$}
         interpolation = heredoc_tag.start_with?('"')
 
         @segment_type = :HEREDOC
@@ -98,11 +98,27 @@ class PuppetLint
         end
       end
 
-      def consumed_bytes
-        scanner.pos
+      # Get the number of characters consumed by the StringSlurper.
+      #
+      # StringScanner from Ruby 2.0 onwards supports #charpos which returns
+      # the number of characters and is multibyte character aware.
+      #
+      # Prior to this, Ruby's multibyte character support in Strings was a
+      # bit unusual and neither String#length nor String#split behave as
+      # expected, so we use String#scan to split all the consumed text using
+      # a UTF-8 aware regex and use the length of the result
+      def consumed_chars
+        return scanner.charpos if scanner.respond_to?(:charpos)
+
+        (scanner.pre_match + scanner.matched).scan(%r{.}mu).length
       end
 
       def start_interp
+        if @segment.last && @segment.last == '\\'
+          read_char
+          return
+        end
+
         if interp_stack.empty?
           scanner.skip(START_INTERP_PATTERN)
           results << [@segment_type, @segment.join]

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

@@ -199,6 +199,12 @@ class PuppetLint
         end
         nil
       end
+
+      def interpolated_variable?
+        return false if type == :TYPE && value != 'type'
+        return true if type == :NAME
+        PuppetLint::Lexer::KEYWORDS.include?(type.to_s.downcase)
+      end
     end
   end
 end

data/lib/puppet-lint/lexer.rb

@@ -104,6 +104,7 @@ class PuppetLint
       :IF      => true,
       :ELSIF   => true,
       :LPAREN  => true,
+      :EQUALS  => true,
     }.freeze
 
     # Internal: some commonly used regular expressions
@@ -123,6 +124,8 @@ class PuppetLint
     # value of the token.
     KNOWN_TOKENS = [
       [:WHITESPACE, %r{\A(#{WHITESPACE_RE}+)}],
+      # FIXME: Future breaking change, the following :TYPE tokens conflict with
+      #        the :TYPE keyword token.
       [:TYPE, %r{\A(Integer|Float|Boolean|Regexp|String|Array|Hash|Resource|Class|Collection|Scalar|Numeric|CatalogEntry|Data|Tuple|Struct|Optional|NotUndef|Variant|Enum|Pattern|Any|Callable|Type|Runtime|Undef|Default|Sensitive)\b}], # rubocop:disable Metrics/LineLength
       [:CLASSREF, %r{\A(((::){0,1}[A-Z][-\w]*)+)}],
       [:NUMBER, %r{\A\b((?:0[xX][0-9A-Fa-f]+|0?\d+(?:\.\d+)?(?:[eE]-?\d+)?))\b}],
@@ -239,9 +242,9 @@ class PuppetLint
           begin
             string_segments = slurper.parse
             process_string_segments(string_segments)
-            length = slurper.consumed_bytes + 1
+            length = slurper.consumed_chars + 1
           rescue PuppetLint::Lexer::StringSlurper::UnterminatedStringError
-            raise PuppetLint::LexerError, @line_no, @column, 'unterminated string'
+            raise PuppetLint::LexerError.new(@line_no, @column, 'unterminated string')
           end
 
         elsif heredoc_name = chunk[%r{\A@\(("?.+?"?(:.+?)?#{WHITESPACE_RE}*(/.*?)?)\)}, 1]
@@ -286,13 +289,21 @@ class PuppetLint
             slurper = PuppetLint::Lexer::StringSlurper.new(code[i + length..-1])
             heredoc_segments = slurper.parse_heredoc(heredoc_tag)
             process_heredoc_segments(heredoc_segments)
-            length += slurper.consumed_bytes
+            length += slurper.consumed_chars
           end
 
         elsif eol = chunk[%r{\A(#{LINE_END_RE})}, 1]
           length = eol.size
           tokens << new_token(:NEWLINE, eol)
 
+          unless heredoc_queue.empty?
+            heredoc_tag = heredoc_queue.shift
+            slurper = PuppetLint::Lexer::StringSlurper.new(code[i + length..-1])
+            heredoc_segments = slurper.parse_heredoc(heredoc_tag)
+            process_heredoc_segments(heredoc_segments)
+            length += slurper.consumed_chars
+          end
+
         elsif chunk.start_with?('/')
           length = 1
           tokens << new_token(:DIV, '/')
@@ -408,7 +419,7 @@ class PuppetLint
           lexer = PuppetLint::Lexer.new
           lexer.tokenise(segment[1])
           lexer.tokens.each_with_index do |t, i|
-            type = i.zero? && t.type == :NAME ? :VARIABLE : t.type
+            type = i.zero? && t.interpolated_variable? ? :VARIABLE : t.type
             tokens << new_token(type, t.value, :raw => t.raw)
           end
         when :UNENC_VAR
@@ -440,7 +451,7 @@ class PuppetLint
           lexer = PuppetLint::Lexer.new
           lexer.tokenise(segment[1])
           lexer.tokens.each_with_index do |t, i|
-            type = i.zero? && t.type == :NAME ? :VARIABLE : t.type
+            type = i.zero? && t.interpolated_variable? ? :VARIABLE : t.type
             tokens << new_token(type, t.value, :raw => t.raw)
           end
         when :UNENC_VAR

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

@@ -22,6 +22,7 @@ PuppetLint.new_check(:parameter_order) do
         end
 
         next unless hash_or_array_stack.empty? && paren_stack.empty?
+        next unless parameter?(token)
         next unless required_parameter?(token)
 
         prev_tokens = class_idx[:param_tokens][0..i]
@@ -38,9 +39,19 @@ PuppetLint.new_check(:parameter_order) do
     end
   end
 
-  def required_parameter?(token)
+  def parameter?(token)
     return false unless token.type == :VARIABLE
+    return false unless token.prev_code_token
+
+    [
+      :LPAREN, # First parameter, no type specification
+      :COMMA,  # Subsequent parameter, no type specification
+      :TYPE,   # Parameter with simple type specification
+      :RBRACK, # Parameter with complex type specification
+    ].include?(token.prev_code_token.type)
+  end
 
+  def required_parameter?(token)
     data_type = token.prev_token_of(:TYPE, :skip_blocks => true)
     return false if data_type && data_type.value == 'Optional'
 

data/lib/puppet-lint/plugins/check_documentation/documentation.rb

@@ -30,8 +30,12 @@ PuppetLint.new_check(:documentation) do
   end
 
   def find_comment_token(start_token)
+    newlines = 0
+
     prev_token = start_token.prev_token
     while !prev_token.nil? && WHITESPACE_TOKENS.include?(prev_token.type)
+      newlines += 1 if prev_token.type == :NEWLINE
+      break if newlines > 1
       prev_token = prev_token.prev_token
     end
 

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

@@ -26,7 +26,7 @@ PuppetLint.new_check(:ensure_first_param) do
   end
 
   def fix(problem)
-    first_param_name_token = tokens[problem[:resource][:start]].next_token_of(:NAME)
+    first_param_name_token = problem[:resource][:param_tokens].first
     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')
 

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

@@ -4,7 +4,7 @@
 #
 # https://puppet.com/docs/puppet/latest/style_guide.html#quoting
 PuppetLint.new_check(:double_quoted_strings) do
-  ESCAPE_CHAR_RE = %r{(\\\$|\\"|\\'|'|\r|\t|\\t|\n|\\n|\\\\)}
+  ESCAPE_CHAR_RE = %r{(\\\$|\\"|\\'|'|\r|\t|\\t|\\s|\n|\\n|\\\\)}
 
   def check
     tokens.select { |token|

data/lib/puppet-lint/tasks/puppet-lint.rb

@@ -20,6 +20,7 @@ class PuppetLint
     attr_accessor :ignore_paths
     attr_accessor :with_filename
     attr_accessor :disable_checks
+    attr_accessor :only_checks
     attr_accessor :fail_on_warnings
     attr_accessor :error_level
     attr_accessor :log_format
@@ -40,6 +41,7 @@ class PuppetLint
       @pattern = DEFAULT_PATTERN
       @with_filename = true
       @disable_checks = []
+      @only_checks = []
       @ignore_paths = []
 
       define(args, &task_block)
@@ -55,6 +57,17 @@ class PuppetLint
       task @name do
         PuppetLint::OptParser.build
 
+        if Array(@only_checks).any?
+          enable_checks = Array(@only_checks).map(&:to_sym)
+          PuppetLint.configuration.checks.each do |check|
+            if enable_checks.include?(check)
+              PuppetLint.configuration.send("enable_#{check}")
+            else
+              PuppetLint.configuration.send("disable_#{check}")
+            end
+          end
+        end
+
         Array(@disable_checks).each do |check|
           PuppetLint.configuration.send("disable_#{check}")
         end
@@ -79,6 +92,7 @@ class PuppetLint
           matched_files = matched_files.exclude(*@ignore_paths)
 
           matched_files.to_a.each do |puppet_file|
+            next unless File.file?(puppet_file)
             linter.file = puppet_file
             linter.run
             linter.print_problems

data/lib/puppet-lint/tasks/release_test.rb

@@ -55,7 +55,9 @@ def with_puppet_lint_head
 end
 
 task :release_test do
-  branch = if ENV['APPVEYOR']
+  branch = if ENV['GITHUB_REF']
+             ENV['GITHUB_REF']
+           elsif ENV['APPVEYOR']
              ENV['APPVEYOR_PULL_REQUEST_HEAD_REPO_BRANCH']
            elsif ENV['TRAVIS']
              ENV['TRAVIS_PULL_REQUEST_BRANCH']

data/lib/puppet-lint/version.rb

@@ -1,3 +1,3 @@
 class PuppetLint
-  VERSION = '2.4.0'.freeze
+  VERSION = '2.5.2'.freeze
 end

data/lib/puppet-lint.rb

@@ -100,9 +100,9 @@ class PuppetLint
   # Returns a format String to be used with String#%.
   def log_format
     if configuration.log_format.nil? || configuration.log_format.empty?
-      ## recreate previous old log format as far as thats possible.
       format = '%{KIND}: %{message} on line %{line}'
       format.prepend('%{path} - ') if configuration.with_filename
+      format.concat(' (check: %{check})')
       configuration.log_format = format
     end
 

data/spec/puppet-lint/bin_spec.rb

@@ -91,8 +91,8 @@ describe PuppetLint::Bin do
     its(:stdout) do
       is_expected.to eq(
         [
-          "#{args[0]} - WARNING: optional parameter listed before required parameter on line 2",
-          "#{args[1]} - ERROR: test::foo not in autoload module layout on line 2",
+          "#{args[0]} - WARNING: optional parameter listed before required parameter on line 2 (check: parameter_order)",
+          "#{args[1]} - ERROR: test::foo not in autoload module layout on line 2 (check: autoloader_layout)",
         ].join("\n")
       )
     end
@@ -102,7 +102,7 @@ describe PuppetLint::Bin do
     let(:args) { 'spec/fixtures/test/manifests/malformed.pp' }
 
     its(:exitstatus) { is_expected.to eq(1) }
-    its(:stdout) { is_expected.to eq('ERROR: Syntax error on line 1') }
+    its(:stdout) { is_expected.to eq('ERROR: Syntax error on line 1 (check: syntax)') }
     its(:stderr) { is_expected.to eq('Try running `puppet parser validate <file>`') }
   end
 
@@ -198,7 +198,7 @@ describe PuppetLint::Bin do
     its(:stdout) do
       is_expected.to eq(
         [
-          'WARNING: optional parameter listed before required parameter on line 2',
+          'WARNING: optional parameter listed before required parameter on line 2 (check: parameter_order)',
           '',
           "  define test::warning($foo='bar', $baz) { }",
           '                                   ^',
@@ -432,7 +432,7 @@ describe PuppetLint::Bin do
     its(:stdout) do
       is_expected.to eq(
         [
-          'IGNORED: double quoted string containing no variables on line 3',
+          'IGNORED: double quoted string containing no variables on line 3 (check: double_quoted_strings)',
           '  for a good reason',
         ].join("\n")
       )
@@ -457,7 +457,7 @@ describe PuppetLint::Bin do
     end
 
     its(:exitstatus) { is_expected.to eq(0) }
-    its(:stdout) { is_expected.to match(%r{^.*line 6$}) }
+    its(:stdout) { is_expected.to match(%r{^.*line 6(?!\d)}) }
   end
 
   context 'when an lint:endignore control comment exists with no opening lint:ignore comment' do
@@ -548,7 +548,7 @@ describe PuppetLint::Bin do
 
         its(:exitstatus) { is_expected.to eq(0) }
         its(:stdout) do
-          is_expected.to eq('WARNING: variable contains a dash on line 3')
+          is_expected.to eq('WARNING: variable contains a dash on line 3 (check: variable_contains_dash)')
         end
       end
 
@@ -562,7 +562,7 @@ describe PuppetLint::Bin do
 
         its(:exitstatus) { is_expected.to eq(0) }
         its(:stdout) do
-          is_expected.to eq('WARNING: variable contains an uppercase letter on line 4')
+          is_expected.to eq('WARNING: variable contains an uppercase letter on line 4 (check: variable_is_lowercase)')
         end
       end
     end

data/spec/puppet-lint/lexer/string_slurper_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe PuppetLint::Lexer::StringSlurper do
@@ -36,14 +38,22 @@ describe PuppetLint::Lexer::StringSlurper do
           end
         end
 
-        context 'an escaped $' do
+        context 'an escaped $var' do
           let(:string) { '\$foo"' }
 
-          it 'does not create an interpolation segment' do
+          it 'does not create an unenclosed variable segment' do
             expect(segments).to eq([[:STRING, '\$foo']])
           end
         end
 
+        context 'an escaped ${} enclosure' do
+          let(:string) { '\"\${\"string\"}\""' }
+
+          it 'does not create an interpolation segment' do
+            expect(segments).to eq([[:STRING, '\"\${\"string\"}\"']])
+          end
+        end
+
         context 'a variable and a suffix' do
           let(:string) { '${foo}bar"' }
 
@@ -238,6 +248,30 @@ describe PuppetLint::Lexer::StringSlurper do
           end
         end
 
+        context 'a variable followed by an odd number of backslashes before a double quote' do
+          let(:string) { '${foo}\"bar"' }
+
+          it 'does not let this double quote terminate the string' do
+            expect(segments).to eq([
+              [:STRING, ''],
+              [:INTERP, 'foo'],
+              [:STRING, '\\"bar'],
+            ])
+          end
+        end
+
+        context 'a variable followed by an even number of backslashes before a double quote' do
+          let(:string) { '${foo}\\\\"bar"' }
+
+          it 'recognizes this double quote as the terminator' do
+            expect(segments).to eq([
+              [:STRING, ''],
+              [:INTERP, 'foo'],
+              [:STRING, '\\\\'],
+            ])
+          end
+        end
+
         context 'an interpolation with a complex function chain' do
           let(:string) { '${key} ${flatten([$value]).join("\nkey ")}"' }
 
@@ -284,6 +318,18 @@ describe PuppetLint::Lexer::StringSlurper do
   describe '#parse_heredoc' do
     subject(:segments) { described_class.new(heredoc).parse_heredoc(heredoc_tag) }
 
+    context 'when the heredoc text contains the tag' do
+      let(:heredoc) { %(  SOMETHING else\n  |-THING) }
+      let(:heredoc_tag) { 'THING' }
+
+      it 'terminates the heredoc at the closing tag' do
+        expect(segments).to eq([
+          [:HEREDOC, "  SOMETHING else\n  "],
+          [:HEREDOC_TERM, '|-THING'],
+        ])
+      end
+    end
+
     context 'when parsing a heredoc with interpolation disabled' do
       context 'that is a plain heredoc' do
         let(:heredoc) { %(  SOMETHING\n  ELSE\n  :\n  |-myheredoc) }
@@ -404,4 +450,24 @@ describe PuppetLint::Lexer::StringSlurper do
       end
     end
   end
+
+  describe '#consumed_chars' do
+    subject { described_class.new(string).tap(&:parse).consumed_chars }
+
+    context 'when slurping a string containing multibyte characters' do
+      let(:string) { 'accentués"' }
+
+      it 'counts the multibyte character as a single consumed character' do
+        is_expected.to eq(10)
+      end
+    end
+
+    context 'when slurping an empty string' do
+      let(:string) { '"' }
+
+      it 'consumes only the closing quote' do
+        is_expected.to eq(1)
+      end
+    end
+  end
 end