Requires PHP 7.2.5+, Symfony 5

olvlvl · olvlvl · commit 658a35ea071e · 2020-03-13T08:21:21.000+01:00
diff --git a/.editorconfig b/.editorconfig
@@ -9,13 +9,7 @@ indent_style = space
 indent_size = 4
 
 [*.yml]
-indent_style = space
 indent_size = 2
 
-[*.md]
-indent_style = space
-indent_size = 4
-
 [Makefile]
 indent_style = tab
-indent_size = 4
diff --git a/.travis.yml b/.travis.yml
@@ -9,9 +9,9 @@ cache:
 language: php
 
 php:
-  - 7.1
   - 7.2
   - 7.3
+  - 7.4
 
 script:
-  - if [[ $TRAVIS_PHP_VERSION == "7.1" ]]; then make test-coveralls; else make test; fi
+  - if [[ $TRAVIS_PHP_VERSION == "7.2" ]]; then make test-coveralls; else make test; fi
diff --git a/Dockerfile b/Dockerfile
@@ -1,4 +1,4 @@
-FROM php:7.1-alpine3.8
+FROM php:7.2-alpine
 
 RUN apk add --no-cache make $PHPIZE_DEPS \
     && pecl install xdebug \
diff --git a/LICENSE b/LICENSE
@@ -1,7 +1,7 @@
 The olvlvl/symfony-dependency-injection-proxy package is free software.
 It is released under the terms of the following BSD License.
 
-Copyright (c) 2018 by Olivier Laviale
+Copyright (c) 2018-2020 by Olivier Laviale
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without modification,
diff --git a/README.md b/README.md
@@ -24,12 +24,12 @@ use Psr\Log\LoggerInterface;
 class ExceptionHandler
 {
     private $logger;
-    
+
     public function __construct(LoggerInterface $logger)
     {
         $this->logger = $logger;
     }
-    
+
     // …
 }
 ```
@@ -143,7 +143,7 @@ ArrayObject:
 
 ## Requirements
 
-The package requires PHP 7.1 or later.
+The package requires PHP 7.2.5 or later.
 
 
 
diff --git a/composer.json b/composer.json
@@ -11,9 +11,12 @@
         }
     ],
     "require": {
-        "php": ">=7.1",
+        "php": ">=7.2.5",
         "ext-json": "*",
-        "symfony/dependency-injection": "^4.2"
+        "symfony/dependency-injection": "^5.0"
+    },
+    "require-dev": {
+        "symfony/config": "^5.0"
     },
     "autoload": {
         "psr-4": {
diff --git a/lib/FactoryRenderer.php b/lib/FactoryRenderer.php
@@ -37,7 +37,7 @@ public function __invoke(string $interface, string $factoryCode): string
             '($this->service ?: $this->service = ($this->factory)())'
         );
 
-        return <<<PHP
+        return <<<PHPTPL
             new class(
                 function () {
                     return $factoryCode;
@@ -53,7 +53,7 @@ public function __construct(callable \$factory)
 
 $methods
             };
-PHP;
+PHPTPL;
     }
 
     /**
diff --git a/lib/MethodRenderer.php b/lib/MethodRenderer.php
@@ -25,12 +25,12 @@ public function __invoke(ReflectionMethod $method, string $getterCode): string
         $call = $this->renderCall($method);
         $mayReturn = ($method->hasReturnType() && $method->getReturnType()->getName() === 'void') ? '' : 'return ';
 
-        return <<<PHP
+        return <<<PHPTPL
                 $signature
                 {
                     {$mayReturn}{$getterCode}->$call;
                 }
-PHP;
+PHPTPL;
     }
 
     private function renderMethodSignature(ReflectionMethod $method): string
diff --git a/lib/ProxyDumper.php b/lib/ProxyDumper.php
@@ -67,13 +67,13 @@ public function getProxyFactoryCode(Definition $definition, $id, $factoryCode)
         $interface = $this->findInterface($definition);
         $proxy = ltrim($this->renderFactory($interface, $factoryCode));
 
-        return <<<PHP
+        return <<<PHPTPL
         if (\$lazyLoad) {
             return {$store}$proxy
         }
 
 
-PHP;
+PHPTPL;
     }
 
     /**
diff --git a/tests/FactoryRendererTest.php b/tests/FactoryRendererTest.php
@@ -39,7 +39,7 @@ public function testRender()
         });
 
         $stu = new FactoryRenderer($methodRenderer->reveal());
-        $expected = <<<PHP
+        $expected = <<<PHPTPL
             new class(
                 function () {
                     return $factoryCode;
@@ -56,7 +56,7 @@ public function __construct(callable \$factory)
                 codeFor:serialize
                 codeFor:unserialize
             };
-PHP;
+PHPTPL;
         $this->assertEquals($expected, $stu($interface, $factoryCode));
     }
 }
diff --git a/tests/MethodRendererTest.php b/tests/MethodRendererTest.php
@@ -43,123 +43,131 @@ public function provideRender(): array
             return new ReflectionMethod(SampleInterfaceForMethodRenderer72::class, $method);
         };
 
-        $cases = [
+        return [
 
             [
                 $reflectionFor('aStaticMethodWithoutParametersOrReturnType'),
                 $getterCode,
-                <<<PHP
+                <<<PHPTPL
                 public static function aStaticMethodWithoutParametersOrReturnType()
                 {
                     return {$getterCode}->aStaticMethodWithoutParametersOrReturnType();
                 }
-PHP
+PHPTPL
             ],
 
             [
                 $reflectionFor('aMethodWithoutParametersOrReturnType'),
                 $getterCode,
-                <<<PHP
+                <<<PHPTPL
                 public function aMethodWithoutParametersOrReturnType()
                 {
                     return {$getterCode}->aMethodWithoutParametersOrReturnType();
                 }
-PHP
+PHPTPL
             ],
 
             [
                 $reflectionFor('aMethodWithoutParametersButABuiltInReturnType'),
                 $getterCode,
-                <<<PHP
+                <<<PHPTPL
                 public function aMethodWithoutParametersButABuiltInReturnType(): array
                 {
                     return {$getterCode}->aMethodWithoutParametersButABuiltInReturnType();
                 }
-PHP
+PHPTPL
             ],
 
             [
                 $reflectionFor('aMethodWithoutParametersButABuiltInReturnTypeNullable'),
                 $getterCode,
-                <<<PHP
+                <<<PHPTPL
                 public function aMethodWithoutParametersButABuiltInReturnTypeNullable(): ?array
                 {
                     return {$getterCode}->aMethodWithoutParametersButABuiltInReturnTypeNullable();
                 }
-PHP
+PHPTPL
             ],
 
             [
                 $reflectionFor('aMethodWithoutParametersButANonBuiltInReturnType'),
                 $getterCode,
-                <<<PHP
+                <<<PHPTPL
                 public function aMethodWithoutParametersButANonBuiltInReturnType(): \ArrayAccess
                 {
                     return {$getterCode}->aMethodWithoutParametersButANonBuiltInReturnType();
                 }
-PHP
+PHPTPL
             ],
 
             [
                 $reflectionFor('aMethodWithoutParametersButANonBuiltInReturnTypeNullable'),
                 $getterCode,
-                <<<PHP
+                <<<PHPTPL
                 public function aMethodWithoutParametersButANonBuiltInReturnTypeNullable(): ?\ArrayAccess
                 {
                     return {$getterCode}->aMethodWithoutParametersButANonBuiltInReturnTypeNullable();
                 }
-PHP
+PHPTPL
             ],
 
             [
                 $reflectionFor('aMethodWithParameters1'),
                 $getterCode,
-                <<<PHP
+                <<<PHPTPL
                 public function aMethodWithParameters1(\$a, bool \$b, ?int \$c, \$d = null)
                 {
                     return {$getterCode}->aMethodWithParameters1(\$a, \$b, \$c, \$d);
                 }
-PHP
+PHPTPL
             ],
 
             [
                 $reflectionFor('aMethodWithParameters2'),
                 $getterCode,
-                <<<PHP
+                <<<PHPTPL
                 public function aMethodWithParameters2(\ArrayAccess \$a, ?\ArrayAccess \$b, ?\ArrayAccess \$c = null)
                 {
                     return {$getterCode}->aMethodWithParameters2(\$a, \$b, \$c);
                 }
-PHP
+PHPTPL
             ],
 
             [
                 $reflectionFor('aMethodWithParameters3'),
                 $getterCode,
-                <<<PHP
+                <<<PHPTPL
                 public function aMethodWithParameters3(\$a = 123, \$b = "abc", \$c = "aConstantValue")
                 {
                     return {$getterCode}->aMethodWithParameters3(\$a, \$b, \$c);
                 }
-PHP
+PHPTPL
             ],
 
-        ];
-
-        if (PHP_VERSION_ID >= 72000) {
-            $cases[] = [
+            [
 
                 $reflectionFor72('aMethodWithReturnTypeVoid'),
                 $getterCode,
-                <<<PHP
+                <<<PHPTPL
                 public function aMethodWithReturnTypeVoid(\$a): void
                 {
                     {$getterCode}->aMethodWithReturnTypeVoid(\$a);
                 }
-PHP
-            ];
-        }
+PHPTPL
+            ],
+
+            [
+
+                $reflectionFor72('aMethodWithReturnTypeObject'),
+                $getterCode,
+                <<<PHPTPL
+                public function aMethodWithReturnTypeObject(\$a): object
+                {
+                    return {$getterCode}->aMethodWithReturnTypeObject(\$a);
+                }
+PHPTPL
+            ],
 
-        return $cases;
+        ];
     }
 }
diff --git a/tests/ProxyDumperTest.php b/tests/ProxyDumperTest.php
@@ -111,13 +111,13 @@ public function testGetProxyFactoryCode(string $id, bool $private, bool $shared,
             $factoryRenderer->reveal()
         );
 
-        $expected = <<<PHP
+        $expected = <<<PHPTPL
         if (\$lazyLoad) {
             return {$expectedStore}$proxyFactoryCode
         }
 
 
-PHP;
+PHPTPL;
 
         $this->assertEquals($expected, $stu->getProxyFactoryCode($definition, $id, $factoryCode));
     }
diff --git a/tests/cases/SampleInterfaceForMethodRenderer72.php b/tests/cases/SampleInterfaceForMethodRenderer72.php
@@ -14,4 +14,6 @@
 interface SampleInterfaceForMethodRenderer72
 {
     public function aMethodWithReturnTypeVoid($a): void;
+
+    public function aMethodWithReturnTypeObject($a): object;
 }

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-FROM php:7.1-alpine3.8`
	`1`	`+FROM php:7.2-alpine`
`2`	`2`
`3`	`3`	`RUN apk add --no-cache make $PHPIZE_DEPS \`
`4`	`4`	`&& pecl install xdebug \`
Original file line number	Diff line number	Diff line change
`@@ -24,12 +24,12 @@ use Psr\Log\LoggerInterface;`
`24`	`24`	`class ExceptionHandler`
`25`	`25`	`{`
`26`	`26`	`private $logger;`
`27`		`-`
	`27`	`+`
`28`	`28`	`public function __construct(LoggerInterface $logger)`
`29`	`29`	`{`
`30`	`30`	`$this->logger = $logger;`
`31`	`31`	`}`
`32`		`-`
	`32`	`+`
`33`	`33`	`// …`
`34`	`34`	`}`
`35`	`35`	```
`@@ -143,7 +143,7 @@ ArrayObject:`
`143`	`143`
`144`	`144`	`## Requirements`
`145`	`145`
`146`		`-The package requires PHP 7.1 or later.`
	`146`	`+The package requires PHP 7.2.5 or later.`
`147`	`147`
`148`	`148`
`149`	`149`
Original file line number	Diff line number	Diff line change
`@@ -25,12 +25,12 @@ public function __invoke(ReflectionMethod $method, string $getterCode): string`
`25`	`25`	`$call = $this->renderCall($method);`
`26`	`26`	`$mayReturn = ($method->hasReturnType() && $method->getReturnType()->getName() === 'void') ? '' : 'return ';`
`27`	`27`
`28`		`- return <<<PHP`
	`28`	`+ return <<<PHPTPL`
`29`	`29`	`$signature`
`30`	`30`	`{`
`31`	`31`	`{$mayReturn}{$getterCode}->$call;`
`32`	`32`	`}`
`33`		`-PHP;`
	`33`	`+PHPTPL;`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`private function renderMethodSignature(ReflectionMethod $method): string`
Original file line number	Diff line number	Diff line change
`@@ -67,13 +67,13 @@ public function getProxyFactoryCode(Definition $definition, $id, $factoryCode)`
`67`	`67`	`$interface = $this->findInterface($definition);`
`68`	`68`	`$proxy = ltrim($this->renderFactory($interface, $factoryCode));`
`69`	`69`
`70`		`- return <<<PHP`
	`70`	`+ return <<<PHPTPL`
`71`	`71`	`if (\$lazyLoad) {`
`72`	`72`	`return {$store}$proxy`
`73`	`73`	`}`
`74`	`74`
`75`	`75`
`76`		`-PHP;`
	`76`	`+PHPTPL;`
`77`	`77`	`}`
`78`	`78`
`79`	`79`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -43,123 +43,131 @@ public function provideRender(): array`
`43`	`43`	`return new ReflectionMethod(SampleInterfaceForMethodRenderer72::class, $method);`
`44`	`44`	`};`
`45`	`45`
`46`		`- $cases = [`
	`46`	`+ return [`
`47`	`47`
`48`	`48`	`[`
`49`	`49`	`$reflectionFor('aStaticMethodWithoutParametersOrReturnType'),`
`50`	`50`	`$getterCode,`
`51`		`- <<<PHP`
	`51`	`+ <<<PHPTPL`
`52`	`52`	`public static function aStaticMethodWithoutParametersOrReturnType()`
`53`	`53`	`{`
`54`	`54`	`return {$getterCode}->aStaticMethodWithoutParametersOrReturnType();`
`55`	`55`	`}`
`56`		`-PHP`
	`56`	`+PHPTPL`
`57`	`57`	`],`
`58`	`58`
`59`	`59`	`[`
`60`	`60`	`$reflectionFor('aMethodWithoutParametersOrReturnType'),`
`61`	`61`	`$getterCode,`
`62`		`- <<<PHP`
	`62`	`+ <<<PHPTPL`
`63`	`63`	`public function aMethodWithoutParametersOrReturnType()`
`64`	`64`	`{`
`65`	`65`	`return {$getterCode}->aMethodWithoutParametersOrReturnType();`
`66`	`66`	`}`
`67`		`-PHP`
	`67`	`+PHPTPL`
`68`	`68`	`],`
`69`	`69`
`70`	`70`	`[`
`71`	`71`	`$reflectionFor('aMethodWithoutParametersButABuiltInReturnType'),`
`72`	`72`	`$getterCode,`
`73`		`- <<<PHP`
	`73`	`+ <<<PHPTPL`
`74`	`74`	`public function aMethodWithoutParametersButABuiltInReturnType(): array`
`75`	`75`	`{`
`76`	`76`	`return {$getterCode}->aMethodWithoutParametersButABuiltInReturnType();`
`77`	`77`	`}`
`78`		`-PHP`
	`78`	`+PHPTPL`
`79`	`79`	`],`
`80`	`80`
`81`	`81`	`[`
`82`	`82`	`$reflectionFor('aMethodWithoutParametersButABuiltInReturnTypeNullable'),`
`83`	`83`	`$getterCode,`
`84`		`- <<<PHP`
	`84`	`+ <<<PHPTPL`
`85`	`85`	`public function aMethodWithoutParametersButABuiltInReturnTypeNullable(): ?array`
`86`	`86`	`{`
`87`	`87`	`return {$getterCode}->aMethodWithoutParametersButABuiltInReturnTypeNullable();`
`88`	`88`	`}`
`89`		`-PHP`
	`89`	`+PHPTPL`
`90`	`90`	`],`
`91`	`91`
`92`	`92`	`[`
`93`	`93`	`$reflectionFor('aMethodWithoutParametersButANonBuiltInReturnType'),`
`94`	`94`	`$getterCode,`
`95`		`- <<<PHP`
	`95`	`+ <<<PHPTPL`
`96`	`96`	`public function aMethodWithoutParametersButANonBuiltInReturnType(): \ArrayAccess`
`97`	`97`	`{`
`98`	`98`	`return {$getterCode}->aMethodWithoutParametersButANonBuiltInReturnType();`
`99`	`99`	`}`
`100`		`-PHP`
	`100`	`+PHPTPL`
`101`	`101`	`],`
`102`	`102`
`103`	`103`	`[`
`104`	`104`	`$reflectionFor('aMethodWithoutParametersButANonBuiltInReturnTypeNullable'),`
`105`	`105`	`$getterCode,`
`106`		`- <<<PHP`
	`106`	`+ <<<PHPTPL`
`107`	`107`	`public function aMethodWithoutParametersButANonBuiltInReturnTypeNullable(): ?\ArrayAccess`
`108`	`108`	`{`
`109`	`109`	`return {$getterCode}->aMethodWithoutParametersButANonBuiltInReturnTypeNullable();`
`110`	`110`	`}`
`111`		`-PHP`
	`111`	`+PHPTPL`
`112`	`112`	`],`
`113`	`113`
`114`	`114`	`[`
`115`	`115`	`$reflectionFor('aMethodWithParameters1'),`
`116`	`116`	`$getterCode,`
`117`		`- <<<PHP`
	`117`	`+ <<<PHPTPL`
`118`	`118`	`public function aMethodWithParameters1(\$a, bool \$b, ?int \$c, \$d = null)`
`119`	`119`	`{`
`120`	`120`	`return {$getterCode}->aMethodWithParameters1(\$a, \$b, \$c, \$d);`
`121`	`121`	`}`
`122`		`-PHP`
	`122`	`+PHPTPL`
`123`	`123`	`],`
`124`	`124`
`125`	`125`	`[`
`126`	`126`	`$reflectionFor('aMethodWithParameters2'),`
`127`	`127`	`$getterCode,`
`128`		`- <<<PHP`
	`128`	`+ <<<PHPTPL`
`129`	`129`	`public function aMethodWithParameters2(\ArrayAccess \$a, ?\ArrayAccess \$b, ?\ArrayAccess \$c = null)`
`130`	`130`	`{`
`131`	`131`	`return {$getterCode}->aMethodWithParameters2(\$a, \$b, \$c);`
`132`	`132`	`}`
`133`		`-PHP`
	`133`	`+PHPTPL`
`134`	`134`	`],`
`135`	`135`
`136`	`136`	`[`
`137`	`137`	`$reflectionFor('aMethodWithParameters3'),`
`138`	`138`	`$getterCode,`
`139`		`- <<<PHP`
	`139`	`+ <<<PHPTPL`
`140`	`140`	`public function aMethodWithParameters3(\$a = 123, \$b = "abc", \$c = "aConstantValue")`
`141`	`141`	`{`
`142`	`142`	`return {$getterCode}->aMethodWithParameters3(\$a, \$b, \$c);`
`143`	`143`	`}`
`144`		`-PHP`
	`144`	`+PHPTPL`
`145`	`145`	`],`
`146`	`146`
`147`		`- ];`
`148`		`-`
`149`		`- if (PHP_VERSION_ID >= 72000) {`
`150`		`- $cases[] = [`
	`147`	`+ [`
`151`	`148`
`152`	`149`	`$reflectionFor72('aMethodWithReturnTypeVoid'),`
`153`	`150`	`$getterCode,`
`154`		`- <<<PHP`
	`151`	`+ <<<PHPTPL`
`155`	`152`	`public function aMethodWithReturnTypeVoid(\$a): void`
`156`	`153`	`{`
`157`	`154`	`{$getterCode}->aMethodWithReturnTypeVoid(\$a);`
`158`	`155`	`}`
`159`		`-PHP`
`160`		`- ];`
`161`		`- }`
	`156`	`+PHPTPL`
	`157`	`+ ],`
	`158`	`+`
	`159`	`+ [`
	`160`	`+`
	`161`	`+ $reflectionFor72('aMethodWithReturnTypeObject'),`
	`162`	`+ $getterCode,`
	`163`	`+ <<<PHPTPL`
	`164`	`+ public function aMethodWithReturnTypeObject(\$a): object`
	`165`	`+ {`
	`166`	`+ return {$getterCode}->aMethodWithReturnTypeObject(\$a);`
	`167`	`+ }`
	`168`	`+PHPTPL`
	`169`	`+ ],`
`162`	`170`
`163`		`- return $cases;`
	`171`	`+ ];`
`164`	`172`	`}`
`165`	`173`	`}`
Original file line number	Diff line number	Diff line change
`@@ -111,13 +111,13 @@ public function testGetProxyFactoryCode(string $id, bool $private, bool $shared,`
`111`	`111`	`$factoryRenderer->reveal()`
`112`	`112`	`);`
`113`	`113`
`114`		`- $expected = <<<PHP`
	`114`	`+ $expected = <<<PHPTPL`
`115`	`115`	`if (\$lazyLoad) {`
`116`	`116`	`return {$expectedStore}$proxyFactoryCode`
`117`	`117`	`}`
`118`	`118`
`119`	`119`
`120`		`-PHP;`
	`120`	`+PHPTPL;`
`121`	`121`
`122`	`122`	`$this->assertEquals($expected, $stu->getProxyFactoryCode($definition, $id, $factoryCode));`
`123`	`123`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,4 +14,6 @@`
`14`	`14`	`interface SampleInterfaceForMethodRenderer72`
`15`	`15`	`{`
`16`	`16`	`public function aMethodWithReturnTypeVoid($a): void;`
	`17`	`+`
	`18`	`+ public function aMethodWithReturnTypeObject($a): object;`
`17`	`19`	`}`