cookstyle 8.6.10 → 9.0.0

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+#
+# Copyright:: Copyright (c) 2016-2025 Progress Software Corporation and/or its subsidiaries or affiliates. All Rights Reserved.
+# 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 Correctness
+        # Setting `unified_mode true` conditionally leaves a resource running in unified mode on newer
+        # Chef Infra Client releases and in legacy mode on older ones. That's not a coherent thing to
+        # want: the resource has to be written, tested, and debugged against both execution models.
+        #
+        # Pick one. Set `unified_mode true` unconditionally and drop support for releases that predate
+        # it, or set `unified_mode false if respond_to?(:unified_mode)` to deliberately opt out of
+        # unified mode everywhere and keep writing the resource in the traditional style.
+        #
+        # Only `unified_mode true` is flagged. `unified_mode false` under a guard is the supported way
+        # to opt out and is left alone.
+        #
+        # @example
+        #
+        #   # bad
+        #   unified_mode true if respond_to?(:unified_mode)
+        #
+        #   # good
+        #   unified_mode true
+        #
+        #   # good - deliberately opting out of unified mode
+        #   unified_mode false if respond_to?(:unified_mode)
+        #
+        class ConditionalUnifiedModeTrue < Base
+          extend AutoCorrector
+          extend TargetChefVersion
+
+          minimum_target_chef_version '15.3'
+
+          MSG = 'Set `unified_mode true` unconditionally. Making it conditional gives you unified mode on newer Chef Infra Client releases and legacy mode on older ones, so the resource has to be tested and reasoned about both ways.'
+          RESTRICT_ON_SEND = [:unified_mode].freeze
+
+          def_node_matcher :unified_mode_true?, '(send nil? :unified_mode (true))'
+
+          def on_send(node)
+            return unless unified_mode_true?(node)
+
+            conditional = node.each_ancestor(:if).first
+            return unless conditional
+
+            add_offense(node, severity: :refactor) do |corrector|
+              # only unwrap the conditional when it wraps nothing but this property, otherwise
+              # we'd delete whatever else the branch was guarding. an elsif is never safe to unwrap:
+              # its node covers only the elsif itself, so replacing it drops that branch's condition
+              # and folds the property into the preceding branch
+              next if conditional.elsif?
+              next unless sole_branch_body?(conditional, node)
+
+              corrector.replace(conditional, node.source)
+            end
+          end
+
+          private
+
+          # Is the property the entire body of the conditional? `if` puts the body in the first
+          # child after the condition and `unless` puts it in the second, so check both. A branch
+          # holding anything else is a `begin` node rather than the property itself, and an `if`
+          # with an `else` (or an `elsif` chain) leaves the other branch non-nil.
+          #
+          # @param [RuboCop::AST::IfNode] conditional
+          # @param [RuboCop::AST::SendNode] node the `unified_mode true` property
+          #
+          # @return [Boolean]
+          def sole_branch_body?(conditional, node)
+            conditional.children[1..2].compact == [node]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -19,13 +19,18 @@ module RuboCop
   module Cop
     module Chef
       module Correctness
-        # Resource guards (not_if/only_if) should not be empty strings as empty strings will always evaluate to true.
-        # This will cause confusion in your cookbooks as the guard will always pass.
+        # Resource guards (not_if/only_if) should not be empty. An empty string always evaluates to true
+        # and an empty block always evaluates to false, so in either case the guard stops doing the job
+        # it was written for and the resource silently runs, or fails to run, on every converge.
         #
         # Empty strings in Ruby are "truthy", which means:
         # - `only_if ''` will ALWAYS execute the resource (guard always passes)
         # - `not_if ''` will NEVER execute the resource (guard always blocks)
         #
+        # An empty block behaves the other way around, since a block with no body returns `nil`:
+        # - `only_if { }` will NEVER execute the resource
+        # - `not_if { }` will ALWAYS execute the resource
+        #
         # This behavior is usually unintended and can lead to resources running when they shouldn't
         # or never running when they should.
         #
@@ -72,6 +77,7 @@ module RuboCop
         #
         class EmptyResourceGuard < Base
           MSG = 'Resource guards (not_if/only_if) should not be empty strings as empty strings will always evaluate to true.'
+          EMPTY_BLOCK_MSG = 'Resource guards (not_if/only_if) should not be empty blocks as an empty block returns nil, which always evaluates to false.'
           RESTRICT_ON_SEND = [:not_if, :only_if].freeze
 
           def_node_matcher :empty_string_guard?, <<-PATTERN
@@ -82,6 +88,12 @@ module RuboCop
             (block (send nil? {:not_if :only_if}) (args) (str #empty_string?))
           PATTERN
 
+          # A block with no body at all. Such a block returns nil rather than the empty string matched
+          # above, so the guard fails rather than passes.
+          def_node_matcher :empty_block_guard?, <<-PATTERN
+            (block (send nil? {:not_if :only_if}) (args) nil?)
+          PATTERN
+
           def empty_string?(str)
             str.empty?
           end
@@ -96,6 +108,10 @@ module RuboCop
             empty_string_block_guard?(node) do
               add_offense(node, severity: :refactor)
             end
+
+            empty_block_guard?(node) do
+              add_offense(node, message: EMPTY_BLOCK_MSG, severity: :refactor)
+            end
           end
         end
       end

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

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+#
+# Copyright:: Copyright (c) 2016-2025 Progress Software Corporation and/or its subsidiaries or affiliates. All Rights Reserved.
+# 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 Correctness
+        # Use the `file` or `directory` resources built into Chef Infra Client with the `:delete` action
+        # to remove files and directories instead of shelling out to `rm`. The resources are idempotent,
+        # report correctly on what they changed, and work without a shell.
+        #
+        # The two resources are not interchangeable and the one you pick has to match what is on disk.
+        # `directory` asserts the path really is a directory before deleting, so it raises
+        # `Cannot delete directory[...]` on a file even with `recursive true`, and `file` calls
+        # `File.delete`, so it raises `Errno::EISDIR` on a directory. A `directory` delete also needs
+        # `recursive true` for anything that isn't empty, or it raises `Errno::ENOTEMPTY`.
+        #
+        # Only a single `rm` of one path is flagged. A command containing a glob, a shell operator, or
+        # anything beyond the one deletion is left alone, since the `file` and `directory` resources
+        # can't express those.
+        #
+        # @example
+        #
+        #   # bad -- rm without -r, which the shell will not let you point at a directory
+        #   execute 'rm /etc/foo.conf'
+        #
+        #   # good
+        #   file '/etc/foo.conf' do
+        #     action :delete
+        #   end
+        #
+        #   # bad -- a recursive rm of a directory
+        #   execute 'delete the thing' do
+        #     command 'rm -rf /opt/thing'
+        #   end
+        #
+        #   # good
+        #   directory '/opt/thing' do
+        #     recursive true
+        #     action :delete
+        #   end
+        #
+        class ExecuteDeleteFile < Base
+          include RuboCop::Chef::CookbookHelpers
+
+          # The two resources are not interchangeable, so the message has to name the right one.
+          # `directory` asserts the path really is a directory before deleting, and `file` calls
+          # File.delete, so pointing at the wrong one fails the converge rather than doing nothing.
+          FILE_MSG = 'Use the `file` resource with the :delete action to remove a file instead of shelling out to rm'
+          DIRECTORY_MSG = 'Use the `directory` resource with `recursive true` and the :delete action to remove a directory instead of shelling out to rm. Use the `file` resource instead if the path is a file.'
+
+          RESTRICT_ON_SEND = [:execute].freeze
+
+          # a lone rm of a single path: optional flags, one target, nothing else on the line.
+          # the target excludes the shell metacharacters used for substitution and expansion, since
+          # a path the shell computes at runtime isn't something the file/directory resources can take
+          DELETE_COMMAND = %r{\A\s*(?:/bin/|/usr/bin/)?rm\s+(?<flags>(?:-[a-zA-Z]+\s+)*)(?<path>[^\s;&|<>$`(){}]+)\s*\z}.freeze
+
+          # the shell resources whose script lives in a code property
+          SCRIPT_RESOURCES = %i(bash sh csh ksh zsh).freeze
+
+          def_node_matcher :execute_with_command_name?, '(send nil? :execute (str $_))'
+
+          def on_send(node)
+            execute_with_command_name?(node) do |command|
+              message = message_for(command)
+              add_offense(node, message: message, severity: :refactor) if message
+            end
+          end
+
+          def on_block(node)
+            match_property_in_resource?(:execute, 'command', node) do |property|
+              report_property(node, property)
+            end
+
+            match_property_in_resource?(SCRIPT_RESOURCES, 'code', node) do |property|
+              report_property(node, property)
+            end
+          end
+
+          private
+
+          def report_property(node, property)
+            command = method_arg_ast_to_string(property)
+            return unless command
+
+            message = message_for(command)
+            add_offense(node, message: message, severity: :refactor) if message
+          end
+
+          # Does the command do nothing but delete one named path, and if so which resource replaces
+          # it? Globs are excluded because the file and directory resources take a single path rather
+          # than a pattern.
+          #
+          # Without -r the shell refuses to remove a directory, so a bare `rm` provably targets a
+          # file and `file` is the right answer. With -r the author is removing a tree, so
+          # `directory` is, though the path could still be a file that -rf was used on out of habit.
+          #
+          # @param [String] command
+          #
+          # @return [String, nil] the message to report, or nil when this isn't a simple delete
+          def message_for(command)
+            match = DELETE_COMMAND.match(command)
+            return if match.nil?
+            return if match[:path].match?(/[*?\[]/)
+
+            match[:flags].match?(/-[a-zA-Z]*r/i) ? DIRECTORY_MSG : FILE_MSG
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+#
+# Copyright:: Copyright (c) 2016-2025 Progress Software Corporation and/or its subsidiaries or affiliates. All Rights Reserved.
+# 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 Correctness
+        # The `checksum` property of the file downloading resources is a SHA-256 digest. An MD5 or
+        # SHA-1 digest can never match, so the resource fails the run with a checksum mismatch rather
+        # than installing anything.
+        #
+        # Only digests that are unambiguously the wrong algorithm are flagged: 32 character (MD5) and
+        # 40 character (SHA-1) hex strings. Anything else is left alone.
+        #
+        # @example
+        #
+        #   # bad
+        #   remote_file '/tmp/foo.tar.gz' do
+        #     source 'https://example.com/foo.tar.gz'
+        #     checksum 'd41d8cd98f00b204e9800998ecf8427e'
+        #   end
+        #
+        #   # good
+        #   remote_file '/tmp/foo.tar.gz' do
+        #     source 'https://example.com/foo.tar.gz'
+        #     checksum 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855'
+        #   end
+        #
+        class InvalidChecksum < Base
+          include RuboCop::Chef::CookbookHelpers
+
+          MSG = 'The checksum property takes a SHA-256 digest. An MD5 or SHA-1 digest can never match, so the run fails with a checksum mismatch.'
+
+          # the file downloading resources that validate a SHA-256 checksum
+          RESOURCES = %i(remote_file windows_package msu_package dmg_package).freeze
+
+          # hex digest lengths of the algorithms people reach for by mistake, with the article that
+          # reads correctly in front of each name
+          WRONG_ALGORITHM_LENGTHS = { 32 => 'an MD5', 40 => 'a SHA-1' }.freeze
+
+          def on_block(node)
+            match_property_in_resource?(RESOURCES, 'checksum', node) do |checksum|
+              value = checksum.arguments.first
+              next unless value&.str_type?
+
+              algorithm = WRONG_ALGORITHM_LENGTHS[value.value.length]
+              next unless algorithm && hex?(value.value)
+
+              add_offense(checksum, message: "#{MSG} This looks like #{algorithm} digest.", severity: :refactor)
+            end
+          end
+
+          private
+
+          # @param [String] string
+          #
+          # @return [Boolean]
+          def hex?(string)
+            string.match?(/\A\h+\z/)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -27,7 +27,7 @@ module RuboCop
         #   platform_family?('redhat')
         #   platform_family?('sles')
         #
-        #   # bad
+        #   # good
         #   platform_family?('rhel')
         #   platform_family?('suse')
         #

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

@@ -27,6 +27,16 @@ module RuboCop
         #   case node['platform_family']
         #   when 'redhat'
         #     puts "I'm on a RHEL-like system"
+        #   when 'debian'
+        #     puts "I'm on a Debian-like system"
+        #   end
+        #
+        #   # good
+        #   case node['platform_family']
+        #   when 'rhel'
+        #     puts "I'm on a RHEL-like system"
+        #   when 'debian'
+        #     puts "I'm on a Debian-like system"
         #   end
         #
         class InvalidPlatformFamilyInCase < Base

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

@@ -27,6 +27,16 @@ module RuboCop
         #   case node['platform']
         #   when 'rhel'
         #     puts "I'm on a Red Hat system!"
+        #   when 'ubuntu'
+        #     puts "I'm on Ubuntu!"
+        #   end
+        #
+        #   # good
+        #   case node['platform']
+        #   when 'redhat'
+        #     puts "I'm on a Red Hat system!"
+        #   when 'ubuntu'
+        #     puts "I'm on Ubuntu!"
         #   end
         #
         class InvalidPlatformInCase < Base

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

@@ -28,6 +28,7 @@ module RuboCop
         #     %w(rhel mac_os_x_server) => { 'default' => 'foo' },
         #     %w(sles) => { 'default' => 'bar' }
         #   )
+        #
         #   # good
         #   value_for_platform(
         #     %w(redhat mac_os_x) => { 'default' => 'foo' },

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

@@ -31,7 +31,7 @@ module RuboCop
           def_node_matcher :openssl_helper?, <<~PATTERN
             (const
               (const
-                (const nil? :Opscode) :OpenSSL) :Password)
+                (const {nil? cbase} :Opscode) :OpenSSL) :Password)
           PATTERN
 
           def on_const(node)

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+#
+# Copyright:: Copyright (c) 2016-2025 Progress Software Corporation and/or its subsidiaries or affiliates. All Rights Reserved.
+# 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 Correctness
+        # Ohai reports version attributes as strings, so comparing one with `<`, `>`, `<=`, or `>=`
+        # compares them character by character rather than as versions. That gives the wrong answer
+        # whenever the version numbers have different digit counts:
+        #
+        #   '7.9' >= '10'   # => true, because '7' sorts after '1'
+        #   '9' > '10'      # => true
+        #
+        # Compare the major version as an integer with `node['platform_version'].to_i`, or compare
+        # full versions with `Gem::Version`.
+        #
+        # @example
+        #
+        #   # bad
+        #   node['platform_version'] >= '10'
+        #   node['platform_version'] < '7.4'
+        #
+        #   # good
+        #   node['platform_version'].to_i >= 10
+        #   Gem::Version.new(node['platform_version']) >= Gem::Version.new('7.4')
+        #
+        #   # good - equality is a plain string match, which is fine
+        #   node['platform_version'] == '10'
+        #
+        class PlatformVersionStringComparison < Base
+          MSG = 'Ohai version attributes are strings, so comparing them with an ordering operator compares them character by character. Use .to_i for a major version comparison, or Gem::Version to compare full versions.'
+          RESTRICT_ON_SEND = %i(< > <= >=).freeze
+
+          # the flat Ohai attributes that hold a dotted version string
+          def_node_matcher :version_attribute_comparison?, <<-PATTERN
+            (send
+              (send (send nil? :node) :[] (str {"platform_version" "os_version"}))
+              {:< :> :<= :>=}
+              (str _))
+          PATTERN
+
+          def on_send(node)
+            version_attribute_comparison?(node) do
+              add_offense(node, severity: :refactor)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -26,13 +26,13 @@ module RuboCop
         #   # bad
         #   powershell_script 'Cleanup old files' do
         #     code 'Remove-Item C:\Windows\foo\bar.txt'
-        #     only_if { ::File.exist?('C:\\Windows\\foo\\bar.txt') }
+        #     only_if { ::File.exist?('C:\Windows\foo\bar.txt') }
         #   end
         #
-        #  ### correct
-        #  file 'C:\Windows\foo\bar.txt' do
-        #    action :delete
-        #  end
+        #   # good
+        #   file 'C:\Windows\foo\bar.txt' do
+        #     action :delete
+        #   end
         #
         class PowershellScriptDeleteFile < Base
           include RuboCop::Chef::CookbookHelpers

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

@@ -24,7 +24,7 @@ module RuboCop
         # @example
         #
         #   # bad
-        #   powershell_out('Test-Path "C:\\Program Files\\LAPS\\CSE\\AdmPwd.dll"').stdout.strip == 'True'
+        #   powershell_out('Test-Path "C:\Program Files\LAPS\CSE\AdmPwd.dll"').stdout.strip == 'True'
         #
         #   # good
         #   ::File.exist?('C:\Program Files\LAPS\CSE\AdmPwd.dll')

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

@@ -41,10 +41,10 @@ module RuboCop
 
           def on_block(node)
             match_property_in_resource?(nil, 'action', node) do |action_node|
-              action_node.arguments.each do |action|
-                next unless action.source == ':none'
+              each_action_symbol(action_node) do |action, prefix|
+                next unless action.value == :none
                 add_offense(action, severity: :refactor) do |corrector|
-                  corrector.replace(action, ':nothing')
+                  corrector.replace(action, "#{prefix}nothing")
                 end
               end
             end

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+#
+# Copyright:: Copyright (c) 2016-2025 Progress Software Corporation and/or its subsidiaries or affiliates. All Rights Reserved.
+# 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 Correctness
+        # A `not_if`/`only_if` guard takes either a string, which is run as a shell command, or a block,
+        # which is run as Ruby. Passing a Ruby expression directly gives the guard the expression's
+        # *result* rather than the expression, because it is evaluated while the recipe is compiled.
+        #
+        # A guard that receives `true` or `false` raises at converge time:
+        #
+        #   ArgumentError: Invalid only_if/not_if command, expected a string: true (TrueClass)
+        #
+        # Worse, an expression that happens to return a string is accepted and then run as a shell
+        # command, so the guard quietly tests something entirely different to what was intended.
+        #
+        # Only expressions that clearly produce a boolean are flagged, so a shell command built in Ruby
+        # and held in a variable is left alone.
+        #
+        # @example
+        #
+        #   # bad
+        #   not_if ::File.exist?('/etc/foo')
+        #   only_if node['foo']['version'] == '1.0'
+        #
+        #   # good
+        #   not_if { ::File.exist?('/etc/foo') }
+        #   only_if { node['foo']['version'] == '1.0' }
+        #
+        #   # good - a string guard runs as a shell command
+        #   not_if 'test -f /etc/foo'
+        #
+        class RubyGuardWithoutBlock < Base
+          extend AutoCorrector
+
+          MSG = 'A Ruby expression used as a resource guard has to be wrapped in a block. Passing it directly hands the guard the expression result, which raises at converge time or silently runs a shell command.'
+          RESTRICT_ON_SEND = [:not_if, :only_if].freeze
+
+          # comparison and negation operators always produce a boolean
+          BOOLEAN_OPERATORS = %i(== != < > <= >= =~ !~ ! equal? eql?).freeze
+
+          def_node_matcher :guard_with_argument, '(send nil? {:not_if :only_if} $_)'
+
+          def on_send(node)
+            guard_with_argument(node) do |argument|
+              next unless boolean_expression?(argument)
+
+              add_offense(node, severity: :refactor) do |corrector|
+                corrector.replace(node, "#{node.method_name} { #{argument.source} }")
+              end
+            end
+          end
+
+          private
+
+          # Can we tell that this expression produces a boolean rather than a shell command? Anything
+          # we can't be sure about, such as a bare method call or a local variable, is left alone: it
+          # may well hold a perfectly good command string.
+          #
+          # @param [RuboCop::AST::Node] node
+          #
+          # @return [Boolean]
+          def boolean_expression?(node)
+            return true if node.boolean_type? || node.defined_type?
+            return true if node.operator_keyword? # && and ||
+            return node.children.one? && boolean_expression?(node.children.first) if node.begin_type?
+            return false unless node.send_type?
+
+            node.method_name.to_s.end_with?('?') || BOOLEAN_OPERATORS.include?(node.method_name)
+          end
+        end
+      end
+    end
+  end
+end