From caf3e350a548af1add9def68087ac53d1d000caa Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Thu, 31 May 2018 14:13:40 +0800
Subject: [PATCH 001/105] doc: update readme for adding binding about skip
 validate (#1359)

* update readme for adding binding about skip validate

* update readme for adding binding about skip validate
---
 README.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/README.md b/README.md
index fd5c1755..0bac65b2 100644
--- a/README.md
+++ b/README.md
@@ -572,6 +572,10 @@ $ curl -v -X POST \
 {"error":"Key: 'Login.Password' Error:Field validation for 'Password' failed on the 'required' tag"}
 ```
 
+**Skip validate**
+
+When running the above example using the above the `curl` command, it returns error. Because the example use `binding:"required"` for `Password`. If use `binding:"-"` for `Password`, then it will not return error when running the above example again.
+
 ### Custom Validators
 
 It is also possible to register custom validators. See the [example code](examples/custom-validation/server.go).

From 87d536c00120e6631cd7e6ff100739858e07e002 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Thu, 21 Jun 2018 09:31:43 +0800
Subject: [PATCH 002/105] utils:  use strings.Split instead of
 strings.IndexByte (#1400)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

And I test them benchmark:

code:

```go
# stringsbench.go
package stringsbench

import "strings"

func index(part string) string {
	if index := strings.IndexByte(part, ';'); index >= 0 {
		if part := strings.TrimSpace(strings.Split(part, ";")[0]); part != "" {
			return part[0:index]
		}
	}
	return ""
}

func split(part string) string {
	return strings.Split(part, ";")[0]
}
```

```go
# stringsbench_test.go
package stringsbench

import (
	"testing"
)

func BenchmarkIndex(b *testing.B) {
	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			index("text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8")
		}
	})
}

func BenchmarkSplit(b *testing.B) {
	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			split("text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8")
		}
	})
}
```

And the result:

```shell
➜  strings go test --bench=.
goos: darwin
goarch: amd64
BenchmarkIndex-8   	30000000	        46.1 ns/op
BenchmarkSplit-8   	50000000	        35.9 ns/op
PASS
ok  	_/Users/tianou/strings	3.271s
➜  strings go test --bench=.
goos: darwin
goarch: amd64
BenchmarkIndex-8   	30000000	        44.2 ns/op
BenchmarkSplit-8   	50000000	        34.7 ns/op
PASS
ok  	_/Users/tianou/strings	3.156s
➜  strings go test --bench=.
goos: darwin
goarch: amd64
BenchmarkIndex-8   	30000000	        45.6 ns/op
BenchmarkSplit-8   	50000000	        35.3 ns/op
PASS
ok  	_/Users/tianou/strings	3.230s
```
---
 utils.go | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/utils.go b/utils.go
index 278029d7..bf32c775 100644
--- a/utils.go
+++ b/utils.go
@@ -103,10 +103,7 @@ func parseAccept(acceptHeader string) []string {
 	parts := strings.Split(acceptHeader, ",")
 	out := make([]string, 0, len(parts))
 	for _, part := range parts {
-		if index := strings.IndexByte(part, ';'); index >= 0 {
-			part = part[0:index]
-		}
-		if part = strings.TrimSpace(part); part != "" {
+		if part = strings.TrimSpace(strings.Split(part, ";")[0]); part != "" {
 			out = append(out, part)
 		}
 	}

From bf85b32c1d11dcfa2202daa6d1ad2addae2d1619 Mon Sep 17 00:00:00 2001
From: htobenothing <htobenothing@gmail.com>
Date: Thu, 21 Jun 2018 09:53:52 +0800
Subject: [PATCH 003/105] Add Pusher() function for support http2 server push
 (#1273)

gin already support http2, while previously not support server push.
Add Pusher() function to extend the ResponseWriter interface.

```golang
// get http.Pusher
 if pusher := c.Writer.Pusher(); pusher != nil {
     // use pusher.Push() to do server push
}
```
<img width="881" alt="screen shot 2018-03-07 at 11 20 49 pm" src="https://user-images.githubusercontent.com/16014993/37100619-680c00c6-225e-11e8-9352-76ec3bd62894.png">
---
 README.md                                | 50 ++++++++++++++++++++++++
 examples/http-pusher/assets/app.js       |  1 +
 examples/http-pusher/main.go             | 41 +++++++++++++++++++
 examples/http-pusher/testdata/ca.pem     | 15 +++++++
 examples/http-pusher/testdata/server.key | 16 ++++++++
 examples/http-pusher/testdata/server.pem | 16 ++++++++
 response_writer.go                       |  2 +-
 response_writer_1.7.go                   | 12 ++++++
 response_writer_1.8.go                   | 25 ++++++++++++
 9 files changed, 177 insertions(+), 1 deletion(-)
 create mode 100644 examples/http-pusher/assets/app.js
 create mode 100644 examples/http-pusher/main.go
 create mode 100644 examples/http-pusher/testdata/ca.pem
 create mode 100644 examples/http-pusher/testdata/server.key
 create mode 100644 examples/http-pusher/testdata/server.pem
 create mode 100644 response_writer_1.7.go
 create mode 100644 response_writer_1.8.go

diff --git a/README.md b/README.md
index 0bac65b2..c2917a5f 100644
--- a/README.md
+++ b/README.md
@@ -54,6 +54,7 @@ Gin is a web framework written in Go (Golang). It features a martini-like API wi
     - [Build a single binary with templates](#build-a-single-binary-with-templates)
     - [Bind form-data request with custom struct](#bind-form-data-request-with-custom-struct)
     - [Try to bind body into different structs](#try-to-bind-body-into-different-structs)
+    - [http2 server push](#http2-server-push)
 - [Testing](#testing)
 - [Users](#users--)
 
@@ -1656,6 +1657,55 @@ enough to call binding at once.
 can be called by `c.ShouldBind()` multiple times without any damage to
 performance (See [#1341](https://github.com/gin-gonic/gin/pull/1341)).
 
+### http2 server push
+
+http.Pusher is supported only **go1.8+**. See the [golang blog](https://blog.golang.org/h2push) for detail information.
+
+[embedmd]:# (examples/http-pusher/main.go go)
+```go
+package main
+
+import (
+	"html/template"
+	"log"
+
+	"github.com/gin-gonic/gin"
+)
+
+var html = template.Must(template.New("https").Parse(`
+<html>
+<head>
+  <title>Https Test</title>
+  <script src="/assets/app.js"></script>
+</head>
+<body>
+  <h1 style="color:red;">Welcome, Ginner!</h1>
+</body>
+</html>
+`))
+
+func main() {
+	r := gin.Default()
+	r.Static("/assets", "./assets")
+	r.SetHTMLTemplate(html)
+
+	r.GET("/", func(c *gin.Context) {
+		if pusher := c.Writer.Pusher(); pusher != nil {
+			// use pusher.Push() to do server push
+			if err := pusher.Push("/assets/app.js", nil); err != nil {
+				log.Printf("Failed to push: %v", err)
+			}
+		}
+		c.HTML(200, "https", gin.H{
+			"status": "success",
+		})
+	})
+
+	// Listen and Server in https://127.0.0.1:8080
+	r.RunTLS(":8080", "./testdata/server.pem", "./testdata/server.key")
+}
+```
+
 ## Testing
 
 The `net/http/httptest` package is preferable way for HTTP testing.
diff --git a/examples/http-pusher/assets/app.js b/examples/http-pusher/assets/app.js
new file mode 100644
index 00000000..05271b67
--- /dev/null
+++ b/examples/http-pusher/assets/app.js
@@ -0,0 +1 @@
+console.log("http2 pusher");
diff --git a/examples/http-pusher/main.go b/examples/http-pusher/main.go
new file mode 100644
index 00000000..d4f33aa0
--- /dev/null
+++ b/examples/http-pusher/main.go
@@ -0,0 +1,41 @@
+package main
+
+import (
+	"html/template"
+	"log"
+
+	"github.com/gin-gonic/gin"
+)
+
+var html = template.Must(template.New("https").Parse(`
+<html>
+<head>
+  <title>Https Test</title>
+  <script src="/assets/app.js"></script>
+</head>
+<body>
+  <h1 style="color:red;">Welcome, Ginner!</h1>
+</body>
+</html>
+`))
+
+func main() {
+	r := gin.Default()
+	r.Static("/assets", "./assets")
+	r.SetHTMLTemplate(html)
+
+	r.GET("/", func(c *gin.Context) {
+		if pusher := c.Writer.Pusher(); pusher != nil {
+			// use pusher.Push() to do server push
+			if err := pusher.Push("/assets/app.js", nil); err != nil {
+				log.Printf("Failed to push: %v", err)
+			}
+		}
+		c.HTML(200, "https", gin.H{
+			"status": "success",
+		})
+	})
+
+	// Listen and Server in https://127.0.0.1:8080
+	r.RunTLS(":8080", "./testdata/server.pem", "./testdata/server.key")
+}
diff --git a/examples/http-pusher/testdata/ca.pem b/examples/http-pusher/testdata/ca.pem
new file mode 100644
index 00000000..6c8511a7
--- /dev/null
+++ b/examples/http-pusher/testdata/ca.pem
@@ -0,0 +1,15 @@
+-----BEGIN CERTIFICATE-----
+MIICSjCCAbOgAwIBAgIJAJHGGR4dGioHMA0GCSqGSIb3DQEBCwUAMFYxCzAJBgNV
+BAYTAkFVMRMwEQYDVQQIEwpTb21lLVN0YXRlMSEwHwYDVQQKExhJbnRlcm5ldCBX
+aWRnaXRzIFB0eSBMdGQxDzANBgNVBAMTBnRlc3RjYTAeFw0xNDExMTEyMjMxMjla
+Fw0yNDExMDgyMjMxMjlaMFYxCzAJBgNVBAYTAkFVMRMwEQYDVQQIEwpTb21lLVN0
+YXRlMSEwHwYDVQQKExhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQxDzANBgNVBAMT
+BnRlc3RjYTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAwEDfBV5MYdlHVHJ7
++L4nxrZy7mBfAVXpOc5vMYztssUI7mL2/iYujiIXM+weZYNTEpLdjyJdu7R5gGUu
+g1jSVK/EPHfc74O7AyZU34PNIP4Sh33N+/A5YexrNgJlPY+E3GdVYi4ldWJjgkAd
+Qah2PH5ACLrIIC6tRka9hcaBlIECAwEAAaMgMB4wDAYDVR0TBAUwAwEB/zAOBgNV
+HQ8BAf8EBAMCAgQwDQYJKoZIhvcNAQELBQADgYEAHzC7jdYlzAVmddi/gdAeKPau
+sPBG/C2HCWqHzpCUHcKuvMzDVkY/MP2o6JIW2DBbY64bO/FceExhjcykgaYtCH/m
+oIU63+CFOTtR7otyQAWHqXa7q4SbCDlG7DyRFxqG0txPtGvy12lgldA2+RgcigQG
+Dfcog5wrJytaQ6UA0wE=
+-----END CERTIFICATE-----
diff --git a/examples/http-pusher/testdata/server.key b/examples/http-pusher/testdata/server.key
new file mode 100644
index 00000000..143a5b87
--- /dev/null
+++ b/examples/http-pusher/testdata/server.key
@@ -0,0 +1,16 @@
+-----BEGIN PRIVATE KEY-----
+MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAOHDFScoLCVJpYDD
+M4HYtIdV6Ake/sMNaaKdODjDMsux/4tDydlumN+fm+AjPEK5GHhGn1BgzkWF+slf
+3BxhrA/8dNsnunstVA7ZBgA/5qQxMfGAq4wHNVX77fBZOgp9VlSMVfyd9N8YwbBY
+AckOeUQadTi2X1S6OgJXgQ0m3MWhAgMBAAECgYAn7qGnM2vbjJNBm0VZCkOkTIWm
+V10okw7EPJrdL2mkre9NasghNXbE1y5zDshx5Nt3KsazKOxTT8d0Jwh/3KbaN+YY
+tTCbKGW0pXDRBhwUHRcuRzScjli8Rih5UOCiZkhefUTcRb6xIhZJuQy71tjaSy0p
+dHZRmYyBYO2YEQ8xoQJBAPrJPhMBkzmEYFtyIEqAxQ/o/A6E+E4w8i+KM7nQCK7q
+K4JXzyXVAjLfyBZWHGM2uro/fjqPggGD6QH1qXCkI4MCQQDmdKeb2TrKRh5BY1LR
+81aJGKcJ2XbcDu6wMZK4oqWbTX2KiYn9GB0woM6nSr/Y6iy1u145YzYxEV/iMwff
+DJULAkB8B2MnyzOg0pNFJqBJuH29bKCcHa8gHJzqXhNO5lAlEbMK95p/P2Wi+4Hd
+aiEIAF1BF326QJcvYKmwSmrORp85AkAlSNxRJ50OWrfMZnBgzVjDx3xG6KsFQVk2
+ol6VhqL6dFgKUORFUWBvnKSyhjJxurlPEahV6oo6+A+mPhFY8eUvAkAZQyTdupP3
+XEFQKctGz+9+gKkemDp7LBBMEMBXrGTLPhpEfcjv/7KPdnFHYmhYeBTBnuVmTVWe
+F98XJ7tIFfJq
+-----END PRIVATE KEY-----
diff --git a/examples/http-pusher/testdata/server.pem b/examples/http-pusher/testdata/server.pem
new file mode 100644
index 00000000..f3d43fcc
--- /dev/null
+++ b/examples/http-pusher/testdata/server.pem
@@ -0,0 +1,16 @@
+-----BEGIN CERTIFICATE-----
+MIICnDCCAgWgAwIBAgIBBzANBgkqhkiG9w0BAQsFADBWMQswCQYDVQQGEwJBVTET
+MBEGA1UECBMKU29tZS1TdGF0ZTEhMB8GA1UEChMYSW50ZXJuZXQgV2lkZ2l0cyBQ
+dHkgTHRkMQ8wDQYDVQQDEwZ0ZXN0Y2EwHhcNMTUxMTA0MDIyMDI0WhcNMjUxMTAx
+MDIyMDI0WjBlMQswCQYDVQQGEwJVUzERMA8GA1UECBMISWxsaW5vaXMxEDAOBgNV
+BAcTB0NoaWNhZ28xFTATBgNVBAoTDEV4YW1wbGUsIENvLjEaMBgGA1UEAxQRKi50
+ZXN0Lmdvb2dsZS5jb20wgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAOHDFSco
+LCVJpYDDM4HYtIdV6Ake/sMNaaKdODjDMsux/4tDydlumN+fm+AjPEK5GHhGn1Bg
+zkWF+slf3BxhrA/8dNsnunstVA7ZBgA/5qQxMfGAq4wHNVX77fBZOgp9VlSMVfyd
+9N8YwbBYAckOeUQadTi2X1S6OgJXgQ0m3MWhAgMBAAGjazBpMAkGA1UdEwQCMAAw
+CwYDVR0PBAQDAgXgME8GA1UdEQRIMEaCECoudGVzdC5nb29nbGUuZnKCGHdhdGVy
+em9vaS50ZXN0Lmdvb2dsZS5iZYISKi50ZXN0LnlvdXR1YmUuY29thwTAqAEDMA0G
+CSqGSIb3DQEBCwUAA4GBAJFXVifQNub1LUP4JlnX5lXNlo8FxZ2a12AFQs+bzoJ6
+hM044EDjqyxUqSbVePK0ni3w1fHQB5rY9yYC5f8G7aqqTY1QOhoUk8ZTSTRpnkTh
+y4jjdvTZeLDVBlueZUTDRmy2feY5aZIU18vFDK08dTG0A87pppuv1LNIR3loveU8
+-----END CERTIFICATE-----
diff --git a/response_writer.go b/response_writer.go
index 232f00aa..14b1cfc3 100644
--- a/response_writer.go
+++ b/response_writer.go
@@ -16,7 +16,7 @@ const (
 	defaultStatus = 200
 )
 
-type ResponseWriter interface {
+type responseWriterBase interface {
 	http.ResponseWriter
 	http.Hijacker
 	http.Flusher
diff --git a/response_writer_1.7.go b/response_writer_1.7.go
new file mode 100644
index 00000000..801d196b
--- /dev/null
+++ b/response_writer_1.7.go
@@ -0,0 +1,12 @@
+// +build !go1.8
+
+// Copyright 2018 Gin Core Team.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+// ResponseWriter ...
+type ResponseWriter interface {
+	responseWriterBase
+}
diff --git a/response_writer_1.8.go b/response_writer_1.8.go
new file mode 100644
index 00000000..527c0038
--- /dev/null
+++ b/response_writer_1.8.go
@@ -0,0 +1,25 @@
+// +build go1.8
+
+// Copyright 2018 Gin Core Team.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+import (
+	"net/http"
+)
+
+// ResponseWriter ...
+type ResponseWriter interface {
+	responseWriterBase
+	// get the http.Pusher for server push
+	Pusher() http.Pusher
+}
+
+func (w *responseWriter) Pusher() (pusher http.Pusher) {
+	if pusher, ok := w.ResponseWriter.(http.Pusher); ok {
+		return pusher
+	}
+	return nil
+}

From 737d2fb7ab4ad358c5fa01b7a08ce346dcaebd79 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Fri, 22 Jun 2018 09:51:06 +0800
Subject: [PATCH 004/105] add grpc example (#1401)

use grpc helloworld example.
---
 Makefile                          |   3 +-
 coverage.sh                       |   2 +-
 examples/grpc/README.md           |  19 ++++
 examples/grpc/gin/main.go         |  46 +++++++++
 examples/grpc/grpc/server.go      |  34 +++++++
 examples/grpc/pb/helloworld.pb.go | 151 ++++++++++++++++++++++++++++++
 examples/grpc/pb/helloworld.proto |  37 ++++++++
 7 files changed, 290 insertions(+), 2 deletions(-)
 create mode 100644 examples/grpc/README.md
 create mode 100644 examples/grpc/gin/main.go
 create mode 100644 examples/grpc/grpc/server.go
 create mode 100644 examples/grpc/pb/helloworld.pb.go
 create mode 100644 examples/grpc/pb/helloworld.proto

diff --git a/Makefile b/Makefile
index 5468563a..51b9969f 100644
--- a/Makefile
+++ b/Makefile
@@ -1,5 +1,6 @@
 GOFMT ?= gofmt "-s"
 PACKAGES ?= $(shell go list ./... | grep -v /vendor/)
+VETPACKAGES ?= $(shell go list ./... | grep -v /vendor/ | grep -v /examples/)
 GOFILES := $(shell find . -name "*.go" -type f -not -path "./vendor/*")
 
 all: install
@@ -26,7 +27,7 @@ fmt-check:
 	fi;
 
 vet:
-	go vet $(PACKAGES)
+	go vet $(VETPACKAGES)
 
 deps:
 	@hash govendor > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
diff --git a/coverage.sh b/coverage.sh
index 81437f91..4d1ee036 100644
--- a/coverage.sh
+++ b/coverage.sh
@@ -4,7 +4,7 @@ set -e
 
 echo "mode: count" > coverage.out
 
-for d in $(go list ./... | grep -E 'gin$|binding$|render$'); do
+for d in $(go list ./... | grep -E 'gin$|binding$|render$' | grep -v 'examples'); do
     go test -v -covermode=count -coverprofile=profile.out $d
     if [ -f profile.out ]; then
         cat profile.out | grep -v "mode:" >> coverage.out
diff --git a/examples/grpc/README.md b/examples/grpc/README.md
new file mode 100644
index 00000000..a96d3c1c
--- /dev/null
+++ b/examples/grpc/README.md
@@ -0,0 +1,19 @@
+## How to run this example
+
+1. run grpc server
+
+```sh
+$ go run grpc/server.go
+```
+
+2. run gin server
+
+```sh
+$ go run gin/main.go
+```
+
+3. use curl command to test it
+
+```sh
+$ curl -v 'http://localhost:8052/rest/n/thinkerou'
+```
diff --git a/examples/grpc/gin/main.go b/examples/grpc/gin/main.go
new file mode 100644
index 00000000..c21692ae
--- /dev/null
+++ b/examples/grpc/gin/main.go
@@ -0,0 +1,46 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+	pb "github.com/gin-gonic/gin/examples/grpc/pb"
+	"google.golang.org/grpc"
+)
+
+func main() {
+	// Set up a connection to the server.
+	conn, err := grpc.Dial("localhost:50051", grpc.WithInsecure())
+	if err != nil {
+		log.Fatalf("did not connect: %v", err)
+	}
+	defer conn.Close()
+	client := pb.NewGreeterClient(conn)
+
+	// Set up a http setver.
+	r := gin.Default()
+	r.GET("/rest/n/:name", func(c *gin.Context) {
+		name := c.Param("name")
+
+		// Contact the server and print out its response.
+		req := &pb.HelloRequest{Name: name}
+		res, err := client.SayHello(g, req)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": err.Error(),
+			})
+			return
+		}
+
+		c.JSON(http.StatusOK, gin.H{
+			"result": fmt.Sprint(res.Message),
+		})
+	})
+
+	// Run http server
+	if err := r.Run(":8052"); err != nil {
+		log.Fatalf("could not run server: %v", err)
+	}
+}
diff --git a/examples/grpc/grpc/server.go b/examples/grpc/grpc/server.go
new file mode 100644
index 00000000..d9bf9fc5
--- /dev/null
+++ b/examples/grpc/grpc/server.go
@@ -0,0 +1,34 @@
+package main
+
+import (
+	"log"
+	"net"
+
+	pb "github.com/gin-gonic/gin/examples/grpc/pb"
+	"golang.org/x/net/context"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/reflection"
+)
+
+// server is used to implement helloworld.GreeterServer.
+type server struct{}
+
+// SayHello implements helloworld.GreeterServer
+func (s *server) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
+	return &pb.HelloReply{Message: "Hello " + in.Name}, nil
+}
+
+func main() {
+	lis, err := net.Listen("tcp", ":50051")
+	if err != nil {
+		log.Fatalf("failed to listen: %v", err)
+	}
+	s := grpc.NewServer()
+	pb.RegisterGreeterServer(s, &server{})
+
+	// Register reflection service on gRPC server.
+	reflection.Register(s)
+	if err := s.Serve(lis); err != nil {
+		log.Fatalf("failed to serve: %v", err)
+	}
+}
diff --git a/examples/grpc/pb/helloworld.pb.go b/examples/grpc/pb/helloworld.pb.go
new file mode 100644
index 00000000..c8c8942a
--- /dev/null
+++ b/examples/grpc/pb/helloworld.pb.go
@@ -0,0 +1,151 @@
+// Code generated by protoc-gen-go.
+// source: helloworld.proto
+// DO NOT EDIT!
+
+/*
+Package helloworld is a generated protocol buffer package.
+
+It is generated from these files:
+	helloworld.proto
+
+It has these top-level messages:
+	HelloRequest
+	HelloReply
+*/
+package helloworld
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+import (
+	context "golang.org/x/net/context"
+	grpc "google.golang.org/grpc"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+// The request message containing the user's name.
+type HelloRequest struct {
+	Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+}
+
+func (m *HelloRequest) Reset()                    { *m = HelloRequest{} }
+func (m *HelloRequest) String() string            { return proto.CompactTextString(m) }
+func (*HelloRequest) ProtoMessage()               {}
+func (*HelloRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+// The response message containing the greetings
+type HelloReply struct {
+	Message string `protobuf:"bytes,1,opt,name=message" json:"message,omitempty"`
+}
+
+func (m *HelloReply) Reset()                    { *m = HelloReply{} }
+func (m *HelloReply) String() string            { return proto.CompactTextString(m) }
+func (*HelloReply) ProtoMessage()               {}
+func (*HelloReply) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+
+func init() {
+	proto.RegisterType((*HelloRequest)(nil), "helloworld.HelloRequest")
+	proto.RegisterType((*HelloReply)(nil), "helloworld.HelloReply")
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// Client API for Greeter service
+
+type GreeterClient interface {
+	// Sends a greeting
+	SayHello(ctx context.Context, in *HelloRequest, opts ...grpc.CallOption) (*HelloReply, error)
+}
+
+type greeterClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewGreeterClient(cc *grpc.ClientConn) GreeterClient {
+	return &greeterClient{cc}
+}
+
+func (c *greeterClient) SayHello(ctx context.Context, in *HelloRequest, opts ...grpc.CallOption) (*HelloReply, error) {
+	out := new(HelloReply)
+	err := grpc.Invoke(ctx, "/helloworld.Greeter/SayHello", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// Server API for Greeter service
+
+type GreeterServer interface {
+	// Sends a greeting
+	SayHello(context.Context, *HelloRequest) (*HelloReply, error)
+}
+
+func RegisterGreeterServer(s *grpc.Server, srv GreeterServer) {
+	s.RegisterService(&_Greeter_serviceDesc, srv)
+}
+
+func _Greeter_SayHello_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(HelloRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(GreeterServer).SayHello(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/helloworld.Greeter/SayHello",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(GreeterServer).SayHello(ctx, req.(*HelloRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _Greeter_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "helloworld.Greeter",
+	HandlerType: (*GreeterServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "SayHello",
+			Handler:    _Greeter_SayHello_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "helloworld.proto",
+}
+
+func init() { proto.RegisterFile("helloworld.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+	// 174 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0x12, 0xc8, 0x48, 0xcd, 0xc9,
+	0xc9, 0x2f, 0xcf, 0x2f, 0xca, 0x49, 0xd1, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x42, 0x88,
+	0x28, 0x29, 0x71, 0xf1, 0x78, 0x80, 0x78, 0x41, 0xa9, 0x85, 0xa5, 0xa9, 0xc5, 0x25, 0x42, 0x42,
+	0x5c, 0x2c, 0x79, 0x89, 0xb9, 0xa9, 0x12, 0x8c, 0x0a, 0x8c, 0x1a, 0x9c, 0x41, 0x60, 0xb6, 0x92,
+	0x1a, 0x17, 0x17, 0x54, 0x4d, 0x41, 0x4e, 0xa5, 0x90, 0x04, 0x17, 0x7b, 0x6e, 0x6a, 0x71, 0x71,
+	0x62, 0x3a, 0x4c, 0x11, 0x8c, 0x6b, 0xe4, 0xc9, 0xc5, 0xee, 0x5e, 0x94, 0x9a, 0x5a, 0x92, 0x5a,
+	0x24, 0x64, 0xc7, 0xc5, 0x11, 0x9c, 0x58, 0x09, 0xd6, 0x25, 0x24, 0xa1, 0x87, 0xe4, 0x02, 0x64,
+	0xcb, 0xa4, 0xc4, 0xb0, 0xc8, 0x00, 0xad, 0x50, 0x62, 0x70, 0x32, 0xe0, 0x92, 0xce, 0xcc, 0xd7,
+	0x4b, 0x2f, 0x2a, 0x48, 0xd6, 0x4b, 0xad, 0x48, 0xcc, 0x2d, 0xc8, 0x49, 0x2d, 0x46, 0x52, 0xeb,
+	0xc4, 0x0f, 0x56, 0x1c, 0x0e, 0x62, 0x07, 0x80, 0xbc, 0x14, 0xc0, 0x98, 0xc4, 0x06, 0xf6, 0x9b,
+	0x31, 0x20, 0x00, 0x00, 0xff, 0xff, 0x0f, 0xb7, 0xcd, 0xf2, 0xef, 0x00, 0x00, 0x00,
+}
diff --git a/examples/grpc/pb/helloworld.proto b/examples/grpc/pb/helloworld.proto
new file mode 100644
index 00000000..d79a6a0d
--- /dev/null
+++ b/examples/grpc/pb/helloworld.proto
@@ -0,0 +1,37 @@
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+syntax = "proto3";
+
+option java_multiple_files = true;
+option java_package = "io.grpc.examples.helloworld";
+option java_outer_classname = "HelloWorldProto";
+
+package helloworld;
+
+// The greeting service definition.
+service Greeter {
+  // Sends a greeting
+  rpc SayHello (HelloRequest) returns (HelloReply) {}
+}
+
+// The request message containing the user's name.
+message HelloRequest {
+  string name = 1;
+}
+
+// The response message containing the greetings
+message HelloReply {
+  string message = 1;
+}

From 605aa1c30f196733a90a4f773b691d2350a30e00 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Fri, 22 Jun 2018 23:44:45 +0800
Subject: [PATCH 005/105] example: fix typo for grpc (#1405)

sorry...fixed #1403
---
 examples/grpc/gin/main.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/grpc/gin/main.go b/examples/grpc/gin/main.go
index c21692ae..edc1ca9b 100644
--- a/examples/grpc/gin/main.go
+++ b/examples/grpc/gin/main.go
@@ -26,7 +26,7 @@ func main() {
 
 		// Contact the server and print out its response.
 		req := &pb.HelloRequest{Name: name}
-		res, err := client.SayHello(g, req)
+		res, err := client.SayHello(c, req)
 		if err != nil {
 			c.JSON(http.StatusInternalServerError, gin.H{
 				"error": err.Error(),

From 8035359102b5384ad1f860675c85c0238b06b6e3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Sat, 23 Jun 2018 00:08:58 +0800
Subject: [PATCH 006/105] use strings.Split instead of strings.IndexByte
 (#1406)

---
 context.go | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)
 mode change 100755 => 100644 context.go

diff --git a/context.go b/context.go
old mode 100755
new mode 100644
index 462357e1..6a84de5e
--- a/context.go
+++ b/context.go
@@ -539,14 +539,10 @@ func (c *Context) ShouldBindBodyWith(
 func (c *Context) ClientIP() string {
 	if c.engine.ForwardedByClientIP {
 		clientIP := c.requestHeader("X-Forwarded-For")
-		if index := strings.IndexByte(clientIP, ','); index >= 0 {
-			clientIP = clientIP[0:index]
+		clientIP = strings.TrimSpace(strings.Split(clientIP, ",")[0])
+		if clientIP == "" {
+			clientIP = strings.TrimSpace(c.requestHeader("X-Real-Ip"))
 		}
-		clientIP = strings.TrimSpace(clientIP)
-		if clientIP != "" {
-			return clientIP
-		}
-		clientIP = strings.TrimSpace(c.requestHeader("X-Real-Ip"))
 		if clientIP != "" {
 			return clientIP
 		}

From 760d0574db7432376d91b53dba9146c1f32d28c0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Sat, 23 Jun 2018 00:45:43 +0800
Subject: [PATCH 007/105] vendor: remove vendor package from example folder
 (#1402)

updated `vendor.json` is ok.
but set `ignore test` in `vendor.json`, `x/net/context` package only use in `context_test.go`, I don't know why vendor still need it.
please @appleboy review the pull request, thanks a lot.
---
 vendor/vendor.json | 61 ----------------------------------------------
 1 file changed, 61 deletions(-)

diff --git a/vendor/vendor.json b/vendor/vendor.json
index 5ace49df..c34c2de3 100644
--- a/vendor/vendor.json
+++ b/vendor/vendor.json
@@ -9,61 +9,30 @@
 			"revision": "346938d642f2ec3594ed81d874461961cd0faa76",
 			"revisionTime": "2016-10-29T20:57:26Z"
 		},
-		{
-			"checksumSHA1": "7c3FuEadBInl/4ExSrB7iJMXpe4=",
-			"path": "github.com/dustin/go-broadcast",
-			"revision": "3bdf6d4a7164a50bc19d5f230e2981d87d2584f1",
-			"revisionTime": "2014-06-27T04:00:55Z"
-		},
 		{
 			"checksumSHA1": "QeKwBtN2df+j+4stw3bQJ6yO4EY=",
 			"path": "github.com/gin-contrib/sse",
 			"revision": "22d885f9ecc78bf4ee5d72b937e4bbcdc58e8cae",
 			"revisionTime": "2017-01-09T09:34:21Z"
 		},
-		{
-			"checksumSHA1": "+vZNyF2MykVjenLg1TpjjgjthV0=",
-			"path": "github.com/gin-gonic/autotls",
-			"revision": "8ca25fbde72bb72a00466215b94b489c71fcb815",
-			"revisionTime": "2017-09-16T16:54:15Z"
-		},
 		{
 			"checksumSHA1": "qlPUeFabwF4RKAOF1H+yBFU1Veg=",
 			"path": "github.com/golang/protobuf/proto",
 			"revision": "5a0f697c9ed9d68fef0116532c6e05cfeae00e55",
 			"revisionTime": "2017-06-01T23:02:30Z"
 		},
-		{
-			"checksumSHA1": "Cq9h7eDNXXyR/qJPvO8/Rk4pmFg=",
-			"path": "github.com/jessevdk/go-assets",
-			"revision": "4f4301a06e153ff90e17793577ab6bf79f8dc5c5",
-			"revisionTime": "2016-09-21T14:41:39Z"
-		},
 		{
 			"checksumSHA1": "Ajh8TemnItg4nn+jKmVcsMRALBc=",
 			"path": "github.com/json-iterator/go",
 			"revision": "36b14963da70d11297d313183d7e6388c8510e1e",
 			"revisionTime": "2017-08-29T15:58:51Z"
 		},
-		{
-			"checksumSHA1": "9if9IBLsxkarJ804NPWAzgskIAk=",
-			"path": "github.com/manucorporat/stats",
-			"revision": "8f2d6ace262eba462e9beb552382c98be51d807b",
-			"revisionTime": "2015-05-31T20:46:25Z"
-		},
 		{
 			"checksumSHA1": "U6lX43KDDlNOn+Z0Yyww+ZzHfFo=",
 			"path": "github.com/mattn/go-isatty",
 			"revision": "57fdcb988a5c543893cc61bce354a6e24ab70022",
 			"revisionTime": "2017-03-07T16:30:44Z"
 		},
-		{
-			"checksumSHA1": "LuFv4/jlrmFNnDb/5SCSEPAM9vU=",
-			"comment": "v1.0.0",
-			"path": "github.com/pmezard/go-difflib/difflib",
-			"revision": "792786c7400a136282c1664665ae0a8db921c6c2",
-			"revisionTime": "2016-01-10T10:55:54Z"
-		},
 		{
 			"checksumSHA1": "Q2V7Zs3diLmLfmfbiuLpSxETSuY=",
 			"comment": "v1.1.4",
@@ -71,30 +40,12 @@
 			"revision": "976c720a22c8eb4eb6a0b4348ad85ad12491a506",
 			"revisionTime": "2016-09-25T22:06:09Z"
 		},
-		{
-			"checksumSHA1": "IopMW+arBezL5bqOfrVU6UEfn28=",
-			"path": "github.com/thinkerou/favicon",
-			"revision": "94a442a49da6e2d44bdd5e0d2e2e185c43a19d93",
-			"revisionTime": "2017-07-10T14:05:20Z"
-		},
 		{
 			"checksumSHA1": "CoxdaTYdPZNJXr8mJfLxye428N0=",
 			"path": "github.com/ugorji/go/codec",
 			"revision": "c88ee250d0221a57af388746f5cf03768c21d6e2",
 			"revisionTime": "2017-02-15T20:11:44Z"
 		},
-		{
-			"checksumSHA1": "W0j4I7QpxXlChjyhAojZmFjU6Bg=",
-			"path": "golang.org/x/crypto/acme",
-			"revision": "adbae1b6b6fb4b02448a0fc0dbbc9ba2b95b294d",
-			"revisionTime": "2017-06-19T06:03:41Z"
-		},
-		{
-			"checksumSHA1": "TrKJW+flz7JulXU3sqnBJjGzgQc=",
-			"path": "golang.org/x/crypto/acme/autocert",
-			"revision": "adbae1b6b6fb4b02448a0fc0dbbc9ba2b95b294d",
-			"revisionTime": "2017-06-19T06:03:41Z"
-		},
 		{
 			"checksumSHA1": "9jjO5GjLa0XF/nfWihF02RoH4qc=",
 			"comment": "release-branch.go1.7",
@@ -102,18 +53,6 @@
 			"revision": "d4c55e66d8c3a2f3382d264b08e3e3454a66355a",
 			"revisionTime": "2016-10-18T08:54:36Z"
 		},
-		{
-			"checksumSHA1": "S0DP7Pn7sZUmXc55IzZnNvERu6s=",
-			"path": "golang.org/x/sync/errgroup",
-			"revision": "8e0aa688b654ef28caa72506fa5ec8dba9fc7690",
-			"revisionTime": "2017-07-19T03:38:01Z"
-		},
-		{
-			"checksumSHA1": "TVEkpH3gq84iQ39I4R+mlDwjuVI=",
-			"path": "golang.org/x/sys/unix",
-			"revision": "99f16d856c9836c42d24e7ab64ea72916925fa97",
-			"revisionTime": "2017-03-08T15:04:45Z"
-		},
 		{
 			"checksumSHA1": "39V1idWER42Lmcmg2Uy40wMzOlo=",
 			"comment": "v8.18.1",

From 1f59bad84b577735b27a1ee855f01ed2f50cd88b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Sat, 23 Jun 2018 11:06:27 +0800
Subject: [PATCH 008/105] add an edge case from httprouter (#1407)

---
 path.go      | 2 +-
 path_test.go | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/path.go b/path.go
index ed63ad1a..1c2b8498 100644
--- a/path.go
+++ b/path.go
@@ -41,7 +41,7 @@ func cleanPath(p string) string {
 		buf[0] = '/'
 	}
 
-	trailing := n > 2 && p[n-1] == '/'
+	trailing := n > 1 && p[n-1] == '/'
 
 	// A bit more clunky without a 'lazybuf' like the path package, but the loop
 	// gets completely inlined (bufApp). So in contrast to the path package this
diff --git a/path_test.go b/path_test.go
index 4a6d945b..c1e6ed4f 100644
--- a/path_test.go
+++ b/path_test.go
@@ -24,6 +24,7 @@ var cleanTests = []struct {
 
 	// missing root
 	{"", "/"},
+	{"a/", "/a/"},
 	{"abc", "/abc"},
 	{"abc/def", "/abc/def"},
 	{"a/b/c", "/a/b/c"},

From 6c6d97ba2e7eeaf78e20fc4344b21c4e057e2a9a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Tue, 26 Jun 2018 17:21:32 +0800
Subject: [PATCH 009/105] remove hardcode instead of http status value (#1411)

---
 auth.go            |  3 ++-
 context.go         |  6 +++---
 gin.go             | 12 ++++++------
 recovery.go        |  3 ++-
 response_writer.go |  2 +-
 routergroup.go     |  2 +-
 6 files changed, 15 insertions(+), 13 deletions(-)

diff --git a/auth.go b/auth.go
index c2143091..9ed81b5d 100644
--- a/auth.go
+++ b/auth.go
@@ -7,6 +7,7 @@ package gin
 import (
 	"crypto/subtle"
 	"encoding/base64"
+	"net/http"
 	"strconv"
 )
 
@@ -51,7 +52,7 @@ func BasicAuthForRealm(accounts Accounts, realm string) HandlerFunc {
 		if !found {
 			// Credentials doesn't match, we return 401 and abort handlers chain.
 			c.Header("WWW-Authenticate", realm)
-			c.AbortWithStatus(401)
+			c.AbortWithStatus(http.StatusUnauthorized)
 			return
 		}
 
diff --git a/context.go b/context.go
index 6a84de5e..65fbb629 100644
--- a/context.go
+++ b/context.go
@@ -474,7 +474,7 @@ func (c *Context) BindQuery(obj interface{}) error {
 // See the binding package.
 func (c *Context) MustBindWith(obj interface{}, b binding.Binding) (err error) {
 	if err = c.ShouldBindWith(obj, b); err != nil {
-		c.AbortWithError(400, err).SetType(ErrorTypeBind)
+		c.AbortWithError(http.StatusBadRequest, err).SetType(ErrorTypeBind)
 	}
 
 	return
@@ -589,9 +589,9 @@ func bodyAllowedForStatus(status int) bool {
 	switch {
 	case status >= 100 && status <= 199:
 		return false
-	case status == 204:
+	case status == http.StatusNoContent:
 		return false
-	case status == 304:
+	case status == http.StatusNotModified:
 		return false
 	}
 	return true
diff --git a/gin.go b/gin.go
index b91fc2fa..65d6d446 100644
--- a/gin.go
+++ b/gin.go
@@ -378,14 +378,14 @@ func (engine *Engine) handleHTTPRequest(c *Context) {
 			if tree.method != httpMethod {
 				if handlers, _, _ := tree.root.getValue(path, nil, unescape); handlers != nil {
 					c.handlers = engine.allNoMethod
-					serveError(c, 405, default405Body)
+					serveError(c, http.StatusMethodNotAllowed, default405Body)
 					return
 				}
 			}
 		}
 	}
 	c.handlers = engine.allNoRoute
-	serveError(c, 404, default404Body)
+	serveError(c, http.StatusNotFound, default404Body)
 }
 
 var mimePlain = []string{MIMEPlain}
@@ -406,9 +406,9 @@ func serveError(c *Context, code int, defaultMessage []byte) {
 func redirectTrailingSlash(c *Context) {
 	req := c.Request
 	path := req.URL.Path
-	code := 301 // Permanent redirect, request with GET method
+	code := http.StatusMovedPermanently // Permanent redirect, request with GET method
 	if req.Method != "GET" {
-		code = 307
+		code = http.StatusTemporaryRedirect
 	}
 
 	if length := len(path); length > 1 && path[length-1] == '/' {
@@ -430,9 +430,9 @@ func redirectFixedPath(c *Context, root *node, trailingSlash bool) bool {
 		trailingSlash,
 	)
 	if found {
-		code := 301 // Permanent redirect, request with GET method
+		code := http.StatusMovedPermanently // Permanent redirect, request with GET method
 		if req.Method != "GET" {
-			code = 307
+			code = http.StatusTemporaryRedirect
 		}
 		req.URL.Path = string(fixedPath)
 		debugPrint("redirecting request %d: %s --> %s", code, path, req.URL.String())
diff --git a/recovery.go b/recovery.go
index dcbeba74..61c5bd53 100644
--- a/recovery.go
+++ b/recovery.go
@@ -10,6 +10,7 @@ import (
 	"io"
 	"io/ioutil"
 	"log"
+	"net/http"
 	"net/http/httputil"
 	"runtime"
 	"time"
@@ -41,7 +42,7 @@ func RecoveryWithWriter(out io.Writer) HandlerFunc {
 					httprequest, _ := httputil.DumpRequest(c.Request, false)
 					logger.Printf("[Recovery] %s panic recovered:\n%s\n%s\n%s%s", timeFormat(time.Now()), string(httprequest), err, stack, reset)
 				}
-				c.AbortWithStatus(500)
+				c.AbortWithStatus(http.StatusInternalServerError)
 			}
 		}()
 		c.Next()
diff --git a/response_writer.go b/response_writer.go
index 14b1cfc3..166ae8c3 100644
--- a/response_writer.go
+++ b/response_writer.go
@@ -13,7 +13,7 @@ import (
 
 const (
 	noWritten     = -1
-	defaultStatus = 200
+	defaultStatus = http.StatusOK
 )
 
 type responseWriterBase interface {
diff --git a/routergroup.go b/routergroup.go
index 53045d10..876a61b8 100644
--- a/routergroup.go
+++ b/routergroup.go
@@ -184,7 +184,7 @@ func (group *RouterGroup) createStaticHandler(relativePath string, fs http.FileS
 	_, nolisting := fs.(*onlyfilesFS)
 	return func(c *Context) {
 		if nolisting {
-			c.Writer.WriteHeader(404)
+			c.Writer.WriteHeader(http.StatusNotFound)
 		}
 		fileServer.ServeHTTP(c.Writer, c.Request)
 	}

From c00f21ff239822d013b80e54bd403fbc08a0b5ff Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Tue, 26 Jun 2018 18:56:43 +0800
Subject: [PATCH 010/105] add go version prerequisite and debug warning (#1394)

* add go version prerequisite and debug warning

* merge duplicate content

* remove duplicate content
---
 README.md     | 113 +++++++++++++++++++++++++++-----------------------
 debug.go      |   3 ++
 debug_test.go |   2 +-
 3 files changed, 64 insertions(+), 54 deletions(-)

diff --git a/README.md b/README.md
index c2917a5f..e09a51f2 100644
--- a/README.md
+++ b/README.md
@@ -15,10 +15,11 @@ Gin is a web framework written in Go (Golang). It features a martini-like API wi
 
 ## Contents
 
+- [Installation](#installation)
+- [Prerequisite](#prerequisite)
 - [Quick start](#quick-start)
 - [Benchmarks](#benchmarks)
 - [Gin v1.stable](#gin-v1-stable)
-- [Start using it](#start-using-it)
 - [Build with jsoniter](#build-with-jsoniter)
 - [API Examples](#api-examples)
     - [Using GET,POST,PUT,PATCH,DELETE and OPTIONS](#using-get-post-put-patch-delete-and-options)
@@ -58,6 +59,64 @@ Gin is a web framework written in Go (Golang). It features a martini-like API wi
 - [Testing](#testing)
 - [Users](#users--)
 
+## Installation
+
+To install Gin package, you need to install Go and set your Go workspace first.
+
+1. Download and install it:
+
+```sh
+$ go get -u github.com/gin-gonic/gin
+```
+
+2. Import it in your code:
+
+```go
+import "github.com/gin-gonic/gin"
+```
+
+3. (Optional) Import `net/http`. This is required for example if using constants such as `http.StatusOK`.
+
+```go
+import "net/http"
+```
+
+### Use a vendor tool like [Govendor](https://github.com/kardianos/govendor)
+
+1. `go get` govendor
+
+```sh
+$ go get github.com/kardianos/govendor
+```
+2. Create your project folder and `cd` inside
+
+```sh
+$ mkdir -p $GOPATH/src/github.com/myusername/project && cd "$_"
+```
+
+3. Vendor init your project and add gin
+
+```sh
+$ govendor init
+$ govendor fetch github.com/gin-gonic/gin@v1.2
+```
+
+4. Copy a starting template inside your project
+
+```sh
+$ curl https://raw.githubusercontent.com/gin-gonic/gin/master/examples/basic/main.go > main.go
+```
+
+5. Run your project
+
+```sh
+$ go run main.go
+```
+
+## Prerequisite
+
+Now Gin requires Go 1.6 or later and Go 1.7 will be required soon.
+
 ## Quick start
  
 ```sh
@@ -135,58 +194,6 @@ BenchmarkVulcan_GithubAll                   |    5000    |   394253    |   19894
 - [x] Battle tested
 - [x] API frozen, new releases will not break your code.
 
-## Start using it
-
-1. Download and install it:
-
-```sh
-$ go get github.com/gin-gonic/gin
-```
-
-2. Import it in your code:
-
-```go
-import "github.com/gin-gonic/gin"
-```
-
-3. (Optional) Import `net/http`. This is required for example if using constants such as `http.StatusOK`.
-
-```go
-import "net/http"
-```
-
-### Use a vendor tool like [Govendor](https://github.com/kardianos/govendor)
-
-1. `go get` govendor
-
-```sh
-$ go get github.com/kardianos/govendor
-```
-2. Create your project folder and `cd` inside
-
-```sh
-$ mkdir -p $GOPATH/src/github.com/myusername/project && cd "$_"
-```
-
-3. Vendor init your project and add gin
-
-```sh
-$ govendor init
-$ govendor fetch github.com/gin-gonic/gin@v1.2
-```
-
-4. Copy a starting template inside your project
-
-```sh
-$ curl https://raw.githubusercontent.com/gin-gonic/gin/master/examples/basic/main.go > main.go
-```
-
-5. Run your project
-
-```sh
-$ go run main.go
-```
-
 ## Build with [jsoniter](https://github.com/json-iterator/go)
 
 Gin use `encoding/json` as default json package but you can change to [jsoniter](https://github.com/json-iterator/go) by build from other tags.
diff --git a/debug.go b/debug.go
index 897c4943..f11156b3 100644
--- a/debug.go
+++ b/debug.go
@@ -47,6 +47,9 @@ func debugPrint(format string, values ...interface{}) {
 }
 
 func debugPrintWARNINGDefault() {
+	debugPrint(`[WARNING] Now Gin requires Go 1.6 or later and Go 1.7 will be required soon.
+
+`)
 	debugPrint(`[WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.
 
 `)
diff --git a/debug_test.go b/debug_test.go
index dfd54c82..440173b7 100644
--- a/debug_test.go
+++ b/debug_test.go
@@ -92,7 +92,7 @@ func TestDebugPrintWARNINGDefault(t *testing.T) {
 	defer teardown()
 
 	debugPrintWARNINGDefault()
-	assert.Equal(t, "[GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.\n\n", w.String())
+	assert.Equal(t, "[GIN-debug] [WARNING] Now Gin requires Go 1.6 or later and Go 1.7 will be required soon.\n\n[GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.\n\n", w.String())
 }
 
 func TestDebugPrintWARNINGNew(t *testing.T) {

From eb9f313144e6768d91421855810ed5937ce348c5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Thu, 28 Jun 2018 17:08:09 +0800
Subject: [PATCH 011/105] add comment for context (#1413)

ref #1075
annotation from go context source.
---
 context.go | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/context.go b/context.go
index 65fbb629..6fc5d25f 100644
--- a/context.go
+++ b/context.go
@@ -836,18 +836,33 @@ func (c *Context) SetAccepted(formats ...string) {
 /***** GOLANG.ORG/X/NET/CONTEXT *****/
 /************************************/
 
+// Deadline returns the time when work done on behalf of this context
+// should be canceled. Deadline returns ok==false when no deadline is
+// set. Successive calls to Deadline return the same results.
 func (c *Context) Deadline() (deadline time.Time, ok bool) {
 	return
 }
 
+// Done returns a channel that's closed when work done on behalf of this
+// context should be canceled. Done may return nil if this context can
+// never be canceled. Successive calls to Done return the same value.
 func (c *Context) Done() <-chan struct{} {
 	return nil
 }
 
+// Err returns a non-nil error value after Done is closed,
+// successive calls to Err return the same error.
+// If Done is not yet closed, Err returns nil.
+// If Done is closed, Err returns a non-nil error explaining why:
+// Canceled if the context was canceled
+// or DeadlineExceeded if the context's deadline passed.
 func (c *Context) Err() error {
 	return nil
 }
 
+// Value returns the value associated with this context for key, or nil
+// if no value is associated with key. Successive calls to Value with
+// the same key returns the same result.
 func (c *Context) Value(key interface{}) interface{} {
 	if key == 0 {
 		return c.Request

From cdd02fa9d65c15de42f1a4522fcb9af28fe56cf9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Sun, 1 Jul 2018 21:10:48 +0800
Subject: [PATCH 012/105] update error(err) to err (#1416)

the pull request update `return error(err)` to `return err`, and remove `kindOfData`.
---
 binding/binding.go           |  5 ++---
 binding/default_validator.go | 19 ++++++++-----------
 2 files changed, 10 insertions(+), 14 deletions(-)

diff --git a/binding/binding.go b/binding/binding.go
index 1a984777..3a2aad9c 100644
--- a/binding/binding.go
+++ b/binding/binding.go
@@ -4,10 +4,9 @@
 
 package binding
 
-import (
-	"net/http"
-)
+import "net/http"
 
+// Content-Type MIME of the most common data formats.
 const (
 	MIMEJSON              = "application/json"
 	MIMEHTML              = "text/html"
diff --git a/binding/default_validator.go b/binding/default_validator.go
index c67aa8a3..e7a302de 100644
--- a/binding/default_validator.go
+++ b/binding/default_validator.go
@@ -18,11 +18,17 @@ type defaultValidator struct {
 
 var _ StructValidator = &defaultValidator{}
 
+// ValidateStruct receives any kind of type, but only performed struct or pointer to struct type.
 func (v *defaultValidator) ValidateStruct(obj interface{}) error {
-	if kindOfData(obj) == reflect.Struct {
+	value := reflect.ValueOf(obj)
+	valueType := value.Kind()
+	if valueType == reflect.Ptr {
+		valueType = value.Elem().Kind()
+	}
+	if valueType == reflect.Struct {
 		v.lazyinit()
 		if err := v.validate.Struct(obj); err != nil {
-			return error(err)
+			return err
 		}
 	}
 	return nil
@@ -43,12 +49,3 @@ func (v *defaultValidator) lazyinit() {
 		v.validate = validator.New(config)
 	})
 }
-
-func kindOfData(data interface{}) reflect.Kind {
-	value := reflect.ValueOf(data)
-	valueType := value.Kind()
-	if valueType == reflect.Ptr {
-		valueType = value.Elem().Kind()
-	}
-	return valueType
-}

From 1c4cbfae59e0f62a6812b7808839eed45b66515f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Mon, 2 Jul 2018 11:06:56 +0800
Subject: [PATCH 013/105] chore: remove duplicate code (#1418)

---
 gin.go | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

diff --git a/gin.go b/gin.go
index 65d6d446..3ee8018d 100644
--- a/gin.go
+++ b/gin.go
@@ -171,14 +171,14 @@ func (engine *Engine) SecureJsonPrefix(prefix string) *Engine {
 func (engine *Engine) LoadHTMLGlob(pattern string) {
 	left := engine.delims.Left
 	right := engine.delims.Right
+	templ := template.Must(template.New("").Delims(left, right).Funcs(engine.FuncMap).ParseGlob(pattern))
 
 	if IsDebugging() {
-		debugPrintLoadTemplate(template.Must(template.New("").Delims(left, right).Funcs(engine.FuncMap).ParseGlob(pattern)))
+		debugPrintLoadTemplate(templ)
 		engine.HTMLRender = render.HTMLDebug{Glob: pattern, FuncMap: engine.FuncMap, Delims: engine.delims}
 		return
 	}
 
-	templ := template.Must(template.New("").Delims(left, right).Funcs(engine.FuncMap).ParseGlob(pattern))
 	engine.SetHTMLTemplate(templ)
 }
 
@@ -425,11 +425,7 @@ func redirectFixedPath(c *Context, root *node, trailingSlash bool) bool {
 	req := c.Request
 	path := req.URL.Path
 
-	fixedPath, found := root.findCaseInsensitivePath(
-		cleanPath(path),
-		trailingSlash,
-	)
-	if found {
+	if fixedPath, ok := root.findCaseInsensitivePath(cleanPath(path), trailingSlash); ok {
 		code := http.StatusMovedPermanently // Permanent redirect, request with GET method
 		if req.Method != "GET" {
 			code = http.StatusTemporaryRedirect

From d17a12591fb637da47576b8669fabb8752fe656d Mon Sep 17 00:00:00 2001
From: vz <vzvway@gmail.com>
Date: Tue, 3 Jul 2018 15:39:18 +0800
Subject: [PATCH 014/105] update assert param(expect, actual) position (#1421)

- update assert param(expect, actual) position
---
 errors_test.go          | 18 +++++++++---------
 response_writer_test.go |  2 +-
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/errors_test.go b/errors_test.go
index a666d7c1..0626611f 100644
--- a/errors_test.go
+++ b/errors_test.go
@@ -19,17 +19,17 @@ func TestError(t *testing.T) {
 		Type: ErrorTypePrivate,
 	}
 	assert.Equal(t, err.Error(), baseError.Error())
-	assert.Equal(t, err.JSON(), H{"error": baseError.Error()})
+	assert.Equal(t, H{"error": baseError.Error()}, err.JSON())
 
 	assert.Equal(t, err.SetType(ErrorTypePublic), err)
-	assert.Equal(t, err.Type, ErrorTypePublic)
+	assert.Equal(t, ErrorTypePublic, err.Type)
 
 	assert.Equal(t, err.SetMeta("some data"), err)
-	assert.Equal(t, err.Meta, "some data")
-	assert.Equal(t, err.JSON(), H{
+	assert.Equal(t, "some data", err.Meta)
+	assert.Equal(t, H{
 		"error": baseError.Error(),
 		"meta":  "some data",
-	})
+	}, err.JSON())
 
 	jsonBytes, _ := json.Marshal(err)
 	assert.Equal(t, "{\"error\":\"test error\",\"meta\":\"some data\"}", string(jsonBytes))
@@ -38,22 +38,22 @@ func TestError(t *testing.T) {
 		"status": "200",
 		"data":   "some data",
 	})
-	assert.Equal(t, err.JSON(), H{
+	assert.Equal(t, H{
 		"error":  baseError.Error(),
 		"status": "200",
 		"data":   "some data",
-	})
+	}, err.JSON())
 
 	err.SetMeta(H{
 		"error":  "custom error",
 		"status": "200",
 		"data":   "some data",
 	})
-	assert.Equal(t, err.JSON(), H{
+	assert.Equal(t, H{
 		"error":  "custom error",
 		"status": "200",
 		"data":   "some data",
-	})
+	}, err.JSON())
 
 	type customError struct {
 		status string
diff --git a/response_writer_test.go b/response_writer_test.go
index cec27338..4289a7c1 100644
--- a/response_writer_test.go
+++ b/response_writer_test.go
@@ -51,7 +51,7 @@ func TestResponseWriterWriteHeader(t *testing.T) {
 	w.WriteHeader(300)
 	assert.False(t, w.Written())
 	assert.Equal(t, 300, w.Status())
-	assert.NotEqual(t, testWritter.Code, 300)
+	assert.NotEqual(t, 300, testWritter.Code)
 
 	w.WriteHeader(-1)
 	assert.Equal(t, 300, w.Status())

From 85221af84cf6ee99dc900bc41912abc09acfc1b5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Rex=20Lee=28=E6=9D=8E=E4=BF=8A=29?= <duguying2008@gmail.com>
Date: Tue, 3 Jul 2018 17:17:08 +0800
Subject: [PATCH 015/105] add json ASCII string render (#1358)

add a json render that rendering json as ASCII string
---
 README.md             | 23 +++++++++++++++++++++++
 context.go            |  6 ++++++
 context_test.go       | 11 +++++++++++
 render/json.go        | 32 ++++++++++++++++++++++++++++++++
 render/render_test.go | 29 +++++++++++++++++++++++++++++
 5 files changed, 101 insertions(+)

diff --git a/README.md b/README.md
index e09a51f2..93896469 100644
--- a/README.md
+++ b/README.md
@@ -900,6 +900,29 @@ func main() {
 }
 ```
 
+#### AsciiJSON
+
+Using AsciiJSON to Generates ASCII-only JSON with escaped non-ASCII chracters.
+
+```go
+func main() {
+	r := gin.Default()
+
+	r.GET("/someJSON", func(c *gin.Context) {
+		data := map[string]interface{}{
+			"lang": "GO语言",
+			"tag":  "<br>",
+		}
+
+		// will output : {"lang":"GO\u8bed\u8a00","tag":"\u003cbr\u003e"}
+		c.AsciiJSON(http.StatusOK, data)
+	})
+
+	// Listen and serve on 0.0.0.0:8080
+	r.Run(":8080")
+}
+```
+
 ### Serving static files
 
 ```go
diff --git a/context.go b/context.go
index 6fc5d25f..d0b4e87f 100644
--- a/context.go
+++ b/context.go
@@ -704,6 +704,12 @@ func (c *Context) JSON(code int, obj interface{}) {
 	c.Render(code, render.JSON{Data: obj})
 }
 
+// AsciiJSON serializes the given struct as JSON into the response body with unicode to ASCII string.
+// It also sets the Content-Type as "application/json".
+func (c *Context) AsciiJSON(code int, obj interface{}) {
+	c.Render(code, render.AsciiJSON{Data: obj})
+}
+
 // XML serializes the given struct as XML into the response body.
 // It also sets the Content-Type as "application/xml".
 func (c *Context) XML(code int, obj interface{}) {
diff --git a/context_test.go b/context_test.go
index 12e02fa0..6f37682e 100644
--- a/context_test.go
+++ b/context_test.go
@@ -686,6 +686,17 @@ func TestContextRenderNoContentSecureJSON(t *testing.T) {
 	assert.Equal(t, "application/json; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
 
+func TestContextRenderNoContentAsciiJSON(t *testing.T) {
+	w := httptest.NewRecorder()
+	c, _ := CreateTestContext(w)
+
+	c.AsciiJSON(http.StatusNoContent, []string{"lang", "Go语言"})
+
+	assert.Equal(t, http.StatusNoContent, w.Code)
+	assert.Empty(t, w.Body.String())
+	assert.Equal(t, "application/json", w.HeaderMap.Get("Content-Type"))
+}
+
 // Tests that the response executes the templates
 // and responds with Content-Type set to text/html
 func TestContextRenderHTML(t *testing.T) {
diff --git a/render/json.go b/render/json.go
index 3a2e8b2f..6e5089a0 100755
--- a/render/json.go
+++ b/render/json.go
@@ -6,6 +6,7 @@ package render
 
 import (
 	"bytes"
+	"fmt"
 	"html/template"
 	"net/http"
 
@@ -30,10 +31,15 @@ type JsonpJSON struct {
 	Data     interface{}
 }
 
+type AsciiJSON struct {
+	Data interface{}
+}
+
 type SecureJSONPrefix string
 
 var jsonContentType = []string{"application/json; charset=utf-8"}
 var jsonpContentType = []string{"application/javascript; charset=utf-8"}
+var jsonAsciiContentType = []string{"application/json"}
 
 func (r JSON) Render(w http.ResponseWriter) (err error) {
 	if err = WriteJSON(w, r.Data); err != nil {
@@ -112,3 +118,29 @@ func (r JsonpJSON) Render(w http.ResponseWriter) (err error) {
 func (r JsonpJSON) WriteContentType(w http.ResponseWriter) {
 	writeContentType(w, jsonpContentType)
 }
+
+func (r AsciiJSON) Render(w http.ResponseWriter) (err error) {
+	r.WriteContentType(w)
+	ret, err := json.Marshal(r.Data)
+	if err != nil {
+		return err
+	}
+
+	var buffer bytes.Buffer
+	for _, r := range string(ret) {
+		cvt := ""
+		if r < 128 {
+			cvt = string(r)
+		} else {
+			cvt = fmt.Sprintf("\\u%04x", int64(r))
+		}
+		buffer.WriteString(cvt)
+	}
+
+	w.Write(buffer.Bytes())
+	return nil
+}
+
+func (r AsciiJSON) WriteContentType(w http.ResponseWriter) {
+	writeContentType(w, jsonAsciiContentType)
+}
diff --git a/render/render_test.go b/render/render_test.go
index 40ec806e..2f728441 100755
--- a/render/render_test.go
+++ b/render/render_test.go
@@ -167,6 +167,35 @@ func TestRenderJsonpJSONFail(t *testing.T) {
 	assert.Error(t, err)
 }
 
+func TestRenderAsciiJSON(t *testing.T) {
+	w1 := httptest.NewRecorder()
+	data1 := map[string]interface{}{
+		"lang": "GO语言",
+		"tag":  "<br>",
+	}
+
+	err := (AsciiJSON{data1}).Render(w1)
+
+	assert.NoError(t, err)
+	assert.Equal(t, "{\"lang\":\"GO\\u8bed\\u8a00\",\"tag\":\"\\u003cbr\\u003e\"}", w1.Body.String())
+	assert.Equal(t, "application/json", w1.Header().Get("Content-Type"))
+
+	w2 := httptest.NewRecorder()
+	data2 := float64(3.1415926)
+
+	err = (AsciiJSON{data2}).Render(w2)
+	assert.NoError(t, err)
+	assert.Equal(t, "3.1415926", w2.Body.String())
+}
+
+func TestRenderAsciiJSONFail(t *testing.T) {
+	w := httptest.NewRecorder()
+	data := make(chan int)
+
+	// json: unsupported type: chan int
+	assert.Error(t, (AsciiJSON{data}).Render(w))
+}
+
 type xmlmap map[string]interface{}
 
 // Allows type H to be used with xml.Marshal

From 220e8d34538f5dfdcc299dda79bf83cf52e633f6 Mon Sep 17 00:00:00 2001
From: solos <lxl1217@gmail.com>
Date: Sat, 21 Jul 2018 00:52:55 +0800
Subject: [PATCH 016/105] return json if jsonp has not callback (#1438)

return json if jsonp has not callback
---
 context.go      |  7 ++++++-
 context_test.go | 14 ++++++++++++++
 2 files changed, 20 insertions(+), 1 deletion(-)

diff --git a/context.go b/context.go
index d0b4e87f..720c4251 100644
--- a/context.go
+++ b/context.go
@@ -695,7 +695,12 @@ func (c *Context) SecureJSON(code int, obj interface{}) {
 // It add padding to response body to request data from a server residing in a different domain than the client.
 // It also sets the Content-Type as "application/javascript".
 func (c *Context) JSONP(code int, obj interface{}) {
-	c.Render(code, render.JsonpJSON{Callback: c.DefaultQuery("callback", ""), Data: obj})
+	callback := c.DefaultQuery("callback", "")
+	if callback == "" {
+		c.Render(code, render.JSON{Data: obj})
+	} else {
+		c.Render(code, render.JsonpJSON{Callback: callback, Data: obj})
+	}
 }
 
 // JSON serializes the given struct as JSON into the response body.
diff --git a/context_test.go b/context_test.go
index 6f37682e..e29569fd 100644
--- a/context_test.go
+++ b/context_test.go
@@ -596,6 +596,20 @@ func TestContextRenderJSONP(t *testing.T) {
 	assert.Equal(t, "application/javascript; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
 
+// Tests that the response is serialized as JSONP
+// and Content-Type is set to application/json
+func TestContextRenderJSONPWithoutCallback(t *testing.T) {
+	w := httptest.NewRecorder()
+	c, _ := CreateTestContext(w)
+	c.Request, _ = http.NewRequest("GET", "http://example.com", nil)
+
+	c.JSONP(201, H{"foo": "bar"})
+
+	assert.Equal(t, 201, w.Code)
+	assert.Equal(t, "{\"foo\":\"bar\"}", w.Body.String())
+	assert.Equal(t, "application/json; charset=utf-8", w.HeaderMap.Get("Content-Type"))
+}
+
 // Tests that no JSON is rendered if code is 204
 func TestContextRenderNoContentJSON(t *testing.T) {
 	w := httptest.NewRecorder()

From 631cfbd1ef2374f5a01f5d17ed8c8f08779ad6fe Mon Sep 17 00:00:00 2001
From: Dmitry Dorogin <dmirogin@ya.ru>
Date: Sun, 5 Aug 2018 08:29:26 +0300
Subject: [PATCH 017/105] Simplify context error (#1431)

Hello!

Looking through context package and found a little bit complicated switch block. And tried to make it easier.

Thanks!
---
 context.go   | 9 ++++-----
 ginS/gins.go | 2 +-
 2 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/context.go b/context.go
index 720c4251..779484b1 100644
--- a/context.go
+++ b/context.go
@@ -159,16 +159,15 @@ func (c *Context) Error(err error) *Error {
 	if err == nil {
 		panic("err is nil")
 	}
-	var parsedError *Error
-	switch err.(type) {
-	case *Error:
-		parsedError = err.(*Error)
-	default:
+
+	parsedError, ok := err.(*Error)
+	if !ok {
 		parsedError = &Error{
 			Err:  err,
 			Type: ErrorTypePrivate,
 		}
 	}
+
 	c.Errors = append(c.Errors, parsedError)
 	return parsedError
 }
diff --git a/ginS/gins.go b/ginS/gins.go
index ee00b381..a7686f23 100644
--- a/ginS/gins.go
+++ b/ginS/gins.go
@@ -128,7 +128,7 @@ func Run(addr ...string) (err error) {
 // RunTLS : The router is attached to a http.Server and starts listening and serving HTTPS requests.
 // It is a shortcut for http.ListenAndServeTLS(addr, certFile, keyFile, router)
 // Note: this method will block the calling goroutine undefinitelly unless an error happens.
-func RunTLS(addr string, certFile string, keyFile string) (err error) {
+func RunTLS(addr, certFile, keyFile string) (err error) {
 	return engine().RunTLS(addr, certFile, keyFile)
 }
 

From 647535cd9b780b6ccbeccfedfba36896e1a1da37 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Mon, 6 Aug 2018 12:07:11 +0800
Subject: [PATCH 018/105] Support map as query string or post form parameters
 (#1383)

* support query map

* add GetQueryMap and unittest

* support post-form map

* add readme for query map

* attempt to fix bug for post-form map when go version is 1.6

* remove duplicate code

* remove comment
---
 README.md       | 29 +++++++++++++++++++++++++++++
 context.go      | 48 ++++++++++++++++++++++++++++++++++++++++++++++++
 context_test.go | 45 ++++++++++++++++++++++++++++++++++++++++++++-
 3 files changed, 121 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 93896469..11c91c9a 100644
--- a/README.md
+++ b/README.md
@@ -27,6 +27,7 @@ Gin is a web framework written in Go (Golang). It features a martini-like API wi
     - [Querystring parameters](#querystring-parameters)
     - [Multipart/Urlencoded Form](#multiparturlencoded-form)
     - [Another example: query + post form](#another-example-query--post-form)
+    - [Map as querystring or postform parameters](#map-as-querystring-or-postform-parameters)
     - [Upload files](#upload-files)
     - [Grouping routes](#grouping-routes)
     - [Blank Gin without middleware by default](#blank-gin-without-middleware-by-default)
@@ -323,6 +324,34 @@ func main() {
 id: 1234; page: 1; name: manu; message: this_is_great
 ```
 
+### Map as querystring or postform parameters
+
+```
+POST /post?ids[a]=1234&ids[b]=hello HTTP/1.1
+Content-Type: application/x-www-form-urlencoded
+
+names[first]=thinkerou&names[second]=tianou
+```
+
+```go
+func main() {
+	router := gin.Default()
+
+	router.POST("/post", func(c *gin.Context) {
+
+		ids := c.QueryMap("ids")
+		names := c.PostFormMap("names")
+
+		fmt.Printf("ids: %v; names: %v", ids, names)
+	})
+	router.Run(":8080")
+}
+```
+
+```
+ids: map[b:hello a:1234], names: map[second:tianou first:thinkerou]
+```
+
 ### Upload files
 
 #### Single file
diff --git a/context.go b/context.go
index 779484b1..724ded79 100644
--- a/context.go
+++ b/context.go
@@ -360,6 +360,18 @@ func (c *Context) GetQueryArray(key string) ([]string, bool) {
 	return []string{}, false
 }
 
+// QueryMap returns a map for a given query key.
+func (c *Context) QueryMap(key string) map[string]string {
+	dicts, _ := c.GetQueryMap(key)
+	return dicts
+}
+
+// GetQueryMap returns a map for a given query key, plus a boolean value
+// whether at least one value exists for the given key.
+func (c *Context) GetQueryMap(key string) (map[string]string, bool) {
+	return c.get(c.Request.URL.Query(), key)
+}
+
 // PostForm returns the specified key from a POST urlencoded form or multipart form
 // when it exists, otherwise it returns an empty string `("")`.
 func (c *Context) PostForm(key string) string {
@@ -415,6 +427,42 @@ func (c *Context) GetPostFormArray(key string) ([]string, bool) {
 	return []string{}, false
 }
 
+// PostFormMap returns a map for a given form key.
+func (c *Context) PostFormMap(key string) map[string]string {
+	dicts, _ := c.GetPostFormMap(key)
+	return dicts
+}
+
+// GetPostFormMap returns a map for a given form key, plus a boolean value
+// whether at least one value exists for the given key.
+func (c *Context) GetPostFormMap(key string) (map[string]string, bool) {
+	req := c.Request
+	req.ParseForm()
+	req.ParseMultipartForm(c.engine.MaxMultipartMemory)
+	dicts, exist := c.get(req.PostForm, key)
+
+	if !exist && req.MultipartForm != nil && req.MultipartForm.File != nil {
+		dicts, exist = c.get(req.MultipartForm.Value, key)
+	}
+
+	return dicts, exist
+}
+
+// get is an internal method and returns a map which satisfy conditions.
+func (c *Context) get(m map[string][]string, key string) (map[string]string, bool) {
+	dicts := make(map[string]string)
+	exist := false
+	for k, v := range m {
+		if i := strings.IndexByte(k, '['); i >= 1 && k[0:i] == key {
+			if j := strings.IndexByte(k[i+1:], ']'); j >= 1 {
+				exist = true
+				dicts[k[i+1:][:j]] = v[0]
+			}
+		}
+	}
+	return dicts, exist
+}
+
 // FormFile returns the first file for the provided form key.
 func (c *Context) FormFile(name string) (*multipart.FileHeader, error) {
 	_, fh, err := c.Request.FormFile(name)
diff --git a/context_test.go b/context_test.go
index e29569fd..589ab336 100644
--- a/context_test.go
+++ b/context_test.go
@@ -47,6 +47,8 @@ func createMultipartRequest() *http.Request {
 	must(mw.WriteField("time_local", "31/12/2016 14:55"))
 	must(mw.WriteField("time_utc", "31/12/2016 14:55"))
 	must(mw.WriteField("time_location", "31/12/2016 14:55"))
+	must(mw.WriteField("names[a]", "thinkerou"))
+	must(mw.WriteField("names[b]", "tianou"))
 	req, err := http.NewRequest("POST", "/", body)
 	must(err)
 	req.Header.Set("Content-Type", MIMEMultipartPOSTForm+"; boundary="+boundary)
@@ -371,7 +373,8 @@ func TestContextQuery(t *testing.T) {
 func TestContextQueryAndPostForm(t *testing.T) {
 	c, _ := CreateTestContext(httptest.NewRecorder())
 	body := bytes.NewBufferString("foo=bar&page=11&both=&foo=second")
-	c.Request, _ = http.NewRequest("POST", "/?both=GET&id=main&id=omit&array[]=first&array[]=second", body)
+	c.Request, _ = http.NewRequest("POST",
+		"/?both=GET&id=main&id=omit&array[]=first&array[]=second&ids[a]=hi&ids[b]=3.14", body)
 	c.Request.Header.Add("Content-Type", MIMEPOSTForm)
 
 	assert.Equal(t, "bar", c.DefaultPostForm("foo", "none"))
@@ -439,6 +442,30 @@ func TestContextQueryAndPostForm(t *testing.T) {
 	values = c.QueryArray("both")
 	assert.Equal(t, 1, len(values))
 	assert.Equal(t, "GET", values[0])
+
+	dicts, ok := c.GetQueryMap("ids")
+	assert.True(t, ok)
+	assert.Equal(t, "hi", dicts["a"])
+	assert.Equal(t, "3.14", dicts["b"])
+
+	dicts, ok = c.GetQueryMap("nokey")
+	assert.False(t, ok)
+	assert.Equal(t, 0, len(dicts))
+
+	dicts, ok = c.GetQueryMap("both")
+	assert.False(t, ok)
+	assert.Equal(t, 0, len(dicts))
+
+	dicts, ok = c.GetQueryMap("array")
+	assert.False(t, ok)
+	assert.Equal(t, 0, len(dicts))
+
+	dicts = c.QueryMap("ids")
+	assert.Equal(t, "hi", dicts["a"])
+	assert.Equal(t, "3.14", dicts["b"])
+
+	dicts = c.QueryMap("nokey")
+	assert.Equal(t, 0, len(dicts))
 }
 
 func TestContextPostFormMultipart(t *testing.T) {
@@ -515,6 +542,22 @@ func TestContextPostFormMultipart(t *testing.T) {
 	values = c.PostFormArray("foo")
 	assert.Equal(t, 1, len(values))
 	assert.Equal(t, "bar", values[0])
+
+	dicts, ok := c.GetPostFormMap("names")
+	assert.True(t, ok)
+	assert.Equal(t, "thinkerou", dicts["a"])
+	assert.Equal(t, "tianou", dicts["b"])
+
+	dicts, ok = c.GetPostFormMap("nokey")
+	assert.False(t, ok)
+	assert.Equal(t, 0, len(dicts))
+
+	dicts = c.PostFormMap("names")
+	assert.Equal(t, "thinkerou", dicts["a"])
+	assert.Equal(t, "tianou", dicts["b"])
+
+	dicts = c.PostFormMap("nokey")
+	assert.Equal(t, 0, len(dicts))
 }
 
 func TestContextSetCookie(t *testing.T) {

From e2b4cf6e2dffb4e59f95f96b78e25e65f9037dec Mon Sep 17 00:00:00 2001
From: grapeVine <treeui.old@gmail.com>
Date: Mon, 6 Aug 2018 23:08:01 +0800
Subject: [PATCH 019/105] interface implement type check (#1459)

interface implement type check
---
 render/render.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/render/render.go b/render/render.go
index 7caf9bba..4ff1c7b6 100755
--- a/render/render.go
+++ b/render/render.go
@@ -26,6 +26,7 @@ var (
 	_ Render     = YAML{}
 	_ Render     = MsgPack{}
 	_ Render     = Reader{}
+	_ Render     = AsciiJSON{}
 )
 
 func writeContentType(w http.ResponseWriter, value []string) {

From 9b7e7bdce6e073d47635d57fbacfb3205cb3127e Mon Sep 17 00:00:00 2001
From: Dmitry Dorogin <dmirogin@ya.ru>
Date: Tue, 7 Aug 2018 01:44:32 +0300
Subject: [PATCH 020/105] Add tests for context.Stream (#1433)

---
 context_test.go | 36 ++++++++++++++++++++++++++++++++++++
 test_helpers.go | 21 +++++++++++++++++++++
 2 files changed, 57 insertions(+)

diff --git a/context_test.go b/context_test.go
index 589ab336..40ae5bf8 100644
--- a/context_test.go
+++ b/context_test.go
@@ -21,6 +21,7 @@ import (
 	"github.com/gin-gonic/gin/binding"
 	"github.com/stretchr/testify/assert"
 	"golang.org/x/net/context"
+	"io"
 )
 
 var _ context.Context = &Context{}
@@ -1558,3 +1559,38 @@ func TestContextRenderDataFromReader(t *testing.T) {
 	assert.Equal(t, fmt.Sprintf("%d", contentLength), w.HeaderMap.Get("Content-Length"))
 	assert.Equal(t, extraHeaders["Content-Disposition"], w.HeaderMap.Get("Content-Disposition"))
 }
+
+func TestContextStream(t *testing.T) {
+	w := CreateTestResponseRecorder()
+	c, _ := CreateTestContext(w)
+
+	stopStream := true
+	c.Stream(func(w io.Writer) bool {
+		defer func() {
+			stopStream = false
+		}()
+
+		w.Write([]byte("test"))
+
+		return stopStream
+	})
+
+	assert.Equal(t, "testtest", w.Body.String())
+}
+
+func TestContextStreamWithClientGone(t *testing.T) {
+	w := CreateTestResponseRecorder()
+	c, _ := CreateTestContext(w)
+
+	c.Stream(func(writer io.Writer) bool {
+		defer func() {
+			w.closeClient()
+		}()
+
+		writer.Write([]byte("test"))
+
+		return true
+	})
+
+	assert.Equal(t, "test", w.Body.String())
+}
diff --git a/test_helpers.go b/test_helpers.go
index 2aed37f2..554568d9 100644
--- a/test_helpers.go
+++ b/test_helpers.go
@@ -6,6 +6,7 @@ package gin
 
 import (
 	"net/http"
+	"net/http/httptest"
 )
 
 // CreateTestContext returns a fresh engine and context for testing purposes
@@ -16,3 +17,23 @@ func CreateTestContext(w http.ResponseWriter) (c *Context, r *Engine) {
 	c.writermem.reset(w)
 	return
 }
+
+type TestResponseRecorder struct {
+	*httptest.ResponseRecorder
+	closeChannel chan bool
+}
+
+func (r *TestResponseRecorder) CloseNotify() <-chan bool {
+	return r.closeChannel
+}
+
+func (r *TestResponseRecorder) closeClient() {
+	r.closeChannel <- true
+}
+
+func CreateTestResponseRecorder() *TestResponseRecorder {
+	return &TestResponseRecorder{
+		httptest.NewRecorder(),
+		make(chan bool, 1),
+	}
+}

From 0552c3bc3a6de6b802684b024ae49c3195cc70dd Mon Sep 17 00:00:00 2001
From: zhanweidu <zhanweidu@163.com>
Date: Tue, 7 Aug 2018 12:41:28 +0800
Subject: [PATCH 021/105] flush operation will overwrite the origin status code
 (#1460)

The status of responseWriter will be overwrite if flush was called. This is caused by the Flush of http.response.Flush().
---
 response_writer.go      |  1 +
 response_writer_test.go | 16 ++++++++++++++++
 2 files changed, 17 insertions(+)

diff --git a/response_writer.go b/response_writer.go
index 166ae8c3..923b53f8 100644
--- a/response_writer.go
+++ b/response_writer.go
@@ -110,5 +110,6 @@ func (w *responseWriter) CloseNotify() <-chan bool {
 
 // Flush implements the http.Flush interface.
 func (w *responseWriter) Flush() {
+	w.WriteHeaderNow()
 	w.ResponseWriter.(http.Flusher).Flush()
 }
diff --git a/response_writer_test.go b/response_writer_test.go
index 4289a7c1..fcc48b3b 100644
--- a/response_writer_test.go
+++ b/response_writer_test.go
@@ -113,3 +113,19 @@ func TestResponseWriterHijack(t *testing.T) {
 
 	w.Flush()
 }
+
+func TestResponseWriterFlush(t *testing.T) {
+	testServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		writer := &responseWriter{}
+		writer.reset(w)
+
+		writer.WriteHeader(http.StatusInternalServerError)
+		writer.Flush()
+	}))
+	defer testServer.Close()
+
+	// should return 500
+	resp, err := http.Get(testServer.URL)
+	assert.NoError(t, err)
+	assert.Equal(t, http.StatusInternalServerError, resp.StatusCode)
+}

From 9666ba67383f6cc7bed3bb18691c2382717d51ae Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Tue, 7 Aug 2018 13:49:31 +0800
Subject: [PATCH 022/105] chore: update top bar header (#1461)

---
 README.md | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/README.md b/README.md
index 11c91c9a..c2cfe2d0 100644
--- a/README.md
+++ b/README.md
@@ -3,10 +3,11 @@
 <img align="right" width="159px" src="https://raw.githubusercontent.com/gin-gonic/logo/master/color.png">
 
 [![Build Status](https://travis-ci.org/gin-gonic/gin.svg)](https://travis-ci.org/gin-gonic/gin)
- [![codecov](https://codecov.io/gh/gin-gonic/gin/branch/master/graph/badge.svg)](https://codecov.io/gh/gin-gonic/gin)
- [![Go Report Card](https://goreportcard.com/badge/github.com/gin-gonic/gin)](https://goreportcard.com/report/github.com/gin-gonic/gin)
- [![GoDoc](https://godoc.org/github.com/gin-gonic/gin?status.svg)](https://godoc.org/github.com/gin-gonic/gin)
- [![Join the chat at https://gitter.im/gin-gonic/gin](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/gin-gonic/gin?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![codecov](https://codecov.io/gh/gin-gonic/gin/branch/master/graph/badge.svg)](https://codecov.io/gh/gin-gonic/gin)
+[![Go Report Card](https://goreportcard.com/badge/github.com/gin-gonic/gin)](https://goreportcard.com/report/github.com/gin-gonic/gin)
+[![GoDoc](https://godoc.org/github.com/gin-gonic/gin?status.svg)](https://godoc.org/github.com/gin-gonic/gin)
+[![Join the chat at https://gitter.im/gin-gonic/gin](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/gin-gonic/gin?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![Sourcegraph](https://sourcegraph.com/github.com/gin-gonic/gin/-/badge.svg)](https://sourcegraph.com/github.com/gin-gonic/gin?badge)
 [![Open Source Helpers](https://www.codetriage.com/gin-gonic/gin/badges/users.svg)](https://www.codetriage.com/gin-gonic/gin)
 
 Gin is a web framework written in Go (Golang). It features a martini-like API with much better performance, up to 40 times faster thanks to [httprouter](https://github.com/julienschmidt/httprouter). If you need performance and good productivity, you will love Gin.
@@ -1811,7 +1812,7 @@ func TestPingRoute(t *testing.T) {
 }
 ```
 
-## Users  [![Sourcegraph](https://sourcegraph.com/github.com/gin-gonic/gin/-/badge.svg)](https://sourcegraph.com/github.com/gin-gonic/gin?badge)
+## Users
 
 Awesome project lists using [Gin](https://github.com/gin-gonic/gin) web framework.
 

From 1f1bc429ed7a4d591a7374f0e267b59747b177bd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Thu, 9 Aug 2018 17:20:06 +0800
Subject: [PATCH 023/105] chore: add test case for source/function of
 recovery.go (#1467)

---
 recovery_test.go | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/recovery_test.go b/recovery_test.go
index de3b62a5..fa065b13 100644
--- a/recovery_test.go
+++ b/recovery_test.go
@@ -41,3 +41,23 @@ func TestPanicWithAbort(t *testing.T) {
 	// TEST
 	assert.Equal(t, 400, w.Code)
 }
+
+func TestSource(t *testing.T) {
+	bs := source(nil, 0)
+	assert.Equal(t, []byte("???"), bs)
+
+	in := [][]byte{
+		[]byte("Hello world."),
+		[]byte("Hi, gin.."),
+	}
+	bs = source(in, 10)
+	assert.Equal(t, []byte("???"), bs)
+
+	bs = source(in, 1)
+	assert.Equal(t, []byte("Hello world."), bs)
+}
+
+func TestFunction(t *testing.T) {
+	bs := function(1)
+	assert.Equal(t, []byte("???"), bs)
+}

From 8fc8ce047243dbbbc5eb3d01b9fd026fc3b08c82 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Fri, 10 Aug 2018 20:50:23 +0800
Subject: [PATCH 024/105] small enhance for cleanPath (#1469)

from httprouter patch: https://github.com/julienschmidt/httprouter/pull/243
---
 path.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/path.go b/path.go
index 1c2b8498..d1f59622 100644
--- a/path.go
+++ b/path.go
@@ -59,11 +59,11 @@ func cleanPath(p string) string {
 
 		case p[r] == '.' && p[r+1] == '/':
 			// . element
-			r++
+			r += 2
 
 		case p[r] == '.' && p[r+1] == '.' && (r+2 == n || p[r+2] == '/'):
 			// .. element: remove to last /
-			r += 2
+			r += 3
 
 			if w > 1 {
 				// can backtrack

From 7e64d32269d817b645d5d4694100a8a8ad6960cb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Sun, 12 Aug 2018 10:12:33 +0800
Subject: [PATCH 025/105] Attempt to fix #1462 (#1463)

#1462
---
 context_test.go | 20 ++++++++++++++++++++
 test_helpers.go | 25 +------------------------
 2 files changed, 21 insertions(+), 24 deletions(-)

diff --git a/context_test.go b/context_test.go
index 40ae5bf8..0185507f 100644
--- a/context_test.go
+++ b/context_test.go
@@ -1560,6 +1560,26 @@ func TestContextRenderDataFromReader(t *testing.T) {
 	assert.Equal(t, extraHeaders["Content-Disposition"], w.HeaderMap.Get("Content-Disposition"))
 }
 
+type TestResponseRecorder struct {
+	*httptest.ResponseRecorder
+	closeChannel chan bool
+}
+
+func (r *TestResponseRecorder) CloseNotify() <-chan bool {
+	return r.closeChannel
+}
+
+func (r *TestResponseRecorder) closeClient() {
+	r.closeChannel <- true
+}
+
+func CreateTestResponseRecorder() *TestResponseRecorder {
+	return &TestResponseRecorder{
+		httptest.NewRecorder(),
+		make(chan bool, 1),
+	}
+}
+
 func TestContextStream(t *testing.T) {
 	w := CreateTestResponseRecorder()
 	c, _ := CreateTestContext(w)
diff --git a/test_helpers.go b/test_helpers.go
index 554568d9..3a7a5ddf 100644
--- a/test_helpers.go
+++ b/test_helpers.go
@@ -4,10 +4,7 @@
 
 package gin
 
-import (
-	"net/http"
-	"net/http/httptest"
-)
+import "net/http"
 
 // CreateTestContext returns a fresh engine and context for testing purposes
 func CreateTestContext(w http.ResponseWriter) (c *Context, r *Engine) {
@@ -17,23 +14,3 @@ func CreateTestContext(w http.ResponseWriter) (c *Context, r *Engine) {
 	c.writermem.reset(w)
 	return
 }
-
-type TestResponseRecorder struct {
-	*httptest.ResponseRecorder
-	closeChannel chan bool
-}
-
-func (r *TestResponseRecorder) CloseNotify() <-chan bool {
-	return r.closeChannel
-}
-
-func (r *TestResponseRecorder) closeClient() {
-	r.closeChannel <- true
-}
-
-func CreateTestResponseRecorder() *TestResponseRecorder {
-	return &TestResponseRecorder{
-		httptest.NewRecorder(),
-		make(chan bool, 1),
-	}
-}

From e5bb4f62a284426de199d68d71900fcbd1285691 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Sun, 12 Aug 2018 21:17:57 +0800
Subject: [PATCH 026/105] chore: add return or remove else for reduce indent
 (#1470)

---
 gin.go         | 69 ++++++++++++++++++++++++++------------------------
 routes_test.go | 10 ++++++++
 2 files changed, 46 insertions(+), 33 deletions(-)

diff --git a/gin.go b/gin.go
index 3ee8018d..fc4d6564 100644
--- a/gin.go
+++ b/gin.go
@@ -349,38 +349,40 @@ func (engine *Engine) handleHTTPRequest(c *Context) {
 	// Find root of the tree for the given HTTP method
 	t := engine.trees
 	for i, tl := 0, len(t); i < tl; i++ {
-		if t[i].method == httpMethod {
-			root := t[i].root
-			// Find route in tree
-			handlers, params, tsr := root.getValue(path, c.Params, unescape)
-			if handlers != nil {
-				c.handlers = handlers
-				c.Params = params
-				c.Next()
-				c.writermem.WriteHeaderNow()
+		if t[i].method != httpMethod {
+			continue
+		}
+		root := t[i].root
+		// Find route in tree
+		handlers, params, tsr := root.getValue(path, c.Params, unescape)
+		if handlers != nil {
+			c.handlers = handlers
+			c.Params = params
+			c.Next()
+			c.writermem.WriteHeaderNow()
+			return
+		}
+		if httpMethod != "CONNECT" && path != "/" {
+			if tsr && engine.RedirectTrailingSlash {
+				redirectTrailingSlash(c)
 				return
 			}
-			if httpMethod != "CONNECT" && path != "/" {
-				if tsr && engine.RedirectTrailingSlash {
-					redirectTrailingSlash(c)
-					return
-				}
-				if engine.RedirectFixedPath && redirectFixedPath(c, root, engine.RedirectFixedPath) {
-					return
-				}
+			if engine.RedirectFixedPath && redirectFixedPath(c, root, engine.RedirectFixedPath) {
+				return
 			}
-			break
 		}
+		break
 	}
 
 	if engine.HandleMethodNotAllowed {
 		for _, tree := range engine.trees {
-			if tree.method != httpMethod {
-				if handlers, _, _ := tree.root.getValue(path, nil, unescape); handlers != nil {
-					c.handlers = engine.allNoMethod
-					serveError(c, http.StatusMethodNotAllowed, default405Body)
-					return
-				}
+			if tree.method == httpMethod {
+				continue
+			}
+			if handlers, _, _ := tree.root.getValue(path, nil, unescape); handlers != nil {
+				c.handlers = engine.allNoMethod
+				serveError(c, http.StatusMethodNotAllowed, default405Body)
+				return
 			}
 		}
 	}
@@ -393,14 +395,16 @@ var mimePlain = []string{MIMEPlain}
 func serveError(c *Context, code int, defaultMessage []byte) {
 	c.writermem.status = code
 	c.Next()
-	if !c.writermem.Written() {
-		if c.writermem.Status() == code {
-			c.writermem.Header()["Content-Type"] = mimePlain
-			c.Writer.Write(defaultMessage)
-		} else {
-			c.writermem.WriteHeaderNow()
-		}
+	if c.writermem.Written() {
+		return
 	}
+	if c.writermem.Status() == code {
+		c.writermem.Header()["Content-Type"] = mimePlain
+		c.Writer.Write(defaultMessage)
+		return
+	}
+	c.writermem.WriteHeaderNow()
+	return
 }
 
 func redirectTrailingSlash(c *Context) {
@@ -411,10 +415,9 @@ func redirectTrailingSlash(c *Context) {
 		code = http.StatusTemporaryRedirect
 	}
 
+	req.URL.Path = path + "/"
 	if length := len(path); length > 1 && path[length-1] == '/' {
 		req.URL.Path = path[:length-1]
-	} else {
-		req.URL.Path = path + "/"
 	}
 	debugPrint("redirecting request %d: %s --> %s", code, path, req.URL.String())
 	http.Redirect(c.Writer, req, req.URL.String(), code)
diff --git a/routes_test.go b/routes_test.go
index 81293907..a2389f9b 100644
--- a/routes_test.go
+++ b/routes_test.go
@@ -333,6 +333,16 @@ func TestRouteNotAllowedEnabled(t *testing.T) {
 	assert.Equal(t, http.StatusTeapot, w.Code)
 }
 
+func TestRouteNotAllowedEnabled2(t *testing.T) {
+	router := New()
+	router.HandleMethodNotAllowed = true
+	// add one methodTree to trees
+	router.addRoute("POST", "/", HandlersChain{func(_ *Context) {}})
+	router.GET("/path2", func(c *Context) {})
+	w := performRequest(router, "POST", "/path2")
+	assert.Equal(t, http.StatusMethodNotAllowed, w.Code)
+}
+
 func TestRouteNotAllowedDisabled(t *testing.T) {
 	router := New()
 	router.HandleMethodNotAllowed = false

From 202db4fb117768795c0fcc909cc9c3d75b9172b7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Sun, 12 Aug 2018 21:38:07 +0800
Subject: [PATCH 027/105] improve utils code coverage (#1473)

---
 utils_test.go | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/utils_test.go b/utils_test.go
index 3d019e7e..95b5de5e 100644
--- a/utils_test.go
+++ b/utils_test.go
@@ -5,6 +5,8 @@
 package gin
 
 import (
+	"bytes"
+	"encoding/xml"
 	"fmt"
 	"net/http"
 	"testing"
@@ -124,3 +126,14 @@ func TestBindMiddleware(t *testing.T) {
 		Bind(&bindTestStruct{})
 	})
 }
+
+func TestMarshalXMLforH(t *testing.T) {
+	h := H{
+		"": "test",
+	}
+	var b bytes.Buffer
+	enc := xml.NewEncoder(&b)
+	var x xml.StartElement
+	e := h.MarshalXML(enc, x)
+	assert.Error(t, e)
+}

From 1ae32f3a2cfa53d1ae3e5c10a72841673bedc449 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Sun, 12 Aug 2018 22:02:37 +0800
Subject: [PATCH 028/105] improve render code coverage (#1474)

all code coverage > 99%
---
 render/render_test.go | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/render/render_test.go b/render/render_test.go
index 2f728441..9e768850 100755
--- a/render/render_test.go
+++ b/render/render_test.go
@@ -158,6 +158,21 @@ func TestRenderJsonpJSON(t *testing.T) {
 	assert.Equal(t, "application/javascript; charset=utf-8", w2.Header().Get("Content-Type"))
 }
 
+func TestRenderJsonpJSONError2(t *testing.T) {
+	w := httptest.NewRecorder()
+	data := map[string]interface{}{
+		"foo": "bar",
+	}
+	(JsonpJSON{"", data}).WriteContentType(w)
+	assert.Equal(t, "application/javascript; charset=utf-8", w.Header().Get("Content-Type"))
+
+	e := (JsonpJSON{"", data}).Render(w)
+	assert.NoError(t, e)
+
+	assert.Equal(t, "{\"foo\":\"bar\"}", w.Body.String())
+	assert.Equal(t, "application/javascript; charset=utf-8", w.Header().Get("Content-Type"))
+}
+
 func TestRenderJsonpJSONFail(t *testing.T) {
 	w := httptest.NewRecorder()
 	data := make(chan int)

From 61592134625e0fca1b2de7c22107a01684e8b130 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Sun, 12 Aug 2018 23:38:31 +0800
Subject: [PATCH 029/105] unify test data (#1417)

mkdir a test data dir.
---
 README.md                                          |  2 +-
 binding/binding_body_test.go                       |  6 +++---
 binding/binding_test.go                            | 14 +++++++-------
 debug_test.go                                      |  2 +-
 examples/template/main.go                          |  2 +-
 gin_test.go                                        |  8 ++++----
 render/render_test.go                              |  4 ++--
 .../testdata => testdata/certificate}/cert.pem     |  0
 .../testdata => testdata/certificate}/key.pem      |  0
 .../example => testdata/protoexample}/test.pb.go   |  6 +++---
 .../example => testdata/protoexample}/test.proto   |  2 +-
 {fixtures/basic => testdata/template}/hello.tmpl   |  0
 {fixtures/basic => testdata/template}/raw.tmpl     |  0
 13 files changed, 23 insertions(+), 23 deletions(-)
 rename {fixtures/testdata => testdata/certificate}/cert.pem (100%)
 rename {fixtures/testdata => testdata/certificate}/key.pem (100%)
 rename {binding/example => testdata/protoexample}/test.pb.go (94%)
 rename {binding/example => testdata/protoexample}/test.proto (90%)
 rename {fixtures/basic => testdata/template}/hello.tmpl (100%)
 rename {fixtures/basic => testdata/template}/raw.tmpl (100%)

diff --git a/README.md b/README.md
index c2cfe2d0..bf1bbb49 100644
--- a/README.md
+++ b/README.md
@@ -1117,7 +1117,7 @@ func main() {
     router.SetFuncMap(template.FuncMap{
         "formatAsDate": formatAsDate,
     })
-    router.LoadHTMLFiles("./fixtures/basic/raw.tmpl")
+    router.LoadHTMLFiles("./testdata/template/raw.tmpl")
 
     router.GET("/raw", func(c *gin.Context) {
         c.HTML(http.StatusOK, "raw.tmpl", map[string]interface{}{
diff --git a/binding/binding_body_test.go b/binding/binding_body_test.go
index c41d9f86..dfd761e1 100644
--- a/binding/binding_body_test.go
+++ b/binding/binding_body_test.go
@@ -5,7 +5,7 @@ import (
 	"io/ioutil"
 	"testing"
 
-	"github.com/gin-gonic/gin/binding/example"
+	"github.com/gin-gonic/gin/testdata/protoexample"
 	"github.com/golang/protobuf/proto"
 	"github.com/stretchr/testify/assert"
 	"github.com/ugorji/go/codec"
@@ -55,12 +55,12 @@ func msgPackBody(t *testing.T) string {
 }
 
 func TestBindingBodyProto(t *testing.T) {
-	test := example.Test{
+	test := protoexample.Test{
 		Label: proto.String("FOO"),
 	}
 	data, _ := proto.Marshal(&test)
 	req := requestWithBody("POST", "/", string(data))
-	form := example.Test{}
+	form := protoexample.Test{}
 	body, _ := ioutil.ReadAll(req.Body)
 	assert.NoError(t, ProtoBuf.BindBody(body, &form))
 	assert.Equal(t, test, form)
diff --git a/binding/binding_test.go b/binding/binding_test.go
index 936deac7..efe87669 100644
--- a/binding/binding_test.go
+++ b/binding/binding_test.go
@@ -14,7 +14,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/gin-gonic/gin/binding/example"
+	"github.com/gin-gonic/gin/testdata/protoexample"
 	"github.com/golang/protobuf/proto"
 	"github.com/stretchr/testify/assert"
 	"github.com/ugorji/go/codec"
@@ -562,7 +562,7 @@ func TestBindingFormMultipartFail(t *testing.T) {
 }
 
 func TestBindingProtoBuf(t *testing.T) {
-	test := &example.Test{
+	test := &protoexample.Test{
 		Label: proto.String("yes"),
 	}
 	data, _ := proto.Marshal(test)
@@ -574,7 +574,7 @@ func TestBindingProtoBuf(t *testing.T) {
 }
 
 func TestBindingProtoBufFail(t *testing.T) {
-	test := &example.Test{
+	test := &protoexample.Test{
 		Label: proto.String("yes"),
 	}
 	data, _ := proto.Marshal(test)
@@ -1156,14 +1156,14 @@ func testBodyBindingFail(t *testing.T, b Binding, name, path, badPath, body, bad
 func testProtoBodyBinding(t *testing.T, b Binding, name, path, badPath, body, badBody string) {
 	assert.Equal(t, name, b.Name())
 
-	obj := example.Test{}
+	obj := protoexample.Test{}
 	req := requestWithBody("POST", path, body)
 	req.Header.Add("Content-Type", MIMEPROTOBUF)
 	err := b.Bind(req, &obj)
 	assert.NoError(t, err)
 	assert.Equal(t, "yes", *obj.Label)
 
-	obj = example.Test{}
+	obj = protoexample.Test{}
 	req = requestWithBody("POST", badPath, badBody)
 	req.Header.Add("Content-Type", MIMEPROTOBUF)
 	err = ProtoBuf.Bind(req, &obj)
@@ -1179,7 +1179,7 @@ func (h hook) Read([]byte) (int, error) {
 func testProtoBodyBindingFail(t *testing.T, b Binding, name, path, badPath, body, badBody string) {
 	assert.Equal(t, name, b.Name())
 
-	obj := example.Test{}
+	obj := protoexample.Test{}
 	req := requestWithBody("POST", path, body)
 
 	req.Body = ioutil.NopCloser(&hook{})
@@ -1187,7 +1187,7 @@ func testProtoBodyBindingFail(t *testing.T, b Binding, name, path, badPath, body
 	err := b.Bind(req, &obj)
 	assert.Error(t, err)
 
-	obj = example.Test{}
+	obj = protoexample.Test{}
 	req = requestWithBody("POST", badPath, badBody)
 	req.Header.Add("Content-Type", MIMEPROTOBUF)
 	err = ProtoBuf.Bind(req, &obj)
diff --git a/debug_test.go b/debug_test.go
index 440173b7..ed5a6a54 100644
--- a/debug_test.go
+++ b/debug_test.go
@@ -72,7 +72,7 @@ func TestDebugPrintLoadTemplate(t *testing.T) {
 	setup(&w)
 	defer teardown()
 
-	templ := template.Must(template.New("").Delims("{[{", "}]}").ParseGlob("./fixtures/basic/hello.tmpl"))
+	templ := template.Must(template.New("").Delims("{[{", "}]}").ParseGlob("./testdata/template/hello.tmpl"))
 	debugPrintLoadTemplate(templ)
 	assert.Regexp(t, `^\[GIN-debug\] Loaded HTML Templates \(2\): \n(\t- \n|\t- hello\.tmpl\n){2}\n`, w.String())
 }
diff --git a/examples/template/main.go b/examples/template/main.go
index f9e611df..e20a3b98 100644
--- a/examples/template/main.go
+++ b/examples/template/main.go
@@ -20,7 +20,7 @@ func main() {
 	router.SetFuncMap(template.FuncMap{
 		"formatAsDate": formatAsDate,
 	})
-	router.LoadHTMLFiles("../../fixtures/basic/raw.tmpl")
+	router.LoadHTMLFiles("../../testdata/template/raw.tmpl")
 
 	router.GET("/raw", func(c *gin.Context) {
 		c.HTML(http.StatusOK, "raw.tmpl", map[string]interface{}{
diff --git a/gin_test.go b/gin_test.go
index 3ac60577..b3cab715 100644
--- a/gin_test.go
+++ b/gin_test.go
@@ -30,7 +30,7 @@ func setupHTMLFiles(t *testing.T, mode string, tls bool) func() {
 		router.SetFuncMap(template.FuncMap{
 			"formatAsDate": formatAsDate,
 		})
-		router.LoadHTMLFiles("./fixtures/basic/hello.tmpl", "./fixtures/basic/raw.tmpl")
+		router.LoadHTMLFiles("./testdata/template/hello.tmpl", "./testdata/template/raw.tmpl")
 		router.GET("/test", func(c *Context) {
 			c.HTML(http.StatusOK, "hello.tmpl", map[string]string{"name": "world"})
 		})
@@ -41,7 +41,7 @@ func setupHTMLFiles(t *testing.T, mode string, tls bool) func() {
 		})
 		if tls {
 			// these files generated by `go run $GOROOT/src/crypto/tls/generate_cert.go --host 127.0.0.1`
-			router.RunTLS(":9999", "./fixtures/testdata/cert.pem", "./fixtures/testdata/key.pem")
+			router.RunTLS(":9999", "./testdata/certificate/cert.pem", "./testdata/certificate/key.pem")
 		} else {
 			router.Run(":8888")
 		}
@@ -59,7 +59,7 @@ func setupHTMLGlob(t *testing.T, mode string, tls bool) func() {
 		router.SetFuncMap(template.FuncMap{
 			"formatAsDate": formatAsDate,
 		})
-		router.LoadHTMLGlob("./fixtures/basic/*")
+		router.LoadHTMLGlob("./testdata/template/*")
 		router.GET("/test", func(c *Context) {
 			c.HTML(http.StatusOK, "hello.tmpl", map[string]string{"name": "world"})
 		})
@@ -70,7 +70,7 @@ func setupHTMLGlob(t *testing.T, mode string, tls bool) func() {
 		})
 		if tls {
 			// these files generated by `go run $GOROOT/src/crypto/tls/generate_cert.go --host 127.0.0.1`
-			router.RunTLS(":9999", "./fixtures/testdata/cert.pem", "./fixtures/testdata/key.pem")
+			router.RunTLS(":9999", "./testdata/certificate/cert.pem", "./testdata/certificate/key.pem")
 		} else {
 			router.Run(":8888")
 		}
diff --git a/render/render_test.go b/render/render_test.go
index 9e768850..8fad12b3 100755
--- a/render/render_test.go
+++ b/render/render_test.go
@@ -388,7 +388,7 @@ func TestRenderHTMLTemplateEmptyName(t *testing.T) {
 
 func TestRenderHTMLDebugFiles(t *testing.T) {
 	w := httptest.NewRecorder()
-	htmlRender := HTMLDebug{Files: []string{"../fixtures/basic/hello.tmpl"},
+	htmlRender := HTMLDebug{Files: []string{"../testdata/template/hello.tmpl"},
 		Glob:    "",
 		Delims:  Delims{Left: "{[{", Right: "}]}"},
 		FuncMap: nil,
@@ -407,7 +407,7 @@ func TestRenderHTMLDebugFiles(t *testing.T) {
 func TestRenderHTMLDebugGlob(t *testing.T) {
 	w := httptest.NewRecorder()
 	htmlRender := HTMLDebug{Files: nil,
-		Glob:    "../fixtures/basic/hello*",
+		Glob:    "../testdata/template/hello*",
 		Delims:  Delims{Left: "{[{", Right: "}]}"},
 		FuncMap: nil,
 	}
diff --git a/fixtures/testdata/cert.pem b/testdata/certificate/cert.pem
similarity index 100%
rename from fixtures/testdata/cert.pem
rename to testdata/certificate/cert.pem
diff --git a/fixtures/testdata/key.pem b/testdata/certificate/key.pem
similarity index 100%
rename from fixtures/testdata/key.pem
rename to testdata/certificate/key.pem
diff --git a/binding/example/test.pb.go b/testdata/protoexample/test.pb.go
similarity index 94%
rename from binding/example/test.pb.go
rename to testdata/protoexample/test.pb.go
index 3de8444f..21997ca1 100644
--- a/binding/example/test.pb.go
+++ b/testdata/protoexample/test.pb.go
@@ -3,7 +3,7 @@
 // DO NOT EDIT!
 
 /*
-Package example is a generated protocol buffer package.
+Package protoexample is a generated protocol buffer package.
 
 It is generated from these files:
 	test.proto
@@ -11,7 +11,7 @@ It is generated from these files:
 It has these top-level messages:
 	Test
 */
-package example
+package protoexample
 
 import proto "github.com/golang/protobuf/proto"
 import math "math"
@@ -109,5 +109,5 @@ func (m *Test_OptionalGroup) GetRequiredField() string {
 }
 
 func init() {
-	proto.RegisterEnum("example.FOO", FOO_name, FOO_value)
+	proto.RegisterEnum("protoexample.FOO", FOO_name, FOO_value)
 }
diff --git a/binding/example/test.proto b/testdata/protoexample/test.proto
similarity index 90%
rename from binding/example/test.proto
rename to testdata/protoexample/test.proto
index 8ee9800a..3e734287 100644
--- a/binding/example/test.proto
+++ b/testdata/protoexample/test.proto
@@ -1,4 +1,4 @@
-package example;
+package protoexample;
 
 enum FOO {X=17;};
 
diff --git a/fixtures/basic/hello.tmpl b/testdata/template/hello.tmpl
similarity index 100%
rename from fixtures/basic/hello.tmpl
rename to testdata/template/hello.tmpl
diff --git a/fixtures/basic/raw.tmpl b/testdata/template/raw.tmpl
similarity index 100%
rename from fixtures/basic/raw.tmpl
rename to testdata/template/raw.tmpl

From 8aef947f6eeeb47872c2e5910d20258cc6ccf375 Mon Sep 17 00:00:00 2001
From: Alex <AWulkan@users.noreply.github.com>
Date: Sun, 12 Aug 2018 22:54:22 +0200
Subject: [PATCH 030/105] docs: remove double negative in README.md (#1480)

"not match neither" means that it will match.
---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index bf1bbb49..28598baf 100644
--- a/README.md
+++ b/README.md
@@ -238,7 +238,7 @@ func main() {
 func main() {
 	router := gin.Default()
 
-	// This handler will match /user/john but will not match neither /user/ or /user
+	// This handler will match /user/john but will not match /user/ or /user
 	router.GET("/user/:name", func(c *gin.Context) {
 		name := c.Param("name")
 		c.String(http.StatusOK, "Hello %s", name)

From f45c928a156e60e521dceea99a183f9c9cf5b2de Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Tue, 14 Aug 2018 09:51:56 +0800
Subject: [PATCH 031/105] chore: use http.Status* instead of hard code (#1482)

---
 auth_test.go                         |  12 +--
 benchmarks_test.go                   |   6 +-
 context_test.go                      | 153 ++++++++++++++-------------
 examples/basic/main.go               |  10 +-
 examples/basic/main_test.go          |   2 +-
 examples/favicon/main.go             |   4 +-
 examples/http2/main.go               |   3 +-
 examples/realtime-advanced/routes.go |  11 +-
 examples/realtime-chat/main.go       |   5 +-
 githubapi_test.go                    |   2 +-
 logger.go                            |   7 +-
 logger_test.go                       |  17 +--
 middleware_test.go                   |  33 +++---
 recovery_test.go                     |   7 +-
 render/redirect.go                   |   2 +
 render/render_test.go                |   4 +-
 response_writer_test.go              |  20 ++--
 routergroup_test.go                  |   7 +-
 routes_test.go                       |  88 +++++++--------
 utils_test.go                        |   8 +-
 20 files changed, 209 insertions(+), 192 deletions(-)

diff --git a/auth_test.go b/auth_test.go
index dc8523b0..ab7e94be 100644
--- a/auth_test.go
+++ b/auth_test.go
@@ -93,7 +93,7 @@ func TestBasicAuthSucceed(t *testing.T) {
 	router := New()
 	router.Use(BasicAuth(accounts))
 	router.GET("/login", func(c *Context) {
-		c.String(200, c.MustGet(AuthUserKey).(string))
+		c.String(http.StatusOK, c.MustGet(AuthUserKey).(string))
 	})
 
 	w := httptest.NewRecorder()
@@ -101,7 +101,7 @@ func TestBasicAuthSucceed(t *testing.T) {
 	req.Header.Set("Authorization", authorizationHeader("admin", "password"))
 	router.ServeHTTP(w, req)
 
-	assert.Equal(t, 200, w.Code)
+	assert.Equal(t, http.StatusOK, w.Code)
 	assert.Equal(t, "admin", w.Body.String())
 }
 
@@ -112,7 +112,7 @@ func TestBasicAuth401(t *testing.T) {
 	router.Use(BasicAuth(accounts))
 	router.GET("/login", func(c *Context) {
 		called = true
-		c.String(200, c.MustGet(AuthUserKey).(string))
+		c.String(http.StatusOK, c.MustGet(AuthUserKey).(string))
 	})
 
 	w := httptest.NewRecorder()
@@ -121,7 +121,7 @@ func TestBasicAuth401(t *testing.T) {
 	router.ServeHTTP(w, req)
 
 	assert.False(t, called)
-	assert.Equal(t, 401, w.Code)
+	assert.Equal(t, http.StatusUnauthorized, w.Code)
 	assert.Equal(t, "Basic realm=\"Authorization Required\"", w.HeaderMap.Get("WWW-Authenticate"))
 }
 
@@ -132,7 +132,7 @@ func TestBasicAuth401WithCustomRealm(t *testing.T) {
 	router.Use(BasicAuthForRealm(accounts, "My Custom \"Realm\""))
 	router.GET("/login", func(c *Context) {
 		called = true
-		c.String(200, c.MustGet(AuthUserKey).(string))
+		c.String(http.StatusOK, c.MustGet(AuthUserKey).(string))
 	})
 
 	w := httptest.NewRecorder()
@@ -141,6 +141,6 @@ func TestBasicAuth401WithCustomRealm(t *testing.T) {
 	router.ServeHTTP(w, req)
 
 	assert.False(t, called)
-	assert.Equal(t, 401, w.Code)
+	assert.Equal(t, http.StatusUnauthorized, w.Code)
 	assert.Equal(t, "Basic realm=\"My Custom \\\"Realm\\\"\"", w.HeaderMap.Get("WWW-Authenticate"))
 }
diff --git a/benchmarks_test.go b/benchmarks_test.go
index e7970034..0b3f82df 100644
--- a/benchmarks_test.go
+++ b/benchmarks_test.go
@@ -54,7 +54,7 @@ func BenchmarkOneRouteJSON(B *testing.B) {
 		Status string `json:"status"`
 	}{"ok"}
 	router.GET("/json", func(c *Context) {
-		c.JSON(200, data)
+		c.JSON(http.StatusOK, data)
 	})
 	runRequest(B, router, "GET", "/json")
 }
@@ -66,7 +66,7 @@ func BenchmarkOneRouteHTML(B *testing.B) {
 	router.SetHTMLTemplate(t)
 
 	router.GET("/html", func(c *Context) {
-		c.HTML(200, "index", "hola")
+		c.HTML(http.StatusOK, "index", "hola")
 	})
 	runRequest(B, router, "GET", "/html")
 }
@@ -82,7 +82,7 @@ func BenchmarkOneRouteSet(B *testing.B) {
 func BenchmarkOneRouteString(B *testing.B) {
 	router := New()
 	router.GET("/text", func(c *Context) {
-		c.String(200, "this is a plain text")
+		c.String(http.StatusOK, "this is a plain text")
 	})
 	runRequest(B, router, "GET", "/text")
 }
diff --git a/context_test.go b/context_test.go
index 0185507f..99d5267d 100644
--- a/context_test.go
+++ b/context_test.go
@@ -9,6 +9,7 @@ import (
 	"errors"
 	"fmt"
 	"html/template"
+	"io"
 	"mime/multipart"
 	"net/http"
 	"net/http/httptest"
@@ -21,7 +22,6 @@ import (
 	"github.com/gin-gonic/gin/binding"
 	"github.com/stretchr/testify/assert"
 	"golang.org/x/net/context"
-	"io"
 )
 
 var _ context.Context = &Context{}
@@ -585,10 +585,11 @@ func TestContextGetCookie(t *testing.T) {
 }
 
 func TestContextBodyAllowedForStatus(t *testing.T) {
+	// todo(thinkerou): go1.6 not support StatusProcessing
 	assert.False(t, false, bodyAllowedForStatus(102))
-	assert.False(t, false, bodyAllowedForStatus(204))
-	assert.False(t, false, bodyAllowedForStatus(304))
-	assert.True(t, true, bodyAllowedForStatus(500))
+	assert.False(t, false, bodyAllowedForStatus(http.StatusNoContent))
+	assert.False(t, false, bodyAllowedForStatus(http.StatusNotModified))
+	assert.True(t, true, bodyAllowedForStatus(http.StatusInternalServerError))
 }
 
 type TestPanicRender struct {
@@ -619,9 +620,9 @@ func TestContextRenderJSON(t *testing.T) {
 	w := httptest.NewRecorder()
 	c, _ := CreateTestContext(w)
 
-	c.JSON(201, H{"foo": "bar"})
+	c.JSON(http.StatusCreated, H{"foo": "bar"})
 
-	assert.Equal(t, 201, w.Code)
+	assert.Equal(t, http.StatusCreated, w.Code)
 	assert.Equal(t, "{\"foo\":\"bar\"}", w.Body.String())
 	assert.Equal(t, "application/json; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
@@ -633,9 +634,9 @@ func TestContextRenderJSONP(t *testing.T) {
 	c, _ := CreateTestContext(w)
 	c.Request, _ = http.NewRequest("GET", "http://example.com/?callback=x", nil)
 
-	c.JSONP(201, H{"foo": "bar"})
+	c.JSONP(http.StatusCreated, H{"foo": "bar"})
 
-	assert.Equal(t, 201, w.Code)
+	assert.Equal(t, http.StatusCreated, w.Code)
 	assert.Equal(t, "x({\"foo\":\"bar\"})", w.Body.String())
 	assert.Equal(t, "application/javascript; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
@@ -647,9 +648,9 @@ func TestContextRenderJSONPWithoutCallback(t *testing.T) {
 	c, _ := CreateTestContext(w)
 	c.Request, _ = http.NewRequest("GET", "http://example.com", nil)
 
-	c.JSONP(201, H{"foo": "bar"})
+	c.JSONP(http.StatusCreated, H{"foo": "bar"})
 
-	assert.Equal(t, 201, w.Code)
+	assert.Equal(t, http.StatusCreated, w.Code)
 	assert.Equal(t, "{\"foo\":\"bar\"}", w.Body.String())
 	assert.Equal(t, "application/json; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
@@ -659,9 +660,9 @@ func TestContextRenderNoContentJSON(t *testing.T) {
 	w := httptest.NewRecorder()
 	c, _ := CreateTestContext(w)
 
-	c.JSON(204, H{"foo": "bar"})
+	c.JSON(http.StatusNoContent, H{"foo": "bar"})
 
-	assert.Equal(t, 204, w.Code)
+	assert.Equal(t, http.StatusNoContent, w.Code)
 	assert.Empty(t, w.Body.String())
 	assert.Equal(t, "application/json; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
@@ -673,9 +674,9 @@ func TestContextRenderAPIJSON(t *testing.T) {
 	c, _ := CreateTestContext(w)
 
 	c.Header("Content-Type", "application/vnd.api+json")
-	c.JSON(201, H{"foo": "bar"})
+	c.JSON(http.StatusCreated, H{"foo": "bar"})
 
-	assert.Equal(t, 201, w.Code)
+	assert.Equal(t, http.StatusCreated, w.Code)
 	assert.Equal(t, "{\"foo\":\"bar\"}", w.Body.String())
 	assert.Equal(t, "application/vnd.api+json", w.HeaderMap.Get("Content-Type"))
 }
@@ -686,9 +687,9 @@ func TestContextRenderNoContentAPIJSON(t *testing.T) {
 	c, _ := CreateTestContext(w)
 
 	c.Header("Content-Type", "application/vnd.api+json")
-	c.JSON(204, H{"foo": "bar"})
+	c.JSON(http.StatusNoContent, H{"foo": "bar"})
 
-	assert.Equal(t, 204, w.Code)
+	assert.Equal(t, http.StatusNoContent, w.Code)
 	assert.Empty(t, w.Body.String())
 	assert.Equal(t, w.HeaderMap.Get("Content-Type"), "application/vnd.api+json")
 }
@@ -699,9 +700,9 @@ func TestContextRenderIndentedJSON(t *testing.T) {
 	w := httptest.NewRecorder()
 	c, _ := CreateTestContext(w)
 
-	c.IndentedJSON(201, H{"foo": "bar", "bar": "foo", "nested": H{"foo": "bar"}})
+	c.IndentedJSON(http.StatusCreated, H{"foo": "bar", "bar": "foo", "nested": H{"foo": "bar"}})
 
-	assert.Equal(t, 201, w.Code)
+	assert.Equal(t, http.StatusCreated, w.Code)
 	assert.Equal(t, "{\n    \"bar\": \"foo\",\n    \"foo\": \"bar\",\n    \"nested\": {\n        \"foo\": \"bar\"\n    }\n}", w.Body.String())
 	assert.Equal(t, "application/json; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
@@ -711,9 +712,9 @@ func TestContextRenderNoContentIndentedJSON(t *testing.T) {
 	w := httptest.NewRecorder()
 	c, _ := CreateTestContext(w)
 
-	c.IndentedJSON(204, H{"foo": "bar", "bar": "foo", "nested": H{"foo": "bar"}})
+	c.IndentedJSON(http.StatusNoContent, H{"foo": "bar", "bar": "foo", "nested": H{"foo": "bar"}})
 
-	assert.Equal(t, 204, w.Code)
+	assert.Equal(t, http.StatusNoContent, w.Code)
 	assert.Empty(t, w.Body.String())
 	assert.Equal(t, "application/json; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
@@ -725,9 +726,9 @@ func TestContextRenderSecureJSON(t *testing.T) {
 	c, router := CreateTestContext(w)
 
 	router.SecureJsonPrefix("&&&START&&&")
-	c.SecureJSON(201, []string{"foo", "bar"})
+	c.SecureJSON(http.StatusCreated, []string{"foo", "bar"})
 
-	assert.Equal(t, 201, w.Code)
+	assert.Equal(t, http.StatusCreated, w.Code)
 	assert.Equal(t, "&&&START&&&[\"foo\",\"bar\"]", w.Body.String())
 	assert.Equal(t, "application/json; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
@@ -737,9 +738,9 @@ func TestContextRenderNoContentSecureJSON(t *testing.T) {
 	w := httptest.NewRecorder()
 	c, _ := CreateTestContext(w)
 
-	c.SecureJSON(204, []string{"foo", "bar"})
+	c.SecureJSON(http.StatusNoContent, []string{"foo", "bar"})
 
-	assert.Equal(t, 204, w.Code)
+	assert.Equal(t, http.StatusNoContent, w.Code)
 	assert.Empty(t, w.Body.String())
 	assert.Equal(t, "application/json; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
@@ -764,9 +765,9 @@ func TestContextRenderHTML(t *testing.T) {
 	templ := template.Must(template.New("t").Parse(`Hello {{.name}}`))
 	router.SetHTMLTemplate(templ)
 
-	c.HTML(201, "t", H{"name": "alexandernyquist"})
+	c.HTML(http.StatusCreated, "t", H{"name": "alexandernyquist"})
 
-	assert.Equal(t, 201, w.Code)
+	assert.Equal(t, http.StatusCreated, w.Code)
 	assert.Equal(t, "Hello alexandernyquist", w.Body.String())
 	assert.Equal(t, "text/html; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
@@ -788,9 +789,9 @@ func TestContextRenderHTML2(t *testing.T) {
 
 	assert.Equal(t, "[GIN-debug] [WARNING] Since SetHTMLTemplate() is NOT thread-safe. It should only be called\nat initialization. ie. before any route is registered or the router is listening in a socket:\n\n\trouter := gin.Default()\n\trouter.SetHTMLTemplate(template) // << good place\n\n", b.String())
 
-	c.HTML(201, "t", H{"name": "alexandernyquist"})
+	c.HTML(http.StatusCreated, "t", H{"name": "alexandernyquist"})
 
-	assert.Equal(t, 201, w.Code)
+	assert.Equal(t, http.StatusCreated, w.Code)
 	assert.Equal(t, "Hello alexandernyquist", w.Body.String())
 	assert.Equal(t, "text/html; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
@@ -802,9 +803,9 @@ func TestContextRenderNoContentHTML(t *testing.T) {
 	templ := template.Must(template.New("t").Parse(`Hello {{.name}}`))
 	router.SetHTMLTemplate(templ)
 
-	c.HTML(204, "t", H{"name": "alexandernyquist"})
+	c.HTML(http.StatusNoContent, "t", H{"name": "alexandernyquist"})
 
-	assert.Equal(t, 204, w.Code)
+	assert.Equal(t, http.StatusNoContent, w.Code)
 	assert.Empty(t, w.Body.String())
 	assert.Equal(t, "text/html; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
@@ -815,9 +816,9 @@ func TestContextRenderXML(t *testing.T) {
 	w := httptest.NewRecorder()
 	c, _ := CreateTestContext(w)
 
-	c.XML(201, H{"foo": "bar"})
+	c.XML(http.StatusCreated, H{"foo": "bar"})
 
-	assert.Equal(t, 201, w.Code)
+	assert.Equal(t, http.StatusCreated, w.Code)
 	assert.Equal(t, "<map><foo>bar</foo></map>", w.Body.String())
 	assert.Equal(t, "application/xml; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
@@ -827,9 +828,9 @@ func TestContextRenderNoContentXML(t *testing.T) {
 	w := httptest.NewRecorder()
 	c, _ := CreateTestContext(w)
 
-	c.XML(204, H{"foo": "bar"})
+	c.XML(http.StatusNoContent, H{"foo": "bar"})
 
-	assert.Equal(t, 204, w.Code)
+	assert.Equal(t, http.StatusNoContent, w.Code)
 	assert.Empty(t, w.Body.String())
 	assert.Equal(t, "application/xml; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
@@ -840,9 +841,9 @@ func TestContextRenderString(t *testing.T) {
 	w := httptest.NewRecorder()
 	c, _ := CreateTestContext(w)
 
-	c.String(201, "test %s %d", "string", 2)
+	c.String(http.StatusCreated, "test %s %d", "string", 2)
 
-	assert.Equal(t, 201, w.Code)
+	assert.Equal(t, http.StatusCreated, w.Code)
 	assert.Equal(t, "test string 2", w.Body.String())
 	assert.Equal(t, "text/plain; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
@@ -852,9 +853,9 @@ func TestContextRenderNoContentString(t *testing.T) {
 	w := httptest.NewRecorder()
 	c, _ := CreateTestContext(w)
 
-	c.String(204, "test %s %d", "string", 2)
+	c.String(http.StatusNoContent, "test %s %d", "string", 2)
 
-	assert.Equal(t, 204, w.Code)
+	assert.Equal(t, http.StatusNoContent, w.Code)
 	assert.Empty(t, w.Body.String())
 	assert.Equal(t, "text/plain; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
@@ -866,9 +867,9 @@ func TestContextRenderHTMLString(t *testing.T) {
 	c, _ := CreateTestContext(w)
 
 	c.Header("Content-Type", "text/html; charset=utf-8")
-	c.String(201, "<html>%s %d</html>", "string", 3)
+	c.String(http.StatusCreated, "<html>%s %d</html>", "string", 3)
 
-	assert.Equal(t, 201, w.Code)
+	assert.Equal(t, http.StatusCreated, w.Code)
 	assert.Equal(t, "<html>string 3</html>", w.Body.String())
 	assert.Equal(t, "text/html; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
@@ -879,9 +880,9 @@ func TestContextRenderNoContentHTMLString(t *testing.T) {
 	c, _ := CreateTestContext(w)
 
 	c.Header("Content-Type", "text/html; charset=utf-8")
-	c.String(204, "<html>%s %d</html>", "string", 3)
+	c.String(http.StatusNoContent, "<html>%s %d</html>", "string", 3)
 
-	assert.Equal(t, 204, w.Code)
+	assert.Equal(t, http.StatusNoContent, w.Code)
 	assert.Empty(t, w.Body.String())
 	assert.Equal(t, "text/html; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
@@ -892,9 +893,9 @@ func TestContextRenderData(t *testing.T) {
 	w := httptest.NewRecorder()
 	c, _ := CreateTestContext(w)
 
-	c.Data(201, "text/csv", []byte(`foo,bar`))
+	c.Data(http.StatusCreated, "text/csv", []byte(`foo,bar`))
 
-	assert.Equal(t, 201, w.Code)
+	assert.Equal(t, http.StatusCreated, w.Code)
 	assert.Equal(t, "foo,bar", w.Body.String())
 	assert.Equal(t, "text/csv", w.HeaderMap.Get("Content-Type"))
 }
@@ -904,9 +905,9 @@ func TestContextRenderNoContentData(t *testing.T) {
 	w := httptest.NewRecorder()
 	c, _ := CreateTestContext(w)
 
-	c.Data(204, "text/csv", []byte(`foo,bar`))
+	c.Data(http.StatusNoContent, "text/csv", []byte(`foo,bar`))
 
-	assert.Equal(t, 204, w.Code)
+	assert.Equal(t, http.StatusNoContent, w.Code)
 	assert.Empty(t, w.Body.String())
 	assert.Equal(t, "text/csv", w.HeaderMap.Get("Content-Type"))
 }
@@ -935,7 +936,7 @@ func TestContextRenderFile(t *testing.T) {
 	c.Request, _ = http.NewRequest("GET", "/", nil)
 	c.File("./gin.go")
 
-	assert.Equal(t, 200, w.Code)
+	assert.Equal(t, http.StatusOK, w.Code)
 	assert.Contains(t, w.Body.String(), "func New() *Engine {")
 	assert.Equal(t, "text/plain; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
@@ -946,9 +947,9 @@ func TestContextRenderYAML(t *testing.T) {
 	w := httptest.NewRecorder()
 	c, _ := CreateTestContext(w)
 
-	c.YAML(201, H{"foo": "bar"})
+	c.YAML(http.StatusCreated, H{"foo": "bar"})
 
-	assert.Equal(t, 201, w.Code)
+	assert.Equal(t, http.StatusCreated, w.Code)
 	assert.Equal(t, "foo: bar\n", w.Body.String())
 	assert.Equal(t, "application/x-yaml; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
@@ -978,9 +979,9 @@ func TestContextRenderRedirectWithRelativePath(t *testing.T) {
 	assert.Panics(t, func() { c.Redirect(299, "/new_path") })
 	assert.Panics(t, func() { c.Redirect(309, "/new_path") })
 
-	c.Redirect(301, "/path")
+	c.Redirect(http.StatusMovedPermanently, "/path")
 	c.Writer.WriteHeaderNow()
-	assert.Equal(t, 301, w.Code)
+	assert.Equal(t, http.StatusMovedPermanently, w.Code)
 	assert.Equal(t, "/path", w.Header().Get("Location"))
 }
 
@@ -989,10 +990,10 @@ func TestContextRenderRedirectWithAbsolutePath(t *testing.T) {
 	c, _ := CreateTestContext(w)
 
 	c.Request, _ = http.NewRequest("POST", "http://example.com", nil)
-	c.Redirect(302, "http://google.com")
+	c.Redirect(http.StatusFound, "http://google.com")
 	c.Writer.WriteHeaderNow()
 
-	assert.Equal(t, 302, w.Code)
+	assert.Equal(t, http.StatusFound, w.Code)
 	assert.Equal(t, "http://google.com", w.Header().Get("Location"))
 }
 
@@ -1001,21 +1002,23 @@ func TestContextRenderRedirectWith201(t *testing.T) {
 	c, _ := CreateTestContext(w)
 
 	c.Request, _ = http.NewRequest("POST", "http://example.com", nil)
-	c.Redirect(201, "/resource")
+	c.Redirect(http.StatusCreated, "/resource")
 	c.Writer.WriteHeaderNow()
 
-	assert.Equal(t, 201, w.Code)
+	assert.Equal(t, http.StatusCreated, w.Code)
 	assert.Equal(t, "/resource", w.Header().Get("Location"))
 }
 
 func TestContextRenderRedirectAll(t *testing.T) {
 	c, _ := CreateTestContext(httptest.NewRecorder())
 	c.Request, _ = http.NewRequest("POST", "http://example.com", nil)
-	assert.Panics(t, func() { c.Redirect(200, "/resource") })
-	assert.Panics(t, func() { c.Redirect(202, "/resource") })
+	assert.Panics(t, func() { c.Redirect(http.StatusOK, "/resource") })
+	assert.Panics(t, func() { c.Redirect(http.StatusAccepted, "/resource") })
 	assert.Panics(t, func() { c.Redirect(299, "/resource") })
 	assert.Panics(t, func() { c.Redirect(309, "/resource") })
-	assert.NotPanics(t, func() { c.Redirect(300, "/resource") })
+	assert.NotPanics(t, func() { c.Redirect(http.StatusMultipleChoices, "/resource") })
+	// todo(thinkerou): go1.6 not support StatusPermanentRedirect(308)
+	// when we upgrade go version we can use http.StatusPermanentRedirect
 	assert.NotPanics(t, func() { c.Redirect(308, "/resource") })
 }
 
@@ -1024,12 +1027,12 @@ func TestContextNegotiationWithJSON(t *testing.T) {
 	c, _ := CreateTestContext(w)
 	c.Request, _ = http.NewRequest("POST", "", nil)
 
-	c.Negotiate(200, Negotiate{
+	c.Negotiate(http.StatusOK, Negotiate{
 		Offered: []string{MIMEJSON, MIMEXML},
 		Data:    H{"foo": "bar"},
 	})
 
-	assert.Equal(t, 200, w.Code)
+	assert.Equal(t, http.StatusOK, w.Code)
 	assert.Equal(t, "{\"foo\":\"bar\"}", w.Body.String())
 	assert.Equal(t, "application/json; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
@@ -1039,12 +1042,12 @@ func TestContextNegotiationWithXML(t *testing.T) {
 	c, _ := CreateTestContext(w)
 	c.Request, _ = http.NewRequest("POST", "", nil)
 
-	c.Negotiate(200, Negotiate{
+	c.Negotiate(http.StatusOK, Negotiate{
 		Offered: []string{MIMEXML, MIMEJSON},
 		Data:    H{"foo": "bar"},
 	})
 
-	assert.Equal(t, 200, w.Code)
+	assert.Equal(t, http.StatusOK, w.Code)
 	assert.Equal(t, "<map><foo>bar</foo></map>", w.Body.String())
 	assert.Equal(t, "application/xml; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
@@ -1056,13 +1059,13 @@ func TestContextNegotiationWithHTML(t *testing.T) {
 	templ := template.Must(template.New("t").Parse(`Hello {{.name}}`))
 	router.SetHTMLTemplate(templ)
 
-	c.Negotiate(200, Negotiate{
+	c.Negotiate(http.StatusOK, Negotiate{
 		Offered:  []string{MIMEHTML},
 		Data:     H{"name": "gin"},
 		HTMLName: "t",
 	})
 
-	assert.Equal(t, 200, w.Code)
+	assert.Equal(t, http.StatusOK, w.Code)
 	assert.Equal(t, "Hello gin", w.Body.String())
 	assert.Equal(t, "text/html; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
@@ -1072,11 +1075,11 @@ func TestContextNegotiationNotSupport(t *testing.T) {
 	c, _ := CreateTestContext(w)
 	c.Request, _ = http.NewRequest("POST", "", nil)
 
-	c.Negotiate(200, Negotiate{
+	c.Negotiate(http.StatusOK, Negotiate{
 		Offered: []string{MIMEPOSTForm},
 	})
 
-	assert.Equal(t, 406, w.Code)
+	assert.Equal(t, http.StatusNotAcceptable, w.Code)
 	assert.Equal(t, c.index, abortIndex)
 	assert.True(t, c.IsAborted())
 }
@@ -1134,11 +1137,11 @@ func TestContextAbortWithStatus(t *testing.T) {
 	c, _ := CreateTestContext(w)
 
 	c.index = 4
-	c.AbortWithStatus(401)
+	c.AbortWithStatus(http.StatusUnauthorized)
 
 	assert.Equal(t, abortIndex, c.index)
-	assert.Equal(t, 401, c.Writer.Status())
-	assert.Equal(t, 401, w.Code)
+	assert.Equal(t, http.StatusUnauthorized, c.Writer.Status())
+	assert.Equal(t, http.StatusUnauthorized, w.Code)
 	assert.True(t, c.IsAborted())
 }
 
@@ -1156,11 +1159,11 @@ func TestContextAbortWithStatusJSON(t *testing.T) {
 	in.Bar = "barValue"
 	in.Foo = "fooValue"
 
-	c.AbortWithStatusJSON(415, in)
+	c.AbortWithStatusJSON(http.StatusUnsupportedMediaType, in)
 
 	assert.Equal(t, abortIndex, c.index)
-	assert.Equal(t, 415, c.Writer.Status())
-	assert.Equal(t, 415, w.Code)
+	assert.Equal(t, http.StatusUnsupportedMediaType, c.Writer.Status())
+	assert.Equal(t, http.StatusUnsupportedMediaType, w.Code)
 	assert.True(t, c.IsAborted())
 
 	contentType := w.Header().Get("Content-Type")
@@ -1223,9 +1226,9 @@ func TestContextAbortWithError(t *testing.T) {
 	w := httptest.NewRecorder()
 	c, _ := CreateTestContext(w)
 
-	c.AbortWithError(401, errors.New("bad input")).SetMeta("some input")
+	c.AbortWithError(http.StatusUnauthorized, errors.New("bad input")).SetMeta("some input")
 
-	assert.Equal(t, 401, w.Code)
+	assert.Equal(t, http.StatusUnauthorized, w.Code)
 	assert.Equal(t, abortIndex, c.index)
 	assert.True(t, c.IsAborted())
 }
@@ -1333,7 +1336,7 @@ func TestContextBadAutoBind(t *testing.T) {
 
 	assert.Empty(t, obj.Bar)
 	assert.Empty(t, obj.Foo)
-	assert.Equal(t, 400, w.Code)
+	assert.Equal(t, http.StatusBadRequest, w.Code)
 	assert.True(t, c.IsAborted())
 }
 
diff --git a/examples/basic/main.go b/examples/basic/main.go
index 473c6a09..48fa7bba 100644
--- a/examples/basic/main.go
+++ b/examples/basic/main.go
@@ -1,6 +1,8 @@
 package main
 
 import (
+	"net/http"
+
 	"github.com/gin-gonic/gin"
 )
 
@@ -13,7 +15,7 @@ func setupRouter() *gin.Engine {
 
 	// Ping test
 	r.GET("/ping", func(c *gin.Context) {
-		c.String(200, "pong")
+		c.String(http.StatusOK, "pong")
 	})
 
 	// Get user value
@@ -21,9 +23,9 @@ func setupRouter() *gin.Engine {
 		user := c.Params.ByName("name")
 		value, ok := DB[user]
 		if ok {
-			c.JSON(200, gin.H{"user": user, "value": value})
+			c.JSON(http.StatusOK, gin.H{"user": user, "value": value})
 		} else {
-			c.JSON(200, gin.H{"user": user, "status": "no value"})
+			c.JSON(http.StatusOK, gin.H{"user": user, "status": "no value"})
 		}
 	})
 
@@ -49,7 +51,7 @@ func setupRouter() *gin.Engine {
 
 		if c.Bind(&json) == nil {
 			DB[user] = json.Value
-			c.JSON(200, gin.H{"status": "ok"})
+			c.JSON(http.StatusOK, gin.H{"status": "ok"})
 		}
 	})
 
diff --git a/examples/basic/main_test.go b/examples/basic/main_test.go
index 61203d66..5eb85240 100644
--- a/examples/basic/main_test.go
+++ b/examples/basic/main_test.go
@@ -15,6 +15,6 @@ func TestPingRoute(t *testing.T) {
 	req, _ := http.NewRequest("GET", "/ping", nil)
 	router.ServeHTTP(w, req)
 
-	assert.Equal(t, 200, w.Code)
+	assert.Equal(t, http.StatusOK, w.Code)
 	assert.Equal(t, "pong", w.Body.String())
 }
diff --git a/examples/favicon/main.go b/examples/favicon/main.go
index 5ad39331..d32ca098 100644
--- a/examples/favicon/main.go
+++ b/examples/favicon/main.go
@@ -1,6 +1,8 @@
 package main
 
 import (
+	"net/http"
+
 	"github.com/gin-gonic/gin"
 	"github.com/thinkerou/favicon"
 )
@@ -9,7 +11,7 @@ func main() {
 	app := gin.Default()
 	app.Use(favicon.New("./favicon.ico"))
 	app.GET("/ping", func(c *gin.Context) {
-		c.String(200, "Hello favicon.")
+		c.String(http.StatusOK, "Hello favicon.")
 	})
 	app.Run(":8080")
 }
diff --git a/examples/http2/main.go b/examples/http2/main.go
index 07df01e2..6598a4c9 100644
--- a/examples/http2/main.go
+++ b/examples/http2/main.go
@@ -3,6 +3,7 @@ package main
 import (
 	"html/template"
 	"log"
+	"net/http"
 	"os"
 
 	"github.com/gin-gonic/gin"
@@ -27,7 +28,7 @@ func main() {
 	r.SetHTMLTemplate(html)
 
 	r.GET("/welcome", func(c *gin.Context) {
-		c.HTML(200, "https", gin.H{
+		c.HTML(http.StatusOK, "https", gin.H{
 			"status": "success",
 		})
 	})
diff --git a/examples/realtime-advanced/routes.go b/examples/realtime-advanced/routes.go
index 86da9bea..03c69910 100644
--- a/examples/realtime-advanced/routes.go
+++ b/examples/realtime-advanced/routes.go
@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"html"
 	"io"
+	"net/http"
 	"strings"
 	"time"
 
@@ -21,12 +22,12 @@ func rateLimit(c *gin.Context) {
 			fmt.Println("ip blocked")
 		}
 		c.Abort()
-		c.String(503, "you were automatically banned :)")
+		c.String(http.StatusServiceUnavailable, "you were automatically banned :)")
 	}
 }
 
 func index(c *gin.Context) {
-	c.Redirect(301, "/room/hn")
+	c.Redirect(http.StatusMovedPermanently, "/room/hn")
 }
 
 func roomGET(c *gin.Context) {
@@ -38,7 +39,7 @@ func roomGET(c *gin.Context) {
 	if len(nick) > 13 {
 		nick = nick[0:12] + "..."
 	}
-	c.HTML(200, "room_login.templ.html", gin.H{
+	c.HTML(http.StatusOK, "room_login.templ.html", gin.H{
 		"roomid":    roomid,
 		"nick":      nick,
 		"timestamp": time.Now().Unix(),
@@ -55,7 +56,7 @@ func roomPOST(c *gin.Context) {
 	validMessage := len(message) > 1 && len(message) < 200
 	validNick := len(nick) > 1 && len(nick) < 14
 	if !validMessage || !validNick {
-		c.JSON(400, gin.H{
+		c.JSON(http.StatusBadRequest, gin.H{
 			"status": "failed",
 			"error":  "the message or nickname is too long",
 		})
@@ -68,7 +69,7 @@ func roomPOST(c *gin.Context) {
 	}
 	messages.Add("inbound", 1)
 	room(roomid).Submit(post)
-	c.JSON(200, post)
+	c.JSON(http.StatusOK, post)
 }
 
 func streamRoom(c *gin.Context) {
diff --git a/examples/realtime-chat/main.go b/examples/realtime-chat/main.go
index e4b55a0f..5741fcba 100644
--- a/examples/realtime-chat/main.go
+++ b/examples/realtime-chat/main.go
@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"io"
 	"math/rand"
+	"net/http"
 
 	"github.com/gin-gonic/gin"
 )
@@ -34,7 +35,7 @@ func stream(c *gin.Context) {
 func roomGET(c *gin.Context) {
 	roomid := c.Param("roomid")
 	userid := fmt.Sprint(rand.Int31())
-	c.HTML(200, "chat_room", gin.H{
+	c.HTML(http.StatusOK, "chat_room", gin.H{
 		"roomid": roomid,
 		"userid": userid,
 	})
@@ -46,7 +47,7 @@ func roomPOST(c *gin.Context) {
 	message := c.PostForm("message")
 	room(roomid).Submit(userid + ": " + message)
 
-	c.JSON(200, gin.H{
+	c.JSON(http.StatusOK, gin.H{
 		"status":  "success",
 		"message": message,
 	})
diff --git a/githubapi_test.go b/githubapi_test.go
index a08c264d..f631035d 100644
--- a/githubapi_test.go
+++ b/githubapi_test.go
@@ -293,7 +293,7 @@ func githubConfigRouter(router *Engine) {
 			for _, param := range c.Params {
 				output[param.Key] = param.Value
 			}
-			c.JSON(200, output)
+			c.JSON(http.StatusOK, output)
 		})
 	}
 }
diff --git a/logger.go b/logger.go
index c679c787..1a8df601 100644
--- a/logger.go
+++ b/logger.go
@@ -7,6 +7,7 @@ package gin
 import (
 	"fmt"
 	"io"
+	"net/http"
 	"os"
 	"time"
 
@@ -118,11 +119,11 @@ func LoggerWithWriter(out io.Writer, notlogged ...string) HandlerFunc {
 
 func colorForStatus(code int) string {
 	switch {
-	case code >= 200 && code < 300:
+	case code >= http.StatusOK && code < http.StatusMultipleChoices:
 		return green
-	case code >= 300 && code < 400:
+	case code >= http.StatusMultipleChoices && code < http.StatusBadRequest:
 		return white
-	case code >= 400 && code < 500:
+	case code >= http.StatusBadRequest && code < http.StatusInternalServerError:
 		return yellow
 	default:
 		return red
diff --git a/logger_test.go b/logger_test.go
index 74a9659c..7dbbf7b1 100644
--- a/logger_test.go
+++ b/logger_test.go
@@ -7,6 +7,7 @@ package gin
 import (
 	"bytes"
 	"errors"
+	"net/http"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -93,9 +94,9 @@ func TestColorForMethod(t *testing.T) {
 }
 
 func TestColorForStatus(t *testing.T) {
-	assert.Equal(t, string([]byte{27, 91, 57, 55, 59, 52, 50, 109}), colorForStatus(200), "2xx should be green")
-	assert.Equal(t, string([]byte{27, 91, 57, 48, 59, 52, 55, 109}), colorForStatus(301), "3xx should be white")
-	assert.Equal(t, string([]byte{27, 91, 57, 55, 59, 52, 51, 109}), colorForStatus(404), "4xx should be yellow")
+	assert.Equal(t, string([]byte{27, 91, 57, 55, 59, 52, 50, 109}), colorForStatus(http.StatusOK), "2xx should be green")
+	assert.Equal(t, string([]byte{27, 91, 57, 48, 59, 52, 55, 109}), colorForStatus(http.StatusMovedPermanently), "3xx should be white")
+	assert.Equal(t, string([]byte{27, 91, 57, 55, 59, 52, 51, 109}), colorForStatus(http.StatusNotFound), "4xx should be yellow")
 	assert.Equal(t, string([]byte{27, 91, 57, 55, 59, 52, 49, 109}), colorForStatus(2), "other things should be red")
 }
 
@@ -106,23 +107,23 @@ func TestErrorLogger(t *testing.T) {
 		c.Error(errors.New("this is an error"))
 	})
 	router.GET("/abort", func(c *Context) {
-		c.AbortWithError(401, errors.New("no authorized"))
+		c.AbortWithError(http.StatusUnauthorized, errors.New("no authorized"))
 	})
 	router.GET("/print", func(c *Context) {
 		c.Error(errors.New("this is an error"))
-		c.String(500, "hola!")
+		c.String(http.StatusInternalServerError, "hola!")
 	})
 
 	w := performRequest(router, "GET", "/error")
-	assert.Equal(t, 200, w.Code)
+	assert.Equal(t, http.StatusOK, w.Code)
 	assert.Equal(t, "{\"error\":\"this is an error\"}", w.Body.String())
 
 	w = performRequest(router, "GET", "/abort")
-	assert.Equal(t, 401, w.Code)
+	assert.Equal(t, http.StatusUnauthorized, w.Code)
 	assert.Equal(t, "{\"error\":\"no authorized\"}", w.Body.String())
 
 	w = performRequest(router, "GET", "/print")
-	assert.Equal(t, 500, w.Code)
+	assert.Equal(t, http.StatusInternalServerError, w.Code)
 	assert.Equal(t, "hola!{\"error\":\"this is an error\"}", w.Body.String())
 }
 
diff --git a/middleware_test.go b/middleware_test.go
index aa6a37a8..983ad933 100644
--- a/middleware_test.go
+++ b/middleware_test.go
@@ -6,6 +6,7 @@ package gin
 
 import (
 	"errors"
+	"net/http"
 	"strings"
 	"testing"
 
@@ -37,7 +38,7 @@ func TestMiddlewareGeneralCase(t *testing.T) {
 	w := performRequest(router, "GET", "/")
 
 	// TEST
-	assert.Equal(t, 200, w.Code)
+	assert.Equal(t, http.StatusOK, w.Code)
 	assert.Equal(t, "ACDB", signature)
 }
 
@@ -73,7 +74,7 @@ func TestMiddlewareNoRoute(t *testing.T) {
 	w := performRequest(router, "GET", "/")
 
 	// TEST
-	assert.Equal(t, 404, w.Code)
+	assert.Equal(t, http.StatusNotFound, w.Code)
 	assert.Equal(t, "ACEGHFDB", signature)
 }
 
@@ -110,7 +111,7 @@ func TestMiddlewareNoMethodEnabled(t *testing.T) {
 	w := performRequest(router, "GET", "/")
 
 	// TEST
-	assert.Equal(t, 405, w.Code)
+	assert.Equal(t, http.StatusMethodNotAllowed, w.Code)
 	assert.Equal(t, "ACEGHFDB", signature)
 }
 
@@ -147,7 +148,7 @@ func TestMiddlewareNoMethodDisabled(t *testing.T) {
 	w := performRequest(router, "GET", "/")
 
 	// TEST
-	assert.Equal(t, 404, w.Code)
+	assert.Equal(t, http.StatusNotFound, w.Code)
 	assert.Equal(t, "AC X DB", signature)
 }
 
@@ -159,7 +160,7 @@ func TestMiddlewareAbort(t *testing.T) {
 	})
 	router.Use(func(c *Context) {
 		signature += "C"
-		c.AbortWithStatus(401)
+		c.AbortWithStatus(http.StatusUnauthorized)
 		c.Next()
 		signature += "D"
 	})
@@ -173,7 +174,7 @@ func TestMiddlewareAbort(t *testing.T) {
 	w := performRequest(router, "GET", "/")
 
 	// TEST
-	assert.Equal(t, 401, w.Code)
+	assert.Equal(t, http.StatusUnauthorized, w.Code)
 	assert.Equal(t, "ACD", signature)
 }
 
@@ -183,7 +184,7 @@ func TestMiddlewareAbortHandlersChainAndNext(t *testing.T) {
 	router.Use(func(c *Context) {
 		signature += "A"
 		c.Next()
-		c.AbortWithStatus(410)
+		c.AbortWithStatus(http.StatusGone)
 		signature += "B"
 
 	})
@@ -195,7 +196,7 @@ func TestMiddlewareAbortHandlersChainAndNext(t *testing.T) {
 	w := performRequest(router, "GET", "/")
 
 	// TEST
-	assert.Equal(t, 410, w.Code)
+	assert.Equal(t, http.StatusGone, w.Code)
 	assert.Equal(t, "ACB", signature)
 }
 
@@ -207,7 +208,7 @@ func TestMiddlewareFailHandlersChain(t *testing.T) {
 	router := New()
 	router.Use(func(context *Context) {
 		signature += "A"
-		context.AbortWithError(500, errors.New("foo"))
+		context.AbortWithError(http.StatusInternalServerError, errors.New("foo"))
 	})
 	router.Use(func(context *Context) {
 		signature += "B"
@@ -218,25 +219,25 @@ func TestMiddlewareFailHandlersChain(t *testing.T) {
 	w := performRequest(router, "GET", "/")
 
 	// TEST
-	assert.Equal(t, 500, w.Code)
+	assert.Equal(t, http.StatusInternalServerError, w.Code)
 	assert.Equal(t, "A", signature)
 }
 
 func TestMiddlewareWrite(t *testing.T) {
 	router := New()
 	router.Use(func(c *Context) {
-		c.String(400, "hola\n")
+		c.String(http.StatusBadRequest, "hola\n")
 	})
 	router.Use(func(c *Context) {
-		c.XML(400, H{"foo": "bar"})
+		c.XML(http.StatusBadRequest, H{"foo": "bar"})
 	})
 	router.Use(func(c *Context) {
-		c.JSON(400, H{"foo": "bar"})
+		c.JSON(http.StatusBadRequest, H{"foo": "bar"})
 	})
 	router.GET("/", func(c *Context) {
-		c.JSON(400, H{"foo": "bar"})
+		c.JSON(http.StatusBadRequest, H{"foo": "bar"})
 	}, func(c *Context) {
-		c.Render(400, sse.Event{
+		c.Render(http.StatusBadRequest, sse.Event{
 			Event: "test",
 			Data:  "message",
 		})
@@ -244,6 +245,6 @@ func TestMiddlewareWrite(t *testing.T) {
 
 	w := performRequest(router, "GET", "/")
 
-	assert.Equal(t, 400, w.Code)
+	assert.Equal(t, http.StatusBadRequest, w.Code)
 	assert.Equal(t, strings.Replace("hola\n<map><foo>bar</foo></map>{\"foo\":\"bar\"}{\"foo\":\"bar\"}event:test\ndata:message\n\n", " ", "", -1), strings.Replace(w.Body.String(), " ", "", -1))
 }
diff --git a/recovery_test.go b/recovery_test.go
index fa065b13..53f4a071 100644
--- a/recovery_test.go
+++ b/recovery_test.go
@@ -6,6 +6,7 @@ package gin
 
 import (
 	"bytes"
+	"net/http"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -22,7 +23,7 @@ func TestPanicInHandler(t *testing.T) {
 	// RUN
 	w := performRequest(router, "GET", "/recovery")
 	// TEST
-	assert.Equal(t, 500, w.Code)
+	assert.Equal(t, http.StatusInternalServerError, w.Code)
 	assert.Contains(t, buffer.String(), "GET /recovery")
 	assert.Contains(t, buffer.String(), "Oupps, Houston, we have a problem")
 	assert.Contains(t, buffer.String(), "TestPanicInHandler")
@@ -33,13 +34,13 @@ func TestPanicWithAbort(t *testing.T) {
 	router := New()
 	router.Use(RecoveryWithWriter(nil))
 	router.GET("/recovery", func(c *Context) {
-		c.AbortWithStatus(400)
+		c.AbortWithStatus(http.StatusBadRequest)
 		panic("Oupps, Houston, we have a problem")
 	})
 	// RUN
 	w := performRequest(router, "GET", "/recovery")
 	// TEST
-	assert.Equal(t, 400, w.Code)
+	assert.Equal(t, http.StatusBadRequest, w.Code)
 }
 
 func TestSource(t *testing.T) {
diff --git a/render/redirect.go b/render/redirect.go
index f874a351..a0634f5a 100644
--- a/render/redirect.go
+++ b/render/redirect.go
@@ -16,6 +16,8 @@ type Redirect struct {
 }
 
 func (r Redirect) Render(w http.ResponseWriter) error {
+	// todo(thinkerou): go1.6 not support StatusPermanentRedirect(308)
+	// when we upgrade go version we can use http.StatusPermanentRedirect
 	if (r.Code < 300 || r.Code > 308) && r.Code != 201 {
 		panic(fmt.Sprintf("Cannot redirect with status code %d", r.Code))
 	}
diff --git a/render/render_test.go b/render/render_test.go
index 8fad12b3..47abf262 100755
--- a/render/render_test.go
+++ b/render/render_test.go
@@ -286,7 +286,7 @@ func TestRenderRedirect(t *testing.T) {
 	assert.NoError(t, err)
 
 	data1 := Redirect{
-		Code:     301,
+		Code:     http.StatusMovedPermanently,
 		Request:  req,
 		Location: "/new/location",
 	}
@@ -296,7 +296,7 @@ func TestRenderRedirect(t *testing.T) {
 	assert.NoError(t, err)
 
 	data2 := Redirect{
-		Code:     200,
+		Code:     http.StatusOK,
 		Request:  req,
 		Location: "/new/location",
 	}
diff --git a/response_writer_test.go b/response_writer_test.go
index fcc48b3b..cc5a89dc 100644
--- a/response_writer_test.go
+++ b/response_writer_test.go
@@ -35,10 +35,10 @@ func TestResponseWriterReset(t *testing.T) {
 
 	writer.reset(testWritter)
 	assert.Equal(t, -1, writer.size)
-	assert.Equal(t, 200, writer.status)
+	assert.Equal(t, http.StatusOK, writer.status)
 	assert.Equal(t, testWritter, writer.ResponseWriter)
 	assert.Equal(t, -1, w.Size())
-	assert.Equal(t, 200, w.Status())
+	assert.Equal(t, http.StatusOK, w.Status())
 	assert.False(t, w.Written())
 }
 
@@ -48,13 +48,13 @@ func TestResponseWriterWriteHeader(t *testing.T) {
 	writer.reset(testWritter)
 	w := ResponseWriter(writer)
 
-	w.WriteHeader(300)
+	w.WriteHeader(http.StatusMultipleChoices)
 	assert.False(t, w.Written())
-	assert.Equal(t, 300, w.Status())
-	assert.NotEqual(t, 300, testWritter.Code)
+	assert.Equal(t, http.StatusMultipleChoices, w.Status())
+	assert.NotEqual(t, http.StatusMultipleChoices, testWritter.Code)
 
 	w.WriteHeader(-1)
-	assert.Equal(t, 300, w.Status())
+	assert.Equal(t, http.StatusMultipleChoices, w.Status())
 }
 
 func TestResponseWriterWriteHeadersNow(t *testing.T) {
@@ -63,12 +63,12 @@ func TestResponseWriterWriteHeadersNow(t *testing.T) {
 	writer.reset(testWritter)
 	w := ResponseWriter(writer)
 
-	w.WriteHeader(300)
+	w.WriteHeader(http.StatusMultipleChoices)
 	w.WriteHeaderNow()
 
 	assert.True(t, w.Written())
 	assert.Equal(t, 0, w.Size())
-	assert.Equal(t, 300, testWritter.Code)
+	assert.Equal(t, http.StatusMultipleChoices, testWritter.Code)
 
 	writer.size = 10
 	w.WriteHeaderNow()
@@ -84,8 +84,8 @@ func TestResponseWriterWrite(t *testing.T) {
 	n, err := w.Write([]byte("hola"))
 	assert.Equal(t, 4, n)
 	assert.Equal(t, 4, w.Size())
-	assert.Equal(t, 200, w.Status())
-	assert.Equal(t, 200, testWritter.Code)
+	assert.Equal(t, http.StatusOK, w.Status())
+	assert.Equal(t, http.StatusOK, testWritter.Code)
 	assert.Equal(t, "hola", testWritter.Body.String())
 	assert.NoError(t, err)
 
diff --git a/routergroup_test.go b/routergroup_test.go
index a362e23d..ce3d54a2 100644
--- a/routergroup_test.go
+++ b/routergroup_test.go
@@ -5,6 +5,7 @@
 package gin
 
 import (
+	"net/http"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -50,7 +51,7 @@ func performRequestInGroup(t *testing.T, method string) {
 	assert.Equal(t, "/v1/login/", login.BasePath())
 
 	handler := func(c *Context) {
-		c.String(400, "the method was %s and index %d", c.Request.Method, c.index)
+		c.String(http.StatusBadRequest, "the method was %s and index %d", c.Request.Method, c.index)
 	}
 
 	switch method {
@@ -80,11 +81,11 @@ func performRequestInGroup(t *testing.T, method string) {
 	}
 
 	w := performRequest(router, method, "/v1/login/test")
-	assert.Equal(t, 400, w.Code)
+	assert.Equal(t, http.StatusBadRequest, w.Code)
 	assert.Equal(t, "the method was "+method+" and index 3", w.Body.String())
 
 	w = performRequest(router, method, "/v1/test")
-	assert.Equal(t, 400, w.Code)
+	assert.Equal(t, http.StatusBadRequest, w.Code)
 	assert.Equal(t, "the method was "+method+" and index 1", w.Body.String())
 }
 
diff --git a/routes_test.go b/routes_test.go
index a2389f9b..23e749e2 100644
--- a/routes_test.go
+++ b/routes_test.go
@@ -80,20 +80,20 @@ func testRouteNotOK2(method string, t *testing.T) {
 func TestRouterMethod(t *testing.T) {
 	router := New()
 	router.PUT("/hey2", func(c *Context) {
-		c.String(200, "sup2")
+		c.String(http.StatusOK, "sup2")
 	})
 
 	router.PUT("/hey", func(c *Context) {
-		c.String(200, "called")
+		c.String(http.StatusOK, "called")
 	})
 
 	router.PUT("/hey3", func(c *Context) {
-		c.String(200, "sup3")
+		c.String(http.StatusOK, "sup3")
 	})
 
 	w := performRequest(router, "PUT", "/hey")
 
-	assert.Equal(t, 200, w.Code)
+	assert.Equal(t, http.StatusOK, w.Code)
 	assert.Equal(t, "called", w.Body.String())
 }
 
@@ -144,42 +144,42 @@ func TestRouteRedirectTrailingSlash(t *testing.T) {
 
 	w := performRequest(router, "GET", "/path/")
 	assert.Equal(t, "/path", w.Header().Get("Location"))
-	assert.Equal(t, 301, w.Code)
+	assert.Equal(t, http.StatusMovedPermanently, w.Code)
 
 	w = performRequest(router, "GET", "/path2")
 	assert.Equal(t, "/path2/", w.Header().Get("Location"))
-	assert.Equal(t, 301, w.Code)
+	assert.Equal(t, http.StatusMovedPermanently, w.Code)
 
 	w = performRequest(router, "POST", "/path3/")
 	assert.Equal(t, "/path3", w.Header().Get("Location"))
-	assert.Equal(t, 307, w.Code)
+	assert.Equal(t, http.StatusTemporaryRedirect, w.Code)
 
 	w = performRequest(router, "PUT", "/path4")
 	assert.Equal(t, "/path4/", w.Header().Get("Location"))
-	assert.Equal(t, 307, w.Code)
+	assert.Equal(t, http.StatusTemporaryRedirect, w.Code)
 
 	w = performRequest(router, "GET", "/path")
-	assert.Equal(t, 200, w.Code)
+	assert.Equal(t, http.StatusOK, w.Code)
 
 	w = performRequest(router, "GET", "/path2/")
-	assert.Equal(t, 200, w.Code)
+	assert.Equal(t, http.StatusOK, w.Code)
 
 	w = performRequest(router, "POST", "/path3")
-	assert.Equal(t, 200, w.Code)
+	assert.Equal(t, http.StatusOK, w.Code)
 
 	w = performRequest(router, "PUT", "/path4/")
-	assert.Equal(t, 200, w.Code)
+	assert.Equal(t, http.StatusOK, w.Code)
 
 	router.RedirectTrailingSlash = false
 
 	w = performRequest(router, "GET", "/path/")
-	assert.Equal(t, 404, w.Code)
+	assert.Equal(t, http.StatusNotFound, w.Code)
 	w = performRequest(router, "GET", "/path2")
-	assert.Equal(t, 404, w.Code)
+	assert.Equal(t, http.StatusNotFound, w.Code)
 	w = performRequest(router, "POST", "/path3/")
-	assert.Equal(t, 404, w.Code)
+	assert.Equal(t, http.StatusNotFound, w.Code)
 	w = performRequest(router, "PUT", "/path4")
-	assert.Equal(t, 404, w.Code)
+	assert.Equal(t, http.StatusNotFound, w.Code)
 }
 
 func TestRouteRedirectFixedPath(t *testing.T) {
@@ -194,19 +194,19 @@ func TestRouteRedirectFixedPath(t *testing.T) {
 
 	w := performRequest(router, "GET", "/PATH")
 	assert.Equal(t, "/path", w.Header().Get("Location"))
-	assert.Equal(t, 301, w.Code)
+	assert.Equal(t, http.StatusMovedPermanently, w.Code)
 
 	w = performRequest(router, "GET", "/path2")
 	assert.Equal(t, "/Path2", w.Header().Get("Location"))
-	assert.Equal(t, 301, w.Code)
+	assert.Equal(t, http.StatusMovedPermanently, w.Code)
 
 	w = performRequest(router, "POST", "/path3")
 	assert.Equal(t, "/PATH3", w.Header().Get("Location"))
-	assert.Equal(t, 307, w.Code)
+	assert.Equal(t, http.StatusTemporaryRedirect, w.Code)
 
 	w = performRequest(router, "POST", "/path4")
 	assert.Equal(t, "/Path4/", w.Header().Get("Location"))
-	assert.Equal(t, 307, w.Code)
+	assert.Equal(t, http.StatusTemporaryRedirect, w.Code)
 }
 
 // TestContextParamsGet tests that a parameter can be parsed from the URL.
@@ -236,7 +236,7 @@ func TestRouteParamsByName(t *testing.T) {
 
 	w := performRequest(router, "GET", "/test/john/smith/is/super/great")
 
-	assert.Equal(t, 200, w.Code)
+	assert.Equal(t, http.StatusOK, w.Code)
 	assert.Equal(t, "john", name)
 	assert.Equal(t, "smith", lastName)
 	assert.Equal(t, "/is/super/great", wild)
@@ -265,7 +265,7 @@ func TestRouteStaticFile(t *testing.T) {
 	w2 := performRequest(router, "GET", "/result")
 
 	assert.Equal(t, w, w2)
-	assert.Equal(t, 200, w.Code)
+	assert.Equal(t, http.StatusOK, w.Code)
 	assert.Equal(t, "Gin Web Framework", w.Body.String())
 	assert.Equal(t, "text/plain; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 
@@ -273,7 +273,7 @@ func TestRouteStaticFile(t *testing.T) {
 	w4 := performRequest(router, "HEAD", "/result")
 
 	assert.Equal(t, w3, w4)
-	assert.Equal(t, 200, w3.Code)
+	assert.Equal(t, http.StatusOK, w3.Code)
 }
 
 // TestHandleStaticDir - ensure the root/sub dir handles properly
@@ -283,7 +283,7 @@ func TestRouteStaticListingDir(t *testing.T) {
 
 	w := performRequest(router, "GET", "/")
 
-	assert.Equal(t, 200, w.Code)
+	assert.Equal(t, http.StatusOK, w.Code)
 	assert.Contains(t, w.Body.String(), "gin.go")
 	assert.Equal(t, "text/html; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
@@ -295,7 +295,7 @@ func TestRouteStaticNoListing(t *testing.T) {
 
 	w := performRequest(router, "GET", "/")
 
-	assert.Equal(t, 404, w.Code)
+	assert.Equal(t, http.StatusNotFound, w.Code)
 	assert.NotContains(t, w.Body.String(), "gin.go")
 }
 
@@ -310,7 +310,7 @@ func TestRouterMiddlewareAndStatic(t *testing.T) {
 
 	w := performRequest(router, "GET", "/gin.go")
 
-	assert.Equal(t, 200, w.Code)
+	assert.Equal(t, http.StatusOK, w.Code)
 	assert.Contains(t, w.Body.String(), "package gin")
 	assert.Equal(t, "text/plain; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 	assert.NotEqual(t, w.HeaderMap.Get("Last-Modified"), "Mon, 02 Jan 2006 15:04:05 MST")
@@ -348,14 +348,14 @@ func TestRouteNotAllowedDisabled(t *testing.T) {
 	router.HandleMethodNotAllowed = false
 	router.POST("/path", func(c *Context) {})
 	w := performRequest(router, "GET", "/path")
-	assert.Equal(t, 404, w.Code)
+	assert.Equal(t, http.StatusNotFound, w.Code)
 
 	router.NoMethod(func(c *Context) {
 		c.String(http.StatusTeapot, "responseText")
 	})
 	w = performRequest(router, "GET", "/path")
 	assert.Equal(t, "404 page not found", w.Body.String())
-	assert.Equal(t, 404, w.Code)
+	assert.Equal(t, http.StatusNotFound, w.Code)
 }
 
 func TestRouterNotFound(t *testing.T) {
@@ -370,20 +370,20 @@ func TestRouterNotFound(t *testing.T) {
 		code     int
 		location string
 	}{
-		{"/path/", 301, "/path"},   // TSR -/
-		{"/dir", 301, "/dir/"},     // TSR +/
-		{"", 301, "/"},             // TSR +/
-		{"/PATH", 301, "/path"},    // Fixed Case
-		{"/DIR/", 301, "/dir/"},    // Fixed Case
-		{"/PATH/", 301, "/path"},   // Fixed Case -/
-		{"/DIR", 301, "/dir/"},     // Fixed Case +/
-		{"/../path", 301, "/path"}, // CleanPath
-		{"/nope", 404, ""},         // NotFound
+		{"/path/", http.StatusMovedPermanently, "/path"},   // TSR -/
+		{"/dir", http.StatusMovedPermanently, "/dir/"},     // TSR +/
+		{"", http.StatusMovedPermanently, "/"},             // TSR +/
+		{"/PATH", http.StatusMovedPermanently, "/path"},    // Fixed Case
+		{"/DIR/", http.StatusMovedPermanently, "/dir/"},    // Fixed Case
+		{"/PATH/", http.StatusMovedPermanently, "/path"},   // Fixed Case -/
+		{"/DIR", http.StatusMovedPermanently, "/dir/"},     // Fixed Case +/
+		{"/../path", http.StatusMovedPermanently, "/path"}, // CleanPath
+		{"/nope", http.StatusNotFound, ""},                 // NotFound
 	}
 	for _, tr := range testRoutes {
 		w := performRequest(router, "GET", tr.route)
 		assert.Equal(t, tr.code, w.Code)
-		if w.Code != 404 {
+		if w.Code != http.StatusNotFound {
 			assert.Equal(t, tr.location, fmt.Sprint(w.Header().Get("Location")))
 		}
 	}
@@ -391,24 +391,24 @@ func TestRouterNotFound(t *testing.T) {
 	// Test custom not found handler
 	var notFound bool
 	router.NoRoute(func(c *Context) {
-		c.AbortWithStatus(404)
+		c.AbortWithStatus(http.StatusNotFound)
 		notFound = true
 	})
 	w := performRequest(router, "GET", "/nope")
-	assert.Equal(t, 404, w.Code)
+	assert.Equal(t, http.StatusNotFound, w.Code)
 	assert.True(t, notFound)
 
 	// Test other method than GET (want 307 instead of 301)
 	router.PATCH("/path", func(c *Context) {})
 	w = performRequest(router, "PATCH", "/path/")
-	assert.Equal(t, 307, w.Code)
+	assert.Equal(t, http.StatusTemporaryRedirect, w.Code)
 	assert.Equal(t, "map[Location:[/path]]", fmt.Sprint(w.Header()))
 
 	// Test special case where no node for the prefix "/" exists
 	router = New()
 	router.GET("/a", func(c *Context) {})
 	w = performRequest(router, "GET", "/")
-	assert.Equal(t, 404, w.Code)
+	assert.Equal(t, http.StatusNotFound, w.Code)
 }
 
 func TestRouteRawPath(t *testing.T) {
@@ -427,7 +427,7 @@ func TestRouteRawPath(t *testing.T) {
 	})
 
 	w := performRequest(route, "POST", "/project/Some%2FOther%2FProject/build/222")
-	assert.Equal(t, 200, w.Code)
+	assert.Equal(t, http.StatusOK, w.Code)
 }
 
 func TestRouteRawPathNoUnescape(t *testing.T) {
@@ -447,7 +447,7 @@ func TestRouteRawPathNoUnescape(t *testing.T) {
 	})
 
 	w := performRequest(route, "POST", "/project/Some%2FOther%2FProject/build/333")
-	assert.Equal(t, 200, w.Code)
+	assert.Equal(t, http.StatusOK, w.Code)
 }
 
 func TestRouteServeErrorWithWriteHeader(t *testing.T) {
diff --git a/utils_test.go b/utils_test.go
index 95b5de5e..9b57c57b 100644
--- a/utils_test.go
+++ b/utils_test.go
@@ -25,7 +25,7 @@ type testStruct struct {
 func (t *testStruct) ServeHTTP(w http.ResponseWriter, req *http.Request) {
 	assert.Equal(t.T, "POST", req.Method)
 	assert.Equal(t.T, "/path", req.URL.Path)
-	w.WriteHeader(500)
+	w.WriteHeader(http.StatusInternalServerError)
 	fmt.Fprint(w, "hello")
 }
 
@@ -35,16 +35,16 @@ func TestWrap(t *testing.T) {
 	router.GET("/path2", WrapF(func(w http.ResponseWriter, req *http.Request) {
 		assert.Equal(t, "GET", req.Method)
 		assert.Equal(t, "/path2", req.URL.Path)
-		w.WriteHeader(400)
+		w.WriteHeader(http.StatusBadRequest)
 		fmt.Fprint(w, "hola!")
 	}))
 
 	w := performRequest(router, "POST", "/path")
-	assert.Equal(t, 500, w.Code)
+	assert.Equal(t, http.StatusInternalServerError, w.Code)
 	assert.Equal(t, "hello", w.Body.String())
 
 	w = performRequest(router, "GET", "/path2")
-	assert.Equal(t, 400, w.Code)
+	assert.Equal(t, http.StatusBadRequest, w.Code)
 	assert.Equal(t, "hola!", w.Body.String())
 }
 

From 6c8a9731345b6782c923054b0c973c2b4b9394a6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Tue, 14 Aug 2018 11:35:13 +0800
Subject: [PATCH 032/105] add issue and pull request template explain (#1483)

* add issue/pr template explain

* add issue/pr template explain
---
 .github/ISSUE_TEMPLATE.md        | 13 +++++++++++++
 .github/PULL_REQUEST_TEMPLATE.md |  7 +++++++
 2 files changed, 20 insertions(+)
 create mode 100644 .github/ISSUE_TEMPLATE.md
 create mode 100644 .github/PULL_REQUEST_TEMPLATE.md

diff --git a/.github/ISSUE_TEMPLATE.md b/.github/ISSUE_TEMPLATE.md
new file mode 100644
index 00000000..de067ce0
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE.md
@@ -0,0 +1,13 @@
+- With issues:
+  - Use the search tool before opening a new issue.
+  - Please provide source code and commit sha if you found a bug.
+  - Review existing issues and provide feedback or react to them.
+
+- gin version (or commit ref):
+- git version:
+- operating system:
+
+## Description
+
+## Screenshots
+
diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
new file mode 100644
index 00000000..8630bc35
--- /dev/null
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -0,0 +1,7 @@
+- With pull requests:
+  - Open your pull request against `master`
+  - Your pull request should have no more than two commits, if not you should squash them.
+  - It should pass all tests in the available continuous integrations systems such as TravisCI.
+  - You should add/modify tests to cover your proposed code changes.
+  - If your pull request contains a new feature, please document it on the README.
+

From b869fe1415e4b9eb52f247441830d502aece2d4d Mon Sep 17 00:00:00 2001
From: Javier Provecho Fernandez <javiertitan@gmail.com>
Date: Tue, 14 Aug 2018 10:58:52 +0200
Subject: [PATCH 033/105] docs: add changelog for v1.3.0, update authors and
 version const (#1478)

* docs: add changelog for v1.3.0, update authors and version const

*  add link for every referenced pull request (#1481)

* docs: add changelog for v1.3.0, update authors and version const

* add link for pr
---
 AUTHORS.md   |  6 +++++-
 CHANGELOG.md | 24 +++++++++++++++++++++++-
 gin.go       |  2 +-
 3 files changed, 29 insertions(+), 3 deletions(-)

diff --git a/AUTHORS.md b/AUTHORS.md
index 7ab7213d..dda19bcf 100644
--- a/AUTHORS.md
+++ b/AUTHORS.md
@@ -1,8 +1,12 @@
 List of all the awesome people working to make Gin the best Web Framework in Go.
 
+## gin 1.x series authors
+
+**Gin Core Team:** Bo-Yi Wu (@appleboy), 田欧 (@thinkerou), Javier Provecho (@javierprovecho)
+
 ## gin 0.x series authors
 
-**Maintainer:** Manu Martinez-Almeida (@manucorporat), Javier Provecho (@javierprovecho)
+**Maintainers:** Manu Martinez-Almeida (@manucorporat), Javier Provecho (@javierprovecho)
 
 People and companies, who have contributed, in alphabetical order.
 
diff --git a/CHANGELOG.md b/CHANGELOG.md
index ee485ec3..e6a108ca 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,28 @@
 # CHANGELOG
 
-### Gin 1.2
+### Gin 1.3.0
+
+- [NEW] Add [`func (*Context) QueryMap`](https://godoc.org/github.com/gin-gonic/gin#Context.QueryMap), [`func (*Context) GetQueryMap`](https://godoc.org/github.com/gin-gonic/gin#Context.GetQueryMap), [`func (*Context) PostFormMap`](https://godoc.org/github.com/gin-gonic/gin#Context.PostFormMap) and [`func (*Context) GetPostFormMap`](https://godoc.org/github.com/gin-gonic/gin#Context.GetPostFormMap) to support `type map[string]string` as query string or form parameters, see [#1383](https://github.com/gin-gonic/gin/pull/1383)
+- [NEW] Add [`func (*Context) AsciiJSON`](https://godoc.org/github.com/gin-gonic/gin#Context.AsciiJSON), see [#1358](https://github.com/gin-gonic/gin/pull/1358)
+- [NEW] Add `Pusher()` in [`type ResponseWriter`](https://godoc.org/github.com/gin-gonic/gin#ResponseWriter) for supporting http2 push, see [#1273](https://github.com/gin-gonic/gin/pull/1273)
+- [NEW] Add [`func (*Context) DataFromReader`](https://godoc.org/github.com/gin-gonic/gin#Context.DataFromReader) for serving dynamic data, see [#1304](https://github.com/gin-gonic/gin/pull/1304)
+- [NEW] Add [`func (*Context) ShouldBindBodyWith`](https://godoc.org/github.com/gin-gonic/gin#Context.ShouldBindBodyWith) allowing to call binding multiple times, see [#1341](https://github.com/gin-gonic/gin/pull/1341)
+- [NEW] Support pointers in form binding, see [#1336](https://github.com/gin-gonic/gin/pull/1336)
+- [NEW] Add [`func (*Context) JSONP`](https://godoc.org/github.com/gin-gonic/gin#Context.JSONP), see [#1333](https://github.com/gin-gonic/gin/pull/1333)
+- [NEW] Support default value in form binding, see [#1138](https://github.com/gin-gonic/gin/pull/1138)
+- [NEW] Expose validator engine in [`type StructValidator`](https://godoc.org/github.com/gin-gonic/gin/binding#StructValidator), see [#1277](https://github.com/gin-gonic/gin/pull/1277)
+- [NEW] Add [`func (*Context) ShouldBind`](https://godoc.org/github.com/gin-gonic/gin#Context.ShouldBind), [`func (*Context) ShouldBindQuery`](https://godoc.org/github.com/gin-gonic/gin#Context.ShouldBindQuery) and [`func (*Context) ShouldBindJSON`](https://godoc.org/github.com/gin-gonic/gin#Context.ShouldBindJSON), see [#1047](https://github.com/gin-gonic/gin/pull/1047)
+- [NEW] Add support for `time.Time` location in form binding, see [#1117](https://github.com/gin-gonic/gin/pull/1117)
+- [NEW] Add [`func (*Context) BindQuery`](https://godoc.org/github.com/gin-gonic/gin#Context.BindQuery), see [#1029](https://github.com/gin-gonic/gin/pull/1029)
+- [NEW] Make [jsonite](https://github.com/json-iterator/go) optional with build tags, see [#1026](https://github.com/gin-gonic/gin/pull/1026)
+- [NEW] Show query string in logger, see [#999](https://github.com/gin-gonic/gin/pull/999)
+- [NEW] Add [`func (*Context) SecureJSON`](https://godoc.org/github.com/gin-gonic/gin#Context.SecureJSON), see [#987](https://github.com/gin-gonic/gin/pull/987) and [#993](https://github.com/gin-gonic/gin/pull/993)
+- [DEPRECATE] `func (*Context) GetCookie` for [`func (*Context) Cookie`](https://godoc.org/github.com/gin-gonic/gin#Context.Cookie)
+- [FIX] Don't display color tags if [`func DisableConsoleColor`](https://godoc.org/github.com/gin-gonic/gin#DisableConsoleColor) called, see [#1072](https://github.com/gin-gonic/gin/pull/1072)
+- [FIX] Gin Mode `""` when calling [`func Mode`](https://godoc.org/github.com/gin-gonic/gin#Mode) now returns `const DebugMode`, see [#1250](https://github.com/gin-gonic/gin/pull/1250)
+- [FIX] `Flush()` now doesn't overwrite `responseWriter` status code, see [#1460](https://github.com/gin-gonic/gin/pull/1460)
+
+### Gin 1.2.0
 
 - [NEW] Switch from godeps to govendor
 - [NEW] Add support for Let's Encrypt via gin-gonic/autotls
diff --git a/gin.go b/gin.go
index fc4d6564..aa62e014 100644
--- a/gin.go
+++ b/gin.go
@@ -16,7 +16,7 @@ import (
 
 const (
 	// Version is Framework's version.
-	Version                = "v1.2"
+	Version                = "v1.3.0"
 	defaultMultipartMemory = 32 << 20 // 32 MB
 )
 

From 64a45486421c37bd60af66ce96a3ef7b62a191aa Mon Sep 17 00:00:00 2001
From: Abner Chen <houjunchen@gmail.com>
Date: Wed, 15 Aug 2018 13:42:12 +0800
Subject: [PATCH 034/105] Fix typo in readme (#1490)

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 28598baf..d8e3ffaa 100644
--- a/README.md
+++ b/README.md
@@ -679,7 +679,7 @@ $ curl "localhost:8085/bookable?check_in=2018-03-08&check_out=2018-03-09"
 {"error":"Key: 'Booking.CheckIn' Error:Field validation for 'CheckIn' failed on the 'bookabledate' tag"}
 ```
 
-[Struct level validations](https://github.com/go-playground/validator/releases/tag/v8.7) can also be registed this way.
+[Struct level validations](https://github.com/go-playground/validator/releases/tag/v8.7) can also be registered this way.
 See the [struct-lvl-validation example](examples/struct-lvl-validations) to learn more.
 
 ### Only Bind Query String

From bef6c56c8928cfe1d96a9fdefe29fcfdeb2b2f89 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Thu, 16 Aug 2018 17:38:17 +0800
Subject: [PATCH 035/105] chore: upgrade dependency library version (#1491)

upgrade lib version, and upgrade `github.com/json-iterator/go` to add two libs.
---
 vendor/vendor.json | 94 +++++++++++++++++++++++++++++++---------------
 1 file changed, 64 insertions(+), 30 deletions(-)

diff --git a/vendor/vendor.json b/vendor/vendor.json
index c34c2de3..e6d038a4 100644
--- a/vendor/vendor.json
+++ b/vendor/vendor.json
@@ -1,13 +1,12 @@
 {
-	"comment": "v1.2",
+	"comment": "v1.3.0",
 	"ignore": "test",
 	"package": [
 		{
-			"checksumSHA1": "dvabztWVQX8f6oMLRyv4dLH+TGY=",
-			"comment": "v1.1.0",
+			"checksumSHA1": "CSPbwbyzqA6sfORicn4HFtIhF/c=",
 			"path": "github.com/davecgh/go-spew/spew",
-			"revision": "346938d642f2ec3594ed81d874461961cd0faa76",
-			"revisionTime": "2016-10-29T20:57:26Z"
+			"revision": "8991bc29aa16c548c550c7ff78260e27b9ab7c73",
+			"revisionTime": "2018-02-21T22:46:20Z"
 		},
 		{
 			"checksumSHA1": "QeKwBtN2df+j+4stw3bQJ6yO4EY=",
@@ -16,35 +15,62 @@
 			"revisionTime": "2017-01-09T09:34:21Z"
 		},
 		{
-			"checksumSHA1": "qlPUeFabwF4RKAOF1H+yBFU1Veg=",
+			"checksumSHA1": "Pyou8mceOASSFxc7GeXZuVdSMi0=",
 			"path": "github.com/golang/protobuf/proto",
-			"revision": "5a0f697c9ed9d68fef0116532c6e05cfeae00e55",
-			"revisionTime": "2017-06-01T23:02:30Z"
+			"revision": "b4deda0973fb4c70b50d226b1af49f3da59f5265",
+			"revisionTime": "2018-04-30T18:52:41Z",
+			"version": "v1.1.0",
+			"versionExact": "v1.1.0"
 		},
 		{
-			"checksumSHA1": "Ajh8TemnItg4nn+jKmVcsMRALBc=",
+			"checksumSHA1": "WqeEgS7pqqkwK8mlrAZmDgtWJMY=",
 			"path": "github.com/json-iterator/go",
-			"revision": "36b14963da70d11297d313183d7e6388c8510e1e",
-			"revisionTime": "2017-08-29T15:58:51Z"
+			"revision": "1624edc4454b8682399def8740d46db5e4362ba4",
+			"revisionTime": "2018-08-06T06:07:27Z",
+			"version": "1.1.5",
+			"versionExact": "1.1.5"
 		},
 		{
-			"checksumSHA1": "U6lX43KDDlNOn+Z0Yyww+ZzHfFo=",
+			"checksumSHA1": "y/A5iuvwjytQE2CqVuphQRXR2nI=",
 			"path": "github.com/mattn/go-isatty",
-			"revision": "57fdcb988a5c543893cc61bce354a6e24ab70022",
-			"revisionTime": "2017-03-07T16:30:44Z"
+			"revision": "0360b2af4f38e8d38c7fce2a9f4e702702d73a39",
+			"revisionTime": "2017-09-25T05:34:41Z",
+			"version": "v0.0.3",
+			"versionExact": "v0.0.3"
 		},
 		{
-			"checksumSHA1": "Q2V7Zs3diLmLfmfbiuLpSxETSuY=",
-			"comment": "v1.1.4",
+			"checksumSHA1": "ZTcgWKWHsrX0RXYVXn5Xeb8Q0go=",
+			"path": "github.com/modern-go/concurrent",
+			"revision": "bacd9c7ef1dd9b15be4a9909b8ac7a4e313eec94",
+			"revisionTime": "2018-03-06T01:26:44Z"
+		},
+		{
+			"checksumSHA1": "qvH48wzTIV3QKSDqI0dLFtVjaDI=",
+			"path": "github.com/modern-go/reflect2",
+			"revision": "94122c33edd36123c84d5368cfb2b69df93a0ec8",
+			"revisionTime": "2018-07-18T01:23:57Z"
+		},
+		{
+			"checksumSHA1": "LuFv4/jlrmFNnDb/5SCSEPAM9vU=",
+			"path": "github.com/pmezard/go-difflib/difflib",
+			"revision": "792786c7400a136282c1664665ae0a8db921c6c2",
+			"revisionTime": "2016-01-10T10:55:54Z"
+		},
+		{
+			"checksumSHA1": "c6pbpF7eowwO59phRTpF8cQ80Z0=",
 			"path": "github.com/stretchr/testify/assert",
-			"revision": "976c720a22c8eb4eb6a0b4348ad85ad12491a506",
-			"revisionTime": "2016-09-25T22:06:09Z"
+			"revision": "f35b8ab0b5a2cef36673838d662e249dd9c94686",
+			"revisionTime": "2018-05-06T18:05:49Z",
+			"version": "v1.2.2",
+			"versionExact": "v1.2.2"
 		},
 		{
-			"checksumSHA1": "CoxdaTYdPZNJXr8mJfLxye428N0=",
+			"checksumSHA1": "5Bd8RPhhaKcEXkagzPqymP4Gx5E=",
 			"path": "github.com/ugorji/go/codec",
-			"revision": "c88ee250d0221a57af388746f5cf03768c21d6e2",
-			"revisionTime": "2017-02-15T20:11:44Z"
+			"revision": "b4c50a2b199d93b13dc15e78929cfb23bfdf21ab",
+			"revisionTime": "2018-04-07T10:07:33Z",
+			"version": "v1.1.1",
+			"versionExact": "v1.1.1"
 		},
 		{
 			"checksumSHA1": "9jjO5GjLa0XF/nfWihF02RoH4qc=",
@@ -54,18 +80,26 @@
 			"revisionTime": "2016-10-18T08:54:36Z"
 		},
 		{
-			"checksumSHA1": "39V1idWER42Lmcmg2Uy40wMzOlo=",
-			"comment": "v8.18.1",
-			"path": "gopkg.in/go-playground/validator.v8",
-			"revision": "5f57d2222ad794d0dffb07e664ea05e2ee07d60c",
-			"revisionTime": "2016-07-18T13:41:25Z"
+			"checksumSHA1": "7Gocawl8bm27cpAILtuf21xvVD8=",
+			"path": "golang.org/x/sys/unix",
+			"revision": "1c9583448a9c3aa0f9a6a5241bf73c0bd8aafded",
+			"revisionTime": "2018-08-15T07:37:39Z"
 		},
 		{
-			"checksumSHA1": "12GqsW8PiRPnezDDy0v4brZrndM=",
-			"comment": "v2",
+			"checksumSHA1": "P/k5ZGf0lEBgpKgkwy++F7K1PSg=",
+			"path": "gopkg.in/go-playground/validator.v8",
+			"revision": "5f1438d3fca68893a817e4a66806cea46a9e4ebf",
+			"revisionTime": "2017-07-30T05:02:35Z",
+			"version": "v8.18.2",
+			"versionExact": "v8.18.2"
+		},
+		{
+			"checksumSHA1": "ZSWoOPUNRr5+3dhkLK3C4cZAQPk=",
 			"path": "gopkg.in/yaml.v2",
-			"revision": "a5b47d31c556af34a302ce5d659e6fea44d90de0",
-			"revisionTime": "2016-09-28T15:37:09Z"
+			"revision": "5420a8b6744d3b0345ab293f6fcba19c978f1183",
+			"revisionTime": "2018-03-28T19:50:20Z",
+			"version": "v2.2.1",
+			"versionExact": "v2.2.1"
 		}
 	],
 	"rootPath": "github.com/gin-gonic/gin"

From 40ab9de4b57ac6ce467a96b1fb4c3379658b29c2 Mon Sep 17 00:00:00 2001
From: syssam <s.y.s.sam.sys@gmail.com>
Date: Fri, 17 Aug 2018 09:12:15 +0800
Subject: [PATCH 036/105] Add BindXML AND ShouldBindXML #1484 (#1485)

Add BindXML AND ShouldBindXML #1484
---
 README.md       | 61 ++++++++++++++++++++++++++++++++++---------------
 context.go      | 10 ++++++++
 context_test.go | 41 +++++++++++++++++++++++++++++++++
 3 files changed, 94 insertions(+), 18 deletions(-)

diff --git a/README.md b/README.md
index d8e3ffaa..5de22dc3 100644
--- a/README.md
+++ b/README.md
@@ -534,10 +534,10 @@ Note that you need to set the corresponding binding tag on all fields you want t
 
 Also, Gin provides two sets of methods for binding:
 - **Type** - Must bind
-  - **Methods** - `Bind`, `BindJSON`, `BindQuery`
+  - **Methods** - `Bind`, `BindJSON`, `BindXML`, `BindQuery`
   - **Behavior** - These methods use `MustBindWith` under the hood. If there is a binding error, the request is aborted with `c.AbortWithError(400, err).SetType(ErrorTypeBind)`. This sets the response status code to 400 and the `Content-Type` header is set to `text/plain; charset=utf-8`. Note that if you try to set the response code after this, it will result in a warning `[GIN-debug] [WARNING] Headers were already written. Wanted to override status code 400 with 422`. If you wish to have greater control over the behavior, consider using the `ShouldBind` equivalent method.
 - **Type** - Should bind
-  - **Methods** - `ShouldBind`, `ShouldBindJSON`, `ShouldBindQuery`
+  - **Methods** - `ShouldBind`, `ShouldBindJSON`, `ShouldBindXML`, `ShouldBindQuery`
   - **Behavior** - These methods use `ShouldBindWith` under the hood. If there is a binding error, the error is returned and it is the developer's responsibility to handle the request and error appropriately.
 
 When using the Bind-method, Gin tries to infer the binder depending on the Content-Type header. If you are sure what you are binding, you can use `MustBindWith` or `ShouldBindWith`.
@@ -547,8 +547,8 @@ You can also specify that specific fields are required. If a field is decorated
 ```go
 // Binding from JSON
 type Login struct {
-	User     string `form:"user" json:"user" binding:"required"`
-	Password string `form:"password" json:"password" binding:"required"`
+	User     string `form:"user" json:"user" xml:"user"  binding:"required"`
+	Password string `form:"password" json:"password" xml:"password" binding:"required"`
 }
 
 func main() {
@@ -557,30 +557,55 @@ func main() {
 	// Example for binding JSON ({"user": "manu", "password": "123"})
 	router.POST("/loginJSON", func(c *gin.Context) {
 		var json Login
-		if err := c.ShouldBindJSON(&json); err == nil {
-			if json.User == "manu" && json.Password == "123" {
-				c.JSON(http.StatusOK, gin.H{"status": "you are logged in"})
-			} else {
-				c.JSON(http.StatusUnauthorized, gin.H{"status": "unauthorized"})
-			}
-		} else {
+		if err := c.ShouldBindXML(&json); err != nil {
 			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
 		}
+		
+		if json.User != "manu" || json.Password != "123" {
+			c.JSON(http.StatusUnauthorized, gin.H{"status": "unauthorized"})
+			return
+		} 
+		
+		c.JSON(http.StatusOK, gin.H{"status": "you are logged in"})
+	})
+
+	// Example for binding XML (
+	//	<?xml version="1.0" encoding="UTF-8"?>
+	//	<root>
+	//		<user>user</user>
+	//		<password>123</user>
+	//	</root>)
+	router.POST("/loginXML", func(c *gin.Context) {
+		var xml Login
+		if err := c.ShouldBindXML(&xml); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		
+		if xml.User != "manu" || xml.Password != "123" {
+			c.JSON(http.StatusUnauthorized, gin.H{"status": "unauthorized"})
+			return
+		} 
+		
+		c.JSON(http.StatusOK, gin.H{"status": "you are logged in"})
 	})
 
 	// Example for binding a HTML form (user=manu&password=123)
 	router.POST("/loginForm", func(c *gin.Context) {
 		var form Login
 		// This will infer what binder to use depending on the content-type header.
-		if err := c.ShouldBind(&form); err == nil {
-			if form.User == "manu" && form.Password == "123" {
-				c.JSON(http.StatusOK, gin.H{"status": "you are logged in"})
-			} else {
-				c.JSON(http.StatusUnauthorized, gin.H{"status": "unauthorized"})
-			}
-		} else {
+		if err := c.ShouldBind(&form); err != nil {
 			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
 		}
+		
+		if form.User != "manu" || form.Password != "123" {
+			c.JSON(http.StatusUnauthorized, gin.H{"status": "unauthorized"})
+			return
+		} 
+		
+		c.JSON(http.StatusOK, gin.H{"status": "you are logged in"})
 	})
 
 	// Listen and serve on 0.0.0.0:8080
diff --git a/context.go b/context.go
index 724ded79..bbdb7e4f 100644
--- a/context.go
+++ b/context.go
@@ -511,6 +511,11 @@ func (c *Context) BindJSON(obj interface{}) error {
 	return c.MustBindWith(obj, binding.JSON)
 }
 
+// BindXML is a shortcut for c.MustBindWith(obj, binding.BindXML).
+func (c *Context) BindXML(obj interface{}) error {
+	return c.MustBindWith(obj, binding.XML)
+}
+
 // BindQuery is a shortcut for c.MustBindWith(obj, binding.Query).
 func (c *Context) BindQuery(obj interface{}) error {
 	return c.MustBindWith(obj, binding.Query)
@@ -545,6 +550,11 @@ func (c *Context) ShouldBindJSON(obj interface{}) error {
 	return c.ShouldBindWith(obj, binding.JSON)
 }
 
+// ShouldBindXML is a shortcut for c.ShouldBindWith(obj, binding.XML).
+func (c *Context) ShouldBindXML(obj interface{}) error {
+	return c.ShouldBindWith(obj, binding.XML)
+}
+
 // ShouldBindQuery is a shortcut for c.ShouldBindWith(obj, binding.Query).
 func (c *Context) ShouldBindQuery(obj interface{}) error {
 	return c.ShouldBindWith(obj, binding.Query)
diff --git a/context_test.go b/context_test.go
index 99d5267d..13fb9099 100644
--- a/context_test.go
+++ b/context_test.go
@@ -1302,6 +1302,26 @@ func TestContextBindWithJSON(t *testing.T) {
 	assert.Equal(t, "bar", obj.Foo)
 	assert.Equal(t, 0, w.Body.Len())
 }
+func TestContextBindWithXML(t *testing.T) {
+	w := httptest.NewRecorder()
+	c, _ := CreateTestContext(w)
+
+	c.Request, _ = http.NewRequest("POST", "/", bytes.NewBufferString(`<?xml version="1.0" encoding="UTF-8"?>
+		<root>
+			<foo>FOO</foo>
+		   	<bar>BAR</bar>
+		</root>`))
+	c.Request.Header.Add("Content-Type", MIMEXML) // set fake content-type
+
+	var obj struct {
+		Foo string `xml:"foo"`
+		Bar string `xml:"bar"`
+	}
+	assert.NoError(t, c.BindXML(&obj))
+	assert.Equal(t, "FOO", obj.Foo)
+	assert.Equal(t, "BAR", obj.Bar)
+	assert.Equal(t, 0, w.Body.Len())
+}
 
 func TestContextBindWithQuery(t *testing.T) {
 	w := httptest.NewRecorder()
@@ -1372,6 +1392,27 @@ func TestContextShouldBindWithJSON(t *testing.T) {
 	assert.Equal(t, 0, w.Body.Len())
 }
 
+func TestContextShouldBindWithXML(t *testing.T) {
+	w := httptest.NewRecorder()
+	c, _ := CreateTestContext(w)
+
+	c.Request, _ = http.NewRequest("POST", "/", bytes.NewBufferString(`<?xml version="1.0" encoding="UTF-8"?>
+		<root>
+			<foo>FOO</foo>
+		   	<bar>BAR</bar>
+		</root>`))
+	c.Request.Header.Add("Content-Type", MIMEXML) // set fake content-type
+
+	var obj struct {
+		Foo string `xml:"foo"`
+		Bar string `xml:"bar"`
+	}
+	assert.NoError(t, c.ShouldBindXML(&obj))
+	assert.Equal(t, "FOO", obj.Foo)
+	assert.Equal(t, "BAR", obj.Bar)
+	assert.Equal(t, 0, w.Body.Len())
+}
+
 func TestContextShouldBindWithQuery(t *testing.T) {
 	w := httptest.NewRecorder()
 	c, _ := CreateTestContext(w)

From 7eb0f74b89af91b609f910f549e312a5c5db2ada Mon Sep 17 00:00:00 2001
From: Alexander Lokhman <alex.lokhman@gmail.com>
Date: Fri, 17 Aug 2018 02:41:56 +0100
Subject: [PATCH 037/105] Set default time format in form binding (#1487)

---
 binding/form_mapping.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/binding/form_mapping.go b/binding/form_mapping.go
index 3f6b9bfa..a714291f 100644
--- a/binding/form_mapping.go
+++ b/binding/form_mapping.go
@@ -178,7 +178,7 @@ func setFloatField(val string, bitSize int, field reflect.Value) error {
 func setTimeField(val string, structField reflect.StructField, value reflect.Value) error {
 	timeFormat := structField.Tag.Get("time_format")
 	if timeFormat == "" {
-		return errors.New("Blank time format")
+		timeFormat = time.RFC3339
 	}
 
 	if val == "" {

From a643d206054d630f66fce6513db80d864159030a Mon Sep 17 00:00:00 2001
From: Eason Lin <easonlin404@gmail.com>
Date: Fri, 17 Aug 2018 11:21:14 +0800
Subject: [PATCH 038/105] readme: fix users link (#1493)

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 5de22dc3..37eec614 100644
--- a/README.md
+++ b/README.md
@@ -59,7 +59,7 @@ Gin is a web framework written in Go (Golang). It features a martini-like API wi
     - [Try to bind body into different structs](#try-to-bind-body-into-different-structs)
     - [http2 server push](#http2-server-push)
 - [Testing](#testing)
-- [Users](#users--)
+- [Users](#users)
 
 ## Installation
 

From f5451bd645be353ba40cd5d308a545f201e68283 Mon Sep 17 00:00:00 2001
From: David Zhang <crispgm@gmail.com>
Date: Fri, 17 Aug 2018 11:33:23 +0800
Subject: [PATCH 039/105] Fix typo in README [ci skip] (#1492)

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 37eec614..920b634b 100644
--- a/README.md
+++ b/README.md
@@ -198,7 +198,7 @@ BenchmarkVulcan_GithubAll                   |    5000    |   394253    |   19894
 
 ## Build with [jsoniter](https://github.com/json-iterator/go)
 
-Gin use `encoding/json` as default json package but you can change to [jsoniter](https://github.com/json-iterator/go) by build from other tags.
+Gin uses `encoding/json` as default json package but you can change to [jsoniter](https://github.com/json-iterator/go) by build from other tags.
 
 ```sh
 $ go build -tags=jsoniter .

From f856aa85cd175ad10d2f55b0a41a51a08f4bdb02 Mon Sep 17 00:00:00 2001
From: chainhelen <chainhelen@gmail.com>
Date: Fri, 17 Aug 2018 14:59:55 +0800
Subject: [PATCH 040/105] Update readme about the version of gin (#1494)

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 920b634b..161ea28b 100644
--- a/README.md
+++ b/README.md
@@ -100,7 +100,7 @@ $ mkdir -p $GOPATH/src/github.com/myusername/project && cd "$_"
 
 ```sh
 $ govendor init
-$ govendor fetch github.com/gin-gonic/gin@v1.2
+$ govendor fetch github.com/gin-gonic/gin@v1.3
 ```
 
 4. Copy a starting template inside your project

From efdd3c8b81a42e1769fe70483d4828d5bba7e87e Mon Sep 17 00:00:00 2001
From: aljun <salameryy@163.com>
Date: Sun, 19 Aug 2018 10:45:56 +0800
Subject: [PATCH 041/105] Add support for Protobuf format response and unit
 test (#1479)

`Gin` now have the `protobufBinding` function to check the request format, but didn't have a protobuf response function like `c.YAML()`.
In our company [ByteDance](http://bytedance.com/), the largest internet company using golang in China, we use `gin` to transfer __Protobuf__  instead of __Json__, we have to write some internal library to make some wrappers to achieve that, and the code is not elegant. So we really want such a feature.
---
 README.md             | 17 +++++++++++++++--
 context.go            |  6 ++++++
 context_test.go       | 27 +++++++++++++++++++++++++++
 render/protobuf.go    | 33 +++++++++++++++++++++++++++++++++
 render/render.go      |  1 +
 render/render_test.go | 31 +++++++++++++++++++++++++++++++
 6 files changed, 113 insertions(+), 2 deletions(-)
 create mode 100644 render/protobuf.go

diff --git a/README.md b/README.md
index 161ea28b..ae183f92 100644
--- a/README.md
+++ b/README.md
@@ -40,7 +40,7 @@ Gin is a web framework written in Go (Golang). It features a martini-like API wi
     - [Bind Query String or Post Data](#bind-query-string-or-post-data)
     - [Bind HTML checkboxes](#bind-html-checkboxes)
     - [Multipart/Urlencoded binding](#multiparturlencoded-binding)
-    - [XML, JSON and YAML rendering](#xml-json-and-yaml-rendering)
+    - [XML, JSON, YAML and ProtoBuf rendering](#xml-json-yaml-and-protobuf-rendering)
     - [JSONP rendering](#jsonp)
     - [Serving static files](#serving-static-files)
     - [Serving data from reader](#serving-data-from-reader)
@@ -871,7 +871,7 @@ Test it with:
 $ curl -v --form user=user --form password=password http://localhost:8080/login
 ```
 
-### XML, JSON and YAML rendering
+### XML, JSON, YAML and ProtoBuf rendering
 
 ```go
 func main() {
@@ -905,6 +905,19 @@ func main() {
 		c.YAML(http.StatusOK, gin.H{"message": "hey", "status": http.StatusOK})
 	})
 
+	r.GET("/someProtoBuf", func(c *gin.Context) {
+		reps := []int64{int64(1), int64(2)}
+		label := "test"
+		// The specific definition of protobuf is written in the testdata/protoexample file.
+		data := &protoexample.Test{
+			Label: &label,
+			Reps:  reps,
+		}
+		// Note that data becomes binary data in the response
+		// Will output protoexample.Test protobuf serialized data
+		c.ProtoBuf(http.StatusOK, data)
+	})
+
 	// Listen and serve on 0.0.0.0:8080
 	r.Run(":8080")
 }
diff --git a/context.go b/context.go
index bbdb7e4f..5cd52837 100644
--- a/context.go
+++ b/context.go
@@ -20,6 +20,7 @@ import (
 	"github.com/gin-contrib/sse"
 	"github.com/gin-gonic/gin/binding"
 	"github.com/gin-gonic/gin/render"
+	"github.com/golang/protobuf/proto"
 )
 
 // Content-Type MIME of the most common data formats.
@@ -845,6 +846,11 @@ func (c *Context) Stream(step func(w io.Writer) bool) {
 	}
 }
 
+// ProtoBuf serializes the given struct as ProtoBuf into the response body.
+func (c *Context) ProtoBuf(code int, obj proto.Message) {
+	c.Render(code, render.ProtoBuf{Data: obj})
+}
+
 /************************************/
 /******** CONTENT NEGOTIATION *******/
 /************************************/
diff --git a/context_test.go b/context_test.go
index 13fb9099..675c2a49 100644
--- a/context_test.go
+++ b/context_test.go
@@ -20,8 +20,11 @@ import (
 
 	"github.com/gin-contrib/sse"
 	"github.com/gin-gonic/gin/binding"
+	"github.com/golang/protobuf/proto"
 	"github.com/stretchr/testify/assert"
 	"golang.org/x/net/context"
+
+	testdata "github.com/gin-gonic/gin/testdata/protoexample"
 )
 
 var _ context.Context = &Context{}
@@ -954,6 +957,30 @@ func TestContextRenderYAML(t *testing.T) {
 	assert.Equal(t, "application/x-yaml; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
 
+// TestContextRenderProtoBuf tests that the response is serialized as ProtoBuf
+// and Content-Type is set to application/x-protobuf
+// and we just use the example protobuf to check if the response is correct
+func TestContextRenderProtoBuf(t *testing.T) {
+	w := httptest.NewRecorder()
+	c, _ := CreateTestContext(w)
+
+	reps := []int64{int64(1), int64(2)}
+	label := "test"
+	data := &testdata.Test{
+		Label: &label,
+		Reps:  reps,
+	}
+
+	c.ProtoBuf(http.StatusCreated, data)
+
+	protoData, err := proto.Marshal(data)
+	assert.NoError(t, err)
+
+	assert.Equal(t, http.StatusCreated, w.Code)
+	assert.Equal(t, string(protoData[:]), w.Body.String())
+	assert.Equal(t, "application/x-protobuf", w.HeaderMap.Get("Content-Type"))
+}
+
 func TestContextHeaders(t *testing.T) {
 	c, _ := CreateTestContext(httptest.NewRecorder())
 	c.Header("Content-Type", "text/plain")
diff --git a/render/protobuf.go b/render/protobuf.go
new file mode 100644
index 00000000..fe826884
--- /dev/null
+++ b/render/protobuf.go
@@ -0,0 +1,33 @@
+// Copyright 2018 Gin Core Team.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package render
+
+import (
+	"net/http"
+
+	"github.com/golang/protobuf/proto"
+)
+
+type ProtoBuf struct {
+	Data proto.Message
+}
+
+var protobufContentType = []string{"application/x-protobuf"}
+
+func (r ProtoBuf) Render(w http.ResponseWriter) error {
+	r.WriteContentType(w)
+
+	bytes, err := proto.Marshal(r.Data)
+	if err != nil {
+		return err
+	}
+
+	w.Write(bytes)
+	return nil
+}
+
+func (r ProtoBuf) WriteContentType(w http.ResponseWriter) {
+	writeContentType(w, protobufContentType)
+}
diff --git a/render/render.go b/render/render.go
index 4ff1c7b6..df0d1d7c 100755
--- a/render/render.go
+++ b/render/render.go
@@ -27,6 +27,7 @@ var (
 	_ Render     = MsgPack{}
 	_ Render     = Reader{}
 	_ Render     = AsciiJSON{}
+	_ Render     = ProtoBuf{}
 )
 
 func writeContentType(w http.ResponseWriter, value []string) {
diff --git a/render/render_test.go b/render/render_test.go
index 47abf262..905b76a1 100755
--- a/render/render_test.go
+++ b/render/render_test.go
@@ -15,6 +15,8 @@ import (
 	"strings"
 	"testing"
 
+	testdata "github.com/gin-gonic/gin/testdata/protoexample"
+	"github.com/golang/protobuf/proto"
 	"github.com/stretchr/testify/assert"
 	"github.com/ugorji/go/codec"
 )
@@ -265,6 +267,35 @@ func TestRenderYAMLFail(t *testing.T) {
 	assert.Error(t, err)
 }
 
+// test Protobuf rendering
+func TestRenderProtoBuf(t *testing.T) {
+	w := httptest.NewRecorder()
+	reps := []int64{int64(1), int64(2)}
+	label := "test"
+	data := &testdata.Test{
+		Label: &label,
+		Reps:  reps,
+	}
+
+	(ProtoBuf{data}).WriteContentType(w)
+	protoData, err := proto.Marshal(data)
+	assert.NoError(t, err)
+	assert.Equal(t, "application/x-protobuf", w.Header().Get("Content-Type"))
+
+	err = (ProtoBuf{data}).Render(w)
+
+	assert.NoError(t, err)
+	assert.Equal(t, string(protoData[:]), w.Body.String())
+	assert.Equal(t, "application/x-protobuf", w.Header().Get("Content-Type"))
+}
+
+func TestRenderProtoBufFail(t *testing.T) {
+	w := httptest.NewRecorder()
+	data := &testdata.Test{}
+	err := (ProtoBuf{data}).Render(w)
+	assert.Error(t, err)
+}
+
 func TestRenderXML(t *testing.T) {
 	w := httptest.NewRecorder()
 	data := xmlmap{

From 6073a79ee08657ea9784c26b8521a8f8ef9e1644 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Sun, 19 Aug 2018 17:39:58 +0800
Subject: [PATCH 042/105] not use protobuf on context but use it on render
 (#1496)

---
 context.go            | 11 +++++------
 render/json.go        |  0
 render/protobuf.go    |  4 ++--
 render/render.go      |  0
 render/render_test.go |  3 ++-
 5 files changed, 9 insertions(+), 9 deletions(-)
 mode change 100755 => 100644 render/json.go
 mode change 100755 => 100644 render/render.go
 mode change 100755 => 100644 render/render_test.go

diff --git a/context.go b/context.go
index 5cd52837..6d80284e 100644
--- a/context.go
+++ b/context.go
@@ -20,7 +20,6 @@ import (
 	"github.com/gin-contrib/sse"
 	"github.com/gin-gonic/gin/binding"
 	"github.com/gin-gonic/gin/render"
-	"github.com/golang/protobuf/proto"
 )
 
 // Content-Type MIME of the most common data formats.
@@ -784,6 +783,11 @@ func (c *Context) YAML(code int, obj interface{}) {
 	c.Render(code, render.YAML{Data: obj})
 }
 
+// ProtoBuf serializes the given struct as ProtoBuf into the response body.
+func (c *Context) ProtoBuf(code int, obj interface{}) {
+	c.Render(code, render.ProtoBuf{Data: obj})
+}
+
 // String writes the given string into the response body.
 func (c *Context) String(code int, format string, values ...interface{}) {
 	c.Render(code, render.String{Format: format, Data: values})
@@ -846,11 +850,6 @@ func (c *Context) Stream(step func(w io.Writer) bool) {
 	}
 }
 
-// ProtoBuf serializes the given struct as ProtoBuf into the response body.
-func (c *Context) ProtoBuf(code int, obj proto.Message) {
-	c.Render(code, render.ProtoBuf{Data: obj})
-}
-
 /************************************/
 /******** CONTENT NEGOTIATION *******/
 /************************************/
diff --git a/render/json.go b/render/json.go
old mode 100755
new mode 100644
diff --git a/render/protobuf.go b/render/protobuf.go
index fe826884..34f1e9b5 100644
--- a/render/protobuf.go
+++ b/render/protobuf.go
@@ -11,7 +11,7 @@ import (
 )
 
 type ProtoBuf struct {
-	Data proto.Message
+	Data interface{}
 }
 
 var protobufContentType = []string{"application/x-protobuf"}
@@ -19,7 +19,7 @@ var protobufContentType = []string{"application/x-protobuf"}
 func (r ProtoBuf) Render(w http.ResponseWriter) error {
 	r.WriteContentType(w)
 
-	bytes, err := proto.Marshal(r.Data)
+	bytes, err := proto.Marshal(r.Data.(proto.Message))
 	if err != nil {
 		return err
 	}
diff --git a/render/render.go b/render/render.go
old mode 100755
new mode 100644
diff --git a/render/render_test.go b/render/render_test.go
old mode 100755
new mode 100644
index 905b76a1..cd20d01d
--- a/render/render_test.go
+++ b/render/render_test.go
@@ -15,10 +15,11 @@ import (
 	"strings"
 	"testing"
 
-	testdata "github.com/gin-gonic/gin/testdata/protoexample"
 	"github.com/golang/protobuf/proto"
 	"github.com/stretchr/testify/assert"
 	"github.com/ugorji/go/codec"
+
+	testdata "github.com/gin-gonic/gin/testdata/protoexample"
 )
 
 // TODO unit tests

From 32b58e0fd2b101cc0bedc925ac71f1bbca620869 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Sun, 19 Aug 2018 22:14:02 +0800
Subject: [PATCH 043/105] render: update msgpack usage (#1498)

please see msgpack usage: https://github.com/ugorji/go/tree/master/codec#usage
---
 render/msgpack.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/render/msgpack.go b/render/msgpack.go
index e6c13e58..b6b8aa0f 100644
--- a/render/msgpack.go
+++ b/render/msgpack.go
@@ -26,6 +26,6 @@ func (r MsgPack) Render(w http.ResponseWriter) error {
 
 func WriteMsgPack(w http.ResponseWriter, obj interface{}) error {
 	writeContentType(w, msgpackContentType)
-	var h codec.Handle = new(codec.MsgpackHandle)
-	return codec.NewEncoder(w, h).Encode(obj)
+	var mh codec.MsgpackHandle
+	return codec.NewEncoder(w, &mh).Encode(obj)
 }

From b7bb9baa642d2b9d5918a5bcd3829dae64c65257 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Sun, 19 Aug 2018 22:52:43 +0800
Subject: [PATCH 044/105] chore: add missing copyright and update if/else
 (#1497)

---
 render/reader.go | 4 ++++
 render/text.go   | 4 ++--
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/render/reader.go b/render/reader.go
index be2132c8..7a06cce4 100644
--- a/render/reader.go
+++ b/render/reader.go
@@ -1,3 +1,7 @@
+// Copyright 2018 Gin Core Team.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
 package render
 
 import (
diff --git a/render/text.go b/render/text.go
index 74cd26be..7a6acc44 100644
--- a/render/text.go
+++ b/render/text.go
@@ -30,7 +30,7 @@ func WriteString(w http.ResponseWriter, format string, data []interface{}) {
 	writeContentType(w, plainContentType)
 	if len(data) > 0 {
 		fmt.Fprintf(w, format, data...)
-	} else {
-		io.WriteString(w, format)
+		return
 	}
+	io.WriteString(w, format)
 }

From c6110f970ca5af365283bd4083b8a105e974e92c Mon Sep 17 00:00:00 2001
From: Filip Figiel <figiel.filip@gmail.com>
Date: Mon, 20 Aug 2018 09:15:31 +0200
Subject: [PATCH 045/105] Add PureJSON renderer (#694)

Closes #693
---
 README.md                | 28 ++++++++++++++++++++++++++++
 context_17.go            | 17 +++++++++++++++++
 context_17_test.go       | 27 +++++++++++++++++++++++++++
 context_test.go          |  5 +++--
 json/json.go             |  1 +
 render/json_17.go        | 28 ++++++++++++++++++++++++++++
 render/render_17_test.go | 26 ++++++++++++++++++++++++++
 render/render_test.go    |  5 +++--
 8 files changed, 133 insertions(+), 4 deletions(-)
 create mode 100644 context_17.go
 create mode 100644 context_17_test.go
 create mode 100644 render/json_17.go
 create mode 100644 render/render_17_test.go

diff --git a/README.md b/README.md
index ae183f92..053750bb 100644
--- a/README.md
+++ b/README.md
@@ -991,6 +991,34 @@ func main() {
 }
 ```
 
+#### PureJSON
+
+Normally, JSON replaces special HTML characters with their unicode entities, e.g. `<` becomes  `\u003c`. If you want to encode such characters literally, you can use PureJSON instead.
+This feature is unavailable in Go 1.6 and lower.
+
+```go
+func main() {
+	r := gin.Default()
+	
+	// Serves unicode entities
+	r.GET("/json", func(c *gin.Context) {
+		c.JSON(200, gin.H{
+			"html": "<b>Hello, world!</b>",
+		})
+	})
+	
+	// Serves literal characters
+	r.GET("/purejson", func(c *gin.Context) {
+		c.PureJSON(200, gin.H{
+			"html": "<b>Hello, world!</b>",
+		})
+	})
+	
+	// listen and serve on 0.0.0.0:8080
+	r.Run(":8080)
+}
+```
+
 ### Serving static files
 
 ```go
diff --git a/context_17.go b/context_17.go
new file mode 100644
index 00000000..8e9f75ad
--- /dev/null
+++ b/context_17.go
@@ -0,0 +1,17 @@
+// Copyright 2018 Gin Core Team.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+// +build go1.7
+
+package gin
+
+import (
+	"github.com/gin-gonic/gin/render"
+)
+
+// PureJSON serializes the given struct as JSON into the response body.
+// PureJSON, unlike JSON, does not replace special html characters with their unicode entities.
+func (c *Context) PureJSON(code int, obj interface{}) {
+	c.Render(code, render.PureJSON{Data: obj})
+}
diff --git a/context_17_test.go b/context_17_test.go
new file mode 100644
index 00000000..d2251904
--- /dev/null
+++ b/context_17_test.go
@@ -0,0 +1,27 @@
+// Copyright 2018 Gin Core Team.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+// +build go1.7
+
+package gin
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+// Tests that the response is serialized as JSON
+// and Content-Type is set to application/json
+// and special HTML characters are preserved
+func TestContextRenderPureJSON(t *testing.T) {
+	w := httptest.NewRecorder()
+	c, _ := CreateTestContext(w)
+	c.PureJSON(http.StatusCreated, H{"foo": "bar", "html": "<b>"})
+	assert.Equal(t, http.StatusCreated, w.Code)
+	assert.Equal(t, "{\"foo\":\"bar\",\"html\":\"<b>\"}\n", w.Body.String())
+	assert.Equal(t, "application/json; charset=utf-8", w.HeaderMap.Get("Content-Type"))
+}
diff --git a/context_test.go b/context_test.go
index 675c2a49..782f7bed 100644
--- a/context_test.go
+++ b/context_test.go
@@ -619,14 +619,15 @@ func TestContextRenderPanicIfErr(t *testing.T) {
 
 // Tests that the response is serialized as JSON
 // and Content-Type is set to application/json
+// and special HTML characters are escaped
 func TestContextRenderJSON(t *testing.T) {
 	w := httptest.NewRecorder()
 	c, _ := CreateTestContext(w)
 
-	c.JSON(http.StatusCreated, H{"foo": "bar"})
+	c.JSON(http.StatusCreated, H{"foo": "bar", "html": "<b>"})
 
 	assert.Equal(t, http.StatusCreated, w.Code)
-	assert.Equal(t, "{\"foo\":\"bar\"}", w.Body.String())
+	assert.Equal(t, "{\"foo\":\"bar\",\"html\":\"\\u003cb\\u003e\"}", w.Body.String())
 	assert.Equal(t, "application/json; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
 
diff --git a/json/json.go b/json/json.go
index aa76aa30..4f643c56 100644
--- a/json/json.go
+++ b/json/json.go
@@ -12,4 +12,5 @@ var (
 	Marshal       = json.Marshal
 	MarshalIndent = json.MarshalIndent
 	NewDecoder    = json.NewDecoder
+	NewEncoder    = json.NewEncoder
 )
diff --git a/render/json_17.go b/render/json_17.go
new file mode 100644
index 00000000..df0dc145
--- /dev/null
+++ b/render/json_17.go
@@ -0,0 +1,28 @@
+// Copyright 2018 Gin Core Team.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+// +build go1.7
+
+package render
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin/json"
+)
+
+type PureJSON struct {
+	Data interface{}
+}
+
+func (r PureJSON) Render(w http.ResponseWriter) error {
+	r.WriteContentType(w)
+	encoder := json.NewEncoder(w)
+	encoder.SetEscapeHTML(false)
+	return encoder.Encode(r.Data)
+}
+
+func (r PureJSON) WriteContentType(w http.ResponseWriter) {
+	writeContentType(w, jsonContentType)
+}
diff --git a/render/render_17_test.go b/render/render_17_test.go
new file mode 100644
index 00000000..68330090
--- /dev/null
+++ b/render/render_17_test.go
@@ -0,0 +1,26 @@
+// Copyright 2018 Gin Core Team.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+// +build go1.7
+
+package render
+
+import (
+	"net/http/httptest"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestRenderPureJSON(t *testing.T) {
+	w := httptest.NewRecorder()
+	data := map[string]interface{}{
+		"foo":  "bar",
+		"html": "<b>",
+	}
+	err := (PureJSON{data}).Render(w)
+	assert.NoError(t, err)
+	assert.Equal(t, "{\"foo\":\"bar\",\"html\":\"<b>\"}\n", w.Body.String())
+	assert.Equal(t, "application/json; charset=utf-8", w.Header().Get("Content-Type"))
+}
diff --git a/render/render_test.go b/render/render_test.go
index cd20d01d..fe9228e9 100644
--- a/render/render_test.go
+++ b/render/render_test.go
@@ -52,7 +52,8 @@ func TestRenderMsgPack(t *testing.T) {
 func TestRenderJSON(t *testing.T) {
 	w := httptest.NewRecorder()
 	data := map[string]interface{}{
-		"foo": "bar",
+		"foo":  "bar",
+		"html": "<b>",
 	}
 
 	(JSON{data}).WriteContentType(w)
@@ -61,7 +62,7 @@ func TestRenderJSON(t *testing.T) {
 	err := (JSON{data}).Render(w)
 
 	assert.NoError(t, err)
-	assert.Equal(t, "{\"foo\":\"bar\"}", w.Body.String())
+	assert.Equal(t, "{\"foo\":\"bar\",\"html\":\"\\u003cb\\u003e\"}", w.Body.String())
 	assert.Equal(t, "application/json; charset=utf-8", w.Header().Get("Content-Type"))
 }
 

From 0ebd42d0a921e49ed6a36fae33f2a2dcae800d6f Mon Sep 17 00:00:00 2001
From: junfengye <junfeng.yejf@gmail.com>
Date: Mon, 20 Aug 2018 18:25:45 +0800
Subject: [PATCH 046/105] Update jsoniter.go (#1500)

add newencoder to fix compile error for -tags=jsoniter
---
 json/jsoniter.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/json/jsoniter.go b/json/jsoniter.go
index ffe1424a..f1ed5bea 100644
--- a/json/jsoniter.go
+++ b/json/jsoniter.go
@@ -13,4 +13,5 @@ var (
 	Marshal       = json.Marshal
 	MarshalIndent = json.MarshalIndent
 	NewDecoder    = json.NewDecoder
+	NewEncoder    = json.NewEncoder
 )

From 85f3e78abcd408e7e155f58f72094446c4411e91 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Mon, 20 Aug 2018 21:49:24 +0800
Subject: [PATCH 047/105] chore: remove else instead of return/continue (#1502)

As[ Effective Go](https://golang.org/doc/effective_go.html?#if) about `if` said, remove else statement instead of return/continue statement.
---
 binding/form_mapping.go | 16 ++++++++--------
 context.go              |  8 ++++----
 render/json.go          |  6 ++----
 3 files changed, 14 insertions(+), 16 deletions(-)

diff --git a/binding/form_mapping.go b/binding/form_mapping.go
index a714291f..f46a0dc1 100644
--- a/binding/form_mapping.go
+++ b/binding/form_mapping.go
@@ -74,16 +74,16 @@ func mapForm(ptr interface{}, form map[string][]string) error {
 				}
 			}
 			val.Field(i).Set(slice)
-		} else {
-			if _, isTime := structField.Interface().(time.Time); isTime {
-				if err := setTimeField(inputValue[0], typeField, structField); err != nil {
-					return err
-				}
-				continue
-			}
-			if err := setWithProperType(typeField.Type.Kind(), inputValue[0], structField); err != nil {
+			continue
+		}
+		if _, isTime := structField.Interface().(time.Time); isTime {
+			if err := setTimeField(inputValue[0], typeField, structField); err != nil {
 				return err
 			}
+			continue
+		}
+		if err := setWithProperType(typeField.Type.Kind(), inputValue[0], structField); err != nil {
+			return err
 		}
 	}
 	return nil
diff --git a/context.go b/context.go
index 6d80284e..063c72f0 100644
--- a/context.go
+++ b/context.go
@@ -665,9 +665,9 @@ func (c *Context) Status(code int) {
 func (c *Context) Header(key, value string) {
 	if value == "" {
 		c.Writer.Header().Del(key)
-	} else {
-		c.Writer.Header().Set(key, value)
+		return
 	}
+	c.Writer.Header().Set(key, value)
 }
 
 // GetHeader returns value from request headers.
@@ -755,9 +755,9 @@ func (c *Context) JSONP(code int, obj interface{}) {
 	callback := c.DefaultQuery("callback", "")
 	if callback == "" {
 		c.Render(code, render.JSON{Data: obj})
-	} else {
-		c.Render(code, render.JsonpJSON{Callback: callback, Data: obj})
+		return
 	}
+	c.Render(code, render.JsonpJSON{Callback: callback, Data: obj})
 }
 
 // JSON serializes the given struct as JSON into the response body.
diff --git a/render/json.go b/render/json.go
index 6e5089a0..4d1857f5 100644
--- a/render/json.go
+++ b/render/json.go
@@ -128,10 +128,8 @@ func (r AsciiJSON) Render(w http.ResponseWriter) (err error) {
 
 	var buffer bytes.Buffer
 	for _, r := range string(ret) {
-		cvt := ""
-		if r < 128 {
-			cvt = string(r)
-		} else {
+		cvt := string(r)
+		if r >= 128 {
 			cvt = fmt.Sprintf("\\u%04x", int64(r))
 		}
 		buffer.WriteString(cvt)

From 0da5b0c85ac2539e775a7e63aebf3e0b5808dab4 Mon Sep 17 00:00:00 2001
From: anoty <anjunyou@foxmail.com>
Date: Tue, 21 Aug 2018 13:29:25 +0800
Subject: [PATCH 048/105] format readme code import (#1503)

---
 README.md | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 053750bb..9f66dd76 100644
--- a/README.md
+++ b/README.md
@@ -750,9 +750,12 @@ See the [detail information](https://github.com/gin-gonic/gin/issues/742#issueco
 ```go
 package main
 
-import "log"
-import "github.com/gin-gonic/gin"
-import "time"
+import (
+	"log"
+	"time"
+
+	"github.com/gin-gonic/gin"
+)
 
 type Person struct {
 	Name     string    `form:"name"`

From 09d342abbc35e473bfbe11abaecdfe237df0630d Mon Sep 17 00:00:00 2001
From: Bo-Yi Wu <appleboy.tw@gmail.com>
Date: Thu, 30 Aug 2018 14:22:51 +0800
Subject: [PATCH 049/105] Add golang 1.11.x testing (#1514)

* Add golang 1.11.x testing

* remove the latest golang testing

See the issue: https://github.com/gin-gonic/gin/pull/1510
---
 .travis.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.travis.yml b/.travis.yml
index e9101568..a93458f9 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -6,7 +6,7 @@ go:
   - 1.8.x
   - 1.9.x
   - 1.10.x
-  - master
+  - 1.11.x
 
 git:
   depth: 10

From 708b76adf011840eb587d57804edf93b2ef4ba75 Mon Sep 17 00:00:00 2001
From: llgoer <yanghuxiao@vip.qq.com>
Date: Thu, 30 Aug 2018 14:29:26 +0800
Subject: [PATCH 050/105] Update README.md (#1509)

change  `ShouldBindXML` to `ShouldBindJSON`
---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 9f66dd76..7d13cf20 100644
--- a/README.md
+++ b/README.md
@@ -557,7 +557,7 @@ func main() {
 	// Example for binding JSON ({"user": "manu", "password": "123"})
 	router.POST("/loginJSON", func(c *gin.Context) {
 		var json Login
-		if err := c.ShouldBindXML(&json); err != nil {
+		if err := c.ShouldBindJSON(&json); err != nil {
 			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
 			return
 		}

From 72db8acd99feab85e81ac6e2ebd16c76e0f986be Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Thu, 30 Aug 2018 19:04:03 +0800
Subject: [PATCH 051/105] add internal package which includes json package
 (#1504)

---
 binding/json.go                     | 2 +-
 errors.go                           | 2 +-
 errors_test.go                      | 2 +-
 {json => internal/json}/json.go     | 0
 {json => internal/json}/jsoniter.go | 0
 render/json.go                      | 2 +-
 render/json_17.go                   | 2 +-
 7 files changed, 5 insertions(+), 5 deletions(-)
 rename {json => internal/json}/json.go (100%)
 rename {json => internal/json}/jsoniter.go (100%)

diff --git a/binding/json.go b/binding/json.go
index fea17bb2..310922c1 100644
--- a/binding/json.go
+++ b/binding/json.go
@@ -9,7 +9,7 @@ import (
 	"io"
 	"net/http"
 
-	"github.com/gin-gonic/gin/json"
+	"github.com/gin-gonic/gin/internal/json"
 )
 
 // EnableDecoderUseNumber is used to call the UseNumber method on the JSON
diff --git a/errors.go b/errors.go
index dbfccd85..6f90377e 100644
--- a/errors.go
+++ b/errors.go
@@ -9,7 +9,7 @@ import (
 	"fmt"
 	"reflect"
 
-	"github.com/gin-gonic/gin/json"
+	"github.com/gin-gonic/gin/internal/json"
 )
 
 type ErrorType uint64
diff --git a/errors_test.go b/errors_test.go
index 0626611f..9351b578 100644
--- a/errors_test.go
+++ b/errors_test.go
@@ -8,7 +8,7 @@ import (
 	"errors"
 	"testing"
 
-	"github.com/gin-gonic/gin/json"
+	"github.com/gin-gonic/gin/internal/json"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/json/json.go b/internal/json/json.go
similarity index 100%
rename from json/json.go
rename to internal/json/json.go
diff --git a/json/jsoniter.go b/internal/json/jsoniter.go
similarity index 100%
rename from json/jsoniter.go
rename to internal/json/jsoniter.go
diff --git a/render/json.go b/render/json.go
index 4d1857f5..f6b7878e 100644
--- a/render/json.go
+++ b/render/json.go
@@ -10,7 +10,7 @@ import (
 	"html/template"
 	"net/http"
 
-	"github.com/gin-gonic/gin/json"
+	"github.com/gin-gonic/gin/internal/json"
 )
 
 type JSON struct {
diff --git a/render/json_17.go b/render/json_17.go
index df0dc145..75f7f374 100644
--- a/render/json_17.go
+++ b/render/json_17.go
@@ -9,7 +9,7 @@ package render
 import (
 	"net/http"
 
-	"github.com/gin-gonic/gin/json"
+	"github.com/gin-gonic/gin/internal/json"
 )
 
 type PureJSON struct {

From 7451a402bbab9dd439b09aa377f18638c7d8fd55 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Thu, 30 Aug 2018 23:36:53 +0800
Subject: [PATCH 052/105] chore: update vendor version (#1520)

#1491 adds some lib when upgrade json-iterator but it is not needed, and use `v1.1.5` not `1.1.5` version for json-iterator.
---
 vendor/vendor.json | 28 ++--------------------------
 1 file changed, 2 insertions(+), 26 deletions(-)

diff --git a/vendor/vendor.json b/vendor/vendor.json
index e6d038a4..86df11be 100644
--- a/vendor/vendor.json
+++ b/vendor/vendor.json
@@ -27,8 +27,8 @@
 			"path": "github.com/json-iterator/go",
 			"revision": "1624edc4454b8682399def8740d46db5e4362ba4",
 			"revisionTime": "2018-08-06T06:07:27Z",
-			"version": "1.1.5",
-			"versionExact": "1.1.5"
+			"version": "v1.1",
+			"versionExact": "v1.1.5"
 		},
 		{
 			"checksumSHA1": "y/A5iuvwjytQE2CqVuphQRXR2nI=",
@@ -38,24 +38,6 @@
 			"version": "v0.0.3",
 			"versionExact": "v0.0.3"
 		},
-		{
-			"checksumSHA1": "ZTcgWKWHsrX0RXYVXn5Xeb8Q0go=",
-			"path": "github.com/modern-go/concurrent",
-			"revision": "bacd9c7ef1dd9b15be4a9909b8ac7a4e313eec94",
-			"revisionTime": "2018-03-06T01:26:44Z"
-		},
-		{
-			"checksumSHA1": "qvH48wzTIV3QKSDqI0dLFtVjaDI=",
-			"path": "github.com/modern-go/reflect2",
-			"revision": "94122c33edd36123c84d5368cfb2b69df93a0ec8",
-			"revisionTime": "2018-07-18T01:23:57Z"
-		},
-		{
-			"checksumSHA1": "LuFv4/jlrmFNnDb/5SCSEPAM9vU=",
-			"path": "github.com/pmezard/go-difflib/difflib",
-			"revision": "792786c7400a136282c1664665ae0a8db921c6c2",
-			"revisionTime": "2016-01-10T10:55:54Z"
-		},
 		{
 			"checksumSHA1": "c6pbpF7eowwO59phRTpF8cQ80Z0=",
 			"path": "github.com/stretchr/testify/assert",
@@ -79,12 +61,6 @@
 			"revision": "d4c55e66d8c3a2f3382d264b08e3e3454a66355a",
 			"revisionTime": "2016-10-18T08:54:36Z"
 		},
-		{
-			"checksumSHA1": "7Gocawl8bm27cpAILtuf21xvVD8=",
-			"path": "golang.org/x/sys/unix",
-			"revision": "1c9583448a9c3aa0f9a6a5241bf73c0bd8aafded",
-			"revisionTime": "2018-08-15T07:37:39Z"
-		},
 		{
 			"checksumSHA1": "P/k5ZGf0lEBgpKgkwy++F7K1PSg=",
 			"path": "gopkg.in/go-playground/validator.v8",

From 705e1992981b974ce131303cdf415ff78114f728 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Sat, 1 Sep 2018 00:40:33 +0800
Subject: [PATCH 053/105] chore: update issue_implate (#1524)

---
 .github/ISSUE_TEMPLATE.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/ISSUE_TEMPLATE.md b/.github/ISSUE_TEMPLATE.md
index de067ce0..9d49aa41 100644
--- a/.github/ISSUE_TEMPLATE.md
+++ b/.github/ISSUE_TEMPLATE.md
@@ -3,8 +3,8 @@
   - Please provide source code and commit sha if you found a bug.
   - Review existing issues and provide feedback or react to them.
 
+- go version:
 - gin version (or commit ref):
-- git version:
 - operating system:
 
 ## Description

From 500ebd9ea866c57427aeaddc31f374adedd4084b Mon Sep 17 00:00:00 2001
From: Javier Provecho Fernandez <javiertitan@gmail.com>
Date: Fri, 31 Aug 2018 22:38:16 +0200
Subject: [PATCH 054/105] docs: add fnproject to gin's user list (#1505)

---
 README.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 7d13cf20..a4bc4e76 100644
--- a/README.md
+++ b/README.md
@@ -1885,5 +1885,6 @@ func TestPingRoute(t *testing.T) {
 
 Awesome project lists using [Gin](https://github.com/gin-gonic/gin) web framework.
 
-* [drone](https://github.com/drone/drone): Drone is a Continuous Delivery platform built on Docker, written in Go
+* [drone](https://github.com/drone/drone): Drone is a Continuous Delivery platform built on Docker, written in Go.
 * [gorush](https://github.com/appleboy/gorush): A push notification server written in Go.
+* [fnproject](https://github.com/fnproject/fn): The container native, cloud agnostic serverless platform.

From df1e17c2f0ca7179b5acf03ce1da5c4f07c4dd7d Mon Sep 17 00:00:00 2001
From: "Iskander (Alex) Sharipov" <iskander.sharipov@intel.com>
Date: Wed, 12 Sep 2018 02:13:16 +0100
Subject: [PATCH 055/105] remove debug print statements from test code (#1540)

Found using https://go-critic.github.io/overview#commentedOutCode-ref
---
 tree_test.go | 11 -----------
 1 file changed, 11 deletions(-)

diff --git a/tree_test.go b/tree_test.go
index 5bc27171..152f6331 100644
--- a/tree_test.go
+++ b/tree_test.go
@@ -125,8 +125,6 @@ func TestTreeAddAndGet(t *testing.T) {
 		tree.addRoute(route, fakeHandler(route))
 	}
 
-	//printChildren(tree, "")
-
 	checkRequests(t, tree, testRequests{
 		{"/a", false, "/a", nil},
 		{"/", true, "", nil},
@@ -168,8 +166,6 @@ func TestTreeWildcard(t *testing.T) {
 		tree.addRoute(route, fakeHandler(route))
 	}
 
-	//printChildren(tree, "")
-
 	checkRequests(t, tree, testRequests{
 		{"/", false, "/", nil},
 		{"/cmd/test/", false, "/cmd/:tool/", Params{Param{"tool", "test"}}},
@@ -208,7 +204,6 @@ func TestUnescapeParameters(t *testing.T) {
 		tree.addRoute(route, fakeHandler(route))
 	}
 
-	//printChildren(tree, "")
 	unescape := true
 	checkRequests(t, tree, testRequests{
 		{"/", false, "/", nil},
@@ -260,8 +255,6 @@ func testRoutes(t *testing.T, routes []testRoute) {
 			t.Errorf("unexpected panic for route '%s': %v", route.path, recv)
 		}
 	}
-
-	//printChildren(tree, "")
 }
 
 func TestTreeWildcardConflict(t *testing.T) {
@@ -328,8 +321,6 @@ func TestTreeDupliatePath(t *testing.T) {
 		}
 	}
 
-	//printChildren(tree, "")
-
 	checkRequests(t, tree, testRequests{
 		{"/", false, "/", nil},
 		{"/doc/", false, "/doc/", nil},
@@ -444,8 +435,6 @@ func TestTreeTrailingSlashRedirect(t *testing.T) {
 		}
 	}
 
-	//printChildren(tree, "")
-
 	tsrRoutes := [...]string{
 		"/hi/",
 		"/b",

From 3f27866f806536be319b3e342001dd4e0fb81691 Mon Sep 17 00:00:00 2001
From: "Iskander (Alex) Sharipov" <iskander.sharipov@intel.com>
Date: Wed, 12 Sep 2018 14:21:26 +0100
Subject: [PATCH 056/105] simplify slice expressions: s[:] => s (#1541)

Found using https://go-critic.github.io/overview#unslice-ref
---
 context_test.go       |  2 +-
 gin_test.go           | 20 ++++++++++----------
 render/render_test.go |  2 +-
 3 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/context_test.go b/context_test.go
index 782f7bed..4c307080 100644
--- a/context_test.go
+++ b/context_test.go
@@ -978,7 +978,7 @@ func TestContextRenderProtoBuf(t *testing.T) {
 	assert.NoError(t, err)
 
 	assert.Equal(t, http.StatusCreated, w.Code)
-	assert.Equal(t, string(protoData[:]), w.Body.String())
+	assert.Equal(t, string(protoData), w.Body.String())
 	assert.Equal(t, "application/x-protobuf", w.HeaderMap.Get("Content-Type"))
 }
 
diff --git a/gin_test.go b/gin_test.go
index b3cab715..95b9cc16 100644
--- a/gin_test.go
+++ b/gin_test.go
@@ -88,7 +88,7 @@ func TestLoadHTMLGlob(t *testing.T) {
 	}
 
 	resp, _ := ioutil.ReadAll(res.Body)
-	assert.Equal(t, "<h1>Hello world</h1>", string(resp[:]))
+	assert.Equal(t, "<h1>Hello world</h1>", string(resp))
 
 	td()
 }
@@ -101,7 +101,7 @@ func TestLoadHTMLGlob2(t *testing.T) {
 	}
 
 	resp, _ := ioutil.ReadAll(res.Body)
-	assert.Equal(t, "<h1>Hello world</h1>", string(resp[:]))
+	assert.Equal(t, "<h1>Hello world</h1>", string(resp))
 
 	td()
 }
@@ -114,7 +114,7 @@ func TestLoadHTMLGlob3(t *testing.T) {
 	}
 
 	resp, _ := ioutil.ReadAll(res.Body)
-	assert.Equal(t, "<h1>Hello world</h1>", string(resp[:]))
+	assert.Equal(t, "<h1>Hello world</h1>", string(resp))
 
 	td()
 }
@@ -134,7 +134,7 @@ func TestLoadHTMLGlobUsingTLS(t *testing.T) {
 	}
 
 	resp, _ := ioutil.ReadAll(res.Body)
-	assert.Equal(t, "<h1>Hello world</h1>", string(resp[:]))
+	assert.Equal(t, "<h1>Hello world</h1>", string(resp))
 
 	td()
 }
@@ -148,7 +148,7 @@ func TestLoadHTMLGlobFromFuncMap(t *testing.T) {
 	}
 
 	resp, _ := ioutil.ReadAll(res.Body)
-	assert.Equal(t, "Date: 2017/07/01\n", string(resp[:]))
+	assert.Equal(t, "Date: 2017/07/01\n", string(resp))
 
 	td()
 }
@@ -187,7 +187,7 @@ func TestLoadHTMLFiles(t *testing.T) {
 	}
 
 	resp, _ := ioutil.ReadAll(res.Body)
-	assert.Equal(t, "<h1>Hello world</h1>", string(resp[:]))
+	assert.Equal(t, "<h1>Hello world</h1>", string(resp))
 	td()
 }
 
@@ -199,7 +199,7 @@ func TestLoadHTMLFiles2(t *testing.T) {
 	}
 
 	resp, _ := ioutil.ReadAll(res.Body)
-	assert.Equal(t, "<h1>Hello world</h1>", string(resp[:]))
+	assert.Equal(t, "<h1>Hello world</h1>", string(resp))
 	td()
 }
 
@@ -211,7 +211,7 @@ func TestLoadHTMLFiles3(t *testing.T) {
 	}
 
 	resp, _ := ioutil.ReadAll(res.Body)
-	assert.Equal(t, "<h1>Hello world</h1>", string(resp[:]))
+	assert.Equal(t, "<h1>Hello world</h1>", string(resp))
 	td()
 }
 
@@ -230,7 +230,7 @@ func TestLoadHTMLFilesUsingTLS(t *testing.T) {
 	}
 
 	resp, _ := ioutil.ReadAll(res.Body)
-	assert.Equal(t, "<h1>Hello world</h1>", string(resp[:]))
+	assert.Equal(t, "<h1>Hello world</h1>", string(resp))
 	td()
 }
 
@@ -243,7 +243,7 @@ func TestLoadHTMLFilesFuncMap(t *testing.T) {
 	}
 
 	resp, _ := ioutil.ReadAll(res.Body)
-	assert.Equal(t, "Date: 2017/07/01\n", string(resp[:]))
+	assert.Equal(t, "Date: 2017/07/01\n", string(resp))
 
 	td()
 }
diff --git a/render/render_test.go b/render/render_test.go
index fe9228e9..09ccc658 100644
--- a/render/render_test.go
+++ b/render/render_test.go
@@ -287,7 +287,7 @@ func TestRenderProtoBuf(t *testing.T) {
 	err = (ProtoBuf{data}).Render(w)
 
 	assert.NoError(t, err)
-	assert.Equal(t, string(protoData[:]), w.Body.String())
+	assert.Equal(t, string(protoData), w.Body.String())
 	assert.Equal(t, "application/x-protobuf", w.Header().Get("Content-Type"))
 }
 

From d510595aa58c2417373d89a8d8ffa21cf58673cb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Sat, 15 Sep 2018 10:23:32 +0800
Subject: [PATCH 057/105] chore: add some annotations (#1544)

ref: #1075
because I am not a native English, maybe have a bit problem.
---
 README.md                            |  1 +
 examples/basic/main.go               |  6 +++---
 examples/custom-validation/server.go |  1 +
 examples/realtime-advanced/main.go   |  3 +++
 examples/realtime-advanced/stats.go  |  1 +
 ginS/gins.go                         |  9 ++++++++-
 internal/json/json.go                | 10 +++++++---
 internal/json/jsoniter.go            | 12 ++++++++----
 render/data.go                       |  2 ++
 render/html.go                       | 14 +++++++++++++-
 render/json.go                       | 17 +++++++++++++++++
 render/json_17.go                    |  3 +++
 render/msgpack.go                    |  4 ++++
 render/protobuf.go                   |  3 +++
 render/reader.go                     |  3 +++
 render/redirect.go                   |  3 +++
 render/render.go                     |  3 +++
 render/text.go                       |  4 ++++
 render/xml.go                        |  3 +++
 render/yaml.go                       |  3 +++
 utils.go                             |  8 ++++----
 21 files changed, 97 insertions(+), 16 deletions(-)

diff --git a/README.md b/README.md
index a4bc4e76..9a97ec54 100644
--- a/README.md
+++ b/README.md
@@ -657,6 +657,7 @@ import (
 	"gopkg.in/go-playground/validator.v8"
 )
 
+// Booking contains binded and validated data.
 type Booking struct {
 	CheckIn  time.Time `form:"check_in" binding:"required,bookabledate" time_format:"2006-01-02"`
 	CheckOut time.Time `form:"check_out" binding:"required,gtfield=CheckIn" time_format:"2006-01-02"`
diff --git a/examples/basic/main.go b/examples/basic/main.go
index 48fa7bba..1c9e0ac4 100644
--- a/examples/basic/main.go
+++ b/examples/basic/main.go
@@ -6,7 +6,7 @@ import (
 	"github.com/gin-gonic/gin"
 )
 
-var DB = make(map[string]string)
+var db = make(map[string]string)
 
 func setupRouter() *gin.Engine {
 	// Disable Console Color
@@ -21,7 +21,7 @@ func setupRouter() *gin.Engine {
 	// Get user value
 	r.GET("/user/:name", func(c *gin.Context) {
 		user := c.Params.ByName("name")
-		value, ok := DB[user]
+		value, ok := db[user]
 		if ok {
 			c.JSON(http.StatusOK, gin.H{"user": user, "value": value})
 		} else {
@@ -50,7 +50,7 @@ func setupRouter() *gin.Engine {
 		}
 
 		if c.Bind(&json) == nil {
-			DB[user] = json.Value
+			db[user] = json.Value
 			c.JSON(http.StatusOK, gin.H{"status": "ok"})
 		}
 	})
diff --git a/examples/custom-validation/server.go b/examples/custom-validation/server.go
index dea0c302..9238200b 100644
--- a/examples/custom-validation/server.go
+++ b/examples/custom-validation/server.go
@@ -10,6 +10,7 @@ import (
 	"gopkg.in/go-playground/validator.v8"
 )
 
+// Booking contains binded and validated data.
 type Booking struct {
 	CheckIn  time.Time `form:"check_in" binding:"required,bookabledate" time_format:"2006-01-02"`
 	CheckOut time.Time `form:"check_out" binding:"required,gtfield=CheckIn" time_format:"2006-01-02"`
diff --git a/examples/realtime-advanced/main.go b/examples/realtime-advanced/main.go
index 1f3c8585..a16c58b0 100644
--- a/examples/realtime-advanced/main.go
+++ b/examples/realtime-advanced/main.go
@@ -13,16 +13,19 @@ func main() {
 	StartGin()
 }
 
+// ConfigRuntime sets the number of operating system threads.
 func ConfigRuntime() {
 	nuCPU := runtime.NumCPU()
 	runtime.GOMAXPROCS(nuCPU)
 	fmt.Printf("Running with %d CPUs\n", nuCPU)
 }
 
+// StartWrokers start starsWorker by goroutine.
 func StartWorkers() {
 	go statsWorker()
 }
 
+// StartGin starts gin web server with setting router.
 func StartGin() {
 	gin.SetMode(gin.ReleaseMode)
 
diff --git a/examples/realtime-advanced/stats.go b/examples/realtime-advanced/stats.go
index 4afedcb5..a6488035 100644
--- a/examples/realtime-advanced/stats.go
+++ b/examples/realtime-advanced/stats.go
@@ -50,6 +50,7 @@ func connectedUsers() uint64 {
 	return uint64(connected)
 }
 
+// Stats returns savedStats data.
 func Stats() map[string]uint64 {
 	mutexStats.RLock()
 	defer mutexStats.RUnlock()
diff --git a/ginS/gins.go b/ginS/gins.go
index a7686f23..04cf131c 100644
--- a/ginS/gins.go
+++ b/ginS/gins.go
@@ -22,14 +22,17 @@ func engine() *gin.Engine {
 	return internalEngine
 }
 
+// LoadHTMLGlob is a wrapper for Engine.LoadHTMLGlob.
 func LoadHTMLGlob(pattern string) {
 	engine().LoadHTMLGlob(pattern)
 }
 
+// LoadHTMLFiles is a wrapper for Engine.LoadHTMLFiles.
 func LoadHTMLFiles(files ...string) {
 	engine().LoadHTMLFiles(files...)
 }
 
+// SetHTMLTemplate is a wrapper for Engine.SetHTMLTemplate.
 func SetHTMLTemplate(templ *template.Template) {
 	engine().SetHTMLTemplate(templ)
 }
@@ -39,7 +42,7 @@ func NoRoute(handlers ...gin.HandlerFunc) {
 	engine().NoRoute(handlers...)
 }
 
-// NoMethod sets the handlers called when... TODO
+// NoMethod is a wrapper for Engine.NoMethod.
 func NoMethod(handlers ...gin.HandlerFunc) {
 	engine().NoMethod(handlers...)
 }
@@ -50,6 +53,7 @@ func Group(relativePath string, handlers ...gin.HandlerFunc) *gin.RouterGroup {
 	return engine().Group(relativePath, handlers...)
 }
 
+// Handle is a wrapper for Engine.Handle.
 func Handle(httpMethod, relativePath string, handlers ...gin.HandlerFunc) gin.IRoutes {
 	return engine().Handle(httpMethod, relativePath, handlers...)
 }
@@ -89,10 +93,12 @@ func HEAD(relativePath string, handlers ...gin.HandlerFunc) gin.IRoutes {
 	return engine().HEAD(relativePath, handlers...)
 }
 
+// Any is a wrapper for Engine.Any.
 func Any(relativePath string, handlers ...gin.HandlerFunc) gin.IRoutes {
 	return engine().Any(relativePath, handlers...)
 }
 
+// StaticFile is a wrapper for Engine.StaticFile.
 func StaticFile(relativePath, filepath string) gin.IRoutes {
 	return engine().StaticFile(relativePath, filepath)
 }
@@ -107,6 +113,7 @@ func Static(relativePath, root string) gin.IRoutes {
 	return engine().Static(relativePath, root)
 }
 
+// StaticFS is a wrapper for Engine.StaticFS.
 func StaticFS(relativePath string, fs http.FileSystem) gin.IRoutes {
 	return engine().StaticFS(relativePath, fs)
 }
diff --git a/internal/json/json.go b/internal/json/json.go
index 4f643c56..419d35f2 100644
--- a/internal/json/json.go
+++ b/internal/json/json.go
@@ -9,8 +9,12 @@ package json
 import "encoding/json"
 
 var (
-	Marshal       = json.Marshal
+	// Marshal is exported by gin/json package.
+	Marshal = json.Marshal
+	// MarshalIndent is exported by gin/json package.
 	MarshalIndent = json.MarshalIndent
-	NewDecoder    = json.NewDecoder
-	NewEncoder    = json.NewEncoder
+	// NewDecoder is exported by gin/json package.
+	NewDecoder = json.NewDecoder
+	// NewEncoder is exported by gin/json package.
+	NewEncoder = json.NewEncoder
 )
diff --git a/internal/json/jsoniter.go b/internal/json/jsoniter.go
index f1ed5bea..2021c53c 100644
--- a/internal/json/jsoniter.go
+++ b/internal/json/jsoniter.go
@@ -9,9 +9,13 @@ package json
 import "github.com/json-iterator/go"
 
 var (
-	json          = jsoniter.ConfigCompatibleWithStandardLibrary
-	Marshal       = json.Marshal
+	json = jsoniter.ConfigCompatibleWithStandardLibrary
+	// Marshal is exported by gin/json package.
+	Marshal = json.Marshal
+	// MarshalIndent is exported by gin/json package.
 	MarshalIndent = json.MarshalIndent
-	NewDecoder    = json.NewDecoder
-	NewEncoder    = json.NewEncoder
+	// NewDecoder is exported by gin/json package.
+	NewDecoder = json.NewDecoder
+	// NewEncoder is exported by gin/json package.
+	NewEncoder = json.NewEncoder
 )
diff --git a/render/data.go b/render/data.go
index 33194913..6ba657ba 100644
--- a/render/data.go
+++ b/render/data.go
@@ -6,6 +6,7 @@ package render
 
 import "net/http"
 
+// Data contains ContentType and bytes data.
 type Data struct {
 	ContentType string
 	Data        []byte
@@ -18,6 +19,7 @@ func (r Data) Render(w http.ResponseWriter) (err error) {
 	return
 }
 
+// WriteContentType (Data) writes custom ContentType.
 func (r Data) WriteContentType(w http.ResponseWriter) {
 	writeContentType(w, []string{r.ContentType})
 }
diff --git a/render/html.go b/render/html.go
index 1e3be65b..4d3d5812 100644
--- a/render/html.go
+++ b/render/html.go
@@ -9,20 +9,27 @@ import (
 	"net/http"
 )
 
+// Delims represents a set of Left and Right delimiters for HTML template rendering.
 type Delims struct {
-	Left  string
+	// Left delimiter, defaults to {{.
+	Left string
+	// Right delimiter, defaults to }}.
 	Right string
 }
 
+// HTMLRender interface is to be implemented by HTMLProduction and HTMLDebug.
 type HTMLRender interface {
+	// Instance returns an HTML instance.
 	Instance(string, interface{}) Render
 }
 
+// HTMLProduction contains template reference and its delims.
 type HTMLProduction struct {
 	Template *template.Template
 	Delims   Delims
 }
 
+// HTMLDebug contains template delims and pattern and function with file list.
 type HTMLDebug struct {
 	Files   []string
 	Glob    string
@@ -30,6 +37,7 @@ type HTMLDebug struct {
 	FuncMap template.FuncMap
 }
 
+// HTML contains template reference and its name with given interface object.
 type HTML struct {
 	Template *template.Template
 	Name     string
@@ -38,6 +46,7 @@ type HTML struct {
 
 var htmlContentType = []string{"text/html; charset=utf-8"}
 
+// Instance (HTMLProduction) returns an HTML instance which it realizes Render interface..
 func (r HTMLProduction) Instance(name string, data interface{}) Render {
 	return HTML{
 		Template: r.Template,
@@ -46,6 +55,7 @@ func (r HTMLProduction) Instance(name string, data interface{}) Render {
 	}
 }
 
+// Instance (HTMLDebug) returns an HTML instance which it realizes Render interface..
 func (r HTMLDebug) Instance(name string, data interface{}) Render {
 	return HTML{
 		Template: r.loadTemplate(),
@@ -66,6 +76,7 @@ func (r HTMLDebug) loadTemplate() *template.Template {
 	panic("the HTML debug render was created without files or glob pattern")
 }
 
+// Render (HTML) executes template and writes its result with custom ContentType for response.
 func (r HTML) Render(w http.ResponseWriter) error {
 	r.WriteContentType(w)
 
@@ -75,6 +86,7 @@ func (r HTML) Render(w http.ResponseWriter) error {
 	return r.Template.ExecuteTemplate(w, r.Name, r.Data)
 }
 
+// WriteContentType (HTML) writes HTML ContentType.
 func (r HTML) WriteContentType(w http.ResponseWriter) {
 	writeContentType(w, htmlContentType)
 }
diff --git a/render/json.go b/render/json.go
index f6b7878e..32d0fc42 100644
--- a/render/json.go
+++ b/render/json.go
@@ -13,34 +13,41 @@ import (
 	"github.com/gin-gonic/gin/internal/json"
 )
 
+// JSON contains the given interface object.
 type JSON struct {
 	Data interface{}
 }
 
+// IndentedJSON contains the given interface object.
 type IndentedJSON struct {
 	Data interface{}
 }
 
+// SecureJSON contains the given interface object and its prefix.
 type SecureJSON struct {
 	Prefix string
 	Data   interface{}
 }
 
+// JsonpJSON contains the given interface object its callback.
 type JsonpJSON struct {
 	Callback string
 	Data     interface{}
 }
 
+// AsciiJSON contains the given interface object.
 type AsciiJSON struct {
 	Data interface{}
 }
 
+// SecureJSONPrefix is a string which represents SecureJSON prefix.
 type SecureJSONPrefix string
 
 var jsonContentType = []string{"application/json; charset=utf-8"}
 var jsonpContentType = []string{"application/javascript; charset=utf-8"}
 var jsonAsciiContentType = []string{"application/json"}
 
+// Render (JSON) writes data with custom ContentType.
 func (r JSON) Render(w http.ResponseWriter) (err error) {
 	if err = WriteJSON(w, r.Data); err != nil {
 		panic(err)
@@ -48,10 +55,12 @@ func (r JSON) Render(w http.ResponseWriter) (err error) {
 	return
 }
 
+// WriteContentType (JSON) writes JSON ContentType.
 func (r JSON) WriteContentType(w http.ResponseWriter) {
 	writeContentType(w, jsonContentType)
 }
 
+// WriteJSON marshals the given interface object and writes it with custom ContentType.
 func WriteJSON(w http.ResponseWriter, obj interface{}) error {
 	writeContentType(w, jsonContentType)
 	jsonBytes, err := json.Marshal(obj)
@@ -62,6 +71,7 @@ func WriteJSON(w http.ResponseWriter, obj interface{}) error {
 	return nil
 }
 
+// Render (IndentedJSON) marshals the given interface object and writes it with custom ContentType.
 func (r IndentedJSON) Render(w http.ResponseWriter) error {
 	r.WriteContentType(w)
 	jsonBytes, err := json.MarshalIndent(r.Data, "", "    ")
@@ -72,10 +82,12 @@ func (r IndentedJSON) Render(w http.ResponseWriter) error {
 	return nil
 }
 
+// WriteContentType (IndentedJSON) writes JSON ContentType.
 func (r IndentedJSON) WriteContentType(w http.ResponseWriter) {
 	writeContentType(w, jsonContentType)
 }
 
+// Render (SecureJSON) marshals the given interface object and writes it with custom ContentType.
 func (r SecureJSON) Render(w http.ResponseWriter) error {
 	r.WriteContentType(w)
 	jsonBytes, err := json.Marshal(r.Data)
@@ -90,10 +102,12 @@ func (r SecureJSON) Render(w http.ResponseWriter) error {
 	return nil
 }
 
+// WriteContentType (SecureJSON) writes JSON ContentType.
 func (r SecureJSON) WriteContentType(w http.ResponseWriter) {
 	writeContentType(w, jsonContentType)
 }
 
+// Render (JsonpJSON) marshals the given interface object and writes it and its callback with custom ContentType.
 func (r JsonpJSON) Render(w http.ResponseWriter) (err error) {
 	r.WriteContentType(w)
 	ret, err := json.Marshal(r.Data)
@@ -115,10 +129,12 @@ func (r JsonpJSON) Render(w http.ResponseWriter) (err error) {
 	return nil
 }
 
+// WriteContentType (JsonpJSON) writes Javascript ContentType.
 func (r JsonpJSON) WriteContentType(w http.ResponseWriter) {
 	writeContentType(w, jsonpContentType)
 }
 
+// Render (AsciiJSON) marshals the given interface object and writes it with custom ContentType.
 func (r AsciiJSON) Render(w http.ResponseWriter) (err error) {
 	r.WriteContentType(w)
 	ret, err := json.Marshal(r.Data)
@@ -139,6 +155,7 @@ func (r AsciiJSON) Render(w http.ResponseWriter) (err error) {
 	return nil
 }
 
+// WriteContentType (AsciiJSON) writes JSON ContentType.
 func (r AsciiJSON) WriteContentType(w http.ResponseWriter) {
 	writeContentType(w, jsonAsciiContentType)
 }
diff --git a/render/json_17.go b/render/json_17.go
index 75f7f374..208193c7 100644
--- a/render/json_17.go
+++ b/render/json_17.go
@@ -12,10 +12,12 @@ import (
 	"github.com/gin-gonic/gin/internal/json"
 )
 
+// PureJSON contains the given interface object.
 type PureJSON struct {
 	Data interface{}
 }
 
+// Render (PureJSON) writes custom ContentType and encodes the given interface object.
 func (r PureJSON) Render(w http.ResponseWriter) error {
 	r.WriteContentType(w)
 	encoder := json.NewEncoder(w)
@@ -23,6 +25,7 @@ func (r PureJSON) Render(w http.ResponseWriter) error {
 	return encoder.Encode(r.Data)
 }
 
+// WriteContentType (PureJSON) writes custom ContentType.
 func (r PureJSON) WriteContentType(w http.ResponseWriter) {
 	writeContentType(w, jsonContentType)
 }
diff --git a/render/msgpack.go b/render/msgpack.go
index b6b8aa0f..dc681fcf 100644
--- a/render/msgpack.go
+++ b/render/msgpack.go
@@ -10,20 +10,24 @@ import (
 	"github.com/ugorji/go/codec"
 )
 
+// MsgPack contains the given interface object.
 type MsgPack struct {
 	Data interface{}
 }
 
 var msgpackContentType = []string{"application/msgpack; charset=utf-8"}
 
+// WriteContentType (MsgPack) writes MsgPack ContentType.
 func (r MsgPack) WriteContentType(w http.ResponseWriter) {
 	writeContentType(w, msgpackContentType)
 }
 
+// Render (MsgPack) encodes the given interface object and writes data with custom ContentType.
 func (r MsgPack) Render(w http.ResponseWriter) error {
 	return WriteMsgPack(w, r.Data)
 }
 
+// WriteMsgPack writes MsgPack ContentType and encodes the given interface object.
 func WriteMsgPack(w http.ResponseWriter, obj interface{}) error {
 	writeContentType(w, msgpackContentType)
 	var mh codec.MsgpackHandle
diff --git a/render/protobuf.go b/render/protobuf.go
index 34f1e9b5..47895072 100644
--- a/render/protobuf.go
+++ b/render/protobuf.go
@@ -10,12 +10,14 @@ import (
 	"github.com/golang/protobuf/proto"
 )
 
+// ProtoBuf contains the given interface object.
 type ProtoBuf struct {
 	Data interface{}
 }
 
 var protobufContentType = []string{"application/x-protobuf"}
 
+// Render (ProtoBuf) marshals the given interface object and writes data with custom ContentType.
 func (r ProtoBuf) Render(w http.ResponseWriter) error {
 	r.WriteContentType(w)
 
@@ -28,6 +30,7 @@ func (r ProtoBuf) Render(w http.ResponseWriter) error {
 	return nil
 }
 
+// WriteContentType (ProtoBuf) writes ProtoBuf ContentType.
 func (r ProtoBuf) WriteContentType(w http.ResponseWriter) {
 	writeContentType(w, protobufContentType)
 }
diff --git a/render/reader.go b/render/reader.go
index 7a06cce4..ab60e53a 100644
--- a/render/reader.go
+++ b/render/reader.go
@@ -10,6 +10,7 @@ import (
 	"strconv"
 )
 
+// Reader contains the IO reader and its length, and custom ContentType and other headers.
 type Reader struct {
 	ContentType   string
 	ContentLength int64
@@ -26,10 +27,12 @@ func (r Reader) Render(w http.ResponseWriter) (err error) {
 	return
 }
 
+// WriteContentType (Reader) writes custom ContentType.
 func (r Reader) WriteContentType(w http.ResponseWriter) {
 	writeContentType(w, []string{r.ContentType})
 }
 
+// writeHeaders writes custom Header.
 func (r Reader) writeHeaders(w http.ResponseWriter, headers map[string]string) {
 	header := w.Header()
 	for k, v := range headers {
diff --git a/render/redirect.go b/render/redirect.go
index a0634f5a..9c145fe2 100644
--- a/render/redirect.go
+++ b/render/redirect.go
@@ -9,12 +9,14 @@ import (
 	"net/http"
 )
 
+// Redirect contains the http request reference and redirects status code and location.
 type Redirect struct {
 	Code     int
 	Request  *http.Request
 	Location string
 }
 
+// Render (Redirect) redirects the http request to new location and writes redirect response.
 func (r Redirect) Render(w http.ResponseWriter) error {
 	// todo(thinkerou): go1.6 not support StatusPermanentRedirect(308)
 	// when we upgrade go version we can use http.StatusPermanentRedirect
@@ -25,4 +27,5 @@ func (r Redirect) Render(w http.ResponseWriter) error {
 	return nil
 }
 
+// WriteContentType (Redirect) don't write any ContentType.
 func (r Redirect) WriteContentType(http.ResponseWriter) {}
diff --git a/render/render.go b/render/render.go
index df0d1d7c..abfc79fc 100644
--- a/render/render.go
+++ b/render/render.go
@@ -6,8 +6,11 @@ package render
 
 import "net/http"
 
+// Render interface is to be implemented by JSON, XML, HTML, YAML and so on.
 type Render interface {
+	// Render writes data with custom ContentType.
 	Render(http.ResponseWriter) error
+	// WriteContentType writes custom ContentType.
 	WriteContentType(w http.ResponseWriter)
 }
 
diff --git a/render/text.go b/render/text.go
index 7a6acc44..2ea7343c 100644
--- a/render/text.go
+++ b/render/text.go
@@ -10,6 +10,7 @@ import (
 	"net/http"
 )
 
+// String contains the given interface object slice and its format.
 type String struct {
 	Format string
 	Data   []interface{}
@@ -17,15 +18,18 @@ type String struct {
 
 var plainContentType = []string{"text/plain; charset=utf-8"}
 
+// Render (String) writes data with custom ContentType.
 func (r String) Render(w http.ResponseWriter) error {
 	WriteString(w, r.Format, r.Data)
 	return nil
 }
 
+// WriteContentType (String) writes Plain ContentType.
 func (r String) WriteContentType(w http.ResponseWriter) {
 	writeContentType(w, plainContentType)
 }
 
+// WriteString writes data according to its format and write custom ContentType.
 func WriteString(w http.ResponseWriter, format string, data []interface{}) {
 	writeContentType(w, plainContentType)
 	if len(data) > 0 {
diff --git a/render/xml.go b/render/xml.go
index cff1ac3e..cc5390a2 100644
--- a/render/xml.go
+++ b/render/xml.go
@@ -9,17 +9,20 @@ import (
 	"net/http"
 )
 
+// XML contains the given interface object.
 type XML struct {
 	Data interface{}
 }
 
 var xmlContentType = []string{"application/xml; charset=utf-8"}
 
+// Render (XML) encodes the given interface object and writes data with custom ContentType.
 func (r XML) Render(w http.ResponseWriter) error {
 	r.WriteContentType(w)
 	return xml.NewEncoder(w).Encode(r.Data)
 }
 
+// WriteContentType (XML) writes XML ContentType for response.
 func (r XML) WriteContentType(w http.ResponseWriter) {
 	writeContentType(w, xmlContentType)
 }
diff --git a/render/yaml.go b/render/yaml.go
index 25d0ebd4..33bc3254 100644
--- a/render/yaml.go
+++ b/render/yaml.go
@@ -10,12 +10,14 @@ import (
 	"gopkg.in/yaml.v2"
 )
 
+// YAML contains the given interface object.
 type YAML struct {
 	Data interface{}
 }
 
 var yamlContentType = []string{"application/x-yaml; charset=utf-8"}
 
+// Render (YAML) marshals the given interface object and writes data with custom ContentType.
 func (r YAML) Render(w http.ResponseWriter) error {
 	r.WriteContentType(w)
 
@@ -28,6 +30,7 @@ func (r YAML) Render(w http.ResponseWriter) error {
 	return nil
 }
 
+// WriteContentType (YAML) writes YAML ContentType for response.
 func (r YAML) WriteContentType(w http.ResponseWriter) {
 	writeContentType(w, yamlContentType)
 }
diff --git a/utils.go b/utils.go
index bf32c775..f4532d56 100644
--- a/utils.go
+++ b/utils.go
@@ -14,8 +14,10 @@ import (
 	"strings"
 )
 
+// BindKey indicates a default bind key.
 const BindKey = "_gin-gonic/gin/bindkey"
 
+// Bind is a helper function for given interface object and returns a Gin middleware.
 func Bind(val interface{}) HandlerFunc {
 	value := reflect.ValueOf(val)
 	if value.Kind() == reflect.Ptr {
@@ -33,16 +35,14 @@ func Bind(val interface{}) HandlerFunc {
 	}
 }
 
-// WrapF is a helper function for wrapping http.HandlerFunc
-// Returns a Gin middleware
+// WrapF is a helper function for wrapping http.HandlerFunc and returns a Gin middleware.
 func WrapF(f http.HandlerFunc) HandlerFunc {
 	return func(c *Context) {
 		f(c.Writer, c.Request)
 	}
 }
 
-// WrapH is a helper function for wrapping http.Handler
-// Returns a Gin middleware
+// WrapH is a helper function for wrapping http.Handler and returns a Gin middleware.
 func WrapH(h http.Handler) HandlerFunc {
 	return func(c *Context) {
 		h.ServeHTTP(c.Writer, c.Request)

From 6db092f778277ef13da427acfa3501890e952436 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Sat, 15 Sep 2018 15:21:54 +0800
Subject: [PATCH 058/105] chore: add some annotations (#1550)

ref #1075 should all annotations and can close #1075 .
---
 context.go                         |  6 ++++++
 errors.go                          | 20 +++++++++++++++-----
 examples/realtime-advanced/main.go |  2 +-
 gin.go                             |  6 ++++++
 mode.go                            | 13 +++++++++++--
 render/html.go                     |  4 ++--
 routergroup.go                     |  8 ++++++--
 7 files changed, 47 insertions(+), 12 deletions(-)

diff --git a/context.go b/context.go
index 063c72f0..809902a3 100644
--- a/context.go
+++ b/context.go
@@ -711,6 +711,7 @@ func (c *Context) Cookie(name string) (string, error) {
 	return val, nil
 }
 
+// Render writes the response headers and calls render.Render to render data.
 func (c *Context) Render(code int, r render.Render) {
 	c.Status(code)
 
@@ -833,6 +834,7 @@ func (c *Context) SSEvent(name string, message interface{}) {
 	})
 }
 
+// Stream sends a streaming response.
 func (c *Context) Stream(step func(w io.Writer) bool) {
 	w := c.Writer
 	clientGone := w.CloseNotify()
@@ -854,6 +856,7 @@ func (c *Context) Stream(step func(w io.Writer) bool) {
 /******** CONTENT NEGOTIATION *******/
 /************************************/
 
+// Negotiate contains all negotiations data.
 type Negotiate struct {
 	Offered  []string
 	HTMLName string
@@ -863,6 +866,7 @@ type Negotiate struct {
 	Data     interface{}
 }
 
+// Negotiate calls different Render according acceptable Accept format.
 func (c *Context) Negotiate(code int, config Negotiate) {
 	switch c.NegotiateFormat(config.Offered...) {
 	case binding.MIMEJSON:
@@ -882,6 +886,7 @@ func (c *Context) Negotiate(code int, config Negotiate) {
 	}
 }
 
+// NegotiateFormat returns an acceptable Accept format.
 func (c *Context) NegotiateFormat(offered ...string) string {
 	assert1(len(offered) > 0, "you must provide at least one offer")
 
@@ -901,6 +906,7 @@ func (c *Context) NegotiateFormat(offered ...string) string {
 	return ""
 }
 
+// SetAccepted sets Accept header data.
 func (c *Context) SetAccepted(formats ...string) {
 	c.Accepted = formats
 }
diff --git a/errors.go b/errors.go
index 6f90377e..477b9d58 100644
--- a/errors.go
+++ b/errors.go
@@ -12,18 +12,24 @@ import (
 	"github.com/gin-gonic/gin/internal/json"
 )
 
+// ErrorType is an unsigned 64-bit error code as defined in the gin spec.
 type ErrorType uint64
 
 const (
-	ErrorTypeBind    ErrorType = 1 << 63 // used when c.Bind() fails
-	ErrorTypeRender  ErrorType = 1 << 62 // used when c.Render() fails
+	// ErrorTypeBind is used when Context.Bind() fails.
+	ErrorTypeBind ErrorType = 1 << 63
+	// ErrorTypeRender is used when Context.Render() fails.
+	ErrorTypeRender ErrorType = 1 << 62
+	// ErrorTypePrivate indicates a private error.
 	ErrorTypePrivate ErrorType = 1 << 0
-	ErrorTypePublic  ErrorType = 1 << 1
-
+	// ErrorTypePublic indicates a public error.
+	ErrorTypePublic ErrorType = 1 << 1
+	// ErrorTypeAny indicates other any error.
 	ErrorTypeAny ErrorType = 1<<64 - 1
 	ErrorTypeNu            = 2
 )
 
+// Error represents a error's specification.
 type Error struct {
 	Err  error
 	Type ErrorType
@@ -34,11 +40,13 @@ type errorMsgs []*Error
 
 var _ error = &Error{}
 
+// SetType sets the error's type.
 func (msg *Error) SetType(flags ErrorType) *Error {
 	msg.Type = flags
 	return msg
 }
 
+// SetMeta sets the error's meta data.
 func (msg *Error) SetMeta(data interface{}) *Error {
 	msg.Meta = data
 	return msg
@@ -70,11 +78,12 @@ func (msg *Error) MarshalJSON() ([]byte, error) {
 	return json.Marshal(msg.JSON())
 }
 
-// Error implements the error interface
+// Error implements the error interface.
 func (msg Error) Error() string {
 	return msg.Err.Error()
 }
 
+// IsType judges one error.
 func (msg *Error) IsType(flags ErrorType) bool {
 	return (msg.Type & flags) > 0
 }
@@ -138,6 +147,7 @@ func (a errorMsgs) JSON() interface{} {
 	}
 }
 
+// MarshalJSON implements the json.Marshaller interface.
 func (a errorMsgs) MarshalJSON() ([]byte, error) {
 	return json.Marshal(a.JSON())
 }
diff --git a/examples/realtime-advanced/main.go b/examples/realtime-advanced/main.go
index a16c58b0..f3ead476 100644
--- a/examples/realtime-advanced/main.go
+++ b/examples/realtime-advanced/main.go
@@ -20,7 +20,7 @@ func ConfigRuntime() {
 	fmt.Printf("Running with %d CPUs\n", nuCPU)
 }
 
-// StartWrokers start starsWorker by goroutine.
+// StartWorkers start starsWorker by goroutine.
 func StartWorkers() {
 	go statsWorker()
 }
diff --git a/gin.go b/gin.go
index aa62e014..6bff3bd5 100644
--- a/gin.go
+++ b/gin.go
@@ -26,7 +26,10 @@ var (
 	defaultAppEngine bool
 )
 
+// HandlerFunc defines the handler used by gin middleware as return value.
 type HandlerFunc func(*Context)
+
+// HandlersChain defines a HandlerFunc array.
 type HandlersChain []HandlerFunc
 
 // Last returns the last handler in the chain. ie. the last handler is the main own.
@@ -37,12 +40,14 @@ func (c HandlersChain) Last() HandlerFunc {
 	return nil
 }
 
+// RouteInfo represents a request route's specification which contains method and path and its handler.
 type RouteInfo struct {
 	Method  string
 	Path    string
 	Handler string
 }
 
+// RoutesInfo defines a RouteInfo array.
 type RoutesInfo []RouteInfo
 
 // Engine is the framework's instance, it contains the muxer, middleware and configuration settings.
@@ -155,6 +160,7 @@ func (engine *Engine) allocateContext() *Context {
 	return &Context{engine: engine}
 }
 
+// Delims sets template left and right delims and returns a Engine instance.
 func (engine *Engine) Delims(left, right string) *Engine {
 	engine.delims = render.Delims{Left: left, Right: right}
 	return engine
diff --git a/mode.go b/mode.go
index 9df4e45f..7cb0143a 100644
--- a/mode.go
+++ b/mode.go
@@ -11,12 +11,16 @@ import (
 	"github.com/gin-gonic/gin/binding"
 )
 
+// ENV_GIN_MODE indicates environment name for gin mode.
 const ENV_GIN_MODE = "GIN_MODE"
 
 const (
-	DebugMode   = "debug"
+	// DebugMode indicates gin mode is debug.
+	DebugMode = "debug"
+	// ReleaseMode indicates gin mode is relase.
 	ReleaseMode = "release"
-	TestMode    = "test"
+	// TestMode indicates gin mode is test.
+	TestMode = "test"
 )
 const (
 	debugCode = iota
@@ -42,6 +46,7 @@ func init() {
 	SetMode(mode)
 }
 
+// SetMode sets gin mode according to input string.
 func SetMode(value string) {
 	switch value {
 	case DebugMode, "":
@@ -59,14 +64,18 @@ func SetMode(value string) {
 	modeName = value
 }
 
+// DisableBindValidation closes the default validator.
 func DisableBindValidation() {
 	binding.Validator = nil
 }
 
+// EnableJsonDecoderUseNumber sets true for binding.EnableDecoderUseNumberto to
+// call the UseNumber method on the JSON Decoder instance.
 func EnableJsonDecoderUseNumber() {
 	binding.EnableDecoderUseNumber = true
 }
 
+// Mode returns currently gin mode.
 func Mode() string {
 	return modeName
 }
diff --git a/render/html.go b/render/html.go
index 4d3d5812..6696ece9 100644
--- a/render/html.go
+++ b/render/html.go
@@ -46,7 +46,7 @@ type HTML struct {
 
 var htmlContentType = []string{"text/html; charset=utf-8"}
 
-// Instance (HTMLProduction) returns an HTML instance which it realizes Render interface..
+// Instance (HTMLProduction) returns an HTML instance which it realizes Render interface.
 func (r HTMLProduction) Instance(name string, data interface{}) Render {
 	return HTML{
 		Template: r.Template,
@@ -55,7 +55,7 @@ func (r HTMLProduction) Instance(name string, data interface{}) Render {
 	}
 }
 
-// Instance (HTMLDebug) returns an HTML instance which it realizes Render interface..
+// Instance (HTMLDebug) returns an HTML instance which it realizes Render interface.
 func (r HTMLDebug) Instance(name string, data interface{}) Render {
 	return HTML{
 		Template: r.loadTemplate(),
diff --git a/routergroup.go b/routergroup.go
index 876a61b8..be561dee 100644
--- a/routergroup.go
+++ b/routergroup.go
@@ -11,11 +11,13 @@ import (
 	"strings"
 )
 
+// IRouter defines all router handle interface includes single and group router.
 type IRouter interface {
 	IRoutes
 	Group(string, ...HandlerFunc) *RouterGroup
 }
 
+// Iroutes defins all router handle interface.
 type IRoutes interface {
 	Use(...HandlerFunc) IRoutes
 
@@ -34,8 +36,8 @@ type IRoutes interface {
 	StaticFS(string, http.FileSystem) IRoutes
 }
 
-// RouterGroup is used internally to configure router, a RouterGroup is associated with a prefix
-// and an array of handlers (middleware).
+// RouterGroup is used internally to configure router, a RouterGroup is associated with
+// a prefix and an array of handlers (middleware).
 type RouterGroup struct {
 	Handlers HandlersChain
 	basePath string
@@ -61,6 +63,8 @@ func (group *RouterGroup) Group(relativePath string, handlers ...HandlerFunc) *R
 	}
 }
 
+// BasePath returns the base path of router group.
+// For example, if v := router.Group("/rest/n/v1/api"), v.BasePath() is "/rest/n/v1/api".
 func (group *RouterGroup) BasePath() string {
 	return group.basePath
 }

From 7c7f703cc559af6c67fc82c3c39959a0c7d42b43 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Sun, 16 Sep 2018 23:22:54 +0800
Subject: [PATCH 059/105] initial go.mod module definition (#1554)

---
 go.mod | 27 ++++++++++++++++++++++++
 go.sum | 65 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 92 insertions(+)
 create mode 100644 go.mod
 create mode 100644 go.sum

diff --git a/go.mod b/go.mod
new file mode 100644
index 00000000..bd4ad975
--- /dev/null
+++ b/go.mod
@@ -0,0 +1,27 @@
+module github.com/gin-gonic/gin
+
+require (
+	github.com/davecgh/go-spew v0.0.0-20180221232628-8991bc29aa16 // indirect
+	github.com/dustin/go-broadcast v0.0.0-20171205050544-f664265f5a66
+	github.com/gin-contrib/sse v0.0.0-20170109093832-22d885f9ecc7
+	github.com/gin-gonic/autotls v0.0.0-20180426091246-be87bd5ef97b
+	github.com/golang/protobuf v1.2.0
+	github.com/jessevdk/go-assets v0.0.0-20160921144138-4f4301a06e15
+	github.com/json-iterator/go v0.0.0-20180806060727-1624edc4454b
+	github.com/manucorporat/stats v0.0.0-20180402194714-3ba42d56d227
+	github.com/mattn/go-isatty v0.0.3
+	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
+	github.com/modern-go/reflect2 v1.0.1 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/stretchr/testify v1.2.2
+	github.com/thinkerou/favicon v0.0.0-20170710140520-94a442a49da6
+	github.com/ugorji/go v1.1.1
+	golang.org/x/crypto v0.0.0-20180910181607-0e37d006457b
+	golang.org/x/net v0.0.0-20180826012351-8a410e7b638d
+	golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f
+	golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e // indirect
+	google.golang.org/grpc v1.15.0
+	gopkg.in/go-playground/assert.v1 v1.2.1 // indirect
+	gopkg.in/go-playground/validator.v8 v8.18.2
+	gopkg.in/yaml.v2 v2.2.1
+)
diff --git a/go.sum b/go.sum
new file mode 100644
index 00000000..3382beed
--- /dev/null
+++ b/go.sum
@@ -0,0 +1,65 @@
+cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
+github.com/davecgh/go-spew v0.0.0-20180221232628-8991bc29aa16 h1:HqkufMBR7waVfFFRABWqHa1WgTvjtVDJTLJe3CR576A=
+github.com/davecgh/go-spew v0.0.0-20180221232628-8991bc29aa16/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dustin/go-broadcast v0.0.0-20171205050544-f664265f5a66 h1:QnnoVdChKs+GeTvN4rPYTW6b5U6M3HMEvQ/+x4IGtfY=
+github.com/dustin/go-broadcast v0.0.0-20171205050544-f664265f5a66/go.mod h1:kTEh6M2J/mh7nsskr28alwLCXm/DSG5OSA/o31yy2XU=
+github.com/gin-contrib/sse v0.0.0-20170109093832-22d885f9ecc7 h1:AzN37oI0cOS+cougNAV9szl6CVoj2RYwzS3DpUQNtlY=
+github.com/gin-contrib/sse v0.0.0-20170109093832-22d885f9ecc7/go.mod h1:VJ0WA2NBN22VlZ2dKZQPAPnyWw5XTlK1KymzLKsr59s=
+github.com/gin-gonic/autotls v0.0.0-20180426091246-be87bd5ef97b h1:dm/NYytoj7p8Jc6zMvyRz3PCQrTTCXnVRvEzyBcM890=
+github.com/gin-gonic/autotls v0.0.0-20180426091246-be87bd5ef97b/go.mod h1:vwfeXwKgEIWq63oVfwaBjoByS4dZzYbHHROHjV4IjNY=
+github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b h1:VKtxabqXZkF25pY9ekfRL6a582T4P37/31XEstQ5p58=
+github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
+github.com/golang/lint v0.0.0-20180702182130-06c8688daad7/go.mod h1:tluoj9z5200jBnyusfRPU2LqT6J+DAorxEvtC7LHB+E=
+github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/protobuf v1.2.0 h1:P3YflyNX/ehuJFLhxviNdFxQPkGK5cDcApsge1SqnvM=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/jessevdk/go-assets v0.0.0-20160921144138-4f4301a06e15 h1:cW/amwGEJK5MSKntPXRjX4dxs/nGxGT8gXKIsKFmHGc=
+github.com/jessevdk/go-assets v0.0.0-20160921144138-4f4301a06e15/go.mod h1:Fdm/oWRW+CH8PRbLntksCNtmcCBximKPkVQYvmMl80k=
+github.com/json-iterator/go v0.0.0-20180806060727-1624edc4454b h1:X61dhFTE1Au92SvyF8HyAwdjWqiSdfBgFR7wTxC0+uU=
+github.com/json-iterator/go v0.0.0-20180806060727-1624edc4454b/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
+github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
+github.com/manucorporat/stats v0.0.0-20180402194714-3ba42d56d227 h1:KIaAZ/V+/0/6BOULrmBQ9T1ed8BkKqGIjIKW923nJuo=
+github.com/manucorporat/stats v0.0.0-20180402194714-3ba42d56d227/go.mod h1:ruMr5t05gVho4tuDv0PbI0Bb8nOxc/5Y6JzRHe/yfA0=
+github.com/mattn/go-isatty v0.0.3 h1:ns/ykhmWi7G9O+8a448SecJU3nSMBXJfqQkl0upE1jI=
+github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/reflect2 v1.0.1 h1:9f412s+6RmYXLWZSEzVVgPGK7C2PphHj5RJrvfx9AWI=
+github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/testify v1.2.2 h1:bSDNvY7ZPG5RlJ8otE/7V6gMiyenm9RtJ7IUVIAoJ1w=
+github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/thinkerou/favicon v0.0.0-20170710140520-94a442a49da6 h1:d/LEgOfWe+AlOCz/kzmkvlO+gq9LRGhjSHqt2nx8Muc=
+github.com/thinkerou/favicon v0.0.0-20170710140520-94a442a49da6/go.mod h1:HL7Pap5kOluZv1ku34pZo/AJ44GaxMEPFZ3pmuexV2s=
+github.com/ugorji/go v1.1.1 h1:gmervu+jDMvXTbcHQ0pd2wee85nEoE0BsVyEuzkfK8w=
+github.com/ugorji/go v1.1.1/go.mod h1:hnLbHMwcvSihnDhEfx2/BzKp2xb0Y+ErdfYcrs9tkJQ=
+golang.org/x/crypto v0.0.0-20180910181607-0e37d006457b h1:2b9XGzhjiYsYPnKXoEfL7klWZQIt8IfyRCz62gCqqlQ=
+golang.org/x/crypto v0.0.0-20180910181607-0e37d006457b/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/lint v0.0.0-20180702182130-06c8688daad7/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/net v0.0.0-20180826012351-8a410e7b638d h1:g9qWBGx4puODJTMVyoPrpoxPFgVGd+z1DZwjfRu4d0I=
+golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f h1:wMNYb4v58l5UBM7MYRLPG6ZhfOqbKu7X5eyFl8ZhKvA=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e h1:o3PsSEY8E4eXWkXrIP9YJALUkVZqzHJT5DOasTyn8Vs=
+golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/tools v0.0.0-20180828015842-6cd1fcedba52/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
+google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8 h1:Nw54tB0rB7hY/N0NQvRW8DG4Yk3Q6T9cu9RcFQDu1tc=
+google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
+google.golang.org/grpc v1.15.0 h1:Az/KuahOM4NAidTEuJCv/RonAA7rYsTPkqXVjr+8OOw=
+google.golang.org/grpc v1.15.0/go.mod h1:0JHn/cJsOMiMfNA9+DeHDlAU7KAAB5GDlYFpa9MZMio=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/go-playground/assert.v1 v1.2.1 h1:xoYuJVE7KT85PYWrN730RguIQO0ePzVRfFMXadIrXTM=
+gopkg.in/go-playground/assert.v1 v1.2.1/go.mod h1:9RXL0bg/zibRAgZUYszZSwO/z8Y/a8bDuhia5mkpMnE=
+gopkg.in/go-playground/validator.v8 v8.18.2 h1:lFB4DoMU6B626w8ny76MV7VX6W2VHct2GVOI3xgiMrQ=
+gopkg.in/go-playground/validator.v8 v8.18.2/go.mod h1:RX2a/7Ha8BgOhfk7j780h4/u/RRjR0eouCJSH80/M2Y=
+gopkg.in/yaml.v2 v2.2.1 h1:mUhvW9EsL+naU5Q3cakzfE91YhliOondGd6ZrsDBHQE=
+gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+honnef.co/go/tools v0.0.0-20180728063816-88497007e858/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=

From 90c680ef5c360ccd2f0f5f9f0ab1f44f3ce9eef9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=A9r=C3=B4me=20Laforge?=
 <jerome-laforge@users.noreply.github.com>
Date: Mon, 17 Sep 2018 06:09:34 +0200
Subject: [PATCH 060/105] Let's user define how he wants to log his routes (eg.
 JSON, key value, or something else) (#1553) (#1555)

---
 README.md | 44 ++++++++++++++++++++++++++++++++++++++++++++
 debug.go  |  8 +++++++-
 2 files changed, 51 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 9a97ec54..45bfce5a 100644
--- a/README.md
+++ b/README.md
@@ -58,6 +58,7 @@ Gin is a web framework written in Go (Golang). It features a martini-like API wi
     - [Bind form-data request with custom struct](#bind-form-data-request-with-custom-struct)
     - [Try to bind body into different structs](#try-to-bind-body-into-different-structs)
     - [http2 server push](#http2-server-push)
+    - [Define format for the log of routes](#define-format-for-the-log-of-routes)
 - [Testing](#testing)
 - [Users](#users)
 
@@ -1836,6 +1837,49 @@ func main() {
 }
 ```
 
+### Define format for the log of routes
+
+The default log of routes is:
+```
+[GIN-debug] POST   /foo                      --> main.main.func1 (3 handlers)
+[GIN-debug] GET    /bar                      --> main.main.func2 (3 handlers)
+[GIN-debug] GET    /status                   --> main.main.func3 (3 handlers)
+```
+
+If you want to log this information in given format (e.g. JSON, key values or something else), then you can define this format with `gin.DebugPrintRouteFunc`.
+In the example below, we log all routes with standard log package but you can use another log tools that suits of your needs.
+```go
+import (
+	"log"
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+)
+
+func main() {
+	r := gin.Default()
+	gin.DebugPrintRouteFunc = func(httpMethod, absolutePath, handlerName string, nuHandlers int) {
+		log.Printf("endpoint %v %v %v %v\n", httpMethod, absolutePath, handlerName, nuHandlers)
+	}
+
+	r.POST("/foo", func(c *gin.Context) {
+		c.JSON(http.StatusOK, "foo")
+	})
+
+	r.GET("/bar", func(c *gin.Context) {
+		c.JSON(http.StatusOK, "bar")
+	})
+
+	r.GET("/status", func(c *gin.Context) {
+		c.JSON(http.StatusOK, "ok")
+	})
+
+	// Listen and Server in http://0.0.0.0:8080
+	r.Run()
+}
+```
+
+
 ## Testing
 
 The `net/http/httptest` package is preferable way for HTTP testing.
diff --git a/debug.go b/debug.go
index f11156b3..693486a9 100644
--- a/debug.go
+++ b/debug.go
@@ -20,11 +20,17 @@ func IsDebugging() bool {
 	return ginMode == debugCode
 }
 
+var DebugPrintRouteFunc func(httpMethod, absolutePath, handlerName string, nuHandlers int)
+
 func debugPrintRoute(httpMethod, absolutePath string, handlers HandlersChain) {
 	if IsDebugging() {
 		nuHandlers := len(handlers)
 		handlerName := nameOfFunction(handlers.Last())
-		debugPrint("%-6s %-25s --> %s (%d handlers)\n", httpMethod, absolutePath, handlerName, nuHandlers)
+		if DebugPrintRouteFunc == nil {
+			debugPrint("%-6s %-25s --> %s (%d handlers)\n", httpMethod, absolutePath, handlerName, nuHandlers)
+		} else {
+			DebugPrintRouteFunc(httpMethod, absolutePath, handlerName, nuHandlers)
+		}
 	}
 }
 

From b27b7026c70697d84226f15d6d433bdf07023c5c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Mon, 17 Sep 2018 15:08:11 +0800
Subject: [PATCH 061/105] chore: add a version file includes gin version
 (#1549)

* chore: add a version file includes gin version

* update version for dev version
---
 gin.go     | 6 +-----
 version.go | 8 ++++++++
 2 files changed, 9 insertions(+), 5 deletions(-)
 create mode 100644 version.go

diff --git a/gin.go b/gin.go
index 6bff3bd5..11f6d94a 100644
--- a/gin.go
+++ b/gin.go
@@ -14,11 +14,7 @@ import (
 	"github.com/gin-gonic/gin/render"
 )
 
-const (
-	// Version is Framework's version.
-	Version                = "v1.3.0"
-	defaultMultipartMemory = 32 << 20 // 32 MB
-)
+const defaultMultipartMemory = 32 << 20 // 32 MB
 
 var (
 	default404Body   = []byte("404 page not found")
diff --git a/version.go b/version.go
new file mode 100644
index 00000000..028caebe
--- /dev/null
+++ b/version.go
@@ -0,0 +1,8 @@
+// Copyright 2018 Gin Core Team.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+// Version is the current gin framework's version.
+const Version = "v1.4.0-dev"

From 07f1bf0e63512fbf9c7d7984d235a399eb916244 Mon Sep 17 00:00:00 2001
From: Bo-Yi Wu <appleboy.tw@gmail.com>
Date: Wed, 19 Sep 2018 13:57:00 +0800
Subject: [PATCH 062/105] feat: replace debug log with fmt package. (#1560)

---
 context_test.go |  12 ++---
 debug.go        |   8 +--
 debug_test.go   | 140 +++++++++++++++++++++++++++---------------------
 3 files changed, 86 insertions(+), 74 deletions(-)

diff --git a/context_test.go b/context_test.go
index 4c307080..5a5bb6e1 100644
--- a/context_test.go
+++ b/context_test.go
@@ -784,14 +784,14 @@ func TestContextRenderHTML2(t *testing.T) {
 	router.addRoute("GET", "/", HandlersChain{func(_ *Context) {}})
 	assert.Len(t, router.trees, 1)
 
-	var b bytes.Buffer
-	setup(&b)
-	defer teardown()
-
 	templ := template.Must(template.New("t").Parse(`Hello {{.name}}`))
-	router.SetHTMLTemplate(templ)
+	re := captureOutput(func() {
+		SetMode(DebugMode)
+		router.SetHTMLTemplate(templ)
+		SetMode(TestMode)
+	})
 
-	assert.Equal(t, "[GIN-debug] [WARNING] Since SetHTMLTemplate() is NOT thread-safe. It should only be called\nat initialization. ie. before any route is registered or the router is listening in a socket:\n\n\trouter := gin.Default()\n\trouter.SetHTMLTemplate(template) // << good place\n\n", b.String())
+	assert.Equal(t, "[GIN-debug] [WARNING] Since SetHTMLTemplate() is NOT thread-safe. It should only be called\nat initialization. ie. before any route is registered or the router is listening in a socket:\n\n\trouter := gin.Default()\n\trouter.SetHTMLTemplate(template) // << good place\n\n", re)
 
 	c.HTML(http.StatusCreated, "t", H{"name": "alexandernyquist"})
 
diff --git a/debug.go b/debug.go
index 693486a9..d6d8bce6 100644
--- a/debug.go
+++ b/debug.go
@@ -6,14 +6,10 @@ package gin
 
 import (
 	"bytes"
+	"fmt"
 	"html/template"
-	"log"
 )
 
-func init() {
-	log.SetFlags(0)
-}
-
 // IsDebugging returns true if the framework is running in debug mode.
 // Use SetMode(gin.ReleaseMode) to disable debug mode.
 func IsDebugging() bool {
@@ -48,7 +44,7 @@ func debugPrintLoadTemplate(tmpl *template.Template) {
 
 func debugPrint(format string, values ...interface{}) {
 	if IsDebugging() {
-		log.Printf("[GIN-debug] "+format, values...)
+		fmt.Printf("[GIN-debug] "+format, values...)
 	}
 }
 
diff --git a/debug_test.go b/debug_test.go
index ed5a6a54..0b9d7910 100644
--- a/debug_test.go
+++ b/debug_test.go
@@ -11,6 +11,7 @@ import (
 	"io"
 	"log"
 	"os"
+	"sync"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -30,86 +31,101 @@ func TestIsDebugging(t *testing.T) {
 }
 
 func TestDebugPrint(t *testing.T) {
-	var w bytes.Buffer
-	setup(&w)
-	defer teardown()
-
-	SetMode(ReleaseMode)
-	debugPrint("DEBUG this!")
-	SetMode(TestMode)
-	debugPrint("DEBUG this!")
-	assert.Empty(t, w.String())
-
-	SetMode(DebugMode)
-	debugPrint("these are %d %s\n", 2, "error messages")
-	assert.Equal(t, "[GIN-debug] these are 2 error messages\n", w.String())
+	re := captureOutput(func() {
+		SetMode(DebugMode)
+		SetMode(ReleaseMode)
+		debugPrint("DEBUG this!")
+		SetMode(TestMode)
+		debugPrint("DEBUG this!")
+		SetMode(DebugMode)
+		debugPrint("these are %d %s\n", 2, "error messages")
+		SetMode(TestMode)
+	})
+	assert.Equal(t, "[GIN-debug] these are 2 error messages\n", re)
 }
 
 func TestDebugPrintError(t *testing.T) {
-	var w bytes.Buffer
-	setup(&w)
-	defer teardown()
-
-	SetMode(DebugMode)
-	debugPrintError(nil)
-	assert.Empty(t, w.String())
-
-	debugPrintError(errors.New("this is an error"))
-	assert.Equal(t, "[GIN-debug] [ERROR] this is an error\n", w.String())
+	re := captureOutput(func() {
+		SetMode(DebugMode)
+		debugPrintError(nil)
+		debugPrintError(errors.New("this is an error"))
+		SetMode(TestMode)
+	})
+	assert.Equal(t, "[GIN-debug] [ERROR] this is an error\n", re)
 }
 
 func TestDebugPrintRoutes(t *testing.T) {
-	var w bytes.Buffer
-	setup(&w)
-	defer teardown()
-
-	debugPrintRoute("GET", "/path/to/route/:param", HandlersChain{func(c *Context) {}, handlerNameTest})
-	assert.Regexp(t, `^\[GIN-debug\] GET    /path/to/route/:param     --> (.*/vendor/)?github.com/gin-gonic/gin.handlerNameTest \(2 handlers\)\n$`, w.String())
+	re := captureOutput(func() {
+		SetMode(DebugMode)
+		debugPrintRoute("GET", "/path/to/route/:param", HandlersChain{func(c *Context) {}, handlerNameTest})
+		SetMode(TestMode)
+	})
+	assert.Regexp(t, `^\[GIN-debug\] GET    /path/to/route/:param     --> (.*/vendor/)?github.com/gin-gonic/gin.handlerNameTest \(2 handlers\)\n$`, re)
 }
 
 func TestDebugPrintLoadTemplate(t *testing.T) {
-	var w bytes.Buffer
-	setup(&w)
-	defer teardown()
-
-	templ := template.Must(template.New("").Delims("{[{", "}]}").ParseGlob("./testdata/template/hello.tmpl"))
-	debugPrintLoadTemplate(templ)
-	assert.Regexp(t, `^\[GIN-debug\] Loaded HTML Templates \(2\): \n(\t- \n|\t- hello\.tmpl\n){2}\n`, w.String())
+	re := captureOutput(func() {
+		SetMode(DebugMode)
+		templ := template.Must(template.New("").Delims("{[{", "}]}").ParseGlob("./testdata/template/hello.tmpl"))
+		debugPrintLoadTemplate(templ)
+		SetMode(TestMode)
+	})
+	assert.Regexp(t, `^\[GIN-debug\] Loaded HTML Templates \(2\): \n(\t- \n|\t- hello\.tmpl\n){2}\n`, re)
 }
 
 func TestDebugPrintWARNINGSetHTMLTemplate(t *testing.T) {
-	var w bytes.Buffer
-	setup(&w)
-	defer teardown()
-
-	debugPrintWARNINGSetHTMLTemplate()
-	assert.Equal(t, "[GIN-debug] [WARNING] Since SetHTMLTemplate() is NOT thread-safe. It should only be called\nat initialization. ie. before any route is registered or the router is listening in a socket:\n\n\trouter := gin.Default()\n\trouter.SetHTMLTemplate(template) // << good place\n\n", w.String())
+	re := captureOutput(func() {
+		SetMode(DebugMode)
+		debugPrintWARNINGSetHTMLTemplate()
+		SetMode(TestMode)
+	})
+	assert.Equal(t, "[GIN-debug] [WARNING] Since SetHTMLTemplate() is NOT thread-safe. It should only be called\nat initialization. ie. before any route is registered or the router is listening in a socket:\n\n\trouter := gin.Default()\n\trouter.SetHTMLTemplate(template) // << good place\n\n", re)
 }
 
 func TestDebugPrintWARNINGDefault(t *testing.T) {
-	var w bytes.Buffer
-	setup(&w)
-	defer teardown()
-
-	debugPrintWARNINGDefault()
-	assert.Equal(t, "[GIN-debug] [WARNING] Now Gin requires Go 1.6 or later and Go 1.7 will be required soon.\n\n[GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.\n\n", w.String())
+	re := captureOutput(func() {
+		SetMode(DebugMode)
+		debugPrintWARNINGDefault()
+		SetMode(TestMode)
+	})
+	assert.Equal(t, "[GIN-debug] [WARNING] Now Gin requires Go 1.6 or later and Go 1.7 will be required soon.\n\n[GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.\n\n", re)
 }
 
 func TestDebugPrintWARNINGNew(t *testing.T) {
-	var w bytes.Buffer
-	setup(&w)
-	defer teardown()
-
-	debugPrintWARNINGNew()
-	assert.Equal(t, "[GIN-debug] [WARNING] Running in \"debug\" mode. Switch to \"release\" mode in production.\n - using env:\texport GIN_MODE=release\n - using code:\tgin.SetMode(gin.ReleaseMode)\n\n", w.String())
+	re := captureOutput(func() {
+		SetMode(DebugMode)
+		debugPrintWARNINGNew()
+		SetMode(TestMode)
+	})
+	assert.Equal(t, "[GIN-debug] [WARNING] Running in \"debug\" mode. Switch to \"release\" mode in production.\n - using env:\texport GIN_MODE=release\n - using code:\tgin.SetMode(gin.ReleaseMode)\n\n", re)
 }
 
-func setup(w io.Writer) {
-	SetMode(DebugMode)
-	log.SetOutput(w)
-}
-
-func teardown() {
-	SetMode(TestMode)
-	log.SetOutput(os.Stdout)
+func captureOutput(f func()) string {
+	reader, writer, err := os.Pipe()
+	if err != nil {
+		panic(err)
+	}
+	stdout := os.Stdout
+	stderr := os.Stderr
+	defer func() {
+		os.Stdout = stdout
+		os.Stderr = stderr
+		log.SetOutput(os.Stderr)
+	}()
+	os.Stdout = writer
+	os.Stderr = writer
+	log.SetOutput(writer)
+	out := make(chan string)
+	wg := new(sync.WaitGroup)
+	wg.Add(1)
+	go func() {
+		var buf bytes.Buffer
+		wg.Done()
+		io.Copy(&buf, reader)
+		out <- buf.String()
+	}()
+	wg.Wait()
+	f()
+	writer.Close()
+	return <-out
 }

From c617b6241a1891081b3632ed89c1887dc4c353af Mon Sep 17 00:00:00 2001
From: Javier Provecho Fernandez <javiertitan@gmail.com>
Date: Thu, 20 Sep 2018 03:13:04 +0200
Subject: [PATCH 063/105] chore: recover go master build, partial revert #1514
 (#1561)

* chore: recover go master build, partial revert #1514

* chore: add master to go branch build targets
---
 .travis.yml | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/.travis.yml b/.travis.yml
index a93458f9..398c1409 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -7,6 +7,11 @@ go:
   - 1.9.x
   - 1.10.x
   - 1.11.x
+  - master
+
+matrix:
+  allow_failures:
+    - go: master
 
 git:
   depth: 10

From f2cd3fcb2a9b4b108f5ce34a9f121ec13ac1cc16 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Thu, 20 Sep 2018 11:53:58 +0800
Subject: [PATCH 064/105] chore: fix typo and add a little anotation (#1562)

---
 debug.go       | 1 +
 routergroup.go | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/debug.go b/debug.go
index d6d8bce6..ce908dc7 100644
--- a/debug.go
+++ b/debug.go
@@ -16,6 +16,7 @@ func IsDebugging() bool {
 	return ginMode == debugCode
 }
 
+// DebugPrintRouteFunc indicates debug log output format.
 var DebugPrintRouteFunc func(httpMethod, absolutePath, handlerName string, nuHandlers int)
 
 func debugPrintRoute(httpMethod, absolutePath string, handlers HandlersChain) {
diff --git a/routergroup.go b/routergroup.go
index be561dee..579aa7dc 100644
--- a/routergroup.go
+++ b/routergroup.go
@@ -17,7 +17,7 @@ type IRouter interface {
 	Group(string, ...HandlerFunc) *RouterGroup
 }
 
-// Iroutes defins all router handle interface.
+// IRoutes defines all router handle interface.
 type IRoutes interface {
 	Use(...HandlerFunc) IRoutes
 

From a210eea3bd1c3766d76968108dfcd83c331f549c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Fri, 21 Sep 2018 10:21:59 +0800
Subject: [PATCH 065/105] improve panic information when a catch-all wildcard
 conflict occurs (#1529)

---
 tree.go      | 11 +++++++++--
 tree_test.go | 42 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 51 insertions(+), 2 deletions(-)

diff --git a/tree.go b/tree.go
index b6530665..ada62ceb 100644
--- a/tree.go
+++ b/tree.go
@@ -193,9 +193,16 @@ func (n *node) addRoute(path string, handlers HandlersChain) {
 						}
 					}
 
-					panic("path segment '" + path +
+					pathSeg := path
+					if n.nType != catchAll {
+						pathSeg = strings.SplitN(path, "/", 2)[0]
+					}
+					prefix := fullPath[:strings.Index(fullPath, pathSeg)] + n.path
+					panic("'" + pathSeg +
+						"' in new path '" + fullPath +
 						"' conflicts with existing wildcard '" + n.path +
-						"' in path '" + fullPath + "'")
+						"' in existing prefix '" + prefix +
+						"'")
 				}
 
 				c := path[0]
diff --git a/tree_test.go b/tree_test.go
index 152f6331..a1b3bbe7 100644
--- a/tree_test.go
+++ b/tree_test.go
@@ -5,7 +5,9 @@
 package gin
 
 import (
+	"fmt"
 	"reflect"
+	"regexp"
 	"strings"
 	"testing"
 )
@@ -653,3 +655,43 @@ func TestTreeInvalidNodeType(t *testing.T) {
 		t.Fatalf("Expected panic '"+panicMsg+"', got '%v'", recv)
 	}
 }
+
+func TestTreeWildcardConflictEx(t *testing.T) {
+	conflicts := [...]struct {
+		route        string
+		segPath      string
+		existPath    string
+		existSegPath string
+	}{
+		{"/who/are/foo", "/foo", `/who/are/\*you`, `/\*you`},
+		{"/who/are/foo/", "/foo/", `/who/are/\*you`, `/\*you`},
+		{"/who/are/foo/bar", "/foo/bar", `/who/are/\*you`, `/\*you`},
+		{"/conxxx", "xxx", `/con:tact`, `:tact`},
+		{"/conooo/xxx", "ooo", `/con:tact`, `:tact`},
+	}
+
+	for _, conflict := range conflicts {
+		// I have to re-create a 'tree', because the 'tree' will be
+		// in an inconsistent state when the loop recovers from the
+		// panic which threw by 'addRoute' function.
+		tree := &node{}
+		routes := [...]string{
+			"/con:tact",
+			"/who/are/*you",
+			"/who/foo/hello",
+		}
+
+		for _, route := range routes {
+			tree.addRoute(route, fakeHandler(route))
+		}
+
+		recv := catchPanic(func() {
+			tree.addRoute(conflict.route, fakeHandler(conflict.route))
+		})
+
+		if !regexp.MustCompile(fmt.Sprintf("'%s' in new path .* conflicts with existing wildcard '%s' in existing prefix '%s'",
+			conflict.segPath, conflict.existSegPath, conflict.existPath)).MatchString(fmt.Sprint(recv)) {
+			t.Fatalf("invalid wildcard conflict error (%v)", recv)
+		}
+	}
+}

From 5a75dc712705510ab39fe7c448e7ab11459ce5b4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Sat, 22 Sep 2018 11:37:28 +0800
Subject: [PATCH 066/105] add release badge for readme (#1533)

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index 45bfce5a..6fd2dd34 100644
--- a/README.md
+++ b/README.md
@@ -9,6 +9,7 @@
 [![Join the chat at https://gitter.im/gin-gonic/gin](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/gin-gonic/gin?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 [![Sourcegraph](https://sourcegraph.com/github.com/gin-gonic/gin/-/badge.svg)](https://sourcegraph.com/github.com/gin-gonic/gin?badge)
 [![Open Source Helpers](https://www.codetriage.com/gin-gonic/gin/badges/users.svg)](https://www.codetriage.com/gin-gonic/gin)
+[![Release](https://img.shields.io/github/release/gin-gonic/gin.svg?style=flat-square)](https://github.com/gin-gonic/gin/releases)
 
 Gin is a web framework written in Go (Golang). It features a martini-like API with much better performance, up to 40 times faster thanks to [httprouter](https://github.com/julienschmidt/httprouter). If you need performance and good productivity, you will love Gin.
 

From ad53619b15fda20df57c16cf19fe83f4a428cefa Mon Sep 17 00:00:00 2001
From: Dustin Decker <dustindecker@protonmail.com>
Date: Sun, 23 Sep 2018 00:15:23 -0700
Subject: [PATCH 067/105] Don't log requests (#1370)

Fixes #1331

HTTP logging leaks sensitive request information.

This PR removes HTTP request logging during panics.
---
 recovery.go      |  8 ++++++--
 recovery_test.go | 12 +++++++++++-
 2 files changed, 17 insertions(+), 3 deletions(-)

diff --git a/recovery.go b/recovery.go
index 61c5bd53..6c28b4fa 100644
--- a/recovery.go
+++ b/recovery.go
@@ -39,8 +39,12 @@ func RecoveryWithWriter(out io.Writer) HandlerFunc {
 			if err := recover(); err != nil {
 				if logger != nil {
 					stack := stack(3)
-					httprequest, _ := httputil.DumpRequest(c.Request, false)
-					logger.Printf("[Recovery] %s panic recovered:\n%s\n%s\n%s%s", timeFormat(time.Now()), string(httprequest), err, stack, reset)
+					if IsDebugging() {
+						httprequest, _ := httputil.DumpRequest(c.Request, false)
+						logger.Printf("[Recovery] %s panic recovered:\n%s\n%s\n%s%s", timeFormat(time.Now()), string(httprequest), err, stack, reset)
+					} else {
+						logger.Printf("[Recovery] %s panic recovered:\n%s\n%s%s", timeFormat(time.Now()), err, stack, reset)
+					}
 				}
 				c.AbortWithStatus(http.StatusInternalServerError)
 			}
diff --git a/recovery_test.go b/recovery_test.go
index 53f4a071..7d422b74 100644
--- a/recovery_test.go
+++ b/recovery_test.go
@@ -24,9 +24,19 @@ func TestPanicInHandler(t *testing.T) {
 	w := performRequest(router, "GET", "/recovery")
 	// TEST
 	assert.Equal(t, http.StatusInternalServerError, w.Code)
-	assert.Contains(t, buffer.String(), "GET /recovery")
+	assert.Contains(t, buffer.String(), "panic recovered")
 	assert.Contains(t, buffer.String(), "Oupps, Houston, we have a problem")
 	assert.Contains(t, buffer.String(), "TestPanicInHandler")
+	assert.NotContains(t, buffer.String(), "GET /recovery")
+
+	// Debug mode prints the request
+	SetMode(DebugMode)
+	// RUN
+	w = performRequest(router, "GET", "/recovery")
+	// TEST
+	assert.Equal(t, http.StatusInternalServerError, w.Code)
+	assert.Contains(t, buffer.String(), "GET /recovery")
+
 }
 
 // TestPanicWithAbort assert that panic has been recovered even if context.Abort was used.

From b02e4f2ed68e1bd9598b8eced0b21c9aacfed5ee Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Tue, 25 Sep 2018 21:52:21 +0800
Subject: [PATCH 068/105] ci: fast finish when build failed (#1568)

---
 .travis.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.travis.yml b/.travis.yml
index 398c1409..f9e241d7 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -12,6 +12,7 @@ go:
 matrix:
   allow_failures:
     - go: master
+  fast_finish: true
 
 git:
   depth: 10

From fd599fcceadba48be39ded04d1e2fb3181b43e8c Mon Sep 17 00:00:00 2001
From: andrea <crypto.andrea@protonmail.ch>
Date: Tue, 25 Sep 2018 21:28:25 -0500
Subject: [PATCH 069/105] Make logger use a yellow background and a darkgray
 text for legibility (#1570)

1. Why is this change neccesary?
White text on a yellow background was illegible with most terminal color schemes

2. How does it address the issue?
The white text was replaced with a bash compatible dark gray while keeping the
yellow background colour

3. What side effects does this change have?
Resolves #1552
---
 logger.go      | 2 +-
 logger_test.go | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/logger.go b/logger.go
index 1a8df601..5f986853 100644
--- a/logger.go
+++ b/logger.go
@@ -17,7 +17,7 @@ import (
 var (
 	green        = string([]byte{27, 91, 57, 55, 59, 52, 50, 109})
 	white        = string([]byte{27, 91, 57, 48, 59, 52, 55, 109})
-	yellow       = string([]byte{27, 91, 57, 55, 59, 52, 51, 109})
+	yellow       = string([]byte{27, 91, 57, 48, 59, 52, 51, 109})
 	red          = string([]byte{27, 91, 57, 55, 59, 52, 49, 109})
 	blue         = string([]byte{27, 91, 57, 55, 59, 52, 52, 109})
 	magenta      = string([]byte{27, 91, 57, 55, 59, 52, 53, 109})
diff --git a/logger_test.go b/logger_test.go
index 7dbbf7b1..6118cb04 100644
--- a/logger_test.go
+++ b/logger_test.go
@@ -85,7 +85,7 @@ func TestLogger(t *testing.T) {
 func TestColorForMethod(t *testing.T) {
 	assert.Equal(t, string([]byte{27, 91, 57, 55, 59, 52, 52, 109}), colorForMethod("GET"), "get should be blue")
 	assert.Equal(t, string([]byte{27, 91, 57, 55, 59, 52, 54, 109}), colorForMethod("POST"), "post should be cyan")
-	assert.Equal(t, string([]byte{27, 91, 57, 55, 59, 52, 51, 109}), colorForMethod("PUT"), "put should be yellow")
+	assert.Equal(t, string([]byte{27, 91, 57, 48, 59, 52, 51, 109}), colorForMethod("PUT"), "put should be yellow")
 	assert.Equal(t, string([]byte{27, 91, 57, 55, 59, 52, 49, 109}), colorForMethod("DELETE"), "delete should be red")
 	assert.Equal(t, string([]byte{27, 91, 57, 55, 59, 52, 50, 109}), colorForMethod("PATCH"), "patch should be green")
 	assert.Equal(t, string([]byte{27, 91, 57, 55, 59, 52, 53, 109}), colorForMethod("HEAD"), "head should be magenta")
@@ -96,7 +96,7 @@ func TestColorForMethod(t *testing.T) {
 func TestColorForStatus(t *testing.T) {
 	assert.Equal(t, string([]byte{27, 91, 57, 55, 59, 52, 50, 109}), colorForStatus(http.StatusOK), "2xx should be green")
 	assert.Equal(t, string([]byte{27, 91, 57, 48, 59, 52, 55, 109}), colorForStatus(http.StatusMovedPermanently), "3xx should be white")
-	assert.Equal(t, string([]byte{27, 91, 57, 55, 59, 52, 51, 109}), colorForStatus(http.StatusNotFound), "4xx should be yellow")
+	assert.Equal(t, string([]byte{27, 91, 57, 48, 59, 52, 51, 109}), colorForStatus(http.StatusNotFound), "4xx should be yellow")
 	assert.Equal(t, string([]byte{27, 91, 57, 55, 59, 52, 49, 109}), colorForStatus(2), "other things should be red")
 }
 

From 834a2ec64ca1ce077e4bdeb5edec019df1c01e71 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Wed, 26 Sep 2018 13:49:11 +0800
Subject: [PATCH 070/105] feat: add go version judge when print debug warning
 log (#1572)

* feat: add go version judge when print debug warning log

* remove invalid statement

* use one const
---
 debug.go      | 18 +++++++++++++++++-
 debug_test.go | 24 +++++++++++++++++++++++-
 2 files changed, 40 insertions(+), 2 deletions(-)

diff --git a/debug.go b/debug.go
index ce908dc7..4fd23fa1 100644
--- a/debug.go
+++ b/debug.go
@@ -8,8 +8,13 @@ import (
 	"bytes"
 	"fmt"
 	"html/template"
+	"runtime"
+	"strconv"
+	"strings"
 )
 
+const ginSupportMinGoVer = 6
+
 // IsDebugging returns true if the framework is running in debug mode.
 // Use SetMode(gin.ReleaseMode) to disable debug mode.
 func IsDebugging() bool {
@@ -49,10 +54,21 @@ func debugPrint(format string, values ...interface{}) {
 	}
 }
 
+func getMinVer(v string) (uint64, error) {
+	first := strings.IndexByte(v, '.')
+	last := strings.LastIndexByte(v, '.')
+	if first == last {
+		return strconv.ParseUint(v[first+1:], 10, 64)
+	}
+	return strconv.ParseUint(v[first+1:last], 10, 64)
+}
+
 func debugPrintWARNINGDefault() {
-	debugPrint(`[WARNING] Now Gin requires Go 1.6 or later and Go 1.7 will be required soon.
+	if v, e := getMinVer(runtime.Version()); e == nil && v <= ginSupportMinGoVer {
+		debugPrint(`[WARNING] Now Gin requires Go 1.6 or later and Go 1.7 will be required soon.
 
 `)
+	}
 	debugPrint(`[WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.
 
 `)
diff --git a/debug_test.go b/debug_test.go
index 0b9d7910..c8a010ff 100644
--- a/debug_test.go
+++ b/debug_test.go
@@ -11,6 +11,7 @@ import (
 	"io"
 	"log"
 	"os"
+	"runtime"
 	"sync"
 	"testing"
 
@@ -88,7 +89,13 @@ func TestDebugPrintWARNINGDefault(t *testing.T) {
 		debugPrintWARNINGDefault()
 		SetMode(TestMode)
 	})
-	assert.Equal(t, "[GIN-debug] [WARNING] Now Gin requires Go 1.6 or later and Go 1.7 will be required soon.\n\n[GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.\n\n", re)
+	m, e := getMinVer(runtime.Version())
+	assert.Nil(t, e)
+	if m <= ginSupportMinGoVer {
+		assert.Equal(t, "[GIN-debug] [WARNING] Now Gin requires Go 1.6 or later and Go 1.7 will be required soon.\n\n[GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.\n\n", re)
+	} else {
+		assert.Equal(t, "[GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.\n\n", re)
+	}
 }
 
 func TestDebugPrintWARNINGNew(t *testing.T) {
@@ -129,3 +136,18 @@ func captureOutput(f func()) string {
 	writer.Close()
 	return <-out
 }
+
+func TestGetMinVer(t *testing.T) {
+	var m uint64
+	var e error
+	_, e = getMinVer("go1")
+	assert.NotNil(t, e)
+	m, e = getMinVer("go1.1")
+	assert.Equal(t, uint64(1), m)
+	assert.Nil(t, e)
+	m, e = getMinVer("go1.1.1")
+	assert.Nil(t, e)
+	assert.Equal(t, uint64(1), m)
+	_, e = getMinVer("go1.1.1.1")
+	assert.NotNil(t, e)
+}

From 402ef120e19218544152502d1ea20709ff5adbc8 Mon Sep 17 00:00:00 2001
From: Bo-Yi Wu <appleboy.tw@gmail.com>
Date: Thu, 27 Sep 2018 08:59:44 +0800
Subject: [PATCH 071/105] fix: fmt output log to os.Stderr (#1571)

fix #1560 changes are breaking in App Engine.

cc @giulianobr @philippgille
---
 debug.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/debug.go b/debug.go
index 4fd23fa1..c5e65b22 100644
--- a/debug.go
+++ b/debug.go
@@ -8,6 +8,7 @@ import (
 	"bytes"
 	"fmt"
 	"html/template"
+	"os"
 	"runtime"
 	"strconv"
 	"strings"
@@ -50,7 +51,7 @@ func debugPrintLoadTemplate(tmpl *template.Template) {
 
 func debugPrint(format string, values ...interface{}) {
 	if IsDebugging() {
-		fmt.Printf("[GIN-debug] "+format, values...)
+		fmt.Fprintf(os.Stderr, "[GIN-debug] "+format, values...)
 	}
 }
 

From b7314d943c81052dd7155499c7313d7524cb024c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Thu, 27 Sep 2018 09:42:41 +0800
Subject: [PATCH 072/105] chore: fix debug test error (#1574)

---
 debug_test.go | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/debug_test.go b/debug_test.go
index c8a010ff..97ff166b 100644
--- a/debug_test.go
+++ b/debug_test.go
@@ -90,8 +90,7 @@ func TestDebugPrintWARNINGDefault(t *testing.T) {
 		SetMode(TestMode)
 	})
 	m, e := getMinVer(runtime.Version())
-	assert.Nil(t, e)
-	if m <= ginSupportMinGoVer {
+	if e == nil && m <= ginSupportMinGoVer {
 		assert.Equal(t, "[GIN-debug] [WARNING] Now Gin requires Go 1.6 or later and Go 1.7 will be required soon.\n\n[GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.\n\n", re)
 	} else {
 		assert.Equal(t, "[GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.\n\n", re)

From 91a4459dd27a311c2b959708f328d60177fa4046 Mon Sep 17 00:00:00 2001
From: Bo-Yi Wu <appleboy.tw@gmail.com>
Date: Thu, 27 Sep 2018 09:58:47 +0800
Subject: [PATCH 073/105] remove allow fail flag (#1573)

golang team revert the net/url issue: https://github.com/golang/go/issues/27302
---
 .travis.yml | 2 --
 1 file changed, 2 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index f9e241d7..a765f37f 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -10,8 +10,6 @@ go:
   - master
 
 matrix:
-  allow_failures:
-    - go: master
   fast_finish: true
 
 git:

From e9f187f60a27477e54c177f314db00d6a1abf062 Mon Sep 17 00:00:00 2001
From: James Pettyjohn <japettyjohn@users.noreply.github.com>
Date: Sun, 30 Sep 2018 19:49:39 -0700
Subject: [PATCH 074/105] removed use of sync.pool from HandleContext and added
 test coverage (#1565)

As per #1230 there is an issue when using HandleContext where the context of the request is returned to the context sync.Pool before the parent request has finished, causing context to be used in a non-thread safe manner.

I've removed the bug by not entering the context back in the pool and leaving that to ServeHTTP.

There was no test coverage for this function so I've also added the test to cover it. As the bug only happens when there are concurrent requests, the tests issues hundreds of concurrent requests. Without the bug fixed the tests do consistently recreate the error.
---
 gin.go                  |  1 -
 gin_integration_test.go | 24 ++++++++++++++++++++++++
 2 files changed, 24 insertions(+), 1 deletion(-)

diff --git a/gin.go b/gin.go
index 11f6d94a..92c24ba2 100644
--- a/gin.go
+++ b/gin.go
@@ -336,7 +336,6 @@ func (engine *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) {
 func (engine *Engine) HandleContext(c *Context) {
 	c.reset()
 	engine.handleHTTPRequest(c)
-	engine.pool.Put(c)
 }
 
 func (engine *Engine) handleHTTPRequest(c *Context) {
diff --git a/gin_integration_test.go b/gin_integration_test.go
index 52f78842..12a943b0 100644
--- a/gin_integration_test.go
+++ b/gin_integration_test.go
@@ -12,6 +12,7 @@ import (
 	"net/http"
 	"net/http/httptest"
 	"os"
+	"sync"
 	"testing"
 	"time"
 
@@ -119,6 +120,29 @@ func TestWithHttptestWithAutoSelectedPort(t *testing.T) {
 	testRequest(t, ts.URL+"/example")
 }
 
+func TestConcurrentHandleContext(t *testing.T) {
+	router := New()
+	router.GET("/", func(c *Context) {
+		c.Request.URL.Path = "/example"
+		router.HandleContext(c)
+	})
+	router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })
+
+	ts := httptest.NewServer(router)
+	defer ts.Close()
+
+	var wg sync.WaitGroup
+	iterations := 200
+	wg.Add(iterations)
+	for i := 0; i < iterations; i++ {
+		go func() {
+			testRequest(t, ts.URL+"/")
+			wg.Done()
+		}()
+	}
+	wg.Wait()
+}
+
 // func TestWithHttptestWithSpecifiedPort(t *testing.T) {
 // 	router := New()
 // 	router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })

From fbdcbd22751c7174d4f363995fca296e4670726b Mon Sep 17 00:00:00 2001
From: zesani <7sin@outlook.co.th>
Date: Tue, 9 Oct 2018 06:14:21 +0700
Subject: [PATCH 075/105] Update README.md (#1583)

change "hava" to "have"
---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 6fd2dd34..95bd3204 100644
--- a/README.md
+++ b/README.md
@@ -1721,11 +1721,11 @@ type StructX struct {
 }
 
 type StructY struct {
-    Y StructX `form:"name_y"` // HERE hava form
+    Y StructX `form:"name_y"` // HERE have form
 }
 
 type StructZ struct {
-    Z *StructZ `form:"name_z"` // HERE hava form
+    Z *StructZ `form:"name_z"` // HERE have form
 }
 ```
 

From 6ab50f944ca52bdd4d982d0bec454d94bf7b802a Mon Sep 17 00:00:00 2001
From: andriikushch <andrii.kushch@gmail.com>
Date: Fri, 12 Oct 2018 01:31:31 +0200
Subject: [PATCH 076/105] replace deprecated HeaderMap with Header() (#1585)

---
 auth_test.go          |  4 +--
 context_17_test.go    |  2 +-
 context_test.go       | 64 +++++++++++++++++++++----------------------
 render/render_test.go |  6 ++--
 routes_test.go        | 12 ++++----
 5 files changed, 44 insertions(+), 44 deletions(-)

diff --git a/auth_test.go b/auth_test.go
index ab7e94be..197e9208 100644
--- a/auth_test.go
+++ b/auth_test.go
@@ -122,7 +122,7 @@ func TestBasicAuth401(t *testing.T) {
 
 	assert.False(t, called)
 	assert.Equal(t, http.StatusUnauthorized, w.Code)
-	assert.Equal(t, "Basic realm=\"Authorization Required\"", w.HeaderMap.Get("WWW-Authenticate"))
+	assert.Equal(t, "Basic realm=\"Authorization Required\"", w.Header().Get("WWW-Authenticate"))
 }
 
 func TestBasicAuth401WithCustomRealm(t *testing.T) {
@@ -142,5 +142,5 @@ func TestBasicAuth401WithCustomRealm(t *testing.T) {
 
 	assert.False(t, called)
 	assert.Equal(t, http.StatusUnauthorized, w.Code)
-	assert.Equal(t, "Basic realm=\"My Custom \\\"Realm\\\"\"", w.HeaderMap.Get("WWW-Authenticate"))
+	assert.Equal(t, "Basic realm=\"My Custom \\\"Realm\\\"\"", w.Header().Get("WWW-Authenticate"))
 }
diff --git a/context_17_test.go b/context_17_test.go
index d2251904..5b9ebcdc 100644
--- a/context_17_test.go
+++ b/context_17_test.go
@@ -23,5 +23,5 @@ func TestContextRenderPureJSON(t *testing.T) {
 	c.PureJSON(http.StatusCreated, H{"foo": "bar", "html": "<b>"})
 	assert.Equal(t, http.StatusCreated, w.Code)
 	assert.Equal(t, "{\"foo\":\"bar\",\"html\":\"<b>\"}\n", w.Body.String())
-	assert.Equal(t, "application/json; charset=utf-8", w.HeaderMap.Get("Content-Type"))
+	assert.Equal(t, "application/json; charset=utf-8", w.Header().Get("Content-Type"))
 }
diff --git a/context_test.go b/context_test.go
index 5a5bb6e1..2e972f18 100644
--- a/context_test.go
+++ b/context_test.go
@@ -628,7 +628,7 @@ func TestContextRenderJSON(t *testing.T) {
 
 	assert.Equal(t, http.StatusCreated, w.Code)
 	assert.Equal(t, "{\"foo\":\"bar\",\"html\":\"\\u003cb\\u003e\"}", w.Body.String())
-	assert.Equal(t, "application/json; charset=utf-8", w.HeaderMap.Get("Content-Type"))
+	assert.Equal(t, "application/json; charset=utf-8", w.Header().Get("Content-Type"))
 }
 
 // Tests that the response is serialized as JSONP
@@ -642,7 +642,7 @@ func TestContextRenderJSONP(t *testing.T) {
 
 	assert.Equal(t, http.StatusCreated, w.Code)
 	assert.Equal(t, "x({\"foo\":\"bar\"})", w.Body.String())
-	assert.Equal(t, "application/javascript; charset=utf-8", w.HeaderMap.Get("Content-Type"))
+	assert.Equal(t, "application/javascript; charset=utf-8", w.Header().Get("Content-Type"))
 }
 
 // Tests that the response is serialized as JSONP
@@ -656,7 +656,7 @@ func TestContextRenderJSONPWithoutCallback(t *testing.T) {
 
 	assert.Equal(t, http.StatusCreated, w.Code)
 	assert.Equal(t, "{\"foo\":\"bar\"}", w.Body.String())
-	assert.Equal(t, "application/json; charset=utf-8", w.HeaderMap.Get("Content-Type"))
+	assert.Equal(t, "application/json; charset=utf-8", w.Header().Get("Content-Type"))
 }
 
 // Tests that no JSON is rendered if code is 204
@@ -668,7 +668,7 @@ func TestContextRenderNoContentJSON(t *testing.T) {
 
 	assert.Equal(t, http.StatusNoContent, w.Code)
 	assert.Empty(t, w.Body.String())
-	assert.Equal(t, "application/json; charset=utf-8", w.HeaderMap.Get("Content-Type"))
+	assert.Equal(t, "application/json; charset=utf-8", w.Header().Get("Content-Type"))
 }
 
 // Tests that the response is serialized as JSON
@@ -682,7 +682,7 @@ func TestContextRenderAPIJSON(t *testing.T) {
 
 	assert.Equal(t, http.StatusCreated, w.Code)
 	assert.Equal(t, "{\"foo\":\"bar\"}", w.Body.String())
-	assert.Equal(t, "application/vnd.api+json", w.HeaderMap.Get("Content-Type"))
+	assert.Equal(t, "application/vnd.api+json", w.Header().Get("Content-Type"))
 }
 
 // Tests that no Custom JSON is rendered if code is 204
@@ -695,7 +695,7 @@ func TestContextRenderNoContentAPIJSON(t *testing.T) {
 
 	assert.Equal(t, http.StatusNoContent, w.Code)
 	assert.Empty(t, w.Body.String())
-	assert.Equal(t, w.HeaderMap.Get("Content-Type"), "application/vnd.api+json")
+	assert.Equal(t, w.Header().Get("Content-Type"), "application/vnd.api+json")
 }
 
 // Tests that the response is serialized as JSON
@@ -708,7 +708,7 @@ func TestContextRenderIndentedJSON(t *testing.T) {
 
 	assert.Equal(t, http.StatusCreated, w.Code)
 	assert.Equal(t, "{\n    \"bar\": \"foo\",\n    \"foo\": \"bar\",\n    \"nested\": {\n        \"foo\": \"bar\"\n    }\n}", w.Body.String())
-	assert.Equal(t, "application/json; charset=utf-8", w.HeaderMap.Get("Content-Type"))
+	assert.Equal(t, "application/json; charset=utf-8", w.Header().Get("Content-Type"))
 }
 
 // Tests that no Custom JSON is rendered if code is 204
@@ -720,7 +720,7 @@ func TestContextRenderNoContentIndentedJSON(t *testing.T) {
 
 	assert.Equal(t, http.StatusNoContent, w.Code)
 	assert.Empty(t, w.Body.String())
-	assert.Equal(t, "application/json; charset=utf-8", w.HeaderMap.Get("Content-Type"))
+	assert.Equal(t, "application/json; charset=utf-8", w.Header().Get("Content-Type"))
 }
 
 // Tests that the response is serialized as Secure JSON
@@ -734,7 +734,7 @@ func TestContextRenderSecureJSON(t *testing.T) {
 
 	assert.Equal(t, http.StatusCreated, w.Code)
 	assert.Equal(t, "&&&START&&&[\"foo\",\"bar\"]", w.Body.String())
-	assert.Equal(t, "application/json; charset=utf-8", w.HeaderMap.Get("Content-Type"))
+	assert.Equal(t, "application/json; charset=utf-8", w.Header().Get("Content-Type"))
 }
 
 // Tests that no Custom JSON is rendered if code is 204
@@ -746,7 +746,7 @@ func TestContextRenderNoContentSecureJSON(t *testing.T) {
 
 	assert.Equal(t, http.StatusNoContent, w.Code)
 	assert.Empty(t, w.Body.String())
-	assert.Equal(t, "application/json; charset=utf-8", w.HeaderMap.Get("Content-Type"))
+	assert.Equal(t, "application/json; charset=utf-8", w.Header().Get("Content-Type"))
 }
 
 func TestContextRenderNoContentAsciiJSON(t *testing.T) {
@@ -757,7 +757,7 @@ func TestContextRenderNoContentAsciiJSON(t *testing.T) {
 
 	assert.Equal(t, http.StatusNoContent, w.Code)
 	assert.Empty(t, w.Body.String())
-	assert.Equal(t, "application/json", w.HeaderMap.Get("Content-Type"))
+	assert.Equal(t, "application/json", w.Header().Get("Content-Type"))
 }
 
 // Tests that the response executes the templates
@@ -773,7 +773,7 @@ func TestContextRenderHTML(t *testing.T) {
 
 	assert.Equal(t, http.StatusCreated, w.Code)
 	assert.Equal(t, "Hello alexandernyquist", w.Body.String())
-	assert.Equal(t, "text/html; charset=utf-8", w.HeaderMap.Get("Content-Type"))
+	assert.Equal(t, "text/html; charset=utf-8", w.Header().Get("Content-Type"))
 }
 
 func TestContextRenderHTML2(t *testing.T) {
@@ -797,7 +797,7 @@ func TestContextRenderHTML2(t *testing.T) {
 
 	assert.Equal(t, http.StatusCreated, w.Code)
 	assert.Equal(t, "Hello alexandernyquist", w.Body.String())
-	assert.Equal(t, "text/html; charset=utf-8", w.HeaderMap.Get("Content-Type"))
+	assert.Equal(t, "text/html; charset=utf-8", w.Header().Get("Content-Type"))
 }
 
 // Tests that no HTML is rendered if code is 204
@@ -811,7 +811,7 @@ func TestContextRenderNoContentHTML(t *testing.T) {
 
 	assert.Equal(t, http.StatusNoContent, w.Code)
 	assert.Empty(t, w.Body.String())
-	assert.Equal(t, "text/html; charset=utf-8", w.HeaderMap.Get("Content-Type"))
+	assert.Equal(t, "text/html; charset=utf-8", w.Header().Get("Content-Type"))
 }
 
 // TestContextXML tests that the response is serialized as XML
@@ -824,7 +824,7 @@ func TestContextRenderXML(t *testing.T) {
 
 	assert.Equal(t, http.StatusCreated, w.Code)
 	assert.Equal(t, "<map><foo>bar</foo></map>", w.Body.String())
-	assert.Equal(t, "application/xml; charset=utf-8", w.HeaderMap.Get("Content-Type"))
+	assert.Equal(t, "application/xml; charset=utf-8", w.Header().Get("Content-Type"))
 }
 
 // Tests that no XML is rendered if code is 204
@@ -836,7 +836,7 @@ func TestContextRenderNoContentXML(t *testing.T) {
 
 	assert.Equal(t, http.StatusNoContent, w.Code)
 	assert.Empty(t, w.Body.String())
-	assert.Equal(t, "application/xml; charset=utf-8", w.HeaderMap.Get("Content-Type"))
+	assert.Equal(t, "application/xml; charset=utf-8", w.Header().Get("Content-Type"))
 }
 
 // TestContextString tests that the response is returned
@@ -849,7 +849,7 @@ func TestContextRenderString(t *testing.T) {
 
 	assert.Equal(t, http.StatusCreated, w.Code)
 	assert.Equal(t, "test string 2", w.Body.String())
-	assert.Equal(t, "text/plain; charset=utf-8", w.HeaderMap.Get("Content-Type"))
+	assert.Equal(t, "text/plain; charset=utf-8", w.Header().Get("Content-Type"))
 }
 
 // Tests that no String is rendered if code is 204
@@ -861,7 +861,7 @@ func TestContextRenderNoContentString(t *testing.T) {
 
 	assert.Equal(t, http.StatusNoContent, w.Code)
 	assert.Empty(t, w.Body.String())
-	assert.Equal(t, "text/plain; charset=utf-8", w.HeaderMap.Get("Content-Type"))
+	assert.Equal(t, "text/plain; charset=utf-8", w.Header().Get("Content-Type"))
 }
 
 // TestContextString tests that the response is returned
@@ -875,7 +875,7 @@ func TestContextRenderHTMLString(t *testing.T) {
 
 	assert.Equal(t, http.StatusCreated, w.Code)
 	assert.Equal(t, "<html>string 3</html>", w.Body.String())
-	assert.Equal(t, "text/html; charset=utf-8", w.HeaderMap.Get("Content-Type"))
+	assert.Equal(t, "text/html; charset=utf-8", w.Header().Get("Content-Type"))
 }
 
 // Tests that no HTML String is rendered if code is 204
@@ -888,7 +888,7 @@ func TestContextRenderNoContentHTMLString(t *testing.T) {
 
 	assert.Equal(t, http.StatusNoContent, w.Code)
 	assert.Empty(t, w.Body.String())
-	assert.Equal(t, "text/html; charset=utf-8", w.HeaderMap.Get("Content-Type"))
+	assert.Equal(t, "text/html; charset=utf-8", w.Header().Get("Content-Type"))
 }
 
 // TestContextData tests that the response can be written from `bytesting`
@@ -901,7 +901,7 @@ func TestContextRenderData(t *testing.T) {
 
 	assert.Equal(t, http.StatusCreated, w.Code)
 	assert.Equal(t, "foo,bar", w.Body.String())
-	assert.Equal(t, "text/csv", w.HeaderMap.Get("Content-Type"))
+	assert.Equal(t, "text/csv", w.Header().Get("Content-Type"))
 }
 
 // Tests that no Custom Data is rendered if code is 204
@@ -913,7 +913,7 @@ func TestContextRenderNoContentData(t *testing.T) {
 
 	assert.Equal(t, http.StatusNoContent, w.Code)
 	assert.Empty(t, w.Body.String())
-	assert.Equal(t, "text/csv", w.HeaderMap.Get("Content-Type"))
+	assert.Equal(t, "text/csv", w.Header().Get("Content-Type"))
 }
 
 func TestContextRenderSSE(t *testing.T) {
@@ -942,7 +942,7 @@ func TestContextRenderFile(t *testing.T) {
 
 	assert.Equal(t, http.StatusOK, w.Code)
 	assert.Contains(t, w.Body.String(), "func New() *Engine {")
-	assert.Equal(t, "text/plain; charset=utf-8", w.HeaderMap.Get("Content-Type"))
+	assert.Equal(t, "text/plain; charset=utf-8", w.Header().Get("Content-Type"))
 }
 
 // TestContextRenderYAML tests that the response is serialized as YAML
@@ -955,7 +955,7 @@ func TestContextRenderYAML(t *testing.T) {
 
 	assert.Equal(t, http.StatusCreated, w.Code)
 	assert.Equal(t, "foo: bar\n", w.Body.String())
-	assert.Equal(t, "application/x-yaml; charset=utf-8", w.HeaderMap.Get("Content-Type"))
+	assert.Equal(t, "application/x-yaml; charset=utf-8", w.Header().Get("Content-Type"))
 }
 
 // TestContextRenderProtoBuf tests that the response is serialized as ProtoBuf
@@ -979,7 +979,7 @@ func TestContextRenderProtoBuf(t *testing.T) {
 
 	assert.Equal(t, http.StatusCreated, w.Code)
 	assert.Equal(t, string(protoData), w.Body.String())
-	assert.Equal(t, "application/x-protobuf", w.HeaderMap.Get("Content-Type"))
+	assert.Equal(t, "application/x-protobuf", w.Header().Get("Content-Type"))
 }
 
 func TestContextHeaders(t *testing.T) {
@@ -1062,7 +1062,7 @@ func TestContextNegotiationWithJSON(t *testing.T) {
 
 	assert.Equal(t, http.StatusOK, w.Code)
 	assert.Equal(t, "{\"foo\":\"bar\"}", w.Body.String())
-	assert.Equal(t, "application/json; charset=utf-8", w.HeaderMap.Get("Content-Type"))
+	assert.Equal(t, "application/json; charset=utf-8", w.Header().Get("Content-Type"))
 }
 
 func TestContextNegotiationWithXML(t *testing.T) {
@@ -1077,7 +1077,7 @@ func TestContextNegotiationWithXML(t *testing.T) {
 
 	assert.Equal(t, http.StatusOK, w.Code)
 	assert.Equal(t, "<map><foo>bar</foo></map>", w.Body.String())
-	assert.Equal(t, "application/xml; charset=utf-8", w.HeaderMap.Get("Content-Type"))
+	assert.Equal(t, "application/xml; charset=utf-8", w.Header().Get("Content-Type"))
 }
 
 func TestContextNegotiationWithHTML(t *testing.T) {
@@ -1095,7 +1095,7 @@ func TestContextNegotiationWithHTML(t *testing.T) {
 
 	assert.Equal(t, http.StatusOK, w.Code)
 	assert.Equal(t, "Hello gin", w.Body.String())
-	assert.Equal(t, "text/html; charset=utf-8", w.HeaderMap.Get("Content-Type"))
+	assert.Equal(t, "text/html; charset=utf-8", w.Header().Get("Content-Type"))
 }
 
 func TestContextNegotiationNotSupport(t *testing.T) {
@@ -1131,7 +1131,7 @@ func TestContextNegotiationFormatWithAccept(t *testing.T) {
 	assert.Empty(t, c.NegotiateFormat(MIMEJSON))
 }
 
-func TestContextNegotiationFormatCustum(t *testing.T) {
+func TestContextNegotiationFormatCustom(t *testing.T) {
 	c, _ := CreateTestContext(httptest.NewRecorder())
 	c.Request, _ = http.NewRequest("POST", "/", nil)
 	c.Request.Header.Add("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8")
@@ -1627,9 +1627,9 @@ func TestContextRenderDataFromReader(t *testing.T) {
 
 	assert.Equal(t, http.StatusOK, w.Code)
 	assert.Equal(t, body, w.Body.String())
-	assert.Equal(t, contentType, w.HeaderMap.Get("Content-Type"))
-	assert.Equal(t, fmt.Sprintf("%d", contentLength), w.HeaderMap.Get("Content-Length"))
-	assert.Equal(t, extraHeaders["Content-Disposition"], w.HeaderMap.Get("Content-Disposition"))
+	assert.Equal(t, contentType, w.Header().Get("Content-Type"))
+	assert.Equal(t, fmt.Sprintf("%d", contentLength), w.Header().Get("Content-Length"))
+	assert.Equal(t, extraHeaders["Content-Disposition"], w.Header().Get("Content-Disposition"))
 }
 
 type TestResponseRecorder struct {
diff --git a/render/render_test.go b/render/render_test.go
index 09ccc658..4c9b180d 100644
--- a/render/render_test.go
+++ b/render/render_test.go
@@ -480,7 +480,7 @@ func TestRenderReader(t *testing.T) {
 
 	assert.NoError(t, err)
 	assert.Equal(t, body, w.Body.String())
-	assert.Equal(t, "image/png", w.HeaderMap.Get("Content-Type"))
-	assert.Equal(t, strconv.Itoa(len(body)), w.HeaderMap.Get("Content-Length"))
-	assert.Equal(t, headers["Content-Disposition"], w.HeaderMap.Get("Content-Disposition"))
+	assert.Equal(t, "image/png", w.Header().Get("Content-Type"))
+	assert.Equal(t, strconv.Itoa(len(body)), w.Header().Get("Content-Length"))
+	assert.Equal(t, headers["Content-Disposition"], w.Header().Get("Content-Disposition"))
 }
diff --git a/routes_test.go b/routes_test.go
index 23e749e2..60f1c81b 100644
--- a/routes_test.go
+++ b/routes_test.go
@@ -267,7 +267,7 @@ func TestRouteStaticFile(t *testing.T) {
 	assert.Equal(t, w, w2)
 	assert.Equal(t, http.StatusOK, w.Code)
 	assert.Equal(t, "Gin Web Framework", w.Body.String())
-	assert.Equal(t, "text/plain; charset=utf-8", w.HeaderMap.Get("Content-Type"))
+	assert.Equal(t, "text/plain; charset=utf-8", w.Header().Get("Content-Type"))
 
 	w3 := performRequest(router, "HEAD", "/using_static/"+filename)
 	w4 := performRequest(router, "HEAD", "/result")
@@ -285,7 +285,7 @@ func TestRouteStaticListingDir(t *testing.T) {
 
 	assert.Equal(t, http.StatusOK, w.Code)
 	assert.Contains(t, w.Body.String(), "gin.go")
-	assert.Equal(t, "text/html; charset=utf-8", w.HeaderMap.Get("Content-Type"))
+	assert.Equal(t, "text/html; charset=utf-8", w.Header().Get("Content-Type"))
 }
 
 // TestHandleHeadToDir - ensure the root/sub dir handles properly
@@ -312,10 +312,10 @@ func TestRouterMiddlewareAndStatic(t *testing.T) {
 
 	assert.Equal(t, http.StatusOK, w.Code)
 	assert.Contains(t, w.Body.String(), "package gin")
-	assert.Equal(t, "text/plain; charset=utf-8", w.HeaderMap.Get("Content-Type"))
-	assert.NotEqual(t, w.HeaderMap.Get("Last-Modified"), "Mon, 02 Jan 2006 15:04:05 MST")
-	assert.Equal(t, "Mon, 02 Jan 2006 15:04:05 MST", w.HeaderMap.Get("Expires"))
-	assert.Equal(t, "Gin Framework", w.HeaderMap.Get("x-GIN"))
+	assert.Equal(t, "text/plain; charset=utf-8", w.Header().Get("Content-Type"))
+	assert.NotEqual(t, w.Header().Get("Last-Modified"), "Mon, 02 Jan 2006 15:04:05 MST")
+	assert.Equal(t, "Mon, 02 Jan 2006 15:04:05 MST", w.Header().Get("Expires"))
+	assert.Equal(t, "Gin Framework", w.Header().Get("x-GIN"))
 }
 
 func TestRouteNotAllowedEnabled(t *testing.T) {

From 268e30710b77e1cd48b25df235cf702dc8e942a2 Mon Sep 17 00:00:00 2001
From: Bo-Yi Wu <appleboy.tw@gmail.com>
Date: Sun, 14 Oct 2018 11:05:24 +0800
Subject: [PATCH 077/105] fix(Makefile): golint to new URL (#1592)

as title. Just update the golint to new URL.
---
 Makefile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Makefile b/Makefile
index 51b9969f..ea7b4f7c 100644
--- a/Makefile
+++ b/Makefile
@@ -43,7 +43,7 @@ embedmd:
 .PHONY: lint
 lint:
 	@hash golint > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
-		go get -u github.com/golang/lint/golint; \
+		go get -u golang.org/x/lint/golint; \
 	fi
 	for PKG in $(PACKAGES); do golint -set_exit_status $$PKG || exit 1; done;
 

From 01ca2530d4b6c44c718b00c06f0e1d092572d49e Mon Sep 17 00:00:00 2001
From: Bo-Yi Wu <appleboy.tw@gmail.com>
Date: Sun, 14 Oct 2018 12:39:16 +0800
Subject: [PATCH 078/105] refactor(Makefile): allow overriding default go
 program (#1593)

---
 Makefile    | 28 ++++++++++++++++++----------
 coverage.sh | 13 -------------
 2 files changed, 18 insertions(+), 23 deletions(-)
 delete mode 100644 coverage.sh

diff --git a/Makefile b/Makefile
index ea7b4f7c..c20429a1 100644
--- a/Makefile
+++ b/Makefile
@@ -1,7 +1,9 @@
+GO ?= go
 GOFMT ?= gofmt "-s"
-PACKAGES ?= $(shell go list ./... | grep -v /vendor/)
-VETPACKAGES ?= $(shell go list ./... | grep -v /vendor/ | grep -v /examples/)
+PACKAGES ?= $(shell $(GO) list ./... | grep -v /vendor/)
+VETPACKAGES ?= $(shell $(GO) list ./... | grep -v /vendor/ | grep -v /examples/)
 GOFILES := $(shell find . -name "*.go" -type f -not -path "./vendor/*")
+TESTFOLDER := $(shell $(GO) list ./... | grep -E 'gin$$|binding$$|render$$' | grep -v examples)
 
 all: install
 
@@ -10,7 +12,14 @@ install: deps
 
 .PHONY: test
 test:
-	sh coverage.sh
+	echo "mode: count" > coverage.out
+	for d in $(TESTFOLDER); do \
+		$(GO) test -v -covermode=count -coverprofile=profile.out $$d; \
+		if [ -f profile.out ]; then \
+			cat profile.out | grep -v "mode:" >> coverage.out; \
+			rm profile.out; \
+		fi; \
+	done
 
 .PHONY: fmt
 fmt:
@@ -18,7 +27,6 @@ fmt:
 
 .PHONY: fmt-check
 fmt-check:
-	# get all go files and run go fmt on them
 	@diff=$$($(GOFMT) -d $(GOFILES)); \
 	if [ -n "$$diff" ]; then \
 		echo "Please run 'make fmt' and commit the result:"; \
@@ -27,14 +35,14 @@ fmt-check:
 	fi;
 
 vet:
-	go vet $(VETPACKAGES)
+	$(GO) vet $(VETPACKAGES)
 
 deps:
 	@hash govendor > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
-		go get -u github.com/kardianos/govendor; \
+		$(GO) get -u github.com/kardianos/govendor; \
 	fi
 	@hash embedmd > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
-		go get -u github.com/campoy/embedmd; \
+		$(GO) get -u github.com/campoy/embedmd; \
 	fi
 
 embedmd:
@@ -43,20 +51,20 @@ embedmd:
 .PHONY: lint
 lint:
 	@hash golint > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
-		go get -u golang.org/x/lint/golint; \
+		$(GO) get -u golang.org/x/lint/golint; \
 	fi
 	for PKG in $(PACKAGES); do golint -set_exit_status $$PKG || exit 1; done;
 
 .PHONY: misspell-check
 misspell-check:
 	@hash misspell > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
-		go get -u github.com/client9/misspell/cmd/misspell; \
+		$(GO) get -u github.com/client9/misspell/cmd/misspell; \
 	fi
 	misspell -error $(GOFILES)
 
 .PHONY: misspell
 misspell:
 	@hash misspell > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
-		go get -u github.com/client9/misspell/cmd/misspell; \
+		$(GO) get -u github.com/client9/misspell/cmd/misspell; \
 	fi
 	misspell -w $(GOFILES)
diff --git a/coverage.sh b/coverage.sh
deleted file mode 100644
index 4d1ee036..00000000
--- a/coverage.sh
+++ /dev/null
@@ -1,13 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-
-echo "mode: count" > coverage.out
-
-for d in $(go list ./... | grep -E 'gin$|binding$|render$' | grep -v 'examples'); do
-    go test -v -covermode=count -coverprofile=profile.out $d
-    if [ -f profile.out ]; then
-        cat profile.out | grep -v "mode:" >> coverage.out
-        rm profile.out
-    fi
-done

From 523435e5245faade0a43a33bd3faab32456bab32 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Mon, 15 Oct 2018 12:52:51 +0800
Subject: [PATCH 079/105] attempt to support go module (#1569)

* support go module

* update golint package url

* update golint
---
 .travis.yml | 10 +++++++++-
 Makefile    |  6 ++++++
 go.mod      | 13 ++++++++-----
 go.sum      | 26 ++++++++++++++++----------
 tools.go    | 25 +++++++++++++++++++++++++
 5 files changed, 64 insertions(+), 16 deletions(-)
 create mode 100644 tools.go

diff --git a/.travis.yml b/.travis.yml
index a765f37f..2eeb0b3d 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -11,12 +11,20 @@ go:
 
 matrix:
   fast_finish: true
+  include:
+  - go: 1.11.x
+    env: GO111MODULE=on
 
 git:
   depth: 10
 
+before_install:
+  - if [[ "${GO111MODULE}" = "on" ]]; then mkdir "${HOME}/go"; export GOPATH="${HOME}/go"; fi
+
 install:
-  - make install
+  - if [[ "${GO111MODULE}" = "on" ]]; then go mod download; else make install; fi
+  - if [[ "${GO111MODULE}" = "on" ]]; then export PATH="${GOPATH}/bin:${GOROOT}/bin:${PATH}"; fi
+  - if [[ "${GO111MODULE}" = "on" ]]; then make tools; fi
 
 go_import_path: github.com/gin-gonic/gin
 
diff --git a/Makefile b/Makefile
index c20429a1..b698ac09 100644
--- a/Makefile
+++ b/Makefile
@@ -68,3 +68,9 @@ misspell:
 		$(GO) get -u github.com/client9/misspell/cmd/misspell; \
 	fi
 	misspell -w $(GOFILES)
+
+.PHONY: tools
+tools:
+	go install golang.org/x/lint/golint; \
+	go install github.com/client9/misspell/cmd/misspell; \
+	go install github.com/campoy/embedmd;
diff --git a/go.mod b/go.mod
index bd4ad975..0797b934 100644
--- a/go.mod
+++ b/go.mod
@@ -1,25 +1,28 @@
 module github.com/gin-gonic/gin
 
 require (
-	github.com/davecgh/go-spew v0.0.0-20180221232628-8991bc29aa16 // indirect
+	github.com/campoy/embedmd v0.0.0-20171205015432-c59ce00e0296
+	github.com/client9/misspell v0.3.4
+	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/dustin/go-broadcast v0.0.0-20171205050544-f664265f5a66
 	github.com/gin-contrib/sse v0.0.0-20170109093832-22d885f9ecc7
 	github.com/gin-gonic/autotls v0.0.0-20180426091246-be87bd5ef97b
 	github.com/golang/protobuf v1.2.0
 	github.com/jessevdk/go-assets v0.0.0-20160921144138-4f4301a06e15
-	github.com/json-iterator/go v0.0.0-20180806060727-1624edc4454b
+	github.com/json-iterator/go v1.1.5
 	github.com/manucorporat/stats v0.0.0-20180402194714-3ba42d56d227
 	github.com/mattn/go-isatty v0.0.3
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/stretchr/testify v1.2.2
-	github.com/thinkerou/favicon v0.0.0-20170710140520-94a442a49da6
+	github.com/thinkerou/favicon v0.1.0
 	github.com/ugorji/go v1.1.1
-	golang.org/x/crypto v0.0.0-20180910181607-0e37d006457b
+	golang.org/x/crypto v0.0.0-20180927165925-5295e8364332
+	golang.org/x/lint v0.0.0-20180702182130-06c8688daad7
 	golang.org/x/net v0.0.0-20180826012351-8a410e7b638d
 	golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f
-	golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e // indirect
+	golang.org/x/sys v0.0.0-20180928133829-e4b3c5e90611 // indirect
 	google.golang.org/grpc v1.15.0
 	gopkg.in/go-playground/assert.v1 v1.2.1 // indirect
 	gopkg.in/go-playground/validator.v8 v8.18.2
diff --git a/go.sum b/go.sum
index 3382beed..2d307e7e 100644
--- a/go.sum
+++ b/go.sum
@@ -1,7 +1,10 @@
 cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+github.com/campoy/embedmd v0.0.0-20171205015432-c59ce00e0296 h1:tRsilif6pbtt+PX6uRoyGd+qR+4ZPucFZLHlc3Ak6z8=
+github.com/campoy/embedmd v0.0.0-20171205015432-c59ce00e0296/go.mod h1:/dBk8ICkslPCmyRdn4azP+QvBxL6Eg3EYxUGI9xMMFw=
+github.com/client9/misspell v0.3.4 h1:ta993UF76GwbvJcIo3Y68y/M3WxlpEHPWIGDkJYwzJI=
 github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
-github.com/davecgh/go-spew v0.0.0-20180221232628-8991bc29aa16 h1:HqkufMBR7waVfFFRABWqHa1WgTvjtVDJTLJe3CR576A=
-github.com/davecgh/go-spew v0.0.0-20180221232628-8991bc29aa16/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/dustin/go-broadcast v0.0.0-20171205050544-f664265f5a66 h1:QnnoVdChKs+GeTvN4rPYTW6b5U6M3HMEvQ/+x4IGtfY=
 github.com/dustin/go-broadcast v0.0.0-20171205050544-f664265f5a66/go.mod h1:kTEh6M2J/mh7nsskr28alwLCXm/DSG5OSA/o31yy2XU=
 github.com/gin-contrib/sse v0.0.0-20170109093832-22d885f9ecc7 h1:AzN37oI0cOS+cougNAV9szl6CVoj2RYwzS3DpUQNtlY=
@@ -10,14 +13,15 @@ github.com/gin-gonic/autotls v0.0.0-20180426091246-be87bd5ef97b h1:dm/NYytoj7p8J
 github.com/gin-gonic/autotls v0.0.0-20180426091246-be87bd5ef97b/go.mod h1:vwfeXwKgEIWq63oVfwaBjoByS4dZzYbHHROHjV4IjNY=
 github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b h1:VKtxabqXZkF25pY9ekfRL6a582T4P37/31XEstQ5p58=
 github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
+github.com/golang/lint v0.0.0-20180702182130-06c8688daad7 h1:2hRPrmiwPrp3fQX967rNJIhQPtiGXdlQWAxKbKw3VHA=
 github.com/golang/lint v0.0.0-20180702182130-06c8688daad7/go.mod h1:tluoj9z5200jBnyusfRPU2LqT6J+DAorxEvtC7LHB+E=
 github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
 github.com/golang/protobuf v1.2.0 h1:P3YflyNX/ehuJFLhxviNdFxQPkGK5cDcApsge1SqnvM=
 github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/jessevdk/go-assets v0.0.0-20160921144138-4f4301a06e15 h1:cW/amwGEJK5MSKntPXRjX4dxs/nGxGT8gXKIsKFmHGc=
 github.com/jessevdk/go-assets v0.0.0-20160921144138-4f4301a06e15/go.mod h1:Fdm/oWRW+CH8PRbLntksCNtmcCBximKPkVQYvmMl80k=
-github.com/json-iterator/go v0.0.0-20180806060727-1624edc4454b h1:X61dhFTE1Au92SvyF8HyAwdjWqiSdfBgFR7wTxC0+uU=
-github.com/json-iterator/go v0.0.0-20180806060727-1624edc4454b/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
+github.com/json-iterator/go v1.1.5 h1:gL2yXlmiIo4+t+y32d4WGwOjKGYcGOuyrg46vadswDE=
+github.com/json-iterator/go v1.1.5/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
 github.com/manucorporat/stats v0.0.0-20180402194714-3ba42d56d227 h1:KIaAZ/V+/0/6BOULrmBQ9T1ed8BkKqGIjIKW923nJuo=
 github.com/manucorporat/stats v0.0.0-20180402194714-3ba42d56d227/go.mod h1:ruMr5t05gVho4tuDv0PbI0Bb8nOxc/5Y6JzRHe/yfA0=
@@ -31,12 +35,13 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/stretchr/testify v1.2.2 h1:bSDNvY7ZPG5RlJ8otE/7V6gMiyenm9RtJ7IUVIAoJ1w=
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
-github.com/thinkerou/favicon v0.0.0-20170710140520-94a442a49da6 h1:d/LEgOfWe+AlOCz/kzmkvlO+gq9LRGhjSHqt2nx8Muc=
-github.com/thinkerou/favicon v0.0.0-20170710140520-94a442a49da6/go.mod h1:HL7Pap5kOluZv1ku34pZo/AJ44GaxMEPFZ3pmuexV2s=
+github.com/thinkerou/favicon v0.1.0 h1:eWMISKTpHq2G8HOuKn7ydD55j5DDehx94b0C2y8ABMs=
+github.com/thinkerou/favicon v0.1.0/go.mod h1:HL7Pap5kOluZv1ku34pZo/AJ44GaxMEPFZ3pmuexV2s=
 github.com/ugorji/go v1.1.1 h1:gmervu+jDMvXTbcHQ0pd2wee85nEoE0BsVyEuzkfK8w=
 github.com/ugorji/go v1.1.1/go.mod h1:hnLbHMwcvSihnDhEfx2/BzKp2xb0Y+ErdfYcrs9tkJQ=
-golang.org/x/crypto v0.0.0-20180910181607-0e37d006457b h1:2b9XGzhjiYsYPnKXoEfL7klWZQIt8IfyRCz62gCqqlQ=
-golang.org/x/crypto v0.0.0-20180910181607-0e37d006457b/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20180927165925-5295e8364332 h1:hvQVdF6P9DX4OiKA5tpehlG6JsgzmyQiThG7q5Bn3UQ=
+golang.org/x/crypto v0.0.0-20180927165925-5295e8364332/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/lint v0.0.0-20180702182130-06c8688daad7 h1:00BeQWmeaGazuOrq8Q5K5d3/cHaGuFrZzpaHBXfrsUA=
 golang.org/x/lint v0.0.0-20180702182130-06c8688daad7/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
 golang.org/x/net v0.0.0-20180826012351-8a410e7b638d h1:g9qWBGx4puODJTMVyoPrpoxPFgVGd+z1DZwjfRu4d0I=
 golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
@@ -44,10 +49,11 @@ golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAG
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f h1:wMNYb4v58l5UBM7MYRLPG6ZhfOqbKu7X5eyFl8ZhKvA=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e h1:o3PsSEY8E4eXWkXrIP9YJALUkVZqzHJT5DOasTyn8Vs=
-golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20180928133829-e4b3c5e90611 h1:O33LKL7WyJgjN9CvxfTIomjIClbd/Kq86/iipowHQU0=
+golang.org/x/sys v0.0.0-20180928133829-e4b3c5e90611/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/tools v0.0.0-20180828015842-6cd1fcedba52 h1:JG/0uqcGdTNgq7FdU+61l5Pdmb8putNZlXb65bJBROs=
 golang.org/x/tools v0.0.0-20180828015842-6cd1fcedba52/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
 google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8 h1:Nw54tB0rB7hY/N0NQvRW8DG4Yk3Q6T9cu9RcFQDu1tc=
diff --git a/tools.go b/tools.go
new file mode 100644
index 00000000..9f96406a
--- /dev/null
+++ b/tools.go
@@ -0,0 +1,25 @@
+// Copyright 2018 Gin Core Team.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+// +build tools
+
+// This file exists to cause `go mod` and `go get` to believe these tools
+// are dependencies, even though they are not runtime dependencies of any
+// gin package. This means they will appear in `go.mod` file, but will not
+// be a part of the build.
+
+package gin
+
+import (
+	_ "github.com/campoy/embedmd"
+	_ "github.com/client9/misspell/cmd/misspell"
+	_ "github.com/dustin/go-broadcast"
+	_ "github.com/gin-gonic/autotls"
+	_ "github.com/jessevdk/go-assets"
+	_ "github.com/manucorporat/stats"
+	_ "github.com/thinkerou/favicon"
+	_ "golang.org/x/crypto/acme/autocert"
+	_ "golang.org/x/lint/golint"
+	_ "google.golang.org/grpc"
+)

From 98082fd590798eda8bdada82fd1550dfe6941964 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Mon, 15 Oct 2018 13:01:44 +0800
Subject: [PATCH 080/105] document: add docs dir and middleware document
 (#1521)

* init docs dir

* add middleware document

* fix indent

* update docs
---
 docs/how-to-build-an-effective-middleware.md | 137 +++++++++++++++++++
 1 file changed, 137 insertions(+)
 create mode 100644 docs/how-to-build-an-effective-middleware.md

diff --git a/docs/how-to-build-an-effective-middleware.md b/docs/how-to-build-an-effective-middleware.md
new file mode 100644
index 00000000..db04428c
--- /dev/null
+++ b/docs/how-to-build-an-effective-middleware.md
@@ -0,0 +1,137 @@
+# How to build one effective middleware?
+
+## Consitituent part
+
+The middleware has two parts:
+
+  - part one is what is executed once, when you initalize your middleware. That's where you set up all the global objects, logicals etc. Everything that happens one per application lifetime.
+
+  - part two is what executes on every request. For example, a database middleware you simply inject your "global" database object into the context. Once it's inside the context, you can retrieve it from within other middlewares and your handler furnction.
+
+```go
+func funcName(params string) gin.HandlerFunc {
+    // <---
+    // This is part one
+    // --->
+    // The follow code is an example
+    if err := check(params); err != nil {
+        panic(err)
+    }
+
+    return func(c *gin.Context) {
+        // <---
+        // This is part two
+        // --->
+        // The follow code is an example
+        c.Set("TestVar", params)
+        c.Next()    
+    }
+}
+```
+
+## Execution process
+
+Firstly, we have the follow example code:
+
+```go
+func main() {
+	router := gin.Default()
+
+	router.Use(globalMiddleware())
+
+	router.GET("/rest/n/api/*some", mid1(), mid2(), handler)
+
+	router.Run()
+}
+
+func globalMiddleware() gin.HandlerFunc {
+	fmt.Println("globalMiddleware...1")
+
+	return func(c *gin.Context) {
+		fmt.Println("globalMiddleware...2")
+		c.Next()
+		fmt.Println("globalMiddleware...3")
+	}
+}
+
+func handler(c *gin.Context) {
+	fmt.Println("exec handler.")
+}
+
+func mid1() gin.HandlerFunc {
+	fmt.Println("mid1...1")
+
+	return func(c *gin.Context) {
+
+		fmt.Println("mid1...2")
+		c.Next()
+		fmt.Println("mid1...3")
+	}
+}
+
+func mid2() gin.HandlerFunc {
+	fmt.Println("mid2...1")
+
+	return func(c *gin.Context) {
+		fmt.Println("mid2...2")
+		c.Next()
+		fmt.Println("mid2...3")
+	}
+}
+```
+
+According to [Consitituent part](#consitituent-part) said, when we run the gin process, **part one** will execute firstly and will print the follow information:
+
+```go
+globalMiddleware...1
+mid1...1
+mid2...1
+```
+
+And init order are:
+
+```go
+globalMiddleware...1
+    |
+    v
+mid1...1
+    |
+    v
+mid2...1
+```
+
+When we curl one request `curl -v localhost:8080/rest/n/api/some`, **part two** will execute their middleware and output the following information:
+
+```go
+globalMiddleware...2
+mid1...2
+mid2...2
+exec handler.
+mid2...3
+mid1...3
+globalMiddleware...3
+```
+
+In other words, run order are:
+
+```go
+globalMiddleware...2
+    |
+    v
+mid1...2
+    |
+    v
+mid2...2
+    |
+    v
+exec handler.
+    |
+    v
+mid2...3
+    |
+    v
+mid1...3
+    |
+    v
+globalMiddleware...3
+```

From 524757b81c99e51a64e6ecc7ee0c181abc39bd79 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Mon, 15 Oct 2018 20:24:32 +0800
Subject: [PATCH 081/105] vendor: upgrade some dependency package version
 (#1596)

ref https://github.com/gin-gonic/gin/pull/1569#issuecomment-429731722
---
 go.mod             | 10 +++++-----
 go.sum             | 19 ++++++++++---------
 vendor/vendor.json | 43 +++++++++++++++++++++++++------------------
 3 files changed, 40 insertions(+), 32 deletions(-)

diff --git a/go.mod b/go.mod
index 0797b934..ef4103fd 100644
--- a/go.mod
+++ b/go.mod
@@ -11,18 +11,18 @@ require (
 	github.com/jessevdk/go-assets v0.0.0-20160921144138-4f4301a06e15
 	github.com/json-iterator/go v1.1.5
 	github.com/manucorporat/stats v0.0.0-20180402194714-3ba42d56d227
-	github.com/mattn/go-isatty v0.0.3
+	github.com/mattn/go-isatty v0.0.4
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/stretchr/testify v1.2.2
 	github.com/thinkerou/favicon v0.1.0
 	github.com/ugorji/go v1.1.1
-	golang.org/x/crypto v0.0.0-20180927165925-5295e8364332
-	golang.org/x/lint v0.0.0-20180702182130-06c8688daad7
-	golang.org/x/net v0.0.0-20180826012351-8a410e7b638d
+	golang.org/x/crypto v0.0.0-20181015023909-0c41d7ab0a0e
+	golang.org/x/lint v0.0.0-20181011164241-5906bd5c48cd
+	golang.org/x/net v0.0.0-20181011144130-49bb7cea24b1
 	golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f
-	golang.org/x/sys v0.0.0-20180928133829-e4b3c5e90611 // indirect
+	golang.org/x/sys v0.0.0-20181011152604-fa43e7bc11ba // indirect
 	google.golang.org/grpc v1.15.0
 	gopkg.in/go-playground/assert.v1 v1.2.1 // indirect
 	gopkg.in/go-playground/validator.v8 v8.18.2
diff --git a/go.sum b/go.sum
index 2d307e7e..2ef7f13b 100644
--- a/go.sum
+++ b/go.sum
@@ -13,7 +13,6 @@ github.com/gin-gonic/autotls v0.0.0-20180426091246-be87bd5ef97b h1:dm/NYytoj7p8J
 github.com/gin-gonic/autotls v0.0.0-20180426091246-be87bd5ef97b/go.mod h1:vwfeXwKgEIWq63oVfwaBjoByS4dZzYbHHROHjV4IjNY=
 github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b h1:VKtxabqXZkF25pY9ekfRL6a582T4P37/31XEstQ5p58=
 github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
-github.com/golang/lint v0.0.0-20180702182130-06c8688daad7 h1:2hRPrmiwPrp3fQX967rNJIhQPtiGXdlQWAxKbKw3VHA=
 github.com/golang/lint v0.0.0-20180702182130-06c8688daad7/go.mod h1:tluoj9z5200jBnyusfRPU2LqT6J+DAorxEvtC7LHB+E=
 github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
 github.com/golang/protobuf v1.2.0 h1:P3YflyNX/ehuJFLhxviNdFxQPkGK5cDcApsge1SqnvM=
@@ -25,8 +24,8 @@ github.com/json-iterator/go v1.1.5/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCV
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
 github.com/manucorporat/stats v0.0.0-20180402194714-3ba42d56d227 h1:KIaAZ/V+/0/6BOULrmBQ9T1ed8BkKqGIjIKW923nJuo=
 github.com/manucorporat/stats v0.0.0-20180402194714-3ba42d56d227/go.mod h1:ruMr5t05gVho4tuDv0PbI0Bb8nOxc/5Y6JzRHe/yfA0=
-github.com/mattn/go-isatty v0.0.3 h1:ns/ykhmWi7G9O+8a448SecJU3nSMBXJfqQkl0upE1jI=
-github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
+github.com/mattn/go-isatty v0.0.4 h1:bnP0vzxcAdeI1zdubAl5PjU6zsERjGZb7raWodagDYs=
+github.com/mattn/go-isatty v0.0.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/reflect2 v1.0.1 h1:9f412s+6RmYXLWZSEzVVgPGK7C2PphHj5RJrvfx9AWI=
@@ -39,18 +38,20 @@ github.com/thinkerou/favicon v0.1.0 h1:eWMISKTpHq2G8HOuKn7ydD55j5DDehx94b0C2y8AB
 github.com/thinkerou/favicon v0.1.0/go.mod h1:HL7Pap5kOluZv1ku34pZo/AJ44GaxMEPFZ3pmuexV2s=
 github.com/ugorji/go v1.1.1 h1:gmervu+jDMvXTbcHQ0pd2wee85nEoE0BsVyEuzkfK8w=
 github.com/ugorji/go v1.1.1/go.mod h1:hnLbHMwcvSihnDhEfx2/BzKp2xb0Y+ErdfYcrs9tkJQ=
-golang.org/x/crypto v0.0.0-20180927165925-5295e8364332 h1:hvQVdF6P9DX4OiKA5tpehlG6JsgzmyQiThG7q5Bn3UQ=
-golang.org/x/crypto v0.0.0-20180927165925-5295e8364332/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
-golang.org/x/lint v0.0.0-20180702182130-06c8688daad7 h1:00BeQWmeaGazuOrq8Q5K5d3/cHaGuFrZzpaHBXfrsUA=
+golang.org/x/crypto v0.0.0-20181015023909-0c41d7ab0a0e h1:IzypfodbhbnViNUO/MEh0FzCUooG97cIGfdggUrUSyU=
+golang.org/x/crypto v0.0.0-20181015023909-0c41d7ab0a0e/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/lint v0.0.0-20180702182130-06c8688daad7/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
-golang.org/x/net v0.0.0-20180826012351-8a410e7b638d h1:g9qWBGx4puODJTMVyoPrpoxPFgVGd+z1DZwjfRu4d0I=
+golang.org/x/lint v0.0.0-20181011164241-5906bd5c48cd h1:cgsAvzdqkDKdI02tIvDjO225vDPHMDCgfKqx5KEVI7U=
+golang.org/x/lint v0.0.0-20181011164241-5906bd5c48cd/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
 golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181011144130-49bb7cea24b1 h1:Y/KGZSOdz/2r0WJ9Mkmz6NJBusp0kiNx1Cn82lzJQ6w=
+golang.org/x/net v0.0.0-20181011144130-49bb7cea24b1/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f h1:wMNYb4v58l5UBM7MYRLPG6ZhfOqbKu7X5eyFl8ZhKvA=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20180928133829-e4b3c5e90611 h1:O33LKL7WyJgjN9CvxfTIomjIClbd/Kq86/iipowHQU0=
-golang.org/x/sys v0.0.0-20180928133829-e4b3c5e90611/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181011152604-fa43e7bc11ba h1:nZJIJPGow0Kf9bU9QTc1U6OXbs/7Hu4e+cNv+hxH+Zc=
+golang.org/x/sys v0.0.0-20181011152604-fa43e7bc11ba/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/tools v0.0.0-20180828015842-6cd1fcedba52 h1:JG/0uqcGdTNgq7FdU+61l5Pdmb8putNZlXb65bJBROs=
diff --git a/vendor/vendor.json b/vendor/vendor.json
index 86df11be..af1a0148 100644
--- a/vendor/vendor.json
+++ b/vendor/vendor.json
@@ -6,7 +6,9 @@
 			"checksumSHA1": "CSPbwbyzqA6sfORicn4HFtIhF/c=",
 			"path": "github.com/davecgh/go-spew/spew",
 			"revision": "8991bc29aa16c548c550c7ff78260e27b9ab7c73",
-			"revisionTime": "2018-02-21T22:46:20Z"
+			"revisionTime": "2018-02-21T22:46:20Z",
+			"version": "v1.1",
+			"versionExact": "v1.1.1"
 		},
 		{
 			"checksumSHA1": "QeKwBtN2df+j+4stw3bQJ6yO4EY=",
@@ -15,12 +17,12 @@
 			"revisionTime": "2017-01-09T09:34:21Z"
 		},
 		{
-			"checksumSHA1": "Pyou8mceOASSFxc7GeXZuVdSMi0=",
+			"checksumSHA1": "mE9XW26JSpe4meBObM6J/Oeq0eg=",
 			"path": "github.com/golang/protobuf/proto",
-			"revision": "b4deda0973fb4c70b50d226b1af49f3da59f5265",
-			"revisionTime": "2018-04-30T18:52:41Z",
-			"version": "v1.1.0",
-			"versionExact": "v1.1.0"
+			"revision": "aa810b61a9c79d51363740d207bb46cf8e620ed5",
+			"revisionTime": "2018-08-14T21:14:27Z",
+			"version": "v1.2",
+			"versionExact": "v1.2.0"
 		},
 		{
 			"checksumSHA1": "WqeEgS7pqqkwK8mlrAZmDgtWJMY=",
@@ -31,19 +33,19 @@
 			"versionExact": "v1.1.5"
 		},
 		{
-			"checksumSHA1": "y/A5iuvwjytQE2CqVuphQRXR2nI=",
+			"checksumSHA1": "w5RcOnfv5YDr3j2bd1YydkPiZx4=",
 			"path": "github.com/mattn/go-isatty",
-			"revision": "0360b2af4f38e8d38c7fce2a9f4e702702d73a39",
-			"revisionTime": "2017-09-25T05:34:41Z",
-			"version": "v0.0.3",
-			"versionExact": "v0.0.3"
+			"revision": "6ca4dbf54d38eea1a992b3c722a76a5d1c4cb25c",
+			"revisionTime": "2017-11-07T05:05:31Z",
+			"version": "v0.0",
+			"versionExact": "v0.0.4"
 		},
 		{
 			"checksumSHA1": "c6pbpF7eowwO59phRTpF8cQ80Z0=",
 			"path": "github.com/stretchr/testify/assert",
 			"revision": "f35b8ab0b5a2cef36673838d662e249dd9c94686",
 			"revisionTime": "2018-05-06T18:05:49Z",
-			"version": "v1.2.2",
+			"version": "v1.2",
 			"versionExact": "v1.2.2"
 		},
 		{
@@ -51,15 +53,20 @@
 			"path": "github.com/ugorji/go/codec",
 			"revision": "b4c50a2b199d93b13dc15e78929cfb23bfdf21ab",
 			"revisionTime": "2018-04-07T10:07:33Z",
-			"version": "v1.1.1",
+			"version": "v1.1",
 			"versionExact": "v1.1.1"
 		},
 		{
-			"checksumSHA1": "9jjO5GjLa0XF/nfWihF02RoH4qc=",
-			"comment": "release-branch.go1.7",
+			"checksumSHA1": "GtamqiJoL7PGHsN454AoffBFMa8=",
 			"path": "golang.org/x/net/context",
-			"revision": "d4c55e66d8c3a2f3382d264b08e3e3454a66355a",
-			"revisionTime": "2016-10-18T08:54:36Z"
+			"revision": "49bb7cea24b1df9410e1712aa6433dae904ff66a",
+			"revisionTime": "2018-10-11T05:27:23Z"
+		},
+		{
+			"checksumSHA1": "SiJNkx+YGtq3Gtr6Ldu6OW83O+U=",
+			"path": "golang.org/x/sys/unix",
+			"revision": "fa43e7bc11baaae89f3f902b2b4d832b68234844",
+			"revisionTime": "2018-10-11T14:35:51Z"
 		},
 		{
 			"checksumSHA1": "P/k5ZGf0lEBgpKgkwy++F7K1PSg=",
@@ -74,7 +81,7 @@
 			"path": "gopkg.in/yaml.v2",
 			"revision": "5420a8b6744d3b0345ab293f6fcba19c978f1183",
 			"revisionTime": "2018-03-28T19:50:20Z",
-			"version": "v2.2.1",
+			"version": "v2.2",
 			"versionExact": "v2.2.1"
 		}
 	],

From cfa092f4f045d004b4c03d5b69af8bab7ed5fc1b Mon Sep 17 00:00:00 2001
From: Sergey Ponomarev <me@sergey-ponomarev.ru>
Date: Tue, 16 Oct 2018 03:48:41 +0300
Subject: [PATCH 082/105] Fix LoadHTML* tests (#1559)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Digging into the test code base I've found out that some of the tests for `LoadHTML*` methods are not reliable and efficient. They use timeouts to be sure that goroutine with the server has started. And even more, in old implementation, the server started only once – all the new instances silently failed due to the occupied network port.

Here is a short overview of the proposed changes:
- it's not necessary to rely on timeouts, the server starts listening synchronously and returns control when it is ready
- once the server is run, it's stopped after a test passes
- dry out http server setup
- magic with empty closure return is eliminated
- preserve router.RunTLS coverage with integration tests
---
 gin_integration_test.go |  26 ++++-
 gin_test.go             | 252 ++++++++++++++++++++++------------------
 2 files changed, 165 insertions(+), 113 deletions(-)

diff --git a/gin_integration_test.go b/gin_integration_test.go
index 12a943b0..038c8b7c 100644
--- a/gin_integration_test.go
+++ b/gin_integration_test.go
@@ -6,6 +6,7 @@ package gin
 
 import (
 	"bufio"
+	"crypto/tls"
 	"fmt"
 	"io/ioutil"
 	"net"
@@ -20,7 +21,14 @@ import (
 )
 
 func testRequest(t *testing.T, url string) {
-	resp, err := http.Get(url)
+	tr := &http.Transport{
+		TLSClientConfig: &tls.Config{
+			InsecureSkipVerify: true,
+		},
+	}
+	client := &http.Client{Transport: tr}
+
+	resp, err := client.Get(url)
 	assert.NoError(t, err)
 	defer resp.Body.Close()
 
@@ -45,6 +53,22 @@ func TestRunEmpty(t *testing.T) {
 	testRequest(t, "http://localhost:8080/example")
 }
 
+func TestRunTLS(t *testing.T) {
+	router := New()
+	go func() {
+		router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })
+
+		assert.NoError(t, router.RunTLS(":8443", "./testdata/certificate/cert.pem", "./testdata/certificate/key.pem"))
+	}()
+
+	// have to wait for the goroutine to start and run the server
+	// otherwise the main thread will complete
+	time.Sleep(5 * time.Millisecond)
+
+	assert.Error(t, router.RunTLS(":8443", "./testdata/certificate/cert.pem", "./testdata/certificate/key.pem"))
+	testRequest(t, "https://localhost:8443/example")
+}
+
 func TestRunEmptyWithEnv(t *testing.T) {
 	os.Setenv("PORT", "3123")
 	router := New()
diff --git a/gin_test.go b/gin_test.go
index 95b9cc16..353c9be1 100644
--- a/gin_test.go
+++ b/gin_test.go
@@ -10,6 +10,7 @@ import (
 	"html/template"
 	"io/ioutil"
 	"net/http"
+	"net/http/httptest"
 	"reflect"
 	"testing"
 	"time"
@@ -22,105 +23,105 @@ func formatAsDate(t time.Time) string {
 	return fmt.Sprintf("%d/%02d/%02d", year, month, day)
 }
 
-func setupHTMLFiles(t *testing.T, mode string, tls bool) func() {
-	go func() {
-		SetMode(mode)
-		router := New()
-		router.Delims("{[{", "}]}")
-		router.SetFuncMap(template.FuncMap{
-			"formatAsDate": formatAsDate,
+func setupHTMLFiles(t *testing.T, mode string, tls bool, loadMethod func(*Engine)) *httptest.Server {
+	SetMode(mode)
+	router := New()
+	router.Delims("{[{", "}]}")
+	router.SetFuncMap(template.FuncMap{
+		"formatAsDate": formatAsDate,
+	})
+	loadMethod(router)
+	router.GET("/test", func(c *Context) {
+		c.HTML(http.StatusOK, "hello.tmpl", map[string]string{"name": "world"})
+	})
+	router.GET("/raw", func(c *Context) {
+		c.HTML(http.StatusOK, "raw.tmpl", map[string]interface{}{
+			"now": time.Date(2017, 07, 01, 0, 0, 0, 0, time.UTC),
 		})
-		router.LoadHTMLFiles("./testdata/template/hello.tmpl", "./testdata/template/raw.tmpl")
-		router.GET("/test", func(c *Context) {
-			c.HTML(http.StatusOK, "hello.tmpl", map[string]string{"name": "world"})
-		})
-		router.GET("/raw", func(c *Context) {
-			c.HTML(http.StatusOK, "raw.tmpl", map[string]interface{}{
-				"now": time.Date(2017, 07, 01, 0, 0, 0, 0, time.UTC),
-			})
-		})
-		if tls {
-			// these files generated by `go run $GOROOT/src/crypto/tls/generate_cert.go --host 127.0.0.1`
-			router.RunTLS(":9999", "./testdata/certificate/cert.pem", "./testdata/certificate/key.pem")
-		} else {
-			router.Run(":8888")
-		}
-	}()
-	t.Log("waiting 1 second for server startup")
-	time.Sleep(1 * time.Second)
-	return func() {}
+	})
+
+	var ts *httptest.Server
+
+	if tls {
+		ts = httptest.NewTLSServer(router)
+	} else {
+		ts = httptest.NewServer(router)
+	}
+
+	return ts
 }
 
-func setupHTMLGlob(t *testing.T, mode string, tls bool) func() {
-	go func() {
-		SetMode(mode)
-		router := New()
-		router.Delims("{[{", "}]}")
-		router.SetFuncMap(template.FuncMap{
-			"formatAsDate": formatAsDate,
-		})
-		router.LoadHTMLGlob("./testdata/template/*")
-		router.GET("/test", func(c *Context) {
-			c.HTML(http.StatusOK, "hello.tmpl", map[string]string{"name": "world"})
-		})
-		router.GET("/raw", func(c *Context) {
-			c.HTML(http.StatusOK, "raw.tmpl", map[string]interface{}{
-				"now": time.Date(2017, 07, 01, 0, 0, 0, 0, time.UTC),
-			})
-		})
-		if tls {
-			// these files generated by `go run $GOROOT/src/crypto/tls/generate_cert.go --host 127.0.0.1`
-			router.RunTLS(":9999", "./testdata/certificate/cert.pem", "./testdata/certificate/key.pem")
-		} else {
-			router.Run(":8888")
-		}
-	}()
-	t.Log("waiting 1 second for server startup")
-	time.Sleep(1 * time.Second)
-	return func() {}
-}
+func TestLoadHTMLGlobDebugMode(t *testing.T) {
+	ts := setupHTMLFiles(
+		t,
+		DebugMode,
+		false,
+		func(router *Engine) {
+			router.LoadHTMLGlob("./testdata/template/*")
+		},
+	)
+	defer ts.Close()
 
-func TestLoadHTMLGlob(t *testing.T) {
-	td := setupHTMLGlob(t, DebugMode, false)
-	res, err := http.Get("http://127.0.0.1:8888/test")
+	res, err := http.Get(fmt.Sprintf("%s/test", ts.URL))
 	if err != nil {
 		fmt.Println(err)
 	}
 
 	resp, _ := ioutil.ReadAll(res.Body)
 	assert.Equal(t, "<h1>Hello world</h1>", string(resp))
-
-	td()
 }
 
-func TestLoadHTMLGlob2(t *testing.T) {
-	td := setupHTMLGlob(t, TestMode, false)
-	res, err := http.Get("http://127.0.0.1:8888/test")
+func TestLoadHTMLGlobTestMode(t *testing.T) {
+	ts := setupHTMLFiles(
+		t,
+		TestMode,
+		false,
+		func(router *Engine) {
+			router.LoadHTMLGlob("./testdata/template/*")
+		},
+	)
+	defer ts.Close()
+
+	res, err := http.Get(fmt.Sprintf("%s/test", ts.URL))
 	if err != nil {
 		fmt.Println(err)
 	}
 
 	resp, _ := ioutil.ReadAll(res.Body)
 	assert.Equal(t, "<h1>Hello world</h1>", string(resp))
-
-	td()
 }
 
-func TestLoadHTMLGlob3(t *testing.T) {
-	td := setupHTMLGlob(t, ReleaseMode, false)
-	res, err := http.Get("http://127.0.0.1:8888/test")
+func TestLoadHTMLGlobReleaseMode(t *testing.T) {
+	ts := setupHTMLFiles(
+		t,
+		ReleaseMode,
+		false,
+		func(router *Engine) {
+			router.LoadHTMLGlob("./testdata/template/*")
+		},
+	)
+	defer ts.Close()
+
+	res, err := http.Get(fmt.Sprintf("%s/test", ts.URL))
 	if err != nil {
 		fmt.Println(err)
 	}
 
 	resp, _ := ioutil.ReadAll(res.Body)
 	assert.Equal(t, "<h1>Hello world</h1>", string(resp))
-
-	td()
 }
 
 func TestLoadHTMLGlobUsingTLS(t *testing.T) {
-	td := setupHTMLGlob(t, DebugMode, true)
+	ts := setupHTMLFiles(
+		t,
+		DebugMode,
+		true,
+		func(router *Engine) {
+			router.LoadHTMLGlob("./testdata/template/*")
+		},
+	)
+	defer ts.Close()
+
 	// Use InsecureSkipVerify for avoiding `x509: certificate signed by unknown authority` error
 	tr := &http.Transport{
 		TLSClientConfig: &tls.Config{
@@ -128,29 +129,33 @@ func TestLoadHTMLGlobUsingTLS(t *testing.T) {
 		},
 	}
 	client := &http.Client{Transport: tr}
-	res, err := client.Get("https://127.0.0.1:9999/test")
+	res, err := client.Get(fmt.Sprintf("%s/test", ts.URL))
 	if err != nil {
 		fmt.Println(err)
 	}
 
 	resp, _ := ioutil.ReadAll(res.Body)
 	assert.Equal(t, "<h1>Hello world</h1>", string(resp))
-
-	td()
 }
 
 func TestLoadHTMLGlobFromFuncMap(t *testing.T) {
-	time.Now()
-	td := setupHTMLGlob(t, DebugMode, false)
-	res, err := http.Get("http://127.0.0.1:8888/raw")
+	ts := setupHTMLFiles(
+		t,
+		DebugMode,
+		false,
+		func(router *Engine) {
+			router.LoadHTMLGlob("./testdata/template/*")
+		},
+	)
+	defer ts.Close()
+
+	res, err := http.Get(fmt.Sprintf("%s/raw", ts.URL))
 	if err != nil {
 		fmt.Println(err)
 	}
 
 	resp, _ := ioutil.ReadAll(res.Body)
 	assert.Equal(t, "Date: 2017/07/01\n", string(resp))
-
-	td()
 }
 
 func init() {
@@ -164,59 +169,77 @@ func TestCreateEngine(t *testing.T) {
 	assert.Empty(t, router.Handlers)
 }
 
-// func TestLoadHTMLDebugMode(t *testing.T) {
-// 	router := New()
-// 	SetMode(DebugMode)
-// 	router.LoadHTMLGlob("*.testtmpl")
-// 	r := router.HTMLRender.(render.HTMLDebug)
-// 	assert.Empty(t, r.Files)
-// 	assert.Equal(t, "*.testtmpl", r.Glob)
-//
-// 	router.LoadHTMLFiles("index.html.testtmpl", "login.html.testtmpl")
-// 	r = router.HTMLRender.(render.HTMLDebug)
-// 	assert.Empty(t, r.Glob)
-// 	assert.Equal(t, []string{"index.html", "login.html"}, r.Files)
-// 	SetMode(TestMode)
-// }
+func TestLoadHTMLFilesTestMode(t *testing.T) {
+	ts := setupHTMLFiles(
+		t,
+		TestMode,
+		false,
+		func(router *Engine) {
+			router.LoadHTMLFiles("./testdata/template/hello.tmpl", "./testdata/template/raw.tmpl")
+		},
+	)
+	defer ts.Close()
 
-func TestLoadHTMLFiles(t *testing.T) {
-	td := setupHTMLFiles(t, TestMode, false)
-	res, err := http.Get("http://127.0.0.1:8888/test")
+	res, err := http.Get(fmt.Sprintf("%s/test", ts.URL))
 	if err != nil {
 		fmt.Println(err)
 	}
 
 	resp, _ := ioutil.ReadAll(res.Body)
 	assert.Equal(t, "<h1>Hello world</h1>", string(resp))
-	td()
 }
 
-func TestLoadHTMLFiles2(t *testing.T) {
-	td := setupHTMLFiles(t, DebugMode, false)
-	res, err := http.Get("http://127.0.0.1:8888/test")
+func TestLoadHTMLFilesDebugMode(t *testing.T) {
+	ts := setupHTMLFiles(
+		t,
+		DebugMode,
+		false,
+		func(router *Engine) {
+			router.LoadHTMLFiles("./testdata/template/hello.tmpl", "./testdata/template/raw.tmpl")
+		},
+	)
+	defer ts.Close()
+
+	res, err := http.Get(fmt.Sprintf("%s/test", ts.URL))
 	if err != nil {
 		fmt.Println(err)
 	}
 
 	resp, _ := ioutil.ReadAll(res.Body)
 	assert.Equal(t, "<h1>Hello world</h1>", string(resp))
-	td()
 }
 
-func TestLoadHTMLFiles3(t *testing.T) {
-	td := setupHTMLFiles(t, ReleaseMode, false)
-	res, err := http.Get("http://127.0.0.1:8888/test")
+func TestLoadHTMLFilesReleaseMode(t *testing.T) {
+	ts := setupHTMLFiles(
+		t,
+		ReleaseMode,
+		false,
+		func(router *Engine) {
+			router.LoadHTMLFiles("./testdata/template/hello.tmpl", "./testdata/template/raw.tmpl")
+		},
+	)
+	defer ts.Close()
+
+	res, err := http.Get(fmt.Sprintf("%s/test", ts.URL))
 	if err != nil {
 		fmt.Println(err)
 	}
 
 	resp, _ := ioutil.ReadAll(res.Body)
 	assert.Equal(t, "<h1>Hello world</h1>", string(resp))
-	td()
 }
 
 func TestLoadHTMLFilesUsingTLS(t *testing.T) {
-	td := setupHTMLFiles(t, TestMode, true)
+	ts := setupHTMLFiles(
+		t,
+		TestMode,
+		true,
+		func(router *Engine) {
+			router.LoadHTMLFiles("./testdata/template/hello.tmpl", "./testdata/template/raw.tmpl")
+		},
+	)
+	defer ts.Close()
+
 	// Use InsecureSkipVerify for avoiding `x509: certificate signed by unknown authority` error
 	tr := &http.Transport{
 		TLSClientConfig: &tls.Config{
@@ -224,28 +247,33 @@ func TestLoadHTMLFilesUsingTLS(t *testing.T) {
 		},
 	}
 	client := &http.Client{Transport: tr}
-	res, err := client.Get("https://127.0.0.1:9999/test")
+	res, err := client.Get(fmt.Sprintf("%s/test", ts.URL))
 	if err != nil {
 		fmt.Println(err)
 	}
 
 	resp, _ := ioutil.ReadAll(res.Body)
 	assert.Equal(t, "<h1>Hello world</h1>", string(resp))
-	td()
 }
 
 func TestLoadHTMLFilesFuncMap(t *testing.T) {
-	time.Now()
-	td := setupHTMLFiles(t, TestMode, false)
-	res, err := http.Get("http://127.0.0.1:8888/raw")
+	ts := setupHTMLFiles(
+		t,
+		TestMode,
+		false,
+		func(router *Engine) {
+			router.LoadHTMLFiles("./testdata/template/hello.tmpl", "./testdata/template/raw.tmpl")
+		},
+	)
+	defer ts.Close()
+
+	res, err := http.Get(fmt.Sprintf("%s/raw", ts.URL))
 	if err != nil {
 		fmt.Println(err)
 	}
 
 	resp, _ := ioutil.ReadAll(res.Body)
 	assert.Equal(t, "Date: 2017/07/01\n", string(resp))
-
-	td()
 }
 
 func TestAddRoute(t *testing.T) {

From 333bac5f94a1bd3237996fbcae6e78fee8dbc5c6 Mon Sep 17 00:00:00 2001
From: "A. F" <hello@clivern.com>
Date: Wed, 17 Oct 2018 09:40:57 +0200
Subject: [PATCH 083/105] add example to set and get cookies (#1599)

---
 README.md | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/README.md b/README.md
index 95bd3204..5c14c440 100644
--- a/README.md
+++ b/README.md
@@ -60,6 +60,7 @@ Gin is a web framework written in Go (Golang). It features a martini-like API wi
     - [Try to bind body into different structs](#try-to-bind-body-into-different-structs)
     - [http2 server push](#http2-server-push)
     - [Define format for the log of routes](#define-format-for-the-log-of-routes)
+    - [Set and get a cookie](#set-and-get-a-cookie)
 - [Testing](#testing)
 - [Users](#users)
 
@@ -1880,6 +1881,35 @@ func main() {
 }
 ```
 
+### Set and get a cookie
+
+```go
+import (
+    "fmt"
+
+    "github.com/gin-gonic/gin"
+)
+
+func main() {
+
+    router := gin.Default()
+
+    router.GET("/cookie", func(c *gin.Context) {
+
+        cookie, err := c.Cookie("gin_cookie")
+
+        if err != nil {
+            cookie = "NotSet"
+            c.SetCookie("gin_cookie", "test", 3600, "/", "localhost", false, true)
+        }
+
+        fmt.Printf("Cookie value: %s \n", cookie)
+    })
+
+    router.Run()
+}
+```
+
 
 ## Testing
 

From a1a32562de0fe61b17aab42cd4fa7847ae814cb8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Fri, 19 Oct 2018 11:06:23 +0800
Subject: [PATCH 084/105] add gin user - photoprism (#1601)

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index 5c14c440..1b5fb493 100644
--- a/README.md
+++ b/README.md
@@ -1964,3 +1964,4 @@ Awesome project lists using [Gin](https://github.com/gin-gonic/gin) web framewor
 * [drone](https://github.com/drone/drone): Drone is a Continuous Delivery platform built on Docker, written in Go.
 * [gorush](https://github.com/appleboy/gorush): A push notification server written in Go.
 * [fnproject](https://github.com/fnproject/fn): The container native, cloud agnostic serverless platform.
+* [photoprism](https://github.com/photoprism/photoprism): Personal photo management powered by Go and Google TensorFlow.

From dbc330b804052d7db230729c15d041cbb775e7b6 Mon Sep 17 00:00:00 2001
From: Ismail Gjevori <isgjevori@protonmail.com>
Date: Mon, 22 Oct 2018 17:01:14 +0200
Subject: [PATCH 085/105] Pass MaxMultipartMemory when FormFile is called
 (#1600)

When `gin.Context.FormFile("...")` is called the `engine.MaxMultipartMemory` is never used. This PR makes sure that the `MaxMultipartMemory` is passed and removes 2 calls to `http.Request.ParseForm` since they are called from `http.Request.ParseMultipartForm`
---
 context.go      |  7 +++++--
 context_test.go | 13 +++++++++++++
 2 files changed, 18 insertions(+), 2 deletions(-)

diff --git a/context.go b/context.go
index 809902a3..c8a59bb0 100644
--- a/context.go
+++ b/context.go
@@ -414,7 +414,6 @@ func (c *Context) PostFormArray(key string) []string {
 // a boolean value whether at least one value exists for the given key.
 func (c *Context) GetPostFormArray(key string) ([]string, bool) {
 	req := c.Request
-	req.ParseForm()
 	req.ParseMultipartForm(c.engine.MaxMultipartMemory)
 	if values := req.PostForm[key]; len(values) > 0 {
 		return values, true
@@ -437,7 +436,6 @@ func (c *Context) PostFormMap(key string) map[string]string {
 // whether at least one value exists for the given key.
 func (c *Context) GetPostFormMap(key string) (map[string]string, bool) {
 	req := c.Request
-	req.ParseForm()
 	req.ParseMultipartForm(c.engine.MaxMultipartMemory)
 	dicts, exist := c.get(req.PostForm, key)
 
@@ -465,6 +463,11 @@ func (c *Context) get(m map[string][]string, key string) (map[string]string, boo
 
 // FormFile returns the first file for the provided form key.
 func (c *Context) FormFile(name string) (*multipart.FileHeader, error) {
+	if c.Request.MultipartForm == nil {
+		if err := c.Request.ParseMultipartForm(c.engine.MaxMultipartMemory); err != nil {
+			return nil, err
+		}
+	}
 	_, fh, err := c.Request.FormFile(name)
 	return fh, err
 }
diff --git a/context_test.go b/context_test.go
index 2e972f18..fb492e02 100644
--- a/context_test.go
+++ b/context_test.go
@@ -84,6 +84,19 @@ func TestContextFormFile(t *testing.T) {
 	assert.NoError(t, c.SaveUploadedFile(f, "test"))
 }
 
+func TestContextFormFileFailed(t *testing.T) {
+	buf := new(bytes.Buffer)
+	mw := multipart.NewWriter(buf)
+	mw.Close()
+	c, _ := CreateTestContext(httptest.NewRecorder())
+	c.Request, _ = http.NewRequest("POST", "/", nil)
+	c.Request.Header.Set("Content-Type", mw.FormDataContentType())
+	c.engine.MaxMultipartMemory = 8 << 20
+	f, err := c.FormFile("file")
+	assert.Error(t, err)
+	assert.Nil(t, f)
+}
+
 func TestContextMultipartForm(t *testing.T) {
 	buf := new(bytes.Buffer)
 	mw := multipart.NewWriter(buf)

From c65e5efc9a0ae6666819cda8e9a86db4d3d19833 Mon Sep 17 00:00:00 2001
From: Thomas Schaffer <loopfz@gmail.com>
Date: Tue, 23 Oct 2018 04:56:33 +0200
Subject: [PATCH 086/105] Expose HandlerFunc in RouteInfos (#1272)

---
 gin.go | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/gin.go b/gin.go
index 92c24ba2..440519f5 100644
--- a/gin.go
+++ b/gin.go
@@ -38,9 +38,10 @@ func (c HandlersChain) Last() HandlerFunc {
 
 // RouteInfo represents a request route's specification which contains method and path and its handler.
 type RouteInfo struct {
-	Method  string
-	Path    string
-	Handler string
+	Method      string
+	Path        string
+	Handler     string
+	HandlerFunc HandlerFunc
 }
 
 // RoutesInfo defines a RouteInfo array.
@@ -266,10 +267,12 @@ func (engine *Engine) Routes() (routes RoutesInfo) {
 func iterate(path, method string, routes RoutesInfo, root *node) RoutesInfo {
 	path += root.path
 	if len(root.handlers) > 0 {
+		handlerFunc := root.handlers.Last()
 		routes = append(routes, RouteInfo{
-			Method:  method,
-			Path:    path,
-			Handler: nameOfFunction(root.handlers.Last()),
+			Method:      method,
+			Path:        path,
+			Handler:     nameOfFunction(handlerFunc),
+			HandlerFunc: handlerFunc,
 		})
 	}
 	for _, child := range root.children {

From 8e9619767c12607afcb086a5e9c791eda2b9e116 Mon Sep 17 00:00:00 2001
From: forging2012 <forging2012@users.noreply.github.com>
Date: Wed, 31 Oct 2018 20:19:58 +0800
Subject: [PATCH 087/105] FIX r.LoadHTMLGlob("/path/to/templates") (#1616)

FIX r.LoadHTMLGlob("/path/to/templates")) to r.LoadHTMLGlob("/path/to/templates")
---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 1b5fb493..ce413325 100644
--- a/README.md
+++ b/README.md
@@ -1160,7 +1160,7 @@ You may use custom delims
 ```go
 	r := gin.Default()
 	r.Delims("{[{", "}]}")
-	r.LoadHTMLGlob("/path/to/templates"))
+	r.LoadHTMLGlob("/path/to/templates")
 ```
 
 #### Custom Template Funcs

From 8fb21a8beff46febac15894200e381473889f0e6 Mon Sep 17 00:00:00 2001
From: "root@andrea:~#" <crypto.andrea@protonmail.ch>
Date: Thu, 1 Nov 2018 01:30:19 -0600
Subject: [PATCH 088/105] Added some comments to avoid having golint warnings
 (#1619)

The following comments to vars, conts and method were added to pass  `golinter` with 100%.

![captura de pantalla 2018-10-31 a la s 15 23 37](https://user-images.githubusercontent.com/10160626/47819725-faba3780-dd20-11e8-978c-1b3ab7de26ed.png)
---
 errors.go | 6 ++++--
 mode.go   | 4 +++-
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/errors.go b/errors.go
index 477b9d58..ab13ca61 100644
--- a/errors.go
+++ b/errors.go
@@ -24,9 +24,10 @@ const (
 	ErrorTypePrivate ErrorType = 1 << 0
 	// ErrorTypePublic indicates a public error.
 	ErrorTypePublic ErrorType = 1 << 1
-	// ErrorTypeAny indicates other any error.
+	// ErrorTypeAny indicates any other error.
 	ErrorTypeAny ErrorType = 1<<64 - 1
-	ErrorTypeNu            = 2
+	// ErrorTypeNu indicates any other error.
+	ErrorTypeNu = 2
 )
 
 // Error represents a error's specification.
@@ -52,6 +53,7 @@ func (msg *Error) SetMeta(data interface{}) *Error {
 	return msg
 }
 
+// JSON creates a properly formated JSON
 func (msg *Error) JSON() interface{} {
 	json := H{}
 	if msg.Meta != nil {
diff --git a/mode.go b/mode.go
index 7cb0143a..6a696329 100644
--- a/mode.go
+++ b/mode.go
@@ -28,7 +28,7 @@ const (
 	testCode
 )
 
-// DefaultWriter is the default io.Writer used the Gin for debug output and
+// DefaultWriter is the default io.Writer used by Gin for debug output and
 // middleware output like Logger() or Recovery().
 // Note that both Logger and Recovery provides custom ways to configure their
 // output io.Writer.
@@ -36,6 +36,8 @@ const (
 // 		import "github.com/mattn/go-colorable"
 // 		gin.DefaultWriter = colorable.NewColorableStdout()
 var DefaultWriter io.Writer = os.Stdout
+
+// DefaultErrorWriter is the default io.Writer used by Gin to debug errors
 var DefaultErrorWriter io.Writer = os.Stderr
 
 var ginMode = debugCode

From 6f7fe487b38baec254343376df603adecd201f10 Mon Sep 17 00:00:00 2001
From: Barnabus <jbampton@users.noreply.github.com>
Date: Thu, 1 Nov 2018 18:05:40 +1000
Subject: [PATCH 089/105] Change HTML input tags to use HTML5 syntax. (#1617)

In XHTML, the <input> tag must be properly closed, like this `<input />`.  In HTML5 the `<input>` tag has no ending slash.  https://www.w3schools.com/tags/tag_input.asp
---
 README.md                                                 | 8 ++++----
 .../realtime-advanced/resources/room_login.templ.html     | 8 ++++----
 examples/realtime-chat/template.go                        | 6 +++---
 3 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/README.md b/README.md
index ce413325..8c2c2c5b 100644
--- a/README.md
+++ b/README.md
@@ -824,12 +824,12 @@ form.html
 <form action="/" method="POST">
     <p>Check some colors</p>
     <label for="red">Red</label>
-    <input type="checkbox" name="colors[]" value="red" id="red" />
+    <input type="checkbox" name="colors[]" value="red" id="red">
     <label for="green">Green</label>
-    <input type="checkbox" name="colors[]" value="green" id="green" />
+    <input type="checkbox" name="colors[]" value="green" id="green">
     <label for="blue">Blue</label>
-    <input type="checkbox" name="colors[]" value="blue" id="blue" />
-    <input type="submit" />
+    <input type="checkbox" name="colors[]" value="blue" id="blue">
+    <input type="submit">
 </form>
 ```
 
diff --git a/examples/realtime-advanced/resources/room_login.templ.html b/examples/realtime-advanced/resources/room_login.templ.html
index 27dac387..5fb2b334 100644
--- a/examples/realtime-advanced/resources/room_login.templ.html
+++ b/examples/realtime-advanced/resources/room_login.templ.html
@@ -79,19 +79,19 @@
                                 <label class="sr-only" for="chat-message">Message</label>
                                 <div class="input-group">
                                     <div class="input-group-addon">{{.nick}}</div>
-                                    <input type="text" name="message" id="chat-message" class="form-control" placeholder="a message" value="" />
+                                    <input type="text" name="message" id="chat-message" class="form-control" placeholder="a message" value="">
                                 </div>
                             </div>
-                            <input type="submit" class="btn btn-primary" value="Send" />
+                            <input type="submit" class="btn btn-primary" value="Send">
                         </form>
                         {{else}}
                         <form action="" method="get" class="form-inline">
                             <legend>Join the SSE real-time chat</legend>
                             <div class="form-group">
-                                <input value='' name="nick" id="nick" placeholder="Your Name" type="text" class="form-control" />
+                                <input value='' name="nick" id="nick" placeholder="Your Name" type="text" class="form-control">
                             </div>
                             <div class="form-group text-center">
-                                <input type="submit" class="btn btn-success btn-login-submit" value="Join" />
+                                <input type="submit" class="btn btn-success btn-login-submit" value="Join">
                             </div>
                         </form>
                         {{end}}
diff --git a/examples/realtime-chat/template.go b/examples/realtime-chat/template.go
index b9024de6..4190251d 100644
--- a/examples/realtime-chat/template.go
+++ b/examples/realtime-chat/template.go
@@ -35,9 +35,9 @@ var html = template.Must(template.New("chat_room").Parse(`
     <h1>Welcome to {{.roomid}} room</h1>
     <div id="messages"></div>
     <form id="myForm" action="/room/{{.roomid}}" method="post"> 
-    User: <input id="user_form" name="user" value="{{.userid}}"></input> 
-    Message: <input id="message_form" name="message"></input> 
-    <input type="submit" value="Submit" /> 
+    User: <input id="user_form" name="user" value="{{.userid}}">
+    Message: <input id="message_form" name="message">
+    <input type="submit" value="Submit"> 
     </form>
 </body>
 </html>

From 6be9b5437b0c1092a94800c449988699a24b3f51 Mon Sep 17 00:00:00 2001
From: Barnabus <jbampton@users.noreply.github.com>
Date: Thu, 1 Nov 2018 23:48:26 +1000
Subject: [PATCH 090/105] Change HTML link tags to use HTML5 syntax. (#1621)

The `<link>` element is an empty element, it contains attributes only. In HTML5 the `<link>` tag has no end tag. In XHTML the `<link>` tag must be properly closed.
---
 examples/realtime-advanced/resources/room_login.templ.html | 2 +-
 examples/realtime-chat/template.go                         | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/examples/realtime-advanced/resources/room_login.templ.html b/examples/realtime-advanced/resources/room_login.templ.html
index 5fb2b334..d4991d8d 100644
--- a/examples/realtime-advanced/resources/room_login.templ.html
+++ b/examples/realtime-advanced/resources/room_login.templ.html
@@ -20,7 +20,7 @@
         <!-- Latest compiled and minified JavaScript -->
         <script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.4/js/bootstrap.min.js"></script>
         <!-- Primjs -->
-        <link href="/static/prismjs.min.css" rel="stylesheet" />
+        <link href="/static/prismjs.min.css" rel="stylesheet">
 
         <script type="text/javascript">
             $(document).ready(function() { 
diff --git a/examples/realtime-chat/template.go b/examples/realtime-chat/template.go
index 4190251d..cc1ab9bc 100644
--- a/examples/realtime-chat/template.go
+++ b/examples/realtime-chat/template.go
@@ -6,7 +6,7 @@ var html = template.Must(template.New("chat_room").Parse(`
 <html> 
 <head> 
     <title>{{.roomid}}</title>
-    <link rel="stylesheet" type="text/css" href="http://meyerweb.com/eric/tools/css/reset/reset.css"/>
+    <link rel="stylesheet" type="text/css" href="http://meyerweb.com/eric/tools/css/reset/reset.css">
     <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.7/jquery.js"></script> 
     <script src="http://malsup.github.com/jquery.form.js"></script> 
     <script> 

From b524e29442c4948052be887570b4bced28682e6b Mon Sep 17 00:00:00 2001
From: chenyang929 <chenyang929code@gmail.com>
Date: Thu, 1 Nov 2018 22:44:49 +0800
Subject: [PATCH 091/105] Update README.md (#1620)

Missing the right colon
---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 8c2c2c5b..ba2dd578 100644
--- a/README.md
+++ b/README.md
@@ -1022,7 +1022,7 @@ func main() {
 	})
 	
 	// listen and serve on 0.0.0.0:8080
-	r.Run(":8080)
+	r.Run(":8080")
 }
 ```
 

From f83cdb357e985369231632e39ea6df8639a578e1 Mon Sep 17 00:00:00 2001
From: Barnabus <jbampton@users.noreply.github.com>
Date: Mon, 5 Nov 2018 11:13:17 +1000
Subject: [PATCH 092/105] Fix typos (#1625)

---
 docs/how-to-build-an-effective-middleware.md           |  4 ++--
 .../realtime-advanced/resources/room_login.templ.html  |  4 ++--
 ginS/gins.go                                           | 10 +++++-----
 3 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/docs/how-to-build-an-effective-middleware.md b/docs/how-to-build-an-effective-middleware.md
index db04428c..568d5720 100644
--- a/docs/how-to-build-an-effective-middleware.md
+++ b/docs/how-to-build-an-effective-middleware.md
@@ -4,9 +4,9 @@
 
 The middleware has two parts:
 
-  - part one is what is executed once, when you initalize your middleware. That's where you set up all the global objects, logicals etc. Everything that happens one per application lifetime.
+  - part one is what is executed once, when you initialize your middleware. That's where you set up all the global objects, logicals etc. Everything that happens one per application lifetime.
 
-  - part two is what executes on every request. For example, a database middleware you simply inject your "global" database object into the context. Once it's inside the context, you can retrieve it from within other middlewares and your handler furnction.
+  - part two is what executes on every request. For example, a database middleware you simply inject your "global" database object into the context. Once it's inside the context, you can retrieve it from within other middlewares and your handler function.
 
 ```go
 func funcName(params string) gin.HandlerFunc {
diff --git a/examples/realtime-advanced/resources/room_login.templ.html b/examples/realtime-advanced/resources/room_login.templ.html
index d4991d8d..56153488 100644
--- a/examples/realtime-advanced/resources/room_login.templ.html
+++ b/examples/realtime-advanced/resources/room_login.templ.html
@@ -49,7 +49,7 @@
             <li><a href="http://www.w3.org/TR/2009/WD-eventsource-20091029/">W3 Standard</a></li>
             <li><a href="http://caniuse.com/#feat=eventsource">Browser Support</a></li>
             <li><a href="http://gin-gonic.github.io/gin/">Gin Framework</a></li>
-            <li><a href="https://github.com/gin-gonic/gin/tree/develop/examples/realtime-advanced">Github</a></li>
+            <li><a href="https://github.com/gin-gonic/gin/tree/develop/examples/realtime-advanced">GitHub</a></li>
           </ul>
         </div><!-- /.nav-collapse -->
       </div><!-- /.container -->
@@ -59,7 +59,7 @@
             <div class="container">
                 <h1>Server-Sent Events in Go</h1>
                 <p>Server-sent events (SSE) is a technology where a browser receives automatic updates from a server via HTTP connection. It is not websockets. <a href="http://www.html5rocks.com/en/tutorials/eventsource/basics/">Learn more.</a></p>
-                <p>The chat and the charts data is provided in realtime using the SSE implemention of <a href="https://github.com/gin-gonic/gin/blob/15b0c49da556d58a3d934b86e3aa552ff224026d/examples/realtime-chat/main.go#L23-L32">Gin Framework</a>.</p>
+                <p>The chat and the charts data is provided in realtime using the SSE implementation of <a href="https://github.com/gin-gonic/gin/blob/15b0c49da556d58a3d934b86e3aa552ff224026d/examples/realtime-chat/main.go#L23-L32">Gin Framework</a>.</p>
                 <div class="row">
                     <div class="col-md-8">
                         <div id="chat-scroll" style="overflow-y:scroll; overflow-x:scroll; height:290px">
diff --git a/ginS/gins.go b/ginS/gins.go
index 04cf131c..0f08645a 100644
--- a/ginS/gins.go
+++ b/ginS/gins.go
@@ -47,8 +47,8 @@ func NoMethod(handlers ...gin.HandlerFunc) {
 	engine().NoMethod(handlers...)
 }
 
-// Group creates a new router group. You should add all the routes that have common middlwares or the same path prefix.
-// For example, all the routes that use a common middlware for authorization could be grouped.
+// Group creates a new router group. You should add all the routes that have common middlewares or the same path prefix.
+// For example, all the routes that use a common middleware for authorization could be grouped.
 func Group(relativePath string, handlers ...gin.HandlerFunc) *gin.RouterGroup {
 	return engine().Group(relativePath, handlers...)
 }
@@ -127,21 +127,21 @@ func Use(middlewares ...gin.HandlerFunc) gin.IRoutes {
 
 // Run : The router is attached to a http.Server and starts listening and serving HTTP requests.
 // It is a shortcut for http.ListenAndServe(addr, router)
-// Note: this method will block the calling goroutine undefinitelly unless an error happens.
+// Note: this method will block the calling goroutine indefinitely unless an error happens.
 func Run(addr ...string) (err error) {
 	return engine().Run(addr...)
 }
 
 // RunTLS : The router is attached to a http.Server and starts listening and serving HTTPS requests.
 // It is a shortcut for http.ListenAndServeTLS(addr, certFile, keyFile, router)
-// Note: this method will block the calling goroutine undefinitelly unless an error happens.
+// Note: this method will block the calling goroutine indefinitely unless an error happens.
 func RunTLS(addr, certFile, keyFile string) (err error) {
 	return engine().RunTLS(addr, certFile, keyFile)
 }
 
 // RunUnix : The router is attached to a http.Server and starts listening and serving HTTP requests
 // through the specified unix socket (ie. a file)
-// Note: this method will block the calling goroutine undefinitelly unless an error happens.
+// Note: this method will block the calling goroutine indefinitely unless an error happens.
 func RunUnix(file string) (err error) {
 	return engine().RunUnix(file)
 }

From af23ac2256c4cdd638ed57570f645d1ab292a13c Mon Sep 17 00:00:00 2001
From: Barnabus <jbampton@users.noreply.github.com>
Date: Mon, 5 Nov 2018 11:35:24 +1000
Subject: [PATCH 093/105] Remove type attribute from HTML script tag to be
 consistent with the rest of the codebase. (#1623)

The `<script>` tag is used to define a client-side script (JavaScript).  The "type" attribute is required in HTML 4, but optional in HTML5.
---
 examples/realtime-advanced/resources/room_login.templ.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/realtime-advanced/resources/room_login.templ.html b/examples/realtime-advanced/resources/room_login.templ.html
index 56153488..a2761080 100644
--- a/examples/realtime-advanced/resources/room_login.templ.html
+++ b/examples/realtime-advanced/resources/room_login.templ.html
@@ -22,7 +22,7 @@
         <!-- Primjs -->
         <link href="/static/prismjs.min.css" rel="stylesheet">
 
-        <script type="text/javascript">
+        <script>
             $(document).ready(function() { 
               StartRealtime({{.roomid}}, {{.timestamp}});
             });

From 4f488aca552812f572d3135693fd26617c2a9350 Mon Sep 17 00:00:00 2001
From: Barnabus <jbampton@users.noreply.github.com>
Date: Mon, 5 Nov 2018 11:44:00 +1000
Subject: [PATCH 094/105] Change the `doctype` to be lowercase to be consistent
 with the rest of the code base. (#1624)

---
 examples/realtime-advanced/resources/room_login.templ.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/realtime-advanced/resources/room_login.templ.html b/examples/realtime-advanced/resources/room_login.templ.html
index a2761080..905c012f 100644
--- a/examples/realtime-advanced/resources/room_login.templ.html
+++ b/examples/realtime-advanced/resources/room_login.templ.html
@@ -1,4 +1,4 @@
-<!DOCTYPE html>
+<!doctype html>
 <html lang="en">
     <head>
         <meta charset="utf-8">

From 7a374f9a47b150ad2ef601c3f83cf8e0bf026268 Mon Sep 17 00:00:00 2001
From: Barnabus <jbampton@users.noreply.github.com>
Date: Mon, 5 Nov 2018 16:17:04 +1000
Subject: [PATCH 095/105] Fix typos (#1626)

---
 binding/binding.go        | 2 +-
 binding/protobuf.go       | 2 +-
 context.go                | 2 +-
 examples/grpc/gin/main.go | 2 +-
 logger.go                 | 2 +-
 routergroup.go            | 4 ++--
 tree_test.go              | 2 +-
 7 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/binding/binding.go b/binding/binding.go
index 3a2aad9c..ecbce2fa 100644
--- a/binding/binding.go
+++ b/binding/binding.go
@@ -37,7 +37,7 @@ type BindingBody interface {
 
 // StructValidator is the minimal interface which needs to be implemented in
 // order for it to be used as the validator engine for ensuring the correctness
-// of the reqest. Gin provides a default implementation for this using
+// of the request. Gin provides a default implementation for this using
 // https://github.com/go-playground/validator/tree/v8.18.2.
 type StructValidator interface {
 	// ValidateStruct can receive any kind of type and it should never panic, even if the configuration is not right.
diff --git a/binding/protobuf.go b/binding/protobuf.go
index 540e9c1f..f9ece928 100644
--- a/binding/protobuf.go
+++ b/binding/protobuf.go
@@ -29,7 +29,7 @@ func (protobufBinding) BindBody(body []byte, obj interface{}) error {
 	if err := proto.Unmarshal(body, obj.(proto.Message)); err != nil {
 		return err
 	}
-	// Here it's same to return validate(obj), but util now we cann't add
+	// Here it's same to return validate(obj), but util now we can't add
 	// `binding:""` to the struct which automatically generate by gen-proto
 	return nil
 	// return validate(obj)
diff --git a/context.go b/context.go
index c8a59bb0..e5d91808 100644
--- a/context.go
+++ b/context.go
@@ -525,7 +525,7 @@ func (c *Context) BindQuery(obj interface{}) error {
 }
 
 // MustBindWith binds the passed struct pointer using the specified binding engine.
-// It will abort the request with HTTP 400 if any error ocurrs.
+// It will abort the request with HTTP 400 if any error occurs.
 // See the binding package.
 func (c *Context) MustBindWith(obj interface{}, b binding.Binding) (err error) {
 	if err = c.ShouldBindWith(obj, b); err != nil {
diff --git a/examples/grpc/gin/main.go b/examples/grpc/gin/main.go
index edc1ca9b..820e65a3 100644
--- a/examples/grpc/gin/main.go
+++ b/examples/grpc/gin/main.go
@@ -19,7 +19,7 @@ func main() {
 	defer conn.Close()
 	client := pb.NewGreeterClient(conn)
 
-	// Set up a http setver.
+	// Set up a http server.
 	r := gin.Default()
 	r.GET("/rest/n/:name", func(c *gin.Context) {
 		name := c.Param("name")
diff --git a/logger.go b/logger.go
index 5f986853..74dd2e6f 100644
--- a/logger.go
+++ b/logger.go
@@ -53,7 +53,7 @@ func Logger() HandlerFunc {
 	return LoggerWithWriter(DefaultWriter)
 }
 
-// LoggerWithWriter instance a Logger middleware with the specified writter buffer.
+// LoggerWithWriter instance a Logger middleware with the specified writer buffer.
 // Example: os.Stdout, a file opened in write mode, a socket...
 func LoggerWithWriter(out io.Writer, notlogged ...string) HandlerFunc {
 	isTerm := true
diff --git a/routergroup.go b/routergroup.go
index 579aa7dc..9cb0b989 100644
--- a/routergroup.go
+++ b/routergroup.go
@@ -53,8 +53,8 @@ func (group *RouterGroup) Use(middleware ...HandlerFunc) IRoutes {
 	return group.returnObj()
 }
 
-// Group creates a new router group. You should add all the routes that have common middlwares or the same path prefix.
-// For example, all the routes that use a common middlware for authorization could be grouped.
+// Group creates a new router group. You should add all the routes that have common middlewares or the same path prefix.
+// For example, all the routes that use a common middleware for authorization could be grouped.
 func (group *RouterGroup) Group(relativePath string, handlers ...HandlerFunc) *RouterGroup {
 	return &RouterGroup{
 		Handlers: group.combineHandlers(handlers),
diff --git a/tree_test.go b/tree_test.go
index a1b3bbe7..92dc6956 100644
--- a/tree_test.go
+++ b/tree_test.go
@@ -12,7 +12,7 @@ import (
 	"testing"
 )
 
-// Used as a workaround since we can't compare functions or their addressses
+// Used as a workaround since we can't compare functions or their addresses
 var fakeHandlerValue string
 
 func fakeHandler(val string) HandlersChain {

From 8cb390f8fe847854adf21aca97561db9602d4ad8 Mon Sep 17 00:00:00 2001
From: Gordon Tyler <gordon@doxxx.net>
Date: Mon, 5 Nov 2018 20:49:45 -0500
Subject: [PATCH 096/105] Yaml binding (#1618)

* Add YAML binding for application/x-yaml.

* Add YAML binding methods to Context.

* Review fixes.

* Revert accidentally removed import.
---
 README.md                    |  6 +++---
 binding/binding.go           |  4 ++++
 binding/binding_body_test.go |  9 +++++++--
 binding/binding_test.go      | 17 +++++++++++++++++
 binding/yaml.go              | 35 +++++++++++++++++++++++++++++++++++
 context.go                   | 11 +++++++++++
 context_test.go              | 34 ++++++++++++++++++++++++++++++++++
 7 files changed, 111 insertions(+), 5 deletions(-)
 create mode 100644 binding/yaml.go

diff --git a/README.md b/README.md
index ba2dd578..96becfc7 100644
--- a/README.md
+++ b/README.md
@@ -529,7 +529,7 @@ func main() {
 
 ### Model binding and validation
 
-To bind a request body into a type, use model binding. We currently support binding of JSON, XML and standard form values (foo=bar&boo=baz).
+To bind a request body into a type, use model binding. We currently support binding of JSON, XML, YAML and standard form values (foo=bar&boo=baz).
 
 Gin uses [**go-playground/validator.v8**](https://github.com/go-playground/validator) for validation. Check the full docs on tags usage [here](http://godoc.org/gopkg.in/go-playground/validator.v8#hdr-Baked_In_Validators_and_Tags).
 
@@ -537,10 +537,10 @@ Note that you need to set the corresponding binding tag on all fields you want t
 
 Also, Gin provides two sets of methods for binding:
 - **Type** - Must bind
-  - **Methods** - `Bind`, `BindJSON`, `BindXML`, `BindQuery`
+  - **Methods** - `Bind`, `BindJSON`, `BindXML`, `BindQuery`, `BindYAML`
   - **Behavior** - These methods use `MustBindWith` under the hood. If there is a binding error, the request is aborted with `c.AbortWithError(400, err).SetType(ErrorTypeBind)`. This sets the response status code to 400 and the `Content-Type` header is set to `text/plain; charset=utf-8`. Note that if you try to set the response code after this, it will result in a warning `[GIN-debug] [WARNING] Headers were already written. Wanted to override status code 400 with 422`. If you wish to have greater control over the behavior, consider using the `ShouldBind` equivalent method.
 - **Type** - Should bind
-  - **Methods** - `ShouldBind`, `ShouldBindJSON`, `ShouldBindXML`, `ShouldBindQuery`
+  - **Methods** - `ShouldBind`, `ShouldBindJSON`, `ShouldBindXML`, `ShouldBindQuery`, `ShouldBindYAML`
   - **Behavior** - These methods use `ShouldBindWith` under the hood. If there is a binding error, the error is returned and it is the developer's responsibility to handle the request and error appropriately.
 
 When using the Bind-method, Gin tries to infer the binder depending on the Content-Type header. If you are sure what you are binding, you can use `MustBindWith` or `ShouldBindWith`.
diff --git a/binding/binding.go b/binding/binding.go
index ecbce2fa..2e2a33da 100644
--- a/binding/binding.go
+++ b/binding/binding.go
@@ -18,6 +18,7 @@ const (
 	MIMEPROTOBUF          = "application/x-protobuf"
 	MIMEMSGPACK           = "application/x-msgpack"
 	MIMEMSGPACK2          = "application/msgpack"
+	MIMEYAML              = "application/x-yaml"
 )
 
 // Binding describes the interface which needs to be implemented for binding the
@@ -68,6 +69,7 @@ var (
 	FormMultipart = formMultipartBinding{}
 	ProtoBuf      = protobufBinding{}
 	MsgPack       = msgpackBinding{}
+	YAML          = yamlBinding{}
 )
 
 // Default returns the appropriate Binding instance based on the HTTP method
@@ -86,6 +88,8 @@ func Default(method, contentType string) Binding {
 		return ProtoBuf
 	case MIMEMSGPACK, MIMEMSGPACK2:
 		return MsgPack
+	case MIMEYAML:
+		return YAML
 	default: //case MIMEPOSTForm, MIMEMultipartPOSTForm:
 		return Form
 	}
diff --git a/binding/binding_body_test.go b/binding/binding_body_test.go
index dfd761e1..901d429c 100644
--- a/binding/binding_body_test.go
+++ b/binding/binding_body_test.go
@@ -19,12 +19,12 @@ func TestBindingBody(t *testing.T) {
 		want    string
 	}{
 		{
-			name:    "JSON bidning",
+			name:    "JSON binding",
 			binding: JSON,
 			body:    `{"foo":"FOO"}`,
 		},
 		{
-			name:    "XML bidning",
+			name:    "XML binding",
 			binding: XML,
 			body: `<?xml version="1.0" encoding="UTF-8"?>
 <root>
@@ -36,6 +36,11 @@ func TestBindingBody(t *testing.T) {
 			binding: MsgPack,
 			body:    msgPackBody(t),
 		},
+		{
+			name:    "YAML binding",
+			binding: YAML,
+			body:    `foo: FOO`,
+		},
 	} {
 		t.Logf("testing: %s", tt.name)
 		req := requestWithBody("POST", "/", tt.body)
diff --git a/binding/binding_test.go b/binding/binding_test.go
index efe87669..e76cb853 100644
--- a/binding/binding_test.go
+++ b/binding/binding_test.go
@@ -190,6 +190,9 @@ func TestBindingDefault(t *testing.T) {
 
 	assert.Equal(t, MsgPack, Default("POST", MIMEMSGPACK))
 	assert.Equal(t, MsgPack, Default("PUT", MIMEMSGPACK2))
+
+	assert.Equal(t, YAML, Default("POST", MIMEYAML))
+	assert.Equal(t, YAML, Default("PUT", MIMEYAML))
 }
 
 func TestBindingJSON(t *testing.T) {
@@ -473,6 +476,20 @@ func TestBindingXMLFail(t *testing.T) {
 		"<map><foo>bar<foo></map>", "<map><bar>foo</bar></map>")
 }
 
+func TestBindingYAML(t *testing.T) {
+	testBodyBinding(t,
+		YAML, "yaml",
+		"/", "/",
+		`foo: bar`, `bar: foo`)
+}
+
+func TestBindingYAMLFail(t *testing.T) {
+	testBodyBindingFail(t,
+		YAML, "yaml",
+		"/", "/",
+		`foo:\nbar`, `bar: foo`)
+}
+
 func createFormPostRequest() *http.Request {
 	req, _ := http.NewRequest("POST", "/?foo=getfoo&bar=getbar", bytes.NewBufferString("foo=bar&bar=foo"))
 	req.Header.Set("Content-Type", MIMEPOSTForm)
diff --git a/binding/yaml.go b/binding/yaml.go
new file mode 100644
index 00000000..a2d36d6a
--- /dev/null
+++ b/binding/yaml.go
@@ -0,0 +1,35 @@
+// Copyright 2018 Gin Core Team.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package binding
+
+import (
+	"bytes"
+	"io"
+	"net/http"
+
+	"gopkg.in/yaml.v2"
+)
+
+type yamlBinding struct{}
+
+func (yamlBinding) Name() string {
+	return "yaml"
+}
+
+func (yamlBinding) Bind(req *http.Request, obj interface{}) error {
+	return decodeYAML(req.Body, obj)
+}
+
+func (yamlBinding) BindBody(body []byte, obj interface{}) error {
+	return decodeYAML(bytes.NewReader(body), obj)
+}
+
+func decodeYAML(r io.Reader, obj interface{}) error {
+	decoder := yaml.NewDecoder(r)
+	if err := decoder.Decode(obj); err != nil {
+		return err
+	}
+	return validate(obj)
+}
diff --git a/context.go b/context.go
index e5d91808..887e716d 100644
--- a/context.go
+++ b/context.go
@@ -31,6 +31,7 @@ const (
 	MIMEPlain             = binding.MIMEPlain
 	MIMEPOSTForm          = binding.MIMEPOSTForm
 	MIMEMultipartPOSTForm = binding.MIMEMultipartPOSTForm
+	MIMEYAML              = binding.MIMEYAML
 	BodyBytesKey          = "_gin-gonic/gin/bodybyteskey"
 )
 
@@ -524,6 +525,11 @@ func (c *Context) BindQuery(obj interface{}) error {
 	return c.MustBindWith(obj, binding.Query)
 }
 
+// BindYAML is a shortcut for c.MustBindWith(obj, binding.YAML).
+func (c *Context) BindYAML(obj interface{}) error {
+	return c.MustBindWith(obj, binding.YAML)
+}
+
 // MustBindWith binds the passed struct pointer using the specified binding engine.
 // It will abort the request with HTTP 400 if any error occurs.
 // See the binding package.
@@ -563,6 +569,11 @@ func (c *Context) ShouldBindQuery(obj interface{}) error {
 	return c.ShouldBindWith(obj, binding.Query)
 }
 
+// ShouldBindYAML is a shortcut for c.ShouldBindWith(obj, binding.YAML).
+func (c *Context) ShouldBindYAML(obj interface{}) error {
+	return c.ShouldBindWith(obj, binding.YAML)
+}
+
 // ShouldBindWith binds the passed struct pointer using the specified binding engine.
 // See the binding package.
 func (c *Context) ShouldBindWith(obj interface{}, b binding.Binding) error {
diff --git a/context_test.go b/context_test.go
index fb492e02..dced73fd 100644
--- a/context_test.go
+++ b/context_test.go
@@ -1380,6 +1380,23 @@ func TestContextBindWithQuery(t *testing.T) {
 	assert.Equal(t, 0, w.Body.Len())
 }
 
+func TestContextBindWithYAML(t *testing.T) {
+	w := httptest.NewRecorder()
+	c, _ := CreateTestContext(w)
+
+	c.Request, _ = http.NewRequest("POST", "/", bytes.NewBufferString("foo: bar\nbar: foo"))
+	c.Request.Header.Add("Content-Type", MIMEXML) // set fake content-type
+
+	var obj struct {
+		Foo string `yaml:"foo"`
+		Bar string `yaml:"bar"`
+	}
+	assert.NoError(t, c.BindYAML(&obj))
+	assert.Equal(t, "foo", obj.Bar)
+	assert.Equal(t, "bar", obj.Foo)
+	assert.Equal(t, 0, w.Body.Len())
+}
+
 func TestContextBadAutoBind(t *testing.T) {
 	w := httptest.NewRecorder()
 	c, _ := CreateTestContext(w)
@@ -1470,6 +1487,23 @@ func TestContextShouldBindWithQuery(t *testing.T) {
 	assert.Equal(t, 0, w.Body.Len())
 }
 
+func TestContextShouldBindWithYAML(t *testing.T) {
+	w := httptest.NewRecorder()
+	c, _ := CreateTestContext(w)
+
+	c.Request, _ = http.NewRequest("POST", "/", bytes.NewBufferString("foo: bar\nbar: foo"))
+	c.Request.Header.Add("Content-Type", MIMEXML) // set fake content-type
+
+	var obj struct {
+		Foo string `yaml:"foo"`
+		Bar string `yaml:"bar"`
+	}
+	assert.NoError(t, c.ShouldBindYAML(&obj))
+	assert.Equal(t, "foo", obj.Bar)
+	assert.Equal(t, "bar", obj.Foo)
+	assert.Equal(t, 0, w.Body.Len())
+}
+
 func TestContextBadAutoShouldBind(t *testing.T) {
 	w := httptest.NewRecorder()
 	c, _ := CreateTestContext(w)

From 66b47a8068235f653b3270b0e4d081880d986125 Mon Sep 17 00:00:00 2001
From: Yoshiki Nakagawa <yyoshiki41@gmail.com>
Date: Tue, 6 Nov 2018 11:28:51 +0900
Subject: [PATCH 097/105] feat(server): Implements RunFd method (#1609)

---
 gin.go                  | 18 ++++++++++++++++++
 gin_integration_test.go | 36 ++++++++++++++++++++++++++++++++++++
 2 files changed, 54 insertions(+)

diff --git a/gin.go b/gin.go
index 440519f5..b7c77e1f 100644
--- a/gin.go
+++ b/gin.go
@@ -5,6 +5,7 @@
 package gin
 
 import (
+	"fmt"
 	"html/template"
 	"net"
 	"net/http"
@@ -321,6 +322,23 @@ func (engine *Engine) RunUnix(file string) (err error) {
 	return
 }
 
+// RunFd attaches the router to a http.Server and starts listening and serving HTTP requests
+// through the specified file descriptor.
+// Note: this method will block the calling goroutine indefinitely unless an error happens.
+func (engine *Engine) RunFd(fd int) (err error) {
+	debugPrint("Listening and serving HTTP on fd@%d", fd)
+	defer func() { debugPrintError(err) }()
+
+	f := os.NewFile(uintptr(fd), fmt.Sprintf("fd@%d", fd))
+	listener, err := net.FileListener(f)
+	if err != nil {
+		return
+	}
+	defer listener.Close()
+	err = http.Serve(listener, engine)
+	return
+}
+
 // ServeHTTP conforms to the http.Handler interface.
 func (engine *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) {
 	c := engine.pool.Get().(*Context)
diff --git a/gin_integration_test.go b/gin_integration_test.go
index 038c8b7c..e14a688c 100644
--- a/gin_integration_test.go
+++ b/gin_integration_test.go
@@ -134,6 +134,42 @@ func TestBadUnixSocket(t *testing.T) {
 	assert.Error(t, router.RunUnix("#/tmp/unix_unit_test"))
 }
 
+func TestFileDescriptor(t *testing.T) {
+	router := New()
+
+	addr, err := net.ResolveTCPAddr("tcp", ":8000")
+	assert.NoError(t, err)
+	listener, err := net.ListenTCP("tcp", addr)
+	assert.NoError(t, err)
+	socketFile, err := listener.File()
+	assert.NoError(t, err)
+
+	go func() {
+		router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })
+		assert.NoError(t, router.RunFd(int(socketFile.Fd())))
+	}()
+	// have to wait for the goroutine to start and run the server
+	// otherwise the main thread will complete
+	time.Sleep(5 * time.Millisecond)
+
+	c, err := net.Dial("tcp", "localhost:8000")
+	assert.NoError(t, err)
+
+	fmt.Fprintf(c, "GET /example HTTP/1.0\r\n\r\n")
+	scanner := bufio.NewScanner(c)
+	var response string
+	for scanner.Scan() {
+		response += scanner.Text()
+	}
+	assert.Contains(t, response, "HTTP/1.0 200", "should get a 200")
+	assert.Contains(t, response, "it worked", "resp body should match")
+}
+
+func TestBadFileDescriptor(t *testing.T) {
+	router := New()
+	assert.Error(t, router.RunFd(0))
+}
+
 func TestWithHttptestWithAutoSelectedPort(t *testing.T) {
 	router := New()
 	router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })

From 37854ee10f7161843c338d9a9fa87f9398aacbbe Mon Sep 17 00:00:00 2001
From: Justin Israel <justinisrael@gmail.com>
Date: Tue, 6 Nov 2018 18:40:20 +1300
Subject: [PATCH 098/105] Fix panic stack trace being printed during recovery
 of broken pipe (#1089) (#1259)

---
 recovery.go      | 40 ++++++++++++++++++++++++++++++++--------
 recovery_test.go | 40 ++++++++++++++++++++++++++++++++++++++++
 2 files changed, 72 insertions(+), 8 deletions(-)

diff --git a/recovery.go b/recovery.go
index 6c28b4fa..e788cc47 100644
--- a/recovery.go
+++ b/recovery.go
@@ -10,9 +10,12 @@ import (
 	"io"
 	"io/ioutil"
 	"log"
+	"net"
 	"net/http"
 	"net/http/httputil"
+	"os"
 	"runtime"
+	"syscall"
 	"time"
 )
 
@@ -37,16 +40,37 @@ func RecoveryWithWriter(out io.Writer) HandlerFunc {
 	return func(c *Context) {
 		defer func() {
 			if err := recover(); err != nil {
-				if logger != nil {
-					stack := stack(3)
-					if IsDebugging() {
-						httprequest, _ := httputil.DumpRequest(c.Request, false)
-						logger.Printf("[Recovery] %s panic recovered:\n%s\n%s\n%s%s", timeFormat(time.Now()), string(httprequest), err, stack, reset)
-					} else {
-						logger.Printf("[Recovery] %s panic recovered:\n%s\n%s%s", timeFormat(time.Now()), err, stack, reset)
+				// Check for a broken connection, as it is not really a
+				// condition that warrants a panic stack trace.
+				var brokenPipe bool
+				if ne, ok := err.(*net.OpError); ok {
+					if se, ok := ne.Err.(*os.SyscallError); ok {
+						if se.Err == syscall.EPIPE || se.Err == syscall.ECONNRESET {
+							brokenPipe = true
+						}
 					}
 				}
-				c.AbortWithStatus(http.StatusInternalServerError)
+				if logger != nil {
+					stack := stack(3)
+					httprequest, _ := httputil.DumpRequest(c.Request, false)
+					if brokenPipe {
+						logger.Printf("%s\n%s%s", err, string(httprequest), reset)
+					} else if IsDebugging() {
+						logger.Printf("[Recovery] %s panic recovered:\n%s\n%s\n%s%s",
+							timeFormat(time.Now()), string(httprequest), err, stack, reset)
+					} else {
+						logger.Printf("[Recovery] %s panic recovered:\n%s\n%s%s",
+							timeFormat(time.Now()), err, stack, reset)
+					}
+				}
+
+				// If the connection is dead, we can't write a status to it.
+				if brokenPipe {
+					c.Error(err.(error))
+					c.Abort()
+				} else {
+					c.AbortWithStatus(http.StatusInternalServerError)
+				}
 			}
 		}()
 		c.Next()
diff --git a/recovery_test.go b/recovery_test.go
index 7d422b74..cafaee91 100644
--- a/recovery_test.go
+++ b/recovery_test.go
@@ -2,11 +2,16 @@
 // Use of this source code is governed by a MIT style
 // license that can be found in the LICENSE file.
 
+// +build go1.7
+
 package gin
 
 import (
 	"bytes"
+	"net"
 	"net/http"
+	"os"
+	"syscall"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -72,3 +77,38 @@ func TestFunction(t *testing.T) {
 	bs := function(1)
 	assert.Equal(t, []byte("???"), bs)
 }
+
+// TestPanicWithBrokenPipe asserts that recovery specifically handles
+// writing responses to broken pipes
+func TestPanicWithBrokenPipe(t *testing.T) {
+	const expectCode = 204
+
+	expectMsgs := map[syscall.Errno]string{
+		syscall.EPIPE:      "broken pipe",
+		syscall.ECONNRESET: "connection reset",
+	}
+
+	for errno, expectMsg := range expectMsgs {
+		t.Run(expectMsg, func(t *testing.T) {
+
+			var buf bytes.Buffer
+
+			router := New()
+			router.Use(RecoveryWithWriter(&buf))
+			router.GET("/recovery", func(c *Context) {
+				// Start writing response
+				c.Header("X-Test", "Value")
+				c.Status(expectCode)
+
+				// Oops. Client connection closed
+				e := &net.OpError{Err: &os.SyscallError{Err: errno}}
+				panic(e)
+			})
+			// RUN
+			w := performRequest(router, "GET", "/recovery")
+			// TEST
+			assert.Equal(t, expectCode, w.Code)
+			assert.Contains(t, buf.String(), expectMsg)
+		})
+	}
+}

From d6b2c13b18cc0986e579e100bc47f3704a0d3bcd Mon Sep 17 00:00:00 2001
From: Sai <sairoutine@gmail.com>
Date: Mon, 12 Nov 2018 19:58:24 +0900
Subject: [PATCH 099/105] Fix typo (#1641)

---
 mode.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mode.go b/mode.go
index 6a696329..f787b5ca 100644
--- a/mode.go
+++ b/mode.go
@@ -17,7 +17,7 @@ const ENV_GIN_MODE = "GIN_MODE"
 const (
 	// DebugMode indicates gin mode is debug.
 	DebugMode = "debug"
-	// ReleaseMode indicates gin mode is relase.
+	// ReleaseMode indicates gin mode is release.
 	ReleaseMode = "release"
 	// TestMode indicates gin mode is test.
 	TestMode = "test"

From 3d44ff82a1fe39b5991f292369eed0d6abf2a430 Mon Sep 17 00:00:00 2001
From: henrylee2cn <henrylee2cn@gmail.com>
Date: Thu, 22 Nov 2018 09:07:00 +0800
Subject: [PATCH 100/105] Make sure the debug log contains line breaks (#1650)

Many debug logs have no line breaks, so fix them here.

- With pull requests:
  - Open your pull request against `master`
  - Your pull request should have no more than two commits, if not you should squash them.
  - It should pass all tests in the available continuous integrations systems such as TravisCI.
  - You should add/modify tests to cover your proposed code changes.
  - If your pull request contains a new feature, please document it on the README.
---
 debug.go | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/debug.go b/debug.go
index c5e65b22..98c67cf7 100644
--- a/debug.go
+++ b/debug.go
@@ -51,6 +51,9 @@ func debugPrintLoadTemplate(tmpl *template.Template) {
 
 func debugPrint(format string, values ...interface{}) {
 	if IsDebugging() {
+		if !strings.HasSuffix(format, "\n") {
+			format += "\n"
+		}
 		fmt.Fprintf(os.Stderr, "[GIN-debug] "+format, values...)
 	}
 }

From 7ec82ee8944579c533425bb6826bcb12b5860ecd Mon Sep 17 00:00:00 2001
From: thinkerou <thinkerou@gmail.com>
Date: Thu, 22 Nov 2018 09:17:44 +0800
Subject: [PATCH 101/105] recovery: fix issue about syscall import on google
 app engine (#1640)

* recovery: fix issue about syscall import on google app engine

* add ToLower()

* the whole error message
---
 recovery.go      | 4 ++--
 recovery_test.go | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/recovery.go b/recovery.go
index e788cc47..f06ad56b 100644
--- a/recovery.go
+++ b/recovery.go
@@ -15,7 +15,7 @@ import (
 	"net/http/httputil"
 	"os"
 	"runtime"
-	"syscall"
+	"strings"
 	"time"
 )
 
@@ -45,7 +45,7 @@ func RecoveryWithWriter(out io.Writer) HandlerFunc {
 				var brokenPipe bool
 				if ne, ok := err.(*net.OpError); ok {
 					if se, ok := ne.Err.(*os.SyscallError); ok {
-						if se.Err == syscall.EPIPE || se.Err == syscall.ECONNRESET {
+						if strings.Contains(strings.ToLower(se.Error()), "broken pipe") || strings.Contains(strings.ToLower(se.Error()), "connection reset by peer") {
 							brokenPipe = true
 						}
 					}
diff --git a/recovery_test.go b/recovery_test.go
index cafaee91..c9fb29ce 100644
--- a/recovery_test.go
+++ b/recovery_test.go
@@ -84,8 +84,8 @@ func TestPanicWithBrokenPipe(t *testing.T) {
 	const expectCode = 204
 
 	expectMsgs := map[syscall.Errno]string{
-		syscall.EPIPE:      "broken pipe",
-		syscall.ECONNRESET: "connection reset",
+		syscall.EPIPE:      "Broken pipe",
+		syscall.ECONNRESET: "connection reset by peer",
 	}
 
 	for errno, expectMsg := range expectMsgs {

From 521d06c81d5e49a004473daa81b71e1d34fe7a05 Mon Sep 17 00:00:00 2001
From: thinkerou <thinkerou@gmail.com>
Date: Thu, 22 Nov 2018 09:29:48 +0800
Subject: [PATCH 102/105] support bind uri param (#1612)

* support bind uri (1)

* uri binding successful run

* fix vet warning: github.com/gin-gonic/gin/internal.Param composite literal uses unkeyed fields

* fix code style

* update function name

* fix test function signature

* add test for CanSet

* update readme and add test case

* remove internal.Params

* add coverage

* fix warning
---
 README.md               | 35 ++++++++++++++++++++++++++
 binding/binding.go      |  8 ++++++
 binding/binding_test.go | 30 +++++++++++++++++++++++
 binding/form_mapping.go | 10 +++++++-
 binding/uri.go          | 18 ++++++++++++++
 context.go              | 13 +++++++---
 githubapi_test.go       | 21 ++++++++++++++++
 tree_test.go            | 54 ++++++++++++++++++++---------------------
 8 files changed, 158 insertions(+), 31 deletions(-)
 create mode 100644 binding/uri.go

diff --git a/README.md b/README.md
index 96becfc7..3f0c9170 100644
--- a/README.md
+++ b/README.md
@@ -39,6 +39,7 @@ Gin is a web framework written in Go (Golang). It features a martini-like API wi
     - [Custom Validators](#custom-validators)
     - [Only Bind Query String](#only-bind-query-string)
     - [Bind Query String or Post Data](#bind-query-string-or-post-data)
+    - [Bind Uri](#bind-uri)
     - [Bind HTML checkboxes](#bind-html-checkboxes)
     - [Multipart/Urlencoded binding](#multiparturlencoded-binding)
     - [XML, JSON, YAML and ProtoBuf rendering](#xml-json-yaml-and-protobuf-rendering)
@@ -793,6 +794,40 @@ Test it with:
 $ curl -X GET "localhost:8085/testing?name=appleboy&address=xyz&birthday=1992-03-15"
 ```
 
+### Bind Uri
+
+See the [detail information](https://github.com/gin-gonic/gin/issues/846).
+
+```go
+package main
+
+import "github.com/gin-gonic/gin"
+
+type Person struct {
+	ID string `uri:"id" binding:"required,uuid"`
+	Name string `uri:"name" binding:"required"`
+}
+
+func main() {
+	route := gin.Default()
+	route.GET("/:name/:id", func(c *gin.Context) {
+		var person Person
+		if err := c.ShouldBindUri(&person); err != nil {
+			c.JSON(400, gin.H{"msg": err})
+			return
+		}
+		c.JSON(200, gin.H{"name": person.Name, "uuid": person.ID})
+	})
+	route.Run(":8088")
+}
+```
+
+Test it with:
+```sh
+$ curl -v localhost:8088/thinkerou/987fbc97-4bed-5078-9f07-9141ba07c9f3
+$ curl -v localhost:8088/thinkerou/not-uuid
+```
+
 ### Bind HTML checkboxes
 
 See the [detail information](https://github.com/gin-gonic/gin/issues/129#issuecomment-124260092)
diff --git a/binding/binding.go b/binding/binding.go
index 2e2a33da..26d71c9f 100644
--- a/binding/binding.go
+++ b/binding/binding.go
@@ -36,6 +36,13 @@ type BindingBody interface {
 	BindBody([]byte, interface{}) error
 }
 
+// BindingUri adds BindUri method to Binding. BindUri is similar with Bind,
+// but it read the Params.
+type BindingUri interface {
+	Name() string
+	BindUri(map[string][]string, interface{}) error
+}
+
 // StructValidator is the minimal interface which needs to be implemented in
 // order for it to be used as the validator engine for ensuring the correctness
 // of the request. Gin provides a default implementation for this using
@@ -70,6 +77,7 @@ var (
 	ProtoBuf      = protobufBinding{}
 	MsgPack       = msgpackBinding{}
 	YAML          = yamlBinding{}
+	Uri           = uriBinding{}
 )
 
 // Default returns the appropriate Binding instance based on the HTTP method
diff --git a/binding/binding_test.go b/binding/binding_test.go
index e76cb853..183d111f 100644
--- a/binding/binding_test.go
+++ b/binding/binding_test.go
@@ -662,6 +662,27 @@ func TestExistsFails(t *testing.T) {
 	assert.Error(t, err)
 }
 
+func TestUriBinding(t *testing.T) {
+	b := Uri
+	assert.Equal(t, "uri", b.Name())
+
+	type Tag struct {
+		Name string `uri:"name"`
+	}
+	var tag Tag
+	m := make(map[string][]string)
+	m["name"] = []string{"thinkerou"}
+	assert.NoError(t, b.BindUri(m, &tag))
+	assert.Equal(t, "thinkerou", tag.Name)
+
+	type NotSupportStruct struct {
+		Name map[string]interface{} `uri:"name"`
+	}
+	var not NotSupportStruct
+	assert.Error(t, b.BindUri(m, &not))
+	assert.Equal(t, "", not.Name)
+}
+
 func testFormBinding(t *testing.T, method, path, badPath, body, badBody string) {
 	b := Form
 	assert.Equal(t, "form", b.Name())
@@ -1232,3 +1253,12 @@ func requestWithBody(method, path, body string) (req *http.Request) {
 	req, _ = http.NewRequest(method, path, bytes.NewBufferString(body))
 	return
 }
+
+func TestCanSet(t *testing.T) {
+	type CanSetStruct struct {
+		lowerStart string `form:"lower"`
+	}
+
+	var c CanSetStruct
+	assert.Nil(t, mapForm(&c, nil))
+}
diff --git a/binding/form_mapping.go b/binding/form_mapping.go
index f46a0dc1..d893c21c 100644
--- a/binding/form_mapping.go
+++ b/binding/form_mapping.go
@@ -12,7 +12,15 @@ import (
 	"time"
 )
 
+func mapUri(ptr interface{}, m map[string][]string) error {
+	return mapFormByTag(ptr, m, "uri")
+}
+
 func mapForm(ptr interface{}, form map[string][]string) error {
+	return mapFormByTag(ptr, form, "form")
+}
+
+func mapFormByTag(ptr interface{}, form map[string][]string, tag string) error {
 	typ := reflect.TypeOf(ptr).Elem()
 	val := reflect.ValueOf(ptr).Elem()
 	for i := 0; i < typ.NumField(); i++ {
@@ -23,7 +31,7 @@ func mapForm(ptr interface{}, form map[string][]string) error {
 		}
 
 		structFieldKind := structField.Kind()
-		inputFieldName := typeField.Tag.Get("form")
+		inputFieldName := typeField.Tag.Get(tag)
 		inputFieldNameList := strings.Split(inputFieldName, ",")
 		inputFieldName = inputFieldNameList[0]
 		var defaultValue string
diff --git a/binding/uri.go b/binding/uri.go
new file mode 100644
index 00000000..f91ec381
--- /dev/null
+++ b/binding/uri.go
@@ -0,0 +1,18 @@
+// Copyright 2018 Gin Core Team.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package binding
+
+type uriBinding struct{}
+
+func (uriBinding) Name() string {
+	return "uri"
+}
+
+func (uriBinding) BindUri(m map[string][]string, obj interface{}) error {
+	if err := mapUri(obj, m); err != nil {
+		return err
+	}
+	return validate(obj)
+}
diff --git a/context.go b/context.go
index 887e716d..478e8c09 100644
--- a/context.go
+++ b/context.go
@@ -574,6 +574,15 @@ func (c *Context) ShouldBindYAML(obj interface{}) error {
 	return c.ShouldBindWith(obj, binding.YAML)
 }
 
+// ShouldBindUri binds the passed struct pointer using the specified binding engine.
+func (c *Context) ShouldBindUri(obj interface{}) error {
+	m := make(map[string][]string)
+	for _, v := range c.Params {
+		m[v.Key] = []string{v.Value}
+	}
+	return binding.Uri.BindUri(m, obj)
+}
+
 // ShouldBindWith binds the passed struct pointer using the specified binding engine.
 // See the binding package.
 func (c *Context) ShouldBindWith(obj interface{}, b binding.Binding) error {
@@ -585,9 +594,7 @@ func (c *Context) ShouldBindWith(obj interface{}, b binding.Binding) error {
 //
 // NOTE: This method reads the body before binding. So you should use
 // ShouldBindWith for better performance if you need to call only once.
-func (c *Context) ShouldBindBodyWith(
-	obj interface{}, bb binding.BindingBody,
-) (err error) {
+func (c *Context) ShouldBindBodyWith(obj interface{}, bb binding.BindingBody) (err error) {
 	var body []byte
 	if cb, ok := c.Get(BodyBytesKey); ok {
 		if cbb, ok := cb.([]byte); ok {
diff --git a/githubapi_test.go b/githubapi_test.go
index f631035d..6b56a2b7 100644
--- a/githubapi_test.go
+++ b/githubapi_test.go
@@ -285,6 +285,27 @@ var githubAPI = []route{
 	{"DELETE", "/user/keys/:id"},
 }
 
+func TestShouldBindUri(t *testing.T) {
+	DefaultWriter = os.Stdout
+	router := Default()
+
+	type Person struct {
+		Name string `uri:"name"`
+		Id   string `uri:"id"`
+	}
+	router.Handle("GET", "/rest/:name/:id", func(c *Context) {
+		var person Person
+		assert.NoError(t, c.ShouldBindUri(&person))
+		assert.True(t, "" != person.Name)
+		assert.True(t, "" != person.Id)
+		c.String(http.StatusOK, "ShouldBindUri test OK")
+	})
+
+	path, _ := exampleFromPath("/rest/:name/:id")
+	w := performRequest(router, "GET", path)
+	assert.Equal(t, "ShouldBindUri test OK", w.Body.String())
+}
+
 func githubConfigRouter(router *Engine) {
 	for _, route := range githubAPI {
 		router.Handle(route.method, route.path, func(c *Context) {
diff --git a/tree_test.go b/tree_test.go
index 92dc6956..dbb0352b 100644
--- a/tree_test.go
+++ b/tree_test.go
@@ -170,19 +170,19 @@ func TestTreeWildcard(t *testing.T) {
 
 	checkRequests(t, tree, testRequests{
 		{"/", false, "/", nil},
-		{"/cmd/test/", false, "/cmd/:tool/", Params{Param{"tool", "test"}}},
-		{"/cmd/test", true, "", Params{Param{"tool", "test"}}},
-		{"/cmd/test/3", false, "/cmd/:tool/:sub", Params{Param{"tool", "test"}, Param{"sub", "3"}}},
-		{"/src/", false, "/src/*filepath", Params{Param{"filepath", "/"}}},
-		{"/src/some/file.png", false, "/src/*filepath", Params{Param{"filepath", "/some/file.png"}}},
+		{"/cmd/test/", false, "/cmd/:tool/", Params{Param{Key: "tool", Value: "test"}}},
+		{"/cmd/test", true, "", Params{Param{Key: "tool", Value: "test"}}},
+		{"/cmd/test/3", false, "/cmd/:tool/:sub", Params{Param{Key: "tool", Value: "test"}, Param{Key: "sub", Value: "3"}}},
+		{"/src/", false, "/src/*filepath", Params{Param{Key: "filepath", Value: "/"}}},
+		{"/src/some/file.png", false, "/src/*filepath", Params{Param{Key: "filepath", Value: "/some/file.png"}}},
 		{"/search/", false, "/search/", nil},
-		{"/search/someth!ng+in+ünìcodé", false, "/search/:query", Params{Param{"query", "someth!ng+in+ünìcodé"}}},
-		{"/search/someth!ng+in+ünìcodé/", true, "", Params{Param{"query", "someth!ng+in+ünìcodé"}}},
-		{"/user_gopher", false, "/user_:name", Params{Param{"name", "gopher"}}},
-		{"/user_gopher/about", false, "/user_:name/about", Params{Param{"name", "gopher"}}},
-		{"/files/js/inc/framework.js", false, "/files/:dir/*filepath", Params{Param{"dir", "js"}, Param{"filepath", "/inc/framework.js"}}},
-		{"/info/gordon/public", false, "/info/:user/public", Params{Param{"user", "gordon"}}},
-		{"/info/gordon/project/go", false, "/info/:user/project/:project", Params{Param{"user", "gordon"}, Param{"project", "go"}}},
+		{"/search/someth!ng+in+ünìcodé", false, "/search/:query", Params{Param{Key: "query", Value: "someth!ng+in+ünìcodé"}}},
+		{"/search/someth!ng+in+ünìcodé/", true, "", Params{Param{Key: "query", Value: "someth!ng+in+ünìcodé"}}},
+		{"/user_gopher", false, "/user_:name", Params{Param{Key: "name", Value: "gopher"}}},
+		{"/user_gopher/about", false, "/user_:name/about", Params{Param{Key: "name", Value: "gopher"}}},
+		{"/files/js/inc/framework.js", false, "/files/:dir/*filepath", Params{Param{Key: "dir", Value: "js"}, Param{Key: "filepath", Value: "/inc/framework.js"}}},
+		{"/info/gordon/public", false, "/info/:user/public", Params{Param{Key: "user", Value: "gordon"}}},
+		{"/info/gordon/project/go", false, "/info/:user/project/:project", Params{Param{Key: "user", Value: "gordon"}, Param{Key: "project", Value: "go"}}},
 	})
 
 	checkPriorities(t, tree)
@@ -209,18 +209,18 @@ func TestUnescapeParameters(t *testing.T) {
 	unescape := true
 	checkRequests(t, tree, testRequests{
 		{"/", false, "/", nil},
-		{"/cmd/test/", false, "/cmd/:tool/", Params{Param{"tool", "test"}}},
-		{"/cmd/test", true, "", Params{Param{"tool", "test"}}},
-		{"/src/some/file.png", false, "/src/*filepath", Params{Param{"filepath", "/some/file.png"}}},
-		{"/src/some/file+test.png", false, "/src/*filepath", Params{Param{"filepath", "/some/file test.png"}}},
-		{"/src/some/file++++%%%%test.png", false, "/src/*filepath", Params{Param{"filepath", "/some/file++++%%%%test.png"}}},
-		{"/src/some/file%2Ftest.png", false, "/src/*filepath", Params{Param{"filepath", "/some/file/test.png"}}},
-		{"/search/someth!ng+in+ünìcodé", false, "/search/:query", Params{Param{"query", "someth!ng in ünìcodé"}}},
-		{"/info/gordon/project/go", false, "/info/:user/project/:project", Params{Param{"user", "gordon"}, Param{"project", "go"}}},
-		{"/info/slash%2Fgordon", false, "/info/:user", Params{Param{"user", "slash/gordon"}}},
-		{"/info/slash%2Fgordon/project/Project%20%231", false, "/info/:user/project/:project", Params{Param{"user", "slash/gordon"}, Param{"project", "Project #1"}}},
-		{"/info/slash%%%%", false, "/info/:user", Params{Param{"user", "slash%%%%"}}},
-		{"/info/slash%%%%2Fgordon/project/Project%%%%20%231", false, "/info/:user/project/:project", Params{Param{"user", "slash%%%%2Fgordon"}, Param{"project", "Project%%%%20%231"}}},
+		{"/cmd/test/", false, "/cmd/:tool/", Params{Param{Key: "tool", Value: "test"}}},
+		{"/cmd/test", true, "", Params{Param{Key: "tool", Value: "test"}}},
+		{"/src/some/file.png", false, "/src/*filepath", Params{Param{Key: "filepath", Value: "/some/file.png"}}},
+		{"/src/some/file+test.png", false, "/src/*filepath", Params{Param{Key: "filepath", Value: "/some/file test.png"}}},
+		{"/src/some/file++++%%%%test.png", false, "/src/*filepath", Params{Param{Key: "filepath", Value: "/some/file++++%%%%test.png"}}},
+		{"/src/some/file%2Ftest.png", false, "/src/*filepath", Params{Param{Key: "filepath", Value: "/some/file/test.png"}}},
+		{"/search/someth!ng+in+ünìcodé", false, "/search/:query", Params{Param{Key: "query", Value: "someth!ng in ünìcodé"}}},
+		{"/info/gordon/project/go", false, "/info/:user/project/:project", Params{Param{Key: "user", Value: "gordon"}, Param{Key: "project", Value: "go"}}},
+		{"/info/slash%2Fgordon", false, "/info/:user", Params{Param{Key: "user", Value: "slash/gordon"}}},
+		{"/info/slash%2Fgordon/project/Project%20%231", false, "/info/:user/project/:project", Params{Param{Key: "user", Value: "slash/gordon"}, Param{Key: "project", Value: "Project #1"}}},
+		{"/info/slash%%%%", false, "/info/:user", Params{Param{Key: "user", Value: "slash%%%%"}}},
+		{"/info/slash%%%%2Fgordon/project/Project%%%%20%231", false, "/info/:user/project/:project", Params{Param{Key: "user", Value: "slash%%%%2Fgordon"}, Param{Key: "project", Value: "Project%%%%20%231"}}},
 	}, unescape)
 
 	checkPriorities(t, tree)
@@ -326,9 +326,9 @@ func TestTreeDupliatePath(t *testing.T) {
 	checkRequests(t, tree, testRequests{
 		{"/", false, "/", nil},
 		{"/doc/", false, "/doc/", nil},
-		{"/src/some/file.png", false, "/src/*filepath", Params{Param{"filepath", "/some/file.png"}}},
-		{"/search/someth!ng+in+ünìcodé", false, "/search/:query", Params{Param{"query", "someth!ng+in+ünìcodé"}}},
-		{"/user_gopher", false, "/user_:name", Params{Param{"name", "gopher"}}},
+		{"/src/some/file.png", false, "/src/*filepath", Params{Param{Key: "filepath", Value: "/some/file.png"}}},
+		{"/search/someth!ng+in+ünìcodé", false, "/search/:query", Params{Param{Key: "query", Value: "someth!ng+in+ünìcodé"}}},
+		{"/user_gopher", false, "/user_:name", Params{Param{Key: "name", Value: "gopher"}}},
 	})
 }
 

From 64457fbca718085b793de98a50e7441b82ad5eb1 Mon Sep 17 00:00:00 2001
From: mllu <mornlyn@gmail.com>
Date: Wed, 21 Nov 2018 17:55:51 -0800
Subject: [PATCH 103/105] handle nil body for JSON binding (#1638)

---
 binding/binding_test.go | 7 +++++++
 binding/json.go         | 4 ++++
 2 files changed, 11 insertions(+)

diff --git a/binding/binding_test.go b/binding/binding_test.go
index 183d111f..5b311764 100644
--- a/binding/binding_test.go
+++ b/binding/binding_test.go
@@ -195,6 +195,13 @@ func TestBindingDefault(t *testing.T) {
 	assert.Equal(t, YAML, Default("PUT", MIMEYAML))
 }
 
+func TestBindingJSONNilBody(t *testing.T) {
+	var obj FooStruct
+	req, _ := http.NewRequest(http.MethodPost, "/", nil)
+	err := JSON.Bind(req, &obj)
+	assert.Error(t, err)
+}
+
 func TestBindingJSON(t *testing.T) {
 	testBodyBinding(t,
 		JSON, "json",
diff --git a/binding/json.go b/binding/json.go
index 310922c1..f968161b 100644
--- a/binding/json.go
+++ b/binding/json.go
@@ -6,6 +6,7 @@ package binding
 
 import (
 	"bytes"
+	"fmt"
 	"io"
 	"net/http"
 
@@ -24,6 +25,9 @@ func (jsonBinding) Name() string {
 }
 
 func (jsonBinding) Bind(req *http.Request, obj interface{}) error {
+	if req == nil || req.Body == nil {
+		return fmt.Errorf("invalid request")
+	}
 	return decodeJSON(req.Body, obj)
 }
 

From 6053156eedb01e982368933dce10ff46f2180c7a Mon Sep 17 00:00:00 2001
From: long-road <13412081338@163.com>
Date: Thu, 22 Nov 2018 23:42:41 +0800
Subject: [PATCH 104/105] add chinese docs (#1588)

---
 README_ZH.md | 1940 ++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 1940 insertions(+)
 create mode 100644 README_ZH.md

diff --git a/README_ZH.md b/README_ZH.md
new file mode 100644
index 00000000..d411f9eb
--- /dev/null
+++ b/README_ZH.md
@@ -0,0 +1,1940 @@
+# Gin Web 框架中文文档
+
+<img align="right" width="159px" src="https://raw.githubusercontent.com/gin-gonic/logo/master/color.png">
+
+[![Build Status](https://travis-ci.org/gin-gonic/gin.svg)](https://travis-ci.org/gin-gonic/gin)
+[![codecov](https://codecov.io/gh/gin-gonic/gin/branch/master/graph/badge.svg)](https://codecov.io/gh/gin-gonic/gin)
+[![Go Report Card](https://goreportcard.com/badge/github.com/gin-gonic/gin)](https://goreportcard.com/report/github.com/gin-gonic/gin)
+[![GoDoc](https://godoc.org/github.com/gin-gonic/gin?status.svg)](https://godoc.org/github.com/gin-gonic/gin)
+[![Join the chat at https://gitter.im/gin-gonic/gin](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/gin-gonic/gin?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![Sourcegraph](https://sourcegraph.com/github.com/gin-gonic/gin/-/badge.svg)](https://sourcegraph.com/github.com/gin-gonic/gin?badge)
+[![Open Source Helpers](https://www.codetriage.com/gin-gonic/gin/badges/users.svg)](https://www.codetriage.com/gin-gonic/gin)
+[![Release](https://img.shields.io/github/release/gin-gonic/gin.svg?style=flat-square)](https://github.com/gin-gonic/gin/releases)
+
+Gin 是一个 Go (Golang) 语言框架。 它是一个拥有更好性能的 martini-like API 框架, 比 [httprouter](https://github.com/julienschmidt/httprouter) 的速度快了40倍. 如果你是性能和高效的追求者, 那么你会爱上 Gin.
+
+![Gin console logger](https://gin-gonic.github.io/gin/other/console.png)
+
+## Contents
+
+- [安装](#安装)
+- [前提条件](#前提条件)
+- [快速启动](#快速启动)
+- [性能测试](#性能测试)
+- [Gin v1 稳定版](#gin-v1-稳定版)
+- [使用 jsoniter 构建](#使用-jsoniter-构建)
+- [API 示例](#api-示例)
+    - [GET,POST,PUT,PATCH,DELETE,OPTIONS 使用](#get-post-put-patch-delete-options-使用)
+    - [路由参数](#路由参数)
+    - [查询字符串参数](#查询字符串参数)
+    - [Multipart Urlencoded 表单](#multipart-urlencoded-表单)
+    - [另一个实列 query + post form](#另一个实列:-query-+-post-form)
+    - [映射参数 表单参数](#映射参数-表单参数)
+    - [上传文件](#上传文件)
+    - [路由组](#路由组)
+    - [默认初始化 Gin](#默认初始化-gin)
+    - [中间件使用](#中间件使用)
+    - [如何记录日志](#如何记录日志)
+    - [模型绑定和验证](#模型绑定和验证)
+    - [自定义验证器](#自定义验证器)
+    - [只绑定查询字符串](#只绑定查询字符串)
+    - [绑定查询字符串或发布数据](#绑定查询字符串或发布数据)
+    - [绑定 HTML 复选框](#绑定-html-复选框)
+    - [Multipart Urlencoded 绑定](#multipart-urlencoded-绑定)
+    - [XML JSON YAML ProtoBuf 渲染](#xml-json-yaml-protobuf-渲染)
+    - [SecureJSON](#SecureJSON)
+    - [静态文件服务](#静态文件服务)
+    - [从读者服务数据](#从读者服务数据)
+    - [HTML 渲染](#html-渲染)
+    - [多模板](#多模板)
+    - [重定向](#重定向)
+    - [自定义中间件](#自定义中间件)
+    - [使用 BasicAuth() 中间件](#使用-basicauth()-中间件)
+    - [Goroutines](#goroutines)
+    - [自定义 HTTP 配置](#自定义-http-配置)
+    - [Let's Encrypt 支持](#lets-encrypt-支持)
+    - [使用 Gin 运行多个服务](使用-gin-运行多个服务)
+    - [优雅重启或停止](#优雅重启或停止)
+    - [使用模板构建单个二进制文件](#使用模板构建单个二进制文件)
+    - [使用自定义结构绑定表单数据请求](#使用自定义结构绑定表单数据请求)
+    - [尝试将body绑定到不同的结构中](#尝试将-body-绑定到不同的结构中)
+    - [http2 server 推送](#http2-server-推送)
+    - [定义路由日志的格式](#定义路由日志的格式)
+- [测试](#测试)
+- [用户](#用户)
+
+## 安装
+
+要安装 Gin 软件包，需要先安装 Go 并设置 Go 工作区。
+
+1. 下载并安装 gin:
+
+```sh
+$ go get -u github.com/gin-gonic/gin
+```
+
+2. 将 gin 引入到代码中:
+
+```go
+import "github.com/gin-gonic/gin"
+```
+
+3. （可选）如果使用诸如`http.StatusOK`之类的常量，则需要引入 `net / http` 包。
+
+```go
+import "net/http"
+```
+
+### 使用 [Govendor](https://github.com/kardianos/govendor) 工具创建项目
+
+1. `go get` govendor
+
+```sh
+$ go get github.com/kardianos/govendor
+```
+2.创建项目并且 `cd` 到项目目录中
+
+```sh
+$ mkdir -p $GOPATH/src/github.com/myusername/project && cd "$_"
+```
+
+3. 使用 govendor 初始化项目,并且引入gin
+
+```sh
+$ govendor init
+$ govendor fetch github.com/gin-gonic/gin@v1.3
+```
+
+4. 复制一个启动文件模板到项目目录中
+
+```sh
+$ curl https://raw.githubusercontent.com/gin-gonic/gin/master/examples/basic/main.go > main.go
+```
+
+5.启动项目
+
+```sh
+$ go run main.go
+```
+
+## 前提条件
+
+新版本的 Gin 需要 Go 1.6 或者更高版本并且很快就会升级到 Go 1.7.
+
+## 快速启动
+ 
+```sh
+# assume the following codes in example.go file
+$ cat example.go
+```
+
+```go
+package main
+
+import "github.com/gin-gonic/gin"
+
+func main() {
+	r := gin.Default()
+	r.GET("/ping", func(c *gin.Context) {
+		c.JSON(200, gin.H{
+			"message": "pong",
+		})
+	})
+	r.Run() // listen and serve on 0.0.0.0:8080
+}
+```
+
+```
+# run example.go and visit 0.0.0.0:8080/ping on browser
+$ go run example.go
+```
+
+## 性能测试
+
+Gin 使用自定义版本的 [HttpRouter](https://github.com/julienschmidt/httprouter)
+
+[所有性能测试](/BENCHMARKS.md)
+
+Benchmark name                              | (1)        | (2)         | (3) 		    | (4)
+--------------------------------------------|-----------:|------------:|-----------:|---------:
+**BenchmarkGin_GithubAll**                  | **30000**  |  **48375**  |     **0**  |   **0**
+BenchmarkAce_GithubAll                      |   10000    |   134059    |   13792    |   167
+BenchmarkBear_GithubAll                     |    5000    |   534445    |   86448    |   943
+BenchmarkBeego_GithubAll                    |    3000    |   592444    |   74705    |   812
+BenchmarkBone_GithubAll                     |     200    |  6957308    |  698784    |  8453
+BenchmarkDenco_GithubAll                    |   10000    |   158819    |   20224    |   167
+BenchmarkEcho_GithubAll                     |   10000    |   154700    |    6496    |   203
+BenchmarkGocraftWeb_GithubAll               |    3000    |   570806    |  131656    |  1686
+BenchmarkGoji_GithubAll                     |    2000    |   818034    |   56112    |   334
+BenchmarkGojiv2_GithubAll                   |    2000    |  1213973    |  274768    |  3712
+BenchmarkGoJsonRest_GithubAll               |    2000    |   785796    |  134371    |  2737
+BenchmarkGoRestful_GithubAll                |     300    |  5238188    |  689672    |  4519
+BenchmarkGorillaMux_GithubAll               |     100    | 10257726    |  211840    |  2272
+BenchmarkHttpRouter_GithubAll               |   20000    |   105414    |   13792    |   167
+BenchmarkHttpTreeMux_GithubAll              |   10000    |   319934    |   65856    |   671
+BenchmarkKocha_GithubAll                    |   10000    |   209442    |   23304    |   843
+BenchmarkLARS_GithubAll                     |   20000    |    62565    |       0    |     0
+BenchmarkMacaron_GithubAll                  |    2000    |  1161270    |  204194    |  2000
+BenchmarkMartini_GithubAll                  |     200    |  9991713    |  226549    |  2325
+BenchmarkPat_GithubAll                      |     200    |  5590793    | 1499568    | 27435
+BenchmarkPossum_GithubAll                   |   10000    |   319768    |   84448    |   609
+BenchmarkR2router_GithubAll                 |   10000    |   305134    |   77328    |   979
+BenchmarkRivet_GithubAll                    |   10000    |   132134    |   16272    |   167
+BenchmarkTango_GithubAll                    |    3000    |   552754    |   63826    |  1618
+BenchmarkTigerTonic_GithubAll               |    1000    |  1439483    |  239104    |  5374
+BenchmarkTraffic_GithubAll                  |     100    | 11383067    | 2659329    | 21848
+BenchmarkVulcan_GithubAll                   |    5000    |   394253    |   19894    |   609
+
+- (1): 在不断的时间内实现总重复，更高意味着更自信的结果
+- (2): 单次重复持续时间（ns / op），越低越好
+- (3): 堆内存（B / op），越低越好
+- (4): 每次重复的平均分配（allocs / op）越低越好
+
+## Gin v1 稳定版
+
+- [x] 零分配路由器。
+- [x] 仍然是最快的http路由器和框架。
+- [x] 完整的单元测试套件
+- [x] 对战测试
+- [x] API冻结，新版本不会破坏您的代码。
+
+## 使用 [jsoniter](https://github.com/json-iterator/go) 构建
+
+Gin使用`encoding / json`作为默认的json包，但您可以通过其他标签的构建更改为[jsoniter]（https://github.com/json-iterator/go）。
+
+```sh
+$ go build -tags=jsoniter .
+```
+
+## API 示例
+
+### GET, POST, PUT, PATCH, DELETE , OPTIONS 使用
+
+```go
+func main() {
+	// Disable Console Color
+	// gin.DisableConsoleColor()
+
+	// Creates a gin router with default middleware:
+	// logger and recovery (crash-free) middleware
+	router := gin.Default()
+
+	router.GET("/someGet", getting)
+	router.POST("/somePost", posting)
+	router.PUT("/somePut", putting)
+	router.DELETE("/someDelete", deleting)
+	router.PATCH("/somePatch", patching)
+	router.HEAD("/someHead", head)
+	router.OPTIONS("/someOptions", options)
+
+	// By default it serves on :8080 unless a
+	// PORT environment variable was defined.
+	router.Run()
+	// router.Run(":3000") for a hard coded port
+}
+```
+
+### 路由参数
+
+```go
+func main() {
+	router := gin.Default()
+
+	// This handler will match /user/john but will not match /user/ or /user
+	router.GET("/user/:name", func(c *gin.Context) {
+		name := c.Param("name")
+		c.String(http.StatusOK, "Hello %s", name)
+	})
+
+	// However, this one will match /user/john/ and also /user/john/send
+	// If no other routers match /user/john, it will redirect to /user/john/
+	router.GET("/user/:name/*action", func(c *gin.Context) {
+		name := c.Param("name")
+		action := c.Param("action")
+		message := name + " is " + action
+		c.String(http.StatusOK, message)
+	})
+
+	router.Run(":8080")
+}
+```
+
+### 查询字符串参数
+
+```go
+func main() {
+	router := gin.Default()
+
+	// Query string parameters are parsed using the existing underlying request object.
+	// The request responds to a url matching:  /welcome?firstname=Jane&lastname=Doe
+	router.GET("/welcome", func(c *gin.Context) {
+		firstname := c.DefaultQuery("firstname", "Guest")
+		lastname := c.Query("lastname") // shortcut for c.Request.URL.Query().Get("lastname")
+
+		c.String(http.StatusOK, "Hello %s %s", firstname, lastname)
+	})
+	router.Run(":8080")
+}
+```
+
+### Multipart Urlencoded 表单
+
+```go
+func main() {
+	router := gin.Default()
+
+	router.POST("/form_post", func(c *gin.Context) {
+		message := c.PostForm("message")
+		nick := c.DefaultPostForm("nick", "anonymous")
+
+		c.JSON(200, gin.H{
+			"status":  "posted",
+			"message": message,
+			"nick":    nick,
+		})
+	})
+	router.Run(":8080")
+}
+```
+
+### 另一个实列 query + post form
+
+```
+POST /post?id=1234&page=1 HTTP/1.1
+Content-Type: application/x-www-form-urlencoded
+
+name=manu&message=this_is_great
+```
+
+```go
+func main() {
+	router := gin.Default()
+
+	router.POST("/post", func(c *gin.Context) {
+
+		id := c.Query("id")
+		page := c.DefaultQuery("page", "0")
+		name := c.PostForm("name")
+		message := c.PostForm("message")
+
+		fmt.Printf("id: %s; page: %s; name: %s; message: %s", id, page, name, message)
+	})
+	router.Run(":8080")
+}
+```
+
+```
+id: 1234; page: 1; name: manu; message: this_is_great
+```
+
+### 映射参数 表单参数
+
+```
+POST /post?ids[a]=1234&ids[b]=hello HTTP/1.1
+Content-Type: application/x-www-form-urlencoded
+
+names[first]=thinkerou&names[second]=tianou
+```
+
+```go
+func main() {
+	router := gin.Default()
+
+	router.POST("/post", func(c *gin.Context) {
+
+		ids := c.QueryMap("ids")
+		names := c.PostFormMap("names")
+
+		fmt.Printf("ids: %v; names: %v", ids, names)
+	})
+	router.Run(":8080")
+}
+```
+
+```
+ids: map[b:hello a:1234], names: map[second:tianou first:thinkerou]
+```
+
+### 上传文件
+
+#### 单个文件上传
+
+参考问题[＃774]（https://github.com/gin-gonic/gin/issues/774）和详细[示例代码]（examples / upload-file / single）。
+
+```go
+func main() {
+	router := gin.Default()
+	// Set a lower memory limit for multipart forms (default is 32 MiB)
+	// router.MaxMultipartMemory = 8 << 20  // 8 MiB
+	router.POST("/upload", func(c *gin.Context) {
+		// single file
+		file, _ := c.FormFile("file")
+		log.Println(file.Filename)
+
+		// Upload the file to specific dst.
+		// c.SaveUploadedFile(file, dst)
+
+		c.String(http.StatusOK, fmt.Sprintf("'%s' uploaded!", file.Filename))
+	})
+	router.Run(":8080")
+}
+```
+
+如何 `curl`:
+
+```bash
+curl -X POST http://localhost:8080/upload \
+  -F "file=@/Users/appleboy/test.zip" \
+  -H "Content-Type: multipart/form-data"
+```
+
+#### 多文件上传
+
+查看详细信息[示例代码]（examples / upload-file / multiple）。
+
+```go
+func main() {
+	router := gin.Default()
+	// Set a lower memory limit for multipart forms (default is 32 MiB)
+	// router.MaxMultipartMemory = 8 << 20  // 8 MiB
+	router.POST("/upload", func(c *gin.Context) {
+		// Multipart form
+		form, _ := c.MultipartForm()
+		files := form.File["upload[]"]
+
+		for _, file := range files {
+			log.Println(file.Filename)
+
+			// Upload the file to specific dst.
+			// c.SaveUploadedFile(file, dst)
+		}
+		c.String(http.StatusOK, fmt.Sprintf("%d files uploaded!", len(files)))
+	})
+	router.Run(":8080")
+}
+```
+
+如何 `curl`:
+
+```bash
+curl -X POST http://localhost:8080/upload \
+  -F "upload[]=@/Users/appleboy/test1.zip" \
+  -F "upload[]=@/Users/appleboy/test2.zip" \
+  -H "Content-Type: multipart/form-data"
+```
+
+### 路由组
+
+```go
+func main() {
+	router := gin.Default()
+
+	// Simple group: v1
+	v1 := router.Group("/v1")
+	{
+		v1.POST("/login", loginEndpoint)
+		v1.POST("/submit", submitEndpoint)
+		v1.POST("/read", readEndpoint)
+	}
+
+	// Simple group: v2
+	v2 := router.Group("/v2")
+	{
+		v2.POST("/login", loginEndpoint)
+		v2.POST("/submit", submitEndpoint)
+		v2.POST("/read", readEndpoint)
+	}
+
+	router.Run(":8080")
+}
+```
+
+### 默认初始化 Gin
+
+用
+
+```go
+r := gin.New()
+```
+
+代替
+
+```go
+// Default With the Logger and Recovery middleware already attached
+r := gin.Default()
+```
+
+
+### 中间件使用
+```go
+func main() {
+	// Creates a router without any middleware by default
+	r := gin.New()
+
+	// Global middleware
+	// Logger middleware will write the logs to gin.DefaultWriter even if you set with GIN_MODE=release.
+	// By default gin.DefaultWriter = os.Stdout
+	r.Use(gin.Logger())
+
+	// Recovery middleware recovers from any panics and writes a 500 if there was one.
+	r.Use(gin.Recovery())
+
+	// Per route middleware, you can add as many as you desire.
+	r.GET("/benchmark", MyBenchLogger(), benchEndpoint)
+
+	// Authorization group
+	// authorized := r.Group("/", AuthRequired())
+	// exactly the same as:
+	authorized := r.Group("/")
+	// per group middleware! in this case we use the custom created
+	// AuthRequired() middleware just in the "authorized" group.
+	authorized.Use(AuthRequired())
+	{
+		authorized.POST("/login", loginEndpoint)
+		authorized.POST("/submit", submitEndpoint)
+		authorized.POST("/read", readEndpoint)
+
+		// nested group
+		testing := authorized.Group("testing")
+		testing.GET("/analytics", analyticsEndpoint)
+	}
+
+	// Listen and serve on 0.0.0.0:8080
+	r.Run(":8080")
+}
+```
+
+### 如何记录日志
+```go
+func main() {
+    // Disable Console Color, you don't need console color when writing the logs to file.
+    gin.DisableConsoleColor()
+
+    // Logging to a file.
+    f, _ := os.Create("gin.log")
+    gin.DefaultWriter = io.MultiWriter(f)
+
+    // Use the following code if you need to write the logs to file and console at the same time.
+    // gin.DefaultWriter = io.MultiWriter(f, os.Stdout)
+
+    router := gin.Default()
+    router.GET("/ping", func(c *gin.Context) {
+        c.String(200, "pong")
+    })
+
+    router.Run(":8080")
+}
+```
+
+### 模型绑定和验证
+
+要将请求主体绑定到类型中，请使用模型绑定。我们目前支持JSON，XML和标准表单值的绑定（foo = bar＆boo = baz）。
+
+Gin使用[** go-playground / validator.v8 **]（https://github.com/go-playground/validator）进行验证。检查有关标签用法的完整文档[此处]（http://godoc.org/gopkg.in/go-playground/validator.v8#hdr-Baked_In_Validators_and_Tags）。
+
+请注意，您需要在要绑定的所有字段上设置相应的绑定标记。例如，从JSON绑定时，设置`json：“fieldname”`。
+
+此外，Gin提供了两组绑定方法：
+- **类型** - 必须绑定
+   - **方法** - `Bind`，`BindJSON`，`BindXML`，`BindQuery`
+   - **行为** - 这些方法在引擎盖下使用`MustBindWith`。如果存在绑定错误，则使用`c.AbortWithError（400，err）.SetType（ErrorTypeBind）`中止请求。这将响应状态代码设置为400，并将`Content-Type`标头设置为`text / plain;字符集= UTF-8`。请注意，如果您在此之后尝试设置响应代码，则会发出警告“[GIN-debug] [警告]标题已经写入。想用422`覆盖状态代码400。如果您希望更好地控制行为，请考虑使用`ShouldBind`等效方法。
+- **类型** - 应该绑定
+   - **方法** - `ShouldBind`，`ShouldBindJSON`，`ShouldBindXML`，`ShouldBindQuery`
+   - **行为** - 这些方法在引擎盖下使用`ShouldBindWith`。如果存在绑定错误，则返回错误，开发人员有责任正确处理请求和错误。
+
+使用Bind方法时，Gin会尝试根据Content-Type标头推断出绑定器。如果你确定你绑定了什么，你可以使用 `MustBindWith` 或 `ShouldBindWith`。
+
+您还可以指定需要特定字段。如果字段用 `binding：“必需”` 来装饰，并且在绑定时具有空值，则会返回错误。
+
+```go
+// Binding from JSON
+type Login struct {
+	User     string `form:"user" json:"user" xml:"user"  binding:"required"`
+	Password string `form:"password" json:"password" xml:"password" binding:"required"`
+}
+
+func main() {
+	router := gin.Default()
+
+	// Example for binding JSON ({"user": "manu", "password": "123"})
+	router.POST("/loginJSON", func(c *gin.Context) {
+		var json Login
+		if err := c.ShouldBindJSON(&json); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		
+		if json.User != "manu" || json.Password != "123" {
+			c.JSON(http.StatusUnauthorized, gin.H{"status": "unauthorized"})
+			return
+		} 
+		
+		c.JSON(http.StatusOK, gin.H{"status": "you are logged in"})
+	})
+
+	// Example for binding XML (
+	//	<?xml version="1.0" encoding="UTF-8"?>
+	//	<root>
+	//		<user>user</user>
+	//		<password>123</user>
+	//	</root>)
+	router.POST("/loginXML", func(c *gin.Context) {
+		var xml Login
+		if err := c.ShouldBindXML(&xml); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		
+		if xml.User != "manu" || xml.Password != "123" {
+			c.JSON(http.StatusUnauthorized, gin.H{"status": "unauthorized"})
+			return
+		} 
+		
+		c.JSON(http.StatusOK, gin.H{"status": "you are logged in"})
+	})
+
+	// Example for binding a HTML form (user=manu&password=123)
+	router.POST("/loginForm", func(c *gin.Context) {
+		var form Login
+		// This will infer what binder to use depending on the content-type header.
+		if err := c.ShouldBind(&form); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		
+		if form.User != "manu" || form.Password != "123" {
+			c.JSON(http.StatusUnauthorized, gin.H{"status": "unauthorized"})
+			return
+		} 
+		
+		c.JSON(http.StatusOK, gin.H{"status": "you are logged in"})
+	})
+
+	// Listen and serve on 0.0.0.0:8080
+	router.Run(":8080")
+}
+```
+
+**简单请求**
+```shell
+$ curl -v -X POST \
+  http://localhost:8080/loginJSON \
+  -H 'content-type: application/json' \
+  -d '{ "user": "manu" }'
+> POST /loginJSON HTTP/1.1
+> Host: localhost:8080
+> User-Agent: curl/7.51.0
+> Accept: */*
+> content-type: application/json
+> Content-Length: 18
+>
+* upload completely sent off: 18 out of 18 bytes
+< HTTP/1.1 400 Bad Request
+< Content-Type: application/json; charset=utf-8
+< Date: Fri, 04 Aug 2017 03:51:31 GMT
+< Content-Length: 100
+<
+{"error":"Key: 'Login.Password' Error:Field validation for 'Password' failed on the 'required' tag"}
+```
+
+**跳过验证**
+
+使用上面 的`curl` 命令运行上面的例子时，它返回错误。 因为这个例子使用 `binding：'需要``````。 如果使用 `binding：“ - ``````，那么在再次运行上面的例子时它不会返回错误。
+
+### 自定义验证器
+
+也可以注册自定义验证器。 请参阅[示例代码]（examples / custom-validation / server.go）。
+
+[embedmd]：＃（examples / custom-validation / server.go go）
+```go
+package main
+
+import (
+	"net/http"
+	"reflect"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/gin-gonic/gin/binding"
+	"gopkg.in/go-playground/validator.v8"
+)
+
+// Booking contains binded and validated data.
+type Booking struct {
+	CheckIn  time.Time `form:"check_in" binding:"required,bookabledate" time_format:"2006-01-02"`
+	CheckOut time.Time `form:"check_out" binding:"required,gtfield=CheckIn" time_format:"2006-01-02"`
+}
+
+func bookableDate(
+	v *validator.Validate, topStruct reflect.Value, currentStructOrField reflect.Value,
+	field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string,
+) bool {
+	if date, ok := field.Interface().(time.Time); ok {
+		today := time.Now()
+		if today.Year() > date.Year() || today.YearDay() > date.YearDay() {
+			return false
+		}
+	}
+	return true
+}
+
+func main() {
+	route := gin.Default()
+
+	if v, ok := binding.Validator.Engine().(*validator.Validate); ok {
+		v.RegisterValidation("bookabledate", bookableDate)
+	}
+
+	route.GET("/bookable", getBookable)
+	route.Run(":8085")
+}
+
+func getBookable(c *gin.Context) {
+	var b Booking
+	if err := c.ShouldBindWith(&b, binding.Query); err == nil {
+		c.JSON(http.StatusOK, gin.H{"message": "Booking dates are valid!"})
+	} else {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+	}
+}
+```
+
+```console
+$ curl "localhost:8085/bookable?check_in=2018-04-16&check_out=2018-04-17"
+{"message":"Booking dates are valid!"}
+
+$ curl "localhost:8085/bookable?check_in=2018-03-08&check_out=2018-03-09"
+{"error":"Key: 'Booking.CheckIn' Error:Field validation for 'CheckIn' failed on the 'bookabledate' tag"}
+```
+
+[结构级验证]（https://github.com/go-playground/validator/releases/tag/v8.7）也可以这种方式注册。
+请参阅[struct-lvl-validation示例]（examples / struct-lvl-validations）以了解更多信息。
+
+### 只绑定查询字符串
+
+`ShouldBindQuery` 函数只绑定查询参数而不是后期数据。 请参阅[详细信息]（https://github.com/gin-gonic/gin/issues/742#issuecomment-315953017）。
+
+```go
+package main
+
+import (
+	"log"
+
+	"github.com/gin-gonic/gin"
+)
+
+type Person struct {
+	Name    string `form:"name"`
+	Address string `form:"address"`
+}
+
+func main() {
+	route := gin.Default()
+	route.Any("/testing", startPage)
+	route.Run(":8085")
+}
+
+func startPage(c *gin.Context) {
+	var person Person
+	if c.ShouldBindQuery(&person) == nil {
+		log.Println("====== Only Bind By Query String ======")
+		log.Println(person.Name)
+		log.Println(person.Address)
+	}
+	c.String(200, "Success")
+}
+
+```
+
+### 绑定查询字符串或发布数据
+
+请参阅[详细信息]（https://github.com/gin-gonic/gin/issues/742#issuecomment-264681292）。
+
+```go
+package main
+
+import (
+	"log"
+	"time"
+
+	"github.com/gin-gonic/gin"
+)
+
+type Person struct {
+	Name     string    `form:"name"`
+	Address  string    `form:"address"`
+	Birthday time.Time `form:"birthday" time_format:"2006-01-02" time_utc:"1"`
+}
+
+func main() {
+	route := gin.Default()
+	route.GET("/testing", startPage)
+	route.Run(":8085")
+}
+
+func startPage(c *gin.Context) {
+	var person Person
+	// If `GET`, only `Form` binding engine (`query`) used.
+	// If `POST`, first checks the `content-type` for `JSON` or `XML`, then uses `Form` (`form-data`).
+	// See more at https://github.com/gin-gonic/gin/blob/master/binding/binding.go#L48
+	if c.ShouldBind(&person) == nil {
+		log.Println(person.Name)
+		log.Println(person.Address)
+		log.Println(person.Birthday)
+	}
+
+	c.String(200, "Success")
+}
+```
+
+测试:
+```sh
+$ curl -X GET "localhost:8085/testing?name=appleboy&address=xyz&birthday=1992-03-15"
+```
+
+### 绑定 HTML 复选框
+
+参见[详细信息]（https://github.com/gin-gonic/gin/issues/129#issuecomment-124260092）
+
+main.go
+
+```go
+...
+
+type myForm struct {
+    Colors []string `form:"colors[]"`
+}
+
+...
+
+func formHandler(c *gin.Context) {
+    var fakeForm myForm
+    c.ShouldBind(&fakeForm)
+    c.JSON(200, gin.H{"color": fakeForm.Colors})
+}
+
+...
+
+```
+
+form.html
+
+```html
+<form action="/" method="POST">
+    <p>Check some colors</p>
+    <label for="red">Red</label>
+    <input type="checkbox" name="colors[]" value="red" id="red" />
+    <label for="green">Green</label>
+    <input type="checkbox" name="colors[]" value="green" id="green" />
+    <label for="blue">Blue</label>
+    <input type="checkbox" name="colors[]" value="blue" id="blue" />
+    <input type="submit" />
+</form>
+```
+
+result:
+
+```
+{"color":["red","green","blue"]}
+```
+
+### Multipart Urlencoded 绑定
+
+```go
+package main
+
+import (
+	"github.com/gin-gonic/gin"
+)
+
+type LoginForm struct {
+	User     string `form:"user" binding:"required"`
+	Password string `form:"password" binding:"required"`
+}
+
+func main() {
+	router := gin.Default()
+	router.POST("/login", func(c *gin.Context) {
+		// you can bind multipart form with explicit binding declaration:
+		// c.ShouldBindWith(&form, binding.Form)
+		// or you can simply use autobinding with ShouldBind method:
+		var form LoginForm
+		// in this case proper binding will be automatically selected
+		if c.ShouldBind(&form) == nil {
+			if form.User == "user" && form.Password == "password" {
+				c.JSON(200, gin.H{"status": "you are logged in"})
+			} else {
+				c.JSON(401, gin.H{"status": "unauthorized"})
+			}
+		}
+	})
+	router.Run(":8080")
+}
+```
+
+Test it with:
+```sh
+$ curl -v --form user=user --form password=password http://localhost:8080/login
+```
+
+### XML JSON YAML ProtoBuf 渲染
+
+```go
+func main() {
+	r := gin.Default()
+
+	// gin.H is a shortcut for map[string]interface{}
+	r.GET("/someJSON", func(c *gin.Context) {
+		c.JSON(http.StatusOK, gin.H{"message": "hey", "status": http.StatusOK})
+	})
+
+	r.GET("/moreJSON", func(c *gin.Context) {
+		// You also can use a struct
+		var msg struct {
+			Name    string `json:"user"`
+			Message string
+			Number  int
+		}
+		msg.Name = "Lena"
+		msg.Message = "hey"
+		msg.Number = 123
+		// Note that msg.Name becomes "user" in the JSON
+		// Will output  :   {"user": "Lena", "Message": "hey", "Number": 123}
+		c.JSON(http.StatusOK, msg)
+	})
+
+	r.GET("/someXML", func(c *gin.Context) {
+		c.XML(http.StatusOK, gin.H{"message": "hey", "status": http.StatusOK})
+	})
+
+	r.GET("/someYAML", func(c *gin.Context) {
+		c.YAML(http.StatusOK, gin.H{"message": "hey", "status": http.StatusOK})
+	})
+
+	r.GET("/someProtoBuf", func(c *gin.Context) {
+		reps := []int64{int64(1), int64(2)}
+		label := "test"
+		// The specific definition of protobuf is written in the testdata/protoexample file.
+		data := &protoexample.Test{
+			Label: &label,
+			Reps:  reps,
+		}
+		// Note that data becomes binary data in the response
+		// Will output protoexample.Test protobuf serialized data
+		c.ProtoBuf(http.StatusOK, data)
+	})
+
+	// Listen and serve on 0.0.0.0:8080
+	r.Run(":8080")
+}
+```
+
+#### SecureJSON
+
+使用 SecureJSON 来防止 json 劫持。 如果给定的结构是数组值，则默认预 置`“while（1），”` 到响应体。
+
+```go
+func main() {
+	r := gin.Default()
+
+	// You can also use your own secure json prefix
+	// r.SecureJsonPrefix(")]}',\n")
+
+	r.GET("/someJSON", func(c *gin.Context) {
+		names := []string{"lena", "austin", "foo"}
+
+		// Will output  :   while(1);["lena","austin","foo"]
+		c.SecureJSON(http.StatusOK, names)
+	})
+
+	// Listen and serve on 0.0.0.0:8080
+	r.Run(":8080")
+}
+```
+#### JSONP
+
+使用 JSONP 从不同域中的服务器请求数据。 如果查询参数回调存在，则将回调添加到响应正文。
+
+```go
+func main() {
+	r := gin.Default()
+
+	r.GET("/JSONP?callback=x", func(c *gin.Context) {
+		data := map[string]interface{}{
+			"foo": "bar",
+		}
+		
+		//callback is x
+		// Will output  :   x({\"foo\":\"bar\"})
+		c.JSONP(http.StatusOK, data)
+	})
+
+	// Listen and serve on 0.0.0.0:8080
+	r.Run(":8080")
+}
+```
+
+#### AsciiJSON
+
+使用 Ascii JSON 生成具有转义的非 ASCII 字符的仅 ASCII JSON。
+
+```go
+func main() {
+	r := gin.Default()
+
+	r.GET("/someJSON", func(c *gin.Context) {
+		data := map[string]interface{}{
+			"lang": "GO语言",
+			"tag":  "<br>",
+		}
+
+		// will output : {"lang":"GO\u8bed\u8a00","tag":"\u003cbr\u003e"}
+		c.AsciiJSON(http.StatusOK, data)
+	})
+
+	// Listen and serve on 0.0.0.0:8080
+	r.Run(":8080")
+}
+```
+
+#### PureJSON
+
+通常，JSON 用其 unicod e实体替换特殊 HTML 字符，例如 `<` 变为 `\ u003c`。 如果要按字面意思对这些字符进行编码，则可以使用 PureJSON。
+Go 1.6 及更低版本无法使用此功能。
+
+```go
+func main() {
+	r := gin.Default()
+	
+	// Serves unicode entities
+	r.GET("/json", func(c *gin.Context) {
+		c.JSON(200, gin.H{
+			"html": "<b>Hello, world!</b>",
+		})
+	})
+	
+	// Serves literal characters
+	r.GET("/purejson", func(c *gin.Context) {
+		c.PureJSON(200, gin.H{
+			"html": "<b>Hello, world!</b>",
+		})
+	})
+	
+	// listen and serve on 0.0.0.0:8080
+	r.Run(":8080)
+}
+```
+
+### 静态文件服务
+
+```go
+func main() {
+	router := gin.Default()
+	router.Static("/assets", "./assets")
+	router.StaticFS("/more_static", http.Dir("my_file_system"))
+	router.StaticFile("/favicon.ico", "./resources/favicon.ico")
+
+	// Listen and serve on 0.0.0.0:8080
+	router.Run(":8080")
+}
+```
+
+### 从 reader 读取数据
+
+```go
+func main() {
+	router := gin.Default()
+	router.GET("/someDataFromReader", func(c *gin.Context) {
+		response, err := http.Get("https://raw.githubusercontent.com/gin-gonic/logo/master/color.png")
+		if err != nil || response.StatusCode != http.StatusOK {
+			c.Status(http.StatusServiceUnavailable)
+			return
+		}
+
+		reader := response.Body
+		contentLength := response.ContentLength
+		contentType := response.Header.Get("Content-Type")
+
+		extraHeaders := map[string]string{
+			"Content-Disposition": `attachment; filename="gopher.png"`,
+		}
+
+		c.DataFromReader(http.StatusOK, contentLength, contentType, reader, extraHeaders)
+	})
+	router.Run(":8080")
+}
+```
+
+### HTML 渲染
+
+使用LoadHTMLGlob（）或LoadHTMLFiles（）
+
+```go
+func main() {
+	router := gin.Default()
+	router.LoadHTMLGlob("templates/*")
+	//router.LoadHTMLFiles("templates/template1.html", "templates/template2.html")
+	router.GET("/index", func(c *gin.Context) {
+		c.HTML(http.StatusOK, "index.tmpl", gin.H{
+			"title": "Main website",
+		})
+	})
+	router.Run(":8080")
+}
+```
+
+templates/index.tmpl
+
+```html
+<html>
+	<h1>
+		{{ .title }}
+	</h1>
+</html>
+```
+
+在不同目录中使用具有相同名称的模板
+
+```go
+func main() {
+	router := gin.Default()
+	router.LoadHTMLGlob("templates/**/*")
+	router.GET("/posts/index", func(c *gin.Context) {
+		c.HTML(http.StatusOK, "posts/index.tmpl", gin.H{
+			"title": "Posts",
+		})
+	})
+	router.GET("/users/index", func(c *gin.Context) {
+		c.HTML(http.StatusOK, "users/index.tmpl", gin.H{
+			"title": "Users",
+		})
+	})
+	router.Run(":8080")
+}
+```
+
+templates/posts/index.tmpl
+
+```html
+{{ define "posts/index.tmpl" }}
+<html><h1>
+	{{ .title }}
+</h1>
+<p>Using posts/index.tmpl</p>
+</html>
+{{ end }}
+```
+
+templates/users/index.tmpl
+
+```html
+{{ define "users/index.tmpl" }}
+<html><h1>
+	{{ .title }}
+</h1>
+<p>Using users/index.tmpl</p>
+</html>
+{{ end }}
+```
+
+#### 自定义模板渲染器
+
+您还可以使用自己的 html 模板渲染
+
+```go
+import "html/template"
+
+func main() {
+	router := gin.Default()
+	html := template.Must(template.ParseFiles("file1", "file2"))
+	router.SetHTMLTemplate(html)
+	router.Run(":8080")
+}
+```
+
+#### 自定义分隔符
+
+您可以使用自定义分隔
+
+```go
+	r := gin.Default()
+	r.Delims("{[{", "}]}")
+	r.LoadHTMLGlob("/path/to/templates"))
+```
+
+#### 自定义模板功能
+
+查看详细信息[示例代码]（示例/模板）。
+
+main.go
+
+```go
+import (
+    "fmt"
+    "html/template"
+    "net/http"
+    "time"
+
+    "github.com/gin-gonic/gin"
+)
+
+func formatAsDate(t time.Time) string {
+    year, month, day := t.Date()
+    return fmt.Sprintf("%d%02d/%02d", year, month, day)
+}
+
+func main() {
+    router := gin.Default()
+    router.Delims("{[{", "}]}")
+    router.SetFuncMap(template.FuncMap{
+        "formatAsDate": formatAsDate,
+    })
+    router.LoadHTMLFiles("./testdata/template/raw.tmpl")
+
+    router.GET("/raw", func(c *gin.Context) {
+        c.HTML(http.StatusOK, "raw.tmpl", map[string]interface{}{
+            "now": time.Date(2017, 07, 01, 0, 0, 0, 0, time.UTC),
+        })
+    })
+
+    router.Run(":8080")
+}
+
+```
+
+raw.tmpl
+
+```html
+日期: {[{.now | formatAsDate}]}
+```
+
+结果:
+```
+Date: 2017/07/01
+```
+
+### 多模板
+
+Gin 允许默认只使用一个 html 模板。 检查[多模板渲染]（https://github.com/gin-contrib/multitemplate）以使用 go 1.6 `block template` 等功能。
+
+### 重定向
+
+Issuing a HTTP redirect is easy. Both internal and external locations are supported.
+
+```go
+r.GET("/test", func(c *gin.Context) {
+	c.Redirect(http.StatusMovedPermanently, "http://www.google.com/")
+})
+```
+
+
+发出路由器重定向，使用如下的“HandleContext”。
+
+``` go
+r.GET("/test", func(c *gin.Context) {
+    c.Request.URL.Path = "/test2"
+    r.HandleContext(c)
+})
+r.GET("/test2", func(c *gin.Context) {
+    c.JSON(200, gin.H{"hello": "world"})
+})
+```
+
+
+###  自定义中间件
+
+```go
+func Logger() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		t := time.Now()
+
+		// Set example variable
+		c.Set("example", "12345")
+
+		// before request
+
+		c.Next()
+
+		// after request
+		latency := time.Since(t)
+		log.Print(latency)
+
+		// access the status we are sending
+		status := c.Writer.Status()
+		log.Println(status)
+	}
+}
+
+func main() {
+	r := gin.New()
+	r.Use(Logger())
+
+	r.GET("/test", func(c *gin.Context) {
+		example := c.MustGet("example").(string)
+
+		// it would print: "12345"
+		log.Println(example)
+	})
+
+	// Listen and serve on 0.0.0.0:8080
+	r.Run(":8080")
+}
+```
+
+### BasicAuth() 中间件
+
+```go
+// simulate some private data
+var secrets = gin.H{
+	"foo":    gin.H{"email": "foo@bar.com", "phone": "123433"},
+	"austin": gin.H{"email": "austin@example.com", "phone": "666"},
+	"lena":   gin.H{"email": "lena@guapa.com", "phone": "523443"},
+}
+
+func main() {
+	r := gin.Default()
+
+	// Group using gin.BasicAuth() middleware
+	// gin.Accounts is a shortcut for map[string]string
+	authorized := r.Group("/admin", gin.BasicAuth(gin.Accounts{
+		"foo":    "bar",
+		"austin": "1234",
+		"lena":   "hello2",
+		"manu":   "4321",
+	}))
+
+	// /admin/secrets endpoint
+	// hit "localhost:8080/admin/secrets
+	authorized.GET("/secrets", func(c *gin.Context) {
+		// get user, it was set by the BasicAuth middleware
+		user := c.MustGet(gin.AuthUserKey).(string)
+		if secret, ok := secrets[user]; ok {
+			c.JSON(http.StatusOK, gin.H{"user": user, "secret": secret})
+		} else {
+			c.JSON(http.StatusOK, gin.H{"user": user, "secret": "NO SECRET :("})
+		}
+	})
+
+	// Listen and serve on 0.0.0.0:8080
+	r.Run(":8080")
+}
+```
+
+###  Goroutines
+
+当在中间件或处理程序中启动新的 Goroutines 时，你不应该**使用其中的原始上下文，你必须使用只读副本。
+
+```go
+func main() {
+	r := gin.Default()
+
+	r.GET("/long_async", func(c *gin.Context) {
+		// create copy to be used inside the goroutine
+		cCp := c.Copy()
+		go func() {
+			// simulate a long task with time.Sleep(). 5 seconds
+			time.Sleep(5 * time.Second)
+
+			// note that you are using the copied context "cCp", IMPORTANT
+			log.Println("Done! in path " + cCp.Request.URL.Path)
+		}()
+	})
+
+	r.GET("/long_sync", func(c *gin.Context) {
+		// simulate a long task with time.Sleep(). 5 seconds
+		time.Sleep(5 * time.Second)
+
+		// since we are NOT using a goroutine, we do not have to copy the context
+		log.Println("Done! in path " + c.Request.URL.Path)
+	})
+
+	// Listen and serve on 0.0.0.0:8080
+	r.Run(":8080")
+}
+```
+
+### 自定义 HTTP 配置
+
+直接使用`http.ListenAndServe（）`，如下所示：
+
+```go
+func main() {
+	router := gin.Default()
+	http.ListenAndServe(":8080", router)
+}
+```
+or
+
+```go
+func main() {
+	router := gin.Default()
+
+	s := &http.Server{
+		Addr:           ":8080",
+		Handler:        router,
+		ReadTimeout:    10 * time.Second,
+		WriteTimeout:   10 * time.Second,
+		MaxHeaderBytes: 1 << 20,
+	}
+	s.ListenAndServe()
+}
+```
+
+###  Let's Encrypt 支持
+
+单行 LetsEncrypt HTTPS 服务器的示例。
+
+[embedmd]:# (examples/auto-tls/example1/main.go go)
+```go
+package main
+
+import (
+	"log"
+
+	"github.com/gin-gonic/autotls"
+	"github.com/gin-gonic/gin"
+)
+
+func main() {
+	r := gin.Default()
+
+	// Ping handler
+	r.GET("/ping", func(c *gin.Context) {
+		c.String(200, "pong")
+	})
+
+	log.Fatal(autotls.Run(r, "example1.com", "example2.com"))
+}
+```
+
+自定义autocert管理器的示例。
+
+[embedmd]:# (examples/auto-tls/example2/main.go go)
+```go
+package main
+
+import (
+	"log"
+
+	"github.com/gin-gonic/autotls"
+	"github.com/gin-gonic/gin"
+	"golang.org/x/crypto/acme/autocert"
+)
+
+func main() {
+	r := gin.Default()
+
+	// Ping handler
+	r.GET("/ping", func(c *gin.Context) {
+		c.String(200, "pong")
+	})
+
+	m := autocert.Manager{
+		Prompt:     autocert.AcceptTOS,
+		HostPolicy: autocert.HostWhitelist("example1.com", "example2.com"),
+		Cache:      autocert.DirCache("/var/www/.cache"),
+	}
+
+	log.Fatal(autotls.RunWithManager(r, &m))
+}
+```
+
+### 使用 Gin 运行多个服务
+
+请参阅[问题]（https://github.com/gin-gonic/gin/issues/346）并尝试以下示例：
+
+[embedmd]:# (examples/multiple-service/main.go go)
+```go
+package main
+
+import (
+	"log"
+	"net/http"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"golang.org/x/sync/errgroup"
+)
+
+var (
+	g errgroup.Group
+)
+
+func router01() http.Handler {
+	e := gin.New()
+	e.Use(gin.Recovery())
+	e.GET("/", func(c *gin.Context) {
+		c.JSON(
+			http.StatusOK,
+			gin.H{
+				"code":  http.StatusOK,
+				"error": "Welcome server 01",
+			},
+		)
+	})
+
+	return e
+}
+
+func router02() http.Handler {
+	e := gin.New()
+	e.Use(gin.Recovery())
+	e.GET("/", func(c *gin.Context) {
+		c.JSON(
+			http.StatusOK,
+			gin.H{
+				"code":  http.StatusOK,
+				"error": "Welcome server 02",
+			},
+		)
+	})
+
+	return e
+}
+
+func main() {
+	server01 := &http.Server{
+		Addr:         ":8080",
+		Handler:      router01(),
+		ReadTimeout:  5 * time.Second,
+		WriteTimeout: 10 * time.Second,
+	}
+
+	server02 := &http.Server{
+		Addr:         ":8081",
+		Handler:      router02(),
+		ReadTimeout:  5 * time.Second,
+		WriteTimeout: 10 * time.Second,
+	}
+
+	g.Go(func() error {
+		return server01.ListenAndServe()
+	})
+
+	g.Go(func() error {
+		return server02.ListenAndServe()
+	})
+
+	if err := g.Wait(); err != nil {
+		log.Fatal(err)
+	}
+}
+```
+
+### 优雅重启或停止
+
+您想要优雅地重启或停止您的Web服务器吗？
+有一些方法可以做到这一点。
+
+我们可以使用[fvbock / endless]（https://github.com/fvbock/endless）来替换默认的`ListenAndServe`。 有关更多详细信息，请参阅问题[＃296]（https://github.com/gin-gonic/gin/issues/296）。
+
+```go
+router := gin.Default()
+router.GET("/", handler)
+// [...]
+endless.ListenAndServe(":4242", router)
+```
+
+另一种替代方案：
+
+* [manners]（https://github.com/braintree/manners）：礼貌的Go HTTP服务器，可以正常关闭。
+* [graceful]（https://github.com/tylerb/graceful）：Graceful是一个Go包，可以正常关闭http.Handler服务器。
+* [grace]（https://github.com/facebookgo/grace）：Go服务器的平滑重启和零停机时间部署。
+
+如果您使用的是Go 1.8，则可能不需要使用此库！ 考虑使用http.Server的内置[Shutdown（）]（https://golang.org/pkg/net/http/#Server.Shutdown）方法进行正常关机。 请参阅gin的完整[graceful-shutdown]（./ examples / graceful-shutdown）示例。
+
+[embedmd]:# (examples/graceful-shutdown/graceful-shutdown/server.go go)
+```go
+// +build go1.8
+
+package main
+
+import (
+	"context"
+	"log"
+	"net/http"
+	"os"
+	"os/signal"
+	"time"
+
+	"github.com/gin-gonic/gin"
+)
+
+func main() {
+	router := gin.Default()
+	router.GET("/", func(c *gin.Context) {
+		time.Sleep(5 * time.Second)
+		c.String(http.StatusOK, "Welcome Gin Server")
+	})
+
+	srv := &http.Server{
+		Addr:    ":8080",
+		Handler: router,
+	}
+
+	go func() {
+		// service connections
+		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+			log.Fatalf("listen: %s\n", err)
+		}
+	}()
+
+	// Wait for interrupt signal to gracefully shutdown the server with
+	// a timeout of 5 seconds.
+	quit := make(chan os.Signal)
+	signal.Notify(quit, os.Interrupt)
+	<-quit
+	log.Println("Shutdown Server ...")
+
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	if err := srv.Shutdown(ctx); err != nil {
+		log.Fatal("Server Shutdown:", err)
+	}
+	log.Println("Server exiting")
+}
+```
+
+### 使用模板构建单个二进制文件
+
+您可以使用[go-assets] []将服务器构建到包含模板的单个二进制文件中。
+
+[go-assets]：https：//github.com/jessevdk/go-assets
+
+```go
+func main() {
+	r := gin.New()
+
+	t, err := loadTemplate()
+	if err != nil {
+		panic(err)
+	}
+	r.SetHTMLTemplate(t)
+
+	r.GET("/", func(c *gin.Context) {
+		c.HTML(http.StatusOK, "/html/index.tmpl",nil)
+	})
+	r.Run(":8080")
+}
+
+// loadTemplate loads templates embedded by go-assets-builder
+func loadTemplate() (*template.Template, error) {
+	t := template.New("")
+	for name, file := range Assets.Files {
+		if file.IsDir() || !strings.HasSuffix(name, ".tmpl") {
+			continue
+		}
+		h, err := ioutil.ReadAll(file)
+		if err != nil {
+			return nil, err
+		}
+		t, err = t.New(name).Parse(string(h))
+		if err != nil {
+			return nil, err
+		}
+	}
+	return t, nil
+}
+```
+
+请参阅`examples / assets-in-binary`目录中的完整示例。
+
+### Bind form-data request with custom struct
+
+以下示例使用自定义结构：
+
+```go
+type StructA struct {
+    FieldA string `form:"field_a"`
+}
+
+type StructB struct {
+    NestedStruct StructA
+    FieldB string `form:"field_b"`
+}
+
+type StructC struct {
+    NestedStructPointer *StructA
+    FieldC string `form:"field_c"`
+}
+
+type StructD struct {
+    NestedAnonyStruct struct {
+        FieldX string `form:"field_x"`
+    }
+    FieldD string `form:"field_d"`
+}
+
+func GetDataB(c *gin.Context) {
+    var b StructB
+    c.Bind(&b)
+    c.JSON(200, gin.H{
+        "a": b.NestedStruct,
+        "b": b.FieldB,
+    })
+}
+
+func GetDataC(c *gin.Context) {
+    var b StructC
+    c.Bind(&b)
+    c.JSON(200, gin.H{
+        "a": b.NestedStructPointer,
+        "c": b.FieldC,
+    })
+}
+
+func GetDataD(c *gin.Context) {
+    var b StructD
+    c.Bind(&b)
+    c.JSON(200, gin.H{
+        "x": b.NestedAnonyStruct,
+        "d": b.FieldD,
+    })
+}
+
+func main() {
+    r := gin.Default()
+    r.GET("/getb", GetDataB)
+    r.GET("/getc", GetDataC)
+    r.GET("/getd", GetDataD)
+
+    r.Run()
+}
+```
+
+使用命令`curl`命令结果：
+
+```
+$ curl "http://localhost:8080/getb?field_a=hello&field_b=world"
+{"a":{"FieldA":"hello"},"b":"world"}
+$ curl "http://localhost:8080/getc?field_a=hello&field_c=world"
+{"a":{"FieldA":"hello"},"c":"world"}
+$ curl "http://localhost:8080/getd?field_x=hello&field_d=world"
+{"d":"world","x":{"FieldX":"hello"}}
+```
+
+**注意**:不支持以下样式结构：
+
+```go
+type StructX struct {
+    X struct {} `form:"name_x"` // HERE have form
+}
+
+type StructY struct {
+    Y StructX `form:"name_y"` // HERE have form
+}
+
+type StructZ struct {
+    Z *StructZ `form:"name_z"` // HERE have form
+}
+```
+
+总之，只支持现在没有`form`的嵌套自定义结构。
+
+### 尝试将 body 绑定到不同的结构中
+
+绑定请求体的常规方法使用`c.Request.Body`和它们
+不能多次调用。
+
+```go
+type formA struct {
+  Foo string `json:"foo" xml:"foo" binding:"required"`
+}
+
+type formB struct {
+  Bar string `json:"bar" xml:"bar" binding:"required"`
+}
+
+func SomeHandler(c *gin.Context) {
+  objA := formA{}
+  objB := formB{}
+  // This c.ShouldBind consumes c.Request.Body and it cannot be reused.
+  if errA := c.ShouldBind(&objA); errA == nil {
+    c.String(http.StatusOK, `the body should be formA`)
+  // Always an error is occurred by this because c.Request.Body is EOF now.
+  } else if errB := c.ShouldBind(&objB); errB == nil {
+    c.String(http.StatusOK, `the body should be formB`)
+  } else {
+    ...
+  }
+}
+```
+
+为此，您可以使用`c.ShouldBindBodyWith`.
+
+```go
+func SomeHandler(c *gin.Context) {
+  objA := formA{}
+  objB := formB{}
+  // This reads c.Request.Body and stores the result into the context.
+  if errA := c.ShouldBindBodyWith(&objA, binding.JSON); errA == nil {
+    c.String(http.StatusOK, `the body should be formA`)
+  // At this time, it reuses body stored in the context.
+  } else if errB := c.ShouldBindBodyWith(&objB, binding.JSON); errB == nil {
+    c.String(http.StatusOK, `the body should be formB JSON`)
+  // And it can accepts other formats
+  } else if errB2 := c.ShouldBindBodyWith(&objB, binding.XML); errB2 == nil {
+    c.String(http.StatusOK, `the body should be formB XML`)
+  } else {
+    ...
+  }
+}
+```
+
+
+482/5000
+*`c.ShouldBindBodyWith`在绑定之前将body存储到上下文中。 这有
+对性能有轻微影响，所以如果你这样做，你不应该使用这种方法
+足以立刻调用绑定。
+*只有某些格式需要此功能 - “JSON”，“XML”，“MsgPack”，
+`ProtoBuf`。 对于其他格式，`Query`，`Form`，`FormPost`，`FormMultipart`，
+可以被`c.ShouldBind（）`多次调用而不会造成任何损害
+表现（见[＃1341]（https://github.com/gin-gonic/gin/pull/1341））。
+
+### http2 server 推送
+
+
+http.Pusher仅支持** go1.8 + **。 有关详细信息，请参阅[golang blog]（https://blog.golang.org/h2push）。
+
+[embedmd]:# (examples/http-pusher/main.go go)
+```go
+package main
+
+import (
+	"html/template"
+	"log"
+
+	"github.com/gin-gonic/gin"
+)
+
+var html = template.Must(template.New("https").Parse(`
+<html>
+<head>
+  <title>Https Test</title>
+  <script src="/assets/app.js"></script>
+</head>
+<body>
+  <h1 style="color:red;">Welcome, Ginner!</h1>
+</body>
+</html>
+`))
+
+func main() {
+	r := gin.Default()
+	r.Static("/assets", "./assets")
+	r.SetHTMLTemplate(html)
+
+	r.GET("/", func(c *gin.Context) {
+		if pusher := c.Writer.Pusher(); pusher != nil {
+			// use pusher.Push() to do server push
+			if err := pusher.Push("/assets/app.js", nil); err != nil {
+				log.Printf("Failed to push: %v", err)
+			}
+		}
+		c.HTML(200, "https", gin.H{
+			"status": "success",
+		})
+	})
+
+	// Listen and Server in https://127.0.0.1:8080
+	r.RunTLS(":8080", "./testdata/server.pem", "./testdata/server.key")
+}
+```
+
+### 定义路由日志的格式
+
+路由的默认日志是：
+```
+[GIN-debug] POST   /foo                      --> main.main.func1 (3 handlers)
+[GIN-debug] GET    /bar                      --> main.main.func2 (3 handlers)
+[GIN-debug] GET    /status                   --> main.main.func3 (3 handlers)
+```
+
+如果要以给定格式记录此信息（例如JSON，键值或其他内容），则可以使用`gin.DebugPrintRouteFunc`定义此格式。
+在下面的示例中，我们使用标准日志包记录所有路由，但您可以使用其他适合您需求的日志工具。
+```go
+import (
+	"log"
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+)
+
+func main() {
+	r := gin.Default()
+	gin.DebugPrintRouteFunc = func(httpMethod, absolutePath, handlerName string, nuHandlers int) {
+		log.Printf("endpoint %v %v %v %v\n", httpMethod, absolutePath, handlerName, nuHandlers)
+	}
+
+	r.POST("/foo", func(c *gin.Context) {
+		c.JSON(http.StatusOK, "foo")
+	})
+
+	r.GET("/bar", func(c *gin.Context) {
+		c.JSON(http.StatusOK, "bar")
+	})
+
+	r.GET("/status", func(c *gin.Context) {
+		c.JSON(http.StatusOK, "ok")
+	})
+
+	// Listen and Server in http://0.0.0.0:8080
+	r.Run()
+}
+```
+
+
+## 测试
+
+`net / http / httptest`包是HTTP测试的首选方式。
+
+```go
+package main
+
+func setupRouter() *gin.Engine {
+	r := gin.Default()
+	r.GET("/ping", func(c *gin.Context) {
+		c.String(200, "pong")
+	})
+	return r
+}
+
+func main() {
+	r := setupRouter()
+	r.Run(":8080")
+}
+```
+
+测试上面的代码示例：
+
+```go
+package main
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestPingRoute(t *testing.T) {
+	router := setupRouter()
+
+	w := httptest.NewRecorder()
+	req, _ := http.NewRequest("GET", "/ping", nil)
+	router.ServeHTTP(w, req)
+
+	assert.Equal(t, 200, w.Code)
+	assert.Equal(t, "pong", w.Body.String())
+}
+```
+
+## 用户
+
+
+使用[Gin]（https://github.com/gin-gonic/gin）Web框架的令人敬畏的项目列表。
+
+* [drone]（https://github.com/drone/drone）：drone，用Go编写。
+* [gorush]（https://github.com/appleboy/gorush）：用Go编写的推送通知服务器。
+* [fnproject]（https://github.com/fnproject/fn）：容器本机，云无关的无服务器平台。

From 1f576fb27c3f3ec00baa0d2868e41830e37d0b54 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=B0=B9=E5=AE=9D=E5=BC=BA?= <wmdandme@gmail.com>
Date: Fri, 23 Nov 2018 09:46:41 +0800
Subject: [PATCH 105/105] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E8=BF=9E=E6=8E=A5?=
 =?UTF-8?q?=E9=94=99=E8=AF=AF=EF=BC=8C=E4=BF=AE=E6=AD=A3=E4=B8=80=E4=BA=9B?=
 =?UTF-8?q?=E6=8A=A5=E5=BC=95=E7=94=A8=E9=94=99=E8=AF=AF=20(#1655)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

修复了全角括号导致超链接不能正常访问的错误。
修复了一些URL中的"/"被改成" / "的错误。
修复了一些包引用中"/"被改成" / "的错误。
修复有超链接被翻译成中文的错误。
---
 README_ZH.md | 68 ++++++++++++++++++++++++++--------------------------
 1 file changed, 34 insertions(+), 34 deletions(-)

diff --git a/README_ZH.md b/README_ZH.md
index d411f9eb..c689ba28 100644
--- a/README_ZH.md
+++ b/README_ZH.md
@@ -79,7 +79,7 @@ $ go get -u github.com/gin-gonic/gin
 import "github.com/gin-gonic/gin"
 ```
 
-3. （可选）如果使用诸如`http.StatusOK`之类的常量，则需要引入 `net / http` 包。
+3. （可选）如果使用诸如`http.StatusOK`之类的常量，则需要引入 `net/http` 包。
 
 ```go
 import "net/http"
@@ -200,7 +200,7 @@ BenchmarkVulcan_GithubAll                   |    5000    |   394253    |   19894
 
 ## 使用 [jsoniter](https://github.com/json-iterator/go) 构建
 
-Gin使用`encoding / json`作为默认的json包，但您可以通过其他标签的构建更改为[jsoniter]（https://github.com/json-iterator/go）。
+Gin使用`encoding/json`作为默认的json包，但您可以通过其他标签的构建更改为[jsoniter](https://github.com/json-iterator/go)。
 
 ```sh
 $ go build -tags=jsoniter .
@@ -359,7 +359,7 @@ ids: map[b:hello a:1234], names: map[second:tianou first:thinkerou]
 
 #### 单个文件上传
 
-参考问题[＃774]（https://github.com/gin-gonic/gin/issues/774）和详细[示例代码]（examples / upload-file / single）。
+参考问题[＃774](https://github.com/gin-gonic/gin/issues/774)和详细[示例代码](examples/upload-file/single)。
 
 ```go
 func main() {
@@ -390,7 +390,7 @@ curl -X POST http://localhost:8080/upload \
 
 #### 多文件上传
 
-查看详细信息[示例代码]（examples / upload-file / multiple）。
+查看详细信息[示例代码](examples/upload-file/multiple)。
 
 ```go
 func main() {
@@ -530,14 +530,14 @@ func main() {
 
 要将请求主体绑定到类型中，请使用模型绑定。我们目前支持JSON，XML和标准表单值的绑定（foo = bar＆boo = baz）。
 
-Gin使用[** go-playground / validator.v8 **]（https://github.com/go-playground/validator）进行验证。检查有关标签用法的完整文档[此处]（http://godoc.org/gopkg.in/go-playground/validator.v8#hdr-Baked_In_Validators_and_Tags）。
+Gin使用[** go-playground/validator.v8 **](https://github.com/go-playground/validator)进行验证。检查有关标签用法的完整文档[此处](http://godoc.org/gopkg.in/go-playground/validator.v8#hdr-Baked_In_Validators_and_Tags)。
 
 请注意，您需要在要绑定的所有字段上设置相应的绑定标记。例如，从JSON绑定时，设置`json：“fieldname”`。
 
 此外，Gin提供了两组绑定方法：
 - **类型** - 必须绑定
    - **方法** - `Bind`，`BindJSON`，`BindXML`，`BindQuery`
-   - **行为** - 这些方法在引擎盖下使用`MustBindWith`。如果存在绑定错误，则使用`c.AbortWithError（400，err）.SetType（ErrorTypeBind）`中止请求。这将响应状态代码设置为400，并将`Content-Type`标头设置为`text / plain;字符集= UTF-8`。请注意，如果您在此之后尝试设置响应代码，则会发出警告“[GIN-debug] [警告]标题已经写入。想用422`覆盖状态代码400。如果您希望更好地控制行为，请考虑使用`ShouldBind`等效方法。
+   - **行为** - 这些方法在引擎盖下使用`MustBindWith`。如果存在绑定错误，则使用`c.AbortWithError(400，err).SetType(ErrorTypeBind)`中止请求。这将响应状态代码设置为400，并将`Content-Type`标头设置为`text/plain;字符集= UTF-8`。请注意，如果您在此之后尝试设置响应代码，则会发出警告“[GIN-debug] [警告]标题已经写入。想用422`覆盖状态代码400。如果您希望更好地控制行为，请考虑使用`ShouldBind`等效方法。
 - **类型** - 应该绑定
    - **方法** - `ShouldBind`，`ShouldBindJSON`，`ShouldBindXML`，`ShouldBindQuery`
    - **行为** - 这些方法在引擎盖下使用`ShouldBindWith`。如果存在绑定错误，则返回错误，开发人员有责任正确处理请求和错误。
@@ -643,9 +643,9 @@ $ curl -v -X POST \
 
 ### 自定义验证器
 
-也可以注册自定义验证器。 请参阅[示例代码]（examples / custom-validation / server.go）。
+也可以注册自定义验证器。 请参阅[示例代码](examples/custom-validation/server.go)。
 
-[embedmd]：＃（examples / custom-validation / server.go go）
+[embedmd]：＃(examples/custom-validation/server.go go)
 ```go
 package main
 
@@ -707,12 +707,12 @@ $ curl "localhost:8085/bookable?check_in=2018-03-08&check_out=2018-03-09"
 {"error":"Key: 'Booking.CheckIn' Error:Field validation for 'CheckIn' failed on the 'bookabledate' tag"}
 ```
 
-[结构级验证]（https://github.com/go-playground/validator/releases/tag/v8.7）也可以这种方式注册。
-请参阅[struct-lvl-validation示例]（examples / struct-lvl-validations）以了解更多信息。
+[结构级验证](https://github.com/go-playground/validator/releases/tag/v8.7)也可以这种方式注册。
+请参阅[struct-lvl-validation示例](examples/struct-lvl-validations)以了解更多信息。
 
 ### 只绑定查询字符串
 
-`ShouldBindQuery` 函数只绑定查询参数而不是后期数据。 请参阅[详细信息]（https://github.com/gin-gonic/gin/issues/742#issuecomment-315953017）。
+`ShouldBindQuery` 函数只绑定查询参数而不是后期数据。 请参阅[详细信息](https://github.com/gin-gonic/gin/issues/742#issuecomment-315953017)。
 
 ```go
 package main
@@ -748,7 +748,7 @@ func startPage(c *gin.Context) {
 
 ### 绑定查询字符串或发布数据
 
-请参阅[详细信息]（https://github.com/gin-gonic/gin/issues/742#issuecomment-264681292）。
+请参阅[详细信息](https://github.com/gin-gonic/gin/issues/742#issuecomment-264681292)。
 
 ```go
 package main
@@ -794,7 +794,7 @@ $ curl -X GET "localhost:8085/testing?name=appleboy&address=xyz&birthday=1992-03
 
 ### 绑定 HTML 复选框
 
-参见[详细信息]（https://github.com/gin-gonic/gin/issues/129#issuecomment-124260092）
+参见[详细信息](https://github.com/gin-gonic/gin/issues/129#issuecomment-124260092)
 
 main.go
 
@@ -931,7 +931,7 @@ func main() {
 
 #### SecureJSON
 
-使用 SecureJSON 来防止 json 劫持。 如果给定的结构是数组值，则默认预 置`“while（1），”` 到响应体。
+使用 SecureJSON 来防止 json 劫持。 如果给定的结构是数组值，则默认预 置`“while(1)，”` 到响应体。
 
 ```go
 func main() {
@@ -1067,7 +1067,7 @@ func main() {
 
 ### HTML 渲染
 
-使用LoadHTMLGlob（）或LoadHTMLFiles（）
+使用LoadHTMLGlob()或LoadHTMLFiles()
 
 ```go
 func main() {
@@ -1159,12 +1159,12 @@ func main() {
 ```go
 	r := gin.Default()
 	r.Delims("{[{", "}]}")
-	r.LoadHTMLGlob("/path/to/templates"))
+	r.LoadHTMLGlob("/path/to/templates")
 ```
 
 #### 自定义模板功能
 
-查看详细信息[示例代码]（示例/模板）。
+查看详细信息[示例代码](examples/template)。
 
 main.go
 
@@ -1215,7 +1215,7 @@ Date: 2017/07/01
 
 ### 多模板
 
-Gin 允许默认只使用一个 html 模板。 检查[多模板渲染]（https://github.com/gin-contrib/multitemplate）以使用 go 1.6 `block template` 等功能。
+Gin 允许默认只使用一个 html 模板。 检查[多模板渲染](https://github.com/gin-contrib/multitemplate)以使用 go 1.6 `block template` 等功能。
 
 ### 重定向
 
@@ -1355,7 +1355,7 @@ func main() {
 
 ### 自定义 HTTP 配置
 
-直接使用`http.ListenAndServe（）`，如下所示：
+直接使用`http.ListenAndServe()`，如下所示：
 
 ```go
 func main() {
@@ -1441,7 +1441,7 @@ func main() {
 
 ### 使用 Gin 运行多个服务
 
-请参阅[问题]（https://github.com/gin-gonic/gin/issues/346）并尝试以下示例：
+请参阅[问题](https://github.com/gin-gonic/gin/issues/346)并尝试以下示例：
 
 [embedmd]:# (examples/multiple-service/main.go go)
 ```go
@@ -1526,7 +1526,7 @@ func main() {
 您想要优雅地重启或停止您的Web服务器吗？
 有一些方法可以做到这一点。
 
-我们可以使用[fvbock / endless]（https://github.com/fvbock/endless）来替换默认的`ListenAndServe`。 有关更多详细信息，请参阅问题[＃296]（https://github.com/gin-gonic/gin/issues/296）。
+我们可以使用[fvbock/endless](https://github.com/fvbock/endless)来替换默认的`ListenAndServe`。 有关更多详细信息，请参阅问题[＃296](https://github.com/gin-gonic/gin/issues/296)。
 
 ```go
 router := gin.Default()
@@ -1537,11 +1537,11 @@ endless.ListenAndServe(":4242", router)
 
 另一种替代方案：
 
-* [manners]（https://github.com/braintree/manners）：礼貌的Go HTTP服务器，可以正常关闭。
-* [graceful]（https://github.com/tylerb/graceful）：Graceful是一个Go包，可以正常关闭http.Handler服务器。
-* [grace]（https://github.com/facebookgo/grace）：Go服务器的平滑重启和零停机时间部署。
+* [manners](https://github.com/braintree/manners)：礼貌的Go HTTP服务器，可以正常关闭。
+* [graceful](https://github.com/tylerb/graceful)：Graceful是一个Go包，可以正常关闭http.Handler服务器。
+* [grace](https://github.com/facebookgo/grace)：Go服务器的平滑重启和零停机时间部署。
 
-如果您使用的是Go 1.8，则可能不需要使用此库！ 考虑使用http.Server的内置[Shutdown（）]（https://golang.org/pkg/net/http/#Server.Shutdown）方法进行正常关机。 请参阅gin的完整[graceful-shutdown]（./ examples / graceful-shutdown）示例。
+如果您使用的是Go 1.8，则可能不需要使用此库！ 考虑使用http.Server的内置[Shutdown()](https://golang.org/pkg/net/http/#Server.Shutdown)方法进行正常关机。 请参阅gin的完整[graceful-shutdown](./examples /graceful-shutdown)示例。
 
 [embedmd]:# (examples/graceful-shutdown/graceful-shutdown/server.go go)
 ```go
@@ -1637,7 +1637,7 @@ func loadTemplate() (*template.Template, error) {
 }
 ```
 
-请参阅`examples / assets-in-binary`目录中的完整示例。
+请参阅`examples/assets-in-binary`目录中的完整示例。
 
 ### Bind form-data request with custom struct
 
@@ -1788,13 +1788,13 @@ func SomeHandler(c *gin.Context) {
 足以立刻调用绑定。
 *只有某些格式需要此功能 - “JSON”，“XML”，“MsgPack”，
 `ProtoBuf`。 对于其他格式，`Query`，`Form`，`FormPost`，`FormMultipart`，
-可以被`c.ShouldBind（）`多次调用而不会造成任何损害
-表现（见[＃1341]（https://github.com/gin-gonic/gin/pull/1341））。
+可以被`c.ShouldBind()`多次调用而不会造成任何损害
+表现（见[＃1341](https://github.com/gin-gonic/gin/pull/1341)。
 
 ### http2 server 推送
 
 
-http.Pusher仅支持** go1.8 + **。 有关详细信息，请参阅[golang blog]（https://blog.golang.org/h2push）。
+http.Pusher仅支持** go1.8 + **。 有关详细信息，请参阅[golang blog](https://blog.golang.org/h2push)。
 
 [embedmd]:# (examples/http-pusher/main.go go)
 ```go
@@ -1886,7 +1886,7 @@ func main() {
 
 ## 测试
 
-`net / http / httptest`包是HTTP测试的首选方式。
+`net/http/httptest`包是HTTP测试的首选方式。
 
 ```go
 package main
@@ -1933,8 +1933,8 @@ func TestPingRoute(t *testing.T) {
 ## 用户
 
 
-使用[Gin]（https://github.com/gin-gonic/gin）Web框架的令人敬畏的项目列表。
+使用[Gin](https://github.com/gin-gonic/gin)Web框架的令人尊敬的项目列表。
 
-* [drone]（https://github.com/drone/drone）：drone，用Go编写。
-* [gorush]（https://github.com/appleboy/gorush）：用Go编写的推送通知服务器。
-* [fnproject]（https://github.com/fnproject/fn）：容器本机，云无关的无服务器平台。
+* [drone](https://github.com/drone/drone)：drone，用Go编写。
+* [gorush](https://github.com/appleboy/gorush)：用Go编写的推送通知服务器。
+* [fnproject](https://github.com/fnproject/fn)：容器本机，云无关的无服务器平台。