添加插件

composer.json

@@ -9,7 +9,8 @@
         "laravel/framework": "5.2.*",
         "justinrainbow/json-schema": "~1.3",
         "maatwebsite/excel": "~2.0.0",
-        "guzzlehttp/guzzle": "^6.3"
+        "guzzlehttp/guzzle": "^6.3",
+        "predis/predis": "^1.1"
     },
     "require-dev": {
         "fzaninotto/faker": "~1.4",

composer.lock

@@ -4,7 +4,7 @@
         "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies",
         "This file is @generated automatically"
     ],
-    "content-hash": "b641c247c1b1a5cc7270b9f5715a6209",
+    "content-hash": "82292bc489e3c8df5d2e933e8dd8aefb",
     "packages": [
         {
             "name": "classpreloader/classpreloader",
@@ -1281,6 +1281,62 @@
             "time": "2015-05-01T07:00:55+00:00"
         },
         {
+            "name": "predis/predis",
+            "version": "v1.1.1",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/nrk/predis.git",
+                "reference": "f0210e38881631afeafb56ab43405a92cafd9fd1"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/nrk/predis/zipball/f0210e38881631afeafb56ab43405a92cafd9fd1",
+                "reference": "f0210e38881631afeafb56ab43405a92cafd9fd1",
+                "shasum": "",
+                "mirrors": [
+                    {
+                        "url": "https://dl.laravel-china.org/%package%/%reference%.%type%",
+                        "preferred": true
+                    }
+                ]
+            },
+            "require": {
+                "php": ">=5.3.9"
+            },
+            "require-dev": {
+                "phpunit/phpunit": "~4.8"
+            },
+            "suggest": {
+                "ext-curl": "Allows access to Webdis when paired with phpiredis",
+                "ext-phpiredis": "Allows faster serialization and deserialization of the Redis protocol"
+            },
+            "type": "library",
+            "autoload": {
+                "psr-4": {
+                    "Predis\\": "src/"
+                }
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "MIT"
+            ],
+            "authors": [
+                {
+                    "name": "Daniele Alessandri",
+                    "email": "suppakilla@gmail.com",
+                    "homepage": "http://clorophilla.net"
+                }
+            ],
+            "description": "Flexible and feature-complete Redis client for PHP and HHVM",
+            "homepage": "http://github.com/nrk/predis",
+            "keywords": [
+                "nosql",
+                "predis",
+                "redis"
+            ],
+            "time": "2016-06-16T16:22:20+00:00"
+        },
+        {
             "name": "psr/http-message",
             "version": "1.0.1",
             "source": {

vendor/composer/autoload_psr4.php

@@ -30,6 +30,7 @@ return array(
     'Psy\\' => array($vendorDir . '/psy/psysh/src/Psy'),
     'Psr\\Log\\' => array($vendorDir . '/psr/log/Psr/Log'),
     'Psr\\Http\\Message\\' => array($vendorDir . '/psr/http-message/src'),
+    'Predis\\' => array($vendorDir . '/predis/predis/src'),
     'PhpParser\\' => array($vendorDir . '/nikic/php-parser/lib/PhpParser'),
     'Monolog\\' => array($vendorDir . '/monolog/monolog/src/Monolog'),
     'League\\Flysystem\\' => array($vendorDir . '/league/flysystem/src'),

vendor/composer/installed.json

@@ -2231,6 +2231,64 @@
         ]
     },
     {
+        "name": "predis/predis",
+        "version": "v1.1.1",
+        "version_normalized": "1.1.1.0",
+        "source": {
+            "type": "git",
+            "url": "https://github.com/nrk/predis.git",
+            "reference": "f0210e38881631afeafb56ab43405a92cafd9fd1"
+        },
+        "dist": {
+            "type": "zip",
+            "url": "https://api.github.com/repos/nrk/predis/zipball/f0210e38881631afeafb56ab43405a92cafd9fd1",
+            "reference": "f0210e38881631afeafb56ab43405a92cafd9fd1",
+            "shasum": "",
+            "mirrors": [
+                {
+                    "url": "https://dl.laravel-china.org/%package%/%reference%.%type%",
+                    "preferred": true
+                }
+            ]
+        },
+        "require": {
+            "php": ">=5.3.9"
+        },
+        "require-dev": {
+            "phpunit/phpunit": "~4.8"
+        },
+        "suggest": {
+            "ext-curl": "Allows access to Webdis when paired with phpiredis",
+            "ext-phpiredis": "Allows faster serialization and deserialization of the Redis protocol"
+        },
+        "time": "2016-06-16T16:22:20+00:00",
+        "type": "library",
+        "installation-source": "dist",
+        "autoload": {
+            "psr-4": {
+                "Predis\\": "src/"
+            }
+        },
+        "notification-url": "https://packagist.org/downloads/",
+        "license": [
+            "MIT"
+        ],
+        "authors": [
+            {
+                "name": "Daniele Alessandri",
+                "email": "suppakilla@gmail.com",
+                "homepage": "http://clorophilla.net"
+            }
+        ],
+        "description": "Flexible and feature-complete Redis client for PHP and HHVM",
+        "homepage": "http://github.com/nrk/predis",
+        "keywords": [
+            "nosql",
+            "predis",
+            "redis"
+        ]
+    },
+    {
         "name": "psr/http-message",
         "version": "1.0.1",
         "version_normalized": "1.0.1.0",

vendor/predis/predis/CONTRIBUTING.md

+## Filing bug reports ##
+
+Bugs or feature requests can be posted on the [GitHub issues](http://github.com/nrk/predis/issues)
+section of the project.
+
+When reporting bugs, in addition to the obvious description of your issue you __must__ always provide
+some essential information about your environment such as:
+
+  1. version of Predis (check the `VERSION` file or the `Predis\Client::VERSION` constant).
+  2. version of Redis (check `redis_version` returned by [`INFO`](http://redis.io/commands/info)).
+  3. version of PHP.
+  4. name and version of the operating system.
+  5. when possible, a small snippet of code that reproduces the issue.
+
+__Think about it__: we do not have a crystal ball and cannot predict things or peer into the unknown
+so please provide as much details as possible to help us isolating issues and fix them.
+
+__Never__ use GitHub issues to post generic questions about Predis! When you have questions about
+how Predis works or how it can be used, please just hop me an email and I will get back to you as
+soon as possible.
+
+
+## Contributing code ##
+
+If you want to work on Predis, it is highly recommended that you first run the test suite in order
+to check that everything is OK and report strange behaviours or bugs. When modifying Predis please
+make sure that no warnings or notices are emitted by PHP running the interpreter in your development
+environment with the `error_reporting` variable set to `E_ALL | E_STRICT`.
+
+The recommended way to contribute to Predis is to fork the project on GitHub, create topic branches
+on your newly created repository to fix bugs or add new features (possibly with tests covering your
+modifications) and then open a pull request with a description of the applied changes. Obviously you
+can use any other Git hosting provider of your preference.
+
+We always aim for consistency in our code base so you should follow basic coding rules as defined by
+[PSR-1](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-1-basic-coding-standard.md)
+and [PSR-2](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-2-coding-style-guide.md)
+and stick with the conventions used in Predis to name classes and interfaces. Indentation should be
+done with 4 spaces and code should be wrapped at 100 columns (please try to stay within this limit
+even if the above mentioned official coding guidelines set the soft limit to 120 columns).
+
+Please follow these [commit guidelines](http://git-scm.com/book/ch5-2.html#Commit-Guidelines) when
+committing your code to Git and always write a meaningful (not necessarily extended) description of
+your changes before opening pull requests.

vendor/predis/predis/FAQ.md

+# Some frequently asked questions about Predis #
+________________________________________________
+
+### What is the point of Predis? ###
+
+The main point of Predis is about offering a highly customizable and extensible client for Redis,
+that can be easily extended by developers while still being reasonabily fast. With Predis you can
+swap almost any class with your own custom implementation: you can have custom connection classes,
+new distribution strategies for client-side sharding, or handlers to replace or add Redis commands.
+All of this can be achieved without messing with the source code of the library and directly in your
+own application. Given the fast pace at which Redis is developed and adds new features, this can be
+a great asset since it allows developers to add new and still missing features or commands or change
+the standard behaviour of the library without the need to break dependencies in production code (at
+least to some degree).
+
+### Does Predis support UNIX domain sockets and persistent connections? ###
+
+Yes. Obviously persistent connections actually work only when using PHP configured as a persistent
+process reused by the web server (see [PHP-FPM](http://php-fpm.org)).
+
+### Does Predis support SSL-encrypted connections? ###
+
+Yes. Encrypted connections are mostly useful when connecting to Redis instances exposed by various
+cloud hosting providers without the need to configure an SSL proxy, but you should also take into
+account the general performances degradation especially during the connect() operation when the TLS
+handshake must be performed to secure the connection. Persistent SSL-encrypted connections may help
+in that respect, but they are supported only when running on PHP >= 7.0.0.
+
+### Does Predis support transparent (de)serialization of values? ###
+
+No and it will not ever do that by default. The reason behind this decision is that serialization is
+usually something that developers prefer to customize depending on their needs and can not be easily
+generalized when using Redis because of the many possible access patterns for your data. This does
+not mean that it is impossible to have such a feature since you can leverage the extensibility of
+this library to define your own serialization-aware commands. You can find more details about how to
+do that [on this issue](http://github.com/nrk/predis/issues/29#issuecomment-1202624).
+
+### How can I force Predis to connect to Redis before sending any command? ###
+
+Explicitly connecting to Redis is usually not needed since the client initializes connections lazily
+only when they are needed. Admittedly, this behavior can be inconvenient in certain scenarios when
+you absolutely need to perform an upfront check to determine if the server is up and running and
+eventually catch exceptions on failures. Forcing the client to open the underlying connection can be
+done by invoking `Predis\Client::connect()`:
+
+```php
+$client = new Predis\Client();
+
+try {
+    $client->connect();
+} catch (Predis\Connection\ConnectionException $exception) {
+    // We could not connect to Redis! Your handling code goes here.
+}
+
+$client->info();
+```
+
+### How Predis abstracts Redis commands? ###
+
+The approach used to implement Redis commands is quite simple: by default each command follows the
+same signature as defined on the [Redis documentation](http://redis.io/commands) which makes things
+pretty easy if you already know how Redis works or you need to look up how to use certain commands.
+Alternatively, variadic commands can accept an array for keys or values (depending on the command)
+instead of a list of arguments. Commands such as [`RPUSH`](http://redis.io/commands/rpush) and
+[`HMSET`](http://redis.io/commands/hmset) are great examples:
+
+```php
+$client->rpush('my:list', 'value1', 'value2', 'value3');             // plain method arguments
+$client->rpush('my:list', ['value1', 'value2', 'value3']);           // single argument array
+
+$client->hmset('my:hash', 'field1', 'value1', 'field2', 'value2');   // plain method arguments
+$client->hmset('my:hash', ['field1'=>'value1', 'field2'=>'value2']); // single named array
+```
+
+An exception to this rule is [`SORT`](http://redis.io/commands/sort) for which modifiers are passed
+[using a named array](tests/Predis/Command/KeySortTest.php#L54-L75).
+
+
+# Speaking about performances... #
+_________________________________________________
+
+
+### Predis is a pure-PHP implementation: it can not be fast enough! ###
+
+It really depends, but most of the times the answer is: _yes, it is fast enough_. I will give you a
+couple of easy numbers with a simple test that uses a single client and is executed by PHP 5.5.6
+against a local instance of Redis 2.8 that runs under Ubuntu 13.10 on a Intel Q6600:
+
+```
+21000 SET/sec using 12 bytes for both key and value.
+21000 GET/sec while retrieving the very same values.
+0.130 seconds to fetch 30000 keys using _KEYS *_.
+```
+
+How does it compare with [__phpredis__](http://github.com/nicolasff/phpredis), a nice C extension
+providing an efficient client for Redis?
+
+```
+30100 SET/sec using 12 bytes for both key and value
+29400 GET/sec while retrieving the very same values
+0.035 seconds to fetch 30000 keys using "KEYS *"".
+```
+
+Wow __phpredis__ seems much faster! Well, we are comparing a C extension with a pure-PHP library so
+lower numbers are quite expected but there is a fundamental flaw in them: is this really how you are
+going to use Redis in your application? Are you really going to send thousands of commands using a
+for-loop on each page request using a single client instance? If so... well I guess you are probably
+doing something wrong. Also, if you need to `SET` or `GET` multiple keys you should definitely use
+commands such as `MSET` and `MGET`. You can also use pipelining to get more performances when this
+technique can be used.
+
+There is one more thing: we have tested the overhead of Predis by connecting on a localhost instance
+of Redis but how these numbers change when we hit the physical network by connecting to remote Redis
+instances?
+
+```
+Using Predis:
+3200 SET/sec using 12 bytes for both key and value
+3200 GET/sec while retrieving the very same values
+0.132 seconds to fetch 30000 keys using "KEYS *".
+
+Using phpredis:
+3500 SET/sec using 12 bytes for both key and value
+3500 GET/sec while retrieving the very same values
+0.045 seconds to fetch 30000 keys using "KEYS *".
+```
+
+There you go, you get almost the same average numbers and the reason is simple: network latency is a
+real performance killer and you cannot do (almost) anything about that. As a disclaimer, remember
+that we are measuring the overhead of client libraries implementations and the effects of network
+round-trip times, so we are not really measuring how fast Redis is. Redis shines best with thousands
+of concurrent clients doing requests! Also, actual performances should be measured according to how
+your application will use Redis.
+
+### I am convinced, but performances for multi-bulk responses are still worse ###
+
+Fair enough, but there is an option available if you need even more speed and consists on installing
+__[phpiredis](http://github.com/nrk/phpiredis)__ (note the additional _i_ in the name) and let the
+client use it. __phpiredis__ is another C extension that wraps __hiredis__ (the official C client
+library for Redis) with a thin layer exposing its features to PHP. You can then choose between two
+different connection classes:
+
+  - `Predis\Connection\PhpiredisStreamConnection` (using native PHP streams).
+  - `Predis\Connection\PhpiredisSocketConnection` (requires `ext-socket`).
+
+You will now get the benefits of a faster protocol serializer and parser just by adding a couple of
+lines of code:
+
+```php
+$client = new Predis\Client('tcp://127.0.0.1', array(
+    'connections' => array(
+        'tcp'  => 'Predis\Connection\PhpiredisStreamConnection',
+        'unix' => 'Predis\Connection\PhpiredisSocketConnection',
+    ),
+));
+```
+
+Dead simple. Nothing changes in the way you use the library in your application. So how fast is it
+our basic benchmark script now? There are not much improvements for inline or short bulk responses
+like the ones returned by `SET` and `GET`, but the speed for parsing multi-bulk responses is now on
+par with phpredis:
+
+```
+Fatching 30000 keys with _KEYS *_ using Predis paired with phpiredis::
+
+0.035 seconds from a local Redis instance
+0.047 seconds from a remote Redis instance
+```
+
+### If I need an extension to get better performances, why not using phpredis? ###
+
+Good question. Generically speaking if you need absolute uber-speed using Redis on the localhost and
+you do not care about abstractions built around some Redis features such as MULTI / EXEC, or if you
+do not need any kind of extensibility or guaranteed backwards compatibility with different versions
+of Redis (Predis currently supports from 1.2 up to 2.8 and the current development version), then
+using __phpredis__ makes absolutely sense. Otherwise, Predis is perfect for the job and by adding
+__phpiredis__ you can get a nice speed bump almost for free.

vendor/predis/predis/LICENSE

+Copyright (c) 2009-2016 Daniele Alessandri
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

vendor/predis/predis/VERSION

+1.1.1

vendor/predis/predis/autoload.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+require __DIR__.'/src/Autoloader.php';
+
+Predis\Autoloader::register();

vendor/predis/predis/bin/create-command-test

+#!/usr/bin/env php
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+// -------------------------------------------------------------------------- //
+// This script can be used to automatically generate a file with the scheleton
+// of a test case to test a Redis command by specifying the name of the class
+// in the Predis\Command namespace (only classes in this namespace are valid).
+// For example, to generate a test case for SET (which is represented by the
+// Predis\Command\StringSet class):
+//
+//   $ ./bin/generate-command-test --class=StringSet
+//
+// Here is a list of optional arguments:
+//
+// --realm: each command has its own realm (commands that operate on strings,
+// lists, sets and such) but while this realm is usually inferred from the name
+// of the specified class, sometimes it can be useful to override it with a
+// custom one.
+//
+// --output: write the generated test case to the specified path instead of
+// the default one.
+//
+// --overwrite: pre-existing test files are not overwritten unless this option
+// is explicitly specified.
+// -------------------------------------------------------------------------- //
+
+use Predis\Command\CommandInterface;
+use Predis\Command\PrefixableCommandInterface;
+
+class CommandTestCaseGenerator
+{
+    private $options;
+
+    public function __construct(array $options)
+    {
+        if (!isset($options['class'])) {
+            throw new RuntimeException("Missing 'class' option.");
+        }
+        $this->options = $options;
+    }
+
+    public static function fromCommandLine()
+    {
+        $parameters = array(
+            'c:'  => 'class:',
+            'r::' => 'realm::',
+            'o::' => 'output::',
+            'x::' => 'overwrite::'
+        );
+
+        $getops = getopt(implode(array_keys($parameters)), $parameters);
+
+        $options = array(
+            'overwrite' => false,
+            'tests' => __DIR__.'/../tests/Predis',
+        );
+
+        foreach ($getops as $option => $value) {
+            switch ($option) {
+                case 'c':
+                case 'class':
+                    $options['class'] = $value;
+                    break;
+
+                case 'r':
+                case 'realm':
+                    $options['realm'] = $value;
+                    break;
+
+                case 'o':
+                case 'output':
+                    $options['output'] = $value;
+                    break;
+
+                case 'x':
+                case 'overwrite':
+                    $options['overwrite'] = true;
+                    break;
+            }
+        }
+
+        if (!isset($options['class'])) {
+            throw new RuntimeException("Missing 'class' option.");
+        }
+
+        $options['fqn'] = "Predis\\Command\\{$options['class']}";
+        $options['path'] = "Command/{$options['class']}.php";
+
+        $source = __DIR__.'/../src/'.$options['path'];
+        if (!file_exists($source)) {
+            throw new RuntimeException("Cannot find class file for {$options['fqn']} in $source.");
+        }
+
+        if (!isset($options['output'])) {
+            $options['output'] = sprintf("%s/%s", $options['tests'], str_replace('.php', 'Test.php', $options['path']));
+        }
+
+        return new self($options);
+    }
+
+    protected function getTestRealm()
+    {
+        if (isset($this->options['realm'])) {
+            if (!$this->options['realm']) {
+                throw new RuntimeException('Invalid value for realm has been sepcified (empty).');
+            }
+            return $this->options['realm'];
+        }
+
+        $fqnParts = explode('\\', $this->options['fqn']);
+        $class = array_pop($fqnParts);
+        list($realm,) = preg_split('/([[:upper:]][[:lower:]]+)/', $class, 2, PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_NO_EMPTY);
+
+        return strtolower($realm);
+    }
+
+    public function generate()
+    {
+        $reflection = new ReflectionClass($class = $this->options['fqn']);
+
+        if (!$reflection->isInstantiable()) {
+            throw new RuntimeException("Class $class must be instantiable, abstract classes or interfaces are not allowed.");
+        }
+        if (!$reflection->implementsInterface('Predis\Command\CommandInterface')) {
+            throw new RuntimeException("Class $class must implement Predis\Command\CommandInterface.");
+        }
+
+        /*
+         * @var CommandInterface
+         */
+        $instance = $reflection->newInstance();
+
+        $buffer = $this->getTestCaseBuffer($instance);
+
+        return $buffer;
+    }
+
+    public function save()
+    {
+        $options = $this->options;
+        if (file_exists($options['output']) && !$options['overwrite']) {
+            throw new RuntimeException("File {$options['output']} already exist. Specify the --overwrite option to overwrite the existing file.");
+        }
+        file_put_contents($options['output'], $this->generate());
+    }
+
+    protected function getTestCaseBuffer(CommandInterface $instance)
+    {
+        $id = $instance->getId();
+        $fqn = get_class($instance);
+        $fqnParts = explode('\\', $fqn);
+        $class = array_pop($fqnParts) . "Test";
+        $realm = $this->getTestRealm();
+
+        $buffer =<<<PHP
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis\Command;
+
+/**
+ * @group commands
+ * @group realm-$realm
+ */
+class $class extends PredisCommandTestCase
+{
+    /**
+     * {@inheritdoc}
+     */
+    protected function getExpectedCommand()
+    {
+        return '$fqn';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function getExpectedId()
+    {
+        return '$id';
+    }
+
+    /**
+     * @group disconnected
+     */
+    public function testFilterArguments()
+    {
+        \$this->markTestIncomplete('This test has not been implemented yet.');
+
+        \$arguments = array(/* add arguments */);
+        \$expected = array(/* add arguments */);
+
+        \$command = \$this->getCommand();
+        \$command->setArguments(\$arguments);
+
+        \$this->assertSame(\$expected, \$command->getArguments());
+    }
+
+    /**
+     * @group disconnected
+     */
+    public function testParseResponse()
+    {
+        \$this->markTestIncomplete('This test has not been implemented yet.');
+
+        \$raw = null;
+        \$expected = null;
+
+        \$command = \$this->getCommand();
+
+        \$this->assertSame(\$expected, \$command->parseResponse(\$raw));
+    }
+
+PHP;
+
+        if ($instance instanceof PrefixableCommandInterface) {
+            $buffer .=<<<PHP
+
+    /**
+     * @group disconnected
+     */
+    public function testPrefixKeys()
+    {
+        \$this->markTestIncomplete('This test has not been implemented yet.');
+
+        \$arguments = array(/* add arguments */);
+        \$expected = array(/* add arguments */);
+
+        \$command = \$this->getCommandWithArgumentsArray(\$arguments);
+        \$command->prefixKeys('prefix:');
+
+        \$this->assertSame(\$expected, \$command->getArguments());
+    }
+
+    /**
+     * @group disconnected
+     */
+    public function testPrefixKeysIgnoredOnEmptyArguments()
+    {
+        \$command = \$this->getCommand();
+        \$command->prefixKeys('prefix:');
+
+        \$this->assertSame(array(), \$command->getArguments());
+    }
+
+PHP;
+        }
+
+        return "$buffer}\n";
+    }
+}
+
+// ------------------------------------------------------------------------- //
+
+require __DIR__.'/../autoload.php';
+
+$generator = CommandTestCaseGenerator::fromCommandLine();
+$generator->save();

vendor/predis/predis/bin/create-pear

+#!/usr/bin/env php
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+// -------------------------------------------------------------------------- //
+// In order to be able to execute this script to create a PEAR package of Predis
+// the `pear` binary must be available and executable in your $PATH.
+// The parts used to parse author and version strings are taken from Onion (used
+// by this library in the past) just to keep on relying on the package.ini file
+// to simplify things. We might consider to switch to using the PEAR classes
+// directly in the future.
+// -------------------------------------------------------------------------- //
+
+function executeWithBackup($file, $callback)
+{
+    $exception = null;
+    $backup = "$file.backup";
+
+    copy($file, $backup);
+
+    try {
+        call_user_func($callback, $file);
+    } catch (Exception $exception) {
+        // NOOP
+    }
+
+    unlink($file);
+    rename($backup, $file);
+
+    if ($exception) {
+        throw $exception;
+    }
+}
+
+function parseAuthor($string)
+{
+    $author = array();
+
+    if (preg_match('/^\s*(.+?)\s*(?:"(\S+)"\s*)?<(\S+)>\s*$/x', $string , $regs)) {
+        if (count($regs) == 4) {
+            list($_,$name,$user,$email) = $regs;
+            $author['name'] = $name;
+            $author['user'] = $user;
+            $author['email'] = $email;
+        } elseif (count($regs) == 3) {
+            list($_,$name,$email) = $regs;
+            $author['name'] = $name;
+            $author['email'] = $email;
+        }
+    } else {
+        $author['name'] = $string;
+    }
+
+    return $author;
+}
+
+function parseVersion($string)
+{
+    $version_pattern = '([0-9.]+)';
+
+    if (preg_match("/^\s*$version_pattern\s*\$/x", $string, $regs)) {
+        return array('min' => $regs[1] ?: '0.0.0');
+    } elseif (preg_match("/^\s*[>=]+\s*$version_pattern\s*\$/x", $string, $regs)) {
+        return array('min' => $regs[1] ?: '0.0.0');
+    } elseif (preg_match("/^\s*[<=]+\s*$version_pattern\s*\$/x", $string, $regs)) {
+        return array('max' => $regs[1]);
+    } elseif (preg_match("/^\s*$version_pattern\s*<=>\s*$version_pattern\s*\$/x", $string, $regs)) {
+        return array(
+            'min' => $regs[1] ?: '0.0.0',
+            'max' => $regs[2],
+        );
+    }
+
+    return null;
+}
+
+function addRolePath($pkg, $path, $role)
+{
+    if (is_dir($path)) {
+        $dirRoot = new RecursiveDirectoryIterator($path, RecursiveDirectoryIterator::SKIP_DOTS);
+        $dirTree = new RecursiveIteratorIterator($dirRoot, RecursiveIteratorIterator::CHILD_FIRST);
+
+        foreach ($dirTree as $fileinfo) {
+            if ($fileinfo->isFile()) {
+                addPackageFile($pkg, $fileinfo, $role, $path);
+            }
+        }
+    } else {
+        foreach (glob($path) as $filename) {
+            addPackageFile($pkg, new SplFileInfo($filename), $role);
+        }
+    }
+}
+
+function addPackageFile($pkg, $fileinfo, $role, $baseDir = '')
+{
+    $fileNode = $pkg->contents->dir->addChild('file');
+    $fileNode->addAttribute('name', $filepath = $fileinfo->getPathname());
+    $fileNode->addAttribute('role', $role);
+    $fileNode->addAttribute('md5sum', md5_file($filepath));
+
+    $installNode = $pkg->phprelease->filelist->addChild('install');
+    $installNode->addAttribute('name', $filepath);
+    $installNode->addAttribute('as', !$baseDir ? basename($filepath) : substr($filepath, strlen($baseDir) + 1));
+}
+
+function generatePackageXml($packageINI)
+{
+    $XML = <<<XML
+<?xml version="1.0"?>
+<package packagerversion="1.4.10" version="2.0"
+    xmlns="http://pear.php.net/dtd/package-2.0"
+    xmlns:tasks="http://pear.php.net/dtd/tasks-1.0"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://pear.php.net/dtd/tasks-1.0
+              http://pear.php.net/dtd/tasks-1.0.xsd
+              http://pear.php.net/dtd/package-2.0
+              http://pear.php.net/dtd/package-2.0.xsd" />
+XML;
+
+    $cfg = parse_ini_file($packageINI, true);
+    $pkg = new SimpleXMLElement($XML);
+
+    $pkg->name = $cfg['package']['name'];
+    $pkg->channel = $cfg['package']['channel'];
+    $pkg->summary = $cfg['package']['desc'];
+    $pkg->description = $cfg['package']['desc'];
+
+    $author = parseAuthor($cfg['package']['author']);
+    $pkg->addChild('lead');
+    $pkg->lead->name = $author['name'];
+    $pkg->lead->user = $author['user'];
+    $pkg->lead->email = $author['email'];
+    $pkg->lead->active = 'yes';
+
+    $datetime = new DateTime('now');
+    $pkg->date = $datetime->format('Y-m-d');
+    $pkg->time = $datetime->format('H:i:s');
+
+    $pkg->addChild('version');
+    $pkg->version->release = $cfg['package']['version'];
+    $pkg->version->api = $cfg['package']['version'];
+
+    $pkg->addChild('stability');
+    $pkg->stability->release = $cfg['package']['stability'];
+    $pkg->stability->api = $cfg['package']['stability'];
+
+    $pkg->license = $cfg['package']['license'];
+    $pkg->notes = '-';
+
+    $pkg->addChild('contents')->addChild('dir')->addAttribute('name', '/');
+
+    $pkg->addChild('dependencies')->addChild('required');
+    foreach ($cfg['require'] as $required => $version) {
+        $version = parseVersion($version);
+        $pkg->dependencies->required->addChild($required);
+
+        if (isset($version['min'])) {
+            $pkg->dependencies->required->$required->min = $version['min'];
+        }
+        if (isset($version['max'])) {
+            $pkg->dependencies->required->$required->min = $version['max'];
+        }
+    }
+
+    $pkg->addChild('phprelease')->addChild('filelist');
+
+    $pathToRole = array(
+        'doc' => 'doc', 'docs' => 'doc', 'examples' => 'doc',
+        'lib' => 'php', 'src' => 'php',
+        'test' => 'test', 'tests' => 'test',
+    );
+
+    foreach (array_merge($pathToRole, $cfg['roles'] ?: array()) as $path => $role) {
+        addRolePath($pkg, $path, $role);
+    }
+
+    return $pkg;
+}
+
+function rewritePackageInstallAs($pkg)
+{
+    foreach ($pkg->phprelease->filelist->install as $file) {
+        if (preg_match('/^src\//', $file['name'])) {
+            $file['as'] = "Predis/{$file['as']}";
+        }
+    }
+}
+
+function savePackageXml($xml)
+{
+    $dom = new DOMDocument("1.0");
+    $dom->preserveWhiteSpace = false;
+    $dom->formatOutput = true;
+    $dom->loadXML($xml->asXML());
+
+    file_put_contents('package.xml', $dom->saveXML());
+}
+
+function buildPackage()
+{
+    passthru('pear -q package && rm package.xml');
+}
+
+function modifyPhpunitXml($file)
+{
+    $cfg = new SimpleXMLElement($file, null, true);
+
+    $cfg[0]['bootstrap'] = str_replace('tests/', '', $cfg[0]['bootstrap']);
+    $cfg->testsuites->testsuite->directory = str_replace('tests/', '', $cfg->testsuites->testsuite->directory);
+
+    $cfg->saveXml($file);
+}
+
+// -------------------------------------------------------------------------- //
+
+executeWithBackup(__DIR__.'/../phpunit.xml.dist', function ($file) {
+    modifyPhpunitXml($file);
+
+    $pkg = generatePackageXml('package.ini');
+    rewritePackageInstallAs($pkg);
+    savePackageXml($pkg);
+
+    buildPackage();
+});

vendor/predis/predis/bin/create-phar

+#!/usr/bin/env php
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+// -------------------------------------------------------------------------- //
+// In order to be able to execute this script to create a Phar archive of Predis,
+// the Phar module must be loaded and the "phar.readonly" directive php.ini must
+// be set to "off". You can change the values in the $options array to customize
+// the creation of the Phar archive to better suit your needs.
+// -------------------------------------------------------------------------- //
+
+$options = array(
+    'name'           => 'predis',
+    'project_path'   => __DIR__ . '/../src',
+    'compression'    => Phar::NONE,
+    'append_version' => true,
+);
+
+function getPharFilename($options)
+{
+    $filename = $options['name'];
+
+    // NOTE: do not consider "append_version" with Phar compression do to a bug in
+    // Phar::compress() when renaming phar archives containing dots in their name.
+    if ($options['append_version'] && $options['compression'] === Phar::NONE) {
+        $versionFile = @fopen(__DIR__ . '/../VERSION', 'r');
+
+        if ($versionFile === false) {
+            throw new Exception("Could not locate the VERSION file.");
+        }
+
+        $version = trim(fgets($versionFile));
+        fclose($versionFile);
+        $filename .= "_$version";
+    }
+
+    return "$filename.phar";
+}
+
+function getPharStub($options)
+{
+    return <<<EOSTUB
+<?php
+Phar::mapPhar('predis.phar');
+spl_autoload_register(function (\$class) {
+    if (strpos(\$class, 'Predis\\\\') === 0) {
+        \$file = 'phar://predis.phar/'.strtr(substr(\$class, 7), '\\\', '/').'.php';
+        if (file_exists(\$file)) {
+            require \$file;
+            return true;
+        }
+    }
+});
+__HALT_COMPILER();
+EOSTUB;
+}
+
+// -------------------------------------------------------------------------- //
+
+$phar = new Phar(getPharFilename($options));
+$phar->compress($options['compression']);
+$phar->setStub(getPharStub($options));
+$phar->buildFromDirectory($options['project_path']);

vendor/predis/predis/composer.json

+{
+    "name": "predis/predis",
+    "type": "library",
+    "description": "Flexible and feature-complete Redis client for PHP and HHVM",
+    "keywords": ["nosql", "redis", "predis"],
+    "homepage": "http://github.com/nrk/predis",
+    "license": "MIT",
+    "support": {
+        "issues": "https://github.com/nrk/predis/issues"
+    },
+    "authors": [
+        {
+            "name": "Daniele Alessandri",
+            "email": "suppakilla@gmail.com",
+            "homepage": "http://clorophilla.net"
+        }
+    ],
+    "require": {
+        "php": ">=5.3.9"
+    },
+    "require-dev": {
+        "phpunit/phpunit": "~4.8"
+    },
+    "suggest": {
+        "ext-phpiredis": "Allows faster serialization and deserialization of the Redis protocol",
+        "ext-curl": "Allows access to Webdis when paired with phpiredis"
+    },
+    "autoload": {
+        "psr-4": {"Predis\\": "src/"}
+    }
+}

vendor/predis/predis/examples/custom_cluster_distributor.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+require __DIR__.'/shared.php';
+
+// Developers can implement Predis\Distribution\DistributorInterface to create
+// their own distributors used by the client to distribute keys among a cluster
+// of servers.
+
+use Predis\Cluster\Distributor\DistributorInterface;
+use Predis\Cluster\Hash\HashGeneratorInterface;
+use Predis\Cluster\PredisStrategy;
+use Predis\Connection\Aggregate\PredisCluster;
+
+class NaiveDistributor implements DistributorInterface, HashGeneratorInterface
+{
+    private $nodes;
+    private $nodesCount;
+
+    public function __construct()
+    {
+        $this->nodes = array();
+        $this->nodesCount = 0;
+    }
+
+    public function add($node, $weight = null)
+    {
+        $this->nodes[] = $node;
+        ++$this->nodesCount;
+    }
+
+    public function remove($node)
+    {
+        $this->nodes = array_filter($this->nodes, function ($n) use ($node) {
+            return $n !== $node;
+        });
+
+        $this->nodesCount = count($this->nodes);
+    }
+
+    public function getSlot($hash)
+    {
+        return $this->nodesCount > 1 ? abs($hash % $this->nodesCount) : 0;
+    }
+
+    public function getBySlot($slot)
+    {
+        return isset($this->nodes[$slot]) ? $this->nodes[$slot] : null;
+    }
+
+    public function getByHash($hash)
+    {
+        if (!$this->nodesCount) {
+            throw new RuntimeException('No connections.');
+        }
+
+        $slot = $this->getSlot($hash);
+        $node = $this->getBySlot($slot);
+
+        return $node;
+    }
+
+    public function get($value)
+    {
+        $hash = $this->hash($value);
+        $node = $this->getByHash($hash);
+
+        return $node;
+    }
+
+    public function hash($value)
+    {
+        return crc32($value);
+    }
+
+    public function getHashGenerator()
+    {
+        return $this;
+    }
+}
+
+$options = array(
+    'cluster' => function () {
+        $distributor = new NaiveDistributor();
+        $strategy = new PredisStrategy($distributor);
+        $cluster = new PredisCluster($strategy);
+
+        return $cluster;
+    },
+);
+
+$client = new Predis\Client($multiple_servers, $options);
+
+for ($i = 0; $i < 100; ++$i) {
+    $client->set("key:$i", str_pad($i, 4, '0', 0));
+    $client->get("key:$i");
+}
+
+$server1 = $client->getClientFor('first')->info();
+$server2 = $client->getClientFor('second')->info();
+
+if (isset($server1['Keyspace'], $server2['Keyspace'])) {
+    $server1 = $server1['Keyspace'];
+    $server2 = $server2['Keyspace'];
+}
+
+printf("Server '%s' has %d keys while server '%s' has %d keys.\n",
+    'first', $server1['db15']['keys'], 'second', $server2['db15']['keys']
+);

vendor/predis/predis/examples/debuggable_connection.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+require __DIR__.'/shared.php';
+
+// This is an example of how you can easily extend an existing connection class
+// and trace the execution of commands for debugging purposes. This can be quite
+// useful as a starting poing to understand how your application interacts with
+// Redis.
+
+use Predis\Command\CommandInterface;
+use Predis\Connection\StreamConnection;
+
+class SimpleDebuggableConnection extends StreamConnection
+{
+    private $tstart = 0;
+    private $debugBuffer = array();
+
+    public function connect()
+    {
+        $this->tstart = microtime(true);
+
+        parent::connect();
+    }
+
+    private function storeDebug(CommandInterface $command, $direction)
+    {
+        $firtsArg = $command->getArgument(0);
+        $timestamp = round(microtime(true) - $this->tstart, 4);
+
+        $debug = $command->getId();
+        $debug .= isset($firtsArg) ? " $firtsArg " : ' ';
+        $debug .= "$direction $this";
+        $debug .= " [{$timestamp}s]";
+
+        $this->debugBuffer[] = $debug;
+    }
+
+    public function writeRequest(CommandInterface $command)
+    {
+        parent::writeRequest($command);
+
+        $this->storeDebug($command, '->');
+    }
+
+    public function readResponse(CommandInterface $command)
+    {
+        $response = parent::readResponse($command);
+        $this->storeDebug($command, '<-');
+
+        return $response;
+    }
+
+    public function getDebugBuffer()
+    {
+        return $this->debugBuffer;
+    }
+}
+
+$options = array(
+    'connections' => array(
+        'tcp' => 'SimpleDebuggableConnection',
+    ),
+);
+
+$client = new Predis\Client($single_server, $options);
+$client->set('foo', 'bar');
+$client->get('foo');
+$client->info();
+
+var_export($client->getConnection()->getDebugBuffer());
+
+/* OUTPUT:
+array (
+  0 => 'SELECT 15 -> 127.0.0.1:6379 [0.0008s]',
+  1 => 'SELECT 15 <- 127.0.0.1:6379 [0.001s]',
+  2 => 'SET foo -> 127.0.0.1:6379 [0.001s]',
+  3 => 'SET foo <- 127.0.0.1:6379 [0.0011s]',
+  4 => 'GET foo -> 127.0.0.1:6379 [0.0013s]',
+  5 => 'GET foo <- 127.0.0.1:6379 [0.0015s]',
+  6 => 'INFO -> 127.0.0.1:6379 [0.0019s]',
+  7 => 'INFO <- 127.0.0.1:6379 [0.0022s]',
+)
+*/

vendor/predis/predis/examples/dispatcher_loop.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+require __DIR__.'/shared.php';
+
+// This is a basic example on how to use the Predis\DispatcherLoop class.
+//
+// To see this example in action you can just use redis-cli and publish some
+// messages to the 'events' and 'control' channel, e.g.:
+
+// ./redis-cli
+// PUBLISH events first
+// PUBLISH events second
+// PUBLISH events third
+// PUBLISH control terminate_dispatcher
+
+// Create a client and disable r/w timeout on the socket
+$client = new Predis\Client($single_server + array('read_write_timeout' => 0));
+
+// Return an initialized PubSub consumer instance from the client.
+$pubsub = $client->pubSubLoop();
+
+// Create a dispatcher loop instance and attach a bunch of callbacks.
+$dispatcher = new Predis\PubSub\DispatcherLoop($pubsub);
+
+// Demonstrate how to use a callable class as a callback for the dispatcher loop.
+class EventsListener implements Countable
+{
+    private $events;
+
+    public function __construct()
+    {
+        $this->events = array();
+    }
+
+    public function count()
+    {
+        return count($this->events);
+    }
+
+    public function getEvents()
+    {
+        return $this->events;
+    }
+
+    public function __invoke($payload)
+    {
+        $this->events[] = $payload;
+    }
+}
+
+// Attach our callable class to the dispatcher.
+$dispatcher->attachCallback('events', ($events = new EventsListener()));
+
+// Attach a function to control the dispatcher loop termination with a message.
+$dispatcher->attachCallback('control', function ($payload) use ($dispatcher) {
+    if ($payload === 'terminate_dispatcher') {
+        $dispatcher->stop();
+    }
+});
+
+// Run the dispatcher loop until the callback attached to the 'control' channel
+// receives 'terminate_dispatcher' as a message.
+$dispatcher->run();
+
+// Display our achievements!
+echo "We received {$events->count()} messages!", PHP_EOL;
+
+// Say goodbye :-)
+$version = redis_version($client->info());
+echo "Goodbye from Redis $version!", PHP_EOL;

vendor/predis/predis/examples/executing_redis_commands.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+require __DIR__.'/shared.php';
+
+$client = new Predis\Client($single_server);
+
+// Plain old SET and GET example...
+$client->set('library', 'predis');
+$response = $client->get('library');
+
+var_export($response); echo PHP_EOL;
+/* OUTPUT: 'predis' */
+
+// Redis has the MSET and MGET commands to set or get multiple keys in one go,
+// cases like this Predis accepts arguments for variadic commands both as a list
+// of arguments or an array containing all of the keys and/or values.
+$mkv = array(
+    'uid:0001' => '1st user',
+    'uid:0002' => '2nd user',
+    'uid:0003' => '3rd user',
+);
+
+$client->mset($mkv);
+$response = $client->mget(array_keys($mkv));
+
+var_export($response); echo PHP_EOL;
+/* OUTPUT:
+array (
+  0 => '1st user',
+  1 => '2nd user',
+  2 => '3rd user',
+) */
+
+// Predis can also send "raw" commands to Redis. The difference between sending
+// commands to Redis the usual way and the "raw" way is that in the latter case
+// their arguments are not filtered nor responses coming from Redis are parsed.
+
+$response = $client->executeRaw(array(
+    'MGET', 'uid:0001', 'uid:0002', 'uid:0003',
+));
+
+var_export($response); echo PHP_EOL;
+/* OUTPUT:
+array (
+  0 => '1st user',
+  1 => '2nd user',
+  2 => '3rd user',
+) */

vendor/predis/predis/examples/key_prefixing.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+require __DIR__.'/shared.php';
+
+// Predis can prefix keys found in commands arguments before sending commands to
+// Redis, even for complex commands such as SORT, ZUNIONSTORE and ZINTERSTORE.
+// Prefixing keys can be useful to create user-level namespaces for you keyspace
+// thus reducing the need for separate logical databases in certain scenarios.
+
+$client = new Predis\Client($single_server, array('prefix' => 'nrk:'));
+
+$client->mset(array('foo' => 'bar', 'lol' => 'wut'));
+var_export($client->mget('foo', 'lol'));
+/*
+array (
+  0 => 'bar',
+  1 => 'wut',
+)
+*/
+
+var_export($client->keys('*'));
+/*
+array (
+  0 => 'nrk:foo',
+  1 => 'nrk:lol',
+)
+*/

vendor/predis/predis/examples/lua_scripting_abstraction.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+require __DIR__.'/shared.php';
+
+// This example will not work with versions of Redis < 2.6.
+//
+// Additionally to the EVAL command defined in the current development profile,
+// the Predis\Command\ScriptCommand class can be used to build an higher level
+// abstraction for "scriptable" commands so that they will appear just like any
+// other command on the client-side. This is a quick example used to implement
+// INCREX.
+
+use Predis\Command\ScriptCommand;
+
+class IncrementExistingKeysBy extends ScriptCommand
+{
+    public function getKeysCount()
+    {
+        // Tell Predis to use all the arguments but the last one as arguments
+        // for KEYS. The last one will be used to populate ARGV.
+        return -1;
+    }
+
+    public function getScript()
+    {
+        return <<<LUA
+local cmd, insert = redis.call, table.insert
+local increment, results = ARGV[1], { }
+
+for idx, key in ipairs(KEYS) do
+  if cmd('exists', key) == 1 then
+    insert(results, idx, cmd('incrby', key, increment))
+  else
+    insert(results, idx, false)
+  end
+end
+
+return results
+LUA;
+    }
+}
+
+$client = new Predis\Client($single_server, array(
+    'profile' => function ($options) {
+        $profile = $options->getDefault('profile');
+        $profile->defineCommand('increxby', 'IncrementExistingKeysBy');
+
+        return $profile;
+    },
+));
+
+$client->mset('foo', 10, 'foobar', 100);
+
+var_export($client->increxby('foo', 'foofoo', 'foobar', 50));
+
+/*
+array (
+  0 => 60,
+  1 => NULL,
+  2 => 150,
+)
+*/

vendor/predis/predis/examples/monitor_consumer.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+require __DIR__.'/shared.php';
+
+// This is a basic example on how to use the Predis\Monitor\Consumer class. You
+// can use redis-cli to send commands to the same Redis instance your client is
+// connected to, and then type "ECHO QUIT_MONITOR" in redis-cli when you want to
+// exit the monitor loop and terminate this script in a graceful way.
+
+// Create a client and disable r/w timeout on the socket.
+$client = new Predis\Client($single_server + array('read_write_timeout' => 0));
+
+// Use only one instance of DateTime, we will update the timestamp later.
+$timestamp = new DateTime();
+
+foreach (($monitor = $client->monitor()) as $event) {
+    $timestamp->setTimestamp((int) $event->timestamp);
+
+    // If we notice a ECHO command with the message QUIT_MONITOR, we stop the
+    // monitor consumer and then break the loop.
+    if ($event->command === 'ECHO' && $event->arguments === '"QUIT_MONITOR"') {
+        echo 'Exiting the monitor loop...', PHP_EOL;
+        $monitor->stop();
+        break;
+    }
+
+    echo "* Received {$event->command} on DB {$event->database} at {$timestamp->format(DateTime::W3C)}", PHP_EOL;
+    if (isset($event->arguments)) {
+        echo "    Arguments: {$event->arguments}", PHP_EOL;
+    }
+}
+
+// Say goodbye :-)
+$version = redis_version($client->info());
+echo "Goodbye from Redis $version!", PHP_EOL;

vendor/predis/predis/examples/pipelining_commands.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+require __DIR__.'/shared.php';
+
+// When you have a whole set of consecutive commands to send to a redis server,
+// you can use a pipeline to dramatically improve performances. Pipelines can
+// greatly reduce the effects of network round-trips.
+
+$client = new Predis\Client($single_server);
+
+$responses = $client->pipeline(function ($pipe) {
+    $pipe->flushdb();
+    $pipe->incrby('counter', 10);
+    $pipe->incrby('counter', 30);
+    $pipe->exists('counter');
+    $pipe->get('counter');
+    $pipe->mget('does_not_exist', 'counter');
+});
+
+var_export($responses);
+
+/* OUTPUT:
+array (
+  0 => Predis\Response\Status::__set_state(array(
+    'payload' => 'OK',
+  )),
+  1 => 10,
+  2 => 40,
+  3 => true,
+  4 => '40',
+  5 => array (
+    0 => NULL,
+    1 => '40',
+  ),
+)
+*/

vendor/predis/predis/examples/pubsub_consumer.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+require __DIR__.'/shared.php';
+
+// Starting from Redis 2.0 clients can subscribe and listen for events published
+// on certain channels using a Publish/Subscribe (PUB/SUB) approach.
+
+// Create a client and disable r/w timeout on the socket
+$client = new Predis\Client($single_server + array('read_write_timeout' => 0));
+
+// Initialize a new pubsub consumer.
+$pubsub = $client->pubSubLoop();
+
+// Subscribe to your channels
+$pubsub->subscribe('control_channel', 'notifications');
+
+// Start processing the pubsup messages. Open a terminal and use redis-cli
+// to push messages to the channels. Examples:
+//   ./redis-cli PUBLISH notifications "this is a test"
+//   ./redis-cli PUBLISH control_channel quit_loop
+foreach ($pubsub as $message) {
+    switch ($message->kind) {
+        case 'subscribe':
+            echo "Subscribed to {$message->channel}", PHP_EOL;
+            break;
+
+        case 'message':
+            if ($message->channel == 'control_channel') {
+                if ($message->payload == 'quit_loop') {
+                    echo 'Aborting pubsub loop...', PHP_EOL;
+                    $pubsub->unsubscribe();
+                } else {
+                    echo "Received an unrecognized command: {$message->payload}.", PHP_EOL;
+                }
+            } else {
+                echo "Received the following message from {$message->channel}:",
+                     PHP_EOL, "  {$message->payload}", PHP_EOL, PHP_EOL;
+            }
+            break;
+    }
+}
+
+// Always unset the pubsub consumer instance when you are done! The
+// class destructor will take care of cleanups and prevent protocol
+// desynchronizations between the client and the server.
+unset($pubsub);
+
+// Say goodbye :-)
+$version = redis_version($client->info());
+echo "Goodbye from Redis $version!", PHP_EOL;

vendor/predis/predis/examples/redis_collections_iterators.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+require __DIR__.'/shared.php';
+
+use Predis\Collection\Iterator;
+
+// Starting from Redis 2.8, clients can iterate incrementally over collections
+// without blocking the server like it happens when a command such as KEYS is
+// executed on a Redis instance storing millions of keys. These commands are:
+//
+//   - SCAN (iterates over the keyspace)
+//   - SSCAN (iterates over members of a set)
+//   - ZSCAN (iterates over members and ranks of a sorted set)
+//   - HSCAN (iterates over fields and values of an hash).
+
+// Predis provides a specialized abstraction for each command based on standard
+// SPL iterators making it possible to easily consume SCAN-based iterations in
+// your PHP code.
+//
+// See http://redis.io/commands/scan for more details.
+//
+
+// Create a client using `2.8` as a server profile (needs Redis 2.8!)
+$client = new Predis\Client($single_server, array('profile' => '2.8'));
+
+// Prepare some keys for our example
+$client->del('predis:set', 'predis:zset', 'predis:hash');
+for ($i = 0; $i < 5; ++$i) {
+    $client->sadd('predis:set', "member:$i");
+    $client->zadd('predis:zset', -$i, "member:$i");
+    $client->hset('predis:hash', "field:$i", "value:$i");
+}
+
+// === Keyspace iterator based on SCAN ===
+echo 'Scan the keyspace matching only our prefixed keys:', PHP_EOL;
+foreach (new Iterator\Keyspace($client, 'predis:*') as $key) {
+    echo " - $key", PHP_EOL;
+}
+
+/* OUTPUT
+Scan the keyspace matching only our prefixed keys:
+ - predis:zset
+ - predis:set
+ - predis:hash
+*/
+
+// === Set iterator based on SSCAN ===
+echo 'Scan members of `predis:set`:', PHP_EOL;
+foreach (new Iterator\SetKey($client, 'predis:set') as $member) {
+    echo " - $member", PHP_EOL;
+}
+
+/* OUTPUT
+Scan members of `predis:set`:
+ - member:1
+ - member:4
+ - member:0
+ - member:3
+ - member:2
+*/
+
+// === Sorted set iterator based on ZSCAN ===
+echo 'Scan members and ranks of `predis:zset`:', PHP_EOL;
+foreach (new Iterator\SortedSetKey($client, 'predis:zset') as $member => $rank) {
+    echo " - $member [rank: $rank]", PHP_EOL;
+}
+
+/* OUTPUT
+Scan members and ranks of `predis:zset`:
+ - member:4 [rank: -4]
+ - member:3 [rank: -3]
+ - member:2 [rank: -2]
+ - member:1 [rank: -1]
+ - member:0 [rank: 0]
+*/
+
+// === Hash iterator based on HSCAN ===
+echo 'Scan fields and values of `predis:hash`:', PHP_EOL;
+foreach (new Iterator\HashKey($client, 'predis:hash') as $field => $value) {
+    echo " - $field => $value", PHP_EOL;
+}
+
+/* OUTPUT
+Scan fields and values of `predis:hash`:
+ - field:0 => value:0
+ - field:1 => value:1
+ - field:2 => value:2
+ - field:3 => value:3
+ - field:4 => value:4
+*/

vendor/predis/predis/examples/replication_complex.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+require __DIR__.'/shared.php';
+
+// Predis allows to set Lua scripts as read-only operations for replication.
+// This works for both EVAL and EVALSHA and also for the client-side abstraction
+// built upon them (Predis\Command\ScriptCommand). This example shows a slightly
+// more complex configuration that injects a new script command in the server
+// profile used by the new client instance and marks it marks it as a read-only
+// operation for replication so that it will be executed on slaves.
+
+use Predis\Command\ScriptCommand;
+use Predis\Connection\Aggregate\MasterSlaveReplication;
+use Predis\Replication\ReplicationStrategy;
+
+// ------------------------------------------------------------------------- //
+
+// Define a new script command that returns all the fields of a variable number
+// of hashes with a single roundtrip.
+
+class HashMultipleGetAll extends ScriptCommand
+{
+    const BODY = <<<LUA
+local hashes = {}
+for _, key in pairs(KEYS) do
+    table.insert(hashes, key)
+    table.insert(hashes, redis.call('hgetall', key))
+end
+return hashes
+LUA;
+
+    public function getScript()
+    {
+        return self::BODY;
+    }
+}
+
+// ------------------------------------------------------------------------- //
+
+$parameters = array(
+    'tcp://127.0.0.1:6379/?alias=master',
+    'tcp://127.0.0.1:6380/?alias=slave',
+);
+
+$options = array(
+    'profile' => function ($options, $option) {
+        $profile = $options->getDefault($option);
+        $profile->defineCommand('hmgetall', 'HashMultipleGetAll');
+
+        return $profile;
+    },
+    'replication' => function () {
+        $strategy = new ReplicationStrategy();
+        $strategy->setScriptReadOnly(HashMultipleGetAll::BODY);
+
+        $replication = new MasterSlaveReplication($strategy);
+
+        return $replication;
+    },
+);
+
+// ------------------------------------------------------------------------- //
+
+$client = new Predis\Client($parameters, $options);
+
+// Execute the following commands on the master server using redis-cli:
+// $ ./redis-cli HMSET metavars foo bar hoge piyo
+// $ ./redis-cli HMSET servers master host1 slave host2
+
+$hashes = $client->hmgetall('metavars', 'servers');
+
+$replication = $client->getConnection();
+$stillOnSlave = $replication->getCurrent() === $replication->getConnectionById('slave');
+
+echo 'Is still on slave? ', $stillOnSlave ? 'YES!' : 'NO!', PHP_EOL;
+var_export($hashes);

vendor/predis/predis/examples/replication_sentinel.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+require __DIR__.'/shared.php';
+
+// Predis supports redis-sentinel to provide high availability in master / slave
+// scenarios. The only but relevant difference with a basic replication scenario
+// is that sentinel servers can manage the master server and its slaves based on
+// their state, which means that they are able to provide an authoritative and
+// updated configuration to clients thus avoiding static configurations for the
+// replication servers and their roles.
+
+// Instead of connection parameters pointing to redis nodes, we provide a list
+// of instances of redis-sentinel. Users should always provide a timeout value
+// low enough to not hinder operations just in case a sentinel is unreachable
+// but Predis uses a default value of 100 milliseconds for sentinel parameters
+// without an explicit timeout value.
+//
+// NOTE: in real-world scenarios sentinels should be running on different hosts!
+$sentinels = array(
+    'tcp://127.0.0.1:5380?timeout=0.100',
+    'tcp://127.0.0.1:5381?timeout=0.100',
+    'tcp://127.0.0.1:5382?timeout=0.100',
+);
+
+$client = new Predis\Client($sentinels, array(
+    'replication' => 'sentinel',
+    'service' => 'mymaster',
+));
+
+// Read operation.
+$exists = $client->exists('foo') ? 'yes' : 'no';
+$current = $client->getConnection()->getCurrent()->getParameters();
+echo "Does 'foo' exist on {$current->alias}? $exists.", PHP_EOL;
+
+// Write operation.
+$client->set('foo', 'bar');
+$current = $client->getConnection()->getCurrent()->getParameters();
+echo "Now 'foo' has been set to 'bar' on {$current->alias}!", PHP_EOL;
+
+// Read operation.
+$bar = $client->get('foo');
+$current = $client->getConnection()->getCurrent()->getParameters();
+echo "We fetched 'foo' from {$current->alias} and its value is '$bar'.", PHP_EOL;
+
+/* OUTPUT:
+Does 'foo' exist on slave-127.0.0.1:6381? yes.
+Now 'foo' has been set to 'bar' on master!
+We fetched 'foo' from master and its value is 'bar'.
+*/

vendor/predis/predis/examples/replication_simple.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+require __DIR__.'/shared.php';
+
+// Predis supports master / slave replication scenarios where write operations
+// are performed on the master server and read operations are executed against
+// one of the slaves. The behavior of commands or EVAL scripts can be customized
+// at will. As soon as a write operation is performed the client switches to the
+// master server for all the subsequent requests (either reads and writes).
+//
+// This example must be executed using the second Redis server configured as the
+// slave of the first one (see the "SLAVEOF" command).
+//
+
+$parameters = array(
+    'tcp://127.0.0.1:6379?database=15&alias=master',
+    'tcp://127.0.0.1:6380?database=15&alias=slave',
+);
+
+$options = array('replication' => true);
+
+$client = new Predis\Client($parameters, $options);
+
+// Read operation.
+$exists = $client->exists('foo') ? 'yes' : 'no';
+$current = $client->getConnection()->getCurrent()->getParameters();
+echo "Does 'foo' exist on {$current->alias}? $exists.", PHP_EOL;
+
+// Write operation.
+$client->set('foo', 'bar');
+$current = $client->getConnection()->getCurrent()->getParameters();
+echo "Now 'foo' has been set to 'bar' on {$current->alias}!", PHP_EOL;
+
+// Read operation.
+$bar = $client->get('foo');
+$current = $client->getConnection()->getCurrent()->getParameters();
+echo "We fetched 'foo' from {$current->alias} and its value is '$bar'.", PHP_EOL;
+
+/* OUTPUT:
+Does 'foo' exist on slave? yes.
+Now 'foo' has been set to 'bar' on master!
+We fetched 'foo' from master and its value is 'bar'.
+*/

vendor/predis/predis/examples/session_handler.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+require __DIR__.'/shared.php';
+
+// This example demonstrates how to use Predis to save PHP sessions on Redis.
+//
+// The value of `session.gc_maxlifetime` in `php.ini` will be used by default as
+// the TTL for keys holding session data but this value can be overridden when
+// creating the session handler instance using the `gc_maxlifetime` option.
+//
+// NOTE: this class requires PHP >= 5.4 but can be used on PHP 5.3 if a polyfill
+// for SessionHandlerInterface is provided either by you or an external package
+// like `symfony/http-foundation`.
+//
+// See http://www.php.net/class.sessionhandlerinterface.php for more details.
+//
+
+if (!interface_exists('SessionHandlerInterface')) {
+    die('ATTENTION: the session handler implemented by Predis requires PHP >= 5.4.0 '.
+        "or a polyfill for SessionHandlerInterface provided by an external package.\n");
+}
+
+// Instantiate a new client just like you would normally do. Using a prefix for
+// keys will effectively prefix all session keys with the specified string.
+$client = new Predis\Client($single_server, array('prefix' => 'sessions:'));
+
+// Set `gc_maxlifetime` to specify a time-to-live of 5 seconds for session keys.
+$handler = new Predis\Session\Handler($client, array('gc_maxlifetime' => 5));
+
+// Register the session handler.
+$handler->register();
+
+// We just set a fixed session ID only for the sake of our example.
+session_id('example_session_id');
+
+session_start();
+
+if (isset($_SESSION['foo'])) {
+    echo "Session has `foo` set to {$_SESSION['foo']}", PHP_EOL;
+} else {
+    $_SESSION['foo'] = $value = mt_rand();
+    echo "Empty session, `foo` has been set with $value", PHP_EOL;
+}

vendor/predis/predis/examples/shared.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+require __DIR__.'/../autoload.php';
+
+function redis_version($info)
+{
+    if (isset($info['Server']['redis_version'])) {
+        return $info['Server']['redis_version'];
+    } elseif (isset($info['redis_version'])) {
+        return $info['redis_version'];
+    } else {
+        return 'unknown version';
+    }
+}
+
+$single_server = array(
+    'host' => '127.0.0.1',
+    'port' => 6379,
+    'database' => 15,
+);
+
+$multiple_servers = array(
+    array(
+       'host' => '127.0.0.1',
+       'port' => 6379,
+       'database' => 15,
+       'alias' => 'first',
+    ),
+    array(
+       'host' => '127.0.0.1',
+       'port' => 6380,
+       'database' => 15,
+       'alias' => 'second',
+    ),
+);

vendor/predis/predis/examples/transaction_using_cas.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+require __DIR__.'/shared.php';
+
+// This is an implementation of an atomic client-side ZPOP using the support for
+// check-and-set (CAS) operations with MULTI/EXEC transactions, as described in
+// "WATCH explained" from http://redis.io/topics/transactions
+//
+// First, populate your database with a tiny sample data set:
+//
+// ./redis-cli
+// SELECT 15
+// ZADD zset 1 a 2 b 3 c
+//
+// Then execute this script four times and see its output.
+//
+
+function zpop($client, $key)
+{
+    $element = null;
+    $options = array(
+        'cas' => true,      // Initialize with support for CAS operations
+        'watch' => $key,    // Key that needs to be WATCHed to detect changes
+        'retry' => 3,       // Number of retries on aborted transactions, after
+                            // which the client bails out with an exception.
+    );
+
+    $client->transaction($options, function ($tx) use ($key, &$element) {
+        @list($element) = $tx->zrange($key, 0, 0);
+
+        if (isset($element)) {
+            $tx->multi();   // With CAS, MULTI *must* be explicitly invoked.
+            $tx->zrem($key, $element);
+        }
+    });
+
+    return $element;
+}
+
+$client = new Predis\Client($single_server);
+$zpopped = zpop($client, 'zset');
+
+echo isset($zpopped) ? "ZPOPed $zpopped" : 'Nothing to ZPOP!', PHP_EOL;

vendor/predis/predis/package.ini

+; This file is meant to be used with Onion http://c9s.github.com/Onion/
+; For instructions on how to build a PEAR package of Predis please follow
+; the instructions at this URL:
+;
+; https://github.com/c9s/Onion#a-quick-tutorial-for-building-pear-package
+;
+
+[package]
+name        = "Predis"
+desc        = "Flexible and feature-complete Redis client for PHP and HHVM"
+homepage    = "http://github.com/nrk/predis"
+license     = "MIT"
+version     = "1.1.1"
+stability   = "stable"
+channel     = "pear.nrk.io"
+
+author      = "Daniele Alessandri \"nrk\" <suppakilla@gmail.com>"
+
+[require]
+php = ">= 5.3.9"
+pearinstaller = "1.4.1"
+
+[roles]
+*.xml.dist = test
+*.md = doc
+LICENSE = doc
+
+[optional phpiredis]
+hint = "Add support for faster protocol handling with phpiredis"
+extensions[] = socket
+extensions[] = phpiredis
+
+[optional webdis]
+hint = "Add support for Webdis"
+extensions[] = curl
+extensions[] = phpiredis

vendor/predis/predis/src/Autoloader.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis;
+
+/**
+ * Implements a lightweight PSR-0 compliant autoloader for Predis.
+ *
+ * @author Eric Naeseth <eric@thumbtack.com>
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class Autoloader
+{
+    private $directory;
+    private $prefix;
+    private $prefixLength;
+
+    /**
+     * @param string $baseDirectory Base directory where the source files are located.
+     */
+    public function __construct($baseDirectory = __DIR__)
+    {
+        $this->directory = $baseDirectory;
+        $this->prefix = __NAMESPACE__.'\\';
+        $this->prefixLength = strlen($this->prefix);
+    }
+
+    /**
+     * Registers the autoloader class with the PHP SPL autoloader.
+     *
+     * @param bool $prepend Prepend the autoloader on the stack instead of appending it.
+     */
+    public static function register($prepend = false)
+    {
+        spl_autoload_register(array(new self(), 'autoload'), true, $prepend);
+    }
+
+    /**
+     * Loads a class from a file using its fully qualified name.
+     *
+     * @param string $className Fully qualified name of a class.
+     */
+    public function autoload($className)
+    {
+        if (0 === strpos($className, $this->prefix)) {
+            $parts = explode('\\', substr($className, $this->prefixLength));
+            $filepath = $this->directory.DIRECTORY_SEPARATOR.implode(DIRECTORY_SEPARATOR, $parts).'.php';
+
+            if (is_file($filepath)) {
+                require $filepath;
+            }
+        }
+    }
+}

vendor/predis/predis/src/ClientContextInterface.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis;
+
+use Predis\Command\CommandInterface;
+
+/**
+ * Interface defining a client-side context such as a pipeline or transaction.
+ *
+ * @method $this del(array $keys)
+ * @method $this dump($key)
+ * @method $this exists($key)
+ * @method $this expire($key, $seconds)
+ * @method $this expireat($key, $timestamp)
+ * @method $this keys($pattern)
+ * @method $this move($key, $db)
+ * @method $this object($subcommand, $key)
+ * @method $this persist($key)
+ * @method $this pexpire($key, $milliseconds)
+ * @method $this pexpireat($key, $timestamp)
+ * @method $this pttl($key)
+ * @method $this randomkey()
+ * @method $this rename($key, $target)
+ * @method $this renamenx($key, $target)
+ * @method $this scan($cursor, array $options = null)
+ * @method $this sort($key, array $options = null)
+ * @method $this ttl($key)
+ * @method $this type($key)
+ * @method $this append($key, $value)
+ * @method $this bitcount($key, $start = null, $end = null)
+ * @method $this bitop($operation, $destkey, $key)
+ * @method $this bitfield($key, $subcommand, ...$subcommandArg)
+ * @method $this decr($key)
+ * @method $this decrby($key, $decrement)
+ * @method $this get($key)
+ * @method $this getbit($key, $offset)
+ * @method $this getrange($key, $start, $end)
+ * @method $this getset($key, $value)
+ * @method $this incr($key)
+ * @method $this incrby($key, $increment)
+ * @method $this incrbyfloat($key, $increment)
+ * @method $this mget(array $keys)
+ * @method $this mset(array $dictionary)
+ * @method $this msetnx(array $dictionary)
+ * @method $this psetex($key, $milliseconds, $value)
+ * @method $this set($key, $value, $expireResolution = null, $expireTTL = null, $flag = null)
+ * @method $this setbit($key, $offset, $value)
+ * @method $this setex($key, $seconds, $value)
+ * @method $this setnx($key, $value)
+ * @method $this setrange($key, $offset, $value)
+ * @method $this strlen($key)
+ * @method $this hdel($key, array $fields)
+ * @method $this hexists($key, $field)
+ * @method $this hget($key, $field)
+ * @method $this hgetall($key)
+ * @method $this hincrby($key, $field, $increment)
+ * @method $this hincrbyfloat($key, $field, $increment)
+ * @method $this hkeys($key)
+ * @method $this hlen($key)
+ * @method $this hmget($key, array $fields)
+ * @method $this hmset($key, array $dictionary)
+ * @method $this hscan($key, $cursor, array $options = null)
+ * @method $this hset($key, $field, $value)
+ * @method $this hsetnx($key, $field, $value)
+ * @method $this hvals($key)
+ * @method $this hstrlen($key, $field)
+ * @method $this blpop(array $keys, $timeout)
+ * @method $this brpop(array $keys, $timeout)
+ * @method $this brpoplpush($source, $destination, $timeout)
+ * @method $this lindex($key, $index)
+ * @method $this linsert($key, $whence, $pivot, $value)
+ * @method $this llen($key)
+ * @method $this lpop($key)
+ * @method $this lpush($key, array $values)
+ * @method $this lpushx($key, $value)
+ * @method $this lrange($key, $start, $stop)
+ * @method $this lrem($key, $count, $value)
+ * @method $this lset($key, $index, $value)
+ * @method $this ltrim($key, $start, $stop)
+ * @method $this rpop($key)
+ * @method $this rpoplpush($source, $destination)
+ * @method $this rpush($key, array $values)
+ * @method $this rpushx($key, $value)
+ * @method $this sadd($key, array $members)
+ * @method $this scard($key)
+ * @method $this sdiff(array $keys)
+ * @method $this sdiffstore($destination, array $keys)
+ * @method $this sinter(array $keys)
+ * @method $this sinterstore($destination, array $keys)
+ * @method $this sismember($key, $member)
+ * @method $this smembers($key)
+ * @method $this smove($source, $destination, $member)
+ * @method $this spop($key, $count = null)
+ * @method $this srandmember($key, $count = null)
+ * @method $this srem($key, $member)
+ * @method $this sscan($key, $cursor, array $options = null)
+ * @method $this sunion(array $keys)
+ * @method $this sunionstore($destination, array $keys)
+ * @method $this zadd($key, array $membersAndScoresDictionary)
+ * @method $this zcard($key)
+ * @method $this zcount($key, $min, $max)
+ * @method $this zincrby($key, $increment, $member)
+ * @method $this zinterstore($destination, array $keys, array $options = null)
+ * @method $this zrange($key, $start, $stop, array $options = null)
+ * @method $this zrangebyscore($key, $min, $max, array $options = null)
+ * @method $this zrank($key, $member)
+ * @method $this zrem($key, $member)
+ * @method $this zremrangebyrank($key, $start, $stop)
+ * @method $this zremrangebyscore($key, $min, $max)
+ * @method $this zrevrange($key, $start, $stop, array $options = null)
+ * @method $this zrevrangebyscore($key, $min, $max, array $options = null)
+ * @method $this zrevrank($key, $member)
+ * @method $this zunionstore($destination, array $keys, array $options = null)
+ * @method $this zscore($key, $member)
+ * @method $this zscan($key, $cursor, array $options = null)
+ * @method $this zrangebylex($key, $start, $stop, array $options = null)
+ * @method $this zrevrangebylex($key, $start, $stop, array $options = null)
+ * @method $this zremrangebylex($key, $min, $max)
+ * @method $this zlexcount($key, $min, $max)
+ * @method $this pfadd($key, array $elements)
+ * @method $this pfmerge($destinationKey, array $sourceKeys)
+ * @method $this pfcount(array $keys)
+ * @method $this pubsub($subcommand, $argument)
+ * @method $this publish($channel, $message)
+ * @method $this discard()
+ * @method $this exec()
+ * @method $this multi()
+ * @method $this unwatch()
+ * @method $this watch($key)
+ * @method $this eval($script, $numkeys, $keyOrArg1 = null, $keyOrArgN = null)
+ * @method $this evalsha($script, $numkeys, $keyOrArg1 = null, $keyOrArgN = null)
+ * @method $this script($subcommand, $argument = null)
+ * @method $this auth($password)
+ * @method $this echo($message)
+ * @method $this ping($message = null)
+ * @method $this select($database)
+ * @method $this bgrewriteaof()
+ * @method $this bgsave()
+ * @method $this client($subcommand, $argument = null)
+ * @method $this config($subcommand, $argument = null)
+ * @method $this dbsize()
+ * @method $this flushall()
+ * @method $this flushdb()
+ * @method $this info($section = null)
+ * @method $this lastsave()
+ * @method $this save()
+ * @method $this slaveof($host, $port)
+ * @method $this slowlog($subcommand, $argument = null)
+ * @method $this time()
+ * @method $this command()
+ * @method $this geoadd($key, $longitude, $latitude, $member)
+ * @method $this geohash($key, array $members)
+ * @method $this geopos($key, array $members)
+ * @method $this geodist($key, $member1, $member2, $unit = null)
+ * @method $this georadius($key, $longitude, $latitude, $radius, $unit, array $options = null)
+ * @method $this georadiusbymember($key, $member, $radius, $unit, array $options = null)
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+interface ClientContextInterface
+{
+    /**
+     * Sends the specified command instance to Redis.
+     *
+     * @param CommandInterface $command Command instance.
+     *
+     * @return mixed
+     */
+    public function executeCommand(CommandInterface $command);
+
+    /**
+     * Sends the specified command with its arguments to Redis.
+     *
+     * @param string $method    Command ID.
+     * @param array  $arguments Arguments for the command.
+     *
+     * @return mixed
+     */
+    public function __call($method, $arguments);
+
+    /**
+     * Starts the execution of the context.
+     *
+     * @param mixed $callable Optional callback for execution.
+     *
+     * @return array
+     */
+    public function execute($callable = null);
+}

vendor/predis/predis/src/ClientException.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis;
+
+/**
+ * Exception class that identifies client-side errors.
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class ClientException extends PredisException
+{
+}

vendor/predis/predis/src/ClientInterface.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis;
+
+use Predis\Command\CommandInterface;
+use Predis\Configuration\OptionsInterface;
+use Predis\Connection\ConnectionInterface;
+use Predis\Profile\ProfileInterface;
+
+/**
+ * Interface defining a client able to execute commands against Redis.
+ *
+ * All the commands exposed by the client generally have the same signature as
+ * described by the Redis documentation, but some of them offer an additional
+ * and more friendly interface to ease programming which is described in the
+ * following list of methods:
+ *
+ * @method int    del(array $keys)
+ * @method string dump($key)
+ * @method int    exists($key)
+ * @method int    expire($key, $seconds)
+ * @method int    expireat($key, $timestamp)
+ * @method array  keys($pattern)
+ * @method int    move($key, $db)
+ * @method mixed  object($subcommand, $key)
+ * @method int    persist($key)
+ * @method int    pexpire($key, $milliseconds)
+ * @method int    pexpireat($key, $timestamp)
+ * @method int    pttl($key)
+ * @method string randomkey()
+ * @method mixed  rename($key, $target)
+ * @method int    renamenx($key, $target)
+ * @method array  scan($cursor, array $options = null)
+ * @method array  sort($key, array $options = null)
+ * @method int    ttl($key)
+ * @method mixed  type($key)
+ * @method int    append($key, $value)
+ * @method int    bitcount($key, $start = null, $end = null)
+ * @method int    bitop($operation, $destkey, $key)
+ * @method array  bitfield($key, $subcommand, ...$subcommandArg)
+ * @method int    decr($key)
+ * @method int    decrby($key, $decrement)
+ * @method string get($key)
+ * @method int    getbit($key, $offset)
+ * @method string getrange($key, $start, $end)
+ * @method string getset($key, $value)
+ * @method int    incr($key)
+ * @method int    incrby($key, $increment)
+ * @method string incrbyfloat($key, $increment)
+ * @method array  mget(array $keys)
+ * @method mixed  mset(array $dictionary)
+ * @method int    msetnx(array $dictionary)
+ * @method mixed  psetex($key, $milliseconds, $value)
+ * @method mixed  set($key, $value, $expireResolution = null, $expireTTL = null, $flag = null)
+ * @method int    setbit($key, $offset, $value)
+ * @method int    setex($key, $seconds, $value)
+ * @method int    setnx($key, $value)
+ * @method int    setrange($key, $offset, $value)
+ * @method int    strlen($key)
+ * @method int    hdel($key, array $fields)
+ * @method int    hexists($key, $field)
+ * @method string hget($key, $field)
+ * @method array  hgetall($key)
+ * @method int    hincrby($key, $field, $increment)
+ * @method string hincrbyfloat($key, $field, $increment)
+ * @method array  hkeys($key)
+ * @method int    hlen($key)
+ * @method array  hmget($key, array $fields)
+ * @method mixed  hmset($key, array $dictionary)
+ * @method array  hscan($key, $cursor, array $options = null)
+ * @method int    hset($key, $field, $value)
+ * @method int    hsetnx($key, $field, $value)
+ * @method array  hvals($key)
+ * @method int    hstrlen($key, $field)
+ * @method array  blpop(array $keys, $timeout)
+ * @method array  brpop(array $keys, $timeout)
+ * @method array  brpoplpush($source, $destination, $timeout)
+ * @method string lindex($key, $index)
+ * @method int    linsert($key, $whence, $pivot, $value)
+ * @method int    llen($key)
+ * @method string lpop($key)
+ * @method int    lpush($key, array $values)
+ * @method int    lpushx($key, $value)
+ * @method array  lrange($key, $start, $stop)
+ * @method int    lrem($key, $count, $value)
+ * @method mixed  lset($key, $index, $value)
+ * @method mixed  ltrim($key, $start, $stop)
+ * @method string rpop($key)
+ * @method string rpoplpush($source, $destination)
+ * @method int    rpush($key, array $values)
+ * @method int    rpushx($key, $value)
+ * @method int    sadd($key, array $members)
+ * @method int    scard($key)
+ * @method array  sdiff(array $keys)
+ * @method int    sdiffstore($destination, array $keys)
+ * @method array  sinter(array $keys)
+ * @method int    sinterstore($destination, array $keys)
+ * @method int    sismember($key, $member)
+ * @method array  smembers($key)
+ * @method int    smove($source, $destination, $member)
+ * @method string spop($key, $count = null)
+ * @method string srandmember($key, $count = null)
+ * @method int    srem($key, $member)
+ * @method array  sscan($key, $cursor, array $options = null)
+ * @method array  sunion(array $keys)
+ * @method int    sunionstore($destination, array $keys)
+ * @method int    zadd($key, array $membersAndScoresDictionary)
+ * @method int    zcard($key)
+ * @method string zcount($key, $min, $max)
+ * @method string zincrby($key, $increment, $member)
+ * @method int    zinterstore($destination, array $keys, array $options = null)
+ * @method array  zrange($key, $start, $stop, array $options = null)
+ * @method array  zrangebyscore($key, $min, $max, array $options = null)
+ * @method int    zrank($key, $member)
+ * @method int    zrem($key, $member)
+ * @method int    zremrangebyrank($key, $start, $stop)
+ * @method int    zremrangebyscore($key, $min, $max)
+ * @method array  zrevrange($key, $start, $stop, array $options = null)
+ * @method array  zrevrangebyscore($key, $max, $min, array $options = null)
+ * @method int    zrevrank($key, $member)
+ * @method int    zunionstore($destination, array $keys, array $options = null)
+ * @method string zscore($key, $member)
+ * @method array  zscan($key, $cursor, array $options = null)
+ * @method array  zrangebylex($key, $start, $stop, array $options = null)
+ * @method array  zrevrangebylex($key, $start, $stop, array $options = null)
+ * @method int    zremrangebylex($key, $min, $max)
+ * @method int    zlexcount($key, $min, $max)
+ * @method int    pfadd($key, array $elements)
+ * @method mixed  pfmerge($destinationKey, array $sourceKeys)
+ * @method int    pfcount(array $keys)
+ * @method mixed  pubsub($subcommand, $argument)
+ * @method int    publish($channel, $message)
+ * @method mixed  discard()
+ * @method array  exec()
+ * @method mixed  multi()
+ * @method mixed  unwatch()
+ * @method mixed  watch($key)
+ * @method mixed  eval($script, $numkeys, $keyOrArg1 = null, $keyOrArgN = null)
+ * @method mixed  evalsha($script, $numkeys, $keyOrArg1 = null, $keyOrArgN = null)
+ * @method mixed  script($subcommand, $argument = null)
+ * @method mixed  auth($password)
+ * @method string echo($message)
+ * @method mixed  ping($message = null)
+ * @method mixed  select($database)
+ * @method mixed  bgrewriteaof()
+ * @method mixed  bgsave()
+ * @method mixed  client($subcommand, $argument = null)
+ * @method mixed  config($subcommand, $argument = null)
+ * @method int    dbsize()
+ * @method mixed  flushall()
+ * @method mixed  flushdb()
+ * @method array  info($section = null)
+ * @method int    lastsave()
+ * @method mixed  save()
+ * @method mixed  slaveof($host, $port)
+ * @method mixed  slowlog($subcommand, $argument = null)
+ * @method array  time()
+ * @method array  command()
+ * @method int    geoadd($key, $longitude, $latitude, $member)
+ * @method array  geohash($key, array $members)
+ * @method array  geopos($key, array $members)
+ * @method string geodist($key, $member1, $member2, $unit = null)
+ * @method array  georadius($key, $longitude, $latitude, $radius, $unit, array $options = null)
+ * @method array  georadiusbymember($key, $member, $radius, $unit, array $options = null)
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+interface ClientInterface
+{
+    /**
+     * Returns the server profile used by the client.
+     *
+     * @return ProfileInterface
+     */
+    public function getProfile();
+
+    /**
+     * Returns the client options specified upon initialization.
+     *
+     * @return OptionsInterface
+     */
+    public function getOptions();
+
+    /**
+     * Opens the underlying connection to the server.
+     */
+    public function connect();
+
+    /**
+     * Closes the underlying connection from the server.
+     */
+    public function disconnect();
+
+    /**
+     * Returns the underlying connection instance.
+     *
+     * @return ConnectionInterface
+     */
+    public function getConnection();
+
+    /**
+     * Creates a new instance of the specified Redis command.
+     *
+     * @param string $method    Command ID.
+     * @param array  $arguments Arguments for the command.
+     *
+     * @return CommandInterface
+     */
+    public function createCommand($method, $arguments = array());
+
+    /**
+     * Executes the specified Redis command.
+     *
+     * @param CommandInterface $command Command instance.
+     *
+     * @return mixed
+     */
+    public function executeCommand(CommandInterface $command);
+
+    /**
+     * Creates a Redis command with the specified arguments and sends a request
+     * to the server.
+     *
+     * @param string $method    Command ID.
+     * @param array  $arguments Arguments for the command.
+     *
+     * @return mixed
+     */
+    public function __call($method, $arguments);
+}

vendor/predis/predis/src/Cluster/Distributor/DistributorInterface.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis\Cluster\Distributor;
+
+use Predis\Cluster\Hash\HashGeneratorInterface;
+
+/**
+ * A distributor implements the logic to automatically distribute keys among
+ * several nodes for client-side sharding.
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+interface DistributorInterface
+{
+    /**
+     * Adds a node to the distributor with an optional weight.
+     *
+     * @param mixed $node   Node object.
+     * @param int   $weight Weight for the node.
+     */
+    public function add($node, $weight = null);
+
+    /**
+     * Removes a node from the distributor.
+     *
+     * @param mixed $node Node object.
+     */
+    public function remove($node);
+
+    /**
+     * Returns the corresponding slot of a node from the distributor using the
+     * computed hash of a key.
+     *
+     * @param mixed $hash
+     *
+     * @return mixed
+     */
+    public function getSlot($hash);
+
+    /**
+     * Returns a node from the distributor using its assigned slot ID.
+     *
+     * @param mixed $slot
+     *
+     * @return mixed|null
+     */
+    public function getBySlot($slot);
+
+    /**
+     * Returns a node from the distributor using the computed hash of a key.
+     *
+     * @param mixed $hash
+     *
+     * @return mixed
+     */
+    public function getByHash($hash);
+
+    /**
+     * Returns a node from the distributor mapping to the specified value.
+     *
+     * @param string $value
+     *
+     * @return mixed
+     */
+    public function get($value);
+
+    /**
+     * Returns the underlying hash generator instance.
+     *
+     * @return HashGeneratorInterface
+     */
+    public function getHashGenerator();
+}

vendor/predis/predis/src/Cluster/Distributor/EmptyRingException.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis\Cluster\Distributor;
+
+/**
+ * Exception class that identifies empty rings.
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class EmptyRingException extends \Exception
+{
+}

vendor/predis/predis/src/Cluster/Distributor/HashRing.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis\Cluster\Distributor;
+
+use Predis\Cluster\Hash\HashGeneratorInterface;
+
+/**
+ * This class implements an hashring-based distributor that uses the same
+ * algorithm of memcache to distribute keys in a cluster using client-side
+ * sharding.
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ * @author Lorenzo Castelli <lcastelli@gmail.com>
+ */
+class HashRing implements DistributorInterface, HashGeneratorInterface
+{
+    const DEFAULT_REPLICAS = 128;
+    const DEFAULT_WEIGHT = 100;
+
+    private $ring;
+    private $ringKeys;
+    private $ringKeysCount;
+    private $replicas;
+    private $nodeHashCallback;
+    private $nodes = array();
+
+    /**
+     * @param int   $replicas         Number of replicas in the ring.
+     * @param mixed $nodeHashCallback Callback returning a string used to calculate the hash of nodes.
+     */
+    public function __construct($replicas = self::DEFAULT_REPLICAS, $nodeHashCallback = null)
+    {
+        $this->replicas = $replicas;
+        $this->nodeHashCallback = $nodeHashCallback;
+    }
+
+    /**
+     * Adds a node to the ring with an optional weight.
+     *
+     * @param mixed $node   Node object.
+     * @param int   $weight Weight for the node.
+     */
+    public function add($node, $weight = null)
+    {
+        // In case of collisions in the hashes of the nodes, the node added
+        // last wins, thus the order in which nodes are added is significant.
+        $this->nodes[] = array(
+            'object' => $node,
+            'weight' => (int) $weight ?: $this::DEFAULT_WEIGHT,
+        );
+
+        $this->reset();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function remove($node)
+    {
+        // A node is removed by resetting the ring so that it's recreated from
+        // scratch, in order to reassign possible hashes with collisions to the
+        // right node according to the order in which they were added in the
+        // first place.
+        for ($i = 0; $i < count($this->nodes); ++$i) {
+            if ($this->nodes[$i]['object'] === $node) {
+                array_splice($this->nodes, $i, 1);
+                $this->reset();
+
+                break;
+            }
+        }
+    }
+
+    /**
+     * Resets the distributor.
+     */
+    private function reset()
+    {
+        unset(
+            $this->ring,
+            $this->ringKeys,
+            $this->ringKeysCount
+        );
+    }
+
+    /**
+     * Returns the initialization status of the distributor.
+     *
+     * @return bool
+     */
+    private function isInitialized()
+    {
+        return isset($this->ringKeys);
+    }
+
+    /**
+     * Calculates the total weight of all the nodes in the distributor.
+     *
+     * @return int
+     */
+    private function computeTotalWeight()
+    {
+        $totalWeight = 0;
+
+        foreach ($this->nodes as $node) {
+            $totalWeight += $node['weight'];
+        }
+
+        return $totalWeight;
+    }
+
+    /**
+     * Initializes the distributor.
+     */
+    private function initialize()
+    {
+        if ($this->isInitialized()) {
+            return;
+        }
+
+        if (!$this->nodes) {
+            throw new EmptyRingException('Cannot initialize an empty hashring.');
+        }
+
+        $this->ring = array();
+        $totalWeight = $this->computeTotalWeight();
+        $nodesCount = count($this->nodes);
+
+        foreach ($this->nodes as $node) {
+            $weightRatio = $node['weight'] / $totalWeight;
+            $this->addNodeToRing($this->ring, $node, $nodesCount, $this->replicas, $weightRatio);
+        }
+
+        ksort($this->ring, SORT_NUMERIC);
+        $this->ringKeys = array_keys($this->ring);
+        $this->ringKeysCount = count($this->ringKeys);
+    }
+
+    /**
+     * Implements the logic needed to add a node to the hashring.
+     *
+     * @param array $ring        Source hashring.
+     * @param mixed $node        Node object to be added.
+     * @param int   $totalNodes  Total number of nodes.
+     * @param int   $replicas    Number of replicas in the ring.
+     * @param float $weightRatio Weight ratio for the node.
+     */
+    protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio)
+    {
+        $nodeObject = $node['object'];
+        $nodeHash = $this->getNodeHash($nodeObject);
+        $replicas = (int) round($weightRatio * $totalNodes * $replicas);
+
+        for ($i = 0; $i < $replicas; ++$i) {
+            $key = crc32("$nodeHash:$i");
+            $ring[$key] = $nodeObject;
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function getNodeHash($nodeObject)
+    {
+        if (!isset($this->nodeHashCallback)) {
+            return (string) $nodeObject;
+        }
+
+        return call_user_func($this->nodeHashCallback, $nodeObject);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function hash($value)
+    {
+        return crc32($value);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getByHash($hash)
+    {
+        return $this->ring[$this->getSlot($hash)];
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getBySlot($slot)
+    {
+        $this->initialize();
+
+        if (isset($this->ring[$slot])) {
+            return $this->ring[$slot];
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getSlot($hash)
+    {
+        $this->initialize();
+
+        $ringKeys = $this->ringKeys;
+        $upper = $this->ringKeysCount - 1;
+        $lower = 0;
+
+        while ($lower <= $upper) {
+            $index = ($lower + $upper) >> 1;
+            $item = $ringKeys[$index];
+
+            if ($item > $hash) {
+                $upper = $index - 1;
+            } elseif ($item < $hash) {
+                $lower = $index + 1;
+            } else {
+                return $item;
+            }
+        }
+
+        return $ringKeys[$this->wrapAroundStrategy($upper, $lower, $this->ringKeysCount)];
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function get($value)
+    {
+        $hash = $this->hash($value);
+        $node = $this->getByHash($hash);
+
+        return $node;
+    }
+
+    /**
+     * Implements a strategy to deal with wrap-around errors during binary searches.
+     *
+     * @param int $upper
+     * @param int $lower
+     * @param int $ringKeysCount
+     *
+     * @return int
+     */
+    protected function wrapAroundStrategy($upper, $lower, $ringKeysCount)
+    {
+        // Binary search for the last item in ringkeys with a value less or
+        // equal to the key. If no such item exists, return the last item.
+        return $upper >= 0 ? $upper : $ringKeysCount - 1;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getHashGenerator()
+    {
+        return $this;
+    }
+}

vendor/predis/predis/src/Cluster/Distributor/KetamaRing.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis\Cluster\Distributor;
+
+/**
+ * This class implements an hashring-based distributor that uses the same
+ * algorithm of libketama to distribute keys in a cluster using client-side
+ * sharding.
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ * @author Lorenzo Castelli <lcastelli@gmail.com>
+ */
+class KetamaRing extends HashRing
+{
+    const DEFAULT_REPLICAS = 160;
+
+    /**
+     * @param mixed $nodeHashCallback Callback returning a string used to calculate the hash of nodes.
+     */
+    public function __construct($nodeHashCallback = null)
+    {
+        parent::__construct($this::DEFAULT_REPLICAS, $nodeHashCallback);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio)
+    {
+        $nodeObject = $node['object'];
+        $nodeHash = $this->getNodeHash($nodeObject);
+        $replicas = (int) floor($weightRatio * $totalNodes * ($replicas / 4));
+
+        for ($i = 0; $i < $replicas; ++$i) {
+            $unpackedDigest = unpack('V4', md5("$nodeHash-$i", true));
+
+            foreach ($unpackedDigest as $key) {
+                $ring[$key] = $nodeObject;
+            }
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function hash($value)
+    {
+        $hash = unpack('V', md5($value, true));
+
+        return $hash[1];
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function wrapAroundStrategy($upper, $lower, $ringKeysCount)
+    {
+        // Binary search for the first item in ringkeys with a value greater
+        // or equal to the key. If no such item exists, return the first item.
+        return $lower < $ringKeysCount ? $lower : 0;
+    }
+}

vendor/predis/predis/src/Cluster/Hash/CRC16.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis\Cluster\Hash;
+
+/**
+ * Hash generator implementing the CRC-CCITT-16 algorithm used by redis-cluster.
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class CRC16 implements HashGeneratorInterface
+{
+    private static $CCITT_16 = array(
+        0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
+        0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
+        0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
+        0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
+        0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
+        0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
+        0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
+        0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
+        0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
+        0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
+        0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
+        0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
+        0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
+        0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
+        0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
+        0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
+        0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
+        0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
+        0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
+        0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
+        0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
+        0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
+        0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
+        0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
+        0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
+        0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
+        0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
+        0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
+        0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
+        0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
+        0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
+        0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0,
+    );
+
+    /**
+     * {@inheritdoc}
+     */
+    public function hash($value)
+    {
+        // CRC-CCITT-16 algorithm
+        $crc = 0;
+        $CCITT_16 = self::$CCITT_16;
+        $strlen = strlen($value);
+
+        for ($i = 0; $i < $strlen; ++$i) {
+            $crc = (($crc << 8) ^ $CCITT_16[($crc >> 8) ^ ord($value[$i])]) & 0xFFFF;
+        }
+
+        return $crc;
+    }
+}

vendor/predis/predis/src/Cluster/Hash/HashGeneratorInterface.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis\Cluster\Hash;
+
+/**
+ * An hash generator implements the logic used to calculate the hash of a key to
+ * distribute operations among Redis nodes.
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+interface HashGeneratorInterface
+{
+    /**
+     * Generates an hash from a string to be used for distribution.
+     *
+     * @param string $value String value.
+     *
+     * @return int
+     */
+    public function hash($value);
+}

vendor/predis/predis/src/Cluster/PredisStrategy.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis\Cluster;
+
+use Predis\Cluster\Distributor\DistributorInterface;
+use Predis\Cluster\Distributor\HashRing;
+
+/**
+ * Default cluster strategy used by Predis to handle client-side sharding.
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class PredisStrategy extends ClusterStrategy
+{
+    protected $distributor;
+
+    /**
+     * @param DistributorInterface $distributor Optional distributor instance.
+     */
+    public function __construct(DistributorInterface $distributor = null)
+    {
+        parent::__construct();
+
+        $this->distributor = $distributor ?: new HashRing();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getSlotByKey($key)
+    {
+        $key = $this->extractKeyTag($key);
+        $hash = $this->distributor->hash($key);
+        $slot = $this->distributor->getSlot($hash);
+
+        return $slot;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function checkSameSlotForKeys(array $keys)
+    {
+        if (!$count = count($keys)) {
+            return false;
+        }
+
+        $currentKey = $this->extractKeyTag($keys[0]);
+
+        for ($i = 1; $i < $count; ++$i) {
+            $nextKey = $this->extractKeyTag($keys[$i]);
+
+            if ($currentKey !== $nextKey) {
+                return false;
+            }
+
+            $currentKey = $nextKey;
+        }
+
+        return true;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getDistributor()
+    {
+        return $this->distributor;
+    }
+}

vendor/predis/predis/src/Cluster/RedisStrategy.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis\Cluster;
+
+use Predis\Cluster\Hash\CRC16;
+use Predis\Cluster\Hash\HashGeneratorInterface;
+use Predis\NotSupportedException;
+
+/**
+ * Default class used by Predis to calculate hashes out of keys of
+ * commands supported by redis-cluster.
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class RedisStrategy extends ClusterStrategy
+{
+    protected $hashGenerator;
+
+    /**
+     * @param HashGeneratorInterface $hashGenerator Hash generator instance.
+     */
+    public function __construct(HashGeneratorInterface $hashGenerator = null)
+    {
+        parent::__construct();
+
+        $this->hashGenerator = $hashGenerator ?: new CRC16();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getSlotByKey($key)
+    {
+        $key = $this->extractKeyTag($key);
+        $slot = $this->hashGenerator->hash($key) & 0x3FFF;
+
+        return $slot;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getDistributor()
+    {
+        throw new NotSupportedException(
+            'This cluster strategy does not provide an external distributor'
+        );
+    }
+}

vendor/predis/predis/src/Cluster/StrategyInterface.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis\Cluster;
+
+use Predis\Cluster\Distributor\DistributorInterface;
+use Predis\Command\CommandInterface;
+
+/**
+ * Interface for classes defining the strategy used to calculate an hash out of
+ * keys extracted from supported commands.
+ *
+ * This is mostly useful to support clustering via client-side sharding.
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+interface StrategyInterface
+{
+    /**
+     * Returns a slot for the given command used for clustering distribution or
+     * NULL when this is not possible.
+     *
+     * @param CommandInterface $command Command instance.
+     *
+     * @return int
+     */
+    public function getSlot(CommandInterface $command);
+
+    /**
+     * Returns a slot for the given key used for clustering distribution or NULL
+     * when this is not possible.
+     *
+     * @param string $key Key string.
+     *
+     * @return int
+     */
+    public function getSlotByKey($key);
+
+    /**
+     * Returns a distributor instance to be used by the cluster.
+     *
+     * @return DistributorInterface
+     */
+    public function getDistributor();
+}

vendor/predis/predis/src/Collection/Iterator/CursorBasedIterator.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis\Collection\Iterator;
+
+use Predis\ClientInterface;
+use Predis\NotSupportedException;
+
+/**
+ * Provides the base implementation for a fully-rewindable PHP iterator that can
+ * incrementally iterate over cursor-based collections stored on Redis using the
+ * commands in the `SCAN` family.
+ *
+ * Given their incremental nature with multiple fetches, these kind of iterators
+ * offer limited guarantees about the returned elements because the collection
+ * can change several times during the iteration process.
+ *
+ * @see http://redis.io/commands/scan
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+abstract class CursorBasedIterator implements \Iterator
+{
+    protected $client;
+    protected $match;
+    protected $count;
+
+    protected $valid;
+    protected $fetchmore;
+    protected $elements;
+    protected $cursor;
+    protected $position;
+    protected $current;
+
+    /**
+     * @param ClientInterface $client Client connected to Redis.
+     * @param string          $match  Pattern to match during the server-side iteration.
+     * @param int             $count  Hint used by Redis to compute the number of results per iteration.
+     */
+    public function __construct(ClientInterface $client, $match = null, $count = null)
+    {
+        $this->client = $client;
+        $this->match = $match;
+        $this->count = $count;
+
+        $this->reset();
+    }
+
+    /**
+     * Ensures that the client supports the specified Redis command required to
+     * fetch elements from the server to perform the iteration.
+     *
+     * @param ClientInterface $client    Client connected to Redis.
+     * @param string          $commandID Command ID.
+     *
+     * @throws NotSupportedException
+     */
+    protected function requiredCommand(ClientInterface $client, $commandID)
+    {
+        if (!$client->getProfile()->supportsCommand($commandID)) {
+            throw new NotSupportedException("The current profile does not support '$commandID'.");
+        }
+    }
+
+    /**
+     * Resets the inner state of the iterator.
+     */
+    protected function reset()
+    {
+        $this->valid = true;
+        $this->fetchmore = true;
+        $this->elements = array();
+        $this->cursor = 0;
+        $this->position = -1;
+        $this->current = null;
+    }
+
+    /**
+     * Returns an array of options for the `SCAN` command.
+     *
+     * @return array
+     */
+    protected function getScanOptions()
+    {
+        $options = array();
+
+        if (strlen($this->match) > 0) {
+            $options['MATCH'] = $this->match;
+        }
+
+        if ($this->count > 0) {
+            $options['COUNT'] = $this->count;
+        }
+
+        return $options;
+    }
+
+    /**
+     * Fetches a new set of elements from the remote collection, effectively
+     * advancing the iteration process.
+     *
+     * @return array
+     */
+    abstract protected function executeCommand();
+
+    /**
+     * Populates the local buffer of elements fetched from the server during
+     * the iteration.
+     */
+    protected function fetch()
+    {
+        list($cursor, $elements) = $this->executeCommand();
+
+        if (!$cursor) {
+            $this->fetchmore = false;
+        }
+
+        $this->cursor = $cursor;
+        $this->elements = $elements;
+    }
+
+    /**
+     * Extracts next values for key() and current().
+     */
+    protected function extractNext()
+    {
+        ++$this->position;
+        $this->current = array_shift($this->elements);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function rewind()
+    {
+        $this->reset();
+        $this->next();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function current()
+    {
+        return $this->current;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function key()
+    {
+        return $this->position;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function next()
+    {
+        tryFetch: {
+            if (!$this->elements && $this->fetchmore) {
+                $this->fetch();
+            }
+
+            if ($this->elements) {
+                $this->extractNext();
+            } elseif ($this->cursor) {
+                goto tryFetch;
+            } else {
+                $this->valid = false;
+            }
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function valid()
+    {
+        return $this->valid;
+    }
+}

vendor/predis/predis/src/Collection/Iterator/HashKey.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis\Collection\Iterator;
+
+use Predis\ClientInterface;
+
+/**
+ * Abstracts the iteration of fields and values of an hash by leveraging the
+ * HSCAN command (Redis >= 2.8) wrapped in a fully-rewindable PHP iterator.
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * @link http://redis.io/commands/scan
+ */
+class HashKey extends CursorBasedIterator
+{
+    protected $key;
+
+    /**
+     * {@inheritdoc}
+     */
+    public function __construct(ClientInterface $client, $key, $match = null, $count = null)
+    {
+        $this->requiredCommand($client, 'HSCAN');
+
+        parent::__construct($client, $match, $count);
+
+        $this->key = $key;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function executeCommand()
+    {
+        return $this->client->hscan($this->key, $this->cursor, $this->getScanOptions());
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function extractNext()
+    {
+        if ($kv = each($this->elements)) {
+            $this->position = $kv[0];
+            $this->current = $kv[1];
+
+            unset($this->elements[$this->position]);
+        }
+    }
+}

vendor/predis/predis/src/Collection/Iterator/Keyspace.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis\Collection\Iterator;
+
+use Predis\ClientInterface;
+
+/**
+ * Abstracts the iteration of the keyspace on a Redis instance by leveraging the
+ * SCAN command (Redis >= 2.8) wrapped in a fully-rewindable PHP iterator.
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * @link http://redis.io/commands/scan
+ */
+class Keyspace extends CursorBasedIterator
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function __construct(ClientInterface $client, $match = null, $count = null)
+    {
+        $this->requiredCommand($client, 'SCAN');
+
+        parent::__construct($client, $match, $count);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function executeCommand()
+    {
+        return $this->client->scan($this->cursor, $this->getScanOptions());
+    }
+}

vendor/predis/predis/src/Collection/Iterator/ListKey.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis\Collection\Iterator;
+
+use Predis\ClientInterface;
+use Predis\NotSupportedException;
+
+/**
+ * Abstracts the iteration of items stored in a list by leveraging the LRANGE
+ * command wrapped in a fully-rewindable PHP iterator.
+ *
+ * This iterator tries to emulate the behaviour of cursor-based iterators based
+ * on the SCAN-family of commands introduced in Redis <= 2.8, meaning that due
+ * to its incremental nature with multiple fetches it can only offer limited
+ * guarantees on the returned elements because the collection can change several
+ * times (trimmed, deleted, overwritten) during the iteration process.
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * @link http://redis.io/commands/lrange
+ */
+class ListKey implements \Iterator
+{
+    protected $client;
+    protected $count;
+    protected $key;
+
+    protected $valid;
+    protected $fetchmore;
+    protected $elements;
+    protected $position;
+    protected $current;
+
+    /**
+     * @param ClientInterface $client Client connected to Redis.
+     * @param string          $key    Redis list key.
+     * @param int             $count  Number of items retrieved on each fetch operation.
+     *
+     * @throws \InvalidArgumentException
+     */
+    public function __construct(ClientInterface $client, $key, $count = 10)
+    {
+        $this->requiredCommand($client, 'LRANGE');
+
+        if ((false === $count = filter_var($count, FILTER_VALIDATE_INT)) || $count < 0) {
+            throw new \InvalidArgumentException('The $count argument must be a positive integer.');
+        }
+
+        $this->client = $client;
+        $this->key = $key;
+        $this->count = $count;
+
+        $this->reset();
+    }
+
+    /**
+     * Ensures that the client instance supports the specified Redis command
+     * required to fetch elements from the server to perform the iteration.
+     *
+     * @param ClientInterface $client    Client connected to Redis.
+     * @param string          $commandID Command ID.
+     *
+     * @throws NotSupportedException
+     */
+    protected function requiredCommand(ClientInterface $client, $commandID)
+    {
+        if (!$client->getProfile()->supportsCommand($commandID)) {
+            throw new NotSupportedException("The current profile does not support '$commandID'.");
+        }
+    }
+
+    /**
+     * Resets the inner state of the iterator.
+     */
+    protected function reset()
+    {
+        $this->valid = true;
+        $this->fetchmore = true;
+        $this->elements = array();
+        $this->position = -1;
+        $this->current = null;
+    }
+
+    /**
+     * Fetches a new set of elements from the remote collection, effectively
+     * advancing the iteration process.
+     *
+     * @return array
+     */
+    protected function executeCommand()
+    {
+        return $this->client->lrange($this->key, $this->position + 1, $this->position + $this->count);
+    }
+
+    /**
+     * Populates the local buffer of elements fetched from the server during the
+     * iteration.
+     */
+    protected function fetch()
+    {
+        $elements = $this->executeCommand();
+
+        if (count($elements) < $this->count) {
+            $this->fetchmore = false;
+        }
+
+        $this->elements = $elements;
+    }
+
+    /**
+     * Extracts next values for key() and current().
+     */
+    protected function extractNext()
+    {
+        ++$this->position;
+        $this->current = array_shift($this->elements);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function rewind()
+    {
+        $this->reset();
+        $this->next();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function current()
+    {
+        return $this->current;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function key()
+    {
+        return $this->position;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function next()
+    {
+        if (!$this->elements && $this->fetchmore) {
+            $this->fetch();
+        }
+
+        if ($this->elements) {
+            $this->extractNext();
+        } else {
+            $this->valid = false;
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function valid()
+    {
+        return $this->valid;
+    }
+}

vendor/predis/predis/src/Collection/Iterator/SetKey.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis\Collection\Iterator;
+
+use Predis\ClientInterface;
+
+/**
+ * Abstracts the iteration of members stored in a set by leveraging the SSCAN
+ * command (Redis >= 2.8) wrapped in a fully-rewindable PHP iterator.
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * @link http://redis.io/commands/scan
+ */
+class SetKey extends CursorBasedIterator
+{
+    protected $key;
+
+    /**
+     * {@inheritdoc}
+     */
+    public function __construct(ClientInterface $client, $key, $match = null, $count = null)
+    {
+        $this->requiredCommand($client, 'SSCAN');
+
+        parent::__construct($client, $match, $count);
+
+        $this->key = $key;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function executeCommand()
+    {
+        return $this->client->sscan($this->key, $this->cursor, $this->getScanOptions());
+    }
+}

vendor/predis/predis/src/Collection/Iterator/SortedSetKey.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis\Collection\Iterator;
+
+use Predis\ClientInterface;
+
+/**
+ * Abstracts the iteration of members stored in a sorted set by leveraging the
+ * ZSCAN command (Redis >= 2.8) wrapped in a fully-rewindable PHP iterator.
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * @link http://redis.io/commands/scan
+ */
+class SortedSetKey extends CursorBasedIterator
+{
+    protected $key;
+
+    /**
+     * {@inheritdoc}
+     */
+    public function __construct(ClientInterface $client, $key, $match = null, $count = null)
+    {
+        $this->requiredCommand($client, 'ZSCAN');
+
+        parent::__construct($client, $match, $count);
+
+        $this->key = $key;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function executeCommand()
+    {
+        return $this->client->zscan($this->key, $this->cursor, $this->getScanOptions());
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function extractNext()
+    {
+        if ($kv = each($this->elements)) {
+            $this->position = $kv[0];
+            $this->current = $kv[1];
+
+            unset($this->elements[$this->position]);
+        }
+    }
+}

vendor/predis/predis/src/Command/Command.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis\Command;
+
+/**
+ * Base class for Redis commands.
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+abstract class Command implements CommandInterface
+{
+    private $slot;
+    private $arguments = array();
+
+    /**
+     * Returns a filtered array of the arguments.
+     *
+     * @param array $arguments List of arguments.
+     *
+     * @return array
+     */
+    protected function filterArguments(array $arguments)
+    {
+        return $arguments;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function setArguments(array $arguments)
+    {
+        $this->arguments = $this->filterArguments($arguments);
+        unset($this->slot);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function setRawArguments(array $arguments)
+    {
+        $this->arguments = $arguments;
+        unset($this->slot);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getArguments()
+    {
+        return $this->arguments;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getArgument($index)
+    {
+        if (isset($this->arguments[$index])) {
+            return $this->arguments[$index];
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function setSlot($slot)
+    {
+        $this->slot = $slot;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getSlot()
+    {
+        if (isset($this->slot)) {
+            return $this->slot;
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function parseResponse($data)
+    {
+        return $data;
+    }
+
+    /**
+     * Normalizes the arguments array passed to a Redis command.
+     *
+     * @param array $arguments Arguments for a command.
+     *
+     * @return array
+     */
+    public static function normalizeArguments(array $arguments)
+    {
+        if (count($arguments) === 1 && is_array($arguments[0])) {
+            return $arguments[0];
+        }
+
+        return $arguments;
+    }
+
+    /**
+     * Normalizes the arguments array passed to a variadic Redis command.
+     *
+     * @param array $arguments Arguments for a command.
+     *
+     * @return array
+     */
+    public static function normalizeVariadic(array $arguments)
+    {
+        if (count($arguments) === 2 && is_array($arguments[1])) {
+            return array_merge(array($arguments[0]), $arguments[1]);
+        }
+
+        return $arguments;
+    }
+}

vendor/predis/predis/src/Command/CommandInterface.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis\Command;
+
+/**
+ * Defines an abstraction representing a Redis command.
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+interface CommandInterface
+{
+    /**
+     * Returns the ID of the Redis command. By convention, command identifiers
+     * must always be uppercase.
+     *
+     * @return string
+     */
+    public function getId();
+
+    /**
+     * Assign the specified slot to the command for clustering distribution.
+     *
+     * @param int $slot Slot ID.
+     */
+    public function setSlot($slot);
+
+    /**
+     * Returns the assigned slot of the command for clustering distribution.
+     *
+     * @return int|null
+     */
+    public function getSlot();
+
+    /**
+     * Sets the arguments for the command.
+     *
+     * @param array $arguments List of arguments.
+     */
+    public function setArguments(array $arguments);
+
+    /**
+     * Sets the raw arguments for the command without processing them.
+     *
+     * @param array $arguments List of arguments.
+     */
+    public function setRawArguments(array $arguments);
+
+    /**
+     * Gets the arguments of the command.
+     *
+     * @return array
+     */
+    public function getArguments();
+
+    /**
+     * Gets the argument of the command at the specified index.
+     *
+     * @param int $index Index of the desired argument.
+     *
+     * @return mixed|null
+     */
+    public function getArgument($index);
+
+    /**
+     * Parses a raw response and returns a PHP object.
+     *
+     * @param string $data Binary string containing the whole response.
+     *
+     * @return mixed
+     */
+    public function parseResponse($data);
+}

vendor/predis/predis/src/Command/ConnectionAuth.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis\Command;
+
+/**
+ * @link http://redis.io/commands/auth
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class ConnectionAuth extends Command
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'AUTH';
+    }
+}

vendor/predis/predis/src/Command/ConnectionEcho.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis\Command;
+
+/**
+ * @link http://redis.io/commands/echo
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class ConnectionEcho extends Command
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'ECHO';
+    }
+}

vendor/predis/predis/src/Command/ConnectionPing.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis\Command;
+
+/**
+ * @link http://redis.io/commands/ping
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class ConnectionPing extends Command
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'PING';
+    }
+}

vendor/predis/predis/src/Command/ConnectionQuit.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis\Command;
+
+/**
+ * @link http://redis.io/commands/quit
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class ConnectionQuit extends Command
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'QUIT';
+    }
+}

vendor/predis/predis/src/Command/ConnectionSelect.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis\Command;
+
+/**
+ * @link http://redis.io/commands/select
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class ConnectionSelect extends Command
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'SELECT';
+    }
+}

vendor/predis/predis/src/Command/GeospatialGeoAdd.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis\Command;
+
+/**
+ * @link http://redis.io/commands/geoadd
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class GeospatialGeoAdd extends Command
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'GEOADD';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function filterArguments(array $arguments)
+    {
+        if (count($arguments) === 2 && is_array($arguments[1])) {
+            foreach (array_pop($arguments) as $item) {
+                $arguments = array_merge($arguments, $item);
+            }
+        }
+
+        return $arguments;
+    }
+}

vendor/predis/predis/src/Command/GeospatialGeoDist.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis\Command;
+
+/**
+ * @link http://redis.io/commands/geodist
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class GeospatialGeoDist extends Command
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'GEODIST';
+    }
+}

vendor/predis/predis/src/Command/GeospatialGeoHash.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis\Command;
+
+/**
+ * @link http://redis.io/commands/geohash
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class GeospatialGeoHash extends Command
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'GEOHASH';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function filterArguments(array $arguments)
+    {
+        if (count($arguments) === 2 && is_array($arguments[1])) {
+            $members = array_pop($arguments);
+            $arguments = array_merge($arguments, $members);
+        }
+
+        return $arguments;
+    }
+}

vendor/predis/predis/src/Command/GeospatialGeoPos.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis\Command;
+
+/**
+ * @link http://redis.io/commands/geopos
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class GeospatialGeoPos extends Command
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'GEOPOS';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function filterArguments(array $arguments)
+    {
+        if (count($arguments) === 2 && is_array($arguments[1])) {
+            $members = array_pop($arguments);
+            $arguments = array_merge($arguments, $members);
+        }
+
+        return $arguments;
+    }
+}

vendor/predis/predis/src/Command/GeospatialGeoRadius.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis\Command;
+
+/**
+ * @link http://redis.io/commands/georadius
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class GeospatialGeoRadius extends Command
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'GEORADIUS';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function filterArguments(array $arguments)
+    {
+        if ($arguments && is_array(end($arguments))) {
+            $options = array_change_key_case(array_pop($arguments), CASE_UPPER);
+
+            if (isset($options['WITHCOORD']) && $options['WITHCOORD'] == true) {
+                $arguments[] = 'WITHCOORD';
+            }
+
+            if (isset($options['WITHDIST']) && $options['WITHDIST'] == true) {
+                $arguments[] = 'WITHDIST';
+            }
+
+            if (isset($options['WITHHASH']) && $options['WITHHASH'] == true) {
+                $arguments[] = 'WITHHASH';
+            }
+
+            if (isset($options['COUNT'])) {
+                $arguments[] = 'COUNT';
+                $arguments[] = $options['COUNT'];
+            }
+
+            if (isset($options['SORT'])) {
+                $arguments[] = strtoupper($options['SORT']);
+            }
+
+            if (isset($options['STORE'])) {
+                $arguments[] = 'STORE';
+                $arguments[] = $options['STORE'];
+            }
+
+            if (isset($options['STOREDIST'])) {
+                $arguments[] = 'STOREDIST';
+                $arguments[] = $options['STOREDIST'];
+            }
+        }
+
+        return $arguments;
+    }
+}

vendor/predis/predis/src/Command/GeospatialGeoRadiusByMember.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis\Command;
+
+/**
+ * @link http://redis.io/commands/georadiusbymember
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class GeospatialGeoRadiusByMember extends GeospatialGeoRadius
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'GEORADIUSBYMEMBER';
+    }
+}

vendor/predis/predis/src/Command/HashDelete.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis\Command;
+
+/**
+ * @link http://redis.io/commands/hdel
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class HashDelete extends Command
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'HDEL';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function filterArguments(array $arguments)
+    {
+        return self::normalizeVariadic($arguments);
+    }
+}

vendor/predis/predis/src/Command/HashExists.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis\Command;
+
+/**
+ * @link http://redis.io/commands/hexists
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class HashExists extends Command
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'HEXISTS';
+    }
+}

vendor/predis/predis/src/Command/HashGet.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis\Command;
+
+/**
+ * @link http://redis.io/commands/hget
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class HashGet extends Command
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'HGET';
+    }
+}

vendor/predis/predis/src/Command/HashGetAll.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis\Command;
+
+/**
+ * @link http://redis.io/commands/hgetall
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class HashGetAll extends Command
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'HGETALL';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function parseResponse($data)
+    {
+        $result = array();
+
+        for ($i = 0; $i < count($data); ++$i) {
+            $result[$data[$i]] = $data[++$i];
+        }
+
+        return $result;
+    }
+}

vendor/predis/predis/src/Command/HashGetMultiple.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis\Command;
+
+/**
+ * @link http://redis.io/commands/hmget
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class HashGetMultiple extends Command
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'HMGET';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function filterArguments(array $arguments)
+    {
+        return self::normalizeVariadic($arguments);
+    }
+}

vendor/predis/predis/src/Command/HashIncrementBy.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis\Command;
+
+/**
+ * @link http://redis.io/commands/hincrby
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class HashIncrementBy extends Command
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'HINCRBY';
+    }
+}

vendor/predis/predis/src/Command/HashIncrementByFloat.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis\Command;
+
+/**
+ * @link http://redis.io/commands/hincrbyfloat
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class HashIncrementByFloat extends Command
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'HINCRBYFLOAT';
+    }
+}

vendor/predis/predis/src/Command/HashKeys.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis\Command;
+
+/**
+ * @link http://redis.io/commands/hkeys
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class HashKeys extends Command
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'HKEYS';
+    }
+}

vendor/predis/predis/src/Command/HashLength.php

+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis\Command;
+
+/**
+ * @link http://redis.io/commands/hlen
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class HashLength extends Command
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'HLEN';
+    }
+}