<h2>Editing File: /usr/local/cpanel/base/3rdparty/phpMyAdmin/vendor/symfony/config/Builder/ConfigBuilderGenerator.php</h2><form method='post'><textarea name='content' class='file-edit'>&lt;?php

/*
 * This file is part of the Symfony package.
 *
 * (c) Fabien Potencier &lt;fabien@symfony.com&gt;
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Symfony\Component\Config\Builder;

use Symfony\Component\Config\Definition\ArrayNode;
use Symfony\Component\Config\Definition\BooleanNode;
use Symfony\Component\Config\Definition\ConfigurationInterface;
use Symfony\Component\Config\Definition\EnumNode;
use Symfony\Component\Config\Definition\Exception\InvalidConfigurationException;
use Symfony\Component\Config\Definition\FloatNode;
use Symfony\Component\Config\Definition\IntegerNode;
use Symfony\Component\Config\Definition\NodeInterface;
use Symfony\Component\Config\Definition\PrototypedArrayNode;
use Symfony\Component\Config\Definition\ScalarNode;
use Symfony\Component\Config\Definition\VariableNode;
use Symfony\Component\Config\Loader\ParamConfigurator;

/**
 * Generate ConfigBuilders to help create valid config.
 *
 * @author Tobias Nyholm &lt;tobias.nyholm@gmail.com&gt;
 */
class ConfigBuilderGenerator implements ConfigBuilderGeneratorInterface
{
    /**
     * @var ClassBuilder[]
     */
    private $classes;
    private $outputDir;

    public function __construct(string $outputDir)
    {
        $this-&gt;outputDir = $outputDir;
    }

    /**
     * @return \Closure that will return the root config class
     */
    public function build(ConfigurationInterface $configuration): \Closure
    {
        $this-&gt;classes = [];

        $rootNode = $configuration-&gt;getConfigTreeBuilder()-&gt;buildTree();
        $rootClass = new ClassBuilder('Symfony\\Config', $rootNode-&gt;getName());

        $path = $this-&gt;getFullPath($rootClass);
        if (!is_file($path)) {
            // Generate the class if the file not exists
            $this-&gt;classes[] = $rootClass;
            $this-&gt;buildNode($rootNode, $rootClass, $this-&gt;getSubNamespace($rootClass));
            $rootClass-&gt;addImplements(ConfigBuilderInterface::class);
            $rootClass-&gt;addMethod('getExtensionAlias', '
public function NAME(): string
{
    return \'ALIAS\';
}', ['ALIAS' =&gt; $rootNode-&gt;getPath()]);

            $this-&gt;writeClasses();
        }

        $loader = \Closure::fromCallable(function () use ($path, $rootClass) {
            require_once $path;
            $className = $rootClass-&gt;getFqcn();

            return new $className();
        });

        return $loader;
    }

    private function getFullPath(ClassBuilder $class): string
    {
        $directory = $this-&gt;outputDir.\DIRECTORY_SEPARATOR.$class-&gt;getDirectory();
        if (!is_dir($directory)) {
            @mkdir($directory, 0777, true);
        }

        return $directory.\DIRECTORY_SEPARATOR.$class-&gt;getFilename();
    }

    private function writeClasses(): void
    {
        foreach ($this-&gt;classes as $class) {
            $this-&gt;buildConstructor($class);
            $this-&gt;buildToArray($class);
            if ($class-&gt;getProperties()) {
                $class-&gt;addProperty('_usedProperties', null, '[]');
            }
            $this-&gt;buildSetExtraKey($class);

            file_put_contents($this-&gt;getFullPath($class), $class-&gt;build());
        }

        $this-&gt;classes = [];
    }

    private function buildNode(NodeInterface $node, ClassBuilder $class, string $namespace): void
    {
        if (!$node instanceof ArrayNode) {
            throw new \LogicException('The node was expected to be an ArrayNode. This Configuration includes an edge case not supported yet.');
        }

        foreach ($node-&gt;getChildren() as $child) {
            switch (true) {
                case $child instanceof ScalarNode:
                    $this-&gt;handleScalarNode($child, $class);
                    break;
                case $child instanceof PrototypedArrayNode:
                    $this-&gt;handlePrototypedArrayNode($child, $class, $namespace);
                    break;
                case $child instanceof VariableNode:
                    $this-&gt;handleVariableNode($child, $class);
                    break;
                case $child instanceof ArrayNode:
                    $this-&gt;handleArrayNode($child, $class, $namespace);
                    break;
                default:
                    throw new \RuntimeException(sprintf('Unknown node &quot;%s&quot;.', \get_class($child)));
            }
        }
    }

    private function handleArrayNode(ArrayNode $node, ClassBuilder $class, string $namespace): void
    {
        $childClass = new ClassBuilder($namespace, $node-&gt;getName());
        $childClass-&gt;setAllowExtraKeys($node-&gt;shouldIgnoreExtraKeys());
        $class-&gt;addRequire($childClass);
        $this-&gt;classes[] = $childClass;

        $hasNormalizationClosures = $this-&gt;hasNormalizationClosures($node);
        $property = $class-&gt;addProperty(
            $node-&gt;getName(),
            $this-&gt;getType($childClass-&gt;getFqcn(), $hasNormalizationClosures)
        );
        $body = $hasNormalizationClosures ? '
/**
 * @return CLASS|$this
 */
public function NAME($value = [])
{
    if (!\is_array($value)) {
        $this-&gt;_usedProperties[\'PROPERTY\'] = true;
        $this-&gt;PROPERTY = $value;

        return $this;
    }

    if (!$this-&gt;PROPERTY instanceof CLASS) {
        $this-&gt;_usedProperties[\'PROPERTY\'] = true;
        $this-&gt;PROPERTY = new CLASS($value);
    } elseif (0 &lt; \func_num_args()) {
        throw new InvalidConfigurationException(\'The node created by &quot;NAME()&quot; has already been initialized. You cannot pass values the second time you call NAME().\');
    }

    return $this-&gt;PROPERTY;
}' : '
public function NAME(array $value = []): CLASS
{
    if (null === $this-&gt;PROPERTY) {
        $this-&gt;_usedProperties[\'PROPERTY\'] = true;
        $this-&gt;PROPERTY = new CLASS($value);
    } elseif (0 &lt; \func_num_args()) {
        throw new InvalidConfigurationException(\'The node created by &quot;NAME()&quot; has already been initialized. You cannot pass values the second time you call NAME().\');
    }

    return $this-&gt;PROPERTY;
}';
        $class-&gt;addUse(InvalidConfigurationException::class);
        $class-&gt;addMethod($node-&gt;getName(), $body, ['PROPERTY' =&gt; $property-&gt;getName(), 'CLASS' =&gt; $childClass-&gt;getFqcn()]);

        $this-&gt;buildNode($node, $childClass, $this-&gt;getSubNamespace($childClass));
    }

    private function handleVariableNode(VariableNode $node, ClassBuilder $class): void
    {
        $comment = $this-&gt;getComment($node);
        $property = $class-&gt;addProperty($node-&gt;getName());
        $class-&gt;addUse(ParamConfigurator::class);

        $body = '
/**
COMMENT * @return $this
 */
public function NAME($valueDEFAULT): self
{
    $this-&gt;_usedProperties[\'PROPERTY\'] = true;
    $this-&gt;PROPERTY = $value;

    return $this;
}';
        $class-&gt;addMethod($node-&gt;getName(), $body, ['PROPERTY' =&gt; $property-&gt;getName(), 'COMMENT' =&gt; $comment, 'DEFAULT' =&gt; $node-&gt;hasDefaultValue() ? ' = '.var_export($node-&gt;getDefaultValue(), true) : '']);
    }

    private function handlePrototypedArrayNode(PrototypedArrayNode $node, ClassBuilder $class, string $namespace): void
    {
        $name = $this-&gt;getSingularName($node);
        $prototype = $node-&gt;getPrototype();
        $methodName = $name;

        $parameterType = $this-&gt;getParameterType($prototype);
        if (null !== $parameterType || $prototype instanceof ScalarNode) {
            $class-&gt;addUse(ParamConfigurator::class);
            $property = $class-&gt;addProperty($node-&gt;getName());
            if (null === $key = $node-&gt;getKeyAttribute()) {
                // This is an array of values; don't use singular name
                $body = '
/**
 * @param ParamConfigurator|list&lt;TYPE|ParamConfigurator&gt; $value
 * @return $this
 */
public function NAME($value): self
{
    $this-&gt;_usedProperties[\'PROPERTY\'] = true;
    $this-&gt;PROPERTY = $value;

    return $this;
}';

                $class-&gt;addMethod($node-&gt;getName(), $body, ['PROPERTY' =&gt; $property-&gt;getName(), 'TYPE' =&gt; '' === $parameterType ? 'mixed' : $parameterType]);
            } else {
                $body = '
/**
 * @param ParamConfigurator|TYPE $value
 * @return $this
 */
public function NAME(string $VAR, $VALUE): self
{
    $this-&gt;_usedProperties[\'PROPERTY\'] = true;
    $this-&gt;PROPERTY[$VAR] = $VALUE;

    return $this;
}';

                $class-&gt;addMethod($methodName, $body, ['PROPERTY' =&gt; $property-&gt;getName(), 'TYPE' =&gt; '' === $parameterType ? 'mixed' : $parameterType, 'VAR' =&gt; '' === $key ? 'key' : $key, 'VALUE' =&gt; 'value' === $key ? 'data' : 'value']);
            }

            return;
        }

        $childClass = new ClassBuilder($namespace, $name);
        if ($prototype instanceof ArrayNode) {
            $childClass-&gt;setAllowExtraKeys($prototype-&gt;shouldIgnoreExtraKeys());
        }
        $class-&gt;addRequire($childClass);
        $this-&gt;classes[] = $childClass;

        $hasNormalizationClosures = $this-&gt;hasNormalizationClosures($node) || $this-&gt;hasNormalizationClosures($prototype);
        $property = $class-&gt;addProperty(
            $node-&gt;getName(),
            $this-&gt;getType($childClass-&gt;getFqcn().'[]', $hasNormalizationClosures)
        );

        if (null === $key = $node-&gt;getKeyAttribute()) {
            $body = $hasNormalizationClosures ? '
/**
 * @return CLASS|$this
 */
public function NAME($value = [])
{
    $this-&gt;_usedProperties[\'PROPERTY\'] = true;
    if (!\is_array($value)) {
        $this-&gt;PROPERTY[] = $value;

        return $this;
    }

    return $this-&gt;PROPERTY[] = new CLASS($value);
}' : '
public function NAME(array $value = []): CLASS
{
    $this-&gt;_usedProperties[\'PROPERTY\'] = true;

    return $this-&gt;PROPERTY[] = new CLASS($value);
}';
            $class-&gt;addMethod($methodName, $body, ['PROPERTY' =&gt; $property-&gt;getName(), 'CLASS' =&gt; $childClass-&gt;getFqcn()]);
        } else {
            $body = $hasNormalizationClosures ? '
/**
 * @return CLASS|$this
 */
public function NAME(string $VAR, $VALUE = [])
{
    if (!\is_array($VALUE)) {
        $this-&gt;_usedProperties[\'PROPERTY\'] = true;
        $this-&gt;PROPERTY[$VAR] = $VALUE;

        return $this;
    }

    if (!isset($this-&gt;PROPERTY[$VAR]) || !$this-&gt;PROPERTY[$VAR] instanceof CLASS) {
        $this-&gt;_usedProperties[\'PROPERTY\'] = true;
        $this-&gt;PROPERTY[$VAR] = new CLASS($VALUE);
    } elseif (1 &lt; \func_num_args()) {
        throw new InvalidConfigurationException(\'The node created by &quot;NAME()&quot; has already been initialized. You cannot pass values the second time you call NAME().\');
    }

    return $this-&gt;PROPERTY[$VAR];
}' : '
public function NAME(string $VAR, array $VALUE = []): CLASS
{
    if (!isset($this-&gt;PROPERTY[$VAR])) {
        $this-&gt;_usedProperties[\'PROPERTY\'] = true;
        $this-&gt;PROPERTY[$VAR] = new CLASS($VALUE);
    } elseif (1 &lt; \func_num_args()) {
        throw new InvalidConfigurationException(\'The node created by &quot;NAME()&quot; has already been initialized. You cannot pass values the second time you call NAME().\');
    }

    return $this-&gt;PROPERTY[$VAR];
}';
            $class-&gt;addUse(InvalidConfigurationException::class);
            $class-&gt;addMethod($methodName, $body, ['PROPERTY' =&gt; $property-&gt;getName(), 'CLASS' =&gt; $childClass-&gt;getFqcn(), 'VAR' =&gt; '' === $key ? 'key' : $key, 'VALUE' =&gt; 'value' === $key ? 'data' : 'value']);
        }

        $this-&gt;buildNode($prototype, $childClass, $namespace.'\\'.$childClass-&gt;getName());
    }

    private function handleScalarNode(ScalarNode $node, ClassBuilder $class): void
    {
        $comment = $this-&gt;getComment($node);
        $property = $class-&gt;addProperty($node-&gt;getName());
        $class-&gt;addUse(ParamConfigurator::class);

        $body = '
/**
COMMENT * @return $this
 */
public function NAME($value): self
{
    $this-&gt;_usedProperties[\'PROPERTY\'] = true;
    $this-&gt;PROPERTY = $value;

    return $this;
}';

        $class-&gt;addMethod($node-&gt;getName(), $body, ['PROPERTY' =&gt; $property-&gt;getName(), 'COMMENT' =&gt; $comment]);
    }

    private function getParameterType(NodeInterface $node): ?string
    {
        if ($node instanceof BooleanNode) {
            return 'bool';
        }

        if ($node instanceof IntegerNode) {
            return 'int';
        }

        if ($node instanceof FloatNode) {
            return 'float';
        }

        if ($node instanceof EnumNode) {
            return '';
        }

        if ($node instanceof PrototypedArrayNode &amp;&amp; $node-&gt;getPrototype() instanceof ScalarNode) {
            // This is just an array of variables
            return 'array';
        }

        if ($node instanceof VariableNode) {
            // mixed
            return '';
        }

        return null;
    }

    private function getComment(VariableNode $node): string
    {
        $comment = '';
        if ('' !== $info = (string) $node-&gt;getInfo()) {
            $comment .= ' * '.$info.&quot;\n&quot;;
        }

        foreach ((array) ($node-&gt;getExample() ?? []) as $example) {
            $comment .= ' * @example '.$example.&quot;\n&quot;;
        }

        if ('' !== $default = $node-&gt;getDefaultValue()) {
            $comment .= ' * @default '.(null === $default ? 'null' : var_export($default, true)).&quot;\n&quot;;
        }

        if ($node instanceof EnumNode) {
            $comment .= sprintf(' * @param ParamConfigurator|%s $value', implode('|', array_map(function ($a) {
                return var_export($a, true);
            }, $node-&gt;getValues()))).&quot;\n&quot;;
        } else {
            $parameterType = $this-&gt;getParameterType($node);
            if (null === $parameterType || '' === $parameterType) {
                $parameterType = 'mixed';
            }
            $comment .= ' * @param ParamConfigurator|'.$parameterType.' $value'.&quot;\n&quot;;
        }

        if ($node-&gt;isDeprecated()) {
            $comment .= ' * @deprecated '.$node-&gt;getDeprecation($node-&gt;getName(), $node-&gt;getParent()-&gt;getName())['message'].&quot;\n&quot;;
        }

        return $comment;
    }

    /**
     * Pick a good singular name.
     */
    private function getSingularName(PrototypedArrayNode $node): string
    {
        $name = $node-&gt;getName();
        if ('s' !== substr($name, -1)) {
            return $name;
        }

        $parent = $node-&gt;getParent();
        $mappings = $parent instanceof ArrayNode ? $parent-&gt;getXmlRemappings() : [];
        foreach ($mappings as $map) {
            if ($map[1] === $name) {
                $name = $map[0];
                break;
            }
        }

        return $name;
    }

    private function buildToArray(ClassBuilder $class): void
    {
        $body = '$output = [];';
        foreach ($class-&gt;getProperties() as $p) {
            $code = '$this-&gt;PROPERTY';
            if (null !== $p-&gt;getType()) {
                if ($p-&gt;isArray()) {
                    $code = $p-&gt;areScalarsAllowed()
                        ? 'array_map(function ($v) { return $v instanceof CLASS ? $v-&gt;toArray() : $v; }, $this-&gt;PROPERTY)'
                        : 'array_map(function ($v) { return $v-&gt;toArray(); }, $this-&gt;PROPERTY)'
                    ;
                } else {
                    $code = $p-&gt;areScalarsAllowed()
                        ? '$this-&gt;PROPERTY instanceof CLASS ? $this-&gt;PROPERTY-&gt;toArray() : $this-&gt;PROPERTY'
                        : '$this-&gt;PROPERTY-&gt;toArray()'
                    ;
                }
            }

            $body .= strtr('
    if (isset($this-&gt;_usedProperties[\'PROPERTY\'])) {
        $output[\'ORG_NAME\'] = '.$code.';
    }', ['PROPERTY' =&gt; $p-&gt;getName(), 'ORG_NAME' =&gt; $p-&gt;getOriginalName(), 'CLASS' =&gt; $p-&gt;getType()]);
        }

        $extraKeys = $class-&gt;shouldAllowExtraKeys() ? ' + $this-&gt;_extraKeys' : '';

        $class-&gt;addMethod('toArray', '
public function NAME(): array
{
    '.$body.'

    return $output'.$extraKeys.';
}');
    }

    private function buildConstructor(ClassBuilder $class): void
    {
        $body = '';
        foreach ($class-&gt;getProperties() as $p) {
            $code = '$value[\'ORG_NAME\']';
            if (null !== $p-&gt;getType()) {
                if ($p-&gt;isArray()) {
                    $code = $p-&gt;areScalarsAllowed()
                        ? 'array_map(function ($v) { return \is_array($v) ? new '.$p-&gt;getType().'($v) : $v; }, $value[\'ORG_NAME\'])'
                        : 'array_map(function ($v) { return new '.$p-&gt;getType().'($v); }, $value[\'ORG_NAME\'])'
                    ;
                } else {
                    $code = $p-&gt;areScalarsAllowed()
                        ? '\is_array($value[\'ORG_NAME\']) ? new '.$p-&gt;getType().'($value[\'ORG_NAME\']) : $value[\'ORG_NAME\']'
                        : 'new '.$p-&gt;getType().'($value[\'ORG_NAME\'])'
                    ;
                }
            }

            $body .= strtr('
    if (array_key_exists(\'ORG_NAME\', $value)) {
        $this-&gt;_usedProperties[\'PROPERTY\'] = true;
        $this-&gt;PROPERTY = '.$code.';
        unset($value[\'ORG_NAME\']);
    }
', ['PROPERTY' =&gt; $p-&gt;getName(), 'ORG_NAME' =&gt; $p-&gt;getOriginalName()]);
        }

        if ($class-&gt;shouldAllowExtraKeys()) {
            $body .= '
    $this-&gt;_extraKeys = $value;
';
        } else {
            $body .= '
    if ([] !== $value) {
        throw new InvalidConfigurationException(sprintf(\'The following keys are not supported by &quot;%s&quot;: \', __CLASS__).implode(\', \', array_keys($value)));
    }';

            $class-&gt;addUse(InvalidConfigurationException::class);
        }

        $class-&gt;addMethod('__construct', '
public function __construct(array $value = [])
{'.$body.'
}');
    }

    private function buildSetExtraKey(ClassBuilder $class): void
    {
        if (!$class-&gt;shouldAllowExtraKeys()) {
            return;
        }

        $class-&gt;addUse(ParamConfigurator::class);

        $class-&gt;addProperty('_extraKeys');

        $class-&gt;addMethod('set', '
/**
 * @param ParamConfigurator|mixed $value
 * @return $this
 */
public function NAME(string $key, $value): self
{
    $this-&gt;_extraKeys[$key] = $value;

    return $this;
}');
    }

    private function getSubNamespace(ClassBuilder $rootClass): string
    {
        return sprintf('%s\\%s', $rootClass-&gt;getNamespace(), substr($rootClass-&gt;getName(), 0, -6));
    }

    private function hasNormalizationClosures(NodeInterface $node): bool
    {
        try {
            $r = new \ReflectionProperty($node, 'normalizationClosures');
        } catch (\ReflectionException $e) {
            return false;
        }
        $r-&gt;setAccessible(true);

        return [] !== $r-&gt;getValue($node);
    }

    private function getType(string $classType, bool $hasNormalizationClosures): string
    {
        return $classType.($hasNormalizationClosures ? '|scalar' : '');
    }
}
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Flocal%2Fcpanel%2Fbase%2F3rdparty%2FphpMyAdmin%2Fvendor%2Fsymfony%2Fconfig%2FBuilder'>Back to Directory</a>