Xml::__construct() - Code Metrics - gyselroth/micro - Measure and Improve Code Quality continuously with Scrutinizer

Xml::__construct() C
last analyzed 2017-12-11 11:42 UTC

↳ Parent: Xml

Complexity

Conditions	9
Paths	15

Size

Total Lines	49
Code Lines	30

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	49
rs	5.7446
c	0
b	0
f	0
cc	9
eloc	30
nc	15
nop	2

<?php
declare(strict_types = 1);

/**
 * Micro
 *
 * @author    Raffael Sahli <[email protected]>
 * @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

     */
    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);

            }
            $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();
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
        $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) {

                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;
    }
}


1			<?php
2			declare(strict_types = 1);
3
4			/**
5			* Micro
6			*
7			* @author Raffael Sahli <[email protected]>
8			* @copyright Copyright (c) 2017 gyselroth GmbH (https://gyselroth.com)
9			* @license MIT https://opensource.org/licenses/MIT
10			*/
11
12			namespace Micro\Config;
13
14			use \Micro\Config;
15			use \SimpleXMLElement;
16
17			class Xml implements ConfigInterface
18			{
19			/**
20			* Config features namespace
21			*/
22			const CONFIG_FEATURE_NAMESPACE = 'https://github.com/gyselroth/micro';
23
24			/**
25			* Config features namespace prefix
26			*/
27			const CONFIG_FEATURE_NAMESPACE_PREFIX = 'm';
28
29
30			/**
31			* Store
32			*
33			* @var SimpleXML
34			*/
35			private $store;
36
37
38			/**
39			* Load config
40			*
41			* @param string $config
42			* @param string $env
43			* @return void
			0 ignored issues – show Comprehensibility Best Practice introduced 2017-06-21 11:15 UTC by Report Bug Copy Issue Report Adding a `@return` annotation to constructors is generally not recommended as a constructor does not have a meaningful return value. Adding a `@return` annotation to a constructor is not recommended, since a constructor does not have a meaningful return value. Please refer to the PHP core documentation on constructors. Loading history...
44			*/
45			public function __construct(string $config, string $env = 'production')
46			{
47			$config = simplexml_load_file($config);
48			if ($this->store === false) {
49			throw new Exception('failed load xml configuration');
50			}
51
52			$store = (array)$config->children();
53			if (!isset($store[$env])) {
54			throw new Exception('env '.$env.' is not configured');
55			}
56
57			$config = $store[$env];
58
59			foreach ($store as $reg) {
60			$result = $reg->xpath('/config/'.$reg->getName().'//*[@'.self::CONFIG_FEATURE_NAMESPACE_PREFIX.':inherits]');
61			while (list(, $node) = each($result)) {
62			$path = (string)$node->attributes(self::CONFIG_FEATURE_NAMESPACE)->inherits;
63
64			if ($path === '') {
65			continue;
66			}
67
68			$xpath = '/config/'.$reg->getName().'/'.str_replace('.', '/', $path).'';
69			$found = $reg->xpath($xpath);
70			if (count($found) !== 1) {
71			throw new Exception('inherits '.$xpath.' not found');
72			}
73
74			unset($node->attributes(self::CONFIG_FEATURE_NAMESPACE)->inherits);
75			$found = array_shift($found);
76
77			$temp = clone $found;
78			$this->appendSimplexml($temp, $node);
79			$this->appendSimplexml($node, $temp);
80			}
81			}
82
83			$attrs = $store[$env]->attributes(self::CONFIG_FEATURE_NAMESPACE);
84			if (isset($attrs['inherits'])) {
85			if (!isset($store[(string)$attrs['inherits']])) {
86			throw new Exception('parent env '.$attrs['inherits'].' is not configured');
87			} else {
88			$this->appendSimplexml($store[(string)$attrs['inherits']], $config);
89			}
90			}
91
92			$this->store = $config;
93			}
94
95
96			/**
97			* Merge xml tree's
98			*
99			* @param SimpleXMLElement $simplexml_to
100			* @param SimpleXMLElement $simplexml_from
101			* @return bool
102			*/
103			protected function appendSimplexml(SimpleXMLElement&$simplexml_to, SimpleXMLElement&$simplexml_from): bool
104			{
105			if (count($simplexml_from->children()) === 0) {
106			if (count($simplexml_to->children()) === 0) {
107			$simplexml_to[0] = htmlspecialchars((string)$simplexml_from);
108			}
109			}
110			$attrs = $simplexml_to->attributes();
111			foreach ($simplexml_from->attributes() as $attr_key => $attr_value) {
112			if (!isset($attrs[$attr_key])) {
113			$simplexml_to->addAttribute($attr_key, (string)$attr_value);
114			} else {
115			$simplexml_to->attributes()->{$attr_key} = (string)$attr_value;
116			}
117			}
118			foreach ($simplexml_from->children() as $simplexml_child) {
119			if (count($simplexml_child->children()) === 0) {
120			if (!isset($simplexml_to->{$simplexml_child->getName()})) {
121			$simplexml_to->addChild($simplexml_child->getName(), htmlspecialchars((string)$simplexml_child));
122			} elseif(count($simplexml_to->{$simplexml_child->getName()}->children()) === 0) {
123			$simplexml_to->{$simplexml_child->getName()} = htmlspecialchars((string)$simplexml_child);
124			}
125			} else {
126			$this->appendSimplexml($simplexml_to->{$simplexml_child->getName()}, $simplexml_child, $replace);
			0 ignored issues – show Bug introduced 2017-11-03 15:49 UTC by Report Bug Copy Issue Report The variable `$replace` does not exist. Did you forget to declare it? This check marks access to variables or properties that have not been declared yet. While PHP has no explicit notion of declaring a variable, accessing it before a value is assigned to it is most likely a bug. Loading history... Unused Code introduced 2017-11-03 15:49 UTC by Report Bug Copy Issue Report The call to `Xml::appendSimplexml()` has too many arguments starting with `$replace`. This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the `@ignore` PhpDoc annotation to the duplicate definition and it will be ignored. Loading history...
127			}
128			$attrs = $simplexml_to->{$simplexml_child->getName()}->attributes();
129			foreach ($simplexml_child->attributes() as $attr_key => $attr_value) {
130			if (!isset($attrs[$attr_key])) {
131			$simplexml_to->{$simplexml_child->getName()}->addAttribute($attr_key, (string)$attr_value);
132			} else {
133			$simplexml_to->{$simplexml_child->getName()}->attributes()->{$attr_key} = (string)$attr_value;
134			}
135			}
136			}
137
138			return true;
139			}
140
141
142			/**
143			* Get entire simplexml
144			*
145			* @return SimpleXMLElement
146			*/
147			public function getRaw(): SimpleXMLElement
148			{
149			return $this->store;
150			}
151
152
153			/**
154			* Get from config
155			*
156			* @param string $name
157			* @return SimpleXMLElement
158			*/
159			public function __get(string $name): SimpleXMLElement
160			{
161			return $this->store->{$name};
162			}
163
164
165			/**
166			* Add config tree and merge it
167			*
168			* @param ConfigInterface $config
169			* @return ConfigInterface
170			*/
171			public function merge($config): ConfigInterface
172			{
173			$merge = $config->getRaw();
			0 ignored issues – show Bug introduced 2017-10-19 13:53 UTC by Report Bug Copy Issue Report 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`. Let’s take a look at an example: interface User { /** @return string / public function getPassword(); } class MyUser implements User { public function getPassword() { // return something } public function getDisplayName() { // return some name. } } class AuthSystem { public function authenticate(User $user) { $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName())); // do something. } } In the above example, the authenticate() method works fine as long as you just pass instances of MyUser. However, if you now also want to pass a different implementation of User which does not have a getDisplayName() method, the code will break. Available Fixes Change the type-hint for the parameter: class AuthSystem { public function authenticate(MyUser $user) { / ... / } } Add an additional type-check: class AuthSystem { public function authenticate(User $user) { if ($user instanceof MyUser) { $this->logger->info(/* ... /); } // or alternatively if ( ! $user instanceof MyUser) { throw new \LogicException( '$user must be an instance of MyUser, ' .'other instances are not supported.' ); } } } Note:* PHP Analyzer uses reverse abstract interpretation to narrow down the types inside the if block in such a case. Add the method to the interface: interface User { /** @return string / public function getPassword(); /* @return string */ public function getDisplayName(); } Loading history...
174			$this->appendSimplexml($this->store, $merge);
175
176			$result = $this->store->xpath('//*[@reference]');
177			while (list(, $node) = each($result)) {
178			$path = (string)$node->attributes()->reference;
179
180			if ($path === '') {
181			continue;
182			}
183
184			$xpath = '//'.str_replace('.', '/', $path);
185			$found = $this->store->xpath($xpath);
186			if (count($found) !== 1) {
187			continue;
188			}
189
190			$found = array_shift($found);
191			$this->appendSimplexml($node, $found);
192			}
193
194			return $this;
195			}
196
197
198			/**
199			* Get xml as config
200			*
201			* @param SimpleXMLElement $xml
202			* @return Config
203			*/
204			public function map(?SimpleXMLElement $xml = null): Config
205			{
206			if ($xml === null) {
207			$xml = $this->store;
208			}
209
210			$config = new Config();
211			foreach ($xml->getNamespaces() + [null] as $prefix => $namespace) {
212			if($prefix === self::CONFIG_FEATURE_NAMESPACE_PREFIX) {
			0 ignored issues – show Unused Code Bug introduced 2017-11-03 15:49 UTC by Report Bug Copy Issue Report 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? Loading history...
213			continue;
214			}
215
216			foreach ($xml->attributes($namespace) as $key => $value) {
217			if (is_string($prefix)) {
218			$key = $prefix.'.'.$key;
219			}
220
221			if ($key === 'reference') {
222			continue;
223			}
224
225			$config[$key] = (string)$value;
226			}
227			}
228
229			foreach ($xml as $name => $element) {
230			if(isset($element->attributes(self::CONFIG_FEATURE_NAMESPACE)->name)) {
231			$name = (string)$element->attributes(self::CONFIG_FEATURE_NAMESPACE)->name;
232			}
233
234			$value = $element->children() ? $this->map($element) : trim((string)$element);
235			if ($value \|\| $value === '0') {
236			if (!isset($arr[$name])) {
237			$config[$name] = $value;
238			} else {
239			foreach ((array)$value as $k => $v) {
240			if (is_numeric($k)) {
241			$config[$name][] = $v;
242			} else {
243			$config[$name][$k] = array_merge(
244			(array)$config[$name][$k],
245			(array)$v
246			);
247			}
248			}
249			}
250			} else {
251			$config[$name] = new Config();
252			}
253			}
254			if ($content = trim((string)$xml)) {
255			$config[] = $content;
256			}
257
258			return $config;
259			}
260			}
261

gyselroth / micro

Xml::__construct() C last analyzed 2017-12-11 11:42 UTC

Complexity

Size

Duplication

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like

Xml::__construct() C
last analyzed 2017-12-11 11:42 UTC