rubocop 1.52.1 → 1.79.2

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

@@ -96,11 +96,7 @@ module RuboCop
         end
 
         def autocorrect(corrector, node, if_branch)
-          if node.condition.or_type? || node.condition.assignment?
-            corrector.wrap(node.condition, '(', ')')
-          end
-
-          if outer_condition_modify_form?(node, if_branch)
+          if node.modifier_form?
             autocorrect_outer_condition_modify_form(corrector, node, if_branch)
           else
             autocorrect_outer_condition_basic(corrector, node, if_branch)
@@ -108,142 +104,133 @@ module RuboCop
         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)
+          correct_node(corrector, node)
 
-          and_operator = if_branch.unless? ? ' && !' : ' && '
           if if_branch.modifier_form?
-            correct_for_guard_condition_style(corrector, outer_condition, if_branch, and_operator)
+            correct_for_guard_condition_style(corrector, node, if_branch)
           else
-            correct_for_basic_condition_style(corrector, node, if_branch, and_operator)
+            correct_for_basic_condition_style(corrector, node, if_branch)
             correct_for_comment(corrector, node, if_branch)
           end
         end
 
-        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)
+        def correct_node(corrector, node)
+          corrector.replace(node.loc.keyword, 'if') if node.unless? && !part_of_ignored_node?(node)
+          corrector.replace(node.condition, chainable_condition(node))
+          ignore_node(node)
         end
 
-        def correct_from_unless_to_if(corrector, node, is_modify_form: false)
-          corrector.replace(node.loc.keyword, 'if')
+        def correct_for_guard_condition_style(corrector, node, if_branch)
+          corrector.insert_after(node.condition, " && #{chainable_condition(if_branch)}")
 
-          insert_bang(corrector, node, is_modify_form)
-        end
-
-        def correct_for_guard_condition_style(corrector, outer_condition, if_branch, and_operator)
-          condition = if_branch.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)
+          range = range_between(
+            if_branch.loc.keyword.begin_pos, if_branch.condition.source_range.end_pos
+          )
           corrector.remove(range_with_surrounding_space(range, newlines: false))
-          corrector.remove(if_branch.loc.keyword)
         end
 
-        def correct_for_basic_condition_style(corrector, node, if_branch, and_operator)
+        def correct_for_basic_condition_style(corrector, node, if_branch)
           range = range_between(
             node.condition.source_range.end_pos, if_branch.condition.source_range.begin_pos
           )
-          corrector.replace(range, and_operator)
-          corrector.remove(range_by_whole_lines(node.loc.end, include_final_newline: true))
+          corrector.replace(range, ' && ')
 
-          wrap_condition(corrector, if_branch.condition)
-        end
+          corrector.replace(if_branch.condition, chainable_condition(if_branch))
 
-        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, '(', ')')
+          corrector.remove(range_by_whole_lines(node.loc.end, include_final_newline: true))
         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)} && ")
+        def autocorrect_outer_condition_modify_form(corrector, node, if_branch)
+          correct_node(corrector, if_branch)
+
+          corrector.insert_before(if_branch.condition, "#{chainable_condition(node)} && ")
 
-          corrector.remove(node.condition)
-          corrector.remove(range_with_surrounding_space(node.loc.keyword, newlines: false))
-          corrector.replace(if_branch.loc.keyword, 'if')
+          range = range_between(node.loc.keyword.begin_pos, node.condition.source_range.end_pos)
+          corrector.remove(range_with_surrounding_space(range, newlines: false))
         end
 
         def correct_for_comment(corrector, node, if_branch)
-          comments = processed_source.ast_with_comments[if_branch]
+          comments = processed_source.ast_with_comments[if_branch].select do |comment|
+            comment.loc.line < if_branch.condition.first_line
+          end
           comment_text = comments.map(&:text).join("\n") << "\n"
 
           corrector.insert_before(node.loc.keyword, comment_text) unless comments.empty?
         end
 
-        def correct_outer_condition(corrector, condition)
-          return unless require_parentheses?(condition)
+        def chainable_condition(node)
+          wrapped_condition = add_parentheses_if_needed(node.condition)
 
-          end_pos = condition.loc.selector.end_pos
-          begin_pos = condition.first_argument.source_range.begin_pos
-          return if end_pos > begin_pos
+          return wrapped_condition if node.if?
 
-          range = range_between(end_pos, begin_pos)
-          corrector.remove(range)
-          corrector.insert_after(range, '(')
-          corrector.insert_after(condition.last_argument, ')')
+          node.condition.and_type? ? "!(#{wrapped_condition})" : "!#{wrapped_condition}"
         end
 
-        def insert_bang(corrector, node, is_modify_form)
-          condition = node.condition
+        def add_parentheses_if_needed(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&.any_block_type? ? condition.send_node : condition
+          return condition.source unless add_parentheses?(node_to_check)
 
-          if (condition.send_type? && condition.comparison_method? && !condition.parenthesized?) ||
-             (is_modify_form && wrap_condition?(condition))
-            corrector.wrap(node.condition, '!(', ')')
+          if parenthesize_method?(condition)
+            parenthesized_method_arguments(condition)
           elsif condition.and_type?
-            insert_bang_for_and(corrector, node)
+            parenthesized_and(condition)
           else
-            corrector.insert_before(condition, '!')
+            "(#{condition.source})"
           end
         end
 
-        def insert_bang_for_and(corrector, node)
-          lhs, rhs = *node
+        def parenthesize_method?(node)
+          node.call_type? && node.arguments.any? && !node.parenthesized? &&
+            !node.comparison_method? && !node.operator_method?
+        end
 
-          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
+        def add_parentheses?(node)
+          return true if node.assignment? || node.or_type?
+          return true if assignment_in_and?(node)
+          return false unless node.call_type?
+
+          (node.arguments.any? && !node.parenthesized?) || node.prefix_not?
         end
 
-        def require_parentheses?(condition)
-          condition.call_type? && !condition.arguments.empty? && !condition.parenthesized? &&
-            !condition.comparison_method?
+        def assignment_in_and?(node)
+          return false unless node.and_type?
+
+          node.each_descendant.any?(&:assignment?)
         end
 
-        def arguments_range(node)
-          range_between(
-            node.first_argument.source_range.begin_pos, node.last_argument.source_range.end_pos
-          )
+        def parenthesized_method_arguments(node)
+          method_call = node.source_range.begin.join(node.loc.selector.end).source
+          arguments = node.first_argument.source_range.begin.join(node.source_range.end).source
+
+          "#{method_call}(#{arguments})"
         end
 
-        def wrap_condition?(node)
-          node.and_type? || node.or_type? ||
-            (node.call_type? && node.arguments.any? && !node.parenthesized?)
+        def parenthesized_and(node)
+          # We only need to add parentheses around the last clause if it's an assignment,
+          # because other clauses will be unchanged by merging conditionals.
+          lhs = node.lhs.source
+          rhs = parenthesized_and_clause(node.rhs)
+          operator = range_with_surrounding_space(node.loc.operator, whitespace: true).source
+
+          "#{lhs}#{operator}#{rhs}"
         end
 
-        def replace_condition(condition)
-          wrap_condition?(condition) ? "(#{condition.source})" : condition.source
+        def parenthesized_and_clause(node)
+          if node.and_type?
+            parenthesized_and(node)
+          elsif node.assignment?
+            "(#{node.source})"
+          else
+            node.source
+          end
         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

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

@@ -58,9 +58,8 @@ module RuboCop
       #
       # @example EnforcedStyle: use_builtin_english_names
       #
-      # Like `use_perl_names` but allows builtin global vars.
-      #
       #   # good
+      #   # Like `use_perl_names` but allows builtin global vars.
       #   puts $LOAD_PATH
       #   puts $LOADED_FEATURES
       #   puts $PROGRAM_NAME
@@ -150,7 +149,7 @@ module RuboCop
         end
 
         def on_gvar(node)
-          global_var, = *node
+          global_var = node.name
 
           return unless (preferred = preferred_names(global_var))
 

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # Check for parentheses around stabby lambda arguments.
+      # Checks for parentheses around stabby lambda arguments.
       # There are two different styles. Defaults to `require_parentheses`.
       #
       # @example EnforcedStyle: require_parentheses (default)

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

@@ -35,6 +35,7 @@ module RuboCop
             corrector.replace(range, 'chars')
           end
         end
+        alias on_csend on_send
       end
     end
   end

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

@@ -51,8 +51,6 @@ module RuboCop
       #   Pathname.new('/') + 'test'
       #
       class StringConcatenation < Base
-        include Util
-        include RangeHelp
         extend AutoCorrector
 
         MSG = 'Prefer string interpolation to string concatenation.'
@@ -129,11 +127,11 @@ module RuboCop
         end
 
         def uncorrectable?(part)
-          part.multiline? || heredoc?(part) || part.each_descendant(:block).any?
+          part.multiline? || heredoc?(part) || part.each_descendant(:any_block).any?
         end
 
         def heredoc?(node)
-          return false unless node.str_type? || node.dstr_type?
+          return false unless node.type?(:str, :dstr)
 
           node.heredoc?
         end
@@ -143,22 +141,24 @@ module RuboCop
         end
 
         def replacement(parts)
-          interpolated_parts =
-            parts.map do |part|
-              case part.type
-              when :str
-                value = part.value
-                single_quoted?(part) ? value.gsub(/(\\|")/, '\\\\\&') : value.inspect[1..-2]
-              when :dstr
-                contents_range(part).source
-              else
-                "\#{#{part.source}}"
-              end
+          interpolated_parts = parts.map do |part|
+            case part.type
+            when :str
+              adjust_str(part)
+            when :dstr
+              part.children.all?(&:str_type?) ? adjust_str(part) : part.value
+            else
+              "\#{#{part.source}}"
             end
+          end
 
           "\"#{handle_quotes(interpolated_parts).join}\""
         end
 
+        def adjust_str(node)
+          single_quoted?(node) ? node.value.gsub(/(\\|")/, '\\\\\&') : node.value.inspect[1..-2]
+        end
+
         def handle_quotes(parts)
           parts.map do |part|
             part == '"' ? '\"' : part

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

@@ -69,7 +69,7 @@ module RuboCop
         end
 
         def all_string_literals?(nodes)
-          nodes.all? { |n| n.str_type? || n.dstr_type? }
+          nodes.all? { |n| n.type?(:str, :dstr) }
         end
 
         def detect_quote_styles(node)

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

@@ -3,22 +3,42 @@
 module RuboCop
   module Cop
     module Style
-      # Checks that quotes inside the string interpolation
+      # Checks that quotes inside string, symbol, and regexp interpolations
       # match the configured preference.
       #
       # @example EnforcedStyle: single_quotes (default)
       #   # bad
-      #   result = "Tests #{success ? "PASS" : "FAIL"}"
+      #   string = "Tests #{success ? "PASS" : "FAIL"}"
+      #   symbol = :"Tests #{success ? "PASS" : "FAIL"}"
+      #   heredoc = <<~TEXT
+      #     Tests #{success ? "PASS" : "FAIL"}
+      #   TEXT
+      #   regexp = /Tests #{success ? "PASS" : "FAIL"}/
       #
       #   # good
-      #   result = "Tests #{success ? 'PASS' : 'FAIL'}"
+      #   string = "Tests #{success ? 'PASS' : 'FAIL'}"
+      #   symbol = :"Tests #{success ? 'PASS' : 'FAIL'}"
+      #   heredoc = <<~TEXT
+      #     Tests #{success ? 'PASS' : 'FAIL'}
+      #   TEXT
+      #   regexp = /Tests #{success ? 'PASS' : 'FAIL'}/
       #
       # @example EnforcedStyle: double_quotes
       #   # bad
-      #   result = "Tests #{success ? 'PASS' : 'FAIL'}"
+      #   string = "Tests #{success ? 'PASS' : 'FAIL'}"
+      #   symbol = :"Tests #{success ? 'PASS' : 'FAIL'}"
+      #   heredoc = <<~TEXT
+      #     Tests #{success ? 'PASS' : 'FAIL'}
+      #   TEXT
+      #   regexp = /Tests #{success ? 'PASS' : 'FAIL'}/
       #
       #   # good
-      #   result = "Tests #{success ? "PASS" : "FAIL"}"
+      #   string = "Tests #{success ? "PASS" : "FAIL"}"
+      #   symbol = :"Tests #{success ? "PASS" : "FAIL"}"
+      #   heredoc = <<~TEXT
+      #     Tests #{success ? "PASS" : "FAIL"}
+      #   TEXT
+      #   regexp = /Tests #{success ? "PASS" : "FAIL"}/
       class StringLiteralsInInterpolation < Base
         include ConfigurableEnforcedStyle
         include StringLiteralsHelp
@@ -29,6 +49,11 @@ module RuboCop
           StringLiteralCorrector.correct(corrector, node, style)
         end
 
+        # Cop classes that include the StringHelp module usually ignore regexp
+        # nodes. Not so for this cop, which is why we override the on_regexp
+        # definition with an empty one.
+        def on_regexp(node); end
+
         private
 
         def message(_node)

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

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module Style
       # Enforces the use of consistent method names
-      # from the String class.
+      # from the `String` class.
       #
       # @example
       #   # bad

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

@@ -22,20 +22,23 @@ module RuboCop
 
         # @!method lstrip_rstrip(node)
         def_node_matcher :lstrip_rstrip, <<~PATTERN
-          {(send $(send _ $:rstrip) $:lstrip)
-           (send $(send _ $:lstrip) $:rstrip)}
+          {
+            (call $(call _ :rstrip) :lstrip)
+            (call $(call _ :lstrip) :rstrip)
+          }
         PATTERN
 
         def on_send(node)
-          lstrip_rstrip(node) do |first_send, method_one, method_two|
+          lstrip_rstrip(node) do |first_send|
             range = range_between(first_send.loc.selector.begin_pos, node.source_range.end_pos)
-            message = format(MSG, methods: "#{method_one}.#{method_two}")
+            message = format(MSG, methods: range.source)
 
             add_offense(range, message: message) do |corrector|
               corrector.replace(range, 'strip')
             end
           end
         end
+        alias on_csend on_send
       end
     end
   end

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

@@ -3,7 +3,8 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for inheritance from Struct.new.
+      # Checks for inheritance from `Struct.new`. Inheriting from `Struct.new`
+      # adds a superfluous level in inheritance tree.
       #
       # @safety
       #   Autocorrection is unsafe because it will change the inheritance
@@ -17,12 +18,18 @@ module RuboCop
       #     end
       #   end
       #
+      #   Person.ancestors
+      #   # => [Person, #<Class:0x000000010b4e14a0>, Struct, (...)]
+      #
       #   # good
       #   Person = Struct.new(:first_name, :last_name) do
       #     def age
       #       42
       #     end
       #   end
+      #
+      #   Person.ancestors
+      #   # => [Person, Struct, (...)]
       class StructInheritance < Base
         include RangeHelp
         extend AutoCorrector
@@ -33,7 +40,7 @@ module RuboCop
         def on_class(node)
           return unless struct_constructor?(node.parent_class)
 
-          add_offense(node.parent_class.source_range) do |corrector|
+          add_offense(node.parent_class) do |corrector|
             corrector.remove(range_with_surrounding_space(node.loc.keyword, newlines: false))
             corrector.replace(node.loc.operator, '=')