PHP Node::isAbstract方法代码示例

 function enterNode(\PhpParser\Node $node)
 {
     if ($node instanceof \PhpParser\Node\Stmt\Namespace_) {
         $this->addNamespace(array('namespace' => $node->name->toString(), 'line' => $node->getLine(), 'file' => $this->file));
     }
     if ($node instanceof \PhpParser\Node\Stmt\Use_) {
         foreach ($node->uses as $use) {
             $this->addUse(array('name' => $use->name, 'alias' => $use->alias));
         }
     }
     if ($node instanceof \PhpParser\Node\Stmt\Class_) {
         $this->addClass(array('name' => $node->name, 'extends' => $node->extends, 'implements' => $node->implements, 'abstract' => $node->isAbstract(), 'final' => $node->isFinal(), 'comment' => $node->getDocComment(), 'doc' => $this->doc_comment_parser->parse($node->getDocComment()), 'line' => $node->getLine(), 'file' => $this->file));
     }
     if ($node instanceof \PhpParser\Node\Stmt\Interface_) {
         $this->addInterface(array('name' => $node->name, 'extends' => $node->extends, 'comment' => $node->getDocComment(), 'doc' => $this->doc_comment_parser->parse($node->getDocComment()), 'line' => $node->getLine(), 'file' => $this->file));
     }
     if ($node instanceof \PhpParser\Node\Stmt\ClassMethod) {
         $this->addClassMethod(array('byRef' => $node->byRef, 'name' => $node->name, 'params' => $node->params, 'returnType' => $node->returnType, 'public' => $node->isPublic(), 'protected' => $node->isProtected(), 'private' => $node->isPrivate(), 'abstract' => $node->isAbstract(), 'final' => $node->isFinal(), 'static' => $node->isStatic(), 'comment' => $node->getDocComment(), 'doc' => $this->doc_comment_parser->parse($node->getDocComment()), 'line' => $node->getLine(), 'file' => $this->file));
     }
     if ($node instanceof \PhpParser\Node\Stmt\Property) {
         $this->last_property = $node;
     }
     if ($node instanceof \PhpParser\Node\Stmt\PropertyProperty) {
         $this->addClassProperty(array('name' => $node->name, 'default' => $node->default, 'public' => $this->last_property->isPublic(), 'protected' => $this->last_property->isProtected(), 'private' => $this->last_property->isPrivate(), 'static' => $this->last_property->isStatic(), 'comment' => $node->getDocComment(), 'doc' => $this->doc_comment_parser->parse($node->getDocComment()), 'line' => $node->getLine(), 'file' => $this->file));
     }
     // $this->logger->info(get_class($node));
 }

 /**
  * @throws RuntimeException if the node is a non-abstract class with abstract methods.
  *
  * @param Node $node
  */
 public function leaveNode(Node $node)
 {
     if ($node instanceof ClassStmt) {
         $count = count($this->abstractMethods);
         if ($count > 0 && !$node->isAbstract()) {
             throw new FatalErrorException(sprintf('Class %s contains %d abstract method%s must therefore be declared abstract or implement the remaining methods (%s)', $node->name, $count, $count === 0 ? '' : 's', implode(', ', $this->abstractMethods)));
         }
     }
 }

 /**
  * Initialize a new User Class
  *
  * @param Node $node
  *
  * @return void
  */
 private function initUserClass(Node $node)
 {
     if (isset($node->namespacedName) && $node->namespacedName instanceof Node\Name && $node->namespacedName->isQualified()) {
         $min = '5.3.0';
     } else {
         if ($node->isAbstract() || $node->isFinal()) {
             $min = '5.0.0';
         } else {
             $min = '4.0.0';
         }
     }
     $max = '';
     $element = 'classes';
     $name = (string) $node->namespacedName;
     $this->contextStack[] = array($element, $name);
     // parent class
     if (isset($node->extends)) {
         $name = (string) $node->extends;
         $group = $this->findObjectType($name);
         $versions = $this->metrics[$group][$name];
         if ('user' == $versions['ext.name']) {
             if ($node->extends->isFullyQualified()) {
                 if (count($node->extends->parts) === 1) {
                     // PHP4 syntax (global namespace)
                     $versions = array('php.min' => '4.0.0');
                 } else {
                     $versions = array('php.min' => '5.3.0');
                 }
             } else {
                 $versions = array();
             }
         }
         $this->updateElementVersion('classes', $name, $versions);
         ++$this->metrics['classes'][$name]['matches'];
         if ('objects' == $group) {
             // now object is categorized, remove from temp queue
             unset($this->metrics[$group][$name]);
         }
         $this->updateLocalVersions($versions);
     }
     // interfaces
     foreach ($node->implements as $interface) {
         $name = (string) $interface;
         $group = $this->findObjectType($name);
         $versions = $this->metrics[$group][$name];
         $this->updateElementVersion('interfaces', $name, $versions);
         ++$this->metrics['interfaces'][$name]['matches'];
         if ('objects' == $group) {
             // now object is categorized, remove from temp queue
             unset($this->metrics[$group][$name]);
         }
         $this->updateLocalVersions($versions);
     }
     $name = (string) $node->namespacedName;
     $group = $this->findObjectType($name);
     $versions = $this->metrics[$group][$name];
     if ('objects' == $group) {
         // now object is categorized, remove from temp queue
         unset($this->metrics[$group][$name]);
     }
     $versions = array_merge($versions, array('php.min' => $min, 'php.max' => $max, 'declared' => true));
     $this->updateLocalVersions($versions);
 }

 public function enterNode(Node $node)
 {
     if ($node instanceof Node\Stmt\Namespace_) {
         /**
          * Namespace declaration.
          *
          *  namespace <name>;
          */
         $this->current_namespace_name = implode("\\", $node->name->parts);
     } elseif ($node instanceof Node\Stmt\Use_) {
         /**
          * Namespace reference.
          *
          *  use <name> [ as <alias> ];
          */
         foreach ($node->uses as $use_node) {
             $this->alias_namespace[$use_node->alias] = implode("\\", $use_node->name->parts);
         }
     } elseif ($node instanceof Node\Stmt\ClassLike) {
         /**
          * Class-like declaration.
          * This is a hierarchical dependency.
          *
          *  class <name> [ extends <name> ] [ implements <name> ] { ... }
          */
         $this->current_class_name = $this->get_namespace_prefixed($node->name);
         // Node: Class
         $node_key = $this->get_namespace_prefixed($node->name);
         $node_def = ['namespace' => $this->current_namespace_name, 'name' => $node->name, 'canonical_name' => $node_key, 'file' => $this->current_file_path, 'stereotype' => ''];
         if ($node instanceof Node\Stmt\Class_) {
             // Class
             $node_def['type'] = 'class';
             if ($node->isAbstract()) {
                 $node_def['stereotype'] = 'abstract';
             }
             $implements = $node->implements;
             $extends = $node->extends;
         } elseif ($node instanceof Node\Stmt\Interface_) {
             // Interface
             $node_def['type'] = 'interface';
             $node_def['stereotype'] = 'interface';
             $implements = $node->extends;
             $extends = null;
         } elseif ($node instanceof Node\Stmt\Trait_) {
             // Trait
             $node_def['type'] = 'trait';
             $node_def['stereotype'] = 'trait';
             $implements = [];
             $extends = null;
         } else {
             // Unsupported class type
             error_log('Skipping unsupported class node type: ' . get_class($node));
             return;
         }
         $this->nodes[$node_key] = $node_def;
         // Edges: Implements (interfaces)
         foreach ($implements as $name_node) {
             $this->add_edge($node_key, $this->get_full_name($name_node), EdgeType::REALIZATION);
         }
         // Edges: Extends (superclass)
         if ($extends) {
             $this->add_edge($node_key, $this->get_full_name($extends), EdgeType::GENERALIZATION);
         }
     } elseif ($node instanceof Node\Expr\New_) {
         /**
          * Class instantiation.
          * This is a dependency.
          *
          *  [ <name> = ] new <name> [ (...) ];
          */
         $this->add_dependency_edge($node);
     } elseif ($node instanceof Node\Expr\StaticCall) {
         /**
          * Static method call.
          * This is a dependency.
          *
          *  <class>::<method_name>(...)
          */
         $this->add_dependency_edge($node);
     } elseif ($node instanceof Node\Expr\StaticPropertyFetch) {
         /**
          * Static property reference.
          * This is a dependency.
          *
          *  <class>::$<property_name>
          */
         $this->add_dependency_edge($node);
     } elseif ($node instanceof Node\Expr\ClassConstFetch) {
         /**
          * Class constant property fetch (also used for <class_name>::class fetches).
          * This is a dependency.
          *
          *  <class>::<const_name>
          */
         $this->add_dependency_edge($node);
     }
 }

 protected function compareModifier(Node $a, Node $b)
 {
     // Within same visibility, goes first
     $cmp = strcmp($b->isStatic(), $a->isStatic());
     if ($cmp !== 0) {
         return $cmp;
     }
     // Within same visibility and ess, abstract goes first
     if ($a instanceof ClassMethod) {
         $cmp = strcmp($b->isAbstract(), $a->isAbstract());
     }
     return $cmp;
 }