rubocop 1.30.1 → 1.64.0

data/lib/rubocop/cop/style/guard_clause.rb

@@ -6,6 +6,13 @@ module RuboCop
       # Use a guard clause instead of wrapping the code inside a conditional
       # expression
       #
+      # A condition with an `elsif` or `else` branch is allowed unless
+      # one of `return`, `break`, `next`, `raise`, or `fail` is used
+      # in the body of the conditional expression.
+      #
+      # NOTE: Autocorrect works in most cases except with if-else statements
+      #   that contain logical operators such as `foo || raise('exception')`
+      #
       # @example
       #   # bad
       #   def test
@@ -48,37 +55,65 @@ module RuboCop
       #   foo || raise('exception') if something
       #   ok
       #
-      # @example AllowConsecutiveConditionals: false (default)
       #   # bad
-      #   if foo?
-      #     work
+      #   define_method(:test) do
+      #     if something
+      #       work
+      #     end
       #   end
       #
-      #   if bar?  # <- reports an offense
+      #   # good
+      #   define_method(:test) do
+      #     return unless something
+      #
       #     work
       #   end
       #
+      #   # also good
+      #   define_method(:test) do
+      #     work if something
+      #   end
+      #
+      # @example AllowConsecutiveConditionals: false (default)
+      #   # bad
+      #   def test
+      #     if foo?
+      #       work
+      #     end
+      #
+      #     if bar?  # <- reports an offense
+      #       work
+      #     end
+      #   end
+      #
       # @example AllowConsecutiveConditionals: true
       #   # good
-      #   if foo?
-      #     work
-      #   end
+      #   def test
+      #     if foo?
+      #       work
+      #     end
       #
-      #   if bar?
-      #     work
+      #     if bar?
+      #       work
+      #     end
       #   end
       #
       #   # bad
-      #   if foo?
-      #     work
-      #   end
+      #   def test
+      #     if foo?
+      #       work
+      #     end
       #
-      #   do_something
+      #     do_something
       #
-      #   if bar?  # <- reports an offense
-      #     work
+      #     if bar?  # <- reports an offense
+      #       work
+      #     end
       #   end
+      #
       class GuardClause < Base
+        extend AutoCorrector
+        include RangeHelp
         include MinBodyLength
         include StatementModifier
 
@@ -90,40 +125,56 @@ module RuboCop
 
           return unless body
 
-          if body.if_type?
-            check_ending_if(body)
-          elsif body.begin_type?
-            final_expression = body.children.last
-            check_ending_if(final_expression) if final_expression&.if_type?
-          end
+          check_ending_body(body)
         end
         alias on_defs on_def
 
+        def on_block(node)
+          return unless node.method?(:define_method) || node.method?(:define_singleton_method)
+
+          on_def(node)
+        end
+        alias on_numblock on_block
+
         def on_if(node)
           return if accepted_form?(node)
 
-          guard_clause_in_if = node.if_branch&.guard_clause?
-          guard_clause_in_else = node.else_branch&.guard_clause?
-          guard_clause = guard_clause_in_if || guard_clause_in_else
-          return unless guard_clause
+          if (guard_clause = node.if_branch&.guard_clause?)
+            kw = node.loc.keyword.source
+            guard = :if
+          elsif (guard_clause = node.else_branch&.guard_clause?)
+            kw = node.inverse_keyword
+            guard = :else
+          else
+            return
+          end
 
-          kw = if guard_clause_in_if
-                 node.loc.keyword.source
-               else
-                 opposite_keyword(node)
-               end
+          guard = nil if and_or_guard_clause?(guard_clause)
 
-          register_offense(node, guard_clause_source(guard_clause), kw)
+          register_offense(node, guard_clause_source(guard_clause), kw, guard)
         end
 
         private
 
+        def check_ending_body(body)
+          return if body.nil?
+
+          if body.if_type?
+            check_ending_if(body)
+          elsif body.begin_type?
+            final_expression = body.children.last
+            check_ending_if(final_expression) if final_expression&.if_type?
+          end
+        end
+
         def check_ending_if(node)
           return if accepted_form?(node, ending: true) || !min_body_length?(node)
           return if allowed_consecutive_conditionals? &&
                     consecutive_conditionals?(node.parent, node)
 
-          register_offense(node, 'return', opposite_keyword(node))
+          register_offense(node, 'return', node.inverse_keyword)
+
+          check_ending_body(node.if_branch)
         end
 
         def consecutive_conditionals?(parent, node)
@@ -134,30 +185,88 @@ module RuboCop
           end
         end
 
-        def opposite_keyword(node)
-          node.if? ? 'unless' : 'if'
-        end
-
-        def register_offense(node, scope_exiting_keyword, conditional_keyword)
+        def register_offense(node, scope_exiting_keyword, conditional_keyword, guard = nil)
           condition, = node.node_parts
           example = [scope_exiting_keyword, conditional_keyword, condition.source].join(' ')
           if too_long_for_single_line?(node, example)
+            return if trivial?(node)
+
             example = "#{conditional_keyword} #{condition.source}; #{scope_exiting_keyword}; end"
+            replacement = <<~RUBY.chomp
+              #{conditional_keyword} #{condition.source}
+                #{scope_exiting_keyword}
+              end
+            RUBY
           end
 
-          add_offense(node.loc.keyword, message: format(MSG, example: example))
+          add_offense(node.loc.keyword, message: format(MSG, example: example)) do |corrector|
+            next if node.else? && guard.nil?
+
+            autocorrect(corrector, node, condition, replacement || example, guard)
+          end
         end
 
-        def guard_clause_source(guard_clause)
-          parent = guard_clause.parent
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def autocorrect(corrector, node, condition, replacement, guard)
+          corrector.replace(node.loc.keyword.join(condition.source_range), replacement)
 
-          if parent.and_type? || parent.or_type?
+          if_branch = node.if_branch
+          else_branch = node.else_branch
+
+          corrector.replace(node.loc.begin, "\n") if node.loc.begin&.is?('then')
+
+          if if_branch&.send_type? && heredoc?(if_branch.last_argument)
+            autocorrect_heredoc_argument(corrector, node, if_branch, else_branch, guard)
+          elsif else_branch&.send_type? && heredoc?(else_branch.last_argument)
+            autocorrect_heredoc_argument(corrector, node, else_branch, if_branch, guard)
+          else
+            corrector.remove(node.loc.end)
+            return unless node.else?
+
+            corrector.remove(node.loc.else)
+            corrector.remove(range_of_branch_to_remove(node, guard))
+          end
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        def heredoc?(argument)
+          argument.respond_to?(:heredoc?) && argument.heredoc?
+        end
+
+        def autocorrect_heredoc_argument(corrector, node, heredoc_branch, leave_branch, guard)
+          return unless node.else?
+
+          remove_whole_lines(corrector, leave_branch.source_range)
+          remove_whole_lines(corrector, node.loc.else)
+          remove_whole_lines(corrector, node.loc.end)
+          remove_whole_lines(corrector, range_of_branch_to_remove(node, guard))
+          corrector.insert_after(
+            heredoc_branch.last_argument.loc.heredoc_end, "\n#{leave_branch.source}"
+          )
+        end
+
+        def range_of_branch_to_remove(node, guard)
+          branch = case guard
+                   when :if then node.if_branch
+                   when :else then node.else_branch
+                   end
+
+          branch.source_range
+        end
+
+        def guard_clause_source(guard_clause)
+          if and_or_guard_clause?(guard_clause)
             guard_clause.parent.source
           else
             guard_clause.source
           end
         end
 
+        def and_or_guard_clause?(guard_clause)
+          parent = guard_clause.parent
+          parent.and_type? || parent.or_type?
+        end
+
         def too_long_for_single_line?(node, example)
           max = max_line_length
           max && node.source_range.column + example.length > max
@@ -167,8 +276,12 @@ module RuboCop
           accepted_if?(node, ending) || node.condition.multiline? || node.parent&.assignment?
         end
 
+        def trivial?(node)
+          node.branches.one? && !node.if_branch.if_type? && !node.if_branch.begin_type?
+        end
+
         def accepted_if?(node, ending)
-          return true if node.modifier_form? || node.ternary?
+          return true if node.modifier_form? || node.ternary? || node.elsif_conditional?
 
           if ending
             node.else?
@@ -177,6 +290,10 @@ module RuboCop
           end
         end
 
+        def remove_whole_lines(corrector, range)
+          corrector.remove(range_by_whole_lines(range, include_final_newline: true))
+        end
+
         def allowed_consecutive_conditionals?
           cop_config.fetch('AllowConsecutiveConditionals', false)
         end

data/lib/rubocop/cop/style/hash_as_last_array_item.rb

@@ -34,6 +34,7 @@ module RuboCop
         extend AutoCorrector
 
         def on_hash(node)
+          return if node.children.first&.kwsplat_type?
           return unless (array = containing_array(node))
           return unless last_array_item?(array, node) && explicit_array?(array)
 
@@ -87,7 +88,7 @@ module RuboCop
 
         def remove_last_element_trailing_comma(corrector, node)
           range = range_with_surrounding_space(
-            range: node.children.last.source_range,
+            node.children.last.source_range,
             side: :right
           ).end.resize(1)
 

data/lib/rubocop/cop/style/hash_conversion.rb

@@ -10,6 +10,16 @@ module RuboCop
       # `Hash[*ary]` can be replaced with `ary.each_slice(2).to_h` but it will be complicated.
       # So, `AllowSplatArgument` option is true by default to allow splat argument for simple code.
       #
+      # @safety
+      #   This cop's autocorrection is unsafe because `ArgumentError` occurs
+      #   if the number of elements is odd:
+      #
+      #   [source,ruby]
+      #   ----
+      #   Hash[[[1, 2], [3]]] #=> {1=>2, 3=>nil}
+      #   [[1, 2], [5]].to_h  #=> wrong array length at 1 (expected 2, was 1) (ArgumentError)
+      #   ----
+      #
       # @example
       #   # bad
       #   Hash[ary]

data/lib/rubocop/cop/style/hash_each_methods.rb

@@ -17,10 +17,16 @@ module RuboCop
       # @example
       #   # bad
       #   hash.keys.each { |k| p k }
-      #   hash.values.each { |v| p v }
+      #   hash.each { |k, unused_value| p k }
       #
       #   # good
       #   hash.each_key { |k| p k }
+      #
+      #   # bad
+      #   hash.values.each { |v| p v }
+      #   hash.each { |unused_key, v| p v }
+      #
+      #   # good
       #   hash.each_value { |v| p v }
       #
       # @example AllowedReceivers: ['execute']
@@ -28,36 +34,149 @@ module RuboCop
       #   execute(sql).keys.each { |v| p v }
       #   execute(sql).values.each { |v| p v }
       class HashEachMethods < Base
+        include AllowedReceivers
         include Lint::UnusedArgument
         extend AutoCorrector
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
+        UNUSED_BLOCK_ARG_MSG = "#{MSG.chop} and remove the unused `%<unused_code>s` block argument."
+        ARRAY_CONVERTER_METHODS = %i[assoc chunk flatten rassoc sort sort_by to_a].freeze
 
         # @!method kv_each(node)
         def_node_matcher :kv_each, <<~PATTERN
-          (block $(send (send _ ${:keys :values}) :each) ...)
+          ({block numblock} $(call (call _ ${:keys :values}) :each) ...)
+        PATTERN
+
+        # @!method each_arguments(node)
+        def_node_matcher :each_arguments, <<~PATTERN
+          (block (call _ :each)(args $_key $_value) ...)
+        PATTERN
+
+        # @!method kv_each_with_block_pass(node)
+        def_node_matcher :kv_each_with_block_pass, <<~PATTERN
+          (call $(call _ ${:keys :values}) :each (block_pass (sym _)))
         PATTERN
 
         def on_block(node)
-          register_kv_offense(node)
+          return unless handleable?(node)
+
+          kv_each(node) do |target, method|
+            register_kv_offense(target, method) and return
+          end
+
+          return unless (key, value = each_arguments(node))
+
+          check_unused_block_args(node, key, value)
+        end
+        alias on_numblock on_block
+
+        # rubocop:disable Metrics/AbcSize
+        def check_unused_block_args(node, key, value)
+          return if node.body.nil?
+
+          value_unused = unused_block_arg_exist?(node, value)
+          key_unused = unused_block_arg_exist?(node, key)
+          return if value_unused && key_unused
+
+          if value_unused
+            message = message('each_key', node.method_name, value.source)
+            unused_range = key.source_range.end.join(value.source_range.end)
+
+            register_each_args_offense(node, message, 'each_key', unused_range)
+          elsif key_unused
+            message = message('each_value', node.method_name, key.source)
+            unused_range = key.source_range.begin.join(value.source_range.begin)
+
+            register_each_args_offense(node, message, 'each_value', unused_range)
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        def on_block_pass(node)
+          kv_each_with_block_pass(node.parent) do |target, method|
+            register_kv_with_block_pass_offense(node, target, method)
+          end
         end
 
         private
 
-        def register_kv_offense(node)
-          kv_each(node) do |target, method|
-            parent_receiver = target.receiver.receiver
-            return unless parent_receiver
-            return if allowed_receiver?(parent_receiver)
+        def handleable?(node)
+          return false if use_array_converter_method_as_preceding?(node)
+          return false unless (root_receiver = root_receiver(node))
+
+          !root_receiver.literal? || root_receiver.hash_type?
+        end
+
+        def register_kv_offense(target, method)
+          return unless (parent_receiver = target.receiver.receiver)
+          return if allowed_receiver?(parent_receiver)
 
-            msg = format(message, prefer: "each_#{method[0..-2]}", current: "#{method}.each")
+          current = target.receiver.loc.selector.join(target.source_range.end).source
 
-            add_offense(kv_range(target), message: msg) do |corrector|
-              correct_key_value_each(target, corrector)
+          add_offense(kv_range(target), message: format_message(method, current)) do |corrector|
+            correct_key_value_each(target, corrector)
+          end
+        end
+
+        def unused_block_arg_exist?(node, block_arg)
+          lvar_sources = node.body.each_descendant(:lvar).map(&:source)
+
+          if block_arg.mlhs_type?
+            block_arg.each_descendant(:arg, :restarg).all? do |block_arg|
+              lvar_sources.none?(block_arg.source.delete_prefix('*'))
             end
+          else
+            lvar_sources.none?(block_arg.source.delete_prefix('*'))
+          end
+        end
+
+        def message(prefer, method_name, unused_code)
+          format(
+            UNUSED_BLOCK_ARG_MSG, prefer: prefer, current: method_name, unused_code: unused_code
+          )
+        end
+
+        def register_each_args_offense(node, message, prefer, unused_range)
+          add_offense(node, message: message) do |corrector|
+            corrector.replace(node.send_node.loc.selector, prefer)
+            corrector.remove(unused_range)
+          end
+        end
+
+        def register_kv_with_block_pass_offense(node, target, method)
+          return unless (parent_receiver = node.parent.receiver.receiver)
+          return if allowed_receiver?(parent_receiver)
+
+          range = target.loc.selector.join(node.parent.loc.selector.end)
+
+          add_offense(range, message: format_message(method, range.source)) do |corrector|
+            corrector.replace(range, "each_#{method[0..-2]}")
           end
         end
 
+        def use_array_converter_method_as_preceding?(node)
+          return false unless (preceding_method = node.children.first.children.first)
+          unless preceding_method.call_type? ||
+                 preceding_method.block_type? || preceding_method.numblock_type?
+            return false
+          end
+
+          ARRAY_CONVERTER_METHODS.include?(preceding_method.method_name)
+        end
+
+        def root_receiver(node)
+          receiver = node.receiver
+          if receiver&.receiver
+            root_receiver(receiver)
+          else
+            receiver
+          end
+        end
+
+        def format_message(method_name, current)
+          format(MSG, prefer: "each_#{method_name[0..-2]}", current: current)
+        end
+
         def check_argument(variable)
           return unless variable.block_argument?
 
@@ -78,7 +197,7 @@ module RuboCop
           name = "each_#{node.receiver.method_name.to_s.chop}"
           return correct_implicit(node, corrector, name) unless receiver
 
-          new_source = receiver.source + ".#{name}"
+          new_source = receiver.source + "#{node.loc.dot.source}#{name}"
           corrector.replace(node, new_source)
         end
 
@@ -92,16 +211,6 @@ module RuboCop
         def kv_range(outer_node)
           outer_node.receiver.loc.selector.join(outer_node.loc.selector)
         end
-
-        def allowed_receiver?(receiver)
-          receiver_name = receiver.send_type? ? receiver.method_name.to_s : receiver.source
-
-          allowed_receivers.include?(receiver_name)
-        end
-
-        def allowed_receivers
-          cop_config.fetch('AllowedReceivers', [])
-        end
       end
     end
   end

data/lib/rubocop/cop/style/hash_except.rb

@@ -13,12 +13,19 @@ module RuboCop
       # when used `==`.
       # And do not check `Hash#delete_if` and `Hash#keep_if` to change receiver object.
       #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   is a `Hash` or responds to the replacement method.
+      #
       # @example
       #
       #   # bad
       #   {foo: 1, bar: 2, baz: 3}.reject {|k, v| k == :bar }
       #   {foo: 1, bar: 2, baz: 3}.select {|k, v| k != :bar }
       #   {foo: 1, bar: 2, baz: 3}.filter {|k, v| k != :bar }
+      #   {foo: 1, bar: 2, baz: 3}.reject {|k, v| %i[foo bar].include?(k) }
+      #   {foo: 1, bar: 2, baz: 3}.select {|k, v| !%i[foo bar].include?(k) }
+      #   {foo: 1, bar: 2, baz: 3}.filter {|k, v| !%i[foo bar].include?(k) }
       #
       #   # good
       #   {foo: 1, bar: 2, baz: 3}.except(:bar)
@@ -33,15 +40,36 @@ module RuboCop
         MSG = 'Use `%<prefer>s` instead.'
         RESTRICT_ON_SEND = %i[reject select filter].freeze
 
-        # @!method bad_method?(node)
-        def_node_matcher :bad_method?, <<~PATTERN
+        # @!method bad_method_with_poro?(node)
+        def_node_matcher :bad_method_with_poro?, <<~PATTERN
+          (block
+            (call _ _)
+            (args
+              $(arg _)
+              (arg _))
+            {
+              $(send
+                _ {:== :!= :eql? :include?} _)
+              (send
+                $(send
+                  _ {:== :!= :eql? :include?} _) :!)
+              })
+        PATTERN
+
+        # @!method bad_method_with_active_support?(node)
+        def_node_matcher :bad_method_with_active_support?, <<~PATTERN
           (block
             (send _ _)
             (args
-              (arg _)
+              $(arg _)
               (arg _))
-            (send
-              _ {:== :!= :eql?} _))
+            {
+              $(send
+                _ {:== :!= :eql? :in? :include? :exclude?} _)
+              (send
+                $(send
+                  _ {:== :!= :eql? :in? :include? :exclude?} _) :!)
+              })
         PATTERN
 
         def on_send(node)
@@ -52,37 +80,101 @@ module RuboCop
           return if except_key.nil? || !safe_to_register_offense?(block, except_key)
 
           range = offense_range(node)
-          preferred_method = "except(#{except_key.source})"
+          preferred_method = "except(#{except_key_source(except_key)})"
 
           add_offense(range, message: format(MSG, prefer: preferred_method)) do |corrector|
             corrector.replace(range, preferred_method)
           end
         end
+        alias on_csend on_send
 
         private
 
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def bad_method?(block)
+          if active_support_extensions_enabled?
+            bad_method_with_active_support?(block) do |key_arg, send_node|
+              if send_node.method?(:in?) && send_node.receiver&.source != key_arg.source
+                return false
+              end
+              return true if !send_node.method?(:include?) && !send_node.method?(:exclude?)
+
+              send_node.first_argument&.source == key_arg.source
+            end
+          else
+            bad_method_with_poro?(block) do |key_arg, send_node|
+              !send_node.method?(:include?) || send_node.first_argument&.source == key_arg.source
+            end
+          end
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
         def semantically_except_method?(send, block)
           body = block.body
 
+          negated = body.method?('!')
+          body = body.receiver if negated
+
           case send.method_name
           when :reject
-            body.method?('==') || body.method?('eql?')
+            body.method?('==') || body.method?('eql?') || included?(negated, body)
           when :select, :filter
-            body.method?('!=')
+            body.method?('!=') || not_included?(negated, body)
           else
             false
           end
         end
 
+        def included?(negated, body)
+          body.method?('include?') || body.method?('in?') || (negated && body.method?('exclude?'))
+        end
+
+        def not_included?(negated, body)
+          body.method?('exclude?') || (negated && (body.method?('include?') || body.method?('in?')))
+        end
+
         def safe_to_register_offense?(block, except_key)
+          extracted = extract_body_if_negated(block.body)
+          if extracted.method?('in?') || extracted.method?('include?') ||
+             extracted.method?('exclude?')
+            return true
+          end
           return true if block.body.method?('eql?')
 
           except_key.sym_type? || except_key.str_type?
         end
 
+        def extract_body_if_negated(body)
+          return body unless body.method?('!')
+
+          body.receiver
+        end
+
+        def except_key_source(key)
+          if key.array_type?
+            key = if key.percent_literal?
+                    key.each_value.map { |v| decorate_source(v) }
+                  else
+                    key.each_value.map(&:source)
+                  end
+            return key.join(', ')
+          end
+
+          key.literal? ? key.source : "*#{key.source}"
+        end
+
+        def decorate_source(value)
+          return ":\"#{value.source}\"" if value.dsym_type?
+          return "\"#{value.source}\"" if value.dstr_type?
+          return ":#{value.source}" if value.sym_type?
+
+          "'#{value.source}'"
+        end
+
         def except_key(node)
           key_argument = node.argument_list.first.source
-          lhs, _method_name, rhs = *node.body
+          body = extract_body_if_negated(node.body)
+          lhs, _method_name, rhs = *body
           return if [lhs, rhs].map(&:source).none?(key_argument)
 
           [lhs, rhs].find { |operand| operand.source != key_argument }