snfoil-rails 0.1.0 → 0.3.0

data/lib/sn_foil/rails/controller/api.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require 'action_controller/api'
-require_relative 'concerns/create_controller_concern'
-require_relative 'concerns/destroy_controller_concern'
-require_relative 'concerns/index_controller_concern'
-require_relative 'concerns/show_controller_concern'
-require_relative 'concerns/update_controller_concern'
-
-module SnFoil
-  module Rails
-    module Controller
-      class API < ::ActionController::API
-        include Concerns::CreateControllerConcern
-        include Concerns::DestroyControllerConcern
-        include Concerns::IndexControllerConcern
-        include Concerns::ShowControllerConcern
-        include Concerns::UpdateControllerConcern
-      end
-    end
-  end
-end

data/lib/sn_foil/rails/controller/concerns/change_controller_concern.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/concern'
-require_relative 'setup_controller_concern'
-
-module SnFoil
-  module Rails
-    module Controller
-      module Concerns
-        module ChangeControllerConcern
-          extend ActiveSupport::Concern
-
-          included do
-            include SetupControllerConcern
-          end
-
-          def render_change(model, **_options)
-            if model.errors.empty?
-              render model
-            else
-              render model.errors, status: :unprocessable_entity
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/sn_foil/rails/controller/concerns/create_controller_concern.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/concern'
-require_relative 'setup_controller_concern'
-require_relative 'change_controller_concern'
-
-module SnFoil
-  module Rails
-    module Controller
-      module Concerns
-        module CreateControllerConcern
-          extend ActiveSupport::Concern
-
-          included do
-            include SetupControllerConcern
-            include ChangeControllerConcern
-          end
-
-          def create(**options)
-            options = setup_create(**options)
-            model = process_create(**options)
-            render_create(model, **options)
-          end
-
-          def setup_create(**options)
-            setup_options(**options.merge(deserialize: true))
-          end
-
-          def process_create(**options)
-            current_context(**options).create(**options)
-          end
-
-          def render_create(model, **options)
-            render_change(model, **options)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/sn_foil/rails/controller/concerns/destroy_controller_concern.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/concern'
-require_relative 'setup_controller_concern'
-
-module SnFoil
-  module Rails
-    module Controller
-      module Concerns
-        module DestroyControllerConcern
-          extend ActiveSupport::Concern
-
-          included do
-            include SetupControllerConcern
-          end
-
-          def destroy(**options)
-            options = setup_update(**options)
-            model = process_destroy(**options)
-            render_destroy(model, **options)
-          end
-
-          def setup_destroy(**options)
-            setup_options(**options)
-          end
-
-          def process_destroy(**options)
-            current_context(**options).destroy(**options)
-          end
-
-          def render_destroy(model, **_options)
-            if model.errors.empty?
-              render nil
-            else
-              render model.errors, status: :unprocessable_entity
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/sn_foil/rails/controller/concerns/index_controller_concern.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/concern'
-require_relative 'setup_controller_concern'
-
-module SnFoil
-  module Rails
-    module Controller
-      module Concerns
-        module IndexControllerConcern
-          extend ActiveSupport::Concern
-
-          included do
-            include SetupControllerConcern
-          end
-
-          def index(**options)
-            options = setup_index(**options)
-            results = process_index(**options)
-            render_index(results, **options)
-          end
-
-          def setup_index(**options)
-            setup_options(**options)
-          end
-
-          def process_index(**options)
-            searcher = options.fetch(:searcher) do
-              current_context(**options).index(options)
-            end
-            searcher.results
-          end
-
-          def render_index(results, **options)
-            paginate(results, **options)
-          end
-
-          def paginate(results, **options)
-            return results unless results.respond_to?(:page)
-
-            results.page(page(**options))
-                   .per(per_page(**options))
-          end
-
-          def page(**options)
-            options[:params].fetch(:page, 1).to_i
-          end
-
-          def per_page(**options)
-            per_page_param = options[:params].fetch(:per_page, 10).to_i
-            return 10_000 if per_page_param.zero?
-
-            per_page_param
-          end
-
-          def meta(results, **options)
-            total_pages = results&.total_pages
-            total_count = results&.total_count
-            paginated = total_pages && total_count
-
-            {
-              page: paginated ? page(**options) : nil,
-              pages: total_pages || 1,
-              total: total_count || 1,
-              per: paginated ? per_page(**options) : nil
-            }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/sn_foil/rails/controller/concerns/setup_controller_concern.rb

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/concern'
-
-module SnFoil
-  module Rails
-    module Controller
-      module Concerns
-        module SetupControllerConcern
-          extend ActiveSupport::Concern
-
-          class_methods do
-            attr_reader :i_deserializer, :i_serializer, :i_context
-
-            def context(klass = nil)
-              @i_context = klass
-            end
-
-            def serializer(klass = nil)
-              @i_serializer = klass
-            end
-
-            def deserializer(klass = nil)
-              @i_deserializer = klass
-            end
-          end
-
-          def context(**options)
-            options[:context] || self.class.i_context
-          end
-
-          def serializer(**options)
-            options[:serializer] || self.class.i_serializer
-          end
-
-          def deserializer(**options)
-            options[:deserializer] || self.class.i_deserializer
-          end
-
-          def setup_options(**options)
-            options = inject_params(**options)
-            options = inject_id(**options)
-            options = inject_includes(**options)
-            options = inject_controller_action(**options)
-            inject_deserialized_params(**options)
-          end
-
-          def current_context(**options)
-            @current_context ||= context(**options).new(context_user)
-          end
-
-          protected
-
-          def pundit_not_authorized
-            head :forbidden
-          end
-
-          private
-
-          # Grab the rails params and inject them into the options
-          def inject_params(**options)
-            return options unless params
-
-            options[:params] = params.to_unsafe_h.deep_symbolize_keys
-            options[:controller_params] = options[:params]
-            options
-          end
-
-          def inject_id(**options)
-            return options if options[:id]
-
-            options[:id] = id if defined? id
-            options[:id] ||= options[:params][:id]
-            options
-          end
-
-          def inject_includes(**options)
-            return options if options[:include]
-            return options unless options.dig(:params, :include)
-
-            options[:include] = options.dig(:params, :include)
-                                       .split(',')
-                                       .map { |item| item.underscore.to_sym }
-            options
-          end
-
-          def inject_controller_action(**options)
-            return options if options[:controller_action]
-            return options unless options.dig(:params, :action)
-
-            options[:controller_action] = options[:params][:action]
-            options
-          end
-
-          def inject_deserialized_params(**options)
-            return options unless options[:params].present? && options[:deserialize] == true
-            return options unless deserializer(**options)
-
-            options[:params] = deserializer(**options).new(options[:params], **options).to_h
-            options
-          end
-
-          def context_user
-            return current_user if defined? current_user
-          end
-        end
-      end
-    end
-  end
-end

data/lib/sn_foil/rails/controller/concerns/show_controller_concern.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/concern'
-require_relative 'setup_controller_concern'
-
-module SnFoil
-  module Rails
-    module Controller
-      module Concerns
-        module ShowControllerConcern
-          extend ActiveSupport::Concern
-
-          included do
-            include SetupControllerConcern
-          end
-
-          def show(**options)
-            options = setup_show(**options)
-            model = process_show(**options)
-            render_show(model, **options)
-          end
-
-          def setup_show(**options)
-            setup_options(**options)
-          end
-
-          def process_show(**options)
-            current_context(**options).show(**options)
-          end
-
-          def render_show(model, **_options)
-            render model
-          end
-        end
-      end
-    end
-  end
-end

data/lib/sn_foil/rails/controller/concerns/update_controller_concern.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/concern'
-require_relative 'setup_controller_concern'
-require_relative 'change_controller_concern'
-
-module SnFoil
-  module Rails
-    module Controller
-      module Concerns
-        module UpdateControllerConcern
-          extend ActiveSupport::Concern
-
-          included do
-            include SetupControllerConcern
-            include ChangeControllerConcern
-          end
-
-          def update(**options)
-            options = setup_update(**options)
-            model = process_update(**options)
-            render_update(model, **options)
-          end
-
-          def setup_update(**options)
-            setup_options(**options.merge(deserialize: true))
-          end
-
-          def process_update(**options)
-            current_context(**options).update(**options)
-          end
-
-          def render_update(model, **options)
-            render_change(model, **options)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/sn_foil/rails/railtie.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails/railtie'
-
-module SnFoil
-  module Rails
-    class Railtie < ::Rails::Railtie
-    end
-  end
-end

data/lib/sn_foil/rails/searcher.rb

@@ -1,127 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/concern'
-require 'sn_foil/searcher'
-
-module SnFoil
-  module Rails
-    module Searcher
-      extend ActiveSupport::Concern
-
-      included do
-        include SnFoil::Searcher
-
-        module_eval do
-          alias_method :base_search, :search
-
-          # patch the additional search capabilities into the method
-          def search(params = {})
-            filtered_scope = base_search(params)
-            additional_search(filtered_scope, params)
-          end
-        end
-
-        ASC ||= 'ASC'
-        DESC ||= 'DESC'
-      end
-
-      class_methods do
-        attr_reader :i_include_params, :i_order_method, :i_order_block, :i_order_by_attr, :i_order_by_direction, :i_is_distinct
-
-        def order(method = nil, &block)
-          @i_order_method = method
-          @i_order_block = block
-        end
-
-        def order_by(attr, direction = nil)
-          @i_order_by_attr = attr
-          @i_order_by_direction = direction
-        end
-
-        def distinct(bool = true)
-          @i_is_distinct = bool
-        end
-
-        def includes(*array)
-          @i_include_params ||= [] # create new array if none exists
-          @i_include_params |= array # combine unique elements of both arrays
-        end
-      end
-
-      def distinct?
-        self.class.i_is_distinct || false
-      end
-
-      def included_params
-        self.class.i_include_params
-      end
-
-      def order_by(params = {})
-        if params[:order_by].present?
-          params[:order_by] = params[:order_by].to_s.underscore
-          return params[:order_by].to_sym if model.attribute_names.include?(params[:order_by])
-        end
-
-        self.class.i_order_by_attr || :id
-      end
-
-      def order(params = {})
-        if params[:order].present?
-          params[:order] = params[:order].to_s.upcase
-          return params[:order] if params[:order].eql?(ASC) || params[:order].eql?(DESC)
-        end
-
-        self.class.i_order_by_direction || ASC
-      end
-
-      private
-
-      def additional_search(filtered_scope, params = {})
-        filtered_scope = apply_order(filtered_scope, params)
-        filtered_scope = apply_includes(filtered_scope)
-        apply_distinct(filtered_scope, params)
-      end
-
-      def apply_includes(filtered_scope)
-        return filtered_scope unless included_params
-
-        filtered_scope.includes(*included_params)
-      end
-
-      def apply_order(filtered_scope, params)
-        return apply_default_order(filtered_scope, params) if params[:order_by].blank? && params[:order].blank?
-
-        filtered_scope.order(order_by(params) => order(params))
-      end
-
-      def apply_default_order(filtered_scope, params)
-        return order_method(filtered_scope, params) if order_method?
-        return order_block(filtered_scope, params) if order_block?
-
-        filtered_scope.order(order_by => order)
-      end
-
-      def order_method(filtered_scope, params)
-        send(self.class.i_order_method, filtered_scope, params)
-      end
-
-      def order_method?
-        self.class.i_order_method.present?
-      end
-
-      def order_block(filtered_scope, params)
-        self.class.i_order_block.call(filtered_scope, params)
-      end
-
-      def order_block?
-        self.class.i_order_block.present?
-      end
-
-      def apply_distinct(filtered_scope, params)
-        return filtered_scope unless distinct? || params[:distinct] == true
-
-        filtered_scope.distinct
-      end
-    end
-  end
-end