Added container values serialization

Author: toonvandenbos

README.md

@@ -16,6 +16,11 @@ This package's only purpose is to build custom repeated layout components, such
     - `build($data)`
     - `buildUsing($callback)`
     - `insert($key, $attributes, $index, $id)`
+- serializing the flexible container's state
+    - `serialize($resource, $attribute)`
+    - `serializeAs($format, $resource, $attribute)`
+    - `serializeUsingFormat($format)`
+    - `serializeUsing($callback)`
 - get all inserted instances, and manipulate the LayoutCollection :
     - `instances()`
     - `$instances->find($key)`

src/Concerns/HasResolver.php

@@ -3,6 +3,8 @@
 namespace Whitecube\LaravelFlexibleContent\Concerns;
 
 use Illuminate\Support\Collection;
+use Whitecube\LaravelFlexibleContent\Contracts\Layout;
+use Whitecube\LaravelFlexibleContent\Exceptions\InvalidSerializationFormatException;
 
 trait HasResolver
 {
@@ -14,11 +16,19 @@ trait HasResolver
     public $buildCallback;
 
     /**
-     * The callback to be used to save the Flexible container's value.
+     * The callback to be used when saving the Flexible container's value.
      *
      * @var null|callable
      */
-    public $saveCallback;
+    public $serializeCallback;
+
+    /**
+     * The value serialization method.
+     * Available methods are: json, array, collection
+     *
+     * @var string
+     */
+    protected $serializeFormat = 'json';
 
     /**
      * Define the callback that should be used to setup the Flexible container's value.
@@ -34,14 +44,27 @@ public function buildUsing(callable $buildCallback)
     }
 
     /**
-     * Define the callback that should be used to save the Flexible container's value.
+     * Define the callback that should be used when saving the Flexible container's value.
      *
      * @param callable $saveCallback
      * @return $this
      */
-    public function saveUsing(callable $saveCallback)
+    public function serializeUsing(callable $serializeCallback)
+    {
+        $this->serializeCallback = $serializeCallback;
+
+        return $this;
+    }
+
+    /**
+     * Define a default serialization format method that should be used when saving the Flexible container's value.
+     *
+     * @param string $serializeFormat
+     * @return $this
+     */
+    public function serializeUsingFormat(string $serializeFormat)
     {
-        $this->saveCallback = $saveCallback;
+        $this->serializeFormat = $serializeFormat;
 
         return $this;
     }
@@ -111,11 +134,67 @@ public function buildItem($item)
     /**
      * Execute what has to be done in order to save the current value for next build.
      *
-     * @return $this
+     * @return mixed
      */
-    public function save()
+    public function serialize()
     {
-        // TODO.
-        return $this;
+        if(! is_null($this->serializeCallback)) {
+            return call_user_func($this->serializeCallback, $this);
+        }
+
+        return $this->serializeAs($this->serializeFormat);
+    }
+
+    /**
+     * Transform the current value in the desired format.
+     *
+     * @param string $format
+     * @return mixed
+     */
+    public function serializeAs(string $format)
+    {
+        $serializationMethod = 'serializeAs' . ucfirst($format);
+
+        if(! method_exists($this, $serializationMethod)) {
+            throw InvalidSerializationFormatException::make($format);
+        }
+
+        return $this->$serializationMethod();
+    }
+
+    /**
+     * Transform the current value into a serialized array.
+     *
+     * @return array
+     */
+    public function serializeAsArray()
+    {
+        return $this->instances()
+            ->map(fn(Layout $instance) => [
+                'key' => $instance->getKey(),
+                'id' => $instance->getId(),
+                'attributes' => $instance->getAttributes()
+            ])
+            ->all();
+    }
+
+    /**
+     * Transform the current value into a serialized JSON string.
+     *
+     * @return string
+     */
+    public function serializeAsJson()
+    {
+        return json_encode($this->serializeAsArray());
+    }
+
+    /**
+     * Transform the current value into a serialized collection.
+     *
+     * @return \Illuminate\Support\Collection
+     */
+    public function serializeAsCollection()
+    {
+        return collect($this->serializeAsArray());
     }
 }

src/Exceptions/InvalidSerializationFormatException.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace Whitecube\LaravelFlexibleContent\Exceptions;
+
+use InvalidArgumentException;
+
+class InvalidSerializationFormatException extends InvalidArgumentException
+{
+    /**
+     * Create a new exception instance with given arguments
+     *
+     * @param string $format
+     * @return \InvalidArgumentException
+     */
+    static public function make($format) : InvalidArgumentException
+    {
+        return new static('Could not save flexible as "' . $format . '": method "serializeAs' . ucfirst($format) . '" is undefined.');
+    }
+}

tests/Unit/InstanceResolvingTest.php

@@ -2,6 +2,7 @@
 
 namespace Tests\Unit;
 
+use Illuminate\Support\Collection;
 use Whitecube\LaravelFlexibleContent\Flexible;
 
 it('can build instances from serialized data (array)', function() {
@@ -84,3 +85,87 @@
 
     expect($values->implode(','))->toBe('one!,two!,three!');
 });
+
+it('can serialize instances into an array', function() {
+    $serialized = (new Flexible())
+        ->register(fn ($layout) => $layout->key('foo'))
+        ->register(fn ($layout) => $layout->key('bar'))
+        ->insert('foo', ['test' => 0])
+        ->insert('bar', ['test' => 1])
+        ->insert('foo', ['test' => 2])
+        ->serializeAsArray();
+
+    expect($serialized)->toBeArray();
+
+    foreach (['foo', 'bar', 'foo'] as $index => $key) {
+        expect($serialized[$index]['key'] ?? null)->toBe($key);
+        expect($serialized[$index]['id'] ?? null)->toBeString();
+        expect($serialized[$index]['attributes']['test'] ?? null)->toBe($index);
+    }
+});
+
+it('can serialize instances into a JSON string', function() {
+    $serialized = (new Flexible())
+        ->register(fn ($layout) => $layout->key('foo'))
+        ->register(fn ($layout) => $layout->key('bar'))
+        ->insert('foo', ['test' => 0])
+        ->insert('bar', ['test' => 1])
+        ->insert('foo', ['test' => 2])
+        ->serializeAsJson();
+
+    expect($serialized)->toBeString();
+    expect($serialized = json_decode($serialized, true))->toBeArray();
+
+    foreach (['foo', 'bar', 'foo'] as $index => $key) {
+        expect($serialized[$index]['key'] ?? null)->toBe($key);
+        expect($serialized[$index]['id'] ?? null)->toBeString();
+        expect($serialized[$index]['attributes']['test'] ?? null)->toBe($index);
+    }
+});
+
+it('can serialize instances into a collection', function() {
+    $serialized = (new Flexible())
+        ->register(fn ($layout) => $layout->key('foo'))
+        ->register(fn ($layout) => $layout->key('bar'))
+        ->insert('foo', ['test' => 0])
+        ->insert('bar', ['test' => 1])
+        ->insert('foo', ['test' => 2])
+        ->serializeAsCollection();
+
+    expect($serialized)->toBeInstanceOf(Collection::class);
+
+    foreach (['foo', 'bar', 'foo'] as $index => $key) {
+        expect($serialized->get($index)['key'] ?? null)->toBe($key);
+        expect($serialized->get($index)['id'] ?? null)->toBeString();
+        expect($serialized->get($index)['attributes']['test'] ?? null)->toBe($index);
+    }
+});
+
+it('can serialize instances into a default (configurable) format', function() {
+    $flexible = (new Flexible())
+        ->register(fn ($layout) => $layout->key('foo'))
+        ->register(fn ($layout) => $layout->key('bar'))
+        ->insert('foo', ['test' => 0])
+        ->insert('bar', ['test' => 1])
+        ->insert('foo', ['test' => 2]);
+
+    expect($flexible->serialize())->toBeString();
+
+    $flexible->serializeUsingFormat('array');
+
+    expect($flexible->serialize())->toBeArray();
+});
+
+it('can serialize instances using a custom callable', function() {
+    $flexible = (new Flexible())
+        ->register(fn ($layout) => $layout->key('foo'))
+        ->register(fn ($layout) => $layout->key('bar'))
+        ->insert('foo', ['test' => 0])
+        ->insert('bar', ['test' => 1])
+        ->insert('foo', ['test' => 2])
+        ->serializeUsing(function(Flexible $flexible) {
+            return $flexible->instances()->map(fn($instance) => $instance->getKey() . $instance->getAttributes()['test'])->implode(',');
+        });
+
+    expect($flexible->serialize())->toBe('foo0,bar1,foo2');
+})->only();