312 lines
8.1 KiB
PHP
312 lines
8.1 KiB
PHP
<?php
|
|
|
|
/*
|
|
* This file is part of the Symfony package.
|
|
*
|
|
* (c) Fabien Potencier <fabien.potencier@symfony-project.com>
|
|
*
|
|
* For the full copyright and license information, please view the LICENSE
|
|
* file that was distributed with this source code.
|
|
*/
|
|
|
|
namespace Symfony\Component\Config\Definition\Builder;
|
|
|
|
use Symfony\Component\Config\Definition\ArrayNode;
|
|
use Symfony\Component\Config\Definition\PrototypedArrayNode;
|
|
use Symfony\Component\Config\Definition\NodeInterface;
|
|
|
|
/**
|
|
* This class provides a fluent interface for defining an array node.
|
|
*
|
|
* @author Johannes M. Schmitt <schmittjoh@gmail.com>
|
|
*/
|
|
class ArrayNodeDefinition extends NodeDefinition implements ParentNodeDefinitionInterface
|
|
{
|
|
protected $performDeepMerging;
|
|
protected $ignoreExtraKeys;
|
|
protected $children;
|
|
protected $prototype;
|
|
protected $atLeastOne;
|
|
protected $allowNewKeys;
|
|
protected $key;
|
|
protected $removeKeyItem;
|
|
protected $addDefaults;
|
|
protected $nodeBuilder;
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
*/
|
|
public function __construct($name, NodeParentInterface $parent = null)
|
|
{
|
|
parent::__construct($name, $parent);
|
|
|
|
$this->children = array();
|
|
$this->addDefaults = false;
|
|
$this->allowNewKeys = true;
|
|
$this->atLeastOne = false;
|
|
$this->allowEmptyValue = true;
|
|
$this->performDeepMerging = true;
|
|
$this->nullEquivalent = array();
|
|
$this->trueEquivalent = array();
|
|
}
|
|
|
|
/**
|
|
* Set a custom children builder
|
|
*
|
|
* @param NodeBuilder $class A custom NodeBuilder
|
|
*/
|
|
public function setBuilder(NodeBuilder $builder)
|
|
{
|
|
$this->nodeBuilder = $builder;
|
|
}
|
|
|
|
/**
|
|
* Returns a builder to add children nodes
|
|
*
|
|
* @return NodeBuilder
|
|
*/
|
|
public function children()
|
|
{
|
|
return $this->getNodeBuilder();
|
|
}
|
|
|
|
/**
|
|
* Sets a prototype for child nodes.
|
|
*
|
|
* @param string $type the type of node
|
|
*
|
|
* @return NodeDefinition
|
|
*/
|
|
public function prototype($type)
|
|
{
|
|
$builder = $this->getNodeBuilder();
|
|
$this->prototype = $builder->node(null, $type);
|
|
$this->prototype->parent = $this;
|
|
|
|
return $this->prototype;
|
|
}
|
|
|
|
/**
|
|
* Adds the default value if the node is not set in the configuration.
|
|
*
|
|
* @return ArrayNodeDefinition
|
|
*/
|
|
public function addDefaultsIfNotSet()
|
|
{
|
|
$this->addDefaults = true;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Requires the node to have at least one element.
|
|
*
|
|
* @return ArrayNodeDefinition
|
|
*/
|
|
public function requiresAtLeastOneElement()
|
|
{
|
|
$this->atLeastOne = true;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Disallows adding news keys in a subsequent configuration.
|
|
*
|
|
* If used all keys have to be defined in the same configuration file.
|
|
*
|
|
* @return ArrayNodeDefinition
|
|
*/
|
|
public function disallowNewKeysInSubsequentConfigs()
|
|
{
|
|
$this->allowNewKeys = false;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Sets a normalization rule for XML configurations.
|
|
*
|
|
* @param string $singular The key to remap
|
|
* @param string $plural The plural of the key for irregular plurals
|
|
*
|
|
* @return ArrayNodeDefinition
|
|
*/
|
|
public function fixXmlConfig($singular, $plural = null)
|
|
{
|
|
$this->normalization()->remap($singular, $plural);
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Set the attribute which value is to be used as key.
|
|
*
|
|
* This is useful when you have an indexed array that should be an
|
|
* associative array. You can select an item from within the array
|
|
* to be the key of the particular item. For example, if "id" is the
|
|
* "key", then:
|
|
*
|
|
* array(
|
|
* array('id' => 'my_name', 'foo' => 'bar'),
|
|
* )
|
|
*
|
|
* becomes
|
|
*
|
|
* array(
|
|
* 'my_name' => array('foo' => 'bar'),
|
|
* )
|
|
*
|
|
* If you'd like "'id' => 'my_name'" to still be present in the resulting
|
|
* array, then you can set the second argument of this method to false.
|
|
*
|
|
* @param string $name The name of the key
|
|
* @param Boolean $removeKeyItem Whether or not the key item should be removed.
|
|
*
|
|
* @return ArrayNodeDefinition
|
|
*/
|
|
public function useAttributeAsKey($name, $removeKeyItem = true)
|
|
{
|
|
$this->key = $name;
|
|
$this->removeKeyItem = $removeKeyItem;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Sets whether the node can be unset.
|
|
*
|
|
* @param Boolean $allow
|
|
*
|
|
* @return ArrayNodeDefinition
|
|
*/
|
|
public function canBeUnset($allow = true)
|
|
{
|
|
$this->merge()->allowUnset($allow);
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Disables the deep merging of the node.
|
|
*
|
|
* @return ArrayNodeDefinition
|
|
*/
|
|
public function performNoDeepMerging()
|
|
{
|
|
$this->performDeepMerging = false;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Allows extra config keys to be specified under an array without
|
|
* throwing an exception.
|
|
*
|
|
* Those config values are simply ignored. This should be used only
|
|
* in special cases where you want to send an entire configuration
|
|
* array through a special tree that processes only part of the array.
|
|
*
|
|
* @return ArrayNodeDefinition
|
|
*/
|
|
public function ignoreExtraKeys()
|
|
{
|
|
$this->ignoreExtraKeys = true;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Append a node definition.
|
|
*
|
|
* $node = new ArrayNodeDefinition()
|
|
* ->children()
|
|
* ->scalarNode('foo')
|
|
* ->scalarNode('baz')
|
|
* ->end()
|
|
* ->append($this->getBarNodeDefinition())
|
|
* ;
|
|
*
|
|
* @return ArrayNodeDefinition This node
|
|
*/
|
|
public function append(NodeDefinition $node)
|
|
{
|
|
$this->children[$node->name] = $node->setParent($this);
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Returns a node builder to be used to add children and protoype
|
|
*
|
|
* @return NodeBuilder The node builder
|
|
*/
|
|
protected function getNodeBuilder()
|
|
{
|
|
if (null === $this->nodeBuilder) {
|
|
$this->nodeBuilder = new NodeBuilder();
|
|
}
|
|
|
|
return $this->nodeBuilder->setParent($this);
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
*/
|
|
protected function createNode()
|
|
{
|
|
if (null == $this->prototype) {
|
|
$node = new ArrayNode($this->name, $this->parent);
|
|
} else {
|
|
$node = new PrototypedArrayNode($this->name, $this->parent);
|
|
}
|
|
|
|
$node->setAddIfNotSet($this->addDefaults);
|
|
$node->setAllowNewKeys($this->allowNewKeys);
|
|
$node->addEquivalentValue(null, $this->nullEquivalent);
|
|
$node->addEquivalentValue(true, $this->trueEquivalent);
|
|
$node->addEquivalentValue(false, $this->falseEquivalent);
|
|
$node->setPerformDeepMerging($this->performDeepMerging);
|
|
$node->setRequired($this->required);
|
|
$node->setIgnoreExtraKeys($this->ignoreExtraKeys);
|
|
|
|
if (null !== $this->normalization) {
|
|
$node->setNormalizationClosures($this->normalization->before);
|
|
$node->setXmlRemappings($this->normalization->remappings);
|
|
}
|
|
|
|
if (null !== $this->merge) {
|
|
$node->setAllowOverwrite($this->merge->allowOverwrite);
|
|
$node->setAllowFalse($this->merge->allowFalse);
|
|
}
|
|
|
|
if (null !== $this->validation) {
|
|
$node->setFinalValidationClosures($this->validation->rules);
|
|
}
|
|
|
|
if (null == $this->prototype) {
|
|
foreach ($this->children as $child) {
|
|
$child->parent = $node;
|
|
$node->addChild($child->getNode());
|
|
}
|
|
} else {
|
|
if (null !== $this->key) {
|
|
$node->setKeyAttribute($this->key, $this->removeKeyItem);
|
|
}
|
|
|
|
if (true === $this->atLeastOne) {
|
|
$node->setMinNumberOfElements(1);
|
|
}
|
|
|
|
if (null !== $this->defaultValue) {
|
|
$node->setDefaultValue($this->defaultValue);
|
|
}
|
|
|
|
$this->prototype->parent = $node;
|
|
$node->setPrototype($this->prototype->getNode());
|
|
}
|
|
|
|
return $node;
|
|
}
|
|
|
|
} |