action_policy 0.4.2 → 0.5.2

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

data/lib/action_policy/policy/reasons.rb

@@ -1,16 +1,8 @@
 # frozen_string_literal: true
 
-unless "".respond_to?(:then)
-  require "action_policy/ext/yield_self_then"
-  using ActionPolicy::Ext::YieldSelfThen
-end
-
-unless {}.respond_to?(:transform_keys)
-  require "action_policy/ext/hash_transform_keys"
-  using ActionPolicy::Ext::HashTransformKeys
-end
-
 module ActionPolicy
+  using RubyNext
+
   module Policy
     # Failures reasons store
     class FailureReasons
@@ -33,17 +25,11 @@ module ActionPolicy
 
       # Return Hash of the form:
       #   { policy_identifier => [rules, ...] }
-      def details
-        reasons.transform_keys(&:identifier)
-      end
+      def details() = reasons.transform_keys(&:identifier)
 
-      def empty?
-        reasons.empty?
-      end
+      def empty?() = reasons.empty?
 
-      def present?
-        !empty?
-      end
+      def present?() = !empty?
 
       private
 
@@ -82,6 +68,25 @@ module ActionPolicy
         @details = nil
       end
 
+      # Returns all the details merged together
+      def all_details
+        return @all_details if defined?(@all_details)
+
+        {}.tap do |all|
+          next unless defined?(@reasons)
+
+          reasons.reasons.each_value do |rules|
+            detailed_reasons = rules.last
+
+            next unless detailed_reasons.is_a?(Hash)
+
+            detailed_reasons.each_value do |details|
+              all.merge!(details)
+            end
+          end
+        end => @all_details
+      end
+
       # Add reasons to inspect
       def inspect
         super.then do |str|
@@ -180,21 +185,28 @@ module ActionPolicy
       def allowed_to?(rule, record = :__undef__, **options)
         res =
           if (record == :__undef__ || record == self.record) && options.empty?
+            rule = resolve_rule(rule)
             policy = self
             with_clean_result { apply(rule) }
           else
             policy = policy_for(record: record, **options)
+            rule = policy.resolve_rule(rule)
 
             policy.apply(rule)
             policy.result
           end
 
-        result.reasons.add(policy, rule, res.details) if res.fail?
+        result&.reasons&.add(policy, rule, res.details) if res.fail?
 
         res.clear_details
 
         res.success?
       end
+
+      def deny!(reason = nil)
+        result&.reasons&.add(self, reason) if reason
+        super()
+      end
     end
   end
 end

data/lib/action_policy/policy/scoping.rb

@@ -148,12 +148,11 @@ module ActionPolicy
         def scope_matchers
           return @scope_matchers if instance_variable_defined?(:@scope_matchers)
 
-          @scope_matchers =
-            if superclass.respond_to?(:scope_matchers)
-              superclass.scope_matchers.dup
-            else
-              []
-            end
+          if superclass.respond_to?(:scope_matchers)
+            superclass.scope_matchers.dup
+          else
+            []
+          end => @scope_matchers
         end
       end
     end

data/lib/action_policy/rails/controller.rb

@@ -26,6 +26,7 @@ module ActionPolicy
       helper_method :allowed_to? if respond_to?(:helper_method)
 
       attr_writer :authorize_count
+      attr_reader :verify_authorized_skipped
 
       protected :authorize_count=, :authorize_count
     end
@@ -57,13 +58,17 @@ module ActionPolicy
 
     def verify_authorized
       raise UnauthorizedAction.new(controller_path, action_name) if
-        authorize_count.zero?
+        authorize_count.zero? && !verify_authorized_skipped
     end
 
     def authorize_count
       @authorize_count ||= 0
     end
 
+    def skip_verify_authorized!
+      @verify_authorized_skipped = true
+    end
+
     class_methods do
       # Adds after_action callback to check that
       # authorize! method has been called.

data/lib/action_policy/rails/ext/active_record.rb

@@ -7,4 +7,11 @@ ActiveRecord::Relation.include(Module.new do
   def policy_cache_key
     object_id
   end
+
+  # Explicitly define the policy_class method to avoid
+  # making Relation immutable (by initializing `arel` in `#respond_to_missing?).
+  # See https://github.com/palkan/action_policy/issues/101
+  def policy_class
+    nil
+  end
 end)

data/lib/action_policy/rails/policy/instrumentation.rb

@@ -11,7 +11,7 @@ module ActionPolicy # :nodoc:
         INIT_EVENT_NAME = "action_policy.init"
         APPLY_EVENT_NAME = "action_policy.apply_rule"
 
-        def initialize(*)
+        def initialize(record = nil, **params)
           event = {policy: self.class.name}
           ActiveSupport::Notifications.instrument(INIT_EVENT_NAME, event) { super }
         end

data/lib/action_policy/rspec/be_authorized_to.rb

@@ -45,16 +45,14 @@ module ActionPolicy
 
         @actual_calls = ActionPolicy::Testing::AuthorizeTracker.calls
 
-        actual_calls.any? { |call| call.matches?(policy, rule, target) }
+        actual_calls.any? { _1.matches?(policy, rule, target) }
       end
 
       def does_not_match?(*)
         raise "This matcher doesn't support negation"
       end
 
-      def supports_block_expectations?
-        true
-      end
+      def supports_block_expectations?() = true
 
       def failure_message
         "expected #{formatted_record} " \
@@ -72,14 +70,12 @@ module ActionPolicy
       end
 
       def formatted_calls
-        actual_calls.map do |acall|
-          " - #{acall.inspect}"
+        actual_calls.map do
+          " - #{_1.inspect}"
         end.join("\n")
       end
 
-      def formatted_record(record = target)
-        ::RSpec::Support::ObjectFormatter.format(record)
-      end
+      def formatted_record(record = target) = ::RSpec::Support::ObjectFormatter.format(record)
     end
   end
 end