clarify code of ConstNodeInspector

Author: doodzik

lib/packwerk.rb

@@ -14,7 +14,6 @@
 require "packwerk/configuration"
 require "packwerk/const_node_inspector"
 require "packwerk/constant_discovery"
-require "packwerk/constant_name_inspector"
 require "packwerk/dependency_checker"
 require "packwerk/deprecated_references"
 require "packwerk/files_for_processing"

lib/packwerk/association_inspector.rb

@@ -1,13 +1,13 @@
 # typed: true
 # frozen_string_literal: true
 
-require "packwerk/constant_name_inspector"
+require "packwerk/constant_name_inspector_interface"
 require "packwerk/node"
 
 module Packwerk
   # Extracts the implicit constant reference from an active record association
   class AssociationInspector
-    include ConstantNameInspector
+    include ConstantNameInspectorInterface
 
     RAILS_ASSOCIATIONS = %i(
       belongs_to

lib/packwerk/const_node_inspector.rb

@@ -1,44 +1,54 @@
 # typed: true
 # frozen_string_literal: true
 
-require "packwerk/constant_name_inspector"
+require "packwerk/constant_name_inspector_interface"
 
 module Packwerk
   # Extracts a constant name from an AST node of type :const
   class ConstNodeInspector
-    include ConstantNameInspector
+    include ConstantNameInspectorInterface
 
     def constant_name_from_node(node, ancestors:)
-      return nil unless Node.type(node) == Node::CONSTANT
-
+      return nil unless Node.constant?(node)
       # Only process the root `const` node for namespaced constant references. For example, in the
       # reference `Spam::Eggs::Thing`, we only process the const node associated with `Spam`.
-      parent = ancestors.first
-      return nil if parent && Node.type(parent) == Node::CONSTANT
-
-      if constant_in_module_or_class_definition?(node, parent: parent)
-        # We're defining a class with this name, in which case the constant is implicitly fully qualified by its
-        # enclosing namespace
-        name = Node.parent_module_name(ancestors: ancestors)
-        name ||= Node.enclosing_namespace_path(node, ancestors: ancestors).push(Node.constant_name(node)).join("::")
+      return nil if root_constant?(ancestors)
 
-        "::" + name
+      if constant_in_module_or_class_definition?(node, ancestors: ancestors)
+        fully_qualify_constant(node, ancestors: ancestors)
       else
-        begin
-          Node.constant_name(node)
-        rescue Node::TypeError
-          nil
-        end
+        Node.constant_name(node)
       end
+    rescue Node::TypeError
+      nil
     end
 
     private
 
-    def constant_in_module_or_class_definition?(node, parent:)
-      if parent
+    def root_constant?(ancestors)
+      parent = ancestors.first
+      parent && Node.constant?(parent)
+    end
+
+    def constant_in_module_or_class_definition?(node, ancestors:)
+      if (parent = ancestors.first)
         parent_name = Node.module_name_from_definition(parent)
         parent_name && parent_name == Node.constant_name(node)
       end
     end
+
+    def fully_qualify_constant(node, ancestors:)
+      # We're defining a class with this name, in which case the constant is implicitly fully qualified by its
+      # enclosing namespace
+      name = Node.parent_module_name(ancestors: ancestors)
+      name ||= generate_qualified_constant(node, ancestors)
+      "::" + name
+    end
+
+    def generate_qualified_constant(node, ancestors:)
+      namespace_path = Node.enclosing_namespace_path(node, ancestors: ancestors)
+      constant_name = Node.constant_name(node)
+      namespace_path.push(constant_name).join("::")
+    end
   end
 end

lib/packwerk/constant_name_inspector.rb lib/packwerk/constant_name_inspector_interface.rb

@@ -6,7 +6,7 @@
 
 module Packwerk
   # An interface describing some object that can extract a constant name from an AST node
-  module ConstantNameInspector
+  module ConstantNameInspectorInterface
     extend T::Sig
     extend T::Helpers
 

lib/packwerk/node.rb

@@ -103,6 +103,10 @@ def location(node)
         Location.new(location.line, location.column)
       end
 
+      def constant?(node)
+        type(node) == CONSTANT
+      end
+
       def method_arguments(method_call_node)
         raise TypeError unless type(method_call_node) == METHOD_CALL
 
@@ -223,15 +227,15 @@ def module_creation?(node)
         # "Class.new"
         # "Module.new"
         type(node) == METHOD_CALL &&
-          type(receiver(node)) == CONSTANT &&
+          constant?(receiver(node)) &&
           ["Class", "Module"].include?(constant_name(receiver(node))) &&
           method_name(node) == :new
       end
 
       def name_from_block_definition(node)
         if method_name(method_call_node(node)) == :class_eval
           receiver = receiver(node)
-          constant_name(receiver) if receiver && type(receiver) == CONSTANT
+          constant_name(receiver) if receiver && constant?(receiver)
         end
       end
 

lib/packwerk/reference_extractor.rb

@@ -4,7 +4,7 @@
 require "sorbet-runtime"
 
 require "packwerk/constant_discovery"
-require "packwerk/constant_name_inspector"
+require "packwerk/constant_name_inspector_interface"
 require "packwerk/node"
 require "packwerk/parsed_constant_definitions"
 require "packwerk/reference"
@@ -17,7 +17,7 @@ class ReferenceExtractor
     sig do
       params(
         context_provider: Packwerk::ConstantDiscovery,
-        constant_name_inspectors: T::Array[Packwerk::ConstantNameInspector],
+        constant_name_inspectors: T::Array[Packwerk::ConstantNameInspectorInterface],
         root_node: ::AST::Node,
         root_path: String,
       ).void

test/unit/reference_extractor_test.rb

@@ -198,7 +198,7 @@ def setup
     private
 
     class DummyAssociationInspector
-      include Packwerk::ConstantNameInspector
+      include Packwerk::ConstantNameInspectorInterface
 
       def initialize(association: false, reference_name: "Dummy", expected_args: nil)
         @association = association