cookstyle-ng 8.0.0

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+#
+# Copyright:: 2020, Chef Software, Inc.
+# Author:: Tim Smith (<tsmith84@gmail.com>)
+#
+# 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 Style
+        # Don't loop over an array to set cookbook dependencies or supported platforms if you have fewer than three values to set. Setting multiple `supports` or `depends` values is simpler and easier to understand for new users.
+        #
+        # @example
+        #
+        #   ### incorrect
+        #
+        #   %w( debian ubuntu ).each do |os|
+        #     supports os
+        #   end
+        #
+        #   %w( apt yum ).each do |cb|
+        #     depends cb
+        #   end
+        #
+        #   ### correct
+        #
+        #   supports 'debian'
+        #   supports 'ubuntu'
+        #
+        #   depends 'apt'
+        #   depends 'yum'
+        #
+        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
+            (block
+              (send
+                $(array ...) :each)
+              (args
+                (arg _))
+              (send nil? ${:supports :depends} (lvar _)))
+          PATTERN
+
+          def on_block(node)
+            supports_depends_array?(node) do |array, type|
+              return unless array.values.count < 3
+              add_offense(node, severity: :refactor) do |corrector|
+                corrected_value = array.values.map { |x| "#{type} '#{x.source}'" }
+                corrector.replace(node, corrected_value.join("\n"))
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+#
+# Copyright:: 2019, Chef Software, Inc.
+# Author:: Tim Smith (<tsmith84@gmail.com>)
+#
+# 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 Style
+        # When checking the major version number of a platform you can take the node['platform_version'] attribute and transform it to an integer to strip it down to just the major version number. This simple way of determining the major version number of a platform should be used instead of splitting the platform into multiple fields with '.' as the delimiter.
+        #
+        # @example
+        #
+        #   ### incorrect
+        #   node['platform_version'].split('.').first
+        #   node['platform_version'].split('.')[0]
+        #   node['platform_version'].split('.').first.to_i
+        #   node['platform_version'].split('.')[0].to_i
+        #
+        #   ### correct
+        #
+        #   # 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
+        #     # some code
+        #   end
+        #
+        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]"
+          RESTRICT_ON_SEND = [:split].freeze
+
+          def_node_matcher :platform_version_check?, <<-PATTERN
+            (send (send (send nil? :node) :[] (str "platform_version") ) :split (str ".") )
+          PATTERN
+
+          def on_send(node)
+            platform_version_check?(node) do
+              if parent_method_equals?(node, :[])
+                node = node.parent
+                if node&.arguments.count == 1 &&
+                   node&.arguments&.first&.int_type? &&
+                   node&.arguments&.first.source == '0'
+                  add_offense_to_i_if_present(node)
+                end
+              elsif parent_method_equals?(node, :first)
+                node = node.parent
+                add_offense_to_i_if_present(node)
+              end
+            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, severity: :refactor) do |corrector|
+              corrector.replace(node, "node['platform_version'].to_i")
+            end
+          end
+
+          # see if the parent is a method and if it equals the passed in name
+          #
+          # @param [Rubocop::AST:Node] node The rubocop ast node to search
+          # @param [Symbol] name The method name
+          #
+          def parent_method_equals?(node, name)
+            return false if node.parent.nil?
+            return false unless node.parent.send_type?
+            name == node.parent.method_name
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+#
+# Copyright:: 2019, Chef Software, Inc.
+# Author:: Tim Smith (<tsmith84@gmail.com>)
+#
+# 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 Style
+        # 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.
+        #
+        # @example
+        #
+        #   ### incorrect
+        #   property :foo, [TrueClass, FalseClass]
+        #
+        #   ### correct
+        #   property :foo, [true, false]
+        #
+        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 |types|
+              add_offense(node, severity: :refactor) do |corrector|
+                corrector.replace(types, '[true, false]')
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+#
+# Copyright:: 2020, Chef Software, Inc.
+# Author:: Tim Smith (<tsmith84@gmail.com>)
+#
+# 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 Style
+        # Use the platform_family?() helpers instead of node['os] == 'foo' for platform_families that match one-to-one with OS values. These helpers are easier to read and can accept multiple platform arguments, which greatly simplifies complex platform logic. All values of `os` from Ohai match one-to-one with `platform_family` values except for `linux`, which has no single equivalent `platform_family`.
+        #
+        # @example
+        #
+        #   ### incorrect
+        #   node['os'] == 'darwin'
+        #   node['os'] == 'windows'
+        #   node['os'].eql?('aix')
+        #   %w(netbsd openbsd freebsd).include?(node['os'])
+        #
+        #   ### correct
+        #   platform_family?('mac_os_x')
+        #   platform_family?('windows')
+        #   platform_family?('aix')
+        #   platform_family?('netbsd', 'openbsd', 'freebsd)
+        #
+        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."
+          RESTRICT_ON_SEND = [:==, :!=, :eql?, :include?].freeze
+
+          # sorted list of all the os values that match 1:1 with a platform_family
+          UNNECESSARY_OS_VALUES = %w(aix darwin dragonflybsd freebsd netbsd openbsd solaris2 windows).freeze
+
+          def_node_matcher :os_equals?, <<-PATTERN
+            (send (send (send nil? :node) :[] (str "os") ) ${:== :!=} $str )
+          PATTERN
+
+          def_node_matcher :os_eql?, <<-PATTERN
+          (send (send (send nil? :node) :[] (str "os") ) :eql? $str )
+          PATTERN
+
+          def_node_matcher :os_include?, <<-PATTERN
+            (send $(array ...) :include? (send (send nil? :node) :[] (str "os")))
+          PATTERN
+
+          def on_send(node)
+            os_equals?(node) do |operator, val|
+              return unless UNNECESSARY_OS_VALUES.include?(val.value)
+              add_offense(node, severity: :refactor) do |corrector|
+                corrected_string = (operator == :!= ? '!' : '') + "platform_family?('#{sanitized_platform(val.value)}')"
+                corrector.replace(node, corrected_string)
+              end
+            end
+
+            os_eql?(node) do |val|
+              return unless UNNECESSARY_OS_VALUES.include?(val.value)
+              add_offense(node, severity: :refactor) do |corrector|
+                corrected_string = "platform_family?('#{sanitized_platform(val.value)}')"
+                corrector.replace(node, 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
+              return unless (UNNECESSARY_OS_VALUES & array_of_plats) == array_of_plats
+              add_offense(node, 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, corrected_string)
+              end
+            end
+          end
+
+          # return the passed value unless the value is darwin and then return mac_os_x
+          def sanitized_platform(plat)
+            plat == 'darwin' ? 'mac_os_x' : plat
+          end
+
+          # given an ast array spit out a ruby array
+          def array_from_ast(ast)
+            vals = []
+            ast.each_child_node { |x| vals << x.value }
+            vals.sort
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+#
+# Copyright:: 2019, Chef Software, Inc.
+# Author:: Tim Smith (<tsmith84@gmail.com>)
+#
+# 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 Style
+        # Use the platform?() and platform_family?() helpers instead of a case statement that only includes a single when statement.
+        #
+        # @example
+        #
+        #   ### incorrect
+        #   case node['platform']
+        #   when 'ubuntu'
+        #     log "We're on Ubuntu"
+        #     apt_update
+        #   end
+        #
+        #   case node['platform_family']
+        #   when 'rhel'
+        #     include_recipe 'yum'
+        #   end
+        #
+        #   ### correct
+        #   if platform?('ubuntu')
+        #     log "We're on Ubuntu"
+        #     apt_update
+        #   end
+        #
+        #   include_recipe 'yum' if platform_family?('rhel')
+        #
+        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.'
+
+          def_node_matcher :platform_case?, <<-PATTERN
+          ( case $( send (send nil? :node) :[] $(str {"platform" "platform_family"})) ... )
+          PATTERN
+
+          def on_case(node)
+            platform_case?(node) do |node_, type|
+              return unless node&.when_branches&.count == 1
+              add_offense(node, 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)
+                  condition_string = node.when_branches.first.conditions.map(&:source).join(', ')
+
+                  # single line bodies without an else statement should be transformed into `X if platform?('ubuntu')` style statements
+                  # while multi-line statements should just have the case and when bits replace with `if platform?('ubuntu')`
+                  if !node.else? && !node.when_branches.first.body.multiline?
+                    new_source = "#{node.when_branches.first.body.source} if #{type.value}?(#{condition_string})"
+                    corrector.replace(node, new_source)
+                  else
+                    # find the range from the beginning of the case to the end of the node['platform'] or node['platform_family']
+                    case_range = node.loc.keyword.join(node_.loc.expression.end)
+
+                    # replace the complete conditional range with a new if statement
+                    corrector.replace(case_range, "if #{type.value}?(#{condition_string})")
+
+                    # find the range from the start of the when to the end of the last argument
+                    conditional_range = node.when_branches.first.conditions[-1].source_range.join(node.when_branches.first.loc.keyword.begin)
+
+                    # remove the when XYZ condition along with any leading spaces so that we remove the whole empty line
+                    corrector.remove(range_with_surrounding_space(range: conditional_range, side: :left))
+                  end
+                end
+              end
+            end
+          end
+
+          private
+
+          # determine if each branch of the case statement contains no code
+          #
+          # @private
+          def empty_case_statement?(node)
+            node.else_branch.nil? && node.when_branches.all? { |x| x.body.nil? }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+#
+# Copyright:: 2019, Chef Software, Inc.
+# Author:: Tim Smith (<tsmith84@gmail.com>)
+#
+# 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 Style
+        # Use the platform?() and platform_family?() helpers instead of node['platform] == 'foo' and node['platform_family'] == 'bar'. These helpers are easier to read and can accept multiple platform arguments, which greatly simplifies complex platform logic.
+        #
+        # @example
+        #
+        #   ### incorrect
+        #   node['platform'] == 'ubuntu'
+        #   node['platform_family'] == 'debian'
+        #   node['platform'] != 'ubuntu'
+        #   node['platform_family'] != 'debian'
+        #   %w(rhel suse).include?(node['platform_family'])
+        #   node['platform'].eql?('ubuntu')
+        #
+        #   ### correct
+        #   platform?('ubuntu')
+        #   !platform?('ubuntu')
+        #   platform_family?('debian')
+        #   !platform_family?('debian')
+        #   platform_family?('rhel', 'suse')
+        #
+        class UsePlatformHelpers < Base
+          extend AutoCorrector
+
+          MSG = "Use platform? and platform_family? helpers to check a node's platform"
+          RESTRICT_ON_SEND = [:==, :!=, :eql?, :include?].freeze
+
+          def_node_matcher :platform_equals?, <<-PATTERN
+            (send (send (send nil? :node) :[] $(str {"platform" "platform_family"}) ) ${:== :!=} $str )
+          PATTERN
+
+          def_node_matcher :platform_include?, <<-PATTERN
+            (send $(array ...) :include? (send (send nil? :node) :[] $(str {"platform" "platform_family"})))
+          PATTERN
+
+          def_node_matcher :platform_eql?, <<-PATTERN
+          (send (send (send nil? :node) :[] $(str {"platform" "platform_family"}) ) :eql? $str )
+          PATTERN
+
+          def on_send(node)
+            platform_equals?(node) do |type, operator, plat|
+              add_offense(node, severity: :refactor) do |corrector|
+                corrected_string = (operator == :!= ? '!' : '') + "#{type.value}?('#{plat.value}')"
+                corrector.replace(node, corrected_string)
+              end
+            end
+
+            platform_include?(node) do |plats, type|
+              add_offense(node, severity: :refactor) do |corrector|
+                platforms = plats.values.map { |x| x.str_type? ? "'#{x.value}'" : x.source }
+                corrected_string = "#{type.value}?(#{platforms.join(', ')})"
+                corrector.replace(node, corrected_string)
+              end
+            end
+
+            platform_eql?(node) do |type, plat|
+              add_offense(node, severity: :refactor) do |corrector|
+                corrected_string = "#{type.value}?('#{plat.value}')"
+                corrector.replace(node, corrected_string)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/inspec/deprecation/attribute_default.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+#
+# Copyright:: 2021, Chef Software Inc.
+# Author:: Tim Smith (<tsmith84@gmail.com>)
+#
+# 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 InSpec
+      module Deprecations
+        # The Chef InSpec inputs `default` option has been replaced with the `value` option.
+        #
+        # @example
+        #
+        #   ### incorrect
+        #   login_defs_umask = input('login_defs_umask', default: '077', description: 'Default umask to set in login.defs')
+        #
+        #   ### correct
+        #   login_defs_umask = input('login_defs_umask', value: '077', description: 'Default umask to set in login.defs')
+        #
+        class AttributeDefault < Base
+          extend AutoCorrector
+
+          MSG = 'The InSpec inputs `default` option has been replaced with the `value` option.'
+          RESTRICT_ON_SEND = [:attribute, :input].freeze
+
+          def_node_matcher :default?, <<-PATTERN
+            (send nil? {:attribute :input} _ (hash <(pair $(sym :default) ...) ...>) )
+          PATTERN
+
+          def on_send(node)
+            default?(node) do |n|
+              add_offense(n, severity: :warning) do |corrector|
+                corrector.replace(n, 'value')
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/inspec/deprecation/attribute_helper.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+#
+# Copyright:: 2021, Chef Software Inc.
+# Author:: Tim Smith (<tsmith84@gmail.com>)
+#
+# 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 InSpec
+      module Deprecations
+        # Chef InSpec attributes have been renamed to inputs. Use the `input` method not the deprecation `attribute` method to access these values.
+        #
+        # @example
+        #
+        #   ### incorrect
+        #   login_defs_umask = attribute('login_defs_umask', value: '077', description: 'Default umask to set in login.defs')
+        #
+        #   ### correct
+        #   login_defs_umask = input('login_defs_umask', value: '077', description: 'Default umask to set in login.defs')
+        #
+        class AttributeHelper < Base
+          extend AutoCorrector
+
+          MSG = 'InSpec attributes have been renamed to inputs. Use the `input` method not the deprecation `attribute` method to access these values.'
+          RESTRICT_ON_SEND = [:attribute].freeze
+
+          def on_send(node)
+            add_offense(node, severity: :warning) do |corrector|
+              corrector.replace(node.loc.expression, node.loc.expression.source.gsub(/^attribute/, 'input'))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/target_chef_version.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# shamelessly borrowed from rubocop-rails. Thanks!
+
+module RuboCop
+  module Cop
+    # Common functionality for checking target chef version.
+    module TargetChefVersion
+      def required_minimum_chef_version
+        @minimum_target_chef_version
+      end
+
+      def minimum_target_chef_version(version)
+        @minimum_target_chef_version = version
+      end
+
+      def support_target_chef_version?(version)
+        Gem::Version.new(@minimum_target_chef_version) <= Gem::Version.new(version)
+      end
+    end
+  end
+end

data/lib/rubocop/monkey_patches/allow_invalid_ruby.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+require 'rubocop/rspec/expect_offense'
+# rubocop:disable Lint/DuplicateMethods
+
+module RuboCop
+  module RSpec
+    module ExpectOffense
+      # Yields to a block with `parse_processed_source` patched to not raise an
+      # exception.
+      #
+      # RSpec's `expect_offense` helper calls a method called
+      # `parse_processed_source` that parses source code and raises an exception
+      # if it is not valid Ruby. Raising an exception prevents RuboCop from
+      # calling the cop's `on_other_file` method for checking non-Ruby files.
+      def allow_invalid_ruby(&block)
+        alias :parse_processed_source :_parse_invalid_source
+        yield block
+        alias :parse_processed_source :_orig_parse_processed_source
+      end
+
+      alias :_orig_parse_processed_source :parse_processed_source
+
+      def _parse_invalid_source(source, file = nil)
+        parse_source(source, file)
+      end
+    end
+  end
+end

data/lib/rubocop/monkey_patches/base.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+module RuboCop
+  module Cop
+    class Base
+      # This is a copy of the #target_rails_version method from rubocop-rails
+      def target_chef_version
+        @config.target_chef_version
+      end
+    end
+  end
+end