rubocop 1.37.1 → 1.39.0

data/lib/rubocop/cop/registry.rb

@@ -149,16 +149,22 @@ module RuboCop
         @registry.size
       end
 
-      def enabled(config, only = [], only_safe: false)
-        select { |cop| only.include?(cop.cop_name) || enabled?(cop, config, only_safe) }
+      def enabled(config)
+        select { |cop| enabled?(cop, config) }
       end
 
-      def enabled?(cop, config, only_safe)
+      def disabled(config)
+        reject { |cop| enabled?(cop, config) }
+      end
+
+      def enabled?(cop, config)
+        return true if options.fetch(:only, []).include?(cop.cop_name)
+
         cfg = config.for_cop(cop)
 
         cop_enabled = cfg.fetch('Enabled') == true || enabled_pending_cop?(cfg, config)
 
-        if only_safe
+        if options.fetch(:safe, false)
           cop_enabled && cfg.fetch('Safe', true)
         else
           cop_enabled

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

@@ -202,31 +202,7 @@ module RuboCop
         end
 
         def remove_node(corrector, node)
-          corrector.remove(
-            range_by_whole_lines(
-              range_with_comments(node),
-              include_final_newline: true
-            )
-          )
-        end
-
-        def range_with_comments(node)
-          ranges = [
-            node,
-            *processed_source.ast_with_comments[node]
-          ].map do |element|
-            element.location.expression
-          end
-          ranges.reduce do |result, range|
-            add_range(result, range)
-          end
-        end
-
-        def add_range(range1, range2)
-          range1.with(
-            begin_pos: [range1.begin_pos, range2.begin_pos].min,
-            end_pos: [range1.end_pos, range2.end_pos].max
-          )
+          corrector.remove(range_with_comments_and_lines(node))
         end
       end
     end

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

@@ -425,7 +425,7 @@ module RuboCop
           if node.parent.begin_type?
             return_value_used?(node.parent)
           else
-            node.parent.assignment? || node.parent.send_type?
+            node.parent.assignment? || node.parent.call_type?
           end
         end
 

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

@@ -97,12 +97,14 @@ module RuboCop
           if node.children.first.method?(:name)
             return class_node.receiver.source if class_node.receiver
 
-            value = class_node.source.delete('"').delete("'")
-            value.prepend('::') if class_node.each_ancestor(:class, :module).any?
-            value
-          else
-            class_node.source
+            if class_node.str_type?
+              value = class_node.source.delete('"').delete("'")
+              value.prepend('::') if class_node.each_ancestor(:class, :module).any?
+              return value
+            end
           end
+
+          class_node.source
         end
 
         def offense_range(receiver_node, node)

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

@@ -8,7 +8,9 @@ module RuboCop
       #
       # @safety
       #   It is unsafe by default because false positives may occur in the
-      #   `nil` check of block arguments to the receiver object.
+      #   `nil` check of block arguments to the receiver object. Additionally,
+      #    we can't know the type of the receiver object for sure, which may
+      #    result in false positives as well.
       #
       #   For example, `[[1, 2], [3, nil]].reject { |first, second| second.nil? }`
       #   and `[[1, 2], [3, nil]].compact` are not compatible. This will work fine
@@ -110,7 +112,7 @@ module RuboCop
         end
 
         def range(begin_pos_node, end_pos_node)
-          range_between(begin_pos_node.loc.selector.begin_pos, end_pos_node.loc.end.end_pos)
+          range_between(begin_pos_node.loc.selector.begin_pos, end_pos_node.loc.expression.end_pos)
         end
       end
     end

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/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/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/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

@@ -31,9 +31,22 @@ module RuboCop
           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

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_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_regexp_escape.rb

@@ -44,7 +44,7 @@ module RuboCop
 
         def on_regexp(node)
           each_escape(node) do |char, index, within_character_class|
-            next if allowed_escape?(node, char, within_character_class)
+            next if allowed_escape?(node, char, index, within_character_class)
 
             location = escape_range_at_index(node, index)
 
@@ -56,7 +56,7 @@ module RuboCop
 
         private
 
-        def allowed_escape?(node, char, within_character_class)
+        def allowed_escape?(node, char, index, within_character_class)
           # Strictly speaking a few single-letter metachars are currently
           # unnecessary to "escape", e.g. i, E, F, but enumerating them is
           # rather difficult, and their behavior could change over time with
@@ -65,12 +65,21 @@ module RuboCop
           return true if ALLOWED_ALWAYS_ESCAPES.include?(char) || delimiter?(node, char)
 
           if within_character_class
-            ALLOWED_WITHIN_CHAR_CLASS_METACHAR_ESCAPES.include?(char)
+            ALLOWED_WITHIN_CHAR_CLASS_METACHAR_ESCAPES.include?(char) &&
+              !char_class_begins_or_ends_with_escaped_hyphen?(node, index)
           else
             ALLOWED_OUTSIDE_CHAR_CLASS_METACHAR_ESCAPES.include?(char)
           end
         end
 
+        def char_class_begins_or_ends_with_escaped_hyphen?(node, index)
+          # The hyphen character is allowed to be escaped within a character class
+          # but it's not necessry to escape hyphen if it's the first or last character
+          # within the character class. This method checks if that's the case.
+          # e.g. "[0-9\\-]" or "[\\-0-9]" would return true
+          node.source[index] == '[' || node.source[index + 3] == ']'
+        end
+
         def delimiter?(node, char)
           delimiters = [node.loc.begin.source[-1], node.loc.end.source[0]]
 

data/lib/rubocop/cop/team.rb

@@ -40,10 +40,9 @@ module RuboCop
 
       # @return [Array<Cop::Cop>]
       def self.mobilize_cops(cop_classes, config, options = {})
-        cop_classes = Registry.new(cop_classes.to_a) unless cop_classes.is_a?(Registry)
-        only = options.fetch(:only, [])
-        safe = options.fetch(:safe, false)
-        cop_classes.enabled(config, only, only_safe: safe).map do |cop_class|
+        cop_classes = Registry.new(cop_classes.to_a, options) unless cop_classes.is_a?(Registry)
+
+        cop_classes.enabled(config).map do |cop_class|
           cop_class.new(config, options)
         end
       end