packwerk 2.0.0 → 2.2.0

data/lib/packwerk/node.rb

@@ -5,7 +5,7 @@ require "parser"
 require "parser/ast/node"
 
 module Packwerk
-  # Convenience methods for working with AST nodes.
+  # Convenience methods for working with Parser::AST::Node nodes.
   module Node
     class TypeError < ArgumentError; end
     Location = Struct.new(:line, :column)
@@ -264,6 +264,7 @@ module Packwerk
         # "Class.new"
         # "Module.new"
         method_call?(node) &&
+          receiver(node) &&
           constant?(receiver(node)) &&
           ["Class", "Module"].include?(constant_name(receiver(node))) &&
           method_name(node) == :new

data/lib/packwerk/node_processor.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module Packwerk
@@ -9,23 +9,23 @@ module Packwerk
     sig do
       params(
         reference_extractor: ReferenceExtractor,
-        filename: String,
+        absolute_file: String,
       ).void
     end
-    def initialize(reference_extractor:, filename:)
+    def initialize(reference_extractor:, absolute_file:)
       @reference_extractor = reference_extractor
-      @filename = filename
+      @absolute_file = absolute_file
     end
 
     sig do
       params(
         node: Parser::AST::Node,
         ancestors: T::Array[Parser::AST::Node]
-      ).returns(T.nilable(Packwerk::Reference))
+      ).returns(T.nilable(UnresolvedReference))
     end
     def call(node, ancestors)
       return unless Node.method_call?(node) || Node.constant?(node)
-      @reference_extractor.reference_from_node(node, ancestors: ancestors, file_path: @filename)
+      @reference_extractor.reference_from_node(node, ancestors: ancestors, absolute_file: @absolute_file)
     end
   end
 end

data/lib/packwerk/node_processor_factory.rb

@@ -9,11 +9,11 @@ module Packwerk
     const :context_provider, Packwerk::ConstantDiscovery
     const :constant_name_inspectors, T::Array[ConstantNameInspector]
 
-    sig { params(filename: String, node: AST::Node).returns(NodeProcessor) }
-    def for(filename:, node:)
+    sig { params(absolute_file: String, node: AST::Node).returns(NodeProcessor) }
+    def for(absolute_file:, node:)
       ::Packwerk::NodeProcessor.new(
         reference_extractor: reference_extractor(node: node),
-        filename: filename,
+        absolute_file: absolute_file,
       )
     end
 
@@ -22,7 +22,6 @@ module Packwerk
     sig { params(node: AST::Node).returns(::Packwerk::ReferenceExtractor) }
     def reference_extractor(node:)
       ::Packwerk::ReferenceExtractor.new(
-        context_provider: context_provider,
         constant_name_inspectors: constant_name_inspectors,
         root_node: node,
         root_path: root_path,

data/lib/packwerk/node_visitor.rb

@@ -4,6 +4,9 @@
 module Packwerk
   # Visits all nodes of an AST, processing them using a given node processor.
   class NodeVisitor
+    extend T::Sig
+
+    sig { params(node_processor: NodeProcessor).void }
     def initialize(node_processor:)
       @node_processor = node_processor
     end

data/lib/packwerk/offense.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "parser/source/map"
@@ -8,7 +8,14 @@ module Packwerk
     extend T::Sig
     extend T::Helpers
 
-    attr_reader :location, :file, :message
+    sig { returns(T.nilable(Node::Location)) }
+    attr_reader :location
+
+    sig { returns(String) }
+    attr_reader :file
+
+    sig { returns(String) }
+    attr_reader :message
 
     sig do
       params(file: String, message: String, location: T.nilable(Node::Location))
@@ -22,6 +29,7 @@ module Packwerk
 
     sig { params(style: OutputStyle).returns(String) }
     def to_s(style = OutputStyles::Plain.new)
+      location = self.location
       if location
         <<~EOS
           #{style.filename}#{file}#{style.reset}:#{location.line}:#{location.column}

data/lib/packwerk/package.rb

@@ -21,6 +21,7 @@ module Packwerk
       @name = name
       @config = T.let(config || {}, T::Hash[T.untyped, T.untyped])
       @dependencies = T.let(Array(@config["dependencies"]).freeze, T::Array[String])
+      @public_path = T.let(nil, T.nilable(String))
     end
 
     sig { returns(T.nilable(T.any(T::Boolean, T::Array[String]))) }
@@ -46,7 +47,6 @@ module Packwerk
 
     sig { returns(String) }
     def public_path
-      @public_path = T.let(@public_path, T.nilable(String))
       @public_path ||= begin
         unprefixed_public_path = user_defined_public_path || "app/public/"
 

data/lib/packwerk/package_set.rb

@@ -12,7 +12,7 @@ module Packwerk
     extend T::Generic
     include Enumerable
 
-    Elem = type_member(fixed: Package)
+    Elem = type_member { { fixed: Package } }
 
     PACKAGE_CONFIG_FILENAME = "package.yml"
 
@@ -79,6 +79,7 @@ module Packwerk
       sorted_packages = packages.sort_by { |package| -package.name.length }
       packages = sorted_packages.each_with_object({}) { |package, hash| hash[package.name] = package }
       @packages = T.let(packages, T::Hash[String, Package])
+      @package_from_path = T.let({}, T::Hash[String, T.nilable(Package)])
     end
 
     sig { override.params(blk: T.proc.params(arg0: Package).returns(T.untyped)).returns(T.untyped) }
@@ -91,10 +92,10 @@ module Packwerk
       packages[name]
     end
 
-    sig { params(file_path: T.any(Pathname, String)).returns(T.nilable(Package)) }
+    sig { params(file_path: T.any(Pathname, String)).returns(Package) }
     def package_from_path(file_path)
       path_string = file_path.to_s
-      packages.values.find { |package| package.package_path?(path_string) }
+      @package_from_path[path_string] ||= T.must(packages.values.find { |package| package.package_path?(path_string) })
     end
   end
 end

data/lib/packwerk/parse_run.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "benchmark"
@@ -8,8 +8,20 @@ module Packwerk
   class ParseRun
     extend T::Sig
 
+    ProcessFileProc = T.type_alias do
+      T.proc.params(path: String).returns(T::Array[Offense])
+    end
+
+    sig do
+      params(
+        absolute_file_set: FilesForProcessing::AbsoluteFileSet,
+        configuration: Configuration,
+        progress_formatter: Formatters::ProgressFormatter,
+        offenses_formatter: OffensesFormatter,
+      ).void
+    end
     def initialize(
-      files:,
+      absolute_file_set:,
       configuration:,
       progress_formatter: Formatters::ProgressFormatter.new(StringIO.new),
       offenses_formatter: Formatters::OffensesFormatter.new
@@ -17,9 +29,10 @@ module Packwerk
       @configuration = configuration
       @progress_formatter = progress_formatter
       @offenses_formatter = offenses_formatter
-      @files = files
+      @absolute_file_set = absolute_file_set
     end
 
+    sig { returns(Result) }
     def detect_stale_violations
       offense_collection = find_offenses
 
@@ -29,6 +42,7 @@ module Packwerk
       Result.new(message: message, status: result_status)
     end
 
+    sig { returns(Result) }
     def update_deprecations
       offense_collection = find_offenses
       offense_collection.dump_deprecated_references_files
@@ -41,6 +55,7 @@ module Packwerk
       Result.new(message: message, status: offense_collection.errors.empty?)
     end
 
+    sig { returns(Result) }
     def check
       offense_collection = find_offenses(show_errors: true)
 
@@ -55,23 +70,24 @@ module Packwerk
 
     private
 
+    sig { params(show_errors: T::Boolean).returns(OffenseCollection) }
     def find_offenses(show_errors: false)
       offense_collection = OffenseCollection.new(@configuration.root_path)
-      @progress_formatter.started(@files)
+      @progress_formatter.started(@absolute_file_set)
 
       run_context = Packwerk::RunContext.from_configuration(@configuration)
-      all_offenses = T.let([], T.untyped)
+      all_offenses = T.let([], T::Array[Offense])
 
-      process_file = -> (path) do
-        run_context.process_file(file: path).tap do |offenses|
+      process_file = T.let(-> (absolute_file) do
+        run_context.process_file(absolute_file: absolute_file).tap do |offenses|
           failed = show_errors && offenses.any? { |offense| !offense_collection.listed?(offense) }
           update_progress(failed: failed)
         end
-      end
+      end, ProcessFileProc)
 
       execution_time = Benchmark.realtime do
         all_offenses = if @configuration.parallel?
-          Parallel.flat_map(@files, &process_file)
+          Parallel.flat_map(@absolute_file_set, &process_file)
         else
           serial_find_offenses(&process_file)
         end
@@ -83,18 +99,22 @@ module Packwerk
       offense_collection
     end
 
-    def serial_find_offenses
-      all_offenses = T.let([], T.untyped)
-      @files.each do |path|
-        offenses = yield path
-        all_offenses.concat(offenses)
+    sig { params(block: ProcessFileProc).returns(T::Array[Offense]) }
+    def serial_find_offenses(&block)
+      all_offenses = T.let([], T::Array[Offense])
+      begin
+        @absolute_file_set.each do |absolute_file|
+          offenses = block.call(absolute_file)
+          all_offenses.concat(offenses)
+        end
+      rescue Interrupt
+        @progress_formatter.interrupted
+        all_offenses
       end
       all_offenses
-    rescue Interrupt
-      @progress_formatter.interrupted
-      all_offenses
     end
 
+    sig { params(failed: T::Boolean).void }
     def update_progress(failed: false)
       if failed
         @progress_formatter.mark_as_failed

data/lib/packwerk/parsed_constant_definitions.rb

@@ -25,13 +25,13 @@ module Packwerk
     def self.reference_qualifications(constant_name, namespace_path:)
       return [constant_name] if constant_name.start_with?("::")
 
-      fully_qualified_constant_name = "::#{constant_name}"
+      resolved_constant_name = "::#{constant_name}"
 
       possible_namespaces = namespace_path.each_with_object([""]) do |current, acc|
         acc << "#{acc.last}::#{current}" if acc.last && current
       end
 
-      possible_namespaces.map { |namespace| namespace + fully_qualified_constant_name }
+      possible_namespaces.map { |namespace| namespace + resolved_constant_name }
     end
 
     private
@@ -53,9 +53,9 @@ module Packwerk
     end
 
     def add_definition(constant_name, current_namespace_path, location)
-      fully_qualified_constant = [""].concat(current_namespace_path).push(constant_name).join("::")
+      resolved_constant = [""].concat(current_namespace_path).push(constant_name).join("::")
 
-      @local_definitions[fully_qualified_constant] = location
+      @local_definitions[resolved_constant] = location
     end
   end
 end

data/lib/packwerk/parsers/erb.rb

@@ -9,6 +9,8 @@ require "parser/source/buffer"
 module Packwerk
   module Parsers
     class Erb
+      include ParserInterface
+
       def initialize(parser_class: BetterHtml::Parser, ruby_parser: Ruby.new)
         @parser_class = parser_class
         @ruby_parser = ruby_parser

data/lib/packwerk/parsers/factory.rb

@@ -6,6 +6,7 @@ require "singleton"
 module Packwerk
   module Parsers
     class Factory
+      extend T::Sig
       include Singleton
 
       RUBY_REGEX = %r{
@@ -19,6 +20,7 @@ module Packwerk
       ERB_REGEX = /\.erb\Z/
       private_constant :ERB_REGEX
 
+      sig { params(path: String).returns(T.nilable(ParserInterface)) }
       def for_path(path)
         case path
         when RUBY_REGEX

data/lib/packwerk/parsers/parser_interface.rb

@@ -0,0 +1,19 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Packwerk
+  module Parsers
+    module ParserInterface
+      extend T::Helpers
+      extend T::Sig
+
+      requires_ancestor { Kernel }
+
+      interface!
+
+      sig { abstract.params(io: File, file_path: String).returns(T.untyped) }
+      def call(io:, file_path:)
+      end
+    end
+  end
+end

data/lib/packwerk/parsers/ruby.rb

@@ -7,6 +7,8 @@ require "parser/current"
 module Packwerk
   module Parsers
     class Ruby
+      include ParserInterface
+
       class RaiseExceptionsParser < Parser::CurrentRuby
         def initialize(builder)
           super(builder)

data/lib/packwerk/parsers.rb

@@ -5,6 +5,7 @@ module Packwerk
   module Parsers
     autoload :Erb, "packwerk/parsers/erb"
     autoload :Factory, "packwerk/parsers/factory"
+    autoload :ParserInterface, "packwerk/parsers/parser_interface"
     autoload :Ruby, "packwerk/parsers/ruby"
 
     class ParseResult < Offense; end

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

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module Packwerk

data/lib/packwerk/reference_checking/reference_checker.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module Packwerk
@@ -6,18 +6,17 @@ module Packwerk
     class ReferenceChecker
       extend T::Sig
 
+      sig { params(checkers: T::Array[Checkers::Checker]).void }
       def initialize(checkers)
         @checkers = checkers
       end
 
       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(

data/lib/packwerk/reference_extractor.rb

@@ -8,58 +8,110 @@ module Packwerk
 
     sig do
       params(
-        context_provider: Packwerk::ConstantDiscovery,
         constant_name_inspectors: T::Array[Packwerk::ConstantNameInspector],
         root_node: ::AST::Node,
         root_path: String,
       ).void
     end
     def initialize(
-      context_provider:,
       constant_name_inspectors:,
       root_node:,
       root_path:
     )
-      @context_provider = context_provider
       @constant_name_inspectors = constant_name_inspectors
       @root_path = root_path
       @local_constant_definitions = ParsedConstantDefinitions.new(root_node: root_node)
     end
 
-    def reference_from_node(node, ancestors:, file_path:)
+    sig do
+      params(
+        node: Parser::AST::Node,
+        ancestors: T::Array[Parser::AST::Node],
+        absolute_file: String
+      ).returns(T.nilable(UnresolvedReference))
+    end
+    def reference_from_node(node, ancestors:, absolute_file:)
       constant_name = T.let(nil, T.nilable(String))
 
       @constant_name_inspectors.each do |inspector|
         constant_name = inspector.constant_name_from_node(node, ancestors: ancestors)
+
         break if constant_name
       end
 
-      reference_from_constant(constant_name, node: node, ancestors: ancestors, file_path: file_path) if constant_name
+      if constant_name
+        reference_from_constant(
+          constant_name,
+          node: node,
+          ancestors: ancestors,
+          absolute_file: absolute_file
+        )
+      end
     end
 
-    private
+    sig do
+      params(
+        unresolved_references: T::Array[UnresolvedReference],
+        context_provider: ConstantDiscovery
+      ).returns(T::Array[Reference])
+    end
+    def self.get_fully_qualified_references_from(unresolved_references, context_provider)
+      fully_qualified_references = T.let([], T::Array[Reference])
 
-    def reference_from_constant(constant_name, node:, ancestors:, file_path:)
-      namespace_path = Node.enclosing_namespace_path(node, ancestors: ancestors)
-      return if local_reference?(constant_name, Node.name_location(node), namespace_path)
+      unresolved_references.each do |unresolved_references_or_offense|
+        unresolved_reference = unresolved_references_or_offense
 
-      constant =
-        @context_provider.context_for(
-          constant_name,
-          current_namespace_path: namespace_path
+        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
 
-      return if constant&.package.nil?
+      fully_qualified_references
+    end
 
-      relative_path =
-        Pathname.new(file_path)
-          .relative_path_from(@root_path).to_s
+    private
 
-      source_package = @context_provider.package_from_path(relative_path)
+    sig do
+      params(
+        constant_name: String,
+        node: Parser::AST::Node,
+        ancestors: T::Array[Parser::AST::Node],
+        absolute_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)
 
-      return if source_package == constant.package
+      return if local_reference?(constant_name, Node.name_location(node), namespace_path)
 
-      Reference.new(source_package, relative_path, constant, Node.location(node))
+      relative_file = Pathname.new(absolute_file).relative_path_from(@root_path).to_s
+      location = Node.location(node)
+
+      UnresolvedReference.new(
+        constant_name,
+        namespace_path,
+        relative_file,
+        location
+      )
     end
 
     def local_reference?(constant_name, name_location, namespace_path)

data/lib/packwerk/reference_offense.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module Packwerk
@@ -7,7 +7,11 @@ module Packwerk
     extend T::Sig
     extend T::Helpers
 
-    attr_reader :reference, :violation_type
+    sig { returns(Reference) }
+    attr_reader :reference
+
+    sig { returns(ViolationType) }
+    attr_reader :violation_type
 
     sig do
       params(
@@ -25,10 +29,11 @@ module Packwerk
 
     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 ? "'#{reference.source_package}'" : "here"
+        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?"

data/lib/packwerk/result.rb

@@ -3,7 +3,7 @@
 
 module Packwerk
   class Result < T::Struct
-    prop :message, String
-    prop :status, T::Boolean
+    const :message, String
+    const :status, T::Boolean
   end
 end