rubocop 1.66.1 → 1.72.2

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

@@ -90,8 +90,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 +108,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)

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

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

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # rubocop:disable InternalAffairs/RedundantSourceRange -- node here is a `NodePattern::Node`
+      class NodePatternGroups
+        # Walks an AST that has been processed by `InternalAffairs::NodePatternGroups::Processor`
+        # in order to find `node_type` and `node_sequence` nodes that can be replaced with a node
+        # group in `InternalAffairs/NodePatternGroups`.
+        #
+        # Calling `ASTWalker#walk` sets `node_groups` with an array of `NodeGroup` structs
+        # that contain metadata about nodes that can be replaced, including location data. That
+        # metadata is used by the cop to register offenses and perform corrections.
+        class ASTWalker
+          # Struct to contain data about parts of a node pattern that can be replaced
+          NodeGroup = Struct.new(
+            :name,             # The name of the node group that will be inserted
+            :union,            # The entire `union` node
+            :node_types,       # An array of `node_type` nodes that will be removed
+            :sequence?,        # The pattern matches a node type with given attributes
+            :start_index,      # The index in the union of the first node type to remove
+            :offense_range,    # The range to mark an offense on
+            :ranges,           # Range of each element to remove, since they may not be adjacent
+            :pipe,             # Is the union delimited by pipes?
+            :other_elements?,  # Does the union have other elements other than those to remove?
+            keyword_init: true
+          )
+
+          def initialize
+            reset!
+          end
+
+          def reset!
+            @node_groups = []
+          end
+
+          attr_reader :node_groups
+
+          # Recursively walk the AST in a depth-first manner.
+          # Only `union` nodes are handled further.
+          def walk(node)
+            return if node.nil?
+
+            on_union(node) if node.type == :union
+
+            node.child_nodes.each do |child|
+              walk(child)
+            end
+          end
+
+          # Search `union` nodes for `node_type` and `node_sequence` nodes that can be
+          # collapsed into a node group.
+          # * `node_type` nodes are nodes with no further configuration (ie. `send`)
+          # * `node_sequence` nodes are nodes with further configuration (ie. `(send ...)`)
+          #
+          # Each group of types that can be collapsed will have a `NodeGroup` record added
+          # to `node_groups`, which is then used by the cop.
+          def on_union(node)
+            all_node_types = each_child_node(node, :node_type, :node_sequence).to_a
+
+            each_node_group(all_node_types) do |group_name, node_types|
+              next unless sequences_match?(node_types)
+
+              node_groups << node_group_data(
+                group_name, node, node_types,
+                all_node_types.index(node_types.first),
+                (node.children - node_types).any?
+              )
+            end
+          end
+
+          private
+
+          def each_child_node(node, *types)
+            return to_enum(__method__, node, *types) unless block_given?
+
+            node.children.each do |child|
+              yield child if types.empty? || types.include?(child.type)
+            end
+
+            self
+          end
+
+          def each_node_group(types_to_check)
+            # Find all node groups where all of the members are present in the union
+            type_names = types_to_check.map(&:child)
+
+            NODE_GROUPS.select { |_, group| group & type_names == group }.each_key do |name|
+              nodes = get_relevant_nodes(types_to_check, name)
+
+              yield name, nodes
+            end
+          end
+
+          def get_relevant_nodes(node_types, group_name)
+            node_types.each_with_object([]) do |node_type, arr|
+              next unless NODE_GROUPS[group_name].include?(node_type.child)
+
+              arr << node_type
+            end
+          end
+
+          def node_group_data(name, union, node_types, start_index, other)
+            NodeGroup.new(
+              name: name,
+              union: union,
+              node_types: node_types,
+              sequence?: node_types.first.type == :node_sequence,
+              start_index: start_index,
+              pipe: union.source_range.source['|'],
+              other_elements?: other
+            )
+          end
+
+          def sequences_match?(types)
+            # Ensure all given types have the same type and the same sequence
+            # ie. `(send ...)` and `(csend ...) is a match
+            #     `(send)` and `(csend ...)` is not a match
+            #     `send` and `(csend ...)` is not a match
+
+            types.each_cons(2).all? do |left, right|
+              left.type == right.type && left.children[1..] == right.children[1..]
+            end
+          end
+        end
+      end
+      # rubocop:enable InternalAffairs/RedundantSourceRange
+    end
+  end
+end