action_policy 0.5.0 → 0.5.5

data/lib/.rbnext/2.7/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? { |_1| exp.match?(_1) }
+      end
+    end
+
+    class << self
+      attr_accessor :ignore_expressions
+
+      if defined?(::Unparser) && defined?(::MethodSource)
+        def available?() ;  true; end
+
+        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; end
+
+        def print_method(_, _) ;  ""; end
+      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/3.0/action_policy/behaviours/thread_memoized.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module ActionPolicy
+  module PerThreadCache # :nodoc:
+    CACHE_KEY = "action_policy.per_thread_cache"
+
+    class << self
+      attr_writer :enabled
+
+      def enabled?() ;  @enabled == true; end
+
+      def fetch(key)
+        return yield unless enabled?
+
+        store = (Thread.current[CACHE_KEY] ||= {})
+
+        return store[key] if store.key?(key)
+
+        store[key] = yield
+      end
+
+      def clear_all
+        Thread.current[CACHE_KEY] = {}
+      end
+    end
+
+    # Turn off by default in test env
+    self.enabled = !(ENV["RAILS_ENV"] == "test" || ENV["RACK_ENV"] == "test")
+  end
+
+  module Behaviours
+    # Per-thread memoization for policies.
+    #
+    # Used by `policy_for` to re-use policy object for records.
+    #
+    # NOTE: don't forget to clear thread cache with ActionPolicy::PerThreadCache.clear_all
+    module ThreadMemoized
+      class << self
+        def prepended(base)
+          base.prepend InstanceMethods
+        end
+
+        alias_method :included, :prepended
+      end
+
+      module InstanceMethods # :nodoc:
+        def policy_for(record:, **opts)
+          __policy_thread_memoize__(record, **opts) { super(record: record, **opts) }
+        end
+      end
+
+      def __policy_thread_memoize__(record, **options)
+        cache_key = policy_for_cache_key(record: record, **options)
+
+        ActionPolicy::PerThreadCache.fetch(cache_key) { yield }
+      end
+    end
+  end
+end

data/lib/.rbnext/3.0/action_policy/ext/policy_cache_key.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module ActionPolicy
+  module Ext
+    # Adds #_policy_cache_key method to Object,
+    # which just call #policy_cache_key or #cache_key
+    # or #object_id (if `use_object_id` parameter is set to true).
+    #
+    # For other core classes returns string representation.
+    #
+    # Raises ArgumentError otherwise.
+    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_with_version if respond_to?(:cache_key_with_version)
+          return cache_key if respond_to?(:cache_key)
+
+          return object_id.to_s if use_object_id == true
+
+          raise ArgumentError, "object is not cacheable"
+        end
+      end
+
+      refine Object do
+        include ObjectExt
+      end
+
+      refine NilClass do
+        def _policy_cache_key(*) ;  ""; end
+      end
+
+      refine TrueClass do
+        def _policy_cache_key(*) ;  "t"; end
+      end
+
+      refine FalseClass do
+        def _policy_cache_key(*) ;  "f"; end
+      end
+
+      refine String do
+        def _policy_cache_key(*) ;  self; end
+      end
+
+      refine Symbol do
+        def _policy_cache_key(*) ;  to_s; end
+      end
+
+      if RUBY_PLATFORM.match?(/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
+
+      refine Time do
+        def _policy_cache_key(*) ;  to_s; end
+      end
+
+      refine Module do
+        def _policy_cache_key(*) ;  name; end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module ActionPolicy
+  module Policy
+    # Adds rules aliases support and ability to specify
+    # the default rule.
+    #
+    #   class ApplicationPolicy
+    #     include ActionPolicy::Policy::Core
+    #     include ActionPolicy::Policy::Aliases
+    #
+    #     # define which rule to use if `authorize!` called with
+    #     # unknown rule
+    #     default_rule :manage?
+    #
+    #     alias_rule :publish?, :unpublish?, to: :update?
+    #   end
+    #
+    # Aliases are used only during `authorize!` call (and do not act like _real_ aliases).
+    #
+    # Aliases useful when combined with `CachedApply` (since we can cache only the target rule).
+    module Aliases
+      DEFAULT = :__default__
+
+      class << self
+        def included(base)
+          base.extend ClassMethods
+        end
+      end
+
+      def resolve_rule(activity)
+        self.class.lookup_alias(activity) ||
+          (activity if respond_to?(activity)) ||
+          self.class.lookup_default_rule ||
+          super
+      end
+
+      module ClassMethods # :nodoc:
+        def default_rule(val)
+          rules_aliases[DEFAULT] = val
+        end
+
+        def alias_rule(*rules, to:)
+          rules.each do |rule|
+            rules_aliases[rule] = to
+          end
+        end
+
+        def lookup_alias(rule) ;  rules_aliases[rule]; end
+
+        def lookup_default_rule() ;  rules_aliases[DEFAULT]; end
+
+        def rules_aliases
+          return @rules_aliases if instance_variable_defined?(:@rules_aliases)
+
+          @rules_aliases = if superclass.respond_to?(:rules_aliases)
+            superclass.rules_aliases.dup
+          else
+            {}
+          end
+        end
+
+        def method_added(name)
+          rules_aliases.delete(name) if public_method_defined?(name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+# 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._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 { _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.value
+          end
+          yield
+          store.write(key, result, options)
+          result.value
+        end
+      end
+
+      def apply(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