Update CHANGELOG and bump VERSION.

[ci skip]

.gitignore

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

.travis.yml

@@ -2,8 +2,12 @@ language: php
 php:
   - 5.3
   - 5.4
+  - 5.5
 branches:
-  only:
-    - master
-    - v0.7
+  except:
+    - v0.5
+    - v0.6
+    - php5.2_backport
+    - documentation
+services: redis-server
 script: phpunit -c phpunit.xml.travisci

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`

CHANGELOG.md

@@ -1,5 +1,276 @@
+v0.8.5 (2014-01-16)
+================================================================================
+
+- Added `2.8` in the server profiles aliases list for Redis 2.8. `2.6` is still
+  the default server profile and `dev` now targets Redis 3.0.
+
+- Added `SCAN`, `SSCAN`, `ZSCAN`, `HSCAN` to the server profile for Redis 2.8.
+
+- Implemented PHP iterators for incremental iterations over Redis collections:
+
+    - keyspace (cursor-based iterator using `SCAN`)
+    - sets (cursor-based iterator using `SSCAN`)
+    - sorted sets (cursor-based iterator using `ZSCAN`)
+    - hashes (cursor-based iterator using `HSCAN`)
+    - lists (plain iterator using `LRANGE`)
+
+- It is now possible to execute "raw commands" using `Predis\Command\RawCommand`
+  and a variable list of command arguments. Input arguments are not filtered and
+  responses are not parsed, which means arguments must follow the signature of
+  the command as defined by Redis and complex responses are left untouched.
+
+- URI parsing for connection parameters has been improved and has slightly less
+  overhead when the number of fields in the querystring grows. New features are:
+
+    - Parsing does not break when value of a field contains one or more "=".
+    - Repeated fieldnames using [] produce an array of values.
+    - Empty or incomplete "key=value" pairs result in an empty string for "key".
+
+- Various improvements and fixes to the redis-cluster connection backend:
+
+    - __FIX__: the `ASKING` command is sent upon -ASK redirections.
+    - An updated slots-map can be fetched from nodes using the `CLUSTER NODES`
+      command. By default this is a manual operation but can be enabled to get
+      automatically done upon -MOVED redirections.
+    - It is possible to specify a common set of connection parameters that are
+      applied to connections created on the fly upon redirections to nodes not
+      part of the initial pool.
+
+- List of deprecated methods:
+
+    - `Predis\Client::multiExec()`: superseded by `Predis\Client::transaction()`
+      and to be removed in the next major release.
+    - `Predis\Client::pubSub()`: superseded by `Predis\Client::pubSubLoop()` and
+      to be removed in the next major release. This change was needed due to the
+      recently introduced `PUBSUB` command in Redis 2.8.
+
+
+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
@@ -66,19 +337,19 @@ v0.7.0 (2011-12-11)
   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`.
+  `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.
+  `Predis_Compatibility.php` to avoid breaking compatibility.
 
 - Added a `VERSION` constant to `Predis\Client`.
 
@@ -88,7 +359,7 @@ v0.6.6 (2011-04-01)
 
 - 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`.
+  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.
 
@@ -112,7 +383,7 @@ v0.6.6 (2011-04-01)
 
 
 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
@@ -120,7 +391,7 @@ v0.6.5 (2011-02-12)
 
 
 v0.6.4 (2011-02-12)
-===============================================================================
+================================================================================
 
 - Various performance improvements (15% ~ 25%) especially when dealing with
   long multibulk replies or when using clustered connections.
@@ -134,7 +405,7 @@ v0.6.4 (2011-02-12)
 
 
 v0.6.3 (2011-01-01)
-===============================================================================
+================================================================================
 
 - New commands available in the Redis v2.2 profile (dev):
   - Strings: `SETRANGE`, `GETRANGE`, `SETBIT`, `GETBIT`
@@ -148,7 +419,7 @@ v0.6.3 (2011-01-01)
 
 
 v0.6.2 (2010-11-28)
-===============================================================================
+================================================================================
 
 - Minor internal improvements and clean ups.
 
@@ -173,7 +444,7 @@ v0.6.2 (2010-11-28)
 
 
 v0.6.1 (2010-07-11)
-===============================================================================
+================================================================================
 
 - Minor internal improvements and clean ups.
 
@@ -215,7 +486,7 @@ v0.6.1 (2010-07-11)
 
 
 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
@@ -227,7 +498,7 @@ v0.6.0 (2010-05-24)
   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.
+  '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`
@@ -240,7 +511,7 @@ v0.6.0 (2010-05-24)
 
 - 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
+  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:
@@ -330,7 +601,7 @@ v0.6.0 (2010-05-24)
 
 
 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
@@ -345,5 +616,5 @@ v0.5.1 (2010-01-23)
 
 
 v0.5.0 (2010-01-09)
-===============================================================================
+================================================================================
 * First versioned release of Predis

CONTRIBUTING.md

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

FAQ.PERFORMANCES.md

@@ -1,79 +0,0 @@
-# Some frequently asked questions about the performances of Predis #
-____________________________________________
-
-
-### 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.3.5 (custom build) and Redis 2.2
-(localhost) under Ubuntu 11.04 (running on a Intel Q6600):
-
-    19600 SET/sec using 12 bytes for both key and value
-    18900 GET/sec while retrieving the very same values
-    0.200 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)?
-
-    30500 SET/sec using 12 bytes for both key and value
-    31000 GET/sec while retrieving the very same values
-    0.030 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:
-    3600 SET/sec using 12 bytes for both key and value
-    3600 GET/sec while retrieving the very same values
-    0.210 seconds to fetch 30000 keys using "KEYS *".
-
-    Using phpredis:
-    4000 SET/sec using 12 bytes for both key and value
-    4000 GET/sec while retrieving the very same values
-    0.051 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/seppo0010/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 will now
-get the benefits of a faster protocol parser just by adding a single line of code in your application:
-
-    $client = new Predis\Client('tcp://127.0.0.1', array(
-        'connections' => array('tcp' => 'Predis\Network\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.031 seconds from a local Redis instance
-    0.058 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.2, and even the current development version), then
-using __phpredis__ can make sense for you. Otherwise, Predis is for you. Using __phpiredis__ gives you
-a nice speed bump, but it is not mandatory.

FAQ.md

@@ -1,58 +1,169 @@
 # 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).
-
-
-### How about performances? ###
-
-Please refer to the dedicated __FAQ.PERFORMANCES__ file.
-
-
-### Why PHP 5.3? ###
-
-Seriously, are you still using PHP 5.2 to build new applications? I assume that if you are throwing Redis
-in the mix, then you are probably coding something new after all. PHP 5.3 is faster, less memory hungry
-and has a few nice features such as namespaces and closures (kind of). More importantly, PHP 5.2 is not
-even officially supported anymore (aside from security patches). PHP 5.3 is not the future of PHP, but
-its current present. Furthermore, most of the existing frameworks out there are also making the switch
-with their respective new major versions. If you still insist on using PHP 5.2, you can get any recent
-backported release of Predis 0.6.x, or just use a different library.
-
-
-### Why so many files for just one library? ###
-
-Before v0.7, Predis used the one-big-file approach to distribute the library. As much as you prefer having
-just one file for everything, this kind of solution is actually not that good. Predis now complies with the
-[PSR-0](http://groups.google.com/group/php-standards/web/psr-0-final-proposal) standard to play nice with
-the major recent frameworks and libraries, so it needs an autoloader function to be defined. If you still
-want to have just one file grouping all the classes for whatever reason, then the __bin/create-single-file.php__
-script in the repository can generate it for you. There is also the __bin/create-phar.php__ script that
-generates a single [Phar archive](http://www.php.net/manual/en/intro.phar.php) of the whole library.
-
+The main point of Predis is about offering a highly customizable and extensible client for Redis,
+that can be easily extended by developers while still being reasonabily fast. With Predis you can
+swap almost any class with your own custom implementation: you can have custom connection classes,
+new distribution strategies for client-side sharding, or handlers to replace or add Redis commands.
+All of this can be achieved without messing with the source code of the library and directly in your
+own application. Given the fast pace at which Redis is developed and adds new features, this can be
+a great asset since it allows developers to add new and still missing features or commands or change
+the standard behaviour of the library without the need to break dependencies in production code (at
+least to some degree).
 
 ### Does Predis support UNIX domain sockets and persistent connections? ###
 
-Yes. Obviously, persistent connections actually work when using PHP configured as a persistent process that
-gets recycled between requests (see [PHP-FPM](http://php-fpm.org/)).
-
+Yes. Obviously persistent connections actually work only when using PHP configured as a persistent
+process reused by the web server (see [PHP-FPM](http://php-fpm.org)).
 
 ### Does Predis support 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.
+No and it will not ever do that by default. The reason behind this decision is that serialization is
+usually something that developers prefer to customize depending on their needs and can not be easily
+generalized when using Redis because of the many possible access patterns for your data. This does
+not mean that it is impossible to have such a feature since you can leverage the extensibility of
+this library to define your own serialization-aware commands. You can find more details about how to
+do that [on this issue](http://github.com/nrk/predis/issues/29#issuecomment-1202624).
+
+### How can I force Predis to connect to Redis before sending any command? ###
+
+Explicitly connecting to Redis is usually not needed since the client initializes connections lazily
+only when they are needed. Admittedly, this behavior can be inconvenient in certain scenarios when
+you absolutely need to perform an upfront check to determine if the server is up and running and
+eventually catch exceptions on failures. Forcing the client to open the underlying connection can be
+done by invoking `Predis\Client::connect()`:
+
+```php
+$client = new Predis\Client();
+
+try {
+    $client->connect();
+} catch (Predis\Connection\ConnectionException $exception) {
+    // We could not connect to Redis! Your handling code goes here.
+}
+
+$client->info();
+```
+
+### How Predis abstracts Redis commands? ###
+
+The approach used to implement Redis commands is quite simple: by default each command follows the
+same signature as defined on the [Redis documentation](http://redis.io/commands) which makes things
+pretty easy if you already know how Redis works or you need to look up how to use certain commands.
+Alternatively, variadic commands can accept an array for keys or values (depending on the command)
+instead of a list of arguments. Commands such as [`RPUSH`](http://redis.io/commands/rpush) and
+[`HMSET`](http://redis.io/commands/hmset) are great examples:
+
+```php
+$client->rpush('my:list', 'value1', 'value2', 'value3');             // plain method arguments
+$client->rpush('my:list', ['value1', 'value2', 'value3']);           // single argument array
+
+$client->hmset('my:hash', 'field1', 'value1', 'field2', 'value2');   // plain method arguments
+$client->hmset('my:hash', ['field1'=>'value1', 'field2'=>'value2']); // single named array
+```
+
+An exception to this rule is [`SORT`](http://redis.io/commands/sort) for which modifiers are passed
+[using a named array](tests/Predis/Command/KeySortTest.php#L54-L75).
+
+
+# Speaking about performances... #
+_________________________________________________
+
+
+### Predis is a pure-PHP implementation: it can not be fast enough! ###
+
+It really depends, but most of the times the answer is: _yes, it is fast enough_. I will give you a
+couple of easy numbers with a simple test that uses a single client and is executed by PHP 5.5.6
+against a local instance of Redis 2.8 that runs under Ubuntu 13.10 on a Intel Q6600:
+
+```
+21000 SET/sec using 12 bytes for both key and value.
+21000 GET/sec while retrieving the very same values.
+0.130 seconds to fetch 30000 keys using _KEYS *_.
+```
+
+How does it compare with [__phpredis__](http://github.com/nicolasff/phpredis), a nice C extension
+providing an efficient client for Redis?
+
+```
+30100 SET/sec using 12 bytes for both key and value
+29400 GET/sec while retrieving the very same values
+0.035 seconds to fetch 30000 keys using "KEYS *"".
+```
+
+Wow __phpredis__ seems much faster! Well, we are comparing a C extension with a pure-PHP library so
+lower numbers are quite expected but there is a fundamental flaw in them: is this really how you are
+going to use Redis in your application? Are you really going to send thousands of commands using a
+for-loop on each page request using a single client instance? If so... well I guess you are probably
+doing something wrong. Also, if you need to `SET` or `GET` multiple keys you should definitely use
+commands such as `MSET` and `MGET`. You can also use pipelining to get more performances when this
+technique can be used.
+
+There is one more thing: we have tested the overhead of Predis by connecting on a localhost instance
+of Redis but how these numbers change when we hit the physical network by connecting to remote Redis
+instances?
+
+```
+Using Predis:
+3200 SET/sec using 12 bytes for both key and value
+3200 GET/sec while retrieving the very same values
+0.132 seconds to fetch 30000 keys using "KEYS *".
+
+Using phpredis:
+3500 SET/sec using 12 bytes for both key and value
+3500 GET/sec while retrieving the very same values
+0.045 seconds to fetch 30000 keys using "KEYS *".
+```
+
+There you go, you get almost the same average numbers and the reason is simple: network latency is a
+real performance killer and you cannot do (almost) anything about that. As a disclaimer, remember
+that we are measuring the overhead of client libraries implementations and the effects of network
+round-trip times, so we are not really measuring how fast Redis is. Redis shines best with thousands
+of concurrent clients doing requests! Also, actual performances should be measured according to how
+your application will use Redis.
+
+### I am convinced, but performances for multi-bulk responses are still worse ###
+
+Fair enough, but there is an option available if you need even more speed and consists on installing
+__[phpiredis](http://github.com/nrk/phpiredis)__ (note the additional _i_ in the name) and let the
+client use it. __phpiredis__ is another C extension that wraps __hiredis__ (the official C client
+library for Redis) with a thin layer exposing its features to PHP. You can then choose between two
+different connection classes:
+
+  - `Predis\Connection\PhpiredisStreamConnection` (using native PHP streams).
+  - `Predis\Connection\PhpiredisConnection` (requires `ext-socket`).
+
+You will now get the benefits of a faster protocol serializer and parser just by adding a couple of
+lines of code:
+
+```php
+$client = new Predis\Client('tcp://127.0.0.1', array(
+    'connections' => array(
+        'tcp'  => 'Predis\Connection\PhpiredisStreamConnection',
+        'unix' => 'Predis\Connection\PhpiredisConnection',
+    ),
+));
+```
+
+Dead simple. Nothing changes in the way you use the library in your application. So how fast is it
+our basic benchmark script now? There are not much improvements for inline or short bulk responses
+like the ones returned by `SET` and `GET`, but the speed for parsing multi-bulk responses is now on
+par with phpredis:
+
+```
+Fatching 30000 keys with _KEYS *_ using Predis paired with phpiredis::
+
+0.035 seconds from a local Redis instance
+0.047 seconds from a remote Redis instance
+```
+
+### If I need an extension to get better performances, why not using phpredis? ###
+
+Good question. Generically speaking if you need absolute uber-speed using Redis on the localhost and
+you do not care about abstractions built around some Redis features such as MULTI / EXEC, or if you
+do not need any kind of extensibility or guaranteed backwards compatibility with different versions
+of Redis (Predis currently supports from 1.2 up to 2.8 and the current development version), then
+using __phpredis__ makes absolutely sense. Otherwise, Predis is perfect for the job and by adding
+__phpiredis__ you can get a nice speed bump almost for free.

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009-2011 Daniele Alessandri
+Copyright (c) 2009-2014 Daniele Alessandri
 
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation

README.md

@@ -1,147 +1,226 @@
 # Predis #
 
-Predis is a flexible and feature-complete PHP (>= 5.3) client library for the Redis key-value store.
+[![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)
 
-For a list of frequently asked questions about Predis, see the __FAQ__ file in the root of the repository.
-For a version compatible with PHP 5.2 you must use the backported version from the latest release in the
-0.6.x series. More details are available on the [official wiki](http://wiki.github.com/nrk/predis) of the
-project,
+Predis is a flexible and feature-complete [Redis](http://redis.io) client library for PHP >= 5.3.
+
+By default Predis does not require any additional C extension, but it can be optionally paired with
+[phpiredis](https://github.com/nrk/phpiredis) to lower the overhead of serializing and parsing the
+Redis protocol. An asynchronous implementation of the client, albeit experimental, is also available
+through [Predis\Async](https://github.com/nrk/predis-async).
+
+More details about the project can be found in our [frequently asked questions](FAQ.md) section or
+on the online [wiki](https://github.com/nrk/predis/wiki).
 
 
 ## Main features ##
 
-- Complete support for Redis from __1.2__ to __2.4__ and the current development versions using different
-  server profiles.
-- Client-side sharding with support for consistent hashing or custom distribution strategies.
-- Command pipelining on single and aggregated connections.
-- Transparent key prefixing strategy capable of handling any command known that has keys in its arguments.
-- Abstraction for Redis transactions (Redis >= 2.0) with support for CAS operations (Redis >= 2.2).
-- Connections to Redis instances are automatically and lazily estabilished upon the first call to a command.
-- Ability to connect to Redis using TCP/IP or UNIX domain sockets with support for persistent connections.
-- Ability to use 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.
+- Wide range of Redis versions supported (from __1.2__ to __2.8__ and unstable) using profiles.
+- Clustering via client-side sharding using consistent hashing or custom distributors.
+- Smart support for [redis-cluster](http://redis.io/topics/cluster-spec) (Redis >= 3.0).
+- Support for master-slave replication configurations (write on master, read from slaves).
+- Transparent key prefixing for all Redis commands.
+- Command pipelining (works on both single and aggregate connections).
+- Abstraction for Redis transactions (Redis >= 2.0) supporting CAS operations (Redis >= 2.2).
+- Abstraction for Lua scripting (Redis >= 2.6) with automatic switching between `EVALSHA` or `EVAL`.
+- Abstraction for `SCAN`, `SSCAN`, `ZSCAN` and `HSCAN` (Redis >= 2.8) based on PHP iterators.
+- Connections to Redis are established lazily by the client upon the first command.
+- Support for both TCP/IP and UNIX domain sockets and persistent connections.
+- Support for [Webdis](http://webd.is) (both `ext-curl` and `ext-phpiredis` are needed).
+- Support for custom connection classes for providing different network or protocol backends.
+- Flexible system for defining and registering custom sets of supported commands or profiles.
 
 
 ## 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 [PearHub](http://pearhub.org/projects/predis)'s
-channel 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).
+Predis is available on [Packagist](http://packagist.org/packages/predis/predis) which allows a quick
+installation using [Composer](http://packagist.org/about-composer). Alternatively, the library can
+be found on our [own PEAR channel](http://pear.nrk.io) for a more traditional installation via PEAR.
+Ultimately, archives of each release are [available on GitHub](https://github.com/nrk/predis/tags).
 
 
 ### Loading the library ###
 
-To automatically load all of its files, Predis relies on the autoloading features of PHP and complies
-with the [PSR-0 standard](http://github.com/php-fig/fig-standards/blob/master/accepted/PSR-0.md) for
-interoperability with most of the major frameworks and libraries. Everything is transparently handled
-for you when installing the library using 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:
+Predis relies on the autoloading features of PHP to load its files when needed and complies with the
+[PSR-0 standard](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-0.md) which makes
+it compatible with most PHP frameworks. Autoloading is handled automatically when dependencies are
+managed using Composer, but you can also leverage its own autoloader if you are going to use it in a
+project or script without any PSR-0 compliant autoloading facility:
 
-``` php
-<?php
-require PREDIS_BASE_PATH . '/Autoloader.php';
+```php
+// Prepend a base path if Predis is not available in your "include_path".
+require 'Predis/Autoloader.php';
 
 Predis\Autoloader::register();
 ```
 
-You can create a single [Phar](http://www.php.net/manual/en/intro.phar.php) archive from the repository
-just by launching the `bin/create-phar.php` executable script. 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 you can generate a single PHP file that holds every class, just like older versions of
-Predis, using the `bin/create-single-file.php` executable sript. 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.
+It is possible to easily create a [phar](http://www.php.net/manual/en/intro.phar.php) archive from
+the repository just by launching `bin/create-phar`. The generated phar contains a stub defining an
+autoloader function for Predis, so you just need to require the phar to start using the library.
+Alternatively, it is also possible to generate one single PHP file that holds every class like older
+versions of Predis by launching `bin/create-single-file`, but this practice __is not__ encouraged.
 
 
-### Connecting to a local instance of Redis ###
+### Connecting to Redis ###
 
-When connecting to local instance of Redis (`127.0.0.1` on port `6379`), you do not have to specify any
-additional parameter to create a new client instance:
+When not specifying any connection parameter to create a new client, Predis assumes `127.0.0.1` and
+`6379` as the default host and port and uses a connection timeout of 5 seconds:
 
-``` php
-<?php
-$redis = new Predis\Client();
-$redis->set('foo', 'bar');
-$value = $redis->get('foo');
+```php
+$client = new Predis\Client();
+$client->set('foo', 'bar');
+$value = $client->get('foo');
 ```
 
-However you can use an URI string or a named array to specify the needed connection parameters:
+Connection parameters can be supplied either in the form of URI strings or named arrays. While the
+latter is the preferred way to supply parameters, URI strings can be useful for quick configurations
+or when parameters are read from a non-structured source:
 
-``` php
-<?php
-$redis = new Predis\Client('tcp://10.0.0.1:6379');
-
-// is equivalent to:
-
-$redis = new Predis\Client(array(
+```php
+// Named array of connection parameters:
+$client = new Predis\Client([
     'scheme' => 'tcp',
     'host'   => '10.0.0.1',
     'port'   => 6379,
-));
+]);
+
+// Same set of parameters, but using an URI string:
+$client = new Predis\Client('tcp://10.0.0.1:6379');
 ```
 
+When an array of connections parameters is provided, Predis automatically works in clustering mode
+using client-side sharding. Both named arrays and URI strings can be mixed for providing each node
+configuration:
 
-### Pipelining multiple commands to multiple instances of Redis with client-side sharding ###
+```php
+$client = new Predis\Client([
+    'tcp://10.0.0.1?alias=first-node',
+    ['host' => '10.0.0.2', 'alias' => 'second-node'],
+]);
+```
 
-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.
+The actual list of supported connection parameters can vary depending on each connection backend so
+it is recommended to refer to their specific documentation for details.
 
-``` php
-<?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) {
+### Client configuration ###
+
+Various aspects of the client can be easily configured by passing options to the second argument of
+`Predis\Client::__construct()`. Options are managed using a mini DI-alike container and their values
+are usually lazily initialized only when needed. Predis by default supports the following options:
+
+  - `profile`: which profile to use in order to match a specific version of Redis.
+  - `prefix`: a prefix string that is automatically applied to keys found in commands.
+  - `exceptions`: whether the client should throw or return responses upon Redis errors.
+  - `connections`: connection backends or a connection factory to be used by the client.
+  - `cluster`: which backend to use for clustering (predis, redis or custom configuration).
+  - `replication`: which backend to use for replication (predis or custom configuration).
+
+Users can provide custom option values, they are stored in the options container and can be accessed
+later through the library.
+
+
+### Aggregate connections ###
+
+Predis is able to aggregate multiple connections which is the base for clustering and replication.
+By default the client implements clustering using either client-side sharding (default) or a Redis
+backed solution using [redis-cluster](http://redis.io/topics/cluster-tutorial). As for replication,
+Predis can handle single-master and multiple-slaves setups by executing read operations on slaves
+and switching to the master for write operations. The replication behaviour is fully configurable.
+
+
+### Command pipelines ###
+
+Pipelining can help with performances when many commands need to be sent to a server by reducing the
+latency introduced by network round-trip timings. Pipelining also works with aggregate connections.
+The client can execute the pipeline inside a callable block or return a pipeline instance with the
+ability to chain commands thanks to its fluent interface:
+
+```php
+// Executes a pipeline inside a given callable block:
+$responses = $client->pipeline(function ($pipe) {
     for ($i = 0; $i < 1000; $i++) {
         $pipe->set("key:$i", str_pad($i, 4, '0', 0));
         $pipe->get("key:$i");
     }
 });
+
+// Returns a pipeline instance with fluent interface:
+$responses = $client->pipeline()->set('foo', 'bar')->get('foo')->execute();
 ```
 
 
-### Overriding standard connection classes with custom ones ###
+### Transactions ###
 
-Predis allows developers to create new connection classes to add support for new protocols or override
-the existing ones and provide a different implementation compared to the default classes. This can be
-obtained by subclassing the `Predis\Network\IConnectionSingle` interface.
+The client provides an abstraction for Redis transactions based on `MULTI` and `EXEC` with a similar
+interface to command pipelines:
 
-``` php
-<?php
-class MyConnectionClass implements Predis\Network\IConnectionSingle
+```php
+// Executes a transaction inside a given callable block:
+$responses = $client->transaction(function ($tx) {
+    $tx->set('foo', 'bar');
+    $tx->get('foo');
+});
+
+// Returns a transaction instance with fluent interface:
+$responses = $client->transaction()->set('foo', 'bar')->get('foo')->execute();
+```
+
+This abstraction can perform check-and-set operations thanks to `WATCH` and `UNWATCH` and provides
+automatic retries of transactions aborted by Redis when `WATCH`ed keys are touched. For an example
+of a transaction using CAS you can see [the following example](examples/TransactionWithCAS.php).
+
+__NOTE__: the method `transaction()` is available since `v0.8.5`, older versions used `multiExec()`
+for the same purpose but it has been deprecated and will be removed in the next major release.
+
+
+### Customizable connection backends ###
+
+Predis can use different connection backends to connect to Redis. Two of them leverage a third party
+extension such as [phpiredis](https://github.com/nrk/phpiredis) resulting in major performance gains
+especially when dealing with big multibulk responses. While one is based on PHP streams, the other
+is based on socket resources provided by `ext-socket`. Both support TCP/IP or UNIX domain sockets:
+
+```php
+$client = new Predis\Client('tcp://127.0.0.1', [
+    'connections' => [
+        'tcp'  => 'Predis\Connection\PhpiredisStreamConnection', // PHP streams
+        'unix' => 'Predis\Connection\PhpiredisConnection',       // ext-socket
+    ],
+]);
+```
+
+Developers can create their own connection classes to add support for new network backends, extend
+existing ones or provide completely different implementations. Connection classes must implement
+`Predis\Connection\SingleConnectionInterface` or extend `Predis\Connection\AbstractConnection`:
+
+```php
+class MyConnectionClass implements Predis\Connection\SingleConnectionInterface
 {
-    // implementation goes here
+    // 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')
-));
+// Use MyConnectionClass to handle connections for the `tcp` scheme:
+$client = new Predis\Client('tcp://127.0.0.1', [
+    'connections' => ['tcp' => 'MyConnectionClass'],
+]);
 ```
 
-The classes contained in the `Predis\Network` namespace give you a better insight with actual code on
-how to create new connection classes.
+For a more in-depth insight on how to create new connection backends you can refer to the actual
+implementation of the standard connection classes available in the `Predis\Connection` namespace.
 
 
-### Defining and registering new commands on the client at runtime ###
+### Adding support for new commands ###
 
-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:
+While we try to update Predis to stay up to date with all the commands available in Redis, you might
+prefer to stick with an older version of the library or provide a different way to filter arguments
+or parse responses for specific commands. To achieve that, Predis provides the ability to implement
+new command classes to define or override commands in the server profiles used by the client:
 
-``` php
-<?php
-class BrandNewRedisCommand extends Predis\Commands\Command
+```php
+// Define a new command by extending Predis\Command\AbstractCommand:
+class BrandNewRedisCommand extends Predis\Command\AbstractCommand
 {
     public function getId()
     {
@@ -149,72 +228,98 @@ class BrandNewRedisCommand extends Predis\Commands\Command
     }
 }
 
-$redis = new Predis\Client();
-$redis->getProfile()->defineCommand('newcmd', 'BrandNewRedisCommand');
-$redis->newcmd();
+// Inject your command in the current profile:
+$client = new Predis\Client();
+$client->getProfile()->defineCommand('newcmd', 'BrandNewRedisCommand');
+
+$response = $client->newcmd();
 ```
 
 
-## Test suite ##
+### Scriptable commands ###
 
-__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!
+A scriptable command is just an abstraction for [Lua scripting](http://redis.io/commands/eval) that
+aims to simplify the usage of scripting with Redis >= 2.6. Scriptable commands can be registered in
+the server profile used by the client and are accessible as if they were plain Redis commands, but
+they define a Lua script that gets transmitted to Redis for remote execution. Internally, scriptable
+commands use by default [EVALSHA](http://redis.io/commands/evalsha) and identify a Lua script by its
+SHA1 hash to save bandwidth but [EVAL](http://redis.io/commands/eval) is automatically preferred as
+a fall back when needed:
 
-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 about testing Predis are available in `tests/README.md`.
+```php
+// Define a new scriptable command by extending Predis\Command\ScriptedCommand:
+class ListPushRandomValue extends Predis\Command\ScriptedCommand
+{
+    public function getKeysCount()
+    {
+        return 1;
+    }
 
-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).
+    public function getScript()
+    {
+        return <<<LUA
+math.randomseed(ARGV[1])
+local rnd = tostring(math.random())
+redis.call('lpush', KEYS[1], rnd)
+return rnd
+LUA;
+    }
+}
+
+// Inject your scriptable command in the current profile:
+$client = new Predis\Client();
+$client->getProfile()->defineCommand('lpushrand', 'ListPushRandomValue');
+
+$response = $client->lpushrand('random_values', $seed = mt_rand());
+```
 
 
-## Contributing ##
-
-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.
+## Development ##
 
 
-## Dependencies ##
+### Reporting bugs and contributing code ###
 
-- PHP >= 5.3.2
-- PHPUnit >= 3.5.0 (needed to run the test suite)
+Contributions to Predis are highly appreciated either in the form of pull requests for new features,
+bug fixes, or just bug reports. We only ask you to adhere to a [basic set of rules](CONTRIBUTING.md)
+before submitting your changes or filing bugs on the issue tracker to make it easier for everyone to
+stay consistent while working on the project.
 
-## Links ##
 
-### Project ###
-- [Source code](http://github.com/nrk/predis/)
-- [Wiki](http://wiki.github.com/nrk/predis/)
-- [Issue tracker](http://github.com/nrk/predis/issues)
+### Test suite ###
 
-### Related ###
-- [Redis](http://redis.io/)
-- [PHP](http://php.net/)
-- [PHPUnit](http://www.phpunit.de/)
-- [Git](http://git-scm.com/)
+__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!
 
-## Author ##
+Predis has a comprehensive test suite covering every aspect of the library. This test 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
+specified Redis profile. 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 profile for Redis 2.6
+but can optionally target a Redis instance built from `2.8` or `unstable` branches by modifying the
+`phpunit.xml` file and setting `REDIS_SERVER_VERSION` respectively to `2.8` or `dev` so that the
+correct server profile will be used. You can refer to [the tests README](tests/README.md) for more
+detailed information about testing Predis.
+
+Predis uses Travis CI for continuous integration and the history for past and current builds can be
+found [on its project page](http://travis-ci.org/nrk/predis).
+
+
+## Other ##
+
+
+### Project related links ###
+
+- [Source code](https://github.com/nrk/predis)
+- [Wiki](https://wiki.github.com/nrk/predis)
+- [Issue tracker](https://github.com/nrk/predis/issues)
+- [PEAR channel](http://pear.nrk.io)
+
+
+### 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 work on extending [phpiredis](http://github.com/seppo0010/phpiredis) for Predis
+### License ###
 
-## License ##
-
-The code for Predis is distributed under the terms of the MIT license (see LICENSE).
+The code for Predis is distributed under the terms of the MIT license (see [LICENSE](LICENSE)).

TODO

@@ -1,4 +0,0 @@
-* Documentation! The README is obviously not enought to show how to use Predis
-  as it does not cover all of its features.
-
-* [v0.8] Implement smart and transparent support for redis-cluster.

VERSION

@@ -1 +1 @@
-0.7.0
+0.8.5

bin/create-command-test

@@ -13,9 +13,9 @@
 // -------------------------------------------------------------------------- //
 // 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\Commands namespace (only classes in this namespace are valid).
+// 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\Commands\StringSet class):
+// Predis\Command\StringSet class):
 //
 //   $ ./bin/generate-command-test.php --class=StringSet
 //
@@ -33,8 +33,8 @@
 // is explicitly specified.
 // -------------------------------------------------------------------------- //
 
-use Predis\Commands\ICommand;
-use Predis\Commands\IPrefixable;
+use Predis\Command\CommandInterface;
+use Predis\Command\PrefixableCommandInterface;
 
 class CommandTestCaseGenerator
 {
@@ -92,8 +92,8 @@ class CommandTestCaseGenerator
             throw new RuntimeException("Missing 'class' option.");
         }
 
-        $options['fqn'] = "Predis\\Commands\\{$options['class']}";
-        $options['path'] = "Predis/Commands/{$options['class']}.php";
+        $options['fqn'] = "Predis\\Command\\{$options['class']}";
+        $options['path'] = "Predis/Command/{$options['class']}.php";
 
         $source = __DIR__.'/../lib/'.$options['path'];
         if (!file_exists($source)) {
@@ -116,7 +116,8 @@ class CommandTestCaseGenerator
             return $this->options['realm'];
         }
 
-        $class = array_pop(explode('\\', $this->options['fqn']));
+        $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);
@@ -129,8 +130,8 @@ class CommandTestCaseGenerator
         if (!$reflection->isInstantiable()) {
             throw new RuntimeException("Class $class must be instantiable, abstract classes or interfaces are not allowed.");
         }
-        if (!$reflection->implementsInterface('Predis\Commands\ICommand')) {
-            throw new RuntimeException("Class $class must implement the Predis\Commands\ICommand interface.");
+        if (!$reflection->implementsInterface('Predis\Command\CommandInterface')) {
+            throw new RuntimeException("Class $class must implement Predis\Command\CommandInterface.");
         }
 
         $instance = $reflection->newInstance();
@@ -148,11 +149,12 @@ class CommandTestCaseGenerator
         file_put_contents($options['output'], $this->generate());
     }
 
-    protected function getTestCaseBuffer(ICommand $instance)
+    protected function getTestCaseBuffer(CommandInterface $instance)
     {
         $id = $instance->getId();
         $fqn = get_class($instance);
-        $class = array_pop(explode('\\', $fqn)) . "Test";
+        $fqnParts = explode('\\', $fqn);
+        $class = array_pop($fqnParts) . "Test";
         $realm = $this->getTestRealm();
 
         $buffer =<<<PHP
@@ -167,15 +169,13 @@ class CommandTestCaseGenerator
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
-
-use \PHPUnit_Framework_TestCase as StandardTestCase;
+namespace Predis\Command;
 
 /**
  * @group commands
  * @group realm-$realm
  */
-class $class extends CommandTestCase
+class $class extends PredisCommandTestCase
 {
     /**
      * {@inheritdoc}
@@ -226,7 +226,7 @@ class $class extends CommandTestCase
 
 PHP;
 
-        if ($instance instanceof IPrefixable) {
+        if ($instance instanceof PrefixableCommandInterface) {
             $buffer .=<<<PHP
 
     /**
@@ -245,6 +245,17 @@ PHP;
         \$this->assertSame(\$expected, \$command->getArguments());
     }
 
+    /**
+     * @group disconnected
+     */
+    public function testPrefixKeysIgnoredOnEmptyArguments()
+    {
+        \$command = \$this->getCommand();
+        \$command->prefixKeys('prefix:');
+
+        \$this->assertSame(array(), \$command->getArguments());
+    }
+
 PHP;
         }
 

bin/create-pear

@@ -0,0 +1,53 @@
+#!/usr/bin/env php
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) Daniele Alessandri <suppakilla@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+// -------------------------------------------------------------------------- //
+// In order to be able to execute this script to create a PEAR package of Predis
+// both `onion` and `pear` must be available and executable in your $PATH.
+// -------------------------------------------------------------------------- //
+
+function executeWithBackup($file, $callback)
+{
+    $exception = null;
+    $backup = "$file.backup";
+
+    copy($file, $backup);
+
+    try {
+        call_user_func($callback, $file);
+    } catch (Exception $exception) {
+        // NOOP
+    }
+
+    unlink($file);
+    rename($backup, $file);
+
+    if ($exception) {
+        throw $exception;
+    }
+}
+
+function buildPackage()
+{
+    passthru('onion build && pear -q package && rm package.xml');
+}
+
+executeWithBackup(__DIR__.'/../phpunit.xml.dist', function ($file) {
+    $cfg = new SimpleXMLElement($file, null, true);
+
+    $cfg[0]['bootstrap'] = str_replace('tests/', '', $cfg[0]['bootstrap']);
+    $cfg->testsuites->testsuite->directory = str_replace('tests/', '', $cfg->testsuites->testsuite->directory);
+
+    $cfg->saveXml($file);
+
+    buildPackage();
+});

bin/create-phar

@@ -50,7 +50,7 @@ function getPharStub($options)
     return <<<EOSTUB
 <?php
 Phar::mapPhar('predis.phar');
-spl_autoload_register(function(\$class) {
+spl_autoload_register(function (\$class) {
     if (strpos(\$class, 'Predis\\\\') === 0) {
         \$file = 'phar://predis.phar/'.strtr(\$class, '\\\', '/').'.php';
         if (file_exists(\$file)) {

bin/create-single-file

@@ -184,7 +184,7 @@ class PredisFile
     {
         $namespaces = array_fill_keys(array_unique(
             array_map(
-                function($fqn) { return PhpNamespace::extractName($fqn); },
+                function ($fqn) { return PhpNamespace::extractName($fqn); },
                 array_keys($dependencyScores)
             )
         ), 0);
@@ -200,7 +200,7 @@ class PredisFile
 
     private function getOrderedClasses(PhpNamespace $phpNamespace, $classes)
     {
-        $nsClassesFQNs = array_map(function($cl) { return $cl->getFQN(); }, $phpNamespace->getClasses());
+        $nsClassesFQNs = array_map(function ($cl) { return $cl->getFQN(); }, $phpNamespace->getClasses());
         $nsOrderedClasses = array();
 
         foreach ($nsClassesFQNs as $nsClassFQN) {
@@ -321,13 +321,15 @@ class PhpUseDirectives implements Countable, IteratorAggregate
 {
     private $use;
     private $aliases;
+    private $reverseAliases;
     private $namespace;
 
     public function __construct(PhpNamespace $namespace)
     {
+        $this->namespace = $namespace;
         $this->use = array();
         $this->aliases = array();
-        $this->namespace = $namespace;
+        $this->reverseAliases = array();
     }
 
     public function add($use, $as = null)
@@ -336,8 +338,35 @@ class PhpUseDirectives implements Countable, IteratorAggregate
             return;
         }
 
+        $rename = null;
         $this->use[] = $use;
-        $this->aliases[$as ?: PhpClass::extractName($use)] = $use;
+        $aliasedClassName = $as ?: PhpClass::extractName($use);
+
+        if (isset($this->aliases[$aliasedClassName])) {
+            $parentNs = $this->getParentNamespace();
+
+            if ($parentNs && false !== $pos = strrpos($parentNs, '\\')) {
+                $parentNs = substr($parentNs, $pos);
+            }
+
+            $newAlias = "{$parentNs}_{$aliasedClassName}";
+            $rename = (object) array(
+                'namespace' => $this->namespace,
+                'from' => $aliasedClassName,
+                'to' => $newAlias,
+            );
+
+            $this->aliases[$newAlias] = $use;
+            $as = $newAlias;
+        } else {
+            $this->aliases[$aliasedClassName] = $use;
+        }
+
+        if ($as !== null) {
+            $this->reverseAliases[$use] = $as;
+        }
+
+        return $rename;
     }
 
     public function getList()
@@ -352,7 +381,15 @@ class PhpUseDirectives implements Countable, IteratorAggregate
 
     public function getPhpCode()
     {
-        $reducer = function($str, $use) { return $str .= "use $use;\n"; };
+        $reverseAliases = $this->reverseAliases;
+
+        $reducer = function ($str, $use) use ($reverseAliases) {
+            if (isset($reverseAliases[$use])) {
+                return $str .= "use $use as {$reverseAliases[$use]};\n";
+            } else {
+                return $str .= "use $use;\n";
+            }
+        };
 
         return array_reduce($this->getList(), $reducer, '');
     }
@@ -362,6 +399,15 @@ class PhpUseDirectives implements Countable, IteratorAggregate
         return $this->namespace;
     }
 
+    public function getParentNamespace()
+    {
+        if (false !== $pos = strrpos($this->namespace, '\\')) {
+            return substr($this->namespace, 0, $pos);
+        }
+
+        return '';
+    }
+
     public function getFQN($className)
     {
         if (($nsSepFirst = strpos($className, '\\')) === false) {
@@ -428,10 +474,19 @@ LICENSE;
 
     private function extractData()
     {
+        $renames = array();
         $useDirectives = $this->getNamespace()->getUseDirectives();
 
-        $useExtractor = function($m) use($useDirectives) {
-            $useDirectives->add(($namespacedPath = $m[1]));
+        $useExtractor = function ($m) use ($useDirectives, &$renames) {
+            array_shift($m);
+
+            if (isset($m[1])) {
+                $m[1] = str_replace(" as ", '', $m[1]);
+            }
+
+            if ($rename = call_user_func_array(array($useDirectives, 'add'), $m)) {
+                $renames[] = $rename;
+            }
         };
 
         $classBuffer = stream_get_contents(fopen($this->getFile()->getPathname(), 'r'));
@@ -443,6 +498,10 @@ LICENSE;
         $classBuffer = preg_replace('/namespace\s+[\w\d_\\\\]+;\s?/', '', $classBuffer);
         $classBuffer = preg_replace_callback('/use\s+([\w\d_\\\\]+)(\s+as\s+.*)?;\s?\n?/', $useExtractor, $classBuffer);
 
+        foreach ($renames as $rename) {
+            $classBuffer = str_replace($rename->from, $rename->to, $classBuffer);
+        }
+
         $this->body = trim($classBuffer);
 
         $this->extractHierarchy();
@@ -453,7 +512,7 @@ LICENSE;
         $implements = array();
         $extends =  array();
 
-        $extractor = function($iterator, $callback) {
+        $extractor = function ($iterator, $callback) {
             $className = '';
             $iterator->seek($iterator->key() + 1);
 
@@ -464,8 +523,7 @@ LICENSE;
                     if (preg_match('/\s?,\s?/', $token)) {
                         $callback(trim($className));
                         $className = '';
-                    }
-                    else if ($token == '{') {
+                    } else if ($token == '{') {
                         $callback(trim($className));
                         return;
                     }
@@ -510,13 +568,13 @@ LICENSE;
                     break;
 
                 case T_IMPLEMENTS:
-                    $extractor($iterator, function($fqn) use (&$implements) {
+                    $extractor($iterator, function ($fqn) use (&$implements) {
                         $implements[] = $fqn;
                     });
                     break;
 
                 case T_EXTENDS:
-                    $extractor($iterator, function($fqn) use (&$extends) {
+                    $extractor($iterator, function ($fqn) use (&$extends) {
                         $extends[] = $fqn;
                     });
                     break;

composer.json

@@ -13,7 +13,11 @@
         }
     ],
     "require": {
-        "php": ">=5.3.0"
+        "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/"}

examples/CustomDistributionStrategy.php

@@ -13,17 +13,18 @@ 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 the Predis\Distribution\IDistributionStrategy interface.
+// that implements Predis\Distribution\DistributionStrategyInterface.
 
-use Predis\Distribution\IDistributionStrategy;
-use Predis\Network\PredisCluster;
+use Predis\Connection\PredisCluster;
+use Predis\Cluster\Distribution\DistributionStrategyInterface;
+use Predis\Cluster\Hash\HashGeneratorInterface;
 
-class NaiveDistributionStrategy implements IDistributionStrategy
+class NaiveDistributionStrategy implements DistributionStrategyInterface, HashGeneratorInterface
 {
     private $nodes;
     private $nodesCount;
 
-    public function __constructor()
+    public function __construct()
     {
         $this->nodes = array();
         $this->nodesCount = 0;
@@ -37,7 +38,7 @@ class NaiveDistributionStrategy implements IDistributionStrategy
 
     public function remove($node)
     {
-        $this->nodes = array_filter($this->nodes, function($n) use($node) {
+        $this->nodes = array_filter($this->nodes, function ($n) use ($node) {
             return $n !== $node;
         });
 
@@ -46,24 +47,30 @@ class NaiveDistributionStrategy implements IDistributionStrategy
 
     public function get($key)
     {
-        $count = $this->nodesCount;
-        if ($count === 0) {
+        if (0 === $count = $this->nodesCount) {
             throw new RuntimeException('No connections');
         }
 
-        return $this->nodes[$count > 1 ? abs(crc32($key) % $count) : 0];
+        return $this->nodes[$count > 1 ? abs($key % $count) : 0];
     }
 
-    public function generateKey($value)
+    public function hash($value)
     {
         return crc32($value);
     }
+
+    public function getHashGenerator()
+    {
+        return $this;
+    }
 }
 
 $options = array(
-    'cluster' => function() {
+    'cluster' => function () {
         $distributor = new NaiveDistributionStrategy();
-        return new PredisCluster($distributor);
+        $cluster = new PredisCluster($distributor);
+
+        return $cluster;
     },
 );
 

examples/DispatcherLoop.php

@@ -60,7 +60,7 @@ class EventsListener implements Countable
 $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) {
+$dispatcher->attachCallback('control', function ($payload) use ($dispatcher) {
     if ($payload === 'terminate_dispatcher') {
         $dispatcher->stop();
     }

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'.
+*/

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);

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
+*/

examples/PipelineContext.php

@@ -16,7 +16,7 @@ require 'SharedConfigurations.php';
 
 $client = new Predis\Client($single_server);
 
-$replies = $client->pipeline(function($pipe) {
+$replies = $client->pipeline(function ($pipe) {
     $pipe->ping();
     $pipe->flushdb();
     $pipe->incrby('counter', 10);

examples/PubSubContext.php

@@ -18,7 +18,7 @@ require 'SharedConfigurations.php';
 $client = new Predis\Client($single_server + array('read_write_timeout' => 0));
 
 // Initialize a new pubsub context
-$pubsub = $client->pubSub();
+$pubsub = $client->pubSubLoop();
 
 // Subscribe to your channels
 $pubsub->subscribe('control_channel', 'notifications');
@@ -38,12 +38,10 @@ foreach ($pubsub as $message) {
                 if ($message->payload == 'quit_loop') {
                     echo "Aborting pubsub loop...\n";
                     $pubsub->unsubscribe();
-                }
-                else {
+                } else {
                     echo "Received an unrecognized command: {$message->payload}.\n";
                 }
-            }
-            else {
+            } else {
                 echo "Received the following message from {$message->channel}:\n",
                      "  {$message->payload}\n\n";
             }

examples/RedisCollectionsIterators.php

@@ -0,0 +1,96 @@
+<?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\Collection\Iterator;
+
+// Redis 2.8 features new commands allowing clients to incrementally
+// iterate over collections without blocking the server like it happens
+// when a command such as KEYS is executed on a Redis instance storing
+// millions of keys. These commands are SCAN (iterates over the keyspace),
+// SSCAN (iterates over members of a set), ZSCAN (iterates over members
+// and ranks of a sorted set) and HSCAN (iterates over fields and values
+// of an hash). Predis provides a specialized abstraction for each command
+// based on SPL iterators making it possible to easily consume SCAN-based
+// iterations in your PHP code.
+//
+// See http://redis.io/commands/scan for more details.
+//
+
+// Create a client using `2.8` as a server profile (needs Redis 2.8!)
+$client = new Predis\Client($single_server, array('profile' => '2.8'));
+
+// Prepare some keys for our example
+$client->del('predis:set', 'predis:zset', 'predis:hash');
+for ($i = 0; $i < 5; $i++) {
+    $client->sadd('predis:set', "member:$i");
+    $client->zadd('predis:zset', -$i, "member:$i");
+    $client->hset('predis:hash', "field:$i", "value:$i");
+}
+
+// === Keyspace iterator based on SCAN ===
+echo 'Scan the keyspace matching only our prefixed keys:', PHP_EOL;
+foreach (new Iterator\Keyspace($client, 'predis:*') as $key) {
+    echo " - $key", PHP_EOL;
+}
+
+/* OUTPUT
+Scan the keyspace matching only our prefixed keys:
+ - predis:zset
+ - predis:set
+ - predis:hash
+*/
+
+// === Set iterator based on SSCAN ===
+echo 'Scan members of `predis:set`:', PHP_EOL;
+foreach (new Iterator\SetKey($client, 'predis:set') as $member) {
+    echo " - $member", PHP_EOL;
+}
+
+/* OUTPUT
+Scan members of `predis:set`:
+ - member:1
+ - member:4
+ - member:0
+ - member:3
+ - member:2
+*/
+
+// === Sorted set iterator based on ZSCAN ===
+echo 'Scan members and ranks of `predis:zset`:', PHP_EOL;
+foreach (new Iterator\SortedSetKey($client, 'predis:zset') as $member => $rank) {
+    echo " - $member [rank: $rank]", PHP_EOL;
+}
+
+/* OUTPUT
+Scan members and ranks of `predis:zset`:
+ - member:4 [rank: -4]
+ - member:3 [rank: -3]
+ - member:2 [rank: -2]
+ - member:1 [rank: -1]
+ - member:0 [rank: 0]
+*/
+
+// === Hash iterator based on HSCAN ===
+echo 'Scan fields and values of `predis:hash`:', PHP_EOL;
+foreach (new Iterator\HashKey($client, 'predis:hash') as $field => $value) {
+    echo " - $field => $value", PHP_EOL;
+}
+
+/* OUTPUT
+Scan fields and values of `predis:hash`:
+ - field:0 => value:0
+ - field:1 => value:1
+ - field:2 => value:2
+ - field:3 => value:3
+ - field:4 => value:4
+*/

examples/ServerSideScripting.php

@@ -14,36 +14,53 @@ 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\Commands\ScriptedCommand base class can be used to build an higher abstraction
+// 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\Commands\ScriptedCommand;
+use Predis\Command\ScriptedCommand;
 
-class IncrementExistingKey extends ScriptedCommand
+class IncrementExistingKeysBy extends ScriptedCommand
 {
     public function getKeysCount()
     {
-        return 1;
+        // 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 = redis.call
-    if cmd('exists', KEYS[1]) == 1 then
-        return cmd('incr', KEYS[1])
-    end
+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, 'dev');
+$client = new Predis\Client($single_server);
 
-$client->getProfile()->defineCommand('increx', 'IncrementExistingKey');
+$client->getProfile()->defineCommand('increxby', 'IncrementExistingKeysBy');
 
-$client->set('foo', 10);
+$client->mset('foo', 10, 'foobar', 100);
 
-var_dump($client->increx('foo'));       // int(11)
-var_dump($client->increx('bar'));       // NULL
+var_export($client->increxby('foo', 'foofoo', 'foobar', 50));
+
+/*
+array (
+  0 => 60,
+  1 => NULL,
+  2 => 150,
+)
+*/

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";
+}

examples/SimpleDebuggableConnection.php

@@ -11,9 +11,8 @@
 
 require 'SharedConfigurations.php';
 
-use Predis\ConnectionParameters;
-use Predis\Commands\ICommand;
-use Predis\Network\StreamConnection;
+use Predis\Command\CommandInterface;
+use Predis\Connection\StreamConnection;
 
 class SimpleDebuggableConnection extends StreamConnection
 {
@@ -27,7 +26,7 @@ class SimpleDebuggableConnection extends StreamConnection
         parent::connect();
     }
 
-    private function storeDebug(ICommand $command, $direction)
+    private function storeDebug(CommandInterface $command, $direction)
     {
         $firtsArg  = $command->getArgument(0);
         $timestamp = round(microtime(true) - $this->tstart, 4);
@@ -40,14 +39,14 @@ class SimpleDebuggableConnection extends StreamConnection
         $this->debugBuffer[] = $debug;
     }
 
-    public function writeCommand(ICommand $command)
+    public function writeCommand(CommandInterface $command)
     {
         parent::writeCommand($command);
 
         $this->storeDebug($command, '->');
     }
 
-    public function readResponse(ICommand $command)
+    public function readResponse(CommandInterface $command)
     {
         $reply = parent::readResponse($command);
         $this->storeDebug($command, '<-');

examples/TransactionWithCAS.php

@@ -33,7 +33,7 @@ function zpop($client, $key)
                             // which the client bails out with an exception.
     );
 
-    $client->multiExec($options, function($tx) use ($key, &$element) {
+    $client->transaction($options, function ($tx) use ($key, &$element) {
         @list($element) = $tx->zrange($key, 0, 0);
 
         if (isset($element)) {

lib/Predis/Autoloader.php

@@ -15,27 +15,32 @@ namespace Predis;
  * Implements a lightweight PSR-0 compliant autoloader.
  *
  * @author Eric Naeseth <eric@thumbtack.com>
+ * @author Daniele Alessandri <suppakilla@gmail.com>
  */
 class Autoloader
 {
-    private $baseDir;
+    private $directory;
     private $prefix;
+    private $prefixLength;
 
     /**
      * @param string $baseDirectory Base directory where the source files are located.
      */
-    public function __construct($baseDirectory = null)
+    public function __construct($baseDirectory = __DIR__)
     {
-        $this->baseDir = $baseDirectory ?: dirname(__FILE__);
+        $this->directory = $baseDirectory;
         $this->prefix = __NAMESPACE__ . '\\';
+        $this->prefixLength = strlen($this->prefix);
     }
 
     /**
      * Registers the autoloader class with the PHP SPL autoloader.
+     *
+     * @param bool $prepend Prepend the autoloader on the stack instead of appending it.
      */
-    public static function register()
+    public static function register($prepend = false)
     {
-        spl_autoload_register(array(new self, 'autoload'));
+        spl_autoload_register(array(new self, 'autoload'), true, $prepend);
     }
 
     /**
@@ -45,13 +50,13 @@ class Autoloader
      */
     public function autoload($className)
     {
-        if (0 !== strpos($className, $this->prefix)) {
-            return;
+        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);
+            }
         }
-
-        $relativeClassName = substr($className, strlen($this->prefix));
-        $classNameParts = explode('\\', $relativeClassName);
-
-        require_once $this->baseDir.DIRECTORY_SEPARATOR.implode(DIRECTORY_SEPARATOR, $classNameParts).'.php';
     }
 }

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);
+}

lib/Predis/Client.php

@@ -11,15 +11,16 @@
 
 namespace Predis;
 
-use Predis\Commands\ICommand;
-use Predis\Options\IClientOptions;
-use Predis\Network\IConnection;
-use Predis\Network\IConnectionSingle;
-use Predis\Profiles\IServerProfile;
-use Predis\Options\ClientOptions;
-use Predis\Profiles\ServerProfile;
-use Predis\PubSub\PubSubContext;
+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\PubSub\PubSubContext;
 use Predis\Transaction\MultiExecContext;
 
 /**
@@ -27,52 +28,48 @@ use Predis\Transaction\MultiExecContext;
  *
  * @author Daniele Alessandri <suppakilla@gmail.com>
  */
-class Client
+class Client implements ClientInterface
 {
-    const VERSION = '0.7.0';
+    const VERSION = '0.8.5';
 
     private $options;
     private $profile;
     private $connection;
-    private $connections;
 
     /**
      * 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.
+     * @param mixed $options    Options that specify certain behaviours for the client.
      */
     public function __construct($parameters = null, $options = null)
     {
-        $options = $this->filterOptions($options);
-        $this->options = $options;
-        $this->profile = $options->profile;
-        $this->connections = $options->connections;
+        $this->options = $this->filterOptions($options);
+        $this->profile = $this->options->profile;
         $this->connection = $this->initializeConnection($parameters);
     }
 
     /**
-     * Creates an instance of Predis\Options\ClientOptions from various types of
-     * arguments (string, array, Predis\Profiles\ServerProfile) or returns the
-     * passed object if it is an instance of Predis\Options\ClientOptions.
+     * 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.
+     * @param  mixed         $options Client options.
      * @return ClientOptions
      */
     protected function filterOptions($options)
     {
-        if ($options === null) {
+        if (!isset($options)) {
             return new ClientOptions();
         }
+
         if (is_array($options)) {
             return new ClientOptions($options);
         }
-        if ($options instanceof IClientOptions) {
+
+        if ($options instanceof ClientOptionsInterface) {
             return $options;
         }
-        if ($options instanceof IServerProfile || is_string($options)) {
-            return new ClientOptions(array('profile' => $options));
-        }
 
         throw new \InvalidArgumentException("Invalid type for client options");
     }
@@ -80,27 +77,42 @@ class Client
     /**
      * Initializes one or multiple connection (cluster) objects from various
      * types of arguments (string, array) or returns the passed object if it
-     * implements the Predis\Network\IConnection interface.
+     * implements Predis\Connection\ConnectionInterface.
      *
-     * @param mixed $parameters Connection parameters or instance.
-     * @return IConnection
+     * @param  mixed               $parameters Connection parameters or instance.
+     * @return ConnectionInterface
      */
     protected function initializeConnection($parameters)
     {
-        if ($parameters instanceof IConnection) {
+        if ($parameters instanceof ConnectionInterface) {
             return $parameters;
         }
+
         if (is_array($parameters) && isset($parameters[0])) {
-            return $this->connections->createCluster($this->options->cluster, $parameters, $this->profile);
+            $options = $this->options;
+            $replication = isset($options->replication) && $options->replication;
+            $connection = $options->{$replication ? 'replication' : 'cluster'};
+
+            return $options->connections->createAggregated($connection, $parameters);
         }
 
-        return $this->connections->create($parameters, $this->profile);
+        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);
     }
 
     /**
-     * Returns the server profile used by the client.
-     *
-     * @return IServerProfile
+     * {@inheritdoc}
      */
     public function getProfile()
     {
@@ -108,9 +120,7 @@ class Client
     }
 
     /**
-     * Returns the client options specified upon initialization.
-     *
-     * @return ClientOptions
+     * {@inheritdoc}
      */
     public function getOptions()
     {
@@ -120,11 +130,11 @@ class Client
     /**
      * Returns the connection factory object used by the client.
      *
-     * @return IConnectionFactory
+     * @return ConnectionFactoryInterface
      */
     public function getConnectionFactory()
     {
-        return $this->connections;
+        return $this->options->connections;
     }
 
     /**
@@ -132,15 +142,16 @@ class Client
      * client is connected to a cluster. The new instance will use the same
      * options of the original client.
      *
+     * @param  string $connectionID Identifier for the connection.
      * @return Client
      */
-    public function getClientFor($connectionAlias)
+    public function getClientFor($connectionID)
     {
-        if (($connection = $this->getConnection($connectionAlias)) === null) {
-            throw new \InvalidArgumentException("Invalid connection alias: '$connectionAlias'");
+        if (!$connection = $this->getConnectionById($connectionID)) {
+            throw new \InvalidArgumentException("Invalid connection ID: '$connectionID'");
         }
 
-        return new Client($connection, $this->options);
+        return new static($connection, $this->options);
     }
 
     /**
@@ -172,8 +183,8 @@ class Client
     /**
      * 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.
+     * @return bool True means that the connection is open.
+     *              False means that the connection is closed.
      */
     public function isConnected()
     {
@@ -181,80 +192,97 @@ class Client
     }
 
     /**
-     * Returns the underlying connection instance or, when connected to a cluster,
-     * one of the connection instances identified by its alias.
-     *
-     * @param string $id The alias of a connection when connected to a cluster.
-     * @return IConnection
+     * {@inheritdoc}
      */
-    public function getConnection($id = null)
+    public function getConnection()
     {
-        if (isset($id)) {
-            if (!Helpers::isCluster($this->connection)) {
-                $message = 'Retrieving connections by alias is supported only with clustered connections';
-                throw new NotSupportedException($message);
-            }
-            return $this->connection->getConnectionById($id);
-        }
-
         return $this->connection;
     }
 
     /**
-     * Dinamically invokes a Redis command with the specified arguments.
+     * Retrieves a single connection out of an aggregated connections instance.
      *
-     * @param string $method The name of a Redis command.
-     * @param array $arguments The arguments for the command.
-     * @return mixed
+     * @param  string                               $connectionId Index or alias of the single connection.
+     * @return Connection\SingleConnectionInterface
      */
-    public function __call($method, $arguments)
+    public function getConnectionById($connectionId)
     {
-        $command = $this->profile->createCommand($method, $arguments);
-        return $this->connection->executeCommand($command);
-    }
-
-    /**
-     * 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 ICommand
-     */
-    public function createCommand($method, $arguments = array())
-    {
-        return $this->profile->createCommand($method, $arguments);
-    }
-
-    /**
-     * Executes the specified Redis command.
-     *
-     * @param ICommand $command A Redis command.
-     * @return mixed
-     */
-    public function executeCommand(ICommand $command)
-    {
-        return $this->connection->executeCommand($command);
-    }
-
-    /**
-     * Executes the specified Redis command on all the nodes of a cluster.
-     *
-     * @param ICommand $command A Redis command.
-     * @return array
-     */
-    public function executeCommandOnShards(ICommand $command)
-    {
-        if (Helpers::isCluster($this->connection)) {
-            $replies = array();
-
-            foreach ($this->connection as $connection) {
-                $replies[] = $connection->executeCommand($command);
-            }
-
-            return $replies;
+        if (!$this->connection instanceof AggregatedConnectionInterface) {
+            throw new NotSupportedException('Retrieving connections by ID is supported only when using aggregated connections');
         }
 
-        return array($this->connection->executeCommand($command));
+        return $this->connection->getConnectionById($connectionId);
+    }
+
+    /**
+     * Creates a Redis command with the specified arguments and sends a request
+     * to the server.
+     *
+     * @param  string $commandID Command ID.
+     * @param  array  $arguments Arguments for the command.
+     * @return mixed
+     */
+    public function __call($commandID, $arguments)
+    {
+        $command = $this->createCommand($commandID, $arguments);
+        $response = $this->executeCommand($command);
+
+        return $response;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function createCommand($commandID, $arguments = array())
+    {
+        return $this->profile->createCommand($commandID, $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;
     }
 
     /**
@@ -262,8 +290,8 @@ class Client
      *
      * TODO: Invert $argv and $initializer.
      *
-     * @param array $argv Arguments for the initializer.
-     * @param string $initializer The initializer method.
+     * @param  array  $argv        Arguments for the initializer.
+     * @param  string $initializer The initializer method.
      * @return mixed
      */
     private function sharedInitializer($argv, $initializer)
@@ -274,10 +302,12 @@ class Client
 
             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:
@@ -289,7 +319,7 @@ class Client
      * 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.
+     * @param  mixed                 ... Options for the context, a callable object, or both.
      * @return PipelineContext|array
      */
     public function pipeline(/* arguments */)
@@ -300,21 +330,29 @@ class Client
     /**
      * Pipeline context initializer.
      *
-     * @param array $options Options for the context.
-     * @param mixed $callable Optional callable object used to execute the context.
+     * @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)
     {
-        $pipeline = new PipelineContext($this, $options);
-        return $this->pipelineExecute($pipeline, $callable);
+        $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.
+     * @param  PipelineContext       $pipeline Pipeline context instance.
+     * @param  mixed                 $callable Optional callable object used to execute the context.
      * @return PipelineContext|array
      */
     private function pipelineExecute(PipelineContext $pipeline, $callable)
@@ -326,7 +364,11 @@ class Client
      * 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.
+     * @deprecated You should start using the new Client::transaction() method
+     *             as it will replace Client::multiExec() in the next major
+     *             version of the library.
+     *
+     * @param  mixed                  ... Options for the context, a callable object, or both.
      * @return MultiExecContext|array
      */
     public function multiExec(/* arguments */)
@@ -334,16 +376,29 @@ class Client
         return $this->sharedInitializer(func_get_args(), 'initMultiExec');
     }
 
+    /**
+     * Creates a new transaction context and returns it, or returns the results of
+     * a transaction executed inside the optionally provided callable object.
+     *
+     * @param  mixed                  ... Options for the context, a callable object, or both.
+     * @return MultiExecContext|array
+     */
+    public function transaction(/* 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.
+     * @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;
     }
 
@@ -351,10 +406,27 @@ class Client
      * 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
+     * @deprecated This method will change in the next major release to support
+     *             the new PUBSUB command introduced in Redis 2.8. Please use
+     *             Client::pubSubLoop() to create Predis\PubSub\PubSubContext
+     *             instances from now on.
+     *
+     * @param  mixed               ... Options for the context, a callable object, or both.
+     * @return PubSubContext|array
      */
     public function pubSub(/* arguments */)
+    {
+        return call_user_func_array(array($this, 'pubSubLoop'), func_get_args());
+    }
+
+    /**
+     * Creates a new Publish / Subscribe context and returns it, or executes it
+     * inside the optionally provided callable object.
+     *
+     * @param  mixed               ... Options for the context, a callable object, or both.
+     * @return PubSubContext|array
+     */
+    public function pubSubLoop(/* arguments */)
     {
         return $this->sharedInitializer(func_get_args(), 'initPubSub');
     }
@@ -362,8 +434,8 @@ class Client
     /**
      * Publish / Subscribe context initializer.
      *
-     * @param array $options Options for the context.
-     * @param mixed $callable Optional callable object used to execute the context.
+     * @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)

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());
+}

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);
+}

lib/Predis/Cluster/Distribution/DistributionStrategyInterface.php

@@ -9,7 +9,9 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Distribution;
+namespace Predis\Cluster\Distribution;
+
+use Predis\Cluster\Hash\HashGeneratorInterface;
 
 /**
  * A distributor implements the logic to automatically distribute
@@ -17,13 +19,13 @@ namespace Predis\Distribution;
  *
  * @author Daniele Alessandri <suppakilla@gmail.com>
  */
-interface IDistributionStrategy extends INodeKeyGenerator
+interface DistributionStrategyInterface
 {
     /**
      * Adds a node to the distributor with an optional weight.
      *
-     * @param mixed $node Node object.
-     * @param int $weight Weight for the node.
+     * @param mixed $node   Node object.
+     * @param int   $weight Weight for the node.
      */
     public function add($node, $weight = null);
 
@@ -37,7 +39,15 @@ interface IDistributionStrategy extends INodeKeyGenerator
     /**
      * Gets a node from the distributor using the computed hash of a key.
      *
+     * @param  mixed $key
      * @return mixed
      */
     public function get($key);
+
+    /**
+     * Returns the underlying hash generator instance.
+     *
+     * @return HashGeneratorInterface
+     */
+    public function getHashGenerator();
 }

lib/Predis/Cluster/Distribution/EmptyRingException.php

@@ -9,7 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Distribution;
+namespace Predis\Cluster\Distribution;
 
 /**
  * Exception class that identifies empty rings.

lib/Predis/Cluster/Distribution/HashRing.php

@@ -9,7 +9,9 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Distribution;
+namespace Predis\Cluster\Distribution;
+
+use Predis\Cluster\Hash\HashGeneratorInterface;
 
 /**
  * This class implements an hashring-based distributor that uses the same
@@ -19,31 +21,33 @@ namespace Predis\Distribution;
  * @author Daniele Alessandri <suppakilla@gmail.com>
  * @author Lorenzo Castelli <lcastelli@gmail.com>
  */
-class HashRing implements IDistributionStrategy
+class HashRing implements DistributionStrategyInterface, HashGeneratorInterface
 {
     const DEFAULT_REPLICAS = 128;
     const DEFAULT_WEIGHT   = 100;
 
-    private $nodes;
     private $ring;
     private $ringKeys;
     private $ringKeysCount;
     private $replicas;
+    private $nodeHashCallback;
+    private $nodes = array();
 
     /**
-     * @param int $replicas Number of replicas in the ring.
+     * @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)
+    public function __construct($replicas = self::DEFAULT_REPLICAS, $nodeHashCallback = null)
     {
         $this->replicas = $replicas;
-        $this->nodes    = array();
+        $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.
+     * @param mixed $node   Node object.
+     * @param int   $weight Weight for the node.
      */
     public function add($node, $weight = null)
     {
@@ -86,7 +90,7 @@ class HashRing implements IDistributionStrategy
     /**
      * Returns the initialization status of the distributor.
      *
-     * @return Boolean
+     * @return bool
      */
     private function isInitialized()
     {
@@ -101,6 +105,7 @@ class HashRing implements IDistributionStrategy
     private function computeTotalWeight()
     {
         $totalWeight = 0;
+
         foreach ($this->nodes as $node) {
             $totalWeight += $node['weight'];
         }
@@ -117,20 +122,20 @@ class HashRing implements IDistributionStrategy
             return;
         }
 
-        if (count($this->nodes) === 0) {
+        if (!$this->nodes) {
             throw new EmptyRingException('Cannot initialize empty hashring');
         }
 
         $this->ring = array();
         $totalWeight = $this->computeTotalWeight();
-        $nodesCount  = count($this->nodes);
+        $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);
 
+        ksort($this->ring, SORT_NUMERIC);
         $this->ringKeys = array_keys($this->ring);
         $this->ringKeysCount = count($this->ringKeys);
     }
@@ -138,10 +143,10 @@ class HashRing implements IDistributionStrategy
     /**
      * 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 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)
@@ -161,16 +166,20 @@ class HashRing implements IDistributionStrategy
      */
     protected function getNodeHash($nodeObject)
     {
-        return (string) $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.
+     * @param  string $value Input value.
      * @return int
      */
-    public function generateKey($value)
+    public function hash($value)
     {
         return crc32($value);
     }
@@ -186,7 +195,7 @@ class HashRing implements IDistributionStrategy
     /**
      * Calculates the corrisponding key of a node distributed in the hashring.
      *
-     * @param int $key Computed hash of a key.
+     * @param  int $key Computed hash of a key.
      * @return int
      */
     private function getNodeKey($key)
@@ -199,13 +208,12 @@ class HashRing implements IDistributionStrategy
         while ($lower <= $upper) {
             $index = ($lower + $upper) >> 1;
             $item  = $ringKeys[$index];
+
             if ($item > $key) {
                 $upper = $index - 1;
-            }
-            else if ($item < $key) {
+            } elseif ($item < $key) {
                 $lower = $index + 1;
-            }
-            else {
+            } else {
                 return $item;
             }
         }
@@ -216,9 +224,9 @@ class HashRing implements IDistributionStrategy
     /**
      * Implements a strategy to deal with wrap-around errors during binary searches.
      *
-     * @param int $upper
-     * @param int $lower
-     * @param int $ringKeysCount
+     * @param  int $upper
+     * @param  int $lower
+     * @param  int $ringKeysCount
      * @return int
      */
     protected function wrapAroundStrategy($upper, $lower, $ringKeysCount)
@@ -227,4 +235,12 @@ class HashRing implements IDistributionStrategy
         // 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;
+    }
 }

lib/Predis/Cluster/Distribution/KetamaPureRing.php

@@ -9,7 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Distribution;
+namespace Predis\Cluster\Distribution;
 
 /**
  * This class implements an hashring-based distributor that uses the same
@@ -24,11 +24,11 @@ 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()
+    public function __construct($nodeHashCallback = null)
     {
-        parent::__construct($this::DEFAULT_REPLICAS);
+        parent::__construct($this::DEFAULT_REPLICAS, $nodeHashCallback);
     }
 
     /**
@@ -42,6 +42,7 @@ class KetamaPureRing extends HashRing
 
         for ($i = 0; $i < $replicas; $i++) {
             $unpackedDigest = unpack('V4', md5("$nodeHash-$i", true));
+
             foreach ($unpackedDigest as $key) {
                 $ring[$key] = $nodeObject;
             }
@@ -51,9 +52,10 @@ class KetamaPureRing extends HashRing
     /**
      * {@inheritdoc}
      */
-    public function generateKey($value)
+    public function hash($value)
     {
         $hash = unpack('V', md5($value, true));
+
         return $hash[1];
     }
 

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;
+    }
+}

lib/Predis/Cluster/Hash/HashGeneratorInterface.php

@@ -9,7 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Distribution;
+namespace Predis\Cluster\Hash;
 
 /**
  * A generator of node keys implements the logic used to calculate the hash of
@@ -17,13 +17,13 @@ namespace Predis\Distribution;
  *
  * @author Daniele Alessandri <suppakilla@gmail.com>
  */
-interface INodeKeyGenerator
+interface HashGeneratorInterface
 {
     /**
      * Generates an hash that is used by the distributor algorithm
      *
-     * @param string $value Value used to generate the hash.
+     * @param  string $value Value used to generate the hash.
      * @return int
      */
-    public function generateKey($value);
+    public function hash($value);
 }

lib/Predis/Cluster/PredisClusterHashStrategy.php

@@ -0,0 +1,389 @@
+<?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,
+            'SSCAN'                 => $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'),
+            'ZSCAN'                 => $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,
+            'HSCAN'                 => $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 bool
+     */
+    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;
+    }
+}

lib/Predis/Cluster/RedisClusterHashStrategy.php

@@ -0,0 +1,292 @@
+<?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,
+            'SSCAN'                 => $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,
+            'ZSCAN'                 => $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,
+            'HSCAN'                 => $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);
+    }
+}

lib/Predis/Collection/Iterator/CursorBasedIterator.php

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

lib/Predis/Collection/Iterator/HashKey.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.
+ */
+
+namespace Predis\Collection\Iterator;
+
+use Predis\ClientInterface;
+
+/**
+ * Abstracts the iteration of fields and values of an hash
+ * by leveraging the HSCAN command (Redis >= 2.8) wrapped
+ * in a fully-rewindable PHP iterator.
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ * @link http://redis.io/commands/scan
+ */
+class HashKey extends CursorBasedIterator
+{
+    protected $key;
+
+    /**
+     * {@inheritdoc}
+     */
+    public function __construct(ClientInterface $client, $key, $match = null, $count = null)
+    {
+        $this->requiredCommand($client, 'HSCAN');
+
+        parent::__construct($client, $match, $count);
+
+        $this->key = $key;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function executeCommand()
+    {
+        return $this->client->hscan($this->key, $this->cursor, $this->getScanOptions());
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function extractNext()
+    {
+        $this->position = key($this->elements);
+        $this->current = array_shift($this->elements);
+    }
+}

lib/Predis/Collection/Iterator/Keyspace.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\Collection\Iterator;
+
+use Predis\ClientInterface;
+
+/**
+ * Abstracts the iteration of the keyspace on a Redis instance
+ * by leveraging the SCAN command (Redis >= 2.8) wrapped in a
+ * fully-rewindable PHP iterator.
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ * @link http://redis.io/commands/scan
+ */
+class Keyspace extends CursorBasedIterator
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function __construct(ClientInterface $client, $match = null, $count = null)
+    {
+        $this->requiredCommand($client, 'SCAN');
+
+        parent::__construct($client, $match, $count);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function executeCommand()
+    {
+        return $this->client->scan($this->cursor, $this->getScanOptions());
+    }
+}

lib/Predis/Collection/Iterator/ListKey.php

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

lib/Predis/Collection/Iterator/SetKey.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\Collection\Iterator;
+
+use Predis\ClientInterface;
+
+/**
+ * Abstracts the iteration of members stored in a set by
+ * leveraging the SSCAN command (Redis >= 2.8) wrapped in
+ * a fully-rewindable PHP iterator.
+ *
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ * @link http://redis.io/commands/scan
+ */
+class SetKey extends CursorBasedIterator
+{
+    protected $key;
+
+    /**
+     * {@inheritdoc}
+     */
+    public function __construct(ClientInterface $client, $key, $match = null, $count = null)
+    {
+        $this->requiredCommand($client, 'SSCAN');
+
+        parent::__construct($client, $match, $count);
+
+        $this->key = $key;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function executeCommand()
+    {
+        return $this->client->sscan($this->key, $this->cursor, $this->getScanOptions());
+    }
+}

lib/Predis/Collection/Iterator/SortedSetKey.php

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

lib/Predis/Command/AbstractCommand.php

@@ -9,17 +9,14 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
-
-use Predis\Helpers;
-use Predis\Distribution\INodeKeyGenerator;
+namespace Predis\Command;
 
 /**
  * Base class for Redis commands.
  *
  * @author Daniele Alessandri <suppakilla@gmail.com>
  */
-abstract class Command implements ICommand
+abstract class AbstractCommand implements CommandInterface
 {
     private $hash;
     private $arguments = array();
@@ -27,7 +24,7 @@ abstract class Command implements ICommand
     /**
      * Returns a filtered array of the arguments.
      *
-     * @param array $arguments List of arguments.
+     * @param  array $arguments List of arguments.
      * @return array
      */
     protected function filterArguments(Array $arguments)
@@ -45,9 +42,7 @@ abstract class Command implements ICommand
     }
 
     /**
-     * Sets the arguments array without filtering.
-     *
-     * @param array $arguments List of arguments.
+     * {@inheritdoc}
      */
     public function setRawArguments(Array $arguments)
     {
@@ -64,69 +59,31 @@ abstract class Command implements ICommand
     }
 
     /**
-     * Gets the argument from the arguments list at the specified index.
-     *
-     * @param array $arguments Position of the argument.
+     * {@inheritdoc}
      */
-    public function getArgument($index = 0)
+    public function getArgument($index)
     {
-        if (isset($this->arguments[$index]) === true) {
+        if (isset($this->arguments[$index])) {
             return $this->arguments[$index];
         }
     }
 
     /**
-     * Checks if the command can return an hash for client-side sharding.
-     *
-     * @return Boolean
+     * {@inheritdoc}
      */
-    protected function canBeHashed()
+    public function setHash($hash)
     {
-        return isset($this->arguments[0]);
-    }
-
-    /**
-     * 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)) === 0) {
-            return false;
-        }
-
-        $currentKey = Helpers::extractKeyTag($keys[0]);
-
-        for ($i = 1; $i < $count; $i++) {
-            $nextKey = Helpers::extractKeyTag($keys[$i]);
-            if ($currentKey !== $nextKey) {
-                return false;
-            }
-            $currentKey = $nextKey;
-        }
-
-        return true;
+        $this->hash = $hash;
     }
 
     /**
      * {@inheritdoc}
      */
-    public function getHash(INodeKeyGenerator $distributor)
+    public function getHash()
     {
         if (isset($this->hash)) {
             return $this->hash;
         }
-
-        if ($this->canBeHashed()) {
-            $key = Helpers::extractKeyTag($this->arguments[0]);
-            $this->hash = $distributor->generateKey($key);
-
-            return $this->hash;
-        }
-
-        return null;
     }
 
     /**
@@ -140,8 +97,8 @@ abstract class Command implements ICommand
     /**
      * Helper function used to reduce a list of arguments to a string.
      *
-     * @param string $accumulator Temporary string.
-     * @param string $argument Current argument.
+     * @param  string $accumulator Temporary string.
+     * @param  string $argument    Current argument.
      * @return string
      */
     protected function toStringArgumentReducer($accumulator, $argument)
@@ -149,6 +106,7 @@ abstract class Command implements ICommand
         if (strlen($argument) > 32) {
             $argument = substr($argument, 0, 32) . '[...]';
         }
+
         $accumulator .= " $argument";
 
         return $accumulator;
@@ -167,4 +125,34 @@ abstract class Command implements ICommand
             $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;
+    }
 }

lib/Predis/Command/CommandInterface.php

@@ -9,15 +9,13 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
-
-use Predis\Distribution\INodeKeyGenerator;
+namespace Predis\Command;
 
 /**
  * Defines an abstraction representing a Redis command.
  * @author Daniele Alessandri <suppakilla@gmail.com>
  */
-interface ICommand
+interface CommandInterface
 {
     /**
      * Gets the ID of a Redis command.
@@ -27,21 +25,33 @@ interface ICommand
     public function getId();
 
     /**
-     * Returns an hash of the command using the provided algorithm against the
-     * key (used to calculate the distribution of keys with client-side sharding).
+     * Set the hash for the command.
      *
-     * @param INodeKeyGenerator $distributor Distribution algorithm.
-     * @return int
+     * @param int $hash Calculated hash.
      */
-    public function getHash(INodeKeyGenerator $distributor);
+    public function setHash($hash);
 
     /**
-     * Sets the arguments of the command.
+     * 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.
      *
@@ -49,10 +59,18 @@ interface ICommand
      */
     public function getArguments();
 
+    /**
+     * Gets the argument of the command at the specified index.
+     *
+     * @param  int   $index Index of the desired argument.
+     * @return mixed
+     */
+    public function getArgument($index);
+
     /**
      * Parses a reply buffer and returns a PHP object.
      *
-     * @param string $data Binary string containing the whole reply.
+     * @param  string $data Binary string containing the whole reply.
      * @return mixed
      */
     public function parseResponse($data);

lib/Predis/Command/ConnectionAuth.php

@@ -9,19 +9,19 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
+namespace Predis\Command;
 
 /**
- * @link http://redis.io/commands/evalsha
+ * @link http://redis.io/commands/auth
  * @author Daniele Alessandri <suppakilla@gmail.com>
  */
-class ServerEvalSHA extends ServerEval
+class ConnectionAuth extends AbstractCommand
 {
     /**
      * {@inheritdoc}
      */
     public function getId()
     {
-        return 'EVALSHA';
+        return 'AUTH';
     }
 }

lib/Predis/Command/ConnectionEcho.php

@@ -9,13 +9,13 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/echo
  * @author Daniele Alessandri <suppakilla@gmail.com>
  */
-class ConnectionEcho extends Command
+class ConnectionEcho extends AbstractCommand
 {
     /**
      * {@inheritdoc}
@@ -24,12 +24,4 @@ class ConnectionEcho extends Command
     {
         return 'ECHO';
     }
-
-    /**
-     * {@inheritdoc}
-     */
-    protected function canBeHashed()
-    {
-        return false;
-    }
 }

lib/Predis/Command/ConnectionPing.php

@@ -9,13 +9,13 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/ping
  * @author Daniele Alessandri <suppakilla@gmail.com>
  */
-class ConnectionPing extends Command
+class ConnectionPing extends AbstractCommand
 {
     /**
      * {@inheritdoc}
@@ -25,14 +25,6 @@ class ConnectionPing extends Command
         return 'PING';
     }
 
-    /**
-     * {@inheritdoc}
-     */
-    protected function canBeHashed()
-    {
-        return false;
-    }
-
     /**
      * {@inheritdoc}
      */

lib/Predis/Command/ConnectionQuit.php

@@ -9,13 +9,13 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/quit
  * @author Daniele Alessandri <suppakilla@gmail.com>
  */
-class ConnectionQuit extends Command
+class ConnectionQuit extends AbstractCommand
 {
     /**
      * {@inheritdoc}
@@ -24,12 +24,4 @@ class ConnectionQuit extends Command
     {
         return 'QUIT';
     }
-
-    /**
-     * {@inheritdoc}
-     */
-    protected function canBeHashed()
-    {
-        return false;
-    }
 }

lib/Predis/Command/ConnectionSelect.php

@@ -9,13 +9,13 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/select
  * @author Daniele Alessandri <suppakilla@gmail.com>
  */
-class ConnectionSelect extends Command
+class ConnectionSelect extends AbstractCommand
 {
     /**
      * {@inheritdoc}
@@ -24,12 +24,4 @@ class ConnectionSelect extends Command
     {
         return 'SELECT';
     }
-
-    /**
-     * {@inheritdoc}
-     */
-    protected function canBeHashed()
-    {
-        return false;
-    }
 }

lib/Predis/Command/HashDelete.php

@@ -9,9 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
-
-use Predis\Helpers;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/hdel
@@ -32,6 +30,6 @@ class HashDelete extends PrefixableCommand
      */
     protected function filterArguments(Array $arguments)
     {
-        return Helpers::filterVariadicValues($arguments);
+        return self::normalizeVariadic($arguments);
     }
 }

lib/Predis/Command/HashExists.php

@@ -9,7 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/hexists

lib/Predis/Command/HashGet.php

@@ -9,7 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/hget

lib/Predis/Command/HashGetAll.php

@@ -9,9 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
-
-use Predis\Iterators\MultiBulkResponseTuple;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/hgetall
@@ -32,11 +30,8 @@ class HashGetAll extends PrefixableCommand
      */
     public function parseResponse($data)
     {
-        if ($data instanceof \Iterator) {
-            return new MultiBulkResponseTuple($data);
-        }
-
         $result = array();
+
         for ($i = 0; $i < count($data); $i++) {
             $result[$data[$i]] = $data[++$i];
         }

lib/Predis/Command/HashGetMultiple.php

@@ -9,9 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
-
-use Predis\Helpers;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/hmget
@@ -32,6 +30,6 @@ class HashGetMultiple extends PrefixableCommand
      */
     protected function filterArguments(Array $arguments)
     {
-        return Helpers::filterVariadicValues($arguments);
+        return self::normalizeVariadic($arguments);
     }
 }

lib/Predis/Command/HashIncrementBy.php

@@ -9,7 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/hincrby

lib/Predis/Command/HashIncrementByFloat.php

@@ -9,7 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/hincrbyfloat

lib/Predis/Command/HashKeys.php

@@ -9,7 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/hkeys

lib/Predis/Command/HashLength.php

@@ -9,7 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/hlen

lib/Predis/Command/HashScan.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.
+ */
+
+namespace Predis\Command;
+
+/**
+ * @link http://redis.io/commands/hscan
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class HashScan extends PrefixableCommand
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'HSCAN';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function filterArguments(Array $arguments)
+    {
+        if (count($arguments) === 3 && is_array($arguments[2])) {
+            $options = $this->prepareOptions(array_pop($arguments));
+            $arguments = array_merge($arguments, $options);
+        }
+
+        return $arguments;
+    }
+
+    /**
+     * Returns a list of options and modifiers compatible with Redis.
+     *
+     * @param  array $options List of options.
+     * @return array
+     */
+    protected function prepareOptions($options)
+    {
+        $options = array_change_key_case($options, CASE_UPPER);
+        $normalized = array();
+
+        if (!empty($options['MATCH'])) {
+            $normalized[] = 'MATCH';
+            $normalized[] = $options['MATCH'];
+        }
+
+        if (!empty($options['COUNT'])) {
+            $normalized[] = 'COUNT';
+            $normalized[] = $options['COUNT'];
+        }
+
+        return $normalized;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function parseResponse($data)
+    {
+        if (is_array($data)) {
+            $data[0] = (int) $data[0];
+            $fields = $data[1];
+            $result = array();
+
+            for ($i = 0; $i < count($fields); $i++) {
+                $result[$fields[$i]] = $fields[++$i];
+            }
+
+            $data[1] = $result;
+        }
+
+        return $data;
+    }
+}

lib/Predis/Command/HashSet.php

@@ -9,7 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/hset

lib/Predis/Command/HashSetMultiple.php

@@ -9,7 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/hmset

lib/Predis/Command/HashSetPreserve.php

@@ -9,7 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/hsetnx

lib/Predis/Command/HashValues.php

@@ -9,7 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/hvals

lib/Predis/Command/KeyDelete.php

@@ -9,15 +9,13 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
-
-use Predis\Helpers;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/del
  * @author Daniele Alessandri <suppakilla@gmail.com>
  */
-class KeyDelete extends Command implements IPrefixable
+class KeyDelete extends AbstractCommand implements PrefixableCommandInterface
 {
     /**
      * {@inheritdoc}
@@ -32,7 +30,7 @@ class KeyDelete extends Command implements IPrefixable
      */
     protected function filterArguments(Array $arguments)
     {
-        return Helpers::filterArrayArguments($arguments);
+        return self::normalizeArguments($arguments);
     }
 
     /**
@@ -42,17 +40,4 @@ class KeyDelete extends Command implements IPrefixable
     {
         PrefixHelpers::all($this, $prefix);
     }
-
-    /**
-     * {@inheritdoc}
-     */
-    protected function canBeHashed()
-    {
-        $args = $this->getArguments();
-        if (count($args) === 1) {
-            return true;
-        }
-
-        return $this->checkSameHashForKeys($args);
-    }
 }

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';
+    }
+}

lib/Predis/Command/KeyExists.php

@@ -9,7 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/exists

lib/Predis/Command/KeyExpire.php

@@ -9,7 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/expire

lib/Predis/Command/KeyExpireAt.php

@@ -9,7 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/expireat

lib/Predis/Command/KeyKeys.php

@@ -9,7 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/keys
@@ -24,12 +24,4 @@ class KeyKeys extends PrefixableCommand
     {
         return 'KEYS';
     }
-
-    /**
-     * {@inheritdoc}
-     */
-    protected function canBeHashed()
-    {
-        return false;
-    }
 }

lib/Predis/Command/KeyKeysV12x.php

@@ -9,7 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/keys

lib/Predis/Command/KeyMove.php

@@ -9,7 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/move
@@ -25,14 +25,6 @@ class KeyMove extends PrefixableCommand
         return 'MOVE';
     }
 
-    /**
-     * {@inheritdoc}
-     */
-    protected function canBeHashed()
-    {
-        return false;
-    }
-
     /**
      * {@inheritdoc}
      */

lib/Predis/Command/KeyPersist.php

@@ -9,7 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/persist

lib/Predis/Command/KeyPreciseExpire.php

@@ -9,7 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/pexpire

lib/Predis/Command/KeyPreciseExpireAt.php

@@ -9,7 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/pexpireat

lib/Predis/Command/KeyPreciseTimeToLive.php

@@ -9,7 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/pttl

lib/Predis/Command/KeyRandom.php

@@ -9,13 +9,13 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/randomkey
  * @author Daniele Alessandri <suppakilla@gmail.com>
  */
-class KeyRandom extends Command
+class KeyRandom extends AbstractCommand
 {
     /**
      * {@inheritdoc}
@@ -25,14 +25,6 @@ class KeyRandom extends Command
         return 'RANDOMKEY';
     }
 
-    /**
-     * {@inheritdoc}
-     */
-    protected function canBeHashed()
-    {
-        return false;
-    }
-
     /**
      * {@inheritdoc}
      */

lib/Predis/Command/KeyRename.php

@@ -9,13 +9,13 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/rename
  * @author Daniele Alessandri <suppakilla@gmail.com>
  */
-class KeyRename extends Command implements IPrefixable
+class KeyRename extends AbstractCommand implements PrefixableCommandInterface
 {
     /**
      * {@inheritdoc}
@@ -32,12 +32,4 @@ class KeyRename extends Command implements IPrefixable
     {
         PrefixHelpers::all($this, $prefix);
     }
-
-    /**
-     * {@inheritdoc}
-     */
-    protected function canBeHashed()
-    {
-        return false;
-    }
 }

lib/Predis/Command/KeyRenamePreserve.php

@@ -9,7 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/renamenx

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';
+    }
+}

lib/Predis/Command/KeyScan.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;
+
+/**
+ * @link http://redis.io/commands/scan
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ */
+class KeyScan extends AbstractCommand
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getId()
+    {
+        return 'SCAN';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function filterArguments(Array $arguments)
+    {
+        if (count($arguments) === 2 && is_array($arguments[1])) {
+            $options = $this->prepareOptions(array_pop($arguments));
+            $arguments = array_merge($arguments, $options);
+        }
+
+        return $arguments;
+    }
+
+    /**
+     * Returns a list of options and modifiers compatible with Redis.
+     *
+     * @param  array $options List of options.
+     * @return array
+     */
+    protected function prepareOptions($options)
+    {
+        $options = array_change_key_case($options, CASE_UPPER);
+        $normalized = array();
+
+        if (!empty($options['MATCH'])) {
+            $normalized[] = 'MATCH';
+            $normalized[] = $options['MATCH'];
+        }
+
+        if (!empty($options['COUNT'])) {
+            $normalized[] = 'COUNT';
+            $normalized[] = $options['COUNT'];
+        }
+
+        return $normalized;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function parseResponse($data)
+    {
+        if (is_array($data)) {
+            $data[0] = (int) $data[0];
+        }
+
+        return $data;
+    }
+}

lib/Predis/Command/KeySort.php

@@ -9,13 +9,13 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/sort
  * @author Daniele Alessandri <suppakilla@gmail.com>
  */
-class KeySort extends Command implements IPrefixable
+class KeySort extends AbstractCommand implements PrefixableCommandInterface
 {
     /**
      * {@inheritdoc}
@@ -44,20 +44,21 @@ class KeySort extends Command implements IPrefixable
 
         if (isset($sortParams['GET'])) {
             $getargs = $sortParams['GET'];
+
             if (is_array($getargs)) {
                 foreach ($getargs as $getarg) {
                     $query[] = 'GET';
                     $query[] = $getarg;
                 }
-            }
-            else {
+            } else {
                 $query[] = 'GET';
                 $query[] = $getargs;
             }
         }
 
-        if (isset($sortParams['LIMIT']) && is_array($sortParams['LIMIT'])
-            && count($sortParams['LIMIT']) == 2) {
+        if (isset($sortParams['LIMIT']) &&
+            is_array($sortParams['LIMIT']) &&
+            count($sortParams['LIMIT']) == 2) {
 
             $query[] = 'LIMIT';
             $query[] = $sortParams['LIMIT'][0];
@@ -85,31 +86,32 @@ class KeySort extends Command implements IPrefixable
      */
     public function prefixKeys($prefix)
     {
-        $arguments = $this->getArguments();
-        $arguments[0] = "$prefix{$arguments[0]}";
+        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;
+            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 'GET':
+                            $value = $arguments[++$i];
+                            if ($value !== '#') {
+                                $arguments[$i] = "$prefix$value";
+                            }
+                            break;
 
-                    case 'LIMIT';
-                        $i += 2;
-                        break;
+                        case 'LIMIT';
+                            $i += 2;
+                            break;
+                    }
                 }
             }
-        }
 
-        $this->setRawArguments($arguments);
+            $this->setRawArguments($arguments);
+        }
     }
 }

lib/Predis/Command/KeyTimeToLive.php

@@ -9,7 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/ttl

lib/Predis/Command/KeyType.php

@@ -9,7 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/type

lib/Predis/Command/ListIndex.php

@@ -9,7 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/lindex

lib/Predis/Command/ListInsert.php

@@ -9,7 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/linsert

lib/Predis/Command/ListLength.php

@@ -9,7 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/llen

lib/Predis/Command/ListPopFirst.php

@@ -9,7 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/lpop

lib/Predis/Command/ListPopFirstBlocking.php

@@ -9,13 +9,13 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/blpop
  * @author Daniele Alessandri <suppakilla@gmail.com>
  */
-class ListPopFirstBlocking extends Command implements IPrefixable
+class ListPopFirstBlocking extends AbstractCommand implements PrefixableCommandInterface
 {
     /**
      * {@inheritdoc}
@@ -34,6 +34,7 @@ class ListPopFirstBlocking extends Command implements IPrefixable
             list($arguments, $timeout) = $arguments;
             array_push($arguments, $timeout);
         }
+
         return $arguments;
     }
 
@@ -44,14 +45,4 @@ class ListPopFirstBlocking extends Command implements IPrefixable
     {
         PrefixHelpers::skipLast($this, $prefix);
     }
-
-    /**
-     * {@inheritdoc}
-     */
-    protected function canBeHashed()
-    {
-        return $this->checkSameHashForKeys(
-            array_slice(($args = $this->getArguments()), 0, count($args) - 1)
-        );
-    }
 }

lib/Predis/Command/ListPopLast.php

@@ -9,7 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/rpop

lib/Predis/Command/ListPopLastBlocking.php

@@ -9,7 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/brpop

lib/Predis/Command/ListPopLastPushHead.php

@@ -9,13 +9,13 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/rpoplpush
  * @author Daniele Alessandri <suppakilla@gmail.com>
  */
-class ListPopLastPushHead extends Command implements IPrefixable
+class ListPopLastPushHead extends AbstractCommand implements PrefixableCommandInterface
 {
     /**
      * {@inheritdoc}
@@ -32,12 +32,4 @@ class ListPopLastPushHead extends Command implements IPrefixable
     {
         PrefixHelpers::all($this, $prefix);
     }
-
-    /**
-     * {@inheritdoc}
-     */
-    protected function canBeHashed()
-    {
-        return $this->checkSameHashForKeys($this->getArguments());
-    }
 }

lib/Predis/Command/ListPopLastPushHeadBlocking.php

@@ -9,13 +9,13 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/brpoplpush
  * @author Daniele Alessandri <suppakilla@gmail.com>
  */
-class ListPopLastPushHeadBlocking extends Command implements IPrefixable
+class ListPopLastPushHeadBlocking extends AbstractCommand implements PrefixableCommandInterface
 {
     /**
      * {@inheritdoc}
@@ -32,14 +32,4 @@ class ListPopLastPushHeadBlocking extends Command implements IPrefixable
     {
         PrefixHelpers::skipLast($this, $prefix);
     }
-
-    /**
-     * {@inheritdoc}
-     */
-    protected function canBeHashed()
-    {
-        return $this->checkSameHashForKeys(
-            array_slice($args = $this->getArguments(), 0, count($args) - 1)
-        );
-    }
 }

lib/Predis/Command/ListPushHead.php

@@ -9,7 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/lpush

lib/Predis/Command/ListPushHeadX.php

@@ -9,7 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/lpushx

lib/Predis/Command/ListPushTail.php

@@ -9,9 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Predis\Commands;
-
-use Predis\Helpers;
+namespace Predis\Command;
 
 /**
  * @link http://redis.io/commands/rpush
@@ -32,6 +30,6 @@ class ListPushTail extends PrefixableCommand
      */
     protected function filterArguments(Array $arguments)
     {
-        return Helpers::filterVariadicValues($arguments);
+        return self::normalizeVariadic($arguments);
     }
 }