NAME
    Mojo::Redis - Asynchronous Redis client for Mojolicious.

SYNOPSIS
      use Mojo::Redis;

      my $redis = Mojo::Redis->new(server => '127.0.0.1:6379');

      # Execute some commands
      $redis->ping(
        sub {
          my ($redis, $res) = @_;
          if (defined $res) {
            print "Got result: ", $res, "\n";
          }
        }
      );

      # Work with keys
      # Ommitting the callback still makes it non-blocking and "error" events
      # will be called if something terrible goes wrong.
      $redis->set(key => 'value');

      $redis->get(
        key => sub {
          my ($redis, $res) = @_;
          print "Value of 'key' is $res\n";
        }
      );

      # Cleanup connection
      $redis->quit(sub { shift->ioloop->stop });

      # Start IOLoop (in case it is not started yet)
      $redis->ioloop->start;

    Create new Mojo::IOLoop instance if you need to get blocked in a
    Mojolicious application.

      use Mojolicious::Lite;
      use Mojo::Redis;

      get '/user' => sub {
        my $self = shift->render_later;
        my $uid = $self->session('uid');
        my $redis = Mojo::Redis->new;

        Mojo::IOLoop->delay(
          sub {
            my ($delay) = @_;
            $redis->hgetall("user:$uid", $delay->begin);
          },
          sub {
            my ($delay, $user) = @_;
            $self->render(json=>$user);
          },
        );
      };

      websocket '/messages' => sub {
        my $self = shift;
        my $tx = $self->tx;
        my $pub = Mojo::Redis->new;
        my $sub = $pub->subscribe('messages');

        # message from redis
        $sub->on(message => sub {
          my ($sub, $message, $channel) = @_; # $channel == messages
          $tx->send($message);
        });

        # message from websocket
        $self->on(message => sub {
          my ($self, $message) = @_;
          $pub->publish(messages => $message);
        });

        # need to clean up after websocket close
        $self->on(finish => sub {
          undef $pub;
          undef $sub;
          undef $tx;
        });
      };

      app->start;

DESCRIPTION
    Mojo::Redis is an asynchronous client to Redis <http://redis.io> for
    Mojo.

EVENTS
  error
        $redis->on(error => sub{
            my($redis, $error) = @_;
            warn "[REDIS ERROR] $error\n";
        });

    Emitted if error occurred. Called before commands callbacks.

  close
        $redis->on(close => sub{
            my($redis) = @_;
            warn "[REDIS DISCONNECT]\n";
        });

    Emitted when the connection to the server gets closed.

ATTRIBUTES
    Mojo::Redis implements the following attributes.

  server
        my $server = $redis->server;
        $redis     = $redis->server('127.0.0.1:6379');
        $redis     = $redis->server('redis://anything:PASSWORD@127.0.0.1:6379/DB_INDEX');

    "Redis" server connection string, defaults to '127.0.0.1:6379'. The
    latter can be used if you want Mojo::Redis to automatically run "auth"
    with "PASSWORD" and/or "select" with "DB_INDEX" on connect. Both AUTH
    and DB_INDEX are optional.

  ioloop
        my $ioloop = $redis->ioloop;
        $redis     = $redis->ioloop(Mojo::IOLoop->new);

    Loop object to use for io operations, by default a Mojo::IOLoop
    singleton object will be used.

  timeout
        my $timeout = $redis->timeout;
        $redis      = $redis->timeout(100);

    Maximum amount of time in seconds a connection can be inactive before
    being dropped, defaults to 0 - meaning no timeout.

  encoding
        my $encoding = $redis->encoding;
        $redis       = $redis->encoding('UTF-8');

    Encoding used for stored data, defaults to "UTF-8".

  protocol_redis
        use Protocol::Redis::XS;
        $redis->protocol_redis("Protocol::Redis::XS");

    Protocol::Redis implementation' constructor for parsing. By default
    Protocol::Redis will be used. Parser library must support APIv1.

    Using Protocol::Redis::XS instead of default choice can speedup parsing.

METHODS
    Mojo::Redis supports Redis' methods.

        $redis->set(key => 'value);
        $redis->get(key => sub { ... });

    For more details take a look at "execute" method.

    Also Mojo::Redis implements the following ones.

  connect
        $redis = $redis->connect;

    Connect to "Redis" server.

  execute
        $redis = $redis->execute("ping" => sub {
            my ($redis, $result) = @_;

            # Process result
        });
        $redis->execute(lrange => "test", 0, -1 => sub {...});
        $redis->execute(set => test => "test_ok");
        $redis->execute(
            [lrange => "test", 0, -1],
            [get => "test"],
            [hmset => foo => { one => 1, two => 2 }],
            sub {
                my($redis, $lrange, $get, $hmset) = @_;
                # ...
            },
        );

    Execute specified command on "Redis" server. If error occurred during
    request $result will be set to undef, error string can be obtained with
    the "error" event.

REDIS METHODS
  append
  auth
    See "server" instead.

  bgrewriteaof
  bgsave
  blpop
  brpop
  brpoplpush
  config_get
  config_resetstat
  config_set
  connected
  dbsize
  debug_object
  debug_segfault
  decr
  decrby
  del
  discard
  disconnect
  echo
  exec
  exists
  expire
  expireat
  flushall
  flushdb
  get
  getbit
  getrange
  getset
  hdel
  hexists
  hget
  hgetall
  hincrby
  hkeys
  hlen
  hmget
  hmset
  hset
  hsetnx
  hvals
  incr
  incrby
  info
  keys
  lastsave
  lindex
  linsert
  llen
  lpop
  lpush
  lpushx
  lrange
  lrem
  lset
  ltrim
  mget
  monitor
  move
  mset
  msetnx
  multi
  persist
  ping
  protocol
  psubscribe
    Subscribes to channels matching the given patterns.

       # Subscribes to foo, foobar, foo.whaz, etc.
       my $psub = $redis->psubscribe('foo*');
       $psub->on(message => sub {
                my ($self, $msg, $channel, $pattern) = @_; # 'hi!', 'foo.roo', 'foo*'
              });

       $redis->publish('foo.roo' => 'hi!');

    psubscribe has the same interface options and capabilities as
    "subscribe".

  publish
  quit
  randomkey
  rename
  renamenx
  rpop
  rpoplpush
  rpush
  rpushx
  sadd
  save
  scard
  sdiff
  sdiffstore
  select
    See "server" instead.

  set
  setbit
  setex
  setnx
  setrange
  shutdown
  sinter
  sinterstore
  sismember
  slaveof
  smembers
  smove
  sort
  spop
  srandmember
  srem
  strlen
  subscribe
    It's possible to subscribe in two ways:

       $self = $redis->subscribe('foo','bar' => sub {
         my ($redis, $data) = @_;
       });

    The above code will overtake the current connection (if any) and put
    this object into a pure subscribe mode.

       my $sub = $redis->subscribe('foo','bar');
       $sub->on(data => sub {
                my ($sub, $data) = @_;
              });

    Opens up a new connection that subscribes to the given pubsub channels.
    Returns an instance of Mojo::Redis::Subscription. The existing $redis
    object can still be used to "get" data as expected.

  sunion
  sunionstore
  sync
  ttl
  type
  unwatch
  watch
  zadd
  zcard
  zcount
  zincrby
  zinterstore
  zrange
  zrangebyscore
  zrank
  zrem
  zremrangebyrank
  zremrangebyscore
  zrevrange
  zrevrangebyscore
  zrevrank
  zscore
  zunionstore
SEE ALSO
    Protocol::Redis, Mojolicious, Mojo::IOLoop

SUPPORT
    You can contact the developers "marcus" and "batman" on IRC:
    <irc://irc.perl.org:6667/#mojo> (#mojo on irc.perl.org)

AUTHOR
    Sergey Zasenko, "undef@cpan.org".

    Forked from MojoX::Redis and updated to new IOLoop API by Marcus Ramberg
    "mramberg@cpan.org" and Jan Henning Thorsen "jhthorsen@cpan.org".

COPYRIGHT AND LICENSE
    Copyright (C) 2010-2011, Sergey Zasenko (C) 2012, Marcus Ramberg

    This program is free software, you can redistribute it and/or modify it
    under the terms of the Artistic License version 2.0.

