From dc2cc6b13c8664ed2ae97611d448f98d1cfae2b8 Mon Sep 17 00:00:00 2001
From: Fabien Potencier <fabien.potencier@gmail.com>
Date: Fri, 11 Jan 2013 14:49:52 +0100
Subject: [PATCH 1/5] [Console] fixed input bug when the value of an option is
 empty (closes #6649, closes #6689)

---
 src/Symfony/Component/Console/Input/ArgvInput.php    |  6 ++++--
 .../Tests/Component/Console/Input/ArgvInputTest.php  | 12 ++++++++++++
 2 files changed, 16 insertions(+), 2 deletions(-)

diff --git a/src/Symfony/Component/Console/Input/ArgvInput.php b/src/Symfony/Component/Console/Input/ArgvInput.php
index afcbc320af..a4d09e7beb 100644
--- a/src/Symfony/Component/Console/Input/ArgvInput.php
+++ b/src/Symfony/Component/Console/Input/ArgvInput.php
@@ -210,12 +210,14 @@ class ArgvInput extends Input
 
         $option = $this->definition->getOption($name);
 
-        if (null === $value && $option->acceptValue()) {
+        if (null === $value && $option->acceptValue() && count($this->parsed)) {
             // if option accepts an optional or mandatory argument
             // let's see if there is one provided
             $next = array_shift($this->parsed);
-            if ('-' !== $next[0]) {
+            if (isset($next[0]) && '-' !== $next[0]) {
                 $value = $next;
+            } elseif (empty($next)) {
+                $value = '';
             } else {
                 array_unshift($this->parsed, $next);
             }
diff --git a/tests/Symfony/Tests/Component/Console/Input/ArgvInputTest.php b/tests/Symfony/Tests/Component/Console/Input/ArgvInputTest.php
index 32c0393228..7b3ebccf4a 100644
--- a/tests/Symfony/Tests/Component/Console/Input/ArgvInputTest.php
+++ b/tests/Symfony/Tests/Component/Console/Input/ArgvInputTest.php
@@ -71,6 +71,18 @@ class ArgvInputTest extends \PHPUnit_Framework_TestCase
         $input->bind(new InputDefinition(array(new InputOption('foo', 'f', InputOption::VALUE_REQUIRED))));
         $this->assertEquals(array('foo' => 'bar'), $input->getOptions(), '->parse() parses short options with a required value (with a space separator)');
 
+        $input = new ArgvInput(array('cli.php', '-f', ''));
+        $input->bind(new InputDefinition(array(new InputOption('foo', 'f', InputOption::VALUE_OPTIONAL))));
+        $this->assertEquals(array('foo' => ''), $input->getOptions(), '->parse() parses short options with an optional empty value');
+
+        $input = new ArgvInput(array('cli.php', '-f', '', 'foo'));
+        $input->bind(new InputDefinition(array(new InputArgument('name'), new InputOption('foo', 'f', InputOption::VALUE_OPTIONAL))));
+        $this->assertEquals(array('foo' => ''), $input->getOptions(), '->parse() parses short options with an optional empty value followed by an argument');
+
+        $input = new ArgvInput(array('cli.php', '-f', '', '-b'));
+        $input->bind(new InputDefinition(array(new InputOption('foo', 'f', InputOption::VALUE_OPTIONAL), new InputOption('bar', 'b'))));
+        $this->assertEquals(array('foo' => '', 'bar' => true), $input->getOptions(), '->parse() parses short options with an optional empty value followed by an option');
+
         $input = new ArgvInput(array('cli.php', '-f', '-b', 'foo'));
         $input->bind(new InputDefinition(array(new InputArgument('name'), new InputOption('foo', 'f', InputOption::VALUE_OPTIONAL), new InputOption('bar', 'b'))));
         $this->assertEquals(array('foo' => null, 'bar' => true), $input->getOptions(), '->parse() parses short options with an optional value which is not present');

From ac756bf39e646b4e130fad058d10a0228dbd9779 Mon Sep 17 00:00:00 2001
From: Fabien Potencier <fabien.potencier@gmail.com>
Date: Thu, 17 Jan 2013 09:31:37 +0100
Subject: [PATCH 2/5] added a way to enable/disable PHP support when parsing a
 YAML input via Yaml::parse()

PHP support when parsing a file has been disabled by default.
If you do need PHP support when parsing a YAML file, enable it via:

    Yaml::setPhpParsing(true);

As of Symfony 2.1, PHP support is disabled by default, and support will
be removed in Symfony 2.3.
---
 src/Symfony/Component/Yaml/Yaml.php | 73 ++++++++++++++++++++++++-----
 1 file changed, 61 insertions(+), 12 deletions(-)

diff --git a/src/Symfony/Component/Yaml/Yaml.php b/src/Symfony/Component/Yaml/Yaml.php
index cd5310f24e..f5e3a0e9b4 100644
--- a/src/Symfony/Component/Yaml/Yaml.php
+++ b/src/Symfony/Component/Yaml/Yaml.php
@@ -22,6 +22,53 @@ use Symfony\Component\Yaml\Exception\ParseException;
  */
 class Yaml
 {
+    /**
+     * Be warned that PHP support will be removed in Symfony 2.3.
+     *
+     * @deprecated Deprecated since version 2.0, to be removed in 2.3.
+     */
+    static public $enablePhpParsing = true;
+
+    /**
+     * Enables PHP support when parsing YAML files.
+     *
+     * Be warned that PHP support will be removed in Symfony 2.3.
+     *
+     * @deprecated Deprecated since version 2.0, to be removed in 2.3.
+     */
+    public static function enablePhpParsing()
+    {
+        self::$enablePhpParsing = true;
+    }
+
+    /**
+     * Sets the PHP support flag when parsing YAML files.
+     *
+     * Be warned that PHP support will be removed in Symfony 2.3.
+     *
+     * @param Boolean $boolean true if PHP parsing support is enabled, false otherwise
+     *
+     * @deprecated Deprecated since version 2.0, to be removed in 2.3.
+     */
+    public static function setPhpParsing($boolean)
+    {
+        self::$enablePhpParsing = (Boolean) $boolean;
+    }
+
+    /**
+     * Checks if PHP support is enabled when parsing YAML files.
+     *
+     * Be warned that PHP support will be removed in Symfony 2.3.
+     *
+     * @return Boolean true if PHP parsing support is enabled, false otherwise
+     *
+     * @deprecated Deprecated since version 2.0, to be removed in 2.3.
+     */
+    public static function supportsPhpParsing()
+    {
+        return self::$enablePhpParsing;
+    }
+
     /**
      * Parses YAML into a PHP array.
      *
@@ -44,27 +91,29 @@ class Yaml
      */
     public static function parse($input)
     {
-        $file = '';
-
         // if input is a file, process it
+        $file = '';
         if (strpos($input, "\n") === false && is_file($input)) {
             if (false === is_readable($input)) {
                 throw new ParseException(sprintf('Unable to parse "%s" as the file is not readable.', $input));
             }
 
             $file = $input;
+            if (self::$enablePhpParsing) {
+                ob_start();
+                $retval = include($file);
+                $content = ob_get_clean();
 
-            ob_start();
-            $retval = include($input);
-            $content = ob_get_clean();
+                // if an array is returned by the config file assume it's in plain php form else in YAML
+                $input = is_array($retval) ? $retval : $content;
 
-            // if an array is returned by the config file assume it's in plain php form else in YAML
-            $input = is_array($retval) ? $retval : $content;
-        }
-
-        // if an array is returned by the config file assume it's in plain php form else in YAML
-        if (is_array($input)) {
-            return $input;
+                // if an array is returned by the config file assume it's in plain php form else in YAML
+                if (is_array($input)) {
+                    return $input;
+                }
+            } else {
+                $input = file_get_contents($file);
+            }
         }
 
         $yaml = new Parser();

From ba6e3159c0eeb3b6e21db32fce8fa2535cb3aa77 Mon Sep 17 00:00:00 2001
From: Fabien Potencier <fabien.potencier@gmail.com>
Date: Thu, 17 Jan 2013 09:34:45 +0100
Subject: [PATCH 3/5] added a way to enable/disable object support when
 parsing/dumping

By default, object support is disabled, and instead of throwing an
exception when an object is handled, null is returned.

If you do need object support, enable it via:

    Yaml::dump($data, false, true);

If you want an exception to be thrown in case an invalid type is handled
(a PHP resource or a PHP object), pass true as the second argument:

    Yaml::dump($data, true, true);

The same can be done when parsing:

    Yaml::parse($data, 2, false, true);
---
 .../Bridge/Twig/Extension/YamlExtension.php   | 10 ++--
 src/Symfony/Component/Yaml/Dumper.php         | 16 +++---
 src/Symfony/Component/Yaml/Inline.php         | 56 +++++++++++++++----
 src/Symfony/Component/Yaml/Parser.php         | 26 +++++----
 src/Symfony/Component/Yaml/Yaml.php           | 16 +++---
 .../Tests/Component/Yaml/DumperTest.php       | 21 ++++++-
 .../Tests/Component/Yaml/ParserTest.php       | 28 ++++++++--
 7 files changed, 122 insertions(+), 51 deletions(-)

diff --git a/src/Symfony/Bridge/Twig/Extension/YamlExtension.php b/src/Symfony/Bridge/Twig/Extension/YamlExtension.php
index 130575cb68..f88829ee34 100644
--- a/src/Symfony/Bridge/Twig/Extension/YamlExtension.php
+++ b/src/Symfony/Bridge/Twig/Extension/YamlExtension.php
@@ -31,7 +31,7 @@ class YamlExtension extends \Twig_Extension
         );
     }
 
-    public function encode($input, $inline = 0)
+    public function encode($input, $inline = 0, $dumpObjects = false)
     {
         static $dumper;
 
@@ -39,20 +39,20 @@ class YamlExtension extends \Twig_Extension
             $dumper = new YamlDumper();
         }
 
-        return $dumper->dump($input, $inline);
+        return $dumper->dump($input, $inline, false, $dumpObjects);
     }
 
-    public function dump($value)
+    public function dump($value, $inline = 0, $dumpObjects = false)
     {
         if (is_resource($value)) {
             return '%Resource%';
         }
 
         if (is_array($value) || is_object($value)) {
-            return '%'.gettype($value).'% '.$this->encode($value);
+            return '%'.gettype($value).'% '.$this->encode($value, $inline, $dumpObjects);
         }
 
-        return $this->encode($value);
+        return $this->encode($value, $inline, $dumpObjects);
     }
 
     /**
diff --git a/src/Symfony/Component/Yaml/Dumper.php b/src/Symfony/Component/Yaml/Dumper.php
index ec74cfc478..9829a49c93 100644
--- a/src/Symfony/Component/Yaml/Dumper.php
+++ b/src/Symfony/Component/Yaml/Dumper.php
@@ -21,19 +21,21 @@ class Dumper
     /**
      * Dumps a PHP value to YAML.
      *
-     * @param mixed   $input  The PHP value
-     * @param integer $inline The level where you switch to inline YAML
-     * @param integer $indent The level of indentation (used internally)
+     * @param mixed   $input                  The PHP value
+     * @param integer $inline                 The level where you switch to inline YAML
+     * @param Boolean $exceptionOnInvalidType true if an exception must be thrown on invalid types (a PHP resource or object), false otherwise
+     * @param Boolean $objectSupport          true if object support is enabled, false otherwise
+     * @param integer $indent                 The level of indentation (used internally)
      *
      * @return string  The YAML representation of the PHP value
      */
-    public function dump($input, $inline = 0, $indent = 0)
+    public function dump($input, $inline = 0, $exceptionOnInvalidType = false, $objectSupport = false, $indent = 0)
     {
         $output = '';
         $prefix = $indent ? str_repeat(' ', $indent) : '';
 
         if ($inline <= 0 || !is_array($input) || empty($input)) {
-            $output .= $prefix.Inline::dump($input);
+            $output .= $prefix.Inline::dump($input, $exceptionOnInvalidType, $objectSupport);
         } else {
             $isAHash = array_keys($input) !== range(0, count($input) - 1);
 
@@ -42,9 +44,9 @@ class Dumper
 
                 $output .= sprintf('%s%s%s%s',
                     $prefix,
-                    $isAHash ? Inline::dump($key).':' : '-',
+                    $isAHash ? Inline::dump($key, $exceptionOnInvalidType, $objectSupport).':' : '-',
                     $willBeInlined ? ' ' : "\n",
-                    $this->dump($value, $inline - 1, $willBeInlined ? 0 : $indent + 2)
+                    $this->dump($value, $inline - 1, $exceptionOnInvalidType, $objectSupport, $willBeInlined ? 0 : $indent + 2)
                 ).($willBeInlined ? "\n" : '');
             }
         }
diff --git a/src/Symfony/Component/Yaml/Inline.php b/src/Symfony/Component/Yaml/Inline.php
index 02968d15f9..2f7855d131 100644
--- a/src/Symfony/Component/Yaml/Inline.php
+++ b/src/Symfony/Component/Yaml/Inline.php
@@ -22,15 +22,23 @@ class Inline
 {
     const REGEX_QUOTED_STRING = '(?:"([^"\\\\]*(?:\\\\.[^"\\\\]*)*)"|\'([^\']*(?:\'\'[^\']*)*)\')';
 
+    private static $exceptionOnInvalidType = false;
+    private static $objectSupport = false;
+
     /**
      * Converts a YAML string to a PHP array.
      *
-     * @param string $value A YAML string
+     * @param string  $value                  A YAML string
+     * @param Boolean $exceptionOnInvalidType true if an exception must be thrown on invalid types (a PHP resource or object), false otherwise
+     * @param Boolean $objectSupport          true if object support is enabled, false otherwise
      *
      * @return array A PHP array representing the YAML string
      */
-    public static function parse($value)
+    public static function parse($value, $exceptionOnInvalidType = false, $objectSupport = false)
     {
+        self::$exceptionOnInvalidType = $exceptionOnInvalidType;
+        self::$objectSupport = $objectSupport;
+
         $value = trim($value);
 
         if (0 == strlen($value)) {
@@ -63,21 +71,35 @@ class Inline
     /**
      * Dumps a given PHP variable to a YAML string.
      *
-     * @param mixed $value The PHP variable to convert
+     * @param mixed   $value                  The PHP variable to convert
+     * @param Boolean $exceptionOnInvalidType true if an exception must be thrown on invalid types (a PHP resource or object), false otherwise
+     * @param Boolean $objectSupport          true if object support is enabled, false otherwise
      *
      * @return string The YAML string representing the PHP array
      *
      * @throws DumpException When trying to dump PHP resource
      */
-    public static function dump($value)
+    public static function dump($value, $exceptionOnInvalidType = false, $objectSupport = false)
     {
         switch (true) {
             case is_resource($value):
-                throw new DumpException(sprintf('Unable to dump PHP resources in a YAML file ("%s").', get_resource_type($value)));
+                if ($exceptionOnInvalidType) {
+                    throw new DumpException(sprintf('Unable to dump PHP resources in a YAML file ("%s").', get_resource_type($value)));
+                }
+
+                return 'null';
             case is_object($value):
-                return '!!php/object:'.serialize($value);
+                if ($objectSupport) {
+                    return '!!php/object:'.serialize($value);
+                }
+
+                if ($exceptionOnInvalidType) {
+                    throw new DumpException('Object support when dumping a YAML file has been disabled.');
+                }
+
+                return 'null';
             case is_array($value):
-                return self::dumpArray($value);
+                return self::dumpArray($value, $exceptionOnInvalidType, $objectSupport);
             case null === $value:
                 return 'null';
             case true === $value:
@@ -115,11 +137,13 @@ class Inline
     /**
      * Dumps a PHP array to a YAML string.
      *
-     * @param array $value The PHP array to dump
+     * @param array   $value                  The PHP array to dump
+     * @param Boolean $exceptionOnInvalidType true if an exception must be thrown on invalid types (a PHP resource or object), false otherwise
+     * @param Boolean $objectSupport          true if object support is enabled, false otherwise
      *
      * @return string The YAML string representing the PHP array
      */
-    private static function dumpArray($value)
+    private static function dumpArray($value, $exceptionOnInvalidType, $objectSupport)
     {
         // array
         $keys = array_keys($value);
@@ -128,7 +152,7 @@ class Inline
         ) {
             $output = array();
             foreach ($value as $val) {
-                $output[] = self::dump($val);
+                $output[] = self::dump($val, $exceptionOnInvalidType, $objectSupport);
             }
 
             return sprintf('[%s]', implode(', ', $output));
@@ -137,7 +161,7 @@ class Inline
         // mapping
         $output = array();
         foreach ($value as $key => $val) {
-            $output[] = sprintf('%s: %s', self::dump($key), self::dump($val));
+            $output[] = sprintf('%s: %s', self::dump($key, $exceptionOnInvalidType, $objectSupport), self::dump($val, $exceptionOnInvalidType, $objectSupport));
         }
 
         return sprintf('{ %s }', implode(', ', $output));
@@ -355,7 +379,15 @@ class Inline
             case 0 === strpos($scalar, '! '):
                 return intval(self::parseScalar(substr($scalar, 2)));
             case 0 === strpos($scalar, '!!php/object:'):
-                return unserialize(substr($scalar, 13));
+                if (self::$objectSupport) {
+                    return unserialize(substr($scalar, 13));
+                }
+
+                if (self::$exceptionOnInvalidType) {
+                    throw new ParseException('Object support when parsing a YAML file has been disabled.');
+                }
+
+                return null;
             case ctype_digit($scalar):
                 $raw = $scalar;
                 $cast = intval($scalar);
diff --git a/src/Symfony/Component/Yaml/Parser.php b/src/Symfony/Component/Yaml/Parser.php
index 0bc4250609..1c0fdd828a 100644
--- a/src/Symfony/Component/Yaml/Parser.php
+++ b/src/Symfony/Component/Yaml/Parser.php
@@ -38,13 +38,15 @@ class Parser
     /**
      * Parses a YAML string to a PHP value.
      *
-     * @param string $value A YAML string
+     * @param string  $value                  A YAML string
+     * @param Boolean $exceptionOnInvalidType true if an exception must be thrown on invalid types (a PHP resource or object), false otherwise
+     * @param Boolean $objectSupport          true if object support is enabled, false otherwise
      *
      * @return mixed  A PHP value
      *
      * @throws ParseException If the YAML is not valid
      */
-    public function parse($value)
+    public function parse($value, $exceptionOnInvalidType = false, $objectSupport = false)
     {
         $this->currentLineNb = -1;
         $this->currentLine = '';
@@ -82,7 +84,7 @@ class Parser
                     $c = $this->getRealCurrentLineNb() + 1;
                     $parser = new Parser($c);
                     $parser->refs =& $this->refs;
-                    $data[] = $parser->parse($this->getNextEmbedBlock());
+                    $data[] = $parser->parse($this->getNextEmbedBlock(), $exceptionOnInvalidType, $objectSupport);
                 } else {
                     if (isset($values['leadspaces'])
                         && ' ' == $values['leadspaces']
@@ -98,12 +100,14 @@ class Parser
                             $block .= "\n".$this->getNextEmbedBlock($this->getCurrentLineIndentation() + 2);
                         }
 
-                        $data[] = $parser->parse($block);
+                        $data[] = $parser->parse($block, $exceptionOnInvalidType, $objectSupport);
                     } else {
-                        $data[] = $this->parseValue($values['value']);
+                        $data[] = $this->parseValue($values['value'], $exceptionOnInvalidType, $objectSupport);
                     }
                 }
             } elseif (preg_match('#^(?P<key>'.Inline::REGEX_QUOTED_STRING.'|[^ \'"\[\{].*?) *\:(\s+(?P<value>.+?))?\s*$#u', $this->currentLine, $values)) {
+                // force correct settings
+                Inline::parse(null, $exceptionOnInvalidType, $objectSupport);
                 try {
                     $key = Inline::parseScalar($values['key']);
                 } catch (ParseException $e) {
@@ -128,7 +132,7 @@ class Parser
                         $c = $this->getRealCurrentLineNb() + 1;
                         $parser = new Parser($c);
                         $parser->refs =& $this->refs;
-                        $parsed = $parser->parse($value);
+                        $parsed = $parser->parse($value, $exceptionOnInvalidType, $objectSupport);
 
                         $merged = array();
                         if (!is_array($parsed)) {
@@ -165,20 +169,20 @@ class Parser
                         $c = $this->getRealCurrentLineNb() + 1;
                         $parser = new Parser($c);
                         $parser->refs =& $this->refs;
-                        $data[$key] = $parser->parse($this->getNextEmbedBlock());
+                        $data[$key] = $parser->parse($this->getNextEmbedBlock(), $exceptionOnInvalidType, $objectSupport);
                     }
                 } else {
                     if ($isInPlace) {
                         $data = $this->refs[$isInPlace];
                     } else {
-                        $data[$key] = $this->parseValue($values['value']);
+                        $data[$key] = $this->parseValue($values['value'], $exceptionOnInvalidType, $objectSupport);
                     }
                 }
             } else {
                 // 1-liner followed by newline
                 if (2 == count($this->lines) && empty($this->lines[1])) {
                     try {
-                        $value = Inline::parse($this->lines[0]);
+                        $value = Inline::parse($this->lines[0], $exceptionOnInvalidType, $objectSupport);
                     } catch (ParseException $e) {
                         $e->setParsedLine($this->getRealCurrentLineNb() + 1);
                         $e->setSnippet($this->currentLine);
@@ -345,7 +349,7 @@ class Parser
      *
      * @throws ParseException When reference does not exist
      */
-    private function parseValue($value)
+    private function parseValue($value, $exceptionOnInvalidType, $objectSupport)
     {
         if (0 === strpos($value, '*')) {
             if (false !== $pos = strpos($value, '#')) {
@@ -368,7 +372,7 @@ class Parser
         }
 
         try {
-            return Inline::parse($value);
+            return Inline::parse($value, $exceptionOnInvalidType, $objectSupport);
         } catch (ParseException $e) {
             $e->setParsedLine($this->getRealCurrentLineNb() + 1);
             $e->setSnippet($this->currentLine);
diff --git a/src/Symfony/Component/Yaml/Yaml.php b/src/Symfony/Component/Yaml/Yaml.php
index f5e3a0e9b4..ae175f1b0e 100644
--- a/src/Symfony/Component/Yaml/Yaml.php
+++ b/src/Symfony/Component/Yaml/Yaml.php
@@ -27,7 +27,7 @@ class Yaml
      *
      * @deprecated Deprecated since version 2.0, to be removed in 2.3.
      */
-    static public $enablePhpParsing = true;
+    public static $enablePhpParsing = true;
 
     /**
      * Enables PHP support when parsing YAML files.
@@ -89,7 +89,7 @@ class Yaml
      *
      * @api
      */
-    public static function parse($input)
+    public static function parse($input, $exceptionOnInvalidType = false, $objectSupport = false)
     {
         // if input is a file, process it
         $file = '';
@@ -119,7 +119,7 @@ class Yaml
         $yaml = new Parser();
 
         try {
-            return $yaml->parse($input);
+            return $yaml->parse($input, $exceptionOnInvalidType, $objectSupport);
         } catch (ParseException $e) {
             if ($file) {
                 $e->setParsedFile($file);
@@ -135,17 +135,19 @@ class Yaml
      * The dump method, when supplied with an array, will do its best
      * to convert the array into friendly YAML.
      *
-     * @param array   $array  PHP array
-     * @param integer $inline The level where you switch to inline YAML
+     * @param array   $array                  PHP array
+     * @param integer $inline                 The level where you switch to inline YAML
+     * @param Boolean $exceptionOnInvalidType true if an exception must be thrown on invalid types (a PHP resource or object), false otherwise
+     * @param Boolean $objectSupport          true if object support is enabled, false otherwise
      *
      * @return string A YAML string representing the original PHP array
      *
      * @api
      */
-    public static function dump($array, $inline = 2)
+    public static function dump($array, $inline = 2, $exceptionOnInvalidType = false, $objectSupport = false)
     {
         $yaml = new Dumper();
 
-        return $yaml->dump($array, $inline);
+        return $yaml->dump($array, $inline, $exceptionOnInvalidType, $objectSupport);
     }
 }
diff --git a/tests/Symfony/Tests/Component/Yaml/DumperTest.php b/tests/Symfony/Tests/Component/Yaml/DumperTest.php
index 33b3978683..83e08ca8cb 100644
--- a/tests/Symfony/Tests/Component/Yaml/DumperTest.php
+++ b/tests/Symfony/Tests/Component/Yaml/DumperTest.php
@@ -152,11 +152,26 @@ EOF;
         $this->assertEquals($expected, $this->dumper->dump($array, 10), '->dump() takes an inline level argument');
     }
 
-    public function testObjectsSupport()
+    public function testObjectSupportEnabled()
     {
-        $a = array('foo' => new A(), 'bar' => 1);
+        $dump = $this->dumper->dump(array('foo' => new A(), 'bar' => 1), 0, false, true);
 
-        $this->assertEquals('{ foo: !!php/object:O:30:"Symfony\Tests\Component\Yaml\A":1:{s:1:"a";s:3:"foo";}, bar: 1 }', $this->dumper->dump($a), '->dump() is able to dump objects');
+        $this->assertEquals('{ foo: !!php/object:O:30:"Symfony\Tests\Component\Yaml\A":1:{s:1:"a";s:3:"foo";}, bar: 1 }', $dump, '->dump() is able to dump objects');
+    }
+
+    public function testObjectSupportDisabledButNoExceptions()
+    {
+        $dump = $this->dumper->dump(array('foo' => new A(), 'bar' => 1));
+
+        $this->assertEquals('{ foo: null, bar: 1 }', $dump, '->dump() does not dump objects when disabled');
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Yaml\Exception\DumpException
+     */
+    public function testObjectSupportDisabledWithExceptions()
+    {
+        $this->dumper->dump(array('foo' => new A(), 'bar' => 1), 0, true, false);
     }
 }
 
diff --git a/tests/Symfony/Tests/Component/Yaml/ParserTest.php b/tests/Symfony/Tests/Component/Yaml/ParserTest.php
index 6a684ed99f..4b3f3bf273 100644
--- a/tests/Symfony/Tests/Component/Yaml/ParserTest.php
+++ b/tests/Symfony/Tests/Component/Yaml/ParserTest.php
@@ -13,7 +13,6 @@ namespace Symfony\Tests\Component\Yaml;
 
 use Symfony\Component\Yaml\Yaml;
 use Symfony\Component\Yaml\Parser;
-use Symfony\Component\Yaml\Exception\ParseException;
 
 class ParserTest extends \PHPUnit_Framework_TestCase
 {
@@ -106,14 +105,31 @@ EOF;
         $this->assertEquals('foo', $this->parser->parse($yaml));
     }
 
-    public function testObjectsSupport()
+    public function testObjectSupportEnabled()
     {
-        $b = array('foo' => new B(), 'bar' => 1);
-        $this->assertEquals($this->parser->parse(<<<EOF
+        $input = <<<EOF
 foo: !!php/object:O:30:"Symfony\Tests\Component\Yaml\B":1:{s:1:"b";s:3:"foo";}
 bar: 1
-EOF
-        ), $b, '->parse() is able to dump objects');
+EOF;
+        $this->assertEquals(array('foo' => new B(), 'bar' => 1), $this->parser->parse($input, false, true), '->parse() is able to parse objects');
+    }
+
+    public function testObjectSupportDisabledButNoExceptions()
+    {
+        $input = <<<EOF
+foo: !!php/object:O:30:"Symfony\Tests\Component\Yaml\B":1:{s:1:"b";s:3:"foo";}
+bar: 1
+EOF;
+
+        $this->assertEquals(array('foo' => null, 'bar' => 1), $this->parser->parse($input), '->parse() does not parse objects');
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Yaml\Exception\ParseException
+     */
+    public function testObjectsSupportDisabledWithExceptions()
+    {
+        $this->parser->parse('foo: !!php/object:O:30:"Symfony\Tests\Component\Yaml\B":1:{s:1:"b";s:3:"foo";}', true, false);
     }
 
     public function testNonUtf8Exception()

From 3c87e2ea185b54413aed92ef9738658f9be13f50 Mon Sep 17 00:00:00 2001
From: sun <sun@unleashedmind.com>
Date: Sun, 5 Aug 2012 00:46:53 +0200
Subject: [PATCH 4/5] Added Yaml\Dumper::setIndentation() method to allow a
 custom indentation level of nested nodes.

YAML does not specify an absolute indentation level, but a consistent indentation of nested nodes only: http://www.yaml.org/spec/1.2/spec.html#space/indentation/

Projects that are generally using 2 spaces for indentation should be able to retain consistency with their coding standards by supplying a custom value for the new $indent parameter added to Yaml::dump(), or the new Dumper::setIndentation() method.

The new parameter is a backwards-compatible API addition and defaults to the previous default of 4 (which was changed from 2 via PR #2242 only recently).

Conflicts:
	src/Symfony/Component/Yaml/Dumper.php
	src/Symfony/Component/Yaml/Yaml.php
---
 src/Symfony/Component/Yaml/Dumper.php | 19 ++++++++++++++++++-
 src/Symfony/Component/Yaml/Yaml.php   |  4 +++-
 2 files changed, 21 insertions(+), 2 deletions(-)

diff --git a/src/Symfony/Component/Yaml/Dumper.php b/src/Symfony/Component/Yaml/Dumper.php
index 9829a49c93..5b0baa5271 100644
--- a/src/Symfony/Component/Yaml/Dumper.php
+++ b/src/Symfony/Component/Yaml/Dumper.php
@@ -18,6 +18,23 @@ namespace Symfony\Component\Yaml;
  */
 class Dumper
 {
+    /**
+     * The amount of spaces to use for indentation of nested nodes.
+     *
+     * @var integer
+     */
+    protected $indentation = 2;
+
+    /**
+     * Sets the indentation.
+     *
+     * @param integer $num The amount of spaces to use for intendation of nested nodes.
+     */
+    public function setIndentation($num)
+    {
+        $this->indentation = $num;
+    }
+
     /**
      * Dumps a PHP value to YAML.
      *
@@ -46,7 +63,7 @@ class Dumper
                     $prefix,
                     $isAHash ? Inline::dump($key, $exceptionOnInvalidType, $objectSupport).':' : '-',
                     $willBeInlined ? ' ' : "\n",
-                    $this->dump($value, $inline - 1, $exceptionOnInvalidType, $objectSupport, $willBeInlined ? 0 : $indent + 2)
+                    $this->dump($value, $inline - 1, $exceptionOnInvalidType, $objectSupport, $willBeInlined ? 0 : $indent + $this->indentation)
                 ).($willBeInlined ? "\n" : '');
             }
         }
diff --git a/src/Symfony/Component/Yaml/Yaml.php b/src/Symfony/Component/Yaml/Yaml.php
index ae175f1b0e..205d866466 100644
--- a/src/Symfony/Component/Yaml/Yaml.php
+++ b/src/Symfony/Component/Yaml/Yaml.php
@@ -137,6 +137,7 @@ class Yaml
      *
      * @param array   $array                  PHP array
      * @param integer $inline                 The level where you switch to inline YAML
+     * @param integer $indent                 The amount of spaces to use for indentation of nested nodes.
      * @param Boolean $exceptionOnInvalidType true if an exception must be thrown on invalid types (a PHP resource or object), false otherwise
      * @param Boolean $objectSupport          true if object support is enabled, false otherwise
      *
@@ -144,9 +145,10 @@ class Yaml
      *
      * @api
      */
-    public static function dump($array, $inline = 2, $exceptionOnInvalidType = false, $objectSupport = false)
+    public static function dump($array, $inline = 2, $indent = 4, $exceptionOnInvalidType = false, $objectSupport = false)
     {
         $yaml = new Dumper();
+        $yaml->setIndentation($indent);
 
         return $yaml->dump($array, $inline, $exceptionOnInvalidType, $objectSupport);
     }

From e17e2327b18ff91f89234ddc13c1525b852a88b6 Mon Sep 17 00:00:00 2001
From: Fabien Potencier <fabien.potencier@gmail.com>
Date: Thu, 17 Jan 2013 16:16:00 +0100
Subject: [PATCH 5/5] [Yaml] fixed default value

---
 src/Symfony/Component/Yaml/Yaml.php | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Symfony/Component/Yaml/Yaml.php b/src/Symfony/Component/Yaml/Yaml.php
index 205d866466..ca24cffb9c 100644
--- a/src/Symfony/Component/Yaml/Yaml.php
+++ b/src/Symfony/Component/Yaml/Yaml.php
@@ -27,7 +27,7 @@ class Yaml
      *
      * @deprecated Deprecated since version 2.0, to be removed in 2.3.
      */
-    public static $enablePhpParsing = true;
+    public static $enablePhpParsing = false;
 
     /**
      * Enables PHP support when parsing YAML files.