rubocop 1.50.2 → 1.59.0

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

@@ -35,7 +35,7 @@ module RuboCop
 
         # @!method sample_candidate?(node)
         def_node_matcher :sample_candidate?, <<~PATTERN
-          (send $(send _ :shuffle $...) ${:#{RESTRICT_ON_SEND.join(' :')}} $...)
+          (call $(call _ :shuffle $...) ${:#{RESTRICT_ON_SEND.join(' :')}} $...)
         PATTERN
 
         def on_send(node)
@@ -52,6 +52,7 @@ module RuboCop
             end
           end
         end
+        alias on_csend on_send
 
         private
 

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

@@ -55,8 +55,8 @@ module RuboCop
         # @!method regexp_match?(node)
         def_node_matcher :regexp_match?, <<~PATTERN
           {
-            (block send (args (arg $_)) ${(send _ %REGEXP_METHODS _) match-with-lvasgn})
-            (numblock send $1 ${(send _ %REGEXP_METHODS _) match-with-lvasgn})
+            (block call (args (arg $_)) ${(send _ %REGEXP_METHODS _) match-with-lvasgn})
+            (numblock call $1 ${(send _ %REGEXP_METHODS _) match-with-lvasgn})
           }
         PATTERN
 
@@ -64,9 +64,9 @@ module RuboCop
         # @!method creates_hash?(node)
         def_node_matcher :creates_hash?, <<~PATTERN
           {
-            (send (const _ :Hash) {:new :[]} ...)
-            (block (send (const _ :Hash) :new ...) ...)
-            (send _ { :to_h :to_hash } ...)
+            (call (const _ :Hash) {:new :[]} ...)
+            (block (call (const _ :Hash) :new ...) ...)
+            (call _ { :to_h :to_hash } ...)
           }
         PATTERN
 
@@ -84,6 +84,7 @@ module RuboCop
           }
         PATTERN
 
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_send(node)
           return unless (block_node = node.block_node)
           return if block_node.body&.begin_type?
@@ -91,11 +92,15 @@ module RuboCop
           return unless (regexp_method_send_node = extract_send_node(block_node))
           return if match_predicate_without_receiver?(regexp_method_send_node)
 
-          opposite = opposite?(regexp_method_send_node)
+          replacement = replacement(regexp_method_send_node, node)
+          return if target_ruby_version <= 2.2 && replacement == 'grep_v'
+
           regexp = find_regexp(regexp_method_send_node, block_node)
 
-          register_offense(node, block_node, regexp, opposite)
+          register_offense(node, block_node, regexp, replacement)
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        alias on_csend on_send
 
         private
 
@@ -105,9 +110,15 @@ module RuboCop
           node.hash_type? || creates_hash?(node) || env_const?(node)
         end
 
-        def register_offense(node, block_node, regexp, opposite)
-          method_name = node.method_name.to_sym
-          replacement = opposite ? OPPOSITE_REPLACEMENTS[method_name] : REPLACEMENTS[method_name]
+        def replacement(regexp_method_send_node, node)
+          opposite = opposite?(regexp_method_send_node)
+
+          method_name = node.method_name
+
+          opposite ? OPPOSITE_REPLACEMENTS[method_name] : REPLACEMENTS[method_name]
+        end
+
+        def register_offense(node, block_node, regexp, replacement)
           message = format(MSG, replacement: replacement, original_method: node.method_name)
 
           add_offense(block_node, message: message) do |corrector|
@@ -136,7 +147,7 @@ module RuboCop
           return node.child_nodes.first if node.match_with_lvasgn_type?
 
           if node.receiver.lvar_type? &&
-             (block.numblock_type? || node.receiver.source == block.arguments.first.source)
+             (block.numblock_type? || node.receiver.source == block.first_argument.source)
             node.first_argument
           elsif node.first_argument.lvar_type?
             node.receiver

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

@@ -16,7 +16,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use self-assignment shorthand `%<method>s=`.'
-        OPS = %i[+ - * ** / | &].freeze
+        OPS = %i[+ - * ** / % ^ << >> | &].freeze
 
         def self.autocorrect_incompatible_with
           [Layout::SpaceAroundOperators]

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

@@ -62,9 +62,6 @@ module RuboCop
         private
 
         def check_for_line_terminator_or_opener
-          # Make the obvious check first
-          return unless processed_source.raw_source.include?(';')
-
           each_semicolon do |line, column, token_before_semicolon|
             register_semicolon(line, column, false, token_before_semicolon)
           end
@@ -83,6 +80,7 @@ module RuboCop
           processed_source.tokens.group_by(&:line)
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def semicolon_position(tokens)
           if tokens.last.semicolon?
             -1
@@ -90,10 +88,16 @@ module RuboCop
             0
           elsif exist_semicolon_before_right_curly_brace?(tokens)
             -3
-          elsif exist_semicolon_after_left_curly_brace?(tokens)
+          elsif exist_semicolon_after_left_curly_brace?(tokens) ||
+                exist_semicolon_after_left_string_interpolation_brace?(tokens)
             2
+          elsif exist_semicolon_after_left_lambda_curly_brace?(tokens)
+            3
+          elsif exist_semicolon_before_right_string_interpolation_brace?(tokens)
+            -4
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def exist_semicolon_before_right_curly_brace?(tokens)
           tokens[-2]&.right_curly_brace? && tokens[-3]&.semicolon?
@@ -103,6 +107,18 @@ module RuboCop
           tokens[1]&.left_curly_brace? && tokens[2]&.semicolon?
         end
 
+        def exist_semicolon_after_left_lambda_curly_brace?(tokens)
+          tokens[2]&.type == :tLAMBEG && tokens[3]&.semicolon?
+        end
+
+        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)
 

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

@@ -198,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

@@ -3,8 +3,11 @@
 module RuboCop
   module Cop
     module Style
-      # Sometimes using dig method ends up with just a single
-      # argument. In such cases, dig should be replaced with [].
+      # Sometimes using `dig` method ends up with just a single
+      # argument. In such cases, dig should be replaced with `[]`.
+      #
+      # Since replacing `hash&.dig(:key)` with `hash[:key]` could potentially lead to error,
+      # calls to the `dig` method using safe navigation will be ignored.
       #
       # @safety
       #   This cop is unsafe because it cannot be guaranteed that the receiver
@@ -33,6 +36,7 @@ module RuboCop
 
         MSG = 'Use `%<receiver>s[%<argument>s]` instead of `%<original>s`.'
         RESTRICT_ON_SEND = %i[dig].freeze
+        IGNORED_ARGUMENT_TYPES = %i[block_pass forwarded_restarg forwarded_args hash].freeze
 
         # @!method single_argument_dig?(node)
         def_node_matcher :single_argument_dig?, <<~PATTERN
@@ -44,7 +48,7 @@ module RuboCop
 
           expression = single_argument_dig?(node)
           return unless expression
-          return if expression.forwarded_args_type?
+          return if IGNORED_ARGUMENT_TYPES.include?(expression.type)
 
           receiver = node.receiver.source
           argument = expression.source

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for single-line `do`...`end` block.
+      #
+      # In practice a single line `do`...`end` is autocorrected when `EnforcedStyle: semantic`
+      # in `Style/BlockDelimiters`. The autocorrection maintains the `do` ... `end` syntax to
+      # preserve semantics and does not change it to `{`...`}` block.
+      #
+      # @example
+      #
+      #   # bad
+      #   foo do |arg| bar(arg) end
+      #
+      #   # good
+      #   foo do |arg|
+      #     bar(arg)
+      #   end
+      #
+      #   # bad
+      #   ->(arg) do bar(arg) end
+      #
+      #   # good
+      #   ->(arg) { bar(arg) }
+      #
+      class SingleLineDoEndBlock < Base
+        extend AutoCorrector
+
+        MSG = 'Prefer multiline `do`...`end` block.'
+
+        # rubocop:disable Metrics/AbcSize
+        def on_block(node)
+          return if !node.single_line? || node.braces?
+
+          add_offense(node) do |corrector|
+            corrector.insert_after(do_line(node), "\n")
+
+            node_body = node.body
+
+            if node_body.respond_to?(:heredoc?) && node_body.heredoc?
+              corrector.remove(node.loc.end)
+              corrector.insert_after(node_body.loc.heredoc_end, "\nend")
+            else
+              corrector.insert_before(node.loc.end, "\n")
+            end
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+        alias on_numblock on_block
+
+        private
+
+        def do_line(node)
+          if node.numblock_type? || node.arguments.children.empty? || node.send_node.lambda_literal?
+            node.loc.begin
+          else
+            node.arguments
+          end
+        end
+
+        def x(corrector, node); end
+      end
+    end
+  end
+end

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

@@ -135,7 +135,7 @@ module RuboCop
 
         def disallow_endless_method_style?
           endless_method_config = config.for_cop('Style/EndlessMethod')
-          return false unless endless_method_config['Enabled']
+          return true unless endless_method_config['Enabled']
 
           endless_method_config['EnforcedStyle'] == 'disallow'
         end

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

@@ -39,7 +39,7 @@ module RuboCop
 
         def on_send(node)
           return unless node.arguments.count == 1
-          return unless range_till_minus_one?(node.arguments.first)
+          return unless range_till_minus_one?(node.first_argument)
 
           add_offense(node.first_argument) do |corrector|
             corrector.remove(node.first_argument.end)

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

@@ -173,7 +173,9 @@ module RuboCop
         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?
@@ -186,7 +188,9 @@ module RuboCop
           begin_pos = condition.first_argument.source_range.begin_pos
           return if end_pos > begin_pos
 
-          corrector.replace(range_between(end_pos, begin_pos), '(')
+          range = range_between(end_pos, begin_pos)
+          corrector.remove(range)
+          corrector.insert_after(range, '(')
           corrector.insert_after(condition.last_argument, ')')
         end
 

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

@@ -3,8 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      #
-      # This cop looks for uses of Perl-style global variables.
+      # Looks for uses of Perl-style global variables.
       # Correcting to global variables in the 'English' library
       # will add a require statement to the top of the file if
       # enabled by RequireEnglish config.
@@ -234,9 +233,9 @@ module RuboCop
         end
 
         def matching_styles(global)
-          STYLE_VARS_MAP.map do |style, vars|
+          STYLE_VARS_MAP.filter_map do |style, vars|
             style if vars.values.flatten(1).include? global
-          end.compact
+          end
         end
 
         def english_name_replacement(preferred_name, node)

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_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/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/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/symbol_array.rb

@@ -22,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]
@@ -40,6 +49,15 @@ module RuboCop
 
         PERCENT_MSG = 'Use `%i` or `%I` 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
@@ -47,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)
@@ -57,13 +75,24 @@ module RuboCop
 
         private
 
-        def symbols_contain_spaces?(node)
+        def complex_content?(node)
           node.children.any? do |sym|
-            content, = *sym
-            content.to_s.include?(' ')
+            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?
 
@@ -88,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
@@ -104,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/unpack_first.rb

@@ -23,38 +23,35 @@ module RuboCop
 
         minimum_target_ruby_version 2.4
 
-        MSG = 'Use `%<receiver>s.unpack1(%<format>s)` instead of ' \
-              '`%<receiver>s.unpack(%<format>s)%<method>s`.'
+        MSG = 'Use `unpack1(%<format>s)` instead of `%<current>s`.'
         RESTRICT_ON_SEND = %i[first [] slice at].freeze
 
         # @!method unpack_and_first_element?(node)
         def_node_matcher :unpack_and_first_element?, <<~PATTERN
           {
-            (send $(send (...) :unpack $(...)) :first)
-            (send $(send (...) :unpack $(...)) {:[] :slice :at} (int 0))
+            (call $(call (...) :unpack $(...)) :first)
+            (call $(call (...) :unpack $(...)) {:[] :slice :at} (int 0))
           }
         PATTERN
 
         def on_send(node)
           unpack_and_first_element?(node) do |unpack_call, unpack_arg|
-            range = first_element_range(node, unpack_call)
-            message = format(MSG,
-                             receiver: unpack_call.receiver.source,
-                             format: unpack_arg.source,
-                             method: range.source)
-            add_offense(node, message: message) do |corrector|
-              corrector.remove(first_element_range(node, unpack_call))
+            first_element_range = first_element_range(node, unpack_call)
+            offense_range = unpack_call.loc.selector.join(node.source_range.end)
+            message = format(MSG, format: unpack_arg.source, current: offense_range.source)
+
+            add_offense(offense_range, message: message) do |corrector|
+              corrector.remove(first_element_range)
               corrector.replace(unpack_call.loc.selector, 'unpack1')
             end
           end
         end
+        alias on_csend on_send
 
         private
 
         def first_element_range(node, unpack_call)
-          Parser::Source::Range.new(node.source_range.source_buffer,
-                                    unpack_call.source_range.end_pos,
-                                    node.source_range.end_pos)
+          unpack_call.source_range.end.join(node.source_range.end)
         end
       end
     end