cookstyle 6.15.9 → 6.16.4

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,7 +30,7 @@ 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.'
 
           def_node_matcher :default_action?, '(send nil? :default_action $_)'
@@ -38,7 +38,7 @@ module RuboCop
           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,7 +35,7 @@ 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.'
 
           def_node_matcher :notification_with_timing?, <<-PATTERN
@@ -44,7 +44,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,9 +31,10 @@ 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.'
 
@@ -45,27 +46,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,7 +32,7 @@ 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.'
@@ -44,7 +44,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,7 +32,8 @@ 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'
@@ -50,8 +51,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 +63,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,7 +35,7 @@ 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.'
@@ -53,10 +53,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

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

@@ -34,7 +34,7 @@ module RuboCop
         #     %w(opensuseleap) => { 'default' => 'bar' }
         #   )
         #
-        class InvalidPlatformValueForPlatformHelper < Cop
+        class InvalidPlatformValueForPlatformHelper < Base
           include ::RuboCop::Chef::PlatformHelpers
 
           MSG = 'Pass valid platforms to the value_for_platform helper.'
@@ -52,10 +52,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_PLATFORMS.key?(plat.value)
+                    next unless INVALID_PLATFORMS.key?(plat.value)
+                    add_offense(plat, message: MSG, severity: :refactor)
                   end
                 elsif INVALID_PLATFORMS.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

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

@@ -30,16 +30,15 @@ module RuboCop
         #   # good
         #   version '1.2.3'
         #
-        class InvalidVersionMetadata < Cop
+        class InvalidVersionMetadata < Base
           MSG = 'Cookbook metadata.rb version field should follow X.Y.Z version format.'
 
           def_node_matcher :version?, '(send nil? :version $str ...)'
 
           def on_send(node)
             version?(node) do |ver|
-              unless /\A\d+\.\d+(\.\d+)?\z/.match?(ver.value) # entirely borrowed from Foodcritic.
-                add_offense(ver, location: :expression, message: MSG, severity: :refactor)
-              end
+              next if /\A\d+\.\d+(\.\d+)?\z/.match?(ver.value) # entirely borrowed from Foodcritic.
+              add_offense(ver, message: MSG, severity: :refactor)
             end
           end
         end

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

@@ -30,7 +30,8 @@ module RuboCop
         #   # good
         #   property :Something, String, default: lazy { node['hostname'] }
         #
-        class LazyEvalNodeAttributeDefaults < Cop
+        class LazyEvalNodeAttributeDefaults < Base
+          extend AutoCorrector
           include RuboCop::Chef::CookbookHelpers
 
           MSG = 'When setting a node attribute as the default value for a custom resource property, wrap the node attribute in `lazy {}` so that its value is available when the resource executes.'
@@ -41,13 +42,9 @@ module RuboCop
 
           def on_send(node)
             non_lazy_node_attribute_default?(node) do |default|
-              add_offense(default, location: :expression, message: MSG, severity: :refactor)
-            end
-          end
-
-          def autocorrect(node)
-            lambda do |corrector|
-              corrector.replace(node.loc.expression, "lazy { #{node.loc.expression.source} }")
+              add_offense(default, message: MSG, severity: :refactor) do |corrector|
+                corrector.replace(default.loc.expression, "lazy { #{default.loc.expression.source} }")
+              end
             end
           end
         end

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

@@ -55,9 +55,8 @@ module RuboCop
               type_val = method_arg_ast_to_string(type)
               return if VALID_VALUES.include?(type_val)
               add_offense(type.loc.expression, message: MSG, severity: :refactor) do |corrector|
-                if INVALID_VALUE_MAP[type_val]
-                  corrector.replace(type.loc.expression, "type '#{INVALID_VALUE_MAP[type_val]}'")
-                end
+                next unless INVALID_VALUE_MAP[type_val]
+                corrector.replace(type.loc.expression, "type '#{INVALID_VALUE_MAP[type_val]}'")
               end
             end
           end

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

@@ -44,20 +44,19 @@ module RuboCop
         #     'default' => 'bar'
         #   )
         #
-        class MalformedPlatformValueForPlatformHelper < Cop
+        class MalformedPlatformValueForPlatformHelper < Base
           def on_send(node)
             return unless node.method_name == :value_for_platform
 
             if node.arguments.count > 1
               msg = 'Malformed value_for_platform helper argument. The value_for_platform helper takes a single hash of platforms as an argument.'
-              add_offense(node, location: :expression, message: msg, severity: :refactor)
+              add_offense(node, message: msg, severity: :refactor)
             elsif node.arguments.first.hash_type? # if it's a variable we can't check what's in that variable so skip
               msg = "Malformed value_for_platform helper argument. The value for each platform in your hash must be a hash of either platform version strings or a value with a key of 'default'"
               node.arguments.first.each_pair do |plats, plat_vals|
                 # instead of a platform the hash key can be default with a value of anything. Depending on the hash format this is a string or symbol
-                unless plat_vals.hash_type? || plats == s(:str, 'default') || plats == s(:sym, :default)
-                  add_offense(plat_vals, location: :expression, message: msg, severity: :refactor)
-                end
+                next if plat_vals.hash_type? || plats == s(:str, 'default') || plats == s(:sym, :default)
+                add_offense(plat_vals, message: msg, severity: :refactor)
               end
             end
           end

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

@@ -27,27 +27,20 @@ module RuboCop
       #   name 'foo'
       #
       module ChefCorrectness
-        class MetadataMissingName < Cop
+        class MetadataMissingName < Base
           include RangeHelp
 
           MSG = 'metadata.rb needs to include the name method or it will fail on Chef Infra Client 12 and later.'
 
-          def investigate(processed_source)
-            return if processed_source.blank?
+          def_node_search :cb_name, '(send nil? :name str ...)'
 
+          def on_new_investigation
             # Using range similar to RuboCop::Cop::Naming::Filename (file_name.rb)
+            return if cb_name(processed_source.ast).any?
             range = source_range(processed_source.buffer, 1, 0)
-
-            add_offense(nil, location: range, message: MSG, severity: :refactor) unless cb_name(processed_source.ast).any?
-          end
-
-          def_node_search :cb_name, '(send nil? :name str ...)'
-
-          def autocorrect(_node)
-            lambda do |_corrector|
+            add_offense(range, message: MSG, severity: :refactor) do |_corrector|
               path = processed_source.path
               cb_name = File.basename(File.dirname(path))
-
               metadata = IO.read(path)
               IO.write(path, "name '#{cb_name}'\n" + metadata)
             end