rest_framework 0.9.7 → 0.9.8

data/lib/rest_framework/serializers.rb

@@ -1,386 +1,7 @@
-# The base serializer defines the interface for all REST Framework serializers.
-class RESTFramework::BaseSerializer
-  # Add `object` accessor to be compatible with `ActiveModel::Serializer`.
-  attr_accessor :object
-
-  # Accept/ignore `*args` to be compatible with the `ActiveModel::Serializer#initialize` signature.
-  def initialize(object=nil, *args, controller: nil, **kwargs)
-    @object = object
-    @controller = controller
-  end
-
-  # The primary interface for extracting a native Ruby types. This works both for records and
-  # collections. We accept and ignore `*args` for compatibility with `active_model_serializers`.
-  def serialize(*args)
-    raise NotImplementedError
-  end
-
-  # Synonym for `serialize` for compatibility with `active_model_serializers`.
-  def serializable_hash(*args)
-    return self.serialize(*args)
-  end
-
-  # For compatibility with `active_model_serializers`.
-  def self.cache_enabled?
-    return false
-  end
-
-  # For compatibility with `active_model_serializers`.
-  def self.fragment_cache_enabled?
-    return false
-  end
-
-  # For compatibility with `active_model_serializers`.
-  def associations(*args, **kwargs)
-    return []
-  end
+module RESTFramework::Serializers
 end
 
-# This serializer uses `.serializable_hash` to convert objects to Ruby primitives (with the
-# top-level being either an array or a hash).
-class RESTFramework::NativeSerializer < RESTFramework::BaseSerializer
-  class_attribute :config
-  class_attribute :singular_config
-  class_attribute :plural_config
-  class_attribute :action_config
-
-  # Accept/ignore `*args` to be compatible with the `ActiveModel::Serializer#initialize` signature.
-  def initialize(object=nil, *args, many: nil, model: nil, **kwargs)
-    super(object, *args, **kwargs)
-
-    if many.nil?
-      # Determine if we are dealing with many objects or just one.
-      @many = @object.is_a?(Enumerable)
-    else
-      @many = many
-    end
-
-    # Determine model either explicitly, or by inspecting @object or @controller.
-    @model = model
-    @model ||= @object.class if @object.is_a?(ActiveRecord::Base)
-    @model ||= @object[0].class if
-      @many && @object.is_a?(Enumerable) && @object.is_a?(ActiveRecord::Base)
-
-    @model ||= @controller.class.get_model if @controller
-  end
-
-  # Get controller action, if possible.
-  def get_action
-    return @controller&.action_name&.to_sym
-  end
-
-  # Get a locally defined native serializer configuration, if one is defined.
-  def get_local_native_serializer_config
-    action = self.get_action
-
-    if action && self.action_config
-      # Index action should use :list serializer config if :index is not provided.
-      action = :list if action == :index && !self.action_config.key?(:index)
-
-      return self.action_config[action] if self.action_config[action]
-    end
-
-    # No action_config, so try singular/plural config if explicitly instructed to via @many.
-    return self.plural_config if @many == true && self.plural_config
-    return self.singular_config if @many == false && self.singular_config
-
-    # Lastly, try returning the default config, or singular/plural config in that order.
-    return self.config || self.singular_config || self.plural_config
-  end
-
-  # Get a native serializer configuration from the controller.
-  def get_controller_native_serializer_config
-    return nil unless @controller
-
-    if @many == true
-      controller_serializer = @controller.try(:native_serializer_plural_config)
-    elsif @many == false
-      controller_serializer = @controller.try(:native_serializer_singular_config)
-    end
-
-    return controller_serializer || @controller.try(:native_serializer_config)
-  end
-
-  # Filter a single subconfig for specific keys. By default, keys from `fields` are removed from the
-  # provided `subcfg`. There are two (mutually exclusive) options to adjust the behavior:
-  #
-  #  `add`: Add any `fields` to the `subcfg` which aren't already in the `subcfg`.
-  #  `only`: Remove any values found in the `subcfg` not in `fields`.
-  def self.filter_subcfg(subcfg, fields:, add: false, only: false)
-    raise "`add` and `only` conflict with one another" if add && only
-
-    # Don't process nil `subcfg`s.
-    return subcfg unless subcfg
-
-    if subcfg.is_a?(Array)
-      subcfg = subcfg.map(&:to_sym)
-
-      if add
-        # Only add fields which are not already included.
-        subcfg += fields - subcfg
-      elsif only
-        subcfg.select! { |c| c.in?(fields) }
-      else
-        subcfg -= fields
-      end
-    elsif subcfg.is_a?(Hash)
-      subcfg = subcfg.symbolize_keys
-
-      if add
-        # Add doesn't make sense in a hash context since we wouldn't know the values.
-      elsif only
-        subcfg.select! { |k, _v| k.in?(fields) }
-      else
-        subcfg.reject! { |k, _v| k.in?(fields) }
-      end
-    else  # Subcfg is a single element (assume string/symbol).
-      subcfg = subcfg.to_sym
-
-      if add
-        subcfg = subcfg.in?(fields) ? fields : [subcfg, *fields]
-      elsif only
-        subcfg = subcfg.in?(fields) ? subcfg : []
-      else
-        subcfg = subcfg.in?(fields) ? [] : subcfg
-      end
-    end
-
-    return subcfg
-  end
-
-  # Filter out configuration properties based on the :except/:only query parameters.
-  def filter_from_request(cfg)
-    return cfg unless @controller
-
-    except_param = @controller.try(:native_serializer_except_query_param)
-    only_param = @controller.try(:native_serializer_only_query_param)
-    if except_param && except = @controller.request&.query_parameters&.[](except_param).presence
-      if except = except.split(",").map(&:strip).map(&:to_sym).presence
-        # Filter `only`, `except` (additive), `include`, `methods`, and `serializer_methods`.
-        if cfg[:only]
-          cfg[:only] = self.class.filter_subcfg(cfg[:only], fields: except)
-        elsif cfg[:except]
-          cfg[:except] = self.class.filter_subcfg(cfg[:except], fields: except, add: true)
-        else
-          cfg[:except] = except
-        end
-
-        cfg[:include] = self.class.filter_subcfg(cfg[:include], fields: except)
-        cfg[:methods] = self.class.filter_subcfg(cfg[:methods], fields: except)
-        cfg[:serializer_methods] = self.class.filter_subcfg(
-          cfg[:serializer_methods], fields: except
-        )
-      end
-    elsif only_param && only = @controller.request&.query_parameters&.[](only_param).presence
-      if only = only.split(",").map(&:strip).map(&:to_sym).presence
-        # Filter `only`, `include`, and `methods`. Adding anything to `except` is not needed,
-        # because any configuration there takes precedence over `only`.
-        if cfg[:only]
-          cfg[:only] = self.class.filter_subcfg(cfg[:only], fields: only, only: true)
-        else
-          cfg[:only] = only
-        end
-
-        cfg[:include] = self.class.filter_subcfg(cfg[:include], fields: only, only: true)
-        cfg[:methods] = self.class.filter_subcfg(cfg[:methods], fields: only, only: true)
-        cfg[:serializer_methods] = self.class.filter_subcfg(
-          cfg[:serializer_methods], fields: only, only: true
-        )
-      end
-    end
+require_relative "serializers/base_serializer"
 
-    return cfg
-  end
-
-  # Get the associations limit from the controller.
-  def _get_associations_limit
-    return @_get_associations_limit if defined?(@_get_associations_limit)
-
-    limit = @controller&.native_serializer_associations_limit
-
-    # Extract the limit from the query parameters if it's set.
-    if query_param = @controller&.native_serializer_associations_limit_query_param
-      if @controller.request.query_parameters.key?(query_param)
-        query_limit = @controller.request.query_parameters[query_param].to_i
-        if query_limit > 0
-          limit = query_limit
-        else
-          limit = nil
-        end
-      end
-    end
-
-    return @_get_associations_limit = limit
-  end
-
-  # Get a serializer configuration from the controller. `@controller` and `@model` must be set.
-  def _get_controller_serializer_config(fields)
-    columns = []
-    includes = {}
-    methods = []
-    serializer_methods = {}
-
-    column_names = @model.column_names
-    reflections = @model.reflections
-    attachment_reflections = @model.attachment_reflections
-
-    fields.each do |f|
-      field_config = @controller.class.get_field_config(f)
-      next if field_config[:write_only]
-
-      if f.in?(column_names)
-        columns << f
-      elsif ref = reflections[f]
-        sub_columns = []
-        sub_methods = []
-        field_config[:sub_fields].each do |sf|
-          if !ref.polymorphic? && sf.in?(ref.klass.column_names)
-            sub_columns << sf
-          else
-            sub_methods << sf
-          end
-        end
-        sub_config = {only: sub_columns, methods: sub_methods}
-
-        # Apply certain rules regarding collection associations.
-        if ref.collection?
-          # If we need to limit the number of serialized association records, then dynamically add a
-          # serializer method to do so.
-          if limit = self._get_associations_limit
-            serializer_methods[f] = f
-            self.define_singleton_method(f) do |record|
-              next record.send(f).limit(limit).as_json(**sub_config)
-            end
-          else
-            includes[f] = sub_config
-          end
-
-          # If we need to include the association count, then add it here.
-          if @controller.native_serializer_include_associations_count
-            method_name = "#{f}.count"
-            serializer_methods[method_name] = method_name
-            self.define_singleton_method(method_name) do |record|
-              next record.send(f).count
-            end
-          end
-        else
-          includes[f] = sub_config
-        end
-      elsif ref = reflections["rich_text_#{f}"]
-        # ActionText Integration: Define rich text serializer method.
-        serializer_methods[f] = f
-        self.define_singleton_method(f) do |record|
-          next record.send(f).to_s
-        end
-      elsif ref = attachment_reflections[f]
-        # ActiveStorage Integration: Define attachment serializer method.
-        serializer_methods[f] = f
-        if ref.macro == :has_one_attached
-          self.define_singleton_method(f) do |record|
-            next record.send(f).attachment&.url
-          end
-        else
-          self.define_singleton_method(f) do |record|
-            next record.send(f).map(&:url)
-          end
-        end
-      elsif @model.method_defined?(f)
-        methods << f
-      end
-    end
-
-    return {
-      only: columns, include: includes, methods: methods, serializer_methods: serializer_methods
-    }
-  end
-
-  # Get the raw serializer config, prior to any adjustments from the request.
-  #
-  # Use `deep_dup` on any class mutables (array, hash, etc) to avoid mutating class state.
-  def get_raw_serializer_config
-    # Return a locally defined serializer config if one is defined.
-    if local_config = self.get_local_native_serializer_config
-      return local_config.deep_dup
-    end
-
-    # Return a serializer config if one is defined on the controller.
-    if serializer_config = self.get_controller_native_serializer_config
-      return serializer_config.deep_dup
-    end
-
-    # If the config wasn't determined, build a serializer config from controller fields.
-    if @model && fields = @controller&.get_fields
-      return self._get_controller_serializer_config(fields.deep_dup)
-    end
-
-    # By default, pass an empty configuration, using the default Rails serializer.
-    return {}
-  end
-
-  # Get a configuration passable to `serializable_hash` for the object, filtered if required.
-  def get_serializer_config
-    return filter_from_request(self.get_raw_serializer_config)
-  end
-
-  # Serialize a single record and merge results of `serializer_methods`.
-  def _serialize(record, config, serializer_methods)
-    # Ensure serializer_methods is either falsy, or a hash.
-    if serializer_methods && !serializer_methods.is_a?(Hash)
-      serializer_methods = [serializer_methods].flatten.map { |m| [m, m] }.to_h
-    end
-
-    # Merge serialized record with any serializer method results.
-    return record.serializable_hash(config).merge(
-      serializer_methods&.map { |m, k| [k.to_sym, self.send(m, record)] }.to_h,
-    )
-  end
-
-  def serialize(*args)
-    config = self.get_serializer_config
-    serializer_methods = config.delete(:serializer_methods)
-
-    if @object.respond_to?(:to_ary)
-      return @object.map { |r| self._serialize(r, config, serializer_methods) }
-    end
-
-    return self._serialize(@object, config, serializer_methods)
-  end
-
-  # Allow a serializer instance to be used as a hash directly in a nested serializer config.
-  def [](key)
-    @_nested_config ||= self.get_serializer_config
-    return @_nested_config[key]
-  end
-
-  def []=(key, value)
-    @_nested_config ||= self.get_serializer_config
-    return @_nested_config[key] = value
-  end
-
-  # Allow a serializer class to be used as a hash directly in a nested serializer config.
-  def self.[](key)
-    @_nested_config ||= self.new.get_serializer_config
-    return @_nested_config[key]
-  end
-
-  def self.[]=(key, value)
-    @_nested_config ||= self.new.get_serializer_config
-    return @_nested_config[key] = value
-  end
-end
-
-# This is a helper factory to wrap an ActiveModelSerializer to provide a `serialize` method which
-# accepts both collections and individual records. Use `.for` to build adapters.
-class RESTFramework::ActiveModelSerializerAdapterFactory
-  def self.for(active_model_serializer)
-    return Class.new(active_model_serializer) do
-      def serialize
-        if self.object.respond_to?(:to_ary)
-          return self.object.map { |r| self.class.superclass.new(r).serializable_hash }
-        end
-
-        return self.serializable_hash
-      end
-    end
-  end
-end
+require_relative "serializers/active_model_serializer_adapter_factory"
+require_relative "serializers/native_serializer"

data/lib/rest_framework.rb

@@ -179,11 +179,11 @@ module RESTFramework
   end
 end
 
-require_relative "rest_framework/controller_mixins"
 require_relative "rest_framework/engine"
 require_relative "rest_framework/errors"
 require_relative "rest_framework/filters"
 require_relative "rest_framework/generators"
+require_relative "rest_framework/mixins"
 require_relative "rest_framework/paginators"
 require_relative "rest_framework/routers"
 require_relative "rest_framework/serializers"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rest_framework
 version: !ruby/object:Gem::Version
-  version: 0.9.7
+  version: 0.9.8
 platform: ruby
 authors:
 - Gregory N. Schmit
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-07-06 00:00:00.000000000 Z
+date: 2023-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -31,6 +31,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".yardopts"
 - LICENSE
 - README.md
 - VERSION
@@ -50,23 +51,28 @@ files:
 - app/views/rest_framework/routes_and_forms/_routes.html.erb
 - app/views/rest_framework/routes_and_forms/routes/_route.html.erb
 - lib/rest_framework.rb
-- lib/rest_framework/controller_mixins.rb
-- lib/rest_framework/controller_mixins/base.rb
-- lib/rest_framework/controller_mixins/bulk.rb
-- lib/rest_framework/controller_mixins/models.rb
 - lib/rest_framework/engine.rb
 - lib/rest_framework/errors.rb
 - lib/rest_framework/filters.rb
-- lib/rest_framework/filters/base.rb
-- lib/rest_framework/filters/model_ordering.rb
-- lib/rest_framework/filters/model_query.rb
-- lib/rest_framework/filters/model_search.rb
-- lib/rest_framework/filters/ransack.rb
+- lib/rest_framework/filters/base_filter.rb
+- lib/rest_framework/filters/model_ordering_filter.rb
+- lib/rest_framework/filters/model_query_filter.rb
+- lib/rest_framework/filters/model_search_filter.rb
+- lib/rest_framework/filters/ransack_filter.rb
 - lib/rest_framework/generators.rb
 - lib/rest_framework/generators/controller_generator.rb
+- lib/rest_framework/mixins.rb
+- lib/rest_framework/mixins/base_controller_mixin.rb
+- lib/rest_framework/mixins/bulk_model_controller_mixin.rb
+- lib/rest_framework/mixins/model_controller_mixin.rb
 - lib/rest_framework/paginators.rb
+- lib/rest_framework/paginators/base_paginator.rb
+- lib/rest_framework/paginators/page_number_paginator.rb
 - lib/rest_framework/routers.rb
 - lib/rest_framework/serializers.rb
+- lib/rest_framework/serializers/active_model_serializer_adapter_factory.rb
+- lib/rest_framework/serializers/base_serializer.rb
+- lib/rest_framework/serializers/native_serializer.rb
 - lib/rest_framework/utils.rb
 - lib/rest_framework/version.rb
 - vendor/assets/javascripts/rest_framework/external.min.js
@@ -83,7 +89,6 @@ post_install_message:
 rdoc_options: []
 require_paths:
 - lib
-- app
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/rest_framework/controller_mixins.rb

@@ -1,7 +0,0 @@
-module RESTFramework::ControllerMixins
-end
-
-require_relative "controller_mixins/base"
-
-require_relative "controller_mixins/bulk"
-require_relative "controller_mixins/models"