[Discussion] Put files into buckets of responsibilities/seams

lib/packwerk/checking_references/checkers/README.md

@@ -0,0 +1,19 @@
+# Packwerk::Checkers
+
+- Checker implements `invalid_reference?(reference)`, which takes a `Packwerk::Reference` and returns Boolean.
+
+### Packwerk::Reference
+
+- It contains the information about source package and destination package.
+
+
+## Example: DependencyChecker
+
+- Dependency means any outgoing dependency from the source package.
+- If source package is enforcing dependency, it will check if declared dependency includes the destination package.
+
+
+## Example: PrivacyChecker
+
+- Privacy means any incoming dependency towards the destination package.
+- If destination package is enforcing privacy, it till check if source package references non-public constants.

lib/packwerk/configurations/README.md

@@ -0,0 +1,3 @@
+### Configurations
+
+Includes validators which are outside of primary `check` runs.

lib/packwerk/extracting_references/README.md

@@ -0,0 +1,4 @@
+# Extracting references
+
+- Given a `AST::Node`, this module extracts `Packwerk::Reference`.
+- `Packwerk::Reference` contains `constant` information, that are worked by `Inflector`.

lib/packwerk/file_processor.rb

@@ -4,6 +4,7 @@
 require "ast/node"
 
 module Packwerk
+  # from file path to node
   class FileProcessor
     class UnknownFileTypeResult < Offense
       def initialize(file:)
@@ -20,6 +21,7 @@ def call(file_path)
       parser = @parser_factory.for_path(file_path)
       return [UnknownFileTypeResult.new(file: file_path)] if parser.nil?
 
+      # path to node
       node = File.open(file_path, "r", external_encoding: Encoding::UTF_8) do |file|
         parser.call(io: file, file_path: file_path)
       rescue Parsers::ParseError => e
@@ -31,6 +33,7 @@ def call(file_path)
         node_processor = @node_processor_factory.for(filename: file_path, node: node)
         node_visitor = Packwerk::NodeVisitor.new(node_processor: node_processor)
 
+        # node to offence
         node_visitor.visit(node, ancestors: [], result: result)
       end
       result

lib/packwerk/node_processor.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 module Packwerk
+  # from node to reference to offence
   class NodeProcessor
     extend T::Sig
 

lib/packwerk/run_context.rb

@@ -4,6 +4,8 @@
 require "constant_resolver"
 
 module Packwerk
+  # Packwerk used to run as a part of Rubocop.
+  # Now that Packwerk is a standalone script, this structure shouldn't be necessary.
   class RunContext
     extend T::Sig
 
@@ -52,7 +54,48 @@ def initialize(
 
     sig { params(file: String).returns(T::Array[T.nilable(::Packwerk::Offense)]) }
     def process_file(file:)
-      file_processor.call(file)
+      # 1. file path to node
+      # It needs to return ancestors relative to node
+      node, ancestors = file_processor.call(file)
+
+      # Inside NodeProcessor - @reference_extractor.reference_from_node(node, ancestors: ancestors, file_path: @filename)
+      # 2. node to constant
+      @constant_name_inspectors.each do |inspector|
+        constant_name = inspector.constant_name_from_node(node, ancestors: ancestors)
+        break if constant_name
+      end
+
+      # Inside ReferenceExtractor - reference_from_constant(constant_name, node: node, ancestors: ancestors, file_path: file_path) if constant_name
+      # 3. constant to reference
+      namespace_path = Node.enclosing_namespace_path(node, ancestors: ancestors)
+      return if local_reference?(constant_name, Node.name_location(node), namespace_path)
+
+      constant =
+        @context_provider.context_for(
+          constant_name,
+          current_namespace_path: namespace_path
+        )
+      return if constant&.package.nil?
+
+      relative_path = Pathname.new(file_path).relative_path_from(@root_path).to_s
+
+      source_package = @context_provider.package_from_path(relative_path)
+      return if source_package == constant.package
+
+      Reference.new(source_package, relative_path, constant)
+
+      # Inside NodeProcessor
+      # 4. reference to an offence
+      @checkers.each_with_object([]) do |checker, violations|
+        next unless checker.invalid_reference?(reference)
+        offense = Packwerk::ReferenceOffense.new(
+          location: Node.location(node),
+          reference: reference,
+          violation_type: checker.violation_type
+        )
+        violations << offense
+      end
+
     end
 
     private