fixed @expectedException class names

* 2.1:
  bumped Symfony version to 2.1.11-DEV
  updated VERSION for 2.1.10
  update CONTRIBUTORS for 2.1.10
  updated CHANGELOG for 2.1.10
  fixed CS
  [Process] Cleanup tests & prevent assertion that kills randomly Travis-CI
  [Filesystem] Fix regression introduced in 10dea948

Conflicts:
	src/Symfony/Component/Form/Extension/Core/DataTransformer/DataTransformerChain.php
	src/Symfony/Component/HttpKernel/Kernel.php
	src/Symfony/Component/HttpKernel/Profiler/RedisProfilerStorage.php
	src/Symfony/Component/Routing/Tests/Loader/XmlFileLoaderTest.php

.gitignore

@@ -1,2 +1,4 @@
 vendor/
 composer.lock
+phpunit.xml
+

ApcClassLoader.php

@@ -42,28 +42,38 @@ namespace Symfony\Component\ClassLoader;
 class ApcClassLoader
 {
     private $prefix;
-    private $classFinder;
+
+    /**
+     * The class loader object being decorated.
+     *
+     * @var \Symfony\Component\ClassLoader\ClassLoader
+     *   A class loader object that implements the findFile() method.
+     */
+    protected $decorated;
 
     /**
      * Constructor.
      *
-     * @param string $prefix      A prefix to create a namespace in APC
-     * @param object $classFinder An object that implements findFile() method.
+     * @param string $prefix      The APC namespace prefix to use.
+     * @param object $decorated   A class loader object that implements the findFile() method.
+     *
+     * @throws \RuntimeException
+     * @throws \InvalidArgumentException
      *
      * @api
      */
-    public function __construct($prefix, $classFinder)
+    public function __construct($prefix, $decorated)
     {
         if (!extension_loaded('apc')) {
             throw new \RuntimeException('Unable to use ApcClassLoader as APC is not enabled.');
         }
 
-        if (!method_exists($classFinder, 'findFile')) {
+        if (!method_exists($decorated, 'findFile')) {
             throw new \InvalidArgumentException('The class finder must implement a "findFile" method.');
         }
 
         $this->prefix = $prefix;
-        $this->classFinder = $classFinder;
+        $this->decorated = $decorated;
     }
 
     /**
@@ -110,9 +120,18 @@ class ApcClassLoader
     public function findFile($class)
     {
         if (false === $file = apc_fetch($this->prefix.$class)) {
-            apc_store($this->prefix.$class, $file = $this->classFinder->findFile($class));
+            apc_store($this->prefix.$class, $file = $this->decorated->findFile($class));
         }
 
         return $file;
     }
+
+    /**
+     * Passes through all unknown calls onto the decorated object.
+     */
+    public function __call($method, $args)
+    {
+        return call_user_func_array(array($this->decorated, $method), $args);
+    }
+
 }

ApcUniversalClassLoader.php

@@ -69,6 +69,8 @@ class ApcUniversalClassLoader extends UniversalClassLoader
      *
      * @param string $prefix A prefix to create a namespace in APC
      *
+     * @throws \RuntimeException
+     *
      * @api
      */
     public function __construct($prefix)

ClassCollectionLoader.php

@@ -20,6 +20,7 @@ class ClassCollectionLoader
 {
     private static $loaded;
     private static $seen;
+    private static $useTokenizer = true;
 
     /**
      * Loads a list of classes and caches them in one big file.
@@ -103,14 +104,14 @@ class ClassCollectionLoader
 
             $c = preg_replace(array('/^\s*<\?php/', '/\?>\s*$/'), '', file_get_contents($class->getFileName()));
 
-            // add namespace declaration for global code
+            // fakes namespace declaration for global code
             if (!$class->inNamespace()) {
-                $c = "\nnamespace\n{\n".self::stripComments($c)."\n}\n";
-            } else {
-                $c = self::fixNamespaceDeclarations('<?php '.$c);
-                $c = preg_replace('/^\s*<\?php/', '', $c);
+                $c = "\nnamespace\n{\n".$c."\n}\n";
             }
 
+            $c = self::fixNamespaceDeclarations('<?php '.$c);
+            $c = preg_replace('/^\s*<\?php/', '', $c);
+
             $content .= $c;
         }
 
@@ -135,49 +136,87 @@ class ClassCollectionLoader
      */
     public static function fixNamespaceDeclarations($source)
     {
-        if (!function_exists('token_get_all')) {
+        if (!function_exists('token_get_all') || !self::$useTokenizer) {
+            if (preg_match('/namespace(.*?)\s*;/', $source)) {
+                $source = preg_replace('/namespace(.*?)\s*;/', "namespace$1\n{", $source)."}\n";
+            }
+
             return $source;
         }
 
+        $rawChunk = '';
         $output = '';
         $inNamespace = false;
         $tokens = token_get_all($source);
 
-        for ($i = 0, $max = count($tokens); $i < $max; $i++) {
-            $token = $tokens[$i];
+        for (reset($tokens); false !== $token = current($tokens); next($tokens)) {
             if (is_string($token)) {
-                $output .= $token;
+                $rawChunk .= $token;
             } elseif (in_array($token[0], array(T_COMMENT, T_DOC_COMMENT))) {
                 // strip comments
                 continue;
             } elseif (T_NAMESPACE === $token[0]) {
                 if ($inNamespace) {
-                    $output .= "}\n";
+                    $rawChunk .= "}\n";
                 }
-                $output .= $token[1];
+                $rawChunk .= $token[1];
 
                 // namespace name and whitespaces
-                while (($t = $tokens[++$i]) && is_array($t) && in_array($t[0], array(T_WHITESPACE, T_NS_SEPARATOR, T_STRING))) {
-                    $output .= $t[1];
+                while (($t = next($tokens)) && is_array($t) && in_array($t[0], array(T_WHITESPACE, T_NS_SEPARATOR, T_STRING))) {
+                    $rawChunk .= $t[1];
                 }
-                if (is_string($t) && '{' === $t) {
+                if ('{' === $t) {
                     $inNamespace = false;
-                    --$i;
+                    prev($tokens);
                 } else {
-                    $output = rtrim($output);
-                    $output .= "\n{";
+                    $rawChunk = rtrim($rawChunk)."\n{";
                     $inNamespace = true;
                 }
+            } elseif (T_START_HEREDOC === $token[0]) {
+                $output .= self::compressCode($rawChunk).$token[1];
+                do {
+                    $token = next($tokens);
+                    $output .= is_string($token) ? $token : $token[1];
+                } while ($token[0] !== T_END_HEREDOC);
+                $output .= "\n";
+                $rawChunk = '';
+            } elseif (T_CONSTANT_ENCAPSED_STRING === $token[0]) {
+                $output .= self::compressCode($rawChunk).$token[1];
+                $rawChunk = '';
             } else {
-                $output .= $token[1];
+                $rawChunk .= $token[1];
             }
         }
 
         if ($inNamespace) {
-            $output .= "}\n";
+            $rawChunk .= "}\n";
         }
 
-        return $output;
+        return $output.self::compressCode($rawChunk);
+    }
+
+    /**
+     * This method is only useful for testing.
+     */
+    public static function enableTokenizer($bool)
+    {
+        self::$useTokenizer = (Boolean) $bool;
+    }
+
+    /**
+     * Strips leading & trailing ws, multiple EOL, multiple ws.
+     *
+     * @param string $code Original PHP code
+     *
+     * @return string compressed code
+     */
+    private static function compressCode($code)
+    {
+        return preg_replace(
+            array('/^\s+/m', '/\s+$/m', '/([\n\r]+ *[\n\r]+)+/', '/[ \t]+/'),
+            array('', '', "\n", ' '),
+            $code
+        );
     }
 
     /**
@@ -200,43 +239,12 @@ class ClassCollectionLoader
         throw new \RuntimeException(sprintf('Failed to write cache file "%s".', $file));
     }
 
-    /**
-     * Removes comments from a PHP source string.
-     *
-     * We don't use the PHP php_strip_whitespace() function
-     * as we want the content to be readable and well-formatted.
-     *
-     * @param string $source A PHP string
-     *
-     * @return string The PHP string with the comments removed
-     */
-    private static function stripComments($source)
-    {
-        if (!function_exists('token_get_all')) {
-            return $source;
-        }
-
-        $output = '';
-        foreach (token_get_all($source) as $token) {
-            if (is_string($token)) {
-                $output .= $token;
-            } elseif (!in_array($token[0], array(T_COMMENT, T_DOC_COMMENT))) {
-                $output .= $token[1];
-            }
-        }
-
-        // replace multiple new lines with a single newline
-        $output = preg_replace(array('/\s+$/Sm', '/\n+/S'), "\n", $output);
-
-        return $output;
-    }
-
     /**
      * Gets an ordered array of passed classes including all their dependencies.
      *
      * @param array $classes
      *
-     * @return array An array of sorted \ReflectionClass instances (dependencies added if needed)
+     * @return \ReflectionClass[] An array of sorted \ReflectionClass instances (dependencies added if needed)
      *
      * @throws \InvalidArgumentException When a class can't be loaded
      */
@@ -273,17 +281,19 @@ class ClassCollectionLoader
             array_unshift($classes, $parent);
         }
 
+        $traits = array();
+
         if (function_exists('get_declared_traits')) {
             foreach ($classes as $c) {
-                foreach (self::getTraits($c) as $trait) {
-                    self::$seen[$trait->getName()] = true;
-
-                    array_unshift($classes, $trait);
+                foreach (self::resolveDependencies(self::computeTraitDeps($c), $c) as $trait) {
+                    if ($trait !== $c) {
+                        $traits[] = $trait;
+                    }
                 }
             }
         }
 
-        return array_merge(self::getInterfaces($class), $classes);
+        return array_merge(self::getInterfaces($class), $traits, $classes);
     }
 
     private static function getInterfaces(\ReflectionClass $class)
@@ -303,18 +313,55 @@ class ClassCollectionLoader
         return $classes;
     }
 
-    private static function getTraits(\ReflectionClass $class)
+    private static function computeTraitDeps(\ReflectionClass $class)
     {
         $traits = $class->getTraits();
-        $classes = array();
+        $deps = array($class->getName() => $traits);
         while ($trait = array_pop($traits)) {
             if ($trait->isUserDefined() && !isset(self::$seen[$trait->getName()])) {
-                $classes[] = $trait;
-
-                $traits = array_merge($traits, $trait->getTraits());
+                self::$seen[$trait->getName()] = true;
+                $traitDeps = $trait->getTraits();
+                $deps[$trait->getName()] = $traitDeps;
+                $traits = array_merge($traits, $traitDeps);
             }
         }
 
-        return $classes;
+        return $deps;
+    }
+
+    /**
+     * Dependencies resolution.
+     *
+     * This function does not check for circular dependencies as it should never
+     * occur with PHP traits.
+     *
+     * @param array             $tree       The dependency tree
+     * @param \ReflectionClass  $node       The node
+     * @param \ArrayObject      $resolved   An array of already resolved dependencies
+     * @param \ArrayObject      $unresolved An array of dependencies to be resolved
+     *
+     * @return \ArrayObject The dependencies for the given node
+     *
+     * @throws \RuntimeException if a circular dependency is detected
+     */
+    private static function resolveDependencies(array $tree, $node, \ArrayObject $resolved = null, \ArrayObject $unresolved = null)
+    {
+        if (null === $resolved) {
+            $resolved = new \ArrayObject();
+        }
+        if (null === $unresolved) {
+            $unresolved = new \ArrayObject();
+        }
+        $nodeName = $node->getName();
+        $unresolved[$nodeName] = $node;
+        foreach ($tree[$nodeName] as $dependency) {
+            if (!$resolved->offsetExists($dependency->getName())) {
+                self::resolveDependencies($tree, $dependency, $resolved, $unresolved);
+            }
+        }
+        $resolved[$nodeName] = $node;
+        unset($unresolved[$nodeName]);
+
+        return $resolved;
     }
 }

ClassLoader.php

@@ -181,7 +181,7 @@ class ClassLoader
         $classPath .= str_replace('_', DIRECTORY_SEPARATOR, $className) . '.php';
 
         foreach ($this->prefixes as $prefix => $dirs) {
-            if (0 === strpos($class, $prefix)) {
+            if ($class === strstr($class, $prefix)) {
                 foreach ($dirs as $dir) {
                     if (file_exists($dir . DIRECTORY_SEPARATOR . $classPath)) {
                         return $dir . DIRECTORY_SEPARATOR . $classPath;

ClassMapGenerator.php

@@ -39,7 +39,7 @@ class ClassMapGenerator
     /**
      * Iterate over all files in the given directory searching for classes
      *
-     * @param Iterator|string $dir The directory to search in or an iterator
+     * @param \Iterator|string $dir The directory to search in or an iterator
      *
      * @return array A class map array
      */

DebugClassLoader.php

@@ -53,7 +53,7 @@ class DebugClassLoader
         }
 
         foreach ($functions as $function) {
-            if (is_array($function) && method_exists($function[0], 'findFile')) {
+            if (is_array($function) && !$function[0] instanceof self && method_exists($function[0], 'findFile')) {
                 $function = array(new static($function[0]), 'loadClass');
             }
 
@@ -69,12 +69,26 @@ class DebugClassLoader
         spl_autoload_unregister(array($this, 'loadClass'));
     }
 
+    /**
+     * Finds a file by class name
+     *
+     * @param string $class A class name to resolve to file
+     *
+     * @return string|null
+     */
+    public function findFile($class)
+    {
+        return $this->classFinder->findFile($class);
+    }
+
     /**
      * Loads the given class or interface.
      *
      * @param string $class The name of the class
      *
      * @return Boolean|null True, if loaded
+     *
+     * @throws \RuntimeException
      */
     public function loadClass($class)
     {
@@ -82,6 +96,10 @@ class DebugClassLoader
             require $file;
 
             if (!class_exists($class, false) && !interface_exists($class, false) && (!function_exists('trait_exists') || !trait_exists($class, false))) {
+                if (false !== strpos($class, '/')) {
+                    throw new \RuntimeException(sprintf('Trying to autoload a class with an invalid name "%s". Be careful that the namespace separator is "\" in PHP, not "/".', $class));
+                }
+
                 throw new \RuntimeException(sprintf('The autoloader expected class "%s" to be defined in file "%s". The file was found but the class was not in it, the class name or namespace probably has a typo.', $class, $file));
             }
 

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2004-2012 Fabien Potencier
+Copyright (c) 2004-2013 Fabien Potencier
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -64,9 +64,6 @@ Resources
 
 You can run the unit tests with the following command:
 
-    phpunit
-
-If you also want to run the unit tests that depend on other Symfony
-Components, install dev dependencies before running PHPUnit:
-
-    php composer.phar install --dev
+    $ cd path/to/Symfony/Component/ClassLoader/
+    $ composer.phar install
+    $ phpunit

Tests/ClassCollectionLoaderTest.php

@@ -20,6 +20,35 @@ require_once __DIR__.'/Fixtures/ClassesWithParents/A.php';
 
 class ClassCollectionLoaderTest extends \PHPUnit_Framework_TestCase
 {
+    public function testTraitDependencies()
+    {
+        if (version_compare(phpversion(), '5.4', '<')) {
+            $this->markTestSkipped('Requires PHP > 5.4');
+
+            return;
+        }
+
+        require_once __DIR__.'/Fixtures/deps/traits.php';
+
+        $r = new \ReflectionClass('Symfony\Component\ClassLoader\ClassCollectionLoader');
+        $m = $r->getMethod('getOrderedClasses');
+        $m->setAccessible(true);
+
+        $ordered = $m->invoke('Symfony\Component\ClassLoader\ClassCollectionLoader', array('CTFoo'));
+
+        $this->assertEquals(
+            array('TD', 'TC', 'TB', 'TA', 'TZ', 'CTFoo'),
+            array_map(function ($class) { return $class->getName(); }, $ordered)
+        );
+
+        $ordered = $m->invoke('Symfony\Component\ClassLoader\ClassCollectionLoader', array('CTBar'));
+
+        $this->assertEquals(
+            array('TD', 'TZ', 'TC', 'TB', 'TA', 'CTBar'),
+            array_map(function ($class) { return $class->getName(); }, $ordered)
+        );
+    }
+
     /**
      * @dataProvider getDifferentOrders
      */
@@ -71,8 +100,8 @@ class ClassCollectionLoaderTest extends \PHPUnit_Framework_TestCase
      */
     public function testClassWithTraitsReordering(array $classes)
     {
-        if (version_compare(phpversion(), '5.4.0', '<')) {
-            $this->markTestSkipped('Requires PHP > 5.4.0.');
+        if (version_compare(phpversion(), '5.4', '<')) {
+            $this->markTestSkipped('Requires PHP > 5.4');
 
             return;
         }
@@ -86,9 +115,9 @@ class ClassCollectionLoaderTest extends \PHPUnit_Framework_TestCase
         $expected = array(
             'ClassesWithParents\\GInterface',
             'ClassesWithParents\\CInterface',
-            'ClassesWithParents\\CTrait',
             'ClassesWithParents\\ATrait',
             'ClassesWithParents\\BTrait',
+            'ClassesWithParents\\CTrait',
             'ClassesWithParents\\B',
             'ClassesWithParents\\A',
             'ClassesWithParents\\D',
@@ -117,66 +146,115 @@ class ClassCollectionLoaderTest extends \PHPUnit_Framework_TestCase
         );
     }
 
-    public function testFixNamespaceDeclarations()
+    /**
+     * @dataProvider getFixNamespaceDeclarationsData
+     */
+    public function testFixNamespaceDeclarations($source, $expected)
     {
-        $source = <<<EOF
-<?php
+        $this->assertEquals('<?php '.$expected, ClassCollectionLoader::fixNamespaceDeclarations('<?php '.$source));
+    }
 
-namespace Foo;
-class Foo {}
-namespace   Bar ;
-class Foo {}
-namespace Foo\Bar;
-class Foo {}
-namespace Foo\Bar\Bar
-{
-    class Foo {}
-}
-namespace
-{
-    class Foo {}
-}
-EOF;
-
-        $expected = <<<EOF
-<?php
-
-namespace Foo
-{
-class Foo {}
-}
-namespace   Bar
-{
-class Foo {}
-}
-namespace Foo\Bar
-{
-class Foo {}
-}
-namespace Foo\Bar\Bar
-{
-    class Foo {}
-}
-namespace
-{
-    class Foo {}
-}
-EOF;
-
-        $this->assertEquals($expected, ClassCollectionLoader::fixNamespaceDeclarations($source));
+    public function getFixNamespaceDeclarationsData()
+    {
+        return array(
+            array("namespace;\nclass Foo {}\n", "namespace\n{\nclass Foo {}\n}"),
+            array("namespace Foo;\nclass Foo {}\n", "namespace Foo\n{\nclass Foo {}\n}"),
+            array("namespace   Bar ;\nclass Foo {}\n", "namespace Bar\n{\nclass Foo {}\n}"),
+            array("namespace Foo\Bar;\nclass Foo {}\n", "namespace Foo\Bar\n{\nclass Foo {}\n}"),
+            array("namespace Foo\Bar\Bar\n{\nclass Foo {}\n}\n", "namespace Foo\Bar\Bar\n{\nclass Foo {}\n}"),
+            array("namespace\n{\nclass Foo {}\n}\n", "namespace\n{\nclass Foo {}\n}"),
+        );
     }
 
     /**
-     * @expectedException InvalidArgumentException
+     * @dataProvider getFixNamespaceDeclarationsDataWithoutTokenizer
+     */
+    public function testFixNamespaceDeclarationsWithoutTokenizer($source, $expected)
+    {
+        ClassCollectionLoader::enableTokenizer(false);
+        $this->assertEquals('<?php '.$expected, ClassCollectionLoader::fixNamespaceDeclarations('<?php '.$source));
+        ClassCollectionLoader::enableTokenizer(true);
+    }
+
+    public function getFixNamespaceDeclarationsDataWithoutTokenizer()
+    {
+        return array(
+            array("namespace;\nclass Foo {}\n", "namespace\n{\nclass Foo {}\n}\n"),
+            array("namespace Foo;\nclass Foo {}\n", "namespace Foo\n{\nclass Foo {}\n}\n"),
+            array("namespace   Bar ;\nclass Foo {}\n", "namespace   Bar\n{\nclass Foo {}\n}\n"),
+            array("namespace Foo\Bar;\nclass Foo {}\n", "namespace Foo\Bar\n{\nclass Foo {}\n}\n"),
+            array("namespace Foo\Bar\Bar\n{\nclass Foo {}\n}\n", "namespace Foo\Bar\Bar\n{\nclass Foo {}\n}\n"),
+            array("namespace\n{\nclass Foo {}\n}\n", "namespace\n{\nclass Foo {}\n}\n"),
+        );
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
      */
     public function testUnableToLoadClassException()
     {
-        ClassCollectionLoader::load(array('SomeNotExistingClass'), '', 'foo', false);
+        if (is_file($file = sys_get_temp_dir().'/foo.php')) {
+            unlink($file);
+        }
+
+        ClassCollectionLoader::load(array('SomeNotExistingClass'), sys_get_temp_dir(), 'foo', false);
     }
 
-    public function testLoadTwiceClass()
+    public function testCommentStripping()
     {
-        ClassCollectionLoader::load(array('Foo'), '', 'foo', false);
-        ClassCollectionLoader::load(array('Foo'), '', 'foo', false);
+        if (is_file($file = sys_get_temp_dir().'/bar.php')) {
+            unlink($file);
+        }
+        spl_autoload_register($r = function ($class) {
+            if (0 === strpos($class, 'Namespaced') || 0 === strpos($class, 'Pearlike_')) {
+                require_once __DIR__.'/Fixtures/'.str_replace(array('\\', '_'), '/', $class).'.php';
+            }
+        });
+
+        ClassCollectionLoader::load(
+            array('Namespaced\\WithComments', 'Pearlike_WithComments'),
+            sys_get_temp_dir(),
+            'bar',
+            false
+        );
+
+        spl_autoload_unregister($r);
+
+        $this->assertEquals(<<<EOF
+namespace Namespaced
+{
+class WithComments
+{
+public static \$loaded = true;
+}
+\$string ='string shoult not be   modified {\$string}';
+\$heredoc = (<<<HD
+
+
+Heredoc should not be   modified {\$string}
+
+
+HD
+);
+\$nowdoc =<<<'ND'
+
+
+Nowdoc should not be   modified {\$string}
+
+
+ND
+;
+}
+namespace
+{
+class Pearlike_WithComments
+{
+public static \$loaded = true;
+}
+}
+EOF
+        , str_replace("<?php \n", '', file_get_contents($file)));
+
+        unlink($file);
     }
 }

Tests/ClassMapGeneratorTest.php

@@ -72,9 +72,10 @@ class ClassMapGeneratorTest extends \PHPUnit_Framework_TestCase
     {
         $data = array(
             array(__DIR__.'/Fixtures/Namespaced', array(
-                'Namespaced\\Bar' => realpath(__DIR__).'/Fixtures/Namespaced/Bar.php',
-                'Namespaced\\Foo' => realpath(__DIR__).'/Fixtures/Namespaced/Foo.php',
-                'Namespaced\\Baz' => realpath(__DIR__).'/Fixtures/Namespaced/Baz.php',
+                'Namespaced\\Bar'          => realpath(__DIR__).'/Fixtures/Namespaced/Bar.php',
+                'Namespaced\\Foo'          => realpath(__DIR__).'/Fixtures/Namespaced/Foo.php',
+                'Namespaced\\Baz'          => realpath(__DIR__).'/Fixtures/Namespaced/Baz.php',
+                'Namespaced\\WithComments' => realpath(__DIR__).'/Fixtures/Namespaced/WithComments.php',
                 )
             ),
             array(__DIR__.'/Fixtures/beta/NamespaceCollision', array(
@@ -84,9 +85,10 @@ class ClassMapGeneratorTest extends \PHPUnit_Framework_TestCase
                 'NamespaceCollision\\C\\B\\Foo' => realpath(__DIR__).'/Fixtures/beta/NamespaceCollision/C/B/Foo.php',
             )),
             array(__DIR__.'/Fixtures/Pearlike', array(
-                'Pearlike_Foo' => realpath(__DIR__).'/Fixtures/Pearlike/Foo.php',
-                'Pearlike_Bar' => realpath(__DIR__).'/Fixtures/Pearlike/Bar.php',
-                'Pearlike_Baz' => realpath(__DIR__).'/Fixtures/Pearlike/Baz.php',
+                'Pearlike_Foo'          => realpath(__DIR__).'/Fixtures/Pearlike/Foo.php',
+                'Pearlike_Bar'          => realpath(__DIR__).'/Fixtures/Pearlike/Bar.php',
+                'Pearlike_Baz'          => realpath(__DIR__).'/Fixtures/Pearlike/Baz.php',
+                'Pearlike_WithComments' => realpath(__DIR__).'/Fixtures/Pearlike/WithComments.php',
             )),
             array(__DIR__.'/Fixtures/classmap', array(
                 'Foo\\Bar\\A'             => realpath(__DIR__).'/Fixtures/classmap/sameNsMultipleClasses.php',

Tests/DebugClassLoaderTest.php

@@ -0,0 +1,52 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ClassLoader\Tests;
+
+use Symfony\Component\ClassLoader\ClassLoader;
+use Symfony\Component\ClassLoader\DebugClassLoader;
+
+class DebugClassLoaderTest extends \PHPUnit_Framework_TestCase
+{
+    private $loader;
+
+    protected function setUp()
+    {
+        $this->loader = new ClassLoader();
+        spl_autoload_register(array($this->loader, 'loadClass'));
+    }
+
+    protected function tearDown()
+    {
+        spl_autoload_unregister(array($this->loader, 'loadClass'));
+    }
+
+    public function testIdempotence()
+    {
+        DebugClassLoader::enable();
+        DebugClassLoader::enable();
+
+        $functions = spl_autoload_functions();
+        foreach ($functions as $function) {
+            if (is_array($function) && $function[0] instanceof DebugClassLoader) {
+                $reflClass = new \ReflectionClass($function[0]);
+                $reflProp = $reflClass->getProperty('classFinder');
+                $reflProp->setAccessible(true);
+
+                $this->assertNotInstanceOf('Symfony\Component\ClassLoader\DebugClassLoader', $reflProp->getValue($function[0]));
+
+                return;
+            }
+        }
+
+        throw new \Exception('DebugClassLoader did not register');
+    }
+}

Tests/Fixtures/Namespaced/WithComments.php

@@ -0,0 +1,37 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Namespaced;
+
+class WithComments
+{
+    /** @Boolean */
+    public static $loaded = true;
+}
+
+$string = 'string shoult not be   modified {$string}';
+
+$heredoc = (<<<HD
+
+
+Heredoc should not be   modified {$string}
+
+
+HD
+);
+
+$nowdoc = <<<'ND'
+
+
+Nowdoc should not be   modified {$string}
+
+
+ND;

Tests/Fixtures/Pearlike/WithComments.php

@@ -0,0 +1,16 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+class Pearlike_WithComments
+{
+    /** @Boolean */
+    public static $loaded = true;
+}

Tests/Fixtures/deps/traits.php

@@ -0,0 +1,36 @@
+<?php
+
+trait TD
+{}
+
+trait TZ
+{
+    use TD;
+}
+
+trait TC
+{
+    use TD;
+}
+
+trait TB
+{
+    use TC;
+}
+
+trait TA
+{
+    use TB;
+}
+
+class CTFoo
+{
+    use TA;
+    use TZ;
+}
+
+class CTBar
+{
+    use TZ;
+    use TA;
+}

Tests/UniversalClassLoaderTest.php

@@ -23,7 +23,7 @@ class UniversalClassLoaderTest extends \PHPUnit_Framework_TestCase
         $loader = new UniversalClassLoader();
         $loader->registerNamespace('Namespaced', __DIR__.DIRECTORY_SEPARATOR.'Fixtures');
         $loader->registerPrefix('Pearlike_', __DIR__.DIRECTORY_SEPARATOR.'Fixtures');
-        $loader->loadClass($testClassName);
+        $this->assertTrue($loader->loadClass($testClassName));
         $this->assertTrue(class_exists($className), $message);
     }
 
@@ -92,7 +92,7 @@ class UniversalClassLoaderTest extends \PHPUnit_Framework_TestCase
         $loader->registerPrefix('Pearlike_', __DIR__.DIRECTORY_SEPARATOR.'Fixtures');
         $loader->registerNamespaceFallbacks(array(__DIR__.DIRECTORY_SEPARATOR.'Fixtures/fallback'));
         $loader->registerPrefixFallbacks(array(__DIR__.DIRECTORY_SEPARATOR.'Fixtures/fallback'));
-        $loader->loadClass($testClassName);
+        $this->assertTrue($loader->loadClass($testClassName));
         $this->assertTrue(class_exists($className), $message);
     }
 
@@ -128,7 +128,7 @@ class UniversalClassLoaderTest extends \PHPUnit_Framework_TestCase
         $loader = new UniversalClassLoader();
         $loader->registerNamespaces($namespaces);
 
-        $loader->loadClass($className);
+        $this->assertTrue($loader->loadClass($className));
         $this->assertTrue(class_exists($className), $message);
     }
 
@@ -178,7 +178,7 @@ class UniversalClassLoaderTest extends \PHPUnit_Framework_TestCase
         $loader = new UniversalClassLoader();
         $loader->registerPrefixes($prefixes);
 
-        $loader->loadClass($className);
+        $this->assertTrue($loader->loadClass($className));
         $this->assertTrue(class_exists($className), $message);
     }
 

Tests/bootstrap.php

@@ -1,22 +0,0 @@
-<?php
-
-/*
- * This file is part of the Symfony package.
- *
- * (c) Fabien Potencier <fabien@symfony.com>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-spl_autoload_register(function ($class) {
-    if (0 === strpos(ltrim($class, '/'), 'Symfony\Component\ClassLoader')) {
-        if (file_exists($file = __DIR__.'/../'.substr(str_replace('\\', '/', $class), strlen('Symfony\Component\ClassLoader')).'.php')) {
-            require_once $file;
-        }
-    }
-});
-
-if (file_exists($loader = __DIR__.'/../vendor/autoload.php')) {
-    require_once $loader;
-}

UniversalClassLoader.php

@@ -242,11 +242,15 @@ class UniversalClassLoader
      * Loads the given class or interface.
      *
      * @param string $class The name of the class
+     *
+     * @return Boolean|null True, if loaded
      */
     public function loadClass($class)
     {
         if ($file = $this->findFile($class)) {
             require $file;
+
+            return true;
         }
     }
 

XcacheClassLoader.php

@@ -51,6 +51,9 @@ class XcacheClassLoader
      * @param string $prefix      A prefix to create a namespace in Xcache
      * @param object $classFinder An object that implements findFile() method.
      *
+     * @throws \RuntimeException
+     * @throws \InvalidArgumentException
+     *
      * @api
      */
     public function __construct($prefix, $classFinder)

composer.json

@@ -20,16 +20,15 @@
         "php": ">=5.3.3"
     },
     "require-dev": {
-        "symfony/finder": "2.1.*"
+        "symfony/finder": "~2.0"
     },
     "autoload": {
-        "psr-0": { "Symfony\\Component\\ClassLoader": "" }
+        "psr-0": { "Symfony\\Component\\ClassLoader\\": "" }
     },
     "target-dir": "Symfony/Component/ClassLoader",
-    "minimum-stability": "dev",
     "extra": {
         "branch-alias": {
-            "dev-master": "2.1-dev"
+            "dev-master": "2.2-dev"
         }
     }
 }

phpunit.xml.dist

@@ -9,7 +9,7 @@
          processIsolation="false"
          stopOnFailure="false"
          syntaxCheck="false"
-         bootstrap="Tests/bootstrap.php"
+         bootstrap="vendor/autoload.php"
 >
     <testsuites>
         <testsuite name="Symfony ClassLoader Component Test Suite">