├── LICENSE
├── README.md
├── composer.json
└── src
    └── ProxyManager
        ├── Autoloader
            ├── Autoloader.php
            └── AutoloaderInterface.php
        ├── Configuration.php
        ├── Exception
            ├── DisabledMethodException.php
            ├── ExceptionInterface.php
            ├── FileNotWritableException.php
            ├── InvalidProxiedClassException.php
            ├── InvalidProxyDirectoryException.php
            └── UnsupportedProxiedClassException.php
        ├── Factory
            ├── AbstractBaseFactory.php
            ├── AccessInterceptorScopeLocalizerFactory.php
            ├── AccessInterceptorValueHolderFactory.php
            ├── LazyLoadingGhostFactory.php
            ├── LazyLoadingValueHolderFactory.php
            ├── NullObjectFactory.php
            ├── RemoteObject
            │   ├── Adapter
            │   │   ├── BaseAdapter.php
            │   │   ├── JsonRpc.php
            │   │   ├── Soap.php
            │   │   └── XmlRpc.php
            │   └── AdapterInterface.php
            └── RemoteObjectFactory.php
        ├── FileLocator
            ├── FileLocator.php
            └── FileLocatorInterface.php
        ├── Generator
            ├── ClassGenerator.php
            ├── MagicMethodGenerator.php
            ├── MethodGenerator.php
            ├── Util
            │   ├── ClassGeneratorUtils.php
            │   ├── IdentifierSuffixer.php
            │   ├── ProxiedMethodReturnExpression.php
            │   └── UniqueIdentifierGenerator.php
            └── ValueGenerator.php
        ├── GeneratorStrategy
            ├── BaseGeneratorStrategy.php
            ├── EvaluatingGeneratorStrategy.php
            ├── FileWriterGeneratorStrategy.php
            └── GeneratorStrategyInterface.php
        ├── Inflector
            ├── ClassNameInflector.php
            ├── ClassNameInflectorInterface.php
            └── Util
            │   ├── ParameterEncoder.php
            │   └── ParameterHasher.php
        ├── Proxy
            ├── AccessInterceptorInterface.php
            ├── AccessInterceptorValueHolderInterface.php
            ├── Exception
            │   └── RemoteObjectException.php
            ├── FallbackValueHolderInterface.php
            ├── GhostObjectInterface.php
            ├── LazyLoadingInterface.php
            ├── NullObjectInterface.php
            ├── ProxyInterface.php
            ├── RemoteObjectInterface.php
            ├── SmartReferenceInterface.php
            ├── ValueHolderInterface.php
            └── VirtualProxyInterface.php
        ├── ProxyGenerator
            ├── AccessInterceptor
            │   ├── MethodGenerator
            │   │   ├── MagicWakeup.php
            │   │   ├── SetMethodPrefixInterceptor.php
            │   │   └── SetMethodSuffixInterceptor.php
            │   └── PropertyGenerator
            │   │   ├── MethodPrefixInterceptors.php
            │   │   └── MethodSuffixInterceptors.php
            ├── AccessInterceptorScopeLocalizer
            │   └── MethodGenerator
            │   │   ├── BindProxyProperties.php
            │   │   ├── InterceptedMethod.php
            │   │   ├── MagicClone.php
            │   │   ├── MagicGet.php
            │   │   ├── MagicIsset.php
            │   │   ├── MagicSet.php
            │   │   ├── MagicSleep.php
            │   │   ├── MagicUnset.php
            │   │   ├── StaticProxyConstructor.php
            │   │   └── Util
            │   │       └── InterceptorGenerator.php
            ├── AccessInterceptorScopeLocalizerGenerator.php
            ├── AccessInterceptorValueHolder
            │   └── MethodGenerator
            │   │   ├── InterceptedMethod.php
            │   │   ├── MagicClone.php
            │   │   ├── MagicGet.php
            │   │   ├── MagicIsset.php
            │   │   ├── MagicSet.php
            │   │   ├── MagicUnset.php
            │   │   ├── StaticProxyConstructor.php
            │   │   └── Util
            │   │       └── InterceptorGenerator.php
            ├── AccessInterceptorValueHolderGenerator.php
            ├── Assertion
            │   └── CanProxyAssertion.php
            ├── LazyLoading
            │   └── MethodGenerator
            │   │   └── StaticProxyConstructor.php
            ├── LazyLoadingGhost
            │   ├── MethodGenerator
            │   │   ├── CallInitializer.php
            │   │   ├── GetProxyInitializer.php
            │   │   ├── InitializeProxy.php
            │   │   ├── IsProxyInitialized.php
            │   │   ├── MagicClone.php
            │   │   ├── MagicGet.php
            │   │   ├── MagicIsset.php
            │   │   ├── MagicSet.php
            │   │   ├── MagicSleep.php
            │   │   ├── MagicUnset.php
            │   │   ├── SetProxyInitializer.php
            │   │   └── SkipDestructor.php
            │   └── PropertyGenerator
            │   │   ├── InitializationTracker.php
            │   │   ├── InitializerProperty.php
            │   │   ├── PrivatePropertiesMap.php
            │   │   └── ProtectedPropertiesMap.php
            ├── LazyLoadingGhostGenerator.php
            ├── LazyLoadingValueHolder
            │   ├── MethodGenerator
            │   │   ├── GetProxyInitializer.php
            │   │   ├── InitializeProxy.php
            │   │   ├── IsProxyInitialized.php
            │   │   ├── LazyLoadingMethodInterceptor.php
            │   │   ├── MagicClone.php
            │   │   ├── MagicGet.php
            │   │   ├── MagicIsset.php
            │   │   ├── MagicSet.php
            │   │   ├── MagicSleep.php
            │   │   ├── MagicUnset.php
            │   │   ├── SetProxyInitializer.php
            │   │   └── SkipDestructor.php
            │   └── PropertyGenerator
            │   │   ├── InitializerProperty.php
            │   │   └── ValueHolderProperty.php
            ├── LazyLoadingValueHolderGenerator.php
            ├── NullObject
            │   └── MethodGenerator
            │   │   ├── NullObjectMethodInterceptor.php
            │   │   └── StaticProxyConstructor.php
            ├── NullObjectGenerator.php
            ├── PropertyGenerator
            │   └── PublicPropertiesMap.php
            ├── ProxyGeneratorInterface.php
            ├── RemoteObject
            │   ├── MethodGenerator
            │   │   ├── MagicGet.php
            │   │   ├── MagicIsset.php
            │   │   ├── MagicSet.php
            │   │   ├── MagicUnset.php
            │   │   ├── RemoteObjectMethod.php
            │   │   └── StaticProxyConstructor.php
            │   └── PropertyGenerator
            │   │   └── AdapterProperty.php
            ├── RemoteObjectGenerator.php
            ├── Util
            │   ├── GetMethodIfExists.php
            │   ├── Properties.php
            │   ├── ProxiedMethodsFilter.php
            │   ├── PublicScopeSimulator.php
            │   └── UnsetPropertiesGenerator.php
            └── ValueHolder
            │   └── MethodGenerator
            │       ├── Constructor.php
            │       ├── GetWrappedValueHolderValue.php
            │       └── MagicSleep.php
        ├── Signature
            ├── ClassSignatureGenerator.php
            ├── ClassSignatureGeneratorInterface.php
            ├── Exception
            │   ├── ExceptionInterface.php
            │   ├── InvalidSignatureException.php
            │   └── MissingSignatureException.php
            ├── SignatureChecker.php
            ├── SignatureCheckerInterface.php
            ├── SignatureGenerator.php
            └── SignatureGeneratorInterface.php
        ├── Stub
            └── EmptyClassStub.php
        └── Version.php


/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2013 Marco Pivetta
 2 | 
 3 | Permission is hereby granted, free of charge, to any person obtaining a copy of
 4 | this software and associated documentation files (the "Software"), to deal in
 5 | the Software without restriction, including without limitation the rights to
 6 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
 7 | of the Software, and to permit persons to whom the Software is furnished to do
 8 | so, subject to the following conditions:
 9 | 
10 | The above copyright notice and this permission notice shall be included in all
11 | copies or substantial portions of the Software.
12 | 
13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
19 | SOFTWARE.
20 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # FriendsOfPHP / Proxy Manager LTS
 2 | 
 3 | This package is a fork of the excellent [`ocramius/proxy-manager`](https://github.com/Ocramius/ProxyManager/) library
 4 | that adds long term support for a wider range of PHP versions.
 5 | 
 6 | Unless they're caused by this very fork, please report issues and submit new features to the origin library.
 7 | 
 8 | This fork:
 9 | - maintains compatibility with PHP `>=7.1`;
10 |   supporting new versions of PHP is considered as a bugfix;
11 | - won't bump the minimum supported version of PHP in a minor release;
12 | - does not depend on Composer 2, thus can be used with Composer 1 if you need more time to migrate;
13 | - uses a versioning policy that is friendly to progressive migrations
14 |   while providing the latest improvements from the origin lib.
15 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name":              "friendsofphp/proxy-manager-lts",
 3 |     "description":       "Adding support for a wider range of PHP versions to ocramius/proxy-manager",
 4 |     "type":              "library",
 5 |     "license":           "MIT",
 6 |     "homepage":          "https://github.com/FriendsOfPHP/proxy-manager-lts",
 7 |     "keywords":          [
 8 |         "proxy",
 9 |         "proxy pattern",
10 |         "service proxies",
11 |         "lazy loading",
12 |         "aop"
13 |     ],
14 |     "authors": [
15 |         {
16 |             "name":     "Marco Pivetta",
17 |             "email":    "ocramius@gmail.com",
18 |             "homepage": "https://ocramius.github.io/"
19 |         },
20 |         {
21 |             "name":     "Nicolas Grekas",
22 |             "email":    "p@tchwork.com"
23 |         }
24 |     ],
25 |     "replace": {
26 |         "ocramius/proxy-manager": "^2.1"
27 |     },
28 |     "require": {
29 |         "php":                       ">=7.1",
30 |         "laminas/laminas-code":      "~3.4.1|^4.0",
31 |         "symfony/filesystem":        "^4.4.17|^5.0|^6.0|^7.0"
32 |     },
33 |     "conflict": {
34 |         "zendframework/zend-stdlib": "<3.2.1",
35 |         "laminas/laminas-stdlib":    "<3.2.1"
36 |     },
37 |     "require-dev": {
38 |         "ext-phar":                     "*",
39 |         "symfony/phpunit-bridge":       "^5.4|^6.0|^7.0"
40 |     },
41 |     "autoload": {
42 |         "psr-4": {
43 |             "ProxyManager\\": "src/ProxyManager"
44 |         }
45 |     },
46 |     "autoload-dev": {
47 |         "psr-4": {
48 |             "ProxyManagerTest\\": "tests/ProxyManagerTest",
49 |             "ProxyManagerTestAsset\\": "tests/ProxyManagerTestAsset",
50 |             "Laminas\\Server\\": "tests/Stubbed/Laminas/Server"
51 |         }
52 |     },
53 |     "minimum-stability": "dev",
54 |     "extra": {
55 |         "thanks": {
56 |             "name": "ocramius/proxy-manager",
57 |             "url": "https://github.com/Ocramius/ProxyManager"
58 |         }
59 |     }
60 | }
61 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Autoloader/Autoloader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Autoloader;
 6 | 
 7 | use ProxyManager\FileLocator\FileLocatorInterface;
 8 | use ProxyManager\Inflector\ClassNameInflectorInterface;
 9 | 
10 | use function class_exists;
11 | use function file_exists;
12 | 
13 | class Autoloader implements AutoloaderInterface
14 | {
15 |     protected $fileLocator;
16 |     protected $classNameInflector;
17 | 
18 |     public function __construct(FileLocatorInterface $fileLocator, ClassNameInflectorInterface $classNameInflector)
19 |     {
20 |         $this->fileLocator        = $fileLocator;
21 |         $this->classNameInflector = $classNameInflector;
22 |     }
23 | 
24 |     public function __invoke(string $className): bool
25 |     {
26 |         if (class_exists($className, false) || ! $this->classNameInflector->isProxyClassName($className)) {
27 |             return false;
28 |         }
29 | 
30 |         $file = $this->fileLocator->getProxyFileName($className);
31 | 
32 |         if (! file_exists($file)) {
33 |             return false;
34 |         }
35 | 
36 |         /* @noinspection PhpIncludeInspection */
37 |         /* @noinspection UsingInclusionOnceReturnValueInspection */
38 |         return (bool) require_once $file;
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Autoloader/AutoloaderInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Autoloader;
 6 | 
 7 | /**
 8 |  * Basic autoloader utilities required to work with proxy files
 9 |  */
10 | interface AutoloaderInterface
11 | {
12 |     /**
13 |      * Callback to allow the object to be handled as autoloader - tries to autoload the given class name
14 |      *
15 |      * @psalm-param class-string $className
16 |      */
17 |     public function __invoke(string $className): bool;
18 | }
19 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Configuration.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace ProxyManager;
  6 | 
  7 | use ProxyManager\Autoloader\Autoloader;
  8 | use ProxyManager\Autoloader\AutoloaderInterface;
  9 | use ProxyManager\FileLocator\FileLocator;
 10 | use ProxyManager\GeneratorStrategy\EvaluatingGeneratorStrategy;
 11 | use ProxyManager\GeneratorStrategy\GeneratorStrategyInterface;
 12 | use ProxyManager\Inflector\ClassNameInflector;
 13 | use ProxyManager\Inflector\ClassNameInflectorInterface;
 14 | use ProxyManager\Signature\ClassSignatureGenerator;
 15 | use ProxyManager\Signature\ClassSignatureGeneratorInterface;
 16 | use ProxyManager\Signature\SignatureChecker;
 17 | use ProxyManager\Signature\SignatureCheckerInterface;
 18 | use ProxyManager\Signature\SignatureGenerator;
 19 | use ProxyManager\Signature\SignatureGeneratorInterface;
 20 | 
 21 | use function sys_get_temp_dir;
 22 | 
 23 | /**
 24 |  * Base configuration class for the proxy manager - serves as micro disposable DIC/facade
 25 |  */
 26 | class Configuration
 27 | {
 28 |     public const DEFAULT_PROXY_NAMESPACE = 'ProxyManagerGeneratedProxy';
 29 | 
 30 |     protected $proxiesTargetDir;
 31 |     protected $proxiesNamespace = self::DEFAULT_PROXY_NAMESPACE;
 32 |     protected $generatorStrategy;
 33 |     protected $proxyAutoloader;
 34 |     protected $classNameInflector;
 35 |     protected $signatureGenerator;
 36 |     protected $signatureChecker;
 37 |     protected $classSignatureGenerator;
 38 | 
 39 |     public function setProxyAutoloader(AutoloaderInterface $proxyAutoloader): void
 40 |     {
 41 |         $this->proxyAutoloader = $proxyAutoloader;
 42 |     }
 43 | 
 44 |     public function getProxyAutoloader(): AutoloaderInterface
 45 |     {
 46 |         return $this->proxyAutoloader
 47 |             ?? $this->proxyAutoloader = new Autoloader(
 48 |                 new FileLocator($this->getProxiesTargetDir()),
 49 |                 $this->getClassNameInflector()
 50 |             );
 51 |     }
 52 | 
 53 |     public function setProxiesNamespace(string $proxiesNamespace): void
 54 |     {
 55 |         $this->proxiesNamespace = $proxiesNamespace;
 56 |     }
 57 | 
 58 |     public function getProxiesNamespace(): string
 59 |     {
 60 |         return $this->proxiesNamespace;
 61 |     }
 62 | 
 63 |     public function setProxiesTargetDir(string $proxiesTargetDir): void
 64 |     {
 65 |         $this->proxiesTargetDir = $proxiesTargetDir;
 66 |     }
 67 | 
 68 |     public function getProxiesTargetDir(): string
 69 |     {
 70 |         return $this->proxiesTargetDir
 71 |             ?? $this->proxiesTargetDir = sys_get_temp_dir();
 72 |     }
 73 | 
 74 |     public function setGeneratorStrategy(GeneratorStrategyInterface $generatorStrategy): void
 75 |     {
 76 |         $this->generatorStrategy = $generatorStrategy;
 77 |     }
 78 | 
 79 |     public function getGeneratorStrategy(): GeneratorStrategyInterface
 80 |     {
 81 |         return $this->generatorStrategy
 82 |             ?? $this->generatorStrategy = new EvaluatingGeneratorStrategy();
 83 |     }
 84 | 
 85 |     public function setClassNameInflector(ClassNameInflectorInterface $classNameInflector): void
 86 |     {
 87 |         $this->classNameInflector = $classNameInflector;
 88 |     }
 89 | 
 90 |     public function getClassNameInflector(): ClassNameInflectorInterface
 91 |     {
 92 |         return $this->classNameInflector
 93 |             ?? $this->classNameInflector = new ClassNameInflector($this->getProxiesNamespace());
 94 |     }
 95 | 
 96 |     public function setSignatureGenerator(SignatureGeneratorInterface $signatureGenerator): void
 97 |     {
 98 |         $this->signatureGenerator = $signatureGenerator;
 99 |     }
100 | 
101 |     public function getSignatureGenerator(): SignatureGeneratorInterface
102 |     {
103 |         return $this->signatureGenerator
104 |             ?? $this->signatureGenerator = new SignatureGenerator();
105 |     }
106 | 
107 |     public function setSignatureChecker(SignatureCheckerInterface $signatureChecker): void
108 |     {
109 |         $this->signatureChecker = $signatureChecker;
110 |     }
111 | 
112 |     public function getSignatureChecker(): SignatureCheckerInterface
113 |     {
114 |         return $this->signatureChecker
115 |             ?? $this->signatureChecker = new SignatureChecker($this->getSignatureGenerator());
116 |     }
117 | 
118 |     public function setClassSignatureGenerator(ClassSignatureGeneratorInterface $classSignatureGenerator): void
119 |     {
120 |         $this->classSignatureGenerator = $classSignatureGenerator;
121 |     }
122 | 
123 |     public function getClassSignatureGenerator(): ClassSignatureGeneratorInterface
124 |     {
125 |         return $this->classSignatureGenerator
126 |             ?? $this->classSignatureGenerator = new ClassSignatureGenerator($this->getSignatureGenerator());
127 |     }
128 | }
129 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Exception/DisabledMethodException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Exception;
 6 | 
 7 | use BadMethodCallException;
 8 | 
 9 | use function sprintf;
10 | 
11 | /**
12 |  * Exception for forcefully disabled methods
13 |  */
14 | class DisabledMethodException extends BadMethodCallException implements ExceptionInterface
15 | {
16 |     public const NAME = self::class;
17 | 
18 |     public static function disabledMethod(string $method): self
19 |     {
20 |         return new self(sprintf('Method "%s" is forcefully disabled', $method));
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Exception/ExceptionInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Exception;
 6 | 
 7 | use Throwable;
 8 | 
 9 | /**
10 |  * Base exception class for the proxy manager
11 |  */
12 | interface ExceptionInterface extends Throwable
13 | {
14 | }
15 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Exception/FileNotWritableException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Exception;
 6 | 
 7 | use Symfony\Component\Filesystem\Exception\IOException;
 8 | use Throwable;
 9 | use UnexpectedValueException;
10 | 
11 | use function sprintf;
12 | 
13 | /**
14 |  * Exception for non writable files
15 |  */
16 | class FileNotWritableException extends UnexpectedValueException implements ExceptionInterface
17 | {
18 |     /**
19 |      * @deprecated
20 |      */
21 |     public static function fromInvalidMoveOperation(string $fromPath, string $toPath): self
22 |     {
23 |         return new self(sprintf(
24 |             'Could not move file "%s" to location "%s": '
25 |             . 'either the source file is not readable, or the destination is not writable',
26 |             $fromPath,
27 |             $toPath
28 |         ));
29 |     }
30 | 
31 |     /**
32 |      * @deprecated
33 |      */
34 |     public static function fromNotWritableDirectory(string $directory): self
35 |     {
36 |         return new self(sprintf(
37 |             'Could not create temp file in directory "%s" '
38 |             . 'either the directory does not exist, or it is not writable',
39 |             $directory
40 |         ));
41 |     }
42 | 
43 |     public static function fromPrevious(Throwable $previous): self
44 |     {
45 |         return new self($previous->getMessage(), 0, $previous);
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Exception/InvalidProxiedClassException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Exception;
 6 | 
 7 | use InvalidArgumentException;
 8 | use ReflectionClass;
 9 | use ReflectionMethod;
10 | 
11 | use function array_filter;
12 | use function array_map;
13 | use function implode;
14 | use function sprintf;
15 | 
16 | /**
17 |  * Exception for invalid proxied classes
18 |  */
19 | class InvalidProxiedClassException extends InvalidArgumentException implements ExceptionInterface
20 | {
21 |     public static function interfaceNotSupported(ReflectionClass $reflection): self
22 |     {
23 |         return new self(sprintf('Provided interface "%s" cannot be proxied', $reflection->getName()));
24 |     }
25 | 
26 |     public static function finalClassNotSupported(ReflectionClass $reflection): self
27 |     {
28 |         return new self(sprintf('Provided class "%s" is final and cannot be proxied', $reflection->getName()));
29 |     }
30 | 
31 |     public static function abstractProtectedMethodsNotSupported(ReflectionClass $reflection): self
32 |     {
33 |         return new self(sprintf(
34 |             'Provided class "%s" has following protected abstract methods, and therefore cannot be proxied:' . "\n%s",
35 |             $reflection->getName(),
36 |             implode(
37 |                 "\n",
38 |                 array_map(
39 |                     static function (ReflectionMethod $reflectionMethod): string {
40 |                         return $reflectionMethod->getDeclaringClass()->getName() . '::' . $reflectionMethod->getName();
41 |                     },
42 |                     array_filter(
43 |                         $reflection->getMethods(),
44 |                         static function (ReflectionMethod $method): bool {
45 |                             return $method->isAbstract() && $method->isProtected();
46 |                         }
47 |                     )
48 |                 )
49 |             )
50 |         ));
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Exception/InvalidProxyDirectoryException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Exception;
 6 | 
 7 | use InvalidArgumentException;
 8 | 
 9 | use function sprintf;
10 | 
11 | /**
12 |  * Exception for invalid directories
13 |  */
14 | class InvalidProxyDirectoryException extends InvalidArgumentException implements ExceptionInterface
15 | {
16 |     public static function proxyDirectoryNotFound(string $directory): self
17 |     {
18 |         return new self(sprintf('Provided directory "%s" does not exist', $directory));
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Exception/UnsupportedProxiedClassException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Exception;
 6 | 
 7 | use LogicException;
 8 | use ProxyManager\ProxyGenerator\Util\Properties;
 9 | use ReflectionClass;
10 | use ReflectionProperty;
11 | 
12 | use function array_map;
13 | use function implode;
14 | use function sprintf;
15 | 
16 | /**
17 |  * Exception for invalid proxied classes
18 |  */
19 | class UnsupportedProxiedClassException extends LogicException implements ExceptionInterface
20 | {
21 |     public static function unsupportedLocalizedReflectionProperty(ReflectionProperty $property): self
22 |     {
23 |         return new self(
24 |             sprintf(
25 |                 'Provided reflection property "%s" of class "%s" is private and cannot be localized in PHP 5.3',
26 |                 $property->getName(),
27 |                 $property->getDeclaringClass()->getName()
28 |             )
29 |         );
30 |     }
31 | 
32 |     public static function nonReferenceableLocalizedReflectionProperties(
33 |         ReflectionClass $class,
34 |         Properties $properties
35 |     ): self {
36 |         return new self(sprintf(
37 |             'Cannot create references for following properties of class %s: %s',
38 |             $class->getName(),
39 |             implode(', ', array_map(static function (ReflectionProperty $property): string {
40 |                 return $property->getName();
41 |             }, $properties->getInstanceProperties()))
42 |         ));
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Factory/AbstractBaseFactory.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace ProxyManager\Factory;
  6 | 
  7 | use OutOfBoundsException;
  8 | use ProxyManager\Configuration;
  9 | use ProxyManager\Generator\ClassGenerator;
 10 | use ProxyManager\ProxyGenerator\ProxyGeneratorInterface;
 11 | use ProxyManager\Signature\Exception\InvalidSignatureException;
 12 | use ProxyManager\Signature\Exception\MissingSignatureException;
 13 | use ProxyManager\Version;
 14 | use ReflectionClass;
 15 | 
 16 | use function array_key_exists;
 17 | use function assert;
 18 | use function class_exists;
 19 | use function is_a;
 20 | use function serialize;
 21 | use function sha1;
 22 | 
 23 | /**
 24 |  * Base factory common logic
 25 |  */
 26 | abstract class AbstractBaseFactory
 27 | {
 28 |     protected $configuration;
 29 | 
 30 |     /**
 31 |      * Cached checked class names
 32 |      *
 33 |      * @var array<string, string>
 34 |      * @psalm-var array<string, class-string>
 35 |      */
 36 |     private $checkedClasses = [];
 37 | 
 38 |     public function __construct(?Configuration $configuration = null)
 39 |     {
 40 |         $this->configuration = $configuration ?? new Configuration();
 41 |     }
 42 | 
 43 |     /**
 44 |      * Generate a proxy from a class name
 45 |      *
 46 |      * @param array<string, mixed> $proxyOptions
 47 |      * @psalm-param class-string<RealObjectType> $className
 48 |      *
 49 |      * @psalm-return class-string<RealObjectType>
 50 |      *
 51 |      * @throws InvalidSignatureException
 52 |      * @throws MissingSignatureException
 53 |      * @throws OutOfBoundsException
 54 |      *
 55 |      * @psalm-template RealObjectType of object
 56 |      */
 57 |     protected function generateProxy(string $className, array $proxyOptions = []): string
 58 |     {
 59 |         $cacheKey = $proxyOptions ? sha1(serialize([$className, $proxyOptions])) : $className;
 60 | 
 61 |         if (array_key_exists($cacheKey, $this->checkedClasses)) {
 62 |             $generatedClassName = $this->checkedClasses[$cacheKey];
 63 | 
 64 |             assert(is_a($generatedClassName, $className, true));
 65 | 
 66 |             return $generatedClassName;
 67 |         }
 68 | 
 69 |         $proxyParameters = [
 70 |             'className'           => $className,
 71 |             'factory'             => static::class,
 72 |             'proxyManagerVersion' => Version::getVersion(),
 73 |             'proxyOptions'        => $proxyOptions,
 74 |         ];
 75 |         $proxyClassName  = $this
 76 |             ->configuration
 77 |             ->getClassNameInflector()
 78 |             ->getProxyClassName($className, $proxyParameters);
 79 | 
 80 |         if (! class_exists($proxyClassName)) {
 81 |             $this->generateProxyClass(
 82 |                 $proxyClassName,
 83 |                 $className,
 84 |                 $proxyParameters,
 85 |                 $proxyOptions
 86 |             );
 87 |         }
 88 | 
 89 |         $this
 90 |             ->configuration
 91 |             ->getSignatureChecker()
 92 |             ->checkSignature(new ReflectionClass($proxyClassName), $proxyParameters);
 93 | 
 94 |         return $this->checkedClasses[$cacheKey] = $proxyClassName;
 95 |     }
 96 | 
 97 |     abstract protected function getGenerator(): ProxyGeneratorInterface;
 98 | 
 99 |     /**
100 |      * Generates the provided `$proxyClassName` from the given `$className` and `$proxyParameters`
101 |      *
102 |      * @param array<string, mixed> $proxyParameters
103 |      * @param array<string, mixed> $proxyOptions
104 |      * @psalm-param class-string $proxyClassName
105 |      * @psalm-param class-string $className
106 |      */
107 |     private function generateProxyClass(
108 |         string $proxyClassName,
109 |         string $className,
110 |         array $proxyParameters,
111 |         array $proxyOptions = []
112 |     ): void {
113 |         $className = $this->configuration->getClassNameInflector()->getUserClassName($className);
114 |         $phpClass  = new ClassGenerator($proxyClassName);
115 | 
116 |         /** @psalm-suppress TooManyArguments - generator interface was not updated due to BC compliance */
117 |         $this->getGenerator()->generate(new ReflectionClass($className), $phpClass, $proxyOptions);
118 | 
119 |         $phpClass = $this->configuration->getClassSignatureGenerator()->addSignature($phpClass, $proxyParameters);
120 | 
121 |         /** @psalm-suppress TooManyArguments - generator interface was not updated due to BC compliance */
122 |         $this->configuration->getGeneratorStrategy()->generate($phpClass, $proxyOptions);
123 | 
124 |         $autoloader = $this->configuration->getProxyAutoloader();
125 | 
126 |         $autoloader($proxyClassName);
127 |     }
128 | }
129 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Factory/AccessInterceptorScopeLocalizerFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Factory;
 6 | 
 7 | use Closure;
 8 | use OutOfBoundsException;
 9 | use ProxyManager\Configuration;
10 | use ProxyManager\Proxy\AccessInterceptorInterface;
11 | use ProxyManager\ProxyGenerator\AccessInterceptorScopeLocalizerGenerator;
12 | use ProxyManager\ProxyGenerator\ProxyGeneratorInterface;
13 | use ProxyManager\Signature\Exception\InvalidSignatureException;
14 | use ProxyManager\Signature\Exception\MissingSignatureException;
15 | 
16 | use function get_class;
17 | 
18 | /**
19 |  * Factory responsible of producing proxy objects
20 |  */
21 | class AccessInterceptorScopeLocalizerFactory extends AbstractBaseFactory
22 | {
23 |     private $generator;
24 | 
25 |     public function __construct(?Configuration $configuration = null)
26 |     {
27 |         parent::__construct($configuration);
28 | 
29 |         $this->generator = new AccessInterceptorScopeLocalizerGenerator();
30 |     }
31 | 
32 |     /**
33 |      * @param object                 $instance           the object to be localized within the access interceptor
34 |      * @param array<string, Closure> $prefixInterceptors an array (indexed by method name) of interceptor closures to be called
35 |      *                                       before method logic is executed
36 |      * @param array<string, Closure> $suffixInterceptors an array (indexed by method name) of interceptor closures to be called
37 |      *                                       after method logic is executed
38 |      * @psalm-param RealObjectType $instance
39 |      * @psalm-param array<string, Closure(
40 |      *   RealObjectType&AccessInterceptorInterface<RealObjectType>=,
41 |      *   RealObjectType=,
42 |      *   string=,
43 |      *   array<string, mixed>=,
44 |      *   bool=
45 |      * ) : mixed> $prefixInterceptors
46 |      * @psalm-param array<string, Closure(
47 |      *   RealObjectType&AccessInterceptorInterface<RealObjectType>=,
48 |      *   RealObjectType=,
49 |      *   string=,
50 |      *   array<string, mixed>=,
51 |      *   mixed=,
52 |      *   bool=
53 |      * ) : mixed> $suffixInterceptors
54 |      *
55 |      * @psalm-return RealObjectType&AccessInterceptorInterface<RealObjectType>
56 |      *
57 |      * @throws InvalidSignatureException
58 |      * @throws MissingSignatureException
59 |      * @throws OutOfBoundsException
60 |      *
61 |      * @psalm-template RealObjectType of object
62 |      * @psalm-suppress MixedInferredReturnType We ignore type checks here, since `staticProxyConstructor` is not
63 |      *                                         interfaced (by design)
64 |      */
65 |     public function createProxy(
66 |         $instance,
67 |         array $prefixInterceptors = [],
68 |         array $suffixInterceptors = []
69 |     ): AccessInterceptorInterface {
70 |         $proxyClassName = $this->generateProxy(get_class($instance));
71 | 
72 |         /**
73 |          * We ignore type checks here, since `staticProxyConstructor` is not interfaced (by design)
74 |          *
75 |          * @psalm-suppress MixedMethodCall
76 |          * @psalm-suppress MixedReturnStatement
77 |          */
78 |         return $proxyClassName::staticProxyConstructor($instance, $prefixInterceptors, $suffixInterceptors);
79 |     }
80 | 
81 |     protected function getGenerator(): ProxyGeneratorInterface
82 |     {
83 |         return $this->generator;
84 |     }
85 | }
86 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Factory/AccessInterceptorValueHolderFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Factory;
 6 | 
 7 | use Closure;
 8 | use OutOfBoundsException;
 9 | use ProxyManager\Configuration;
10 | use ProxyManager\Proxy\AccessInterceptorInterface;
11 | use ProxyManager\Proxy\AccessInterceptorValueHolderInterface;
12 | use ProxyManager\Proxy\ValueHolderInterface;
13 | use ProxyManager\ProxyGenerator\AccessInterceptorValueHolderGenerator;
14 | use ProxyManager\ProxyGenerator\ProxyGeneratorInterface;
15 | use ProxyManager\Signature\Exception\InvalidSignatureException;
16 | use ProxyManager\Signature\Exception\MissingSignatureException;
17 | 
18 | use function get_class;
19 | 
20 | /**
21 |  * Factory responsible of producing proxy objects
22 |  */
23 | class AccessInterceptorValueHolderFactory extends AbstractBaseFactory
24 | {
25 |     private $generator;
26 | 
27 |     public function __construct(?Configuration $configuration = null)
28 |     {
29 |         parent::__construct($configuration);
30 | 
31 |         $this->generator = new AccessInterceptorValueHolderGenerator();
32 |     }
33 | 
34 |     /**
35 |      * @param object                 $instance           the object to be wrapped within the value holder
36 |      * @param array<string, Closure> $prefixInterceptors an array (indexed by method name) of interceptor closures to be called
37 |      *                                       before method logic is executed
38 |      * @param array<string, Closure> $suffixInterceptors an array (indexed by method name) of interceptor closures to be called
39 |      *                                       after method logic is executed
40 |      * @psalm-param RealObjectType $instance
41 |      * @psalm-param array<string, callable(
42 |      *   RealObjectType&AccessInterceptorInterface<RealObjectType>=,
43 |      *   RealObjectType=,
44 |      *   string=,
45 |      *   array<string, mixed>=,
46 |      *   bool=
47 |      * ) : mixed> $prefixInterceptors
48 |      * @psalm-param array<string, callable(
49 |      *   RealObjectType&AccessInterceptorInterface<RealObjectType>=,
50 |      *   RealObjectType=,
51 |      *   string=,
52 |      *   array<string, mixed>=,
53 |      *   mixed=,
54 |      *   bool=
55 |      * ) : mixed> $suffixInterceptors
56 |      *
57 |      * @psalm-return RealObjectType&AccessInterceptorInterface<RealObjectType>&ValueHolderInterface<RealObjectType>&AccessInterceptorValueHolderInterface<RealObjectType>
58 |      *
59 |      * @throws InvalidSignatureException
60 |      * @throws MissingSignatureException
61 |      * @throws OutOfBoundsException
62 |      *
63 |      * @psalm-template RealObjectType of object
64 |      * @psalm-suppress MixedInferredReturnType We ignore type checks here, since `staticProxyConstructor` is not
65 |      *                                         interfaced (by design)
66 |      */
67 |     public function createProxy(
68 |         $instance,
69 |         array $prefixInterceptors = [],
70 |         array $suffixInterceptors = []
71 |     ): AccessInterceptorValueHolderInterface {
72 |         $proxyClassName = $this->generateProxy(get_class($instance));
73 | 
74 |         /**
75 |          * We ignore type checks here, since `staticProxyConstructor` is not interfaced (by design)
76 |          *
77 |          * @psalm-suppress MixedMethodCall
78 |          * @psalm-suppress MixedReturnStatement
79 |          */
80 |         return $proxyClassName::staticProxyConstructor($instance, $prefixInterceptors, $suffixInterceptors);
81 |     }
82 | 
83 |     protected function getGenerator(): ProxyGeneratorInterface
84 |     {
85 |         return $this->generator;
86 |     }
87 | }
88 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Factory/LazyLoadingValueHolderFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Factory;
 6 | 
 7 | use Closure;
 8 | use ProxyManager\Configuration;
 9 | use ProxyManager\Proxy\ValueHolderInterface;
10 | use ProxyManager\Proxy\VirtualProxyInterface;
11 | use ProxyManager\ProxyGenerator\LazyLoadingValueHolderGenerator;
12 | use ProxyManager\ProxyGenerator\ProxyGeneratorInterface;
13 | 
14 | /**
15 |  * Factory responsible of producing virtual proxy instances
16 |  */
17 | class LazyLoadingValueHolderFactory extends AbstractBaseFactory
18 | {
19 |     private $generator;
20 | 
21 |     public function __construct(?Configuration $configuration = null)
22 |     {
23 |         parent::__construct($configuration);
24 | 
25 |         $this->generator = new LazyLoadingValueHolderGenerator();
26 |     }
27 | 
28 |     /**
29 |      * @param array<string, mixed> $proxyOptions
30 |      * @psalm-param class-string<RealObjectType> $className
31 |      * @psalm-param Closure(
32 |      *   RealObjectType|null=,
33 |      *   RealObjectType&ValueHolderInterface<RealObjectType>&VirtualProxyInterface=,
34 |      *   string=,
35 |      *   array<string, mixed>=,
36 |      *   ?Closure=
37 |      * ) : bool $initializer
38 |      * @psalm-param array{skipDestructor?: bool, fluentSafe?: bool} $proxyOptions
39 |      *
40 |      * @psalm-return RealObjectType&ValueHolderInterface<RealObjectType>&VirtualProxyInterface
41 |      *
42 |      * @psalm-template RealObjectType of object
43 |      * @psalm-suppress MixedInferredReturnType We ignore type checks here, since `staticProxyConstructor` is not
44 |      *                                         interfaced (by design)
45 |      */
46 |     public function createProxy(
47 |         string $className,
48 |         Closure $initializer,
49 |         array $proxyOptions = []
50 |     ): VirtualProxyInterface {
51 |         $proxyClassName = $this->generateProxy($className, $proxyOptions);
52 | 
53 |         /**
54 |          * We ignore type checks here, since `staticProxyConstructor` is not interfaced (by design)
55 |          *
56 |          * @psalm-suppress MixedMethodCall
57 |          * @psalm-suppress MixedReturnStatement
58 |          */
59 |         return $proxyClassName::staticProxyConstructor($initializer);
60 |     }
61 | 
62 |     protected function getGenerator(): ProxyGeneratorInterface
63 |     {
64 |         return $this->generator;
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Factory/NullObjectFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Factory;
 6 | 
 7 | use OutOfBoundsException;
 8 | use ProxyManager\Configuration;
 9 | use ProxyManager\Proxy\NullObjectInterface;
10 | use ProxyManager\ProxyGenerator\NullObjectGenerator;
11 | use ProxyManager\ProxyGenerator\ProxyGeneratorInterface;
12 | use ProxyManager\Signature\Exception\InvalidSignatureException;
13 | use ProxyManager\Signature\Exception\MissingSignatureException;
14 | 
15 | use function get_class;
16 | use function is_object;
17 | 
18 | /**
19 |  * Factory responsible of producing proxy objects
20 |  */
21 | class NullObjectFactory extends AbstractBaseFactory
22 | {
23 |     private $generator;
24 | 
25 |     public function __construct(?Configuration $configuration = null)
26 |     {
27 |         parent::__construct($configuration);
28 | 
29 |         $this->generator = new NullObjectGenerator();
30 |     }
31 | 
32 |     /**
33 |      * @param object|string $instanceOrClassName the object to be wrapped or interface to transform to null object
34 |      * @psalm-param RealObjectType|class-string<RealObjectType> $instanceOrClassName
35 |      *
36 |      * @psalm-return RealObjectType&NullObjectInterface
37 |      *
38 |      * @throws InvalidSignatureException
39 |      * @throws MissingSignatureException
40 |      * @throws OutOfBoundsException
41 |      *
42 |      * @psalm-template RealObjectType of object
43 |      * @psalm-suppress MixedInferredReturnType We ignore type checks here, since `staticProxyConstructor` is not
44 |      *                                         interfaced (by design)
45 |      */
46 |     public function createProxy($instanceOrClassName): NullObjectInterface
47 |     {
48 |         $className      = is_object($instanceOrClassName) ? get_class($instanceOrClassName) : $instanceOrClassName;
49 |         $proxyClassName = $this->generateProxy($className);
50 | 
51 |         /**
52 |          * We ignore type checks here, since `staticProxyConstructor` is not interfaced (by design)
53 |          *
54 |          * @psalm-suppress MixedMethodCall
55 |          * @psalm-suppress MixedReturnStatement
56 |          */
57 |         return $proxyClassName::staticProxyConstructor();
58 |     }
59 | 
60 |     protected function getGenerator(): ProxyGeneratorInterface
61 |     {
62 |         return $this->generator;
63 |     }
64 | }
65 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Factory/RemoteObject/Adapter/BaseAdapter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Factory\RemoteObject\Adapter;
 6 | 
 7 | use Laminas\Server\Client;
 8 | use ProxyManager\Factory\RemoteObject\AdapterInterface;
 9 | 
10 | use function array_key_exists;
11 | 
12 | /**
13 |  * Remote Object base adapter
14 |  */
15 | abstract class BaseAdapter implements AdapterInterface
16 | {
17 |     protected $client;
18 | 
19 |     /**
20 |      * Service name mapping
21 |      *
22 |      * @var array<string, string>
23 |      */
24 |     protected $map = [];
25 | 
26 |     /**
27 |      * Constructor
28 |      *
29 |      * @param array<string, string> $map map of service names to their aliases
30 |      */
31 |     public function __construct(Client $client, array $map = [])
32 |     {
33 |         $this->client = $client;
34 |         $this->map    = $map;
35 |     }
36 | 
37 |     /**
38 |      * {@inheritDoc}
39 |      */
40 |     public function call(string $wrappedClass, string $method, array $params = [])
41 |     {
42 |         $serviceName = $this->getServiceName($wrappedClass, $method);
43 | 
44 |         if (array_key_exists($serviceName, $this->map)) {
45 |             $serviceName = $this->map[$serviceName];
46 |         }
47 | 
48 |         return $this->client->call($serviceName, $params);
49 |     }
50 | 
51 |     /**
52 |      * Get the service name will be used by the adapter
53 |      */
54 |     abstract protected function getServiceName(string $wrappedClass, string $method): string;
55 | }
56 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Factory/RemoteObject/Adapter/JsonRpc.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Factory\RemoteObject\Adapter;
 6 | 
 7 | /**
 8 |  * Remote Object JSON RPC adapter
 9 |  */
10 | class JsonRpc extends BaseAdapter
11 | {
12 |     protected function getServiceName(string $wrappedClass, string $method): string
13 |     {
14 |         return $wrappedClass . '.' . $method;
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Factory/RemoteObject/Adapter/Soap.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Factory\RemoteObject\Adapter;
 6 | 
 7 | /**
 8 |  * Remote Object SOAP adapter
 9 |  */
10 | class Soap extends BaseAdapter
11 | {
12 |     protected function getServiceName(string $wrappedClass, string $method): string
13 |     {
14 |         return $method;
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Factory/RemoteObject/Adapter/XmlRpc.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Factory\RemoteObject\Adapter;
 6 | 
 7 | /**
 8 |  * Remote Object XML RPC adapter
 9 |  */
10 | class XmlRpc extends BaseAdapter
11 | {
12 |     protected function getServiceName(string $wrappedClass, string $method): string
13 |     {
14 |         return $wrappedClass . '.' . $method;
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Factory/RemoteObject/AdapterInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Factory\RemoteObject;
 6 | 
 7 | /**
 8 |  * Remote Object adapter interface
 9 |  */
10 | interface AdapterInterface
11 | {
12 |     /**
13 |      * Call remote object
14 |      *
15 |      * @param array<int, mixed> $params
16 |      *
17 |      * Due to BC compliance, we cannot add a native `: mixed` return type declaration here
18 |      *
19 |      * phpcs:disable SlevomatCodingStandard.TypeHints.ReturnTypeHint.MissingNativeTypeHint
20 |      *
21 |      * @return mixed
22 |      */
23 |     public function call(string $wrappedClass, string $method, array $params = []);
24 | }
25 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Factory/RemoteObjectFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Factory;
 6 | 
 7 | use OutOfBoundsException;
 8 | use ProxyManager\Configuration;
 9 | use ProxyManager\Factory\RemoteObject\AdapterInterface;
10 | use ProxyManager\Proxy\RemoteObjectInterface;
11 | use ProxyManager\ProxyGenerator\ProxyGeneratorInterface;
12 | use ProxyManager\ProxyGenerator\RemoteObjectGenerator;
13 | use ProxyManager\Signature\Exception\InvalidSignatureException;
14 | use ProxyManager\Signature\Exception\MissingSignatureException;
15 | 
16 | use function get_class;
17 | use function is_object;
18 | 
19 | /**
20 |  * Factory responsible of producing remote proxy objects
21 |  */
22 | class RemoteObjectFactory extends AbstractBaseFactory
23 | {
24 |     protected $adapter;
25 |     private $generator;
26 | 
27 |     /**
28 |      * {@inheritDoc}
29 |      *
30 |      * @param AdapterInterface $adapter
31 |      * @param Configuration    $configuration
32 |      */
33 |     public function __construct(AdapterInterface $adapter, ?Configuration $configuration = null)
34 |     {
35 |         parent::__construct($configuration);
36 | 
37 |         $this->adapter   = $adapter;
38 |         $this->generator = new RemoteObjectGenerator();
39 |     }
40 | 
41 |     /**
42 |      * @psalm-param RealObjectType|class-string<RealObjectType> $instanceOrClassName
43 |      *
44 |      * @psalm-return RealObjectType&RemoteObjectInterface
45 |      *
46 |      * @throws InvalidSignatureException
47 |      * @throws MissingSignatureException
48 |      * @throws OutOfBoundsException
49 |      *
50 |      * @psalm-template RealObjectType of object
51 |      * @psalm-suppress MixedInferredReturnType We ignore type checks here, since `staticProxyConstructor` is not
52 |      *                                         interfaced (by design)
53 |      */
54 |     public function createProxy($instanceOrClassName): RemoteObjectInterface
55 |     {
56 |         $proxyClassName = $this->generateProxy(
57 |             is_object($instanceOrClassName) ? get_class($instanceOrClassName) : $instanceOrClassName
58 |         );
59 | 
60 |         /**
61 |          * We ignore type checks here, since `staticProxyConstructor` is not interfaced (by design)
62 |          *
63 |          * @psalm-suppress MixedMethodCall
64 |          * @psalm-suppress MixedReturnStatement
65 |          */
66 |         return $proxyClassName::staticProxyConstructor($this->adapter);
67 |     }
68 | 
69 |     protected function getGenerator(): ProxyGeneratorInterface
70 |     {
71 |         return $this->generator ?? $this->generator = new RemoteObjectGenerator();
72 |     }
73 | }
74 | 


--------------------------------------------------------------------------------
/src/ProxyManager/FileLocator/FileLocator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\FileLocator;
 6 | 
 7 | use ProxyManager\Exception\InvalidProxyDirectoryException;
 8 | 
 9 | use function realpath;
10 | use function str_replace;
11 | 
12 | use const DIRECTORY_SEPARATOR;
13 | 
14 | class FileLocator implements FileLocatorInterface
15 | {
16 |     protected $proxiesDirectory;
17 | 
18 |     /**
19 |      * @throws InvalidProxyDirectoryException
20 |      */
21 |     public function __construct(string $proxiesDirectory)
22 |     {
23 |         $absolutePath = realpath($proxiesDirectory);
24 | 
25 |         if ($absolutePath === false) {
26 |             throw InvalidProxyDirectoryException::proxyDirectoryNotFound($proxiesDirectory);
27 |         }
28 | 
29 |         $this->proxiesDirectory = $absolutePath;
30 |     }
31 | 
32 |     public function getProxyFileName(string $className): string
33 |     {
34 |         return $this->proxiesDirectory . DIRECTORY_SEPARATOR . str_replace('\\', '', $className) . '.php';
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/ProxyManager/FileLocator/FileLocatorInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\FileLocator;
 6 | 
 7 | /**
 8 |  * Basic autoloader utilities required to work with proxy files
 9 |  */
10 | interface FileLocatorInterface
11 | {
12 |     /**
13 |      * Retrieves the file name for the given proxy
14 |      */
15 |     public function getProxyFileName(string $className): string;
16 | }
17 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Generator/ClassGenerator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Generator;
 6 | 
 7 | use Laminas\Code\Generator\ClassGenerator as LaminasClassGenerator;
 8 | 
 9 | /**
10 |  * Class generator that ensures that interfaces/classes that are implemented/extended are FQCNs
11 |  *
12 |  * @internal do not use this in your code: it is only here for internal use
13 |  * @deprecated this class was in use due to parent implementation not receiving prompt bugfixes, but
14 |  *             `laminas/laminas-code` is actively maintained and receives quick release iterations.
15 |  */
16 | class ClassGenerator extends LaminasClassGenerator
17 | {
18 | }
19 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Generator/MagicMethodGenerator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Generator;
 6 | 
 7 | use Laminas\Code\Generator\MethodGenerator as LaminasMethodGenerator;
 8 | use Laminas\Code\Generator\ParameterGenerator;
 9 | use LogicException;
10 | use ReflectionClass;
11 | use ReflectionIntersectionType;
12 | use ReflectionNamedType;
13 | use ReflectionUnionType;
14 | 
15 | use function get_class;
16 | use function implode;
17 | use function strtolower;
18 | 
19 | /**
20 |  * Method generator for magic methods
21 |  */
22 | class MagicMethodGenerator extends MethodGenerator
23 | {
24 |     /**
25 |      * @param ParameterGenerator[]|array[]|string[] $parameters
26 |      */
27 |     public function __construct(ReflectionClass $originalClass, string $name, array $parameters = [])
28 |     {
29 |         parent::__construct(
30 |             $name,
31 |             $parameters,
32 |             self::FLAG_PUBLIC
33 |         );
34 | 
35 |         $this->setReturnsReference(strtolower($name) === '__get');
36 | 
37 |         if (! $originalClass->hasMethod($name)) {
38 |             return;
39 |         }
40 | 
41 |         $originalMethod     = $originalClass->getMethod($name);
42 |         $originalReturnType = $originalMethod->getReturnType();
43 | 
44 |         $this->setReturnsReference($originalMethod->returnsReference());
45 | 
46 |         if ($originalReturnType instanceof ReflectionNamedType) {
47 |             $this->setReturnType(($originalReturnType->allowsNull() && $originalReturnType->getName() !== 'mixed' ? '?' : '') . $originalReturnType->getName());
48 |         } elseif ($originalReturnType instanceof ReflectionUnionType || $originalReturnType instanceof ReflectionIntersectionType) {
49 |             $returnType = [];
50 |             foreach ($originalReturnType->getTypes() as $type) {
51 |                 $returnType[] = $type->getName();
52 |             }
53 | 
54 |             $this->setReturnType(implode($originalReturnType instanceof ReflectionIntersectionType ? '&' : '|', $returnType));
55 |         } elseif ($originalReturnType) {
56 |             throw new LogicException('Unexpected ' . get_class($type));
57 |         }
58 |     }
59 | 
60 |     public function setBody($body): LaminasMethodGenerator
61 |     {
62 |         if ((string) $this->getReturnType() === 'void') {
63 |             $body = preg_replace('/return ([^;]++;)/', '\1 return;', $body);
64 |         }
65 | 
66 |         return parent::setBody($body);
67 |     }
68 | }
69 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Generator/Util/ClassGeneratorUtils.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Generator\Util;
 6 | 
 7 | use Laminas\Code\Generator\ClassGenerator;
 8 | use Laminas\Code\Generator\MethodGenerator;
 9 | use ReflectionClass;
10 | 
11 | /**
12 |  * Util class to help to generate code
13 |  */
14 | final class ClassGeneratorUtils
15 | {
16 |     public static function addMethodIfNotFinal(
17 |         ReflectionClass $originalClass,
18 |         ClassGenerator $classGenerator,
19 |         MethodGenerator $generatedMethod
20 |     ): bool {
21 |         $methodName = $generatedMethod->getName();
22 | 
23 |         if ($originalClass->hasMethod($methodName) && $originalClass->getMethod($methodName)->isFinal()) {
24 |             return false;
25 |         }
26 | 
27 |         $classGenerator->addMethodFromGenerator($generatedMethod);
28 | 
29 |         return true;
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Generator/Util/IdentifierSuffixer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Generator\Util;
 6 | 
 7 | use Composer\InstalledVersions;
 8 | 
 9 | use function class_exists;
10 | use function method_exists;
11 | use function preg_match;
12 | use function serialize;
13 | use function sha1;
14 | use function substr;
15 | 
16 | /**
17 |  * Utility class capable of generating
18 |  * valid class/property/method identifiers
19 |  * with a deterministic attached suffix,
20 |  * in order to prevent property name collisions
21 |  * and tampering from userland
22 |  */
23 | abstract class IdentifierSuffixer
24 | {
25 |     public const VALID_IDENTIFIER_FORMAT = '/^[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]+$/';
26 |     public const DEFAULT_IDENTIFIER      = 'g';
27 | 
28 |     final private function __construct()
29 |     {
30 |     }
31 | 
32 |     /**
33 |      * Generates a valid unique identifier from the given name,
34 |      * with a suffix attached to it
35 |      */
36 |     public static function getIdentifier(string $name): string
37 |     {
38 |         /** @var string|null $salt */
39 |         static $salt;
40 | 
41 |         $salt = $salt ?? self::loadBaseHashSalt();
42 |         $suffix = substr(sha1($name . $salt), 0, 5);
43 | 
44 |         if (! preg_match(self::VALID_IDENTIFIER_FORMAT, $name)) {
45 |             return self::DEFAULT_IDENTIFIER . $suffix;
46 |         }
47 | 
48 |         return $name . $suffix;
49 |     }
50 | 
51 |     private static function loadBaseHashSalt(): string
52 |     {
53 |         if (! class_exists(InstalledVersions::class)) {
54 |             return self::class;
55 |         }
56 | 
57 |         return sha1(serialize(
58 |             method_exists(InstalledVersions::class, 'getAllRawData')
59 |                 ? InstalledVersions::getAllRawData() // Composer >= 2.0.14
60 |                 : InstalledVersions::getRawData()
61 |         ));
62 |     }
63 | }
64 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Generator/Util/ProxiedMethodReturnExpression.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Generator\Util;
 6 | 
 7 | use ReflectionMethod;
 8 | use ReflectionNamedType;
 9 | 
10 | /**
11 |  * Utility class to generate return expressions in method, given a method signature.
12 |  *
13 |  * This is required since return expressions may be forbidden by the method signature (void).
14 |  */
15 | final class ProxiedMethodReturnExpression
16 | {
17 |     public static function generate(string $returnedValueExpression, ?ReflectionMethod $originalMethod): string
18 |     {
19 |         $originalReturnType = $originalMethod === null
20 |             ? null
21 |             : $originalMethod->getReturnType();
22 | 
23 |         if ($originalReturnType instanceof ReflectionNamedType && $originalReturnType->getName() === 'void') {
24 |             return $returnedValueExpression . ";\nreturn;";
25 |         }
26 | 
27 |         if ($originalReturnType instanceof ReflectionNamedType && $originalReturnType->getName() === 'never') {
28 |             return $returnedValueExpression . ';';
29 |         }
30 | 
31 |         return 'return ' . $returnedValueExpression . ';';
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Generator/Util/UniqueIdentifierGenerator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Generator\Util;
 6 | 
 7 | use function preg_match;
 8 | use function str_replace;
 9 | use function uniqid;
10 | 
11 | /**
12 |  * Utility class capable of generating unique
13 |  * valid class/property/method identifiers
14 |  */
15 | abstract class UniqueIdentifierGenerator
16 | {
17 |     public const VALID_IDENTIFIER_FORMAT = '/^[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]+$/';
18 |     public const DEFAULT_IDENTIFIER      = 'g';
19 | 
20 |     /**
21 |      * Generates a valid unique identifier from the given name
22 |      *
23 |      * @psalm-return class-string
24 |      *
25 |      * @psalm-suppress MoreSpecificReturnType
26 |      */
27 |     public static function getIdentifier(string $name): string
28 |     {
29 |         /**
30 |          * @psalm-suppress LessSpecificReturnStatement
31 |          */
32 |         return str_replace(
33 |             '.',
34 |             '',
35 |             uniqid(
36 |                 preg_match(self::VALID_IDENTIFIER_FORMAT, $name)
37 |                 ? $name
38 |                 : self::DEFAULT_IDENTIFIER,
39 |                 true
40 |             )
41 |         );
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/ProxyManager/GeneratorStrategy/BaseGeneratorStrategy.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\GeneratorStrategy;
 6 | 
 7 | use Laminas\Code\Generator\ClassGenerator;
 8 | 
 9 | /**
10 |  * Generator strategy that generates the class body
11 |  */
12 | class BaseGeneratorStrategy implements GeneratorStrategyInterface
13 | {
14 |     /**
15 |      * {@inheritDoc}
16 |      *
17 |      * @psalm-suppress MixedInferredReturnType upstream has no declared type
18 |      */
19 |     public function generate(ClassGenerator $classGenerator): string
20 |     {
21 |         /** @psalm-suppress MixedReturnStatement upstream has no declared type */
22 |         return $classGenerator->generate();
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/ProxyManager/GeneratorStrategy/EvaluatingGeneratorStrategy.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\GeneratorStrategy;
 6 | 
 7 | use Laminas\Code\Generator\ClassGenerator;
 8 | use Symfony\Component\Filesystem\Filesystem;
 9 | 
10 | use function ini_get;
11 | use function unlink;
12 | 
13 | /**
14 |  * Generator strategy that produces the code and evaluates it at runtime
15 |  */
16 | class EvaluatingGeneratorStrategy implements GeneratorStrategyInterface
17 | {
18 |     /** @var bool flag indicating whether {@see eval} can be used */
19 |     private $canEval = true;
20 | 
21 |     /**
22 |      * Constructor
23 |      */
24 |     public function __construct()
25 |     {
26 |         // @codeCoverageIgnoreStart
27 |         $this->canEval = ! ini_get('suhosin.executor.disable_eval');
28 |         // @codeCoverageIgnoreEnd
29 |     }
30 | 
31 |     /**
32 |      * Evaluates the generated code before returning it
33 |      *
34 |      * {@inheritDoc}
35 |      */
36 |     public function generate(ClassGenerator $classGenerator): string
37 |     {
38 |         $code = $classGenerator->generate();
39 | 
40 |         // @codeCoverageIgnoreStart
41 |         if (! $this->canEval) {
42 |             $fileName = __DIR__ . '/EvaluatingGeneratorStrategy.php.tmp';
43 |             (new Filesystem())->dumpFile($fileName, "<?php\n" . $code);
44 | 
45 |             /* @noinspection PhpIncludeInspection */
46 |             require $fileName;
47 |             unlink($fileName);
48 | 
49 |             return $code;
50 |         }
51 | 
52 |         // @codeCoverageIgnoreEnd
53 | 
54 |         eval($code);
55 | 
56 |         return $code;
57 |     }
58 | }
59 | 


--------------------------------------------------------------------------------
/src/ProxyManager/GeneratorStrategy/FileWriterGeneratorStrategy.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\GeneratorStrategy;
 6 | 
 7 | use Laminas\Code\Generator\ClassGenerator;
 8 | use ProxyManager\Exception\FileNotWritableException;
 9 | use ProxyManager\FileLocator\FileLocatorInterface;
10 | use Symfony\Component\Filesystem\Exception\IOException;
11 | use Symfony\Component\Filesystem\Filesystem;
12 | 
13 | /**
14 |  * Generator strategy that writes the generated classes to disk while generating them
15 |  *
16 |  * {@inheritDoc}
17 |  */
18 | class FileWriterGeneratorStrategy implements GeneratorStrategyInterface
19 | {
20 |     protected $fileLocator;
21 |     private $emptyErrorHandler;
22 | 
23 |     public function __construct(FileLocatorInterface $fileLocator)
24 |     {
25 |         $this->fileLocator = $fileLocator;
26 |     }
27 | 
28 |     /**
29 |      * Write generated code to disk and return the class code
30 |      *
31 |      * {@inheritDoc}
32 |      *
33 |      * @throws FileNotWritableException
34 |      */
35 |     public function generate(ClassGenerator $classGenerator): string
36 |     {
37 |         $generatedCode = $classGenerator->generate();
38 |         $className     = (string) $classGenerator->getNamespaceName() . '\\' . $classGenerator->getName();
39 |         $fileName      = $this->fileLocator->getProxyFileName($className);
40 | 
41 |         try {
42 |             (new Filesystem())->dumpFile($fileName, "<?php\n\n" . $generatedCode);
43 | 
44 |             return $generatedCode;
45 |         } catch (IOException $e) {
46 |             throw FileNotWritableException::fromPrevious($e);
47 |         }
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/src/ProxyManager/GeneratorStrategy/GeneratorStrategyInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\GeneratorStrategy;
 6 | 
 7 | use Laminas\Code\Generator\ClassGenerator;
 8 | 
 9 | class_exists(\Zend\Code\Generator\ClassGenerator::class);
10 | 
11 | /**
12 |  * Generator strategy interface - defines basic behavior of class generators
13 |  */
14 | interface GeneratorStrategyInterface
15 | {
16 |     /**
17 |      * Generate the provided class
18 |      */
19 |     public function generate(ClassGenerator $classGenerator): string;
20 | }
21 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Inflector/ClassNameInflector.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Inflector;
 6 | 
 7 | use ProxyManager\Inflector\Util\ParameterHasher;
 8 | 
 9 | use function is_int;
10 | use function ltrim;
11 | use function strlen;
12 | use function strrpos;
13 | use function substr;
14 | 
15 | final class ClassNameInflector implements ClassNameInflectorInterface
16 | {
17 |     private $proxyNamespace;
18 |     /** @var int @TODO annotation still needed for phpstan to understand this */
19 |     private $proxyMarkerLength;
20 |     private $proxyMarker;
21 |     private $parameterHasher;
22 | 
23 |     public function __construct(string $proxyNamespace)
24 |     {
25 |         $this->proxyNamespace    = $proxyNamespace;
26 |         $this->proxyMarker       = '\\' . self::PROXY_MARKER . '\\';
27 |         $this->proxyMarkerLength = strlen($this->proxyMarker);
28 |         $this->parameterHasher   = new ParameterHasher();
29 |     }
30 | 
31 |     /**
32 |      * {@inheritDoc}
33 |      *
34 |      * @psalm-suppress MoreSpecificReturnType we ignore these issues because classes may not have been loaded yet
35 |      */
36 |     public function getUserClassName(string $className): string
37 |     {
38 |         $className = ltrim($className, '\\');
39 |         $position  = strrpos($className, $this->proxyMarker);
40 | 
41 |         if (! is_int($position)) {
42 |             /** @psalm-suppress LessSpecificReturnStatement */
43 |             return $className;
44 |         }
45 | 
46 |         /** @psalm-suppress LessSpecificReturnStatement */
47 |         return substr(
48 |             $className,
49 |             $this->proxyMarkerLength + $position,
50 |             (int) strrpos($className, '\\') - ($position + $this->proxyMarkerLength)
51 |         );
52 |     }
53 | 
54 |     /**
55 |      * {@inheritDoc}
56 |      *
57 |      * @psalm-suppress MoreSpecificReturnType we ignore these issues because classes may not have been loaded yet
58 |      */
59 |     public function getProxyClassName(string $className, array $options = []): string
60 |     {
61 |         /** @psalm-suppress LessSpecificReturnStatement */
62 |         return $this->proxyNamespace
63 |             . $this->proxyMarker
64 |             . $this->getUserClassName($className)
65 |             . '\\Generated' . $this->parameterHasher->hashParameters($options);
66 |     }
67 | 
68 |     public function isProxyClassName(string $className): bool
69 |     {
70 |         return strrpos($className, $this->proxyMarker) !== false;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Inflector/ClassNameInflectorInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Inflector;
 6 | 
 7 | use ProxyManager\Proxy\ProxyInterface;
 8 | 
 9 | /**
10 |  * Interface for a proxy- to user-class and user- to proxy-class name inflector
11 |  */
12 | interface ClassNameInflectorInterface
13 | {
14 |     /**
15 |      * Marker for proxy classes - classes containing this marker are considered proxies
16 |      */
17 |     public const PROXY_MARKER = '__PM__';
18 | 
19 |     /**
20 |      * Retrieve the class name of a user-defined class
21 |      *
22 |      * @psalm-param class-string<RealClassName>|class-string<ProxyInterface<RealClassName>> $className
23 |      *
24 |      * @psalm-return class-string<RealClassName>
25 |      *
26 |      * @psalm-template RealClassName of object
27 |      */
28 |     public function getUserClassName(string $className): string;
29 | 
30 |     /**
31 |      * Retrieve the class name of the proxy for the given user-defined class name
32 |      *
33 |      * @param array<string, mixed> $options arbitrary options to be used for the generated class name
34 |      * @psalm-param class-string<RealClassName>|class-string<ProxyInterface<RealClassName>> $className
35 |      *
36 |      * @psalm-return class-string<RealClassName&ProxyInterface>
37 |      *
38 |      * @psalm-template RealClassName of object
39 |      */
40 |     public function getProxyClassName(string $className, array $options = []): string;
41 | 
42 |     /**
43 |      * Retrieve whether the provided class name is a proxy
44 |      *
45 |      * @psalm-param class-string<RealClassName>|class-string<ProxyInterface<RealClassName>> $className
46 |      *
47 |      * @psalm-template RealClassName of object
48 |      */
49 |     public function isProxyClassName(string $className): bool;
50 | }
51 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Inflector/Util/ParameterEncoder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Inflector\Util;
 6 | 
 7 | use function base64_encode;
 8 | use function serialize;
 9 | 
10 | /**
11 |  * Encodes parameters into a class-name safe string
12 |  */
13 | class ParameterEncoder
14 | {
15 |     /**
16 |      * Converts the given parameters into a set of characters that are safe to
17 |      * use in a class name
18 |      *
19 |      * @param mixed[] $parameters
20 |      */
21 |     public function encodeParameters(array $parameters): string
22 |     {
23 |         return base64_encode(serialize($parameters));
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Inflector/Util/ParameterHasher.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Inflector\Util;
 6 | 
 7 | use function md5;
 8 | use function serialize;
 9 | 
10 | /**
11 |  * Converts given parameters into a likely unique hash
12 |  */
13 | class ParameterHasher
14 | {
15 |     /**
16 |      * Converts the given parameters into a likely-unique hash
17 |      *
18 |      * @param mixed[] $parameters
19 |      */
20 |     public function hashParameters(array $parameters): string
21 |     {
22 |         return md5(serialize($parameters));
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Proxy/AccessInterceptorInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Proxy;
 6 | 
 7 | use Closure;
 8 | 
 9 | /**
10 |  * Access interceptor object marker
11 |  *
12 |  * @psalm-template InterceptedObjectType of object
13 |  */
14 | interface AccessInterceptorInterface extends ProxyInterface
15 | {
16 |     /**
17 |      * Set or remove the prefix interceptor for a method
18 |      *
19 |      * @link https://github.com/Ocramius/ProxyManager/blob/master/docs/access-interceptor-value-holder.md
20 |      *
21 |      * A prefix interceptor should have a signature like following:
22 |      *
23 |      * <code>
24 |      * $interceptor = function ($proxy, $instance, string $method, array $params, & $returnEarly) {};
25 |      * </code>
26 |      *
27 |      * @param string       $methodName        name of the intercepted method
28 |      * @param Closure|null $prefixInterceptor interceptor closure or null to unset the currently active interceptor
29 |      * @psalm-param null|Closure(
30 |      *   InterceptedObjectType&AccessInterceptorInterface=,
31 |      *   InterceptedObjectType=,
32 |      *   string=,
33 |      *   array<string, mixed>=,
34 |      *   bool=
35 |      * ) : mixed $prefixInterceptor
36 |      */
37 |     public function setMethodPrefixInterceptor(string $methodName, ?Closure $prefixInterceptor = null): void;
38 | 
39 |     /**
40 |      * Set or remove the suffix interceptor for a method
41 |      *
42 |      * @link https://github.com/Ocramius/ProxyManager/blob/master/docs/access-interceptor-value-holder.md
43 |      *
44 |      * A prefix interceptor should have a signature like following:
45 |      *
46 |      * <code>
47 |      * $interceptor = function ($proxy, $instance, string $method, array $params, $returnValue, & $returnEarly) {};
48 |      * </code>
49 |      *
50 |      * @param string       $methodName        name of the intercepted method
51 |      * @param Closure|null $suffixInterceptor interceptor closure or null to unset the currently active interceptor
52 |      * @psalm-param null|Closure(
53 |      *   InterceptedObjectType&AccessInterceptorInterface=,
54 |      *   InterceptedObjectType=,
55 |      *   string=,
56 |      *   array<string, mixed>=,
57 |      *   mixed=,
58 |      *   bool=
59 |      * ) : mixed $suffixInterceptor
60 |      */
61 |     public function setMethodSuffixInterceptor(string $methodName, ?Closure $suffixInterceptor = null): void;
62 | }
63 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Proxy/AccessInterceptorValueHolderInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Proxy;
 6 | 
 7 | use Closure;
 8 | 
 9 | /**
10 |  * Aggregates AccessInterceptor and ValueHolderInterface, mostly for return type hinting
11 |  *
12 |  * @psalm-template InterceptedObjectType of object
13 |  */
14 | interface AccessInterceptorValueHolderInterface extends AccessInterceptorInterface, ValueHolderInterface
15 | {
16 |     /**
17 |      * {@inheritDoc}
18 |      *
19 |      * Definitions are duplicated here to allow templated definitions in this child type
20 |      *
21 |      * @psalm-param null|Closure(
22 |      *   InterceptedObjectType&AccessInterceptorInterface=,
23 |      *   InterceptedObjectType=,
24 |      *   string=,
25 |      *   array<string, mixed>=,
26 |      *   bool=
27 |      * ) : mixed $prefixInterceptor
28 |      */
29 |     public function setMethodPrefixInterceptor(string $methodName, ?Closure $prefixInterceptor = null): void;
30 | 
31 |     /**
32 |      * {@inheritDoc}
33 |      *
34 |      * Definitions are duplicated here to allow templated definitions in this child type
35 |      *
36 |      * @param string       $methodName        name of the intercepted method
37 |      * @param Closure|null $suffixInterceptor interceptor closure or null to unset the currently active interceptor
38 |      * @psalm-param null|Closure(
39 |      *   InterceptedObjectType&AccessInterceptorInterface=,
40 |      *   InterceptedObjectType=,
41 |      *   string=,
42 |      *   array<string, mixed>=,
43 |      *   mixed=,
44 |      *   bool=
45 |      * ) : mixed $suffixInterceptor
46 |      */
47 |     public function setMethodSuffixInterceptor(string $methodName, ?Closure $suffixInterceptor = null): void;
48 | 
49 |     /**
50 |      * {@inheritDoc}
51 |      *
52 |      * Definitions are duplicated here to allow templated definitions in this child type
53 |      *
54 |      * @psalm-return InterceptedObjectType|null
55 |      */
56 |     public function getWrappedValueHolderValue();
57 | }
58 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Proxy/Exception/RemoteObjectException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Proxy\Exception;
 6 | 
 7 | use RuntimeException;
 8 | 
 9 | /**
10 |  * Remote object exception
11 |  *
12 |  * @deprecated this exception is not in use anymore, and should not be relied upon
13 |  */
14 | class RemoteObjectException extends RuntimeException
15 | {
16 | }
17 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Proxy/FallbackValueHolderInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Proxy;
 6 | 
 7 | /**
 8 |  * Fallback value holder object marker
 9 |  *
10 |  * @deprecated this interface is not in use anymore, and should not be relied upon
11 |  */
12 | interface FallbackValueHolderInterface extends ProxyInterface
13 | {
14 | }
15 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Proxy/GhostObjectInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Proxy;
 6 | 
 7 | use Closure;
 8 | 
 9 | /**
10 |  * Ghost object marker
11 |  *
12 |  * @psalm-template LazilyLoadedObjectType of object
13 |  */
14 | interface GhostObjectInterface extends LazyLoadingInterface
15 | {
16 |     /**
17 |      * {@inheritDoc}
18 |      *
19 |      * Definitions are duplicated here to allow templated definitions in this child type.
20 |      *
21 |      * @psalm-param null|Closure(
22 |      *   LazilyLoadedObjectType&GhostObjectInterface<LazilyLoadedObjectType>=,
23 |      *   string=,
24 |      *   array<string, mixed>=,
25 |      *   ?Closure=,
26 |      *   array<string, mixed>=
27 |      * ) : bool $initializer
28 |      *
29 |      * @psalm-suppress ImplementedParamTypeMismatch Note that the closure signature below is slightly different
30 |      *                                              from the one declared in LazyLoadingInterface.
31 |      */
32 |     public function setProxyInitializer(?Closure $initializer = null);
33 | 
34 |     /**
35 |      * {@inheritDoc}
36 |      *
37 |      * Definitions are duplicated here to allow templated definitions in this child type
38 |      *
39 |      * @psalm-return null|Closure(
40 |      *   LazilyLoadedObjectType&GhostObjectInterface<LazilyLoadedObjectType>=,
41 |      *   string,
42 |      *   array<string, mixed>=,
43 |      *   ?Closure=,
44 |      *   array<string, mixed>=
45 |      * ) : bool
46 |      *
47 |      * @psalm-suppress ImplementedReturnTypeMismatch Note that the closure signature below is slightly different
48 |      *                                               from the one declared in LazyLoadingInterface.
49 |      */
50 |     public function getProxyInitializer(): ?Closure;
51 | }
52 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Proxy/LazyLoadingInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Proxy;
 6 | 
 7 | use Closure;
 8 | 
 9 | /**
10 |  * Lazy loading object identifier
11 |  *
12 |  * @psalm-template LazilyLoadedObjectType of object
13 |  */
14 | interface LazyLoadingInterface extends ProxyInterface
15 | {
16 |     /**
17 |      * Set or unset the initializer for the proxy instance
18 |      *
19 |      * @link https://github.com/Ocramius/ProxyManager/blob/master/docs/lazy-loading-value-holder.md#lazy-initialization
20 |      *
21 |      * An initializer should have a signature like following:
22 |      *
23 |      * <code>
24 |      * $initializer = function (
25 |      *   & ?object $wrappedObject,
26 |      *   LazyLoadingInterface $proxy,
27 |      *   string $calledMethod,
28 |      *   array $callParameters,
29 |      *   & ?\Closure $initializer,
30 |      *   array $propertiesToBeSet = [] // works only on ghost objects
31 |      * ) {};
32 |      * </code>
33 |      *
34 |      * @psalm-param null|Closure(
35 |      *   LazilyLoadedObjectType|null=,
36 |      *   LazilyLoadedObjectType&LazyLoadingInterface<LazilyLoadedObjectType>=,
37 |      *   string=,
38 |      *   array<string, mixed>=,
39 |      *   ?Closure=,
40 |      *   array<string, mixed>=
41 |      * ) : bool $initializer
42 |      *
43 |      * Due to BC compliance, we cannot add a native `: void` return type declaration here
44 |      *
45 |      * phpcs:disable SlevomatCodingStandard.TypeHints.ReturnTypeHint.MissingNativeTypeHint
46 |      *
47 |      * @return void
48 |      */
49 |     public function setProxyInitializer(?Closure $initializer = null);
50 | 
51 |     /**
52 |      * @psalm-return null|Closure(
53 |      *   LazilyLoadedObjectType|null=,
54 |      *   LazilyLoadedObjectType&LazyLoadingInterface<LazilyLoadedObjectType>=,
55 |      *   string,
56 |      *   array<string, mixed>=,
57 |      *   ?Closure=,
58 |      *   array<string, mixed>=
59 |      * ) : bool
60 |      */
61 |     public function getProxyInitializer(): ?Closure;
62 | 
63 |     /**
64 |      * Force initialization of the proxy
65 |      *
66 |      * @return bool true if the proxy could be initialized
67 |      */
68 |     public function initializeProxy(): bool;
69 | 
70 |     /**
71 |      * Retrieves current initialization status of the proxy
72 |      */
73 |     public function isProxyInitialized(): bool;
74 | }
75 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Proxy/NullObjectInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Proxy;
 6 | 
 7 | /**
 8 |  * Null object marker
 9 |  */
10 | interface NullObjectInterface extends ProxyInterface
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Proxy/ProxyInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Proxy;
 6 | 
 7 | /**
 8 |  * Base proxy marker
 9 |  *
10 |  * @psalm-template DecoratedClassName of object
11 |  */
12 | interface ProxyInterface
13 | {
14 | }
15 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Proxy/RemoteObjectInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Proxy;
 6 | 
 7 | /**
 8 |  * Remote object marker
 9 |  */
10 | interface RemoteObjectInterface extends ProxyInterface
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Proxy/SmartReferenceInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Proxy;
 6 | 
 7 | /**
 8 |  * Smart reference object marker
 9 |  *
10 |  * @deprecated this interface is not in use anymore, and should not be relied upon
11 |  */
12 | interface SmartReferenceInterface extends ProxyInterface
13 | {
14 | }
15 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Proxy/ValueHolderInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Proxy;
 6 | 
 7 | /**
 8 |  * Value holder marker
 9 |  *
10 |  * @psalm-template WrappedValueHolderType of object
11 |  */
12 | interface ValueHolderInterface extends ProxyInterface
13 | {
14 |     /**
15 |      * @return object|null the wrapped value
16 |      * @psalm-return WrappedValueHolderType|null
17 |      */
18 |     public function getWrappedValueHolderValue();
19 | }
20 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Proxy/VirtualProxyInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Proxy;
 6 | 
 7 | /**
 8 |  * Virtual Proxy - a lazy initializing object wrapping around the proxied subject
 9 |  */
10 | interface VirtualProxyInterface extends LazyLoadingInterface, ValueHolderInterface
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/AccessInterceptor/MethodGenerator/MagicWakeup.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\AccessInterceptor\MethodGenerator;
 6 | 
 7 | use ProxyManager\Generator\MagicMethodGenerator;
 8 | use ProxyManager\ProxyGenerator\Util\Properties;
 9 | use ProxyManager\ProxyGenerator\Util\UnsetPropertiesGenerator;
10 | use ReflectionClass;
11 | 
12 | /**
13 |  * Magic `__wakeup` for lazy loading value holder objects
14 |  */
15 | class MagicWakeup extends MagicMethodGenerator
16 | {
17 |     /**
18 |      * Constructor
19 |      */
20 |     public function __construct(ReflectionClass $originalClass)
21 |     {
22 |         parent::__construct($originalClass, '__wakeup');
23 | 
24 |         $this->setBody(UnsetPropertiesGenerator::generateSnippet(
25 |             Properties::fromReflectionClass($originalClass),
26 |             'this'
27 |         ));
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/AccessInterceptor/MethodGenerator/SetMethodPrefixInterceptor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\AccessInterceptor\MethodGenerator;
 6 | 
 7 | use Closure;
 8 | use Laminas\Code\Generator\Exception\InvalidArgumentException;
 9 | use Laminas\Code\Generator\ParameterGenerator;
10 | use Laminas\Code\Generator\PropertyGenerator;
11 | use ProxyManager\Generator\MethodGenerator;
12 | 
13 | /**
14 |  * Implementation for {@see \ProxyManager\Proxy\AccessInterceptorInterface::setMethodPrefixInterceptor}
15 |  * for access interceptor objects
16 |  */
17 | class SetMethodPrefixInterceptor extends MethodGenerator
18 | {
19 |     /**
20 |      * Constructor
21 |      *
22 |      * @throws InvalidArgumentException
23 |      */
24 |     public function __construct(PropertyGenerator $prefixInterceptor)
25 |     {
26 |         parent::__construct('setMethodPrefixInterceptor');
27 | 
28 |         $interceptor = new ParameterGenerator('prefixInterceptor');
29 | 
30 |         $interceptor->setType('?' . Closure::class);
31 |         $interceptor->setDefaultValue(null);
32 |         $this->setParameter(new ParameterGenerator('methodName', 'string'));
33 |         $this->setParameter($interceptor);
34 |         $this->setReturnType('void');
35 |         $this->setBody('$this->' . $prefixInterceptor->getName() . '[$methodName] = $prefixInterceptor;');
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/AccessInterceptor/MethodGenerator/SetMethodSuffixInterceptor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\AccessInterceptor\MethodGenerator;
 6 | 
 7 | use Closure;
 8 | use Laminas\Code\Generator\Exception\InvalidArgumentException;
 9 | use Laminas\Code\Generator\ParameterGenerator;
10 | use Laminas\Code\Generator\PropertyGenerator;
11 | use ProxyManager\Generator\MethodGenerator;
12 | 
13 | /**
14 |  * Implementation for {@see \ProxyManager\Proxy\AccessInterceptorInterface::setMethodSuffixInterceptor}
15 |  * for access interceptor objects
16 |  */
17 | class SetMethodSuffixInterceptor extends MethodGenerator
18 | {
19 |     /**
20 |      * Constructor
21 |      *
22 |      * @throws InvalidArgumentException
23 |      */
24 |     public function __construct(PropertyGenerator $suffixInterceptor)
25 |     {
26 |         parent::__construct('setMethodSuffixInterceptor');
27 | 
28 |         $interceptor = new ParameterGenerator('suffixInterceptor');
29 | 
30 |         $interceptor->setType('?' . Closure::class);
31 |         $interceptor->setDefaultValue(null);
32 |         $this->setParameter(new ParameterGenerator('methodName', 'string'));
33 |         $this->setParameter($interceptor);
34 |         $this->setReturnType('void');
35 |         $this->setBody('$this->' . $suffixInterceptor->getName() . '[$methodName] = $suffixInterceptor;');
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/AccessInterceptor/PropertyGenerator/MethodPrefixInterceptors.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\AccessInterceptor\PropertyGenerator;
 6 | 
 7 | use Laminas\Code\Generator\Exception\InvalidArgumentException;
 8 | use Laminas\Code\Generator\PropertyGenerator;
 9 | use ProxyManager\Generator\Util\IdentifierSuffixer;
10 | 
11 | /**
12 |  * Property that contains the interceptor for operations to be executed before method execution
13 |  */
14 | class MethodPrefixInterceptors extends PropertyGenerator
15 | {
16 |     /**
17 |      * Constructor
18 |      *
19 |      * @throws InvalidArgumentException
20 |      */
21 |     public function __construct()
22 |     {
23 |         parent::__construct(IdentifierSuffixer::getIdentifier('methodPrefixInterceptors'));
24 | 
25 |         $this->setDefaultValue([]);
26 |         $this->setVisibility(self::VISIBILITY_PRIVATE);
27 |         $this->setDocBlock('@var \\Closure[] map of interceptors to be called per-method before execution');
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/AccessInterceptor/PropertyGenerator/MethodSuffixInterceptors.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\AccessInterceptor\PropertyGenerator;
 6 | 
 7 | use Laminas\Code\Generator\Exception\InvalidArgumentException;
 8 | use Laminas\Code\Generator\PropertyGenerator;
 9 | use ProxyManager\Generator\Util\IdentifierSuffixer;
10 | 
11 | /**
12 |  * Property that contains the interceptor for operations to be executed after method execution
13 |  */
14 | class MethodSuffixInterceptors extends PropertyGenerator
15 | {
16 |     /**
17 |      * Constructor
18 |      *
19 |      * @throws InvalidArgumentException
20 |      */
21 |     public function __construct()
22 |     {
23 |         parent::__construct(IdentifierSuffixer::getIdentifier('methodSuffixInterceptors'));
24 | 
25 |         $this->setDefaultValue([]);
26 |         $this->setVisibility(self::VISIBILITY_PRIVATE);
27 |         $this->setDocBlock('@var \\Closure[] map of interceptors to be called per-method after execution');
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/AccessInterceptorScopeLocalizer/MethodGenerator/BindProxyProperties.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\AccessInterceptorScopeLocalizer\MethodGenerator;
 6 | 
 7 | use Laminas\Code\Generator\ParameterGenerator;
 8 | use Laminas\Code\Generator\PropertyGenerator;
 9 | use ProxyManager\Exception\UnsupportedProxiedClassException;
10 | use ProxyManager\Generator\MethodGenerator;
11 | use ProxyManager\ProxyGenerator\Util\Properties;
12 | use ReflectionClass;
13 | 
14 | use function implode;
15 | use function var_export;
16 | 
17 | /**
18 |  * The `bindProxyProperties` method implementation for access interceptor scope localizers
19 |  */
20 | class BindProxyProperties extends MethodGenerator
21 | {
22 |     /**
23 |      * Constructor
24 |      */
25 |     public function __construct(
26 |         ReflectionClass $originalClass,
27 |         PropertyGenerator $prefixInterceptors,
28 |         PropertyGenerator $suffixInterceptors
29 |     ) {
30 |         parent::__construct(
31 |             'bindProxyProperties',
32 |             [
33 |                 new ParameterGenerator('localizedObject', $originalClass->getName()),
34 |                 new ParameterGenerator('prefixInterceptors', 'array', []),
35 |                 new ParameterGenerator('suffixInterceptors', 'array', []),
36 |             ],
37 |             self::FLAG_PRIVATE,
38 |             null,
39 |             "@override constructor to setup interceptors\n\n"
40 |             . '@param \\' . $originalClass->getName() . " \$localizedObject\n"
41 |             . "@param \\Closure[] \$prefixInterceptors method interceptors to be used before method logic\n"
42 |             . '@param \\Closure[] $suffixInterceptors method interceptors to be used before method logic'
43 |         );
44 | 
45 |         $localizedProperties        = [];
46 |         $properties                 = Properties::fromReflectionClass($originalClass);
47 |         $nonReferenceableProperties = $properties
48 |             ->onlyNonReferenceableProperties()
49 |             ->onlyInstanceProperties();
50 | 
51 |         if (! $nonReferenceableProperties->empty()) {
52 |             throw UnsupportedProxiedClassException::nonReferenceableLocalizedReflectionProperties(
53 |                 $originalClass,
54 |                 $nonReferenceableProperties
55 |             );
56 |         }
57 | 
58 |         foreach ($properties->getAccessibleProperties() as $property) {
59 |             $propertyName = $property->getName();
60 | 
61 |             $localizedProperties[] = '$this->' . $propertyName . ' = & $localizedObject->' . $propertyName . ';';
62 |         }
63 | 
64 |         foreach ($properties->getPrivateProperties() as $property) {
65 |             $propertyName = $property->getName();
66 | 
67 |             $localizedProperties[] = "\\Closure::bind(function () use (\$localizedObject) {\n    "
68 |                 . '$this->' . $propertyName . ' = & $localizedObject->' . $propertyName . ";\n"
69 |                 . '}, $this, ' . var_export($property->getDeclaringClass()->getName(), true)
70 |                 . ')->__invoke();';
71 |         }
72 | 
73 |         $this->setBody(
74 |             ($localizedProperties ? implode("\n\n", $localizedProperties) . "\n\n" : '')
75 |             . '$this->' . $prefixInterceptors->getName() . " = \$prefixInterceptors;\n"
76 |             . '$this->' . $suffixInterceptors->getName() . ' = $suffixInterceptors;'
77 |         );
78 |     }
79 | }
80 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/AccessInterceptorScopeLocalizer/MethodGenerator/InterceptedMethod.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\AccessInterceptorScopeLocalizer\MethodGenerator;
 6 | 
 7 | use Laminas\Code\Generator\Exception\InvalidArgumentException;
 8 | use Laminas\Code\Generator\PropertyGenerator;
 9 | use Laminas\Code\Reflection\MethodReflection;
10 | use ProxyManager\Generator\MethodGenerator;
11 | use ProxyManager\ProxyGenerator\AccessInterceptorScopeLocalizer\MethodGenerator\Util\InterceptorGenerator;
12 | 
13 | use function implode;
14 | 
15 | /**
16 |  * Method with additional pre- and post- interceptor logic in the body
17 |  */
18 | class InterceptedMethod extends MethodGenerator
19 | {
20 |     /**
21 |      * @throws InvalidArgumentException
22 |      */
23 |     public static function generateMethod(
24 |         MethodReflection $originalMethod,
25 |         PropertyGenerator $prefixInterceptors,
26 |         PropertyGenerator $suffixInterceptors
27 |     ): self {
28 |         $method          = static::fromReflectionWithoutBodyAndDocBlock($originalMethod);
29 |         $forwardedParams = [];
30 | 
31 |         foreach ($originalMethod->getParameters() as $parameter) {
32 |             $forwardedParams[] = ($parameter->isVariadic() ? '...' : '') . '$' . $parameter->getName();
33 |         }
34 | 
35 |         $method->setBody(InterceptorGenerator::createInterceptedMethodBody(
36 |             '$returnValue = parent::'
37 |             . $originalMethod->getName() . '(' . implode(', ', $forwardedParams) . ');',
38 |             $method,
39 |             $prefixInterceptors,
40 |             $suffixInterceptors,
41 |             $originalMethod
42 |         ));
43 | 
44 |         return $method;
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/AccessInterceptorScopeLocalizer/MethodGenerator/MagicClone.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\AccessInterceptorScopeLocalizer\MethodGenerator;
 6 | 
 7 | use Laminas\Code\Generator\PropertyGenerator;
 8 | use ProxyManager\Generator\MagicMethodGenerator;
 9 | use ProxyManager\ProxyGenerator\AccessInterceptorScopeLocalizer\MethodGenerator\Util\InterceptorGenerator;
10 | use ProxyManager\ProxyGenerator\Util\GetMethodIfExists;
11 | use ReflectionClass;
12 | 
13 | /**
14 |  * Magic `__clone` for lazy loading ghost objects
15 |  */
16 | class MagicClone extends MagicMethodGenerator
17 | {
18 |     /**
19 |      * Constructor
20 |      */
21 |     public function __construct(
22 |         ReflectionClass $originalClass,
23 |         PropertyGenerator $prefixInterceptors,
24 |         PropertyGenerator $suffixInterceptors
25 |     ) {
26 |         parent::__construct($originalClass, '__clone');
27 | 
28 |         $parent = GetMethodIfExists::get($originalClass, '__clone');
29 | 
30 |         $this->setBody(InterceptorGenerator::createInterceptedMethodBody(
31 |             $parent ? '$returnValue = parent::__clone();' : '$returnValue = null;',
32 |             $this,
33 |             $prefixInterceptors,
34 |             $suffixInterceptors,
35 |             $parent
36 |         ));
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/AccessInterceptorScopeLocalizer/MethodGenerator/MagicGet.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\AccessInterceptorScopeLocalizer\MethodGenerator;
 6 | 
 7 | use InvalidArgumentException;
 8 | use Laminas\Code\Generator\ParameterGenerator;
 9 | use Laminas\Code\Generator\PropertyGenerator;
10 | use ProxyManager\Generator\MagicMethodGenerator;
11 | use ProxyManager\ProxyGenerator\AccessInterceptorScopeLocalizer\MethodGenerator\Util\InterceptorGenerator;
12 | use ProxyManager\ProxyGenerator\Util\GetMethodIfExists;
13 | use ProxyManager\ProxyGenerator\Util\PublicScopeSimulator;
14 | use ReflectionClass;
15 | 
16 | /**
17 |  * Magic `__get` for lazy loading ghost objects
18 |  */
19 | class MagicGet extends MagicMethodGenerator
20 | {
21 |     /**
22 |      * @throws InvalidArgumentException
23 |      */
24 |     public function __construct(
25 |         ReflectionClass $originalClass,
26 |         PropertyGenerator $prefixInterceptors,
27 |         PropertyGenerator $suffixInterceptors
28 |     ) {
29 |         parent::__construct($originalClass, '__get', [new ParameterGenerator('name')]);
30 | 
31 |         $parent = GetMethodIfExists::get($originalClass, '__get');
32 | 
33 |         $callParent = '$returnValue = & parent::__get($name);';
34 | 
35 |         if (! $parent) {
36 |             $callParent = PublicScopeSimulator::getPublicAccessSimulationCode(
37 |                 PublicScopeSimulator::OPERATION_GET,
38 |                 'name',
39 |                 null,
40 |                 null,
41 |                 'returnValue',
42 |                 $originalClass
43 |             );
44 |         }
45 | 
46 |         $this->setBody(InterceptorGenerator::createInterceptedMethodBody(
47 |             $callParent,
48 |             $this,
49 |             $prefixInterceptors,
50 |             $suffixInterceptors,
51 |             $parent
52 |         ));
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/AccessInterceptorScopeLocalizer/MethodGenerator/MagicIsset.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\AccessInterceptorScopeLocalizer\MethodGenerator;
 6 | 
 7 | use InvalidArgumentException;
 8 | use Laminas\Code\Generator\ParameterGenerator;
 9 | use Laminas\Code\Generator\PropertyGenerator;
10 | use ProxyManager\Generator\MagicMethodGenerator;
11 | use ProxyManager\ProxyGenerator\AccessInterceptorScopeLocalizer\MethodGenerator\Util\InterceptorGenerator;
12 | use ProxyManager\ProxyGenerator\Util\GetMethodIfExists;
13 | use ProxyManager\ProxyGenerator\Util\PublicScopeSimulator;
14 | use ReflectionClass;
15 | 
16 | /**
17 |  * Magic `__isset` method for lazy loading ghost objects
18 |  */
19 | class MagicIsset extends MagicMethodGenerator
20 | {
21 |     /**
22 |      * @throws InvalidArgumentException
23 |      */
24 |     public function __construct(
25 |         ReflectionClass $originalClass,
26 |         PropertyGenerator $prefixInterceptors,
27 |         PropertyGenerator $suffixInterceptors
28 |     ) {
29 |         parent::__construct($originalClass, '__isset', [new ParameterGenerator('name')]);
30 | 
31 |         $parent = GetMethodIfExists::get($originalClass, '__isset');
32 | 
33 |         $callParent = '$returnValue = & parent::__isset($name);';
34 | 
35 |         if (! $parent) {
36 |             $callParent = PublicScopeSimulator::getPublicAccessSimulationCode(
37 |                 PublicScopeSimulator::OPERATION_ISSET,
38 |                 'name',
39 |                 null,
40 |                 null,
41 |                 'returnValue',
42 |                 $originalClass
43 |             );
44 |         }
45 | 
46 |         $this->setBody(InterceptorGenerator::createInterceptedMethodBody(
47 |             $callParent,
48 |             $this,
49 |             $prefixInterceptors,
50 |             $suffixInterceptors,
51 |             $parent
52 |         ));
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/AccessInterceptorScopeLocalizer/MethodGenerator/MagicSet.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\AccessInterceptorScopeLocalizer\MethodGenerator;
 6 | 
 7 | use InvalidArgumentException;
 8 | use Laminas\Code\Generator\ParameterGenerator;
 9 | use Laminas\Code\Generator\PropertyGenerator;
10 | use ProxyManager\Generator\MagicMethodGenerator;
11 | use ProxyManager\ProxyGenerator\AccessInterceptorScopeLocalizer\MethodGenerator\Util\InterceptorGenerator;
12 | use ProxyManager\ProxyGenerator\Util\GetMethodIfExists;
13 | use ProxyManager\ProxyGenerator\Util\PublicScopeSimulator;
14 | use ReflectionClass;
15 | 
16 | /**
17 |  * Magic `__set` for lazy loading ghost objects
18 |  */
19 | class MagicSet extends MagicMethodGenerator
20 | {
21 |     /**
22 |      * @throws InvalidArgumentException
23 |      */
24 |     public function __construct(
25 |         ReflectionClass $originalClass,
26 |         PropertyGenerator $prefixInterceptors,
27 |         PropertyGenerator $suffixInterceptors
28 |     ) {
29 |         parent::__construct(
30 |             $originalClass,
31 |             '__set',
32 |             [new ParameterGenerator('name'), new ParameterGenerator('value')]
33 |         );
34 | 
35 |         $parent = GetMethodIfExists::get($originalClass, '__set');
36 | 
37 |         $callParent = '$returnValue = & parent::__set($name, $value);';
38 | 
39 |         if (! $parent) {
40 |             $callParent = PublicScopeSimulator::getPublicAccessSimulationCode(
41 |                 PublicScopeSimulator::OPERATION_SET,
42 |                 'name',
43 |                 'value',
44 |                 null,
45 |                 'returnValue',
46 |                 $originalClass
47 |             );
48 |         }
49 | 
50 |         $this->setBody(InterceptorGenerator::createInterceptedMethodBody(
51 |             $callParent,
52 |             $this,
53 |             $prefixInterceptors,
54 |             $suffixInterceptors,
55 |             $parent
56 |         ));
57 |     }
58 | }
59 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/AccessInterceptorScopeLocalizer/MethodGenerator/MagicSleep.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\AccessInterceptorScopeLocalizer\MethodGenerator;
 6 | 
 7 | use Laminas\Code\Generator\PropertyGenerator;
 8 | use ProxyManager\Generator\MagicMethodGenerator;
 9 | use ProxyManager\ProxyGenerator\AccessInterceptorScopeLocalizer\MethodGenerator\Util\InterceptorGenerator;
10 | use ProxyManager\ProxyGenerator\Util\GetMethodIfExists;
11 | use ReflectionClass;
12 | 
13 | /**
14 |  * Magic `__sleep` for lazy loading ghost objects
15 |  */
16 | class MagicSleep extends MagicMethodGenerator
17 | {
18 |     /**
19 |      * Constructor
20 |      */
21 |     public function __construct(
22 |         ReflectionClass $originalClass,
23 |         PropertyGenerator $prefixInterceptors,
24 |         PropertyGenerator $suffixInterceptors
25 |     ) {
26 |         parent::__construct($originalClass, '__sleep');
27 | 
28 |         $parent = GetMethodIfExists::get($originalClass, '__sleep');
29 | 
30 |         $callParent = $parent ? '$returnValue = & parent::__sleep();' : '$returnValue = array_keys((array) $this);';
31 | 
32 |         $this->setBody(InterceptorGenerator::createInterceptedMethodBody(
33 |             $callParent,
34 |             $this,
35 |             $prefixInterceptors,
36 |             $suffixInterceptors,
37 |             $parent
38 |         ));
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/AccessInterceptorScopeLocalizer/MethodGenerator/MagicUnset.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\AccessInterceptorScopeLocalizer\MethodGenerator;
 6 | 
 7 | use InvalidArgumentException;
 8 | use Laminas\Code\Generator\ParameterGenerator;
 9 | use Laminas\Code\Generator\PropertyGenerator;
10 | use ProxyManager\Generator\MagicMethodGenerator;
11 | use ProxyManager\ProxyGenerator\AccessInterceptorScopeLocalizer\MethodGenerator\Util\InterceptorGenerator;
12 | use ProxyManager\ProxyGenerator\Util\GetMethodIfExists;
13 | use ProxyManager\ProxyGenerator\Util\PublicScopeSimulator;
14 | use ReflectionClass;
15 | 
16 | /**
17 |  * Magic `__unset` method for lazy loading ghost objects
18 |  */
19 | class MagicUnset extends MagicMethodGenerator
20 | {
21 |     /**
22 |      * @throws InvalidArgumentException
23 |      */
24 |     public function __construct(
25 |         ReflectionClass $originalClass,
26 |         PropertyGenerator $prefixInterceptors,
27 |         PropertyGenerator $suffixInterceptors
28 |     ) {
29 |         parent::__construct($originalClass, '__unset', [new ParameterGenerator('name')]);
30 | 
31 |         $parent = GetMethodIfExists::get($originalClass, '__unset');
32 | 
33 |         $callParent = '$returnValue = & parent::__unset($name);';
34 | 
35 |         if (! $parent) {
36 |             $callParent = PublicScopeSimulator::getPublicAccessSimulationCode(
37 |                 PublicScopeSimulator::OPERATION_UNSET,
38 |                 'name',
39 |                 null,
40 |                 null,
41 |                 'returnValue',
42 |                 $originalClass
43 |             );
44 |         }
45 | 
46 |         $this->setBody(InterceptorGenerator::createInterceptedMethodBody(
47 |             $callParent,
48 |             $this,
49 |             $prefixInterceptors,
50 |             $suffixInterceptors,
51 |             $parent
52 |         ));
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/AccessInterceptorScopeLocalizer/MethodGenerator/StaticProxyConstructor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\AccessInterceptorScopeLocalizer\MethodGenerator;
 6 | 
 7 | use Laminas\Code\Generator\Exception\InvalidArgumentException;
 8 | use Laminas\Code\Generator\ParameterGenerator;
 9 | use ProxyManager\Generator\MethodGenerator;
10 | use ReflectionClass;
11 | 
12 | /**
13 |  * The `staticProxyConstructor` implementation for an access interceptor scope localizer proxy
14 |  */
15 | class StaticProxyConstructor extends MethodGenerator
16 | {
17 |     /**
18 |      * Constructor
19 |      *
20 |      * @throws InvalidArgumentException
21 |      */
22 |     public function __construct(ReflectionClass $originalClass)
23 |     {
24 |         parent::__construct('staticProxyConstructor', [], self::FLAG_PUBLIC | self::FLAG_STATIC);
25 | 
26 |         $localizedObject = new ParameterGenerator('localizedObject');
27 |         $prefix          = new ParameterGenerator('prefixInterceptors');
28 |         $suffix          = new ParameterGenerator('suffixInterceptors');
29 | 
30 |         $localizedObject->setType($originalClass->getName());
31 |         $prefix->setDefaultValue([]);
32 |         $suffix->setDefaultValue([]);
33 |         $prefix->setType('array');
34 |         $suffix->setType('array');
35 | 
36 |         $this->setParameter($localizedObject);
37 |         $this->setParameter($prefix);
38 |         $this->setParameter($suffix);
39 |         $this->setReturnType($originalClass->getName());
40 | 
41 |         $this->setDocBlock(
42 |             "Constructor to setup interceptors\n\n"
43 |             . '@param \\' . $originalClass->getName() . " \$localizedObject\n"
44 |             . "@param \\Closure[] \$prefixInterceptors method interceptors to be used before method logic\n"
45 |             . "@param \\Closure[] \$suffixInterceptors method interceptors to be used before method logic\n\n"
46 |             . '@return self'
47 |         );
48 |         $this->setBody(
49 |             'static $reflection;' . "\n\n"
50 |             . '$reflection = $reflection ?? new \ReflectionClass(__CLASS__);' . "\n"
51 |             . '$instance   = $reflection->newInstanceWithoutConstructor();' . "\n\n"
52 |             . '$instance->bindProxyProperties($localizedObject, $prefixInterceptors, $suffixInterceptors);' . "\n\n"
53 |             . 'return $instance;'
54 |         );
55 |     }
56 | }
57 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/AccessInterceptorScopeLocalizer/MethodGenerator/Util/InterceptorGenerator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\AccessInterceptorScopeLocalizer\MethodGenerator\Util;
 6 | 
 7 | use Laminas\Code\Generator\ParameterGenerator;
 8 | use Laminas\Code\Generator\PropertyGenerator;
 9 | use ProxyManager\Generator\MethodGenerator;
10 | use ProxyManager\Generator\Util\ProxiedMethodReturnExpression;
11 | use ReflectionMethod;
12 | 
13 | use function array_keys;
14 | use function array_map;
15 | use function implode;
16 | use function str_replace;
17 | use function var_export;
18 | 
19 | /**
20 |  * Utility to create pre- and post- method interceptors around a given method body
21 |  *
22 |  * @private - this class is just here as a small utility for this component, don't use it in your own code
23 |  */
24 | class InterceptorGenerator
25 | {
26 |     private const TEMPLATE = <<<'PHP'
27 | if (isset($this->{{$prefixInterceptorsName}}[{{$name}}])) {
28 |     $returnEarly       = false;
29 |     $prefixReturnValue = $this->{{$prefixInterceptorsName}}[{{$name}}]->__invoke($this, $this, {{$name}}, {{$paramsString}}, $returnEarly);
30 | 
31 |     if ($returnEarly) {
32 |         {{$prefixEarlyReturnExpression}}
33 |     }
34 | }
35 | 
36 | {{$methodBody}}
37 | 
38 | if (isset($this->{{$suffixInterceptorsName}}[{{$name}}])) {
39 |     $returnEarly       = false;
40 |     $suffixReturnValue = $this->{{$suffixInterceptorsName}}[{{$name}}]->__invoke($this, $this, {{$name}}, {{$paramsString}}, $returnValue, $returnEarly);
41 | 
42 |     if ($returnEarly) {
43 |         {{$suffixEarlyReturnExpression}}
44 |     }
45 | }
46 | 
47 | {{$returnExpression}}
48 | PHP;
49 | 
50 |     /**
51 |      * @param string $methodBody the body of the previously generated code.
52 |      *                           It MUST assign the return value to a variable
53 |      *                           `$returnValue` instead of directly returning
54 |      */
55 |     public static function createInterceptedMethodBody(
56 |         string $methodBody,
57 |         MethodGenerator $method,
58 |         PropertyGenerator $prefixInterceptors,
59 |         PropertyGenerator $suffixInterceptors,
60 |         ?ReflectionMethod $originalMethod
61 |     ): string {
62 |         $replacements = [
63 |             '{{$name}}'                        => var_export($method->getName(), true),
64 |             '{{$prefixInterceptorsName}}'      => $prefixInterceptors->getName(),
65 |             '{{$prefixEarlyReturnExpression}}' => ProxiedMethodReturnExpression::generate('$prefixReturnValue', $originalMethod),
66 |             '{{$methodBody}}'                  => $methodBody,
67 |             '{{$suffixInterceptorsName}}'      => $suffixInterceptors->getName(),
68 |             '{{$suffixEarlyReturnExpression}}' => ProxiedMethodReturnExpression::generate('$suffixReturnValue', $originalMethod),
69 |             '{{$returnExpression}}'            => ProxiedMethodReturnExpression::generate('$returnValue', $originalMethod),
70 |             '{{$paramsString}}'                => 'array(' . implode(', ', array_map(
71 |                 static function (ParameterGenerator $parameter): string {
72 |                     return var_export($parameter->getName(), true) . ' => ' . ($parameter->getPassedByReference() ? '&$' : '$') . $parameter->getName();
73 |                 },
74 |                 $method->getParameters()
75 |             ))
76 |                 . ')',
77 |         ];
78 | 
79 |         return str_replace(
80 |             array_keys($replacements),
81 |             $replacements,
82 |             self::TEMPLATE
83 |         );
84 |     }
85 | }
86 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/AccessInterceptorValueHolder/MethodGenerator/InterceptedMethod.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\AccessInterceptorValueHolder\MethodGenerator;
 6 | 
 7 | use Laminas\Code\Generator\Exception\InvalidArgumentException;
 8 | use Laminas\Code\Generator\PropertyGenerator;
 9 | use Laminas\Code\Reflection\MethodReflection;
10 | use ProxyManager\Generator\MethodGenerator;
11 | use ProxyManager\ProxyGenerator\AccessInterceptorValueHolder\MethodGenerator\Util\InterceptorGenerator;
12 | 
13 | use function implode;
14 | 
15 | /**
16 |  * Method with additional pre- and post- interceptor logic in the body
17 |  */
18 | class InterceptedMethod extends MethodGenerator
19 | {
20 |     /**
21 |      * @throws InvalidArgumentException
22 |      */
23 |     public static function generateMethod(
24 |         MethodReflection $originalMethod,
25 |         PropertyGenerator $valueHolderProperty,
26 |         PropertyGenerator $prefixInterceptors,
27 |         PropertyGenerator $suffixInterceptors
28 |     ): self {
29 |         $method          = static::fromReflectionWithoutBodyAndDocBlock($originalMethod);
30 |         $forwardedParams = [];
31 | 
32 |         foreach ($originalMethod->getParameters() as $parameter) {
33 |             $forwardedParams[] = ($parameter->isVariadic() ? '...' : '') . '$' . $parameter->getName();
34 |         }
35 | 
36 |         $method->setBody(InterceptorGenerator::createInterceptedMethodBody(
37 |             '$returnValue = $this->' . $valueHolderProperty->getName() . '->'
38 |             . $originalMethod->getName() . '(' . implode(', ', $forwardedParams) . ');',
39 |             $method,
40 |             $valueHolderProperty,
41 |             $prefixInterceptors,
42 |             $suffixInterceptors,
43 |             $originalMethod
44 |         ));
45 | 
46 |         return $method;
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/AccessInterceptorValueHolder/MethodGenerator/MagicClone.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\AccessInterceptorValueHolder\MethodGenerator;
 6 | 
 7 | use Laminas\Code\Generator\PropertyGenerator;
 8 | use ProxyManager\Generator\MagicMethodGenerator;
 9 | use ReflectionClass;
10 | 
11 | use function array_keys;
12 | use function str_replace;
13 | 
14 | /**
15 |  * Magic `__clone` for lazy loading value holder objects
16 |  */
17 | class MagicClone extends MagicMethodGenerator
18 | {
19 |     private const TEMPLATE = <<<'PHP'
20 | $this->{{$valueHolder}} = clone $this->{{$valueHolder}};
21 | 
22 | foreach ($this->{{$prefix}} as $key => $value) {
23 |     $this->{{$prefix}}[$key] = clone $value;
24 | }
25 | 
26 | foreach ($this->{{$suffix}} as $key => $value) {
27 |     $this->{{$suffix}}[$key] = clone $value;
28 | }
29 | PHP;
30 | 
31 |     /**
32 |      * Constructor
33 |      */
34 |     public function __construct(
35 |         ReflectionClass $originalClass,
36 |         PropertyGenerator $valueHolderProperty,
37 |         PropertyGenerator $prefixInterceptors,
38 |         PropertyGenerator $suffixInterceptors
39 |     ) {
40 |         parent::__construct($originalClass, '__clone');
41 | 
42 |         $valueHolder = $valueHolderProperty->getName();
43 |         $prefix      = $prefixInterceptors->getName();
44 |         $suffix      = $suffixInterceptors->getName();
45 | 
46 |         $replacements = [
47 |             '{{$valueHolder}}' => $valueHolder,
48 |             '{{$prefix}}' => $prefix,
49 |             '{{$suffix}}' => $suffix,
50 |         ];
51 | 
52 |         $this->setBody(str_replace(
53 |             array_keys($replacements),
54 |             $replacements,
55 |             self::TEMPLATE
56 |         ));
57 |     }
58 | }
59 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/AccessInterceptorValueHolder/MethodGenerator/MagicGet.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\AccessInterceptorValueHolder\MethodGenerator;
 6 | 
 7 | use InvalidArgumentException;
 8 | use Laminas\Code\Generator\ParameterGenerator;
 9 | use Laminas\Code\Generator\PropertyGenerator;
10 | use ProxyManager\Generator\MagicMethodGenerator;
11 | use ProxyManager\ProxyGenerator\AccessInterceptorValueHolder\MethodGenerator\Util\InterceptorGenerator;
12 | use ProxyManager\ProxyGenerator\PropertyGenerator\PublicPropertiesMap;
13 | use ProxyManager\ProxyGenerator\Util\GetMethodIfExists;
14 | use ProxyManager\ProxyGenerator\Util\PublicScopeSimulator;
15 | use ReflectionClass;
16 | 
17 | /**
18 |  * Magic `__get` for method interceptor value holder objects
19 |  */
20 | class MagicGet extends MagicMethodGenerator
21 | {
22 |     /**
23 |      * Constructor
24 |      *
25 |      * @throws InvalidArgumentException
26 |      */
27 |     public function __construct(
28 |         ReflectionClass $originalClass,
29 |         PropertyGenerator $valueHolder,
30 |         PropertyGenerator $prefixInterceptors,
31 |         PropertyGenerator $suffixInterceptors,
32 |         PublicPropertiesMap $publicProperties
33 |     ) {
34 |         parent::__construct($originalClass, '__get', [new ParameterGenerator('name')]);
35 | 
36 |         $parent          = GetMethodIfExists::get($originalClass, '__get');
37 |         $valueHolderName = $valueHolder->getName();
38 | 
39 |         $callParent = PublicScopeSimulator::getPublicAccessSimulationCode(
40 |             PublicScopeSimulator::OPERATION_GET,
41 |             'name',
42 |             null,
43 |             $valueHolder,
44 |             'returnValue',
45 |             $originalClass
46 |         );
47 | 
48 |         if (! $publicProperties->isEmpty()) {
49 |             $callParent = 'if (isset(self::$' . $publicProperties->getName() . "[\$name])) {\n"
50 |                 . '    $returnValue = & $this->' . $valueHolderName . '->$name;'
51 |                 . "\n} else {\n    " . $callParent . "\n}\n\n";
52 |         }
53 | 
54 |         $this->setBody(InterceptorGenerator::createInterceptedMethodBody(
55 |             $callParent,
56 |             $this,
57 |             $valueHolder,
58 |             $prefixInterceptors,
59 |             $suffixInterceptors,
60 |             $parent
61 |         ));
62 |     }
63 | }
64 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/AccessInterceptorValueHolder/MethodGenerator/MagicIsset.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\AccessInterceptorValueHolder\MethodGenerator;
 6 | 
 7 | use InvalidArgumentException;
 8 | use Laminas\Code\Generator\ParameterGenerator;
 9 | use Laminas\Code\Generator\PropertyGenerator;
10 | use ProxyManager\Generator\MagicMethodGenerator;
11 | use ProxyManager\ProxyGenerator\AccessInterceptorValueHolder\MethodGenerator\Util\InterceptorGenerator;
12 | use ProxyManager\ProxyGenerator\PropertyGenerator\PublicPropertiesMap;
13 | use ProxyManager\ProxyGenerator\Util\GetMethodIfExists;
14 | use ProxyManager\ProxyGenerator\Util\PublicScopeSimulator;
15 | use ReflectionClass;
16 | 
17 | /**
18 |  * Magic `__isset` for method interceptor value holder objects
19 |  */
20 | class MagicIsset extends MagicMethodGenerator
21 | {
22 |     /**
23 |      * Constructor
24 |      *
25 |      * @throws InvalidArgumentException
26 |      */
27 |     public function __construct(
28 |         ReflectionClass $originalClass,
29 |         PropertyGenerator $valueHolder,
30 |         PropertyGenerator $prefixInterceptors,
31 |         PropertyGenerator $suffixInterceptors,
32 |         PublicPropertiesMap $publicProperties
33 |     ) {
34 |         parent::__construct($originalClass, '__isset', [new ParameterGenerator('name')]);
35 | 
36 |         $parent          = GetMethodIfExists::get($originalClass, '__isset');
37 |         $valueHolderName = $valueHolder->getName();
38 | 
39 |         $callParent = PublicScopeSimulator::getPublicAccessSimulationCode(
40 |             PublicScopeSimulator::OPERATION_ISSET,
41 |             'name',
42 |             null,
43 |             $valueHolder,
44 |             'returnValue',
45 |             $originalClass
46 |         );
47 | 
48 |         if (! $publicProperties->isEmpty()) {
49 |             $callParent = 'if (isset(self::$' . $publicProperties->getName() . "[\$name])) {\n"
50 |                 . '    $returnValue = isset($this->' . $valueHolderName . '->$name);'
51 |                 . "\n} else {\n    " . $callParent . "\n}\n\n";
52 |         }
53 | 
54 |         $this->setBody(InterceptorGenerator::createInterceptedMethodBody(
55 |             $callParent,
56 |             $this,
57 |             $valueHolder,
58 |             $prefixInterceptors,
59 |             $suffixInterceptors,
60 |             $parent
61 |         ));
62 |     }
63 | }
64 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/AccessInterceptorValueHolder/MethodGenerator/MagicSet.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\AccessInterceptorValueHolder\MethodGenerator;
 6 | 
 7 | use InvalidArgumentException;
 8 | use Laminas\Code\Generator\ParameterGenerator;
 9 | use Laminas\Code\Generator\PropertyGenerator;
10 | use ProxyManager\Generator\MagicMethodGenerator;
11 | use ProxyManager\ProxyGenerator\AccessInterceptorValueHolder\MethodGenerator\Util\InterceptorGenerator;
12 | use ProxyManager\ProxyGenerator\PropertyGenerator\PublicPropertiesMap;
13 | use ProxyManager\ProxyGenerator\Util\GetMethodIfExists;
14 | use ProxyManager\ProxyGenerator\Util\PublicScopeSimulator;
15 | use ReflectionClass;
16 | 
17 | /**
18 |  * Magic `__set` for method interceptor value holder objects
19 |  */
20 | class MagicSet extends MagicMethodGenerator
21 | {
22 |     /**
23 |      * Constructor
24 |      *
25 |      * @throws InvalidArgumentException
26 |      */
27 |     public function __construct(
28 |         ReflectionClass $originalClass,
29 |         PropertyGenerator $valueHolder,
30 |         PropertyGenerator $prefixInterceptors,
31 |         PropertyGenerator $suffixInterceptors,
32 |         PublicPropertiesMap $publicProperties
33 |     ) {
34 |         parent::__construct(
35 |             $originalClass,
36 |             '__set',
37 |             [new ParameterGenerator('name'), new ParameterGenerator('value')]
38 |         );
39 | 
40 |         $parent          = GetMethodIfExists::get($originalClass, '__set');
41 |         $valueHolderName = $valueHolder->getName();
42 | 
43 |         $callParent = PublicScopeSimulator::getPublicAccessSimulationCode(
44 |             PublicScopeSimulator::OPERATION_SET,
45 |             'name',
46 |             'value',
47 |             $valueHolder,
48 |             'returnValue',
49 |             $originalClass
50 |         );
51 | 
52 |         if (! $publicProperties->isEmpty()) {
53 |             $callParent = 'if (isset(self::$' . $publicProperties->getName() . "[\$name])) {\n"
54 |                 . '    $returnValue = ($this->' . $valueHolderName . '->$name = $value);'
55 |                 . "\n} else {\n    " . $callParent . "\n}\n\n";
56 |         }
57 | 
58 |         $this->setBody(InterceptorGenerator::createInterceptedMethodBody(
59 |             $callParent,
60 |             $this,
61 |             $valueHolder,
62 |             $prefixInterceptors,
63 |             $suffixInterceptors,
64 |             $parent
65 |         ));
66 |     }
67 | }
68 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/AccessInterceptorValueHolder/MethodGenerator/MagicUnset.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\AccessInterceptorValueHolder\MethodGenerator;
 6 | 
 7 | use InvalidArgumentException;
 8 | use Laminas\Code\Generator\ParameterGenerator;
 9 | use Laminas\Code\Generator\PropertyGenerator;
10 | use ProxyManager\Generator\MagicMethodGenerator;
11 | use ProxyManager\ProxyGenerator\AccessInterceptorValueHolder\MethodGenerator\Util\InterceptorGenerator;
12 | use ProxyManager\ProxyGenerator\PropertyGenerator\PublicPropertiesMap;
13 | use ProxyManager\ProxyGenerator\Util\GetMethodIfExists;
14 | use ProxyManager\ProxyGenerator\Util\PublicScopeSimulator;
15 | use ReflectionClass;
16 | 
17 | /**
18 |  * Magic `__unset` for method interceptor value holder objects
19 |  */
20 | class MagicUnset extends MagicMethodGenerator
21 | {
22 |     /**
23 |      * Constructor
24 |      *
25 |      * @throws InvalidArgumentException
26 |      */
27 |     public function __construct(
28 |         ReflectionClass $originalClass,
29 |         PropertyGenerator $valueHolder,
30 |         PropertyGenerator $prefixInterceptors,
31 |         PropertyGenerator $suffixInterceptors,
32 |         PublicPropertiesMap $publicProperties
33 |     ) {
34 |         parent::__construct($originalClass, '__unset', [new ParameterGenerator('name')]);
35 | 
36 |         $parent          = GetMethodIfExists::get($originalClass, '__unset');
37 |         $valueHolderName = $valueHolder->getName();
38 | 
39 |         $callParent = PublicScopeSimulator::getPublicAccessSimulationCode(
40 |             PublicScopeSimulator::OPERATION_UNSET,
41 |             'name',
42 |             null,
43 |             $valueHolder,
44 |             'returnValue',
45 |             $originalClass
46 |         );
47 | 
48 |         if (! $publicProperties->isEmpty()) {
49 |             $callParent = 'if (isset(self::$' . $publicProperties->getName() . "[\$name])) {\n"
50 |                 . '    unset($this->' . $valueHolderName . '->$name);'
51 |                 . "\n} else {\n    " . $callParent . "\n}\n\n";
52 |         }
53 | 
54 |         $callParent .= '$returnValue = false;';
55 | 
56 |         $this->setBody(InterceptorGenerator::createInterceptedMethodBody(
57 |             $callParent,
58 |             $this,
59 |             $valueHolder,
60 |             $prefixInterceptors,
61 |             $suffixInterceptors,
62 |             $parent
63 |         ));
64 |     }
65 | }
66 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/AccessInterceptorValueHolder/MethodGenerator/StaticProxyConstructor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\AccessInterceptorValueHolder\MethodGenerator;
 6 | 
 7 | use Laminas\Code\Generator\Exception\InvalidArgumentException;
 8 | use Laminas\Code\Generator\ParameterGenerator;
 9 | use Laminas\Code\Generator\PropertyGenerator;
10 | use ProxyManager\Generator\MethodGenerator;
11 | use ProxyManager\ProxyGenerator\Util\Properties;
12 | use ProxyManager\ProxyGenerator\Util\UnsetPropertiesGenerator;
13 | use ReflectionClass;
14 | 
15 | /**
16 |  * The `staticProxyConstructor` implementation for access interceptor value holders
17 |  */
18 | class StaticProxyConstructor extends MethodGenerator
19 | {
20 |     /**
21 |      * Constructor
22 |      *
23 |      * @throws InvalidArgumentException
24 |      */
25 |     public function __construct(
26 |         ReflectionClass $originalClass,
27 |         PropertyGenerator $valueHolder,
28 |         PropertyGenerator $prefixInterceptors,
29 |         PropertyGenerator $suffixInterceptors
30 |     ) {
31 |         parent::__construct('staticProxyConstructor', [], self::FLAG_PUBLIC | self::FLAG_STATIC);
32 | 
33 |         $prefix = new ParameterGenerator('prefixInterceptors');
34 |         $suffix = new ParameterGenerator('suffixInterceptors');
35 | 
36 |         $prefix->setDefaultValue([]);
37 |         $suffix->setDefaultValue([]);
38 |         $prefix->setType('array');
39 |         $suffix->setType('array');
40 | 
41 |         $this->setParameter(new ParameterGenerator('wrappedObject'));
42 |         $this->setParameter($prefix);
43 |         $this->setParameter($suffix);
44 |         $this->setReturnType($originalClass->getName());
45 | 
46 |         $this->setDocBlock(
47 |             "Constructor to setup interceptors\n\n"
48 |             . '@param \\' . $originalClass->getName() . " \$wrappedObject\n"
49 |             . "@param \\Closure[] \$prefixInterceptors method interceptors to be used before method logic\n"
50 |             . "@param \\Closure[] \$suffixInterceptors method interceptors to be used before method logic\n\n"
51 |             . '@return self'
52 |         );
53 | 
54 |         $this->setBody(
55 |             'static $reflection;' . "\n\n"
56 |             . '$reflection = $reflection ?? new \ReflectionClass(__CLASS__);' . "\n"
57 |             . '$instance   = $reflection->newInstanceWithoutConstructor();' . "\n\n"
58 |             . UnsetPropertiesGenerator::generateSnippet(Properties::fromReflectionClass($originalClass), 'instance')
59 |             . '$instance->' . $valueHolder->getName() . " = \$wrappedObject;\n"
60 |             . '$instance->' . $prefixInterceptors->getName() . " = \$prefixInterceptors;\n"
61 |             . '$instance->' . $suffixInterceptors->getName() . " = \$suffixInterceptors;\n\n"
62 |             . 'return $instance;'
63 |         );
64 |     }
65 | }
66 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/AccessInterceptorValueHolder/MethodGenerator/Util/InterceptorGenerator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\AccessInterceptorValueHolder\MethodGenerator\Util;
 6 | 
 7 | use Laminas\Code\Generator\PropertyGenerator;
 8 | use ProxyManager\Generator\MethodGenerator;
 9 | use ProxyManager\Generator\Util\ProxiedMethodReturnExpression;
10 | use ReflectionMethod;
11 | 
12 | use function array_keys;
13 | use function implode;
14 | use function str_replace;
15 | use function var_export;
16 | 
17 | /**
18 |  * Utility to create pre- and post- method interceptors around a given method body
19 |  *
20 |  * @private - this class is just here as a small utility for this component, don't use it in your own code
21 |  */
22 | class InterceptorGenerator
23 | {
24 |     private const TEMPLATE = <<<'PHP'
25 | if (isset($this->{{$prefixInterceptorsName}}[{{$name}}])) {
26 |     $returnEarly       = false;
27 |     $prefixReturnValue = $this->{{$prefixInterceptorsName}}[{{$name}}]->__invoke($this, $this->{{$valueHolderName}}, {{$name}}, {{$paramsString}}, $returnEarly);
28 | 
29 |     if ($returnEarly) {
30 |         {{$returnEarlyPrefixExpression}}
31 |     }
32 | }
33 | 
34 | {{$methodBody}}
35 | 
36 | if (isset($this->{{$suffixInterceptorsName}}[{{$name}}])) {
37 |     $returnEarly       = false;
38 |     $suffixReturnValue = $this->{{$suffixInterceptorsName}}[{{$name}}]->__invoke($this, $this->{{$valueHolderName}}, {{$name}}, {{$paramsString}}, $returnValue, $returnEarly);
39 | 
40 |     if ($returnEarly) {
41 |         {{$returnEarlySuffixExpression}}
42 |     }
43 | }
44 | 
45 | {{$returnExpression}}
46 | PHP;
47 | 
48 |     /**
49 |      * @param string $methodBody the body of the previously generated code.
50 |      *                           It MUST assign the return value to a variable
51 |      *                           `$returnValue` instead of directly returning
52 |      */
53 |     public static function createInterceptedMethodBody(
54 |         string $methodBody,
55 |         MethodGenerator $method,
56 |         PropertyGenerator $valueHolder,
57 |         PropertyGenerator $prefixInterceptors,
58 |         PropertyGenerator $suffixInterceptors,
59 |         ?ReflectionMethod $originalMethod
60 |     ): string {
61 |         $name                   = var_export($method->getName(), true);
62 |         $valueHolderName        = $valueHolder->getName();
63 |         $prefixInterceptorsName = $prefixInterceptors->getName();
64 |         $suffixInterceptorsName = $suffixInterceptors->getName();
65 |         $params                 = [];
66 | 
67 |         foreach ($method->getParameters() as $parameter) {
68 |             $parameterName = $parameter->getName();
69 |             $symbol        = $parameter->getPassedByReference() ? '&$' : '$';
70 |             $params[]      = var_export($parameterName, true) . ' => ' . $symbol . $parameterName;
71 |         }
72 | 
73 |         $paramsString = 'array(' . implode(', ', $params) . ')';
74 | 
75 |         $replacements = [
76 |             '{{$prefixInterceptorsName}}' => $prefixInterceptorsName,
77 |             '{{$name}}' => $name,
78 |             '{{$valueHolderName}}' => $valueHolderName,
79 |             '{{$paramsString}}' => $paramsString,
80 |             '{{$returnEarlyPrefixExpression}}' => ProxiedMethodReturnExpression::generate('$prefixReturnValue', $originalMethod),
81 |             '{{$methodBody}}' => $methodBody,
82 |             '{{$suffixInterceptorsName}}' => $suffixInterceptorsName,
83 |             '{{$returnEarlySuffixExpression}}' => ProxiedMethodReturnExpression::generate('$suffixReturnValue', $originalMethod),
84 |             '{{$returnExpression}}' => ProxiedMethodReturnExpression::generate('$returnValue', $originalMethod),
85 | 
86 |         ];
87 | 
88 |         return str_replace(array_keys($replacements), $replacements, self::TEMPLATE);
89 |     }
90 | }
91 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/Assertion/CanProxyAssertion.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\Assertion;
 6 | 
 7 | use BadMethodCallException;
 8 | use ProxyManager\Exception\InvalidProxiedClassException;
 9 | use ReflectionClass;
10 | use ReflectionMethod;
11 | 
12 | use function array_filter;
13 | 
14 | /**
15 |  * Assertion that verifies that a class can be proxied
16 |  */
17 | final class CanProxyAssertion
18 | {
19 |     /**
20 |      * Disabled constructor: not meant to be instantiated
21 |      *
22 |      * @throws BadMethodCallException
23 |      */
24 |     public function __construct()
25 |     {
26 |         throw new BadMethodCallException('Unsupported constructor.');
27 |     }
28 | 
29 |     /**
30 |      * @throws InvalidProxiedClassException
31 |      */
32 |     public static function assertClassCanBeProxied(ReflectionClass $originalClass, bool $allowInterfaces = true): void
33 |     {
34 |         self::isNotFinal($originalClass);
35 |         self::hasNoAbstractProtectedMethods($originalClass);
36 | 
37 |         if ($allowInterfaces) {
38 |             return;
39 |         }
40 | 
41 |         self::isNotInterface($originalClass);
42 |     }
43 | 
44 |     /**
45 |      * @throws InvalidProxiedClassException
46 |      */
47 |     private static function isNotFinal(ReflectionClass $originalClass): void
48 |     {
49 |         if ($originalClass->isFinal()) {
50 |             throw InvalidProxiedClassException::finalClassNotSupported($originalClass);
51 |         }
52 |     }
53 | 
54 |     /**
55 |      * @throws InvalidProxiedClassException
56 |      */
57 |     private static function hasNoAbstractProtectedMethods(ReflectionClass $originalClass): void
58 |     {
59 |         $protectedAbstract = array_filter(
60 |             $originalClass->getMethods(),
61 |             static function (ReflectionMethod $method): bool {
62 |                 return $method->isAbstract() && $method->isProtected();
63 |             }
64 |         );
65 | 
66 |         if ($protectedAbstract) {
67 |             throw InvalidProxiedClassException::abstractProtectedMethodsNotSupported($originalClass);
68 |         }
69 |     }
70 | 
71 |     /**
72 |      * @throws InvalidProxiedClassException
73 |      */
74 |     private static function isNotInterface(ReflectionClass $originalClass): void
75 |     {
76 |         if ($originalClass->isInterface()) {
77 |             throw InvalidProxiedClassException::interfaceNotSupported($originalClass);
78 |         }
79 |     }
80 | }
81 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/LazyLoading/MethodGenerator/StaticProxyConstructor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\LazyLoading\MethodGenerator;
 6 | 
 7 | use Laminas\Code\Generator\Exception\InvalidArgumentException;
 8 | use Laminas\Code\Generator\ParameterGenerator;
 9 | use Laminas\Code\Generator\PropertyGenerator;
10 | use ProxyManager\Generator\MethodGenerator;
11 | use ProxyManager\ProxyGenerator\Util\Properties;
12 | use ProxyManager\ProxyGenerator\Util\UnsetPropertiesGenerator;
13 | 
14 | /**
15 |  * The `staticProxyConstructor` implementation for lazy loading proxies
16 |  */
17 | class StaticProxyConstructor extends MethodGenerator
18 | {
19 |     /**
20 |      * Static constructor
21 |      *
22 |      * @throws InvalidArgumentException
23 |      */
24 |     public function __construct(PropertyGenerator $initializerProperty, Properties $properties)
25 |     {
26 |         parent::__construct('staticProxyConstructor', [], self::FLAG_PUBLIC | self::FLAG_STATIC);
27 | 
28 |         $this->setParameter(new ParameterGenerator('initializer'));
29 | 
30 |         $this->setDocBlock("Constructor for lazy initialization\n\n@param \\Closure|null \$initializer");
31 |         $this->setBody(
32 |             'static $reflection;' . "\n\n"
33 |             . '$reflection = $reflection ?? new \ReflectionClass(__CLASS__);' . "\n"
34 |             . '$instance   = $reflection->newInstanceWithoutConstructor();' . "\n\n"
35 |             . UnsetPropertiesGenerator::generateSnippet($properties, 'instance')
36 |             . '$instance->' . $initializerProperty->getName() . ' = $initializer;' . "\n\n"
37 |             . 'return $instance;'
38 |         );
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/LazyLoadingGhost/MethodGenerator/GetProxyInitializer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\LazyLoadingGhost\MethodGenerator;
 6 | 
 7 | use Laminas\Code\Generator\Exception\InvalidArgumentException;
 8 | use Laminas\Code\Generator\PropertyGenerator;
 9 | use ProxyManager\Generator\MethodGenerator;
10 | 
11 | /**
12 |  * Implementation for {@see \ProxyManager\Proxy\LazyLoadingInterface::getProxyInitializer}
13 |  * for lazy loading value holder objects
14 |  */
15 | class GetProxyInitializer extends MethodGenerator
16 | {
17 |     /**
18 |      * Constructor
19 |      *
20 |      * @throws InvalidArgumentException
21 |      */
22 |     public function __construct(PropertyGenerator $initializerProperty)
23 |     {
24 |         parent::__construct('getProxyInitializer');
25 |         $this->setReturnType('?\\Closure');
26 |         $this->setBody('return $this->' . $initializerProperty->getName() . ';');
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/LazyLoadingGhost/MethodGenerator/InitializeProxy.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\LazyLoadingGhost\MethodGenerator;
 6 | 
 7 | use Laminas\Code\Generator\Exception\InvalidArgumentException;
 8 | use Laminas\Code\Generator\MethodGenerator as LaminasMethodGenerator;
 9 | use Laminas\Code\Generator\PropertyGenerator;
10 | use ProxyManager\Generator\MethodGenerator;
11 | 
12 | /**
13 |  * Implementation for {@see \ProxyManager\Proxy\LazyLoadingInterface::initializeProxy}
14 |  * for lazy loading ghost objects
15 |  */
16 | class InitializeProxy extends MethodGenerator
17 | {
18 |     /**
19 |      * Constructor
20 |      *
21 |      * @throws InvalidArgumentException
22 |      */
23 |     public function __construct(PropertyGenerator $initializerProperty, LaminasMethodGenerator $callInitializer)
24 |     {
25 |         parent::__construct('initializeProxy');
26 |         $this->setReturnType('bool');
27 | 
28 |         $this->setBody(
29 |             'return $this->' . $initializerProperty->getName() . ' && $this->' . $callInitializer->getName()
30 |             . '(\'initializeProxy\', []);'
31 |         );
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/LazyLoadingGhost/MethodGenerator/IsProxyInitialized.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\LazyLoadingGhost\MethodGenerator;
 6 | 
 7 | use Laminas\Code\Generator\Exception\InvalidArgumentException;
 8 | use Laminas\Code\Generator\PropertyGenerator;
 9 | use ProxyManager\Generator\MethodGenerator;
10 | 
11 | /**
12 |  * Implementation for {@see \ProxyManager\Proxy\LazyLoadingInterface::isProxyInitialized}
13 |  * for lazy loading value holder objects
14 |  */
15 | class IsProxyInitialized extends MethodGenerator
16 | {
17 |     /**
18 |      * Constructor
19 |      *
20 |      * @throws InvalidArgumentException
21 |      */
22 |     public function __construct(PropertyGenerator $initializerProperty)
23 |     {
24 |         parent::__construct('isProxyInitialized');
25 |         $this->setReturnType('bool');
26 |         $this->setBody('return ! $this->' . $initializerProperty->getName() . ';');
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/LazyLoadingGhost/MethodGenerator/MagicClone.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\LazyLoadingGhost\MethodGenerator;
 6 | 
 7 | use Laminas\Code\Generator\MethodGenerator;
 8 | use Laminas\Code\Generator\PropertyGenerator;
 9 | use ProxyManager\Generator\MagicMethodGenerator;
10 | use ReflectionClass;
11 | 
12 | /**
13 |  * Magic `__clone` for lazy loading ghost objects
14 |  */
15 | class MagicClone extends MagicMethodGenerator
16 | {
17 |     /**
18 |      * Constructor
19 |      */
20 |     public function __construct(
21 |         ReflectionClass $originalClass,
22 |         PropertyGenerator $initializerProperty,
23 |         MethodGenerator $callInitializer
24 |     ) {
25 |         parent::__construct($originalClass, '__clone');
26 | 
27 |         $this->setBody(
28 |             '$this->' . $initializerProperty->getName() . ' && $this->' . $callInitializer->getName()
29 |             . '(\'__clone\', []);'
30 |             . ($originalClass->hasMethod('__clone') ? "\n\nparent::__clone();" : '')
31 |         );
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/LazyLoadingGhost/MethodGenerator/MagicIsset.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace ProxyManager\ProxyGenerator\LazyLoadingGhost\MethodGenerator;
  6 | 
  7 | use InvalidArgumentException;
  8 | use Laminas\Code\Generator\MethodGenerator;
  9 | use Laminas\Code\Generator\ParameterGenerator;
 10 | use Laminas\Code\Generator\PropertyGenerator;
 11 | use ProxyManager\Generator\MagicMethodGenerator;
 12 | use ProxyManager\ProxyGenerator\LazyLoadingGhost\PropertyGenerator\PrivatePropertiesMap;
 13 | use ProxyManager\ProxyGenerator\LazyLoadingGhost\PropertyGenerator\ProtectedPropertiesMap;
 14 | use ProxyManager\ProxyGenerator\PropertyGenerator\PublicPropertiesMap;
 15 | use ProxyManager\ProxyGenerator\Util\PublicScopeSimulator;
 16 | use ReflectionClass;
 17 | 
 18 | use function sprintf;
 19 | 
 20 | /**
 21 |  * Magic `__isset` method for lazy loading ghost objects
 22 |  */
 23 | class MagicIsset extends MagicMethodGenerator
 24 | {
 25 |     private $callParentTemplate = <<<'PHP'
 26 | %s
 27 | 
 28 | if (isset(self::$%s[$name])) {
 29 |     return isset($this->$name);
 30 | }
 31 | 
 32 | if (isset(self::$%s[$name])) {
 33 |     // check protected property access via compatible class
 34 |     $callers      = debug_backtrace(\DEBUG_BACKTRACE_PROVIDE_OBJECT, 2);
 35 |     $caller       = isset($callers[1]) ? $callers[1] : [];
 36 |     $object       = isset($caller['object']) ? $caller['object'] : '';
 37 |     $expectedType = self::$%s[$name];
 38 | 
 39 |     if ($object instanceof $expectedType) {
 40 |         return isset($this->$name);
 41 |     }
 42 | 
 43 |     $class = isset($caller['class']) ? $caller['class'] : '';
 44 | 
 45 |     if ($class === $expectedType || is_subclass_of($class, $expectedType)) {
 46 |         return isset($this->$name);
 47 |     }
 48 | } else {
 49 |     // check private property access via same class
 50 |     $callers = debug_backtrace(\DEBUG_BACKTRACE_PROVIDE_OBJECT, 2);
 51 |     $caller  = isset($callers[1]) ? $callers[1] : [];
 52 |     $class   = isset($caller['class']) ? $caller['class'] : '';
 53 | 
 54 |     static $accessorCache = [];
 55 | 
 56 |     if (isset(self::$%s[$name][$class])) {
 57 |         $cacheKey = $class . '#' . $name;
 58 |         $accessor = isset($accessorCache[$cacheKey])
 59 |             ? $accessorCache[$cacheKey]
 60 |             : $accessorCache[$cacheKey] = \Closure::bind(static function ($instance) use ($name) {
 61 |                 return isset($instance->$name);
 62 |             }, null, $class);
 63 | 
 64 |         return $accessor($this);
 65 |     }
 66 | 
 67 |     if ('ReflectionProperty' === $class) {
 68 |         $tmpClass = key(self::$%s[$name]);
 69 |         $cacheKey = $tmpClass . '#' . $name;
 70 |         $accessor = isset($accessorCache[$cacheKey])
 71 |             ? $accessorCache[$cacheKey]
 72 |             : $accessorCache[$cacheKey] = \Closure::bind(static function ($instance) use ($name) {
 73 |                 return isset($instance->$name);
 74 |             }, null, $tmpClass);
 75 | 
 76 |         return $accessor($this);
 77 |     }
 78 | }
 79 | 
 80 | %s
 81 | PHP;
 82 | 
 83 |     /**
 84 |      * @throws InvalidArgumentException
 85 |      */
 86 |     public function __construct(
 87 |         ReflectionClass $originalClass,
 88 |         PropertyGenerator $initializerProperty,
 89 |         MethodGenerator $callInitializer,
 90 |         PublicPropertiesMap $publicProperties,
 91 |         ProtectedPropertiesMap $protectedProperties,
 92 |         PrivatePropertiesMap $privateProperties
 93 |     ) {
 94 |         parent::__construct($originalClass, '__isset', [new ParameterGenerator('name')]);
 95 | 
 96 |         $override = $originalClass->hasMethod('__isset');
 97 | 
 98 |         $parentAccess = 'return parent::__isset($name);';
 99 | 
100 |         if (! $override) {
101 |             $parentAccess = PublicScopeSimulator::getPublicAccessSimulationCode(
102 |                 PublicScopeSimulator::OPERATION_ISSET,
103 |                 'name'
104 |             );
105 |         }
106 | 
107 |         $this->setBody(sprintf(
108 |             $this->callParentTemplate,
109 |             '$this->' . $initializerProperty->getName() . ' && $this->' . $callInitializer->getName()
110 |             . '(\'__isset\', array(\'name\' => $name));',
111 |             $publicProperties->getName(),
112 |             $protectedProperties->getName(),
113 |             $protectedProperties->getName(),
114 |             $privateProperties->getName(),
115 |             $privateProperties->getName(),
116 |             $parentAccess
117 |         ));
118 |     }
119 | }
120 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/LazyLoadingGhost/MethodGenerator/MagicSleep.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\LazyLoadingGhost\MethodGenerator;
 6 | 
 7 | use Laminas\Code\Generator\MethodGenerator;
 8 | use Laminas\Code\Generator\PropertyGenerator;
 9 | use ProxyManager\Generator\MagicMethodGenerator;
10 | use ReflectionClass;
11 | 
12 | /**
13 |  * Magic `__sleep` for lazy loading ghost objects
14 |  */
15 | class MagicSleep extends MagicMethodGenerator
16 | {
17 |     /**
18 |      * Constructor
19 |      */
20 |     public function __construct(
21 |         ReflectionClass $originalClass,
22 |         PropertyGenerator $initializerProperty,
23 |         MethodGenerator $callInitializer
24 |     ) {
25 |         parent::__construct($originalClass, '__sleep');
26 | 
27 |         $this->setBody(
28 |             '$this->' . $initializerProperty->getName() . ' && $this->' . $callInitializer->getName()
29 |             . '(\'__sleep\', []);' . "\n\n"
30 |             . ($originalClass->hasMethod('__sleep') ? 'return parent::__sleep();' : 'return array_keys((array) $this);')
31 |         );
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/LazyLoadingGhost/MethodGenerator/MagicUnset.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace ProxyManager\ProxyGenerator\LazyLoadingGhost\MethodGenerator;
  6 | 
  7 | use InvalidArgumentException;
  8 | use Laminas\Code\Generator\MethodGenerator;
  9 | use Laminas\Code\Generator\ParameterGenerator;
 10 | use Laminas\Code\Generator\PropertyGenerator;
 11 | use ProxyManager\Generator\MagicMethodGenerator;
 12 | use ProxyManager\ProxyGenerator\LazyLoadingGhost\PropertyGenerator\PrivatePropertiesMap;
 13 | use ProxyManager\ProxyGenerator\LazyLoadingGhost\PropertyGenerator\ProtectedPropertiesMap;
 14 | use ProxyManager\ProxyGenerator\PropertyGenerator\PublicPropertiesMap;
 15 | use ProxyManager\ProxyGenerator\Util\PublicScopeSimulator;
 16 | use ReflectionClass;
 17 | 
 18 | use function sprintf;
 19 | 
 20 | /**
 21 |  * Magic `__unset` method for lazy loading ghost objects
 22 |  */
 23 | class MagicUnset extends MagicMethodGenerator
 24 | {
 25 |     private $callParentTemplate = <<<'PHP'
 26 | %s
 27 | 
 28 | if (isset(self::$%s[$name])) {
 29 |     unset($this->$name);
 30 | 
 31 |     return;
 32 | }
 33 | 
 34 | if (isset(self::$%s[$name])) {
 35 |     // check protected property access via compatible class
 36 |     $callers      = debug_backtrace(\DEBUG_BACKTRACE_PROVIDE_OBJECT, 2);
 37 |     $caller       = isset($callers[1]) ? $callers[1] : [];
 38 |     $object       = isset($caller['object']) ? $caller['object'] : '';
 39 |     $expectedType = self::$%s[$name];
 40 | 
 41 |     if ($object instanceof $expectedType) {
 42 |         unset($this->$name);
 43 | 
 44 |         return;
 45 |     }
 46 | 
 47 |     $class = isset($caller['class']) ? $caller['class'] : '';
 48 | 
 49 |     if ($class === $expectedType || is_subclass_of($class, $expectedType) || $class === 'ReflectionProperty') {
 50 |         unset($this->$name);
 51 | 
 52 |         return;
 53 |     }
 54 | } elseif (isset(self::$%s[$name])) {
 55 |     // check private property access via same class
 56 |     $callers = debug_backtrace(\DEBUG_BACKTRACE_PROVIDE_OBJECT, 2);
 57 |     $caller  = isset($callers[1]) ? $callers[1] : [];
 58 |     $class   = isset($caller['class']) ? $caller['class'] : '';
 59 | 
 60 |     static $accessorCache = [];
 61 | 
 62 |     if (isset(self::$%s[$name][$class])) {
 63 |         $cacheKey = $class . '#' . $name;
 64 |         $accessor = isset($accessorCache[$cacheKey])
 65 |             ? $accessorCache[$cacheKey]
 66 |             : $accessorCache[$cacheKey] = \Closure::bind(static function ($instance) use ($name) {
 67 |                 unset($instance->$name);
 68 |             }, null, $class);
 69 | 
 70 |         return $accessor($this);
 71 |     }
 72 | 
 73 |     if ('ReflectionProperty' === $class) {
 74 |         $tmpClass = key(self::$%s[$name]);
 75 |         $cacheKey = $tmpClass . '#' . $name;
 76 |         $accessor = isset($accessorCache[$cacheKey])
 77 |             ? $accessorCache[$cacheKey]
 78 |             : $accessorCache[$cacheKey] = \Closure::bind(static function ($instance) use ($name) {
 79 |                 unset($instance->$name);
 80 |             }, null, $tmpClass);
 81 | 
 82 |         return $accessor($this);
 83 |     }
 84 | }
 85 | 
 86 | %s
 87 | PHP;
 88 | 
 89 |     /**
 90 |      * @throws InvalidArgumentException
 91 |      */
 92 |     public function __construct(
 93 |         ReflectionClass $originalClass,
 94 |         PropertyGenerator $initializerProperty,
 95 |         MethodGenerator $callInitializer,
 96 |         PublicPropertiesMap $publicProperties,
 97 |         ProtectedPropertiesMap $protectedProperties,
 98 |         PrivatePropertiesMap $privateProperties
 99 |     ) {
100 |         parent::__construct($originalClass, '__unset', [new ParameterGenerator('name')]);
101 | 
102 |         $override = $originalClass->hasMethod('__unset');
103 | 
104 |         $parentAccess = 'return parent::__unset($name);';
105 | 
106 |         if (! $override) {
107 |             $parentAccess = PublicScopeSimulator::getPublicAccessSimulationCode(
108 |                 PublicScopeSimulator::OPERATION_UNSET,
109 |                 'name'
110 |             );
111 |         }
112 | 
113 |         $this->setBody(sprintf(
114 |             $this->callParentTemplate,
115 |             '$this->' . $initializerProperty->getName() . ' && $this->' . $callInitializer->getName()
116 |             . '(\'__unset\', array(\'name\' => $name));',
117 |             $publicProperties->getName(),
118 |             $protectedProperties->getName(),
119 |             $protectedProperties->getName(),
120 |             $privateProperties->getName(),
121 |             $privateProperties->getName(),
122 |             $privateProperties->getName(),
123 |             $parentAccess
124 |         ));
125 |     }
126 | }
127 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/LazyLoadingGhost/MethodGenerator/SetProxyInitializer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\LazyLoadingGhost\MethodGenerator;
 6 | 
 7 | use Closure;
 8 | use Laminas\Code\Generator\ParameterGenerator;
 9 | use Laminas\Code\Generator\PropertyGenerator;
10 | use ProxyManager\Generator\MethodGenerator;
11 | 
12 | /**
13 |  * Implementation for {@see \ProxyManager\Proxy\LazyLoadingInterface::setProxyInitializer}
14 |  * for lazy loading value holder objects
15 |  */
16 | class SetProxyInitializer extends MethodGenerator
17 | {
18 |     /**
19 |      * Constructor
20 |      */
21 |     public function __construct(PropertyGenerator $initializerProperty)
22 |     {
23 |         parent::__construct(
24 |             'setProxyInitializer',
25 |             [(new ParameterGenerator('initializer', '?' . Closure::class))->setDefaultValue(null)],
26 |             self::FLAG_PUBLIC,
27 |             '$this->' . $initializerProperty->getName() . ' = $initializer;'
28 |         );
29 | 
30 |         $this->setReturnType('void');
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/LazyLoadingGhost/MethodGenerator/SkipDestructor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\LazyLoadingGhost\MethodGenerator;
 6 | 
 7 | use Laminas\Code\Generator\Exception\InvalidArgumentException;
 8 | use Laminas\Code\Generator\PropertyGenerator;
 9 | use ProxyManager\Generator\MethodGenerator;
10 | 
11 | /**
12 |  * Destructor that skips the original destructor when the proxy is not initialized.
13 |  */
14 | class SkipDestructor extends MethodGenerator
15 | {
16 |     /**
17 |      * Constructor
18 |      *
19 |      * @throws InvalidArgumentException
20 |      */
21 |     public function __construct(PropertyGenerator $initializerProperty)
22 |     {
23 |         parent::__construct('__destruct');
24 | 
25 |         $this->setBody(
26 |             '$this->' . $initializerProperty->getName() . ' || parent::__destruct();'
27 |         );
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/LazyLoadingGhost/PropertyGenerator/InitializationTracker.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\LazyLoadingGhost\PropertyGenerator;
 6 | 
 7 | use Laminas\Code\Generator\Exception\InvalidArgumentException;
 8 | use Laminas\Code\Generator\PropertyGenerator;
 9 | use ProxyManager\Generator\Util\IdentifierSuffixer;
10 | 
11 | /**
12 |  * Property that contains the initializer for a lazy object
13 |  */
14 | class InitializationTracker extends PropertyGenerator
15 | {
16 |     /**
17 |      * Constructor
18 |      *
19 |      * @throws InvalidArgumentException
20 |      */
21 |     public function __construct()
22 |     {
23 |         parent::__construct(IdentifierSuffixer::getIdentifier('initializationTracker'));
24 | 
25 |         $this->setVisibility(self::VISIBILITY_PRIVATE);
26 |         $this->setDocBlock('@var bool tracks initialization status - true while the object is initializing');
27 |         $this->setDefaultValue(false);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/LazyLoadingGhost/PropertyGenerator/InitializerProperty.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\LazyLoadingGhost\PropertyGenerator;
 6 | 
 7 | use Laminas\Code\Generator\Exception\InvalidArgumentException;
 8 | use Laminas\Code\Generator\PropertyGenerator;
 9 | use ProxyManager\Generator\Util\IdentifierSuffixer;
10 | 
11 | /**
12 |  * Property that contains the initializer for a lazy object
13 |  */
14 | class InitializerProperty extends PropertyGenerator
15 | {
16 |     /**
17 |      * Constructor
18 |      *
19 |      * @throws InvalidArgumentException
20 |      */
21 |     public function __construct()
22 |     {
23 |         parent::__construct(IdentifierSuffixer::getIdentifier('initializer'));
24 | 
25 |         $this->setVisibility(self::VISIBILITY_PRIVATE);
26 |         $this->setDocBlock('@var \\Closure|null initializer responsible for generating the wrapped object');
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/LazyLoadingGhost/PropertyGenerator/PrivatePropertiesMap.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\LazyLoadingGhost\PropertyGenerator;
 6 | 
 7 | use Laminas\Code\Generator\Exception\InvalidArgumentException;
 8 | use Laminas\Code\Generator\PropertyGenerator;
 9 | use ProxyManager\Generator\Util\IdentifierSuffixer;
10 | use ProxyManager\ProxyGenerator\Util\Properties;
11 | 
12 | /**
13 |  * Property that contains the initializer for a lazy object
14 |  */
15 | class PrivatePropertiesMap extends PropertyGenerator
16 | {
17 |     public const KEY_DEFAULT_VALUE = 'defaultValue';
18 | 
19 |     /** @var list<string> */
20 |     private $readOnlyPropertyNames = [];
21 | 
22 |     /**
23 |      * Constructor
24 |      *
25 |      * @throws InvalidArgumentException
26 |      */
27 |     public function __construct(Properties $properties)
28 |     {
29 |         parent::__construct(
30 |             IdentifierSuffixer::getIdentifier('privateProperties')
31 |         );
32 | 
33 |         $this->setVisibility(self::VISIBILITY_PRIVATE);
34 |         $this->setStatic(true);
35 |         $this->setDocBlock(
36 |             '@var array[][] visibility and default value of defined properties, indexed by property name and class name'
37 |         );
38 |         $this->setDefaultValue($this->getMap($properties));
39 |     }
40 | 
41 |     /**
42 |      * @return list<string>
43 |      */
44 |     public function getReadOnlyPropertyNames(): array
45 |     {
46 |         return $this->readOnlyPropertyNames;
47 |     }
48 | 
49 |     /**
50 |      * @return array<string, array<class-string, bool>>
51 |      */
52 |     private function getMap(Properties $properties): array
53 |     {
54 |         $map = [];
55 | 
56 |         foreach ($properties->getInstanceProperties() as $property) {
57 |             if (\PHP_VERSION_ID >= 80100 && $property->isReadOnly()) {
58 |                 $this->readOnlyPropertyNames[] = $property->getName();
59 |             } elseif (! $property->isPrivate()) {
60 |                 continue;
61 |             }
62 | 
63 |             $map[$property->getName()][$property->getDeclaringClass()->getName()] = true;
64 |         }
65 | 
66 |         return $map;
67 |     }
68 | }
69 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/LazyLoadingGhost/PropertyGenerator/ProtectedPropertiesMap.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\LazyLoadingGhost\PropertyGenerator;
 6 | 
 7 | use Laminas\Code\Generator\Exception\InvalidArgumentException;
 8 | use Laminas\Code\Generator\PropertyGenerator;
 9 | use ProxyManager\Generator\Util\IdentifierSuffixer;
10 | use ProxyManager\ProxyGenerator\Util\Properties;
11 | 
12 | /**
13 |  * Property that contains the protected instance lazy-loadable properties of an object
14 |  */
15 | class ProtectedPropertiesMap extends PropertyGenerator
16 | {
17 |     public const KEY_DEFAULT_VALUE = 'defaultValue';
18 | 
19 |     /**
20 |      * Constructor
21 |      *
22 |      * @throws InvalidArgumentException
23 |      */
24 |     public function __construct(Properties $properties)
25 |     {
26 |         parent::__construct(
27 |             IdentifierSuffixer::getIdentifier('protectedProperties')
28 |         );
29 | 
30 |         $this->setVisibility(self::VISIBILITY_PRIVATE);
31 |         $this->setStatic(true);
32 |         $this->setDocBlock(
33 |             '@var string[][] declaring class name of defined protected properties, indexed by property name'
34 |         );
35 |         $this->setDefaultValue($this->getMap($properties));
36 |     }
37 | 
38 |     /** @return string[] */
39 |     private function getMap(Properties $properties): array
40 |     {
41 |         $map = [];
42 | 
43 |         foreach ($properties->getProtectedProperties() as $property) {
44 |             if (\PHP_VERSION_ID >= 80100 && $property->isReadOnly()) {
45 |                 continue;
46 |             }
47 | 
48 |             $map[$property->getName()] = $property->getDeclaringClass()->getName();
49 |         }
50 | 
51 |         return $map;
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/LazyLoadingValueHolder/MethodGenerator/GetProxyInitializer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\LazyLoadingValueHolder\MethodGenerator;
 6 | 
 7 | use Laminas\Code\Generator\Exception\InvalidArgumentException;
 8 | use Laminas\Code\Generator\PropertyGenerator;
 9 | use ProxyManager\Generator\MethodGenerator;
10 | 
11 | /**
12 |  * Implementation for {@see \ProxyManager\Proxy\LazyLoadingInterface::getProxyInitializer}
13 |  * for lazy loading value holder objects
14 |  */
15 | class GetProxyInitializer extends MethodGenerator
16 | {
17 |     /**
18 |      * Constructor
19 |      *
20 |      * @throws InvalidArgumentException
21 |      */
22 |     public function __construct(PropertyGenerator $initializerProperty)
23 |     {
24 |         parent::__construct('getProxyInitializer');
25 |         $this->setReturnType('?\\Closure');
26 |         $this->setBody('return $this->' . $initializerProperty->getName() . ';');
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/LazyLoadingValueHolder/MethodGenerator/InitializeProxy.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\LazyLoadingValueHolder\MethodGenerator;
 6 | 
 7 | use Laminas\Code\Generator\Exception\InvalidArgumentException;
 8 | use Laminas\Code\Generator\PropertyGenerator;
 9 | use ProxyManager\Generator\MethodGenerator;
10 | 
11 | /**
12 |  * Implementation for {@see \ProxyManager\Proxy\LazyLoadingInterface::initializeProxy}
13 |  * for lazy loading value holder objects
14 |  */
15 | class InitializeProxy extends MethodGenerator
16 | {
17 |     /**
18 |      * Constructor
19 |      *
20 |      * @throws InvalidArgumentException
21 |      */
22 |     public function __construct(PropertyGenerator $initializerProperty, PropertyGenerator $valueHolderProperty)
23 |     {
24 |         parent::__construct('initializeProxy');
25 |         $this->setReturnType('bool');
26 | 
27 |         $initializer = $initializerProperty->getName();
28 |         $valueHolder = $valueHolderProperty->getName();
29 | 
30 |         $this->setBody(
31 |             'return $this->' . $initializer . ' && ($this->' . $initializer
32 |             . '->__invoke($' . $valueHolder
33 |             . ', $this, \'initializeProxy\', array(), $this->' . $initializer . ') || 1)'
34 |             . ' && $this->' . $valueHolder . ' = $' . $valueHolder . ';'
35 |         );
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/LazyLoadingValueHolder/MethodGenerator/IsProxyInitialized.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\LazyLoadingValueHolder\MethodGenerator;
 6 | 
 7 | use Laminas\Code\Generator\Exception\InvalidArgumentException;
 8 | use Laminas\Code\Generator\PropertyGenerator;
 9 | use ProxyManager\Generator\MethodGenerator;
10 | 
11 | /**
12 |  * Implementation for {@see \ProxyManager\Proxy\LazyLoadingInterface::isProxyInitialized}
13 |  * for lazy loading value holder objects
14 |  */
15 | class IsProxyInitialized extends MethodGenerator
16 | {
17 |     /**
18 |      * Constructor
19 |      *
20 |      * @throws InvalidArgumentException
21 |      */
22 |     public function __construct(PropertyGenerator $valueHolderProperty)
23 |     {
24 |         parent::__construct('isProxyInitialized');
25 |         $this->setReturnType('bool');
26 |         $this->setBody('return null !== $this->' . $valueHolderProperty->getName() . ';');
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/LazyLoadingValueHolder/MethodGenerator/LazyLoadingMethodInterceptor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\LazyLoadingValueHolder\MethodGenerator;
 6 | 
 7 | use Laminas\Code\Generator\Exception\InvalidArgumentException;
 8 | use Laminas\Code\Generator\PropertyGenerator;
 9 | use Laminas\Code\Reflection\MethodReflection;
10 | use ProxyManager\Generator\MethodGenerator;
11 | use ProxyManager\Generator\Util\ProxiedMethodReturnExpression;
12 | 
13 | use function implode;
14 | use function var_export;
15 | 
16 | /**
17 |  * Method decorator for lazy loading value holder objects
18 |  */
19 | class LazyLoadingMethodInterceptor extends MethodGenerator
20 | {
21 |     /**
22 |      * @throws InvalidArgumentException
23 |      */
24 |     public static function generateMethod(
25 |         MethodReflection $originalMethod,
26 |         PropertyGenerator $initializerProperty,
27 |         PropertyGenerator $valueHolderProperty
28 |     ): self {
29 |         $method            = static::fromReflectionWithoutBodyAndDocBlock($originalMethod);
30 |         $initializerName   = $initializerProperty->getName();
31 |         $valueHolderName   = $valueHolderProperty->getName();
32 |         $parameters        = $originalMethod->getParameters();
33 |         $methodName        = $originalMethod->getName();
34 |         $initializerParams = [];
35 |         $forwardedParams   = [];
36 | 
37 |         foreach ($parameters as $parameter) {
38 |             $parameterName       = $parameter->getName();
39 |             $variadicPrefix      = $parameter->isVariadic() ? '...' : '';
40 |             $initializerParams[] = var_export($parameterName, true) . ' => $' . $parameterName;
41 |             $forwardedParams[]   = $variadicPrefix . '$' . $parameterName;
42 |         }
43 | 
44 |         $method->setBody(
45 |             '$this->' . $initializerName
46 |             . ' && ($this->' . $initializerName
47 |             . '->__invoke($' . $valueHolderName . ', $this, ' . var_export($methodName, true)
48 |             . ', array(' . implode(', ', $initializerParams) .  '), $this->' . $initializerName . ') || 1)'
49 |             . ' && $this->' . $valueHolderName . ' = $' . $valueHolderName . ";\n\n"
50 |             . ProxiedMethodReturnExpression::generate(
51 |                 '$this->' . $valueHolderName . '->' . $methodName . '(' . implode(', ', $forwardedParams) . ')',
52 |                 $originalMethod
53 |             )
54 |         );
55 | 
56 |         return $method;
57 |     }
58 | }
59 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/LazyLoadingValueHolder/MethodGenerator/MagicClone.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\LazyLoadingValueHolder\MethodGenerator;
 6 | 
 7 | use Laminas\Code\Generator\PropertyGenerator;
 8 | use ProxyManager\Generator\MagicMethodGenerator;
 9 | use ReflectionClass;
10 | 
11 | /**
12 |  * Magic `__clone` for lazy loading value holder objects
13 |  */
14 | class MagicClone extends MagicMethodGenerator
15 | {
16 |     /**
17 |      * Constructor
18 |      */
19 |     public function __construct(
20 |         ReflectionClass $originalClass,
21 |         PropertyGenerator $initializerProperty,
22 |         PropertyGenerator $valueHolderProperty
23 |     ) {
24 |         parent::__construct($originalClass, '__clone');
25 | 
26 |         $initializer = $initializerProperty->getName();
27 |         $valueHolder = $valueHolderProperty->getName();
28 | 
29 |         $this->setBody(
30 |             '$this->' . $initializer . ' && ($this->' . $initializer
31 |             . '->__invoke($' . $valueHolder
32 |             . ', $this, \'__clone\', array(), $this->' . $initializer . ') || 1)'
33 |             . ' && $this->' . $valueHolder . ' = $' . $valueHolder . ';' . "\n\n"
34 |             . '$this->' . $valueHolder . ' = clone $this->' . $valueHolder . ';'
35 |         );
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/LazyLoadingValueHolder/MethodGenerator/MagicGet.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\LazyLoadingValueHolder\MethodGenerator;
 6 | 
 7 | use InvalidArgumentException;
 8 | use Laminas\Code\Generator\ParameterGenerator;
 9 | use Laminas\Code\Generator\PropertyGenerator;
10 | use ProxyManager\Generator\MagicMethodGenerator;
11 | use ProxyManager\ProxyGenerator\PropertyGenerator\PublicPropertiesMap;
12 | use ProxyManager\ProxyGenerator\Util\PublicScopeSimulator;
13 | use ReflectionClass;
14 | 
15 | /**
16 |  * Magic `__get` for lazy loading value holder objects
17 |  */
18 | class MagicGet extends MagicMethodGenerator
19 | {
20 |     /**
21 |      * Constructor
22 |      *
23 |      * @throws InvalidArgumentException
24 |      */
25 |     public function __construct(
26 |         ReflectionClass $originalClass,
27 |         PropertyGenerator $initializerProperty,
28 |         PropertyGenerator $valueHolderProperty,
29 |         PublicPropertiesMap $publicProperties
30 |     ) {
31 |         parent::__construct($originalClass, '__get', [new ParameterGenerator('name')]);
32 | 
33 |         $hasParent = $originalClass->hasMethod('__get');
34 | 
35 |         $initializer = $initializerProperty->getName();
36 |         $valueHolder = $valueHolderProperty->getName();
37 |         $callParent  = 'if (isset(self::$' . $publicProperties->getName() . "[\$name])) {\n"
38 |             . '    return $this->' . $valueHolder . '->$name;'
39 |             . "\n}\n\n";
40 | 
41 |         if ($hasParent) {
42 |             $this->setInitializerBody(
43 |                 $initializer,
44 |                 $valueHolder,
45 |                 $callParent . 'return $this->' . $valueHolder . '->__get($name);'
46 |             );
47 | 
48 |             return;
49 |         }
50 | 
51 |         $this->setInitializerBody(
52 |             $initializer,
53 |             $valueHolder,
54 |             $callParent . PublicScopeSimulator::getPublicAccessSimulationCode(
55 |                 PublicScopeSimulator::OPERATION_GET,
56 |                 'name',
57 |                 null,
58 |                 $valueHolderProperty,
59 |                 null,
60 |                 $originalClass
61 |             )
62 |         );
63 |     }
64 | 
65 |     private function setInitializerBody(string $initializer, string $valueHolder, string $callParent): void
66 |     {
67 |         $this->setBody(
68 |             '$this->' . $initializer . ' && ($this->' . $initializer
69 |             . '->__invoke($' . $valueHolder . ', $this, \'__get\', [\'name\' => $name], $this->'
70 |             . $initializer . ') || 1) && $this->' . $valueHolder . ' = $' . $valueHolder . ';'
71 |             . "\n\n" . $callParent
72 |         );
73 |     }
74 | }
75 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/LazyLoadingValueHolder/MethodGenerator/MagicIsset.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\LazyLoadingValueHolder\MethodGenerator;
 6 | 
 7 | use InvalidArgumentException;
 8 | use Laminas\Code\Generator\ParameterGenerator;
 9 | use Laminas\Code\Generator\PropertyGenerator;
10 | use ProxyManager\Generator\MagicMethodGenerator;
11 | use ProxyManager\ProxyGenerator\PropertyGenerator\PublicPropertiesMap;
12 | use ProxyManager\ProxyGenerator\Util\PublicScopeSimulator;
13 | use ReflectionClass;
14 | 
15 | /**
16 |  * Magic `__isset` method for lazy loading value holder objects
17 |  */
18 | class MagicIsset extends MagicMethodGenerator
19 | {
20 |     /**
21 |      * Constructor
22 |      *
23 |      * @throws InvalidArgumentException
24 |      */
25 |     public function __construct(
26 |         ReflectionClass $originalClass,
27 |         PropertyGenerator $initializerProperty,
28 |         PropertyGenerator $valueHolderProperty,
29 |         PublicPropertiesMap $publicProperties
30 |     ) {
31 |         parent::__construct($originalClass, '__isset', [new ParameterGenerator('name')]);
32 | 
33 |         $initializer = $initializerProperty->getName();
34 |         $valueHolder = $valueHolderProperty->getName();
35 |         $callParent  = '';
36 | 
37 |         if (! $publicProperties->isEmpty()) {
38 |             $callParent = 'if (isset(self::$' . $publicProperties->getName() . "[\$name])) {\n"
39 |                 . '    return isset($this->' . $valueHolder . '->$name);'
40 |                 . "\n}\n\n";
41 |         }
42 | 
43 |         $callParent .= PublicScopeSimulator::getPublicAccessSimulationCode(
44 |             PublicScopeSimulator::OPERATION_ISSET,
45 |             'name',
46 |             null,
47 |             $valueHolderProperty,
48 |             null,
49 |             $originalClass
50 |         );
51 | 
52 |         $this->setBody(
53 |             '$this->' . $initializer . ' && ($this->' . $initializer
54 |             . '->__invoke($' . $valueHolder . ', $this, \'__isset\', array(\'name\' => $name), $this->'
55 |             . $initializer . ') || 1) && $this->' . $valueHolder . ' = $' . $valueHolder . ';' . "\n\n" . $callParent
56 |         );
57 |     }
58 | }
59 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/LazyLoadingValueHolder/MethodGenerator/MagicSet.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\LazyLoadingValueHolder\MethodGenerator;
 6 | 
 7 | use InvalidArgumentException;
 8 | use Laminas\Code\Generator\ParameterGenerator;
 9 | use Laminas\Code\Generator\PropertyGenerator;
10 | use ProxyManager\Generator\MagicMethodGenerator;
11 | use ProxyManager\ProxyGenerator\PropertyGenerator\PublicPropertiesMap;
12 | use ProxyManager\ProxyGenerator\Util\PublicScopeSimulator;
13 | use ReflectionClass;
14 | 
15 | /**
16 |  * Magic `__set` for lazy loading value holder objects
17 |  */
18 | class MagicSet extends MagicMethodGenerator
19 | {
20 |     /**
21 |      * Constructor
22 |      *
23 |      * @throws InvalidArgumentException
24 |      */
25 |     public function __construct(
26 |         ReflectionClass $originalClass,
27 |         PropertyGenerator $initializerProperty,
28 |         PropertyGenerator $valueHolderProperty,
29 |         PublicPropertiesMap $publicProperties
30 |     ) {
31 |         parent::__construct(
32 |             $originalClass,
33 |             '__set',
34 |             [new ParameterGenerator('name'), new ParameterGenerator('value')]
35 |         );
36 | 
37 |         $hasParent   = $originalClass->hasMethod('__set');
38 |         $initializer = $initializerProperty->getName();
39 |         $valueHolder = $valueHolderProperty->getName();
40 |         $callParent  = '';
41 | 
42 |         if (! $publicProperties->isEmpty()) {
43 |             $callParent = 'if (isset(self::$' . $publicProperties->getName() . "[\$name])) {\n"
44 |                 . '    return ($this->' . $valueHolder . '->$name = $value);'
45 |                 . "\n}\n\n";
46 |         }
47 | 
48 |         $callParent .= $hasParent
49 |             ? 'return $this->' . $valueHolder . '->__set($name, $value);'
50 |             : PublicScopeSimulator::getPublicAccessSimulationCode(
51 |                 PublicScopeSimulator::OPERATION_SET,
52 |                 'name',
53 |                 'value',
54 |                 $valueHolderProperty,
55 |                 null,
56 |                 $originalClass
57 |             );
58 | 
59 |         $this->setBody(
60 |             '$this->' . $initializer . ' && ($this->' . $initializer
61 |             . '->__invoke($' . $valueHolder . ', $this, '
62 |             . '\'__set\', array(\'name\' => $name, \'value\' => $value), $this->' . $initializer . ') || 1)'
63 |             . ' && $this->' . $valueHolder . ' = $' . $valueHolder . ';'
64 |             . "\n\n" . $callParent
65 |         );
66 |     }
67 | }
68 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/LazyLoadingValueHolder/MethodGenerator/MagicSleep.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\LazyLoadingValueHolder\MethodGenerator;
 6 | 
 7 | use Laminas\Code\Generator\PropertyGenerator;
 8 | use ProxyManager\Generator\MagicMethodGenerator;
 9 | use ReflectionClass;
10 | 
11 | use function var_export;
12 | 
13 | /**
14 |  * Magic `__sleep` for lazy loading value holder objects
15 |  */
16 | class MagicSleep extends MagicMethodGenerator
17 | {
18 |     /**
19 |      * Constructor
20 |      */
21 |     public function __construct(
22 |         ReflectionClass $originalClass,
23 |         PropertyGenerator $initializerProperty,
24 |         PropertyGenerator $valueHolderProperty
25 |     ) {
26 |         parent::__construct($originalClass, '__sleep');
27 | 
28 |         $initializer = $initializerProperty->getName();
29 |         $valueHolder = $valueHolderProperty->getName();
30 | 
31 |         $this->setBody(
32 |             '$this->' . $initializer . ' && ($this->' . $initializer
33 |             . '->__invoke($' . $valueHolder . ', $this, \'__sleep\', array(), $this->'
34 |             . $initializer . ') || 1) && $this->' . $valueHolder . ' = $' . $valueHolder . ';' . "\n\n"
35 |             . 'return array(' . var_export($valueHolder, true) . ');'
36 |         );
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/LazyLoadingValueHolder/MethodGenerator/MagicUnset.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\LazyLoadingValueHolder\MethodGenerator;
 6 | 
 7 | use InvalidArgumentException;
 8 | use Laminas\Code\Generator\ParameterGenerator;
 9 | use Laminas\Code\Generator\PropertyGenerator;
10 | use ProxyManager\Generator\MagicMethodGenerator;
11 | use ProxyManager\ProxyGenerator\PropertyGenerator\PublicPropertiesMap;
12 | use ProxyManager\ProxyGenerator\Util\PublicScopeSimulator;
13 | use ReflectionClass;
14 | 
15 | /**
16 |  * Magic `__unset` method for lazy loading value holder objects
17 |  */
18 | class MagicUnset extends MagicMethodGenerator
19 | {
20 |     /**
21 |      * Constructor
22 |      *
23 |      * @throws InvalidArgumentException
24 |      */
25 |     public function __construct(
26 |         ReflectionClass $originalClass,
27 |         PropertyGenerator $initializerProperty,
28 |         PropertyGenerator $valueHolderProperty,
29 |         PublicPropertiesMap $publicProperties
30 |     ) {
31 |         parent::__construct($originalClass, '__unset', [new ParameterGenerator('name')]);
32 | 
33 |         $hasParent   = $originalClass->hasMethod('__unset');
34 |         $initializer = $initializerProperty->getName();
35 |         $valueHolder = $valueHolderProperty->getName();
36 |         $callParent  = '';
37 | 
38 |         if (! $publicProperties->isEmpty()) {
39 |             $callParent = 'if (isset(self::$' . $publicProperties->getName() . "[\$name])) {\n"
40 |                 . '    unset($this->' . $valueHolder . '->$name);' . "\n\n    return;"
41 |                 . "\n}\n\n";
42 |         }
43 | 
44 |         $callParent .= $hasParent
45 |             ? 'return $this->' . $valueHolder . '->__unset($name);'
46 |             : PublicScopeSimulator::getPublicAccessSimulationCode(
47 |                 PublicScopeSimulator::OPERATION_UNSET,
48 |                 'name',
49 |                 null,
50 |                 $valueHolderProperty,
51 |                 null,
52 |                 $originalClass
53 |             );
54 | 
55 |         $this->setBody(
56 |             '$this->' . $initializer . ' && ($this->' . $initializer
57 |             . '->__invoke($' . $valueHolder . ', $this, \'__unset\', array(\'name\' => $name), $this->'
58 |             . $initializer . ') || 1) && $this->' . $valueHolder . ' = $' . $valueHolder . ';' . "\n\n" . $callParent
59 |         );
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/LazyLoadingValueHolder/MethodGenerator/SetProxyInitializer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\LazyLoadingValueHolder\MethodGenerator;
 6 | 
 7 | use Closure;
 8 | use Laminas\Code\Generator\Exception\InvalidArgumentException;
 9 | use Laminas\Code\Generator\ParameterGenerator;
10 | use Laminas\Code\Generator\PropertyGenerator;
11 | use ProxyManager\Generator\MethodGenerator;
12 | 
13 | /**
14 |  * Implementation for {@see \ProxyManager\Proxy\LazyLoadingInterface::setProxyInitializer}
15 |  * for lazy loading value holder objects
16 |  */
17 | class SetProxyInitializer extends MethodGenerator
18 | {
19 |     /**
20 |      * Constructor
21 |      *
22 |      * @throws InvalidArgumentException
23 |      */
24 |     public function __construct(PropertyGenerator $initializerProperty)
25 |     {
26 |         parent::__construct('setProxyInitializer');
27 | 
28 |         $initializerParameter = new ParameterGenerator('initializer');
29 | 
30 |         $initializerParameter->setType('?' . Closure::class);
31 |         $initializerParameter->setDefaultValue(null);
32 |         $this->setParameter($initializerParameter);
33 |         $this->setBody('$this->' . $initializerProperty->getName() . ' = $initializer;');
34 |         $this->setReturnType('void');
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/LazyLoadingValueHolder/MethodGenerator/SkipDestructor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\LazyLoadingValueHolder\MethodGenerator;
 6 | 
 7 | use Laminas\Code\Generator\PropertyGenerator;
 8 | use ProxyManager\Generator\MethodGenerator;
 9 | use ReflectionClass;
10 | 
11 | /**
12 |  * Destructor that skips the original destructor when the proxy is not initialized.
13 |  */
14 | class SkipDestructor extends MethodGenerator
15 | {
16 |     /**
17 |      * Constructor
18 |      */
19 |     public function __construct(
20 |         PropertyGenerator $initializerProperty,
21 |         PropertyGenerator $valueHolderProperty
22 |     ) {
23 |         parent::__construct('__destruct');
24 | 
25 |         $initializer = $initializerProperty->getName();
26 |         $valueHolder = $valueHolderProperty->getName();
27 | 
28 |         $this->setBody(
29 |             '$this->' . $initializer . ' || $this->' . $valueHolder . '->__destruct();'
30 |         );
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/LazyLoadingValueHolder/PropertyGenerator/InitializerProperty.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\LazyLoadingValueHolder\PropertyGenerator;
 6 | 
 7 | use Laminas\Code\Generator\Exception\InvalidArgumentException;
 8 | use Laminas\Code\Generator\PropertyGenerator;
 9 | use ProxyManager\Generator\Util\IdentifierSuffixer;
10 | 
11 | /**
12 |  * Property that contains the initializer for a lazy object
13 |  */
14 | class InitializerProperty extends PropertyGenerator
15 | {
16 |     /**
17 |      * Constructor
18 |      *
19 |      * @throws InvalidArgumentException
20 |      */
21 |     public function __construct()
22 |     {
23 |         parent::__construct(IdentifierSuffixer::getIdentifier('initializer'));
24 | 
25 |         $this->setVisibility(self::VISIBILITY_PRIVATE);
26 |         $this->setDocBlock('@var \\Closure|null initializer responsible for generating the wrapped object');
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/LazyLoadingValueHolder/PropertyGenerator/ValueHolderProperty.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\LazyLoadingValueHolder\PropertyGenerator;
 6 | 
 7 | use Laminas\Code\Generator\DocBlockGenerator;
 8 | use Laminas\Code\Generator\Exception\InvalidArgumentException;
 9 | use Laminas\Code\Generator\PropertyGenerator;
10 | use ProxyManager\Generator\Util\IdentifierSuffixer;
11 | use ReflectionClass;
12 | 
13 | /**
14 |  * Property that contains the wrapped value of a lazy loading proxy
15 |  */
16 | class ValueHolderProperty extends PropertyGenerator
17 | {
18 |     /**
19 |      * Constructor
20 |      *
21 |      * @throws InvalidArgumentException
22 |      */
23 |     public function __construct(ReflectionClass $type)
24 |     {
25 |         parent::__construct(IdentifierSuffixer::getIdentifier('valueHolder'));
26 | 
27 |         $docBlock = new DocBlockGenerator();
28 | 
29 |         $docBlock->setWordWrap(false);
30 |         $docBlock->setLongDescription('@var \\' . $type->getName() . '|null wrapped object, if the proxy is initialized');
31 |         $this->setDocBlock($docBlock);
32 |         $this->setVisibility(self::VISIBILITY_PRIVATE);
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/NullObject/MethodGenerator/NullObjectMethodInterceptor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\NullObject\MethodGenerator;
 6 | 
 7 | use Laminas\Code\Reflection\MethodReflection;
 8 | use ProxyManager\Generator\MethodGenerator;
 9 | use ProxyManager\Generator\Util\IdentifierSuffixer;
10 | use ReflectionNamedType;
11 | 
12 | use function in_array;
13 | 
14 | /**
15 |  * Method decorator for null objects
16 |  */
17 | class NullObjectMethodInterceptor extends MethodGenerator
18 | {
19 |     /**
20 |      * @return static
21 |      */
22 |     public static function generateMethod(MethodReflection $originalMethod): self
23 |     {
24 |         $method = static::fromReflectionWithoutBodyAndDocBlock($originalMethod);
25 | 
26 |         $returnType = $originalMethod->getReturnType();
27 |         $nullCast   = $returnType instanceof ReflectionNamedType && ! $returnType->allowsNull() && in_array($returnType->getName(), ['array', 'float', 'int', 'string'], true)  ? '(' . $returnType->getName() . ') ' : '';
28 | 
29 |         if ($originalMethod->returnsReference() || $nullCast !== '') {
30 |             $reference = IdentifierSuffixer::getIdentifier('ref');
31 | 
32 |             $method->setBody('$' . $reference . ' = ' . $nullCast . "null;\nreturn \$" . $reference . ';');
33 |         }
34 | 
35 |         return $method;
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/NullObject/MethodGenerator/StaticProxyConstructor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\NullObject\MethodGenerator;
 6 | 
 7 | use Laminas\Code\Generator\Exception\InvalidArgumentException;
 8 | use ProxyManager\Generator\MethodGenerator;
 9 | use ProxyManager\ProxyGenerator\Util\Properties;
10 | use ReflectionClass;
11 | use ReflectionProperty;
12 | 
13 | use function array_map;
14 | use function implode;
15 | 
16 | /**
17 |  * The `staticProxyConstructor` implementation for null object proxies
18 |  */
19 | class StaticProxyConstructor extends MethodGenerator
20 | {
21 |     /**
22 |      * Constructor
23 |      *
24 |      * @param ReflectionClass $originalClass Reflection of the class to proxy
25 |      *
26 |      * @throws InvalidArgumentException
27 |      */
28 |     public function __construct(ReflectionClass $originalClass)
29 |     {
30 |         parent::__construct('staticProxyConstructor', [], self::FLAG_PUBLIC | self::FLAG_STATIC);
31 | 
32 |         $nullableProperties = array_map(
33 |             static function (ReflectionProperty $publicProperty): string {
34 |                 return '$instance->' . $publicProperty->getName() . ' = null;';
35 |             },
36 |             Properties::fromReflectionClass($originalClass)
37 |                 ->onlyNullableProperties()
38 |                 ->getPublicProperties()
39 |         );
40 | 
41 |         $this->setReturnType($originalClass->getName());
42 |         $this->setDocBlock('Constructor for null object initialization');
43 |         $this->setBody(
44 |             'static $reflection;' . "\n\n"
45 |             . '$reflection = $reflection ?? new \ReflectionClass(__CLASS__);' . "\n"
46 |             . '$instance   = $reflection->newInstanceWithoutConstructor();' . "\n\n"
47 |             . ($nullableProperties ? implode("\n", $nullableProperties) . "\n\n" : '')
48 |             . 'return $instance;'
49 |         );
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/NullObjectGenerator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator;
 6 | 
 7 | use Laminas\Code\Generator\ClassGenerator;
 8 | use Laminas\Code\Generator\Exception\InvalidArgumentException;
 9 | use Laminas\Code\Reflection\MethodReflection;
10 | use ProxyManager\Exception\InvalidProxiedClassException;
11 | use ProxyManager\Generator\Util\ClassGeneratorUtils;
12 | use ProxyManager\Proxy\NullObjectInterface;
13 | use ProxyManager\ProxyGenerator\Assertion\CanProxyAssertion;
14 | use ProxyManager\ProxyGenerator\NullObject\MethodGenerator\NullObjectMethodInterceptor;
15 | use ProxyManager\ProxyGenerator\NullObject\MethodGenerator\StaticProxyConstructor;
16 | use ProxyManager\ProxyGenerator\Util\ProxiedMethodsFilter;
17 | use ReflectionClass;
18 | 
19 | /**
20 |  * Generator for proxies implementing {@see \ProxyManager\Proxy\NullObjectInterface}
21 |  *
22 |  * {@inheritDoc}
23 |  */
24 | class NullObjectGenerator implements ProxyGeneratorInterface
25 | {
26 |     /**
27 |      * {@inheritDoc}
28 |      *
29 |      * @throws InvalidProxiedClassException
30 |      * @throws InvalidArgumentException
31 |      */
32 |     public function generate(ReflectionClass $originalClass, ClassGenerator $classGenerator): void
33 |     {
34 |         CanProxyAssertion::assertClassCanBeProxied($originalClass);
35 | 
36 |         $interfaces = [NullObjectInterface::class];
37 | 
38 |         if ($originalClass->isInterface()) {
39 |             $interfaces[] = $originalClass->getName();
40 |         } else {
41 |             $classGenerator->setExtendedClass($originalClass->getName());
42 |         }
43 | 
44 |         $classGenerator->setImplementedInterfaces($interfaces);
45 | 
46 |         foreach (ProxiedMethodsFilter::getProxiedMethods($originalClass, []) as $method) {
47 |             $classGenerator->addMethodFromGenerator(
48 |                 NullObjectMethodInterceptor::generateMethod(
49 |                     new MethodReflection($method->getDeclaringClass()->getName(), $method->getName())
50 |                 )
51 |             );
52 |         }
53 | 
54 |         ClassGeneratorUtils::addMethodIfNotFinal(
55 |             $originalClass,
56 |             $classGenerator,
57 |             new StaticProxyConstructor($originalClass)
58 |         );
59 |     }
60 | }
61 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/PropertyGenerator/PublicPropertiesMap.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\PropertyGenerator;
 6 | 
 7 | use Laminas\Code\Generator\Exception\InvalidArgumentException;
 8 | use Laminas\Code\Generator\PropertyGenerator;
 9 | use ProxyManager\Generator\Util\IdentifierSuffixer;
10 | use ProxyManager\ProxyGenerator\Util\Properties;
11 | 
12 | /**
13 |  * Map of public properties that exist in the class being proxied
14 |  */
15 | class PublicPropertiesMap extends PropertyGenerator
16 | {
17 |     /** @var array<string, bool> */
18 |     private $publicProperties = [];
19 | 
20 |     /**
21 |      * @throws InvalidArgumentException
22 |      */
23 |     public function __construct(Properties $properties, bool $skipReadOnlyProperties = false)
24 |     {
25 |         parent::__construct(IdentifierSuffixer::getIdentifier('publicProperties'));
26 | 
27 |         foreach ($properties->getPublicProperties() as $publicProperty) {
28 |             if ($skipReadOnlyProperties && \PHP_VERSION_ID >= 80100 && $publicProperty->isReadOnly()) {
29 |                 continue;
30 |             }
31 | 
32 |             $this->publicProperties[$publicProperty->getName()] = true;
33 |         }
34 | 
35 |         $this->setDefaultValue($this->publicProperties);
36 |         $this->setVisibility(self::VISIBILITY_PRIVATE);
37 |         $this->setStatic(true);
38 |         $this->setDocBlock('@var bool[] map of public properties of the parent class');
39 |     }
40 | 
41 |     public function isEmpty(): bool
42 |     {
43 |         return ! $this->publicProperties;
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/ProxyGeneratorInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator;
 6 | 
 7 | use Laminas\Code\Generator\ClassGenerator;
 8 | use ReflectionClass;
 9 | 
10 | class_exists(\Zend\Code\Generator\ClassGenerator::class);
11 | 
12 | /**
13 |  * Base interface for proxy generators - describes how a proxy generator should use
14 |  * reflection classes to modify given class generators
15 |  */
16 | interface ProxyGeneratorInterface
17 | {
18 |     /**
19 |      * Apply modifications to the provided $classGenerator to proxy logic from $originalClass
20 |      *
21 |      * Due to BC compliance, we cannot add a native `: void` return type declaration here
22 |      *
23 |      * phpcs:disable SlevomatCodingStandard.TypeHints.ReturnTypeHint.MissingNativeTypeHint
24 |      *
25 |      * @return void
26 |      */
27 |     public function generate(ReflectionClass $originalClass, ClassGenerator $classGenerator);
28 | }
29 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/RemoteObject/MethodGenerator/MagicGet.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\RemoteObject\MethodGenerator;
 6 | 
 7 | use Laminas\Code\Generator\Exception\InvalidArgumentException;
 8 | use Laminas\Code\Generator\ParameterGenerator;
 9 | use Laminas\Code\Generator\PropertyGenerator;
10 | use ProxyManager\Generator\MagicMethodGenerator;
11 | use ReflectionClass;
12 | 
13 | use function var_export;
14 | 
15 | /**
16 |  * Magic `__get` for remote objects
17 |  */
18 | class MagicGet extends MagicMethodGenerator
19 | {
20 |     /**
21 |      * Constructor
22 |      *
23 |      * @throws InvalidArgumentException
24 |      */
25 |     public function __construct(ReflectionClass $originalClass, PropertyGenerator $adapterProperty)
26 |     {
27 |         parent::__construct($originalClass, '__get', [new ParameterGenerator('name')]);
28 | 
29 |         $this->setDocBlock('@param string $name');
30 |         $this->setBody(
31 |             '$return = $this->' . $adapterProperty->getName() . '->call(' . var_export($originalClass->getName(), true)
32 |             . ', \'__get\', array($name));' . "\n\n" . 'return $return;'
33 |         );
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/RemoteObject/MethodGenerator/MagicIsset.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\RemoteObject\MethodGenerator;
 6 | 
 7 | use Laminas\Code\Generator\Exception\InvalidArgumentException;
 8 | use Laminas\Code\Generator\ParameterGenerator;
 9 | use Laminas\Code\Generator\PropertyGenerator;
10 | use ProxyManager\Generator\MagicMethodGenerator;
11 | use ReflectionClass;
12 | 
13 | use function var_export;
14 | 
15 | /**
16 |  * Magic `__isset` method for remote objects
17 |  */
18 | class MagicIsset extends MagicMethodGenerator
19 | {
20 |     /**
21 |      * Constructor
22 |      *
23 |      * @throws InvalidArgumentException
24 |      */
25 |     public function __construct(ReflectionClass $originalClass, PropertyGenerator $adapterProperty)
26 |     {
27 |         parent::__construct($originalClass, '__isset', [new ParameterGenerator('name')]);
28 | 
29 |         $this->setDocBlock('@param string $name');
30 |         $this->setBody(
31 |             '$return = $this->' . $adapterProperty->getName() . '->call(' . var_export($originalClass->getName(), true)
32 |             . ', \'__isset\', array($name));' . "\n\n"
33 |             . 'return $return;'
34 |         );
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/RemoteObject/MethodGenerator/MagicSet.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\RemoteObject\MethodGenerator;
 6 | 
 7 | use Laminas\Code\Generator\Exception\InvalidArgumentException;
 8 | use Laminas\Code\Generator\ParameterGenerator;
 9 | use Laminas\Code\Generator\PropertyGenerator;
10 | use ProxyManager\Generator\MagicMethodGenerator;
11 | use ReflectionClass;
12 | 
13 | use function var_export;
14 | 
15 | /**
16 |  * Magic `__set` for remote objects
17 |  */
18 | class MagicSet extends MagicMethodGenerator
19 | {
20 |     /**
21 |      * Constructor
22 |      *
23 |      * @throws InvalidArgumentException
24 |      */
25 |     public function __construct(ReflectionClass $originalClass, PropertyGenerator $adapterProperty)
26 |     {
27 |         parent::__construct(
28 |             $originalClass,
29 |             '__set',
30 |             [new ParameterGenerator('name'), new ParameterGenerator('value')]
31 |         );
32 | 
33 |         $this->setDocBlock('@param string \$name\n@param mixed \$value');
34 |         $this->setBody(
35 |             '$return = $this->' . $adapterProperty->getName() . '->call(' . var_export($originalClass->getName(), true)
36 |             . ', \'__set\', array($name, $value));' . "\n\n"
37 |             . 'return $return;'
38 |         );
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/RemoteObject/MethodGenerator/MagicUnset.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\RemoteObject\MethodGenerator;
 6 | 
 7 | use Laminas\Code\Generator\Exception\InvalidArgumentException;
 8 | use Laminas\Code\Generator\ParameterGenerator;
 9 | use Laminas\Code\Generator\PropertyGenerator;
10 | use ProxyManager\Generator\MagicMethodGenerator;
11 | use ReflectionClass;
12 | 
13 | use function var_export;
14 | 
15 | /**
16 |  * Magic `__unset` method for remote objects
17 |  */
18 | class MagicUnset extends MagicMethodGenerator
19 | {
20 |     /**
21 |      * Constructor
22 |      *
23 |      * @throws InvalidArgumentException
24 |      */
25 |     public function __construct(ReflectionClass $originalClass, PropertyGenerator $adapterProperty)
26 |     {
27 |         parent::__construct($originalClass, '__unset', [new ParameterGenerator('name')]);
28 | 
29 |         $this->setDocBlock('@param string $name');
30 |         $this->setBody(
31 |             '$return = $this->' . $adapterProperty->getName() . '->call(' . var_export($originalClass->getName(), true)
32 |             . ', \'__unset\', array($name));' . "\n\n"
33 |             . 'return $return;'
34 |         );
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/RemoteObject/MethodGenerator/RemoteObjectMethod.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\RemoteObject\MethodGenerator;
 6 | 
 7 | use Laminas\Code\Generator\PropertyGenerator;
 8 | use Laminas\Code\Reflection\MethodReflection;
 9 | use ProxyManager\Generator\MethodGenerator;
10 | use ProxyManager\Generator\Util\ProxiedMethodReturnExpression;
11 | use ProxyManager\Generator\ValueGenerator;
12 | use ReflectionClass;
13 | 
14 | use function sprintf;
15 | use function strtr;
16 | use function var_export;
17 | 
18 | /**
19 |  * Method decorator for remote objects
20 |  */
21 | class RemoteObjectMethod extends MethodGenerator
22 | {
23 |     private const TEMPLATE
24 |         = <<<'PHP'
25 | $args = \func_get_args();
26 | 
27 | switch (\func_num_args()) {#DEFAULT_VALUES#
28 | }
29 | 
30 | #PROXIED_RETURN#
31 | PHP;
32 | 
33 |     /** @return static */
34 |     public static function generateMethod(
35 |         MethodReflection $originalMethod,
36 |         PropertyGenerator $adapterProperty,
37 |         ReflectionClass $originalClass
38 |     ): self {
39 |         $method        = static::fromReflectionWithoutBodyAndDocBlock($originalMethod);
40 |         $proxiedReturn = '$return = $this->' . $adapterProperty->getName()
41 |             . '->call(' . var_export($originalClass->getName(), true)
42 |             . ', ' . var_export($originalMethod->getName(), true) . ', $args);' . "\n\n"
43 |             . ProxiedMethodReturnExpression::generate('$return', $originalMethod);
44 | 
45 |         $defaultValues = self::getDefaultValuesForMethod($originalMethod);
46 | 
47 |         $method->setBody(
48 |             strtr(
49 |                 self::TEMPLATE,
50 |                 [
51 |                     '#PROXIED_RETURN#' => $proxiedReturn,
52 |                     '#DEFAULT_VALUES#' => $defaultValues,
53 |                 ]
54 |             )
55 |         );
56 | 
57 |         return $method;
58 |     }
59 | 
60 |     private static function getDefaultValuesForMethod(MethodReflection $originalMethod): string
61 |     {
62 |         $defaultValues = '';
63 |         foreach ($originalMethod->getParameters() as $i => $parameter) {
64 |             if ($parameter->isOptional() && $parameter->isDefaultValueAvailable()) {
65 |                 $default        = new ValueGenerator($parameter->getDefaultValue(), $parameter);
66 |                 $defaultValues .= sprintf("\n    case %d: \$args[] = %s;", $i, $default->generate());
67 |                 continue;
68 |             }
69 | 
70 |             if ($parameter->isVariadic()) {
71 |                 continue;
72 |             }
73 | 
74 |             $defaultValues .= sprintf("\n    case %d: \$args[] = null;", $i);
75 |         }
76 | 
77 |         return $defaultValues;
78 |     }
79 | }
80 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/RemoteObject/MethodGenerator/StaticProxyConstructor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\RemoteObject\MethodGenerator;
 6 | 
 7 | use Laminas\Code\Generator\ParameterGenerator;
 8 | use Laminas\Code\Generator\PropertyGenerator;
 9 | use ProxyManager\Factory\RemoteObject\AdapterInterface;
10 | use ProxyManager\Generator\MethodGenerator;
11 | use ProxyManager\ProxyGenerator\Util\Properties;
12 | use ProxyManager\ProxyGenerator\Util\UnsetPropertiesGenerator;
13 | use ReflectionClass;
14 | 
15 | /**
16 |  * The `staticProxyConstructor` implementation for remote object proxies
17 |  */
18 | class StaticProxyConstructor extends MethodGenerator
19 | {
20 |     /**
21 |      * Constructor
22 |      *
23 |      * @param ReflectionClass   $originalClass Reflection of the class to proxy
24 |      * @param PropertyGenerator $adapter       Adapter property
25 |      */
26 |     public function __construct(ReflectionClass $originalClass, PropertyGenerator $adapter)
27 |     {
28 |         $adapterName = $adapter->getName();
29 | 
30 |         parent::__construct(
31 |             'staticProxyConstructor',
32 |             [new ParameterGenerator($adapterName, AdapterInterface::class)],
33 |             MethodGenerator::FLAG_PUBLIC | MethodGenerator::FLAG_STATIC,
34 |             null,
35 |             'Constructor for remote object control\n\n'
36 |             . '@param \\ProxyManager\\Factory\\RemoteObject\\AdapterInterface \$adapter'
37 |         );
38 | 
39 |         $body = 'static $reflection;' . "\n\n"
40 |             . '$reflection = $reflection ?? new \ReflectionClass(__CLASS__);' . "\n"
41 |             . '$instance   = $reflection->newInstanceWithoutConstructor();' . "\n\n"
42 |             . '$instance->' . $adapterName . ' = $' . $adapterName . ";\n\n"
43 |             . UnsetPropertiesGenerator::generateSnippet(Properties::fromReflectionClass($originalClass), 'instance');
44 | 
45 |         $this->setBody($body . "\n\nreturn \$instance;");
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/RemoteObject/PropertyGenerator/AdapterProperty.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\RemoteObject\PropertyGenerator;
 6 | 
 7 | use Laminas\Code\Generator\Exception\InvalidArgumentException;
 8 | use Laminas\Code\Generator\PropertyGenerator;
 9 | use ProxyManager\Factory\RemoteObject\AdapterInterface;
10 | use ProxyManager\Generator\Util\IdentifierSuffixer;
11 | 
12 | /**
13 |  * Property that contains the remote object adapter
14 |  */
15 | class AdapterProperty extends PropertyGenerator
16 | {
17 |     /**
18 |      * Constructor
19 |      *
20 |      * @throws InvalidArgumentException
21 |      */
22 |     public function __construct()
23 |     {
24 |         parent::__construct(IdentifierSuffixer::getIdentifier('adapter'));
25 | 
26 |         $this->setVisibility(self::VISIBILITY_PRIVATE);
27 |         $this->setDocBlock('@var \\' . AdapterInterface::class . ' Remote web service adapter');
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/RemoteObjectGenerator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator;
 6 | 
 7 | use Laminas\Code\Generator\ClassGenerator;
 8 | use Laminas\Code\Generator\Exception\InvalidArgumentException;
 9 | use Laminas\Code\Generator\MethodGenerator;
10 | use Laminas\Code\Reflection\MethodReflection;
11 | use ProxyManager\Exception\InvalidProxiedClassException;
12 | use ProxyManager\Generator\Util\ClassGeneratorUtils;
13 | use ProxyManager\Proxy\RemoteObjectInterface;
14 | use ProxyManager\ProxyGenerator\Assertion\CanProxyAssertion;
15 | use ProxyManager\ProxyGenerator\RemoteObject\MethodGenerator\MagicGet;
16 | use ProxyManager\ProxyGenerator\RemoteObject\MethodGenerator\MagicIsset;
17 | use ProxyManager\ProxyGenerator\RemoteObject\MethodGenerator\MagicSet;
18 | use ProxyManager\ProxyGenerator\RemoteObject\MethodGenerator\MagicUnset;
19 | use ProxyManager\ProxyGenerator\RemoteObject\MethodGenerator\RemoteObjectMethod;
20 | use ProxyManager\ProxyGenerator\RemoteObject\MethodGenerator\StaticProxyConstructor;
21 | use ProxyManager\ProxyGenerator\RemoteObject\PropertyGenerator\AdapterProperty;
22 | use ProxyManager\ProxyGenerator\Util\ProxiedMethodsFilter;
23 | use ReflectionClass;
24 | use ReflectionMethod;
25 | 
26 | use function array_map;
27 | use function array_merge;
28 | 
29 | /**
30 |  * Generator for proxies implementing {@see \ProxyManager\Proxy\RemoteObjectInterface}
31 |  *
32 |  * {@inheritDoc}
33 |  */
34 | class RemoteObjectGenerator implements ProxyGeneratorInterface
35 | {
36 |     /**
37 |      * {@inheritDoc}
38 |      *
39 |      * @return void
40 |      *
41 |      * @throws InvalidProxiedClassException
42 |      * @throws InvalidArgumentException
43 |      */
44 |     public function generate(ReflectionClass $originalClass, ClassGenerator $classGenerator)
45 |     {
46 |         CanProxyAssertion::assertClassCanBeProxied($originalClass);
47 | 
48 |         $interfaces = [RemoteObjectInterface::class];
49 | 
50 |         if ($originalClass->isInterface()) {
51 |             $interfaces[] = $originalClass->getName();
52 |         } else {
53 |             $classGenerator->setExtendedClass($originalClass->getName());
54 |         }
55 | 
56 |         $classGenerator->setImplementedInterfaces($interfaces);
57 |         $classGenerator->addPropertyFromGenerator($adapter = new AdapterProperty());
58 | 
59 |         array_map(
60 |             static function (MethodGenerator $generatedMethod) use ($originalClass, $classGenerator): void {
61 |                 ClassGeneratorUtils::addMethodIfNotFinal($originalClass, $classGenerator, $generatedMethod);
62 |             },
63 |             array_merge(
64 |                 array_map(
65 |                     static function (ReflectionMethod $method) use ($adapter, $originalClass): RemoteObjectMethod {
66 |                         return RemoteObjectMethod::generateMethod(
67 |                             new MethodReflection($method->getDeclaringClass()->getName(), $method->getName()),
68 |                             $adapter,
69 |                             $originalClass
70 |                         );
71 |                     },
72 |                     ProxiedMethodsFilter::getProxiedMethods(
73 |                         $originalClass,
74 |                         ['__get', '__set', '__isset', '__unset']
75 |                     )
76 |                 ),
77 |                 [
78 |                     new StaticProxyConstructor($originalClass, $adapter),
79 |                     new MagicGet($originalClass, $adapter),
80 |                     new MagicSet($originalClass, $adapter),
81 |                     new MagicIsset($originalClass, $adapter),
82 |                     new MagicUnset($originalClass, $adapter),
83 |                 ]
84 |             )
85 |         );
86 |     }
87 | }
88 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/Util/GetMethodIfExists.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\Util;
 6 | 
 7 | use ReflectionClass;
 8 | use ReflectionMethod;
 9 | 
10 | /**
11 |  * Internal utility class - allows fetching a method from a given class, if it exists
12 |  */
13 | final class GetMethodIfExists
14 | {
15 |     private function __construct()
16 |     {
17 |     }
18 | 
19 |     public static function get(ReflectionClass $class, string $method): ?ReflectionMethod
20 |     {
21 |         return $class->hasMethod($method) ? $class->getMethod($method) : null;
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/Util/ProxiedMethodsFilter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\Util;
 6 | 
 7 | use ReflectionClass;
 8 | use ReflectionMethod;
 9 | 
10 | use function array_filter;
11 | use function array_flip;
12 | use function array_key_exists;
13 | use function array_map;
14 | use function array_values;
15 | use function strtolower;
16 | 
17 | /**
18 |  * Utility class used to filter methods that can be proxied
19 |  */
20 | final class ProxiedMethodsFilter
21 | {
22 |     /**
23 |      * @internal
24 |      */
25 |     public const DEFAULT_EXCLUDED = [
26 |         '__get',
27 |         '__set',
28 |         '__isset',
29 |         '__unset',
30 |         '__clone',
31 |         '__sleep',
32 |         '__wakeup',
33 |     ];
34 | 
35 |     /**
36 |      * @param ReflectionClass    $class    reflection class from which methods should be extracted
37 |      * @param array<int, string> $excluded methods to be ignored
38 |      *
39 |      * @return ReflectionMethod[]
40 |      */
41 |     public static function getProxiedMethods(ReflectionClass $class, ?array $excluded = null): array
42 |     {
43 |         return self::doFilter($class, $excluded ?? self::DEFAULT_EXCLUDED);
44 |     }
45 | 
46 |     /**
47 |      * @param ReflectionClass    $class    reflection class from which methods should be extracted
48 |      * @param array<int, string> $excluded methods to be ignored
49 |      *
50 |      * @return ReflectionMethod[]
51 |      */
52 |     public static function getAbstractProxiedMethods(ReflectionClass $class, ?array $excluded = null): array
53 |     {
54 |         return self::doFilter($class, $excluded ?? self::DEFAULT_EXCLUDED, true);
55 |     }
56 | 
57 |     /**
58 |      * @param array<int, string> $excluded
59 |      *
60 |      * @return array<int, ReflectionMethod>
61 |      */
62 |     private static function doFilter(ReflectionClass $class, array $excluded, bool $requireAbstract = false): array
63 |     {
64 |         $ignored = array_flip(array_map('strtolower', $excluded));
65 | 
66 |         return array_values(array_filter(
67 |             $class->getMethods(ReflectionMethod::IS_PUBLIC),
68 |             static function (ReflectionMethod $method) use ($ignored, $requireAbstract): bool {
69 |                 return (! $requireAbstract || $method->isAbstract()) && ! (
70 |                     array_key_exists(strtolower($method->getName()), $ignored)
71 |                     || self::methodCannotBeProxied($method)
72 |                 );
73 |             }
74 |         ));
75 |     }
76 | 
77 |     /**
78 |      * Checks whether the method cannot be proxied
79 |      */
80 |     private static function methodCannotBeProxied(ReflectionMethod $method): bool
81 |     {
82 |         return $method->isConstructor() || $method->isFinal() || $method->isStatic();
83 |     }
84 | }
85 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/Util/UnsetPropertiesGenerator.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace ProxyManager\ProxyGenerator\Util;
  6 | 
  7 | use ReflectionClass;
  8 | use ReflectionProperty;
  9 | 
 10 | use function array_map;
 11 | use function assert;
 12 | use function implode;
 13 | use function reset;
 14 | use function sprintf;
 15 | use function var_export;
 16 | 
 17 | /**
 18 |  * Generates code necessary to unset all the given properties from a particular given instance string name
 19 |  */
 20 | final class UnsetPropertiesGenerator
 21 | {
 22 |     private const CLOSURE_TEMPLATE = <<<'PHP'
 23 | \Closure::bind(function (\%s $instance) {
 24 |     %s
 25 | }, $%s, %s)->__invoke($%s);
 26 | PHP;
 27 | 
 28 |     public static function generateSnippet(Properties $properties, string $instanceName): string
 29 |     {
 30 |         $scopedPropertyGroups = [];
 31 |         $nonScopedProperties  = [];
 32 | 
 33 |         foreach ($properties->getInstanceProperties() as $propertyInternalName => $property) {
 34 |             if ($property->isPrivate() || (\PHP_VERSION_ID >= 80100 && $property->isReadOnly())) {
 35 |                 $scopedPropertyGroups[$property->getDeclaringClass()->getName()][$property->getName()] = $property;
 36 |             } else {
 37 |                 $nonScopedProperties[$propertyInternalName] = $property;
 38 |             }
 39 |         }
 40 | 
 41 |         return self::generateUnsetNonScopedPropertiesCode($nonScopedProperties, $instanceName)
 42 |             . self::generateUnsetScopedPropertiesCode($scopedPropertyGroups, $instanceName);
 43 |     }
 44 | 
 45 |     /** @param array<string, ReflectionProperty> $nonScopedProperties */
 46 |     private static function generateUnsetNonScopedPropertiesCode(array $nonScopedProperties, string $instanceName): string
 47 |     {
 48 |         if (! $nonScopedProperties) {
 49 |             return '';
 50 |         }
 51 | 
 52 |         return self::generateUnsetStatement($nonScopedProperties, $instanceName) . "\n\n";
 53 |     }
 54 | 
 55 |     /** @param array<class-string, array<string, ReflectionProperty>> $scopedPropertyGroups */
 56 |     private static function generateUnsetScopedPropertiesCode(array $scopedPropertyGroups, string $instanceName): string
 57 |     {
 58 |         if (! $scopedPropertyGroups) {
 59 |             return '';
 60 |         }
 61 | 
 62 |         $unsetClosureCalls = [];
 63 | 
 64 |         foreach ($scopedPropertyGroups as $scopedProperties) {
 65 |             $firstProperty = reset($scopedProperties);
 66 |             assert($firstProperty instanceof ReflectionProperty);
 67 | 
 68 |             $unsetClosureCalls[] = self::generateUnsetClassScopedPropertiesBlock(
 69 |                 $firstProperty->getDeclaringClass(),
 70 |                 $scopedProperties,
 71 |                 $instanceName
 72 |             );
 73 |         }
 74 | 
 75 |         return implode("\n\n", $unsetClosureCalls) . "\n\n";
 76 |     }
 77 | 
 78 |     /** @param array<string, ReflectionProperty> $properties */
 79 |     private static function generateUnsetClassScopedPropertiesBlock(
 80 |         ReflectionClass $declaringClass,
 81 |         array $properties,
 82 |         string $instanceName
 83 |     ): string {
 84 |         $declaringClassName = $declaringClass->getName();
 85 | 
 86 |         return sprintf(
 87 |             self::CLOSURE_TEMPLATE,
 88 |             $declaringClassName,
 89 |             self::generateUnsetStatement($properties, 'instance'),
 90 |             $instanceName,
 91 |             var_export($declaringClassName, true),
 92 |             $instanceName
 93 |         );
 94 |     }
 95 | 
 96 |     /** @param array<string, ReflectionProperty> $properties */
 97 |     private static function generateUnsetStatement(array $properties, string $instanceName): string
 98 |     {
 99 |         return 'unset('
100 |             . implode(
101 |                 ', ',
102 |                 array_map(
103 |                     static function (ReflectionProperty $property) use ($instanceName): string {
104 |                         return '$' . $instanceName . '->' . $property->getName();
105 |                     },
106 |                     $properties
107 |                 )
108 |             )
109 |             . ');';
110 |     }
111 | }
112 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/ValueHolder/MethodGenerator/Constructor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\ValueHolder\MethodGenerator;
 6 | 
 7 | use Laminas\Code\Generator\Exception\InvalidArgumentException;
 8 | use Laminas\Code\Generator\PropertyGenerator;
 9 | use Laminas\Code\Reflection\MethodReflection;
10 | use Laminas\Code\Reflection\ParameterReflection;
11 | use ProxyManager\Generator\MethodGenerator;
12 | use ProxyManager\ProxyGenerator\Util\Properties;
13 | use ProxyManager\ProxyGenerator\Util\UnsetPropertiesGenerator;
14 | use ReflectionClass;
15 | use ReflectionMethod;
16 | 
17 | use function array_filter;
18 | use function array_map;
19 | use function implode;
20 | use function reset;
21 | use function var_export;
22 | 
23 | /**
24 |  * The `__construct` implementation for lazy loading proxies
25 |  */
26 | class Constructor extends MethodGenerator
27 | {
28 |     /**
29 |      * @throws InvalidArgumentException
30 |      */
31 |     public static function generateMethod(ReflectionClass $originalClass, PropertyGenerator $valueHolder): self
32 |     {
33 |         $originalConstructor = self::getConstructor($originalClass);
34 | 
35 |         $constructor = $originalConstructor
36 |             ? self::fromReflectionWithoutBodyAndDocBlock($originalConstructor)
37 |             : new self('__construct');
38 | 
39 |         $constructor->setBody(
40 |             'static $reflection;' . "\n\n"
41 |             . 'if (! $this->' . $valueHolder->getName() . ') {' . "\n"
42 |             . '    $reflection = $reflection ?? new \ReflectionClass('
43 |             . var_export($originalClass->getName(), true)
44 |             . ");\n"
45 |             . '    $this->' . $valueHolder->getName() . ' = $reflection->newInstanceWithoutConstructor();' . "\n"
46 |             . UnsetPropertiesGenerator::generateSnippet(Properties::fromReflectionClass($originalClass), 'this')
47 |             . '}'
48 |             . ($originalConstructor ? self::generateOriginalConstructorCall($originalConstructor, $valueHolder) : '')
49 |         );
50 | 
51 |         return $constructor;
52 |     }
53 | 
54 |     private static function generateOriginalConstructorCall(
55 |         MethodReflection $originalConstructor,
56 |         PropertyGenerator $valueHolder
57 |     ): string {
58 |         return "\n\n"
59 |             . '$this->' . $valueHolder->getName() . '->' . $originalConstructor->getName() . '('
60 |             . implode(
61 |                 ', ',
62 |                 array_map(
63 |                     static function (ParameterReflection $parameter): string {
64 |                         return ($parameter->isVariadic() ? '...' : '') . '$' . $parameter->getName();
65 |                     },
66 |                     $originalConstructor->getParameters()
67 |                 )
68 |             )
69 |             . ');';
70 |     }
71 | 
72 |     private static function getConstructor(ReflectionClass $class): ?MethodReflection
73 |     {
74 |         $constructors = array_map(
75 |             static function (ReflectionMethod $method): MethodReflection {
76 |                 return new MethodReflection(
77 |                     $method->getDeclaringClass()->getName(),
78 |                     $method->getName()
79 |                 );
80 |             },
81 |             array_filter(
82 |                 $class->getMethods(),
83 |                 static function (ReflectionMethod $method): bool {
84 |                     return $method->isConstructor();
85 |                 }
86 |             )
87 |         );
88 | 
89 |         return reset($constructors) ?: null;
90 |     }
91 | }
92 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/ValueHolder/MethodGenerator/GetWrappedValueHolderValue.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\ValueHolder\MethodGenerator;
 6 | 
 7 | use Laminas\Code\Generator\Exception\InvalidArgumentException;
 8 | use Laminas\Code\Generator\PropertyGenerator;
 9 | use ProxyManager\Generator\MethodGenerator;
10 | 
11 | /**
12 |  * Implementation for {@see \ProxyManager\Proxy\ValueHolderInterface::getWrappedValueHolderValue}
13 |  * for lazy loading value holder objects
14 |  */
15 | class GetWrappedValueHolderValue extends MethodGenerator
16 | {
17 |     /**
18 |      * Constructor
19 |      *
20 |      * @throws InvalidArgumentException
21 |      */
22 |     public function __construct(PropertyGenerator $valueHolderProperty)
23 |     {
24 |         parent::__construct('getWrappedValueHolderValue');
25 |         $this->setBody('return $this->' . $valueHolderProperty->getName() . ';');
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/ProxyManager/ProxyGenerator/ValueHolder/MethodGenerator/MagicSleep.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\ProxyGenerator\ValueHolder\MethodGenerator;
 6 | 
 7 | use Laminas\Code\Generator\PropertyGenerator;
 8 | use ProxyManager\Generator\MagicMethodGenerator;
 9 | use ReflectionClass;
10 | 
11 | use function var_export;
12 | 
13 | /**
14 |  * Magic `__sleep` for value holder objects
15 |  */
16 | class MagicSleep extends MagicMethodGenerator
17 | {
18 |     /**
19 |      * Constructor
20 |      */
21 |     public function __construct(ReflectionClass $originalClass, PropertyGenerator $valueHolderProperty)
22 |     {
23 |         parent::__construct($originalClass, '__sleep');
24 | 
25 |         $this->setBody('return array(' . var_export($valueHolderProperty->getName(), true) . ');');
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Signature/ClassSignatureGenerator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Signature;
 6 | 
 7 | use Laminas\Code\Exception\InvalidArgumentException;
 8 | use Laminas\Code\Generator\ClassGenerator;
 9 | use Laminas\Code\Generator\PropertyGenerator;
10 | 
11 | /**
12 |  * Applies a signature to a given class generator
13 |  */
14 | final class ClassSignatureGenerator implements ClassSignatureGeneratorInterface
15 | {
16 |     private $signatureGenerator;
17 | 
18 |     public function __construct(SignatureGeneratorInterface $signatureGenerator)
19 |     {
20 |         $this->signatureGenerator = $signatureGenerator;
21 |     }
22 | 
23 |     /**
24 |      * {@inheritDoc}
25 |      *
26 |      * @throws InvalidArgumentException
27 |      */
28 |     public function addSignature(ClassGenerator $classGenerator, array $parameters): ClassGenerator
29 |     {
30 |         $classGenerator->addPropertyFromGenerator(new PropertyGenerator(
31 |             'signature' . $this->signatureGenerator->generateSignatureKey($parameters),
32 |             $this->signatureGenerator->generateSignature($parameters),
33 |             PropertyGenerator::FLAG_STATIC | PropertyGenerator::FLAG_PRIVATE
34 |         ));
35 | 
36 |         return $classGenerator;
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Signature/ClassSignatureGeneratorInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Signature;
 6 | 
 7 | use Laminas\Code\Generator\ClassGenerator;
 8 | 
 9 | class_exists(\Zend\Code\Generator\ClassGenerator::class);
10 | 
11 | /**
12 |  * Applies a signature to a given class generator
13 |  */
14 | interface ClassSignatureGeneratorInterface
15 | {
16 |     /**
17 |      * Applies a signature to a given class generator
18 |      *
19 |      * @param array<string, mixed> $parameters
20 |      */
21 |     public function addSignature(ClassGenerator $classGenerator, array $parameters): ClassGenerator;
22 | }
23 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Signature/Exception/ExceptionInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Signature\Exception;
 6 | 
 7 | /**
 8 |  * Exception marker for exceptions from the signature sub-component
 9 |  */
10 | interface ExceptionInterface
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Signature/Exception/InvalidSignatureException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Signature\Exception;
 6 | 
 7 | use ReflectionClass;
 8 | use UnexpectedValueException;
 9 | 
10 | use function count;
11 | use function sprintf;
12 | 
13 | /**
14 |  * Exception for invalid provided signatures
15 |  */
16 | class InvalidSignatureException extends UnexpectedValueException implements ExceptionInterface
17 | {
18 |     /** @param mixed[] $parameters */
19 |     public static function fromInvalidSignature(
20 |         ReflectionClass $class,
21 |         array $parameters,
22 |         string $signature,
23 |         string $expected
24 |     ): self {
25 |         return new self(sprintf(
26 |             'Found signature "%s" for class "%s" does not correspond to expected signature "%s" for %d parameters',
27 |             $signature,
28 |             $class->getName(),
29 |             $expected,
30 |             count($parameters)
31 |         ));
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Signature/Exception/MissingSignatureException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Signature\Exception;
 6 | 
 7 | use ReflectionClass;
 8 | use UnexpectedValueException;
 9 | 
10 | use function count;
11 | use function sprintf;
12 | 
13 | /**
14 |  * Exception for no found signatures
15 |  */
16 | class MissingSignatureException extends UnexpectedValueException implements ExceptionInterface
17 | {
18 |     /** @param mixed[] $parameters */
19 |     public static function fromMissingSignature(ReflectionClass $class, array $parameters, string $expected): self
20 |     {
21 |         return new self(sprintf(
22 |             'No signature found for class "%s", expected signature "%s" for %d parameters',
23 |             $class->getName(),
24 |             $expected,
25 |             count($parameters)
26 |         ));
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Signature/SignatureChecker.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Signature;
 6 | 
 7 | use ProxyManager\Signature\Exception\InvalidSignatureException;
 8 | use ProxyManager\Signature\Exception\MissingSignatureException;
 9 | use ReflectionClass;
10 | 
11 | use function array_key_exists;
12 | use function is_string;
13 | 
14 | /**
15 |  * Generator for signatures to be used to check the validity of generated code
16 |  */
17 | final class SignatureChecker implements SignatureCheckerInterface
18 | {
19 |     private $signatureGenerator;
20 | 
21 |     public function __construct(SignatureGeneratorInterface $signatureGenerator)
22 |     {
23 |         $this->signatureGenerator = $signatureGenerator;
24 |     }
25 | 
26 |     /**
27 |      * {@inheritDoc}
28 |      */
29 |     public function checkSignature(ReflectionClass $class, array $parameters): void
30 |     {
31 |         $propertyName      = 'signature' . $this->signatureGenerator->generateSignatureKey($parameters);
32 |         $signature         = $this->signatureGenerator->generateSignature($parameters);
33 |         $defaultProperties = $class->getDefaultProperties();
34 | 
35 |         if (! (array_key_exists($propertyName, $defaultProperties) && is_string($defaultProperties[$propertyName]))) {
36 |             throw MissingSignatureException::fromMissingSignature($class, $parameters, $signature);
37 |         }
38 | 
39 |         if ($defaultProperties[$propertyName] !== $signature) {
40 |             throw InvalidSignatureException::fromInvalidSignature(
41 |                 $class,
42 |                 $parameters,
43 |                 $defaultProperties[$propertyName],
44 |                 $signature
45 |             );
46 |         }
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Signature/SignatureCheckerInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Signature;
 6 | 
 7 | use ProxyManager\Signature\Exception\InvalidSignatureException;
 8 | use ProxyManager\Signature\Exception\MissingSignatureException;
 9 | use ReflectionClass;
10 | 
11 | /**
12 |  * Generator for signatures to be used to check the validity of generated code
13 |  */
14 | interface SignatureCheckerInterface
15 | {
16 |     /**
17 |      * Checks whether the given signature is valid or not
18 |      *
19 |      * @param array<string, mixed> $parameters
20 |      *
21 |      * @throws InvalidSignatureException
22 |      * @throws MissingSignatureException
23 |      */
24 |     public function checkSignature(ReflectionClass $class, array $parameters): void;
25 | }
26 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Signature/SignatureGenerator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Signature;
 6 | 
 7 | use ProxyManager\Inflector\Util\ParameterEncoder;
 8 | use ProxyManager\Inflector\Util\ParameterHasher;
 9 | 
10 | final class SignatureGenerator implements SignatureGeneratorInterface
11 | {
12 |     private $parameterEncoder;
13 |     private $parameterHasher;
14 | 
15 |     public function __construct()
16 |     {
17 |         $this->parameterEncoder = new ParameterEncoder();
18 |         $this->parameterHasher  = new ParameterHasher();
19 |     }
20 | 
21 |     /**
22 |      * {@inheritDoc}
23 |      */
24 |     public function generateSignature(array $parameters): string
25 |     {
26 |         return $this->parameterEncoder->encodeParameters($parameters);
27 |     }
28 | 
29 |     /**
30 |      * {@inheritDoc}
31 |      */
32 |     public function generateSignatureKey(array $parameters): string
33 |     {
34 |         return $this->parameterHasher->hashParameters($parameters);
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Signature/SignatureGeneratorInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Signature;
 6 | 
 7 | /**
 8 |  * Generator for signatures to be used to check the validity of generated code
 9 |  */
10 | interface SignatureGeneratorInterface
11 | {
12 |     /**
13 |      * Generates a signature to be used to verify generated code validity
14 |      *
15 |      * @param array<string, mixed> $parameters
16 |      */
17 |     public function generateSignature(array $parameters): string;
18 | 
19 |     /**
20 |      * Generates a signature key to be looked up when verifying generated code validity
21 |      *
22 |      * @param array<string, mixed> $parameters
23 |      */
24 |     public function generateSignatureKey(array $parameters): string;
25 | }
26 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Stub/EmptyClassStub.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager\Stub;
 6 | 
 7 | /**
 8 |  * Just an empty instantiable class
 9 |  */
10 | final class EmptyClassStub
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/ProxyManager/Version.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ProxyManager;
 6 | 
 7 | use Composer\InstalledVersions;
 8 | use PackageVersions\Versions;
 9 | use OutOfBoundsException;
10 | 
11 | use function class_exists;
12 | 
13 | /**
14 |  * Version class
15 |  *
16 |  * Note that we cannot check the version at runtime via `git` because that would cause a lot of I/O operations.
17 |  */
18 | final class Version
19 | {
20 |     /**
21 |      * Private constructor - this class is not meant to be instantiated
22 |      */
23 |     private function __construct()
24 |     {
25 |     }
26 | 
27 |     /**
28 |      * Retrieves the package version in the format <detected-version>@<commit-hash>,
29 |      * where the detected version is what composer could detect.
30 |      *
31 |      * @throws OutOfBoundsException
32 |      *
33 |      * @psalm-pure
34 |      *
35 |      * @psalm-suppress MixedOperand `composer-runtime-api:^2` has rough if no type declarations at all - we'll live with it
36 |      * @psalm-suppress ImpureMethodCall `composer-runtime-api:^2` has rough if no type declarations at all - we'll live with it
37 |      */
38 |     public static function getVersion(): string
39 |     {
40 |         if (class_exists(InstalledVersions::class) && InstalledVersions::isInstalled('friendsofphp/proxy-manager-lts')) {
41 |             return InstalledVersions::getPrettyVersion('friendsofphp/proxy-manager-lts')
42 |                 . '@' . InstalledVersions::getReference('friendsofphp/proxy-manager-lts');
43 |         }
44 | 
45 |         if (class_exists(Versions::class)) {
46 |             try {
47 |                 return Versions::getVersion('friendsofphp/proxy-manager-lts');
48 |             } catch (\OutOfBoundsException $e) {
49 |                 // no-op
50 |             }
51 |         }
52 | 
53 |         return '1@friendsofphp/proxy-manager-lts';
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------