rubocop 1.18.0 → 1.56.0

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for redundant parentheses.
+      # Checks for redundant parentheses.
       #
       # @example
       #
@@ -29,6 +29,9 @@ module RuboCop
         # @!method rescue?(node)
         def_node_matcher :rescue?, '{^resbody ^^resbody}'
 
+        # @!method allowed_pin_operator?(node)
+        def_node_matcher :allowed_pin_operator?, '^(pin (begin !{lvar ivar cvar gvar}))'
+
         # @!method arg_in_call_with_block?(node)
         def_node_matcher :arg_in_call_with_block?, '^^(block (send _ _ equal?(%0) ...) ...)'
 
@@ -44,6 +47,7 @@ module RuboCop
           empty_parentheses?(node) ||
             first_arg_begins_with_hash_literal?(node) ||
             rescue?(node) ||
+            allowed_pin_operator?(node) ||
             allowed_expression?(node)
         end
 
@@ -57,8 +61,8 @@ module RuboCop
         def allowed_expression?(node)
           allowed_ancestor?(node) ||
             allowed_method_call?(node) ||
-            allowed_array_or_hash_element?(node) ||
-            allowed_multiple_expression?(node)
+            allowed_multiple_expression?(node) ||
+            allowed_ternary?(node)
         end
 
         def allowed_ancestor?(node)
@@ -80,8 +84,22 @@ module RuboCop
           !ancestor.begin_type? && !ancestor.def_type? && !ancestor.block_type?
         end
 
+        def allowed_ternary?(node)
+          return false unless node&.parent&.if_type?
+
+          node.parent.ternary? && ternary_parentheses_required?
+        end
+
+        def ternary_parentheses_required?
+          config = @config.for_cop('Style/TernaryParentheses')
+          allowed_styles = %w[require_parentheses require_parentheses_when_complex]
+
+          config.fetch('Enabled') && allowed_styles.include?(config['EnforcedStyle'])
+        end
+
         def like_method_argument_parentheses?(node)
-          node.send_type? && node.arguments.size == 1 && !node.arithmetic_operation?
+          node.send_type? && node.arguments.one? && !node.parenthesized? &&
+            !node.arithmetic_operation? && node.first_argument.begin_type?
         end
 
         def empty_parentheses?(node)
@@ -135,7 +153,7 @@ module RuboCop
 
           return if node.send_type? && !method_call_with_redundant_parentheses?(node)
 
-          offense(begin_node, 'an unary operation')
+          offense(begin_node, 'a unary operation')
         end
 
         def offense(node, msg)
@@ -152,26 +170,6 @@ module RuboCop
           node.parent&.keyword?
         end
 
-        def allowed_array_or_hash_element?(node)
-          # Don't flag
-          # ```
-          # { a: (1
-          #      ), }
-          # ```
-          hash_or_array_element?(node) && only_closing_paren_before_comma?(node)
-        end
-
-        def hash_or_array_element?(node)
-          node.each_ancestor(:array, :hash).any?
-        end
-
-        def only_closing_paren_before_comma?(node)
-          source_buffer = node.source_range.source_buffer
-          line_range = source_buffer.line_range(node.loc.end.line)
-
-          /^\s*\)\s*,/.match?(line_range.source)
-        end
-
         def disallowed_literal?(begin_node, node)
           node.literal? && !node.range_type? && !raised_to_power_negative_numeric?(begin_node, node)
         end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for usage of the %q/%Q syntax when '' or "" would do.
+      # Checks for usage of the %q/%Q syntax when '' or "" would do.
       #
       # @example
       #
@@ -65,9 +65,8 @@ module RuboCop
         end
 
         def allowed_percent_q?(node)
-          node.source.start_with?(PERCENT_Q) && acceptable_q?(node) ||
-            node.source.start_with?(PERCENT_CAPITAL_Q) &&
-              acceptable_capital_q?(node)
+          (node.source.start_with?(PERCENT_Q) && acceptable_q?(node)) ||
+            (node.source.start_with?(PERCENT_CAPITAL_Q) && acceptable_capital_q?(node))
         end
 
         def message(node)
@@ -94,7 +93,7 @@ module RuboCop
 
           return true if STRING_INTERPOLATION_REGEXP.match?(src)
 
-          src.scan(/\\./).any? { |s| ESCAPED_NON_BACKSLASH.match?(s) }
+          src.scan(/\\./).any?(ESCAPED_NON_BACKSLASH)
         end
 
         def acceptable_capital_q?(node)

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Identifies places where argument can be replaced from
+      # a deterministic regexp to a string.
+      #
+      # @example
+      #   # bad
+      #   'foo'.byteindex(/f/)
+      #   'foo'.byterindex(/f/)
+      #   'foo'.gsub(/f/, 'x')
+      #   'foo'.gsub!(/f/, 'x')
+      #   'foo'.partition(/f/)
+      #   'foo'.rpartition(/f/)
+      #   'foo'.scan(/f/)
+      #   'foo'.split(/f/)
+      #   'foo'.start_with?(/f/)
+      #   'foo'.sub(/f/, 'x')
+      #   'foo'.sub!(/f/, 'x')
+      #
+      #   # good
+      #   'foo'.byteindex('f')
+      #   'foo'.byterindex('f')
+      #   'foo'.gsub('f', 'x')
+      #   'foo'.gsub!('f', 'x')
+      #   'foo'.partition('f')
+      #   'foo'.rpartition('f')
+      #   'foo'.scan('f')
+      #   'foo'.split('f')
+      #   'foo'.start_with?('f')
+      #   'foo'.sub('f', 'x')
+      #   'foo'.sub!('f', 'x')
+      class RedundantRegexpArgument < Base
+        extend AutoCorrector
+
+        MSG = 'Use string `%<prefer>s` as argument instead of regexp `%<current>s`.'
+        RESTRICT_ON_SEND = %i[
+          byteindex byterindex gsub gsub! partition rpartition scan split start_with? sub sub!
+        ].freeze
+        DETERMINISTIC_REGEX = /\A(?:#{LITERAL_REGEX})+\Z/.freeze
+        STR_SPECIAL_CHARS = %w[
+          \a \c \C \e \f \M \n \" \' \\\\ \t \b \f \r \u \v \x \0 \1 \2 \3 \4 \5 \6 \7
+        ].freeze
+
+        def on_send(node)
+          return unless (regexp_node = node.first_argument)
+          return unless regexp_node.regexp_type?
+          return if !regexp_node.regopt.children.empty? || regexp_node.content == ' '
+          return unless determinist_regexp?(regexp_node)
+
+          prefer = preferred_argument(regexp_node)
+          message = format(MSG, prefer: prefer, current: regexp_node.source)
+
+          add_offense(regexp_node, message: message) do |corrector|
+            corrector.replace(regexp_node, prefer)
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def determinist_regexp?(regexp_node)
+          DETERMINISTIC_REGEX.match?(regexp_node.source)
+        end
+
+        def preferred_argument(regexp_node)
+          new_argument = replacement(regexp_node)
+
+          if new_argument.include?('"')
+            new_argument.gsub!("'", "\\\\'")
+            quote = "'"
+          else
+            quote = '"'
+          end
+
+          "#{quote}#{new_argument}#{quote}"
+        end
+
+        def replacement(regexp_node)
+          regexp_content = regexp_node.content
+          stack = []
+          chars = regexp_content.chars.each_with_object([]) do |char, strings|
+            if stack.empty? && char == '\\'
+              stack.push(char)
+            else
+              strings << "#{stack.pop}#{char}"
+            end
+          end
+          chars.map do |char|
+            char = char.dup
+            char.delete!('\\') unless STR_SPECIAL_CHARS.include?(char)
+            char
+          end.join
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for unnecessary single-element Regexp character classes.
+      # Checks for unnecessary single-element Regexp character classes.
       #
       # @example
       #
@@ -63,6 +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_codepoints?(expr.expressions.first)
 
             yield expr
           end
@@ -73,14 +74,22 @@ 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_codepoints?(expression)
+          expression.respond_to?(:codepoints) && expression.codepoints.count >= 2
+        end
+
         def without_character_class(loc)
-          loc.source[1..-2]
+          without_character_class = loc.source[1..-2]
+
+          # Adds `\` to prevent autocorrection that changes to an interpolated string when `[#]`.
+          # e.g. From `/[#]{0}/` to `/#{0}/`
+          loc.source == '[#]' ? "\\#{without_character_class}" : without_character_class
         end
 
         def whitespace_in_free_space_mode?(node, elem)
@@ -90,11 +99,17 @@ module RuboCop
         end
 
         def backslash_b?(elem)
-          # \b's behaviour is different inside and outside of a character class, matching word
+          # \b's behavior is different inside and outside of a character class, matching word
           # boundaries outside but backspace (0x08) when inside.
           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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for redundant escapes inside Regexp literals.
+      # Checks for redundant escapes inside Regexp literals.
       #
       # @example
       #   # bad
@@ -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,21 +57,38 @@ 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 behaviour could change over time with
+          # rather difficult, and their behavior could change over time with
           # different versions of Ruby so that e.g. /\i/ != /i/
           return true if /[[:alnum:]]/.match?(char)
           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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for redundant `return` expressions.
+      # Checks for redundant `return` expressions.
       #
       # @example
       #   # These bad cases should be extended to handle methods whose body is
@@ -22,13 +22,18 @@ module RuboCop
       #     return something
       #   end
       #
-      #   # good
+      #   # bad
       #   def test
       #     return something if something_else
       #   end
       #
       #   # good
       #   def test
+      #     something if something_else
+      #   end
+      #
+      #   # good
+      #   def test
       #     if x
       #     elsif y
       #     else
@@ -53,6 +58,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)
@@ -76,7 +88,7 @@ module RuboCop
             corrector.replace(first_argument, first_argument.source.delete_prefix('*'))
           end
 
-          keyword = range_with_surrounding_space(range: return_node.loc.keyword, side: :right)
+          keyword = range_with_surrounding_space(return_node.loc.keyword, side: :right)
           corrector.remove(keyword)
         end
 
@@ -129,7 +141,7 @@ module RuboCop
         end
 
         def check_if_node(node)
-          return if node.modifier_form? || node.ternary?
+          return if node.ternary?
 
           check_branch(node.if_branch)
           check_branch(node.else_branch)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for redundant uses of `self`.
+      # Checks for redundant uses of `self`.
       #
       # The usage of `self` is only needed when:
       #
@@ -53,7 +53,7 @@ module RuboCop
                       yield __FILE__ __LINE__ __ENCODING__].freeze
 
         def self.autocorrect_incompatible_with
-          [ColonMethodCall]
+          [ColonMethodCall, Layout::DotPosition]
         end
 
         def initialize(config = nil, options = nil)
@@ -100,6 +100,10 @@ module RuboCop
           add_lhs_to_local_variables_scopes(rhs, lhs)
         end
 
+        def on_in_pattern(node)
+          add_match_var_scopes(node)
+        end
+
         def on_send(node)
           return unless node.self_receiver? && regular_method_call?(node)
           return if node.parent&.mlhs_type?
@@ -116,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`.
@@ -185,6 +191,12 @@ module RuboCop
             add_lhs_to_local_variables_scopes(rhs, child.to_a.first)
           end
         end
+
+        def add_match_var_scopes(in_pattern_node)
+          in_pattern_node.each_descendant(:match_var) do |match_var_node|
+            @local_variables_scopes[in_pattern_node] << match_var_node.children.first
+          end
+        end
       end
     end
   end

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

@@ -3,12 +3,13 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for places where redundant assignments are made for in place
+      # Checks for places where redundant assignments are made for in place
       # modification methods.
       #
-      # This cop is marked as unsafe, because it can produce false positives for
-      # user defined methods having one of the expected names, but not modifying
-      # its receiver in place.
+      # @safety
+      #   This cop is unsafe, because it can produce false positives for
+      #   user defined methods having one of the expected names, but not modifying
+      #   its receiver in place.
       #
       # @example
       #   # bad
@@ -31,7 +32,7 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Redundant self assignment detected. '\
+        MSG = 'Redundant self assignment detected. ' \
               'Method `%<method_name>s` modifies its receiver in place.'
 
         METHODS_RETURNING_SELF = %i[
@@ -66,8 +67,7 @@ module RuboCop
         alias on_gvasgn on_lvasgn
 
         def on_send(node)
-          # TODO: Remove `Symbol#to_s` after supporting only Ruby >= 2.7.
-          return unless node.method_name.to_s.end_with?('=')
+          return unless node.assignment_method?
           return unless redundant_assignment?(node)
 
           message = format(MSG, method_name: node.first_argument.method_name)

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for places where conditional branch makes redundant self-assignment.
+      #
+      # It only detects local variable because it may replace state of instance variable,
+      # class variable, and global variable that have state across methods with `nil`.
+      #
+      # @example
+      #
+      #   # bad
+      #   foo = condition ? bar : foo
+      #
+      #   # good
+      #   foo = bar if condition
+      #
+      #   # bad
+      #   foo = condition ? foo : bar
+      #
+      #   # good
+      #   foo = bar unless condition
+      #
+      class RedundantSelfAssignmentBranch < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Remove the self-assignment branch.'
+
+        # @!method bad_method?(node)
+        def_node_matcher :bad_method?, <<~PATTERN
+          (send nil? :bad_method ...)
+        PATTERN
+
+        def on_lvasgn(node)
+          variable, expression = *node
+          return unless use_if_and_else_branch?(expression)
+
+          if_branch = expression.if_branch
+          else_branch = expression.else_branch
+          return if inconvertible_to_modifier?(if_branch, else_branch)
+
+          if self_assign?(variable, if_branch)
+            register_offense(expression, if_branch, else_branch, 'unless')
+          elsif self_assign?(variable, else_branch)
+            register_offense(expression, else_branch, if_branch, 'if')
+          end
+        end
+
+        private
+
+        def use_if_and_else_branch?(expression)
+          return false unless expression&.if_type?
+
+          !expression.ternary? || !expression.else?
+        end
+
+        def inconvertible_to_modifier?(if_branch, else_branch)
+          multiple_statements?(if_branch) || multiple_statements?(else_branch) ||
+            (else_branch.respond_to?(:elsif?) && else_branch.elsif?)
+        end
+
+        def multiple_statements?(branch)
+          return false unless branch&.begin_type?
+
+          !branch.children.empty?
+        end
+
+        def self_assign?(variable, branch)
+          variable.to_s == branch&.source
+        end
+
+        def register_offense(if_node, offense_branch, opposite_branch, keyword)
+          add_offense(offense_branch) do |corrector|
+            assignment_value = opposite_branch ? opposite_branch.source : 'nil'
+            replacement = "#{assignment_value} #{keyword} #{if_node.condition.source}"
+
+            corrector.replace(if_node, replacement)
+          end
+        end
+      end
+    end
+  end
+end