packwerk 1.0.0 → 1.1.2

data/lib/packwerk/association_inspector.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "packwerk/constant_name_inspector"
@@ -7,38 +7,68 @@ require "packwerk/node"
 module Packwerk
   # Extracts the implicit constant reference from an active record association
   class AssociationInspector
+    extend T::Sig
     include ConstantNameInspector
 
-    RAILS_ASSOCIATIONS = %i(
-      belongs_to
-      has_many
-      has_one
-      has_and_belongs_to_many
-    ).to_set
+    CustomAssociations = T.type_alias { T.any(T::Array[Symbol], T::Set[Symbol]) }
 
-    def initialize(inflector: Inflector.new, custom_associations: Set.new)
+    RAILS_ASSOCIATIONS = T.let(
+      %i(
+        belongs_to
+        has_many
+        has_one
+        has_and_belongs_to_many
+      ).to_set,
+      CustomAssociations
+    )
+
+    sig { params(inflector: Inflector, custom_associations: CustomAssociations).void }
+    def initialize(inflector:, custom_associations: Set.new)
       @inflector = inflector
-      @associations = RAILS_ASSOCIATIONS + custom_associations
+      @associations = T.let(RAILS_ASSOCIATIONS + custom_associations, CustomAssociations)
     end
 
+    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 unless Node.type(node) == Node::METHOD_CALL
-
-      method_name = Node.method_name(node)
-      return nil unless @associations.include?(method_name)
+      return unless Node.method_call?(node)
+      return unless association?(node)
 
       arguments = Node.method_arguments(node)
-      association_name = Node.literal_value(arguments[0]) if Node.type(arguments[0]) == Node::SYMBOL
-      return nil unless association_name
+      return unless (association_name = association_name(arguments))
 
-      association_options = arguments.detect { |n| Node.type(n) == Node::HASH }
-      class_name_node = Node.value_from_hash(association_options, :class_name) if association_options
-
-      if class_name_node
-        Node.literal_value(class_name_node) if Node.type(class_name_node) == Node::STRING
+      if (class_name_node = custom_class_name(arguments))
+        return unless Node.string?(class_name_node)
+        Node.literal_value(class_name_node)
       else
         @inflector.classify(association_name.to_s)
       end
     end
+
+    private
+
+    sig { params(node: AST::Node).returns(T::Boolean) }
+    def association?(node)
+      method_name = Node.method_name(node)
+      @associations.include?(method_name)
+    end
+
+    sig { params(arguments: T::Array[AST::Node]).returns(T.nilable(AST::Node)) }
+    def custom_class_name(arguments)
+      association_options = arguments.detect { |n| Node.hash?(n) }
+      return unless association_options
+
+      Node.value_from_hash(association_options, :class_name)
+    end
+
+    sig { params(arguments: T::Array[AST::Node]).returns(T.any(T.nilable(Symbol), T.nilable(String))) }
+    def association_name(arguments)
+      return unless Node.symbol?(arguments[0])
+
+      Node.literal_value(arguments[0])
+    end
   end
 end

data/lib/packwerk/cache_deprecated_references.rb

@@ -0,0 +1,55 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+require "packwerk/deprecated_references"
+require "packwerk/reference"
+require "packwerk/reference_lister"
+require "packwerk/violation_type"
+
+module Packwerk
+  class CacheDeprecatedReferences
+    extend T::Sig
+    extend T::Helpers
+    include ReferenceLister
+    abstract!
+
+    sig do
+      params(
+        root_path: String,
+        deprecated_references: T::Hash[Packwerk::Package, Packwerk::DeprecatedReferences]
+      ).void
+    end
+    def initialize(root_path, deprecated_references = {})
+      @root_path = root_path
+      @deprecated_references = T.let(deprecated_references, T::Hash[Packwerk::Package, Packwerk::DeprecatedReferences])
+    end
+
+    sig do
+      params(reference: Packwerk::Reference, violation_type: ViolationType)
+        .returns(T::Boolean)
+        .override
+    end
+    def listed?(reference, violation_type:)
+      deprecated_references = deprecated_references_for(reference.source_package)
+      deprecated_references.add_entries(reference, violation_type.serialize)
+      true
+    end
+
+    private
+
+    sig { params(package: Packwerk::Package).returns(Packwerk::DeprecatedReferences) }
+    def deprecated_references_for(package)
+      @deprecated_references[package] ||= Packwerk::DeprecatedReferences.new(
+        package,
+        deprecated_references_file_for(package),
+      )
+    end
+
+    sig { params(package: Packwerk::Package).returns(String) }
+    def deprecated_references_file_for(package)
+      File.join(@root_path, package.name, "deprecated_references.yml")
+    end
+  end
+end

data/lib/packwerk/checker.rb

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

data/lib/packwerk/checking_deprecated_references.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "sorbet-runtime"
@@ -10,9 +10,10 @@ module Packwerk
     extend T::Sig
     include ReferenceLister
 
+    sig { params(root_path: String).void }
     def initialize(root_path)
       @root_path = root_path
-      @deprecated_references = {}
+      @deprecated_references = T.let({}, T::Hash[Packwerk::Package, Packwerk::DeprecatedReferences])
     end
 
     sig do
@@ -26,6 +27,7 @@ module Packwerk
 
     private
 
+    sig { params(source_package: Packwerk::Package).returns(Packwerk::DeprecatedReferences) }
     def deprecated_references_for(source_package)
       @deprecated_references[source_package] ||= Packwerk::DeprecatedReferences.new(
         source_package,
@@ -33,6 +35,7 @@ module Packwerk
       )
     end
 
+    sig { params(package: Packwerk::Package).returns(String) }
     def deprecated_references_file_for(package)
       File.join(@root_path, package.name, "deprecated_references.yml")
     end

data/lib/packwerk/cli.rb

@@ -3,25 +3,45 @@
 require "benchmark"
 require "sorbet-runtime"
 
+require "packwerk/application_load_paths"
 require "packwerk/application_validator"
 require "packwerk/configuration"
 require "packwerk/files_for_processing"
+require "packwerk/formatters/offenses_formatter"
 require "packwerk/formatters/progress_formatter"
 require "packwerk/inflector"
-require "packwerk/output_styles"
+require "packwerk/output_style"
+require "packwerk/output_styles/plain"
 require "packwerk/run_context"
 require "packwerk/updating_deprecated_references"
+require "packwerk/checking_deprecated_references"
+require "packwerk/commands/detect_stale_violations_command"
+require "packwerk/commands/update_deprecations_command"
+require "packwerk/commands/offense_progress_marker"
 
 module Packwerk
   class Cli
     extend T::Sig
-
-    def initialize(run_context: nil, configuration: nil, out: $stdout, err_out: $stderr, style: OutputStyles::Plain)
+    include OffenseProgressMarker
+
+    sig do
+      params(
+        run_context: T.nilable(Packwerk::RunContext),
+        configuration: T.nilable(Configuration),
+        out: T.any(StringIO, IO),
+        err_out: T.any(StringIO, IO),
+        style: Packwerk::OutputStyle
+      ).void
+    end
+    def initialize(run_context: nil, configuration: nil, out: $stdout, err_out: $stderr, style: OutputStyles::Plain.new)
       @out = out
       @err_out = err_out
       @style = style
       @configuration = configuration || Configuration.from_path
-      @run_context = run_context || Packwerk::RunContext.from_configuration(@configuration)
+      @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)
     end
 
@@ -41,8 +61,12 @@ module Packwerk
         generate_configs
       when "check"
         check(args)
+      when "detect-stale-violations"
+        detect_stale_violations(args)
       when "update"
         update(args)
+      when "update-deprecations"
+        update_deprecations(args)
       when "validate"
         validate(args)
       when nil, "help"
@@ -52,7 +76,8 @@ module Packwerk
           Subcommands:
             init - set up packwerk
             check - run all checks
-            update - update deprecated references
+            update - update deprecated references (deprecated, use update-deprecations instead)
+            update-deprecations - update deprecated references
             validate - verify integrity of packwerk and package configuration
             help  - display help information about packwerk
         USAGE
@@ -89,7 +114,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
       )
@@ -117,31 +142,21 @@ module Packwerk
     end
 
     def update(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.file_processor.call(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.")
+      warn("`packwerk update` is deprecated in favor of `packwerk update-deprecations`.")
+      update_deprecations(paths)
+    end
 
-      all_offenses.empty?
+    def update_deprecations(paths)
+      update_deprecations = Commands::UpdateDeprecationsCommand.new(
+        files: fetch_files_to_process(paths),
+        configuration: @configuration,
+        offenses_formatter: offenses_formatter,
+        progress_formatter: @progress_formatter
+      )
+      result = update_deprecations.run
+      @out.puts
+      @out.puts(result.message)
+      result.status
     end
 
     def check(paths)
@@ -152,8 +167,8 @@ module Packwerk
       all_offenses = T.let([], T.untyped)
       execution_time = Benchmark.realtime do
         files.each do |path|
-          @run_context.file_processor.call(path).tap do |offenses|
-            mark_progress(offenses)
+          @run_context.process_file(file: path).tap do |offenses|
+            mark_progress(offenses: offenses, progress_formatter: @progress_formatter)
             all_offenses.concat(offenses)
           end
         end
@@ -162,13 +177,25 @@ module Packwerk
         @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)
+      @out.puts
+      @out.puts(offenses_formatter.show_offenses(all_offenses))
 
       all_offenses.empty?
     end
 
+    def detect_stale_violations(paths)
+      detect_stale_violations = Commands::DetectStaleViolationsCommand.new(
+        files: fetch_files_to_process(paths),
+        configuration: @configuration,
+        progress_formatter: @progress_formatter
+      )
+      result = detect_stale_violations.run
+      @out.puts
+      @out.puts(result.message)
+      result.status
+    end
+
     def fetch_files_to_process(paths)
       files = FilesForProcessing.fetch(paths: paths, configuration: @configuration)
       abort("No files found or given. "\
@@ -176,14 +203,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"\
@@ -192,7 +211,6 @@ module Packwerk
       @progress_formatter.started_validation do
         checker = Packwerk::ApplicationValidator.new(
           config_file_path: @configuration.config_path,
-          application_load_paths: @configuration.all_application_autoload_paths,
           configuration: @configuration
         )
         result = checker.check_all
@@ -203,19 +221,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?
@@ -234,5 +239,9 @@ module Packwerk
         false
       end
     end
+
+    def offenses_formatter
+      @offenses_formatter ||= Formatters::OffensesFormatter.new(style: @style)
+    end
   end
 end

data/lib/packwerk/commands/detect_stale_violations_command.rb

@@ -0,0 +1,60 @@
+# typed: true
+# frozen_string_literal: true
+require "sorbet-runtime"
+require "benchmark"
+require "packwerk/run_context"
+require "packwerk/detect_stale_deprecated_references"
+require "packwerk/commands/offense_progress_marker"
+require "packwerk/commands/result"
+
+module Packwerk
+  module Commands
+    class DetectStaleViolationsCommand
+      extend T::Sig
+      include OffenseProgressMarker
+      def initialize(files:, configuration:, run_context: nil, progress_formatter: nil, reference_lister: nil)
+        @configuration = configuration
+        @run_context = run_context
+        @reference_lister = reference_lister
+        @progress_formatter = progress_formatter
+        @files = files
+      end
+
+      sig { returns(Result) }
+      def run
+        @progress_formatter.started(@files)
+
+        execution_time = Benchmark.realtime do
+          @files.flat_map do |path|
+            run_context.process_file(file: path).tap do |offenses|
+              mark_progress(offenses: offenses, progress_formatter: @progress_formatter)
+            end
+          end
+        end
+
+        @progress_formatter.finished(execution_time)
+        calculate_result
+      end
+
+      private
+
+      def run_context
+        @run_context ||= Packwerk::RunContext.from_configuration(@configuration, reference_lister: reference_lister)
+      end
+
+      def reference_lister
+        @reference_lister ||= ::Packwerk::DetectStaleDeprecatedReferences.new(@configuration.root_path)
+      end
+
+      sig { returns(Result) }
+      def calculate_result
+        result_status = !reference_lister.stale_violations?
+        message = "There were stale violations found, please run `packwerk update-deprecations`"
+        if result_status
+          message = "No stale violations detected"
+        end
+        Result.new(message: message, status: result_status)
+      end
+    end
+  end
+end