rubocop 1.62.1 → 1.63.4

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

@@ -41,6 +41,7 @@ module RuboCop
         def on_send(node)
           return unless node.command?(:alias_method)
           return unless style == :prefer_alias && alias_keyword_possible?(node)
+          return unless node.arguments.count == 2
 
           msg = format(MSG_ALIAS_METHOD, current: lexical_scope_type(node))
           add_offense(node.loc.selector, message: msg) do |corrector|

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

@@ -312,7 +312,8 @@ module RuboCop
         end
 
         def register_forward_block_arg_offense(add_parens, def_arguments_or_send, block_arg)
-          return if target_ruby_version <= 3.0 || block_arg.source == '&' || explicit_block_name?
+          return if target_ruby_version <= 3.0 ||
+                    block_arg.nil? || block_arg.source == '&' || explicit_block_name?
 
           add_offense(block_arg, message: BLOCK_MSG) do |corrector|
             add_parens_if_missing(def_arguments_or_send, corrector) if add_parens

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

@@ -19,9 +19,7 @@ module RuboCop
       # @example
       #   # bad
       #   array.reject(&:nil?)
-      #   array.delete_if(&:nil?)
       #   array.reject { |e| e.nil? }
-      #   array.delete_if { |e| e.nil? }
       #   array.select { |e| !e.nil? }
       #   array.grep_v(nil)
       #   array.grep_v(NilClass)
@@ -31,7 +29,9 @@ module RuboCop
       #
       #   # bad
       #   hash.reject!(&:nil?)
+      #   array.delete_if(&:nil?)
       #   hash.reject! { |k, v| v.nil? }
+      #   array.delete_if { |e| e.nil? }
       #   hash.select! { |k, v| !v.nil? }
       #
       #   # good
@@ -127,7 +127,7 @@ module RuboCop
         end
 
         def good_method_name(node)
-          if node.bang_method?
+          if node.bang_method? || node.method?(:delete_if)
             'compact!'
           else
             'compact'

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

@@ -28,18 +28,27 @@ module RuboCop
         def on_new_investigation
           return if notice.empty? || notice_found?(processed_source)
 
-          add_offense(offense_range, message: format(MSG, notice: notice)) do |corrector|
-            verify_autocorrect_notice!
-
-            token = insert_notice_before(processed_source)
-            range = token.nil? ? range_between(0, 0) : token.pos
-
-            corrector.insert_before(range, "#{autocorrect_notice}\n")
+          verify_autocorrect_notice!
+          message = format(MSG, notice: notice)
+          if processed_source.blank?
+            add_global_offense(message)
+          else
+            offense_range = source_range(processed_source.buffer, 1, 0)
+            add_offense(offense_range, message: message) do |corrector|
+              autocorrect(corrector)
+            end
           end
         end
 
         private
 
+        def autocorrect(corrector)
+          token = insert_notice_before(processed_source)
+          range = token.nil? ? range_between(0, 0) : token.pos
+
+          corrector.insert_before(range, "#{autocorrect_notice}\n")
+        end
+
         def notice
           cop_config['Notice']
         end
@@ -48,10 +57,6 @@ module RuboCop
           cop_config['AutocorrectNotice']
         end
 
-        def offense_range
-          source_range(processed_source.buffer, 1, 0)
-        end
-
         def verify_autocorrect_notice!
           raise Warning, AUTOCORRECT_EMPTY_WARNING if autocorrect_notice.empty?
 

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

@@ -141,7 +141,7 @@ module RuboCop
         end
 
         def check_file(node, file_node)
-          return true if special_file_keyword?(file_node)
+          return if special_file_keyword?(file_node)
 
           message = format(MSG_INCORRECT_FILE,
                            method_name: node.method_name,
@@ -155,6 +155,8 @@ module RuboCop
 
         def check_line(node, code)
           line_node = node.last_argument
+          return if line_node.variable? || (line_node.send_type? && !line_node.method?(:+))
+
           line_diff = line_difference(line_node, code)
           if line_diff.zero?
             add_offense_for_same_line(node, line_node)

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

@@ -38,12 +38,13 @@ module RuboCop
         PATTERN
 
         def on_send(node)
+          return unless (receiver = node.receiver)
           return unless (regexp = exact_regexp_match(node))
 
           parsed_regexp = Regexp::Parser.parse(regexp)
           return unless exact_match_pattern?(parsed_regexp)
 
-          prefer = "#{node.receiver.source} #{new_method(node)} '#{parsed_regexp[1].text}'"
+          prefer = "#{receiver.source} #{new_method(node)} '#{parsed_regexp[1].text}'"
 
           add_offense(node, message: format(MSG, prefer: prefer)) do |corrector|
             corrector.replace(node, prefer)

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

@@ -25,27 +25,27 @@ module RuboCop
       #
       # @example EnforcedStyle: format (default)
       #   # bad
-      #   puts sprintf('%10s', 'hoge')
-      #   puts '%10s' % 'hoge'
+      #   puts sprintf('%10s', 'foo')
+      #   puts '%10s' % 'foo'
       #
       #   # good
-      #   puts format('%10s', 'hoge')
+      #   puts format('%10s', 'foo')
       #
       # @example EnforcedStyle: sprintf
       #   # bad
-      #   puts format('%10s', 'hoge')
-      #   puts '%10s' % 'hoge'
+      #   puts format('%10s', 'foo')
+      #   puts '%10s' % 'foo'
       #
       #   # good
-      #   puts sprintf('%10s', 'hoge')
+      #   puts sprintf('%10s', 'foo')
       #
       # @example EnforcedStyle: percent
       #   # bad
-      #   puts format('%10s', 'hoge')
-      #   puts sprintf('%10s', 'hoge')
+      #   puts format('%10s', 'foo')
+      #   puts sprintf('%10s', 'foo')
       #
       #   # good
-      #   puts '%10s' % 'hoge'
+      #   puts '%10s' % 'foo'
       #
       class FormatString < Base
         include ConfigurableEnforcedStyle

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

@@ -0,0 +1,175 @@
+# 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 a local variable
+      # initialized as an empty array and referred to only by the pushing operation.
+      # 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 }
+      #
+      #   # 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 each_block_with_push?(node)
+        def_node_matcher :each_block_with_push?, <<-PATTERN
+          [
+            ^({begin kwbegin} ...)
+            ({block numblock} (send _ :each) _
+              (send (lvar _) {:<< :push :append} _))
+          ]
+        PATTERN
+
+        # @!method empty_array_asgn?(node)
+        def_node_matcher :empty_array_asgn?, '(lvasgn _ (array))'
+
+        # @!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)
+          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)
+
+          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 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)
+            remove_assignment(corrector, asgn)
+            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)
+          when :block, :numblock
+            !parent.void_context?
+          else
+            true
+          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 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

@@ -55,7 +55,7 @@ module RuboCop
           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

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/redundant_argument.rb

@@ -81,7 +81,13 @@ module RuboCop
           redundant_argument = redundant_arg_for_method(node.method_name.to_s)
           return false if redundant_argument.nil?
 
-          node.first_argument.source.sub(/\A'/, '"').sub(/'\z/, '"') == redundant_argument
+          target_argument = if node.first_argument.respond_to?(:value)
+                              node.first_argument.value
+                            else
+                              node.first_argument
+                            end
+
+          argument_matched?(target_argument, redundant_argument)
         end
 
         def redundant_arg_for_method(method_name)
@@ -98,6 +104,23 @@ module RuboCop
             range_with_surrounding_space(node.first_argument.source_range, newlines: false)
           end
         end
+
+        def argument_matched?(target_argument, redundant_argument)
+          argument = if target_argument.is_a?(AST::Node)
+                       target_argument.source
+                     elsif exclude_cntrl_character?(target_argument, redundant_argument)
+                       target_argument.inspect
+                     else
+                       target_argument.to_s
+                     end
+
+          argument == redundant_argument
+        end
+
+        def exclude_cntrl_character?(target_argument, redundant_argument)
+          !target_argument.to_s.sub(/\A'/, '"').sub(/'\z/, '"').match?(/[[:cntrl:]]/) ||
+            !redundant_argument.match?(/[[:cntrl:]]/)
+        end
       end
     end
   end

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

@@ -18,10 +18,10 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Remove the redundant current directory path.'
+        RESTRICT_ON_SEND = %i[require_relative].freeze
         CURRENT_DIRECTORY_PATH = './'
 
         def on_send(node)
-          return unless node.method?(:require_relative)
           return unless (first_argument = node.first_argument)
           return unless first_argument.str_content&.start_with?(CURRENT_DIRECTORY_PATH)
           return unless (index = first_argument.source.index(CURRENT_DIRECTORY_PATH))

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

@@ -86,7 +86,7 @@ module RuboCop
         def range(node)
           return node.selector unless node.method?(:each)
 
-          if node.parent.call_type?
+          if node.parent&.call_type?
             node.selector.join(node.parent.loc.dot)
           else
             node.loc.dot.join(node.selector)

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

@@ -79,7 +79,7 @@ module RuboCop
         private_constant :REPLACEMENT_METHODS
 
         def on_send(node)
-          return if node.arguments? || node.block_node
+          return if node.arguments? || node.block_literal?
 
           select_predicate?(node) do |select_node, filter_method|
             return if RAILS_METHODS.include?(filter_method) && !active_support_extensions_enabled?

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

@@ -72,7 +72,7 @@ module RuboCop
         ALLOWED_STRING_TOKENS = %i[tSTRING tSTRING_CONTENT].freeze
         ARGUMENT_TYPES = %i[
           kFALSE kNIL kSELF kTRUE tCONSTANT tCVAR tFLOAT tGVAR tIDENTIFIER tINTEGER tIVAR
-          tLABEL tLBRACK tLCURLY tLPAREN_ARG tSTRING tSTRING_BEG tSYMBOL tXSTRING_BEG
+          tLBRACK tLCURLY tLPAREN_ARG tSTRING tSTRING_BEG tSYMBOL tXSTRING_BEG
         ].freeze
 
         def on_new_investigation
@@ -124,10 +124,8 @@ module RuboCop
           return true unless (node = find_node_for_line(range.line))
           return false if argument_newline?(node)
 
-          continuation_node = node.parent || node
-          return false if allowed_type?(node) || allowed_type?(continuation_node)
-
-          continuation_node.source.include?("\n") || continuation_node.source.include?("\\\n")
+          source = node.parent ? node.parent.source : node.source
+          parse(source.gsub("\\\n", "\n")).valid_syntax?
         end
 
         def inside_string_literal?(range, token)
@@ -139,25 +137,27 @@ module RuboCop
         #   do_something \
         #     argument
         def method_with_argument?(current_token, next_token)
-          current_token.type == :tIDENTIFIER && ARGUMENT_TYPES.include?(next_token.type)
+          return false if current_token.type != :tIDENTIFIER && current_token.type != :kRETURN
+
+          ARGUMENT_TYPES.include?(next_token.type)
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable Metrics/AbcSize
         def argument_newline?(node)
           node = node.to_a.last if node.assignment?
           return false if node.parenthesized_call?
 
           node = node.children.first if node.root? && node.begin_type?
 
-          if argument_is_method?(node) || node.begin_type?
-            argument_newline?(node.children.first)
+          if argument_is_method?(node)
+            argument_newline?(node.first_argument)
           else
             return false unless method_call_with_arguments?(node)
 
-            !same_line?(node, node.first_argument)
+            node.loc.selector.line != node.first_argument.loc.line
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/AbcSize
 
         def find_node_for_line(line)
           processed_source.ast.each_node do |node|
@@ -165,10 +165,6 @@ module RuboCop
           end
         end
 
-        def allowed_type?(node)
-          node.and_type? || node.or_type? || (node.if_type? && node.ternary?)
-        end
-
         def same_line?(node, line)
           return false unless (source_range = node.source_range)
 

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

@@ -53,7 +53,7 @@ module RuboCop
           return if interpolated_quotes?(node) || allowed_percent_q?(node)
 
           add_offense(node) do |corrector|
-            delimiter = /^%Q[^"]+$|'/.match?(node.source) ? QUOTE : SINGLE_QUOTE
+            delimiter = /\A%Q[^"]+\z|'/.match?(node.source) ? QUOTE : SINGLE_QUOTE
 
             corrector.replace(node.loc.begin, delimiter)
             corrector.replace(node.loc.end, delimiter)

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

@@ -131,7 +131,7 @@ module RuboCop
         end
 
         def in_same_section?(node1, node2)
-          !node1.source_range.with(end_pos: node2.source_range.end_pos).source.include?("\n\n")
+          !node1.source_range.join(node2.source_range.end).source.include?("\n\n")
         end
       end
     end

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

@@ -7,12 +7,12 @@ module RuboCop
       #
       # @example
       #   # bad
-      #   Foo.send(:bar)
-      #   quuz.send(:fred)
+      #   Foo.send(bar)
+      #   quuz.send(fred)
       #
       #   # good
-      #   Foo.__send__(:bar)
-      #   quuz.public_send(:fred)
+      #   Foo.__send__(bar)
+      #   quuz.public_send(fred)
       class Send < Base
         MSG = 'Prefer `Object#__send__` or `Object#public_send` to `send`.'
         RESTRICT_ON_SEND = %i[send].freeze

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

@@ -77,7 +77,7 @@ module RuboCop
 
         # @!method define_method_block?(node)
         def_node_matcher :define_method_block?, <<~PATTERN
-          ({block numblock} (send _ {:define_method} _) ...)
+          ({block numblock} (send _ :define_method _) ...)
         PATTERN
       end
     end

data/lib/rubocop/cop/team.rb

@@ -174,6 +174,9 @@ module RuboCop
       end
 
       def support_target_rails_version?(cop)
+        # In this case, the rails version was already checked by `#excluded_file?`
+        return true if defined?(RuboCop::Rails::TargetRailsVersion::USES_REQUIRES_GEM_API)
+
         return true unless cop.class.respond_to?(:support_target_rails_version?)
 
         cop.class.support_target_rails_version?(cop.target_rails_version)

data/lib/rubocop/formatter/clang_style_formatter.rb

@@ -24,14 +24,10 @@ module RuboCop
           message: message(offense)
         )
 
-        begin
-          return unless valid_line?(offense)
+        return unless valid_line?(offense)
 
-          report_line(offense.location)
-          report_highlighted_area(offense.highlighted_area)
-        rescue IndexError
-          # range is not on a valid line; perhaps the source file is empty
-        end
+        report_line(offense.location)
+        report_highlighted_area(offense.highlighted_area)
       end
 
       def valid_line?(offense)

data/lib/rubocop/formatter/tap_formatter.rb

@@ -53,14 +53,10 @@ module RuboCop
           message: message(offense)
         )
 
-        begin
-          return unless valid_line?(offense)
+        return unless valid_line?(offense)
 
-          report_line(offense.location)
-          report_highlighted_area(offense.highlighted_area)
-        rescue IndexError
-          # range is not on a valid line; perhaps the source file is empty
-        end
+        report_line(offense.location)
+        report_highlighted_area(offense.highlighted_area)
       end
 
       def annotate_message(msg)