rubocop 1.26.0 → 1.36.0

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for unnecessary conditional expressions.
+      # Checks for unnecessary conditional expressions.
       #
       # @example
       #   # bad
@@ -44,9 +44,9 @@ module RuboCop
           message = message(node)
 
           add_offense(range_of_offense(node), message: message) do |corrector|
-            if node.ternary?
+            if node.ternary? && !branches_have_method?(node)
               correct_ternary(corrector, node)
-            elsif node.modifier_form? || !node.else_branch
+            elsif redundant_condition?(node)
               corrector.replace(node, node.if_branch.source)
             else
               corrected = make_ternary_form(node)
@@ -59,7 +59,7 @@ module RuboCop
         private
 
         def message(node)
-          if node.modifier_form? || !node.else_branch
+          if redundant_condition?(node)
             REDUNDANT_CONDITION
           else
             MSG
@@ -68,18 +68,22 @@ module RuboCop
 
         def range_of_offense(node)
           return node.loc.expression unless node.ternary?
+          return node.loc.expression if node.ternary? && branches_have_method?(node)
 
           range_between(node.loc.question.begin_pos, node.loc.colon.end_pos)
         end
 
         def offense?(node)
-          condition, if_branch, else_branch = *node
+          _condition, _if_branch, else_branch = *node
 
           return false if use_if_branch?(else_branch) || use_hash_key_assignment?(else_branch)
 
-          condition == if_branch && !node.elsif? && (
-            node.ternary? || !else_branch.instance_of?(AST::Node) || else_branch.single_line?
-          )
+          synonymous_condition_and_branch?(node) && !node.elsif? &&
+            (node.ternary? || !else_branch.instance_of?(AST::Node) || else_branch.single_line?)
+        end
+
+        def redundant_condition?(node)
+          node.modifier_form? || !node.else_branch
         end
 
         def use_if_branch?(else_branch)
@@ -90,19 +94,123 @@ module RuboCop
           else_branch&.send_type? && else_branch&.method?(:[]=)
         end
 
-        def else_source(else_branch)
-          if require_parentheses?(else_branch)
+        def use_hash_key_access?(node)
+          node.send_type? && node.method?(:[])
+        end
+
+        def synonymous_condition_and_branch?(node)
+          condition, if_branch, _else_branch = *node
+          # e.g.
+          #   if var
+          #     var
+          #   else
+          #     'foo'
+          #   end
+          return true if condition == if_branch
+
+          # e.g.
+          #   if foo
+          #     @value = foo
+          #   else
+          #     @value = another_value?
+          #   end
+          return true if branches_have_assignment?(node) && condition == if_branch.expression
+
+          # e.g.
+          #   if foo
+          #     test.value = foo
+          #   else
+          #     test.value = another_value?
+          #   end
+          branches_have_method?(node) && condition == if_branch.first_argument &&
+            !use_hash_key_access?(if_branch)
+        end
+
+        def branches_have_assignment?(node)
+          _condition, if_branch, else_branch = *node
+
+          return false unless if_branch && else_branch
+
+          asgn_type?(if_branch) && (if_branch_variable_name = if_branch.name) &&
+            asgn_type?(else_branch) && (else_branch_variable_name = else_branch.name) &&
+            if_branch_variable_name == else_branch_variable_name
+        end
+
+        def asgn_type?(node)
+          node.lvasgn_type? || node.ivasgn_type? || node.cvasgn_type? || node.gvasgn_type?
+        end
+
+        def branches_have_method?(node)
+          _condition, if_branch, else_branch = *node
+
+          return false unless if_branch && else_branch
+
+          if_branch.send_type? && if_branch.arguments.count == 1 &&
+            else_branch.send_type? && else_branch.arguments.count == 1 &&
+            same_method?(if_branch, else_branch)
+        end
+
+        def same_method?(if_branch, else_branch)
+          if_branch.method?(else_branch.method_name) && if_branch.receiver == else_branch.receiver
+        end
+
+        def if_source(if_branch, arithmetic_operation)
+          if branches_have_method?(if_branch.parent) && if_branch.parenthesized?
+            if_branch.source.delete_suffix(')')
+          elsif arithmetic_operation
+            argument_source = if_branch.first_argument.source
+
+            "#{if_branch.receiver.source} #{if_branch.method_name} (#{argument_source}"
+          else
+            if_branch.source
+          end
+        end
+
+        def else_source(else_branch, arithmetic_operation) # rubocop:disable Metrics/AbcSize
+          if arithmetic_operation
+            "#{else_branch.first_argument.source})"
+          elsif branches_have_method?(else_branch.parent)
+            else_source_if_has_method(else_branch)
+          elsif require_parentheses?(else_branch)
             "(#{else_branch.source})"
           elsif without_argument_parentheses_method?(else_branch)
             "#{else_branch.method_name}(#{else_branch.arguments.map(&:source).join(', ')})"
+          elsif branches_have_assignment?(else_branch.parent)
+            else_source_if_has_assignment(else_branch)
           else
             else_branch.source
           end
         end
 
+        def else_source_if_has_method(else_branch)
+          if require_parentheses?(else_branch.first_argument)
+            "(#{else_branch.first_argument.source})"
+          elsif require_braces?(else_branch.first_argument)
+            "{ #{else_branch.first_argument.source} }"
+          else
+            else_branch.first_argument.source
+          end
+        end
+
+        def else_source_if_has_assignment(else_branch)
+          if require_parentheses?(else_branch.expression)
+            "(#{else_branch.expression.source})"
+          elsif require_braces?(else_branch.expression)
+            "{ #{else_branch.expression.source} }"
+          else
+            else_branch.expression.source
+          end
+        end
+
         def make_ternary_form(node)
           _condition, if_branch, else_branch = *node
-          ternary_form = [if_branch.source, else_source(else_branch)].join(' || ')
+          arithmetic_operation = use_arithmetic_operation?(if_branch)
+
+          ternary_form = [
+            if_source(if_branch, arithmetic_operation),
+            else_source(else_branch, arithmetic_operation)
+          ].join(' || ')
+          ternary_form += ')' if branches_have_method?(node) && if_branch.parenthesized?
 
           if node.parent&.send_type?
             "(#{ternary_form})"
@@ -126,9 +234,17 @@ module RuboCop
             (node.respond_to?(:semantic_operator?) && node.semantic_operator?)
         end
 
+        def require_braces?(node)
+          node.hash_type? && !node.braces?
+        end
+
+        def use_arithmetic_operation?(node)
+          node.respond_to?(:arithmetic_operation?) && node.arithmetic_operation?
+        end
+
         def without_argument_parentheses_method?(node)
-          node.send_type? &&
-            !node.arguments.empty? && !node.parenthesized? && !node.operator_method?
+          node.send_type? && !node.arguments.empty? &&
+            !node.parenthesized? && !node.operator_method? && !node.assignment_method?
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for redundant returning of true/false in conditionals.
+      # Checks for redundant returning of true/false in conditionals.
       #
       # @example
       #   # bad

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for RuntimeError as the argument of raise/fail.
+      # Checks for RuntimeError as the argument of raise/fail.
       #
       # It checks for code like this:
       #

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop identifies places where `fetch(key) { value }`
+      # Identifies places where `fetch(key) { value }`
       # can be replaced by `fetch(key, value)`.
       #
       # In such cases `fetch(key, value)` method is faster
@@ -50,7 +50,7 @@ module RuboCop
             ${nil? #basic_literal? #const_type?})
         PATTERN
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           redundant_fetch_block_candidate?(node) do |send, body|
             return if should_not_check?(send, body)
 

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for the presence of superfluous `.rb` extension in
+      # Checks for the presence of superfluous `.rb` extension in
       # the filename provided to `require` and `require_relative`.
       #
       # Note: If the extension is omitted, Ruby tries adding '.rb', '.so',

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop check for uses of `Object#freeze` on immutable objects.
+      # Check for uses of `Object#freeze` on immutable objects.
       #
       # NOTE: Regexp and Range literals are frozen objects since Ruby 3.0.
       #

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

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for `initialize` methods that are redundant.
+      #
+      # An initializer is redundant if it does not do anything, or if it only
+      # calls `super` with the same arguments given to it. If the initializer takes
+      # an argument that accepts multiple values (`restarg`, `kwrestarg`, etc.) it
+      # will not register an offense, because it allows the initializer to take a different
+      # number of arguments as its superclass potentially does.
+      #
+      # NOTE: If an initializer argument has a default value, RuboCop assumes it
+      # to *not* be redundant.
+      #
+      # NOTE: Empty initializers are registered as offenses, but it is possible
+      # to purposely create an empty `initialize` method to override a superclass's
+      # initializer.
+      #
+      # @safety
+      #   This cop is unsafe because if subclass overrides `initialize` method with
+      #   a different arity than superclass.
+      #
+      # @example
+      #   # bad
+      #   def initialize
+      #   end
+      #
+      #   # bad
+      #   def initialize
+      #     super
+      #   end
+      #
+      #   # bad
+      #   def initialize(a, b)
+      #     super
+      #   end
+      #
+      #   # bad
+      #   def initialize(a, b)
+      #     super(a, b)
+      #   end
+      #
+      #   # good
+      #   def initialize
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   def initialize
+      #     do_something
+      #     super
+      #   end
+      #
+      #   # good (different number of parameters)
+      #   def initialize(a, b)
+      #     super(a)
+      #   end
+      #
+      #   # good (default value)
+      #   def initialize(a, b = 5)
+      #     super
+      #   end
+      #
+      #   # good (default value)
+      #   def initialize(a, b: 5)
+      #     super
+      #   end
+      #
+      #   # good (changes the parameter requirements)
+      #   def initialize(*)
+      #   end
+      #
+      #   # good (changes the parameter requirements)
+      #   def initialize(**)
+      #   end
+      #
+      #   # good (changes the parameter requirements)
+      #   def initialize(...)
+      #   end
+      #
+      # @example AllowComments: true (default)
+      #
+      #   # good
+      #   def initialize
+      #     # Overriding to negate superclass `initialize` method.
+      #   end
+      #
+      # @example AllowComments: false
+      #
+      #   # bad
+      #   def initialize
+      #     # Overriding to negate superclass `initialize` method.
+      #   end
+      #
+      class RedundantInitialize < Base
+        include CommentsHelp
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Remove unnecessary `initialize` method.'
+        MSG_EMPTY = 'Remove unnecessary empty `initialize` method.'
+
+        # @!method initialize_forwards?(node)
+        def_node_matcher :initialize_forwards?, <<~PATTERN
+          (def _ (args $arg*) $({super zsuper} ...))
+        PATTERN
+
+        def on_def(node)
+          return if acceptable?(node)
+
+          if node.body.nil?
+            register_offense(node, MSG_EMPTY)
+          else
+            return if node.body.begin_type?
+
+            if (args, super_node = initialize_forwards?(node))
+              return unless same_args?(super_node, args)
+
+              register_offense(node, MSG)
+            end
+          end
+        end
+
+        private
+
+        def register_offense(node, message)
+          add_offense(node, message: message) do |corrector|
+            corrector.remove(range_by_whole_lines(node.source_range, include_final_newline: true))
+          end
+        end
+
+        def acceptable?(node)
+          !node.method?(:initialize) || forwards?(node) || allow_comments?(node)
+        end
+
+        def forwards?(node)
+          node.arguments.each_child_node(:restarg, :kwrestarg, :forward_args, :forward_arg).any?
+        end
+
+        def allow_comments?(node)
+          cop_config['AllowComments'] && contains_comments?(node)
+        end
+
+        def same_args?(super_node, args)
+          return true if super_node.zsuper_type?
+
+          args.map(&:name) == super_node.arguments.map { |a| a.children[0] }
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,28 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for strings that are just an interpolated expression.
+      # Checks for strings that are just an interpolated expression.
+      #
+      # @safety
+      #   Autocorrection is unsafe because when calling a destructive method to string,
+      #   the resulting string may have different behavior or raise `FrozenError`.
+      #
+      #   [source,ruby]
+      #   ----
+      #   x = 'a'
+      #   y = "#{x}"
+      #   y << 'b'   # return 'ab'
+      #   x          # return 'a'
+      #   y = x.to_s
+      #   y << 'b'   # return 'ab'
+      #   x          # return 'ab'
+      #
+      #   x = 'a'.freeze
+      #   y = "#{x}"
+      #   y << 'b'   # return 'ab'.
+      #   y = x.to_s
+      #   y << 'b'   # raise `FrozenError`.
+      #   ----
       #
       # @example
       #

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 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.arithmetic_operation? && node.first_argument.begin_type?
         end
 
         def empty_parentheses?(node)
@@ -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
       #

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_codepoins?(expr.expressions.first)
 
             yield expr
           end
@@ -79,10 +80,14 @@ module RuboCop
           !non_redundant
         end
 
+        def multiple_codepoins?(expression)
+          expression.respond_to?(:codepoints) && expression.codepoints.count >= 2
+        end
+
         def without_character_class(loc)
           without_character_class = loc.source[1..-2]
 
-          # Adds `\` to prevent auto-correction that changes to an interpolated string when `[#]`.
+          # 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
@@ -94,7 +99,7 @@ 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

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
@@ -59,7 +59,7 @@ module RuboCop
         def allowed_escape?(node, char, 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)

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
@@ -76,7 +76,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
 

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:
       #
@@ -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.rb

@@ -3,7 +3,7 @@
 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.
       #
       # @safety
@@ -32,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[
@@ -67,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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for places where conditional branch makes redundant self-assignment.
+      # 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`.