packwerk 1.1.0 → 1.2.0

data/lib/packwerk/application_validator.rb

@@ -6,11 +6,6 @@ require "constant_resolver"
 require "pathname"
 require "yaml"
 
-require "packwerk/package_set"
-require "packwerk/graph"
-require "packwerk/inflector"
-require "packwerk/application_load_paths"
-
 module Packwerk
   class ApplicationValidator
     def initialize(config_file_path:, configuration:)
@@ -35,16 +30,7 @@ module Packwerk
         check_root_package_exists,
       ]
 
-      results.reject!(&:ok?)
-
-      if results.empty?
-        Result.new(true)
-      else
-        Result.new(
-          false,
-          results.map(&:error_value).join("\n===\n")
-        )
-      end
+      merge_results(results)
     end
 
     def check_autoload_path_cache
@@ -65,51 +51,37 @@ module Packwerk
     def check_package_manifests_for_privacy
       privacy_settings = package_manifests_settings_for("enforce_privacy")
 
-      autoload_paths = @configuration.load_paths
-
       resolver = ConstantResolver.new(
         root_path: @configuration.root_path,
-        load_paths: autoload_paths
+        load_paths: @configuration.load_paths
       )
 
-      errors = []
+      results = []
 
-      privacy_settings.each do |filepath, setting|
+      privacy_settings.each do |config_file_path, setting|
         next unless setting.is_a?(Array)
+        constants = setting
 
-        setting.each do |constant|
-          # make sure the constant can be loaded
-          constant.constantize # rubocop:disable Sorbet/ConstantsFromStrings
-          context = resolver.resolve(constant)
-
-          unless context
-            errors << "#{constant}, listed in #{filepath.inspect}, could not be resolved"
-            next
-          end
-
-          expected_filename = constant.underscore + ".rb"
+        assert_constants_can_be_loaded(constants)
 
-          # We don't support all custom inflections yet, so we may accidentally resolve constants to the
-          # file that defines their parent namespace. This restriction makes sure that we don't.
-          next if context.location.end_with?(expected_filename)
+        constant_locations = constants.map { |c| [c, resolver.resolve(c)&.location] }
 
-          errors << "Explicitly private constants need to have their own files.\n"\
-            "#{constant}, listed in #{filepath.inspect}, was resolved to #{context.location.inspect}.\n"\
-            "It should be in something like #{expected_filename.inspect}"
+        constant_locations.each do |name, location|
+          results << if location
+            check_private_constant_location(name, location, config_file_path)
+          else
+            private_constant_unresolvable(name, config_file_path)
+          end
         end
       end
 
-      if errors.empty?
-        Result.new(true)
-      else
-        Result.new(false, errors.join("\n---\n"))
-      end
+      merge_results(results, separator: "\n---\n")
     end
 
     def check_package_manifest_syntax
       errors = []
 
-      package_manifests(package_glob).each do |f|
+      package_manifests.each do |f|
         hash = YAML.load_file(f)
         next unless hash
 
@@ -124,26 +96,26 @@ module Packwerk
 
         if hash.key?("enforce_privacy")
           unless [TrueClass, FalseClass, Array].include?(hash["enforce_privacy"].class)
-            errors << "Invalid 'enforce_privacy' option in #{f.inspect}: #{hash['enforce_privacy'].inspect}"
+            errors << "Invalid 'enforce_privacy' option in #{f.inspect}: #{hash["enforce_privacy"].inspect}"
           end
         end
 
         if hash.key?("enforce_dependencies")
           unless [TrueClass, FalseClass].include?(hash["enforce_dependencies"].class)
-            errors << "Invalid 'enforce_dependencies' option in #{f.inspect}: #{hash['enforce_dependencies'].inspect}"
+            errors << "Invalid 'enforce_dependencies' option in #{f.inspect}: #{hash["enforce_dependencies"].inspect}"
           end
         end
 
         if hash.key?("public_path")
           unless hash["public_path"].is_a?(String)
-            errors << "'public_path' option must be a string in #{f.inspect}: #{hash['public_path'].inspect}"
+            errors << "'public_path' option must be a string in #{f.inspect}: #{hash["public_path"].inspect}"
           end
         end
 
         next unless hash.key?("dependencies")
         next if hash["dependencies"].is_a?(Array)
 
-        errors << "Invalid 'dependencies' option in #{f.inspect}: #{hash['dependencies'].inspect}"
+        errors << "Invalid 'dependencies' option in #{f.inspect}: #{hash["dependencies"].inspect}"
       end
 
       if errors.empty?
@@ -193,24 +165,16 @@ module Packwerk
         end
       end
 
-      errors = results.reject(&:ok?)
-
-      if errors.empty?
-        Result.new(true)
-      else
-        Result.new(
-          false,
-          "Inflections specified in #{inflections_file} don't line up with application!\n" +
-            errors.map(&:error_value).join("\n")
-        )
-      end
+      merge_results(
+        results,
+        separator: "\n",
+        errors_headline: "Inflections specified in #{inflections_file} don't line up with application!\n"
+      )
     end
 
     def check_acyclic_graph
-      packages = Packwerk::PackageSet.load_all_from(@configuration.root_path)
-
-      edges = packages.flat_map do |package|
-        package.dependencies.map { |dependency| [package, packages.fetch(dependency)] }
+      edges = package_set.flat_map do |package|
+        package.dependencies.map { |dependency| [package, package_set.fetch(dependency)] }
       end
       dependency_graph = Packwerk::Graph.new(*edges)
 
@@ -225,7 +189,7 @@ module Packwerk
       cycle_strings = dependency_graph.cycles.map do |cycle|
         cycle_strings = cycle.map(&:to_s)
         cycle_strings << cycle.first.to_s
-        "\t- #{cycle_strings.join(' → ')}"
+        "\t- #{cycle_strings.join(" → ")}"
       end
 
       if dependency_graph.acyclic?
@@ -316,8 +280,7 @@ module Packwerk
     private
 
     def package_manifests_settings_for(setting)
-      package_manifests(package_glob)
-        .map { |f| [f, (YAML.load_file(File.join(f)) || {})[setting]] }
+      package_manifests.map { |f| [f, (YAML.load_file(File.join(f)) || {})[setting]] }
     end
 
     def format_yaml_strings(list)
@@ -328,13 +291,17 @@ module Packwerk
       @configuration.package_paths || "**"
     end
 
-    def package_manifests(glob_pattern)
+    def package_manifests(glob_pattern = package_glob)
       PackageSet.package_paths(@configuration.root_path, glob_pattern)
         .map { |f| File.realpath(f) }
     end
 
     def relative_paths(paths)
-      paths.map { |path| Pathname.new(path).relative_path_from(@configuration.root_path) }
+      paths.map { |path| relative_path(path) }
+    end
+
+    def relative_path(path)
+      Pathname.new(path).relative_path_from(@configuration.root_path)
     end
 
     def invalid_package_path?(path)
@@ -344,5 +311,54 @@ module Packwerk
       package_path = File.join(@configuration.root_path, path, Packwerk::PackageSet::PACKAGE_CONFIG_FILENAME)
       !File.file?(package_path)
     end
+
+    def assert_constants_can_be_loaded(constants)
+      constants.each(&:constantize)
+      nil
+    end
+
+    def private_constant_unresolvable(name, config_file_path)
+      explicit_filepath = (name.start_with?("::") ? name[2..-1] : name).underscore + ".rb"
+
+      Result.new(
+        false,
+        "'#{name}', listed in #{config_file_path}, could not be resolved.\n"\
+        "This is probably because it is an autovivified namespace - a namespace module that doesn't have a\n"\
+        "file explicitly defining it. Packwerk currently doesn't support declaring autovivified namespaces as\n"\
+        "private. Add a #{explicit_filepath} file to explicitly define the constant."
+      )
+    end
+
+    def check_private_constant_location(name, location, config_file_path)
+      declared_package = package_set.package_from_path(relative_path(config_file_path))
+      constant_package = package_set.package_from_path(location)
+
+      if constant_package == declared_package
+        Result.new(true)
+      else
+        Result.new(
+          false,
+          "'#{name}' is declared as private in the '#{declared_package}' package but appears to be "\
+          "defined\nin the '#{constant_package}' package. Packwerk resolved it to #{location}."
+        )
+      end
+    end
+
+    def package_set
+      @package_set ||= Packwerk::PackageSet.load_all_from(@configuration.root_path, package_pathspec: package_glob)
+    end
+
+    def merge_results(results, separator: "\n===\n", errors_headline: "")
+      results.reject!(&:ok?)
+
+      if results.empty?
+        Result.new(true)
+      else
+        Result.new(
+          false,
+          errors_headline + results.map(&:error_value).join(separator)
+        )
+      end
+    end
   end
 end

data/lib/packwerk/association_inspector.rb

@@ -1,26 +1,35 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-require "packwerk/constant_name_inspector"
-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]) }
+
+    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.method_call?(node)
       return unless association?(node)
@@ -38,11 +47,13 @@ module Packwerk
 
     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
@@ -50,6 +61,7 @@ module Packwerk
       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])
 

data/lib/packwerk/checker.rb

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

data/lib/packwerk/cli.rb

@@ -1,35 +1,32 @@
 # typed: true
 # frozen_string_literal: true
-require "benchmark"
-require "sorbet-runtime"
-
-require "packwerk/application_validator"
-require "packwerk/configuration"
-require "packwerk/files_for_processing"
-require "packwerk/formatters/progress_formatter"
-require "packwerk/inflector"
-require "packwerk/output_styles"
-require "packwerk/run_context"
-require "packwerk/updating_deprecated_references"
-require "packwerk/checking_deprecated_references"
-require "packwerk/commands/detect_stale_violations_command"
-require "packwerk/commands/offense_progress_marker"
 
 module Packwerk
   class Cli
     extend T::Sig
-    include OffenseProgressMarker
 
-    def initialize(run_context: nil, configuration: nil, out: $stdout, err_out: $stderr, style: OutputStyles::Plain)
+    sig do
+      params(
+        configuration: T.nilable(Configuration),
+        out: T.any(StringIO, IO),
+        err_out: T.any(StringIO, IO),
+        style: Packwerk::OutputStyle,
+        offenses_formatter: T.nilable(Packwerk::OffensesFormatter)
+      ).void
+    end
+    def initialize(
+      configuration: nil,
+      out: $stdout,
+      err_out: $stderr,
+      style: OutputStyles::Plain.new,
+      offenses_formatter: nil
+    )
       @out = out
       @err_out = err_out
       @style = style
       @configuration = configuration || Configuration.from_path
-      @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)
+      @offenses_formatter = offenses_formatter || Formatters::OffensesFormatter.new(style: @style)
     end
 
     sig { params(args: T::Array[String]).returns(T.noreturn) }
@@ -47,13 +44,13 @@ module Packwerk
       when "generate_configs"
         generate_configs
       when "check"
-        check(args)
+        output_result(parse_run(args).check)
       when "detect-stale-violations"
-        detect_stale_violations(args)
+        output_result(parse_run(args).detect_stale_violations)
       when "update"
         update(args)
       when "update-deprecations"
-        update_deprecations(args)
+        output_result(parse_run(args).update_deprecations)
       when "validate"
         validate(args)
       when nil, "help"
@@ -101,7 +98,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
       )
@@ -130,71 +127,10 @@ module Packwerk
 
     def update(paths)
       warn("`packwerk update` is deprecated in favor of `packwerk update-deprecations`.")
-      update_deprecations(paths)
-    end
-
-    def update_deprecations(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.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
-
-      @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.")
-
-      all_offenses.empty?
-    end
-
-    def check(paths)
-      files = fetch_files_to_process(paths)
-
-      @progress_formatter.started(files)
-
-      all_offenses = T.let([], T.untyped)
-      execution_time = Benchmark.realtime do
-        files.each do |path|
-          @run_context.process_file(file: path).tap do |offenses|
-            mark_progress(offenses: offenses, progress_formatter: @progress_formatter)
-            all_offenses.concat(offenses)
-          end
-        end
-      rescue Interrupt
-        @out.puts
-        @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)
-
-      all_offenses.empty?
+      output_result(parse_run(paths).update_deprecations)
     end
 
-    def detect_stale_violations(paths)
-      detect_stale_violations = DetectStaleViolationsCommand.new(
-        files: fetch_files_to_process(paths),
-        configuration: @configuration,
-        progress_formatter: @progress_formatter
-      )
-      result = detect_stale_violations.run
+    def output_result(result)
       @out.puts
       @out.puts(result.message)
       result.status
@@ -225,19 +161,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?
@@ -256,5 +179,14 @@ module Packwerk
         false
       end
     end
+
+    def parse_run(paths)
+      ParseRun.new(
+        files: fetch_files_to_process(paths),
+        configuration: @configuration,
+        progress_formatter: @progress_formatter,
+        offenses_formatter: @offenses_formatter
+      )
+    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,10 +45,15 @@ module Packwerk
       @root_path = File.expand_path(root)
       @package_paths = configs["package_paths"] || "**/"
       @custom_associations = configs["custom_associations"] || []
-      @load_paths = configs["load_paths"]
+      @load_paths = configs["load_paths"] || []
       @inflections_file = File.expand_path(configs["inflections_file"] || "config/inflections.yml", @root_path)
+      @parallel = configs.key?("parallel") ? configs["parallel"] : true
 
       @config_path = config_path
     end
+
+    def parallel?
+      @parallel
+    end
   end
 end

data/lib/packwerk/const_node_inspector.rb

@@ -1,20 +1,24 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-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.constant?(node)
       parent = ancestors.first
       return nil unless root_constant?(parent)
 
       if parent && constant_in_module_or_class_definition?(node, parent: parent)
-        fully_qualify_constant(node, ancestors: ancestors)
+        fully_qualify_constant(ancestors)
       else
         begin
           Node.constant_name(node)
@@ -28,27 +32,22 @@ module Packwerk
 
     # 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:)
       parent_name = Node.module_name_from_definition(parent)
       parent_name && parent_name == Node.constant_name(node)
     end
 
-    def fully_qualify_constant(node, ancestors:)
+    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
-      name = Node.parent_module_name(ancestors: ancestors)
-      name ||= generate_qualified_constant(node, ancestors)
-      "::" + name
-    end
-
-    def generate_qualified_constant(node, ancestors:)
-      namespace_path = Node.enclosing_namespace_path(node, ancestors: ancestors)
-      constant_name = Node.constant_name(node)
-      namespace_path.push(constant_name).join("::")
+      "::" + Node.parent_module_name(ancestors: ancestors)
     end
   end
 end

data/lib/packwerk/constant_discovery.rb

@@ -1,6 +1,8 @@
 # typed: true
 # frozen_string_literal: true
 
+require "constant_resolver"
+
 module Packwerk
   # Get information about (partially qualified) constants without loading the application code.
   # Information gathered: Fully qualified name, path to file containing the definition, package,

data/lib/packwerk/constant_name_inspector.rb

@@ -2,7 +2,6 @@
 # frozen_string_literal: true
 
 require "ast"
-require "sorbet-runtime"
 
 module Packwerk
   # An interface describing some object that can extract a constant name from an AST node

data/lib/packwerk/dependency_checker.rb

@@ -1,31 +1,26 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-require "packwerk/violation_type"
-require "packwerk/checker"
-
 module Packwerk
   class DependencyChecker
+    extend T::Sig
     include Checker
 
+    sig { override.returns(ViolationType) }
     def violation_type
       ViolationType::Dependency
     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)
-      true
+    sig do
+      override
+        .params(reference: Packwerk::Reference)
+        .returns(T::Boolean)
     end
-
-    def message_for(reference)
-      "Dependency violation: #{reference.constant.name} belongs to '#{reference.constant.package}', but " \
-        "'#{reference.source_package}' does not specify a dependency on " \
-        "'#{reference.constant.package}'.\n" \
-        "Are we missing an abstraction?\n" \
-        "Is the code making the reference, and the referenced constant, in the right packages?\n"
+    def invalid_reference?(reference)
+      return false unless reference.source_package
+      return false unless reference.source_package.enforce_dependencies?
+      return false if reference.source_package.dependency?(reference.constant.package)
+      true
     end
   end
 end