cookstyle 6.15.9 → 6.17.5

data/lib/rubocop/cop/chef/sharing/invalid_license_string.rb

@@ -37,7 +37,9 @@ module RuboCop
         # json_data = JSON.parse(Net::HTTP.get(URI('https://raw.githubusercontent.com/spdx/license-list-data/master/json/licenses.json')))
         # licenses = json_data['licenses'].map {|l| l['licenseId'] }.sort
         #
-        class InvalidLicenseString < Cop
+        class InvalidLicenseString < Base
+          extend AutoCorrector
+
           VALID_LICENSE_STRING = %w(
             0BSD
             AAL
@@ -456,22 +458,16 @@ module RuboCop
           }.freeze
 
           MSG = 'Cookbook metadata.rb does not use a SPDX compliant license string or "all rights reserved". See https://spdx.org/licenses/ for a complete list of license identifiers.'
+          RESTRICT_ON_SEND = [:license].freeze
 
           def_node_matcher :license?, '(send nil? :license $str ...)'
 
           def on_send(node)
             license?(node) do |license|
-              unless valid_license?(license.str_content)
-                add_offense(license, location: :expression, message: MSG, severity: :refactor)
-              end
-            end
-          end
-
-          def autocorrect(node)
-            correct_string = autocorrect_license_string(node.str_content)
-            if correct_string
-              lambda do |corrector|
-                corrector.replace(node.loc.expression, "'#{correct_string}'")
+              return if valid_license?(license.str_content)
+              add_offense(license, message: MSG, severity: :refactor) do |corrector|
+                correct_string = autocorrect_license_string(license.str_content)
+                corrector.replace(license.loc.expression, "'#{correct_string}'") if correct_string
               end
             end
           end

data/lib/rubocop/cop/chef/style/chef_whaaat.rb

@@ -35,13 +35,12 @@ module RuboCop
         class ChefWhaaat < Cop
           MSG = 'Do you mean Chef (the company) or a Chef product (e.g. Chef Infra, Chef InSpec, etc)?'
 
-          def investigate(processed_source)
+          def on_new_investigation
             return unless processed_source.ast
 
             processed_source.comments.each do |comment|
-              if comment.text.match?(/Chef [a-z]/) # https://rubular.com/r/0YzfDAbwJrDHix
-                add_offense(comment, location: comment.loc.expression, message: MSG, severity: :refactor)
-              end
+              next unless comment.text.match?(/Chef [a-z]/) # https://rubular.com/r/0YzfDAbwJrDHix
+              add_offense(comment.loc.expression, message: MSG, severity: :refactor)
             end
           end
         end

data/lib/rubocop/cop/chef/style/comment_sentence_spacing.rb

@@ -22,22 +22,20 @@ module RuboCop
       module ChefStyle
         # Replaces double spaces between sentences with a single space.
         # Note: This is DISABLED by default.
-        class CommentSentenceSpacing < Cop
+        class CommentSentenceSpacing < Base
+          extend AutoCorrector
           MSG = 'Use a single space after sentences in comments'
 
           def investigate(processed_source)
             return unless processed_source.ast
 
             processed_source.comments.each do |comment|
-              if comment.text.match?(/(.|\?)\s{2}/) # https://rubular.com/r/8o3SiDrQMJSzuU
-                add_offense(comment, location: comment.loc.expression, message: MSG, severity: :refactor)
+              next unless comment.text.match?(/(.|\?)\s{2}/) # https://rubular.com/r/8o3SiDrQMJSzuU
+              add_offense(comment, location: comment.loc.expression, message: MSG, severity: :refactor) do |corrector|
+                corrector.replace(comment.loc.expression, comment.text.gsub('.  ', '. ').gsub('?  ', '? '))
               end
             end
           end
-
-          def autocorrect(comment)
-            ->(corrector) { corrector.replace(comment.loc.expression, comment.text.gsub('.  ', '. ').gsub('?  ', '? ')) }
-          end
         end
       end
     end

data/lib/rubocop/cop/chef/style/comments_copyright_format.rb

@@ -43,23 +43,19 @@ module RuboCop
 
           MSG = 'Properly format copyrights header comments'
 
-          def investigate(processed_source)
+          def on_new_investigation
             return unless processed_source.ast
 
             processed_source.comments.each do |comment|
-              next unless comment.inline? # headers aren't in blocks
+              next unless comment.inline? && invalid_copyright_comment?(comment) # headers aren't in blocks
 
-              if invalid_copyright_comment?(comment)
-                add_offense(comment, location: comment.loc.expression, message: MSG, severity: :refactor)
+              add_offense(comment, location: comment.loc.expression, message: MSG, severity: :refactor) do |corrector|
+                correct_comment = "# Copyright:: #{copyright_date_range(comment)}, #{copyright_holder(comment)}"
+                corrector.replace(comment.loc.expression, correct_comment)
               end
             end
           end
 
-          def autocorrect(comment)
-            correct_comment = "# Copyright:: #{copyright_date_range(comment)}, #{copyright_holder(comment)}"
-            ->(corrector) { corrector.replace(comment.loc.expression, correct_comment) }
-          end
-
           private
 
           def copyright_date_range(comment)

data/lib/rubocop/cop/chef/style/comments_default_copyright.rb

@@ -32,18 +32,16 @@ module RuboCop
         #   Copyright:: 2019 Tim Smith
         #   Copyright:: 2019 Chef Software, Inc.
         #
-        class DefaultCopyrightComments < Cop
+        class DefaultCopyrightComments < Base
           MSG = 'Cookbook copyright comment headers should be updated for a real person or organization.'
 
-          def investigate(processed_source)
+          def on_new_investigation
             return unless processed_source.ast
 
             processed_source.comments.each do |comment|
-              next unless comment.inline? # headers aren't in blocks
-
-              if /# (?:Copyright\W*).*YOUR_(NAME|COMPANY_NAME)/.match?(comment.text)
-                add_offense(comment, location: comment.loc.expression, message: MSG, severity: :refactor)
-              end
+              next unless comment.inline? &&  # headers aren't in blocks
+                          /# (?:Copyright\W*).*YOUR_(NAME|COMPANY_NAME)/.match?(comment.text)
+              add_offense(comment.loc.expression, message: MSG, severity: :refactor)
             end
           end
         end

data/lib/rubocop/cop/chef/style/comments_format.rb

@@ -40,33 +40,30 @@ module RuboCop
         #   License:: Apache License, Version 2.0
         #   Cookbook:: Tomcat
         #
-        class CommentFormat < Cop
+        class CommentFormat < Base
+          extend AutoCorrector
+
           MSG = 'Properly format header comments'
 
-          def investigate(processed_source)
+          def on_new_investigation
             return unless processed_source.ast
 
             processed_source.comments.each do |comment|
               next if comment.loc.first_line > 10 # avoid false positives when we were checking further down the file
-              next unless comment.inline? # headers aren't in blocks
+              next unless comment.inline? && invalid_comment?(comment) # headers aren't in blocks
 
-              if invalid_comment?(comment)
-                add_offense(comment, location: comment.loc.expression, message: MSG, severity: :refactor)
+              add_offense(comment.loc.expression, message: MSG, severity: :refactor) do |corrector|
+                # Extract the type and the actual value. Strip out "Name" or "File"
+                # 'Cookbook Name' should be 'Cookbook'. Also skip a :: if present
+                # https://rubular.com/r/Do9fpLWXlCmvdJ
+                match = /^#\s*([A-Za-z]+)\s?(?:Name|File)?(?:::)?\s(.*)/.match(comment.text)
+                comment_type, value = match.captures
+                correct_comment = "# #{comment_type}:: #{value}"
+                corrector.replace(comment.loc.expression, correct_comment)
               end
             end
           end
 
-          def autocorrect(comment)
-            # Extract the type and the actual value. Strip out "Name" or "File"
-            # 'Cookbook Name' should be 'Cookbook'. Also skip a :: if present
-            # https://rubular.com/r/Do9fpLWXlCmvdJ
-            match = /^#\s*([A-Za-z]+)\s?(?:Name|File)?(?:::)?\s(.*)/.match(comment.text)
-            comment_type, value = match.captures
-            correct_comment = "# #{comment_type}:: #{value}"
-
-            ->(corrector) { corrector.replace(comment.loc.expression, correct_comment) }
-          end
-
           private
 
           def invalid_comment?(comment)

data/lib/rubocop/cop/chef/style/file_mode.rb

@@ -55,6 +55,7 @@ module RuboCop
           extend RuboCop::Cop::AutoCorrector
 
           MSG = 'Use strings to represent file modes to avoid confusion between octal and base 10 integer formats'
+          RESTRICT_ON_SEND = [:mode, :files_mode].freeze
 
           def_node_matcher :resource_mode?, <<-PATTERN
             (send nil? {:mode :files_mode} $int)

data/lib/rubocop/cop/chef/style/immediate_notification_timing.rb

@@ -35,8 +35,11 @@ module RuboCop
         #     notifies :restart, 'service[apache]', :immediately
         #   end
         #
-        class ImmediateNotificationTiming < Cop
+        class ImmediateNotificationTiming < Base
+          extend AutoCorrector
+
           MSG = 'Use :immediately instead of :immediate for resource notification timing'
+          RESTRICT_ON_SEND = [:notifies].freeze
 
           def_node_matcher :immediate_notify?, <<-PATTERN
             (send nil? :notifies (sym _) (...) $(sym :immediate))
@@ -44,13 +47,9 @@ module RuboCop
 
           def on_send(node)
             immediate_notify?(node) do |timing|
-              add_offense(timing, location: :expression, message: MSG, severity: :refactor)
-            end
-          end
-
-          def autocorrect(node)
-            lambda do |corrector|
-              corrector.replace(node.loc.expression, ':immediately')
+              add_offense(timing.loc.expression, message: MSG, severity: :refactor) do |corrector|
+                corrector.replace(timing.loc.expression, ':immediately')
+              end
             end
           end
         end

data/lib/rubocop/cop/chef/style/include_recipe_with_parentheses.rb

@@ -34,6 +34,7 @@ module RuboCop
           extend RuboCop::Cop::AutoCorrector
 
           MSG = 'There is no need to wrap the recipe in parentheses when using the include_recipe helper'
+          RESTRICT_ON_SEND = [:include_recipe].freeze
 
           def_node_matcher :include_recipe?, <<-PATTERN
             (send nil? :include_recipe $(str _))

data/lib/rubocop/cop/chef/style/negating_only_if.rb

@@ -33,7 +33,9 @@ module RuboCop
         #     not_if { systemd }
         #   end
         #
-        class NegatingOnlyIf < Cop
+        class NegatingOnlyIf < Base
+          extend AutoCorrector
+
           MSG = 'Instead of using only_if conditionals with ! to negate the returned value, use not_if which is easier to read'
 
           def_node_matcher :negated_only_if?, <<-PATTERN
@@ -45,7 +47,7 @@ module RuboCop
           PATTERN
 
           def on_block(node)
-            negated_only_if?(node) do |_only_if, code|
+            negated_only_if?(node) do |only_if, code|
               # skip inspec controls where we don't have not_if
               return if node.parent&.parent&.block_type? &&
                         node.parent&.parent&.method_name == :control
@@ -54,13 +56,7 @@ module RuboCop
               return if code.descendants.first.send_type? &&
                         code.descendants.first.negation_method?
 
-              add_offense(node, location: :expression, message: MSG, severity: :refactor)
-            end
-          end
-
-          def autocorrect(node)
-            negated_only_if?(node) do |only_if, code|
-              lambda do |corrector|
+              add_offense(node.loc.expression, message: MSG, severity: :refactor) do |corrector|
                 corrector.replace(code.loc.expression, code.source.gsub(/^!/, ''))
                 corrector.replace(only_if.source_range, 'not_if')
               end

data/lib/rubocop/cop/chef/style/overly_complex_supports_depends_metadata.rb

@@ -41,7 +41,8 @@ module RuboCop
         #   depends 'apt'
         #   depends 'yum'
         #
-        class OverlyComplexSupportsDependsMetadata < Cop
+        class OverlyComplexSupportsDependsMetadata < Base
+          extend AutoCorrector
           MSG = "Don't loop over an array to set cookbook dependencies or supported platforms if you have fewer than three values to set."
 
           def_node_matcher :supports_depends_array?, <<-PATTERN
@@ -54,14 +55,9 @@ module RuboCop
           PATTERN
 
           def on_block(node)
-            supports_depends_array?(node) do |array, _type|
-              add_offense(node, location: :expression, message: MSG, severity: :refactor) if array.values.count < 3
-            end
-          end
-
-          def autocorrect(node)
-            lambda do |corrector|
-              supports_depends_array?(node) do |array, type|
+            supports_depends_array?(node) do |array, type|
+              return unless array.values.count < 3
+              add_offense(node.loc.expression, message: MSG, severity: :refactor) do |corrector|
                 corrected_value = array.values.map { |x| "#{type} '#{x.source}'" }
                 corrector.replace(node.loc.expression, corrected_value.join("\n"))
               end

data/lib/rubocop/cop/chef/style/simplify_platform_major_version_check.rb

@@ -34,7 +34,9 @@ module RuboCop
         #   # check to see if we're on RHEL 7 on a RHEL 7.6 node where node['platform_version] is 7.6.1810
         #   if node['platform_version'].to_i == 7
         #
-        class SimplifyPlatformMajorVersionCheck < Cop
+        class SimplifyPlatformMajorVersionCheck < Base
+          extend AutoCorrector
+
           MSG = "Use node['platform_version'].to_i instead of node['platform_version'].split('.').first or node['platform_version'].split('.')[0]"
 
           def_node_matcher :platform_version_check?, <<-PATTERN
@@ -57,18 +59,14 @@ module RuboCop
             end
           end
 
-          def autocorrect(node)
-            lambda do |corrector|
-              corrector.replace(node.loc.expression, "node['platform_version'].to_i")
-            end
-          end
-
           private
 
           # if the parent is .to_i then we want to alert on that
           def add_offense_to_i_if_present(node)
             node = node.parent if parent_method_equals?(node, :to_i)
-            add_offense(node, location: :expression, message: MSG, severity: :refactor)
+            add_offense(node, message: MSG, severity: :refactor) do |corrector|
+              corrector.replace(node.loc.expression, "node['platform_version'].to_i")
+            end
           end
 
           # see if the parent is a method and if it equals the passed in name

data/lib/rubocop/cop/chef/style/true_false_resource_properties.rb

@@ -29,22 +29,19 @@ module RuboCop
         #   # good
         #   property :foo, [true, false]
         #
-        class TrueClassFalseClassResourceProperties < Cop
+        class TrueClassFalseClassResourceProperties < Base
+          extend AutoCorrector
+
           MSG = "When setting the allowed types for a resource to accept either true or false values it's much simpler to use true and false instead of TrueClass and FalseClass."
+          RESTRICT_ON_SEND = [:property, :attribute].freeze
 
           def_node_matcher :trueclass_falseclass_property?, <<-PATTERN
             (send nil? {:property :attribute} (sym _) $(array (const nil? :TrueClass) (const nil? :FalseClass)) ... )
           PATTERN
 
           def on_send(node)
-            trueclass_falseclass_property?(node) do
-              add_offense(node, location: :expression, message: MSG, severity: :refactor)
-            end
-          end
-
-          def autocorrect(node)
-            lambda do |corrector|
-              trueclass_falseclass_property?(node) do |types|
+            trueclass_falseclass_property?(node) do |types|
+              add_offense(node.loc.expression, message: MSG, severity: :refactor) do |corrector|
                 corrector.replace(types.loc.expression, '[true, false]')
               end
             end

data/lib/rubocop/cop/chef/style/unnecessary_os_check.rb

@@ -35,7 +35,9 @@ module RuboCop
         #   platform_family?('aix')
         #   platform_family?('netbsd', 'openbsd', 'freebsd)
         #
-        class UnnecessaryOSCheck < Cop
+        class UnnecessaryOSCheck < Base
+          extend AutoCorrector
+
           MSG = "Use the platform_family?() helpers instead of node['os] == 'foo' for platform_families that match 1:1 with OS values."
 
           # sorted list of all the os values that match 1:1 with a platform_family
@@ -54,23 +56,30 @@ module RuboCop
           PATTERN
 
           def on_send(node)
-            os_equals?(node) do |_operator, val|
-              if UNNECESSARY_OS_VALUES.include?(val.value)
-                add_offense(node, location: :expression, message: MSG, severity: :refactor)
+            os_equals?(node) do |operator, val|
+              return unless UNNECESSARY_OS_VALUES.include?(val.value)
+              add_offense(node.loc.expression, message: MSG, severity: :refactor) do |corrector|
+                corrected_string = (operator == :!= ? '!' : '') + "platform_family?('#{sanitized_platform(val.value)}')"
+                corrector.replace(node.loc.expression, corrected_string)
               end
             end
 
             os_eql?(node) do |val|
-              if UNNECESSARY_OS_VALUES.include?(val.value)
-                add_offense(node, location: :expression, message: MSG, severity: :refactor)
+              return unless UNNECESSARY_OS_VALUES.include?(val.value)
+              add_offense(node, message: MSG, severity: :refactor) do |corrector|
+                corrected_string = "platform_family?('#{sanitized_platform(val.value)}')"
+                corrector.replace(node.loc.expression, corrected_string)
               end
             end
 
             os_include?(node) do |val|
               array_of_plats = array_from_ast(val)
               # see if all the values in the .include? usage are in our list of 1:1 platform family to os values
-              if (UNNECESSARY_OS_VALUES & array_of_plats) == array_of_plats
-                add_offense(node, location: :expression, message: MSG, severity: :refactor)
+              return unless (UNNECESSARY_OS_VALUES & array_of_plats) == array_of_plats
+              add_offense(node, message: MSG, severity: :refactor) do |corrector|
+                platforms = val.values.map { |x| x.str_type? ? "'#{sanitized_platform(x.value)}'" : x.source }
+                corrected_string = "platform_family?(#{platforms.join(', ')})"
+                corrector.replace(node.loc.expression, corrected_string)
               end
             end
           end
@@ -86,26 +95,6 @@ module RuboCop
             ast.each_child_node { |x| vals << x.value }
             vals.sort
           end
-
-          def autocorrect(node)
-            lambda do |corrector|
-              os_equals?(node) do |operator, plat|
-                corrected_string = (operator == :!= ? '!' : '') + "platform_family?('#{sanitized_platform(plat.value)}')"
-                corrector.replace(node.loc.expression, corrected_string)
-              end
-
-              os_include?(node) do |plats|
-                platforms = plats.values.map { |x| x.str_type? ? "'#{sanitized_platform(x.value)}'" : x.source }
-                corrected_string = "platform_family?(#{platforms.join(', ')})"
-                corrector.replace(node.loc.expression, corrected_string)
-              end
-
-              os_eql?(node) do |plat|
-                corrected_string = "platform_family?('#{sanitized_platform(plat.value)}')"
-                corrector.replace(node.loc.expression, corrected_string)
-              end
-            end
-          end
         end
       end
     end

data/lib/rubocop/cop/chef/style/unnecessary_platform_case_statement.rb

@@ -43,7 +43,8 @@ module RuboCop
         #
         #   include_recipe 'yum' if platform_family?('rhel')
         #
-        class UnnecessaryPlatformCaseStatement < Cop
+        class UnnecessaryPlatformCaseStatement < Base
+          extend AutoCorrector
           include RangeHelp
 
           MSG = 'Use the platform?() and platform_family?() helpers instead of a case statement that only includes a single when statement.'
@@ -53,14 +54,9 @@ module RuboCop
           PATTERN
 
           def on_case(node)
-            platform_case?(node) do
-              add_offense(node, location: :expression, message: MSG, severity: :refactor) if node&.when_branches&.count == 1
-            end
-          end
-
-          def autocorrect(node)
-            lambda do |corrector|
-              platform_case?(node) do |node_, type|
+            platform_case?(node) do |node_, type|
+              return unless node&.when_branches&.count == 1
+              add_offense(node.loc.expression, message: MSG, severity: :refactor) do |corrector|
                 # we have at least one supermarket cookbook with an entirely empty platform case statement
                 # we can't actually fix that so let's do nothing here.
                 unless empty_case_statement?(node)