packwerk 2.3.0 → 3.0.1

data/lib/packwerk/cli.rb

@@ -14,8 +14,8 @@ module Packwerk
         out: T.any(StringIO, IO),
         err_out: T.any(StringIO, IO),
         environment: String,
-        style: Packwerk::OutputStyle,
-        offenses_formatter: T.nilable(Packwerk::OffensesFormatter)
+        style: OutputStyle,
+        offenses_formatter: T.nilable(OffensesFormatter)
       ).void
     end
     def initialize(
@@ -33,7 +33,7 @@ module Packwerk
       @configuration = T.let(configuration || Configuration.from_path, Configuration)
       @progress_formatter = T.let(Formatters::ProgressFormatter.new(@out, style: style), Formatters::ProgressFormatter)
       @offenses_formatter = T.let(
-        offenses_formatter || Formatters::OffensesFormatter.new(style: @style),
+        offenses_formatter || @configuration.offenses_formatter,
         OffensesFormatter
       )
     end
@@ -52,22 +52,13 @@ module Packwerk
         init
       when "check"
         output_result(parse_run(args).check)
-      when "detect-stale-violations"
-        output_result(parse_run(args).detect_stale_violations)
-      when "update-deprecations"
-        warning = <<~WARNING.squish
-          DEPRECATION WARNING: `update-deprecations` is deprecated in favor of
-          `update-todo`.
-        WARNING
-
-        warn(warning)
-        output_result(parse_run(args).update_todo)
-      when "update-todo"
-        output_result(parse_run(args).update_todo)
-      when "update"
+      when "update-todo", "update"
         output_result(parse_run(args).update_todo)
       when "validate"
         validate(args)
+      when "version"
+        @out.puts(Packwerk::VERSION)
+        true
       when nil, "help"
         usage
       else
@@ -89,12 +80,12 @@ module Packwerk
 
     sig { returns(T::Boolean) }
     def generate_configs
-      configuration_file = Packwerk::Generators::ConfigurationFile.generate(
+      configuration_file = Generators::ConfigurationFile.generate(
         root: @configuration.root_path,
         out: @out
       )
 
-      root_package = Packwerk::Generators::RootPackage.generate(root: @configuration.root_path, out: @out)
+      root_package = Generators::RootPackage.generate(root: @configuration.root_path, out: @out)
 
       success = configuration_file && root_package
 
@@ -124,8 +115,9 @@ module Packwerk
         Subcommands:
           init - set up packwerk
           check - run all checks
-          update-deprecations - update deprecated_references.yml files
+          update-todo - update package_todo.yml files
           validate - verify integrity of packwerk and package configuration
+          version - output packwerk version
           help  - display help information about packwerk
       USAGE
       true
@@ -142,72 +134,95 @@ module Packwerk
       params(
         relative_file_paths: T::Array[String],
         ignore_nested_packages: T::Boolean
-      ).returns(FilesForProcessing::RelativeFileSet)
+      ).returns(FilesForProcessing)
     end
     def fetch_files_to_process(relative_file_paths, ignore_nested_packages)
-      relative_file_set = FilesForProcessing.fetch(
+      files_for_processing = FilesForProcessing.fetch(
         relative_file_paths: relative_file_paths,
         ignore_nested_packages: ignore_nested_packages,
         configuration: @configuration
       )
-      abort("No files found or given. "\
-        "Specify files or check the include and exclude glob in the config file.") if relative_file_set.empty?
-      relative_file_set
+      @out.puts(<<~MSG.squish) if files_for_processing.files.empty?
+        No files found or given.
+        Specify files or check the include and exclude glob in the config file.
+      MSG
+
+      files_for_processing
     end
 
     sig { params(_paths: T::Array[String]).returns(T::Boolean) }
     def validate(_paths)
+      result = T.let(nil, T.nilable(Validator::Result))
+
       @progress_formatter.started_validation do
-        result = checker.check_all
+        result = validator.check_all(package_set, @configuration)
 
         list_validation_errors(result)
-
-        return result.ok?
       end
+
+      T.must(result).ok?
     end
 
     sig { returns(ApplicationValidator) }
-    def checker
-      Packwerk::ApplicationValidator.new(
-        config_file_path: @configuration.config_path,
-        configuration: @configuration,
-        environment: @environment,
+    def validator
+      ApplicationValidator.new
+    end
+
+    sig { returns(PackageSet) }
+    def package_set
+      PackageSet.load_all_from(
+        @configuration.root_path,
+        package_pathspec: @configuration.package_paths
       )
     end
 
-    sig { params(result: ApplicationValidator::Result).void }
+    sig { params(result: Validator::Result).void }
     def list_validation_errors(result)
       @out.puts
       if result.ok?
         @out.puts("Validation successful 🎉")
       else
         @out.puts("Validation failed ❗")
+        @out.puts
         @out.puts(result.error_value)
       end
     end
 
-    sig { params(params: T.untyped).returns(ParseRun) }
-    def parse_run(params)
+    sig { params(args: T::Array[String]).returns(ParseRun) }
+    def parse_run(args)
       relative_file_paths = T.let([], T::Array[String])
       ignore_nested_packages = nil
+      formatter = @offenses_formatter
 
-      if params.any? { |p| p.include?("--packages") }
+      if args.any? { |arg| arg.include?("--packages") }
         OptionParser.new do |parser|
           parser.on("--packages=PACKAGESLIST", Array, "package names, comma separated") do |p|
             relative_file_paths = p
           end
-        end.parse!(params)
+        end.parse!(args)
         ignore_nested_packages = true
       else
-        relative_file_paths = params
+        relative_file_paths = args
         ignore_nested_packages = false
       end
 
+      if args.any? { |arg| arg.include?("--offenses-formatter") }
+        OptionParser.new do |parser|
+          parser.on("--offenses-formatter=FORMATTER", String,
+            "identifier of offenses formatter to use") do |formatter_identifier|
+            formatter = OffensesFormatter.find(formatter_identifier)
+          end
+        end.parse!(args)
+      end
+
+      files_for_processing = fetch_files_to_process(relative_file_paths, ignore_nested_packages)
+
       ParseRun.new(
-        relative_file_set: fetch_files_to_process(relative_file_paths, ignore_nested_packages),
+        relative_file_set: files_for_processing.files,
+        file_set_specified: files_for_processing.files_specified?,
         configuration: @configuration,
         progress_formatter: @progress_formatter,
-        offenses_formatter: @offenses_formatter
+        offenses_formatter: formatter
       )
     end
   end

data/lib/packwerk/configuration.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "pathname"
@@ -6,7 +6,12 @@ require "yaml"
 
 module Packwerk
   class Configuration
+    extend T::Sig
+
     class << self
+      extend T::Sig
+
+      sig { params(path: String).returns(Configuration) }
       def from_path(path = Dir.pwd)
         raise ArgumentError, "#{File.expand_path(path)} does not exist" unless File.exist?(path)
 
@@ -21,6 +26,7 @@ module Packwerk
 
       private
 
+      sig { params(path: String).returns(Configuration) }
       def from_packwerk_config(path)
         new(
           YAML.load_file(path) || {},
@@ -30,63 +36,78 @@ module Packwerk
     end
 
     DEFAULT_CONFIG_PATH = "packwerk.yml"
-    DEFAULT_INCLUDE_GLOBS = ["**/*.{rb,rake,erb}"]
-    DEFAULT_EXCLUDE_GLOBS = ["{bin,node_modules,script,tmp,vendor}/**/*"]
+    DEFAULT_INCLUDE_GLOBS = T.let(["**/*.{rb,rake,erb}"], T::Array[String])
+    DEFAULT_EXCLUDE_GLOBS = T.let(["{bin,node_modules,script,tmp,vendor}/**/*"], T::Array[String])
 
-    attr_reader(
-      :include, :exclude, :root_path, :package_paths, :custom_associations, :config_path, :cache_directory
-    )
+    sig { returns(T::Array[String]) }
+    attr_reader(:include)
 
-    def initialize(configs = {}, config_path: nil)
-      @include = configs["include"] || DEFAULT_INCLUDE_GLOBS
-      @exclude = configs["exclude"] || DEFAULT_EXCLUDE_GLOBS
-      root = config_path ? File.dirname(config_path) : "."
-      @root_path = File.expand_path(root)
-      @package_paths = configs["package_paths"] || "**/"
-      @custom_associations = configs["custom_associations"] || []
-      @parallel = configs.key?("parallel") ? configs["parallel"] : true
-      @cache_enabled = configs.key?("cache") ? configs["cache"] : false
-      @cache_directory = Pathname.new(configs["cache_directory"] || "tmp/cache/packwerk")
-      @config_path = config_path
+    sig { returns(T::Array[String]) }
+    attr_reader(:exclude)
 
-      if configs["load_paths"]
-        warning = <<~WARNING
-          DEPRECATION WARNING: The 'load_paths' key in `packwerk.yml` is deprecated.
-          This value is no longer cached, and you can remove the key from `packwerk.yml`.
-        WARNING
+    sig { returns(String) }
+    attr_reader(:root_path)
 
-        warn(warning)
-      end
+    sig { returns(T.any(String, T::Array[String])) }
+    attr_reader(:package_paths)
 
-      if configs["inflections_file"]
-        warning = <<~WARNING
-          DEPRECATION WARNING: The 'inflections_file' key in `packwerk.yml` is deprecated.
-          This value is no longer cached, and you can remove the key from `packwerk.yml`.
-          You can also delete #{configs["inflections_file"]}.
-        WARNING
+    sig { returns(T::Array[Symbol]) }
+    attr_reader(:custom_associations)
 
-        warn(warning)
-      end
+    sig { returns(T.nilable(String)) }
+    attr_reader(:config_path)
+
+    sig { returns(Pathname) }
+    attr_reader(:cache_directory)
 
-      inflection_file = File.expand_path(configs["inflections_file"] || "config/inflections.yml", @root_path)
-      if Pathname.new(inflection_file).exist?
-        warning = <<~WARNING
-          DEPRECATION WARNING: Inflections YMLs in packwerk are now deprecated.
-          This value is no longer cached, and you can now delete #{inflection_file}
-        WARNING
+    sig do
+      params(
+        configs: T::Hash[String, T.untyped],
+        config_path: T.nilable(String),
+      ).void
+    end
+    def initialize(configs = {}, config_path: nil)
+      @include = T.let(configs["include"] || DEFAULT_INCLUDE_GLOBS, T::Array[String])
+      @exclude = T.let(configs["exclude"] || DEFAULT_EXCLUDE_GLOBS, T::Array[String])
+      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])
+      @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)
+      @config_path = config_path
 
-        warn(warning)
+      @offenses_formatter_identifier = T.let(
+        configs["offenses_formatter"] || Formatters::DefaultOffensesFormatter::IDENTIFIER, String
+      )
+
+      if configs.key?("require")
+        configs["require"].each do |require_directive|
+          ExtensionLoader.load(require_directive, @root_path)
+        end
       end
     end
 
+    sig { returns(T::Hash[String, Module]) }
     def load_paths
-      @load_paths ||= ApplicationLoadPaths.extract_relevant_paths(@root_path, "test")
+      @load_paths ||= T.let(
+        RailsLoadPaths.for(@root_path, environment: "test"),
+        T.nilable(T::Hash[String, Module]),
+      )
     end
 
+    sig { returns(T::Boolean) }
     def parallel?
       @parallel
     end
 
+    sig { returns(OffensesFormatter) }
+    def offenses_formatter
+      OffensesFormatter.find(@offenses_formatter_identifier)
+    end
+
+    sig { returns(T::Boolean) }
     def cache_enabled?
       @cache_enabled
     end

data/lib/packwerk/const_node_inspector.rb

@@ -52,4 +52,6 @@ module Packwerk
       "::" + NodeHelpers.parent_module_name(ancestors: ancestors)
     end
   end
+
+  private_constant :ConstNodeInspector
 end

data/lib/packwerk/constant_context.rb

@@ -0,0 +1,8 @@
+# typed: true
+# frozen_string_literal: true
+
+module Packwerk
+  extend T::Sig
+
+  ConstantContext = Struct.new(:name, :location, :package)
+end

data/lib/packwerk/constant_discovery.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "constant_resolver"
@@ -17,8 +17,6 @@ module Packwerk
   class ConstantDiscovery
     extend T::Sig
 
-    ConstantContext = Struct.new(:name, :location, :package, :public?)
-
     # @param constant_resolver [ConstantResolver]
     # @param packages [Packwerk::PackageSet]
     sig do
@@ -50,12 +48,12 @@ module Packwerk
     # @param const_name [String] The unresolved constant's name.
     # @param current_namespace_path [Array<String>] (optional) The namespace of the context in which the constant is
     #   used, e.g. ["Apps", "Models"] for `Apps::Models`. Defaults to [] which means top level.
-    # @return [Packwerk::ConstantDiscovery::ConstantContext]
+    # @return [ConstantContext]
     sig do
       params(
         const_name: String,
         current_namespace_path: T.nilable(T::Array[String]),
-      ).returns(T.nilable(ConstantDiscovery::ConstantContext))
+      ).returns(T.nilable(ConstantContext))
     end
     def context_for(const_name, current_namespace_path: [])
       begin
@@ -71,8 +69,9 @@ module Packwerk
         constant.name,
         constant.location,
         package,
-        package.public_path?(constant.location),
       )
     end
   end
+
+  private_constant :ConstantDiscovery
 end

data/lib/packwerk/constant_name_inspector.rb

@@ -18,4 +18,6 @@ module Packwerk
     end
     def constant_name_from_node(node, ancestors:); end
   end
+
+  private_constant :ConstantNameInspector
 end

data/lib/packwerk/disable_sorbet.rb

@@ -0,0 +1,41 @@
+# typed: true
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+begin
+  T::Configuration.default_checked_level = :never
+
+  T.singleton_class.prepend(
+    Module.new do
+      def cast(value, type, checked: true)
+        value
+      end
+
+      def let(value, type, checked: true)
+        value
+      end
+
+      def must(arg)
+        arg
+      end
+
+      def absurd(value)
+        value
+      end
+
+      def bind(value, type, checked: true)
+        value
+      end
+    end
+  )
+rescue RuntimeError => error
+  # From https://github.com/sorbet/sorbet/blob/dcf1b069cfb0d6624c027e45e59f4c6ca33de970/gems/sorbet-runtime/lib/types/private/runtime_levels.rb#L54
+  # Sorbet has already evaluated a method call somewhere, so we can't disable it.
+  # In this case, we want to log a warning so Packwerk can still be used (but will be slower).
+  if /Set the default checked level earlier./.match?(error.message)
+    warn("Packwerk couldn't disable Sorbet. Please ensure it isn't being used before Packwerk is loaded.")
+  else
+    raise error
+  end
+end

data/lib/packwerk/extension_loader.rb

@@ -0,0 +1,24 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Packwerk
+  # This class handles loading extensions to packwerk using the `require` directive
+  # in the `packwerk.yml` configuration.
+  module ExtensionLoader
+    class << self
+      extend T::Sig
+      sig { params(require_directive: String, config_dir_path: String).void }
+      def load(require_directive, config_dir_path)
+        # We want to transform the require directive to behave differently
+        # if it's a specific local file being required versus a gem
+        if require_directive.start_with?(".")
+          require File.join(config_dir_path, require_directive)
+        else
+          require require_directive
+        end
+      end
+    end
+  end
+
+  private_constant :ExtensionLoader
+end

data/lib/packwerk/file_processor.rb

@@ -64,7 +64,7 @@ module Packwerk
       references = []
 
       node_processor = @node_processor_factory.for(relative_file: relative_file, node: node)
-      node_visitor = Packwerk::NodeVisitor.new(node_processor: node_processor)
+      node_visitor = NodeVisitor.new(node_processor: node_processor)
       node_visitor.visit(node, ancestors: [], result: references)
 
       references
@@ -82,4 +82,6 @@ module Packwerk
       @parser_factory.for_path(file_path)
     end
   end
+
+  private_constant :FileProcessor
 end

data/lib/packwerk/files_for_processing.rb

@@ -15,10 +15,10 @@ module Packwerk
           relative_file_paths: T::Array[String],
           configuration: Configuration,
           ignore_nested_packages: T::Boolean
-        ).returns(RelativeFileSet)
+        ).returns(FilesForProcessing)
       end
       def fetch(relative_file_paths:, configuration:, ignore_nested_packages: false)
-        new(relative_file_paths, configuration, ignore_nested_packages).files
+        new(relative_file_paths, configuration, ignore_nested_packages)
       end
     end
 
@@ -33,37 +33,48 @@ module Packwerk
       @relative_file_paths = relative_file_paths
       @configuration = configuration
       @ignore_nested_packages = ignore_nested_packages
-      @custom_files = T.let(nil, T.nilable(RelativeFileSet))
+      @specified_files = T.let(nil, T.nilable(RelativeFileSet))
+      @files = T.let(nil, T.nilable(RelativeFileSet))
     end
 
     sig { returns(RelativeFileSet) }
     def files
-      include_files = if custom_files.empty?
+      @files ||= files_for_processing
+    end
+
+    sig { returns(T::Boolean) }
+    def files_specified?
+      specified_files.any?
+    end
+
+    private
+
+    sig { returns(RelativeFileSet) }
+    def files_for_processing
+      all_included_files = if specified_files.empty?
         configured_included_files
       else
-        configured_included_files & custom_files
+        configured_included_files & specified_files
       end
 
-      include_files - configured_excluded_files
+      all_included_files - configured_excluded_files
     end
 
-    private
-
     sig { returns(RelativeFileSet) }
-    def custom_files
-      @custom_files ||= Set.new(
+    def specified_files
+      @specified_files ||= Set.new(
         @relative_file_paths.map do |relative_file_path|
           if File.file?(relative_file_path)
             relative_file_path
           else
-            custom_included_files(relative_file_path)
+            specified_included_files(relative_file_path)
           end
         end
       ).flatten
     end
 
     sig { params(relative_file_path: String).returns(RelativeFileSet) }
-    def custom_included_files(relative_file_path)
+    def specified_included_files(relative_file_path)
       # Note, assuming include globs are always relative paths
       relative_includes = @configuration.include
       relative_files = Dir.glob([File.join(relative_file_path, "**", "*")]).select do |relative_path|
@@ -100,4 +111,6 @@ module Packwerk
       Set.new(relative_globs.flat_map { |glob| Dir[glob] })
     end
   end
+
+  private_constant :FilesForProcessing
 end

data/lib/packwerk/formatters/default_offenses_formatter.rb

@@ -0,0 +1,77 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Packwerk
+  module Formatters
+    class DefaultOffensesFormatter
+      include OffensesFormatter
+
+      IDENTIFIER = T.let("default", String)
+
+      extend T::Sig
+
+      sig { override.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
+
+      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)
+          "There were stale violations found, please run `packwerk update-todo`"
+        else
+          "No stale violations detected"
+        end
+      end
+
+      sig { override.returns(String) }
+      def identifier
+        IDENTIFIER
+      end
+
+      sig { override.params(strict_mode_violations: T::Array[ReferenceOffense]).returns(String) }
+      def show_strict_mode_violations(strict_mode_violations)
+        if strict_mode_violations.any?
+          strict_mode_violations.compact.map { |offense| format_strict_mode_violation(offense) }.join("\n")
+        else
+          ""
+        end
+      end
+
+      private
+
+      sig { returns(OutputStyle) }
+      def style
+        @style ||= T.let(Packwerk::OutputStyles::Coloured.new, T.nilable(Packwerk::OutputStyles::Coloured))
+      end
+
+      sig { params(offense: ReferenceOffense).returns(String) }
+      def format_strict_mode_violation(offense)
+        reference_package = offense.reference.package
+        defining_package = offense.reference.constant.package
+        "#{reference_package} cannot have #{offense.violation_type} violations on #{defining_package} "\
+          "because strict mode is enabled for #{offense.violation_type} violations in "\
+          "the enforcing package's package.yml"
+      end
+
+      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 = "offense".pluralize(offenses.length)
+        "#{offenses.length} #{offenses_string} detected"
+      end
+    end
+  end
+end