/**
* @return \Donquixote\HastyReflectionCommon\Reflection\ClassLike\ClassLikeReflectionInterface[]
*/
private function buildInterfaces()
{
$interfaces = array();
foreach ($this->ownInterfaceNames as $qcn) {
$interface = $this->autoloadSource->classGetReflection($qcn);
if ($interface && $interface->isInterface()) {
$interfaces[$qcn] = $interface;
}
}
return $interfaces;
}
/**
* @return \Donquixote\HastyReflectionCommon\Reflection\ClassLike\ClassLikeReflectionInterface[]
*/
protected function buildAllInterfacesWithoutSelf()
{
$interfaces = array();
foreach ($this->allInterfaceNamesWithoutSelf as $interfaceName) {
$interface = $this->autoloadSource->classGetReflection($interfaceName);
if ($interface && $interface->isInterface()) {
$interfaces[$interfaceName] = $interface;
}
}
return $interfaces;
}
/**
* @return \Donquixote\HastyReflectionCommon\Reflection\ClassLike\ClassLikeReflectionInterface|null
*/
private function buildParentClass()
{
if (NULL === $this->parentClassQcn) {
return NULL;
}
$classLikeReflection = $this->autoloadSource->classGetReflection($this->parentClassQcn);
if (!$classLikeReflection || !$classLikeReflection->isClass()) {
return NULL;
}
return $classLikeReflection;
}
/**
* Gets all interfaces directly or indirectly implemented by this class.
*
* Will include the class itself if it is an interface.
*
* @param bool $includeSelf
*
* @return \Donquixote\HastyReflectionCommon\Reflection\ClassLike\ClassLikeReflectionInterface[]
*/
function getAllInterfaces($includeSelf)
{
if (NULL === $this->interfacesAll) {
$this->interfacesAllInclSelf = $this->interfacesAll = $this->buildAllInterfacesWithoutSelf();
if (NULL !== $this->selfInterfaceName) {
$selfInterface = $this->classIndex->classGetReflection($this->selfInterfaceName);
if (NULL !== $selfInterface) {
$this->interfacesAllInclSelf = array($this->selfInterfaceName => $selfInterface) + $this->interfacesAllInclSelf;
}
}
}
return $includeSelf ? $this->interfacesAllInclSelf : $this->interfacesAll;
}
/**
* @return \Donquixote\HastyReflectionCommon\Reflection\FunctionLike\MethodReflectionInterface[]
*/
protected function findOwnMethods()
{
$classReflection = $this->autoloadSource->classGetReflection($this->reflectionClass->getName());
if (NULL === $classReflection) {
return array();
}
$class = $this->reflectionClass->getName();
$methods = array();
foreach ($this->reflectionClass->getMethods() as $reflectionMethod) {
if ($class === $reflectionMethod->getDeclaringClass()->getName()) {
$methods[$reflectionMethod->getName()] = new MethodReflection_Native($classReflection, $reflectionMethod);
}
}
return $methods;
}
/**
* @param \Donquixote\HastyReflectionCommon\Canvas\ClassIndex\ClassIndexInterface $classIndex
* @param string $class
*
* @dataProvider provideClassIndexArgs()
*/
function testClassIndex(ClassIndexInterface $classIndex, $class)
{
$classReflection = $classIndex->classGetReflection($class);
$reflectionClass = new \ReflectionClass($class);
// Test identity.
$this->assertTrue($classReflection === $classIndex->classGetReflection($class));
// Test class type/info.
$expectedIsClass = !$reflectionClass->isInterface() && !$reflectionClass->isTrait();
$this->assertEquals($reflectionClass->getName(), $classReflection->getName());
$this->assertEquals($reflectionClass->getShortName(), $classReflection->getShortName());
$this->assertEquals($reflectionClass->getDocComment(), $classReflection->getDocComment());
$this->assertEquals($reflectionClass->isInterface(), $classReflection->isInterface());
$this->assertEquals($reflectionClass->isTrait(), $classReflection->isTrait());
$this->assertEquals($expectedIsClass, $classReflection->isClass());
$this->assertEquals($reflectionClass->isAbstract() && $expectedIsClass, $classReflection->isAbstractClass());
// Test context.
$this->assertEquals($reflectionClass->getNamespaceName(), $classReflection->getNamespaceUseContext()->getNamespaceName());
// Test interfaces
foreach ($classReflection->getOwnInterfaces() as $interfaceName => $interfaceReflection) {
$this->assertTrue($reflectionClass->implementsInterface($interfaceName));
}
foreach ($reflectionClass->getInterfaceNames() as $interfaceName) {
$this->assertTrue($classReflection->extendsOrImplementsInterface($interfaceName, FALSE));
}
$expectedAllInterfaceNames = $expectedAllAndSelfInterfaceNames = $reflectionClass->getInterfaceNames();
if ($reflectionClass->isInterface()) {
array_unshift($expectedAllAndSelfInterfaceNames, $class);
}
$this->assertEqualSorted($expectedAllAndSelfInterfaceNames, array_keys($classReflection->getAllInterfaces(TRUE)));
$this->assertEqualSorted($expectedAllInterfaceNames, array_keys($classReflection->getAllInterfaces(FALSE)));
$expectedMethodNames = array();
$expectedOwnMethodNames = array();
foreach ($reflectionClass->getMethods() as $method) {
$expectedMethodNames[] = $method->getName();
if ($method->getDeclaringClass()->getName() === $reflectionClass->getName()) {
$expectedOwnMethodNames[] = $method->getName();
}
}
$this->assertEquals($expectedOwnMethodNames, array_keys($classReflection->getOwnMethods()));
$this->assertEqualSorted($expectedMethodNames, array_keys($classReflection->getMethods()));
$methodReflections = $classReflection->getMethods();
foreach ($reflectionClass->getMethods() as $reflectionMethod) {
$methodReflection = $methodReflections[$reflectionMethod->getShortName()];
$this->assertEqualMethods($reflectionMethod, $methodReflection);
}
// isAbstract() is a beast, so we test it least.
$this->assertEquals($reflectionClass->isAbstract(), $classReflection->isAbstract());
}
/**
* @param \Donquixote\HastyPhpAst\Ast\FunctionLike\AstFunctionLikeInterface $methodNode
*
* @return \Donquixote\HastyReflectionCommon\Reflection\FunctionLike\MethodReflectionInterface
*/
private function methodNodeBuildMethod(AstFunctionLikeInterface $methodNode)
{
$declaringClass = $this->autoloadSource->classGetReflection($this->name);
return new MethodReflection_Ast($declaringClass, $methodNode);
}
