feat: added Binary::toBinary

chore: self-serializer now uses `Binary` helper instead of own instance of `Serializer`

Author: petrknap

src/Binary.php

@@ -21,15 +21,26 @@ public static function decode(string $data): DecoderInterface
      */
     public static function serialize(mixed $data): string
     {
-        return (new Serializer())->serialize(serializable: $data);
+        return self::serializer()->serialize(serializable: $data);
     }
 
     /**
      * @see Serializer::unserialize()
      */
     public static function unserialize(string $data): mixed
     {
-        return (new Serializer())->unserialize(serialized: $data);
+        return self::serializer()->unserialize(serialized: $data);
+    }
+
+    /**
+     * @see Serializer\OneWaySelfSerializerInterface::toBinary()
+     */
+    public static function toBinary(Serializer\OneWaySelfSerializerInterface|string $data): string
+    {
+        if ($data instanceof Serializer\OneWaySelfSerializerInterface) {
+            return $data->toBinary();
+        }
+        return $data;
     }
 
     /**
@@ -39,14 +50,26 @@ public static function unserialize(string $data): mixed
      */
     public static function bite(string $data, int $size1, int ...$sizeN): array
     {
-        return (new Byter())->bite($data, $size1, ...$sizeN);
+        return self::byter()->bite($data, $size1, ...$sizeN);
     }
 
     /**
      * @see Byter::unbite()
      */
     public static function unbite(string $bite1, string ...$biteN): string
     {
-        return (new Byter())->unbite($bite1, ...$biteN);
+        return self::byter()->unbite($bite1, ...$biteN);
+    }
+
+    private static function serializer(): Serializer
+    {
+        static $serializer;
+        return $serializer ??= new Serializer();
+    }
+
+    private static function byter(): Byter
+    {
+        static $byter;
+        return $byter ??= new Byter();
     }
 }

src/Serializer/SelfSerializerTrait.php

@@ -4,7 +4,7 @@
 
 namespace PetrKnap\Binary\Serializer;
 
-use PetrKnap\Binary\Serializer;
+use PetrKnap\Binary\Binary;
 
 /**
  * If your {@see self::__construct()} argument is an instance of {@see SelfSerializerInterface} then
@@ -19,7 +19,7 @@ trait SelfSerializerTrait
 
     public function toBinary(): string
     {
-        return (new Serializer())->serialize(array_map(
+        return Binary::serialize(array_map(
             static fn (mixed $constructorArg): mixed => match ($constructorArg instanceof SelfSerializerInterface) {
                 true => $constructorArg->toBinary(),
                 false => $constructorArg,
@@ -30,6 +30,6 @@ public function toBinary(): string
 
     public static function fromBinary(string $data): self
     {
-        return new self(...(new Serializer())->unserialize($data));
+        return new self(...Binary::unserialize($data));
     }
 }

tests/BinariableTest.php

@@ -4,6 +4,7 @@
 
 namespace PetrKnap\Binary;
 
+use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\TestCase;
 
 final class BinariableTest extends TestCase
@@ -23,16 +24,24 @@ public function testNativeComparisonWorks(): void
         self::assertTrue(self::BINARY == self::getInstance());
     }
 
-    public function testUnionTypingWorks(): void
+    #[DataProvider('unionTypeDataProvider')]
+    public function testConversionHelperWorks(BinariableInterface|string $data): void
     {
-        $function = static fn (BinariableInterface|string $parameter): string => (string) $parameter;
-
         self::assertSame(
             self::BINARY,
-            $function(self::getInstance()),
+            Binary::toBinary($data),
         );
     }
 
+    public static function unionTypeDataProvider(): array
+    {
+        $instance = self::getInstance();
+        return [
+            BinariableInterface::class => [$instance],
+            'binary' => [$instance->toBinary()],
+        ];
+    }
+
     private static function getInstance(): BinariableInterface
     {
         return new class () implements BinariableInterface {