packwerk 1.0.0 → 1.1.2

data/lib/packwerk/generators/application_validation.rb

@@ -35,7 +35,7 @@ module Packwerk
           return true
         end
 
-        source_file_path = File.expand_path("../templates/packwerk", __FILE__)
+        source_file_path = File.expand_path("templates/packwerk", __dir__)
         FileUtils.cp(source_file_path, destination_file_path)
 
         @out.puts("✅ Packwerk application validation bin script generated in #{destination_file_path}")
@@ -51,7 +51,7 @@ module Packwerk
           return true
         end
 
-        source_file_path = File.expand_path("../templates/packwerk_validator_test.rb", __FILE__)
+        source_file_path = File.expand_path("templates/packwerk_validator_test.rb", __dir__)
         FileUtils.cp(source_file_path, destination_file_path)
 
         @out.puts("✅ Packwerk application validation test generated in #{destination_file_path}")

data/lib/packwerk/generators/templates/package.yml

@@ -11,6 +11,10 @@ enforce_dependencies: true
 # We recommend enabling this for any new packages you create to aid with encapsulation.
 enforce_privacy: false
 
+# By default the public path will be app/public/, however this may not suit all applications' architecture so
+# this allows you to modify what your package's public path is.
+# public_path: app/public/
+
 # A list of this package's dependencies
 # Note that packages in this list require their own `package.yml` file
 # dependencies:

data/lib/packwerk/generators/templates/packwerk

@@ -10,12 +10,12 @@ ENV["RAILS_ENV"] = "test"
 packwerk_argv = ARGV.dup
 
 begin
-  load(File.expand_path("../spring", __FILE__))
+  load(File.expand_path("spring", __dir__))
 rescue LoadError => e
   raise unless e.message.include?("spring")
 end
 
-require File.expand_path("../../config/environment", __FILE__)
+require File.expand_path("../config/environment", __dir__)
 
 require "packwerk"
 

data/lib/packwerk/generators/templates/packwerk.yml.erb

@@ -7,7 +7,7 @@
 
 # List of patterns for folder paths to exclude
 # exclude:
-# - "{bin,node_modules,script,tmp}/**/*"
+# - "{bin,node_modules,script,tmp,vendor}/**/*"
 
 # Patterns to find package configuration files
 # package_paths: "**/"

data/lib/packwerk/inflector.rb

@@ -8,20 +8,31 @@ require "packwerk/inflections/custom"
 module Packwerk
   class Inflector
     class << self
+      extend T::Sig
+
       def default
-        @default ||= new
+        @default ||= new(custom_inflector: Inflections::Custom.new)
+      end
+
+      sig { params(inflections_file: String).returns(::Packwerk::Inflector) }
+      def from_file(inflections_file)
+        new(custom_inflector: Inflections::Custom.new(inflections_file))
       end
     end
 
-    # For #camelize, #classify, #pluralize, #singularize
-    include ::ActiveSupport::Inflector
+    extend T::Sig
+    include ::ActiveSupport::Inflector # For #camelize, #classify, #pluralize, #singularize
 
-    def initialize(custom_inflection_file: nil)
+    sig do
+      params(
+        custom_inflector: Inflections::Custom
+      ).void
+    end
+    def initialize(custom_inflector:)
       @inflections = ::ActiveSupport::Inflector::Inflections.new
 
       Inflections::Default.apply_to(@inflections)
-
-      Inflections::Custom.new(custom_inflection_file).apply_to(@inflections)
+      custom_inflector.apply_to(@inflections)
     end
 
     def pluralize(word, count = nil)
@@ -32,8 +43,6 @@ module Packwerk
       end
     end
 
-    private
-
     def inflections(_ = nil)
       @inflections
     end

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,8 +95,36 @@ 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_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 type(method_call_node) == METHOD_CALL
+        raise TypeError unless method_call?(method_call_node)
 
         # (send (lvar :foo) :bar (int 1))
         #   "foo.bar(1)"
@@ -112,7 +132,7 @@ module Packwerk
       end
 
       def method_name(method_call_node)
-        raise TypeError unless type(method_call_node) == METHOD_CALL
+        raise TypeError unless method_call?(method_call_node)
 
         # (send (lvar :foo) :bar (int 1))
         #   "foo.bar(1)"
@@ -120,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"
@@ -130,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"
@@ -153,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)
@@ -171,20 +192,38 @@ 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 type(hash_node) == HASH
+        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(hash_pair_node) == HASH_PAIR
+        raise TypeError unless type_of(hash_pair_node) == HASH_PAIR
 
         # (pair (int 1) (int 2))
         #   "1 => 2"
@@ -194,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"
@@ -204,15 +243,15 @@ module Packwerk
       end
 
       def hash_pairs(hash_node)
-        raise TypeError unless type(hash_node) == HASH
+        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(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"
@@ -222,8 +261,8 @@ module Packwerk
       def module_creation?(node)
         # "Class.new"
         # "Module.new"
-        type(node) == METHOD_CALL &&
-          type(receiver(node)) == CONSTANT &&
+        method_call?(node) &&
+          constant?(receiver(node)) &&
           ["Class", "Module"].include?(constant_name(receiver(node))) &&
           method_name(node) == :new
       end
@@ -231,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
@@ -245,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

@@ -3,9 +3,21 @@
 
 require "packwerk/node"
 require "packwerk/offense"
+require "packwerk/checker"
+require "packwerk/reference_lister"
 
 module Packwerk
   class NodeProcessor
+    extend T::Sig
+
+    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:)
       @reference_extractor = reference_extractor
       @reference_lister = reference_lister
@@ -14,8 +26,7 @@ module Packwerk
     end
 
     def call(node, ancestors:)
-      case Node.type(node)
-      when Node::METHOD_CALL, Node::CONSTANT
+      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
@@ -30,7 +41,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/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}