Validate empty with context

library/Zend/InputFilter/BaseInputFilter.php

@@ -187,8 +187,10 @@ protected function validateInputs(array $inputs)
                 && $input->isRequired()
                 && $input->allowEmpty()
             ) {
-                $this->validInputs[$name] = $input;
-                continue;
+                if (!$input->allowEmpty()) {
+                    $this->validInputs[$name] = $input;
+                    continue;
+                }
             }
 
             // key exists, is null, input is not required; valid
@@ -223,14 +225,18 @@ protected function validateInputs(array $inputs)
             }
 
             // key exists, empty string, input is required, allows empty; valid
+            // if continueIfEmpty is false, otherwise validation continues
             if ($dataExists
                 && '' === $this->data[$name]
                 && $input instanceof InputInterface
+                && $input instanceof EmptyContextInterface
                 && $input->isRequired()
                 && $input->allowEmpty()
             ) {
-                $this->validInputs[$name] = $input;
-                continue;
+                if (!$input->continueIfEmpty()) {
+                    $this->validInputs[$name] = $input;
+                    continue;
+                }
             }
 
             // key exists, is array representing file, no file present, input not

library/Zend/InputFilter/EmptyContextInterface.php

@@ -0,0 +1,17 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2013 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ */
+
+namespace Zend\InputFilter;
+
+interface EmptyContextInterface
+{
+    public function setContinueIfEmpty($continueIfEmpty);
+
+    public function continueIfEmpty();
+}

library/Zend/InputFilter/Factory.php

@@ -153,6 +153,9 @@ public function createInput($inputSpecification)
                         $input->setRequired(!$value);
                     }
                     break;
+                case 'continue_if_empty':
+                    $input->setContinueIfEmpty($inputSpecification['continue_if_empty']);
+                    break;
                 case 'fallback_value':
                     $input->setFallbackValue($value);
                     break;

library/Zend/InputFilter/Input.php

@@ -13,12 +13,17 @@
 use Zend\Validator\ValidatorChain;
 use Zend\Validator\NotEmpty;
 
-class Input implements InputInterface
+class Input implements InputInterface, EmptyContextInterface
 {
     /**
      * @var bool
      */
     protected $allowEmpty = false;
+
+    /**
+     * @var bool
+     */
+    protected $continueIfEmpty = false;
 
     /**
      * @var bool
@@ -89,6 +94,16 @@ public function setBreakOnFailure($breakOnFailure)
         $this->breakOnFailure = (bool) $breakOnFailure;
         return $this;
     }
+
+    /**
+     * @param bool $continueIfEmpty
+     * @return \Zend\InputFilter\Input
+     */
+    public function setContinueIfEmpty($continueIfEmpty)
+    {
+        $this->continueIfEmpty = (bool) $continueIfEmpty;
+        return $this;
+    }
 
     /**
      * @param  string|null $errorMessage
@@ -175,6 +190,14 @@ public function breakOnFailure()
     {
         return $this->breakOnFailure;
     }
+
+    /**
+     * @return bool
+     */
+    public function continueIfEmpty()
+    {
+        return $this->continueIfEmpty;
+    }
 
     /**
      * @return string|null
@@ -274,7 +297,12 @@ public function merge(InputInterface $input)
      */
     public function isValid($context = null)
     {
-        $this->injectNotEmptyValidator();
+        // Empty value needs further validation if continueIfEmpty is set
+        // so don't inject NotEmpty validator which would always
+        // mark that as false
+        if (!$this->continueIfEmpty()) {
+            $this->injectNotEmptyValidator();
+        }
         $validator = $this->getValidatorChain();
         $value     = $this->getValue();
         $result    = $validator->isValid($value, $context);

library/Zend/InputFilter/InputInterface.php

@@ -16,6 +16,7 @@ interface InputInterface
 {
     public function setAllowEmpty($allowEmpty);
     public function setBreakOnFailure($breakOnFailure);
+    public function setContinueIfEmpty($continueIfEmpty);
     public function setErrorMessage($errorMessage);
     public function setFilterChain(FilterChain $filterChain);
     public function setName($name);
@@ -26,6 +27,7 @@ public function merge(InputInterface $input);
 
     public function allowEmpty();
     public function breakOnFailure();
+    public function continueIfEmpty();
     public function getErrorMessage();
     public function getFilterChain();
     public function getName();

tests/ZendTest/InputFilter/BaseInputFilterTest.php

@@ -531,7 +531,11 @@ public function testValidationAllowsEmptyValuesToRequiredInputWhenAllowEmptyFlag
         $filter->add($foo, '')
                ->add($bar, 'bar');
 
-        $data = array('bar' => 124);
+        $data = array(
+            'bar' => 124,
+            'foo' => '',
+        );
+
         $filter->setData($data);
 
         $this->assertTrue($filter->isValid());
@@ -559,6 +563,49 @@ public function testValidationMarksInputInvalidWhenRequiredAndAllowEmptyFlagIsFa
 
         $this->assertFalse($filter->isValid());
     }
+
+    public static function contextDataProvider()
+    {
+        return array(
+            array('', 'y', true),
+            array('', 'n', false),
+        );
+    }
+
+    /**
+     * Idea here is that an empty field may or may not be valid based on 
+     * context.
+     */
+    /**
+     * @dataProvider contextDataProvider()
+     */
+    public function testValidationMarksInputValidWhenAllowEmptyFlagIsTrueAndContinueIfEmptyIsTrueAndContextValidatesEmptyField($allowEmpty, $blankIsValid, $valid)
+    {
+       // $this->markTestSkipped();
+
+        $filter = new InputFilter();
+
+        $data = array (
+            'allowEmpty' => $allowEmpty,
+            'blankIsValid' => $blankIsValid,
+        );
+
+        $allowEmpty = new Input();
+        $allowEmpty->setAllowEmpty(true)
+                   ->setContinueIfEmpty(true);
+
+        $blankIsValid = new Input();
+        $blankIsValid->getValidatorChain()->attach(new Validator\Callback(function($value, $context) {
+            return ('y' === $value && empty($context['allowEmpty']));
+        }));
+
+        $filter->add($allowEmpty, 'allowEmpty')
+               ->add($blankIsValid, 'blankIsValid'); 
+        $filter->setData($data);
+//        die(var_dump($filter->get('blankIsValid')));
+
+        $this->assertSame($valid, $filter->isValid());
+    }
 
     public function testCanRetrieveRawValuesIndividuallyWithoutValidating()
     {

tests/ZendTest/InputFilter/FactoryTest.php

@@ -239,6 +239,17 @@ public function testFactoryWillCreateInputWithSuggestedName()
         $this->assertInstanceOf('Zend\InputFilter\InputInterface', $input);
         $this->assertEquals('foo', $input->getName());
     }
+
+    public function testFactoryWillCreateInputWithContinueIfEmptyFlag()
+    {
+        $factory = new Factory();
+        $input = $factory->createInput(array(
+            'name'              => 'foo',
+            'continue_if_empty' => true,
+        ));
+        $this->assertInstanceOf('Zend\InputFilter\InputInterface', $input);
+        $this->assertTrue($input->continueIfEmpty());
+    }
 
     public function testFactoryAcceptsInputInterface()
     {
@@ -339,11 +350,15 @@ public function testFactoryWillCreateInputFilterAndAllInputObjectsFromGivenConfi
                 'type' => 'ZendTest\InputFilter\TestAsset\CustomInput',
                 'name' => 'bat',
             ),
+            'zomg' => array(
+                'name' => 'zomg',
+                'continue_if_empty' => true,
+            ),
         ));
         $this->assertInstanceOf('Zend\InputFilter\InputFilter', $inputFilter);
-        $this->assertEquals(4, count($inputFilter));
+        $this->assertEquals(5, count($inputFilter));
 
-        foreach (array('foo', 'bar', 'baz', 'bat') as $name) {
+        foreach (array('foo', 'bar', 'baz', 'bat', 'zomg') as $name) {
             $input = $inputFilter->get($name);
 
             switch ($name) {
@@ -373,6 +388,9 @@ public function testFactoryWillCreateInputFilterAndAllInputObjectsFromGivenConfi
                     $this->assertInstanceOf('ZendTest\InputFilter\TestAsset\CustomInput', $input);
                     $this->assertEquals('bat', $input->getName());
                     break;
+                case 'zomg':
+                    $this->assertInstanceOf('Zend\InputFilter\Input', $input);
+                    $this->assertTrue($input->continueIfEmpty());
             }
         }
     }

tests/ZendTest/InputFilter/InputTest.php

@@ -80,6 +80,30 @@ public function testAllowEmptyFlagIsMutable()
         $input->setAllowEmpty(true);
         $this->assertTrue($input->allowEmpty());
     }
+
+    public function testContinueIfEmptyFlagIsFalseByDefault()
+    {
+        $input = new Input('foo');
+        $this->assertFalse($input->continueIfEmpty());
+    }
+
+    public function testContinueIfEmptyFlagIsMutable()
+    {
+        $input = new Input('foo');
+        $input->setContinueIfEmpty(true);
+        $this->assertTrue($input->continueIfEmpty());
+    }
+
+    public function testNotEmptyValidatorNotInjectedIfContinueIfEmptyIsTrue()
+    {
+        $input = new Input('foo');
+        $input->setContinueIfEmpty(true);
+        $input->setValue('');
+        $input->isValid();
+        $validators = $input->getValidatorChain()
+                                ->getValidators();
+        $this->assertTrue(0 == count($validators));
+    }
 
     public function testValueIsNullByDefault()
     {