/**
  * Visits a class node.
  *
  * @param \PDepend\Source\AST\ASTClass $class
  * @return void
  */
 public function visitClass(ASTClass $class)
 {
     if (!$class->isUserDefined()) {
         return;
     }
     $doc = $this->packages->ownerDocument;
     $classXml = $doc->createElement('Class');
     $classXml->setAttribute('sourceFile', (string) $class->getCompilationUnit());
     $classXml->appendChild($doc->createTextNode($class->getName()));
     if ($class->isAbstract()) {
         $this->abstractClasses->appendChild($classXml);
     } else {
         $this->concreteClasses->appendChild($classXml);
     }
 }
Пример #2
0
 /**
  * This method will persist a class instance for later reuse.
  *
  * @param  string                       $className
  * @param  string                       $namespaceName
  * @param  \PDepend\Source\AST\ASTClass $class
  * @return void
  * @@since 0.9.5
  */
 protected function storeClass($className, $namespaceName, ASTClass $class)
 {
     $className = strtolower($className);
     if (!isset($this->classes[$className][$namespaceName])) {
         $this->classes[$className][$namespaceName] = array();
     }
     $this->classes[$className][$namespaceName][$class->getId()] = $class;
     $namespace = $this->buildNamespace($namespaceName);
     $namespace->addType($class);
 }
 /**
  * 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);
 }
 /**
  * Visits a class node.
  *
  * @param \PDepend\Source\AST\ASTClass $class
  * @return void
  */
 public function visitClass(ASTClass $class)
 {
     $this->visits[] = $class->getName();
     parent::visitClass($class);
 }
 /**
  * Creates a ready to use class fixture.
  *
  * @param string $name Optional class name.
  *
  * @return \PDepend\Source\AST\ASTClass
  * @since 1.0.2
  */
 protected function createClassFixture($name = null)
 {
     $name = $name ? $name : get_class($this);
     $class = new ASTClass($name);
     $class->setCompilationUnit(new ASTCompilationUnit($GLOBALS['argv'][0]));
     $class->setCache(new MemoryCacheDriver());
     $class->setContext($this->getMock('PDepend\\Source\\Builder\\BuilderContext'));
     return $class;
 }
Пример #6
0
    /**
     * Generates the XML for a class or trait node.
     *
     * @param \PDepend\Source\AST\ASTClass $type
     * @param string $typeIdentifier
     * @return void
     */
    private function generateTypeXml(ASTClass $type, $typeIdentifier)
    {
        if (!$type->isUserDefined()) {
            return;
        }

        $xml = end($this->xmlStack);
        $doc = $xml->ownerDocument;

        $typeXml = $doc->createElement($typeIdentifier);
        $typeXml->setAttribute('name', $type->getName());

        $this->writeNodeMetrics($typeXml, $type);
        $this->writeFileReference($typeXml, $type->getCompilationUnit());

        $xml->appendChild($typeXml);

        array_push($this->xmlStack, $typeXml);

        foreach ($type->getMethods() as $method) {
            $method->accept($this);
        }
        foreach ($type->getProperties() as $property) {
            $property->accept($this);
        }

        array_pop($this->xmlStack);
    }
Пример #7
0
 /**
  * Visits a class node.
  *
  * @param \PDepend\Source\AST\ASTClass $node
  * @return void
  */
 public function visitClass(ASTClass $node)
 {
     if (!$node->isUserDefined()) {
         return;
     }
     $this->apply(new ClassNode($node));
     parent::visitClass($node);
 }
 /**
  * Calculates metrics for the given <b>$class</b> instance.
  *
  * @param \PDepend\Source\AST\ASTClass $class
  * @return void
  */
 public function visitClass(ASTClass $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->getId()] = true;
         }
         $this->noneLeafs[$parentClass->getId()] = true;
     }
     // Store node metric
     $this->nodeMetrics[$class->getId()] = array();
     foreach ($class->getMethods() as $method) {
         $method->accept($this);
     }
     foreach ($class->getProperties() as $property) {
         $property->accept($this);
     }
     $this->fireEndClass($class);
 }
Пример #9
0
 /**
  * Calculates the Variables Inheritance of a class metric, this method only
  * counts protected and public properties of parent classes.
  *
  * @param  \PDepend\Source\AST\ASTClass $class The context class instance.
  * @return integer
  */
 private function calculateVarsi(ASTClass $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);
 }
 /**
  * Tests that build interface updates the source file information for null
  * values.
  *
  * @return void
  */
 public function testSetSourceFileInformationForNullValue()
 {
     $file = new ASTCompilationUnit(__FILE__);
     $class = new ASTClass(__CLASS__);
     $class->setCompilationUnit($file);
     $method = new ASTMethod(__FUNCTION__);
     $method->setParent($class);
     $this->assertSame($file, $method->getCompilationUnit());
 }
Пример #11
0
 /**
  * Visits a class node.
  *
  * @param \PDepend\Source\AST\ASTClass $class
  * @return void
  */
 public function visitClass(ASTClass $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->getCompilationUnit());
     $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);
 }
 /**
  * testIsUserDefinedReturnsTrueWhenChildElementIsUserDefined
  *
  * @return void
  */
 public function testIsUserDefinedReturnsTrueWhenChildElementIsUserDefined()
 {
     $class = new ASTClass('class', 0);
     $class->setUserDefined();
     $namespace = new ASTNamespace('package1');
     $namespace->addType($class);
     $this->assertTrue($namespace->isUserDefined());
 }
 /**
  * testBuilderCreatesCaseInSensitiveMethodIdentifiers
  *
  * @return void
  */
 public function testBuilderCreatesCaseInSensitiveMethodIdentifiers()
 {
     $compilationUnit = new ASTCompilationUnit(__FILE__);
     $compilationUnit->setId(__FUNCTION__);
     $class = new ASTClass(__FUNCTION__);
     $class->setCompilationUnit($compilationUnit);
     $method0 = new ASTMethod(__FUNCTION__);
     $method0->setParent($class);
     $method1 = new ASTMethod(strtolower(__FUNCTION__));
     $method1->setParent($class);
     $builder0 = new IdBuilder();
     $builder1 = new IdBuilder();
     $this->assertEquals($builder0->forMethod($method0), $builder1->forMethod($method1));
 }
Пример #14
0
 /**
  * Parses a parent class declaration for the given <b>$class</b>.
  *
  * @param  \PDepend\Source\AST\ASTClass $class
  * @return \PDepend\Source\AST\ASTClass
  * @since  1.0.0
  */
 private function parseClassExtends(ASTClass $class)
 {
     $this->consumeToken(Tokens::T_EXTENDS);
     $this->tokenStack->push();
     $class->setParentClassReference($this->setNodePositionsAndReturn($this->builder->buildAstClassReference($this->parseQualifiedName())));
     return $class;
 }
Пример #15
0
 /**
  * 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()
 {
     $this->methods = null;
     foreach ($this->nodes as $node) {
         $node->setParent($this);
     }
     parent::__wakeup();
 }
 /**
  * Visits a class node.
  *
  * @param \PDepend\Source\AST\ASTClass $class
  * @return void
  */
 public function visitClass(ASTClass $class)
 {
     if (false === $class->isUserDefined()) {
         return;
     }
     $this->fireStartClass($class);
     // Update global class count
     ++$this->noc;
     $id = $class->getNamespace()->getId();
     ++$this->nodeMetrics[$id][self::M_NUMBER_OF_CLASSES];
     $this->nodeMetrics[$class->getId()] = array(self::M_NUMBER_OF_METHODS => 0);
     foreach ($class->getMethods() as $method) {
         $method->accept($this);
     }
     $this->fireEndClass($class);
 }
 /**
  * Initializes a empty metric container for the given class node.
  *
  * @param  \PDepend\Source\AST\ASTClass $class
  * @return void
  * @since  0.9.10
  */
 private function initNodeMetricsForClass(ASTClass $class)
 {
     $id = $class->getId();
     if (isset($this->nodeMetrics[$id])) {
         return;
     }
     ++$this->numberOfClasses;
     $this->nodeMetrics[$id] = 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);
     }
 }
 /**
  * Creates an abstract item instance.
  *
  * @return \PDepend\Source\AST\AbstractASTArtifact
  */
 protected function createItem()
 {
     $class = new ASTClass(__CLASS__);
     $class->setCompilationUnit(new ASTCompilationUnit(__FILE__));
     $class->setCache(new MemoryCacheDriver());
     $class->setContext($this->getMock('PDepend\\Source\\Builder\\BuilderContext'));
     return $class;
 }
 /**
  * testIteratorReturnsSameClassOnlyOnce
  *
  * @return void
  */
 public function testIteratorReturnsSameClassOnlyOnce()
 {
     $class1 = new ASTClass('c1');
     $class1->setId(md5(23));
     $class2 = new ASTClass('c2');
     $class2->setId(md5(23));
     $reference1 = $this->getMockBuilder('PDepend\\Source\\AST\\ASTSelfReference')->disableOriginalConstructor()->getMock();
     $reference1->expects($this->once())->method('getType')->will($this->returnValue($class1));
     $reference2 = $this->getMockBuilder('PDepend\\Source\\AST\\ASTSelfReference')->disableOriginalConstructor()->getMock();
     $reference2->expects($this->once())->method('getType')->will($this->returnValue($class2));
     $references = array($reference1, $reference2);
     $refs = new ASTClassOrInterfaceReferenceIterator($references);
     $types = array();
     foreach ($refs as $type) {
         $types[] = $type->getId();
     }
     $this->assertEquals(array($class1->getId()), $types);
 }