Drop old sf and add type hints (#114)

* Drop old versions of Symfony

* Replace exceptions with type hints

* Add obvious type hint

* Add type hints everywhere we can

Author: greg0ire

.travis.yml

@@ -20,8 +20,6 @@ matrix:
           env: COVERAGE=true PHPUNIT_FLAGS="-v --coverage-text"
 
           # Force some major versions of Symfony
-        - php: 7.3
-          env: DEPENDENCIES="dunglas/symfony-lock:^2"
         - php: 7.3
           env: DEPENDENCIES="dunglas/symfony-lock:^3"
         - php: 7.3

Loader/ExtensionConfigurationBuilder.php

@@ -23,7 +23,7 @@ public function setExtension(ExtensionInterface $extension)
         return $this;
     }
 
-    public function getExtension()
+    public function getExtension(): ExtensionInterface
     {
         if (!($this->extension instanceof ExtensionInterface)) {
             throw new \LogicException('You need to call setExtension() first');
@@ -46,7 +46,7 @@ public function setSources(array $sources)
         return $this;
     }
 
-    public function getSources()
+    public function getSources(): array
     {
         if (count($this->sources) === 0) {
             throw new \LogicException('You need to call setSources() or addSource() first');
@@ -55,7 +55,7 @@ public function getSources()
         return $this->sources;
     }
 
-    public function getConfiguration()
+    public function getConfiguration(): array
     {
         $container = new ContainerBuilder();
 
@@ -66,15 +66,15 @@ public function getConfiguration()
         return $this->getExtensionConfiguration($container);
     }
 
-    private function loadSources(ContainerBuilder $container, array $sources)
+    private function loadSources(ContainerBuilder $container, array $sources): void
     {
         foreach ($sources as $source) {
             $loader = $this->loaderFactory->createLoaderForSource($container, $source);
             $loader->load($source);
         }
     }
 
-    private function getExtensionConfiguration(ContainerBuilder $container)
+    private function getExtensionConfiguration(ContainerBuilder $container): array
     {
         $extensionAlias = $this->getExtension()->getAlias();
 

Loader/LoaderFactory.php

@@ -4,6 +4,7 @@
 
 use Matthias\SymfonyDependencyInjectionTest\Loader\Exception\UnknownConfigurationSourceException;
 use Symfony\Component\Config\FileLocator;
+use Symfony\Component\Config\Loader\LoaderInterface;
 use Symfony\Component\DependencyInjection\ContainerBuilder;
 use Symfony\Component\DependencyInjection\Loader\ClosureLoader;
 use Symfony\Component\DependencyInjection\Loader\IniFileLoader;
@@ -13,7 +14,7 @@
 
 class LoaderFactory implements LoaderFactoryInterface
 {
-    public function createLoaderForSource(ContainerBuilder $container, $source)
+    public function createLoaderForSource(ContainerBuilder $container, $source): LoaderInterface
     {
         if ($source instanceof \Closure) {
             return new ClosureLoader($container);
@@ -41,22 +42,22 @@ public function createLoaderForSource(ContainerBuilder $container, $source)
         ));
     }
 
-    public function createYamlFileLoader($container)
+    public function createYamlFileLoader($container): YamlFileLoader
     {
         return new YamlFileLoader($container, new FileLocator());
     }
 
-    public function createXmlFileLoader(ContainerBuilder $container)
+    public function createXmlFileLoader(ContainerBuilder $container): XmlFileLoader
     {
         return new XmlFileLoader($container, new FileLocator());
     }
 
-    public function createPhpFileLoader(ContainerBuilder $container)
+    public function createPhpFileLoader(ContainerBuilder $container): PhpFileLoader
     {
         return new PhpFileLoader($container, new FileLocator());
     }
 
-    public function createIniFileLoader(ContainerBuilder $container)
+    public function createIniFileLoader(ContainerBuilder $container): IniFileLoader
     {
         return new IniFileLoader($container, new FileLocator());
     }

Loader/LoaderFactoryInterface.php

@@ -7,11 +7,5 @@
 
 interface LoaderFactoryInterface
 {
-    /**
-     * @param ContainerBuilder $container
-     * @param $source
-     *
-     * @return LoaderInterface
-     */
-    public function createLoaderForSource(ContainerBuilder $container, $source);
+    public function createLoaderForSource(ContainerBuilder $container, $source): LoaderInterface;
 }

PhpUnit/AbstractCompilerPassTestCase.php

@@ -12,14 +12,14 @@ abstract class AbstractCompilerPassTestCase extends AbstractContainerBuilderTest
      *
      *   $container->addCompilerPass(new MyCompilerPass());
      */
-    abstract protected function registerCompilerPass(ContainerBuilder $container);
+    abstract protected function registerCompilerPass(ContainerBuilder $container): void;
 
     /**
      * This test will run the compile method.
      *
      * @test
      */
-    public function compilation_should_not_fail_with_empty_container()
+    public function compilation_should_not_fail_with_empty_container(): void
     {
         try {
             $this->compile();

PhpUnit/AbstractContainerBuilderTestCase.php

@@ -29,13 +29,8 @@ protected function tearDown(): void
 
     /**
      * Shortcut for quickly defining services. The returned Definition object can be further modified if necessary.
-     *
-     * @param $serviceId
-     * @param $class
-     *
-     * @return Definition
      */
-    protected function registerService($serviceId, $class)
+    protected function registerService(string $serviceId, string $class): Definition
     {
         $definition = new Definition($class);
 
@@ -46,41 +41,34 @@ protected function registerService($serviceId, $class)
 
     /**
      * Set a service definition you manually created.
-     *
-     * @param $serviceId
-     * @param Definition $definition
      */
-    protected function setDefinition($serviceId, Definition $definition)
+    protected function setDefinition(string $serviceId, Definition $definition): void
     {
         $this->container->setDefinition($serviceId, $definition);
     }
 
     /**
      * Set a parameter.
      *
-     * @param $parameterId
-     * @param $parameterValue
+     * @param mixed $parameterValue
      */
-    protected function setParameter($parameterId, $parameterValue)
+    protected function setParameter(string $parameterId, $parameterValue): void
     {
         $this->container->setParameter($parameterId, $parameterValue);
     }
 
     /**
      * Call this method to compile the ContainerBuilder, to test if any problems would occur at runtime.
      */
-    protected function compile()
+    protected function compile(): void
     {
         $this->container->compile();
     }
 
     /**
      * Assert that the ContainerBuilder for this test has a service definition with the given id and class.
-     *
-     * @param $serviceId
-     * @param $expectedClass
      */
-    protected function assertContainerBuilderHasService($serviceId, $expectedClass = null)
+    protected function assertContainerBuilderHasService(string $serviceId, ?string $expectedClass = null): void
     {
         $checkExpectedClass = (func_num_args() > 1);
 
@@ -92,10 +80,8 @@ protected function assertContainerBuilderHasService($serviceId, $expectedClass =
 
     /**
      * Assert that the ContainerBuilder for this test does not have a service definition with the given id.
-     *
-     * @param $serviceId
      */
-    protected function assertContainerBuilderNotHasService($serviceId)
+    protected function assertContainerBuilderNotHasService(string $serviceId): void
     {
         self::assertThat(
             $this->container,
@@ -105,10 +91,8 @@ protected function assertContainerBuilderNotHasService($serviceId)
 
     /**
      * Assert that the ContainerBuilder for this test has a synthetic service with the given id.
-     *
-     * @param $serviceId
      */
-    protected function assertContainerBuilderHasSyntheticService($serviceId)
+    protected function assertContainerBuilderHasSyntheticService(string $serviceId): void
     {
         self::assertThat(
             $this->container,
@@ -118,11 +102,8 @@ protected function assertContainerBuilderHasSyntheticService($serviceId)
 
     /**
      * Assert that the ContainerBuilder for this test has an alias and that it is an alias for the given service id.
-     *
-     * @param $aliasId
-     * @param $expectedServiceId
      */
-    protected function assertContainerBuilderHasAlias($aliasId, $expectedServiceId = null)
+    protected function assertContainerBuilderHasAlias(string $aliasId, ?string $expectedServiceId = null): void
     {
         self::assertThat(
             $this->container,
@@ -133,10 +114,9 @@ protected function assertContainerBuilderHasAlias($aliasId, $expectedServiceId =
     /**
      * Assert that the ContainerBuilder for this test has a parameter and that its value is the given value.
      *
-     * @param $parameterName
-     * @param $expectedParameterValue
+     * @param mixed $expectedParameterValue
      */
-    protected function assertContainerBuilderHasParameter($parameterName, $expectedParameterValue = null)
+    protected function assertContainerBuilderHasParameter(string $parameterName, $expectedParameterValue = null): void
     {
         $checkParameterValue = (func_num_args() > 1);
 
@@ -150,15 +130,13 @@ protected function assertContainerBuilderHasParameter($parameterName, $expectedP
      * Assert that the ContainerBuilder for this test has a service definition with the given id, which has an argument
      * at the given index, and its value is the given value.
      *
-     * @param $serviceId
-     * @param $argumentIndex
-     * @param $expectedValue
+     * @param mixed $expectedValue
      */
     protected function assertContainerBuilderHasServiceDefinitionWithArgument(
-        $serviceId,
+        string $serviceId,
         $argumentIndex,
         $expectedValue = null
-    ) {
+    ): void {
         $definition = $this->container->findDefinition($serviceId);
         $checkValue = (func_num_args() > 2);
 
@@ -172,15 +150,14 @@ protected function assertContainerBuilderHasServiceDefinitionWithArgument(
      * Assert that the ContainerBuilder for this test has a service definition with the given id, which has an argument
      * at the given index, and its value is a ServiceLocator with a reference-map equal to the given value.
      *
-     * @param string     $serviceId
      * @param int|string $argumentIndex
      * @param array      $expectedServiceMap an array of service-id references and their key in the map
      */
     protected function assertContainerBuilderHasServiceDefinitionWithServiceLocatorArgument(
-        $serviceId,
+        string $serviceId,
         $argumentIndex,
         array $expectedValue
-    ) {
+    ): void {
         self::assertThat(
             $this->container,
             new DefinitionArgumentEqualsServiceLocatorConstraint($serviceId, $argumentIndex, $expectedValue)
@@ -191,17 +168,14 @@ protected function assertContainerBuilderHasServiceDefinitionWithServiceLocatorA
      * Assert that the ContainerBuilder for this test has a service definition with the given id, which has a method
      * call to the given method with the given arguments.
      *
-     * @param string   $serviceId
-     * @param string   $method
-     * @param array    $arguments
      * @param int|null $index
      */
     protected function assertContainerBuilderHasServiceDefinitionWithMethodCall(
-        $serviceId,
-        $method,
+        string $serviceId,
+        string $method,
         array $arguments = [],
         $index = null
-    ) {
+    ): void {
         $definition = $this->container->findDefinition($serviceId);
 
         self::assertThat($definition, new DefinitionHasMethodCallConstraint($method, $arguments, $index));
@@ -210,16 +184,12 @@ protected function assertContainerBuilderHasServiceDefinitionWithMethodCall(
     /**
      * Assert that the ContainerBuilder for this test has a service definition with the given id, which has a tag
      * with the given attributes.
-     *
-     * @param string $serviceId
-     * @param string $tag
-     * @param array  $attributes
      */
     protected function assertContainerBuilderHasServiceDefinitionWithTag(
-        $serviceId,
-        $tag,
+        string $serviceId,
+        string $tag,
         array $attributes = []
-    ) {
+    ): void {
         $definition = $this->container->findDefinition($serviceId);
 
         self::assertThat($definition, new DefinitionHasTagConstraint($tag, $attributes));
@@ -228,11 +198,8 @@ protected function assertContainerBuilderHasServiceDefinitionWithTag(
     /**
      * Assert that the ContainerBuilder for this test has a service definition with the given id which is a decorated
      * service and it has the given parent service.
-     *
-     * @param $serviceId
-     * @param $parentServiceId
      */
-    protected function assertContainerBuilderHasServiceDefinitionWithParent($serviceId, $parentServiceId)
+    protected function assertContainerBuilderHasServiceDefinitionWithParent(string $serviceId, string $parentServiceId): void
     {
         $definition = $this->container->findDefinition($serviceId);
 
@@ -242,10 +209,9 @@ protected function assertContainerBuilderHasServiceDefinitionWithParent($service
     /**
      * Assert that the ContainerBuilder for this test has a ServiceLocator service definition with the given id.
      *
-     * @param string $serviceId
-     * @param array  $expectedServiceMap an array of service-id references and their key in the map
+     * @param array $expectedServiceMap an array of service-id references and their key in the map
      */
-    protected function assertContainerBuilderHasServiceLocator(string $serviceId, array $expectedServiceMap = [])
+    protected function assertContainerBuilderHasServiceLocator(string $serviceId, array $expectedServiceMap = []): void
     {
         $definition = $this->container->findDefinition($serviceId);
 

PhpUnit/AbstractExtensionConfigurationTestCase.php

@@ -13,19 +13,15 @@ abstract class AbstractExtensionConfigurationTestCase extends TestCase
 {
     /**
      * Return an instance of the container extension that you are testing.
-     *
-     * @return ExtensionInterface
      */
-    abstract protected function getContainerExtension();
+    abstract protected function getContainerExtension(): ExtensionInterface;
 
     /**
      * Return an instance of the configuration class that you are testing.
-     *
-     * @return ConfigurationInterface
      */
-    abstract protected function getConfiguration();
+    abstract protected function getConfiguration(): ConfigurationInterface;
 
-    protected function assertProcessedConfigurationEquals($expectedConfiguration, array $sources)
+    protected function assertProcessedConfigurationEquals(array $expectedConfiguration, array $sources): void
     {
         $extensionConfigurationBuilder = new ExtensionConfigurationBuilder(new LoaderFactory());
         $extensionConfiguration = $extensionConfigurationBuilder