packwerk 3.0.0 → 3.2.2

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

@@ -54,12 +54,18 @@ module Packwerk
     sig { returns(T::Array[Symbol]) }
     attr_reader(:custom_associations)
 
+    sig { returns(T::Array[String]) }
+    attr_reader(:associations_exclude)
+
     sig { returns(T.nilable(String)) }
     attr_reader(:config_path)
 
     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 +78,8 @@ 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])
+      @associations_exclude = T.let(configs["associations_exclude"] || [], T::Array[String])
       @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/const_node_inspector.rb

@@ -9,10 +9,10 @@ module Packwerk
 
     sig do
       override
-        .params(node: AST::Node, ancestors: T::Array[AST::Node])
+        .params(node: AST::Node, ancestors: T::Array[AST::Node], relative_file: String)
         .returns(T.nilable(String))
     end
-    def constant_name_from_node(node, ancestors:)
+    def constant_name_from_node(node, ancestors:, relative_file:)
       return nil unless NodeHelpers.constant?(node)
 
       parent = ancestors.first

data/lib/packwerk/constant_name_inspector.rb

@@ -13,10 +13,10 @@ module Packwerk
 
     sig do
       abstract
-        .params(node: ::AST::Node, ancestors: T::Array[::AST::Node])
+        .params(node: ::AST::Node, ancestors: T::Array[::AST::Node], relative_file: String)
         .returns(T.nilable(String))
     end
-    def constant_name_from_node(node, ancestors:); end
+    def constant_name_from_node(node, ancestors:, relative_file:); end
   end
 
   private_constant :ConstantNameInspector

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&.join("\n")}"
+      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/package.yml

@@ -2,8 +2,8 @@
 # Please validate the configuration using `packwerk validate` (for Rails applications) or running the auto generated
 # test case (for non-Rails projects). You can then use `packwerk check` to check your code.
 
-# Turn on dependency checks for this package
-enforce_dependencies: true
+# Change to `true` to turn on dependency checks for this package
+enforce_dependencies: false
 
 # A list of this package's dependencies
 # Note that packages in this list require their own `package.yml` file

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

@@ -20,16 +20,15 @@ module Packwerk
     class << self
       extend T::Sig
 
-      sig { params(base: Class).void }
+      sig { params(base: T::Class[T.anything]).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[T::Class[T.anything]]) }
+      def offenses_formatters
+        @offenses_formatters ||= T.let([], T.nilable(T::Array[T::Class[T.anything]]))
+      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)]))

data/lib/packwerk/package.rb

@@ -42,7 +42,7 @@ module Packwerk
     def package_path?(path)
       return true if root?
 
-      path.start_with?(@name)
+      path.start_with?(@name + "/")
     end
 
     sig { params(other: T.untyped).returns(T.nilable(Integer)) }