packwerk 1.1.3 → 1.2.0

data/lib/packwerk/parse_run.rb

@@ -0,0 +1,104 @@
+# typed: true
+# frozen_string_literal: true
+
+require "benchmark"
+require "parallel"
+
+module Packwerk
+  class ParseRun
+    extend T::Sig
+
+    def initialize(
+      files:,
+      configuration:,
+      progress_formatter: Formatters::ProgressFormatter.new(StringIO.new),
+      offenses_formatter: Formatters::OffensesFormatter.new
+    )
+      @configuration = configuration
+      @progress_formatter = progress_formatter
+      @offenses_formatter = offenses_formatter
+      @files = files
+    end
+
+    def detect_stale_violations
+      offense_collection = find_offenses
+
+      result_status = !offense_collection.stale_violations?
+      message = if result_status
+        "No stale violations detected"
+      else
+        "There were stale violations found, please run `packwerk update-deprecations`"
+      end
+
+      Result.new(message: message, status: result_status)
+    end
+
+    def update_deprecations
+      offense_collection = find_offenses
+      offense_collection.dump_deprecated_references_files
+
+      message = <<~EOS
+        #{@offenses_formatter.show_offenses(offense_collection.errors)}
+        ✅ `deprecated_references.yml` has been updated.
+      EOS
+
+      Result.new(message: message, status: offense_collection.errors.empty?)
+    end
+
+    def check
+      offense_collection = find_offenses(show_errors: true)
+      message = @offenses_formatter.show_offenses(offense_collection.outstanding_offenses)
+      Result.new(message: message, status: offense_collection.outstanding_offenses.empty?)
+    end
+
+    private
+
+    def find_offenses(show_errors: false)
+      offense_collection = OffenseCollection.new(@configuration.root_path)
+      @progress_formatter.started(@files)
+
+      run_context = Packwerk::RunContext.from_configuration(@configuration)
+      all_offenses = T.let([], T.untyped)
+
+      process_file = -> (path) do
+        run_context.process_file(file: path).tap do |offenses|
+          failed = show_errors && offenses.any? { |offense| !offense_collection.listed?(offense) }
+          update_progress(failed: failed)
+        end
+      end
+
+      execution_time = Benchmark.realtime do
+        all_offenses = if @configuration.parallel?
+          Parallel.flat_map(@files, &process_file)
+        else
+          serial_find_offenses(&process_file)
+        end
+      end
+
+      @progress_formatter.finished(execution_time)
+
+      all_offenses.each { |offense| offense_collection.add_offense(offense) }
+      offense_collection
+    end
+
+    def serial_find_offenses
+      all_offenses = T.let([], T.untyped)
+      @files.each do |path|
+        offenses = yield path
+        all_offenses.concat(offenses)
+      end
+      all_offenses
+    rescue Interrupt
+      @progress_formatter.interrupted
+      all_offenses
+    end
+
+    def update_progress(failed: false)
+      if failed
+        @progress_formatter.mark_as_failed
+      else
+        @progress_formatter.mark_as_inspected
+      end
+    end
+  end
+end

data/lib/packwerk/parsed_constant_definitions.rb

@@ -3,8 +3,6 @@
 
 require "ast/node"
 
-require "packwerk/node"
-
 module Packwerk
   class ParsedConstantDefinitions
     def initialize(root_node:)

data/lib/packwerk/parsers.rb

@@ -1,8 +1,6 @@
 # typed: true
 # frozen_string_literal: true
 
-require "packwerk/offense"
-
 module Packwerk
   module Parsers
     autoload :Erb, "packwerk/parsers/erb"

data/lib/packwerk/parsers/erb.rb

@@ -6,8 +6,6 @@ require "better_html"
 require "better_html/parser"
 require "parser/source/buffer"
 
-require "packwerk/parsers"
-
 module Packwerk
   module Parsers
     class Erb

data/lib/packwerk/parsers/factory.rb

@@ -3,8 +3,6 @@
 
 require "singleton"
 
-require "packwerk/parsers"
-
 module Packwerk
   module Parsers
     class Factory

data/lib/packwerk/privacy_checker.rb

@@ -1,9 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "packwerk/violation_type"
-require "packwerk/checker"
-
 module Packwerk
   class PrivacyChecker
     extend T::Sig
@@ -16,10 +13,10 @@ 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 if reference.constant.public?
 
       privacy_option = reference.constant.package.enforce_privacy
@@ -28,19 +25,9 @@ module Packwerk
       return false unless privacy_option == true ||
         explicitly_private_constant?(reference.constant, explicitly_private_constants: privacy_option)
 
-      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)
-      source_desc = reference.source_package ? "'#{reference.source_package}'" : "here"
-      "Privacy violation: '#{reference.constant.name}' is private to '#{reference.constant.package}' but " \
-        "referenced from #{source_desc}.\n" \
-        "Is there a public entrypoint in '#{reference.constant.package.public_path}' that you can use instead?"
-    end
-
     private
 
     sig do

data/lib/packwerk/reference_extractor.rb

@@ -1,14 +1,6 @@
 # typed: true
 # frozen_string_literal: true
 
-require "sorbet-runtime"
-
-require "packwerk/constant_discovery"
-require "packwerk/constant_name_inspector"
-require "packwerk/node"
-require "packwerk/parsed_constant_definitions"
-require "packwerk/reference"
-
 module Packwerk
   # extracts a possible constant reference from a given AST node
   class ReferenceExtractor

data/lib/packwerk/reference_offense.rb

@@ -0,0 +1,49 @@
+# typed: true
+# frozen_string_literal: true
+
+module Packwerk
+  class ReferenceOffense < Offense
+    extend T::Sig
+    extend T::Helpers
+
+    attr_reader :reference, :violation_type
+
+    sig do
+      params(
+        reference: Packwerk::Reference,
+        violation_type: Packwerk::ViolationType,
+        location: T.nilable(Node::Location)
+      )
+        .void
+    end
+    def initialize(reference:, violation_type:, location: nil)
+      super(file: reference.relative_path, message: build_message(reference, violation_type), location: location)
+      @reference = reference
+      @violation_type = violation_type
+    end
+
+    private
+
+    def build_message(reference, violation_type)
+      violation_message = case violation_type
+      when ViolationType::Privacy
+        source_desc = reference.source_package ? "'#{reference.source_package}'" : "here"
+        "Privacy violation: '#{reference.constant.name}' is private to '#{reference.constant.package}' but " \
+        "referenced from #{source_desc}.\n" \
+        "Is there a public entrypoint in '#{reference.constant.package.public_path}' that you can use instead?"
+      when ViolationType::Dependency
+        "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
+
+      <<~EOS
+        #{violation_message}
+        Inference details: this is a reference to #{reference.constant.name} which seems to be defined in #{reference.constant.location}.
+        To receive help interpreting or resolving this error message, see: https://github.com/Shopify/packwerk/blob/main/TROUBLESHOOT.md#Troubleshooting-violations
+      EOS
+    end
+  end
+end

data/lib/packwerk/result.rb

@@ -0,0 +1,9 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Packwerk
+  class Result < T::Struct
+    prop :message, String
+    prop :status, T::Boolean
+  end
+end

data/lib/packwerk/run_context.rb

@@ -3,17 +3,6 @@
 
 require "constant_resolver"
 
-require "packwerk/association_inspector"
-require "packwerk/constant_discovery"
-require "packwerk/const_node_inspector"
-require "packwerk/dependency_checker"
-require "packwerk/file_processor"
-require "packwerk/inflector"
-require "packwerk/package_set"
-require "packwerk/privacy_checker"
-require "packwerk/reference_extractor"
-require "packwerk/node_processor_factory"
-
 module Packwerk
   class RunContext
     extend T::Sig
@@ -27,23 +16,20 @@ module Packwerk
       :checker_classes,
     )
 
-    attr_accessor :reference_lister
-
     DEFAULT_CHECKERS = [
       ::Packwerk::DependencyChecker,
       ::Packwerk::PrivacyChecker,
     ]
 
     class << self
-      def from_configuration(configuration, reference_lister:)
+      def from_configuration(configuration)
         inflector = ::Packwerk::Inflector.from_file(configuration.inflections_file)
         new(
           root_path: configuration.root_path,
           load_paths: configuration.load_paths,
           package_paths: configuration.package_paths,
           inflector: inflector,
-          custom_associations: configuration.custom_associations,
-          reference_lister: reference_lister,
+          custom_associations: configuration.custom_associations
         )
       end
     end
@@ -54,8 +40,7 @@ module Packwerk
       package_paths: nil,
       inflector: nil,
       custom_associations: [],
-      checker_classes: DEFAULT_CHECKERS,
-      reference_lister:
+      checker_classes: DEFAULT_CHECKERS
     )
       @root_path = root_path
       @load_paths = load_paths
@@ -63,7 +48,6 @@ module Packwerk
       @inflector = inflector
       @custom_associations = custom_associations
       @checker_classes = checker_classes
-      @reference_lister = reference_lister
     end
 
     sig { params(file: String).returns(T::Array[T.nilable(::Packwerk::Offense)]) }
@@ -84,8 +68,7 @@ module Packwerk
         context_provider: context_provider,
         checkers: checkers,
         root_path: root_path,
-        constant_name_inspectors: constant_name_inspectors,
-        reference_lister: reference_lister
+        constant_name_inspectors: constant_name_inspectors
       )
     end
 

data/lib/packwerk/sanity_checker.rb

@@ -1,8 +1,6 @@
 # typed: false
 # frozen_string_literal: true
 
-require "packwerk/application_validator"
-
 module Packwerk
   # To do: This alias and file should be removed as it is deprecated
   warn("DEPRECATION WARNING: Packwerk::SanityChecker is deprecated, use Packwerk::ApplicationValidator instead.")

data/lib/packwerk/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Packwerk
-  VERSION = "1.1.3"
+  VERSION = "1.2.0"
 end

data/lib/packwerk/violation_type.rb

@@ -1,8 +1,6 @@
 # typed: true
 # frozen_string_literal: true
 
-require "sorbet-runtime"
-
 module Packwerk
   class ViolationType < T::Enum
     enums do

data/packwerk.gemspec

@@ -42,6 +42,7 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency("activesupport", ">= 5.2")
   spec.add_dependency("constant_resolver")
+  spec.add_dependency("parallel")
   spec.add_dependency("sorbet-runtime")
 
   spec.add_development_dependency("bundler")

data/service.yml

@@ -1,6 +1,3 @@
-# https://services.shopify.io/services/packwerk/production
-org_line: Kernel
-owners: Shopify/core-stewardship
 classification: library
 slack_channels:
-  - core-stewardship
+- core-stewardship

data/sorbet/rbi/gems/parallel@1.20.1.rbi

@@ -4,5 +4,114 @@
 
 # typed: true
 
-# THIS IS AN EMPTY RBI FILE.
-# see https://github.com/Shopify/tapioca/blob/master/README.md#manual-gem-requires
+module Parallel
+  extend(::Parallel::ProcessorCount)
+
+  class << self
+    def all?(*args, &block); end
+    def any?(*args, &block); end
+    def each(array, options = T.unsafe(nil), &block); end
+    def each_with_index(array, options = T.unsafe(nil), &block); end
+    def flat_map(*args, &block); end
+    def in_processes(options = T.unsafe(nil), &block); end
+    def in_threads(options = T.unsafe(nil)); end
+    def map(source, options = T.unsafe(nil), &block); end
+    def map_with_index(array, options = T.unsafe(nil), &block); end
+    def worker_number; end
+    def worker_number=(worker_num); end
+
+    private
+
+    def add_progress_bar!(job_factory, options); end
+    def call_with_index(item, index, options, &block); end
+    def create_workers(job_factory, options, &block); end
+    def extract_count_from_options(options); end
+    def process_incoming_jobs(read, write, job_factory, options, &block); end
+    def replace_worker(job_factory, workers, i, options, blk); end
+    def with_instrumentation(item, index, options); end
+    def work_direct(job_factory, options, &block); end
+    def work_in_processes(job_factory, options, &blk); end
+    def work_in_threads(job_factory, options, &block); end
+    def worker(job_factory, options, &block); end
+  end
+end
+
+class Parallel::Break < ::StandardError
+  def initialize(value = T.unsafe(nil)); end
+
+  def value; end
+end
+
+class Parallel::DeadWorker < ::StandardError
+end
+
+class Parallel::ExceptionWrapper
+  def initialize(exception); end
+
+  def exception; end
+end
+
+class Parallel::JobFactory
+  def initialize(source, mutex); end
+
+  def next; end
+  def pack(item, index); end
+  def size; end
+  def unpack(data); end
+
+  private
+
+  def producer?; end
+  def queue_wrapper(array); end
+end
+
+class Parallel::Kill < ::Parallel::Break
+end
+
+module Parallel::ProcessorCount
+  def physical_processor_count; end
+  def processor_count; end
+end
+
+Parallel::Stop = T.let(T.unsafe(nil), Object)
+
+class Parallel::UndumpableException < ::StandardError
+  def initialize(original); end
+
+  def backtrace; end
+end
+
+class Parallel::UserInterruptHandler
+  class << self
+    def kill(thing); end
+    def kill_on_ctrl_c(pids, options); end
+
+    private
+
+    def restore_interrupt(old, signal); end
+    def trap_interrupt(signal); end
+  end
+end
+
+Parallel::UserInterruptHandler::INTERRUPT_SIGNAL = T.let(T.unsafe(nil), Symbol)
+
+Parallel::VERSION = T.let(T.unsafe(nil), String)
+
+Parallel::Version = T.let(T.unsafe(nil), String)
+
+class Parallel::Worker
+  def initialize(read, write, pid); end
+
+  def close_pipes; end
+  def pid; end
+  def read; end
+  def stop; end
+  def thread; end
+  def thread=(_arg0); end
+  def work(data); end
+  def write; end
+
+  private
+
+  def wait; end
+end