action_policy 0.7.3 → 0.7.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 21363e4337fbe0caea24309750d79d94bb9fa6c4ae0a9d0697b0e686519fa763
-  data.tar.gz: 8ac572534b621240640723ea5c6ec942a73b91e14f2d40e534889c2dc7ba9251
+  metadata.gz: c2ca6d3ab4293001cc4b07e7fe5503a8c06a8b72684c0f7a9c4e7a4ef8a32c89
+  data.tar.gz: f1e726704611a3bc9ade5d3466fd64c4a5c9faddf5aa8338f3179ec4da2381e5
 SHA512:
-  metadata.gz: c1dd33d739cfdf1143b7cc2402c2e8bf7ebf1f1613fa7c650c72fddf0bd4fd4b5c924c920ff143ad582ab68524836f0d0c32641372c5999fdd95f6d9113078dc
-  data.tar.gz: 5fb9dbd9b1f19fb6bed19ddbeb99be9bd35495b2d0f89bd3fb0cd8fed59a0513c4a627fdd25291b56dcfc7cf9b60f64d351bb2b658d97351f9a7b5db2d1c4128
+  metadata.gz: aa35a3efefa37fc64066a78899b9b03a2283e2458471425a2e7cc2bc0b4ff829e87beda744057866f661e37fc54f14d094ba0fc446ea155537042478109576a7
+  data.tar.gz: d90069b7a1b3bea22c2d5e6dd990231f1bf24f85fd50081a92a54bcd5c271faa42f40c9c526a8434abd793e6f4c928b5cb28d4dad3fbaeb2bf3701f67fd4fd21

data/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## master
 
+## 0.7.4 (2025-03-12)
+
+- Let authorize! return the policy record ([@sedubois][])
+
+- Enable `allowance_to` as a helper method by default ([@stephannv][])
+
+- Allow the `:through` option of `authorize` to be passed a proc ([@brendon][])
+
 ## 0.7.3 (2024-12-18)
 
 - Fix keeping the result object in concurrent (Fiber-ed) execution environments. ([@palkan][])
@@ -539,3 +547,5 @@ This value is now stored in a cache (if any) instead of just the call result (`t
 [@matsales28]: https://github.com/matsales28
 [@killondark]: https://github.com/killondark
 [@Spone]: https://github.com/Spone
+[@stephannv]: https://github.com/stephannv
+[@sedubois]: https://github.com/sedubois

data/lib/.rbnext/3.0/action_policy/policy/pre_check.rb

@@ -78,8 +78,6 @@ module ActionPolicy
 
           rebuild_filter
         end
-        # rubocop: enable
-        # rubocop: enable
 
         def dup
           self.class.new(

data/lib/.rbnext/3.0/action_policy/policy/reasons.rb

@@ -27,6 +27,8 @@ module ActionPolicy
       #   { policy_identifier => [rules, ...] }
       def details() ;  reasons.transform_keys(&:identifier); end
 
+      alias_method :to_h, :details
+
       def empty?() ;  reasons.empty?; end
 
       def present?() ;  !empty?; end

data/lib/action_policy/behaviour.rb

@@ -33,11 +33,13 @@ module ActionPolicy
     # Policy is inferred from record
     # (unless explicitly specified through `with` option).
     #
+    # @return the policy record
     # Raises `ActionPolicy::Unauthorized` if check failed.
     def authorize!(record = :__undef__, to:, **options)
       policy = lookup_authorization_policy(record, **options)
 
       Authorizer.call(policy, authorization_rule_for(policy, to))
+      policy.record
     end
 
     # Checks that an activity is allowed for the current context (e.g. user).
@@ -62,8 +64,8 @@ module ActionPolicy
 
     private def build_authorization_context
       self.class.authorization_targets
-        .each_with_object({}) do |(key, meth), obj|
-        obj[key] = send(meth)
+        .each_with_object({}) do |(key, method_or_proc), obj|
+        obj[key] = method_or_proc.is_a?(Proc) ? method_or_proc.call : send(method_or_proc)
       end
     end
 
@@ -103,8 +105,8 @@ module ActionPolicy
       #     authorize :user
       #   end
       def authorize(key, through: nil)
-        meth = through || key
-        authorization_targets[key] = meth
+        method_or_proc = through || key
+        authorization_targets[key] = method_or_proc
       end
 
       def authorization_targets

data/lib/action_policy/policy/pre_check.rb

@@ -78,8 +78,6 @@ module ActionPolicy
 
           rebuild_filter
         end
-        # rubocop: enable
-        # rubocop: enable
 
         def dup
           self.class.new(

data/lib/action_policy/policy/reasons.rb

@@ -27,6 +27,8 @@ module ActionPolicy
       #   { policy_identifier => [rules, ...] }
       def details() = reasons.transform_keys(&:identifier)
 
+      alias_method :to_h, :details
+
       def empty?() = reasons.empty?
 
       def present?() = !empty?

data/lib/action_policy/rails/controller.rb

@@ -26,6 +26,7 @@ module ActionPolicy
       if respond_to?(:helper_method)
         helper_method :allowed_to?
         helper_method :authorized_scope
+        helper_method :allowance_to
       end
 
       attr_writer :authorize_count
@@ -44,13 +45,15 @@ module ActionPolicy
     # If record is not provided, tries to infer the resource class
     # from controller name (i.e. `controller_name.classify.safe_constantize`).
     #
+    # @return the policy record
     # Raises `ActionPolicy::Unauthorized` if check failed.
     def authorize!(record = :__undef__, to: nil, **options)
       to ||= :"#{action_name}?"
 
-      super
+      policy_record = super
 
       self.authorize_count += 1
+      policy_record
     end
 
     # Tries to infer the resource class from controller name

data/lib/action_policy/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: action_policy
 version: !ruby/object:Gem::Version
-  version: 0.7.3
+  version: 0.7.4
 platform: ruby
 authors:
 - Vladimir Dementyev
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-18 00:00:00.000000000 Z
+date: 2025-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-next-core
@@ -133,15 +133,6 @@ files:
 - LICENSE.txt
 - README.md
 - config/rubocop-rspec.yml
-- lib/.rbnext/2.7/action_policy/behaviours/policy_for.rb
-- lib/.rbnext/2.7/action_policy/i18n.rb
-- lib/.rbnext/2.7/action_policy/policy/cache.rb
-- lib/.rbnext/2.7/action_policy/policy/pre_check.rb
-- lib/.rbnext/2.7/action_policy/rails/scope_matchers/action_controller_params.rb
-- lib/.rbnext/2.7/action_policy/rails/scope_matchers/active_record.rb
-- lib/.rbnext/2.7/action_policy/rspec/be_authorized_to.rb
-- lib/.rbnext/2.7/action_policy/rspec/have_authorized_scope.rb
-- lib/.rbnext/2.7/action_policy/utils/pretty_print.rb
 - lib/.rbnext/3.0/action_policy/behaviours/policy_for.rb
 - lib/.rbnext/3.0/action_policy/behaviours/thread_memoized.rb
 - lib/.rbnext/3.0/action_policy/ext/policy_cache_key.rb
@@ -152,6 +143,8 @@ files:
 - lib/.rbnext/3.0/action_policy/policy/execution_result.rb
 - lib/.rbnext/3.0/action_policy/policy/pre_check.rb
 - lib/.rbnext/3.0/action_policy/policy/reasons.rb
+- lib/.rbnext/3.0/action_policy/rails/scope_matchers/action_controller_params.rb
+- lib/.rbnext/3.0/action_policy/rails/scope_matchers/active_record.rb
 - lib/.rbnext/3.0/action_policy/rspec/be_an_alias_of.rb
 - lib/.rbnext/3.0/action_policy/rspec/be_authorized_to.rb
 - lib/.rbnext/3.0/action_policy/rspec/have_authorized_scope.rb
@@ -234,7 +227,7 @@ metadata:
   documentation_uri: https://actionpolicy.evilmartians.io/
   homepage_uri: https://actionpolicy.evilmartians.io/
   source_code_uri: http://github.com/palkan/action_policy
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -250,7 +243,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.4.19
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Authorization framework for Ruby/Rails application
 test_files: []

data/lib/.rbnext/2.7/action_policy/behaviours/policy_for.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-module ActionPolicy
-  module Behaviours
-    # Adds `policy_for` method
-    module PolicyFor
-      require "action_policy/ext/policy_cache_key"
-      using ActionPolicy::Ext::PolicyCacheKey
-
-      # Returns policy instance for the record.
-      def policy_for(record:, with: nil, namespace: authorization_namespace, context: nil, allow_nil: false, default: default_authorization_policy_class, strict_namespace: authorization_strict_namespace)
-        context = context ? build_authorization_context.merge(context) : authorization_context
-
-        policy_class = with || ::ActionPolicy.lookup(
-          record,
-          namespace: namespace, context: context, allow_nil: allow_nil, default: default, strict_namespace: strict_namespace
-        )
-        policy_class&.new(record, **context)
-      end
-
-      def authorization_context ;  @authorization_context ||= build_authorization_context; end
-
-      def build_authorization_context
-        Kernel.raise NotImplementedError, "Please, define `build_authorization_context` method!"
-      end
-
-      def authorization_namespace
-        # override to provide specific authorization namespace
-      end
-
-      def default_authorization_policy_class
-        # override to provide a policy class use when no policy found
-      end
-
-      def authorization_strict_namespace
-        # override to provide strict namespace lookup option
-      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.
-      #
-      # It is also used to infer a policy for scoping (in `authorized_scope` method).
-      def implicit_authorization_target
-        # no-op
-      end
-
-      # Return implicit authorization target or raises an exception if it's nil
-      def implicit_authorization_target!
-        implicit_authorization_target || Kernel.raise(
-          NotFound,
-          [
-            self,
-            "Couldn't find implicit authorization target " \
-            "for #{self.class}. " \
-            "Please, provide policy class explicitly using `with` option or " \
-            "define the `implicit_authorization_target` method."
-          ]
-        )
-      end
-
-      def policy_for_cache_key(record:, with: nil, namespace: nil, context: authorization_context, **__kwrest__)
-        record_key = record._policy_cache_key(use_object_id: true)
-        context_key = context.values.map { |_1| _1._policy_cache_key(use_object_id: true) }.join(".")
-
-        "#{namespace}/#{with}/#{context_key}/#{record_key}"
-      end
-    end
-  end
-end

data/lib/.rbnext/2.7/action_policy/i18n.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module ActionPolicy
-  module I18n # :nodoc:
-    DEFAULT_UNAUTHORIZED_MESSAGE = "You are not authorized to perform this action"
-
-    class << self
-      def full_message(policy_class, rule, details = nil)
-        candidates = candidates_for(policy_class, rule)
-
-        options = {scope: :action_policy}
-        options.merge!(details) unless details.nil?
-
-        ::I18n.t(
-          candidates.shift,
-          default: candidates,
-          **options
-        )
-      end
-
-      private
-
-      def candidates_for(policy_class, rule)
-        policy_hierarchy = policy_class.ancestors.select { |_1| _1.respond_to?(:identifier) }
-        [
-          *policy_hierarchy.map { |klass| :"policy.#{klass.identifier}.#{rule}" },
-          :"policy.#{rule}",
-          :unauthorized,
-          DEFAULT_UNAUTHORIZED_MESSAGE
-        ]
-      end
-    end
-
-    ActionPolicy::Policy::FailureReasons.prepend(Module.new do
-      def full_messages
-        reasons.flat_map do |policy_klass, rules|
-          rules.flat_map do |rule|
-            if rule.is_a?(::Hash)
-              rule.map do |key, details|
-                ActionPolicy::I18n.full_message(policy_klass, key, details)
-              end
-            else
-              ActionPolicy::I18n.full_message(policy_klass, rule)
-            end
-          end
-        end
-      end
-    end)
-
-    ActionPolicy::Policy::ExecutionResult.prepend(Module.new do
-      def message
-        ActionPolicy::I18n.full_message(policy, rule, details)
-      end
-    end)
-  end
-end

data/lib/.rbnext/2.7/action_policy/policy/cache.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-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/policy_cache_key"
-
-  using ActionPolicy::Ext::PolicyCacheKey
-
-  module Policy
-    # Provides long-lived cache through ActionPolicy.cache_store.
-    #
-    # NOTE: if cache_store is nil then we silently skip all the caching.
-    module Cache
-      class << self
-        def included(base)
-          base.extend ClassMethods
-        end
-      end
-
-      def cache_namespace() ;  ActionPolicy::CACHE_NAMESPACE; end
-
-      def cache_key(*parts)
-        [
-          cache_namespace,
-          *parts
-        ].map { |_1| _1._policy_cache_key }.join("/")
-      end
-
-      def rule_cache_key(rule)
-        cache_key(
-          context_cache_key,
-          record,
-          self.class,
-          rule
-        )
-      end
-
-      def context_cache_key
-        authorization_context.map { |_1, _2| _2._policy_cache_key.to_s }.join("/")
-      end
-
-      def apply_with_cache(rule)
-        options = self.class.cached_rules.fetch(rule)
-        key = rule_cache_key(rule)
-
-        ActionPolicy.cache_store.then do |store|
-          result = store.read(key)
-          unless result.nil?
-            result.cached!
-            next result
-          end
-          yield.tap do |result|
-            store.write(key, result, options)
-          end
-        end
-      end
-
-      def apply_r(rule)
-        return super if ActionPolicy.cache_store.nil? ||
-          !self.class.cached_rules.key?(rule)
-
-        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|
-            cached_rules[rule] = options
-          end
-        end
-
-        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
-        end
-      end
-    end
-  end
-end

data/lib/.rbnext/2.7/action_policy/policy/pre_check.rb

@@ -1,162 +0,0 @@
-# frozen_string_literal: true
-
-module ActionPolicy
-  module Policy
-    # Adds callback-style checks to policies to
-    # extract common checks from rules.
-    #
-    #    class ApplicationPolicy < ActionPolicy::Base
-    #      authorize :user
-    #      pre_check :allow_admins
-    #
-    #      private
-    #        # Allow every action for admins
-    #        def allow_admins
-    #          allow! if user.admin?
-    #        end
-    #    end
-    #
-    # You can specify conditional pre-checks (through `except` / `only`) options
-    # and skip already defined pre-checks if necessary.
-    #
-    #    class UserPolicy < ApplicationPolicy
-    #      skip_pre_check :allow_admins, only: :destroy?
-    #
-    #      def destroy?
-    #        user.admin? && !record.admin?
-    #      end
-    #    end
-    module PreCheck
-      # Single pre-check instance.
-      #
-      # Implements filtering logic.
-      class Check
-        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"
-          end
-
-          @policy_class = policy
-          @name = name
-          @blacklist = Array(except) unless except.nil?
-          @whitelist = Array(only) unless only.nil?
-
-          rebuild_filter
-        end
-
-        def applicable?(rule)
-          return true if filter.nil?
-          filter.call(rule)
-        end
-
-        def call(policy) ;  policy.send(name); end
-
-        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"
-          end
-
-          if except.nil? && only.nil?
-            raise ArgumentError,
-              "At least one of `except` and `only` must be specified when skipping pre-check"
-          end
-
-          if except
-            @whitelist = Array(except)
-            @whitelist -= blacklist if blacklist
-            @blacklist = nil
-          else
-            # only
-            @blacklist += Array(only) if blacklist
-            @whitelist -= Array(only) if whitelist
-            @blacklist = Array(only) if filter.nil?
-          end
-
-          rebuild_filter
-        end
-        # rubocop: enable
-        # rubocop: enable
-
-        def dup
-          self.class.new(
-            policy_class,
-            name,
-            except: blacklist&.dup,
-            only: whitelist&.dup
-          )
-        end
-
-        private
-
-        attr_reader :whitelist, :blacklist, :filter
-
-        def rebuild_filter
-          @filter =
-            if whitelist
-              proc { |rule| whitelist.include?(rule) }
-            elsif blacklist
-              proc { |rule| !blacklist.include?(rule) }
-            end
-        end
-      end
-
-      class << self
-        def included(base)
-          base.extend ClassMethods
-        end
-      end
-
-      def run_pre_checks(rule)
-        self.class.pre_checks.each do |check|
-          next unless check.applicable?(rule)
-          check.call(self)
-        end
-
-        yield if block_given?
-      end
-
-      def __apply__(rule)
-        run_pre_checks(rule) { super }
-      end
-
-      module ClassMethods # :nodoc:
-        def pre_check(*names, **options)
-          names.each do |name|
-            # do not allow pre-check override
-            check = pre_checks.find { |_1| _1.name == name }
-            raise "Pre-check already defined: #{name}" unless check.nil?
-
-            pre_checks << Check.new(self, name, **options)
-          end
-        end
-
-        def skip_pre_check(*names, **options)
-          names.each do |name|
-            check = pre_checks.find { |_1| _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 { |_1| _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
-        end
-      end
-    end
-  end
-end

data/lib/.rbnext/2.7/action_policy/rspec/be_authorized_to.rb

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-require "action_policy/testing"
-
-module ActionPolicy
-  module RSpec
-    # Authorization matcher `be_authorized_to`.
-    #
-    # Verifies that a block of code has been authorized using specific policy.
-    #
-    # Example:
-    #
-    #   # in controller/request specs
-    #   subject { patch :update, id: product.id }
-    #
-    #   it "is authorized" do
-    #     expect { subject }
-    #       .to be_authorized_to(:manage?, product)
-    #       .with(ProductPolicy)
-    #   end
-    #
-    class BeAuthorizedTo < ::RSpec::Matchers::BuiltIn::BaseMatcher
-      attr_reader :rule, :target, :policy, :actual_calls, :context
-
-      def initialize(rule, target)
-        @rule = rule
-        @target = target
-      end
-
-      def with(policy)
-        @policy = policy
-        self
-      end
-
-      def with_context(context)
-        @context = context
-        self
-      end
-
-      def match(_expected, actual)
-        raise "This matcher only supports block expectations" unless actual.is_a?(Proc)
-
-        @policy ||= ::ActionPolicy.lookup(target)
-        @context ||= nil
-
-        begin
-          ActionPolicy::Testing::AuthorizeTracker.tracking { actual.call }
-        rescue ActionPolicy::Unauthorized
-          # we don't want to care about authorization result
-        end
-
-        @actual_calls = ActionPolicy::Testing::AuthorizeTracker.calls
-
-        actual_calls.any? { |_1| _1.matches?(policy, rule, target, context) }
-      end
-
-      def does_not_match?(*__rest__)
-        raise "This matcher doesn't support negation"
-      end
-
-      def supports_block_expectations?() ;  true; end
-
-      def failure_message
-        "expected #{formatted_record} " \
-        "to be authorized with #{policy}##{rule}, " \
-        "#{context ? "and context #{context.inspect}, " : ""}" \
-        "but #{actual_calls_message}"
-      end
-
-      def actual_calls_message
-        if actual_calls.empty?
-          "no authorization calls have been made"
-        else
-          "the following calls were encountered:\n" \
-          "#{formatted_calls}"
-        end
-      end
-
-      def formatted_calls
-        actual_calls.map do |_1|
-          " - #{_1.inspect}"
-        end.join("\n")
-      end
-
-      def formatted_record(record = target) ;  ::RSpec::Support::ObjectFormatter.format(record); end
-    end
-  end
-end
-
-RSpec.configure do |config|
-  config.include(Module.new do
-    def be_authorized_to(rule, target)
-      ActionPolicy::RSpec::BeAuthorizedTo.new(rule, target)
-    end
-  end)
-end

data/lib/.rbnext/2.7/action_policy/rspec/have_authorized_scope.rb

@@ -1,130 +0,0 @@
-# frozen_string_literal: true
-
-require "action_policy/testing"
-
-module ActionPolicy
-  module RSpec
-    # Implements `have_authorized_scope` matcher.
-    #
-    # Verifies that a block of code applies authorization scoping using specific policy.
-    #
-    # Example:
-    #
-    #   # in controller/request specs
-    #   subject { get :index }
-    #
-    #   it "has authorized scope" do
-    #     expect { subject }
-    #       .to have_authorized_scope(:active_record_relation)
-    #       .with(ProductPolicy)
-    #   end
-    #
-    class HaveAuthorizedScope < ::RSpec::Matchers::BuiltIn::BaseMatcher
-      attr_reader :type, :name, :policy, :scope_options, :actual_scopes,
-        :target_expectations, :context
-
-      def initialize(type)
-        @type = type
-        @name = :default
-        @scope_options = nil
-      end
-
-      def with(policy)
-        @policy = policy
-        self
-      end
-
-      def as(name)
-        @name = name
-        self
-      end
-
-      def with_scope_options(scope_options)
-        @scope_options = scope_options
-        self
-      end
-
-      def with_target(&block)
-        @target_expectations = block
-        self
-      end
-
-      def with_context(context)
-        @context = context
-        self
-      end
-
-      def match(_expected, actual)
-        raise "This matcher only supports block expectations" unless actual.is_a?(Proc)
-
-        ActionPolicy::Testing::AuthorizeTracker.tracking { actual.call }
-
-        @actual_scopes = ActionPolicy::Testing::AuthorizeTracker.scopings
-
-        matching_scopes = actual_scopes.select { |_1| _1.matches?(policy, type, name, scope_options, context) }
-
-        return false if matching_scopes.empty?
-
-        return true unless target_expectations
-
-        if matching_scopes.size > 1
-          raise "Too many matching scopings (#{matching_scopes.size}), " \
-                "you can run `.with_target` only when there is the only one match"
-        end
-
-        target_expectations.call(matching_scopes.first.target)
-        true
-      end
-
-      def does_not_match?(*__rest__)
-        raise "This matcher doesn't support negation"
-      end
-
-      def supports_block_expectations?() ;  true; end
-
-      def failure_message
-        "expected a scoping named :#{name} for type :#{type} " \
-        "#{scope_options_message} " \
-        "#{context ? "and context #{context.inspect} " : ""}" \
-        "from #{policy} to have been applied, " \
-        "but #{actual_scopes_message}"
-      end
-
-      def scope_options_message
-        if scope_options
-          if defined?(::RSpec::Matchers::Composable) &&
-              scope_options.is_a?(::RSpec::Matchers::Composable)
-            "with scope options #{scope_options.description}"
-          else
-            "with scope options #{scope_options}"
-          end
-        else
-          "without scope options"
-        end
-      end
-
-      def actual_scopes_message
-        if actual_scopes.empty?
-          "no scopings have been made"
-        else
-          "the following scopings were encountered:\n" \
-          "#{formatted_scopings}"
-        end
-      end
-
-      def formatted_scopings
-        actual_scopes.map do |_1|
-          " - #{_1.inspect}"
-        end.join("\n")
-      end
-    end
-  end
-end
-
-RSpec.configure do |config|
-  config.include(Module.new do
-    def have_authorized_scope(type)
-      ActionPolicy::RSpec::HaveAuthorizedScope.new(type)
-    end
-  end)
-end

data/lib/.rbnext/2.7/action_policy/utils/pretty_print.rb

@@ -1,155 +0,0 @@
-# frozen_string_literal: true
-
-old_verbose = $VERBOSE
-
-begin
-  require "method_source"
-  # Ignore parse warnings when patch
-  # Ruby version mismatches
-  $VERBOSE = nil
-  require "prism"
-rescue LoadError
-  # do nothing
-ensure
-  $VERBOSE = old_verbose
-end
-
-module ActionPolicy
-  using RubyNext
-
-  # Takes the object and a method name,
-  # and returns the "annotated" source code for the method:
-  # code is split into parts by logical operators and each
-  # part is evaluated separately.
-  #
-  # Example:
-  #
-  #  class MyClass
-  #    def access?
-  #      admin? && access_feed?
-  #    end
-  #  end
-  #
-  #  puts PrettyPrint.format_method(MyClass.new, :access?)
-  #
-  #  #=> MyClass#access?
-  #  #=> ↳ admin? #=> false
-  #  #=> AND
-  #  #=> access_feed? #=> true
-  module PrettyPrint
-    TRUE = "\e[32mtrue\e[0m"
-    FALSE = "\e[31mfalse\e[0m"
-
-    class Visitor
-      attr_reader :lines, :object, :source
-      attr_accessor :indent
-
-      def initialize(object)
-        @object = object
-      end
-
-      def collect(ast)
-        @lines = []
-        @indent = 0
-        @source = ast.source.source
-        ast = ast.value.child_nodes[0].child_nodes[0].body
-
-        visit_node(ast)
-
-        lines.join("\n")
-      end
-
-      def visit_node(ast)
-        if respond_to?("visit_#{ast.type}")
-          send("visit_#{ast.type}", ast)
-        else
-          visit_missing ast
-        end
-      end
-
-      def expression_with_result(sexp)
-        expression = source[sexp.location.start_offset...sexp.location.end_offset]
-        "#{expression} #=> #{PrettyPrint.colorize(eval_exp(expression))}"
-      end
-
-      def eval_exp(exp)
-        return "<skipped>" if ignore_exp?(exp)
-        object.instance_eval(exp)
-      rescue => e
-        "Failed: #{e.message}"
-      end
-
-      def visit_and_node(ast)
-        visit_node(ast.left)
-        lines << indented("AND")
-        visit_node(ast.right)
-      end
-
-      def visit_or_node(ast)
-        visit_node(ast.left)
-        lines << indented("OR")
-        visit_node(ast.right)
-      end
-
-      def visit_statements_node(ast)
-        ast.child_nodes.each do |node|
-          visit_node(node)
-          # restore indent after each expression
-          self.indent -= 2
-        end
-      end
-
-      def visit_parentheses_node(ast)
-        lines << indented("(")
-        self.indent += 2
-        visit_node(ast.child_nodes[0])
-        lines << indented(")")
-      end
-
-      def visit_missing(ast)
-        lines << indented(expression_with_result(ast))
-      end
-
-      def indented(str)
-        "#{indent.zero? ? "↳ " : ""}#{" " * indent}#{str}".tap do
-          # increase indent after the first expression
-          self.indent += 2 if indent.zero?
-        end
-      end
-
-      # Some lines should not be evaled
-      def ignore_exp?(exp)
-        PrettyPrint.ignore_expressions.any? { |_1| exp.match?(_1) }
-      end
-    end
-
-    class << self
-      attr_accessor :ignore_expressions
-
-      if defined?(::Prism) && defined?(::MethodSource)
-        def available?() ;  true; end
-
-        def print_method(object, method_name)
-          ast = Prism.parse(object.method(method_name).source)
-
-          Visitor.new(object).collect(ast)
-        end
-      else
-        def available?() ;  false; end
-
-        def print_method(_, _) ;  ""; end
-      end
-
-      def colorize(val)
-        return val unless $stdout.isatty
-        return TRUE if val.eql?(true) # rubocop:disable Lint/DeprecatedConstants
-        return FALSE if val.eql?(false) # rubocop:disable Lint/DeprecatedConstants
-        val
-      end
-    end
-
-    self.ignore_expressions = [
-      /^\s*binding\.(pry|irb)\s*$/s
-    ]
-  end
-end