cookstyle 7.32.8 → 8.1.1

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

@@ -1,103 +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
+# 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

@@ -1,100 +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
+# 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.last.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

@@ -1,86 +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
+# 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