snfoil 0.9.0 → 1.0.0

data/lib/sn_foil/contexts/destroy_context.rb

@@ -1,164 +0,0 @@
-# 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], options.fetch(:authorize, :destroy?), **options)
-        options = destroy_hooks(**options)
-        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(**options)
-        options = setup_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_destroy(**options)
-        setup_destroy_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[: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_change(**options)
-        options = before_change_hooks.reduce(options) { |opts, hook| run_hook(hook, **opts) }
-        options = before_destroy(**options)
-        before_destroy_hooks.reduce(options) { |opts, hook| run_hook(hook, **opts) }
-      end
-
-      def after_destroy_save(options)
-        options = after_change(**options)
-        options = after_change_hooks.reduce(options) { |opts, hook| run_hook(hook, **opts) }
-        options = after_destroy(**options)
-        after_destroy_hooks.reduce(options) { |opts, hook| run_hook(hook, **opts) }
-      end
-
-      def after_destroy_save_success(options)
-        options = after_change_success(**options)
-        options = after_change_success_hooks.reduce(options) { |opts, hook| run_hook(hook, **opts) }
-        options = after_destroy_success(**options)
-        after_destroy_success_hooks.reduce(options) { |opts, hook| run_hook(hook, **opts) }
-      end
-
-      def after_destroy_save_failure(options)
-        options = after_change_failure(**options)
-        options = after_change_failure_hooks.reduce(options) { |opts, hook| run_hook(hook, **opts) }
-        options = after_destroy_failure(**options)
-        after_destroy_failure_hooks.reduce(options) { |opts, hook| run_hook(hook, **opts) }
-      end
-    end
-  end
-end

data/lib/sn_foil/contexts/index_context.rb

@@ -1,64 +0,0 @@
-# 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(**options)
-        options = setup_hooks.reduce(options) { |opts, hook| run_hook(hook, **opts) }
-        options = setup_index(**options)
-        setup_index_hooks.reduce(options) { |opts, hook| run_hook(hook, **opts) }
-      end
-    end
-  end
-end

data/lib/sn_foil/contexts/setup_context.rb

@@ -1,119 +0,0 @@
-# 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

@@ -1,61 +0,0 @@
-# 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(**options)
-        options = setup_hooks.reduce(options) { |opts, hook| run_hook(hook, **opts) }
-        options = setup_show(**options)
-        setup_show_hooks.reduce(options) { |opts, hook| run_hook(hook, **opts) }
-      end
-    end
-  end
-end

data/lib/sn_foil/contexts/update_context.rb

@@ -1,168 +0,0 @@
-# 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(id: id, **options, 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, options.fetch(:authorize, :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], options.fetch(:authorize, :update?), **options)
-        options = update_hooks(**options)
-        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(**options)
-        options = setup_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_update(**options)
-        setup_update_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[: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_change(**options)
-        options = before_change_hooks.reduce(options) { |opts, hook| run_hook(hook, **opts) }
-        options = before_update(**options)
-        before_update_hooks.reduce(options) { |opts, hook| run_hook(hook, **opts) }
-      end
-
-      def after_update_save(options)
-        options = after_change(**options)
-        options = after_change_hooks.reduce(options) { |opts, hook| run_hook(hook, **opts) }
-        options = after_update(**options)
-        after_update_hooks.reduce(options) { |opts, hook| run_hook(hook, **opts) }
-      end
-
-      def after_update_save_success(options)
-        options = after_change_success(**options)
-        options = after_change_success_hooks.reduce(options) { |opts, hook| run_hook(hook, **opts) }
-        options = after_update_success(**options)
-        after_update_success_hooks.reduce(options) { |opts, hook| run_hook(hook, **opts) }
-      end
-
-      def after_update_save_failure(options)
-        options = after_change_failure(**options)
-        options = after_change_failure_hooks.reduce(options) { |opts, hook| run_hook(hook, **opts) }
-        options = after_update_failure(**options)
-        after_update_failure_hooks.reduce(options) { |opts, hook| run_hook(hook, **opts) }
-      end
-    end
-  end
-end

data/lib/sn_foil/policy.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/concern'
-
-module SnFoil
-  module Policy
-    extend ActiveSupport::Concern
-
-    attr_reader :record, :entity
-    attr_accessor :options
-
-    def initialize(entity, record, options = {})
-      @record = record
-      @entity = entity
-      @options = options
-    end
-
-    def index?
-      false
-    end
-
-    def show?
-      false
-    end
-
-    def create?
-      false
-    end
-
-    def update?
-      false
-    end
-
-    def destroy?
-      false
-    end
-
-    def associate?
-      false
-    end
-
-    class Scope
-      attr_reader :scope, :entity
-
-      def initialize(scope, entity = nil)
-        @entity = entity
-        @scope = scope
-      end
-
-      def resolve
-        scope.all
-      end
-    end
-  end
-end