EmailEngineExtension::createResolver() - Code Metrics - Inspection of "Merge pull request #2 from sfcod/remove-container" - sfcod/email-engine - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( e347f9...ce4937 )

by Alexey

created 2018-06-18 11:46 UTC

EmailEngineExtension::createResolver() A

↳ Parent: EmailEngineExtension

Complexity

Conditions	1
Paths	1

Size

Total Lines	11
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	11
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	7
nc	1
nop	2

<?php

namespace SfCod\EmailEngineBundle\DependencyInjection;

use SfCod\EmailEngineBundle\Mailer\Mailer;
use SfCod\EmailEngineBundle\Mailer\TemplateManager;
use SfCod\EmailEngineBundle\Template\ParametersAwareInterface;
use SfCod\EmailEngineBundle\Template\Params\ParameterResolver;
use SfCod\EmailEngineBundle\Template\Params\ParameterResolverInterface;
use Symfony\Component\Config\Definition\Exception\InvalidConfigurationException;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\ContainerInterface;
use Symfony\Component\DependencyInjection\Definition;
use Symfony\Component\DependencyInjection\Extension\Extension;
use Symfony\Component\DependencyInjection\Reference;

/**
 * Class EmailEngineExtension
 *
 * @author Virchenko Maksim <[email protected]>
 *
 * @package SfCod\EmailEngineBundle\DependencyInjection
 */
class EmailEngineExtension extends Extension
{
    /**
     * Loads a specific configuration.
     *
     * @param array $configs
     * @param ContainerBuilder $container
     */
    public function load(array $configs, ContainerBuilder $container)
    {
        $configuration = new EmailEngineConfiguration();

        $config = $this->processConfiguration($configuration, $configs);

        $this->createSenders($config, $container);
        $this->createTemplates($config, $container);
        $this->createResolver($config, $container);
    }

    /**
     * Get extension alias
     *
     * @return string
     */
    public function getAlias()
    {
        return 'sfcod_email_engine';
    }

    /**
     * Create parameter resolver
     *
     * @param array $config
     * @param ContainerBuilder $container
     */
    private function createResolver(array $config, ContainerBuilder $container)

    {
        $resolver = new Definition(ParameterResolverInterface::class);
        $resolver->setPublic(true);
        $resolver->setClass(ParameterResolver::class);
        $resolver->setArguments([
            new Reference(ContainerInterface::class),
        ]);

        $container->setDefinition(ParameterResolverInterface::class, $resolver);
    }

    /**
     * Create senders
     *
     * @param array $config
     * @param ContainerBuilder $container
     */
    private function createSenders(array $config, ContainerBuilder $container)
    {
        $senders = [];
        $mainSender = $this->getSender($config['main_sender'], $config);

        if (isset($mainSender['chain'])) {
            foreach ($mainSender['chain']['senders'] as $sender) {
                $senders[$sender] = $this->getSender($sender, $config);
            }
        } else {
            $senders[$config['main_sender']] = $mainSender;
        }

        foreach ($senders as $name => $config) {
            if (false === isset($config['sender'], $config['repository']) ||
                false === isset($config['sender']['class'], $config['repository']['class'])) {
                throw  new InvalidConfigurationException(sprintf('"sender" and "repository" must be defined in "%s" sender.', $name));
            }

            $sender = new Definition($config['sender']['class']);
            $sender
                ->setPublic(true)
                ->setAutoconfigured(true)
                ->setAutowired(true);

            $repository = new Definition($config['repository']['class']);
            $repository
                ->setPublic(true)
                ->setAutoconfigured(true)
                ->setAutowired(true);

            $container->addDefinitions([
                $config['repository']['class'] => $repository,
                $config['sender']['class'] => $sender,
            ]);
        }

        $mailer = new Definition(Mailer::class);
        $mailer
            ->setPublic(true)
            ->setArguments([
                new Reference(ContainerInterface::class),
            ])
            ->addMethodCall('setSenders', [$senders]);

        $container->setDefinition(Mailer::class, $mailer);
    }

    /**
     * Get sender from senders config
     *
     * @param string $sender
     * @param array $config
     *
     * @return array
     */
    private function getSender(string $sender, array $config): array
    {
        if (false === isset($config['senders'][$sender])) {
            throw new InvalidConfigurationException(sprintf('Main sender "%s" does not exist in senders "%s".', $sender, json_encode(array_keys($config['senders']))));
        }

        return $config['senders'][$sender];
    }

    /**
     * Create templates
     *
     * @param array $config
     * @param ContainerBuilder $container
     */
    private function createTemplates(array $config, ContainerBuilder $container)
    {
        foreach ($config['templates'] as $template) {
            if (in_array(ParametersAwareInterface::class, class_implements($template))) {
                /** @var ParametersAwareInterface $template */
                foreach ($template::listParameters() as $parameter) {
                    $definition = new Definition($parameter);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                    $definition
                        ->setPublic(true)
                        ->setAutowired(true)
                        ->setAutoconfigured(true)
                        ->addTag(sprintf('%s.parameter', $template));

                    $container->setDefinition($parameter, $definition);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                }
            }
        }

        $templateManager = new Definition(TemplateManager::class);
        $templateManager
            ->setPublic(true)
            ->addArgument($config['templates']);

        $container->setDefinition(TemplateManager::class, $templateManager);
    }
}


1			<?php
2
3			namespace SfCod\EmailEngineBundle\DependencyInjection;
4
5			use SfCod\EmailEngineBundle\Mailer\Mailer;
6			use SfCod\EmailEngineBundle\Mailer\TemplateManager;
7			use SfCod\EmailEngineBundle\Template\ParametersAwareInterface;
8			use SfCod\EmailEngineBundle\Template\Params\ParameterResolver;
9			use SfCod\EmailEngineBundle\Template\Params\ParameterResolverInterface;
10			use Symfony\Component\Config\Definition\Exception\InvalidConfigurationException;
11			use Symfony\Component\DependencyInjection\ContainerBuilder;
12			use Symfony\Component\DependencyInjection\ContainerInterface;
13			use Symfony\Component\DependencyInjection\Definition;
14			use Symfony\Component\DependencyInjection\Extension\Extension;
15			use Symfony\Component\DependencyInjection\Reference;
16
17			/**
18			* Class EmailEngineExtension
19			*
20			* @author Virchenko Maksim <[email protected]>
21			*
22			* @package SfCod\EmailEngineBundle\DependencyInjection
23			*/
24			class EmailEngineExtension extends Extension
25			{
26			/**
27			* Loads a specific configuration.
28			*
29			* @param array $configs
30			* @param ContainerBuilder $container
31			*/
32			public function load(array $configs, ContainerBuilder $container)
33			{
34			$configuration = new EmailEngineConfiguration();
35
36			$config = $this->processConfiguration($configuration, $configs);
37
38			$this->createSenders($config, $container);
39			$this->createTemplates($config, $container);
40			$this->createResolver($config, $container);
41			}
42
43			/**
44			* Get extension alias
45			*
46			* @return string
47			*/
48			public function getAlias()
49			{
50			return 'sfcod_email_engine';
51			}
52
53			/**
54			* Create parameter resolver
55			*
56			* @param array $config
57			* @param ContainerBuilder $container
58			*/
59			private function createResolver(array $config, ContainerBuilder $container)
			0 ignored issues – show Unused Code introduced 2018-06-18 12:18 UTC by Report Bug Copy Issue Report The parameter `$config` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
60			{
61			$resolver = new Definition(ParameterResolverInterface::class);
62			$resolver->setPublic(true);
63			$resolver->setClass(ParameterResolver::class);
64			$resolver->setArguments([
65			new Reference(ContainerInterface::class),
66			]);
67
68			$container->setDefinition(ParameterResolverInterface::class, $resolver);
69			}
70
71			/**
72			* Create senders
73			*
74			* @param array $config
75			* @param ContainerBuilder $container
76			*/
77			private function createSenders(array $config, ContainerBuilder $container)
78			{
79			$senders = [];
80			$mainSender = $this->getSender($config['main_sender'], $config);
81
82			if (isset($mainSender['chain'])) {
83			foreach ($mainSender['chain']['senders'] as $sender) {
84			$senders[$sender] = $this->getSender($sender, $config);
85			}
86			} else {
87			$senders[$config['main_sender']] = $mainSender;
88			}
89
90			foreach ($senders as $name => $config) {
91			if (false === isset($config['sender'], $config['repository']) \|\|
92			false === isset($config['sender']['class'], $config['repository']['class'])) {
93			throw new InvalidConfigurationException(sprintf('"sender" and "repository" must be defined in "%s" sender.', $name));
94			}
95
96			$sender = new Definition($config['sender']['class']);
97			$sender
98			->setPublic(true)
99			->setAutoconfigured(true)
100			->setAutowired(true);
101
102			$repository = new Definition($config['repository']['class']);
103			$repository
104			->setPublic(true)
105			->setAutoconfigured(true)
106			->setAutowired(true);
107
108			$container->addDefinitions([
109			$config['repository']['class'] => $repository,
110			$config['sender']['class'] => $sender,
111			]);
112			}
113
114			$mailer = new Definition(Mailer::class);
115			$mailer
116			->setPublic(true)
117			->setArguments([
118			new Reference(ContainerInterface::class),
119			])
120			->addMethodCall('setSenders', [$senders]);
121
122			$container->setDefinition(Mailer::class, $mailer);
123			}
124
125			/**
126			* Get sender from senders config
127			*
128			* @param string $sender
129			* @param array $config
130			*
131			* @return array
132			*/
133			private function getSender(string $sender, array $config): array
134			{
135			if (false === isset($config['senders'][$sender])) {
136			throw new InvalidConfigurationException(sprintf('Main sender "%s" does not exist in senders "%s".', $sender, json_encode(array_keys($config['senders']))));
137			}
138
139			return $config['senders'][$sender];
140			}
141
142			/**
143			* Create templates
144			*
145			* @param array $config
146			* @param ContainerBuilder $container
147			*/
148			private function createTemplates(array $config, ContainerBuilder $container)
149			{
150			foreach ($config['templates'] as $template) {
151			if (in_array(ParametersAwareInterface::class, class_implements($template))) {
152			/** @var ParametersAwareInterface $template */
153			foreach ($template::listParameters() as $parameter) {
154			$definition = new Definition($parameter);
			0 ignored issues – show Documentation introduced 2018-06-18 12:18 UTC by Report Bug Copy Issue Report `$parameter` is of type `object<SfCod\EmailEngine...ams\ParameterInterface>`, but the function expects a `string\|null`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
155			$definition
156			->setPublic(true)
157			->setAutowired(true)
158			->setAutoconfigured(true)
159			->addTag(sprintf('%s.parameter', $template));
160
161			$container->setDefinition($parameter, $definition);
			0 ignored issues – show Documentation introduced 2018-06-18 12:18 UTC by Report Bug Copy Issue Report `$parameter` is of type `object<SfCod\EmailEngine...ams\ParameterInterface>`, but the function expects a `string`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
162			}
163			}
164			}
165
166			$templateManager = new Definition(TemplateManager::class);
167			$templateManager
168			->setPublic(true)
169			->addArgument($config['templates']);
170
171			$container->setDefinition(TemplateManager::class, $templateManager);
172			}
173			}
174

sfcod / email-engine

Push — master ( e347f9...ce4937 )

EmailEngineExtension::createResolver() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like