packwerk 1.0.2 → 1.2.0

data/lib/packwerk/file_processor.rb

@@ -3,10 +3,6 @@
 
 require "ast/node"
 
-require "packwerk/node"
-require "packwerk/offense"
-require "packwerk/parsers"
-
 module Packwerk
   class FileProcessor
     class UnknownFileTypeResult < Offense

data/lib/packwerk/formatters/offenses_formatter.rb

@@ -0,0 +1,43 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Packwerk
+  module Formatters
+    class OffensesFormatter
+      include Packwerk::OffensesFormatter
+
+      extend T::Sig
+
+      sig { params(style: OutputStyle).void }
+      def initialize(style: OutputStyles::Plain.new)
+        @style = style
+      end
+
+      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
+
+      private
+
+      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 = Inflector.default.pluralize("offense", offenses.length)
+        "#{offenses.length} #{offenses_string} detected"
+      end
+    end
+  end
+end

data/lib/packwerk/formatters/progress_formatter.rb

@@ -3,13 +3,13 @@
 
 require "benchmark"
 
-require "packwerk/inflector"
-require "packwerk/output_styles"
-
 module Packwerk
   module Formatters
     class ProgressFormatter
-      def initialize(out, style: OutputStyles::Plain)
+      extend T::Sig
+
+      sig { params(out: T.any(StringIO, IO), style: OutputStyle).void }
+      def initialize(out, style: OutputStyles::Plain.new)
         @out = out
         @style = style
       end
@@ -41,6 +41,11 @@ module Packwerk
         @out.puts
         @out.puts("📦 Finished in #{execution_time.round(2)} seconds")
       end
+
+      def interrupted
+        @out.puts
+        @out.puts("Manually interrupted. Violations caught so far are listed below:")
+      end
     end
   end
 end

data/lib/packwerk/generators/configuration_file.rb

@@ -1,7 +1,6 @@
 # typed: true
 # frozen_string_literal: true
 
-require "packwerk/configuration"
 require "erb"
 
 module Packwerk

data/lib/packwerk/inflector.rb

@@ -2,8 +2,6 @@
 # frozen_string_literal: true
 
 require "active_support/inflector"
-require "packwerk/inflections/default"
-require "packwerk/inflections/custom"
 
 module Packwerk
   class Inflector

data/lib/packwerk/node.rb

@@ -1,6 +1,7 @@
 # typed: true
 # frozen_string_literal: true
 
+require "parser"
 require "parser/ast/node"
 
 module Packwerk
@@ -9,6 +10,8 @@ module Packwerk
     Location = Struct.new(:line, :column)
 
     class << self
+      extend T::Sig
+
       def class_or_module_name(class_or_module_node)
         case type_of(class_or_module_node)
         when CLASS, MODULE
@@ -27,7 +30,7 @@ module Packwerk
         case type_of(constant_node)
         when CONSTANT_ROOT_NAMESPACE
           ""
-        when CONSTANT, CONSTANT_ASSIGNMENT
+        when CONSTANT, CONSTANT_ASSIGNMENT, SELF
           # (const nil :Foo)
           #   "Foo"
           # (const (cbase) :Foo)
@@ -40,6 +43,8 @@ module Packwerk
           #   "::Foo = 1"
           # (casgn (lvar :a) :Foo (int 1))
           #   "a::Foo = 1"
+          # (casgn (self) :Foo (int 1))
+          #   "self::Foo = 1"
           namespace, name = constant_node.children
           if namespace
             [constant_name(namespace), name].join("::")
@@ -176,6 +181,7 @@ module Packwerk
         class_node.children[1]
       end
 
+      sig { params(ancestors: T::Array[AST::Node]).returns(String) }
       def parent_module_name(ancestors:)
         definitions = ancestors
           .select { |n| [CLASS, MODULE, CONSTANT_ASSIGNMENT, BLOCK].include?(type_of(n)) }
@@ -204,12 +210,13 @@ module Packwerk
       HASH_PAIR = :pair
       METHOD_CALL = :send
       MODULE = :module
+      SELF = :self
       STRING = :str
       SYMBOL = :sym
 
       private_constant(
         :BLOCK, :CLASS, :CONSTANT, :CONSTANT_ASSIGNMENT, :CONSTANT_ROOT_NAMESPACE, :HASH, :HASH_PAIR, :METHOD_CALL,
-        :MODULE, :STRING, :SYMBOL,
+        :MODULE, :SELF, :STRING, :SYMBOL,
       )
 
       def type_of(node)

data/lib/packwerk/node_processor.rb

@@ -1,11 +1,6 @@
 # typed: true
 # frozen_string_literal: true
 
-require "packwerk/node"
-require "packwerk/offense"
-require "packwerk/checker"
-require "packwerk/reference_lister"
-
 module Packwerk
   class NodeProcessor
     extend T::Sig
@@ -13,48 +8,36 @@ module Packwerk
     sig do
       params(
         reference_extractor: ReferenceExtractor,
-        reference_lister: ReferenceLister,
         filename: String,
         checkers: T::Array[Checker]
       ).void
     end
-    def initialize(reference_extractor:, reference_lister:, filename:, checkers:)
+    def initialize(reference_extractor:, filename:, checkers:)
       @reference_extractor = reference_extractor
-      @reference_lister = reference_lister
       @filename = filename
       @checkers = checkers
     end
 
-    def call(node, ancestors:)
-      if Node.method_call?(node) || Node.constant?(node)
-        reference = @reference_extractor.reference_from_node(node, ancestors: ancestors, file_path: @filename)
-        check_reference(reference, node) if reference
-      end
+    sig { params(node: Parser::AST::Node, ancestors: T::Array[Parser::AST::Node]).returns(T::Array[Offense]) }
+    def call(node, ancestors)
+      return [] unless Node.method_call?(node) || Node.constant?(node)
+      reference = @reference_extractor.reference_from_node(node, ancestors: ancestors, file_path: @filename)
+      check_reference(reference, node)
     end
 
     private
 
     def check_reference(reference, node)
-      return nil unless (message = failed_check(reference))
-
-      constant = reference.constant
-
-      Packwerk::Offense.new(
-        location: Node.location(node),
-        file: reference.relative_path,
-        message: <<~EOS
-          #{message}
-          Inference details: this is a reference to #{constant.name} which seems to be defined in #{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
-
-    def failed_check(reference)
-      failing_checker = @checkers.find do |checker|
-        checker.invalid_reference?(reference, @reference_lister)
+      return [] unless reference
+      @checkers.each_with_object([]) do |checker, violations|
+        next unless checker.invalid_reference?(reference)
+        offense = Packwerk::ReferenceOffense.new(
+          location: Node.location(node),
+          reference: reference,
+          violation_type: checker.violation_type
+        )
+        violations << offense
       end
-      failing_checker&.message_for(reference)
     end
   end
 end

data/lib/packwerk/node_processor_factory.rb

@@ -1,15 +1,11 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "packwerk/constant_name_inspector"
-require "packwerk/checker"
-
 module Packwerk
   class NodeProcessorFactory < T::Struct
     extend T::Sig
 
     const :root_path, String
-    const :reference_lister, ReferenceLister
     const :context_provider, Packwerk::ConstantDiscovery
     const :constant_name_inspectors, T::Array[ConstantNameInspector]
     const :checkers, T::Array[Checker]
@@ -18,7 +14,6 @@ module Packwerk
     def for(filename:, node:)
       ::Packwerk::NodeProcessor.new(
         reference_extractor: reference_extractor(node: node),
-        reference_lister: reference_lister,
         filename: filename,
         checkers: checkers,
       )

data/lib/packwerk/node_visitor.rb

@@ -1,8 +1,6 @@
 # typed: false
 # frozen_string_literal: true
 
-require "packwerk/node"
-
 module Packwerk
   class NodeVisitor
     def initialize(node_processor:)
@@ -10,8 +8,7 @@ module Packwerk
     end
 
     def visit(node, ancestors:, result:)
-      offense = @node_processor.call(node, ancestors: ancestors)
-      result << offense if offense
+      result.concat(@node_processor.call(node, ancestors))
 
       child_ancestors = [node] + ancestors
       Node.each_child(node) do |child|

data/lib/packwerk/offense.rb

@@ -2,9 +2,6 @@
 # frozen_string_literal: true
 
 require "parser/source/map"
-require "sorbet-runtime"
-
-require "packwerk/output_styles"
 
 module Packwerk
   class Offense
@@ -23,11 +20,8 @@ module Packwerk
       @message = message
     end
 
-    sig do
-      params(style: T.any(T.class_of(OutputStyles::Plain), T.class_of(OutputStyles::Coloured)))
-        .returns(String)
-    end
-    def to_s(style = OutputStyles::Plain)
+    sig { params(style: OutputStyle).returns(String) }
+    def to_s(style = OutputStyles::Plain.new)
       if location
         <<~EOS
           #{style.filename}#{file}#{style.reset}:#{location.line}:#{location.column}

data/lib/packwerk/offense_collection.rb

@@ -0,0 +1,84 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Packwerk
+  class OffenseCollection
+    extend T::Sig
+    extend T::Helpers
+
+    sig do
+      params(
+        root_path: String,
+        deprecated_references: T::Hash[Packwerk::Package, Packwerk::DeprecatedReferences]
+      ).void
+    end
+    def initialize(root_path, deprecated_references = {})
+      @root_path = root_path
+      @deprecated_references = T.let(deprecated_references, T::Hash[Packwerk::Package, Packwerk::DeprecatedReferences])
+      @new_violations = T.let([], T::Array[Packwerk::ReferenceOffense])
+      @errors = T.let([], T::Array[Packwerk::Offense])
+    end
+
+    sig { returns(T::Array[Packwerk::ReferenceOffense]) }
+    attr_reader :new_violations
+
+    sig { returns(T::Array[Packwerk::Offense]) }
+    attr_reader :errors
+
+    sig do
+      params(offense: Packwerk::Offense)
+        .returns(T::Boolean)
+    end
+    def listed?(offense)
+      return false unless offense.is_a?(ReferenceOffense)
+      reference = offense.reference
+      deprecated_references_for(reference.source_package).listed?(reference, violation_type: offense.violation_type)
+    end
+
+    sig do
+      params(offense: Packwerk::Offense).void
+    end
+    def add_offense(offense)
+      unless offense.is_a?(ReferenceOffense)
+        @errors << offense
+        return
+      end
+      deprecated_references = deprecated_references_for(offense.reference.source_package)
+      unless deprecated_references.add_entries(offense.reference, offense.violation_type)
+        new_violations << offense
+      end
+    end
+
+    sig { returns(T::Boolean) }
+    def stale_violations?
+      @deprecated_references.values.any?(&:stale_violations?)
+    end
+
+    sig { void }
+    def dump_deprecated_references_files
+      @deprecated_references.each do |_, deprecated_references_file|
+        deprecated_references_file.dump
+      end
+    end
+
+    sig { returns(T::Array[Packwerk::Offense]) }
+    def outstanding_offenses
+      errors + new_violations
+    end
+
+    private
+
+    sig { params(package: Packwerk::Package).returns(Packwerk::DeprecatedReferences) }
+    def deprecated_references_for(package)
+      @deprecated_references[package] ||= Packwerk::DeprecatedReferences.new(
+        package,
+        deprecated_references_file_for(package),
+      )
+    end
+
+    sig { params(package: Packwerk::Package).returns(String) }
+    def deprecated_references_file_for(package)
+      File.join(@root_path, package.name, "deprecated_references.yml")
+    end
+  end
+end

data/lib/packwerk/offenses_formatter.rb

@@ -0,0 +1,15 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Packwerk
+  module OffensesFormatter
+    extend T::Sig
+    extend T::Helpers
+
+    interface!
+
+    sig { abstract.params(offenses: T::Array[T.nilable(Offense)]).returns(String) }
+    def show_offenses(offenses)
+    end
+  end
+end

data/lib/packwerk/output_style.rb

@@ -0,0 +1,20 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Packwerk
+  module OutputStyle
+    extend T::Sig
+    extend T::Helpers
+
+    interface!
+
+    sig { abstract.returns(String) }
+    def reset; end
+
+    sig { abstract.returns(String) }
+    def filename; end
+
+    sig { abstract.returns(String) }
+    def error; end
+  end
+end

data/lib/packwerk/output_styles/coloured.rb

@@ -0,0 +1,29 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Packwerk
+  module OutputStyles
+    # See https://en.wikipedia.org/wiki/ANSI_escape_code#3/4_bit for ANSI escape colour codes
+    class Coloured
+      extend T::Sig
+      include OutputStyle
+
+      sig { override.returns(String) }
+      def reset
+        "\033[m"
+      end
+
+      sig { override.returns(String) }
+      def filename
+        # 36 is foreground cyan
+        "\033[36m"
+      end
+
+      sig { override.returns(String) }
+      def error
+        # 31 is foreground red
+        "\033[31m"
+      end
+    end
+  end
+end