rubocop 1.34.1 → 1.54.0

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

@@ -63,7 +63,7 @@ module RuboCop
             next if expr.type != :set || expr.expressions.size != 1
             next if expr.negative?
             next if %i[set posixclass nonposixclass].include?(expr.expressions.first.type)
-            next if multiple_codepoins?(expr.expressions.first)
+            next if multiple_codepoints?(expr.expressions.first)
 
             yield expr
           end
@@ -74,13 +74,13 @@ module RuboCop
 
           non_redundant =
             whitespace_in_free_space_mode?(node, class_elem) ||
-            backslash_b?(class_elem) ||
+            backslash_b?(class_elem) || octal_requiring_char_class?(class_elem) ||
             requires_escape_outside_char_class?(class_elem)
 
           !non_redundant
         end
 
-        def multiple_codepoins?(expression)
+        def multiple_codepoints?(expression)
           expression.respond_to?(:codepoints) && expression.codepoints.count >= 2
         end
 
@@ -104,6 +104,12 @@ module RuboCop
           elem == '\b'
         end
 
+        def octal_requiring_char_class?(elem)
+          # The octal escapes \1 to \7 only work inside a character class
+          # because they would be a backreference outside it.
+          elem.match?(/\A\\[1-7]\z/)
+        end
+
         def requires_escape_outside_char_class?(elem)
           REQUIRES_ESCAPE_OUTSIDE_CHAR_CLASS_CHARS.include?(elem)
         end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for the instantiation of regexp using redundant `Regexp.new` or `Regexp.compile`.
+      # Autocorrect replaces to regexp literal which is the simplest and fastest.
+      #
+      # @example
+      #
+      #   # bad
+      #   Regexp.new(/regexp/)
+      #   Regexp.compile(/regexp/)
+      #
+      #   # good
+      #   /regexp/
+      #   Regexp.new('regexp')
+      #   Regexp.compile('regexp')
+      #
+      class RedundantRegexpConstructor < Base
+        extend AutoCorrector
+
+        MSG = 'Remove the redundant `Regexp.%<method>s`.'
+        RESTRICT_ON_SEND = %i[new compile].freeze
+
+        # @!method redundant_regexp_constructor(node)
+        def_node_matcher :redundant_regexp_constructor, <<~PATTERN
+          (send
+            (const {nil? cbase} :Regexp) {:new :compile}
+            (regexp $... (regopt $...)))
+        PATTERN
+
+        def on_send(node)
+          return unless (regexp, regopt = redundant_regexp_constructor(node))
+
+          add_offense(node, message: format(MSG, method: node.method_name)) do |corrector|
+            pattern = regexp.map(&:source).join
+            regopt = regopt.join
+
+            corrector.replace(node, "/#{pattern}/#{regopt}")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -44,7 +44,8 @@ module RuboCop
 
         def on_regexp(node)
           each_escape(node) do |char, index, within_character_class|
-            next if allowed_escape?(node, char, within_character_class)
+            next if char.valid_encoding? && allowed_escape?(node, char, index,
+                                                            within_character_class)
 
             location = escape_range_at_index(node, index)
 
@@ -56,7 +57,7 @@ module RuboCop
 
         private
 
-        def allowed_escape?(node, char, within_character_class)
+        def allowed_escape?(node, char, index, within_character_class)
           # Strictly speaking a few single-letter metachars are currently
           # unnecessary to "escape", e.g. i, E, F, but enumerating them is
           # rather difficult, and their behavior could change over time with
@@ -65,12 +66,29 @@ module RuboCop
           return true if ALLOWED_ALWAYS_ESCAPES.include?(char) || delimiter?(node, char)
 
           if within_character_class
-            ALLOWED_WITHIN_CHAR_CLASS_METACHAR_ESCAPES.include?(char)
+            ALLOWED_WITHIN_CHAR_CLASS_METACHAR_ESCAPES.include?(char) &&
+              !char_class_begins_or_ends_with_escaped_hyphen?(node, index)
           else
             ALLOWED_OUTSIDE_CHAR_CLASS_METACHAR_ESCAPES.include?(char)
           end
         end
 
+        def char_class_begins_or_ends_with_escaped_hyphen?(node, index)
+          # The hyphen character is allowed to be escaped within a character class
+          # but it's not necessary to escape hyphen if it's the first or last character
+          # within the character class. This method checks if that's the case.
+          # e.g. "[0-9\\-]" or "[\\-0-9]" would return true
+          content = contents_range(node).source
+
+          if content[index + 2] == ']'
+            true
+          elsif content[index - 1] == '['
+            index < 2 || content[index - 2] != '\\'
+          else
+            false
+          end
+        end
+
         def delimiter?(node, char)
           delimiters = [node.loc.begin.source[-1], node.loc.end.source[0]]
 
@@ -90,7 +108,7 @@ module RuboCop
             end
           end
         # Please remove this `else` branch when support for regexp_parser 1.8 will be dropped.
-        # It's for compatibility with regexp_arser 1.8 and will never be maintained.
+        # It's for compatibility with regexp_parser 1.8 and will never be maintained.
         else
           def each_escape(node)
             node.parsed_tree&.traverse&.reduce(0) do |char_class_depth, (event, expr)|

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

@@ -53,6 +53,13 @@ module RuboCop
 
         MSG = 'Redundant `return` detected.'
         MULTI_RETURN_MSG = 'To return multiple values, use an array.'
+        RESTRICT_ON_SEND = %i[define_method define_singleton_method].freeze
+
+        def on_send(node)
+          return unless (parent = node.parent) && parent.block_type?
+
+          check_branch(parent.body)
+        end
 
         def on_def(node)
           check_branch(node.body)

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

@@ -120,6 +120,8 @@ module RuboCop
           add_scope(node, @local_variables_scopes[node])
         end
 
+        alias on_numblock on_block
+
         def on_if(node)
           # Allow conditional nodes to use `self` in the condition if that variable
           # name is used in an `lvasgn` or `masgn` within the `if`.

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

@@ -62,7 +62,9 @@ module RuboCop
         end
 
         def multiple_statements?(branch)
-          branch && branch.children.compact.count > 1
+          return false unless branch&.begin_type?
+
+          !branch.children.empty?
         end
 
         def self_assign?(variable, branch)

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

@@ -129,13 +129,13 @@ module RuboCop
         end
 
         def offense_range(sort_node, node)
-          range_between(sort_node.loc.selector.begin_pos, node.loc.expression.end_pos)
+          range_between(sort_node.loc.selector.begin_pos, node.source_range.end_pos)
         end
 
         def message(node, sorter, accessor)
           accessor_source = range_between(
             node.loc.selector.begin_pos,
-            node.loc.expression.end_pos
+            node.source_range.end_pos
           ).source
 
           format(MSG,
@@ -146,7 +146,7 @@ module RuboCop
 
         def autocorrect(corrector, node, sort_node, sorter, accessor)
           # Remove accessor, e.g. `first` or `[-1]`.
-          corrector.remove(range_between(accessor_start(node), node.loc.expression.end_pos))
+          corrector.remove(range_between(accessor_start(node), node.source_range.end_pos))
           # Replace "sort" or "sort_by" with the appropriate min/max method.
           corrector.replace(sort_node.loc.selector, suggestion(sorter, accessor, arg_value(node)))
           # Replace to avoid syntax errors when followed by a logical operator.
@@ -184,7 +184,7 @@ module RuboCop
         end
 
         def arg_value(node)
-          arg_node(node).nil? ? nil : arg_node(node).node_parts.first
+          arg_node(node)&.node_parts&.first
         end
 
         # This gets the start of the accessor whether it has a dot
@@ -198,7 +198,7 @@ module RuboCop
         end
 
         def with_logical_operator?(node)
-          return unless (parent = node.parent)
+          return false unless (parent = node.parent)
 
           parent.or_type? || parent.and_type?
         end

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

@@ -19,18 +19,24 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Use `sort` instead of `sort_by { |%<var>s| %<var>s }`.'
-
-        # @!method redundant_sort_by(node)
-        def_node_matcher :redundant_sort_by, <<~PATTERN
-          (block $(send _ :sort_by) (args (arg $_x)) (lvar _x))
-        PATTERN
+        MSG_BLOCK = 'Use `sort` instead of `sort_by { |%<var>s| %<var>s }`.'
+        MSG_NUMBLOCK = 'Use `sort` instead of `sort_by { _1 }`.'
 
         def on_block(node)
-          redundant_sort_by(node) do |send, var_name|
+          redundant_sort_by_block(node) do |send, var_name|
             range = sort_by_range(send, node)
 
-            add_offense(range, message: format(MSG, var: var_name)) do |corrector|
+            add_offense(range, message: format(MSG_BLOCK, var: var_name)) do |corrector|
+              corrector.replace(range, 'sort')
+            end
+          end
+        end
+
+        def on_numblock(node)
+          redundant_sort_by_numblock(node) do |send|
+            range = sort_by_range(send, node)
+
+            add_offense(range, message: format(MSG_NUMBLOCK)) do |corrector|
               corrector.replace(range, 'sort')
             end
           end
@@ -38,6 +44,16 @@ module RuboCop
 
         private
 
+        # @!method redundant_sort_by_block(node)
+        def_node_matcher :redundant_sort_by_block, <<~PATTERN
+          (block $(send _ :sort_by) (args (arg $_x)) (lvar _x))
+        PATTERN
+
+        # @!method redundant_sort_by_numblock(node)
+        def_node_matcher :redundant_sort_by_numblock, <<~PATTERN
+          (numblock $(send _ :sort_by) 1 (lvar :_1))
+        PATTERN
+
         def sort_by_range(send, node)
           range_between(send.loc.selector.begin_pos, node.loc.end.end_pos)
         end

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

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for redundant escapes in string literals.
+      #
+      # @example
+      #   # bad - no need to escape # without following {/$/@
+      #   "\#foo"
+      #
+      #   # bad - no need to escape single quotes inside double quoted string
+      #   "\'foo\'"
+      #
+      #   # bad - heredocs are also checked for unnecessary escapes
+      #   <<~STR
+      #     \#foo \"foo\"
+      #   STR
+      #
+      #   # good
+      #   "#foo"
+      #
+      #   # good
+      #   "\#{no_interpolation}"
+      #
+      #   # good
+      #   "'foo'"
+      #
+      #   # good
+      #   "foo\
+      #   bar"
+      #
+      #   # good
+      #   <<~STR
+      #     #foo "foo"
+      #   STR
+      class RedundantStringEscape < Base
+        include MatchRange
+        extend AutoCorrector
+
+        MSG = 'Redundant escape of %<char>s inside string literal.'
+
+        def on_str(node)
+          return if node.parent&.regexp_type? || node.parent&.xstr_type? || node.character_literal?
+
+          str_contents_range = str_contents_range(node)
+
+          each_match_range(str_contents_range, /(\\.)/) do |range|
+            next if allowed_escape?(node, range.resize(3))
+
+            add_offense(range) do |corrector|
+              corrector.remove_leading(range, 1)
+            end
+          end
+        end
+
+        private
+
+        def message(range)
+          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)
+          end
+        end
+
+        def begin_loc_present?(node)
+          # e.g. a __FILE__ literal has no begin loc so we can't query if it's nil
+          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)]
+
+          # Inside a single-quoted string, escapes (except \\ and \') do not have special meaning,
+          # and so are not redundant, as they are a literal backslash.
+          return true if interpolation_not_enabled?(node)
+
+          # Strictly speaking a few single-letter chars are currently unnecessary to "escape", e.g.
+          # d, but enumerating them is rather difficult, and their behavior could change over time
+          # 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) || 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) ||
+            percent_w_literal?(node) ||
+            percent_q_literal?(node) ||
+            heredoc_with_disabled_interpolation?(node)
+        end
+
+        def single_quoted?(node)
+          delimiter?(node, "'")
+        end
+
+        def percent_q_literal?(node)
+          if literal_in_interpolated_or_multiline_string?(node)
+            percent_q_literal?(node.parent)
+          else
+            node.source.start_with?('%q')
+          end
+        end
+
+        def array_literal?(node, prefix)
+          if literal_in_interpolated_or_multiline_string?(node)
+            array_literal?(node.parent, prefix)
+          else
+            node.parent&.array_type? && node.parent.source.start_with?(prefix)
+          end
+        end
+
+        def percent_w_literal?(node)
+          array_literal?(node, '%w')
+        end
+
+        def percent_w_upper_literal?(node)
+          array_literal?(node, '%W')
+        end
+
+        def percent_array_literal?(node)
+          (percent_w_literal?(node) || percent_w_upper_literal?(node))
+        end
+
+        def heredoc_with_disabled_interpolation?(node)
+          if heredoc?(node)
+            node.source.end_with?("'")
+          elsif node.parent&.dstr_type?
+            heredoc_with_disabled_interpolation?(node.parent)
+          else
+            false
+          end
+        end
+
+        def heredoc?(node)
+          (node.str_type? || node.dstr_type?) && node.heredoc?
+        end
+
+        def delimiter?(node, char)
+          return false if heredoc?(node)
+
+          if literal_in_interpolated_or_multiline_string?(node) || percent_array_literal?(node)
+            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)
+        end
+
+        def literal_in_interpolated_or_multiline_string?(node)
+          node.str_type? && !begin_loc_present?(node) && node.parent&.dstr_type?
+        end
+
+        def disabling_interpolation?(range)
+          # 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
+      end
+    end
+  end
+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,13 +3,11 @@
 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
-      #   might led us to believe that `rescue` handles the given exception
+      #   might lead us to believe that `rescue` handles the given exception
       #   but it actually rescue all exceptions to return the given rescue
       #   block. In this case, value returned by handle_error or
       #   SomeException.

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