rubocop 1.36.0 → 1.39.0

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

@@ -50,6 +50,10 @@ module RuboCop
           (block $_ (args $...) (yield $...))
         PATTERN
 
+        def self.autocorrect_incompatible_with
+          [Lint::UnusedMethodArgument]
+        end
+
         def initialize(config = nil, options = nil)
           super
           @def_nodes = Set.new

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

@@ -77,7 +77,7 @@ module RuboCop
       #   # bad
       #   redirect('foo/%{bar_id}')
       #
-      # @example AllowedPatterns: [/redirect/]
+      # @example AllowedPatterns: ['redirect']
       #
       #   # good
       #   redirect('foo/%{bar_id}')

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

@@ -10,6 +10,9 @@ module RuboCop
       # one of `return`, `break`, `next`, `raise`, or `fail` is used
       # in the body of the conditional expression.
       #
+      # NOTE: Autocorrect works in most cases except with if-else statements
+      #   that contain logical operators such as `foo || raise('exception')`
+      #
       # @example
       #   # bad
       #   def test
@@ -90,6 +93,7 @@ module RuboCop
       #   end
       #
       class GuardClause < Base
+        extend AutoCorrector
         include MinBodyLength
         include StatementModifier
 
@@ -101,40 +105,49 @@ module RuboCop
 
           return unless body
 
-          if body.if_type?
-            check_ending_if(body)
-          elsif body.begin_type?
-            final_expression = body.children.last
-            check_ending_if(final_expression) if final_expression&.if_type?
-          end
+          check_ending_body(body)
         end
         alias on_defs on_def
 
         def on_if(node)
           return if accepted_form?(node)
 
-          guard_clause_in_if = node.if_branch&.guard_clause?
-          guard_clause_in_else = node.else_branch&.guard_clause?
-          guard_clause = guard_clause_in_if || guard_clause_in_else
-          return unless guard_clause
+          if (guard_clause = node.if_branch&.guard_clause?)
+            kw = node.loc.keyword.source
+            guard = :if
+          elsif (guard_clause = node.else_branch&.guard_clause?)
+            kw = node.inverse_keyword
+            guard = :else
+          else
+            return
+          end
 
-          kw = if guard_clause_in_if
-                 node.loc.keyword.source
-               else
-                 node.inverse_keyword
-               end
+          guard = nil if and_or_guard_clause?(guard_clause)
 
-          register_offense(node, guard_clause_source(guard_clause), kw)
+          register_offense(node, guard_clause_source(guard_clause), kw, guard)
         end
 
         private
 
+        def check_ending_body(body)
+          return if body.nil?
+
+          if body.if_type?
+            check_ending_if(body)
+          elsif body.begin_type?
+            final_expression = body.children.last
+            check_ending_if(final_expression) if final_expression&.if_type?
+          end
+        end
+
         def check_ending_if(node)
           return if accepted_form?(node, ending: true) || !min_body_length?(node)
           return if allowed_consecutive_conditionals? &&
                     consecutive_conditionals?(node.parent, node)
 
           register_offense(node, 'return', node.inverse_keyword)
+
+          check_ending_body(node.if_branch)
         end
 
         def consecutive_conditionals?(parent, node)
@@ -145,28 +158,56 @@ module RuboCop
           end
         end
 
-        def register_offense(node, scope_exiting_keyword, conditional_keyword)
+        def register_offense(node, scope_exiting_keyword, conditional_keyword, guard = nil)
           condition, = node.node_parts
           example = [scope_exiting_keyword, conditional_keyword, condition.source].join(' ')
           if too_long_for_single_line?(node, example)
             return if trivial?(node)
 
             example = "#{conditional_keyword} #{condition.source}; #{scope_exiting_keyword}; end"
+            replacement = <<~RUBY.chomp
+              #{conditional_keyword} #{condition.source}
+                #{scope_exiting_keyword}
+              end
+            RUBY
           end
 
-          add_offense(node.loc.keyword, message: format(MSG, example: example))
+          add_offense(node.loc.keyword, message: format(MSG, example: example)) do |corrector|
+            next if node.else? && guard.nil?
+
+            autocorrect(corrector, node, condition, replacement || example, guard)
+          end
         end
 
-        def guard_clause_source(guard_clause)
-          parent = guard_clause.parent
+        def autocorrect(corrector, node, condition, replacement, guard)
+          corrector.replace(node.loc.keyword.join(condition.loc.expression), replacement)
+          corrector.remove(node.loc.end)
+          return unless node.else?
+
+          corrector.remove(node.loc.else)
+          corrector.remove(branch_to_remove(node, guard))
+        end
+
+        def branch_to_remove(node, guard)
+          case guard
+          when :if then node.if_branch
+          when :else then node.else_branch
+          end
+        end
 
-          if parent.and_type? || parent.or_type?
+        def guard_clause_source(guard_clause)
+          if and_or_guard_clause?(guard_clause)
             guard_clause.parent.source
           else
             guard_clause.source
           end
         end
 
+        def and_or_guard_clause?(guard_clause)
+          parent = guard_clause.parent
+          parent.and_type? || parent.or_type?
+        end
+
         def too_long_for_single_line?(node, example)
           max = max_line_length
           max && node.source_range.column + example.length > max

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

@@ -34,6 +34,7 @@ module RuboCop
         extend AutoCorrector
 
         def on_hash(node)
+          return if node.children.first&.kwsplat_type?
           return unless (array = containing_array(node))
           return unless last_array_item?(array, node) && explicit_array?(array)
 

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

@@ -38,28 +38,50 @@ module RuboCop
           ({block numblock} $(send (send _ ${:keys :values}) :each) ...)
         PATTERN
 
+        # @!method kv_each_with_block_pass(node)
+        def_node_matcher :kv_each_with_block_pass, <<~PATTERN
+          (send $(send _ ${:keys :values}) :each (block_pass (sym _)))
+        PATTERN
+
         def on_block(node)
-          register_kv_offense(node)
+          kv_each(node) do |target, method|
+            register_kv_offense(target, method)
+          end
         end
 
         alias on_numblock on_block
 
+        def on_block_pass(node)
+          kv_each_with_block_pass(node.parent) do |target, method|
+            register_kv_with_block_pass_offense(node, target, method)
+          end
+        end
+
         private
 
-        def register_kv_offense(node)
-          kv_each(node) do |target, method|
-            parent_receiver = target.receiver.receiver
-            return unless parent_receiver
-            return if allowed_receiver?(parent_receiver)
+        def register_kv_offense(target, method)
+          return unless (parent_receiver = target.receiver.receiver)
+          return if allowed_receiver?(parent_receiver)
+
+          add_offense(kv_range(target), message: format_message(method)) do |corrector|
+            correct_key_value_each(target, corrector)
+          end
+        end
 
-            msg = format(message, prefer: "each_#{method[0..-2]}", current: "#{method}.each")
+        def register_kv_with_block_pass_offense(node, target, method)
+          return unless (parent_receiver = node.parent.receiver.receiver)
+          return if allowed_receiver?(parent_receiver)
 
-            add_offense(kv_range(target), message: msg) do |corrector|
-              correct_key_value_each(target, corrector)
-            end
+          range = target.loc.selector.with(end_pos: node.parent.loc.selector.end_pos)
+          add_offense(range, message: format_message(method)) do |corrector|
+            corrector.replace(range, "each_#{method[0..-2]}")
           end
         end
 
+        def format_message(method_name)
+          format(MSG, prefer: "each_#{method_name[0..-2]}", current: "#{method_name}.each")
+        end
+
         def check_argument(variable)
           return unless variable.block_argument?
 

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

@@ -13,6 +13,10 @@ module RuboCop
       # when used `==`.
       # And do not check `Hash#delete_if` and `Hash#keep_if` to change receiver object.
       #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   is a `Hash` or responds to the replacement method.
+      #
       # @example
       #
       #   # bad

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

@@ -28,7 +28,7 @@ module RuboCop
       # * always - forces use of the 3.1 syntax (e.g. {foo:})
       # * never - forces use of explicit hash literal value
       # * either - accepts both shorthand and explicit use of hash literal value
-      # * consistent - like "always", but will avoid mixing styles in a single hash
+      # * consistent - like "either", but will avoid mixing styles in a single hash
       #
       # @example EnforcedStyle: ruby19 (default)
       #   # bad

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

@@ -5,10 +5,27 @@ module RuboCop
     module Style
       # 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.
+      # The conditions to be checked are comparison methods, predicate methods, and
+      # double negation (!!).
       # `nonzero?` method is allowed by default.
       # These are customizable with `AllowedMethods` option.
       #
+      # This cop targets only `if`s with a single `elsif` or `else` branch. The following
+      # code will be allowed, because it has two `elsif` branches:
+      #
+      # [source,ruby]
+      # ----
+      # if foo
+      #   true
+      # elsif bar > baz
+      #   true
+      # elsif qux > quux # Single `elsif` is warned, but two or more `elsif`s are not.
+      #   true
+      # else
+      #   false
+      # end
+      # ----
+      #
       # @safety
       #   Autocorrection is unsafe because there is no guarantee that all predicate methods
       #   will return a boolean value. Those methods can be allowed with `AllowedMethods` config.
@@ -57,7 +74,7 @@ module RuboCop
         def_node_matcher :double_negative?, '(send (send _ :!) :!)'
 
         def on_if(node)
-          return unless if_with_boolean_literal_branches?(node)
+          return if !if_with_boolean_literal_branches?(node) || multiple_elsif?(node)
 
           condition = node.condition
           range, keyword = offense_range_with_keyword(node, condition)
@@ -76,6 +93,12 @@ module RuboCop
 
         private
 
+        def multiple_elsif?(node)
+          return false unless (parent = node.parent)
+
+          parent.if_type? && parent.elsif?
+        end
+
         def offense_range_with_keyword(node, condition)
           if node.ternary?
             range = condition.source_range.end.join(node.source_range.end)

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

@@ -20,8 +20,8 @@ module RuboCop
             return if require_parentheses_for_hash_value_omission?(node)
             return if syntax_like_method_call?(node)
             return if super_call_without_arguments?(node)
-            return if allowed_camel_case_method_call?(node)
             return if legitimate_call_with_parentheses?(node)
+            return if allowed_camel_case_method_call?(node)
             return if allowed_string_interpolation_method_call?(node)
 
             add_offense(offense_range(node), message: OMIT_MSG) do |corrector|
@@ -97,7 +97,8 @@ module RuboCop
               call_in_optional_arguments?(node) ||
               call_in_single_line_inheritance?(node) ||
               allowed_multiline_call_with_parentheses?(node) ||
-              allowed_chained_call_with_parentheses?(node)
+              allowed_chained_call_with_parentheses?(node) ||
+              assignment_in_condition?(node)
           end
 
           def call_in_literals?(node)
@@ -202,6 +203,16 @@ module RuboCop
           def inside_string_interpolation?(node)
             node.ancestors.drop_while { |a| !a.begin_type? }.any?(&:dstr_type?)
           end
+
+          def assignment_in_condition?(node)
+            parent = node.parent
+            return false unless parent
+
+            grandparent = parent.parent
+            return false unless grandparent
+
+            parent.assignment? && (grandparent.conditional? || grandparent.when_type?)
+          end
         end
         # rubocop:enable Metrics/ModuleLength, Metrics/CyclomaticComplexity
       end

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

@@ -3,13 +3,15 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for use of `extend self` or `module_function` in a
-      # module.
+      # Checks for use of `extend self` or `module_function` in a module.
       #
-      # Supported styles are: module_function, extend_self, forbidden. `forbidden`
-      # style prohibits the usage of both styles.
+      # Supported styles are: `module_function` (default), `extend_self` and `forbidden`.
       #
-      # NOTE: the cop won't be activated when the module contains any private methods.
+      # A couple of things to keep in mind:
+      #
+      # - `forbidden` style prohibits the usage of both styles
+      # - in default mode (`module_function`), the cop won't be activated when the module
+      #   contains any private methods
       #
       # @safety
       #   Autocorrection is unsafe (and is disabled by default) because `extend self`
@@ -28,7 +30,6 @@ module RuboCop
       #     # ...
       #   end
       #
-      # @example EnforcedStyle: module_function (default)
       #   # good
       #   module Test
       #     extend self
@@ -37,6 +38,13 @@ module RuboCop
       #     # ...
       #   end
       #
+      #   # good
+      #   module Test
+      #     class << self
+      #       # ...
+      #     end
+      #   end
+      #
       # @example EnforcedStyle: extend_self
       #   # bad
       #   module Test
@@ -50,6 +58,13 @@ module RuboCop
       #     # ...
       #   end
       #
+      #   # good
+      #   module Test
+      #     class << self
+      #       # ...
+      #     end
+      #   end
+      #
       # @example EnforcedStyle: forbidden
       #   # bad
       #   module Test
@@ -70,6 +85,13 @@ module RuboCop
       #     private
       #     # ...
       #   end
+      #
+      #   # good
+      #   module Test
+      #     class << self
+      #       # ...
+      #     end
+      #   end
       class ModuleFunction < Base
         include ConfigurableEnforcedStyle
         extend AutoCorrector

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

@@ -49,7 +49,8 @@ module RuboCop
         def on_if(node)
           return unless if_else?(node)
 
-          condition = node.condition
+          condition = unwrap_begin_nodes(node.condition)
+
           return if double_negation?(condition) || !negated_condition?(condition)
 
           type = node.ternary? ? 'ternary' : 'if-else'
@@ -71,6 +72,11 @@ module RuboCop
           !node.elsif? && else_branch && (!else_branch.if_type? || !else_branch.elsif?)
         end
 
+        def unwrap_begin_nodes(node)
+          node = node.children.first while node.begin_type? || node.kwbegin_type?
+          node
+        end
+
         def negated_condition?(node)
           node.send_type? &&
             (node.negation_method? || NEGATED_EQUALITY_METHODS.include?(node.method_name))

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

@@ -66,7 +66,7 @@ module RuboCop
       #   foo.negative?
       #   bar.baz.positive?
       #
-      # @example AllowedPatterns: [/zero/] with EnforcedStyle: predicate
+      # @example AllowedPatterns: ['zero'] with EnforcedStyle: predicate
       #   # good
       #   # bad
       #   foo.zero?

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

@@ -25,6 +25,9 @@ module RuboCop
       class ObjectThen < Base
         include ConfigurableEnforcedStyle
         extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.6
 
         MSG = 'Prefer `%<prefer>s` over `%<current>s`.'
 

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

@@ -0,0 +1,53 @@
+# 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?
+
+          _lhs, _op, rhs = *node
+          return if rhs.nil? || rhs.children.first
+
+          add_offense(dot) do |corrector|
+            wrap_in_parentheses_if_chained(corrector, node)
+            corrector.replace(dot, ' ')
+          end
+        end
+
+        private
+
+        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/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_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

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

@@ -145,11 +145,14 @@ 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)
+          node.send_type? && !node.method?(:[]) && node.arguments.one?
+        end
+
         def same_method?(if_branch, else_branch)
           if_branch.method?(else_branch.method_name) && if_branch.receiver == else_branch.receiver
         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_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)