agi_active_model_serializers 0.10.7

data/lib/active_model_serializers/test/serializer.rb

@@ -0,0 +1,125 @@
+require 'set'
+module ActiveModelSerializers
+  module Test
+    module Serializer
+      extend ActiveSupport::Concern
+
+      included do
+        setup :setup_serialization_subscriptions
+        teardown :teardown_serialization_subscriptions
+      end
+
+      # Asserts that the request was rendered with the appropriate serializers.
+      #
+      #  # assert that the "PostSerializer" serializer was rendered
+      #  assert_serializer "PostSerializer"
+      #
+      #  # return a custom error message
+      #  assert_serializer "PostSerializer", "PostSerializer not rendered"
+      #
+      #  # assert that the instance of PostSerializer was rendered
+      #  assert_serializer PostSerializer
+      #
+      #  # assert that the "PostSerializer" serializer was rendered
+      #  assert_serializer :post_serializer
+      #
+      #  # assert that the rendered serializer starts with "Post"
+      #  assert_serializer %r{\APost.+\Z}
+      #
+      #  # assert that no serializer was rendered
+      #  assert_serializer nil
+      #
+      def assert_serializer(expectation, message = nil)
+        @assert_serializer.expectation = expectation
+        @assert_serializer.message = message
+        @assert_serializer.response = response
+        assert(@assert_serializer.matches?, @assert_serializer.message)
+      end
+
+      class AssertSerializer
+        attr_reader :serializers, :message
+        attr_accessor :response, :expectation
+
+        def initialize
+          @serializers = Set.new
+          @_subscribers = []
+        end
+
+        def message=(message)
+          @message = message || "expecting <#{expectation.inspect}> but rendering with <#{serializers.to_a}>"
+        end
+
+        def matches?
+          # Force body to be read in case the template is being streamed.
+          response.body
+
+          case expectation
+          when a_serializer? then matches_class?
+          when Symbol        then matches_symbol?
+          when String        then matches_string?
+          when Regexp        then matches_regexp?
+          when NilClass      then matches_nil?
+          else fail ArgumentError, 'assert_serializer only accepts a String, Symbol, Regexp, ActiveModel::Serializer, or nil'
+          end
+        end
+
+        def subscribe
+          @_subscribers << ActiveSupport::Notifications.subscribe(event_name) do |_name, _start, _finish, _id, payload|
+            serializer = payload[:serializer].name
+            serializers << serializer
+          end
+        end
+
+        def unsubscribe
+          @_subscribers.each do |subscriber|
+            ActiveSupport::Notifications.unsubscribe(subscriber)
+          end
+        end
+
+        private
+
+        def matches_class?
+          serializers.include?(expectation.name)
+        end
+
+        def matches_symbol?
+          camelize_expectation = expectation.to_s.camelize
+          serializers.include?(camelize_expectation)
+        end
+
+        def matches_string?
+          !expectation.empty? && serializers.include?(expectation)
+        end
+
+        def matches_regexp?
+          serializers.any? do |serializer|
+            serializer.match(expectation)
+          end
+        end
+
+        def matches_nil?
+          serializers.empty?
+        end
+
+        def a_serializer?
+          ->(exp) { exp.is_a?(Class) && exp < ActiveModel::Serializer }
+        end
+
+        def event_name
+          ::ActiveModelSerializers::Logging::RENDER_EVENT
+        end
+      end
+
+      private
+
+      def setup_serialization_subscriptions
+        @assert_serializer = AssertSerializer.new
+        @assert_serializer.subscribe
+      end
+
+      def teardown_serialization_subscriptions
+        @assert_serializer.unsubscribe
+      end
+    end
+  end
+end

data/lib/generators/rails/USAGE

@@ -0,0 +1,6 @@
+Description:
+    Generates a serializer for the given resource.
+
+Example:
+    `rails generate serializer Account name created_at`
+

data/lib/generators/rails/resource_override.rb

@@ -0,0 +1,10 @@
+require 'rails/generators'
+require 'rails/generators/rails/resource/resource_generator'
+
+module Rails
+  module Generators
+    class ResourceGenerator
+      hook_for :serializer, default: true, boolean: true
+    end
+  end
+end

data/lib/generators/rails/serializer_generator.rb

@@ -0,0 +1,36 @@
+module Rails
+  module Generators
+    class SerializerGenerator < NamedBase
+      source_root File.expand_path('../templates', __FILE__)
+      check_class_collision suffix: 'Serializer'
+
+      argument :attributes, type: :array, default: [], banner: 'field:type field:type'
+
+      class_option :parent, type: :string, desc: 'The parent class for the generated serializer'
+
+      def create_serializer_file
+        template 'serializer.rb.erb', File.join('app/serializers', class_path, "#{file_name}_serializer.rb")
+      end
+
+      private
+
+      def attributes_names
+        [:id] + attributes.reject(&:reference?).map! { |a| a.name.to_sym }
+      end
+
+      def association_names
+        attributes.select(&:reference?).map! { |a| a.name.to_sym }
+      end
+
+      def parent_class_name
+        if options[:parent]
+          options[:parent]
+        elsif 'ApplicationSerializer'.safe_constantize
+          'ApplicationSerializer'
+        else
+          'ActiveModel::Serializer'
+        end
+      end
+    end
+  end
+end

data/lib/generators/rails/templates/serializer.rb.erb

@@ -0,0 +1,15 @@
+<%- module_namespacing do -%>
+<%- module_name = class_name.split('::')[0..-2] -%>
+<%- if module_name.any? -%>
+module <%= class_name.split('::')[0..-2].join('::') %>
+<%- end -%>
+  class <%= class_name.split('::').last %>Serializer < BaseSerializer
+    attributes <%= attributes_names.map(&:inspect).join(", ") %>
+  <%- association_names.each do |attribute| -%>
+    has_one :<%= attribute %>
+  <%- end -%>
+  end
+<%- if module_name.any? -%>
+end
+<%- end -%>
+<%- end -%>

data/lib/grape/active_model_serializers.rb

@@ -0,0 +1,16 @@
+# To add Grape support, require 'grape/active_model_serializers' in the base of your Grape endpoints
+# Then add 'include Grape::ActiveModelSerializers' to enable the formatter and helpers
+require 'active_model_serializers'
+require 'grape/formatters/active_model_serializers'
+require 'grape/helpers/active_model_serializers'
+
+module Grape
+  module ActiveModelSerializers
+    extend ActiveSupport::Concern
+
+    included do
+      formatter :json, Grape::Formatters::ActiveModelSerializers
+      helpers Grape::Helpers::ActiveModelSerializers
+    end
+  end
+end

data/lib/grape/formatters/active_model_serializers.rb

@@ -0,0 +1,32 @@
+# A Grape response formatter that can be used as 'formatter :json, Grape::Formatters::ActiveModelSerializers'
+#
+# Serializer options can be passed as a hash from your Grape endpoint using env[:active_model_serializer_options],
+# or better yet user the render helper in Grape::Helpers::ActiveModelSerializers
+
+require 'active_model_serializers/serialization_context'
+
+module Grape
+  module Formatters
+    module ActiveModelSerializers
+      def self.call(resource, env)
+        serializer_options = build_serializer_options(env)
+        ::ActiveModelSerializers::SerializableResource.new(resource, serializer_options).to_json
+      end
+
+      def self.build_serializer_options(env)
+        ams_options = env[:active_model_serializer_options] || {}
+
+        # Add serialization context
+        ams_options.fetch(:serialization_context) do
+          request = env['grape.request']
+          ams_options[:serialization_context] = ::ActiveModelSerializers::SerializationContext.new(
+            request_url: request.url[/\A[^?]+/],
+            query_parameters: request.params
+          )
+        end
+
+        ams_options
+      end
+    end
+  end
+end

data/lib/grape/helpers/active_model_serializers.rb

@@ -0,0 +1,17 @@
+# Helpers can be included in your Grape endpoint as: helpers Grape::Helpers::ActiveModelSerializers
+
+module Grape
+  module Helpers
+    module ActiveModelSerializers
+      # A convenience method for passing ActiveModelSerializers serializer options
+      #
+      # Example: To include relationships in the response: render(post, include: ['comments'])
+      #
+      # Example: To include pagination meta data: render(posts, meta: { page: posts.page, total_pages: posts.total_pages })
+      def render(resource, active_model_serializer_options = {})
+        env[:active_model_serializer_options] = active_model_serializer_options
+        resource
+      end
+    end
+  end
+end

data/test/action_controller/adapter_selector_test.rb

@@ -0,0 +1,53 @@
+require 'test_helper'
+
+module ActionController
+  module Serialization
+    class AdapterSelectorTest < ActionController::TestCase
+      class AdapterSelectorTestController < ActionController::Base
+        def render_using_default_adapter
+          @profile = Profile.new(name: 'Name 1', description: 'Description 1', comments: 'Comments 1')
+          render json: @profile
+        end
+
+        def render_using_adapter_override
+          @profile = Profile.new(name: 'Name 1', description: 'Description 1', comments: 'Comments 1')
+          render json: @profile, adapter: :json_api
+        end
+
+        def render_skipping_adapter
+          @profile = Profile.new(id: 'render_skipping_adapter_id', name: 'Name 1', description: 'Description 1', comments: 'Comments 1')
+          render json: @profile, adapter: false
+        end
+      end
+
+      tests AdapterSelectorTestController
+
+      def test_render_using_default_adapter
+        get :render_using_default_adapter
+        assert_equal '{"name":"Name 1","description":"Description 1"}', response.body
+      end
+
+      def test_render_using_adapter_override
+        get :render_using_adapter_override
+
+        expected = {
+          data: {
+            id: @controller.instance_variable_get(:@profile).id.to_s,
+            type: 'profiles',
+            attributes: {
+              name: 'Name 1',
+              description: 'Description 1'
+            }
+          }
+        }
+
+        assert_equal expected.to_json, response.body
+      end
+
+      def test_render_skipping_adapter
+        get :render_skipping_adapter
+        assert_equal '{"id":"render_skipping_adapter_id","name":"Name 1","description":"Description 1"}', response.body
+      end
+    end
+  end
+end

data/test/action_controller/explicit_serializer_test.rb

@@ -0,0 +1,135 @@
+require 'test_helper'
+
+module ActionController
+  module Serialization
+    class ExplicitSerializerTest < ActionController::TestCase
+      class ExplicitSerializerTestController < ActionController::Base
+        def render_using_explicit_serializer
+          @profile = Profile.new(name: 'Name 1',
+                                 description: 'Description 1',
+                                 comments: 'Comments 1')
+          render json: @profile, serializer: ProfilePreviewSerializer
+        end
+
+        def render_array_using_explicit_serializer
+          array = [
+            Profile.new(name: 'Name 1',
+                        description: 'Description 1',
+                        comments: 'Comments 1'),
+            Profile.new(name: 'Name 2',
+                        description: 'Description 2',
+                        comments: 'Comments 2')
+          ]
+          render json: array,
+                 serializer: PaginatedSerializer,
+                 each_serializer: ProfilePreviewSerializer
+        end
+
+        def render_array_using_implicit_serializer
+          array = [
+            Profile.new(name: 'Name 1',
+                        description: 'Description 1',
+                        comments: 'Comments 1'),
+            Profile.new(name: 'Name 2',
+                        description: 'Description 2',
+                        comments: 'Comments 2')
+          ]
+          render json: array,
+                 each_serializer: ProfilePreviewSerializer
+        end
+
+        def render_array_using_explicit_serializer_and_custom_serializers
+          @post = Post.new(title: 'New Post', body: 'Body')
+          @author = Author.new(name: 'Jane Blogger')
+          @author.posts = [@post]
+          @post.author = @author
+          @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]
+          @first_comment.post = @post
+          @first_comment.author = nil
+          @second_comment.post = @post
+          @second_comment.author = nil
+          @blog = Blog.new(id: 23, name: 'AMS Blog')
+          @post.blog = @blog
+
+          render json: [@post], each_serializer: PostPreviewSerializer
+        end
+
+        def render_using_explicit_each_serializer
+          location       = Location.new(id: 42, lat: '-23.550520', lng: '-46.633309')
+          place          = Place.new(id: 1337, name: 'Amazing Place', locations: [location])
+
+          render json: place, each_serializer: PlaceSerializer
+        end
+      end
+
+      tests ExplicitSerializerTestController
+
+      def test_render_using_explicit_serializer
+        get :render_using_explicit_serializer
+
+        assert_equal 'application/json', @response.content_type
+        assert_equal '{"name":"Name 1"}', @response.body
+      end
+
+      def test_render_array_using_explicit_serializer
+        get :render_array_using_explicit_serializer
+        assert_equal 'application/json', @response.content_type
+
+        expected = [
+          { 'name' => 'Name 1' },
+          { 'name' => 'Name 2' }
+        ]
+
+        assert_equal expected.to_json, @response.body
+      end
+
+      def test_render_array_using_implicit_serializer
+        get :render_array_using_implicit_serializer
+        assert_equal 'application/json', @response.content_type
+
+        expected = [
+          { 'name' => 'Name 1' },
+          { 'name' => 'Name 2' }
+        ]
+        assert_equal expected.to_json, @response.body
+      end
+
+      def test_render_array_using_explicit_serializer_and_custom_serializers
+        get :render_array_using_explicit_serializer_and_custom_serializers
+
+        expected = [
+          {
+            'title' => 'New Post',
+            'body' => 'Body',
+            'id' => @controller.instance_variable_get(:@post).id,
+            'comments' => [{ 'id' => 1 }, { 'id' => 2 }],
+            'author' => { 'id' => @controller.instance_variable_get(:@author).id }
+          }
+        ]
+
+        assert_equal expected.to_json, @response.body
+      end
+
+      def test_render_using_explicit_each_serializer
+        get :render_using_explicit_each_serializer
+
+        expected = {
+          id: 1337,
+          name: 'Amazing Place',
+          locations: [
+            {
+              id: 42,
+              lat: '-23.550520',
+              lng: '-46.633309',
+              address: 'Nowhere' # is a virtual attribute on LocationSerializer
+            }
+          ]
+        }
+
+        assert_equal expected.to_json, response.body
+      end
+    end
+  end
+end