snfoil-rails 0.8.3 → 1.0.0

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

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/concern'
-
-module SnFoil
-  module Controller
-    module Concerns
-      module SetupControllerConcern
-        extend ActiveSupport::Concern
-
-        class_methods do
-          attr_reader :i_context
-
-          def context(klass = nil)
-            @i_context = klass
-          end
-        end
-
-        def context(**options)
-          options[:context] || self.class.i_context
-        end
-
-        def setup_options(**options)
-          options = inject_params(**options)
-          options = inject_id(**options)
-          options = inject_includes(**options)
-          inject_controller_action(**options)
-        end
-
-        def current_context(**options)
-          @current_context ||= context(**options).new(context_entity)
-        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 if options[:params]
-          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 context_entity
-          return current_entity if defined? current_entity
-          return current_user if defined? current_user
-        end
-      end
-    end
-  end
-end

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

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/concern'
-require_relative 'setup_controller_concern'
-
-module SnFoil
-  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

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

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/concern'
-require_relative 'setup_controller_concern'
-require_relative 'change_controller_concern'
-
-module SnFoil
-  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)
-        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

data/lib/sn_foil/jsonapi_deserializer.rb

@@ -1,159 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/concern'
-
-module SnFoil
-  module JsonapiDeserializer # rubocop:disable Metrics/ModuleLength
-    extend ActiveSupport::Concern
-
-    class_methods do
-      attr_reader :i_attribute_fields, :i_attribute_transforms
-
-      def attributes(*fields)
-        @i_attribute_fields ||= []
-        @i_attribute_fields |= fields
-      end
-
-      def attribute(key, **options)
-        @i_attribute_transforms ||= {}
-        @i_attribute_transforms[key] = options.merge(transform_type: :attribute)
-      end
-
-      def has_one(key, deserializer:, **options) # rubocop:disable Naming/PredicateName
-        @i_attribute_transforms ||= {}
-        @i_attribute_transforms[key] = options.merge(deserializer: deserializer, transform_type: :has_one)
-      end
-      alias_method :belongs_to, :has_one
-
-      def has_many(key, deserializer:, **options) # rubocop:disable Naming/PredicateName
-        @i_attribute_transforms ||= {}
-        @i_attribute_transforms[key] = options.merge(deserializer: deserializer, transform_type: :has_many)
-      end
-    end
-
-    attr_reader :object, :included, :options
-
-    def initialize(object, included: nil, **options)
-      @object = object
-      @included = included || object[:included]
-      @options = options
-    end
-
-    def attribute_fields
-      self.class.i_attribute_fields || []
-    end
-
-    def attribute_transforms
-      self.class.i_attribute_transforms || {}
-    end
-
-    def attributes
-      @attributes ||= attribute_fields | attribute_transforms.map { |k, v| v[:key] || k }
-    end
-
-    def parse
-      parse_data
-    end
-    alias to_h parse
-
-    private
-
-    def parse_data
-      if object[:data].is_a? Array
-        object[:data].map { |d| build_attributes(d) }
-      else
-        build_attributes(object[:data])
-      end
-    end
-
-    def build_attributes(data)
-      attributes = data_id({}, data)
-      attributes = parse_standard_attributes(attributes, data) if data[:attributes]
-      attribute_transforms.each do |key, opts|
-        attributes = apply_attribute_transform(attributes, data, key, **opts)
-      end
-      attributes
-    end
-
-    def data_id(attributes, data)
-      if data[:id]
-        attributes[:id] = data[:id]
-      elsif data[:'local:id']
-        attributes[:lid] = data[:'local:id']
-      end
-      attributes
-    end
-
-    def parse_standard_attributes(attributes, data)
-      attributes.merge!(data[:attributes].select { |k, _| attribute_fields.include? k })
-    end
-
-    def apply_attribute_transform(attributes, data, key, transform_type:, **opts)
-      case transform_type
-      when :attribute
-        parse_attribute_transform(attributes, data, key, **opts)
-      when :has_one
-        parse_has_one_relationship(attributes, data, key, **opts)
-      when :has_many
-        parse_has_many_relationship(attributes, data, key, **opts)
-      end
-    end
-
-    def parse_attribute_transform(attributes, data, key, **opts)
-      return attributes unless data.dig(:attributes, key)
-
-      attributes.merge({ opts.fetch(:key) { key } => data[:attributes][key] })
-    end
-
-    def parse_relationships(attributes, data)
-      self.class.has_one_relationships.each do |key, opts|
-        attributes = has_one_relationship(attributes, data, key, **opts)
-      end
-      self.class.has_many_relationships.each do |key, opts|
-        attributes = has_many_relationship(attributes, data, key, **opts)
-      end
-      attributes
-    end
-
-    def parse_has_one_relationship(attributes, data, key, deserializer:, **opts)
-      resource_data = data.dig(:relationships, key, :data)
-      return attributes unless resource_data
-
-      resource_data = data_id(resource_data, resource_data)
-      attribute_data = lookup_relationship(resource_data)
-      relationship_data = { data: attribute_data || resource_data }
-      attributes[opts.fetch(:key) { key }] = deserializer.new(relationship_data, **options, included: included).parse
-      attributes
-    end
-
-    def parse_has_many_relationship(attributes, data, key, deserializer:, **opts)
-      array_data = data.dig(:relationships, key, :data)
-      return attributes unless array_data
-
-      attributes[opts.fetch(:key) { key }] = array_data.map do |resource_data|
-        resource_data = data_id(resource_data, resource_data)
-        attribute_data = lookup_relationship(resource_data)
-        relationship_data = { data: attribute_data || resource_data }
-        deserializer.new(relationship_data, **options, included: included).parse
-      end
-      attributes
-    end
-
-    def lookup_relationship(type:, id: nil, lid: nil, **_opts)
-      check_for_id(id, lid)
-
-      included&.find do |x|
-        x[:type].eql?(type) &&
-          if id
-            x[:id].eql?(id)
-          elsif lid
-            x[:'local:id'].eql?(lid)
-          end
-      end
-    end
-
-    def check_for_id(id, lid)
-      raise ::ArgumentError, "missing keyword: id or lid for type: #{type}" unless id || lid
-    end
-  end
-end

data/lib/sn_foil/jsonapi_serializer.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/concern'
-require 'jsonapi/serializer'
-
-module SnFoil
-  module JsonapiSerializer
-    extend ActiveSupport::Concern
-
-    included do
-      include JSONAPI::Serializer
-
-      set_key_transform :dash
-    end
-  end
-end

data/lib/sn_foil/rails/engine.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module SnFoil
-  module Rails
-    class Engine < ::Rails::Engine
-      require 'sn_foil'
-      require_relative '../searcher'
-      require_relative '../jsonapi_serializer'
-      require_relative '../jsonapi_deserializer'
-      require_relative '../controller/concerns/change_controller_concern'
-      require_relative '../controller/concerns/create_controller_concern'
-      require_relative '../controller/concerns/destroy_controller_concern'
-      require_relative '../controller/concerns/index_controller_concern'
-      require_relative '../controller/concerns/setup_controller_concern'
-      require_relative '../controller/concerns/show_controller_concern'
-      require_relative '../controller/concerns/update_controller_concern'
-      require_relative '../controller/api'
-      require_relative '../controller/base'
-
-      require_relative '../configuration/lazy_jsonapi_serializer'
-    end
-  end
-end

data/lib/sn_foil/rails/version.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module SnFoil
-  module Rails
-    VERSION = '0.8.3'
-  end
-end

data/lib/sn_foil/rails.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module SnFoil
-  module Rails
-    if defined?(Rails)
-      require 'sn_foil/rails/engine'
-    else
-      require 'sn_foil'
-      require_relative '../searcher'
-      require_relative '../jsonapi_serializer'
-      require_relative '../jsonapi_deserializer'
-      require_relative '../controller/concerns/change_controller_concern'
-      require_relative '../controller/concerns/create_controller_concern'
-      require_relative '../controller/concerns/destroy_controller_concern'
-      require_relative '../controller/concerns/index_controller_concern'
-      require_relative '../controller/concerns/setup_controller_concern'
-      require_relative '../controller/concerns/show_controller_concern'
-      require_relative '../controller/concerns/update_controller_concern'
-      require_relative '../controller/api'
-      require_relative '../controller/base'
-
-      require_relative '../configuration/lazy_jsonapi_serializer'
-    end
-  end
-end

data/lib/sn_foil/searcher.rb

@@ -1,122 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/concern'
-require 'sn_foil/searcher'
-
-module SnFoil
-  module Searcher
-    extend ActiveSupport::Concern
-    ASC = 'ASC'
-    DESC = 'DESC'
-
-    included do
-      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
-    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) # rubocop:disable Style/OptionalBooleanParameter reason: class configuration looks better this way
-        @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)
-      instance_exec filtered_scope, params, &self.class.i_order_block
-    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

data/lib/snfoil-rails.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'sn_foil/rails'
-module SnFoil
-end