active_model_serializers 0.10.0.rc2 → 0.10.0.rc3

data/lib/active_model/serializer/railtie.rb

@@ -1,5 +1,12 @@
+require 'rails/railtie'
 module ActiveModel
   class Railtie < Rails::Railtie
+    initializer 'active_model_serializers.logger' do
+      ActiveSupport.on_load(:action_controller) do
+        ActiveModelSerializers.logger = ActionController::Base.logger
+      end
+    end
+
     initializer 'generators' do |app|
       app.load_generators
       require 'generators/serializer/resource_override'

data/lib/active_model/serializer/reflection.rb

@@ -0,0 +1,74 @@
+module ActiveModel
+  class Serializer
+    # Holds all the meta-data about an association as it was specified in the
+    # ActiveModel::Serializer class.
+    #
+    # @example
+    #  class PostSerializer < ActiveModel::Serializer
+    #     has_one :author, serializer: AuthorSerializer
+    #     has_many :comments
+    #  end
+    #
+    #  PostSerializer._reflections #=>
+    #    # [
+    #    #   HasOneReflection.new(:author, serializer: AuthorSerializer),
+    #    #   HasManyReflection.new(:comments)
+    #    # ]
+    #
+    # So you can inspect reflections in your Adapters.
+    #
+    Reflection = Struct.new(:name, :options) do
+      # 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 [Hash{Symbol => Object}] parent_serializer_options
+      #
+      # @example
+      #    # Given the following serializer defined:
+      #    class PostSerializer < ActiveModel::Serializer
+      #      has_many :comments, serializer: CommentSummarySerializer
+      #    end
+      #
+      #    # Then you instantiate your serializer
+      #    post_serializer = PostSerializer.new(post, foo: 'bar') #
+      #    # to build association for comments you need to get reflection
+      #    comments_reflection = PostSerializer._reflections.detect { |r| r.name == :comments }
+      #    # and #build_association
+      #    comments_reflection.build_association(post_serializer, foo: 'bar')
+      #
+      # @api private
+      #
+      def build_association(subject, parent_serializer_options)
+        association_value = subject.send(name)
+        reflection_options = options.dup
+        serializer_class = ActiveModel::Serializer.serializer_for(association_value, reflection_options)
+
+        if serializer_class
+          begin
+            serializer = serializer_class.new(
+              association_value,
+              serializer_options(parent_serializer_options, reflection_options)
+            )
+          rescue ActiveModel::Serializer::ArraySerializer::NoSerializerError
+            reflection_options[:virtual_value] = association_value.try(:as_json) || association_value
+          end
+        elsif !association_value.nil? && !association_value.instance_of?(Object)
+          reflection_options[:virtual_value] = association_value
+        end
+
+        Association.new(name, serializer, reflection_options)
+      end
+
+      private
+
+      def serializer_options(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
+      end
+    end
+  end
+end

data/lib/active_model/serializer/singular_reflection.rb

@@ -0,0 +1,7 @@
+module ActiveModel
+  class Serializer
+    # @api private
+    class SingularReflection < Reflection
+    end
+  end
+end

data/lib/active_model/serializer/utils.rb

@@ -0,0 +1,35 @@
+module ActiveModel::Serializer::Utils
+  module_function
+
+  # Translates a comma separated list of dot separated paths (JSONAPI format) into a Hash.
+  # Example: `'posts.author, posts.comments.upvotes, posts.comments.author'` would become `{ posts: { author: {}, comments: { author: {}, upvotes: {} } } }`.
+  #
+  # @param [String] included
+  # @return [Hash] a Hash representing the same tree structure
+  def include_string_to_hash(included)
+    included.delete(' ').split(',').inject({}) do |hash, path|
+      hash.deep_merge!(path.split('.').reverse_each.inject({}) { |a, e| { e.to_sym => a } })
+    end
+  end
+
+  # Translates the arguments passed to the include option into a Hash. The format can be either
+  # a String (see #include_string_to_hash), an Array of Symbols and Hashes, or a mix of both.
+  # Example: `posts: [:author, comments: [:author, :upvotes]]` would become `{ posts: { author: {}, comments: { author: {}, upvotes: {} } } }`.
+  #
+  # @param [Symbol, Hash, Array, String] included
+  # @return [Hash] a Hash representing the same tree structure
+  def include_args_to_hash(included)
+    case included
+    when Symbol
+      { included => {} }
+    when Hash
+      included.each_with_object({}) { |(key, value), hash| hash[key] = include_args_to_hash(value) }
+    when Array
+      included.inject({}) { |a, e| a.merge!(include_args_to_hash(e)) }
+    when String
+      include_string_to_hash(included)
+    else
+      {}
+    end
+  end
+end

data/lib/active_model/serializer/version.rb

@@ -1,5 +1,5 @@
 module ActiveModel
   class Serializer
-    VERSION = "0.10.0.rc2"
+    VERSION = '0.10.0.rc3'
   end
 end

data/lib/active_model_serializers.rb

@@ -1,19 +1,33 @@
+require 'logger'
 require 'active_model'
-require 'active_model/serializer/version'
-require 'active_model/serializer'
-require 'active_model/serializer/fieldset'
-require 'active_model/serializer/railtie'
+require 'active_support/railtie'
+require 'action_controller'
+require 'action_controller/railtie'
+module ActiveModelSerializers
+  mattr_accessor :logger
+  self.logger = Rails.logger || Logger.new(IO::NULL)
 
-begin
-  require 'action_controller'
-  require 'action_controller/serialization'
+  module_function
 
-  ActiveSupport.on_load(:action_controller) do
-    include ::ActionController::Serialization
-    ActionDispatch::Reloader.to_prepare do
-      ActiveModel::Serializer.serializers_cache.clear
-    end
+  def silence_warnings
+    verbose = $VERBOSE
+    $VERBOSE = nil
+    yield
+  ensure
+    $VERBOSE = verbose
   end
-rescue LoadError
-  # rails not installed, continuing
 end
+
+require 'active_model/serializer'
+require 'active_model/serializable_resource'
+require 'active_model/serializer/version'
+
+require 'action_controller/serialization'
+ActiveSupport.on_load(:action_controller) do
+  include ::ActionController::Serialization
+  ActionDispatch::Reloader.to_prepare do
+    ActiveModel::Serializer.serializers_cache.clear
+  end
+end
+
+require 'active_model/serializer/railtie'

data/lib/generators/serializer/serializer_generator.rb

@@ -1,15 +1,15 @@
 module Rails
   module Generators
     class SerializerGenerator < NamedBase
-      source_root File.expand_path("../templates", __FILE__)
-      check_class_collision :suffix => "Serializer"
+      source_root File.expand_path('../templates', __FILE__)
+      check_class_collision :suffix => 'Serializer'
 
-      argument :attributes, :type => :array, :default => [], :banner => "field:type field:type"
+      argument :attributes, :type => :array, :default => [], :banner => 'field:type field:type'
 
-      class_option :parent, :type => :string, :desc => "The parent class for the generated serializer"
+      class_option :parent, :type => :string, :desc => 'The parent class for the generated serializer'
 
       def create_serializer_file
-        template 'serializer.rb', File.join('app/serializers', class_path, "#{file_name}_serializer.rb")
+        template 'serializer.rb.erb', File.join('app/serializers', class_path, "#{file_name}_serializer.rb")
       end
 
       private
@@ -26,9 +26,9 @@ module Rails
         if options[:parent]
           options[:parent]
         elsif defined?(::ApplicationSerializer)
-          "ApplicationSerializer"
+          'ApplicationSerializer'
         else
-          "ActiveModel::Serializer"
+          'ActiveModel::Serializer'
         end
       end
     end

data/lib/generators/serializer/templates/{serializer.rb → serializer.rb.erb}

@@ -1,8 +1,8 @@
 <% module_namespacing do -%>
 class <%= class_name %>Serializer < <%= parent_class_name %>
   attributes <%= attributes_names.map(&:inspect).join(", ") %>
-end
 <% association_names.each do |attribute| -%>
-  attribute :<%= attribute %>
+  has_one :<%= attribute %>
 <% end -%>
+end
 <% end -%>

data/test/action_controller/adapter_selector_test.rb

@@ -33,10 +33,10 @@ module ActionController
         expected = {
           data: {
             id: assigns(:profile).id.to_s,
-            type: "profiles",
+            type: 'profiles',
             attributes: {
-              name: "Name 1",
-              description: "Description 1",
+              name: 'Name 1',
+              description: 'Description 1',
             }
           }
         }

data/test/action_controller/explicit_serializer_test.rb

@@ -100,11 +100,11 @@ module ActionController
         get :render_array_using_explicit_serializer_and_custom_serializers
 
         expected = [
-          { "title" => "New Post",
-            "body" => "Body",
-            "id" => assigns(:post).id,
-            "comments" => [{"id" => 1}, {"id" => 2}],
-            "author" => { "id" => assigns(:author).id }
+          { 'title' => 'New Post',
+            'body' => 'Body',
+            'id' => assigns(:post).id,
+            'comments' => [{ 'id' => 1 }, { 'id' => 2 }],
+            'author' => { 'id' => assigns(:author).id }
           }
         ]
 
@@ -116,13 +116,13 @@ module ActionController
 
         expected = {
           id: 1337,
-          name: "Amazing Place",
+          name: 'Amazing Place',
           locations: [
             {
               id: 42,
-              lat: "-23.550520",
-              lng: "-46.633309",
-              place: "Nowhere" # is a virtual attribute on LocationSerializer
+              lat: '-23.550520',
+              lng: '-46.633309',
+              place: 'Nowhere' # is a virtual attribute on LocationSerializer
             }
           ]
         }

data/test/action_controller/json_api/linked_test.rb

@@ -0,0 +1,179 @@
+require 'test_helper'
+
+module ActionController
+  module Serialization
+    class JsonApi
+      class LinkedTest < ActionController::TestCase
+        class LinkedTestController < ActionController::Base
+          def setup_post
+            ActionController::Base.cache_store.clear
+            @role1 = Role.new(id: 1, name: 'admin')
+            @role2 = Role.new(id: 2, name: 'colab')
+            @author = Author.new(id: 1, name: 'Steve K.')
+            @author.posts = []
+            @author.bio = nil
+            @author.roles = [@role1, @role2]
+            @role1.author = @author
+            @role2.author = @author
+            @author2 = Author.new(id: 2, name: 'Anonymous')
+            @author2.posts = []
+            @author2.bio = nil
+            @author2.roles = []
+            @post = Post.new(id: 1, title: 'New Post', body: 'Body')
+            @first_comment = Comment.new(id: 1, body: 'ZOMG A COMMENT')
+            @second_comment = Comment.new(id: 2, body: 'ZOMG ANOTHER COMMENT')
+            @post.comments = [@first_comment, @second_comment]
+            @post.author = @author
+            @first_comment.post = @post
+            @first_comment.author = @author2
+            @second_comment.post = @post
+            @second_comment.author = nil
+            @post2 = Post.new(id: 2, title: 'Another Post', body: 'Body')
+            @post2.author = @author
+            @post2.comments = []
+            @blog = Blog.new(id: 1, name: 'My Blog!!')
+            @post.blog = @blog
+            @post2.blog = @blog
+          end
+
+          def render_resource_without_include
+            setup_post
+            render json: @post, adapter: :json_api
+          end
+
+          def render_resource_with_include
+            setup_post
+            render json: @post, include: [:author], adapter: :json_api
+          end
+
+          def render_resource_with_nested_include
+            setup_post
+            render json: @post, include: [comments: [:author]], adapter: :json_api
+          end
+
+          def render_resource_with_nested_has_many_include
+            setup_post
+            render json: @post, include: 'author.roles', adapter: :json_api
+          end
+
+          def render_resource_with_missing_nested_has_many_include
+            setup_post
+            @post.author = @author2 # author2 has no roles.
+            render json: @post, include: [author: [:roles]], adapter: :json_api
+          end
+
+          def render_collection_with_missing_nested_has_many_include
+            setup_post
+            @post.author = @author2
+            render json: [@post, @post2], include: [author: [:roles]], adapter: :json_api
+          end
+
+          def render_collection_without_include
+            setup_post
+            render json: [@post], adapter: :json_api
+          end
+
+          def render_collection_with_include
+            setup_post
+            render json: [@post], include: 'author, comments', adapter: :json_api
+          end
+        end
+
+        tests LinkedTestController
+
+        def test_render_resource_without_include
+          get :render_resource_without_include
+          response = JSON.parse(@response.body)
+          refute response.key? 'included'
+        end
+
+        def test_render_resource_with_include
+          get :render_resource_with_include
+          response = JSON.parse(@response.body)
+          assert response.key? 'included'
+          assert_equal 1, response['included'].size
+          assert_equal 'Steve K.', response['included'].first['attributes']['name']
+        end
+
+        def test_render_resource_with_nested_has_many_include
+          get :render_resource_with_nested_has_many_include
+          response = JSON.parse(@response.body)
+          expected_linked = [
+            {
+              'id' => '1',
+              'type' => 'authors',
+              'attributes' => {
+                'name' => 'Steve K.'
+              },
+              'relationships' => {
+                'posts' => { 'data' => [] },
+                'roles' => { 'data' => [{ 'type' => 'roles', 'id' => '1' }, { 'type' => 'roles', 'id' => '2' }] },
+                'bio' => { 'data' => nil }
+              }
+            }, {
+              'id' => '1',
+              'type' => 'roles',
+              'attributes' => {
+                'name' => 'admin',
+                'description' => nil,
+                'slug' => 'admin-1'
+              },
+              'relationships' => {
+                'author' => { 'data' => { 'type' => 'authors', 'id' => '1' } }
+              }
+            }, {
+              'id' => '2',
+              'type' => 'roles',
+              'attributes' => {
+                'name' => 'colab',
+                'description' => nil,
+                'slug' => 'colab-2'
+              },
+              'relationships' => {
+                'author' => { 'data' => { 'type' => 'authors', 'id' => '1' } }
+              }
+            }
+          ]
+          assert_equal expected_linked, response['included']
+        end
+
+        def test_render_resource_with_nested_include
+          get :render_resource_with_nested_include
+          response = JSON.parse(@response.body)
+          assert response.key? 'included'
+          assert_equal 3, response['included'].size
+        end
+
+        def test_render_collection_without_include
+          get :render_collection_without_include
+          response = JSON.parse(@response.body)
+          refute response.key? 'included'
+        end
+
+        def test_render_collection_with_include
+          get :render_collection_with_include
+          response = JSON.parse(@response.body)
+          assert response.key? 'included'
+        end
+
+        def test_render_resource_with_nested_attributes_even_when_missing_associations
+          get :render_resource_with_missing_nested_has_many_include
+          response = JSON.parse(@response.body)
+          assert response.key? 'included'
+          refute has_type?(response['included'], 'roles')
+        end
+
+        def test_render_collection_with_missing_nested_has_many_include
+          get :render_collection_with_missing_nested_has_many_include
+          response = JSON.parse(@response.body)
+          assert response.key? 'included'
+          assert has_type?(response['included'], 'roles')
+        end
+
+        def has_type?(collection, value)
+          collection.detect { |i| i['type'] == value }
+        end
+      end
+    end
+  end
+end