XmlDifferenceService::getDifferentChildren() - Code Metrics - Inspection of "Fix XmlDifferenceService::getDifferentChildren" - Horat1us/php-xml-convertible - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 132d64...2ffb4e )

by Alexander

created 2017-05-11 16:18 UTC

XmlDifferenceService::getDifferentChildren() A

↳ Parent: XmlDifferenceService

Complexity

Conditions	1
Paths	1

Size

Total Lines	14
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	10
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	14
ccs	10
cts	10
cp	1
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	9
nc	1
nop	0
crap	1

<?php
/**
 * Created by PhpStorm.
 * User: horat1us
 * Date: 5/11/17
 * Time: 6:41 PM
 */

namespace Horat1us\Services;

use Horat1us\Arrays\Collection;
use Horat1us\XmlConvertibleInterface;
use Horat1us\XmlConvertibleObject;


/**
 * Class XmlDifferenceService
 * @package Horat1us\Services
 */
class XmlDifferenceService
{
    /**
     * @var XmlConvertibleInterface
     */
    protected $source;

    /**
     * @var XmlConvertibleInterface
     */
    protected $target;


    /**
     * XmlDifferenceService constructor.
     * @param XmlConvertibleInterface $source
     * @param XmlConvertibleInterface $target
     */
    public function __construct(
        XmlConvertibleInterface $source,
        XmlConvertibleInterface $target
    )
    {
        $this
            ->setSource($source)
            ->setTarget($target);
    }

    /**
     * @return XmlConvertibleInterface|null
     */
    public function difference()
    {
        $current = $this->getSource();
        $compared = $this->getTarget();

        if (
            $current->getXmlElementName() !== $compared->getXmlElementName()
            || empty($current->getXmlChildren()) && !empty($compared->getXmlChildren())
            || $this->getIsDifferentProperties()
        ) {
            return clone $current;
        }

        $newChildren = $this->getDifferentChildren();
        if (empty($newChildren)) {
            return null;
        }

        $target = clone $current;
        $target->setXmlChildren($newChildren);

        return clone $target;
    }

    public function getDifferentChildren()
    {
        return Collection::from($this->getSource()->getXmlChildren() ?? [])
            ->map(function ($child) {
                return $this->transform($child);
            })
            ->map(function (XmlConvertibleInterface $child) {
                return $this->findDifference($child);
            })
            ->filter(function ($child) {
                return $child !== null;
            })
            ->array;
    }

    /**
     * Finding difference in properties
     *
     * @return bool
     */
    protected function getIsDifferentProperties()
    {
        foreach ($this->getSource()->getXmlProperties() as $property) {
            if (
                !property_exists($this->getTarget(), $property)
                || $this->getSource()->{$property} !== $this->getTarget()->{$property}
            ) {
                return true;
            }
        }

        return false;
    }

    /**
     * @param XmlConvertibleInterface|\DOMNode|\DOMDocument $object
     * @return XmlConvertibleInterface
     */
    protected function transform($object)
    {
        return $object instanceof XmlConvertibleInterface
            ? $object
            : XmlConvertibleObject::fromXml($object);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * @param XmlConvertibleInterface $child
     * @return XmlConvertibleInterface|null
     */
    protected function findDifference(
        XmlConvertibleInterface $child
    )
    {
        foreach ($this->getTarget()->getXmlChildren() ?? [] as $comparedChild) {
            $target = $this->transform($comparedChild);

            if ($difference = $child->xmlDiff($target)) {
                return $difference;
            }
        }

        return null;
    }

    /**
     * @return XmlConvertibleInterface
     */
    public function getSource(): XmlConvertibleInterface
    {
        return $this->source;
    }

    /**
     * @param XmlConvertibleInterface $source
     * @return $this
     */
    public function setSource(XmlConvertibleInterface $source)
    {
        $this->source = $source;

        return $this;
    }

    /**
     * @return XmlConvertibleInterface
     */
    public function getTarget(): XmlConvertibleInterface
    {
        return $this->target;
    }

    /**
     * @param XmlConvertibleInterface $target
     * @return $this
     */
    public function setTarget(XmlConvertibleInterface $target)
    {
        $this->target = $target;

        return $this;
    }
}

1		<?php
2		/**
3		* Created by PhpStorm.
4		* User: horat1us
5		* Date: 5/11/17
6		* Time: 6:41 PM
7		*/
8
9		namespace Horat1us\Services;
10
11		use Horat1us\Arrays\Collection;
12		use Horat1us\XmlConvertibleInterface;
13		use Horat1us\XmlConvertibleObject;
14
15
16		/**
17		* Class XmlDifferenceService
18		* @package Horat1us\Services
19		*/
20		class XmlDifferenceService
21		{
22		/**
23		* @var XmlConvertibleInterface
24		*/
25		protected $source;
26
27		/**
28		* @var XmlConvertibleInterface
29		*/
30		protected $target;
31
32
33		/**
34		* XmlDifferenceService constructor.
35		* @param XmlConvertibleInterface $source
36		* @param XmlConvertibleInterface $target
37		*/
38	4	public function __construct(
39		XmlConvertibleInterface $source,
40		XmlConvertibleInterface $target
41		)
42		{
43		$this
44	4	->setSource($source)
45	4	->setTarget($target);
46	4	}
47
48		/**
49		* @return XmlConvertibleInterface\|null
50		*/
51	4	public function difference()
52		{
53	4	$current = $this->getSource();
54	4	$compared = $this->getTarget();
55
56		if (
57	4	$current->getXmlElementName() !== $compared->getXmlElementName()
58	4	\|\| empty($current->getXmlChildren()) && !empty($compared->getXmlChildren())
59	4	\|\| $this->getIsDifferentProperties()
60		) {
61	4	return clone $current;
62		}
63
64	2	$newChildren = $this->getDifferentChildren();
65	2	if (empty($newChildren)) {
66	2	return null;
67		}
68
69	2	$target = clone $current;
70	2	$target->setXmlChildren($newChildren);
71
72	2	return clone $target;
73		}
74
75	2	public function getDifferentChildren()
76		{
77	2	return Collection::from($this->getSource()->getXmlChildren() ?? [])
78		->map(function ($child) {
79	2	return $this->transform($child);
80	2	})
81		->map(function (XmlConvertibleInterface $child) {
82	2	return $this->findDifference($child);
83	2	})
84	2	->filter(function ($child) {
85	2	return $child !== null;
86	2	})
87	2	->array;
88		}
89
90		/**
91		* Finding difference in properties
92		*
93		* @return bool
94		*/
95	3	protected function getIsDifferentProperties()
96		{
97	3	foreach ($this->getSource()->getXmlProperties() as $property) {
98		if (
99	3	!property_exists($this->getTarget(), $property)
100	3	\|\| $this->getSource()->{$property} !== $this->getTarget()->{$property}
101		) {
102	3	return true;
103		}
104		}
105
106	2	return false;
107		}
108
109		/**
110		* @param XmlConvertibleInterface\|\DOMNode\|\DOMDocument $object
111		* @return XmlConvertibleInterface
112		*/
113	2	protected function transform($object)
114		{
115	2	return $object instanceof XmlConvertibleInterface
116	2	? $object
117	2	: XmlConvertibleObject::fromXml($object);
		0 ignored issues – show Documentation introduced 2017-05-11 16:13 UTC by Report Bug Copy Issue Report `$object` is of type `object<DOMNode>`, but the function expects a `object<DOMDocument>\|object<DOMElement>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
118		}
119
120		/**
121		* @param XmlConvertibleInterface $child
122		* @return XmlConvertibleInterface\|null
123		*/
124	2	protected function findDifference(
125		XmlConvertibleInterface $child
126		)
127		{
128	2	foreach ($this->getTarget()->getXmlChildren() ?? [] as $comparedChild) {
129	2	$target = $this->transform($comparedChild);
130
131	2	if ($difference = $child->xmlDiff($target)) {
132	2	return $difference;
133		}
134		}
135
136	2	return null;
137		}
138
139		/**
140		* @return XmlConvertibleInterface
141		*/
142	4	public function getSource(): XmlConvertibleInterface
143		{
144	4	return $this->source;
145		}
146
147		/**
148		* @param XmlConvertibleInterface $source
149		* @return $this
150		*/
151	4	public function setSource(XmlConvertibleInterface $source)
152		{
153	4	$this->source = $source;
154
155	4	return $this;
156		}
157
158		/**
159		* @return XmlConvertibleInterface
160		*/
161	4	public function getTarget(): XmlConvertibleInterface
162		{
163	4	return $this->target;
164		}
165
166		/**
167		* @param XmlConvertibleInterface $target
168		* @return $this
169		*/
170	4	public function setTarget(XmlConvertibleInterface $target)
171		{
172	4	$this->target = $target;
173
174	4	return $this;
175		}
176		}

Horat1us / php-xml-convertible

Push — master ( 132d64...2ffb4e )

XmlDifferenceService::getDifferentChildren() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like