PHP ClassNode::getParentClass方法代码示例

 /**
  * Supports everything that extends SplFileInfo.
  *
  * @param ClassNode $node
  *
  * @return bool
  */
 public function supports(ClassNode $node)
 {
     if (null === $node->getParentClass()) {
         return false;
     }
     return 'SplFileInfo' === $node->getParentClass() || is_subclass_of($node->getParentClass(), 'SplFileInfo');
 }

 /**
  * Supports exceptions on HHVM.
  *
  * @param ClassNode $node
  *
  * @return bool
  */
 public function supports(ClassNode $node)
 {
     if (!defined('HHVM_VERSION')) {
         return false;
     }
     return 'Exception' === $node->getParentClass() || is_subclass_of($node->getParentClass(), 'Exception');
 }

 /**
  *
  * @param \Prophecy\Doubler\Generator\Node\ClassNode $node        	
  */
 function it_ignores_existing_methods($node)
 {
     $node->getParentClass()->willReturn('spec\\Prophecy\\Doubler\\ClassPatch\\MagicalApiExtended');
     $node->addMethod(new MethodNode('undefinedMethod'))->shouldBeCalled();
     $node->addMethod(new MethodNode('definedMethod'))->shouldNotBeCalled();
     $this->apply($node);
 }

 /**
  *
  * @param \Prophecy\Doubler\Generator\Node\ClassNode $reflectionClassNode        	
  * @param \Prophecy\Doubler\Generator\Node\ClassNode $anotherClassNode        	
  */
 function it_supports_ReflectionClass_only($reflectionClassNode, $anotherClassNode)
 {
     $reflectionClassNode->getParentClass()->willReturn('ReflectionClass');
     $anotherClassNode->getParentClass()->willReturn('stdClass');
     $this->supports($reflectionClassNode)->shouldReturn(true);
     $this->supports($anotherClassNode)->shouldReturn(false);
 }

 /**
  * @param \Prophecy\Doubler\Generator\Node\ClassNode $node
  */
 function it_discovers_api_using_phpdoc_from_extended_parent_interfaces($node)
 {
     $node->getParentClass()->willReturn('spec\\Prophecy\\Doubler\\ClassPatch\\MagicalApiImplementedExtended');
     $node->getInterfaces()->willReturn(array());
     $node->addMethod(new MethodNode('implementedMethod'))->shouldBeCalled();
     $this->apply($node);
 }

 /**
  * @param \Prophecy\Doubler\Generator\Node\ClassNode $node
  * @param \Prophecy\Doubler\Generator\Node\MethodNode $method
  */
 function it_should_not_supply_a_file_for_a_directory_iterator($node, $method)
 {
     $node->hasMethod('__construct')->willReturn(true);
     $node->getMethod('__construct')->willReturn($method);
     $node->getParentClass()->willReturn('DirectoryIterator');
     $method->setCode(Argument::that(function ($value) {
         return strpos($value, '.php') === false;
     }))->shouldBeCalled();
     $this->apply($node);
 }

 function it_should_supply_a_file_for_a_spl_file_object(ClassNode $node, MethodNode $method)
 {
     $node->hasMethod('__construct')->willReturn(true);
     $node->getMethod('__construct')->willReturn($method);
     $node->getParentClass()->willReturn('SplFileObject');
     $method->setCode(Argument::that(function ($value) {
         return strpos($value, '.php') !== false;
     }))->shouldBeCalled();
     $this->apply($node);
 }

 /**
  * Discover Magical API
  *
  * @param ClassNode $node
  */
 public function apply(ClassNode $node)
 {
     $parentClass = $node->getParentClass();
     $reflectionClass = new \ReflectionClass($parentClass);
     $phpdoc = new DocBlock($reflectionClass->getDocComment());
     $tagList = $phpdoc->getTagsByName('method');
     foreach ($tagList as $tag) {
         $methodNode = new MethodNode($tag->getMethodName());
         $methodNode->setStatic($tag->isStatic());
         $node->addMethod($methodNode);
     }
 }

 /**
  * Discover Magical API
  *
  * @param ClassNode $node
  */
 public function apply(ClassNode $node)
 {
     $parentClass = $node->getParentClass();
     $reflectionClass = new \ReflectionClass($parentClass);
     $tagList = $this->tagRetriever->getTagList($reflectionClass);
     foreach ($tagList as $tag) {
         $methodName = $tag->getMethodName();
         if (empty($methodName)) {
             continue;
         }
         if (!$reflectionClass->hasMethod($methodName)) {
             $methodNode = new MethodNode($methodName);
             $methodNode->setStatic($tag->isStatic());
             $node->addMethod($methodNode);
         }
     }
 }

 /**
  * Discover Magical API
  *
  * @param ClassNode $node
  */
 public function apply(ClassNode $node)
 {
     $parentClass = $node->getParentClass();
     $reflectionClass = new \ReflectionClass($parentClass);
     $phpdoc = new DocBlock($reflectionClass->getDocComment());
     $tagList = $phpdoc->getTagsByName('method');
     $interfaces = $reflectionClass->getInterfaces();
     foreach ($interfaces as $interface) {
         $phpdoc = new DocBlock($interface);
         $tagList = array_merge($tagList, $phpdoc->getTagsByName('method'));
     }
     foreach ($tagList as $tag) {
         $methodName = $tag->getMethodName();
         if (!$reflectionClass->hasMethod($methodName)) {
             $methodNode = new MethodNode($tag->getMethodName());
             $methodNode->setStatic($tag->isStatic());
             $node->addMethod($methodNode);
         }
     }
 }

 /**
  * Discover Magical API
  *
  * @param ClassNode $node
  */
 public function apply(ClassNode $node)
 {
     $types = array_filter($node->getInterfaces(), function ($interface) {
         return 0 !== strpos($interface, 'Prophecy\\');
     });
     $types[] = $node->getParentClass();
     foreach ($types as $type) {
         $reflectionClass = new \ReflectionClass($type);
         $tagList = $this->tagRetriever->getTagList($reflectionClass);
         foreach ($tagList as $tag) {
             $methodName = $tag->getMethodName();
             if (empty($methodName)) {
                 continue;
             }
             if (!$reflectionClass->hasMethod($methodName)) {
                 $methodNode = new MethodNode($methodName);
                 $methodNode->setStatic($tag->isStatic());
                 $node->addMethod($methodNode);
             }
         }
     }
 }

    /**
     * @param \Prophecy\Doubler\Generator\Node\ClassNode $class
     */
    function it_wraps_class_in_namespace_if_it_is_namespaced($class)
    {
        $class->getParentClass()->willReturn('stdClass');
        $class->getInterfaces()->willReturn(array('Prophecy\\Doubler\\Generator\\MirroredInterface'));
        $class->getProperties()->willReturn(array());
        $class->getMethods()->willReturn(array());
        $code = $this->generate('My\\Awesome\\CustomClass', $class);
        $expected = <<<'PHP'
namespace My\Awesome {
class CustomClass extends \stdClass implements \Prophecy\Doubler\Generator\MirroredInterface {


}
}
PHP;
        $expected = strtr($expected, array("\r\n" => "\n", "\r" => "\n"));
        $code->shouldBe($expected);
    }

 /**
  * @param \Prophecy\Doubler\Generator\Node\ClassNode $node
  */
 function it_discovers_api_using_phpdoc($node)
 {
     $node->getParentClass()->willReturn('spec\\Prophecy\\Doubler\\ClassPatch\\MagicalApi');
     $node->addMethod(new MethodNode('undefinedMethod'))->shouldBeCalled();
     $this->apply($node);
 }

 /**
  * @param ClassNode $node
  * @return boolean
  */
 private function nodeIsSplFileObject(ClassNode $node)
 {
     $parent = $node->getParentClass();
     return 'SplFileObject' === $parent || is_subclass_of($parent, 'SplFileObject');
 }

 /**
  * @param \Prophecy\Doubler\Generator\Node\ClassNode $node
  */
 function it_supports_nodes_with_derivative_of_SplFileInfo_as_parent_class($node)
 {
     $node->getParentClass()->willReturn('SplFileInfo');
     $this->supports($node)->shouldReturn(true);
 }