rubocop 1.31.1 → 1.51.0

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,25 +148,46 @@ 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
 
-        def if_source(if_branch)
+        # 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(')')
+          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)
-          if branches_have_method?(else_branch.parent)
+        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})"
@@ -198,7 +222,12 @@ module RuboCop
 
         def make_ternary_form(node)
           _condition, if_branch, else_branch = *node
-          ternary_form = [if_source(if_branch), 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?
@@ -227,6 +256,10 @@ module RuboCop
           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.assignment_method?

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

@@ -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_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

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

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for redundant `each`.
+      #
+      # @safety
+      #   This cop is unsafe, as it can produce false positives if the receiver
+      #   is not an `Enumerator`.
+      #
+      # @example
+      #
+      #   # bad
+      #   array.each.each { |v| do_something(v) }
+      #
+      #   # good
+      #   array.each { |v| do_something(v) }
+      #
+      #   # bad
+      #   array.each.each_with_index { |v, i| do_something(v, i) }
+      #
+      #   # good
+      #   array.each.with_index { |v, i| do_something(v, i) }
+      #   array.each_with_index { |v, i| do_something(v, i) }
+      #
+      #   # bad
+      #   array.each.each_with_object { |v, o| do_something(v, o) }
+      #
+      #   # good
+      #   array.each.with_object { |v, o| do_something(v, o) }
+      #   array.each_with_object { |v, o| do_something(v, o) }
+      #
+      class RedundantEach < Base
+        extend AutoCorrector
+
+        MSG = 'Remove redundant `each`.'
+        MSG_WITH_INDEX = 'Use `with_index` to remove redundant `each`.'
+        MSG_WITH_OBJECT = 'Use `with_object` to remove redundant `each`.'
+
+        RESTRICT_ON_SEND = %i[each each_with_index each_with_object].freeze
+
+        def on_send(node)
+          return unless (redundant_node = redundant_each_method(node))
+
+          range = range(node)
+
+          add_offense(range, message: message(node)) do |corrector|
+            case node.method_name
+            when :each
+              remove_redundant_each(corrector, range, redundant_node)
+            when :each_with_index
+              corrector.replace(node.loc.selector, 'with_index')
+            when :each_with_object
+              corrector.replace(node.loc.selector, 'with_object')
+            end
+          end
+        end
+
+        private
+
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def redundant_each_method(node)
+          return if node.last_argument&.block_pass_type?
+
+          if node.method?(:each) && !node.parent&.block_type?
+            ancestor_node = node.each_ancestor(:send).detect do |ancestor|
+              ancestor.receiver == node &&
+                (RESTRICT_ON_SEND.include?(ancestor.method_name) || ancestor.method?(:reverse_each))
+            end
+
+            return ancestor_node if ancestor_node
+          end
+
+          return unless (prev_method = node.children.first)
+          return if !prev_method.send_type? ||
+                    prev_method.parent.block_type? || prev_method.last_argument&.block_pass_type?
+
+          detected = prev_method.method_name.to_s.start_with?('each_') unless node.method?(:each)
+
+          prev_method if detected || prev_method.method?(:reverse_each)
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        def range(node)
+          if node.method?(:each)
+            node.loc.dot.join(node.loc.selector)
+          else
+            node.loc.selector
+          end
+        end
+
+        def message(node)
+          case node.method_name
+          when :each
+            MSG
+          when :each_with_index
+            MSG_WITH_INDEX
+          when :each_with_object
+            MSG_WITH_OBJECT
+          end
+        end
+
+        def remove_redundant_each(corrector, range, redundant_node)
+          corrector.remove(range)
+
+          if redundant_node.method?(:each_with_index)
+            corrector.replace(redundant_node.loc.selector, 'each.with_index')
+          elsif redundant_node.method?(:each_with_object)
+            corrector.replace(redundant_node.loc.selector, 'each.with_object')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,11 +3,13 @@
 module RuboCop
   module Cop
     module Style
-      # Identifies places where `fetch(key) { value }`
-      # can be replaced by `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
-      # than `fetch(key) { value }`.
+      # In such cases `fetch(key, value)` method is faster than `fetch(key) { value }`.
+      #
+      # NOTE: The block string `'value'` in `hash.fetch(:key) { 'value' }` is detected
+      # when frozen string literal magic comment is enabled (i.e. `# frozen_string_literal: true`),
+      # but not when disabled.
       #
       # @safety
       #   This cop is unsafe because it cannot be guaranteed that the receiver
@@ -50,7 +52,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_heredoc_delimiter_quotes.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for redundant heredoc delimiter quotes.
+      #
+      # @example
+      #
+      #   # bad
+      #   do_something(<<~'EOS')
+      #     no string interpolation style text
+      #   EOS
+      #
+      #   # good
+      #   do_something(<<~EOS)
+      #     no string interpolation style text
+      #   EOS
+      #
+      #   do_something(<<~'EOS')
+      #     #{string_interpolation_style_text_not_evaluated}
+      #   EOS
+      #
+      #   do_something(<<~'EOS')
+      #     Preserve \
+      #     newlines
+      #   EOS
+      #
+      class RedundantHeredocDelimiterQuotes < Base
+        include Heredoc
+        extend AutoCorrector
+
+        MSG = 'Remove the redundant heredoc delimiter quotes, use `%<replacement>s` instead.'
+        STRING_INTERPOLATION_OR_ESCAPED_CHARACTER_PATTERN = /#(\{|@|\$)|\\/.freeze
+
+        def on_heredoc(node)
+          return if need_heredoc_delimiter_quotes?(node)
+
+          replacement = "#{heredoc_type(node)}#{delimiter_string(node)}"
+
+          add_offense(node, message: format(MSG, replacement: replacement)) do |corrector|
+            corrector.replace(node, replacement)
+          end
+        end
+
+        private
+
+        def need_heredoc_delimiter_quotes?(node)
+          heredoc_delimiter = node.source.delete(heredoc_type(node))
+          return true unless heredoc_delimiter.start_with?("'", '"')
+
+          node.loc.heredoc_end.source.strip.match?(/\W/) ||
+            node.loc.heredoc_body.source.match?(STRING_INTERPOLATION_OR_ESCAPED_CHARACTER_PATTERN)
+        end
+      end
+    end
+  end
+end

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

@@ -140,7 +140,9 @@ module RuboCop
         end
 
         def allow_comments?(node)
-          cop_config['AllowComments'] && contains_comments?(node)
+          return false unless cop_config['AllowComments']
+
+          contains_comments?(node) && !comments_contain_disables?(node, name)
         end
 
         def same_args?(super_node, args)

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

@@ -97,7 +97,7 @@ module RuboCop
         end
 
         def autocorrect_variable_interpolation(corrector, embedded_node, node)
-          replacement = "#{embedded_node.loc.expression.source}.to_s"
+          replacement = "#{embedded_node.source}.to_s"
 
           corrector.replace(node, replacement)
         end
@@ -107,7 +107,7 @@ module RuboCop
 
           source = if require_parentheses?(embedded_var)
                      receiver = range_between(
-                       embedded_var.loc.expression.begin_pos, embedded_var.loc.selector.end_pos
+                       embedded_var.source_range.begin_pos, embedded_var.loc.selector.end_pos
                      )
                      arguments = embedded_var.arguments.map(&:source).join(', ')
 

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

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Check for redundant line continuation.
+      #
+      # This cop marks a line continuation as redundant if removing the backslash
+      # does not result in a syntax error.
+      # However, a backslash at the end of a comment or
+      # for string concatenation is not redundant and is not considered an offense.
+      #
+      # @example
+      #   # bad
+      #   foo. \
+      #     bar
+      #   foo \
+      #     &.bar \
+      #       .baz
+      #
+      #   # good
+      #   foo.
+      #     bar
+      #   foo
+      #     &.bar
+      #       .baz
+      #
+      #   # bad
+      #   [foo, \
+      #     bar]
+      #   {foo: \
+      #     bar}
+      #
+      #   # good
+      #   [foo,
+      #     bar]
+      #   {foo:
+      #     bar}
+      #
+      #   # bad
+      #   foo(bar, \
+      #     baz)
+      #
+      #   # good
+      #   foo(bar,
+      #     baz)
+      #
+      #   # also good - backslash in string concatenation is not redundant
+      #   foo('bar' \
+      #     'baz')
+      #
+      #   # also good - backslash at the end of a comment is not redundant
+      #   foo(bar, # \
+      #     baz)
+      #
+      #   # also good - backslash at the line following the newline begins with a + or -,
+      #   # it is not redundant
+      #   1 \
+      #     + 2 \
+      #       - 3
+      #
+      #   # also good - backslash with newline between the method name and its arguments,
+      #   # it is not redundant.
+      #   some_method \
+      #     (argument)
+      #
+      class RedundantLineContinuation < Base
+        include MatchRange
+        extend AutoCorrector
+
+        MSG = 'Redundant line continuation.'
+        ALLOWED_STRING_TOKENS = %i[tSTRING tSTRING_CONTENT].freeze
+        ARGUMENT_TYPES = %i[
+          kFALSE kNIL kSELF kTRUE tCONSTANT tCVAR tFLOAT tGVAR tIDENTIFIER tINTEGER tIVAR
+          tLBRACK tLCURLY tLPAREN_ARG tSTRING tSTRING_BEG tSYMBOL tXSTRING_BEG
+        ].freeze
+
+        def on_new_investigation
+          return unless processed_source.ast
+
+          each_match_range(processed_source.ast.source_range, /(\\\n)/) do |range|
+            next if require_line_continuation?(range)
+            next unless redundant_line_continuation?(range)
+
+            add_offense(range) do |corrector|
+              corrector.remove_leading(range, 1)
+            end
+          end
+        end
+
+        private
+
+        def require_line_continuation?(range)
+          !ends_with_backslash_without_comment?(range.source_line) ||
+            string_concatenation?(range.source_line) ||
+            start_with_arithmetic_operator?(processed_source[range.line]) ||
+            inside_string_literal_or_method_with_argument?(range)
+        end
+
+        def ends_with_backslash_without_comment?(source_line)
+          source_line.gsub(/#.+/, '').end_with?('\\')
+        end
+
+        def string_concatenation?(source_line)
+          /["']\s*\\\z/.match?(source_line)
+        end
+
+        def inside_string_literal_or_method_with_argument?(range)
+          processed_source.tokens.each_cons(2).any? do |token, next_token|
+            inside_string_literal?(range, token) || method_with_argument?(token, next_token)
+          end
+        end
+
+        def redundant_line_continuation?(range)
+          return true unless (node = find_node_for_line(range.line))
+          return false if argument_newline?(node)
+
+          source = node.parent ? node.parent.source : node.source
+          parse(source.gsub(/\\\n/, "\n")).valid_syntax?
+        end
+
+        def inside_string_literal?(range, token)
+          ALLOWED_STRING_TOKENS.include?(token.type) && token.pos.overlaps?(range)
+        end
+
+        # A method call without parentheses such as the following cannot remove `\`:
+        #
+        #   do_something \
+        #     argument
+        def method_with_argument?(current_token, next_token)
+          current_token.type == :tIDENTIFIER && ARGUMENT_TYPES.include?(next_token.type)
+        end
+
+        def argument_newline?(node)
+          node = node.children.first if node.root? && node.begin_type?
+
+          if argument_is_method?(node)
+            argument_newline?(node.first_argument)
+          else
+            return false unless method_call_with_arguments?(node)
+
+            node.loc.selector.line != node.first_argument.loc.line
+          end
+        end
+
+        def find_node_for_line(line)
+          processed_source.ast.each_node do |node|
+            return node if same_line?(node, line)
+          end
+        end
+
+        def same_line?(node, line)
+          return unless (source_range = node.source_range)
+
+          if node.is_a?(AST::StrNode)
+            if node.heredoc?
+              (node.loc.heredoc_body.line..node.loc.heredoc_body.last_line).cover?(line)
+            else
+              (source_range.line..source_range.last_line).cover?(line)
+            end
+          else
+            source_range.line == line
+          end
+        end
+
+        def argument_is_method?(node)
+          return false unless node.send_type?
+          return false unless (first_argument = node.first_argument)
+
+          method_call_with_arguments?(first_argument)
+        end
+
+        def method_call_with_arguments?(node)
+          node.call_type? && !node.arguments.empty?
+        end
+
+        def start_with_arithmetic_operator?(source_line)
+          %r{\A\s*[+\-*/%]}.match?(source_line)
+        end
+      end
+    end
+  end
+end