rubocop 1.67.0 → 1.82.1

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/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

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

@@ -23,6 +23,10 @@ module RuboCop
       # `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)
@@ -44,6 +48,16 @@ module RuboCop
       #     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,
@@ -54,56 +68,86 @@ module RuboCop
       class SuperArguments < Base
         extend AutoCorrector
 
-        DEF_TYPES = %i[def defs].freeze
         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)
-          def_node = super_node.ancestors.find do |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.block_type?
+            break if node.any_block_type? && !block_sends_to_super?(super_node, node)
 
-            break node if DEF_TYPES.include?(node.type)
+            break node if node.any_def_type?
           end
-          return unless def_node
-          return unless arguments_identical?(def_node, def_node.arguments.argument_list,
-                                             super_node.arguments)
-
-          add_offense(super_node) { |corrector| corrector.replace(super_node, 'super') }
         end
 
-        private
-
         # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        def arguments_identical?(def_node, def_args, super_args)
-          super_args = preprocess_super_args(super_args)
-          return false if def_args.size != super_args.size
+        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 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, 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.arg_type? || def_arg.optarg_type?
+          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)
+        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?
@@ -114,7 +158,7 @@ module RuboCop
         end
 
         def keyword_arg_same?(def_arg, super_arg)
-          return false unless def_arg.kwarg_type? || def_arg.kwoptarg_type?
+          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?
@@ -133,8 +177,11 @@ module RuboCop
           def_arg.name == lvar_node.children.first
         end
 
-        def block_arg_same?(def_node, def_arg, super_arg)
-          return false unless def_arg.blockarg_type? && super_arg.block_pass_type?
+        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?
 

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

@@ -79,26 +79,15 @@ module RuboCop
         end
 
         def lhs(node)
-          case node.type
-          when :casgn
-            namespace, name, = *node
-            if namespace
-              "#{namespace.const_name}::#{name}"
-            else
-              name.to_s
-            end
+          if node.casgn_type?
+            "#{'::' if node.absolute?}#{node.const_name}"
           else
-            node.children[0].to_s
+            node.name.to_s
           end
         end
 
         def rhs(node)
-          case node.type
-          when :casgn
-            node.children[2].source
-          else
-            node.children[1].source
-          end
+          node.expression.source
         end
 
         def correction_range(tmp_assign, y_assign)

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

@@ -81,7 +81,7 @@ module RuboCop
 
             content = *sym
             content = content.map { |c| c.is_a?(AST::Node) ? c.source : c }.join
-            content_without_delimiter_pairs = content.gsub(/(\[[^\s\[\]]*\])|(\([^\s\(\)]*\))/, '')
+            content_without_delimiter_pairs = content.gsub(/(\[[^\s\[\]]*\])|(\([^\s()]*\))/, '')
 
             content.include?(' ') || DELIMITERS.any? do |delimiter|
               content_without_delimiter_pairs.include?(delimiter)

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

@@ -159,6 +159,7 @@ module RuboCop
           {
             (block $#symbol_proc_receiver? $(args (arg _var)) (send (lvar _var) $_))
             (numblock $#symbol_proc_receiver? $1 (send (lvar :_1) $_))
+            (itblock $#symbol_proc_receiver? $_ (send (lvar :it) $_))
           }
         PATTERN
 
@@ -185,6 +186,7 @@ module RuboCop
         end
         # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         alias on_numblock on_block
+        alias on_itblock on_block
 
         def destructuring_block_argument?(argument_node)
           argument_node.one? && argument_node.source.include?(',')
@@ -268,7 +270,7 @@ module RuboCop
         end
 
         def allow_if_method_has_argument?(send_node)
-          !!cop_config.fetch('AllowMethodsWithArguments', false) && !send_node.arguments.count.zero?
+          !!cop_config.fetch('AllowMethodsWithArguments', false) && send_node.arguments.any?
         end
 
         def allow_comments?

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

@@ -171,9 +171,7 @@ module RuboCop
         end
 
         def unsafe_autocorrect?(condition)
-          condition.children.any? do |child|
-            unparenthesized_method_call?(child) || below_ternary_precedence?(child)
-          end
+          condition.children.any? { |child| below_ternary_precedence?(child) }
         end
 
         def unparenthesized_method_call?(child)
@@ -192,7 +190,7 @@ module RuboCop
         # @!method method_name(node)
         def_node_matcher :method_name, <<~PATTERN
           {($:defined? _ ...)
-           (send {_ nil?} $_ _ ...)}
+           (call {_ nil?} $_ _ ...)}
         PATTERN
 
         def correct_parenthesized(corrector, condition)
@@ -203,16 +201,39 @@ module RuboCop
           # If we remove the parentheses, we need to add a space or we'll
           # generate invalid code.
           corrector.insert_after(condition.loc.end, ' ') unless whitespace_after?(condition)
+
+          if (send_node = condition.child_nodes.last) && node_args_need_parens?(send_node)
+            parenthesize_condition_arguments(corrector, send_node)
+          end
         end
 
         def correct_unparenthesized(corrector, condition)
           corrector.wrap(condition, '(', ')')
         end
 
+        def parenthesize_condition_arguments(corrector, send_node)
+          range_start = send_node.defined_type? ? send_node.loc.keyword : send_node.loc.selector
+          opening_range = range_start.end.join(send_node.first_argument.source_range.begin)
+
+          corrector.replace(opening_range, '(')
+          corrector.insert_after(send_node.last_argument, ')')
+        end
+
         def whitespace_after?(node)
           last_token = processed_source.last_token_of(node)
           last_token.space_after?
         end
+
+        def node_args_need_parens?(send_node)
+          return false unless node_with_args?(send_node)
+          return false if send_node.arguments.none? || send_node.parenthesized?
+
+          send_node.dot? || send_node.safe_navigation? || unparenthesized_method_call?(send_node)
+        end
+
+        def node_with_args?(node)
+          node.type?(:call, :defined?)
+        end
       end
     end
   end

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

@@ -64,6 +64,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
@@ -77,7 +78,7 @@ module RuboCop
 
         # @!method define_method_block?(node)
         def_node_matcher :define_method_block?, <<~PATTERN
-          ({block numblock} (send _ :define_method _) ...)
+          (any_block (send _ :define_method _) ...)
         PATTERN
       end
     end

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

@@ -7,12 +7,18 @@ module RuboCop
       # The supported styles are:
       #
       # * `consistent_comma`: Requires a comma after the last argument,
-      # for all parenthesized method calls with arguments.
+      # for all parenthesized multi-line method calls with arguments.
       # * `comma`: Requires a comma after the last argument, but only for
       # parenthesized method calls where each argument is on its own line.
+      # * `diff_comma`: Requires a comma after the last argument, but only
+      # when that argument is followed by an immediate newline, even if
+      # there is an inline comment on the same line.
       # * `no_comma`: Requires that there is no comma after the last
       # argument.
       #
+      # Regardless of style, trailing commas are not allowed in
+      # single-line method calls.
+      #
       # @example EnforcedStyleForMultiline: consistent_comma
       #   # bad
       #   method(1, 2,)
@@ -72,14 +78,62 @@ module RuboCop
       #     2,
       #   )
       #
+      # @example EnforcedStyleForMultiline: diff_comma
+      #   # bad
+      #   method(1, 2,)
+      #
+      #   # good
+      #   method(1, 2)
+      #
+      #   # good
+      #   method(
+      #     1, 2,
+      #     3,
+      #   )
+      #
+      #   # good
+      #   method(
+      #     1, 2, 3,
+      #   )
+      #
+      #   # good
+      #   method(
+      #     1,
+      #     2,
+      #   )
+      #
+      #   # bad
+      #   method(1, [
+      #     2,
+      #   ],)
+      #
+      #   # good
+      #   method(1, [
+      #     2,
+      #   ])
+      #
+      #   # bad
+      #   object[1, 2,
+      #          3, 4,]
+      #
+      #   # good
+      #   object[1, 2,
+      #          3, 4]
+      #
       # @example EnforcedStyleForMultiline: no_comma (default)
       #   # bad
       #   method(1, 2,)
       #
+      #   # bad
+      #   object[1, 2,]
+      #
       #   # good
       #   method(1, 2)
       #
       #   # good
+      #   object[1, 2]
+      #
+      #   # good
       #   method(
       #     1,
       #     2
@@ -93,7 +147,7 @@ module RuboCop
         end
 
         def on_send(node)
-          return unless node.arguments? && node.parenthesized?
+          return unless node.arguments? && (node.parenthesized? || node.method?(:[]))
 
           check(node, node.arguments, 'parameter of %<article>s method call',
                 node.last_argument.source_range.end_pos,

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

@@ -6,12 +6,13 @@ module RuboCop
       # Checks for trailing comma in array literals.
       # The configuration options are:
       #
-      # * `consistent_comma`: Requires a comma after the
-      # last item of all non-empty, multiline array literals.
-      # * `comma`: Requires a comma after last item in an array,
-      # but only when each item is on its own line.
-      # * `no_comma`: Does not require a comma after the
-      # last item in an array
+      # * `consistent_comma`: Requires a comma after the last item of all non-empty, multiline array
+      # literals.
+      # * `comma`: Requires a comma after the last item in an array, but only when each item is on
+      # its own line.
+      # * `diff_comma`: Requires a comma after the last item in an array, but only when that item is
+      # followed by an immediate newline, even if there is an inline comment on the same line.
+      # * `no_comma`: Does not require a comma after the last item in an array
       #
       # @example EnforcedStyleForMultiline: consistent_comma
       #   # bad
@@ -37,6 +38,14 @@ module RuboCop
       #     2,
       #   ]
       #
+      #   # bad
+      #   a = [1, 2,
+      #        3, 4]
+      #
+      #   # good
+      #   a = [1, 2,
+      #        3, 4,]
+      #
       # @example EnforcedStyleForMultiline: comma
       #   # bad
       #   a = [1, 2,]
@@ -72,6 +81,38 @@ module RuboCop
       #     2,
       #   ]
       #
+      # @example EnforcedStyleForMultiline: diff_comma
+      #   # bad
+      #   a = [1, 2,]
+      #
+      #   # good
+      #   a = [1, 2]
+      #
+      #   # good
+      #   a = [
+      #     1, 2,
+      #     3,
+      #   ]
+      #
+      #   # good
+      #   a = [
+      #     1, 2, 3,
+      #   ]
+      #
+      #   # good
+      #   a = [
+      #     1,
+      #     2,
+      #   ]
+      #
+      #   # bad
+      #   a = [1, 2,
+      #        3, 4,]
+      #
+      #   # good
+      #   a = [1, 2,
+      #        3, 4]
+      #
       # @example EnforcedStyleForMultiline: no_comma (default)
       #   # bad
       #   a = [1, 2,]

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

@@ -97,7 +97,7 @@ module RuboCop
           pipes = tokens.select { |token| token.type == :tPIPE }
           begin_pos, end_pos = pipes.map { |pipe| tokens.index(pipe) }
 
-          tokens[begin_pos + 1..end_pos - 1]
+          tokens[(begin_pos + 1)..(end_pos - 1)]
         end
       end
     end

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

@@ -6,12 +6,13 @@ module RuboCop
       # Checks for trailing comma in hash literals.
       # The configuration options are:
       #
-      # * `consistent_comma`: Requires a comma after the
-      # last item of all non-empty, multiline hash literals.
-      # * `comma`: Requires a comma after the last item in a hash,
-      # but only when each item is on its own line.
-      # * `no_comma`: Does not require a comma after the
-      # last item in a hash
+      # * `consistent_comma`: Requires a comma after the last item of all non-empty, multiline hash
+      # literals.
+      # * `comma`: Requires a comma after the last item in a hash, but only when each item is on its
+      # own line.
+      # * `diff_comma`: Requires a comma after the last item in a hash, but only when that item is
+      # followed by an immediate newline, even if there is an inline comment on the same line.
+      # * `no_comma`: Does not require a comma after the last item in a hash
       #
       # @example EnforcedStyleForMultiline: consistent_comma
       #
@@ -38,6 +39,14 @@ module RuboCop
       #     bar: 2,
       #   }
       #
+      #   # bad
+      #   a = { foo: 1, bar: 2,
+      #         baz: 3, qux: 4 }
+      #
+      #   # good
+      #   a = { foo: 1, bar: 2,
+      #         baz: 3, qux: 4, }
+      #
       # @example EnforcedStyleForMultiline: comma
       #
       #   # bad
@@ -74,6 +83,39 @@ module RuboCop
       #     bar: 2,
       #   }
       #
+      # @example EnforcedStyleForMultiline: diff_comma
+      #
+      #   # bad
+      #   a = { foo: 1, bar: 2, }
+      #
+      #   # good
+      #   a = { foo: 1, bar: 2 }
+      #
+      #   # good
+      #   a = {
+      #     foo: 1, bar: 2,
+      #     qux: 3,
+      #   }
+      #
+      #   # good
+      #   a = {
+      #     foo: 1, bar: 2, qux: 3,
+      #   }
+      #
+      #   # good
+      #   a = {
+      #     foo: 1,
+      #     bar: 2,
+      #   }
+      #
+      #   # bad
+      #   a = { foo: 1, bar: 2,
+      #         baz: 3, qux: 4, }
+      #
+      #   # good
+      #   a = { foo: 1, bar: 2,
+      #         baz: 3, qux: 4 }
+      #
       # @example EnforcedStyleForMultiline: no_comma (default)
       #
       #   # bad