rubocop 1.24.1 → 1.64.1

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

@@ -3,22 +3,42 @@
 module RuboCop
   module Cop
     module Style
-      # This cop 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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop enforces the use of consistent method names
+      # Enforces the use of consistent method names
       # from the String class.
       #
       # @example

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop identifies places where `lstrip.rstrip` can be replaced by
+      # Identifies places where `lstrip.rstrip` can be replaced by
       # `strip`.
       #
       # @example
@@ -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,10 +3,10 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for inheritance from Struct.new.
+      # Checks for inheritance from Struct.new.
       #
       # @safety
-      #   Auto-correction is unsafe because it will change the inheritance
+      #   Autocorrection is unsafe because it will change the inheritance
       #   tree (e.g. return value of `Module#ancestors`) of the constant.
       #
       # @example
@@ -34,7 +34,7 @@ module RuboCop
           return unless struct_constructor?(node.parent_class)
 
           add_offense(node.parent_class.source_range) do |corrector|
-            corrector.remove(range_with_surrounding_space(range: node.loc.keyword, newlines: false))
+            corrector.remove(range_with_surrounding_space(node.loc.keyword, newlines: false))
             corrector.replace(node.loc.operator, '=')
 
             correct_parent(node.parent_class, corrector)
@@ -51,11 +51,11 @@ module RuboCop
 
         def correct_parent(parent, corrector)
           if parent.block_type?
-            corrector.remove(range_with_surrounding_space(range: parent.loc.end, newlines: false))
+            corrector.remove(range_with_surrounding_space(parent.loc.end, newlines: false))
           elsif (class_node = parent.parent).body.nil?
             corrector.remove(range_for_empty_class_body(class_node, parent))
           else
-            corrector.insert_after(parent.loc.expression, ' do')
+            corrector.insert_after(parent, ' do')
           end
         end
 

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

@@ -0,0 +1,156 @@
+# 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.
+      #
+      # @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
+      #
+      #   # 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
+
+        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.'
+
+        def on_super(super_node)
+          def_node = super_node.ancestors.find do |node|
+            # You can't implicitly call super when dynamically defining methods
+            break if define_method?(node)
+
+            break node if DEF_TYPES.include?(node.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_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, 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 positional_arg_same?(def_arg, super_arg)
+          return false unless def_arg.arg_type? || def_arg.optarg_type?
+          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.kwarg_type? || def_arg.kwoptarg_type?
+          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, def_arg, super_arg)
+          return false unless def_arg.blockarg_type? && 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|
+            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 define_method?(node)
+          return false unless node.block_type?
+
+          node.method?(:define_method) || node.method?(:define_singleton_method)
+        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

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces the presence of parentheses in `super` containing arguments.
+      #
+      # `super` is a keyword and is provided as a distinct cop from those designed for method call.
+      #
+      # @example
+      #
+      #   # bad
+      #   super name, age
+      #
+      #   # good
+      #   super(name, age)
+      #
+      class SuperWithArgsParentheses < Base
+        extend AutoCorrector
+
+        MSG = 'Use parentheses for `super` with arguments.'
+
+        def on_super(node)
+          return if node.parenthesized?
+
+          add_offense(node) do |corrector|
+            range = node.loc.keyword.end.join(node.first_argument.source_range.begin)
+            corrector.replace(range, '(')
+            corrector.insert_after(node.last_argument, ')')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop enforces the use of shorthand-style swapping of 2 variables.
+      # Enforces the use of shorthand-style swapping of 2 variables.
       #
       # @safety
       #   Autocorrection is unsafe, because the temporary variable used to
@@ -22,7 +22,7 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Replace this and assignments at lines %<x_line>d '\
+        MSG = 'Replace this and assignments at lines %<x_line>d ' \
               'and %<y_line>d with `%<replacement>s`.'
 
         SIMPLE_ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn casgn].to_set.freeze
@@ -58,6 +58,8 @@ module RuboCop
         end
 
         def simple_assignment?(node)
+          return false unless node.respond_to?(:type)
+
           SIMPLE_ASSIGNMENT_TYPES.include?(node.type)
         end
 

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

@@ -3,11 +3,12 @@
 module RuboCop
   module Cop
     module Style
-      # This cop can check for array literals made up of symbols that are not
+      # Checks for array literals made up of symbols that are not
       # using the %i() syntax.
       #
       # Alternatively, it checks for symbol arrays using the %i() syntax on
-      # projects which do not want to use that syntax.
+      # projects which do not want to use that syntax, perhaps because they
+      # support a version of Ruby lower than 2.0.
       #
       # Configuration option: MinSize
       # If set, arrays with fewer elements than this value will not trigger the
@@ -21,6 +22,15 @@ module RuboCop
       #   # bad
       #   [:foo, :bar, :baz]
       #
+      #   # bad (contains spaces)
+      #   %i[foo\ bar baz\ quux]
+      #
+      #   # bad (contains [] with spaces)
+      #   %i[foo \[ \]]
+      #
+      #   # bad (contains () with spaces)
+      #   %i(foo \( \))
+      #
       # @example EnforcedStyle: brackets
       #   # good
       #   [:foo, :bar, :baz]
@@ -33,9 +43,21 @@ module RuboCop
         include ConfigurableEnforcedStyle
         include PercentArray
         extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.0
 
         PERCENT_MSG = 'Use `%i` or `%I` for an array of symbols.'
-        ARRAY_MSG = 'Use `%<prefer>s` for an array of symbols.'
+        ARRAY_MSG = 'Use %<prefer>s for an array of symbols.'
+        DELIMITERS = ['[', ']', '(', ')'].freeze
+        SPECIAL_GVARS = %w[
+          $! $" $$ $& $' $* $+ $, $/ $; $: $. $< $= $> $? $@ $\\ $_ $` $~ $0
+          $-0 $-F $-I $-K $-W $-a $-d $-i $-l $-p $-v $-w
+        ].freeze
+        REDEFINABLE_OPERATORS = %w(
+          | ^ & <=> == === =~ > >= < <= << >>
+          + - * / % ** ~ +@ -@ [] []= ` ! != !~
+        ).freeze
 
         class << self
           attr_accessor :largest_brackets
@@ -43,7 +65,7 @@ module RuboCop
 
         def on_array(node)
           if bracketed_array_of?(:sym, node)
-            return if symbols_contain_spaces?(node)
+            return if complex_content?(node)
 
             check_bracketed_array(node, 'i')
           elsif node.percent_literal?(:symbol)
@@ -53,25 +75,37 @@ module RuboCop
 
         private
 
-        def symbols_contain_spaces?(node)
+        def complex_content?(node)
           node.children.any? do |sym|
-            content, = *sym
-            / /.match?(content)
+            return false if DELIMITERS.include?(sym.source)
+
+            content = *sym
+            content = content.map { |c| c.is_a?(AST::Node) ? c.source : c }.join
+            content_without_delimiter_pairs = content.gsub(/(\[[^\s\[\]]*\])|(\([^\s\(\)]*\))/, '')
+
+            content.include?(' ') || DELIMITERS.any? do |delimiter|
+              content_without_delimiter_pairs.include?(delimiter)
+            end
           end
         end
 
+        def invalid_percent_array_contents?(node)
+          complex_content?(node)
+        end
+
         def build_bracketed_array(node)
+          return '[]' if node.children.empty?
+
           syms = node.children.map do |c|
             if c.dsym_type?
               string_literal = to_string_literal(c.source)
 
-              ":#{trim_string_interporation_escape_character(string_literal)}"
+              ":#{trim_string_interpolation_escape_character(string_literal)}"
             else
               to_symbol_literal(c.value.to_s)
             end
           end
-
-          "[#{syms.join(', ')}]"
+          build_bracketed_array_with_appropriate_whitespace(elements: syms, node: node)
         end
 
         def to_symbol_literal(string)
@@ -83,15 +117,6 @@ module RuboCop
         end
 
         def symbol_without_quote?(string)
-          special_gvars = %w[
-            $! $" $$ $& $' $* $+ $, $/ $; $: $. $< $= $> $? $@ $\\ $_ $` $~ $0
-            $-0 $-F $-I $-K $-W $-a $-d $-i $-l $-p $-v $-w
-          ]
-          redefinable_operators = %w(
-            | ^ & <=> == === =~ > >= < <= << >>
-            + - * / % ** ~ +@ -@ [] []= ` ! != !~
-          )
-
           # method name
           /\A[a-zA-Z_]\w*[!?]?\z/.match?(string) ||
             # instance / class variable
@@ -99,8 +124,8 @@ module RuboCop
             # global variable
             /\A\$[1-9]\d*\z/.match?(string) ||
             /\A\$[a-zA-Z_]\w*\z/.match?(string) ||
-            special_gvars.include?(string) ||
-            redefinable_operators.include?(string)
+            SPECIAL_GVARS.include?(string) ||
+            REDEFINABLE_OPERATORS.include?(string)
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks symbol literal syntax.
+      # Checks symbol literal syntax.
       #
       # @example
       #