gyselroth / micro

src/Config/Xml.php

<?php
declare(strict_types = 1);

/**
 * Micro
 *
 * @author    Raffael Sahli <sahli@gyselroth.net>
 * @copyright Copyright (c) 2017 gyselroth GmbH (https://gyselroth.com)
 * @license   MIT https://opensource.org/licenses/MIT
 */

namespace Micro\Config;

use \Micro\Config;
use \SimpleXMLElement;

class Xml implements ConfigInterface
{
    /**
     * Config features namespace
     */
    const CONFIG_FEATURE_NAMESPACE = 'https://github.com/gyselroth/micro';

    /**
     * Config features namespace prefix
     */
    const CONFIG_FEATURE_NAMESPACE_PREFIX = 'm';


    /**
     * Store
     *
     * @var SimpleXML
     */
    private $store;


    /**
     * Load config
     *
     * @param   string $config
     * @param   string $env
     * @return  void

Adding a @return annotation to constructors is generally not recommended as a constructor does not have a meaningful return value.

     */
    public function __construct(string $config, string $env = 'production')
    {
        $config = simplexml_load_file($config);
        if ($this->store === false) {
            throw new Exception('failed load xml configuration');
        }

        $store = (array)$config->children();
        if (!isset($store[$env])) {
            throw new Exception('env '.$env.' is not configured');
        }

        $config = $store[$env];

        foreach ($store as $reg) {
            $result = $reg->xpath('/config/'.$reg->getName().'//*[@'.self::CONFIG_FEATURE_NAMESPACE_PREFIX.':inherits]');
            while (list(, $node) = each($result)) {
                $path = (string)$node->attributes(self::CONFIG_FEATURE_NAMESPACE)->inherits;

                if ($path === '') {
                    continue;
                }

                $xpath = '/config/'.$reg->getName().'/'.str_replace('.', '/', $path).'';
                $found = $reg->xpath($xpath);
                if (count($found) !== 1) {
                    throw new Exception('inherits '.$xpath.' not found');
                }

                unset($node->attributes(self::CONFIG_FEATURE_NAMESPACE)->inherits);
                $found = array_shift($found);

                $temp = clone $found;
                $this->appendSimplexml($temp, $node);
                $this->appendSimplexml($node, $temp);
            }
        }

        $attrs = $store[$env]->attributes(self::CONFIG_FEATURE_NAMESPACE);
        if (isset($attrs['inherits'])) {
            if (!isset($store[(string)$attrs['inherits']])) {
                throw new Exception('parent env '.$attrs['inherits'].' is not configured');
            } else {
                $this->appendSimplexml($store[(string)$attrs['inherits']], $config);
            }
        }

        $this->store = $config;
    }


    /**
     * Merge xml tree's
     *
     * @param   SimpleXMLElement $simplexml_to
     * @param   SimpleXMLElement $simplexml_from
     * @return  bool
     */
    protected function appendSimplexml(SimpleXMLElement&$simplexml_to, SimpleXMLElement&$simplexml_from): bool
    {
        if (count($simplexml_from->children()) === 0) {
            if (count($simplexml_to->children()) === 0) {
                $simplexml_to[0] = htmlspecialchars((string)$simplexml_from);
            }
        }
        $attrs = $simplexml_to->attributes();
        foreach ($simplexml_from->attributes() as $attr_key => $attr_value) {
            if (!isset($attrs[$attr_key])) {
                $simplexml_to->addAttribute($attr_key, (string)$attr_value);
            } else {
                $simplexml_to->attributes()->{$attr_key} = (string)$attr_value;
            }
        }
        foreach ($simplexml_from->children() as $simplexml_child) {
            if (count($simplexml_child->children()) === 0) {
                if (!isset($simplexml_to->{$simplexml_child->getName()})) {
                    $simplexml_to->addChild($simplexml_child->getName(), htmlspecialchars((string)$simplexml_child));
                } elseif(count($simplexml_to->{$simplexml_child->getName()}->children()) === 0) {
                    $simplexml_to->{$simplexml_child->getName()} = htmlspecialchars((string)$simplexml_child);
                }
            } else {
                $this->appendSimplexml($simplexml_to->{$simplexml_child->getName()}, $simplexml_child, $replace);

The variable $replace does not exist. Did you forget to declare it?

The call to Xml::appendSimplexml() has too many arguments starting with $replace.

            }
            $attrs = $simplexml_to->{$simplexml_child->getName()}->attributes();
            foreach ($simplexml_child->attributes() as $attr_key => $attr_value) {
                if (!isset($attrs[$attr_key])) {
                    $simplexml_to->{$simplexml_child->getName()}->addAttribute($attr_key, (string)$attr_value);
                } else {
                    $simplexml_to->{$simplexml_child->getName()}->attributes()->{$attr_key} = (string)$attr_value;
                }
            }
        }

        return true;
    }


    /**
     * Get entire simplexml
     *
     * @return SimpleXMLElement
     */
    public function getRaw(): SimpleXMLElement
    {
        return $this->store;
    }


    /**
     * Get from config
     *
     * @param   string $name
     * @return  SimpleXMLElement
     */
    public function __get(string $name): SimpleXMLElement
    {
        return $this->store->{$name};
    }


    /**
     * Add config tree and merge it
     *
     * @param   ConfigInterface $config
     * @return  ConfigInterface
     */
    public function merge($config): ConfigInterface
    {
        $merge = $config->getRaw();

It seems like you code against a concrete implementation and not the interface Micro\Config\ConfigInterface as the method getRaw() does only exist in the following implementations of said interface: Micro\Config\Xml.

        $this->appendSimplexml($this->store, $merge);

        $result = $this->store->xpath('//*[@reference]');
        while (list(, $node) = each($result)) {
            $path = (string)$node->attributes()->reference;

            if ($path === '') {
                continue;
            }

            $xpath = '//'.str_replace('.', '/', $path);
            $found = $this->store->xpath($xpath);
            if (count($found) !== 1) {
                continue;
            }

            $found = array_shift($found);
            $this->appendSimplexml($node, $found);
        }

        return $this;
    }


    /**
     * Get xml as config
     *
     * @param   SimpleXMLElement $xml
     * @return  Config
     */
    public function map(?SimpleXMLElement $xml = null): Config
    {
        if ($xml === null) {
            $xml = $this->store;
        }

        $config = new Config();
        foreach ($xml->getNamespaces() + [null] as $prefix => $namespace) {
            if($prefix === self::CONFIG_FEATURE_NAMESPACE_PREFIX) {

The strict comparison === seems to always evaluate to false as the types of $prefix (integer) and self::CONFIG_FEATURE_NAMESPACE_PREFIX (string) can never be identical. Maybe you want to use a loose comparison == instead?

                continue;
            }

            foreach ($xml->attributes($namespace) as $key => $value) {
                if (is_string($prefix)) {
                    $key = $prefix.'.'.$key;
                }

                if ($key === 'reference') {
                    continue;
                }

                $config[$key] = (string)$value;
            }
        }

        foreach ($xml as $name => $element) {
            if(isset($element->attributes(self::CONFIG_FEATURE_NAMESPACE)->name)) {
                $name = (string)$element->attributes(self::CONFIG_FEATURE_NAMESPACE)->name;
            }

            $value = $element->children() ? $this->map($element) : trim((string)$element);
            if ($value || $value === '0') {
                if (!isset($arr[$name])) {
                    $config[$name] = $value;
                } else {
                    foreach ((array)$value as $k => $v) {
                        if (is_numeric($k)) {
                            $config[$name][] = $v;
                        } else {
                            $config[$name][$k] = array_merge(
                                (array)$config[$name][$k],
                                (array)$v
                            );
                        }
                    }
                }
            } else {
                $config[$name] = new Config();
            }
        }
        if ($content = trim((string)$xml)) {
            $config[] = $content;
        }

        return $config;
    }
}