/**
* Parses a parent class declaration for the given <b>$class</b>.
*
* @param PHP_Depend_Code_Class $class The context class instance.
*
* @return PHP_Depend_Code_Class
* @since 1.0.0
*/
private function _parseClassExtends(PHP_Depend_Code_Class $class)
{
$this->consumeToken(self::T_EXTENDS);
$this->_tokenStack->push();
$class->setParentClassReference($this->_setNodePositionsAndReturn($this->builder->buildASTClassReference($this->parseQualifiedName())));
return $class;
}
/**
* Tests that build interface updates the source file information for null
* values.
*
* @return void
*/
public function testSetSourceFileInformationForNullValue()
{
$file = new PHP_Depend_Code_File(__FILE__);
$class = new PHP_Depend_Code_Class(__CLASS__);
$class->setSourceFile($file);
$method = new PHP_Depend_Code_Method(__FUNCTION__);
$method->setParent($class);
self::assertSame($file, $method->getSourceFile());
}
/**
* The magic wakeup method will be called by PHP's runtime environment when
* a serialized instance of this class was unserialized. This implementation
* of the wakeup method will register this object in the the global class
* context.
*
* @return void
*/
public function __wakeup()
{
parent::__wakeup();
$this->context->registerTrait($this);
}
/**
* Calculates the Variables Inheritance of a class metric, this method only
* counts protected and public properties of parent classes.
*
* @param PHP_Depend_Code_Class $class The context class instance.
*
* @return integer
*/
private function calculateVarsi(PHP_Depend_Code_Class $class)
{
// List of properties, this method only counts not overwritten properties
$properties = array();
// Collect all properties of the context class
foreach ($class->getProperties() as $prop) {
$properties[$prop->getName()] = true;
}
foreach ($class->getParentClasses() as $parent) {
foreach ($parent->getProperties() as $prop) {
if (!$prop->isPrivate() && !isset($properties[$prop->getName()])) {
$properties[$prop->getName()] = true;
}
}
}
return count($properties);
}
/**
* Calculates metrics for the given <b>$class</b> instance.
*
* @param PHP_Depend_Code_Class $class The context class instance.
*
* @return void
* @see PHP_Depend_VisitorI::visitClass()
*/
public function visitClass(PHP_Depend_Code_Class $class)
{
if (false === $class->isUserDefined()) {
return;
}
$this->fireStartClass($class);
++$this->_cls;
if ($class->isAbstract()) {
++$this->_clsa;
}
$parentClass = $class->getParentClass();
if ($parentClass !== null) {
if ($parentClass->getParentClass() === null) {
$this->_roots[$parentClass->getUUID()] = true;
}
$this->_noneLeafs[$parentClass->getUUID()] = true;
}
// Store node metric
$this->_nodeMetrics[$class->getUUID()] = array();
foreach ($class->getMethods() as $method) {
$method->accept($this);
}
foreach ($class->getProperties() as $property) {
$property->accept($this);
}
$this->fireEndClass($class);
}
/**
* Visits a class node.
*
* @param PHP_Depend_Code_Class $class The current class node.
*
* @return void
* @see PHP_Depend_VisitorI::visitClass()
*/
public function visitClass(PHP_Depend_Code_Class $class)
{
$this->visits[] = $class->getName();
parent::visitClass($class);
}
/**
* testBuilderCreatesCaseInSensitiveMethodIdentifiers
*
* @return void
*/
public function testBuilderCreatesCaseInSensitiveMethodIdentifiers()
{
$file = new PHP_Depend_Code_File(__FILE__);
$file->setUuid(__FUNCTION__);
$class = new PHP_Depend_Code_Class(__FUNCTION__);
$class->setSourceFile($file);
$method0 = new PHP_Depend_Code_Method(__FUNCTION__);
$method0->setParent($class);
$method1 = new PHP_Depend_Code_Method(strtolower(__FUNCTION__));
$method1->setParent($class);
$builder0 = new PHP_Depend_Util_UuidBuilder();
$builder1 = new PHP_Depend_Util_UuidBuilder();
self::assertEquals($builder0->forMethod($method0), $builder1->forMethod($method1));
}
/**
* testIteratorReturnsSameClassOnlyOnce
*
* @return void
*/
public function testIteratorReturnsSameClassOnlyOnce()
{
$class1 = new PHP_Depend_Code_Class('c1');
$class1->setUUID(md5(23));
$class2 = new PHP_Depend_Code_Class('c2');
$class2->setUUID(md5(23));
$reference1 = $this->getMockBuilder(PHP_Depend_Code_ASTSelfReference::CLAZZ)->disableOriginalConstructor()->getMock();
$reference1->expects($this->once())->method('getType')->will($this->returnValue($class1));
$reference2 = $this->getMockBuilder(PHP_Depend_Code_ASTSelfReference::CLAZZ)->disableOriginalConstructor()->getMock();
$reference2->expects($this->once())->method('getType')->will($this->returnValue($class2));
$references = array($reference1, $reference2);
$refs = new PHP_Depend_Code_ClassOrInterfaceReferenceIterator($references);
$types = array();
foreach ($refs as $type) {
$types[] = $type->getUUID();
}
$this->assertEquals(array($class1->getUUID()), $types);
}
/**
* testBuilderCreatesExpectedIdentifierForMethod
*
* @return void
* @covers PHP_Depend_Util_UuidBuilder
* @group pdepend
* @group pdepend::util
* @group unittest
*/
public function testBuilderCreatesExpectedIdentifierForMethod()
{
$class = new PHP_Depend_Code_Class(__CLASS__);
$class->setUUID('FooBar');
$method = new PHP_Depend_Code_Method(__FUNCTION__);
$method->setParent($class);
$builder = new PHP_Depend_Util_UuidBuilder();
$this->assertRegExp('/^FooBar\\-[a-z0-9]{11}$/', $builder->forMethod($method));
}
/**
* Creates a ready to use class fixture.
*
* @param string $name Optional class name.
*
* @return PHP_Depend_Code_Class
* @since 1.0.2
*/
protected function createClassFixture($name = null)
{
$name = $name ? $name : get_class($this);
$class = new PHP_Depend_Code_Class($name);
$class->setSourceFile(new PHP_Depend_Code_File($GLOBALS['argv'][0]));
$class->setCache(new PHP_Depend_Util_Cache_Driver_Memory());
$class->setContext($this->getMock('PHP_Depend_Builder_Context'));
return $class;
}
/**
* Visits a class node.
*
* @param PHP_Depend_Code_Class $class The current class node.
*
* @return void
* @see PHP_Depend_VisitorI::visitClass()
*/
public function visitClass(PHP_Depend_Code_Class $class)
{
if (false === $class->isUserDefined()) {
return;
}
$this->fireStartClass($class);
// Update global class count
++$this->_noc;
// Update parent package
$packageUUID = $class->getPackage()->getUUID();
++$this->_nodeMetrics[$packageUUID][self::M_NUMBER_OF_CLASSES];
$this->_nodeMetrics[$class->getUUID()] = array(self::M_NUMBER_OF_METHODS => 0);
foreach ($class->getMethods() as $method) {
$method->accept($this);
}
$this->fireEndClass($class);
}
/**
* Calculates the Weight Method Per Class metric, this method only counts
* protected and public methods of parent classes.
*
* @param PHP_Depend_Code_Class $class The context class instance.
*
* @return integer
*/
private function _calculateWMCi(PHP_Depend_Code_Class $class)
{
// List of methods, this method only counts not overwritten methods.
$ccn = array();
// First collect all methods of the context class
foreach ($class->getMethods() as $m) {
$ccn[$m->getName()] = $this->_cyclomaticAnalyzer->getCCN2($m);
}
// Get parent class and collect all non private methods.
$parent = $class->getParentClass();
while ($parent !== null) {
// Count all methods
foreach ($parent->getMethods() as $m) {
if (!$m->isPrivate() && !isset($methods[$m->getName()])) {
$ccn[$m->getName()] = $this->_cyclomaticAnalyzer->getCCN2($m);
}
}
// Fetch parent class
$parent = $parent->getParentClass();
}
return array_sum($ccn);
}
/**
* testHasSuppressWarningsAnnotationForReturnsTrue
*
* @return void
* @covers PHP_PMD_Node_AbstractNode
* @group phpmd
* @group phpmd::node
* @group unittest
*/
public function testHasSuppressWarningsAnnotationForReturnsTrue()
{
$class = new PHP_Depend_Code_Class(null);
$class->setDocComment('/** @SuppressWarnings("PMD") */');
$rule = $this->getMock('PHP_PMD_AbstractRule');
$node = new PHP_PMD_Node_Class($class);
$this->assertTrue($node->hasSuppressWarningsAnnotationFor($rule));
}
/**
* Visits a class node.
*
* @param PHP_Depend_Code_Class $class The current class node.
*
* @return void
* @see PHP_Depend_VisitorI::visitClass()
*/
public function visitClass(PHP_Depend_Code_Class $class)
{
if (!$class->isUserDefined()) {
return;
}
$xml = end($this->_xmlStack);
$doc = $xml->ownerDocument;
$classXml = $doc->createElement('class');
$classXml->setAttribute('name', $class->getName());
$this->writeNodeMetrics($classXml, $class);
$this->writeFileReference($classXml, $class->getSourceFile());
$xml->appendChild($classXml);
array_push($this->_xmlStack, $classXml);
foreach ($class->getMethods() as $method) {
$method->accept($this);
}
foreach ($class->getProperties() as $property) {
$property->accept($this);
}
array_pop($this->_xmlStack);
}
/**
* Creates an abstract item instance.
*
* @return PHP_Depend_Code_AbstractItem
*/
protected function createItem()
{
$class = new PHP_Depend_Code_Class(__CLASS__);
$class->setContext($this->getMock('PHP_Depend_Builder_Context'));
return $class;
}
/**
* Visits a class node.
*
* @param PHP_Depend_Code_Class $node The current class node.
*
* @return void
* @see PHP_Depend_VisitorI::visitClass()
*/
public function visitClass(PHP_Depend_Code_Class $node)
{
if (!$node->isUserDefined()) {
return;
}
$this->_apply(new PHP_PMD_Node_Class($node));
parent::visitClass($node);
}
/**
* testVisitClassCountsClassesThatAreNotUserDefined
*
* @return void
* @covers PHP_Depend_Metrics_NodeCount_Analyzer
* @group pdepend
* @group pdepend::metrics
* @group pdepend::metrics::nodecount
* @group unittest
*/
public function testVisitClassCountsClassesThatAreNotUserDefined()
{
$userDefined = new PHP_Depend_Code_Class('Manuel');
$userDefined->setUserDefined();
$package = new PHP_Depend_Code_Package('PHP_Depend');
$package->addType($userDefined);
$analyzer = new PHP_Depend_Metrics_NodeCount_Analyzer();
$analyzer->analyze(new PHP_Depend_Code_NodeIterator(array($package)));
$metrics = $analyzer->getNodeMetrics($package);
$this->assertEquals(1, $metrics['noc']);
}
/**
* testIsUserDefinedReturnsTrueWhenChildElementIsUserDefined
*
* @return void
* @covers PHP_Depend_Code_Package
* @group pdepend
* @group pdepend::code
* @group unittest
*/
public function testIsUserDefinedReturnsTrueWhenChildElementIsUserDefined()
{
$class = new PHP_Depend_Code_Class('class', 0);
$class->setUserDefined();
$package = new PHP_Depend_Code_Package('package1');
$package->addType($class);
$this->assertTrue($package->isUserDefined());
}
/**
* Initializes a empty metric container for the given class node.
*
* @param PHP_Depend_Code_Class $class The context class instance.
*
* @return void
* @since 0.9.10
*/
private function initNodeMetricsForClass(PHP_Depend_Code_Class $class)
{
$uuid = $class->getUuid();
if (isset($this->nodeMetrics[$uuid])) {
return;
}
++$this->numberOfClasses;
$this->nodeMetrics[$uuid] = array(self::M_DEPTH_OF_INHERITANCE_TREE => 0, self::M_NUMBER_OF_ADDED_METHODS => 0, self::M_NUMBER_OF_DERIVED_CLASSES => 0, self::M_NUMBER_OF_OVERWRITTEN_METHODS => 0);
foreach ($class->getParentClasses() as $parent) {
$this->initNodeMetricsForClass($parent);
}
}
/**
* Visits a class node.
*
* @param PHP_Depend_Code_Class $class The current class node.
*
* @return void
* @see PHP_Depend_VisitorI::visitClass()
*/
public function visitClass(PHP_Depend_Code_Class $class)
{
if (!$class->isUserDefined()) {
return;
}
$doc = $this->packages->ownerDocument;
$classXml = $doc->createElement('Class');
$classXml->setAttribute('sourceFile', (string) $class->getSourceFile());
$classXml->appendChild($doc->createTextNode($class->getName()));
if ($class->isAbstract()) {
$this->abstractClasses->appendChild($classXml);
} else {
$this->concreteClasses->appendChild($classXml);
}
}
/**
* This method will persist a class instance for later reuse.
*
* @param string $className The local class name.
* @param string $packageName The package name
* @param PHP_Depend_Code_Class $class The context class.
*
* @return void
* @@since 0.9.5
*/
protected function storeClass($className, $packageName, PHP_Depend_Code_Class $class)
{
$className = strtolower($className);
if (!isset($this->_classes[$className][$packageName])) {
$this->_classes[$className][$packageName] = array();
}
$this->_classes[$className][$packageName][$class->getUUID()] = $class;
$package = $this->buildPackage($packageName);
$package->addType($class);
}
/**
* Builds a new class instance or reuses a previous created class.
*
* Where possible you should give a qualified class name, that is prefixed
* with the package identifier.
*
* <code>
* $builder->buildClass('php::depend::Parser');
* </code>
*
* To determine the correct class, this method implements the following
* algorithm.
*
* <ol>
* <li>Check for an exactly matching instance and reuse it.</li>
* <li>Check for a class instance that belongs to the default package. If
* such an instance exists, reuse it and replace the default package with
* the newly given package information.</li>
* <li>Check that the requested class is in the default package, if this
* is true, reuse the first class instance and ignore the default package.
* </li>
* <li>Create a new instance for the specified package.</li>
* </ol>
*
* @param string $name The class name.
*
* @return PHP_Depend_Code_Class The created class object.
*/
public function buildClass($name)
{
$this->checkBuilderState();
$className = $this->extractTypeName($name);
$packageName = $this->extractPackageName($name);
$class = new PHP_Depend_Code_Class($className);
$class->setSourceFile($this->defaultFile);
$this->storeClass($className, $packageName, $class);
return $class;
}
/**
* Initializes a empty metric container for the given class node.
*
* @param PHP_Depend_Code_Class $class The context class instance.
*
* @return void
* @since 0.9.10
*/
private function _initNodeMetricsForClass(PHP_Depend_Code_Class $class)
{
if (is_object($class->getParentClass())) {
$this->_initNodeMetricsForClass($class->getParentClass());
}
$uuid = $class->getUUID();
if (isset($this->_nodeMetrics[$uuid])) {
return;
}
++$this->_numberOfClasses;
$this->_nodeMetrics[$uuid] = array(self::M_DEPTH_OF_INHERITANCE_TREE => 0, self::M_NUMBER_OF_ADDED_METHODS => 0, self::M_NUMBER_OF_DERIVED_CLASSES => 0, self::M_NUMBER_OF_OVERWRITTEN_METHODS => 0);
}
/**
* Creates an abstract item instance.
*
* @return PHP_Depend_Code_AbstractItem
*/
protected function createItem()
{
$class = new PHP_Depend_Code_Class(__CLASS__);
$class->setSourceFile(new PHP_Depend_Code_File(__FILE__));
$class->setCache(new PHP_Depend_Util_Cache_Driver_Memory());
$class->setContext($this->getMock('PHP_Depend_Builder_Context'));
return $class;
}
/**
* Tests the visitor accept method.
*
* @return void
* @covers PHP_Depend_Code_AbstractClassOrInterface
* @covers PHP_Depend_Code_Class
* @group pdepend
* @group pdepend::code
* @group unittest
*/
public function testVisitorAccept()
{
$class = new PHP_Depend_Code_Class('clazz', 0);
$visitor = new PHP_Depend_Visitor_TestNodeVisitor();
$class->accept($visitor);
$this->assertSame($class, $visitor->class);
}
