packwerk 1.1.0 → 1.3.0

data/lib/packwerk/configuration.rb

@@ -22,7 +22,10 @@ module Packwerk
       private
 
       def from_packwerk_config(path)
-        new(YAML.load_file(path), config_path: path)
+        new(
+          YAML.load_file(path) || {},
+          config_path: path
+        )
       end
     end
 
@@ -42,10 +45,15 @@ module Packwerk
       @root_path = File.expand_path(root)
       @package_paths = configs["package_paths"] || "**/"
       @custom_associations = configs["custom_associations"] || []
-      @load_paths = configs["load_paths"]
+      @load_paths = configs["load_paths"] || []
       @inflections_file = File.expand_path(configs["inflections_file"] || "config/inflections.yml", @root_path)
+      @parallel = configs.key?("parallel") ? configs["parallel"] : true
 
       @config_path = config_path
     end
+
+    def parallel?
+      @parallel
+    end
   end
 end

data/lib/packwerk/const_node_inspector.rb

@@ -1,20 +1,24 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-require "packwerk/constant_name_inspector"
-
 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])
+        .returns(T.nilable(String))
+    end
     def constant_name_from_node(node, ancestors:)
       return nil unless Node.constant?(node)
       parent = ancestors.first
       return nil unless root_constant?(parent)
 
       if parent && constant_in_module_or_class_definition?(node, parent: parent)
-        fully_qualify_constant(node, ancestors: ancestors)
+        fully_qualify_constant(ancestors)
       else
         begin
           Node.constant_name(node)
@@ -28,27 +32,22 @@ module Packwerk
 
     # Only process the root `const` node for namespaced constant references. For example, in the
     # reference `Spam::Eggs::Thing`, we only process the const node associated with `Spam`.
+    sig { params(parent: T.nilable(AST::Node)).returns(T::Boolean) }
     def root_constant?(parent)
       !(parent && Node.constant?(parent))
     end
 
+    sig { params(node: AST::Node, parent: AST::Node).returns(T.nilable(T::Boolean)) }
     def constant_in_module_or_class_definition?(node, parent:)
       parent_name = Node.module_name_from_definition(parent)
       parent_name && parent_name == Node.constant_name(node)
     end
 
-    def fully_qualify_constant(node, ancestors:)
+    sig { params(ancestors: T::Array[AST::Node]).returns(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
-      name = Node.parent_module_name(ancestors: ancestors)
-      name ||= generate_qualified_constant(node, ancestors)
-      "::" + name
-    end
-
-    def generate_qualified_constant(node, ancestors:)
-      namespace_path = Node.enclosing_namespace_path(node, ancestors: ancestors)
-      constant_name = Node.constant_name(node)
-      namespace_path.push(constant_name).join("::")
+      "::" + Node.parent_module_name(ancestors: ancestors)
     end
   end
 end

data/lib/packwerk/constant_discovery.rb

@@ -1,6 +1,8 @@
 # typed: true
 # frozen_string_literal: true
 
+require "constant_resolver"
+
 module Packwerk
   # Get information about (partially qualified) constants without loading the application code.
   # Information gathered: Fully qualified name, path to file containing the definition, package,

data/lib/packwerk/constant_name_inspector.rb

@@ -2,7 +2,6 @@
 # frozen_string_literal: true
 
 require "ast"
-require "sorbet-runtime"
 
 module Packwerk
   # An interface describing some object that can extract a constant name from an AST node

data/lib/packwerk/dependency_checker.rb

@@ -1,31 +1,26 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-require "packwerk/violation_type"
-require "packwerk/checker"
-
 module Packwerk
   class DependencyChecker
+    extend T::Sig
     include Checker
 
+    sig { override.returns(ViolationType) }
     def violation_type
       ViolationType::Dependency
     end
 
-    def invalid_reference?(reference, reference_lister)
-      return unless reference.source_package
-      return unless reference.source_package.enforce_dependencies?
-      return if reference.source_package.dependency?(reference.constant.package)
-      return if reference_lister.listed?(reference, violation_type: violation_type)
-      true
+    sig do
+      override
+        .params(reference: Packwerk::Reference)
+        .returns(T::Boolean)
     end
-
-    def message_for(reference)
-      "Dependency violation: #{reference.constant.name} belongs to '#{reference.constant.package}', but " \
-        "'#{reference.source_package}' does not specify a dependency on " \
-        "'#{reference.constant.package}'.\n" \
-        "Are we missing an abstraction?\n" \
-        "Is the code making the reference, and the referenced constant, in the right packages?\n"
+    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)
+      true
     end
   end
 end

data/lib/packwerk/deprecated_references.rb

@@ -1,19 +1,13 @@
 # typed: true
 # frozen_string_literal: true
 
-require "sorbet-runtime"
 require "yaml"
-require "sorbet-runtime"
-
-require "packwerk/reference"
-require "packwerk/reference_lister"
-require "packwerk/violation_type"
 
 module Packwerk
   class DeprecatedReferences
     extend T::Sig
-    include ReferenceLister
 
+    sig { params(package: Packwerk::Package, filepath: String).void }
     def initialize(package, filepath)
       @package = package
       @filepath = filepath
@@ -23,7 +17,6 @@ module Packwerk
     sig do
       params(reference: Packwerk::Reference, violation_type: ViolationType)
         .returns(T::Boolean)
-        .override
     end
     def listed?(reference, violation_type:)
       violated_constants_found = deprecated_references.dig(reference.constant.package.name, reference.constant.name)
@@ -35,17 +28,19 @@ module Packwerk
       violated_constants_found.fetch("violations", []).include?(violation_type.serialize)
     end
 
+    sig { params(reference: Packwerk::Reference, violation_type: Packwerk::ViolationType).returns(T::Boolean) }
     def add_entries(reference, violation_type)
       package_violations = @new_entries.fetch(reference.constant.package.name, {})
       entries_for_file = package_violations[reference.constant.name] ||= {}
 
       entries_for_file["violations"] ||= []
-      entries_for_file["violations"] << violation_type
+      entries_for_file["violations"] << violation_type.serialize
 
       entries_for_file["files"] ||= []
       entries_for_file["files"] << reference.relative_path.to_s
 
       @new_entries[reference.constant.package.name] = package_violations
+      listed?(reference, violation_type: violation_type)
     end
 
     sig { returns(T::Boolean) }
@@ -66,6 +61,7 @@ module Packwerk
       end
     end
 
+    sig { void }
     def dump
       if @new_entries.empty?
         File.delete(@filepath) if File.exist?(@filepath)
@@ -77,7 +73,7 @@ module Packwerk
           #
           # You can regenerate this file using the following command:
           #
-          # bundle exec packwerk update-deprecations #{@package.name}
+          # packwerk update-deprecations #{@package.name}
         MESSAGE
         File.open(@filepath, "w") do |f|
           f.write(message)
@@ -88,6 +84,7 @@ module Packwerk
 
     private
 
+    sig { returns(Hash) }
     def prepare_entries_for_dump
       @new_entries.each do |package_name, package_violations|
         package_violations.each do |_, entries_for_file|
@@ -100,6 +97,7 @@ module Packwerk
       @new_entries = @new_entries.sort.to_h
     end
 
+    sig { returns(Hash) }
     def deprecated_references
       @deprecated_references ||= if File.exist?(@filepath)
         YAML.load_file(@filepath) || {}

data/lib/packwerk/file_processor.rb

@@ -3,10 +3,6 @@
 
 require "ast/node"
 
-require "packwerk/node"
-require "packwerk/offense"
-require "packwerk/parsers"
-
 module Packwerk
   class FileProcessor
     class UnknownFileTypeResult < Offense

data/lib/packwerk/formatters/offenses_formatter.rb

@@ -0,0 +1,52 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Packwerk
+  module Formatters
+    class OffensesFormatter
+      include Packwerk::OffensesFormatter
+
+      extend T::Sig
+
+      sig { params(style: OutputStyle).void }
+      def initialize(style: OutputStyles::Plain.new)
+        @style = style
+      end
+
+      sig { override.params(offenses: T::Array[T.nilable(Offense)]).returns(String) }
+      def show_offenses(offenses)
+        return "No offenses detected" if offenses.empty?
+
+        <<~EOS
+          #{offenses_list(offenses)}
+          #{offenses_summary(offenses)}
+        EOS
+      end
+
+      sig { override.params(offense_collection: Packwerk::OffenseCollection).returns(String) }
+      def show_stale_violations(offense_collection)
+        if offense_collection.stale_violations?
+          "There were stale violations found, please run `packwerk update-deprecations`"
+        else
+          "No stale violations detected"
+        end
+      end
+
+      private
+
+      sig { params(offenses: T::Array[T.nilable(Offense)]).returns(String) }
+      def offenses_list(offenses)
+        offenses
+          .compact
+          .map { |offense| offense.to_s(@style) }
+          .join("\n")
+      end
+
+      sig { params(offenses: T::Array[T.nilable(Offense)]).returns(String) }
+      def offenses_summary(offenses)
+        offenses_string = Inflector.default.pluralize("offense", offenses.length)
+        "#{offenses.length} #{offenses_string} detected"
+      end
+    end
+  end
+end

data/lib/packwerk/formatters/progress_formatter.rb

@@ -3,13 +3,13 @@
 
 require "benchmark"
 
-require "packwerk/inflector"
-require "packwerk/output_styles"
-
 module Packwerk
   module Formatters
     class ProgressFormatter
-      def initialize(out, style: OutputStyles::Plain)
+      extend T::Sig
+
+      sig { params(out: T.any(StringIO, IO), style: OutputStyle).void }
+      def initialize(out, style: OutputStyles::Plain.new)
         @out = out
         @style = style
       end
@@ -41,6 +41,11 @@ module Packwerk
         @out.puts
         @out.puts("📦 Finished in #{execution_time.round(2)} seconds")
       end
+
+      def interrupted
+        @out.puts
+        @out.puts("Manually interrupted. Violations caught so far are listed below:")
+      end
     end
   end
 end

data/lib/packwerk/generators/configuration_file.rb

@@ -1,7 +1,6 @@
 # typed: true
 # frozen_string_literal: true
 
-require "packwerk/configuration"
 require "erb"
 
 module Packwerk

data/lib/packwerk/inflector.rb

@@ -2,8 +2,6 @@
 # frozen_string_literal: true
 
 require "active_support/inflector"
-require "packwerk/inflections/default"
-require "packwerk/inflections/custom"
 
 module Packwerk
   class Inflector

data/lib/packwerk/node.rb

@@ -1,6 +1,7 @@
 # typed: true
 # frozen_string_literal: true
 
+require "parser"
 require "parser/ast/node"
 
 module Packwerk
@@ -9,6 +10,8 @@ module Packwerk
     Location = Struct.new(:line, :column)
 
     class << self
+      extend T::Sig
+
       def class_or_module_name(class_or_module_node)
         case type_of(class_or_module_node)
         when CLASS, MODULE
@@ -27,7 +30,7 @@ module Packwerk
         case type_of(constant_node)
         when CONSTANT_ROOT_NAMESPACE
           ""
-        when CONSTANT, CONSTANT_ASSIGNMENT
+        when CONSTANT, CONSTANT_ASSIGNMENT, SELF
           # (const nil :Foo)
           #   "Foo"
           # (const (cbase) :Foo)
@@ -40,6 +43,8 @@ module Packwerk
           #   "::Foo = 1"
           # (casgn (lvar :a) :Foo (int 1))
           #   "a::Foo = 1"
+          # (casgn (self) :Foo (int 1))
+          #   "self::Foo = 1"
           namespace, name = constant_node.children
           if namespace
             [constant_name(namespace), name].join("::")
@@ -176,6 +181,7 @@ module Packwerk
         class_node.children[1]
       end
 
+      sig { params(ancestors: T::Array[AST::Node]).returns(String) }
       def parent_module_name(ancestors:)
         definitions = ancestors
           .select { |n| [CLASS, MODULE, CONSTANT_ASSIGNMENT, BLOCK].include?(type_of(n)) }
@@ -204,12 +210,13 @@ module Packwerk
       HASH_PAIR = :pair
       METHOD_CALL = :send
       MODULE = :module
+      SELF = :self
       STRING = :str
       SYMBOL = :sym
 
       private_constant(
         :BLOCK, :CLASS, :CONSTANT, :CONSTANT_ASSIGNMENT, :CONSTANT_ROOT_NAMESPACE, :HASH, :HASH_PAIR, :METHOD_CALL,
-        :MODULE, :STRING, :SYMBOL,
+        :MODULE, :SELF, :STRING, :SYMBOL,
       )
 
       def type_of(node)

data/lib/packwerk/node_processor.rb

@@ -1,11 +1,6 @@
 # typed: true
 # frozen_string_literal: true
 
-require "packwerk/node"
-require "packwerk/offense"
-require "packwerk/checker"
-require "packwerk/reference_lister"
-
 module Packwerk
   class NodeProcessor
     extend T::Sig
@@ -13,48 +8,36 @@ module Packwerk
     sig do
       params(
         reference_extractor: ReferenceExtractor,
-        reference_lister: ReferenceLister,
         filename: String,
         checkers: T::Array[Checker]
       ).void
     end
-    def initialize(reference_extractor:, reference_lister:, filename:, checkers:)
+    def initialize(reference_extractor:, filename:, checkers:)
       @reference_extractor = reference_extractor
-      @reference_lister = reference_lister
       @filename = filename
       @checkers = checkers
     end
 
-    def call(node, ancestors:)
-      if Node.method_call?(node) || Node.constant?(node)
-        reference = @reference_extractor.reference_from_node(node, ancestors: ancestors, file_path: @filename)
-        check_reference(reference, node) if reference
-      end
+    sig { params(node: Parser::AST::Node, ancestors: T::Array[Parser::AST::Node]).returns(T::Array[Offense]) }
+    def call(node, ancestors)
+      return [] unless Node.method_call?(node) || Node.constant?(node)
+      reference = @reference_extractor.reference_from_node(node, ancestors: ancestors, file_path: @filename)
+      check_reference(reference, node)
     end
 
     private
 
     def check_reference(reference, node)
-      return nil unless (message = failed_check(reference))
-
-      constant = reference.constant
-
-      Packwerk::Offense.new(
-        location: Node.location(node),
-        file: reference.relative_path,
-        message: <<~EOS
-          #{message}
-          Inference details: this is a reference to #{constant.name} which seems to be defined in #{constant.location}.
-          To receive help interpreting or resolving this error message, see: https://github.com/Shopify/packwerk/blob/main/TROUBLESHOOT.md#Troubleshooting-violations
-        EOS
-      )
-    end
-
-    def failed_check(reference)
-      failing_checker = @checkers.find do |checker|
-        checker.invalid_reference?(reference, @reference_lister)
+      return [] unless reference
+      @checkers.each_with_object([]) do |checker, violations|
+        next unless checker.invalid_reference?(reference)
+        offense = Packwerk::ReferenceOffense.new(
+          location: Node.location(node),
+          reference: reference,
+          violation_type: checker.violation_type
+        )
+        violations << offense
       end
-      failing_checker&.message_for(reference)
     end
   end
 end