/**
* Explicitly compile proxy classes
*
* The compile command triggers the proxy class compilation.
* Although a compilation run is triggered automatically by Flow, there might
* be cases in a production context where a manual compile run is needed.
*
* @Flow\Internal
* @param boolean $force If set, classes will be compiled even though the cache says that everything is up to date.
* @return void
*/
public function compileCommand($force = false)
{
/** @var VariableFrontend $objectConfigurationCache */
$objectConfigurationCache = $this->cacheManager->getCache('Flow_Object_Configuration');
if ($force === false) {
if ($objectConfigurationCache->has('allCompiledCodeUpToDate')) {
return;
}
}
/** @var PhpFrontend $classesCache */
$classesCache = $this->cacheManager->getCache('Flow_Object_Classes');
$this->proxyClassCompiler->injectClassesCache($classesCache);
$this->aopProxyClassBuilder->injectObjectConfigurationCache($objectConfigurationCache);
$this->aopProxyClassBuilder->build();
$this->dependencyInjectionProxyClassBuilder->build();
$classCount = $this->proxyClassCompiler->compile();
$dataTemporaryPath = $this->environment->getPathToTemporaryDirectory();
Files::createDirectoryRecursively($dataTemporaryPath);
file_put_contents($dataTemporaryPath . 'AvailableProxyClasses.php', $this->proxyClassCompiler->getStoredProxyClassMap());
$objectConfigurationCache->set('allCompiledCodeUpToDate', true);
$classesCacheBackend = $classesCache->getBackend();
if ($this->bootstrap->getContext()->isProduction() && $classesCacheBackend instanceof FreezableBackendInterface) {
/** @var FreezableBackendInterface $backend */
$backend = $classesCache->getBackend();
$backend->freeze();
}
$this->emitFinishedCompilationRun($classCount);
}
/**
* Analyzes the Object Configuration provided by the compiler and builds the necessary PHP code for the proxy classes
* to realize dependency injection.
*
* @return void
*/
public function build()
{
$this->objectConfigurations = $this->objectManager->getObjectConfigurations();
foreach ($this->objectConfigurations as $objectName => $objectConfiguration) {
$className = $objectConfiguration->getClassName();
if ($className === '' || $this->compiler->hasCacheEntryForClass($className) === true) {
continue;
}
if ($objectName !== $className || $this->reflectionService->isClassAbstract($className)) {
continue;
}
$proxyClass = $this->compiler->getProxyClass($className);
if ($proxyClass === false) {
continue;
}
$this->systemLogger->log('Building DI proxy for "' . $className . '".', LOG_DEBUG);
$constructorPreCode = '';
$constructorPostCode = '';
$constructorPreCode .= $this->buildSetInstanceCode($objectConfiguration);
$constructorPreCode .= $this->buildConstructorInjectionCode($objectConfiguration);
$setRelatedEntitiesCode = '';
if (!$this->reflectionService->hasMethod($className, '__sleep')) {
$proxyClass->addTraits(['\\' . ObjectSerializationTrait::class]);
$sleepMethod = $proxyClass->getMethod('__sleep');
$sleepMethod->addPostParentCallCode($this->buildSerializeRelatedEntitiesCode($objectConfiguration));
$setRelatedEntitiesCode = "\n " . '$this->Flow_setRelatedEntities();' . "\n";
}
$wakeupMethod = $proxyClass->getMethod('__wakeup');
$wakeupMethod->addPreParentCallCode($this->buildSetInstanceCode($objectConfiguration));
$wakeupMethod->addPreParentCallCode($setRelatedEntitiesCode);
$wakeupMethod->addPostParentCallCode($this->buildLifecycleInitializationCode($objectConfiguration, ObjectManagerInterface::INITIALIZATIONCAUSE_RECREATED));
$wakeupMethod->addPostParentCallCode($this->buildLifecycleShutdownCode($objectConfiguration));
$injectPropertiesCode = $this->buildPropertyInjectionCode($objectConfiguration);
if ($injectPropertiesCode !== '') {
$proxyClass->addTraits(['\\' . PropertyInjectionTrait::class]);
$proxyClass->getMethod('Flow_Proxy_injectProperties')->addPreParentCallCode($injectPropertiesCode);
$proxyClass->getMethod('Flow_Proxy_injectProperties')->overrideMethodVisibility('private');
$wakeupMethod->addPreParentCallCode(" \$this->Flow_Proxy_injectProperties();\n");
$constructorPostCode .= ' if (\'' . $className . '\' === get_class($this)) {' . "\n";
$constructorPostCode .= ' $this->Flow_Proxy_injectProperties();' . "\n";
$constructorPostCode .= ' }' . "\n";
}
$constructorPostCode .= $this->buildLifecycleInitializationCode($objectConfiguration, ObjectManagerInterface::INITIALIZATIONCAUSE_CREATED);
$constructorPostCode .= $this->buildLifecycleShutdownCode($objectConfiguration);
$constructor = $proxyClass->getConstructor();
$constructor->addPreParentCallCode($constructorPreCode);
$constructor->addPostParentCallCode($constructorPostCode);
if ($this->objectManager->getContext()->isProduction()) {
$this->compileStaticMethods($className, $proxyClass);
}
}
}
/**
* Adds code to build the methods and advices array in case the parent class has some.
*
* @param string $className
* @param ClassNameIndex $treatedSubClasses
* @return ClassNameIndex
*/
protected function addBuildMethodsAndAdvicesCodeToClass($className, ClassNameIndex $treatedSubClasses)
{
if ($treatedSubClasses->hasClassName($className)) {
return $treatedSubClasses;
}
$treatedSubClasses = $treatedSubClasses->union(new ClassNameIndex([$className]));
if ($this->reflectionService->isClassReflected($className) === false) {
return $treatedSubClasses;
}
$proxyClass = $this->compiler->getProxyClass($className);
if ($proxyClass === false) {
return $treatedSubClasses;
}
$callBuildMethodsAndAdvicesArrayCode = " if (method_exists(get_parent_class(), 'Flow_Aop_Proxy_buildMethodsAndAdvicesArray') && is_callable('parent::Flow_Aop_Proxy_buildMethodsAndAdvicesArray')) parent::Flow_Aop_Proxy_buildMethodsAndAdvicesArray();\n";
$proxyClass->getConstructor()->addPreParentCallCode($callBuildMethodsAndAdvicesArrayCode);
$proxyClass->getMethod('__wakeup')->addPreParentCallCode($callBuildMethodsAndAdvicesArrayCode);
return $treatedSubClasses;
}
/**
* Builds the class documentation block for the specified class keeping doc comments and vital annotations
*
* @return string $methodDocumentation DocComment for the given method
*/
protected function buildClassDocumentation()
{
$classDocumentation = "/**\n";
$classReflection = new ClassReflection($this->fullOriginalClassName);
$classDescription = $classReflection->getDescription();
$classDocumentation .= ' * ' . str_replace("\n", "\n * ", $classDescription) . "\n";
foreach ($this->reflectionService->getClassAnnotations($this->fullOriginalClassName) as $annotation) {
$classDocumentation .= ' * ' . Compiler::renderAnnotation($annotation) . "\n";
}
$classDocumentation .= " */\n";
return $classDocumentation;
}
/**
* @param string $classCode
* @param string $expectedResult
* @test
* @dataProvider stripOpeningPhpTagCorrectlyStripsPhpTagDataProvider
*/
public function stripOpeningPhpTagCorrectlyStripsPhpTagTests($classCode, $expectedResult)
{
$actualResult = $this->compiler->_call('stripOpeningPhpTag', $classCode);
$this->assertSame($expectedResult, $actualResult);
}
/**
* Builds the method documentation block for the specified method keeping the vital annotations
*
* @param string $className Name of the class the method is declared in
* @param string $methodName Name of the method to create the parameters code for
* @return string $methodDocumentation DocComment for the given method
*/
protected function buildMethodDocumentation($className, $methodName)
{
$methodDocumentation = " /**\n * Autogenerated Proxy Method\n";
if ($this->reflectionService->hasMethod($className, $methodName)) {
$methodTags = $this->reflectionService->getMethodTagsValues($className, $methodName);
$allowedTags = ['param', 'return', 'throws'];
foreach ($methodTags as $tag => $values) {
if (in_array($tag, $allowedTags)) {
if (count($values) === 0) {
$methodDocumentation .= ' * @' . $tag . "\n";
} else {
foreach ($values as $value) {
$methodDocumentation .= ' * @' . $tag . ' ' . $value . "\n";
}
}
}
}
$methodAnnotations = $this->reflectionService->getMethodAnnotations($className, $methodName);
foreach ($methodAnnotations as $annotation) {
$methodDocumentation .= ' * ' . Compiler::renderAnnotation($annotation) . "\n";
}
}
$methodDocumentation .= " */\n";
return $methodDocumentation;
}
