Xml::parse() - Code Metrics - Inspection of "XML Parser refactored" - selamiphp/entity - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( eea540...1a3db9 )

by Mehmet

created 2017-01-20 16:44 UTC

Xml::parse() A

↳ Parent: Xml

Complexity

Conditions	2
Paths	2

Size

Total Lines	11
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	11
rs	9.4285
c	0
b	0
f	0
cc	2
eloc	8
nc	2
nop	0

<?php
declare(strict_types=1);

namespace Selami\Entity\Parser;

use Selami\Entity\Interfaces\ParserInterface;
use InvalidArgumentException;
use SimpleXMLElement;

/**
 * XML Parser
 *
 * @package Selami\Entity\Parser
 */
class Xml implements ParserInterface
{
    use ParserTrait;

    /**
     * Config constructor.
     *
     * @param  string $schemaConfig
     * @throws InvalidArgumentException
     *
     */
    public function __construct(string $schemaConfig = null)
    {
        if ($schemaConfig !== null) {
            $this->setConfig($schemaConfig);
        }
    }

    /**
     * {@inheritDoc}
     */
    public function parse()
    {
        $this->isConfigEmpty($this->schemaConfig);
        try {
            $schemaData = new SimpleXMLElement($this->schemaConfig);
        } catch (\Exception $e) {
            throw new InvalidArgumentException($e->getMessage());
        }
        $schema = $this->getSchema($schemaData);
        return ['schema' => $schema];
    }

    /**
     * {@inheritDoc}
     */
    public function checkFormat()
    {
        try {
            new SimpleXMLElement($this->schemaConfig);
        } catch (\Exception $e) {
            return false;
        }
        return true;
    }

    private function getSchema($schemaData)
    {
        return $this->arrayWalkRecursively((array) $schemaData);
    }

    private function arrayWalkRecursively(array $schemaData)
    {
        foreach ($schemaData as $key => $value) {
            $newValue = null;
            if ($value instanceof SimpleXMLElement) {
                $newValue = (array) $value;
                $newValue = $this->arrayWalkRecursively($newValue);
            }
            $schemaData[$key] = $newValue===null ? $value: $newValue;
        }
        return $schemaData;
    }
}


1			<?php
2			declare(strict_types=1);
3
4			namespace Selami\Entity\Parser;
5
6			use Selami\Entity\Interfaces\ParserInterface;
7			use InvalidArgumentException;
8			use SimpleXMLElement;
9
10			/**
11			* XML Parser
12			*
13			* @package Selami\Entity\Parser
14			*/
15			class Xml implements ParserInterface
16			{
17			use ParserTrait;
18
19			/**
20			* Config constructor.
21			*
22			* @param string $schemaConfig
23			* @throws InvalidArgumentException
24			*
25			*/
26			public function __construct(string $schemaConfig = null)
27			{
28			if ($schemaConfig !== null) {
29			$this->setConfig($schemaConfig);
30			}
31			}
32
33			/**
34			* {@inheritDoc}
35			*/
36			public function parse()
37			{
38			$this->isConfigEmpty($this->schemaConfig);
39			try {
40			$schemaData = new SimpleXMLElement($this->schemaConfig);
41			} catch (\Exception $e) {
42			throw new InvalidArgumentException($e->getMessage());
43			}
44			$schema = $this->getSchema($schemaData);
45			return ['schema' => $schema];
46			}
47
48			/**
49			* {@inheritDoc}
50			*/
51			public function checkFormat()
52			{
53			try {
54			new SimpleXMLElement($this->schemaConfig);
55			} catch (\Exception $e) {
56			return false;
57			}
58			return true;
59			}
60
61			private function getSchema($schemaData)
62			{
63			return $this->arrayWalkRecursively((array) $schemaData);
64			}
65
66			private function arrayWalkRecursively(array $schemaData)
67			{
68			foreach ($schemaData as $key => $value) {
69			$newValue = null;
70			if ($value instanceof SimpleXMLElement) {
71			$newValue = (array) $value;
72			$newValue = $this->arrayWalkRecursively($newValue);
73			}
74			$schemaData[$key] = $newValue===null ? $value: $newValue;
75			}
76			return $schemaData;
77			}
78			}
79

selamiphp / entity

Push — master ( eea540...1a3db9 )

Xml::parse() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like