packwerk 1.0.2 → 1.2.0

data/lib/packwerk/checker.rb

@@ -1,9 +1,6 @@
 # typed: true
 # frozen_string_literal: true
 
-require "sorbet-runtime"
-require "packwerk/reference_lister"
-
 module Packwerk
   module Checker
     extend T::Sig
@@ -11,10 +8,10 @@ module Packwerk
 
     interface!
 
-    sig { params(reference: Reference, reference_lister: ReferenceLister).returns(T::Boolean).abstract }
-    def invalid_reference?(reference, reference_lister); end
+    sig { returns(ViolationType).abstract }
+    def violation_type; end
 
-    sig { params(reference: Reference).returns(String).abstract }
-    def message_for(reference); end
+    sig { params(reference: Reference).returns(T::Boolean).abstract }
+    def invalid_reference?(reference); end
   end
 end

data/lib/packwerk/cli.rb

@@ -1,32 +1,32 @@
 # typed: true
 # frozen_string_literal: true
-require "benchmark"
-require "sorbet-runtime"
-
-require "packwerk/application_validator"
-require "packwerk/configuration"
-require "packwerk/files_for_processing"
-require "packwerk/formatters/progress_formatter"
-require "packwerk/inflector"
-require "packwerk/output_styles"
-require "packwerk/run_context"
-require "packwerk/updating_deprecated_references"
-require "packwerk/checking_deprecated_references"
 
 module Packwerk
   class Cli
     extend T::Sig
 
-    def initialize(run_context: nil, configuration: nil, out: $stdout, err_out: $stderr, style: OutputStyles::Plain)
+    sig do
+      params(
+        configuration: T.nilable(Configuration),
+        out: T.any(StringIO, IO),
+        err_out: T.any(StringIO, IO),
+        style: Packwerk::OutputStyle,
+        offenses_formatter: T.nilable(Packwerk::OffensesFormatter)
+      ).void
+    end
+    def initialize(
+      configuration: nil,
+      out: $stdout,
+      err_out: $stderr,
+      style: OutputStyles::Plain.new,
+      offenses_formatter: nil
+    )
       @out = out
       @err_out = err_out
       @style = style
       @configuration = configuration || Configuration.from_path
-      @run_context = run_context || Packwerk::RunContext.from_configuration(
-        @configuration,
-        reference_lister: ::Packwerk::CheckingDeprecatedReferences.new(@configuration.root_path),
-      )
       @progress_formatter = Formatters::ProgressFormatter.new(@out, style: style)
+      @offenses_formatter = offenses_formatter || Formatters::OffensesFormatter.new(style: @style)
     end
 
     sig { params(args: T::Array[String]).returns(T.noreturn) }
@@ -44,11 +44,13 @@ module Packwerk
       when "generate_configs"
         generate_configs
       when "check"
-        check(args)
+        output_result(parse_run(args).check)
+      when "detect-stale-violations"
+        output_result(parse_run(args).detect_stale_violations)
       when "update"
         update(args)
       when "update-deprecations"
-        update_deprecations(args)
+        output_result(parse_run(args).update_deprecations)
       when "validate"
         validate(args)
       when nil, "help"
@@ -96,7 +98,7 @@ module Packwerk
 
     def generate_configs
       configuration_file = Packwerk::Generators::ConfigurationFile.generate(
-        load_paths: @configuration.load_paths,
+        load_paths: Packwerk::ApplicationLoadPaths.extract_relevant_paths,
         root: @configuration.root_path,
         out: @out
       )
@@ -125,60 +127,13 @@ module Packwerk
 
     def update(paths)
       warn("`packwerk update` is deprecated in favor of `packwerk update-deprecations`.")
-      update_deprecations(paths)
+      output_result(parse_run(paths).update_deprecations)
     end
 
-    def update_deprecations(paths)
-      updating_deprecated_references = ::Packwerk::UpdatingDeprecatedReferences.new(@configuration.root_path)
-      @run_context = Packwerk::RunContext.from_configuration(
-        @configuration,
-        reference_lister: updating_deprecated_references
-      )
-
-      files = fetch_files_to_process(paths)
-
-      @progress_formatter.started(files)
-
-      all_offenses = T.let([], T.untyped)
-      execution_time = Benchmark.realtime do
-        all_offenses = files.flat_map do |path|
-          @run_context.process_file(file: path).tap { |offenses| mark_progress(offenses) }
-        end
-
-        updating_deprecated_references.dump_deprecated_references_files
-      end
-
-      @out.puts # put a new line after the progress dots
-      show_offenses(all_offenses)
-      @progress_formatter.finished(execution_time)
-      @out.puts("✅ `deprecated_references.yml` has been updated.")
-
-      all_offenses.empty?
-    end
-
-    def check(paths)
-      files = fetch_files_to_process(paths)
-
-      @progress_formatter.started(files)
-
-      all_offenses = T.let([], T.untyped)
-      execution_time = Benchmark.realtime do
-        files.each do |path|
-          @run_context.process_file(file: path).tap do |offenses|
-            mark_progress(offenses)
-            all_offenses.concat(offenses)
-          end
-        end
-      rescue Interrupt
-        @out.puts
-        @out.puts("Manually interrupted. Violations caught so far are listed below:")
-      end
-
-      @out.puts # put a new line after the progress dots
-      show_offenses(all_offenses)
-      @progress_formatter.finished(execution_time)
-
-      all_offenses.empty?
+    def output_result(result)
+      @out.puts
+      @out.puts(result.message)
+      result.status
     end
 
     def fetch_files_to_process(paths)
@@ -188,14 +143,6 @@ module Packwerk
       files
     end
 
-    def mark_progress(offenses)
-      if offenses.empty?
-        @progress_formatter.mark_as_inspected
-      else
-        @progress_formatter.mark_as_failed
-      end
-    end
-
     def validate(_paths)
       warn("`packwerk validate` should be run within the application. "\
         "Generate the bin script using `packwerk init` and"\
@@ -214,19 +161,6 @@ module Packwerk
       end
     end
 
-    def show_offenses(offenses)
-      if offenses.empty?
-        @out.puts("No offenses detected 🎉")
-      else
-        offenses.each do |offense|
-          @out.puts(offense.to_s(@style))
-        end
-
-        offenses_string = Inflector.default.pluralize("offense", offenses.length)
-        @out.puts("#{offenses.length} #{offenses_string} detected")
-      end
-    end
-
     def list_validation_errors(result)
       @out.puts
       if result.ok?
@@ -245,5 +179,14 @@ module Packwerk
         false
       end
     end
+
+    def parse_run(paths)
+      ParseRun.new(
+        files: fetch_files_to_process(paths),
+        configuration: @configuration,
+        progress_formatter: @progress_formatter,
+        offenses_formatter: @offenses_formatter
+      )
+    end
   end
 end

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,18 +1,13 @@
 # typed: true
 # frozen_string_literal: true
 
-require "sorbet-runtime"
 require "yaml"
 
-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
@@ -22,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)
@@ -34,19 +28,40 @@ 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) }
+    def stale_violations?
+      prepare_entries_for_dump
+      deprecated_references.any? do |package, package_violations|
+        package_violations.any? do |constant_name, entries_for_file|
+          new_entries_violation_types = @new_entries.dig(package, constant_name, "violations")
+          return true if new_entries_violation_types.nil?
+          if entries_for_file["violations"].all? { |type| new_entries_violation_types.include?(type) }
+            stale_violations =
+              entries_for_file["files"] - Array(@new_entries.dig(package, constant_name, "files"))
+            stale_violations.present?
+          else
+            return true
+          end
+        end
+      end
     end
 
+    sig { void }
     def dump
       if @new_entries.empty?
         File.delete(@filepath) if File.exist?(@filepath)
@@ -69,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|
@@ -81,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) || {}