Update Composer, update everything

vendor/symfony/dependency-injection/Tests/Fixtures/containers/CustomContainer.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace Symfony\Component\DependencyInjection\Tests\Fixtures\containers;
+
+use Symfony\Component\DependencyInjection\Container;
+use Symfony\Component\DependencyInjection\ParameterBag\ParameterBag;
+
+class CustomContainer extends Container
+{
+    public function getBarService()
+    {
+    }
+
+    public function getFoobarService()
+    {
+    }
+}

vendor/symfony/dependency-injection/Tests/Fixtures/containers/container10.php

@@ -0,0 +1,15 @@
+<?php
+
+require_once __DIR__.'/../includes/classes.php';
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Reference;
+
+$container = new ContainerBuilder();
+$container->
+    register('foo', 'FooClass')->
+    addArgument(new Reference('bar'))
+    ->setPublic(true)
+;
+
+return $container;

vendor/symfony/dependency-injection/Tests/Fixtures/containers/container11.php

@@ -0,0 +1,13 @@
+<?php
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Definition;
+
+$container = new ContainerBuilder();
+$container->
+    register('foo', 'FooClass')->
+    addArgument(new Definition('BarClass', array(new Definition('BazClass'))))
+    ->setPublic(true)
+;
+
+return $container;

vendor/symfony/dependency-injection/Tests/Fixtures/containers/container12.php

@@ -0,0 +1,13 @@
+<?php
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+
+$container = new ContainerBuilder();
+$container->
+    register('foo', 'FooClass\\Foo')->
+    addArgument('foo<>&bar')->
+    addTag('foo"bar\\bar', array('foo' => 'foo"barřž€'))
+    ->setPublic(true)
+;
+
+return $container;

vendor/symfony/dependency-injection/Tests/Fixtures/containers/container13.php

@@ -0,0 +1,18 @@
+<?php
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Reference;
+
+$container = new ContainerBuilder();
+$container->
+    register('foo', 'FooClass')->
+    addArgument(new Reference('bar'))
+    ->setPublic(true)
+;
+$container->
+    register('bar', 'BarClass')
+    ->setPublic(true)
+;
+$container->compile();
+
+return $container;

vendor/symfony/dependency-injection/Tests/Fixtures/containers/container14.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace Container14;
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+
+/*
+ * This file is included in Tests\Dumper\GraphvizDumperTest::testDumpWithFrozenCustomClassContainer
+ * and Tests\Dumper\XmlDumperTest::testCompiledContainerCanBeDumped.
+ */
+if (!class_exists('Container14\ProjectServiceContainer')) {
+    class ProjectServiceContainer extends ContainerBuilder
+    {
+    }
+}
+
+return new ProjectServiceContainer();

vendor/symfony/dependency-injection/Tests/Fixtures/containers/container15.php

@@ -0,0 +1,12 @@
+<?php
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+
+$container = new ContainerBuilder();
+$container
+    ->register('foo', 'FooClass\\Foo')
+    ->setDecoratedService('bar', 'bar.woozy')
+    ->setPublic(true)
+;
+
+return $container;

vendor/symfony/dependency-injection/Tests/Fixtures/containers/container16.php

@@ -0,0 +1,12 @@
+<?php
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+
+$container = new ContainerBuilder();
+$container
+    ->register('foo', 'FooClass\\Foo')
+    ->setDecoratedService('bar')
+    ->setPublic(true)
+;
+
+return $container;

vendor/symfony/dependency-injection/Tests/Fixtures/containers/container17.php

@@ -0,0 +1,11 @@
+<?php
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+
+$container = new ContainerBuilder();
+$container
+    ->register('foo', '%foo.class%')
+    ->setPublic(true)
+;
+
+return $container;

vendor/symfony/dependency-injection/Tests/Fixtures/containers/container19.php

@@ -0,0 +1,27 @@
+<?php
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Definition;
+
+require_once __DIR__.'/../includes/classes.php';
+
+$container = new ContainerBuilder();
+
+$container->setParameter('env(FOO)', 'Bar\FaooClass');
+$container->setParameter('foo', '%env(FOO)%');
+
+$container
+    ->register('service_from_anonymous_factory', '%foo%')
+    ->setFactory(array(new Definition('%foo%'), 'getInstance'))
+    ->setPublic(true)
+;
+
+$anonymousServiceWithFactory = new Definition('Bar\FooClass');
+$anonymousServiceWithFactory->setFactory('Bar\FooClass::getInstance');
+$container
+    ->register('service_with_method_call_and_factory', 'Bar\FooClass')
+    ->addMethodCall('setBar', array($anonymousServiceWithFactory))
+    ->setPublic(true)
+;
+
+return $container;

vendor/symfony/dependency-injection/Tests/Fixtures/containers/container21.php

@@ -0,0 +1,21 @@
+<?php
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Definition;
+
+$container = new ContainerBuilder();
+
+$bar = new Definition('Bar');
+$bar->setConfigurator(array(new Definition('Baz'), 'configureBar'));
+
+$fooFactory = new Definition('FooFactory');
+$fooFactory->setFactory(array(new Definition('Foobar'), 'createFooFactory'));
+
+$container
+    ->register('foo', 'Foo')
+    ->setFactory(array($fooFactory, 'createFoo'))
+    ->setConfigurator(array($bar, 'configureFoo'))
+    ->setPublic(true)
+;
+
+return $container;

vendor/symfony/dependency-injection/Tests/Fixtures/containers/container24.php

@@ -0,0 +1,13 @@
+<?php
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+
+$container = new ContainerBuilder();
+
+$container
+    ->register('foo', 'Foo')
+    ->setAutowired(true)
+    ->setPublic(true)
+;
+
+return $container;

vendor/symfony/dependency-injection/Tests/Fixtures/containers/container33.php

@@ -0,0 +1,12 @@
+<?php
+
+namespace Symfony\Component\DependencyInjection\Tests\Fixtures\Container33;
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+
+$container = new ContainerBuilder();
+
+$container->register(\Foo\Foo::class)->setPublic(true);
+$container->register(\Bar\Foo::class)->setPublic(true);
+
+return $container;

vendor/symfony/dependency-injection/Tests/Fixtures/containers/container8.php

@@ -0,0 +1,14 @@
+<?php
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\ParameterBag\ParameterBag;
+
+$container = new ContainerBuilder(new ParameterBag(array(
+    'foo' => '%baz%',
+    'baz' => 'bar',
+    'bar' => 'foo is %%foo bar',
+    'escape' => '@escapeme',
+    'values' => array(true, false, null, 0, 1000.3, 'true', 'false', 'null'),
+)));
+
+return $container;

vendor/symfony/dependency-injection/Tests/Fixtures/containers/container9.php

@@ -0,0 +1,176 @@
+<?php
+
+require_once __DIR__.'/../includes/classes.php';
+require_once __DIR__.'/../includes/foo.php';
+
+use Symfony\Component\DependencyInjection\Argument\IteratorArgument;
+use Symfony\Component\DependencyInjection\Argument\TaggedIteratorArgument;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Reference;
+use Symfony\Component\DependencyInjection\Parameter;
+use Symfony\Component\ExpressionLanguage\Expression;
+
+$container = new ContainerBuilder();
+$container
+    ->register('foo', '\Bar\FooClass')
+    ->addTag('foo', array('foo' => 'foo'))
+    ->addTag('foo', array('bar' => 'bar', 'baz' => 'baz'))
+    ->setFactory(array('Bar\\FooClass', 'getInstance'))
+    ->setArguments(array('foo', new Reference('foo.baz'), array('%foo%' => 'foo is %foo%', 'foobar' => '%foo%'), true, new Reference('service_container')))
+    ->setProperties(array('foo' => 'bar', 'moo' => new Reference('foo.baz'), 'qux' => array('%foo%' => 'foo is %foo%', 'foobar' => '%foo%')))
+    ->addMethodCall('setBar', array(new Reference('bar')))
+    ->addMethodCall('initialize')
+    ->setConfigurator('sc_configure')
+    ->setPublic(true)
+;
+$container
+    ->register('foo.baz', '%baz_class%')
+    ->setFactory(array('%baz_class%', 'getInstance'))
+    ->setConfigurator(array('%baz_class%', 'configureStatic1'))
+    ->setPublic(true)
+;
+$container
+    ->register('bar', 'Bar\FooClass')
+    ->setArguments(array('foo', new Reference('foo.baz'), new Parameter('foo_bar')))
+    ->setConfigurator(array(new Reference('foo.baz'), 'configure'))
+    ->setPublic(true)
+;
+$container
+    ->register('foo_bar', '%foo_class%')
+    ->addArgument(new Reference('deprecated_service'))
+    ->setShared(false)
+    ->setPublic(true)
+;
+$container->getParameterBag()->clear();
+$container->getParameterBag()->add(array(
+    'baz_class' => 'BazClass',
+    'foo_class' => 'Bar\FooClass',
+    'foo' => 'bar',
+));
+$container
+    ->register('method_call1', 'Bar\FooClass')
+    ->setFile(realpath(__DIR__.'/../includes/foo.php'))
+    ->addMethodCall('setBar', array(new Reference('foo')))
+    ->addMethodCall('setBar', array(new Reference('foo2', ContainerInterface::NULL_ON_INVALID_REFERENCE)))
+    ->addMethodCall('setBar', array(new Reference('foo3', ContainerInterface::IGNORE_ON_INVALID_REFERENCE)))
+    ->addMethodCall('setBar', array(new Reference('foobaz', ContainerInterface::IGNORE_ON_INVALID_REFERENCE)))
+    ->addMethodCall('setBar', array(new Expression('service("foo").foo() ~ (container.hasParameter("foo") ? parameter("foo") : "default")')))
+    ->setPublic(true)
+;
+$container
+    ->register('foo_with_inline', 'Foo')
+    ->addMethodCall('setBar', array(new Reference('inlined')))
+    ->setPublic(true)
+;
+$container
+    ->register('inlined', 'Bar')
+    ->setProperty('pub', 'pub')
+    ->addMethodCall('setBaz', array(new Reference('baz')))
+    ->setPublic(false)
+;
+$container
+    ->register('baz', 'Baz')
+    ->addMethodCall('setFoo', array(new Reference('foo_with_inline')))
+    ->setPublic(true)
+;
+$container
+    ->register('request', 'Request')
+    ->setSynthetic(true)
+    ->setPublic(true)
+;
+$container
+    ->register('configurator_service', 'ConfClass')
+    ->setPublic(false)
+    ->addMethodCall('setFoo', array(new Reference('baz')))
+;
+$container
+    ->register('configured_service', 'stdClass')
+    ->setConfigurator(array(new Reference('configurator_service'), 'configureStdClass'))
+    ->setPublic(true)
+;
+$container
+    ->register('configurator_service_simple', 'ConfClass')
+    ->addArgument('bar')
+    ->setPublic(false)
+;
+$container
+    ->register('configured_service_simple', 'stdClass')
+    ->setConfigurator(array(new Reference('configurator_service_simple'), 'configureStdClass'))
+    ->setPublic(true)
+;
+$container
+    ->register('decorated', 'stdClass')
+    ->setPublic(true)
+;
+$container
+    ->register('decorator_service', 'stdClass')
+    ->setDecoratedService('decorated')
+    ->setPublic(true)
+;
+$container
+    ->register('decorator_service_with_name', 'stdClass')
+    ->setDecoratedService('decorated', 'decorated.pif-pouf')
+    ->setPublic(true)
+;
+$container
+    ->register('deprecated_service', 'stdClass')
+    ->setDeprecated(true)
+    ->setPublic(true)
+;
+$container
+    ->register('new_factory', 'FactoryClass')
+    ->setProperty('foo', 'bar')
+    ->setPublic(false)
+;
+$container
+    ->register('factory_service', 'Bar')
+    ->setFactory(array(new Reference('foo.baz'), 'getInstance'))
+    ->setPublic(true)
+;
+$container
+    ->register('new_factory_service', 'FooBarBaz')
+    ->setProperty('foo', 'bar')
+    ->setFactory(array(new Reference('new_factory'), 'getInstance'))
+    ->setPublic(true)
+;
+$container
+    ->register('service_from_static_method', 'Bar\FooClass')
+    ->setFactory(array('Bar\FooClass', 'getInstance'))
+    ->setPublic(true)
+;
+$container
+    ->register('factory_simple', 'SimpleFactoryClass')
+    ->addArgument('foo')
+    ->setDeprecated(true)
+    ->setPublic(false)
+;
+$container
+    ->register('factory_service_simple', 'Bar')
+    ->setFactory(array(new Reference('factory_simple'), 'getInstance'))
+    ->setPublic(true)
+;
+$container
+    ->register('lazy_context', 'LazyContext')
+    ->setArguments(array(new IteratorArgument(array('k1' => new Reference('foo.baz'), 'k2' => new Reference('service_container'))), new IteratorArgument(array())))
+    ->setPublic(true)
+;
+$container
+    ->register('lazy_context_ignore_invalid_ref', 'LazyContext')
+    ->setArguments(array(new IteratorArgument(array(new Reference('foo.baz'), new Reference('invalid', ContainerInterface::IGNORE_ON_INVALID_REFERENCE))), new IteratorArgument(array())))
+    ->setPublic(true)
+;
+$container
+    ->register('tagged_iterator_foo', 'Bar')
+    ->addTag('foo')
+    ->setPublic(false)
+;
+$container
+    ->register('tagged_iterator', 'Bar')
+    ->addArgument(new TaggedIteratorArgument('foo'))
+    ->setPublic(true)
+;
+$container->setAlias('alias_for_foo', 'foo')->setPublic(true);
+$container->setAlias('alias_for_alias', 'alias_for_foo')->setPublic(true);
+
+return $container;

vendor/symfony/dependency-injection/Tests/Fixtures/containers/container_abstract.php

@@ -0,0 +1,13 @@
+<?php
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+
+$container = new ContainerBuilder();
+
+$container
+    ->register('foo', 'Foo')
+    ->setAbstract(true)
+    ->setPublic(true)
+;
+
+return $container;

vendor/symfony/dependency-injection/Tests/Fixtures/containers/container_almost_circular.php

@@ -0,0 +1,118 @@
+<?php
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\DependencyInjection\Dumper\PhpDumper;
+use Symfony\Component\DependencyInjection\Reference;
+
+$public = 'public' === $visibility;
+$container = new ContainerBuilder();
+
+// same visibility for deps
+
+$container->register('foo', FooCircular::class)->setPublic(true)
+   ->addArgument(new Reference('bar'));
+
+$container->register('bar', BarCircular::class)->setPublic($public)
+    ->addMethodCall('addFoobar', array(new Reference('foobar')));
+
+$container->register('foobar', FoobarCircular::class)->setPublic($public)
+    ->addArgument(new Reference('foo'));
+
+// mixed visibility for deps
+
+$container->register('foo2', FooCircular::class)->setPublic(true)
+   ->addArgument(new Reference('bar2'));
+
+$container->register('bar2', BarCircular::class)->setPublic(!$public)
+    ->addMethodCall('addFoobar', array(new Reference('foobar2')));
+
+$container->register('foobar2', FoobarCircular::class)->setPublic($public)
+    ->addArgument(new Reference('foo2'));
+
+// simple inline setter with internal reference
+
+$container->register('bar3', BarCircular::class)->setPublic(true)
+    ->addMethodCall('addFoobar', array(new Reference('foobar3'), new Reference('foobar3')));
+
+$container->register('foobar3', FoobarCircular::class)->setPublic($public);
+
+// loop with non-shared dep
+
+$container->register('foo4', 'stdClass')->setPublic($public)
+    ->setShared(false)
+    ->setProperty('foobar', new Reference('foobar4'));
+
+$container->register('foobar4', 'stdClass')->setPublic(true)
+    ->addArgument(new Reference('foo4'));
+
+// loop on the constructor of a setter-injected dep with property
+
+$container->register('foo5', 'stdClass')->setPublic(true)
+    ->setProperty('bar', new Reference('bar5'));
+
+$container->register('bar5', 'stdClass')->setPublic($public)
+    ->addArgument(new Reference('foo5'))
+    ->setProperty('foo', new Reference('foo5'));
+
+// doctrine-like event system + some extra
+
+$container->register('manager', 'stdClass')->setPublic(true)
+    ->addArgument(new Reference('connection'));
+
+$container->register('logger', 'stdClass')->setPublic(true)
+    ->addArgument(new Reference('connection'))
+    ->setProperty('handler', (new Definition('stdClass'))->addArgument(new Reference('manager')))
+;
+$container->register('connection', 'stdClass')->setPublic(true)
+    ->addArgument(new Reference('dispatcher'))
+    ->addArgument(new Reference('config'));
+
+$container->register('config', 'stdClass')->setPublic(false)
+    ->setProperty('logger', new Reference('logger'));
+
+$container->register('dispatcher', 'stdClass')->setPublic($public)
+    ->setLazy($public)
+    ->setProperty('subscriber', new Reference('subscriber'));
+
+$container->register('subscriber', 'stdClass')->setPublic(true)
+    ->addArgument(new Reference('manager'));
+
+// doctrine-like event system + some extra (bis)
+
+$container->register('manager2', 'stdClass')->setPublic(true)
+    ->addArgument(new Reference('connection2'));
+
+$container->register('logger2', 'stdClass')->setPublic(false)
+    ->addArgument(new Reference('connection2'))
+    ->setProperty('handler2', (new Definition('stdClass'))->addArgument(new Reference('manager2')))
+;
+$container->register('connection2', 'stdClass')->setPublic(true)
+    ->addArgument(new Reference('dispatcher2'))
+    ->addArgument(new Reference('config2'));
+
+$container->register('config2', 'stdClass')->setPublic(false)
+    ->setProperty('logger2', new Reference('logger2'));
+
+$container->register('dispatcher2', 'stdClass')->setPublic($public)
+    ->setLazy($public)
+    ->setProperty('subscriber2', new Reference('subscriber2'));
+
+$container->register('subscriber2', 'stdClass')->setPublic(false)
+    ->addArgument(new Reference('manager2'));
+
+// private service involved in a loop
+
+$container->register('foo6', 'stdClass')
+    ->setPublic(true)
+    ->setProperty('bar6', new Reference('bar6'));
+
+$container->register('bar6', 'stdClass')
+    ->setPublic(false)
+    ->addArgument(new Reference('foo6'));
+
+$container->register('baz6', 'stdClass')
+    ->setPublic(true)
+    ->setProperty('bar6', new Reference('bar6'));
+
+return $container;

vendor/symfony/dependency-injection/Tests/Fixtures/containers/container_env_in_id.php

@@ -0,0 +1,22 @@
+<?php
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\DependencyInjection\Dumper\PhpDumper;
+use Symfony\Component\DependencyInjection\Reference;
+
+$container = new ContainerBuilder();
+
+$container->setParameter('env(BAR)', 'bar');
+
+$container->register('foo', 'stdClass')->setPublic(true)
+   ->addArgument(new Reference('bar_%env(BAR)%'))
+   ->addArgument(array('baz_%env(BAR)%' => new Reference('baz_%env(BAR)%')));
+
+$container->register('bar', 'stdClass')->setPublic(true)
+   ->addArgument(new Reference('bar_%env(BAR)%'));
+
+$container->register('bar_%env(BAR)%', 'stdClass')->setPublic(false);
+$container->register('baz_%env(BAR)%', 'stdClass')->setPublic(false);
+
+return $container;

vendor/symfony/dependency-injection/Tests/Fixtures/containers/container_inline_requires.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace Symfony\Tests\InlineRequires;
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\DependencyInjection\Dumper\PhpDumper;
+use Symfony\Component\DependencyInjection\Reference;
+use Symfony\Component\DependencyInjection\Tests\Fixtures\includes\HotPath;
+use Symfony\Component\DependencyInjection\Tests\Fixtures\ParentNotExists;
+
+$container = new ContainerBuilder();
+
+$container->register(HotPath\C1::class)->addTag('container.hot_path')->setPublic(true);
+$container->register(HotPath\C2::class)->addArgument(new Reference(HotPath\C3::class))->setPublic(true);
+$container->register(HotPath\C3::class);
+$container->register(ParentNotExists::class)->setPublic(true);
+
+return $container;

vendor/symfony/dependency-injection/Tests/Fixtures/containers/container_uninitialized_ref.php

@@ -0,0 +1,49 @@
+<?php
+
+use Symfony\Component\DependencyInjection\Argument\IteratorArgument;
+use Symfony\Component\DependencyInjection\Argument\ServiceClosureArgument;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Reference;
+
+$container = new ContainerBuilder();
+
+$container
+    ->register('foo1', 'stdClass')
+    ->setPublic(true)
+;
+
+$container
+    ->register('foo2', 'stdClass')
+    ->setPublic(false)
+;
+
+$container
+    ->register('foo3', 'stdClass')
+    ->setPublic(false)
+;
+
+$container
+    ->register('baz', 'stdClass')
+    ->setProperty('foo3', new Reference('foo3'))
+    ->setPublic(true)
+;
+
+$container
+    ->register('bar', 'stdClass')
+    ->setProperty('foo1', new Reference('foo1', $container::IGNORE_ON_UNINITIALIZED_REFERENCE))
+    ->setProperty('foo2', new Reference('foo2', $container::IGNORE_ON_UNINITIALIZED_REFERENCE))
+    ->setProperty('foo3', new Reference('foo3', $container::IGNORE_ON_UNINITIALIZED_REFERENCE))
+    ->setProperty('closures', array(
+        new ServiceClosureArgument(new Reference('foo1', $container::IGNORE_ON_UNINITIALIZED_REFERENCE)),
+        new ServiceClosureArgument(new Reference('foo2', $container::IGNORE_ON_UNINITIALIZED_REFERENCE)),
+        new ServiceClosureArgument(new Reference('foo3', $container::IGNORE_ON_UNINITIALIZED_REFERENCE)),
+    ))
+    ->setProperty('iter', new IteratorArgument(array(
+        'foo1' => new Reference('foo1', $container::IGNORE_ON_UNINITIALIZED_REFERENCE),
+        'foo2' => new Reference('foo2', $container::IGNORE_ON_UNINITIALIZED_REFERENCE),
+        'foo3' => new Reference('foo3', $container::IGNORE_ON_UNINITIALIZED_REFERENCE),
+    )))
+    ->setPublic(true)
+;
+
+return $container;