PHP DocParser::setImports方法代码示例

 /**
  * Set imports for annotations
  *
  * @param array $imports
  */
 public function setImports(array $imports)
 {
     $convertedImports = array();
     foreach ($imports as $aliasName => $fullName) {
         $convertedImports[strtolower($aliasName)] = $fullName;
     }
     $this->parser->setImports($convertedImports);
 }

 /**
  * {@inheritdoc}
  */
 public function process($context, Result $result, Collection $collection)
 {
     $this->result = $result;
     $this->collection = $collection;
     $this->docParser = new DocParser();
     $this->docParser->setIgnoreNotImportedAnnotations(true);
     $phpdoc = $namespace = false;
     $tokenParser = new TokenParser($context->getFileContent());
     while ($token = $tokenParser->next(false)) {
         if (false === is_array($token)) {
             continue;
         }
         switch ($token[0]) {
             case T_DOC_COMMENT:
                 if ($phpdoc !== false) {
                     $this->processDocComment($phpdoc);
                     $phpdoc = false;
                 }
                 $phpdoc = $token[1];
                 break;
             case T_NAMESPACE:
                 $namespace = $tokenParser->parseNamespace();
                 break;
             case T_USE:
                 // add imports to doc parser to be able to use annotation without FQCN.
                 foreach ($tokenParser->parseUseStatement() as $alias => $target) {
                     if ($target[0] === '\\') {
                         $target = substr($target, 1);
                     }
                     $imports[$alias] = $target;
                 }
                 $this->docParser->setImports($imports);
                 break;
             case T_CLASS:
                 $token = $tokenParser->next(false);
                 $class = $namespace ? $namespace . '\\' . $token[1] : $token[1];
                 $this->dispatchEvent(Events::TOKEN_PHP_CLASS, new Context\PHP\PHPClass($class, $phpdoc), $phpdoc);
                 break;
             case T_VARIABLE:
                 $this->dispatchEvent(Events::TOKEN_PHP_VARIABLE, new Context\PHP\PHPVariable(substr($token[1], 1), isset($class) ? $class : null, $phpdoc), $phpdoc);
                 break;
             case T_FUNCTION:
                 $token = $tokenParser->next(false);
                 if (!is_array($token)) {
                     continue;
                 }
                 $this->dispatchEvent(Events::TOKEN_PHP_FUNCTION, new Context\PHP\PHPFunction($token[1], isset($class) ? $class : null, $phpdoc), $phpdoc);
                 break;
         }
     }
 }

 protected final function getDocParser()
 {
     $docParser = new DocParser();
     $docParser->setImports(array('desc' => 'JMS\\TranslationBundle\\Annotation\\Desc', 'meaning' => 'JMS\\TranslationBundle\\Annotation\\Meaning', 'ignore' => 'JMS\\TranslationBundle\\Annotation\\Ignore'));
     $docParser->setIgnoreNotImportedAnnotations(true);
     return $docParser;
 }

 /**
  * {@inheritDoc}
  */
 public function getMethodAnnotations(ReflectionMethod $method)
 {
     $class = $method->getDeclaringClass();
     $context = 'method ' . $class->getName() . '::' . $method->getName() . '()';
     $this->parser->setTarget(Target::TARGET_METHOD);
     $this->parser->setImports($this->getMethodImports($method));
     $this->parser->setIgnoredAnnotationNames($this->getIgnoredAnnotationNames($class));
     return $this->parser->parse($method->getDocComment(), $context);
 }

 public function testIssueGlobalNamespace()
 {
     $docblock = "@Entity";
     $parser = new DocParser();
     $parser->setImports(array("__NAMESPACE__" => "Doctrine\\Tests\\Common\\Annotations\\Ticket\\Doctrine\\ORM\\Mapping"));
     $annots = $parser->parse($docblock);
     $this->assertEquals(1, count($annots));
     $this->assertInstanceOf("Doctrine\\Tests\\Common\\Annotations\\Ticket\\Doctrine\\ORM\\Mapping\\Entity", $annots[0]);
 }

 public function __construct($docParser = null)
 {
     if ($docParser === null) {
         $docParser = new DocParser();
         $docParser->setIgnoreNotImportedAnnotations(true);
         $docParser->setImports(['swg' => 'Swagger\\Annotations']);
         // Use @SWG\* for swagger annotations.
     }
     $this->docParser = $docParser;
 }

 private function extract($directory)
 {
     $twig = new \Twig_Environment();
     $twig->addExtension(new SymfonyTranslationExtension($translator = new IdentityTranslator(new MessageSelector())));
     $twig->addExtension(new TranslationExtension($translator));
     $docParser = new DocParser();
     $docParser->setImports(array('desc' => 'JMS\\TranslationBundle\\Annotation\\Desc', 'meaning' => 'JMS\\TranslationBundle\\Annotation\\Meaning', 'ignore' => 'JMS\\TranslationBundle\\Annotation\\Ignore'));
     $docParser->setIgnoreNotImportedAnnotations(true);
     $factory = new ClassMetadataFactory(new AnnotationLoader(new AnnotationReader()));
     $extractor = new FileExtractor($twig, new NullLogger(), array(new DefaultPhpFileExtractor($docParser), new TranslationContainerExtractor(), new TwigFileExtractor($twig), new ValidationExtractor($factory), new FormExtractor($docParser)));
     $extractor->setDirectory($directory);
     return $extractor->extract();
 }

 public function scanForAnnotations(string $docBlock, $context, array $imports) : Annotations
 {
     // Hack to ensure an attempt to autoload an annotation class is made
     AnnotationRegistry::registerLoader(function ($class) {
         return (bool) class_exists($class);
     });
     $imports = array_combine(array_map(function ($string) {
         return strtolower($string);
     }, array_keys($imports)), array_values($imports));
     $parser = new DocParser();
     $parser->setIgnoreNotImportedAnnotations(true);
     $parser->setImports($imports);
     return new Annotations($parser->parse($docBlock, $context));
 }

 /**
  * @group performance
  */
 public function testDocParsePerformance()
 {
     $imports = array('ignorephpdoc' => 'Annotations\\Annotation\\IgnorePhpDoc', 'ignoreannotation' => 'Annotations\\Annotation\\IgnoreAnnotation', 'route' => 'Doctrine\\Tests\\Common\\Annotations\\Fixtures\\Annotation\\Route', 'template' => 'Doctrine\\Tests\\Common\\Annotations\\Fixtures\\Annotation\\Template', '__NAMESPACE__' => 'Doctrine\\Tests\\Common\\Annotations\\Fixtures');
     $ignored = array('access', 'author', 'copyright', 'deprecated', 'example', 'ignore', 'internal', 'link', 'see', 'since', 'tutorial', 'version', 'package', 'subpackage', 'name', 'global', 'param', 'return', 'staticvar', 'static', 'var', 'throws', 'inheritdoc');
     $method = $this->getMethod();
     $methodComment = $method->getDocComment();
     $classComment = $method->getDeclaringClass()->getDocComment();
     $time = microtime(true);
     for ($i = 0, $c = 200; $i < $c; $i++) {
         $parser = new DocParser();
         $parser->setImports($imports);
         $parser->setIgnoredAnnotationNames($ignored);
         $parser->setIgnoreNotImportedAnnotations(true);
         $parser->parse($methodComment);
         $parser->parse($classComment);
     }
     $time = microtime(true) - $time;
     $this->printResults('doc-parser', $time, $c);
 }

 private function extract($file, FormExtractor $extractor = null)
 {
     if (!is_file($file = __DIR__ . '/Fixture/' . $file)) {
         throw new RuntimeException(sprintf('The file "%s" does not exist.', $file));
     }
     $file = new \SplFileInfo($file);
     if (null === $extractor) {
         $docParser = new DocParser();
         $docParser->setImports(array('desc' => 'JMS\\TranslationBundle\\Annotation\\Desc', 'meaning' => 'JMS\\TranslationBundle\\Annotation\\Meaning', 'ignore' => 'JMS\\TranslationBundle\\Annotation\\Ignore'));
         $docParser->setIgnoreNotImportedAnnotations(true);
         $extractor = new FormExtractor($docParser);
     }
     $lexer = new \PHPParser_Lexer(file_get_contents($file));
     $parser = new \PHPParser_Parser();
     $ast = $parser->parse($lexer);
     $catalogue = new MessageCatalogue();
     $extractor->visitPhpFile($file, $catalogue, $ast);
     return $catalogue;
 }

 private function extract($directory)
 {
     $twig = new \Twig_Environment();
     $twig->addExtension(new SymfonyTranslationExtension($translator = new IdentityTranslator(new MessageSelector())));
     $twig->addExtension(new TranslationExtension($translator));
     $loader = new \Twig_Loader_Filesystem(realpath(__DIR__ . "/Fixture/SimpleTest/Resources/views/"));
     $twig->setLoader($loader);
     $docParser = new DocParser();
     $docParser->setImports(array('desc' => 'JMS\\TranslationBundle\\Annotation\\Desc', 'meaning' => 'JMS\\TranslationBundle\\Annotation\\Meaning', 'ignore' => 'JMS\\TranslationBundle\\Annotation\\Ignore'));
     $docParser->setIgnoreNotImportedAnnotations(true);
     //use correct factory class depending on whether using Symfony 2 or 3
     if (class_exists('Symfony\\Component\\Validator\\Mapping\\Factory\\LazyLoadingMetadataFactory')) {
         $metadataFactoryClass = 'Symfony\\Component\\Validator\\Mapping\\Factory\\LazyLoadingMetadataFactory';
     } else {
         $metadataFactoryClass = 'Symfony\\Component\\Validator\\Mapping\\ClassMetadataFactory';
     }
     $factory = new $metadataFactoryClass(new AnnotationLoader(new AnnotationReader()));
     $extractor = new FileExtractor($twig, new NullLogger(), array(new DefaultPhpFileExtractor($docParser), new TranslationContainerExtractor(), new TwigFileExtractor($twig), new ValidationExtractor($factory), new FormExtractor($docParser)));
     $extractor->setDirectory($directory);
     return $extractor->extract();
 }

 protected function setUp()
 {
     $docParser = new DocParser();
     $docParser->setImports(array('desc' => 'JMS\\TranslationBundle\\Annotation\\Desc', 'meaning' => 'JMS\\TranslationBundle\\Annotation\\Meaning', 'ignore' => 'JMS\\TranslationBundle\\Annotation\\Ignore'));
     $docParser->setIgnoreNotImportedAnnotations(true);
     $this->extractor = new FormExtractor($docParser);
 }

 /**
  * Collects parsing metadata for a given annotation class
  *
  * @param string $name The annotation name
  */
 private function collectAnnotationMetadata($name)
 {
     if (self::$metadataParser == null) {
         self::$metadataParser = new self();
         self::$metadataParser->setTarget(Target::TARGET_CLASS);
         self::$metadataParser->setIgnoreNotImportedAnnotations(true);
         self::$metadataParser->setImports(array('target' => 'Doctrine\\Common\\Annotations\\Annotation\\Target', 'attribute' => 'Doctrine\\Common\\Annotations\\Annotation\\Attribute', 'attributes' => 'Doctrine\\Common\\Annotations\\Annotation\\Attributes'));
         AnnotationRegistry::registerFile(__DIR__ . '/Annotation/Target.php');
         AnnotationRegistry::registerFile(__DIR__ . '/Annotation/Attribute.php');
         AnnotationRegistry::registerFile(__DIR__ . '/Annotation/Attributes.php');
     }
     $class = new \ReflectionClass($name);
     $docComment = $class->getDocComment();
     // Sets default values for annotation metadata
     $metadata = array('default_property' => null, 'has_constructor' => null !== ($constructor = $class->getConstructor()) && $constructor->getNumberOfParameters() > 0, 'properties' => array(), 'property_types' => array(), 'attribute_types' => array(), 'targets_literal' => null, 'targets' => Target::TARGET_ALL, 'is_annotation' => false !== strpos($docComment, '@Annotation'));
     // verify that the class is really meant to be an annotation
     if ($metadata['is_annotation']) {
         foreach (self::$metadataParser->parse($docComment, 'class @' . $name) as $annotation) {
             if ($annotation instanceof Target) {
                 $metadata['targets'] = $annotation->targets;
                 $metadata['targets_literal'] = $annotation->literal;
             } elseif ($annotation instanceof Attributes) {
                 foreach ($annotation->value as $attrib) {
                     // handle internal type declaration
                     $type = isset(self::$typeMap[$attrib->type]) ? self::$typeMap[$attrib->type] : $attrib->type;
                     // handle the case if the property type is mixed
                     if ('mixed' !== $type) {
                         // Checks if the property has array<type>
                         if (false !== ($pos = strpos($type, '<'))) {
                             $arrayType = substr($type, $pos + 1, -1);
                             $type = 'array';
                             if (isset(self::$typeMap[$arrayType])) {
                                 $arrayType = self::$typeMap[$arrayType];
                             }
                             $metadata['attribute_types'][$attrib->name]['array_type'] = $arrayType;
                         }
                         $metadata['attribute_types'][$attrib->name]['type'] = $type;
                         $metadata['attribute_types'][$attrib->name]['value'] = $attrib->type;
                         $metadata['attribute_types'][$attrib->name]['required'] = $attrib->required;
                     }
                 }
             }
         }
         // if not has a constructor will inject values into public properties
         if (false === $metadata['has_constructor']) {
             // collect all public properties
             foreach ($class->getProperties(\ReflectionProperty::IS_PUBLIC) as $property) {
                 $metadata['properties'][$property->name] = $property->name;
                 // checks if the property has @var annotation
                 if (false !== ($propertyComment = $property->getDocComment()) && false !== strpos($propertyComment, '@var') && preg_match('/@var\\s+([^\\s]+)/', $propertyComment, $matches)) {
                     // literal type declaration
                     $value = $matches[1];
                     // handle internal type declaration
                     $type = isset(self::$typeMap[$value]) ? self::$typeMap[$value] : $value;
                     // handle the case if the property type is mixed
                     if ('mixed' !== $type) {
                         // Checks if the property has @var array<type> annotation
                         if (false !== ($pos = strpos($type, '<'))) {
                             $arrayType = substr($type, $pos + 1, -1);
                             $type = 'array';
                             if (isset(self::$typeMap[$arrayType])) {
                                 $arrayType = self::$typeMap[$arrayType];
                             }
                             $metadata['attribute_types'][$property->name]['array_type'] = $arrayType;
                         }
                         $metadata['attribute_types'][$property->name]['type'] = $type;
                         $metadata['attribute_types'][$property->name]['value'] = $value;
                         $metadata['attribute_types'][$property->name]['required'] = false !== strpos($propertyComment, '@Required');
                     }
                 }
             }
             // choose the first property as default property
             $metadata['default_property'] = reset($metadata['properties']);
         }
     }
     self::$annotationMetadata[$name] = $metadata;
 }

 public function createTestParser()
 {
     $parser = new DocParser();
     $parser->setIgnoreNotImportedAnnotations(true);
     $parser->setImports(array('name' => 'Doctrine\\Tests\\Common\\Annotations\\Name', '__NAMESPACE__' => 'Doctrine\\Tests\\Common\\Annotations'));
     return $parser;
 }

 /**
  * Collects parsing metadata for a given annotation class
  *
  * @param string $name The annotation name
  *
  * @return void
  */
 private function collectAnnotationMetadata($name)
 {
     if (self::$metadataParser === null) {
         self::$metadataParser = new self();
         self::$metadataParser->setIgnoreNotImportedAnnotations(true);
         self::$metadataParser->setIgnoredAnnotationNames($this->ignoredAnnotationNames);
         self::$metadataParser->setImports(array('enum' => 'Doctrine\\Common\\Annotations\\Annotation\\Enum', 'target' => 'Doctrine\\Common\\Annotations\\Annotation\\Target', 'attribute' => 'Doctrine\\Common\\Annotations\\Annotation\\Attribute', 'attributes' => 'Doctrine\\Common\\Annotations\\Annotation\\Attributes'));
         AnnotationRegistry::registerFile(__DIR__ . '/Annotation/Enum.php');
         AnnotationRegistry::registerFile(__DIR__ . '/Annotation/Target.php');
         AnnotationRegistry::registerFile(__DIR__ . '/Annotation/Attribute.php');
         AnnotationRegistry::registerFile(__DIR__ . '/Annotation/Attributes.php');
     }
     $class = new \ReflectionClass($name);
     $docComment = $class->getDocComment();
     // Sets default values for annotation metadata
     $metadata = array('default_property' => null, 'has_constructor' => null !== ($constructor = $class->getConstructor()) && $constructor->getNumberOfParameters() > 0, 'properties' => array(), 'property_types' => array(), 'attribute_types' => array(), 'targets_literal' => null, 'targets' => Target::TARGET_ALL, 'is_annotation' => false !== strpos($docComment, '@Annotation'));
     // verify that the class is really meant to be an annotation
     if ($metadata['is_annotation']) {
         self::$metadataParser->setTarget(Target::TARGET_CLASS);
         foreach (self::$metadataParser->parse($docComment, 'class @' . $name) as $annotation) {
             if ($annotation instanceof Target) {
                 $metadata['targets'] = $annotation->targets;
                 $metadata['targets_literal'] = $annotation->literal;
                 continue;
             }
             if ($annotation instanceof Attributes) {
                 foreach ($annotation->value as $attribute) {
                     $this->collectAttributeTypeMetadata($metadata, $attribute);
                 }
             }
         }
         // if not has a constructor will inject values into public properties
         if (false === $metadata['has_constructor']) {
             // collect all public properties
             foreach ($class->getProperties(\ReflectionProperty::IS_PUBLIC) as $property) {
                 $metadata['properties'][$property->name] = $property->name;
                 if (false === ($propertyComment = $property->getDocComment())) {
                     continue;
                 }
                 $attribute = new Attribute();
                 $attribute->required = false !== strpos($propertyComment, '@Required');
                 $attribute->name = $property->name;
                 $attribute->type = false !== strpos($propertyComment, '@var') && preg_match('/@var\\s+([^\\s]+)/', $propertyComment, $matches) ? $matches[1] : 'mixed';
                 $this->collectAttributeTypeMetadata($metadata, $attribute);
                 // checks if the property has @Enum
                 if (false !== strpos($propertyComment, '@Enum')) {
                     $context = 'property ' . $class->name . "::\$" . $property->name;
                     self::$metadataParser->setTarget(Target::TARGET_PROPERTY);
                     foreach (self::$metadataParser->parse($propertyComment, $context) as $annotation) {
                         if (!$annotation instanceof Enum) {
                             continue;
                         }
                         $metadata['enum'][$property->name]['value'] = $annotation->value;
                         $metadata['enum'][$property->name]['literal'] = !empty($annotation->literal) ? $annotation->literal : $annotation->value;
                     }
                 }
             }
             // choose the first property as default property
             $metadata['default_property'] = reset($metadata['properties']);
         }
     }
     self::$annotationMetadata[$name] = $metadata;
 }