packwerk 2.1.1 → 2.2.1

data/lib/packwerk/reference_checking/checkers/dependency_checker.rb

@@ -23,8 +23,24 @@ module Packwerk
           return false unless reference.source_package
           return false unless reference.source_package.enforce_dependencies?
           return false if reference.source_package.dependency?(reference.constant.package)
+
           true
         end
+
+        sig do
+          override
+            .params(reference: Packwerk::Reference)
+            .returns(String)
+        end
+        def message(reference)
+          <<~EOS
+            Dependency violation: #{reference.constant.name} belongs to '#{reference.constant.package}', but '#{reference.source_package}' does not specify a dependency on '#{reference.constant.package}'.
+            Are we missing an abstraction?
+            Is the code making the reference, and the referenced constant, in the right packages?
+
+            #{standard_help_message(reference)}
+          EOS
+        end
       end
     end
   end

data/lib/packwerk/reference_checking/checkers/privacy_checker.rb

@@ -31,6 +31,24 @@ module Packwerk
           true
         end
 
+        sig do
+          override
+            .params(reference: Packwerk::Reference)
+            .returns(String)
+        end
+        def message(reference)
+          source_desc = "'#{reference.source_package}'"
+
+          message = <<~EOS
+            Privacy violation: '#{reference.constant.name}' is private to '#{reference.constant.package}' but referenced from #{source_desc}.
+            Is there a public entrypoint in '#{reference.constant.package.public_path}' that you can use instead?
+
+            #{standard_help_message(reference)}
+          EOS
+
+          message.chomp
+        end
+
         private
 
         sig do

data/lib/packwerk/reference_checking/reference_checker.rb

@@ -13,18 +13,18 @@ module Packwerk
 
       sig do
         params(
-          reference: T.any(Packwerk::Reference, Packwerk::Offense)
+          reference: Reference
         ).returns(T::Array[Packwerk::Offense])
       end
       def call(reference)
-        return [reference] if reference.is_a?(Packwerk::Offense)
-
         @checkers.each_with_object([]) do |checker, violations|
           next unless checker.invalid_reference?(reference)
+
           offense = Packwerk::ReferenceOffense.new(
             location: reference.source_location,
             reference: reference,
-            violation_type: checker.violation_type
+            violation_type: checker.violation_type,
+            message: checker.message(reference)
           )
           violations << offense
         end

data/lib/packwerk/reference_extractor.rb

@@ -6,6 +6,49 @@ module Packwerk
   class ReferenceExtractor
     extend T::Sig
 
+    class << self
+      extend T::Sig
+
+      sig do
+        params(
+          unresolved_references: T::Array[UnresolvedReference],
+          context_provider: ConstantDiscovery
+        ).returns(T::Array[Reference])
+      end
+      def get_fully_qualified_references_from(unresolved_references, context_provider)
+        fully_qualified_references = T.let([], T::Array[Reference])
+
+        unresolved_references.each do |unresolved_references_or_offense|
+          unresolved_reference = unresolved_references_or_offense
+
+          constant =
+            context_provider.context_for(
+              unresolved_reference.constant_name,
+              current_namespace_path: unresolved_reference.namespace_path
+            )
+
+          next if constant.nil?
+
+          package_for_constant = constant.package
+
+          next if package_for_constant.nil?
+
+          source_package = context_provider.package_from_path(unresolved_reference.relative_path)
+
+          next if source_package == package_for_constant
+
+          fully_qualified_references << Reference.new(
+            source_package,
+            unresolved_reference.relative_path,
+            constant,
+            unresolved_reference.source_location
+          )
+        end
+
+        fully_qualified_references
+      end
+    end
+
     sig do
       params(
         constant_name_inspectors: T::Array[Packwerk::ConstantNameInspector],
@@ -27,10 +70,10 @@ module Packwerk
       params(
         node: Parser::AST::Node,
         ancestors: T::Array[Parser::AST::Node],
-        absolute_file: String
+        relative_file: String
       ).returns(T.nilable(UnresolvedReference))
     end
-    def reference_from_node(node, ancestors:, absolute_file:)
+    def reference_from_node(node, ancestors:, relative_file:)
       constant_name = T.let(nil, T.nilable(String))
 
       @constant_name_inspectors.each do |inspector|
@@ -44,56 +87,11 @@ module Packwerk
           constant_name,
           node: node,
           ancestors: ancestors,
-          absolute_file: absolute_file
+          relative_file: relative_file
         )
       end
     end
 
-    sig do
-      params(
-        unresolved_references_and_offenses: T::Array[T.any(UnresolvedReference, Offense)],
-        context_provider: ConstantDiscovery
-      ).returns(T::Array[T.any(Reference, Offense)])
-    end
-    def self.get_fully_qualified_references_and_offenses_from(unresolved_references_and_offenses, context_provider)
-      fully_qualified_references_and_offenses = T.let([], T::Array[T.any(Reference, Offense)])
-
-      unresolved_references_and_offenses.each do |unresolved_references_or_offense|
-        if unresolved_references_or_offense.is_a?(Offense)
-          fully_qualified_references_and_offenses << unresolved_references_or_offense
-
-          next
-        end
-
-        unresolved_reference = unresolved_references_or_offense
-
-        constant =
-          context_provider.context_for(
-            unresolved_reference.constant_name,
-            current_namespace_path: unresolved_reference.namespace_path
-          )
-
-        next if constant.nil?
-
-        package_for_constant = constant.package
-
-        next if package_for_constant.nil?
-
-        source_package = context_provider.package_from_path(unresolved_reference.relative_path)
-
-        next if source_package == package_for_constant
-
-        fully_qualified_references_and_offenses << Reference.new(
-          source_package,
-          unresolved_reference.relative_path,
-          constant,
-          unresolved_reference.source_location
-        )
-      end
-
-      fully_qualified_references_and_offenses
-    end
-
     private
 
     sig do
@@ -101,16 +99,15 @@ module Packwerk
         constant_name: String,
         node: Parser::AST::Node,
         ancestors: T::Array[Parser::AST::Node],
-        absolute_file: String
+        relative_file: String
       ).returns(T.nilable(UnresolvedReference))
     end
-    def reference_from_constant(constant_name, node:, ancestors:, absolute_file:)
-      namespace_path = Node.enclosing_namespace_path(node, ancestors: ancestors)
+    def reference_from_constant(constant_name, node:, ancestors:, relative_file:)
+      namespace_path = NodeHelpers.enclosing_namespace_path(node, ancestors: ancestors)
 
-      return if local_reference?(constant_name, Node.name_location(node), namespace_path)
+      return if local_reference?(constant_name, NodeHelpers.name_location(node), namespace_path)
 
-      relative_file = Pathname.new(absolute_file).relative_path_from(@root_path).to_s
-      location = Node.location(node)
+      location = NodeHelpers.location(node)
 
       UnresolvedReference.new(
         constant_name,

data/lib/packwerk/reference_offense.rb

@@ -17,39 +17,15 @@ module Packwerk
       params(
         reference: Packwerk::Reference,
         violation_type: Packwerk::ViolationType,
+        message: String,
         location: T.nilable(Node::Location)
       )
         .void
     end
-    def initialize(reference:, violation_type:, location: nil)
-      super(file: reference.relative_path, message: build_message(reference, violation_type), location: location)
+    def initialize(reference:, violation_type:, message:, location: nil)
+      super(file: reference.relative_path, message: message, location: location)
       @reference = reference
       @violation_type = violation_type
     end
-
-    private
-
-    sig { params(reference: Reference, violation_type: ViolationType).returns(String) }
-    def build_message(reference, violation_type)
-      violation_message = case violation_type
-      when ViolationType::Privacy
-        source_desc = "'#{reference.source_package}'"
-        "Privacy violation: '#{reference.constant.name}' is private to '#{reference.constant.package}' but " \
-        "referenced from #{source_desc}.\n" \
-        "Is there a public entrypoint in '#{reference.constant.package.public_path}' that you can use instead?"
-      when ViolationType::Dependency
-        "Dependency violation: #{reference.constant.name} belongs to '#{reference.constant.package}', but " \
-        "'#{reference.source_package}' does not specify a dependency on " \
-        "'#{reference.constant.package}'.\n" \
-        "Are we missing an abstraction?\n" \
-        "Is the code making the reference, and the referenced constant, in the right packages?\n"
-      end
-
-      <<~EOS
-        #{violation_message}
-        Inference details: this is a reference to #{reference.constant.name} which seems to be defined in #{reference.constant.location}.
-        To receive help interpreting or resolving this error message, see: https://github.com/Shopify/packwerk/blob/main/TROUBLESHOOT.md#Troubleshooting-violations
-      EOS
-    end
   end
 end

data/lib/packwerk/run_context.rb

@@ -38,7 +38,7 @@ module Packwerk
     sig do
       params(
         root_path: String,
-        load_paths: T::Array[String],
+        load_paths: T::Hash[String, Module],
         inflector: T.class_of(ActiveSupport::Inflector),
         cache_directory: Pathname,
         config_path: T.nilable(String),
@@ -77,15 +77,17 @@ module Packwerk
       )
     end
 
-    sig { params(absolute_file: String).returns(T::Array[Packwerk::Offense]) }
-    def process_file(absolute_file:)
-      unresolved_references_and_offenses = file_processor.call(absolute_file)
-      references_and_offenses = ReferenceExtractor.get_fully_qualified_references_and_offenses_from(
-        unresolved_references_and_offenses,
+    sig { params(relative_file: String).returns(T::Array[Packwerk::Offense]) }
+    def process_file(relative_file:)
+      processed_file = file_processor.call(relative_file)
+
+      references = ReferenceExtractor.get_fully_qualified_references_from(
+        processed_file.unresolved_references,
         context_provider
       )
       reference_checker = ReferenceChecking::ReferenceChecker.new(@checkers)
-      references_and_offenses.flat_map { |reference| reference_checker.call(reference) }
+
+      processed_file.offenses + references.flat_map { |reference| reference_checker.call(reference) }
     end
 
     private

data/lib/packwerk/spring_command.rb

@@ -1,5 +1,5 @@
-# frozen_string_literal: true
 # typed: true
+# frozen_string_literal: true
 
 require "spring/commands"
 

data/lib/packwerk/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Packwerk
-  VERSION = "2.1.1"
+  VERSION = "2.2.1"
 end

data/lib/packwerk.rb

@@ -26,6 +26,7 @@ module Packwerk
   autoload :FilesForProcessing
   autoload :Graph
   autoload :Node
+  autoload :NodeHelpers
   autoload :NodeProcessor
   autoload :NodeProcessorFactory
   autoload :NodeVisitor

data/packwerk.gemspec

@@ -36,22 +36,15 @@ Gem::Specification.new do |spec|
   spec.files = Dir.chdir(__dir__) do
     %x(git ls-files -z).split("\x0").reject { |f| f.match(%r{^(test|spec|features|static)/}) }
   end
-  spec.require_paths = %w(lib)
+  spec.require_paths = ["lib"]
 
   spec.required_ruby_version = ">= 2.6"
 
   spec.add_dependency("activesupport", ">= 5.2")
-  spec.add_dependency("constant_resolver")
-  spec.add_dependency("parallel")
-  spec.add_dependency("sorbet-runtime")
   spec.add_dependency("bundler")
-  spec.add_dependency("digest")
-
-  spec.add_development_dependency("rake")
-  spec.add_development_dependency("sorbet")
-  spec.add_development_dependency("m")
-  # https://github.com/ruby/psych/pull/487
-  spec.add_development_dependency("psych", "~> 3")
+  spec.add_dependency("constant_resolver", ">= 0.2.0")
+  spec.add_dependency("parallel")
+  spec.add_dependency("sorbet-runtime", ">= 0.5.9914")
 
   # For Ruby parsing
   spec.add_dependency("ast")