SubscriberPass::getDoctrineEventsList() - Code Metrics - Inspection of ":hammer: [Refactor] Remove Direct Container Depend..." - xiidea/EasyAuditBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( e9e666...e79deb )

by Roni

created 2018-11-17 16:08 UTC

SubscriberPass::getDoctrineEventsList() A

↳ Parent: SubscriberPass

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?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
{
    public function process(ContainerBuilder $container)
    {

        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())
    {
        $doctrine_entities = $container->getParameter('xiidea.easy_audit.doctrine_entities');

        if ($doctrine_entities === false) {
            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
     * @return null
     */
    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			public function process(ContainerBuilder $container)
21			{
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
33			$eventsList = $container->getParameter('xiidea.easy_audit.events');
34
35			$this->appendDoctrineEventsToList($container, $eventsList);
36			$this->appendSubscribedEventsToList($container, $eventsList);
37
38			$this->registerEventsToListener($eventsList, $container);
39
40			}
41
42			private function appendDoctrineEventsToList(ContainerBuilder $container, &$events = array())
43			{
44			$doctrine_entities = $container->getParameter('xiidea.easy_audit.doctrine_entities');
45
46			if ($doctrine_entities === false) {
47			return;
48			}
49
50			foreach (DoctrineEvents::getConstants() as $constant) {
51			array_push($events, $constant);
52			}
53			}
54
55			/**
56			* @param ContainerBuilder $container
57			* @param array $events
58			*/
59			private function appendSubscribedEventsToList(ContainerBuilder $container, &$events = array())
60			{
61			$taggedSubscribers = $container->findTaggedServiceIds('easy_audit.event_subscriber');
62
63			if (empty($taggedSubscribers)) {
64			return;
65			}
66
67			foreach ($taggedSubscribers as $id => $attributes) {
68			$this->appendEventsFromSubscriber($container, $events, $id,
69			$this->getResolverFromConfigurationAttributes($attributes)
70			);
71			}
72			}
73
74			/**
75			* @param $attributes
76			* @return null
77			*/
78			private function getResolverFromConfigurationAttributes($attributes)
79			{
80			return isset($attributes[0]) && isset($attributes[0]['resolver']) ? $attributes[0]['resolver'] : null;
81			}
82
83			/**
84			* @param ContainerBuilder $container
85			* @param $events
86			* @param $id
87			* @param $defaultResolver
88			*/
89			private function appendEventsFromSubscriber(ContainerBuilder $container, &$events, $id, $defaultResolver = null)
90			{
91			$subscriber = $container->get($id);
92
93			$subscribedEvents = $subscriber->getSubscribedEvents();
94
95			foreach ($subscribedEvents as $key => $item) {
96
97			$resolver = !empty($defaultResolver) && !is_string($key) ? $defaultResolver : $key;
98			$this->addEventFromSubscriber($events, $item, $resolver);
99			}
100			}
101
102			/**
103			* @param $events
104			* @param $item
105			* @param $resolver
106			*/
107			private function addEventFromSubscriber(&$events, $item, $resolver)
108			{
109			$items = array($item);
110			foreach ($items as $value) {
111			$this->appendEventArray($events, $resolver, $value);
112			}
113			}
114
115			/**
116			* @param $events
117			* @param $resolver
118			* @param $item
119			*/
120			private function appendEventArray(&$events, $resolver, $item)
121			{
122			if ($this->isEventWithResolver($resolver)) {
123			$this->appendEventWithResolver($events, $item, $resolver);
124			return;
125			}
126
127			array_push($events, $item);
128			}
129
130			/**
131			* @param $resolver
132			* @return bool
133			*/
134			private function isEventWithResolver($resolver)
135			{
136			return is_string($resolver);
137			}
138
139			/**
140			* @param $events
141			* @param $items
142			* @param $key
143			* @internal param $event
144			*/
145			private function appendEventWithResolver(&$events, $items, $key)
146			{
147			$items = (array) $items;
148
149			foreach($items as $item) {
150			array_push($events, array($item => $key));
151			}
152			}
153
154			/**
155			* @param $events
156			* @param ContainerBuilder $container
157			*/
158			private function registerEventsToListener($events, ContainerBuilder $container)
159			{
160			if(empty($events)) {
161			return;
162			}
163
164			$definition = $container->getDefinition('xiidea.easy_audit.event_listener');
165			$customResolvers = $container->getParameter('xiidea.easy_audit.custom_resolvers');
166
167			$listenableEventsList = $this->getListenableEventList($events);
168			$this->buildCustomResolverList($events, $customResolvers);
169
170			$definition->setTags(array('kernel.event_listener' => array_values($listenableEventsList)));
171			$container->setParameter('xiidea.easy_audit.custom_resolvers', $customResolvers);
172			}
173
174			/**
175			* @param $events
176			* @return array
177			*/
178			private function getListenableEventList($events)
179			{
180			$eventList = array();
181
182			foreach ($events as $item) {
183
184			$event = is_array($item) ? key($item) : $item;
185
186			$eventList[$event] = array(
187			'event' => $event,
188			'method' => 'resolveEventHandler'
189			);
190			}
191
192			return $eventList;
193			}
194
195			private function buildCustomResolverList($events, &$customResolver)
196			{
197			foreach ($events as $item) {
198			if (is_array($item)) {
199			$event = key($item);
200			$resolver = $item[$event];
201			$customResolver[$event] = $resolver;
202			}
203			}
204			}
205			}
206

xiidea / EasyAuditBundle

Push — master ( e9e666...e79deb )

SubscriberPass::getDoctrineEventsList() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like