packwerk 2.2.2 → 3.0.0

data/lib/packwerk/node_processor.rb

@@ -29,4 +29,6 @@ module Packwerk
       @reference_extractor.reference_from_node(node, ancestors: ancestors, relative_file: @relative_file)
     end
   end
+
+  private_constant :NodeProcessor
 end

data/lib/packwerk/node_processor_factory.rb

@@ -6,12 +6,12 @@ module Packwerk
     extend T::Sig
 
     const :root_path, String
-    const :context_provider, Packwerk::ConstantDiscovery
+    const :context_provider, ConstantDiscovery
     const :constant_name_inspectors, T::Array[ConstantNameInspector]
 
     sig { params(relative_file: String, node: AST::Node).returns(NodeProcessor) }
     def for(relative_file:, node:)
-      ::Packwerk::NodeProcessor.new(
+      NodeProcessor.new(
         reference_extractor: reference_extractor(node: node),
         relative_file: relative_file,
       )
@@ -19,13 +19,15 @@ module Packwerk
 
     private
 
-    sig { params(node: AST::Node).returns(::Packwerk::ReferenceExtractor) }
+    sig { params(node: AST::Node).returns(ReferenceExtractor) }
     def reference_extractor(node:)
-      ::Packwerk::ReferenceExtractor.new(
+      ReferenceExtractor.new(
         constant_name_inspectors: constant_name_inspectors,
         root_node: node,
         root_path: root_path,
       )
     end
   end
+
+  private_constant :NodeProcessorFactory
 end

data/lib/packwerk/node_visitor.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module Packwerk
@@ -11,6 +11,13 @@ module Packwerk
       @node_processor = node_processor
     end
 
+    sig do
+      params(
+        node: Parser::AST::Node,
+        ancestors: T::Array[Parser::AST::Node],
+        result: T::Array[UnresolvedReference],
+      ).void
+    end
     def visit(node, ancestors:, result:)
       reference = @node_processor.call(node, ancestors)
       result << reference if reference
@@ -21,4 +28,6 @@ module Packwerk
       end
     end
   end
+
+  private_constant :NodeVisitor
 end

data/lib/packwerk/offense_collection.rb

@@ -1,6 +1,8 @@
 # typed: strict
 # frozen_string_literal: true
 
+require "pathname"
+
 module Packwerk
   class OffenseCollection
     extend T::Sig
@@ -9,13 +11,14 @@ module Packwerk
     sig do
       params(
         root_path: String,
-        deprecated_references: T::Hash[Packwerk::Package, Packwerk::DeprecatedReferences]
+        package_todo: T::Hash[Packwerk::Package, Packwerk::PackageTodo]
       ).void
     end
-    def initialize(root_path, deprecated_references = {})
+    def initialize(root_path, package_todo = {})
       @root_path = root_path
-      @deprecated_references = T.let(deprecated_references, T::Hash[Packwerk::Package, Packwerk::DeprecatedReferences])
+      @package_todo = T.let(package_todo, T::Hash[Packwerk::Package, Packwerk::PackageTodo])
       @new_violations = T.let([], T::Array[Packwerk::ReferenceOffense])
+      @strict_mode_violations = T.let([], T::Array[Packwerk::ReferenceOffense])
       @errors = T.let([], T::Array[Packwerk::Offense])
     end
 
@@ -25,6 +28,9 @@ module Packwerk
     sig { returns(T::Array[Packwerk::Offense]) }
     attr_reader :errors
 
+    sig { returns(T::Array[Packwerk::ReferenceOffense]) }
+    attr_reader :strict_mode_violations
+
     sig do
       params(offense: Packwerk::Offense)
         .returns(T::Boolean)
@@ -33,7 +39,7 @@ module Packwerk
       return false unless offense.is_a?(ReferenceOffense)
 
       reference = offense.reference
-      deprecated_references_for(reference.source_package).listed?(reference, violation_type: offense.violation_type)
+      package_todo_for(reference.package).listed?(reference, violation_type: offense.violation_type)
     end
 
     sig do
@@ -44,23 +50,25 @@ module Packwerk
         @errors << offense
         return
       end
-      deprecated_references = deprecated_references_for(offense.reference.source_package)
-      unless deprecated_references.add_entries(offense.reference, offense.violation_type)
+
+      if !already_listed?(offense)
         new_violations << offense
+      elsif strict_mode_violation?(offense)
+        strict_mode_violations << offense
       end
     end
 
     sig { params(for_files: T::Set[String]).returns(T::Boolean) }
     def stale_violations?(for_files)
-      @deprecated_references.values.any? do |deprecated_references|
-        deprecated_references.stale_violations?(for_files)
+      @package_todo.values.any? do |package_todo|
+        package_todo.stale_violations?(for_files)
       end
     end
 
     sig { params(package_set: Packwerk::PackageSet).void }
-    def persist_deprecated_references_files(package_set)
-      dump_deprecated_references_files
-      cleanup_extra_deprecated_references_files(package_set)
+    def persist_package_todo_files(package_set)
+      dump_package_todo_files
+      cleanup_extra_package_todo_files(package_set)
     end
 
     sig { returns(T::Array[Packwerk::Offense]) }
@@ -70,34 +78,46 @@ module Packwerk
 
     private
 
+    sig { params(offense: ReferenceOffense).returns(T::Boolean) }
+    def already_listed?(offense)
+      package_todo_for(offense.reference.package).add_entries(offense.reference,
+        offense.violation_type)
+    end
+
+    sig { params(offense: ReferenceOffense).returns(T::Boolean) }
+    def strict_mode_violation?(offense)
+      checker = Checker.find(offense.violation_type)
+      checker.strict_mode_violation?(offense)
+    end
+
     sig { params(package_set: Packwerk::PackageSet).void }
-    def cleanup_extra_deprecated_references_files(package_set)
-      packages_without_todos = (package_set.packages.values - @deprecated_references.keys)
+    def cleanup_extra_package_todo_files(package_set)
+      packages_without_todos = (package_set.packages.values - @package_todo.keys)
 
       packages_without_todos.each do |package|
-        Packwerk::DeprecatedReferences.new(
+        Packwerk::PackageTodo.new(
           package,
-          deprecated_references_file_for(package),
+          package_todo_file_for(package),
         ).delete_if_exists
       end
     end
 
     sig { void }
-    def dump_deprecated_references_files
-      @deprecated_references.each_value(&:dump)
+    def dump_package_todo_files
+      @package_todo.each_value(&:dump)
     end
 
-    sig { params(package: Packwerk::Package).returns(Packwerk::DeprecatedReferences) }
-    def deprecated_references_for(package)
-      @deprecated_references[package] ||= Packwerk::DeprecatedReferences.new(
+    sig { params(package: Packwerk::Package).returns(Packwerk::PackageTodo) }
+    def package_todo_for(package)
+      @package_todo[package] ||= Packwerk::PackageTodo.new(
         package,
-        deprecated_references_file_for(package),
+        package_todo_file_for(package),
       )
     end
 
     sig { params(package: Packwerk::Package).returns(String) }
-    def deprecated_references_file_for(package)
-      File.join(@root_path, package.name, "deprecated_references.yml")
+    def package_todo_file_for(package)
+      File.join(@root_path, package.name, "package_todo.yml")
     end
   end
 end

data/lib/packwerk/offenses_formatter.rb

@@ -6,14 +6,71 @@ module Packwerk
     extend T::Sig
     extend T::Helpers
 
-    interface!
+    abstract!
+
+    class DuplicateFormatterError < StandardError
+      extend T::Sig
+
+      sig { params(identifier: String).void }
+      def initialize(identifier)
+        super("Cannot have multiple identifiers with the same key (`#{identifier}`)")
+      end
+    end
+
+    class << self
+      extend T::Sig
+
+      sig { params(base: Class).void }
+      def included(base)
+        @offenses_formatters ||= T.let(@offenses_formatters, T.nilable(T::Array[Class]))
+        @offenses_formatters ||= []
+        @offenses_formatters << base
+      end
+
+      sig { returns(T::Array[OffensesFormatter]) }
+      def all
+        T.unsafe(@offenses_formatters).map(&:new)
+      end
+
+      sig { params(identifier: String).returns(OffensesFormatter) }
+      def find(identifier)
+        formatter_by_identifier(identifier)
+      end
+
+      private
+
+      sig { params(name: String).returns(OffensesFormatter) }
+      def formatter_by_identifier(name)
+        @formatter_by_identifier ||= T.let(nil, T.nilable(T::Hash[String, T.nilable(OffensesFormatter)]))
+        @formatter_by_identifier ||= begin
+          index = T.let({}, T::Hash[String, T.nilable(OffensesFormatter)])
+          OffensesFormatter.all.each do |formatter|
+            identifier = formatter.identifier
+            raise DuplicateFormatterError, identifier if index.key?(identifier)
+
+            index[identifier] = formatter
+          end
+          T.let(index, T.nilable(T::Hash[String, T.nilable(OffensesFormatter)]))
+        end
+
+        T.must(T.must(@formatter_by_identifier)[name])
+      end
+    end
 
     sig { abstract.params(offenses: T::Array[T.nilable(Offense)]).returns(String) }
     def show_offenses(offenses)
     end
 
-    sig { abstract.params(offense_collection: Packwerk::OffenseCollection, for_files: T::Set[String]).returns(String) }
+    sig { abstract.params(offense_collection: OffenseCollection, for_files: T::Set[String]).returns(String) }
     def show_stale_violations(offense_collection, for_files)
     end
+
+    sig { abstract.returns(String) }
+    def identifier
+    end
+
+    sig { abstract.params(strict_mode_violations: T::Array[ReferenceOffense]).returns(String) }
+    def show_strict_mode_violations(strict_mode_violations)
+    end
   end
 end

data/lib/packwerk/package.rb

@@ -17,22 +17,20 @@ module Packwerk
     sig { returns(T::Array[String]) }
     attr_reader :dependencies
 
-    sig { params(name: String, config: T.nilable(T.any(T::Hash[T.untyped, T.untyped], FalseClass))).void }
-    def initialize(name:, config:)
+    sig { returns(T::Hash[T.untyped, T.untyped]) }
+    attr_reader :config
+
+    sig { params(name: String, config: T.nilable(T::Hash[String, T.untyped])).void }
+    def initialize(name:, config: nil)
       @name = name
-      @config = T.let(config || {}, T::Hash[T.untyped, T.untyped])
+      @config = T.let(config || {}, T::Hash[String, 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]))) }
-    def enforce_privacy
-      @config["enforce_privacy"]
-    end
-
     sig { returns(T::Boolean) }
     def enforce_dependencies?
-      @config["enforce_dependencies"] == true
+      [true, "strict"].include?(@config["enforce_dependencies"])
     end
 
     sig { params(package: Package).returns(T::Boolean) }
@@ -47,32 +45,6 @@ module Packwerk
       path.start_with?(@name)
     end
 
-    sig { returns(String) }
-    def public_path
-      @public_path ||= begin
-        unprefixed_public_path = user_defined_public_path || "app/public/"
-
-        if root?
-          unprefixed_public_path
-        else
-          File.join(@name, unprefixed_public_path)
-        end
-      end
-    end
-
-    sig { params(path: String).returns(T::Boolean) }
-    def public_path?(path)
-      path.start_with?(public_path)
-    end
-
-    sig { returns(T.nilable(String)) }
-    def user_defined_public_path
-      return unless @config["public_path"]
-      return @config["public_path"] if @config["public_path"].end_with?("/")
-
-      @config["public_path"] + "/"
-    end
-
     sig { params(other: T.untyped).returns(T.nilable(Integer)) }
     def <=>(other)
       return nil unless other.is_a?(self.class)

data/lib/packwerk/package_set.rb

@@ -26,7 +26,7 @@ module Packwerk
 
         packages = package_paths.map do |path|
           root_relative = path.dirname.relative_path_from(root_path)
-          Package.new(name: root_relative.to_s, config: YAML.load_file(path))
+          Package.new(name: root_relative.to_s, config: YAML.load_file(path, fallback: nil))
         end
 
         create_root_package_if_none_in(packages)

data/lib/packwerk/{deprecated_references.rb → package_todo.rb}

@@ -4,7 +4,7 @@
 require "yaml"
 
 module Packwerk
-  class DeprecatedReferences
+  class PackageTodo
     extend T::Sig
 
     EntriesType = T.type_alias do
@@ -16,30 +16,32 @@ module Packwerk
       @package = package
       @filepath = filepath
       @new_entries = T.let({}, EntriesType)
-      @deprecated_references = T.let(nil, T.nilable(EntriesType))
+      @todo_list = T.let(nil, T.nilable(EntriesType))
     end
 
     sig do
-      params(reference: Packwerk::Reference, violation_type: ViolationType)
+      params(reference: Packwerk::Reference, violation_type: String)
         .returns(T::Boolean)
     end
     def listed?(reference, violation_type:)
-      violated_constants_found = deprecated_references.dig(reference.constant.package.name, reference.constant.name)
+      violated_constants_found = todo_list.dig(reference.constant.package.name, reference.constant.name)
       return false unless violated_constants_found
 
       violated_constant_in_file = violated_constants_found.fetch("files", []).include?(reference.relative_path)
       return false unless violated_constant_in_file
 
-      violated_constants_found.fetch("violations", []).include?(violation_type.serialize)
+      violated_constants_found.fetch("violations", []).include?(violation_type)
     end
 
-    sig { params(reference: Packwerk::Reference, violation_type: Packwerk::ViolationType).returns(T::Boolean) }
+    sig do
+      params(reference: Packwerk::Reference, violation_type: String).returns(T::Boolean)
+    end
     def add_entries(reference, violation_type)
       package_violations = @new_entries.fetch(reference.constant.package.name, {})
       entries_for_constant = package_violations[reference.constant.name] ||= {}
 
       entries_for_constant["violations"] ||= []
-      entries_for_constant["violations"] << violation_type.serialize
+      entries_for_constant["violations"] << violation_type
 
       entries_for_constant["files"] ||= []
       entries_for_constant["files"] << reference.relative_path.to_s
@@ -52,7 +54,7 @@ module Packwerk
     def stale_violations?(for_files)
       prepare_entries_for_dump
 
-      deprecated_references.any? do |package, package_violations|
+      todo_list.any? do |package, package_violations|
         package_violations_for_files = {}
         package_violations.each do |constant_name, entries_for_constant|
           entries_for_files = for_files & entries_for_constant["files"]
@@ -64,11 +66,17 @@ module Packwerk
           }
         end
 
-        return true if package_violations_for_files.empty?
+        # We `next false` because if we cannot find existing violations for `for_files` within
+        # the `package_todo.yml` file, then there are no violations that
+        # can be considered stale.
+        next false if package_violations_for_files.empty?
 
         package_violations_for_files.any? do |constant_name, entries_for_constant|
           new_entries_violation_types = @new_entries.dig(package, constant_name, "violations")
-          return true if new_entries_violation_types.nil?
+          # If there are no NEW entries that match the old entries `for_files`,
+          # @new_entries is from the list of violations we get when we check this file.
+          # If this list is empty, we also must have stale violations.
+          next true if new_entries_violation_types.nil?
 
           if entries_for_constant["violations"].all? { |type| new_entries_violation_types.include?(type) }
             stale_violations =
@@ -83,6 +91,8 @@ module Packwerk
 
     sig { void }
     def dump
+      delete_old_deprecated_references
+
       if @new_entries.empty?
         delete_if_exists
       else
@@ -93,7 +103,7 @@ module Packwerk
           #
           # You can regenerate this file using the following command:
           #
-          # bin/packwerk update-deprecations #{@package.name}
+          # bin/packwerk update-todo #{@package.name}
         MESSAGE
         File.open(@filepath, "w") do |f|
           f.write(message)
@@ -109,6 +119,12 @@ module Packwerk
 
     private
 
+    sig { void }
+    def delete_old_deprecated_references
+      deprecated_references_filepath = File.join(File.dirname(@filepath), "deprecated_references.yml")
+      File.delete(deprecated_references_filepath) if File.exist?(deprecated_references_filepath)
+    end
+
     sig { returns(EntriesType) }
     def prepare_entries_for_dump
       @new_entries.each do |package_name, package_violations|
@@ -123,8 +139,8 @@ module Packwerk
     end
 
     sig { returns(EntriesType) }
-    def deprecated_references
-      @deprecated_references ||= if File.exist?(@filepath)
+    def todo_list
+      @todo_list ||= if File.exist?(@filepath)
         load_yaml(@filepath)
       else
         {}

data/lib/packwerk/parse_run.rb

@@ -1,7 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "benchmark"
 require "parallel"
 
 module Packwerk
@@ -16,77 +15,71 @@ module Packwerk
       params(
         relative_file_set: FilesForProcessing::RelativeFileSet,
         configuration: Configuration,
+        file_set_specified: T::Boolean,
+        offenses_formatter: T.nilable(OffensesFormatter),
         progress_formatter: Formatters::ProgressFormatter,
-        offenses_formatter: OffensesFormatter,
       ).void
     end
     def initialize(
       relative_file_set:,
       configuration:,
-      progress_formatter: Formatters::ProgressFormatter.new(StringIO.new),
-      offenses_formatter: Formatters::OffensesFormatter.new
+      file_set_specified: false,
+      offenses_formatter: nil,
+      progress_formatter: Formatters::ProgressFormatter.new(StringIO.new)
     )
+
       @configuration = configuration
       @progress_formatter = progress_formatter
-      @offenses_formatter = offenses_formatter
+      @offenses_formatter = T.let(offenses_formatter || configuration.offenses_formatter, Packwerk::OffensesFormatter)
       @relative_file_set = relative_file_set
+      @file_set_specified = file_set_specified
     end
 
-    sig { returns(Result) }
-    def detect_stale_violations
-      warn(<<~WARNING.squish)
-        DEPRECATION WARNING: `detect-stale-violation` is deprecated,
-        the output of `check` includes stale references.
-      WARNING
-
-      run_context = Packwerk::RunContext.from_configuration(@configuration)
-      offense_collection = find_offenses(run_context)
+    sig { returns(Cli::Result) }
+    def update_todo
+      if @file_set_specified
+        message = <<~MSG.squish
+          ⚠️ update-todo must be called without any file arguments.
+        MSG
 
-      result_status = !offense_collection.stale_violations?(@relative_file_set)
-      message = @offenses_formatter.show_stale_violations(offense_collection, @relative_file_set)
-
-      Result.new(message: message, status: result_status)
-    end
+        return Cli::Result.new(message: message, status: false)
+      end
 
-    sig { returns(Result) }
-    def update_deprecations
-      run_context = Packwerk::RunContext.from_configuration(@configuration)
+      run_context = RunContext.from_configuration(@configuration)
       offense_collection = find_offenses(run_context)
-      offense_collection.persist_deprecated_references_files(run_context.package_set)
+      offense_collection.persist_package_todo_files(run_context.package_set)
 
       message = <<~EOS
         #{@offenses_formatter.show_offenses(offense_collection.errors)}
-        ✅ `deprecated_references.yml` has been updated.
+        ✅ `package_todo.yml` has been updated.
       EOS
 
-      Result.new(message: message, status: offense_collection.errors.empty?)
+      Cli::Result.new(message: message, status: offense_collection.errors.empty?)
     end
 
-    sig { returns(Result) }
+    sig { returns(Cli::Result) }
     def check
-      run_context = Packwerk::RunContext.from_configuration(@configuration)
+      run_context = RunContext.from_configuration(@configuration)
       offense_collection = find_offenses(run_context, show_errors: true)
 
       messages = [
         @offenses_formatter.show_offenses(offense_collection.outstanding_offenses),
         @offenses_formatter.show_stale_violations(offense_collection, @relative_file_set),
+        @offenses_formatter.show_strict_mode_violations(offense_collection.strict_mode_violations),
       ]
 
       result_status = offense_collection.outstanding_offenses.empty? &&
-        !offense_collection.stale_violations?(@relative_file_set)
+        !offense_collection.stale_violations?(@relative_file_set) && offense_collection.strict_mode_violations.empty?
 
-      Result.new(message: messages.join("\n") + "\n", status: result_status)
+      Cli::Result.new(message: messages.select(&:present?).join("\n") + "\n", status: result_status)
     end
 
     private
 
-    sig { params(run_context: Packwerk::RunContext, show_errors: T::Boolean).returns(OffenseCollection) }
+    sig { params(run_context: RunContext, show_errors: T::Boolean).returns(OffenseCollection) }
     def find_offenses(run_context, show_errors: false)
       offense_collection = OffenseCollection.new(@configuration.root_path)
-      @progress_formatter.started(@relative_file_set)
-
       all_offenses = T.let([], T::Array[Offense])
-
       process_file = T.let(->(relative_file) do
         run_context.process_file(relative_file: relative_file).tap do |offenses|
           failed = show_errors && offenses.any? { |offense| !offense_collection.listed?(offense) }
@@ -94,7 +87,7 @@ module Packwerk
         end
       end, ProcessFileProc)
 
-      execution_time = Benchmark.realtime do
+      @progress_formatter.started_inspection(@relative_file_set) do
         all_offenses = if @configuration.parallel?
           Parallel.flat_map(@relative_file_set, &process_file)
         else
@@ -102,8 +95,6 @@ module Packwerk
         end
       end
 
-      @progress_formatter.finished(execution_time)
-
       all_offenses.each { |offense| offense_collection.add_offense(offense) }
       offense_collection
     end
@@ -132,4 +123,6 @@ module Packwerk
       end
     end
   end
+
+  private_constant :ParseRun
 end