packwerk 3.0.1 → 3.1.0

data/lib/packwerk/commands/lazy_loaded_entry.rb

@@ -0,0 +1,37 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Packwerk
+  module Commands
+    class LazyLoadedEntry
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :name
+
+      sig { params(name: String, aliases: T::Array[String]).void }
+      def initialize(name, aliases: [])
+        @name = name
+        @aliases = aliases
+      end
+
+      sig { returns(T.class_of(BaseCommand)) }
+      def command_class
+        classname = @name.sub(" ", "_").underscore.classify + "Command"
+        Commands.const_get(classname) # rubocop:disable Sorbet/ConstantsFromStrings
+      end
+
+      sig { returns(String) }
+      def description
+        command_class.description
+      end
+
+      sig { params(name_or_alias: String).returns(T::Boolean) }
+      def matches_command?(name_or_alias)
+        @name == name_or_alias || @aliases.include?(name_or_alias)
+      end
+    end
+
+    private_constant :LazyLoadedEntry
+  end
+end

data/lib/packwerk/commands/update_todo_command.rb

@@ -0,0 +1,60 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Packwerk
+  module Commands
+    class UpdateTodoCommand < BaseCommand
+      extend T::Sig
+      include UsesParseRun
+
+      description "update package_todo.yml files"
+
+      sig { override.returns(T::Boolean) }
+      def run
+        if @files_for_processing.files_specified?
+          out.puts(<<~MSG.squish)
+            ⚠️ update-todo must be called without any file arguments.
+          MSG
+
+          return false
+        end
+        if @files_for_processing.files.empty?
+          out.puts(<<~MSG.squish)
+            No files found or given.
+            Specify files or check the include and exclude glob in the config file.
+          MSG
+
+          return true
+        end
+
+        run_context = RunContext.from_configuration(configuration)
+        offenses = T.let([], T::Array[Offense])
+        progress_formatter.started_inspection(@files_for_processing.files) do
+          offenses = parse_run.find_offenses(run_context, on_interrupt: -> { progress_formatter.interrupted }) do
+            progress_formatter.increment_progress
+          end
+        end
+
+        offense_collection = OffenseCollection.new(configuration.root_path)
+        offense_collection.add_offenses(offenses)
+        offense_collection.persist_package_todo_files(run_context.package_set)
+
+        unlisted_strict_mode_violations = offense_collection.unlisted_strict_mode_violations
+
+        messages = [
+          offenses_formatter.show_offenses(offense_collection.errors + unlisted_strict_mode_violations),
+        ]
+
+        messages << if unlisted_strict_mode_violations.any?
+          "⚠️ `package_todo.yml` has been updated, but unlisted strict mode violations were not added."
+        else
+          "✅ `package_todo.yml` has been updated."
+        end
+
+        out.puts(messages.select(&:present?).join("\n") + "\n")
+
+        unlisted_strict_mode_violations.empty? && offense_collection.errors.empty?
+      end
+    end
+  end
+end

data/lib/packwerk/commands/uses_parse_run.rb

@@ -0,0 +1,92 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "optparse"
+
+module Packwerk
+  module Commands
+    module UsesParseRun
+      extend T::Sig
+      extend T::Helpers
+
+      requires_ancestor { BaseCommand }
+
+      sig do
+        params(
+          args: T::Array[String],
+          configuration: Configuration,
+          out: T.any(StringIO, IO),
+          err_out: T.any(StringIO, IO),
+          progress_formatter: Formatters::ProgressFormatter,
+          offenses_formatter: OffensesFormatter,
+        ).void
+      end
+      def initialize(args, configuration:, out:, err_out:, progress_formatter:, offenses_formatter:)
+        super
+        @files_for_processing = T.let(fetch_files_to_process, FilesForProcessing)
+        @offenses_formatter = T.let(offenses_formatter_from_options || @offenses_formatter, OffensesFormatter)
+        configuration.parallel = parsed_options[:parallel]
+      end
+
+      private
+
+      sig { returns(FilesForProcessing) }
+      def fetch_files_to_process
+        FilesForProcessing.fetch(
+          relative_file_paths: parsed_options[:relative_file_paths],
+          ignore_nested_packages: parsed_options[:ignore_nested_packages],
+          configuration: configuration
+        )
+      end
+
+      sig { returns(T.nilable(OffensesFormatter)) }
+      def offenses_formatter_from_options
+        OffensesFormatter.find(parsed_options[:formatter_name]) if parsed_options[:formatter_name]
+      end
+
+      sig { returns(ParseRun) }
+      def parse_run
+        ParseRun.new(
+          relative_file_set: @files_for_processing.files,
+          parallel: configuration.parallel?,
+        )
+      end
+
+      sig { returns(T::Hash[Symbol, T.untyped]) }
+      def parsed_options
+        return @parsed_options if @parsed_options
+
+        @parsed_options = T.let(nil, T.nilable(T::Hash[Symbol, T.untyped]))
+
+        @parsed_options = {
+          relative_file_paths: T.let([], T::Array[String]),
+          ignore_nested_packages: T.let(false, T::Boolean),
+          formatter_name: T.let(nil, T.nilable(String)),
+          parallel: T.let(configuration.parallel?, T::Boolean),
+        }
+
+        OptionParser.new do |parser|
+          parser.on("--packages=PACKAGESLIST", Array, "package names, comma separated") do |p|
+            @parsed_options[:relative_file_paths] = p
+            @parsed_options[:ignore_nested_packages] = true
+          end
+
+          parser.on("--offenses-formatter=FORMATTER", String,
+            "identifier of offenses formatter to use") do |formatter_name|
+            @parsed_options[:formatter_name] = formatter_name
+          end
+
+          parser.on("--[no-]parallel", TrueClass, "parallel processing") do |parallel|
+            @parsed_options[:parallel] = parallel
+          end
+        end.parse!(args)
+
+        @parsed_options[:relative_file_paths] = args if @parsed_options[:relative_file_paths].empty?
+
+        @parsed_options
+      end
+    end
+
+    private_constant :UsesParseRun
+  end
+end

data/lib/packwerk/commands/validate_command.rb

@@ -0,0 +1,46 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Packwerk
+  module Commands
+    class ValidateCommand < BaseCommand
+      extend T::Sig
+
+      description "verify integrity of packwerk and package configuration"
+
+      sig { override.returns(T::Boolean) }
+      def run
+        validator_result = T.let(nil, T.nilable(Validator::Result))
+
+        progress_formatter.started_validation do
+          validator_result = validator.check_all(package_set, configuration)
+        end
+
+        validator_result = T.must(validator_result)
+
+        if validator_result.ok?
+          out.puts("Validation successful 🎉")
+        else
+          out.puts("Validation failed ❗\n\n#{validator_result.error_value}")
+        end
+
+        validator_result.ok?
+      end
+
+      private
+
+      sig { returns(ApplicationValidator) }
+      def validator
+        ApplicationValidator.new
+      end
+
+      sig { returns(PackageSet) }
+      def package_set
+        PackageSet.load_all_from(
+          configuration.root_path,
+          package_pathspec: configuration.package_paths
+        )
+      end
+    end
+  end
+end

data/lib/packwerk/commands/version_command.rb

@@ -0,0 +1,18 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Packwerk
+  module Commands
+    class VersionCommand < BaseCommand
+      extend T::Sig
+
+      description "output packwerk version"
+
+      sig { override.returns(T::Boolean) }
+      def run
+        out.puts(Packwerk::VERSION)
+        true
+      end
+    end
+  end
+end

data/lib/packwerk/commands.rb

@@ -0,0 +1,54 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Packwerk
+  module Commands
+    extend T::Sig
+    extend ActiveSupport::Autoload
+
+    autoload :BaseCommand
+    autoload :CheckCommand
+    autoload :HelpCommand
+    autoload :InitCommand
+    autoload :LazyLoadedEntry
+    autoload :UpdateTodoCommand
+    autoload :UsesParseRun
+    autoload :ValidateCommand
+    autoload :VersionCommand
+
+    class << self
+      extend T::Sig
+
+      sig { params(name: String, aliases: T::Array[String]).void }
+      def register(name, aliases: [])
+        registry << LazyLoadedEntry.new(name, aliases: aliases)
+      end
+
+      sig { params(name_or_alias: String).returns(T.nilable(T.class_of(BaseCommand))) }
+      def for(name_or_alias)
+        registry
+          .find { |command| command.matches_command?(name_or_alias) }
+          &.command_class
+      end
+
+      sig { returns(T::Array[LazyLoadedEntry]) }
+      def all
+        registry.dup
+      end
+
+      private
+
+      sig { returns(T::Array[LazyLoadedEntry]) }
+      def registry
+        @registry ||= T.let([], T.nilable(T::Array[LazyLoadedEntry]))
+      end
+    end
+
+    register("init")
+    register("check")
+    register("update-todo", aliases: ["update"])
+    register("validate")
+    register("version")
+    register("help")
+  end
+end

data/lib/packwerk/configuration.rb

@@ -60,6 +60,9 @@ module Packwerk
     sig { returns(Pathname) }
     attr_reader(:cache_directory)
 
+    sig { params(parallel: T::Boolean).returns(T::Boolean) }
+    attr_writer(:parallel)
+
     sig do
       params(
         configs: T::Hash[String, T.untyped],
@@ -72,7 +75,7 @@ module Packwerk
       root = config_path ? File.dirname(config_path) : "."
       @root_path = T.let(File.expand_path(root), String)
       @package_paths = T.let(configs["package_paths"] || "**/", T.any(String, T::Array[String]))
-      @custom_associations = T.let(configs["custom_associations"] || [], T::Array[Symbol])
+      @custom_associations = T.let((configs["custom_associations"] || []).map(&:to_sym), T::Array[Symbol])
       @parallel = T.let(configs.key?("parallel") ? configs["parallel"] : true, T::Boolean)
       @cache_enabled = T.let(configs.key?("cache") ? configs["cache"] : false, T::Boolean)
       @cache_directory = T.let(Pathname.new(configs["cache_directory"] || "tmp/cache/packwerk"), Pathname)

data/lib/packwerk/file_processor.rb

@@ -1,7 +1,7 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "ast/node"
+require "parser/ast/node"
 
 module Packwerk
   class FileProcessor
@@ -53,6 +53,17 @@ module Packwerk
       ProcessedFile.new(unresolved_references: unresolved_references)
     rescue Parsers::ParseError => e
       ProcessedFile.new(offenses: [e.result])
+    rescue StandardError => e
+      message = <<~MSG
+        Packwerk encountered an internal error.
+        For now, you can add this file to `packwerk.yml` `exclude` list.
+        Please file an issue and include this error message and stacktrace:
+
+        #{e.message} #{e.backtrace}"
+      MSG
+
+      offense = Parsers::ParseResult.new(file: relative_file, message: message)
+      ProcessedFile.new(offenses: [offense])
     end
 
     private

data/lib/packwerk/formatters/default_offenses_formatter.rb

@@ -20,9 +20,9 @@ module Packwerk
         EOS
       end
 
-      sig { override.params(offense_collection: OffenseCollection, fileset: T::Set[String]).returns(String) }
-      def show_stale_violations(offense_collection, fileset)
-        if offense_collection.stale_violations?(fileset)
+      sig { override.params(offense_collection: OffenseCollection, file_set: T::Set[String]).returns(String) }
+      def show_stale_violations(offense_collection, file_set)
+        if offense_collection.stale_violations?(file_set)
           "There were stale violations found, please run `packwerk update-todo`"
         else
           "No stale violations detected"

data/lib/packwerk/formatters/progress_formatter.rb

@@ -30,6 +30,15 @@ module Packwerk
         finished(execution_time)
       end
 
+      sig { params(failed: T::Boolean).void }
+      def increment_progress(failed = false)
+        if failed
+          mark_as_failed
+        else
+          mark_as_inspected
+        end
+      end
+
       sig { void }
       def mark_as_inspected
         @out.print(".")
@@ -44,6 +53,7 @@ module Packwerk
       def interrupted
         @out.puts
         @out.puts("Manually interrupted. Violations caught so far are listed below:")
+        @out.puts
       end
 
       private
@@ -52,6 +62,7 @@ module Packwerk
       def finished(execution_time)
         @out.puts
         @out.puts("📦 Finished in #{execution_time.round(2)} seconds")
+        @out.puts
       end
 
       sig { void }

data/lib/packwerk/generators/templates/packwerk.yml.erb

@@ -1,5 +1,5 @@
 # See: Setting up the configuration file
-# https://github.com/Shopify/packwerk/blob/main/USAGE.md#setting-up-the-configuration-file
+# https://github.com/Shopify/packwerk/blob/main/USAGE.md#configuring-packwerk
 
 # List of patterns for folder paths to include
 # include:

data/lib/packwerk/offense_collection.rb

@@ -11,12 +11,12 @@ module Packwerk
     sig do
       params(
         root_path: String,
-        package_todo: T::Hash[Packwerk::Package, Packwerk::PackageTodo]
+        package_todos: T::Hash[Packwerk::Package, Packwerk::PackageTodo]
       ).void
     end
-    def initialize(root_path, package_todo = {})
+    def initialize(root_path, package_todos = {})
       @root_path = root_path
-      @package_todo = T.let(package_todo, T::Hash[Packwerk::Package, Packwerk::PackageTodo])
+      @package_todos = T.let(package_todos, T::Hash[Packwerk::Package, Packwerk::PackageTodo])
       @new_violations = T.let([], T::Array[Packwerk::ReferenceOffense])
       @strict_mode_violations = T.let([], T::Array[Packwerk::ReferenceOffense])
       @errors = T.let([], T::Array[Packwerk::Offense])
@@ -38,8 +38,12 @@ module Packwerk
     def listed?(offense)
       return false unless offense.is_a?(ReferenceOffense)
 
-      reference = offense.reference
-      package_todo_for(reference.package).listed?(reference, violation_type: offense.violation_type)
+      already_listed?(offense)
+    end
+
+    sig { params(offenses: T::Array[Offense]).void }
+    def add_offenses(offenses)
+      offenses.each { |offense| add_offense(offense) }
     end
 
     sig do
@@ -51,16 +55,21 @@ module Packwerk
         return
       end
 
-      if !already_listed?(offense)
-        new_violations << offense
-      elsif strict_mode_violation?(offense)
+      already_listed = already_listed?(offense)
+
+      new_violations << offense unless already_listed
+
+      if strict_mode_violation?(offense)
+        add_to_package_todo(offense) if already_listed
         strict_mode_violations << offense
+      else
+        add_to_package_todo(offense)
       end
     end
 
     sig { params(for_files: T::Set[String]).returns(T::Boolean) }
     def stale_violations?(for_files)
-      @package_todo.values.any? do |package_todo|
+      @package_todos.values.any? do |package_todo|
         package_todo.stale_violations?(for_files)
       end
     end
@@ -76,10 +85,21 @@ module Packwerk
       errors + new_violations
     end
 
+    sig { returns(T::Array[Packwerk::ReferenceOffense]) }
+    def unlisted_strict_mode_violations
+      strict_mode_violations.reject { |offense| already_listed?(offense) }
+    end
+
     private
 
     sig { params(offense: ReferenceOffense).returns(T::Boolean) }
     def already_listed?(offense)
+      package_todo_for(offense.reference.package).listed?(offense.reference,
+        violation_type: offense.violation_type)
+    end
+
+    sig { params(offense: ReferenceOffense).returns(T::Boolean) }
+    def add_to_package_todo(offense)
       package_todo_for(offense.reference.package).add_entries(offense.reference,
         offense.violation_type)
     end
@@ -92,7 +112,7 @@ module Packwerk
 
     sig { params(package_set: Packwerk::PackageSet).void }
     def cleanup_extra_package_todo_files(package_set)
-      packages_without_todos = (package_set.packages.values - @package_todo.keys)
+      packages_without_todos = (package_set.packages.values - @package_todos.keys)
 
       packages_without_todos.each do |package|
         Packwerk::PackageTodo.new(
@@ -104,12 +124,12 @@ module Packwerk
 
     sig { void }
     def dump_package_todo_files
-      @package_todo.each_value(&:dump)
+      @package_todos.each_value(&:dump)
     end
 
     sig { params(package: Packwerk::Package).returns(Packwerk::PackageTodo) }
     def package_todo_for(package)
-      @package_todo[package] ||= Packwerk::PackageTodo.new(
+      @package_todos[package] ||= Packwerk::PackageTodo.new(
         package,
         package_todo_file_for(package),
       )

data/lib/packwerk/offenses_formatter.rb

@@ -22,14 +22,13 @@ module Packwerk
 
       sig { params(base: Class).void }
       def included(base)
-        @offenses_formatters ||= T.let(@offenses_formatters, T.nilable(T::Array[Class]))
-        @offenses_formatters ||= []
-        @offenses_formatters << base
+        offenses_formatters << base
       end
 
       sig { returns(T::Array[OffensesFormatter]) }
       def all
-        T.unsafe(@offenses_formatters).map(&:new)
+        load_defaults
+        T.cast(offenses_formatters.map(&:new), T::Array[OffensesFormatter])
       end
 
       sig { params(identifier: String).returns(OffensesFormatter) }
@@ -39,6 +38,16 @@ module Packwerk
 
       private
 
+      sig { void }
+      def load_defaults
+        require("packwerk/formatters/default_offenses_formatter")
+      end
+
+      sig { returns(T::Array[Class]) }
+      def offenses_formatters
+        @offenses_formatters ||= T.let([], T.nilable(T::Array[Class]))
+      end
+
       sig { params(name: String).returns(OffensesFormatter) }
       def formatter_by_identifier(name)
         @formatter_by_identifier ||= T.let(nil, T.nilable(T::Hash[String, T.nilable(OffensesFormatter)]))