active_model_serializers 0.10.0.rc1 → 0.10.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e77127a346e9bfdfb4b48152c333394b5c5e2e41
-  data.tar.gz: cc4ba7acbb64a83d588e6da78c54ace9e9309734
+  metadata.gz: 47b346a9a30d6c7e246505a4b48e3c8dd593c2a6
+  data.tar.gz: 74a94269fb1ffd10b1e30b65cd99e43ca3a62b30
 SHA512:
-  metadata.gz: fca71a58180a630765a4628c9202b775fb855c36d517546a6fa122166944cd14d79e968369d7fdabce45c6bd585b55a3e9c17ccd72b8b1287fe8eff0b8507167
-  data.tar.gz: dafdf5f8c3f57bdbaf141d05573459bc14f314a0a5bc6a30f94eb8f8d6f2e8d29649ba34187112c27c819536dd77a7983715b066c83283ef1434a8ea333669ff
+  metadata.gz: 61c621fc667fc3e1e168e50c4af8f267f4b7e3e82ce634d2555e814b2dde4a4514a9033cfa6f917b225bcc01b1f86fee36625a74e4a5d3dbeffc4209ff17aa70
+  data.tar.gz: a365c42818a1d413d10d78abce01954160879249b6b4e6119db93178d54aa4b608c026c730b2da2f00af7c77537a1260a506ed8fbf8cecf73341f90d437b5f89

data/.travis.yml

@@ -15,13 +15,12 @@ install:
   - bundle install --retry=3
 
 env:
-  - "RAILS_VERSION=3.2"
   - "RAILS_VERSION=4.0"
   - "RAILS_VERSION=4.1"
+  - "RAILS_VERSION=4.2"
   - "RAILS_VERSION=master"
 
 matrix:
   allow_failures:
     - rvm: ruby-head
     - env: "RAILS_VERSION=master"
-    - env: "RAILS_VERSION=3.2"

data/Gemfile

@@ -5,7 +5,7 @@ gemspec
 
 gem "minitest"
 
-version = ENV["RAILS_VERSION"] || "4.1"
+version = ENV["RAILS_VERSION"] || "4.2"
 
 if version == "master"
   gem "rails", github: "rails/rails"

data/README.md

@@ -8,6 +8,9 @@ AMS does this through two components: **serializers** and **adapters**.
 Serializers describe _which_ attributes and relationships should be serialized.
 Adapters describe _how_ attributes and relationships should be serialized.
 
+By default AMS will use the **Json Adapter**. But we strongly advise you to use JsonApi Adapter that follows 1.0 of the format specified in [jsonapi.org/format](http://jsonapi.org/format).
+Check how to change the adapter in the sections bellow.
+
 # RELEASE CANDIDATE, PLEASE READ
 
 This is the master branch of AMS. It will become the `0.10.0` release when it's
@@ -175,7 +178,7 @@ end
 
 #### JSONAPI
 
-This adapter follows RC3 of the format specified in
+This adapter follows RC4 of the format specified in
 [jsonapi.org/format](http://jsonapi.org/format). It will include the associated
 resources in the `"included"` member when the resource names are included in the
 `include` option.
@@ -265,7 +268,7 @@ The options are the same options of ```ActiveSupport::Cache::Store```, plus
 a ```key``` option that will be the prefix of the object cache
 on a pattern ```"#{key}/#{object.id}-#{object.updated_at}"```.
 
-The cache support is optimized to use the cached object in multiple request. An object cached on an ```show``` request will be reused at the ```index```. If there is a relationship with another cached serializer it will also be created and reused automatically.
+The cache support is optimized to use the cached object in multiple request. An object cached on a ```show``` request will be reused at the ```index```. If there is a relationship with another cached serializer it will also be created and reused automatically.
 
 **[NOTE] Every object is individually cached.**
 
@@ -294,7 +297,7 @@ but in this case it will be automatically expired after 3 hours.
 
 ### Fragmenting Caching
 
-If there is some API endpoint that shouldn't be fully cached, you can still optmise it, using Fragment Cache on the attributes and relationships that you want to cache.
+If there is some API endpoint that shouldn't be fully cached, you can still optimise it, using Fragment Cache on the attributes and relationships that you want to cache.
 
 You can define the attribute by using ```only``` or ```except``` option on cache method.
 

data/lib/action_controller/serialization.rb

@@ -6,7 +6,7 @@ module ActionController
 
     include ActionController::Renderers
 
-    ADAPTER_OPTION_KEYS = [:include, :fields, :root, :adapter]
+    ADAPTER_OPTION_KEYS = [:include, :fields, :adapter]
 
     included do
       class_attribute :_serialization_scope
@@ -53,6 +53,14 @@ module ActionController
       end
     end
 
+    def rescue_with_handler(exception)
+      @_serializer = nil
+      @_serializer_opts = nil
+      @_adapter_opts = nil
+
+      super(exception)
+    end
+
     module ClassMethods
       def serialization_scope(scope)
         self._serialization_scope = scope

data/lib/active_model/serializer.rb

@@ -19,18 +19,22 @@ module ActiveModel
       attr_accessor :_cache_only
       attr_accessor :_cache_except
       attr_accessor :_cache_options
+      attr_accessor :_cache_digest
     end
 
     def self.inherited(base)
-      base._attributes = []
-      base._attributes_keys = {}
-      base._associations = {}
+      base._attributes = self._attributes.try(:dup)  || []
+      base._attributes_keys = self._attributes_keys.try(:dup) || {}
+      base._associations = self._associations.try(:dup) || {}
       base._urls = []
+      serializer_file = File.open(caller.first[/^[^:]+/])
+      base._cache_digest = Digest::MD5.hexdigest(serializer_file.read)
     end
 
     def self.attributes(*attrs)
       attrs = attrs.first if attrs.first.class == Array
       @_attributes.concat attrs
+      @_attributes.uniq!
 
       attrs.each do |attr|
         define_method attr do
@@ -42,7 +46,7 @@ module ActiveModel
     def self.attribute(attr, options = {})
       key = options.fetch(:key, attr)
       @_attributes_keys[attr] = {key: key} if key != attr
-      @_attributes.concat [key]
+      @_attributes << key unless @_attributes.include?(key)
       define_method key do
         object.read_attribute_for_serialization(attr)
       end unless method_defined?(key) || _fragmented.respond_to?(attr)
@@ -115,7 +119,9 @@ module ActiveModel
     end
 
     def self.serializer_for(resource, options = {})
-      if resource.respond_to?(:to_ary)
+      if resource.respond_to?(:serializer_class)
+        resource.serializer_class
+      elsif resource.respond_to?(:to_ary)
         config.array_serializer
       else
         options
@@ -139,14 +145,6 @@ module ActiveModel
       adapter_class
     end
 
-    def self._root
-      @@root ||= false
-    end
-
-    def self._root=(root)
-      @@root = root
-    end
-
     def self.root_name
       name.demodulize.underscore.sub(/_serializer$/, '') if name
     end
@@ -156,7 +154,7 @@ module ActiveModel
     def initialize(object, options = {})
       @object     = object
       @options    = options
-      @root       = options[:root] || (self.class._root ? self.class.root_name : false)
+      @root       = options[:root]
       @meta       = options[:meta]
       @meta_key   = options[:meta_key]
       @scope      = options[:scope]
@@ -170,11 +168,7 @@ module ActiveModel
     end
 
     def json_key
-      if root == true || root.nil?
-        self.class.root_name
-      else
-        root
-      end
+      self.class.root_name
     end
 
     def id
@@ -182,7 +176,7 @@ module ActiveModel
     end
 
     def type
-      object.class.to_s.demodulize.underscore.pluralize
+      object.class.model_name.plural
     end
 
     def attributes(options = {})
@@ -214,7 +208,7 @@ module ActiveModel
         if serializer_class
           serializer = serializer_class.new(
             association_value,
-            options.merge(serializer_from_options(association_options))
+            options.except(:serializer).merge(serializer_from_options(association_options))
           )
         elsif !association_value.nil? && !association_value.instance_of?(Object)
           association_options[:association_options][:virtual_value] = association_value

data/lib/active_model/serializer/adapter.rb

@@ -5,6 +5,7 @@ module ActiveModel
     class Adapter
       extend ActiveSupport::Autoload
       autoload :Json
+      autoload :FlattenJson
       autoload :Null
       autoload :JsonApi
 
@@ -21,7 +22,8 @@ module ActiveModel
 
       def as_json(options = {})
         hash = serializable_hash(options)
-        include_meta(hash)
+        include_meta(hash) unless self.class == FlattenJson
+        hash
       end
 
       def self.create(resource, options = {})
@@ -48,7 +50,7 @@ module ActiveModel
             yield
           end
         elsif is_fragment_cached?
-          FragmentCache.new(self, @cached_serializer, @options, @root).fetch
+          FragmentCache.new(self, @cached_serializer, @options).fetch
         else
           yield
         end
@@ -63,6 +65,13 @@ module ActiveModel
       end
 
       def cache_key
+        parts = []
+        parts << object_cache_key
+        parts << @klass._cache_digest unless @klass._cache_options && @klass._cache_options[:skip_digest]
+        parts.join("/")
+      end
+
+      def object_cache_key
         (@klass._cache_key) ? "#{@klass._cache_key}/#{@cached_serializer.object.id}-#{@cached_serializer.object.updated_at}" : @cached_serializer.object.cache_key
       end
 
@@ -75,11 +84,11 @@ module ActiveModel
       end
 
       def root
-        serializer.json_key
+        serializer.json_key.to_sym if serializer.json_key
       end
 
       def include_meta(json)
-        json[meta_key] = meta if meta && root
+        json[meta_key] = meta if meta
         json
       end
     end

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

@@ -0,0 +1,12 @@
+module ActiveModel
+  class Serializer
+    class Adapter
+      class FlattenJson < Json
+        def serializable_hash(options = {})
+          super
+          @result
+        end
+      end
+    end
+  end
+end

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

@@ -5,8 +5,7 @@ module ActiveModel
 
         attr_reader :serializer
 
-        def initialize(adapter, serializer, options, root)
-          @root       = root
+        def initialize(adapter, serializer, options)
           @options    = options
           @adapter    = adapter
           @serializer = serializer
@@ -35,8 +34,9 @@ module ActiveModel
         private
 
         def cached_attributes(klass, serializers)
-          cached_attributes     = (klass._cache_only) ? klass._cache_only : serializer.attributes.keys.delete_if {|attr| klass._cache_except.include?(attr) }
-          non_cached_attributes = serializer.attributes.keys.delete_if {|attr| cached_attributes.include?(attr) }
+          attributes            = serializer.class._attributes
+          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|
             options = serializer.class._attributes_keys[attribute]
@@ -75,4 +75,4 @@ module ActiveModel
       end
     end
   end
-end
+end

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

@@ -6,7 +6,7 @@ module ActiveModel
       class Json < Adapter
         def serializable_hash(options = {})
           if serializer.respond_to?(:each)
-            @result = serializer.map{|s| self.class.new(s).serializable_hash }
+            @result = serializer.map{|s| FlattenJson.new(s).serializable_hash }
           else
             @hash = {}
 
@@ -23,7 +23,7 @@ module ActiveModel
                   end
                 end
               else
-                if association
+                if association && association.object
                   @hash[name] = cache_check(association) do
                     association.attributes(options)
                   end
@@ -37,16 +37,14 @@ module ActiveModel
             @result = @core.merge @hash
           end
 
-          if root = options.fetch(:root, serializer.json_key)
-            @result = { root => @result }
-          end
-          @result
+          { root => @result }
+        end
+
+        def fragment_cache(cached_hash, non_cached_hash)
+          Json::FragmentCache.new().fragment_cache(cached_hash, non_cached_hash)
         end
-      end
 
-      def fragment_cache(cached_hash, non_cached_hash)
-        Json::FragmentCache.new().fragment_cache(cached_hash, non_cached_hash)
       end
     end
   end
-end
+end

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

@@ -6,7 +6,6 @@ module ActiveModel
       class JsonApi < Adapter
         def initialize(serializer, options = {})
           super
-          serializer.root = true
           @hash = { data: [] }
 
           if fields = options.delete(:fields)
@@ -29,7 +28,7 @@ module ActiveModel
             end
           else
             @hash[:data] = attributes_for_serializer(serializer, @options)
-            add_resource_links(@hash[:data], serializer)
+            add_resource_relationships(@hash[:data], serializer)
           end
           @hash
         end
@@ -41,18 +40,18 @@ module ActiveModel
 
         private
 
-        def add_links(resource, name, serializers)
-          resource[:links] ||= {}
-          resource[:links][name] ||= { linkage: [] }
-          resource[:links][name][:linkage] += serializers.map { |serializer| { type: serializer.type, id: serializer.id.to_s } }
+        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_link(resource, name, serializer, val=nil)
-          resource[:links] ||= {}
-          resource[:links][name] = { linkage: nil }
+        def add_relationship(resource, name, serializer, val=nil)
+          resource[:relationships] ||= {}
+          resource[:relationships][name] = { data: nil }
 
           if serializer && serializer.object
-            resource[:links][name][:linkage] = { type: serializer.type, id: serializer.id.to_s }
+            resource[:relationships][name][:data] = { type: serializer.type, id: serializer.id.to_s }
           end
         end
 
@@ -68,7 +67,7 @@ module ActiveModel
             serializers.each do |serializer|
               attrs = attributes_for_serializer(serializer, @options)
 
-              add_resource_links(attrs, serializer, add_included: false)
+              add_resource_relationships(attrs, serializer, add_included: false)
 
               @hash[:included].push(attrs) unless @hash[:included].include?(attrs)
             end
@@ -85,26 +84,31 @@ module ActiveModel
           if serializer.respond_to?(:each)
             result = []
             serializer.each do |object|
-              options[:fields] = @fieldset && @fieldset.fields_for(serializer)
-              result << cache_check(object) do
-                options[:required_fields] = [:id, :type]
-                attributes = object.attributes(options)
-                attributes[:id] = attributes[:id].to_s
-                result << attributes
-              end
+              result << resource_object_for(object, options)
             end
           else
-            options[:fields] = @fieldset && @fieldset.fields_for(serializer)
-            options[:required_fields] = [:id, :type]
-            result = cache_check(serializer) do
-              result = serializer.attributes(options)
-              result[:id] = result[:id].to_s
-              result
-            end
+            result = resource_object_for(serializer, options)
           end
           result
         end
 
+        def resource_object_for(serializer, options)
+          options[:fields] = @fieldset && @fieldset.fields_for(serializer)
+          options[:required_fields] = [:id, :type]
+
+          cache_check(serializer) do
+            attributes = serializer.attributes(options)
+
+            result = {
+              id: attributes.delete(:id).to_s,
+              type: attributes.delete(:type)
+            }
+
+            result[:attributes] = attributes if attributes.any?
+            result
+          end
+        end
+
         def include_assoc?(assoc)
           return false unless @options[:include]
           check_assoc("#{assoc}$")
@@ -123,19 +127,19 @@ module ActiveModel
           end
         end
 
-        def add_resource_links(attrs, serializer, options = {})
+        def add_resource_relationships(attrs, serializer, options = {})
           options[:add_included] = options.fetch(:add_included, true)
 
           serializer.each_association do |name, association, opts|
-            attrs[:links] ||= {}
+            attrs[:relationships] ||= {}
 
             if association.respond_to?(:each)
-              add_links(attrs, name, association)
+              add_relationships(attrs, name, association)
             else
               if opts[:virtual_value]
-                add_link(attrs, name, nil, opts[:virtual_value])
+                add_relationship(attrs, name, nil, opts[:virtual_value])
               else
-                add_link(attrs, name, association)
+                add_relationship(attrs, name, association)
               end
             end