cookstyle 6.15.9 → 6.17.5

data/lib/rubocop/cop/chef/correctness/block_guard_clause_string_only.rb

@@ -37,7 +37,9 @@ module RuboCop
         #     only_if 'test -f /etc/foo'
         #   end
         #
-        class BlockGuardWithOnlyString < Cop
+        class BlockGuardWithOnlyString < Base
+          extend AutoCorrector
+
           MSG = 'A resource guard (not_if/only_if) that is a string should not be wrapped in {}. Wrapping a guard string in {} causes it be executed as Ruby code which will always returns true instead of a shell command that will actually run.'
 
           def_node_matcher :block_guard_with_only_string?, <<-PATTERN
@@ -46,14 +48,10 @@ module RuboCop
 
           def on_block(node)
             block_guard_with_only_string?(node) do
-              add_offense(node, location: :expression, message: MSG, severity: :refactor)
-            end
-          end
-
-          def autocorrect(node)
-            lambda do |corrector|
-              new_val = "#{node.method_name} #{node.body.source}"
-              corrector.replace(node.loc.expression, new_val)
+              add_offense(node, message: MSG, severity: :refactor) do |corrector|
+                new_val = "#{node.method_name} #{node.body.source}"
+                corrector.replace(node.loc.expression, new_val)
+              end
             end
           end
         end

data/lib/rubocop/cop/chef/correctness/chef_application_fatal.rb

@@ -29,7 +29,9 @@ module RuboCop
         #   # good
         #   raise "Something horrible happened!"
         #
-        class ChefApplicationFatal < Cop
+        class ChefApplicationFatal < Base
+          extend AutoCorrector
+
           MSG = 'Use raise to force Chef Infra Client to fail instead of using Chef::Application.fatal'
 
           def_node_matcher :application_fatal?, <<-PATTERN
@@ -40,14 +42,8 @@ module RuboCop
           PATTERN
 
           def on_send(node)
-            application_fatal?(node) do
-              add_offense(node, location: :expression, message: MSG, severity: :refactor)
-            end
-          end
-
-          def autocorrect(node)
-            lambda do |corrector|
-              application_fatal?(node) do |val|
+            application_fatal?(node) do |val|
+              add_offense(node, message: MSG, severity: :refactor) do |corrector|
                 corrector.replace(node.loc.expression, "raise(#{val.source})")
               end
             end

data/lib/rubocop/cop/chef/correctness/conditional_ruby_shellout.rb

@@ -40,8 +40,10 @@ module RuboCop
         #     only_if 'wget https://www.bar.com/foobar.txt -O /dev/null'
         #   end
         #
-        class ConditionalRubyShellout < Cop
+        class ConditionalRubyShellout < Base
+          extend AutoCorrector
           include RuboCop::Chef::CookbookHelpers
+
           MSG = "Don't use Ruby to shellout in an only_if / not_if conditional when you can shellout directly by wrapping the command in quotes."
 
           def_node_matcher :conditional_shellout?, <<-PATTERN
@@ -54,14 +56,8 @@ module RuboCop
           PATTERN
 
           def on_block(node)
-            conditional_shellout?(node) do
-              add_offense(node, location: :expression, message: MSG, severity: :refactor)
-            end
-          end
-
-          def autocorrect(node)
-            lambda do |corrector|
-              conditional_shellout?(node) do |type, val|
+            conditional_shellout?(node) do |type, val|
+              add_offense(node, message: MSG, severity: :refactor) do |corrector|
                 corrector.replace(node.loc.expression, "#{type} #{val.source}")
               end
             end

data/lib/rubocop/cop/chef/correctness/dnf_package_allow_downgrades.rb

@@ -34,21 +34,18 @@ module RuboCop
         #     version '1.2.3'
         #   end
         #
-        class DnfPackageAllowDowngrades < Cop
+        class DnfPackageAllowDowngrades < Base
           include RangeHelp
           include RuboCop::Chef::CookbookHelpers
+          extend AutoCorrector
 
           MSG = 'dnf_package does not support the allow_downgrades property'
 
           def on_block(node)
             match_property_in_resource?(:dnf_package, :allow_downgrades, node) do |prop|
-              add_offense(prop, location: :expression, message: MSG, severity: :refactor)
-            end
-          end
-
-          def autocorrect(node)
-            lambda do |corrector|
-              corrector.remove(range_with_surrounding_space(range: node.loc.expression, side: :left))
+              add_offense(prop, message: MSG, severity: :refactor) do |corrector|
+                corrector.remove(range_with_surrounding_space(range: prop.loc.expression, side: :left))
+              end
             end
           end
         end

data/lib/rubocop/cop/chef/correctness/incorrect_library_injection.rb

@@ -32,7 +32,9 @@ module RuboCop
         #   # good
         #   ::Chef::DSL::Recipe.send(:include, Filebeat::Helpers) # covers previous Recipe & Provider classes
         #
-        class IncorrectLibraryInjection < Cop
+        class IncorrectLibraryInjection < Base
+          extend AutoCorrector
+
           MSG = 'Libraries should be injected into the Chef::DSL::Recipe class and not Chef::Recipe or Chef::Provider classes directly.'
 
           def_node_matcher :legacy_class_sends?, <<-PATTERN
@@ -45,17 +47,17 @@ module RuboCop
 
           def on_send(node)
             legacy_class_sends?(node) do
-              add_offense(node, location: :expression, message: MSG, severity: :refactor)
+              add_offense(node, message: MSG, severity: :refactor) do |corrector|
+                corrector.replace(node.loc.expression,
+                  node.source.gsub(/Chef::(Provider|Recipe)/, 'Chef::DSL::Recipe'))
+              end
             end
 
             legacy_class_includes?(node) do
-              add_offense(node, location: :expression, message: MSG, severity: :refactor)
-            end
-          end
-
-          def autocorrect(node)
-            lambda do |corrector|
-              corrector.replace(node.loc.expression, node.source.gsub(/Chef::(Provider|Recipe)/, 'Chef::DSL::Recipe'))
+              add_offense(node, message: MSG, severity: :refactor) do |corrector|
+                corrector.replace(node.loc.expression,
+                  node.source.gsub(/Chef::(Provider|Recipe)/, 'Chef::DSL::Recipe'))
+              end
             end
           end
         end

data/lib/rubocop/cop/chef/correctness/invalid_default_action.rb

@@ -30,15 +30,16 @@ module RuboCop
       #   default_action :create
       #
       module ChefCorrectness
-        class InvalidDefaultAction < Cop
+        class InvalidDefaultAction < Base
           MSG = 'Default actions in resources should be symbols or an array of symbols.'
+          RESTRICT_ON_SEND = [:default_action].freeze
 
           def_node_matcher :default_action?, '(send nil? :default_action $_)'
 
           def on_send(node)
             default_action?(node) do |match|
               return if %i(send sym array).include?(match.type)
-              add_offense(node, location: :expression, message: MSG, severity: :refactor)
+              add_offense(node, message: MSG, severity: :refactor)
             end
           end
         end

data/lib/rubocop/cop/chef/correctness/invalid_notification_timing.rb

@@ -35,8 +35,9 @@ module RuboCop
         #     notifies :restart, 'service[apache]', :immediately
         #   end
         #
-        class InvalidNotificationTiming < Cop
+        class InvalidNotificationTiming < Base
           MSG = 'Valid notification timings are :immediately, :immediate (alias for :immediately), :delayed, and :before.'
+          RESTRICT_ON_SEND = [:notifies, :subscribes].freeze
 
           def_node_matcher :notification_with_timing?, <<-PATTERN
             (send nil? {:notifies :subscribes} (sym _) (...) $(sym _))
@@ -44,7 +45,7 @@ module RuboCop
 
           def on_send(node)
             notification_with_timing?(node) do |timing|
-              add_offense(timing, location: :expression, message: MSG, severity: :refactor) unless %i(immediate immediately delayed before).include?(timing.value)
+              add_offense(timing, message: MSG, severity: :refactor) unless %i(immediate immediately delayed before).include?(timing.value)
             end
           end
         end

data/lib/rubocop/cop/chef/correctness/invalid_platform_family_helper.rb

@@ -31,11 +31,13 @@ module RuboCop
         #   platform_family?('rhel')
         #   platform_family?('suse')
         #
-        class InvalidPlatformFamilyHelper < Cop
+        class InvalidPlatformFamilyHelper < Base
           include ::RuboCop::Chef::PlatformHelpers
           include RangeHelp
+          extend AutoCorrector
 
           MSG = 'Pass valid platform families to the platform_family? helper.'
+          RESTRICT_ON_SEND = [:platform_family?].freeze
 
           def_node_matcher :platform_family_helper?, <<-PATTERN
             (send nil? :platform_family? $str*)
@@ -45,27 +47,20 @@ module RuboCop
             platform_family_helper?(node) do |plats|
               plats.to_a.each do |p|
                 next unless INVALID_PLATFORM_FAMILIES.key?(p.value)
-                add_offense(p, location: :expression, message: MSG, severity: :refactor)
-              end
-            end
-          end
+                add_offense(p, message: MSG, severity: :refactor) do |corrector|
+                  replacement_platform = INVALID_PLATFORM_FAMILIES[p.value]
+                  all_passed_platforms = p.parent.arguments.map(&:value)
 
-          def autocorrect(node)
-            replacement_platform = INVALID_PLATFORM_FAMILIES[node.value]
-            all_passed_platforms = node.parent.arguments.map(&:value)
-
-            # see if we have a replacement platform in our hash. If not we can't autocorrect
-            if replacement_platform
-              # if the replacement platform was one of the other platforms passed we can just delete this bad platform
-              if all_passed_platforms.include?(replacement_platform)
-                all_passed_platforms.delete(node.value)
-                lambda do |corrector|
-                  arg_range = node.parent.arguments.first.loc.expression.join(node.parent.arguments[-1].loc.expression.end)
-                  corrector.replace(arg_range, all_passed_platforms.map { |x| "'#{x}'" }.join(', '))
-                end
-              else
-                lambda do |corrector|
-                  corrector.replace(node.loc.expression, node.value.gsub(node.value, "'#{replacement_platform}'")) # gsub to retain quotes
+                  # see if we have a replacement platform in our hash. If not we can't autocorrect
+                  next unless replacement_platform
+                  # if the replacement platform was one of the other platforms passed we can just delete this bad platform
+                  if all_passed_platforms.include?(replacement_platform)
+                    all_passed_platforms.delete(p.value)
+                    arg_range = p.parent.arguments.first.loc.expression.join(p.parent.arguments[-1].loc.expression.end)
+                    corrector.replace(arg_range, all_passed_platforms.map { |x| "'#{x}'" }.join(', '))
+                  else
+                    corrector.replace(p.loc.expression, p.value.gsub(p.value, "'#{replacement_platform}'")) # gsub to retain quotes
+                  end
                 end
               end
             end

data/lib/rubocop/cop/chef/correctness/invalid_platform_family_values_in_case.rb

@@ -29,7 +29,8 @@ module RuboCop
         #     puts "I'm on a RHEL-like system"
         #   end
         #
-        class InvalidPlatformFamilyInCase < Cop
+        class InvalidPlatformFamilyInCase < Base
+          extend AutoCorrector
           include RangeHelp
           include ::RuboCop::Chef::PlatformHelpers
 
@@ -43,34 +44,25 @@ module RuboCop
             node_platform_family?(node.condition) do
               node.each_when do |when_node|
                 when_node.each_condition do |con|
-                  next unless con.str_type? # if the condition isn't a string we can't check so skip
+                  next unless con.str_type?
+                  # if the condition isn't a string we can't check so skip
+                  # some invalid platform families have no direct correction value and return nil instead
+                  new_value = INVALID_PLATFORM_FAMILIES[con.str_content]
+                  next unless new_value
 
-                  if INVALID_PLATFORM_FAMILIES[con.str_content]
-                    add_offense(con, location: :expression, message: MSG, severity: :refactor)
+                  add_offense(con, message: MSG, severity: :refactor) do |corrector|
+                    # if the correct value already exists in the when statement then we just want to delete this node
+                    if con.parent.conditions.any? { |x| x.str_content == new_value }
+                      range = range_with_surrounding_comma(range_with_surrounding_space(range: con.loc.expression, side: :left), :both)
+                      corrector.remove(range)
+                    else
+                      corrector.replace(con.loc.expression, "'#{new_value}'")
+                    end
                   end
                 end
               end
             end
           end
-
-          def autocorrect(node)
-            new_value = INVALID_PLATFORM_FAMILIES[node.str_content]
-
-            # some invalid platform families have no direct correction value and return nil instead
-            return unless new_value
-
-            # if the correct value already exists in the when statement then we just want to delete this node
-            if node.parent.conditions.any? { |x| x.str_content == new_value }
-              lambda do |corrector|
-                range = range_with_surrounding_comma(range_with_surrounding_space(range: node.loc.expression, side: :left), :both)
-                corrector.remove(range)
-              end
-            else
-              lambda do |corrector|
-                corrector.replace(node.loc.expression, "'#{new_value}'")
-              end
-            end
-          end
         end
       end
     end

data/lib/rubocop/cop/chef/correctness/invalid_platform_helper.rb

@@ -32,10 +32,11 @@ module RuboCop
         #   platform?('mac_os_x')
         #   platform?('redhat)
         #   platform?('suse')
-        class InvalidPlatformHelper < Cop
+        class InvalidPlatformHelper < Base
           include ::RuboCop::Chef::PlatformHelpers
 
           MSG = 'Pass valid platforms to the platform? helper.'
+          RESTRICT_ON_SEND = [:platform?].freeze
 
           def_node_matcher :platform_helper?, <<-PATTERN
             (send nil? :platform? $str*)
@@ -44,7 +45,7 @@ module RuboCop
           def on_send(node)
             platform_helper?(node) do |plat|
               plat.to_a.each do |p|
-                add_offense(p, location: :expression, message: MSG, severity: :refactor) if INVALID_PLATFORMS.key?(p.value)
+                add_offense(p, message: MSG, severity: :refactor) if INVALID_PLATFORMS.key?(p.value)
               end
             end
           end

data/lib/rubocop/cop/chef/correctness/invalid_platform_metadata.rb

@@ -32,10 +32,12 @@ module RuboCop
         #   supports 'mac_os_x'
         #   supports 'windows'
         #
-        class InvalidPlatformMetadata < Cop
+        class InvalidPlatformMetadata < Base
+          extend AutoCorrector
           include ::RuboCop::Chef::PlatformHelpers
 
           MSG = 'metadata.rb "supports" platform is invalid'
+          RESTRICT_ON_SEND = [:supports].freeze
 
           def_node_matcher :supports?, '(send nil? :supports $str ...)'
 
@@ -50,8 +52,11 @@ module RuboCop
 
           def on_send(node)
             supports?(node) do |plat|
-              if INVALID_PLATFORMS[plat.str_content]
-                add_offense(plat, location: :expression, message: MSG, severity: :refactor)
+              next unless INVALID_PLATFORMS[plat.str_content]
+              add_offense(plat, message: MSG, severity: :refactor) do |corrector|
+                correct_string = corrected_platform_source(plat)
+                next unless correct_string
+                corrector.replace(plat.loc.expression, correct_string)
               end
             end
           end
@@ -59,22 +64,16 @@ module RuboCop
           def on_block(node)
             supports_array?(node) do |plats|
               plats.values.each do |plat|
-                if INVALID_PLATFORMS[plat.str_content]
-                  add_offense(plat, location: :expression, message: MSG, severity: :refactor)
+                next unless INVALID_PLATFORMS[plat.str_content]
+                add_offense(plat, message: MSG, severity: :refactor) do |corrector|
+                  correct_string = corrected_platform_source(plat)
+                  next unless correct_string
+                  corrector.replace(plat.loc.expression, correct_string)
                 end
               end
             end
           end
 
-          def autocorrect(node)
-            correct_string = corrected_platform_source(node)
-            if correct_string
-              lambda do |corrector|
-                corrector.replace(node.loc.expression, correct_string)
-              end
-            end
-          end
-
           # private
 
           def corrected_platform_source(node)

data/lib/rubocop/cop/chef/correctness/invalid_platform_values_in_case.rb

@@ -29,7 +29,8 @@ module RuboCop
         #     puts "I'm on a Red Hat system!"
         #   end
         #
-        class InvalidPlatformInCase < Cop
+        class InvalidPlatformInCase < Base
+          extend AutoCorrector
           include RangeHelp
           include ::RuboCop::Chef::PlatformHelpers
 
@@ -44,33 +45,23 @@ module RuboCop
               node.each_when do |when_node|
                 when_node.each_condition do |con|
                   next unless con.str_type? # if the condition isn't a string we can't check so skip
+                  new_value = INVALID_PLATFORMS[con.str_content]
+                  # some invalid platform have no direct correction value and return nil instead
+                  next unless new_value
 
-                  if INVALID_PLATFORMS[con.str_content]
-                    add_offense(con, location: :expression, message: MSG, severity: :refactor)
+                  add_offense(con, message: MSG, severity: :refactor) do |corrector|
+                    # if the correct value already exists in the when statement then we just want to delete this node
+                    if con.parent.conditions.any? { |x| x.str_content == new_value }
+                      range = range_with_surrounding_comma(range_with_surrounding_space(range: con.loc.expression, side: :left), :both)
+                      corrector.remove(range)
+                    else
+                      corrector.replace(con.loc.expression, "'#{new_value}'")
+                    end
                   end
                 end
               end
             end
           end
-
-          def autocorrect(node)
-            new_value = INVALID_PLATFORMS[node.str_content]
-
-            # some invalid platform have no direct correction value and return nil instead
-            return unless new_value
-
-            # if the correct value already exists in the when statement then we just want to delete this node
-            if node.parent.conditions.any? { |x| x.str_content == new_value }
-              lambda do |corrector|
-                range = range_with_surrounding_comma(range_with_surrounding_space(range: node.loc.expression, side: :left), :both)
-                corrector.remove(range)
-              end
-            else
-              lambda do |corrector|
-                corrector.replace(node.loc.expression, "'#{new_value}'")
-              end
-            end
-          end
         end
       end
     end

data/lib/rubocop/cop/chef/correctness/invalid_value_for_platform_family_helper.rb

@@ -35,10 +35,11 @@ module RuboCop
         #     %w(mac_os_x) => 'foo'
         #   )
         #
-        class InvalidPlatformValueForPlatformFamilyHelper < Cop
+        class InvalidPlatformValueForPlatformFamilyHelper < Base
           include ::RuboCop::Chef::PlatformHelpers
 
           MSG = 'Pass valid platform families to the value_for_platform_family helper.'
+          RESTRICT_ON_SEND = [:value_for_platform_family].freeze
 
           def_node_matcher :value_for_platform_family?, <<-PATTERN
           (send nil? :value_for_platform_family
@@ -53,10 +54,11 @@ module RuboCop
               plats.each do |p_hash|
                 if p_hash.key.array_type?
                   p_hash.key.values.each do |plat|
-                    add_offense(plat, location: :expression, message: MSG, severity: :refactor) if INVALID_PLATFORM_FAMILIES.key?(plat.value)
+                    next unless INVALID_PLATFORM_FAMILIES.key?(plat.value)
+                    add_offense(plat, message: MSG, severity: :refactor)
                   end
                 elsif INVALID_PLATFORM_FAMILIES.key?(p_hash.key.value)
-                  add_offense(p_hash.key, location: :expression, message: MSG, severity: :refactor)
+                  add_offense(p_hash.key, message: MSG, severity: :refactor)
                 end
               end
             end