puppet-lint 2.3.0 → 2.3.1

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

@@ -73,17 +73,15 @@ class PuppetLint
         when :SSTRING
           "'#{@value}'"
         when :DQPRE
-          "\"#{@value}"
+          "\"#{@value}#{string_suffix}"
         when :DQPOST
-          "#{@value}\""
+          "#{string_prefix}#{@value}\""
+        when :DQMID
+          "#{string_prefix}#{@value}#{string_suffix}"
         when :VARIABLE
           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
+            @raw.nil? ? @value : @raw
           else
             "$#{@value}"
           end
@@ -101,13 +99,35 @@ class PuppetLint
           "@(#{@value})"
         when :HEREDOC
           @raw
+        when :HEREDOC_PRE
+          "#{@value}#{string_suffix}"
         when :HEREDOC_POST
-          @raw
+          "#{string_prefix}#{@raw}"
+        when :HEREDOC_MID
+          "#{string_prefix}#{@value}#{string_suffix}"
         else
           @value
         end
       end
 
+      def string_suffix
+        no_enclose_tokens = Set.new([:UNENC_VARIABLE, :DQMID, :DQPOST, :HEREDOC_MID, :HEREDOC_POST])
+        if next_token && no_enclose_tokens.include?(next_token.type)
+          ''
+        else
+          '${'
+        end
+      end
+
+      def string_prefix
+        no_enclose_tokens = Set.new([:UNENC_VARIABLE, :DQPRE, :DQMID, :HEREDOC_PRE, :HEREDOC_MID])
+        if prev_token && no_enclose_tokens.include?(prev_token.type)
+          ''
+        else
+          '}'
+        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.
@@ -154,18 +174,14 @@ class PuppetLint
         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
+        token_iter = send("#{direction}_token".to_sym)
+        until token_iter.nil?
+          if to_find.include?(token_iter.type)
+            return token_iter if opts[:value].nil? || token_iter.value == opts[:value]
           end
 
-          opening_token = direction == :next ? "L" : "R"
-          closing_token = direction == :next ? "R" : "L"
+          opening_token = direction == :next ? 'L' : 'R'
+          closing_token = direction == :next ? 'R' : 'L'
 
           if opts[:skip_blocks]
             case token_iter.type

data/lib/puppet-lint/optparser.rb

@@ -3,7 +3,7 @@ require 'optparse'
 # Public: Contains the puppet-lint option parser so that it can be used easily
 # in multiple places.
 class PuppetLint::OptParser
-  HELP_TEXT = <<-EOF
+  HELP_TEXT = <<-EOF.freeze
     puppet-lint
 
     Basic Command Line Usage:
@@ -41,8 +41,11 @@ class PuppetLint::OptParser
         PuppetLint.configuration.fail_on_warnings = true
       end
 
-      opts.on('--error-level LEVEL', [:all, :warning, :error],
-              'The level of error to return (warning, error or all).') do |el|
+      opts.on(
+        '--error-level LEVEL',
+        [:all, :warning, :error],
+        'The level of error to return (warning, error or all).',
+      ) do |el|
         PuppetLint.configuration.error_level = el
       end
 
@@ -55,13 +58,13 @@ class PuppetLint::OptParser
       end
 
       opts.on('-l', '--load FILE', 'Load a file containing custom puppet-lint checks.') do |f|
-        load f
+        load(f)
       end
 
       opts.on('--load-from-puppet MODULEPATH', 'Load plugins from the given Puppet module path.') do |path|
         path.split(':').each do |p|
           Dir["#{p}/*/lib/puppet-lint/plugins/*.rb"].each do |file|
-            load file
+            load(file)
           end
         end
       end
@@ -70,18 +73,19 @@ class PuppetLint::OptParser
         PuppetLint.configuration.fix = true
       end
 
-      opts.on('--log-format FORMAT',
-              'Change the log format.', 'Overrides --with-filename.',
-              'The following placeholders can be used:',
-              '%{filename} - Filename without path.',
-              '%{path}     - Path as provided to puppet-lint.',
-              '%{fullpath} - Expanded path to the file.',
-              '%{line}     - Line number.',
-              '%{column}   - Column number.',
-              '%{kind}     - The kind of message (warning, error).',
-              '%{KIND}     - Uppercase version of %{kind}.',
-              '%{check}    - The name of the check.',
-              '%{message}  - The message.'
+      opts.on(
+        '--log-format FORMAT',
+        'Change the log format.', 'Overrides --with-filename.',
+        'The following placeholders can be used:',
+        '%{filename} - Filename without path.',
+        '%{path}     - Path as provided to puppet-lint.',
+        '%{fullpath} - Expanded path to the file.',
+        '%{line}     - Line number.',
+        '%{column}   - Column number.',
+        '%{kind}     - The kind of message (warning, error).',
+        '%{KIND}     - Uppercase version of %{kind}.',
+        '%{check}    - The name of the check.',
+        '%{message}  - The message.'
       ) do |format|
         PuppetLint.configuration.log_format = format
       end
@@ -90,13 +94,13 @@ class PuppetLint::OptParser
         PuppetLint.configuration.json = true
       end
 
-      opts.separator ''
-      opts.separator '    Checks:'
+      opts.separator('')
+      opts.separator('    Checks:')
 
       opts.on('--only-checks CHECKS', 'A comma separated list of checks that should be run') do |checks|
         enable_checks = checks.split(',').map(&:to_sym)
-        (PuppetLint.configuration.checks).each do |check|
-          if enable_checks.include? check
+        PuppetLint.configuration.checks.each do |check|
+          if enable_checks.include?(check)
             PuppetLint.configuration.send("enable_#{check}")
           else
             PuppetLint.configuration.send("disable_#{check}")
@@ -108,19 +112,18 @@ class PuppetLint::OptParser
         opts.on("--no-#{check}-check", "Skip the #{check} check.") do
           PuppetLint.configuration.send("disable_#{check}")
         end
-        unless PuppetLint.configuration.send("#{check}_enabled?")
-          opts.on("--#{check}-check", "Enable the #{check} check.") do
-            PuppetLint.configuration.send("enable_#{check}")
-          end
+
+        next if PuppetLint.configuration.send("#{check}_enabled?")
+
+        opts.on("--#{check}-check", "Enable the #{check} check.") do
+          PuppetLint.configuration.send("enable_#{check}")
         end
       end
 
       opts.load('/etc/puppet-lint.rc')
-      begin
-        opts.load(File.expand_path('~/.puppet-lint.rc')) if ENV['HOME']
-      rescue Errno::EACCES
-        # silently skip loading this file if HOME is set to a directory that
-        # the user doesn't have read access to.
+      if ENV.key?('HOME') && File.readable?(ENV['HOME'])
+        home_dotfile_path = File.expand_path('~/.puppet-lint.rc')
+        opts.load(home_dotfile_path) if File.readable?(home_dotfile_path)
       end
       opts.load('.puppet-lint.rc')
     end

data/lib/puppet-lint/plugins.rb

@@ -14,8 +14,8 @@ class PuppetLint
       gem_directories.select { |path|
         (path + 'puppet-lint/plugins').directory?
       }.each do |gem_path|
-        Dir["#{(gem_path + 'puppet-lint/plugins').to_s}/*.rb"].each do |file|
-          load file
+        Dir["#{gem_path + 'puppet-lint/plugins'}/*.rb"].each do |file|
+          load(file)
         end
       end
     end
@@ -25,49 +25,53 @@ class PuppetLint
     # 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
-  private
-    # Internal: Check if RubyGems is loaded and available.
-    #
-    # Returns true if RubyGems is available, false if not.
-    def self.has_rubygems?
-      defined? ::Gem
+      load(Pathname.new(gemspec.full_gem_path) + 'spec/spec_helper.rb')
     end
 
-    # Internal: Retrieve a list of avaliable gemspecs.
-    #
-    # Returns an Array of Gem::Specification objects.
-    def self.gemspecs
-      @gemspecs ||= if Gem::Specification.respond_to?(:latest_specs)
-        Gem::Specification.latest_specs(load_prerelease_plugins?)
-      else
-        Gem.searcher.init_gemspecs
+    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
-    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 self.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)
+      # 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
-      false
-    end
 
-    # Internal: Retrieve a list of available gem paths from RubyGems.
-    #
-    # Returns an Array of Pathname objects.
-    def self.gem_directories
-      if has_rubygems?
-        gemspecs.reject { |spec| spec.name == 'puppet-lint' }.map do |spec|
-          Pathname.new(spec.full_gem_path) + 'lib'
+      # 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
+      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
+          []
         end
-      else
-        []
       end
     end
   end

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

@@ -5,42 +5,40 @@
 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
+      next 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
 
   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
+    prev_code_token = token.prev_code_token
+    next_code_token = token.next_code_token
+    indent_token = prev_code_token.prev_token_of(:INDENT)
 
-    temp_token.next_token = token
-    token.prev_token = temp_token
-    index = tokens.index(token.next_code_token)
-    tokens.insert(index, token)
+    # Delete all tokens between the two code tokens the anchor is between
+    temp_token = prev_code_token
+    while (temp_token = temp_token.next_token) && (temp_token != next_code_token)
+      remove_token(temp_token) unless temp_token == token
+    end
 
-    whitespace_token = PuppetLint::Lexer::Token.new(:WHITESPACE, ' ', temp_token.line + 1, 3)
-    whitespace_token.prev_token = token
-    token.next_token = whitespace_token
-    whitespace_token.next_token = tokens[index + 1]
-    tokens[index + 1].prev_token = whitespace_token
-    tokens.insert(index + 1, whitespace_token)
-  end
+    # Insert a newline and an indent before the arrow
+    index = tokens.index(token)
+    newline_token = PuppetLint::Lexer::Token.new(:NEWLINE, "\n", token.line, 0)
+    add_token(index, newline_token)
+    add_token(index + 1, indent_token) if indent_token
 
-  def whitespace?(token)
-    Set[:INDENT, :WHITESPACE].include?(token.type)
+    # Insert a space between the arrow and the following code token
+    index = tokens.index(token)
+    whitespace_token = PuppetLint::Lexer::Token.new(:WHITESPACE, ' ', token.line, 3)
+    add_token(index + 1, whitespace_token)
   end
 end

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

@@ -5,29 +5,30 @@
 # https://docs.puppet.com/guides/style_guide.html#separate-files
 PuppetLint.new_check(:autoloader_layout) do
   def check
-    unless fullpath.nil? || fullpath == ''
-      (class_indexes + defined_type_indexes).each do |class_idx|
-        title_token = class_idx[:name_token]
-        split_title = title_token.value.split('::')
-        mod = split_title.first
-        if split_title.length > 1
-          expected_path = "/#{mod}/manifests/#{split_title[1..-1].join('/')}.pp"
-        else
-          expected_path = "/#{title_token.value}/manifests/init.pp"
-        end
+    return if fullpath.nil? || fullpath == ''
 
-        if PuppetLint.configuration.relative
-          expected_path = expected_path.gsub(/^\//,'').split('/')[1..-1].join('/')
-        end
+    (class_indexes + defined_type_indexes).each do |class_idx|
+      title_token = class_idx[:name_token]
+      split_title = title_token.value.split('::')
+      mod = split_title.first
+      expected_path = if split_title.length > 1
+                        "/#{mod}/manifests/#{split_title[1..-1].join('/')}.pp"
+                      else
+                        "/#{title_token.value}/manifests/init.pp"
+                      end
 
-        unless fullpath.end_with? expected_path
-          notify :error, {
-            :message => "#{title_token.value} not in autoload module layout",
-            :line    => title_token.line,
-            :column  => title_token.column,
-          }
-        end
+      if PuppetLint.configuration.relative
+        expected_path = expected_path.gsub(%r{^/}, '').split('/')[1..-1].join('/')
       end
+
+      next if fullpath.end_with?(expected_path)
+
+      notify(
+        :error,
+        :message => "#{title_token.value} not in autoload module layout",
+        :line    => title_token.line,
+        :column  => title_token.column,
+      )
     end
   end
 end

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

@@ -5,15 +5,14 @@
 PuppetLint.new_check(:class_inherits_from_params_class) do
   def check
     class_indexes.each do |class_idx|
-      unless class_idx[:inherited_token].nil?
-        if class_idx[:inherited_token].value.end_with? '::params'
-          notify :warning, {
-            :message => 'class inheriting from params class',
-            :line    => class_idx[:inherited_token].line,
-            :column  => class_idx[:inherited_token].column,
-          }
-        end
-      end
+      next unless class_idx[:inherited_token] && class_idx[:inherited_token].value.end_with?('::params')
+
+      notify(
+        :warning,
+        :message => 'class inheriting from params class',
+        :line    => class_idx[:inherited_token].line,
+        :column  => class_idx[:inherited_token].column,
+      )
     end
   end
 end

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

@@ -7,14 +7,15 @@ PuppetLint.new_check(:code_on_top_scope) do
     top_scope   = tokens - class_scope
 
     top_scope.each do |token|
-      unless formatting_tokens.include? token.type
-        notify :warning, {
-          :message => "code outside of class or define block - #{token.value}",
-          :line    => token.line,
-          :column  => token.column
-        }
-      end
+      next if formatting_tokens.include?(token.type)
+
+      notify(
+        :warning,
+        :message => "code outside of class or define block - #{token.value}",
+        :line    => token.line,
+        :column  => token.column,
+      )
     end
   end
 end
-PuppetLint.configuration.send("disable_code_on_top_scope")
+PuppetLint.configuration.send('disable_code_on_top_scope')