puppet-lint 2.3.6 → 2.5.0

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

@@ -0,0 +1,173 @@
+require 'strscan'
+
+class PuppetLint
+  class Lexer
+    # Document this
+    # TODO
+    class StringSlurper
+      class UnterminatedStringError < StandardError; end
+
+      attr_accessor :scanner
+      attr_accessor :results
+      attr_accessor :interp_stack
+
+      START_INTERP_PATTERN = %r{\$\{}
+      END_INTERP_PATTERN = %r{\}}
+      END_STRING_PATTERN = %r{(\A|[^\\])(\\\\)*"}
+      UNENC_VAR_PATTERN = %r{(\A|[^\\])\$(::)?(\w+(-\w+)*::)*\w+(-\w+)*}
+      ESC_DQUOTE_PATTERN = %r{\\+"}
+      LBRACE_PATTERN = %r{\{}
+
+      def initialize(string)
+        @scanner = StringScanner.new(string)
+        @results = []
+        @interp_stack = []
+        @segment = []
+      end
+
+      def parse
+        @segment_type = :STRING
+
+        until scanner.eos?
+          if scanner.match?(START_INTERP_PATTERN)
+            start_interp
+          elsif !interp_stack.empty? && scanner.match?(LBRACE_PATTERN)
+            read_char
+          elsif scanner.match?(END_INTERP_PATTERN)
+            end_interp
+          elsif unenclosed_variable?
+            unenclosed_variable
+          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
+        end
+
+        raise UnterminatedStringError if results.empty? && scanner.matched?
+
+        results
+      end
+
+      def unenclosed_variable?
+        interp_stack.empty? &&
+          scanner.match?(UNENC_VAR_PATTERN) &&
+          (@segment.last.nil? ? true : !@segment.last.end_with?('\\'))
+      end
+
+      def parse_heredoc(heredoc_tag)
+        heredoc_name = heredoc_tag[%r{\A"?(.+?)"?(:.+?)?#{PuppetLint::Lexer::WHITESPACE_RE}*(/.*)?\Z}, 1]
+        end_heredoc_pattern = %r{^\|?\s*-?\s*#{Regexp.escape(heredoc_name)}$}
+        interpolation = heredoc_tag.start_with?('"')
+
+        @segment_type = :HEREDOC
+
+        until scanner.eos?
+          if scanner.match?(end_heredoc_pattern)
+            end_heredoc(end_heredoc_pattern)
+            break if interp_stack.empty?
+          elsif interpolation && scanner.match?(START_INTERP_PATTERN)
+            start_interp
+          elsif interpolation && !interp_stack.empty? && scanner.match?(LBRACE_PATTERN)
+            read_char
+          elsif interpolation && unenclosed_variable?
+            unenclosed_variable
+          elsif interpolation && scanner.match?(END_INTERP_PATTERN)
+            end_interp
+          else
+            read_char
+          end
+        end
+
+        results
+      end
+
+      def read_char
+        @segment << scanner.getch
+
+        return if interp_stack.empty?
+
+        case @segment.last
+        when '{'
+          interp_stack.push(true)
+        when '}'
+          interp_stack.pop
+        end
+      end
+
+      # 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]
+          @segment = []
+        else
+          @segment << scanner.scan(START_INTERP_PATTERN)
+        end
+
+        interp_stack.push(true)
+      end
+
+      def end_interp
+        if interp_stack.empty?
+          @segment << scanner.scan(END_INTERP_PATTERN)
+          return
+        else
+          interp_stack.pop
+        end
+
+        if interp_stack.empty?
+          results << [:INTERP, @segment.join]
+          @segment = []
+          scanner.skip(END_INTERP_PATTERN)
+        else
+          @segment << scanner.scan(END_INTERP_PATTERN)
+        end
+      end
+
+      def unenclosed_variable
+        read_char if scanner.match?(%r{.\$})
+
+        results << [@segment_type, @segment.join]
+        results << [:UNENC_VAR, scanner.scan(UNENC_VAR_PATTERN)]
+        @segment = []
+      end
+
+      def end_heredoc(pattern)
+        results << [:HEREDOC, @segment.join]
+        results << [:HEREDOC_TERM, scanner.scan(pattern)]
+      end
+
+      def end_string
+        if interp_stack.empty?
+          @segment << scanner.scan(END_STRING_PATTERN).gsub!(%r{"\Z}, '')
+          results << [@segment_type, @segment.join]
+        else
+          @segment << scanner.scan(END_STRING_PATTERN)
+        end
+      end
+    end
+  end
+end

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

@@ -193,10 +193,18 @@ class PuppetLint
               token_iter = token_iter.send("#{direction}_token_of".to_sym, ["#{closing_token}PAREN".to_sym, opts])
             end
           end
+
+          return nil if token_iter.nil?
           token_iter = token_iter.send("#{direction}_token".to_sym)
         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/optparser.rb

@@ -18,7 +18,6 @@ class PuppetLint::OptParser
   #
   # Returns an OptionParser object.
   def self.build(args = [])
-    noconfig = false
     opt_parser = OptionParser.new do |opts|
       opts.banner = HELP_TEXT
 
@@ -27,7 +26,7 @@ class PuppetLint::OptParser
       end
 
       opts.on('--no-config', 'Do not load default puppet-lint option files.') do
-        noconfig = true
+        # nothing to do, option is handled differently
       end
 
       opts.on('-c', '--config FILE', 'Load puppet-lint options from file.') do |file|
@@ -134,9 +133,7 @@ class PuppetLint::OptParser
       end
     end
 
-    opt_parser.parse!(args) unless args.empty?
-
-    unless noconfig
+    unless args.include?('--no-config')
       opt_parser.load('/etc/puppet-lint.rc')
       if ENV.key?('HOME') && File.readable?(ENV['HOME'])
         home_dotfile_path = File.expand_path('~/.puppet-lint.rc')
@@ -145,6 +142,8 @@ class PuppetLint::OptParser
       opt_parser.load('.puppet-lint.rc')
     end
 
+    opt_parser.parse!(args) unless args.empty?
+
     opt_parser
   end
 end

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_conditionals/case_without_default.rb

@@ -31,7 +31,21 @@ PuppetLint.new_check(:case_without_default) do
         case_tokens -= tokens[successor_kase[:start]..successor_kase[:end]]
       end
 
-      next if case_tokens.index { |r| r.type == :DEFAULT }
+      found_matching_default = false
+      depth = 0
+
+      case_tokens.each do |token|
+        if token.type == :LBRACE
+          depth += 1
+        elsif token.type == :RBRACE
+          depth -= 1
+        elsif token.type == :DEFAULT && depth == 1
+          found_matching_default = true
+          break
+        end
+      end
+
+      next if found_matching_default
 
       notify(
         :warning,

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,12 +26,15 @@ 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')
+
+    raise PuppetLint::NoFix if ensure_param_name_token.nil?
+
     ensure_param_comma_token = ensure_param_name_token.next_token_of([:COMMA, :SEMIC])
 
-    if first_param_name_token.nil? || first_param_comma_token.nil? || ensure_param_name_token.nil? || ensure_param_comma_token.nil?
+    if first_param_name_token.nil? || first_param_comma_token.nil? || ensure_param_comma_token.nil?
       raise PuppetLint::NoFix
     end
 

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

@@ -25,3 +25,4 @@ PuppetLint.new_check(:quoted_booleans) do
     problem[:token].type = problem[:token].value.upcase.to_sym
   end
 end
+PuppetLint.configuration.send('disable_quoted_booleans')

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

@@ -1,9 +1,19 @@
+require 'set'
+require 'strscan'
+
 # Public: Check the manifest tokens for any variables in a string that have
 # not been enclosed by braces ({}) and record a warning for each instance
 # found.
 #
 # https://puppet.com/docs/puppet/latest/style_guide.html#quoting
 PuppetLint.new_check(:variables_not_enclosed) do
+  STRING_TOKEN_TYPES = Set[
+    :DQMID,
+    :DQPOST,
+    :HEREDOC_MID,
+    :HEREDOC_POST,
+  ]
+
   def check
     tokens.select { |r|
       r.type == :UNENC_VARIABLE
@@ -18,7 +28,68 @@ PuppetLint.new_check(:variables_not_enclosed) do
     end
   end
 
+  def hash_or_array_ref?(token)
+    token.next_token &&
+      STRING_TOKEN_TYPES.include?(token.next_token.type) &&
+      token.next_token.value.start_with?('[')
+  end
+
+  def extract_hash_or_array_ref(token)
+    scanner = StringScanner.new(token.value)
+
+    brack_depth = 0
+    result = { :ref => '' }
+
+    until scanner.eos?
+      result[:ref] += scanner.getch
+
+      # Pass a length of 1 when slicing the last character from the string
+      # to prevent Ruby 1.8 returning a Fixnum instead of a String.
+      case result[:ref][-1, 1]
+      when '['
+        brack_depth += 1
+      when ']'
+        brack_depth -= 1
+      end
+
+      break if brack_depth.zero? && scanner.peek(1) != '['
+    end
+
+    result[:remainder] = scanner.rest
+    result
+  end
+
+  def variable_contains_dash?(token)
+    token.value.include?('-')
+  end
+
+  def handle_variable_containing_dash(var_token)
+    str_token = var_token.next_token
+
+    var_name, text = var_token.value.split('-', 2)
+    var_token.value = var_name
+
+    return if str_token.nil?
+    str_token.value = "-#{text}#{str_token.value}"
+  end
+
   def fix(problem)
     problem[:token].type = :VARIABLE
+
+    if hash_or_array_ref?(problem[:token])
+      string_token = problem[:token].next_token
+      tokens_index = tokens.index(string_token)
+
+      hash_or_array_ref = extract_hash_or_array_ref(string_token)
+
+      ref_tokens = PuppetLint::Lexer.new.tokenise(hash_or_array_ref[:ref])
+      ref_tokens.each_with_index do |token, i|
+        add_token(tokens_index + i, token)
+      end
+
+      string_token.value = hash_or_array_ref[:remainder]
+    end
+
+    handle_variable_containing_dash(problem[:token]) if variable_contains_dash?(problem[:token])
   end
 end

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

@@ -51,7 +51,7 @@ PuppetLint.new_check(:arrow_alignment) do
             this_arrow_column = param_column[level_idx] + param_length + 1
           else
             this_arrow_column = param_token.column + param_token.to_manifest.length
-            this_arrow_column += 1 unless param_token.type == :DQPOST
+            this_arrow_column += 1
           end
 
           if arrow_column[level_idx] < this_arrow_column

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