Add deprecation comments, gofmt all

redis/conn.go

@@ -60,7 +60,7 @@ type conn struct {
 // DialTimeout acts like Dial but takes timeouts for establishing the
 // connection to the server, writing a command and reading a reply.
 //
-// Deprecated: Use Dial with options instead.
+// Deprecated: This package is replaced by github.com/gomodule/redigo/redis.
 func DialTimeout(network, address string, connectTimeout, readTimeout, writeTimeout time.Duration) (Conn, error) {
 	return Dial(network, address,
 		DialConnectTimeout(connectTimeout),
@@ -167,6 +167,8 @@ func DialUseTLS(useTLS bool) DialOption {
 
 // Dial connects to the Redis server at the given network and
 // address using the specified options.
+//
+// Deprecated: This package is replaced by github.com/gomodule/redigo/redis.
 func Dial(network, address string, options ...DialOption) (Conn, error) {
 	do := dialOptions{
 		dialer: &net.Dialer{
@@ -239,6 +241,8 @@ var pathDBRegexp = regexp.MustCompile(`/(\d*)\z`)
 // DialURL connects to a Redis server at the given URL using the Redis
 // URI scheme. URLs should follow the draft IANA specification for the
 // scheme (https://www.iana.org/assignments/uri-schemes/prov/redis).
+//
+// Deprecated: This package is replaced by github.com/gomodule/redigo/redis.
 func DialURL(rawurl string, options ...DialOption) (Conn, error) {
 	u, err := url.Parse(rawurl)
 	if err != nil {
@@ -291,6 +295,8 @@ func DialURL(rawurl string, options ...DialOption) (Conn, error) {
 }
 
 // NewConn returns a new Redigo connection for the given net connection.
+//
+// Deprecated: This package is replaced by github.com/gomodule/redigo/redis.
 func NewConn(netConn net.Conn, readTimeout, writeTimeout time.Duration) Conn {
 	return &conn{
 		conn:         netConn,

redis/conn_test.go

@@ -38,10 +38,14 @@ type testConn struct {
 	writeDeadline time.Time
 }
 
-func (*testConn) Close() error                         { return nil }
-func (*testConn) LocalAddr() net.Addr                  { return nil }
-func (*testConn) RemoteAddr() net.Addr                 { return nil }
-func (c *testConn) SetDeadline(t time.Time) error      { c.readDeadline = t; c.writeDeadline = t; return nil }
+func (*testConn) Close() error         { return nil }
+func (*testConn) LocalAddr() net.Addr  { return nil }
+func (*testConn) RemoteAddr() net.Addr { return nil }
+func (c *testConn) SetDeadline(t time.Time) error {
+	c.readDeadline = t
+	c.writeDeadline = t
+	return nil
+}
 func (c *testConn) SetReadDeadline(t time.Time) error  { c.readDeadline = t; return nil }
 func (c *testConn) SetWriteDeadline(t time.Time) error { c.writeDeadline = t; return nil }
 

redis/doc.go

@@ -17,7 +17,7 @@
 // The Redigo FAQ (https://github.com/garyburd/redigo/wiki/FAQ) contains more
 // documentation about this package.
 //
-// Connections
+// # Connections
 //
 // The Conn interface is the primary interface for working with Redis.
 // Applications create connections by calling the Dial, DialWithTimeout or
@@ -27,58 +27,58 @@
 // The application must call the connection Close method when the application
 // is done with the connection.
 //
-// Executing Commands
+// # Executing Commands
 //
 // The Conn interface has a generic method for executing Redis commands:
 //
-//  Do(commandName string, args ...interface{}) (reply interface{}, err error)
+//	Do(commandName string, args ...interface{}) (reply interface{}, err error)
 //
 // The Redis command reference (http://redis.io/commands) lists the available
 // commands. An example of using the Redis APPEND command is:
 //
-//  n, err := conn.Do("APPEND", "key", "value")
+//	n, err := conn.Do("APPEND", "key", "value")
 //
 // The Do method converts command arguments to bulk strings for transmission
 // to the server as follows:
 //
-//  Go Type                 Conversion
-//  []byte                  Sent as is
-//  string                  Sent as is
-//  int, int64              strconv.FormatInt(v)
-//  float64                 strconv.FormatFloat(v, 'g', -1, 64)
-//  bool                    true -> "1", false -> "0"
-//  nil                     ""
-//  all other types         fmt.Fprint(w, v)
+//	Go Type                 Conversion
+//	[]byte                  Sent as is
+//	string                  Sent as is
+//	int, int64              strconv.FormatInt(v)
+//	float64                 strconv.FormatFloat(v, 'g', -1, 64)
+//	bool                    true -> "1", false -> "0"
+//	nil                     ""
+//	all other types         fmt.Fprint(w, v)
 //
 // Redis command reply types are represented using the following Go types:
 //
-//  Redis type              Go type
-//  error                   redis.Error
-//  integer                 int64
-//  simple string           string
-//  bulk string             []byte or nil if value not present.
-//  array                   []interface{} or nil if value not present.
+//	Redis type              Go type
+//	error                   redis.Error
+//	integer                 int64
+//	simple string           string
+//	bulk string             []byte or nil if value not present.
+//	array                   []interface{} or nil if value not present.
 //
 // Use type assertions or the reply helper functions to convert from
 // interface{} to the specific Go type for the command result.
 //
-// Pipelining
+// # Pipelining
 //
 // Connections support pipelining using the Send, Flush and Receive methods.
 //
-//  Send(commandName string, args ...interface{}) error
-//  Flush() error
-//  Receive() (reply interface{}, err error)
+//	Send(commandName string, args ...interface{}) error
+//	Flush() error
+//	Receive() (reply interface{}, err error)
 //
 // Send writes the command to the connection's output buffer. Flush flushes the
 // connection's output buffer to the server. Receive reads a single reply from
 // the server. The following example shows a simple pipeline.
 //
-//  c.Send("SET", "foo", "bar")
-//  c.Send("GET", "foo")
-//  c.Flush()
-//  c.Receive() // reply from SET
-//  v, err = c.Receive() // reply from GET
+//	c.Send("SET", "foo", "bar")
+//	c.Send("GET", "foo")
+//	c.Flush()
+//	c.Receive() // reply from SET
+//	v, err = c.Receive() // reply from GET
 //
 // The Do method combines the functionality of the Send, Flush and Receive
 // methods. The Do method starts by writing the command and flushing the output
@@ -91,13 +91,13 @@
 //
 // Use the Send and Do methods to implement pipelined transactions.
 //
-//  c.Send("MULTI")
-//  c.Send("INCR", "foo")
-//  c.Send("INCR", "bar")
-//  r, err := c.Do("EXEC")
-//  fmt.Println(r) // prints [1, 1]
+//	c.Send("MULTI")
+//	c.Send("INCR", "foo")
+//	c.Send("INCR", "bar")
+//	r, err := c.Do("EXEC")
+//	fmt.Println(r) // prints [1, 1]
 //
-// Concurrency
+// # Concurrency
 //
 // Connections support one concurrent caller to the Receive method and one
 // concurrent caller to the Send and Flush methods. No other concurrency is
@@ -108,39 +108,39 @@
 // a Pool have the concurrency restrictions described in the previous
 // paragraph.
 //
-// Publish and Subscribe
+// # Publish and Subscribe
 //
 // Use the Send, Flush and Receive methods to implement Pub/Sub subscribers.
 //
-//  c.Send("SUBSCRIBE", "example")
-//  c.Flush()
-//  for {
-//      reply, err := c.Receive()
-//      if err != nil {
-//          return err
-//      }
-//      // process pushed message
-//  }
+//	c.Send("SUBSCRIBE", "example")
+//	c.Flush()
+//	for {
+//	    reply, err := c.Receive()
+//	    if err != nil {
+//	        return err
+//	    }
+//	    // process pushed message
+//	}
 //
 // The PubSubConn type wraps a Conn with convenience methods for implementing
 // subscribers. The Subscribe, PSubscribe, Unsubscribe and PUnsubscribe methods
 // send and flush a subscription management command. The receive method
 // converts a pushed message to convenient types for use in a type switch.
 //
-//  psc := redis.PubSubConn{Conn: c}
-//  psc.Subscribe("example")
-//  for {
-//      switch v := psc.Receive().(type) {
-//      case redis.Message:
-//          fmt.Printf("%s: message: %s\n", v.Channel, v.Data)
-//      case redis.Subscription:
-//          fmt.Printf("%s: %s %d\n", v.Channel, v.Kind, v.Count)
-//      case error:
-//          return v
-//      }
-//  }
-//
-// Reply Helpers
+//	psc := redis.PubSubConn{Conn: c}
+//	psc.Subscribe("example")
+//	for {
+//	    switch v := psc.Receive().(type) {
+//	    case redis.Message:
+//	        fmt.Printf("%s: message: %s\n", v.Channel, v.Data)
+//	    case redis.Subscription:
+//	        fmt.Printf("%s: %s %d\n", v.Channel, v.Kind, v.Count)
+//	    case error:
+//	        return v
+//	    }
+//	}
+//
+// # Reply Helpers
 //
 // The Bool, Int, Bytes, String, Strings and Values functions convert a reply
 // to a value of a specific type. To allow convenient wrapping of calls to the
@@ -149,24 +149,24 @@
 // error. If the error is nil, the function converts the reply to the specified
 // type:
 //
-//  exists, err := redis.Bool(c.Do("EXISTS", "foo"))
-//  if err != nil {
-//      // handle error return from c.Do or type conversion error.
-//  }
+//	exists, err := redis.Bool(c.Do("EXISTS", "foo"))
+//	if err != nil {
+//	    // handle error return from c.Do or type conversion error.
+//	}
 //
 // The Scan function converts elements of a array reply to Go types:
 //
-//  var value1 int
-//  var value2 string
-//  reply, err := redis.Values(c.Do("MGET", "key1", "key2"))
-//  if err != nil {
-//      // handle error
-//  }
-//   if _, err := redis.Scan(reply, &value1, &value2); err != nil {
-//      // handle error
-//  }
-//
-// Errors
+//	var value1 int
+//	var value2 string
+//	reply, err := redis.Values(c.Do("MGET", "key1", "key2"))
+//	if err != nil {
+//	    // handle error
+//	}
+//	 if _, err := redis.Scan(reply, &value1, &value2); err != nil {
+//	    // handle error
+//	}
+//
+// # Errors
 //
 // Connection methods return error replies from the server as type redis.Error.
 //

redis/go16.go

@@ -1,3 +1,4 @@
+//go:build !go1.7
 // +build !go1.7
 
 package redis

redis/go17.go

@@ -1,3 +1,4 @@
+//go:build go1.7 && !go1.8
 // +build go1.7,!go1.8
 
 package redis

redis/go18.go

@@ -1,3 +1,4 @@
+//go:build go1.8
 // +build go1.8
 
 package redis

redis/list_test.go

@@ -12,6 +12,7 @@
 // License for the specific language governing permissions and limitations
 // under the License.
 
+//go:build go1.9
 // +build go1.9
 
 package redis