rubocop 1.48.1 → 1.62.1

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

@@ -3,8 +3,9 @@
 module RuboCop
   module Cop
     module Style
-      # Checks that arrays are sliced with endless ranges instead of
-      # `ary[start..-1]` on Ruby 2.6+.
+      # Checks that arrays are not sliced with the redundant `ary[0..-1]`, replacing it with `ary`,
+      # and ensures arrays are sliced with endless ranges instead of `ary[start..-1]` on Ruby 2.6+,
+      # and with beginless ranges instead of `ary[nil..end]` on Ruby 2.7+.
       #
       # @safety
       #   This cop is unsafe because `x..-1` and `x..` are only guaranteed to
@@ -21,29 +22,94 @@ module RuboCop
       #
       # @example
       #   # bad
-      #   items[1..-1]
+      #   items[0..-1]
+      #   items[0..nil]
+      #   items[0...nil]
       #
       #   # good
-      #   items[1..]
+      #   items
+      #
+      #   # bad
+      #   items[1..-1]   # Ruby 2.6+
+      #   items[1..nil]  # Ruby 2.6+
+      #
+      #   # good
+      #   items[1..]     # Ruby 2.6+
+      #
+      #   # bad
+      #   items[nil..42] # Ruby 2.7+
+      #
+      #   # good
+      #   items[..42]    # Ruby 2.7+
+      #   items[0..42]   # Ruby 2.7+
+      #
       class SlicingWithRange < Base
         extend AutoCorrector
         extend TargetRubyVersion
 
         minimum_target_ruby_version 2.6
 
-        MSG = 'Prefer ary[n..] over ary[n..-1].'
+        MSG = 'Prefer `%<prefer>s` over `%<current>s`.'
+        MSG_USELESS_RANGE = 'Remove the useless `%<prefer>s`.'
         RESTRICT_ON_SEND = %i[[]].freeze
 
+        # @!method range_from_zero_till_minus_one?(node)
+        def_node_matcher :range_from_zero_till_minus_one?, <<~PATTERN
+          {
+            (irange (int 0) {(int -1) nil})
+            (erange (int 0) nil)
+          }
+        PATTERN
+
         # @!method range_till_minus_one?(node)
-        def_node_matcher :range_till_minus_one?, '(irange !nil? (int -1))'
+        def_node_matcher :range_till_minus_one?, <<~PATTERN
+          {
+            (irange !nil? {(int -1) nil})
+            (erange !nil? nil)
+          }
+        PATTERN
+
+        # @!method range_from_zero?(node)
+        def_node_matcher :range_from_zero?, <<~PATTERN
+          (irange nil !nil?)
+        PATTERN
 
         def on_send(node)
-          return unless node.arguments.count == 1
-          return unless range_till_minus_one?(node.arguments.first)
+          return unless node.arguments.one?
 
-          add_offense(node.first_argument) do |corrector|
-            corrector.remove(node.first_argument.end)
+          range_node = node.first_argument
+          selector = node.loc.selector
+          unless (message, removal_range = offense_message_with_removal_range(range_node, selector))
+            return
           end
+
+          add_offense(selector, message: message) do |corrector|
+            corrector.remove(removal_range)
+          end
+        end
+
+        private
+
+        def offense_message_with_removal_range(range_node, selector)
+          if range_from_zero_till_minus_one?(range_node)
+            [format(MSG_USELESS_RANGE, prefer: selector.source), selector]
+          elsif range_till_minus_one?(range_node)
+            [
+              format(MSG, prefer: endless(range_node), current: selector.source), range_node.end
+            ]
+          elsif range_from_zero?(range_node) && target_ruby_version >= 2.7
+            [
+              format(MSG, prefer: beginless(range_node), current: selector.source), range_node.begin
+            ]
+          end
+        end
+
+        def endless(range_node)
+          "[#{range_node.begin.source}#{range_node.loc.operator.source}]"
+        end
+
+        def beginless(range_node)
+          "[#{range_node.loc.operator.source}#{range_node.end.source}]"
         end
       end
     end

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

@@ -167,13 +167,15 @@ module RuboCop
           corrector.insert_before(condition,
                                   "#{'!' if node.unless?}#{replace_condition(node.condition)} && ")
 
-          corrector.remove(node.condition.source_range)
+          corrector.remove(node.condition)
           corrector.remove(range_with_surrounding_space(node.loc.keyword, newlines: false))
           corrector.replace(if_branch.loc.keyword, 'if')
         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,8 +188,10 @@ 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), '(')
-          corrector.insert_after(condition.last_argument.source_range, ')')
+          range = range_between(end_pos, begin_pos)
+          corrector.remove(range)
+          corrector.insert_after(range, '(')
+          corrector.insert_after(condition.last_argument, ')')
         end
 
         def insert_bang(corrector, node, is_modify_form)

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/struct_inheritance.rb

@@ -55,7 +55,7 @@ module RuboCop
           elsif (class_node = parent.parent).body.nil?
             corrector.remove(range_for_empty_class_body(class_node, parent))
           else
-            corrector.insert_after(parent.source_range, ' do')
+            corrector.insert_after(parent, ' do')
           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/symbol_proc.rb

@@ -37,6 +37,42 @@ module RuboCop
       #   # ArgumentError: wrong number of arguments (given 1, expected 0)
       #   ----
       #
+      #   It is also unsafe because `Symbol#to_proc` does not work with
+      #   `protected` methods which would otherwise be accessible.
+      #
+      #   For example:
+      #
+      #   [source,ruby]
+      #   ----
+      #   class Box
+      #     def initialize
+      #       @secret = rand
+      #     end
+      #
+      #     def normal_matches?(*others)
+      #       others.map { |other| other.secret }.any?(secret)
+      #     end
+      #
+      #     def symbol_to_proc_matches?(*others)
+      #       others.map(&:secret).any?(secret)
+      #     end
+      #
+      #     protected
+      #
+      #     attr_reader :secret
+      #   end
+      #
+      #   boxes = [Box.new, Box.new]
+      #   Box.new.normal_matches?(*boxes)
+      #   # => false
+      #   boxes.first.normal_matches?(*boxes)
+      #   # => true
+      #   Box.new.symbol_to_proc_matches?(*boxes)
+      #   # => NoMethodError: protected method `secret' called for #<Box...>
+      #   boxes.first.symbol_to_proc_matches?(*boxes)
+      #   # => NoMethodError: protected method `secret' called for #<Box...>
+      #   ----
+      #
       # @example
       #   # bad
       #   something.map { |s| s.upcase }

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

@@ -34,6 +34,7 @@ module RuboCop
             )
           end
         end
+        alias on_sclass on_class
       end
     end
   end

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

@@ -238,7 +238,7 @@ module RuboCop
 
           indent = ' ' * node.loc.column
           corrector.replace(
-            node.source_range,
+            node,
             ['class << self',
              "#{indent}  #{accessor(kind, node.method_name)}",
              "#{indent}end"].join("\n")

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

@@ -8,6 +8,7 @@ module RuboCop
       # to read and understand.
       #
       # This cop supports two styles:
+      #
       # - `forbid_mixed_logical_operators` (default)
       # - `forbid_logical_operators`
       #

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

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for the use of `YAML.load`, `YAML.safe_load`, and `YAML.parse` with
+      # `File.read` argument.
+      #
+      # NOTE: `YAML.safe_load_file` was introduced in Ruby 3.0.
+      #
+      # @example
+      #
+      #   # bad
+      #   YAML.load(File.read(path))
+      #   YAML.parse(File.read(path))
+      #
+      #   # good
+      #   YAML.load_file(path)
+      #   YAML.parse_file(path)
+      #
+      #   # bad
+      #   YAML.safe_load(File.read(path)) # Ruby 3.0 and newer
+      #
+      #   # good
+      #   YAML.safe_load_file(path)       # Ruby 3.0 and newer
+      #
+      class YAMLFileRead < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<prefer>s` instead.'
+        RESTRICT_ON_SEND = %i[load safe_load parse].freeze
+
+        # @!method yaml_file_read?(node)
+        def_node_matcher :yaml_file_read?, <<~PATTERN
+          (send
+            (const {cbase nil?} :YAML) _
+            (send
+              (const {cbase nil?} :File) :read $_) $...)
+        PATTERN
+
+        def on_send(node)
+          return if node.method?(:safe_load) && target_ruby_version <= 2.7
+          return unless (file_path, rest_arguments = yaml_file_read?(node))
+
+          range = offense_range(node)
+          rest_arguments = if rest_arguments.empty?
+                             ''
+                           else
+                             ", #{rest_arguments.map(&:source).join(', ')}"
+                           end
+          prefer = "#{node.method_name}_file(#{file_path.source}#{rest_arguments})"
+
+          add_offense(range, message: format(MSG, prefer: prefer)) do |corrector|
+            corrector.replace(range, prefer)
+          end
+        end
+
+        private
+
+        def offense_range(node)
+          node.loc.selector.join(node.source_range.end)
+        end
+      end
+    end
+  end
+end

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

@@ -118,16 +118,18 @@ module RuboCop
           node.comparison_method? && !noncommutative_operator?(node)
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def valid_yoda?(node)
-          lhs = node.receiver
-          rhs = node.first_argument
+          return true unless (rhs = node.first_argument)
 
+          lhs = node.receiver
           return true if (constant_portion?(lhs) && constant_portion?(rhs)) ||
                          (!constant_portion?(lhs) && !constant_portion?(rhs)) ||
                          interpolation?(lhs)
 
           enforce_yoda? ? constant_portion?(lhs) : constant_portion?(rhs)
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def message(node)
           format(MSG, source: node.source)

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

@@ -19,22 +19,23 @@ module RuboCop
       #   differently on different classes, and are not guaranteed to
       #   have the same result if reversed.
       #
-      # @example SupportedOperators: ['*', '+', '&'']
+      # @example SupportedOperators: ['*', '+', '&', '|', '^'] (default)
       #   # bad
-      #   1 + x
       #   10 * y
+      #   1 + x
       #   1 & z
+      #   1 | x
+      #   1 ^ x
       #   1 + CONST
       #
       #   # good
-      #   60 * 24
-      #   x + 1
       #   y * 10
+      #   x + 1
       #   z & 1
+      #   x | 1
+      #   x ^ 1
       #   CONST + 1
-      #
-      #   # good
-      #   1 | x
+      #   60 * 24
       #
       class YodaExpression < Base
         extend AutoCorrector

data/lib/rubocop/cop/team.rb

@@ -112,7 +112,7 @@ module RuboCop
       end
 
       def external_dependency_checksum
-        keys = cops.map(&:external_dependency_checksum).compact
+        keys = cops.filter_map(&:external_dependency_checksum)
         Digest::SHA1.hexdigest(keys.join)
       end
 

data/lib/rubocop/cop/util.rb

@@ -142,7 +142,7 @@ module RuboCop
       end
 
       def escape_string(string)
-        string.inspect[1..-2].tap { |s| s.gsub!(/\\"/, '"') }
+        string.inspect[1..-2].tap { |s| s.gsub!('\\"', '"') }
       end
 
       def to_string_literal(string)