rubocop 1.67.0 → 1.79.1

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

@@ -6,10 +6,11 @@ module RuboCop
       # An attribute assignment method calls should be listed only once
       # in a gemspec.
       #
-      # Assigning to an attribute with the same name using `spec.foo =` will be
-      # an unintended usage. On the other hand, duplication of methods such
-      # as `spec.requirements`, `spec.add_runtime_dependency`, and others are
-      # permitted because it is the intended use of appending values.
+      # Assigning to an attribute with the same name using `spec.foo =` or
+      # `spec.attribute#[]=` will be an unintended usage. On the other hand,
+      # duplication of methods such # as `spec.requirements`,
+      # `spec.add_runtime_dependency`, and others are permitted because it is
+      # the intended use of appending values.
       #
       # @example
       #   # bad
@@ -34,6 +35,18 @@ module RuboCop
       #     spec.add_dependency('parallel', '~> 1.10')
       #     spec.add_dependency('parser', '>= 2.3.3.1', '< 3.0')
       #   end
+      #
+      #   # bad
+      #   Gem::Specification.new do |spec|
+      #     spec.metadata["key"] = "value"
+      #     spec.metadata["key"] = "value"
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.metadata["key"] = "value"
+      #   end
+      #
       class DuplicatedAssignment < Base
         include RangeHelp
         include GemspecHelp
@@ -41,15 +54,16 @@ module RuboCop
         MSG = '`%<assignment>s` method calls already given on line ' \
               '%<line_of_first_occurrence>d of the gemspec.'
 
-        # @!method assignment_method_declarations(node)
-        def_node_search :assignment_method_declarations, <<~PATTERN
-          (send
-            (lvar #match_block_variable_name?) _ ...)
-        PATTERN
-
         def on_new_investigation
           return if processed_source.blank?
 
+          process_assignment_method_nodes
+          process_indexed_assignment_method_nodes
+        end
+
+        private
+
+        def process_assignment_method_nodes
           duplicated_assignment_method_nodes.each do |nodes|
             nodes[1..].each do |node|
               register_offense(node, node.method_name, nodes.first.first_line)
@@ -57,11 +71,12 @@ module RuboCop
           end
         end
 
-        private
-
-        def match_block_variable_name?(receiver_name)
-          gem_specification(processed_source.ast) do |block_variable_name|
-            return block_variable_name == receiver_name
+        def process_indexed_assignment_method_nodes
+          duplicated_indexed_assignment_method_nodes.each do |nodes|
+            nodes[1..].each do |node|
+              assignment = "#{node.children.first.method_name}[#{node.first_argument.source}]="
+              register_offense(node, assignment, nodes.first.first_line)
+            end
           end
         end
 
@@ -73,6 +88,13 @@ module RuboCop
             .select { |nodes| nodes.size > 1 }
         end
 
+        def duplicated_indexed_assignment_method_nodes
+          indexed_assignment_method_declarations(processed_source.ast)
+            .group_by { |node| [node.children.first.method_name, node.first_argument] }
+            .values
+            .select { |nodes| nodes.size > 1 }
+        end
+
         def register_offense(node, assignment, line_of_first_occurrence)
           line_range = node.loc.column...node.loc.last_column
           offense_location = source_range(processed_source.buffer, node.first_line, line_range)

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

@@ -71,7 +71,7 @@ module RuboCop
 
           dependency_declarations(processed_source.ast)
             .each_cons(2) do |previous, current|
-            next unless consecutive_lines(previous, current)
+            next unless consecutive_lines?(previous, current)
             next unless case_insensitive_out_of_order?(gem_name(current), gem_name(previous))
             next unless get_dependency_name(previous) == get_dependency_name(current)
 

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

@@ -74,6 +74,14 @@ module RuboCop
           }
         PATTERN
 
+        # @!method metadata_assignment(node)
+        def_node_search :metadata_assignment, <<~PATTERN
+          `{
+            (send _ :metadata= _)
+            (send (send _ :metadata) :[]= (str _) _)
+          }
+        PATTERN
+
         # @!method rubygems_mfa_required(node)
         def_node_search :rubygems_mfa_required, <<~PATTERN
           (pair (str "rubygems_mfa_required") $_)
@@ -131,9 +139,15 @@ module RuboCop
         end
 
         def insert_mfa_required(corrector, node, block_var)
-          corrector.insert_before(node.loc.end, <<~RUBY)
+          require_mfa_directive = <<~RUBY.strip
             #{block_var}.metadata['rubygems_mfa_required'] = 'true'
           RUBY
+
+          if (last_assignment = metadata_assignment(processed_source.ast).to_a.last)
+            corrector.insert_after(last_assignment, "\n#{require_mfa_directive}")
+          else
+            corrector.insert_before(node.loc.end, "#{require_mfa_directive}\n")
+          end
         end
 
         def change_value(corrector, value)

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 ' \

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_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/example_description.rb

@@ -46,14 +46,16 @@ module RuboCop
           /\A(does not|doesn't) (register|find|flag|report)/ => 'registers',
           /\A(does not|doesn't) add (a|an|any )?offense/ => 'registers an offense',
           /\Aregisters no offense/ => 'registers an offense',
-          /\A(accepts|register)\b/ => 'registers'
+          /\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
 
@@ -67,7 +69,7 @@ module RuboCop
         # @!method offense_example(node)
         def_node_matcher :offense_example, <<~PATTERN
           (block
-            (send _ {:it :specify} $...)
+            (send _ {:it :specify :xit :fit} $...)
             _args
             `(send nil? %RESTRICT_ON_SEND ...)
           )
@@ -90,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
 
@@ -106,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/node_first_or_last_argument.rb

@@ -27,8 +27,8 @@ module RuboCop
         # @!method arguments_first_or_last?(node)
         def_node_matcher :arguments_first_or_last?, <<~PATTERN
           {
-            (send (send !nil? :arguments) ${:first :last})
-            (send (send !nil? :arguments) :[] (int ${0 -1}))
+            (call (call !nil? :arguments) ${:first :last})
+            (call (call !nil? :arguments) :[] (int ${0 -1}))
           }
         PATTERN
 
@@ -47,6 +47,7 @@ module RuboCop
             end
           end
         end
+        alias on_csend on_send
       end
     end
   end

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

@@ -62,7 +62,7 @@ module RuboCop
         private
 
         def valid_method_name?(node)
-          node.first_argument.str_type? || node.first_argument.sym_type?
+          node.first_argument.type?(:str, :sym)
         end
 
         def method_directives(node)
@@ -110,8 +110,8 @@ module RuboCop
         def directive_offense_type(directive, actual_name)
           return :missing_directive unless directive
 
-          return :wrong_scope if wrong_scope(directive, actual_name)
-          return :no_scope if no_scope(directive, actual_name)
+          return :wrong_scope if wrong_scope?(directive, actual_name)
+          return :no_scope if no_scope?(directive, actual_name)
 
           # The method directive being prefixed by 'self.' is always an offense.
           # The matched method_name does not contain the receiver but the
@@ -121,11 +121,11 @@ module RuboCop
           end
         end
 
-        def wrong_scope(directive, actual_name)
+        def wrong_scope?(directive, actual_name)
           !actual_name.start_with?('self.') && directive[:has_scope_directive]
         end
 
-        def no_scope(directive, actual_name)
+        def no_scope?(directive, actual_name)
           actual_name.start_with?('self.') && !directive[:has_scope_directive]
         end
 

data/lib/rubocop/cop/internal_affairs/node_pattern_groups/ast_processor.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      class NodePatternGroups
+        # AST Processor for NodePattern ASTs, for use with `InternalAffairs/NodePatternGroups`.
+        #
+        # Looks for sequences and subsequences where the first item is a `node_type` node,
+        # and converts them to `node_sequence` nodes (not a true `Rubocop::AST::NodePattern`
+        # node type).
+        #
+        # The resulting AST will be walked by `InternalAffairs::NodePatternGroups::ASTWalker`
+        # in order to find node types in a `union` node that can be rewritten as a node group.
+        #
+        # NOTE: The `on_*` methods in this class relate not to the normal node types but
+        # rather to the Node Pattern node types. Not every node type is handled.
+        #
+        class ASTProcessor
+          include ::AST::Processor::Mixin
+
+          def handler_missing(node)
+            node.updated(nil, process_children(node))
+          end
+
+          # Look for `sequence` and `subsequence` nodes that contain a `node_type` node as
+          # their first child. These are rewritten as `node_sequence` nodes so that it is
+          # possible to compare nodes while looking for replacement candidates for node groups.
+          # This is necessary so that extended patterns can be matched and replaced.
+          # ie. `{(send _ :foo ...) (csend _ :foo ...)}` can become `(call _ :foo ...)`
+          def on_sequence(node)
+            first_child = node.child
+
+            if first_child.type == :node_type
+              children = [first_child.child, *process_children(node, 1..)]
+
+              # The `node_sequence` node contains the `node_type` symbol as its first child,
+              # followed by all the other nodes contained in the `sequence` node.
+              # The location is copied from the sequence, so that the entire sequence can
+              # eventually be corrected in the cop.
+              n(:node_sequence, children, location: node.location)
+            else
+              node.updated(nil, process_children(node))
+            end
+          end
+          alias on_subsequence on_sequence
+
+          private
+
+          def n(type, children = [], properties = {})
+            NodePattern::Node.new(type, children, properties)
+          end
+
+          def process_children(node, range = 0..-1)
+            node.children[range].map do |child|
+              child.is_a?(::AST::Node) ? process(child) : child
+            end
+          end
+        end
+      end
+    end
+  end
+end