cookstyle 6.6.9 → 6.11.4

data/lib/cookstyle.rb

@@ -11,7 +11,8 @@ require 'rubocop/monkey_patches/comment_config.rb'
 # monkey patches needed for the TargetChefVersion config option
 require 'rubocop/monkey_patches/config.rb'
 require 'rubocop/monkey_patches/cop.rb'
-require 'rubocop/monkey_patches/commissioner.rb'
+require 'rubocop/monkey_patches/team.rb'
+require 'rubocop/monkey_patches/registry_cop.rb'
 
 module RuboCop
   class ConfigLoader

data/lib/cookstyle/version.rb

@@ -1,4 +1,4 @@
 module Cookstyle
-  VERSION = "6.6.9".freeze # rubocop: disable Style/StringLiterals
-  RUBOCOP_VERSION = '0.83.0'.freeze
+  VERSION = "6.11.4".freeze # rubocop: disable Style/StringLiterals
+  RUBOCOP_VERSION = '0.87.1'.freeze
 end

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

@@ -25,6 +25,8 @@ module RuboCop
         #   # bad
         #   ::Chef::Recipe.send(:include, Filebeat::Helpers)
         #   ::Chef::Provider.send(:include, Filebeat::Helpers)
+        #   ::Chef::Recipe.include Filebeat::Helpers
+        #   ::Chef::Provider.include Filebeat::Helpers
         #
         #   # good
         #   ::Chef::DSL::Recipe.send(:include, Filebeat::Helpers) # covers previous Recipe & Provider classes
@@ -36,10 +38,18 @@ module RuboCop
             (send (const (const (cbase) :Chef) {:Recipe :Provider}) :send (sym :include) ... )
           PATTERN
 
+          def_node_matcher :legacy_class_includes?, <<-PATTERN
+            (send (const (const (cbase) :Chef) {:Recipe :Provider}) :include ... )
+          PATTERN
+
           def on_send(node)
             legacy_class_sends?(node) do
               add_offense(node, location: :expression, message: MSG, severity: :refactor)
             end
+
+            legacy_class_includes?(node) do
+              add_offense(node, location: :expression, message: MSG, severity: :refactor)
+            end
           end
 
           def autocorrect(node)

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

@@ -36,7 +36,7 @@ module RuboCop
 
           def on_send(node)
             version?(node) do |ver|
-              if ver.value !~ /\A\d+\.\d+(\.\d+)?\z/ # entirely borrowed from Foodcritic.
+              unless /\A\d+\.\d+(\.\d+)?\z/.match?(ver.value) # entirely borrowed from Foodcritic.
                 add_offense(ver, location: :expression, message: MSG, severity: :refactor)
               end
             end

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

@@ -19,7 +19,7 @@ module RuboCop
   module Cop
     module Chef
       module ChefCorrectness
-        # When setting a node attribute as a default value for a custom resource property, make sure to wrap the node attribute in `lazy {}` so that the node attribute is available when the resource executes.
+        # 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.
         #
         # @example
         #
@@ -32,10 +32,10 @@ module RuboCop
         class LazyEvalNodeAttributeDefaults < Cop
           include RuboCop::Chef::CookbookHelpers
 
-          MSG = 'When setting a node attribute as a default value for a custom resource property, make sure to wrap the node attribute in `lazy {}` so that the node attribute is available when the resource executes.'.freeze
+          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.'.freeze
 
           def_node_matcher :non_lazy_node_attribute_default?, <<-PATTERN
-           (send nil? :property (sym _) ... (hash <(pair (sym :default) $(send (send _ :node) :[] _) ) ...>))
+            (send nil? :property (sym _) ... (hash <(pair (sym :default) $(send (send _ :node) :[] _) ) ...>))
           PATTERN
 
           def on_send(node)

data/lib/rubocop/cop/chef/deprecation/hwrp_without_provides.rb

@@ -0,0 +1,141 @@
+#
+# Copyright:: Copyright (c) Chef Software Inc.
+# Author:: Tim Smith (<tsmith@chef.io>)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+module RuboCop
+  module Cop
+    module Chef
+      module ChefDeprecations
+        # Chef Infra Client 16 and later a legacy HWRP resource must use `provides` to define how the resource is called in recipes or other resources. To maintain compatibility with Chef Infra Client < 16 use both `resource_name` and `provides`.
+        #
+        # @example
+        #
+        #   # bad
+        #   class Chef
+        #     class Resource
+        #       class UlimitRule < Chef::Resource
+        #         property :type, [Symbol, String], required: true
+        #         property :item, [Symbol, String], required: true
+        #
+        #         # additional resource code
+        #       end
+        #     end
+        #   end
+        #
+        #   # bad
+        #   class Chef
+        #     class Resource
+        #       class UlimitRule < Chef::Resource
+        #         resource_name :ulimit_rule
+        #
+        #         property :type, [Symbol, String], required: true
+        #         property :item, [Symbol, String], required: true
+        #
+        #         # additional resource code
+        #       end
+        #     end
+        #   end
+        #
+        #  # good when Chef Infra Client < 15 (but compatible with 16+ as well)
+        #   class Chef
+        #     class Resource
+        #       class UlimitRule < Chef::Resource
+        #         resource_name :ulimit_rule
+        #         provides :ulimit_rule
+        #
+        #         property :type, [Symbol, String], required: true
+        #         property :item, [Symbol, String], required: true
+        #
+        #         # additional resource code
+        #       end
+        #     end
+        #   end
+        #
+        #  # good when Chef Infra Client 16+
+        #   class Chef
+        #     class Resource
+        #       class UlimitRule < Chef::Resource
+        #         provides :ulimit_rule
+        #
+        #         property :type, [Symbol, String], required: true
+        #         property :item, [Symbol, String], required: true
+        #
+        #         # additional resource code
+        #       end
+        #     end
+        #   end
+        #
+        #  # better
+        #  Convert your legacy HWRPs to custom resources
+        #
+        class HWRPWithoutProvides < Cop
+          MSG = 'In Chef Infra Client 16 and later a legacy HWRP resource must use `provides` to define how the resource is called in recipes or other resources. To maintain compatibility with Chef Infra Client < 16 use both `resource_name` and `provides`.'.freeze
+
+          def_node_matcher :HWRP?, <<-PATTERN
+          (class
+            (const nil? :Chef) nil?
+            (class
+              (const nil? :Resource) nil?
+              $(class
+                (const nil? ... )
+                (const
+                  (const nil? :Chef) :Resource)
+                  (begin ... ))))
+          PATTERN
+
+          def_node_search :provides, '(send nil? :provides (sym $_) ...)'
+          def_node_search :resource_name_ast, '$(send nil? :resource_name ...)'
+          def_node_search :resource_name, '(send nil? :resource_name (sym $_))'
+
+          def on_class(node)
+            HWRP?(node) do |inherit|
+              add_offense(inherit, location: :expression, message: MSG, severity: :warning) unless has_provides?
+            end
+          end
+
+          def has_provides?
+            provides_ast = provides(processed_source.ast)
+            return false if provides_ast.count == 0
+
+            resource_ast = resource_name(processed_source.ast)
+
+            if resource_ast.count == 0
+              true # no resource_name, but provides
+            else
+              # since we have a resource and provides make sure the there is a provides that
+              # matches the resource name
+              provides_ast.include?(resource_ast.first)
+            end
+          end
+
+          def indentation(node)
+            node.source_range.source_line =~ /\S/
+          end
+
+          def autocorrect(node)
+            lambda do |corrector|
+              resource_name_ast(node) do |ast_match|
+                # build a new string to add after that includes the new line and the proper indentation
+                new_string = "\n" + ast_match.source.dup.gsub('resource_name', 'provides').prepend(' ' * indentation(ast_match))
+                corrector.insert_after(ast_match.source_range, new_string)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/chef/deprecation/resource_uses_only_resource_name.rb

@@ -0,0 +1,86 @@
+#
+# Copyright:: Copyright (c) Chef Software Inc.
+# Author:: Tim Smith (<tsmith@chef.io>)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+module RuboCop
+  module Cop
+    module Chef
+      module ChefDeprecations
+        # Starting with Chef Infra Client 16, using `resource_name` without also using `provides` will result in resource failures. Make sure to use both `resource_name` and `provides` to change the name of the resource. You can also omit `resource_name` entirely if the value set matches the name Chef Infra Client automatically assigns based on COOKBOOKNAME_FILENAME.
+        #
+        # @example
+        #
+        #   # bad
+        #   mycookbook/resources/myresource.rb:
+        #   resource_name :mycookbook_myresource
+        #
+        class ResourceUsesOnlyResourceName < Cop
+          include RuboCop::Chef::CookbookHelpers
+          include RangeHelp
+
+          MSG = 'Starting with Chef Infra Client 16, using `resource_name` without also using `provides` will result in resource failures. Make sure to use both `resource_name` and `provides` to change the name of the resource. You can also omit `resource_name` entirely if the value set matches the name Chef Infra Client automatically assigns based on COOKBOOKNAME_FILENAME.'.freeze
+
+          def_node_matcher :resource_name?, '(send nil? :resource_name (sym $_ ))'
+
+          def_node_search :cb_name_match, '(send nil? :name (str $_))'
+
+          def_node_search :provides, '(send nil? :provides (sym $_) ...)'
+
+          # determine the cookbook name either by parsing metdata.rb or by parsing metata.json
+          #
+          # @returns [String] the cookbook name
+          def cookbook_name
+            cb_path = File.expand_path(File.join(processed_source.file_path, '../..'))
+
+            if File.exist?(File.join(cb_path, 'metadata.rb'))
+              cb_metadata_ast = ProcessedSource.from_file(File.join(cb_path, 'metadata.rb'), @config.target_ruby_version).ast
+              cb_name_match(cb_metadata_ast).first
+            elsif File.exist?(File.join(cb_path, 'metadata.json')) # this exists only for supermarket files that lack metadata.rb
+              JSON.parse(File.read(File.join(cb_path, 'metadata.json')))['name']
+            end
+          end
+
+          # given a resource name make sure there's a provides that matches that name
+          #
+          # @returns [TrueClass, FalseClass]
+          def valid_provides?(resource_name)
+            provides_ast = provides(processed_source.ast)
+            return false unless provides_ast
+
+            provides_ast.include?(resource_name)
+          end
+
+          def on_send(node)
+            resource_name?(node) do |r_name|
+              add_offense(node, location: :expression, message: MSG, severity: :warning) unless valid_provides?(r_name)
+            end
+          end
+
+          def autocorrect(node)
+            lambda do |corrector|
+              resource_name?(node) do |name|
+                if name.to_s == "#{cookbook_name}_#{File.basename(processed_source.path, '.rb')}"
+                  corrector.remove(range_with_surrounding_space(range: node.loc.expression, side: :left))
+                else
+                  corrector.insert_after(node.source_range, "\n#{node.source.gsub('resource_name', 'provides')}")
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/chef/modernize/conditional_using_test.rb

@@ -0,0 +1,56 @@
+#
+# Copyright:: 2019, Chef Software, Inc.
+# Author:: Tim Smith (<tsmith@chef.io>)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+module RuboCop
+  module Cop
+    module Chef
+      module ChefModernize
+        # Use ::File.exist?('/foo/bar') instead of the slower 'test -f /foo/bar' which requires shelling out
+        #
+        # @example
+        #
+        #   # bad
+        #   only_if 'test -f /bin/foo'
+        #
+        #   # good
+        #   only_if { ::File.exist?('bin/foo') }
+        #
+        class ConditionalUsingTest < Cop
+          MSG = "Use ::File.exist?('/foo/bar') instead of the slower 'test -f /foo/bar' which requires shelling out".freeze
+
+          def_node_matcher :resource_conditional?, <<~PATTERN
+          (send nil? {:not_if :only_if} $str )
+          PATTERN
+
+          def on_send(node)
+            resource_conditional?(node) do |conditional|
+              add_offense(node, location: :expression, message: MSG, severity: :refactor) if conditional.value.match?(/^test -[ef] \S*$/)
+            end
+          end
+
+          def autocorrect(node)
+            lambda do |corrector|
+              resource_conditional?(node) do |conditional|
+                new_string = "{ ::File.exist?('#{conditional.value.match(/^test -[ef] (\S*)$/)[1]}') }"
+                corrector.replace(conditional.loc.expression, new_string)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/chef/modernize/includes_mixin_shellout.rb

@@ -1,5 +1,5 @@
 #
-# Copyright:: 2019, Chef Software Inc.
+# Copyright:: 2019-2020, Chef Software Inc.
 # Author:: Tim Smith (<tsmith@chef.io>)
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -42,13 +42,34 @@ module RuboCop
             (send nil? :require ( str {"chef/mixin/shell_out" "chef/mixin/powershell_out"} ))
           PATTERN
 
+          def_node_search :hwrp_classes?, <<-PATTERN
+            (class
+              (const ... )
+              {(const
+                (const
+                  (const nil? :Chef) :Provider) :LWRPBase)
+               (const
+                 (const nil? :Chef) :Provider)
+               }
+              ...)
+          PATTERN
+
+          def check_for_offenses(node)
+            containing_dir = File.basename(File.dirname(processed_source.path))
+
+            # only add offenses when we're in a custom resource or HWRP, but not a plain old library
+            if containing_dir == 'resources' || hwrp_classes?(processed_source.ast)
+              add_offense(node, location: :expression, message: MSG, severity: :refactor)
+            end
+          end
+
           def on_send(node)
             require_shellout?(node) do
-              add_offense(node, location: :expression, message: MSG, severity: :refactor)
+              check_for_offenses(node)
             end
 
             include_shellout?(node) do
-              add_offense(node, location: :expression, message: MSG, severity: :refactor)
+              check_for_offenses(node)
             end
           end
 

data/lib/rubocop/cop/chef/modernize/node_init_package.rb

@@ -27,18 +27,20 @@ module RuboCop
         #   ::File.open('/proc/1/comm').chomp == 'systemd'
         #   File.open('/proc/1/comm').gets.chomp == 'systemd'
         #   File.open('/proc/1/comm').chomp == 'systemd'
-        #   File.exist?('/proc/1/comm') && File.open('/proc/1/comm').chomp == 'systemd'
-        #
         #   IO.read('/proc/1/comm').chomp == 'systemd'
         #   IO.read('/proc/1/comm').gets.chomp == 'systemd'
         #   ::IO.read('/proc/1/comm').chomp == 'systemd'
         #   ::IO.read('/proc/1/comm').gets.chomp == 'systemd'
         #   File.exist?('/proc/1/comm') && File.open('/proc/1/comm').chomp == 'systemd'
+        #   only_if 'test -f /bin/systemctl && /bin/systemctl'
         #
         #   # good
         #   node['init_package'] == 'systemd'
+        #   only_if { node['init_package'] == 'systemd' }
         #
-        class NodeInitPackage < Cop
+        class NodeInitPackage < Base
+          extend RuboCop::Cop::AutoCorrector
+
           MSG = "Use node['init_package'] to check for systemd instead of reading the contents of '/proc/1/comm'".freeze
 
           def_node_matcher :file_reads_proc_1_comm?, <<-PATTERN
@@ -58,18 +60,24 @@ module RuboCop
                 :== (str "systemd"))
           PATTERN
 
+          def_node_matcher :file_systemd_conditional?, <<~PATTERN
+          (send nil? {:not_if :only_if} $(str "test -f /bin/systemctl && /bin/systemctl"))
+          PATTERN
+
           def on_send(node)
             compare_init_system?(node) do
               # if there's a ::File.exist?('/proc/1/comm') check first we want to match that as well
               node = node.parent if node.parent&.and_type? && proc_1_comm_exists?(node.parent.conditions.first)
 
-              add_offense(node, location: :expression, message: MSG, severity: :refactor)
+              add_offense(node.loc.expression, message: MSG, severity: :refactor) do |corrector|
+                corrector.replace(node, "node['init_package'] == 'systemd'")
+              end
             end
-          end
 
-          def autocorrect(node)
-            lambda do |corrector|
-              corrector.replace(node.loc.expression, "node['init_package'] == 'systemd'")
+            file_systemd_conditional?(node) do |conditional|
+              add_offense(node.loc.expression, message: MSG, severity: :refactor) do |corrector|
+                corrector.replace(conditional.loc.expression, "{ node['init_package'] == 'systemd' }")
+              end
             end
           end
         end