rubocop 1.56.0 → 1.57.0

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

@@ -4,13 +4,25 @@ module RuboCop
   module Cop
     module Style
       # Enforces the use of a single string formatting utility.
-      # Valid options include Kernel#format, Kernel#sprintf and String#%.
+      # Valid options include `Kernel#format`, `Kernel#sprintf`, and `String#%`.
       #
-      # The detection of String#% cannot be implemented in a reliable
+      # The detection of `String#%` cannot be implemented in a reliable
       # manner for all cases, so only two scenarios are considered -
       # if the first argument is a string literal and if the second
       # argument is an array literal.
       #
+      # Autocorrection will be applied when using argument is a literal or known built-in conversion
+      # methods such as `to_d`, `to_f`, `to_h`, `to_i`, `to_r`, `to_s`, and `to_sym` on variables,
+      # provided that their return value is not an array. For example, when using `to_s`,
+      # `'%s' % [1, 2, 3].to_s` can be autocorrected without any incompatibility:
+      #
+      # [source,ruby]
+      # ----
+      # '%s' % [1, 2, 3]        #=> '1'
+      # format('%s', [1, 2, 3]) #=> '[1, 2, 3]'
+      # '%s' % [1, 2, 3].to_s   #=> '[1, 2, 3]'
+      # ----
+      #
       # @example EnforcedStyle: format (default)
       #   # bad
       #   puts sprintf('%10s', 'hoge')
@@ -42,6 +54,9 @@ module RuboCop
         MSG = 'Favor `%<prefer>s` over `%<current>s`.'
         RESTRICT_ON_SEND = %i[format sprintf %].freeze
 
+        # Known conversion methods whose return value is not an array.
+        AUTOCORRECTABLE_METHODS = %i[to_d to_f to_h to_i to_r to_s to_sym].freeze
+
         # @!method formatter(node)
         def_node_matcher :formatter, <<~PATTERN
           {
@@ -53,7 +68,7 @@ module RuboCop
 
         # @!method variable_argument?(node)
         def_node_matcher :variable_argument?, <<~PATTERN
-          (send {str dstr} :% {send_type? lvar_type?})
+          (send {str dstr} :% #autocorrectable?)
         PATTERN
 
         def on_send(node)
@@ -70,6 +85,12 @@ module RuboCop
 
         private
 
+        def autocorrectable?(node)
+          return true if node.lvar_type?
+
+          node.send_type? && !AUTOCORRECTABLE_METHODS.include?(node.method_name)
+        end
+
         def message(detected_style)
           format(MSG, prefer: method_name(style), current: method_name(detected_style))
         end

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

@@ -55,6 +55,25 @@ module RuboCop
       #   foo || raise('exception') if something
       #   ok
       #
+      #   # bad
+      #   define_method(:test) do
+      #     if something
+      #       work
+      #     end
+      #   end
+      #
+      #   # good
+      #   define_method(:test) do
+      #     return unless something
+      #
+      #     work
+      #   end
+      #
+      #   # also good
+      #   define_method(:test) do
+      #     work if something
+      #   end
+      #
       # @example AllowConsecutiveConditionals: false (default)
       #   # bad
       #   def test
@@ -110,6 +129,13 @@ module RuboCop
         end
         alias on_defs on_def
 
+        def on_block(node)
+          return unless node.method?(:define_method) || node.method?(:define_singleton_method)
+
+          on_def(node)
+        end
+        alias on_numblock on_block
+
         def on_if(node)
           return if accepted_form?(node)
 

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

@@ -136,7 +136,7 @@ module RuboCop
 
         private
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def check_branches(node, branches)
           # return if any branch is empty. An empty branch can be an `if`
           # without an `else` or a branch that contains only comments.
@@ -149,9 +149,15 @@ module RuboCop
                     branches.any? { |branch| single_child_branch?(branch) }
 
           heads = branches.map { |branch| head(branch) }
-          check_expressions(node, heads, :before_condition) if duplicated_expressions?(node, heads)
+
+          return unless duplicated_expressions?(node, heads)
+
+          condition_variable = assignable_condition_value(node)
+          return if heads.first.assignment? && condition_variable == heads.first.name.to_s
+
+          check_expressions(node, heads, :before_condition)
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def duplicated_expressions?(node, expressions)
           unique_expressions = expressions.uniq
@@ -164,6 +170,14 @@ module RuboCop
           node.condition.child_nodes.none? { |n| n.source == lhs.source if n.variable? }
         end
 
+        def assignable_condition_value(node)
+          if node.condition.call_type?
+            (receiver = node.condition.receiver) ? receiver.source : node.condition.source
+          elsif node.condition.variable?
+            node.condition.source
+          end
+        end
+
         # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         def check_expressions(node, expressions, insert_position)
           return if expressions.any?(&:nil?)

data/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb

@@ -146,7 +146,9 @@ module RuboCop
           end
 
           def call_in_match_pattern?(node)
-            node.parent&.match_pattern_type?
+            return false unless (parent = node.parent)
+
+            parent.match_pattern_type? || parent.match_pattern_p_type?
           end
 
           def hash_literal_in_arguments?(node)

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

@@ -28,7 +28,7 @@ module RuboCop
         MSG = 'Avoid multi-line chains of blocks.'
 
         def on_block(node)
-          node.send_node.each_node(:send) do |send_node|
+          node.send_node.each_node(:send, :csend) do |send_node|
             receiver = send_node.receiver
 
             next unless (receiver&.block_type? || receiver&.numblock_type?) && receiver&.multiline?

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

@@ -39,7 +39,7 @@ module RuboCop
 
         MSG_IF = 'Avoid multi-line ternary operators, use `if` or `unless` instead.'
         MSG_SINGLE_LINE = 'Avoid multi-line ternary operators, use single-line instead.'
-        SINGLE_LINE_TYPES = %i[return break next send].freeze
+        SINGLE_LINE_TYPES = %i[return break next send csend].freeze
 
         def on_if(node)
           return unless offense?(node)

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

@@ -27,24 +27,16 @@ module RuboCop
 
           node.each_descendant(:if).select(&:ternary?).each do |nested_ternary|
             add_offense(nested_ternary) do |corrector|
-              if_node = if_node(nested_ternary)
-              next if part_of_ignored_node?(if_node)
+              next if part_of_ignored_node?(node)
 
-              autocorrect(corrector, if_node)
-              ignore_node(if_node)
+              autocorrect(corrector, node)
+              ignore_node(node)
             end
           end
         end
 
         private
 
-        def if_node(node)
-          node = node.parent
-          return node if node.if_type?
-
-          if_node(node)
-        end
-
         def autocorrect(corrector, if_node)
           replace_loc_and_whitespace(corrector, if_node.loc.question, "\n")
           replace_loc_and_whitespace(corrector, if_node.loc.colon, "\nelse\n")

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

@@ -45,7 +45,7 @@ module RuboCop
         MSG = 'Avoid using `OpenStruct`; use `Struct`, `Hash`, a class or test doubles instead.'
 
         # @!method uses_open_struct?(node)
-        def_node_matcher :uses_open_struct?, <<-PATTERN
+        def_node_matcher :uses_open_struct?, <<~PATTERN
           (const {nil? (cbase)} :OpenStruct)
         PATTERN
 

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

@@ -23,6 +23,7 @@ module RuboCop
         MSG = 'Redundant dot detected.'
         RESTRICT_ON_SEND = %i[| ^ & <=> == === =~ > >= < <= << >> + - * / % ** ~ ! != !~].freeze
 
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
         def on_send(node)
           return unless (dot = node.loc.dot)
           return if node.receiver.const_type? || !node.arguments.one?
@@ -33,8 +34,12 @@ module RuboCop
           add_offense(dot) do |corrector|
             wrap_in_parentheses_if_chained(corrector, node)
             corrector.replace(dot, ' ')
+
+            selector = node.loc.selector
+            corrector.insert_after(selector, ' ') if selector.end_pos == rhs.source_range.begin_pos
           end
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
 
         private
 
@@ -54,6 +59,7 @@ module RuboCop
 
         def wrap_in_parentheses_if_chained(corrector, node)
           return unless node.parent&.call_type?
+          return if node.parent.first_argument == node
 
           operator = node.loc.selector
 

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

@@ -114,7 +114,7 @@ module RuboCop
             if node.parent&.assignment?
               replace_begin_with_statement(corrector, offense_range, node)
             else
-              corrector.remove(offense_range)
+              remove_begin(corrector, offense_range, node)
             end
 
             if use_modifier_form_after_multiline_begin_block?(node)
@@ -136,6 +136,14 @@ module RuboCop
           restore_removed_comments(corrector, offense_range, node, first_child)
         end
 
+        def remove_begin(corrector, offense_range, node)
+          if node.parent.respond_to?(:endless?) && node.parent.endless?
+            offense_range = range_with_surrounding_space(offense_range, newlines: true)
+          end
+
+          corrector.remove(offense_range)
+        end
+
         # Restore comments that occur between "begin" and "first_child".
         # These comments will be moved to above the assignment line.
         def restore_removed_comments(corrector, offense_range, node, first_child)

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

@@ -70,19 +70,11 @@ module RuboCop
 
         def replacement_condition(node)
           condition = node.condition.source
-          expression = invert_expression?(node) ? "!(#{condition})" : condition
+          expression = redundant_condition_inverted?(node) ? "!(#{condition})" : condition
 
           node.elsif? ? indented_else_node(expression, node) : expression
         end
 
-        def invert_expression?(node)
-          (
-            (node.if? || node.elsif? || node.ternary?) && redundant_condition_inverted?(node)
-          ) || (
-            node.unless? && redundant_condition?(node)
-          )
-        end
-
         def indented_else_node(expression, node)
           "else\n#{indentation(node)}#{expression}"
         end

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

@@ -13,25 +13,50 @@ module RuboCop
       #   # good
       #   do_something(foo: bar, baz: qux)
       #
+      #   # bad
+      #   do_something(**{foo: bar, baz: qux}.merge(options))
+      #
+      #   # good
+      #   do_something(foo: bar, baz: qux, **options)
+      #
       class RedundantDoubleSplatHashBraces < Base
         extend AutoCorrector
 
         MSG = 'Remove the redundant double splat and braces, use keyword arguments directly.'
+        MERGE_METHODS = %i[merge merge!].freeze
 
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_hash(node)
-          return if node.pairs.empty? || node.pairs.any?(&:hash_rocket?)
+          return if !node.braces? || node.pairs.empty? || node.pairs.any?(&:hash_rocket?)
           return unless (parent = node.parent)
-          return unless parent.kwsplat_type?
+          return unless (kwsplat = node.each_ancestor(:kwsplat).first)
+          return if parent.call_type? && !merge_method?(parent)
 
-          add_offense(parent) do |corrector|
-            corrector.remove(parent.loc.operator)
-            corrector.remove(opening_brace(node))
-            corrector.remove(closing_brace(node))
+          add_offense(kwsplat) do |corrector|
+            autocorrect(corrector, node, kwsplat)
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         private
 
+        def autocorrect(corrector, node, kwsplat)
+          corrector.remove(kwsplat.loc.operator)
+          corrector.remove(opening_brace(node))
+          corrector.remove(closing_brace(node))
+
+          merge_methods = select_merge_method_nodes(kwsplat)
+          return if merge_methods.empty?
+
+          autocorrect_merge_methods(corrector, merge_methods, kwsplat)
+        end
+
+        def select_merge_method_nodes(kwsplat)
+          extract_send_methods(kwsplat).select do |node|
+            merge_method?(node)
+          end
+        end
+
         def opening_brace(node)
           node.loc.begin.join(node.children.first.source_range.begin)
         end
@@ -39,6 +64,44 @@ module RuboCop
         def closing_brace(node)
           node.children.last.source_range.end.join(node.loc.end)
         end
+
+        def autocorrect_merge_methods(corrector, merge_methods, kwsplat)
+          range = range_of_merge_methods(merge_methods)
+
+          new_kwsplat_arguments = extract_send_methods(kwsplat).map do |descendant|
+            convert_to_new_arguments(descendant)
+          end
+          new_source = new_kwsplat_arguments.compact.reverse.unshift('').join(', ')
+
+          corrector.replace(range, new_source)
+        end
+
+        def range_of_merge_methods(merge_methods)
+          begin_merge_method = merge_methods.last
+          end_merge_method = merge_methods.first
+
+          begin_merge_method.loc.dot.begin.join(end_merge_method.source_range.end)
+        end
+
+        def extract_send_methods(kwsplat)
+          @extract_send_methods ||= kwsplat.each_descendant(:send, :csend)
+        end
+
+        def convert_to_new_arguments(node)
+          return unless merge_method?(node)
+
+          node.arguments.map do |arg|
+            if arg.hash_type?
+              arg.source
+            else
+              "**#{arg.source}"
+            end
+          end
+        end
+
+        def merge_method?(node)
+          MERGE_METHODS.include?(node.method_name)
+        end
       end
     end
   end

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

@@ -6,6 +6,12 @@ module RuboCop
       # Identifies usages of `any?`, `empty?` or `none?` predicate methods
       # chained to `select`/`filter`/`find_all` and change them to use predicate method instead.
       #
+      # @safety
+      #   This cop's autocorrection is unsafe because `array.select.any?` evaluates all elements
+      #   through the `select` method, while `array.any?` uses short-circuit evaluation.
+      #   In other words, `array.select.any?` guarantees the evaluation of every element,
+      #   but `array.any?` does not necessarily evaluate all of them.
+      #
       # @example
       #   # bad
       #   arr.select { |x| x > 1 }.any?
@@ -28,6 +34,9 @@ module RuboCop
       #   # good
       #   arr.select { |x| x > 1 }.many?
       #
+      #   # good
+      #   arr.select { |x| x > 1 }.present?
+      #
       # @example AllCops:ActiveSupportExtensionsEnabled: true
       #   # bad
       #   arr.select { |x| x > 1 }.many?
@@ -35,12 +44,18 @@ module RuboCop
       #   # good
       #   arr.many? { |x| x > 1 }
       #
+      #   # bad
+      #   arr.select { |x| x > 1 }.present?
+      #
+      #   # good
+      #   arr.any? { |x| x > 1 }
+      #
       class RedundantFilterChain < Base
         extend AutoCorrector
 
         MSG = 'Use `%<prefer>s` instead of `%<first_method>s.%<second_method>s`.'
 
-        RAILS_METHODS = %i[many?].freeze
+        RAILS_METHODS = %i[many? present?].freeze
         RESTRICT_ON_SEND = (%i[any? empty? none? one?] + RAILS_METHODS).freeze
 
         # @!method select_predicate?(node)
@@ -58,7 +73,8 @@ module RuboCop
           empty?: :none?,
           none?: :none?,
           one?: :one?,
-          many?: :many?
+          many?: :many?,
+          present?: :any?
         }.freeze
         private_constant :REPLACEMENT_METHODS
 

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

@@ -98,7 +98,9 @@ module RuboCop
         end
 
         def like_method_argument_parentheses?(node)
-          node.send_type? && node.arguments.one? && !node.parenthesized? &&
+          return false if !node.send_type? && !node.super_type? && !node.yield_type?
+
+          node.arguments.one? && !node.parenthesized? &&
             !node.arithmetic_operation? && node.first_argument.begin_type?
         end
 
@@ -124,16 +126,32 @@ module RuboCop
 
         def check(begin_node)
           node = begin_node.children.first
-          return offense(begin_node, 'a keyword') if keyword_with_redundant_parentheses?(node)
-          return offense(begin_node, 'a literal') if disallowed_literal?(begin_node, node)
-          return offense(begin_node, 'a variable') if node.variable?
-          return offense(begin_node, 'a constant') if node.const_type?
 
-          return offense(begin_node, 'an interpolated expression') if interpolation?(begin_node)
+          if (message = find_offense_message(begin_node, node))
+            return offense(begin_node, message)
+          end
 
           check_send(begin_node, node) if node.call_type?
         end
 
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def find_offense_message(begin_node, node)
+          return 'a keyword' if keyword_with_redundant_parentheses?(node)
+          return 'a literal' if disallowed_literal?(begin_node, node)
+          return 'a variable' if node.variable?
+          return 'a constant' if node.const_type?
+          return 'an interpolated expression' if interpolation?(begin_node)
+
+          return if begin_node.chained? || !begin_node.parent.nil?
+
+          if node.and_type? || node.or_type?
+            'a logical expression'
+          elsif node.respond_to?(:comparison_method?) && node.comparison_method?
+            'a comparison expression'
+          end
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
         # @!method interpolation?(node)
         def_node_matcher :interpolation?, '[^begin ^^dstr]'
 

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

@@ -75,6 +75,11 @@ module RuboCop
           add_offense(offense_branch) do |corrector|
             assignment_value = opposite_branch ? opposite_branch.source : 'nil'
             replacement = "#{assignment_value} #{keyword} #{if_node.condition.source}"
+            if opposite_branch.respond_to?(:heredoc?) && opposite_branch.heredoc?
+              replacement += opposite_branch.loc.heredoc_end.with(
+                begin_pos: opposite_branch.source_range.end_pos
+              ).source
+            end
 
             corrector.replace(if_node, replacement)
           end

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

@@ -3,9 +3,13 @@
 module RuboCop
   module Cop
     module Style
-      # Enforces consistency between 'return nil' and 'return'.
+      # Enforces consistency between `return nil` and `return`.
       #
-      # Supported styles are: return, return_nil.
+      # This cop is disabled by default. Because there seems to be a perceived semantic difference
+      # between `return` and `return nil`. The former can be seen as just halting evaluation,
+      # while the latter might be used when the return value is of specific concern.
+      #
+      # Supported styles are `return` and `return_nil`.
       #
       # @example EnforcedStyle: return (default)
       #   # bad

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for single-line `do`...`end` block.
+      #
+      # In practice a single line `do`...`end` is autocorrected when `EnforcedStyle: semantic`
+      # in `Style/BlockDelimiters`. The autocorrection maintains the `do` ... `end` syntax to
+      # preserve semantics and does not change it to `{`...`}` block.
+      #
+      # @example
+      #
+      #   # bad
+      #   foo do |arg| bar(arg) end
+      #
+      #   # good
+      #   foo do |arg|
+      #     bar(arg)
+      #   end
+      #
+      #   # bad
+      #   ->(arg) do bar(arg) end
+      #
+      #   # good
+      #   ->(arg) { bar(arg) }
+      #
+      class SingleLineDoEndBlock < Base
+        extend AutoCorrector
+
+        MSG = 'Prefer multiline `do`...`end` block.'
+
+        def on_block(node)
+          return if !node.single_line? || node.braces?
+
+          add_offense(node) do |corrector|
+            corrector.insert_after(do_line(node), "\n")
+
+            node_body = node.body
+
+            if node_body.respond_to?(:heredoc?) && node_body.heredoc?
+              corrector.remove(node.loc.end)
+              corrector.insert_after(node_body.loc.heredoc_end, "\nend")
+            else
+              corrector.insert_after(node_body, "\n")
+            end
+          end
+        end
+        alias on_numblock on_block
+
+        private
+
+        def do_line(node)
+          if node.numblock_type? || node.arguments.children.empty? || node.send_node.lambda_literal?
+            node.loc.begin
+          else
+            node.arguments
+          end
+        end
+
+        def x(corrector, node); end
+      end
+    end
+  end
+end

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

@@ -173,7 +173,9 @@ module RuboCop
         end
 
         def correct_for_comment(corrector, node, if_branch)
-          comments = processed_source.ast_with_comments[if_branch]
+          comments = processed_source.ast_with_comments[if_branch].select do |comment|
+            comment.loc.line < if_branch.condition.first_line
+          end
           comment_text = comments.map(&:text).join("\n") << "\n"
 
           corrector.insert_before(node.loc.keyword, comment_text) unless comments.empty?

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

@@ -50,6 +50,14 @@ module RuboCop
         PERCENT_MSG = 'Use `%i` or `%I` for an array of symbols.'
         ARRAY_MSG = 'Use %<prefer>s for an array of symbols.'
         DELIMITERS = ['[', ']', '(', ')'].freeze
+        SPECIAL_GVARS = %w[
+          $! $" $$ $& $' $* $+ $, $/ $; $: $. $< $= $> $? $@ $\\ $_ $` $~ $0
+          $-0 $-F $-I $-K $-W $-a $-d $-i $-l $-p $-v $-w
+        ].freeze
+        REDEFINABLE_OPERATORS = %w(
+          | ^ & <=> == === =~ > >= < <= << >>
+          + - * / % ** ~ +@ -@ [] []= ` ! != !~
+        ).freeze
 
         class << self
           attr_accessor :largest_brackets
@@ -69,6 +77,8 @@ module RuboCop
 
         def complex_content?(node)
           node.children.any? do |sym|
+            return false if DELIMITERS.include?(sym.source)
+
             content = *sym
             content = content.map { |c| c.is_a?(AST::Node) ? c.source : c }.join
             content_without_delimiter_pairs = content.gsub(/(\[[^\s\[\]]*\])|(\([^\s\(\)]*\))/, '')
@@ -107,15 +117,6 @@ module RuboCop
         end
 
         def symbol_without_quote?(string)
-          special_gvars = %w[
-            $! $" $$ $& $' $* $+ $, $/ $; $: $. $< $= $> $? $@ $\\ $_ $` $~ $0
-            $-0 $-F $-I $-K $-W $-a $-d $-i $-l $-p $-v $-w
-          ]
-          redefinable_operators = %w(
-            | ^ & <=> == === =~ > >= < <= << >>
-            + - * / % ** ~ +@ -@ [] []= ` ! != !~
-          )
-
           # method name
           /\A[a-zA-Z_]\w*[!?]?\z/.match?(string) ||
             # instance / class variable
@@ -123,8 +124,8 @@ module RuboCop
             # global variable
             /\A\$[1-9]\d*\z/.match?(string) ||
             /\A\$[a-zA-Z_]\w*\z/.match?(string) ||
-            special_gvars.include?(string) ||
-            redefinable_operators.include?(string)
+            SPECIAL_GVARS.include?(string) ||
+            REDEFINABLE_OPERATORS.include?(string)
         end
       end
     end