Horat1us\Services\XmlDifferenceService

Complexity

Total Complexity

21

Size/Duplication

Total Lines	159
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	5
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	getDifferentChildren()	0	26	3
A	getSource()	0	3	1
A	__construct()	0	7	1
A	difference()	0	19	4
A	transform()	0	5	2
A	setTarget()	0	5	1
A	findDifference()	0	12	3
A	setSource()	0	5	1
A	getTarget()	0	3	1
A	getIsCommonDifferent()	0	5	4

<?php

namespace Horat1us\Services;

use Horat1us\Services\Traits\PropertiesDifferenceTrait;
use Horat1us\XmlConvertibleInterface;
use Horat1us\XmlConvertibleObject;

/**
 * Class XmlDifferenceService
 * @package Horat1us\Services
 */
class XmlDifferenceService
{
    use PropertiesDifferenceTrait;

    /**
     * @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()
    {
        if ($this->source->xmlEqual($this->target)) {
            return null;
        }

        if ($this->getIsCommonDifferent()) {
            return clone $this->getSource();
        }

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

        $target = clone $this->getSource();
        $target->setXmlChildren($newChildren);

        return clone $target;
    }

    /**
     * Difference by element name, children count and properties
     */
    public function getIsCommonDifferent()
    {
        return $this->getSource()->getXmlElementName() !== $this->getTarget()->getXmlElementName()
            || empty($this->getSource()->getXmlChildren()) && !empty($this->getTarget()->getXmlChildren())
            || $this->getIsDifferentProperties();
    }

    /**
     * @return array
     */
    public function getDifferentChildren()
    {
        $sourceChildren = array_map(
            fn($child) => $this->transform($child),
            $this->getSource()->getXmlChildren() ?? []
        );
        $targetChildren = array_map(
            fn($child) => $this->transform($child),
            $this->getTarget()->getXmlChildren() ?? []
        );
        $sourceChildren = array_filter(
            $sourceChildren,
            function (XmlConvertibleInterface $sourceChild) use ($targetChildren): bool {
                foreach ($targetChildren as $targetChild) {
                    if ($targetChild->xmlEqual($sourceChild)) {
                        return false;
                    }
                }
                return true;
            }
        );
        $diffChildren = array_map(
            fn(XmlConvertibleInterface $child) => $this->findDifference($child),
            $sourceChildren
        );
        return array_filter($diffChildren);
    }

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

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

The expression return $difference also could return the type Horat1us\XmlConvertible which is incompatible with the documented return type Horat1us\XmlConvertibleInterface|null.

            }
        }

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