Change how to stringify Stringable objects

This library's goal is to convert anything to a string, and although it
seems obvious to return the content of the `__toString()` method, that
behavior does not tell the user much about what the input is.

This commit sets the tone for this library: it's for engineers to
represent anything as a string. However, the fact that we can convert
an object to a string does not mean it is a string.

This commit will also change how we verify those objects. Since PHP 8.0,
any object that implements a `__toString()` method automatically
implements the Stringable interface. Since we dropped support for
versions that are less than 8.1, it makes sense to check that instead of
checking if the method exists.

Signed-off-by: Henrique Moody <[email protected]>

Author: henriquemoody

src/Stringifiers/ClusterStringifier.php

@@ -44,7 +44,7 @@ public static function createDefault(): self
             new TraversableStringifier($stringifier, $quoter),
             new DateTimeStringifier($quoter, DateTimeInterface::ATOM),
             new ThrowableStringifier($stringifier, $quoter),
-            new StringableObjectStringifier($stringifier),
+            new StringableObjectStringifier($jsonParsableStringifier, $quoter),
             new JsonSerializableObjectStringifier($jsonParsableStringifier, $quoter),
             new ObjectStringifier($stringifier, $quoter),
             new ArrayStringifier($stringifier, $quoter, self::MAXIMUM_DEPTH, self::MAXIMUM_NUMBER_OF_ITEMS),

src/Stringifiers/StringableObjectStringifier.php

@@ -10,28 +10,33 @@
 
 namespace Respect\Stringifier\Stringifiers;
 
+use Respect\Stringifier\Quoter;
 use Respect\Stringifier\Stringifier;
+use Stringable;
 
-use function is_object;
-use function method_exists;
+use function sprintf;
 
 final class StringableObjectStringifier implements Stringifier
 {
     public function __construct(
-        private readonly Stringifier $stringifier
+        private readonly Stringifier $stringifier,
+        private readonly Quoter $quoter
     ) {
     }
 
     public function stringify(mixed $raw, int $depth): ?string
     {
-        if (!is_object($raw)) {
+        if (!$raw instanceof Stringable) {
             return null;
         }
 
-        if (!method_exists($raw, '__toString')) {
-            return null;
-        }
-
-        return $this->stringifier->stringify($raw->__toString(), $depth);
+        return $this->quoter->quote(
+            sprintf(
+                '%s { __toString() => %s }',
+                $raw::class,
+                $this->stringifier->stringify($raw->__toString(), $depth + 1)
+            ),
+            $depth
+        );
     }
 }

tests/src/MyStringable.php tests/fixtures/ConcreteStringable.phptests/src/MyStringable.php renamed to tests/fixtures/ConcreteStringable.php

@@ -8,14 +8,10 @@
 
 declare(strict_types=1);
 
-namespace Respect\Stringifier\Test;
-
-final class MyStringable
+final class ConcreteStringable
 {
-    public const STRING_VALUE = self::class;
-
     public function __toString(): string
     {
-        return self::STRING_VALUE;
+        return 'This is the return of __toString()';
     }
 }

tests/integration/stringify-object-stringable.phpt

@@ -5,7 +5,7 @@ declare(strict_types=1);
 
 require 'vendor/autoload.php';
 
-output(new Respect\Stringifier\Test\MyStringable());
+output(new ConcreteStringable());
 ?>
 --EXPECT--
-"Respect\\Stringifier\\Test\\MyStringable"
+`ConcreteStringable { __toString() => "This is the return of __toString()" }`

tests/unit/Stringifiers/StringableObjectStringifierTest.php

@@ -10,66 +10,48 @@
 
 namespace Respect\Stringifier\Test\Unit\Stringifiers;
 
+use ConcreteStringable;
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\Test;
 use PHPUnit\Framework\TestCase;
-use Respect\Stringifier\Stringifier;
 use Respect\Stringifier\Stringifiers\StringableObjectStringifier;
-use Respect\Stringifier\Test\MyStringable;
+use Respect\Stringifier\Test\Double\FakeQuoter;
+use Respect\Stringifier\Test\Double\FakeStringifier;
 use stdClass;
 
+use function sprintf;
+
 #[CoversClass(StringableObjectStringifier::class)]
 final class StringableObjectStringifierTest extends TestCase
 {
-    #[Test]
-    public function shouldNotConvertToStringWhenValueIsNotAnObject(): void
-    {
-        $raw = 'not-an-object';
-        $depth = 1;
-
-        $stringifierMock = $this->createMock(Stringifier::class);
-        $stringifierMock
-            ->expects($this->never())
-            ->method('stringify');
-
-        $stringableObjectStringifier = new StringableObjectStringifier($stringifierMock);
-
-        self::assertNull($stringableObjectStringifier->stringify($raw, $depth));
-    }
+    private const DEPTH = 0;
 
     #[Test]
-    public function shouldNotConvertToStringWhenValueIsNonStringableObject(): void
+    public function itShouldNotStringifyRawValueWhenItIsNotAnInstanceOfStringable(): void
     {
-        $raw = new stdClass();
-        $depth = 1;
-
-        $stringifierMock = $this->createMock(Stringifier::class);
-        $stringifierMock
-            ->expects($this->never())
-            ->method('stringify');
+        $sut = new StringableObjectStringifier(new FakeStringifier(), new FakeQuoter());
 
-        $stringableObjectStringifier = new StringableObjectStringifier($stringifierMock);
-
-        self::assertNull($stringableObjectStringifier->stringify($raw, $depth));
+        self::assertNull($sut->stringify(new stdClass(), self::DEPTH));
     }
 
     #[Test]
-    public function shouldConvertToStringWhenValueIsAnStringableObject(): void
+    public function itShouldStringifyRawValueWhenItIsAnInstanceOfStringable(): void
     {
-        $raw = new MyStringable();
-        $depth = 0;
+        $raw = new ConcreteStringable();
+
+        $stringifier = new FakeStringifier();
+        $quoter = new FakeQuoter();
 
-        $expectedValue = MyStringable::STRING_VALUE;
+        $string = $stringifier->stringify($raw->__toString(), self::DEPTH + 1);
 
-        $stringifierMock = $this->createMock(Stringifier::class);
-        $stringifierMock
-            ->expects($this->once())
-            ->method('stringify')
-            ->with(MyStringable::STRING_VALUE, $depth)
-            ->willReturn($expectedValue);
+        $sut = new StringableObjectStringifier($stringifier, $quoter);
 
-        $stringableObjectStringifier = new StringableObjectStringifier($stringifierMock);
+        $actual = $sut->stringify($raw, self::DEPTH);
+        $expected = $quoter->quote(
+            sprintf('%s { __toString() => %s }', ConcreteStringable::class, $string),
+            self::DEPTH
+        );
 
-        self::assertSame($expectedValue, $stringableObjectStringifier->stringify($raw, $depth));
+        self::assertSame($expected, $actual);
     }
 }