active_model_serializers 0.10.0.rc2 → 0.10.0.rc3

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

@@ -1,12 +1,12 @@
-module ActiveModel
-  class Serializer
-    class Adapter
-      class FlattenJson < Json
+class ActiveModel::Serializer::Adapter::FlattenJson < ActiveModel::Serializer::Adapter::Json
         def serializable_hash(options = {})
-          super
-          @result
+          super.each_value.first
+        end
+
+        private
+
+        # no-op: FlattenJson adapter does not include meta data, because it does not support root.
+        def include_meta(json)
+          json
         end
-      end
-    end
-  end
 end

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

@@ -1,8 +1,4 @@
-module ActiveModel
-  class Serializer
-    class Adapter
-      class FragmentCache
-
+class ActiveModel::Serializer::Adapter::FragmentCache
         attr_reader :serializer
 
         def initialize(adapter, serializer, options)
@@ -35,7 +31,7 @@ module ActiveModel
 
         def cached_attributes(klass, serializers)
           attributes            = serializer.class._attributes
-          cached_attributes     = (klass._cache_only) ? klass._cache_only : attributes.reject {|attr| klass._cache_except.include?(attr) }
+          cached_attributes     = (klass._cache_only) ? klass._cache_only : attributes.reject { |attr| klass._cache_except.include?(attr) }
           non_cached_attributes = attributes - cached_attributes
 
           cached_attributes.each do |attribute|
@@ -54,13 +50,13 @@ module ActiveModel
         end
 
         def fragment_serializer(name, klass)
-          cached     = "#{name.capitalize}CachedSerializer"
-          non_cached = "#{name.capitalize}NonCachedSerializer"
+          cached     = "#{to_valid_const_name(name)}CachedSerializer"
+          non_cached = "#{to_valid_const_name(name)}NonCachedSerializer"
 
           Object.const_set cached, Class.new(ActiveModel::Serializer) unless Object.const_defined?(cached)
           Object.const_set non_cached, Class.new(ActiveModel::Serializer) unless Object.const_defined?(non_cached)
 
-          klass._cache_options       ||= {}
+          klass._cache_options ||= {}
           klass._cache_options[:key] = klass._cache_key if klass._cache_key
 
           cached.constantize.cache(klass._cache_options)
@@ -68,11 +64,12 @@ module ActiveModel
           cached.constantize.fragmented(serializer)
           non_cached.constantize.fragmented(serializer)
 
-          serializers = {cached: cached, non_cached: non_cached}
+          serializers = { cached: cached, non_cached: non_cached }
           cached_attributes(klass, serializers)
           serializers
         end
-      end
-    end
-  end
+
+        def to_valid_const_name(name)
+          name.gsub('::', '_')
+        end
 end

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

@@ -1,50 +1,47 @@
-require 'active_model/serializer/adapter/json/fragment_cache'
+class ActiveModel::Serializer::Adapter::Json < ActiveModel::Serializer::Adapter
+        extend ActiveSupport::Autoload
+        autoload :FragmentCache
 
-module ActiveModel
-  class Serializer
-    class Adapter
-      class Json < Adapter
-        def serializable_hash(options = {})
+        def serializable_hash(options = nil)
+          options ||= {}
           if serializer.respond_to?(:each)
-            @result = serializer.map{|s| FlattenJson.new(s).serializable_hash }
+            result = serializer.map { |s| FlattenJson.new(s).serializable_hash(options) }
           else
-            @hash = {}
+            hash = {}
 
-            @core = cache_check(serializer) do
+            core = cache_check(serializer) do
               serializer.attributes(options)
             end
 
-            serializer.each_association do |name, association, opts|
-              if association.respond_to?(:each)
-                array_serializer = association
-                @hash[name] = array_serializer.map do |item|
+            serializer.associations.each do |association|
+              serializer = association.serializer
+              opts = association.options
+
+              if serializer.respond_to?(:each)
+                array_serializer = serializer
+                hash[association.key] = array_serializer.map do |item|
                   cache_check(item) do
                     item.attributes(opts)
                   end
                 end
               else
-                if association && association.object
-                  @hash[name] = cache_check(association) do
-                    association.attributes(options)
+                hash[association.key] =
+                  if serializer && serializer.object
+                    cache_check(serializer) do
+                      serializer.attributes(options)
+                    end
+                  elsif opts[:virtual_value]
+                    opts[:virtual_value]
                   end
-                elsif opts[:virtual_value]
-                  @hash[name] = opts[:virtual_value]
-                else
-                  @hash[name] = nil
-                end
               end
             end
-            @result = @core.merge @hash
+            result = core.merge hash
           end
 
-          { root => @result }
+          { root => result }
         end
 
         def fragment_cache(cached_hash, non_cached_hash)
-          Json::FragmentCache.new().fragment_cache(cached_hash, non_cached_hash)
+          ActiveModel::Serializer::Adapter::Json::FragmentCache.new().fragment_cache(cached_hash, non_cached_hash)
         end
-
-      end
-    end
-  end
 end

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

@@ -1,15 +1,5 @@
-module ActiveModel
-  class Serializer
-    class Adapter
-      class Json < Adapter
-        class FragmentCache
-
+class ActiveModel::Serializer::Adapter::Json::FragmentCache
           def fragment_cache(cached_hash, non_cached_hash)
             non_cached_hash.merge cached_hash
           end
-
-        end
-      end
-    end
-  end
-end
+end

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

@@ -1,156 +1,158 @@
-require 'active_model/serializer/adapter/json_api/fragment_cache'
+class ActiveModel::Serializer::Adapter::JsonApi < ActiveModel::Serializer::Adapter
+        extend ActiveSupport::Autoload
+        autoload :PaginationLinks
+        autoload :FragmentCache
 
-module ActiveModel
-  class Serializer
-    class Adapter
-      class JsonApi < Adapter
         def initialize(serializer, options = {})
           super
-          @hash = { data: [] }
-
-          if fields = options.delete(:fields)
+          @included = ActiveModel::Serializer::Utils.include_args_to_hash(@options[:include])
+          fields = options.delete(:fields)
+          if fields
             @fieldset = ActiveModel::Serializer::Fieldset.new(fields, serializer.json_key)
           else
             @fieldset = options[:fieldset]
           end
         end
 
-        def serializable_hash(options = {})
+        def serializable_hash(options = nil)
+          options ||= {}
           if serializer.respond_to?(:each)
-            serializer.each do |s|
-              result = self.class.new(s, @options.merge(fieldset: @fieldset)).serializable_hash
-              @hash[:data] << result[:data]
-
-              if result[:included]
-                @hash[:included] ||= []
-                @hash[:included] |= result[:included]
-              end
-            end
+            serializable_hash_for_collection(serializer, options)
           else
-            @hash[:data] = attributes_for_serializer(serializer, @options)
-            add_resource_relationships(@hash[:data], serializer)
+            serializable_hash_for_single_resource(serializer, options)
           end
-          @hash
         end
 
         def fragment_cache(cached_hash, non_cached_hash)
           root = false if @options.include?(:include)
-          JsonApi::FragmentCache.new().fragment_cache(root, cached_hash, non_cached_hash)
+          ActiveModel::Serializer::Adapter::JsonApi::FragmentCache.new.fragment_cache(root, cached_hash, non_cached_hash)
         end
 
         private
 
-        def add_relationships(resource, name, serializers)
-          resource[:relationships] ||= {}
-          resource[:relationships][name] ||= { data: [] }
-          resource[:relationships][name][:data] += serializers.map { |serializer| { type: serializer.type, id: serializer.id.to_s } }
-        end
-
-        def add_relationship(resource, name, serializer, val=nil)
-          resource[:relationships] ||= {}
-          resource[:relationships][name] = { data: nil }
+        def serializable_hash_for_collection(serializer, options)
+          hash = { data: [] }
+          serializer.each do |s|
+            result = self.class.new(s, @options.merge(fieldset: @fieldset)).serializable_hash(options)
+            hash[:data] << result[:data]
 
-          if serializer && serializer.object
-            resource[:relationships][name][:data] = { type: serializer.type, id: serializer.id.to_s }
+            if result[:included]
+              hash[:included] ||= []
+              hash[:included] |= result[:included]
+            end
           end
-        end
 
-        def add_included(resource_name, serializers, parent = nil)
-          unless serializers.respond_to?(:each)
-            return unless serializers.object
-            serializers = Array(serializers)
+          if serializer.paginated?
+            hash[:links] ||= {}
+            hash[:links].update(links_for(serializer, options))
           end
-          resource_path = [parent, resource_name].compact.join('.')
-          if include_assoc?(resource_path)
-            @hash[:included] ||= []
 
-            serializers.each do |serializer|
-              attrs = attributes_for_serializer(serializer, @options)
+          hash
+        end
 
-              add_resource_relationships(attrs, serializer, add_included: false)
+        def serializable_hash_for_single_resource(serializer, options)
+          primary_data = primary_data_for(serializer, options)
+          relationships = relationships_for(serializer)
+          included = included_for(serializer)
+          hash = { data: primary_data }
+          hash[:data][:relationships] = relationships if relationships.any?
+          hash[:included] = included if included.any?
 
-              @hash[:included].push(attrs) unless @hash[:included].include?(attrs)
-            end
-          end
+          hash
+        end
 
-          serializers.each do |serializer|
-            serializer.each_association do |name, association, opts|
-              add_included(name, association, resource_path) if association
-            end if include_nested_assoc? resource_path
+        def resource_identifier_type_for(serializer)
+          if ActiveModel::Serializer.config.jsonapi_resource_type == :singular
+            serializer.object.class.model_name.singular
+          else
+            serializer.object.class.model_name.plural
           end
         end
 
-        def attributes_for_serializer(serializer, options)
-          if serializer.respond_to?(:each)
-            result = []
-            serializer.each do |object|
-              result << resource_object_for(object, options)
-            end
+        def resource_identifier_id_for(serializer)
+          if serializer.respond_to?(:id)
+            serializer.id
           else
-            result = resource_object_for(serializer, options)
+            serializer.object.id
           end
-          result
         end
 
-        def resource_object_for(serializer, options)
-          options[:fields] = @fieldset && @fieldset.fields_for(serializer)
-          options[:required_fields] = [:id, :type]
+        def resource_identifier_for(serializer)
+          type = resource_identifier_type_for(serializer)
+          id   = resource_identifier_id_for(serializer)
 
-          cache_check(serializer) do
-            attributes = serializer.attributes(options)
+          { id: id.to_s, type: type }
+        end
 
-            result = {
-              id: attributes.delete(:id).to_s,
-              type: attributes.delete(:type)
-            }
+        def resource_object_for(serializer, options = {})
+          options[:fields] = @fieldset && @fieldset.fields_for(serializer)
 
+          cache_check(serializer) do
+            result = resource_identifier_for(serializer)
+            attributes = serializer.attributes(options).except(:id)
             result[:attributes] = attributes if attributes.any?
             result
           end
         end
 
-        def include_assoc?(assoc)
-          return false unless @options[:include]
-          check_assoc("#{assoc}$")
+        def primary_data_for(serializer, options)
+          if serializer.respond_to?(:each)
+            serializer.map { |s| resource_object_for(s, options) }
+          else
+            resource_object_for(serializer, options)
+          end
+        end
+
+        def relationship_value_for(serializer, options = {})
+          if serializer.respond_to?(:each)
+            serializer.map { |s| resource_identifier_for(s) }
+          else
+            if options[:virtual_value]
+              options[:virtual_value]
+            elsif serializer && serializer.object
+              resource_identifier_for(serializer)
+            end
+          end
         end
 
-        def include_nested_assoc?(assoc)
-          return false unless @options[:include]
-          check_assoc("#{assoc}.")
+        def relationships_for(serializer)
+          Hash[serializer.associations.map { |association| [association.key, { data: relationship_value_for(association.serializer, association.options) }] }]
         end
 
-        def check_assoc(assoc)
-          include_opt = @options[:include]
-          include_opt = include_opt.split(',') if include_opt.is_a?(String)
-          include_opt.any? do |s|
-            s.match(/^#{assoc.gsub('.', '\.')}/)
+        def included_for(serializer)
+          included = @included.flat_map do |inc|
+            association = serializer.associations.find { |assoc| assoc.key == inc.first }
+            _included_for(association.serializer, inc.second) if association
           end
+
+          included.uniq
         end
 
-        def add_resource_relationships(attrs, serializer, options = {})
-          options[:add_included] = options.fetch(:add_included, true)
+        def _included_for(serializer, includes)
+          if serializer.respond_to?(:each)
+            serializer.flat_map { |s| _included_for(s, includes) }.uniq
+          else
+            return [] unless serializer && serializer.object
 
-          serializer.each_association do |name, association, opts|
-            attrs[:relationships] ||= {}
+            primary_data = primary_data_for(serializer, @options)
+            relationships = relationships_for(serializer)
+            primary_data[:relationships] = relationships if relationships.any?
 
-            if association.respond_to?(:each)
-              add_relationships(attrs, name, association)
-            else
-              if opts[:virtual_value]
-                add_relationship(attrs, name, nil, opts[:virtual_value])
-              else
-                add_relationship(attrs, name, association)
-              end
-            end
+            included = [primary_data]
 
-            if options[:add_included]
-              Array(association).each do |association|
-                add_included(name, association)
+            includes.each do |inc|
+              association = serializer.associations.find { |assoc| assoc.key == inc.first }
+              if association
+                included.concat(_included_for(association.serializer, inc.second))
+                included.uniq!
               end
             end
+
+            included
           end
         end
-      end
-    end
-  end
+
+        def links_for(serializer, options)
+          JsonApi::PaginationLinks.new(serializer.object, options[:context]).serializable_hash(options)
+        end
 end

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

@@ -1,23 +1,13 @@
-module ActiveModel
-  class Serializer
-    class Adapter
-      class JsonApi < Adapter
-        class FragmentCache
-
+class ActiveModel::Serializer::Adapter::JsonApi::FragmentCache
           def fragment_cache(root, cached_hash, non_cached_hash)
             hash              = {}
             core_cached       = cached_hash.first
             core_non_cached   = non_cached_hash.first
-            no_root_cache     = cached_hash.delete_if {|key, value| key == core_cached[0] }
-            no_root_non_cache = non_cached_hash.delete_if {|key, value| key == core_non_cached[0] }
+            no_root_cache     = cached_hash.delete_if { |key, value| key == core_cached[0] }
+            no_root_non_cache = non_cached_hash.delete_if { |key, value| key == core_non_cached[0] }
             cached_resource   = (core_cached[1]) ? core_cached[1].deep_merge(core_non_cached[1]) : core_non_cached[1]
             hash = (root) ? { root => cached_resource } : cached_resource
 
             hash.deep_merge no_root_non_cache.deep_merge no_root_cache
           end
-
-        end
-      end
-    end
-  end
-end
+end