Change how to stringify objects

I'm matching the latest changes in format, using "{}" for objects, but
I'm making many improvements to the `ObjectStringifier`.

When stringifying objects, we have access to the protected and private
properties. I made it more familiar as well, prefixing the variables
with a "$", which is how we describe variables, and using the symbols
"+", "#" and "-", which is how UML represents visibility.

I also fixed a bug because getting the value of non-initialized
properties raises an error, which we didn't consider before.

With this commit, I also introduced a maximum number of properties to
prevent longer strings and a maximum depth to infinite recursion.

Since now we always represent objects with "{}", we don't need to prefix
it with "object" anymore.

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

Author: henriquemoody

src/Stringifiers/ClusterStringifier.php

@@ -18,6 +18,7 @@ final class ClusterStringifier implements Stringifier
 {
     private const MAXIMUM_DEPTH = 3;
     private const MAXIMUM_NUMBER_OF_ITEMS = 5;
+    private const MAXIMUM_NUMBER_OF_PROPERTIES = self::MAXIMUM_NUMBER_OF_ITEMS;
 
     /**
      * @var Stringifier[]
@@ -46,7 +47,7 @@ public static function createDefault(): self
             new ThrowableObjectStringifier($jsonEncodableStringifier, $quoter),
             new StringableObjectStringifier($jsonEncodableStringifier, $quoter),
             new JsonSerializableObjectStringifier($jsonEncodableStringifier, $quoter),
-            new ObjectStringifier($stringifier, $quoter),
+            new ObjectStringifier($stringifier, $quoter, self::MAXIMUM_DEPTH, self::MAXIMUM_NUMBER_OF_PROPERTIES),
             new ArrayStringifier($stringifier, $quoter, self::MAXIMUM_DEPTH, self::MAXIMUM_NUMBER_OF_ITEMS),
             new InfiniteNumberStringifier($quoter),
             new NotANumberStringifier($quoter),

src/Stringifiers/ObjectStringifier.php

@@ -10,18 +10,26 @@
 
 namespace Respect\Stringifier\Stringifiers;
 
+use ReflectionObject;
+use ReflectionProperty;
 use Respect\Stringifier\Quoter;
 use Respect\Stringifier\Stringifier;
 
-use function get_object_vars;
+use function count;
+use function implode;
 use function is_object;
 use function sprintf;
+use function trim;
 
 final class ObjectStringifier implements Stringifier
 {
+    private const LIMIT_EXCEEDED_PLACEHOLDER = '...';
+
     public function __construct(
         private readonly Stringifier $stringifier,
-        private readonly Quoter $quoter
+        private readonly Quoter $quoter,
+        private readonly int $maximumDepth,
+        private readonly int $maximumNumberOfProperties
     ) {
     }
 
@@ -31,13 +39,61 @@ public function stringify(mixed $raw, int $depth): ?string
             return null;
         }
 
-        return $this->quoter->quote(
-            sprintf(
-                '[object] (%s: %s)',
-                $raw::class,
-                $this->stringifier->stringify(get_object_vars($raw), $depth + 1)
-            ),
-            $depth
-        );
+        if ($depth >= $this->maximumDepth) {
+            return $this->quoter->quote(sprintf('%s { %s }', $raw::class, self::LIMIT_EXCEEDED_PLACEHOLDER), $depth);
+        }
+
+        $properties = $this->getProperties(new ReflectionObject($raw), $raw, $depth + 1);
+        if (count($properties) === 0) {
+            return $this->quoter->quote(sprintf('%s {}', $raw::class), $depth);
+        }
+
+        return $this->quoter->quote(sprintf('%s { %s }', $raw::class, implode(' ', $properties)), $depth);
+    }
+
+    /**
+     * @return array<int, string>
+     */
+    private function getProperties(ReflectionObject $reflectionObject, object $object, int $depth): array
+    {
+        $reflectionProperties = $reflectionObject->getProperties();
+        if (count($reflectionProperties) === 0) {
+            return [];
+        }
+
+        $properties = [];
+        foreach ($reflectionProperties as $reflectionProperty) {
+            if (count($properties) >= $this->maximumNumberOfProperties) {
+                $properties[] = self::LIMIT_EXCEEDED_PLACEHOLDER;
+                break;
+            }
+
+            $properties[] = trim(sprintf(
+                '%s$%s=%s',
+                match (true) {
+                    $reflectionProperty->isPrivate() => '-',
+                    $reflectionProperty->isProtected() => '#',
+                    default => '+',
+                },
+                $reflectionProperty->getName(),
+                $this->getPropertyValue($reflectionProperty, $object, $depth)
+            ));
+        }
+
+        return $properties;
+    }
+
+    private function getPropertyValue(ReflectionProperty $reflectionProperty, object $object, int $depth): ?string
+    {
+        if (!$reflectionProperty->isInitialized($object)) {
+            return '*uninitialized*';
+        }
+
+        $value = $reflectionProperty->getValue($object);
+        if (is_object($value)) {
+            return $this->stringify($value, $depth);
+        }
+
+        return $this->stringifier->stringify($value, $depth);
     }
 }

tests/fixtures/WithProperties.php

@@ -0,0 +1,20 @@
+<?php
+
+/*
+ * This file is part of Respect/Stringifier.
+ * Copyright (c) Henrique Moody <[email protected]>
+ * SPDX-License-Identifier: MIT
+ */
+
+declare(strict_types=1);
+
+// phpcs:disable PSR1.Classes.ClassDeclaration.MissingNamespace
+
+class WithProperties
+{
+    public bool $publicProperty = true;
+
+    protected int $protectedProperty = 42;
+
+    private string $privateProperty = 'something'; // @phpstan-ignore-line
+}

tests/fixtures/WithUninitializedProperties.php

@@ -0,0 +1,16 @@
+<?php
+
+/*
+ * This file is part of Respect/Stringifier.
+ * Copyright (c) Henrique Moody <[email protected]>
+ * SPDX-License-Identifier: MIT
+ */
+
+declare(strict_types=1);
+
+// phpcs:disable PSR1.Classes.ClassDeclaration.MissingNamespace
+
+final class WithUninitializedProperties
+{
+    public string $uninitializedProperty;
+}

tests/integration/stringify-array.phpt

@@ -25,4 +25,4 @@ output([
 ]);
 ?>
 --EXPECT--
-`[1, null, [1.0, [resource <stream>, ..., []]], false, [object] (stdClass: []), ...]`
+`[1, null, [1.0, [resource <stream>, ..., []]], false, stdClass {}, ...]`

tests/integration/stringify-object.phpt

@@ -5,7 +5,13 @@ declare(strict_types=1);
 
 require 'vendor/autoload.php';
 
-output(new Respect\Stringifier\Test\MyObject());
+outputMultiple(
+    new stdClass(),
+    new WithProperties(),
+    new WithUninitializedProperties(),
+);
 ?>
 --EXPECT--
-`[object] (Respect\Stringifier\Test\MyObject: ["foo": true])`
+`stdClass {}`
+`WithProperties { +$publicProperty=true #$protectedProperty=42 -$privateProperty="something" }`
+`WithUninitializedProperties { +$uninitializedProperty=*uninitialized* }`