EventHistoryProvider::lastIndex() - Code Metrics - Inspection of "WIP" - phpwintools/wmi-scripting - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — drivers ( fe89be...446647 )

by Joe

created 2019-09-18 20:02 UTC

EventHistoryProvider::lastIndex() A

↳ Parent: EventHistoryProvider

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	1
c	0
b	0
f	0
nc	1
nop	0
dl	0
loc	3
rs	10

<?php

namespace PhpWinTools\WmiScripting\Support\Events;

use Closure;
use Countable;
use PhpWinTools\WmiScripting\Configuration\Config;

class EventHistoryProvider implements Countable
{
    /** @var Config */
    protected $config;

    /** @var array|FiredEvent[] */
    protected $fired_events = [];

    /** @var array */
    protected $event_cache = [
        'actual' => [],
        'ancestors' => [],
        'listeners' => [],
    ];

    protected $eventContainer;

    public function __construct(Config $config = null)
    {
        $this->config = $config ?? Config::instance();

        $this->eventContainer = new EventCacheContainer();
    }

    public function container()
    {
        return $this->eventContainer;
    }

    /**
     * @param Event            $event
     * @param array|Listener[] $listeners
     *
     * @return self
     */
    public function add(Event $event, array $listeners = []): self
    {
        if ($this->shouldNotTrack()) {
            return $this;
        }

        $this->fired_events[] = new FiredEvent($event, $listeners);

        return $this->cacheEvent($event, $listeners);
    }

    /**
     * @return array|FiredEvent[]
     */
    public function all()
    {
        return $this->fired_events;
    }

    /**
     * @param string              $event
     * @param array|Closure|mixed $default
     *
     * @return array|FiredEvent[]|mixed
     */
    public function get(string $event, $default = [])
    {
        return $this->findEvents($this->getFiredEventKeys($event), $default);
    }

    /**
     * @param string              $listener
     * @param array|Closure|mixed $default
     *
     * @return array|FiredEvent[]|mixed
     */
    public function getFromListener(string $listener, $default = [])
    {
        return $this->findEvents($this->event_cache['listeners'][$listener] ?? [], $default);
    }

    /**
     * @param string $event
     *
     * @return array|mixed
     */
    public function getFiredEventKeys(string $event)
    {
        $keys = [];

        if ($this->wasFiredByName($event)) {
            $keys = $this->event_cache['actual'][$event];
        }

        if ($this->wasFiredByDescendant($event)) {
            $keys = array_merge($keys, $this->event_cache['ancestors'][$event]);
        }

        return $keys;
    }

    /**
     * @return int
     */
    public function count(): int
    {
        return count($this->fired_events);
    }

    /**
     * @param string|null $event
     *
     * @return int
     */
    public function eventCount(string $event = null): int
    {
        return is_null($event) ? $this->count() : count($this->get($event));
    }

    /**
     * @return int
     */
    public function lastIndex(): int
    {
        return $this->count() - 1;
    }

    /**
     * @param string $event
     *
     * @return bool
     */
    public function hasFired(string $event): bool
    {
        return $this->wasFiredByName($event) || $this->wasFiredByDescendant($event);
    }

    /**
     * @param string $event
     *
     * @return bool
     */
    public function hasNotFired(string $event): bool
    {
        return $this->hasFired($event) === false;
    }

    /**
     * @param string $event
     *
     * @return bool
     */
    public function wasFiredByName(string $event): bool
    {
        return array_key_exists($event, $this->event_cache['actual']);
    }

    /**
     * @param string $event
     *
     * @return bool
     */
    public function wasFiredByDescendant(string $event): bool
    {
        return array_key_exists($event, $this->event_cache['ancestors']);
    }

    /**
     * @param array               $event_keys
     * @param array|Closure|mixed $default
     *
     * @return array|FiredEvent[]|mixed
     */
    protected function findEvents(array $event_keys = [], $default = [])
    {
        $events = array_values(array_map(function ($event_key) {
            return $this->fired_events[$event_key];
        }, $event_keys));

        if (empty($events)) {
            return is_callable($default) ? $default() : $default;
        }

        return $events;
    }

    /**
     * @param Event            $event
     * @param array|Listener[] $listeners
     *
     * @return self
     */
    protected function cacheEvent(Event $event, array $listeners = []): self
    {
        $this->event_cache['actual'][get_class($event)][] = $this->lastIndex();

        $this->cacheEventSet($event, 'ancestors', class_parents($event), function ($item) {
            return $item;
        });

        $this->cacheEventSet($event, 'listeners', $listeners, function (Listener $listener) {
            return get_class($listener);
        });

        return $this;
    }

    protected function cacheEventSet(Event $event, string $set_name, array $set, Closure $getItemKey)
    protected function cacheEventSet(/** @scrutinizer ignore-unused */ Event $event, string $set_name, array $set, Closure $getItemKey)
    {
        array_map(function ($item) use ($set_name, $getItemKey) {
            $this->event_cache[$set_name][$getItemKey($item)][] = $this->lastIndex();
        }, $set);
    }

    /**
     * @return bool
     */
    protected function shouldTrack(): bool
    {
        return $this->config->shouldTrackEvents();
    }

    /**
     * @return bool
     */
    protected function shouldNotTrack(): bool
    {
        return $this->shouldTrack() === false;
    }
}


phpwintools / wmi-scripting

Push — drivers ( fe89be...446647 )

EventHistoryProvider::lastIndex() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like