Set the data of this index to the given class
names. Note: Make sure to sort the array before!
| public setClassNames ( array $classNames ) : void | ||
| $classNames | array | |
| return | void | |
/**
* @test
*/
public function filterByPrefixWork()
{
$index1 = new Aop\Builder\ClassNameIndex();
$index1->setClassNames(['\\Foo\\Bar', '\\Foo\\Baz', '\\Bar\\Baz', '\\Foo\\Blubb']);
// We need to call sort manually!
$index1->sort();
$filteredIndex = $index1->filterByPrefix('\\Foo');
$this->assertEquals(['\\Foo\\Bar', '\\Foo\\Baz', '\\Foo\\Blubb'], $filteredIndex->getClassNames());
}
/**
* @test
*/
public function reduceTargetClassNamesFiltersAllClassesNotMatchedByAClassNameFilterWithRegularExpressions()
{
$availableClassNames = ['TestPackage\\Subpackage\\Class1', 'TestPackage\\Class2', 'TestPackage\\Subpackage\\SubSubPackage\\Class3', 'TestPackage\\Subpackage2\\Class4'];
sort($availableClassNames);
$availableClassNamesIndex = new Aop\Builder\ClassNameIndex();
$availableClassNamesIndex->setClassNames($availableClassNames);
$expectedClassNames = ['TestPackage\\Subpackage\\Class1', 'TestPackage\\Subpackage\\SubSubPackage\\Class3'];
sort($expectedClassNames);
$expectedClassNamesIndex = new Aop\Builder\ClassNameIndex();
$expectedClassNamesIndex->setClassNames($expectedClassNames);
$classNameFilter = new Aop\Pointcut\PointcutClassNameFilter('TestPackage\\Subpackage\\.*');
$result = $classNameFilter->reduceTargetClassNames($availableClassNamesIndex);
$this->assertEquals($expectedClassNamesIndex, $result, 'The wrong class names have been filtered');
}
/**
* @test
*/
public function reduceTargetClassNamesFiltersAllClassesNotHavingAMethodWithTheGivenAnnotation()
{
$availableClassNames = ['TestPackage\\Subpackage\\Class1', 'TestPackage\\Class2', 'TestPackage\\Subpackage\\SubSubPackage\\Class3', 'TestPackage\\Subpackage2\\Class4'];
sort($availableClassNames);
$availableClassNamesIndex = new Aop\Builder\ClassNameIndex();
$availableClassNamesIndex->setClassNames($availableClassNames);
$mockReflectionService = $this->getMockBuilder(ReflectionService::class)->disableOriginalConstructor()->getMock();
$mockReflectionService->expects($this->any())->method('getClassesContainingMethodsAnnotatedWith')->with('SomeAnnotationClass')->will($this->returnValue(['TestPackage\\Subpackage\\Class1', 'TestPackage\\Subpackage\\SubSubPackage\\Class3', 'SomeMoreClass']));
$methodAnnotatedWithFilter = new Aop\Pointcut\PointcutMethodAnnotatedWithFilter('SomeAnnotationClass');
$methodAnnotatedWithFilter->injectReflectionService($mockReflectionService);
$expectedClassNames = ['TestPackage\\Subpackage\\Class1', 'TestPackage\\Subpackage\\SubSubPackage\\Class3'];
sort($expectedClassNames);
$expectedClassNamesIndex = new Aop\Builder\ClassNameIndex();
$expectedClassNamesIndex->setClassNames($expectedClassNames);
$result = $methodAnnotatedWithFilter->reduceTargetClassNames($availableClassNamesIndex);
$this->assertEquals($expectedClassNamesIndex, $result, 'The wrong class names have been filtered');
}
/**
* @test
*/
public function reduceTargetClassNamesFiltersAllClassesNotBeeingConfiguredAsScopeSession()
{
$availableClassNames = ['TestPackage\\Subpackage\\Class1', 'TestPackage\\Class2', 'TestPackage\\Subpackage\\SubSubPackage\\Class3', 'TestPackage\\Subpackage2\\Class4'];
sort($availableClassNames);
$availableClassNamesIndex = new ClassNameIndex();
$availableClassNamesIndex->setClassNames($availableClassNames);
$mockCompileTimeObjectManager = $this->getMockBuilder(CompileTimeObjectManager::class)->disableOriginalConstructor()->getMock();
$mockCompileTimeObjectManager->expects($this->any())->method('getClassNamesByScope')->with(Configuration::SCOPE_SESSION)->will($this->returnValue(['TestPackage\\Subpackage\\Class1', 'TestPackage\\Subpackage\\SubSubPackage\\Class3', 'SomeMoreClass']));
$sessionObjectMethodsPointcutFilter = new SessionObjectMethodsPointcutFilter();
$sessionObjectMethodsPointcutFilter->injectObjectManager($mockCompileTimeObjectManager);
$expectedClassNames = ['TestPackage\\Subpackage\\Class1', 'TestPackage\\Subpackage\\SubSubPackage\\Class3'];
sort($expectedClassNames);
$expectedClassNamesIndex = new ClassNameIndex();
$expectedClassNamesIndex->setClassNames($expectedClassNames);
$result = $sessionObjectMethodsPointcutFilter->reduceTargetClassNames($availableClassNamesIndex);
$this->assertEquals($expectedClassNamesIndex, $result, 'The wrong class names have been filtered');
}
/**
* @test
*/
public function reduceTargetClassNamesFiltersAllClassesExceptTheClassItselfAndAllItsSubclasses()
{
$testClassName = uniqid('someTestInterface');
eval('class ' . $testClassName . ' {}');
$availableClassNames = [$testClassName, 'TestPackage\\Subpackage\\Class1', 'TestPackage\\Class2', 'TestPackage\\Subpackage\\SubSubPackage\\Class3', 'TestPackage\\Subpackage2\\Class4'];
sort($availableClassNames);
$availableClassNamesIndex = new Aop\Builder\ClassNameIndex();
$availableClassNamesIndex->setClassNames($availableClassNames);
$mockReflectionService = $this->getMockBuilder(ReflectionService::class)->disableOriginalConstructor()->getMock();
$mockReflectionService->expects($this->any())->method('getAllSubClassNamesForClass')->with($testClassName)->will($this->returnValue(['TestPackage\\Subpackage\\Class1', 'TestPackage\\Subpackage\\SubSubPackage\\Class3', 'SomeMoreClass']));
$classTypeFilter = new Aop\Pointcut\PointcutClassTypeFilter($testClassName);
$classTypeFilter->injectReflectionService($mockReflectionService);
$expectedClassNames = [$testClassName, 'TestPackage\\Subpackage\\Class1', 'TestPackage\\Subpackage\\SubSubPackage\\Class3'];
sort($expectedClassNames);
$expectedClassNamesIndex = new Aop\Builder\ClassNameIndex();
$expectedClassNamesIndex->setClassNames($expectedClassNames);
$result = $classTypeFilter->reduceTargetClassNames($availableClassNamesIndex);
$this->assertEquals($expectedClassNamesIndex, $result, 'The wrong class names have been filtered');
}
/**
* This method is used to optimize the matching process.
*
* @param ClassNameIndex $classNameIndex
* @return ClassNameIndex
*/
public function reduceTargetClassNames(ClassNameIndex $classNameIndex)
{
$classNames = $this->reflectionService->getClassesContainingMethodsAnnotatedWith($this->annotation);
$annotatedIndex = new ClassNameIndex();
$annotatedIndex->setClassNames($classNames);
return $classNameIndex->intersect($annotatedIndex);
}
/**
* @test
*/
public function reduceTargetClassNamesFiltersAllClassesNotMatchedAByClassNameFilter()
{
$availableClassNames = ['TestPackage\\Subpackage\\Class1', 'TestPackage\\Class2', 'TestPackage\\Subpackage\\SubSubPackage\\Class3', 'TestPackage\\Subpackage2\\Class4'];
sort($availableClassNames);
$availableClassNamesIndex = new Aop\Builder\ClassNameIndex();
$availableClassNamesIndex->setClassNames($availableClassNames);
$classNameFilter1 = new Pointcut\PointcutClassNameFilter('TestPackage\\Subpackage\\SubSubPackage\\Class3');
$classNameFilter2 = new Pointcut\PointcutClassNameFilter('TestPackage\\Subpackage\\Class1');
$methodNameFilter1 = new Pointcut\PointcutMethodNameFilter('method2');
$expectedClassNames = ['TestPackage\\Subpackage\\Class1', 'TestPackage\\Subpackage\\SubSubPackage\\Class3'];
sort($expectedClassNames);
$expectedClassNamesIndex = new Aop\Builder\ClassNameIndex();
$expectedClassNamesIndex->setClassNames($expectedClassNames);
$pointcutFilterComposite = new Pointcut\PointcutFilterComposite();
$pointcutFilterComposite->addFilter('&&', $classNameFilter1);
$pointcutFilterComposite->addFilter('||', $classNameFilter2);
$pointcutFilterComposite->addFilter('&&', $methodNameFilter1);
$result = $pointcutFilterComposite->reduceTargetClassNames($availableClassNamesIndex);
$this->assertEquals($expectedClassNamesIndex, $result, 'The wrong class names have been filtered');
}
/**
* This method is used to optimize the matching process.
*
* @param ClassNameIndex $classNameIndex
* @return ClassNameIndex
*/
public function reduceTargetClassNames(ClassNameIndex $classNameIndex)
{
if (interface_exists($this->interfaceOrClassName)) {
$classNames = $this->reflectionService->getAllImplementationClassNamesForInterface($this->interfaceOrClassName);
} elseif (class_exists($this->interfaceOrClassName)) {
$classNames = $this->reflectionService->getAllSubClassNamesForClass($this->interfaceOrClassName);
$classNames[] = $this->interfaceOrClassName;
} else {
$classNames = [];
}
$filteredIndex = new ClassNameIndex();
$filteredIndex->setClassNames($classNames);
return $classNameIndex->intersect($filteredIndex);
}
/**
* This method is used to optimize the matching process.
*
* @param ClassNameIndex $classNameIndex
* @return ClassNameIndex
*/
public function reduceTargetClassNames(ClassNameIndex $classNameIndex)
{
$sessionClasses = new ClassNameIndex();
$sessionClasses->setClassNames($this->objectManager->getClassNamesByScope(ObjectConfiguration::SCOPE_SESSION));
return $classNameIndex->intersect($sessionClasses);
}
/**
* Builds proxy class code which weaves advices into the respective target classes.
*
* The object configurations provided by the Compiler are searched for possible aspect
* annotations. If an aspect class is found, the pointcut expressions are parsed and
* a new aspect with one or more advisors is added to the aspect registry of the AOP framework.
* Finally all advices are woven into their target classes by generating proxy classes.
*
* In general, the command neos.flow:core:compile is responsible for compilation
* and calls this method to do so.
*
* In order to distinguish between an emerged / changed possible target class and
* a class which has been matched previously but just didn't have to be proxied,
* the latter are kept track of by an "unproxiedClass-*" cache entry.
*
* @return void
*/
public function build()
{
$allAvailableClassNamesByPackage = $this->objectManager->getRegisteredClassNames();
$possibleTargetClassNames = $this->getProxyableClasses($allAvailableClassNamesByPackage);
$actualAspectClassNames = $this->reflectionService->getClassNamesByAnnotation(Flow\Aspect::class);
sort($possibleTargetClassNames);
sort($actualAspectClassNames);
$this->aspectContainers = $this->buildAspectContainers($actualAspectClassNames);
$rebuildEverything = false;
if ($this->objectConfigurationCache->has('allAspectClassesUpToDate') === false) {
$rebuildEverything = true;
$this->systemLogger->log('Aspects have been modified, therefore rebuilding all target classes.', LOG_INFO);
$this->objectConfigurationCache->set('allAspectClassesUpToDate', true);
}
$possibleTargetClassNameIndex = new ClassNameIndex();
$possibleTargetClassNameIndex->setClassNames($possibleTargetClassNames);
$targetClassNameCandidates = new ClassNameIndex();
foreach ($this->aspectContainers as $aspectContainer) {
$targetClassNameCandidates->applyUnion($aspectContainer->reduceTargetClassNames($possibleTargetClassNameIndex));
}
$targetClassNameCandidates->sort();
$treatedSubClasses = new ClassNameIndex();
foreach ($targetClassNameCandidates->getClassNames() as $targetClassName) {
$isUnproxied = $this->objectConfigurationCache->has('unproxiedClass-' . str_replace('\\', '_', $targetClassName));
$hasCacheEntry = $this->compiler->hasCacheEntryForClass($targetClassName) || $isUnproxied;
if ($rebuildEverything === true || $hasCacheEntry === false) {
$proxyBuildResult = $this->buildProxyClass($targetClassName, $this->aspectContainers);
if ($proxyBuildResult === false) {
// In case the proxy was not build because there was nothing adviced,
// it might be an advice in the parent and so we need to try to treat this class.
$treatedSubClasses = $this->addBuildMethodsAndAdvicesCodeToClass($targetClassName, $treatedSubClasses);
}
$treatedSubClasses = $this->proxySubClassesOfClassToEnsureAdvices($targetClassName, $targetClassNameCandidates, $treatedSubClasses);
if ($proxyBuildResult !== false) {
if ($isUnproxied) {
$this->objectConfigurationCache->remove('unproxiedClass-' . str_replace('\\', '_', $targetClassName));
}
$this->systemLogger->log(sprintf('Built AOP proxy for class "%s".', $targetClassName), LOG_DEBUG);
} else {
$this->objectConfigurationCache->set('unproxiedClass-' . str_replace('\\', '_', $targetClassName), true);
}
}
}
}
/**
* Returns a new index object which contains all class names of this index
* starting with the given prefix
*
* @param string $prefixFilter A prefix string to filter the class names of this index
* @return \Neos\Flow\Aop\Builder\ClassNameIndex A new index object
*/
public function filterByPrefix($prefixFilter)
{
$pointcuts = array_keys($this->classNames);
$result = new ClassNameIndex();
$right = count($pointcuts) - 1;
$left = 0;
$found = false;
$currentPosition = -1;
while ($found === false) {
if ($left > $right) {
break;
}
$currentPosition = $left + floor(($right - $left) / 2);
if (strpos($pointcuts[$currentPosition], $prefixFilter) === 0) {
$found = true;
break;
} else {
$comparisonResult = strcmp($prefixFilter, $pointcuts[$currentPosition]);
if ($comparisonResult > 0) {
$left = $currentPosition + 1;
} else {
$right = $currentPosition - 1;
}
}
}
if ($found === true) {
$startIndex = $currentPosition;
while ($startIndex >= 0 && strpos($pointcuts[$startIndex], $prefixFilter) === 0) {
$startIndex--;
}
$startIndex++;
$endIndex = $currentPosition;
while ($endIndex < count($pointcuts) && strpos($pointcuts[$endIndex], $prefixFilter) === 0) {
$endIndex++;
}
$result->setClassNames(array_slice($pointcuts, $startIndex, $endIndex - $startIndex));
}
return $result;
}
