active_model_serializers 0.10.0.rc3 → 0.10.0.rc4

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

@@ -0,0 +1,207 @@
+module ActiveModel
+  class Serializer
+    module Adapter
+      class JsonApi
+        # NOTE(Experimental):
+        # This is an experimental feature. Both the interface and internals could be subject
+        # to changes.
+        module Deserialization
+          InvalidDocument = Class.new(ArgumentError)
+
+          module_function
+
+          # Transform a JSON API document, containing a single data object,
+          # into a hash that is ready for ActiveRecord::Base.new() and such.
+          # Raises InvalidDocument if the payload is not properly formatted.
+          #
+          # @param [Hash|ActionController::Parameters] document
+          # @param [Hash] options
+          #   only: Array of symbols of whitelisted fields.
+          #   except: Array of symbols of blacklisted fields.
+          #   keys: Hash of translated keys (e.g. :author => :user).
+          #   polymorphic: Array of symbols of polymorphic fields.
+          # @return [Hash]
+          #
+          # @example
+          #   document = {
+          #     data: {
+          #       id: 1,
+          #       type: 'post',
+          #       attributes: {
+          #         title: 'Title 1',
+          #         date: '2015-12-20'
+          #       },
+          #       associations: {
+          #         author: {
+          #           data: {
+          #             type: 'user',
+          #             id: 2
+          #           }
+          #         },
+          #         second_author: {
+          #           data: nil
+          #         },
+          #         comments: {
+          #           data: [{
+          #             type: 'comment',
+          #             id: 3
+          #           },{
+          #             type: 'comment',
+          #             id: 4
+          #           }]
+          #         }
+          #       }
+          #     }
+          #   }
+          #
+          #   parse(document) #=>
+          #     # {
+          #     #   title: 'Title 1',
+          #     #   date: '2015-12-20',
+          #     #   author_id: 2,
+          #     #   second_author_id: nil
+          #     #   comment_ids: [3, 4]
+          #     # }
+          #
+          #   parse(document, only: [:title, :date, :author],
+          #                   keys: { date: :published_at },
+          #                   polymorphic: [:author]) #=>
+          #     # {
+          #     #   title: 'Title 1',
+          #     #   published_at: '2015-12-20',
+          #     #   author_id: '2',
+          #     #   author_type: 'people'
+          #     # }
+          #
+          def parse!(document, options = {})
+            parse(document, options) do |invalid_payload, reason|
+              fail InvalidDocument, "Invalid payload (#{reason}): #{invalid_payload}"
+            end
+          end
+
+          # Same as parse!, but returns an empty hash instead of raising InvalidDocument
+          # on invalid payloads.
+          def parse(document, options = {})
+            document = document.dup.permit!.to_h if document.is_a?(ActionController::Parameters)
+
+            validate_payload(document) do |invalid_document, reason|
+              yield invalid_document, reason if block_given?
+              return {}
+            end
+
+            primary_data = document['data']
+            attributes = primary_data['attributes'] || {}
+            attributes['id'] = primary_data['id'] if primary_data['id']
+            relationships = primary_data['relationships'] || {}
+
+            filter_fields(attributes, options)
+            filter_fields(relationships, options)
+
+            hash = {}
+            hash.merge!(parse_attributes(attributes, options))
+            hash.merge!(parse_relationships(relationships, options))
+
+            hash
+          end
+
+          # Checks whether a payload is compliant with the JSON API spec.
+          #
+          # @api private
+          # rubocop:disable Metrics/CyclomaticComplexity
+          def validate_payload(payload)
+            unless payload.is_a?(Hash)
+              yield payload, 'Expected hash'
+              return
+            end
+
+            primary_data = payload['data']
+            unless primary_data.is_a?(Hash)
+              yield payload, { data: 'Expected hash' }
+              return
+            end
+
+            attributes = primary_data['attributes'] || {}
+            unless attributes.is_a?(Hash)
+              yield payload, { data: { attributes: 'Expected hash or nil' } }
+              return
+            end
+
+            relationships = primary_data['relationships'] || {}
+            unless relationships.is_a?(Hash)
+              yield payload, { data: { relationships: 'Expected hash or nil' } }
+              return
+            end
+
+            relationships.each do |(key, value)|
+              unless value.is_a?(Hash) && value.key?('data')
+                yield payload, { data: { relationships: { key => 'Expected hash with :data key' } } }
+              end
+            end
+          end
+          # rubocop:enable Metrics/CyclomaticComplexity
+
+          # @api private
+          def filter_fields(fields, options)
+            if (only = options[:only])
+              fields.slice!(*Array(only).map(&:to_s))
+            elsif (except = options[:except])
+              fields.except!(*Array(except).map(&:to_s))
+            end
+          end
+
+          # @api private
+          def field_key(field, options)
+            (options[:keys] || {}).fetch(field.to_sym, field).to_sym
+          end
+
+          # @api private
+          def parse_attributes(attributes, options)
+            attributes
+              .map { |(k, v)| { field_key(k, options) => v } }
+              .reduce({}, :merge)
+          end
+
+          # Given an association name, and a relationship data attribute, build a hash
+          # mapping the corresponding ActiveRecord attribute to the corresponding value.
+          #
+          # @example
+          #   parse_relationship(:comments, [{ 'id' => '1', 'type' => 'comments' },
+          #                                  { 'id' => '2', 'type' => 'comments' }],
+          #                                 {})
+          #    # => { :comment_ids => ['1', '2'] }
+          #   parse_relationship(:author, { 'id' => '1', 'type' => 'users' }, {})
+          #    # => { :author_id => '1' }
+          #   parse_relationship(:author, nil, {})
+          #    # => { :author_id => nil }
+          # @param [Symbol] assoc_name
+          # @param [Hash] assoc_data
+          # @param [Hash] options
+          # @return [Hash{Symbol, Object}]
+          #
+          # @api private
+          def parse_relationship(assoc_name, assoc_data, options)
+            prefix_key = field_key(assoc_name, options).to_s.singularize
+            hash =
+              if assoc_data.is_a?(Array)
+                { "#{prefix_key}_ids".to_sym => assoc_data.map { |ri| ri['id'] } }
+              else
+                { "#{prefix_key}_id".to_sym => assoc_data ? assoc_data['id'] : nil }
+              end
+
+            polymorphic = (options[:polymorphic] || []).include?(assoc_name.to_sym)
+            hash.merge!("#{prefix_key}_type".to_sym => assoc_data['type']) if polymorphic
+
+            hash
+          end
+
+          # @api private
+          def parse_relationships(relationships, options)
+            relationships
+              .map { |(k, v)| parse_relationship(k, v['data'], options) }
+              .reduce({}, :merge)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,8 @@
-class ActiveModel::Serializer::Adapter::JsonApi::FragmentCache
+module ActiveModel
+  class Serializer
+    module Adapter
+      class JsonApi
+        class FragmentCache
           def fragment_cache(root, cached_hash, non_cached_hash)
             hash              = {}
             core_cached       = cached_hash.first
@@ -10,4 +14,8 @@ class ActiveModel::Serializer::Adapter::JsonApi::FragmentCache
 
             hash.deep_merge no_root_non_cache.deep_merge no_root_cache
           end
+        end
+      end
+    end
+  end
 end

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

@@ -0,0 +1,44 @@
+module ActiveModel
+  class Serializer
+    module Adapter
+      class JsonApi
+        class Link
+          def initialize(serializer, value)
+            @object = serializer.object
+            @scope = serializer.scope
+
+            # Use the return value of the block unless it is nil.
+            if value.respond_to?(:call)
+              @value = instance_eval(&value)
+            else
+              @value = value
+            end
+          end
+
+          def href(value)
+            @href = value
+            nil
+          end
+
+          def meta(value)
+            @meta = value
+            nil
+          end
+
+          def as_json
+            return @value if @value
+
+            hash = { href: @href }
+            hash.merge!(meta: @meta) if @meta
+
+            hash
+          end
+
+          protected
+
+          attr_reader :object, :scope
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,8 @@
-class ActiveModel::Serializer::Adapter::JsonApi::PaginationLinks
+module ActiveModel
+  class Serializer
+    module Adapter
+      class JsonApi < Base
+        class PaginationLinks
           FIRST_PAGE = 1
 
           attr_reader :collection, :context
@@ -37,14 +41,18 @@ class ActiveModel::Serializer::Adapter::JsonApi::PaginationLinks
           end
 
           def url(options)
-            @url ||= options.fetch(:links, {}).fetch(:self, nil) || original_url
+            @url ||= options.fetch(:links, {}).fetch(:self, nil) || request_url
           end
 
-          def original_url
-            @original_url ||= context.original_url[/\A[^?]+/]
+          def request_url
+            @request_url ||= context.request_url
           end
 
           def query_parameters
             @query_parameters ||= context.query_parameters
           end
+        end
+      end
+    end
+  end
 end

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

@@ -1,5 +1,11 @@
-class ActiveModel::Serializer::Adapter::Null < ActiveModel::Serializer::Adapter
+module ActiveModel
+  class Serializer
+    module Adapter
+      class Null < Base
         def serializable_hash(options = nil)
           {}
         end
+      end
+    end
+  end
 end

data/lib/active_model/serializer/array_serializer.rb

@@ -1,40 +1,9 @@
-module ActiveModel
-  class Serializer
-    class ArraySerializer
-      NoSerializerError = Class.new(StandardError)
-      include Enumerable
-      delegate :each, to: :@serializers
-
-      attr_reader :object, :root, :meta, :meta_key
-
-      def initialize(resources, options = {})
-        @root = options[:root]
-        @object = resources
-        @serializers = resources.map do |resource|
-          serializer_class = options.fetch(:serializer) {
-            ActiveModel::Serializer.serializer_for(resource)
-          }
-
-          if serializer_class.nil?
-            fail NoSerializerError, "No serializer found for resource: #{resource.inspect}"
-          else
-            serializer_class.new(resource, options.except(:serializer))
-          end
-        end
-        @meta     = options[:meta]
-        @meta_key = options[:meta_key]
-      end
-
-      def json_key
-        key = root || @serializers.first.try(:json_key) || object.try(:name).try(:underscore)
-        key.try(:pluralize)
-      end
-
-      def paginated?
-        object.respond_to?(:current_page) &&
-          object.respond_to?(:total_pages) &&
-          object.respond_to?(:size)
-      end
+require 'active_model/serializer/collection_serializer'
+class ActiveModel::Serializer
+  class ArraySerializer < CollectionSerializer
+    def initialize(*)
+      warn "Calling deprecated ArraySerializer in #{caller[0..2].join(', ')}. Please use CollectionSerializer"
+      super
     end
   end
 end

data/lib/active_model/serializer/associations.rb

@@ -10,11 +10,15 @@ module ActiveModel
     module Associations
       extend ActiveSupport::Concern
 
-      included do |base|
-        class << base
-          attr_accessor :_reflections
+      DEFAULT_INCLUDE_TREE = ActiveModel::Serializer::IncludeTree.from_string('*')
+
+      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
@@ -26,7 +30,8 @@ module ActiveModel
 
       module ClassMethods
         def inherited(base)
-          base._reflections = self._reflections.try(:dup) || []
+          super
+          base._reflections = _reflections.dup
         end
 
         # @param [Symbol] name of the association
@@ -36,8 +41,8 @@ module ActiveModel
         # @example
         #  has_many :comments, serializer: CommentSummarySerializer
         #
-        def has_many(name, options = {})
-          associate HasManyReflection.new(name, options)
+        def has_many(name, options = {}, &block)
+          associate(HasManyReflection.new(name, options, block))
         end
 
         # @param [Symbol] name of the association
@@ -47,8 +52,8 @@ module ActiveModel
         # @example
         #  belongs_to :author, serializer: AuthorSerializer
         #
-        def belongs_to(name, options = {})
-          associate BelongsToReflection.new(name, options)
+        def belongs_to(name, options = {}, &block)
+          associate(BelongsToReflection.new(name, options, block))
         end
 
         # @param [Symbol] name of the association
@@ -58,8 +63,8 @@ module ActiveModel
         # @example
         #  has_one :author, serializer: AuthorSerializer
         #
-        def has_one(name, options = {})
-          associate HasOneReflection.new(name, options)
+        def has_one(name, options = {}, &block)
+          associate(HasOneReflection.new(name, options, block))
         end
 
         private
@@ -71,24 +76,22 @@ module ActiveModel
         # @api private
         #
         def associate(reflection)
-          self._reflections = _reflections.dup
-
-          define_method reflection.name do
-            object.send reflection.name
-          end unless method_defined?(reflection.name)
-
           self._reflections << reflection
         end
       end
 
+      # @param [IncludeTree] include_tree (defaults to all associations when not provided)
       # @return [Enumerator<Association>]
       #
-      def associations
+      def associations(include_tree = DEFAULT_INCLUDE_TREE)
         return unless object
 
         Enumerator.new do |y|
           self.class._reflections.each do |reflection|
-            y.yield reflection.build_association(self, options)
+            next if reflection.excluded?(self)
+            key = reflection.options.fetch(:key, reflection.name)
+            next unless include_tree.key?(key)
+            y.yield reflection.build_association(self, instance_options)
           end
         end
       end