packwerk 2.2.2 → 3.0.0

data/lib/packwerk/parsed_constant_definitions.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "ast/node"
@@ -6,27 +6,40 @@ require "ast/node"
 module Packwerk
   # A collection of constant definitions parsed from an Abstract Syntax Tree (AST).
   class ParsedConstantDefinitions
+    extend T::Sig
+
     class << self
+      extend T::Sig
+
       # What fully qualified constants can this constant refer to in this context?
+      sig { params(constant_name: String, namespace_path: T::Array[T.nilable(String)]).returns(T::Array[String]) }
       def reference_qualifications(constant_name, namespace_path:)
         return [constant_name] if constant_name.start_with?("::")
 
         resolved_constant_name = "::#{constant_name}"
 
         possible_namespaces = namespace_path.each_with_object([""]) do |current, acc|
-          acc << "#{acc.last}::#{current}" if acc.last && current
+          acc << "#{acc.last}::#{current}" if current
         end
 
         possible_namespaces.map { |namespace| namespace + resolved_constant_name }
       end
     end
 
+    sig { params(root_node: T.nilable(AST::Node)).void }
     def initialize(root_node:)
-      @local_definitions = {}
+      @local_definitions = T.let({}, T::Hash[String, T.nilable(Node::Location)])
 
       collect_local_definitions_from_root(root_node) if root_node
     end
 
+    sig do
+      params(
+        constant_name: String,
+        location: T.nilable(Node::Location),
+        namespace_path: T::Array[String],
+      ).returns(T::Boolean)
+    end
     def local_reference?(constant_name, location: nil, namespace_path: [])
       qualifications = self.class.reference_qualifications(constant_name, namespace_path: namespace_path)
 
@@ -38,13 +51,14 @@ module Packwerk
 
     private
 
+    sig { params(node: AST::Node, current_namespace_path: T::Array[T.nilable(String)]).void }
     def collect_local_definitions_from_root(node, current_namespace_path = [])
       if NodeHelpers.constant_assignment?(node)
         add_definition(NodeHelpers.constant_name(node), current_namespace_path, NodeHelpers.name_location(node))
       elsif NodeHelpers.module_name_from_definition(node)
         # handle compact constant nesting (e.g. "module Sales::Order")
-        tempnode = node
-        while (tempnode = NodeHelpers.each_child(tempnode).find { |n| NodeHelpers.constant?(n) })
+        tempnode = T.let(node, T.nilable(AST::Node))
+        while (tempnode = NodeHelpers.each_child(T.must(tempnode)).find { |node| NodeHelpers.constant?(node) })
           add_definition(NodeHelpers.constant_name(tempnode), current_namespace_path,
             NodeHelpers.name_location(tempnode))
         end
@@ -55,10 +69,19 @@ module Packwerk
       NodeHelpers.each_child(node) { |child| collect_local_definitions_from_root(child, current_namespace_path) }
     end
 
+    sig do
+      params(
+        constant_name: String,
+        current_namespace_path: T::Array[T.nilable(String)],
+        location: T.nilable(Node::Location),
+      ).void
+    end
     def add_definition(constant_name, current_namespace_path, location)
       resolved_constant = [""].concat(current_namespace_path).push(constant_name).join("::")
 
       @local_definitions[resolved_constant] = location
     end
   end
+
+  private_constant :ParsedConstantDefinitions
 end

data/lib/packwerk/parsers/erb.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "ast/node"
@@ -9,19 +9,24 @@ require "parser/source/buffer"
 module Packwerk
   module Parsers
     class Erb
+      extend T::Sig
+
       include ParserInterface
 
+      sig { params(parser_class: T.untyped, ruby_parser: Ruby).void }
       def initialize(parser_class: BetterHtml::Parser, ruby_parser: Ruby.new)
-        @parser_class = parser_class
+        @parser_class = T.let(parser_class, T.class_of(BetterHtml::Parser))
         @ruby_parser = ruby_parser
       end
 
+      sig { override.params(io: T.any(IO, StringIO), file_path: String).returns(T.untyped) }
       def call(io:, file_path: "<unknown>")
         buffer = Parser::Source::Buffer.new(file_path)
         buffer.source = io.read
         parse_buffer(buffer, file_path: file_path)
       end
 
+      sig { params(buffer: Parser::Source::Buffer, file_path: String).returns(T.nilable(AST::Node)) }
       def parse_buffer(buffer, file_path:)
         parser = @parser_class.new(buffer, template_language: :html)
         to_ruby_ast(parser.ast, file_path)
@@ -35,12 +40,18 @@ module Packwerk
 
       private
 
+      sig do
+        params(
+          erb_ast: T.all(::AST::Node, Object),
+          file_path: String
+        ).returns(T.nilable(::AST::Node))
+      end
       def to_ruby_ast(erb_ast, file_path)
         # Note that we're not using the source location (line/column) at the moment, but if we did
         # care about that, we'd need to tweak this to insert empty lines and spaces so that things
         # line up with the ERB file
-        code_pieces = code_nodes(erb_ast).map do |node|
-          node.children.first
+        code_pieces = T.must(code_nodes(erb_ast)).map do |node|
+          T.cast(node, ::AST::Node).children.first
         end
 
         @ruby_parser.call(
@@ -49,6 +60,14 @@ module Packwerk
         )
       end
 
+      sig do
+        params(
+          node: T.any(::AST::Node, String, NilClass),
+          block: T.nilable(T.proc.params(arg0: ::AST::Node).void),
+        ).returns(
+          T.any(T::Enumerator[::AST::Node], T::Array[String], NilClass)
+        )
+      end
       def code_nodes(node, &block)
         return enum_for(:code_nodes, node) unless block
         return unless node.is_a?(::AST::Node)

data/lib/packwerk/parsers/factory.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "singleton"
@@ -20,20 +20,29 @@ module Packwerk
       ERB_REGEX = /\.erb\Z/
       private_constant :ERB_REGEX
 
+      sig { void }
+      def initialize
+        @ruby_parser = T.let(nil, T.nilable(ParserInterface))
+        @erb_parser = T.let(nil, T.nilable(ParserInterface))
+        @erb_parser_class = T.let(nil, T.nilable(Class))
+      end
+
       sig { params(path: String).returns(T.nilable(ParserInterface)) }
       def for_path(path)
         case path
         when RUBY_REGEX
           @ruby_parser ||= Ruby.new
         when ERB_REGEX
-          @erb_parser ||= erb_parser_class.new
+          @erb_parser ||= T.unsafe(erb_parser_class).new
         end
       end
 
+      sig { returns(Class) }
       def erb_parser_class
         @erb_parser_class ||= Erb
       end
 
+      sig { params(klass: T.nilable(Class)).void }
       def erb_parser_class=(klass)
         @erb_parser_class = klass
         @erb_parser = nil

data/lib/packwerk/parsers/parser_interface.rb

@@ -11,7 +11,7 @@ module Packwerk
 
       interface!
 
-      sig { abstract.params(io: File, file_path: String).returns(T.untyped) }
+      sig { abstract.params(io: T.any(IO, StringIO), file_path: String).returns(T.untyped) }
       def call(io:, file_path:)
       end
     end

data/lib/packwerk/parsers/ruby.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "parser"
@@ -7,9 +7,14 @@ require "parser/current"
 module Packwerk
   module Parsers
     class Ruby
+      extend T::Sig
+
       include ParserInterface
 
       class RaiseExceptionsParser < Parser::CurrentRuby
+        extend T::Sig
+
+        sig { params(builder: T.untyped).void }
         def initialize(builder)
           super(builder)
           super.diagnostics.all_errors_are_fatal = true
@@ -17,16 +22,21 @@ module Packwerk
       end
 
       class TolerateInvalidUtf8Builder < Parser::Builders::Default
+        extend T::Sig
+
+        sig { params(token: T.untyped).returns(T.untyped) }
         def string_value(token)
           value(token)
         end
       end
 
+      sig { params(parser_class: T.untyped).void }
       def initialize(parser_class: RaiseExceptionsParser)
-        @builder = TolerateInvalidUtf8Builder.new
-        @parser_class = parser_class
+        @builder = T.let(TolerateInvalidUtf8Builder.new, Object)
+        @parser_class = T.let(parser_class, T.class_of(RaiseExceptionsParser))
       end
 
+      sig { override.params(io: T.any(IO, StringIO), file_path: String).returns(T.nilable(Parser::AST::Node)) }
       def call(io:, file_path: "<unknown>")
         buffer = Parser::Source::Buffer.new(file_path)
         buffer.source = io.read

data/lib/packwerk/parsers.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module Packwerk
@@ -11,8 +11,12 @@ module Packwerk
     class ParseResult < Offense; end
 
     class ParseError < StandardError
-      attr_reader :result
+      extend T::Sig
 
+      sig { returns(ParseResult) }
+      attr_reader(:result)
+
+      sig { params(result: ParseResult).void }
       def initialize(result)
         super(result.message)
         @result = result

data/lib/packwerk/{application_load_paths.rb → rails_load_paths.rb}

@@ -2,15 +2,17 @@
 # frozen_string_literal: true
 
 require "bundler"
+gem "railties", ">= 6.0"
+require "rails/railtie"
 
 module Packwerk
   # Extracts the load paths from the analyzed application so that we can map constant names to paths.
-  module ApplicationLoadPaths
+  module RailsLoadPaths
     class << self
       extend T::Sig
 
       sig { params(root: String, environment: String).returns(T::Hash[String, Module]) }
-      def extract_relevant_paths(root, environment)
+      def for(root, environment:)
         require_application(root, environment)
         all_paths = extract_application_autoload_paths
         relevant_paths = filter_relevant_paths(all_paths)
@@ -18,6 +20,8 @@ module Packwerk
         relative_path_strings(relevant_paths)
       end
 
+      private
+
       sig { returns(T::Hash[String, Module]) }
       def extract_application_autoload_paths
         Rails.autoloaders.inject({}) do |h, loader|
@@ -44,8 +48,6 @@ module Packwerk
         load_paths.transform_keys { |path| Pathname.new(path).relative_path_from(rails_root).to_s }
       end
 
-      private
-
       sig { params(root: String, environment: String).void }
       def require_application(root, environment)
         environment_file = "#{root}/config/environment"

data/lib/packwerk/reference.rb

@@ -3,5 +3,11 @@
 
 module Packwerk
   # A reference from a file in one package to a constant that may be defined in a different package.
-  Reference = Struct.new(:source_package, :relative_path, :constant, :source_location)
+  Reference = Struct.new(
+    :package,
+    :relative_path,
+    :constant,
+    :source_location,
+    keyword_init: true,
+  )
 end

data/lib/packwerk/reference_checking/checkers/dependency_checker.rb

@@ -9,9 +9,11 @@ module Packwerk
         extend T::Sig
         include Checker
 
-        sig { override.returns(ViolationType) }
+        VIOLATION_TYPE = T.let("dependency", String)
+
+        sig { override.returns(String) }
         def violation_type
-          ViolationType::Dependency
+          VIOLATION_TYPE
         end
 
         sig do
@@ -20,9 +22,8 @@ module Packwerk
             .returns(T::Boolean)
         end
         def invalid_reference?(reference)
-          return false unless reference.source_package
-          return false unless reference.source_package.enforce_dependencies?
-          return false if reference.source_package.dependency?(reference.constant.package)
+          return false unless reference.package.enforce_dependencies?
+          return false if reference.package.dependency?(reference.constant.package)
 
           true
         end
@@ -33,14 +34,36 @@ module Packwerk
             .returns(String)
         end
         def message(reference)
+          const_name = reference.constant.name
+          const_package = reference.constant.package
+          ref_package = reference.package
+
           <<~EOS
-            Dependency violation: #{reference.constant.name} belongs to '#{reference.constant.package}', but '#{reference.source_package}' does not specify a dependency on '#{reference.constant.package}'.
+            Dependency violation: #{const_name} belongs to '#{const_package}', but '#{ref_package}' does not specify a dependency on '#{const_package}'.
             Are we missing an abstraction?
             Is the code making the reference, and the referenced constant, in the right packages?
 
             #{standard_help_message(reference)}
           EOS
         end
+
+        sig { override.params(listed_offense: ReferenceOffense).returns(T::Boolean) }
+        def strict_mode_violation?(listed_offense)
+          referencing_package = listed_offense.reference.package
+          referencing_package.config["enforce_dependencies"] == "strict"
+        end
+
+        private
+
+        sig { params(reference: Reference).returns(String) }
+        def standard_help_message(reference)
+          standard_message = <<~EOS
+            Inference details: this is a reference to #{reference.constant.name} which seems to be defined in #{reference.constant.location}.
+            To receive help interpreting or resolving this error message, see: https://github.com/Shopify/packwerk/blob/main/TROUBLESHOOT.md#Troubleshooting-violations
+          EOS
+
+          standard_message.chomp
+        end
       end
     end
   end

data/lib/packwerk/reference_checking/reference_checker.rb

@@ -6,7 +6,7 @@ module Packwerk
     class ReferenceChecker
       extend T::Sig
 
-      sig { params(checkers: T::Array[Checkers::Checker]).void }
+      sig { params(checkers: T::Array[Checker]).void }
       def initialize(checkers)
         @checkers = checkers
       end

data/lib/packwerk/reference_extractor.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module Packwerk
@@ -38,10 +38,10 @@ module Packwerk
           next if source_package == package_for_constant
 
           fully_qualified_references << Reference.new(
-            source_package,
-            unresolved_reference.relative_path,
-            constant,
-            unresolved_reference.source_location
+            package: source_package,
+            relative_path: unresolved_reference.relative_path,
+            constant: constant,
+            source_location: unresolved_reference.source_location,
           )
         end
 
@@ -51,8 +51,8 @@ module Packwerk
 
     sig do
       params(
-        constant_name_inspectors: T::Array[Packwerk::ConstantNameInspector],
-        root_node: ::AST::Node,
+        constant_name_inspectors: T::Array[ConstantNameInspector],
+        root_node: AST::Node,
         root_path: String,
       ).void
     end
@@ -63,7 +63,10 @@ module Packwerk
     )
       @constant_name_inspectors = constant_name_inspectors
       @root_path = root_path
-      @local_constant_definitions = ParsedConstantDefinitions.new(root_node: root_node)
+      @local_constant_definitions = T.let(
+        ParsedConstantDefinitions.new(root_node: root_node),
+        ParsedConstantDefinitions,
+      )
     end
 
     sig do
@@ -110,13 +113,20 @@ module Packwerk
       location = NodeHelpers.location(node)
 
       UnresolvedReference.new(
-        constant_name,
-        namespace_path,
-        relative_file,
-        location
+        constant_name: constant_name,
+        namespace_path: namespace_path,
+        relative_path: relative_file,
+        source_location: location
       )
     end
 
+    sig do
+      params(
+        constant_name: String,
+        name_location: T.nilable(Node::Location),
+        namespace_path: T::Array[String],
+      ).returns(T::Boolean)
+    end
     def local_reference?(constant_name, name_location, namespace_path)
       @local_constant_definitions.local_reference?(
         constant_name,
@@ -125,4 +135,6 @@ module Packwerk
       )
     end
   end
+
+  private_constant :ReferenceExtractor
 end

data/lib/packwerk/reference_offense.rb

@@ -10,13 +10,13 @@ module Packwerk
     sig { returns(Reference) }
     attr_reader :reference
 
-    sig { returns(ViolationType) }
+    sig { returns(String) }
     attr_reader :violation_type
 
     sig do
       params(
         reference: Packwerk::Reference,
-        violation_type: Packwerk::ViolationType,
+        violation_type: String,
         message: String,
         location: T.nilable(Node::Location)
       )

data/lib/packwerk/run_context.rb

@@ -8,11 +8,6 @@ module Packwerk
   class RunContext
     extend T::Sig
 
-    DEFAULT_CHECKERS = T.let([
-      ::Packwerk::ReferenceChecking::Checkers::DependencyChecker.new,
-      ::Packwerk::ReferenceChecking::Checkers::PrivacyChecker.new,
-    ], T::Array[ReferenceChecking::Checkers::Checker])
-
     class << self
       extend T::Sig
 
@@ -44,7 +39,7 @@ module Packwerk
         config_path: T.nilable(String),
         package_paths: T.nilable(T.any(T::Array[String], String)),
         custom_associations: AssociationInspector::CustomAssociations,
-        checkers: T::Array[ReferenceChecking::Checkers::Checker],
+        checkers: T::Array[Checker],
         cache_enabled: T::Boolean,
       ).void
     end
@@ -56,7 +51,7 @@ module Packwerk
       config_path: nil,
       package_paths: nil,
       custom_associations: [],
-      checkers: DEFAULT_CHECKERS,
+      checkers: Checker.all,
       cache_enabled: false
     )
       @root_path = root_path
@@ -114,7 +109,7 @@ module Packwerk
 
     sig { returns(ConstantDiscovery) }
     def context_provider
-      @context_provider ||= ::Packwerk::ConstantDiscovery.new(
+      @context_provider ||= ConstantDiscovery.new(
         constant_resolver: resolver,
         packages: package_set
       )
@@ -132,9 +127,11 @@ module Packwerk
     sig { returns(T::Array[ConstantNameInspector]) }
     def constant_name_inspectors
       [
-        ::Packwerk::ConstNodeInspector.new,
-        ::Packwerk::AssociationInspector.new(inflector: @inflector, custom_associations: @custom_associations),
+        ConstNodeInspector.new,
+        AssociationInspector.new(inflector: @inflector, custom_associations: @custom_associations),
       ]
     end
   end
+
+  private_constant :RunContext
 end

data/lib/packwerk/spring_command.rb

@@ -1,24 +1,31 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "spring/commands"
+require "sorbet-runtime"
 
 module Packwerk
   class SpringCommand
-    def env(*)
+    extend T::Sig
+
+    sig { params(args: T.untyped).returns(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) }
     def exec_name
       "packwerk"
     end
 
+    sig { returns(String) }
     def gem_name
       "packwerk"
     end
 
+    sig { returns(T::Boolean) }
     def call
       load(Gem.bin_path(gem_name, exec_name))
     end
@@ -26,3 +33,5 @@ module Packwerk
 
   Spring.register_command("packwerk", SpringCommand.new)
 end
+
+require "packwerk/disable_sorbet"

data/lib/packwerk/unresolved_reference.rb

@@ -6,5 +6,13 @@ module Packwerk
   # Unresolved means that we know how it's referred to in the file,
   # and we have enough context on that reference to figure out the fully qualified reference such that we
   # can produce a Reference in a separate pass. However, we have not yet resolved it to its fully qualified version.
-  UnresolvedReference = Struct.new(:constant_name, :namespace_path, :relative_path, :source_location)
+  UnresolvedReference = Struct.new(
+    :constant_name,
+    :namespace_path,
+    :relative_path,
+    :source_location,
+    keyword_init: true,
+  )
+
+  private_constant :UnresolvedReference
 end

data/lib/packwerk/validator/result.rb

@@ -0,0 +1,18 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Packwerk
+  module Validator
+    class Result < T::Struct
+      extend T::Sig
+
+      const :ok, T::Boolean
+      const :error_value, T.nilable(String)
+
+      sig { returns(T::Boolean) }
+      def ok?
+        ok
+      end
+    end
+  end
+end