Mcneely\Core\Traits\CoreTrait

Complexity

Total Complexity

26

Size/Duplication

Total Lines	177
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	CoreTrait_getCoreObject()	0	5	1
A	cleanTraits()	0	7	2
A	CoreTrait_fireEvents()	0	16	3
A	CoreTrait_fireStartup()	0	11	3
A	CoreTrait_require()	0	7	3
A	CoreTrait_processTriggers()	0	15	4
A	CoreTrait_registerEvent()	0	8	2
A	CoreTrait_setCoreObject()	0	8	2
A	CoreTrait_buildTriggers()	0	19	4
A	getAllTraits()	0	9	2

<?php


declare(strict_types=1);

namespace Mcneely\Core\Traits;

use Mcneely\Core\CoreObject;

trait CoreTrait
{
    /** @var CoreObject */
    private $CoreTrait_CoreObject = null;

    /** @var bool $CoreTrait_hasSetUp */
    private $CoreTrait_hasSetUp = false;

    /** @var array $CoreTrait_events */
    private $CoreTrait_events = [];

    /**
     * @return CoreObject
     */
    protected function CoreTrait_getCoreObject(): CoreObject
    {
        $this->CoreTrait_fireEvents($this, __CLASS__, __METHOD__, __TRAIT__);

        return $this->CoreTrait_CoreObject;
    }

    /**
     * @param object $eventClassObject    -- object as function type not introduced until 7.2
     * @param string $eventImmediateClass
     * @param string $eventMethod
     * @param string $eventTrait
     *
     * @return self
     */
    protected function CoreTrait_fireEvents(
        /* @noinspection PhpUnusedParameterInspection */
        $eventClassObject,
        ?string $eventImmediateClass = '',
        ?string $eventMethod = '',
        ?string $eventTrait = ''
    ): self {
        if (!$this->CoreTrait_hasSetUp) {
            $this->CoreTrait_fireStartup($eventClassObject, $eventImmediateClass);
        }

        $eventMethodArray = !empty($eventMethod) ? explode('::', $eventMethod) : [];
        $eventMethodShort = array_pop($eventMethodArray);
        $triggers         = $this->CoreTrait_buildTriggers($eventClassObject, $eventMethodShort); /**/

        return $this->CoreTrait_processTriggers($triggers, $eventClassObject, $eventMethodShort);
    }

    /**
     * @param object $eventClassObject
     * @param string $eventImmediateClass
     */
    private function CoreTrait_fireStartup($eventClassObject, $eventImmediateClass): void
    {
        $this->CoreTrait_hasSetUp = true;
        $traits                   = array_merge(class_uses($eventImmediateClass), class_uses($eventClassObject));
        $traits                   = $this->cleanTraits($traits);

        $methods = preg_grep('/^__setUp_/', get_class_methods(get_class($eventClassObject)));

        foreach ($methods as $method) {
            if (in_array(substr($method, 8), $traits)) {
                $eventClassObject->$method();
            }
        }
    }

    protected function cleanTraits(array $traits): array
    {
        foreach ($traits as $key => $trait) {
            $traits[$key] = basename(str_replace('\\', '/', $trait));
        }

        return $traits;
    }

    /**
     * @param object $eventClassObject
     * @param string $eventMethodShort
     *
     * @return array
     */
    protected function CoreTrait_buildTriggers($eventClassObject, ?string $eventMethodShort): array
    {
        $beforeMethod = '__fireBefore_'.$eventMethodShort;
        $triggers     = [];

        if (method_exists($eventClassObject, $beforeMethod)) {
            $triggers[] = [
                'method'  => $beforeMethod,
                'exclude' => [],
            ];
        }

        $functionTriggers = array_key_exists(
            $eventMethodShort,
            $this->CoreTrait_events
        ) ? $this->CoreTrait_events[$eventMethodShort] : [];
        $wildCardTriggers = array_key_exists('*', $this->CoreTrait_events) ? $this->CoreTrait_events['*'] : [];

        return array_merge($triggers, $functionTriggers, $wildCardTriggers);
    }

    /**
     * @param array       $triggers
     * @param object      $eventClassObject
     * @param string|null $eventMethodShort
     *
     * @return self
     */
    protected function CoreTrait_processTriggers(array $triggers, $eventClassObject, ?string $eventMethodShort): self
    {
        foreach ($triggers as $trigger) {
            if (!in_array($eventMethodShort, $trigger['exclude'])) {
                $method = $trigger['method'];
                if ($method instanceof \Closure) {
                    $closure = \Closure::bind($method, $eventClassObject);
                    $closure();
                } else {
                    $eventClassObject->$method();
                }
            }
        }

        return $this;
    }

    /**
     * @param mixed $object
     *
     * @return self
     */
    protected function CoreTrait_setCoreObject($object = null): self
    {
        $this->CoreTrait_hasSetUp   = false;
        $this->CoreTrait_events     = [];
        $this->CoreTrait_CoreObject = ($object instanceof CoreObject) ? $object : new CoreObject($object);
        $this->CoreTrait_fireEvents($this, __CLASS__, __METHOD__, __TRAIT__);

        return $this;
    }

    protected function CoreTrait_registerEvent($onFunction, $triggerMethod, array $exclude = []): self
    {
        $this->CoreTrait_events[$onFunction][] = [
            'method'  => $triggerMethod,
            'exclude' => ('*' === $onFunction) ? $exclude : [],
        ];

        return $this;
    }

    /**
     * @param array $traits
     * @param       $currentTrait
     *
     * @throws \Exception
     */
    protected function CoreTrait_require(array $traits, $currentTrait)
    {
        $classTraits = $this->getAllTraits($this);

        foreach ($traits as $trait) {
            if (!in_array($trait, $classTraits)) {
                throw new \Exception("{$currentTrait} requires trait {$trait}");
            }
        }
    }

    protected function getAllTraits($object)
    {
        $objects = array_merge([$object], class_parents($object));
        $traits  = [];
        foreach ($objects as $object) {

$object is overwriting one of the parameters of this function.

            $traits = array_merge(class_uses($object), $traits);
        }

        return array_unique($traits);
    }
}