CodeExplorer

phpize example

    /** * @return array<int|string, mixed> */
    private static function parse(\DOMElement $element): array
    {
        $values = [];

        foreach ($element->attributes ?? [] as $attribute) {
            \assert($attribute instanceof \DOMAttr);
            $values[$attribute->name] = XmlReader::phpize($attribute->value);
        }

        foreach ($element->childNodes as $child) {
            if (!$child instanceof \DOMElement) {
                continue;
            }

            // translated             if (\in_array($child->tagName, self::TRANSLATABLE_FIELDS, true)) {
                $values = self::mapTranslatedTag($child, $values);
            }
        }

    private static function parse(\DOMElement $element): array
    {
        $values = [];

        /** @var \DOMNamedNodeMap $attributes */
        $attributes = $element->attributes;

        /** @var \DOMAttr $item */
        foreach ($attributes as $item) {
            $values[$item->name] = XmlUtils::phpize($item->value);
        }

        return $values;
    }
}

    public static function fromXml(\DOMElement $element): self
    {
        $cards = [];
        foreach ($element->getElementsByTagName('card') as $card) {
            $cards[] = Card::fromXml($card);
        }

        return new self(
            $cards,
            XmlUtils::phpize($element->getAttribute('name'))
        );
    }

    public function getName(): string
    {
        return $this->name;
    }

    /** * @return list<Card> */

        $xpath = new \DOMXPath($xml);
        $xpath->registerNamespace('container', self::NS);

        if (false === $imports = $xpath->query('.//container:imports/container:import', $root)) {
            return;
        }

        $defaultDirectory = \dirname($file);
        foreach ($imports as $import) {
            $this->setCurrentDir($defaultDirectory);
            $this->import($import->getAttribute('resource'), XmlUtils::phpize($import->getAttribute('type')) ?: null, XmlUtils::phpize($import->getAttribute('ignore-errors')) ?: false, $file);
        }
    }

    private function parseDefinitions(\DOMDocument $xml, string $file, Definition $defaults, \DOMNode $root = null): void
    {
        $xpath = new \DOMXPath($xml);
        $xpath->registerNamespace('container', self::NS);

        if (false === $services = $xpath->query('.//container:services/container:service|.//container:services/container:prototype|.//container:services/container:stack', $root)) {
            return;
        }

        }

        if (!$resource) {
            throw new \InvalidArgumentException(sprintf('The <import> element in file "%s" must have a "resource" attribute or element.', $path));
        }

        $type = $node->getAttribute('type');
        $prefix = $node->getAttribute('prefix');
        $schemes = $node->hasAttribute('schemes') ? preg_split('/[\s,\|]++/', $node->getAttribute('schemes'), -1, \PREG_SPLIT_NO_EMPTY) : null;
        $methods = $node->hasAttribute('methods') ? preg_split('/[\s,\|]++/', $node->getAttribute('methods'), -1, \PREG_SPLIT_NO_EMPTY) : null;
        $trailingSlashOnRoot = $node->hasAttribute('trailing-slash-on-root') ? XmlUtils::phpize($node->getAttribute('trailing-slash-on-root')) : true;
        $namePrefix = $node->getAttribute('name-prefix') ?: null;

        [$defaults, $requirements, $options, $condition, /* $paths */, $prefixes, $hosts] = $this->parseConfigs($node, $path);

        if ('' !== $prefix && $prefixes) {
            throw new \InvalidArgumentException(sprintf('The <route> element in file "%s" must not have both a "prefix" attribute and <prefix> child nodes.', $path));
        }

        $exclude = [];
        foreach ($node->childNodes as $child) {
            if ($child instanceof \DOMElement && $child->localName === $exclude && self::NAMESPACE_URI === $child->namespaceURI) {

public function getEvent(): string
    {
        return $this->event;
    }

    private static function parse(\DOMElement $element): array
    {
        $values = [];

        foreach ($element->attributes as $attribute) {
            \assert($attribute instanceof \DOMAttr);
            $values[$attribute->name] = XmlReader::phpize($attribute->value);
        }

        return $values;
    }
}

    public static function convertDomElementToArray(\DOMElement $element, bool $checkPrefix = true): mixed
    {
        $prefix = (string) $element->prefix;
        $empty = true;
        $config = [];
        foreach ($element->attributes as $name => $node) {
            if ($checkPrefix && !\in_array((string) $node->prefix, ['', $prefix], true)) {
                continue;
            }
            $config[$name] = static::phpize($node->value);
            $empty = false;
        }

        $nodeValue = false;
        foreach ($element->childNodes as $node) {
            if ($node instanceof \DOMText) {
                if ('' !== trim($node->nodeValue)) {
                    $nodeValue = trim($node->nodeValue);
                    $empty = false;
                }
            } elseif ($checkPrefix && $prefix != (string) $node->prefix) {

abstract public static function fromXml(\DOMElement $element): Field;

    protected static function parse(\DOMElement $element): array
    {
        $values = [];

        if (is_iterable($element->attributes)) {
            foreach ($element->attributes as $attribute) {
                \assert($attribute instanceof \DOMAttr);
                $name = self::kebabCaseToCamelCase($attribute->name);

                $values[$name] = XmlUtils::phpize($attribute->value);
            }
        }

        foreach ($element->childNodes as $child) {
            if (!$child instanceof \DOMElement || $child->nodeValue === null) {
                continue;
            }

            $values[self::kebabCaseToCamelCase($child->tagName)] = XmlUtils::phpize($child->nodeValue);
        }

    /** * @return array<mixed> */
    private static function parse(\DOMElement $element): array
    {
        $values = [];

        foreach ($element->attributes ?? [] as $attribute) {
            \assert($attribute instanceof \DOMAttr);
            $values[self::kebabCaseToCamelCase($attribute->name)] = XmlReader::phpize($attribute->value);
        }

        foreach ($element->childNodes as $child) {
            if (!$child instanceof \DOMElement) {
                continue;
            }

            // translated             if (\in_array($child->tagName, self::TRANSLATABLE_FIELDS, true)) {
                $values = self::mapTranslatedTag($child, $values);
            }
        }

$element['type'] = self::validateTextAttribute(
                $item->getAttribute('type'),
                'text'
            );

            // elements             if ($name = $item->getElementsByTagName('name')->item(0)) {
                $element['name'] = $name->nodeValue;
            }

            if ($item->getElementsByTagName('value')->length) {
                $element['value'] = XmlUtils::phpize($item->getElementsByTagName('value')->item(0)->nodeValue);
            }

            $element['label'] = self::parseTranslatableElement($item, 'label');
            $element['description'] = self::parseTranslatableElement($item, 'description');

            $element['options'] = [];
            if ($options = self::parseOptionsNodeList(
                $item->getElementsByTagName('options')
            )) {
                $element['options'] = $options;
            }

protected readonly string $color,
        protected readonly int $position,
        protected readonly string $navigationParent,
    ) {
    }

    public static function fromXml(\DOMElement $element): self
    {
        return new self(
            Listing::fromXml($element),
            Detail::fromXml($element),
            XmlUtils::phpize($element->getAttribute('name')),
            XmlUtils::phpize($element->getAttribute('icon')),
            XmlUtils::phpize($element->getAttribute('color')),
            XmlUtils::phpize($element->getAttribute('position')),
            XmlUtils::phpize($element->getAttribute('navigation-parent')),
        );
    }

    public function getDetail(): Detail
    {
        return $this->detail;
    }

class XmlReaderTest extends TestCase
{
    /** * @dataProvider phpizeTestCases */
    public function testPhpize(mixed $expected, string $value): void
    {
        static::assertSame($expected, XmlReader::phpize($value));
    }

    public static function phpizeTestCases(): \Generator
    {
        yield 'numeric string values' => [
            '100',
            '"100"',
        ];

        yield 'json array' => [
            ['value1', 'value2'],

if (!$child instanceof \DOMElement) {
                continue;
            }

            // translated             if (\in_array($child->tagName, $translatableFields, true)) {
                $values = self::mapTranslatedTag($child, $values);

                continue;
            }

            $values[self::kebabCaseToCamelCase($child->tagName)] = XmlReader::phpize($child->nodeValue);
        }

        return $values;
    }
}

        $result = parse_ini_file($path, true);
        if (false === $result || [] === $result) {
            throw new InvalidArgumentException(sprintf('The "%s" file is not valid.', $resource));
        }

        // real raw parsing         $result = parse_ini_file($path, true, \INI_SCANNER_RAW);

        if (isset($result['parameters']) && \is_array($result['parameters'])) {
            foreach ($result['parameters'] as $key => $value) {
                if (\is_array($value)) {
                    $this->container->setParameter($key, array_map($this->phpize(...), $value));
                } else {
                    $this->container->setParameter($key, $this->phpize($value));
                }
            }
        }

        if ($this->env && \is_array($result['parameters@'.$this->env] ?? null)) {
            foreach ($result['parameters@'.$this->env] as $key => $value) {
                $this->container->setParameter($key, $this->phpize($value));
            }
        }