packwerk 3.2.3 → 3.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9b01578e447c49b16c57f33b6bfb111f65f91046b12465a433da90c30d6d1f7e
-  data.tar.gz: 731840a1431c1ac5305a30489379cd36a8c345e52589282eed80d694d2cc9b9a
+  metadata.gz: '087052a5ee210069f8924a622aec5c335221c0b2558ab9773e08bb1a674a3802'
+  data.tar.gz: '09e3fa99ed0eb9ee0d73803725667ea21d3e200c16bb4d7cd2c487784a55d457'
 SHA512:
-  metadata.gz: 26ff296eba5296f6674ebd963d4a5a3868a3a18d2464420d6ca3523745f8b5bfe6652c193cd43e6aa0304fe53bbba642857a956e89ae7b94e893edd47e47fb95
-  data.tar.gz: 742bdcfab120757f90621cea4301b84036cfdf0747809d1116a972c9076cd448451723f7b8fa1f62baeebfe0e539be71c1e4fdb319925130c9103af22780d143
+  metadata.gz: f1a4719aec0613776fa7ae34d7518a3c88142bd9f82875b1e8a0e257a6832c3e2ae6546997a58922e7c3a04de39e59bc7cb50bd2cf650701417711d99a1458fb
+  data.tar.gz: f2e0e1a12f63a9ec25daa3e34ed5ba13ef4129e172665a103f4938cdc06a0a9d3a804f83eb8984ed5dfbee74d22fc6b0185f2b6ba4688d22ce230712d6b70f09

data/exe/packwerk

@@ -1,10 +1,6 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-unless defined?(Spring)
-  require "packwerk/disable_sorbet"
-end
-
 require "packwerk"
 
 # Needs to be run in test environment in order to have test helper paths available in the autoload paths

data/lib/packwerk/application_validator.rb

@@ -10,18 +10,18 @@ module Packwerk
   # correct results.
   class ApplicationValidator
     include Validator
-    extend T::Sig
     extend ActiveSupport::Autoload
 
     autoload :Helpers
 
-    sig { params(package_set: PackageSet, configuration: Configuration).returns(Validator::Result) }
+    #: (PackageSet package_set, Configuration configuration) -> Validator::Result
     def check_all(package_set, configuration)
       results = Validator.all.flat_map { |validator| validator.call(package_set, configuration) }
       merge_results(results)
     end
 
-    sig { override.params(package_set: PackageSet, configuration: Configuration).returns(Validator::Result) }
+    # @override
+    #: (PackageSet package_set, Configuration configuration) -> Validator::Result
     def call(package_set, configuration)
       results = [
         check_package_manifest_syntax(configuration),
@@ -33,14 +33,15 @@ module Packwerk
       merge_results(results, separator: "\n❓ ")
     end
 
-    sig { override.returns(T::Array[String]) }
+    # @override
+    #: -> Array[String]
     def permitted_keys
       [
         "metadata",
       ]
     end
 
-    sig { params(configuration: Configuration).returns(Validator::Result) }
+    #: (Configuration configuration) -> Validator::Result
     def check_package_manifest_syntax(configuration)
       errors = []
 
@@ -68,7 +69,7 @@ module Packwerk
       end
     end
 
-    sig { params(configuration: Configuration).returns(Validator::Result) }
+    #: (Configuration configuration) -> Validator::Result
     def check_application_structure(configuration)
       resolver = ConstantResolver.new(
         root_path: configuration.root_path.to_s,
@@ -84,7 +85,7 @@ module Packwerk
       end
     end
 
-    sig { params(configuration: Configuration).returns(Validator::Result) }
+    #: (Configuration configuration) -> Validator::Result
     def check_package_manifest_paths(configuration)
       all_package_manifests = package_manifests(configuration, "**/")
       package_paths_package_manifests = package_manifests(configuration, package_glob(configuration))
@@ -105,7 +106,7 @@ module Packwerk
       end
     end
 
-    sig { params(configuration: Configuration).returns(Validator::Result) }
+    #: (Configuration configuration) -> Validator::Result
     def check_root_package_exists(configuration)
       root_package_path = File.join(configuration.root_path, "package.yml")
       all_packages_manifests = package_manifests(configuration, package_glob(configuration))
@@ -124,12 +125,12 @@ module Packwerk
 
     private
 
-    sig { params(list: T.untyped).returns(T.untyped) }
+    #: (untyped list) -> untyped
     def format_yaml_strings(list)
       list.sort.map { |p| "- \"#{p}\"" }.join("\n")
     end
 
-    sig { params(configuration: Configuration, paths: T::Array[String]).returns(T::Array[Pathname]) }
+    #: (Configuration configuration, Array[String] paths) -> Array[Pathname]
     def relative_paths(configuration, paths)
       paths.map { |path| relative_path(configuration, path) }
     end

data/lib/packwerk/association_inspector.rb

@@ -4,39 +4,28 @@
 module Packwerk
   # Extracts the implicit constant reference from an active record association
   class AssociationInspector
-    extend T::Sig
     include ConstantNameInspector
 
-    CustomAssociations = T.type_alias { T.any(T::Array[Symbol], T::Set[Symbol]) }
-
-    RAILS_ASSOCIATIONS = T.let(
-      [
-        :belongs_to,
-        :has_many,
-        :has_one,
-        :has_and_belongs_to_many,
-      ].to_set,
-      CustomAssociations
-    )
-
-    sig do
-      params(
-        inflector: T.class_of(ActiveSupport::Inflector),
-        custom_associations: CustomAssociations,
-        excluded_files: T::Set[String]
-      ).void
-    end
+    RAILS_ASSOCIATIONS = [
+      :belongs_to,
+      :has_many,
+      :has_one,
+      :has_and_belongs_to_many,
+    ].to_set #: Set[Symbol]
+
+    #: (
+    #|   inflector: singleton(ActiveSupport::Inflector),
+    #|   ?custom_associations: Set[Symbol],
+    #|   ?excluded_files: Set[String]
+    #| ) -> void
     def initialize(inflector:, custom_associations: Set.new, excluded_files: Set.new)
       @inflector = inflector
-      @associations = T.let(RAILS_ASSOCIATIONS + custom_associations, CustomAssociations)
-      @excluded_files = T.let(excluded_files, T::Set[String])
+      @associations = RAILS_ASSOCIATIONS + custom_associations #: Set[Symbol]
+      @excluded_files = excluded_files #: Set[String]
     end
 
-    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 unless NodeHelpers.method_call?(node)
       return if excluded?(relative_file)
@@ -56,18 +45,18 @@ module Packwerk
 
     private
 
-    sig { params(relative_file: String).returns(T::Boolean) }
+    #: (String relative_file) -> bool
     def excluded?(relative_file)
       @excluded_files.include?(relative_file)
     end
 
-    sig { params(node: AST::Node).returns(T::Boolean) }
+    #: (AST::Node node) -> bool
     def association?(node)
       method_name = NodeHelpers.method_name(node)
       @associations.include?(method_name)
     end
 
-    sig { params(arguments: T::Array[AST::Node]).returns(T.nilable(AST::Node)) }
+    #: (Array[AST::Node] arguments) -> AST::Node?
     def custom_class_name(arguments)
       association_options = arguments.detect { |n| NodeHelpers.hash?(n) }
       return unless association_options
@@ -75,9 +64,9 @@ module Packwerk
       NodeHelpers.value_from_hash(association_options, :class_name)
     end
 
-    sig { params(arguments: T::Array[AST::Node]).returns(T.any(T.nilable(Symbol), T.nilable(String))) }
+    #: (Array[AST::Node] arguments) -> (Symbol | String)?
     def association_name(arguments)
-      association_name_node = T.must(arguments[0])
+      association_name_node = arguments[0] #: as !nil
       return unless NodeHelpers.symbol?(association_name_node)
 
       NodeHelpers.literal_value(association_name_node)

data/lib/packwerk/cache.rb

@@ -5,18 +5,21 @@ require "digest"
 
 module Packwerk
   class Cache
-    extend T::Sig
+    class CacheContents
+      #: String
+      attr_reader :file_contents_digest
 
-    class CacheContents < T::Struct
-      extend T::Sig
+      #: Array[UnresolvedReference]
+      attr_reader :unresolved_references
 
-      const :file_contents_digest, String
-      const :unresolved_references, T::Array[UnresolvedReference]
+      #: (file_contents_digest: String, unresolved_references: Array[UnresolvedReference]) -> void
+      def initialize(file_contents_digest:, unresolved_references:)
+        @file_contents_digest = file_contents_digest
+        @unresolved_references = unresolved_references
+      end
 
       class << self
-        extend T::Sig
-
-        sig { params(serialized_cache_contents: String).returns(CacheContents) }
+        #: (String serialized_cache_contents) -> CacheContents
         def deserialize(serialized_cache_contents)
           cache_contents_json = JSON.parse(serialized_cache_contents)
           unresolved_references = cache_contents_json["unresolved_references"].map do |json|
@@ -35,24 +38,36 @@ module Packwerk
         end
       end
 
-      sig { returns(String) }
+      #: (*untyped _args) -> String
+      def to_json(*_args)
+        JSON.generate({
+          file_contents_digest: @file_contents_digest,
+          unresolved_references: @unresolved_references.map do |ref|
+            source_location = ref.source_location #: as !nil
+
+            {
+              constant_name: ref.constant_name,
+              namespace_path: ref.namespace_path,
+              relative_path: ref.relative_path,
+              source_location: { line: source_location.line, column: source_location.column },
+            }
+          end,
+        })
+      end
+
+      #: -> String
       def serialize
         to_json
       end
     end
 
-    CacheShape = T.type_alias do
-      T::Hash[
-        String,
-        CacheContents
-      ]
-    end
+    #: type cache_shape = Hash[String, CacheContents]
 
-    sig { params(enable_cache: T::Boolean, cache_directory: Pathname, config_path: T.nilable(String)).void }
+    #: (enable_cache: bool, cache_directory: Pathname, config_path: String?) -> void
     def initialize(enable_cache:, cache_directory:, config_path:)
       @enable_cache = enable_cache
-      @cache = T.let({}, CacheShape)
-      @files_by_digest = T.let({}, T::Hash[String, String])
+      @cache = {} #: cache_shape
+      @files_by_digest = {} #: Hash[String, String]
       @config_path = config_path
       @cache_directory = cache_directory
 
@@ -63,25 +78,19 @@ module Packwerk
       end
     end
 
-    sig { void }
+    #: -> void
     def bust_cache!
       FileUtils.rm_rf(@cache_directory)
     end
 
-    sig do
-      params(
-        file_path: String,
-        block: T.proc.returns(T::Array[UnresolvedReference])
-      ).returns(T::Array[UnresolvedReference])
-    end
+    #: (String file_path) { -> Array[UnresolvedReference] } -> Array[UnresolvedReference]
     def with_cache(file_path, &block)
       return yield unless @enable_cache
 
       cache_location = @cache_directory.join(digest_for_string(file_path))
 
       cache_contents = if cache_location.exist?
-        T.let(CacheContents.deserialize(cache_location.read),
-          CacheContents)
+        CacheContents.deserialize(cache_location.read) #: CacheContents
       end
 
       file_contents_digest = digest_for_file(file_path)
@@ -105,31 +114,31 @@ module Packwerk
       end
     end
 
-    sig { params(file: String).returns(String) }
+    #: (String file) -> String
     def digest_for_file(file)
       digest_for_string(File.read(file))
     end
 
-    sig { params(str: String).returns(String) }
+    #: (String str) -> String
     def digest_for_string(str)
       # MD5 appears to be the fastest
       # https://gist.github.com/morimori/1330095
       Digest::MD5.hexdigest(str)
     end
 
-    sig { void }
+    #: -> void
     def bust_cache_if_packwerk_yml_has_changed!
       return nil if @config_path.nil?
 
       bust_cache_if_contents_have_changed(File.read(@config_path), :packwerk_yml)
     end
 
-    sig { void }
+    #: -> void
     def bust_cache_if_inflections_have_changed!
       bust_cache_if_contents_have_changed(YAML.dump(ActiveSupport::Inflector.inflections), :inflections)
     end
 
-    sig { params(contents: String, contents_key: Symbol).void }
+    #: (String contents, Symbol contents_key) -> void
     def bust_cache_if_contents_have_changed(contents, contents_key)
       current_digest = digest_for_string(contents)
       cached_digest_path = @cache_directory.join(contents_key.to_s)
@@ -153,7 +162,7 @@ module Packwerk
       end
     end
 
-    sig { void }
+    #: -> void
     def create_cache_directory!
       FileUtils.mkdir_p(@cache_directory)
     end
@@ -161,9 +170,7 @@ module Packwerk
 
   class Debug
     class << self
-      extend T::Sig
-
-      sig { params(out: String).void }
+      #: (String out) -> void
       def out(out)
         if ENV["DEBUG_PACKWERK_CACHE"]
           puts(out)

data/lib/packwerk/checker.rb

@@ -2,62 +2,60 @@
 # frozen_string_literal: true
 
 module Packwerk
+  # @abstract
   module Checker
-    extend T::Sig
-    extend T::Helpers
-
-    abstract!
-
     class << self
-      extend T::Sig
-
-      sig { params(base: T::Class[T.anything]).void }
+      #: (Class[top] base) -> void
       def included(base)
         checkers << base
       end
 
-      sig { returns(T::Array[Checker]) }
+      #: -> Array[Checker]
       def all
         load_defaults
-        T.cast(checkers.map(&:new), T::Array[Checker])
+        checkers.map(&:new) #: as Array[Checker]
       end
 
-      sig { params(violation_type: String).returns(Checker) }
+      #: (String violation_type) -> Checker
       def find(violation_type)
         checker_by_violation_type(violation_type)
       end
 
       private
 
-      sig { void }
+      #: -> void
       def load_defaults
         require("packwerk/reference_checking/checkers/dependency_checker")
       end
 
-      sig { returns(T::Array[T::Class[T.anything]]) }
+      #: -> Array[Class[top]]
       def checkers
-        @checkers ||= T.let([], T.nilable(T::Array[T::Class[T.anything]]))
+        @checkers ||= [] #: Array[Class[top]]?
       end
 
-      sig { params(name: String).returns(Checker) }
+      #: (String name) -> Checker
       def checker_by_violation_type(name)
-        @checker_by_violation_type ||= T.let(Checker.all.to_h do |checker|
-                                               [checker.violation_type, checker]
-                                             end, T.nilable(T::Hash[String, Checker]))
+        @checker_by_violation_type ||= Checker.all.to_h do |checker|
+          [checker.violation_type, checker]
+        end #: Hash[String, Checker]?
         @checker_by_violation_type.fetch(name)
       end
     end
 
-    sig { abstract.returns(String) }
-    def violation_type; end
+    # @abstract
+    #: -> String
+    def violation_type = raise NotImplementedError, "Abstract method called"
 
-    sig { abstract.params(offense: ReferenceOffense).returns(T::Boolean) }
-    def strict_mode_violation?(offense); end
+    # @abstract
+    #: (ReferenceOffense offense) -> bool
+    def strict_mode_violation?(offense) = raise NotImplementedError, "Abstract method called"
 
-    sig { abstract.params(reference: Reference).returns(T::Boolean) }
-    def invalid_reference?(reference); end
+    # @abstract
+    #: (Reference reference) -> bool
+    def invalid_reference?(reference) = raise NotImplementedError, "Abstract method called"
 
-    sig { abstract.params(reference: Reference).returns(String) }
-    def message(reference); end
+    # @abstract
+    #: (Reference reference) -> String
+    def message(reference) = raise NotImplementedError, "Abstract method called"
   end
 end

data/lib/packwerk/cli.rb

@@ -4,18 +4,14 @@
 module Packwerk
   # A command-line interface to Packwerk.
   class Cli
-    extend T::Sig
-
-    sig do
-      params(
-        configuration: T.nilable(Configuration),
-        out: T.any(StringIO, IO),
-        err_out: T.any(StringIO, IO),
-        environment: String,
-        style: OutputStyle,
-        offenses_formatter: T.nilable(OffensesFormatter)
-      ).void
-    end
+    #: (
+    #|   ?configuration: Configuration?,
+    #|   ?out: (StringIO | IO),
+    #|   ?err_out: (StringIO | IO),
+    #|   ?environment: String,
+    #|   ?style: OutputStyle,
+    #|   ?offenses_formatter: OffensesFormatter?
+    #| ) -> void
     def initialize(
       configuration: nil,
       out: $stdout,
@@ -28,21 +24,18 @@ module Packwerk
       @err_out = err_out
       @environment = environment
       @style = style
-      @configuration = T.let(configuration || Configuration.from_path, Configuration)
-      @progress_formatter = T.let(Formatters::ProgressFormatter.new(@out, style: style), Formatters::ProgressFormatter)
-      @offenses_formatter = T.let(
-        offenses_formatter || @configuration.offenses_formatter,
-        OffensesFormatter
-      )
+      @configuration = configuration || Configuration.from_path #: Configuration
+      @progress_formatter = Formatters::ProgressFormatter.new(@out, style: style) #: Formatters::ProgressFormatter
+      @offenses_formatter = offenses_formatter || @configuration.offenses_formatter #: OffensesFormatter
     end
 
-    sig { params(args: T::Array[String]).returns(T.noreturn) }
+    #: (Array[String] args) -> bot
     def run(args)
       success = execute_command(args)
       exit(success)
     end
 
-    sig { params(args: T::Array[String]).returns(T::Boolean) }
+    #: (Array[String] args) -> bool
     def execute_command(args)
       command = args.shift || "help"
       command_class = Commands.for(command)

data/lib/packwerk/commands/base_command.rb

@@ -3,17 +3,12 @@
 
 module Packwerk
   module Commands
+    # @abstract
     class BaseCommand
-      extend T::Sig
-      extend T::Helpers
-      abstract!
-
-      @description = T.let("", String)
+      @description = "" #: String
 
       class << self
-        extend T::Sig
-
-        sig { params(description: T.nilable(String)).returns(String) }
+        #: (?String? description) -> String
         def description(description = nil)
           if description
             @description = description
@@ -23,16 +18,14 @@ module Packwerk
         end
       end
 
-      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:)
         @args = args
         @configuration = configuration
@@ -42,27 +35,28 @@ module Packwerk
         @offenses_formatter = offenses_formatter
       end
 
-      sig { abstract.returns(T::Boolean) }
-      def run; end
+      # @abstract
+      #: -> bool
+      def run = raise NotImplementedError, "Abstract method called"
 
       private
 
-      sig { returns(T::Array[String]) }
+      #: Array[String]
       attr_reader :args
 
-      sig { returns(Configuration) }
+      #: Configuration
       attr_reader :configuration
 
-      sig { returns(T.any(StringIO, IO)) }
+      #: (StringIO | IO)
       attr_reader :out
 
-      sig { returns(T.any(StringIO, IO)) }
+      #: (StringIO | IO)
       attr_reader :err_out
 
-      sig { returns(Formatters::ProgressFormatter) }
+      #: Formatters::ProgressFormatter
       attr_reader :progress_formatter
 
-      sig { returns(OffensesFormatter) }
+      #: OffensesFormatter
       attr_reader :offenses_formatter
     end
   end

data/lib/packwerk/commands/check_command.rb

@@ -4,12 +4,12 @@
 module Packwerk
   module Commands
     class CheckCommand < BaseCommand
-      extend T::Sig
       include UsesParseRun
 
       description "run all checks"
 
-      sig { override.returns(T::Boolean) }
+      # @override
+      #: -> bool
       def run
         if @files_for_processing.files.empty?
           out.puts(<<~MSG.squish)
@@ -20,8 +20,8 @@ module Packwerk
           true
         end
 
-        all_offenses = T.let([], T::Array[Offense])
-        on_interrupt = T.let(-> { progress_formatter.interrupted }, T.proc.void)
+        all_offenses = [] #: Array[Offense]
+        on_interrupt = -> { progress_formatter.interrupted } #: ^-> void
 
         progress_formatter.started_inspection(@files_for_processing.files) do
           all_offenses = parse_run.find_offenses(run_context, on_interrupt: on_interrupt) do |offenses|
@@ -48,14 +48,14 @@ module Packwerk
 
       private
 
-      sig { returns(RunContext) }
+      #: -> RunContext
       def run_context
-        @run_context ||= T.let(RunContext.from_configuration(configuration), T.nilable(RunContext))
+        @run_context ||= RunContext.from_configuration(configuration) #: RunContext?
       end
 
-      sig { returns(OffenseCollection) }
+      #: -> OffenseCollection
       def offense_collection
-        @offense_collection ||= T.let(OffenseCollection.new(configuration.root_path), T.nilable(OffenseCollection))
+        @offense_collection ||= OffenseCollection.new(configuration.root_path) #: OffenseCollection?
       end
     end
   end

data/lib/packwerk/commands/help_command.rb

@@ -4,11 +4,10 @@
 module Packwerk
   module Commands
     class HelpCommand < BaseCommand
-      extend T::Sig
-
       description "display help information about packwerk"
 
-      sig { override.returns(T::Boolean) }
+      # @override
+      #: -> bool
       def run
         err_out.puts(<<~USAGE)
           Usage: #{$PROGRAM_NAME} <subcommand>
@@ -22,7 +21,7 @@ module Packwerk
 
       private
 
-      sig { returns(String) }
+      #: -> String
       def command_help_lines
         Commands.all.map do |command|
           "  #{command.name} - #{command.description}"

data/lib/packwerk/commands/init_command.rb

@@ -4,11 +4,10 @@
 module Packwerk
   module Commands
     class InitCommand < BaseCommand
-      extend T::Sig
-
       description "set up packwerk"
 
-      sig { override.returns(T::Boolean) }
+      # @override
+      #: -> bool
       def run
         out.puts("📦 Initializing Packwerk...")