packwerk 3.2.3 → 3.3.0

data/lib/packwerk/commands/lazy_loaded_entry.rb

@@ -4,29 +4,27 @@
 module Packwerk
   module Commands
     class LazyLoadedEntry
-      extend T::Sig
-
-      sig { returns(String) }
+      #: String
       attr_reader :name
 
-      sig { params(name: String, aliases: T::Array[String]).void }
+      #: (String name, ?aliases: Array[String]) -> void
       def initialize(name, aliases: [])
         @name = name
         @aliases = aliases
       end
 
-      sig { returns(T.class_of(BaseCommand)) }
+      #: -> singleton(BaseCommand)
       def command_class
         classname = @name.sub(" ", "_").underscore.classify + "Command"
         Commands.const_get(classname) # rubocop:disable Sorbet/ConstantsFromStrings
       end
 
-      sig { returns(String) }
+      #: -> String
       def description
         command_class.description
       end
 
-      sig { params(name_or_alias: String).returns(T::Boolean) }
+      #: (String name_or_alias) -> bool
       def matches_command?(name_or_alias)
         @name == name_or_alias || @aliases.include?(name_or_alias)
       end

data/lib/packwerk/commands/update_todo_command.rb

@@ -4,12 +4,12 @@
 module Packwerk
   module Commands
     class UpdateTodoCommand < BaseCommand
-      extend T::Sig
       include UsesParseRun
 
       description "update package_todo.yml files"
 
-      sig { override.returns(T::Boolean) }
+      # @override
+      #: -> bool
       def run
         if @files_for_processing.files_specified?
           out.puts(<<~MSG.squish)
@@ -28,7 +28,7 @@ module Packwerk
         end
 
         run_context = RunContext.from_configuration(configuration)
-        offenses = T.let([], T::Array[Offense])
+        offenses = [] #: Array[Offense]
         progress_formatter.started_inspection(@files_for_processing.files) do
           offenses = parse_run.find_offenses(run_context, on_interrupt: -> { progress_formatter.interrupted }) do
             progress_formatter.increment_progress

data/lib/packwerk/commands/uses_parse_run.rb

@@ -5,32 +5,26 @@ require "optparse"
 
 module Packwerk
   module Commands
+    # @requires_ancestor: BaseCommand
     module UsesParseRun
-      extend T::Sig
-      extend T::Helpers
-
-      requires_ancestor { BaseCommand }
-
-      sig do
-        params(
-          args: T::Array[String],
-          configuration: Configuration,
-          out: T.any(StringIO, IO),
-          err_out: T.any(StringIO, IO),
-          progress_formatter: Formatters::ProgressFormatter,
-          offenses_formatter: OffensesFormatter,
-        ).void
-      end
+      #: (
+      #|   Array[String] args,
+      #|   configuration: Configuration,
+      #|   out: (StringIO | IO),
+      #|   err_out: (StringIO | IO),
+      #|   progress_formatter: Formatters::ProgressFormatter,
+      #|   offenses_formatter: OffensesFormatter
+      #| ) -> void
       def initialize(args, configuration:, out:, err_out:, progress_formatter:, offenses_formatter:)
         super
-        @files_for_processing = T.let(fetch_files_to_process, FilesForProcessing)
-        @offenses_formatter = T.let(offenses_formatter_from_options || @offenses_formatter, OffensesFormatter)
+        @files_for_processing = fetch_files_to_process #: FilesForProcessing
+        @offenses_formatter = offenses_formatter_from_options || @offenses_formatter #: OffensesFormatter
         configuration.parallel = parsed_options[:parallel]
       end
 
       private
 
-      sig { returns(FilesForProcessing) }
+      #: -> FilesForProcessing
       def fetch_files_to_process
         FilesForProcessing.fetch(
           relative_file_paths: parsed_options[:relative_file_paths],
@@ -39,12 +33,12 @@ module Packwerk
         )
       end
 
-      sig { returns(T.nilable(OffensesFormatter)) }
+      #: -> OffensesFormatter?
       def offenses_formatter_from_options
         OffensesFormatter.find(parsed_options[:formatter_name]) if parsed_options[:formatter_name]
       end
 
-      sig { returns(ParseRun) }
+      #: -> ParseRun
       def parse_run
         ParseRun.new(
           relative_file_set: @files_for_processing.files,
@@ -52,17 +46,17 @@ module Packwerk
         )
       end
 
-      sig { returns(T::Hash[Symbol, T.untyped]) }
+      #: -> Hash[Symbol, untyped]
       def parsed_options
         return @parsed_options if @parsed_options
 
-        @parsed_options = T.let(nil, T.nilable(T::Hash[Symbol, T.untyped]))
+        @parsed_options = nil #: Hash[Symbol, untyped]?
 
         @parsed_options = {
-          relative_file_paths: T.let([], T::Array[String]),
-          ignore_nested_packages: T.let(false, T::Boolean),
-          formatter_name: T.let(nil, T.nilable(String)),
-          parallel: T.let(configuration.parallel?, T::Boolean),
+          relative_file_paths: [], #: Array[String]
+          ignore_nested_packages: false, #: bool
+          formatter_name: nil, #: String?
+          parallel: configuration.parallel?,
         }
 
         OptionParser.new do |parser|

data/lib/packwerk/commands/validate_command.rb

@@ -4,19 +4,18 @@
 module Packwerk
   module Commands
     class ValidateCommand < BaseCommand
-      extend T::Sig
-
       description "verify integrity of packwerk and package configuration"
 
-      sig { override.returns(T::Boolean) }
+      # @override
+      #: -> bool
       def run
-        validator_result = T.let(nil, T.nilable(Validator::Result))
+        validator_result = nil #: Validator::Result?
 
         progress_formatter.started_validation do
           validator_result = validator.check_all(package_set, configuration)
         end
 
-        validator_result = T.must(validator_result)
+        validator_result = validator_result #: as !nil
 
         if validator_result.ok?
           out.puts("Validation successful 🎉")
@@ -29,12 +28,12 @@ module Packwerk
 
       private
 
-      sig { returns(ApplicationValidator) }
+      #: -> ApplicationValidator
       def validator
         ApplicationValidator.new
       end
 
-      sig { returns(PackageSet) }
+      #: -> PackageSet
       def package_set
         PackageSet.load_all_from(
           configuration.root_path,

data/lib/packwerk/commands/version_command.rb

@@ -4,11 +4,10 @@
 module Packwerk
   module Commands
     class VersionCommand < BaseCommand
-      extend T::Sig
-
       description "output packwerk version"
 
-      sig { override.returns(T::Boolean) }
+      # @override
+      #: -> bool
       def run
         out.puts(Packwerk::VERSION)
         true

data/lib/packwerk/commands.rb

@@ -3,7 +3,6 @@
 
 module Packwerk
   module Commands
-    extend T::Sig
     extend ActiveSupport::Autoload
 
     autoload :BaseCommand
@@ -17,30 +16,28 @@ module Packwerk
     autoload :VersionCommand
 
     class << self
-      extend T::Sig
-
-      sig { params(name: String, aliases: T::Array[String]).void }
+      #: (String name, ?aliases: Array[String]) -> void
       def register(name, aliases: [])
         registry << LazyLoadedEntry.new(name, aliases: aliases)
       end
 
-      sig { params(name_or_alias: String).returns(T.nilable(T.class_of(BaseCommand))) }
+      #: (String name_or_alias) -> singleton(BaseCommand)?
       def for(name_or_alias)
         registry
           .find { |command| command.matches_command?(name_or_alias) }
           &.command_class
       end
 
-      sig { returns(T::Array[LazyLoadedEntry]) }
+      #: -> Array[LazyLoadedEntry]
       def all
         registry.dup
       end
 
       private
 
-      sig { returns(T::Array[LazyLoadedEntry]) }
+      #: -> Array[LazyLoadedEntry]
       def registry
-        @registry ||= T.let([], T.nilable(T::Array[LazyLoadedEntry]))
+        @registry ||= [] #: Array[LazyLoadedEntry]?
       end
     end
 

data/lib/packwerk/configuration.rb

@@ -6,12 +6,8 @@ require "yaml"
 
 module Packwerk
   class Configuration
-    extend T::Sig
-
     class << self
-      extend T::Sig
-
-      sig { params(path: String).returns(Configuration) }
+      #: (?String path) -> Configuration
       def from_path(path = Dir.pwd)
         raise ArgumentError, "#{File.expand_path(path)} does not exist" unless File.exist?(path)
 
@@ -26,7 +22,7 @@ module Packwerk
 
       private
 
-      sig { params(path: String).returns(Configuration) }
+      #: (String path) -> Configuration
       def from_packwerk_config(path)
         new(
           YAML.load_file(path) || {},
@@ -36,58 +32,51 @@ module Packwerk
     end
 
     DEFAULT_CONFIG_PATH = "packwerk.yml"
-    DEFAULT_INCLUDE_GLOBS = T.let(["**/*.{rb,rake,erb}"], T::Array[String])
-    DEFAULT_EXCLUDE_GLOBS = T.let(["{bin,node_modules,script,tmp,vendor}/**/*"], T::Array[String])
+    DEFAULT_INCLUDE_GLOBS = ["**/*.{rb,rake,erb}"] #: Array[String]
+    DEFAULT_EXCLUDE_GLOBS = ["{bin,node_modules,script,tmp,vendor}/**/*"] #: Array[String]
 
-    sig { returns(T::Array[String]) }
+    #: Array[String]
     attr_reader(:include)
 
-    sig { returns(T::Array[String]) }
+    #: Array[String]
     attr_reader(:exclude)
 
-    sig { returns(String) }
+    #: String
     attr_reader(:root_path)
 
-    sig { returns(T.any(String, T::Array[String])) }
+    #: (String | Array[String])
     attr_reader(:package_paths)
 
-    sig { returns(T::Array[Symbol]) }
+    #: Array[Symbol]
     attr_reader(:custom_associations)
 
-    sig { returns(T::Array[String]) }
+    #: Array[String]
     attr_reader(:associations_exclude)
 
-    sig { returns(T.nilable(String)) }
+    #: String?
     attr_reader(:config_path)
 
-    sig { returns(Pathname) }
+    #: Pathname
     attr_reader(:cache_directory)
 
-    sig { params(parallel: T::Boolean).returns(T::Boolean) }
+    #: bool
     attr_writer(:parallel)
 
-    sig do
-      params(
-        configs: T::Hash[String, T.untyped],
-        config_path: T.nilable(String),
-      ).void
-    end
+    #: (?Hash[String, untyped] configs, ?config_path: String?) -> void
     def initialize(configs = {}, config_path: nil)
-      @include = T.let(configs["include"] || DEFAULT_INCLUDE_GLOBS, T::Array[String])
-      @exclude = T.let(configs["exclude"] || DEFAULT_EXCLUDE_GLOBS, T::Array[String])
+      @include = configs["include"] || DEFAULT_INCLUDE_GLOBS #: Array[String]
+      @exclude = configs["exclude"] || DEFAULT_EXCLUDE_GLOBS #: Array[String]
       root = config_path ? File.dirname(config_path) : "."
-      @root_path = T.let(File.expand_path(root), String)
-      @package_paths = T.let(configs["package_paths"] || "**/", T.any(String, T::Array[String]))
-      @custom_associations = T.let((configs["custom_associations"] || []).map(&:to_sym), T::Array[Symbol])
-      @associations_exclude = T.let(configs["associations_exclude"] || [], T::Array[String])
-      @parallel = T.let(configs.key?("parallel") ? configs["parallel"] : true, T::Boolean)
-      @cache_enabled = T.let(configs.key?("cache") ? configs["cache"] : false, T::Boolean)
-      @cache_directory = T.let(Pathname.new(configs["cache_directory"] || "tmp/cache/packwerk"), Pathname)
+      @root_path = File.expand_path(root) #: String
+      @package_paths = configs["package_paths"] || "**/" #: (String | Array[String])
+      @custom_associations = (configs["custom_associations"] || []).map(&:to_sym) #: Array[Symbol]
+      @associations_exclude = configs["associations_exclude"] || [] #: Array[String]
+      @parallel = configs.key?("parallel") ? configs["parallel"] : true #: bool
+      @cache_enabled = configs.key?("cache") ? configs["cache"] : false #: bool
+      @cache_directory = Pathname.new(configs["cache_directory"] || "tmp/cache/packwerk") #: Pathname
       @config_path = config_path
 
-      @offenses_formatter_identifier = T.let(
-        configs["offenses_formatter"] || Formatters::DefaultOffensesFormatter::IDENTIFIER, String
-      )
+      @offenses_formatter_identifier = configs["offenses_formatter"] || Formatters::DefaultOffensesFormatter::IDENTIFIER #: String
 
       if configs.key?("require")
         configs["require"].each do |require_directive|
@@ -96,25 +85,22 @@ module Packwerk
       end
     end
 
-    sig { returns(T::Hash[String, Module]) }
+    #: -> Hash[String, Module[top]]
     def load_paths
-      @load_paths ||= T.let(
-        RailsLoadPaths.for(@root_path, environment: "test"),
-        T.nilable(T::Hash[String, Module]),
-      )
+      @load_paths ||= RailsLoadPaths.for(@root_path, environment: "test") #: Hash[String, Module[top]]?
     end
 
-    sig { returns(T::Boolean) }
+    #: -> bool
     def parallel?
       @parallel
     end
 
-    sig { returns(OffensesFormatter) }
+    #: -> OffensesFormatter
     def offenses_formatter
       OffensesFormatter.find(@offenses_formatter_identifier)
     end
 
-    sig { returns(T::Boolean) }
+    #: -> bool
     def cache_enabled?
       @cache_enabled
     end

data/lib/packwerk/const_node_inspector.rb

@@ -4,14 +4,10 @@
 module Packwerk
   # Extracts a constant name from an AST node of type :const
   class ConstNodeInspector
-    extend T::Sig
     include ConstantNameInspector
 
-    sig do
-      override
-        .params(node: AST::Node, ancestors: T::Array[AST::Node], relative_file: String)
-        .returns(T.nilable(String))
-    end
+    # @override
+    #: (AST::Node node, ancestors: Array[AST::Node], relative_file: String) -> String?
     def constant_name_from_node(node, ancestors:, relative_file:)
       return nil unless NodeHelpers.constant?(node)
 
@@ -34,18 +30,18 @@ module Packwerk
 
     private
 
-    sig { params(parent: T.nilable(AST::Node)).returns(T::Boolean) }
+    #: (AST::Node? parent) -> bool
     def root_constant?(parent)
       !(parent && NodeHelpers.constant?(parent))
     end
 
-    sig { params(node: AST::Node, parent: AST::Node).returns(T.nilable(T::Boolean)) }
+    #: (AST::Node node, parent: AST::Node) -> bool?
     def constant_in_module_or_class_definition?(node, parent:)
       parent_name = NodeHelpers.module_name_from_definition(parent)
       parent_name && parent_name == NodeHelpers.constant_name(node)
     end
 
-    sig { params(ancestors: T::Array[AST::Node]).returns(String) }
+    #: (Array[AST::Node] ancestors) -> String
     def fully_qualify_constant(ancestors)
       # We're defining a class with this name, in which case the constant is implicitly fully qualified by its
       # enclosing namespace

data/lib/packwerk/constant_context.rb

@@ -2,7 +2,5 @@
 # frozen_string_literal: true
 
 module Packwerk
-  extend T::Sig
-
   ConstantContext = Struct.new(:name, :location, :package)
 end

data/lib/packwerk/constant_discovery.rb

@@ -15,13 +15,9 @@ module Packwerk
   #   have no way of inferring the file it is defined in. You could argue though that inheritance means that another
   #   constant with the same name exists in the inheriting class, and this view is sufficient for all our use cases.
   class ConstantDiscovery
-    extend T::Sig
-
     # @param constant_resolver [ConstantResolver]
     # @param packages [Packwerk::PackageSet]
-    sig do
-      params(constant_resolver: ConstantResolver, packages: Packwerk::PackageSet).void
-    end
+    #: (constant_resolver: ConstantResolver, packages: Packwerk::PackageSet) -> void
     def initialize(constant_resolver:, packages:)
       @packages = packages
       @resolver = constant_resolver
@@ -33,11 +29,7 @@ module Packwerk
     #
     # @return [Packwerk::Package] the package that contains the given file,
     #   or nil if the path is not owned by any component
-    sig do
-      params(
-        path: String,
-      ).returns(Packwerk::Package)
-    end
+    #: (String path) -> Packwerk::Package
     def package_from_path(path)
       @packages.package_from_path(path)
     end
@@ -49,12 +41,7 @@ module Packwerk
     # @param current_namespace_path [Array<String>] (optional) The namespace of the context in which the constant is
     #   used, e.g. ["Apps", "Models"] for `Apps::Models`. Defaults to [] which means top level.
     # @return [ConstantContext]
-    sig do
-      params(
-        const_name: String,
-        current_namespace_path: T.nilable(T::Array[String]),
-      ).returns(T.nilable(ConstantContext))
-    end
+    #: (String const_name, ?current_namespace_path: Array[String]?) -> ConstantContext?
     def context_for(const_name, current_namespace_path: [])
       begin
         constant = @resolver.resolve(const_name, current_namespace_path: current_namespace_path)

data/lib/packwerk/constant_name_inspector.rb

@@ -5,18 +5,11 @@ require "ast"
 
 module Packwerk
   # An interface describing an object that can extract a constant name from an AST node.
+  # @interface
   module ConstantNameInspector
-    extend T::Sig
-    extend T::Helpers
-
-    interface!
-
-    sig do
-      abstract
-        .params(node: ::AST::Node, ancestors: T::Array[::AST::Node], relative_file: String)
-        .returns(T.nilable(String))
-    end
-    def constant_name_from_node(node, ancestors:, relative_file:); end
+    # @abstract
+    #: (::AST::Node node, ancestors: Array[::AST::Node], relative_file: String) -> String?
+    def constant_name_from_node(node, ancestors:, relative_file:) = raise NotImplementedError, "Abstract method called"
   end
 
   private_constant :ConstantNameInspector

data/lib/packwerk/extension_loader.rb

@@ -6,8 +6,7 @@ module Packwerk
   # in the `packwerk.yml` configuration.
   module ExtensionLoader
     class << self
-      extend T::Sig
-      sig { params(require_directive: String, config_dir_path: String).void }
+      #: (String require_directive, String config_dir_path) -> void
       def load(require_directive, config_dir_path)
         # We want to transform the require directive to behave differently
         # if it's a specific local file being required versus a gem

data/lib/packwerk/file_processor.rb

@@ -1,42 +1,39 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "parser/ast/node"
+require "parser"
 
 module Packwerk
   class FileProcessor
-    extend T::Sig
-
     class UnknownFileTypeResult < Offense
-      extend T::Sig
-
-      sig { params(file: String).void }
+      #: (file: String) -> void
       def initialize(file:)
         super(file: file, message: "unknown file type")
       end
     end
 
-    sig do
-      params(
-        node_processor_factory: NodeProcessorFactory,
-        cache: Cache,
-        parser_factory: T.nilable(Parsers::Factory)
-      ).void
-    end
+    #: (node_processor_factory: NodeProcessorFactory, cache: Cache, ?parser_factory: Parsers::Factory?) -> void
     def initialize(node_processor_factory:, cache:, parser_factory: nil)
       @node_processor_factory = node_processor_factory
       @cache = cache
-      @parser_factory = T.let(parser_factory || Packwerk::Parsers::Factory.instance, Parsers::Factory)
+      @parser_factory = parser_factory || Packwerk::Parsers::Factory.instance #: Parsers::Factory
     end
 
-    class ProcessedFile < T::Struct
-      const :unresolved_references, T::Array[UnresolvedReference], default: []
-      const :offenses, T::Array[Offense], default: []
-    end
+    class ProcessedFile
+      #: Array[UnresolvedReference]
+      attr_reader :unresolved_references
 
-    sig do
-      params(relative_file: String).returns(ProcessedFile)
+      #: Array[Offense]
+      attr_reader :offenses
+
+      #: (?unresolved_references: Array[UnresolvedReference], ?offenses: Array[Offense]) -> void
+      def initialize(unresolved_references: [], offenses: [])
+        @unresolved_references = unresolved_references
+        @offenses = offenses
+      end
     end
+
+    #: (String relative_file) -> ProcessedFile
     def call(relative_file)
       parser = parser_for(relative_file)
       if parser.nil?
@@ -68,9 +65,7 @@ module Packwerk
 
     private
 
-    sig do
-      params(node: Parser::AST::Node, relative_file: String).returns(T::Array[UnresolvedReference])
-    end
+    #: (Parser::AST::Node node, String relative_file) -> Array[UnresolvedReference]
     def references_from_ast(node, relative_file)
       references = []
 
@@ -81,14 +76,14 @@ module Packwerk
       references
     end
 
-    sig { params(relative_file: String, parser: Parsers::ParserInterface).returns(T.untyped) }
+    #: (String relative_file, Parsers::ParserInterface parser) -> untyped
     def parse_into_ast(relative_file, parser)
       File.open(relative_file, "r", nil, external_encoding: Encoding::UTF_8) do |file|
         parser.call(io: file, file_path: relative_file)
       end
     end
 
-    sig { params(file_path: String).returns(T.nilable(Parsers::ParserInterface)) }
+    #: (String file_path) -> Parsers::ParserInterface?
     def parser_for(file_path)
       @parser_factory.for_path(file_path)
     end