adds params to relatinoship blocks and tests

Author: shishirmk

lib/fast_jsonapi/object_serializer.rb

@@ -39,7 +39,7 @@ def hash_for_one_record
       return serializable_hash unless @resource
 
       serializable_hash[:data] = self.class.record_hash(@resource, @params)
-      serializable_hash[:included] = self.class.get_included_records(@resource, @includes, @known_included_objects) if @includes.present?
+      serializable_hash[:included] = self.class.get_included_records(@resource, @includes, @known_included_objects, @params) if @includes.present?
       serializable_hash
     end
 
@@ -50,7 +50,7 @@ def hash_for_collection
       included = []
       @resource.each do |record|
         data << self.class.record_hash(record, @params)
-        included.concat self.class.get_included_records(record, @includes, @known_included_objects) if @includes.present?
+        included.concat self.class.get_included_records(record, @includes, @known_included_objects, @params) if @includes.present?
       end
 
       serializable_hash[:data] = data

lib/fast_jsonapi/serialization_core.rb

@@ -44,15 +44,15 @@ def id_hash_from_record(record, record_types)
         id_hash(record.id, record_type)
       end
 
-      def ids_hash_from_record_and_relationship(record, relationship)
+      def ids_hash_from_record_and_relationship(record, relationship, params = {})
         polymorphic = relationship[:polymorphic]
 
         return ids_hash(
-          fetch_id(record, relationship),
+          fetch_id(record, relationship, params),
           relationship[:record_type]
         ) unless polymorphic
 
-        return unless associated_object = fetch_associated_object(record, relationship)
+        return unless associated_object = fetch_associated_object(record, relationship, params)
 
         return associated_object.map do |object|
           id_hash_from_record object, polymorphic
@@ -71,14 +71,14 @@ def attributes_hash(record, params = {})
         end
       end
 
-      def relationships_hash(record, relationships = nil)
+      def relationships_hash(record, relationships = nil, params = {})
         relationships = relationships_to_serialize if relationships.nil?
 
         relationships.each_with_object({}) do |(_k, relationship), hash|
           name = relationship[:key]
           empty_case = relationship[:relationship_type] == :has_many ? [] : nil
           hash[name] = {
-            data: ids_hash_from_record_and_relationship(record, relationship) || empty_case
+            data: ids_hash_from_record_and_relationship(record, relationship, params) || empty_case
           }
         end
       end
@@ -89,15 +89,15 @@ def record_hash(record, params = {})
             temp_hash = id_hash(id_from_record(record), record_type, true)
             temp_hash[:attributes] = attributes_hash(record, params) if attributes_to_serialize.present?
             temp_hash[:relationships] = {}
-            temp_hash[:relationships] = relationships_hash(record, cachable_relationships_to_serialize) if cachable_relationships_to_serialize.present?
+            temp_hash[:relationships] = relationships_hash(record, cachable_relationships_to_serialize, params) if cachable_relationships_to_serialize.present?
             temp_hash
           end
-          record_hash[:relationships] = record_hash[:relationships].merge(relationships_hash(record, uncachable_relationships_to_serialize)) if uncachable_relationships_to_serialize.present?
+          record_hash[:relationships] = record_hash[:relationships].merge(relationships_hash(record, uncachable_relationships_to_serialize, params)) if uncachable_relationships_to_serialize.present?
           record_hash
         else
           record_hash = id_hash(id_from_record(record), record_type, true)
           record_hash[:attributes] = attributes_hash(record, params) if attributes_to_serialize.present?
-          record_hash[:relationships] = relationships_hash(record) if relationships_to_serialize.present?
+          record_hash[:relationships] = relationships_hash(record, nil, params) if relationships_to_serialize.present?
           record_hash
         end
       end
@@ -115,9 +115,9 @@ def to_json(payload)
 
       # includes handler
 
-      def get_included_records(record, includes_list, known_included_objects)
+      def get_included_records(record, includes_list, known_included_objects, params = {})
         includes_list.each_with_object([]) do |item, included_records|
-          included_objects = fetch_associated_object(record, @relationships_to_serialize[item])
+          included_objects = fetch_associated_object(record, @relationships_to_serialize[item], params)
           next if included_objects.blank?
 
           record_type = @relationships_to_serialize[item][:record_type]
@@ -128,19 +128,19 @@ def get_included_records(record, includes_list, known_included_objects)
             code = "#{record_type}_#{inc_obj.id}"
             next if known_included_objects.key?(code)
             known_included_objects[code] = inc_obj
-            included_records << serializer.record_hash(inc_obj)
+            included_records << serializer.record_hash(inc_obj, params)
           end
         end
       end
 
-      def fetch_associated_object(record, relationship)
-        return relationship[:object_block].call(record) unless relationship[:object_block].nil?
+      def fetch_associated_object(record, relationship, params)
+        return relationship[:object_block].call(record, params) unless relationship[:object_block].nil?
         record.send(relationship[:object_method_name])
       end
 
-      def fetch_id(record, relationship)
+      def fetch_id(record, relationship, params)
         unless relationship[:object_block].nil?
-          object = relationship[:object_block].call(record)
+          object = relationship[:object_block].call(record, params)
 
           return object.map(&:id) if object.respond_to? :map
           return object.id

spec/lib/object_serializer_param_spec.rb …bject_serializer_attribute_param_spec.rbspec/lib/object_serializer_param_spec.rb renamed to spec/lib/object_serializer_attribute_param_spec.rb spec/lib/object_serializer_param_spec.rb renamed to spec/lib/object_serializer_attribute_param_spec.rb

@@ -23,7 +23,7 @@ class MovieSerializer
         end
       end
 
-      class User < Struct.new(:viewed); end
+      User = Struct.new(:viewed)
     end
 
     after(:context) do

spec/lib/object_serializer_relationship_param_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe FastJsonapi::ObjectSerializer do
+  include_context 'movie class'
+
+  context "params option" do
+    let(:hash) { serializer.serializable_hash }
+
+    before(:context) do
+      class MovieSerializer
+        has_many :agencies do |movie, params|
+          movie.actors.map(&:agency) if params[:authorized]
+        end
+
+        belongs_to :primary_agency do |movie, params|
+          movie.actors.map(&:agency)[0] if params[:authorized]
+        end
+
+        belongs_to :secondary_agency do |movie|
+          movie.actors.map(&:agency)[1]
+        end
+      end
+    end
+
+    context "passing params to the serializer" do
+      let(:params) { {authorized: true} }
+      let(:options_with_params) { {params: params} }
+
+      context "with a single record" do
+        let(:serializer) { MovieSerializer.new(movie, options_with_params) }
+
+        it "handles relationships that use params" do
+          ids = hash[:data][:relationships][:agencies][:data].map{|a| a[:id]}
+          ids.map!(&:to_i)
+          expect(ids).to eq [0,1,2]
+        end
+
+        it "handles relationships that don't use params" do
+          expect(hash[:data][:relationships][:secondary_agency][:data]).to include({id: 1.to_s})
+        end
+      end
+
+      context "with a list of records" do
+        let(:movies) { build_movies(3) }
+        let(:params) { {authorized: true} }
+        let(:serializer) { MovieSerializer.new(movies, options_with_params) }
+
+        it "handles relationship params when passing params to a list of resources" do
+          relationships_hashes = hash[:data].map{|a| a[:relationships][:agencies][:data]}.uniq.flatten
+          expect(relationships_hashes.map{|a| a[:id].to_i}).to contain_exactly 0,1,2
+
+          uniq_count = hash[:data].map{|a| a[:relationships][:primary_agency] }.uniq.count
+          expect(uniq_count).to eq 1
+        end
+
+        it "handles relationships without params" do
+          uniq_count = hash[:data].map{|a| a[:relationships][:secondary_agency] }.uniq.count
+          expect(uniq_count).to eq 1
+        end
+      end
+    end
+  end
+end