EventsTrait::restoreEventSubscribers() - Code Metrics - juliangut/doctrine-base-repositories - Measure and Improve Code Quality continuously with Scrutinizer

EventsTrait::restoreEventSubscribers() A
last analyzed 2018-06-05 21:28 UTC

↳ Parent: EventsTrait

Complexity

Conditions	2
Paths	2

Size

Total Lines	10
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	10
rs	9.4285
c	0
b	0
f	0
cc	2
eloc	5
nc	2
nop	0

<?php

/*
 * doctrine-base-repositories (https://github.com/juliangut/doctrine-base-repositories).
 * Doctrine2 utility repositories.
 *
 * @license MIT
 * @link https://github.com/juliangut/doctrine-base-repositories
 * @author Julián Gutiérrez <[email protected]>
 */

declare(strict_types=1);

namespace Jgut\Doctrine\Repository;

use Doctrine\Common\EventManager;
use Doctrine\Common\EventSubscriber;

/**
 * Events trait.
 */
trait EventsTrait
{
    /**
     * List of disabled event subscribers.
     *
     * @var EventSubscriber[]
     */
    protected $disabledSubscribers = [];

    /**
     * List of disabled event listeners.
     *
     * @var EventSubscriber[]
     */
    protected $disabledListeners = [];

    /**
     * Disable event subscriber.
     *
     * @param \Doctrine\Common\EventSubscriber|string $subscriberClass
     */
    public function disableEventSubscriber($subscriberClass)
    {
        $subscriberClass = $this->getSubscriberClassName($subscriberClass);
        $eventManager = $this->getEventManager();

        /* @var EventSubscriber[] $subscribers */
        foreach ($this->getEventListeners() as $subscribers) {
            while ($subscriber = \array_shift($subscribers)) {
                if ($subscriber instanceof $subscriberClass) {
                    $this->disabledSubscribers[] = $subscriber;

                    $eventManager->removeEventSubscriber($subscriber);

                    return;
                }
            }
        }
    }

    /**
     * Restore disabled event subscribers.
     */
    public function restoreEventSubscribers()
    {
        $eventManager = $this->getEventManager();

        foreach ($this->disabledSubscribers as $subscriber) {
            $eventManager->addEventSubscriber($subscriber);
        }

        $this->disabledSubscribers = [];
    }

    /**
     * Disable all listeners for an event.
     *
     * @param string $event
     */
    public function disableEventListeners(string $event)
    {
        $eventManager = $this->getEventManager();

        if (!\array_key_exists($event, $this->disabledListeners)) {
            $this->disabledListeners[$event] = [];
        }

        foreach ($this->getEventListeners($event) as $listener) {
            $eventManager->removeEventListener($event, $listener);

            $this->disabledListeners[$event][] = $listener;
        }
    }

    /**
     * Disable listener for an event.
     *
     * @param string                 $event
     * @param string|EventSubscriber $subscriberClass
     *
     * @throws \InvalidArgumentException
     */
    public function disableEventListener(string $event, $subscriberClass)
    {
        $subscriberClass = $this->getSubscriberClassName($subscriberClass);

        if (!\array_key_exists($event, $this->disabledListeners)) {
            $this->disabledListeners[$event] = [];
        }

        $eventManager = $this->getEventManager();

        foreach ($this->getEventListeners($event) as $listener) {
            if ($listener instanceof $subscriberClass) {
                $this->disabledListeners[$event][] = $listener;

                $eventManager->removeEventListener($event, $listener);
                break;
            }
        }
    }

    /**
     * Restore all disabled listeners.
     */
    public function restoreAllEventListeners()
    {
        $eventManager = $this->getEventManager();

        foreach ($this->disabledListeners as $event => $listeners) {
            /* @var EventSubscriber[] $listeners */
            foreach ($listeners as $listener) {
                $eventManager->addEventListener($event, $listener);
            }

            $this->disabledListeners[$event] = [];
        }
    }

    /**
     * Restore disabled listeners for an event.
     *
     * @param string $event
     */
    public function restoreEventListeners(string $event)
    {
        if (!\array_key_exists($event, $this->disabledListeners) || empty($this->disabledListeners[$event])) {
            return;
        }

        $eventManager = $this->getEventManager();

        /* @var EventSubscriber[] $listeners */
        $listeners = $this->disabledListeners[$event];
        foreach ($listeners as $listener) {
            $eventManager->addEventListener($event, $listener);
        }

        $this->disabledListeners[$event] = [];
    }

    /**
     * Get subscriber class name.
     *
     * @param string|EventSubscriber $subscriberClass
     *
     * @throws \InvalidArgumentException
     *
     * @return string
     */
    protected function getSubscriberClassName($subscriberClass): string
    {
        if ($this->isEventSubscriber($subscriberClass)) {
            return \is_object($subscriberClass) ? \get_class($subscriberClass) : $subscriberClass;
        }

        throw new \InvalidArgumentException('subscriberClass must be an EventSubscriber');
    }

    /**
     * Is an event subscriber.
     *
     * @param $subscriberClass
     *
     * @return bool
     */
    private function isEventSubscriber($subscriberClass): bool
    {
        return \is_object($subscriberClass) || (\is_string($subscriberClass) && \class_exists($subscriberClass))
            ? \in_array(EventSubscriber::class, \class_implements($subscriberClass), true)
            : false;
    }

    /**
     * Get registered events.
     *
     * @return array
     */
    public function getRegisteredEvents(): array
    {
        return \array_keys($this->getEventManager()->getListeners());
    }

    /**
     * Get event listeners.
     *
     * @param string|null $event
     *
     * @return EventSubscriber[]
     */
    protected function getEventListeners($event = null): array
    {
        $eventManager = $this->getEventManager();

        return $event !== null && !$eventManager->hasListeners($event) ? [] : $eventManager->getListeners($event);
    }

    /**
     * Get event manager.
     *
     * @return EventManager
     */
    protected function getEventManager(): EventManager
    {
        return $this->getManager()->getEventManager();
    }

    /**
     * Get object manager.
     *
     * @return \Doctrine\Common\Persistence\ObjectManager
     */
    abstract protected function getManager();
}


1			<?php
2
3			/*
4			* doctrine-base-repositories (https://github.com/juliangut/doctrine-base-repositories).
5			* Doctrine2 utility repositories.
6			*
7			* @license MIT
8			* @link https://github.com/juliangut/doctrine-base-repositories
9			* @author Julián Gutiérrez <[email protected]>
10			*/
11
12			declare(strict_types=1);
13
14			namespace Jgut\Doctrine\Repository;
15
16			use Doctrine\Common\EventManager;
17			use Doctrine\Common\EventSubscriber;
18
19			/**
20			* Events trait.
21			*/
22			trait EventsTrait
23			{
24			/**
25			* List of disabled event subscribers.
26			*
27			* @var EventSubscriber[]
28			*/
29			protected $disabledSubscribers = [];
30
31			/**
32			* List of disabled event listeners.
33			*
34			* @var EventSubscriber[]
35			*/
36			protected $disabledListeners = [];
37
38			/**
39			* Disable event subscriber.
40			*
41			* @param \Doctrine\Common\EventSubscriber\|string $subscriberClass
42			*/
43			public function disableEventSubscriber($subscriberClass)
44			{
45			$subscriberClass = $this->getSubscriberClassName($subscriberClass);
46			$eventManager = $this->getEventManager();
47
48			/* @var EventSubscriber[] $subscribers */
49			foreach ($this->getEventListeners() as $subscribers) {
50			while ($subscriber = \array_shift($subscribers)) {
51			if ($subscriber instanceof $subscriberClass) {
52			$this->disabledSubscribers[] = $subscriber;
53
54			$eventManager->removeEventSubscriber($subscriber);
55
56			return;
57			}
58			}
59			}
60			}
61
62			/**
63			* Restore disabled event subscribers.
64			*/
65			public function restoreEventSubscribers()
66			{
67			$eventManager = $this->getEventManager();
68
69			foreach ($this->disabledSubscribers as $subscriber) {
70			$eventManager->addEventSubscriber($subscriber);
71			}
72
73			$this->disabledSubscribers = [];
74			}
75
76			/**
77			* Disable all listeners for an event.
78			*
79			* @param string $event
80			*/
81			public function disableEventListeners(string $event)
82			{
83			$eventManager = $this->getEventManager();
84
85			if (!\array_key_exists($event, $this->disabledListeners)) {
86			$this->disabledListeners[$event] = [];
87			}
88
89			foreach ($this->getEventListeners($event) as $listener) {
90			$eventManager->removeEventListener($event, $listener);
91
92			$this->disabledListeners[$event][] = $listener;
93			}
94			}
95
96			/**
97			* Disable listener for an event.
98			*
99			* @param string $event
100			* @param string\|EventSubscriber $subscriberClass
101			*
102			* @throws \InvalidArgumentException
103			*/
104			public function disableEventListener(string $event, $subscriberClass)
105			{
106			$subscriberClass = $this->getSubscriberClassName($subscriberClass);
107
108			if (!\array_key_exists($event, $this->disabledListeners)) {
109			$this->disabledListeners[$event] = [];
110			}
111
112			$eventManager = $this->getEventManager();
113
114			foreach ($this->getEventListeners($event) as $listener) {
115			if ($listener instanceof $subscriberClass) {
116			$this->disabledListeners[$event][] = $listener;
117
118			$eventManager->removeEventListener($event, $listener);
119			break;
120			}
121			}
122			}
123
124			/**
125			* Restore all disabled listeners.
126			*/
127			public function restoreAllEventListeners()
128			{
129			$eventManager = $this->getEventManager();
130
131			foreach ($this->disabledListeners as $event => $listeners) {
132			/* @var EventSubscriber[] $listeners */
133			foreach ($listeners as $listener) {
134			$eventManager->addEventListener($event, $listener);
135			}
136
137			$this->disabledListeners[$event] = [];
138			}
139			}
140
141			/**
142			* Restore disabled listeners for an event.
143			*
144			* @param string $event
145			*/
146			public function restoreEventListeners(string $event)
147			{
148			if (!\array_key_exists($event, $this->disabledListeners) \|\| empty($this->disabledListeners[$event])) {
149			return;
150			}
151
152			$eventManager = $this->getEventManager();
153
154			/* @var EventSubscriber[] $listeners */
155			$listeners = $this->disabledListeners[$event];
156			foreach ($listeners as $listener) {
157			$eventManager->addEventListener($event, $listener);
158			}
159
160			$this->disabledListeners[$event] = [];
161			}
162
163			/**
164			* Get subscriber class name.
165			*
166			* @param string\|EventSubscriber $subscriberClass
167			*
168			* @throws \InvalidArgumentException
169			*
170			* @return string
171			*/
172			protected function getSubscriberClassName($subscriberClass): string
173			{
174			if ($this->isEventSubscriber($subscriberClass)) {
175			return \is_object($subscriberClass) ? \get_class($subscriberClass) : $subscriberClass;
176			}
177
178			throw new \InvalidArgumentException('subscriberClass must be an EventSubscriber');
179			}
180
181			/**
182			* Is an event subscriber.
183			*
184			* @param $subscriberClass
185			*
186			* @return bool
187			*/
188			private function isEventSubscriber($subscriberClass): bool
189			{
190			return \is_object($subscriberClass) \|\| (\is_string($subscriberClass) && \class_exists($subscriberClass))
191			? \in_array(EventSubscriber::class, \class_implements($subscriberClass), true)
192			: false;
193			}
194
195			/**
196			* Get registered events.
197			*
198			* @return array
199			*/
200			public function getRegisteredEvents(): array
201			{
202			return \array_keys($this->getEventManager()->getListeners());
203			}
204
205			/**
206			* Get event listeners.
207			*
208			* @param string\|null $event
209			*
210			* @return EventSubscriber[]
211			*/
212			protected function getEventListeners($event = null): array
213			{
214			$eventManager = $this->getEventManager();
215
216			return $event !== null && !$eventManager->hasListeners($event) ? [] : $eventManager->getListeners($event);
217			}
218
219			/**
220			* Get event manager.
221			*
222			* @return EventManager
223			*/
224			protected function getEventManager(): EventManager
225			{
226			return $this->getManager()->getEventManager();
227			}
228
229			/**
230			* Get object manager.
231			*
232			* @return \Doctrine\Common\Persistence\ObjectManager
233			*/
234			abstract protected function getManager();
235			}
236

juliangut / doctrine-base-repositories

EventsTrait::restoreEventSubscribers() A last analyzed 2018-06-05 21:28 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

EventsTrait::restoreEventSubscribers() A
last analyzed 2018-06-05 21:28 UTC