rubocop 1.57.1 → 1.81.7

data/lib/rubocop/cop/gemspec/required_ruby_version.rb

@@ -53,8 +53,6 @@ module RuboCop
       #     spec.required_ruby_version = '~> 2.5'
       #   end
       class RequiredRubyVersion < Base
-        include RangeHelp
-
         RESTRICT_ON_SEND = %i[required_ruby_version=].freeze
         NOT_EQUAL_MSG = '`required_ruby_version` and `TargetRubyVersion` ' \
                         '(%<target_ruby_version>s, which may be specified in ' \
@@ -76,7 +74,9 @@ module RuboCop
         PATTERN
 
         def on_new_investigation
-          add_global_offense(MISSING_MSG) unless required_ruby_version?(processed_source.ast)
+          return if processed_source.ast && required_ruby_version?(processed_source.ast)
+
+          add_global_offense(MISSING_MSG)
         end
 
         def on_send(node)
@@ -110,6 +110,8 @@ module RuboCop
             end
           end
 
+          return unless required_ruby_version
+
           required_ruby_version.str_content.scan(/\d/).first(2).join('.')
         end
 

data/lib/rubocop/cop/gemspec/ruby_version_globals_usage.rb

@@ -14,15 +14,15 @@ module RuboCop
       #   # bad
       #   Gem::Specification.new do |spec|
       #     if RUBY_VERSION >= '3.0'
-      #       spec.add_runtime_dependency 'gem_a'
+      #       spec.add_dependency 'gem_a'
       #     else
-      #       spec.add_runtime_dependency 'gem_b'
+      #       spec.add_dependency 'gem_b'
       #     end
       #   end
       #
       #   # good
       #   Gem::Specification.new do |spec|
-      #     spec.add_runtime_dependency 'gem_a'
+      #     spec.add_dependency 'gem_a'
       #   end
       #
       class RubyVersionGlobalsUsage < Base

data/lib/rubocop/cop/generator.rb

@@ -71,11 +71,17 @@ module RuboCop
                   (send nil? :bad_method ...)
                 PATTERN
 
+                # Called on every `send` node (method call) while walking the AST.
+                # TODO: remove this method if inspecting `send` nodes is unneeded for your cop.
+                # By default, this is aliased to `on_csend` as well to handle method calls
+                # with safe navigation, remove the alias if this is unnecessary.
+                # If kept, ensure your tests cover safe navigation as well!
                 def on_send(node)
                   return unless bad_method?(node)
 
                   add_offense(node)
                 end
+                alias on_csend on_send
               end
             end
           end

data/lib/rubocop/cop/internal_affairs/cop_description.rb

@@ -112,10 +112,6 @@ module RuboCop
           body = comment_body(comment_line)
           node.source.index(body)
         end
-
-        def relevant_file?(file)
-          file.match?(%r{/cop/.*\.rb\z})
-        end
       end
     end
   end

data/lib/rubocop/cop/internal_affairs/cop_enabled.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Use `config.cop_enabled?('Department/CopName')` instead of
+      # traversing the config hash.
+      #
+      # @example
+      #   # `for_cop(...)['Enabled']
+      #
+      #   # bad
+      #   config.for_cop('Department/CopName')['Enabled']
+      #
+      #   # good
+      #   config.cop_enabled?('Department/CopName')
+      #
+      # @example
+      #   # when keeping a cop's config in a local and then checking the `Enabled` key
+      #
+      #   # bad
+      #   cop_config = config.for_cop('Department/CopName')
+      #   cop_config['Enabled'] && cop_config['Foo']
+      #
+      #   # good
+      #   config.for_enabled_cop('Department/CopName')['Foo']
+      #
+      class CopEnabled < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<replacement>s` instead of `%<source>s`.'
+        MSG_HASH = 'Consider replacing uses of `%<hash_name>s` with `config.for_enabled_cop`.'
+
+        RESTRICT_ON_SEND = [:[]].freeze
+
+        # @!method for_cop_enabled?(node)
+        def_node_matcher :for_cop_enabled?, <<~PATTERN
+          (send
+            (send
+              ${(send nil? :config) (ivar :@config)} :for_cop
+              $(str _)) :[]
+            (str "Enabled"))
+        PATTERN
+
+        # @!method config_enabled_lookup?(node)
+        def_node_matcher :config_enabled_lookup?, <<~PATTERN
+          (send
+            {(lvar $_) (ivar $_) (send nil? $_)} :[]
+            (str "Enabled"))
+        PATTERN
+
+        def on_send(node)
+          if (config_var, cop_name = for_cop_enabled?(node))
+            handle_for_cop(node, config_var, cop_name)
+          elsif (config_var = config_enabled_lookup?(node))
+            return unless config_var.end_with?('_config')
+
+            handle_hash(node, config_var)
+          end
+        end
+
+        private
+
+        def handle_for_cop(node, config_var, cop_name)
+          source = node.source
+          quote = cop_name.loc.begin.source
+          cop_name = cop_name.value
+
+          replacement = "#{config_var.source}.cop_enabled?(#{quote}#{cop_name}#{quote})"
+          message = format(MSG, source: source, replacement: replacement)
+
+          add_offense(node, message: message) do |corrector|
+            corrector.replace(node, replacement)
+          end
+        end
+
+        def handle_hash(node, config_var)
+          message = format(MSG_HASH, hash_name: config_var)
+
+          add_offense(node, message: message)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs/empty_line_between_expect_offense_and_correction.rb

@@ -38,7 +38,8 @@ module RuboCop
         CORRECTION_EXPECTATION_METHODS = %i[expect_correction expect_no_corrections].freeze
 
         def on_send(node)
-          return unless (next_sibling = node.right_sibling) && next_sibling.send_type?
+          return unless (next_sibling = node.right_sibling)
+          return unless next_sibling.respond_to?(:send_type?) && next_sibling.send_type?
 
           method_name = next_sibling.method_name
           return unless CORRECTION_EXPECTATION_METHODS.include?(method_name)

data/lib/rubocop/cop/internal_affairs/example_description.rb

@@ -45,14 +45,17 @@ module RuboCop
         EXPECT_OFFENSE_DESCRIPTION_MAPPING = {
           /\A(does not|doesn't) (register|find|flag|report)/ => 'registers',
           /\A(does not|doesn't) add (a|an|any )?offense/ => 'registers an offense',
-          /\Aaccepts\b/ => 'registers'
+          /\Aregisters no offense/ => 'registers an offense',
+          /\A(accepts|allows|register)\b/ => 'registers'
         }.freeze
 
         EXPECT_NO_CORRECTIONS_DESCRIPTION_MAPPING = {
-          /\A(auto[- ]?)?correct/ => 'does not correct'
+          /\A(auto[- ]?)?corrects?/ => 'does not correct',
+          /\band (auto[- ]?)?corrects/ => 'but does not correct'
         }.freeze
 
         EXPECT_CORRECTION_DESCRIPTION_MAPPING = {
+          /\bbut (does not|doesn't) (auto[- ]?)?correct/ => 'and autocorrects',
           /\b(does not|doesn't) (auto[- ]?)?correct/ => 'autocorrects'
         }.freeze
 
@@ -63,10 +66,10 @@ module RuboCop
           expect_correction: EXPECT_CORRECTION_DESCRIPTION_MAPPING
         }.freeze
 
-        # @!method offense_example?(node)
-        def_node_matcher :offense_example?, <<~PATTERN
+        # @!method offense_example(node)
+        def_node_matcher :offense_example, <<~PATTERN
           (block
-            (send _ {:it :specify} $_description)
+            (send _ {:it :specify :xit :fit} $...)
             _args
             `(send nil? %RESTRICT_ON_SEND ...)
           )
@@ -74,7 +77,7 @@ module RuboCop
 
         def on_send(node)
           parent = node.each_ancestor(:block).first
-          return unless parent && (current_description = offense_example?(parent))
+          return unless parent && (current_description = offense_example(parent)&.first)
 
           method_name = node.method_name
           message = format(MSG, method_name: method_name)
@@ -89,8 +92,10 @@ module RuboCop
           description_text = string_contents(current_description)
           return unless (new_description = correct_description(description_text, description_map))
 
+          quote = current_description.dstr_type? ? '"' : "'"
+
           add_offense(current_description, message: message) do |corrector|
-            corrector.replace(current_description, "'#{new_description}'")
+            corrector.replace(current_description, "#{quote}#{new_description}#{quote}")
           end
         end
 
@@ -105,7 +110,7 @@ module RuboCop
         end
 
         def string_contents(node)
-          node.str_type? ? node.value : node.source
+          node.type?(:str, :dstr) ? node.value : node.source
         end
       end
     end

data/lib/rubocop/cop/internal_affairs/location_exists.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # When a node location may not exist, `Node#loc?` or `Node#loc_is?`
+      # can be used instead of calling `Node#respond_to?` before using
+      # the value.
+      #
+      # @example
+      #   # bad
+      #   node.loc.respond_to?(:begin) && node.loc.begin
+      #
+      #   # good
+      #   node.loc?(:begin)
+      #
+      #   # bad
+      #   node.loc.respond_to?(:begin) && node.loc.begin.is?('(')
+      #
+      #   # good
+      #   node.loc_is?(:begin, '(')
+      #
+      #   # bad
+      #   node.loc.respond_to?(:begin) && node.loc.begin.source == '('
+      #
+      #   # good
+      #   node.loc_is?(:begin, '(')
+      #
+      class LocationExists < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<replacement>s` instead of `%<source>s`.'
+
+        # @!method replaceable_with_loc_is(node)
+        def_node_matcher :replaceable_with_loc_is, <<~PATTERN
+          (and
+            (call
+              (call $_receiver :loc) :respond_to?
+              $(sym _location))
+            {
+              (call
+                (call
+                  (call _receiver :loc) _location) :is?
+                $(str _))
+              (call
+                (call
+                  (call
+                    (call _receiver :loc) _location) :source) :==
+                    $(str _))
+            })
+        PATTERN
+
+        # @!method replaceable_with_loc(node)
+        def_node_matcher :replaceable_with_loc, <<~PATTERN
+          (and
+            (call
+              (call $_receiver :loc) :respond_to?
+              $(sym _location))
+            (call
+              (call _receiver :loc) _location))
+        PATTERN
+
+        def on_and(node)
+          replace_with_loc(node) || replace_with_loc_is(node)
+        end
+
+        private
+
+        def replace_with_loc(node)
+          replaceable_with_loc(node) do |receiver, location|
+            if node.parent&.assignment?
+              register_offense(node, replace_assignment(receiver, location))
+            else
+              register_offense(node, replacement(receiver, "loc?(#{location.source})"))
+            end
+          end
+        end
+
+        def replace_with_loc_is(node)
+          replaceable_with_loc_is(node) do |receiver, location, value|
+            replacement = replacement(receiver, "loc_is?(#{location.source}, #{value.source})")
+            register_offense(node, replacement)
+          end
+        end
+
+        def register_offense(node, replacement)
+          message = format(MSG, replacement: replacement, source: node.source)
+
+          add_offense(node, message: message) do |corrector|
+            corrector.replace(node, replacement)
+          end
+        end
+
+        def replacement(receiver, rest)
+          "#{replace_receiver(receiver)}#{rest}"
+        end
+
+        def replace_assignment(receiver, location)
+          prefix = replace_receiver(receiver)
+
+          "#{prefix}loc#{dot(receiver)}#{location.value} if #{prefix}loc?(#{location.source})"
+        end
+
+        def replace_receiver(receiver)
+          return '' unless receiver
+
+          "#{receiver.source}#{dot(receiver)}"
+        end
+
+        def dot(node)
+          node.parent.loc.dot.source
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs/location_expression.rb

@@ -22,7 +22,7 @@ module RuboCop
 
         def on_send(node)
           return unless (parent = node.parent)
-          return unless parent.send_type? && parent.method?(:expression)
+          return unless parent.call_type? && parent.method?(:expression)
           return unless parent.receiver.receiver
 
           offense = node.loc.selector.join(parent.source_range.end)
@@ -31,6 +31,7 @@ module RuboCop
             corrector.replace(offense, 'source_range')
           end
         end
+        alias on_csend on_send
       end
     end
   end

data/lib/rubocop/cop/internal_affairs/location_line_equality_comparison.rb

@@ -19,6 +19,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `%<preferred>s`.'
+        RESTRICT_ON_SEND = [:==].freeze
 
         # @!method line_send(node)
         def_node_matcher :line_send, <<~PATTERN
@@ -36,10 +37,8 @@ module RuboCop
         def on_send(node)
           return unless location_line_equality_comparison?(node)
 
-          lhs, _op, rhs = *node
-
-          lhs_receiver = extract_receiver(lhs)
-          rhs_receiver = extract_receiver(rhs)
+          lhs_receiver = extract_receiver(node.receiver)
+          rhs_receiver = extract_receiver(node.first_argument)
           preferred = "same_line?(#{lhs_receiver}, #{rhs_receiver})"
 
           add_offense(node, message: format(MSG, preferred: preferred)) do |corrector|

data/lib/rubocop/cop/internal_affairs/method_name_end_with.rb

@@ -30,6 +30,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `%<method_name>s` instead of `%<method_suffix>s`.'
+        RESTRICT_ON_SEND = %i[end_with?].freeze
         SUGGEST_METHOD_FOR_SUFFIX = {
           '=' => 'assignment_method?',
           '!' => 'bang_method?',
@@ -51,14 +52,15 @@ module RuboCop
 
         def on_send(node)
           method_name_end_with?(node) do |method_name_node, end_with_arg|
+            next unless method_name_node.receiver
+
+            preferred_method = SUGGEST_METHOD_FOR_SUFFIX[end_with_arg.value]
             range = range(method_name_node, node)
-            message = format(
-              MSG,
-              method_name: SUGGEST_METHOD_FOR_SUFFIX[end_with_arg.value],
-              method_suffix: range.source
-            )
+            message = format(MSG, method_name: preferred_method, method_suffix: range.source)
 
-            add_offense(range, message: message)
+            add_offense(range, message: message) do |corrector|
+              corrector.replace(range, preferred_method)
+            end
           end
         end
         alias on_csend on_send

data/lib/rubocop/cop/internal_affairs/method_name_equal.rb

@@ -12,38 +12,37 @@ module RuboCop
       #   # good
       #   node.method?(:do_something)
       #
+      #   # bad
+      #   node.method_name != :do_something
+      #
+      #   # good
+      #   !node.method?(:do_something)
+      #
       class MethodNameEqual < Base
-        include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Use `method?(%<method_name>s)` instead of `method_name == %<method_name>s`.'
-        RESTRICT_ON_SEND = %i[==].freeze
+        MSG = 'Use `%<prefer>s` instead.'
+        RESTRICT_ON_SEND = %i[== !=].freeze
 
-        # @!method method_name?(node)
-        def_node_matcher :method_name?, <<~PATTERN
+        # @!method method_name(node)
+        def_node_matcher :method_name, <<~PATTERN
           (send
-            $(send
-              (...) :method_name) :==
-            $...)
+            (send
+              (...) :method_name) {:== :!=}
+            $_)
         PATTERN
 
         def on_send(node)
-          method_name?(node) do |method_name_node, method_name_arg|
-            message = format(MSG, method_name: method_name_arg.first.source)
+          method_name(node) do |method_name_arg|
+            bang = node.method?(:!=) ? '!' : ''
+            prefer = "#{bang}#{node.receiver.receiver.source}.method?(#{method_name_arg.source})"
+            message = format(MSG, prefer: prefer)
 
-            range = range(method_name_node, node)
-
-            add_offense(range, message: message) do |corrector|
-              corrector.replace(range, "method?(#{method_name_arg.first.source})")
+            add_offense(node, message: message) do |corrector|
+              corrector.replace(node, prefer)
             end
           end
         end
-
-        private
-
-        def range(method_name_node, node)
-          range_between(method_name_node.loc.selector.begin_pos, node.source_range.end_pos)
-        end
       end
     end
   end

data/lib/rubocop/cop/internal_affairs/node_first_or_last_argument.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks for the use of `node.arguments.first` or `node.arguments.last` and
+      # suggests the use of `node.first_argument` or `node.last_argument` instead.
+      #
+      # @example
+      #   # bad
+      #   node.arguments.first
+      #   node.arguments[0]
+      #   node.arguments.last
+      #   node.arguments[-1]
+      #
+      #   # good
+      #   node.first_argument
+      #   node.last_argument
+      #
+      class NodeFirstOrLastArgument < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Use `#%<correct>s` instead of `#%<incorrect>s`.'
+        RESTRICT_ON_SEND = %i[arguments].freeze
+
+        # @!method arguments_first_or_last?(node)
+        def_node_matcher :arguments_first_or_last?, <<~PATTERN
+          {
+            (call (call !nil? :arguments) ${:first :last})
+            (call (call !nil? :arguments) :[] (int ${0 -1}))
+          }
+        PATTERN
+
+        def on_send(node)
+          arguments_first_or_last?(node.parent) do |end_or_index|
+            range = range_between(node.loc.selector.begin_pos, node.parent.source_range.end_pos)
+            correct = case end_or_index
+                      when :first, 0 then 'first_argument'
+                      when :last, -1 then 'last_argument'
+                      else raise "Unknown end_or_index: #{end_or_index}"
+                      end
+            message = format(MSG, correct: correct, incorrect: range.source)
+
+            add_offense(range, message: message) do |corrector|
+              corrector.replace(range, correct)
+            end
+          end
+        end
+        alias on_csend on_send
+      end
+    end
+  end
+end