Merge pull request #12 from petrknap/rebinariable

Implemented helper for two-way object to binary string conversion

Author: petrknap

composer.json

@@ -53,6 +53,7 @@
   "scripts": {
     "test": "phpunit --colors=always --testdox tests",
     "validate": [
+      "composer outdated \"petrknap/*\" --major-only --strict --ansi --no-interaction",
       "phpcs --colors --standard=PSR12 --exclude=Generic.Files.LineLength src tests",
       "phpstan analyse --level max src",
       "phpstan analyse --level 5 tests",

src/BinariableInterface.php

@@ -6,12 +6,6 @@
 
 use Stringable;
 
-interface BinariableInterface extends Stringable
+interface BinariableInterface extends Serializer\OneWaySelfSerializerInterface, Stringable
 {
-    /**
-     * @return string binary representation of this instance
-     *
-     * @throws Exception\CouldNotConvertToBinary
-     */
-    public function toBinary(): string;
 }

src/BinariableTrait.php

@@ -4,19 +4,14 @@
 
 namespace PetrKnap\Binary;
 
-use PetrKnap\Shorts\Exception\NotImplemented;
-
 trait BinariableTrait
 {
     /**
      * Unfortunately PHP uses string for binary data, so the magic clashes.
      */
     public function __toString(): string
     {
-        if (!($this instanceof BinariableInterface)) {
-            NotImplemented::throw(BinariableInterface::class);
-        }
-
+        /** @var BinariableInterface $this */
         $binary = $this->toBinary();
         trigger_error(
             'Returned binary string',

src/Exception/BinariableException.php

@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PetrKnap\Binary\Serializer;
+
+interface OneWaySelfSerializerInterface
+{
+    /**
+     * @return string binary representation of this instance
+     *
+     * @throws Exception\CouldNotSerializeData
+     */
+    public function toBinary(): string;
+}

src/Exception/CouldNotConvertToBinary.php

@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PetrKnap\Binary\Serializer;
+
+interface SelfSerializerInterface extends OneWaySelfSerializerInterface
+{
+    /**
+     * @param string $data binary representation of an instance
+     *
+     * @throws Exception\CouldNotUnserializeData
+     */
+    public static function fromBinary(string $data): self;
+}

src/Serializer/OneWaySelfSerializerInterface.php

@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PetrKnap\Binary\Serializer;
+
+use PetrKnap\Binary\Serializer;
+
+/**
+ * If your {@see self::__construct()} argument is an instance of {@see SelfSerializerInterface} then
+ * accept it as an union type `YourClass|string` and call {@see SelfSerializerInterface::fromBinary()} if it is a string.
+ */
+trait SelfSerializerTrait
+{
+    /**
+     * References to {@see self::__construct()} arguments (`&$argument`)
+     */
+    private readonly array $referencesToConstructorArgs;
+
+    public function toBinary(): string
+    {
+        return (new Serializer())->serialize(array_map(
+            static fn (mixed $constructorArg): mixed => match ($constructorArg instanceof SelfSerializerInterface) {
+                true => $constructorArg->toBinary(),
+                false => $constructorArg,
+            },
+            $this->referencesToConstructorArgs,
+        ));
+    }
+
+    public static function fromBinary(string $data): self
+    {
+        return new self(...(new Serializer())->unserialize($data));
+    }
+}

src/Serializer/SelfSerializerInterface.php

@@ -8,47 +8,39 @@
 
 final class BinariableTest extends TestCase
 {
-    public const DATA = b'data';
-
-    public function testExplicitConversionWorks(): void
-    {
-        self::assertSame(
-            self::DATA,
-            self::getBinariable()->toBinary(),
-        );
-    }
+    public const BINARY = b'binary';
 
     public function testNativeConversionWorks(): void
     {
         self::assertSame(
-            self::DATA,
-            (string) self::getBinariable(),
+            self::BINARY,
+            (string) self::getInstance(),
         );
     }
 
     public function testNativeComparisonWorks(): void
     {
-        self::assertTrue(self::DATA == self::getBinariable());
+        self::assertTrue(self::BINARY == self::getInstance());
     }
 
     public function testUnionTypingWorks(): void
     {
         $function = static fn (BinariableInterface|string $parameter): string => (string) $parameter;
 
         self::assertSame(
-            self::DATA,
-            $function(self::getBinariable()),
+            self::BINARY,
+            $function(self::getInstance()),
         );
     }
 
-    private function getBinariable(): BinariableInterface
+    private static function getInstance(): BinariableInterface
     {
         return new class () implements BinariableInterface {
             use BinariableTrait;
 
             public function toBinary(): string
             {
-                return BinariableTest::DATA;
+                return BinariableTest::BINARY;
             }
         };
     }

src/Serializer/SelfSerializerTrait.php

@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PetrKnap\Binary\Serializer;
+
+use PHPUnit\Framework\TestCase;
+
+final class SelfSerializerTest extends TestCase
+{
+    public function testSerializationWorks(): void
+    {
+        self::assertEquals(
+            SelfSerializingDataObject::BINARY_B64,
+            base64_encode(SelfSerializingDataObject::getInstance()->toBinary()),
+        );
+    }
+
+    public function testUnserializationWorks(): void
+    {
+        self::assertEquals(
+            SelfSerializingDataObject::getInstance(),
+            SelfSerializingDataObject::fromBinary(base64_decode(SelfSerializingDataObject::BINARY_B64)),
+        );
+    }
+}

tests/BinariableTest.php

@@ -0,0 +1,58 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PetrKnap\Binary\Serializer;
+
+use stdClass;
+
+final class SelfSerializingDataObject implements SelfSerializerInterface
+{
+    use SelfSerializerTrait;
+
+    public const BINARY_B64 = 'S7QysarOtDKwzrQyBGN/KwsrpeKSFOecxOJiJStDq+piK2MrpbT8fCVrMCspsUjJujbTygjINTQxtVLy3mK0cdW5LUYbgJgpyTm7Xptbe+mjSSLP5xx5lKSq7bz6VZJ2svbSLX9qVLMNtDU3epzcJbZkz41Td454nazuvngs9Pk2iVyGpG0qz99U5ea9Xdqv1mkzv/hJ4KRV2z6/Cve8dfKW9/Y/KwPPml24dudFYdH0m0+D1fM+ro+sfHxFVt/XO9W5Njo4jNeNTXUBc8/av2uyGZWAHjG29rOuBQA=';
+
+    public readonly ?self $innerInstance;
+
+    private function __construct(
+        public readonly int $scalar,
+        public readonly stdClass $serializable,
+        self|string|null $innerInstance = null,
+        public mixed $variable = null,
+    ) {
+        $this->innerInstance = match (is_string($innerInstance)) {
+            true => self::fromBinary($innerInstance),
+            false => $innerInstance,
+        };
+        $this->referencesToConstructorArgs = [
+            $this->scalar,
+            $this->serializable,
+            $this->innerInstance,
+            &$this->variable,
+        ];
+    }
+
+    public static function getInstance(): self
+    {
+        $stdClass = new stdClass();
+        $stdClass->foo = 'bar';
+
+        $instance = new self(
+            1,
+            $stdClass,
+            new self(
+                2,
+                $stdClass,
+                new self(
+                    3,
+                    $stdClass,
+                    variable: 'value',
+                ),
+            ),
+        );
+
+        $instance->innerInstance->innerInstance->variable = 'changed';
+
+        return $instance;
+    }
+}