active_model_serializers 0.10.2 → 0.10.3

data/docs/integrations/ember-and-json-api.md

@@ -38,19 +38,51 @@ You will also want to set the `key_transform` to `:unaltered` since you will adj
 ActiveModelSerializers.config.key_transform = :unaltered
 ```
 
-Lastly, in order to properly handle JSON API responses, we need to register a JSON API renderer, like so:
+In order to properly handle JSON API responses, we need to register a JSON API renderer, like so:
 
 ```ruby
 # config/initializers/active_model_serializers.rb
-require 'active_model_serializers/register_jsonapi_renderer'
+ActiveSupport.on_load(:action_controller) do
+  require 'active_model_serializers/register_jsonapi_renderer'
+end
 ```
+Rails also requires your controller to tell it that you accept and generate JSONAPI data.  To do that, you use `respond_to` in your controller handlers to tell rails you are consuming and returning jsonapi format data. Without this, Rails will refuse to parse the request body into params.  You can add `ActionController::MimeResponds` to your application controller to enable this:
+
+```ruby
+class ApplicationController < ActionController::API
+  include ActionController::MimeResponds
+end
+```
+Then, in your controller you can tell rails you're accepting and rendering the jsonapi format:
+```ruby
+ # POST /post
+  def create
+    @post = Post.new(post_params)
+    respond_to do |format|
+      if @post.save
+        format.jsonapi { render jsonapi: @post, status: :created, location: @post }
+      else
+        format.jsonapi { render jsonapi: @post.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+  
+    # Only allow a trusted parameter "white list" through.
+    def post_params
+      ActiveModelSerializers::Deserialization.jsonapi_parse!(params, only: [:title, :body] )
+    end
+end
+```
+
 
 ### Adapter Changes
 
 ```javascript
 // app/adapters/application.js
+import Ember from 'ember';
 import DS from 'ember-data';
 import ENV from "../config/environment";
+const { underscore, pluralize } = Ember.String;
 
 export default  DS.JSONAPIAdapter.extend({
   namespace: 'api',
@@ -61,22 +93,10 @@ export default  DS.JSONAPIAdapter.extend({
 
   // allows the multiword paths in urls to be underscored
   pathForType: function(type) {
-    let underscored = Ember.String.underscore(type);
-    return Ember.String.pluralize(underscored);
+    let underscored = underscore(type);
+    return pluralize(underscored);
   },
 
-  // allows queries to be sent along with a findRecord
-  // hopefully Ember / EmberData will soon have this built in
-  // ember-data issue tracked here:
-  // https://github.com/emberjs/data/issues/3596
-  urlForFindRecord(id, modelName, snapshot) {
-    let url = this._super(...arguments);
-    let query = Ember.get(snapshot, 'adapterOptions.query');
-    if(query) {
-      url += '?' + Ember.$.param(query);
-    }
-    return url;
-  }
 });
 ```
 
@@ -100,22 +120,19 @@ export default DS.JSONAPISerializer.extend({
 
 ```
 
-## Including Nested Resources
 
-Previously, `store.find` and `store.findRecord` did not allow specification of any query params.
-The ActiveModelSerializers default for the `include` parameter is to be `nil` meaning that if any associations are defined in your serializer, only the `id` and `type` will be in the `relationships` structure of the JSON API response.
-For more on `include` usage, see: [The JSON API include examples](./../general/adapters.md#JSON-API)
+## Including Nested Resources
 
-With the above modifications, you can execute code as below in order to include nested resources while doing a find query.
+Ember Data can request related records by using `include`.  Below are some examples of how to make Ember Data request the inclusion of related records. For more on `include` usage, see: [The JSON API include examples](./../general/adapters.md#JSON-API)
 
 ```javascript
-store.findRecord('post', postId, { adapterOptions: { query: { include: 'comments' } } });
+store.findRecord('post', postId, { include: 'comments' } );
 ```
-will generate the path `/posts/{postId}?include='comments'`
+which will generate the path /posts/{postId}?include='comments'
 
 So then in your controller, you'll want to be sure to have something like:
 ```ruby
-render json: @post, include: params[:include]
+render jsonapi: @post, include: params[:include]
 ```
 
 If you want to use `include` on a collection, you'd write something like this:

data/lib/action_controller/serialization.rb

@@ -16,6 +16,12 @@ module ActionController
     included do
       class_attribute :_serialization_scope
       self._serialization_scope = :current_user
+
+      attr_writer :namespace_for_serializer
+    end
+
+    def namespace_for_serializer
+      @namespace_for_serializer ||= self.class.parent unless self.class.parent == Object
     end
 
     def serialization_scope
@@ -30,6 +36,9 @@ module ActionController
           "Please pass 'adapter: false' or see ActiveSupport::SerializableResource.new"
         options[:adapter] = false
       end
+
+      options.fetch(:namespace) { options[:namespace] = namespace_for_serializer }
+
       serializable_resource = ActiveModelSerializers::SerializableResource.new(resource, options)
       serializable_resource.serialization_scope ||= options.fetch(:scope) { serialization_scope }
       serializable_resource.serialization_scope_name = options.fetch(:scope_name) { _serialization_scope }

data/lib/active_model/serializer.rb

@@ -4,15 +4,15 @@ require 'active_model/serializer/collection_serializer'
 require 'active_model/serializer/array_serializer'
 require 'active_model/serializer/error_serializer'
 require 'active_model/serializer/errors_serializer'
-require 'active_model/serializer/associations'
-require 'active_model/serializer/attributes'
-require 'active_model/serializer/caching'
-require 'active_model/serializer/configuration'
+require 'active_model/serializer/concerns/associations'
+require 'active_model/serializer/concerns/attributes'
+require 'active_model/serializer/concerns/caching'
+require 'active_model/serializer/concerns/configuration'
+require 'active_model/serializer/concerns/links'
+require 'active_model/serializer/concerns/meta'
+require 'active_model/serializer/concerns/type'
 require 'active_model/serializer/fieldset'
 require 'active_model/serializer/lint'
-require 'active_model/serializer/links'
-require 'active_model/serializer/meta'
-require 'active_model/serializer/type'
 
 # ActiveModel::Serializer is an abstract class that is
 # reified when subclassed to decorate a resource.
@@ -44,7 +44,7 @@ module ActiveModel
       elsif resource.respond_to?(:to_ary)
         config.collection_serializer
       else
-        options.fetch(:serializer) { get_serializer_for(resource.class) }
+        options.fetch(:serializer) { get_serializer_for(resource.class, options[:namespace]) }
       end
     end
 
@@ -59,17 +59,11 @@ module ActiveModel
     end
 
     # @api private
-    def self.serializer_lookup_chain_for(klass)
-      chain = []
-
-      resource_class_name = klass.name.demodulize
-      resource_namespace = klass.name.deconstantize
-      serializer_class_name = "#{resource_class_name}Serializer"
-
-      chain.push("#{name}::#{serializer_class_name}") if self != ActiveModel::Serializer
-      chain.push("#{resource_namespace}::#{serializer_class_name}")
-
-      chain
+    def self.serializer_lookup_chain_for(klass, namespace = nil)
+      lookups = ActiveModelSerializers.config.serializer_lookup_chain
+      Array[*lookups].flat_map do |lookup|
+        lookup.call(klass, self, namespace)
+      end.compact
     end
 
     # Used to cache serializer name => serializer class
@@ -84,11 +78,14 @@ module ActiveModel
     #   1. class name appended with "Serializer"
     #   2. try again with superclass, if present
     #   3. nil
-    def self.get_serializer_for(klass)
+    def self.get_serializer_for(klass, namespace = nil)
       return nil unless config.serializer_lookup_enabled
-      serializers_cache.fetch_or_store(klass) do
+
+      cache_key = ActiveSupport::Cache.expand_cache_key(klass, namespace)
+      serializers_cache.fetch_or_store(cache_key) do
         # NOTE(beauby): When we drop 1.9.3 support we can lazify the map for perfs.
-        serializer_class = serializer_lookup_chain_for(klass).map(&:safe_constantize).find { |x| x && x < ActiveModel::Serializer }
+        lookup_chain = serializer_lookup_chain_for(klass, namespace)
+        serializer_class = lookup_chain.map(&:safe_constantize).find { |x| x && x < ActiveModel::Serializer }
 
         if serializer_class
           serializer_class

data/lib/active_model/serializer/association.rb

@@ -1,19 +1,34 @@
 module ActiveModel
   class Serializer
-    # This class hold all information about serializer's association.
+    # This class holds all information about serializer's association.
     #
     # @attr [Symbol] name
-    # @attr [ActiveModel::Serializer] serializer
     # @attr [Hash{Symbol => Object}] options
+    # @attr [block]
     #
     # @example
-    #  Association.new(:comments, CommentSummarySerializer)
+    #  Association.new(:comments, { serializer: CommentSummarySerializer })
     #
-    Association = Struct.new(:name, :serializer, :options, :links, :meta) do
+    class Association < Field
       # @return [Symbol]
       def key
         options.fetch(:key, name)
       end
+
+      # @return [ActiveModel::Serializer, nil]
+      def serializer
+        options[:serializer]
+      end
+
+      # @return [Hash]
+      def links
+        options.fetch(:links) || {}
+      end
+
+      # @return [Hash, nil]
+      def meta
+        options[:meta]
+      end
     end
   end
 end

data/lib/active_model/serializer/collection_serializer.rb

@@ -1,7 +1,6 @@
 module ActiveModel
   class Serializer
     class CollectionSerializer
-      NoSerializerError = Class.new(StandardError)
       include Enumerable
       delegate :each, to: :@serializers
 
@@ -52,7 +51,8 @@ module ActiveModel
       # rubocop:enable Metrics/CyclomaticComplexity
 
       def paginated?
-        object.respond_to?(:current_page) &&
+        ActiveModelSerializers.config.jsonapi_pagination_links_enabled &&
+          object.respond_to?(:current_page) &&
           object.respond_to?(:total_pages) &&
           object.respond_to?(:size)
       end
@@ -71,10 +71,13 @@ module ActiveModel
       end
 
       def serializer_from_resource(resource, serializer_context_class, options)
-        serializer_class = options.fetch(:serializer) { serializer_context_class.serializer_for(resource) }
+        serializer_class = options.fetch(:serializer) do
+          serializer_context_class.serializer_for(resource, namespace: options[:namespace])
+        end
 
-        if serializer_class.nil? # rubocop:disable Style/GuardClause
-          fail NoSerializerError, "No serializer found for resource: #{resource.inspect}"
+        if serializer_class.nil?
+          ActiveModelSerializers.logger.debug "No serializer found for resource: #{resource.inspect}"
+          throw :no_serializer
         else
           serializer_class.new(resource, options.except(:serializer))
         end

data/lib/active_model/serializer/{associations.rb → concerns/associations.rb}

@@ -13,7 +13,7 @@ module ActiveModel
       included do
         with_options instance_writer: false, instance_reader: true do |serializer|
           serializer.class_attribute :_reflections
-          self._reflections ||= []
+          self._reflections ||= {}
         end
 
         extend ActiveSupport::Autoload
@@ -74,7 +74,8 @@ module ActiveModel
         # @api private
         #
         def associate(reflection)
-          self._reflections << reflection
+          key = reflection.options[:key] || reflection.name
+          self._reflections[key] = reflection
         end
       end
 
@@ -82,15 +83,17 @@ module ActiveModel
       #   +default_include_directive+ config value when not provided)
       # @return [Enumerator<Association>]
       #
-      def associations(include_directive = ActiveModelSerializers.default_include_directive)
+      def associations(include_directive = ActiveModelSerializers.default_include_directive, include_slice = nil)
+        include_slice ||= include_directive
         return unless object
 
         Enumerator.new do |y|
-          self.class._reflections.each do |reflection|
+          self.class._reflections.values.each do |reflection|
             next if reflection.excluded?(self)
             key = reflection.options.fetch(:key, reflection.name)
             next unless include_directive.key?(key)
-            y.yield reflection.build_association(self, instance_options)
+
+            y.yield reflection.build_association(self, instance_options, include_slice)
           end
         end
       end

data/lib/active_model/serializer/{caching.rb → concerns/caching.rb}

@@ -263,7 +263,11 @@ module ActiveModel
         parts << object_cache_key
         parts << adapter_instance.cache_key
         parts << serializer_class._cache_digest unless serializer_class._skip_digest?
-        @cache_key = parts.join('/')
+        @cache_key = expand_cache_key(parts)
+      end
+
+      def expand_cache_key(parts)
+        ActiveSupport::Cache.expand_cache_key(parts)
       end
 
       # Use object's cache_key if available, else derive a key from the object

data/lib/active_model/serializer/{configuration.rb → concerns/configuration.rb}

@@ -21,13 +21,36 @@ module ActiveModel
 
         config.default_includes = '*'
         config.adapter = :attributes
+        config.key_transform = nil
+        config.jsonapi_pagination_links_enabled = true
         config.jsonapi_resource_type = :plural
+        config.jsonapi_namespace_separator = '-'.freeze
         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.include_data_default = true
+
+        # For configuring how serializers are found.
+        # This should be an array of procs.
+        #
+        # The priority of the output is that the first item
+        # in the evaluated result array will take precedence
+        # over other possible serializer paths.
+        #
+        # i.e.: First match wins.
+        #
+        # @example output
+        # => [
+        #   "CustomNamespace::ResourceSerializer",
+        #   "ParentSerializer::ResourceSerializer",
+        #   "ResourceNamespace::ResourceSerializer" ,
+        #   "ResourceSerializer"]
+        #
+        # If CustomNamespace::ResourceSerializer exists, it will be used
+        # for serialization
+        config.serializer_lookup_chain = ActiveModelSerializers::LookupChain::DEFAULT.dup
 
         config.schema_path = 'test/support/schemas'
       end

data/lib/active_model/serializer/reflection.rb

@@ -37,7 +37,7 @@ module ActiveModel
       def initialize(*)
         super
         @_links = {}
-        @_include_data = true
+        @_include_data = Serializer.config.include_data_default
         @_meta = nil
       end
 
@@ -69,17 +69,15 @@ module ActiveModel
       #       Blog.find(object.blog_id)
       #     end
       #   end
-      def value(serializer)
+      def value(serializer, include_slice)
         @object = serializer.object
         @scope = serializer.scope
 
-        if block
-          block_value = instance_exec(serializer, &block)
-          if block_value != :nil
-            block_value
-          elsif @_include_data
-            serializer.read_attribute_for_serialization(name)
-          end
+        block_value = instance_exec(serializer, &block) if block
+        return unless include_data?(include_slice)
+
+        if block && block_value != :nil
+          block_value
         else
           serializer.read_attribute_for_serialization(name)
         end
@@ -88,7 +86,7 @@ module ActiveModel
       # Build association. This method is used internally to
       # build serializer's association by its reflection.
       #
-      # @param [Serializer] subject is a parent serializer for given association
+      # @param [Serializer] parent_serializer for given association
       # @param [Hash{Symbol => Object}] parent_serializer_options
       #
       # @example
@@ -106,26 +104,36 @@ module ActiveModel
       #
       # @api private
       #
-      def build_association(subject, parent_serializer_options)
-        association_value = value(subject)
+      def build_association(parent_serializer, parent_serializer_options, include_slice = {})
         reflection_options = options.dup
-        serializer_class = subject.class.serializer_for(association_value, reflection_options)
-        reflection_options[:include_data] = @_include_data
+
+        # Pass the parent's namespace onto the child serializer
+        reflection_options[:namespace] ||= parent_serializer_options[:namespace]
+
+        association_value = value(parent_serializer, include_slice)
+        serializer_class = parent_serializer.class.serializer_for(association_value, reflection_options)
+        reflection_options[:include_data] = include_data?(include_slice)
+        reflection_options[:links] = @_links
+        reflection_options[:meta] = @_meta
 
         if serializer_class
-          begin
-            serializer = serializer_class.new(
+          serializer = catch(:no_serializer) do
+            serializer_class.new(
               association_value,
-              serializer_options(subject, parent_serializer_options, reflection_options)
+              serializer_options(parent_serializer, parent_serializer_options, reflection_options)
             )
-          rescue ActiveModel::Serializer::CollectionSerializer::NoSerializerError
+          end
+          if serializer.nil?
             reflection_options[:virtual_value] = association_value.try(:as_json) || association_value
+          else
+            reflection_options[:serializer] = serializer
           end
         elsif !association_value.nil? && !association_value.instance_of?(Object)
           reflection_options[:virtual_value] = association_value
         end
 
-        Association.new(name, serializer, reflection_options, @_links, @_meta)
+        block = nil
+        Association.new(name, reflection_options, block)
       end
 
       protected
@@ -134,12 +142,20 @@ module ActiveModel
 
       private
 
-      def serializer_options(subject, parent_serializer_options, reflection_options)
+      def include_data?(include_slice)
+        if @_include_data == :if_sideloaded
+          include_slice.key?(name)
+        else
+          @_include_data
+        end
+      end
+
+      def serializer_options(parent_serializer, parent_serializer_options, reflection_options)
         serializer = reflection_options.fetch(:serializer, nil)
 
         serializer_options = parent_serializer_options.except(:serializer)
         serializer_options[:serializer] = serializer if serializer
-        serializer_options[:serializer_context_class] = subject.class
+        serializer_options[:serializer_context_class] = parent_serializer.class
         serializer_options
       end
     end