snfoil 0.6

data/lib/sn_foil/contexts/destroy_context.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require_relative './setup_context'
+require_relative './change_context'
+
+module SnFoil
+  module Contexts
+    module DestroyContext # rubocop:disable Metrics/ModuleLength
+      extend ActiveSupport::Concern
+
+      included do
+        include SetupContext
+        include ChangeContext
+      end
+
+      class_methods do
+        attr_reader :i_setup_destroy_hooks, :i_before_destroy_hooks, :i_after_destroy_hooks,
+                    :i_after_destroy_success_hooks, :i_after_destroy_failure_hooks
+        def destroy(id:, entity: nil, **options)
+          new(entity).destroy(**options, id: id)
+        end
+
+        def setup_destroy(method = nil, **options, &block)
+          raise ArgumentError, '#setup_destroy requires either a method name or a block' if method.nil? && block.nil?
+
+          (@i_setup_destroy_hooks ||= []) << { method: method, block: block, if: options[:if], unless: options[:unless] }
+        end
+
+        def before_destroy(method = nil, **options, &block)
+          raise ArgumentError, '#before_destroy requires either a method name or a block' if method.nil? && block.nil?
+
+          (@i_before_destroy_hooks ||= []) << { method: method, block: block, if: options[:if], unless: options[:unless] }
+        end
+
+        def after_destroy(method = nil, **options, &block)
+          raise ArgumentError, '#after_destroy requires either a method name or a block' if method.nil? && block.nil?
+
+          (@i_after_destroy_hooks ||= []) << { method: method, block: block, if: options[:if], unless: options[:unless] }
+        end
+
+        def after_destroy_success(method = nil, **options, &block)
+          raise ArgumentError, '#after_destroy_success requires either a method name or a block' if method.nil? && block.nil?
+
+          (@i_after_destroy_success_hooks ||= []) << { method: method, block: block, if: options[:if], unless: options[:unless] }
+        end
+
+        def after_destroy_failure(method = nil, **options, &block)
+          raise ArgumentError, '#after_destroy_failure requires either a method name or a block' if method.nil? && block.nil?
+
+          (@i_after_destroy_failure_hooks ||= []) << { method: method, block: block, if: options[:if], unless: options[:unless] }
+        end
+      end
+
+      def setup_destroy_object(id: nil, object: nil, **options)
+        raise ArgumentError, 'one of the following keywords is required: id, object' unless id || object
+
+        options.merge! object: wrap_object(object || scope.resolve.find(id))
+      end
+
+      def destroy(**options)
+        options[:action] = :destroy
+        options = before_setup_destroy_object(**options)
+        options = setup_destroy_object(**options)
+        authorize(options[:object], :destroy?, **options)
+        options = destroy_hooks(**options)
+        unwrap_object(options[:object])
+      end
+
+      def setup_destroy(**options)
+        options
+      end
+
+      def before_destroy(**options)
+        options
+      end
+
+      def after_destroy(**options)
+        options
+      end
+
+      def after_destroy_success(**options)
+        options
+      end
+
+      def after_destroy_failure(**options)
+        options
+      end
+
+      def setup_destroy_hooks
+        self.class.i_setup_destroy_hooks || []
+      end
+
+      def before_destroy_hooks
+        self.class.i_before_destroy_hooks || []
+      end
+
+      def after_destroy_hooks
+        self.class.i_after_destroy_hooks || []
+      end
+
+      def after_destroy_success_hooks
+        self.class.i_after_destroy_success_hooks || []
+      end
+
+      def after_destroy_failure_hooks
+        self.class.i_after_destroy_failure_hooks || []
+      end
+
+      private
+
+      def before_setup_destroy_object(**options)
+        options = setup_destroy(**options)
+        options = setup_destroy_hooks.reduce(options) { |opts, hook| run_hook(hook, opts) }
+        options = setup_change(**options)
+        options = setup_change_hooks.reduce(options) { |opts, hook| run_hook(hook, opts) }
+        options = setup(**options)
+        setup_hooks.reduce(options) { |opts, hook| run_hook(hook, opts) }
+      end
+
+      # This method is private to help protect the order of execution of hooks
+      def destroy_hooks(options)
+        options = before_destroy_save(options)
+        destroy_successful = options[:object].destroy
+        options.merge!(object: unwrap_object(options[:object]))
+        options = if destroy_successful
+                    after_destroy_save_success(options)
+                  else
+                    after_destroy_save_failure(options)
+                  end
+        after_destroy_save(options)
+      end
+
+      def before_destroy_save(options)
+        options = before_destroy(**options)
+        options = before_destroy_hooks.reduce(options) { |opts, hook| run_hook(hook, **opts) }
+        options = before_change(**options)
+        before_change_hooks.reduce(options) { |opts, hook| run_hook(hook, **opts) }
+      end
+
+      def after_destroy_save(options)
+        options = after_destroy(**options)
+        options = after_destroy_hooks.reduce(options) { |opts, hook| run_hook(hook, **opts) }
+        options = after_change(**options)
+        after_change_hooks.reduce(options) { |opts, hook| run_hook(hook, **opts) }
+      end
+
+      def after_destroy_save_success(options)
+        options = after_destroy_success(**options)
+        options = after_destroy_success_hooks.reduce(options) { |opts, hook| run_hook(hook, **opts) }
+        options = after_change_success(**options)
+        after_change_success_hooks.reduce(options) { |opts, hook| run_hook(hook, **opts) }
+      end
+
+      def after_destroy_save_failure(options)
+        options = after_destroy_failure(**options)
+        options = after_destroy_failure_hooks.reduce(options) { |opts, hook| run_hook(hook, **opts) }
+        options = after_change_failure(**options)
+        after_change_failure_hooks.reduce(options) { |opts, hook| run_hook(hook, **opts) }
+      end
+    end
+  end
+end

data/lib/sn_foil/contexts/index_context.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require_relative './change_context'
+
+module SnFoil
+  module Contexts
+    module IndexContext
+      extend ActiveSupport::Concern
+
+      included do
+        include SetupContext
+      end
+
+      class_methods do
+        attr_reader :i_searcher, :i_setup_index_hooks
+
+        def index(params: {}, entity: nil, **options)
+          new(entity).index(**options, params: params)
+        end
+
+        def searcher(klass = nil)
+          @i_searcher = klass
+        end
+
+        def setup_index(method = nil, **options, &block)
+          raise ArgumentError, '#setup_index requires either a method name or a block' if method.nil? && block.nil?
+
+          (@i_setup_index_hooks ||= []) << { method: method, block: block, if: options[:if], unless: options[:unless] }
+        end
+      end
+
+      def searcher
+        self.class.i_searcher
+      end
+
+      def setup_index_hooks
+        self.class.i_setup_index_hooks || []
+      end
+
+      def index(**options)
+        options[:action] = :index
+        options = before_setup_index(**options)
+        authorize(nil, :index?, **options)
+        options.fetch(:searcher) { searcher }
+               .new(scope: scope.resolve)
+               .search(options.fetch(:params) { {} })
+      end
+
+      def setup_index(**options)
+        options
+      end
+
+      private
+
+      def before_setup_index(**options)
+        options = setup_index(**options)
+        options = setup_index_hooks.reduce(options) { |opts, hook| run_hook(hook, opts) }
+        options = setup(**options)
+        setup_hooks.reduce(options) { |opts, hook| run_hook(hook, opts) }
+      end
+    end
+  end
+end

data/lib/sn_foil/contexts/setup_context.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require 'active_support/core_ext/string/inflections'
+
+module SnFoil
+  module Contexts
+    module SetupContext
+      extend ActiveSupport::Concern
+
+      class_methods do
+        attr_reader :i_model, :i_policy, :i_setup_hooks
+
+        def model(klass = nil)
+          @i_model = klass
+        end
+
+        def policy(klass = nil)
+          @i_policy = klass
+        end
+
+        def setup(method = nil, **options, &block)
+          raise ArgumentError, '#setup requires either a method name or a block' if method.nil? && block.nil?
+
+          (@i_setup_hooks ||= []) << { method: method, block: block, if: options[:if], unless: options[:unless] }
+        end
+      end
+
+      def model
+        self.class.i_model
+      end
+
+      def policy
+        self.class.i_policy
+      end
+
+      def setup(**options)
+        options
+      end
+
+      def setup_hooks
+        self.class.i_setup_hooks || []
+      end
+
+      attr_reader :entity
+      def initialize(entity = nil)
+        @entity = entity
+      end
+
+      def authorize(object, action, **options)
+        return unless entity # Add logging
+
+        policy = lookup_policy(object, options)
+        raise Pundit::NotAuthorizedError, query: action, record: object, policy: policy unless policy.public_send(action)
+
+        true
+      end
+
+      def scope(object_class = nil, **options)
+        object_class ||= model
+        policy_name = lookup_policy(object_class, options).class.name
+        "#{policy_name}::Scope".safe_constantize.new(wrap_object(object_class), entity)
+      end
+
+      def wrap_object(object)
+        return object unless adapter
+
+        adapter.new(object)
+      end
+
+      def unwrap_object(object)
+        return object unless adapter
+
+        adapter?(object) ? object.__getobj__ : object
+      end
+
+      def adapter?(object)
+        return false unless adapter
+
+        object.instance_of? adapter
+      end
+
+      def adapter
+        @adapter ||= SnFoil.adapter
+      end
+
+      def run_hook(hook, **options)
+        return options unless hook_valid?(hook, **options)
+
+        return send(hook[:method], **options) if hook[:method]
+
+        instance_exec options, &hook[:block]
+      end
+
+      def hook_valid?(hook, **options)
+        return false if !hook[:if].nil? && hook[:if].call(options) == false
+        return false if !hook[:unless].nil? && hook[:unless].call(options) == true
+
+        true
+      end
+
+      private
+
+      def lookup_policy(object, options)
+        lookup = if options[:policy]
+                   options[:policy].new(entity, object)
+                 elsif policy
+                   policy.new(entity, object)
+                 else
+                   Pundit.policy!(entity, object)
+                 end
+
+        lookup.options = options if lookup.respond_to? :options=
+        lookup
+      end
+    end
+  end
+end

data/lib/sn_foil/contexts/show_context.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require_relative './setup_context'
+
+module SnFoil
+  module Contexts
+    module ShowContext
+      extend ActiveSupport::Concern
+
+      included do
+        include SetupContext
+      end
+
+      class_methods do
+        attr_reader :i_setup_show_hooks
+
+        def show(id:, entity: nil, **options)
+          new(entity).show(**options, id: id)
+        end
+
+        def setup_show(method = nil, **options, &block)
+          raise ArgumentError, '#setup_show requires either a method name or a block' if method.nil? && block.nil?
+
+          (@i_setup_show_hooks ||= []) << { method: method, block: block, if: options[:if], unless: options[:unless] }
+        end
+      end
+
+      def setup_show_object(id: nil, object: nil, **options)
+        raise ArgumentError, 'one of the following keywords is required: id, object' unless id || object
+
+        options.merge! object: wrap_object(object || scope.resolve.find(id))
+      end
+
+      def setup_show_hooks
+        self.class.i_setup_show_hooks || []
+      end
+
+      def show(**options)
+        options[:action] = :show
+        options = before_setup_show(**options)
+        options = setup_show_object(**options)
+        authorize(options[:object], :show?, **options)
+        unwrap_object options[:object]
+      end
+
+      def setup_show(**options)
+        options
+      end
+
+      private
+
+      def before_setup_show(**options)
+        options = setup_show(**options)
+        options = setup_show_hooks.reduce(options) { |opts, hook| run_hook(hook, opts) }
+        options = setup(**options)
+        setup_hooks.reduce(options) { |opts, hook| run_hook(hook, opts) }
+      end
+    end
+  end
+end

data/lib/sn_foil/contexts/update_context.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require_relative './setup_context'
+require_relative './change_context'
+
+module SnFoil
+  module Contexts
+    module UpdateContext # rubocop:disable Metrics/ModuleLength
+      extend ActiveSupport::Concern
+
+      included do
+        include SetupContext
+        include ChangeContext
+      end
+
+      class_methods do
+        attr_reader :i_setup_update_hooks, :i_before_update_hooks, :i_after_update_hooks,
+                    :i_after_update_success_hooks, :i_after_update_failure_hooks
+        def update(id:, params:, entity: nil, **options)
+          new(entity).update(**options, id: id, params: params)
+        end
+
+        def setup_update(method = nil, **options, &block)
+          raise ArgumentError, '#setup_update requires either a method name or a block' if method.nil? && block.nil?
+
+          (@i_setup_update_hooks ||= []) << { method: method, block: block, if: options[:if], unless: options[:unless] }
+        end
+
+        def before_update(method = nil, **options, &block)
+          raise ArgumentError, '#before_update requires either a method name or a block' if method.nil? && block.nil?
+
+          (@i_before_update_hooks ||= []) << { method: method, block: block, if: options[:if], unless: options[:unless] }
+        end
+
+        def after_update(method = nil, **options, &block)
+          raise ArgumentError, '#after_update requires either a method name or a block' if method.nil? && block.nil?
+
+          (@i_after_update_hooks ||= []) << { method: method, block: block, if: options[:if], unless: options[:unless] }
+        end
+
+        def after_update_success(method = nil, **options, &block)
+          raise ArgumentError, '#after_update_success requires either a method name or a block' if method.nil? && block.nil?
+
+          (@i_after_update_success_hooks ||= []) << { method: method, block: block, if: options[:if], unless: options[:unless] }
+        end
+
+        def after_update_failure(method = nil, **options, &block)
+          raise ArgumentError, '#after_update_failure requires either a method name or a block' if method.nil? && block.nil?
+
+          (@i_after_update_failure_hooks ||= []) << { method: method, block: block, if: options[:if], unless: options[:unless] }
+        end
+      end
+
+      def setup_update_object(params: {}, id: nil, object: nil, **options)
+        raise ArgumentError, 'one of the following keywords is required: id, object' unless id || object
+
+        object = wrap_object(object || scope.resolve.find(id))
+        authorize(object, :update?, **options)
+        object.attributes = params
+        options.merge! object: object
+      end
+
+      def update(**options)
+        options[:action] = :update
+        options = before_setup_update_object(**options)
+        options = setup_update_object(**options)
+        authorize(options[:object], :update?, **options)
+        options = update_hooks(**options)
+        unwrap_object(options[:object])
+      end
+
+      def setup_update(**options)
+        options
+      end
+
+      def before_update(**options)
+        options
+      end
+
+      def after_update(**options)
+        options
+      end
+
+      def after_update_success(**options)
+        options
+      end
+
+      def after_update_failure(**options)
+        options
+      end
+
+      def setup_update_hooks
+        self.class.i_setup_update_hooks || []
+      end
+
+      def before_update_hooks
+        self.class.i_before_update_hooks || []
+      end
+
+      def after_update_hooks
+        self.class.i_after_update_hooks || []
+      end
+
+      def after_update_success_hooks
+        self.class.i_after_update_success_hooks || []
+      end
+
+      def after_update_failure_hooks
+        self.class.i_after_update_failure_hooks || []
+      end
+
+      private
+
+      def before_setup_update_object(**options)
+        options = setup_update(**options)
+        options = setup_update_hooks.reduce(options) { |opts, hook| run_hook(hook, opts) }
+        options = setup_change(**options)
+        options = setup_change_hooks.reduce(options) { |opts, hook| run_hook(hook, opts) }
+        options = setup(**options)
+        setup_hooks.reduce(options) { |opts, hook| run_hook(hook, opts) }
+      end
+
+      # This method is private to help protect the order of execution of hooks
+      def update_hooks(options)
+        options = before_update_save(options)
+        update_successful = options[:object].save
+        options.merge!(object: unwrap_object(options[:object]))
+        options = if update_successful
+                    after_update_save_success(options)
+                  else
+                    after_update_save_failure(options)
+                  end
+        after_update_save(options)
+      end
+
+      def before_update_save(options)
+        options = before_update(**options)
+        options = before_update_hooks.reduce(options) { |opts, hook| run_hook(hook, **opts) }
+        options = before_change(**options)
+        before_change_hooks.reduce(options) { |opts, hook| run_hook(hook, **opts) }
+      end
+
+      def after_update_save(options)
+        options = after_update(**options)
+        options = after_update_hooks.reduce(options) { |opts, hook| run_hook(hook, **opts) }
+        options = after_change(**options)
+        after_change_hooks.reduce(options) { |opts, hook| run_hook(hook, **opts) }
+      end
+
+      def after_update_save_success(options)
+        options = after_update_success(**options)
+        options = after_update_success_hooks.reduce(options) { |opts, hook| run_hook(hook, **opts) }
+        options = after_change_success(**options)
+        after_change_success_hooks.reduce(options) { |opts, hook| run_hook(hook, **opts) }
+      end
+
+      def after_update_save_failure(options)
+        options = after_update_failure(**options)
+        options = after_update_failure_hooks.reduce(options) { |opts, hook| run_hook(hook, **opts) }
+        options = after_change_failure(**options)
+        after_change_failure_hooks.reduce(options) { |opts, hook| run_hook(hook, **opts) }
+      end
+    end
+  end
+end