Update example and doc.

v2/doc.go

@@ -3,9 +3,11 @@ Package github.com/vmihailenco/redis implements a Redis client.
 
 Let's start with connecting to Redis using TCP:
 
-    password := ""  // no password set
+	client := redis.NewTCPClient(&redis.Options{
-    db := int64(-1) // use default DB
+		Addr:     "localhost:6379",
-    client := redis.NewTCPClient("localhost:6379", password, db)
+		Password: "", // no password set
+		DB:       0,  // use default DB
+	})
 	defer client.Close()
 
 	ping := client.Ping()
@@ -14,7 +16,9 @@ Let's start with connecting to Redis using TCP:
 
 or using Unix socket:
 
-    client := redis.NewUnixClient("/tmp/redis.sock", "", -1)
+	client := redis.NewUnixClient(&redis.Options{
+		Addr: "/tmp/redis.sock",
+	})
 	defer client.Close()
 
 	ping := client.Ping()
@@ -23,6 +27,11 @@ or using Unix socket:
 
 Then we can start sending commands:
 
+	client := redis.NewTCPClient(&redis.Options{
+		Addr: ":6379",
+	})
+	defer client.Close()
+
 	set := client.Set("foo", "bar")
 	fmt.Println(set.Err(), set.Val())
 
@@ -34,100 +43,120 @@ Then we can start sending commands:
 
 We can also pipeline two commands together:
 
-    var set *redis.StatusReq
+	client := redis.NewTCPClient(&redis.Options{
-    var get *redis.StringReq
+		Addr: ":6379",
-    reqs, err := client.Pipelined(func(c *redis.PipelineClient) {
-        set = c.Set("key1", "hello1")
-        get = c.Get("key2")
 	})
-    fmt.Println(err, reqs)
+	defer client.Close()
-    fmt.Println(set)
+
-    fmt.Println(get)
+	cmds, err := client.Pipelined(func(c *redis.Pipeline) {
-    // Output: <nil> [SET key1 hello1: OK GET key2: (nil)]
+		c.Set("key1", "hello1")
-    // SET key1 hello1: OK
+		c.Get("key2")
-    // GET key2: (nil)
+	})
+	fmt.Println(cmds, err)
+	// Output: [SET key1 hello1: OK GET key2: (nil)] (nil)
 
 or:
 
-    var set *redis.StatusReq
+	client := redis.NewTCPClient(&redis.Options{
-    var get *redis.StringReq
+		Addr: ":6379",
-    reqs, err := client.Pipelined(func(c *redis.PipelineClient) {
-        set = c.Set("key1", "hello1")
-        get = c.Get("key2")
 	})
-    fmt.Println(err, reqs)
+	defer client.Close()
+
+	pipeline := client.Pipeline()
+	set := pipeline.Set("key1", "hello1")
+	get := pipeline.Get("key2")
+	cmds, err := pipeline.Exec()
+	fmt.Println(cmds, err)
 	fmt.Println(set)
 	fmt.Println(get)
-    // Output: <nil> [SET key1 hello1 GET key2]
+	// Output: [SET key1 hello1: OK GET key2: (nil)] (nil)
-    // SET key1 hello1
+	// SET key1 hello1: OK
-    // GET key2
+	// GET key2: (nil)
 
 We can also send several commands in transaction:
 
-    func transaction(multi *redis.MultiClient) ([]redis.Req, error) {
+	incr := func(tx *redis.Multi) ([]redis.Cmder, error) {
-        get := multi.Get("key")
+		get := tx.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() {
+		return tx.Exec(func() {
-            multi.Set("key", strconv.FormatInt(val+1, 10))
+			tx.Set("key", strconv.FormatInt(val+1, 10))
 		})
-        // Transaction failed. Repeat.
-        if err == redis.Nil {
-            return transaction(multi)
-        }
-        return reqs, err
 	}
 
-    multi, err := client.MultiClient()
+	client := redis.NewTCPClient(&redis.Options{
-    _ = err
+		Addr: ":6379",
-    defer multi.Close()
+	})
+	defer client.Close()
 
-    watch := multi.Watch("key")
+	client.Del("key")
+
+	tx := client.Multi()
+	defer tx.Close()
+
+	watch := tx.Watch("key")
 	_ = watch.Err()
 
-    reqs, err := transaction(multi)
+	for {
-    fmt.Println(err, reqs)
+		cmds, err := incr(tx)
+		if err == redis.Nil {
+			// Transaction failed. Repeat.
+			continue
+		} else if err != nil {
+			panic(err)
+		}
+		fmt.Println(err, cmds)
+		break
+	}
 
 	// Output: <nil> [SET key 1: OK]
 
 To subscribe to the channel:
 
-    pubsub, err := client.PubSubClient()
+	client := redis.NewTCPClient(&redis.Options{
+		Addr: ":6379",
+	})
+	defer client.Close()
+
+	pubsub := client.PubSub()
 	defer pubsub.Close()
 
-    ch, err := pubsub.Subscribe("mychannel")
+	err := pubsub.Subscribe("mychannel")
 	_ = err
 
-    subscribeMsg := <-ch
+	msg, err := pubsub.Receive()
-    fmt.Println(subscribeMsg.Err, subscribeMsg.Name)
+	fmt.Println(msg, err)
 
 	pub := client.Publish("mychannel", "hello")
 	_ = pub.Err()
 
-    msg := <-ch
+	msg, err = pubsub.Receive()
-    fmt.Println(msg.Err, msg.Message)
+	fmt.Println(msg, err)
 
-    // Output: <nil> subscribe
+	// Output: &{subscribe mychannel 1} <nil>
-    // <nil> hello
+	// &{mychannel hello} <nil>
 
 You can also write custom commands:
 
-    func Get(client *redis.Client, key string) *redis.StringReq {
+	func Get(client *redis.Client, key string) *redis.StringCmd {
-        req := redis.NewStringReq("GET", key)
+		cmd := redis.NewStringCmd("GET", key)
-        client.Process(req)
+		client.Process(cmd)
-        return req
+		return cmd
 	}
 
+	func ExampleCustomCommand() {
+		client := redis.NewTCPClient(&redis.Options{
+			Addr: ":6379",
+		})
+		defer client.Close()
+
 		get := Get(client, "key_does_not_exist")
 		fmt.Println(get.Err(), get.Val())
 		// Output: (nil)
-
+	}
-Client uses connection pool to send commands. You can change maximum number of connections with:
-
-    client.ConnPool.(*redis.MultiConnPool).MaxCap = 1
 */
 package redis

v2/example_test.go

@@ -47,27 +47,40 @@ func ExampleSet() {
 	// <nil> bar
 }
 
+func ExamplePipelined() {
+	client := redis.NewTCPClient(&redis.Options{
+		Addr: ":6379",
+	})
+	defer client.Close()
+
+	cmds, err := client.Pipelined(func(c *redis.Pipeline) {
+		c.Set("key1", "hello1")
+		c.Get("key2")
+	})
+	fmt.Println(cmds, err)
+	// Output: [SET key1 hello1: OK GET key2: (nil)] (nil)
+}
+
 func ExamplePipeline() {
 	client := redis.NewTCPClient(&redis.Options{
 		Addr: ":6379",
 	})
 	defer client.Close()
 
-	var set *redis.StatusCmd
+	pipeline := client.Pipeline()
-	var get *redis.StringCmd
+	set := pipeline.Set("key1", "hello1")
-	cmds, err := client.Pipelined(func(c *redis.Pipeline) {
+	get := pipeline.Get("key2")
-		set = c.Set("key1", "hello1")
+	cmds, err := pipeline.Exec()
-		get = c.Get("key2")
+	fmt.Println(cmds, err)
-	})
-	fmt.Println(err, cmds)
 	fmt.Println(set)
 	fmt.Println(get)
-	// Output: (nil) [SET key1 hello1: OK GET key2: (nil)]
+	// Output: [SET key1 hello1: OK GET key2: (nil)] (nil)
 	// SET key1 hello1: OK
 	// GET key2: (nil)
 }
 
-func incr(tx *redis.Multi) ([]redis.Cmder, error) {
+func ExampleMulti() {
+	incr := func(tx *redis.Multi) ([]redis.Cmder, error) {
 		get := tx.Get("key")
 		if err := get.Err(); err != nil && err != redis.Nil {
 			return nil, err
@@ -75,17 +88,11 @@ func incr(tx *redis.Multi) ([]redis.Cmder, error) {
 
 		val, _ := strconv.ParseInt(get.Val(), 10, 64)
 
-	cmds, err := tx.Exec(func() {
+		return tx.Exec(func() {
 			tx.Set("key", strconv.FormatInt(val+1, 10))
 		})
-	// Transaction failed. Repeat.
-	if err == redis.Nil {
-		return incr(tx)
 	}
-	return cmds, err
-}
 
-func ExampleMulti() {
 	client := redis.NewTCPClient(&redis.Options{
 		Addr: ":6379",
 	})
@@ -99,8 +106,17 @@ func ExampleMulti() {
 	watch := tx.Watch("key")
 	_ = watch.Err()
 
+	for {
 		cmds, err := incr(tx)
+		if err == redis.Nil {
+			// Transaction failed. Repeat.
+			continue
+		} else if err != nil {
+			panic(err)
+		}
 		fmt.Println(err, cmds)
+		break
+	}
 
 	// Output: <nil> [SET key 1: OK]
 }