packwerk 1.0.1 → 1.1.3

data/lib/packwerk/commands/result.rb

@@ -0,0 +1,13 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Packwerk
+  module Commands
+    class Result < T::Struct
+      prop :message, String
+      prop :status, T::Boolean
+    end
+  end
+end

data/lib/packwerk/commands/update_deprecations_command.rb

@@ -0,0 +1,81 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+require "benchmark"
+
+require "packwerk/commands/offense_progress_marker"
+require "packwerk/commands/result"
+require "packwerk/run_context"
+require "packwerk/updating_deprecated_references"
+
+module Packwerk
+  module Commands
+    class UpdateDeprecationsCommand
+      extend T::Sig
+      include OffenseProgressMarker
+
+      sig do
+        params(
+          files: T::Enumerable[String],
+          configuration: Configuration,
+          offenses_formatter: Formatters::OffensesFormatter,
+          progress_formatter: Formatters::ProgressFormatter
+        ).void
+      end
+      def initialize(files:, configuration:, offenses_formatter:, progress_formatter:)
+        @files = files
+        @configuration = configuration
+        @progress_formatter = progress_formatter
+        @offenses_formatter = offenses_formatter
+        @updating_deprecated_references = T.let(nil, T.nilable(UpdatingDeprecatedReferences))
+        @run_context = T.let(nil, T.nilable(RunContext))
+      end
+
+      sig { returns(Result) }
+      def run
+        @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 do |offenses|
+              mark_progress(offenses: offenses, progress_formatter: @progress_formatter)
+            end
+          end
+
+          updating_deprecated_references.dump_deprecated_references_files
+        end
+
+        @progress_formatter.finished(execution_time)
+        calculate_result(all_offenses)
+      end
+
+      private
+
+      sig { returns(RunContext) }
+      def run_context
+        @run_context ||= RunContext.from_configuration(
+          @configuration,
+          reference_lister: updating_deprecated_references
+        )
+      end
+
+      sig { returns(UpdatingDeprecatedReferences) }
+      def updating_deprecated_references
+        @updating_deprecated_references ||= UpdatingDeprecatedReferences.new(@configuration.root_path)
+      end
+
+      sig { params(all_offenses: T::Array[T.nilable(::Packwerk::Offense)]).returns(Result) }
+      def calculate_result(all_offenses)
+        result_status = all_offenses.empty?
+        message = <<~EOS
+          #{@offenses_formatter.show_offenses(all_offenses)}
+          ✅ `deprecated_references.yml` has been updated.
+        EOS
+
+        Result.new(message: message, status: result_status)
+      end
+    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,45 +45,10 @@ module Packwerk
       @root_path = File.expand_path(root)
       @package_paths = configs["package_paths"] || "**/"
       @custom_associations = configs["custom_associations"] || []
-      @load_paths = configs["load_paths"] || all_application_autoload_paths
+      @load_paths = configs["load_paths"] || []
       @inflections_file = File.expand_path(configs["inflections_file"] || "config/inflections.yml", @root_path)
 
       @config_path = config_path
     end
-
-    def all_application_autoload_paths
-      return [] unless defined?(::Rails)
-
-      all_paths = Rails.application.railties
-        .select { |railtie| railtie.is_a?(Rails::Engine) }
-        .push(Rails.application)
-        .flat_map do |engine|
-        (engine.config.autoload_paths + engine.config.eager_load_paths + engine.config.autoload_once_paths).uniq
-      end
-
-      bundle_path_match = Bundler.bundle_path.join("**").to_s
-
-      all_paths = all_paths.each_with_object([]) do |path_string, paths|
-        # ignore paths inside gems
-        path = Pathname.new(path_string)
-
-        next unless path.exist?
-        next if path.realpath.fnmatch(bundle_path_match)
-
-        paths << path.relative_path_from(Rails.root).to_s
-      end
-
-      all_paths.tap do |paths|
-        if paths.empty?
-          raise <<~EOS
-            No autoload paths have been set up in your Rails app. This is likely a bug, and
-            packwerk is unlikely to work correctly without any autoload paths.
-
-            You can follow the Rails guides on setting up load paths, or manually configure
-            them in `packwerk.yml` with `load_paths`.
-          EOS
-        end
-      end
-    end
   end
 end

data/lib/packwerk/const_node_inspector.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "packwerk/constant_name_inspector"
@@ -6,23 +6,21 @@ 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.type(node) == Node::CONSTANT
-
-      # 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`.
+      return nil unless Node.constant?(node)
       parent = ancestors.first
-      return nil if parent && Node.type(parent) == Node::CONSTANT
+      return nil unless root_constant?(parent)
 
-      if constant_in_module_or_class_definition?(node, parent: parent)
-        # 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 ||= Node.enclosing_namespace_path(node, ancestors: ancestors).push(Node.constant_name(node)).join("::")
-
-        "::" + name
+      if parent && constant_in_module_or_class_definition?(node, parent: parent)
+        fully_qualify_constant(ancestors)
       else
         begin
           Node.constant_name(node)
@@ -34,11 +32,24 @@ module Packwerk
 
     private
 
+    # 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:)
-      if parent
-        parent_name = Node.module_name_from_definition(parent)
-        parent_name && parent_name == Node.constant_name(node)
-      end
+      parent_name = Node.module_name_from_definition(parent)
+      parent_name && parent_name == Node.constant_name(node)
+    end
+
+    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
+      "::" + Node.parent_module_name(ancestors: ancestors)
     end
   end
 end

data/lib/packwerk/dependency_checker.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "packwerk/violation_type"
@@ -6,20 +6,28 @@ require "packwerk/checker"
 
 module Packwerk
   class DependencyChecker
+    extend T::Sig
     include Checker
 
+    sig { override.returns(ViolationType) }
     def violation_type
       ViolationType::Dependency
     end
 
+    sig do
+      override
+        .params(reference: Packwerk::Reference, reference_lister: Packwerk::ReferenceLister)
+        .returns(T::Boolean)
+    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)
+      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 if reference_lister.listed?(reference, violation_type: violation_type)
       true
     end
 
+    sig { override.params(reference: Packwerk::Reference).returns(String) }
     def message_for(reference)
       "Dependency violation: #{reference.constant.name} belongs to '#{reference.constant.package}', but " \
         "'#{reference.source_package}' does not specify a dependency on " \

data/lib/packwerk/deprecated_references.rb

@@ -13,6 +13,7 @@ module Packwerk
     extend T::Sig
     include ReferenceLister
 
+    sig { params(package: Packwerk::Package, filepath: String).void }
     def initialize(package, filepath)
       @package = package
       @filepath = filepath
@@ -34,6 +35,7 @@ module Packwerk
       violated_constants_found.fetch("violations", []).include?(violation_type.serialize)
     end
 
+    sig { params(reference: Packwerk::Reference, violation_type: String).void }
     def add_entries(reference, violation_type)
       package_violations = @new_entries.fetch(reference.constant.package.name, {})
       entries_for_file = package_violations[reference.constant.name] ||= {}
@@ -47,6 +49,25 @@ module Packwerk
       @new_entries[reference.constant.package.name] = package_violations
     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 +90,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 +103,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/detect_stale_deprecated_references.rb

@@ -0,0 +1,14 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "packwerk/cache_deprecated_references"
+
+module Packwerk
+  class DetectStaleDeprecatedReferences < CacheDeprecatedReferences
+    extend T::Sig
+    sig { returns(T::Boolean) }
+    def stale_violations?
+      @deprecated_references.values.any?(&:stale_violations?)
+    end
+  end
+end

data/lib/packwerk/file_processor.rb

@@ -15,8 +15,8 @@ module Packwerk
       end
     end
 
-    def initialize(run_context:, parser_factory: nil)
-      @run_context = run_context
+    def initialize(node_processor_factory:, parser_factory: nil)
+      @node_processor_factory = node_processor_factory
       @parser_factory = parser_factory || Packwerk::Parsers::Factory.instance
     end
 
@@ -32,8 +32,8 @@ module Packwerk
 
       result = []
       if node
-        @node_processor = @run_context.node_processor_for(filename: file_path, ast_node: node)
-        node_visitor = Packwerk::NodeVisitor.new(node_processor: @node_processor)
+        node_processor = @node_processor_factory.for(filename: file_path, node: node)
+        node_visitor = Packwerk::NodeVisitor.new(node_processor: node_processor)
 
         node_visitor.visit(node, ancestors: [], result: result)
       end

data/lib/packwerk/formatters/offenses_formatter.rb

@@ -0,0 +1,48 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "benchmark"
+require "sorbet-runtime"
+
+require "packwerk/inflector"
+require "packwerk/output_style"
+require "packwerk/output_styles/plain"
+
+module Packwerk
+  module Formatters
+    class OffensesFormatter
+      extend T::Sig
+
+      sig { params(style: OutputStyle).void }
+      def initialize(style: OutputStyles::Plain.new)
+        @style = style
+      end
+
+      sig { 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
+
+      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

@@ -4,12 +4,16 @@
 require "benchmark"
 
 require "packwerk/inflector"
-require "packwerk/output_styles"
+require "packwerk/output_style"
+require "packwerk/output_styles/plain"
 
 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

data/lib/packwerk/inflector.rb

@@ -8,20 +8,31 @@ require "packwerk/inflections/custom"
 module Packwerk
   class Inflector
     class << self
+      extend T::Sig
+
       def default
-        @default ||= new
+        @default ||= new(custom_inflector: Inflections::Custom.new)
+      end
+
+      sig { params(inflections_file: String).returns(::Packwerk::Inflector) }
+      def from_file(inflections_file)
+        new(custom_inflector: Inflections::Custom.new(inflections_file))
       end
     end
 
-    # For #camelize, #classify, #pluralize, #singularize
-    include ::ActiveSupport::Inflector
+    extend T::Sig
+    include ::ActiveSupport::Inflector # For #camelize, #classify, #pluralize, #singularize
 
-    def initialize(custom_inflection_file: nil)
+    sig do
+      params(
+        custom_inflector: Inflections::Custom
+      ).void
+    end
+    def initialize(custom_inflector:)
       @inflections = ::ActiveSupport::Inflector::Inflections.new
 
       Inflections::Default.apply_to(@inflections)
-
-      Inflections::Custom.new(custom_inflection_file).apply_to(@inflections)
+      custom_inflector.apply_to(@inflections)
     end
 
     def pluralize(word, count = nil)
@@ -32,8 +43,6 @@ module Packwerk
       end
     end
 
-    private
-
     def inflections(_ = nil)
       @inflections
     end