Fix all examples in readme. Req now implements Stringer interface for debugging purposes.

README.md

@@ -23,110 +23,120 @@ Install:
 Getting started
 ---------------
 
-Let's start with connecting to Redis:
+Let's start with connecting to Redis using TCP:
 
     password := ""  // no password set
-    db := -1 // use default DB
+    db := int64(-1) // use default DB
     client := redis.NewTCPClient("localhost:6379", password, db)
     defer client.Close()
 
+    ping := client.Ping()
+    fmt.Println(ping.Err(), ping.Val())
+    // Output: <nil> PONG
+
+or using Unix socket:
+
+   client := redis.NewUnixClient("/tmp/redis.sock", "", -1)
+   defer client.Close()
+
+   ping := client.Ping()
+   fmt.Println(ping.Err(), ping.Val())
+   // Output: <nil> PONG
+
 Then we can start sending commands:
 
-    set := client.Set("foo", "bar");
+    set := client.Set("foo", "bar")
-    if err := set.Err(); err != nil {
+    fmt.Println(set.Err(), set.Val())
-        panic(err)
-    }
 
     get := client.Get("foo")
-    if err := get.Err(); err != nil {
+    fmt.Println(get.Err(), get.Val())
-        panic(err)
+
-    }
+    // Output: <nil> OK
-    fmt.Println(get.Val())
+    // <nil> bar
 
 We can also pipeline two commands together:
 
     var set *redis.StatusReq
     var get *redis.StringReq
-    reqs, err := client.Pipelined(func(c *redis.PipelineClient)) {
+    reqs, err := client.Pipelined(func(c *redis.PipelineClient) {
         set = c.Set("key1", "hello1")
         get = c.Get("key2")
-    }
+    })
-    if err != nil { panic(err) }
+    fmt.Println(err)
-    if err := set.Err(); err != nil { panic(err) }
+    fmt.Println(reqs)
-    if err := get.Err(); err != nil { panic(err) }
+    fmt.Println(set)
-    fmt.Println(get.Val())
+    fmt.Println(get)
-    fmt.Println(reqs[0] == set)
+    // Output: <nil
-    fmt.Println(reqs[1] == get)
+    // Output: <nil> [SET key1 hello1: OK GET key2: (nil)]>
+    // SET key1 hello1: OK
+    // GET key2: (nil)
 
 or:
 
-    pipeline, err := client.PipelineClient()
+    var set *redis.StatusReq
-    if err != nil {
+    var get *redis.StringReq
-        panic(err)
+    reqs, err := client.Pipelined(func(c *redis.PipelineClient) {
-    }
+        set = c.Set("key1", "hello1")
-    defer pipeline.Close()
+        get = c.Get("key2")
-
+    })
-    set := pipeline.Set("key1", "hello1")
+    fmt.Println(err, reqs)
-    get := pipleine.Get("key2")
+    fmt.Println(set)
-
+    fmt.Println(get)
-    reqs, err := pipeline.RunQueued()
+    // Output: <nil> [SET key1 hello1 GET key2]
-    if err != nil { panic(err) }
+    // SET key1 hello1
-
+    // GET key2
-    if err := set.Err(); err != nil { panic(err) }
-    if err := get.Err(); err != nil { panic(err) }
-    fmt.Println(get.Val())
-    fmt.Println(reqs[0] == set)
-    fmt.Println(reqs[1] == get)
 
 We can also send several commands in transaction:
 
-    func incrKeyInTransaction(multi *redis.MultiClient) ([]redis.Req, error) {
+    func transaction(multi *redis.MultiClient) ([]redis.Req, error) {
         get := multi.Get("key")
-        if err := get.Err(); err != nil {
+        if err := get.Err(); err != nil && err != redis.Nil {
-            panic(err)
+            return nil, err
         }
 
-        val, err := strconv.ParseInt(get.Val(), 10, 64)
+        val, _ := strconv.ParseInt(get.Val(), 10, 64)
-        if err != nil { panic(err) }
 
-        reqs, err = multi.Exec(func() {
+        reqs, err := multi.Exec(func() {
-            multi.Set("key", val + 1)
+            multi.Set("key", strconv.FormatInt(val+1, 10))
         })
         // Transaction failed. Repeat.
         if err == redis.Nil {
-            return incrKeyInTransaction(multi)
+            return transaction(multi)
         }
         return reqs, err
     }
 
     multi, err := client.MultiClient()
-    if err != nil { panic(err) }
+    _ = err
     defer multi.Close()
 
     watch := multi.Watch("key")
-    if err := watch.Err(); err != nil { panic(err) }
+    _ = watch.Err()
 
-    reqs, err := incrKeyInTransaction(multi)
+    reqs, err := transaction(multi)
-    if err != nil { panic(err) }
+    fmt.Println(err, reqs)
-    for _, req := range reqs {
+
-        // ...
+    // Output: <nil> [SET key 1: OK]
-    }
 
 To subscribe to the channel:
 
     pubsub, err := client.PubSubClient()
-    if err != nil { panic(err) }
     defer pubsub.Close()
 
     ch, err := pubsub.Subscribe("mychannel")
-    if err != nil { panic(err) }
+    _ = err
 
-    go func() {
+    subscribeMsg := <-ch
-        for msg := range ch {
+    fmt.Println(subscribeMsg.Err, subscribeMsg.Name)
-            if err := msg.Err; err != nil { panic(err) }
+
-            message := msg.Message
+    pub := client.Publish("mychannel", "hello")
-        }
+    _ = pub.Err()
-    }
+
+    msg := <-ch
+    fmt.Println(msg.Err, msg.Message)
+
+    // Output: <nil> subscribe
+    // <nil> hello
 
 You can also write custom commands:
 
@@ -136,8 +146,9 @@ You can also write custom commands:
         return req
     }
 
-    get := Get(redisClient, "key")
+    get := Get(client, "key_does_not_exist")
-    if err := get.Err(); err != nil && err != redis.Nil { panic(err) }
+    fmt.Println(get.Err(), get.Val())
+    // Output: (nil)
 
 Client uses connection pool to send commands. You can change maximum number of connections with:
 

example_test.go

@@ -0,0 +1,135 @@
+package redis_test
+
+import (
+	"fmt"
+	"strconv"
+
+	"github.com/vmihailenco/redis"
+)
+
+func ExampleTCPClient() {
+	password := ""  // no password set
+	db := int64(-1) // use default DB
+	client := redis.NewTCPClient("localhost:6379", password, db)
+	defer client.Close()
+
+	ping := client.Ping()
+	fmt.Println(ping.Err(), ping.Val())
+	// Output: <nil> PONG
+}
+
+func ExampleUnixClient() {
+	client := redis.NewUnixClient("/tmp/redis.sock", "", -1)
+	defer client.Close()
+
+	ping := client.Ping()
+	fmt.Println(ping.Err(), ping.Val())
+	// Output: <nil> PONG
+}
+
+func ExampleSetGet() {
+	client := redis.NewTCPClient(":6379", "", -1)
+	defer client.Close()
+
+	set := client.Set("foo", "bar")
+	fmt.Println(set.Err(), set.Val())
+
+	get := client.Get("foo")
+	fmt.Println(get.Err(), get.Val())
+
+	// Output: <nil> OK
+	// <nil> bar
+}
+
+func ExamplePipeline() {
+	client := redis.NewTCPClient(":6379", "", -1)
+	defer client.Close()
+
+	var set *redis.StatusReq
+	var get *redis.StringReq
+	reqs, err := client.Pipelined(func(c *redis.PipelineClient) {
+		set = c.Set("key1", "hello1")
+		get = c.Get("key2")
+	})
+	fmt.Println(err, reqs)
+	fmt.Println(set)
+	fmt.Println(get)
+	// Output: <nil> [SET key1 hello1: OK GET key2: (nil)]
+	// SET key1 hello1: OK
+	// GET key2: (nil)
+}
+
+func transaction(multi *redis.MultiClient) ([]redis.Req, error) {
+	get := multi.Get("key")
+	if err := get.Err(); err != nil && err != redis.Nil {
+		return nil, err
+	}
+
+	val, _ := strconv.ParseInt(get.Val(), 10, 64)
+
+	reqs, err := multi.Exec(func() {
+		multi.Set("key", strconv.FormatInt(val+1, 10))
+	})
+	// Transaction failed. Repeat.
+	if err == redis.Nil {
+		return transaction(multi)
+	}
+	return reqs, err
+}
+
+func ExampleTransaction() {
+	client := redis.NewTCPClient(":6379", "", -1)
+	defer client.Close()
+
+	client.Del("key")
+
+	multi, err := client.MultiClient()
+	_ = err
+	defer multi.Close()
+
+	watch := multi.Watch("key")
+	_ = watch.Err()
+
+	reqs, err := transaction(multi)
+	fmt.Println(err, reqs)
+
+	// Output: <nil> [SET key 1: OK]
+}
+
+func ExamplePubSub() {
+	client := redis.NewTCPClient(":6379", "", -1)
+	defer client.Close()
+
+	pubsub, err := client.PubSubClient()
+	defer pubsub.Close()
+
+	ch, err := pubsub.Subscribe("mychannel")
+	_ = err
+
+	subscribeMsg := <-ch
+	fmt.Println(subscribeMsg.Err, subscribeMsg.Name)
+
+	pub := client.Publish("mychannel", "hello")
+	_ = pub.Err()
+
+	msg := <-ch
+	fmt.Println(msg.Err, msg.Message)
+
+	// Output: <nil> subscribe
+	// <nil> hello
+}
+
+func Get(client *redis.Client, key string) *redis.StringReq {
+	req := redis.NewStringReq("GET", key)
+	client.Process(req)
+	return req
+}
+
+func ExampleCustomCommand() {
+	client := redis.NewTCPClient(":6379", "", -1)
+	defer client.Close()
+
+	get := Get(client, "key_does_not_exist")
+	fmt.Println(get.Err(), get.Val())
+	// Output: (nil)
+}

redis_test.go

@@ -270,6 +270,19 @@ func (t *RedisTest) resetRedis(c *C) {
 
 //------------------------------------------------------------------------------
 
+func (t *RedisTest) TestReqStringMethod(c *C) {
+	set := t.client.Set("foo", "bar")
+	c.Assert(set.String(), Equals, "SET foo bar: OK")
+
+	get := t.client.Get("foo")
+	c.Assert(get.String(), Equals, "GET foo: bar")
+}
+
+func (t *RedisTest) TestReqStringMethodError(c *C) {
+	get2 := t.client.Get("key_does_not_exists")
+	c.Assert(get2.String(), Equals, "GET key_does_not_exists: (nil)")
+}
+
 func (t *RedisTest) TestRunWithouthCheckingErrVal(c *C) {
 	set := t.client.Set("key", "hello")
 	c.Assert(set.Err(), IsNil)

req.go

@@ -1,7 +1,9 @@
 package redis
 
 import (
+	"fmt"
 	"strconv"
+	"strings"
 )
 
 type Req interface {
@@ -64,6 +66,16 @@ func (r *BaseReq) ParseReply(rd reader) (interface{}, error) {
 	return parseReply(rd)
 }
 
+func (r *BaseReq) String() string {
+	args := strings.Join(r.args, " ")
+	if r.err != nil {
+		return args + ": " + r.err.Error()
+	} else if r.val != nil {
+		return args + ": " + fmt.Sprint(r.val)
+	}
+	return args
+}
+
 //------------------------------------------------------------------------------
 
 type IfaceReq struct {