agi_active_model_serializers 0.10.7

data/lib/active_model/serializer/adapter/attributes.rb

@@ -0,0 +1,15 @@
+module ActiveModel
+  class Serializer
+    module Adapter
+      class Attributes < DelegateClass(ActiveModelSerializers::Adapter::Attributes)
+        def initialize(serializer, options = {})
+          super(ActiveModelSerializers::Adapter::Attributes.new(serializer, options))
+        end
+        class << self
+          extend ActiveModelSerializers::Deprecate
+          deprecate :new, 'ActiveModelSerializers::Adapter::Json.'
+        end
+      end
+    end
+  end
+end

data/lib/active_model/serializer/adapter/base.rb

@@ -0,0 +1,18 @@
+module ActiveModel
+  class Serializer
+    module Adapter
+      class Base < DelegateClass(ActiveModelSerializers::Adapter::Base)
+        class << self
+          extend ActiveModelSerializers::Deprecate
+          deprecate :inherited, 'ActiveModelSerializers::Adapter::Base.'
+        end
+
+        # :nocov:
+        def initialize(serializer, options = {})
+          super(ActiveModelSerializers::Adapter::Base.new(serializer, options))
+        end
+        # :nocov:
+      end
+    end
+  end
+end

data/lib/active_model/serializer/adapter/json.rb

@@ -0,0 +1,15 @@
+module ActiveModel
+  class Serializer
+    module Adapter
+      class Json < DelegateClass(ActiveModelSerializers::Adapter::Json)
+        def initialize(serializer, options = {})
+          super(ActiveModelSerializers::Adapter::Json.new(serializer, options))
+        end
+        class << self
+          extend ActiveModelSerializers::Deprecate
+          deprecate :new, 'ActiveModelSerializers::Adapter::Json.new'
+        end
+      end
+    end
+  end
+end

data/lib/active_model/serializer/adapter/json_api.rb

@@ -0,0 +1,15 @@
+module ActiveModel
+  class Serializer
+    module Adapter
+      class JsonApi < DelegateClass(ActiveModelSerializers::Adapter::JsonApi)
+        def initialize(serializer, options = {})
+          super(ActiveModelSerializers::Adapter::JsonApi.new(serializer, options))
+        end
+        class << self
+          extend ActiveModelSerializers::Deprecate
+          deprecate :new, 'ActiveModelSerializers::Adapter::JsonApi.new'
+        end
+      end
+    end
+  end
+end

data/lib/active_model/serializer/adapter/null.rb

@@ -0,0 +1,15 @@
+module ActiveModel
+  class Serializer
+    module Adapter
+      class Null < DelegateClass(ActiveModelSerializers::Adapter::Null)
+        def initialize(serializer, options = {})
+          super(ActiveModelSerializers::Adapter::Null.new(serializer, options))
+        end
+        class << self
+          extend ActiveModelSerializers::Deprecate
+          deprecate :new, 'ActiveModelSerializers::Adapter::Null.new'
+        end
+      end
+    end
+  end
+end

data/lib/active_model/serializer/array_serializer.rb

@@ -0,0 +1,12 @@
+require 'active_model/serializer/collection_serializer'
+
+module ActiveModel
+  class Serializer
+    class ArraySerializer < CollectionSerializer
+      class << self
+        extend ActiveModelSerializers::Deprecate
+        deprecate :new, 'ActiveModel::Serializer::CollectionSerializer.'
+      end
+    end
+  end
+end

data/lib/active_model/serializer/association.rb

@@ -0,0 +1,34 @@
+module ActiveModel
+  class Serializer
+    # This class holds all information about serializer's association.
+    #
+    # @attr [Symbol] name
+    # @attr [Hash{Symbol => Object}] options
+    # @attr [block]
+    #
+    # @example
+    #  Association.new(:comments, { serializer: CommentSummarySerializer })
+    #
+    class Association < Field
+      # @return [Symbol]
+      def key
+        options.fetch(:key, name)
+      end
+
+      # @return [ActiveModel::Serializer, nil]
+      def serializer
+        options[:serializer]
+      end
+
+      # @return [Hash]
+      def links
+        options.fetch(:links) || {}
+      end
+
+      # @return [Hash, nil]
+      def meta
+        options[:meta]
+      end
+    end
+  end
+end

data/lib/active_model/serializer/attribute.rb

@@ -0,0 +1,25 @@
+require 'active_model/serializer/field'
+
+module ActiveModel
+  class Serializer
+    # Holds all the meta-data about an attribute as it was specified in the
+    # ActiveModel::Serializer class.
+    #
+    # @example
+    #   class PostSerializer < ActiveModel::Serializer
+    #     attribute :content
+    #     attribute :name, key: :title
+    #     attribute :email, key: :author_email, if: :user_logged_in?
+    #     attribute :preview do
+    #       truncate(object.content)
+    #     end
+    #
+    #     def user_logged_in?
+    #       current_user.logged_in?
+    #     end
+    #   end
+    #
+    class Attribute < Field
+    end
+  end
+end

data/lib/active_model/serializer/belongs_to_reflection.rb

@@ -0,0 +1,7 @@
+module ActiveModel
+  class Serializer
+    # @api private
+    class BelongsToReflection < SingularReflection
+    end
+  end
+end

data/lib/active_model/serializer/collection_reflection.rb

@@ -0,0 +1,7 @@
+module ActiveModel
+  class Serializer
+    # @api private
+    class CollectionReflection < Reflection
+    end
+  end
+end

data/lib/active_model/serializer/collection_serializer.rb

@@ -0,0 +1,87 @@
+module ActiveModel
+  class Serializer
+    class CollectionSerializer
+      include Enumerable
+      delegate :each, to: :@serializers
+
+      attr_reader :object, :root
+
+      def initialize(resources, options = {})
+        @object                  = resources
+        @options                 = options
+        @root                    = options[:root]
+        @serializers             = serializers_from_resources
+      end
+
+      def success?
+        true
+      end
+
+      # @api private
+      def serializable_hash(adapter_options, options, adapter_instance)
+        include_directive = ActiveModel::Serializer.include_directive_from_options(adapter_options)
+        adapter_options[:cached_attributes] ||= ActiveModel::Serializer.cache_read_multi(self, adapter_instance, include_directive)
+        adapter_opts = adapter_options.merge(include_directive: include_directive)
+        serializers.map do |serializer|
+          serializer.serializable_hash(adapter_opts, options, adapter_instance)
+        end
+      end
+
+      # TODO: unify naming of root, json_key, and _type.  Right now, a serializer's
+      # json_key comes from the root option or the object's model name, by default.
+      # But, if a dev defines a custom `json_key` method with an explicit value,
+      # we have no simple way to know that it is safe to call that instance method.
+      # (which is really a class property at this point, anyhow).
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # Disabling cop since it's good to highlight the complexity of this method by
+      # including all the logic right here.
+      def json_key
+        return root if root
+        # 1. get from options[:serializer] for empty resource collection
+        key = object.empty? &&
+          (explicit_serializer_class = options[:serializer]) &&
+          explicit_serializer_class._type
+        # 2. get from first serializer instance in collection
+        key ||= (serializer = serializers.first) && serializer.json_key
+        # 3. get from collection name, if a named collection
+        key ||= object.respond_to?(:name) ? object.name && object.name.underscore : nil
+        # 4. key may be nil for empty collection and no serializer option
+        key && key.pluralize
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+
+      def paginated?
+        ActiveModelSerializers.config.jsonapi_pagination_links_enabled &&
+          object.respond_to?(:current_page) &&
+          object.respond_to?(:total_pages) &&
+          object.respond_to?(:size)
+      end
+
+      protected
+
+      attr_reader :serializers, :options
+
+      private
+
+      def serializers_from_resources
+        serializer_context_class = options.fetch(:serializer_context_class, ActiveModel::Serializer)
+        object.map do |resource|
+          serializer_from_resource(resource, serializer_context_class, options)
+        end
+      end
+
+      def serializer_from_resource(resource, serializer_context_class, options)
+        serializer_class = options.fetch(:serializer) do
+          serializer_context_class.serializer_for(resource, namespace: options[:namespace])
+        end
+
+        if serializer_class.nil?
+          ActiveModelSerializers.logger.debug "No serializer found for resource: #{resource.inspect}"
+          throw :no_serializer
+        else
+          serializer_class.new(resource, options.except(:serializer))
+        end
+      end
+    end
+  end
+end

data/lib/active_model/serializer/concerns/associations.rb

@@ -0,0 +1,102 @@
+module ActiveModel
+  class Serializer
+    # Defines an association in the object should be rendered.
+    #
+    # The serializer object should implement the association name
+    # as a method which should return an array when invoked. If a method
+    # with the association name does not exist, the association name is
+    # dispatched to the serialized object.
+    #
+    module Associations
+      extend ActiveSupport::Concern
+
+      included do
+        with_options instance_writer: false, instance_reader: true do |serializer|
+          serializer.class_attribute :_reflections
+          self._reflections ||= {}
+        end
+
+        extend ActiveSupport::Autoload
+        autoload :Association
+        autoload :Reflection
+        autoload :SingularReflection
+        autoload :CollectionReflection
+        autoload :BelongsToReflection
+        autoload :HasOneReflection
+        autoload :HasManyReflection
+      end
+
+      module ClassMethods
+        def inherited(base)
+          super
+          base._reflections = _reflections.dup
+        end
+
+        # @param [Symbol] name of the association
+        # @param [Hash<Symbol => any>] options for the reflection
+        # @return [void]
+        #
+        # @example
+        #  has_many :comments, serializer: CommentSummarySerializer
+        #
+        def has_many(name, options = {}, &block) # rubocop:disable Style/PredicateName
+          associate(HasManyReflection.new(name, options, block))
+        end
+
+        # @param [Symbol] name of the association
+        # @param [Hash<Symbol => any>] options for the reflection
+        # @return [void]
+        #
+        # @example
+        #  belongs_to :author, serializer: AuthorSerializer
+        #
+        def belongs_to(name, options = {}, &block)
+          associate(BelongsToReflection.new(name, options, block))
+        end
+
+        # @param [Symbol] name of the association
+        # @param [Hash<Symbol => any>] options for the reflection
+        # @return [void]
+        #
+        # @example
+        #  has_one :author, serializer: AuthorSerializer
+        #
+        def has_one(name, options = {}, &block) # rubocop:disable Style/PredicateName
+          associate(HasOneReflection.new(name, options, block))
+        end
+
+        private
+
+        # Add reflection and define {name} accessor.
+        # @param [ActiveModel::Serializer::Reflection] reflection
+        # @return [void]
+        #
+        # @api private
+        #
+        def associate(reflection)
+          key = reflection.options[:key] || reflection.name
+          self._reflections[key] = reflection
+        end
+      end
+
+      # @param [JSONAPI::IncludeDirective] include_directive (defaults to the
+      #   +default_include_directive+ config value when not provided)
+      # @return [Enumerator<Association>]
+      #
+      def associations(include_directive = ActiveModelSerializers.default_include_directive, include_slice = nil)
+        include_slice ||= include_directive
+        return unless object
+
+        Enumerator.new do |y|
+          self.class._reflections.values.each do |reflection|
+            next if reflection.excluded?(self)
+            key = reflection.options.fetch(:key, reflection.name)
+            next unless include_directive.key?(key)
+
+            y.yield reflection.build_association(self, instance_options, include_slice)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_model/serializer/concerns/attributes.rb

@@ -0,0 +1,82 @@
+module ActiveModel
+  class Serializer
+    module Attributes
+      extend ActiveSupport::Concern
+
+      included do
+        with_options instance_writer: false, instance_reader: false do |serializer|
+          serializer.class_attribute :_attributes_data # @api private
+          self._attributes_data ||= {}
+        end
+
+        extend ActiveSupport::Autoload
+        autoload :Attribute
+
+        # Return the +attributes+ of +object+ as presented
+        # by the serializer.
+        def attributes(requested_attrs = nil, reload = false)
+          @attributes = nil if reload
+          @attributes ||= self.class._attributes_data.each_with_object({}) do |(key, attr), hash|
+            next if attr.excluded?(self)
+            next unless requested_attrs.nil? || requested_attrs.include?(key)
+            hash[key] = attr.value(self)
+          end
+        end
+      end
+
+      module ClassMethods
+        def inherited(base)
+          super
+          base._attributes_data = _attributes_data.dup
+        end
+
+        # @example
+        #   class AdminAuthorSerializer < ActiveModel::Serializer
+        #     attributes :id, :name, :recent_edits
+        def attributes(*attrs)
+          attrs = attrs.first if attrs.first.class == Array
+
+          attrs.each do |attr|
+            attribute(attr)
+          end
+        end
+
+        # @example
+        #   class AdminAuthorSerializer < ActiveModel::Serializer
+        #     attributes :id, :recent_edits
+        #     attribute :name, key: :title
+        #
+        #     attribute :full_name do
+        #       "#{object.first_name} #{object.last_name}"
+        #     end
+        #
+        #     def recent_edits
+        #       object.edits.last(5)
+        #     end
+        def attribute(attr, options = {}, &block)
+          key = options.fetch(:key, attr)
+          _attributes_data[key] = Attribute.new(attr, options, block)
+        end
+
+        # @api private
+        # keys of attributes
+        # @see Serializer::attribute
+        def _attributes
+          _attributes_data.keys
+        end
+
+        # @api private
+        # maps attribute value to explicit key name
+        # @see Serializer::attribute
+        # @see FragmentCache#fragment_serializer
+        def _attributes_keys
+          _attributes_data
+            .each_with_object({}) do |(key, attr), hash|
+              next if key == attr.name
+              hash[attr.name] = { key: key }
+            end
+        end
+      end
+    end
+  end
+end