Make generic interface (#1)

* Make generic interface

* add grayburd redis client example

* update examples and docs

* update docs

Author: dineshgowda24

.gitignore

@@ -0,0 +1,2 @@
+examples/garyburd/vendor
+examples/goredis/vendor

README.md

@@ -2,78 +2,30 @@
 
 [![Build Status](https://travis-ci.com/dineshgowda24/redislock.svg)](https://travis-ci.com/dineshgowda24/redislock)
 [![GoDoc](https://godoc.org/github.com/dineshgowda24/redislock?status.png)](http://godoc.org/github.com/bsm/redislock)
-[![Go Report Card](https://goreportcard.com/badge/github.com/bsm/redislock)](https://goreportcard.com/report/github.com/bsm/redislock)
+[![Go Report Card](https://goreportcard.com/badge/github.com/dineshgowda24/redislock)](https://goreportcard.com/report/github.com/bsm/redislock)
 [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 
 Simplified distributed locking implementation using [Redis](http://redis.io/topics/distlock).
 For more information, please see examples.
 
-## Examples
-
-```go
-import (
-  "fmt"
-  "time"
-
-  "github.com/bsm/redislock"
-  "github.com/go-redis/redis/v7"
-)
-
-func main() {
-	// Connect to redis.
-	client := &redis.Pool{
-		MaxIdle:     3,
-		IdleTimeout: 240 * time.Second,
-		Dial: func() (redis.Conn, error) {
-			return redis.Dial("tcp", ":6379",
-				redis.DialDatabase(1))
-		},
-	}
-
-	// Create a new lock client.
-	locker := redislock.New(client)
+## Motivation
 
-	// Try to obtain lock.
-	lock, err := locker.Obtain("my-key", 100*time.Millisecond, nil)
-	if err == redislock.ErrNotObtained {
-		fmt.Println("Could not obtain lock!")
-	} else if err != nil {
-		log.Fatalln(err)
-	}
+I came across a concurrency issue when multiple clients were accessing single redis instance. So I wanted a primitive locking solution, but redis did not have one implemented. So started looking for open source libraries and found [redislock](https://github.com/bsm/redislock) very well written and effective library. But it still did not solve my problem as I was using [redigo](https://github.com/garyburd/redigo) client but the package used [go-redis](https://github.com/go-redis/redis). Although `redigo` had [`redsync`](https://github.com/go-redsync/redsync), I wanted a much more simpler one and so with `redislock`.
 
-	// Don't forget to defer Release.
-	defer lock.Release()
-	fmt.Println("I have a lock!")
+## Features
 
-	// Sleep and check the remaining TTL.
-	time.Sleep(50 * time.Millisecond)
-	if ttl, err := lock.TTL(); err != nil {
-		log.Fatalln(err)
-	} else if ttl > 0 {
-		fmt.Println("Yay, I still have my lock!")
-	}
+ - Simple and easy to use interface.
+ - Plug in any redis client of your choice by implementing the `RedisClient` interface.
+ - Simple but effective locking for single redis instance.
 
-	// Extend my lock.
-	if err := lock.Refresh(100*time.Millisecond, nil); err != nil {
-		log.Fatalln(err)
-	}
-
-	// Sleep a little longer, then check.
-	time.Sleep(100 * time.Millisecond)
-	if ttl, err := lock.TTL(); err != nil {
-		log.Fatalln(err)
-	} else if ttl == 0 {
-		fmt.Println("Now, my lock has expired!")
-	}
-
-	// Output:
-	// I have a lock!
-	// Yay, I still have my lock!
-	// Now, my lock has expired!
+## Examples
 
-}
-```
+Check out examples in for [`garyburd`](./examples/garyburd) and [`go-redis`](./examples/goredis) clients.
 
 ## Documentation
 
 Full documentation is available on [GoDoc](http://godoc.org/github.com/dineshgowda24/redislock)
+
+## Contribution
+
+Feel free to send a PR.

README.md.tpl

@@ -0,0 +1,46 @@
+# Gopkg.toml example
+#
+# Refer to https://golang.github.io/dep/docs/Gopkg.toml.html
+# for detailed Gopkg.toml documentation.
+#
+# required = ["github.com/user/thing/cmd/thing"]
+# ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"]
+#
+# [[constraint]]
+#   name = "github.com/user/project"
+#   version = "1.0.0"
+#
+# [[constraint]]
+#   name = "github.com/user/project2"
+#   branch = "dev"
+#   source = "github.com/myfork/project2"
+#
+# [[override]]
+#   name = "github.com/x/y"
+#   version = "2.4.0"
+#
+# [prune]
+#   non-go = false
+#   go-tests = true
+#   unused-packages = true
+
+
+[[constraint]]
+  branch = "interface"
+  name = "github.com/dineshgowda24/redislock"
+
+[[constraint]]
+  name = "github.com/garyburd/redigo"
+  version = "1.6.0"
+
+[[constraint]]
+  name = "github.com/onsi/ginkgo"
+  version = "1.14.0"
+
+[[constraint]]
+  name = "github.com/onsi/gomega"
+  version = "1.10.1"
+
+[prune]
+  go-tests = true
+  unused-packages = true

examples/garyburd/Gopkg.lock

@@ -0,0 +1,24 @@
+# Garyburd redigo
+
+```
+type RedisLockClient struct {
+	pool       *redis.Pool
+	luaRefresh *redis.Script
+	luaPttl    *redis.Script
+	luaRelease *redis.Script
+}
+```
+
+`RedisLockClient` implements `RedisClient` interface from `redislock.go`
+
+## Installing the dependencies
+
+```
+dep ensure -v
+```
+
+## Running the application
+
+```
+go run main.go
+```