Update clue/redis-protocol to v0.2.0 and explicitly pass its arguments

Explicitly pass the protocol factory and serializer to the Client

Author: clue

composer.json

@@ -14,7 +14,7 @@
         "react/promise": "~1",
         "react/socket-client": "0.3.*",
         "react/event-loop": "0.3.*",
-        "clue/redis-protocol": "0.1.*"
+        "clue/redis-protocol": "0.2.*"
     },
     "autoload": {
         "psr-0": { "Clue\\Redis\\React": "src" }

composer.lock

@@ -4,9 +4,10 @@
 
 use Evenement\EventEmitter;
 use React\Stream\Stream;
-use Clue\Redis\Protocol\ProtocolInterface;
-use Clue\Redis\Protocol\ParserException;
-use Clue\Redis\Protocol\ErrorReplyException;
+use Clue\Redis\Protocol\Parser\ParserInterface;
+use Clue\Redis\Protocol\Parser\ParserException;
+use Clue\Redis\Protocol\Model\ErrorReplyException;
+use Clue\Redis\Protocol\Serializer\SerializerInterface;
 use Clue\Redis\Protocol\Factory as ProtocolFactory;
 use Clue\Redis\React\Request;
 use React\Promise\When;
@@ -16,29 +17,36 @@
 class Client extends EventEmitter
 {
     private $stream;
-    private $protocol;
+    private $parser;
+    private $serializer;
     private $requests = array();
     private $ending = false;
 
-    public function __construct(Stream $stream, ProtocolInterface $protocol = null)
+    public function __construct(Stream $stream, ParserInterface $parser = null, SerializerInterface $serializer = null)
     {
-        if ($protocol === null) {
-            $protocol = ProtocolFactory::create();
+        if ($parser === null || $serializer === null) {
+            $factory = new ProtocolFactory();
+            if ($parser === null) {
+                $parser = $factory->createParser();
+            }
+            if ($serializer === null) {
+                $serializer = $factory->createSerializer();
+            }
         }
 
         $that = $this;
-        $stream->on('data', function($chunk) use ($protocol, $that) {
+        $stream->on('data', function($chunk) use ($parser, $that) {
             try {
-                $protocol->pushIncoming($chunk);
+                $parser->pushIncoming($chunk);
             }
             catch (ParserException $error) {
                 $that->emit('error', array($error));
                 $that->close();
                 return;
             }
 
-            while ($protocol->hasIncoming()) {
-                $data = $protocol->popIncoming();
+            while ($parser->hasIncomingModel()) {
+                $data = $parser->popIncomingModel();
 
                 try {
                     $that->handleReply($data);
@@ -56,7 +64,8 @@ public function __construct(Stream $stream, ProtocolInterface $protocol = null)
         });
         $stream->resume();
         $this->stream = $stream;
-        $this->protocol = $protocol;
+        $this->parser = $parser;
+        $this->serializer = $serializer;
     }
 
     public function __call($name, $args)
@@ -70,7 +79,7 @@ public function __call($name, $args)
         /* Build the Redis unified protocol command */
         array_unshift($args, $name);
 
-        $this->stream->write($this->protocol->createMessage($args));
+        $this->stream->write($this->serializer->createRequestMessage($args));
 
         $request = new Request($name);
         $this->requests []= $request;

src/Clue/Redis/React/Client.php

@@ -18,11 +18,17 @@ class Factory
 {
     private $loop;
     private $connector;
+    private $protocol;
 
-    public function __construct(LoopInterface $loop, ConnectorInterface $connector = null)
+    public function __construct(LoopInterface $loop, ConnectorInterface $connector = null, ProtocolFactory $protocol = null)
     {
         $this->loop = $loop;
         $this->connector = $connector;
+
+        if ($protocol === null) {
+            $protocol = new ProtocolFactory();
+        }
+        $this->protocol = $protocol;
     }
 
     /**
@@ -33,12 +39,12 @@ public function __construct(LoopInterface $loop, ConnectorInterface $connector =
      */
     public function createClient($target = null)
     {
-        $that = $this;
         $auth = $this->getAuthFromTarget($target);
         $db   = $this->getDatabaseFromTarget($target);
+        $protocol = $this->protocol;
 
-        return $this->connect($target)->then(function (Stream $stream) use ($that, $auth, $db) {
-            $client = new Client($stream, $that->createProtocol());
+        return $this->connect($target)->then(function (Stream $stream) use ($auth, $db, $protocol) {
+            $client = new Client($stream, $protocol->createParser(), $protocol->createSerializer());
 
             return When::all(
                 array(
@@ -56,11 +62,6 @@ function($error) use ($client) {
         });
     }
 
-    public function createProtocol()
-    {
-        return ProtocolFactory::create();
-    }
-
     private function parseUrl($target)
     {
         if ($target === null) {

src/Clue/Redis/React/Factory.php

@@ -2,17 +2,18 @@
 
 namespace Clue\Redis\React;
 
-use Clue\Redis\Protocol\ErrorReplyException;
+use Clue\Redis\Protocol\Model\ModelInterface;
+use Clue\Redis\Protocol\Model\ErrorReply;
 use React\Promise\Deferred;
 
 class Request extends Deferred
 {
-    public function handleReply($data)
+    public function handleReply(ModelInterface $data)
     {
-        if ($data instanceof ErrorReplyException) {
+        if ($data instanceof ErrorReply) {
             $this->reject($data);
         } else {
-            $this->resolve($data);
+            $this->resolve($data->getValueNative());
         }
     }
 }