rubocop 1.50.2 → 1.57.1

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

@@ -3,7 +3,16 @@
 module RuboCop
   module Cop
     module Style
-      # Enforces using // or %r around regular expressions.
+      # Enforces using `//` or `%r` around regular expressions.
+      #
+      # NOTE: The following `%r` cases using a regexp starts with a blank or `=`
+      # as a method argument allowed to prevent syntax errors.
+      #
+      # [source,ruby]
+      # ----
+      # do_something %r{ regexp} # `do_something / regexp/` is an invalid syntax.
+      # do_something %r{=regexp} # `do_something /=regexp/` is an invalid syntax.
+      # ----
       #
       # @example EnforcedStyle: slashes (default)
       #   # bad
@@ -151,7 +160,7 @@ module RuboCop
 
         def allowed_omit_parentheses_with_percent_r_literal?(node)
           return false unless node.parent&.call_type?
-          return true if node.content.start_with?(' ')
+          return true if node.content.start_with?(' ', '=')
 
           enforced_style = config.for_cop('Style/MethodCallWithArgsParentheses')['EnforcedStyle']
 

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

@@ -88,10 +88,7 @@ module RuboCop
           return unless previous_older_sibling
 
           add_offense(node, message: format(MSG, name: node.method_name)) do |corrector|
-            corrector.swap(
-              range_with_comments_and_lines(previous_older_sibling),
-              range_with_comments_and_lines(node.parent.if_type? ? node.parent : node)
-            )
+            autocorrect(corrector, node, previous_older_sibling)
           end
         end
 
@@ -109,11 +106,20 @@ module RuboCop
             break unless sibling&.send_type? && sibling&.method?(node.method_name)
             break unless sibling.arguments? && !sibling.receiver
             break unless in_same_section?(sibling, node)
+            break unless node.first_argument.str_type? && sibling.first_argument.str_type?
 
-            node.first_argument.source < sibling.first_argument.source
+            node.first_argument.value < sibling.first_argument.value
           end
         end
 
+        def autocorrect(corrector, node, previous_older_sibling)
+          range1 = range_with_comments_and_lines(previous_older_sibling)
+          range2 = range_with_comments_and_lines(node.parent.if_type? ? node.parent : node)
+
+          corrector.remove(range2)
+          corrector.insert_before(range1, range2.source)
+        end
+
         def search_node(node)
           node.parent.if_type? ? node.parent : node
         end

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

@@ -3,9 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for uses of rescue in its modifier form.
-      #
-      # The cop to check `rescue` in its modifier form is added for following
+      # Checks for uses of `rescue` in its modifier form is added for following
       # reasons:
       #
       # * The syntax of modifier form `rescue` can be misleading because it

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

@@ -3,9 +3,13 @@
 module RuboCop
   module Cop
     module Style
-      # Enforces consistency between 'return nil' and 'return'.
+      # Enforces consistency between `return nil` and `return`.
       #
-      # Supported styles are: return, return_nil.
+      # This cop is disabled by default. Because there seems to be a perceived semantic difference
+      # between `return` and `return nil`. The former can be seen as just halting evaluation,
+      # while the latter might be used when the return value is of specific concern.
+      #
+      # Supported styles are `return` and `return_nil`.
       #
       # @example EnforcedStyle: return (default)
       #   # bad

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks if `return` or `return nil` is used in predicate method definitions.
+      #
+      # @safety
+      #   Autocorrection is marked as unsafe because the change of the return value
+      #   from `nil` to `false` could potentially lead to incompatibility issues.
+      #
+      # @example
+      #   # bad
+      #   def foo?
+      #     return if condition
+      #
+      #     do_something?
+      #   end
+      #
+      #   # bad
+      #   def foo?
+      #     return nil if condition
+      #
+      #     do_something?
+      #   end
+      #
+      #   # good
+      #   def foo?
+      #     return false if condition
+      #
+      #     do_something?
+      #   end
+      #
+      # @example AllowedMethods: ['foo?']
+      #   # good
+      #   def foo?
+      #     return if condition
+      #
+      #     do_something?
+      #   end
+      #
+      # @example AllowedPatterns: [/foo/]
+      #   # good
+      #   def foo?
+      #     return if condition
+      #
+      #     do_something?
+      #   end
+      #
+      class ReturnNilInPredicateMethodDefinition < Base
+        extend AutoCorrector
+        include AllowedMethods
+        include AllowedPattern
+
+        MSG = 'Return `false` instead of `nil` in predicate methods.'
+
+        # @!method return_nil?(node)
+        def_node_matcher :return_nil?, <<~PATTERN
+          {(return) (return (nil))}
+        PATTERN
+
+        def on_def(node)
+          return unless node.predicate_method?
+          return if allowed_method?(node.method_name) || matches_allowed_pattern?(node.method_name)
+          return unless (body = node.body)
+
+          body.each_descendant(:return) do |return_node|
+            register_offense(return_node, 'return false') if return_nil?(return_node)
+          end
+
+          return unless (nil_node = nil_node_at_the_end_of_method_body(body))
+
+          register_offense(nil_node, 'false')
+        end
+        alias on_defs on_def
+
+        private
+
+        def nil_node_at_the_end_of_method_body(body)
+          return body if body.nil_type?
+          return unless body.begin_type?
+          return unless (last_child = body.children.last)
+
+          last_child if last_child.is_a?(AST::Node) && last_child.nil_type?
+        end
+
+        def register_offense(offense_node, replacement)
+          add_offense(offense_node) do |corrector|
+            corrector.replace(offense_node, replacement)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -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,14 @@ 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
 
         private
 
@@ -105,9 +109,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|

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
@@ -90,8 +87,11 @@ 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_before_right_string_interpolation_brace?(tokens)
+            -4
           end
         end
 
@@ -103,6 +103,14 @@ module RuboCop
           tokens[1]&.left_curly_brace? && tokens[2]&.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_line_do_end_block.rb

@@ -0,0 +1,65 @@
+# 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.'
+
+        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_after(node_body, "\n")
+            end
+          end
+        end
+        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/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_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/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/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