Introduce serializer and introduce json serialization instead of php serialization

src/Serializer/CompositeSerializer.php

@@ -0,0 +1,51 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Setono\TagBag\Serializer;
+
+use Setono\TagBag\Exception\SerializationException;
+
+final class CompositeSerializer implements SerializerInterface
+{
+    /** @var list<SerializerInterface> */
+    private array $serializers = [];
+
+    public function __construct(SerializerInterface ...$serializers)
+    {
+        foreach ($serializers as $serializer) {
+            $this->add($serializer);
+        }
+    }
+
+    public function add(SerializerInterface $serializer): void
+    {
+        $this->serializers[] = $serializer;
+    }
+
+    public function serialize(array $tags): string
+    {
+        foreach ($this->serializers as $serializer) {
+            try {
+                return $serializer->serialize($tags);
+            } catch (SerializationException) {
+                continue;
+            }
+        }
+
+        throw new SerializationException('No serializer was able to serialize the tags');
+    }
+
+    public function deserialize(string $data): array
+    {
+        foreach ($this->serializers as $serializer) {
+            try {
+                return $serializer->deserialize($data);
+            } catch (SerializationException) {
+                continue;
+            }
+        }
+
+        throw new SerializationException('No serializer was able to deserialize the data');
+    }
+}

src/Serializer/JsonSerializer.php

@@ -0,0 +1,50 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Setono\TagBag\Serializer;
+
+use JsonException;
+use Setono\TagBag\Exception\SerializationException;
+use Setono\TagBag\Tag\RenderedTag;
+use Throwable;
+use Webmozart\Assert\Assert;
+
+final class JsonSerializer implements SerializerInterface
+{
+    public function serialize(array $tags): string
+    {
+        try {
+            return json_encode($tags, \JSON_THROW_ON_ERROR);
+        } catch (JsonException $e) {
+            throw new SerializationException(message: $e->getMessage(), previous: $e);
+        }
+    }
+
+    public function deserialize(string $data): array
+    {
+        try {
+            /** @var mixed $data */
+            $data = json_decode(json: $data, associative: true, flags: \JSON_THROW_ON_ERROR);
+            Assert::isArray($data);
+
+            $tags = [];
+
+            foreach ($data as $section => $sectionTags) {
+                Assert::string($section);
+                Assert::isArray($sectionTags);
+
+                /** @var mixed $tag */
+                foreach ($sectionTags as $tag) {
+                    Assert::isArray($tag);
+
+                    $tags[$section][] = RenderedTag::createFromArray($tag);
+                }
+            }
+
+            return $tags;
+        } catch (Throwable $e) {
+            throw new SerializationException(message: $e->getMessage(), previous: $e);
+        }
+    }
+}

src/Serializer/PhpSerializer.php

@@ -0,0 +1,75 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Setono\TagBag\Serializer;
+
+use Setono\TagBag\Exception\SerializationException;
+use Setono\TagBag\Tag\RenderedTag;
+use Webmozart\Assert\Assert;
+
+/**
+ * @deprecated since 2.3 and will be removed in 3.0. Use the `JsonSerializer` instead
+ */
+final class PhpSerializer implements SerializerInterface
+{
+    public function serialize(array $tags): string
+    {
+        return serialize($tags);
+    }
+
+    /**
+     * Most of this method is taken from here: https://github.com/symfony/symfony/blob/6.2/src/Symfony/Component/Messenger/Transport/Serialization/PhpSerializer.php
+     */
+    public function deserialize(string $data): array
+    {
+        if ('' === $data) {
+            throw SerializationException::emptyData();
+        }
+
+        $serializationException = new SerializationException(sprintf('Could not unserialize data: %s.', $data));
+        $prevUnserializeHandler = ini_set('unserialize_callback_func', self::class . '::handleUnserializeCallback');
+        /** @psalm-suppress MixedArgumentTypeCoercion,UndefinedVariable */
+        $prevErrorHandler = set_error_handler(static function ($type, $msg, $file, $line, $context = []) use (&$prevErrorHandler, $serializationException) {
+            if (__FILE__ === $file) {
+                throw $serializationException;
+            }
+
+            /** @psalm-suppress MixedFunctionCall */
+            return $prevErrorHandler ? $prevErrorHandler($type, $msg, $file, $line, $context) : false;
+        });
+
+        try {
+            /** @var array<string, list<RenderedTag>> $result */
+            $result = unserialize($data, [
+                'allowed_classes' => [RenderedTag::class],
+            ]);
+            /** @psalm-suppress RedundantConditionGivenDocblockType */
+            Assert::isArray($result);
+            foreach ($result as $section => $tags) {
+                /** @psalm-suppress RedundantConditionGivenDocblockType */
+                Assert::string($section);
+
+                /** @psalm-suppress RedundantConditionGivenDocblockType */
+                Assert::isArray($tags);
+
+                Assert::allIsInstanceOf($tags, RenderedTag::class);
+            }
+        } catch (\InvalidArgumentException) {
+            throw new SerializationException(sprintf('The unserialized data was incorrect. Here is the original data: %s', $data));
+        } finally {
+            restore_error_handler();
+            ini_set('unserialize_callback_func', $prevUnserializeHandler);
+        }
+
+        return $result;
+    }
+
+    /**
+     * @internal
+     */
+    public static function handleUnserializeCallback(string $class): never
+    {
+        throw new SerializationException(sprintf('Message class "%s" not found during decoding.', $class));
+    }
+}

src/Serializer/SerializerInterface.php

@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Setono\TagBag\Serializer;
+
+use Setono\TagBag\Exception\SerializationException;
+use Setono\TagBag\Tag\RenderedTag;
+
+interface SerializerInterface
+{
+    /**
+     * @param array<string, list<RenderedTag>> $tags
+     *
+     * @throws SerializationException if the serialization fails
+     */
+    public function serialize(array $tags): string;
+
+    /**
+     * @return array<string, list<RenderedTag>>
+     *
+     * @throws SerializationException if the deserialization fails
+     */
+    public function deserialize(string $data): array;
+}

src/Tag/RenderedTag.php

@@ -4,6 +4,10 @@
 
 namespace Setono\TagBag\Tag;
 
+use InvalidArgumentException;
+use JsonSerializable;
+use Stringable;
+
 /**
  * This class is not intended to be used outside the Setono\TagBag\TagBag class.
  *
@@ -12,7 +16,7 @@
  *
  * @internal
  */
-final class RenderedTag implements \Stringable
+final class RenderedTag implements Stringable, JsonSerializable
 {
     private function __construct(
         public readonly string $value,
@@ -34,8 +38,38 @@
         );
     }
 
+    public static function createFromArray(array $data): self
+    {
+        if (!isset($data['value'], $data['section'], $data['priority'], $data['unique'], $data['fingerprint'])) {
+            throw new InvalidArgumentException('The data array must contain the keys "value", "section", "priority", "unique", and "fingerprint"');
+        }
+
+        if (!is_string($data['value']) || !is_string($data['section']) || !is_int($data['priority']) || !is_bool($data['unique']) || !is_string($data['fingerprint'])) {
+            throw new InvalidArgumentException('The data array must have the correct types for the keys "value" (string), "section" (string), "priority" (int), "unique" (bool), and "fingerprint" (string)');
+        }
+
+        return new self(
+            $data['value'],
+            $data['section'],
+            $data['priority'],
+            $data['unique'],
+            $data['fingerprint'],
+        );
+    }
+
     public function __toString(): string
     {
         return $this->value;
     }
+
+    public function jsonSerialize(): array
+    {
+        return [
+            'value' => $this->value,
+            'section' => $this->section,
+            'priority' => $this->priority,
+            'unique' => $this->unique,
+            'fingerprint' => $this->fingerprint,
+        ];
+    }
 }

src/TagBag.php

@@ -4,7 +4,6 @@
 
 namespace Setono\TagBag;
 
-use InvalidArgumentException;
 use Psr\EventDispatcher\EventDispatcherInterface;
 use Psr\Log\LoggerAwareInterface;
 use Psr\Log\LoggerInterface;
@@ -20,11 +19,14 @@
 use Setono\TagBag\Renderer\ContentAwareRenderer;
 use Setono\TagBag\Renderer\ElementRenderer;
 use Setono\TagBag\Renderer\RendererInterface;
+use Setono\TagBag\Serializer\CompositeSerializer;
+use Setono\TagBag\Serializer\JsonSerializer;
+use Setono\TagBag\Serializer\PhpSerializer;
+use Setono\TagBag\Serializer\SerializerInterface;
 use Setono\TagBag\Storage\StorageInterface;
 use Setono\TagBag\Tag\RenderedTag;
 use Setono\TagBag\Tag\TagInterface;
 use Throwable;
-use Webmozart\Assert\Assert;
 
 final class TagBag implements TagBagInterface, LoggerAwareInterface
 {
@@ -41,13 +43,19 @@ final class TagBag implements TagBagInterface, LoggerAwareInterface
 
     private readonly FingerprintGeneratorInterface $fingerprintGenerator;
 
+    private readonly SerializerInterface $serializer;
+
     public function __construct(
         RendererInterface $renderer = null,
         FingerprintGeneratorInterface $fingerprintGenerator = null,
+        SerializerInterface $serializer = null,
     ) {
         $this->logger = new NullLogger();
         $this->renderer = $renderer ?? new CompositeRenderer(new ElementRenderer(), new ContentAwareRenderer());
         $this->fingerprintGenerator = $fingerprintGenerator ?? new ValueBasedFingerprintGenerator();
+
+        /** @psalm-suppress DeprecatedClass */
+        $this->serializer = $serializer ?? new CompositeSerializer(new JsonSerializer(), new PhpSerializer());
     }
 
     public function add(TagInterface $tag): void
@@ -176,7 +184,7 @@ public function store(): void
             if (count($this->tags) === 0) {
                 $this->storage->remove();
             } else {
-                $this->storage->store(serialize($this->tags));
+                $this->storage->store($this->serializer->serialize($this->tags));
             }
         } catch (StorageException $e) {
             $this->logger->error($e->getMessage());
@@ -202,7 +210,7 @@ public function restore(): void
         $this->tags = [];
         if (null !== $data) {
             try {
-                $this->tags = $this->unserialize($data);
+                $this->tags = $this->serializer->deserialize($data);
             } catch (SerializationException $e) {
                 $this->logger->error(sprintf('Exception thrown when trying to unserialize data. Error was: %s. Data was: %s', $e->getMessage(), $data));
             }
@@ -248,63 +256,4 @@ private function findTagByFingerprint(string $fingerprint): ?array
 
         return null;
     }
-
-    /**
-     * @throws SerializationException if the data cannot be unserialized
-     *
-     * @return array<string, list<RenderedTag>>
-     *
-     * Most of this method is taken from here: https://github.com/symfony/symfony/blob/6.2/src/Symfony/Component/Messenger/Transport/Serialization/PhpSerializer.php
-     */
-    private function unserialize(string $data): array
-    {
-        if ('' === $data) {
-            throw SerializationException::emptyData();
-        }
-
-        $serializationException = new SerializationException(sprintf('Could not unserialize data: %s.', $data));
-        $prevUnserializeHandler = ini_set('unserialize_callback_func', self::class . '::handleUnserializeCallback');
-        /** @psalm-suppress MixedArgumentTypeCoercion,UndefinedVariable */
-        $prevErrorHandler = set_error_handler(static function ($type, $msg, $file, $line, $context = []) use (&$prevErrorHandler, $serializationException) {
-            if (__FILE__ === $file) {
-                throw $serializationException;
-            }
-
-            /** @psalm-suppress MixedFunctionCall */
-            return $prevErrorHandler ? $prevErrorHandler($type, $msg, $file, $line, $context) : false;
-        });
-
-        try {
-            /** @var array<string, list<RenderedTag>> $result */
-            $result = unserialize($data, [
-                'allowed_classes' => [RenderedTag::class],
-            ]);
-            /** @psalm-suppress RedundantConditionGivenDocblockType */
-            Assert::isArray($result);
-            foreach ($result as $section => $tags) {
-                /** @psalm-suppress RedundantConditionGivenDocblockType */
-                Assert::string($section);
-
-                /** @psalm-suppress RedundantConditionGivenDocblockType */
-                Assert::isArray($tags);
-
-                Assert::allIsInstanceOf($tags, RenderedTag::class);
-            }
-        } catch (InvalidArgumentException) {
-            throw new SerializationException(sprintf('The unserialized data was incorrect. Here is the original data: %s', $data));
-        } finally {
-            restore_error_handler();
-            ini_set('unserialize_callback_func', $prevUnserializeHandler);
-        }
-
-        return $result;
-    }
-
-    /**
-     * @internal
-     */
-    public static function handleUnserializeCallback(string $class): never
-    {
-        throw new SerializationException(sprintf('Message class "%s" not found during decoding.', $class));
-    }
 }