BuildableTrait::__clone() - Code Metrics - Inspection of "Remove all uses of the Magic Methods by regenerati..." - Garethp/php-ews - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#265)

by Gareth

created 2025-05-04 14:49 UTC

BuildableTrait::__clone() A

↳ Parent: BuildableTrait

Complexity

Conditions	2
Paths	2

Size

Total Lines	5
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	2

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	2
eloc	2
nc	2
nop	0
dl	0
loc	5
rs	10
c	1
b	0
f	0
ccs	3
cts	3
cp	1
crap	2

<?php

namespace garethp\ews;

use garethp\ews\API\Type;
use garethp\ews\API\XmlObject;

trait BuildableTrait
{
    /**
     * @var string
     */
    public $_ = '';

    public $_value = null;

    public function getNonNullItems($includeHiddenValue = false)
    {
        $items = get_object_vars($this);

        foreach ($items as $key => $item) {
            if (substr($key, 0, 1) == "_" || $item === null) {
                unset($items[$key]);
            }
        }

        if ($includeHiddenValue && $this->_value !== null) {
            $items['_value'] = $this->_value;
        }

        return $items;
    }

    /**
     * @param $array
     * @param bool $strict When set to true, we'll use reflection to build the objects
     *
     * @return static|XmlObject
     */
    public static function buildFromArray($array, bool $strict = false)
    {
        if (static::class === Type::class) {

            return XmlObject::buildFromArray($array, $strict);
        }

        if ($array instanceof XmlObject && $strict) {
            $array = (array)$array;
        }

        if (!is_array($array)) {
            return $array;
        }

        if (!self::arrayIsAssoc($array)) {
            return self::buildArrayFromArray($array, $strict);
            return self::/** @scrutinizer ignore-call */ buildArrayFromArray($array, $strict);
        } else {
            return self::buildObjectFromArray($array, $strict);
        }
    }

    protected static function buildObjectFromArray($array, bool $strict = false)
    {
        $object = new static();
        $reflect = new \ReflectionClass(static::class);

        foreach ($array as $key => $value) {
            // If we're in strict mode, let's take the reflection class, check for a setter and try to use that to build
            // the array, resulting in type-correct responses the whole way down.
            if ($strict === true && $reflect->hasMethod("set" . ucfirst($key))) {
                $parameters = $reflect->getMethod("set" . ucfirst($key))->getParameters();

                if (count($parameters) === 1
                    && $parameters[0]->hasType()
                    && $parameters[0]->getClass() !== null) {
                    $classToBuild = $parameters[0]->getClass()->getName();

                    $newValue = call_user_func("$classToBuild::buildFromArray", $value, true);
                    $object->$key = $newValue;
                    continue;
                }
            }

            if (is_array($value)) {
                $value = self::buildFromArray($value);
            }

            //I think _value is a more expressive way to set string value, but Soap needs _
            if ($key === "_value") {
                $key = "_";
            }

            $object->$key = $value;
        }

        return $object;
    }

    public static function buildArrayFromArray($array)
    {
        foreach ($array as $key => $value) {
            $array[$key] = self::buildFromArray($value);
        }

        return $array;
    }

    public function toXmlObject()
    {
        $objectToReturn = new XmlObject();
        $objectToReturn->_ = (string)$this;

        $properties = $this->getNonNullItems(true);

        foreach ($properties as $name => $property) {
            //I think _value is a more expressive way to set string value, but Soap needs _
            if ($name == "_value") {
                $name = "_";
            }

            $name = ucfirst($name);
            $objectToReturn->$name = $this->propertyToXml($name, $property);
        }

        return $objectToReturn;
    }

    /**
     * @param $name
     * @param $property
     * @return array|Type|null
     */
    protected function propertyToXml($name, $property)
    protected function propertyToXml(/** @scrutinizer ignore-unused */ $name, $property)
    {
        if ($property instanceof \DateTime) {
            $property = $property->format("c");
        }

        if ($property instanceof Type) {
            return $property->toXmlObject();

        }

        if (is_array($property) && $this->arrayIsAssoc($property)) {
            return $this->buildFromArray($property);

        }

        if (is_array($property)) {
            return array_map(function ($property) {
                if ($property instanceof Type) {
                    return $property->toXmlObject();
                }

                return $property;
            }, $property);
        }

        return $property;
    }

    public static function arrayIsAssoc($array)
    {
        return (bool)count(array_filter(array_keys($array), 'is_string'));
    }

    /**
     * Clones any object properties on a type object when it is cloned. Allows
     * for a deep clone required when using object to represent data types when
     * making a SOAP call.
     */
    public function __clone()
    {
        // Iterate over all properties on the current object.
        foreach (get_object_vars($this) as $property => $value) {
            $this->$property = \garethp\ews\Utilities\cloneValue($value);
        }
    }

    public function __toString()
    {
        if (!is_string($this->_)) {

            return '';
        }

        return $this->_;
    }
}


Garethp / php-ews

Pull Request — master (#265)

BuildableTrait::__clone() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like