packwerk 1.1.2 → 1.3.1

data/lib/packwerk/application_load_paths.rb

@@ -8,20 +8,15 @@ module Packwerk
     class << self
       extend T::Sig
 
-      sig { returns(T::Array[String]) }
-      def extract_relevant_paths
-        assert_application_booted
+      sig { params(root: String, environment: String).returns(T::Array[String]) }
+      def extract_relevant_paths(root, environment)
+        require_application(root, environment)
         all_paths = extract_application_autoload_paths
         relevant_paths = filter_relevant_paths(all_paths)
         assert_load_paths_present(relevant_paths)
         relative_path_strings(relevant_paths)
       end
 
-      sig { void }
-      def assert_application_booted
-        raise "The application needs to be booted to extract load paths" unless defined?(::Rails)
-      end
-
       sig { returns(T::Array[String]) }
       def extract_application_autoload_paths
         Rails.application.railties
@@ -54,6 +49,21 @@ module Packwerk
           .uniq
       end
 
+      private
+
+      sig { params(root: String, environment: String).void }
+      def require_application(root, environment)
+        environment_file = "#{root}/config/environment"
+
+        if File.file?("#{environment_file}.rb")
+          ENV["RAILS_ENV"] ||= environment
+
+          require environment_file
+        else
+          raise "A Rails application could not be found in #{root}"
+        end
+      end
+
       sig { params(paths: T::Array[T.untyped]).void }
       def assert_load_paths_present(paths)
         if paths.empty?

data/lib/packwerk/application_validator.rb

@@ -1,4 +1,4 @@
-# typed: false
+# typed: true
 # frozen_string_literal: true
 
 require "active_support/inflector/inflections"
@@ -6,18 +6,14 @@ 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:)
+    def initialize(config_file_path:, configuration:, environment:)
       @config_file_path = config_file_path
       @configuration = configuration
+      @environment = environment
 
-      @application_load_paths = ApplicationLoadPaths.extract_relevant_paths
+      @application_load_paths = ApplicationLoadPaths.extract_relevant_paths(configuration.root_path, environment)
     end
 
     Result = Struct.new(:ok?, :error_value)
@@ -101,26 +97,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?
@@ -181,21 +177,9 @@ module Packwerk
       edges = package_set.flat_map do |package|
         package.dependencies.map { |dependency| [package, package_set.fetch(dependency)] }
       end
-      dependency_graph = Packwerk::Graph.new(*edges)
-
-      # Convert the cycle
-      #
-      #   [a, b, c]
-      #
-      # to the string
-      #
-      #   a -> b -> c -> a
-      #
-      cycle_strings = dependency_graph.cycles.map do |cycle|
-        cycle_strings = cycle.map(&:to_s)
-        cycle_strings << cycle.first.to_s
-        "\t- #{cycle_strings.join(' → ')}"
-      end
+      dependency_graph = Packwerk::Graph.new(*T.unsafe(edges))
+
+      cycle_strings = build_cycle_strings(dependency_graph.cycles)
 
       if dependency_graph.acyclic?
         Result.new(true)
@@ -284,6 +268,21 @@ module Packwerk
 
     private
 
+    # Convert the cycles:
+    #
+    #   [[a, b, c], [b, c]]
+    #
+    # to the string:
+    #
+    #   ["a -> b -> c -> a", "b -> c -> b"]
+    def build_cycle_strings(cycles)
+      cycles.map do |cycle|
+        cycle_strings = cycle.map(&:to_s)
+        cycle_strings << cycle.first.to_s
+        "\t- #{cycle_strings.join(" → ")}"
+      end
+    end
+
     def package_manifests_settings_for(setting)
       package_manifests.map { |f| [f, (YAML.load_file(File.join(f)) || {})[setting]] }
     end

data/lib/packwerk/association_inspector.rb

@@ -1,9 +1,6 @@
 # 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

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
@@ -14,10 +11,7 @@ module Packwerk
     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
+    sig { params(reference: Reference).returns(T::Boolean).abstract }
+    def invalid_reference?(reference); end
   end
 end

data/lib/packwerk/cli.rb

@@ -1,48 +1,35 @@
 # typed: true
 # frozen_string_literal: true
-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_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
-    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
+        environment: String,
+        style: Packwerk::OutputStyle,
+        offenses_formatter: T.nilable(Packwerk::OffensesFormatter)
       ).void
     end
-    def initialize(run_context: nil, configuration: nil, out: $stdout, err_out: $stderr, style: OutputStyles::Plain.new)
+    def initialize(
+      configuration: nil,
+      out: $stdout,
+      err_out: $stderr,
+      environment: "test",
+      style: OutputStyles::Plain.new,
+      offenses_formatter: nil
+    )
       @out = out
       @err_out = err_out
+      @environment = environment
       @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) }
@@ -60,13 +47,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"
@@ -93,28 +80,12 @@ module Packwerk
     def init
       @out.puts("📦 Initializing Packwerk...")
 
-      application_validation = Packwerk::Generators::ApplicationValidation.generate(
-        for_rails_app: rails_app?,
-        root: @configuration.root_path,
-        out: @out
-      )
-
-      if application_validation
-        if rails_app?
-          # To run in the same space as the Rails process,
-          # in order to fetch load paths for the configuration generator
-          exec("bin/packwerk", "generate_configs")
-        else
-          generate_configurations = generate_configs
-        end
-      end
-
-      application_validation && generate_configurations
+      generate_configs
     end
 
     def generate_configs
       configuration_file = Packwerk::Generators::ConfigurationFile.generate(
-        load_paths: Packwerk::ApplicationLoadPaths.extract_relevant_paths,
+        load_paths: Packwerk::ApplicationLoadPaths.extract_relevant_paths(@configuration.root_path, @environment),
         root: @configuration.root_path,
         out: @out
       )
@@ -143,54 +114,10 @@ module Packwerk
 
     def update(paths)
       warn("`packwerk update` is deprecated in favor of `packwerk update-deprecations`.")
-      update_deprecations(paths)
+      output_result(parse_run(paths).update_deprecations)
     end
 
-    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)
-      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
-
-      @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
+    def output_result(result)
       @out.puts
       @out.puts(result.message)
       result.status
@@ -204,14 +131,11 @@ module Packwerk
     end
 
     def validate(_paths)
-      warn("`packwerk validate` should be run within the application. "\
-        "Generate the bin script using `packwerk init` and"\
-        " use `bin/packwerk validate` instead.") unless defined?(::Rails)
-
       @progress_formatter.started_validation do
         checker = Packwerk::ApplicationValidator.new(
           config_file_path: @configuration.config_path,
-          configuration: @configuration
+          configuration: @configuration,
+          environment: @environment,
         )
         result = checker.check_all
 
@@ -231,17 +155,13 @@ module Packwerk
       end
     end
 
-    sig { returns(T::Boolean) }
-    def rails_app?
-      if File.exist?("config/application.rb") && File.exist?("bin/rails")
-        File.foreach("Gemfile").any? { |line| line.match?(/['"]rails['"]/) }
-      else
-        false
-      end
-    end
-
-    def offenses_formatter
-      @offenses_formatter ||= Formatters::OffensesFormatter.new(style: @style)
+    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

@@ -47,8 +47,13 @@ module Packwerk
       @custom_associations = configs["custom_associations"] || []
       @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,8 +1,6 @@
 # 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

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,9 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "packwerk/violation_type"
-require "packwerk/checker"
-
 module Packwerk
   class DependencyChecker
     extend T::Sig
@@ -16,24 +13,14 @@ module Packwerk
 
     sig do
       override
-        .params(reference: Packwerk::Reference, reference_lister: Packwerk::ReferenceLister)
+        .params(reference: Packwerk::Reference)
         .returns(T::Boolean)
     end
-    def invalid_reference?(reference, reference_lister)
+    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)
-      return false if reference_lister.listed?(reference, violation_type: violation_type)
       true
     end
-
-    sig { override.params(reference: Packwerk::Reference).returns(String) }
-    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"
-    end
   end
 end