packwerk 3.2.2 → 3.3.0

data/lib/packwerk/reference_extractor.rb

@@ -4,19 +4,10 @@
 module Packwerk
   # Extracts a possible constant reference from a given AST node.
   class ReferenceExtractor
-    extend T::Sig
-
     class << self
-      extend T::Sig
-
-      sig do
-        params(
-          unresolved_references: T::Array[UnresolvedReference],
-          context_provider: ConstantDiscovery
-        ).returns(T::Array[Reference])
-      end
+      #: (Array[UnresolvedReference] unresolved_references, ConstantDiscovery context_provider) -> Array[Reference]
       def get_fully_qualified_references_from(unresolved_references, context_provider)
-        fully_qualified_references = T.let([], T::Array[Reference])
+        fully_qualified_references = [] #: Array[Reference]
 
         unresolved_references.each do |unresolved_references_or_offense|
           unresolved_reference = unresolved_references_or_offense
@@ -49,13 +40,7 @@ module Packwerk
       end
     end
 
-    sig do
-      params(
-        constant_name_inspectors: T::Array[ConstantNameInspector],
-        root_node: AST::Node,
-        root_path: String,
-      ).void
-    end
+    #: (constant_name_inspectors: Array[ConstantNameInspector], root_node: AST::Node, root_path: String) -> void
     def initialize(
       constant_name_inspectors:,
       root_node:,
@@ -63,21 +48,12 @@ module Packwerk
     )
       @constant_name_inspectors = constant_name_inspectors
       @root_path = root_path
-      @local_constant_definitions = T.let(
-        ParsedConstantDefinitions.new(root_node: root_node),
-        ParsedConstantDefinitions,
-      )
+      @local_constant_definitions = ParsedConstantDefinitions.new(root_node: root_node) #: ParsedConstantDefinitions
     end
 
-    sig do
-      params(
-        node: Parser::AST::Node,
-        ancestors: T::Array[Parser::AST::Node],
-        relative_file: String
-      ).returns(T.nilable(UnresolvedReference))
-    end
+    #: (Parser::AST::Node node, ancestors: Array[Parser::AST::Node], relative_file: String) -> UnresolvedReference?
     def reference_from_node(node, ancestors:, relative_file:)
-      constant_name = T.let(nil, T.nilable(String))
+      constant_name = nil #: String?
 
       @constant_name_inspectors.each do |inspector|
         constant_name = inspect_node(
@@ -102,21 +78,20 @@ 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
+    #: (
+    #|   ConstantNameInspector inspector,
+    #|   node: Parser::AST::Node,
+    #|   ancestors: Array[Parser::AST::Node],
+    #|   relative_file: String
+    #| ) -> String?
     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
+        inspector_ = inspector #: as untyped
+        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
+            #{inspector_.class}#reference_from_node without a relative_file: keyword
             argument is deprecated and will be required in Packwerk 3.1.1.
           MSG
         end
@@ -125,14 +100,12 @@ module Packwerk
       end
     end
 
-    sig do
-      params(
-        constant_name: String,
-        node: Parser::AST::Node,
-        ancestors: T::Array[Parser::AST::Node],
-        relative_file: String
-      ).returns(T.nilable(UnresolvedReference))
-    end
+    #: (
+    #|   String constant_name,
+    #|   node: Parser::AST::Node,
+    #|   ancestors: Array[Parser::AST::Node],
+    #|   relative_file: String
+    #| ) -> UnresolvedReference?
     def reference_from_constant(constant_name, node:, ancestors:, relative_file:)
       namespace_path = NodeHelpers.enclosing_namespace_path(node, ancestors: ancestors)
 
@@ -148,13 +121,7 @@ module Packwerk
       )
     end
 
-    sig do
-      params(
-        constant_name: String,
-        name_location: T.nilable(Node::Location),
-        namespace_path: T::Array[String],
-      ).returns(T::Boolean)
-    end
+    #: (String constant_name, Node::Location? name_location, Array[String] namespace_path) -> bool
     def local_reference?(constant_name, name_location, namespace_path)
       @local_constant_definitions.local_reference?(
         constant_name,

data/lib/packwerk/reference_offense.rb

@@ -4,26 +4,16 @@
 module Packwerk
   # An offense related to a {Packwerk::Reference}.
   class ReferenceOffense < Offense
-    extend T::Sig
-    extend T::Helpers
-
-    sig { returns(Reference) }
+    #: Reference
     attr_reader :reference
 
-    sig { returns(String) }
+    #: String
     attr_reader :violation_type
 
-    sig do
-      params(
-        reference: Packwerk::Reference,
-        violation_type: String,
-        message: String,
-        location: T.nilable(Node::Location)
-      )
-        .void
-    end
+    #: (reference: Packwerk::Reference, violation_type: String, message: String, ?location: Node::Location?) -> void
     def initialize(reference:, violation_type:, message:, location: nil)
-      super(file: T.must(reference.relative_path), message: message, location: location)
+      file = reference.relative_path #: as !nil
+      super(file: file, message: message, location: location)
       @reference = reference
       @violation_type = violation_type
     end

data/lib/packwerk/run_context.rb

@@ -6,22 +6,17 @@ require "constant_resolver"
 module Packwerk
   # Holds the context of a Packwerk run across multiple files.
   class RunContext
-    extend T::Sig
-
     class << self
-      extend T::Sig
-
-      sig do
-        params(configuration: Configuration).returns(RunContext)
-      end
+      #: (Configuration configuration) -> RunContext
       def from_configuration(configuration)
         new(
           root_path: configuration.root_path,
           load_paths: configuration.load_paths,
           package_paths: configuration.package_paths,
           inflector: ActiveSupport::Inflector,
-          custom_associations: configuration.custom_associations,
+          custom_associations: configuration.custom_associations.to_set,
           associations_exclude: configuration.associations_exclude,
+          exclude: configuration.exclude,
           cache_enabled: configuration.cache_enabled?,
           cache_directory: configuration.cache_directory,
           config_path: configuration.config_path,
@@ -29,20 +24,19 @@ module Packwerk
       end
     end
 
-    sig do
-      params(
-        root_path: String,
-        load_paths: T::Hash[String, Module],
-        inflector: T.class_of(ActiveSupport::Inflector),
-        cache_directory: Pathname,
-        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
-    end
+    #: (
+    #|   root_path: String,
+    #|   load_paths: Hash[String, Module[top]],
+    #|   inflector: singleton(ActiveSupport::Inflector),
+    #|   cache_directory: Pathname,
+    #|   ?config_path: String?,
+    #|   ?package_paths: (Array[String] | String)?,
+    #|   ?custom_associations: Set[Symbol],
+    #|   ?associations_exclude: Array[String],
+    #|   ?exclude: Array[String],
+    #|   ?checkers: Array[Checker],
+    #|   ?cache_enabled: bool
+    #| ) -> void
     def initialize(
       root_path:,
       load_paths:,
@@ -50,8 +44,9 @@ module Packwerk
       cache_directory:,
       config_path: nil,
       package_paths: nil,
-      custom_associations: [],
+      custom_associations: Set.new,
       associations_exclude: [],
+      exclude: [],
       checkers: Checker.all,
       cache_enabled: false
     )
@@ -65,17 +60,16 @@ module Packwerk
       @cache_enabled = cache_enabled
       @cache_directory = cache_directory
       @config_path = config_path
+      @exclude = exclude
 
-      @file_processor = T.let(nil, T.nilable(FileProcessor))
-      @context_provider = T.let(nil, T.nilable(ConstantDiscovery))
-      @package_set = T.let(nil, T.nilable(PackageSet))
+      @file_processor = nil #: FileProcessor?
+      @context_provider = nil #: ConstantDiscovery?
+      @package_set = nil #: PackageSet?
       # We need to initialize this before we fork the process, see https://github.com/Shopify/packwerk/issues/182
-      @cache = T.let(
-        Cache.new(enable_cache: @cache_enabled, cache_directory: @cache_directory, config_path: @config_path), Cache
-      )
+      @cache = Cache.new(enable_cache: @cache_enabled, cache_directory: @cache_directory, config_path: @config_path) #: Cache
     end
 
-    sig { params(relative_file: String).returns(T::Array[Packwerk::Offense]) }
+    #: (relative_file: String) -> Array[Packwerk::Offense]
     def process_file(relative_file:)
       processed_file = file_processor.call(relative_file)
 
@@ -88,28 +82,27 @@ module Packwerk
       processed_file.offenses + references.flat_map { |reference| reference_checker.call(reference) }
     end
 
-    sig { returns(PackageSet) }
+    #: -> PackageSet
     def package_set
       @package_set ||= ::Packwerk::PackageSet.load_all_from(@root_path, package_pathspec: @package_paths)
     end
 
     private
 
-    sig { returns(FileProcessor) }
+    #: -> FileProcessor
     def file_processor
       @file_processor ||= FileProcessor.new(node_processor_factory: node_processor_factory, cache: @cache)
     end
 
-    sig { returns(NodeProcessorFactory) }
+    #: -> NodeProcessorFactory
     def node_processor_factory
       NodeProcessorFactory.new(
-        context_provider: context_provider,
         root_path: @root_path,
         constant_name_inspectors: constant_name_inspectors
       )
     end
 
-    sig { returns(ConstantDiscovery) }
+    #: -> ConstantDiscovery
     def context_provider
       @context_provider ||= ConstantDiscovery.new(
         constant_resolver: resolver,
@@ -117,16 +110,17 @@ module Packwerk
       )
     end
 
-    sig { returns(ConstantResolver) }
+    #: -> ConstantResolver
     def resolver
       ConstantResolver.new(
         root_path: @root_path,
         load_paths: @load_paths,
         inflector: @inflector,
+        exclude: @exclude,
       )
     end
 
-    sig { returns(T::Array[ConstantNameInspector]) }
+    #: -> Array[ConstantNameInspector]
     def constant_name_inspectors
       [
         ConstNodeInspector.new,
@@ -138,7 +132,7 @@ module Packwerk
       ]
     end
 
-    sig { params(relative_globs: T::Array[String]).returns(FilesForProcessing::RelativeFileSet) }
+    #: (Array[String] relative_globs) -> FilesForProcessing::relative_file_set
     def relative_files_for_globs(relative_globs)
       Set.new(relative_globs.flat_map { |glob| Dir[glob] })
     end

data/lib/packwerk/spring_command.rb

@@ -2,30 +2,27 @@
 # frozen_string_literal: true
 
 require "spring/commands"
-require "sorbet-runtime"
 
 module Packwerk
   class SpringCommand
-    extend T::Sig
-
-    sig { params(args: T.untyped).returns(String) }
+    #: (untyped args) -> String
     def env(args)
       # Packwerk needs to run in a test environment, which has a set of autoload paths that are
       # often a superset of the dev/prod paths (for example, test/support/helpers)
       "test"
     end
 
-    sig { returns(String) }
+    #: -> String
     def exec_name
       "packwerk"
     end
 
-    sig { returns(String) }
+    #: -> String
     def gem_name
       "packwerk"
     end
 
-    sig { returns(T::Boolean) }
+    #: -> bool
     def call
       load(Gem.bin_path(gem_name, exec_name))
     end

data/lib/packwerk/validator/result.rb

@@ -3,13 +3,20 @@
 
 module Packwerk
   module Validator
-    class Result < T::Struct
-      extend T::Sig
+    class Result
+      #: bool
+      attr_reader :ok
 
-      const :ok, T::Boolean
-      const :error_value, T.nilable(String)
+      #: String?
+      attr_reader :error_value
 
-      sig { returns(T::Boolean) }
+      #: (ok: bool, ?error_value: String?) -> void
+      def initialize(ok:, error_value: nil)
+        @ok = ok
+        @error_value = error_value
+      end
+
+      #: -> bool
       def ok?
         ok
       end

data/lib/packwerk/validator.rb

@@ -6,78 +6,68 @@ require "pathname"
 require "yaml"
 
 module Packwerk
+  # @abstract
   module Validator
-    extend T::Sig
-    extend T::Helpers
     extend ActiveSupport::Autoload
 
     autoload :Result
 
-    abstract!
-
     class << self
-      extend T::Sig
-
-      sig { params(base: T::Class[T.anything]).void }
+      #: (Class[top] base) -> void
       def included(base)
         validators << base
       end
 
-      sig { returns(T::Array[Validator]) }
+      #: -> Array[Validator]
       def all
         load_defaults
-        T.cast(validators.map(&:new), T::Array[Validator])
+        validators.map(&:new) #: as Array[Validator]
       end
 
       private
 
-      sig { void }
+      #: -> void
       def load_defaults
         require("packwerk/validators/dependency_validator")
       end
 
-      sig { returns(T::Array[T::Class[T.anything]]) }
+      #: -> Array[Class[top]]
       def validators
-        @validators ||= T.let([], T.nilable(T::Array[T::Class[T.anything]]))
+        @validators ||= [] #: Array[Class[top]]?
       end
     end
 
-    sig { abstract.returns(T::Array[String]) }
-    def permitted_keys
-    end
+    # @abstract
+    #: -> Array[String]
+    def permitted_keys = raise NotImplementedError, "Abstract method called"
 
-    sig { abstract.params(package_set: PackageSet, configuration: Configuration).returns(Validator::Result) }
-    def call(package_set, configuration)
-    end
+    # @abstract
+    #: (PackageSet package_set, Configuration configuration) -> Validator::Result
+    def call(package_set, configuration) = raise NotImplementedError, "Abstract method called"
 
-    sig { params(configuration: Configuration, setting: T.untyped).returns(T.untyped) }
+    #: (Configuration configuration, untyped setting) -> untyped
     def package_manifests_settings_for(configuration, setting)
       package_manifests(configuration).map { |f| [f, (YAML.load_file(File.join(f)) || {})[setting]] }
     end
 
-    sig do
-      params(configuration: Configuration,
-        glob_pattern: T.nilable(T.any(T::Array[String], String))).returns(T::Array[String])
-    end
+    #: (Configuration configuration, ?(Array[String] | String)? glob_pattern) -> Array[String]
     def package_manifests(configuration, glob_pattern = nil)
       glob_pattern ||= package_glob(configuration)
       PackageSet.package_paths(configuration.root_path, glob_pattern, configuration.exclude)
         .map { |f| File.realpath(f) }
     end
 
-    sig { params(configuration: Configuration).returns(T.any(T::Array[String], String)) }
+    #: (Configuration configuration) -> (Array[String] | String)
     def package_glob(configuration)
       configuration.package_paths
     end
 
-    sig do
-      params(
-        results: T::Array[Validator::Result],
-        separator: String,
-        before_errors: String,
-        after_errors: String,
-      ).returns(Validator::Result)
-    end
+    #: (
+    #|   Array[Validator::Result] results,
+    #|   ?separator: String,
+    #|   ?before_errors: String,
+    #|   ?after_errors: String
+    #| ) -> Validator::Result
     def merge_results(results, separator: "\n", before_errors: "", after_errors: "")
       results.reject!(&:ok?)
 
@@ -96,7 +86,7 @@ module Packwerk
       end
     end
 
-    sig { params(configuration: Configuration, path: String).returns(Pathname) }
+    #: (Configuration configuration, String path) -> Pathname
     def relative_path(configuration, path)
       Pathname.new(path).relative_path_from(configuration.root_path)
     end

data/lib/packwerk/validators/dependency_validator.rb

@@ -4,12 +4,10 @@
 module Packwerk
   module Validators
     class DependencyValidator
-      extend T::Sig
       include Validator
 
-      sig do
-        override.params(package_set: PackageSet, configuration: Configuration).returns(Validator::Result)
-      end
+      # @override
+      #: (PackageSet package_set, Configuration configuration) -> Validator::Result
       def call(package_set, configuration)
         results = [
           check_package_manifest_syntax(configuration),
@@ -20,7 +18,8 @@ module Packwerk
         merge_results(results)
       end
 
-      sig { override.returns(T::Array[String]) }
+      # @override
+      #: -> Array[String]
       def permitted_keys
         [
           "enforce_dependencies",
@@ -30,7 +29,7 @@ module Packwerk
 
       private
 
-      sig { params(configuration: Configuration).returns(Validator::Result) }
+      #: (Configuration configuration) -> Validator::Result
       def check_package_manifest_syntax(configuration)
         errors = []
 
@@ -63,12 +62,13 @@ module Packwerk
         end
       end
 
-      sig { params(package_set: PackageSet).returns(Validator::Result) }
+      #: (PackageSet package_set) -> Validator::Result
       def check_acyclic_graph(package_set)
-        edges = package_set.flat_map do |package|
-          package.dependencies.map do |dependency|
-            [package.name, package_set.fetch(dependency)&.name]
-          end
+        edges = package_set.to_h do |package|
+          [
+            package.name,
+            package.dependencies.map { |dependency| package_set.fetch(dependency)&.name },
+          ]
         end
 
         dependency_graph = Graph.new(edges)
@@ -89,7 +89,7 @@ module Packwerk
         end
       end
 
-      sig { params(configuration: Configuration).returns(Validator::Result) }
+      #: (Configuration configuration) -> Validator::Result
       def check_valid_package_dependencies(configuration)
         packages_dependencies = package_manifests_settings_for(configuration, "dependencies")
           .delete_if { |_, deps| deps.nil? }
@@ -125,7 +125,7 @@ module Packwerk
         end
       end
 
-      sig { params(configuration: Configuration, path: T.untyped).returns(T::Boolean) }
+      #: (Configuration configuration, untyped path) -> bool
       def invalid_package_path?(configuration, path)
         # Packages at the root can be implicitly specified as "."
         return false if path == "."
@@ -141,7 +141,7 @@ module Packwerk
       # to the string:
       #
       #   ["a -> b -> c -> a", "b -> c -> b"]
-      sig { params(cycles: T.untyped).returns(T::Array[String]) }
+      #: (untyped cycles) -> Array[String]
       def build_cycle_strings(cycles)
         cycles.map do |cycle|
           cycle_strings = cycle.map(&:to_s)

data/lib/packwerk/version.rb

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

data/lib/packwerk.rb

@@ -1,7 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "sorbet-runtime"
 require "active_support"
 require "fileutils"
 require "stringio"

data/sorbet/config

@@ -1,4 +1,6 @@
 --dir
 .
+--parser=prism
 --enable-experimental-requires-ancestor
+--enable-experimental-rbs-comments
 --ignore=/vendor/bundle