grape-active_model_serializers 1.4.0 → 1.5.0

data/lib/grape-active_model_serializers/serializer_resolver.rb

@@ -0,0 +1,99 @@
+module Grape
+  module ActiveModelSerializers
+    class SerializerResolver
+      def initialize(resource, options)
+        self.resource = resource
+        self.options = options
+      end
+
+      def serializer
+        serializer_class.new(resource, serializer_options) if serializer_class
+      end
+
+      private
+
+      attr_accessor :resource, :options
+
+      def serializer_class
+        return @serializer_class if defined?(@serializer_class)
+        @serializer_class = resource_defined_class
+        @serializer_class ||= collection_class
+        @serializer_class ||= options[:serializer]
+        @serializer_class ||= namespace_inferred_class
+        @serializer_class ||= version_inferred_class
+        @serializer_class ||= resource_serializer_class
+      end
+
+      def serializer_options
+        if collection_serializer? && !options.key?(:serializer)
+          options.merge(each_serializer_option)
+        else
+          options
+        end
+      end
+
+      def collection_serializer?
+        serializer_class == ActiveModel::Serializer.config.collection_serializer
+      end
+
+      def each_serializer_option
+        serializer_class = options[:each_serializer]
+        serializer_class ||= namespace_inferred_class
+        serializer_class ||= version_inferred_class
+        serializer_class ? { serializer: serializer_class } : {}
+      end
+
+      def resource_defined_class
+        resource.serializer_class if resource.respond_to?(:serializer_class)
+      end
+
+      def collection_class
+        return nil unless resource.respond_to?(:to_ary)
+        ActiveModel::Serializer.config.collection_serializer
+      end
+
+      def namespace_inferred_class
+        return nil unless options.key?(:for)
+        namespace = options[:for].to_s.deconstantize
+        "#{namespace}::#{resource_serializer_klass}".safe_constantize
+      end
+
+      def version_inferred_class
+        return nil unless options.key?(:version)
+        "#{version}::#{resource_serializer_klass}".safe_constantize
+      end
+
+      def version
+        options[:version].try(:classify)
+      end
+
+      def resource_serializer_klass
+        @resource_serializer_klass ||= [
+          resource_namespace,
+          "#{resource_klass}Serializer"
+        ].compact.join('::')
+      end
+
+      def resource_klass
+        resource_class.name.demodulize
+      end
+
+      def resource_namespace
+        klass = resource_class.name.deconstantize
+        klass.empty? ? nil : klass
+      end
+
+      def resource_class
+        if resource.respond_to?(:to_ary)
+          resource.try(:klass) || resource.compact.first.class
+        else
+          resource.class
+        end
+      end
+
+      def resource_serializer_class
+        ActiveModel::Serializer.serializer_for(resource)
+      end
+    end
+  end
+end

data/lib/grape-active_model_serializers/version.rb

@@ -1,5 +1,5 @@
 module Grape
   module ActiveModelSerializers
-    VERSION = '1.4.0'
+    VERSION = '1.5.0'.freeze
   end
 end

data/spec/features/grape-active_model_serializers/render_spec.rb

@@ -5,6 +5,7 @@ describe '#render' do
   let(:app) { Class.new(Grape::API) }
 
   before do
+    ActiveModelSerializers.config.adapter = :json
     app.format :json
     app.formatter :json, Grape::Formatter::ActiveModelSerializers
   end

data/spec/grape-active_model_serializers/endpoint_extension_spec.rb

@@ -2,9 +2,17 @@ require 'spec_helper'
 
 describe 'Grape::EndpointExtension' do
   if Grape::Util.const_defined?('InheritableSetting')
-    subject { Grape::Endpoint.new(Grape::Util::InheritableSetting.new, path: '/', method: 'foo') }
+    subject do
+      Grape::Endpoint.new(
+        Grape::Util::InheritableSetting.new,
+        path:   '/',
+        method: 'foo'
+      )
+    end
   else
-    subject { Grape::Endpoint.new({}, path: '/', method: 'foo') }
+    subject do
+      Grape::Endpoint.new({}, path: '/', method: 'foo')
+    end
   end
 
   let(:serializer) { Grape::Formatter::ActiveModelSerializers }
@@ -23,19 +31,29 @@ describe 'Grape::EndpointExtension' do
     before do
       allow(subject).to receive(:env).and_return({})
     end
+
     it { should respond_to(:render) }
     let(:meta_content) { { total: 2 } }
     let(:meta_full) { { meta: meta_content } }
+
     context 'supplying meta' do
+      before do
+        allow(subject).to receive(:env) { { meta: meta_full } }
+      end
+
       it 'passes through the Resource and uses given meta settings' do
-        allow(subject).to receive(:env).and_return(meta: meta_full)
         expect(subject.render(users, meta_full)).to eq(users)
       end
     end
+
     context 'supplying meta and key' do
       let(:meta_key) { { meta_key: :custom_key_name } }
+
+      before do
+        allow(subject).to receive(:env) { { meta: meta_full.merge(meta_key) } }
+      end
+
       it 'passes through the Resource and uses given meta settings' do
-        allow(subject).to receive(:env).and_return(meta: meta_full.merge(meta_key))
         expect(subject.render(users, meta_full.merge(meta_key))).to eq(users)
       end
     end

data/spec/grape-active_model_serializers/formatter_spec.rb

@@ -18,19 +18,24 @@ describe Grape::Formatter::ActiveModelSerializers do
       end
     end
 
+    let(:env) { { 'api.endpoint' => app.endpoints.first } }
+    let(:options) { described_class.build_options(nil, env) }
+
     it 'should read serializer options like "root"' do
-      expect(described_class.build_options_from_endpoint(app.endpoints.first)).to include :root
+      expect(options).to include(:root)
     end
   end
 
   describe '.fetch_serializer' do
     let(:user) { User.new(first_name: 'John') }
 
+    let(:params) { { path: '/', method: 'foo', root: false } }
     if Grape::Util.const_defined?('InheritableSetting')
-      let(:endpoint) { Grape::Endpoint.new(Grape::Util::InheritableSetting.new, path: '/', method: 'foo', root: false) }
+      let(:setting) { Grape::Util::InheritableSetting.new }
     else
-      let(:endpoint) { Grape::Endpoint.new({}, path: '/', method: 'foo', root: false) }
+      let(:setting) { {} }
     end
+    let(:endpoint) { Grape::Endpoint.new(setting, params) }
 
     let(:env) { { 'api.endpoint' => endpoint } }
 
@@ -44,7 +49,10 @@ describe Grape::Formatter::ActiveModelSerializers do
       end
     end
 
-    subject { described_class.fetch_serializer(user, env) }
+    let(:options) { described_class.build_options(user, env) }
+    subject { described_class.fetch_serializer(user, options) }
+
+    let(:instance_options) { subject.instance_variable_get(:@instance_options) }
 
     it { should be_a UserSerializer }
 
@@ -53,12 +61,12 @@ describe Grape::Formatter::ActiveModelSerializers do
     end
 
     it 'should read default serializer options' do
-      expect(subject.instance_variable_get('@only')).to eq([:only])
-      expect(subject.instance_variable_get('@except')).to eq([:except])
+      expect(instance_options[:only]).to eq(:only)
+      expect(instance_options[:except]).to eq(:except)
     end
 
     it 'should read serializer options like "root"' do
-      expect(described_class.build_options_from_endpoint(endpoint).keys).to include :root
+      expect(options).to include(:root)
     end
   end
 end

data/spec/grape-active_model_serializers/versioned_api_formatter_spec.rb

@@ -15,25 +15,35 @@ describe Grape::Formatter::ActiveModelSerializers do
 
         app.namespace('space') do |ns|
           ns.get('/', root: false, apiver: 'v1') do
-            { user: { first_name: 'JR', last_name: 'HE', email: 'jrhe@github.com' } }
+            {
+              user: {
+                first_name: 'JR',
+                last_name:  'HE',
+                email:      'jrhe@github.com'
+              }
+            }
           end
         end
       end
 
+      let(:env) { { 'api.endpoint' => app.endpoints.first } }
+      let(:options) { described_class.build_options(nil, env) }
+
       it 'should read serializer options like "root"' do
-        expect(described_class.build_options_from_endpoint(app.endpoints.first)).to include :root
+        expect(options).to include(:root)
       end
     end
 
     describe '.fetch_serializer' do
       let(:user) { User.new(first_name: 'John', email: 'j.doe@internet.com') }
 
+      let(:params) { { path: '/', method: 'foo', version: 'v1', root: false } }
       if Grape::Util.const_defined?('InheritableSetting')
-        let(:endpoint) { Grape::Endpoint.new(Grape::Util::InheritableSetting.new, path: '/', method: 'foo', version: 'v1', root: false) }
+        let(:setting) { Grape::Util::InheritableSetting.new }
       else
-        let(:endpoint) { Grape::Endpoint.new({}, path: '/', method: 'foo', version: 'v1', root: false) }
+        let(:setting) { {} }
       end
-
+      let(:endpoint) { Grape::Endpoint.new(setting, params) }
       let(:env) { { 'api.endpoint' => endpoint } }
 
       before do
@@ -46,7 +56,10 @@ describe Grape::Formatter::ActiveModelSerializers do
         end
       end
 
-      subject { described_class.fetch_serializer(user, env) }
+      let(:options) { described_class.build_options(user, env) }
+      subject { described_class.fetch_serializer(user, options) }
+
+      let(:instance_options) { subject.send(:instance_options) }
 
       it { should be_a V1::UserSerializer }
 
@@ -55,12 +68,12 @@ describe Grape::Formatter::ActiveModelSerializers do
       end
 
       it 'should read default serializer options' do
-        expect(subject.instance_variable_get('@only')).to eq([:only])
-        expect(subject.instance_variable_get('@except')).to eq([:except])
+        expect(instance_options[:only]).to eq(:only)
+        expect(instance_options[:except]).to eq(:except)
       end
 
       it 'should read serializer options like "root"' do
-        expect(described_class.build_options_from_endpoint(endpoint).keys).to include :root
+        expect(options).to include(:root)
       end
     end
   end

data/spec/grape/active_model_serializers/serializer_resolver_spec.rb

@@ -0,0 +1,146 @@
+require 'pry'
+require 'spec_helper'
+
+# asserts serializer resolution order:
+#   1. resource_defined_class     # V1::UserSerializer
+#   2. collection_class           # CollectionSerializer, V2::UserSerializer
+#   3. options[:serializer]       # V3::UserSerializer
+#   4. namespace_inferred_class   # V4::UserSerializer
+#   5. version_inferred_class     # V5::UserSerializer
+#   6. resource_serializer_class  # UserSerializer
+#   7. missing resource           # nil
+
+describe Grape::ActiveModelSerializers::SerializerResolver do
+  let(:resolver) { described_class.new(resource, options) }
+  let(:resource) { User.new }
+  let(:options) {
+    {
+      serializer: options_serializer_class, # options defined
+      for:        V4::UsersApi,             # namespace inference
+      version:    'v5'                      # version inference
+    }
+  }
+  # resource defined
+  let(:resource_defined?) { true }
+  let(:defined_serializer_class) { V1::UserSerializer }
+  # options defined
+  let(:options_serializer_class) { V3::UserSerializer }
+
+  let(:serializer) { resolver.serializer }
+
+  before do
+    if resource_defined?
+      allow(resource).to receive(:respond_to?).and_call_original
+      allow(resource).to receive(:respond_to?).with(:to_ary) { true }
+      allow(resource).to receive(:serializer_class) { defined_serializer_class }
+    end
+  end
+
+  context 'resource defined' do
+    it 'returns serializer' do
+      expect(serializer).to be_kind_of(defined_serializer_class)
+    end
+  end
+
+  context 'not resource defined' do
+    let(:resource_defined?) { false }
+
+    context 'resource collection' do
+      let(:resource) { [User.new] }
+      let(:serializer_class) { ActiveModel::Serializer::CollectionSerializer }
+
+      it 'returns serializer' do
+        expect(serializer).to be_kind_of(serializer_class)
+      end
+
+      context 'each serializer' do
+        let(:options) {
+          super().except(:serializer).merge(
+            each_serializer: V2::UserSerializer
+          )
+        }
+        let(:each_serializer) { serializer.send(:options)[:serializer] }
+
+        context 'each_serializer option' do
+          it 'returns expected serializer' do
+            expect(each_serializer).to eq(V2::UserSerializer)
+          end
+        end
+
+        context 'no each_serializer option' do
+          let(:options) { super().except(:each_serializer) }
+
+          context 'namespace inferred' do
+            it 'returns expected serializer' do
+              expect(each_serializer).to eq(V4::UserSerializer)
+            end
+          end
+
+          context 'not namespace inferred' do
+            let(:options) { super().except(:for) }
+
+            context 'version inferred' do
+              it 'returns expected serializer' do
+                expect(each_serializer).to eq(V5::UserSerializer)
+              end
+            end
+
+            context 'not version inferred' do
+              let(:options) { super().except(:version) }
+
+              it 'returns nil' do
+                expect(each_serializer).to eq(nil)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    context 'not resource collection' do
+      context 'specified by options' do
+        it 'returns specified serializer' do
+          expect(serializer).to be_kind_of(V3::UserSerializer)
+        end
+      end
+
+      context 'not specified by options' do
+        let(:options) { super().except(:serializer) }
+
+        context 'namespace inferred' do
+          it 'returns inferred serializer' do
+            expect(serializer).to be_kind_of(V4::UserSerializer)
+          end
+        end
+
+        context 'not namespace inferred' do
+          let(:options) { super().except(:for) }
+
+          context 'version inferred' do
+            it 'returns inferred serializer' do
+              expect(serializer).to be_kind_of(V5::UserSerializer)
+            end
+          end
+
+          context 'not version inferred' do
+            let(:options) { super().except(:version) }
+
+            context 'ASM resolved' do
+              it 'returns serializer' do
+                expect(serializer).to be_kind_of(UserSerializer)
+              end
+            end
+
+            context 'not ASM resolved' do
+              let(:resource) { nil }
+
+              it 'returns nil' do
+                expect(serializer).to eq(nil)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/old_grape_ams_spec.rb

@@ -10,6 +10,7 @@ describe Grape::ActiveModelSerializers do
   subject { last_response.body }
 
   before do
+    ActiveModelSerializers.config.adapter = :json
     app.format :json
     app.formatter :json, Grape::Formatter::ActiveModelSerializers
   end
@@ -30,31 +31,48 @@ describe Grape::ActiveModelSerializers do
     end
     it 'uses the built in grape serializer' do
       get('/home')
-      expect(subject).to eql "{\"user\":{\"first_name\":\"JR\",\"last_name\":\"HE\"}}"
+      expect(subject).to eq(
+        '{"user":{"first_name":"JR","last_name":"HE"}}'
+      )
     end
   end
 
   context "serializer isn't set" do
     before do
       app.get('/home') do
-        User.new(first_name: 'JR', last_name: 'HE', email: 'contact@jrhe.co.uk')
+        User.new(
+          first_name: 'JR',
+          last_name:  'HE',
+          email:      'contact@jrhe.co.uk'
+        )
       end
     end
 
     it 'infers the serializer' do
       get '/home'
-      expect(subject).to eql "{\"user\":{\"first_name\":\"JR\",\"last_name\":\"HE\"}}"
+      expect(subject).to eq(
+        '{"user":{"first_name":"JR","last_name":"HE"}}'
+      )
     end
   end
 
   it 'serializes arrays of objects' do
     app.get('/users') do
-      user = User.new(first_name: 'JR', last_name: 'HE', email: 'contact@jrhe.co.uk')
+      user = User.new(
+        first_name: 'JR',
+        last_name:  'HE',
+        email:      'contact@jrhe.co.uk'
+      )
       [user, user]
     end
 
     get '/users'
-    expect(subject).to eql "{\"users\":[{\"first_name\":\"JR\",\"last_name\":\"HE\"},{\"first_name\":\"JR\",\"last_name\":\"HE\"}]}"
+    expect(subject).to eq(
+      '{"users":['\
+        '{"first_name":"JR","last_name":"HE"},'\
+        '{"first_name":"JR","last_name":"HE"}'\
+      ']}'
+    )
   end
 
   context 'models with compound names' do
@@ -64,17 +82,29 @@ describe Grape::ActiveModelSerializers do
       end
 
       get '/home'
-      expect(subject).to eql "{\"blog_post\":{\"title\":\"Grape AM::S Rocks!\",\"body\":\"Really, it does.\"}}"
+      expect(subject).to eq(
+        '{"blog_post":'\
+          '{"title":"Grape AM::S Rocks!","body":"Really, it does."}'\
+        '}'
+      )
     end
 
     it "generates the proper 'root' node for serialized arrays" do
       app.get('/blog_posts') do
-        blog_post = BlogPost.new(title: 'Grape AM::S Rocks!', body: 'Really, it does.')
+        blog_post = BlogPost.new(
+          title: 'Grape AM::S Rocks!',
+          body:  'Really, it does.'
+        )
         [blog_post, blog_post]
       end
 
       get '/blog_posts'
-      expect(subject).to eql "{\"blog_posts\":[{\"title\":\"Grape AM::S Rocks!\",\"body\":\"Really, it does.\"},{\"title\":\"Grape AM::S Rocks!\",\"body\":\"Really, it does.\"}]}"
+      expect(subject).to eq(
+        '{"blog_posts":['\
+          '{"title":"Grape AM::S Rocks!","body":"Really, it does."},'\
+          '{"title":"Grape AM::S Rocks!","body":"Really, it does."}'\
+        ']}'
+      )
     end
   end
 
@@ -86,7 +116,9 @@ describe Grape::ActiveModelSerializers do
     end
 
     get '/admin/jeff'
-    expect(subject).to eql "{\"user\":{\"first_name\":\"Jeff\",\"last_name\":null}}"
+    expect(subject).to eq(
+      '{"user":{"first_name":"Jeff","last_name":null}}'
+    )
   end
 
   context 'route is in a namespace' do
@@ -99,7 +131,12 @@ describe Grape::ActiveModelSerializers do
       end
 
       get '/admin/jeff'
-      expect(subject).to eql "{\"admin\":[{\"first_name\":\"Jeff\",\"last_name\":null},{\"first_name\":\"Jeff\",\"last_name\":null}]}"
+      expect(subject).to eq(
+        '{"admin":['\
+          '{"first_name":"Jeff","last_name":null},'\
+          '{"first_name":"Jeff","last_name":null}'\
+        ']}'
+      )
     end
   end
 
@@ -111,7 +148,12 @@ describe Grape::ActiveModelSerializers do
       end
 
       get '/people'
-      expect(subject).to eql "{\"people\":[{\"first_name\":\"Jeff\",\"last_name\":null},{\"first_name\":\"Jeff\",\"last_name\":null}]}"
+      expect(subject).to eq(
+        '{"people":['\
+          '{"first_name":"Jeff","last_name":null},'\
+          '{"first_name":"Jeff","last_name":null}'\
+        ']}'
+      )
     end
   end
 end