rubocop 1.34.1 → 1.54.0

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for redundant dot before operator method call.
+      # The target operator methods are `|`, `^`, `&`, `<=>`, `==`, `===`, `=~`, `>`, `>=`, `<`,
+      # `<=`, `<<`, `>>`, `+`, `-`, `*`, `/`, `%`, `**`, `~`, `!`, `!=`, and `!~`.
+      #
+      # @example
+      #
+      #   # bad
+      #   foo.+ bar
+      #   foo.& bar
+      #
+      #   # good
+      #   foo + bar
+      #   foo & bar
+      #
+      class OperatorMethodCall < Base
+        extend AutoCorrector
+
+        MSG = 'Redundant dot detected.'
+        RESTRICT_ON_SEND = %i[| ^ & <=> == === =~ > >= < <= << >> + - * / % ** ~ ! != !~].freeze
+
+        def on_send(node)
+          return unless (dot = node.loc.dot)
+          return if node.receiver.const_type? || !node.arguments.one?
+
+          _lhs, _op, rhs = *node
+          return if !rhs || method_call_with_parenthesized_arg?(rhs) || anonymous_forwarding?(rhs)
+
+          add_offense(dot) do |corrector|
+            wrap_in_parentheses_if_chained(corrector, node)
+            corrector.replace(dot, ' ')
+          end
+        end
+
+        private
+
+        # Checks for an acceptable case of `foo.+(bar).baz`.
+        def method_call_with_parenthesized_arg?(argument)
+          return false unless argument.parent.parent&.send_type?
+
+          argument.children.first && argument.parent.parenthesized?
+        end
+
+        def anonymous_forwarding?(argument)
+          return true if argument.forwarded_args_type? || argument.forwarded_restarg_type?
+          return true if argument.hash_type? && argument.children.first&.forwarded_kwrestarg_type?
+
+          argument.block_pass_type? && argument.source == '&'
+        end
+
+        def wrap_in_parentheses_if_chained(corrector, node)
+          return unless node.parent&.call_type?
+
+          operator = node.loc.selector
+
+          ParenthesesCorrector.correct(corrector, node)
+          corrector.insert_after(operator, ' ')
+          corrector.wrap(node, '(', ')')
+        end
+      end
+    end
+  end
+end

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

@@ -31,22 +31,26 @@ module RuboCop
         def on_masgn(node)
           lhs, rhs = *node
           lhs_elements = *lhs
+          rhs = rhs.body if rhs.rescue_type?
           rhs_elements = Array(rhs).compact # edge case for one constant
 
           return if allowed_lhs?(lhs) || allowed_rhs?(rhs) ||
                     allowed_masign?(lhs_elements, rhs_elements)
 
-          add_offense(node) { |corrector| autocorrect(corrector, node) }
+          range = node.source_range.begin.join(rhs.source_range.end)
+
+          add_offense(range) do |corrector|
+            autocorrect(corrector, node, lhs, rhs)
+          end
         end
 
         private
 
-        def autocorrect(corrector, node)
-          left, right = *node
-          left_elements = *left
-          right_elements = Array(right).compact
+        def autocorrect(corrector, node, lhs, rhs)
+          left_elements = *lhs
+          right_elements = Array(rhs).compact
           order = find_valid_order(left_elements, right_elements)
-          correction = assignment_corrector(node, order)
+          correction = assignment_corrector(node, rhs, order)
 
           corrector.replace(correction.correction_range, correction.correction)
         end
@@ -77,14 +81,19 @@ module RuboCop
           node.block_type? || node.send_type?
         end
 
-        def assignment_corrector(node, order)
-          _assignment, modifier = *node.parent
+        def assignment_corrector(node, rhs, order)
+          if node.parent&.rescue_type?
+            _assignment, modifier = *node.parent
+          else
+            _assignment, modifier = *rhs.parent
+          end
+
           if modifier_statement?(node.parent)
-            ModifierCorrector.new(node, config, order)
+            ModifierCorrector.new(node, rhs, modifier, config, order)
           elsif rescue_modifier?(modifier)
-            RescueCorrector.new(node, config, order)
+            RescueCorrector.new(node, rhs, modifier, config, order)
           else
-            GenericCorrector.new(node, config, order)
+            GenericCorrector.new(node, rhs, modifier, config, order)
           end
         end
 
@@ -172,17 +181,21 @@ module RuboCop
         end
 
         def modifier_statement?(node)
-          node && %i[if while until].include?(node.type) && node.modifier_form?
+          return false unless node
+
+          node.basic_conditional? && node.modifier_form?
         end
 
         # An internal class for correcting parallel assignment
         class GenericCorrector
           include Alignment
 
-          attr_reader :config, :node
+          attr_reader :node, :rhs, :rescue_result, :config
 
-          def initialize(node, config, new_elements)
+          def initialize(node, rhs, modifier, config, new_elements)
             @node = node
+            @rhs = rhs
+            _, _, @rescue_result = *modifier
             @config = config
             @new_elements = new_elements
           end
@@ -226,13 +239,10 @@ module RuboCop
         # protected by rescue
         class RescueCorrector < GenericCorrector
           def correction
-            _node, rescue_clause = *node.parent
-            _, _, rescue_result = *rescue_clause
-
             # If the parallel assignment uses a rescue modifier and it is the
             # only contents of a method, then we want to make use of the
             # implicit begin
-            if node.parent.parent&.def_type?
+            if rhs.parent.parent.parent&.def_type?
               super + def_correction(rescue_result)
             else
               begin_correction(rescue_result)
@@ -240,7 +250,7 @@ module RuboCop
           end
 
           def correction_range
-            node.parent.source_range
+            rhs.parent.parent.source_range
           end
 
           private

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

@@ -92,9 +92,8 @@ module RuboCop
 
         def contains_delimiter?(node, delimiters)
           delimiters_regexp = Regexp.union(delimiters)
-          node
-            .children.map { |n| string_source(n) }.compact
-            .any? { |s| delimiters_regexp.match?(s) }
+
+          node.children.filter_map { |n| string_source(n) }.any?(delimiters_regexp)
         end
 
         def string_source(node)

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

@@ -44,7 +44,7 @@ module RuboCop
 
           # Report offense only if changing case doesn't change semantics,
           # i.e., if the string would become dynamic or has special characters.
-          ast = ProcessedSource.new(corrected(node.source), target_ruby_version).ast
+          ast = parse(corrected(node.source)).ast
           return if node.children != ast.children
 
           add_offense(node.loc.begin) do |corrector|

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

@@ -83,10 +83,31 @@ module RuboCop
           end
         end
 
+        # @private
+        # @param [RuboCop::AST::Node] node
+        # @return [String, nil]
+        def preferred_expression_to_node_with_constant_prefix(node)
+          expression = preferred_expression_to(node)
+          return unless expression
+
+          "#{constant_prefix(node)}#{expression}"
+        end
+
+        # @private
+        # @param [RuboCop::AST::Node] node
+        # @return [String]
+        def constant_prefix(node)
+          if node.each_ancestor(:class, :module).any?
+            '::'
+          else
+            ''
+          end
+        end
+
         # @private
         # @param [RuboCop::AST::Node] node
         def on_back_ref_or_gvar_or_nth_ref(node)
-          preferred_expression = preferred_expression_to(node)
+          preferred_expression = preferred_expression_to_node_with_constant_prefix(node)
           return unless preferred_expression
 
           add_offense(

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

@@ -61,7 +61,7 @@ module RuboCop
           if style == :verbose
             "has_#{method_name}"
           else
-            method_name.to_s.sub(/has_/, '')
+            method_name.to_s.delete_prefix('has_')
           end
         end
 

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

@@ -19,7 +19,8 @@ module RuboCop
         MSG = 'Use `proc` instead of `Proc.new`.'
 
         # @!method proc_new?(node)
-        def_node_matcher :proc_new?, '(block $(send (const {nil? cbase} :Proc) :new) ...)'
+        def_node_matcher :proc_new?,
+                         '({block numblock} $(send (const {nil? cbase} :Proc) :new) ...)'
 
         def on_block(node)
           proc_new?(node) do |block_method|
@@ -28,6 +29,8 @@ module RuboCop
             end
           end
         end
+
+        alias on_numblock on_block
       end
     end
   end

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

@@ -93,7 +93,7 @@ module RuboCop
                        end
 
           # The conversion process doubles escaped slashes, so they have to be reverted
-          correction.gsub('\\\\', '\\')
+          correction.gsub('\\\\', '\\').gsub('\"', '"')
         end
 
         def style

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

@@ -13,6 +13,7 @@ module RuboCop
       # ----
       # Methods:
       #   join: ''
+      #   sum: 0
       #   split: ' '
       #   chomp: "\n"
       #   chomp!: "\n"
@@ -33,6 +34,7 @@ module RuboCop
       #   # bad
       #   array.join('')
       #   [1, 2, 3].join("")
+      #   array.sum(0)
       #   string.split(" ")
       #   "first\nsecond".split(" ")
       #   string.chomp("\n")
@@ -42,6 +44,7 @@ module RuboCop
       #   # good
       #   array.join
       #   [1, 2, 3].join
+      #   array.sum
       #   string.split
       #   "first second".split
       #   string.chomp

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for the instantiation of array using redundant `Array` constructor.
+      # Autocorrect replaces to array literal which is the simplest and fastest.
+      #
+      # @example
+      #
+      #   # bad
+      #   Array.new([])
+      #   Array[]
+      #   Array([])
+      #   Array.new(['foo', 'foo', 'foo'])
+      #   Array['foo', 'foo', 'foo']
+      #   Array(['foo', 'foo', 'foo'])
+      #
+      #   # good
+      #   []
+      #   ['foo', 'foo', 'foo']
+      #   Array.new(3, 'foo')
+      #   Array.new(3) { 'foo' }
+      #
+      class RedundantArrayConstructor < Base
+        extend AutoCorrector
+
+        MSG = 'Remove the redundant `Array` constructor.'
+
+        RESTRICT_ON_SEND = %i[new [] Array].freeze
+
+        # @!method redundant_array_constructor(node)
+        def_node_matcher :redundant_array_constructor, <<~PATTERN
+          {
+            (send
+              (const {nil? cbase} :Array) :new
+              $(array ...))
+            (send
+              (const {nil? cbase} :Array) :[]
+              $...)
+            (send
+              nil? :Array
+              $(array ...))
+          }
+        PATTERN
+
+        def on_send(node)
+          return unless (array_literal = redundant_array_constructor(node))
+
+          receiver = node.receiver
+          selector = node.loc.selector
+
+          if node.method?(:new)
+            range = receiver.source_range.join(selector)
+            replacement = array_literal
+          elsif node.method?(:Array)
+            range = selector
+            replacement = array_literal
+          else
+            range = receiver
+            replacement = selector.begin.join(node.source_range.end)
+          end
+
+          register_offense(range, node, replacement)
+        end
+
+        private
+
+        def register_offense(range, node, replacement)
+          add_offense(range) do |corrector|
+            corrector.replace(node, replacement.source)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -75,6 +75,7 @@ module RuboCop
 
         def on_def(node)
           return unless node.body&.kwbegin_type?
+          return if node.endless? && !node.body.children.one?
 
           register_offense(node.body)
         end
@@ -89,6 +90,8 @@ module RuboCop
           register_offense(node.body)
         end
 
+        alias on_numblock on_block
+
         def on_kwbegin(node)
           return unless (target_node = offensive_kwbegins(node).to_a.last)
 
@@ -143,7 +146,7 @@ module RuboCop
         end
 
         def use_modifier_form_after_multiline_begin_block?(node)
-          return unless (parent = node.parent)
+          return false unless (parent = node.parent)
 
           node.multiline? && parent.if_type? && parent.modifier_form?
         end

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

@@ -36,6 +36,9 @@ module RuboCop
 
         MSG = 'Use double pipes `||` instead.'
         REDUNDANT_CONDITION = 'This condition is not needed.'
+        ARGUMENT_WITH_OPERATOR_TYPES = %i[
+          splat block_pass forwarded_restarg forwarded_kwrestarg forwarded_args
+        ].freeze
 
         def on_if(node)
           return if node.elsif_conditional?
@@ -67,8 +70,8 @@ module RuboCop
         end
 
         def range_of_offense(node)
-          return node.loc.expression unless node.ternary?
-          return node.loc.expression if node.ternary? && branches_have_method?(node)
+          return node.source_range unless node.ternary?
+          return node.source_range if node.ternary? && branches_have_method?(node)
 
           range_between(node.loc.question.begin_pos, node.loc.colon.end_pos)
         end
@@ -145,15 +148,30 @@ module RuboCop
 
           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 &&
+          single_argument_method?(if_branch) && single_argument_method?(else_branch) &&
             same_method?(if_branch, else_branch)
         end
 
+        def single_argument_method?(node)
+          return false if !node.send_type? || node.method?(:[]) || !node.arguments.one?
+
+          !argument_with_operator?(node.first_argument)
+        end
+
         def same_method?(if_branch, else_branch)
           if_branch.method?(else_branch.method_name) && if_branch.receiver == else_branch.receiver
         end
 
+        # If the argument is using an operator, it is an invalid syntax.
+        # e.g. `foo || *bar`, `foo || **bar`, and `foo || &bar`.
+        def argument_with_operator?(argument)
+          return true if ARGUMENT_WITH_OPERATOR_TYPES.include?(argument.type)
+          return false unless argument.hash_type?
+          return false unless (node = argument.children.first)
+
+          node.kwsplat_type? || node.forwarded_kwrestarg_type?
+        end
+
         def if_source(if_branch, arithmetic_operation)
           if branches_have_method?(if_branch.parent) && if_branch.parenthesized?
             if_branch.source.delete_suffix(')')

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

@@ -63,7 +63,7 @@ module RuboCop
         RUBY
 
         def offense?(node)
-          return if node.modifier_form?
+          return false if node.modifier_form?
 
           redundant_condition?(node) || redundant_condition_inverted?(node)
         end
@@ -86,10 +86,6 @@ module RuboCop
         def indented_else_node(expression, node)
           "else\n#{indentation(node)}#{expression}"
         end
-
-        def configured_indentation_width
-          super || 2
-        end
       end
     end
   end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Avoid redundant `::` prefix on constant.
+      #
+      # How Ruby searches constant is a bit complicated, and it can often be difficult to
+      # understand from the code whether the `::` is intended or not. Where `Module.nesting`
+      # is empty, there is no need to prepend `::`, so it would be nice to consistently
+      # avoid such meaningless `::` prefix to avoid confusion.
+      #
+      # NOTE: This cop is disabled if `Lint/ConstantResolution` cop is enabled to prevent
+      # conflicting rules. Because it respects user configurations that want to enable
+      # `Lint/ConstantResolution` cop which is disabled by default.
+      #
+      # @example
+      #   # bad
+      #   ::Const
+      #
+      #   # good
+      #   Const
+      #
+      #   # bad
+      #   class << self
+      #     ::Const
+      #   end
+      #
+      #   # good
+      #   class << self
+      #     Const
+      #   end
+      #
+      #   # good
+      #   class A
+      #     ::Const
+      #   end
+      #
+      #   # good
+      #   module A
+      #     ::Const
+      #   end
+      class RedundantConstantBase < Base
+        extend AutoCorrector
+
+        MSG = 'Remove redundant `::`.'
+
+        def on_cbase(node)
+          return if lint_constant_resolution_cop_enabled?
+          return unless bad?(node)
+
+          add_offense(node) do |corrector|
+            corrector.remove(node)
+          end
+        end
+
+        private
+
+        def lint_constant_resolution_cop_enabled?
+          lint_constant_resolution_config.fetch('Enabled', false)
+        end
+
+        def lint_constant_resolution_config
+          config.for_cop('Lint/ConstantResolution')
+        end
+
+        def bad?(node)
+          module_nesting_ancestors_of(node).none?
+        end
+
+        def module_nesting_ancestors_of(node)
+          node.each_ancestor(:class, :module).reject do |ancestor|
+            ancestor.class_type? && used_in_super_class_part?(node, class_node: ancestor)
+          end
+        end
+
+        def used_in_super_class_part?(node, class_node:)
+          class_node.parent_class&.each_descendant(:cbase)&.any? do |descendant|
+            descendant.equal?(node)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for uses a redundant current directory in path.
+      #
+      # @example
+      #
+      #   # bad
+      #   require_relative './path/to/feature'
+      #
+      #   # good
+      #   require_relative 'path/to/feature'
+      #
+      class RedundantCurrentDirectoryInPath < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Remove the redundant current directory path.'
+        CURRENT_DIRECTORY_PATH = './'
+
+        def on_send(node)
+          return unless node.method?(:require_relative)
+          return unless node.first_argument.str_content&.start_with?(CURRENT_DIRECTORY_PATH)
+          return unless (index = node.first_argument.source.index(CURRENT_DIRECTORY_PATH))
+
+          begin_pos = node.first_argument.source_range.begin.begin_pos + index
+          range = range_between(begin_pos, begin_pos + 2)
+
+          add_offense(range) do |corrector|
+            corrector.remove(range)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for redundant uses of double splat hash braces.
+      #
+      # @example
+      #
+      #   # bad
+      #   do_something(**{foo: bar, baz: qux})
+      #
+      #   # good
+      #   do_something(foo: bar, baz: qux)
+      #
+      class RedundantDoubleSplatHashBraces < Base
+        extend AutoCorrector
+
+        MSG = 'Remove the redundant double splat and braces, use keyword arguments directly.'
+
+        def on_hash(node)
+          return if node.pairs.empty? || node.pairs.any?(&:hash_rocket?)
+          return unless (parent = node.parent)
+          return unless parent.kwsplat_type?
+
+          add_offense(parent) do |corrector|
+            corrector.remove(parent.loc.operator)
+            corrector.remove(opening_brace(node))
+            corrector.remove(closing_brace(node))
+          end
+        end
+
+        private
+
+        def opening_brace(node)
+          node.loc.begin.join(node.children.first.source_range.begin)
+        end
+
+        def closing_brace(node)
+          node.children.last.source_range.end.join(node.loc.end)
+        end
+      end
+    end
+  end
+end