rubocop 1.46.0 → 1.52.1

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

@@ -131,7 +131,7 @@ module RuboCop
         end
 
         def whole_line_expression(node)
-          range_by_whole_lines(node.loc.expression, include_final_newline: true)
+          range_by_whole_lines(node.source_range, include_final_newline: true)
         end
       end
     end

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

@@ -37,7 +37,7 @@ module RuboCop
 
         def autocorrect(corrector, node)
           block = node.parent
-          range = range_between(block.loc.begin.end_pos, node.loc.expression.end_pos)
+          range = range_between(block.loc.begin.end_pos, node.source_range.end_pos)
 
           corrector.remove(range)
         end

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

@@ -34,7 +34,7 @@ module RuboCop
 
         def autocorrect(corrector, node)
           send_node = node.parent.send_node
-          range = range_between(send_node.loc.expression.end_pos, node.loc.expression.end_pos)
+          range = range_between(send_node.source_range.end_pos, node.source_range.end_pos)
 
           corrector.remove(range)
         end

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`; ' \
@@ -146,7 +146,7 @@ module RuboCop
                            actual: line_node.source,
                            expected: expected)
 
-          add_offense(line_node.loc.expression, message: message) do |corrector|
+          add_offense(line_node.source_range, message: message) do |corrector|
             corrector.replace(line_node, expected)
           end
         end
@@ -175,14 +175,14 @@ module RuboCop
         end
 
         def line_difference(line_node, code)
-          string_first_line(code) - line_node.loc.expression.first_line
+          string_first_line(code) - line_node.source_range.first_line
         end
 
         def string_first_line(str_node)
           if str_node.heredoc?
             str_node.loc.heredoc_body.first_line
           else
-            str_node.loc.expression.first_line
+            str_node.source_range.first_line
           end
         end
 
@@ -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.loc.expression.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/explicit_block_argument.rb

@@ -145,7 +145,7 @@ module RuboCop
         end
 
         def block_body_range(block_node, send_node)
-          range_between(send_node.loc.expression.end_pos, block_node.loc.end.end_pos)
+          range_between(send_node.source_range.end_pos, block_node.loc.end.end_pos)
         end
       end
     end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Prefer to use `File.empty?('path/to/file')` when checking if a file is empty.
+      #
+      # @safety
+      #   This cop is unsafe, because `File.size`, `File.read`, and `File.binread`
+      #   raise `ENOENT` exception when there is no file corresponding to the path,
+      #   while `File.empty?` does not raise an exception.
+      #
+      # @example
+      #   # bad
+      #   File.zero?('path/to/file')
+      #   File.size('path/to/file') == 0
+      #   File.size('path/to/file') >= 0
+      #   File.size('path/to/file').zero?
+      #   File.read('path/to/file').empty?
+      #   File.binread('path/to/file') == ''
+      #   FileTest.zero?('path/to/file')
+      #
+      #   # good
+      #   File.empty?('path/to/file')
+      #   FileTest.empty?('path/to/file')
+      #
+      class FileEmpty < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        MSG = 'Use `%<file_class>s.empty?(%<arg>s)` instead.'
+        RESTRICT_ON_SEND = %i[>= != == zero? empty?].freeze
+
+        minimum_target_ruby_version 2.4
+
+        # @!method offensive?(node)
+        def_node_matcher :offensive?, <<~PATTERN
+          {
+            (send $(const {nil? cbase} {:File :FileTest}) :zero? $_)
+            (send (send $(const {nil? cbase} {:File :FileTest}) :size $_) {:== :>=} (int 0))
+            (send (send (send $(const {nil? cbase} {:File :FileTest}) :size $_) :!) {:== :>=} (int 0))
+            (send (send $(const {nil? cbase} {:File :FileTest}) :size $_) :zero?)
+            (send (send $(const {nil? cbase} {:File :FileTest}) {:read :binread} $_) {:!= :==} (str empty?))
+            (send (send (send $(const {nil? cbase} {:File :FileTest}) {:read :binread} $_) :!) {:!= :==} (str empty?))
+            (send (send $(const {nil? cbase} {:File :FileTest}) {:read :binread} $_) :empty?)
+          }
+        PATTERN
+
+        def on_send(node)
+          offensive?(node) do |const_node, arg_node|
+            add_offense(node,
+                        message: format(MSG, file_class: const_node.source,
+                                             arg: arg_node.source)) do |corrector|
+              corrector.replace(node,
+                                "#{bang(node)}#{const_node.source}.empty?(#{arg_node.source})")
+            end
+          end
+        end
+
+        private
+
+        def bang(node)
+          if (node.method?(:==) && node.child_nodes.first.method?(:!)) ||
+             (%i[>= !=].include?(node.method_name) && !node.child_nodes.first.method?(:!))
+            '!'
+          end
+        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)
@@ -71,7 +71,7 @@ module RuboCop
             message = format(MSG, read_method: read_method(mode))
 
             add_offense(read_node, message: message) do |corrector|
-              range = range_between(node.loc.selector.begin_pos, read_node.loc.expression.end_pos)
+              range = range_between(node.loc.selector.begin_pos, read_node.source_range.end_pos)
               replacement = "#{read_method(mode)}(#{filename.source})"
 
               corrector.replace(range, replacement)
@@ -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/file_write.rb

@@ -74,7 +74,7 @@ module RuboCop
             message = format(MSG, write_method: write_method(mode))
 
             add_offense(write_node, message: message) do |corrector|
-              range = range_between(node.loc.selector.begin_pos, write_node.loc.expression.end_pos)
+              range = range_between(node.loc.selector.begin_pos, write_node.source_range.end_pos)
               replacement = replacement(mode, filename, content, write_node)
 
               corrector.replace(range, replacement)

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

@@ -148,7 +148,7 @@ module RuboCop
         end
 
         def frozen_string_literal_comment(processed_source)
-          processed_source.find_token do |token|
+          processed_source.tokens.find do |token|
             token.text.start_with?(FROZEN_STRING_LITERAL)
           end
         end

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

@@ -182,11 +182,13 @@ module RuboCop
 
         # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def autocorrect(corrector, node, condition, replacement, guard)
-          corrector.replace(node.loc.keyword.join(condition.loc.expression), replacement)
+          corrector.replace(node.loc.keyword.join(condition.source_range), replacement)
 
           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
@@ -122,8 +133,8 @@ module RuboCop
         end
 
         def safe_to_register_offense?(block, except_key)
-          extracted = extract_body_if_nagated(block.body)
-          if extracted.method?('in?') || extracted.method?('include?') || \
+          extracted = extract_body_if_negated(block.body)
+          if extracted.method?('in?') || extracted.method?('include?') ||
              extracted.method?('exclude?')
             return true
           end
@@ -132,7 +143,7 @@ module RuboCop
           except_key.sym_type? || except_key.str_type?
         end
 
-        def extract_body_if_nagated(body)
+        def extract_body_if_negated(body)
           return body unless body.method?('!')
 
           body.receiver
@@ -161,7 +172,7 @@ module RuboCop
 
         def except_key(node)
           key_argument = node.argument_list.first.source
-          body = extract_body_if_nagated(node.body)
+          body = extract_body_if_negated(node.body)
           lhs, _method_name, rhs = *body
           return if [lhs, rhs].map(&:source).none?(key_argument)
 

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

@@ -37,6 +37,8 @@ module RuboCop
       #   end
       #
       class HashLikeCase < Base
+        include MinBranchesCount
+
         MSG = 'Consider replacing `case-when` with a hash lookup.'
 
         # @!method hash_like_case?(node)
@@ -49,7 +51,7 @@ module RuboCop
         PATTERN
 
         def on_case(node)
-          return if node.when_branches.size < min_branches_count
+          return unless min_branches_count?(node)
 
           hash_like_case?(node) do |condition_nodes, body_nodes|
             if nodes_of_same_type?(condition_nodes) && nodes_of_same_type?(body_nodes)
@@ -63,14 +65,6 @@ module RuboCop
         def nodes_of_same_type?(nodes)
           nodes.all? { |node| node.type == nodes.first.type }
         end
-
-        def min_branches_count
-          length = cop_config['MinBranchesCount'] || 3
-          return length if length.is_a?(Integer) && length.positive?
-
-          warn Rainbow('`MinBranchesCount` needs to be a positive integer!').red
-          exit!
-        end
       end
     end
   end

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

@@ -88,6 +88,9 @@ module RuboCop
       #   {foo: foo, bar: bar}
       #
       #   # good
+      #   {foo: foo, bar:}
+      #
+      #   # good
       #   {foo:, bar:}
       #
       # @example EnforcedShorthandSyntax: consistent
@@ -207,7 +210,7 @@ module RuboCop
           return true if /\A[_a-z]\w*[?!]?\z/i.match?(sym_name)
 
           # For more complicated hash keys, let the parser validate the syntax.
-          ProcessedSource.new("{ #{sym_name}: :foo }", target_ruby_version).valid_syntax?
+          parse("{ #{sym_name}: :foo }").valid_syntax?
         end
 
         def check(pairs, delim, msg)
@@ -247,7 +250,7 @@ module RuboCop
         end
 
         def argument_without_space?(node)
-          node.argument? && node.loc.expression.begin_pos == node.parent.loc.selector.end_pos
+          node.argument? && node.source_range.begin_pos == node.parent.loc.selector.end_pos
         end
 
         def autocorrect_hash_rockets(corrector, pair_node)

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