packwerk 3.0.1 → 3.1.0

data/lib/packwerk/package_todo.rb

@@ -7,16 +7,20 @@ module Packwerk
   class PackageTodo
     extend T::Sig
 
-    EntriesType = T.type_alias do
-      T::Hash[String, T.untyped]
+    PackageName = T.type_alias { String }
+    ConstantName = T.type_alias { String }
+    FilePath = T.type_alias { String }
+    Entry = T.type_alias { T::Hash[ConstantName, T::Hash[ConstantName, T::Array[FilePath]]] }
+    Entries = T.type_alias do
+      T::Hash[PackageName, Entry]
     end
 
-    sig { params(package: Packwerk::Package, filepath: String).void }
-    def initialize(package, filepath)
+    sig { params(package: Packwerk::Package, path: String).void }
+    def initialize(package, path)
       @package = package
-      @filepath = filepath
-      @new_entries = T.let({}, EntriesType)
-      @todo_list = T.let(nil, T.nilable(EntriesType))
+      @path = path
+      @new_entries = T.let({}, Entries)
+      @old_entries = T.let(nil, T.nilable(Entries))
     end
 
     sig do
@@ -24,7 +28,7 @@ module Packwerk
         .returns(T::Boolean)
     end
     def listed?(reference, violation_type:)
-      violated_constants_found = todo_list.dig(reference.constant.package.name, reference.constant.name)
+      violated_constants_found = old_entries.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)
@@ -37,16 +41,16 @@ module Packwerk
       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, {})
+      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
+      entries_for_constant.fetch("violations") << violation_type
 
       entries_for_constant["files"] ||= []
-      entries_for_constant["files"] << reference.relative_path.to_s
+      entries_for_constant.fetch("files") << reference.relative_path.to_s
 
-      @new_entries[reference.constant.package.name] = package_violations
+      new_entries[reference.constant.package.name] = package_violations
       listed?(reference, violation_type: violation_type)
     end
 
@@ -54,44 +58,22 @@ module Packwerk
     def stale_violations?(for_files)
       prepare_entries_for_dump
 
-      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"]
-          next if entries_for_files.none?
-
-          package_violations_for_files[constant_name] = {
-            "violations" => entries_for_constant["violations"],
-            "files" => entries_for_files.to_a,
-          }
-        end
+      old_entries.any? do |package, violations|
+        files = for_files + deleted_files_for(package)
+        violations_for_files = package_violations_for(violations, files: files)
 
         # 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")
-          # 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 =
-              entries_for_constant["files"] - Array(@new_entries.dig(package, constant_name, "files"))
-            stale_violations.any?
-          else
-            return true
-          end
-        end
+        next false if violations_for_files.empty?
+
+        stale_violation_for_package?(package, violations: violations_for_files)
       end
     end
 
     sig { void }
     def dump
-      if @new_entries.empty?
+      if new_entries.empty?
         delete_if_exists
       else
         prepare_entries_for_dump
@@ -104,45 +86,90 @@ module Packwerk
           #
           # bin/packwerk update-todo
         MESSAGE
-        File.open(@filepath, "w") do |f|
+        File.open(@path, "w") do |f|
           f.write(message)
-          f.write(@new_entries.to_yaml)
+          f.write(new_entries.to_yaml)
         end
       end
     end
 
     sig { void }
     def delete_if_exists
-      File.delete(@filepath) if File.exist?(@filepath)
+      File.delete(@path) if File.exist?(@path)
     end
 
     private
 
-    sig { returns(EntriesType) }
+    sig { returns(Entries) }
+    attr_reader(:new_entries)
+
+    sig { params(package: String).returns(T::Array[String]) }
+    def deleted_files_for(package)
+      old_files = old_entries.fetch(package, {}).values.flat_map { |violation| violation.fetch("files") }
+      new_files = new_entries.fetch(package, {}).values.flat_map { |violation| violation.fetch("files") }
+      old_files - new_files
+    end
+
+    sig { params(package: String, violations: Entry).returns(T::Boolean) }
+    def stale_violation_for_package?(package, violations:)
+      violations.any? do |constant_name, entries_for_constant|
+        new_entries_violation_types = T.cast(
+          new_entries.dig(package, constant_name, "violations"),
+          T.nilable(T::Array[String]),
+        )
+        # 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.fetch("violations").all? { |type| new_entries_violation_types.include?(type) }
+          stale_violations =
+            entries_for_constant.fetch("files") - Array(new_entries.dig(package, constant_name, "files"))
+          stale_violations.any?
+        else
+          return true
+        end
+      end
+    end
+
+    sig { params(package_violations: Entry, files: T::Set[String]).returns(Entry) }
+    def package_violations_for(package_violations, files:)
+      {}.tap do |package_violations_for_files|
+        package_violations_for_files = T.cast(package_violations_for_files, Entry)
+
+        package_violations.each do |constant_name, entries_for_constant|
+          entries_for_files = files & entries_for_constant.fetch("files")
+          next if entries_for_files.none?
+
+          package_violations_for_files[constant_name] = {
+            "violations" => entries_for_constant["violations"],
+            "files" => entries_for_files.to_a,
+          }
+        end
+      end
+    end
+
+    sig { returns(Entries) }
     def prepare_entries_for_dump
-      @new_entries.each do |package_name, package_violations|
+      new_entries.each do |package_name, package_violations|
         package_violations.each do |_, entries_for_constant|
-          entries_for_constant["violations"].sort!.uniq!
-          entries_for_constant["files"].sort!.uniq!
+          entries_for_constant.fetch("violations").sort!.uniq!
+          entries_for_constant.fetch("files").sort!.uniq!
         end
-        @new_entries[package_name] = package_violations.sort.to_h
+        new_entries[package_name] = package_violations.sort.to_h
       end
 
-      @new_entries = @new_entries.sort.to_h
+      @new_entries = new_entries.sort.to_h
     end
 
-    sig { returns(EntriesType) }
-    def todo_list
-      @todo_list ||= if File.exist?(@filepath)
-        load_yaml(@filepath)
-      else
-        {}
-      end
+    sig { returns(Entries) }
+    def old_entries
+      @old_entries ||= load_yaml_file(@path)
     end
 
-    sig { params(filepath: String).returns(EntriesType) }
-    def load_yaml(filepath)
-      YAML.load_file(filepath) || {}
+    sig { params(path: String).returns(Entries) }
+    def load_yaml_file(path)
+      File.exist?(path) && YAML.load_file(path) || {}
     rescue Psych::Exception
       {}
     end

data/lib/packwerk/parse_run.rb

@@ -14,93 +14,62 @@ module Packwerk
     sig do
       params(
         relative_file_set: FilesForProcessing::RelativeFileSet,
-        configuration: Configuration,
-        file_set_specified: T::Boolean,
-        offenses_formatter: T.nilable(OffensesFormatter),
-        progress_formatter: Formatters::ProgressFormatter,
+        parallel: T::Boolean,
       ).void
     end
-    def initialize(
-      relative_file_set:,
-      configuration:,
-      file_set_specified: false,
-      offenses_formatter: nil,
-      progress_formatter: Formatters::ProgressFormatter.new(StringIO.new)
-    )
-
-      @configuration = configuration
-      @progress_formatter = progress_formatter
-      @offenses_formatter = T.let(offenses_formatter || configuration.offenses_formatter, Packwerk::OffensesFormatter)
+    def initialize(relative_file_set:, parallel:)
       @relative_file_set = relative_file_set
-      @file_set_specified = file_set_specified
+      @parallel = parallel
     end
 
-    sig { returns(Cli::Result) }
-    def update_todo
-      if @file_set_specified
-        message = <<~MSG.squish
-          ⚠️ update-todo must be called without any file arguments.
-        MSG
-
-        return Cli::Result.new(message: message, status: false)
-      end
-
-      run_context = RunContext.from_configuration(@configuration)
-      offense_collection = find_offenses(run_context)
-      offense_collection.persist_package_todo_files(run_context.package_set)
-
-      message = <<~EOS
-        #{@offenses_formatter.show_offenses(offense_collection.errors)}
-        ✅ `package_todo.yml` has been updated.
-      EOS
-
-      Cli::Result.new(message: message, status: offense_collection.errors.empty?)
+    sig do
+      params(
+        run_context: RunContext,
+        on_interrupt: T.nilable(T.proc.void),
+        block: T.nilable(T.proc.params(
+          offenses: T::Array[Packwerk::Offense],
+        ).void)
+      ).returns(T::Array[Offense])
     end
+    def find_offenses(run_context, on_interrupt: nil, &block)
+      process_file_proc = process_file_proc(run_context, &block)
 
-    sig { returns(Cli::Result) }
-    def check
-      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.strict_mode_violations.empty?
+      offenses = if @parallel
+        Parallel.flat_map(@relative_file_set, &process_file_proc)
+      else
+        serial_find_offenses(on_interrupt: on_interrupt, &process_file_proc)
+      end
 
-      Cli::Result.new(message: messages.select(&:present?).join("\n") + "\n", status: result_status)
+      offenses
     end
 
     private
 
-    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)
-      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) }
-          update_progress(failed: failed)
-        end
-      end, ProcessFileProc)
-
-      @progress_formatter.started_inspection(@relative_file_set) do
-        all_offenses = if @configuration.parallel?
-          Parallel.flat_map(@relative_file_set, &process_file)
-        else
-          serial_find_offenses(&process_file)
-        end
+    sig do
+      params(
+        run_context: RunContext,
+        block: T.nilable(T.proc.params(offenses: T::Array[Offense]).void)
+      ).returns(ProcessFileProc)
+    end
+    def process_file_proc(run_context, &block)
+      if block
+        T.let(proc do |relative_file|
+          run_context.process_file(relative_file: relative_file).tap(&block)
+        end, ProcessFileProc)
+      else
+        T.let(proc do |relative_file|
+          run_context.process_file(relative_file: relative_file)
+        end, ProcessFileProc)
       end
-
-      all_offenses.each { |offense| offense_collection.add_offense(offense) }
-      offense_collection
     end
 
-    sig { params(block: ProcessFileProc).returns(T::Array[Offense]) }
-    def serial_find_offenses(&block)
+    sig do
+      params(
+        on_interrupt: T.nilable(T.proc.void),
+        block: ProcessFileProc
+      ).returns(T::Array[Offense])
+    end
+    def serial_find_offenses(on_interrupt: nil, &block)
       all_offenses = T.let([], T::Array[Offense])
       begin
         @relative_file_set.each do |relative_file|
@@ -108,20 +77,11 @@ module Packwerk
           all_offenses.concat(offenses)
         end
       rescue Interrupt
-        @progress_formatter.interrupted
+        on_interrupt&.call
         all_offenses
       end
       all_offenses
     end
-
-    sig { params(failed: T::Boolean).void }
-    def update_progress(failed: false)
-      if failed
-        @progress_formatter.mark_as_failed
-      else
-        @progress_formatter.mark_as_inspected
-      end
-    end
   end
 
   private_constant :ParseRun

data/lib/packwerk/validator.rb

@@ -9,6 +9,9 @@ module Packwerk
   module Validator
     extend T::Sig
     extend T::Helpers
+    extend ActiveSupport::Autoload
+
+    autoload :Result
 
     abstract!
 
@@ -17,14 +20,25 @@ module Packwerk
 
       sig { params(base: Class).void }
       def included(base)
-        @validators ||= T.let(@validators, T.nilable(T::Array[Class]))
-        @validators ||= []
-        @validators << base
+        validators << base
       end
 
       sig { returns(T::Array[Validator]) }
       def all
-        T.unsafe(@validators).map(&:new)
+        load_defaults
+        T.cast(validators.map(&:new), T::Array[Validator])
+      end
+
+      private
+
+      sig { void }
+      def load_defaults
+        require("packwerk/validators/dependency_validator")
+      end
+
+      sig { returns(T::Array[Class]) }
+      def validators
+        @validators ||= T.let([], T.nilable(T::Array[Class]))
       end
     end
 

data/lib/packwerk/version.rb

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

data/lib/packwerk.rb

@@ -18,6 +18,7 @@ module Packwerk
   autoload :Cli
   autoload :Configuration
   autoload :ConstantContext
+  autoload :Commands
   autoload :Node
   autoload :Offense
   autoload :OffenseCollection
@@ -32,12 +33,6 @@ module Packwerk
   autoload :ReferenceOffense
   autoload :Validator
 
-  class Cli
-    extend ActiveSupport::Autoload
-
-    autoload :Result
-  end
-
   module OutputStyles
     extend ActiveSupport::Autoload
 
@@ -45,20 +40,17 @@ module Packwerk
     autoload :Plain
   end
 
-  autoload_under "commands" do
-    autoload :OffenseProgressMarker
-  end
-
   module Formatters
     extend ActiveSupport::Autoload
 
+    autoload :DefaultOffensesFormatter
     autoload :ProgressFormatter
   end
 
-  module Validator
+  module Validators
     extend ActiveSupport::Autoload
 
-    autoload :Result
+    autoload :DependencyValidator
   end
 
   # Private APIs
@@ -101,26 +93,10 @@ module Packwerk
       extend ActiveSupport::Autoload
 
       autoload :DependencyChecker
-      autoload :PrivacyChecker
     end
   end
 
   private_constant :ReferenceChecking
-
-  class ApplicationValidator
-    extend ActiveSupport::Autoload
-
-    autoload :Helpers
-  end
 end
 
 require "packwerk/version"
-
-# Required to register the DefaultOffensesFormatter
-# We put this at the *end* of the file to specify all autoloads first
-require "packwerk/formatters/default_offenses_formatter"
-
-# Required to register the default DependencyChecker
-require "packwerk/reference_checking/checkers/dependency_checker"
-# Required to register the default DependencyValidator
-require "packwerk/validators/dependency_validator"