packwerk 3.0.0 → 3.2.2

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,102 +58,115 @@ 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
-      delete_old_deprecated_references
-
-      if @new_entries.empty?
+      if new_entries.empty?
         delete_if_exists
       else
         prepare_entries_for_dump
         message = <<~MESSAGE
-          # This file contains a list of dependencies that are not part of the long term plan for #{@package.name}.
-          # We should generally work to reduce this list, but not at the expense of actually getting work done.
+          # This file contains a list of dependencies that are not part of the long term plan for the
+          # '#{@package.name}' package.
+          # We should generally work to reduce this list over time.
           #
           # You can regenerate this file using the following command:
           #
-          # bin/packwerk update-todo #{@package.name}
+          # 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 { 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)
+    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 { returns(EntriesType) }
+    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 = 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.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/parsers/factory.rb

@@ -24,7 +24,7 @@ module Packwerk
       def initialize
         @ruby_parser = T.let(nil, T.nilable(ParserInterface))
         @erb_parser = T.let(nil, T.nilable(ParserInterface))
-        @erb_parser_class = T.let(nil, T.nilable(Class))
+        @erb_parser_class = T.let(nil, T.nilable(T::Class[T.anything]))
       end
 
       sig { params(path: String).returns(T.nilable(ParserInterface)) }
@@ -37,12 +37,12 @@ module Packwerk
         end
       end
 
-      sig { returns(Class) }
+      sig { returns(T::Class[T.anything]) }
       def erb_parser_class
         @erb_parser_class ||= Erb
       end
 
-      sig { params(klass: T.nilable(Class)).void }
+      sig { params(klass: T.nilable(T::Class[T.anything])).void }
       def erb_parser_class=(klass)
         @erb_parser_class = klass
         @erb_parser = nil

data/lib/packwerk/parsers/ruby.rb

@@ -2,7 +2,7 @@
 # frozen_string_literal: true
 
 require "parser"
-require "parser/current"
+require "prism"
 
 module Packwerk
   module Parsers
@@ -11,7 +11,7 @@ module Packwerk
 
       include ParserInterface
 
-      class RaiseExceptionsParser < Parser::CurrentRuby
+      class RaiseExceptionsParser < Prism::Translation::Parser
         extend T::Sig
 
         sig { params(builder: T.untyped).void }
@@ -19,6 +19,13 @@ module Packwerk
           super(builder)
           super.diagnostics.all_errors_are_fatal = true
         end
+
+        private
+
+        sig { params(error: Prism::ParseError).returns(T::Boolean) }
+        def valid_error?(error)
+          error.type != :invalid_yield
+        end
       end
 
       class TolerateInvalidUtf8Builder < Parser::Builders::Default

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

@@ -47,9 +47,9 @@ module Packwerk
           EOS
         end
 
-        sig { override.params(listed_offense: ReferenceOffense).returns(T::Boolean) }
-        def strict_mode_violation?(listed_offense)
-          referencing_package = listed_offense.reference.package
+        sig { override.params(offense: ReferenceOffense).returns(T::Boolean) }
+        def strict_mode_violation?(offense)
+          referencing_package = offense.reference.package
           referencing_package.config["enforce_dependencies"] == "strict"
         end
 

data/lib/packwerk/reference_extractor.rb

@@ -80,7 +80,12 @@ module Packwerk
       constant_name = T.let(nil, T.nilable(String))
 
       @constant_name_inspectors.each do |inspector|
-        constant_name = inspector.constant_name_from_node(node, ancestors: ancestors)
+        constant_name = inspect_node(
+          inspector,
+          node: node,
+          ancestors: ancestors,
+          relative_file: relative_file
+        )
 
         break if constant_name
       end
@@ -97,6 +102,29 @@ module Packwerk
 
     private
 
+    sig do
+      params(
+        inspector: ConstantNameInspector,
+        node: Parser::AST::Node,
+        ancestors: T::Array[Parser::AST::Node],
+        relative_file: String
+      ).returns(T.nilable(String))
+    end
+    def inspect_node(inspector, node:, ancestors:, relative_file:)
+      inspector.constant_name_from_node(node, ancestors: ancestors, relative_file: relative_file)
+    rescue ArgumentError => error
+      if error.message == "unknown keyword: :relative_file"
+        T.unsafe(inspector).constant_name_from_node(node, ancestors: ancestors).tap do
+          warn(<<~MSG.squish)
+            #{T.cast(inspector, Object).class}#reference_from_node without a relative_file: keyword
+            argument is deprecated and will be required in Packwerk 3.1.1.
+          MSG
+        end
+      else
+        raise
+      end
+    end
+
     sig do
       params(
         constant_name: String,

data/lib/packwerk/reference_offense.rb

@@ -23,7 +23,7 @@ module Packwerk
         .void
     end
     def initialize(reference:, violation_type:, message:, location: nil)
-      super(file: reference.relative_path, message: message, location: location)
+      super(file: T.must(reference.relative_path), message: message, location: location)
       @reference = reference
       @violation_type = violation_type
     end

data/lib/packwerk/run_context.rb

@@ -15,14 +15,13 @@ module Packwerk
         params(configuration: Configuration).returns(RunContext)
       end
       def from_configuration(configuration)
-        inflector = ActiveSupport::Inflector
-
         new(
           root_path: configuration.root_path,
           load_paths: configuration.load_paths,
           package_paths: configuration.package_paths,
-          inflector: inflector,
+          inflector: ActiveSupport::Inflector,
           custom_associations: configuration.custom_associations,
+          associations_exclude: configuration.associations_exclude,
           cache_enabled: configuration.cache_enabled?,
           cache_directory: configuration.cache_directory,
           config_path: configuration.config_path,
@@ -39,6 +38,7 @@ module Packwerk
         config_path: T.nilable(String),
         package_paths: T.nilable(T.any(T::Array[String], String)),
         custom_associations: AssociationInspector::CustomAssociations,
+        associations_exclude: T::Array[String],
         checkers: T::Array[Checker],
         cache_enabled: T::Boolean,
       ).void
@@ -51,6 +51,7 @@ module Packwerk
       config_path: nil,
       package_paths: nil,
       custom_associations: [],
+      associations_exclude: [],
       checkers: Checker.all,
       cache_enabled: false
     )
@@ -59,6 +60,7 @@ module Packwerk
       @package_paths = package_paths
       @inflector = inflector
       @custom_associations = custom_associations
+      @associations_exclude = associations_exclude
       @checkers = checkers
       @cache_enabled = cache_enabled
       @cache_directory = cache_directory
@@ -128,9 +130,18 @@ module Packwerk
     def constant_name_inspectors
       [
         ConstNodeInspector.new,
-        AssociationInspector.new(inflector: @inflector, custom_associations: @custom_associations),
+        AssociationInspector.new(
+          inflector: @inflector,
+          custom_associations: @custom_associations,
+          excluded_files: relative_files_for_globs(@associations_exclude),
+        ),
       ]
     end
+
+    sig { params(relative_globs: T::Array[String]).returns(FilesForProcessing::RelativeFileSet) }
+    def relative_files_for_globs(relative_globs)
+      Set.new(relative_globs.flat_map { |glob| Dir[glob] })
+    end
   end
 
   private_constant :RunContext

data/lib/packwerk/spring_command.rb

@@ -33,5 +33,3 @@ module Packwerk
 
   Spring.register_command("packwerk", SpringCommand.new)
 end
-
-require "packwerk/disable_sorbet"

data/lib/packwerk/validator.rb

@@ -9,22 +9,36 @@ module Packwerk
   module Validator
     extend T::Sig
     extend T::Helpers
+    extend ActiveSupport::Autoload
+
+    autoload :Result
 
     abstract!
 
     class << self
       extend T::Sig
 
-      sig { params(base: Class).void }
+      sig { params(base: T::Class[T.anything]).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[T::Class[T.anything]]) }
+      def validators
+        @validators ||= T.let([], T.nilable(T::Array[T::Class[T.anything]]))
       end
     end
 

data/lib/packwerk/version.rb

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