Exclude load paths

Allow load path exclusion so that certain paths should be ignored. This
is useful to ignore engines separate to a main application that live
within your application.

Author: gmcgibbon

README.md

@@ -62,6 +62,23 @@ context.name     # => "::Some::Nested::Model"
 context.location # => "models/some/nested/model.rb"
 ```
 
+### Ignoring paths
+
+You may want to only resolve constants from certain sections of your application. If you want to leave any paths out, use `exclude`:
+
+```ruby
+resolver = ConstantResolver.new(
+  root_path: "/app",
+  load_paths: [
+    "/app/models",
+    "/some/engine/app/models",
+  ],
+  exclude: [
+    "some/engine/**/*"
+  ],
+)
+```
+
 ## Development
 
 After checking out the repo, run `bundle` to install dependencies. Then, run `rake test` to run the tests.

lib/constant_resolver.rb

@@ -13,6 +13,8 @@
 #   have no way of inferring the file it is defined in. You could argue though that inheritance means that another
 #   constant with the same name exists in the inheriting class, and this view is sufficient for all our use cases.
 class ConstantResolver
+  RUBY_FILES_GLOB = "**/*.rb"
+
   class Error < StandardError; end
   class ConstantContext < Struct.new(:name, :location); end
 
@@ -25,10 +27,12 @@ def camelize(string)
     end
   end
 
+  private_constant :RUBY_FILES_GLOB
   private_constant :DefaultInflector
 
   # @param root_path [String] The root path of the application to analyze
   # @param load_paths [Array<String>] The autoload paths of the application.
+  # @param exclude [Array<String>] Paths to exclude to scan for constants.
   # @param inflector [Object] Any object that implements a `camelize` function.
   #
   # @example usage in a Rails app
@@ -39,13 +43,14 @@ def camelize(string)
   #     root_path: Rails.root.to_s,
   #     load_paths: load_paths
   #   )
-  def initialize(root_path:, load_paths:, inflector: DefaultInflector.new)
+  def initialize(root_path:, load_paths:, exclude: [], inflector: DefaultInflector.new)
     root_path += "/" unless root_path.end_with?("/")
 
     @root_path = root_path
     @load_paths = coerce_load_paths(load_paths)
     @file_map = nil
     @inflector = inflector
+    @exclude = exclude
   end
 
   # Resolve a constant via its name.
@@ -87,7 +92,10 @@ def file_map
           duplicate_files[const_name] ||= [existing_entry]
           duplicate_files[const_name] << root_relative_path
         end
-        @file_map[const_name] = root_relative_path
+
+        if allowed?(root_relative_path)
+          @file_map[const_name] = root_relative_path
+        end
       end
     end
 
@@ -120,6 +128,10 @@ def config
 
   private
 
+  def allowed?(path)
+    !@exclude.any? { |glob| File.fnmatch(glob, path, File::FNM_EXTGLOB | File::FNM_PATHNAME) }
+  end
+
   def coerce_load_paths(load_paths)
     load_paths = Hash[load_paths.map { |p| [p, "Object"] }] unless load_paths.respond_to?(:transform_keys)
 
@@ -137,7 +149,7 @@ def ambiguous_constant_message(const_name, paths)
   end
 
   def glob_path(path)
-    @root_path + path + "**/*.rb"
+    File.join(@root_path, path, RUBY_FILES_GLOB)
   end
 
   def resolve_constant(const_name, current_namespace_path, original_name: const_name)

test/constant_resolver_test.rb

@@ -33,152 +33,6 @@ def setup
       super
     end
 
-    def test_that_it_has_a_version_number
-      refute_nil(::ConstantResolver::VERSION)
-    end
-
-    def test_discovers_simple_constant
-      constant = @resolver.resolve("Order")
-      assert_equal("::Order", constant.name)
-      assert_equal("app/models/order.rb", constant.location)
-    end
-
-    def test_resolves_constants_from_non_default_root_path_namespace
-      Object.const_set(:Api, Module.new)
-
-      resolver = ConstantResolver.new(
-        root_path: "test/fixtures/constant_discovery/valid/",
-        load_paths: {
-          "app/models" => Object,
-          "app/rest_api" => Api,
-          "app/internal" => "::Company::Internal",
-        },
-      )
-
-      constant = resolver.resolve("Order")
-      assert_equal("::Order", constant.name)
-      assert_equal("app/models/order.rb", constant.location)
-
-      constant = resolver.resolve("Api::Repositories")
-      assert_equal("::Api::Repositories", constant.name)
-      assert_equal("app/rest_api/repositories.rb", constant.location)
-
-      constant = resolver.resolve("Company::Internal::Main")
-      assert_equal("::Company::Internal::Main", constant.name)
-      assert_equal("app/internal/main.rb", constant.location)
-    end
-
-    def test_resolve_returns_constant_context
-      context = @resolver.resolve("Order")
-      assert_instance_of(ConstantResolver::ConstantContext, context)
-    end
-
-    def test_does_not_discover_constant_with_invalid_casing
-      constant = @resolver.resolve("ORDER")
-      assert_nil(constant)
-    end
-
-    def test_understands_nested_load_paths
-      constant = @resolver.resolve("Entry")
-      assert_equal("::Entry", constant.name)
-      assert_equal("app/models/entry.rb", constant.location)
-
-      constant = @resolver.resolve("HasTimeline")
-      assert_equal("::HasTimeline", constant.name)
-      assert_equal("app/models/concerns/has_timeline.rb", constant.location)
-    end
-
-    def test_does_not_try_to_discover_constant_outside_of_load_paths
-      assert(File.file?(@resolver.config[:root_path] + "initializers/app_extensions.rb"))
-
-      constant = @resolver.resolve("AppExtensions")
-      assert_nil(constant)
-    end
-
-    def test_discovers_constants_that_dont_have_their_own_file_using_their_parent_namespace
-      constant = @resolver.resolve(
-        "Sales::Errors::SomethingWentWrong",
-      )
-      assert_equal("::Sales::Errors::SomethingWentWrong", constant.name)
-      assert_equal("app/public/sales/errors.rb", constant.location)
-    end
-
-    def test_resolves_constant_to_most_specific_file_path
-      sales_entry_constant = @resolver.resolve("Sales::Entry")
-      sales_constant = @resolver.resolve("Sales")
-
-      assert_equal("::Sales::Entry", sales_entry_constant.name)
-      assert_equal("::Sales", sales_constant.name)
-
-      assert_equal("app/models/sales/entry.rb", sales_entry_constant.location)
-      assert_equal("app/models/sales.rb", sales_constant.location)
-    end
-
-    def test_discovers_constants_using_custom_inflector
-      constant = @resolver.resolve("GraphQL::QueryRoot")
-
-      assert_equal("::GraphQL::QueryRoot", constant.name)
-      assert_equal("app/models/graphql/query_root.rb", constant.location)
-    end
-
-    def test_discovers_constants_that_are_partially_qualified_inferring_their_full_qualification_from_parent_namespace
-      constant = @resolver.resolve(
-        "Errors",
-        current_namespace_path: ["Sales", "SomeEntrypoint"],
-      )
-      assert_equal("::Sales::Errors", constant.name)
-      assert_equal("app/public/sales/errors.rb", constant.location)
-    end
-
-    def test_discovers_constants_that_are_both_partially_qualified_and_dont_have_their_own_file
-      constant = @resolver.resolve(
-        "Errors::SomethingWentWrong",
-        current_namespace_path: ["Sales", "SomeEntrypoint"],
-      )
-      assert_equal("::Sales::Errors::SomethingWentWrong", constant.name)
-      assert_equal("app/public/sales/errors.rb", constant.location)
-    end
-
-    def test_discovers_constants_that_are_explicitly_toplevel
-      constant = @resolver.resolve("::Order")
-      assert_equal("::Order", constant.name)
-      assert_equal("app/models/order.rb", constant.location)
-    end
-
-    def test_respects_colon_colon_prefix_by_resolving_as_top_level_constant
-      constant = @resolver.resolve(
-        "Entry",
-        current_namespace_path: ["Sales", "SomeEntrypoint"],
-      )
-      assert_equal("::Sales::Entry", constant.name)
-      assert_equal("app/models/sales/entry.rb", constant.location)
-
-      constant = @resolver.resolve(
-        "::Entry",
-        current_namespace_path: ["Sales", "SomeEntrypoint"],
-      )
-      assert_equal("::Entry", constant.name)
-      assert_equal("app/models/entry.rb", constant.location)
-    end
-
-    def test_raises_if_ambiguous_file_path_structure
-      resolver = ConstantResolver.new(**@resolver.config.merge(
-        root_path: "test/fixtures/constant_discovery/invalid/",
-      ))
-      begin
-        e = assert_raises(ConstantResolver::Error) do
-          resolver.resolve("AnythingReally")
-        end
-        assert_equal(<<~MSG, e.message)
-          Ambiguous constant definition:
-
-          "Order" could refer to any of
-            app/models/order.rb
-            app/services/order.rb
-        MSG
-      end
-    end
-
     def test_raises_if_no_files
       resolver = ConstantResolver.new(**@resolver.config.merge(
         root_path: "test/fixtures/constant_discovery/empty/",
@@ -197,5 +51,14 @@ def test_raises_if_no_files
         MSG
       end
     end
+
+    def test_respects_exclude
+      resolver = ConstantResolver.new(**@resolver.config.merge(
+        exclude: ["app/models/**/*"],
+      ))
+
+      constant = resolver.resolve("Order")
+      assert_nil(constant)
+    end
   end
 end