comparison vendor/doctrine/annotations/lib/Doctrine/Common/Annotations/DocParser.php @ 12:7a779792577d

Update Drupal core to v8.4.5 (via Composer)

     private $lexer;
 
     /**
      * Current target context.
      *
-     * @var string
+     * @var integer
      */
     private $target;
 
     /**
      * Doc parser used to collect annotation target.

     private $ignoreNotImportedAnnotations = false;
 
     /**
      * An array of default namespaces if operating in simple mode.
      *
-     * @var array
+     * @var string[]
      */
     private $namespaces = array();
 
     /**
      * A list with annotations that are not causing exceptions when not resolved to an annotation class.
      *
      * The names must be the raw names as used in the class, not the fully qualified
      * class names.
      *
-     * @var array
+     * @var bool[] indexed by annotation name
      */
     private $ignoredAnnotationNames = array();
+
+    /**
+     * A list with annotations in namespaced format
+     * that are not causing exceptions when not resolved to an annotation class.
+     *
+     * @var bool[] indexed by namespace name
+     */
+    private $ignoredAnnotationNamespaces = array();
 
     /**
      * @var string
      */
     private $context = '';

      * Sets the annotation names that are ignored during the parsing process.
      *
      * The names are supposed to be the raw names as used in the class, not the
      * fully qualified class names.
      *
-     * @param array $names
+     * @param bool[] $names indexed by annotation name
      *
      * @return void
      */
     public function setIgnoredAnnotationNames(array $names)
     {
         $this->ignoredAnnotationNames = $names;
     }
 
     /**
+     * Sets the annotation namespaces that are ignored during the parsing process.
+     *
+     * @param bool[] $ignoredAnnotationNamespaces indexed by annotation namespace name
+     *
+     * @return void
+     */
+    public function setIgnoredAnnotationNamespaces($ignoredAnnotationNamespaces)
+    {
+        $this->ignoredAnnotationNamespaces = $ignoredAnnotationNamespaces;
+    }
+
+    /**
      * Sets ignore on not-imported annotations.
      *
      * @param boolean $bool
      *
      * @return void

     }
 
     /**
      * Sets the default namespaces.
      *
-     * @param array $namespace
+     * @param string $namespace
      *
      * @return void
      *
      * @throws \RuntimeException
      */

     {
         $pos = 0;
 
         // search for first valid annotation
         while (($pos = strpos($input, '@', $pos)) !== false) {
-            // if the @ is preceded by a space or * it is valid
-            if ($pos === 0 || $input[$pos - 1] === ' ' || $input[$pos - 1] === '*') {
+            $preceding = substr($input, $pos - 1, 1);
+
+            // if the @ is preceded by a space, a tab or * it is valid
+            if ($pos === 0 || $preceding === ' ' || $preceding === '*' || $preceding === "\t") {
                 return $pos;
             }
 
             $pos++;
         }

         // only process names which are not fully qualified, yet
         // fully qualified names must start with a \
         $originalName = $name;
 
         if ('\\' !== $name[0]) {
-            $alias = (false === $pos = strpos($name, '\\'))? $name : substr($name, 0, $pos);
+            $pos = strpos($name, '\\');
+            $alias = (false === $pos)? $name : substr($name, 0, $pos);
             $found = false;
+            $loweredAlias = strtolower($alias);
 
             if ($this->namespaces) {
                 foreach ($this->namespaces as $namespace) {
                     if ($this->classExists($namespace.'\\'.$name)) {
                         $name = $namespace.'\\'.$name;
                         $found = true;
                         break;
                     }
                 }
-            } elseif (isset($this->imports[$loweredAlias = strtolower($alias)])) {
+            } elseif (isset($this->imports[$loweredAlias])) {
                 $found = true;
                 $name  = (false !== $pos)
                     ? $this->imports[$loweredAlias] . substr($name, $pos)
                     : $this->imports[$loweredAlias];
             } elseif ( ! isset($this->ignoredAnnotationNames[$name])

             } elseif (! isset($this->ignoredAnnotationNames[$name]) && $this->classExists($name)) {
                 $found = true;
             }
 
             if ( ! $found) {
-                if ($this->ignoreNotImportedAnnotations || isset($this->ignoredAnnotationNames[$name])) {
+                if ($this->isIgnoredAnnotation($name)) {
                     return false;
                 }
 
                 throw AnnotationException::semanticalError(sprintf('The annotation "@%s" in %s was never imported. Did you maybe forget to add a "use" statement for this annotation?', $name, $this->context));
             }
         }
+
+        $name = ltrim($name,'\\');
 
         if ( ! $this->classExists($name)) {
             throw AnnotationException::semanticalError(sprintf('The annotation "@%s" in %s does not exist, or could not be auto-loaded.', $name, $this->context));
         }
 

             $this->collectAnnotationMetadata($name);
         }
 
         // verify that the class is really meant to be an annotation and not just any ordinary class
         if (self::$annotationMetadata[$name]['is_annotation'] === false) {
-            if (isset($this->ignoredAnnotationNames[$originalName])) {
+            if ($this->ignoreNotImportedAnnotations || isset($this->ignoredAnnotationNames[$originalName])) {
                 return false;
             }
 
             throw AnnotationException::semanticalError(sprintf('The class "%s" is not annotated with @Annotation. Are you sure this class can be used as annotation? If so, then you need to add @Annotation to the _class_ doc comment of "%s". If it is indeed no annotation, then you need to add @IgnoreAnnotation("%s") to the _class_ doc comment of %s.', $name, $name, $originalName, $this->context));
         }

         $identifier = $this->Identifier();
 
         if ( ! defined($identifier) && false !== strpos($identifier, '::') && '\\' !== $identifier[0]) {
             list($className, $const) = explode('::', $identifier);
 
-            $alias = (false === $pos = strpos($className, '\\')) ? $className : substr($className, 0, $pos);
+            $pos = strpos($className, '\\');
+            $alias = (false === $pos) ? $className : substr($className, 0, $pos);
             $found = false;
+            $loweredAlias = strtolower($alias);
 
             switch (true) {
                 case !empty ($this->namespaces):
                     foreach ($this->namespaces as $ns) {
                         if (class_exists($ns.'\\'.$className) || interface_exists($ns.'\\'.$className)) {

                              break;
                         }
                     }
                     break;
 
-                case isset($this->imports[$loweredAlias = strtolower($alias)]):
+                case isset($this->imports[$loweredAlias]):
                     $found     = true;
                     $className = (false !== $pos)
                         ? $this->imports[$loweredAlias] . substr($className, $pos)
                         : $this->imports[$loweredAlias];
                     break;

 
     /**
      * FieldAssignment ::= FieldName "=" PlainValue
      * FieldName ::= identifier
      *
-     * @return array
+     * @return \stdClass
      */
     private function FieldAssignment()
     {
         $this->match(DocLexer::T_IDENTIFIER);
         $fieldName = $this->lexer->token['value'];

             return array($key, $this->PlainValue());
         }
 
         return array(null, $this->Value());
     }
+
+    /**
+     * Checks whether the given $name matches any ignored annotation name or namespace
+     *
+     * @param string $name
+     *
+     * @return bool
+     */
+    private function isIgnoredAnnotation($name)
+    {
+        if ($this->ignoreNotImportedAnnotations || isset($this->ignoredAnnotationNames[$name])) {
+            return true;
+        }
+
+        foreach (array_keys($this->ignoredAnnotationNamespaces) as $ignoredAnnotationNamespace) {
+            $ignoredAnnotationNamespace = rtrim($ignoredAnnotationNamespace, '\\') . '\\';
+
+            if (0 === stripos(rtrim($name, '\\') . '\\', $ignoredAnnotationNamespace)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
 }