Make getNamespacedId protected instead of private

lib/Doctrine/Common/Annotations/AnnotationReader.php

@@ -68,6 +68,8 @@ final class AnnotationReader implements Reader
         'codeCoverageIgnore' => true, 'codeCoverageIgnoreStart' => true, 'codeCoverageIgnoreEnd' => true,
         'Required' => true, 'Attribute' => true, 'Attributes' => true,
         'Target' => true, 'SuppressWarnings' => true,
+        'ingroup' => true, 'code' => true, 'endcode' => true,
+        'package_version' => true,
     );
 
     /**

lib/Doctrine/Common/Annotations/SimpleAnnotationReader.php

@@ -68,7 +68,6 @@ public function addNamespace($namespace)
      */
     public function getClassAnnotations(\ReflectionClass $class)
     {
-        $this->parser->setTarget(Target::TARGET_CLASS);
         return $this->parser->parse($class->getDocComment(), 'class '.$class->getName());
     }
 
@@ -81,7 +80,6 @@ public function getClassAnnotations(\ReflectionClass $class)
      */
     public function getMethodAnnotations(\ReflectionMethod $method)
     {
-        $this->parser->setTarget(Target::TARGET_METHOD);
         return $this->parser->parse($method->getDocComment(), 'method '.$method->getDeclaringClass()->name.'::'.$method->getName().'()');
     }
 
@@ -94,7 +92,6 @@ public function getMethodAnnotations(\ReflectionMethod $method)
      */
     public function getPropertyAnnotations(\ReflectionProperty $property)
     {
-        $this->parser->setTarget(Target::TARGET_PROPERTY);
         return $this->parser->parse($property->getDocComment(), 'property '.$property->getDeclaringClass()->name.'::$'.$property->getName());
     }
 

lib/Doctrine/Common/Cache/CacheProvider.php

@@ -129,7 +129,7 @@ public function deleteAll()
      * @param string $id  The id to namespace
      * @return string $id The namespaced id
      */
-    private function getNamespacedId($id)
+    protected function getNamespacedId($id)
     {
         $namespaceCacheKey = sprintf(self::DOCTRINE_NAMESPACE_CACHEKEY, $this->namespace);
         $namespaceVersion  = ($this->doContains($namespaceCacheKey)) ? $this->doFetch($namespaceCacheKey) : 1;

lib/Doctrine/Common/Cache/MemcacheCache.php

@@ -82,6 +82,9 @@ protected function doContains($id)
      */
     protected function doSave($id, $data, $lifeTime = 0)
     {
+        if ($lifeTime > 30 * 24 * 3600) {
+            $lifeTime = time() + $lifeTime;
+        }
         return $this->memcache->set($id, $data, 0, (int) $lifeTime);
     }
 
@@ -115,4 +118,4 @@ protected function doGetStats()
             Cache::STATS_MEMORY_AVAILIABLE  => $stats['limit_maxbytes'],
         );
     }
-}
+}

lib/Doctrine/Common/Cache/MemcachedCache.php

@@ -82,6 +82,9 @@ protected function doContains($id)
      */
     protected function doSave($id, $data, $lifeTime = 0)
     {
+        if ($lifeTime > 30 * 24 * 3600) {
+            $lifeTime = time() + $lifeTime;
+        }
         return $this->memcached->set($id, $data, (int) $lifeTime);
     }
 
@@ -118,4 +121,4 @@ protected function doGetStats()
             Cache::STATS_MEMORY_AVAILIABLE  => $stats['limit_maxbytes'],
         );
     }
-}
+}

lib/Doctrine/Common/Persistence/AbstractManagerRegistry.php

@@ -155,6 +155,12 @@ public function getManager($name = null)
      */
     public function getManagerForClass($class)
     {
+        // Check for namespace alias
+        if (strpos($class, ':') !== false) {
+            list($namespaceAlias, $simpleClassName) = explode(':', $class);
+            $class = $this->getAliasNamespace($namespaceAlias) . '\\' . $simpleClassName;
+        }
+
         $proxyClass = new \ReflectionClass($class);
         if ($proxyClass->implementsInterface($this->proxyInterfaceName)) {
             $class = $proxyClass->getParentClass()->getName();

lib/Doctrine/Common/Version.php

@@ -36,7 +36,7 @@ class Version
     /**
      * Current Doctrine Version
      */
-    const VERSION = '2.2.0-DEV';
+    const VERSION = '2.2.4';
 
     /**
      * Compares a Doctrine version with the current one.

tests/Doctrine/Tests/Common/Annotations/AbstractReaderTest.php

@@ -311,6 +311,21 @@ public function testInvalidAnnotationUsageButIgnoredClass()
         $this->assertEquals(2, count($annots));
     }
 
+    /**
+     * @group DDC-1660
+     * @group regression
+     */
+    public function testInvalidAnnotationButIgnored()
+    {
+        $reader = $this->getReader();
+        $class  = new \ReflectionClass('Doctrine\Tests\Common\Annotations\Fixtures\ClassDDC1660');
+
+        $this->assertTrue(class_exists('Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Version'));
+        $this->assertCount(0, $reader->getClassAnnotations($class));
+        $this->assertCount(0, $reader->getMethodAnnotations($class->getMethod('bar')));
+        $this->assertCount(0, $reader->getPropertyAnnotations($class->getProperty('foo')));
+    }
+
     abstract protected function getReader();
 }
 

tests/Doctrine/Tests/Common/Annotations/Fixtures/Annotation/Version.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures\Annotation;
+
+/**
+ * @Annotation
+ * @Target("PROPERTY")
+ */
+final class Version
+{
+}

tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassDDC1660.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+/**
+ * @since 2.0
+ * @version $Id: SomeEntityClass.php 509 2012-02-03 09:38:48Z mf $
+ */
+class ClassDDC1660
+{
+
+    /**
+     * @var     string
+     * @since   2.0
+     * @version 1
+     */
+    public $foo;
+
+    /**
+     * @param   string
+     * @return  string
+     * @since   2.0
+     * @version 1
+     */
+    public function bar($param)
+    {
+        return null;
+    }
+
+}

tests/Doctrine/Tests/Common/Annotations/SimpleAnnotationReaderTest.php

@@ -24,6 +24,42 @@ public function testImportDetectsNonExistentAnnotation()
         parent::testImportDetectsNonExistentAnnotation();
     }
 
+    /**
+     * Contrary to the behavior of the default annotation reader, we do just ignore
+     * these in the simple annotation reader (so, no expected exception here).
+     */
+    public function testClassWithInvalidAnnotationTargetAtClassDocBlock()
+    {
+        parent::testClassWithInvalidAnnotationTargetAtClassDocBlock();
+    }
+
+    /**
+     * Contrary to the behavior of the default annotation reader, we do just ignore
+     * these in the simple annotation reader (so, no expected exception here).
+     */
+    public function testClassWithInvalidAnnotationTargetAtPropertyDocBlock()
+    {
+        parent::testClassWithInvalidAnnotationTargetAtPropertyDocBlock();
+    }
+
+    /**
+     * Contrary to the behavior of the default annotation reader, we do just ignore
+     * these in the simple annotation reader (so, no expected exception here).
+     */
+    public function testClassWithInvalidNestedAnnotationTargetAtPropertyDocBlock()
+    {
+        parent::testClassWithInvalidNestedAnnotationTargetAtPropertyDocBlock();
+    }
+
+    /**
+     * Contrary to the behavior of the default annotation reader, we do just ignore
+     * these in the simple annotation reader (so, no expected exception here).
+     */
+    public function testClassWithInvalidAnnotationTargetAtMethodDocBlock()
+    {
+        parent::testClassWithInvalidAnnotationTargetAtMethodDocBlock();
+    }
+
     /**
      * @expectedException Doctrine\Common\Annotations\AnnotationException
      */
@@ -32,11 +68,29 @@ public function testInvalidAnnotationUsageButIgnoredClass()
         parent::testInvalidAnnotationUsageButIgnoredClass();
     }
 
+    /**
+     * @group DDC-1660
+     * @group regression
+     *
+     * Contrary to the behavior of the default annotation reader, @version is not ignored
+     */
+    public function testInvalidAnnotationButIgnored()
+    {
+        $reader = $this->getReader();
+        $class  = new \ReflectionClass('Doctrine\Tests\Common\Annotations\Fixtures\ClassDDC1660');
+
+        $this->assertTrue(class_exists('Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Version'));
+        $this->assertCount(1, $reader->getClassAnnotations($class));
+        $this->assertCount(1, $reader->getMethodAnnotations($class->getMethod('bar')));
+        $this->assertCount(1, $reader->getPropertyAnnotations($class->getProperty('foo')));
+    }
+
     protected function getReader()
     {
         $reader = new SimpleAnnotationReader();
         $reader->addNamespace(__NAMESPACE__);
         $reader->addNamespace(__NAMESPACE__ . '\Fixtures');
+        $reader->addNamespace(__NAMESPACE__ . '\Fixtures\Annotation');
 
         return $reader;
     }

tests/Doctrine/Tests/Common/Cache/MemcacheCacheTest.php

@@ -21,10 +21,18 @@ public function setUp()
         }
     }
 
+    public function testNoExpire() {
+        $cache = $this->_getCacheDriver();
+        $cache->save('noexpire', 'value', 0);
+        sleep(1);
+        $this->assertTrue($cache->contains('noexpire'), 'Memcache provider should support no-expire');
+    }
+
     protected function _getCacheDriver()
     {
         $driver = new MemcacheCache();
         $driver->setMemcache($this->_memcache);
         return $driver;
     }
+
 }

tests/Doctrine/Tests/Common/Cache/MemcachedCacheTest.php

@@ -24,6 +24,13 @@ public function setUp()
         }
     }
 
+    public function testNoExpire() {
+        $cache = $this->_getCacheDriver();
+        $cache->save('noexpire', 'value', 0);
+        sleep(1);
+        $this->assertTrue($cache->contains('noexpire'), 'Memcache provider should support no-expire');
+    }
+
     protected function _getCacheDriver()
     {
         $driver = new MemcachedCache();