packwerk 3.2.3 → 3.3.0

data/lib/packwerk/node_visitor.rb

@@ -4,20 +4,12 @@
 module Packwerk
   # Visits all nodes of an AST, processing them using a given node processor.
   class NodeVisitor
-    extend T::Sig
-
-    sig { params(node_processor: NodeProcessor).void }
+    #: (node_processor: NodeProcessor) -> void
     def initialize(node_processor:)
       @node_processor = node_processor
     end
 
-    sig do
-      params(
-        node: Parser::AST::Node,
-        ancestors: T::Array[Parser::AST::Node],
-        result: T::Array[UnresolvedReference],
-      ).void
-    end
+    #: (Parser::AST::Node node, ancestors: Array[Parser::AST::Node], result: Array[UnresolvedReference]) -> void
     def visit(node, ancestors:, result:)
       reference = @node_processor.call(node, ancestors)
       result << reference if reference

data/lib/packwerk/offense.rb

@@ -1,33 +1,27 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "parser/source/map"
+require "parser"
 
 module Packwerk
   class Offense
-    extend T::Sig
-    extend T::Helpers
-
-    sig { returns(T.nilable(Node::Location)) }
+    #: Node::Location?
     attr_reader :location
 
-    sig { returns(String) }
+    #: String
     attr_reader :file
 
-    sig { returns(String) }
+    #: String
     attr_reader :message
 
-    sig do
-      params(file: String, message: String, location: T.nilable(Node::Location))
-        .void
-    end
+    #: (file: String, message: String, ?location: Node::Location?) -> void
     def initialize(file:, message:, location: nil)
       @location = location
       @file = file
       @message = message
     end
 
-    sig { params(style: OutputStyle).returns(String) }
+    #: (?OutputStyle style) -> String
     def to_s(style = OutputStyles::Plain.new)
       location = self.location
       if location

data/lib/packwerk/offense_collection.rb

@@ -5,50 +5,37 @@ require "pathname"
 
 module Packwerk
   class OffenseCollection
-    extend T::Sig
-    extend T::Helpers
-
-    sig do
-      params(
-        root_path: String,
-        package_todos: T::Hash[Packwerk::Package, Packwerk::PackageTodo]
-      ).void
-    end
+    #: (String root_path, ?Hash[Packwerk::Package, Packwerk::PackageTodo] package_todos) -> void
     def initialize(root_path, package_todos = {})
       @root_path = root_path
-      @package_todos = T.let(package_todos, T::Hash[Packwerk::Package, Packwerk::PackageTodo])
-      @new_violations = T.let([], T::Array[Packwerk::ReferenceOffense])
-      @strict_mode_violations = T.let([], T::Array[Packwerk::ReferenceOffense])
-      @errors = T.let([], T::Array[Packwerk::Offense])
+      @package_todos = package_todos #: Hash[Packwerk::Package, Packwerk::PackageTodo]
+      @new_violations = [] #: Array[Packwerk::ReferenceOffense]
+      @strict_mode_violations = [] #: Array[Packwerk::ReferenceOffense]
+      @errors = [] #: Array[Packwerk::Offense]
     end
 
-    sig { returns(T::Array[Packwerk::ReferenceOffense]) }
+    #: Array[Packwerk::ReferenceOffense]
     attr_reader :new_violations
 
-    sig { returns(T::Array[Packwerk::Offense]) }
+    #: Array[Packwerk::Offense]
     attr_reader :errors
 
-    sig { returns(T::Array[Packwerk::ReferenceOffense]) }
+    #: Array[Packwerk::ReferenceOffense]
     attr_reader :strict_mode_violations
 
-    sig do
-      params(offense: Packwerk::Offense)
-        .returns(T::Boolean)
-    end
+    #: (Packwerk::Offense offense) -> bool
     def listed?(offense)
       return false unless offense.is_a?(ReferenceOffense)
 
       already_listed?(offense)
     end
 
-    sig { params(offenses: T::Array[Offense]).void }
+    #: (Array[Offense] offenses) -> void
     def add_offenses(offenses)
       offenses.each { |offense| add_offense(offense) }
     end
 
-    sig do
-      params(offense: Packwerk::Offense).void
-    end
+    #: (Packwerk::Offense offense) -> void
     def add_offense(offense)
       unless offense.is_a?(ReferenceOffense)
         @errors << offense
@@ -67,50 +54,50 @@ module Packwerk
       end
     end
 
-    sig { params(for_files: T::Set[String]).returns(T::Boolean) }
+    #: (Set[String] for_files) -> bool
     def stale_violations?(for_files)
       @package_todos.values.any? do |package_todo|
         package_todo.stale_violations?(for_files)
       end
     end
 
-    sig { params(package_set: Packwerk::PackageSet).void }
+    #: (Packwerk::PackageSet package_set) -> void
     def persist_package_todo_files(package_set)
       dump_package_todo_files
       cleanup_extra_package_todo_files(package_set)
     end
 
-    sig { returns(T::Array[Packwerk::Offense]) }
+    #: -> Array[Packwerk::Offense]
     def outstanding_offenses
       errors + new_violations
     end
 
-    sig { returns(T::Array[Packwerk::ReferenceOffense]) }
+    #: -> Array[Packwerk::ReferenceOffense]
     def unlisted_strict_mode_violations
       strict_mode_violations.reject { |offense| already_listed?(offense) }
     end
 
     private
 
-    sig { params(offense: ReferenceOffense).returns(T::Boolean) }
+    #: (ReferenceOffense offense) -> bool
     def already_listed?(offense)
       package_todo_for(offense.reference.package).listed?(offense.reference,
         violation_type: offense.violation_type)
     end
 
-    sig { params(offense: ReferenceOffense).returns(T::Boolean) }
+    #: (ReferenceOffense offense) -> bool
     def add_to_package_todo(offense)
       package_todo_for(offense.reference.package).add_entries(offense.reference,
         offense.violation_type)
     end
 
-    sig { params(offense: ReferenceOffense).returns(T::Boolean) }
+    #: (ReferenceOffense offense) -> bool
     def strict_mode_violation?(offense)
       checker = Checker.find(offense.violation_type)
       checker.strict_mode_violation?(offense)
     end
 
-    sig { params(package_set: Packwerk::PackageSet).void }
+    #: (Packwerk::PackageSet package_set) -> void
     def cleanup_extra_package_todo_files(package_set)
       packages_without_todos = (package_set.packages.values - @package_todos.keys)
 
@@ -122,12 +109,12 @@ module Packwerk
       end
     end
 
-    sig { void }
+    #: -> void
     def dump_package_todo_files
       @package_todos.each_value(&:dump)
     end
 
-    sig { params(package: Packwerk::Package).returns(Packwerk::PackageTodo) }
+    #: (Packwerk::Package package) -> Packwerk::PackageTodo
     def package_todo_for(package)
       @package_todos[package] ||= Packwerk::PackageTodo.new(
         package,
@@ -135,7 +122,7 @@ module Packwerk
       )
     end
 
-    sig { params(package: Packwerk::Package).returns(String) }
+    #: (Packwerk::Package package) -> String
     def package_todo_file_for(package)
       File.join(@root_path, package.name, "package_todo.yml")
     end

data/lib/packwerk/offenses_formatter.rb

@@ -2,84 +2,77 @@
 # frozen_string_literal: true
 
 module Packwerk
+  # @abstract
   module OffensesFormatter
-    extend T::Sig
-    extend T::Helpers
-
-    abstract!
-
     class DuplicateFormatterError < StandardError
-      extend T::Sig
-
-      sig { params(identifier: String).void }
+      #: (String identifier) -> void
       def initialize(identifier)
         super("Cannot have multiple identifiers with the same key (`#{identifier}`)")
       end
     end
 
     class << self
-      extend T::Sig
-
-      sig { params(base: T::Class[T.anything]).void }
+      #: (Class[top] base) -> void
       def included(base)
         offenses_formatters << base
       end
 
-      sig { returns(T::Array[OffensesFormatter]) }
+      #: -> Array[OffensesFormatter]
       def all
         load_defaults
-        T.cast(offenses_formatters.map(&:new), T::Array[OffensesFormatter])
+        offenses_formatters.map(&:new) #: as Array[OffensesFormatter]
       end
 
-      sig { params(identifier: String).returns(OffensesFormatter) }
+      #: (String identifier) -> OffensesFormatter
       def find(identifier)
         formatter_by_identifier(identifier)
       end
 
       private
 
-      sig { void }
+      #: -> void
       def load_defaults
         require("packwerk/formatters/default_offenses_formatter")
       end
 
-      sig { returns(T::Array[T::Class[T.anything]]) }
+      #: -> Array[Class[top]]
       def offenses_formatters
-        @offenses_formatters ||= T.let([], T.nilable(T::Array[T::Class[T.anything]]))
+        @offenses_formatters ||= [] #: Array[Class[top]]?
       end
 
-      sig { params(name: String).returns(OffensesFormatter) }
+      #: (String name) -> OffensesFormatter
       def formatter_by_identifier(name)
-        @formatter_by_identifier ||= T.let(nil, T.nilable(T::Hash[String, T.nilable(OffensesFormatter)]))
+        @formatter_by_identifier ||= nil #: Hash[String, OffensesFormatter?]?
         @formatter_by_identifier ||= begin
-          index = T.let({}, T::Hash[String, T.nilable(OffensesFormatter)])
+          index = {} #: Hash[String, OffensesFormatter?]
           OffensesFormatter.all.each do |formatter|
             identifier = formatter.identifier
             raise DuplicateFormatterError, identifier if index.key?(identifier)
 
             index[identifier] = formatter
           end
-          T.let(index, T.nilable(T::Hash[String, T.nilable(OffensesFormatter)]))
+          index #: Hash[String, OffensesFormatter?]?
         end
 
-        T.must(T.must(@formatter_by_identifier)[name])
+        formatter_by_identifier = @formatter_by_identifier #: as !nil
+        formatter_by_identifier[name] #: as !nil
       end
     end
 
-    sig { abstract.params(offenses: T::Array[T.nilable(Offense)]).returns(String) }
-    def show_offenses(offenses)
-    end
+    # @abstract
+    #: (Array[Offense?] offenses) -> String
+    def show_offenses(offenses) = raise NotImplementedError, "Abstract method called"
 
-    sig { abstract.params(offense_collection: OffenseCollection, for_files: T::Set[String]).returns(String) }
-    def show_stale_violations(offense_collection, for_files)
-    end
+    # @abstract
+    #: (OffenseCollection offense_collection, Set[String] for_files) -> String
+    def show_stale_violations(offense_collection, for_files) = raise NotImplementedError, "Abstract method called"
 
-    sig { abstract.returns(String) }
-    def identifier
-    end
+    # @abstract
+    #: -> String
+    def identifier = raise NotImplementedError, "Abstract method called"
 
-    sig { abstract.params(strict_mode_violations: T::Array[ReferenceOffense]).returns(String) }
-    def show_strict_mode_violations(strict_mode_violations)
-    end
+    # @abstract
+    #: (Array[ReferenceOffense] strict_mode_violations) -> String
+    def show_strict_mode_violations(strict_mode_violations) = raise NotImplementedError, "Abstract method called"
   end
 end

data/lib/packwerk/output_style.rb

@@ -2,19 +2,18 @@
 # frozen_string_literal: true
 
 module Packwerk
+  # @interface
   module OutputStyle
-    extend T::Sig
-    extend T::Helpers
+    # @abstract
+    #: -> String
+    def reset = raise NotImplementedError, "Abstract method called"
 
-    interface!
+    # @abstract
+    #: -> String
+    def filename = raise NotImplementedError, "Abstract method called"
 
-    sig { abstract.returns(String) }
-    def reset; end
-
-    sig { abstract.returns(String) }
-    def filename; end
-
-    sig { abstract.returns(String) }
-    def error; end
+    # @abstract
+    #: -> String
+    def error = raise NotImplementedError, "Abstract method called"
   end
 end

data/lib/packwerk/output_styles/coloured.rb

@@ -5,21 +5,23 @@ module Packwerk
   module OutputStyles
     # See https://en.wikipedia.org/wiki/ANSI_escape_code#3/4_bit for ANSI escape colour codes
     class Coloured
-      extend T::Sig
       include OutputStyle
 
-      sig { override.returns(String) }
+      # @override
+      #: -> String
       def reset
         "\033[m"
       end
 
-      sig { override.returns(String) }
+      # @override
+      #: -> String
       def filename
         # 36 is foreground cyan
         "\033[36m"
       end
 
-      sig { override.returns(String) }
+      # @override
+      #: -> String
       def error
         # 31 is foreground red
         "\033[31m"

data/lib/packwerk/output_styles/plain.rb

@@ -4,20 +4,22 @@
 module Packwerk
   module OutputStyles
     class Plain
-      extend T::Sig
       include OutputStyle
 
-      sig { override.returns(String) }
+      # @override
+      #: -> String
       def reset
         ""
       end
 
-      sig { override.returns(String) }
+      # @override
+      #: -> String
       def filename
         ""
       end
 
-      sig { override.returns(String) }
+      # @override
+      #: -> String
       def error
         ""
       end

data/lib/packwerk/package.rb

@@ -6,68 +6,67 @@ module Packwerk
   # The package contains all constants defined in files in this folder and all subfolders that are not packages
   # themselves.
   class Package
-    extend T::Sig
     include Comparable
 
     ROOT_PACKAGE_NAME = "."
 
-    sig { returns(String) }
+    #: String
     attr_reader :name
 
-    sig { returns(T::Array[String]) }
+    #: Array[String]
     attr_reader :dependencies
 
-    sig { returns(T::Hash[T.untyped, T.untyped]) }
+    #: Hash[untyped, untyped]
     attr_reader :config
 
-    sig { params(name: String, config: T.nilable(T::Hash[String, T.untyped])).void }
+    #: (name: String, ?config: Hash[String, untyped]?) -> void
     def initialize(name:, config: nil)
       @name = name
-      @config = T.let(config || {}, T::Hash[String, T.untyped])
-      @dependencies = T.let(Array(@config["dependencies"]).freeze, T::Array[String])
-      @public_path = T.let(nil, T.nilable(String))
+      @config = config || {} #: Hash[String, untyped]
+      @dependencies = Array(@config["dependencies"]).freeze #: Array[String]
+      @public_path = nil #: String?
     end
 
-    sig { returns(T::Boolean) }
+    #: -> bool
     def enforce_dependencies?
       [true, "strict"].include?(@config["enforce_dependencies"])
     end
 
-    sig { params(package: Package).returns(T::Boolean) }
+    #: (Package package) -> bool
     def dependency?(package)
       @dependencies.include?(package.name)
     end
 
-    sig { params(path: String).returns(T::Boolean) }
+    #: (String path) -> bool
     def package_path?(path)
       return true if root?
 
       path.start_with?(@name + "/")
     end
 
-    sig { params(other: T.untyped).returns(T.nilable(Integer)) }
+    #: (untyped other) -> Integer?
     def <=>(other)
       return nil unless other.is_a?(self.class)
 
       name <=> other.name
     end
 
-    sig { params(other: T.untyped).returns(T::Boolean) }
+    #: (untyped other) -> bool
     def eql?(other)
       self == other
     end
 
-    sig { returns(Integer) }
+    #: -> Integer
     def hash
       name.hash
     end
 
-    sig { returns(String) }
+    #: -> String
     def to_s
       name
     end
 
-    sig { returns(T::Boolean) }
+    #: -> bool
     def root?
       @name == ROOT_PACKAGE_NAME
     end

data/lib/packwerk/package_set.rb

@@ -5,22 +5,17 @@ require "pathname"
 require "bundler"
 
 module Packwerk
-  PathSpec = T.type_alias { T.any(String, T::Array[String]) }
+  #: type path_spec = String | Array[String]
 
   # A set of {Packwerk::Package}s as well as methods to parse packages from the filesystem.
+  #: [Elem = Package]
   class PackageSet
-    extend T::Sig
-    extend T::Generic
     include Enumerable
 
-    Elem = type_member { { fixed: Package } }
-
     PACKAGE_CONFIG_FILENAME = "package.yml"
 
     class << self
-      extend T::Sig
-
-      sig { params(root_path: String, package_pathspec: T.nilable(PathSpec)).returns(PackageSet) }
+      #: (String root_path, ?package_pathspec: path_spec?) -> PackageSet
       def load_all_from(root_path, package_pathspec: nil)
         package_paths = package_paths(root_path, package_pathspec || "**")
 
@@ -34,13 +29,7 @@ module Packwerk
         new(packages)
       end
 
-      sig do
-        params(
-          root_path: String,
-          package_pathspec: PathSpec,
-          exclude_pathspec: T.nilable(PathSpec)
-        ).returns(T::Array[Pathname])
-      end
+      #: (String root_path, path_spec package_pathspec, ?path_spec? exclude_pathspec) -> Array[Pathname]
       def package_paths(root_path, package_pathspec, exclude_pathspec = [])
         exclude_pathspec = Array(exclude_pathspec).dup
           .push(Bundler.bundle_path.join("**").to_s)
@@ -57,14 +46,14 @@ module Packwerk
 
       private
 
-      sig { params(packages: T::Array[Package]).void }
+      #: (Array[Package] packages) -> void
       def create_root_package_if_none_in(packages)
         return if packages.any?(&:root?)
 
         packages << Package.new(name: Package::ROOT_PACKAGE_NAME, config: nil)
       end
 
-      sig { params(globs: T::Array[String], path: Pathname).returns(T::Boolean) }
+      #: (Array[String] globs, Pathname path) -> bool
       def exclude_path?(globs, path)
         globs.any? do |glob|
           path.realpath.fnmatch(glob, File::FNM_EXTGLOB)
@@ -72,32 +61,33 @@ module Packwerk
       end
     end
 
-    sig { returns(T::Hash[String, Package]) }
+    #: Hash[String, Package]
     attr_reader :packages
 
-    sig { params(packages: T::Array[Package]).void }
+    #: (Array[Package] packages) -> void
     def initialize(packages)
       # We want to match more specific paths first
       sorted_packages = packages.sort_by { |package| -package.name.length }
       packages = sorted_packages.each_with_object({}) { |package, hash| hash[package.name] = package }
-      @packages = T.let(packages, T::Hash[String, Package])
-      @package_from_path = T.let({}, T::Hash[String, T.nilable(Package)])
+      @packages = packages #: Hash[String, Package]
+      @package_from_path = {} #: Hash[String, Package?]
     end
 
-    sig { override.params(blk: T.proc.params(arg0: Package).returns(T.untyped)).returns(T.untyped) }
+    # @override
+    #: { (Package arg0) -> untyped } -> untyped
     def each(&blk)
       packages.values.each(&blk)
     end
 
-    sig { params(name: String).returns(T.nilable(Package)) }
+    #: (String name) -> Package?
     def fetch(name)
       packages[name]
     end
 
-    sig { params(file_path: T.any(Pathname, String)).returns(Package) }
+    #: ((Pathname | String) file_path) -> Package
     def package_from_path(file_path)
       path_string = file_path.to_s
-      @package_from_path[path_string] ||= T.must(packages.values.find { |package| package.package_path?(path_string) })
+      @package_from_path[path_string] ||= packages.values.find { |package| package.package_path?(path_string) } #: as !nil
     end
   end
 end