rubocop 1.50.2 → 1.54.1

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

@@ -4,12 +4,12 @@ module RuboCop
   module Cop
     module Style
       # Ensures that eval methods (`eval`, `instance_eval`, `class_eval`
-      # and `module_eval`) are given filename and line number values (`__FILE__`
-      # and `__LINE__`). This data is used to ensure that any errors raised
+      # and `module_eval`) are given filename and line number values (`\_\_FILE\_\_`
+      # and `\_\_LINE\_\_`). This data is used to ensure that any errors raised
       # within the evaluated code will be given the correct identification
       # in a backtrace.
       #
-      # The cop also checks that the line number given relative to `__LINE__` is
+      # The cop also checks that the line number given relative to `\_\_LINE\_\_` is
       # correct.
       #
       # This cop will autocorrect incorrect or missing filename and line number
@@ -57,7 +57,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Pass `__FILE__` and `__LINE__` to `%<method_name>s`.'
-        MSG_EVAL = 'Pass a binding, `__FILE__` and `__LINE__` to `eval`.'
+        MSG_EVAL = 'Pass a binding, `__FILE__`, and `__LINE__` to `eval`.'
         MSG_INCORRECT_FILE = 'Incorrect file for `%<method_name>s`; ' \
                              'use `%<expected>s` instead of `%<actual>s`.'
         MSG_INCORRECT_LINE = 'Incorrect line number for `%<method_name>s`; ' \
@@ -210,7 +210,7 @@ module RuboCop
         def add_offense_for_missing_line(node, code)
           register_offense(node) do |corrector|
             line_str = missing_line(node, code)
-            corrector.insert_after(node.source_range.end, ", #{line_str}")
+            corrector.insert_after(node.last_argument.source_range.end, ", #{line_str}")
           end
         end
 

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for exact regexp match inside Regexp literals.
+      #
+      # @example
+      #
+      #   # bad
+      #   string =~ /\Astring\z/
+      #   string === /\Astring\z/
+      #   string.match(/\Astring\z/)
+      #   string.match?(/\Astring\z/)
+      #
+      #   # good
+      #   string == 'string'
+      #
+      #   # bad
+      #   string !~ /\Astring\z/
+      #
+      #   # good
+      #   string != 'string'
+      #
+      class ExactRegexpMatch < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<prefer>s`.'
+        RESTRICT_ON_SEND = %i[=~ === !~ match match?].freeze
+
+        # @!method exact_regexp_match(node)
+        def_node_matcher :exact_regexp_match, <<~PATTERN
+          (send
+            _ {:=~ :=== :!~ :match :match?}
+            (regexp
+              (str $_)
+              (regopt)))
+        PATTERN
+
+        def on_send(node)
+          return unless (regexp = exact_regexp_match(node))
+
+          parsed_regexp = Regexp::Parser.parse(regexp)
+          return unless exact_match_pattern?(parsed_regexp)
+
+          prefer = "#{node.receiver.source} #{new_method(node)} '#{parsed_regexp[1].text}'"
+
+          add_offense(node, message: format(MSG, prefer: prefer)) do |corrector|
+            corrector.replace(node, prefer)
+          end
+        end
+
+        private
+
+        def exact_match_pattern?(parsed_regexp)
+          tokens = parsed_regexp.map(&:token)
+          return false unless tokens[0] == :bos && tokens[1] == :literal && tokens[2] == :eos
+
+          !parsed_regexp[1].quantifier
+        end
+
+        def new_method(node)
+          node.method?(:!~) ? '!=' : '=='
+        end
+      end
+    end
+  end
+end

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

@@ -63,7 +63,7 @@ module RuboCop
 
         # @!method block_read?(node)
         def_node_matcher :block_read?, <<~PATTERN
-          (block _ (args (arg $_)) (send (lvar $_) :read))
+          (block _ (args (arg _name)) (send (lvar _name) :read))
         PATTERN
 
         def on_send(node)
@@ -100,7 +100,7 @@ module RuboCop
         def file_open_read?(node)
           return true if send_read?(node)
 
-          block_read?(node) { |block_arg, read_lvar| block_arg == read_lvar }
+          block_read?(node)
         end
 
         def read_method(mode)

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

@@ -187,6 +187,8 @@ module RuboCop
           if_branch = node.if_branch
           else_branch = node.else_branch
 
+          corrector.replace(node.loc.begin, "\n") if node.loc.begin&.is?('then')
+
           if if_branch&.send_type? && heredoc?(if_branch.last_argument)
             autocorrect_heredoc_argument(corrector, node, if_branch, else_branch, guard)
           elsif else_branch&.send_type? && heredoc?(else_branch.last_argument)

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

@@ -28,6 +28,7 @@ module RuboCop
       #   execute(sql).keys.each { |v| p v }
       #   execute(sql).values.each { |v| p v }
       class HashEachMethods < Base
+        include AllowedReceivers
         include Lint::UnusedArgument
         extend AutoCorrector
 
@@ -116,28 +117,6 @@ module RuboCop
         def kv_range(outer_node)
           outer_node.receiver.loc.selector.join(outer_node.loc.selector)
         end
-
-        def allowed_receiver?(receiver)
-          receiver_name = receiver_name(receiver)
-
-          allowed_receivers.include?(receiver_name)
-        end
-
-        def receiver_name(receiver)
-          if receiver.send_type?
-            if receiver.receiver
-              "#{receiver_name(receiver.receiver)}.#{receiver.method_name}"
-            else
-              receiver.method_name.to_s
-            end
-          else
-            receiver.source
-          end
-        end
-
-        def allowed_receivers
-          cop_config.fetch('AllowedReceivers', [])
-        end
       end
     end
   end

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

@@ -45,13 +45,13 @@ module RuboCop
           (block
             (send _ _)
             (args
-              (arg _)
+              $(arg _)
               (arg _))
             {
-              (send
+              $(send
                 _ {:== :!= :eql? :include?} _)
               (send
-                (send
+                $(send
                   _ {:== :!= :eql? :include?} _) :!)
               })
         PATTERN
@@ -61,13 +61,13 @@ module RuboCop
           (block
             (send _ _)
             (args
-              (arg _)
+              $(arg _)
               (arg _))
             {
-              (send
+              $(send
                 _ {:== :!= :eql? :in? :include? :exclude?} _)
               (send
-                (send
+                $(send
                   _ {:== :!= :eql? :in? :include? :exclude?} _) :!)
               })
         PATTERN
@@ -89,13 +89,24 @@ module RuboCop
 
         private
 
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def bad_method?(block)
           if active_support_extensions_enabled?
-            bad_method_with_active_support?(block)
+            bad_method_with_active_support?(block) do |key_arg, send_node|
+              if send_node.method?(:in?) && send_node.receiver&.source != key_arg.source
+                return false
+              end
+              return true if !send_node.method?(:include?) && !send_node.method?(:exclude?)
+
+              send_node.first_argument&.source == key_arg.source
+            end
           else
-            bad_method_with_poro?(block)
+            bad_method_with_poro?(block) do |key_arg, send_node|
+              !send_node.method?(:include?) || send_node.first_argument&.source == key_arg.source
+            end
           end
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def semantically_except_method?(send, block)
           body = block.body

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

@@ -3,8 +3,8 @@
 module RuboCop
   module Cop
     module Style
-      # Looks for uses of `_.each_with_object({}) {...}`,
-      # `_.map {...}.to_h`, and `Hash[_.map {...}]` that are actually just
+      # Looks for uses of `\_.each_with_object({}) {...}`,
+      # `\_.map {...}.to_h`, and `Hash[\_.map {...}]` that are actually just
       # transforming the keys of a hash, and tries to use a simpler & faster
       # call to `transform_keys` instead.
       # It should only be enabled on Ruby version 2.5 or newer.

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

@@ -3,8 +3,8 @@
 module RuboCop
   module Cop
     module Style
-      # Looks for uses of `_.each_with_object({}) {...}`,
-      # `_.map {...}.to_h`, and `Hash[_.map {...}]` that are actually just
+      # Looks for uses of `\_.each_with_object({}) {...}`,
+      # `\_.map {...}.to_h`, and `Hash[\_.map {...}]` that are actually just
       # transforming the values of a hash, and tries to use a simpler & faster
       # call to `transform_values` instead.
       #

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

@@ -158,13 +158,16 @@ module RuboCop
           return false unless expressions.size >= 1 && unique_expressions.one?
 
           unique_expression = unique_expressions.first
-          return true unless unique_expression.assignment?
+          return true unless unique_expression&.assignment?
 
           lhs = unique_expression.child_nodes.first
           node.condition.child_nodes.none? { |n| n.source == lhs.source if n.variable? }
         end
 
-        def check_expressions(node, expressions, insert_position) # rubocop:disable Metrics/MethodLength
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        def check_expressions(node, expressions, insert_position)
+          return if expressions.any?(&:nil?)
+
           inserted_expression = false
 
           expressions.each do |expression|
@@ -184,6 +187,7 @@ module RuboCop
             end
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
         def last_child_of_parent?(node)
           return true unless (parent = node.parent)

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

@@ -59,11 +59,13 @@ module RuboCop
       #   end
       #
       class IfInsideElse < Base
+        include IgnoredNode
         include RangeHelp
         extend AutoCorrector
 
         MSG = 'Convert `if` nested inside `else` to `elsif`.'
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def on_if(node)
           return if node.ternary? || node.unless?
 
@@ -73,9 +75,13 @@ module RuboCop
           return if allow_if_modifier_in_else_branch?(else_branch)
 
           add_offense(else_branch.loc.keyword) do |corrector|
+            next if part_of_ignored_node?(node)
+
             autocorrect(corrector, else_branch)
+            ignore_node(node)
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         private
 

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

@@ -84,7 +84,10 @@ module RuboCop
           return unless (msg = message(node))
 
           add_offense(node.loc.keyword, message: format(msg, keyword: node.keyword)) do |corrector|
+            next if part_of_ignored_node?(node)
+
             autocorrect(corrector, node)
+            ignore_node(node)
           end
         end
 

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

@@ -47,7 +47,7 @@ module RuboCop
         def correct_elsif(node)
           <<~RUBY.chop
             if #{node.condition.source}
-              #{node.if_branch.source}
+              #{node.if_branch&.source}
             #{build_else_branch(node.else_branch).chop}
             end
           RUBY
@@ -56,7 +56,7 @@ module RuboCop
         def build_else_branch(second_condition)
           result = <<~RUBY
             elsif #{second_condition.condition.source}
-              #{second_condition.if_branch.source}
+              #{second_condition.if_branch&.source}
           RUBY
 
           if second_condition.else_branch

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

@@ -10,12 +10,16 @@ module RuboCop
       # Methods that can be inverted should be defined in `InverseMethods`. Note that
       # the relationship of inverse methods needs to be defined in both directions.
       # For example,
-      #   InverseMethods:
-      #     :!=: :==
-      #     :even?: :odd?
-      #     :odd?: :even?
       #
-      #  will suggest both `even?` and `odd?` to be inverted, but only `!=` (and not `==`).
+      # [source,yaml]
+      # ----
+      # InverseMethods:
+      #   :!=: :==
+      #   :even?: :odd?
+      #   :odd?: :even?
+      # ----
+      #
+      # will suggest both `even?` and `odd?` to be inverted, but only `!=` (and not `==`).
       #
       # @safety
       #   This cop is unsafe because it cannot be guaranteed that the method
@@ -68,7 +72,7 @@ module RuboCop
           when :begin
             invertible?(node.children.first)
           when :send
-            return if inheritance_check?(node)
+            return false if inheritance_check?(node)
 
             node.method?(:!) || inverse_methods.key?(node.method_name)
           when :or, :and

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

@@ -69,10 +69,10 @@ module RuboCop
           return unless offending_selector?(node, selector)
 
           add_offense(node.send_node.source_range, message: message(node, selector)) do |corrector|
-            if node.send_node.source == 'lambda'
-              autocorrect_method_to_literal(corrector, node)
-            else
+            if node.send_node.lambda_literal?
               LambdaLiteralToMethodCorrector.new(node).call(corrector)
+            else
+              autocorrect_method_to_literal(corrector, node)
             end
           end
         end

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

@@ -98,7 +98,7 @@ module RuboCop
 
           def call_in_literals?(node)
             parent = node.parent&.block_type? ? node.parent.parent : node.parent
-            return unless parent
+            return false unless parent
 
             parent.pair_type? ||
               parent.array_type? ||
@@ -109,7 +109,7 @@ module RuboCop
 
           def call_in_logical_operators?(node)
             parent = node.parent&.block_type? ? node.parent.parent : node.parent
-            return unless parent
+            return false unless parent
 
             logical_operator?(parent) ||
               (parent.send_type? &&
@@ -135,8 +135,7 @@ module RuboCop
           end
 
           def call_with_braced_block?(node)
-            (node.send_type? || node.super_type?) &&
-              ((node.parent&.block_type? || node.parent&.numblock_type?) && node.parent&.braces?)
+            (node.send_type? || node.super_type?) && node.block_node&.braces?
           end
 
           def call_as_argument_or_chain?(node)

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

@@ -40,6 +40,15 @@ module RuboCop
       #
       #   # good
       #   foo if [b.lightweight, b.heavyweight].include?(a)
+      #
+      # @example ComparisonsThreshold: 2 (default)
+      #   # bad
+      #   foo if a == 'a' || a == 'b'
+      #
+      # @example ComparisonsThreshold: 3
+      #   # good
+      #   foo if a == 'a' || a == 'b'
+      #
       class MultipleComparison < Base
         extend AutoCorrector
 
@@ -58,6 +67,7 @@ module RuboCop
           return unless node == root_of_or_node
           return unless nested_variable_comparison?(root_of_or_node)
           return if @allowed_method_comparison
+          return if @compared_elements.size < comparisons_threshold
 
           add_offense(node) do |corrector|
             elements = @compared_elements.join(', ')
@@ -151,6 +161,10 @@ module RuboCop
         def allow_method_comparison?
           cop_config.fetch('AllowMethodComparison', true)
         end
+
+        def comparisons_threshold
+          cop_config.fetch('ComparisonsThreshold', 2)
+        end
       end
     end
   end

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

@@ -121,7 +121,7 @@ module RuboCop
 
         def allowed_patterns
           # Convert the patterns to be anchored
-          super.map { |regexp| Regexp.new(/\A#{regexp}\z/) }
+          super.map { |regexp| /\A#{regexp}\z/ }
         end
       end
     end

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

@@ -93,7 +93,7 @@ module RuboCop
         def contains_delimiter?(node, delimiters)
           delimiters_regexp = Regexp.union(delimiters)
 
-          node.children.map { |n| string_source(n) }.compact.any?(delimiters_regexp)
+          node.children.filter_map { |n| string_source(n) }.any?(delimiters_regexp)
         end
 
         def string_source(node)

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

@@ -61,7 +61,7 @@ module RuboCop
           if style == :verbose
             "has_#{method_name}"
           else
-            method_name.to_s.sub(/has_/, '')
+            method_name.to_s.delete_prefix('has_')
           end
         end
 

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for the instantiation of array using redundant `Array` constructor.
+      # Autocorrect replaces to array literal which is the simplest and fastest.
+      #
+      # @example
+      #
+      #   # bad
+      #   Array.new([])
+      #   Array[]
+      #   Array([])
+      #   Array.new(['foo', 'foo', 'foo'])
+      #   Array['foo', 'foo', 'foo']
+      #   Array(['foo', 'foo', 'foo'])
+      #
+      #   # good
+      #   []
+      #   ['foo', 'foo', 'foo']
+      #   Array.new(3, 'foo')
+      #   Array.new(3) { 'foo' }
+      #
+      class RedundantArrayConstructor < Base
+        extend AutoCorrector
+
+        MSG = 'Remove the redundant `Array` constructor.'
+
+        RESTRICT_ON_SEND = %i[new [] Array].freeze
+
+        # @!method redundant_array_constructor(node)
+        def_node_matcher :redundant_array_constructor, <<~PATTERN
+          {
+            (send
+              (const {nil? cbase} :Array) :new
+              $(array ...))
+            (send
+              (const {nil? cbase} :Array) :[]
+              $...)
+            (send
+              nil? :Array
+              $(array ...))
+          }
+        PATTERN
+
+        def on_send(node)
+          return unless (array_literal = redundant_array_constructor(node))
+
+          receiver = node.receiver
+          selector = node.loc.selector
+
+          if node.method?(:new)
+            range = receiver.source_range.join(selector)
+            replacement = array_literal
+          elsif node.method?(:Array)
+            range = selector
+            replacement = array_literal
+          else
+            range = receiver
+            replacement = selector.begin.join(node.source_range.end)
+          end
+
+          register_offense(range, node, replacement)
+        end
+
+        private
+
+        def register_offense(range, node, replacement)
+          add_offense(range) do |corrector|
+            corrector.replace(node, replacement.source)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -146,7 +146,7 @@ module RuboCop
         end
 
         def use_modifier_form_after_multiline_begin_block?(node)
-          return unless (parent = node.parent)
+          return false unless (parent = node.parent)
 
           node.multiline? && parent.if_type? && parent.modifier_form?
         end

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

@@ -63,7 +63,7 @@ module RuboCop
         RUBY
 
         def offense?(node)
-          return if node.modifier_form?
+          return false if node.modifier_form?
 
           redundant_condition?(node) || redundant_condition_inverted?(node)
         end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for uses a redundant current directory in path.
+      #
+      # @example
+      #
+      #   # bad
+      #   require_relative './path/to/feature'
+      #
+      #   # good
+      #   require_relative 'path/to/feature'
+      #
+      class RedundantCurrentDirectoryInPath < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Remove the redundant current directory path.'
+        CURRENT_DIRECTORY_PATH = './'
+
+        def on_send(node)
+          return unless node.method?(:require_relative)
+          return unless node.first_argument.str_content&.start_with?(CURRENT_DIRECTORY_PATH)
+          return unless (index = node.first_argument.source.index(CURRENT_DIRECTORY_PATH))
+
+          begin_pos = node.first_argument.source_range.begin.begin_pos + index
+          range = range_between(begin_pos, begin_pos + 2)
+
+          add_offense(range) do |corrector|
+            corrector.remove(range)
+          end
+        end
+      end
+    end
+  end
+end