Add the Extension interface

Author: rybakit

README.md

@@ -277,8 +277,8 @@ var_dump($ext->data === "\xaa"); // bool(true)
 
 In addition to [the basic types](https://github.com/msgpack/msgpack/blob/master/spec.md#type-system),
 the library provides functionality to serialize and deserialize arbitrary types. In order to support a custom 
-type you need to create and register a transformer. The transformer should implement either or both the `CanPack` 
-and/or the `CanUnpackExt` interface.
+type you need to create and register a transformer. The transformer should implement either the `CanPack` interface 
+or the `Extension` interface.
 
 The purpose of `CanPack` transformers is to serialize a specific value to one of the basic MessagePack types. A good 
 example of such a transformer is a `MapTransformer` that comes with the library. It serializes `Map` objects (which 
@@ -324,26 +324,37 @@ $packed = $packer->pack([
 ]);
 ```
 
-Transformers implementing the `CanUnpackExt` interface are intended for unpacking 
-[extension types](https://github.com/msgpack/msgpack/blob/master/spec.md#extension-types). 
-With the help of the abstract class [Extension](src/TypeTransformer/Extension.php) you can extend 
-the MessagePack protocol with your own types. For example, the code below shows how to create 
-an extension that allows you to work transparently with `DateTime` objects:
+Transformers implementing the `Extension` interface are intended to handle [extension types](https://github.com/msgpack/msgpack/blob/master/spec.md#extension-types). 
+For example, the code below shows how to create an extension that allows you to work transparently with `DateTime` objects:
 
 ```php
 use MessagePack\BufferUnpacker;
 use MessagePack\Packer;
 use MessagePack\TypeTransformer\Extension;
 
-class DateTimeExtension extends Extension 
+class DateTimeExtension implements Extension 
 {
-    protected function packExt(Packer $packer, $value) : ?string
+    private $type;
+
+    public function __construct(int $type)
+    {
+        $this->type = $type;
+    }
+
+    public function getType() : int
+    {
+        return $this->type;
+    }
+
+    public function pack(Packer $packer, $value) : ?string
     {
         if (!$value instanceof \DateTimeInterface) {
             return null;
         }
 
-        return $packer->packStr($value->format('Y-m-d\TH:i:s.uP'));
+        return $packer->packExt($this->type,
+            $packer->packStr($value->format('Y-m-d\TH:i:s.uP'))
+        );
     }
 
     public function unpackExt(BufferUnpacker $unpacker, int $extLength)

examples/MessagePack/ArrayIteratorExtension.php

@@ -15,9 +15,21 @@
 use MessagePack\Packer;
 use MessagePack\TypeTransformer\Extension;
 
-class ArrayIteratorExtension extends Extension
+class ArrayIteratorExtension implements Extension
 {
-    protected function packExt(Packer $packer, $value) : ?string
+    private $type;
+
+    public function __construct(int $type)
+    {
+        $this->type = $type;
+    }
+
+    public function getType() : int
+    {
+        return $this->type;
+    }
+
+    public function pack(Packer $packer, $value) : ?string
     {
         if (!$value instanceof \ArrayIterator) {
             return null;
@@ -30,7 +42,9 @@ protected function packExt(Packer $packer, $value) : ?string
             ++$size;
         }
 
-        return $packer->packArrayHeader($size).$data;
+        return $packer->packExt($this->type,
+            $packer->packArrayHeader($size).$data
+        );
     }
 
     public function unpackExt(BufferUnpacker $unpacker, int $extLength)

examples/MessagePack/DateTimeExtension.php

@@ -15,15 +15,29 @@
 use MessagePack\Packer;
 use MessagePack\TypeTransformer\Extension;
 
-class DateTimeExtension extends Extension
+class DateTimeExtension implements Extension
 {
-    protected function packExt(Packer $packer, $value) : ?string
+    private $type;
+
+    public function __construct(int $type)
+    {
+        $this->type = $type;
+    }
+
+    public function getType() : int
+    {
+        return $this->type;
+    }
+
+    public function pack(Packer $packer, $value) : ?string
     {
         if (!$value instanceof \DateTimeInterface) {
             return null;
         }
 
-        return $packer->packStr($value->format('Y-m-d\TH:i:s.uP'));
+        return $packer->packExt($this->type,
+            $packer->packStr($value->format('Y-m-d\TH:i:s.uP'))
+        );
     }
 
     public function unpackExt(BufferUnpacker $unpacker, int $extLength)

examples/MessagePack/PackedMapExtension.php

@@ -15,9 +15,21 @@
 use MessagePack\Packer;
 use MessagePack\TypeTransformer\Extension;
 
-class PackedMapExtension extends Extension
+class PackedMapExtension implements Extension
 {
-    protected function packExt(Packer $packer, $value) : ?string
+    private $type;
+
+    public function __construct(int $type)
+    {
+        $this->type = $type;
+    }
+
+    public function getType() : int
+    {
+        return $this->type;
+    }
+
+    public function pack(Packer $packer, $value) : ?string
     {
         if (!$value instanceof PackedMap) {
             return null;
@@ -32,9 +44,11 @@ protected function packExt(Packer $packer, $value) : ?string
             ++$size;
         }
 
-        return $packer->packMap($value->schema)
-            .$packer->packArrayHeader($size)
-            .$data;
+        return $packer->packExt($this->type,
+            $packer->packMap($value->schema).
+            $packer->packArrayHeader($size).
+            $data
+        );
     }
 
     public function unpackExt(BufferUnpacker $unpacker, int $extLength)

src/BufferUnpacker.php

@@ -15,7 +15,7 @@
 use MessagePack\Exception\IntegerOverflowException;
 use MessagePack\Exception\InvalidOptionException;
 use MessagePack\Exception\UnpackingFailedException;
-use MessagePack\TypeTransformer\CanUnpackExt;
+use MessagePack\TypeTransformer\Extension;
 
 class BufferUnpacker
 {
@@ -25,18 +25,18 @@ class BufferUnpacker
     private $isBigIntAsGmp;
 
     /**
-     * @var CanUnpackExt[]
+     * @var Extension[]
      */
-    private $transformers = [];
+    private $extensions = [];
 
     /**
      * @param string $buffer
      * @param UnpackOptions|int|null $options
-     * @param CanUnpackExt[] $transformers
+     * @param Extension[] $extensions
      *
      * @throws InvalidOptionException
      */
-    public function __construct(string $buffer = '', $options = null, array $transformers = [])
+    public function __construct(string $buffer = '', $options = null, array $extensions = [])
     {
         if (null === $options) {
             $options = UnpackOptions::fromDefaults();
@@ -49,22 +49,22 @@ public function __construct(string $buffer = '', $options = null, array $transfo
 
         $this->buffer = $buffer;
 
-        if ([] !== $transformers) {
-            $this->transformers = [];
-            foreach ($transformers as $transformer) {
-                $this->transformers[$transformer->getType()] = $transformer;
+        if ([] !== $extensions) {
+            $this->extensions = [];
+            foreach ($extensions as $extension) {
+                $this->extensions[$extension->getType()] = $extension;
             }
         }
     }
 
-    public function extendWith(CanUnpackExt $transformer, CanUnpackExt ...$transformers) : self
+    public function extendWith(Extension $extension, Extension ...$extensions) : self
     {
         $new = clone $this;
-        $new->transformers[$transformer->getType()] = $transformer;
+        $new->extensions[$extension->getType()] = $extension;
 
-        if ([] !== $transformers) {
-            foreach ($transformers as $extraTransformer) {
-                $new->transformers[$extraTransformer->getType()] = $extraTransformer;
+        if ([] !== $extensions) {
+            foreach ($extensions as $extraExtension) {
+                $new->extensions[$extraExtension->getType()] = $extraExtension;
             }
         }
 
@@ -652,8 +652,8 @@ private function unpackExtData($length)
             $type -= 0x100;
         }
 
-        if (isset($this->transformers[$type])) {
-            return $this->transformers[$type]->unpackExt($this, $length);
+        if (isset($this->extensions[$type])) {
+            return $this->extensions[$type]->unpackExt($this, $length);
         }
 
         $data = \substr($this->buffer, $this->offset, $length);

src/TypeTransformer/CanUnpackExt.php

@@ -11,30 +11,11 @@
 
 namespace MessagePack\TypeTransformer;
 
-use MessagePack\Packer;
+use MessagePack\BufferUnpacker;
 
-abstract class Extension implements CanPack, CanUnpackExt
+interface Extension extends CanPack
 {
-    private $type;
+    public function getType() : int;
 
-    public function __construct(int $type)
-    {
-        $this->type = $type;
-    }
-
-    public function getType() : int
-    {
-        return $this->type;
-    }
-
-    public function pack(Packer $packer, $value) : ?string
-    {
-        if (null === $data = $this->packExt($packer, $value)) {
-            return null;
-        }
-
-        return $packer->packExt($this->type, $data);
-    }
-
-    abstract protected function packExt(Packer $packer, $value) : ?string;
+    public function unpackExt(BufferUnpacker $unpacker, int $extLength);
 }

src/TypeTransformer/Extension.php

@@ -17,7 +17,7 @@
 use MessagePack\Exception\InvalidOptionException;
 use MessagePack\Exception\UnpackingFailedException;
 use MessagePack\Ext;
-use MessagePack\TypeTransformer\CanUnpackExt;
+use MessagePack\TypeTransformer\Extension;
 use MessagePack\UnpackOptions;
 use PHPUnit\Framework\Error\Warning;
 use PHPUnit\Framework\TestCase;
@@ -301,7 +301,7 @@ public function testConstructorSetsTransformers() : void
         $obj = new \stdClass();
         $type = 5;
 
-        $transformer = $this->createMock(CanUnpackExt::class);
+        $transformer = $this->createMock(Extension::class);
         $transformer->method('getType')->willReturn($type);
         $transformer->expects(self::once())->method('unpackExt')
             ->with($this->isInstanceOf(BufferUnpacker::class), 1)
@@ -320,19 +320,19 @@ public function testUnpackCustomType() : void
         $type1 = 5;
         $type2 = 6;
 
-        $transformer1 = $this->createMock(CanUnpackExt::class);
-        $transformer1->method('getType')->willReturn($type1);
-        $transformer1->expects(self::once())->method('unpackExt')
+        $extension1 = $this->createMock(Extension::class);
+        $extension1->method('getType')->willReturn($type1);
+        $extension1->expects(self::once())->method('unpackExt')
             ->with($this->isInstanceOf(BufferUnpacker::class), 1)
             ->willReturn($obj1);
 
-        $transformer2 = $this->createMock(CanUnpackExt::class);
-        $transformer2->method('getType')->willReturn($type2);
-        $transformer2->expects(self::once())->method('unpackExt')
+        $extension2 = $this->createMock(Extension::class);
+        $extension2->method('getType')->willReturn($type2);
+        $extension2->expects(self::once())->method('unpackExt')
             ->with($this->isInstanceOf(BufferUnpacker::class), 1)
             ->willReturn($obj2);
 
-        $unpacker = $this->unpacker->extendWith($transformer1, $transformer2);
+        $unpacker = $this->unpacker->extendWith($extension1, $extension2);
 
         self::assertSame($obj1, $unpacker->reset("\xd4\x05\x01")->unpack());
         self::assertSame($obj2, $unpacker->reset("\xd4\x06\x01")->unpack());