action_policy 0.5.1 → 0.5.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 90b8e4f19873080b0353ab3b1df8b23bc468b2702e2f9798caf45c1a53bff82e
-  data.tar.gz: 802d9b6589a5e1c4686718e993cf0389a5bcb1d270a751516245e8dd7f175a78
+  metadata.gz: e859b71805cff1035904f6a6b6ec73e19f4722e894f88b9a7834a30569c4f587
+  data.tar.gz: 2df569e93f84268bf3244d1615559716b16081d53df826dfe856cefb7dd0becc
 SHA512:
-  metadata.gz: 63c57ef86e1d488f7816860728452a409ec7225db6666c1b59913ddfedacda5030d55c95a0c94435049cf63425c0ddb01a3010a4ba494fe05fbcc503b938acb0
-  data.tar.gz: 714a3089ff46e2df58fcc1c9f37f74ead81a8db9dd063a19eab9e6193ed3c50ddc075ae44a6e375dad4de4581f0889609b21b3600fb7ecb1539c12ff7fec7f3a
+  metadata.gz: 6457503550706d1cc63e4e636c675f9d7a0f70184deb0217a8ad79206c897e00317eef14522a72c415b8e292ee0d52a9837c011e2793cec1eee55e8ed792f778
+  data.tar.gz: 148141b42a80097b3b7369118027b77a8cd7a1412cef4b3cd75f5e80415c93cd60f1d1a5d3fd1ee0f30f44886475f59db408deffa3c40d060ff3319fef45c1b9

data/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 ## master
 
+## 0.5.6 (2021-03-03)
+
+- Add `ActionPolicy.enforce_predicate_rules_naming` config to catch rule missing question mark ([@skojin][])
+
+## 0.5.5 (2020-12-28)
+
+- Upgrade to Ruby 3.0. ([@palkan][])
+
+## 0.5.4 (2020-12-09)
+
+- Add support for RSpec aliases detection when linting policy specs with `rubocop-rspec` 2.0 ([@pirj][])
+
+- Fix `strict_namespace: true` lookup option not finding policies in global namespace ([@Be-ngt-oH][])
+
 ## 0.5.0 (2020-09-29)
 
 - Move `deny!` / `allow!` to core. ([@palkan][])
@@ -37,7 +51,7 @@ This method is similar to `allowed_to?` but returns an authorization result obje
 
 Fixes [#122](https://github.com/palkan/action_policy/issues/122).
 
-- Separated `#classify`-based and `#camelize`-based symbol lookups. ([Be-ngt-oH][])
+- Separated `#classify`-based and `#camelize`-based symbol lookups. ([@Be-ngt-oH][])
 
 Only affects Rails apps. Now lookup for `:users` tries to find `UsersPolicy` first (camelize),
 and only then search for `UserPolicy` (classify).
@@ -425,7 +439,9 @@ This value is now stored in a cache (if any) instead of just the call result (`t
 [@ilyasgaraev]: https://github.com/ilyasgaraev
 [@brendon]: https://github.com/brendon
 [@DmitryTsepelev]: https://github.com/DmitryTsepelev
-[@korolvs]: https://github.com/korolvs
+[@korolvs]: https://github.com/slavadev
 [@nicolas-brousse]: https://github.com/nicolas-brousse
 [@somenugget]: https://github.com/somenugget
 [@Be-ngt-oH]: https://github.com/Be-ngt-oH
+[@pirj]: https://github.com/pirj
+[@skojin]: https://github.com/skojin

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2018-2020 Vladimir Dementyev
+Copyright (c) 2018-2021 Vladimir Dementyev
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -31,7 +31,7 @@ Composable. Extensible. Performant.
 Add this line to your application's `Gemfile`:
 
 ```ruby
-gem "action_policy", "~> 0.4.0"
+gem "action_policy"
 ```
 
 And then execute:

data/config/rubocop-rspec.yml

@@ -0,0 +1,17 @@
+RSpec:
+  Language:
+    ExampleGroups:
+      Regular:
+        - describe_rule
+      Focused:
+        - fdescribe_rule
+      Skipped:
+        - xdescribe_rule
+    Includes:
+      Examples:
+        - succeed
+        - failed
+        - fsucceed
+        - ffailed
+        - xsucceed
+        - xfailed

data/lib/.rbnext/{3.0 → 1995.next}/action_policy/behaviours/policy_for.rb

@@ -11,7 +11,7 @@ module ActionPolicy
       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: namespace, context: context, allow_nil: allow_nil, default: default}
+          namespace: namespace, context: context, allow_nil: allow_nil, default: default
         )
         policy_class&.new(record, **context)
       end

data/lib/.rbnext/{3.0 → 1995.next}/action_policy/behaviours/scoping.rb

@@ -19,11 +19,11 @@ module ActionPolicy
         type ||= authorization_scope_type_for(policy, target)
         name = as
 
-        Authorizer.scopify(target, policy, **{type: type, name: name, scope_options: scope_options})
+        Authorizer.scopify(target, policy, type: type, name: name, scope_options: scope_options)
       end
 
       # For backward compatibility
-      alias authorized authorized_scope
+      alias_method :authorized, :authorized_scope
 
       # Infer scope type for target if none provided.
       # Raises an exception if type couldn't be inferred.

data/lib/.rbnext/1995.next/action_policy/utils/pretty_print.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+old_verbose = $VERBOSE
+
+begin
+  require "method_source"
+  # Ignore parse warnings when patch
+  # Ruby version mismatches
+  $VERBOSE = nil
+  require "parser/current"
+  require "unparser"
+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
+      attr_accessor :indent
+
+      def initialize(object)
+        @object = object
+      end
+
+      def collect(ast)
+        @lines = []
+        @indent = 0
+
+        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 = Unparser.unparse(sexp)
+        "#{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(ast)
+        visit_node(ast.children[0])
+        lines << indented("AND")
+        visit_node(ast.children[1])
+      end
+
+      def visit_or(ast)
+        visit_node(ast.children[0])
+        lines << indented("OR")
+        visit_node(ast.children[1])
+      end
+
+      def visit_begin(ast)
+        #  Parens
+        if ast.children.size == 1
+          lines << indented("(")
+          self.indent += 2
+          visit_node(ast.children[0])
+          self.indent -= 2
+          lines << indented(")")
+        else
+          # Multiple expressions
+          ast.children.each do |node|
+            visit_node(node)
+            # restore indent after each expression
+            self.indent -= 2
+          end
+        end
+      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? { exp.match?(_1) }
+      end
+    end
+
+    class << self
+      attr_accessor :ignore_expressions
+
+      if defined?(::Unparser) && defined?(::MethodSource)
+        def available?() = true
+
+        def print_method(object, method_name)
+          ast = object.method(method_name).source.then(&Unparser.method(:parse))
+          # outer node is a method definition itself
+          body = ast.children[2]
+
+          Visitor.new(object).collect(body)
+        end
+      else
+        def available?() = false
+
+        def print_method(_, _) = ""
+      end
+
+      def colorize(val)
+        return val unless $stdout.isatty
+        return TRUE if val.eql?(true)
+        return FALSE if val.eql?(false)
+        val
+      end
+    end
+
+    self.ignore_expressions = [
+      /^\s*binding\.(pry|irb)\s*$/s
+    ]
+  end
+end

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

@@ -11,7 +11,7 @@ module ActionPolicy
       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: namespace, context: context, allow_nil: allow_nil, default: default}
+          namespace: namespace, context: context, allow_nil: allow_nil, default: default
         )
         policy_class&.new(record, **context)
       end

data/lib/.rbnext/3.0/action_policy/behaviours/thread_memoized.rb

@@ -40,7 +40,7 @@ module ActionPolicy
           base.prepend InstanceMethods
         end
 
-        alias included prepended
+        alias_method :included, :prepended
       end
 
       module InstanceMethods # :nodoc:

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

@@ -185,10 +185,12 @@ 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

data/lib/action_policy.rb

@@ -34,6 +34,8 @@ module ActionPolicy
   class << self
     attr_accessor :cache_store
 
+    attr_accessor :enforce_predicate_rules_naming
+
     # Find a policy class for a target
     def lookup(target, allow_nil: false, default: nil, **options)
       LookupChain.call(target, **options) ||

data/lib/action_policy/behaviour.rb

@@ -104,11 +104,11 @@ module ActionPolicy
       def authorization_targets
         return @authorization_targets if instance_variable_defined?(:@authorization_targets)
 
-        if superclass.respond_to?(:authorization_targets)
+        @authorization_targets = if superclass.respond_to?(:authorization_targets)
           superclass.authorization_targets.dup
         else
           {}
-        end => @authorization_targets
+        end
       end
     end
   end

data/lib/action_policy/behaviours/memoized.rb

@@ -24,7 +24,7 @@ module ActionPolicy
           base.prepend InstanceMethods
         end
 
-        alias included prepended
+        alias_method :included, :prepended
       end
 
       module InstanceMethods # :nodoc:

data/lib/action_policy/behaviours/namespaced.rb

@@ -66,7 +66,7 @@ module ActionPolicy
           base.prepend InstanceMethods
         end
 
-        alias included prepended
+        alias_method :included, :prepended
       end
 
       module InstanceMethods # :nodoc:

data/lib/action_policy/behaviours/policy_for.rb

@@ -11,7 +11,7 @@ module ActionPolicy
       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}
+          namespace:, context:, allow_nil:, default:
         )
         policy_class&.new(record, **context)
       end

data/lib/action_policy/behaviours/scoping.rb

@@ -19,11 +19,11 @@ module ActionPolicy
         type ||= authorization_scope_type_for(policy, target)
         name = as
 
-        Authorizer.scopify(target, policy, **{type, name, scope_options})
+        Authorizer.scopify(target, policy, type:, name:, scope_options:)
       end
 
       # For backward compatibility
-      alias authorized authorized_scope
+      alias_method :authorized, :authorized_scope
 
       # Infer scope type for target if none provided.
       # Raises an exception if type couldn't be inferred.

data/lib/action_policy/behaviours/thread_memoized.rb

@@ -40,7 +40,7 @@ module ActionPolicy
           base.prepend InstanceMethods
         end
 
-        alias included prepended
+        alias_method :included, :prepended
       end
 
       module InstanceMethods # :nodoc:

data/lib/action_policy/lookup_chain.rb

@@ -36,8 +36,7 @@ module ActionPolicy
           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 }
+            put_if_absent(:flexible, namespace, policy, &block)
           end
         end
 
@@ -53,7 +52,7 @@ module ActionPolicy
     class << self
       attr_accessor :chain, :namespace_cache_enabled
 
-      alias namespace_cache_enabled? namespace_cache_enabled
+      alias_method :namespace_cache_enabled?, :namespace_cache_enabled
 
       def call(record, **opts)
         chain.each do |probe|
@@ -66,22 +65,17 @@ module ActionPolicy
       private
 
       def lookup_within_namespace(policy_name, namespace, strict: false)
-        return unless namespace
-        NamespaceCache.fetch(namespace.name, policy_name, strict: strict) do
+        NamespaceCache.fetch(namespace&.name || "Kernel", policy_name, strict: strict) do
           mod = namespace
           loop do
-            policy = "#{mod.name}::#{policy_name}".safe_constantize
-            break policy unless policy.nil?
+            policy = [mod&.name, policy_name].compact.join("::").safe_constantize
+            break policy if policy || mod.nil? || strict
+
             mod = mod.namespace
-            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)
 
@@ -110,17 +104,10 @@ module ActionPolicy
       record.class.policy_class if record.class.respond_to?(:policy_class)
     }
 
-    # Lookup within namespace when provided
-    NAMESPACE_LOOKUP = ->(record, namespace: nil, **) {
-      next if namespace.nil?
-
-      policy_name = policy_class_name_for(record)
-      lookup_within_namespace(policy_name, namespace)
-    }
-
     # Infer from class name
-    INFER_FROM_CLASS = ->(record, **) {
-      policy_class_name_for(record).safe_constantize
+    INFER_FROM_CLASS = ->(record, namespace: nil, strict_namespace: false, **) {
+      policy_name = policy_class_name_for(record)
+      lookup_within_namespace(policy_name, namespace, strict: strict_namespace)
     }
 
     # Infer from passed symbol
@@ -128,8 +115,7 @@ module ActionPolicy
       next unless record.is_a?(Symbol)
 
       policy_name = "#{record.camelize}Policy"
-      lookup_within_namespace(policy_name, namespace, strict: strict_namespace) ||
-        objectify_policy(policy_name, strict: strict_namespace)
+      lookup_within_namespace(policy_name, namespace, strict: strict_namespace)
     }
 
     # (Optional) Infer using String#classify if available
@@ -137,8 +123,7 @@ module ActionPolicy
       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)
+      lookup_within_namespace(policy_name, namespace, strict: strict_namespace)
     }
 
     self.chain = [
@@ -146,7 +131,6 @@ module ActionPolicy
       (CLASSIFY_SYMBOL_LOOKUP if String.method_defined?(:classify)),
       INSTANCE_POLICY_CLASS,
       CLASS_POLICY_CLASS,
-      NAMESPACE_LOOKUP,
       INFER_FROM_CLASS
     ].compact
   end

data/lib/action_policy/policy/aliases.rb

@@ -31,10 +31,18 @@ module ActionPolicy
       def resolve_rule(activity)
         self.class.lookup_alias(activity) ||
           (activity if respond_to?(activity)) ||
+          (check_rule_naming(activity) if ActionPolicy.enforce_predicate_rules_naming) ||
           self.class.lookup_default_rule ||
           super
       end
 
+      private def check_rule_naming(activity)
+        unless activity[-1] == "?"
+          raise NonPredicateRule.new(self, activity)
+        end
+        nil
+      end
+
       module ClassMethods # :nodoc:
         def default_rule(val)
           rules_aliases[DEFAULT] = val
@@ -53,11 +61,11 @@ module ActionPolicy
         def rules_aliases
           return @rules_aliases if instance_variable_defined?(:@rules_aliases)
 
-          if superclass.respond_to?(:rules_aliases)
+          @rules_aliases = if superclass.respond_to?(:rules_aliases)
             superclass.rules_aliases.dup
           else
             {}
-          end => @rules_aliases
+          end
         end
 
         def method_added(name)

data/lib/action_policy/policy/authorization.rb

@@ -75,11 +75,11 @@ module ActionPolicy
         def authorization_targets
           return @authorization_targets if instance_variable_defined?(:@authorization_targets)
 
-          if superclass.respond_to?(:authorization_targets)
+          @authorization_targets = if superclass.respond_to?(:authorization_targets)
             superclass.authorization_targets.dup
           else
             {}
-          end => @authorization_targets
+          end
         end
       end
     end

data/lib/action_policy/policy/cache.rb

@@ -89,11 +89,11 @@ module ActionPolicy # :nodoc:
         def cached_rules
           return @cached_rules if instance_variable_defined?(:@cached_rules)
 
-          if superclass.respond_to?(:cached_rules)
+          @cached_rules = if superclass.respond_to?(:cached_rules)
             superclass.cached_rules.dup
           else
             {}
-          end => @cached_rules
+          end
         end
       end
     end

data/lib/action_policy/policy/core.rb

@@ -23,12 +23,19 @@ module ActionPolicy
     def initialize(policy, rule)
       @policy = policy.class
       @rule = rule
-      @message =
-        "Couldn't find rule '#{@rule}' for #{@policy}" \
+      @message = "Couldn't find rule '#{@rule}' for #{@policy}" \
         "#{suggest(@rule, @policy.instance_methods - Object.instance_methods)}"
     end
   end
 
+  class NonPredicateRule < UnknownRule
+    def initialize(policy, rule)
+      @policy = policy.class
+      @rule = rule
+      @message = "The rule '#{@rule}' of '#{@policy}' must ends with ? (question mark)\nDid you mean? #{@rule}?"
+    end
+  end
+
   module Policy
     # Core policy API
     module Core

data/lib/action_policy/policy/pre_check.rb

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

data/lib/action_policy/policy/reasons.rb

@@ -72,7 +72,7 @@ module ActionPolicy
       def all_details
         return @all_details if defined?(@all_details)
 
-        {}.tap do |all|
+        @all_details = {}.tap do |all|
           next unless defined?(@reasons)
 
           reasons.reasons.each_value do |rules|
@@ -84,7 +84,7 @@ module ActionPolicy
               all.merge!(details)
             end
           end
-        end => @all_details
+        end
       end
 
       # Add reasons to inspect
@@ -185,10 +185,12 @@ 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

data/lib/action_policy/policy/scoping.rb

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

data/lib/action_policy/test_helper.rb

@@ -21,6 +21,7 @@ module ActionPolicy
         yield scopes.first.target
       end
     end
+
     # Asserts that the given policy was used to authorize the given target.
     #
     #   def test_authorize

data/lib/action_policy/utils/pretty_print.rb

@@ -146,8 +146,8 @@ module ActionPolicy
 
       def colorize(val)
         return val unless $stdout.isatty
-        return TRUE if val.eql?(true)
-        return FALSE if val.eql?(false)
+        return TRUE if val.eql?(true) # rubocop:disable Lint/DeprecatedConstants
+        return FALSE if val.eql?(false) # rubocop:disable Lint/DeprecatedConstants
         val
       end
     end

data/lib/action_policy/version.rb

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

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: action_policy
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.6
 platform: ruby
 authors:
 - Vladimir Dementyev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-09-30 00:00:00.000000000 Z
+date: 2021-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: ruby-next-core
+  name: ruby-next
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.10.3
+        version: 0.11.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.10.3
+        version: 0.11.0
 - !ruby/object:Gem::Dependency
   name: ammeter
   requirement: !ruby/object:Gem::Requirement
@@ -132,6 +132,11 @@ files:
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
+- config/rubocop-rspec.yml
+- lib/.rbnext/1995.next/action_policy/behaviours/policy_for.rb
+- lib/.rbnext/1995.next/action_policy/behaviours/scoping.rb
+- lib/.rbnext/1995.next/action_policy/policy/authorization.rb
+- lib/.rbnext/1995.next/action_policy/utils/pretty_print.rb
 - 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
@@ -139,20 +144,15 @@ files:
 - 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/behaviour.rb
-- lib/.rbnext/3.0/action_policy/behaviours/policy_for.rb
-- lib/.rbnext/3.0/action_policy/behaviours/scoping.rb
 - lib/.rbnext/3.0/action_policy/behaviours/thread_memoized.rb
 - lib/.rbnext/3.0/action_policy/ext/policy_cache_key.rb
 - lib/.rbnext/3.0/action_policy/policy/aliases.rb
-- lib/.rbnext/3.0/action_policy/policy/authorization.rb
 - lib/.rbnext/3.0/action_policy/policy/cache.rb
 - lib/.rbnext/3.0/action_policy/policy/core.rb
 - lib/.rbnext/3.0/action_policy/policy/defaults.rb
 - 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/policy/scoping.rb
 - lib/.rbnext/3.0/action_policy/rspec/be_authorized_to.rb
 - lib/.rbnext/3.0/action_policy/rspec/have_authorized_scope.rb
 - lib/.rbnext/3.0/action_policy/utils/pretty_print.rb

data/lib/.rbnext/3.0/action_policy/behaviour.rb

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-require "action_policy/behaviours/policy_for"
-require "action_policy/behaviours/scoping"
-require "action_policy/behaviours/memoized"
-require "action_policy/behaviours/thread_memoized"
-require "action_policy/behaviours/namespaced"
-
-require "action_policy/authorizer"
-
-module ActionPolicy
-  # Provides `authorize!` and `allowed_to?` methods and
-  # `authorize` class method to define authorization context.
-  #
-  # Could be included anywhere to perform authorization.
-  module Behaviour
-    include ActionPolicy::Behaviours::PolicyFor
-    include ActionPolicy::Behaviours::Scoping
-
-    def self.included(base)
-      # Handle ActiveSupport::Concern differently
-      if base.respond_to?(:class_methods)
-        base.class_methods do
-          include ClassMethods
-        end
-      else
-        base.extend ClassMethods
-      end
-    end
-
-    # Authorize action against a policy.
-    #
-    # Policy is inferred from record
-    # (unless explicitly specified through `with` option).
-    #
-    # 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))
-    end
-
-    # Checks that an activity is allowed for the current context (e.g. user).
-    #
-    # Returns true of false.
-    def allowed_to?(rule, record = :__undef__, **options)
-      policy = lookup_authorization_policy(record, **options)
-
-      policy.apply(authorization_rule_for(policy, rule))
-    end
-
-    # Returns the authorization result object after applying a specified rule to a record.
-    def allowance_to(rule, record = :__undef__, **options)
-      policy = lookup_authorization_policy(record, **options)
-
-      policy.apply(authorization_rule_for(policy, rule))
-      policy.result
-    end
-
-    def authorization_context
-      return @__authorization_context if
-        instance_variable_defined?(:@__authorization_context)
-
-      @__authorization_context = self.class.authorization_targets
-        .each_with_object({}) do |(key, meth), obj|
-        obj[key] = send(meth)
-      end
-    end
-
-    # Check that rule is defined for policy,
-    # otherwise fallback to :manage? rule.
-    def authorization_rule_for(policy, rule)
-      policy.resolve_rule(rule)
-    end
-
-    def lookup_authorization_policy(record, **options) # :nodoc:
-      record = implicit_authorization_target! if record == :__undef__
-      raise ArgumentError, "Record must be specified" if record.nil?
-
-      options[:context] && (options[:context] = authorization_context.merge(options[:context]))
-
-      policy_for(record: record, **options)
-    end
-
-    module ClassMethods # :nodoc:
-      # Configure authorization context.
-      #
-      # For example:
-      #
-      #   class ApplicationController < ActionController::Base
-      #     # Pass the value of `current_user` to authorization as `user`
-      #     authorize :user, through: :current_user
-      #   end
-      #
-      #   # Assuming that in your ApplicationPolicy
-      #   class ApplicationPolicy < ActionPolicy::Base
-      #     authorize :user
-      #   end
-      def authorize(key, through: nil)
-        meth = through || key
-        authorization_targets[key] = meth
-      end
-
-      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
-      end
-    end
-  end
-end

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

@@ -1,160 +0,0 @@
-# frozen_string_literal: true
-
-require "action_policy/behaviours/scoping"
-
-require "action_policy/utils/suggest_message"
-
-module ActionPolicy
-  class UnknownScopeType < Error # :nodoc:
-    include ActionPolicy::SuggestMessage
-
-    MESSAGE_TEMPLATE = "Unknown policy scope type :%s for %s%s"
-
-    attr_reader :message
-
-    def initialize(policy_class, type)
-      @message = format(
-        MESSAGE_TEMPLATE,
-        type, policy_class,
-        suggest(type, policy_class.scoping_handlers.keys)
-      )
-    end
-  end
-
-  class UnknownNamedScope < Error # :nodoc:
-    include ActionPolicy::SuggestMessage
-
-    MESSAGE_TEMPLATE = "Unknown named scope :%s for type :%s for %s%s"
-
-    attr_reader :message
-
-    def initialize(policy_class, type, name)
-      @message = format(
-        MESSAGE_TEMPLATE, name, type, policy_class,
-        suggest(name, policy_class.scoping_handlers[type].keys)
-      )
-    end
-  end
-
-  class UnrecognizedScopeTarget < Error # :nodoc:
-    MESSAGE_TEMPLATE = "Couldn't infer scope type for %s instance"
-
-    attr_reader :message
-
-    def initialize(target)
-      target_class = target.is_a?(Module) ? target : target.class
-
-      @message = format(
-        MESSAGE_TEMPLATE, target_class
-      )
-    end
-  end
-
-  module Policy
-    # Scoping is used to modify the _object under authorization_.
-    #
-    # The most common situation is when you want to _scope_ the collection depending
-    # on the current user permissions.
-    #
-    # For example:
-    #
-    #   class ApplicationPolicy < ActionPolicy::Base
-    #     # Scoping only makes sense when you have the authorization context
-    #     authorize :user
-    #
-    #     # :relation here is a scoping type
-    #     scope_for :relation do |relation|
-    #       # authorization context is available within a scope
-    #       if user.admin?
-    #         relation
-    #       else
-    #         relation.publicly_visible
-    #       end
-    #     end
-    #   end
-    #
-    #   base_scope = User.all
-    #   authorized_scope = ApplicantPolicy.new(user: user)
-    #    .apply_scope(base_scope, type: :relation)
-    module Scoping
-      class << self
-        def included(base)
-          base.extend ClassMethods
-        end
-      end
-
-      include ActionPolicy::Behaviours::Scoping
-
-      # Pass target to the scope handler of the specified type and name.
-      # If `name` is not specified then `:default` name is used.
-      # If `type` is not specified then we try to infer the type from the
-      # target class.
-      def apply_scope(target, type:, name: :default, scope_options: nil)
-        raise ActionPolicy::UnknownScopeType.new(self.class, type) unless
-          self.class.scoping_handlers.key?(type)
-
-        raise ActionPolicy::UnknownNamedScope.new(self.class, type, name) unless
-          self.class.scoping_handlers[type].key?(name)
-
-        mid = :"__scoping__#{type}__#{name}"
-        scope_options ? send(mid, target, **scope_options) : send(mid, target)
-      end
-
-      def resolve_scope_type(target)
-        lookup_type_from_target(target) ||
-          raise(ActionPolicy::UnrecognizedScopeTarget, target)
-      end
-
-      def lookup_type_from_target(target)
-        self.class.scope_matchers.detect do |(_type, matcher)|
-          matcher === target
-        end&.first
-      end
-
-      module ClassMethods # :nodoc:
-        # Register a new scoping method for the `type`
-        def scope_for(type, name = :default, &block)
-          mid = :"__scoping__#{type}__#{name}"
-
-          define_method(mid, &block)
-
-          scoping_handlers[type][name] = mid
-        end
-
-        def scoping_handlers
-          return @scoping_handlers if instance_variable_defined?(:@scoping_handlers)
-
-          @scoping_handlers =
-            Hash.new { |h, k| h[k] = {} }.tap do |handlers|
-              if superclass.respond_to?(:scoping_handlers)
-                superclass.scoping_handlers.each do |k, v|
-                  handlers[k] = v.dup
-                end
-              end
-            end
-        end
-
-        # Define scope type matcher.
-        #
-        # Scope matcher is an object that implements `#===` (_case equality_) or a Proc.
-        #
-        # When no type is provided when applying a scope we try to infer a type
-        # from the target object by calling matchers one by one until we find a matching
-        # type (i.e. there is a matcher which returns `true` when applying it to the target).
-        def scope_matcher(type, class_or_proc)
-          scope_matchers << [type, class_or_proc]
-        end
-
-        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
-        end
-      end
-    end
-  end
-end