active_model_serializers 0.10.0.rc5 → 0.10.0

data/lib/active_model/serializer/field.rb

@@ -4,6 +4,12 @@ module ActiveModel
     # specified in the ActiveModel::Serializer class.
     # Notice that the field block is evaluated in the context of the serializer.
     Field = Struct.new(:name, :options, :block) do
+      def initialize(*)
+        super
+
+        validate_condition!
+      end
+
       # Compute the actual value of a field for a given serializer instance.
       # @param [Serializer] The serializer instance for which the value is computed.
       # @return [Object] value
@@ -27,9 +33,9 @@ module ActiveModel
       def excluded?(serializer)
         case condition_type
         when :if
-          !serializer.public_send(condition)
+          !evaluate_condition(serializer)
         when :unless
-          serializer.public_send(condition)
+          evaluate_condition(serializer)
         else
           false
         end
@@ -37,6 +43,34 @@ module ActiveModel
 
       private
 
+      def validate_condition!
+        return if condition_type == :none
+
+        case condition
+        when Symbol, String, Proc
+          # noop
+        else
+          fail TypeError, "#{condition_type.inspect} should be a Symbol, String or Proc"
+        end
+      end
+
+      def evaluate_condition(serializer)
+        case condition
+        when Symbol
+          serializer.public_send(condition)
+        when String
+          serializer.instance_eval(condition)
+        when Proc
+          if condition.arity.zero?
+            serializer.instance_exec(&condition)
+          else
+            serializer.instance_exec(serializer, &condition)
+          end
+        else
+          nil
+        end
+      end
+
       def condition_type
         @condition_type ||=
           if options.key?(:if)

data/lib/active_model/serializer/lint.rb

@@ -36,16 +36,10 @@ module ActiveModel::Serializer::Lint
     def test_read_attribute_for_serialization
       assert_respond_to resource, :read_attribute_for_serialization, 'The resource should respond to read_attribute_for_serialization'
       actual_arity = resource.method(:read_attribute_for_serialization).arity
-      if defined?(::Rubinius)
-        #  1 for def read_attribute_for_serialization(name); end
-        # -2 for alias :read_attribute_for_serialization :send for rbx because :shrug:
-        assert_includes [1, -2], actual_arity, "expected #{actual_arity.inspect} to be 1 or -2"
-      else
-        # using absolute value since arity is:
-        #  1 for def read_attribute_for_serialization(name); end
-        # -1 for alias :read_attribute_for_serialization :send
-        assert_includes [1, -1], actual_arity, "expected #{actual_arity.inspect} to be 1 or -1"
-      end
+      # using absolute value since arity is:
+      #  1 for def read_attribute_for_serialization(name); end
+      # -1 for alias :read_attribute_for_serialization :send
+      assert_equal 1, actual_arity.abs, "expected #{actual_arity.inspect}.abs to be 1 or -1"
     end
 
     # Passes if the object responds to <tt>as_json</tt> and if it takes
@@ -76,19 +70,15 @@ module ActiveModel::Serializer::Lint
       resource.to_json(nil)
     end
 
-    # Passes if the object responds to <tt>cache_key</tt> and if it takes no
-    # arguments (Rails 4.0) or a splat (Rails 4.1+).
+    # Passes if the object responds to <tt>cache_key</tt>
     # Fails otherwise.
     #
-    # <tt>cache_key</tt> returns a (self-expiring) unique key for the object, and
-    # is part of the (self-expiring) cache_key, which is used by the adapter.
-    # It is not required unless caching is enabled.
+    # <tt>cache_key</tt> returns a (self-expiring) unique key for the object,
+    # and is part of the (self-expiring) cache_key, which is used by the
+    # adapter. It is not required unless caching is enabled.
     def test_cache_key
       assert_respond_to resource, :cache_key
       actual_arity = resource.method(:cache_key).arity
-      # using absolute value since arity is:
-      #   0 for Rails 4.1+, *timestamp_names
-      #  -1 for Rails 4.0, no arguments
       assert_includes [-1, 0], actual_arity, "expected #{actual_arity.inspect} to be 0 or -1"
     end
 

data/lib/active_model/serializer/version.rb

@@ -1,5 +1,5 @@
 module ActiveModel
   class Serializer
-    VERSION = '0.10.0.rc5'.freeze
+    VERSION = '0.10.0'.freeze
   end
 end

data/lib/active_model_serializers.rb

@@ -6,8 +6,6 @@ require 'active_support/json'
 module ActiveModelSerializers
   extend ActiveSupport::Autoload
   autoload :Model
-  autoload :CachedSerializer
-  autoload :FragmentCache
   autoload :Callbacks
   autoload :Deserialization
   autoload :SerializableResource

data/lib/active_model_serializers/adapter/attributes.rb

@@ -8,7 +8,7 @@ module ActiveModelSerializers
       end
 
       def serializable_hash(options = nil)
-        options ||= {}
+        options = serialization_options(options)
 
         if serializer.respond_to?(:each)
           serializable_hash_for_collection(options)
@@ -25,33 +25,6 @@ module ActiveModelSerializers
         serializer.map { |s| Attributes.new(s, instance_options).serializable_hash(options) }
       end
 
-      # Read cache from cache_store
-      # @return [Hash]
-      def cache_read_multi
-        return {} if ActiveModelSerializers.config.cache_store.blank?
-
-        keys = CachedSerializer.object_cache_keys(serializer, self, @include_tree)
-
-        return {} if keys.blank?
-
-        ActiveModelSerializers.config.cache_store.read_multi(*keys)
-      end
-
-      # Set @cached_attributes
-      def cache_attributes
-        return if @cached_attributes.present?
-
-        @cached_attributes = cache_read_multi
-      end
-
-      # Get attributes from @cached_attributes
-      # @return [Hash] cached attributes
-      def cached_attributes(cached_serializer)
-        return yield unless cached_serializer.cached?
-
-        @cached_attributes.fetch(cached_serializer.cache_key(self)) { yield }
-      end
-
       def serializable_hash_for_single_resource(options)
         resource = resource_object_for(options)
         relationships = resource_relationships(options)
@@ -61,7 +34,7 @@ module ActiveModelSerializers
       def resource_relationships(options)
         relationships = {}
         serializer.associations(@include_tree).each do |association|
-          relationships[association.key] = relationship_value_for(association, options)
+          relationships[association.key] ||= relationship_value_for(association, options)
         end
 
         relationships
@@ -72,21 +45,30 @@ module ActiveModelSerializers
         return unless association.serializer && association.serializer.object
 
         opts = instance_options.merge(include: @include_tree[association.key])
-        Attributes.new(association.serializer, opts).serializable_hash(options)
+        relationship_value = Attributes.new(association.serializer, opts).serializable_hash(options)
+
+        if association.options[:polymorphic] && relationship_value
+          polymorphic_type = association.serializer.object.class.name.underscore
+          relationship_value = { type: polymorphic_type, polymorphic_type.to_sym => relationship_value }
+        end
+
+        relationship_value
       end
 
-      # no-op: Attributes adapter does not include meta data, because it does not support root.
-      def include_meta(json)
-        json
+      # Set @cached_attributes
+      def cache_attributes
+        return if @cached_attributes.present?
+
+        @cached_attributes = ActiveModel::Serializer.cache_read_multi(serializer, self, @include_tree)
       end
 
       def resource_object_for(options)
-        cached_serializer = CachedSerializer.new(serializer)
-
-        cached_attributes(cached_serializer) do
-          cached_serializer.cache_check(self) do
-            serializer.attributes(options[:fields])
+        if serializer.class.cache_enabled?
+          @cached_attributes.fetch(serializer.cache_key(self)) do
+            serializer.cached_fields(options[:fields], self)
           end
+        else
+          serializer.cached_fields(options[:fields], self)
         end
       end
     end

data/lib/active_model_serializers/adapter/base.rb

@@ -19,14 +19,14 @@ module ActiveModelSerializers
         @cached_name ||= self.class.name.demodulize.underscore
       end
 
+      # Subclasses that implement this method must first call
+      #   options = serialization_options(options)
       def serializable_hash(_options = nil)
         fail NotImplementedError, 'This is an abstract method. Should be implemented at the concrete adapter.'
       end
 
       def as_json(options = nil)
-        hash = serializable_hash(options)
-        include_meta(hash)
-        hash
+        serializable_hash(options)
       end
 
       def fragment_cache(cached_hash, non_cached_hash)
@@ -34,30 +34,23 @@ module ActiveModelSerializers
       end
 
       def cache_check(serializer)
-        CachedSerializer.new(serializer).cache_check(self) do
+        serializer.cache_check(self) do
           yield
         end
       end
 
       private
 
-      def meta
-        instance_options.fetch(:meta, nil)
-      end
-
-      def meta_key
-        instance_options.fetch(:meta_key, 'meta'.freeze)
+      # see https://github.com/rails-api/active_model_serializers/pull/965
+      # When <tt>options</tt> is +nil+, sets it to +{}+
+      def serialization_options(options)
+        options ||= {} # rubocop:disable Lint/UselessAssignment
       end
 
       def root
         serializer.json_key.to_sym if serializer.json_key
       end
 
-      def include_meta(json)
-        json[meta_key] = meta unless meta.blank?
-        json
-      end
-
       class << self
         # Sets the default transform for the adapter.
         #

data/lib/active_model_serializers/adapter/json.rb

@@ -2,9 +2,19 @@ module ActiveModelSerializers
   module Adapter
     class Json < Base
       def serializable_hash(options = nil)
-        options ||= {}
+        options = serialization_options(options)
         serialized_hash = { root => Attributes.new(serializer, instance_options).serializable_hash(options) }
-        self.class.transform_key_casing!(serialized_hash, options)
+        serialized_hash[meta_key] = meta unless meta.blank?
+
+        self.class.transform_key_casing!(serialized_hash, instance_options)
+      end
+
+      def meta
+        instance_options.fetch(:meta, nil)
+      end
+
+      def meta_key
+        instance_options.fetch(:meta_key, 'meta'.freeze)
       end
     end
   end

data/lib/active_model_serializers/adapter/json_api.rb

@@ -43,14 +43,13 @@ module ActiveModelSerializers
 
       # {http://jsonapi.org/format/#crud Requests are transactional, i.e. success or failure}
       # {http://jsonapi.org/format/#document-top-level data and errors MUST NOT coexist in the same document.}
-      def serializable_hash(options = nil)
-        options ||= {}
+      def serializable_hash(*)
         document = if serializer.success?
-                     success_document(options)
+                     success_document
                    else
-                     failure_document(options)
+                     failure_document
                    end
-        self.class.transform_key_casing!(document, options)
+        self.class.transform_key_casing!(document, instance_options)
       end
 
       # {http://jsonapi.org/format/#document-top-level Primary data}
@@ -68,10 +67,11 @@ module ActiveModelSerializers
       #    links: toplevel_links,
       #    jsonapi: toplevel_jsonapi
       #  }.reject! {|_,v| v.nil? }
-      def success_document(options)
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def success_document
         is_collection = serializer.respond_to?(:each)
         serializers = is_collection ? serializer : [serializer]
-        primary_data, included = resource_objects_for(serializers, options)
+        primary_data, included = resource_objects_for(serializers)
 
         hash = {}
         # toplevel_data
@@ -128,11 +128,14 @@ module ActiveModelSerializers
 
         if is_collection && serializer.paginated?
           hash[:links] ||= {}
-          hash[:links].update(pagination_links_for(serializer, options))
+          hash[:links].update(pagination_links_for(serializer))
         end
 
+        hash[:meta] = instance_options[:meta] unless instance_options[:meta].blank?
+
         hash
       end
+      # rubocop:enable Metrics/CyclomaticComplexity
 
       # {http://jsonapi.org/format/#errors JSON API Errors}
       # TODO: look into caching
@@ -148,7 +151,7 @@ module ActiveModelSerializers
       #   }.reject! {|_,v| v.nil? }
       # prs:
       #  https://github.com/rails-api/active_model_serializers/pull/1004
-      def failure_document(options)
+      def failure_document
         hash = {}
         # PR Please :)
         # Jsonapi.add!(hash)
@@ -163,10 +166,10 @@ module ActiveModelSerializers
         #   ]
         if serializer.respond_to?(:each)
           hash[:errors] = serializer.flat_map do |error_serializer|
-            Error.resource_errors(error_serializer, options)
+            Error.resource_errors(error_serializer, instance_options)
           end
         else
-          hash[:errors] = Error.resource_errors(serializer, options)
+          hash[:errors] = Error.resource_errors(serializer, instance_options)
         end
         hash
       end
@@ -224,21 +227,21 @@ module ActiveModelSerializers
       #     [x] url helpers https://github.com/rails-api/active_model_serializers/issues/1269
       #   meta
       #     [x] https://github.com/rails-api/active_model_serializers/pull/1340
-      def resource_objects_for(serializers, options)
+      def resource_objects_for(serializers)
         @primary = []
         @included = []
         @resource_identifiers = Set.new
-        serializers.each { |serializer| process_resource(serializer, true, options) }
-        serializers.each { |serializer| process_relationships(serializer, @include_tree, options) }
+        serializers.each { |serializer| process_resource(serializer, true) }
+        serializers.each { |serializer| process_relationships(serializer, @include_tree) }
 
         [@primary, @included]
       end
 
-      def process_resource(serializer, primary, options)
-        resource_identifier = ResourceIdentifier.new(serializer, options).as_json
+      def process_resource(serializer, primary)
+        resource_identifier = ResourceIdentifier.new(serializer, instance_options).as_json
         return false unless @resource_identifiers.add?(resource_identifier)
 
-        resource_object = resource_object_for(serializer, options)
+        resource_object = resource_object_for(serializer)
         if primary
           @primary << resource_object
         else
@@ -248,21 +251,21 @@ module ActiveModelSerializers
         true
       end
 
-      def process_relationships(serializer, include_tree, options)
+      def process_relationships(serializer, include_tree)
         serializer.associations(include_tree).each do |association|
-          process_relationship(association.serializer, include_tree[association.key], options)
+          process_relationship(association.serializer, include_tree[association.key])
         end
       end
 
-      def process_relationship(serializer, include_tree, options)
+      def process_relationship(serializer, include_tree)
         if serializer.respond_to?(:each)
-          serializer.each { |s| process_relationship(s, include_tree, options) }
+          serializer.each { |s| process_relationship(s, include_tree) }
           return
         end
         return unless serializer && serializer.object
-        return unless process_resource(serializer, false, options)
+        return unless process_resource(serializer, false)
 
-        process_relationships(serializer, include_tree, options)
+        process_relationships(serializer, include_tree)
       end
 
       # {http://jsonapi.org/format/#document-resource-object-attributes Document Resource Object Attributes}
@@ -286,9 +289,9 @@ module ActiveModelSerializers
       end
 
       # {http://jsonapi.org/format/#document-resource-objects Document Resource Objects}
-      def resource_object_for(serializer, options)
+      def resource_object_for(serializer)
         resource_object = cache_check(serializer) do
-          resource_object = ResourceIdentifier.new(serializer, options).as_json
+          resource_object = ResourceIdentifier.new(serializer, instance_options).as_json
 
           requested_fields = fieldset && fieldset.fields_for(resource_object[:type])
           attributes = attributes_for(serializer, requested_fields)
@@ -297,7 +300,7 @@ module ActiveModelSerializers
         end
 
         requested_associations = fieldset.fields_for(resource_object[:type]) || '*'
-        relationships = relationships_for(serializer, requested_associations, options)
+        relationships = relationships_for(serializer, requested_associations)
         resource_object[:relationships] = relationships if relationships.any?
 
         links = links_for(serializer)
@@ -425,13 +428,13 @@ module ActiveModelSerializers
       #     id: 'required-id',
       #     meta: meta
       #   }.reject! {|_,v| v.nil? }
-      def relationships_for(serializer, requested_associations, options)
+      def relationships_for(serializer, requested_associations)
         include_tree = ActiveModel::Serializer::IncludeTree.from_include_args(requested_associations)
         serializer.associations(include_tree).each_with_object({}) do |association, hash|
           hash[association.key] = Relationship.new(
             serializer,
             association.serializer,
-            options,
+            instance_options,
             options: association.options,
             links: association.links,
             meta: association.meta
@@ -499,8 +502,8 @@ module ActiveModelSerializers
       #   end
       # prs:
       #   https://github.com/rails-api/active_model_serializers/pull/1041
-      def pagination_links_for(serializer, options)
-        PaginationLinks.new(serializer.object, options[:serialization_context]).serializable_hash(options)
+      def pagination_links_for(serializer)
+        PaginationLinks.new(serializer.object, instance_options).as_json
       end
 
       # {http://jsonapi.org/format/#document-meta Docment Meta}