packwerk 3.2.3 → 3.3.0

data/lib/packwerk/files_for_processing.rb

@@ -3,53 +3,37 @@
 
 module Packwerk
   class FilesForProcessing
-    extend T::Sig
-
-    RelativeFileSet = T.type_alias { T::Set[String] }
+    #: type relative_file_set = Set[String]
 
     class << self
-      extend T::Sig
-
-      sig do
-        params(
-          relative_file_paths: T::Array[String],
-          configuration: Configuration,
-          ignore_nested_packages: T::Boolean
-        ).returns(FilesForProcessing)
-      end
+      #: (relative_file_paths: Array[String], configuration: Configuration, ?ignore_nested_packages: bool) -> FilesForProcessing
       def fetch(relative_file_paths:, configuration:, ignore_nested_packages: false)
         new(relative_file_paths, configuration, ignore_nested_packages)
       end
     end
 
-    sig do
-      params(
-        relative_file_paths: T::Array[String],
-        configuration: Configuration,
-        ignore_nested_packages: T::Boolean
-      ).void
-    end
+    #: (Array[String] relative_file_paths, Configuration configuration, bool ignore_nested_packages) -> void
     def initialize(relative_file_paths, configuration, ignore_nested_packages)
       @relative_file_paths = relative_file_paths
       @configuration = configuration
       @ignore_nested_packages = ignore_nested_packages
-      @specified_files = T.let(nil, T.nilable(RelativeFileSet))
-      @files = T.let(nil, T.nilable(RelativeFileSet))
+      @specified_files = nil #: relative_file_set?
+      @files = nil #: relative_file_set?
     end
 
-    sig { returns(RelativeFileSet) }
+    #: -> relative_file_set
     def files
       @files ||= files_for_processing
     end
 
-    sig { returns(T::Boolean) }
+    #: -> bool
     def files_specified?
       specified_files.any?
     end
 
     private
 
-    sig { returns(RelativeFileSet) }
+    #: -> relative_file_set
     def files_for_processing
       all_included_files = if specified_files.empty?
         configured_included_files
@@ -60,7 +44,7 @@ module Packwerk
       all_included_files - configured_excluded_files
     end
 
-    sig { returns(RelativeFileSet) }
+    #: -> relative_file_set
     def specified_files
       @specified_files ||= Set.new(
         @relative_file_paths.map do |relative_file_path|
@@ -73,7 +57,7 @@ module Packwerk
       ).flatten
     end
 
-    sig { params(relative_file_path: String).returns(RelativeFileSet) }
+    #: (String relative_file_path) -> relative_file_set
     def specified_included_files(relative_file_path)
       # Note, assuming include globs are always relative paths
       relative_includes = @configuration.include
@@ -96,17 +80,17 @@ module Packwerk
       Set.new(relative_files)
     end
 
-    sig { returns(RelativeFileSet) }
+    #: -> relative_file_set
     def configured_included_files
       relative_files_for_globs(@configuration.include)
     end
 
-    sig { returns(RelativeFileSet) }
+    #: -> relative_file_set
     def configured_excluded_files
       relative_files_for_globs(@configuration.exclude)
     end
 
-    sig { params(relative_globs: T::Array[String]).returns(RelativeFileSet) }
+    #: (Array[String] relative_globs) -> relative_file_set
     def relative_files_for_globs(relative_globs)
       Set.new(relative_globs.flat_map { |glob| Dir[glob] })
     end

data/lib/packwerk/formatters/default_offenses_formatter.rb

@@ -6,11 +6,10 @@ module Packwerk
     class DefaultOffensesFormatter
       include OffensesFormatter
 
-      IDENTIFIER = T.let("default", String)
+      IDENTIFIER = "default" #: String
 
-      extend T::Sig
-
-      sig { override.params(offenses: T::Array[T.nilable(Offense)]).returns(String) }
+      # @override
+      #: (Array[Offense?] offenses) -> String
       def show_offenses(offenses)
         return "No offenses detected" if offenses.empty?
 
@@ -20,7 +19,8 @@ module Packwerk
         EOS
       end
 
-      sig { override.params(offense_collection: OffenseCollection, file_set: T::Set[String]).returns(String) }
+      # @override
+      #: (OffenseCollection offense_collection, Set[String] file_set) -> String
       def show_stale_violations(offense_collection, file_set)
         if offense_collection.stale_violations?(file_set)
           "There were stale violations found, please run `packwerk update-todo`"
@@ -29,12 +29,14 @@ module Packwerk
         end
       end
 
-      sig { override.returns(String) }
+      # @override
+      #: -> String
       def identifier
         IDENTIFIER
       end
 
-      sig { override.params(strict_mode_violations: T::Array[ReferenceOffense]).returns(String) }
+      # @override
+      #: (Array[ReferenceOffense] strict_mode_violations) -> String
       def show_strict_mode_violations(strict_mode_violations)
         if strict_mode_violations.any?
           strict_mode_violations.compact.map { |offense| format_strict_mode_violation(offense) }.join("\n")
@@ -45,12 +47,12 @@ module Packwerk
 
       private
 
-      sig { returns(OutputStyle) }
+      #: -> OutputStyle
       def style
-        @style ||= T.let(Packwerk::OutputStyles::Coloured.new, T.nilable(Packwerk::OutputStyles::Coloured))
+        @style ||= Packwerk::OutputStyles::Coloured.new #: Packwerk::OutputStyles::Coloured?
       end
 
-      sig { params(offense: ReferenceOffense).returns(String) }
+      #: (ReferenceOffense offense) -> String
       def format_strict_mode_violation(offense)
         reference_package = offense.reference.package
         defining_package = offense.reference.constant.package
@@ -59,7 +61,7 @@ module Packwerk
           "the enforcing package's package.yml"
       end
 
-      sig { params(offenses: T::Array[T.nilable(Offense)]).returns(String) }
+      #: (Array[Offense?] offenses) -> String
       def offenses_list(offenses)
         offenses
           .compact
@@ -67,7 +69,7 @@ module Packwerk
           .join("\n")
       end
 
-      sig { params(offenses: T::Array[T.nilable(Offense)]).returns(String) }
+      #: (Array[Offense?] offenses) -> String
       def offenses_summary(offenses)
         offenses_string = "offense".pluralize(offenses.length)
         "#{offenses.length} #{offenses_string} detected"

data/lib/packwerk/formatters/progress_formatter.rb

@@ -6,15 +6,13 @@ require "benchmark"
 module Packwerk
   module Formatters
     class ProgressFormatter
-      extend T::Sig
-
-      sig { params(out: T.any(StringIO, IO), style: OutputStyle).void }
+      #: ((StringIO | IO) out, ?style: OutputStyle) -> void
       def initialize(out, style: OutputStyles::Plain.new)
         @out = out
         @style = style
       end
 
-      sig { params(block: T.proc.void).void }
+      #: { -> void } -> void
       def started_validation(&block)
         start_validation
 
@@ -22,7 +20,7 @@ module Packwerk
         finished(execution_time)
       end
 
-      sig { params(target_files: FilesForProcessing::RelativeFileSet, block: T.proc.void).void }
+      #: (FilesForProcessing::relative_file_set target_files) { -> void } -> void
       def started_inspection(target_files, &block)
         start_inspection(target_files)
 
@@ -30,7 +28,7 @@ module Packwerk
         finished(execution_time)
       end
 
-      sig { params(failed: T::Boolean).void }
+      #: (?bool failed) -> void
       def increment_progress(failed = false)
         if failed
           mark_as_failed
@@ -39,17 +37,17 @@ module Packwerk
         end
       end
 
-      sig { void }
+      #: -> void
       def mark_as_inspected
         @out.print(".")
       end
 
-      sig { void }
+      #: -> void
       def mark_as_failed
         @out.print("#{@style.error}E#{@style.reset}")
       end
 
-      sig { void }
+      #: -> void
       def interrupted
         @out.puts
         @out.puts("Manually interrupted. Violations caught so far are listed below:")
@@ -58,19 +56,19 @@ module Packwerk
 
       private
 
-      sig { params(execution_time: Float).void }
+      #: (Float execution_time) -> void
       def finished(execution_time)
         @out.puts
         @out.puts("📦 Finished in #{execution_time.round(2)} seconds")
         @out.puts
       end
 
-      sig { void }
+      #: -> void
       def start_validation
         @out.puts("📦 Packwerk is running validation...")
       end
 
-      sig { params(target_files: FilesForProcessing::RelativeFileSet).void }
+      #: (FilesForProcessing::relative_file_set target_files) -> void
       def start_inspection(target_files)
         files_size = target_files.size
         files_string = "file".pluralize(files_size)

data/lib/packwerk/generators/configuration_file.rb

@@ -6,26 +6,22 @@ require "erb"
 module Packwerk
   module Generators
     class ConfigurationFile
-      extend T::Sig
-
       CONFIGURATION_TEMPLATE_FILE_PATH = "templates/packwerk.yml.erb"
 
       class << self
-        extend T::Sig
-
-        sig { params(root: String, out: T.any(IO, StringIO)).returns(T::Boolean) }
+        #: (root: String, out: (IO | StringIO)) -> bool
         def generate(root:, out:)
           new(root: root, out: out).generate
         end
       end
 
-      sig { params(root: String, out: T.any(StringIO, IO)).void }
+      #: (root: String, ?out: (StringIO | IO)) -> void
       def initialize(root:, out: $stdout)
         @root = root
         @out = out
       end
 
-      sig { returns(T::Boolean) }
+      #: -> bool
       def generate
         @out.puts("📦 Generating Packwerk configuration file...")
         default_config_path = File.join(@root, Configuration::DEFAULT_CONFIG_PATH)
@@ -43,12 +39,12 @@ module Packwerk
 
       private
 
-      sig { returns(String) }
+      #: -> String
       def render
         ERB.new(template, trim_mode: "-").result(binding)
       end
 
-      sig { returns(String) }
+      #: -> String
       def template
         template_file_path = File.join(__dir__, CONFIGURATION_TEMPLATE_FILE_PATH)
         File.read(template_file_path)

data/lib/packwerk/generators/root_package.rb

@@ -4,24 +4,20 @@
 module Packwerk
   module Generators
     class RootPackage
-      extend T::Sig
-
       class << self
-        extend T::Sig
-
-        sig { params(root: String, out: T.any(IO, StringIO)).returns(T::Boolean) }
+        #: (root: String, out: (IO | StringIO)) -> bool
         def generate(root:, out:)
           new(root: root, out: out).generate
         end
       end
 
-      sig { params(root: String, out: T.any(IO, StringIO)).void }
+      #: (root: String, ?out: (IO | StringIO)) -> void
       def initialize(root:, out: $stdout)
         @root = root
         @out = out
       end
 
-      sig { returns(T::Boolean) }
+      #: -> bool
       def generate
         if Dir.glob("#{@root}/package.yml").any?
           @out.puts("⚠️  Root package already exists.")

data/lib/packwerk/graph.rb

@@ -8,13 +8,7 @@ module Packwerk
   class Graph
     include TSort
 
-    extend T::Sig
-    sig do
-      params(
-        # The edges of the graph; represented as an Hash of Arrays.
-        edges: T::Hash[T.any(String, Integer, NilClass), T::Array[T.any(String, Integer, NilClass)]]
-      ).void
-    end
+    #: (Hash[(String | Integer | NilClass), Array[(String | Integer | NilClass)]] edges) -> void
     def initialize(edges)
       @edges = edges
     end

data/lib/packwerk/node_helpers.rb

@@ -10,9 +10,7 @@ module Packwerk
     class TypeError < ArgumentError; end
 
     class << self
-      extend T::Sig
-
-      sig { params(class_or_module_node: AST::Node).returns(String) }
+      #: (AST::Node class_or_module_node) -> String
       def class_or_module_name(class_or_module_node)
         case type_of(class_or_module_node)
         when CLASS, MODULE
@@ -27,7 +25,7 @@ module Packwerk
         end
       end
 
-      sig { params(constant_node: AST::Node).returns(String) }
+      #: (AST::Node constant_node) -> String
       def constant_name(constant_node)
         case type_of(constant_node)
         when CONSTANT_ROOT_NAMESPACE
@@ -59,12 +57,7 @@ module Packwerk
         end
       end
 
-      sig do
-        params(
-          node: AST::Node,
-          block: T.nilable(T.proc.params(arg0: Parser::AST::Node).void),
-        ).returns(T::Enumerable[AST::Node])
-      end
+      #: (AST::Node node) ?{ (Parser::AST::Node arg0) -> void } -> Enumerable[AST::Node]
       def each_child(node, &block)
         if block
           node.children.each do |child|
@@ -75,7 +68,7 @@ module Packwerk
         end
       end
 
-      sig { params(starting_node: AST::Node, ancestors: T::Array[AST::Node]).returns(T::Array[String]) }
+      #: (AST::Node starting_node, ancestors: Array[AST::Node]) -> Array[String]
       def enclosing_namespace_path(starting_node, ancestors:)
         ancestors.select { |n| [CLASS, MODULE].include?(type_of(n)) }
           .each_with_object([]) do |node, namespace|
@@ -88,7 +81,7 @@ module Packwerk
         end
       end
 
-      sig { params(string_or_symbol_node: AST::Node).returns(T.any(String, Symbol)) }
+      #: (AST::Node string_or_symbol_node) -> (String | Symbol)
       def literal_value(string_or_symbol_node)
         case type_of(string_or_symbol_node)
         when STRING, SYMBOL
@@ -102,48 +95,48 @@ module Packwerk
         end
       end
 
-      sig { params(node: Parser::AST::Node).returns(Node::Location) }
+      #: (Parser::AST::Node node) -> Node::Location
       def location(node)
         location = node.location
         Node::Location.new(location.line, location.column)
       end
 
-      sig { params(node: AST::Node).returns(T::Boolean) }
+      #: (AST::Node node) -> bool
       def constant?(node)
         type_of(node) == CONSTANT
       end
 
-      sig { params(node: AST::Node).returns(T::Boolean) }
+      #: (AST::Node node) -> bool
       def constant_assignment?(node)
         type_of(node) == CONSTANT_ASSIGNMENT
       end
 
-      sig { params(node: AST::Node).returns(T::Boolean) }
+      #: (AST::Node node) -> bool
       def class?(node)
         type_of(node) == CLASS
       end
 
-      sig { params(node: AST::Node).returns(T::Boolean) }
+      #: (AST::Node node) -> bool
       def method_call?(node)
         type_of(node) == METHOD_CALL
       end
 
-      sig { params(node: AST::Node).returns(T::Boolean) }
+      #: (AST::Node node) -> bool
       def hash?(node)
         type_of(node) == HASH
       end
 
-      sig { params(node: AST::Node).returns(T::Boolean) }
+      #: (AST::Node node) -> bool
       def string?(node)
         type_of(node) == STRING
       end
 
-      sig { params(node: AST::Node).returns(T::Boolean) }
+      #: (AST::Node node) -> bool
       def symbol?(node)
         type_of(node) == SYMBOL
       end
 
-      sig { params(method_call_node: AST::Node).returns(T::Array[AST::Node]) }
+      #: (AST::Node method_call_node) -> Array[AST::Node]
       def method_arguments(method_call_node)
         raise TypeError unless method_call?(method_call_node)
 
@@ -152,7 +145,7 @@ module Packwerk
         method_call_node.children.slice(2..-1)
       end
 
-      sig { params(method_call_node: AST::Node).returns(Symbol) }
+      #: (AST::Node method_call_node) -> Symbol
       def method_name(method_call_node)
         raise TypeError unless method_call?(method_call_node)
 
@@ -161,7 +154,7 @@ module Packwerk
         method_call_node.children[1]
       end
 
-      sig { params(node: AST::Node).returns(T.nilable(String)) }
+      #: (AST::Node node) -> String?
       def module_name_from_definition(node)
         case type_of(node)
         when CLASS, MODULE
@@ -186,9 +179,10 @@ module Packwerk
         end
       end
 
-      sig { params(node: AST::Node).returns(T.nilable(Node::Location)) }
+      #: (AST::Node node) -> Node::Location?
       def name_location(node)
-        location = T.cast(node, Parser::AST::Node).location
+        location = node #: as Parser::AST::Node
+          .location
 
         if location.respond_to?(:name)
           name = location.name
@@ -196,7 +190,7 @@ module Packwerk
         end
       end
 
-      sig { params(class_node: AST::Node).returns(T.nilable(AST::Node)) }
+      #: (AST::Node class_node) -> AST::Node?
       def parent_class(class_node)
         raise TypeError unless type_of(class_node) == CLASS
 
@@ -205,7 +199,7 @@ module Packwerk
         class_node.children[1]
       end
 
-      sig { params(ancestors: T::Array[AST::Node]).returns(String) }
+      #: (ancestors: Array[AST::Node]) -> String
       def parent_module_name(ancestors:)
         definitions = ancestors
           .select { |n| [CLASS, MODULE, CONSTANT_ASSIGNMENT, BLOCK].include?(type_of(n)) }
@@ -217,7 +211,7 @@ module Packwerk
         names.empty? ? "Object" : names.reverse.join("::")
       end
 
-      sig { params(hash_node: AST::Node, key: Symbol).returns(T.untyped) }
+      #: (AST::Node hash_node, Symbol key) -> untyped
       def value_from_hash(hash_node, key)
         raise TypeError unless hash?(hash_node)
 
@@ -245,12 +239,12 @@ module Packwerk
         :MODULE, :SELF, :STRING, :SYMBOL,
       )
 
-      sig { params(node: AST::Node).returns(Symbol) }
+      #: (AST::Node node) -> Symbol
       def type_of(node)
         node.type
       end
 
-      sig { params(hash_pair_node: AST::Node).returns(T.untyped) }
+      #: (AST::Node hash_pair_node) -> untyped
       def hash_pair_key(hash_pair_node)
         raise TypeError unless type_of(hash_pair_node) == HASH_PAIR
 
@@ -261,7 +255,7 @@ module Packwerk
         hash_pair_node.children[0]
       end
 
-      sig { params(hash_pair_node: AST::Node).returns(T.untyped) }
+      #: (AST::Node hash_pair_node) -> untyped
       def hash_pair_value(hash_pair_node)
         raise TypeError unless type_of(hash_pair_node) == HASH_PAIR
 
@@ -272,7 +266,7 @@ module Packwerk
         hash_pair_node.children[1]
       end
 
-      sig { params(hash_node: AST::Node).returns(T::Array[AST::Node]) }
+      #: (AST::Node hash_node) -> Array[AST::Node]
       def hash_pairs(hash_node)
         raise TypeError unless hash?(hash_node)
 
@@ -281,7 +275,7 @@ module Packwerk
         hash_node.children.select { |n| type_of(n) == HASH_PAIR }
       end
 
-      sig { params(block_node: AST::Node).returns(AST::Node) }
+      #: (AST::Node block_node) -> AST::Node
       def method_call_node(block_node)
         raise TypeError unless type_of(block_node) == BLOCK
 
@@ -290,7 +284,7 @@ module Packwerk
         block_node.children[0]
       end
 
-      sig { params(node: AST::Node).returns(T::Boolean) }
+      #: (AST::Node node) -> bool
       def module_creation?(node)
         # "Class.new"
         # "Module.new"
@@ -299,14 +293,14 @@ module Packwerk
           method_name(node) == :new
       end
 
-      sig { params(node: T.nilable(AST::Node)).returns(T::Boolean) }
+      #: (AST::Node? node) -> bool
       def dynamic_class_creation?(node)
         !!node &&
           constant?(node) &&
           ["Class", "Module"].include?(constant_name(node))
       end
 
-      sig { params(node: AST::Node).returns(T.nilable(String)) }
+      #: (AST::Node node) -> String?
       def name_from_block_definition(node)
         if method_name(method_call_node(node)) == :class_eval
           receiver = receiver(node)
@@ -314,7 +308,7 @@ module Packwerk
         end
       end
 
-      sig { params(node: AST::Node).returns(T.nilable(String)) }
+      #: (AST::Node node) -> String?
       def name_part_from_definition(node)
         case type_of(node)
         when CLASS, MODULE, CONSTANT_ASSIGNMENT
@@ -324,7 +318,7 @@ module Packwerk
         end
       end
 
-      sig { params(method_call_or_block_node: AST::Node).returns(T.nilable(AST::Node)) }
+      #: (AST::Node method_call_or_block_node) -> AST::Node?
       def receiver(method_call_or_block_node)
         case type_of(method_call_or_block_node)
         when METHOD_CALL

data/lib/packwerk/node_processor.rb

@@ -4,25 +4,13 @@
 module Packwerk
   # Processes a single node in an abstract syntax tree (AST) using the provided checkers.
   class NodeProcessor
-    extend T::Sig
-
-    sig do
-      params(
-        reference_extractor: ReferenceExtractor,
-        relative_file: String,
-      ).void
-    end
+    #: (reference_extractor: ReferenceExtractor, relative_file: String) -> void
     def initialize(reference_extractor:, relative_file:)
       @reference_extractor = reference_extractor
       @relative_file = relative_file
     end
 
-    sig do
-      params(
-        node: Parser::AST::Node,
-        ancestors: T::Array[Parser::AST::Node]
-      ).returns(T.nilable(UnresolvedReference))
-    end
+    #: (Parser::AST::Node node, Array[Parser::AST::Node] ancestors) -> UnresolvedReference?
     def call(node, ancestors)
       return unless NodeHelpers.method_call?(node) || NodeHelpers.constant?(node)
 

data/lib/packwerk/node_processor_factory.rb

@@ -2,14 +2,20 @@
 # frozen_string_literal: true
 
 module Packwerk
-  class NodeProcessorFactory < T::Struct
-    extend T::Sig
+  class NodeProcessorFactory
+    #: String
+    attr_reader :root_path
 
-    const :root_path, String
-    const :context_provider, ConstantDiscovery
-    const :constant_name_inspectors, T::Array[ConstantNameInspector]
+    #: Array[ConstantNameInspector]
+    attr_reader :constant_name_inspectors
 
-    sig { params(relative_file: String, node: AST::Node).returns(NodeProcessor) }
+    #: (root_path: String, constant_name_inspectors: Array[ConstantNameInspector]) -> void
+    def initialize(root_path:, constant_name_inspectors:)
+      @root_path = root_path
+      @constant_name_inspectors = constant_name_inspectors
+    end
+
+    #: (relative_file: String, node: AST::Node) -> NodeProcessor
     def for(relative_file:, node:)
       NodeProcessor.new(
         reference_extractor: reference_extractor(node: node),
@@ -19,7 +25,7 @@ module Packwerk
 
     private
 
-    sig { params(node: AST::Node).returns(ReferenceExtractor) }
+    #: (node: AST::Node) -> ReferenceExtractor
     def reference_extractor(node:)
       ReferenceExtractor.new(
         constant_name_inspectors: constant_name_inspectors,