the whole shebang

vendor/predis/predis/.gitignore

@@ -0,0 +1,7 @@
+*.tgz
+*.phar
+phpunit.xml
+package.xml
+composer.lock
+experiments/
+vendor/

vendor/predis/predis/.travis.yml

@@ -0,0 +1,13 @@
+language: php
+php:
+  - 5.3
+  - 5.4
+  - 5.5
+branches:
+  except:
+    - v0.5
+    - v0.6
+    - php5.2_backport
+    - documentation
+services: redis-server
+script: phpunit -c phpunit.xml.travisci

vendor/predis/predis/CHANGELOG.NAMING.md

@@ -0,0 +1,53 @@
+# Namespaces, interfaces and classes renamed in Predis v0.8 #
+____________________________________________
+
+Some namespaces, interfaces and classes in Predis v0.8 have been renamed to follow a common rule inspired
+by the naming conventions adopted by the Symfony2 project. This is a list of all the changes:
+
+### Renamed namespaces ###
+
+  - `Predis\Network` => `Predis\Connection`
+  - `Predis\Profiles` => `Predis\Profile`
+  - `Predis\Iterators` => `Predis\Iterator`
+  - `Predis\Options` => `Predis\Option`
+  - `Predis\Commands` => `Predis\Command`
+  - `Predis\Commands\Processors` => `Predis\Command\Processor`
+
+### Renamed interfaces ###
+
+  - `Predis\IReplyObject` => `Predis\ResponseObjectInterface`
+  - `Predis\IRedisServerError` => `Predis\ResponseErrorInterface`
+  - `Predis\Options\IOption` => `Predis\Option\OptionInterface`
+  - `Predis\Options\IClientOptions` => `Predis\Option\ClientOptionsInterface`
+  - `Predis\Profile\IServerProfile` => `Predis\Profile\ServerProfileInterface`
+  - `Predis\Pipeline\IPipelineExecutor` => `Predis\Pipeline\PipelineExecutorInterface`
+  - `Predis\Distribution\INodeKeyGenerator` => `Predis\Distribution\HashGeneratorInterface`
+  - `Predis\Distribution\IDistributionStrategy` => `Predis\Distribution\DistributionStrategyInterface`
+  - `Predis\Protocol\IProtocolProcessor` => `Predis\Protocol\ProtocolInterface`
+  - `Predis\Protocol\IResponseReader` => `Predis\Protocol\ResponseReaderInterface`
+  - `Predis\Protocol\IResponseHandler` => `Predis\Protocol\ResponseHandlerInterface`
+  - `Predis\Protocol\ICommandSerializer` => `Predis\Protocol\CommandSerializerInterface`
+  - `Predis\Protocol\IComposableProtocolProcessor` => `Predis\Protocol\ComposableProtocolInterface`
+  - `Predis\Network\IConnection` => `Predis\Connection\ConnectionInterface`
+  - `Predis\Network\IConnectionSingle` => `Predis\Connection\SingleConnectionInterface`
+  - `Predis\Network\IConnectionComposable` => `Predis\Connection\ComposableConnectionInterface`
+  - `Predis\Network\IConnectionCluster` => `Predis\Connection\ClusterConnectionInterface`
+  - `Predis\Network\IConnectionReplication` => `Predis\Connection\ReplicationConnectionInterface`
+  - `Predis\Commands\ICommand` => `Predis\Command\CommandInterface`
+  - `Predis\Commands\IPrefixable` => `Predis\Command\PrefixableCommandInterface`
+  - `Predis\Command\Processor\ICommandProcessor` => `Predis\Command\Processor\CommandProcessorInterface`
+  - `Predis\Command\Processor\ICommandProcessorChain` => `Predis\Command\Processor\CommandProcessorChainInterface`
+  - `Predis\Command\Processor\IProcessingSupport` => `Predis\Command\Processor\CommandProcessingInterface`
+
+### Renamed classes ###
+
+  - `Predis\Commands\Command` => `Predis\Command\AbstractCommand`
+  - `Predis\Network\ConnectionBase` => `Predis\Connection\AbstractConnection`
+
+### Classes or interfaces moved to different namespaces ###
+
+  - `Predis\MonitorContext` => `Predis\Monitor\MonitorContext`
+  - `Predis\ConnectionParameters` => `Predis\Connection\ConnectionParameters`
+  - `Predis\ConnectionParametersInterface` => `Predis\Connection\ConnectionParametersInterface`
+  - `Predis\ConnectionFactory` => `Predis\Connection\ConnectionFactory`
+  - `Predis\ConnectionFactoryInterface` => `Predis\Connection\ConnectionFactoryInterface`

vendor/predis/predis/CHANGELOG.md

@@ -0,0 +1,573 @@
+v0.8.4 (2013-07-27)
+===============================================================================
+
+- Added `DUMP` and `RESTORE` to the server profile for Redis 2.6.
+
+- Connection exceptions now report basic host details in their messages.
+
+- Allow `Predis\Connection\PhpiredisConnection` to use a random IP when a host
+  actually has several IPs (ISSUE #116).
+
+- __FIX__: allow `HMSET` when using a cluster of Redis nodes with client-side
+  sharding or redis-cluster (ISSUE #106).
+
+- __FIX__: set `WITHSCORES` modifer for `ZRANGE`, `ZREVRANGE`, `ZRANGEBYSCORE`
+  and `ZREVRANGEBYSCORE` only when the options array passed to these commands
+  has `WITHSCORES` set to `true` (ISSUE #107).
+
+- __FIX__: scripted commands falling back from `EVALSHA` to `EVAL` resulted in
+  PHP errors when using a prefixed client (ISSUE #109).
+
+- __FIX__: `Predis\PubSub\DispatcherLoop` now works properly when using key
+  prefixing (ISSUE #114).
+
+
+v0.8.3 (2013-02-18)
+===============================================================================
+
+- Added `CLIENT SETNAME` and `CLIENT GETNAME` (ISSUE #102).
+
+- Implemented the `Predis\Connection\PhpiredisStreamConnection` class using the
+  `phpiredis` extension like `Predis\Connection\PhpiredisStreamConnection`, but
+  without requiring the `socket` extension since it relies on PHP's streams.
+
+- Added support for the TCP_NODELAY flag via the `tcp_nodelay` parameter for
+  stream-based connections, namely `Predis\Connection\StreamConnection` and
+  `Predis\Connection\PhpiredisStreamConnection` (requires PHP >= 5.4.0).
+
+- Updated the aggregated connection class for redis-cluster to work with 16384
+  hash slots instead of 4096 to reflect the recent change from redis unstable
+  ([see this commit](https://github.com/antirez/redis/commit/ebd666d)).
+
+- The constructor of `Predis\Client` now accepts a callable as first argument
+  returning `Predis\Connection\ConnectionInterface`. Users can create their
+  own self-contained strategies to create and set up the underlying connection.
+
+- Users should return `0` from `Predis\Command\ScriptedCommand::getKeysCount()`
+  instead of `FALSE` to indicate that all of the arguments of a Lua script must
+  be used to populate `ARGV[]`. This does not represent a breaking change.
+
+- The `Predis\Helpers` class has been deprecated and it will be removed in
+  future releases.
+
+
+v0.8.2 (2013-02-03)
+===============================================================================
+
+- Added `Predis\Session\SessionHandler` to make it easy to store PHP sessions
+  on Redis using Predis. Please note that this class needs either PHP >= 5.4.0
+  or a polyfill for PHP's `SessionHandlerInterface`.
+
+- Added the ability to get the default value of a client option directly from
+  `Predis\Option\ClientOption` using the `getDefault()` method by passing the
+  option name or its instance.
+
+- __FIX__: the standard pipeline executor was not using the response parser
+  methods associated to commands to process raw responses (ISSUE #101).
+
+
+v0.8.1 (2013-01-19)
+===============================================================================
+
+- The `connections` client option can now accept a callable object returning
+  an instance of `Predis\Connection\ConnectionFactoryInterface`.
+
+- Client options accepting callable objects as factories now pass their actual
+  instance to the callable as the second argument.
+
+- `Predis\Command\Processor\KeyPrefixProcessor` can now be directly casted to
+  string to obtain the current prefix, useful with string interpolation.
+
+- Added an optional callable argument to `Predis\Cluster\Distribution\HashRing`
+  and `Predis\Cluster\Distribution\KetamaPureRing` constructor that can be used
+  to customize how the distributor should extract the connection hash when
+  initializing the nodes distribution (ISSUE #36).
+
+- Correctly handle `TTL` and `PTTL` returning -2 on non existing keys starting
+  with Redis 2.8.
+
+- __FIX__: a missing use directive in `Predis\Transaction\MultiExecContext`
+  caused PHP errors when Redis did not return `+QUEUED` replies to commands
+  when inside a MULTI / EXEC context.
+
+- __FIX__: the `parseResponse()` method implemented for a scripted command was
+  ignored when retrying to execute a Lua script by falling back to `EVAL` after
+  a `-NOSCRIPT` error (ISSUE #94).
+
+- __FIX__: when subclassing `Predis\Client` the `getClientFor()` method returns
+  a new instance of the subclass instead of a new instance of `Predis\Client`.
+
+
+v0.8.0 (2012-10-23)
+===============================================================================
+
+- The default server profile for Redis is now `2.6`.
+
+- Certain connection parameters have been renamed:
+
+  - `connection_async` is now `async_connect`
+  - `connection_timeout` is now `timeout`
+  - `connection_persistent` is now `persistent`
+
+- The `throw_errors` connection parameter has been removed and replaced by the
+  new `exceptions` client option since exceptions on `-ERR` replies returned by
+  Redis are not generated by connection classes anymore but instead are thrown
+  by the client class and other abstractions such as pipeline contexts.
+
+- Added smart support for redis-cluster (Redis v3.0) in addition to the usual
+  cluster implementation that uses client-side sharding.
+
+- Various namespaces and classes have been renamed to follow rules inspired by
+  the Symfony2 naming conventions.
+
+- The second argument of the constructor of `Predis\Client` does not accept
+  strings or instances of `Predis\Profile\ServerProfileInterface` anymore.
+  To specify a server profile you must explicitly set `profile` in the array
+  of client options.
+
+- `Predis\Command\ScriptedCommand` internally relies on `EVALSHA` instead of
+  `EVAL` thus avoiding to send Lua scripts bodies on each request. The client
+  automatically resends the command falling back to `EVAL` when Redis returns a
+  `-NOSCRIPT` error. Automatic fallback to `EVAL` does not work with pipelines,
+  inside a `MULTI / EXEC` context or with plain `EVALSHA` commands.
+
+- Complex responses are no more parsed by connection classes as they must be
+  processed by consumer classes using the handler associated to the issued
+  command. This means that executing commands directly on connections only
+  returns simple Redis types, but nothing changes when using `Predis\Client`
+  or the provided abstractions for pipelines and transactions.
+
+- Iterators for multi-bulk replies now skip the response parsing method of the
+  command that generated the response and are passed directly to user code.
+  Pipeline and transaction objects still consume automatically iterators.
+
+- Cluster and replication connections now extend a new common interface,
+  `Predis\Connection\AggregatedConnectionInterface`.
+
+- `Predis\Connection\MasterSlaveReplication` now uses an external strategy
+  class to handle the logic for checking readable / writable commands and Lua
+  scripts.
+
+- Command pipelines have been optimized for both speed and code cleanness, but
+  at the cost of bringing a breaking change in the signature of the interface
+  for pipeline executors.
+
+- Added a new pipeline executor that sends commands wrapped in a MULTI / EXEC
+  context to make the execution atomic: if a pipeline fails at a certain point
+  then the whole pipeline is discarded.
+
+- The key-hashing mechanism for commands is now handled externally and is no
+  more a competence of each command class. This change is neeeded to support
+  both client-side sharding and Redis cluster.
+
+- `Predis\Options\Option` is now abstract, see `Predis\Option\AbstractOption`.
+
+
+v0.7.3 (2012-06-01)
+===============================================================================
+
+- New commands available in the Redis v2.6 profile (dev): `BITOP`, `BITCOUNT`.
+
+- When the number of keys `Predis\Commands\ScriptedCommand` is negative, Predis
+  will count from the end of the arguments list to calculate the actual number
+  of keys that will be interpreted as elements for `KEYS` by the underlying
+  `EVAL` command.
+
+- __FIX__: `examples\CustomDistributionStrategy.php` had a mistyped constructor
+  call and produced a bad distribution due to an error as pointed in ISSUE #63.
+  This bug is limited to the above mentioned example and does not affect the
+  classes implemented in the `Predis\Distribution` namespace.
+
+- __FIX__: `Predis\Commands\ServerEvalSHA::getScriptHash()` was calculating the
+  hash while it just needs to return the first argument of the command.
+
+- __FIX__: `Predis\Autoloader` has been modified to allow cascading autoloaders
+  for the `Predis` namespace.
+
+
+v0.7.2 (2012-04-01)
+===============================================================================
+
+- Added `2.6` in the server profiles aliases list for the upcoming Redis 2.6.
+  `2.4` is still the default server profile. `dev` now targets Redis 2.8.
+
+- Connection instances can be serialized and unserialized using `serialize()`
+  and `unserialize()`. This is handy in certain scenarios such as client-side
+  clustering or replication to lower the overhead of initializing a connection
+  object with many sub-connections since unserializing them can be up to 5x
+  times faster.
+
+- Reworked the default autoloader to make it faster. It is also possible to
+  prepend it in PHP's autoload stack.
+
+- __FIX__: fixed parsing of the payload returned by `MONITOR` with Redis 2.6.
+
+
+v0.7.1 (2011-12-27)
+===============================================================================
+
+- The PEAR channel on PearHub has been deprecated in favour of `pear.nrk.io`.
+
+- Miscellaneous minor fixes.
+
+- Added transparent support for master / slave replication configurations where
+  write operations are performed on the master server and read operations are
+  routed to one of the slaves. Please refer to ISSUE #21 for a bit of history
+  and more details about replication support in Predis.
+
+- The `profile` client option now accepts a callable object used to initialize
+  a new instance of `Predis\Profiles\IServerProfile`.
+
+- Exposed a method for MULTI / EXEC contexts that adds the ability to execute
+  instances of Redis commands against transaction objects.
+
+
+v0.7.0 (2011-12-11)
+===============================================================================
+
+- Predis now adheres to the PSR-0 standard which means that there is no more a
+  single file holding all the classes of the library, but multiple files (one
+  for each class). You can use any PSR-0 compatible autoloader to load Predis
+  or just leverage the default one shipped with the library by requiring the
+  `Predis/Autoloader.php` and call `Predis\Autoloader::register()`.
+
+- The default server profile for Redis is now 2.4. The `dev` profile supports
+  all the features of Redis 2.6 (currently unstable) such as Lua scripting.
+
+- Support for long aliases (method names) for Redis commands has been dropped.
+
+- Redis 1.0 is no more supported. From now on Predis will use only the unified
+  protocol to serialize commands.
+
+- It is possible to prefix keys transparently on a client-level basis with the
+  new `prefix` client option.
+
+- An external connection factory is used to initialize new connection instances
+  and developers can now register their own connection classes using the new
+  `connections` client option.
+
+- It is possible to connect locally to Redis using UNIX domain sockets. Just
+  use `unix:///path/to/redis.sock` or a named array just like in the following
+  example: `array('scheme' => 'unix', 'path' => '/path/to/redis.sock');`.
+
+- If the `phpiredis` extension is loaded by PHP, it is now possible to use an
+  alternative connection class that leverages it to make Predis faster on many
+  cases, especially when dealing with big multibulk replies, with the the only
+  downside that persistent connections are not supported. Please refer to the
+  documentation to see how to activate this class using the new `connections`
+  client option.
+
+- Predis is capable to talk with Webdis, albeit with some limitations such as
+  the lack of pipelining and transactions, just by using the `http` scheme in
+  in the connection parameters. All is needed is PHP with the `curl` and the
+  `phpiredis` extensions loaded.
+
+- Way too many changes in the public API to make a list here, we just tried to
+  make all the Redis commands compatible with previous releases of v0.6 so that
+  you do not have to worry if you are simply using Predis as a client. Probably
+  the only breaking changes that should be mentioned here are:
+
+  - `throw_on_error` has been renamed to `throw_errors` and it is a connection
+    parameter instead of a client option, along with `iterable_multibulk`.
+
+  - `key_distribution` has been removed from the client options. To customize
+    the distribution strategy you must provide a callable object to the new
+    `cluster` client option to configure and then return a new instance of
+    `Predis\Network\IConnectionCluster`.
+
+  - `Predis\Client::create()` has been removed. Just use the constructor to set
+    up a new instance of `Predis\Client`.
+
+  - `Predis\Client::pipelineSafe()` was deprecated in Predis v0.6.1 and now has
+    finally removed. Use `Predis\Client::pipeline(array('safe' => true))`.
+
+  - `Predis\Client::rawCommand()` has been removed due to inconsistencies with
+    the underlying connection abstractions. You can still get the raw resource
+    out of a connection with `Predis\Network\IConnectionSingle::getResource()`
+    so that you can talk directly with Redis.
+
+- The `Predis\MultiBulkCommand` class has been merged into `Predis\Command` and
+  thus removed. Serialization of commands is now a competence of connections.
+
+- The `Predis\IConnection` interface has been splitted into two new interfaces:
+  `Predis\Network\IConnectionSingle` and `Predis\Network\IConnectionCluster`.
+
+- The constructor of `Predis\Client` now accepts more type of arguments such as
+  instances of `Predis\IConnectionParameters` and `Predis\Network\IConnection`.
+
+
+v0.6.6 (2011-04-01)
+===============================================================================
+
+- Switched to Redis 2.2 as the default server profile (there are no changes
+  that would break compatibility with previous releases). Long command names
+  are no more supported by default but if you need them you can still require
+  `Predis_Compatibility.php` to avoid breaking compatibility.
+
+- Added a `VERSION` constant to `Predis\Client`.
+
+- Some performance improvements for multibulk replies (parsing them is about
+  16% faster than the previous version). A few core classes have been heavily
+  optimized to reduce overhead when creating new instances.
+
+- Predis now uses by default a new protocol reader, more lightweight and
+  faster than the default handler-based one. Users can revert to the old
+  protocol reader with the `reader` client option set to `composable`.
+  This client option can also accept custom reader classes implementing the
+  new `Predis\IResponseReader` interface.
+
+- Added support for connecting to Redis using UNIX domain sockets (ISSUE #25).
+
+- The `read_write_timeout` connection parameter can now be set to 0 or false
+  to disable read and write timeouts on connections. The old behaviour of -1
+  is still intact.
+
+- `ZUNIONSTORE` and `ZINTERSTORE` can accept an array to specify a list of the
+  source keys to be used to populate the destination key.
+
+- `MGET`, `SINTER`, `SUNION` and `SDIFF` can accept an array to specify a list
+  of keys. `SINTERSTORE`, `SUNIONSTORE` and `SDIFFSTORE` can also accept an
+  array to specify the list of source keys.
+
+- `SUBSCRIBE` and `PSUBSCRIBE` can accept a list of channels for subscription.
+
+- __FIX__: some client-side clean-ups for `MULTI/EXEC` were handled incorrectly
+  in a couple of corner cases (ISSUE #27).
+
+
+v0.6.5 (2011-02-12)
+===============================================================================
+
+- __FIX__: due to an untested internal change introduced in v0.6.4, a wrong
+  handling of bulk reads of zero-length values was producing protocol
+  desynchronization errors (ISSUE #20).
+
+
+v0.6.4 (2011-02-12)
+===============================================================================
+
+- Various performance improvements (15% ~ 25%) especially when dealing with
+  long multibulk replies or when using clustered connections.
+
+- Added the `on_retry` option to `Predis\MultiExecBlock` that can be used to
+  specify an external callback (or any callable object) that gets invoked
+  whenever a transaction is aborted by the server.
+
+- Added inline (p)subscribtion via options when initializing an instance of
+  `Predis\PubSubContext`.
+
+
+v0.6.3 (2011-01-01)
+===============================================================================
+
+- New commands available in the Redis v2.2 profile (dev):
+  - Strings: `SETRANGE`, `GETRANGE`, `SETBIT`, `GETBIT`
+  - Lists  : `BRPOPLPUSH`
+
+- The abstraction for `MULTI/EXEC` transactions has been dramatically improved
+  by providing support for check-and-set (CAS) operations when using Redis >=
+  2.2. Aborted transactions can also be optionally replayed in automatic up
+  to a user-defined number of times, after which a `Predis\AbortedMultiExec`
+  exception is thrown.
+
+
+v0.6.2 (2010-11-28)
+===============================================================================
+
+- Minor internal improvements and clean ups.
+
+- New commands available in the Redis v2.2 profile (dev):
+  - Strings: `STRLEN`
+  - Lists  : `LINSERT`, `RPUSHX`, `LPUSHX`
+  - ZSets  : `ZREVRANGEBYSCORE`
+  - Misc.  : `PERSIST`
+
+- WATCH also accepts a single array parameter with the keys that should be
+  monitored during a transaction.
+
+- Improved the behaviour of `Predis\MultiExecBlock` in certain corner cases.
+
+- Improved parameters checking for the SORT command.
+
+- __FIX__: the `STORE` parameter for the `SORT` command didn't work correctly
+  when using `0` as the target key (ISSUE #13).
+
+- __FIX__: the methods for `UNWATCH` and `DISCARD` do not break anymore method
+  chaining with `Predis\MultiExecBlock`.
+
+
+v0.6.1 (2010-07-11)
+===============================================================================
+
+- Minor internal improvements and clean ups.
+
+- New commands available in the Redis v2.2 profile (dev):
+  - Misc.  : `WATCH`, `UNWATCH`
+
+- Optional modifiers for `ZRANGE`, `ZREVRANGE` and `ZRANGEBYSCORE` queries are
+  supported using an associative array passed as the last argument of their
+  respective methods.
+
+- The `LIMIT` modifier for `ZRANGEBYSCORE` can be specified using either:
+  - an indexed array: `array($offset, $count)`
+  - an associative array: `array('offset' => $offset, 'count' => $count)`
+
+- The method `Predis\Client::__construct()` now accepts also instances of
+  `Predis\ConnectionParameters`.
+
+- `Predis\MultiExecBlock` and `Predis\PubSubContext` now throw an exception
+  when trying to create their instances using a profile that does not
+  support the required Redis commands or when the client is connected to
+  a cluster of connections.
+
+- Various improvements to `Predis\MultiExecBlock`:
+  - fixes and more consistent behaviour across various usage cases.
+  - support for `WATCH` and `UNWATCH` when using the current development
+    profile (Redis v2.2) and aborted transactions.
+
+- New signature for `Predis\Client::multiExec()` which is now able to accept
+  an array of options for the underlying instance of `Predis\MultiExecBlock`.
+  Backwards compatibility with previous releases of Predis is ensured.
+
+- New signature for `Predis\Client::pipeline()` which is now able to accept
+  an array of options for the underlying instance of Predis\CommandPipeline.
+  Backwards compatibility with previous releases of Predis is ensured.
+  The method `Predis\Client::pipelineSafe()` is to be considered deprecated.
+
+- __FIX__: The `WEIGHT` modifier for `ZUNIONSTORE` and `ZINTERSTORE` was
+  handled incorrectly with more than two weights specified.
+
+
+v0.6.0 (2010-05-24)
+===============================================================================
+
+- Switched to the new multi-bulk request protocol for all of the commands
+  in the Redis 1.2 and Redis 2.0 profiles. Inline and bulk requests are now
+  deprecated as they will be removed in future releases of Redis.
+
+- The default server profile is `2.0` (targeting Redis 2.0.x). If you are
+  using older versions of Redis, it is highly recommended that you specify
+  which server profile the client should use (e.g. `1.2` when connecting
+  to instances of Redis 1.2.x).
+
+- Support for Redis 1.0 is now optional and it is provided by requiring
+  'Predis_Compatibility.php' before creating an instance of `Predis\Client`.
+
+- New commands added to the Redis 2.0 profile since Predis 0.5.1:
+  - Strings: `SETEX`, `APPEND`, `SUBSTR`
+  - ZSets  : `ZCOUNT`, `ZRANK`, `ZUNIONSTORE`, `ZINTERSTORE`, `ZREMBYRANK`,
+             `ZREVRANK`
+  - Hashes : `HSET`, `HSETNX`, `HMSET`, `HINCRBY`, `HGET`, `HMGET`, `HDEL`,
+             `HEXISTS`, `HLEN`, `HKEYS`, `HVALS`, `HGETALL`
+  - PubSub : `PUBLISH`, `SUBSCRIBE`, `UNSUBSCRIBE`
+  - Misc.  : `DISCARD`, `CONFIG`
+
+- Introduced client-level options with the new `Predis\ClientOptions` class.
+  Options can be passed to the constructor of `Predis\Client` in its second
+  argument as an array or an instance of `Predis\ClientOptions`. For brevity's
+  sake and compatibility with older versions, the constructor still accepts
+  an instance of `Predis\RedisServerProfile` in its second argument. The
+  currently supported client options are:
+
+  - `profile` [default: `2.0` as of Predis 0.6.0]: specifies which server
+    profile to use when connecting to Redis. This option accepts an instance
+    of `Predis\RedisServerProfile` or a string that indicates the version.
+
+  - `key_distribution` [default: `Predis\Distribution\HashRing`]: specifies
+    which key distribution strategy to use to distribute keys among the
+    servers that compose a cluster. This option accepts an instance of
+    `Predis\Distribution\IDistributionStrategy` so that users can implement
+    their own key distribution strategy. `Predis\Distribution\KetamaPureRing`
+    is an alternative distribution strategy providing a pure-PHP implementation
+    of the same algorithm used by libketama.
+
+  - `throw_on_error` [default: `TRUE`]: server errors can optionally be handled
+    "silently": instead of throwing an exception, the client returns an error
+    response type.
+
+  - `iterable_multibulk` [EXPERIMENTAL - default: `FALSE`]: in addition to the
+    classic way of fetching a whole multibulk reply into an array, the client
+    can now optionally stream a multibulk reply down to the user code by using
+    PHP iterators. It is just a little bit slower, but it can save a lot of
+    memory in certain scenarios.
+
+- New parameters for connections:
+
+  - `alias` [default: not set]: every connection can now be identified by an
+    alias that is useful to get a specific connections when connected to a
+    cluster of Redis servers.
+  - `weight` [default: not set]: allows to balance keys asymmetrically across
+    multiple servers. This is useful when you have servers with different
+    amounts of memory to distribute the load of your keys accordingly.
+  - `connection_async` [default: `FALSE`]: estabilish connections to servers
+    in a non-blocking way, so that the client is not blocked while the socket
+    resource performs the actual connection.
+  - `connection_persistent` [default: `FALSE`]: the underlying socket resource
+    is left open when a script ends its lifecycle. Persistent connections can
+    lead to unpredictable or strange behaviours, so they should be used with
+    extreme care.
+
+- Introduced the `Predis\Pipeline\IPipelineExecutor` interface. Classes that
+  implements this interface are used internally by the `Predis\CommandPipeline`
+  class to change the behaviour of the pipeline when writing/reading commands
+  from one or multiple servers. Here is the list of the default executors:
+
+  - `Predis\Pipeline\StandardExecutor`: exceptions generated by server errors
+    might be thrown depending on the options passed to the client (see the
+    `throw_on_error` client option). Instead, protocol or network errors always
+    throw exceptions. This is the default executor for single and clustered
+    connections and shares the same behaviour of Predis 0.5.x.
+  - `Predis\Pipeline\SafeExecutor`: exceptions generated by server, protocol
+    or network errors are not thrown but returned in the response array as
+    instances of `Predis\ResponseError` or `Predis\CommunicationException`.
+  - `Predis\Pipeline\SafeClusterExecutor`: this executor shares the same
+    behaviour of `Predis\Pipeline\SafeExecutor` but it is geared towards
+    clustered connections.
+
+- Support for PUB/SUB is handled by the new `Predis\PubSubContext` class, which
+  could also be used to build a callback dispatcher for PUB/SUB scenarios.
+
+- When connected to a cluster of connections, it is now possible to get a
+  new `Predis\Client` instance for a single connection of the cluster by
+  passing its alias/index to the new `Predis\Client::getClientFor()` method.
+
+- `Predis\CommandPipeline` and `Predis\MultiExecBlock` return their instances
+  when invokink commands, thus allowing method chaining in pipelines and
+  multi-exec blocks.
+
+- `Predis\MultiExecBlock` can handle the new `DISCARD` command.
+
+- Connections now support float values for the `connection_timeout` parameter
+  to express timeouts with a microsecond resolution.
+
+- __FIX__: TCP connections now respect the read/write timeout parameter when
+  reading the payload of server responses. Previously, `stream_get_contents()`
+  was being used internally to read data from a connection but it looks like
+  PHP does not honour the specified timeout for socket streams when inside
+  this function.
+
+- __FIX__: The `GET` parameter for the `SORT` command now accepts also multiple
+  key patterns by passing an array of strings. (ISSUE #1).
+
+* __FIX__: Replies to the `DEL` command return the number of elements deleted
+  by the server and not 0 or 1 interpreted as a boolean response. (ISSUE #4).
+
+
+v0.5.1 (2010-01-23)
+===============================================================================
+
+* `RPOPLPUSH` has been changed from bulk command to inline command in Redis
+  1.2.1, so `ListPopLastPushHead` now extends `InlineCommand`. The old behavior
+  is still available via the `ListPopLastPushHeadBulk` class so that you can
+  override the server profile if you need the old (and uncorrect) behaviour
+  when connecting to a Redis 1.2.0 instance.
+
+* Added missing support for `BGREWRITEAOF` for Redis >= 1.2.0.
+
+* Implemented a factory method for the `RedisServerProfile` class to ease the
+  creation of new server profile instances based on a version string.
+
+
+v0.5.0 (2010-01-09)
+===============================================================================
+* First versioned release of Predis

vendor/predis/predis/CONTRIBUTING.md

@@ -0,0 +1,40 @@
+## Filing bug reports ##
+
+Bugs or feature requests can be posted online 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 the `redis_version` field 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 and 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 by 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 new topic branches
+on your newly created repository to fix or add features (possibly with tests covering your modifications)
+and then open a new pull request with a description of the applied changes. Obviously you can use any
+other Git hosting provider of your preference.
+
+When writing code please follow the [basic coding (PSR-1)](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-1-basic-coding-standard.md)
+and [coding style (PSR-2)](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-2-coding-style-guide.md)
+standards and stick with the conventions used in Predis to name classes and interfaces.
+
+Please also follow some basic [commit guidelines](http://git-scm.com/book/ch5-2.html#Commit-Guidelines)
+before opening pull requests.

vendor/predis/predis/FAQ.md

@@ -0,0 +1,160 @@
+# Some frequently asked questions about Predis #
+_________________________________________________
+
+
+### What is the point of Predis? ###
+
+The main point of Predis is about offering a highly customizable client for Redis that can be easily
+extended by developers while still being reasonabily fast. With Predis you can swap almost any class
+used internally with your own custom implementation: you can build connection classes, or new
+distribution strategies for client-side sharding, or class handlers to replace existing commands or
+add new ones. 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 that allows you to add new and still missing features or commands,
+or change the behaviour of the library without the need to break your dependencies in production code
+(well, at least to some degree).
+
+### Does Predis support UNIX domain sockets and persistent connections? ###
+
+Yes. Obviously, persistent connections actually work when using PHP configured as a persistent process that
+gets recycled between requests (see [PHP-FPM](http://php-fpm.org/)).
+
+
+### Does Predis support transparent (de)serialization of values? ###
+
+No, and it will not ever do that for you 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 the data. This does not
+mean that it is impossible to have such a feature, you can leverage Predis' extensibility to define your
+own serialization-aware commands. See [here](http://github.com/nrk/predis/issues/29#issuecomment-1202624)
+for more details on how to implement such a feature with a practical example.
+
+
+### How can I force Predis to connect to Redis before sending any command? ###
+
+Explicitly connecting to Redis is usually not needed since the client library relies on lazily initialized
+connections to the server, but this behavior can be inconvenient in certain scenarios when you absolutely
+need to do an upfront check to detect if the server is up and running and eventually catch exceptions on
+failures. In this case developers can use `Predis\Client::connect()` to explicitly connect to the server:
+
+```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 implements abstraction of Redis commands? ###
+
+The approach used in Predis to implement the abstraction of Redis commands is quite simple. By default
+every command in the library follows exactly the same argument list as defined in the great online
+[Redis documentation](http://redis.io/commands) which makes things pretty easy if you already know how
+Redis works or if 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. See for
+example how [RPUSH](http://redis.io/commands/rpush) or [HMSET](http://redis.io/commands/hmset) work:
+
+```php
+$client->rpush('my:list', 'value1', 'value2', 'value3');                 // values as arguments
+$client->rpush('my:list', array('value1', 'value2', 'value3'));          // values as single argument array
+
+$client->hmset('my:hash', 'field1', 'value1', 'field2', 'value2');       // values as arguments
+$client->hmset('my:hash', array('field1'=>'value1', 'field2'=>'value2'); // values as single named array
+```
+
+The only exception to this _rule_ is the [SORT](http://redis.io/commands/sort) command for which modifiers are
+[passed using a named array](tests/Predis/Command/KeySortTest.php#L56-77).
+
+
+
+# Frequently asked questions 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 using a single Predis client with PHP 5.4.7 (custom build) and Redis 2.2
+(localhost) under Ubuntu 12.04.1 (running on a Intel Q6600):
+
+    21500 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 a nice C-based extension such as [__phpredis__](http://github.com/nicolasff/phpredis)?
+
+    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__ looks so 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 in a for-loop
+for 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 network by connecting to instances of Redis that
+reside on other servers?
+
+    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 quite simple: network latency
+is a real performance killer and you cannot do (almost) anything about that. As a disclaimer, please
+remember that we are measuring the overhead of client libraries implementations and the effects of the
+network round-trip time, we are not really measuring how fast Redis is. Redis shines the 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 replies (e.g. _KEYS *_) are still worse ###
+
+Fair enough, but there is actually an option for you if you need even more speed and it consists on
+installing __[phpiredis](http://github.com/nrk/phpiredis)__ (note the additional _i_ in the name)
+and let Predis using it. __phpiredis__ is a C-based extension that wraps __hiredis__ (the official
+Redis C client library) with a thin layer that exposes its features to PHP. You can choose between
+two different connection backend classes: `Predis\Connection\PhpiredisConnection` (it depends on the
+`socket` extension) and `Predis\Connection\PhpiredisStreamConnection` (it uses PHP's native streams).
+You will now get the benefits of a faster protocol 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\PhpiredisConnection',
+    	'unix' => 'Predis\Connection\PhpiredisConnection',
+	),
+));
+```
+
+As simple as it is, nothing will really change in the way you use the library in your application. So,
+how fast is it now? There are not much improvements for inline or short bulk replies (e.g. _SET_ or
+_GET_), but the speed for parsing multi-bulk replies is now on par with phpredis:
+
+    Using Predis with a phpiredis-based connection to fetch 30000 keys using _KEYS *_:
+
+    0.035 seconds from a local Redis instance
+    0.047 seconds from a remote Redis instance
+
+
+### If I need to install a C extension to get better performances, why not using phpredis? ###
+
+Good question. Generically speaking, if you need absolute uber-speed using localhost instances of Redis
+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.6, and even the current development version), then
+using __phpredis__ can make sense for you. Otherwise, Predis is perfect for the job. __phpiredis__
+can give you a nice speed bump, but using it is not mandatory.

vendor/predis/predis/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2009-2013 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/README.md

@@ -0,0 +1,263 @@
+# Predis #
+[![Latest Stable Version](https://poser.pugx.org/predis/predis/v/stable.png)](https://packagist.org/packages/predis/predis)
+[![Total Downloads](https://poser.pugx.org/predis/predis/downloads.png)](https://packagist.org/packages/predis/predis)
+
+Predis is a flexible and feature-complete PHP (>= 5.3) client library for the Redis key-value store.
+
+The library does not require any additional extension loaded in PHP but it can be optionally paired
+with the [phpiredis](https://github.com/nrk/phpiredis) C-based extension to lower the overhead of
+serializing and parsing the Redis protocol. Predis is also available in an asynchronous fashion
+through the experimental client provided by the [Predis\Async](http://github.com/nrk/predis-async)
+library.
+
+For a list of frequently asked questions about Predis see our [FAQ](FAQ.md).
+More details are available on the [official wiki](http://wiki.github.com/nrk/predis) of the project.
+
+
+## Main features ##
+
+- Wide range of Redis versions supported (from __1.2__ to __2.6__ and unstable) using server profiles.
+- Smart support for [redis-cluster](http://redis.io/topics/cluster-spec) (Redis >= 3.0).
+- Client-side sharding via consistent hashing or custom distribution strategies.
+- Support for master / slave replication configurations (write on master, read from slaves).
+- Transparent key prefixing strategy capable of handling any command known that has keys in its arguments.
+- Command pipelining on single and aggregated connections.
+- Abstraction for Redis transactions (Redis >= 2.0) with support for CAS operations (Redis >= 2.2).
+- Abstraction for Lua scripting (Redis >= 2.6) capable of automatically switching between `EVAL` and `EVALSHA`.
+- Connections to Redis instances are lazily established upon the first call to a command by the client.
+- Ability to connect to Redis using TCP/IP or UNIX domain sockets with support for persistent connections.
+- Ability to specify alternative connection classes to use different types of network or protocol backends.
+- Flexible system to define and register your own set of commands or server profiles to client instances.
+
+
+## How to use Predis ##
+
+Predis is available on [Packagist](http://packagist.org/packages/predis/predis) for an easy installation
+using [Composer](http://packagist.org/about-composer). Composer helps you manage dependencies for your
+projects and libraries without much hassle which makes it the preferred way to get up and running with
+new applications. Alternatively, the library is available on our [own PEAR channel](http://pear.nrk.io)
+for a more traditional installation via PEAR. Zip and tar.gz archives are also downloadable from GitHub
+by browsing the list of [tagged releases](http://github.com/nrk/predis/tags).
+
+
+### Loading the library ###
+
+Predis relies on the autoloading features of PHP to load its files when needed and complies with the
+[PSR-0 standard](http://github.com/php-fig/fig-standards/blob/master/accepted/PSR-0.md) which makes it
+compatible with most of the major frameworks and libraries. Autoloading in your application is handled
+automatically when managing the dependencies with Composer, but you can also leverage its own autoloader
+class if you are going to use it in a project or script without any PSR-0 compliant autoloading facility:
+
+```php
+<?php
+// prepend a base path if Predis is not present in your "include_path".
+require 'Predis/Autoloader.php';
+
+Predis\Autoloader::register();
+```
+
+It is possible to create a single [Phar](http://www.php.net/manual/en/intro.phar.php) archive from the
+repository just by launching `bin/create-phar.php`. The generated Phar archive ships with a stub defining
+an autoloader function for Predis, so you just need to require the Phar to be able to use the library.
+
+Alternatively it is possible to generate a single PHP file that holds every class, just like older versions
+of Predis, using `bin/create-single-file.php`. In this way you can load Predis in your scripts simply by
+using functions such as `require` and `include`, but this practice is not encouraged.
+
+
+### Connecting to Redis ###
+
+By default Predis uses `127.0.0.1` and `6379` as the default host and port when creating a new client
+instance without specifying any connection parameter:
+
+```php
+$redis = new Predis\Client();
+$redis->set('foo', 'bar');
+$value = $redis->get('foo');
+```
+
+It is possible to specify the various connection parameters using URI strings or named arrays:
+
+```php
+$redis = new Predis\Client('tcp://10.0.0.1:6379');
+
+// is equivalent to:
+
+$redis = new Predis\Client(array(
+    'scheme' => 'tcp',
+    'host'   => '10.0.0.1',
+    'port'   => 6379,
+));
+```
+
+
+### Pipelining commands to multiple instances of Redis with client-side sharding ###
+
+Pipelining helps with performances when there is the need to send many commands to a server in one go.
+Furthermore, pipelining works transparently even on aggregated connections. To achieve this, Predis
+supports client-side sharding using consistent-hashing on keys while clustered connections are supported
+natively by the client class.
+
+```php
+$redis = new Predis\Client(array(
+    array('host' => '10.0.0.1', 'port' => 6379),
+    array('host' => '10.0.0.2', 'port' => 6379)
+));
+
+$replies = $redis->pipeline(function ($pipe) {
+    for ($i = 0; $i < 1000; $i++) {
+        $pipe->set("key:$i", str_pad($i, 4, '0', 0));
+        $pipe->get("key:$i");
+    }
+});
+```
+
+
+### Multiple and customizable connection backends ###
+
+Predis can optionally use different connection backends to connect to Redis. Two of them leverage
+the [phpiredis](http://github.com/nrk/phpiredis) C-based extension resulting in a major speed bump
+especially when dealing with long multibulk replies, namely `Predis\Connection\PhpiredisConnection`
+(the `socket` extension is also required) and `Predis\Connection\StreamPhpiredisConnection` (it
+does not require additional extensions since it relies on PHP's native streams). Both of them can
+connect to Redis using standard TCP/IP connections or UNIX domain sockets:
+
+```php
+$client = new Predis\Client('tcp://127.0.0.1', array(
+    'connections' => array(
+        'tcp'  => 'Predis\Connection\PhpiredisConnection',
+        'unix' => 'Predis\Connection\PhpiredisStreamConnection',
+    )
+));
+```
+
+Developers can also create their own connection backends to add support for new protocols, extend
+existing ones or provide different implementations. Connection backend classes must implement
+`Predis\Connection\SingleConnectionInterface` or extend `Predis\Connection\AbstractConnection`:
+
+```php
+class MyConnectionClass implements Predis\Connection\SingleConnectionInterface
+{
+    // implementation goes here
+}
+
+// Let Predis automatically use your own class to handle connections identified by the tcp scheme.
+$client = new Predis\Client('tcp://127.0.0.1', array(
+    'connections' => array('tcp' => 'MyConnectionClass')
+));
+```
+
+For a more in-depth insight on how to create new connection backends you can look at the actual
+implementation of the classes contained in the `Predis\Connection` namespace.
+
+
+### Defining and registering new commands on the client at runtime ###
+
+Let's suppose Redis just added the support for a brand new feature associated with a new command. If
+you want to start using the above mentioned new feature right away without messing with Predis source
+code or waiting for it to find its way into a stable Predis release, then you can start off by creating
+a new class that matches the command type and its behaviour and then bind it to a client instance at
+runtime. Actually, it is easier done than said:
+
+```php
+class BrandNewRedisCommand extends Predis\Command\AbstractCommand
+{
+    public function getId()
+    {
+        return 'NEWCMD';
+    }
+}
+
+$redis = new Predis\Client();
+$redis->getProfile()->defineCommand('newcmd', 'BrandNewRedisCommand');
+$redis->newcmd();
+```
+
+
+### Abstraction for handling Lua scripts as plain Redis commands ###
+
+A scripted command in Predis is an abstraction for [Lua scripting](http://redis.io/commands/eval)
+with Redis >= 2.6 that allows to use a Lua script as if it was a plain Redis command registered
+in the server profile being used by the client instance. Internally, scripted commands use
+[EVALSHA](http://redis.io/commands/evalsha) to refer to a Lua script by its SHA1 hash in order
+to save bandwidth, but they are capable of falling back to [EVAL](http://redis.io/commands/eval)
+when needed:
+
+```php
+class ListPushRandomValue extends Predis\Command\ScriptedCommand
+{
+    public function getKeysCount()
+    {
+        return 1;
+    }
+
+    public function getScript()
+    {
+        return
+<<<LUA
+math.randomseed(ARGV[1])
+local rnd = tostring(math.random())
+redis.call('lpush', KEYS[1], rnd)
+return rnd
+LUA;
+    }
+}
+
+$client = new Predis\Client();
+$client->getProfile()->defineCommand('lpushrand', 'ListPushRandomValue');
+
+$value = $client->lpushrand('random_values', $seed = mt_rand());
+```
+
+
+## Test suite ##
+
+__ATTENTION__: Do not ever run the test suite shipped with Predis against instances of Redis running in
+production environments or containing data you are interested in!
+
+Predis has a comprehensive test suite covering every aspect of the library. The suite performs integration
+tests against a running instance of Redis (>= 2.4.0 is required) to verify the correct behaviour of the
+implementation of each command and automatically skips commands not defined in the selected version of
+Redis. If you do not have Redis up and running, integration tests can be disabled. By default, the test
+suite is configured to execute integration tests using the server profile for Redis v2.4 (which is the
+current stable version of Redis). You can optionally run the suite against a Redis instance built from
+the `unstable` branch with the development profile by changing the `REDIS_SERVER_VERSION` to `dev` in
+the `phpunit.xml` file. More details on testing Predis can be found in [the tests README](tests/README.md).
+
+Predis uses Travis CI for continuous integration. You can find the results of the test suite and the build
+history [on its project page](http://travis-ci.org/nrk/predis).
+
+
+## Dependencies ##
+
+- PHP >= 5.3.2
+- PHPUnit >= 3.5.0 (needed to run the test suite)
+
+## Links ##
+
+### Project ###
+- [Source code](http://github.com/nrk/predis/)
+- [Wiki](http://wiki.github.com/nrk/predis/)
+- [Issue tracker](http://github.com/nrk/predis/issues)
+- [PEAR channel](http://pear.nrk.io)
+
+### Related ###
+- [Redis](http://redis.io/)
+- [PHP](http://php.net/)
+- [PHPUnit](http://www.phpunit.de/)
+- [Git](http://git-scm.com/)
+
+## Author ##
+
+- [Daniele Alessandri](mailto:suppakilla@gmail.com) ([twitter](http://twitter.com/JoL1hAHN))
+
+## Contributors ##
+
+- [Lorenzo Castelli](http://github.com/lcastelli)
+- [Jordi Boggiano](http://github.com/Seldaek) ([twitter](http://twitter.com/seldaek))
+- [Sebastian Waisbrot](http://github.com/seppo0010) ([twitter](http://twitter.com/seppo0010))
+  for his past work on extending [phpiredis](http://github.com/nrk/phpiredis) for Predis.
+
+## License ##
+
+The code for Predis is distributed under the terms of the MIT license (see [LICENSE](LICENSE)).

vendor/predis/predis/VERSION

@@ -0,0 +1 @@
+0.8.4

vendor/predis/predis/autoload.php

@@ -0,0 +1,14 @@
+<?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__.'/lib/Predis/Autoloader.php';
+
+Predis\Autoloader::register();

vendor/predis/predis/bin/create-phar.php

@@ -0,0 +1,71 @@
+#!/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__ . '/../lib/',
+    '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(\$class, '\\\', '/').'.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/bin/create-single-file.php

@@ -0,0 +1,606 @@
+#!/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 glue all the .php files of Predis
+// into a single monolithic script file that can be used without an autoloader,
+// just like the other previous versions of the library.
+//
+// Much of its complexity is due to the fact that we cannot simply join PHP
+// files, but namespaces and classes definitions must follow a precise order
+// when dealing with subclassing and inheritance.
+//
+// The current implementation is pretty na<6E>ve, but it should do for now.
+// -------------------------------------------------------------------------- //
+
+class CommandLine
+{
+    public static function getOptions()
+    {
+        $parameters = array(
+            's:'  => 'source:',
+            'o:'  => 'output:',
+            'e:'  => 'exclude:',
+            'E:'  => 'exclude-classes:',
+        );
+
+        $getops = getopt(implode(array_keys($parameters)), $parameters);
+
+        $options = array(
+            'source'  => __DIR__ . "/../lib/",
+            'output'  => PredisFile::NS_ROOT . '.php',
+            'exclude' => array(),
+        );
+
+        foreach ($getops as $option => $value) {
+            switch ($option) {
+                case 's':
+                case 'source':
+                    $options['source'] = $value;
+                    break;
+
+                case 'o':
+                case 'output':
+                    $options['output'] = $value;
+                    break;
+
+                case 'E':
+                case 'exclude-classes':
+                    $options['exclude'] = @file($value, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES) ?: $value;
+                    break;
+
+                case 'e':
+                case 'exclude':
+                    $options['exclude'] = is_array($value) ? $value : array($value);
+                    break;
+            }
+        }
+
+        return $options;
+    }
+}
+
+class PredisFile
+{
+    const NS_ROOT = 'Predis';
+
+    private $namespaces;
+
+    public function __construct()
+    {
+        $this->namespaces = array();
+    }
+
+    public static function from($libraryPath, Array $exclude = array())
+    {
+        $nsroot = self::NS_ROOT;
+        $predisFile = new PredisFile();
+        $libIterator = new RecursiveDirectoryIterator("$libraryPath$nsroot");
+
+        foreach (new RecursiveIteratorIterator($libIterator) as $classFile)
+        {
+            if (!$classFile->isFile()) {
+                continue;
+            }
+
+            $namespace = strtr(str_replace($libraryPath, '', $classFile->getPath()), '/', '\\');
+
+            if (in_array(sprintf('%s\\%s', $namespace, $classFile->getBasename('.php')), $exclude)) {
+                continue;
+            }
+
+            $phpNamespace = $predisFile->getNamespace($namespace);
+
+            if ($phpNamespace === false) {
+                $phpNamespace = new PhpNamespace($namespace);
+                $predisFile->addNamespace($phpNamespace);
+            }
+
+            $phpClass = new PhpClass($phpNamespace, $classFile);
+        }
+
+        return $predisFile;
+    }
+
+    public function addNamespace(PhpNamespace $namespace)
+    {
+        if (isset($this->namespaces[(string)$namespace])) {
+            throw new InvalidArgumentException("Duplicated namespace");
+        }
+        $this->namespaces[(string)$namespace] = $namespace;
+    }
+
+    public function getNamespaces()
+    {
+        return $this->namespaces;
+    }
+
+    public function getNamespace($namespace)
+    {
+        if (!isset($this->namespaces[$namespace])) {
+            return false;
+        }
+
+        return $this->namespaces[$namespace];
+    }
+
+    public function getClassByFQN($classFqn)
+    {
+        if (($nsLastPos = strrpos($classFqn, '\\')) !== false) {
+            $namespace = $this->getNamespace(substr($classFqn, 0, $nsLastPos));
+            if ($namespace === false) {
+                return null;
+            }
+            $className = substr($classFqn, $nsLastPos + 1);
+
+            return $namespace->getClass($className);
+        }
+
+        return null;
+    }
+
+    private function calculateDependencyScores(&$classes, $fqn)
+    {
+        if (!isset($classes[$fqn])) {
+            $classes[$fqn] = 0;
+        }
+
+        $classes[$fqn] += 1;
+
+        if (($phpClass = $this->getClassByFQN($fqn)) === null) {
+            throw new RuntimeException(
+                "Cannot found the class $fqn which is required by other subclasses. Are you missing a file?"
+            );
+        }
+
+        foreach ($phpClass->getDependencies() as $fqn) {
+            $this->calculateDependencyScores($classes, $fqn);
+        }
+    }
+
+    private function getDependencyScores()
+    {
+        $classes = array();
+
+        foreach ($this->getNamespaces() as $phpNamespace) {
+            foreach ($phpNamespace->getClasses() as $phpClass) {
+                $this->calculateDependencyScores($classes, $phpClass->getFQN());
+            }
+        }
+
+        return $classes;
+    }
+
+    private function getOrderedNamespaces($dependencyScores)
+    {
+        $namespaces = array_fill_keys(array_unique(
+            array_map(
+                function ($fqn) { return PhpNamespace::extractName($fqn); },
+                array_keys($dependencyScores)
+            )
+        ), 0);
+
+        foreach ($dependencyScores as $classFqn => $score) {
+            $namespaces[PhpNamespace::extractName($classFqn)] += $score;
+        }
+
+        arsort($namespaces);
+
+        return array_keys($namespaces);
+    }
+
+    private function getOrderedClasses(PhpNamespace $phpNamespace, $classes)
+    {
+        $nsClassesFQNs = array_map(function ($cl) { return $cl->getFQN(); }, $phpNamespace->getClasses());
+        $nsOrderedClasses = array();
+
+        foreach ($nsClassesFQNs as $nsClassFQN) {
+            $nsOrderedClasses[$nsClassFQN] = $classes[$nsClassFQN];
+        }
+
+        arsort($nsOrderedClasses);
+
+        return array_keys($nsOrderedClasses);
+    }
+
+    public function getPhpCode()
+    {
+        $buffer = array("<?php\n\n", PhpClass::LICENSE_HEADER, "\n\n");
+        $classes = $this->getDependencyScores();
+        $namespaces = $this->getOrderedNamespaces($classes);
+
+        foreach ($namespaces as $namespace) {
+            $phpNamespace = $this->getNamespace($namespace);
+
+            // generate namespace directive
+            $buffer[] = $phpNamespace->getPhpCode();
+            $buffer[] = "\n";
+
+            // generate use directives
+            $useDirectives = $phpNamespace->getUseDirectives();
+            if (count($useDirectives) > 0) {
+                $buffer[] = $useDirectives->getPhpCode();
+                $buffer[] = "\n";
+            }
+
+            // generate classes bodies
+            $nsClasses = $this->getOrderedClasses($phpNamespace, $classes);
+            foreach ($nsClasses as $classFQN) {
+                $buffer[] = $this->getClassByFQN($classFQN)->getPhpCode();
+                $buffer[] = "\n\n";
+            }
+
+            $buffer[] = "/* " . str_repeat("-", 75) . " */";
+            $buffer[] = "\n\n";
+        }
+
+        return implode($buffer);
+    }
+
+    public function saveTo($outputFile)
+    {
+        // TODO: add more sanity checks
+        if ($outputFile === null || $outputFile === '') {
+            throw new InvalidArgumentException('You must specify a valid output file');
+        }
+        file_put_contents($outputFile, $this->getPhpCode());
+    }
+}
+
+class PhpNamespace implements IteratorAggregate
+{
+    private $namespace;
+    private $classes;
+
+    public function __construct($namespace)
+    {
+        $this->namespace = $namespace;
+        $this->classes = array();
+        $this->useDirectives = new PhpUseDirectives($this);
+    }
+
+    public static function extractName($fqn)
+    {
+        $nsSepLast = strrpos($fqn, '\\');
+        if ($nsSepLast === false) {
+            return $fqn;
+        }
+        $ns = substr($fqn, 0, $nsSepLast);
+
+        return $ns !== '' ? $ns : null;
+    }
+
+    public function addClass(PhpClass $class)
+    {
+        $this->classes[$class->getName()] = $class;
+    }
+
+    public function getClass($className)
+    {
+        if (isset($this->classes[$className])) {
+            return $this->classes[$className];
+        }
+    }
+
+    public function getClasses()
+    {
+        return array_values($this->classes);
+    }
+
+    public function getIterator()
+    {
+        return new \ArrayIterator($this->getClasses());
+    }
+
+    public function getUseDirectives()
+    {
+        return $this->useDirectives;
+    }
+
+    public function getPhpCode()
+    {
+        return "namespace $this->namespace;\n";
+    }
+
+    public function __toString()
+    {
+        return $this->namespace;
+    }
+}
+
+class PhpUseDirectives implements Countable, IteratorAggregate
+{
+    private $use;
+    private $aliases;
+    private $namespace;
+
+    public function __construct(PhpNamespace $namespace)
+    {
+        $this->use = array();
+        $this->aliases = array();
+        $this->namespace = $namespace;
+    }
+
+    public function add($use, $as = null)
+    {
+        if (in_array($use, $this->use)) {
+            return;
+        }
+
+        $this->use[] = $use;
+        $this->aliases[$as ?: PhpClass::extractName($use)] = $use;
+    }
+
+    public function getList()
+    {
+        return $this->use;
+    }
+
+    public function getIterator()
+    {
+        return new \ArrayIterator($this->getList());
+    }
+
+    public function getPhpCode()
+    {
+        $reducer = function ($str, $use) {
+            return $str .= "use $use;\n";
+        };
+
+        return array_reduce($this->getList(), $reducer, '');
+    }
+
+    public function getNamespace()
+    {
+        return $this->namespace;
+    }
+
+    public function getFQN($className)
+    {
+        if (($nsSepFirst = strpos($className, '\\')) === false) {
+            if (isset($this->aliases[$className])) {
+                return $this->aliases[$className];
+            }
+
+            return (string)$this->getNamespace() . "\\$className";
+        }
+
+        if ($nsSepFirst != 0) {
+            throw new InvalidArgumentException("Partially qualified names are not supported");
+        }
+
+        return $className;
+    }
+
+    public function count()
+    {
+        return count($this->use);
+    }
+}
+
+class PhpClass
+{
+    const LICENSE_HEADER = <<<LICENSE
+/*
+ * 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.
+ */
+LICENSE;
+
+    private $namespace;
+    private $file;
+    private $body;
+    private $implements;
+    private $extends;
+    private $name;
+
+    public function __construct(PhpNamespace $namespace, SplFileInfo $classFile)
+    {
+        $this->namespace = $namespace;
+        $this->file = $classFile;
+        $this->implements = array();
+        $this->extends = array();
+
+        $this->extractData();
+        $namespace->addClass($this);
+    }
+
+    public static function extractName($fqn)
+    {
+        $nsSepLast = strrpos($fqn, '\\');
+        if ($nsSepLast === false) {
+            return $fqn;
+        }
+
+        return substr($fqn, $nsSepLast + 1);
+    }
+
+    private function extractData()
+    {
+        $useDirectives = $this->getNamespace()->getUseDirectives();
+
+        $useExtractor = function ($m) use ($useDirectives) {
+            $useDirectives->add(($namespacedPath = $m[1]));
+        };
+
+        $classBuffer = stream_get_contents(fopen($this->getFile()->getPathname(), 'r'));
+
+        $classBuffer = str_replace(self::LICENSE_HEADER, '', $classBuffer);
+
+        $classBuffer = preg_replace('/<\?php\s?\\n\s?/', '', $classBuffer);
+        $classBuffer = preg_replace('/\s?\?>\n?/ms', '', $classBuffer);
+        $classBuffer = preg_replace('/namespace\s+[\w\d_\\\\]+;\s?/', '', $classBuffer);
+        $classBuffer = preg_replace_callback('/use\s+([\w\d_\\\\]+)(\s+as\s+.*)?;\s?\n?/', $useExtractor, $classBuffer);
+
+        $this->body = trim($classBuffer);
+
+        $this->extractHierarchy();
+    }
+
+    private function extractHierarchy()
+    {
+        $implements = array();
+        $extends =  array();
+
+        $extractor = function ($iterator, $callback) {
+            $className = '';
+            $iterator->seek($iterator->key() + 1);
+
+            while ($iterator->valid()) {
+                $token = $iterator->current();
+
+                if (is_string($token)) {
+                    if (preg_match('/\s?,\s?/', $token)) {
+                        $callback(trim($className));
+                        $className = '';
+                    } else if ($token == '{') {
+                        $callback(trim($className));
+                        return;
+                    }
+                }
+
+                switch ($token[0]) {
+                    case T_NS_SEPARATOR:
+                        $className .= '\\';
+                        break;
+
+                    case T_STRING:
+                        $className .= $token[1];
+                        break;
+
+                    case T_IMPLEMENTS:
+                    case T_EXTENDS:
+                        $callback(trim($className));
+                        $iterator->seek($iterator->key() - 1);
+                        return;
+                }
+
+                $iterator->next();
+            }
+        };
+
+        $tokens = token_get_all("<?php\n" . trim($this->getPhpCode()));
+        $iterator = new ArrayIterator($tokens);
+
+        while ($iterator->valid()) {
+            $token = $iterator->current();
+            if (is_string($token)) {
+                $iterator->next();
+                continue;
+            }
+
+            switch ($token[0]) {
+                case T_CLASS:
+                case T_INTERFACE:
+                    $iterator->seek($iterator->key() + 2);
+                    $tk = $iterator->current();
+                    $this->name = $tk[1];
+                    break;
+
+                case T_IMPLEMENTS:
+                    $extractor($iterator, function ($fqn) use (&$implements) {
+                        $implements[] = $fqn;
+                    });
+                    break;
+
+                case T_EXTENDS:
+                    $extractor($iterator, function ($fqn) use (&$extends) {
+                        $extends[] = $fqn;
+                    });
+                    break;
+            }
+
+            $iterator->next();
+        }
+
+        $this->implements = $this->guessFQN($implements);
+        $this->extends = $this->guessFQN($extends);
+    }
+
+    public function guessFQN($classes)
+    {
+        $useDirectives = $this->getNamespace()->getUseDirectives();
+        return array_map(array($useDirectives, 'getFQN'), $classes);
+    }
+
+    public function getImplementedInterfaces($all = false)
+    {
+        if ($all) {
+            return $this->implements;
+        }
+
+        return array_filter(
+            $this->implements,
+            function ($cn) { return strpos($cn, 'Predis\\') === 0; }
+        );
+    }
+
+    public function getExtendedClasses($all = false)
+    {
+        if ($all) {
+            return $this->extemds;
+        }
+
+        return array_filter(
+            $this->extends,
+            function ($cn) { return strpos($cn, 'Predis\\') === 0; }
+        );
+    }
+
+    public function getDependencies($all = false)
+    {
+        return array_merge(
+            $this->getImplementedInterfaces($all),
+            $this->getExtendedClasses($all)
+        );
+    }
+
+    public function getNamespace()
+    {
+        return $this->namespace;
+    }
+
+    public function getFile()
+    {
+        return $this->file;
+    }
+
+    public function getName()
+    {
+        return $this->name;
+    }
+
+    public function getFQN()
+    {
+        return (string)$this->getNamespace() . '\\' . $this->name;
+    }
+
+    public function getPhpCode()
+    {
+        return $this->body;
+    }
+
+    public function __toString()
+    {
+        return "class " . $this->getName() . '{ ... }';
+    }
+}
+
+/* -------------------------------------------------------------------------- */
+
+$options = CommandLine::getOptions();
+$predisFile = PredisFile::from($options['source'], $options['exclude']);
+$predisFile->saveTo($options['output']);

vendor/predis/predis/bin/generate-command-test.php

@@ -0,0 +1,273 @@
+#!/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.php --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',
+        );
+
+        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'] = "Predis/Command/{$options['class']}.php";
+
+        $source = __DIR__.'/../lib/'.$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.");
+        }
+
+        $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;
+
+use \PHPUnit_Framework_TestCase as StandardTestCase;
+
+/**
+ * @group commands
+ * @group realm-$realm
+ */
+class $class extends CommandTestCase
+{
+    /**
+     * {@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/composer.json

@@ -0,0 +1,25 @@
+{
+    "name": "predis/predis",
+    "type": "library",
+    "description": "Flexible and feature-complete PHP client library for Redis",
+    "keywords": ["nosql", "redis", "predis"],
+    "homepage": "http://github.com/nrk/predis",
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "Daniele Alessandri",
+            "email": "suppakilla@gmail.com",
+            "homepage": "http://clorophilla.net"
+        }
+    ],
+    "require": {
+        "php": ">=5.3.2"
+    },
+    "suggest": {
+        "ext-phpiredis": "Allows faster serialization and deserialization of the Redis protocol",
+        "ext-curl": "Allows access to Webdis when paired with phpiredis"
+    },
+    "autoload": {
+        "psr-0": {"Predis": "lib/"}
+    }
+}

vendor/predis/predis/examples/CustomDistributionStrategy.php

@@ -0,0 +1,89 @@
+<?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 'SharedConfigurations.php';
+
+// Developers can customize the distribution strategy used by the client
+// to distribute keys among a cluster of servers simply by creating a class
+// that implements Predis\Distribution\DistributionStrategyInterface.
+
+use Predis\Connection\PredisCluster;
+use Predis\Cluster\Distribution\DistributionStrategyInterface;
+use Predis\Cluster\Hash\HashGeneratorInterface;
+
+class NaiveDistributionStrategy implements DistributionStrategyInterface, 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 get($key)
+    {
+        if (0 === $count = $this->nodesCount) {
+            throw new RuntimeException('No connections');
+        }
+
+        return $this->nodes[$count > 1 ? abs($key % $count) : 0];
+    }
+
+    public function hash($value)
+    {
+        return crc32($value);
+    }
+
+    public function getHashGenerator()
+    {
+        return $this;
+    }
+}
+
+$options = array(
+    'cluster' => function () {
+        $distributor = new NaiveDistributionStrategy();
+        $cluster = new PredisCluster($distributor);
+
+        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();
+
+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/DispatcherLoop.php

@@ -0,0 +1,78 @@
+<?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 'SharedConfigurations.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));
+
+// Create a Predis\DispatcherLoop instance and attach a bunch of callbacks.
+$dispatcher = new Predis\PubSub\DispatcherLoop($client);
+
+// Demonstrate how to use a callable class as a callback for Predis\DispatcherLoop.
+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!\n";
+
+// Say goodbye :-)
+$info = $client->info();
+print_r("Goodbye from Redis v{$info['redis_version']}!\n");

vendor/predis/predis/examples/KeyPrefixes.php

@@ -0,0 +1,37 @@
+<?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 'SharedConfigurations.php';
+
+// Predis ships with a KeyPrefixProcessor class that is used to transparently
+// prefix each key before sending commands to Redis, even for complex commands
+// such as SORT, ZUNIONSTORE and ZINTERSTORE. Key prefixes are useful to create
+// user-level namespaces for you keyspace, thus eliminating the need for separate
+// logical databases.
+
+$client = new Predis\Client($single_server, array('prefix' => 'nrk:'));
+
+$client->mset(array('foo' => 'bar', 'lol' => 'wut'));
+var_dump($client->mget('foo', 'lol'));
+/*
+array(2) {
+  [0]=> string(3) "bar"
+  [1]=> string(3) "wut"
+}
+*/
+
+var_dump($client->keys('*'));
+/*
+array(2) {
+  [0]=> string(7) "nrk:foo"
+  [1]=> string(7) "nrk:lol"
+}
+*/

vendor/predis/predis/examples/MasterSlaveReplication.php

@@ -0,0 +1,52 @@
+<?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 'SharedConfigurations.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 behaviour of commands or EVAL scripts can be customized at will.
+// As soon as a write operation is performed, all the subsequent requests (reads
+// or writes) will be served by the master server.
+//
+// This example must be executed with the second Redis server acting as the slave
+// of the first one using 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.\n";
+
+// Write operation.
+$client->set('foo', 'bar');
+$current = $client->getConnection()->getCurrent()->getParameters();
+echo "Now 'foo' has been set to 'bar' on {$current->alias}!\n";
+
+// Read operation.
+$bar = $client->get('foo');
+$current = $client->getConnection()->getCurrent()->getParameters();
+echo "We just fetched 'foo' from {$current->alias} and its value is '$bar'.\n";
+
+/* OUTPUT:
+Does 'foo' exist on slave? yes.
+Now 'foo' has been set to 'bar' on master!
+We just fetched 'foo' from master and its value is 'bar'.
+*/

vendor/predis/predis/examples/MasterSlaveReplicationComplex.php

@@ -0,0 +1,84 @@
+<?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 'SharedConfigurations.php';
+
+// Predis allows to set Lua scripts as read-only operations in the context of
+// replication. This works for both EVAL and EVALSHA and also for the client-side
+// abstraction built upon them (Predis\Command\ScriptedCommand). This example
+// shows a slightly more complex configuration that injects a new scripted 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\ScriptedCommand;
+use Predis\Connection\MasterSlaveReplication;
+use Predis\Profile\ServerProfile;
+use Predis\Replication\ReplicationStrategy;
+
+// ------------------------------------------------------------------------- //
+
+// Define a new scripted command that returns all the fields
+// of a variable number of hashes with a single roundtrip.
+
+class HashMultipleGetAll extends ScriptedCommand {
+    const BODY = <<<EOS
+local hashes = {}
+for _, key in pairs(KEYS) do
+    table.insert(hashes, key)
+    table.insert(hashes, redis.call('hgetall', key))
+end
+return hashes
+EOS;
+
+    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 ($options) {
+        $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', "!\n";
+var_export($hashes);

vendor/predis/predis/examples/MonitorContext.php

@@ -0,0 +1,44 @@
+<?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 'SharedConfigurations.php';
+
+// This is a basic example on how to use the Predis\MonitorContext 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 close the
+    // monitor context and then break the loop.
+    if ($event->command === 'ECHO' && $event->arguments === '"QUIT_MONITOR"') {
+        echo "Exiting the monitor loop...\n";
+        $monitor->closeContext();
+        break;
+    }
+
+    echo "* Received {$event->command} on DB {$event->database} at {$timestamp->format(DateTime::W3C)}\n";
+    if (isset($event->arguments)) {
+        echo "    Arguments: {$event->arguments}\n";
+    }
+}
+
+// Say goodbye :-)
+$info = $client->info();
+print_r("Goodbye from Redis v{$info['redis_version']}!\n");

vendor/predis/predis/examples/MultiBulkReplyIterators.php

@@ -0,0 +1,56 @@
+<?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 'SharedConfigurations.php';
+
+// Operations such as LRANGE, ZRANGE and others can potentially generate replies
+// containing a huge number of items. In some corner cases, such replies might
+// end up exhausting the maximum allowed memory allocated for a PHP process.
+// Multibulk iterators can be handy because they allow you to stream multibulk
+// replies using plain old PHP iterators, making it possible to iterate them with
+// a classic `foreach` loop and avoiding to consume an excessive amount of memory.
+//
+// PS: please note that multibulk iterators are supported only by the standard
+// connection backend class (Predis\Connection\StreamConnection) and not the
+// phpiredis-based one (Predis\Connection\PhpiredisConnection).
+
+// Create a client and force the connection to use iterable multibulk responses.
+$client = new Predis\Client($single_server + array('iterable_multibulk' => true));
+
+// Prepare an hash with some fields and their respective values.
+$client->hmset('metavars', array('foo' => 'bar', 'hoge' => 'piyo', 'lol' => 'wut'));
+
+// By default multibulk iterators iterate over the reply as a list of items...
+foreach ($client->hgetall('metavars') as $index => $item) {
+    echo "[$index] $item\n";
+}
+
+/* OUTPUT:
+[0] foo
+[1] bar
+[2] hoge
+[3] piyo
+[4] lol
+[5] wut
+*/
+
+// ... but certain multibulk replies are better represented as lists of tuples.
+foreach ($client->hgetall('metavars')->asTuple() as $index => $kv) {
+    list($key, $value) = $kv;
+
+    echo "[$index] $key => $value\n";
+}
+
+/* OUTPUT:
+[0] foo => bar
+[1] hoge => piyo
+[2] lol => wut
+*/

vendor/predis/predis/examples/MultiExecTransactionsWithCAS.php

@@ -0,0 +1,51 @@
+<?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 'SharedConfigurations.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
+// ZADD zset 2 b
+// ZADD zset 3 c
+
+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->multiExec($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!", "\n";

vendor/predis/predis/examples/MultipleSetAndGet.php

@@ -0,0 +1,38 @@
+<?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 'SharedConfigurations.php';
+
+// redis can set keys and their relative values in one go
+// using MSET, then the same values can be retrieved with
+// a single command using MGET.
+
+$mkv = array(
+    'usr:0001' => 'First user',
+    'usr:0002' => 'Second user',
+    'usr:0003' => 'Third user'
+);
+
+$client = new Predis\Client($single_server);
+
+$client->mset($mkv);
+$retval = $client->mget(array_keys($mkv));
+
+print_r($retval);
+
+/* OUTPUT:
+Array
+(
+    [0] => First user
+    [1] => Second user
+    [2] => Third user
+)
+*/

vendor/predis/predis/examples/PipelineContext.php

@@ -0,0 +1,47 @@
+<?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 'SharedConfigurations.php';
+
+// When you have a whole set of consecutive commands to send to
+// a redis server, you can use a pipeline to improve performances.
+
+$client = new Predis\Client($single_server);
+
+$replies = $client->pipeline(function ($pipe) {
+    $pipe->ping();
+    $pipe->flushdb();
+    $pipe->incrby('counter', 10);
+    $pipe->incrby('counter', 30);
+    $pipe->exists('counter');
+    $pipe->get('counter');
+    $pipe->mget('does_not_exist', 'counter');
+});
+
+print_r($replies);
+
+/* OUTPUT:
+Array
+(
+    [0] => 1
+    [1] => 1
+    [2] => 10
+    [3] => 40
+    [4] => 1
+    [5] => 40
+    [6] => Array
+        (
+            [0] =>
+            [1] => 40
+        )
+
+)
+*/

vendor/predis/predis/examples/PubSubContext.php

@@ -0,0 +1,59 @@
+<?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 'SharedConfigurations.php';
+
+// Redis 2.0 features new commands that allow clients to subscribe for
+// events published on certain channels (PUBSUB).
+
+// 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 context
+$pubsub = $client->pubSub();
+
+// 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}\n";
+            break;
+
+        case 'message':
+            if ($message->channel == 'control_channel') {
+                if ($message->payload == 'quit_loop') {
+                    echo "Aborting pubsub loop...\n";
+                    $pubsub->unsubscribe();
+                } else {
+                    echo "Received an unrecognized command: {$message->payload}.\n";
+                }
+            } else {
+                echo "Received the following message from {$message->channel}:\n",
+                     "  {$message->payload}\n\n";
+            }
+            break;
+    }
+}
+
+// Always unset the pubsub context 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 :-)
+$info = $client->info();
+print_r("Goodbye from Redis v{$info['redis_version']}!\n");

vendor/predis/predis/examples/ServerSideScripting.php

@@ -0,0 +1,66 @@
+<?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 'SharedConfigurations.php';
+
+// This example will not work with versions of Redis < 2.6.
+//
+// Additionally to the EVAL command defined in the current development profile, the new
+// Predis\Command\ScriptedCommand base class can be used to build an higher abstraction
+// for our "scripted" 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\ScriptedCommand;
+
+class IncrementExistingKeysBy extends ScriptedCommand
+{
+    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);
+
+$client->getProfile()->defineCommand('increxby', 'IncrementExistingKeysBy');
+
+$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/SessionHandler.php

@@ -0,0 +1,39 @@
+<?php
+
+require 'SharedConfigurations.php';
+
+// This example demonstrates how to leverage Predis to save PHP sessions on Redis.
+//
+// The value of `session.gc_maxlifetime` in `php.ini` will be used by default as the
+// the TTL for keys holding session data on Redis, but this value can be overridden
+// when creating the session handler instance with the `gc_maxlifetime` option.
+//
+// Note that this class needs PHP >= 5.4 but can be used on PHP 5.3 if a polyfill for
+// SessionHandlerInterface (see http://www.php.net/class.sessionhandlerinterface.php)
+// is provided either by you or an external package like `symfony/http-foundation`.
+
+if (!interface_exists('SessionHandlerInterface')) {
+    die("ATTENTION: the session handler implemented by Predis needs PHP >= 5.4.0 or a polyfill ".
+        "for \SessionHandlerInterface either provided by you or an external package.\n");
+}
+
+// Instantiate a new client just like you would normally do. We'll prefix our session keys here.
+$client = new Predis\Client($single_server, array('prefix' => 'sessions:'));
+
+// Set `gc_maxlifetime` so that a session will be expired after 5 seconds since last access.
+$handler = new Predis\Session\SessionHandler($client, array('gc_maxlifetime' => 5));
+
+// Register our session handler (it uses `session_set_save_handler()` internally).
+$handler->register();
+
+// Set a fixed session ID just 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']}\n";
+} else {
+    $_SESSION['foo'] = $value = mt_rand();
+    echo "Empty session, `foo` has been set with $value\n";
+}

vendor/predis/predis/examples/SharedConfigurations.php

@@ -0,0 +1,33 @@
+<?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';
+
+$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/SimpleDebuggableConnection.php

@@ -0,0 +1,88 @@
+<?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 'SharedConfigurations.php';
+
+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 writeCommand(CommandInterface $command)
+    {
+        parent::writeCommand($command);
+
+        $this->storeDebug($command, '->');
+    }
+
+    public function readResponse(CommandInterface $command)
+    {
+        $reply = parent::readResponse($command);
+        $this->storeDebug($command, '<-');
+
+        return $reply;
+    }
+
+    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();
+
+print_r($client->getConnection()->getDebugBuffer());
+
+/* OUTPUT:
+Array
+(
+    [0] => SELECT 15 -> 127.0.0.1:6379 [0.0008s]
+    [1] => SELECT 15 <- 127.0.0.1:6379 [0.0012s]
+    [2] => SET foo -> 127.0.0.1:6379 [0.0014s]
+    [3] => SET foo <- 127.0.0.1:6379 [0.0014s]
+    [4] => GET foo -> 127.0.0.1:6379 [0.0016s]
+    [5] => GET foo <- 127.0.0.1:6379 [0.0018s]
+    [6] => INFO -> 127.0.0.1:6379 [0.002s]
+    [7] => INFO <- 127.0.0.1:6379 [0.0025s]
+)
+*/

vendor/predis/predis/examples/SimpleSetAndGet.php

@@ -0,0 +1,25 @@
+<?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 'SharedConfigurations.php';
+
+// simple set and get scenario
+
+$client = new Predis\Client($single_server);
+
+$client->set('library', 'predis');
+$retval = $client->get('library');
+
+var_dump($retval);
+
+/* OUTPUT
+string(6) "predis"
+*/

vendor/predis/predis/lib/Predis/Autoloader.php

@@ -0,0 +1,62 @@
+<?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.
+ *
+ * @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 boolean $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/lib/Predis/BasicClientInterface.php

@@ -0,0 +1,31 @@
+<?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;
+
+/**
+ * Defines the interface of a basic client object or abstraction that
+ * can send commands to Redis.
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+interface BasicClientInterface
+{
+    /**
+     * Executes the specified Redis command.
+     *
+     * @param CommandInterface $command A Redis command.
+     * @return mixed
+     */
+    public function executeCommand(CommandInterface $command);
+}

vendor/predis/predis/lib/Predis/Client.php

@@ -0,0 +1,436 @@
+<?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\Command\ScriptedCommand;
+use Predis\Connection\AggregatedConnectionInterface;
+use Predis\Connection\ConnectionInterface;
+use Predis\Connection\ConnectionFactoryInterface;
+use Predis\Monitor\MonitorContext;
+use Predis\Option\ClientOptions;
+use Predis\Option\ClientOptionsInterface;
+use Predis\Pipeline\PipelineContext;
+use Predis\Profile\ServerProfile;
+use Predis\PubSub\PubSubContext;
+use Predis\Transaction\MultiExecContext;
+
+/**
+ * Main class that exposes the most high-level interface to interact with Redis.
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class Client implements ClientInterface
+{
+    const VERSION = '0.8.4';
+
+    private $options;
+    private $profile;
+    private $connection;
+
+    /**
+     * Initializes a new client with optional connection parameters and client options.
+     *
+     * @param mixed $parameters Connection parameters for one or multiple servers.
+     * @param mixed $options Options that specify certain behaviours for the client.
+     */
+    public function __construct($parameters = null, $options = null)
+    {
+        $this->options = $this->filterOptions($options);
+        $this->profile = $this->options->profile;
+        $this->connection = $this->initializeConnection($parameters);
+    }
+
+    /**
+     * Creates an instance of Predis\Option\ClientOptions from various types of
+     * arguments (string, array, Predis\Profile\ServerProfile) or returns the
+     * passed object if it is an instance of Predis\Option\ClientOptions.
+     *
+     * @param mixed $options Client options.
+     * @return ClientOptions
+     */
+    protected function filterOptions($options)
+    {
+        if (!isset($options)) {
+            return new ClientOptions();
+        }
+
+        if (is_array($options)) {
+            return new ClientOptions($options);
+        }
+
+        if ($options instanceof ClientOptionsInterface) {
+            return $options;
+        }
+
+        throw new \InvalidArgumentException("Invalid type for client options");
+    }
+
+    /**
+     * Initializes one or multiple connection (cluster) objects from various
+     * types of arguments (string, array) or returns the passed object if it
+     * implements Predis\Connection\ConnectionInterface.
+     *
+     * @param mixed $parameters Connection parameters or instance.
+     * @return ConnectionInterface
+     */
+    protected function initializeConnection($parameters)
+    {
+        if ($parameters instanceof ConnectionInterface) {
+            return $parameters;
+        }
+
+        if (is_array($parameters) && isset($parameters[0])) {
+            $options = $this->options;
+            $replication = isset($options->replication) && $options->replication;
+            $connection = $options->{$replication ? 'replication' : 'cluster'};
+
+            return $options->connections->createAggregated($connection, $parameters);
+        }
+
+        if (is_callable($parameters)) {
+            $connection = call_user_func($parameters, $this->options);
+
+            if (!$connection instanceof ConnectionInterface) {
+                throw new \InvalidArgumentException(
+                    'Callable parameters must return instances of Predis\Connection\ConnectionInterface'
+                );
+            }
+
+            return $connection;
+        }
+
+        return $this->options->connections->create($parameters);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getProfile()
+    {
+        return $this->profile;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getOptions()
+    {
+        return $this->options;
+    }
+
+    /**
+     * Returns the connection factory object used by the client.
+     *
+     * @return ConnectionFactoryInterface
+     */
+    public function getConnectionFactory()
+    {
+        return $this->options->connections;
+    }
+
+    /**
+     * Returns a new instance of a client for the specified connection when the
+     * client is connected to a cluster. The new instance will use the same
+     * options of the original client.
+     *
+     * @return Client
+     */
+    public function getClientFor($connectionID)
+    {
+        if (!$connection = $this->getConnectionById($connectionID)) {
+            throw new \InvalidArgumentException("Invalid connection ID: '$connectionID'");
+        }
+
+        return new static($connection, $this->options);
+    }
+
+    /**
+     * Opens the connection to the server.
+     */
+    public function connect()
+    {
+        $this->connection->connect();
+    }
+
+    /**
+     * Disconnects from the server.
+     */
+    public function disconnect()
+    {
+        $this->connection->disconnect();
+    }
+
+    /**
+     * Disconnects from the server.
+     *
+     * This method is an alias of disconnect().
+     */
+    public function quit()
+    {
+        $this->disconnect();
+    }
+
+    /**
+     * Checks if the underlying connection is connected to Redis.
+     *
+     * @return Boolean True means that the connection is open.
+     *                 False means that the connection is closed.
+     */
+    public function isConnected()
+    {
+        return $this->connection->isConnected();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getConnection()
+    {
+        return $this->connection;
+    }
+
+    /**
+     * Retrieves a single connection out of an aggregated connections instance.
+     *
+     * @param string $connectionId Index or alias of the connection.
+     * @return Connection\SingleConnectionInterface
+     */
+    public function getConnectionById($connectionId)
+    {
+        if (!$this->connection instanceof AggregatedConnectionInterface) {
+            throw new NotSupportedException('Retrieving connections by ID is supported only when using aggregated connections');
+        }
+
+        return $this->connection->getConnectionById($connectionId);
+    }
+
+    /**
+     * Dynamically invokes a Redis command with the specified arguments.
+     *
+     * @param string $method The name of a Redis command.
+     * @param array $arguments The arguments for the command.
+     * @return mixed
+     */
+    public function __call($method, $arguments)
+    {
+        $command = $this->profile->createCommand($method, $arguments);
+        $response = $this->connection->executeCommand($command);
+
+        if ($response instanceof ResponseObjectInterface) {
+            if ($response instanceof ResponseErrorInterface) {
+                $response = $this->onResponseError($command, $response);
+            }
+
+            return $response;
+        }
+
+        return $command->parseResponse($response);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function createCommand($method, $arguments = array())
+    {
+        return $this->profile->createCommand($method, $arguments);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function executeCommand(CommandInterface $command)
+    {
+        $response = $this->connection->executeCommand($command);
+
+        if ($response instanceof ResponseObjectInterface) {
+            if ($response instanceof ResponseErrorInterface) {
+                $response = $this->onResponseError($command, $response);
+            }
+
+            return $response;
+        }
+
+        return $command->parseResponse($response);
+    }
+
+    /**
+     * Handles -ERR responses returned by Redis.
+     *
+     * @param CommandInterface $command The command that generated the error.
+     * @param ResponseErrorInterface $response The error response instance.
+     * @return mixed
+     */
+    protected function onResponseError(CommandInterface $command, ResponseErrorInterface $response)
+    {
+        if ($command instanceof ScriptedCommand && $response->getErrorType() === 'NOSCRIPT') {
+            $eval = $this->createCommand('eval');
+            $eval->setRawArguments($command->getEvalArguments());
+
+            $response = $this->executeCommand($eval);
+
+            if (!$response instanceof ResponseObjectInterface) {
+                $response = $command->parseResponse($response);
+            }
+
+            return $response;
+        }
+
+        if ($this->options->exceptions) {
+            throw new ServerException($response->getMessage());
+        }
+
+        return $response;
+    }
+
+    /**
+     * Calls the specified initializer method on $this with 0, 1 or 2 arguments.
+     *
+     * TODO: Invert $argv and $initializer.
+     *
+     * @param array $argv Arguments for the initializer.
+     * @param string $initializer The initializer method.
+     * @return mixed
+     */
+    private function sharedInitializer($argv, $initializer)
+    {
+        switch (count($argv)) {
+            case 0:
+                return $this->$initializer();
+
+            case 1:
+                list($arg0) = $argv;
+                return is_array($arg0) ? $this->$initializer($arg0) : $this->$initializer(null, $arg0);
+
+            case 2:
+                list($arg0, $arg1) = $argv;
+                return $this->$initializer($arg0, $arg1);
+
+            default:
+                return $this->$initializer($this, $argv);
+        }
+    }
+
+    /**
+     * Creates a new pipeline context and returns it, or returns the results of
+     * a pipeline executed inside the optionally provided callable object.
+     *
+     * @param mixed $arg,... Options for the context, a callable object, or both.
+     * @return PipelineContext|array
+     */
+    public function pipeline(/* arguments */)
+    {
+        return $this->sharedInitializer(func_get_args(), 'initPipeline');
+    }
+
+    /**
+     * Pipeline context initializer.
+     *
+     * @param array $options Options for the context.
+     * @param mixed $callable Optional callable object used to execute the context.
+     * @return PipelineContext|array
+     */
+    protected function initPipeline(Array $options = null, $callable = null)
+    {
+        $executor = isset($options['executor']) ? $options['executor'] : null;
+
+        if (is_callable($executor)) {
+            $executor = call_user_func($executor, $this, $options);
+        }
+
+        $pipeline = new PipelineContext($this, $executor);
+        $replies  = $this->pipelineExecute($pipeline, $callable);
+
+        return $replies;
+    }
+
+    /**
+     * Executes a pipeline context when a callable object is passed.
+     *
+     * @param array $options Options of the context initialization.
+     * @param mixed $callable Optional callable object used to execute the context.
+     * @return PipelineContext|array
+     */
+    private function pipelineExecute(PipelineContext $pipeline, $callable)
+    {
+        return isset($callable) ? $pipeline->execute($callable) : $pipeline;
+    }
+
+    /**
+     * Creates a new transaction context and returns it, or returns the results of
+     * a transaction executed inside the optionally provided callable object.
+     *
+     * @param mixed $arg,... Options for the context, a callable object, or both.
+     * @return MultiExecContext|array
+     */
+    public function multiExec(/* arguments */)
+    {
+        return $this->sharedInitializer(func_get_args(), 'initMultiExec');
+    }
+
+    /**
+     * Transaction context initializer.
+     *
+     * @param array $options Options for the context.
+     * @param mixed $callable Optional callable object used to execute the context.
+     * @return MultiExecContext|array
+     */
+    protected function initMultiExec(Array $options = null, $callable = null)
+    {
+        $transaction = new MultiExecContext($this, $options ?: array());
+        return isset($callable) ? $transaction->execute($callable) : $transaction;
+    }
+
+    /**
+     * Creates a new Publish / Subscribe context and returns it, or executes it
+     * inside the optionally provided callable object.
+     *
+     * @param mixed $arg,... Options for the context, a callable object, or both.
+     * @return MultiExecContext|array
+     */
+    public function pubSub(/* arguments */)
+    {
+        return $this->sharedInitializer(func_get_args(), 'initPubSub');
+    }
+
+    /**
+     * Publish / Subscribe context initializer.
+     *
+     * @param array $options Options for the context.
+     * @param mixed $callable Optional callable object used to execute the context.
+     * @return PubSubContext
+     */
+    protected function initPubSub(Array $options = null, $callable = null)
+    {
+        $pubsub = new PubSubContext($this, $options);
+
+        if (!isset($callable)) {
+            return $pubsub;
+        }
+
+        foreach ($pubsub as $message) {
+            if (call_user_func($callable, $pubsub, $message) === false) {
+                $pubsub->closeContext();
+            }
+        }
+    }
+
+    /**
+     * Returns a new monitor context.
+     *
+     * @return MonitorContext
+     */
+    public function monitor()
+    {
+        return new MonitorContext($this);
+    }
+}

vendor/predis/predis/lib/Predis/ClientException.php

@@ -0,0 +1,21 @@
+<?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/lib/Predis/ClientInterface.php

@@ -0,0 +1,66 @@
+<?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\Connection\ConnectionInterface;
+use Predis\Option\ClientOptionsInterface;
+use Predis\Profile\ServerProfileInterface;
+
+/**
+ * Interface defining the most important parts needed to create an
+ * high-level Redis client object that can interact with other
+ * building blocks of Predis.
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+interface ClientInterface extends BasicClientInterface
+{
+    /**
+     * Returns the server profile used by the client.
+     *
+     * @return ServerProfileInterface
+     */
+    public function getProfile();
+
+    /**
+     * Returns the client options specified upon initialization.
+     *
+     * @return ClientOptionsInterface
+     */
+    public function getOptions();
+
+    /**
+     * Opens the connection to the server.
+     */
+    public function connect();
+
+    /**
+     * Disconnects 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 The name of a Redis command.
+     * @param array $arguments The arguments for the command.
+     * @return Command\CommandInterface
+     */
+    public function createCommand($method, $arguments = array());
+}

vendor/predis/predis/lib/Predis/Cluster/CommandHashStrategyInterface.php

@@ -0,0 +1,42 @@
+<?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\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 CommandHashStrategyInterface
+{
+    /**
+     * Returns the hash for the given command using the specified algorithm, or null
+     * if the command cannot be hashed.
+     *
+     * @param CommandInterface $command Command to be hashed.
+     * @return int
+     */
+    public function getHash(CommandInterface $command);
+
+    /**
+     * Returns the hash for the given key using the specified algorithm.
+     *
+     * @param string $key Key to be hashed.
+     * @return string
+     */
+    public function getKeyHash($key);
+}

vendor/predis/predis/lib/Predis/Cluster/Distribution/DistributionStrategyInterface.php

@@ -0,0 +1,52 @@
+<?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\Distribution;
+
+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 DistributionStrategyInterface
+{
+    /**
+     * 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);
+
+    /**
+     * Gets a node from the distributor using the computed hash of a key.
+     *
+     * @return mixed
+     */
+    public function get($key);
+
+    /**
+     * Returns the underlying hash generator instance.
+     *
+     * @return HashGeneratorInterface
+     */
+    public function getHashGenerator();
+}

vendor/predis/predis/lib/Predis/Cluster/Distribution/EmptyRingException.php

@@ -0,0 +1,21 @@
+<?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\Distribution;
+
+/**
+ * Exception class that identifies empty rings.
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class EmptyRingException extends \Exception
+{
+}

vendor/predis/predis/lib/Predis/Cluster/Distribution/HashRing.php

@@ -0,0 +1,246 @@
+<?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\Distribution;
+
+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 DistributionStrategyInterface, 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 the string used to calculate the hash of a node.
+     */
+    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 Boolean
+     */
+    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 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 ($this->nodeHashCallback === null) {
+            return (string) $nodeObject;
+        }
+
+        return call_user_func($this->nodeHashCallback, $nodeObject);
+    }
+
+    /**
+     * Calculates the hash for the specified value.
+     *
+     * @param string $value Input value.
+     * @return int
+     */
+    public function hash($value)
+    {
+        return crc32($value);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function get($key)
+    {
+        return $this->ring[$this->getNodeKey($key)];
+    }
+
+    /**
+     * Calculates the corrisponding key of a node distributed in the hashring.
+     *
+     * @param int $key Computed hash of a key.
+     * @return int
+     */
+    private function getNodeKey($key)
+    {
+        $this->initialize();
+        $ringKeys = $this->ringKeys;
+        $upper = $this->ringKeysCount - 1;
+        $lower = 0;
+
+        while ($lower <= $upper) {
+            $index = ($lower + $upper) >> 1;
+            $item  = $ringKeys[$index];
+
+            if ($item > $key) {
+                $upper = $index - 1;
+            } else if ($item < $key) {
+                $lower = $index + 1;
+            } else {
+                return $item;
+            }
+        }
+
+        return $ringKeys[$this->wrapAroundStrategy($upper, $lower, $this->ringKeysCount)];
+    }
+
+    /**
+     * 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/lib/Predis/Cluster/Distribution/KetamaPureRing.php

@@ -0,0 +1,70 @@
+<?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\Distribution;
+
+/**
+ * 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 KetamaPureRing extends HashRing
+{
+    const DEFAULT_REPLICAS = 160;
+
+    /**
+     * @param mixed $nodeHashCallback Callback returning the string used to calculate the hash of a node.
+     */
+    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/lib/Predis/Cluster/Hash/CRC16HashGenerator.php

@@ -0,0 +1,72 @@
+<?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;
+
+/**
+ * This class implements the CRC-CCITT-16 algorithm used by redis-cluster.
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class CRC16HashGenerator 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/lib/Predis/Cluster/Hash/HashGeneratorInterface.php

@@ -0,0 +1,29 @@
+<?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;
+
+/**
+ * A generator of node keys implements the logic used to calculate the hash of
+ * a key to distribute the respective operations among nodes.
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+interface HashGeneratorInterface
+{
+    /**
+     * Generates an hash that is used by the distributor algorithm
+     *
+     * @param string $value Value used to generate the hash.
+     * @return int
+     */
+    public function hash($value);
+}

vendor/predis/predis/lib/Predis/Cluster/PredisClusterHashStrategy.php

@@ -0,0 +1,385 @@
+<?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\HashGeneratorInterface;
+use Predis\Command\CommandInterface;
+use Predis\Command\ScriptedCommand;
+
+/**
+ * Default class used by Predis for client-side sharding to calculate
+ * hashes out of keys of supported commands.
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class PredisClusterHashStrategy implements CommandHashStrategyInterface
+{
+    private $commands;
+    private $hashGenerator;
+
+    /**
+     * @param HashGeneratorInterface $hashGenerator Hash generator instance.
+     */
+    public function __construct(HashGeneratorInterface $hashGenerator)
+    {
+        $this->commands = $this->getDefaultCommands();
+        $this->hashGenerator = $hashGenerator;
+    }
+
+    /**
+     * Returns the default map of supported commands with their handlers.
+     *
+     * @return array
+     */
+    protected function getDefaultCommands()
+    {
+        $keyIsFirstArgument = array($this, 'getKeyFromFirstArgument');
+        $keysAreAllArguments = array($this, 'getKeyFromAllArguments');
+
+        return array(
+            /* commands operating on the key space */
+            'EXISTS'                => $keyIsFirstArgument,
+            'DEL'                   => $keysAreAllArguments,
+            'TYPE'                  => $keyIsFirstArgument,
+            'EXPIRE'                => $keyIsFirstArgument,
+            'EXPIREAT'              => $keyIsFirstArgument,
+            'PERSIST'               => $keyIsFirstArgument,
+            'PEXPIRE'               => $keyIsFirstArgument,
+            'PEXPIREAT'             => $keyIsFirstArgument,
+            'TTL'                   => $keyIsFirstArgument,
+            'PTTL'                  => $keyIsFirstArgument,
+            'SORT'                  => $keyIsFirstArgument, // TODO
+            'DUMP'                  => $keyIsFirstArgument,
+            'RESTORE'               => $keyIsFirstArgument,
+
+            /* commands operating on string values */
+            'APPEND'                => $keyIsFirstArgument,
+            'DECR'                  => $keyIsFirstArgument,
+            'DECRBY'                => $keyIsFirstArgument,
+            'GET'                   => $keyIsFirstArgument,
+            'GETBIT'                => $keyIsFirstArgument,
+            'MGET'                  => $keysAreAllArguments,
+            'SET'                   => $keyIsFirstArgument,
+            'GETRANGE'              => $keyIsFirstArgument,
+            'GETSET'                => $keyIsFirstArgument,
+            'INCR'                  => $keyIsFirstArgument,
+            'INCRBY'                => $keyIsFirstArgument,
+            'SETBIT'                => $keyIsFirstArgument,
+            'SETEX'                 => $keyIsFirstArgument,
+            'MSET'                  => array($this, 'getKeyFromInterleavedArguments'),
+            'MSETNX'                => array($this, 'getKeyFromInterleavedArguments'),
+            'SETNX'                 => $keyIsFirstArgument,
+            'SETRANGE'              => $keyIsFirstArgument,
+            'STRLEN'                => $keyIsFirstArgument,
+            'SUBSTR'                => $keyIsFirstArgument,
+            'BITOP'                 => array($this, 'getKeyFromBitOp'),
+            'BITCOUNT'              => $keyIsFirstArgument,
+
+            /* commands operating on lists */
+            'LINSERT'               => $keyIsFirstArgument,
+            'LINDEX'                => $keyIsFirstArgument,
+            'LLEN'                  => $keyIsFirstArgument,
+            'LPOP'                  => $keyIsFirstArgument,
+            'RPOP'                  => $keyIsFirstArgument,
+            'RPOPLPUSH'             => $keysAreAllArguments,
+            'BLPOP'                 => array($this, 'getKeyFromBlockingListCommands'),
+            'BRPOP'                 => array($this, 'getKeyFromBlockingListCommands'),
+            'BRPOPLPUSH'            => array($this, 'getKeyFromBlockingListCommands'),
+            'LPUSH'                 => $keyIsFirstArgument,
+            'LPUSHX'                => $keyIsFirstArgument,
+            'RPUSH'                 => $keyIsFirstArgument,
+            'RPUSHX'                => $keyIsFirstArgument,
+            'LRANGE'                => $keyIsFirstArgument,
+            'LREM'                  => $keyIsFirstArgument,
+            'LSET'                  => $keyIsFirstArgument,
+            'LTRIM'                 => $keyIsFirstArgument,
+
+            /* commands operating on sets */
+            'SADD'                  => $keyIsFirstArgument,
+            'SCARD'                 => $keyIsFirstArgument,
+            'SDIFF'                 => $keysAreAllArguments,
+            'SDIFFSTORE'            => $keysAreAllArguments,
+            'SINTER'                => $keysAreAllArguments,
+            'SINTERSTORE'           => $keysAreAllArguments,
+            'SUNION'                => $keysAreAllArguments,
+            'SUNIONSTORE'           => $keysAreAllArguments,
+            'SISMEMBER'             => $keyIsFirstArgument,
+            'SMEMBERS'              => $keyIsFirstArgument,
+            'SPOP'                  => $keyIsFirstArgument,
+            'SRANDMEMBER'           => $keyIsFirstArgument,
+            'SREM'                  => $keyIsFirstArgument,
+
+            /* commands operating on sorted sets */
+            'ZADD'                  => $keyIsFirstArgument,
+            'ZCARD'                 => $keyIsFirstArgument,
+            'ZCOUNT'                => $keyIsFirstArgument,
+            'ZINCRBY'               => $keyIsFirstArgument,
+            'ZINTERSTORE'           => array($this, 'getKeyFromZsetAggregationCommands'),
+            'ZRANGE'                => $keyIsFirstArgument,
+            'ZRANGEBYSCORE'         => $keyIsFirstArgument,
+            'ZRANK'                 => $keyIsFirstArgument,
+            'ZREM'                  => $keyIsFirstArgument,
+            'ZREMRANGEBYRANK'       => $keyIsFirstArgument,
+            'ZREMRANGEBYSCORE'      => $keyIsFirstArgument,
+            'ZREVRANGE'             => $keyIsFirstArgument,
+            'ZREVRANGEBYSCORE'      => $keyIsFirstArgument,
+            'ZREVRANK'              => $keyIsFirstArgument,
+            'ZSCORE'                => $keyIsFirstArgument,
+            'ZUNIONSTORE'           => array($this, 'getKeyFromZsetAggregationCommands'),
+
+            /* commands operating on hashes */
+            'HDEL'                  => $keyIsFirstArgument,
+            'HEXISTS'               => $keyIsFirstArgument,
+            'HGET'                  => $keyIsFirstArgument,
+            'HGETALL'               => $keyIsFirstArgument,
+            'HMGET'                 => $keyIsFirstArgument,
+            'HMSET'                 => $keyIsFirstArgument,
+            'HINCRBY'               => $keyIsFirstArgument,
+            'HINCRBYFLOAT'          => $keyIsFirstArgument,
+            'HKEYS'                 => $keyIsFirstArgument,
+            'HLEN'                  => $keyIsFirstArgument,
+            'HSET'                  => $keyIsFirstArgument,
+            'HSETNX'                => $keyIsFirstArgument,
+            'HVALS'                 => $keyIsFirstArgument,
+
+            /* scripting */
+            'EVAL'                  => array($this, 'getKeyFromScriptingCommands'),
+            'EVALSHA'               => array($this, 'getKeyFromScriptingCommands'),
+        );
+    }
+
+    /**
+     * Returns the list of IDs for the supported commands.
+     *
+     * @return array
+     */
+    public function getSupportedCommands()
+    {
+        return array_keys($this->commands);
+    }
+
+    /**
+     * Sets an handler for the specified command ID.
+     *
+     * The signature of the callback must have a single parameter
+     * of type Predis\Command\CommandInterface.
+     *
+     * When the callback argument is omitted or NULL, the previously
+     * associated handler for the specified command ID is removed.
+     *
+     * @param string $commandId The ID of the command to be handled.
+     * @param mixed $callback A valid callable object or NULL.
+     */
+    public function setCommandHandler($commandId, $callback = null)
+    {
+        $commandId = strtoupper($commandId);
+
+        if (!isset($callback)) {
+            unset($this->commands[$commandId]);
+            return;
+        }
+
+        if (!is_callable($callback)) {
+            throw new \InvalidArgumentException("Callback must be a valid callable object or NULL");
+        }
+
+        $this->commands[$commandId] = $callback;
+    }
+
+    /**
+     * Extracts the key from the first argument of a command instance.
+     *
+     * @param CommandInterface $command Command instance.
+     * @return string
+     */
+    protected function getKeyFromFirstArgument(CommandInterface $command)
+    {
+        return $command->getArgument(0);
+    }
+
+    /**
+     * Extracts the key from a command with multiple keys only when all keys
+     * in the arguments array produce the same hash.
+     *
+     * @param CommandInterface $command Command instance.
+     * @return string
+     */
+    protected function getKeyFromAllArguments(CommandInterface $command)
+    {
+        $arguments = $command->getArguments();
+
+        if ($this->checkSameHashForKeys($arguments)) {
+            return $arguments[0];
+        }
+    }
+
+    /**
+     * Extracts the key from a command with multiple keys only when all keys
+     * in the arguments array produce the same hash.
+     *
+     * @param CommandInterface $command Command instance.
+     * @return string
+     */
+    protected function getKeyFromInterleavedArguments(CommandInterface $command)
+    {
+        $arguments = $command->getArguments();
+        $keys = array();
+
+        for ($i = 0; $i < count($arguments); $i += 2) {
+            $keys[] = $arguments[$i];
+        }
+
+        if ($this->checkSameHashForKeys($keys)) {
+            return $arguments[0];
+        }
+    }
+
+    /**
+     * Extracts the key from BLPOP and BRPOP commands.
+     *
+     * @param CommandInterface $command Command instance.
+     * @return string
+     */
+    protected function getKeyFromBlockingListCommands(CommandInterface $command)
+    {
+        $arguments = $command->getArguments();
+
+        if ($this->checkSameHashForKeys(array_slice($arguments, 0, count($arguments) - 1))) {
+            return $arguments[0];
+        }
+    }
+
+    /**
+     * Extracts the key from BITOP command.
+     *
+     * @param CommandInterface $command Command instance.
+     * @return string
+     */
+    protected function getKeyFromBitOp(CommandInterface $command)
+    {
+        $arguments = $command->getArguments();
+
+        if ($this->checkSameHashForKeys(array_slice($arguments, 1, count($arguments)))) {
+            return $arguments[1];
+        }
+    }
+
+    /**
+     * Extracts the key from ZINTERSTORE and ZUNIONSTORE commands.
+     *
+     * @param CommandInterface $command Command instance.
+     * @return string
+     */
+    protected function getKeyFromZsetAggregationCommands(CommandInterface $command)
+    {
+        $arguments = $command->getArguments();
+        $keys = array_merge(array($arguments[0]), array_slice($arguments, 2, $arguments[1]));
+
+        if ($this->checkSameHashForKeys($keys)) {
+            return $arguments[0];
+        }
+    }
+
+    /**
+     * Extracts the key from EVAL and EVALSHA commands.
+     *
+     * @param CommandInterface $command Command instance.
+     * @return string
+     */
+    protected function getKeyFromScriptingCommands(CommandInterface $command)
+    {
+        if ($command instanceof ScriptedCommand) {
+            $keys = $command->getKeys();
+        } else {
+            $keys = array_slice($args = $command->getArguments(), 2, $args[1]);
+        }
+
+        if ($keys && $this->checkSameHashForKeys($keys)) {
+            return $keys[0];
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getHash(CommandInterface $command)
+    {
+        $hash = $command->getHash();
+
+        if (!isset($hash) && isset($this->commands[$cmdID = $command->getId()])) {
+            $key = call_user_func($this->commands[$cmdID], $command);
+
+            if (isset($key)) {
+                $hash = $this->getKeyHash($key);
+                $command->setHash($hash);
+            }
+        }
+
+        return $hash;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getKeyHash($key)
+    {
+        $key = $this->extractKeyTag($key);
+        $hash = $this->hashGenerator->hash($key);
+
+        return $hash;
+    }
+
+    /**
+     * Checks if the specified array of keys will generate the same hash.
+     *
+     * @param array $keys Array of keys.
+     * @return Boolean
+     */
+    protected function checkSameHashForKeys(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;
+    }
+
+    /**
+     * Returns only the hashable part of a key (delimited by "{...}"), or the
+     * whole key if a key tag is not found in the string.
+     *
+     * @param string $key A key.
+     * @return string
+     */
+    protected function extractKeyTag($key)
+    {
+        if (false !== $start = strpos($key, '{')) {
+            if (false !== $end = strpos($key, '}', $start)) {
+                $key = substr($key, ++$start, $end - $start);
+            }
+        }
+
+        return $key;
+    }
+}

vendor/predis/predis/lib/Predis/Cluster/RedisClusterHashStrategy.php

@@ -0,0 +1,288 @@
+<?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\CRC16HashGenerator;
+use Predis\Command\CommandInterface;
+use Predis\Command\ScriptedCommand;
+
+/**
+ * Default class used by Predis to calculate hashes out of keys of
+ * commands supported by redis-cluster.
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class RedisClusterHashStrategy implements CommandHashStrategyInterface
+{
+    private $commands;
+    private $hashGenerator;
+
+    /**
+     *
+     */
+    public function __construct()
+    {
+        $this->commands = $this->getDefaultCommands();
+        $this->hashGenerator = new CRC16HashGenerator();
+    }
+
+    /**
+     * Returns the default map of supported commands with their handlers.
+     *
+     * @return array
+     */
+    protected function getDefaultCommands()
+    {
+        $keyIsFirstArgument = array($this, 'getKeyFromFirstArgument');
+
+        return array(
+            /* commands operating on the key space */
+            'EXISTS'                => $keyIsFirstArgument,
+            'DEL'                   => array($this, 'getKeyFromAllArguments'),
+            'TYPE'                  => $keyIsFirstArgument,
+            'EXPIRE'                => $keyIsFirstArgument,
+            'EXPIREAT'              => $keyIsFirstArgument,
+            'PERSIST'               => $keyIsFirstArgument,
+            'PEXPIRE'               => $keyIsFirstArgument,
+            'PEXPIREAT'             => $keyIsFirstArgument,
+            'TTL'                   => $keyIsFirstArgument,
+            'PTTL'                  => $keyIsFirstArgument,
+            'SORT'                  => $keyIsFirstArgument, // TODO
+
+            /* commands operating on string values */
+            'APPEND'                => $keyIsFirstArgument,
+            'DECR'                  => $keyIsFirstArgument,
+            'DECRBY'                => $keyIsFirstArgument,
+            'GET'                   => $keyIsFirstArgument,
+            'GETBIT'                => $keyIsFirstArgument,
+            'MGET'                  => array($this, 'getKeyFromAllArguments'),
+            'SET'                   => $keyIsFirstArgument,
+            'GETRANGE'              => $keyIsFirstArgument,
+            'GETSET'                => $keyIsFirstArgument,
+            'INCR'                  => $keyIsFirstArgument,
+            'INCRBY'                => $keyIsFirstArgument,
+            'SETBIT'                => $keyIsFirstArgument,
+            'SETEX'                 => $keyIsFirstArgument,
+            'MSET'                  => array($this, 'getKeyFromInterleavedArguments'),
+            'MSETNX'                => array($this, 'getKeyFromInterleavedArguments'),
+            'SETNX'                 => $keyIsFirstArgument,
+            'SETRANGE'              => $keyIsFirstArgument,
+            'STRLEN'                => $keyIsFirstArgument,
+            'SUBSTR'                => $keyIsFirstArgument,
+            'BITCOUNT'              => $keyIsFirstArgument,
+
+            /* commands operating on lists */
+            'LINSERT'               => $keyIsFirstArgument,
+            'LINDEX'                => $keyIsFirstArgument,
+            'LLEN'                  => $keyIsFirstArgument,
+            'LPOP'                  => $keyIsFirstArgument,
+            'RPOP'                  => $keyIsFirstArgument,
+            'BLPOP'                 => array($this, 'getKeyFromBlockingListCommands'),
+            'BRPOP'                 => array($this, 'getKeyFromBlockingListCommands'),
+            'LPUSH'                 => $keyIsFirstArgument,
+            'LPUSHX'                => $keyIsFirstArgument,
+            'RPUSH'                 => $keyIsFirstArgument,
+            'RPUSHX'                => $keyIsFirstArgument,
+            'LRANGE'                => $keyIsFirstArgument,
+            'LREM'                  => $keyIsFirstArgument,
+            'LSET'                  => $keyIsFirstArgument,
+            'LTRIM'                 => $keyIsFirstArgument,
+
+            /* commands operating on sets */
+            'SADD'                  => $keyIsFirstArgument,
+            'SCARD'                 => $keyIsFirstArgument,
+            'SISMEMBER'             => $keyIsFirstArgument,
+            'SMEMBERS'              => $keyIsFirstArgument,
+            'SPOP'                  => $keyIsFirstArgument,
+            'SRANDMEMBER'           => $keyIsFirstArgument,
+            'SREM'                  => $keyIsFirstArgument,
+
+            /* commands operating on sorted sets */
+            'ZADD'                  => $keyIsFirstArgument,
+            'ZCARD'                 => $keyIsFirstArgument,
+            'ZCOUNT'                => $keyIsFirstArgument,
+            'ZINCRBY'               => $keyIsFirstArgument,
+            'ZRANGE'                => $keyIsFirstArgument,
+            'ZRANGEBYSCORE'         => $keyIsFirstArgument,
+            'ZRANK'                 => $keyIsFirstArgument,
+            'ZREM'                  => $keyIsFirstArgument,
+            'ZREMRANGEBYRANK'       => $keyIsFirstArgument,
+            'ZREMRANGEBYSCORE'      => $keyIsFirstArgument,
+            'ZREVRANGE'             => $keyIsFirstArgument,
+            'ZREVRANGEBYSCORE'      => $keyIsFirstArgument,
+            'ZREVRANK'              => $keyIsFirstArgument,
+            'ZSCORE'                => $keyIsFirstArgument,
+
+            /* commands operating on hashes */
+            'HDEL'                  => $keyIsFirstArgument,
+            'HEXISTS'               => $keyIsFirstArgument,
+            'HGET'                  => $keyIsFirstArgument,
+            'HGETALL'               => $keyIsFirstArgument,
+            'HMGET'                 => $keyIsFirstArgument,
+            'HMSET'                 => $keyIsFirstArgument,
+            'HINCRBY'               => $keyIsFirstArgument,
+            'HINCRBYFLOAT'          => $keyIsFirstArgument,
+            'HKEYS'                 => $keyIsFirstArgument,
+            'HLEN'                  => $keyIsFirstArgument,
+            'HSET'                  => $keyIsFirstArgument,
+            'HSETNX'                => $keyIsFirstArgument,
+            'HVALS'                 => $keyIsFirstArgument,
+
+            /* scripting */
+            'EVAL'                  => array($this, 'getKeyFromScriptingCommands'),
+            'EVALSHA'               => array($this, 'getKeyFromScriptingCommands'),
+        );
+    }
+
+    /**
+     * Returns the list of IDs for the supported commands.
+     *
+     * @return array
+     */
+    public function getSupportedCommands()
+    {
+        return array_keys($this->commands);
+    }
+
+    /**
+     * Sets an handler for the specified command ID.
+     *
+     * The signature of the callback must have a single parameter
+     * of type Predis\Command\CommandInterface.
+     *
+     * When the callback argument is omitted or NULL, the previously
+     * associated handler for the specified command ID is removed.
+     *
+     * @param string $commandId The ID of the command to be handled.
+     * @param mixed $callback A valid callable object or NULL.
+     */
+    public function setCommandHandler($commandId, $callback = null)
+    {
+        $commandId = strtoupper($commandId);
+
+        if (!isset($callback)) {
+            unset($this->commands[$commandId]);
+            return;
+        }
+
+        if (!is_callable($callback)) {
+            throw new \InvalidArgumentException("Callback must be a valid callable object or NULL");
+        }
+
+        $this->commands[$commandId] = $callback;
+    }
+
+    /**
+     * Extracts the key from the first argument of a command instance.
+     *
+     * @param CommandInterface $command Command instance.
+     * @return string
+     */
+    protected function getKeyFromFirstArgument(CommandInterface $command)
+    {
+        return $command->getArgument(0);
+    }
+
+    /**
+     * Extracts the key from a command that can accept multiple keys ensuring
+     * that only one key is actually specified to comply with redis-cluster.
+     *
+     * @param CommandInterface $command Command instance.
+     * @return string
+     */
+    protected function getKeyFromAllArguments(CommandInterface $command)
+    {
+        $arguments = $command->getArguments();
+
+        if (count($arguments) === 1) {
+            return $arguments[0];
+        }
+    }
+
+    /**
+     * Extracts the key from a command that can accept multiple keys ensuring
+     * that only one key is actually specified to comply with redis-cluster.
+     *
+     * @param CommandInterface $command Command instance.
+     * @return string
+     */
+    protected function getKeyFromInterleavedArguments(CommandInterface $command)
+    {
+        $arguments = $command->getArguments();
+
+        if (count($arguments) === 2) {
+            return $arguments[0];
+        }
+    }
+
+    /**
+     * Extracts the key from BLPOP and BRPOP commands ensuring that only one key
+     * is actually specified to comply with redis-cluster.
+     *
+     * @param CommandInterface $command Command instance.
+     * @return string
+     */
+    protected function getKeyFromBlockingListCommands(CommandInterface $command)
+    {
+        $arguments = $command->getArguments();
+
+        if (count($arguments) === 2) {
+            return $arguments[0];
+        }
+    }
+
+    /**
+     * Extracts the key from EVAL and EVALSHA commands.
+     *
+     * @param CommandInterface $command Command instance.
+     * @return string
+     */
+    protected function getKeyFromScriptingCommands(CommandInterface $command)
+    {
+        if ($command instanceof ScriptedCommand) {
+            $keys = $command->getKeys();
+        } else {
+            $keys = array_slice($args = $command->getArguments(), 2, $args[1]);
+        }
+
+        if (count($keys) === 1) {
+            return $keys[0];
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getHash(CommandInterface $command)
+    {
+        $hash = $command->getHash();
+
+        if (!isset($hash) && isset($this->commands[$cmdID = $command->getId()])) {
+            $key = call_user_func($this->commands[$cmdID], $command);
+
+            if (isset($key)) {
+                $hash = $this->hashGenerator->hash($key);
+                $command->setHash($hash);
+            }
+        }
+
+        return $hash;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getKeyHash($key)
+    {
+        return $this->hashGenerator->hash($key);
+    }
+}

vendor/predis/predis/lib/Predis/Command/AbstractCommand.php

@@ -0,0 +1,162 @@
+<?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 AbstractCommand implements CommandInterface
+{
+    private $hash;
+    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->hash);
+    }
+
+    /**
+     * Sets the arguments array without filtering.
+     *
+     * @param array $arguments List of arguments.
+     */
+    public function setRawArguments(Array $arguments)
+    {
+        $this->arguments = $arguments;
+        unset($this->hash);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getArguments()
+    {
+        return $this->arguments;
+    }
+
+    /**
+     * Gets the argument from the arguments list at the specified index.
+     *
+     * @param array $arguments Position of the argument.
+     */
+    public function getArgument($index)
+    {
+        if (isset($this->arguments[$index])) {
+            return $this->arguments[$index];
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function setHash($hash)
+    {
+        $this->hash = $hash;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getHash()
+    {
+        if (isset($this->hash)) {
+            return $this->hash;
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function parseResponse($data)
+    {
+        return $data;
+    }
+
+    /**
+     * Helper function used to reduce a list of arguments to a string.
+     *
+     * @param string $accumulator Temporary string.
+     * @param string $argument Current argument.
+     * @return string
+     */
+    protected function toStringArgumentReducer($accumulator, $argument)
+    {
+        if (strlen($argument) > 32) {
+            $argument = substr($argument, 0, 32) . '[...]';
+        }
+
+        $accumulator .= " $argument";
+
+        return $accumulator;
+    }
+
+    /**
+     * Returns a partial string representation of the command with its arguments.
+     *
+     * @return string
+     */
+    public function __toString()
+    {
+        return array_reduce(
+            $this->getArguments(),
+            array($this, 'toStringArgumentReducer'),
+            $this->getId()
+        );
+    }
+
+    /**
+     * 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/lib/Predis/Command/CommandInterface.php

@@ -0,0 +1,76 @@
+<?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
+{
+    /**
+     * Gets the ID of a Redis command.
+     *
+     * @return string
+     */
+    public function getId();
+
+    /**
+     * Set the hash for the command.
+     *
+     * @param int $hash Calculated hash.
+     */
+    public function setHash($hash);
+
+    /**
+     * Returns the hash of the command.
+     *
+     * @return int
+     */
+    public function getHash();
+
+    /**
+     * 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.
+     *
+     * @return array
+     */
+    public function getArgument($index);
+
+    /**
+     * Parses a reply buffer and returns a PHP object.
+     *
+     * @param string $data Binary string containing the whole reply.
+     * @return mixed
+     */
+    public function parseResponse($data);
+}

vendor/predis/predis/lib/Predis/Command/ConnectionAuth.php

@@ -0,0 +1,27 @@
+<?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 AbstractCommand
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'AUTH';
+    }
+}

vendor/predis/predis/lib/Predis/Command/ConnectionEcho.php

@@ -0,0 +1,27 @@
+<?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 AbstractCommand
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'ECHO';
+    }
+}

vendor/predis/predis/lib/Predis/Command/ConnectionPing.php

@@ -0,0 +1,35 @@
+<?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 AbstractCommand
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'PING';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function parseResponse($data)
+    {
+        return $data === 'PONG' ? true : false;
+    }
+}

vendor/predis/predis/lib/Predis/Command/ConnectionQuit.php

@@ -0,0 +1,27 @@
+<?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 AbstractCommand
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'QUIT';
+    }
+}

vendor/predis/predis/lib/Predis/Command/ConnectionSelect.php

@@ -0,0 +1,27 @@
+<?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 AbstractCommand
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'SELECT';
+    }
+}

vendor/predis/predis/lib/Predis/Command/HashDelete.php

@@ -0,0 +1,35 @@
+<?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 PrefixableCommand
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'HDEL';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function filterArguments(Array $arguments)
+    {
+        return self::normalizeVariadic($arguments);
+    }
+}

vendor/predis/predis/lib/Predis/Command/HashExists.php

@@ -0,0 +1,35 @@
+<?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 PrefixableCommand
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'HEXISTS';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function parseResponse($data)
+    {
+        return (bool) $data;
+    }
+}

vendor/predis/predis/lib/Predis/Command/HashGet.php

@@ -0,0 +1,27 @@
+<?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 PrefixableCommand
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'HGET';
+    }
+}

vendor/predis/predis/lib/Predis/Command/HashGetAll.php

@@ -0,0 +1,41 @@
+<?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 PrefixableCommand
+{
+    /**
+     * {@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/lib/Predis/Command/HashGetMultiple.php

@@ -0,0 +1,35 @@
+<?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 PrefixableCommand
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'HMGET';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function filterArguments(Array $arguments)
+    {
+        return self::normalizeVariadic($arguments);
+    }
+}

vendor/predis/predis/lib/Predis/Command/HashIncrementBy.php

@@ -0,0 +1,27 @@
+<?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 PrefixableCommand
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'HINCRBY';
+    }
+}

vendor/predis/predis/lib/Predis/Command/HashIncrementByFloat.php

@@ -0,0 +1,27 @@
+<?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 PrefixableCommand
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'HINCRBYFLOAT';
+    }
+}

vendor/predis/predis/lib/Predis/Command/HashKeys.php

@@ -0,0 +1,27 @@
+<?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 PrefixableCommand
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'HKEYS';
+    }
+}

vendor/predis/predis/lib/Predis/Command/HashLength.php

@@ -0,0 +1,27 @@
+<?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 PrefixableCommand
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'HLEN';
+    }
+}

vendor/predis/predis/lib/Predis/Command/HashSet.php

@@ -0,0 +1,35 @@
+<?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/hset
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class HashSet extends PrefixableCommand
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'HSET';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function parseResponse($data)
+    {
+        return (bool) $data;
+    }
+}

vendor/predis/predis/lib/Predis/Command/HashSetMultiple.php

@@ -0,0 +1,47 @@
+<?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/hmset
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class HashSetMultiple extends PrefixableCommand
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'HMSET';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function filterArguments(Array $arguments)
+    {
+        if (count($arguments) === 2 && is_array($arguments[1])) {
+            $flattenedKVs = array($arguments[0]);
+            $args = $arguments[1];
+
+            foreach ($args as $k => $v) {
+                $flattenedKVs[] = $k;
+                $flattenedKVs[] = $v;
+            }
+
+            return $flattenedKVs;
+        }
+
+        return $arguments;
+    }
+}

vendor/predis/predis/lib/Predis/Command/HashSetPreserve.php

@@ -0,0 +1,35 @@
+<?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/hsetnx
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class HashSetPreserve extends PrefixableCommand
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'HSETNX';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function parseResponse($data)
+    {
+        return (bool) $data;
+    }
+}

vendor/predis/predis/lib/Predis/Command/HashValues.php

@@ -0,0 +1,27 @@
+<?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/hvals
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class HashValues extends PrefixableCommand
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'HVALS';
+    }
+}

vendor/predis/predis/lib/Predis/Command/KeyDelete.php

@@ -0,0 +1,43 @@
+<?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/del
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class KeyDelete extends AbstractCommand implements PrefixableCommandInterface
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'DEL';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function filterArguments(Array $arguments)
+    {
+        return self::normalizeArguments($arguments);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function prefixKeys($prefix)
+    {
+        PrefixHelpers::all($this, $prefix);
+    }
+}

vendor/predis/predis/lib/Predis/Command/KeyDump.php

@@ -0,0 +1,27 @@
+<?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/dump
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class KeyDump extends PrefixableCommand
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'DUMP';
+    }
+}

vendor/predis/predis/lib/Predis/Command/KeyExists.php

@@ -0,0 +1,35 @@
+<?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/exists
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class KeyExists extends PrefixableCommand
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'EXISTS';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function parseResponse($data)
+    {
+        return (bool) $data;
+    }
+}

vendor/predis/predis/lib/Predis/Command/KeyExpire.php

@@ -0,0 +1,35 @@
+<?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/expire
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class KeyExpire extends PrefixableCommand
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'EXPIRE';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function parseResponse($data)
+    {
+        return (bool) $data;
+    }
+}

vendor/predis/predis/lib/Predis/Command/KeyExpireAt.php

@@ -0,0 +1,35 @@
+<?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/expireat
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class KeyExpireAt extends PrefixableCommand
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'EXPIREAT';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function parseResponse($data)
+    {
+        return (bool) $data;
+    }
+}

vendor/predis/predis/lib/Predis/Command/KeyKeys.php

@@ -0,0 +1,27 @@
+<?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/keys
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class KeyKeys extends PrefixableCommand
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'KEYS';
+    }
+}

vendor/predis/predis/lib/Predis/Command/KeyKeysV12x.php

@@ -0,0 +1,28 @@
+<?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/keys
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ * @deprecated
+ */
+class KeyKeysV12x extends KeyKeys
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function parseResponse($data)
+    {
+        return explode(' ', $data);
+    }
+}

vendor/predis/predis/lib/Predis/Command/KeyMove.php

@@ -0,0 +1,35 @@
+<?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/move
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class KeyMove extends PrefixableCommand
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'MOVE';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function parseResponse($data)
+    {
+        return (bool) $data;
+    }
+}

vendor/predis/predis/lib/Predis/Command/KeyPersist.php

@@ -0,0 +1,35 @@
+<?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/persist
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class KeyPersist extends PrefixableCommand
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'PERSIST';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function parseResponse($data)
+    {
+        return (bool) $data;
+    }
+}

vendor/predis/predis/lib/Predis/Command/KeyPreciseExpire.php

@@ -0,0 +1,27 @@
+<?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/pexpire
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class KeyPreciseExpire extends KeyExpire
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'PEXPIRE';
+    }
+}

vendor/predis/predis/lib/Predis/Command/KeyPreciseExpireAt.php

@@ -0,0 +1,27 @@
+<?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/pexpireat
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class KeyPreciseExpireAt extends KeyExpireAt
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'PEXPIREAT';
+    }
+}

vendor/predis/predis/lib/Predis/Command/KeyPreciseTimeToLive.php

@@ -0,0 +1,27 @@
+<?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/pttl
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class KeyPreciseTimeToLive extends KeyTimeToLive
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'PTTL';
+    }
+}

vendor/predis/predis/lib/Predis/Command/KeyRandom.php

@@ -0,0 +1,35 @@
+<?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/randomkey
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class KeyRandom extends AbstractCommand
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'RANDOMKEY';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function parseResponse($data)
+    {
+        return $data !== '' ? $data : null;
+    }
+}

vendor/predis/predis/lib/Predis/Command/KeyRename.php

@@ -0,0 +1,35 @@
+<?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/rename
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class KeyRename extends AbstractCommand implements PrefixableCommandInterface
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'RENAME';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function prefixKeys($prefix)
+    {
+        PrefixHelpers::all($this, $prefix);
+    }
+}

vendor/predis/predis/lib/Predis/Command/KeyRenamePreserve.php

@@ -0,0 +1,35 @@
+<?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/renamenx
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class KeyRenamePreserve extends KeyRename
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'RENAMENX';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function parseResponse($data)
+    {
+        return (bool) $data;
+    }
+}

vendor/predis/predis/lib/Predis/Command/KeyRestore.php

@@ -0,0 +1,27 @@
+<?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/restore
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class KeyRestore extends PrefixableCommand
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'RESTORE';
+    }
+}

vendor/predis/predis/lib/Predis/Command/KeySort.php

@@ -0,0 +1,117 @@
+<?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/sort
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class KeySort extends AbstractCommand implements PrefixableCommandInterface
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'SORT';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function filterArguments(Array $arguments)
+    {
+        if (count($arguments) === 1) {
+            return $arguments;
+        }
+
+        $query = array($arguments[0]);
+        $sortParams = array_change_key_case($arguments[1], CASE_UPPER);
+
+        if (isset($sortParams['BY'])) {
+            $query[] = 'BY';
+            $query[] = $sortParams['BY'];
+        }
+
+        if (isset($sortParams['GET'])) {
+            $getargs = $sortParams['GET'];
+
+            if (is_array($getargs)) {
+                foreach ($getargs as $getarg) {
+                    $query[] = 'GET';
+                    $query[] = $getarg;
+                }
+            } else {
+                $query[] = 'GET';
+                $query[] = $getargs;
+            }
+        }
+
+        if (isset($sortParams['LIMIT']) &&
+            is_array($sortParams['LIMIT']) &&
+            count($sortParams['LIMIT']) == 2) {
+
+            $query[] = 'LIMIT';
+            $query[] = $sortParams['LIMIT'][0];
+            $query[] = $sortParams['LIMIT'][1];
+        }
+
+        if (isset($sortParams['SORT'])) {
+            $query[] = strtoupper($sortParams['SORT']);
+        }
+
+        if (isset($sortParams['ALPHA']) && $sortParams['ALPHA'] == true) {
+            $query[] = 'ALPHA';
+        }
+
+        if (isset($sortParams['STORE'])) {
+            $query[] = 'STORE';
+            $query[] = $sortParams['STORE'];
+        }
+
+        return $query;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function prefixKeys($prefix)
+    {
+        if ($arguments = $this->getArguments()) {
+            $arguments[0] = "$prefix{$arguments[0]}";
+
+            if (($count = count($arguments)) > 1) {
+                for ($i = 1; $i < $count; $i++) {
+                    switch ($arguments[$i]) {
+                        case 'BY':
+                        case 'STORE':
+                            $arguments[$i] = "$prefix{$arguments[++$i]}";
+                            break;
+
+                        case 'GET':
+                            $value = $arguments[++$i];
+                            if ($value !== '#') {
+                                $arguments[$i] = "$prefix$value";
+                            }
+                            break;
+
+                        case 'LIMIT';
+                            $i += 2;
+                            break;
+                    }
+                }
+            }
+
+            $this->setRawArguments($arguments);
+        }
+    }
+}

vendor/predis/predis/lib/Predis/Command/KeyTimeToLive.php

@@ -0,0 +1,27 @@
+<?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/ttl
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class KeyTimeToLive extends PrefixableCommand
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'TTL';
+    }
+}

vendor/predis/predis/lib/Predis/Command/KeyType.php

@@ -0,0 +1,27 @@
+<?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/type
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class KeyType extends PrefixableCommand
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'TYPE';
+    }
+}

vendor/predis/predis/lib/Predis/Command/ListIndex.php

@@ -0,0 +1,27 @@
+<?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/lindex
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class ListIndex extends PrefixableCommand
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'LINDEX';
+    }
+}

vendor/predis/predis/lib/Predis/Command/ListInsert.php

@@ -0,0 +1,27 @@
+<?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/linsert
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class ListInsert extends PrefixableCommand
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'LINSERT';
+    }
+}

vendor/predis/predis/lib/Predis/Command/ListLength.php

@@ -0,0 +1,27 @@
+<?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/llen
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class ListLength extends PrefixableCommand
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'LLEN';
+    }
+}

vendor/predis/predis/lib/Predis/Command/ListPopFirst.php

@@ -0,0 +1,27 @@
+<?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/lpop
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class ListPopFirst extends PrefixableCommand
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'LPOP';
+    }
+}

vendor/predis/predis/lib/Predis/Command/ListPopFirstBlocking.php

@@ -0,0 +1,48 @@
+<?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/blpop
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class ListPopFirstBlocking extends AbstractCommand implements PrefixableCommandInterface
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'BLPOP';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function filterArguments(Array $arguments)
+    {
+        if (count($arguments) === 2 && is_array($arguments[0])) {
+            list($arguments, $timeout) = $arguments;
+            array_push($arguments, $timeout);
+        }
+
+        return $arguments;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function prefixKeys($prefix)
+    {
+        PrefixHelpers::skipLast($this, $prefix);
+    }
+}

vendor/predis/predis/lib/Predis/Command/ListPopLast.php

@@ -0,0 +1,27 @@
+<?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/rpop
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class ListPopLast extends PrefixableCommand
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'RPOP';
+    }
+}

vendor/predis/predis/lib/Predis/Command/ListPopLastBlocking.php

@@ -0,0 +1,27 @@
+<?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/brpop
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class ListPopLastBlocking extends ListPopFirstBlocking
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'BRPOP';
+    }
+}

vendor/predis/predis/lib/Predis/Command/ListPopLastPushHead.php

@@ -0,0 +1,35 @@
+<?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/rpoplpush
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class ListPopLastPushHead extends AbstractCommand implements PrefixableCommandInterface
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'RPOPLPUSH';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function prefixKeys($prefix)
+    {
+        PrefixHelpers::all($this, $prefix);
+    }
+}

vendor/predis/predis/lib/Predis/Command/ListPopLastPushHeadBlocking.php

@@ -0,0 +1,35 @@
+<?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/brpoplpush
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class ListPopLastPushHeadBlocking extends AbstractCommand implements PrefixableCommandInterface
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'BRPOPLPUSH';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function prefixKeys($prefix)
+    {
+        PrefixHelpers::skipLast($this, $prefix);
+    }
+}

vendor/predis/predis/lib/Predis/Command/ListPushHead.php

@@ -0,0 +1,27 @@
+<?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/lpush
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class ListPushHead extends ListPushTail
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'LPUSH';
+    }
+}

vendor/predis/predis/lib/Predis/Command/ListPushHeadX.php

@@ -0,0 +1,27 @@
+<?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/lpushx
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class ListPushHeadX extends PrefixableCommand
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'LPUSHX';
+    }
+}

vendor/predis/predis/lib/Predis/Command/ListPushTail.php

@@ -0,0 +1,35 @@
+<?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/rpush
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class ListPushTail extends PrefixableCommand
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'RPUSH';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function filterArguments(Array $arguments)
+    {
+        return self::normalizeVariadic($arguments);
+    }
+}

vendor/predis/predis/lib/Predis/Command/ListPushTailX.php

@@ -0,0 +1,27 @@
+<?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/rpushx
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class ListPushTailX extends PrefixableCommand
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'RPUSHX';
+    }
+}

vendor/predis/predis/lib/Predis/Command/ListRange.php

@@ -0,0 +1,27 @@
+<?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/lrange
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class ListRange extends PrefixableCommand
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'LRANGE';
+    }
+}

vendor/predis/predis/lib/Predis/Command/ListRemove.php

@@ -0,0 +1,27 @@
+<?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/lrem
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class ListRemove extends PrefixableCommand
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'LREM';
+    }
+}

vendor/predis/predis/lib/Predis/Command/ListSet.php

@@ -0,0 +1,27 @@
+<?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/lset
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class ListSet extends PrefixableCommand
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'LSET';
+    }
+}

vendor/predis/predis/lib/Predis/Command/ListTrim.php

@@ -0,0 +1,27 @@
+<?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/ltrim
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class ListTrim extends PrefixableCommand
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'LTRIM';
+    }
+}