Split attribute serialization into its own class

Author: TrevorHinesley

lib/fast_jsonapi/attribute_serializer.rb

@@ -0,0 +1,29 @@
+module FastJsonapi
+  class AttributeSerializer
+    attr_reader :key, :method, :conditional_proc
+
+    def initialize(key:, method:, options: {})
+      @key = key
+      @method = method
+      @conditional_proc = options[:if]
+    end
+
+    def serialize(record, serialization_params, output_hash)
+      if include_attribute?(record, serialization_params)
+        output_hash[key] = if method.is_a?(Proc)
+          method.arity == 1 ? method.call(record) : method.call(record, serialization_params)
+        else
+          record.public_send(method)
+        end
+      end
+    end
+
+    def include_attribute?(record, serialization_params)
+      if conditional_proc.present?
+        conditional_proc.call(record, serialization_params)
+      else
+        true
+      end
+    end
+  end
+end

lib/fast_jsonapi/object_serializer.rb

@@ -3,6 +3,7 @@
 require 'active_support/core_ext/object'
 require 'active_support/concern'
 require 'active_support/inflector'
+require 'fast_jsonapi/attribute_serializer'
 require 'fast_jsonapi/serialization_core'
 
 module FastJsonapi
@@ -151,16 +152,15 @@ def attributes(*attributes_list, &block)
         attributes_list = attributes_list.first if attributes_list.first.class.is_a?(Array)
         options = attributes_list.last.is_a?(Hash) ? attributes_list.pop : {}
         self.attributes_to_serialize = {} if self.attributes_to_serialize.nil?
-        self.optional_attributes_to_serialize = {} if self.optional_attributes_to_serialize.nil?
 
         attributes_list.each do |attr_name|
           method_name = attr_name
           key = run_key_transform(method_name)
-          if options[:if].present?
-            optional_attributes_to_serialize[key] = [method_name, options[:if]]
-          else
-            attributes_to_serialize[key] = block || method_name
-          end
+          attributes_to_serialize[key] = AttributeSerializer.new(
+            key: key,
+            method: block || method_name,
+            options: options
+          )
         end
       end
 

lib/fast_jsonapi/serialization_core.rb

@@ -12,7 +12,6 @@ module SerializationCore
     included do
       class << self
         attr_accessor :attributes_to_serialize,
-                      :optional_attributes_to_serialize,
                       :relationships_to_serialize,
                       :cachable_relationships_to_serialize,
                       :uncachable_relationships_to_serialize,
@@ -74,21 +73,9 @@ def links_hash(record, params = {})
       end
 
       def attributes_hash(record, params = {})
-        attributes = attributes_to_serialize.each_with_object({}) do |(key, method), attr_hash|
-          attr_hash[key] = if method.is_a?(Proc)
-            method.arity == 1 ? method.call(record) : method.call(record, params)
-          else
-            record.public_send(method)
-          end
+        attributes_to_serialize.each_with_object({}) do |(key, attribute), attr_hash|
+          attribute.serialize(record, params, attr_hash)
         end
-
-        self.optional_attributes_to_serialize = {} if self.optional_attributes_to_serialize.nil?
-        optional_attributes_to_serialize.each do |key, details|
-          method_name, check_proc = details
-          attributes[key] = record.send(method_name) if check_proc.call(record, params)
-        end
-
-        attributes
       end
 
       def relationships_hash(record, relationships = nil, params = {})

spec/lib/object_serializer_inheritance_spec.rb

@@ -113,7 +113,7 @@ class EmployeeSerializer < UserSerializer
     end
 
     it 'includes child attributes' do
-      expect(EmployeeSerializer.attributes_to_serialize[:location]).to eq(:location)
+      expect(EmployeeSerializer.attributes_to_serialize[:location].method).to eq(:location)
     end
 
     it 'doesnt change parent class attributes' do

spec/lib/serialization_core_spec.rb

@@ -39,9 +39,9 @@
       attributes_hash = MovieSerializer.send(:attributes_hash, movie)
       attribute_names = attributes_hash.keys.sort
       expect(attribute_names).to eq MovieSerializer.attributes_to_serialize.keys.sort
-      MovieSerializer.attributes_to_serialize.each do |key, method_name|
+      MovieSerializer.attributes_to_serialize.each do |key, attribute|
         value = attributes_hash[key]
-        expect(value).to eq movie.send(method_name)
+        expect(value).to eq movie.send(attribute.method)
       end
     end