action_policy 0.4.0 → 0.5.0

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

data/lib/action_policy/policy/core.rb

@@ -11,6 +11,8 @@ unless "".respond_to?(:underscore)
 end
 
 module ActionPolicy
+  using RubyNext
+
   # Raised when `resolve_rule` failed to find an approriate
   # policy rule method for the activity
   class UnknownRule < Error
@@ -75,15 +77,28 @@ module ActionPolicy
       # `apply` also calls pre-checks.
       def apply(rule)
         @result = self.class.result_class.new(self.class, rule)
-        @result.load __apply__(rule)
+
+        catch :policy_fulfilled do
+          result.load __apply__(rule)
+        end
+
+        result.value
+      end
+
+      def deny!
+        result&.load false
+        throw :policy_fulfilled
+      end
+
+      def allow!
+        result&.load true
+        throw :policy_fulfilled
       end
 
       # This method performs the rule call.
       # Override or extend it to provide custom functionality
       # (such as caching, pre checks, etc.)
-      def __apply__(rule)
-        public_send(rule)
-      end
+      def __apply__(rule) = public_send(rule)
 
       # Wrap code that could modify result
       # to prevent the current result modification
@@ -102,16 +117,16 @@ module ActionPolicy
       # If record is `nil` then we uses the current policy.
       def allowed_to?(rule, record = :__undef__, **options)
         if (record == :__undef__ || record == self.record) && options.empty?
-          __apply__(rule)
+          __apply__(resolve_rule(rule))
         else
-          policy_for(record: record, **options).apply(rule)
+          policy_for(record: record, **options).then do |policy|
+            policy.apply(policy.resolve_rule(rule))
+          end
         end
       end
 
       # An alias for readability purposes
-      def check?(*args)
-        allowed_to?(*args)
-      end
+      def check?(*args) = allowed_to?(*args)
 
       # Returns a rule name (policy method name) for activity.
       #
@@ -127,9 +142,7 @@ module ActionPolicy
       # Return annotated source code for the rule
       # NOTE: require "method_source" and "unparser" gems to be installed.
       # Otherwise returns empty string.
-      def inspect_rule(rule)
-        PrettyPrint.print_method(self, rule)
-      end
+      def inspect_rule(rule) = PrettyPrint.print_method(self, rule)
 
       # Helper for printing the annotated rule source.
       # Useful for debugging: type `pp :show?` within the context of the policy

data/lib/action_policy/policy/defaults.rb

@@ -21,17 +21,11 @@ module ActionPolicy
         base.authorize :user
       end
 
-      def index?
-        false
-      end
+      def index?() = false
 
-      def create?
-        false
-      end
+      def create?() = false
 
-      def manage?
-        false
-      end
+      def manage?() = false
     end
   end
 end

data/lib/action_policy/policy/execution_result.rb

@@ -19,21 +19,15 @@ module ActionPolicy
         @value = value
       end
 
-      def success?
-        @value == true
-      end
+      def success?() = @value == true
 
-      def fail?
-        @value == false
-      end
+      def fail?() = @value == false
 
       def cached!
         @cached = true
       end
 
-      def cached?
-        @cached == true
-      end
+      def cached?() = @cached == true
 
       def inspect
         "<#{policy}##{rule}: #{@value}>"

data/lib/action_policy/policy/pre_check.rb

@@ -31,40 +31,12 @@ module ActionPolicy
       #
       # Implements filtering logic.
       class Check
-        # Wrapper over check result
-        class Result
-          DENY = :__deny__
-          ALLOW = :__allow__
-
-          KINDS = {
-            DENY => false,
-            ALLOW => true
-          }.freeze
-
-          attr_reader :fulfilled
-
-          def initialize(val)
-            @fulfilled = KINDS.key?(val)
-            @value = val
-          end
-
-          alias fulfilled? fulfilled
-
-          def denied?
-            @value == DENY
-          end
-
-          def value
-            KINDS.fetch(@value)
-          end
-        end
-
         attr_reader :name, :policy_class
 
         def initialize(policy, name, except: nil, only: nil)
           if !except.nil? && !only.nil?
             raise ArgumentError,
-                  "Only one of `except` and `only` may be specified for pre-check"
+              "Only one of `except` and `only` may be specified for pre-check"
           end
 
           @policy_class = policy
@@ -80,23 +52,17 @@ module ActionPolicy
           filter.call(rule)
         end
 
-        def call(policy)
-          Result.new(policy.send(name)).tap do |res|
-            # add denial reason if Reasons included
-            policy.result.reasons.add(policy, name) if
-              res.denied? && policy.result.respond_to?(:reasons)
-          end
-        end
+        def call(policy) = policy.send(name)
 
         def skip!(except: nil, only: nil)
           if !except.nil? && !only.nil?
             raise ArgumentError,
-                  "Only one of `except` and `only` may be specified when skipping pre-check"
+              "Only one of `except` and `only` may be specified when skipping pre-check"
           end
 
           if except.nil? && only.nil?
             raise ArgumentError,
-                  "At least one of `except` and `only` must be specified when skipping pre-check"
+              "At least one of `except` and `only` must be specified when skipping pre-check"
           end
 
           if except
@@ -116,7 +82,12 @@ module ActionPolicy
         # rubocop: enable
 
         def dup
-          self.class.new(policy_class, name, except: blacklist&.dup, only: whitelist&.dup)
+          self.class.new(
+            policy_class,
+            name,
+            except: blacklist&.dup,
+            only: whitelist&.dup
+          )
         end
 
         private
@@ -142,21 +113,12 @@ module ActionPolicy
       def run_pre_checks(rule)
         self.class.pre_checks.each do |check|
           next unless check.applicable?(rule)
-          res = check.call(self)
-          return res.value if res.fulfilled?
+          check.call(self)
         end
 
         yield if block_given?
       end
 
-      def deny!
-        Check::Result::DENY
-      end
-
-      def allow!
-        Check::Result::ALLOW
-      end
-
       def __apply__(rule)
         run_pre_checks(rule) { super }
       end
@@ -165,7 +127,7 @@ module ActionPolicy
         def pre_check(*names, **options)
           names.each do |name|
             # do not allow pre-check override
-            check = pre_checks.find { |c| c.name == name }
+            check = pre_checks.find { _1.name == name }
             raise "Pre-check already defined: #{name}" unless check.nil?
 
             pre_checks << Check.new(self, name, **options)
@@ -174,26 +136,25 @@ module ActionPolicy
 
         def skip_pre_check(*names, **options)
           names.each do |name|
-            check = pre_checks.find { |c| c.name == name }
+            check = pre_checks.find { _1.name == name }
             raise "Pre-check not found: #{name}" if check.nil?
 
             # when no options provided we remove this check completely
             next pre_checks.delete(check) if options.empty?
 
             # otherwise duplicate and apply skip options
-            pre_checks[pre_checks.index(check)] = check.dup.tap { |c| c.skip!(**options) }
+            pre_checks[pre_checks.index(check)] = check.dup.tap { _1.skip!(**options) }
           end
         end
 
         def pre_checks
           return @pre_checks if instance_variable_defined?(:@pre_checks)
 
-          @pre_checks =
-            if superclass.respond_to?(:pre_checks)
-              superclass.pre_checks.dup
-            else
-              []
-            end
+          if superclass.respond_to?(:pre_checks)
+            superclass.pre_checks.dup
+          else
+            []
+          end => @pre_checks
         end
       end
     end