rails-surrender 0.1.0 → 8.0.0

data/lib/rails/surrender/model_filter_scopes.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-# Add filter_by_date_(to/from/before/after) methods for all *_at columns
-module Rails
-  module Surrender
-    # apply filter scopes to the model
-    module ModelFilterScopes
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-
-      module ClassMethods
-        def inherited(child)
-          super
-
-          # Bad things happen if you ask table_exists? to ApplicationRecord while it's loading!
-          # TODO: Add configuration in case ApplicationRecord is _not_ the primary abstract class
-          return if child.name == 'ApplicationRecord'
-
-          return unless child.table_exists?
-
-          child.instance_eval do
-            # scope to filter by every column name
-            apply_surrender_column_name_scopes(child)
-
-            # scope to filter by date or time column names
-            apply_surrender_column_datetime_scopes(child)
-          rescue StandardError
-            # TODO: why are tests failing here!!!
-          end
-        end
-
-        def apply_surrender_column_name_scopes(child)
-          child.column_names.each do |column|
-            scope "filter_by_#{column}".to_sym, ->(val) { where({ column.to_sym => val }) }
-          end
-        end
-
-        def apply_surrender_column_datetime_scopes(child)
-          with_surrender_datetime_columns(child) do |column|
-            base = column.split(/_at$/).first
-
-            scope "filter_by_#{base}_to".to_sym, ->(time) { where("#{child.table_name}.#{column} <= ?", time) }
-            scope "filter_by_#{base}_from".to_sym, ->(time) { where("#{child.table_name}.#{column} >= ?", time) }
-            scope "filter_by_#{base}_before".to_sym, ->(time) { where("#{child.table_name}.#{column} < ?", time) }
-            scope "filter_by_#{base}_after".to_sym, ->(time) { where("#{child.table_name}.#{column} > ?", time) }
-          end
-        end
-
-        def with_surrender_datetime_columns(child, &block)
-          child.columns.select { |c| c.type.in? %i[date datetime] }.map(&:name).each(&block)
-        end
-      end
-    end
-  end
-end

data/lib/rails/surrender/render/configuration/inclusion_mapper_logic.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-module Rails
-  module Surrender
-    module Render
-      # Container for config structure when rendering or generating the inclusion object.
-      class Configuration
-        module InclusionMapperLogic
-          def expanding_elements
-            list = resource_class_surrender_attributes_that_expand +
-                   resource_class_surrender_expands +
-                   resource_class_subclass_surrender_attributes_that_expand +
-                   resource_class_subclass_surrender_expands +
-                   user_included_joins_required +
-                   ctrl_included_joins_required
-                   .flatten.uniq
-            list
-              .map { |e| element_from(e) }
-              .reject do |element|
-              element.klass.in?(history) ||
-                element.name.in?(local_user_excludes) ||
-                (element.name.in?(local_ctrl_excludes) && !element.name.in?(local_user_includes))
-            end
-          end
-
-          private
-
-          def resource_class_surrender_attributes_that_expand
-            resource_class.surrender_attributes
-                          .select { |attr| attr.match /_ids$/ }
-                          .map { |attr| attr.to_s.sub('_ids', '').pluralize }
-                          .select { |include| attribute_type(include).in? %i[expand associate] }
-          end
-
-          def resource_class_surrender_expands
-            resource_class.surrender_expands
-          end
-
-          def resource_class_subclass_surrender_attributes_that_expand
-            resource_class.subclasses.map do |subclass|
-              subclass.surrender_attributes
-                      .select { |attr| attr.match /_ids$/ }
-                      .map { |attr| attr.to_s.sub('_ids', '').pluralize }
-                      .select { |include| attribute_type(include, resource_class: sc).in? %i[expand associate] }
-            end
-          end
-
-          def resource_class_subclass_surrender_expands
-            resource_class.subclasses.map(&:surrender_expands)
-          end
-
-          def user_included_joins_required
-            top_level_keys_from(user_include).select { |include| attribute_type(include).in? %i[expand associate] }
-          end
-
-          def ctrl_included_joins_required
-            top_level_keys_from(ctrl_include).select { |include| attribute_type(include).in? %i[expand associate] }
-          end
-
-          def element_from(item)
-            item_name = resource_class.reflections.key?(item.to_s) ? item.to_s : item.to_s.sub('_ids', '').pluralize
-            item_klass = resource_class.reflections[item_name].klass
-            Element.new name: item_name, klass: item_klass, continue: (item.to_s == item_name)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/rails/surrender/render/configuration/instance_logic.rb

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-
-module Rails
-  module Surrender
-    module Render
-      # Container for config structure when rendering or generating the inclusion object.
-      class Configuration
-        module InstanceLogic
-          def nested_user_includes
-            next_level_asks_from(user_include)
-          end
-
-          def nested_ctrl_includes
-            next_level_asks_from(ctrl_include)
-          end
-
-          def nested_user_excludes
-            next_level_asks_from(user_exclude)
-          end
-
-          def nested_ctrl_excludes
-            next_level_asks_from(ctrl_exclude)
-          end
-
-          def locally_included_attributes
-            [].push(resource_class.surrender_attributes)
-              .push(ctrl_included_attributes)
-              .push(user_included_attributes_to_render)
-              .flatten.uniq
-              .reject { |attr| exclude_locally?(attr) }
-          end
-
-          def locally_included_expands
-            [].push(user_included_local_expansions_to_render)
-              .push(ctrl_included_expansions)
-              .push(resource_class.surrender_expands)
-              .flatten.uniq
-              .each_with_object({}) { |key, result| result[key.to_sym] = [] }
-              .deep_merge(nested_user_includes)
-              .deep_merge(nested_ctrl_includes)
-          end
-
-          def exclude_locally?(key)
-            local_excludes.include?(key) && !local_user_includes.include?(key)
-          end
-
-          private
-
-          def local_excludes
-            local_ctrl_excludes.dup.push(local_user_excludes).flatten.uniq
-          end
-
-          def user_included_attributes
-            top_level_keys_from(user_include).select { |include| attribute_type(include).in? %i[include associate] }
-          end
-
-          def user_included_attributes_to_render
-            attrs = user_included_attributes
-            unavailable_attrs = (attrs - resource_class.surrender_callable_attributes)
-            return attrs if unavailable_attrs.empty?
-
-            raise Error, I18n.t('surrender.error.query_string.include.not_available', param: unavailable_attrs)
-          end
-
-          def user_included_expansions
-            local_user_includes.select { |i| attribute_type(i) == :expand }
-          end
-
-          def user_included_local_expansions_to_render
-            expansions = user_included_expansions
-            unavailable_expansions = (expansions - resource_class.surrender_callable_expands)
-            return expansions if unavailable_expansions.empty?
-
-            raise Error, I18n.t('surrender.error.query_string.include.not_available', param: unavailable_expansions)
-          end
-
-          def ctrl_included_attributes
-            top_level_keys_from(ctrl_include).select { |include| attribute_type(include).in? %i[include associate] }
-          end
-
-          def ctrl_included_expansions
-            local_ctrl_includes.select { |i| attribute_type(i) == :expand }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/rails/surrender/render/configuration.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'configuration/inclusion_mapper_logic'
-require_relative 'configuration/instance_logic'
-
-module Rails
-  module Surrender
-    module Render
-      # Container for config structure when rendering or generating the inclusion object.
-      class Configuration
-        include InclusionMapperLogic
-        include InstanceLogic
-
-        attr_accessor :resource_class,
-                      :reload_resource,
-                      :user_exclude,
-                      :user_include,
-                      :ctrl_exclude,
-                      :ctrl_include,
-                      :history
-
-        alias reload_resource? reload_resource
-
-        Element = Struct.new(:name, :klass, :continue, keyword_init: true)
-
-        def initialize(
-          resource_class: nil,
-          reload_resource: false,
-          user_exclude: [],
-          user_include: [],
-          ctrl_exclude: [],
-          ctrl_include: [],
-          history: []
-        )
-          @resource_class = resource_class
-          @reload_resource = reload_resource
-          @user_exclude = user_exclude.compact
-          @user_include = user_include
-          @ctrl_exclude = ctrl_exclude.compact
-          @ctrl_include = ctrl_include
-          @history = history
-
-          validate_user_includes!
-        end
-
-        private
-
-        def validate_user_includes!
-          return if invalid_local_user_includes.empty?
-
-          raise Error, I18n.t('surrender.error.query_string.include.not_available', param: invalid_local_user_includes)
-        end
-
-        def invalid_local_user_includes
-          local_user_includes.select { |include| attribute_type(include) == :none }
-        end
-
-        def local_ctrl_excludes
-          top_level_keys_from(ctrl_exclude)
-        end
-
-        def local_ctrl_includes
-          top_level_keys_from(ctrl_include)
-        end
-
-        def local_user_excludes
-          top_level_keys_from(user_exclude)
-        end
-
-        def local_user_includes
-          top_level_keys_from(user_include)
-        end
-
-        def attribute_type(attr, klass: resource_class)
-          return :expand if klass.reflections.keys.include?(attr.to_s)
-          return :associate if klass.reflections.keys.include?(attr.to_s.sub('_ids', '').pluralize)
-          return :include if klass.attribute_names.include?(attr.to_s)
-          return :include if klass.instance_methods.include?(attr)
-
-          :none
-        end
-
-        def top_level_keys_from(list)
-          list.map { |x| x.is_a?(Hash) ? x.keys : x }.flatten.map(&:to_sym).uniq
-        end
-
-        def next_level_asks_from(list)
-          list.select { |x| x.is_a? Hash }.reduce({}, :merge).symbolize_keys
-        end
-      end
-    end
-  end
-end

data/lib/rails/surrender/render/count.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Rails
-  module Surrender
-    module Render
-      # Rendering a count of resources.
-      class Count
-        attr_reader :resource
-
-        def initialize(resource)
-          @resource = resource
-        end
-
-        def parse
-          count = resource.respond_to?(:count) ? resource.count : 1
-          Response.new(data: { count: count })
-        end
-      end
-    end
-  end
-end

data/lib/rails/surrender/render/ids.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Rails
-  module Surrender
-    module Render
-      # Rendering the IDs of the requested resources.
-      class Ids
-        attr_reader :resource
-
-        def initialize(resource)
-          @resource = resource
-        end
-
-        def parse
-          ids = resource.respond_to?(:ids) ? resource.ids : [resource.id]
-          Response.new(data: { ids: ids })
-        end
-      end
-    end
-  end
-end

data/lib/rails/surrender/render/resource/collection.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module Rails
-  module Surrender
-    module Render
-      class Resource
-        # Renders a collection resource
-        class Collection
-          attr_reader :resource, :config, :ability
-
-          def initialize(resource:, config:, ability:)
-            @resource = resource
-            @config = config
-            @ability = ability
-          end
-
-          def render
-            return nil if resource.nil?
-
-            resource.map { |data| Instance.new(resource: data, config: config, ability: ability).render }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/rails/surrender/render/resource/inclusion_mapper.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-module Rails
-  module Surrender
-    module Render
-      class Resource
-        # Builds a complete map of the resources needed to fulfill the request, for supplying to ActiveRecord.includes
-        class InclusionMapper
-          attr_reader :resource_class, :config
-
-          Element = Struct.new(:name, :klass, keyword_init: true)
-          # InclusionMapper is designed to recursively crawl through the model rendering structure and build a hash
-          # that ActiveRecord can use to eager load ALL of the data we're going to render, to prevent N+1 queries
-          def initialize(resource_class:, config:)
-            @resource_class = resource_class
-            @config = config
-          end
-
-          def parse
-            config.history.push resource_class
-            includes = []
-
-            config.expanding_elements.each do |element|
-              item_config = Configuration.new(
-                resource_class: element.klass,
-                user_include: config.nested_user_includes[element.name] || [],
-                ctrl_include: config.nested_ctrl_includes[element.name] || [],
-                user_exclude: config.nested_user_excludes[element.name] || [],
-                ctrl_exclude: config.nested_ctrl_excludes[element.name] || [],
-                history: config.history.dup.push(element.klass)
-              )
-
-              nested = if element.continue
-                         InclusionMapper.new(resource_class: element.klass, config: item_config).parse
-                       else
-                         []
-                       end
-
-              includes << (nested.size.zero? ? element.name : { element.name => nested })
-            end
-
-            includes.sort_by { |x| x.is_a?(Symbol) ? 0 : 1 }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/rails/surrender/render/resource/instance.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-module Rails
-  module Surrender
-    module Render
-      class Resource
-        # Renders an instance resource
-        class Instance
-          attr_reader :resource, :config, :ability
-
-          def initialize(resource:, config:, ability:)
-            @resource = resource
-            @config = config
-            @ability = ability
-          end
-
-          def render
-            config.history.push history_class
-
-            result = {}
-            config.locally_included_attributes.each { |attr| result[attr.to_sym] = resource.send(attr) }
-
-            config.locally_included_expands.each_key do |key|
-              next if config.exclude_locally?(key)
-
-              nested_resource_class = nested_class_for(resource, key)
-              next if config.history.include? nested_resource_class
-
-              nested_config = nested_config_for(nested_resource_class, key)
-
-              if resource.class.reflections[key.to_s].try(:collection?)
-                collection = resource.send(key.to_sym).select { |i| ability.can? :read, i }
-                result[key] = Collection.new(resource: collection, config: nested_config, ability: ability).render
-              else
-                instance = resource.send(key)
-                next if config.history.include? instance.class
-
-                if ability.can?(:read, instance)
-                  result[key] = Instance.new(resource: instance, config: nested_config, ability: ability).render
-                elsif instance.nil?
-                  result[key] = nil # represent an associated element as null if it's missing
-                end
-              end
-            end
-            result
-          end
-
-          private
-
-          def nested_class_for(resource, key)
-            resource.class.reflections[key.to_s].klass
-          rescue NoMethodError
-            resource.send(key).class
-          end
-
-          def nested_config_for(nested_resource_class, key)
-            Configuration.new(
-              resource_class: nested_resource_class,
-              user_include: config.nested_user_includes[key]  || [],
-              ctrl_include: config.nested_ctrl_includes[key]  || [],
-              user_exclude: config.nested_user_excludes[key]  || [],
-              ctrl_exclude: config.nested_ctrl_excludes[key]  || [],
-              history: config.history
-            )
-          end
-
-          # get to the root subclass for sti models and store that as history
-          def history_class
-            resource.class.superclass until resource.class.superclass.in? [ActiveRecord::Base, ApplicationRecord]
-          end
-        end
-      end
-    end
-  end
-end

data/test/surrender_test.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class SurrenderTest < ActiveSupport::TestCase
-  test 'truth' do
-    assert_kind_of Module, Surrender
-  end
-end

data/test/test_helper.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-# Configure Rails Environment
-ENV['RAILS_ENV'] = 'test'
-
-require File.expand_path('../test/dummy/config/environment.rb', __dir__)
-ActiveRecord::Migrator.migrations_paths = [File.expand_path('../test/dummy/db/migrate', __dir__)]
-require 'rails/test_help'
-
-# Filter out Minitest backtrace while allowing backtrace from other libraries
-# to be shown.
-Minitest.backtrace_filter = Minitest::BacktraceFilter.new
-
-# Load support files
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
-
-# Load fixtures from the engine
-if ActiveSupport::TestCase.respond_to?(:fixture_path=)
-  ActiveSupport::TestCase.fixture_path = File.expand_path('fixtures', __dir__)
-  ActiveSupport::TestCase.fixtures :all
-end