snfoil 0.1.0

data/lib/sn_foil/contexts/create_context_concern.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require_relative './setup_context_concern'
+require_relative './change_context_concern'
+
+module SnFoil
+  module Contexts
+    module CreateContextConcern # rubocop:disable Metrics/ModuleLength
+      extend ActiveSupport::Concern
+
+      included do
+        include SetupContextConcern
+        include ChangeContextConcern
+      end
+
+      class_methods do
+        attr_reader :i_before_create_hooks, :i_after_create_hooks, :i_after_create_success_hooks, :i_after_create_failure_hooks
+        def create(params:, user: nil, **options)
+          new(user).create(**options, params: params)
+        end
+
+        def before_create(method = nil, **options, &block)
+          raise ArgumentError, '#on_create requires either a method name or a block' if method.nil? && block.nil?
+
+          (@i_before_create_hooks ||= []) << { method: method, block: block, if: options[:if], unless: options[:unless] }
+        end
+
+        def after_create(method = nil, **options, &block)
+          raise ArgumentError, '#after_create requires either a method name or a block' if method.nil? && block.nil?
+
+          (@i_after_create_hooks ||= []) << { method: method, block: block, if: options[:if], unless: options[:unless] }
+        end
+
+        def after_create_success(method = nil, **options, &block)
+          raise ArgumentError, '#after_create_success requires either a method name or a block' if method.nil? && block.nil?
+
+          (@i_after_create_success_hooks ||= []) << { method: method, block: block, if: options[:if], unless: options[:unless] }
+        end
+
+        def after_create_failure(method = nil, **options, &block)
+          raise ArgumentError, '#after_create_failure requires either a method name or a block' if method.nil? && block.nil?
+
+          (@i_after_create_failure_hooks ||= []) << { method: method, block: block, if: options[:if], unless: options[:unless] }
+        end
+      end
+
+      def setup_create_object(params: {}, object: nil, **options)
+        object = if object
+                   wrap_object(object)
+                 else
+                   klass = options.fetch(:model) { model }
+                   wrap_object(klass).new
+                 end
+
+        object.attributes = params
+        options.merge! object: object
+      end
+
+      def create(**options)
+        options[:action] = :create
+        options = setup_change(setup_create(**options))
+        options = setup_create_object(**options)
+        authorize(options[:object], :create?, **options)
+        options = create_hooks(**options)
+        unwrap_object(options[:object])
+      end
+
+      def setup_create(**options)
+        options
+      end
+
+      def before_create(**options)
+        options
+      end
+
+      def after_create(**options)
+        options
+      end
+
+      def after_create_success(**options)
+        options
+      end
+
+      def after_create_failure(**options)
+        options
+      end
+
+      def before_create_hooks
+        self.class.i_before_create_hooks || []
+      end
+
+      def after_create_hooks
+        self.class.i_after_create_hooks || []
+      end
+
+      def after_create_success_hooks
+        self.class.i_after_create_success_hooks || []
+      end
+
+      def after_create_failure_hooks
+        self.class.i_after_create_failure_hooks || []
+      end
+
+      private
+
+      # This method is private to help protect the order of execution of hooks
+      def create_hooks(options)
+        options = before_create_save(**options)
+        options = if options[:object].save
+                    after_create_save_success(**options)
+                  else
+                    after_create_save_failure(**options)
+                  end
+        after_create_save(**options)
+      end
+
+      def before_create_save(**options)
+        options = before_create(**options)
+        options = before_create_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_create_save(**options)
+        options = after_create(**options)
+        options = after_create_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_create_save_success(**options)
+        options = after_create_success(**options)
+        options = after_create_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_create_save_failure(**options)
+        options = after_create_failure(**options)
+        options = after_create_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/destroy_context_concern.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require_relative './setup_context_concern'
+require_relative './change_context_concern'
+
+module SnFoil
+  module Contexts
+    module DestroyContextConcern
+      extend ActiveSupport::Concern
+
+      included do
+        include SetupContextConcern
+        include ChangeContextConcern
+      end
+
+      class_methods do
+        attr_reader :i_before_destroy_hooks, :i_after_destroy_hooks, :i_after_destroy_success_hooks, :i_after_destroy_failure_hooks
+        def destroy(id:, user: nil, **options)
+          new(user).destroy(**options, id: id)
+        end
+
+        def before_destroy(method = nil, **options, &block)
+          raise ArgumentError, '#on_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 = setup_destroy(setup_change(**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 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
+
+      # This method is private to help protect the order of execution of hooks
+      def destroy_hooks(options)
+        options = before_destroy_save(options)
+        options = if options[:object].destroy
+                    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_concern.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require_relative './change_context_concern'
+
+module SnFoil
+  module Contexts
+    module IndexContextConcern
+      extend ActiveSupport::Concern
+
+      included do
+        include SetupContextConcern
+      end
+
+      class_methods do
+        attr_reader :i_searcher
+
+        def index(params: {}, user: nil, **options)
+          new(user).index(**options, params: params)
+        end
+
+        def searcher(klass = nil)
+          @i_searcher = klass
+        end
+      end
+
+      def searcher
+        self.class.i_searcher
+      end
+
+      def index(params:, **options)
+        options[:action] = :index
+        options = setup_index(**options)
+        options.fetch(:searcher) { searcher }
+               .new(scope: scope.resolve)
+               .search(params: params)
+      end
+
+      # Param manipulation based on User should be done here
+      def setup_index(**options)
+        options
+      end
+    end
+  end
+end

data/lib/sn_foil/contexts/setup_context_concern.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require 'active_support/core_ext/string/inflections'
+
+module SnFoil
+  module Contexts
+    module SetupContextConcern
+      extend ActiveSupport::Concern
+
+      class_methods do
+        attr_reader :i_model, :i_policy
+
+        def model(klass = nil)
+          @i_model = klass
+        end
+
+        def policy(klass = nil)
+          @i_policy = klass
+        end
+      end
+
+      def model
+        self.class.i_model
+      end
+
+      def policy
+        self.class.i_policy
+      end
+
+      attr_reader :user
+      def initialize(user = nil)
+        @user = user
+      end
+
+      def authorize(object, action, **options)
+        return unless user # Add logging
+
+        lookup_policy(object, options).send(action)
+      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), user)
+      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
+
+      private
+
+      def lookup_policy(object, options)
+        return options[:policy].new(user, object) if options[:policy]
+        return policy.new(user, object) if policy
+
+        Pundit.policy!(user, object)
+      end
+    end
+  end
+end

data/lib/sn_foil/contexts/show_context_concern.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require_relative './setup_context_concern'
+
+module SnFoil
+  module Contexts
+    module ShowContextConcern
+      extend ActiveSupport::Concern
+
+      included do
+        include SetupContextConcern
+      end
+
+      class_methods do
+        def show(id:, user: nil, **options)
+          new(user).show(**options, id: id)
+        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 show(**options)
+        options[:action] = :show
+        options = setup_show_object(**options)
+        authorize(options[:object], :show?, **options)
+        unwrap_object options[:object]
+      end
+    end
+  end
+end

data/lib/sn_foil/contexts/update_context_concern.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require_relative './setup_context_concern'
+require_relative './change_context_concern'
+
+module SnFoil
+  module Contexts
+    module UpdateContextConcern # rubocop:disable Metrics/ModuleLength
+      extend ActiveSupport::Concern
+
+      included do
+        include SetupContextConcern
+        include ChangeContextConcern
+      end
+
+      class_methods do
+        attr_reader :i_before_update_hooks, :i_after_update_hooks, :i_after_update_success_hooks, :i_after_update_failure_hooks
+        def update(id:, params:, user: nil, **options)
+          new(user).update(**options, id: id, params: params)
+        end
+
+        def before_update(method = nil, **options, &block)
+          raise ArgumentError, '#on_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 = setup_change(setup_update(**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 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
+
+      # This method is private to help protect the order of execution of hooks
+      def update_hooks(options)
+        options = before_update_save(options)
+        options = if options[:object].save
+                    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

data/lib/sn_foil/policy.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+
+module SnFoil
+  module Policy
+    extend ActiveSupport::Concern
+
+    attr_reader :record, :entity
+    def initialize(record, entity = nil)
+      @record = record
+      @entity = entity
+    end
+
+    def index?
+      false
+    end
+
+    def show?
+      false
+    end
+
+    def create?
+      false
+    end
+
+    def update?
+      false
+    end
+
+    def destroy?
+      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