SubscriberPass::appendEventWithResolver() - Code Metrics - xiidea/EasyAuditBundle - Measure and Improve Code Quality continuously with Scrutinizer

SubscriberPass::appendEventWithResolver() A
last analyzed 2024-11-20 16:54 UTC

↳ Parent: SubscriberPass

Complexity

Conditions	2
Paths	2

Size

Total Lines	6
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

/*
 * This file is part of the XiideaEasyAuditBundle package.
 *
 * (c) Xiidea <http://www.xiidea.net>
 *
 * This source file is subject to the MIT license that is bundled
 * with this source code in the file LICENSE.
 */

namespace Xiidea\EasyAuditBundle\DependencyInjection\Compiler;

use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
use Xiidea\EasyAuditBundle\Events\DoctrineEvents;

class SubscriberPass implements CompilerPassInterface
{
    #[\Override]
    public function process(ContainerBuilder $container): void
    {
        if (false === $container->hasDefinition('xiidea.easy_audit.event_listener')) {
            return;
        }

        $this->initializeSubscriberEvents($container);
    }

    private function initializeSubscriberEvents(ContainerBuilder $container)
    {
        $eventsList = $container->getParameter('xiidea.easy_audit.events');

        $this->appendDoctrineEventsToList($container, $eventsList);
        $this->appendSubscribedEventsToList($container, $eventsList);

        $this->registerEventsToListener($eventsList, $container);
    }

    private function appendDoctrineEventsToList(ContainerBuilder $container, &$events = array())
    {
        if (false === $container->getParameter('xiidea.easy_audit.doctrine_objects')) {
            return;
        }

        foreach (DoctrineEvents::getConstants() as $constant) {
            array_push($events, $constant);
        }
    }

    /**
     * @param ContainerBuilder $container
     * @param array            $events
     */
    private function appendSubscribedEventsToList(ContainerBuilder $container, &$events = array())
    {
        $taggedSubscribers = $container->findTaggedServiceIds('easy_audit.event_subscriber');

        if (empty($taggedSubscribers)) {
            return;
        }

        foreach ($taggedSubscribers as $id => $attributes) {
            $this->appendEventsFromSubscriber($container, $events, $id,
                $this->getResolverFromConfigurationAttributes($attributes)
            );
        }
    }

    /**
     * @param $attributes
     */
    private function getResolverFromConfigurationAttributes($attributes)
    {
        return isset($attributes[0]) && isset($attributes[0]['resolver']) ? $attributes[0]['resolver'] : null;
    }

    /**
     * @param ContainerBuilder $container
     * @param $events
     * @param $id
     * @param $defaultResolver
     */
    private function appendEventsFromSubscriber(ContainerBuilder $container, &$events, $id, $defaultResolver = null)
    {
        $subscriber = $container->get($id);

        $subscribedEvents = $subscriber->getSubscribedEvents();

        foreach ($subscribedEvents as $key => $item) {
            $resolver = !empty($defaultResolver) && !is_string($key) ? $defaultResolver : $key;
            $this->addEventFromSubscriber($events, $item, $resolver);
        }
    }

    /**
     * @param $events
     * @param $item
     * @param $resolver
     */
    private function addEventFromSubscriber(&$events, $item, $resolver)
    {
        $items = array($item);
        foreach ($items as $value) {
            $this->appendEventArray($events, $resolver, $value);
        }
    }

    /**
     * @param $events
     * @param $resolver
     * @param $item
     */
    private function appendEventArray(&$events, $resolver, $item)
    {
        if ($this->isEventWithResolver($resolver)) {
            $this->appendEventWithResolver($events, $item, $resolver);
            return;
        }

        array_push($events, $item);
    }

    /**
     * @param $resolver
     *
     * @return bool
     */
    private function isEventWithResolver($resolver)
    {
        return is_string($resolver);
    }

    /**
     * @param $events
     * @param $items
     * @param $key
     *
     * @internal param $event
     */
    private function appendEventWithResolver(&$events, $items, $key)
    {
        $items = (array) $items;

        foreach ($items as $item) {
            array_push($events, array($item => $key));
        }
    }

    /**
     * @param $events
     * @param ContainerBuilder $container
     */
    private function registerEventsToListener($events, ContainerBuilder $container)
    {
        if (empty($events)) {
            return;
        }

        $definition = $container->getDefinition('xiidea.easy_audit.event_listener');
        $customResolvers = $container->getParameter('xiidea.easy_audit.custom_resolvers');

        $listenableEventsList = $this->getListenableEventList($events);
        $this->buildCustomResolverList($events, $customResolvers);

        $definition->setTags(array('kernel.event_listener' => array_values($listenableEventsList)));
        $container->setParameter('xiidea.easy_audit.custom_resolvers', $customResolvers);
    }

    /**
     * @param $events
     *
     * @return array
     */
    private function getListenableEventList($events)
    {
        $eventList = array();

        foreach ($events as $item) {
            $event = is_array($item) ? key($item) : $item;

            $eventList[$event] = array(
                'event' => $event,
                'method' => 'resolveEventHandler',
            );
        }

        return $eventList;
    }

    private function buildCustomResolverList($events, &$customResolver)
    {
        foreach ($events as $item) {
            if (is_array($item)) {
                $event = key($item);
                $resolver = $item[$event];
                $customResolver[$event] = $resolver;
            }
        }
    }
}


1			<?php
2
3			/*
4			* This file is part of the XiideaEasyAuditBundle package.
5			*
6			* (c) Xiidea <http://www.xiidea.net>
7			*
8			* This source file is subject to the MIT license that is bundled
9			* with this source code in the file LICENSE.
10			*/
11
12			namespace Xiidea\EasyAuditBundle\DependencyInjection\Compiler;
13
14			use Symfony\Component\DependencyInjection\ContainerBuilder;
15			use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
16			use Xiidea\EasyAuditBundle\Events\DoctrineEvents;
17
18			class SubscriberPass implements CompilerPassInterface
19			{
20			#[\Override]
21			public function process(ContainerBuilder $container): void
22			{
23			if (false === $container->hasDefinition('xiidea.easy_audit.event_listener')) {
24			return;
25			}
26
27			$this->initializeSubscriberEvents($container);
28			}
29
30			private function initializeSubscriberEvents(ContainerBuilder $container)
31			{
32			$eventsList = $container->getParameter('xiidea.easy_audit.events');
33
34			$this->appendDoctrineEventsToList($container, $eventsList);
35			$this->appendSubscribedEventsToList($container, $eventsList);
36
37			$this->registerEventsToListener($eventsList, $container);
38			}
39
40			private function appendDoctrineEventsToList(ContainerBuilder $container, &$events = array())
41			{
42			if (false === $container->getParameter('xiidea.easy_audit.doctrine_objects')) {
43			return;
44			}
45
46			foreach (DoctrineEvents::getConstants() as $constant) {
47			array_push($events, $constant);
48			}
49			}
50
51			/**
52			* @param ContainerBuilder $container
53			* @param array $events
54			*/
55			private function appendSubscribedEventsToList(ContainerBuilder $container, &$events = array())
56			{
57			$taggedSubscribers = $container->findTaggedServiceIds('easy_audit.event_subscriber');
58
59			if (empty($taggedSubscribers)) {
60			return;
61			}
62
63			foreach ($taggedSubscribers as $id => $attributes) {
64			$this->appendEventsFromSubscriber($container, $events, $id,
65			$this->getResolverFromConfigurationAttributes($attributes)
66			);
67			}
68			}
69
70			/**
71			* @param $attributes
72			*/
73			private function getResolverFromConfigurationAttributes($attributes)
74			{
75			return isset($attributes[0]) && isset($attributes[0]['resolver']) ? $attributes[0]['resolver'] : null;
76			}
77
78			/**
79			* @param ContainerBuilder $container
80			* @param $events
81			* @param $id
82			* @param $defaultResolver
83			*/
84			private function appendEventsFromSubscriber(ContainerBuilder $container, &$events, $id, $defaultResolver = null)
85			{
86			$subscriber = $container->get($id);
87
88			$subscribedEvents = $subscriber->getSubscribedEvents();
89
90			foreach ($subscribedEvents as $key => $item) {
91			$resolver = !empty($defaultResolver) && !is_string($key) ? $defaultResolver : $key;
92			$this->addEventFromSubscriber($events, $item, $resolver);
93			}
94			}
95
96			/**
97			* @param $events
98			* @param $item
99			* @param $resolver
100			*/
101			private function addEventFromSubscriber(&$events, $item, $resolver)
102			{
103			$items = array($item);
104			foreach ($items as $value) {
105			$this->appendEventArray($events, $resolver, $value);
106			}
107			}
108
109			/**
110			* @param $events
111			* @param $resolver
112			* @param $item
113			*/
114			private function appendEventArray(&$events, $resolver, $item)
115			{
116			if ($this->isEventWithResolver($resolver)) {
117			$this->appendEventWithResolver($events, $item, $resolver);
118			return;
119			}
120
121			array_push($events, $item);
122			}
123
124			/**
125			* @param $resolver
126			*
127			* @return bool
128			*/
129			private function isEventWithResolver($resolver)
130			{
131			return is_string($resolver);
132			}
133
134			/**
135			* @param $events
136			* @param $items
137			* @param $key
138			*
139			* @internal param $event
140			*/
141			private function appendEventWithResolver(&$events, $items, $key)
142			{
143			$items = (array) $items;
144
145			foreach ($items as $item) {
146			array_push($events, array($item => $key));
147			}
148			}
149
150			/**
151			* @param $events
152			* @param ContainerBuilder $container
153			*/
154			private function registerEventsToListener($events, ContainerBuilder $container)
155			{
156			if (empty($events)) {
157			return;
158			}
159
160			$definition = $container->getDefinition('xiidea.easy_audit.event_listener');
161			$customResolvers = $container->getParameter('xiidea.easy_audit.custom_resolvers');
162
163			$listenableEventsList = $this->getListenableEventList($events);
164			$this->buildCustomResolverList($events, $customResolvers);
165
166			$definition->setTags(array('kernel.event_listener' => array_values($listenableEventsList)));
167			$container->setParameter('xiidea.easy_audit.custom_resolvers', $customResolvers);
168			}
169
170			/**
171			* @param $events
172			*
173			* @return array
174			*/
175			private function getListenableEventList($events)
176			{
177			$eventList = array();
178
179			foreach ($events as $item) {
180			$event = is_array($item) ? key($item) : $item;
181
182			$eventList[$event] = array(
183			'event' => $event,
184			'method' => 'resolveEventHandler',
185			);
186			}
187
188			return $eventList;
189			}
190
191			private function buildCustomResolverList($events, &$customResolver)
192			{
193			foreach ($events as $item) {
194			if (is_array($item)) {
195			$event = key($item);
196			$resolver = $item[$event];
197			$customResolver[$event] = $resolver;
198			}
199			}
200			}
201			}
202

xiidea / EasyAuditBundle

SubscriberPass::appendEventWithResolver() A last analyzed 2024-11-20 16:54 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

SubscriberPass::appendEventWithResolver() A
last analyzed 2024-11-20 16:54 UTC