packwerk 1.0.1 → 1.1.3

data/lib/packwerk/node.rb

@@ -5,24 +5,14 @@ require "parser/ast/node"
 
 module Packwerk
   module Node
-    BLOCK = :block
-    CLASS = :class
-    CONSTANT = :const
-    CONSTANT_ASSIGNMENT = :casgn
-    CONSTANT_ROOT_NAMESPACE = :cbase
-    HASH = :hash
-    HASH_PAIR = :pair
-    METHOD_CALL = :send
-    MODULE = :module
-    STRING = :str
-    SYMBOL = :sym
-
     class TypeError < ArgumentError; end
     Location = Struct.new(:line, :column)
 
     class << self
+      extend T::Sig
+
       def class_or_module_name(class_or_module_node)
-        case type(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"
@@ -36,10 +26,10 @@ module Packwerk
       end
 
       def constant_name(constant_node)
-        case type(constant_node)
+        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)
@@ -52,6 +42,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("::")
@@ -74,19 +66,19 @@ module Packwerk
       end
 
       def enclosing_namespace_path(starting_node, ancestors:)
-        ancestors.select { |n| [CLASS, MODULE].include?(type(n)) }
+        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(node) == CLASS && parent_class(node) == starting_node
+          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(string_or_symbol_node)
+        case type_of(string_or_symbol_node)
         when STRING, SYMBOL
           # (str "foo")
           #   "'foo'"
@@ -103,20 +95,32 @@ module Packwerk
         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(node) == METHOD_CALL
+        type_of(node) == METHOD_CALL
       end
 
       def hash?(node)
-        type(node) == HASH
+        type_of(node) == HASH
       end
 
       def string?(node)
-        type(node) == STRING
+        type_of(node) == STRING
       end
 
       def symbol?(node)
-        type(node) == SYMBOL
+        type_of(node) == SYMBOL
       end
 
       def method_arguments(method_call_node)
@@ -136,7 +140,7 @@ module Packwerk
       end
 
       def module_name_from_definition(node)
-        case type(node)
+        case type_of(node)
         when CLASS, MODULE
           # "class My::Class; end"
           # "module My::Module; end"
@@ -146,7 +150,7 @@ module Packwerk
           # "My::Module = ..."
           rvalue = node.children.last
 
-          case type(rvalue)
+          case type_of(rvalue)
           when METHOD_CALL
             # "Class.new"
             # "Module.new"
@@ -169,16 +173,17 @@ module Packwerk
       end
 
       def parent_class(class_node)
-        raise TypeError unless type(class_node) == CLASS
+        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(n)) }
+          .select { |n| [CLASS, MODULE, CONSTANT_ASSIGNMENT, BLOCK].include?(type_of(n)) }
 
         names = definitions.map do |definition|
           name_part_from_definition(definition)
@@ -187,10 +192,6 @@ module Packwerk
         names.empty? ? "Object" : names.reverse.join("::")
       end
 
-      def type(node)
-        node.type
-      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 }
@@ -199,8 +200,30 @@ module Packwerk
 
       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(hash_pair_node) == HASH_PAIR
+        raise TypeError unless type_of(hash_pair_node) == HASH_PAIR
 
         # (pair (int 1) (int 2))
         #   "1 => 2"
@@ -210,7 +233,7 @@ module Packwerk
       end
 
       def hash_pair_value(hash_pair_node)
-        raise TypeError unless type(hash_pair_node) == HASH_PAIR
+        raise TypeError unless type_of(hash_pair_node) == HASH_PAIR
 
         # (pair (int 1) (int 2))
         #   "1 => 2"
@@ -224,11 +247,11 @@ module Packwerk
 
         # (hash (pair (int 1) (int 2)) (pair (int 3) (int 4)))
         #   "{1 => 2, 3 => 4}"
-        hash_node.children.select { |n| type(n) == HASH_PAIR }
+        hash_node.children.select { |n| type_of(n) == HASH_PAIR }
       end
 
       def method_call_node(block_node)
-        raise TypeError unless type(block_node) == BLOCK
+        raise TypeError unless type_of(block_node) == BLOCK
 
         # (block (send (lvar :foo) :bar) (args) (int 42))
         #   "foo.bar do 42 end"
@@ -239,7 +262,7 @@ module Packwerk
         # "Class.new"
         # "Module.new"
         method_call?(node) &&
-          type(receiver(node)) == CONSTANT &&
+          constant?(receiver(node)) &&
           ["Class", "Module"].include?(constant_name(receiver(node))) &&
           method_name(node) == :new
       end
@@ -247,12 +270,12 @@ module Packwerk
       def name_from_block_definition(node)
         if method_name(method_call_node(node)) == :class_eval
           receiver = receiver(node)
-          constant_name(receiver) if receiver && type(receiver) == CONSTANT
+          constant_name(receiver) if receiver && constant?(receiver)
         end
       end
 
       def name_part_from_definition(node)
-        case type(node)
+        case type_of(node)
         when CLASS, MODULE, CONSTANT_ASSIGNMENT
           module_name_from_definition(node)
         when BLOCK
@@ -261,7 +284,7 @@ module Packwerk
       end
 
       def receiver(method_call_or_block_node)
-        case type(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

data/lib/packwerk/node_processor.rb

@@ -25,9 +25,9 @@ module Packwerk
       @checkers = checkers
     end
 
-    def call(node, ancestors:)
-      case Node.type(node)
-      when Node::METHOD_CALL, Node::CONSTANT
+    sig { params(node: Parser::AST::Node, ancestors: T::Array[Parser::AST::Node]).returns(T.nilable(Offense)) }
+    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
@@ -42,7 +42,7 @@ module Packwerk
 
       Packwerk::Offense.new(
         location: Node.location(node),
-        file: @filename,
+        file: reference.relative_path,
         message: <<~EOS
           #{message}
           Inference details: this is a reference to #{constant.name} which seems to be defined in #{constant.location}.

data/lib/packwerk/node_processor_factory.rb

@@ -0,0 +1,39 @@
+# 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]
+
+    sig { params(filename: String, node: AST::Node).returns(NodeProcessor) }
+    def for(filename:, node:)
+      ::Packwerk::NodeProcessor.new(
+        reference_extractor: reference_extractor(node: node),
+        reference_lister: reference_lister,
+        filename: filename,
+        checkers: checkers,
+      )
+    end
+
+    private
+
+    sig { params(node: AST::Node).returns(::Packwerk::ReferenceExtractor) }
+    def reference_extractor(node:)
+      ::Packwerk::ReferenceExtractor.new(
+        context_provider: context_provider,
+        constant_name_inspectors: constant_name_inspectors,
+        root_node: node,
+        root_path: root_path,
+      )
+    end
+  end
+end

data/lib/packwerk/node_visitor.rb

@@ -10,7 +10,7 @@ module Packwerk
     end
 
     def visit(node, ancestors:, result:)
-      offense = @node_processor.call(node, ancestors: ancestors)
+      offense = @node_processor.call(node, ancestors)
       result << offense if offense
 
       child_ancestors = [node] + ancestors

data/lib/packwerk/offense.rb

@@ -4,7 +4,8 @@
 require "parser/source/map"
 require "sorbet-runtime"
 
-require "packwerk/output_styles"
+require "packwerk/output_style"
+require "packwerk/output_styles/plain"
 
 module Packwerk
   class Offense
@@ -23,11 +24,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/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

data/lib/packwerk/output_styles/plain.rb

@@ -0,0 +1,26 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Packwerk
+  module OutputStyles
+    class Plain
+      extend T::Sig
+      include OutputStyle
+
+      sig { override.returns(String) }
+      def reset
+        ""
+      end
+
+      sig { override.returns(String) }
+      def filename
+        ""
+      end
+
+      sig { override.returns(String) }
+      def error
+        ""
+      end
+    end
+  end
+end

data/lib/packwerk/package_set.rb

@@ -28,8 +28,13 @@ module Packwerk
       def package_paths(root_path, package_pathspec)
         bundle_path_match = Bundler.bundle_path.join("**").to_s
 
-        Dir.glob(File.join(root_path, package_pathspec, PACKAGE_CONFIG_FILENAME))
-          .map { |path| Pathname.new(path) }.reject { |path| path.realpath.fnmatch(bundle_path_match) }
+        glob_patterns = Array(package_pathspec).map do |pathspec|
+          File.join(root_path, pathspec, PACKAGE_CONFIG_FILENAME)
+        end
+
+        Dir.glob(glob_patterns)
+          .map { |path| Pathname.new(path).cleanpath }
+          .reject { |path| path.realpath.fnmatch(bundle_path_match) }
       end
 
       private
@@ -55,7 +60,8 @@ module Packwerk
     end
 
     def package_from_path(file_path)
-      @packages.values.find { |package| package.package_path?(file_path) }
+      path_string = file_path.to_s
+      @packages.values.find { |package| package.package_path?(path_string) }
     end
   end
 end

data/lib/packwerk/parsed_constant_definitions.rb

@@ -28,8 +28,8 @@ module Packwerk
 
       fully_qualified_constant_name = "::#{constant_name}"
 
-      possible_namespaces = namespace_path.reduce([""]) do |acc, current|
-        acc << acc.last + "::" + current
+      possible_namespaces = namespace_path.each_with_object([""]) do |current, acc|
+        acc << "#{acc.last}::#{current}" if acc.last && current
       end
 
       possible_namespaces.map { |namespace| namespace + fully_qualified_constant_name }
@@ -38,12 +38,12 @@ module Packwerk
     private
 
     def collect_local_definitions_from_root(node, current_namespace_path = [])
-      if Node.type(node) == Node::CONSTANT_ASSIGNMENT
+      if Node.constant_assignment?(node)
         add_definition(Node.constant_name(node), current_namespace_path, Node.name_location(node))
       elsif Node.module_name_from_definition(node)
         # handle compact constant nesting (e.g. "module Sales::Order")
         tempnode = node
-        while (tempnode = Node.each_child(tempnode).find { |n| Node.type(n) == Node::CONSTANT })
+        while (tempnode = Node.each_child(tempnode).find { |n| Node.constant?(n) })
           add_definition(Node.constant_name(tempnode), current_namespace_path, Node.name_location(tempnode))
         end