active_model_serializers 0.10.0.rc4 → 0.10.0.rc5

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

@@ -1,9 +1,13 @@
 module ActiveModel
   class Serializer
     module Adapter
-      class Null < Base
-        def serializable_hash(options = nil)
-          {}
+      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

data/lib/active_model/serializer/array_serializer.rb

@@ -1,9 +1,9 @@
 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
+    class << self
+      extend ActiveModelSerializers::Deprecate
+      deprecate :new, 'ActiveModel::Serializer::CollectionSerializer.'
     end
   end
 end

data/lib/active_model/serializer/association.rb

@@ -2,16 +2,15 @@ module ActiveModel
   class Serializer
     # This class hold all information about serializer's association.
     #
-    # @param [Symbol] name
-    # @param [ActiveModel::Serializer] serializer
-    # @param [Hash{Symbol => Object}] options
+    # @attr [Symbol] name
+    # @attr [ActiveModel::Serializer] serializer
+    # @attr [Hash{Symbol => Object}] options
     #
     # @example
     #  Association.new(:comments, CommentSummarySerializer)
     #
-    Association = Struct.new(:name, :serializer, :options) do
+    Association = Struct.new(:name, :serializer, :options, :links, :meta) do
       # @return [Symbol]
-      #
       def key
         options.fetch(:key, name)
       end

data/lib/active_model/serializer/attributes.rb

@@ -68,7 +68,7 @@ module ActiveModel
         # @api private
         # maps attribute value to explict key name
         # @see Serializer::attribute
-        # @see Adapter::FragmentCache#fragment_serializer
+        # @see FragmentCache#fragment_serializer
         def _attributes_keys
           _attributes_data
             .each_with_object({}) do |(key, attr), hash|

data/lib/active_model/serializer/caching.rb

@@ -5,9 +5,9 @@ module ActiveModel
 
       included do
         with_options instance_writer: false, instance_reader: false do |serializer|
-          serializer.class_attribute :_cache         # @api private : the cache object
+          serializer.class_attribute :_cache         # @api private : the cache store
           serializer.class_attribute :_fragmented    # @api private : @see ::fragmented
-          serializer.class_attribute :_cache_key     # @api private : when present, is first item in cache_key
+          serializer.class_attribute :_cache_key     # @api private : when present, is first item in cache_key.  Ignored if the serializable object defines #cache_key.
           serializer.class_attribute :_cache_only    # @api private : when fragment caching, whitelists cached_attributes. Cannot combine with except
           serializer.class_attribute :_cache_except  # @api private : when fragment caching, blacklists cached_attributes. Cannot combine with only
           serializer.class_attribute :_cache_options # @api private : used by CachedSerializer, passed to _cache.fetch
@@ -58,6 +58,10 @@ module ActiveModel
           ''.freeze
         end
 
+        def _skip_digest?
+          _cache_options && _cache_options[:skip_digest]
+        end
+
         # @api private
         # Used by FragmentCache on the CachedSerializer
         #  to call attribute methods on the fragmented cached serializer.
@@ -70,7 +74,8 @@ module ActiveModel
         # Sets +::_cache+ object to <tt>ActionController::Base.cache_store</tt>
         #   when Rails.configuration.action_controller.perform_caching
         #
-        # @params options [Hash] with valid keys:
+        # @param options [Hash] with valid keys:
+        #   cache_store    : @see ::_cache
         #   key            : @see ::_cache_key
         #   only           : @see ::_cache_only
         #   except         : @see ::_cache_except
@@ -88,11 +93,57 @@ module ActiveModel
         # @todo require less code comments. See
         # https://github.com/rails-api/active_model_serializers/pull/1249#issuecomment-146567837
         def cache(options = {})
-          self._cache = ActiveModelSerializers.config.cache_store if ActiveModelSerializers.config.perform_caching
+          self._cache =
+            options.delete(:cache_store) ||
+            ActiveModelSerializers.config.cache_store ||
+            ActiveSupport::Cache.lookup_store(:null_store)
           self._cache_key = options.delete(:key)
           self._cache_only = options.delete(:only)
           self._cache_except = options.delete(:except)
-          self._cache_options = (options.empty?) ? nil : options
+          self._cache_options = options.empty? ? nil : options
+        end
+
+        # Value is from ActiveModelSerializers.config.perform_caching. Is used to
+        # globally enable or disable all serializer caching, just like
+        # Rails.configuration.action_controller.perform_caching, which is its
+        # default value in a Rails application.
+        # @return [true, false]
+        # Memoizes value of config first time it is called with a non-nil value.
+        # rubocop:disable Style/ClassVars
+        def perform_caching
+          return @@perform_caching if defined?(@@perform_caching) && !@@perform_caching.nil?
+          @@perform_caching = ActiveModelSerializers.config.perform_caching
+        end
+        alias perform_caching? perform_caching
+        # rubocop:enable Style/ClassVars
+
+        # The canonical method for getting the cache store for the serializer.
+        #
+        # @return [nil] when _cache is not set (i.e. when `cache` has not been called)
+        # @return [._cache] when _cache is not the NullStore
+        # @return [ActiveModelSerializers.config.cache_store] when _cache is the NullStore.
+        #   This is so we can use `cache` being called to mean the serializer should be cached
+        #   even if ActiveModelSerializers.config.cache_store has not yet been set.
+        #   That means that when _cache is the NullStore and ActiveModelSerializers.config.cache_store
+        #   is configured, `cache_store` becomes `ActiveModelSerializers.config.cache_store`.
+        # @return [nil] when _cache is the NullStore and ActiveModelSerializers.config.cache_store is nil.
+        def cache_store
+          return nil if _cache.nil?
+          return _cache if _cache.class != ActiveSupport::Cache::NullStore
+          if ActiveModelSerializers.config.cache_store
+            self._cache = ActiveModelSerializers.config.cache_store
+          else
+            nil
+          end
+        end
+
+        def cache_enabled?
+          perform_caching? && cache_store && !_cache_only && !_cache_except
+        end
+
+        def fragment_cache_enabled?
+          perform_caching? && cache_store &&
+            (_cache_only && !_cache_except || !_cache_only && _cache_except)
         end
       end
     end

data/lib/active_model/serializer/collection_serializer.rb

@@ -8,13 +8,14 @@ module ActiveModel
       attr_reader :object, :root
 
       def initialize(resources, options = {})
-        @root = options[:root]
-        @object = resources
+        @object                  = resources
+        @options                 = options
+        @root                    = options[:root]
+        serializer_context_class = options.fetch(:serializer_context_class, ActiveModel::Serializer)
         @serializers = resources.map do |resource|
-          serializer_context_class = options.fetch(:serializer_context_class, ActiveModel::Serializer)
           serializer_class = options.fetch(:serializer) { serializer_context_class.serializer_for(resource) }
 
-          if serializer_class.nil?
+          if serializer_class.nil? # rubocop:disable Style/GuardClause
             fail NoSerializerError, "No serializer found for resource: #{resource.inspect}"
           else
             serializer_class.new(resource, options.except(:serializer))
@@ -22,9 +23,32 @@ module ActiveModel
         end
       end
 
+      def success?
+        true
+      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
-        root || derived_root
+        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?
         object.respond_to?(:current_page) &&
@@ -34,14 +58,7 @@ module ActiveModel
 
       protected
 
-      attr_reader :serializers
-
-      private
-
-      def derived_root
-        key = serializers.first.try(:json_key) || object.try(:name).try(:underscore)
-        key.try(:pluralize)
-      end
+      attr_reader :serializers, :options
     end
   end
 end

data/lib/active_model/serializer/configuration.rb

@@ -21,6 +21,13 @@ module ActiveModel
 
         config.adapter = :attributes
         config.jsonapi_resource_type = :plural
+        config.jsonapi_version = '1.0'
+        config.jsonapi_toplevel_meta = {}
+        # Make JSON API top-level jsonapi member opt-in
+        # ref: http://jsonapi.org/format/#document-top-level
+        config.jsonapi_include_toplevel_object = false
+        config.key_transform = nil
+
         config.schema_path = 'test/support/schemas'
       end
     end

data/lib/active_model/serializer/error_serializer.rb

@@ -0,0 +1,10 @@
+class ActiveModel::Serializer::ErrorSerializer < ActiveModel::Serializer
+  # @return [Hash<field_name,Array<error_message>>]
+  def as_json
+    object.errors.messages
+  end
+
+  def success?
+    false
+  end
+end

data/lib/active_model/serializer/errors_serializer.rb

@@ -0,0 +1,27 @@
+require 'active_model/serializer/error_serializer'
+class ActiveModel::Serializer::ErrorsSerializer
+  include Enumerable
+  delegate :each, to: :@serializers
+  attr_reader :object, :root
+
+  def initialize(resources, options = {})
+    @root = options[:root]
+    @object = resources
+    @serializers = resources.map do |resource|
+      serializer_class = options.fetch(:serializer) { ActiveModel::Serializer::ErrorSerializer }
+      serializer_class.new(resource, options.except(:serializer))
+    end
+  end
+
+  def success?
+    false
+  end
+
+  def json_key
+    nil
+  end
+
+  protected
+
+  attr_reader :serializers
+end

data/lib/active_model/serializer/links.rb

@@ -20,9 +20,11 @@ module ActiveModel
 
         # Define a link on a serializer.
         # @example
-        #   link :self { "//example.com/posts/#{object.id}" }
+        #   link(:self) { resource_url(object) }
         # @example
-        #   link :self, "//example.com/user"
+        #   link(:self) { "http://example.com/resource/#{object.id}" }
+        # @example
+        #   link :resource, "http://example.com/resource"
         #
         def link(name, value = nil, &block)
           _links[name] = block || value

data/lib/active_model/serializer/lint.rb

@@ -129,6 +129,20 @@ module ActiveModel::Serializer::Lint
       assert_instance_of resource_class.model_name, ActiveModel::Name
     end
 
+    def test_active_model_errors
+      assert_respond_to resource, :errors
+    end
+
+    def test_active_model_errors_human_attribute_name
+      assert_respond_to resource.class, :human_attribute_name
+      assert_equal(-2, resource.class.method(:human_attribute_name).arity)
+    end
+
+    def test_active_model_errors_lookup_ancestors
+      assert_respond_to resource.class, :lookup_ancestors
+      assert_equal 0, resource.class.method(:lookup_ancestors).arity
+    end
+
     private
 
     def resource

data/lib/active_model/serializer/meta.rb

@@ -0,0 +1,29 @@
+module ActiveModel
+  class Serializer
+    module Meta
+      extend ActiveSupport::Concern
+
+      included do
+        with_options instance_writer: false, instance_reader: true do |serializer|
+          serializer.class_attribute :_meta # @api private
+        end
+
+        extend ActiveSupport::Autoload
+      end
+
+      module ClassMethods
+        # Set the JSON API meta attribute of a serializer.
+        # @example
+        #   class AdminAuthorSerializer < ActiveModel::Serializer
+        #     meta { stuff: 'value' }
+        # @example
+        #     meta do
+        #       { comment_count: object.comments.count }
+        #     end
+        def meta(value = nil, &block)
+          self._meta = block || value
+        end
+      end
+    end
+  end
+end

data/lib/active_model/serializer/null.rb

@@ -0,0 +1,17 @@
+module ActiveModel
+  class Serializer
+    class Null < Serializer
+      def attributes(*)
+        {}
+      end
+
+      def associations(*)
+        {}
+      end
+
+      def serializable_hash(*)
+        {}
+      end
+    end
+  end
+end

data/lib/active_model/serializer/reflection.rb

@@ -34,6 +34,57 @@ module ActiveModel
     # So you can inspect reflections in your Adapters.
     #
     class Reflection < Field
+      def initialize(*)
+        super
+        @_links = {}
+        @_include_data = true
+        @_meta = nil
+      end
+
+      def link(name, value = nil, &block)
+        @_links[name] = block || value
+        :nil
+      end
+
+      def meta(value = nil, &block)
+        @_meta = block || value
+        :nil
+      end
+
+      def include_data(value = true)
+        @_include_data = value
+        :nil
+      end
+
+      # @param serializer [ActiveModel::Serializer]
+      # @yield [ActiveModel::Serializer]
+      # @return [:nil, associated resource or resource collection]
+      # @example
+      #   has_one :blog do |serializer|
+      #     serializer.cached_blog
+      #   end
+      #
+      #   def cached_blog
+      #     cache_store.fetch("cached_blog:#{object.updated_at}") do
+      #       Blog.find(object.blog_id)
+      #     end
+      #   end
+      def value(serializer)
+        @object = serializer.object
+        @scope = serializer.scope
+
+        if block
+          block_value = instance_exec(serializer, &block)
+          if block_value == :nil
+            serializer.read_attribute_for_serialization(name)
+          else
+            block_value
+          end
+        else
+          serializer.read_attribute_for_serialization(name)
+        end
+      end
+
       # Build association. This method is used internally to
       # build serializer's association by its reflection.
       #
@@ -59,6 +110,7 @@ module ActiveModel
         association_value = value(subject)
         reflection_options = options.dup
         serializer_class = subject.class.serializer_for(association_value, reflection_options)
+        reflection_options[:include_data] = @_include_data
 
         if serializer_class
           begin
@@ -73,9 +125,13 @@ module ActiveModel
           reflection_options[:virtual_value] = association_value
         end
 
-        Association.new(name, serializer, reflection_options)
+        Association.new(name, serializer, reflection_options, @_links, @_meta)
       end
 
+      protected
+
+      attr_accessor :object, :scope
+
       private
 
       def serializer_options(subject, parent_serializer_options, reflection_options)

data/lib/active_model/serializer/type.rb

@@ -17,7 +17,7 @@ module ActiveModel
         #   class AdminAuthorSerializer < ActiveModel::Serializer
         #     type 'authors'
         def type(type)
-          self._type = type
+          self._type = type && type.to_s
         end
       end
     end