rubocop 1.31.1 → 1.33.0

data/lib/rubocop/cop/internal_affairs/useless_restrict_on_send.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Check for useless `RESTRICT_ON_SEND`.
+      #
+      # @example
+      #   # bad
+      #   class FooCop
+      #     RESTRICT_ON_SEND = %i[bad_method].freeze
+      #   end
+      #
+      #   # good
+      #   class FooCop
+      #     RESTRICT_ON_SEND = %i[bad_method].freeze
+      #     def on_send(node)
+      #       # ...
+      #     end
+      #   end
+      #
+      #   # good
+      #   class FooCop
+      #     RESTRICT_ON_SEND = %i[bad_method].freeze
+      #     def after_send(node)
+      #       # ...
+      #     end
+      #   end
+      #
+      class UselessRestrictOnSend < Base
+        extend AutoCorrector
+
+        MSG = 'Useless `RESTRICT_ON_SEND` is defined.'
+
+        # @!method defined_send_callback?(node)
+        def_node_search :defined_send_callback?, <<~PATTERN
+          {
+            (def {:on_send :after_send} ...)
+            (alias (sym {:on_send :after_send}) _source ...)
+            (send nil? :alias_method {(sym {:on_send :after_send}) (str {"on_send" "after_send"})} _source ...)
+          }
+        PATTERN
+
+        def on_casgn(node)
+          return if !restrict_on_send?(node) || defined_send_callback?(node.parent)
+
+          add_offense(node) do |corrector|
+            corrector.remove(node)
+          end
+        end
+
+        private
+
+        def restrict_on_send?(node)
+          node.name == :RESTRICT_ON_SEND
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs.rb

@@ -20,3 +20,4 @@ require_relative 'internal_affairs/redundant_method_dispatch_node'
 require_relative 'internal_affairs/style_detected_api_use'
 require_relative 'internal_affairs/undefined_config'
 require_relative 'internal_affairs/useless_message_assertion'
+require_relative 'internal_affairs/useless_restrict_on_send'

data/lib/rubocop/cop/layout/block_end_newline.rb

@@ -36,24 +36,51 @@ module RuboCop
           # If the end is on its own line, there is no offense
           return if begins_its_line?(node.loc.end)
 
-          add_offense(node.loc.end, message: message(node)) do |corrector|
-            corrector.replace(delimiter_range(node), "\n#{node.loc.end.source}#{offset(node)}")
-          end
+          register_offense(node)
         end
 
         private
 
+        def register_offense(node)
+          add_offense(node.loc.end, message: message(node)) do |corrector|
+            offense_range = offense_range(node)
+            replacement = "\n#{offense_range.source.strip}"
+
+            if (heredoc = last_heredoc_argument(node.body))
+              corrector.remove(offense_range)
+              corrector.insert_after(heredoc.loc.heredoc_end, replacement)
+            else
+              corrector.replace(offense_range, replacement)
+            end
+          end
+        end
+
         def message(node)
           format(MSG, line: node.loc.end.line, column: node.loc.end.column + 1)
         end
 
-        def delimiter_range(node)
+        def last_heredoc_argument(node)
+          return unless (arguments = node&.arguments)
+
+          heredoc = arguments.reverse.detect(&:heredoc?)
+          return heredoc if heredoc
+
+          last_heredoc_argument(node.children.first)
+        end
+
+        def offense_range(node)
           Parser::Source::Range.new(
             node.loc.expression.source_buffer,
             node.children.compact.last.loc.expression.end_pos,
-            node.loc.expression.end_pos
+            end_of_method_chain(node).loc.expression.end_pos
           )
         end
+
+        def end_of_method_chain(node)
+          return node unless node.parent&.call_type?
+
+          end_of_method_chain(node.parent)
+        end
       end
     end
   end

data/lib/rubocop/cop/layout/first_argument_indentation.rb

@@ -153,7 +153,8 @@ module RuboCop
         MSG = 'Indent the first argument one step more than %<base>s.'
 
         def on_send(node)
-          return if style != :consistent && enforce_first_argument_with_fixed_indentation?
+          return if style != :consistent && enforce_first_argument_with_fixed_indentation? &&
+                    !enable_layout_first_method_argument_line_break?
           return if !node.arguments? || bare_operator?(node) || node.setter_method?
 
           indent = base_indentation(node) + configured_indentation_width
@@ -267,6 +268,10 @@ module RuboCop
           argument_alignment_config['EnforcedStyle'] == 'with_fixed_indentation'
         end
 
+        def enable_layout_first_method_argument_line_break?
+          config.for_cop('Layout/FirstMethodArgumentLineBreak')['Enabled']
+        end
+
         def argument_alignment_config
           config.for_cop('Layout/ArgumentAlignment')
         end

data/lib/rubocop/cop/layout/first_array_element_indentation.rb

@@ -120,14 +120,15 @@ module RuboCop
             check_first(first_elem, left_bracket, left_parenthesis, 0)
           end
 
-          check_right_bracket(array_node.loc.end, left_bracket, left_parenthesis)
+          check_right_bracket(array_node.loc.end, first_elem, left_bracket, left_parenthesis)
         end
 
-        def check_right_bracket(right_bracket, left_bracket, left_parenthesis)
+        def check_right_bracket(right_bracket, first_elem, left_bracket, left_parenthesis)
           # if the right bracket is on the same line as the last value, accept
           return if /\S/.match?(right_bracket.source_line[0...right_bracket.column])
 
-          expected_column, indent_base_type = indent_base(left_bracket, left_parenthesis)
+          expected_column, indent_base_type = indent_base(left_bracket, first_elem,
+                                                          left_parenthesis)
           @column_delta = expected_column - right_bracket.column
           return if @column_delta.zero?
 

data/lib/rubocop/cop/layout/first_hash_element_indentation.rb

@@ -158,14 +158,14 @@ module RuboCop
             end
           end
 
-          check_right_brace(hash_node.loc.end, left_brace, left_parenthesis)
+          check_right_brace(hash_node.loc.end, first_pair, left_brace, left_parenthesis)
         end
 
-        def check_right_brace(right_brace, left_brace, left_parenthesis)
+        def check_right_brace(right_brace, first_pair, left_brace, left_parenthesis)
           # if the right brace is on the same line as the last value, accept
           return if /\S/.match?(right_brace.source_line[0...right_brace.column])
 
-          expected_column, indent_base_type = indent_base(left_brace, left_parenthesis)
+          expected_column, indent_base_type = indent_base(left_brace, first_pair, left_parenthesis)
           @column_delta = expected_column - right_brace.column
           return if @column_delta.zero?
 

data/lib/rubocop/cop/layout/line_continuation_leading_space.rb

@@ -4,9 +4,10 @@ module RuboCop
   module Cop
     module Layout
       # Checks that strings broken over multiple lines (by a backslash) contain
-      # trailing spaces instead of leading spaces.
+      # trailing spaces instead of leading spaces (default) or leading spaces
+      # instead of trailing spaces.
       #
-      # @example
+      # @example EnforcedStyle: trailing (default)
       #   # bad
       #   'this text contains a lot of' \
       #   '               spaces'
@@ -23,18 +24,38 @@ module RuboCop
       #   'this text is too ' \
       #   'long'
       #
+      # @example EnforcedStyle: leading
+      #   # bad
+      #   'this text contains a lot of               ' \
+      #   'spaces'
+      #
+      #   # good
+      #   'this text contains a lot of' \
+      #   '               spaces'
+      #
+      #   # bad
+      #   'this text is too ' \
+      #   'long'
+      #
+      #   # good
+      #   'this text is too' \
+      #   ' long'
       class LineContinuationLeadingSpace < Base
         include RangeHelp
 
-        MSG = 'Move leading spaces to the end of previous line.'
-
         def on_dstr(node)
-          range_start = node.loc.expression.begin_pos - node.loc.expression.column
+          end_of_first_line = node.loc.expression.begin_pos - node.loc.expression.column
 
           raw_lines(node).each_cons(2) do |raw_line_one, raw_line_two|
-            range_start += raw_line_one.length
+            end_of_first_line += raw_line_one.length
 
-            investigate(raw_line_one, raw_line_two, range_start)
+            next unless continuation?(raw_line_one)
+
+            if enforced_style_leading?
+              investigate_leading_style(raw_line_one, end_of_first_line)
+            else
+              investigate_trailing_style(raw_line_two, end_of_first_line)
+            end
           end
         end
 
@@ -44,24 +65,47 @@ module RuboCop
           processed_source.raw_source.lines[node.first_line - 1, line_range(node).size]
         end
 
-        def investigate(first_line, second_line, range_start)
-          return unless continuation?(first_line)
+        def investigate_leading_style(first_line, end_of_first_line)
+          matches = first_line.match(/(?<trailing_spaces>\s+)(?<ending>['"]\s*\\\n)/)
+          return if matches.nil?
 
-          matches = second_line.match(/\A(?<indent>\s*['"])(?<leading_spaces>\s+)/)
+          add_offense(leading_offense_range(end_of_first_line, matches))
+        end
+
+        def investigate_trailing_style(second_line, end_of_first_line)
+          matches = second_line.match(/\A(?<beginning>\s*['"])(?<leading_spaces>\s+)/)
           return if matches.nil?
 
-          add_offense(offense_range(range_start, matches))
+          add_offense(trailing_offense_range(end_of_first_line, matches))
         end
 
         def continuation?(line)
           line.end_with?("\\\n")
         end
 
-        def offense_range(range_start, matches)
-          begin_pos = range_start + matches[:indent].length
+        def leading_offense_range(end_of_first_line, matches)
+          end_pos = end_of_first_line - matches[:ending].length
+          begin_pos = end_pos - matches[:trailing_spaces].length
+          range_between(begin_pos, end_pos)
+        end
+
+        def trailing_offense_range(end_of_first_line, matches)
+          begin_pos = end_of_first_line + matches[:beginning].length
           end_pos = begin_pos + matches[:leading_spaces].length
           range_between(begin_pos, end_pos)
         end
+
+        def message(_range)
+          if enforced_style_leading?
+            'Move trailing spaces to the start of next line.'
+          else
+            'Move leading spaces to the end of previous line.'
+          end
+        end
+
+        def enforced_style_leading?
+          cop_config['EnforcedStyle'] == 'leading'
+        end
       end
     end
   end

data/lib/rubocop/cop/layout/line_length.rb

@@ -37,6 +37,7 @@ module RuboCop
       # * MultilineHashBraceLayout
       # * MultilineHashKeyLineBreaks
       # * MultilineMethodArgumentLineBreaks
+      # * MultilineMethodParameterLineBreaks
       # * ParameterAlignment
       #
       # Together, these cops will pretty print hashes, arrays,
@@ -79,6 +80,7 @@ module RuboCop
         alias on_array on_potential_breakable_node
         alias on_hash on_potential_breakable_node
         alias on_send on_potential_breakable_node
+        alias on_def on_potential_breakable_node
 
         def on_new_investigation
           check_for_breakable_semicolons(processed_source)

data/lib/rubocop/cop/layout/multiline_method_argument_line_breaks.rb

@@ -6,7 +6,7 @@ module RuboCop
       # Ensures that each argument in a multi-line method call
       # starts on a separate line.
       #
-      # NOTE: this cop does not move the first argument, if you want that to
+      # NOTE: This cop does not move the first argument, if you want that to
       # be on a separate line, see `Layout/FirstMethodArgumentLineBreak`.
       #
       # @example
@@ -22,6 +22,9 @@ module RuboCop
       #     b,
       #     c
       #   )
+      #
+      #   # good
+      #   foo(a, b, c)
       class MultilineMethodArgumentLineBreaks < Base
         include MultilineElementLineBreaks
         extend AutoCorrector

data/lib/rubocop/cop/layout/multiline_method_parameter_line_breaks.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Ensures that each parameter in a multi-line method definition
+      # starts on a separate line.
+      #
+      # NOTE: This cop does not move the first argument, if you want that to
+      # be on a separate line, see `Layout/FirstMethodParameterLineBreak`.
+      #
+      # @example
+      #
+      #   # bad
+      #   def foo(a, b,
+      #     c
+      #   )
+      #   end
+      #
+      #   # good
+      #   def foo(
+      #     a,
+      #     b,
+      #     c
+      #   )
+      #   end
+      #
+      #   # good
+      #   def foo(a, b, c)
+      #   end
+      class MultilineMethodParameterLineBreaks < Base
+        include MultilineElementLineBreaks
+        extend AutoCorrector
+
+        MSG = 'Each parameter in a multi-line method definition must start on a separate line.'
+
+        def on_def(node)
+          return if node.arguments.empty?
+
+          check_line_breaks(node, node.arguments)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/ambiguous_block_association.rb

@@ -6,7 +6,8 @@ module RuboCop
       # Checks for ambiguous block association with method
       # when param passed without parentheses.
       #
-      # This cop can customize ignored methods with `IgnoredMethods`.
+      # This cop can customize allowed methods with `AllowedMethods`.
+      # By default, there are no methods to allowed.
       #
       # @example
       #
@@ -29,12 +30,30 @@ module RuboCop
       #   # Lambda arguments require no disambiguation
       #   foo = ->(bar) { bar.baz }
       #
-      # @example IgnoredMethods: [change]
+      # @example AllowedMethods: [] (default)
+      #
+      #   # bad
+      #   expect { do_something }.to change { object.attribute }
+      #
+      # @example AllowedMethods: [change]
       #
       #   # good
       #   expect { do_something }.to change { object.attribute }
+      #
+      # @example AllowedPatterns: [] (default)
+      #
+      #   # bad
+      #   expect { do_something }.to change { object.attribute }
+      #
+      # @example AllowedPatterns: [/change/]
+      #
+      #   # good
+      #   expect { do_something }.to change { object.attribute }
+      #   expect { do_something }.to not_change { object.attribute }
+      #
       class AmbiguousBlockAssociation < Base
-        include IgnoredMethods
+        include AllowedMethods
+        include AllowedPattern
 
         MSG = 'Parenthesize the param `%<param>s` to make sure that the ' \
               'block will be associated with the `%<method>s` method ' \
@@ -45,7 +64,7 @@ module RuboCop
 
           return unless ambiguous_block_association?(node)
           return if node.parenthesized? || node.last_argument.lambda? || node.last_argument.proc? ||
-                    allowed_method?(node)
+                    allowed_method_pattern?(node)
 
           message = message(node)
 
@@ -59,9 +78,10 @@ module RuboCop
           send_node.last_argument.block_type? && !send_node.last_argument.send_node.arguments?
         end
 
-        def allowed_method?(node)
+        def allowed_method_pattern?(node)
           node.assignment? || node.operator_method? || node.method?(:[]) ||
-            ignored_method?(node.last_argument.send_node.source)
+            allowed_method?(node.last_argument.method_name) ||
+            matches_allowed_pattern?(node.last_argument.method_name)
         end
 
         def message(send_node)

data/lib/rubocop/cop/lint/debugger.rb

@@ -15,9 +15,19 @@ module RuboCop
       # [source,yaml]
       # ----
       # Lint/Debugger:
-      #   WebConsole: ~
+      #   DebuggerMethods:
+      #     WebConsole: ~
       # ----
       #
+      # You can also add your own methods by adding a new category:
+      #
+      # [source,yaml]
+      # ----
+      # Lint/Debugger:
+      #   DebuggerMethods:
+      #     MyDebugger:
+      #       MyDebugger.debug_this
+      # ----
       #
       # @example
       #

data/lib/rubocop/cop/lint/deprecated_class_methods.rb

@@ -8,22 +8,22 @@ module RuboCop
       # @example
       #
       #   # bad
-      #
       #   File.exists?(some_path)
       #   Dir.exists?(some_path)
       #   iterator?
       #   ENV.freeze # Calling `Env.freeze` raises `TypeError` since Ruby 2.7.
+      #   ENV.clone
+      #   ENV.dup # Calling `Env.dup` raises `TypeError` since Ruby 3.1.
       #   Socket.gethostbyname(host)
       #   Socket.gethostbyaddr(host)
       #
-      # @example
-      #
       #   # good
-      #
       #   File.exist?(some_path)
       #   Dir.exist?(some_path)
       #   block_given?
       #   ENV # `ENV.freeze` cannot prohibit changes to environment variables.
+      #   ENV.to_h
+      #   ENV.to_h # `ENV.dup` cannot dup `ENV`, use `ENV.to_h` to get a copy of `ENV` as a hash.
       #   Addrinfo.getaddrinfo(nodename, service)
       #   Addrinfo.tcp(host, port).getnameinfo
       class DeprecatedClassMethods < Base
@@ -111,6 +111,12 @@ module RuboCop
           DeprecatedClassMethod.new(:freeze, class_constant: :ENV) =>
             Replacement.new(nil, class_constant: :ENV),
 
+          DeprecatedClassMethod.new(:clone, class_constant: :ENV) =>
+            Replacement.new(:to_h, class_constant: :ENV),
+
+          DeprecatedClassMethod.new(:dup, class_constant: :ENV) =>
+            Replacement.new(:to_h, class_constant: :ENV),
+
           DeprecatedClassMethod.new(:gethostbyaddr, class_constant: :Socket, correctable: false) =>
             Replacement.new(:getnameinfo, class_constant: :Addrinfo, instance_method: true),
 

data/lib/rubocop/cop/lint/empty_conditional_body.rb

@@ -4,6 +4,9 @@ module RuboCop
   module Cop
     module Lint
       # Checks for the presence of `if`, `elsif` and `unless` branches without a body.
+      #
+      # NOTE: empty `else` branches are handled by `Style/EmptyElse`.
+      #
       # @example
       #   # bad
       #   if condition
@@ -53,7 +56,9 @@ module RuboCop
       #   end
       #
       class EmptyConditionalBody < Base
+        extend AutoCorrector
         include CommentsHelp
+        include RangeHelp
 
         MSG = 'Avoid `%<keyword>s` branches without a body.'
 
@@ -61,7 +66,61 @@ module RuboCop
           return if node.body
           return if cop_config['AllowComments'] && contains_comments?(node)
 
-          add_offense(node, message: format(MSG, keyword: node.keyword))
+          add_offense(node, message: format(MSG, keyword: node.keyword)) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          remove_comments(corrector, node)
+          remove_empty_branch(corrector, node)
+          correct_other_branches(corrector, node)
+        end
+
+        def remove_comments(corrector, node)
+          comments_in_range(node).each do |comment|
+            range = range_by_whole_lines(comment.loc.expression, include_final_newline: true)
+            corrector.remove(range)
+          end
+        end
+
+        def remove_empty_branch(corrector, node)
+          corrector.remove(deletion_range(branch_range(node)))
+        end
+
+        def correct_other_branches(corrector, node)
+          return unless (node.if? || node.unless?) && node.else_branch
+
+          if node.else_branch.if_type?
+            # Replace an orphaned `elsif` with `if`
+            corrector.replace(node.else_branch.loc.keyword, 'if')
+          else
+            # Flip orphaned `else`
+            corrector.replace(node.loc.else, "#{node.inverse_keyword} #{node.condition.source}")
+          end
+        end
+
+        def branch_range(node)
+          if node.loc.else
+            node.source_range.with(end_pos: node.loc.else.begin_pos - 1)
+          else
+            node.source_range
+          end
+        end
+
+        def deletion_range(range)
+          # Collect a range between the start of the `if` node and the next relevant node,
+          # including final new line.
+          # Based on `RangeHelp#range_by_whole_lines` but allows the `if` to not start
+          # on the first column.
+          buffer = @processed_source.buffer
+
+          last_line = buffer.source_line(range.last_line)
+          end_offset = last_line.length - range.last_column + 1
+
+          range.adjust(end_pos: end_offset).intersect(buffer.source_range)
         end
       end
     end