packwerk 2.2.0 → 2.2.2

data/lib/packwerk/deprecated_references.rb

@@ -7,7 +7,7 @@ module Packwerk
   class DeprecatedReferences
     extend T::Sig
 
-    ENTRIES_TYPE = T.type_alias do
+    EntriesType = T.type_alias do
       T::Hash[String, T.untyped]
     end
 
@@ -15,8 +15,8 @@ module Packwerk
     def initialize(package, filepath)
       @package = package
       @filepath = filepath
-      @new_entries = T.let({}, ENTRIES_TYPE)
-      @deprecated_references = T.let(nil, T.nilable(ENTRIES_TYPE))
+      @new_entries = T.let({}, EntriesType)
+      @deprecated_references = T.let(nil, T.nilable(EntriesType))
     end
 
     sig do
@@ -36,28 +36,43 @@ module Packwerk
     sig { params(reference: Packwerk::Reference, violation_type: Packwerk::ViolationType).returns(T::Boolean) }
     def add_entries(reference, violation_type)
       package_violations = @new_entries.fetch(reference.constant.package.name, {})
-      entries_for_file = package_violations[reference.constant.name] ||= {}
+      entries_for_constant = package_violations[reference.constant.name] ||= {}
 
-      entries_for_file["violations"] ||= []
-      entries_for_file["violations"] << violation_type.serialize
+      entries_for_constant["violations"] ||= []
+      entries_for_constant["violations"] << violation_type.serialize
 
-      entries_for_file["files"] ||= []
-      entries_for_file["files"] << reference.relative_path.to_s
+      entries_for_constant["files"] ||= []
+      entries_for_constant["files"] << reference.relative_path.to_s
 
       @new_entries[reference.constant.package.name] = package_violations
       listed?(reference, violation_type: violation_type)
     end
 
-    sig { returns(T::Boolean) }
-    def stale_violations?
+    sig { params(for_files: T::Set[String]).returns(T::Boolean) }
+    def stale_violations?(for_files)
       prepare_entries_for_dump
+
       deprecated_references.any? do |package, package_violations|
-        package_violations.any? do |constant_name, entries_for_file|
+        package_violations_for_files = {}
+        package_violations.each do |constant_name, entries_for_constant|
+          entries_for_files = for_files & entries_for_constant["files"]
+          next if entries_for_files.none?
+
+          package_violations_for_files[constant_name] = {
+            "violations" => entries_for_constant["violations"],
+            "files" => entries_for_files.to_a,
+          }
+        end
+
+        return true if package_violations_for_files.empty?
+
+        package_violations_for_files.any? do |constant_name, entries_for_constant|
           new_entries_violation_types = @new_entries.dig(package, constant_name, "violations")
           return true if new_entries_violation_types.nil?
-          if entries_for_file["violations"].all? { |type| new_entries_violation_types.include?(type) }
+
+          if entries_for_constant["violations"].all? { |type| new_entries_violation_types.include?(type) }
             stale_violations =
-              entries_for_file["files"] - Array(@new_entries.dig(package, constant_name, "files"))
+              entries_for_constant["files"] - Array(@new_entries.dig(package, constant_name, "files"))
             stale_violations.any?
           else
             return true
@@ -69,7 +84,7 @@ module Packwerk
     sig { void }
     def dump
       if @new_entries.empty?
-        File.delete(@filepath) if File.exist?(@filepath)
+        delete_if_exists
       else
         prepare_entries_for_dump
         message = <<~MESSAGE
@@ -87,14 +102,19 @@ module Packwerk
       end
     end
 
+    sig { void }
+    def delete_if_exists
+      File.delete(@filepath) if File.exist?(@filepath)
+    end
+
     private
 
-    sig { returns(ENTRIES_TYPE) }
+    sig { returns(EntriesType) }
     def prepare_entries_for_dump
       @new_entries.each do |package_name, package_violations|
-        package_violations.each do |_, entries_for_file|
-          entries_for_file["violations"].sort!.uniq!
-          entries_for_file["files"].sort!.uniq!
+        package_violations.each do |_, entries_for_constant|
+          entries_for_constant["violations"].sort!.uniq!
+          entries_for_constant["files"].sort!.uniq!
         end
         @new_entries[package_name] = package_violations.sort.to_h
       end
@@ -102,7 +122,7 @@ module Packwerk
       @new_entries = @new_entries.sort.to_h
     end
 
-    sig { returns(ENTRIES_TYPE) }
+    sig { returns(EntriesType) }
     def deprecated_references
       @deprecated_references ||= if File.exist?(@filepath)
         load_yaml(@filepath)
@@ -111,7 +131,7 @@ module Packwerk
       end
     end
 
-    sig { params(filepath: String).returns(ENTRIES_TYPE) }
+    sig { params(filepath: String).returns(EntriesType) }
     def load_yaml(filepath)
       YAML.load_file(filepath) || {}
     rescue Psych::Exception

data/lib/packwerk/file_processor.rb

@@ -35,19 +35,19 @@ module Packwerk
     end
 
     sig do
-      params(absolute_file: String).returns(ProcessedFile)
+      params(relative_file: String).returns(ProcessedFile)
     end
-    def call(absolute_file)
-      parser = parser_for(absolute_file)
+    def call(relative_file)
+      parser = parser_for(relative_file)
       if parser.nil?
-        return ProcessedFile.new(offenses: [UnknownFileTypeResult.new(file: absolute_file)])
+        return ProcessedFile.new(offenses: [UnknownFileTypeResult.new(file: relative_file)])
       end
 
-      unresolved_references = @cache.with_cache(absolute_file) do
-        node = parse_into_ast(absolute_file, parser)
+      unresolved_references = @cache.with_cache(relative_file) do
+        node = parse_into_ast(relative_file, parser)
         return ProcessedFile.new unless node
 
-        references_from_ast(node, absolute_file)
+        references_from_ast(node, relative_file)
       end
 
       ProcessedFile.new(unresolved_references: unresolved_references)
@@ -58,22 +58,22 @@ module Packwerk
     private
 
     sig do
-      params(node: Parser::AST::Node, absolute_file: String).returns(T::Array[UnresolvedReference])
+      params(node: Parser::AST::Node, relative_file: String).returns(T::Array[UnresolvedReference])
     end
-    def references_from_ast(node, absolute_file)
+    def references_from_ast(node, relative_file)
       references = []
 
-      node_processor = @node_processor_factory.for(absolute_file: absolute_file, node: node)
+      node_processor = @node_processor_factory.for(relative_file: relative_file, node: node)
       node_visitor = Packwerk::NodeVisitor.new(node_processor: node_processor)
       node_visitor.visit(node, ancestors: [], result: references)
 
       references
     end
 
-    sig { params(absolute_file: String, parser: Parsers::ParserInterface).returns(T.untyped) }
-    def parse_into_ast(absolute_file, parser)
-      File.open(absolute_file, "r", nil, external_encoding: Encoding::UTF_8) do |file|
-        parser.call(io: file, file_path: absolute_file)
+    sig { params(relative_file: String, parser: Parsers::ParserInterface).returns(T.untyped) }
+    def parse_into_ast(relative_file, parser)
+      File.open(relative_file, "r", nil, external_encoding: Encoding::UTF_8) do |file|
+        parser.call(io: file, file_path: relative_file)
       end
     end
 

data/lib/packwerk/files_for_processing.rb

@@ -5,7 +5,7 @@ module Packwerk
   class FilesForProcessing
     extend T::Sig
 
-    AbsoluteFileSet = T.type_alias { T::Set[String] }
+    RelativeFileSet = T.type_alias { T::Set[String] }
 
     class << self
       extend T::Sig
@@ -15,7 +15,7 @@ module Packwerk
           relative_file_paths: T::Array[String],
           configuration: Configuration,
           ignore_nested_packages: T::Boolean
-        ).returns(AbsoluteFileSet)
+        ).returns(RelativeFileSet)
       end
       def fetch(relative_file_paths:, configuration:, ignore_nested_packages: false)
         new(relative_file_paths, configuration, ignore_nested_packages).files
@@ -33,15 +33,15 @@ module Packwerk
       @relative_file_paths = relative_file_paths
       @configuration = configuration
       @ignore_nested_packages = ignore_nested_packages
-      @custom_files = T.let(nil, T.nilable(AbsoluteFileSet))
+      @custom_files = T.let(nil, T.nilable(RelativeFileSet))
     end
 
-    sig { returns(AbsoluteFileSet) }
+    sig { returns(RelativeFileSet) }
     def files
       include_files = if custom_files.empty?
         configured_included_files
       else
-        custom_files
+        configured_included_files & custom_files
       end
 
       include_files - configured_excluded_files
@@ -49,59 +49,55 @@ module Packwerk
 
     private
 
-    sig { returns(AbsoluteFileSet) }
+    sig { returns(RelativeFileSet) }
     def custom_files
       @custom_files ||= Set.new(
         @relative_file_paths.map do |relative_file_path|
-          absolute_file_path = File.expand_path(relative_file_path, @configuration.root_path)
-          if File.file?(absolute_file_path)
-            absolute_file_path
+          if File.file?(relative_file_path)
+            relative_file_path
           else
-            custom_included_files(absolute_file_path)
+            custom_included_files(relative_file_path)
           end
         end
       ).flatten
     end
 
-    sig { params(absolute_file_path: String).returns(AbsoluteFileSet) }
-    def custom_included_files(absolute_file_path)
+    sig { params(relative_file_path: String).returns(RelativeFileSet) }
+    def custom_included_files(relative_file_path)
       # Note, assuming include globs are always relative paths
-      absolute_includes = @configuration.include.map do |glob|
-        File.expand_path(glob, @configuration.root_path)
-      end
-
-      absolute_files = Dir.glob([File.join(absolute_file_path, "**", "*")]).select do |absolute_path|
-        absolute_includes.any? do |pattern|
-          File.fnmatch?(pattern, absolute_path, File::FNM_EXTGLOB)
+      relative_includes = @configuration.include
+      relative_files = Dir.glob([File.join(relative_file_path, "**", "*")]).select do |relative_path|
+        relative_includes.any? do |pattern|
+          File.fnmatch?(pattern, relative_path, File::FNM_EXTGLOB)
         end
       end
 
       if @ignore_nested_packages
-        nested_packages_absolute_file_paths = Dir.glob(File.join(absolute_file_path, "*", "**", "package.yml"))
-        nested_packages_absolute_globs = nested_packages_absolute_file_paths.map do |npp|
+        nested_packages_relative_file_paths = Dir.glob(File.join(relative_file_path, "*", "**", "package.yml"))
+        nested_packages_relative_globs = nested_packages_relative_file_paths.map do |npp|
           npp.gsub("package.yml", "**/*")
         end
-        nested_packages_absolute_globs.each do |absolute_glob|
-          absolute_files -= Dir.glob(absolute_glob)
+        nested_packages_relative_globs.each do |relative_glob|
+          relative_files -= Dir.glob(relative_glob)
         end
       end
 
-      Set.new(absolute_files)
+      Set.new(relative_files)
     end
 
-    sig { returns(AbsoluteFileSet) }
+    sig { returns(RelativeFileSet) }
     def configured_included_files
-      absolute_files_for_globs(@configuration.include)
+      relative_files_for_globs(@configuration.include)
     end
 
-    sig { returns(AbsoluteFileSet) }
+    sig { returns(RelativeFileSet) }
     def configured_excluded_files
-      absolute_files_for_globs(@configuration.exclude)
+      relative_files_for_globs(@configuration.exclude)
     end
 
-    sig { params(relative_globs: T::Array[String]).returns(AbsoluteFileSet) }
-    def absolute_files_for_globs(relative_globs)
-      Set.new(relative_globs.flat_map { |glob| Dir[File.expand_path(glob, @configuration.root_path)] })
+    sig { params(relative_globs: T::Array[String]).returns(RelativeFileSet) }
+    def relative_files_for_globs(relative_globs)
+      Set.new(relative_globs.flat_map { |glob| Dir[glob] })
     end
   end
 end

data/lib/packwerk/formatters/offenses_formatter.rb

@@ -23,9 +23,9 @@ module Packwerk
         EOS
       end
 
-      sig { override.params(offense_collection: Packwerk::OffenseCollection).returns(String) }
-      def show_stale_violations(offense_collection)
-        if offense_collection.stale_violations?
+      sig { override.params(offense_collection: Packwerk::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-deprecations`"
         else
           "No stale violations detected"

data/lib/packwerk/formatters/progress_formatter.rb

@@ -20,10 +20,10 @@ module Packwerk
         @out.puts("📦 Packwerk is inspecting #{files_size} #{files_string}")
       end
 
-      def started_validation
+      def started_validation(&block)
         @out.puts("📦 Packwerk is running validation...")
 
-        execution_time = Benchmark.realtime { yield }
+        execution_time = Benchmark.realtime(&block)
         finished(execution_time)
 
         @out.puts("✅ Packages are valid. Use `packwerk check` to run static checks.")

data/lib/packwerk/node.rb

@@ -1,301 +1,8 @@
 # typed: true
 # frozen_string_literal: true
 
-require "parser"
-require "parser/ast/node"
-
 module Packwerk
-  # Convenience methods for working with Parser::AST::Node nodes.
-  module Node
-    class TypeError < ArgumentError; end
+  class Node
     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
-          # (class (const nil :Foo) (const nil :Bar) (nil))
-          #   "class Foo < Bar; end"
-          # (module (const nil :Foo) (nil))
-          #   "module Foo; end"
-          identifier = class_or_module_node.children[0]
-          constant_name(identifier)
-        else
-          raise TypeError
-        end
-      end
-
-      def constant_name(constant_node)
-        case type_of(constant_node)
-        when CONSTANT_ROOT_NAMESPACE
-          ""
-        when CONSTANT, CONSTANT_ASSIGNMENT, SELF
-          # (const nil :Foo)
-          #   "Foo"
-          # (const (cbase) :Foo)
-          #   "::Foo"
-          # (const (lvar :a) :Foo)
-          #   "a::Foo"
-          # (casgn nil :Foo (int 1))
-          #   "Foo = 1"
-          # (casgn (cbase) :Foo (int 1))
-          #   "::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("::")
-          else
-            name.to_s
-          end
-        else
-          raise TypeError
-        end
-      end
-
-      def each_child(node)
-        if block_given?
-          node.children.each do |child|
-            yield child if child.is_a?(Parser::AST::Node)
-          end
-        else
-          enum_for(:each_child, node)
-        end
-      end
-
-      def enclosing_namespace_path(starting_node, ancestors:)
-        ancestors.select { |n| [CLASS, MODULE].include?(type_of(n)) }
-          .each_with_object([]) do |node, namespace|
-          # when evaluating `class Child < Parent`, the const node for `Parent` is a child of the class
-          # node, so it'll be an ancestor, but `Parent` is not evaluated in the namespace of `Child`, so
-          # we need to skip it here
-          next if type_of(node) == CLASS && parent_class(node) == starting_node
-
-          namespace.prepend(class_or_module_name(node))
-        end
-      end
-
-      def literal_value(string_or_symbol_node)
-        case type_of(string_or_symbol_node)
-        when STRING, SYMBOL
-          # (str "foo")
-          #   "'foo'"
-          # (sym :foo)
-          #   ":foo"
-          string_or_symbol_node.children[0]
-        else
-          raise TypeError
-        end
-      end
-
-      def location(node)
-        location = node.location
-        Location.new(location.line, location.column)
-      end
-
-      def constant?(node)
-        type_of(node) == CONSTANT
-      end
-
-      def constant_assignment?(node)
-        type_of(node) == CONSTANT_ASSIGNMENT
-      end
-
-      def class?(node)
-        type_of(node) == CLASS
-      end
-
-      def method_call?(node)
-        type_of(node) == METHOD_CALL
-      end
-
-      def hash?(node)
-        type_of(node) == HASH
-      end
-
-      def string?(node)
-        type_of(node) == STRING
-      end
-
-      def symbol?(node)
-        type_of(node) == SYMBOL
-      end
-
-      def method_arguments(method_call_node)
-        raise TypeError unless method_call?(method_call_node)
-
-        # (send (lvar :foo) :bar (int 1))
-        #   "foo.bar(1)"
-        method_call_node.children.slice(2..-1)
-      end
-
-      def method_name(method_call_node)
-        raise TypeError unless method_call?(method_call_node)
-
-        # (send (lvar :foo) :bar (int 1))
-        #   "foo.bar(1)"
-        method_call_node.children[1]
-      end
-
-      def module_name_from_definition(node)
-        case type_of(node)
-        when CLASS, MODULE
-          # "class My::Class; end"
-          # "module My::Module; end"
-          class_or_module_name(node)
-        when CONSTANT_ASSIGNMENT
-          # "My::Class = ..."
-          # "My::Module = ..."
-          rvalue = node.children.last
-
-          case type_of(rvalue)
-          when METHOD_CALL
-            # "Class.new"
-            # "Module.new"
-            constant_name(node) if module_creation?(rvalue)
-          when BLOCK
-            # "Class.new do end"
-            # "Module.new do end"
-            constant_name(node) if module_creation?(method_call_node(rvalue))
-          end
-        end
-      end
-
-      def name_location(node)
-        location = node.location
-
-        if location.respond_to?(:name)
-          name = location.name
-          Location.new(name.line, name.column)
-        end
-      end
-
-      def parent_class(class_node)
-        raise TypeError unless type_of(class_node) == CLASS
-
-        # (class (const nil :Foo) (const nil :Bar) (nil))
-        #   "class Foo < Bar; end"
-        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)) }
-
-        names = definitions.map do |definition|
-          name_part_from_definition(definition)
-        end.compact
-
-        names.empty? ? "Object" : names.reverse.join("::")
-      end
-
-      def value_from_hash(hash_node, key)
-        raise TypeError unless hash?(hash_node)
-        pair = hash_pairs(hash_node).detect { |pair_node| literal_value(hash_pair_key(pair_node)) == key }
-        hash_pair_value(pair) if pair
-      end
-
-      private
-
-      BLOCK = :block
-      CLASS = :class
-      CONSTANT = :const
-      CONSTANT_ASSIGNMENT = :casgn
-      CONSTANT_ROOT_NAMESPACE = :cbase
-      HASH = :hash
-      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, :SELF, :STRING, :SYMBOL,
-      )
-
-      def type_of(node)
-        node.type
-      end
-
-      def hash_pair_key(hash_pair_node)
-        raise TypeError unless type_of(hash_pair_node) == HASH_PAIR
-
-        # (pair (int 1) (int 2))
-        #   "1 => 2"
-        # (pair (sym :answer) (int 42))
-        #   "answer: 42"
-        hash_pair_node.children[0]
-      end
-
-      def hash_pair_value(hash_pair_node)
-        raise TypeError unless type_of(hash_pair_node) == HASH_PAIR
-
-        # (pair (int 1) (int 2))
-        #   "1 => 2"
-        # (pair (sym :answer) (int 42))
-        #   "answer: 42"
-        hash_pair_node.children[1]
-      end
-
-      def hash_pairs(hash_node)
-        raise TypeError unless hash?(hash_node)
-
-        # (hash (pair (int 1) (int 2)) (pair (int 3) (int 4)))
-        #   "{1 => 2, 3 => 4}"
-        hash_node.children.select { |n| type_of(n) == HASH_PAIR }
-      end
-
-      def method_call_node(block_node)
-        raise TypeError unless type_of(block_node) == BLOCK
-
-        # (block (send (lvar :foo) :bar) (args) (int 42))
-        #   "foo.bar do 42 end"
-        block_node.children[0]
-      end
-
-      def module_creation?(node)
-        # "Class.new"
-        # "Module.new"
-        method_call?(node) &&
-          receiver(node) &&
-          constant?(receiver(node)) &&
-          ["Class", "Module"].include?(constant_name(receiver(node))) &&
-          method_name(node) == :new
-      end
-
-      def name_from_block_definition(node)
-        if method_name(method_call_node(node)) == :class_eval
-          receiver = receiver(node)
-          constant_name(receiver) if receiver && constant?(receiver)
-        end
-      end
-
-      def name_part_from_definition(node)
-        case type_of(node)
-        when CLASS, MODULE, CONSTANT_ASSIGNMENT
-          module_name_from_definition(node)
-        when BLOCK
-          name_from_block_definition(node)
-        end
-      end
-
-      def receiver(method_call_or_block_node)
-        case type_of(method_call_or_block_node)
-        when METHOD_CALL
-          method_call_or_block_node.children[0]
-        when BLOCK
-          receiver(method_call_node(method_call_or_block_node))
-        else
-          raise TypeError
-        end
-      end
-    end
   end
 end