Mcneely\Core\CoreObject

Complexity

Total Complexity

22

Size/Duplication

Total Lines	114
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
A	setRetriever()	0	5	1
A	getObject()	0	5	2
A	bindRetriever()	0	8	4
A	unWrap()	0	13	2
A	hasRetriever()	0	3	1
A	setObject()	0	6	1
B	internalUnWrap()	0	20	10

<?php

declare(strict_types=1);

namespace Mcneely\Core;

use ArrayIterator;

/**
 * Class CoreObject.
 *
 * @package Mcneely\Core
 */
class CoreObject
{
    /** @var mixed $object */
    protected $object;

    /** @var callable|false $retriever */
    protected $retriever = false;

    /** @var callable|false $boundObject */
    protected $boundObject = false;

    /**
     * CoreObject constructor.
     *
     * @param mixed $object
     */
    public function __construct($object)
    {
        $this->setObject($object);
    }

    /**
     * @param callable $retriever
     *
     * @return CoreObject
     */
    public function setRetriever(callable $retriever): self
    {
        $this->retriever = $retriever;

        return $this;
    }

    public function unWrap(?string $instance = null, ?string $exclude = null)
    {
        $unWrap = $this->internalUnWrap($instance, $exclude);
        $object = $unWrap['object'];

        if ($unWrap['skipped']) {
            return $object;
        }

        $this->setObject($object);
        $this->retriever = false;

        return $object;
    }

    protected function internalUnWrap(?string $instance = null, ?string $exclude = null): array
    {
        $object = $this->getObject();

        $object = ($object instanceof \IteratorAggregate) ? $object->getIterator() : $object;
        $object = ($object instanceof \IteratorIterator) ? $object->getInnerIterator() : $object;

        $skip    = false;
        $exclude = ($exclude && $object instanceof $exclude);
        if ($instance && $object instanceof $instance && !$exclude) {
            $skip = true;
        } else {
            $object = ($object instanceof \Traversable) ? iterator_to_array($object) : $object;
            $object = (method_exists($object, 'toArray')) ? $object->toArray() : $object;
            $object = (is_array($object)) ? new ArrayIterator($object) : $object;
        }

        return [
            'skipped' => $skip,
            'object'  => $object,
        ];

    }

    /**
     *
     * @return mixed
     */
    protected function getObject()
    {
        $this->bindRetriever();

        return ($this->hasRetriever()) ? $this->boundObject : $this->object;
    }

    /**
     * @param mixed $object
     *
     * @return CoreObject
     */
    public function setObject($object): self
    {
        $this->object      = $object;
        $this->boundObject = false;

        return $this;
    }

    /**
     * @param bool|null $rebind
     *
     * @return CoreObject
     */
    public function bindRetriever(?bool $rebind = false): self
    {
        if ($this->hasRetriever() && ($rebind || !$this->boundObject)) {
            $retriever         = $this->retriever;

It seems like $this->retriever can also be of type boolean. However, the property $retriever is declared as type callable|false. Maybe add an additional type check?

            $this->boundObject = $retriever($this->object);
        }

        return $this;
    }

    public function hasRetriever(): bool
    {
        return (bool)$this->retriever;
    }
}