rubocop 1.39.0 → 1.57.1

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

@@ -36,7 +36,6 @@ module RuboCop
       #   STR
       class RedundantStringEscape < Base
         include MatchRange
-        include RangeHelp
         extend AutoCorrector
 
         MSG = 'Redundant escape of %<char>s inside string literal.'
@@ -58,16 +57,16 @@ module RuboCop
         private
 
         def message(range)
-          format(MSG, char: range.source.chars.last)
+          format(MSG, char: range.source[-1])
         end
 
         def str_contents_range(node)
           if heredoc?(node)
             node.loc.heredoc_body
+          elsif node.str_type?
+            node.source_range
           elsif begin_loc_present?(node)
             contents_range(node)
-          else
-            node.loc.expression
           end
         end
 
@@ -76,6 +75,7 @@ module RuboCop
           node.loc.to_hash.key?(:begin) && !node.loc.begin.nil?
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def allowed_escape?(node, range)
           escaped = range.source[(1..-1)]
 
@@ -88,13 +88,14 @@ module RuboCop
           # with different versions of Ruby so that e.g. /\d/ != /d/
           return true if /[\n\\[[:alnum:]]]/.match?(escaped[0])
 
-          return true if escaped[0] == ' ' && percent_array_literal?(node)
+          return true if escaped[0] == ' ' && (percent_array_literal?(node) || node.heredoc?)
 
           return true if disabling_interpolation?(range)
           return true if delimiter?(node, escaped[0])
 
           false
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def interpolation_not_enabled?(node)
           single_quoted?(node) ||
@@ -137,7 +138,7 @@ module RuboCop
 
         def heredoc_with_disabled_interpolation?(node)
           if heredoc?(node)
-            node.loc.expression.source.end_with?("'")
+            node.source.end_with?("'")
           elsif node.parent&.dstr_type?
             heredoc_with_disabled_interpolation?(node.parent)
           else
@@ -156,6 +157,8 @@ module RuboCop
             return delimiter?(node.parent, char)
           end
 
+          return true unless node.loc.begin
+
           delimiters = [node.loc.begin.source[-1], node.loc.end.source[0]]
 
           delimiters.include?(char)
@@ -169,9 +172,10 @@ module RuboCop
           # Allow \#{foo}, \#$foo, \#@foo, and \#@@foo
           # for escaping local, global, instance and class variable interpolations
           return true if range.source.match?(/\A\\#[{$@]/)
-
           # Also allow #\{foo}, #\$foo, #\@foo and #\@@foo
           return true if range.adjust(begin_pos: -2).source.match?(/\A[^\\]#\\[{$@]/)
+          # For `\#\{foo} allow `\#` and warn `\{`
+          return true if range.adjust(end_pos: 1).source == '\\#\\{'
 
           false
         end

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

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Sort `require` and `require_relative` in alphabetical order.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because it will obviously change the execution order.
+      #
+      # @example
+      #   # bad
+      #   require 'b'
+      #   require 'a'
+      #
+      #   # good
+      #   require 'a'
+      #   require 'b'
+      #
+      #   # bad
+      #   require_relative 'b'
+      #   require_relative 'a'
+      #
+      #   # good
+      #   require_relative 'a'
+      #   require_relative 'b'
+      #
+      #   # good (sorted within each section separated by a blank line)
+      #   require 'a'
+      #   require 'd'
+      #
+      #   require 'b'
+      #   require 'c'
+      #
+      #   # good
+      #   require 'b'
+      #   require_relative 'c'
+      #   require 'a'
+      #
+      #   # bad
+      #   require 'a'
+      #   require 'c' if foo
+      #   require 'b'
+      #
+      #   # good
+      #   require 'a'
+      #   require 'b'
+      #   require 'c' if foo
+      #
+      #   # bad
+      #   require 'c'
+      #   if foo
+      #     require 'd'
+      #     require 'b'
+      #   end
+      #   require 'a'
+      #
+      #   # good
+      #   require 'c'
+      #   if foo
+      #     require 'b'
+      #     require 'd'
+      #   end
+      #   require 'a'
+      #
+      class RequireOrder < Base
+        extend AutoCorrector
+
+        include RangeHelp
+
+        RESTRICT_ON_SEND = %i[require require_relative].freeze
+
+        MSG = 'Sort `%<name>s` in alphabetical order.'
+
+        # @!method if_inside_only_require(node)
+        def_node_matcher :if_inside_only_require, <<~PATTERN
+          {
+            (if _ _ $(send nil? {:require :require_relative} _))
+            (if _ $(send nil? {:require :require_relative} _) _)
+          }
+        PATTERN
+
+        def on_send(node)
+          return unless node.parent && node.arguments?
+          return if not_modifier_form?(node.parent)
+
+          previous_older_sibling = find_previous_older_sibling(node)
+          return unless previous_older_sibling
+
+          add_offense(node, message: format(MSG, name: node.method_name)) do |corrector|
+            autocorrect(corrector, node, previous_older_sibling)
+          end
+        end
+
+        private
+
+        def not_modifier_form?(node)
+          node.if_type? && !node.modifier_form?
+        end
+
+        def find_previous_older_sibling(node) # rubocop:disable Metrics
+          search_node(node).left_siblings.reverse.find do |sibling|
+            next unless sibling.is_a?(AST::Node)
+
+            sibling = sibling_node(sibling)
+            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.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
+
+        def sibling_node(node)
+          return if not_modifier_form?(node)
+
+          node.if_type? ? if_inside_only_require(node) : node
+        end
+
+        def in_same_section?(node1, node2)
+          !node1.source_range.with(end_pos: node2.source_range.end_pos).source.include?("\n\n")
+        end
+      end
+    end
+  end
+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/rescue_standard_error.rb

@@ -105,11 +105,11 @@ module RuboCop
         private
 
         def offense_for_implicit_enforced_style(node, error)
-          range = node.loc.keyword.join(error.loc.expression)
+          range = node.loc.keyword.join(error.source_range)
 
           add_offense(range, message: MSG_IMPLICIT) do |corrector|
             error = rescue_standard_error?(node)
-            range = range_between(node.loc.keyword.end_pos, error.loc.expression.end_pos)
+            range = range_between(node.loc.keyword.end_pos, error.source_range.end_pos)
 
             corrector.remove(range)
           end

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

@@ -50,6 +50,11 @@ module RuboCop
       #   foo && foo.bar { |e| e.something }
       #   foo && foo.bar(param) { |e| e.something }
       #
+      #   foo ? foo.bar : nil
+      #   foo.nil? ? nil : foo.bar
+      #   !foo.nil? ? foo.bar : nil
+      #   !foo ? nil : foo.bar
+      #
       #   # good
       #   foo&.bar
       #   foo&.bar&.baz
@@ -105,6 +110,17 @@ module RuboCop
           }
         PATTERN
 
+        # @!method ternary_safe_navigation_candidate(node)
+        def_node_matcher :ternary_safe_navigation_candidate, <<~PATTERN
+          {
+            (if (send $_ {:nil? :!}) nil $_)
+
+            (if (send (send $_ :nil?) :!) $_ nil)
+
+            (if $_ $_ nil)
+          }
+        PATTERN
+
         # @!method not_nil_check?(node)
         def_node_matcher :not_nil_check?, '(send (send $_ :nil?) :!)'
 
@@ -118,9 +134,11 @@ module RuboCop
           check_node(node)
         end
 
+        private
+
         def check_node(node)
           checked_variable, receiver, method_chain, method = extract_parts(node)
-          return unless receiver == checked_variable
+          return if receiver != checked_variable || receiver.nil?
           return if use_var_only_in_unless_modifier?(node, checked_variable)
           return if chain_length(method_chain, method) > max_chain_length
           return if unsafe_method_used?(method_chain, method)
@@ -133,10 +151,8 @@ module RuboCop
           node.if_type? && node.unless? && !method_called?(variable)
         end
 
-        private
-
         def autocorrect(corrector, node)
-          body = node.node_parts[1]
+          body = extract_body(node)
           method_call = method_call(node)
 
           corrector.remove(begin_range(node, body))
@@ -147,6 +163,14 @@ module RuboCop
           add_safe_nav_to_all_methods_in_chain(corrector, method_call, body)
         end
 
+        def extract_body(node)
+          if node.if_type? && node.ternary?
+            node.branches.find { |branch| !branch.nil_type? }
+          else
+            node.node_parts[1]
+          end
+        end
+
         def handle_comments(corrector, node, method_call)
           comments = comments(node)
           return if comments.empty?
@@ -174,7 +198,7 @@ module RuboCop
         end
 
         def allowed_if_condition?(node)
-          node.else? || node.elsif? || node.ternary?
+          node.else? || node.elsif?
         end
 
         def method_call(node)
@@ -192,7 +216,12 @@ module RuboCop
         end
 
         def extract_parts_from_if(node)
-          variable, receiver = modifier_if_safe_navigation_candidate(node)
+          variable, receiver =
+            if node.ternary?
+              ternary_safe_navigation_candidate(node)
+            else
+              modifier_if_safe_navigation_candidate(node)
+            end
 
           checked_variable, matching_receiver, method = extract_common_parts(receiver, variable)
 
@@ -268,11 +297,11 @@ module RuboCop
         end
 
         def begin_range(node, method_call)
-          range_between(node.loc.expression.begin_pos, method_call.loc.expression.begin_pos)
+          range_between(node.source_range.begin_pos, method_call.source_range.begin_pos)
         end
 
         def end_range(node, method_call)
-          range_between(method_call.loc.expression.end_pos, node.loc.expression.end_pos)
+          range_between(method_call.source_range.end_pos, node.source_range.end_pos)
         end
 
         def add_safe_nav_to_all_methods_in_chain(corrector,

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

@@ -49,7 +49,8 @@ module RuboCop
         MSG = 'Prefer `%<replacement>s` to `%<original_method>s` with a regexp match.'
         RESTRICT_ON_SEND = %i[select find_all reject].freeze
         REPLACEMENTS = { select: 'grep', find_all: 'grep', reject: 'grep_v' }.freeze
-        REGEXP_METHODS = %i[match? =~].to_set.freeze
+        OPPOSITE_REPLACEMENTS = { select: 'grep_v', find_all: 'grep_v', reject: 'grep' }.freeze
+        REGEXP_METHODS = %i[match? =~ !~].to_set.freeze
 
         # @!method regexp_match?(node)
         def_node_matcher :regexp_match?, <<~PATTERN
@@ -83,16 +84,22 @@ 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?
+          return if block_node.body&.begin_type?
           return if receiver_allowed?(block_node.receiver)
           return unless (regexp_method_send_node = extract_send_node(block_node))
           return if match_predicate_without_receiver?(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)
+
+          register_offense(node, block_node, regexp, replacement)
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         private
 
@@ -102,8 +109,15 @@ module RuboCop
           node.hash_type? || creates_hash?(node) || env_const?(node)
         end
 
-        def register_offense(node, block_node, regexp)
-          replacement = REPLACEMENTS[node.method_name.to_sym]
+        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|
@@ -124,6 +138,10 @@ module RuboCop
           regexp_method_send_node
         end
 
+        def opposite?(regexp_method_send_node)
+          regexp_method_send_node.send_type? && regexp_method_send_node.method?(:!~)
+        end
+
         def find_regexp(node, block)
           return node.child_nodes.first if node.match_with_lvasgn_type?
 

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

@@ -42,7 +42,7 @@ module RuboCop
 
           if rhs.send_type?
             check_send_node(node, rhs, var_name, var_type)
-          elsif %i[and or].include?(rhs.type)
+          elsif rhs.operator_keyword?
             check_boolean_node(node, rhs, var_name, var_type)
           end
         end
@@ -76,7 +76,7 @@ module RuboCop
 
           if rhs.send_type?
             autocorrect_send_node(corrector, node, rhs)
-          elsif %i[and or].include?(rhs.type)
+          elsif rhs.operator_keyword?
             autocorrect_boolean_node(corrector, node, rhs)
           end
         end

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

@@ -37,13 +37,14 @@ module RuboCop
         end
 
         def on_new_investigation
-          return if processed_source.blank?
+          return if processed_source.blank? || !processed_source.raw_source.include?(';')
 
           check_for_line_terminator_or_opener
         end
 
         def on_begin(node)
           return if cop_config['AllowAsExpressionSeparator']
+          return unless node.source.include?(';')
 
           exprs = node.children
 
@@ -61,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
@@ -71,8 +69,10 @@ module RuboCop
 
         def each_semicolon
           tokens_for_lines.each do |line, tokens|
-            yield line, tokens.last.column, tokens[-2] if tokens.last.semicolon?
-            yield line, tokens.first.column if tokens.first.semicolon?
+            semicolon_pos = semicolon_position(tokens)
+            after_expr_pos = semicolon_pos == -1 ? -2 : semicolon_pos
+
+            yield line, tokens[semicolon_pos].column, tokens[after_expr_pos] if semicolon_pos
           end
         end
 
@@ -80,6 +80,37 @@ module RuboCop
           processed_source.tokens.group_by(&:line)
         end
 
+        def semicolon_position(tokens)
+          if tokens.last.semicolon?
+            -1
+          elsif tokens.first.semicolon?
+            0
+          elsif exist_semicolon_before_right_curly_brace?(tokens)
+            -3
+          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
+
+        def exist_semicolon_before_right_curly_brace?(tokens)
+          tokens[-2]&.right_curly_brace? && tokens[-3]&.semicolon?
+        end
+
+        def exist_semicolon_after_left_curly_brace?(tokens)
+          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

@@ -119,11 +119,6 @@ module RuboCop
         # @!method custom_fail_methods(node)
         def_node_search :custom_fail_methods, '{(def :fail ...) (defs _ :fail ...)}'
 
-        def on_new_investigation
-          ast = processed_source.ast
-          @custom_fail_defined = ast && custom_fail_methods(ast).any?
-        end
-
         def on_rescue(node)
           return unless style == :semantic
 
@@ -141,7 +136,7 @@ module RuboCop
           when :semantic
             check_send(:raise, node) unless ignored_node?(node)
           when :only_raise
-            return if @custom_fail_defined
+            return if custom_fail_defined?
 
             check_send(:fail, node)
           when :only_fail
@@ -151,6 +146,13 @@ module RuboCop
 
         private
 
+        def custom_fail_defined?
+          return @custom_fail_defined if defined?(@custom_fail_defined)
+
+          ast = processed_source.ast
+          @custom_fail_defined = ast && custom_fail_methods(ast).any?
+        end
+
         def message(method_name)
           case style
           when :semantic
@@ -196,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