action_policy 0.4.2 → 0.5.2

data/lib/action_policy/behaviours/policy_for.rb

@@ -8,8 +8,11 @@ module ActionPolicy
       using ActionPolicy::Ext::PolicyCacheKey
 
       # Returns policy instance for the record.
-      def policy_for(record:, with: nil, namespace: authorization_namespace, context: authorization_context, allow_nil: false)
-        policy_class = with || ::ActionPolicy.lookup(record, namespace: namespace, context: context, allow_nil: allow_nil)
+      def policy_for(record:, with: nil, namespace: authorization_namespace, context: authorization_context, allow_nil: false, default: default_authorization_policy_class)
+        policy_class = with || ::ActionPolicy.lookup(
+          record,
+          **{namespace, context, allow_nil, default}
+        )
         policy_class&.new(record, **context)
       end
 
@@ -21,6 +24,10 @@ module ActionPolicy
         # override to provide specific authorization namespace
       end
 
+      def default_authorization_policy_class
+        # override to provide a policy class use when no policy found
+      end
+
       # Override this method to provide implicit authorization target
       # that would be used in case `record` is not specified in
       # `authorize!` and `allowed_to?` call.
@@ -46,7 +53,7 @@ module ActionPolicy
 
       def policy_for_cache_key(record:, with: nil, namespace: nil, context: authorization_context, **)
         record_key = record._policy_cache_key(use_object_id: true)
-        context_key = context.values.map { |v| v._policy_cache_key(use_object_id: true) }.join(".")
+        context_key = context.values.map { _1._policy_cache_key(use_object_id: true) }.join(".")
 
         "#{namespace}/#{with}/#{context_key}/#{record_key}"
       end

data/lib/action_policy/behaviours/scoping.rb

@@ -17,8 +17,9 @@ module ActionPolicy
         policy ||= policy_for(record: implicit_authorization_target!, **options)
 
         type ||= authorization_scope_type_for(policy, target)
+        name = as
 
-        Authorizer.scopify(target, policy, type: type, name: as, scope_options: scope_options)
+        Authorizer.scopify(target, policy, **{type, name, scope_options})
       end
 
       # For backward compatibility

data/lib/action_policy/behaviours/thread_memoized.rb

@@ -7,9 +7,7 @@ module ActionPolicy
     class << self
       attr_writer :enabled
 
-      def enabled?
-        @enabled == true
-      end
+      def enabled?() = @enabled == true
 
       def fetch(key)
         return yield unless enabled?

data/lib/action_policy/ext/module_namespace.rb

@@ -9,11 +9,6 @@ module ActionPolicy
         using ActionPolicy::Ext::StringConstantize
       end
 
-      unless "".respond_to?(:match?)
-        require "action_policy/ext/string_match"
-        using ActionPolicy::Ext::StringMatch
-      end
-
       module Ext
         def namespace
           return unless name&.match?(/[^^]::/)
@@ -23,7 +18,7 @@ module ActionPolicy
       end
 
       # See https://github.com/jruby/jruby/issues/5220
-      ::Module.include(Ext) if RUBY_PLATFORM =~ /java/i
+      ::Module.include(Ext) if RUBY_PLATFORM.match?(/java/i)
 
       refine Module do
         include Ext

data/lib/action_policy/ext/policy_cache_key.rb

@@ -13,77 +13,59 @@ module ActionPolicy
       module ObjectExt
         def _policy_cache_key(use_object_id: false)
           return policy_cache_key if respond_to?(:policy_cache_key)
+          return cache_key_with_version if respond_to?(:cache_key_with_version)
           return cache_key if respond_to?(:cache_key)
 
-          return object_id if use_object_id == true
+          return object_id.to_s if use_object_id == true
 
           raise ArgumentError, "object is not cacheable"
         end
       end
 
-      # JRuby doesn't support _global_ modules refinements (see https://github.com/jruby/jruby/issues/5220)
-      # Fallback to monkey-patching.
-      # TODO: remove after 9.2.7.0 (See https://github.com/jruby/jruby/pull/5627)
-      ::Object.include(ObjectExt) if RUBY_PLATFORM =~ /java/i
-
       refine Object do
         include ObjectExt
       end
 
       refine NilClass do
-        def _policy_cache_key(*)
-          ""
-        end
+        def _policy_cache_key(*) = ""
       end
 
       refine TrueClass do
-        def _policy_cache_key(*)
-          "t"
-        end
+        def _policy_cache_key(*) = "t"
       end
 
       refine FalseClass do
-        def _policy_cache_key(*)
-          "f"
-        end
+        def _policy_cache_key(*) = "f"
       end
 
       refine String do
-        def _policy_cache_key(*)
-          self
-        end
+        def _policy_cache_key(*) = self
       end
 
       refine Symbol do
-        def _policy_cache_key(*)
-          to_s
-        end
+        def _policy_cache_key(*) = to_s
       end
 
       if RUBY_PLATFORM.match?(/java/i)
         refine Integer do
-          def _policy_cache_key(*)
-            to_s
-          end
+          def _policy_cache_key(*) = to_s
         end
 
         refine Float do
-          def _policy_cache_key(*)
-            to_s
-          end
+          def _policy_cache_key(*) = to_s
         end
       else
         refine Numeric do
-          def _policy_cache_key(*)
-            to_s
-          end
+          def _policy_cache_key(*) = to_s
         end
       end
 
       refine Time do
-        def _policy_cache_key(*)
-          to_s
-        end
+        def _policy_cache_key(*) = to_s
+      end
+
+      refine Module do
+        def _policy_cache_key(*) = name
       end
     end
   end

data/lib/action_policy/ext/{symbol_classify.rb → 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

data/lib/action_policy/i18n.rb

@@ -21,7 +21,7 @@ module ActionPolicy
       private
 
       def candidates_for(policy_class, rule)
-        policy_hierarchy = policy_class.ancestors.select { |klass| klass.respond_to?(:identifier) }
+        policy_hierarchy = policy_class.ancestors.select { _1.respond_to?(:identifier) }
         [
           *policy_hierarchy.map { |klass| :"policy.#{klass.identifier}.#{rule}" },
           :"policy.#{rule}",

data/lib/action_policy/lookup_chain.rb

@@ -12,8 +12,8 @@ module ActionPolicy
       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
@@ -24,14 +24,26 @@ module ActionPolicy
       class << self
         attr_reader :store
 
-        def fetch(namespace, policy)
+        def put_if_absent(scope, namespace, policy)
+          local_store = store[scope][namespace]
+          return local_store[policy] if local_store[policy]
+          local_store[policy] ||= yield
+        end
+
+        def fetch(namespace, policy, strict:, &block)
           return yield unless LookupChain.namespace_cache_enabled?
-          return store[namespace][policy] if store[namespace].key?(policy)
-          store[namespace][policy] ||= yield
+
+          if strict
+            put_if_absent(:strict, namespace, policy, &block)
+          else
+            cached_policy = put_if_absent(:strict, namespace, policy, &block)
+            put_if_absent(:flexible, namespace, policy) { cached_policy }
+          end
         end
 
         def clear
-          @store = Hash.new { |h, k| h[k] = {} }
+          hash = Hash.new { |h, k| h[k] = {} }
+          @store = {strict: hash, flexible: hash.clone}
         end
       end
 
@@ -53,22 +65,23 @@ module ActionPolicy
 
       private
 
-      def lookup_within_namespace(policy_name, namespace)
-        NamespaceCache.fetch(namespace.name, policy_name) do
+      def lookup_within_namespace(policy_name, namespace, strict: false)
+        return unless namespace
+        NamespaceCache.fetch(namespace.name, policy_name, strict: strict) do
           mod = namespace
-
           loop do
             policy = "#{mod.name}::#{policy_name}".safe_constantize
-
             break policy unless policy.nil?
-
             mod = mod.namespace
-
-            break if mod.nil?
+            break if mod.nil? || strict
           end
         end
       end
 
+      def objectify_policy(policy_name, strict: false)
+        policy_name.safe_constantize unless strict
+      end
+
       def policy_class_name_for(record)
         return record.policy_name.to_s if record.respond_to?(:policy_name)
 
@@ -111,23 +124,30 @@ module ActionPolicy
     }
 
     # Infer from passed symbol
-    SYMBOL_LOOKUP = ->(record, namespace: nil, **) {
+    SYMBOL_LOOKUP = ->(record, namespace: nil, strict_namespace: false, **) {
       next unless record.is_a?(Symbol)
 
-      policy_name = "#{record.classify}Policy"
-      if namespace.nil?
-        policy_name.safe_constantize
-      else
-        lookup_within_namespace(policy_name, namespace)
-      end
+      policy_name = "#{record.camelize}Policy"
+      lookup_within_namespace(policy_name, namespace, strict: strict_namespace) ||
+        objectify_policy(policy_name, strict: strict_namespace)
+    }
+
+    # (Optional) Infer using String#classify if available
+    CLASSIFY_SYMBOL_LOOKUP = ->(record, namespace: nil, strict_namespace: false, **) {
+      next unless record.is_a?(Symbol)
+
+      policy_name = "#{record.to_s.classify}Policy"
+      lookup_within_namespace(policy_name, namespace, strict: strict_namespace) ||
+        objectify_policy(policy_name, strict: strict_namespace)
     }
 
     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

data/lib/action_policy/policy/aliases.rb

@@ -46,23 +46,18 @@ module ActionPolicy
           end
         end
 
-        def lookup_alias(rule)
-          rules_aliases[rule]
-        end
+        def lookup_alias(rule) = rules_aliases[rule]
 
-        def lookup_default_rule
-          rules_aliases[DEFAULT]
-        end
+        def lookup_default_rule() = rules_aliases[DEFAULT]
 
         def rules_aliases
           return @rules_aliases if instance_variable_defined?(:@rules_aliases)
 
-          @rules_aliases =
-            if superclass.respond_to?(:rules_aliases)
-              superclass.rules_aliases.dup
-            else
-              {}
-            end
+          if superclass.respond_to?(:rules_aliases)
+            superclass.rules_aliases.dup
+          else
+            {}
+          end => @rules_aliases
         end
 
         def method_added(name)

data/lib/action_policy/policy/authorization.rb

@@ -43,21 +43,17 @@ module ActionPolicy
 
       attr_reader :authorization_context
 
-      def initialize(*args, **params)
-        super(*args)
+      def initialize(record = nil, **params)
+        super(record)
 
         @authorization_context = {}
 
         self.class.authorization_targets.each do |id, opts|
-          if opts[:optional] == true
-            val = params.fetch(id, nil)
-          else
-            raise AuthorizationContextMissing, id unless params.key?(id)
+          raise AuthorizationContextMissing, id unless params.key?(id) || opts[:optional]
 
-            val = params.fetch(id)
+          val = params.fetch(id, nil)
 
-            raise AuthorizationContextMissing, id if val.nil? && opts[:allow_nil] != true
-          end
+          raise AuthorizationContextMissing, id if val.nil? && opts[:allow_nil] != true
 
           authorization_context[id] = instance_variable_set("@#{id}", val)
         end
@@ -66,9 +62,11 @@ module ActionPolicy
       end
 
       module ClassMethods # :nodoc:
-        def authorize(*ids, **opts)
+        def authorize(*ids, allow_nil: false, optional: false)
+          allow_nil ||= optional
+
           ids.each do |id|
-            authorization_targets[id] = opts
+            authorization_targets[id] = {allow_nil, optional}
           end
 
           attr_reader(*ids)
@@ -77,12 +75,11 @@ module ActionPolicy
         def authorization_targets
           return @authorization_targets if instance_variable_defined?(:@authorization_targets)
 
-          @authorization_targets =
-            if superclass.respond_to?(:authorization_targets)
-              superclass.authorization_targets.dup
-            else
-              {}
-            end
+          if superclass.respond_to?(:authorization_targets)
+            superclass.authorization_targets.dup
+          else
+            {}
+          end => @authorization_targets
         end
       end
     end

data/lib/action_policy/policy/cache.rb

@@ -3,16 +3,13 @@
 require "action_policy/version"
 
 module ActionPolicy # :nodoc:
+  using RubyNext
+
   # By default cache namespace (or prefix) contains major and minor version of the gem
   CACHE_NAMESPACE = "acp:#{ActionPolicy::VERSION.split(".").take(2).join(".")}"
 
-  require "action_policy/ext/yield_self_then"
   require "action_policy/ext/policy_cache_key"
 
-  unless "".respond_to?(:then)
-    require "action_policy/ext/yield_self_then"
-    using ActionPolicy::Ext::YieldSelfThen
-  end
   using ActionPolicy::Ext::PolicyCacheKey
 
   module Policy
@@ -26,22 +23,31 @@ module ActionPolicy # :nodoc:
         end
       end
 
-      def cache_namespace
-        ActionPolicy::CACHE_NAMESPACE
+      def cache_namespace() = ActionPolicy::CACHE_NAMESPACE
+
+      def cache_key(*parts)
+        [
+          cache_namespace,
+          *parts
+        ].map { _1._policy_cache_key }.join("/")
       end
 
-      def cache_key(rule)
-        "#{cache_namespace}/#{context_cache_key}/" \
-        "#{record._policy_cache_key}/#{self.class.name}/#{rule}"
+      def rule_cache_key(rule)
+        cache_key(
+          context_cache_key,
+          record,
+          self.class,
+          rule
+        )
       end
 
       def context_cache_key
-        authorization_context.map { |_k, v| v._policy_cache_key.to_s }.join("/")
+        authorization_context.map { _2._policy_cache_key.to_s }.join("/")
       end
 
       def apply_with_cache(rule)
         options = self.class.cached_rules.fetch(rule)
-        key = cache_key(rule)
+        key = rule_cache_key(rule)
 
         ActionPolicy.cache_store.then do |store|
           @result = store.read(key)
@@ -62,6 +68,17 @@ module ActionPolicy # :nodoc:
         apply_with_cache(rule) { super }
       end
 
+      def cache(*parts, **options)
+        key = cache_key(*parts)
+        ActionPolicy.cache_store.then do |store|
+          res = store.read(key)
+          next res unless res.nil?
+          res = yield
+          store.write(key, res, options)
+          res
+        end
+      end
+
       module ClassMethods # :nodoc:
         def cache(*rules, **options)
           rules.each do |rule|
@@ -72,12 +89,11 @@ module ActionPolicy # :nodoc:
         def cached_rules
           return @cached_rules if instance_variable_defined?(:@cached_rules)
 
-          @cached_rules =
-            if superclass.respond_to?(:cached_rules)
-              superclass.cached_rules.dup
-            else
-              {}
-            end
+          if superclass.respond_to?(:cached_rules)
+            superclass.cached_rules.dup
+          else
+            {}
+          end => @cached_rules
         end
       end
     end