rubocop 1.59.0 → 1.68.0

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

@@ -4,6 +4,7 @@ module RuboCop
   module Cop
     module Style
       # Prefer `select` or `reject` over `map { ... }.compact`.
+      # This cop also handles `filter_map { ... }`, similar to `map { ... }.compact`.
       #
       # @example
       #
@@ -11,6 +12,9 @@ module RuboCop
       #   array.map { |e| some_condition? ? e : next }.compact
       #
       #   # bad
+      #   array.filter_map { |e| some_condition? ? e : next }
+      #
+      #   # bad
       #   array.map do |e|
       #     if some_condition?
       #       e
@@ -40,55 +44,73 @@ module RuboCop
       class MapCompactWithConditionalBlock < Base
         extend AutoCorrector
 
-        MSG = 'Replace `map { ... }.compact` with `%<method>s`.'
-
-        # @!method map_and_compact?(node)
-        def_node_matcher :map_and_compact?, <<~RUBY
-          (call
-            (block
-              (call _ :map)
-              (args
-                $(arg _))
-              {
-                (if $_ $(lvar _) {next nil?})
-                (if $_ {next nil?} $(lvar _))
-                (if $_ (next $(lvar _)) {next nil nil?})
-                (if $_ {next nil nil?} (next $(lvar _)))
-                (begin
-                  {
-                    (if $_ next nil?)
-                    (if $_ nil? next)
-                  }
-                  $(lvar _))
-                (begin
-                  {
-                    (if $_ (next $(lvar _)) nil?)
-                    (if $_ nil? (next $(lvar _)))
-                  }
-                  (nil))
-              }) :compact)
+        MSG = 'Replace `%<current>s` with `%<method>s`.'
+        RESTRICT_ON_SEND = %i[compact filter_map].freeze
+
+        # @!method conditional_block(node)
+        def_node_matcher :conditional_block, <<~RUBY
+          (block
+            (call _ {:map :filter_map})
+            (args
+              $(arg _))
+            {
+              (if $_ $(lvar _) {next nil?})
+              (if $_ {next nil?} $(lvar _))
+              (if $_ (next $(lvar _)) {next nil nil?})
+              (if $_ {next nil nil?} (next $(lvar _)))
+              (begin
+                {
+                  (if $_ next nil?)
+                  (if $_ nil? next)
+                }
+                $(lvar _))
+              (begin
+                {
+                  (if $_ (next $(lvar _)) nil?)
+                  (if $_ nil? (next $(lvar _)))
+                }
+                (nil))
+            })
         RUBY
 
         def on_send(node)
-          map_and_compact?(node) do |block_argument_node, condition_node, return_value_node|
-            return unless returns_block_argument?(block_argument_node, return_value_node)
-            return if condition_node.parent.elsif?
-
-            method = truthy_branch?(return_value_node) ? 'select' : 'reject'
-            range = range(node)
-
-            add_offense(range, message: format(MSG, method: method)) do |corrector|
-              corrector.replace(
-                range,
-                "#{method} { |#{block_argument_node.source}| #{condition_node.source} }"
-              )
-            end
+          map_candidate = node.children.first
+          if (block_argument, condition, return_value = conditional_block(map_candidate))
+            return unless node.method?(:compact) && node.arguments.empty?
+
+            range = map_with_compact_range(node)
+          elsif (block_argument, condition, return_value = conditional_block(node.parent))
+            return unless node.method?(:filter_map)
+
+            range = filter_map_range(node)
+          else
+            return
           end
+
+          inspect(node, block_argument, condition, return_value, range)
         end
         alias on_csend on_send
 
         private
 
+        def inspect(node, block_argument_node, condition_node, return_value_node, range)
+          return unless returns_block_argument?(block_argument_node, return_value_node)
+          return if condition_node.parent.elsif?
+
+          method = truthy_branch?(return_value_node) ? 'select' : 'reject'
+          current = current(node)
+
+          add_offense(range, message: format(MSG, current: current, method: method)) do |corrector|
+            return if part_of_ignored_node?(node) || ignored_node?(node)
+
+            corrector.replace(
+              range, "#{method} { |#{block_argument_node.source}| #{condition_node.source} }"
+            )
+
+            ignore_node(node)
+          end
+        end
+
         def returns_block_argument?(block_argument_node, return_value_node)
           block_argument_node.name == return_value_node.children.first
         end
@@ -116,20 +138,29 @@ module RuboCop
         def truthy_branch_for_guard?(node)
           if_node = node.left_sibling
 
-          if if_node.if? || if_node.ternary?
-            if_node.else_branch.nil?
-          elsif if_node.unless?
-            if_node.if_branch.nil?
+          if if_node.if?
+            if_node.if_branch.arguments.any?
+          else
+            if_node.if_branch.arguments.none?
           end
         end
 
-        def range(node)
-          buffer = node.source_range.source_buffer
-          map_node = node.receiver.send_node
-          begin_pos = map_node.loc.selector.begin_pos
-          end_pos = node.source_range.end_pos
+        def current(node)
+          if node.method?(:compact)
+            map_or_filter_map_method = node.children.first
+
+            "#{map_or_filter_map_method.method_name} { ... }.compact"
+          else
+            'filter_map { ... }'
+          end
+        end
+
+        def map_with_compact_range(node)
+          node.receiver.send_node.loc.selector.begin.join(node.source_range.end)
+        end
 
-          Parser::Source::Range.new(buffer, begin_pos, end_pos)
+        def filter_map_range(node)
+          node.loc.selector.join(node.parent.source_range.end)
         end
       end
     end

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

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for usages of `each` with `<<`, `push`, or `append` which
+      # can be replaced by `map`.
+      #
+      # If `PreferredMethods` is configured for `map` in `Style/CollectionMethods`,
+      # this cop uses the specified method for replacement.
+      #
+      # NOTE: The return value of `Enumerable#each` is `self`, whereas the
+      # return value of `Enumerable#map` is an `Array`. They are not autocorrected
+      # when a return value could be used because these types differ.
+      #
+      # NOTE: It only detects when the mapping destination is either:
+      # * a local variable initialized as an empty array and referred to only by the
+      # pushing operation;
+      # * or, if it is the single block argument to a `[].tap` block.
+      # This is because, if not, it's challenging to statically guarantee that the
+      # mapping destination variable remains an empty array:
+      #
+      # [source,ruby]
+      # ----
+      # ret = []
+      # src.each { |e| ret << e * 2 } # `<<` method may mutate `ret`
+      #
+      # dest = []
+      # src.each { |e| dest << transform(e, dest) } # `transform` method may mutate `dest`
+      # ----
+      #
+      # @safety
+      #   This cop is unsafe because not all objects that have an `each`
+      #   method also have a `map` method (e.g. `ENV`). Additionally, for calls
+      #   with a block, not all objects that have a `map` method return an array
+      #   (e.g. `Enumerator::Lazy`).
+      #
+      # @example
+      #   # bad
+      #   dest = []
+      #   src.each { |e| dest << e * 2 }
+      #   dest
+      #
+      #   # good
+      #   dest = src.map { |e| e * 2 }
+      #
+      #   # bad
+      #   [].tap do |dest|
+      #     src.each { |e| dest << e * 2 }
+      #   end
+      #
+      #   # good
+      #   dest = src.map { |e| e * 2 }
+      #
+      #   # good - contains another operation
+      #   dest = []
+      #   src.each { |e| dest << e * 2; puts e }
+      #   dest
+      #
+      class MapIntoArray < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use `%<new_method_name>s` instead of `each` to map elements into an array.'
+
+        # @!method suitable_argument_node?(node)
+        def_node_matcher :suitable_argument_node?, <<-PATTERN
+          !{splat forwarded-restarg forwarded-args (hash (forwarded-kwrestarg)) (block-pass nil?)}
+        PATTERN
+
+        # @!method each_block_with_push?(node)
+        def_node_matcher :each_block_with_push?, <<-PATTERN
+          [
+            ^({begin kwbegin block} ...)
+            ({block numblock} (send !{nil? self} :each) _
+              (send (lvar _) {:<< :push :append} #suitable_argument_node?))
+          ]
+        PATTERN
+
+        # @!method empty_array_asgn?(node)
+        def_node_matcher :empty_array_asgn?, <<~PATTERN
+          (
+            lvasgn _ {
+              (array)
+              (send (const {nil? cbase} :Array) :[])
+              (send (const {nil? cbase} :Array) :new (array)?)
+              (send nil? :Array (array))
+            }
+          )
+        PATTERN
+
+        # @!method empty_array_tap(node)
+        def_node_matcher :empty_array_tap, <<~PATTERN
+          ^^$(
+            block
+              (send (array) :tap)
+              (args (arg _))
+              ...
+          )
+        PATTERN
+
+        # @!method lvar_ref?(node, name)
+        def_node_matcher :lvar_ref?, '(lvar %1)'
+
+        def self.joining_forces
+          VariableForce
+        end
+
+        def after_leaving_scope(scope, _variable_table)
+          (@scopes ||= []) << scope
+        end
+
+        def on_block(node)
+          return unless each_block_with_push?(node)
+
+          dest_var = find_dest_var(node)
+
+          if offending_empty_array_tap?(node, dest_var)
+            asgn = dest_var.declaration_node
+          else
+            return unless (asgn = find_closest_assignment(node, dest_var))
+            return unless empty_array_asgn?(asgn)
+            return unless dest_used_only_for_mapping?(node, dest_var, asgn)
+          end
+
+          register_offense(node, dest_var, asgn)
+        end
+
+        alias on_numblock on_block
+
+        private
+
+        def find_dest_var(block)
+          node = block.body.receiver
+          name = node.children.first
+
+          candidates = @scopes.lazy.filter_map { |s| s.variables[name] }
+          candidates.find { |v| v.references.any? { |n| n.node.equal?(node) } }
+        end
+
+        def offending_empty_array_tap?(node, dest_var)
+          return false unless (tap_block_node = empty_array_tap(dest_var.declaration_node))
+
+          # A `tap` block only offends if the array push is the only thing in it;
+          # otherwise we cannot guarantee that the block variable is still an empty
+          # array when pushed to.
+          tap_block_node.body == node
+        end
+
+        def find_closest_assignment(block, dest_var)
+          dest_var.assignments.reverse_each.lazy.map(&:node).find do |node|
+            node.source_range.end_pos < block.source_range.begin_pos
+          end
+        end
+
+        def dest_used_only_for_mapping?(block, dest_var, asgn)
+          range = asgn.source_range.join(block.source_range)
+
+          asgn.parent.equal?(block.parent) &&
+            dest_var.references.one? { |r| range.contains?(r.node.source_range) } &&
+            dest_var.assignments.one? { |a| range.contains?(a.node.source_range) }
+        end
+
+        def register_offense(block, dest_var, asgn)
+          add_offense(block, message: format(MSG, new_method_name: new_method_name)) do |corrector|
+            next if return_value_used?(block)
+
+            corrector.replace(block.send_node.selector, new_method_name)
+
+            if (tap_block_node = empty_array_tap(dest_var.declaration_node))
+              remove_tap(corrector, block, tap_block_node)
+            else
+              remove_assignment(corrector, asgn)
+            end
+
+            correct_push_node(corrector, block.body)
+            correct_return_value_handling(corrector, block, dest_var)
+          end
+        end
+
+        def new_method_name
+          default = 'map'
+          alternative = config.for_cop('Style/CollectionMethods').dig('PreferredMethods', default)
+          alternative || default
+        end
+
+        def return_value_used?(node)
+          parent = node.parent
+
+          case parent&.type
+          when nil
+            false
+          when :begin, :kwbegin
+            !node.right_sibling && return_value_used?(parent)
+          else
+            !parent.respond_to?(:void_context?) || !parent.void_context?
+          end
+        end
+
+        def remove_assignment(corrector, asgn)
+          range = range_with_surrounding_space(asgn.source_range, side: :right)
+          range = range_with_surrounding_space(range, side: :right, newlines: false)
+
+          corrector.remove(range)
+        end
+
+        def remove_tap(corrector, node, block_node)
+          range = range_between(block_node.source_range.begin_pos, node.source_range.begin_pos)
+          corrector.remove(range)
+          corrector.remove(range_with_surrounding_space(block_node.loc.end, side: :left))
+        end
+
+        def correct_push_node(corrector, push_node)
+          range = push_node.source_range
+          arg_range = push_node.first_argument.source_range
+
+          corrector.remove(range_between(range.begin_pos, arg_range.begin_pos))
+          corrector.remove(range_between(arg_range.end_pos, range.end_pos))
+        end
+
+        def correct_return_value_handling(corrector, block, dest_var)
+          next_node = block.right_sibling
+
+          if lvar_ref?(next_node, dest_var.name)
+            corrector.remove(range_with_surrounding_space(next_node.source_range, side: :left))
+          end
+
+          corrector.insert_before(block, "#{dest_var.name} = ")
+        end
+      end
+    end
+  end
+end

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

@@ -37,8 +37,8 @@ module RuboCop
         MSG = 'Pass a block to `to_h` instead of calling `%<method>s%<dot>sto_h`.'
         RESTRICT_ON_SEND = %i[to_h].freeze
 
-        # @!method map_to_h?(node)
-        def_node_matcher :map_to_h?, <<~PATTERN
+        # @!method map_to_h(node)
+        def_node_matcher :map_to_h, <<~PATTERN
           {
             $(call ({block numblock} $(call _ {:map :collect}) ...) :to_h)
             $(call $(call _ {:map :collect} (block_pass sym)) :to_h)
@@ -50,12 +50,12 @@ module RuboCop
         end
 
         def on_send(node)
-          return unless (to_h_node, map_node = map_to_h?(node))
+          return unless (to_h_node, map_node = map_to_h(node))
 
-          message = format(MSG, method: map_node.loc.selector.source, dot: map_node.loc.dot.source)
+          message = format(MSG, method: map_node.loc.selector.source, dot: to_h_node.loc.dot.source)
           add_offense(map_node.loc.selector, message: message) do |corrector|
             # If the `to_h` call already has a block, do not autocorrect.
-            next if to_h_node.block_node
+            next if to_h_node.block_literal?
 
             autocorrect(corrector, to_h_node, map_node)
           end
@@ -64,13 +64,17 @@ module RuboCop
 
         private
 
+        # rubocop:disable Metrics/AbcSize
         def autocorrect(corrector, to_h, map)
           removal_range = range_between(to_h.loc.dot.begin_pos, to_h.loc.selector.end_pos)
 
           corrector.remove(range_with_surrounding_space(removal_range, side: :left))
-          corrector.replace(map.loc.dot, '.') if to_h.dot?
+          if (map_dot = map.loc.dot)
+            corrector.replace(map_dot, to_h.loc.dot.source)
+          end
           corrector.replace(map.loc.selector, 'to_h')
         end
+        # rubocop:enable Metrics/AbcSize
       end
     end
   end

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

@@ -44,7 +44,7 @@ module RuboCop
           message = format(MSG, method: map_node.loc.selector.source)
           add_offense(map_node.loc.selector, message: message) do |corrector|
             # If the `to_set` call already has a block, do not autocorrect.
-            next if to_set_node.block_node
+            next if to_set_node.block_literal?
 
             autocorrect(corrector, to_set_node, map_node)
           end

data/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb

@@ -7,6 +7,8 @@ module RuboCop
         # Style omit_parentheses
         # rubocop:disable Metrics/ModuleLength, Metrics/CyclomaticComplexity
         module OmitParentheses
+          include RangeHelp
+
           TRAILING_WHITESPACE_REGEX = /\s+\Z/.freeze
           OMIT_MSG = 'Omit parentheses for method calls with arguments.'
           private_constant :OMIT_MSG
@@ -18,6 +20,7 @@ module RuboCop
             return if inside_endless_method_def?(node)
             return if require_parentheses_for_hash_value_omission?(node)
             return if syntax_like_method_call?(node)
+            return if method_call_before_constant_resolution?(node)
             return if super_call_without_arguments?(node)
             return if legitimate_call_with_parentheses?(node)
             return if allowed_camel_case_method_call?(node)
@@ -29,10 +32,13 @@ module RuboCop
           end
 
           def autocorrect(corrector, node)
+            range = args_begin(node)
             if parentheses_at_the_end_of_multiline_call?(node)
-              corrector.replace(args_begin(node), ' \\')
+              # Whitespace after line continuation (`\ `) is a syntax error
+              with_whitespace = range_with_surrounding_space(range, side: :right, newlines: false)
+              corrector.replace(with_whitespace, ' \\')
             else
-              corrector.replace(args_begin(node), ' ')
+              corrector.replace(range, ' ')
             end
             corrector.remove(node.loc.end)
           end
@@ -46,11 +52,11 @@ module RuboCop
             node.each_ancestor(:def, :defs).any?(&:endless?) && node.arguments.any?
           end
 
-          def require_parentheses_for_hash_value_omission?(node)
+          def require_parentheses_for_hash_value_omission?(node) # rubocop:disable Metrics/PerceivedComplexity
             return false unless (last_argument = node.last_argument)
             return false if !last_argument.hash_type? || !last_argument.pairs.last&.value_omission?
 
-            node.parent&.conditional? || !last_expression?(node)
+            node.parent&.conditional? || node.parent&.single_line? || !last_expression?(node)
           end
 
           # Require hash value omission be enclosed in parentheses to prevent the following issue:
@@ -63,6 +69,10 @@ module RuboCop
             node.implicit_call? || node.operator_method?
           end
 
+          def method_call_before_constant_resolution?(node)
+            node.parent&.const_type?
+          end
+
           def super_call_without_arguments?(node)
             node.super_type? && node.arguments.none?
           end
@@ -122,28 +132,36 @@ module RuboCop
           end
 
           def call_in_single_line_inheritance?(node)
-            node.parent&.class_type? && node.parent&.single_line?
+            node.parent&.class_type? && node.parent.single_line?
           end
 
           def call_with_ambiguous_arguments?(node) # rubocop:disable Metrics/PerceivedComplexity
             call_with_braced_block?(node) ||
+              call_in_argument_with_block?(node) ||
               call_as_argument_or_chain?(node) ||
               call_in_match_pattern?(node) ||
               hash_literal_in_arguments?(node) ||
               node.descendants.any? do |n|
-                n.forwarded_args_type? || ambiguous_literal?(n) || logical_operator?(n) ||
-                  call_with_braced_block?(n)
+                n.forwarded_args_type? || n.block_type? || n.numblock_type? ||
+                  ambiguous_literal?(n) || logical_operator?(n)
               end
           end
 
           def call_with_braced_block?(node)
-            (node.send_type? || node.super_type?) && node.block_node&.braces?
+            (node.call_type? || node.super_type?) && node.block_node&.braces?
+          end
+
+          def call_in_argument_with_block?(node)
+            parent = node.parent&.block_type? && node.parent.parent
+            return false unless parent
+
+            parent.call_type? || parent.super_type? || parent.yield_type?
           end
 
           def call_as_argument_or_chain?(node)
             node.parent &&
-              ((node.parent.send_type? && !assigned_before?(node.parent, node)) ||
-              node.parent.csend_type? || node.parent.super_type? || node.parent.yield_type?)
+              (node.parent.call_type? || node.parent.super_type? || node.parent.yield_type?) &&
+              !assigned_before?(node.parent, node)
           end
 
           def call_in_match_pattern?(node)
@@ -198,7 +216,7 @@ module RuboCop
 
           def unary_literal?(node)
             (node.numeric_type? && node.sign?) ||
-              (node.parent&.send_type? && node.parent&.unary_operation?)
+              (node.parent&.send_type? && node.parent.unary_operation?)
           end
 
           def assigned_before?(node, target)

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

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module Style
       # Enforces the presence (default) or absence of parentheses in
-      # method calls containing parameters.
+      # method calls containing arguments.
       #
       # In the default style (require_parentheses), macro methods are allowed.
       # Additional methods can be added to the `AllowedMethods` or
@@ -218,15 +218,13 @@ module RuboCop
           send(style, node) # call require_parentheses or omit_parentheses
         end
         alias on_csend on_send
-        alias on_super on_send
         alias on_yield on_send
 
         private
 
         def args_begin(node)
           loc = node.loc
-          selector =
-            node.super_type? || node.yield_type? ? loc.keyword : loc.selector
+          selector = node.yield_type? ? loc.keyword : loc.selector
 
           resize_by = args_parenthesized?(node) ? 2 : 1
           selector.end.resize(resize_by)

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

@@ -5,8 +5,8 @@ module RuboCop
     module Style
       # Checks for unwanted parentheses in parameterless method calls.
       #
-      # This cop can be customized allowed methods with `AllowedMethods`.
-      # By default, there are no methods to allowed.
+      # This cop's allowed methods can be customized with `AllowedMethods`.
+      # By default, there are no allowed methods.
       #
       # NOTE: This cop allows the use of `it()` without arguments in blocks,
       # as in `0.times { it() }`, following `Lint/ItWithoutArgumentsInBlock` cop.

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

@@ -168,10 +168,6 @@ module RuboCop
           config.for_cop('Style/UnlessElse')
         end
 
-        def empty_else_cop_enabled?
-          empty_else_config.fetch('Enabled')
-        end
-
         def empty_else_style
           return unless empty_else_config.key?('EnforcedStyle')
 

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

@@ -43,7 +43,7 @@ module RuboCop
 
           return unless bad_rhs?(rhs)
 
-          add_offense(node.source_range) do |corrector|
+          add_offense(node) do |corrector|
             if style == :keyword
               keyword_autocorrect(rhs, corrector)
             else

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

@@ -38,6 +38,7 @@ module RuboCop
 
         private
 
+        # rubocop:disable Metrics/AbcSize
         def autocorrect(corrector, node, begin_of_arguments)
           arguments = node.arguments
           joined_arguments = arguments.map(&:source).join(', ')
@@ -49,9 +50,17 @@ module RuboCop
             corrector.remove(range_by_whole_lines(arguments.loc.end, include_final_newline: true))
           end
 
-          corrector.remove(arguments_range(node))
+          arguments_range = arguments_range(node)
+          # If the method name isn't on the same line as def, move it directly after def
+          if arguments_range.first_line != opening_line(node)
+            corrector.remove(node.loc.name)
+            corrector.insert_after(node.loc.keyword, " #{node.loc.name.source}")
+          end
+
+          corrector.remove(arguments_range)
           corrector.insert_after(begin_of_arguments, joined_arguments)
         end
+        # rubocop:enable Metrics/AbcSize
 
         def last_line_source_of_arguments(arguments)
           processed_source[arguments.last_line - 1].strip

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

@@ -47,19 +47,21 @@ module RuboCop
           message = enforce_single_line_ternary_operator?(node) ? MSG_SINGLE_LINE : MSG_IF
 
           add_offense(node, message: message) do |corrector|
+            next if part_of_ignored_node?(node)
+
             autocorrect(corrector, node)
+
+            ignore_node(node)
           end
         end
 
         private
 
         def offense?(node)
-          node.ternary? && node.multiline?
+          node.ternary? && node.multiline? && node.source != replacement(node)
         end
 
         def autocorrect(corrector, node)
-          return unless offense?(node)
-
           corrector.replace(node, replacement(node))
           return unless (parent = node.parent)
           return unless (comments_in_condition = comments_in_condition(node))