Replace "\n" with PHP_EOL

Author: imliam

ext/markup/tests/children.phpt

@@ -11,25 +11,25 @@ use function Markup\raw;
 // --- scalar and array child coercion ---
 
 // Scalars: int/float stringify, true -> "1", false/null -> "".
-echo (new Element('p', [], [1, ' ', 2.5, ' ', true, false, null]))->__toString(), "\n";
+echo (new Element('p', [], [1, ' ', 2.5, ' ', true, false, null]))->__toString(), PHP_EOL;
 
 // Arrays flatten recursively (the array_map loop idiom).
 $items = ['Ada', 'Linus', 'Grace'];
 echo (new Element('ul', [], [
     array_map(fn($n) => new Element('li', [], [$n]), $items),
-]))->__toString(), "\n";
+]))->__toString(), PHP_EOL;
 
 // A nested Html passes through un-escaped.
-echo (new Element('div', [], [raw('<b>bold</b>')]))->__toString(), "\n";
+echo (new Element('div', [], [raw('<b>bold</b>')]))->__toString(), PHP_EOL;
 
 // Nested elements are Html too.
-echo (new Element('div', [], [new Element('em', [], ['hi & bye'])]))->__toString(), "\n";
+echo (new Element('div', [], [new Element('em', [], ['hi & bye'])]))->__toString(), PHP_EOL;
 
 // Non-Stringable object is a hard error.
 try {
     (new Element('div', [], [new stdClass]))->__toString();
 } catch (\Throwable $e) {
-    echo $e::class, ': ', $e->getMessage(), "\n";
+    echo $e::class, ': ', $e->getMessage(), PHP_EOL;
 }
 
 // --- Traversable children: generators, Iterator, IteratorAggregate ---
@@ -39,19 +39,19 @@ function rows(): Generator {
     yield new Element('li', [], ['one']);
     yield new Element('li', [], ['two']);
 }
-echo (new Element('ul', [], [rows()]))->__toString(), "\n";
+echo (new Element('ul', [], [rows()]))->__toString(), PHP_EOL;
 
 // ArrayIterator (Iterator), mixing scalars and Html, with keys ignored
 $it = new ArrayIterator(['a' => 'x & y', 'b' => new Element('b', [], ['z'])]);
-echo (new Element('p', [], [$it]))->__toString(), "\n";
+echo (new Element('p', [], [$it]))->__toString(), PHP_EOL;
 
 // IteratorAggregate, nested inside an array (recursive flattening)
 $agg = new class implements IteratorAggregate {
     public function getIterator(): Iterator {
         return new ArrayIterator([new Element('span', [], ['nested'])]);
     }
 };
-echo (new Element('div', [], [['before ', $agg, ' after']]))->__toString(), "\n";
+echo (new Element('div', [], [['before ', $agg, ' after']]))->__toString(), PHP_EOL;
 
 // An exception thrown mid-iteration propagates.
 function boom(): Generator {
@@ -61,7 +61,7 @@ function boom(): Generator {
 try {
     (new Element('div', [], [boom()]))->__toString();
 } catch (\Throwable $e) {
-    echo $e::class, ': ', $e->getMessage(), "\n";
+    echo $e::class, ': ', $e->getMessage(), PHP_EOL;
 }
 
 // --- nesting-depth bound ---
@@ -72,13 +72,13 @@ for ($i = 0; $i < 2048; $i++) {
     $kids = [$kids];
 }
 try {
-    echo (new E('div', [], $kids))->__toString(), "\n";
+    echo (new E('div', [], $kids))->__toString(), PHP_EOL;
 } catch (\Throwable $e) {
-    echo $e::class, ': ', $e->getMessage(), "\n";
+    echo $e::class, ': ', $e->getMessage(), PHP_EOL;
 }
 
 // Normal (shallow) nesting still renders.
-echo (new E('ul', [], [[[new E('li', [], ['ok'])]]]))->__toString(), "\n";
+echo (new E('ul', [], [[[new E('li', [], ['ok'])]]]))->__toString(), PHP_EOL;
 ?>
 --EXPECTF--
 <p>1 2.5 1</p>

ext/markup/tests/component_hardening.phpt

@@ -11,7 +11,7 @@ function expect_error(callable $f): void {
         $f();
         echo "NO ERROR\n";
     } catch (Error $e) {
-        echo $e::class, ": ", $e->getMessage(), "\n";
+        echo $e::class, ": ", $e->getMessage(), PHP_EOL;
     }
 }
 
@@ -49,7 +49,7 @@ class NoCtor implements Markup\Html {
     public function toHtml(): Markup\Html { return Markup\raw("no-ctor"); }
 }
 expect_error(fn() => render_component("NoCtor", ["title" => "x"]));
-echo render_component("NoCtor"), "\n"; // without props it is fine
+echo render_component("NoCtor"), PHP_EOL; // without props it is fine
 
 // --- static-method visibility guards ---
 
@@ -75,7 +75,7 @@ for ($i = 0; $i < 3; $i++) {
     try {
         echo render_component('NeedsDep')->__toString();
     } catch (\Error $e) {
-        echo $e->getMessage(), "\n";
+        echo $e->getMessage(), PHP_EOL;
     }
 }
 
@@ -87,7 +87,7 @@ class Boom implements Markup\Html {
 try {
     echo render_component('Boom')->__toString();
 } catch (\Throwable $e) {
-    echo $e::class, ": ", $e->getMessage(), "\n";
+    echo $e::class, ": ", $e->getMessage(), PHP_EOL;
 }
 
 echo "clean\n";

ext/markup/tests/component_hooks.phpt

@@ -64,30 +64,30 @@ $make = fn(string $class, array $args)
 
 // (1) Without hooks, the engine's own `new` runs and fails for the missing Clock.
 try { echo <TimeBadge label="x"/>; }
-catch (\Error $e) { echo "default:  ", $e->getMessage(), "\n"; }
+catch (\Error $e) { echo "default:  ", $e->getMessage(), PHP_EOL; }
 
 // $defer is first, so a working result proves the chain skips a null-returning
 // factory and falls through to $make.
 register_component_factory($defer);
 register_component_factory($make);
 
-echo "class:    ", <TimeBadge label="A"/>, "\n";
+echo "class:    ", <TimeBadge label="A"/>, PHP_EOL;
 
 // (2) A factory must return an instance of the requested class. Swap $make for a
 // bad factory so the chain becomes [$defer, $bad] and the bad one is reached.
 var_dump(unregister_component_factory($make));
 $bad = fn(string $class, array $args) => new Clock();
 register_component_factory($bad);
 try { echo <TimeBadge label="e"/>; }
-catch (\Error $e) { echo "badreturn: ", $e->getMessage(), "\n"; }
+catch (\Error $e) { echo "badreturn: ", $e->getMessage(), PHP_EOL; }
 
 // (3) Unregistering everything restores the engine default. Unregister identity
 // is by callable; a fresh closure does not match.
 var_dump(unregister_component_factory(fn($c, $a) => null));
 var_dump(unregister_component_factory($defer));
 var_dump(unregister_component_factory($bad));
 try { echo <TimeBadge label="f"/>; }
-catch (\Error $e) { echo "restored:  ", $e->getMessage(), "\n"; }
+catch (\Error $e) { echo "restored:  ", $e->getMessage(), PHP_EOL; }
 
 // --- decorators: uniform wrapping, composition, bad return ---
 
@@ -96,20 +96,20 @@ catch (\Error $e) { echo "restored:  ", $e->getMessage(), "\n"; }
 $marker = fn(Markup\Html $h, string $c) => Markup\raw("[$c]" . $h . "[/$c]");
 register_component_decorator($marker);
 
-echo <Card title="a"/>, "\n";
-echo <Note t="b"/>, "\n";
-echo <Author::byline t="c"/>, "\n";
+echo <Card title="a"/>, PHP_EOL;
+echo <Note t="b"/>, PHP_EOL;
+echo <Author::byline t="c"/>, PHP_EOL;
 
 // Decorators compose in registration order, each wrapping the previous result.
 $outer = fn(Markup\Html $h, string $c) => Markup\raw("<<" . $h . ">>");
 register_component_decorator($outer);
-echo <Note t="d"/>, "\n";
+echo <Note t="d"/>, PHP_EOL;
 
 // A decorator must return a Markup\Html.
 $badDecorator = fn(Markup\Html $h, string $c) => "not html";
 register_component_decorator($badDecorator);
 try { echo <Note t="e"/>; }
-catch (\Error $e) { echo $e->getMessage(), "\n"; }
+catch (\Error $e) { echo $e->getMessage(), PHP_EOL; }
 
 // Clean up this section's decorators so the next section starts from default.
 unregister_component_decorator($badDecorator);
@@ -126,8 +126,8 @@ $cardFactory = function (string $class, array $args) {
     return new Card("made");
 };
 register_component_factory($cardFactory, '\cArD');
-echo <Card/>, "\n";
-echo <Badge/>, "\n";
+echo <Card/>, PHP_EOL;
+echo <Badge/>, PHP_EOL;
 
 // (2) Scoped and unscoped factories share one chain in registration order:
 // the scoped one (registered first) wins for Card; the unscoped one sees Badge.
@@ -136,25 +136,25 @@ $anyFactory = function (string $class, array $args) {
     return null; // defer
 };
 register_component_factory($anyFactory);
-echo <Card/>, "\n";
-echo <Badge/>, "\n";
+echo <Card/>, PHP_EOL;
+echo <Badge/>, PHP_EOL;
 
 // (3) Unregister identity includes the scope: the callable alone (or with the
 // wrong scope) does not match; with its scope it does.
 var_dump(unregister_component_factory($cardFactory));
 var_dump(unregister_component_factory($cardFactory, 'Badge'));
 var_dump(unregister_component_factory($cardFactory, 'Card'));
 var_dump(unregister_component_factory($anyFactory));
-echo <Card/>, "\n";
+echo <Card/>, PHP_EOL;
 
 // (4) A decorator scoped to Badge wraps only Badge's output - Card renders
 // untouched.
 $badgeDecorator = fn(Markup\Html $h, string $c) => Markup\raw("<<$h>>");
 register_component_decorator($badgeDecorator, Badge::class);
-echo <Badge label="B"/>, "\n";
-echo <Card title="C"/>, "\n";
+echo <Badge label="B"/>, PHP_EOL;
+echo <Card title="C"/>, PHP_EOL;
 var_dump(unregister_component_decorator($badgeDecorator, 'badge'));
-echo <Badge label="B"/>, "\n";
+echo <Badge label="B"/>, PHP_EOL;
 ?>
 --EXPECT--
 default:  TimeBadge::__construct(): Argument #1 ($clock) not passed

ext/markup/tests/component_slots.phpt

@@ -39,7 +39,7 @@ $out = render_component(
     ],
     new Fragment([new E('p', [], ['loose body'])]),          // body slot
 );
-echo $out, "\n";
+echo $out, PHP_EOL;
 
 // Body slot only.
 class Panel implements Markup\Html {
@@ -51,7 +51,7 @@ class Panel implements Markup\Html {
         return new E('section', ['class' => $this->kind], [$this->content]);
     }
 }
-echo render_component(Panel::class, ['kind' => 'note'], new Fragment([Markup\raw('<b>hi</b>')]))->__toString(), "\n";
+echo render_component(Panel::class, ['kind' => 'note'], new Fragment([Markup\raw('<b>hi</b>')]))->__toString(), PHP_EOL;
 
 // --- slot-routing validation errors ---
 
@@ -60,29 +60,29 @@ class Solo implements Markup\Html {
     public function __construct(#[Slot] public Markup\Html $body) {}
     public function toHtml(): Markup\Html { return new E('p', [], [$this->body]); }
 }
-echo err(fn() => render_component(Solo::class, ['body' => 'x'], new Fragment([Markup\raw('y')]))), "\n";
+echo err(fn() => render_component(Solo::class, ['body' => 'x'], new Fragment([Markup\raw('y')]))), PHP_EOL;
 
 // Body content given to a component that has no slot parameter.
 class NoSlot implements Markup\Html {
     public function __construct(public string $x) {}
     public function toHtml(): Markup\Html { return new E('i', [], [$this->x]); }
 }
-echo err(fn() => render_component(NoSlot::class, ['x' => 'hi'], new Fragment([Markup\raw('body')]))), "\n";
+echo err(fn() => render_component(NoSlot::class, ['x' => 'hi'], new Fragment([Markup\raw('body')]))), PHP_EOL;
 
 // More than one slot parameter is a definition error.
 class TwoSlots implements Markup\Html {
     public function __construct(#[Slot] public ?Markup\Html $a = null, #[Slot] public ?Markup\Html $b = null) {}
     public function toHtml(): Markup\Html { return new Fragment([$this->a, $this->b]); }
 }
-echo err(fn() => render_component(TwoSlots::class, [], new Fragment([]))), "\n";
+echo err(fn() => render_component(TwoSlots::class, [], new Fragment([]))), PHP_EOL;
 
 // #[Slot] on a variadic parameter is a definition error.
 class Variadic implements Markup\Html {
     private array $parts;
     public function __construct(#[Slot] Markup\Html ...$parts) { $this->parts = $parts; }
     public function toHtml(): Markup\Html { return new Fragment($this->parts); }
 }
-echo err(fn() => render_component(Variadic::class, [], new Fragment([]))), "\n";
+echo err(fn() => render_component(Variadic::class, [], new Fragment([]))), PHP_EOL;
 
 // --- Markup\Slot is a bare parameter-target marker attribute ---
 

ext/markup/tests/components.phpt

@@ -48,49 +48,49 @@ class Author {
 $who = 'Ada & co';
 
 // class component: attribute prop + body routed to the anonymous slot
-echo (<Card title={$who}><p>Hi {$who}</p></Card>)->__toString(), "\n";
+echo (<Card title={$who}><p>Hi {$who}</p></Card>)->__toString(), PHP_EOL;
 
 // self-closing class component (no body -> slot is null)
-echo (<Card title="Solo"/>)->__toString(), "\n";
+echo (<Card title="Solo"/>)->__toString(), PHP_EOL;
 
 // static-method component
-echo (<Author::byline name={$who}/>)->__toString(), "\n";
+echo (<Author::byline name={$who}/>)->__toString(), PHP_EOL;
 
 // the same dispatch, called directly by name
-echo render_component(Badge::class, ['label' => 'New &'])->__toString(), "\n";
+echo render_component(Badge::class, ['label' => 'New &'])->__toString(), PHP_EOL;
 
 // a component used as a child of an HTML element, and inside interpolation
-echo (<div class="wrap"><Badge label="x"/></div>)->__toString(), "\n";
-echo (<ul>{array_map(fn($t) => <Badge label={$t}/>, ['a', 'b'])}</ul>)->__toString(), "\n";
+echo (<div class="wrap"><Badge label="x"/></div>)->__toString(), PHP_EOL;
+echo (<ul>{array_map(fn($t) => <Badge label={$t}/>, ['a', 'b'])}</ul>)->__toString(), PHP_EOL;
 
 // --- resolution errors: a component is a class implementing Html ---
 
 // Unknown symbol -> hard error.
-echo err(fn() => render_component('NoSuchThing')), "\n";
+echo err(fn() => render_component('NoSuchThing')), PHP_EOL;
 
 // A function name is not a component (functions are Future Scope).
 function Chip(): Markup\Html { return Markup\raw('FROM FUNCTION'); }
-echo err(fn() => render_component('Chip')), "\n";
+echo err(fn() => render_component('Chip')), PHP_EOL;
 
 // A "date"-named tag can never reach the internal date() function.
-echo err(fn() => render_component('date', ['datetime' => 'now'])), "\n";
+echo err(fn() => render_component('date', ['datetime' => 'now'])), PHP_EOL;
 
 // A class that does NOT implement Html -> hard error.
 class Plain {}
-echo err(fn() => render_component('Plain')), "\n";
+echo err(fn() => render_component('Plain')), PHP_EOL;
 
 // "Class::method" resolves to a public static method and is called; the
 // result must be a Markup\Html.
-echo render_component('Author::byline', ['name' => 'Ada'])->__toString(), "\n";
-echo err(fn() => render_component('Author::broken')), "\n";
-echo err(fn() => render_component('NoSuchClass::method')), "\n";
+echo render_component('Author::byline', ['name' => 'Ada'])->__toString(), PHP_EOL;
+echo err(fn() => render_component('Author::broken')), PHP_EOL;
+echo err(fn() => render_component('NoSuchClass::method')), PHP_EOL;
 
 // A class implementing Html resolves, regardless of same-named functions.
 function Widget(): Markup\Html { return Markup\raw('FROM FUNCTION'); }
 class Widget implements Markup\Html {
     public function toHtml(): Markup\Html { return Markup\raw('FROM CLASS'); }
 }
-echo render_component('Widget')->__toString(), "\n";
+echo render_component('Widget')->__toString(), PHP_EOL;
 
 // --- hyphenated attributes route through named args ---
 
@@ -105,14 +105,14 @@ class Box implements Markup\Html {
 
 // Hyphenated attributes work directly on a component (no spread needed) - they
 // become named arguments and the variadic collects them.
-echo (<Box kind="note" data-id="7" aria-label="hi"/>), "\n";
+echo (<Box kind="note" data-id="7" aria-label="hi"/>), PHP_EOL;
 
 // A component without a variadic rejects an unknown (hyphenated) attribute.
 class Tight implements Markup\Html {
     public function __construct(public string $kind) {}
     public function toHtml(): Markup\Html { return new E('div', ['class' => $this->kind], ['y']); }
 }
-echo err(fn() => (<Tight kind="b" data-x="1"/>)->__toString()), "\n";
+echo err(fn() => (<Tight kind="b" data-x="1"/>)->__toString()), PHP_EOL;
 ?>
 --EXPECT--
 <section class="card"><h2>Ada &amp; co</h2><p>Hi Ada &amp; co</p></section>