rubocop 1.31.2 → 1.32.0

data/lib/rubocop/cop/mixin/check_line_breakable.rb

@@ -46,6 +46,8 @@ module RuboCop
         if node.send_type?
           args = process_args(node.arguments)
           return extract_breakable_node_from_elements(node, args, max)
+        elsif node.def_type?
+          return extract_breakable_node_from_elements(node, node.arguments, max)
         elsif node.array_type? || node.hash_type?
           return extract_breakable_node_from_elements(node, node.children, max)
         end
@@ -216,6 +218,8 @@ module RuboCop
 
       # @api private
       def already_on_multiple_lines?(node)
+        return node.first_line != node.arguments.last.last_line if node.def_type?
+
         node.first_line != node.last_line
       end
     end

data/lib/rubocop/cop/mixin/percent_array.rb

@@ -44,13 +44,26 @@ module RuboCop
         no_acceptable_style! if brackets_required
 
         bracketed_array = build_bracketed_array(node)
-        message = format(self.class::ARRAY_MSG, prefer: bracketed_array)
+        message = build_message_for_bracketed_array(bracketed_array)
 
         add_offense(node, message: message) do |corrector|
           corrector.replace(node, bracketed_array)
         end
       end
 
+      # @param [String] preferred_array_code
+      # @return [String]
+      def build_message_for_bracketed_array(preferred_array_code)
+        format(
+          self.class::ARRAY_MSG,
+          prefer: if preferred_array_code.include?("\n")
+                    'an array literal `[...]`'
+                  else
+                    "`#{preferred_array_code}`"
+                  end
+        )
+      end
+
       def check_bracketed_array(node, literal_prefix)
         return if allowed_bracket_array?(node)
 
@@ -63,6 +76,52 @@ module RuboCop
           percent_literal_corrector.correct(corrector, node, literal_prefix)
         end
       end
+
+      # @param [RuboCop::AST::ArrayNode] node
+      # @param [Array<String>] elements
+      # @return [String]
+      def build_bracketed_array_with_appropriate_whitespace(elements:, node:)
+        [
+          '[',
+          whitespace_leading(node),
+          elements.join(",#{whitespace_between(node)}"),
+          whitespace_trailing(node),
+          ']'
+        ].join
+      end
+
+      # Provides whitespace between elements for building a bracketed array.
+      #   %w[  a   b   c    ]
+      #         ^^^
+      # @param [RuboCop::AST::ArrayNode] node
+      # @return [String]
+      def whitespace_between(node)
+        if node.children.length >= 2
+          node.source[
+            node.children[0].loc.expression.end_pos...node.children[1].loc.expression.begin_pos
+          ]
+        else
+          ' '
+        end
+      end
+
+      # Provides leading whitespace for building a bracketed array.
+      #   %w[  a   b   c    ]
+      #      ^^
+      # @param [RuboCop::AST::ArrayNode] node
+      # @return [String]
+      def whitespace_leading(node)
+        node.source[node.loc.begin.end_pos...node.children[0].loc.expression.begin_pos]
+      end
+
+      # Provides trailing whitespace for building a bracketed array.
+      #   %w[  a   b   c    ]
+      #                 ^^^^
+      # @param [RuboCop::AST::ArrayNode] node
+      # @return [String]
+      def whitespace_trailing(node)
+        node.source[node.children[-1].loc.expression.end_pos...node.loc.end.begin_pos]
+      end
     end
   end
 end

data/lib/rubocop/cop/naming/predicate_name.rb

@@ -4,6 +4,8 @@ module RuboCop
   module Cop
     module Naming
       # Makes sure that predicates are named properly.
+      # `is_a?` method is allowed by default.
+      # These are customizable with `AllowedMethods` option.
       #
       # @example
       #   # bad
@@ -27,6 +29,12 @@ module RuboCop
       #   # good
       #   def value?
       #   end
+      #
+      # @example AllowedMethods: ['is_a?'] (default)
+      #   # good
+      #   def is_a?(value)
+      #   end
+      #
       class PredicateName < Base
         include AllowedMethods
 

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

@@ -5,6 +5,8 @@ module RuboCop
     module Style
       # Enforces the use of `Object#instance_of?` instead of class comparison
       # for equality.
+      # `==`, `equal?`, and `eql?` methods are ignored by default.
+      # These are customizable with `IgnoredMethods` option.
       #
       # @example
       #   # bad
@@ -16,6 +18,26 @@ module RuboCop
       #   # good
       #   var.instance_of?(Date)
       #
+      # @example IgnoreMethods: [] (default)
+      #   # good
+      #   var.instance_of?(Date)
+      #
+      #   # bad
+      #   var.class == Date
+      #   var.class.equal?(Date)
+      #   var.class.eql?(Date)
+      #   var.class.name == 'Date'
+      #
+      # @example IgnoreMethods: [`==`]
+      #   # good
+      #   var.instance_of?(Date)
+      #   var.class == Date
+      #   var.class.name == 'Date'
+      #
+      #   # bad
+      #   var.class.equal?(Date)
+      #   var.class.eql?(Date)
+      #
       class ClassEqualityComparison < Base
         include RangeHelp
         include IgnoredMethods

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

@@ -89,6 +89,41 @@ module RuboCop
       #   if condition
       #     statement
       #   end
+      #
+      # @example AllowComments: false (default)
+      #
+      #   # bad
+      #   if condition
+      #     statement
+      #   else
+      #     # something comment
+      #     nil
+      #   end
+      #
+      #   # bad
+      #   if condition
+      #     statement
+      #   else
+      #     # something comment
+      #   end
+      #
+      # @example AllowComments: true
+      #
+      #   # good
+      #   if condition
+      #     statement
+      #   else
+      #     # something comment
+      #     nil
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     statement
+      #   else
+      #     # something comment
+      #   end
+      #
       class EmptyElse < Base
         include OnNormalIfUnless
         include ConfigurableEnforcedStyle
@@ -108,6 +143,8 @@ module RuboCop
         private
 
         def check(node)
+          return if cop_config['AllowComments'] && comment_in_else?(node.loc)
+
           empty_check(node) if empty_style?
           nil_check(node) if nil_style?
         end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for using empty heredoc to reduce redundancy.
+      #
+      # @example
+      #
+      #   # bad
+      #   <<~EOS
+      #   EOS
+      #
+      #   <<-EOS
+      #   EOS
+      #
+      #   <<EOS
+      #   EOS
+      #
+      #   # good
+      #   ''
+      #
+      #   # bad
+      #   do_something(<<~EOS)
+      #   EOS
+      #
+      #   do_something(<<-EOS)
+      #   EOS
+      #
+      #   do_something(<<EOS)
+      #   EOS
+      #
+      #   # good
+      #   do_something('')
+      #
+      class EmptyHeredoc < Base
+        include Heredoc
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use an empty string literal instead of heredoc.'
+
+        def on_heredoc(node)
+          heredoc_body = node.loc.heredoc_body
+
+          return unless heredoc_body.source.empty?
+
+          add_offense(node) do |corrector|
+            heredoc_end = node.loc.heredoc_end
+
+            corrector.replace(node, "''")
+            corrector.remove(range_by_whole_lines(heredoc_body, include_final_newline: true))
+            corrector.remove(range_by_whole_lines(heredoc_end, include_final_newline: true))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -9,32 +9,15 @@ module RuboCop
       # On the other hand, `ENV.fetch` raises KeyError or returns the explicitly
       # specified default value.
       #
-      # When an `ENV[]` is the LHS of `||`, the autocorrect makes the RHS
-      # the default value of `ENV.fetch`.
-      #
       # @example
       #   # bad
       #   ENV['X']
-      #   ENV['X'] || 'string literal'
-      #   ENV['X'] || some_method
       #   x = ENV['X']
       #
-      #   ENV['X'] || y.map do |a|
-      #     puts a * 2
-      #   end
-      #
       #   # good
       #   ENV.fetch('X')
-      #   ENV.fetch('X', 'string literal')
-      #   ENV.fetch('X') { some_method }
       #   x = ENV.fetch('X')
       #
-      #   ENV.fetch('X') do
-      #     y.map do |a|
-      #       puts a * 2
-      #     end
-      #   end
-      #
       #   # also good
       #   !ENV['X']
       #   ENV['X'].some_method # (e.g. `.nil?`)
@@ -42,48 +25,20 @@ module RuboCop
       class FetchEnvVar < Base
         extend AutoCorrector
 
-        # rubocop:disable Layout/LineLength
-        MSG_DEFAULT_NIL = 'Use `ENV.fetch(%<key>s)` or `ENV.fetch(%<key>s, nil)` instead of `ENV[%<key>s]`.'
-        MSG_DEFAULT_RHS_SECOND_ARG_OF_FETCH = 'Use `ENV.fetch(%<key>s, %<default>s)` instead of `ENV[%<key>s] || %<default>s`.'
-        MSG_DEFAULT_RHS_SINGLE_LINE_BLOCK = 'Use `ENV.fetch(%<key>s) { %<default>s }` instead of `ENV[%<key>s] || %<default>s`.'
-        MSG_DEFAULT_RHS_MULTILINE_BLOCK = 'Use `ENV.fetch(%<key>s)` with a block containing `%<default>s ...`'
-        # rubocop:enable Layout/LineLength
+        MSG = 'Use `ENV.fetch(%<key>s)` or `ENV.fetch(%<key>s, nil)` instead of `ENV[%<key>s]`.'
 
         # @!method env_with_bracket?(node)
         def_node_matcher :env_with_bracket?, <<~PATTERN
           (send (const nil? :ENV) :[] $_)
         PATTERN
 
-        # @!method operand_of_or?(node)
-        def_node_matcher :operand_of_or?, <<~PATTERN
-          (^or ...)
-        PATTERN
-
-        # @!method block_control?(node)
-        def_node_matcher :block_control?, <<~PATTERN
-          ({next | break | retry | redo})
-        PATTERN
-
-        # @!method offensive_nodes(node)
-        def_node_search :offensive_nodes, <<~PATTERN
-          [#env_with_bracket? #offensive?]
-        PATTERN
-
         def on_send(node)
           env_with_bracket?(node) do |name_node|
             break unless offensive?(node)
 
-            if operand_of_or?(node)
-              target_node = offensive_nodes(or_chain_root(node)).to_a.last
-              target_name_node = env_with_bracket?(target_node)
-
-              if default_to_rhs?(target_node)
-                default_rhs(target_node, target_name_node)
-              else
-                default_nil(target_node, target_name_node)
-              end
-            else
-              default_nil(node, name_node)
+            message = format(MSG, key: name_node.source)
+            add_offense(node, message: message) do |corrector|
+              corrector.replace(node, new_code(name_node))
             end
           end
         end
@@ -130,17 +85,6 @@ module RuboCop
           !(allowed_var?(node) || allowable_use?(node))
         end
 
-        def or_chain_root(node)
-          while operand_of_or?(ancestor_or ||= node.parent)
-            ancestor_or = ancestor_or.parent
-          end
-          ancestor_or
-        end
-
-        def default_to_rhs?(node)
-          operand_of_or?(node) && !right_end_of_or_chains?(node) && rhs_can_be_default_value?(node)
-        end
-
         # Check if the node is a receiver and receives a message with dot syntax.
         def message_chained_with_dot?(node)
           return false if node.root?
@@ -157,8 +101,9 @@ module RuboCop
         #   it simply checks whether the variable is set.
         # - Receiving a message with dot syntax, e.g. `ENV['X'].nil?`.
         # - `ENV['key']` assigned by logical AND/OR assignment.
+        # - `ENV['key']` is the LHS of a `||`.
         def allowable_use?(node)
-          used_as_flag?(node) || message_chained_with_dot?(node) || assigned?(node)
+          used_as_flag?(node) || message_chained_with_dot?(node) || assigned?(node) || or_lhs?(node)
         end
 
         # The following are allowed cases:
@@ -172,127 +117,15 @@ module RuboCop
           node == lhs
         end
 
-        def left_end_of_or_chains?(node)
-          return false unless operand_of_or?(node)
-
-          node.parent.lhs == node
-        end
-
-        def right_end_of_or_chains?(node)
-          !(left_end_of_or_chains?(node) || node.parent&.parent&.or_type?)
-        end
-
-        def conterpart_rhs_of(node)
-          left_end_of_or_chains?(node) ? node.parent.rhs : node.parent.parent.rhs
-        end
-
-        def rhs_can_be_default_value?(node)
-          !rhs_is_block_control?(node)
-        end
+        def or_lhs?(node)
+          return false unless (parent = node.parent)&.or_type?
 
-        def rhs_is_block_control?(node)
-          block_control?(conterpart_rhs_of(node))
+          parent.lhs == node || parent.parent&.or_type?
         end
 
-        def new_code_default_nil(name_node)
+        def new_code(name_node)
           "ENV.fetch(#{name_node.source}, nil)"
         end
-
-        def new_code_default_rhs_single_line(node, name_node)
-          parent = node.parent
-          if parent.rhs.basic_literal?
-            "ENV.fetch(#{name_node.source}, #{parent.rhs.source})"
-          else
-            "ENV.fetch(#{name_node.source}) { #{parent.rhs.source} }"
-          end
-        end
-
-        def new_code_default_rhs_multiline(node, name_node)
-          env_indent = indent(node.parent)
-          default = node.parent.rhs.source.split("\n").map do |line|
-            "#{env_indent}#{line}"
-          end.join("\n")
-          <<~NEW_CODE.chomp
-            ENV.fetch(#{name_node.source}) do
-            #{configured_indentation}#{default}
-            #{env_indent}end
-          NEW_CODE
-        end
-
-        def new_code_default_rhs(node, name_node)
-          if node.parent.rhs.single_line?
-            new_code_default_rhs_single_line(node, name_node)
-          else
-            new_code_default_rhs_multiline(node, name_node)
-          end
-        end
-
-        def default_rhs(node, name_node)
-          if left_end_of_or_chains?(node)
-            default_rhs_in_same_or(node, name_node)
-          else
-            default_rhs_in_outer_or(node, name_node)
-          end
-        end
-
-        # Adds an offense and sets `nil` to the default value of `ENV.fetch`.
-        # `ENV['X']` --> `ENV.fetch('X', nil)`
-        def default_nil(node, name_node)
-          message = format(MSG_DEFAULT_NIL, key: name_node.source)
-
-          add_offense(node, message: message) do |corrector|
-            corrector.replace(node, new_code_default_nil(name_node))
-          end
-        end
-
-        # Adds an offense and makes the RHS the default value of `ENV.fetch`.
-        # `ENV['X'] || y` --> `ENV.fetch('X') { y }`
-        def default_rhs_in_same_or(node, name_node)
-          template = message_template_for(node.parent.rhs)
-          message = format(template,
-                           key: name_node.source,
-                           default: first_line_of(node.parent.rhs.source))
-
-          add_offense(node, message: message) do |corrector|
-            corrector.replace(node.parent, new_code_default_rhs(node, name_node))
-          end
-        end
-
-        # Adds an offense and makes the RHS the default value of `ENV.fetch`.
-        # `z || ENV['X'] || y` --> `z || ENV.fetch('X') { y }`
-        def default_rhs_in_outer_or(node, name_node)
-          parent = node.parent
-          grand_parent = parent.parent
-
-          template = message_template_for(grand_parent.rhs)
-          message = format(template,
-                           key: name_node.source,
-                           default: first_line_of(grand_parent.rhs.source))
-
-          add_offense(node, message: message) do |corrector|
-            lhs_code = parent.lhs.source
-            rhs_code = new_code_default_rhs(parent, name_node)
-            corrector.replace(grand_parent, "#{lhs_code} || #{rhs_code}")
-          end
-        end
-
-        def message_template_for(rhs)
-          if rhs.multiline?
-            MSG_DEFAULT_RHS_MULTILINE_BLOCK
-          elsif rhs.basic_literal?
-            MSG_DEFAULT_RHS_SECOND_ARG_OF_FETCH
-          else
-            MSG_DEFAULT_RHS_SINGLE_LINE_BLOCK
-          end
-        end
-
-        def configured_indentation
-          ' ' * (config.for_cop('Layout/IndentationWidth')['Width'] || 2)
-        end
-
-        def first_line_of(source)
-          source.split("\n").first
-        end
       end
     end
   end

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

@@ -12,6 +12,7 @@ module RuboCop
       # to encoded URLs or Date/Time formatting strings.
       #
       # This cop can be customized ignored methods with `IgnoredMethods`.
+      # By default, there are no methods to ignored.
       #
       # @example EnforcedStyle: annotated (default)
       #
@@ -61,6 +62,11 @@ module RuboCop
       #   # good
       #   format('%06d', 10)
       #
+      # @example IgnoredMethods: [] (default)
+      #
+      #   # bad
+      #   redirect('foo/%{bar_id}')
+      #
       # @example IgnoredMethods: [redirect]
       #
       #   # good

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

@@ -6,6 +6,8 @@ module RuboCop
       # Checks for redundant `if` with boolean literal branches.
       # It checks only conditions to return boolean value (`true` or `false`) for safe detection.
       # The conditions to be checked are comparison methods, predicate methods, and double negative.
+      # `nonzero?` method is allowed by default.
+      # These are customizable with `AllowedMethods` option.
       #
       # @safety
       #   Autocorrection is unsafe because there is no guarantee that all predicate methods

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

@@ -5,12 +5,24 @@ module RuboCop
     module Style
       # Checks for unwanted parentheses in parameterless method calls.
       #
+      # This cop can be customized ignored methods with `IgnoredMethods`.
+      # By default, there are no methods to ignored.
+      #
       # @example
       #   # bad
       #   object.some_method()
       #
       #   # good
       #   object.some_method
+      #
+      # @example IgnoredMethods: [] (default)
+      #   # bad
+      #   object.foo()
+      #
+      # @example IgnoredMethods: [foo]
+      #   # good
+      #   object.foo()
+      #
       class MethodCallWithoutArgsParentheses < Base
         include IgnoredMethods
         extend AutoCorrector

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

@@ -5,6 +5,10 @@ module RuboCop
     module Style
       # Checks for unparenthesized method calls in the argument list
       # of a parenthesized method call.
+      # `be`, `be_a`, `be_an`, `be_between`, `be_falsey`, `be_kind_of`, `be_instance_of`,
+      # `be_truthy`, `be_within`, `eq`, `eql`, `end_with`, `include`, `match`, `raise_error`,
+      # `respond_to`, and `start_with` methods are allowed by default.
+      # These are customizable with `AllowedMethods` option.
       #
       # @example
       #   # good
@@ -12,6 +16,11 @@ module RuboCop
       #
       #   # bad
       #   method1(method2 arg)
+      #
+      # @example AllowedMethods: [foo]
+      #   # good
+      #   method1(foo arg)
+      #
       class NestedParenthesizedCalls < Base
         include RangeHelp
         include AllowedMethods

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

@@ -6,13 +6,16 @@ module RuboCop
       # Checks for usage of comparison operators (`==`,
       # `>`, `<`) to test numbers as zero, positive, or negative.
       # These can be replaced by their respective predicate methods.
-      # The cop can also be configured to do the reverse.
+      # This cop can also be configured to do the reverse.
       #
-      # The cop disregards `#nonzero?` as its value is truthy or falsey,
+      # This cop can be customized ignored methods with `IgnoredMethods`.
+      # By default, there are no methods to ignored.
+      #
+      # This cop disregards `#nonzero?` as its value is truthy or falsey,
       # but not `true` and `false`, and thus not always interchangeable with
       # `!= 0`.
       #
-      # The cop ignores comparisons to global variables, since they are often
+      # This cop ignores comparisons to global variables, since they are often
       # populated with objects which can be compared with integers, but are
       # not themselves `Integer` polymorphic.
       #
@@ -23,29 +26,40 @@ module RuboCop
       #
       # @example EnforcedStyle: predicate (default)
       #   # bad
-      #
       #   foo == 0
       #   0 > foo
       #   bar.baz > 0
       #
       #   # good
-      #
       #   foo.zero?
       #   foo.negative?
       #   bar.baz.positive?
       #
       # @example EnforcedStyle: comparison
       #   # bad
-      #
       #   foo.zero?
       #   foo.negative?
       #   bar.baz.positive?
       #
       #   # good
+      #   foo == 0
+      #   0 > foo
+      #   bar.baz > 0
+      #
+      # @example IgnoredMethods: [] (default) with EnforcedStyle: predicate
+      #   # bad
+      #   foo == 0
+      #   0 > foo
+      #   bar.baz > 0
       #
+      # @example IgnoredMethods: [==] with EnforcedStyle: predicate
+      #   # good
       #   foo == 0
+      #
+      #   # bad
       #   0 > foo
       #   bar.baz > 0
+      #
       class NumericPredicate < Base
         include ConfigurableEnforcedStyle
         include IgnoredMethods