Initial commit

vendor/symfony/monolog-bundle/DependencyInjection/Compiler/AddProcessorsPass.php

@@ -0,0 +1,59 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Bundle\MonologBundle\DependencyInjection\Compiler;
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+use Symfony\Component\DependencyInjection\Reference;
+
+/**
+ * Registers processors in Monolog loggers or handlers.
+ *
+ * @author Christophe Coevoet <stof@notk.org>
+ */
+class AddProcessorsPass implements CompilerPassInterface
+{
+    public function process(ContainerBuilder $container)
+    {
+        if (!$container->hasDefinition('monolog.logger')) {
+            return;
+        }
+
+        foreach ($container->findTaggedServiceIds('monolog.processor') as $id => $tags) {
+            foreach ($tags as $tag) {
+                if (!empty($tag['channel']) && !empty($tag['handler'])) {
+                    throw new \InvalidArgumentException(sprintf('you cannot specify both the "handler" and "channel" attributes for the "monolog.processor" tag on service "%s"', $id));
+                }
+
+                if (!empty($tag['handler'])) {
+                    $definition = $container->findDefinition(sprintf('monolog.handler.%s', $tag['handler']));
+                } elseif (!empty($tag['channel'])) {
+                    if ('app' === $tag['channel']) {
+                        $definition = $container->getDefinition('monolog.logger');
+                    } else {
+                        $definition = $container->getDefinition(sprintf('monolog.logger.%s', $tag['channel']));
+                    }
+                } else {
+                    $definition = $container->getDefinition('monolog.logger_prototype');
+                }
+
+                if (!empty($tag['method'])) {
+                    $processor = array(new Reference($id), $tag['method']);
+                } else {
+                    // If no method is defined, fallback to use __invoke
+                    $processor = new Reference($id);
+                }
+                $definition->addMethodCall('pushProcessor', array($processor));
+            }
+        }
+    }
+}

vendor/symfony/monolog-bundle/DependencyInjection/Compiler/AddSwiftMailerTransportPass.php

@@ -0,0 +1,57 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Bundle\MonologBundle\DependencyInjection\Compiler;
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+use Symfony\Component\DependencyInjection\Reference;
+
+/**
+ * Sets the transport for Swiftmailer handlers depending on the existing
+ * container definitions.
+ *
+ * @author Christian Flothmann <christian.flothmann@xabbuh.de>
+ */
+class AddSwiftMailerTransportPass implements CompilerPassInterface
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function process(ContainerBuilder $container)
+    {
+        $handlers = $container->getParameter('monolog.swift_mailer.handlers');
+
+        foreach ($handlers as $id) {
+            $definition = $container->getDefinition($id);
+            $mailerId = (string) $definition->getArgument(0);
+
+            // Try to fetch the transport for a non-default mailer first, then go with the default swiftmailer
+            $possibleServices = array(
+                $mailerId.'.transport.real',
+                $mailerId.'.transport',
+                'swiftmailer.transport.real',
+                'swiftmailer.transport',
+            );
+
+            foreach ($possibleServices as $serviceId) {
+                if ($container->hasAlias($serviceId) || $container->hasDefinition($serviceId)) {
+                    $definition->addMethodCall(
+                        'setTransport',
+                        array(new Reference($serviceId))
+                    );
+
+                    break;
+                }
+            }
+        }
+    }
+}

vendor/symfony/monolog-bundle/DependencyInjection/Compiler/DebugHandlerPass.php

@@ -0,0 +1,61 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Bundle\MonologBundle\DependencyInjection\Compiler;
+
+use Symfony\Component\DependencyInjection\Reference;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+use Symfony\Component\DependencyInjection\Definition;
+use Monolog\Logger;
+
+/**
+ * Adds the DebugHandler when the profiler is enabled and kernel.debug is true.
+ *
+ * @author Christophe Coevoet <stof@notk.org>
+ * @author Jordi Boggiano <j.boggiano@seld.be>
+ *
+ * @deprecated since version 2.12, to be removed in 4.0. Use AddDebugLogProcessorPass in FrameworkBundle instead.
+ */
+class DebugHandlerPass implements CompilerPassInterface
+{
+    private $channelPass;
+
+    public function __construct(LoggerChannelPass $channelPass)
+    {
+        // Trigger the deprecation only when using a Symfony version supporting the new feature (i.e. 3.2+)
+        if (class_exists('Symfony\Bridge\Monolog\Processor\DebugProcessor') && class_exists('Symfony\Bundle\FrameworkBundle\DependencyInjection\Compiler\AddDebugLogProcessorPass')) {
+            @trigger_error('The '.__CLASS__.' class is deprecated since version 2.12 and will be removed in 4.0. Use AddDebugLogProcessorPass in FrameworkBundle instead.', E_USER_DEPRECATED);
+        }
+
+        $this->channelPass = $channelPass;
+    }
+
+    public function process(ContainerBuilder $container)
+    {
+        if (!$container->hasDefinition('profiler')) {
+            return;
+        }
+
+        if (!$container->getParameter('kernel.debug')) {
+            return;
+        }
+
+        $debugHandler = new Definition('Symfony\Bridge\Monolog\Handler\DebugHandler', array(Logger::DEBUG, true));
+        $container->setDefinition('monolog.handler.debug', $debugHandler);
+
+        foreach ($this->channelPass->getChannels() as $channel) {
+            $container
+                ->getDefinition($channel === 'app' ? 'monolog.logger' : 'monolog.logger.'.$channel)
+                ->addMethodCall('pushHandler', array(new Reference('monolog.handler.debug')));
+        }
+    }
+}

vendor/symfony/monolog-bundle/DependencyInjection/Compiler/FixEmptyLoggerPass.php

@@ -0,0 +1,55 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Bundle\MonologBundle\DependencyInjection\Compiler;
+
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Reference;
+
+/**
+ * Fixes loggers with no handlers (by registering a "null" one).
+ *
+ * Monolog 1.x adds a default handler logging on STDERR when a logger has
+ * no registered handlers. This is NOT what what we want in Symfony, so in such
+ * cases, we add a "null" handler to avoid the issue.
+ *
+ * Note that Monolog 2.x does not register a default handler anymore, so this pass can
+ * be removed when MonologBundle minimum version of Monolog is bumped to 2.0.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ *
+ * @see https://github.com/Seldaek/monolog/commit/ad37b7b2d11f300cbace9f5e84f855d329519e28
+ */
+class FixEmptyLoggerPass implements CompilerPassInterface
+{
+    private $channelPass;
+
+    public function __construct(LoggerChannelPass $channelPass)
+    {
+        $this->channelPass = $channelPass;
+    }
+
+    public function process(ContainerBuilder $container)
+    {
+        $container->register('monolog.handler.null_internal', 'Monolog\Handler\NullHandler');
+        foreach ($this->channelPass->getChannels() as $channel) {
+            $def = $container->getDefinition($channel === 'app' ? 'monolog.logger' : 'monolog.logger.'.$channel);
+            foreach ($def->getMethodCalls() as $method) {
+                if ('pushHandler' === $method[0]) {
+                    continue 2;
+                }
+            }
+
+            $def->addMethodCall('pushHandler', array(new Reference('monolog.handler.null_internal')));
+        }
+    }
+}

vendor/symfony/monolog-bundle/DependencyInjection/Compiler/LoggerChannelPass.php

@@ -0,0 +1,155 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Bundle\MonologBundle\DependencyInjection\Compiler;
+
+use Symfony\Component\DependencyInjection\Argument\BoundArgument;
+use Symfony\Component\DependencyInjection\Reference;
+use Symfony\Component\DependencyInjection\ChildDefinition;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+use Symfony\Component\DependencyInjection\DefinitionDecorator;
+use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
+
+/**
+ * Replaces the default logger by another one with its own channel for tagged services.
+ *
+ * @author Christophe Coevoet <stof@notk.org>
+ */
+class LoggerChannelPass implements CompilerPassInterface
+{
+    protected $channels = array('app');
+
+    public function process(ContainerBuilder $container)
+    {
+        if (!$container->hasDefinition('monolog.logger')) {
+            return;
+        }
+
+        // create channels necessary for the handlers
+        foreach ($container->findTaggedServiceIds('monolog.logger') as $id => $tags) {
+            foreach ($tags as $tag) {
+                if (empty($tag['channel']) || 'app' === $tag['channel']) {
+                    continue;
+                }
+
+                $resolvedChannel = $container->getParameterBag()->resolveValue($tag['channel']);
+
+                $definition = $container->getDefinition($id);
+                $loggerId = sprintf('monolog.logger.%s', $resolvedChannel);
+                $this->createLogger($resolvedChannel, $loggerId, $container);
+
+                foreach ($definition->getArguments() as $index => $argument) {
+                    if ($argument instanceof Reference && 'logger' === (string) $argument) {
+                        $definition->replaceArgument($index, $this->changeReference($argument, $loggerId));
+                    }
+                }
+
+                $calls = $definition->getMethodCalls();
+                foreach ($calls as $i => $call) {
+                    foreach ($call[1] as $index => $argument) {
+                        if ($argument instanceof Reference && 'logger' === (string) $argument) {
+                            $calls[$i][1][$index] = $this->changeReference($argument, $loggerId);
+                        }
+                    }
+                }
+                $definition->setMethodCalls($calls);
+
+                if (\method_exists($definition, 'getBindings')) {
+                    $binding = new BoundArgument(new Reference($loggerId));
+
+                    // Mark the binding as used already, to avoid reporting it as unused if the service does not use a
+                    // logger injected through the LoggerInterface alias.
+                    $values = $binding->getValues();
+                    $values[2] = true;
+                    $binding->setValues($values);
+
+                    $bindings = $definition->getBindings();
+                    $bindings['Psr\Log\LoggerInterface'] = $binding;
+                    $definition->setBindings($bindings);
+                }
+            }
+        }
+
+        // create additional channels
+        foreach ($container->getParameter('monolog.additional_channels') as $chan) {
+            $loggerId = sprintf('monolog.logger.%s', $chan);
+            $this->createLogger($chan, $loggerId, $container);
+            $container->getDefinition($loggerId)->setPublic(true);
+        }
+        $container->getParameterBag()->remove('monolog.additional_channels');
+
+        // wire handlers to channels
+        $handlersToChannels = $container->getParameter('monolog.handlers_to_channels');
+        foreach ($handlersToChannels as $handler => $channels) {
+            foreach ($this->processChannels($channels) as $channel) {
+                try {
+                    $logger = $container->getDefinition($channel === 'app' ? 'monolog.logger' : 'monolog.logger.'.$channel);
+                } catch (InvalidArgumentException $e) {
+                    $msg = 'Monolog configuration error: The logging channel "'.$channel.'" assigned to the "'.substr($handler, 16).'" handler does not exist.';
+                    throw new \InvalidArgumentException($msg, 0, $e);
+                }
+                $logger->addMethodCall('pushHandler', array(new Reference($handler)));
+            }
+        }
+    }
+
+    public function getChannels()
+    {
+        return $this->channels;
+    }
+
+    protected function processChannels($configuration)
+    {
+        if (null === $configuration) {
+            return $this->channels;
+        }
+
+        if ('inclusive' === $configuration['type']) {
+            return $configuration['elements'] ?: $this->channels;
+        }
+
+        return array_diff($this->channels, $configuration['elements']);
+    }
+
+    protected function createLogger($channel, $loggerId, ContainerBuilder $container)
+    {
+        if (!in_array($channel, $this->channels)) {
+            if (class_exists('Symfony\Component\DependencyInjection\ChildDefinition')) {
+                $logger = new ChildDefinition('monolog.logger_prototype');
+            } else {
+                $logger = new DefinitionDecorator('monolog.logger_prototype');
+            }
+
+            $logger->replaceArgument(0, $channel);
+            $container->setDefinition($loggerId, $logger);
+            $this->channels[] = $channel;
+        }
+    }
+
+    /**
+     * Creates a copy of a reference and alters the service ID.
+     *
+     * @param Reference $reference
+     * @param string    $serviceId
+     *
+     * @return Reference
+     */
+    private function changeReference(Reference $reference, $serviceId)
+    {
+        if (method_exists($reference, 'isStrict')) {
+            // Stay compatible with Symfony 2
+            return new Reference($serviceId, $reference->getInvalidBehavior(), $reference->isStrict(false));
+        }
+
+        return new Reference($serviceId, $reference->getInvalidBehavior());
+    }
+}