action_policy 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd1a7f10e0934ff905e63da4fe68970165813f062ee10c2534eba30acbdcb04b
-  data.tar.gz: 0e26b4d23cd11d96accad3c4ba15ff7dfbd68483b1592a98dff181afe6c699a3
+  metadata.gz: a261b126090b29222039294b84b4575fa796bf115033c2514fe301e0ec3d34af
+  data.tar.gz: 05f9d1cd84b2f4ce2b951267e0122fb54a436a5e51f0dd2f9a7d79e06f30d6ec
 SHA512:
-  metadata.gz: b9643d2b9298058b34d42717b25cb258f53d8cd1aa4314889fab4c830fe781af82e3688400453c1edb0fd41273c5abcdf77f36031d6afc984ececb666570b4f0
-  data.tar.gz: ea54f95f99eeb8e60f0554c9bc4b1ae1dccd235c34efba012c08e7a222f3ea1b6fcb873bc19fad1f147af526724e326ad913e6663a8e88b072b315f0e25e3ac4
+  metadata.gz: 80bbbe6ec61bf7241fe0e823844120292e6b8efd98a3c06834d98ac797cf92ebdffa21332e40305770622d5120d391443d0570193001a5e358f1ee6056c09bbb
+  data.tar.gz: 7f6990f7bcd5998eef536640a451591801afd073e29b25a764c500b1d0f535e3cfaf1a176f0adf930f498386ca9f206aa377b4c5adf1b2d119be642681fa7e81

data/.rubocop.yml

@@ -39,6 +39,10 @@ Naming/FileName:
    - 'Gemfile'
    - '**/*.md'
 
+Layout/InitialIndentation:
+  Exclude:
+    - 'CHANGELOG.md'
+
 Naming/UncommunicativeMethodParamName:
   Enabled: false
 

data/.travis.yml

@@ -11,7 +11,7 @@ matrix:
   include:
     - rvm: ruby-head
       gemfile: gemfiles/railsmaster.gemfile
-    - rvm: jruby-9.1.0.0
+    - rvm: jruby-9.2.0.0
       gemfile: gemfiles/jruby.gemfile
     - rvm: 2.5.1
       gemfile: Gemfile
@@ -24,5 +24,5 @@ matrix:
   allow_failures:
     - rvm: ruby-head
       gemfile: gemfiles/railsmaster.gemfile
-    - rvm: jruby-9.1.0.0
+    - rvm: jruby-9.2.0.0
       gemfile: gemfiles/jruby.gemfile

data/CHANGELOG.md

@@ -1,5 +1,26 @@
 ## master
 
+## 0.2.0 (2018-06-17)
+
+- Make `action_policy` JRuby-compatible. ([@palkan][])
+
+- Add `reasons.details`. ([@palkan][])
+
+  ```ruby
+  rescue_from ActionPolicy::Unauthorized do |ex|
+    ex.result.reasons.details #=> { stage: [:show?] }
+  end
+  ```
+
+- Add `ExecutionResult`. ([@palkan][])
+
+  ExecutionResult contains all the rule application artifacts: the result (`true` / `false`),
+  failures reasons.
+
+  This value is now stored in a cache (if any) instead of just the call result (`true` / `false`).
+
+- Add `Policy.identifier`. ([@palkan][])
+
 ## 0.1.4 (2018-06-06)
 
 - Fix Railtie injection hook. ([@palkan][])

data/docs/caching.md

@@ -155,7 +155,9 @@ Rails.application.configure do |config|
 end
 ```
 
-Cache store must provide at least a `#fetch(key, **options, &block)` method.
+Cache store must provide at least a `#read(key)` and `write(key, value, **options)` methods.
+
+**NOTE:** cache store also should take care of serialiation/deserialization since the `value` is `ExecutionResult` instance (which contains also some additional information, e.g. failure reasons). Rails cache store supports serialization/deserialization out-of-the-box.
 
 By default, Action Policy builds a cache key using the following scheme:
 

data/docs/custom_policy.md

@@ -10,10 +10,12 @@ It looks like this:
 class ActionPolicy::Base
   include ActionPolicy::Policy::Core
   include ActionPolicy::Policy::Authorization
-  include ActionPolicy::Policy::Reasons
   include ActionPolicy::Policy::PreCheck
+  include ActionPolicy::Policy::Reasons
   include ActionPolicy::Policy::Aliases
+  include ActionPolicy::Policy::Cache
   include ActionPolicy::Policy::CachedApply
+  include ActionPolicy::Policy::Defaults
 
   # ActionPolicy::Policy::Defaults module adds the following
 

data/docs/quick_start.md

@@ -74,7 +74,15 @@ end
 
 In the above case, Action Policy automatically infers a policy class and a rule to verify access: `@post -> Post -> PostPolicy`, rule is inferred from the action name (`update -> update?`), and `current_user` is used as `user` within the policy by default (read more about [authorization context](authorization_context.md)).
 
-When authorization is successful (i.e., the corresponding rule returns `true`), nothing happens, but in case of an authorization failure `ActionPolicy::Unauthorized` error is raised.
+When authorization is successful (i.e., the corresponding rule returns `true`), nothing happens, but in case of an authorization failure `ActionPolicy::Unauthorized` error is raised:
+
+```ruby
+rescue_from ActionPolicy::Unauthorized do |ex|
+  # Exception object contains the following information
+  ex.policy #=> policy class, e.g. UserPolicy
+  ex.rule #=> applied rule, e.g. :show?
+end
+```
 
 There is also an `allowed_to?` method which returns `true` or `false` and could be used, for example, in views:
 

data/docs/reasons.md

@@ -17,16 +17,23 @@ class ApplicantPolicy < ApplicationPolicy
 end
 ```
 
-When `ApplicantPolicy#show?` check fails, the exception has the `reasons` object, which contains additional information about the failure:
+When `ApplicantPolicy#show?` check fails, the exception has the `result` object, which in its turn contains additional information about the failure (`reasons`):
 
 ```ruby
 class ApplicationController < ActionController::Base
   rescue_from ActionPolicy::Unauthorized do |ex|
-    p ex.reasons.messages #=> { stage: [:show?] }
+    p ex.result.reasons.details #=> { stage: [:show?] }
+
+    # or with i18n support
+    p ex.result.reasons.full_messages #=> ["You do not have access to the stage"]
   end
 end
 ```
 
+The reason key is the corresponding policy [identifier](writing_policies.md#identifiers).
+
+**NOTE:** `full_messages` support hasn't been released yet. See [the issue](https://github.com/palkan/action_policy/issues/15).
+
 You can also wrap _local_ rules into `allowed_to?` to populate reasons:
 
 ```ruby
@@ -42,12 +49,14 @@ class ApplicantPolicy < ApplicationPolicy
 end
 
 # then the reasons object could be
-p ex.reasons.messages #=> { applicant: [:view_applicants?] }
+p ex.result.reasons.details #=> { applicant: [:view_applicants?] }
 
 # or
-p ex.reasons.messages #=> { stage: [:show?] }
+p ex.result.reasons.details #=> { stage: [:show?] }
 ```
 
+
+
 **What is the point of failure reasons?**
 
 First, you can provide a user with helpful feedback. For example, in the above scenario, when the reason is `ApplicantPolicy#view_applicants?`, you could show the following message:

data/docs/writing_policies.md

@@ -53,3 +53,39 @@ end
 ```
 
 You can also specify all the usual options (such as `with`).
+
+## Identifiers
+
+Each policy class has an `identifier`, which is by default just an underscored class name:
+
+```ruby
+class CommentPolicy < ApplicationPolicy
+end
+
+CommentPolicy.identifier #=> :comment
+```
+
+For namespaced policies it has a form of:
+
+```ruby
+module ActiveAdmin
+  class UserPolicy < ApplicationPolicy
+  end
+end
+
+ActiveAdmin::UserPolicy.identifier # => :"active_admin/user"
+```
+
+You can specify your own identifier:
+
+```ruby
+module MyVeryLong
+  class LongLongNamePolicy < ApplicationPolicy
+    self.identifier = :long_name
+  end
+end
+
+MyVeryLong::LongLongNamePolicy.identifier #=> :long_name
+```
+
+Identifiers are required for some modules, such as [failure reasons tracking](reasons.md) and [i18n](i18n.md).

data/lib/action_policy/authorizer.rb

@@ -3,13 +3,12 @@
 module ActionPolicy
   # Raised when `authorize!` check fails
   class Unauthorized < Error
-    attr_reader :policy, :rule, :reasons
+    attr_reader :policy, :rule, :result
 
     def initialize(policy, rule)
       @policy = policy.class
       @rule = rule
-      # Reasons module could be not included
-      @reasons = policy.reasons if policy.respond_to?(:reasons)
+      @result = policy.result
     end
   end
 

data/lib/action_policy/ext/module_namespace.rb

@@ -3,24 +3,31 @@
 module ActionPolicy
   module Ext
     # Add Module#namespace method
-    module ModuleNamespace
-      refine Module do
-        unless "".respond_to?(:safe_constantize)
-          require "action_policy/ext/string_constantize"
-          using ActionPolicy::Ext::StringConstantize
-        end
+    module ModuleNamespace # :nodoc: all
+      unless "".respond_to?(:safe_constantize)
+        require "action_policy/ext/string_constantize"
+        using ActionPolicy::Ext::StringConstantize
+      end
 
-        unless "".respond_to?(:match?)
-          require "action_policy/ext/string_match"
-          using ActionPolicy::Ext::StringMatch
-        end
+      unless "".respond_to?(:match?)
+        require "action_policy/ext/string_match"
+        using ActionPolicy::Ext::StringMatch
+      end
 
+      module Ext
         def namespace
           return unless name.match?(/[^^]::/)
 
           name.sub(/::[^:]+$/, "").safe_constantize
         end
       end
+
+      # See https://github.com/jruby/jruby/issues/5220
+      ::Module.include(Ext) if RUBY_PLATFORM =~ /java/i
+
+      refine Module do
+        include Ext
+      end
     end
   end
 end

data/lib/action_policy/ext/policy_cache_key.rb

@@ -9,8 +9,8 @@ module ActionPolicy
     # For other core classes returns string representation.
     #
     # Raises ArgumentError otherwise.
-    module PolicyCacheKey
-      refine Object do
+    module PolicyCacheKey # :nodoc: all
+      module ObjectExt
         def _policy_cache_key(use_object_id: false)
           return policy_cache_key if respond_to?(:policy_cache_key)
           return cache_key if respond_to?(:cache_key)
@@ -21,6 +21,14 @@ module ActionPolicy
         end
       end
 
+      # JRuby doesn't support _global_ modules refinements (see https://github.com/jruby/jruby/issues/5220)
+      # Fallback to monkey-patching.
+      ::Object.include(ObjectExt) if RUBY_PLATFORM =~ /java/i
+
+      refine Object do
+        include ObjectExt
+      end
+
       refine NilClass do
         def _policy_cache_key(*)
           ""
@@ -51,9 +59,23 @@ module ActionPolicy
         end
       end
 
-      refine Numeric do
-        def _policy_cache_key(*)
-          to_s
+      if RUBY_PLATFORM =~ /java/i
+        refine Integer do
+          def _policy_cache_key(*)
+            to_s
+          end
+        end
+
+        refine Float do
+          def _policy_cache_key(*)
+            to_s
+          end
+        end
+      else
+        refine Numeric do
+          def _policy_cache_key(*)
+            to_s
+          end
         end
       end
 

data/lib/action_policy/ext/string_underscore.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module ActionPolicy
+  module Ext
+    # Add underscore to String
+    module StringUnderscore
+      refine String do
+        def underscore
+          word = gsub(/::/, "/")
+          word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+          word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+          word.downcase!
+          word
+        end
+      end
+    end
+  end
+end

data/lib/action_policy/ext/yield_self_then.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ActionPolicy
+  module Ext # :nodoc: all
+    # Add yield_self and then if missing
+    module YieldSelfThen
+      module Ext
+        unless nil.respond_to?(:yield_self)
+          def yield_self
+            yield self
+          end
+        end
+
+        alias then yield_self
+      end
+
+      # See https://github.com/jruby/jruby/issues/5220
+      ::Object.include(Ext) if RUBY_PLATFORM =~ /java/i
+
+      refine Object do
+        include Ext
+      end
+    end
+  end
+end

data/lib/action_policy/policy/aliases.rb

@@ -7,7 +7,7 @@ module ActionPolicy
     #
     #   class ApplicationPolicy
     #     include ActionPolicy::Policy::Core
-    #     prepend ActionPolicy::Policy::Aliases
+    #     include ActionPolicy::Policy::Aliases
     #
     #     # define which rule to use if `authorize!` called with
     #     # unknown rule
@@ -23,19 +23,14 @@ module ActionPolicy
       DEFAULT = :__default__
 
       class << self
-        def prepended(base)
+        def included(base)
           base.extend ClassMethods
-          base.prepend InstanceMethods
         end
-
-        alias included prepended
       end
 
-      module InstanceMethods # :nodoc:
-        def resolve_rule(activity)
-          return activity if respond_to?(activity)
-          self.class.lookup_alias(activity) || super
-        end
+      def resolve_rule(activity)
+        return activity if respond_to?(activity)
+        self.class.lookup_alias(activity) || super
       end
 
       module ClassMethods # :nodoc:

data/lib/action_policy/policy/authorization.rb

@@ -36,34 +36,29 @@ module ActionPolicy
     #   ApplicantPolicy.new(user: user, account: account)
     module Authorization
       class << self
-        def prepended(base)
+        def included(base)
           base.extend ClassMethods
-          base.prepend InstanceMethods
         end
-
-        alias included prepended
       end
 
       attr_reader :authorization_context
 
-      module InstanceMethods # :nodoc:
-        def initialize(*args, **params)
-          super(*args)
-
-          @authorization_context = {}
+      def initialize(*args, **params)
+        super(*args)
 
-          self.class.authorization_targets.each do |id, opts|
-            raise AuthorizationContextMissing, id unless params.key?(id)
+        @authorization_context = {}
 
-            val = params.fetch(id)
+        self.class.authorization_targets.each do |id, opts|
+          raise AuthorizationContextMissing, id unless params.key?(id)
 
-            raise AuthorizationContextMissing, id if val.nil? && opts[:allow_nil] != true
+          val = params.fetch(id)
 
-            authorization_context[id] = instance_variable_set("@#{id}", val)
-          end
+          raise AuthorizationContextMissing, id if val.nil? && opts[:allow_nil] != true
 
-          authorization_context.freeze
+          authorization_context[id] = instance_variable_set("@#{id}", val)
         end
+
+        authorization_context.freeze
       end
 
       module ClassMethods # :nodoc:

data/lib/action_policy/policy/cache.rb

@@ -6,7 +6,10 @@ module ActionPolicy # :nodoc:
   # 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"
+
+  using ActionPolicy::Ext::YieldSelfThen
   using ActionPolicy::Ext::PolicyCacheKey
 
   module Policy
@@ -15,12 +18,9 @@ module ActionPolicy # :nodoc:
     # NOTE: if cache_store is nil then we silently skip all the caching.
     module Cache
       class << self
-        def prepended(base)
+        def included(base)
           base.extend ClassMethods
-          base.prepend InstanceMethods
         end
-
-        alias included prepended
       end
 
       def cache_namespace
@@ -36,19 +36,26 @@ module ActionPolicy # :nodoc:
         authorization_context.map { |_k, v| v._policy_cache_key.to_s }.join("/")
       end
 
+      # rubocop: disable Metrics/AbcSize
       def apply_with_cache(rule)
         options = self.class.cached_rules.fetch(rule)
+        key = cache_key(rule)
 
-        ActionPolicy.cache_store.fetch(cache_key(rule), options) { yield }
+        ActionPolicy.cache_store.then do |store|
+          @result = store.read(key)
+          next result.value unless result.nil?
+          yield
+          store.write(key, result, options)
+          result.value
+        end
       end
+      # rubocop: enable Metrics/AbcSize
 
-      module InstanceMethods # :nodoc:
-        def apply(rule)
-          return super if ActionPolicy.cache_store.nil? ||
-                          !self.class.cached_rules.key?(rule)
+      def apply(rule)
+        return super if ActionPolicy.cache_store.nil? ||
+                        !self.class.cached_rules.key?(rule)
 
-          apply_with_cache(rule) { super }
-        end
+        apply_with_cache(rule) { super }
       end
 
       module ClassMethods # :nodoc:

data/lib/action_policy/policy/cached_apply.rb

@@ -7,21 +7,19 @@ module ActionPolicy
     # When you call `apply` twice on the same policy and for the same rule,
     # the check (and pre-checks) is only called once.
     module CachedApply
-      class << self
-        def prepended(base)
-          base.prepend InstanceMethods
+      def apply(rule)
+        @__rules_cache__ ||= {}
+
+        if @__rules_cache__.key?(rule)
+          @result = @__rules_cache__[rule]
+          return result.value
         end
 
-        alias included prepended
-      end
+        super
 
-      module InstanceMethods # :nodoc:
-        def apply(rule)
-          @__rules_cache__ ||= {}
-          return @__rules_cache__[rule] if @__rules_cache__.key?(rule)
+        @__rules_cache__[rule] = result
 
-          @__rules_cache__[rule] = super
-        end
+        result.value
       end
     end
   end

data/lib/action_policy/policy/core.rb

@@ -1,6 +1,12 @@
 # frozen_string_literal: true
 
 require "action_policy/behaviours/policy_for"
+require "action_policy/policy/execution_result"
+
+unless "".respond_to?(:underscore)
+  require "action_policy/ext/string_underscore"
+  using ActionPolicy::Ext::StringUnderscore
+end
 
 module ActionPolicy
   # Raised when `resolve_rule` failed to find an approriate
@@ -18,35 +24,80 @@ module ActionPolicy
   module Policy
     # Core policy API
     module Core
+      class << self
+        def included(base)
+          base.extend ClassMethods
+
+          # Generate a new class for each _policy chain_
+          # in order to extend it independently
+          base.module_eval do
+            @result_class = Class.new(ExecutionResult)
+
+            # we need to make this class _named_,
+            # 'cause anonymous classes couldn't be marshalled
+            base.const_set(:APR, @result_class)
+          end
+        end
+      end
+
+      module ClassMethods # :nodoc:
+        attr_writer :identifier
+
+        def result_class
+          return @result_class if instance_variable_defined?(:@result_class)
+          @result_class = superclass.result_class
+        end
+
+        def identifier
+          return @identifier if instance_variable_defined?(:@identifier)
+
+          @identifier = name.sub(/Policy$/, "").underscore.to_sym
+        end
+      end
+
       include ActionPolicy::Behaviours::PolicyFor
 
-      attr_reader :record
+      attr_reader :record, :result
 
       def initialize(record = nil)
         @record = record
       end
 
-      # Returns a result of applying the specified rule.
+      # Returns a result of applying the specified rule (true of false).
       # Unlike simply calling a predicate rule (`policy.manage?`),
       # `apply` also calls pre-checks.
       def apply(rule)
+        @result = self.class.result_class.new
+        @result.load __apply__(rule)
+      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
 
+      # Wrap code that could modify result
+      # to prevent the current result modification
+      def with_clean_result
+        was_result = @result
+        res = yield
+        @result = was_result
+        res
+      end
+
       # Returns a result of applying the specified rule to the specified record.
       # Under the hood a policy class for record is resolved
       # (unless it's explicitly set through `with` option).
       #
       # If record is `nil` then we uses the current policy.
       def allowed_to?(rule, record = :__undef__, **options)
-        policy =
-          if record == :__undef__
-            self
-          else
-            policy_for(record: record, **options)
-          end
-
-        policy.apply(rule)
+        if record == :__undef__
+          __apply__(rule)
+        else
+          policy_for(record: record, **options).apply(rule)
+        end
       end
 
       # Returns a rule name (policy method name) for activity.

data/lib/action_policy/policy/execution_result.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ActionPolicy
+  module Policy
+    # Result of applying a policy rule
+    #
+    # This class could be extended by some modules to provide
+    # additional functionality
+    class ExecutionResult
+      attr_reader :value
+
+      # Populate the final value
+      def load(value)
+        @value = value
+      end
+
+      def success?
+        @value == true
+      end
+
+      def fail?
+        @value == false
+      end
+    end
+  end
+end

data/lib/action_policy/policy/pre_check.rb

@@ -83,8 +83,8 @@ module ActionPolicy
         def call(policy)
           Result.new(policy.send(name)).tap do |res|
             # add denial reason if Reasons included
-            policy.reasons.add(policy_class, name) if
-              res.denied? && policy.respond_to?(:reasons)
+            policy.result.reasons.add(policy, name) if
+              res.denied? && policy.result.respond_to?(:reasons)
           end
         end
 
@@ -136,12 +136,9 @@ module ActionPolicy
       end
 
       class << self
-        def prepended(base)
+        def included(base)
           base.extend ClassMethods
-          base.prepend InstanceMethods
         end
-
-        alias included prepended
       end
 
       def run_pre_checks(rule)
@@ -162,10 +159,8 @@ module ActionPolicy
         Check::Result::ALLOW
       end
 
-      module InstanceMethods # :nodoc:
-        def apply(rule)
-          run_pre_checks(rule) { super }
-        end
+      def __apply__(rule)
+        run_pre_checks(rule) { super }
       end
 
       module ClassMethods # :nodoc:

data/lib/action_policy/policy/reasons.rb

@@ -2,28 +2,33 @@
 
 module ActionPolicy
   module Policy
-    class FailureReason # :nodoc:
-      attr_reader :policy, :rule
+    # Failures reasons store
+    class FailureReasons
+      attr_reader :details
 
-      def initialize(policy_or_class, rule)
-        @policy = policy_or_class.is_a?(Class) ? policy_or_class : policy_or_class.class
-        @rule = rule
+      def initialize
+        @details = {}
       end
-    end
 
-    # Failures reasons store
-    class FailureReasons
-      include Enumerable
-      extend Forwardable
+      def add(policy_or_class, rule)
+        policy_class = policy_or_class.is_a?(Class) ? policy_or_class : policy_or_class.class
+        details[policy_class.identifier] ||= []
+        details[policy_class.identifier] << rule
+      end
 
-      def_delegators :@reasons, :size, :empty?, :last, :each
+      def empty?
+        details.empty?
+      end
 
-      def initialize
-        @reasons = []
+      def present?
+        !empty?
       end
+    end
 
-      def add(policy, rule)
-        @reasons << FailureReason.new(policy, rule)
+    # Extend ExecutionResult with `reasons` method
+    module ResultFailureReasons
+      def reasons
+        @reasons ||= FailureReasons.new
       end
     end
 
@@ -45,9 +50,21 @@ module ActionPolicy
     # information about the failure:
     #
     #   rescue_from ActionPolicy::Unauthorized do |ex|
-    #     ex.reasons.messages  #=> { stage: [:show] }
+    #     ex.policy #=> ApplicantPolicy
+    #     ex.rule #=> :show?
+    #     ex.result.reasons.details  #=> { stage: [:show?] }
+    #   end
+    #
+    # NOTE: the reason key (`stage`) is a policy identifier (underscored class name by default).
+    # For namespaced policies it has a form of:
+    #
+    #   class Admin::UserPolicy < ApplicationPolicy
+    #     # ..
     #   end
     #
+    #   reasons.details #=> { :"admin/user" => [:show?] }
+    #
+    #
     # You can also wrap _local_ rules into `allowed_to?` to populate reasons:
     #
     #   class ApplicantPolicy < ApplicationPolicy
@@ -62,48 +79,29 @@ module ActionPolicy
     #   end
     module Reasons
       class << self
-        def prepended(base)
-          base.prepend InstanceMethods
+        def included(base)
+          base.result_class.include(ResultFailureReasons)
         end
-
-        alias included prepended
       end
 
-      attr_reader :reasons
+      # rubocop: disable Metrics/MethodLength
+      def allowed_to?(rule, record = :__undef__, **options)
+        policy = nil
 
-      def with_clean_reasons # :nodoc:
-        old_reasons = reasons
-        @reasons = nil
-        res = yield
-        @reasons = old_reasons
-        res
-      end
+        succeed =
+          if record == :__undef__
+            policy = self
+            with_clean_result { apply(rule) }
+          else
+            policy = policy_for(record: record, **options)
 
-      module InstanceMethods # :nodoc:
-        def apply(rule)
-          @reasons = FailureReasons.new
-          super
-        end
-
-        # rubocop: disable Metrics/MethodLength
-        def allowed_to?(rule, record = :__undef__, **options)
-          policy = nil
-
-          succeed =
-            if record == :__undef__
-              policy = self
-              with_clean_reasons { apply(rule) }
-            else
-              policy = policy_for(record: record, **options)
+            policy.apply(rule)
+          end
 
-              policy.apply(rule)
-            end
-
-          reasons.add(policy, rule) if reasons && !succeed
-          succeed
-        end
-        # rubocop: enable Metrics/MethodLength
+        result.reasons.add(policy, rule) unless succeed
+        succeed
       end
+      # rubocop: enable Metrics/MethodLength
     end
   end
 end

data/lib/action_policy/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActionPolicy
-  VERSION = "0.1.4"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: action_policy
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - Vladimir Dementyev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-06 00:00:00.000000000 Z
+date: 2018-06-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -163,6 +163,8 @@ files:
 - lib/action_policy/ext/policy_cache_key.rb
 - lib/action_policy/ext/string_constantize.rb
 - lib/action_policy/ext/string_match.rb
+- lib/action_policy/ext/string_underscore.rb
+- lib/action_policy/ext/yield_self_then.rb
 - lib/action_policy/lookup_chain.rb
 - lib/action_policy/policy/aliases.rb
 - lib/action_policy/policy/authorization.rb
@@ -170,6 +172,7 @@ files:
 - lib/action_policy/policy/cached_apply.rb
 - lib/action_policy/policy/core.rb
 - lib/action_policy/policy/defaults.rb
+- lib/action_policy/policy/execution_result.rb
 - lib/action_policy/policy/pre_check.rb
 - lib/action_policy/policy/reasons.rb
 - lib/action_policy/rails/channel.rb