rubocop 1.57.1 → 1.81.7

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,68 +104,56 @@ module RuboCop
         end
 
         def autocorrect_outer_condition_basic(corrector, node, if_branch)
-          correct_from_unless_to_if(corrector, node) if node.unless?
+          correct_node(corrector, node)
 
-          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, 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)
-        end
-
-        def correct_from_unless_to_if(corrector, node, is_modify_form: false)
-          corrector.replace(node.loc.keyword, 'if')
-
-          insert_bang(corrector, node, is_modify_form)
+        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_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)}")
+        def correct_for_guard_condition_style(corrector, node, if_branch)
+          corrector.insert_after(node.condition, " && #{chainable_condition(if_branch)}")
 
-          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)
+        # rubocop:disable Metrics/AbcSize
+        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))
-
-          wrap_condition(corrector, if_branch.condition)
-        end
+          corrector.replace(range, ' && ')
 
-        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.replace(if_branch.condition, chainable_condition(if_branch))
 
-          corrector.wrap(condition, '(', ')')
+          end_range = if same_line?(node.loc.end, node.if_branch.loc.end)
+                        node.loc.end
+                      else
+                        range_by_whole_lines(node.loc.end, include_final_newline: true)
+                      end
+          corrector.remove(end_range)
         end
+        # rubocop:enable Metrics/AbcSize
+
+        def autocorrect_outer_condition_modify_form(corrector, node, if_branch)
+          correct_node(corrector, if_branch)
 
-        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.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)
@@ -181,71 +165,79 @@ module RuboCop
           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.'
@@ -102,7 +100,7 @@ module RuboCop
           node.receiver.str_type? &&
             node.first_argument.str_type? &&
             node.multiline? &&
-            node.source =~ /\+\s*\n/
+            node.source.match?(/\+\s*\n/)
         end
 
         def find_topmost_plus_node(node)
@@ -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,28 @@ 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
-            end
+          interpolated_parts = parts.map { |part| adjust_str(part) }
 
           "\"#{handle_quotes(interpolated_parts).join}\""
         end
 
+        def adjust_str(part)
+          case part.type
+          when :str
+            if single_quoted?(part)
+              part.value.gsub(/(\\|"|#\{|#@|#\$)/, '\\\\\&')
+            else
+              part.value.inspect[1..-2]
+            end
+          when :dstr, :begin
+            part.children.map do |child|
+              adjust_str(child)
+            end.join
+          else
+            "\#{#{part.source}}"
+          end
+        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_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, '=')
 

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

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for redundant argument forwarding when calling super with arguments identical to
+      # the method definition.
+      #
+      # Using zero arity `super` within a `define_method` block results in `RuntimeError`:
+      #
+      # [source,ruby]
+      # ----
+      # def m
+      #   define_method(:foo) { super() } # => OK
+      # end
+      #
+      # def m
+      #   define_method(:foo) { super }   # => RuntimeError
+      # end
+      # ----
+      #
+      # Furthermore, any arguments accompanied by a block may potentially be delegating to
+      # `define_method`, therefore, `super` used within these blocks will be allowed.
+      # This approach might result in false negatives, yet ensuring safe detection takes precedence.
+      #
+      # NOTE: When forwarding the same arguments but replacing the block argument with a new inline
+      # block, it is not necessary to explicitly list the non-block arguments. As such, an offense
+      # will be registered in this case.
+      #
+      # @example
+      #   # bad
+      #   def method(*args, **kwargs)
+      #     super(*args, **kwargs)
+      #   end
+      #
+      #   # good - implicitly passing all arguments
+      #   def method(*args, **kwargs)
+      #     super
+      #   end
+      #
+      #   # good - forwarding a subset of the arguments
+      #   def method(*args, **kwargs)
+      #     super(*args)
+      #   end
+      #
+      #   # good - forwarding no arguments
+      #   def method(*args, **kwargs)
+      #     super()
+      #   end
+      #
+      #   # bad - forwarding with overridden block
+      #   def method(*args, **kwargs, &block)
+      #     super(*args, **kwargs) { do_something }
+      #   end
+      #
+      #   # good - implicitly passing all non-block arguments
+      #   def method(*args, **kwargs, &block)
+      #     super { do_something }
+      #   end
+      #
+      #   # good - assigning to the block variable before calling super
+      #   def method(&block)
+      #     # Assigning to the block variable would pass the old value to super,
+      #     # under this circumstance the block must be referenced explicitly.
+      #     block ||= proc { 'fallback behavior' }
+      #     super(&block)
+      #   end
+      class SuperArguments < Base
+        extend AutoCorrector
+
+        ASSIGN_TYPES = %i[or_asgn lvasgn].freeze
+
+        MSG = 'Call `super` without arguments and parentheses when the signature is identical.'
+        MSG_INLINE_BLOCK = 'Call `super` without arguments and parentheses when all positional ' \
+                           'and keyword arguments are forwarded.'
+
+        def on_super(super_node)
+          return unless (def_node = find_def_node(super_node))
+
+          def_node_args = def_node.arguments.argument_list
+          super_args = preprocess_super_args(super_node.arguments)
+
+          return unless arguments_identical?(def_node, super_node, def_node_args, super_args)
+
+          # If the number of arguments to the def node and super node are different here,
+          # it's because the block argument is not forwarded.
+          message = def_node_args.size == super_args.size ? MSG : MSG_INLINE_BLOCK
+          add_offense(super_node, message: message) do |corrector|
+            corrector.replace(super_node, 'super')
+          end
+        end
+
+        private
+
+        def find_def_node(super_node)
+          super_node.ancestors.find do |node|
+            # When defining dynamic methods, implicitly calling `super` is not possible.
+            # Since there is a possibility of delegation to `define_method`,
+            # `super` used within the block is always allowed.
+            break if node.any_block_type? && !block_sends_to_super?(super_node, node)
+
+            break node if node.any_def_type?
+          end
+        end
+
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def arguments_identical?(def_node, super_node, def_args, super_args)
+          return false if argument_list_size_differs?(def_args, super_args, super_node)
+
+          def_args.zip(super_args).each do |def_arg, super_arg|
+            next if positional_arg_same?(def_arg, super_arg)
+            next if positional_rest_arg_same(def_arg, super_arg)
+            next if keyword_arg_same?(def_arg, super_arg)
+            next if keyword_rest_arg_same?(def_arg, super_arg)
+            next if block_arg_same?(def_node, super_node, def_arg, super_arg)
+            next if forward_arg_same?(def_arg, super_arg)
+
+            return false
+          end
+
+          true
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        def argument_list_size_differs?(def_args, super_args, super_node)
+          # If the def node has a block argument and the super node has an explicit block,
+          # the number of arguments is the same, so ignore the def node block arg.
+          def_args_size = def_args.size
+          def_args_size -= 1 if def_args.any?(&:blockarg_type?) && block_sends_to_super?(super_node)
+
+          def_args_size != super_args.size
+        end
+
+        def block_sends_to_super?(super_node, parent_node = super_node.parent)
+          # Checks if the send node of a block is the given super node,
+          # or a method chain containing it.
+          return false unless parent_node
+          return false unless parent_node.any_block_type?
+
+          parent_node.send_node.each_node(:super).any?(super_node)
+        end
+
+        def positional_arg_same?(def_arg, super_arg)
+          return false unless def_arg.type?(:arg, :optarg)
+          return false unless super_arg.lvar_type?
+
+          def_arg.name == super_arg.children.first
+        end
+
+        def positional_rest_arg_same(def_arg, super_arg)
+          return false unless def_arg.restarg_type?
+          # anonymous forwarding
+          return true if def_arg.name.nil? && super_arg.forwarded_restarg_type?
+          return false unless super_arg.splat_type?
+          return false unless (lvar_node = super_arg.children.first).lvar_type?
+
+          def_arg.name == lvar_node.children.first
+        end
+
+        def keyword_arg_same?(def_arg, super_arg)
+          return false unless def_arg.type?(:kwarg, :kwoptarg)
+          return false unless (pair_node = super_arg).pair_type?
+          return false unless (sym_node = pair_node.key).sym_type?
+          return false unless (lvar_node = pair_node.value).lvar_type?
+          return false unless sym_node.source == lvar_node.source
+
+          def_arg.name == sym_node.value
+        end
+
+        def keyword_rest_arg_same?(def_arg, super_arg)
+          return false unless def_arg.kwrestarg_type?
+          # anonymous forwarding
+          return true if def_arg.name.nil? && super_arg.forwarded_kwrestarg_type?
+          return false unless super_arg.kwsplat_type?
+          return false unless (lvar_node = super_arg.children.first).lvar_type?
+
+          def_arg.name == lvar_node.children.first
+        end
+
+        def block_arg_same?(def_node, super_node, def_arg, super_arg)
+          return false unless def_arg.blockarg_type?
+          return true if block_sends_to_super?(super_node)
+          return false unless super_arg.block_pass_type?
+
+          # anonymous forwarding
+          return true if (block_pass_child = super_arg.children.first).nil? && def_arg.name.nil?
+
+          block_arg_name = block_pass_child.children.first
+          def_arg.name == block_arg_name && !block_reassigned?(def_node, block_arg_name)
+        end
+
+        # Reassigning the block argument will still pass along the original block to super
+        # https://bugs.ruby-lang.org/issues/20505
+        def block_reassigned?(def_node, block_arg_name)
+          def_node.each_node(*ASSIGN_TYPES).any? do |assign_node|
+            # TODO: Since `Symbol#name` is supported from Ruby 3.0, the inheritance check for
+            # `AST::Node` can be removed when requiring Ruby 3.0+.
+            lhs = assign_node.node_parts[0]
+            next if lhs.is_a?(AST::Node) && !lhs.respond_to?(:name)
+
+            assign_node.name == block_arg_name
+          end
+        end
+
+        def forward_arg_same?(def_arg, super_arg)
+          def_arg.forward_arg_type? && super_arg.forwarded_args_type?
+        end
+
+        def preprocess_super_args(super_args)
+          super_args.flat_map do |node|
+            if node.hash_type? && !node.braces?
+              node.children
+            else
+              node
+            end
+          end
+        end
+      end
+    end
+  end
+end