String/Lambda support for conditional attributes/associations

Author: mtsmfm

lib/active_model/serializer/field.rb

@@ -27,16 +27,29 @@ def value(serializer)
       def excluded?(serializer)
         case condition_type
         when :if
-          !serializer.public_send(condition)
+          !condition_lambda.call(serializer)
         when :unless
-          serializer.public_send(condition)
+          condition_lambda.call(serializer)
         else
           false
         end
       end
 
       private
 
+      def condition_lambda
+        case condition
+        when Symbol
+          -> (serializer) { serializer.public_send(condition) }
+        when String
+          -> (serializer) { serializer.instance_eval(condition) }
+        when Proc
+          -> (serializer) { condition.call(serializer) }
+        else
+          raise ArgumentError
+        end
+      end
+
       def condition_type
         @condition_type ||=
           if options.key?(:if)

test/serializers/associations_test.rb

@@ -239,7 +239,7 @@ def test_associations_namespaced_resources
           end
         end
 
-        def test_conditional_associations
+        def test_symbol_conditional_associations
           serializer = Class.new(ActiveModel::Serializer) do
             belongs_to :if_assoc_included, if: :true
             belongs_to :if_assoc_excluded, if: :false
@@ -261,6 +261,36 @@ def false
 
           assert_equal(expected, hash)
         end
+
+        def test_string_conditional_associations
+          serializer = Class.new(ActiveModel::Serializer) do
+            belongs_to :if_assoc_included, if: 'object.true'
+            belongs_to :if_assoc_excluded, if: 'object.false'
+            belongs_to :unless_assoc_included, unless: 'object.false'
+            belongs_to :unless_assoc_excluded, unless: 'object.true'
+          end
+
+          model = ::Model.new(true: true, false: false)
+          hash = serializable(model, serializer: serializer).serializable_hash
+          expected = { if_assoc_included: nil, unless_assoc_included: nil }
+
+          assert_equal(expected, hash)
+        end
+
+        def test_lambda_conditional_associations
+          serializer = Class.new(ActiveModel::Serializer) do
+            belongs_to :if_assoc_included, if: -> (s) { s.object.true }
+            belongs_to :if_assoc_excluded, if: -> (s) { s.object.false }
+            belongs_to :unless_assoc_included, unless: -> (s) { s.object.false }
+            belongs_to :unless_assoc_excluded, unless: -> (s) { s.object.true }
+          end
+
+          model = ::Model.new(true: true, false: false)
+          hash = serializable(model, serializer: serializer).serializable_hash
+          expected = { if_assoc_included: nil, unless_assoc_included: nil }
+
+          assert_equal(expected, hash)
+        end
       end
     end
   end

test/serializers/attribute_test.rb

@@ -96,7 +96,7 @@ def test_virtual_attribute_block
         assert_equal(expected, hash)
       end
 
-      def test_conditional_attributes
+      def test_symbol_conditional_attributes
         serializer = Class.new(ActiveModel::Serializer) do
           attribute :if_attribute_included, if: :true
           attribute :if_attribute_excluded, if: :false
@@ -118,6 +118,36 @@ def false
 
         assert_equal(expected, hash)
       end
+
+      def test_string_conditional_attributes
+        serializer = Class.new(ActiveModel::Serializer) do
+          attribute :if_attribute_included, if: 'object.true'
+          attribute :if_attribute_excluded, if: 'object.false'
+          attribute :unless_attribute_included, unless: 'object.false'
+          attribute :unless_attribute_excluded, unless: 'object.true'
+        end
+
+        model = ::Model.new(true: true, false: false)
+        hash = serializable(model, serializer: serializer).serializable_hash
+        expected = { if_attribute_included: nil, unless_attribute_included: nil }
+
+        assert_equal(expected, hash)
+      end
+
+      def test_lambda_conditional_attributes
+        serializer = Class.new(ActiveModel::Serializer) do
+          attribute :if_attribute_included, if: -> (s) { s.object.true }
+          attribute :if_attribute_excluded, if: -> (s) { s.object.false }
+          attribute :unless_attribute_included, unless: -> (s) { s.object.false }
+          attribute :unless_attribute_excluded, unless: -> (s) { s.object.true }
+        end
+
+        model = ::Model.new(true: true, false: false)
+        hash = serializable(model, serializer: serializer).serializable_hash
+        expected = { if_attribute_included: nil, unless_attribute_included: nil }
+
+        assert_equal(expected, hash)
+      end
     end
   end
 end