Question

Sometimes happen that a collection of values is stored in a database as a unique string. This string is so made of all the values separated by a user-defined delimiter (e.g. “,” or “_”).

What would be nice in a Symfony2.1 application is to have a Validation Constraint that validates a string (e.g. provided by an input text form) by counting the number of tokens included in that string.

A possible example is when you store the tags in a string format, i.e. you receive a string from an input field like value1,value2,value10,value25. You see that 4 tokens are passed, but there is no form validator that does that control for you. So, one should use such a validator like:

/**
* @Assert\Token(
     *      delimiter=",", 
     *      min = "1",
     *      max = "5",
     *      minMessage = "You must specify at least one token",
     *      maxMessage = "You cannot specify more than 5 tokens")
*/ 
$tags;

There is something similar when using the new in Symfony2.1 Count validator, but is doesn’t work on strings, just on array of objects that implements Countable.

Who know how to implement that kind of “tokenized string” validator?

Answer 1

I solved my problem, I just want to share my solutions.

One possible solution is to use a Callback constraint. For instance, following the tag list example provided in the question:

/**
 * @Assert\Callback(methods={"isTagStringValid"})
 */
class AFormModel{

protected $tags;

    public function isTagStringValid(ExecutionContext $context){
        $tagsExploded = explode(',', $this->tags);

        if(count($tagsExploded)==0){
            $context->addViolationAtSubPath('tags', 'Insert at least a tag', array(), null);    
        }
        if(count($tagsExploded)==1 && $tagsExploded[0]==='')
            $context->addViolationAtSubPath('tags', 'Insert at least a tag', array(), null);            
        }
        else if(count($tagsExploded)>10){
            $context->addViolationAtSubPath('tags', 'Max 10 values', array(), null);            
        }
    }

}

---

A more elegant way is to define the “Token” validator. An example follows here:

namespace .....

use Symfony\Component\Validator\Constraint;

/**
  * @Annotation
*/
class Token extends Constraint {
    public $min;
    public $max;
    public $minMessage = '{{ min }} token(s) are expected';
    public $maxMessage = '{{ max }} token(s) are expected';
    public $invalidMessage = 'This value should be a string.';   
    public $delimiter = ',';
public function __construct($options = null){
    parent::__construct($options);

    if (null === $this->min && null === $this->max) {
        throw new MissingOptionsException('Either option "min" or "max" must be given for constraint ' . __CLASS__, array('min', 'max'));
    }
}    

}

And the validator class is:

namespace ...

use Symfony\Component\Validator\Constraint;
use Symfony\Component\Validator\ConstraintValidator;

class TokenValidator extends ConstraintValidator {
    public function isValid($value, Constraint $constraint) {
        if ($value === null) {
            return;
        }
        if(!is_string($value)){
            $this->context->addViolation($constraint->invalidMessage, array(
                '{{ value }}' => $value,
            ));

            return;
        }

        $tokensExploded = explode($constraint->delimiter, $value);
        $tokens = count($tokensExploded);
        if($tokens==1){
            if($tokensExploded[0]==='')
                $tokens = 0;
        }

        if (null !== $constraint->max && $tokens > $constraint->max) {
            $this->context->addViolation($constraint->maxMessage, array(
                '{{ value }}' => $value,
                '{{ limit }}' => $constraint->max,
            ));

            return;
        }
        if (null !== $constraint->min && $tokens < $constraint->min) {
            $this->context->addViolation($constraint->minMessage, array(
                '{{ value }}' => $value,
                '{{ limit }}' => $constraint->min,
            ));
        }        
    }
}

In this way you can import the user-defined validator and use it everywhere like I proposed in my question.