danger-packwerk 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ed0f4ec91fc454370224df9823a43b198bbb3172fa996ac426975bf28d5e5cd8
-  data.tar.gz: '0398f5c8ed12c82a0ed23b32e055463bac58a9797800c5aac1f115afa8bf811a'
+  metadata.gz: 3338a7622d64fc169f9ef273873bc11002ff56ba3d66b225189f0dc1bd6b6cf9
+  data.tar.gz: 58cb63b3956cf29245575e8be453280c33041b3ce15579c2102d07819c836c26
 SHA512:
-  metadata.gz: 1b20096b8a326a153832e24d73ddf4beab32220c65b035d44ca6ac2baa8f0bb043bcacba294e710c1000934d936410f59f61a7547fe304edd094cfb26f32fbc0
-  data.tar.gz: e1948eab25e12d87c03ef56054c8a981ca6e92ded648f05b0c38b28495d12ac5808cf6c453949f4f3d453ae79862bf5acb740e974f1146fac383144d41d59469
+  metadata.gz: 31aab3fcdb5c3bb7837214ac46fae8807fcfa9727d9a3d21a4d371c8c8de4db688c13ff486e7e9660ec552f7aa39cbd1c622338e8b88ae087f226362804e8097
+  data.tar.gz: fba5ddd5b2d9ed86b3173b1aca8562ba523dcd74c974d45570edc07853ac5c4819bf3c64956ca10a037b800db056853cb38097ce422fa79eb2983ab297ea9890

data/lib/danger-packwerk/basic_reference_offense.rb

@@ -45,7 +45,8 @@ module DangerPackwerk
     def self.from(deprecated_references_yml)
       deprecated_references_yml_pathname = Pathname.new(deprecated_references_yml)
 
-      from_package_name = T.must(ParsePackwerk.package_from_path(deprecated_references_yml_pathname)).name
+      from_package = ParsePackwerk.package_from_path(deprecated_references_yml_pathname)
+      from_package_name = from_package.name
       violations = Private::DeprecatedReferences.from(deprecated_references_yml_pathname).violations
 
       # See the larger comment below for more information on why we need this information.

data/lib/danger-packwerk/danger_deprecated_references_yml_changes.rb

@@ -45,14 +45,7 @@ module DangerPackwerk
 
       current_comment_count = 0
 
-      # The format for git.renamed_files is a T::Array[{after: "some/path/new", before: "some/path/old"}]
-      renamed_files = git.renamed_files.map { |before_after_file| before_after_file[:after] }
-
-      violations_to_comment_on = violation_diff.added_violations.reject do |violation|
-        renamed_files.include?(violation.file)
-      end
-
-      violations_to_comment_on.group_by(&:class_name).each do |_class_name, violations|
+      violation_diff.added_violations.group_by(&:class_name).each do |_class_name, violations|
         break if current_comment_count >= max_comments
 
         location = T.must(violations.first).file_location
@@ -92,8 +85,36 @@ module DangerPackwerk
         removed_violations += base_commit_violations - head_commit_violations
       end
 
+      # The format for git.renamed_files is a T::Array[{after: "some/path/new", before: "some/path/old"}]
+      renamed_files = git.renamed_files.map { |before_after_file| before_after_file[:after] }
+
+      #
+      # This implementation creates some false negatives:
+      # That is – it doesn't capture some cases:
+      # 1) A file has been renamed without renaming a constant.
+      # That can happen if we change only the autoloaded portion of a filename.
+      # For example: `packs/foo/app/services/my_class.rb` (defines: `MyClass`)
+      # is changed to `packs/foo/app/public/my_class.rb` (still defines: `MyClass`)
+      #
+      # This implementation also doesn't cover these false positives:
+      # That is – it leaves a comment when it should not.
+      # 1) A CONSTANT within a class or module has been renamed.
+      # e.g. `class MyClass; MY_CONSTANT = 1; end` becomes `class MyClass; RENAMED_CONSTANT = 1; end`
+      # We would not detect based on file renames that `MY_CONSTANT` has been renamed.
+      #
+      renamed_constants = []
+
+      added_violations.each do |violation|
+        filepath_that_defines_this_constant = Private.constant_resolver.resolve(violation.class_name)&.location
+        renamed_constants << violation.class_name if renamed_files.include?(filepath_that_defines_this_constant)
+      end
+
+      relevant_added_violations = added_violations.reject do |violation|
+        renamed_files.include?(violation.file) || renamed_constants.include?(violation.class_name)
+      end
+
       ViolationDiff.new(
-        added_violations: added_violations,
+        added_violations: relevant_added_violations,
         removed_violations: removed_violations
       )
     end

data/lib/danger-packwerk/danger_packwerk.rb

@@ -84,14 +84,23 @@ module DangerPackwerk
 
       packwerk_reference_offenses = PackwerkWrapper.get_offenses_for_files(targeted_files.to_a).compact
 
+      renamed_files = git.renamed_files.map { |before_after_file| before_after_file[:after] }
+
+      # Ignore references that have been renamed
+      packwerk_reference_offenses_to_care_about = packwerk_reference_offenses.reject do |packwerk_reference_offense|
+        constant_name = packwerk_reference_offense.reference.constant.name
+        filepath_that_defines_this_constant = Private.constant_resolver.resolve(constant_name)&.location
+        renamed_files.include?(filepath_that_defines_this_constant)
+      end
+
       # We group by the constant name, line number, and reference path. Any offenses with these same values should only differ on what type of violation
       # they are (privacy or dependency). We put privacy and dependency violation messages in the same comment since they would occur on the same line.
-      packwerk_reference_offenses.group_by do |packwerk_reference_offense|
+      packwerk_reference_offenses_to_care_about.group_by do |packwerk_reference_offense|
         case grouping_strategy
         when CommentGroupingStrategy::PerConstantPerLocation
           [
             packwerk_reference_offense.reference.constant.name,
-            packwerk_reference_offense.location.line,
+            packwerk_reference_offense.location&.line,
             packwerk_reference_offense.reference.relative_path
           ]
         when CommentGroupingStrategy::PerConstantPerPack
@@ -108,7 +117,7 @@ module DangerPackwerk
         current_comment_count += 1
 
         reference_offense = T.must(unique_packwerk_reference_offenses.first)
-        line_number = reference_offense.location.line
+        line_number = reference_offense.location&.line
         referencing_file = reference_offense.reference.relative_path
 
         message = offenses_formatter.call(unique_packwerk_reference_offenses)

data/lib/danger-packwerk/private.rb

@@ -1,13 +1,27 @@
-# typed: strong
+# typed: strict
 
 require 'danger-packwerk/private/deprecated_references'
 require 'danger-packwerk/private/default_offenses_formatter'
+require 'constant_resolver'
 
 module DangerPackwerk
   #
   # Anything within the Private module is subject to change.
   #
   module Private
+    extend T::Sig
+
+    sig { returns(ConstantResolver) }
+    def self.constant_resolver
+      @constant_resolver = T.let(@constant_resolver, T.nilable(ConstantResolver))
+      @constant_resolver ||= begin
+        load_paths = Packwerk::ApplicationLoadPaths.extract_relevant_paths(Dir.pwd, 'test')
+        ConstantResolver.new(
+          root_path: Dir.pwd,
+          load_paths: T.unsafe(load_paths).keys
+        )
+      end
+    end
   end
 
   private_constant :Private

data/lib/danger-packwerk/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module DangerPackwerk
-  VERSION = '0.5.0'
+  VERSION = '0.6.0'
 end

data/sorbet/rbi/gems/constant_resolver@0.2.0.rbi

@@ -0,0 +1,30 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `constant_resolver` gem.
+# Please instead update this file by running `bin/tapioca gem constant_resolver`.
+
+class ConstantResolver
+  def initialize(root_path:, load_paths:, inflector: T.unsafe(nil)); end
+
+  def config; end
+  def file_map; end
+  def resolve(const_name, current_namespace_path: T.unsafe(nil)); end
+
+  private
+
+  def ambiguous_constant_message(const_name, paths); end
+  def coerce_load_paths(load_paths); end
+  def glob_path(path); end
+  def resolve_constant(const_name, current_namespace_path, original_name: T.unsafe(nil)); end
+  def resolve_traversing_namespace_path(const_name, current_namespace_path); end
+end
+
+class ConstantResolver::ConstantContext < ::Struct; end
+
+class ConstantResolver::DefaultInflector
+  def camelize(string); end
+end
+
+class ConstantResolver::Error < ::StandardError; end
+ConstantResolver::VERSION = T.let(T.unsafe(nil), String)

data/sorbet/rbi/gems/{packwerk@1.3.2.rbi → packwerk@2.1.1.rbi}

@@ -38,60 +38,153 @@ module Packwerk::ApplicationLoadPaths
 end
 
 class Packwerk::ApplicationValidator
+  sig { params(config_file_path: ::String, configuration: ::Packwerk::Configuration, environment: ::String).void }
   def initialize(config_file_path:, configuration:, environment:); end
 
+  sig { returns(::Packwerk::ApplicationValidator::Result) }
   def check_acyclic_graph; end
+
+  sig { returns(::Packwerk::ApplicationValidator::Result) }
   def check_all; end
+
+  sig { returns(::Packwerk::ApplicationValidator::Result) }
   def check_application_structure; end
-  def check_autoload_path_cache; end
-  def check_inflection_file; end
+
+  sig { returns(::Packwerk::ApplicationValidator::Result) }
   def check_package_manifest_paths; end
+
+  sig { returns(::Packwerk::ApplicationValidator::Result) }
   def check_package_manifest_syntax; end
+
+  sig { returns(::Packwerk::ApplicationValidator::Result) }
   def check_package_manifests_for_privacy; end
+
+  sig { returns(::Packwerk::ApplicationValidator::Result) }
   def check_root_package_exists; end
+
+  sig { returns(::Packwerk::ApplicationValidator::Result) }
   def check_valid_package_dependencies; end
 
   private
 
-  def assert_constants_can_be_loaded(constants); end
+  sig do
+    params(
+      constants: T.untyped,
+      config_file_path: ::String
+    ).returns(T::Array[::Packwerk::ApplicationValidator::Result])
+  end
+  def assert_constants_can_be_loaded(constants, config_file_path); end
+
+  sig { params(cycles: T.untyped).returns(T::Array[::String]) }
   def build_cycle_strings(cycles); end
+
+  sig do
+    params(
+      name: T.untyped,
+      location: T.untyped,
+      config_file_path: T.untyped
+    ).returns(::Packwerk::ApplicationValidator::Result)
+  end
   def check_private_constant_location(name, location, config_file_path); end
+
+  sig { params(list: T.untyped).returns(T.untyped) }
   def format_yaml_strings(list); end
+
+  sig { params(path: T.untyped).returns(T::Boolean) }
   def invalid_package_path?(path); end
+
+  sig do
+    params(
+      results: T::Array[::Packwerk::ApplicationValidator::Result],
+      separator: ::String,
+      errors_headline: ::String
+    ).returns(::Packwerk::ApplicationValidator::Result)
+  end
   def merge_results(results, separator: T.unsafe(nil), errors_headline: T.unsafe(nil)); end
+
+  sig { returns(T.any(::String, T::Array[::String])) }
   def package_glob; end
+
+  sig { params(glob_pattern: T.any(::String, T::Array[::String])).returns(T::Array[::String]) }
   def package_manifests(glob_pattern = T.unsafe(nil)); end
+
+  sig { params(setting: T.untyped).returns(T.untyped) }
   def package_manifests_settings_for(setting); end
-  def package_set; end
+
+  sig { params(name: T.untyped, config_file_path: T.untyped).returns(::Packwerk::ApplicationValidator::Result) }
   def private_constant_unresolvable(name, config_file_path); end
+
+  sig { params(path: ::String).returns(::Pathname) }
   def relative_path(path); end
+
+  sig { params(paths: T::Array[::String]).returns(T::Array[::Pathname]) }
   def relative_paths(paths); end
 end
 
-class Packwerk::ApplicationValidator::Result < ::Struct
-  def error_value; end
-  def error_value=(_); end
+class Packwerk::ApplicationValidator::Result < ::T::Struct
+  const :error_value, T.nilable(::String)
+  const :ok, T::Boolean
+
+  sig { returns(T::Boolean) }
   def ok?; end
 
   class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
+    def inherited(s); end
   end
 end
 
 Packwerk::AssociationInspector::CustomAssociations = T.type_alias { T.any(T::Array[::Symbol], T::Set[::Symbol]) }
 Packwerk::AssociationInspector::RAILS_ASSOCIATIONS = T.let(T.unsafe(nil), Set)
 
-module Packwerk::Checker
-  interface!
+class Packwerk::Cache
+  sig { params(enable_cache: T::Boolean, cache_directory: ::Pathname, config_path: T.nilable(::String)).void }
+  def initialize(enable_cache:, cache_directory:, config_path:); end
 
-  sig { abstract.params(reference: ::Packwerk::Reference).returns(T::Boolean) }
-  def invalid_reference?(reference); end
+  sig { void }
+  def bust_cache!; end
 
-  sig { abstract.returns(::Packwerk::ViolationType) }
-  def violation_type; end
+  sig { params(contents: ::String, contents_key: ::Symbol).void }
+  def bust_cache_if_contents_have_changed(contents, contents_key); end
+
+  sig { void }
+  def bust_cache_if_inflections_have_changed!; end
+
+  sig { void }
+  def bust_cache_if_packwerk_yml_has_changed!; end
+
+  sig { void }
+  def create_cache_directory!; end
+
+  sig { params(file: ::String).returns(::String) }
+  def digest_for_file(file); end
+
+  sig { params(str: ::String).returns(::String) }
+  def digest_for_string(str); end
+
+  sig do
+    params(
+      file_path: ::String,
+      block: T.proc.returns(T::Array[::Packwerk::UnresolvedReference])
+    ).returns(T::Array[::Packwerk::UnresolvedReference])
+  end
+  def with_cache(file_path, &block); end
+end
+
+Packwerk::Cache::CACHE_SHAPE = T.type_alias { T::Hash[::String, ::Packwerk::Cache::CacheContents] }
+
+class Packwerk::Cache::CacheContents < ::T::Struct
+  const :file_contents_digest, ::String
+  const :unresolved_references, T::Array[::Packwerk::UnresolvedReference]
+
+  sig { returns(::String) }
+  def serialize; end
+
+  class << self
+    sig { params(serialized_cache_contents: ::String).returns(::Packwerk::Cache::CacheContents) }
+    def deserialize(serialized_cache_contents); end
+
+    def inherited(s); end
+  end
 end
 
 class Packwerk::Cli
@@ -115,24 +208,45 @@ class Packwerk::Cli
 
   private
 
-  def fetch_files_to_process(paths); end
+  sig { returns(::Packwerk::ApplicationValidator) }
+  def checker; end
+
+  sig do
+    params(
+      relative_file_paths: T::Array[::String],
+      ignore_nested_packages: T::Boolean
+    ).returns(T::Array[::String])
+  end
+  def fetch_files_to_process(relative_file_paths, ignore_nested_packages); end
+
+  sig { returns(T::Boolean) }
   def generate_configs; end
+
+  sig { returns(T::Boolean) }
   def init; end
+
+  sig { params(result: ::Packwerk::ApplicationValidator::Result).void }
   def list_validation_errors(result); end
+
+  sig { params(result: ::Packwerk::Result).returns(T::Boolean) }
   def output_result(result); end
-  def parse_run(paths); end
-  def update(paths); end
+
+  sig { params(params: T.untyped).returns(::Packwerk::ParseRun) }
+  def parse_run(params); end
+
+  sig { params(_paths: T::Array[::String]).returns(T::Boolean) }
   def validate(_paths); end
 end
 
 class Packwerk::Configuration
   def initialize(configs = T.unsafe(nil), config_path: T.unsafe(nil)); end
 
+  def cache_directory; end
+  def cache_enabled?; end
   def config_path; end
   def custom_associations; end
   def exclude; end
   def include; end
-  def inflections_file; end
   def load_paths; end
   def package_paths; end
   def parallel?; end
@@ -152,9 +266,18 @@ Packwerk::Configuration::DEFAULT_EXCLUDE_GLOBS = T.let(T.unsafe(nil), Array)
 Packwerk::Configuration::DEFAULT_INCLUDE_GLOBS = T.let(T.unsafe(nil), Array)
 
 class Packwerk::ConstantDiscovery
+  sig { params(constant_resolver: ::ConstantResolver, packages: Packwerk::PackageSet).void }
   def initialize(constant_resolver:, packages:); end
 
+  sig do
+    params(
+      const_name: ::String,
+      current_namespace_path: T.nilable(T::Array[::String])
+    ).returns(T.nilable(::Packwerk::ConstantDiscovery::ConstantContext))
+  end
   def context_for(const_name, current_namespace_path: T.unsafe(nil)); end
+
+  sig { params(path: ::String).returns(::Packwerk::Package) }
   def package_from_path(path); end
 end
 
@@ -175,14 +298,11 @@ class Packwerk::ConstantDiscovery::ConstantContext < ::Struct
   end
 end
 
-class Packwerk::DependencyChecker
-  include ::Packwerk::Checker
-
-  sig { override.params(reference: ::Packwerk::Reference).returns(T::Boolean) }
-  def invalid_reference?(reference); end
-
-  sig { override.returns(::Packwerk::ViolationType) }
-  def violation_type; end
+class Packwerk::Debug
+  class << self
+    sig { params(out: ::String).void }
+    def out(out); end
+  end
 end
 
 class Packwerk::DeprecatedReferences
@@ -203,41 +323,62 @@ class Packwerk::DeprecatedReferences
 
   private
 
-  sig { returns(T::Hash[T.untyped, T.untyped]) }
+  sig { returns(T::Hash[::String, T.untyped]) }
   def deprecated_references; end
 
-  sig { params(filepath: ::String).returns(T::Hash[T.untyped, T.untyped]) }
+  sig { params(filepath: ::String).returns(T::Hash[::String, T.untyped]) }
   def load_yaml(filepath); end
 
-  sig { returns(T::Hash[T.untyped, T.untyped]) }
+  sig { returns(T::Hash[::String, T.untyped]) }
   def prepare_entries_for_dump; end
 end
 
-class Packwerk::FileProcessor
-  def initialize(node_processor_factory:, parser_factory: T.unsafe(nil)); end
-
-  def call(file_path); end
-end
+Packwerk::DeprecatedReferences::ENTRIES_TYPE = T.type_alias { T::Hash[::String, T.untyped] }
 
 class Packwerk::FileProcessor::UnknownFileTypeResult < ::Packwerk::Offense
+  sig { params(file: ::String).void }
   def initialize(file:); end
 end
 
 class Packwerk::FilesForProcessing
-  def initialize(paths, configuration); end
+  sig do
+    params(
+      relative_file_paths: T::Array[::String],
+      configuration: ::Packwerk::Configuration,
+      ignore_nested_packages: T::Boolean
+    ).void
+  end
+  def initialize(relative_file_paths, configuration, ignore_nested_packages); end
 
+  sig { returns(T::Array[::String]) }
   def files; end
 
   private
 
+  sig { params(relative_globs: T::Array[::String]).returns(T::Array[::String]) }
+  def absolute_files_for_globs(relative_globs); end
+
+  sig { returns(T::Array[::String]) }
   def configured_excluded_files; end
+
+  sig { returns(T::Array[::String]) }
   def configured_included_files; end
+
+  sig { returns(T::Array[::String]) }
   def custom_files; end
-  def custom_included_files(path); end
-  def files_for_globs(globs); end
+
+  sig { params(absolute_file_path: ::String).returns(T::Array[::String]) }
+  def custom_included_files(absolute_file_path); end
 
   class << self
-    def fetch(paths:, configuration:); end
+    sig do
+      params(
+        relative_file_paths: T::Array[::String],
+        configuration: ::Packwerk::Configuration,
+        ignore_nested_packages: T::Boolean
+      ).returns(T::Array[::String])
+    end
+    def fetch(relative_file_paths:, configuration:, ignore_nested_packages: T.unsafe(nil)); end
   end
 end
 
@@ -281,8 +422,8 @@ module Packwerk::Generators
 end
 
 class Packwerk::Generators::ConfigurationFile
-  sig { params(load_paths: T::Array[::String], root: ::String, out: T.any(::IO, ::StringIO)).void }
-  def initialize(load_paths:, root:, out: T.unsafe(nil)); end
+  sig { params(root: ::String, out: T.any(::IO, ::StringIO)).void }
+  def initialize(root:, out: T.unsafe(nil)); end
 
   sig { returns(T::Boolean) }
   def generate; end
@@ -290,27 +431,15 @@ class Packwerk::Generators::ConfigurationFile
   private
 
   def render; end
-  def set_template_variables; end
   def template; end
 
   class << self
-    def generate(load_paths:, root:, out:); end
+    def generate(root:, out:); end
   end
 end
 
 Packwerk::Generators::ConfigurationFile::CONFIGURATION_TEMPLATE_FILE_PATH = T.let(T.unsafe(nil), String)
 
-class Packwerk::Generators::InflectionsFile
-  def initialize(root, out: T.unsafe(nil)); end
-
-  sig { returns(T::Boolean) }
-  def generate; end
-
-  class << self
-    def generate(root:, out:); end
-  end
-end
-
 class Packwerk::Generators::RootPackage
   def initialize(root:, out: T.unsafe(nil)); end
 
@@ -337,77 +466,7 @@ class Packwerk::Graph
   def visit(node, visited_nodes: T.unsafe(nil), path: T.unsafe(nil)); end
 end
 
-module Packwerk::Inflections
-end
-
-class Packwerk::Inflections::Custom
-  def initialize(custom_inflection_file = T.unsafe(nil)); end
-
-  def apply_to(inflections_object); end
-  def inflections; end
-  def inflections=(_arg0); end
-end
-
-Packwerk::Inflections::Custom::SUPPORTED_INFLECTION_METHODS = T.let(T.unsafe(nil), Array)
-
-module Packwerk::Inflections::Default
-  class << self
-    def apply_to(inflections_object); end
-  end
-end
-
-class Packwerk::Inflector
-  sig { params(custom_inflector: ::Packwerk::Inflections::Custom).void }
-  def initialize(custom_inflector:); end
-
-  def inflections(_ = T.unsafe(nil)); end
-  def pluralize(word, count = T.unsafe(nil)); end
-
-  class << self
-    def default; end
-
-    sig { params(inflections_file: ::String).returns(::Packwerk::Inflector) }
-    def from_file(inflections_file); end
-  end
-end
-
 module Packwerk::Node
-  class << self
-    def class?(node); end
-    def class_or_module_name(class_or_module_node); end
-    def constant?(node); end
-    def constant_assignment?(node); end
-    def constant_name(constant_node); end
-    def each_child(node); end
-    def enclosing_namespace_path(starting_node, ancestors:); end
-    def hash?(node); end
-    def literal_value(string_or_symbol_node); end
-    def location(node); end
-    def method_arguments(method_call_node); end
-    def method_call?(node); end
-    def method_name(method_call_node); end
-    def module_name_from_definition(node); end
-    def name_location(node); end
-    def parent_class(class_node); end
-
-    def parent_module_name(ancestors:); end
-
-    def string?(node); end
-    def symbol?(node); end
-    def value_from_hash(hash_node, key); end
-
-    private
-
-    def hash_pair_key(hash_pair_node); end
-    def hash_pair_value(hash_pair_node); end
-    def hash_pairs(hash_node); end
-    def method_call_node(block_node); end
-    def module_creation?(node); end
-    def name_from_block_definition(node); end
-    def name_part_from_definition(node); end
-    def receiver(method_call_or_block_node); end
-    def type_of(node); end
-  end
 end
 
 class Packwerk::Node::Location < ::Struct
@@ -426,7 +485,11 @@ end
 
 class Packwerk::Node::TypeError < ::ArgumentError; end
 
+class Packwerk::NodeProcessor
+end
+
 class Packwerk::NodeVisitor
+  sig { params(node_processor: ::Packwerk::NodeProcessor).void }
   def initialize(node_processor:); end
 
   def visit(node, ancestors:, result:); end
@@ -436,8 +499,13 @@ class Packwerk::Offense
   sig { params(file: ::String, message: ::String, location: T.nilable(::Packwerk::Node::Location)).void }
   def initialize(file:, message:, location: T.unsafe(nil)); end
 
+  sig { returns(::String) }
   def file; end
+
+  sig { returns(T.nilable(::Packwerk::Node::Location)) }
   def location; end
+
+  sig { returns(::String) }
   def message; end
 
   sig { params(style: ::Packwerk::OutputStyle).returns(::String) }
@@ -538,61 +606,143 @@ end
 class Packwerk::Package
   include ::Comparable
 
+  sig { params(name: ::String, config: T.nilable(T.any(::FalseClass, T::Hash[T.untyped, T.untyped]))).void }
   def initialize(name:, config:); end
 
+  sig { params(other: T.untyped).returns(T.nilable(::Integer)) }
   def <=>(other); end
+
+  sig { returns(T::Array[::String]) }
   def dependencies; end
+
+  sig { params(package: ::Packwerk::Package).returns(T::Boolean) }
   def dependency?(package); end
+
+  sig { returns(T::Boolean) }
   def enforce_dependencies?; end
+
+  sig { returns(T.nilable(T.any(T::Array[::String], T::Boolean))) }
   def enforce_privacy; end
+
+  sig { params(other: T.untyped).returns(T::Boolean) }
   def eql?(other); end
+
+  sig { returns(::Integer) }
   def hash; end
+
+  sig { returns(::String) }
   def name; end
+
+  sig { params(path: ::String).returns(T::Boolean) }
   def package_path?(path); end
+
+  sig { returns(::String) }
   def public_path; end
+
+  sig { params(path: ::String).returns(T::Boolean) }
   def public_path?(path); end
+
+  sig { returns(T::Boolean) }
   def root?; end
+
+  sig { returns(::String) }
   def to_s; end
+
+  sig { returns(T.nilable(::String)) }
   def user_defined_public_path; end
 end
 
 Packwerk::Package::ROOT_PACKAGE_NAME = T.let(T.unsafe(nil), String)
 
 class Packwerk::PackageSet
+  extend T::Generic
   include ::Enumerable
 
+  Elem = type_member(fixed: Packwerk::Package)
+
+  sig { params(packages: T::Array[::Packwerk::Package]).void }
   def initialize(packages); end
 
+  sig { override.params(blk: T.proc.params(arg0: ::Packwerk::Package).returns(T.untyped)).returns(T.untyped) }
   def each(&blk); end
+
+  sig { params(name: ::String).returns(T.nilable(::Packwerk::Package)) }
   def fetch(name); end
+
+  sig { params(file_path: T.any(::Pathname, ::String)).returns(::Packwerk::Package) }
   def package_from_path(file_path); end
 
+  sig { returns(T::Hash[::String, ::Packwerk::Package]) }
+  def packages; end
+
   class << self
+    sig do
+      params(
+        root_path: ::String,
+        package_pathspec: T.nilable(T.any(::String, T::Array[::String]))
+      ).returns(Packwerk::PackageSet)
+    end
     def load_all_from(root_path, package_pathspec: T.unsafe(nil)); end
-    def package_paths(root_path, package_pathspec); end
+
+    sig do
+      params(
+        root_path: ::String,
+        package_pathspec: T.any(::String, T::Array[::String]),
+        exclude_pathspec: T.nilable(T.any(::String, T::Array[::String]))
+      ).returns(T::Array[::Pathname])
+    end
+    def package_paths(root_path, package_pathspec, exclude_pathspec = T.unsafe(nil)); end
 
     private
 
+    sig { params(packages: T::Array[::Packwerk::Package]).void }
     def create_root_package_if_none_in(packages); end
+
+    sig { params(globs: T::Array[::String], path: ::Pathname).returns(T::Boolean) }
+    def exclude_path?(globs, path); end
   end
 end
 
 Packwerk::PackageSet::PACKAGE_CONFIG_FILENAME = T.let(T.unsafe(nil), String)
 
 class Packwerk::ParseRun
-  def initialize(files:, configuration:, progress_formatter: T.unsafe(nil), offenses_formatter: T.unsafe(nil)); end
+  sig do
+    params(
+      absolute_files: T::Array[::String],
+      configuration: ::Packwerk::Configuration,
+      progress_formatter: ::Packwerk::Formatters::ProgressFormatter,
+      offenses_formatter: ::Packwerk::OffensesFormatter
+    ).void
+  end
+  def initialize(absolute_files:, configuration:, progress_formatter: T.unsafe(nil), offenses_formatter: T.unsafe(nil)); end
 
+  sig { returns(::Packwerk::Result) }
   def check; end
+
+  sig { returns(::Packwerk::Result) }
   def detect_stale_violations; end
+
+  sig { returns(::Packwerk::Result) }
   def update_deprecations; end
 
   private
 
+  sig { params(show_errors: T::Boolean).returns(::Packwerk::OffenseCollection) }
   def find_offenses(show_errors: T.unsafe(nil)); end
-  def serial_find_offenses; end
+
+  sig do
+    params(
+      block: T.proc.params(path: ::String).returns(T::Array[::Packwerk::Offense])
+    ).returns(T::Array[::Packwerk::Offense])
+  end
+  def serial_find_offenses(&block); end
+
+  sig { params(failed: T::Boolean).void }
   def update_progress(failed: T.unsafe(nil)); end
 end
 
+Packwerk::ParseRun::ProcessFileProc = T.type_alias { T.proc.params(path: ::String).returns(T::Array[::Packwerk::Offense]) }
+
 class Packwerk::ParsedConstantDefinitions
   def initialize(root_node:); end
 
@@ -610,12 +760,28 @@ end
 
 module Packwerk::Parsers; end
 
+class Packwerk::Parsers::Erb
+  include ::Packwerk::Parsers::ParserInterface
+
+  def initialize(parser_class: T.unsafe(nil), ruby_parser: T.unsafe(nil)); end
+
+  def call(io:, file_path: T.unsafe(nil)); end
+  def parse_buffer(buffer, file_path:); end
+
+  private
+
+  def code_nodes(node); end
+  def to_ruby_ast(erb_ast, file_path); end
+end
+
 class Packwerk::Parsers::Factory
   include ::Singleton
   extend ::Singleton::SingletonClassMethods
 
   def erb_parser_class; end
   def erb_parser_class=(klass); end
+
+  sig { params(path: ::String).returns(T.nilable(::Packwerk::Parsers::ParserInterface)) }
   def for_path(path); end
 end
 
@@ -630,14 +796,69 @@ end
 
 class Packwerk::Parsers::ParseResult < ::Packwerk::Offense; end
 
+module Packwerk::Parsers::ParserInterface
+  interface!
+
+  sig { abstract.params(io: ::File, file_path: ::String).returns(T.untyped) }
+  def call(io:, file_path:); end
+end
+
 class Packwerk::Parsers::Ruby
+  include ::Packwerk::Parsers::ParserInterface
+
   def initialize(parser_class: T.unsafe(nil)); end
 
   def call(io:, file_path: T.unsafe(nil)); end
 end
 
-class Packwerk::PrivacyChecker
-  include ::Packwerk::Checker
+Packwerk::PathSpec = T.type_alias { T.any(::String, T::Array[::String]) }
+
+class Packwerk::Reference < ::Struct
+  def constant; end
+  def constant=(_); end
+  def relative_path; end
+  def relative_path=(_); end
+  def source_location; end
+  def source_location=(_); end
+  def source_package; end
+  def source_package=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+module Packwerk::ReferenceChecking
+end
+
+module Packwerk::ReferenceChecking::Checkers
+end
+
+module Packwerk::ReferenceChecking::Checkers::Checker
+  interface!
+
+  sig { abstract.params(reference: ::Packwerk::Reference).returns(T::Boolean) }
+  def invalid_reference?(reference); end
+
+  sig { abstract.returns(::Packwerk::ViolationType) }
+  def violation_type; end
+end
+
+class Packwerk::ReferenceChecking::Checkers::DependencyChecker
+  include ::Packwerk::ReferenceChecking::Checkers::Checker
+
+  sig { override.params(reference: ::Packwerk::Reference).returns(T::Boolean) }
+  def invalid_reference?(reference); end
+
+  sig { override.returns(::Packwerk::ViolationType) }
+  def violation_type; end
+end
+
+class Packwerk::ReferenceChecking::Checkers::PrivacyChecker
+  include ::Packwerk::ReferenceChecking::Checkers::Checker
 
   sig { override.params(reference: ::Packwerk::Reference).returns(T::Boolean) }
   def invalid_reference?(reference); end
@@ -659,20 +880,15 @@ class Packwerk::PrivacyChecker
   def explicitly_private_constant?(constant, explicitly_private_constants:); end
 end
 
-class Packwerk::Reference < ::Struct
-  def constant; end
-  def constant=(_); end
-  def relative_path; end
-  def relative_path=(_); end
-  def source_package; end
-  def source_package=(_); end
+class Packwerk::ReferenceChecking::ReferenceChecker
+  sig { params(checkers: T::Array[::Packwerk::ReferenceChecking::Checkers::Checker]).void }
+  def initialize(checkers); end
 
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
+  sig { params(reference: T.any(::Packwerk::Offense, ::Packwerk::Reference)).returns(T::Array[::Packwerk::Offense]) }
+  def call(reference); end
+end
+
+class Packwerk::ReferenceExtractor
 end
 
 class Packwerk::ReferenceOffense < ::Packwerk::Offense
@@ -685,25 +901,50 @@ class Packwerk::ReferenceOffense < ::Packwerk::Offense
   end
   def initialize(reference:, violation_type:, location: T.unsafe(nil)); end
 
+  sig { returns(::Packwerk::Reference) }
   def reference; end
+
+  sig { returns(::Packwerk::ViolationType) }
   def violation_type; end
 
   private
 
+  sig { params(reference: ::Packwerk::Reference, violation_type: ::Packwerk::ViolationType).returns(::String) }
   def build_message(reference, violation_type); end
 end
 
 class Packwerk::Result < ::T::Struct
-  prop :message, ::String
-  prop :status, T::Boolean
+  const :message, ::String
+  const :status, T::Boolean
 
   class << self
     def inherited(s); end
   end
 end
 
+class Packwerk::RunContext
+end
 
 Packwerk::RunContext::DEFAULT_CHECKERS = T.let(T.unsafe(nil), Array)
+
+class Packwerk::UnresolvedReference < ::Struct
+  def constant_name; end
+  def constant_name=(_); end
+  def namespace_path; end
+  def namespace_path=(_); end
+  def relative_path; end
+  def relative_path=(_); end
+  def source_location; end
+  def source_location=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
 Packwerk::VERSION = T.let(T.unsafe(nil), String)
 
 class Packwerk::ViolationType < ::T::Enum

data/sorbet/rbi/gems/{parse_packwerk@0.12.0.rbi → parse_packwerk@0.12.1.rbi}

@@ -15,7 +15,7 @@ module ParsePackwerk
     sig { params(name: ::String).returns(T.nilable(::ParsePackwerk::Package)) }
     def find(name); end
 
-    sig { params(file_path: T.any(::Pathname, ::String)).returns(T.nilable(::ParsePackwerk::Package)) }
+    sig { params(file_path: T.any(::Pathname, ::String)).returns(::ParsePackwerk::Package) }
     def package_from_path(file_path); end
 
     sig { params(package: ::ParsePackwerk::Package).void }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: danger-packwerk
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Gusto Engineers
@@ -198,9 +198,10 @@ files:
 - lib/danger-packwerk/violation_diff.rb
 - lib/danger_plugin.rb
 - sorbet/config
+- sorbet/rbi/gems/constant_resolver@0.2.0.rbi
 - sorbet/rbi/gems/danger@8.5.0.rbi
-- sorbet/rbi/gems/packwerk@1.3.2.rbi
-- sorbet/rbi/gems/parse_packwerk@0.12.0.rbi
+- sorbet/rbi/gems/packwerk@2.1.1.rbi
+- sorbet/rbi/gems/parse_packwerk@0.12.1.rbi
 - sorbet/rbi/todo.rbi
 - sorbet/tapioca/require.rb
 homepage: https://github.com/rubyatscale/danger-packwerk