vendor/symfony/symfony/src/Symfony/Component/Config/Definition/VariableNode.php line 51

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\Config\Definition;
  14. use Symfony\Component\Config\Definition\Exception\InvalidConfigurationException;
  16. /**
  17.  * This node represents a value of variable type in the config tree.
  18.  *
  19.  * This node is intended for values of arbitrary type.
  20.  * Any PHP type is accepted as a value.
  21.  *
  22.  * @author Jeremy Mikola <jmikola@gmail.com>
  23.  */
  24. class VariableNode extends BaseNode implements PrototypeNodeInterface
  25. {
  26.     protected $defaultValueSet = false;
  27.     protected $defaultValue;
  28.     protected $allowEmptyValue = true;
  30.     public function setDefaultValue($value)
  31.     {
  32.         $this->defaultValueSet = true;
  33.         $this->defaultValue = $value;
  34.     }
  36.     /**
  37.      * {@inheritdoc}
  38.      */
  39.     public function hasDefaultValue()
  40.     {
  41.         return $this->defaultValueSet;
  42.     }
  44.     /**
  45.      * {@inheritdoc}
  46.      */
  47.     public function getDefaultValue()
  48.     {
  49.         $v = $this->defaultValue;
  51.         return $v instanceof \Closure ? $v() : $v;
  52.     }
  54.     /**
  55.      * Sets if this node is allowed to have an empty value.
  56.      *
  57.      * @param bool $boolean True if this entity will accept empty values
  58.      */
  59.     public function setAllowEmptyValue($boolean)
  60.     {
  61.         $this->allowEmptyValue = (bool) $boolean;
  62.     }
  64.     /**
  65.      * {@inheritdoc}
  66.      */
  67.     public function setName($name)
  68.     {
  69.         $this->name = $name;
  70.     }
  72.     /**
  73.      * {@inheritdoc}
  74.      */
  75.     protected function validateType($value)
  76.     {
  77.     }
  79.     /**
  80.      * {@inheritdoc}
  81.      */
  82.     protected function finalizeValue($value)
  83.     {
  84.         // deny environment variables only when using custom validators
  85.         // this avoids ever passing an empty value to final validation closures
  86.         if (!$this->allowEmptyValue && $this->isHandlingPlaceholder() && $this->finalValidationClosures) {
  87.             @trigger_error(sprintf('Setting path "%s" to an environment variable is deprecated since Symfony 4.3. Remove "cannotBeEmpty()", "validate()" or include a prefix/suffix value instead.', $this->getPath()), E_USER_DEPRECATED);
  88. //            $e = new InvalidConfigurationException(sprintf('The path "%s" cannot contain an environment variable when empty values are not allowed by definition and are validated.', $this->getPath()));
  89. //            if ($hint = $this->getInfo()) {
  90. //                $e->addHint($hint);
  91. //            }
  92. //            $e->setPath($this->getPath());
  93. //
  94. //            throw $e;
  95.         }
  97.         if (!$this->allowEmptyValue && $this->isValueEmpty($value)) {
  98.             $ex = new InvalidConfigurationException(sprintf('The path "%s" cannot contain an empty value, but got %s.', $this->getPath(), json_encode($value)));
  99.             if ($hint = $this->getInfo()) {
  100.                 $ex->addHint($hint);
  101.             }
  102.             $ex->setPath($this->getPath());
  104.             throw $ex;
  105.         }
  107.         return $value;
  108.     }
  110.     /**
  111.      * {@inheritdoc}
  112.      */
  113.     protected function normalizeValue($value)
  114.     {
  115.         return $value;
  116.     }
  118.     /**
  119.      * {@inheritdoc}
  120.      */
  121.     protected function mergeValues($leftSide, $rightSide)
  122.     {
  123.         return $rightSide;
  124.     }
  126.     /**
  127.      * Evaluates if the given value is to be treated as empty.
  128.      *
  129.      * By default, PHP's empty() function is used to test for emptiness. This
  130.      * method may be overridden by subtypes to better match their understanding
  131.      * of empty data.
  132.      *
  133.      * @param mixed $value
  134.      *
  135.      * @return bool
  136.      *
  137.      * @see finalizeValue()
  138.      */
  139.     protected function isValueEmpty($value)
  140.     {
  141.         return empty($value);
  142.     }
  143. }