Separate camelize and classify lookup

Previously, if you were using ActiveSupport, the lookup would use Rails'
`String#classify` method. Without ActiveSupport it'd use a patched
version which implemented classifying as camelizing a String.

As an example, if the lookup was given a symbol `:users`, it'd behave as
follows:
a) Without ActiveSupport, look for `UsersPolicy`;
b) With ActiveSupport, look for `UserPolicy`;

This change does three things. First, we add a new lookup that uses
`camelize`. This enables the lookup to find `UsersPolicy` when given
`:users` in Rails. This is the new behaviour.

Second, by changing the Symbol extension, we keep the old behaviour in
the non-Rails working.

Finally, we add a new lookup that is only used when `classify` is
available on String and uses that to infer the polict. This ensures that
finding `UserPolicy` still works in the case where we're in a Rails
application.

docs/lookup_chain.md

@@ -2,7 +2,12 @@
 
 Action Policy tries to automatically infer policy class from the target using the following _probes_:
 
-1. If the target is a `Symbol`, then use `"#{target.to_s.classify}Policy"` as a `policy_name` (see below);
+1. If the target is a `Symbol`:
+
+    a) Try `"#{target.to_s.camelize}Policy"` as a `policy_name` (see below);
+
+    b) If `String#classify` is available, e.g. when using Rails' ActiveSupport, try `"#{target.to_s.classify}Policy"`;
+
 2. If the target responds to `policy_class`, then use it;
 3. If the target's class responds to `policy_class`, then use it;
 4. If the target or the target's class responds to `policy_name`, then use it (the `policy_name` should end with `Policy` as it's not appended automatically);

lib/action_policy/ext/symbol_classify.rb → lib/action_policy/ext/symbol_camelize.rb

@@ -2,15 +2,15 @@
 
 module ActionPolicy
   module Ext
-    # Add `classify` to Symbol
-    module SymbolClassify
+    # Add `camelize` to Symbol
+    module SymbolCamelize
       refine Symbol do
-        if "".respond_to?(:classify)
-          def classify
-            to_s.classify
+        if "".respond_to?(:camelize)
+          def camelize
+            to_s.camelize
           end
         else
-          def classify
+          def camelize
             word = to_s.capitalize
             word.gsub!(/(?:_)([a-z\d]*)/) { $1.capitalize }
             word

lib/action_policy/lookup_chain.rb

@@ -12,8 +12,8 @@ module LookupChain
       using ActionPolicy::Ext::StringConstantize
     end
 
-    require "action_policy/ext/symbol_classify"
-    using ActionPolicy::Ext::SymbolClassify
+    require "action_policy/ext/symbol_camelize"
+    using ActionPolicy::Ext::SymbolCamelize
 
     require "action_policy/ext/module_namespace"
     using ActionPolicy::Ext::ModuleNamespace
@@ -114,7 +114,19 @@ def policy_class_name_for(record)
     SYMBOL_LOOKUP = ->(record, namespace: nil, **) {
       next unless record.is_a?(Symbol)
 
-      policy_name = "#{record.classify}Policy"
+      policy_name = "#{record.camelize}Policy"
+      if namespace.nil?
+        policy_name.safe_constantize
+      else
+        lookup_within_namespace(policy_name, namespace)
+      end
+    }
+
+    # (Optional) Infer using String#classify if available
+    CLASSIFY_SYMBOL_LOOKUP = ->(record, namespace: nil, **) {
+      next unless record.is_a?(Symbol)
+
+      policy_name = "#{record.to_s.classify}Policy"
       if namespace.nil?
         policy_name.safe_constantize
       else
@@ -124,10 +136,11 @@ def policy_class_name_for(record)
 
     self.chain = [
       SYMBOL_LOOKUP,
+      (CLASSIFY_SYMBOL_LOOKUP if String.method_defined?(:classify)),
       INSTANCE_POLICY_CLASS,
       CLASS_POLICY_CLASS,
       NAMESPACE_LOOKUP,
       INFER_FROM_CLASS
-    ]
+    ].compact
   end
 end

test/action_policy/ext/symbol_camelize_test.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+require "action_policy/ext/symbol_camelize"
+using ActionPolicy::Ext::SymbolCamelize
+
+class TestSymbolClassify < Minitest::Test
+  def test_simple_name
+    assert_equal "Test", :test.camelize
+  end
+
+  def test_underscored_name
+    assert_equal "TeStO", :te_st_o.camelize
+  end
+end

test/action_policy/lookup_chain_test.rb

@@ -25,6 +25,7 @@ def self.policy_class
 
 class LookupAPolicy; end
 class LookupBPolicy; end
+class LookupBsPolicy; end
 
 module LookupNamespace
   class LookupAPolicy; end
@@ -54,6 +55,13 @@ def test_symbol
     )
   end
 
+  def test_symbol_exact_match
+    assert_equal(
+      LookupBsPolicy,
+      ActionPolicy.lookup(:lookup_bs)
+    )
+  end
+
   def test_symbol_namespaced
     assert_equal(
       LookupNamespace::LookupAPolicy,

test/action_policy/rails/dummy/config/application.rb

@@ -4,6 +4,7 @@
 
 require "rails"
 require "action_controller/railtie"
+require "action_policy"
 require "action_policy/railtie"
 
 Bundler.require(*Rails.groups)

test/action_policy/rails/lookup_chain_test.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# Skip this test if the lookup chain is already defined. This is the case when
+# *not* running in isolated mode (`bundle exec rake test:isolated`).
+return if defined?(ActionPolicy::LookupChain)
+
+require_relative "./dummy/config/environment"
+require "test_helper"
+
+class EntityPolicy; end
+
+class TestLookupChain < Minitest::Test
+  def test_symbol_singular
+    assert_equal(
+      EntityPolicy,
+      ActionPolicy.lookup(:entity)
+    )
+  end
+
+  def test_symbol_plural
+    assert_equal(
+      EntityPolicy,
+      ActionPolicy.lookup(:entities)
+    )
+  end
+end