puppet-lint 2.5.2 → 3.0.1

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

@@ -4,19 +4,24 @@
 #
 # https://puppet.com/docs/puppet/latest/style_guide.html#quoting
 PuppetLint.new_check(:double_quoted_strings) do
-  ESCAPE_CHAR_RE = %r{(\\\$|\\"|\\'|'|\r|\t|\\t|\\s|\n|\\n|\\\\)}
+  ESCAPE_CHAR_RE = %r{(\\\$|\\"|\\'|'|\r|\t|\\t|\\s|\n|\\n|\\\\)}.freeze
 
   def check
-    tokens.select { |token|
+    invalid_tokens = tokens.select do |token|
       token.type == :STRING &&
         token.value.gsub(' ' * token.column, "\n")[ESCAPE_CHAR_RE].nil?
-    }.each do |token|
+    end
+
+    invalid_tokens.each do |token|
       notify(
         :warning,
-        :message => 'double quoted string containing no variables',
-        :line    => token.line,
-        :column  => token.column,
-        :token   => token
+        message: 'double quoted string containing no variables',
+        line: token.line,
+        column: token.column,
+        token: token,
+        description: 'Check the manifest tokens for any double quoted strings that don\'t '\
+          'contain any variables or common escape characters and record a warning for each instance found.',
+        help_uri: 'https://puppet.com/docs/puppet/latest/style_guide.html#quoting',
       )
     end
   end

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

@@ -25,12 +25,14 @@ PuppetLint.new_check(:only_variable_string) do
             end
             notify(
               :warning,
-              :message     => 'string containing only a variable',
-              :line        => var_token.line,
-              :column      => var_token.column,
-              :start_token => start_token,
-              :var_token   => var_token,
-              :end_token   => eos_token
+              message: 'string containing only a variable',
+              line: var_token.line,
+              column: var_token.column,
+              start_token: start_token,
+              var_token: var_token,
+              end_token: eos_token,
+              description: 'Check the manifest tokens for double quoted strings that contain a single variable only and record a warning for each instance found.',
+              help_uri: 'https://puppet.com/docs/puppet/latest/style_guide.html#quoting',
             )
           end
           break

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

@@ -5,17 +5,23 @@
 # No style guide reference
 PuppetLint.new_check(:puppet_url_without_modules) do
   def check
-    tokens.select { |token|
+    puppet_urls = tokens.select do |token|
       (token.type == :SSTRING || token.type == :STRING || token.type == :DQPRE) && token.value.start_with?('puppet://')
-    }.reject { |token|
-      token.value[%r{puppet://.*?/(.+)}, 1].start_with?('modules/') unless token.value[%r{puppet://.*?/(.+)}, 1].nil?
-    }.each do |token|
+    end
+
+    invalid_urls = puppet_urls.reject do |token|
+      token.value[%r{puppet://.*?/(.+)}, 1]&.start_with?('modules/')
+    end
+
+    invalid_urls.each do |token|
       notify(
         :warning,
-        :message => 'puppet:// URL without modules/ found',
-        :line    => token.line,
-        :column  => token.column,
-        :token   => token
+        message: 'puppet:// URL without modules/ found',
+        line: token.line,
+        column: token.column,
+        token: token,
+        description: 'Check the manifest tokens for any puppet:// URL strings where the path section doesn\'t start with modules/ and record a warning for each instance found.',
+        help_uri: nil,
       )
     end
   end

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

@@ -8,15 +8,19 @@ PuppetLint.new_check(:quoted_booleans) do
   BOOLEANS = Set['true', 'false']
 
   def check
-    tokens.select { |r|
-      STRING_TYPES.include?(r.type) && BOOLEANS.include?(r.value)
-    }.each do |token|
+    invalid_tokens = tokens.select do |token|
+      STRING_TYPES.include?(token.type) && BOOLEANS.include?(token.value)
+    end
+
+    invalid_tokens.each do |token|
       notify(
         :warning,
-        :message => 'quoted boolean value found',
-        :line    => token.line,
-        :column  => token.column,
-        :token   => token
+        message: 'quoted boolean value found',
+        line: token.line,
+        column: token.column,
+        token: token,
+        description: 'Check the manifest tokens for any double or single quoted strings containing only a boolean value and record a warning for each instance found.',
+        help_uri: nil,
       )
     end
   end

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

@@ -4,14 +4,19 @@
 # https://puppet.com/docs/puppet/latest/style_guide.html#quoting
 PuppetLint.new_check(:single_quote_string_with_variables) do
   def check
-    tokens.select { |r|
-      r.type == :SSTRING && r.value.include?('${') && !r.prev_token.prev_token.value.match(%r{inline_(epp|template)})
-    }.each do |token|
+    invalid_tokens = tokens.select do |token|
+      token.type == :SSTRING && token.value.include?('${') && !token.prev_token.prev_token.value.match(%r{inline_(epp|template)})
+    end
+
+    invalid_tokens.each do |token|
       notify(
         :error,
-        :message => 'single quoted string containing a variable found',
-        :line    => token.line,
-        :column  => token.column
+        message: 'single quoted string containing a variable found',
+        line: token.line,
+        column: token.column,
+        description: 'Check the manifest tokens for any single quoted strings containing '\
+          'a enclosed variable and record an error for each instance found.',
+        help_uri: 'https://puppet.com/docs/puppet/latest/style_guide.html#quoting',
       )
     end
   end

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

@@ -15,15 +15,19 @@ PuppetLint.new_check(:variables_not_enclosed) do
   ]
 
   def check
-    tokens.select { |r|
-      r.type == :UNENC_VARIABLE
-    }.each do |token|
+    invalid_tokens = tokens.select do |token|
+      token.type == :UNENC_VARIABLE
+    end
+
+    invalid_tokens.each do |token|
       notify(
         :warning,
-        :message => 'variable not enclosed in {}',
-        :line    => token.line,
-        :column  => token.column,
-        :token   => token
+        message: 'variable not enclosed in {}',
+        line: token.line,
+        column: token.column,
+        token: token,
+        description: '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.',
+        help_uri: 'https://puppet.com/docs/puppet/latest/style_guide.html#quoting',
       )
     end
   end
@@ -38,7 +42,7 @@ PuppetLint.new_check(:variables_not_enclosed) do
     scanner = StringScanner.new(token.value)
 
     brack_depth = 0
-    result = { :ref => '' }
+    result = { ref: '' }
 
     until scanner.eos?
       result[:ref] += scanner.getch

data/lib/puppet-lint/plugins/check_variables/variable_contains_dash.rb

@@ -6,16 +6,20 @@ PuppetLint.new_check(:variable_contains_dash) do
   VARIABLE_DASH_TYPES = Set[:VARIABLE, :UNENC_VARIABLE]
 
   def check
-    tokens.select { |r|
-      VARIABLE_DASH_TYPES.include?(r.type)
-    }.each do |token|
-      next unless token.value.gsub(%r{\[.+?\]}, '') =~ %r{-}
+    invalid_tokens = tokens.select do |token|
+      VARIABLE_DASH_TYPES.include?(token.type)
+    end
+
+    invalid_tokens.each do |token|
+      next unless %r{-}.match?(token.value.gsub(%r{\[.+?\]}, ''))
 
       notify(
         :warning,
-        :message => 'variable contains a dash',
-        :line    => token.line,
-        :column  => token.column
+        message: 'variable contains a dash',
+        line: token.line,
+        column: token.column,
+        description: 'Test the manifest tokens for variables that contain a dash and record a warning for each instance found.',
+        help_uri: nil,
       )
     end
   end

data/lib/puppet-lint/plugins/check_variables/variable_is_lowercase.rb

@@ -6,16 +6,20 @@ PuppetLint.new_check(:variable_is_lowercase) do
   VARIABLE_LOWERCASE_TYPES = Set[:VARIABLE, :UNENC_VARIABLE]
 
   def check
-    tokens.select { |r|
-      VARIABLE_LOWERCASE_TYPES.include?(r.type)
-    }.each do |token|
-      next unless token.value.gsub(%r{\[.+?\]}, '') =~ %r{[A-Z]}
+    invalid_tokens = tokens.select do |token|
+      VARIABLE_LOWERCASE_TYPES.include?(token.type)
+    end
+
+    invalid_tokens.each do |token|
+      next unless %r{[A-Z]}.match?(token.value.gsub(%r{\[.+?\]}, ''))
 
       notify(
         :warning,
-        :message => 'variable contains an uppercase letter',
-        :line    => token.line,
-        :column  => token.column
+        message: 'variable contains an uppercase letter',
+        line: token.line,
+        column: token.column,
+        description: 'Test the manifest tokens for variables that contain an uppercase letter and record a warning for each instance found.',
+        help_uri: nil,
       )
     end
   end

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

@@ -7,15 +7,10 @@
 PuppetLint.new_check(:'140chars') do
   def check
     manifest_lines.each_with_index do |line, idx|
-      next if line =~ %r{://} || line =~ %r{template\(}
-      next unless line.scan(%r{.}mu).size > 140
+      result = PuppetLint::LineLengthCheck.check(idx + 1, line, 140)
 
-      notify(
-        :warning,
-        :message => 'line has more than 140 characters',
-        :line    => idx + 1,
-        :column  => 140
-      )
+      next if result.nil?
+      notify(*result)
     end
   end
 end

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

@@ -4,16 +4,18 @@
 # https://puppet.com/docs/puppet/latest/style_guide.html#spacing-indentation-and-whitespace
 PuppetLint.new_check(:'2sp_soft_tabs') do
   def check
-    tokens.select { |r|
-      r.type == :INDENT
-    }.reject { |r|
-      r.value.length.even?
-    }.each do |token|
+    indents = tokens.select { |token| token.type == :INDENT }
+
+    invalid_indents = indents.reject { |token| token.value.length.even? }
+
+    invalid_indents.each do |token|
       notify(
         :error,
-        :message => 'two-space soft tabs not used',
-        :line    => token.line,
-        :column  => token.column
+        message: 'two-space soft tabs not used',
+        line: token.line,
+        column: token.column,
+        description: 'Check the manifest tokens for any indentation not using 2 space soft tabs and record an error for each instance found.',
+        help_uri: 'https://puppet.com/docs/puppet/latest/style_guide.html#spacing-indentation-and-whitespace',
       )
     end
   end

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

@@ -6,15 +6,10 @@
 PuppetLint.new_check(:'80chars') do
   def check
     manifest_lines.each_with_index do |line, idx|
-      next if line =~ %r{://} || line =~ %r{template\(}
-      next unless line.scan(%r{.}mu).size > 80
+      result = PuppetLint::LineLengthCheck.check(idx + 1, line, 80)
 
-      notify(
-        :warning,
-        :message => 'line has more than 80 characters',
-        :line    => idx + 1,
-        :column  => 80
-      )
+      next if result.nil?
+      notify(*result)
     end
   end
 end

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

@@ -72,13 +72,15 @@ PuppetLint.new_check(:arrow_alignment) do
               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
+                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,
+                description: 'Check the manifest tokens for any arrows (=>) in a grouping ({}) that are not aligned with other arrows in that grouping.',
+                help_uri: 'https://puppet.com/docs/puppet/latest/style_guide.html#spacing-indentation-and-whitespace',
               )
             end
           end
@@ -104,7 +106,7 @@ PuppetLint.new_check(:arrow_alignment) do
 
       end_param_idx = tokens.index(problem[:token].prev_code_token)
       start_param_idx = tokens.index(problem[:token].prev_token_of([:INDENT, :NEWLINE]))
-      param_length = tokens[start_param_idx..end_param_idx].map { |r| r.to_manifest.length }.reduce(0) { |sum, x| sum + x } + 1
+      param_length = tokens[start_param_idx..end_param_idx].sum { |r| r.to_manifest.length } + 1
       new_ws_len = problem[:arrow_column] - param_length
     else
       new_ws_len = if problem[:token].prev_token.type == :WHITESPACE

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

@@ -6,15 +6,19 @@ PuppetLint.new_check(:hard_tabs) do
   WHITESPACE_TYPES = Set[:INDENT, :WHITESPACE]
 
   def check
-    tokens.select { |r|
-      WHITESPACE_TYPES.include?(r.type) && r.value.include?("\t")
-    }.each do |token|
+    invalid_tokens = tokens.select do |token|
+      WHITESPACE_TYPES.include?(token.type) && token.value.include?("\t")
+    end
+
+    invalid_tokens.each do |token|
       notify(
         :error,
-        :message => 'tab character found',
-        :line    => token.line,
-        :column  => token.column,
-        :token   => token
+        message: 'tab character found',
+        line: token.line,
+        column: token.column,
+        token: token,
+        description: 'Check the raw manifest string for lines containing hard tab characters and record an error for each instance found.',
+        help_uri: 'https://puppet.com/docs/puppet/latest/style_guide.html#spacing-indentation-and-whitespace',
       )
     end
   end

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

@@ -0,0 +1,29 @@
+# A utility class for checking the length of a given string.
+class PuppetLint::LineLengthCheck
+  # Check the current line to determine if it is more than character_count
+  # and record a warning if an instance is found. The only exceptions
+  # to this rule are lines containing URLs and template() calls which would hurt
+  # readability if split.
+  #
+  # @param line_number [Integer] The line number of the current line.
+  # @param content [String] The content of the current line.
+  # @param character_count [Integer] The maximum number of characters allowed
+  #
+  # @return problem [Array] An array containing a description of the problem.
+  # Can be passed directly to notify..
+  def self.check(line_number, content, character_count)
+    return if content.include? '://'
+    return if content.include? 'template('
+    return unless content.scan(%r{.}mu).size > character_count
+
+    [
+      :warning,
+      message: "line has more than #{character_count} characters",
+      line: line_number,
+      column: character_count,
+      description: 'Test the raw manifest string for lines containing more than #{character_count} characters and record a warning for each instance found. '\
+        'The only exceptions to this rule are lines containing URLs and template() calls which would hurt readability if split.',
+      help_uri: 'https://puppet.com/docs/puppet/latest/style_guide.html#spacing-indentation-and-whitespace',
+    ]
+  end
+end

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

@@ -4,17 +4,23 @@
 # https://puppet.com/docs/puppet/latest/style_guide.html#spacing-indentation-and-whitespace
 PuppetLint.new_check(:trailing_whitespace) do
   def check
-    tokens.select { |token|
+    whitespace = tokens.select do |token|
       [:WHITESPACE, :INDENT].include?(token.type)
-    }.select { |token|
+    end
+
+    whitespace_at_eol = whitespace.select do |token|
       token.next_token.nil? || token.next_token.type == :NEWLINE
-    }.each do |token|
+    end
+
+    whitespace_at_eol.each do |token|
       notify(
         :error,
-        :message => 'trailing whitespace found',
-        :line    => token.line,
-        :column  => token.column,
-        :token   => token
+        message: 'trailing whitespace found',
+        line: token.line,
+        column: token.column,
+        token: token,
+        description: 'Check the manifest tokens for lines ending with whitespace and record an error for each instance found.',
+        help_uri: 'https://puppet.com/docs/puppet/latest/style_guide.html#spacing-indentation-and-whitespace',
       )
     end
   end

data/lib/puppet-lint/plugins.rb

@@ -1,77 +1,76 @@
 require 'pathname'
 
-class PuppetLint
-  # Public: Various methods that implement puppet-lint's plugin system
+# Public: Various methods that implement puppet-lint's plugin system
+#
+# Examples
+#
+#   PuppetLint::Plugins.load_spec_helper
+class PuppetLint::Plugins
+  # Internal: Find any gems containing puppet-lint plugins and load them.
   #
-  # Examples
-  #
-  #   PuppetLint::Plugins.load_spec_helper
-  class Plugins
-    # Internal: Find any gems containing puppet-lint plugins and load them.
-    #
-    # Returns nothing.
-    def self.load_from_gems
-      gem_directories.select { |path|
-        (path + 'puppet-lint/plugins').directory?
-      }.each do |gem_path|
-        Dir["#{gem_path + 'puppet-lint/plugins'}/*.rb"].each do |file|
-          load(file)
-        end
+  # Returns nothing.
+  def self.load_from_gems
+    gem_directories.each do |directory|
+      path = directory + 'puppet-lint/plugins'
+      next unless path.directory?
+
+      Dir["#{path}/**/*.rb"].each do |file|
+        load(file)
       end
     end
+  end
 
-    # Public: Load the puppet-lint spec_helper.rb
-    #
-    # Returns nothings.
-    def self.load_spec_helper
-      gemspec = gemspecs.select { |spec| spec.name == 'puppet-lint' }.first
-      load(Pathname.new(gemspec.full_gem_path) + 'spec/spec_helper.rb')
-    end
+  # Public: Load the puppet-lint spec_helper.rb
+  #
+  # Returns nothings.
+  def self.load_spec_helper
+    gemspec = gemspecs.find { |spec| spec.name == 'puppet-lint' }
+    load(Pathname.new(gemspec.full_gem_path) + 'spec/spec_helper.rb')
+  end
 
-    class << self
-      private
+  class << self
+    private
 
-      # Internal: Check if RubyGems is loaded and available.
-      #
-      # Returns true if RubyGems is available, false if not.
-      def rubygems?
-        defined?(::Gem)
-      end
+    # Internal: Check if RubyGems is loaded and available.
+    #
+    # Returns true if RubyGems is available, false if not.
+    def rubygems?
+      defined?(::Gem)
+    end
 
-      # Internal: Retrieve a list of avaliable gemspecs.
-      #
-      # Returns an Array of Gem::Specification objects.
-      def gemspecs
-        @gemspecs ||= if Gem::Specification.respond_to?(:latest_specs)
-                        Gem::Specification.latest_specs(load_prerelease_plugins?)
-                      else
-                        Gem.searcher.init_gemspecs
-                      end
-      end
+    # Internal: Retrieve a list of avaliable gemspecs.
+    #
+    # Returns an Array of Gem::Specification objects.
+    def gemspecs
+      @gemspecs ||= if Gem::Specification.respond_to?(:latest_specs)
+                      Gem::Specification.latest_specs(load_prerelease_plugins?)
+                    else
+                      Gem.searcher.init_gemspecs
+                    end
+    end
 
-      # Internal: Determine whether to load plugins that contain a letter in their version number.
-      #
-      # Returns true if the configuration is set to load "prerelease" gems, false otherwise.
-      def load_prerelease_plugins?
-        # Load prerelease plugins (which ruby defines as any gem which has a letter in its version number).
-        # Can't use puppet-lint configuration object here because this code executes before the command line is parsed.
-        if ENV['PUPPET_LINT_LOAD_PRERELEASE_PLUGINS']
-          return %w[true yes].include?(ENV['PUPPET_LINT_LOAD_PRERELEASE_PLUGINS'].downcase)
-        end
-        false
+    # Internal: Determine whether to load plugins that contain a letter in their version number.
+    #
+    # Returns true if the configuration is set to load "prerelease" gems, false otherwise.
+    def load_prerelease_plugins?
+      # Load prerelease plugins (which ruby defines as any gem which has a letter in its version number).
+      # Can't use puppet-lint configuration object here because this code executes before the command line is parsed.
+      if ENV['PUPPET_LINT_LOAD_PRERELEASE_PLUGINS']
+        return ['true', 'yes'].include?(ENV['PUPPET_LINT_LOAD_PRERELEASE_PLUGINS'].downcase)
       end
+      false
+    end
 
-      # Internal: Retrieve a list of available gem paths from RubyGems.
-      #
-      # Returns an Array of Pathname objects.
-      def gem_directories
-        if rubygems?
-          gemspecs.reject { |spec| spec.name == 'puppet-lint' }.map do |spec|
-            Pathname.new(spec.full_gem_path) + 'lib'
-          end
-        else
-          []
+    # Internal: Retrieve a list of available gem paths from RubyGems.
+    #
+    # Returns an Array of Pathname objects.
+    def gem_directories
+      if rubygems?
+        gemspecs.reject { |spec| spec.name == 'puppet-lint' }.map do |spec|
+          Pathname.new(spec.full_gem_path) + 'lib'
         end
+      else
+        []
       end
     end
   end

data/lib/puppet-lint/report/github.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class PuppetLint::Report
+  # This formatter formats report data as GitHub Workflow commands resulting
+  # in GitHub check annotations when run within GitHub Actions.
+  class GitHubActionsReporter
+    ESCAPE_MAP = { '%' => '%25', "\n" => '%0A', "\r" => '%0D' }.freeze
+
+    def self.format_problem(file, problem)
+      "\n::#{problem[:kind]} file=#{file},line=#{problem[:line]},col=#{problem[:column]}::#{github_escape(problem[:message])} (check: #{problem[:check]})\n"
+    end
+
+    def self.github_escape(string)
+      string.gsub(Regexp.union(ESCAPE_MAP.keys), ESCAPE_MAP)
+    end
+  end
+end

data/lib/puppet-lint/report/sarif_template.json

@@ -0,0 +1,63 @@
+{
+  "$schema":"https://www.schemastore.org/schemas/json/sarif-2.1.0-rtm.5.json",
+  "version":"2.1.0",
+  "runs":[
+    {
+      "tool":{
+        "driver":{
+          "name":"Puppet Lint",
+          "informationUri":"https://github.com/puppetlabs/puppet-lint",
+          "version":"0.15.0",
+          "rules":[
+            {
+              "id":"",
+              "name":"",
+              "shortDescription":{
+                "text":""
+              },
+              "fullDescription":{
+                "text":""
+              },
+              "defaultConfiguration":{
+                "level":"warning"
+              },
+              "help":{
+                "text":""
+              }
+            }
+          ]
+        }
+      },
+      "results":[
+        {
+          "ruleId":"",
+          "ruleIndex":0,
+          "level":"error",
+          "message":{
+            "text":""
+          },
+          "locations":[
+            {
+              "physicalLocation":{
+                "artifactLocation":{
+                  "uri":"puppet-lint/spec/fixtures/test/manifests/fail.pp",
+                  "uriBaseId":"ROOTPATH"
+                },
+                "region":{
+                  "startLine":1,
+                  "startColumn":1
+                }
+              }
+            }
+          ]
+        }
+      ],
+      "columnKind":"utf16CodeUnits",
+      "originalUriBaseIds":{
+        "ROOTPATH":{
+          "uri":"file:///home/user/repos/"
+        }
+      }
+    }
+  ]
+}