EventsTrait::getSubscriberClassName() - Code Metrics - Inspection of "event subscriber discovery update" - juliangut/doctrine-base-repositories - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 1d042b...298f70 )

by Julián

created 2017-06-04 09:51 UTC

EventsTrait::getSubscriberClassName() A

↳ Parent: EventsTrait

Complexity

Conditions	3
Paths	3

Size

Total Lines	8
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	8
rs	9.4285
c	0
b	0
f	0
cc	3
eloc	4
nc	3
nop	1

<?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);

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

                    $this->getEventManager()->removeEventSubscriber($subscriber);

                    return;
                }
            }
        }
    }

    /**
     * Restore disabled event subscribers.
     */
    public function restoreEventSubscribers()
    {
        foreach ($this->disabledSubscribers as $subscriber) {
            $this->getEventManager()->addEventSubscriber($subscriber);
        }

        $this->disabledSubscribers = [];
    }

    /**
     * Disable all listeners for an event.
     *
     * @param string $event
     */
    public function disableEventListeners(string $event)
    {
        if (!array_key_exists($event, $this->disabledListeners)) {
            $this->disabledListeners[$event] = [];
        }

        foreach ($this->getEventListeners($event) as $listener) {
            $this->getEventManager()->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] = [];
        }

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

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

    /**
     * Restore all disabled listeners.
     */
    public function restoreAllEventListeners()
    {
        foreach ($this->disabledListeners as $event => $listeners) {
            /* @var EventSubscriber[] $listeners */
            foreach ($listeners as $listener) {
                $this->getEventManager()->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;
        }

        /* @var EventSubscriber[] $listeners */
        $listeners = $this->disabledListeners[$event];

        foreach ($listeners as $listener) {
            $this->getEventManager()->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))
            : 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
47			/* @var EventSubscriber[] $subscribers */
48			foreach ($this->getEventListeners() as $subscribers) {
49			while ($subscriber = array_shift($subscribers)) {
50			if ($subscriber instanceof $subscriberClass) {
51			$this->disabledSubscribers[] = $subscriber;
52
53			$this->getEventManager()->removeEventSubscriber($subscriber);
54
55			return;
56			}
57			}
58			}
59			}
60
61			/**
62			* Restore disabled event subscribers.
63			*/
64			public function restoreEventSubscribers()
65			{
66			foreach ($this->disabledSubscribers as $subscriber) {
67			$this->getEventManager()->addEventSubscriber($subscriber);
68			}
69
70			$this->disabledSubscribers = [];
71			}
72
73			/**
74			* Disable all listeners for an event.
75			*
76			* @param string $event
77			*/
78			public function disableEventListeners(string $event)
79			{
80			if (!array_key_exists($event, $this->disabledListeners)) {
81			$this->disabledListeners[$event] = [];
82			}
83
84			foreach ($this->getEventListeners($event) as $listener) {
85			$this->getEventManager()->removeEventListener($event, $listener);
86
87			$this->disabledListeners[$event][] = $listener;
88			}
89			}
90
91			/**
92			* Disable listener for an event.
93			*
94			* @param string $event
95			* @param string\|EventSubscriber $subscriberClass
96			*
97			* @throws \InvalidArgumentException
98			*/
99			public function disableEventListener(string $event, $subscriberClass)
100			{
101			$subscriberClass = $this->getSubscriberClassName($subscriberClass);
102
103			if (!array_key_exists($event, $this->disabledListeners)) {
104			$this->disabledListeners[$event] = [];
105			}
106
107			foreach ($this->getEventListeners($event) as $listener) {
108			if ($listener instanceof $subscriberClass) {
109			$this->disabledListeners[$event][] = $listener;
110
111			$this->getEventManager()->removeEventListener($event, $listener);
112			break;
113			}
114			}
115			}
116
117			/**
118			* Restore all disabled listeners.
119			*/
120			public function restoreAllEventListeners()
121			{
122			foreach ($this->disabledListeners as $event => $listeners) {
123			/* @var EventSubscriber[] $listeners */
124			foreach ($listeners as $listener) {
125			$this->getEventManager()->addEventListener($event, $listener);
126			}
127
128			$this->disabledListeners[$event] = [];
129			}
130			}
131
132			/**
133			* Restore disabled listeners for an event.
134			*
135			* @param string $event
136			*/
137			public function restoreEventListeners(string $event)
138			{
139			if (!array_key_exists($event, $this->disabledListeners) \|\| empty($this->disabledListeners[$event])) {
140			return;
141			}
142
143			/* @var EventSubscriber[] $listeners */
144			$listeners = $this->disabledListeners[$event];
145
146			foreach ($listeners as $listener) {
147			$this->getEventManager()->addEventListener($event, $listener);
148			}
149
150			$this->disabledListeners[$event] = [];
151			}
152
153			/**
154			* Get subscriber class name.
155			*
156			* @param string\|EventSubscriber $subscriberClass
157			*
158			* @throws \InvalidArgumentException
159			*
160			* @return string
161			*/
162			protected function getSubscriberClassName($subscriberClass): string
163			{
164			if ($this->isEventSubscriber($subscriberClass)) {
165			return is_object($subscriberClass) ? get_class($subscriberClass) : $subscriberClass;
166			}
167
168			throw new \InvalidArgumentException('subscriberClass must be an EventSubscriber');
169			}
170
171			/**
172			* Is an event subscriber.
173			*
174			* @param $subscriberClass
175			*
176			* @return bool
177			*/
178			private function isEventSubscriber($subscriberClass): bool
179			{
180			return is_object($subscriberClass) \|\| (is_string($subscriberClass) && class_exists($subscriberClass))
181			? in_array(EventSubscriber::class, class_implements($subscriberClass))
182			: false;
183			}
184
185			/**
186			* Get registered events.
187			*
188			* @return array
189			*/
190			public function getRegisteredEvents(): array
191			{
192			return array_keys($this->getEventManager()->getListeners());
193			}
194
195			/**
196			* Get event listeners.
197			*
198			* @param string\|null $event
199			*
200			* @return EventSubscriber[]
201			*/
202			protected function getEventListeners($event = null): array
203			{
204			$eventManager = $this->getEventManager();
205
206			return $event !== null && !$eventManager->hasListeners($event) ? [] : $eventManager->getListeners($event);
207			}
208
209			/**
210			* Get event manager.
211			*
212			* @return EventManager
213			*/
214			protected function getEventManager(): EventManager
215			{
216			return $this->getManager()->getEventManager();
217			}
218
219			/**
220			* Get object manager.
221			*
222			* @return \Doctrine\Common\Persistence\ObjectManager
223			*/
224			abstract protected function getManager();
225			}
226

juliangut / doctrine-base-repositories

Push — master ( 1d042b...298f70 )

EventsTrait::getSubscriberClassName() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like