Feature proposal: Honor all conditional checks config - path for sparse fields

README.md

@@ -670,13 +670,15 @@ Output:
 
 
 Both the `field` and the global Blueprinter Configuration supports `:if` and `:unless` options that can be used to serialize fields conditionally.
+By default, field-level conditions override global conditions. By enabling `enforce_all_conditions`, BOTH field-level and global conditions must be met in order for the field to be serialized.
 
 ### Global Config Setting - if and unless
 
 ```ruby
 Blueprinter.configure do |config|
   config.if = ->(field_name, obj, _options) { !obj[field_name].nil? }
   config.unless = ->(field_name, obj, _options) { obj[field_name].nil? }
+  config.enforce_all_conditions = true
 end
 ```
 
@@ -690,8 +692,7 @@ class UserBlueprint < Blueprinter::Base
 end
 ```
 
-_NOTE:_ The field-level setting overrides the global config setting (for the field) if both are set.
-
+---
 </details>
 
 <details>

lib/blueprinter/configuration.rb

@@ -3,7 +3,8 @@
 module Blueprinter
   class Configuration
     attr_accessor :association_default, :datetime_format, :deprecations, :field_default, :generator, :if, :method,
-                  :sort_fields_by, :unless, :extractor_default, :default_transformers, :custom_array_like_classes
+                  :sort_fields_by, :unless, :extractor_default, :default_transformers, :custom_array_like_classes,
+                  :enforce_all_conditions
 
     VALID_CALLABLES = %i[if unless].freeze
 
@@ -20,6 +21,7 @@ def initialize
       @extractor_default = AutoExtractor
       @default_transformers = []
       @custom_array_like_classes = []
+      @enforce_all_conditions = false
     end
 
     def array_like_classes

lib/blueprinter/field.rb

@@ -18,25 +18,49 @@ def extract(object, local_options)
     end
 
     def skip?(field_name, object, local_options)
-      return true if if_callable && !if_callable.call(field_name, object, local_options)
+      if Blueprinter.configuration.enforce_all_conditions
+        any_global_or_field_condition_failed?(field_name, object, local_options)
+      else
+        return true if if_callable && !if_callable.call(field_name, object, local_options)
 
-      unless_callable && unless_callable.call(field_name, object, local_options)
+        unless_callable && unless_callable.call(field_name, object, local_options)
+      end
     end
 
     private
 
+    def any_global_or_field_condition_failed?(field_name, object, local_options)
+      return true if if_callables.any? { |if_call| !if_call.call(field_name, object, local_options) }
+
+      unless_callables.any? { |unless_call| unless_call.call(field_name, object, local_options) }
+    end
+
     def if_callable
       return @if_callable if defined?(@if_callable)
 
       @if_callable = callable_from(:if)
     end
 
+    def if_callables
+      [
+        extract_callable_from(Blueprinter.configuration.if),
+        extract_callable_from(options[:if])
+      ].select { |callable| callable }
+    end
+
     def unless_callable
       return @unless_callable if defined?(@unless_callable)
 
       @unless_callable = callable_from(:unless)
     end
 
+    def unless_callables
+      [
+        extract_callable_from(Blueprinter.configuration.unless),
+        extract_callable_from(options[:unless])
+      ].select { |callable| callable }
+    end
+
     def callable_from(condition)
       config = Blueprinter.configuration
 
@@ -47,13 +71,17 @@ def callable_from(condition)
               config.public_send(condition)
             end
 
-      return false unless tmp
+      extract_callable_from(tmp)
+    end
+
+    def extract_callable_from(tmp_callable)
+      return false unless tmp_callable
 
-      case tmp
-      when Proc then tmp
-      when Symbol then blueprint.method(tmp)
+      case tmp_callable
+      when Proc then tmp_callable
+      when Symbol then blueprint.method(tmp_callable)
       else
-        raise ArgumentError, "#{tmp.class} is passed to :#{condition}"
+        raise ArgumentError, "#{tmp_callable.class} is passed to :#{condition}"
       end
     end
   end

spec/integrations/shared/base_render_examples.rb

@@ -333,6 +333,43 @@ def self.unless_method(_field_name, _object, _options)
                 include_examples 'does not serialize the conditional field'
               end
             end
+
+            context 'enforce_all_conditions is enabled' do
+              let(:local_options) { {x: 1, y: 2, v1: value, v2: other_value} }
+
+              before do
+                Blueprinter.configuration.enforce_all_conditions = true
+                Blueprinter.configuration.if = ->(field_name, object, local_opts) {
+                  if local_opts[:sparse_fields]
+                    local_opts[:sparse_fields].include?(field_name.to_s)
+                  else
+                    value
+                  end
+                }
+                Blueprinter.configuration.unless = ->(_a,_b,_c) { other_value }
+              end
+              after do
+                Blueprinter.configuration.enforce_all_conditions = false
+                Blueprinter.configuration.if = nil
+                Blueprinter.configuration.unless = nil
+              end
+
+              if value && !other_value
+                include_examples 'serializes the conditional field'
+
+                context 'and top level conditional triggered by local options' do
+                  let(:local_options) { {sparse_fields: ['first_name']} }
+
+                  it 'honors all configuration conditionals - only serializes specified field' do
+                    should eq(%({"first_name":"Meg"}))
+                  end
+                end
+              else
+                it 'nothing is serialized' do
+                  should eq('{}')
+                end
+              end
+            end
           end
         end