rubocop 1.18.0 → 1.56.0

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for multiple expressions placed on the same line.
+      # Checks for multiple expressions placed on the same line.
       # It also checks for lines terminated with a semicolon.
       #
       # This cop has `AllowAsExpressionSeparator` configuration option.
@@ -32,69 +32,132 @@ module RuboCop
 
         MSG = 'Do not use semicolons to terminate expressions.'
 
-        def on_new_investigation
-          return if processed_source.blank?
+        def self.autocorrect_incompatible_with
+          [Style::SingleLineMethods]
+        end
 
-          @processed_source = processed_source
+        def on_new_investigation
+          return if processed_source.blank? || !processed_source.raw_source.include?(';')
 
           check_for_line_terminator_or_opener
         end
 
-        def on_begin(node) # rubocop:todo Metrics/CyclomaticComplexity
+        def on_begin(node)
           return if cop_config['AllowAsExpressionSeparator']
+          return unless node.source.include?(';')
 
           exprs = node.children
 
           return if exprs.size < 2
 
-          # create a map matching lines to the number of expressions on them
-          exprs_lines = exprs.map(&:first_line)
-          lines = exprs_lines.group_by(&:itself)
-
-          lines.each do |line, expr_on_line|
+          expressions_per_line(exprs).each do |line, expr_on_line|
             # Every line with more than one expression on it is a
             # potential offense
             next unless expr_on_line.size > 1
 
-            # TODO: Find the correct position of the semicolon. We don't know
-            # if the first semicolon on the line is a separator of
-            # expressions. It's just a guess.
-            column = @processed_source[line - 1].index(';')
-
-            next unless column
-
-            convention_on(line, column, false)
+            find_semicolon_positions(line) { |pos| register_semicolon(line, pos, true) }
           end
         end
 
         private
 
         def check_for_line_terminator_or_opener
-          # Make the obvious check first
-          return unless @processed_source.raw_source.include?(';')
-
-          each_semicolon { |line, column| convention_on(line, column, true) }
+          each_semicolon do |line, column, token_before_semicolon|
+            register_semicolon(line, column, false, token_before_semicolon)
+          end
         end
 
         def each_semicolon
           tokens_for_lines.each do |line, tokens|
-            yield line, tokens.last.column if tokens.last.semicolon?
-            yield line, tokens.first.column if tokens.first.semicolon?
+            semicolon_pos = semicolon_position(tokens)
+            after_expr_pos = semicolon_pos == -1 ? -2 : semicolon_pos
+
+            yield line, tokens[semicolon_pos].column, tokens[after_expr_pos] if semicolon_pos
           end
         end
 
         def tokens_for_lines
-          @processed_source.tokens.group_by(&:line)
+          processed_source.tokens.group_by(&:line)
+        end
+
+        def semicolon_position(tokens)
+          if tokens.last.semicolon?
+            -1
+          elsif tokens.first.semicolon?
+            0
+          elsif exist_semicolon_before_right_curly_brace?(tokens)
+            -3
+          elsif exist_semicolon_after_left_curly_brace?(tokens) ||
+                exist_semicolon_after_left_string_interpolation_brace?(tokens)
+            2
+          elsif exist_semicolon_before_right_string_interpolation_brace?(tokens)
+            -4
+          end
+        end
+
+        def exist_semicolon_before_right_curly_brace?(tokens)
+          tokens[-2]&.right_curly_brace? && tokens[-3]&.semicolon?
+        end
+
+        def exist_semicolon_after_left_curly_brace?(tokens)
+          tokens[1]&.left_curly_brace? && tokens[2]&.semicolon?
         end
 
-        def convention_on(line, column, autocorrect)
-          range = source_range(@processed_source.buffer, line, column)
-          # Don't attempt to autocorrect if semicolon is separating statements
-          # on the same line
+        def exist_semicolon_before_right_string_interpolation_brace?(tokens)
+          tokens[-3]&.type == :tSTRING_DEND && tokens[-4]&.semicolon?
+        end
+
+        def exist_semicolon_after_left_string_interpolation_brace?(tokens)
+          tokens[1]&.type == :tSTRING_DBEG && tokens[2]&.semicolon?
+        end
+
+        def register_semicolon(line, column, after_expression, token_before_semicolon = nil)
+          range = source_range(processed_source.buffer, line, column)
+
           add_offense(range) do |corrector|
-            corrector.remove(range) if autocorrect
+            if after_expression
+              corrector.replace(range, "\n")
+            else
+              # Prevents becoming one range instance with subsequent line when endless range
+              # without parentheses.
+              # See: https://github.com/rubocop/rubocop/issues/10791
+              if token_before_semicolon&.regexp_dots?
+                range_node = find_range_node(token_before_semicolon)
+                corrector.wrap(range_node, '(', ')') if range_node
+              end
+
+              corrector.remove(range)
+            end
+          end
+        end
+
+        def expressions_per_line(exprs)
+          # create a map matching lines to the number of expressions on them
+          exprs_lines = exprs.map(&:first_line)
+          exprs_lines.group_by(&:itself)
+        end
+
+        def find_semicolon_positions(line)
+          # Scan for all the semicolons on the line
+          semicolons = processed_source[line - 1].enum_for(:scan, ';')
+          semicolons.each do
+            yield Regexp.last_match.begin(0)
           end
         end
+
+        def find_range_node(token_before_semicolon)
+          range_nodes.detect do |range_node|
+            range_node.source_range.contains?(token_before_semicolon.pos)
+          end
+        end
+
+        def range_nodes
+          return @range_nodes if instance_variable_defined?(:@range_nodes)
+
+          ast = processed_source.ast
+          @range_nodes = ast.range_type? ? [ast] : []
+          @range_nodes.concat(ast.each_descendant(:irange, :erange).to_a)
+        end
       end
     end
   end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for the use of the send method.
+      # Checks for the use of the send method.
       #
       # @example
       #   # bad

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for uses of `fail` and `raise`.
+      # Checks for uses of `fail` and `raise`.
       #
       # @example EnforcedStyle: only_raise (default)
       #   # The `only_raise` style enforces the sole use of `raise`.
@@ -119,11 +119,6 @@ module RuboCop
         # @!method custom_fail_methods(node)
         def_node_search :custom_fail_methods, '{(def :fail ...) (defs _ :fail ...)}'
 
-        def on_new_investigation
-          ast = processed_source.ast
-          @custom_fail_defined = ast && custom_fail_methods(ast).any?
-        end
-
         def on_rescue(node)
           return unless style == :semantic
 
@@ -141,7 +136,7 @@ module RuboCop
           when :semantic
             check_send(:raise, node) unless ignored_node?(node)
           when :only_raise
-            return if @custom_fail_defined
+            return if custom_fail_defined?
 
             check_send(:fail, node)
           when :only_fail
@@ -151,6 +146,13 @@ module RuboCop
 
         private
 
+        def custom_fail_defined?
+          return @custom_fail_defined if defined?(@custom_fail_defined)
+
+          ast = processed_source.ast
+          @custom_fail_defined = ast && custom_fail_methods(ast).any?
+        end
+
         def message(method_name)
           case style
           when :semantic
@@ -196,7 +198,7 @@ module RuboCop
         end
 
         def command_or_kernel_call?(name, node)
-          return unless node.method?(name)
+          return false unless node.method?(name)
 
           node.command?(name) || kernel_call?(node, name)
         end

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

@@ -6,6 +6,11 @@ module RuboCop
       # Sometimes using dig method ends up with just a single
       # argument. In such cases, dig should be replaced with [].
       #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   is an `Enumerable` or does not have a nonstandard implementation
+      #   of `dig`.
+      #
       # @example
       #   # bad
       #   { key: 'value' }.dig(:key)
@@ -39,15 +44,20 @@ module RuboCop
 
           expression = single_argument_dig?(node)
           return unless expression
+          return if expression.forwarded_args_type?
 
           receiver = node.receiver.source
           argument = expression.source
 
           message = format(MSG, receiver: receiver, argument: argument, original: node.source)
           add_offense(node, message: message) do |corrector|
+            next if part_of_ignored_node?(node)
+
             correct_access = "#{receiver}[#{argument}]"
             corrector.replace(node, correct_access)
           end
+
+          ignore_node(node)
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks whether the block parameters of a single-line
+      # Checks whether the block parameters of a single-line
       # method accepting a block match the names specified via configuration.
       #
       # For instance one can configure `reduce`(`inject`) to use |a, e| as
@@ -33,13 +33,13 @@ module RuboCop
 
         MSG = 'Name `%<method>s` block params `|%<params>s|`.'
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           return unless node.single_line?
 
           return unless eligible_method?(node)
           return unless eligible_arguments?(node)
 
-          method_name = node.send_node.method_name
+          method_name = node.method_name
           return if args_match?(method_name, node.arguments)
 
           preferred_block_arguments = build_preferred_arguments_map(node, target_args(method_name))
@@ -81,7 +81,7 @@ module RuboCop
         end
 
         def eligible_method?(node)
-          node.send_node.receiver && method_names.include?(node.send_node.method_name)
+          node.receiver && method_names.include?(node.method_name)
         end
 
         def methods
@@ -109,7 +109,9 @@ module RuboCop
           # we remove any leading underscores before comparing.
           actual_args_no_underscores = actual_args.map { |arg| arg.to_s.sub(/^_+/, '') }
 
-          actual_args_no_underscores == target_args(method_name)
+          # Allow the arguments if the names match but not all are given
+          expected_args = target_args(method_name).first(actual_args_no_underscores.size)
+          actual_args_no_underscores == expected_args
         end
       end
     end

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

@@ -3,13 +3,13 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for single-line method definitions that contain a body.
+      # Checks for single-line method definitions that contain a body.
       # It will accept single-line methods with no body.
       #
       # Endless methods added in Ruby 3.0 are also accepted by this cop.
       #
       # If `Style/EndlessMethod` is enabled with `EnforcedStyle: allow_single_line` or
-      # `allow_always`, single-line methods will be auto-corrected to endless
+      # `allow_always`, single-line methods will be autocorrected to endless
       # methods if there is only one statement in the body.
       #
       # @example
@@ -36,6 +36,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Avoid single-line method definitions.'
+        NOT_SUPPORTED_ENDLESS_METHOD_BODY_TYPES = %i[return break next].freeze
 
         def on_def(node)
           return unless node.single_line?
@@ -62,29 +63,24 @@ module RuboCop
 
         def correct_to_endless?(body_node)
           return false if target_ruby_version < 3.0
-
-          endless_method_config = config.for_cop('Style/EndlessMethod')
-
-          return false unless endless_method_config['Enabled']
-          return false if endless_method_config['EnforcedStyle'] == 'disallow'
+          return false if disallow_endless_method_style?
           return false unless body_node
-          return false if body_node.parent.assignment_method?
+          return false if body_node.parent.assignment_method? ||
+                          NOT_SUPPORTED_ENDLESS_METHOD_BODY_TYPES.include?(body_node.type)
 
           !(body_node.begin_type? || body_node.kwbegin_type?)
         end
 
         def correct_to_multiline(corrector, node)
-          each_part(node.body) do |part|
-            LineBreakCorrector.break_line_before(
-              range: part, node: node, corrector: corrector,
-              configured_width: configured_indentation_width
-            )
+          if (body = node.body) && body.begin_type? && body.parenthesized_call?
+            break_line_before(corrector, node, body)
+          else
+            each_part(body) do |part|
+              break_line_before(corrector, node, part)
+            end
           end
 
-          LineBreakCorrector.break_line_before(
-            range: node.loc.end, node: node, corrector: corrector,
-            indent_steps: 0, configured_width: configured_indentation_width
-          )
+          break_line_before(corrector, node, node.loc.end, indent_steps: 0)
 
           move_comment(node, corrector)
         end
@@ -98,6 +94,13 @@ module RuboCop
           corrector.replace(node, replacement)
         end
 
+        def break_line_before(corrector, node, range, indent_steps: 1)
+          LineBreakCorrector.break_line_before(
+            range: range, node: node, corrector: corrector,
+            configured_width: configured_indentation_width, indent_steps: indent_steps
+          )
+        end
+
         def each_part(body)
           return unless body
 
@@ -129,6 +132,13 @@ module RuboCop
         def require_parentheses?(method_body)
           method_body.send_type? && !method_body.arguments.empty? && !method_body.comparison_method?
         end
+
+        def disallow_endless_method_style?
+          endless_method_config = config.for_cop('Style/EndlessMethod')
+          return true unless endless_method_config['Enabled']
+
+          endless_method_config['EnforcedStyle'] == 'disallow'
+        end
       end
     end
   end

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

@@ -3,9 +3,22 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks that arrays are sliced with endless ranges instead of
+      # Checks that arrays are sliced with endless ranges instead of
       # `ary[start..-1]` on Ruby 2.6+.
       #
+      # @safety
+      #   This cop is unsafe because `x..-1` and `x..` are only guaranteed to
+      #   be equivalent for `Array#[]`, `String#[]`, and the cop cannot determine what class
+      #   the receiver is.
+      #
+      #   For example:
+      #   [source,ruby]
+      #   ----
+      #   sum = proc { |ary| ary.sum }
+      #   sum[-3..-1] # => -6
+      #   sum[-3..] # Hangs forever
+      #   ----
+      #
       # @example
       #   # bad
       #   items[1..-1]

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

@@ -15,6 +15,11 @@ module RuboCop
       #     end
       #   end
       #
+      #   # bad
+      #   if condition_b
+      #     do_something
+      #   end if condition_a
+      #
       #   # good
       #   if condition_a && condition_b
       #     do_something
@@ -26,24 +31,37 @@ module RuboCop
       #     do_something if condition_b
       #   end
       #
+      #   # bad
+      #   if condition_b
+      #     do_something
+      #   end if condition_a
+      #
       # @example AllowModifier: true
       #   # good
       #   if condition_a
       #     do_something if condition_b
       #   end
       #
+      #   # good
+      #   if condition_b
+      #     do_something
+      #   end if condition_a
       class SoleNestedConditional < Base
         include RangeHelp
         extend AutoCorrector
 
         MSG = 'Consider merging nested conditions into outer `%<conditional_type>s` conditions.'
 
+        def self.autocorrect_incompatible_with
+          [Style::NegatedIf, Style::NegatedUnless]
+        end
+
         def on_if(node)
           return if node.ternary? || node.else? || node.elsif?
 
           if_branch = node.if_branch
           return if use_variable_assignment_in_condition?(node.condition, if_branch)
-          return unless offending_branch?(if_branch)
+          return unless offending_branch?(node, if_branch)
 
           message = format(MSG, conditional_type: node.keyword)
           add_offense(if_branch.loc.keyword, message: message) do |corrector|
@@ -68,49 +86,59 @@ module RuboCop
           end
         end
 
-        def offending_branch?(branch)
+        def offending_branch?(node, branch)
           return false unless branch
 
           branch.if_type? &&
             !branch.else? &&
             !branch.ternary? &&
-            !(branch.modifier_form? && allow_modifier?)
+            !((node.modifier_form? || branch.modifier_form?) && allow_modifier?)
         end
 
         def autocorrect(corrector, node, if_branch)
-          corrector.wrap(node.condition, '(', ')') if node.condition.or_type?
+          if node.condition.or_type? || node.condition.assignment?
+            corrector.wrap(node.condition, '(', ')')
+          end
+
+          if outer_condition_modify_form?(node, if_branch)
+            autocorrect_outer_condition_modify_form(corrector, node, if_branch)
+          else
+            autocorrect_outer_condition_basic(corrector, node, if_branch)
+          end
+        end
 
+        def autocorrect_outer_condition_basic(corrector, node, if_branch)
           correct_from_unless_to_if(corrector, node) if node.unless?
 
+          outer_condition = node.condition
+          correct_outer_condition(corrector, outer_condition)
+
           and_operator = if_branch.unless? ? ' && !' : ' && '
           if if_branch.modifier_form?
-            correct_for_guard_condition_style(corrector, node, if_branch, and_operator)
+            correct_for_guard_condition_style(corrector, outer_condition, if_branch, and_operator)
           else
             correct_for_basic_condition_style(corrector, node, if_branch, and_operator)
             correct_for_comment(corrector, node, if_branch)
           end
         end
 
-        def correct_from_unless_to_if(corrector, node)
+        def autocorrect_outer_condition_modify_form(corrector, node, if_branch)
+          correct_from_unless_to_if(corrector, if_branch, is_modify_form: true) if if_branch.unless?
+          correct_for_outer_condition_modify_form_style(corrector, node, if_branch)
+        end
+
+        def correct_from_unless_to_if(corrector, node, is_modify_form: false)
           corrector.replace(node.loc.keyword, 'if')
 
-          condition = node.condition
-          if condition.send_type? && condition.comparison_method? && !condition.parenthesized?
-            corrector.wrap(node.condition, '!(', ')')
-          else
-            corrector.insert_before(node.condition, '!')
-          end
+          insert_bang(corrector, node, is_modify_form)
         end
 
-        def correct_for_guard_condition_style(corrector, node, if_branch, and_operator)
-          outer_condition = node.condition
-          correct_outer_condition(corrector, outer_condition)
-
+        def correct_for_guard_condition_style(corrector, outer_condition, if_branch, and_operator)
           condition = if_branch.condition
-          corrector.insert_after(outer_condition, replacement_condition(and_operator, condition))
+          corrector.insert_after(outer_condition, "#{and_operator}#{replace_condition(condition)}")
 
           range = range_between(if_branch.loc.keyword.begin_pos, condition.source_range.end_pos)
-          corrector.remove(range_with_surrounding_space(range: range, newlines: false))
+          corrector.remove(range_with_surrounding_space(range, newlines: false))
           corrector.remove(if_branch.loc.keyword)
         end
 
@@ -120,12 +148,31 @@ module RuboCop
           )
           corrector.replace(range, and_operator)
           corrector.remove(range_by_whole_lines(node.loc.end, include_final_newline: true))
-          corrector.wrap(if_branch.condition, '(', ')') if wrap_condition?(if_branch.condition)
+
+          wrap_condition(corrector, if_branch.condition)
         end
 
-        def correct_for_comment(corrector, node, if_branch)
-          return if config.for_cop('Style/IfUnlessModifier')['Enabled']
+        def wrap_condition(corrector, condition)
+          # Handle `send` and `block` nodes that need to be wrapped in parens
+          # FIXME: autocorrection prevents syntax errors by wrapping the entire node in parens,
+          #        but wrapping the argument list would be a more ergonomic correction.
+          node_to_check = condition&.block_type? ? condition.send_node : condition
+          return unless wrap_condition?(node_to_check)
+
+          corrector.wrap(condition, '(', ')')
+        end
+
+        def correct_for_outer_condition_modify_form_style(corrector, node, if_branch)
+          condition = if_branch.condition
+          corrector.insert_before(condition,
+                                  "#{'!' if node.unless?}#{replace_condition(node.condition)} && ")
 
+          corrector.remove(node.condition)
+          corrector.remove(range_with_surrounding_space(node.loc.keyword, newlines: false))
+          corrector.replace(if_branch.loc.keyword, 'if')
+        end
+
+        def correct_for_comment(corrector, node, if_branch)
           comments = processed_source.ast_with_comments[if_branch]
           comment_text = comments.map(&:text).join("\n") << "\n"
 
@@ -133,18 +180,45 @@ module RuboCop
         end
 
         def correct_outer_condition(corrector, condition)
-          return unless requrie_parentheses?(condition)
+          return unless require_parentheses?(condition)
 
           end_pos = condition.loc.selector.end_pos
           begin_pos = condition.first_argument.source_range.begin_pos
           return if end_pos > begin_pos
 
-          corrector.replace(range_between(end_pos, begin_pos), '(')
-          corrector.insert_after(condition.last_argument.source_range, ')')
+          range = range_between(end_pos, begin_pos)
+          corrector.remove(range)
+          corrector.insert_after(range, '(')
+          corrector.insert_after(condition.last_argument, ')')
+        end
+
+        def insert_bang(corrector, node, is_modify_form)
+          condition = node.condition
+
+          if (condition.send_type? && condition.comparison_method? && !condition.parenthesized?) ||
+             (is_modify_form && wrap_condition?(condition))
+            corrector.wrap(node.condition, '!(', ')')
+          elsif condition.and_type?
+            insert_bang_for_and(corrector, node)
+          else
+            corrector.insert_before(condition, '!')
+          end
         end
 
-        def requrie_parentheses?(condition)
-          condition.send_type? && !condition.arguments.empty? && !condition.parenthesized? &&
+        def insert_bang_for_and(corrector, node)
+          lhs, rhs = *node
+
+          if lhs.and_type?
+            insert_bang_for_and(corrector, lhs)
+            corrector.insert_before(rhs, '!') if rhs
+          else
+            corrector.insert_before(lhs, '!')
+            corrector.insert_before(rhs, '!')
+          end
+        end
+
+        def require_parentheses?(condition)
+          condition.call_type? && !condition.arguments.empty? && !condition.parenthesized? &&
             !condition.comparison_method?
         end
 
@@ -156,20 +230,20 @@ module RuboCop
 
         def wrap_condition?(node)
           node.and_type? || node.or_type? ||
-            (node.send_type? && node.arguments.any? && !node.parenthesized?)
+            (node.call_type? && node.arguments.any? && !node.parenthesized?)
         end
 
-        def replacement_condition(and_operator, condition)
-          if wrap_condition?(condition)
-            "#{and_operator}(#{condition.source})"
-          else
-            "#{and_operator}#{condition.source}"
-          end
+        def replace_condition(condition)
+          wrap_condition?(condition) ? "(#{condition.source})" : condition.source
         end
 
         def allow_modifier?
           cop_config['AllowModifier']
         end
+
+        def outer_condition_modify_form?(node, if_branch)
+          node.condition.source_range.begin_pos > if_branch.condition.source_range.begin_pos
+        end
       end
     end
   end