Dumper.php

@@ -64,14 +64,31 @@ public function dump($input, int $inline = 0, int $indent = 0, int $flags = 0):
             $dumpAsMap = Inline::isHash($input);
 
             foreach ($input as $key => $value) {
+                if ('' !== $output && "\n" !== $output[-1]) {
+                    $output .= "\n";
+                }
+
                 if ($inline >= 1 && Yaml::DUMP_MULTI_LINE_LITERAL_BLOCK & $flags && \is_string($value) && false !== strpos($value, "\n") && false === strpos($value, "\r")) {
                     // If the first line starts with a space character, the spec requires a blockIndicationIndicator
                     // http://www.yaml.org/spec/1.2/spec.html#id2793979
                     $blockIndentationIndicator = (' ' === substr($value, 0, 1)) ? (string) $this->indentation : '';
-                    $output .= sprintf("%s%s%s |%s\n", $prefix, $dumpAsMap ? Inline::dump($key, $flags).':' : '-', '', $blockIndentationIndicator);
+
+                    if (isset($value[-2]) && "\n" === $value[-2] && "\n" === $value[-1]) {
+                        $blockChompingIndicator = '+';
+                    } elseif ("\n" === $value[-1]) {
+                        $blockChompingIndicator = '';
+                    } else {
+                        $blockChompingIndicator = '-';
+                    }
+
+                    $output .= sprintf('%s%s%s |%s%s', $prefix, $dumpAsMap ? Inline::dump($key, $flags).':' : '-', '', $blockIndentationIndicator, $blockChompingIndicator);
 
                     foreach (explode("\n", $value) as $row) {
-                        $output .= sprintf("%s%s%s\n", $prefix, str_repeat(' ', $this->indentation), $row);
+                        if ('' === $row) {
+                            $output .= "\n";
+                        } else {
+                            $output .= sprintf("\n%s%s%s", $prefix, str_repeat(' ', $this->indentation), $row);
+                        }
                     }
 
                     continue;
@@ -84,10 +101,10 @@ public function dump($input, int $inline = 0, int $indent = 0, int $flags = 0):
                         // If the first line starts with a space character, the spec requires a blockIndicationIndicator
                         // http://www.yaml.org/spec/1.2/spec.html#id2793979
                         $blockIndentationIndicator = (' ' === substr($value->getValue(), 0, 1)) ? (string) $this->indentation : '';
-                        $output .= sprintf(" |%s\n", $blockIndentationIndicator);
+                        $output .= sprintf(' |%s', $blockIndentationIndicator);
 
                         foreach (explode("\n", $value->getValue()) as $row) {
-                            $output .= sprintf("%s%s%s\n", $prefix, str_repeat(' ', $this->indentation), $row);
+                            $output .= sprintf("\n%s%s%s", $prefix, str_repeat(' ', $this->indentation), $row);
                         }
 
                         continue;

Escaper.php

@@ -28,15 +28,15 @@ class Escaper
     // first to ensure proper escaping because str_replace operates iteratively
     // on the input arrays. This ordering of the characters avoids the use of strtr,
     // which performs more slowly.
-    private static $escapees = ['\\', '\\\\', '\\"', '"',
+    private const ESCAPEES = ['\\', '\\\\', '\\"', '"',
                                      "\x00",  "\x01",  "\x02",  "\x03",  "\x04",  "\x05",  "\x06",  "\x07",
                                      "\x08",  "\x09",  "\x0a",  "\x0b",  "\x0c",  "\x0d",  "\x0e",  "\x0f",
                                      "\x10",  "\x11",  "\x12",  "\x13",  "\x14",  "\x15",  "\x16",  "\x17",
                                      "\x18",  "\x19",  "\x1a",  "\x1b",  "\x1c",  "\x1d",  "\x1e",  "\x1f",
                                      "\x7f",
                                      "\xc2\x85", "\xc2\xa0", "\xe2\x80\xa8", "\xe2\x80\xa9",
                                ];
-    private static $escaped = ['\\\\', '\\"', '\\\\', '\\"',
+    private const ESCAPED = ['\\\\', '\\"', '\\\\', '\\"',
                                      '\\0',   '\\x01', '\\x02', '\\x03', '\\x04', '\\x05', '\\x06', '\\a',
                                      '\\b',   '\\t',   '\\n',   '\\v',   '\\f',   '\\r',   '\\x0e', '\\x0f',
                                      '\\x10', '\\x11', '\\x12', '\\x13', '\\x14', '\\x15', '\\x16', '\\x17',
@@ -66,7 +66,7 @@ public static function requiresDoubleQuoting(string $value): bool
      */
     public static function escapeWithDoubleQuotes(string $value): string
     {
-        return sprintf('"%s"', str_replace(self::$escapees, self::$escaped, $value));
+        return sprintf('"%s"', str_replace(self::ESCAPEES, self::ESCAPED, $value));
     }
 
     /**
@@ -86,7 +86,7 @@ public static function requiresSingleQuoting(string $value): bool
 
         // Determines if the PHP value contains any single characters that would
         // cause it to require single quoting in YAML.
-        return 0 < preg_match('/[ \s \' " \: \{ \} \[ \] , & \* \# \?] | \A[ \- ? | < > = ! % @ ` ]/x', $value);
+        return 0 < preg_match('/[ \s \' " \: \{ \} \[ \] , & \* \# \?] | \A[ \- ? | < > = ! % @ ` \p{Zs}]/xu', $value);
     }
 
     /**

LICENSE

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

Parser.php

@@ -200,7 +200,7 @@ private function doParse(string $value, int $flags)
                     array_pop($this->refsBeingParsed);
                 }
             } elseif (
-                self::preg_match('#^(?P<key>(?:![^\s]++\s++)?(?:'.Inline::REGEX_QUOTED_STRING.'|(?:!?!php/const:)?[^ \'"\[\{!].*?)) *\:(\s++(?P<value>.+))?$#u', rtrim($this->currentLine), $values)
+                self::preg_match('#^(?P<key>(?:![^\s]++\s++)?(?:'.Inline::REGEX_QUOTED_STRING.'|(?:!?!php/const:)?[^ \'"\[\{!].*?)) *\:( ++(?P<value>.+))?$#u', rtrim($this->currentLine), $values)
                 && (false === strpos($values['key'], ' #') || \in_array($values['key'][0], ['"', "'"]))
             ) {
                 if ($context && 'sequence' == $context) {
@@ -724,7 +724,7 @@ private function parseValue(string $value, int $flags, string $context)
         }
 
         if (\in_array($value[0], ['!', '|', '>'], true) && self::preg_match('/^(?:'.self::TAG_PATTERN.' +)?'.self::BLOCK_SCALAR_HEADER_PATTERN.'$/', $value, $matches)) {
-            $modifiers = isset($matches['modifiers']) ? $matches['modifiers'] : '';
+            $modifiers = $matches['modifiers'] ?? '';
 
             $data = $this->parseBlockScalar($matches['separator'], preg_replace('#\d+#', '', $modifiers), abs((int) $modifiers));
 

Tests/Command/LintCommandTest.php

@@ -92,7 +92,7 @@ public function testCustomTagsError()
 
     public function testLintFileNotReadable()
     {
-        $this->expectException('RuntimeException');
+        $this->expectException(\RuntimeException::class);
         $tester = $this->createCommandTester();
         $filename = $this->createFile('');
         unlink($filename);

Tests/DumperTest.php

@@ -13,6 +13,7 @@
 
 use PHPUnit\Framework\TestCase;
 use Symfony\Component\Yaml\Dumper;
+use Symfony\Component\Yaml\Exception\DumpException;
 use Symfony\Component\Yaml\Parser;
 use Symfony\Component\Yaml\Tag\TaggedValue;
 use Symfony\Component\Yaml\Yaml;
@@ -194,7 +195,7 @@ public function testObjectSupportDisabledButNoExceptions()
 
     public function testObjectSupportDisabledWithExceptions()
     {
-        $this->expectException('Symfony\Component\Yaml\Exception\DumpException');
+        $this->expectException(DumpException::class);
         $this->dumper->dump(['foo' => new A(), 'bar' => 1], 0, 0, Yaml::DUMP_EXCEPTION_ON_INVALID_TYPE);
     }
 
@@ -493,19 +494,16 @@ public function testDumpingMultiLineStringAsScalarBlockTaggedValue()
         $data = [
             'foo' => new TaggedValue('bar', "foo\nline with trailing spaces:\n  \nbar\ninteger like line:\n123456789\nempty line:\n\nbaz"),
         ];
-        $expected = <<<YAML
-foo: !bar |
-    foo
-    line with trailing spaces:
-      
-    bar
-    integer like line:
-    123456789
-    empty line:
-    
-    baz
-
-YAML;
+        $expected = "foo: !bar |\n".
+            "    foo\n".
+            "    line with trailing spaces:\n".
+            "      \n".
+            "    bar\n".
+            "    integer like line:\n".
+            "    123456789\n".
+            "    empty line:\n".
+            "    \n".
+            '    baz';
 
         $this->assertSame($expected, $this->dumper->dump($data, 2, 0, Yaml::DUMP_MULTI_LINE_LITERAL_BLOCK));
     }
@@ -545,7 +543,9 @@ public function testDumpMultiLineStringAsScalarBlockWhenFirstLineHasLeadingSpace
             ],
         ];
 
-        $this->assertSame(file_get_contents(__DIR__.'/Fixtures/multiple_lines_as_literal_block_leading_space_in_first_line.yml'), $this->dumper->dump($data, 2, 0, Yaml::DUMP_MULTI_LINE_LITERAL_BLOCK));
+        $expected = "data:\n    multi_line: |4-\n            the first line has leading spaces\n        The second line does not.";
+
+        $this->assertSame($expected, $this->dumper->dump($data, 2, 0, Yaml::DUMP_MULTI_LINE_LITERAL_BLOCK));
     }
 
     public function testCarriageReturnFollowedByNewlineIsMaintainedWhenDumpingAsMultiLineLiteralBlock()
@@ -568,16 +568,66 @@ public function testCarriageReturnNotFollowedByNewlineIsPreservedWhenDumpingAsMu
         ], 4, 0, Yaml::DUMP_MULTI_LINE_LITERAL_BLOCK));
     }
 
+    public function testNoExtraTrailingNewlineWhenDumpingAsMultiLineLiteralBlock()
+    {
+        $data = [
+            "a\nb",
+            "c\nd",
+        ];
+        $yaml = $this->dumper->dump($data, 2, 0, Yaml::DUMP_MULTI_LINE_LITERAL_BLOCK);
+
+        $this->assertSame("- |-\n    a\n    b\n- |-\n    c\n    d", $yaml);
+        $this->assertSame($data, Yaml::parse($yaml));
+    }
+
+    public function testDumpTrailingNewlineInMultiLineLiteralBlocks()
+    {
+        $data = [
+            'clip 1' => "one\ntwo\n",
+            'clip 2' => "one\ntwo\n",
+            'keep 1' => "one\ntwo\n",
+            'keep 2' => "one\ntwo\n\n",
+            'strip 1' => "one\ntwo",
+            'strip 2' => "one\ntwo",
+        ];
+        $yaml = $this->dumper->dump($data, 2, 0, Yaml::DUMP_MULTI_LINE_LITERAL_BLOCK);
+
+        $expected = <<<YAML
+'clip 1': |
+    one
+    two
+'clip 2': |
+    one
+    two
+'keep 1': |
+    one
+    two
+'keep 2': |+
+    one
+    two
+
+'strip 1': |-
+    one
+    two
+'strip 2': |-
+    one
+    two
+YAML;
+
+        $this->assertSame($expected, $yaml);
+        $this->assertSame($data, Yaml::parse($yaml));
+    }
+
     public function testZeroIndentationThrowsException()
     {
-        $this->expectException('InvalidArgumentException');
+        $this->expectException(\InvalidArgumentException::class);
         $this->expectExceptionMessage('The indentation must be greater than zero');
         new Dumper(0);
     }
 
     public function testNegativeIndentationThrowsException()
     {
-        $this->expectException('InvalidArgumentException');
+        $this->expectException(\InvalidArgumentException::class);
         $this->expectExceptionMessage('The indentation must be greater than zero');
         new Dumper(-4);
     }
@@ -586,6 +636,21 @@ public function testDumpNullAsTilde()
     {
         $this->assertSame('{ foo: ~ }', $this->dumper->dump(['foo' => null], 0, 0, Yaml::DUMP_NULL_AS_TILDE));
     }
+
+    public function testDumpIdeographicSpaces()
+    {
+        $expected = <<<YAML
+alone: '　'
+within_string: 'a　b'
+regular_space: 'a b'
+
+YAML;
+        $this->assertSame($expected, $this->dumper->dump([
+            'alone' => '　',
+            'within_string' => 'a　b',
+            'regular_space' => 'a b',
+        ], 2));
+    }
 }
 
 class A

Tests/Fixtures/multiple_lines_as_literal_block.yml

@@ -1,14 +1,14 @@
 data:
     single_line: 'foo bar baz'
-    multi_line: |
+    multi_line: |-
         foo
         line with trailing spaces:
           
         bar
         integer like line:
         123456789
         empty line:
-        
+
         baz
     multi_line_with_carriage_return: "foo\nbar\r\nbaz"
     nested_inlined_multi_line_string: { inlined_multi_line: "foo\nbar\r\nempty line:\n\nbaz" }