Merge branch '2.3' into 2.4

* 2.3:
  fixed various inconsistencies
  reduced recursion when building DumperPrefixCollection
  renamed variables - making next change more readable
  removing dead code.
  [DomCrawler] Fixed filterXPath() chaining
  [DomCrawler] Fixed incorrect handling of image inputs

Conflicts:
	src/Symfony/Component/DomCrawler/Crawler.php
	src/Symfony/Component/EventDispatcher/Tests/EventDispatcherTest.php
	src/Symfony/Component/Form/Extension/DependencyInjection/DependencyInjectionExtension.php
	src/Symfony/Component/Serializer/Tests/Normalizer/CustomNormalizerTest.php
	src/Symfony/Component/Templating/Tests/Loader/CacheLoaderTest.php
	src/Symfony/Component/Templating/Tests/Loader/LoaderTest.php

Debug.php

@@ -11,8 +11,6 @@
 
 namespace Symfony\Component\Debug;
 
-use Symfony\Component\Debug\DebugClassLoader;
-
 /**
  * Registers all the debug tools.
  *

ErrorHandler.php

@@ -14,6 +14,7 @@ namespace Symfony\Component\Debug;
 use Psr\Log\LoggerInterface;
 use Symfony\Component\Debug\Exception\ContextErrorException;
 use Symfony\Component\Debug\Exception\FatalErrorException;
+use Symfony\Component\Debug\Exception\DummyException;
 use Symfony\Component\Debug\FatalErrorHandler\UndefinedFunctionFatalErrorHandler;
 use Symfony\Component\Debug\FatalErrorHandler\ClassNotFoundFatalErrorHandler;
 use Symfony\Component\Debug\FatalErrorHandler\FatalErrorHandlerInterface;
@@ -59,7 +60,7 @@ class ErrorHandler
      * Registers the error handler.
      *
      * @param integer $level         The level at which the conversion to Exception is done (null to use the error_reporting() value and 0 to disable)
-     * @param Boolean $displayErrors Display errors (for dev environment) or just log they (production usage)
+     * @param Boolean $displayErrors Display errors (for dev environment) or just log them (production usage)
      *
      * @return ErrorHandler The registered error handler
      */
@@ -144,7 +145,34 @@ class ErrorHandler
                 require __DIR__.'/Exception/ContextErrorException.php';
             }
 
-            throw new ContextErrorException(sprintf('%s: %s in %s line %d', isset($this->levels[$level]) ? $this->levels[$level] : $level, $message, $file, $line), 0, $level, $file, $line, $context);
+            $exception = new ContextErrorException(sprintf('%s: %s in %s line %d', isset($this->levels[$level]) ? $this->levels[$level] : $level, $message, $file, $line), 0, $level, $file, $line, $context);
+
+            // Exceptions thrown from error handlers are sometimes not caught by the exception
+            // handler, so we invoke it directly (https://bugs.php.net/bug.php?id=54275)
+            $exceptionHandler = set_exception_handler(function () {});
+            restore_exception_handler();
+
+            if (is_array($exceptionHandler) && $exceptionHandler[0] instanceof ExceptionHandler) {
+                $exceptionHandler[0]->handle($exception);
+
+                if (!class_exists('Symfony\Component\Debug\Exception\DummyException')) {
+                    require __DIR__.'/Exception/DummyException.php';
+                }
+
+                // we must stop the PHP script execution, as the exception has
+                // already been dealt with, so, let's throw an exception that
+                // will be caught by a dummy exception handler
+                set_exception_handler(function (\Exception $e) use ($exceptionHandler) {
+                    if (!$e instanceof DummyException) {
+                        // happens if our dummy exception is caught by a
+                        // catch-all from user code, in which case, let's the
+                        // current handler handle this "new" exception
+                        call_user_func($exceptionHandler, $e);
+                    }
+                });
+
+                throw new DummyException();
+            }
         }
 
         return false;
@@ -177,7 +205,7 @@ class ErrorHandler
         }
 
         // get current exception handler
-        $exceptionHandler = set_exception_handler(function() {});
+        $exceptionHandler = set_exception_handler(function () {});
         restore_exception_handler();
 
         if (is_array($exceptionHandler) && $exceptionHandler[0] instanceof ExceptionHandler) {

Exception/DummyException.php

@@ -0,0 +1,21 @@
+<?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\Debug\Exception;
+
+/**
+ * Used to stop execution of a PHP script after handling a fatal error.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class DummyException extends \ErrorException
+{
+}

Exception/FlattenException.php

@@ -249,7 +249,7 @@ class FlattenException
                 if ($level > 10) {
                     $result[$key] = array('array', '*DEEP NESTED ARRAY*');
                 } else {
-                    $result[$key] = array('array', $this->flattenArgs($value, ++$level));
+                    $result[$key] = array('array', $this->flattenArgs($value, $level + 1));
                 }
             } elseif (null === $value) {
                 $result[$key] = array('null', null);

FatalErrorHandler/ClassNotFoundFatalErrorHandler.php

@@ -110,7 +110,7 @@ class ClassNotFoundFatalErrorHandler implements FatalErrorHandlerInterface
             if ($function[0] instanceof ComposerClassLoader || $function[0] instanceof SymfonyClassLoader) {
                 foreach ($function[0]->getPrefixes() as $paths) {
                     foreach ($paths as $path) {
-                        $classes = array_merge($classes, $this->findClassInPath($function[0], $path, $class));
+                        $classes = array_merge($classes, $this->findClassInPath($path, $class));
                     }
                 }
             }
@@ -119,7 +119,13 @@ class ClassNotFoundFatalErrorHandler implements FatalErrorHandlerInterface
         return $classes;
     }
 
-    private function findClassInPath($loader, $path, $class)
+    /**
+     * @param string $path
+     * @param string $class
+     *
+     * @return array
+     */
+    private function findClassInPath($path, $class)
     {
         if (!$path = realpath($path)) {
             return array();
@@ -128,7 +134,7 @@ class ClassNotFoundFatalErrorHandler implements FatalErrorHandlerInterface
         $classes = array();
         $filename = $class.'.php';
         foreach (new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator($path), \RecursiveIteratorIterator::LEAVES_ONLY) as $file) {
-            if ($filename == $file->getFileName() && $class = $this->convertFileToClass($loader, $path, $file->getPathName())) {
+            if ($filename == $file->getFileName() && $class = $this->convertFileToClass($path, $file->getPathName())) {
                 $classes[] = $class;
             }
         }
@@ -136,25 +142,40 @@ class ClassNotFoundFatalErrorHandler implements FatalErrorHandlerInterface
         return $classes;
     }
 
-    private function convertFileToClass($loader, $path, $file)
+    /**
+     * @param string $path
+     * @param string $file
+     *
+     * @return string|null
+     */
+    private function convertFileToClass($path, $file)
     {
+        $namespacedClass = str_replace(array($path.'/', '.php', '/'), array('', '', '\\'), $file);
+        $pearClass = str_replace('\\', '_', $namespacedClass);
+
         // We cannot use the autoloader here as most of them use require; but if the class
         // is not found, the new autoloader call will require the file again leading to a
         // "cannot redeclare class" error.
-        require_once $file;
-
-        $file = str_replace(array($path.'/', '.php'), array('', ''), $file);
-
-        // is it a namespaced class?
-        $class = str_replace('/', '\\', $file);
-        if (class_exists($class, false) || interface_exists($class, false) || (function_exists('trait_exists') && trait_exists($class, false))) {
-            return $class;
+        if (!$this->classExists($namespacedClass) && !$this->classExists($pearClass)) {
+            require_once $file;
         }
 
-        // is it a PEAR-like class name instead?
-        $class = str_replace('/', '_', $file);
-        if (class_exists($class, false) || interface_exists($class, false) || (function_exists('trait_exists') && trait_exists($class, false))) {
-            return $class;
+        if ($this->classExists($namespacedClass)) {
+            return $namespacedClass;
+        }
+
+        if ($this->classExists($pearClass)) {
+            return $pearClass;
         }
     }
+
+    /**
+     * @param string $class
+     *
+     * @return Boolean
+     */
+    private function classExists($class)
+    {
+        return class_exists($class, false) || interface_exists($class, false) || (function_exists('trait_exists') && trait_exists($class, false));
+    }
 }

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2004-2013 Fabien Potencier
+Copyright (c) 2004-2014 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

Tests/ErrorHandlerTest.php

@@ -12,6 +12,7 @@
 namespace Symfony\Component\Debug\Tests;
 
 use Symfony\Component\Debug\ErrorHandler;
+use Symfony\Component\Debug\Exception\DummyException;
 
 /**
  * ErrorHandlerTest
@@ -20,100 +21,224 @@ use Symfony\Component\Debug\ErrorHandler;
  */
 class ErrorHandlerTest extends \PHPUnit_Framework_TestCase
 {
+    /**
+     * @var int Error reporting level before running tests.
+     */
+    protected $errorReporting;
+
+    /**
+     * @var string Display errors setting before running tests.
+     */
+    protected $displayErrors;
+
+    public function setUp()
+    {
+        $this->errorReporting = error_reporting(E_ALL | E_STRICT);
+        $this->displayErrors = ini_get('display_errors');
+        ini_set('display_errors', '1');
+    }
+
+    public function tearDown()
+    {
+        ini_set('display_errors', $this->displayErrors);
+        error_reporting($this->errorReporting);
+    }
+
     public function testCompileTimeError()
     {
-        // the ContextErrorException must not be loaded for this test to work
+        // the ContextErrorException must not be loaded to test the workaround
+        // for https://bugs.php.net/bug.php?id=65322.
         if (class_exists('Symfony\Component\Debug\Exception\ContextErrorException', false)) {
             $this->markTestSkipped('The ContextErrorException class is already loaded.');
         }
 
-        $handler = ErrorHandler::register(E_ALL | E_STRICT);
-        $displayErrors = ini_get('display_errors');
-        ini_set('display_errors', '1');
+        $exceptionHandler = $this->getMock('Symfony\Component\Debug\ExceptionHandler', array('handle'));
 
+        // the following code forces some PHPUnit classes to be loaded
+        // so that they will be available in the exception handler
+        // as they won't be autoloaded by PHP
+        class_exists('PHPUnit_Framework_MockObject_Invocation_Object');
+        $this->assertInstanceOf('stdClass', new \stdClass());
+        $this->assertEquals(1, 1);
+        $this->assertStringStartsWith('foo', 'foobar');
+        $this->assertArrayHasKey('bar', array('bar' => 'foo'));
+
+        $that = $this;
+        $exceptionCheck = function ($exception) use ($that) {
+            $that->assertInstanceOf('Symfony\Component\Debug\Exception\ContextErrorException', $exception);
+            $that->assertEquals(E_STRICT, $exception->getSeverity());
+            $that->assertEquals(2, $exception->getLine());
+            $that->assertStringStartsWith('Runtime Notice: Declaration of _CompileTimeError::foo() should be compatible with', $exception->getMessage());
+            $that->assertArrayHasKey('bar', $exception->getContext());
+        };
+
+        $exceptionHandler->expects($this->once())
+            ->method('handle')
+            ->will($this->returnCallback($exceptionCheck))
+        ;
+
+        ErrorHandler::register();
+        set_exception_handler(array($exceptionHandler, 'handle'));
+
+        // dummy variable to check for in error handler.
+        $bar = 123;
+
+        // trigger compile time error
         try {
-            // trigger compile time error
             eval(<<<'PHP'
 class _BaseCompileTimeError { function foo() {} }
 class _CompileTimeError extends _BaseCompileTimeError { function foo($invalid) {} }
 PHP
             );
-        } catch (\Exception $e) {
+        } catch (DummyException $e) {
             // if an exception is thrown, the test passed
+        } catch (\Exception $e) {
+            restore_error_handler();
+            restore_exception_handler();
+
+            throw $e;
         }
 
-        ini_set('display_errors', $displayErrors);
         restore_error_handler();
+        restore_exception_handler();
+    }
+
+    public function testNotice()
+    {
+        $exceptionHandler = $this->getMock('Symfony\Component\Debug\ExceptionHandler', array('handle'));
+        set_exception_handler(array($exceptionHandler, 'handle'));
+
+        $that = $this;
+        $exceptionCheck = function ($exception) use ($that) {
+            $that->assertInstanceOf('Symfony\Component\Debug\Exception\ContextErrorException', $exception);
+            $that->assertEquals(E_NOTICE, $exception->getSeverity());
+            $that->assertEquals(__LINE__ + 44, $exception->getLine());
+            $that->assertEquals(__FILE__, $exception->getFile());
+            $that->assertRegexp('/^Notice: Undefined variable: (foo|bar)/', $exception->getMessage());
+            $that->assertArrayHasKey('foobar', $exception->getContext());
+
+            $trace = $exception->getTrace();
+            $that->assertEquals(__FILE__, $trace[0]['file']);
+            $that->assertEquals('Symfony\Component\Debug\ErrorHandler', $trace[0]['class']);
+            $that->assertEquals('handle', $trace[0]['function']);
+            $that->assertEquals('->', $trace[0]['type']);
+
+            $that->assertEquals(__FILE__, $trace[1]['file']);
+            $that->assertEquals(__CLASS__, $trace[1]['class']);
+            $that->assertEquals('triggerNotice', $trace[1]['function']);
+            $that->assertEquals('::', $trace[1]['type']);
+
+            $that->assertEquals(__CLASS__, $trace[2]['class']);
+            $that->assertEquals('testNotice', $trace[2]['function']);
+            $that->assertEquals('->', $trace[2]['type']);
+        };
+
+        $exceptionHandler->expects($this->once())
+            ->method('handle')
+            ->will($this->returnCallback($exceptionCheck));
+        ErrorHandler::register();
+
+        try {
+            self::triggerNotice($this);
+        } catch (DummyException $e) {
+            // if an exception is thrown, the test passed
+        } catch (\Exception $e) {
+            restore_error_handler();
+
+            throw $e;
+        }
+
+        restore_error_handler();
+    }
+
+    // dummy function to test trace in error handler.
+    private static function triggerNotice($that)
+    {
+        // dummy variable to check for in error handler.
+        $foobar = 123;
+        $that->assertSame('', $foo.$foo.$bar);
     }
 
     public function testConstruct()
     {
-        $handler = ErrorHandler::register(3);
+        try {
+            $handler = ErrorHandler::register(3);
 
-        $level = new \ReflectionProperty($handler, 'level');
-        $level->setAccessible(true);
+            $level = new \ReflectionProperty($handler, 'level');
+            $level->setAccessible(true);
 
-        $this->assertEquals(3, $level->getValue($handler));
+            $this->assertEquals(3, $level->getValue($handler));
 
-        restore_error_handler();
+            restore_error_handler();
+        } catch (\Exception $e) {
+            restore_error_handler();
+
+            throw $e;
+        }
     }
 
     public function testHandle()
     {
-        $handler = ErrorHandler::register(0);
-        $this->assertFalse($handler->handle(0, 'foo', 'foo.php', 12, 'foo'));
-
-        restore_error_handler();
-
-        $handler = ErrorHandler::register(3);
-        $this->assertFalse($handler->handle(4, 'foo', 'foo.php', 12, 'foo'));
-
-        restore_error_handler();
-
-        $handler = ErrorHandler::register(3);
         try {
-            $handler->handle(111, 'foo', 'foo.php', 12, 'foo');
-        } catch (\ErrorException $e) {
-            $this->assertSame('111: foo in foo.php line 12', $e->getMessage());
-            $this->assertSame(111, $e->getSeverity());
-            $this->assertSame('foo.php', $e->getFile());
-            $this->assertSame(12, $e->getLine());
+            $handler = ErrorHandler::register(0);
+            $this->assertFalse($handler->handle(0, 'foo', 'foo.php', 12, 'foo'));
+
+            restore_error_handler();
+
+            $handler = ErrorHandler::register(3);
+            $this->assertFalse($handler->handle(4, 'foo', 'foo.php', 12, 'foo'));
+
+            restore_error_handler();
+
+            $handler = ErrorHandler::register(3);
+            try {
+                $handler->handle(111, 'foo', 'foo.php', 12, 'foo');
+            } catch (\ErrorException $e) {
+                $this->assertSame('111: foo in foo.php line 12', $e->getMessage());
+                $this->assertSame(111, $e->getSeverity());
+                $this->assertSame('foo.php', $e->getFile());
+                $this->assertSame(12, $e->getLine());
+            }
+
+            restore_error_handler();
+
+            $handler = ErrorHandler::register(E_USER_DEPRECATED);
+            $this->assertTrue($handler->handle(E_USER_DEPRECATED, 'foo', 'foo.php', 12, 'foo'));
+
+            restore_error_handler();
+
+            $handler = ErrorHandler::register(E_DEPRECATED);
+            $this->assertTrue($handler->handle(E_DEPRECATED, 'foo', 'foo.php', 12, 'foo'));
+
+            restore_error_handler();
+
+            $logger = $this->getMock('Psr\Log\LoggerInterface');
+
+            $that = $this;
+            $warnArgCheck = function ($message, $context) use ($that) {
+                $that->assertEquals('foo', $message);
+                $that->assertArrayHasKey('type', $context);
+                $that->assertEquals($context['type'], ErrorHandler::TYPE_DEPRECATION);
+                $that->assertArrayHasKey('stack', $context);
+                $that->assertInternalType('array', $context['stack']);
+            };
+
+            $logger
+                ->expects($this->once())
+                ->method('warning')
+                ->will($this->returnCallback($warnArgCheck))
+            ;
+
+            $handler = ErrorHandler::register(E_USER_DEPRECATED);
+            $handler->setLogger($logger);
+            $handler->handle(E_USER_DEPRECATED, 'foo', 'foo.php', 12, 'foo');
+
+            restore_error_handler();
+        } catch (\Exception $e) {
+            restore_error_handler();
+
+            throw $e;
         }
-
-        restore_error_handler();
-
-        $handler = ErrorHandler::register(E_USER_DEPRECATED);
-        $this->assertTrue($handler->handle(E_USER_DEPRECATED, 'foo', 'foo.php', 12, 'foo'));
-
-        restore_error_handler();
-
-        $handler = ErrorHandler::register(E_DEPRECATED);
-        $this->assertTrue($handler->handle(E_DEPRECATED, 'foo', 'foo.php', 12, 'foo'));
-
-        restore_error_handler();
-
-        $logger = $this->getMock('Psr\Log\LoggerInterface');
-
-        $that = $this;
-        $warnArgCheck = function($message, $context) use ($that) {
-            $that->assertEquals('foo', $message);
-            $that->assertArrayHasKey('type', $context);
-            $that->assertEquals($context['type'], ErrorHandler::TYPE_DEPRECATION);
-            $that->assertArrayHasKey('stack', $context);
-            $that->assertInternalType('array', $context['stack']);
-        };
-
-        $logger
-            ->expects($this->once())
-            ->method('warning')
-            ->will($this->returnCallback($warnArgCheck))
-        ;
-
-        $handler = ErrorHandler::register(E_USER_DEPRECATED);
-        $handler->setLogger($logger);
-        $handler->handle(E_USER_DEPRECATED, 'foo', 'foo.php', 12, 'foo');
-
-        restore_error_handler();
     }
 
     /**
@@ -144,10 +269,10 @@ PHP
                     'type' => 1,
                     'line' => 12,
                     'file' => 'foo.php',
-                    'message' => 'Call to undefined function test_namespaced_function()',
+                    'message' => 'Call to undefined function test_namespaced_function_again()',
                 ),
                 'Symfony\Component\Debug\Exception\UndefinedFunctionException',
-                'Attempted to call function "test_namespaced_function" from the global namespace in foo.php line 12. Did you mean to call: "\\symfony\\component\\debug\\tests\\fatalerrorhandler\\test_namespaced_function"?',
+                'Attempted to call function "test_namespaced_function_again" from the global namespace in foo.php line 12. Did you mean to call: "\\symfony\\component\\debug\\tests\\test_namespaced_function_again"?',
             ),
             // class not found
             array(
@@ -163,3 +288,7 @@ PHP
         );
     }
 }
+
+function test_namespaced_function_again()
+{
+}

Tests/ExceptionHandlerTest.php

@@ -57,6 +57,6 @@ class ExceptionHandlerTest extends \PHPUnit_Framework_TestCase
     public function testNestedExceptions()
     {
         $handler = new ExceptionHandler(true);
-        $response = $handler->createResponse(new \RuntimeException('Foo', null, new \RuntimeException('Bar')));
+        $response = $handler->createResponse(new \RuntimeException('Foo', 0, new \RuntimeException('Bar')));
     }
 }

Tests/FatalErrorHandler/ClassNotFoundFatalErrorHandlerTest.php

@@ -81,4 +81,25 @@ class ClassNotFoundFatalErrorHandlerTest extends \PHPUnit_Framework_TestCase
             ),
         );
     }
+
+    public function testCannotRedeclareClass()
+    {
+        if (!file_exists(__DIR__.'/../FIXTURES/REQUIREDTWICE.PHP')) {
+            $this->markTestSkipped('Can only be run on case insensitive filesystems');
+        }
+
+        require_once __DIR__.'/../FIXTURES/REQUIREDTWICE.PHP';
+
+        $error = array(
+            'type' => 1,
+            'line' => 12,
+            'file' => 'foo.php',
+            'message' => 'Class \'Foo\\Bar\\RequiredTwice\' not found',
+        );
+
+        $handler = new ClassNotFoundFatalErrorHandler();
+        $exception = $handler->handleError($error, new FatalErrorException('', 0, $error['type'], $error['file'], $error['line']));
+
+        $this->assertInstanceof('Symfony\Component\Debug\Exception\ClassNotFoundException', $exception);
+    }
 }

Tests/Fixtures/RequiredTwice.php

@@ -0,0 +1,7 @@
+<?php
+
+namespace Symfony\Component\Debug\Tests\Fixtures;
+
+class RequiredTwice
+{
+}