packwerk 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6adf93154744a85f6f49a1b830710dee4f4c7b8e05373de50aef86926167f23e
-  data.tar.gz: cfea93c802c34114e63966717e7a643cf1de94f3061b13ed434b04dd12469bed
+  metadata.gz: 3b54c31e7c1902a03feb01304c85c9f2363b769fdb5f3c3cea7f38c67ff77af3
+  data.tar.gz: efefa11bf554021227ce63a876c891d5466ee7bcd173e319deb086c8ec9732a5
 SHA512:
-  metadata.gz: 00dfee149ce8b43ce862a0df57eda5af2583fd4066cd1596ffaae2a1a5f562150e8caf84d29f062e11a039bf08bea3eb360e9a2817b14c2d9229ce77a89dc2e4
-  data.tar.gz: f74cecc91b2fce594df2c1dae811d469a1f8e490daefbd396ed2fb87cb6438e7286de98f63c425d196af2b7ce4ed6f8ef6e0cfb9ddf8b47d17e38bbccda2a0db
+  metadata.gz: 5765e07827c5c5fc6d297f916e80c6cd2a6e09984ba91a1f2186ce1209d7965c7d906b6ff06a6b50fd37c299cdb9f82188d57273faf6e0fe7c654983ff8c0e8d
+  data.tar.gz: b44c1ba5e1c5b61dd2d3e4755b5c215f245cb412a05f272513a6eba83e561097d6f6e624d65f5e8fa7021479616433f0e37ca9b818f00363efd11f24f8b6bca6

data/.github/pull_request_template.md

@@ -7,21 +7,22 @@
 ## What should reviewers focus on?
 
 
-
 ## Type of Change
 
-- [ ] Bug fix (non-breaking change which fixes an issue)
-- [ ] New feature (non-breaking change which adds functionality)
-- [ ] Code refactor (non-breaking change that doesn't add functionality)
-- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected)
-- [ ] This change requires a documentation update
+- [ ] Bugfix
+- [ ] New feature
+- [ ] Non-breaking change (a change that doesn't alter functionality - i.e., code refactor, configs, etc.)
 
 ### Additional Release Notes
 
+- [ ] Breaking change (fix or feature that would cause existing functionality to change)
+
 Include any notes here to include in the release description. For example, if you selected "breaking change" above, leave notes on how users can transition to this version.
 
 If no additional notes are necessary, delete this section or leave it unchanged.
 
 ## Checklist
 
-- [ ] It is safe to simply rollback this change.
+- [ ] I have updated the documentation accordingly.
+- [ ] I have added tests to cover my changes.
+- [ ] It is safe to rollback this change.

data/Gemfile

@@ -19,4 +19,5 @@ gem("tapioca", require: false)
 
 group :development do
   gem("byebug", require: false)
+  gem("minitest-focus", require: false)
 end

data/Gemfile.lock

@@ -85,7 +85,7 @@ GIT
 PATH
   remote: .
   specs:
-    packwerk (1.0.1)
+    packwerk (1.0.2)
       activesupport (>= 5.2)
       ast
       better_html
@@ -137,6 +137,8 @@ GEM
     mini_mime (1.0.2)
     mini_portile2 (2.4.0)
     minitest (5.14.0)
+    minitest-focus (1.2.1)
+      minitest (>= 4, < 6)
     mocha (1.11.2)
     nio4r (2.5.2)
     nokogiri (1.10.9)
@@ -180,7 +182,7 @@ GEM
     smart_properties (1.15.0)
     sorbet (0.5.5898)
       sorbet-static (= 0.5.5898)
-    sorbet-runtime (0.5.5898)
+    sorbet-runtime (0.5.6049)
     sorbet-static (0.5.5898-universal-darwin-19)
     spoom (1.0.4)
       colorize
@@ -220,6 +222,7 @@ DEPENDENCIES
   byebug
   constant_resolver
   m
+  minitest-focus
   mocha
   packwerk!
   rails!

data/USAGE.md

@@ -70,7 +70,7 @@ Packwerk reads from the `packwerk.yml` configuration file in the root directory.
 
 ### Inflections
 
-Packwerk requires custom inflections to be defined in `inflections.yml` instead of the traditional `inflections.rb`. This is because Packwerk accounts for custom inflections, such as acronyms, when resolving constants. Additionally, Packwerk interprets Active Record associations as references to constants. For example, `has_many :birds` is reference to the `Birds` constant.
+Packwerk requires custom inflections to be defined in `inflections.yml` instead of the traditional `inflections.rb`. This is because Packwerk accounts for custom inflections, such as acronyms, when resolving constants. Additionally, Packwerk interprets Active Record associations as references to constants. For example, `has_many :birds` is a reference to the `Bird` constant.
 
 In order to make your custom inflections compatible with Active Support and Packwerk, you must create a `config/inflections.yml` file and point `ActiveSupport::Inflector` to that file.
 

data/lib/packwerk.rb

@@ -14,7 +14,6 @@ require "packwerk/cli"
 require "packwerk/configuration"
 require "packwerk/const_node_inspector"
 require "packwerk/constant_discovery"
-require "packwerk/constant_name_inspector"
 require "packwerk/dependency_checker"
 require "packwerk/deprecated_references"
 require "packwerk/files_for_processing"

data/lib/packwerk/application_load_paths.rb

@@ -0,0 +1,67 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "bundler"
+
+module Packwerk
+  module ApplicationLoadPaths
+    class << self
+      extend T::Sig
+
+      sig { returns(T::Array[String]) }
+      def extract_relevant_paths
+        assert_application_booted
+        all_paths = extract_application_autoload_paths
+        relevant_paths = filter_relevant_paths(all_paths)
+        assert_load_paths_present(relevant_paths)
+        relative_path_strings(relevant_paths)
+      end
+
+      sig { void }
+      def assert_application_booted
+        raise "The application needs to be booted to extract load paths" unless defined?(::Rails)
+      end
+
+      sig { returns(T::Array[String]) }
+      def extract_application_autoload_paths
+        Rails.application.railties
+          .select { |railtie| railtie.is_a?(Rails::Engine) }
+          .push(Rails.application)
+          .flat_map do |engine|
+          (engine.config.autoload_paths + engine.config.eager_load_paths + engine.config.autoload_once_paths).uniq
+        end
+      end
+
+      sig do
+        params(all_paths: T::Array[String], bundle_path: Pathname, rails_root: Pathname)
+          .returns(T::Array[Pathname])
+      end
+      def filter_relevant_paths(all_paths, bundle_path: Bundler.bundle_path, rails_root: Rails.root)
+        bundle_path_match = bundle_path.join("**")
+        rails_root_match = rails_root.join("**")
+
+        all_paths
+          .map { |path| Pathname.new(path).expand_path }
+          .select { |path| path.fnmatch(rails_root_match.to_s) } # path needs to be in application directory
+          .reject { |path| path.fnmatch(bundle_path_match.to_s) } # reject paths from vendored gems
+      end
+
+      sig { params(paths: T::Array[Pathname], rails_root: Pathname).returns(T::Array[String]) }
+      def relative_path_strings(paths, rails_root: Rails.root)
+        paths
+          .map { |path| path.relative_path_from(rails_root).to_s }
+          .uniq
+      end
+
+      sig { params(paths: T::Array[T.untyped]).void }
+      def assert_load_paths_present(paths)
+        if paths.empty?
+          raise <<~EOS
+            We could not extract autoload paths from your Rails app. This is likely a configuration error.
+            Packwerk will not work correctly without any autoload paths.
+          EOS
+        end
+      end
+    end
+  end
+end

data/lib/packwerk/application_validator.rb

@@ -9,15 +9,15 @@ require "yaml"
 require "packwerk/package_set"
 require "packwerk/graph"
 require "packwerk/inflector"
+require "packwerk/application_load_paths"
 
 module Packwerk
   class ApplicationValidator
-    def initialize(config_file_path:, application_load_paths:, configuration:)
+    def initialize(config_file_path:, configuration:)
       @config_file_path = config_file_path
       @configuration = configuration
 
-      # Load paths should be from the application
-      @application_load_paths = application_load_paths.sort.uniq
+      @application_load_paths = ApplicationLoadPaths.extract_relevant_paths
     end
 
     Result = Struct.new(:ok?, :error_value)
@@ -170,14 +170,12 @@ module Packwerk
     def check_inflection_file
       inflections_file = @configuration.inflections_file
 
-      test_inflections = ActiveSupport::Inflector::Inflections.new
-
-      Packwerk::Inflections::Default.apply_to(test_inflections)
-      Packwerk::Inflections::Custom.new(inflections_file).apply_to(test_inflections)
+      application_inflections = ActiveSupport::Inflector.inflections
+      packwerk_inflections = Packwerk::Inflector.from_file(inflections_file).inflections
 
       results = %i(plurals singulars uncountables humans acronyms).map do |type|
-        expected = ActiveSupport::Inflector.inflections.public_send(type).to_set
-        actual = test_inflections.public_send(type).to_set
+        expected = application_inflections.public_send(type).to_set
+        actual = packwerk_inflections.public_send(type).to_set
 
         if expected == actual
           Result.new(true)
@@ -331,7 +329,8 @@ module Packwerk
     end
 
     def package_manifests(glob_pattern)
-      PackageSet.package_paths(@configuration.root_path, glob_pattern).map(&:to_s)
+      PackageSet.package_paths(@configuration.root_path, glob_pattern)
+        .map { |f| File.realpath(f) }
     end
 
     def relative_paths(paths)

data/lib/packwerk/association_inspector.rb

@@ -16,7 +16,7 @@ module Packwerk
       has_and_belongs_to_many
     ).to_set
 
-    def initialize(inflector: Inflector.new, custom_associations: Set.new)
+    def initialize(inflector:, custom_associations: Set.new)
       @inflector = inflector
       @associations = RAILS_ASSOCIATIONS + custom_associations
     end

data/lib/packwerk/cli.rb

@@ -11,6 +11,7 @@ require "packwerk/inflector"
 require "packwerk/output_styles"
 require "packwerk/run_context"
 require "packwerk/updating_deprecated_references"
+require "packwerk/checking_deprecated_references"
 
 module Packwerk
   class Cli
@@ -21,7 +22,10 @@ module Packwerk
       @err_out = err_out
       @style = style
       @configuration = configuration || Configuration.from_path
-      @run_context = run_context || Packwerk::RunContext.from_configuration(@configuration)
+      @run_context = run_context || Packwerk::RunContext.from_configuration(
+        @configuration,
+        reference_lister: ::Packwerk::CheckingDeprecatedReferences.new(@configuration.root_path),
+      )
       @progress_formatter = Formatters::ProgressFormatter.new(@out, style: style)
     end
 
@@ -138,7 +142,7 @@ module Packwerk
       all_offenses = T.let([], T.untyped)
       execution_time = Benchmark.realtime do
         all_offenses = files.flat_map do |path|
-          @run_context.file_processor.call(path).tap { |offenses| mark_progress(offenses) }
+          @run_context.process_file(file: path).tap { |offenses| mark_progress(offenses) }
         end
 
         updating_deprecated_references.dump_deprecated_references_files
@@ -160,7 +164,7 @@ module Packwerk
       all_offenses = T.let([], T.untyped)
       execution_time = Benchmark.realtime do
         files.each do |path|
-          @run_context.file_processor.call(path).tap do |offenses|
+          @run_context.process_file(file: path).tap do |offenses|
             mark_progress(offenses)
             all_offenses.concat(offenses)
           end
@@ -200,7 +204,6 @@ module Packwerk
       @progress_formatter.started_validation do
         checker = Packwerk::ApplicationValidator.new(
           config_file_path: @configuration.config_path,
-          application_load_paths: @configuration.all_application_autoload_paths,
           configuration: @configuration
         )
         result = checker.check_all

data/lib/packwerk/configuration.rb

@@ -42,45 +42,10 @@ module Packwerk
       @root_path = File.expand_path(root)
       @package_paths = configs["package_paths"] || "**/"
       @custom_associations = configs["custom_associations"] || []
-      @load_paths = configs["load_paths"] || all_application_autoload_paths
+      @load_paths = configs["load_paths"]
       @inflections_file = File.expand_path(configs["inflections_file"] || "config/inflections.yml", @root_path)
 
       @config_path = config_path
     end
-
-    def all_application_autoload_paths
-      return [] unless defined?(::Rails)
-
-      all_paths = Rails.application.railties
-        .select { |railtie| railtie.is_a?(Rails::Engine) }
-        .push(Rails.application)
-        .flat_map do |engine|
-        (engine.config.autoload_paths + engine.config.eager_load_paths + engine.config.autoload_once_paths).uniq
-      end
-
-      bundle_path_match = Bundler.bundle_path.join("**").to_s
-
-      all_paths = all_paths.each_with_object([]) do |path_string, paths|
-        # ignore paths inside gems
-        path = Pathname.new(path_string)
-
-        next unless path.exist?
-        next if path.realpath.fnmatch(bundle_path_match)
-
-        paths << path.relative_path_from(Rails.root).to_s
-      end
-
-      all_paths.tap do |paths|
-        if paths.empty?
-          raise <<~EOS
-            No autoload paths have been set up in your Rails app. This is likely a bug, and
-            packwerk is unlikely to work correctly without any autoload paths.
-
-            You can follow the Rails guides on setting up load paths, or manually configure
-            them in `packwerk.yml` with `load_paths`.
-          EOS
-        end
-      end
-    end
   end
 end

data/lib/packwerk/const_node_inspector.rb

@@ -9,20 +9,12 @@ module Packwerk
     include ConstantNameInspector
 
     def constant_name_from_node(node, ancestors:)
-      return nil unless Node.type(node) == Node::CONSTANT
-
-      # Only process the root `const` node for namespaced constant references. For example, in the
-      # reference `Spam::Eggs::Thing`, we only process the const node associated with `Spam`.
+      return nil unless Node.constant?(node)
       parent = ancestors.first
-      return nil if parent && Node.type(parent) == Node::CONSTANT
-
-      if constant_in_module_or_class_definition?(node, parent: parent)
-        # We're defining a class with this name, in which case the constant is implicitly fully qualified by its
-        # enclosing namespace
-        name = Node.parent_module_name(ancestors: ancestors)
-        name ||= Node.enclosing_namespace_path(node, ancestors: ancestors).push(Node.constant_name(node)).join("::")
+      return nil unless root_constant?(parent)
 
-        "::" + name
+      if parent && constant_in_module_or_class_definition?(node, parent: parent)
+        fully_qualify_constant(node, ancestors: ancestors)
       else
         begin
           Node.constant_name(node)
@@ -34,11 +26,29 @@ module Packwerk
 
     private
 
+    # Only process the root `const` node for namespaced constant references. For example, in the
+    # reference `Spam::Eggs::Thing`, we only process the const node associated with `Spam`.
+    def root_constant?(parent)
+      !(parent && Node.constant?(parent))
+    end
+
     def constant_in_module_or_class_definition?(node, parent:)
-      if parent
-        parent_name = Node.module_name_from_definition(parent)
-        parent_name && parent_name == Node.constant_name(node)
-      end
+      parent_name = Node.module_name_from_definition(parent)
+      parent_name && parent_name == Node.constant_name(node)
+    end
+
+    def fully_qualify_constant(node, ancestors:)
+      # We're defining a class with this name, in which case the constant is implicitly fully qualified by its
+      # enclosing namespace
+      name = Node.parent_module_name(ancestors: ancestors)
+      name ||= generate_qualified_constant(node, ancestors)
+      "::" + name
+    end
+
+    def generate_qualified_constant(node, ancestors:)
+      namespace_path = Node.enclosing_namespace_path(node, ancestors: ancestors)
+      constant_name = Node.constant_name(node)
+      namespace_path.push(constant_name).join("::")
     end
   end
 end

data/lib/packwerk/file_processor.rb

@@ -15,8 +15,8 @@ module Packwerk
       end
     end
 
-    def initialize(run_context:, parser_factory: nil)
-      @run_context = run_context
+    def initialize(node_processor_factory:, parser_factory: nil)
+      @node_processor_factory = node_processor_factory
       @parser_factory = parser_factory || Packwerk::Parsers::Factory.instance
     end
 
@@ -32,8 +32,8 @@ module Packwerk
 
       result = []
       if node
-        @node_processor = @run_context.node_processor_for(filename: file_path, ast_node: node)
-        node_visitor = Packwerk::NodeVisitor.new(node_processor: @node_processor)
+        node_processor = @node_processor_factory.for(filename: file_path, node: node)
+        node_visitor = Packwerk::NodeVisitor.new(node_processor: node_processor)
 
         node_visitor.visit(node, ancestors: [], result: result)
       end

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,12 @@ 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
       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,7 +24,7 @@ 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
@@ -74,19 +62,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 +91,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 +136,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 +146,7 @@ module Packwerk
           # "My::Module = ..."
           rvalue = node.children.last
 
-          case type(rvalue)
+          case type_of(rvalue)
           when METHOD_CALL
             # "Class.new"
             # "Module.new"
@@ -169,7 +169,7 @@ 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"
@@ -178,7 +178,7 @@ module Packwerk
 
       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 +187,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 +195,29 @@ 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
+      STRING = :str
+      SYMBOL = :sym
+
+      private_constant(
+        :BLOCK, :CLASS, :CONSTANT, :CONSTANT_ASSIGNMENT, :CONSTANT_ROOT_NAMESPACE, :HASH, :HASH_PAIR, :METHOD_CALL,
+        :MODULE, :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 +227,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 +241,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 +256,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 +264,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 +278,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

@@ -26,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
@@ -42,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/package_set.rb

@@ -29,7 +29,8 @@ module Packwerk
         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) }
+          .map { |path| Pathname.new(path) }
+          .reject { |path| path.realpath.fnmatch(bundle_path_match) }
       end
 
       private

data/lib/packwerk/parsed_constant_definitions.rb

@@ -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
 

data/lib/packwerk/run_context.rb

@@ -1,30 +1,31 @@
 # typed: true
 # frozen_string_literal: true
 
-require "active_support/inflector"
 require "constant_resolver"
 
 require "packwerk/association_inspector"
-require "packwerk/checking_deprecated_references"
 require "packwerk/constant_discovery"
 require "packwerk/const_node_inspector"
 require "packwerk/dependency_checker"
 require "packwerk/file_processor"
-require "packwerk/node_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
+
     attr_reader(
-      :checkers,
-      :constant_name_inspectors,
-      :context_provider,
       :root_path,
-      :file_processor,
-      :node_processor_class,
-      :reference_lister
+      :load_paths,
+      :package_paths,
+      :inflector,
+      :custom_associations,
+      :checker_classes,
+      :reference_lister,
     )
 
     DEFAULT_CHECKERS = [
@@ -33,16 +34,15 @@ module Packwerk
     ]
 
     class << self
-      def from_configuration(configuration, reference_lister: nil)
-        default_reference_lister = reference_lister ||
-          ::Packwerk::CheckingDeprecatedReferences.new(configuration.root_path)
+      def from_configuration(configuration, reference_lister:)
+        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: ActiveSupport::Inflector,
+          inflector: inflector,
           custom_associations: configuration.custom_associations,
-          reference_lister: default_reference_lister,
+          reference_lister: reference_lister,
         )
       end
     end
@@ -54,51 +54,73 @@ module Packwerk
       inflector: nil,
       custom_associations: [],
       checker_classes: DEFAULT_CHECKERS,
-      node_processor_class: NodeProcessor,
-      reference_lister: nil
+      reference_lister:
     )
-      @root_path = File.expand_path(root_path)
+      @root_path = root_path
+      @load_paths = load_paths
+      @package_paths = package_paths
+      @inflector = inflector
+      @custom_associations = custom_associations
+      @checker_classes = checker_classes
+      @reference_lister = reference_lister
+    end
 
-      resolver = ConstantResolver.new(
-        root_path: @root_path,
-        load_paths: load_paths,
-        inflector: inflector,
-      )
+    sig { params(file: String).returns(T::Array[T.nilable(::Packwerk::Offense)]) }
+    def process_file(file:)
+      file_processor.call(file)
+    end
+
+    private
 
-      package_set = ::Packwerk::PackageSet.load_all_from(@root_path, package_pathspec: package_paths)
+    sig { returns(FileProcessor) }
+    def file_processor
+      @file_processor ||= FileProcessor.new(node_processor_factory: node_processor_factory)
+    end
 
-      @context_provider = ::Packwerk::ConstantDiscovery.new(
+    sig { returns(NodeProcessorFactory) }
+    def node_processor_factory
+      NodeProcessorFactory.new(
+        context_provider: context_provider,
+        checkers: checkers,
+        root_path: root_path,
+        constant_name_inspectors: constant_name_inspectors,
+        reference_lister: reference_lister
+      )
+    end
+
+    sig { returns(ConstantDiscovery) }
+    def context_provider
+      ::Packwerk::ConstantDiscovery.new(
         constant_resolver: resolver,
         packages: package_set
       )
+    end
+
+    sig { returns(ConstantResolver) }
+    def resolver
+      ConstantResolver.new(
+        root_path: root_path,
+        load_paths: load_paths,
+        inflector: inflector,
+      )
+    end
 
-      @reference_lister = reference_lister || ::Packwerk::CheckingDeprecatedReferences.new(@root_path)
+    sig { returns(PackageSet) }
+    def package_set
+      ::Packwerk::PackageSet.load_all_from(root_path, package_pathspec: package_paths)
+    end
 
-      @checkers = checker_classes.map(&:new)
+    sig { returns(T::Array[Checker]) }
+    def checkers
+      checker_classes.map(&:new)
+    end
 
-      @constant_name_inspectors = [
+    sig { returns(T::Array[ConstantNameInspector]) }
+    def constant_name_inspectors
+      [
         ::Packwerk::ConstNodeInspector.new,
         ::Packwerk::AssociationInspector.new(inflector: inflector, custom_associations: custom_associations),
       ]
-
-      @node_processor_class = node_processor_class
-      @file_processor = FileProcessor.new(run_context: self)
-    end
-
-    def node_processor_for(filename:, ast_node:)
-      reference_extractor = ::Packwerk::ReferenceExtractor.new(
-        context_provider: context_provider,
-        constant_name_inspectors: constant_name_inspectors,
-        root_node: ast_node,
-        root_path: root_path,
-      )
-
-      node_processor_class.new(
-        reference_extractor: reference_extractor,
-        reference_lister: @reference_lister,
-        filename: filename,
-        checkers: checkers,
-      )
     end
   end
 end

data/lib/packwerk/version.rb

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

data/packwerk.gemspec

@@ -34,7 +34,7 @@ Gem::Specification.new do |spec|
   spec.executables << "packwerk"
 
   spec.files = Dir.chdir(__dir__) do
-    %x(git ls-files -z).split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+    %x(git ls-files -z).split("\x0").reject { |f| f.match(%r{^(test|spec|features|static)/}) }
   end
   spec.require_paths = %w(lib)
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: packwerk
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Shopify Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-10-30 00:00:00.000000000 Z
+date: 2020-11-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -183,6 +183,7 @@ files:
 - docs/cohesion.png
 - exe/packwerk
 - lib/packwerk.rb
+- lib/packwerk/application_load_paths.rb
 - lib/packwerk/application_validator.rb
 - lib/packwerk/association_inspector.rb
 - lib/packwerk/checker.rb
@@ -212,6 +213,7 @@ files:
 - lib/packwerk/inflector.rb
 - lib/packwerk/node.rb
 - lib/packwerk/node_processor.rb
+- lib/packwerk/node_processor_factory.rb
 - lib/packwerk/node_visitor.rb
 - lib/packwerk/offense.rb
 - lib/packwerk/output_styles.rb
@@ -307,11 +309,6 @@ files:
 - sorbet/rbi/gems/websocket-extensions@0.1.4.rbi
 - sorbet/rbi/gems/zeitwerk@2.3.0.rbi
 - sorbet/tapioca/require.rb
-- static/packwerk-check-demo.png
-- static/packwerk_check.gif
-- static/packwerk_check_violation.gif
-- static/packwerk_update.gif
-- static/packwerk_validate.gif
 homepage: https://github.com/Shopify/packwerk
 licenses:
 - MIT