make it better

68 files changed, 8770 insertions, 0 deletions

diff --git a/vendor/github.com/gin-gonic/gin/.gitignore b/vendor/github.com/gin-gonic/gin/.gitignore
new file mode 100644
index 0000000..9f48f14
--- /dev/null
+++ b/vendor/github.com/gin-gonic/gin/.gitignore
@@ -0,0 +1,4 @@
+Godeps/*
+!Godeps/Godeps.json
+coverage.out
+count.out
diff --git a/vendor/github.com/gin-gonic/gin/.travis.yml b/vendor/github.com/gin-gonic/gin/.travis.yml
new file mode 100644
index 0000000..695f0b7
--- /dev/null
+++ b/vendor/github.com/gin-gonic/gin/.travis.yml
@@ -0,0 +1,22 @@
+language: go
+sudo: false
+go:
+  - 1.4
+  - 1.4.2
+  - tip
+
+script:
+  - go get golang.org/x/tools/cmd/cover
+  - go get github.com/mattn/goveralls
+  - go test -v -covermode=count -coverprofile=coverage.out
+
+after_success:
+  - goveralls -coverprofile=coverage.out -service=travis-ci -repotoken yFj7FrCeddvBzUaaCyG33jCLfWXeb93eA
+
+notifications:
+  webhooks:
+    urls:
+      - https://webhooks.gitter.im/e/acc2c57482e94b44f557
+    on_success: change  # options: [always|never|change] default: always
+    on_failure: always  # options: [always|never|change] default: always
+    on_start: false     # default: false
diff --git a/vendor/github.com/gin-gonic/gin/AUTHORS.md b/vendor/github.com/gin-gonic/gin/AUTHORS.md
new file mode 100644
index 0000000..2feaf46
--- /dev/null
+++ b/vendor/github.com/gin-gonic/gin/AUTHORS.md
@@ -0,0 +1,229 @@
+List of all the awesome people working to make Gin the best Web Framework in Go.
+
+
+
+##gin 0.x series authors
+
+**Maintainer:** Manu Martinez-Almeida (@manucorporat), Javier Provecho (@javierprovecho)
+
+People and companies, who have contributed, in alphabetical order.
+
+**@858806258 (杰哥)**
+- Fix typo in example
+
+
+**@achedeuzot (Klemen Sever)**
+- Fix newline debug printing
+
+
+**@adammck (Adam Mckaig)**
+- Add MIT license
+
+
+**@AlexanderChen1989 (Alexander)**
+- Typos in README
+
+
+**@alexanderdidenko (Aleksandr Didenko)**
+- Add support multipart/form-data
+
+
+**@alexandernyquist (Alexander Nyquist)**
+- Using template.Must to fix multiple return issue
+- ★ Added support for OPTIONS verb
+- ★ Setting response headers before calling WriteHeader
+- Improved documentation for model binding
+- ★ Added Content.Redirect()
+- ★ Added tons of Unit tests
+
+
+**@austinheap (Austin Heap)**
+- Added travis CI integration
+
+
+**@andredublin (Andre Dublin)**
+- Fix typo in comment
+
+
+**@bredov (Ludwig Valda Vasquez)**
+- Fix html templating in debug mode
+
+
+**@bluele (Jun Kimura)**
+- Fixes code examples in README
+
+
+**@chad-russell**
+- ★ Support for serializing gin.H into XML
+
+
+**@dickeyxxx (Jeff Dickey)**
+- Typos in README
+- Add example about serving static files
+
+
+**@donileo (Adonis)**
+- Add NoMethod handler
+
+
+**@dutchcoders (DutchCoders)**
+- ★ Fix security bug that allows client to spoof ip
+- Fix typo. r.HTMLTemplates -> SetHTMLTemplate
+
+
+**@el3ctro- (Joshua Loper)**
+- Fix typo in example
+
+
+**@ethankan (Ethan Kan)**
+- Unsigned integers in binding
+
+
+**(Evgeny Persienko)**
+- Validate sub structures
+
+
+**@frankbille (Frank Bille)**
+- Add support for HTTP Realm Auth
+
+
+**@fmd (Fareed Dudhia)**
+- Fix typo. SetHTTPTemplate -> SetHTMLTemplate
+
+
+**@ironiridis (Christopher Harrington)**
+- Remove old reference
+
+
+**@jammie-stackhouse (Jamie Stackhouse)**
+- Add more shortcuts for router methods
+
+
+**@jasonrhansen**
+- Fix spelling and grammar errors in documentation
+
+
+**@JasonSoft (Jason Lee)**
+- Fix typo in comment
+
+
+**@joiggama (Ignacio Galindo)**
+- Add utf-8 charset header on renders
+
+
+**@julienschmidt (Julien Schmidt)**
+- gofmt the code examples
+
+
+**@kelcecil (Kel Cecil)**
+- Fix readme typo
+
+
+**@kyledinh (Kyle Dinh)**
+- Adds RunTLS()
+
+
+**@LinusU (Linus Unnebäck)**
+- Small fixes in README
+
+
+**@loongmxbt (Saint Asky)**
+- Fix typo in example
+
+
+**@lucas-clemente (Lucas Clemente)**
+- ★ work around path.Join removing trailing slashes from routes
+
+
+**@mattn (Yasuhiro Matsumoto)**
+- Improve color logger
+
+
+**@mdigger (Dmitry Sedykh)**
+- Fixes Form binding when content-type is x-www-form-urlencoded
+- No repeat call c.Writer.Status() in gin.Logger
+- Fixes Content-Type for json render
+
+
+**@mirzac (Mirza Ceric)**
+- Fix debug printing
+
+
+**@mopemope (Yutaka Matsubara)**
+- ★ Adds Godep support (Dependencies Manager)
+- Fix variadic parameter in the flexible render API
+- Fix Corrupted plain render
+- Add Pluggable View Renderer Example
+ 
+
+**@msemenistyi (Mykyta Semenistyi)**
+- update Readme.md. Add code to String method
+
+
+**@msoedov (Sasha Myasoedov)**
+- ★ Adds tons of unit tests.
+
+
+**@ngerakines (Nick Gerakines)**
+- ★ Improves API, c.GET() doesn't panic
+- Adds MustGet() method
+
+
+**@r8k (Rajiv Kilaparti)**
+- Fix Port usage in README.
+
+
+**@rayrod2030 (Ray Rodriguez)**
+- Fix typo in example
+
+
+**@rns**
+- Fix typo in example
+
+
+**@RobAWilkinson (Robert Wilkinson)**
+- Add example of forms and params
+
+
+**@rogierlommers (Rogier Lommers)**
+- Add updated static serve example
+
+
+**@se77en (Damon Zhao)**
+- Improve color logging
+
+
+**@silasb (Silas Baronda)**
+- Fixing quotes in README
+
+
+**@SkuliOskarsson (Skuli Oskarsson)**
+- Fixes some texts in README II
+
+
+**@slimmy (Jimmy Pettersson)**
+- Added messages for required bindings
+
+
+**@smira (Andrey Smirnov)**
+- Add support for ignored/unexported fields in binding
+
+
+**@superalsrk (SRK.Lyu)**
+- Update httprouter godeps
+
+
+**@tebeka (Miki Tebeka)**
+- Use net/http constants instead of numeric values
+
+
+**@techjanitor**
+- Update context.go reserved IPs
+
+
+**@yosssi (Keiji Yoshida)**
+- Fix link in README
+
+
+**@yuyabee**
+- Fixed README
\ No newline at end of file
diff --git a/vendor/github.com/gin-gonic/gin/BENCHMARKS.md b/vendor/github.com/gin-gonic/gin/BENCHMARKS.md
new file mode 100644
index 0000000..181f75b
--- /dev/null
+++ b/vendor/github.com/gin-gonic/gin/BENCHMARKS.md
@@ -0,0 +1,298 @@
+**Machine:** intel i7 ivy bridge quad-core. 8GB RAM.  
+**Date:** June 4th, 2015  
+[https://github.com/gin-gonic/go-http-routing-benchmark](https://github.com/gin-gonic/go-http-routing-benchmark)
+
+```
+BenchmarkAce_Param   5000000           372 ns/op          32 B/op          1 allocs/op
+BenchmarkBear_Param  1000000          1165 ns/op         424 B/op          5 allocs/op
+BenchmarkBeego_Param     1000000          2440 ns/op         720 B/op         10 allocs/op
+BenchmarkBone_Param  1000000          1067 ns/op         384 B/op          3 allocs/op
+BenchmarkDenco_Param     5000000           240 ns/op          32 B/op          1 allocs/op
+BenchmarkEcho_Param 10000000           130 ns/op           0 B/op          0 allocs/op
+BenchmarkGin_Param  10000000           133 ns/op           0 B/op          0 allocs/op
+BenchmarkGocraftWeb_Param    1000000          1826 ns/op         656 B/op          9 allocs/op
+BenchmarkGoji_Param  2000000           957 ns/op         336 B/op          2 allocs/op
+BenchmarkGoJsonRest_Param    1000000          2021 ns/op         657 B/op         14 allocs/op
+BenchmarkGoRestful_Param      200000          8825 ns/op        2496 B/op         31 allocs/op
+BenchmarkGorillaMux_Param     500000          3340 ns/op         784 B/op          9 allocs/op
+BenchmarkHttpRouter_Param   10000000           152 ns/op          32 B/op          1 allocs/op
+BenchmarkHttpTreeMux_Param   2000000           717 ns/op         336 B/op          2 allocs/op
+BenchmarkKocha_Param     3000000           423 ns/op          56 B/op          3 allocs/op
+BenchmarkMacaron_Param   1000000          3410 ns/op        1104 B/op         11 allocs/op
+BenchmarkMartini_Param    200000          7101 ns/op        1152 B/op         12 allocs/op
+BenchmarkPat_Param   1000000          2040 ns/op         656 B/op         14 allocs/op
+BenchmarkPossum_Param    1000000          2048 ns/op         624 B/op          7 allocs/op
+BenchmarkR2router_Param  1000000          1144 ns/op         432 B/op          6 allocs/op
+BenchmarkRevel_Param      200000          6725 ns/op        1672 B/op         28 allocs/op
+BenchmarkRivet_Param     1000000          1121 ns/op         464 B/op          5 allocs/op
+BenchmarkTango_Param     1000000          1479 ns/op         256 B/op         10 allocs/op
+BenchmarkTigerTonic_Param    1000000          3393 ns/op         992 B/op         19 allocs/op
+BenchmarkTraffic_Param    300000          5525 ns/op        1984 B/op         23 allocs/op
+BenchmarkVulcan_Param    2000000           924 ns/op          98 B/op          3 allocs/op
+BenchmarkZeus_Param  1000000          1084 ns/op         368 B/op          3 allocs/op
+BenchmarkAce_Param5  3000000           614 ns/op         160 B/op          1 allocs/op
+BenchmarkBear_Param5     1000000          1617 ns/op         469 B/op          5 allocs/op
+BenchmarkBeego_Param5    1000000          3373 ns/op         992 B/op         13 allocs/op
+BenchmarkBone_Param5     1000000          1478 ns/op         432 B/op          3 allocs/op
+BenchmarkDenco_Param5    3000000           570 ns/op         160 B/op          1 allocs/op
+BenchmarkEcho_Param5     5000000           256 ns/op           0 B/op          0 allocs/op
+BenchmarkGin_Param5 10000000           222 ns/op           0 B/op          0 allocs/op
+BenchmarkGocraftWeb_Param5   1000000          2789 ns/op         928 B/op         12 allocs/op
+BenchmarkGoji_Param5     1000000          1287 ns/op         336 B/op          2 allocs/op
+BenchmarkGoJsonRest_Param5   1000000          3670 ns/op        1105 B/op         17 allocs/op
+BenchmarkGoRestful_Param5     200000         10756 ns/op        2672 B/op         31 allocs/op
+BenchmarkGorillaMux_Param5    300000          5543 ns/op         912 B/op          9 allocs/op
+BenchmarkHttpRouter_Param5   5000000           403 ns/op         160 B/op          1 allocs/op
+BenchmarkHttpTreeMux_Param5  1000000          1089 ns/op         336 B/op          2 allocs/op
+BenchmarkKocha_Param5    1000000          1682 ns/op         440 B/op         10 allocs/op
+BenchmarkMacaron_Param5   300000          4596 ns/op        1376 B/op         14 allocs/op
+BenchmarkMartini_Param5   100000         15703 ns/op        1280 B/op         12 allocs/op
+BenchmarkPat_Param5   300000          5320 ns/op        1008 B/op         42 allocs/op
+BenchmarkPossum_Param5   1000000          2155 ns/op         624 B/op          7 allocs/op
+BenchmarkR2router_Param5     1000000          1559 ns/op         432 B/op          6 allocs/op
+BenchmarkRevel_Param5     200000          8184 ns/op        2024 B/op         35 allocs/op
+BenchmarkRivet_Param5    1000000          1914 ns/op         528 B/op          9 allocs/op
+BenchmarkTango_Param5    1000000          3280 ns/op         944 B/op         18 allocs/op
+BenchmarkTigerTonic_Param5    200000         11638 ns/op        2519 B/op         53 allocs/op
+BenchmarkTraffic_Param5   200000          8941 ns/op        2280 B/op         31 allocs/op
+BenchmarkVulcan_Param5   1000000          1279 ns/op          98 B/op          3 allocs/op
+BenchmarkZeus_Param5     1000000          1574 ns/op         416 B/op          3 allocs/op
+BenchmarkAce_Param20     1000000          1528 ns/op         640 B/op          1 allocs/op
+BenchmarkBear_Param20     300000          4906 ns/op        1633 B/op          5 allocs/op
+BenchmarkBeego_Param20    200000         10529 ns/op        3868 B/op         17 allocs/op
+BenchmarkBone_Param20     300000          7362 ns/op        2539 B/op          5 allocs/op
+BenchmarkDenco_Param20   1000000          1884 ns/op         640 B/op          1 allocs/op
+BenchmarkEcho_Param20    2000000           689 ns/op           0 B/op          0 allocs/op
+BenchmarkGin_Param20     3000000           545 ns/op           0 B/op          0 allocs/op
+BenchmarkGocraftWeb_Param20   200000          9437 ns/op        3804 B/op         16 allocs/op
+BenchmarkGoji_Param20     500000          3987 ns/op        1246 B/op          2 allocs/op
+BenchmarkGoJsonRest_Param20   100000         12799 ns/op        4492 B/op         21 allocs/op
+BenchmarkGoRestful_Param20    100000         19451 ns/op        5244 B/op         33 allocs/op
+BenchmarkGorillaMux_Param20   100000         12456 ns/op        3275 B/op         11 allocs/op
+BenchmarkHttpRouter_Param20  1000000          1333 ns/op         640 B/op          1 allocs/op
+BenchmarkHttpTreeMux_Param20      300000          6490 ns/op        2187 B/op          4 allocs/op
+BenchmarkKocha_Param20    300000          5335 ns/op        1808 B/op         27 allocs/op
+BenchmarkMacaron_Param20      200000         11325 ns/op        4252 B/op         18 allocs/op
+BenchmarkMartini_Param20       20000         64419 ns/op        3644 B/op         14 allocs/op
+BenchmarkPat_Param20       50000         24672 ns/op        4888 B/op        151 allocs/op
+BenchmarkPossum_Param20  1000000          2085 ns/op         624 B/op          7 allocs/op
+BenchmarkR2router_Param20     300000          6809 ns/op        2283 B/op          8 allocs/op
+BenchmarkRevel_Param20    100000         16600 ns/op        5551 B/op         54 allocs/op
+BenchmarkRivet_Param20    200000          8428 ns/op        2620 B/op         26 allocs/op
+BenchmarkTango_Param20    100000         16302 ns/op        8224 B/op         48 allocs/op
+BenchmarkTigerTonic_Param20    30000         46828 ns/op       10538 B/op        178 allocs/op
+BenchmarkTraffic_Param20       50000         28871 ns/op        7998 B/op         66 allocs/op
+BenchmarkVulcan_Param20  1000000          2267 ns/op          98 B/op          3 allocs/op
+BenchmarkZeus_Param20     300000          6828 ns/op        2507 B/op          5 allocs/op
+BenchmarkAce_ParamWrite  3000000           502 ns/op          40 B/op          2 allocs/op
+BenchmarkBear_ParamWrite     1000000          1303 ns/op         424 B/op          5 allocs/op
+BenchmarkBeego_ParamWrite    1000000          2489 ns/op         728 B/op         11 allocs/op
+BenchmarkBone_ParamWrite     1000000          1181 ns/op         384 B/op          3 allocs/op
+BenchmarkDenco_ParamWrite    5000000           315 ns/op          32 B/op          1 allocs/op
+BenchmarkEcho_ParamWrite    10000000           237 ns/op           8 B/op          1 allocs/op
+BenchmarkGin_ParamWrite  5000000           336 ns/op           0 B/op          0 allocs/op
+BenchmarkGocraftWeb_ParamWrite   1000000          2079 ns/op         664 B/op         10 allocs/op
+BenchmarkGoji_ParamWrite     1000000          1092 ns/op         336 B/op          2 allocs/op
+BenchmarkGoJsonRest_ParamWrite   1000000          3329 ns/op        1136 B/op         19 allocs/op
+BenchmarkGoRestful_ParamWrite     200000          9273 ns/op        2504 B/op         32 allocs/op
+BenchmarkGorillaMux_ParamWrite    500000          3919 ns/op         792 B/op         10 allocs/op
+BenchmarkHttpRouter_ParamWrite  10000000           223 ns/op          32 B/op          1 allocs/op
+BenchmarkHttpTreeMux_ParamWrite  2000000           788 ns/op         336 B/op          2 allocs/op
+BenchmarkKocha_ParamWrite    3000000           549 ns/op          56 B/op          3 allocs/op
+BenchmarkMacaron_ParamWrite   500000          4558 ns/op        1216 B/op         16 allocs/op
+BenchmarkMartini_ParamWrite   200000          8850 ns/op        1256 B/op         16 allocs/op
+BenchmarkPat_ParamWrite   500000          3679 ns/op        1088 B/op         19 allocs/op
+BenchmarkPossum_ParamWrite   1000000          2114 ns/op         624 B/op          7 allocs/op
+BenchmarkR2router_ParamWrite     1000000          1320 ns/op         432 B/op          6 allocs/op
+BenchmarkRevel_ParamWrite     200000          8048 ns/op        2128 B/op         33 allocs/op
+BenchmarkRivet_ParamWrite    1000000          1393 ns/op         472 B/op          6 allocs/op
+BenchmarkTango_ParamWrite    2000000           819 ns/op         136 B/op          5 allocs/op
+BenchmarkTigerTonic_ParamWrite    300000          5860 ns/op        1440 B/op         25 allocs/op
+BenchmarkTraffic_ParamWrite   200000          7429 ns/op        2400 B/op         27 allocs/op
+BenchmarkVulcan_ParamWrite   2000000           972 ns/op          98 B/op          3 allocs/op
+BenchmarkZeus_ParamWrite     1000000          1226 ns/op         368 B/op          3 allocs/op
+BenchmarkAce_GithubStatic    5000000           294 ns/op           0 B/op          0 allocs/op
+BenchmarkBear_GithubStatic   3000000           575 ns/op          88 B/op          3 allocs/op
+BenchmarkBeego_GithubStatic  1000000          1561 ns/op         368 B/op          7 allocs/op
+BenchmarkBone_GithubStatic    200000         12301 ns/op        2880 B/op         60 allocs/op
+BenchmarkDenco_GithubStatic 20000000            74.6 ns/op         0 B/op          0 allocs/op
+BenchmarkEcho_GithubStatic  10000000           176 ns/op           0 B/op          0 allocs/op
+BenchmarkGin_GithubStatic   10000000           159 ns/op           0 B/op          0 allocs/op
+BenchmarkGocraftWeb_GithubStatic     1000000          1116 ns/op         304 B/op          6 allocs/op
+BenchmarkGoji_GithubStatic   5000000           413 ns/op           0 B/op          0 allocs/op
+BenchmarkGoRestful_GithubStatic    30000         55200 ns/op        3520 B/op         36 allocs/op
+BenchmarkGoJsonRest_GithubStatic     1000000          1504 ns/op         337 B/op         12 allocs/op
+BenchmarkGorillaMux_GithubStatic      100000         23620 ns/op         464 B/op          8 allocs/op
+BenchmarkHttpRouter_GithubStatic    20000000            78.3 ns/op         0 B/op          0 allocs/op
+BenchmarkHttpTreeMux_GithubStatic   20000000            84.9 ns/op         0 B/op          0 allocs/op
+BenchmarkKocha_GithubStatic 20000000           111 ns/op           0 B/op          0 allocs/op
+BenchmarkMacaron_GithubStatic    1000000          2686 ns/op         752 B/op          8 allocs/op
+BenchmarkMartini_GithubStatic     100000         22244 ns/op         832 B/op         11 allocs/op
+BenchmarkPat_GithubStatic     100000         13278 ns/op        3648 B/op         76 allocs/op
+BenchmarkPossum_GithubStatic     1000000          1429 ns/op         480 B/op          4 allocs/op
+BenchmarkR2router_GithubStatic   2000000           726 ns/op         144 B/op          5 allocs/op
+BenchmarkRevel_GithubStatic   300000          6271 ns/op        1288 B/op         25 allocs/op
+BenchmarkRivet_GithubStatic  3000000           474 ns/op         112 B/op          2 allocs/op
+BenchmarkTango_GithubStatic  1000000          1842 ns/op         256 B/op         10 allocs/op
+BenchmarkTigerTonic_GithubStatic     5000000           361 ns/op          48 B/op          1 allocs/op
+BenchmarkTraffic_GithubStatic      30000         47197 ns/op       18920 B/op        149 allocs/op
+BenchmarkVulcan_GithubStatic     1000000          1415 ns/op          98 B/op          3 allocs/op
+BenchmarkZeus_GithubStatic   1000000          2522 ns/op         512 B/op         11 allocs/op
+BenchmarkAce_GithubParam     3000000           578 ns/op          96 B/op          1 allocs/op
+BenchmarkBear_GithubParam    1000000          1592 ns/op         464 B/op          5 allocs/op
+BenchmarkBeego_GithubParam   1000000          2891 ns/op         784 B/op         11 allocs/op
+BenchmarkBone_GithubParam     300000          6440 ns/op        1456 B/op         16 allocs/op
+BenchmarkDenco_GithubParam   3000000           514 ns/op         128 B/op          1 allocs/op
+BenchmarkEcho_GithubParam    5000000           292 ns/op           0 B/op          0 allocs/op
+BenchmarkGin_GithubParam    10000000           242 ns/op           0 B/op          0 allocs/op
+BenchmarkGocraftWeb_GithubParam  1000000          2343 ns/op         720 B/op         10 allocs/op
+BenchmarkGoji_GithubParam    1000000          1566 ns/op         336 B/op          2 allocs/op
+BenchmarkGoJsonRest_GithubParam  1000000          2828 ns/op         721 B/op         15 allocs/op
+BenchmarkGoRestful_GithubParam     10000        177711 ns/op        2816 B/op         35 allocs/op
+BenchmarkGorillaMux_GithubParam   100000         13591 ns/op         816 B/op          9 allocs/op
+BenchmarkHttpRouter_GithubParam  5000000           352 ns/op          96 B/op          1 allocs/op
+BenchmarkHttpTreeMux_GithubParam     2000000           973 ns/op         336 B/op          2 allocs/op
+BenchmarkKocha_GithubParam   2000000           889 ns/op         128 B/op          5 allocs/op
+BenchmarkMacaron_GithubParam      500000          4047 ns/op        1168 B/op         12 allocs/op
+BenchmarkMartini_GithubParam       50000         28982 ns/op        1184 B/op         12 allocs/op
+BenchmarkPat_GithubParam      200000          8747 ns/op        2480 B/op         56 allocs/op
+BenchmarkPossum_GithubParam  1000000          2158 ns/op         624 B/op          7 allocs/op
+BenchmarkR2router_GithubParam    1000000          1352 ns/op         432 B/op          6 allocs/op
+BenchmarkRevel_GithubParam    200000          7673 ns/op        1784 B/op         30 allocs/op
+BenchmarkRivet_GithubParam   1000000          1573 ns/op         480 B/op          6 allocs/op
+BenchmarkTango_GithubParam   1000000          2418 ns/op         480 B/op         13 allocs/op
+BenchmarkTigerTonic_GithubParam   300000          6048 ns/op        1440 B/op         28 allocs/op
+BenchmarkTraffic_GithubParam      100000         20143 ns/op        6024 B/op         55 allocs/op
+BenchmarkVulcan_GithubParam  1000000          2224 ns/op          98 B/op          3 allocs/op
+BenchmarkZeus_GithubParam     500000          4156 ns/op        1312 B/op         12 allocs/op
+BenchmarkAce_GithubAll     10000        109482 ns/op       13792 B/op        167 allocs/op
+BenchmarkBear_GithubAll    10000        287490 ns/op       79952 B/op        943 allocs/op
+BenchmarkBeego_GithubAll        3000        562184 ns/op      146272 B/op       2092 allocs/op
+BenchmarkBone_GithubAll      500       2578716 ns/op      648016 B/op       8119 allocs/op
+BenchmarkDenco_GithubAll       20000         94955 ns/op       20224 B/op        167 allocs/op
+BenchmarkEcho_GithubAll    30000         58705 ns/op           0 B/op          0 allocs/op
+BenchmarkGin_GithubAll     30000         50991 ns/op           0 B/op          0 allocs/op
+BenchmarkGocraftWeb_GithubAll       5000        449648 ns/op      133280 B/op       1889 allocs/op
+BenchmarkGoji_GithubAll     2000        689748 ns/op       56113 B/op        334 allocs/op
+BenchmarkGoJsonRest_GithubAll       5000        537769 ns/op      135995 B/op       2940 allocs/op
+BenchmarkGoRestful_GithubAll         100      18410628 ns/op      797236 B/op       7725 allocs/op
+BenchmarkGorillaMux_GithubAll        200       8036360 ns/op      153137 B/op       1791 allocs/op
+BenchmarkHttpRouter_GithubAll      20000         63506 ns/op       13792 B/op        167 allocs/op
+BenchmarkHttpTreeMux_GithubAll     10000        165927 ns/op       56112 B/op        334 allocs/op
+BenchmarkKocha_GithubAll       10000        171362 ns/op       23304 B/op        843 allocs/op
+BenchmarkMacaron_GithubAll      2000        817008 ns/op      224960 B/op       2315 allocs/op
+BenchmarkMartini_GithubAll       100      12609209 ns/op      237952 B/op       2686 allocs/op
+BenchmarkPat_GithubAll       300       4830398 ns/op     1504101 B/op      32222 allocs/op
+BenchmarkPossum_GithubAll      10000        301716 ns/op       97440 B/op        812 allocs/op
+BenchmarkR2router_GithubAll    10000        270691 ns/op       77328 B/op       1182 allocs/op
+BenchmarkRevel_GithubAll        1000       1491919 ns/op      345553 B/op       5918 allocs/op
+BenchmarkRivet_GithubAll       10000        283860 ns/op       84272 B/op       1079 allocs/op
+BenchmarkTango_GithubAll        5000        473821 ns/op       87078 B/op       2470 allocs/op
+BenchmarkTigerTonic_GithubAll       2000       1120131 ns/op      241088 B/op       6052 allocs/op
+BenchmarkTraffic_GithubAll       200       8708979 ns/op     2664762 B/op      22390 allocs/op
+BenchmarkVulcan_GithubAll       5000        353392 ns/op       19894 B/op        609 allocs/op
+BenchmarkZeus_GithubAll     2000        944234 ns/op      300688 B/op       2648 allocs/op
+BenchmarkAce_GPlusStatic     5000000           251 ns/op           0 B/op          0 allocs/op
+BenchmarkBear_GPlusStatic    3000000           415 ns/op          72 B/op          3 allocs/op
+BenchmarkBeego_GPlusStatic   1000000          1416 ns/op         352 B/op          7 allocs/op
+BenchmarkBone_GPlusStatic   10000000           192 ns/op          32 B/op          1 allocs/op
+BenchmarkDenco_GPlusStatic  30000000            47.6 ns/op         0 B/op          0 allocs/op
+BenchmarkEcho_GPlusStatic   10000000           131 ns/op           0 B/op          0 allocs/op
+BenchmarkGin_GPlusStatic    10000000           131 ns/op           0 B/op          0 allocs/op
+BenchmarkGocraftWeb_GPlusStatic  1000000          1035 ns/op         288 B/op          6 allocs/op
+BenchmarkGoji_GPlusStatic    5000000           304 ns/op           0 B/op          0 allocs/op
+BenchmarkGoJsonRest_GPlusStatic  1000000          1286 ns/op         337 B/op         12 allocs/op
+BenchmarkGoRestful_GPlusStatic    200000          9649 ns/op        2160 B/op         30 allocs/op
+BenchmarkGorillaMux_GPlusStatic  1000000          2346 ns/op         464 B/op          8 allocs/op
+BenchmarkHttpRouter_GPlusStatic 30000000            42.7 ns/op         0 B/op          0 allocs/op
+BenchmarkHttpTreeMux_GPlusStatic    30000000            49.5 ns/op         0 B/op          0 allocs/op
+BenchmarkKocha_GPlusStatic  20000000            74.8 ns/op         0 B/op          0 allocs/op
+BenchmarkMacaron_GPlusStatic     1000000          2520 ns/op         736 B/op          8 allocs/op
+BenchmarkMartini_GPlusStatic      300000          5310 ns/op         832 B/op         11 allocs/op
+BenchmarkPat_GPlusStatic     5000000           398 ns/op          96 B/op          2 allocs/op
+BenchmarkPossum_GPlusStatic  1000000          1434 ns/op         480 B/op          4 allocs/op
+BenchmarkR2router_GPlusStatic    2000000           646 ns/op         144 B/op          5 allocs/op
+BenchmarkRevel_GPlusStatic    300000          6172 ns/op        1272 B/op         25 allocs/op
+BenchmarkRivet_GPlusStatic   3000000           444 ns/op         112 B/op          2 allocs/op
+BenchmarkTango_GPlusStatic   1000000          1400 ns/op         208 B/op         10 allocs/op
+BenchmarkTigerTonic_GPlusStatic 10000000           213 ns/op          32 B/op          1 allocs/op
+BenchmarkTraffic_GPlusStatic     1000000          3091 ns/op        1208 B/op         16 allocs/op
+BenchmarkVulcan_GPlusStatic  2000000           863 ns/op          98 B/op          3 allocs/op
+BenchmarkZeus_GPlusStatic   10000000           237 ns/op          16 B/op          1 allocs/op
+BenchmarkAce_GPlusParam  3000000           435 ns/op          64 B/op          1 allocs/op
+BenchmarkBear_GPlusParam     1000000          1205 ns/op         448 B/op          5 allocs/op
+BenchmarkBeego_GPlusParam    1000000          2494 ns/op         720 B/op         10 allocs/op
+BenchmarkBone_GPlusParam     1000000          1126 ns/op         384 B/op          3 allocs/op
+BenchmarkDenco_GPlusParam    5000000           325 ns/op          64 B/op          1 allocs/op
+BenchmarkEcho_GPlusParam    10000000           168 ns/op           0 B/op          0 allocs/op
+BenchmarkGin_GPlusParam 10000000           170 ns/op           0 B/op          0 allocs/op
+BenchmarkGocraftWeb_GPlusParam   1000000          1895 ns/op         656 B/op          9 allocs/op
+BenchmarkGoji_GPlusParam     1000000          1071 ns/op         336 B/op          2 allocs/op
+BenchmarkGoJsonRest_GPlusParam   1000000          2282 ns/op         657 B/op         14 allocs/op
+BenchmarkGoRestful_GPlusParam     100000         19400 ns/op        2560 B/op         33 allocs/op
+BenchmarkGorillaMux_GPlusParam    500000          5001 ns/op         784 B/op          9 allocs/op
+BenchmarkHttpRouter_GPlusParam  10000000           240 ns/op          64 B/op          1 allocs/op
+BenchmarkHttpTreeMux_GPlusParam  2000000           797 ns/op         336 B/op          2 allocs/op
+BenchmarkKocha_GPlusParam    3000000           505 ns/op          56 B/op          3 allocs/op
+BenchmarkMacaron_GPlusParam  1000000          3668 ns/op        1104 B/op         11 allocs/op
+BenchmarkMartini_GPlusParam   200000         10672 ns/op        1152 B/op         12 allocs/op
+BenchmarkPat_GPlusParam  1000000          2376 ns/op         704 B/op         14 allocs/op
+BenchmarkPossum_GPlusParam   1000000          2090 ns/op         624 B/op          7 allocs/op
+BenchmarkR2router_GPlusParam     1000000          1233 ns/op         432 B/op          6 allocs/op
+BenchmarkRevel_GPlusParam     200000          6778 ns/op        1704 B/op         28 allocs/op
+BenchmarkRivet_GPlusParam    1000000          1279 ns/op         464 B/op          5 allocs/op
+BenchmarkTango_GPlusParam    1000000          1981 ns/op         272 B/op         10 allocs/op
+BenchmarkTigerTonic_GPlusParam    500000          3893 ns/op        1064 B/op         19 allocs/op
+BenchmarkTraffic_GPlusParam   200000          6585 ns/op        2000 B/op         23 allocs/op
+BenchmarkVulcan_GPlusParam   1000000          1233 ns/op          98 B/op          3 allocs/op
+BenchmarkZeus_GPlusParam     1000000          1350 ns/op         368 B/op          3 allocs/op
+BenchmarkAce_GPlus2Params    3000000           512 ns/op          64 B/op          1 allocs/op
+BenchmarkBear_GPlus2Params   1000000          1564 ns/op         464 B/op          5 allocs/op
+BenchmarkBeego_GPlus2Params  1000000          3043 ns/op         784 B/op         11 allocs/op
+BenchmarkBone_GPlus2Params   1000000          3152 ns/op         736 B/op          7 allocs/op
+BenchmarkDenco_GPlus2Params  3000000           431 ns/op          64 B/op          1 allocs/op
+BenchmarkEcho_GPlus2Params   5000000           247 ns/op           0 B/op          0 allocs/op
+BenchmarkGin_GPlus2Params   10000000           219 ns/op           0 B/op          0 allocs/op
+BenchmarkGocraftWeb_GPlus2Params     1000000          2363 ns/op         720 B/op         10 allocs/op
+BenchmarkGoji_GPlus2Params   1000000          1540 ns/op         336 B/op          2 allocs/op
+BenchmarkGoJsonRest_GPlus2Params     1000000          2872 ns/op         721 B/op         15 allocs/op
+BenchmarkGoRestful_GPlus2Params   100000         23030 ns/op        2720 B/op         35 allocs/op
+BenchmarkGorillaMux_GPlus2Params      200000         10516 ns/op         816 B/op          9 allocs/op
+BenchmarkHttpRouter_GPlus2Params     5000000           273 ns/op          64 B/op          1 allocs/op
+BenchmarkHttpTreeMux_GPlus2Params    2000000           939 ns/op         336 B/op          2 allocs/op
+BenchmarkKocha_GPlus2Params  2000000           844 ns/op         128 B/op          5 allocs/op
+BenchmarkMacaron_GPlus2Params     500000          3914 ns/op        1168 B/op         12 allocs/op
+BenchmarkMartini_GPlus2Params      50000         35759 ns/op        1280 B/op         16 allocs/op
+BenchmarkPat_GPlus2Params     200000          7089 ns/op        2304 B/op         41 allocs/op
+BenchmarkPossum_GPlus2Params     1000000          2093 ns/op         624 B/op          7 allocs/op
+BenchmarkR2router_GPlus2Params   1000000          1320 ns/op         432 B/op          6 allocs/op
+BenchmarkRevel_GPlus2Params   200000          7351 ns/op        1800 B/op         30 allocs/op
+BenchmarkRivet_GPlus2Params  1000000          1485 ns/op         480 B/op          6 allocs/op
+BenchmarkTango_GPlus2Params  1000000          2111 ns/op         448 B/op         12 allocs/op
+BenchmarkTigerTonic_GPlus2Params      300000          6271 ns/op        1528 B/op         28 allocs/op
+BenchmarkTraffic_GPlus2Params     100000         14886 ns/op        3312 B/op         34 allocs/op
+BenchmarkVulcan_GPlus2Params     1000000          1883 ns/op          98 B/op          3 allocs/op
+BenchmarkZeus_GPlus2Params   1000000          2686 ns/op         784 B/op          6 allocs/op
+BenchmarkAce_GPlusAll     300000          5912 ns/op         640 B/op         11 allocs/op
+BenchmarkBear_GPlusAll    100000         16448 ns/op        5072 B/op         61 allocs/op
+BenchmarkBeego_GPlusAll    50000         32916 ns/op        8976 B/op        129 allocs/op
+BenchmarkBone_GPlusAll     50000         25836 ns/op        6992 B/op         76 allocs/op
+BenchmarkDenco_GPlusAll   500000          4462 ns/op         672 B/op         11 allocs/op
+BenchmarkEcho_GPlusAll    500000          2806 ns/op           0 B/op          0 allocs/op
+BenchmarkGin_GPlusAll     500000          2579 ns/op           0 B/op          0 allocs/op
+BenchmarkGocraftWeb_GPlusAll       50000         25223 ns/op        8144 B/op        116 allocs/op
+BenchmarkGoji_GPlusAll    100000         14237 ns/op        3696 B/op         22 allocs/op
+BenchmarkGoJsonRest_GPlusAll       50000         29227 ns/op        8221 B/op        183 allocs/op
+BenchmarkGoRestful_GPlusAll    10000        203144 ns/op       36064 B/op        441 allocs/op
+BenchmarkGorillaMux_GPlusAll       20000         80906 ns/op        9712 B/op        115 allocs/op
+BenchmarkHttpRouter_GPlusAll      500000          3040 ns/op         640 B/op         11 allocs/op
+BenchmarkHttpTreeMux_GPlusAll     200000          9627 ns/op        3696 B/op         22 allocs/op
+BenchmarkKocha_GPlusAll   200000          8108 ns/op         976 B/op         43 allocs/op
+BenchmarkMacaron_GPlusAll      30000         48083 ns/op       13968 B/op        142 allocs/op
+BenchmarkMartini_GPlusAll      10000        196978 ns/op       15072 B/op        178 allocs/op
+BenchmarkPat_GPlusAll      30000         58865 ns/op       16880 B/op        343 allocs/op
+BenchmarkPossum_GPlusAll      100000         19685 ns/op        6240 B/op         52 allocs/op
+BenchmarkR2router_GPlusAll    100000         16251 ns/op        5040 B/op         76 allocs/op
+BenchmarkRevel_GPlusAll    20000         93489 ns/op       21656 B/op        368 allocs/op
+BenchmarkRivet_GPlusAll   100000         16907 ns/op        5408 B/op         64 allocs/op
+```
\ No newline at end of file
diff --git a/vendor/github.com/gin-gonic/gin/CHANGELOG.md b/vendor/github.com/gin-gonic/gin/CHANGELOG.md
new file mode 100644
index 0000000..938084c
--- /dev/null
+++ b/vendor/github.com/gin-gonic/gin/CHANGELOG.md
@@ -0,0 +1,141 @@
+#CHANGELOG
+
+###Gin 1.0rc2 (...)
+
+- [PERFORMANCE] Fast path for writting Content-Type.
+- [PERFORMANCE] Much faster 404 routing
+- [PERFORMANCE] Allocation optimizations
+- [PERFORMANCE] Faster root tree lookup
+- [PERFORMANCE] Zero overhead, String() and JSON() rendering.
+- [PERFORMANCE] Faster ClientIP parsing
+- [PERFORMANCE] Much faster SSE implementation
+- [NEW] Benchmarks suite
+- [NEW] Bind validation can be disabled and replaced with custom validators.
+- [NEW] More flexible HTML render
+- [FIX] Binding multipart form
+- [FIX] Integration tests
+- [FIX] Crash when binding non struct object in Context.
+- [FIX] RunTLS() implementation
+- [FIX] Logger() unit tests
+- [FIX] Better approach to avoid directory listing in StaticFS()
+- [FIX] Context.ClientIP() always returns the IP with trimmed spaces.
+- [FIX] Better warning when running in debug mode.
+- [FIX] Google App Engine integration. debugPrint does not use os.Stdout
+- [FIX] Fixes integer overflow in error type
+- [FIX] Error implements the json.Marshaller interface
+- [FIX] MIT license in every file
+
+
+###Gin 1.0rc1 (May 22, 2015)
+
+- [PERFORMANCE] Zero allocation router
+- [PERFORMANCE] Faster JSON, XML and text rendering
+- [PERFORMANCE] Custom hand optimized HttpRouter for Gin
+- [PERFORMANCE] Misc code optimizations. Inlining, tail call optimizations
+- [NEW] Built-in support for golang.org/x/net/context
+- [NEW] Any(path, handler). Create a route that matches any path
+- [NEW] Refactored rendering pipeline (faster and static typeded)
+- [NEW] Refactored errors API
+- [NEW] IndentedJSON() prints pretty JSON
+- [NEW] Added gin.DefaultWriter
+- [NEW] UNIX socket support
+- [NEW] RouterGroup.BasePath is exposed
+- [NEW] JSON validation using go-validate-yourself (very powerful options)
+- [NEW] Completed suite of unit tests
+- [NEW] HTTP streaming with c.Stream()
+- [NEW] StaticFile() creates a router for serving just one file.
+- [NEW] StaticFS() has an option to disable directory listing.
+- [NEW] StaticFS() for serving static files through virtual filesystems
+- [NEW] Server-Sent Events native support
+- [NEW] WrapF() and WrapH() helpers for wrapping http.HandlerFunc and http.Handler
+- [NEW] Added LoggerWithWriter() middleware
+- [NEW] Added RecoveryWithWriter() middleware
+- [NEW] Added DefaultPostFormValue()
+- [NEW] Added DefaultFormValue()
+- [NEW] Added DefaultParamValue()
+- [FIX] BasicAuth() when using custom realm
+- [FIX] Bug when serving static files in nested routing group
+- [FIX] Redirect using built-in http.Redirect()
+- [FIX] Logger when printing the requested path
+- [FIX] Documentation typos
+- [FIX] Context.Engine renamed to Context.engine
+- [FIX] Better debugging messages
+- [FIX] ErrorLogger
+- [FIX] Debug HTTP render
+- [FIX] Refactored binding and render modules 
+- [FIX] Refactored Context initialization
+- [FIX] Refactored BasicAuth()
+- [FIX] NoMethod/NoRoute handlers
+- [FIX] Hijacking http
+- [FIX] Better support for Google App Engine (using log instead of fmt)
+
+
+###Gin 0.6 (Mar 9, 2015)
+
+- [NEW] Support multipart/form-data
+- [NEW] NoMethod handler
+- [NEW] Validate sub structures
+- [NEW] Support for HTTP Realm Auth
+- [FIX] Unsigned integers in binding
+- [FIX] Improve color logger
+
+
+###Gin 0.5 (Feb 7, 2015)
+
+- [NEW] Content Negotiation
+- [FIX] Solved security bug that allow a client to spoof ip
+- [FIX] Fix unexported/ignored fields in binding
+
+
+###Gin 0.4 (Aug 21, 2014)
+
+- [NEW] Development mode
+- [NEW] Unit tests
+- [NEW] Add Content.Redirect()
+- [FIX] Deferring WriteHeader()
+- [FIX] Improved documentation for model binding
+
+
+###Gin 0.3 (Jul 18, 2014)
+
+- [PERFORMANCE] Normal log and error log are printed in the same call.
+- [PERFORMANCE] Improve performance of NoRouter()
+- [PERFORMANCE] Improve context's memory locality, reduce CPU cache faults.
+- [NEW] Flexible rendering API
+- [NEW] Add Context.File()
+- [NEW] Add shorcut RunTLS() for http.ListenAndServeTLS
+- [FIX] Rename NotFound404() to NoRoute()
+- [FIX] Errors in context are purged
+- [FIX] Adds HEAD method in Static file serving
+- [FIX] Refactors Static() file serving
+- [FIX] Using keyed initialization to fix app-engine integration
+- [FIX] Can't unmarshal JSON array, #63
+- [FIX] Renaming Context.Req to Context.Request
+- [FIX] Check application/x-www-form-urlencoded when parsing form
+
+
+###Gin 0.2b (Jul 08, 2014)
+- [PERFORMANCE] Using sync.Pool to allocatio/gc overhead
+- [NEW] Travis CI integration
+- [NEW] Completely new logger
+- [NEW] New API for serving static files. gin.Static()
+- [NEW] gin.H() can be serialized into XML
+- [NEW] Typed errors. Errors can be typed. Internet/external/custom.
+- [NEW] Support for Godeps
+- [NEW] Travis/Godocs badges in README
+- [NEW] New Bind() and BindWith() methods for parsing request body.
+- [NEW] Add Content.Copy()
+- [NEW] Add context.LastError()
+- [NEW] Add shorcut for OPTIONS HTTP method
+- [FIX] Tons of README fixes
+- [FIX] Header is written before body
+- [FIX] BasicAuth() and changes API a little bit
+- [FIX] Recovery() middleware only prints panics
+- [FIX] Context.Get() does not panic anymore. Use MustGet() instead.
+- [FIX] Multiple http.WriteHeader() in NotFound handlers
+- [FIX] Engine.Run() panics if http server can't be setted up
+- [FIX] Crash when route path doesn't start with '/'
+- [FIX] Do not update header when status code is negative
+- [FIX] Setting response headers before calling WriteHeader in context.String()
+- [FIX] Add MIT license
+- [FIX] Changes behaviour of ErrorLogger() and Logger()
diff --git a/vendor/github.com/gin-gonic/gin/LICENSE b/vendor/github.com/gin-gonic/gin/LICENSE
new file mode 100644
index 0000000..1ff7f37
--- /dev/null
+++ b/vendor/github.com/gin-gonic/gin/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Manuel Martínez-Almeida
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/gin-gonic/gin/README.md b/vendor/github.com/gin-gonic/gin/README.md
new file mode 100644
index 0000000..67c9fa8
--- /dev/null
+++ b/vendor/github.com/gin-gonic/gin/README.md
@@ -0,0 +1,579 @@
+#Gin Web Framework [![Build Status](https://travis-ci.org/gin-gonic/gin.svg)](https://travis-ci.org/gin-gonic/gin) [![Coverage Status](https://coveralls.io/repos/gin-gonic/gin/badge.svg?branch=master)](https://coveralls.io/r/gin-gonic/gin?branch=master)  
+
+ [![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)
+
+Gin is a web framework written in 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. 
+
+![Gin console logger](https://gin-gonic.github.io/gin/other/console.png)
+
+```
+$ cat test.go
+```
+```go 
+package main
+
+import "github.com/gin-gonic/gin"
+
+func main() {
+	r := gin.Default()
+	r.GET("/ping", func(c *gin.Context) {
+		c.String(200, "pong")
+	})
+	r.Run(":8080") // listen and serve on 0.0.0.0:8080
+}
+```
+
+## Benchmarks
+
+Gin uses a custom version of [HttpRouter](https://github.com/julienschmidt/httprouter)  
+
+[See all benchmarks](/BENCHMARKS.md)
+
+
+```
+BenchmarkAce_GithubAll     10000        109482 ns/op       13792 B/op        167 allocs/op
+BenchmarkBear_GithubAll    10000        287490 ns/op       79952 B/op        943 allocs/op
+BenchmarkBeego_GithubAll        3000        562184 ns/op      146272 B/op       2092 allocs/op
+BenchmarkBone_GithubAll      500       2578716 ns/op      648016 B/op       8119 allocs/op
+BenchmarkDenco_GithubAll       20000         94955 ns/op       20224 B/op        167 allocs/op
+BenchmarkEcho_GithubAll    30000         58705 ns/op           0 B/op          0 allocs/op
+BenchmarkGin_GithubAll     30000         50991 ns/op           0 B/op          0 allocs/op
+BenchmarkGocraftWeb_GithubAll       5000        449648 ns/op      133280 B/op       1889 allocs/op
+BenchmarkGoji_GithubAll     2000        689748 ns/op       56113 B/op        334 allocs/op
+BenchmarkGoJsonRest_GithubAll       5000        537769 ns/op      135995 B/op       2940 allocs/op
+BenchmarkGoRestful_GithubAll         100      18410628 ns/op      797236 B/op       7725 allocs/op
+BenchmarkGorillaMux_GithubAll        200       8036360 ns/op      153137 B/op       1791 allocs/op
+BenchmarkHttpRouter_GithubAll      20000         63506 ns/op       13792 B/op        167 allocs/op
+BenchmarkHttpTreeMux_GithubAll     10000        165927 ns/op       56112 B/op        334 allocs/op
+BenchmarkKocha_GithubAll       10000        171362 ns/op       23304 B/op        843 allocs/op
+BenchmarkMacaron_GithubAll      2000        817008 ns/op      224960 B/op       2315 allocs/op
+BenchmarkMartini_GithubAll       100      12609209 ns/op      237952 B/op       2686 allocs/op
+BenchmarkPat_GithubAll       300       4830398 ns/op     1504101 B/op      32222 allocs/op
+BenchmarkPossum_GithubAll      10000        301716 ns/op       97440 B/op        812 allocs/op
+BenchmarkR2router_GithubAll    10000        270691 ns/op       77328 B/op       1182 allocs/op
+BenchmarkRevel_GithubAll        1000       1491919 ns/op      345553 B/op       5918 allocs/op
+BenchmarkRivet_GithubAll       10000        283860 ns/op       84272 B/op       1079 allocs/op
+BenchmarkTango_GithubAll        5000        473821 ns/op       87078 B/op       2470 allocs/op
+BenchmarkTigerTonic_GithubAll       2000       1120131 ns/op      241088 B/op       6052 allocs/op
+BenchmarkTraffic_GithubAll       200       8708979 ns/op     2664762 B/op      22390 allocs/op
+BenchmarkVulcan_GithubAll       5000        353392 ns/op       19894 B/op        609 allocs/op
+BenchmarkZeus_GithubAll     2000        944234 ns/op      300688 B/op       2648 allocs/op
+```
+
+
+##Gin v1. stable
+
+- [x] Zero allocation router.
+- [x] Still the fastest http router and framework. From routing to writing.
+- [x] Complete suite of unit tests
+- [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"
+```
+
+##API Examples
+
+#### Using GET, POST, PUT, PATCH, DELETE and OPTIONS
+
+```go
+func main() {
+	// Creates a gin router with default middlewares:
+	// logger and recovery (crash-free) middlewares
+	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)
+
+	// Listen and server on 0.0.0.0:8080
+	router.Run(":8080")
+}
+```
+
+#### Parameters in path
+
+```go
+func main() {
+	router := gin.Default()
+	
+	// This handler will match /user/john but will not match neither /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/join/
+	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")
+}
+```
+
+#### Querystring parameters
+```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 Form 
+
+```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,
+        })
+    })
+    router.Run(":8080")
+}
+```
+
+#### Grouping routes
+```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")
+}
+```
+
+
+#### Blank Gin without middlewares by default
+
+Use
+
+```go
+r := gin.New()
+```
+instead of
+
+```go
+r := gin.Default()
+```
+
+
+#### Using middlewares
+```go
+func main() {
+	// Creates a router without any middleware by default
+	r := gin.New()
+
+	// Global middlewares
+	r.Use(gin.Logger())
+	r.Use(gin.Recovery())
+
+	// Per route middlewares, you can add as many as you desire.
+	r.GET("/benchmark", MyBenchLogger(), benchEndpoint)
+
+	// Authorization group
+	// authorized := r.Group("/", AuthRequired())
+	// exactly the same than:
+	authorized := r.Group("/")
+	// per group middlewares! 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 server on 0.0.0.0:8080
+	r.Run(":8080")
+}
+```
+
+#### 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).
+
+Note that you need to set the corresponding binding tag on all fields you want to bind. For example, when binding from JSON, set `json:"fieldname"`.
+
+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 BindWith. 
+
+You can also specify that specific fields are required. If a field is decorated with `binding:"required"` and has a empty value when binding, the current request will fail with an error.
+
+```go
+// Binding from JSON
+type LoginJSON struct {
+	User     string `json:"user" binding:"required"`
+	Password string `json:"password" binding:"required"`
+}
+
+// Binding from form values
+type LoginForm struct {
+    User     string `form:"user" binding:"required"`
+    Password string `form:"password" binding:"required"`   
+}
+
+func main() {
+	r := gin.Default()
+
+    // Example for binding JSON ({"user": "manu", "password": "123"})
+	r.POST("/loginJSON", func(c *gin.Context) {
+		var json LoginJSON
+
+        c.Bind(&json) // This will infer what binder to use depending on the content-type header.
+        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"})
+        }
+	})
+
+    // Example for binding a HTML form (user=manu&password=123)
+    r.POST("/loginHTML", func(c *gin.Context) {
+        var form LoginForm
+
+        c.BindWith(&form, binding.Form) // You can also specify which binder to use. We support binding.Form, binding.JSON and binding.XML.
+        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"})
+        }
+    })
+
+	// Listen and server on 0.0.0.0:8080
+	r.Run(":8080")
+}
+```
+
+
+###Multipart/Urlencoded binding 
+```go
+package main
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/gin-gonic/gin/binding"
+)
+
+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.BindWith(&form, binding.Form)
+		// or you can simply use autobinding with Bind method:
+		var form LoginForm
+		c.Bind(&form) // in this case proper binding will be automatically selected
+
+		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:
+```bash
+$ curl -v --form user=user --form password=password http://localhost:8080/login
+```
+
+
+#### XML and JSON rendering
+
+```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})
+	})
+
+	// Listen and server on 0.0.0.0:8080
+	r.Run(":8080")
+}
+```
+
+####Serving static files
+
+```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 server on 0.0.0.0:8080
+    router.Run(":8080")
+}
+```
+
+####HTML rendering
+
+Using LoadHTMLTemplates()
+
+```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")
+}
+```
+```html
+<html><h1>
+	{{ .title }}
+</h1>
+</html>
+```
+
+You can also use your own html template render
+
+```go
+import "html/template"
+
+func main() {
+	router := gin.Default()
+	html := template.Must(template.ParseFiles("file1", "file2"))
+	router.SetHTMLTemplate(html)
+	router.Run(":8080")
+}
+```
+
+
+#### Redirects
+
+Issuing a HTTP redirect is easy:
+
+```go
+r.GET("/test", func(c *gin.Context) {
+	c.Redirect(http.StatusMovedPermanently, "http://www.google.com/")
+})
+```
+Both internal and external locations are supported.
+
+
+#### Custom Middlewares
+
+```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 server on 0.0.0.0:8080
+	r.Run(":8080")
+}
+```
+
+#### Using BasicAuth() middleware
+```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 setted 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 server on 0.0.0.0:8080
+	r.Run(":8080")
+}
+```
+
+
+#### Goroutines inside a middleware
+When starting inside a middleware or handler, you **SHOULD NOT** use the original context inside it, you have to use a read-only copy.
+
+```go
+func main() {
+	r := gin.Default()
+
+	r.GET("/long_async", func(c *gin.Context) {
+		// create copy to be used inside the goroutine
+		c_cp := c.Copy()
+		go func() {
+			// simulate a long task with time.Sleep(). 5 seconds
+			time.Sleep(5 * time.Second)
+
+			// note than you are using the copied context "c_cp", IMPORTANT
+			log.Println("Done! in path " + c_cp.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 server on 0.0.0.0:8080
+    r.Run(":8080")
+}
+```
+
+#### Custom HTTP configuration
+
+Use `http.ListenAndServe()` directly, like this:
+
+```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()
+}
+```
diff --git a/vendor/github.com/gin-gonic/gin/auth.go b/vendor/github.com/gin-gonic/gin/auth.go
new file mode 100644
index 0000000..33f8e9a
--- /dev/null
+++ b/vendor/github.com/gin-gonic/gin/auth.go
@@ -0,0 +1,98 @@
+// Copyright 2014 Manu Martinez-Almeida.  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 (
+	"crypto/subtle"
+	"encoding/base64"
+	"strconv"
+)
+
+const (
+	AuthUserKey = "user"
+)
+
+type (
+	Accounts map[string]string
+	authPair struct {
+		Value string
+		User  string
+	}
+	authPairs []authPair
+)
+
+func (a authPairs) searchCredential(authValue string) (string, bool) {
+	if len(authValue) == 0 {
+		return "", false
+	}
+	for _, pair := range a {
+		if pair.Value == authValue {
+			return pair.User, true
+		}
+	}
+	return "", false
+}
+
+// Implements a basic Basic HTTP Authorization. It takes as arguments a map[string]string where
+// the key is the user name and the value is the password, as well as the name of the Realm
+// (see http://tools.ietf.org/html/rfc2617#section-1.2)
+func BasicAuthForRealm(accounts Accounts, realm string) HandlerFunc {
+	if realm == "" {
+		realm = "Authorization Required"
+	}
+	realm = "Basic realm=" + strconv.Quote(realm)
+	pairs := processAccounts(accounts)
+	return func(c *Context) {
+		// Search user in the slice of allowed credentials
+		user, found := pairs.searchCredential(c.Request.Header.Get("Authorization"))
+		if !found {
+			// Credentials doesn't match, we return 401 and abort handlers chain.
+			c.Header("WWW-Authenticate", realm)
+			c.AbortWithStatus(401)
+		} else {
+			// The user credentials was found, set user's id to key AuthUserKey in this context, the userId can be read later using
+			// c.MustGet(gin.AuthUserKey)
+			c.Set(AuthUserKey, user)
+		}
+	}
+}
+
+// Implements a basic Basic HTTP Authorization. It takes as argument a map[string]string where
+// the key is the user name and the value is the password.
+func BasicAuth(accounts Accounts) HandlerFunc {
+	return BasicAuthForRealm(accounts, "")
+}
+
+func processAccounts(accounts Accounts) authPairs {
+	if len(accounts) == 0 {
+		panic("Empty list of authorized credentials")
+	}
+	pairs := make(authPairs, 0, len(accounts))
+	for user, password := range accounts {
+		if len(user) == 0 {
+			panic("User can not be empty")
+		}
+		value := authorizationHeader(user, password)
+		pairs = append(pairs, authPair{
+			Value: value,
+			User:  user,
+		})
+	}
+	return pairs
+}
+
+func authorizationHeader(user, password string) string {
+	base := user + ":" + password
+	return "Basic " + base64.StdEncoding.EncodeToString([]byte(base))
+}
+
+func secureCompare(given, actual string) bool {
+	if subtle.ConstantTimeEq(int32(len(given)), int32(len(actual))) == 1 {
+		return subtle.ConstantTimeCompare([]byte(given), []byte(actual)) == 1
+	} else {
+		/* Securely compare actual to itself to keep constant time, but always return false */
+		return subtle.ConstantTimeCompare([]byte(actual), []byte(actual)) == 1 && false
+	}
+}
diff --git a/vendor/github.com/gin-gonic/gin/binding/binding.go b/vendor/github.com/gin-gonic/gin/binding/binding.go
new file mode 100644
index 0000000..f719fbc
--- /dev/null
+++ b/vendor/github.com/gin-gonic/gin/binding/binding.go
@@ -0,0 +1,61 @@
+// Copyright 2014 Manu Martinez-Almeida.  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 "net/http"
+
+const (
+	MIMEJSON              = "application/json"
+	MIMEHTML              = "text/html"
+	MIMEXML               = "application/xml"
+	MIMEXML2              = "text/xml"
+	MIMEPlain             = "text/plain"
+	MIMEPOSTForm          = "application/x-www-form-urlencoded"
+	MIMEMultipartPOSTForm = "multipart/form-data"
+)
+
+type Binding interface {
+	Name() string
+	Bind(*http.Request, interface{}) error
+}
+
+type StructValidator interface {
+	// ValidateStruct can receive any kind of type and it should never panic, even if the configuration is not right.
+	// If the received type is not a struct, any validation should be skipped and nil must be returned.
+	// If the received type is a struct or pointer to a struct, the validation should be performed.
+	// If the struct is not valid or the validation itself fails, a descriptive error should be returned.
+	// Otherwise nil must be returned.
+	ValidateStruct(interface{}) error
+}
+
+var Validator StructValidator = &defaultValidator{}
+
+var (
+	JSON = jsonBinding{}
+	XML  = xmlBinding{}
+	Form = formBinding{}
+)
+
+func Default(method, contentType string) Binding {
+	if method == "GET" {
+		return Form
+	} else {
+		switch contentType {
+		case MIMEJSON:
+			return JSON
+		case MIMEXML, MIMEXML2:
+			return XML
+		default: //case MIMEPOSTForm, MIMEMultipartPOSTForm:
+			return Form
+		}
+	}
+}
+
+func validate(obj interface{}) error {
+	if Validator == nil {
+		return nil
+	}
+	return Validator.ValidateStruct(obj)
+}
diff --git a/vendor/github.com/gin-gonic/gin/binding/default_validator.go b/vendor/github.com/gin-gonic/gin/binding/default_validator.go
new file mode 100644
index 0000000..7f12152
--- /dev/null
+++ b/vendor/github.com/gin-gonic/gin/binding/default_validator.go
@@ -0,0 +1,40 @@
+package binding
+
+import (
+	"reflect"
+	"sync"
+
+	"gopkg.in/bluesuncorp/validator.v5"
+)
+
+type defaultValidator struct {
+	once     sync.Once
+	validate *validator.Validate
+}
+
+var _ StructValidator = &defaultValidator{}
+
+func (v *defaultValidator) ValidateStruct(obj interface{}) error {
+	if kindOfData(obj) == reflect.Struct {
+		v.lazyinit()
+		if err := v.validate.Struct(obj); err != nil {
+			return error(err)
+		}
+	}
+	return nil
+}
+
+func (v *defaultValidator) lazyinit() {
+	v.once.Do(func() {
+		v.validate = validator.New("binding", validator.BakedInValidators)
+	})
+}
+
+func kindOfData(data interface{}) reflect.Kind {
+	value := reflect.ValueOf(data)
+	valueType := value.Kind()
+	if valueType == reflect.Ptr {
+		valueType = value.Elem().Kind()
+	}
+	return valueType
+}
diff --git a/vendor/github.com/gin-gonic/gin/binding/form.go b/vendor/github.com/gin-gonic/gin/binding/form.go
new file mode 100644
index 0000000..ff00b0d
--- /dev/null
+++ b/vendor/github.com/gin-gonic/gin/binding/form.go
@@ -0,0 +1,24 @@
+// Copyright 2014 Manu Martinez-Almeida.  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 "net/http"
+
+type formBinding struct{}
+
+func (_ formBinding) Name() string {
+	return "form"
+}
+
+func (_ formBinding) Bind(req *http.Request, obj interface{}) error {
+	if err := req.ParseForm(); err != nil {
+		return err
+	}
+	req.ParseMultipartForm(32 << 10) // 32 MB
+	if err := mapForm(obj, req.Form); err != nil {
+		return err
+	}
+	return validate(obj)
+}
diff --git a/vendor/github.com/gin-gonic/gin/binding/form_mapping.go b/vendor/github.com/gin-gonic/gin/binding/form_mapping.go
new file mode 100644
index 0000000..d8b13b1
--- /dev/null
+++ b/vendor/github.com/gin-gonic/gin/binding/form_mapping.go
@@ -0,0 +1,151 @@
+// Copyright 2014 Manu Martinez-Almeida.  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 (
+	"errors"
+	"reflect"
+	"strconv"
+)
+
+func mapForm(ptr interface{}, form map[string][]string) error {
+	typ := reflect.TypeOf(ptr).Elem()
+	val := reflect.ValueOf(ptr).Elem()
+	for i := 0; i < typ.NumField(); i++ {
+		typeField := typ.Field(i)
+		structField := val.Field(i)
+		if !structField.CanSet() {
+			continue
+		}
+
+		structFieldKind := structField.Kind()
+		inputFieldName := typeField.Tag.Get("form")
+		if inputFieldName == "" {
+			inputFieldName = typeField.Name
+
+			// if "form" tag is nil, we inspect if the field is a struct.
+			// this would not make sense for JSON parsing but it does for a form
+			// since data is flatten
+			if structFieldKind == reflect.Struct {
+				err := mapForm(structField.Addr().Interface(), form)
+				if err != nil {
+					return err
+				}
+				continue
+			}
+		}
+		inputValue, exists := form[inputFieldName]
+		if !exists {
+			continue
+		}
+
+		numElems := len(inputValue)
+		if structFieldKind == reflect.Slice && numElems > 0 {
+			sliceOf := structField.Type().Elem().Kind()
+			slice := reflect.MakeSlice(structField.Type(), numElems, numElems)
+			for i := 0; i < numElems; i++ {
+				if err := setWithProperType(sliceOf, inputValue[i], slice.Index(i)); err != nil {
+					return err
+				}
+			}
+			val.Field(i).Set(slice)
+		} else {
+			if err := setWithProperType(typeField.Type.Kind(), inputValue[0], structField); err != nil {
+				return err
+			}
+		}
+
+	}
+	return nil
+}
+
+func setWithProperType(valueKind reflect.Kind, val string, structField reflect.Value) error {
+	switch valueKind {
+	case reflect.Int:
+		return setIntField(val, 0, structField)
+	case reflect.Int8:
+		return setIntField(val, 8, structField)
+	case reflect.Int16:
+		return setIntField(val, 16, structField)
+	case reflect.Int32:
+		return setIntField(val, 32, structField)
+	case reflect.Int64:
+		return setIntField(val, 64, structField)
+	case reflect.Uint:
+		return setUintField(val, 0, structField)
+	case reflect.Uint8:
+		return setUintField(val, 8, structField)
+	case reflect.Uint16:
+		return setUintField(val, 16, structField)
+	case reflect.Uint32:
+		return setUintField(val, 32, structField)
+	case reflect.Uint64:
+		return setUintField(val, 64, structField)
+	case reflect.Bool:
+		return setBoolField(val, structField)
+	case reflect.Float32:
+		return setFloatField(val, 32, structField)
+	case reflect.Float64:
+		return setFloatField(val, 64, structField)
+	case reflect.String:
+		structField.SetString(val)
+	default:
+		return errors.New("Unknown type")
+	}
+	return nil
+}
+
+func setIntField(val string, bitSize int, field reflect.Value) error {
+	if val == "" {
+		val = "0"
+	}
+	intVal, err := strconv.ParseInt(val, 10, bitSize)
+	if err == nil {
+		field.SetInt(intVal)
+	}
+	return err
+}
+
+func setUintField(val string, bitSize int, field reflect.Value) error {
+	if val == "" {
+		val = "0"
+	}
+	uintVal, err := strconv.ParseUint(val, 10, bitSize)
+	if err == nil {
+		field.SetUint(uintVal)
+	}
+	return err
+}
+
+func setBoolField(val string, field reflect.Value) error {
+	if val == "" {
+		val = "false"
+	}
+	boolVal, err := strconv.ParseBool(val)
+	if err == nil {
+		field.SetBool(boolVal)
+	}
+	return nil
+}
+
+func setFloatField(val string, bitSize int, field reflect.Value) error {
+	if val == "" {
+		val = "0.0"
+	}
+	floatVal, err := strconv.ParseFloat(val, bitSize)
+	if err == nil {
+		field.SetFloat(floatVal)
+	}
+	return err
+}
+
+// Don't pass in pointers to bind to. Can lead to bugs. See:
+// https://github.com/codegangsta/martini-contrib/issues/40
+// https://github.com/codegangsta/martini-contrib/pull/34#issuecomment-29683659
+func ensureNotPointer(obj interface{}) {
+	if reflect.TypeOf(obj).Kind() == reflect.Ptr {
+		panic("Pointers are not accepted as binding models")
+	}
+}
diff --git a/vendor/github.com/gin-gonic/gin/binding/json.go b/vendor/github.com/gin-gonic/gin/binding/json.go
new file mode 100644
index 0000000..25c5a06
--- /dev/null
+++ b/vendor/github.com/gin-gonic/gin/binding/json.go
@@ -0,0 +1,25 @@
+// Copyright 2014 Manu Martinez-Almeida.  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 (
+	"encoding/json"
+
+	"net/http"
+)
+
+type jsonBinding struct{}
+
+func (_ jsonBinding) Name() string {
+	return "json"
+}
+
+func (_ jsonBinding) Bind(req *http.Request, obj interface{}) error {
+	decoder := json.NewDecoder(req.Body)
+	if err := decoder.Decode(obj); err != nil {
+		return err
+	}
+	return validate(obj)
+}
diff --git a/vendor/github.com/gin-gonic/gin/binding/xml.go b/vendor/github.com/gin-gonic/gin/binding/xml.go
new file mode 100644
index 0000000..cac4be8
--- /dev/null
+++ b/vendor/github.com/gin-gonic/gin/binding/xml.go
@@ -0,0 +1,24 @@
+// Copyright 2014 Manu Martinez-Almeida.  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 (
+	"encoding/xml"
+	"net/http"
+)
+
+type xmlBinding struct{}
+
+func (_ xmlBinding) Name() string {
+	return "xml"
+}
+
+func (_ xmlBinding) Bind(req *http.Request, obj interface{}) error {
+	decoder := xml.NewDecoder(req.Body)
+	if err := decoder.Decode(obj); err != nil {
+		return err
+	}
+	return validate(obj)
+}
diff --git a/vendor/github.com/gin-gonic/gin/context.go b/vendor/github.com/gin-gonic/gin/context.go
new file mode 100644
index 0000000..12920fd
--- /dev/null
+++ b/vendor/github.com/gin-gonic/gin/context.go
@@ -0,0 +1,477 @@
+// Copyright 2014 Manu Martinez-Almeida.  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 (
+	"errors"
+	"io"
+	"math"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/gin-gonic/gin/binding"
+	"github.com/gin-gonic/gin/render"
+	"github.com/manucorporat/sse"
+	"golang.org/x/net/context"
+)
+
+const (
+	MIMEJSON              = binding.MIMEJSON
+	MIMEHTML              = binding.MIMEHTML
+	MIMEXML               = binding.MIMEXML
+	MIMEXML2              = binding.MIMEXML2
+	MIMEPlain             = binding.MIMEPlain
+	MIMEPOSTForm          = binding.MIMEPOSTForm
+	MIMEMultipartPOSTForm = binding.MIMEMultipartPOSTForm
+)
+
+const AbortIndex int8 = math.MaxInt8 / 2
+
+// Context is the most important part of gin. It allows us to pass variables between middleware,
+// manage the flow, validate the JSON of a request and render a JSON response for example.
+type Context struct {
+	writermem responseWriter
+	Request   *http.Request
+	Writer    ResponseWriter
+
+	Params   Params
+	handlers HandlersChain
+	index    int8
+
+	engine   *Engine
+	Keys     map[string]interface{}
+	Errors   errorMsgs
+	Accepted []string
+}
+
+var _ context.Context = &Context{}
+
+/************************************/
+/********** CONTEXT CREATION ********/
+/************************************/
+
+func (c *Context) reset() {
+	c.Writer = &c.writermem
+	c.Params = c.Params[0:0]
+	c.handlers = nil
+	c.index = -1
+	c.Keys = nil
+	c.Errors = c.Errors[0:0]
+	c.Accepted = nil
+}
+
+func (c *Context) Copy() *Context {
+	var cp Context = *c
+	cp.writermem.ResponseWriter = nil
+	cp.Writer = &cp.writermem
+	cp.index = AbortIndex
+	cp.handlers = nil
+	return &cp
+}
+
+func (c *Context) HandlerName() string {
+	return nameOfFunction(c.handlers.Last())
+}
+
+/************************************/
+/*********** FLOW CONTROL ***********/
+/************************************/
+
+// Next should be used only in the middlewares.
+// It executes the pending handlers in the chain inside the calling handler.
+// See example in github.
+func (c *Context) Next() {
+	c.index++
+	s := int8(len(c.handlers))
+	for ; c.index < s; c.index++ {
+		c.handlers[c.index](c)
+	}
+}
+
+// Returns if the currect context was aborted.
+func (c *Context) IsAborted() bool {
+	return c.index == AbortIndex
+}
+
+// Stops the system to continue calling the pending handlers in the chain.
+// Let's say you have an authorization middleware that validates if the request is authorized
+// if the authorization fails (the password does not match). This method (Abort()) should be called
+// in order to stop the execution of the actual handler.
+func (c *Context) Abort() {
+	c.index = AbortIndex
+}
+
+// It calls Abort() and writes the headers with the specified status code.
+// For example, a failed attempt to authentificate a request could use: context.AbortWithStatus(401).
+func (c *Context) AbortWithStatus(code int) {
+	c.Writer.WriteHeader(code)
+	c.Abort()
+}
+
+// It calls AbortWithStatus() and Error() internally. This method stops the chain, writes the status code and
+// pushes the specified error to `c.Errors`.
+// See Context.Error() for more details.
+func (c *Context) AbortWithError(code int, err error) *Error {
+	c.AbortWithStatus(code)
+	return c.Error(err)
+}
+
+/************************************/
+/********* ERROR MANAGEMENT *********/
+/************************************/
+
+// Attaches an error to the current context. The error is pushed to a list of errors.
+// It's a good idea to call Error for each error that occurred during the resolution of a request.
+// A middleware can be used to collect all the errors and push them to a database together, print a log, or append it in the HTTP response.
+func (c *Context) Error(err error) *Error {
+	var parsedError *Error
+	switch err.(type) {
+	case *Error:
+		parsedError = err.(*Error)
+	default:
+		parsedError = &Error{
+			Err:  err,
+			Type: ErrorTypePrivate,
+		}
+	}
+	c.Errors = append(c.Errors, parsedError)
+	return parsedError
+}
+
+/************************************/
+/******** METADATA MANAGEMENT********/
+/************************************/
+
+// Sets a new pair key/value just for this context.
+// It also lazy initializes the hashmap if it was not used previously.
+func (c *Context) Set(key string, value interface{}) {
+	if c.Keys == nil {
+		c.Keys = make(map[string]interface{})
+	}
+	c.Keys[key] = value
+}
+
+// Returns the value for the given key, ie: (value, true).
+// If the value does not exists it returns (nil, false)
+func (c *Context) Get(key string) (value interface{}, exists bool) {
+	if c.Keys != nil {
+		value, exists = c.Keys[key]
+	}
+	return
+}
+
+// Returns the value for the given key if it exists, otherwise it panics.
+func (c *Context) MustGet(key string) interface{} {
+	if value, exists := c.Get(key); exists {
+		return value
+	}
+	panic("Key \"" + key + "\" does not exist")
+}
+
+/************************************/
+/************ INPUT DATA ************/
+/************************************/
+
+// Shortcut for c.Request.URL.Query().Get(key)
+func (c *Context) Query(key string) (va string) {
+	va, _ = c.query(key)
+	return
+}
+
+// Shortcut for c.Request.PostFormValue(key)
+func (c *Context) PostForm(key string) (va string) {
+	va, _ = c.postForm(key)
+	return
+}
+
+// Shortcut for c.Params.ByName(key)
+func (c *Context) Param(key string) string {
+	return c.Params.ByName(key)
+}
+
+func (c *Context) DefaultPostForm(key, defaultValue string) string {
+	if va, ok := c.postForm(key); ok {
+		return va
+	}
+	return defaultValue
+}
+
+func (c *Context) DefaultQuery(key, defaultValue string) string {
+	if va, ok := c.query(key); ok {
+		return va
+	}
+	return defaultValue
+}
+
+func (c *Context) query(key string) (string, bool) {
+	req := c.Request
+	if values, ok := req.URL.Query()[key]; ok && len(values) > 0 {
+		return values[0], true
+	}
+	return "", false
+}
+
+func (c *Context) postForm(key string) (string, bool) {
+	req := c.Request
+	req.ParseMultipartForm(32 << 20) // 32 MB
+	if values := req.PostForm[key]; len(values) > 0 {
+		return values[0], true
+	}
+	if req.MultipartForm != nil && req.MultipartForm.File != nil {
+		if values := req.MultipartForm.Value[key]; len(values) > 0 {
+			return values[0], true
+		}
+	}
+	return "", false
+}
+
+// This function checks the Content-Type to select a binding engine automatically,
+// Depending the "Content-Type" header different bindings are used:
+// "application/json" --> JSON binding
+// "application/xml"  --> XML binding
+// else --> returns an error
+// if Parses the request's body as JSON if Content-Type == "application/json"  using JSON or XML  as a JSON input. It decodes the json payload into the struct specified as a pointer.Like ParseBody() but this method also writes a 400 error if the json is not valid.
+func (c *Context) Bind(obj interface{}) error {
+	b := binding.Default(c.Request.Method, c.ContentType())
+	return c.BindWith(obj, b)
+}
+
+// Shortcut for c.BindWith(obj, binding.JSON)
+func (c *Context) BindJSON(obj interface{}) error {
+	return c.BindWith(obj, binding.JSON)
+}
+
+func (c *Context) BindWith(obj interface{}, b binding.Binding) error {
+	if err := b.Bind(c.Request, obj); err != nil {
+		c.AbortWithError(400, err).SetType(ErrorTypeBind)
+		return err
+	}
+	return nil
+}
+
+// Best effort algoritm to return the real client IP, it parses
+// X-Real-IP and X-Forwarded-For in order to work properly with reverse-proxies such us: nginx or haproxy.
+func (c *Context) ClientIP() string {
+	if c.engine.ForwardedByClientIP {
+		clientIP := strings.TrimSpace(c.requestHeader("X-Real-Ip"))
+		if len(clientIP) > 0 {
+			return clientIP
+		}
+		clientIP = c.requestHeader("X-Forwarded-For")
+		if index := strings.IndexByte(clientIP, ','); index >= 0 {
+			clientIP = clientIP[0:index]
+		}
+		clientIP = strings.TrimSpace(clientIP)
+		if len(clientIP) > 0 {
+			return clientIP
+		}
+	}
+	return strings.TrimSpace(c.Request.RemoteAddr)
+}
+
+func (c *Context) ContentType() string {
+	return filterFlags(c.requestHeader("Content-Type"))
+}
+
+func (c *Context) requestHeader(key string) string {
+	if values, _ := c.Request.Header[key]; len(values) > 0 {
+		return values[0]
+	}
+	return ""
+}
+
+/************************************/
+/******** RESPONSE RENDERING ********/
+/************************************/
+
+// Intelligent shortcut for c.Writer.Header().Set(key, value)
+// it writes a header in the response.
+// If value == "", this method removes the header `c.Writer.Header().Del(key)`
+func (c *Context) Header(key, value string) {
+	if len(value) == 0 {
+		c.Writer.Header().Del(key)
+	} else {
+		c.Writer.Header().Set(key, value)
+	}
+}
+
+func (c *Context) Render(code int, r render.Render) {
+	c.writermem.WriteHeader(code)
+	if err := r.Render(c.Writer); err != nil {
+		c.renderError(err)
+	}
+}
+
+func (c *Context) renderError(err error) {
+	debugPrintError(err)
+	c.AbortWithError(500, err).SetType(ErrorTypeRender)
+}
+
+// Renders the HTTP template specified by its file name.
+// It also updates the HTTP code and sets the Content-Type as "text/html".
+// See http://golang.org/doc/articles/wiki/
+func (c *Context) HTML(code int, name string, obj interface{}) {
+	instance := c.engine.HTMLRender.Instance(name, obj)
+	c.Render(code, instance)
+}
+
+// Serializes the given struct as pretty JSON (indented + endlines) into the response body.
+// It also sets the Content-Type as "application/json".
+// WARNING: we recommend to use this only for development propuses since printing pretty JSON is
+// more CPU and bandwidth consuming. Use Context.JSON() instead.
+func (c *Context) IndentedJSON(code int, obj interface{}) {
+	c.Render(code, render.IndentedJSON{Data: obj})
+}
+
+// Serializes the given struct as JSON into the response body.
+// It also sets the Content-Type as "application/json".
+func (c *Context) JSON(code int, obj interface{}) {
+	c.writermem.WriteHeader(code)
+	if err := render.WriteJSON(c.Writer, obj); err != nil {
+		c.renderError(err)
+	}
+}
+
+// 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{}) {
+	c.Render(code, render.XML{Data: obj})
+}
+
+// Writes the given string into the response body.
+func (c *Context) String(code int, format string, values ...interface{}) {
+	c.writermem.WriteHeader(code)
+	render.WriteString(c.Writer, format, values)
+}
+
+// Returns a HTTP redirect to the specific location.
+func (c *Context) Redirect(code int, location string) {
+	c.Render(-1, render.Redirect{
+		Code:     code,
+		Location: location,
+		Request:  c.Request,
+	})
+}
+
+// Writes some data into the body stream and updates the HTTP code.
+func (c *Context) Data(code int, contentType string, data []byte) {
+	c.Render(code, render.Data{
+		ContentType: contentType,
+		Data:        data,
+	})
+}
+
+// Writes the specified file into the body stream in a efficient way.
+func (c *Context) File(filepath string) {
+	http.ServeFile(c.Writer, c.Request, filepath)
+}
+
+func (c *Context) SSEvent(name string, message interface{}) {
+	c.Render(-1, sse.Event{
+		Event: name,
+		Data:  message,
+	})
+}
+
+func (c *Context) Stream(step func(w io.Writer) bool) {
+	w := c.Writer
+	clientGone := w.CloseNotify()
+	for {
+		select {
+		case <-clientGone:
+			return
+		default:
+			keepopen := step(w)
+			w.Flush()
+			if !keepopen {
+				return
+			}
+		}
+	}
+}
+
+/************************************/
+/******** CONTENT NEGOTIATION *******/
+/************************************/
+
+type Negotiate struct {
+	Offered  []string
+	HTMLName string
+	HTMLData interface{}
+	JSONData interface{}
+	XMLData  interface{}
+	Data     interface{}
+}
+
+func (c *Context) Negotiate(code int, config Negotiate) {
+	switch c.NegotiateFormat(config.Offered...) {
+	case binding.MIMEJSON:
+		data := chooseData(config.JSONData, config.Data)
+		c.JSON(code, data)
+
+	case binding.MIMEHTML:
+		data := chooseData(config.HTMLData, config.Data)
+		c.HTML(code, config.HTMLName, data)
+
+	case binding.MIMEXML:
+		data := chooseData(config.XMLData, config.Data)
+		c.XML(code, data)
+
+	default:
+		c.AbortWithError(http.StatusNotAcceptable, errors.New("the accepted formats are not offered by the server"))
+	}
+}
+
+func (c *Context) NegotiateFormat(offered ...string) string {
+	if len(offered) == 0 {
+		panic("you must provide at least one offer")
+	}
+	if c.Accepted == nil {
+		c.Accepted = parseAccept(c.requestHeader("Accept"))
+	}
+	if len(c.Accepted) == 0 {
+		return offered[0]
+	}
+	for _, accepted := range c.Accepted {
+		for _, offert := range offered {
+			if accepted == offert {
+				return offert
+			}
+		}
+	}
+	return ""
+}
+
+func (c *Context) SetAccepted(formats ...string) {
+	c.Accepted = formats
+}
+
+/************************************/
+/***** GOLANG.ORG/X/NET/CONTEXT *****/
+/************************************/
+
+func (c *Context) Deadline() (deadline time.Time, ok bool) {
+	return
+}
+
+func (c *Context) Done() <-chan struct{} {
+	return nil
+}
+
+func (c *Context) Err() error {
+	return nil
+}
+
+func (c *Context) Value(key interface{}) interface{} {
+	if key == 0 {
+		return c.Request
+	}
+	if keyAsString, ok := key.(string); ok {
+		val, _ := c.Get(keyAsString)
+		return val
+	}
+	return nil
+}
diff --git a/vendor/github.com/gin-gonic/gin/debug.go b/vendor/github.com/gin-gonic/gin/debug.go
new file mode 100644
index 0000000..2f4b101
--- /dev/null
+++ b/vendor/github.com/gin-gonic/gin/debug.go
@@ -0,0 +1,52 @@
+// Copyright 2014 Manu Martinez-Almeida.  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 "log"
+
+func init() {
+	log.SetFlags(0)
+}
+func IsDebugging() bool {
+	return ginMode == debugCode
+}
+
+func debugPrintRoute(httpMethod, absolutePath string, handlers HandlersChain) {
+	if IsDebugging() {
+		nuHandlers := len(handlers)
+		handlerName := nameOfFunction(handlers.Last())
+		debugPrint("%-5s %-25s --> %s (%d handlers)\n", httpMethod, absolutePath, handlerName, nuHandlers)
+	}
+}
+
+func debugPrint(format string, values ...interface{}) {
+	if IsDebugging() {
+		log.Printf("[GIN-debug] "+format, values...)
+	}
+}
+
+func debugPrintWARNING_New() {
+	debugPrint(`[WARNING] Running in "debug" mode. Switch to "release" mode in production.
+ - using env:	export GIN_MODE=release
+ - using code:	gin.SetMode(gin.ReleaseMode)
+
+`)
+}
+
+func debugPrintWARNING_SetHTMLTemplate() {
+	debugPrint(`[WARNING] Since SetHTMLTemplate() is NOT thread-safe. It should only be called
+at initialization. ie. before any route is registered or the router is listening in a socket:
+
+	router := gin.Default()
+	router.SetHTMLTemplate(template) // << good place
+
+`)
+}
+
+func debugPrintError(err error) {
+	if err != nil {
+		debugPrint("[ERROR] %v\n", err)
+	}
+}
diff --git a/vendor/github.com/gin-gonic/gin/deprecated.go b/vendor/github.com/gin-gonic/gin/deprecated.go
new file mode 100644
index 0000000..b2e874f
--- /dev/null
+++ b/vendor/github.com/gin-gonic/gin/deprecated.go
@@ -0,0 +1,5 @@
+// Copyright 2014 Manu Martinez-Almeida.  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
diff --git a/vendor/github.com/gin-gonic/gin/errors.go b/vendor/github.com/gin-gonic/gin/errors.go
new file mode 100644
index 0000000..982c026
--- /dev/null
+++ b/vendor/github.com/gin-gonic/gin/errors.go
@@ -0,0 +1,161 @@
+// Copyright 2014 Manu Martinez-Almeida.  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 (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"reflect"
+)
+
+type ErrorType uint64
+
+const (
+	ErrorTypeBind    ErrorType = 1 << 63 // used when c.Bind() fails
+	ErrorTypeRender  ErrorType = 1 << 62 // used when c.Render() fails
+	ErrorTypePrivate ErrorType = 1 << 0
+	ErrorTypePublic  ErrorType = 1 << 1
+
+	ErrorTypeAny ErrorType = 1<<64 - 1
+	ErrorTypeNu            = 2
+)
+
+type (
+	Error struct {
+		Err  error
+		Type ErrorType
+		Meta interface{}
+	}
+
+	errorMsgs []*Error
+)
+
+var _ error = &Error{}
+
+func (msg *Error) SetType(flags ErrorType) *Error {
+	msg.Type = flags
+	return msg
+}
+
+func (msg *Error) SetMeta(data interface{}) *Error {
+	msg.Meta = data
+	return msg
+}
+
+func (msg *Error) JSON() interface{} {
+	json := H{}
+	if msg.Meta != nil {
+		value := reflect.ValueOf(msg.Meta)
+		switch value.Kind() {
+		case reflect.Struct:
+			return msg.Meta
+		case reflect.Map:
+			for _, key := range value.MapKeys() {
+				json[key.String()] = value.MapIndex(key).Interface()
+			}
+		default:
+			json["meta"] = msg.Meta
+		}
+	}
+	if _, ok := json["error"]; !ok {
+		json["error"] = msg.Error()
+	}
+	return json
+}
+
+// Implements the json.Marshaller interface
+func (msg *Error) MarshalJSON() ([]byte, error) {
+	return json.Marshal(msg.JSON())
+}
+
+// Implements the error interface
+func (msg *Error) Error() string {
+	return msg.Err.Error()
+}
+
+func (msg *Error) IsType(flags ErrorType) bool {
+	return (msg.Type & flags) > 0
+}
+
+// Returns a readonly copy filterd the byte.
+// ie ByType(gin.ErrorTypePublic) returns a slice of errors with type=ErrorTypePublic
+func (a errorMsgs) ByType(typ ErrorType) errorMsgs {
+	if len(a) == 0 {
+		return nil
+	}
+	if typ == ErrorTypeAny {
+		return a
+	}
+	var result errorMsgs = nil
+	for _, msg := range a {
+		if msg.IsType(typ) {
+			result = append(result, msg)
+		}
+	}
+	return result
+}
+
+// Returns the last error in the slice. It returns nil if the array is empty.
+// Shortcut for errors[len(errors)-1]
+func (a errorMsgs) Last() *Error {
+	length := len(a)
+	if length == 0 {
+		return nil
+	}
+	return a[length-1]
+}
+
+// Returns an array will all the error messages.
+// Example
+// ```
+// c.Error(errors.New("first"))
+// c.Error(errors.New("second"))
+// c.Error(errors.New("third"))
+// c.Errors.Errors() // == []string{"first", "second", "third"}
+// ``
+func (a errorMsgs) Errors() []string {
+	if len(a) == 0 {
+		return nil
+	}
+	errorStrings := make([]string, len(a))
+	for i, err := range a {
+		errorStrings[i] = err.Error()
+	}
+	return errorStrings
+}
+
+func (a errorMsgs) JSON() interface{} {
+	switch len(a) {
+	case 0:
+		return nil
+	case 1:
+		return a.Last().JSON()
+	default:
+		json := make([]interface{}, len(a))
+		for i, err := range a {
+			json[i] = err.JSON()
+		}
+		return json
+	}
+}
+
+func (a errorMsgs) MarshalJSON() ([]byte, error) {
+	return json.Marshal(a.JSON())
+}
+
+func (a errorMsgs) String() string {
+	if len(a) == 0 {
+		return ""
+	}
+	var buffer bytes.Buffer
+	for i, msg := range a {
+		fmt.Fprintf(&buffer, "Error #%02d: %s\n", (i + 1), msg.Err)
+		if msg.Meta != nil {
+			fmt.Fprintf(&buffer, "     Meta: %v\n", msg.Meta)
+		}
+	}
+	return buffer.String()
+}
diff --git a/vendor/github.com/gin-gonic/gin/fs.go b/vendor/github.com/gin-gonic/gin/fs.go
new file mode 100644
index 0000000..f95dc84
--- /dev/null
+++ b/vendor/github.com/gin-gonic/gin/fs.go
@@ -0,0 +1,43 @@
+package gin
+
+import (
+	"net/http"
+	"os"
+)
+
+type (
+	onlyfilesFS struct {
+		fs http.FileSystem
+	}
+	neuteredReaddirFile struct {
+		http.File
+	}
+)
+
+// It returns a http.Filesystem that can be used by http.FileServer(). It is used interally
+// in router.Static().
+// if listDirectory == true, then it works the same as http.Dir() otherwise it returns
+// a filesystem that prevents http.FileServer() to list the directory files.
+func Dir(root string, listDirectory bool) http.FileSystem {
+	fs := http.Dir(root)
+	if listDirectory {
+		return fs
+	} else {
+		return &onlyfilesFS{fs}
+	}
+}
+
+// Conforms to http.Filesystem
+func (fs onlyfilesFS) Open(name string) (http.File, error) {
+	f, err := fs.fs.Open(name)
+	if err != nil {
+		return nil, err
+	}
+	return neuteredReaddirFile{f}, nil
+}
+
+// Overrides the http.File default implementation
+func (f neuteredReaddirFile) Readdir(count int) ([]os.FileInfo, error) {
+	// this disables directory listing
+	return nil, nil
+}
diff --git a/vendor/github.com/gin-gonic/gin/gin.go b/vendor/github.com/gin-gonic/gin/gin.go
new file mode 100644
index 0000000..7b0ede1
--- /dev/null
+++ b/vendor/github.com/gin-gonic/gin/gin.go
@@ -0,0 +1,369 @@
+// Copyright 2014 Manu Martinez-Almeida.  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 (
+	"html/template"
+	"net"
+	"net/http"
+	"os"
+	"sync"
+
+	"github.com/gin-gonic/gin/render"
+)
+
+const Version = "v1.0rc2"
+
+var default404Body = []byte("404 page not found")
+var default405Body = []byte("405 method not allowed")
+
+type HandlerFunc func(*Context)
+type HandlersChain []HandlerFunc
+
+func (c HandlersChain) Last() HandlerFunc {
+	length := len(c)
+	if length > 0 {
+		return c[length-1]
+	}
+	return nil
+}
+
+type (
+	RoutesInfo []RouteInfo
+	RouteInfo  struct {
+		Method  string
+		Path    string
+		Handler string
+	}
+
+	// Represents the web framework, it wraps the blazing fast httprouter multiplexer and a list of global middlewares.
+	Engine struct {
+		RouterGroup
+		HTMLRender  render.HTMLRender
+		allNoRoute  HandlersChain
+		allNoMethod HandlersChain
+		noRoute     HandlersChain
+		noMethod    HandlersChain
+		pool        sync.Pool
+		trees       methodTrees
+
+		// Enables automatic redirection if the current route can't be matched but a
+		// handler for the path with (without) the trailing slash exists.
+		// For example if /foo/ is requested but a route only exists for /foo, the
+		// client is redirected to /foo with http status code 301 for GET requests
+		// and 307 for all other request methods.
+		RedirectTrailingSlash bool
+
+		// If enabled, the router tries to fix the current request path, if no
+		// handle is registered for it.
+		// First superfluous path elements like ../ or // are removed.
+		// Afterwards the router does a case-insensitive lookup of the cleaned path.
+		// If a handle can be found for this route, the router makes a redirection
+		// to the corrected path with status code 301 for GET requests and 307 for
+		// all other request methods.
+		// For example /FOO and /..//Foo could be redirected to /foo.
+		// RedirectTrailingSlash is independent of this option.
+		RedirectFixedPath bool
+
+		// If enabled, the router checks if another method is allowed for the
+		// current route, if the current request can not be routed.
+		// If this is the case, the request is answered with 'Method Not Allowed'
+		// and HTTP status code 405.
+		// If no other Method is allowed, the request is delegated to the NotFound
+		// handler.
+		HandleMethodNotAllowed bool
+		ForwardedByClientIP    bool
+	}
+)
+
+var _ RoutesInterface = &Engine{}
+
+// Returns a new blank Engine instance without any middleware attached.
+// The most basic configuration
+func New() *Engine {
+	debugPrintWARNING_New()
+	engine := &Engine{
+		RouterGroup: RouterGroup{
+			Handlers: nil,
+			BasePath: "/",
+			root:     true,
+		},
+		RedirectTrailingSlash:  true,
+		RedirectFixedPath:      false,
+		HandleMethodNotAllowed: false,
+		ForwardedByClientIP:    true,
+		trees:                  make(methodTrees, 0, 9),
+	}
+	engine.RouterGroup.engine = engine
+	engine.pool.New = func() interface{} {
+		return engine.allocateContext()
+	}
+	return engine
+}
+
+// Returns a Engine instance with the Logger and Recovery already attached.
+func Default() *Engine {
+	engine := New()
+	engine.Use(Recovery(), Logger())
+	return engine
+}
+
+func (engine *Engine) allocateContext() *Context {
+	return &Context{engine: engine}
+}
+
+func (engine *Engine) LoadHTMLGlob(pattern string) {
+	if IsDebugging() {
+		engine.HTMLRender = render.HTMLDebug{Glob: pattern}
+	} else {
+		templ := template.Must(template.ParseGlob(pattern))
+		engine.SetHTMLTemplate(templ)
+	}
+}
+
+func (engine *Engine) LoadHTMLFiles(files ...string) {
+	if IsDebugging() {
+		engine.HTMLRender = render.HTMLDebug{Files: files}
+	} else {
+		templ := template.Must(template.ParseFiles(files...))
+		engine.SetHTMLTemplate(templ)
+	}
+}
+
+func (engine *Engine) SetHTMLTemplate(templ *template.Template) {
+	if len(engine.trees) > 0 {
+		debugPrintWARNING_SetHTMLTemplate()
+	}
+	engine.HTMLRender = render.HTMLProduction{Template: templ}
+}
+
+// Adds handlers for NoRoute. It return a 404 code by default.
+func (engine *Engine) NoRoute(handlers ...HandlerFunc) {
+	engine.noRoute = handlers
+	engine.rebuild404Handlers()
+}
+
+// Sets the handlers called when... TODO
+func (engine *Engine) NoMethod(handlers ...HandlerFunc) {
+	engine.noMethod = handlers
+	engine.rebuild405Handlers()
+}
+
+// Attachs a global middleware to the router. ie. the middlewares attached though Use() will be
+// included in the handlers chain for every single request. Even 404, 405, static files...
+// For example, this is the right place for a logger or error management middleware.
+func (engine *Engine) Use(middlewares ...HandlerFunc) routesInterface {
+	engine.RouterGroup.Use(middlewares...)
+	engine.rebuild404Handlers()
+	engine.rebuild405Handlers()
+	return engine
+}
+
+func (engine *Engine) rebuild404Handlers() {
+	engine.allNoRoute = engine.combineHandlers(engine.noRoute)
+}
+
+func (engine *Engine) rebuild405Handlers() {
+	engine.allNoMethod = engine.combineHandlers(engine.noMethod)
+}
+
+func (engine *Engine) addRoute(method, path string, handlers HandlersChain) {
+	debugPrintRoute(method, path, handlers)
+
+	if path[0] != '/' {
+		panic("path must begin with '/'")
+	}
+	if method == "" {
+		panic("HTTP method can not be empty")
+	}
+	if len(handlers) == 0 {
+		panic("there must be at least one handler")
+	}
+
+	root := engine.trees.get(method)
+	if root == nil {
+		root = new(node)
+		engine.trees = append(engine.trees, methodTree{
+			method: method,
+			root:   root,
+		})
+	}
+	root.addRoute(path, handlers)
+}
+
+func (engine *Engine) Routes() (routes RoutesInfo) {
+	for _, tree := range engine.trees {
+		routes = iterate("", tree.method, routes, tree.root)
+	}
+	return routes
+}
+
+func iterate(path, method string, routes RoutesInfo, root *node) RoutesInfo {
+	path += root.path
+	if len(root.handlers) > 0 {
+		routes = append(routes, RouteInfo{
+			Method:  method,
+			Path:    path,
+			Handler: nameOfFunction(root.handlers.Last()),
+		})
+	}
+	for _, node := range root.children {
+		routes = iterate(path, method, routes, node)
+	}
+	return routes
+}
+
+// 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.
+func (engine *Engine) Run(addr string) (err error) {
+	debugPrint("Listening and serving HTTP on %s\n", addr)
+	defer func() { debugPrintError(err) }()
+
+	err = http.ListenAndServe(addr, engine)
+	return
+}
+
+// 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 (engine *Engine) RunTLS(addr string, certFile string, keyFile string) (err error) {
+	debugPrint("Listening and serving HTTPS on %s\n", addr)
+	defer func() { debugPrintError(err) }()
+
+	err = http.ListenAndServeTLS(addr, certFile, keyFile, engine)
+	return
+}
+
+// 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.
+func (engine *Engine) RunUnix(file string) (err error) {
+	debugPrint("Listening and serving HTTP on unix:/%s", file)
+	defer func() { debugPrintError(err) }()
+
+	os.Remove(file)
+	listener, err := net.Listen("unix", file)
+	if err != nil {
+		return
+	}
+	defer listener.Close()
+	err = http.Serve(listener, engine)
+	return
+}
+
+// Conforms to the http.Handler interface.
+func (engine *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) {
+	c := engine.pool.Get().(*Context)
+	c.writermem.reset(w)
+	c.Request = req
+	c.reset()
+
+	engine.handleHTTPRequest(c)
+
+	engine.pool.Put(c)
+}
+
+func (engine *Engine) handleHTTPRequest(context *Context) {
+	httpMethod := context.Request.Method
+	path := context.Request.URL.Path
+
+	// 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, context.Params)
+			if handlers != nil {
+				context.handlers = handlers
+				context.Params = params
+				context.Next()
+				context.writermem.WriteHeaderNow()
+				return
+
+			} else if httpMethod != "CONNECT" && path != "/" {
+				if tsr && engine.RedirectFixedPath {
+					redirectTrailingSlash(context)
+					return
+				}
+				if engine.RedirectFixedPath && redirectFixedPath(context, root, engine.RedirectFixedPath) {
+					return
+				}
+			}
+			break
+		}
+	}
+
+	// TODO: unit test
+	if engine.HandleMethodNotAllowed {
+		for _, tree := range engine.trees {
+			if tree.method != httpMethod {
+				if handlers, _, _ := tree.root.getValue(path, nil); handlers != nil {
+					context.handlers = engine.allNoMethod
+					serveError(context, 405, default405Body)
+					return
+				}
+			}
+		}
+	}
+	context.handlers = engine.allNoRoute
+	serveError(context, 404, default404Body)
+}
+
+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()
+		}
+	}
+}
+
+func redirectTrailingSlash(c *Context) {
+	req := c.Request
+	path := req.URL.Path
+	code := 301 // Permanent redirect, request with GET method
+	if req.Method != "GET" {
+		code = 307
+	}
+
+	if len(path) > 1 && path[len(path)-1] == '/' {
+		req.URL.Path = path[:len(path)-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)
+	c.writermem.WriteHeaderNow()
+}
+
+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 {
+		code := 301 // Permanent redirect, request with GET method
+		if req.Method != "GET" {
+			code = 307
+		}
+		req.URL.Path = string(fixedPath)
+		debugPrint("redirecting request %d: %s --> %s", code, path, req.URL.String())
+		http.Redirect(c.Writer, req, req.URL.String(), code)
+		c.writermem.WriteHeaderNow()
+		return true
+	}
+	return false
+}
diff --git a/vendor/github.com/gin-gonic/gin/logger.go b/vendor/github.com/gin-gonic/gin/logger.go
new file mode 100644
index 0000000..e0f9b36
--- /dev/null
+++ b/vendor/github.com/gin-gonic/gin/logger.go
@@ -0,0 +1,113 @@
+// Copyright 2014 Manu Martinez-Almeida.  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 (
+	"fmt"
+	"io"
+	"time"
+)
+
+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})
+	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})
+	cyan    = string([]byte{27, 91, 57, 55, 59, 52, 54, 109})
+	reset   = string([]byte{27, 91, 48, 109})
+)
+
+func ErrorLogger() HandlerFunc {
+	return ErrorLoggerT(ErrorTypeAny)
+}
+
+func ErrorLoggerT(typ ErrorType) HandlerFunc {
+	return func(c *Context) {
+		c.Next()
+		// avoid writting if we already wrote into the response body
+		if !c.Writer.Written() {
+			errors := c.Errors.ByType(typ)
+			if len(errors) > 0 {
+				c.JSON(-1, errors)
+			}
+		}
+	}
+}
+
+// Instances a Logger middleware that will write the logs to gin.DefaultWriter
+// By default gin.DefaultWriter = os.Stdout
+func Logger() HandlerFunc {
+	return LoggerWithWriter(DefaultWriter)
+}
+
+// Instance a Logger middleware with the specified writter buffer.
+// Example: os.Stdout, a file opened in write mode, a socket...
+func LoggerWithWriter(out io.Writer) HandlerFunc {
+	return func(c *Context) {
+		// Start timer
+		start := time.Now()
+		path := c.Request.URL.Path
+
+		// Process request
+		c.Next()
+
+		// Stop timer
+		end := time.Now()
+		latency := end.Sub(start)
+
+		clientIP := c.ClientIP()
+		method := c.Request.Method
+		statusCode := c.Writer.Status()
+		statusColor := colorForStatus(statusCode)
+		methodColor := colorForMethod(method)
+		comment := c.Errors.ByType(ErrorTypePrivate).String()
+
+		fmt.Fprintf(out, "[GIN] %v |%s %3d %s| %13v | %s |%s  %s %-7s %s\n%s",
+			end.Format("2006/01/02 - 15:04:05"),
+			statusColor, statusCode, reset,
+			latency,
+			clientIP,
+			methodColor, reset, method,
+			path,
+			comment,
+		)
+	}
+}
+
+func colorForStatus(code int) string {
+	switch {
+	case code >= 200 && code < 300:
+		return green
+	case code >= 300 && code < 400:
+		return white
+	case code >= 400 && code < 500:
+		return yellow
+	default:
+		return red
+	}
+}
+
+func colorForMethod(method string) string {
+	switch method {
+	case "GET":
+		return blue
+	case "POST":
+		return cyan
+	case "PUT":
+		return yellow
+	case "DELETE":
+		return red
+	case "PATCH":
+		return green
+	case "HEAD":
+		return magenta
+	case "OPTIONS":
+		return white
+	default:
+		return reset
+	}
+}
diff --git a/vendor/github.com/gin-gonic/gin/mode.go b/vendor/github.com/gin-gonic/gin/mode.go
new file mode 100644
index 0000000..15efaeb
--- /dev/null
+++ b/vendor/github.com/gin-gonic/gin/mode.go
@@ -0,0 +1,61 @@
+// Copyright 2014 Manu Martinez-Almeida.  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 (
+	"io"
+	"os"
+
+	"github.com/gin-gonic/gin/binding"
+	"github.com/mattn/go-colorable"
+)
+
+const ENV_GIN_MODE = "GIN_MODE"
+
+const (
+	DebugMode   string = "debug"
+	ReleaseMode string = "release"
+	TestMode    string = "test"
+)
+const (
+	debugCode   = iota
+	releaseCode = iota
+	testCode    = iota
+)
+
+var DefaultWriter io.Writer = colorable.NewColorableStdout()
+var ginMode int = debugCode
+var modeName string = DebugMode
+
+func init() {
+	mode := os.Getenv(ENV_GIN_MODE)
+	if len(mode) == 0 {
+		SetMode(DebugMode)
+	} else {
+		SetMode(mode)
+	}
+}
+
+func SetMode(value string) {
+	switch value {
+	case DebugMode:
+		ginMode = debugCode
+	case ReleaseMode:
+		ginMode = releaseCode
+	case TestMode:
+		ginMode = testCode
+	default:
+		panic("gin mode unknown: " + value)
+	}
+	modeName = value
+}
+
+func DisableBindValidation() {
+	binding.Validator = nil
+}
+
+func Mode() string {
+	return modeName
+}
diff --git a/vendor/github.com/gin-gonic/gin/path.go b/vendor/github.com/gin-gonic/gin/path.go
new file mode 100644
index 0000000..43cdd04
--- /dev/null
+++ b/vendor/github.com/gin-gonic/gin/path.go
@@ -0,0 +1,123 @@
+// Copyright 2013 Julien Schmidt. All rights reserved.
+// Based on the path package, Copyright 2009 The Go Authors.
+// Use of this source code is governed by a BSD-style license that can be found
+// in the LICENSE file.
+
+package gin
+
+// CleanPath is the URL version of path.Clean, it returns a canonical URL path
+// for p, eliminating . and .. elements.
+//
+// The following rules are applied iteratively until no further processing can
+// be done:
+//	1. Replace multiple slashes with a single slash.
+//	2. Eliminate each . path name element (the current directory).
+//	3. Eliminate each inner .. path name element (the parent directory)
+//	   along with the non-.. element that precedes it.
+//	4. Eliminate .. elements that begin a rooted path:
+//	   that is, replace "/.." by "/" at the beginning of a path.
+//
+// If the result of this process is an empty string, "/" is returned
+func cleanPath(p string) string {
+	// Turn empty string into "/"
+	if p == "" {
+		return "/"
+	}
+
+	n := len(p)
+	var buf []byte
+
+	// Invariants:
+	//      reading from path; r is index of next byte to process.
+	//      writing to buf; w is index of next byte to write.
+
+	// path must start with '/'
+	r := 1
+	w := 1
+
+	if p[0] != '/' {
+		r = 0
+		buf = make([]byte, n+1)
+		buf[0] = '/'
+	}
+
+	trailing := n > 2 && 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
+	// loop has no expensive function calls (except 1x make)
+
+	for r < n {
+		switch {
+		case p[r] == '/':
+			// empty path element, trailing slash is added after the end
+			r++
+
+		case p[r] == '.' && r+1 == n:
+			trailing = true
+			r++
+
+		case p[r] == '.' && p[r+1] == '/':
+			// . element
+			r++
+
+		case p[r] == '.' && p[r+1] == '.' && (r+2 == n || p[r+2] == '/'):
+			// .. element: remove to last /
+			r += 2
+
+			if w > 1 {
+				// can backtrack
+				w--
+
+				if buf == nil {
+					for w > 1 && p[w] != '/' {
+						w--
+					}
+				} else {
+					for w > 1 && buf[w] != '/' {
+						w--
+					}
+				}
+			}
+
+		default:
+			// real path element.
+			// add slash if needed
+			if w > 1 {
+				bufApp(&buf, p, w, '/')
+				w++
+			}
+
+			// copy element
+			for r < n && p[r] != '/' {
+				bufApp(&buf, p, w, p[r])
+				w++
+				r++
+			}
+		}
+	}
+
+	// re-append trailing slash
+	if trailing && w > 1 {
+		bufApp(&buf, p, w, '/')
+		w++
+	}
+
+	if buf == nil {
+		return p[:w]
+	}
+	return string(buf[:w])
+}
+
+// internal helper to lazily create a buffer if necessary
+func bufApp(buf *[]byte, s string, w int, c byte) {
+	if *buf == nil {
+		if s[w] == c {
+			return
+		}
+
+		*buf = make([]byte, len(s))
+		copy(*buf, s[:w])
+	}
+	(*buf)[w] = c
+}
diff --git a/vendor/github.com/gin-gonic/gin/recovery.go b/vendor/github.com/gin-gonic/gin/recovery.go
new file mode 100644
index 0000000..e296e33
--- /dev/null
+++ b/vendor/github.com/gin-gonic/gin/recovery.go
@@ -0,0 +1,106 @@
+// Copyright 2014 Manu Martinez-Almeida.  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 (
+	"bytes"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"log"
+	"runtime"
+)
+
+var (
+	dunno     = []byte("???")
+	centerDot = []byte("·")
+	dot       = []byte(".")
+	slash     = []byte("/")
+)
+
+// Recovery returns a middleware that recovers from any panics and writes a 500 if there was one.
+func Recovery() HandlerFunc {
+	return RecoveryWithWriter(DefaultWriter)
+}
+
+func RecoveryWithWriter(out io.Writer) HandlerFunc {
+	var logger *log.Logger
+	if out != nil {
+		logger = log.New(out, "", log.LstdFlags)
+	}
+	return func(c *Context) {
+		defer func() {
+			if err := recover(); err != nil {
+				if logger != nil {
+					stack := stack(3)
+					logger.Printf("Panic recovery -> %s\n%s\n", err, stack)
+				}
+				c.AbortWithStatus(500)
+			}
+		}()
+		c.Next()
+	}
+}
+
+// stack returns a nicely formated stack frame, skipping skip frames
+func stack(skip int) []byte {
+	buf := new(bytes.Buffer) // the returned data
+	// As we loop, we open files and read them. These variables record the currently
+	// loaded file.
+	var lines [][]byte
+	var lastFile string
+	for i := skip; ; i++ { // Skip the expected number of frames
+		pc, file, line, ok := runtime.Caller(i)
+		if !ok {
+			break
+		}
+		// Print this much at least.  If we can't find the source, it won't show.
+		fmt.Fprintf(buf, "%s:%d (0x%x)\n", file, line, pc)
+		if file != lastFile {
+			data, err := ioutil.ReadFile(file)
+			if err != nil {
+				continue
+			}
+			lines = bytes.Split(data, []byte{'\n'})
+			lastFile = file
+		}
+		fmt.Fprintf(buf, "\t%s: %s\n", function(pc), source(lines, line))
+	}
+	return buf.Bytes()
+}
+
+// source returns a space-trimmed slice of the n'th line.
+func source(lines [][]byte, n int) []byte {
+	n-- // in stack trace, lines are 1-indexed but our array is 0-indexed
+	if n < 0 || n >= len(lines) {
+		return dunno
+	}
+	return bytes.TrimSpace(lines[n])
+}
+
+// function returns, if possible, the name of the function containing the PC.
+func function(pc uintptr) []byte {
+	fn := runtime.FuncForPC(pc)
+	if fn == nil {
+		return dunno
+	}
+	name := []byte(fn.Name())
+	// The name includes the path name to the package, which is unnecessary
+	// since the file name is already included.  Plus, it has center dots.
+	// That is, we see
+	//	runtime/debug.*T·ptrmethod
+	// and want
+	//	*T.ptrmethod
+	// Also the package path might contains dot (e.g. code.google.com/...),
+	// so first eliminate the path prefix
+	if lastslash := bytes.LastIndex(name, slash); lastslash >= 0 {
+		name = name[lastslash+1:]
+	}
+	if period := bytes.Index(name, dot); period >= 0 {
+		name = name[period+1:]
+	}
+	name = bytes.Replace(name, centerDot, dot, -1)
+	return name
+}
diff --git a/vendor/github.com/gin-gonic/gin/render/data.go b/vendor/github.com/gin-gonic/gin/render/data.go
new file mode 100644
index 0000000..efa75d5
--- /dev/null
+++ b/vendor/github.com/gin-gonic/gin/render/data.go
@@ -0,0 +1,20 @@
+// Copyright 2014 Manu Martinez-Almeida.  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"
+
+type Data struct {
+	ContentType string
+	Data        []byte
+}
+
+func (r Data) Render(w http.ResponseWriter) error {
+	if len(r.ContentType) > 0 {
+		w.Header()["Content-Type"] = []string{r.ContentType}
+	}
+	w.Write(r.Data)
+	return nil
+}
diff --git a/vendor/github.com/gin-gonic/gin/render/html.go b/vendor/github.com/gin-gonic/gin/render/html.go
new file mode 100644
index 0000000..01f6bf2
--- /dev/null
+++ b/vendor/github.com/gin-gonic/gin/render/html.go
@@ -0,0 +1,67 @@
+// Copyright 2014 Manu Martinez-Almeida.  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 (
+	"html/template"
+	"net/http"
+)
+
+type (
+	HTMLRender interface {
+		Instance(string, interface{}) Render
+	}
+
+	HTMLProduction struct {
+		Template *template.Template
+	}
+
+	HTMLDebug struct {
+		Files []string
+		Glob  string
+	}
+
+	HTML struct {
+		Template *template.Template
+		Name     string
+		Data     interface{}
+	}
+)
+
+var htmlContentType = []string{"text/html; charset=utf-8"}
+
+func (r HTMLProduction) Instance(name string, data interface{}) Render {
+	return HTML{
+		Template: r.Template,
+		Name:     name,
+		Data:     data,
+	}
+}
+
+func (r HTMLDebug) Instance(name string, data interface{}) Render {
+	return HTML{
+		Template: r.loadTemplate(),
+		Name:     name,
+		Data:     data,
+	}
+}
+func (r HTMLDebug) loadTemplate() *template.Template {
+	if len(r.Files) > 0 {
+		return template.Must(template.ParseFiles(r.Files...))
+	}
+	if len(r.Glob) > 0 {
+		return template.Must(template.ParseGlob(r.Glob))
+	}
+	panic("the HTML debug render was created without files or glob pattern")
+}
+
+func (r HTML) Render(w http.ResponseWriter) error {
+	writeContentType(w, htmlContentType)
+	if len(r.Name) == 0 {
+		return r.Template.Execute(w, r.Data)
+	} else {
+		return r.Template.ExecuteTemplate(w, r.Name, r.Data)
+	}
+}
diff --git a/vendor/github.com/gin-gonic/gin/render/json.go b/vendor/github.com/gin-gonic/gin/render/json.go
new file mode 100644
index 0000000..32e6058
--- /dev/null
+++ b/vendor/github.com/gin-gonic/gin/render/json.go
@@ -0,0 +1,41 @@
+// Copyright 2014 Manu Martinez-Almeida.  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 (
+	"encoding/json"
+	"net/http"
+)
+
+type (
+	JSON struct {
+		Data interface{}
+	}
+
+	IndentedJSON struct {
+		Data interface{}
+	}
+)
+
+var jsonContentType = []string{"application/json; charset=utf-8"}
+
+func (r JSON) Render(w http.ResponseWriter) error {
+	return WriteJSON(w, r.Data)
+}
+
+func (r IndentedJSON) Render(w http.ResponseWriter) error {
+	writeContentType(w, jsonContentType)
+	jsonBytes, err := json.MarshalIndent(r.Data, "", "    ")
+	if err != nil {
+		return err
+	}
+	w.Write(jsonBytes)
+	return nil
+}
+
+func WriteJSON(w http.ResponseWriter, obj interface{}) error {
+	writeContentType(w, jsonContentType)
+	return json.NewEncoder(w).Encode(obj)
+}
diff --git a/vendor/github.com/gin-gonic/gin/render/redirect.go b/vendor/github.com/gin-gonic/gin/render/redirect.go
new file mode 100644
index 0000000..d64e4d7
--- /dev/null
+++ b/vendor/github.com/gin-gonic/gin/render/redirect.go
@@ -0,0 +1,24 @@
+// Copyright 2014 Manu Martinez-Almeida.  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 (
+	"fmt"
+	"net/http"
+)
+
+type Redirect struct {
+	Code     int
+	Request  *http.Request
+	Location string
+}
+
+func (r Redirect) Render(w http.ResponseWriter) error {
+	if r.Code < 300 || r.Code > 308 {
+		panic(fmt.Sprintf("Cannot redirect with status code %d", r.Code))
+	}
+	http.Redirect(w, r.Request, r.Location, r.Code)
+	return nil
+}
diff --git a/vendor/github.com/gin-gonic/gin/render/render.go b/vendor/github.com/gin-gonic/gin/render/render.go
new file mode 100644
index 0000000..994fcd7
--- /dev/null
+++ b/vendor/github.com/gin-gonic/gin/render/render.go
@@ -0,0 +1,30 @@
+// Copyright 2014 Manu Martinez-Almeida.  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"
+
+type Render interface {
+	Render(http.ResponseWriter) error
+}
+
+var (
+	_ Render     = JSON{}
+	_ Render     = IndentedJSON{}
+	_ Render     = XML{}
+	_ Render     = String{}
+	_ Render     = Redirect{}
+	_ Render     = Data{}
+	_ Render     = HTML{}
+	_ HTMLRender = HTMLDebug{}
+	_ HTMLRender = HTMLProduction{}
+)
+
+func writeContentType(w http.ResponseWriter, value []string) {
+	header := w.Header()
+	if val := header["Content-Type"]; len(val) == 0 {
+		header["Content-Type"] = value
+	}
+}
diff --git a/vendor/github.com/gin-gonic/gin/render/text.go b/vendor/github.com/gin-gonic/gin/render/text.go
new file mode 100644
index 0000000..5a9e280
--- /dev/null
+++ b/vendor/github.com/gin-gonic/gin/render/text.go
@@ -0,0 +1,33 @@
+// Copyright 2014 Manu Martinez-Almeida.  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 (
+	"fmt"
+	"io"
+	"net/http"
+)
+
+type String struct {
+	Format string
+	Data   []interface{}
+}
+
+var plainContentType = []string{"text/plain; charset=utf-8"}
+
+func (r String) Render(w http.ResponseWriter) error {
+	WriteString(w, r.Format, r.Data)
+	return nil
+}
+
+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)
+	}
+}
diff --git a/vendor/github.com/gin-gonic/gin/render/xml.go b/vendor/github.com/gin-gonic/gin/render/xml.go
new file mode 100644
index 0000000..be22e6f
--- /dev/null
+++ b/vendor/github.com/gin-gonic/gin/render/xml.go
@@ -0,0 +1,21 @@
+// Copyright 2014 Manu Martinez-Almeida.  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 (
+	"encoding/xml"
+	"net/http"
+)
+
+type XML struct {
+	Data interface{}
+}
+
+var xmlContentType = []string{"application/xml; charset=utf-8"}
+
+func (r XML) Render(w http.ResponseWriter) error {
+	writeContentType(w, xmlContentType)
+	return xml.NewEncoder(w).Encode(r.Data)
+}
diff --git a/vendor/github.com/gin-gonic/gin/response_writer.go b/vendor/github.com/gin-gonic/gin/response_writer.go
new file mode 100644
index 0000000..5a75335
--- /dev/null
+++ b/vendor/github.com/gin-gonic/gin/response_writer.go
@@ -0,0 +1,106 @@
+// Copyright 2014 Manu Martinez-Almeida.  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 (
+	"bufio"
+	"io"
+	"net"
+	"net/http"
+)
+
+const (
+	noWritten     = -1
+	defaultStatus = 200
+)
+
+type (
+	ResponseWriter interface {
+		http.ResponseWriter
+		http.Hijacker
+		http.Flusher
+		http.CloseNotifier
+
+		Status() int
+		Size() int
+		WriteString(string) (int, error)
+		Written() bool
+		WriteHeaderNow()
+	}
+
+	responseWriter struct {
+		http.ResponseWriter
+		size   int
+		status int
+	}
+)
+
+var _ ResponseWriter = &responseWriter{}
+
+func (w *responseWriter) reset(writer http.ResponseWriter) {
+	w.ResponseWriter = writer
+	w.size = noWritten
+	w.status = defaultStatus
+}
+
+func (w *responseWriter) WriteHeader(code int) {
+	if code > 0 && w.status != code {
+		if w.Written() {
+			debugPrint("[WARNING] Headers were already written. Wanted to override status code %d with %d", w.status, code)
+		}
+		w.status = code
+	}
+}
+
+func (w *responseWriter) WriteHeaderNow() {
+	if !w.Written() {
+		w.size = 0
+		w.ResponseWriter.WriteHeader(w.status)
+	}
+}
+
+func (w *responseWriter) Write(data []byte) (n int, err error) {
+	w.WriteHeaderNow()
+	n, err = w.ResponseWriter.Write(data)
+	w.size += n
+	return
+}
+
+func (w *responseWriter) WriteString(s string) (n int, err error) {
+	w.WriteHeaderNow()
+	n, err = io.WriteString(w.ResponseWriter, s)
+	w.size += n
+	return
+}
+
+func (w *responseWriter) Status() int {
+	return w.status
+}
+
+func (w *responseWriter) Size() int {
+	return w.size
+}
+
+func (w *responseWriter) Written() bool {
+	return w.size != noWritten
+}
+
+// Implements the http.Hijacker interface
+func (w *responseWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
+	if w.size < 0 {
+		w.size = 0
+	}
+	return w.ResponseWriter.(http.Hijacker).Hijack()
+}
+
+// Implements the http.CloseNotify interface
+func (w *responseWriter) CloseNotify() <-chan bool {
+	return w.ResponseWriter.(http.CloseNotifier).CloseNotify()
+}
+
+// Implements the http.Flush interface
+func (w *responseWriter) Flush() {
+	w.ResponseWriter.(http.Flusher).Flush()
+}
diff --git a/vendor/github.com/gin-gonic/gin/routergroup.go b/vendor/github.com/gin-gonic/gin/routergroup.go
new file mode 100644
index 0000000..b77a55b
--- /dev/null
+++ b/vendor/github.com/gin-gonic/gin/routergroup.go
@@ -0,0 +1,207 @@
+// Copyright 2014 Manu Martinez-Almeida.  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"
+	"path"
+	"regexp"
+	"strings"
+)
+
+type (
+	RoutesInterface interface {
+		routesInterface
+		Group(string, ...HandlerFunc) *RouterGroup
+	}
+
+	routesInterface interface {
+		Use(...HandlerFunc) routesInterface
+
+		Handle(string, string, ...HandlerFunc) routesInterface
+		Any(string, ...HandlerFunc) routesInterface
+		GET(string, ...HandlerFunc) routesInterface
+		POST(string, ...HandlerFunc) routesInterface
+		DELETE(string, ...HandlerFunc) routesInterface
+		PATCH(string, ...HandlerFunc) routesInterface
+		PUT(string, ...HandlerFunc) routesInterface
+		OPTIONS(string, ...HandlerFunc) routesInterface
+		HEAD(string, ...HandlerFunc) routesInterface
+
+		StaticFile(string, string) routesInterface
+		Static(string, string) routesInterface
+		StaticFS(string, http.FileSystem) routesInterface
+	}
+
+	// Used internally to configure router, a RouterGroup is associated with a prefix
+	// and an array of handlers (middlewares)
+	RouterGroup struct {
+		Handlers HandlersChain
+		BasePath string
+		engine   *Engine
+		root     bool
+	}
+)
+
+var _ RoutesInterface = &RouterGroup{}
+
+// Adds middlewares to the group, see example code in github.
+func (group *RouterGroup) Use(middlewares ...HandlerFunc) routesInterface {
+	group.Handlers = append(group.Handlers, middlewares...)
+	return group.returnObj()
+}
+
+// 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.
+func (group *RouterGroup) Group(relativePath string, handlers ...HandlerFunc) *RouterGroup {
+	return &RouterGroup{
+		Handlers: group.combineHandlers(handlers),
+		BasePath: group.calculateAbsolutePath(relativePath),
+		engine:   group.engine,
+	}
+}
+
+// Handle registers a new request handle and middlewares with the given path and method.
+// The last handler should be the real handler, the other ones should be middlewares that can and should be shared among different routes.
+// See the example code in github.
+//
+// For GET, POST, PUT, PATCH and DELETE requests the respective shortcut
+// functions can be used.
+//
+// This function is intended for bulk loading and to allow the usage of less
+// frequently used, non-standardized or custom methods (e.g. for internal
+// communication with a proxy).
+func (group *RouterGroup) handle(httpMethod, relativePath string, handlers HandlersChain) routesInterface {
+	absolutePath := group.calculateAbsolutePath(relativePath)
+	handlers = group.combineHandlers(handlers)
+	group.engine.addRoute(httpMethod, absolutePath, handlers)
+	return group.returnObj()
+}
+
+func (group *RouterGroup) Handle(httpMethod, relativePath string, handlers ...HandlerFunc) routesInterface {
+	if matches, err := regexp.MatchString("^[A-Z]+$", httpMethod); !matches || err != nil {
+		panic("http method " + httpMethod + " is not valid")
+	}
+	return group.handle(httpMethod, relativePath, handlers)
+}
+
+// POST is a shortcut for router.Handle("POST", path, handle)
+func (group *RouterGroup) POST(relativePath string, handlers ...HandlerFunc) routesInterface {
+	return group.handle("POST", relativePath, handlers)
+}
+
+// GET is a shortcut for router.Handle("GET", path, handle)
+func (group *RouterGroup) GET(relativePath string, handlers ...HandlerFunc) routesInterface {
+	return group.handle("GET", relativePath, handlers)
+}
+
+// DELETE is a shortcut for router.Handle("DELETE", path, handle)
+func (group *RouterGroup) DELETE(relativePath string, handlers ...HandlerFunc) routesInterface {
+	return group.handle("DELETE", relativePath, handlers)
+}
+
+// PATCH is a shortcut for router.Handle("PATCH", path, handle)
+func (group *RouterGroup) PATCH(relativePath string, handlers ...HandlerFunc) routesInterface {
+	return group.handle("PATCH", relativePath, handlers)
+}
+
+// PUT is a shortcut for router.Handle("PUT", path, handle)
+func (group *RouterGroup) PUT(relativePath string, handlers ...HandlerFunc) routesInterface {
+	return group.handle("PUT", relativePath, handlers)
+}
+
+// OPTIONS is a shortcut for router.Handle("OPTIONS", path, handle)
+func (group *RouterGroup) OPTIONS(relativePath string, handlers ...HandlerFunc) routesInterface {
+	return group.handle("OPTIONS", relativePath, handlers)
+}
+
+// HEAD is a shortcut for router.Handle("HEAD", path, handle)
+func (group *RouterGroup) HEAD(relativePath string, handlers ...HandlerFunc) routesInterface {
+	return group.handle("HEAD", relativePath, handlers)
+}
+
+func (group *RouterGroup) Any(relativePath string, handlers ...HandlerFunc) routesInterface {
+	// GET, POST, PUT, PATCH, HEAD, OPTIONS, DELETE, CONNECT, TRACE
+	group.handle("GET", relativePath, handlers)
+	group.handle("POST", relativePath, handlers)
+	group.handle("PUT", relativePath, handlers)
+	group.handle("PATCH", relativePath, handlers)
+	group.handle("HEAD", relativePath, handlers)
+	group.handle("OPTIONS", relativePath, handlers)
+	group.handle("DELETE", relativePath, handlers)
+	group.handle("CONNECT", relativePath, handlers)
+	group.handle("TRACE", relativePath, handlers)
+	return group.returnObj()
+}
+
+func (group *RouterGroup) StaticFile(relativePath, filepath string) routesInterface {
+	if strings.Contains(relativePath, ":") || strings.Contains(relativePath, "*") {
+		panic("URL parameters can not be used when serving a static file")
+	}
+	handler := func(c *Context) {
+		c.File(filepath)
+	}
+	group.GET(relativePath, handler)
+	group.HEAD(relativePath, handler)
+	return group.returnObj()
+}
+
+// Static serves files from the given file system root.
+// Internally a http.FileServer is used, therefore http.NotFound is used instead
+// of the Router's NotFound handler.
+// To use the operating system's file system implementation,
+// use :
+//     router.Static("/static", "/var/www")
+func (group *RouterGroup) Static(relativePath, root string) routesInterface {
+	return group.StaticFS(relativePath, Dir(root, false))
+}
+
+func (group *RouterGroup) StaticFS(relativePath string, fs http.FileSystem) routesInterface {
+	if strings.Contains(relativePath, ":") || strings.Contains(relativePath, "*") {
+		panic("URL parameters can not be used when serving a static folder")
+	}
+	handler := group.createStaticHandler(relativePath, fs)
+	urlPattern := path.Join(relativePath, "/*filepath")
+
+	// Register GET and HEAD handlers
+	group.GET(urlPattern, handler)
+	group.HEAD(urlPattern, handler)
+	return group.returnObj()
+}
+
+func (group *RouterGroup) createStaticHandler(relativePath string, fs http.FileSystem) HandlerFunc {
+	absolutePath := group.calculateAbsolutePath(relativePath)
+	fileServer := http.StripPrefix(absolutePath, http.FileServer(fs))
+	_, nolisting := fs.(*onlyfilesFS)
+	return func(c *Context) {
+		if nolisting {
+			c.Writer.WriteHeader(404)
+		}
+		fileServer.ServeHTTP(c.Writer, c.Request)
+	}
+}
+
+func (group *RouterGroup) combineHandlers(handlers HandlersChain) HandlersChain {
+	finalSize := len(group.Handlers) + len(handlers)
+	if finalSize >= int(AbortIndex) {
+		panic("too many handlers")
+	}
+	mergedHandlers := make(HandlersChain, finalSize)
+	copy(mergedHandlers, group.Handlers)
+	copy(mergedHandlers[len(group.Handlers):], handlers)
+	return mergedHandlers
+}
+
+func (group *RouterGroup) calculateAbsolutePath(relativePath string) string {
+	return joinPaths(group.BasePath, relativePath)
+}
+
+func (group *RouterGroup) returnObj() routesInterface {
+	if group.root {
+		return group.engine
+	} else {
+		return group
+	}
+}
diff --git a/vendor/github.com/gin-gonic/gin/tree.go b/vendor/github.com/gin-gonic/gin/tree.go
new file mode 100644
index 0000000..c87e0d8
--- /dev/null
+++ b/vendor/github.com/gin-gonic/gin/tree.go
@@ -0,0 +1,596 @@
+// Copyright 2013 Julien Schmidt. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be found
+// in the LICENSE file.
+
+package gin
+
+import (
+	"strings"
+	"unicode"
+)
+
+// Param is a single URL parameter, consisting of a key and a value.
+type Param struct {
+	Key   string
+	Value string
+}
+
+// Params is a Param-slice, as returned by the router.
+// The slice is ordered, the first URL parameter is also the first slice value.
+// It is therefore safe to read values by the index.
+type Params []Param
+
+// ByName returns the value of the first Param which key matches the given name.
+// If no matching Param is found, an empty string is returned.
+func (ps Params) Get(name string) (string, bool) {
+	for _, entry := range ps {
+		if entry.Key == name {
+			return entry.Value, true
+		}
+	}
+	return "", false
+}
+
+func (ps Params) ByName(name string) (va string) {
+	va, _ = ps.Get(name)
+	return
+}
+
+type methodTree struct {
+	method string
+	root   *node
+}
+
+type methodTrees []methodTree
+
+func (trees methodTrees) get(method string) *node {
+	for _, tree := range trees {
+		if tree.method == method {
+			return tree.root
+		}
+	}
+	return nil
+}
+
+func min(a, b int) int {
+	if a <= b {
+		return a
+	}
+	return b
+}
+
+func countParams(path string) uint8 {
+	var n uint
+	for i := 0; i < len(path); i++ {
+		if path[i] != ':' && path[i] != '*' {
+			continue
+		}
+		n++
+	}
+	if n >= 255 {
+		return 255
+	}
+	return uint8(n)
+}
+
+type nodeType uint8
+
+const (
+	static   nodeType = 0
+	param    nodeType = 1
+	catchAll nodeType = 2
+)
+
+type node struct {
+	path      string
+	wildChild bool
+	nType     nodeType
+	maxParams uint8
+	indices   string
+	children  []*node
+	handlers  HandlersChain
+	priority  uint32
+}
+
+// increments priority of the given child and reorders if necessary
+func (n *node) incrementChildPrio(pos int) int {
+	n.children[pos].priority++
+	prio := n.children[pos].priority
+
+	// adjust position (move to front)
+	newPos := pos
+	for newPos > 0 && n.children[newPos-1].priority < prio {
+		// swap node positions
+		tmpN := n.children[newPos-1]
+		n.children[newPos-1] = n.children[newPos]
+		n.children[newPos] = tmpN
+
+		newPos--
+	}
+
+	// build new index char string
+	if newPos != pos {
+		n.indices = n.indices[:newPos] + // unchanged prefix, might be empty
+			n.indices[pos:pos+1] + // the index char we move
+			n.indices[newPos:pos] + n.indices[pos+1:] // rest without char at 'pos'
+	}
+
+	return newPos
+}
+
+// addRoute adds a node with the given handle to the path.
+// Not concurrency-safe!
+func (n *node) addRoute(path string, handlers HandlersChain) {
+	fullPath := path
+	n.priority++
+	numParams := countParams(path)
+
+	// non-empty tree
+	if len(n.path) > 0 || len(n.children) > 0 {
+	walk:
+		for {
+			// Update maxParams of the current node
+			if numParams > n.maxParams {
+				n.maxParams = numParams
+			}
+
+			// Find the longest common prefix.
+			// This also implies that the common prefix contains no ':' or '*'
+			// since the existing key can't contain those chars.
+			i := 0
+			max := min(len(path), len(n.path))
+			for i < max && path[i] == n.path[i] {
+				i++
+			}
+
+			// Split edge
+			if i < len(n.path) {
+				child := node{
+					path:      n.path[i:],
+					wildChild: n.wildChild,
+					indices:   n.indices,
+					children:  n.children,
+					handlers:  n.handlers,
+					priority:  n.priority - 1,
+				}
+
+				// Update maxParams (max of all children)
+				for i := range child.children {
+					if child.children[i].maxParams > child.maxParams {
+						child.maxParams = child.children[i].maxParams
+					}
+				}
+
+				n.children = []*node{&child}
+				// []byte for proper unicode char conversion, see #65
+				n.indices = string([]byte{n.path[i]})
+				n.path = path[:i]
+				n.handlers = nil
+				n.wildChild = false
+			}
+
+			// Make new node a child of this node
+			if i < len(path) {
+				path = path[i:]
+
+				if n.wildChild {
+					n = n.children[0]
+					n.priority++
+
+					// Update maxParams of the child node
+					if numParams > n.maxParams {
+						n.maxParams = numParams
+					}
+					numParams--
+
+					// Check if the wildcard matches
+					if len(path) >= len(n.path) && n.path == path[:len(n.path)] {
+						// check for longer wildcard, e.g. :name and :names
+						if len(n.path) >= len(path) || path[len(n.path)] == '/' {
+							continue walk
+						}
+					}
+
+					panic("path segment '" + path +
+						"' conflicts with existing wildcard '" + n.path +
+						"' in path '" + fullPath + "'")
+				}
+
+				c := path[0]
+
+				// slash after param
+				if n.nType == param && c == '/' && len(n.children) == 1 {
+					n = n.children[0]
+					n.priority++
+					continue walk
+				}
+
+				// Check if a child with the next path byte exists
+				for i := 0; i < len(n.indices); i++ {
+					if c == n.indices[i] {
+						i = n.incrementChildPrio(i)
+						n = n.children[i]
+						continue walk
+					}
+				}
+
+				// Otherwise insert it
+				if c != ':' && c != '*' {
+					// []byte for proper unicode char conversion, see #65
+					n.indices += string([]byte{c})
+					child := &node{
+						maxParams: numParams,
+					}
+					n.children = append(n.children, child)
+					n.incrementChildPrio(len(n.indices) - 1)
+					n = child
+				}
+				n.insertChild(numParams, path, fullPath, handlers)
+				return
+
+			} else if i == len(path) { // Make node a (in-path) leaf
+				if n.handlers != nil {
+					panic("handlers are already registered for path ''" + fullPath + "'")
+				}
+				n.handlers = handlers
+			}
+			return
+		}
+	} else { // Empty tree
+		n.insertChild(numParams, path, fullPath, handlers)
+	}
+}
+
+func (n *node) insertChild(numParams uint8, path string, fullPath string, handlers HandlersChain) {
+	var offset int // already handled bytes of the path
+
+	// find prefix until first wildcard (beginning with ':'' or '*'')
+	for i, max := 0, len(path); numParams > 0; i++ {
+		c := path[i]
+		if c != ':' && c != '*' {
+			continue
+		}
+
+		// find wildcard end (either '/' or path end)
+		end := i + 1
+		for end < max && path[end] != '/' {
+			switch path[end] {
+			// the wildcard name must not contain ':' and '*'
+			case ':', '*':
+				panic("only one wildcard per path segment is allowed, has: '" +
+					path[i:] + "' in path '" + fullPath + "'")
+			default:
+				end++
+			}
+		}
+
+		// check if this Node existing children which would be
+		// unreachable if we insert the wildcard here
+		if len(n.children) > 0 {
+			panic("wildcard route '" + path[i:end] +
+				"' conflicts with existing children in path '" + fullPath + "'")
+		}
+
+		// check if the wildcard has a name
+		if end-i < 2 {
+			panic("wildcards must be named with a non-empty name in path '" + fullPath + "'")
+		}
+
+		if c == ':' { // param
+			// split path at the beginning of the wildcard
+			if i > 0 {
+				n.path = path[offset:i]
+				offset = i
+			}
+
+			child := &node{
+				nType:     param,
+				maxParams: numParams,
+			}
+			n.children = []*node{child}
+			n.wildChild = true
+			n = child
+			n.priority++
+			numParams--
+
+			// if the path doesn't end with the wildcard, then there
+			// will be another non-wildcard subpath starting with '/'
+			if end < max {
+				n.path = path[offset:end]
+				offset = end
+
+				child := &node{
+					maxParams: numParams,
+					priority:  1,
+				}
+				n.children = []*node{child}
+				n = child
+			}
+
+		} else { // catchAll
+			if end != max || numParams > 1 {
+				panic("catch-all routes are only allowed at the end of the path in path '" + fullPath + "'")
+			}
+
+			if len(n.path) > 0 && n.path[len(n.path)-1] == '/' {
+				panic("catch-all conflicts with existing handle for the path segment root in path '" + fullPath + "'")
+			}
+
+			// currently fixed width 1 for '/'
+			i--
+			if path[i] != '/' {
+				panic("no / before catch-all in path '" + fullPath + "'")
+			}
+
+			n.path = path[offset:i]
+
+			// first node: catchAll node with empty path
+			child := &node{
+				wildChild: true,
+				nType:     catchAll,
+				maxParams: 1,
+			}
+			n.children = []*node{child}
+			n.indices = string(path[i])
+			n = child
+			n.priority++
+
+			// second node: node holding the variable
+			child = &node{
+				path:      path[i:],
+				nType:     catchAll,
+				maxParams: 1,
+				handlers:  handlers,
+				priority:  1,
+			}
+			n.children = []*node{child}
+
+			return
+		}
+	}
+
+	// insert remaining path part and handle to the leaf
+	n.path = path[offset:]
+	n.handlers = handlers
+}
+
+// Returns the handle registered with the given path (key). The values of
+// wildcards are saved to a map.
+// If no handle can be found, a TSR (trailing slash redirect) recommendation is
+// made if a handle exists with an extra (without the) trailing slash for the
+// given path.
+func (n *node) getValue(path string, po Params) (handlers HandlersChain, p Params, tsr bool) {
+	p = po
+walk: // Outer loop for walking the tree
+	for {
+		if len(path) > len(n.path) {
+			if path[:len(n.path)] == n.path {
+				path = path[len(n.path):]
+				// If this node does not have a wildcard (param or catchAll)
+				// child,  we can just look up the next child node and continue
+				// to walk down the tree
+				if !n.wildChild {
+					c := path[0]
+					for i := 0; i < len(n.indices); i++ {
+						if c == n.indices[i] {
+							n = n.children[i]
+							continue walk
+						}
+					}
+
+					// Nothing found.
+					// We can recommend to redirect to the same URL without a
+					// trailing slash if a leaf exists for that path.
+					tsr = (path == "/" && n.handlers != nil)
+					return
+				}
+
+				// handle wildcard child
+				n = n.children[0]
+				switch n.nType {
+				case param:
+					// find param end (either '/' or path end)
+					end := 0
+					for end < len(path) && path[end] != '/' {
+						end++
+					}
+
+					// save param value
+					if cap(p) < int(n.maxParams) {
+						p = make(Params, 0, n.maxParams)
+					}
+					i := len(p)
+					p = p[:i+1] // expand slice within preallocated capacity
+					p[i].Key = n.path[1:]
+					p[i].Value = path[:end]
+
+					// we need to go deeper!
+					if end < len(path) {
+						if len(n.children) > 0 {
+							path = path[end:]
+							n = n.children[0]
+							continue walk
+						}
+
+						// ... but we can't
+						tsr = (len(path) == end+1)
+						return
+					}
+
+					if handlers = n.handlers; handlers != nil {
+						return
+					} else if len(n.children) == 1 {
+						// No handle found. Check if a handle for this path + a
+						// trailing slash exists for TSR recommendation
+						n = n.children[0]
+						tsr = (n.path == "/" && n.handlers != nil)
+					}
+
+					return
+
+				case catchAll:
+					// save param value
+					if cap(p) < int(n.maxParams) {
+						p = make(Params, 0, n.maxParams)
+					}
+					i := len(p)
+					p = p[:i+1] // expand slice within preallocated capacity
+					p[i].Key = n.path[2:]
+					p[i].Value = path
+
+					handlers = n.handlers
+					return
+
+				default:
+					panic("invalid node type")
+				}
+			}
+		} else if path == n.path {
+			// We should have reached the node containing the handle.
+			// Check if this node has a handle registered.
+			if handlers = n.handlers; handlers != nil {
+				return
+			}
+
+			// No handle found. Check if a handle for this path + a
+			// trailing slash exists for trailing slash recommendation
+			for i := 0; i < len(n.indices); i++ {
+				if n.indices[i] == '/' {
+					n = n.children[i]
+					tsr = (len(n.path) == 1 && n.handlers != nil) ||
+						(n.nType == catchAll && n.children[0].handlers != nil)
+					return
+				}
+			}
+
+			return
+		}
+
+		// Nothing found. We can recommend to redirect to the same URL with an
+		// extra trailing slash if a leaf exists for that path
+		tsr = (path == "/") ||
+			(len(n.path) == len(path)+1 && n.path[len(path)] == '/' &&
+				path == n.path[:len(n.path)-1] && n.handlers != nil)
+		return
+	}
+}
+
+// Makes a case-insensitive lookup of the given path and tries to find a handler.
+// It can optionally also fix trailing slashes.
+// It returns the case-corrected path and a bool indicating whether the lookup
+// was successful.
+func (n *node) findCaseInsensitivePath(path string, fixTrailingSlash bool) (ciPath []byte, found bool) {
+	ciPath = make([]byte, 0, len(path)+1) // preallocate enough memory
+
+	// Outer loop for walking the tree
+	for len(path) >= len(n.path) && strings.ToLower(path[:len(n.path)]) == strings.ToLower(n.path) {
+		path = path[len(n.path):]
+		ciPath = append(ciPath, n.path...)
+
+		if len(path) > 0 {
+			// If this node does not have a wildcard (param or catchAll) child,
+			// we can just look up the next child node and continue to walk down
+			// the tree
+			if !n.wildChild {
+				r := unicode.ToLower(rune(path[0]))
+				for i, index := range n.indices {
+					// must use recursive approach since both index and
+					// ToLower(index) could exist. We must check both.
+					if r == unicode.ToLower(index) {
+						out, found := n.children[i].findCaseInsensitivePath(path, fixTrailingSlash)
+						if found {
+							return append(ciPath, out...), true
+						}
+					}
+				}
+
+				// Nothing found. We can recommend to redirect to the same URL
+				// without a trailing slash if a leaf exists for that path
+				found = (fixTrailingSlash && path == "/" && n.handlers != nil)
+				return
+			}
+
+			n = n.children[0]
+			switch n.nType {
+			case param:
+				// find param end (either '/' or path end)
+				k := 0
+				for k < len(path) && path[k] != '/' {
+					k++
+				}
+
+				// add param value to case insensitive path
+				ciPath = append(ciPath, path[:k]...)
+
+				// we need to go deeper!
+				if k < len(path) {
+					if len(n.children) > 0 {
+						path = path[k:]
+						n = n.children[0]
+						continue
+					}
+
+					// ... but we can't
+					if fixTrailingSlash && len(path) == k+1 {
+						return ciPath, true
+					}
+					return
+				}
+
+				if n.handlers != nil {
+					return ciPath, true
+				} else if fixTrailingSlash && len(n.children) == 1 {
+					// No handle found. Check if a handle for this path + a
+					// trailing slash exists
+					n = n.children[0]
+					if n.path == "/" && n.handlers != nil {
+						return append(ciPath, '/'), true
+					}
+				}
+				return
+
+			case catchAll:
+				return append(ciPath, path...), true
+
+			default:
+				panic("invalid node type")
+			}
+		} else {
+			// We should have reached the node containing the handle.
+			// Check if this node has a handle registered.
+			if n.handlers != nil {
+				return ciPath, true
+			}
+
+			// No handle found.
+			// Try to fix the path by adding a trailing slash
+			if fixTrailingSlash {
+				for i := 0; i < len(n.indices); i++ {
+					if n.indices[i] == '/' {
+						n = n.children[i]
+						if (len(n.path) == 1 && n.handlers != nil) ||
+							(n.nType == catchAll && n.children[0].handlers != nil) {
+							return append(ciPath, '/'), true
+						}
+						return
+					}
+				}
+			}
+			return
+		}
+	}
+
+	// Nothing found.
+	// Try to fix the path by adding / removing a trailing slash
+	if fixTrailingSlash {
+		if path == "/" {
+			return ciPath, true
+		}
+		if len(path)+1 == len(n.path) && n.path[len(path)] == '/' &&
+			strings.ToLower(path) == strings.ToLower(n.path[:len(path)]) &&
+			n.handlers != nil {
+			return append(ciPath, n.path...), true
+		}
+	}
+	return
+}
diff --git a/vendor/github.com/gin-gonic/gin/utils.go b/vendor/github.com/gin-gonic/gin/utils.go
new file mode 100644
index 0000000..7e64687
--- /dev/null
+++ b/vendor/github.com/gin-gonic/gin/utils.go
@@ -0,0 +1,131 @@
+// Copyright 2014 Manu Martinez-Almeida.  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 (
+	"encoding/xml"
+	"net/http"
+	"path"
+	"reflect"
+	"runtime"
+	"strings"
+)
+
+const BindKey = "_gin-gonic/gin/bindkey"
+
+func Bind(val interface{}) HandlerFunc {
+	value := reflect.ValueOf(val)
+	if value.Kind() == reflect.Ptr {
+		panic(`Bind struct can not be a pointer. Example:
+	Use: gin.Bind(Struct{}) instead of gin.Bind(&Struct{})
+`)
+	}
+	typ := value.Type()
+
+	return func(c *Context) {
+		obj := reflect.New(typ).Interface()
+		if c.Bind(obj) == nil {
+			c.Set(BindKey, obj)
+		}
+	}
+}
+
+func WrapF(f http.HandlerFunc) HandlerFunc {
+	return func(c *Context) {
+		f(c.Writer, c.Request)
+	}
+}
+
+func WrapH(h http.Handler) HandlerFunc {
+	return func(c *Context) {
+		h.ServeHTTP(c.Writer, c.Request)
+	}
+}
+
+type H map[string]interface{}
+
+// Allows type H to be used with xml.Marshal
+func (h H) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
+	start.Name = xml.Name{
+		Space: "",
+		Local: "map",
+	}
+	if err := e.EncodeToken(start); err != nil {
+		return err
+	}
+	for key, value := range h {
+		elem := xml.StartElement{
+			Name: xml.Name{Space: "", Local: key},
+			Attr: []xml.Attr{},
+		}
+		if err := e.EncodeElement(value, elem); err != nil {
+			return err
+		}
+	}
+	if err := e.EncodeToken(xml.EndElement{Name: start.Name}); err != nil {
+		return err
+	}
+	return nil
+}
+
+func filterFlags(content string) string {
+	for i, char := range content {
+		if char == ' ' || char == ';' {
+			return content[:i]
+		}
+	}
+	return content
+}
+
+func chooseData(custom, wildcard interface{}) interface{} {
+	if custom == nil {
+		if wildcard == nil {
+			panic("negotiation config is invalid")
+		}
+		return wildcard
+	}
+	return custom
+}
+
+func parseAccept(acceptHeader string) []string {
+	parts := strings.Split(acceptHeader, ",")
+	out := make([]string, 0, len(parts))
+	for _, part := range parts {
+		index := strings.IndexByte(part, ';')
+		if index >= 0 {
+			part = part[0:index]
+		}
+		part = strings.TrimSpace(part)
+		if len(part) > 0 {
+			out = append(out, part)
+		}
+	}
+	return out
+}
+
+func lastChar(str string) uint8 {
+	size := len(str)
+	if size == 0 {
+		panic("The length of the string can't be 0")
+	}
+	return str[size-1]
+}
+
+func nameOfFunction(f interface{}) string {
+	return runtime.FuncForPC(reflect.ValueOf(f).Pointer()).Name()
+}
+
+func joinPaths(absolutePath, relativePath string) string {
+	if len(relativePath) == 0 {
+		return absolutePath
+	}
+
+	finalPath := path.Join(absolutePath, relativePath)
+	appendSlash := lastChar(relativePath) == '/' && lastChar(finalPath) != '/'
+	if appendSlash {
+		return finalPath + "/"
+	}
+	return finalPath
+}
diff --git a/vendor/github.com/gin-gonic/gin/wercker.yml b/vendor/github.com/gin-gonic/gin/wercker.yml
new file mode 100644
index 0000000..3ab8084
--- /dev/null
+++ b/vendor/github.com/gin-gonic/gin/wercker.yml
@@ -0,0 +1 @@
+box: wercker/default
\ No newline at end of file
diff --git a/vendor/github.com/heroku/x/hmetrics/doc.go b/vendor/github.com/heroku/x/hmetrics/doc.go
new file mode 100644
index 0000000..f33757c
--- /dev/null
+++ b/vendor/github.com/heroku/x/hmetrics/doc.go
@@ -0,0 +1,5 @@
+/*
+package hmetrics is a self-contained client for heroku Go runtime metrics.
+*/
+
+package hmetrics
diff --git a/vendor/github.com/heroku/x/hmetrics/hmetrics.go b/vendor/github.com/heroku/x/hmetrics/hmetrics.go
new file mode 100644
index 0000000..4ae88f6
--- /dev/null
+++ b/vendor/github.com/heroku/x/hmetrics/hmetrics.go
@@ -0,0 +1,169 @@
+package hmetrics
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"os"
+	"runtime"
+	"sync"
+	"time"
+)
+
+const (
+	metricWaitTime = 20 * time.Second
+)
+
+var (
+	DefaultEndpoint string
+)
+
+func init() {
+	DefaultEndpoint = os.Getenv("HEROKU_METRICS_URL")
+}
+
+type AlreadyStarted struct{}
+
+func (as AlreadyStarted) Error() string {
+	return "already started"
+}
+
+func (as AlreadyStarted) Fatal() bool {
+	return false
+}
+
+type HerokuMetricsURLUnset struct{}
+
+func (e HerokuMetricsURLUnset) Error() string {
+	return "cannot report metrics because HEROKU_METRICS_URL is unset"
+}
+
+func (e HerokuMetricsURLUnset) Fatal() bool {
+	return true
+}
+
+var (
+	mu      sync.Mutex
+	started bool
+)
+
+// ErrHandler receives any errors encountered during collection or reporting of metrics to Heroku. Processing of metrics
+// continues if the ErrHandler returns nil, but aborts if the ErrHandler itself returns an error.
+type ErrHandler func(err error) error
+
+func Report(ctx context.Context, ef ErrHandler) error {
+	mu.Lock()
+	defer mu.Unlock()
+	if started {
+		return AlreadyStarted{}
+	}
+	endpoint := DefaultEndpoint
+	if endpoint == "" {
+		return HerokuMetricsURLUnset{}
+	}
+	if ef == nil {
+		ef = func(_ error) error { return nil }
+	}
+	go report(ctx, endpoint, ef)
+	started = true
+	return nil
+}
+
+// The only thing that should come after an exit() is a return.
+// Best to use in a function that can defer it.
+func exit() {
+	mu.Lock()
+	defer mu.Unlock()
+	started = false
+}
+
+func report(ctx context.Context, endpoint string, ef ErrHandler) {
+	defer exit()
+
+	t := time.NewTicker(metricWaitTime)
+	defer t.Stop()
+
+	for {
+		select {
+		case <-t.C:
+		case <-ctx.Done():
+			return
+		}
+
+		if err := gatherMetrics(); err != nil {
+			if err := ef(err); err != nil {
+				return
+			}
+			continue
+		}
+		if err := submitPayload(ctx, endpoint); err != nil {
+			if err := ef(err); err != nil {
+				return
+			}
+			continue
+		}
+	}
+}
+
+var (
+	lastGCPause uint64
+	lastNumGC   uint32
+	buf         bytes.Buffer
+)
+
+// TODO: If we ever have high frequency charts HeapIdle minus HeapReleased could be interesting.
+func gatherMetrics() error {
+	var stats runtime.MemStats
+	runtime.ReadMemStats(&stats)
+
+	// cribbed from https://github.com/codahale/metrics/blob/master/runtime/memstats.go
+
+	pauseNS := stats.PauseTotalNs - lastGCPause
+	lastGCPause = stats.PauseTotalNs
+
+	numGC := stats.NumGC - lastNumGC
+	lastNumGC = stats.NumGC
+
+	result := struct {
+		Counters map[string]float64 `json:"counters"`
+		Gauges   map[string]float64 `json:"gauges"`
+	}{
+		Counters: map[string]float64{
+			"go.gc.collections": float64(numGC),
+			"go.gc.pause.ns":    float64(pauseNS),
+		},
+		Gauges: map[string]float64{
+			"go.memory.heap.bytes":   float64(stats.Alloc),
+			"go.memory.stack.bytes":  float64(stats.StackInuse),
+			"go.memory.heap.objects": float64(stats.Mallocs - stats.Frees), // Number of "live" objects.
+			"go.gc.goal":             float64(stats.NextGC),                // Goal heap size for next GC.
+			"go.routines":            float64(runtime.NumGoroutine()),      // Current number of goroutines.
+		},
+	}
+
+	buf.Reset()
+	return json.NewEncoder(&buf).Encode(result)
+}
+
+func submitPayload(ctx context.Context, where string) error {
+	req, err := http.NewRequest("POST", where, &buf)
+	if err != nil {
+		return err
+	}
+	req = req.WithContext(ctx)
+	req.Header.Add("Content-Type", "application/json")
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("expected %v (http.StatusOK) but got %s", http.StatusOK, resp.Status)
+	}
+
+	return nil
+}
diff --git a/vendor/github.com/heroku/x/hmetrics/onload/README.md b/vendor/github.com/heroku/x/hmetrics/onload/README.md
new file mode 100644
index 0000000..037068e
--- /dev/null
+++ b/vendor/github.com/heroku/x/hmetrics/onload/README.md
@@ -0,0 +1,7 @@
+runtime-metrics
+===============
+
+This will only be useful if you are inside the runtime metrics private beta.
+
+This package, once loaded, will implicitly dump a subset of runtime performace
+metrics to the URL denoted by `HEROKU_METRICS_URL`
diff --git a/vendor/github.com/heroku/x/hmetrics/onload/init.go b/vendor/github.com/heroku/x/hmetrics/onload/init.go
new file mode 100644
index 0000000..d6fb49d
--- /dev/null
+++ b/vendor/github.com/heroku/x/hmetrics/onload/init.go
@@ -0,0 +1,25 @@
+/*
+package onload automatically starts up the hmetrics reporting.
+
+Use this package when you don't care about shutting down them metrics reporting or being notified of any reporting
+errors.
+
+usage:
+
+import (
+	_ "github.com/heroku/x/hmetrics/onload"
+)
+
+*/
+
+package onloads
+
+import (
+	"context"
+
+	"github.com/heroku/x/hmetrics"
+)
+
+func init() {
+	hmetrics.Report(context.Background(), nil)
+}
diff --git a/vendor/github.com/manucorporat/sse/.travis.yml b/vendor/github.com/manucorporat/sse/.travis.yml
new file mode 100644
index 0000000..3d33833
--- /dev/null
+++ b/vendor/github.com/manucorporat/sse/.travis.yml
@@ -0,0 +1,6 @@
+language: go
+sudo: false
+go:
+  - 1.3
+  - 1.4
+  - tip
diff --git a/vendor/github.com/manucorporat/sse/LICENSE b/vendor/github.com/manucorporat/sse/LICENSE
new file mode 100644
index 0000000..1ff7f37
--- /dev/null
+++ b/vendor/github.com/manucorporat/sse/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Manuel Martínez-Almeida
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/manucorporat/sse/README.md b/vendor/github.com/manucorporat/sse/README.md
new file mode 100644
index 0000000..4e1cf0e
--- /dev/null
+++ b/vendor/github.com/manucorporat/sse/README.md
@@ -0,0 +1,54 @@
+#Server-Sent Events [![GoDoc](https://godoc.org/github.com/manucorporat/sse?status.svg)](https://godoc.org/github.com/manucorporat/sse) [![Build Status](https://travis-ci.org/manucorporat/sse.svg)](https://travis-ci.org/manucorporat/sse)
+
+Server-sent events (SSE) is a technology where a browser receives automatic updates from a server via HTTP connection. The Server-Sent Events EventSource API is [standardized as part of HTML5[1] by the W3C](http://www.w3.org/TR/2009/WD-eventsource-20091029/).
+
+- [Real world demostration using Gin](http://sse.getgin.io/)
+- [Read this great SSE introduction by the HTML5Rocks guys](http://www.html5rocks.com/en/tutorials/eventsource/basics/)
+- [Browser support](http://caniuse.com/#feat=eventsource)
+
+##Sample code
+
+```go
+import "github.com/manucorporat/sse"
+
+func httpHandler(w http.ResponseWriter, req *http.Request) {
+	// data can be a primitive like a string, an integer or a float
+	sse.Encode(w, sse.Event{
+		Event: "message",
+		Data:  "some data\nmore data",
+	})
+
+	// also a complex type, like a map, a struct or a slice
+	sse.Encode(w, sse.Event{
+		Id:    "124",
+		Event: "message",
+		Data: map[string]interface{}{
+			"user":    "manu",
+			"date":    time.Now().Unix(),
+			"content": "hi!",
+		},
+	})
+}
+```
+```
+event: message
+data: some data\\nmore data
+
+id: 124
+event: message
+data: {"content":"hi!","date":1431540810,"user":"manu"}
+ 
+```
+
+##Content-Type
+
+```go
+fmt.Println(sse.ContentType)
+```
+```
+text/event-stream
+```
+
+##Decoding support
+
+There is a client-side implementation of SSE coming soon.
\ No newline at end of file
diff --git a/vendor/github.com/manucorporat/sse/sse-encoder.go b/vendor/github.com/manucorporat/sse/sse-encoder.go
new file mode 100644
index 0000000..16bab76
--- /dev/null
+++ b/vendor/github.com/manucorporat/sse/sse-encoder.go
@@ -0,0 +1,106 @@
+// Copyright 2014 Manu Martinez-Almeida.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package sse
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"reflect"
+	"strconv"
+	"strings"
+)
+
+// Server-Sent Events
+// W3C Working Draft 29 October 2009
+// http://www.w3.org/TR/2009/WD-eventsource-20091029/
+
+const ContentType = "text/event-stream"
+
+var contentType = []string{ContentType}
+var noCache = []string{"no-cache"}
+var replacer = strings.NewReplacer("\n", "\\n", "\r", "\\r")
+
+type Event struct {
+	Event string
+	Id    string
+	Retry uint
+	Data  interface{}
+}
+
+func Encode(writer io.Writer, event Event) error {
+	w := checkWriter(writer)
+	writeId(w, event.Id)
+	writeEvent(w, event.Event)
+	writeRetry(w, event.Retry)
+	return writeData(w, event.Data)
+}
+
+func writeId(w stringWriter, id string) {
+	if len(id) > 0 {
+		w.WriteString("id: ")
+		writeEscape(w, id)
+		w.WriteString("\n")
+	}
+}
+
+func writeEvent(w stringWriter, event string) {
+	if len(event) > 0 {
+		w.WriteString("event: ")
+		writeEscape(w, event)
+		w.WriteString("\n")
+	}
+}
+
+func writeRetry(w stringWriter, retry uint) {
+	if retry > 0 {
+		w.WriteString("retry: ")
+		w.WriteString(strconv.FormatUint(uint64(retry), 10))
+		w.WriteString("\n")
+	}
+}
+
+func writeData(w stringWriter, data interface{}) error {
+	w.WriteString("data: ")
+	switch kindOfData(data) {
+	case reflect.Struct, reflect.Slice, reflect.Map:
+		err := json.NewEncoder(w).Encode(data)
+		if err != nil {
+			return err
+		}
+		w.WriteString("\n")
+	default:
+		text := fmt.Sprint(data)
+		writeEscape(w, text)
+		w.WriteString("\n\n")
+	}
+	return nil
+}
+
+func (r Event) Render(w http.ResponseWriter) error {
+	header := w.Header()
+	header["Content-Type"] = contentType
+
+	if _, exist := header["Cache-Control"]; !exist {
+		header["Cache-Control"] = noCache
+	}
+	return Encode(w, r)
+}
+
+func kindOfData(data interface{}) reflect.Kind {
+	value := reflect.ValueOf(data)
+	valueType := value.Kind()
+	if valueType == reflect.Ptr {
+		valueType = value.Elem().Kind()
+	}
+	return valueType
+}
+
+func writeEscape(w stringWriter, str string) {
+	// any-char		= %x0000-0009 / %x000B-000C / %x000E-10FFFF
+	// ; a Unicode character other than U+000A LINE FEED (LF) or U+000D CARRIAGE RETURN (CR)
+	replacer.WriteString(w, str)
+}
diff --git a/vendor/github.com/manucorporat/sse/writer.go b/vendor/github.com/manucorporat/sse/writer.go
new file mode 100644
index 0000000..6f9806c
--- /dev/null
+++ b/vendor/github.com/manucorporat/sse/writer.go
@@ -0,0 +1,24 @@
+package sse
+
+import "io"
+
+type stringWriter interface {
+	io.Writer
+	WriteString(string) (int, error)
+}
+
+type stringWrapper struct {
+	io.Writer
+}
+
+func (w stringWrapper) WriteString(str string) (int, error) {
+	return w.Writer.Write([]byte(str))
+}
+
+func checkWriter(writer io.Writer) stringWriter {
+	if w, ok := writer.(stringWriter); ok {
+		return w
+	} else {
+		return stringWrapper{writer}
+	}
+}
diff --git a/vendor/github.com/mattn/go-colorable/README.md b/vendor/github.com/mattn/go-colorable/README.md
new file mode 100644
index 0000000..e84226a
--- /dev/null
+++ b/vendor/github.com/mattn/go-colorable/README.md
@@ -0,0 +1,43 @@
+# go-colorable
+
+Colorable writer for windows.
+
+For example, most of logger packages doesn't show colors on windows. (I know we can do it with ansicon. But I don't want.)
+This package is possible to handle escape sequence for ansi color on windows.
+
+## Too Bad!
+
+![](https://raw.githubusercontent.com/mattn/go-colorable/gh-pages/bad.png)
+
+
+## So Good!
+
+![](https://raw.githubusercontent.com/mattn/go-colorable/gh-pages/good.png)
+
+## Usage
+
+```go
+logrus.SetFormatter(&logrus.TextFormatter{ForceColors: true})
+logrus.SetOutput(colorable.NewColorableStdout())
+
+logrus.Info("succeeded")
+logrus.Warn("not correct")
+logrus.Error("something error")
+logrus.Fatal("panic")
+```
+
+You can compile above code on non-windows OSs.
+
+## Installation
+
+```
+$ go get github.com/mattn/go-colorable
+```
+
+# License
+
+MIT
+
+# Author
+
+Yasuhiro Matsumoto (a.k.a mattn)
diff --git a/vendor/github.com/mattn/go-colorable/colorable_others.go b/vendor/github.com/mattn/go-colorable/colorable_others.go
new file mode 100644
index 0000000..219f02f
--- /dev/null
+++ b/vendor/github.com/mattn/go-colorable/colorable_others.go
@@ -0,0 +1,16 @@
+// +build !windows
+
+package colorable
+
+import (
+	"io"
+	"os"
+)
+
+func NewColorableStdout() io.Writer {
+	return os.Stdout
+}
+
+func NewColorableStderr() io.Writer {
+	return os.Stderr
+}
diff --git a/vendor/github.com/mattn/go-colorable/colorable_windows.go b/vendor/github.com/mattn/go-colorable/colorable_windows.go
new file mode 100644
index 0000000..6a27878
--- /dev/null
+++ b/vendor/github.com/mattn/go-colorable/colorable_windows.go
@@ -0,0 +1,594 @@
+package colorable
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"os"
+	"strconv"
+	"strings"
+	"syscall"
+	"unsafe"
+
+	"github.com/mattn/go-isatty"
+)
+
+const (
+	foregroundBlue      = 0x1
+	foregroundGreen     = 0x2
+	foregroundRed       = 0x4
+	foregroundIntensity = 0x8
+	foregroundMask      = (foregroundRed | foregroundBlue | foregroundGreen | foregroundIntensity)
+	backgroundBlue      = 0x10
+	backgroundGreen     = 0x20
+	backgroundRed       = 0x40
+	backgroundIntensity = 0x80
+	backgroundMask      = (backgroundRed | backgroundBlue | backgroundGreen | backgroundIntensity)
+)
+
+type wchar uint16
+type short int16
+type dword uint32
+type word uint16
+
+type coord struct {
+	x short
+	y short
+}
+
+type smallRect struct {
+	left   short
+	top    short
+	right  short
+	bottom short
+}
+
+type consoleScreenBufferInfo struct {
+	size              coord
+	cursorPosition    coord
+	attributes        word
+	window            smallRect
+	maximumWindowSize coord
+}
+
+var (
+	kernel32                       = syscall.NewLazyDLL("kernel32.dll")
+	procGetConsoleScreenBufferInfo = kernel32.NewProc("GetConsoleScreenBufferInfo")
+	procSetConsoleTextAttribute    = kernel32.NewProc("SetConsoleTextAttribute")
+)
+
+type Writer struct {
+	out     io.Writer
+	handle  syscall.Handle
+	lastbuf bytes.Buffer
+	oldattr word
+}
+
+func NewColorableStdout() io.Writer {
+	var csbi consoleScreenBufferInfo
+	out := os.Stdout
+	if !isatty.IsTerminal(out.Fd()) {
+		return out
+	}
+	handle := syscall.Handle(out.Fd())
+	procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
+	return &Writer{out: out, handle: handle, oldattr: csbi.attributes}
+}
+
+func NewColorableStderr() io.Writer {
+	var csbi consoleScreenBufferInfo
+	out := os.Stderr
+	if !isatty.IsTerminal(out.Fd()) {
+		return out
+	}
+	handle := syscall.Handle(out.Fd())
+	procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
+	return &Writer{out: out, handle: handle, oldattr: csbi.attributes}
+}
+
+var color256 = map[int]int{
+	0:   0x000000,
+	1:   0x800000,
+	2:   0x008000,
+	3:   0x808000,
+	4:   0x000080,
+	5:   0x800080,
+	6:   0x008080,
+	7:   0xc0c0c0,
+	8:   0x808080,
+	9:   0xff0000,
+	10:  0x00ff00,
+	11:  0xffff00,
+	12:  0x0000ff,
+	13:  0xff00ff,
+	14:  0x00ffff,
+	15:  0xffffff,
+	16:  0x000000,
+	17:  0x00005f,
+	18:  0x000087,
+	19:  0x0000af,
+	20:  0x0000d7,
+	21:  0x0000ff,
+	22:  0x005f00,
+	23:  0x005f5f,
+	24:  0x005f87,
+	25:  0x005faf,
+	26:  0x005fd7,
+	27:  0x005fff,
+	28:  0x008700,
+	29:  0x00875f,
+	30:  0x008787,
+	31:  0x0087af,
+	32:  0x0087d7,
+	33:  0x0087ff,
+	34:  0x00af00,
+	35:  0x00af5f,
+	36:  0x00af87,
+	37:  0x00afaf,
+	38:  0x00afd7,
+	39:  0x00afff,
+	40:  0x00d700,
+	41:  0x00d75f,
+	42:  0x00d787,
+	43:  0x00d7af,
+	44:  0x00d7d7,
+	45:  0x00d7ff,
+	46:  0x00ff00,
+	47:  0x00ff5f,
+	48:  0x00ff87,
+	49:  0x00ffaf,
+	50:  0x00ffd7,
+	51:  0x00ffff,
+	52:  0x5f0000,
+	53:  0x5f005f,
+	54:  0x5f0087,
+	55:  0x5f00af,
+	56:  0x5f00d7,
+	57:  0x5f00ff,
+	58:  0x5f5f00,
+	59:  0x5f5f5f,
+	60:  0x5f5f87,
+	61:  0x5f5faf,
+	62:  0x5f5fd7,
+	63:  0x5f5fff,
+	64:  0x5f8700,
+	65:  0x5f875f,
+	66:  0x5f8787,
+	67:  0x5f87af,
+	68:  0x5f87d7,
+	69:  0x5f87ff,
+	70:  0x5faf00,
+	71:  0x5faf5f,
+	72:  0x5faf87,
+	73:  0x5fafaf,
+	74:  0x5fafd7,
+	75:  0x5fafff,
+	76:  0x5fd700,
+	77:  0x5fd75f,
+	78:  0x5fd787,
+	79:  0x5fd7af,
+	80:  0x5fd7d7,
+	81:  0x5fd7ff,
+	82:  0x5fff00,
+	83:  0x5fff5f,
+	84:  0x5fff87,
+	85:  0x5fffaf,
+	86:  0x5fffd7,
+	87:  0x5fffff,
+	88:  0x870000,
+	89:  0x87005f,
+	90:  0x870087,
+	91:  0x8700af,
+	92:  0x8700d7,
+	93:  0x8700ff,
+	94:  0x875f00,
+	95:  0x875f5f,
+	96:  0x875f87,
+	97:  0x875faf,
+	98:  0x875fd7,
+	99:  0x875fff,
+	100: 0x878700,
+	101: 0x87875f,
+	102: 0x878787,
+	103: 0x8787af,
+	104: 0x8787d7,
+	105: 0x8787ff,
+	106: 0x87af00,
+	107: 0x87af5f,
+	108: 0x87af87,
+	109: 0x87afaf,
+	110: 0x87afd7,
+	111: 0x87afff,
+	112: 0x87d700,
+	113: 0x87d75f,
+	114: 0x87d787,
+	115: 0x87d7af,
+	116: 0x87d7d7,
+	117: 0x87d7ff,
+	118: 0x87ff00,
+	119: 0x87ff5f,
+	120: 0x87ff87,
+	121: 0x87ffaf,
+	122: 0x87ffd7,
+	123: 0x87ffff,
+	124: 0xaf0000,
+	125: 0xaf005f,
+	126: 0xaf0087,
+	127: 0xaf00af,
+	128: 0xaf00d7,
+	129: 0xaf00ff,
+	130: 0xaf5f00,
+	131: 0xaf5f5f,
+	132: 0xaf5f87,
+	133: 0xaf5faf,
+	134: 0xaf5fd7,
+	135: 0xaf5fff,
+	136: 0xaf8700,
+	137: 0xaf875f,
+	138: 0xaf8787,
+	139: 0xaf87af,
+	140: 0xaf87d7,
+	141: 0xaf87ff,
+	142: 0xafaf00,
+	143: 0xafaf5f,
+	144: 0xafaf87,
+	145: 0xafafaf,
+	146: 0xafafd7,
+	147: 0xafafff,
+	148: 0xafd700,
+	149: 0xafd75f,
+	150: 0xafd787,
+	151: 0xafd7af,
+	152: 0xafd7d7,
+	153: 0xafd7ff,
+	154: 0xafff00,
+	155: 0xafff5f,
+	156: 0xafff87,
+	157: 0xafffaf,
+	158: 0xafffd7,
+	159: 0xafffff,
+	160: 0xd70000,
+	161: 0xd7005f,
+	162: 0xd70087,
+	163: 0xd700af,
+	164: 0xd700d7,
+	165: 0xd700ff,
+	166: 0xd75f00,
+	167: 0xd75f5f,
+	168: 0xd75f87,
+	169: 0xd75faf,
+	170: 0xd75fd7,
+	171: 0xd75fff,
+	172: 0xd78700,
+	173: 0xd7875f,
+	174: 0xd78787,
+	175: 0xd787af,
+	176: 0xd787d7,
+	177: 0xd787ff,
+	178: 0xd7af00,
+	179: 0xd7af5f,
+	180: 0xd7af87,
+	181: 0xd7afaf,
+	182: 0xd7afd7,
+	183: 0xd7afff,
+	184: 0xd7d700,
+	185: 0xd7d75f,
+	186: 0xd7d787,
+	187: 0xd7d7af,
+	188: 0xd7d7d7,
+	189: 0xd7d7ff,
+	190: 0xd7ff00,
+	191: 0xd7ff5f,
+	192: 0xd7ff87,
+	193: 0xd7ffaf,
+	194: 0xd7ffd7,
+	195: 0xd7ffff,
+	196: 0xff0000,
+	197: 0xff005f,
+	198: 0xff0087,
+	199: 0xff00af,
+	200: 0xff00d7,
+	201: 0xff00ff,
+	202: 0xff5f00,
+	203: 0xff5f5f,
+	204: 0xff5f87,
+	205: 0xff5faf,
+	206: 0xff5fd7,
+	207: 0xff5fff,
+	208: 0xff8700,
+	209: 0xff875f,
+	210: 0xff8787,
+	211: 0xff87af,
+	212: 0xff87d7,
+	213: 0xff87ff,
+	214: 0xffaf00,
+	215: 0xffaf5f,
+	216: 0xffaf87,
+	217: 0xffafaf,
+	218: 0xffafd7,
+	219: 0xffafff,
+	220: 0xffd700,
+	221: 0xffd75f,
+	222: 0xffd787,
+	223: 0xffd7af,
+	224: 0xffd7d7,
+	225: 0xffd7ff,
+	226: 0xffff00,
+	227: 0xffff5f,
+	228: 0xffff87,
+	229: 0xffffaf,
+	230: 0xffffd7,
+	231: 0xffffff,
+	232: 0x080808,
+	233: 0x121212,
+	234: 0x1c1c1c,
+	235: 0x262626,
+	236: 0x303030,
+	237: 0x3a3a3a,
+	238: 0x444444,
+	239: 0x4e4e4e,
+	240: 0x585858,
+	241: 0x626262,
+	242: 0x6c6c6c,
+	243: 0x767676,
+	244: 0x808080,
+	245: 0x8a8a8a,
+	246: 0x949494,
+	247: 0x9e9e9e,
+	248: 0xa8a8a8,
+	249: 0xb2b2b2,
+	250: 0xbcbcbc,
+	251: 0xc6c6c6,
+	252: 0xd0d0d0,
+	253: 0xdadada,
+	254: 0xe4e4e4,
+	255: 0xeeeeee,
+}
+
+func (w *Writer) Write(data []byte) (n int, err error) {
+	var csbi consoleScreenBufferInfo
+	procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
+
+	er := bytes.NewBuffer(data)
+loop:
+	for {
+		r1, _, err := procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
+		if r1 == 0 {
+			break loop
+		}
+
+		c1, _, err := er.ReadRune()
+		if err != nil {
+			break loop
+		}
+		if c1 != 0x1b {
+			fmt.Fprint(w.out, string(c1))
+			continue
+		}
+		c2, _, err := er.ReadRune()
+		if err != nil {
+			w.lastbuf.WriteRune(c1)
+			break loop
+		}
+		if c2 != 0x5b {
+			w.lastbuf.WriteRune(c1)
+			w.lastbuf.WriteRune(c2)
+			continue
+		}
+
+		var buf bytes.Buffer
+		var m rune
+		for {
+			c, _, err := er.ReadRune()
+			if err != nil {
+				w.lastbuf.WriteRune(c1)
+				w.lastbuf.WriteRune(c2)
+				w.lastbuf.Write(buf.Bytes())
+				break loop
+			}
+			if ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '@' {
+				m = c
+				break
+			}
+			buf.Write([]byte(string(c)))
+		}
+
+		switch m {
+		case 'm':
+			attr := csbi.attributes
+			cs := buf.String()
+			if cs == "" {
+				procSetConsoleTextAttribute.Call(uintptr(w.handle), uintptr(w.oldattr))
+				continue
+			}
+			token := strings.Split(cs, ";")
+			for i, ns := range token {
+				if n, err = strconv.Atoi(ns); err == nil {
+					switch {
+					case n == 0 || n == 100:
+						attr = w.oldattr
+					case 1 <= n && n <= 5:
+						attr |= foregroundIntensity
+					case n == 7:
+						attr = ((attr & foregroundMask) << 4) | ((attr & backgroundMask) >> 4)
+					case 22 == n || n == 25 || n == 25:
+						attr |= foregroundIntensity
+					case n == 27:
+						attr = ((attr & foregroundMask) << 4) | ((attr & backgroundMask) >> 4)
+					case 30 <= n && n <= 37:
+						attr = (attr & backgroundMask)
+						if (n-30)&1 != 0 {
+							attr |= foregroundRed
+						}
+						if (n-30)&2 != 0 {
+							attr |= foregroundGreen
+						}
+						if (n-30)&4 != 0 {
+							attr |= foregroundBlue
+						}
+					case n == 38: // set foreground color.
+						if i < len(token)-2 && token[i+1] == "5" {
+							if n256, err := strconv.Atoi(token[i+2]); err == nil {
+								if n256foreAttr == nil {
+									n256setup()
+								}
+								attr &= backgroundMask
+								attr |= n256foreAttr[n256]
+								i += 2
+							}
+						} else {
+							attr = attr & (w.oldattr & backgroundMask)
+						}
+					case n == 39: // reset foreground color.
+						attr &= backgroundMask
+						attr |= w.oldattr & foregroundMask
+					case 40 <= n && n <= 47:
+						attr = (attr & foregroundMask)
+						if (n-40)&1 != 0 {
+							attr |= backgroundRed
+						}
+						if (n-40)&2 != 0 {
+							attr |= backgroundGreen
+						}
+						if (n-40)&4 != 0 {
+							attr |= backgroundBlue
+						}
+					case n == 48: // set background color.
+						if i < len(token)-2 && token[i+1] == "5" {
+							if n256, err := strconv.Atoi(token[i+2]); err == nil {
+								if n256backAttr == nil {
+									n256setup()
+								}
+								attr &= foregroundMask
+								attr |= n256backAttr[n256]
+								i += 2
+							}
+						} else {
+							attr = attr & (w.oldattr & foregroundMask)
+						}
+					case n == 49: // reset foreground color.
+						attr &= foregroundMask
+						attr |= w.oldattr & backgroundMask
+					}
+					procSetConsoleTextAttribute.Call(uintptr(w.handle), uintptr(attr))
+				}
+			}
+		}
+	}
+	return len(data) - w.lastbuf.Len(), nil
+}
+
+type consoleColor struct {
+	red       bool
+	green     bool
+	blue      bool
+	intensity bool
+}
+
+func minmax3(a, b, c int) (min, max int) {
+	if a < b {
+		if b < c {
+			return a, c
+		} else if a < c {
+			return a, b
+		} else {
+			return c, b
+		}
+	} else {
+		if a < c {
+			return b, c
+		} else if b < c {
+			return b, a
+		} else {
+			return c, a
+		}
+	}
+}
+
+func toConsoleColor(rgb int) (c consoleColor) {
+	r, g, b := (rgb&0xFF0000)>>16, (rgb&0x00FF00)>>8, rgb&0x0000FF
+	min, max := minmax3(r, g, b)
+	a := (min + max) / 2
+	if r < 128 && g < 128 && b < 128 {
+		if r >= a {
+			c.red = true
+		}
+		if g >= a {
+			c.green = true
+		}
+		if b >= a {
+			c.blue = true
+		}
+		// non-intensed white is lighter than intensed black, so swap those.
+		if c.red && c.green && c.blue {
+			c.red, c.green, c.blue = false, false, false
+			c.intensity = true
+		}
+	} else {
+		if min < 128 {
+			min = 128
+			a = (min + max) / 2
+		}
+		if r >= a {
+			c.red = true
+		}
+		if g >= a {
+			c.green = true
+		}
+		if b >= a {
+			c.blue = true
+		}
+		c.intensity = true
+		// intensed black is darker than non-intensed white, so swap those.
+		if !c.red && !c.green && !c.blue {
+			c.red, c.green, c.blue = true, true, true
+			c.intensity = false
+		}
+	}
+	return c
+}
+
+func (c consoleColor) foregroundAttr() (attr word) {
+	if c.red {
+		attr |= foregroundRed
+	}
+	if c.green {
+		attr |= foregroundGreen
+	}
+	if c.blue {
+		attr |= foregroundBlue
+	}
+	if c.intensity {
+		attr |= foregroundIntensity
+	}
+	return
+}
+
+func (c consoleColor) backgroundAttr() (attr word) {
+	if c.red {
+		attr |= backgroundRed
+	}
+	if c.green {
+		attr |= backgroundGreen
+	}
+	if c.blue {
+		attr |= backgroundBlue
+	}
+	if c.intensity {
+		attr |= backgroundIntensity
+	}
+	return
+}
+
+var n256foreAttr []word
+var n256backAttr []word
+
+func n256setup() {
+	n256foreAttr = make([]word, 256)
+	n256backAttr = make([]word, 256)
+	for i, rgb := range color256 {
+		c := toConsoleColor(rgb)
+		n256foreAttr[i] = c.foregroundAttr()
+		n256backAttr[i] = c.backgroundAttr()
+	}
+}
diff --git a/vendor/github.com/mattn/go-isatty/LICENSE b/vendor/github.com/mattn/go-isatty/LICENSE
new file mode 100644
index 0000000..65dc692
--- /dev/null
+++ b/vendor/github.com/mattn/go-isatty/LICENSE
@@ -0,0 +1,9 @@
+Copyright (c) Yasuhiro MATSUMOTO <mattn.jp@gmail.com>
+
+MIT License (Expat)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/vendor/github.com/mattn/go-isatty/README.md b/vendor/github.com/mattn/go-isatty/README.md
new file mode 100644
index 0000000..74845de
--- /dev/null
+++ b/vendor/github.com/mattn/go-isatty/README.md
@@ -0,0 +1,37 @@
+# go-isatty
+
+isatty for golang
+
+## Usage
+
+```go
+package main
+
+import (
+	"fmt"
+	"github.com/mattn/go-isatty"
+	"os"
+)
+
+func main() {
+	if isatty.IsTerminal(os.Stdout.Fd()) {
+		fmt.Println("Is Terminal")
+	} else {
+		fmt.Println("Is Not Terminal")
+	}
+}
+```
+
+## Installation
+
+```
+$ go get github.com/mattn/go-isatty
+```
+
+# License
+
+MIT
+
+# Author
+
+Yasuhiro Matsumoto (a.k.a mattn)
diff --git a/vendor/github.com/mattn/go-isatty/doc.go b/vendor/github.com/mattn/go-isatty/doc.go
new file mode 100644
index 0000000..17d4f90
--- /dev/null
+++ b/vendor/github.com/mattn/go-isatty/doc.go
@@ -0,0 +1,2 @@
+// Package isatty implements interface to isatty
+package isatty
diff --git a/vendor/github.com/mattn/go-isatty/isatty_bsd.go b/vendor/github.com/mattn/go-isatty/isatty_bsd.go
new file mode 100644
index 0000000..e6282b5
--- /dev/null
+++ b/vendor/github.com/mattn/go-isatty/isatty_bsd.go
@@ -0,0 +1,17 @@
+// +build darwin freebsd openbsd netbsd
+
+package isatty
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+const ioctlReadTermios = syscall.TIOCGETA
+
+// IsTerminal return true if the file descriptor is terminal.
+func IsTerminal(fd uintptr) bool {
+	var termios syscall.Termios
+	_, _, err := syscall.Syscall6(syscall.SYS_IOCTL, fd, ioctlReadTermios, uintptr(unsafe.Pointer(&termios)), 0, 0, 0)
+	return err == 0
+}
diff --git a/vendor/github.com/mattn/go-isatty/isatty_linux.go b/vendor/github.com/mattn/go-isatty/isatty_linux.go
new file mode 100644
index 0000000..8b361d7
--- /dev/null
+++ b/vendor/github.com/mattn/go-isatty/isatty_linux.go
@@ -0,0 +1,17 @@
+// +build linux
+
+package isatty
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+const ioctlReadTermios = syscall.TCGETS
+
+// IsTerminal return true if the file descriptor is terminal.
+func IsTerminal(fd uintptr) bool {
+	var termios syscall.Termios
+	_, _, err := syscall.Syscall6(syscall.SYS_IOCTL, fd, ioctlReadTermios, uintptr(unsafe.Pointer(&termios)), 0, 0, 0)
+	return err == 0
+}
diff --git a/vendor/github.com/mattn/go-isatty/isatty_windows.go b/vendor/github.com/mattn/go-isatty/isatty_windows.go
new file mode 100644
index 0000000..562ee39
--- /dev/null
+++ b/vendor/github.com/mattn/go-isatty/isatty_windows.go
@@ -0,0 +1,18 @@
+// +build windows
+
+package isatty
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+var kernel32 = syscall.NewLazyDLL("kernel32.dll")
+var procGetConsoleMode = kernel32.NewProc("GetConsoleMode")
+
+// IsTerminal return true if the file descriptor is terminal.
+func IsTerminal(fd uintptr) bool {
+	var st uint32
+	r, _, e := syscall.Syscall(procGetConsoleMode.Addr(), 2, fd, uintptr(unsafe.Pointer(&st)), 0)
+	return r != 0 && e == 0
+}
diff --git a/vendor/golang.org/x/net/AUTHORS b/vendor/golang.org/x/net/AUTHORS
new file mode 100644
index 0000000..15167cd
--- /dev/null
+++ b/vendor/golang.org/x/net/AUTHORS
@@ -0,0 +1,3 @@
+# This source code refers to The Go Authors for copyright purposes.
+# The master list of authors is in the main Go distribution,
+# visible at http://tip.golang.org/AUTHORS.
diff --git a/vendor/golang.org/x/net/CONTRIBUTORS b/vendor/golang.org/x/net/CONTRIBUTORS
new file mode 100644
index 0000000..1c4577e
--- /dev/null
+++ b/vendor/golang.org/x/net/CONTRIBUTORS
@@ -0,0 +1,3 @@
+# This source code was written by the Go contributors.
+# The master list of contributors is in the main Go distribution,
+# visible at http://tip.golang.org/CONTRIBUTORS.
diff --git a/vendor/golang.org/x/net/LICENSE b/vendor/golang.org/x/net/LICENSE
new file mode 100644
index 0000000..6a66aea
--- /dev/null
+++ b/vendor/golang.org/x/net/LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) 2009 The Go Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/golang.org/x/net/PATENTS b/vendor/golang.org/x/net/PATENTS
new file mode 100644
index 0000000..7330990
--- /dev/null
+++ b/vendor/golang.org/x/net/PATENTS
@@ -0,0 +1,22 @@
+Additional IP Rights Grant (Patents)
+
+"This implementation" means the copyrightable works distributed by
+Google as part of the Go project.
+
+Google hereby grants to You a perpetual, worldwide, non-exclusive,
+no-charge, royalty-free, irrevocable (except as stated in this section)
+patent license to make, have made, use, offer to sell, sell, import,
+transfer and otherwise run, modify and propagate the contents of this
+implementation of Go, where such license applies only to those patent
+claims, both currently owned or controlled by Google and acquired in
+the future, licensable by Google that are necessarily infringed by this
+implementation of Go.  This grant does not include claims that would be
+infringed only as a consequence of further modification of this
+implementation.  If you or your agent or exclusive licensee institute or
+order or agree to the institution of patent litigation against any
+entity (including a cross-claim or counterclaim in a lawsuit) alleging
+that this implementation of Go or any code incorporated within this
+implementation of Go constitutes direct or contributory patent
+infringement, or inducement of patent infringement, then any patent
+rights granted to you under this License for this implementation of Go
+shall terminate as of the date such litigation is filed.
diff --git a/vendor/golang.org/x/net/context/context.go b/vendor/golang.org/x/net/context/context.go
new file mode 100644
index 0000000..e7ee376
--- /dev/null
+++ b/vendor/golang.org/x/net/context/context.go
@@ -0,0 +1,447 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package context defines the Context type, which carries deadlines,
+// cancelation signals, and other request-scoped values across API boundaries
+// and between processes.
+//
+// Incoming requests to a server should create a Context, and outgoing calls to
+// servers should accept a Context.  The chain of function calls between must
+// propagate the Context, optionally replacing it with a modified copy created
+// using WithDeadline, WithTimeout, WithCancel, or WithValue.
+//
+// Programs that use Contexts should follow these rules to keep interfaces
+// consistent across packages and enable static analysis tools to check context
+// propagation:
+//
+// Do not store Contexts inside a struct type; instead, pass a Context
+// explicitly to each function that needs it.  The Context should be the first
+// parameter, typically named ctx:
+//
+// 	func DoSomething(ctx context.Context, arg Arg) error {
+// 		// ... use ctx ...
+// 	}
+//
+// Do not pass a nil Context, even if a function permits it.  Pass context.TODO
+// if you are unsure about which Context to use.
+//
+// Use context Values only for request-scoped data that transits processes and
+// APIs, not for passing optional parameters to functions.
+//
+// The same Context may be passed to functions running in different goroutines;
+// Contexts are safe for simultaneous use by multiple goroutines.
+//
+// See http://blog.golang.org/context for example code for a server that uses
+// Contexts.
+package context // import "golang.org/x/net/context"
+
+import (
+	"errors"
+	"fmt"
+	"sync"
+	"time"
+)
+
+// A Context carries a deadline, a cancelation signal, and other values across
+// API boundaries.
+//
+// Context's methods may be called by multiple goroutines simultaneously.
+type Context interface {
+	// 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.
+	Deadline() (deadline time.Time, ok bool)
+
+	// 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.
+	//
+	// WithCancel arranges for Done to be closed when cancel is called;
+	// WithDeadline arranges for Done to be closed when the deadline
+	// expires; WithTimeout arranges for Done to be closed when the timeout
+	// elapses.
+	//
+	// Done is provided for use in select statements:
+	//
+	//  // Stream generates values with DoSomething and sends them to out
+	//  // until DoSomething returns an error or ctx.Done is closed.
+	//  func Stream(ctx context.Context, out <-chan Value) error {
+	//  	for {
+	//  		v, err := DoSomething(ctx)
+	//  		if err != nil {
+	//  			return err
+	//  		}
+	//  		select {
+	//  		case <-ctx.Done():
+	//  			return ctx.Err()
+	//  		case out <- v:
+	//  		}
+	//  	}
+	//  }
+	//
+	// See http://blog.golang.org/pipelines for more examples of how to use
+	// a Done channel for cancelation.
+	Done() <-chan struct{}
+
+	// Err returns a non-nil error value after Done is closed.  Err returns
+	// Canceled if the context was canceled or DeadlineExceeded if the
+	// context's deadline passed.  No other values for Err are defined.
+	// After Done is closed, successive calls to Err return the same value.
+	Err() error
+
+	// 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.
+	//
+	// Use context values only for request-scoped data that transits
+	// processes and API boundaries, not for passing optional parameters to
+	// functions.
+	//
+	// A key identifies a specific value in a Context.  Functions that wish
+	// to store values in Context typically allocate a key in a global
+	// variable then use that key as the argument to context.WithValue and
+	// Context.Value.  A key can be any type that supports equality;
+	// packages should define keys as an unexported type to avoid
+	// collisions.
+	//
+	// Packages that define a Context key should provide type-safe accessors
+	// for the values stores using that key:
+	//
+	// 	// Package user defines a User type that's stored in Contexts.
+	// 	package user
+	//
+	// 	import "golang.org/x/net/context"
+	//
+	// 	// User is the type of value stored in the Contexts.
+	// 	type User struct {...}
+	//
+	// 	// key is an unexported type for keys defined in this package.
+	// 	// This prevents collisions with keys defined in other packages.
+	// 	type key int
+	//
+	// 	// userKey is the key for user.User values in Contexts.  It is
+	// 	// unexported; clients use user.NewContext and user.FromContext
+	// 	// instead of using this key directly.
+	// 	var userKey key = 0
+	//
+	// 	// NewContext returns a new Context that carries value u.
+	// 	func NewContext(ctx context.Context, u *User) context.Context {
+	// 		return context.WithValue(ctx, userKey, u)
+	// 	}
+	//
+	// 	// FromContext returns the User value stored in ctx, if any.
+	// 	func FromContext(ctx context.Context) (*User, bool) {
+	// 		u, ok := ctx.Value(userKey).(*User)
+	// 		return u, ok
+	// 	}
+	Value(key interface{}) interface{}
+}
+
+// Canceled is the error returned by Context.Err when the context is canceled.
+var Canceled = errors.New("context canceled")
+
+// DeadlineExceeded is the error returned by Context.Err when the context's
+// deadline passes.
+var DeadlineExceeded = errors.New("context deadline exceeded")
+
+// An emptyCtx is never canceled, has no values, and has no deadline.  It is not
+// struct{}, since vars of this type must have distinct addresses.
+type emptyCtx int
+
+func (*emptyCtx) Deadline() (deadline time.Time, ok bool) {
+	return
+}
+
+func (*emptyCtx) Done() <-chan struct{} {
+	return nil
+}
+
+func (*emptyCtx) Err() error {
+	return nil
+}
+
+func (*emptyCtx) Value(key interface{}) interface{} {
+	return nil
+}
+
+func (e *emptyCtx) String() string {
+	switch e {
+	case background:
+		return "context.Background"
+	case todo:
+		return "context.TODO"
+	}
+	return "unknown empty Context"
+}
+
+var (
+	background = new(emptyCtx)
+	todo       = new(emptyCtx)
+)
+
+// Background returns a non-nil, empty Context. It is never canceled, has no
+// values, and has no deadline.  It is typically used by the main function,
+// initialization, and tests, and as the top-level Context for incoming
+// requests.
+func Background() Context {
+	return background
+}
+
+// TODO returns a non-nil, empty Context.  Code should use context.TODO when
+// it's unclear which Context to use or it's is not yet available (because the
+// surrounding function has not yet been extended to accept a Context
+// parameter).  TODO is recognized by static analysis tools that determine
+// whether Contexts are propagated correctly in a program.
+func TODO() Context {
+	return todo
+}
+
+// A CancelFunc tells an operation to abandon its work.
+// A CancelFunc does not wait for the work to stop.
+// After the first call, subsequent calls to a CancelFunc do nothing.
+type CancelFunc func()
+
+// WithCancel returns a copy of parent with a new Done channel. The returned
+// context's Done channel is closed when the returned cancel function is called
+// or when the parent context's Done channel is closed, whichever happens first.
+//
+// Canceling this context releases resources associated with it, so code should
+// call cancel as soon as the operations running in this Context complete.
+func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {
+	c := newCancelCtx(parent)
+	propagateCancel(parent, &c)
+	return &c, func() { c.cancel(true, Canceled) }
+}
+
+// newCancelCtx returns an initialized cancelCtx.
+func newCancelCtx(parent Context) cancelCtx {
+	return cancelCtx{
+		Context: parent,
+		done:    make(chan struct{}),
+	}
+}
+
+// propagateCancel arranges for child to be canceled when parent is.
+func propagateCancel(parent Context, child canceler) {
+	if parent.Done() == nil {
+		return // parent is never canceled
+	}
+	if p, ok := parentCancelCtx(parent); ok {
+		p.mu.Lock()
+		if p.err != nil {
+			// parent has already been canceled
+			child.cancel(false, p.err)
+		} else {
+			if p.children == nil {
+				p.children = make(map[canceler]bool)
+			}
+			p.children[child] = true
+		}
+		p.mu.Unlock()
+	} else {
+		go func() {
+			select {
+			case <-parent.Done():
+				child.cancel(false, parent.Err())
+			case <-child.Done():
+			}
+		}()
+	}
+}
+
+// parentCancelCtx follows a chain of parent references until it finds a
+// *cancelCtx.  This function understands how each of the concrete types in this
+// package represents its parent.
+func parentCancelCtx(parent Context) (*cancelCtx, bool) {
+	for {
+		switch c := parent.(type) {
+		case *cancelCtx:
+			return c, true
+		case *timerCtx:
+			return &c.cancelCtx, true
+		case *valueCtx:
+			parent = c.Context
+		default:
+			return nil, false
+		}
+	}
+}
+
+// removeChild removes a context from its parent.
+func removeChild(parent Context, child canceler) {
+	p, ok := parentCancelCtx(parent)
+	if !ok {
+		return
+	}
+	p.mu.Lock()
+	if p.children != nil {
+		delete(p.children, child)
+	}
+	p.mu.Unlock()
+}
+
+// A canceler is a context type that can be canceled directly.  The
+// implementations are *cancelCtx and *timerCtx.
+type canceler interface {
+	cancel(removeFromParent bool, err error)
+	Done() <-chan struct{}
+}
+
+// A cancelCtx can be canceled.  When canceled, it also cancels any children
+// that implement canceler.
+type cancelCtx struct {
+	Context
+
+	done chan struct{} // closed by the first cancel call.
+
+	mu       sync.Mutex
+	children map[canceler]bool // set to nil by the first cancel call
+	err      error             // set to non-nil by the first cancel call
+}
+
+func (c *cancelCtx) Done() <-chan struct{} {
+	return c.done
+}
+
+func (c *cancelCtx) Err() error {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	return c.err
+}
+
+func (c *cancelCtx) String() string {
+	return fmt.Sprintf("%v.WithCancel", c.Context)
+}
+
+// cancel closes c.done, cancels each of c's children, and, if
+// removeFromParent is true, removes c from its parent's children.
+func (c *cancelCtx) cancel(removeFromParent bool, err error) {
+	if err == nil {
+		panic("context: internal error: missing cancel error")
+	}
+	c.mu.Lock()
+	if c.err != nil {
+		c.mu.Unlock()
+		return // already canceled
+	}
+	c.err = err
+	close(c.done)
+	for child := range c.children {
+		// NOTE: acquiring the child's lock while holding parent's lock.
+		child.cancel(false, err)
+	}
+	c.children = nil
+	c.mu.Unlock()
+
+	if removeFromParent {
+		removeChild(c.Context, c)
+	}
+}
+
+// WithDeadline returns a copy of the parent context with the deadline adjusted
+// to be no later than d.  If the parent's deadline is already earlier than d,
+// WithDeadline(parent, d) is semantically equivalent to parent.  The returned
+// context's Done channel is closed when the deadline expires, when the returned
+// cancel function is called, or when the parent context's Done channel is
+// closed, whichever happens first.
+//
+// Canceling this context releases resources associated with it, so code should
+// call cancel as soon as the operations running in this Context complete.
+func WithDeadline(parent Context, deadline time.Time) (Context, CancelFunc) {
+	if cur, ok := parent.Deadline(); ok && cur.Before(deadline) {
+		// The current deadline is already sooner than the new one.
+		return WithCancel(parent)
+	}
+	c := &timerCtx{
+		cancelCtx: newCancelCtx(parent),
+		deadline:  deadline,
+	}
+	propagateCancel(parent, c)
+	d := deadline.Sub(time.Now())
+	if d <= 0 {
+		c.cancel(true, DeadlineExceeded) // deadline has already passed
+		return c, func() { c.cancel(true, Canceled) }
+	}
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	if c.err == nil {
+		c.timer = time.AfterFunc(d, func() {
+			c.cancel(true, DeadlineExceeded)
+		})
+	}
+	return c, func() { c.cancel(true, Canceled) }
+}
+
+// A timerCtx carries a timer and a deadline.  It embeds a cancelCtx to
+// implement Done and Err.  It implements cancel by stopping its timer then
+// delegating to cancelCtx.cancel.
+type timerCtx struct {
+	cancelCtx
+	timer *time.Timer // Under cancelCtx.mu.
+
+	deadline time.Time
+}
+
+func (c *timerCtx) Deadline() (deadline time.Time, ok bool) {
+	return c.deadline, true
+}
+
+func (c *timerCtx) String() string {
+	return fmt.Sprintf("%v.WithDeadline(%s [%s])", c.cancelCtx.Context, c.deadline, c.deadline.Sub(time.Now()))
+}
+
+func (c *timerCtx) cancel(removeFromParent bool, err error) {
+	c.cancelCtx.cancel(false, err)
+	if removeFromParent {
+		// Remove this timerCtx from its parent cancelCtx's children.
+		removeChild(c.cancelCtx.Context, c)
+	}
+	c.mu.Lock()
+	if c.timer != nil {
+		c.timer.Stop()
+		c.timer = nil
+	}
+	c.mu.Unlock()
+}
+
+// WithTimeout returns WithDeadline(parent, time.Now().Add(timeout)).
+//
+// Canceling this context releases resources associated with it, so code should
+// call cancel as soon as the operations running in this Context complete:
+//
+// 	func slowOperationWithTimeout(ctx context.Context) (Result, error) {
+// 		ctx, cancel := context.WithTimeout(ctx, 100*time.Millisecond)
+// 		defer cancel()  // releases resources if slowOperation completes before timeout elapses
+// 		return slowOperation(ctx)
+// 	}
+func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) {
+	return WithDeadline(parent, time.Now().Add(timeout))
+}
+
+// WithValue returns a copy of parent in which the value associated with key is
+// val.
+//
+// Use context Values only for request-scoped data that transits processes and
+// APIs, not for passing optional parameters to functions.
+func WithValue(parent Context, key interface{}, val interface{}) Context {
+	return &valueCtx{parent, key, val}
+}
+
+// A valueCtx carries a key-value pair.  It implements Value for that key and
+// delegates all other calls to the embedded Context.
+type valueCtx struct {
+	Context
+	key, val interface{}
+}
+
+func (c *valueCtx) String() string {
+	return fmt.Sprintf("%v.WithValue(%#v, %#v)", c.Context, c.key, c.val)
+}
+
+func (c *valueCtx) Value(key interface{}) interface{} {
+	if c.key == key {
+		return c.val
+	}
+	return c.Context.Value(key)
+}
diff --git a/vendor/gopkg.in/bluesuncorp/validator.v5/.gitignore b/vendor/gopkg.in/bluesuncorp/validator.v5/.gitignore
new file mode 100644
index 0000000..4159020
--- /dev/null
+++ b/vendor/gopkg.in/bluesuncorp/validator.v5/.gitignore
@@ -0,0 +1,26 @@
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe
+*.test
+*.prof
+*.test
+*.out
\ No newline at end of file
diff --git a/vendor/gopkg.in/bluesuncorp/validator.v5/.travis.yml b/vendor/gopkg.in/bluesuncorp/validator.v5/.travis.yml
new file mode 100644
index 0000000..68398d9
--- /dev/null
+++ b/vendor/gopkg.in/bluesuncorp/validator.v5/.travis.yml
@@ -0,0 +1,13 @@
+language: go
+
+notificaitons:
+  email:
+    recipients: bluesuncorp01@gmail.com
+    on_success: change
+    on_failure: always
+
+go:
+  - 1.2
+  - 1.3
+  - 1.4
+  - tip
\ No newline at end of file
diff --git a/vendor/gopkg.in/bluesuncorp/validator.v5/LICENSE b/vendor/gopkg.in/bluesuncorp/validator.v5/LICENSE
new file mode 100644
index 0000000..6a2ae9a
--- /dev/null
+++ b/vendor/gopkg.in/bluesuncorp/validator.v5/LICENSE
@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Dean Karn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
diff --git a/vendor/gopkg.in/bluesuncorp/validator.v5/README.md b/vendor/gopkg.in/bluesuncorp/validator.v5/README.md
new file mode 100644
index 0000000..c1e9d00
--- /dev/null
+++ b/vendor/gopkg.in/bluesuncorp/validator.v5/README.md
@@ -0,0 +1,44 @@
+Package validator
+================
+[![Build Status](https://travis-ci.org/bluesuncorp/validator.svg?branch=v5.1)](https://travis-ci.org/bluesuncorp/validator)
+[![GoDoc](https://godoc.org/gopkg.in/bluesuncorp/validator.v5?status.svg)](https://godoc.org/gopkg.in/bluesuncorp/validator.v5)
+
+Package validator implements value validations for structs and individual fields based on tags.
+It is also capable of Cross Field and Cross Struct validations.
+
+Installation
+============
+
+Use go get.
+
+	go get gopkg.in/bluesuncorp/validator.v5
+
+or to update
+
+	go get -u gopkg.in/bluesuncorp/validator.v5
+
+Then import the validator package into your own code.
+
+	import "gopkg.in/bluesuncorp/validator.v5"
+
+Usage and documentation
+=======================
+
+Please see http://godoc.org/gopkg.in/bluesuncorp/validator.v5 for detailed usage docs.
+
+How to Contribute
+=================
+
+There will always be a development branch for each version i.e. `v1-development`. In order to contribute, 
+please make your pull requests against those branches.
+
+If the changes being proposed or requested are breaking changes, please create an issue, for discussion 
+or create a pull request against the highest development branch for example this package has a 
+v1 and v1-development branch however, there will also be a v2-development brach even though v2 doesn't exist yet.
+
+I strongly encourage everyone whom creates a custom validation function to contribute them and
+help make this package even better.
+
+License
+=======
+Distributed under MIT License, please see license file in code for more details.
diff --git a/vendor/gopkg.in/bluesuncorp/validator.v5/baked_in.go b/vendor/gopkg.in/bluesuncorp/validator.v5/baked_in.go
new file mode 100644
index 0000000..22746ad
--- /dev/null
+++ b/vendor/gopkg.in/bluesuncorp/validator.v5/baked_in.go
@@ -0,0 +1,999 @@
+package validator
+
+import (
+	"fmt"
+	"net/url"
+	"reflect"
+	"strconv"
+	"strings"
+	"time"
+	"unicode/utf8"
+)
+
+// BakedInValidators is the default map of ValidationFunc
+// you can add, remove or even replace items to suite your needs,
+// or even disregard and use your own map if so desired.
+var BakedInValidators = map[string]Func{
+	"required":     hasValue,
+	"len":          hasLengthOf,
+	"min":          hasMinOf,
+	"max":          hasMaxOf,
+	"eq":           isEq,
+	"ne":           isNe,
+	"lt":           isLt,
+	"lte":          isLte,
+	"gt":           isGt,
+	"gte":          isGte,
+	"eqfield":      isEqField,
+	"nefield":      isNeField,
+	"gtefield":     isGteField,
+	"gtfield":      isGtField,
+	"ltefield":     isLteField,
+	"ltfield":      isLtField,
+	"alpha":        isAlpha,
+	"alphanum":     isAlphanum,
+	"numeric":      isNumeric,
+	"number":       isNumber,
+	"hexadecimal":  isHexadecimal,
+	"hexcolor":     isHexcolor,
+	"rgb":          isRgb,
+	"rgba":         isRgba,
+	"hsl":          isHsl,
+	"hsla":         isHsla,
+	"email":        isEmail,
+	"url":          isURL,
+	"uri":          isURI,
+	"base64":       isBase64,
+	"contains":     contains,
+	"containsany":  containsAny,
+	"containsrune": containsRune,
+	"excludes":     excludes,
+	"excludesall":  excludesAll,
+	"excludesrune": excludesRune,
+	"isbn":         isISBN,
+	"isbn10":       isISBN10,
+	"isbn13":       isISBN13,
+	"uuid":         isUUID,
+	"uuid3":        isUUID3,
+	"uuid4":        isUUID4,
+	"uuid5":        isUUID5,
+	"ascii":        isASCII,
+	"printascii":   isPrintableASCII,
+	"multibyte":    hasMultiByteCharacter,
+	"datauri":      isDataURI,
+	"latitude":     isLatitude,
+	"longitude":    isLongitude,
+	"ssn":          isSSN,
+}
+
+func isSSN(top interface{}, current interface{}, field interface{}, param string) bool {
+
+	if len(field.(string)) != 11 {
+		return false
+	}
+
+	return matchesRegex(sSNRegex, field)
+}
+
+func isLongitude(top interface{}, current interface{}, field interface{}, param string) bool {
+	return matchesRegex(longitudeRegex, field)
+}
+
+func isLatitude(top interface{}, current interface{}, field interface{}, param string) bool {
+	return matchesRegex(latitudeRegex, field)
+}
+
+func isDataURI(top interface{}, current interface{}, field interface{}, param string) bool {
+
+	uri := strings.SplitN(field.(string), ",", 2)
+
+	if len(uri) != 2 {
+		return false
+	}
+
+	if !matchesRegex(dataURIRegex, uri[0]) {
+		return false
+	}
+
+	return isBase64(top, current, uri[1], param)
+}
+
+func hasMultiByteCharacter(top interface{}, current interface{}, field interface{}, param string) bool {
+
+	if len(field.(string)) == 0 {
+		return true
+	}
+
+	return matchesRegex(multibyteRegex, field)
+}
+
+func isPrintableASCII(top interface{}, current interface{}, field interface{}, param string) bool {
+	return matchesRegex(printableASCIIRegex, field)
+}
+
+func isASCII(top interface{}, current interface{}, field interface{}, param string) bool {
+	return matchesRegex(aSCIIRegex, field)
+}
+
+func isUUID5(top interface{}, current interface{}, field interface{}, param string) bool {
+	return matchesRegex(uUID5Regex, field)
+}
+
+func isUUID4(top interface{}, current interface{}, field interface{}, param string) bool {
+	return matchesRegex(uUID4Regex, field)
+}
+
+func isUUID3(top interface{}, current interface{}, field interface{}, param string) bool {
+	return matchesRegex(uUID3Regex, field)
+}
+
+func isUUID(top interface{}, current interface{}, field interface{}, param string) bool {
+	return matchesRegex(uUIDRegex, field)
+}
+
+func isISBN(top interface{}, current interface{}, field interface{}, param string) bool {
+	return isISBN10(top, current, field, param) || isISBN13(top, current, field, param)
+}
+
+func isISBN13(top interface{}, current interface{}, field interface{}, param string) bool {
+
+	s := strings.Replace(strings.Replace(field.(string), "-", "", 4), " ", "", 4)
+
+	if !matchesRegex(iSBN13Regex, s) {
+		return false
+	}
+
+	var checksum int32
+	var i int32
+
+	factor := []int32{1, 3}
+
+	for i = 0; i < 12; i++ {
+		checksum += factor[i%2] * int32(s[i]-'0')
+	}
+
+	if (int32(s[12]-'0'))-((10-(checksum%10))%10) == 0 {
+		return true
+	}
+
+	return false
+}
+
+func isISBN10(top interface{}, current interface{}, field interface{}, param string) bool {
+
+	s := strings.Replace(strings.Replace(field.(string), "-", "", 3), " ", "", 3)
+
+	if !matchesRegex(iSBN10Regex, s) {
+		return false
+	}
+
+	var checksum int32
+	var i int32
+
+	for i = 0; i < 9; i++ {
+		checksum += (i + 1) * int32(s[i]-'0')
+	}
+
+	if s[9] == 'X' {
+		checksum += 10 * 10
+	} else {
+		checksum += 10 * int32(s[9]-'0')
+	}
+
+	if checksum%11 == 0 {
+		return true
+	}
+
+	return false
+}
+
+func excludesRune(top interface{}, current interface{}, field interface{}, param string) bool {
+	return !containsRune(top, current, field, param)
+}
+
+func excludesAll(top interface{}, current interface{}, field interface{}, param string) bool {
+	return !containsAny(top, current, field, param)
+}
+
+func excludes(top interface{}, current interface{}, field interface{}, param string) bool {
+	return !contains(top, current, field, param)
+}
+
+func containsRune(top interface{}, current interface{}, field interface{}, param string) bool {
+	r, _ := utf8.DecodeRuneInString(param)
+
+	return strings.ContainsRune(field.(string), r)
+}
+
+func containsAny(top interface{}, current interface{}, field interface{}, param string) bool {
+	return strings.ContainsAny(field.(string), param)
+}
+
+func contains(top interface{}, current interface{}, field interface{}, param string) bool {
+	return strings.Contains(field.(string), param)
+}
+
+func isNeField(top interface{}, current interface{}, field interface{}, param string) bool {
+	return !isEqField(top, current, field, param)
+}
+
+func isNe(top interface{}, current interface{}, field interface{}, param string) bool {
+	return !isEq(top, current, field, param)
+}
+
+func isEqField(top interface{}, current interface{}, field interface{}, param string) bool {
+
+	if current == nil {
+		panic("struct not passed for cross validation")
+	}
+
+	currentVal := reflect.ValueOf(current)
+
+	if currentVal.Kind() == reflect.Ptr && !currentVal.IsNil() {
+		currentVal = reflect.ValueOf(currentVal.Elem().Interface())
+	}
+
+	var currentFielVal reflect.Value
+
+	switch currentVal.Kind() {
+
+	case reflect.Struct:
+
+		if currentVal.Type() == reflect.TypeOf(time.Time{}) {
+			currentFielVal = currentVal
+			break
+		}
+
+		f := currentVal.FieldByName(param)
+
+		if f.Kind() == reflect.Invalid {
+			panic(fmt.Sprintf("Field \"%s\" not found in struct", param))
+		}
+
+		currentFielVal = f
+
+	default:
+
+		currentFielVal = currentVal
+	}
+
+	if currentFielVal.Kind() == reflect.Ptr && !currentFielVal.IsNil() {
+
+		currentFielVal = reflect.ValueOf(currentFielVal.Elem().Interface())
+	}
+
+	fv := reflect.ValueOf(field)
+
+	switch fv.Kind() {
+
+	case reflect.String:
+		return fv.String() == currentFielVal.String()
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+
+		return fv.Int() == currentFielVal.Int()
+
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+
+		return fv.Uint() == currentFielVal.Uint()
+
+	case reflect.Float32, reflect.Float64:
+
+		return fv.Float() == currentFielVal.Float()
+	case reflect.Slice, reflect.Map, reflect.Array:
+
+		return int64(fv.Len()) == int64(currentFielVal.Len())
+	case reflect.Struct:
+
+		if fv.Type() == reflect.TypeOf(time.Time{}) {
+
+			if currentFielVal.Type() != reflect.TypeOf(time.Time{}) {
+				panic("Bad Top Level field type")
+			}
+
+			t := currentFielVal.Interface().(time.Time)
+			fieldTime := field.(time.Time)
+
+			return fieldTime.Equal(t)
+		}
+	}
+
+	panic(fmt.Sprintf("Bad field type %T", field))
+}
+
+func isEq(top interface{}, current interface{}, field interface{}, param string) bool {
+
+	st := reflect.ValueOf(field)
+
+	switch st.Kind() {
+
+	case reflect.String:
+
+		return st.String() == param
+
+	case reflect.Slice, reflect.Map, reflect.Array:
+		p := asInt(param)
+
+		return int64(st.Len()) == p
+
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		p := asInt(param)
+
+		return st.Int() == p
+
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		p := asUint(param)
+
+		return st.Uint() == p
+
+	case reflect.Float32, reflect.Float64:
+		p := asFloat(param)
+
+		return st.Float() == p
+	}
+
+	panic(fmt.Sprintf("Bad field type %T", field))
+}
+
+func isBase64(top interface{}, current interface{}, field interface{}, param string) bool {
+	return matchesRegex(base64Regex, field)
+}
+
+func isURI(top interface{}, current interface{}, field interface{}, param string) bool {
+
+	st := reflect.ValueOf(field)
+
+	switch st.Kind() {
+
+	case reflect.String:
+		_, err := url.ParseRequestURI(field.(string))
+
+		return err == nil
+	}
+
+	panic(fmt.Sprintf("Bad field type %T", field))
+}
+
+func isURL(top interface{}, current interface{}, field interface{}, param string) bool {
+	st := reflect.ValueOf(field)
+
+	switch st.Kind() {
+
+	case reflect.String:
+		url, err := url.ParseRequestURI(field.(string))
+
+		if err != nil {
+			return false
+		}
+
+		if len(url.Scheme) == 0 {
+			return false
+		}
+
+		return err == nil
+	}
+
+	panic(fmt.Sprintf("Bad field type %T", field))
+}
+
+func isEmail(top interface{}, current interface{}, field interface{}, param string) bool {
+	return matchesRegex(emailRegex, field)
+}
+
+func isHsla(top interface{}, current interface{}, field interface{}, param string) bool {
+	return matchesRegex(hslaRegex, field)
+}
+
+func isHsl(top interface{}, current interface{}, field interface{}, param string) bool {
+	return matchesRegex(hslRegex, field)
+}
+
+func isRgba(top interface{}, current interface{}, field interface{}, param string) bool {
+	return matchesRegex(rgbaRegex, field)
+}
+
+func isRgb(top interface{}, current interface{}, field interface{}, param string) bool {
+	return matchesRegex(rgbRegex, field)
+}
+
+func isHexcolor(top interface{}, current interface{}, field interface{}, param string) bool {
+	return matchesRegex(hexcolorRegex, field)
+}
+
+func isHexadecimal(top interface{}, current interface{}, field interface{}, param string) bool {
+	return matchesRegex(hexadecimalRegex, field)
+}
+
+func isNumber(top interface{}, current interface{}, field interface{}, param string) bool {
+	return matchesRegex(numberRegex, field)
+}
+
+func isNumeric(top interface{}, current interface{}, field interface{}, param string) bool {
+	return matchesRegex(numericRegex, field)
+}
+
+func isAlphanum(top interface{}, current interface{}, field interface{}, param string) bool {
+	return matchesRegex(alphaNumericRegex, field)
+}
+
+func isAlpha(top interface{}, current interface{}, field interface{}, param string) bool {
+	return matchesRegex(alphaRegex, field)
+}
+
+func hasValue(top interface{}, current interface{}, field interface{}, param string) bool {
+
+	st := reflect.ValueOf(field)
+
+	switch st.Kind() {
+
+	case reflect.Slice, reflect.Map, reflect.Array:
+		return field != nil && int64(st.Len()) > 0
+
+	default:
+		return field != nil && field != reflect.Zero(reflect.TypeOf(field)).Interface()
+	}
+}
+
+func isGteField(top interface{}, current interface{}, field interface{}, param string) bool {
+
+	if current == nil {
+		panic("struct not passed for cross validation")
+	}
+
+	currentVal := reflect.ValueOf(current)
+
+	if currentVal.Kind() == reflect.Ptr && !currentVal.IsNil() {
+		currentVal = reflect.ValueOf(currentVal.Elem().Interface())
+	}
+
+	var currentFielVal reflect.Value
+
+	switch currentVal.Kind() {
+
+	case reflect.Struct:
+
+		if currentVal.Type() == reflect.TypeOf(time.Time{}) {
+			currentFielVal = currentVal
+			break
+		}
+
+		f := currentVal.FieldByName(param)
+
+		if f.Kind() == reflect.Invalid {
+			panic(fmt.Sprintf("Field \"%s\" not found in struct", param))
+		}
+
+		currentFielVal = f
+
+	default:
+
+		currentFielVal = currentVal
+	}
+
+	if currentFielVal.Kind() == reflect.Ptr && !currentFielVal.IsNil() {
+
+		currentFielVal = reflect.ValueOf(currentFielVal.Elem().Interface())
+	}
+
+	fv := reflect.ValueOf(field)
+
+	switch fv.Kind() {
+
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+
+		return fv.Int() >= currentFielVal.Int()
+
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+
+		return fv.Uint() >= currentFielVal.Uint()
+
+	case reflect.Float32, reflect.Float64:
+
+		return fv.Float() >= currentFielVal.Float()
+
+	case reflect.Struct:
+
+		if fv.Type() == reflect.TypeOf(time.Time{}) {
+
+			if currentFielVal.Type() != reflect.TypeOf(time.Time{}) {
+				panic("Bad Top Level field type")
+			}
+
+			t := currentFielVal.Interface().(time.Time)
+			fieldTime := field.(time.Time)
+
+			return fieldTime.After(t) || fieldTime.Equal(t)
+		}
+	}
+
+	panic(fmt.Sprintf("Bad field type %T", field))
+}
+
+func isGtField(top interface{}, current interface{}, field interface{}, param string) bool {
+
+	if current == nil {
+		panic("struct not passed for cross validation")
+	}
+
+	currentVal := reflect.ValueOf(current)
+
+	if currentVal.Kind() == reflect.Ptr && !currentVal.IsNil() {
+		currentVal = reflect.ValueOf(currentVal.Elem().Interface())
+	}
+
+	var currentFielVal reflect.Value
+
+	switch currentVal.Kind() {
+
+	case reflect.Struct:
+
+		if currentVal.Type() == reflect.TypeOf(time.Time{}) {
+			currentFielVal = currentVal
+			break
+		}
+
+		f := currentVal.FieldByName(param)
+
+		if f.Kind() == reflect.Invalid {
+			panic(fmt.Sprintf("Field \"%s\" not found in struct", param))
+		}
+
+		currentFielVal = f
+
+	default:
+
+		currentFielVal = currentVal
+	}
+
+	if currentFielVal.Kind() == reflect.Ptr && !currentFielVal.IsNil() {
+
+		currentFielVal = reflect.ValueOf(currentFielVal.Elem().Interface())
+	}
+
+	fv := reflect.ValueOf(field)
+
+	switch fv.Kind() {
+
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+
+		return fv.Int() > currentFielVal.Int()
+
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+
+		return fv.Uint() > currentFielVal.Uint()
+
+	case reflect.Float32, reflect.Float64:
+
+		return fv.Float() > currentFielVal.Float()
+
+	case reflect.Struct:
+
+		if fv.Type() == reflect.TypeOf(time.Time{}) {
+
+			if currentFielVal.Type() != reflect.TypeOf(time.Time{}) {
+				panic("Bad Top Level field type")
+			}
+
+			t := currentFielVal.Interface().(time.Time)
+			fieldTime := field.(time.Time)
+
+			return fieldTime.After(t)
+		}
+	}
+
+	panic(fmt.Sprintf("Bad field type %T", field))
+}
+
+func isGte(top interface{}, current interface{}, field interface{}, param string) bool {
+
+	st := reflect.ValueOf(field)
+
+	switch st.Kind() {
+
+	case reflect.String:
+		p := asInt(param)
+
+		return int64(len(st.String())) >= p
+
+	case reflect.Slice, reflect.Map, reflect.Array:
+		p := asInt(param)
+
+		return int64(st.Len()) >= p
+
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		p := asInt(param)
+
+		return st.Int() >= p
+
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		p := asUint(param)
+
+		return st.Uint() >= p
+
+	case reflect.Float32, reflect.Float64:
+		p := asFloat(param)
+
+		return st.Float() >= p
+
+	case reflect.Struct:
+
+		if st.Type() == reflect.TypeOf(time.Time{}) {
+
+			now := time.Now().UTC()
+			t := field.(time.Time)
+
+			return t.After(now) || t.Equal(now)
+		}
+	}
+
+	panic(fmt.Sprintf("Bad field type %T", field))
+}
+
+func isGt(top interface{}, current interface{}, field interface{}, param string) bool {
+
+	st := reflect.ValueOf(field)
+
+	switch st.Kind() {
+
+	case reflect.String:
+		p := asInt(param)
+
+		return int64(len(st.String())) > p
+
+	case reflect.Slice, reflect.Map, reflect.Array:
+		p := asInt(param)
+
+		return int64(st.Len()) > p
+
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		p := asInt(param)
+
+		return st.Int() > p
+
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		p := asUint(param)
+
+		return st.Uint() > p
+
+	case reflect.Float32, reflect.Float64:
+		p := asFloat(param)
+
+		return st.Float() > p
+	case reflect.Struct:
+
+		if st.Type() == reflect.TypeOf(time.Time{}) {
+
+			return field.(time.Time).After(time.Now().UTC())
+		}
+	}
+
+	panic(fmt.Sprintf("Bad field type %T", field))
+}
+
+// length tests whether a variable's length is equal to a given
+// value. For strings it tests the number of characters whereas
+// for maps and slices it tests the number of items.
+func hasLengthOf(top interface{}, current interface{}, field interface{}, param string) bool {
+
+	st := reflect.ValueOf(field)
+
+	switch st.Kind() {
+
+	case reflect.String:
+		p := asInt(param)
+
+		return int64(len(st.String())) == p
+
+	case reflect.Slice, reflect.Map, reflect.Array:
+		p := asInt(param)
+
+		return int64(st.Len()) == p
+
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		p := asInt(param)
+
+		return st.Int() == p
+
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		p := asUint(param)
+
+		return st.Uint() == p
+
+	case reflect.Float32, reflect.Float64:
+		p := asFloat(param)
+
+		return st.Float() == p
+	}
+
+	panic(fmt.Sprintf("Bad field type %T", field))
+}
+
+// min tests whether a variable value is larger or equal to a given
+// number. For number types, it's a simple lesser-than test; for
+// strings it tests the number of characters whereas for maps
+// and slices it tests the number of items.
+func hasMinOf(top interface{}, current interface{}, field interface{}, param string) bool {
+
+	return isGte(top, current, field, param)
+}
+
+func isLteField(top interface{}, current interface{}, field interface{}, param string) bool {
+
+	if current == nil {
+		panic("struct not passed for cross validation")
+	}
+
+	currentVal := reflect.ValueOf(current)
+
+	if currentVal.Kind() == reflect.Ptr && !currentVal.IsNil() {
+		currentVal = reflect.ValueOf(currentVal.Elem().Interface())
+	}
+
+	var currentFielVal reflect.Value
+
+	switch currentVal.Kind() {
+
+	case reflect.Struct:
+
+		if currentVal.Type() == reflect.TypeOf(time.Time{}) {
+			currentFielVal = currentVal
+			break
+		}
+
+		f := currentVal.FieldByName(param)
+
+		if f.Kind() == reflect.Invalid {
+			panic(fmt.Sprintf("Field \"%s\" not found in struct", param))
+		}
+
+		currentFielVal = f
+
+	default:
+
+		currentFielVal = currentVal
+	}
+
+	if currentFielVal.Kind() == reflect.Ptr && !currentFielVal.IsNil() {
+
+		currentFielVal = reflect.ValueOf(currentFielVal.Elem().Interface())
+	}
+
+	fv := reflect.ValueOf(field)
+
+	switch fv.Kind() {
+
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+
+		return fv.Int() <= currentFielVal.Int()
+
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+
+		return fv.Uint() <= currentFielVal.Uint()
+
+	case reflect.Float32, reflect.Float64:
+
+		return fv.Float() <= currentFielVal.Float()
+
+	case reflect.Struct:
+
+		if fv.Type() == reflect.TypeOf(time.Time{}) {
+
+			if currentFielVal.Type() != reflect.TypeOf(time.Time{}) {
+				panic("Bad Top Level field type")
+			}
+
+			t := currentFielVal.Interface().(time.Time)
+			fieldTime := field.(time.Time)
+
+			return fieldTime.Before(t) || fieldTime.Equal(t)
+		}
+	}
+
+	panic(fmt.Sprintf("Bad field type %T", field))
+}
+
+func isLtField(top interface{}, current interface{}, field interface{}, param string) bool {
+
+	if current == nil {
+		panic("struct not passed for cross validation")
+	}
+
+	currentVal := reflect.ValueOf(current)
+
+	if currentVal.Kind() == reflect.Ptr && !currentVal.IsNil() {
+		currentVal = reflect.ValueOf(currentVal.Elem().Interface())
+	}
+
+	var currentFielVal reflect.Value
+
+	switch currentVal.Kind() {
+
+	case reflect.Struct:
+
+		if currentVal.Type() == reflect.TypeOf(time.Time{}) {
+			currentFielVal = currentVal
+			break
+		}
+
+		f := currentVal.FieldByName(param)
+
+		if f.Kind() == reflect.Invalid {
+			panic(fmt.Sprintf("Field \"%s\" not found in struct", param))
+		}
+
+		currentFielVal = f
+
+	default:
+
+		currentFielVal = currentVal
+	}
+
+	if currentFielVal.Kind() == reflect.Ptr && !currentFielVal.IsNil() {
+
+		currentFielVal = reflect.ValueOf(currentFielVal.Elem().Interface())
+	}
+
+	fv := reflect.ValueOf(field)
+
+	switch fv.Kind() {
+
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+
+		return fv.Int() < currentFielVal.Int()
+
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+
+		return fv.Uint() < currentFielVal.Uint()
+
+	case reflect.Float32, reflect.Float64:
+
+		return fv.Float() < currentFielVal.Float()
+
+	case reflect.Struct:
+
+		if fv.Type() == reflect.TypeOf(time.Time{}) {
+
+			if currentFielVal.Type() != reflect.TypeOf(time.Time{}) {
+				panic("Bad Top Level field type")
+			}
+
+			t := currentFielVal.Interface().(time.Time)
+			fieldTime := field.(time.Time)
+
+			return fieldTime.Before(t)
+		}
+	}
+
+	panic(fmt.Sprintf("Bad field type %T", field))
+}
+
+func isLte(top interface{}, current interface{}, field interface{}, param string) bool {
+
+	st := reflect.ValueOf(field)
+
+	switch st.Kind() {
+
+	case reflect.String:
+		p := asInt(param)
+
+		return int64(len(st.String())) <= p
+
+	case reflect.Slice, reflect.Map, reflect.Array:
+		p := asInt(param)
+
+		return int64(st.Len()) <= p
+
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		p := asInt(param)
+
+		return st.Int() <= p
+
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		p := asUint(param)
+
+		return st.Uint() <= p
+
+	case reflect.Float32, reflect.Float64:
+		p := asFloat(param)
+
+		return st.Float() <= p
+
+	case reflect.Struct:
+
+		if st.Type() == reflect.TypeOf(time.Time{}) {
+
+			now := time.Now().UTC()
+			t := field.(time.Time)
+
+			return t.Before(now) || t.Equal(now)
+		}
+	}
+
+	panic(fmt.Sprintf("Bad field type %T", field))
+}
+
+func isLt(top interface{}, current interface{}, field interface{}, param string) bool {
+
+	st := reflect.ValueOf(field)
+
+	switch st.Kind() {
+
+	case reflect.String:
+		p := asInt(param)
+
+		return int64(len(st.String())) < p
+
+	case reflect.Slice, reflect.Map, reflect.Array:
+		p := asInt(param)
+
+		return int64(st.Len()) < p
+
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		p := asInt(param)
+
+		return st.Int() < p
+
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		p := asUint(param)
+
+		return st.Uint() < p
+
+	case reflect.Float32, reflect.Float64:
+		p := asFloat(param)
+
+		return st.Float() < p
+
+	case reflect.Struct:
+
+		if st.Type() == reflect.TypeOf(time.Time{}) {
+
+			return field.(time.Time).Before(time.Now().UTC())
+		}
+	}
+
+	panic(fmt.Sprintf("Bad field type %T", field))
+}
+
+// max tests whether a variable value is lesser than a given
+// value. For numbers, it's a simple lesser-than test; for
+// strings it tests the number of characters whereas for maps
+// and slices it tests the number of items.
+func hasMaxOf(top interface{}, current interface{}, field interface{}, param string) bool {
+
+	return isLte(top, current, field, param)
+}
+
+// asInt retuns the parameter as a int64
+// or panics if it can't convert
+func asInt(param string) int64 {
+
+	i, err := strconv.ParseInt(param, 0, 64)
+	panicIf(err)
+
+	return i
+}
+
+// asUint returns the parameter as a uint64
+// or panics if it can't convert
+func asUint(param string) uint64 {
+
+	i, err := strconv.ParseUint(param, 0, 64)
+	panicIf(err)
+
+	return i
+}
+
+// asFloat returns the parameter as a float64
+// or panics if it can't convert
+func asFloat(param string) float64 {
+
+	i, err := strconv.ParseFloat(param, 64)
+	panicIf(err)
+
+	return i
+}
+
+func panicIf(err error) {
+	if err != nil {
+		panic(err.Error())
+	}
+}
diff --git a/vendor/gopkg.in/bluesuncorp/validator.v5/doc.go b/vendor/gopkg.in/bluesuncorp/validator.v5/doc.go
new file mode 100644
index 0000000..06c940b
--- /dev/null
+++ b/vendor/gopkg.in/bluesuncorp/validator.v5/doc.go
@@ -0,0 +1,474 @@
+/*
+Package validator implements value validations for structs and individual fields based on tags. It can also handle Cross Field and Cross Struct validation for nested structs.
+
+Validate
+
+	validate := validator.New("validate", validator.BakedInValidators)
+
+	errs := validate.Struct(//your struct)
+	valErr := validate.Field(field, "omitempty,min=1,max=10")
+
+A simple example usage:
+
+	type UserDetail struct {
+		Details string `validate:"-"`
+	}
+
+	type User struct {
+		Name         string     `validate:"required,max=60"`
+		PreferedName string     `validate:"omitempty,max=60"`
+		Sub          UserDetail
+	}
+
+	user := &User {
+		Name: "",
+	}
+
+	// errs will contain a hierarchical list of errors
+	// using the StructErrors struct
+	// or nil if no errors exist
+	errs := validate.Struct(user)
+
+	// in this case 1 error Name is required
+	errs.Struct will be "User"
+	errs.StructErrors will be empty <-- fields that were structs
+	errs.Errors will have 1 error of type FieldError
+
+	NOTE: Anonymous Structs - they don't have names so expect the Struct name
+	within StructErrors to be blank.
+
+Error Handling
+
+The error can be used like so
+
+	fieldErr, _ := errs["Name"]
+	fieldErr.Field    // "Name"
+	fieldErr.ErrorTag // "required"
+
+Both StructErrors and FieldError implement the Error interface but it's
+intended use is for development + debugging, not a production error message.
+
+	fieldErr.Error() // Field validation for "Name" failed on the "required" tag
+	errs.Error()
+	// Struct: User
+	// Field validation for "Name" failed on the "required" tag
+
+Why not a better error message? because this library intends for you to handle your own error messages
+
+Why should I handle my own errors? Many reasons, for us building an internationalized application
+I needed to know the field and what validation failed so that I could provide an error in the users specific language.
+
+	if fieldErr.Field == "Name" {
+		switch fieldErr.ErrorTag
+		case "required":
+			return "Translated string based on field + error"
+		default:
+		return "Translated string based on field"
+	}
+
+The hierarchical error structure is hard to work with sometimes.. Agreed Flatten function to the rescue!
+Flatten will return a map of FieldError's but the field name will be namespaced.
+
+	// if UserDetail Details field failed validation
+	Field will be "Sub.Details"
+
+	// for Name
+	Field will be "Name"
+
+Custom Functions
+
+Custom functions can be added
+
+	//Structure
+	func customFunc(top interface{}, current interface{}, field interface{}, param string) bool {
+
+		if whatever {
+			return false
+		}
+
+		return true
+	}
+
+	validate.AddFunction("custom tag name", customFunc)
+	// NOTES: using the same tag name as an existing function
+	//        will overwrite the existing one
+
+Cross Field Validation
+
+Cross Field Validation can be implemented, for example Start & End Date range validation
+
+	// NOTE: when calling validate.Struct(val) val will be the top level struct passed
+	//       into the function
+	//       when calling validate.FieldWithValue(val, field, tag) val will be
+	//       whatever you pass, struct, field...
+	//       when calling validate.Field(field, tag) val will be nil
+	//
+	// Because of the specific requirements and field names within each persons project that
+	// uses this library it is likely that custom functions will need to be created for your
+	// Cross Field Validation needs, however there are some build in Generic Cross Field validations,
+	// see Baked In Validators and Tags below
+
+	func isDateRangeValid(val interface{}, field interface{}, param string) bool {
+
+		myStruct := val.(myStructType)
+
+		if myStruct.Start.After(field.(time.Time)) {
+			return false
+		}
+
+		return true
+	}
+
+Multiple Validators
+
+Multiple validators on a field will process in the order defined
+
+	type Test struct {
+		Field `validate:"max=10,min=1"`
+	}
+
+	// max will be checked then min
+
+Bad Validator definitions are not handled by the library
+
+	type Test struct {
+		Field `validate:"min=10,max=0"`
+	}
+
+	// this definition of min max will never validate
+
+Baked In Validators and Tags
+
+NOTE: Baked In Cross field validation only compares fields on the same struct,
+if cross field + cross struct validation is needed your own custom validator
+should be implemented.
+
+NOTE2: comma is the default separator of validation tags, if you wish to have a comma
+included within the parameter i.e. excludesall=, you will need to use the UTF-8 hex
+representation 0x2C, which is replaced in the code as a comma, so the above will
+become excludesall=0x2C
+
+Here is a list of the current built in validators:
+
+	-
+		Tells the validation to skip this struct field; this is particularily
+		handy in ignoring embedded structs from being validated. (Usage: -)
+
+	|
+		This is the 'or' operator allowing multiple validators to be used and
+		accepted. (Usage: rbg|rgba) <-- this would allow either rgb or rgba
+		colors to be accepted. This can also be combined with 'and' for example
+		( Usage: omitempty,rgb|rgba)
+
+	structonly
+		When a field that is a nest struct in encountered and contains this flag
+		any validation on the nested struct such as "required" will be run, but
+		none of the nested struct fields will be validated. This is usefull if
+		inside of you program you know the struct will be valid, but need to
+		verify it has been assigned.
+
+	omitempty
+		Allows conditional validation, for example if a field is not set with
+		a value (Determined by the required validator) then other validation
+		such as min or max won't run, but if a value is set validation will run.
+		(Usage: omitempty)
+
+	dive
+		This tells the validator to dive into a slice, array or map and validate that
+		level of the slice, array or map with the validation tags that follow.
+		Multidimensional nesting is also supported, each level you with to dive will
+		require another dive tag. (Usage: dive)
+		Example: [][]string with validation tag "gt=0,dive,len=1,dive,required"
+		gt=0 will be applied to []
+		len=1 will be applied to []string
+		required will be applied to string
+		Example2: [][]string with validation tag "gt=0,dive,dive,required"
+		gt=0 will be applied to []
+		[]string will be spared validation
+		required will be applied to string
+		NOTE: in Example2 if the required validation failed, but all others passed
+		the hierarchy of FieldError's in the middle with have their IsPlaceHolder field
+		set to true. If a FieldError has IsSliceOrMap=true or IsMap=true then the
+		FieldError is a Slice or Map field and if IsPlaceHolder=true then contains errors
+		within its SliceOrArrayErrs or MapErrs fields.
+
+	required
+		This validates that the value is not the data types default value.
+		For numbers ensures value is not zero. For strings ensures value is
+		not "". For slices, arrays, and maps, ensures the length is not zero.
+		(Usage: required)
+
+	len
+		For numbers, max will ensure that the value is
+		equal to the parameter given. For strings, it checks that
+		the string length is exactly that number of characters. For slices,
+		arrays, and maps, validates the number of items. (Usage: len=10)
+
+	max
+		For numbers, max will ensure that the value is
+		less than or equal to the parameter given. For strings, it checks
+		that the string length is at most that number of characters. For
+		slices, arrays, and maps, validates the number of items. (Usage: max=10)
+
+	min
+		For numbers, min will ensure that the value is
+		greater or equal to the parameter given. For strings, it checks that
+		the string length is at least that number of characters. For slices,
+		arrays, and maps, validates the number of items. (Usage: min=10)
+
+	eq
+		For strings & numbers, eq will ensure that the value is
+		equal to the parameter given. For slices, arrays, and maps,
+		validates the number of items. (Usage: eq=10)
+
+	ne
+		For strings & numbers, eq will ensure that the value is not
+		equal to the parameter given. For slices, arrays, and maps,
+		validates the number of items. (Usage: eq=10)
+
+	gt
+		For numbers, this will ensure that the value is greater than the
+		parameter given. For strings, it checks that the string length
+		is greater than that number of characters. For slices, arrays
+		and maps it validates the number of items. (Usage: gt=10)
+		For time.Time ensures the time value is greater than time.Now.UTC()
+		(Usage: gt)
+
+	gte
+		Same as 'min' above. Kept both to make terminology with 'len' easier
+		(Usage: gte=10)
+		For time.Time ensures the time value is greater than or equal to time.Now.UTC()
+		(Usage: gte)
+
+	lt
+		For numbers, this will ensure that the value is
+		less than the parameter given. For strings, it checks
+		that the string length is less than that number of characters.
+		For slices, arrays, and maps it validates the number of items.
+		(Usage: lt=10)
+		For time.Time ensures the time value is less than time.Now.UTC()
+		(Usage: lt)
+
+	lte
+		Same as 'max' above. Kept both to make terminology with 'len' easier
+		(Usage: lte=10)
+		For time.Time ensures the time value is less than or equal to time.Now.UTC()
+		(Usage: lte)
+
+	eqfield
+		This will validate the field value against another fields value either within
+		a struct or passed in field.
+		usage examples are for validation of a password and confirm password:
+		Validation on Password field using validate.Struct Usage(eqfield=ConfirmPassword)
+		Validating by field validate.FieldWithValue(password, confirmpassword, "eqfield")
+
+	nefield
+		This will validate the field value against another fields value either within
+		a struct or passed in field.
+		usage examples are for ensuring two colors are not the same:
+		Validation on Color field using validate.Struct Usage(nefield=Color2)
+		Validating by field validate.FieldWithValue(color1, color2, "nefield")
+
+	gtfield
+		Only valid for Numbers and time.Time types, this will validate the field value
+		against another fields value either within a struct or passed in field.
+		usage examples are for validation of a Start and End date:
+		Validation on End field using validate.Struct Usage(gtfield=Start)
+		Validating by field validate.FieldWithValue(start, end, "gtfield")
+
+	gtefield
+		Only valid for Numbers and time.Time types, this will validate the field value
+		against another fields value either within a struct or passed in field.
+		usage examples are for validation of a Start and End date:
+		Validation on End field using validate.Struct Usage(gtefield=Start)
+		Validating by field validate.FieldWithValue(start, end, "gtefield")
+
+	ltfield
+		Only valid for Numbers and time.Time types, this will validate the field value
+		against another fields value either within a struct or passed in field.
+		usage examples are for validation of a Start and End date:
+		Validation on End field using validate.Struct Usage(ltfield=Start)
+		Validating by field validate.FieldWithValue(start, end, "ltfield")
+
+	ltefield
+		Only valid for Numbers and time.Time types, this will validate the field value
+		against another fields value either within a struct or passed in field.
+		usage examples are for validation of a Start and End date:
+		Validation on End field using validate.Struct Usage(ltefield=Start)
+		Validating by field validate.FieldWithValue(start, end, "ltefield")
+
+	alpha
+		This validates that a string value contains alpha characters only
+		(Usage: alpha)
+
+	alphanum
+		This validates that a string value contains alphanumeric characters only
+		(Usage: alphanum)
+
+	numeric
+		This validates that a string value contains a basic numeric value.
+		basic excludes exponents etc...
+		(Usage: numeric)
+
+	hexadecimal
+		This validates that a string value contains a valid hexadecimal.
+		(Usage: hexadecimal)
+
+	hexcolor
+		This validates that a string value contains a valid hex color including
+		hashtag (#)
+		(Usage: hexcolor)
+
+	rgb
+		This validates that a string value contains a valid rgb color
+		(Usage: rgb)
+
+	rgba
+		This validates that a string value contains a valid rgba color
+		(Usage: rgba)
+
+	hsl
+		This validates that a string value contains a valid hsl color
+		(Usage: hsl)
+
+	hsla
+		This validates that a string value contains a valid hsla color
+		(Usage: hsla)
+
+	email
+		This validates that a string value contains a valid email
+		This may not conform to all possibilities of any rfc standard, but neither
+		does any email provider accept all posibilities...
+		(Usage: email)
+
+	url
+		This validates that a string value contains a valid url
+		This will accept any url the golang request uri accepts but must contain
+		a schema for example http:// or rtmp://
+		(Usage: url)
+
+	uri
+		This validates that a string value contains a valid uri
+		This will accept any uri the golang request uri accepts (Usage: uri)
+
+	base64
+		This validates that a string value contains a valid base64 value.
+		Although an empty string is valid base64 this will report an empty string
+		as an error, if you wish to accept an empty string as valid you can use
+		this with the omitempty tag. (Usage: base64)
+
+	contains
+		This validates that a string value contains the substring value.
+		(Usage: contains=@)
+
+	containsany
+		This validates that a string value contains any Unicode code points
+		in the substring value. (Usage: containsany=!@#?)
+
+	containsrune
+		This validates that a string value contains the supplied rune value.
+		(Usage: containsrune=@)
+
+	excludes
+		This validates that a string value does not contain the substring value.
+		(Usage: excludes=@)
+
+	excludesall
+		This validates that a string value does not contain any Unicode code
+		points in the substring value. (Usage: excludesall=!@#?)
+
+	excludesrune
+		This validates that a string value does not contain the supplied rune value.
+		(Usage: excludesrune=@)
+
+	isbn
+		This validates that a string value contains a valid isbn10 or isbn13 value.
+		(Usage: isbn)
+
+	isbn10
+		This validates that a string value contains a valid isbn10 value.
+		(Usage: isbn10)
+
+	isbn13
+		This validates that a string value contains a valid isbn13 value.
+		(Usage: isbn13)
+
+	uuid
+		This validates that a string value contains a valid UUID.
+		(Usage: uuid)
+
+	uuid3
+		This validates that a string value contains a valid version 3 UUID.
+		(Usage: uuid3)
+
+	uuid4
+		This validates that a string value contains a valid version 4 UUID.
+		(Usage: uuid4)
+
+	uuid5
+		This validates that a string value contains a valid version 5 UUID.
+		(Usage: uuid5)
+
+	ascii
+		This validates that a string value contains only ASCII characters.
+		NOTE: if the string is blank, this validates as true.
+		(Usage: ascii)
+
+	asciiprint
+		This validates that a string value contains only printable ASCII characters.
+		NOTE: if the string is blank, this validates as true.
+		(Usage: asciiprint)
+
+	multibyte
+		This validates that a string value contains one or more multibyte characters.
+		NOTE: if the string is blank, this validates as true.
+		(Usage: multibyte)
+
+	datauri
+		This validates that a string value contains a valid DataURI.
+		NOTE: this will also validate that the data portion is valid base64
+		(Usage: datauri)
+
+	latitude
+		This validates that a string value contains a valid latitude.
+		(Usage: latitude)
+
+	longitude
+		This validates that a string value contains a valid longitude.
+		(Usage: longitude)
+
+	ssn
+		This validates that a string value contains a valid U.S. Social Security Number.
+		(Usage: ssn)
+
+Validator notes:
+
+	regex
+		a regex validator won't be added because commas and = signs can be part of
+		a regex which conflict with the validation definitions, although workarounds
+		can be made, they take away from using pure regex's. Furthermore it's quick
+		and dirty but the regex's become harder to maintain and are not reusable, so
+		it's as much a programming philosiphy as anything.
+
+		In place of this new validator functions should be created; a regex can be
+		used within the validator function and even be precompiled for better efficiency
+		within regexes.go.
+
+		And the best reason, you can submit a pull request and we can keep on adding to the
+		validation library of this package!
+
+Panics
+
+This package panics when bad input is provided, this is by design, bad code like that should not make it to production.
+
+	type Test struct {
+		TestField string `validate:"nonexistantfunction=1"`
+	}
+
+	t := &Test{
+		TestField: "Test"
+	}
+
+	validate.Struct(t) // this will panic
+*/
+package validator
diff --git a/vendor/gopkg.in/bluesuncorp/validator.v5/regexes.go b/vendor/gopkg.in/bluesuncorp/validator.v5/regexes.go
new file mode 100644
index 0000000..d3e8d80
--- /dev/null
+++ b/vendor/gopkg.in/bluesuncorp/validator.v5/regexes.go
@@ -0,0 +1,64 @@
+package validator
+
+import "regexp"
+
+const (
+	alphaRegexString          = "^[a-zA-Z]+$"
+	alphaNumericRegexString   = "^[a-zA-Z0-9]+$"
+	numericRegexString        = "^[-+]?[0-9]+(?:\\.[0-9]+)?$"
+	numberRegexString         = "^[0-9]+$"
+	hexadecimalRegexString    = "^[0-9a-fA-F]+$"
+	hexcolorRegexString       = "^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6})$"
+	rgbRegexString            = "^rgb\\(\\s*(?:(?:0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])\\s*,\\s*(?:0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])\\s*,\\s*(?:0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])|(?:0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])%\\s*,\\s*(?:0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])%\\s*,\\s*(?:0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])%)\\s*\\)$"
+	rgbaRegexString           = "^rgba\\(\\s*(?:(?:0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])\\s*,\\s*(?:0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])\\s*,\\s*(?:0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])|(?:0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])%\\s*,\\s*(?:0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])%\\s*,\\s*(?:0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])%)\\s*,\\s*(?:(?:0.[1-9]*)|[01])\\s*\\)$"
+	hslRegexString            = "^hsl\\(\\s*(?:0|[1-9]\\d?|[12]\\d\\d|3[0-5]\\d|360)\\s*,\\s*(?:(?:0|[1-9]\\d?|100)%)\\s*,\\s*(?:(?:0|[1-9]\\d?|100)%)\\s*\\)$"
+	hslaRegexString           = "^hsla\\(\\s*(?:0|[1-9]\\d?|[12]\\d\\d|3[0-5]\\d|360)\\s*,\\s*(?:(?:0|[1-9]\\d?|100)%)\\s*,\\s*(?:(?:0|[1-9]\\d?|100)%)\\s*,\\s*(?:(?:0.[1-9]*)|[01])\\s*\\)$"
+	emailRegexString          = "^(?:(?:(?:(?:[a-zA-Z]|\\d|[!#\\$%&'\\*\\+\\-\\/=\\?\\^_`{\\|}~]|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])+(?:\\.([a-zA-Z]|\\d|[!#\\$%&'\\*\\+\\-\\/=\\?\\^_`{\\|}~]|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])+)*)|(?:(?:\\x22)(?:(?:(?:(?:\\x20|\\x09)*(?:\\x0d\\x0a))?(?:\\x20|\\x09)+)?(?:(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x7f]|\\x21|[\\x23-\\x5b]|[\\x5d-\\x7e]|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])|(?:\\(?:[\\x01-\\x09\\x0b\\x0c\\x0d-\\x7f]|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}]))))*(?:(?:(?:\\x20|\\x09)*(?:\\x0d\\x0a))?(\\x20|\\x09)+)?(?:\\x22)))@(?:(?:(?:[a-zA-Z]|\\d|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])|(?:(?:[a-zA-Z]|\\d|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])(?:[a-zA-Z]|\\d|-|\\.|_|~|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])*(?:[a-zA-Z]|\\d|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])))\\.)+(?:(?:[a-zA-Z]|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])|(?:(?:[a-zA-Z]|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])(?:[a-zA-Z]|\\d|-|\\.|_|~|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])*(?:[a-zA-Z]|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])))\\.?$"
+	base64RegexString         = "^(?:[A-Za-z0-9+\\/]{4})*(?:[A-Za-z0-9+\\/]{2}==|[A-Za-z0-9+\\/]{3}=|[A-Za-z0-9+\\/]{4})$"
+	iSBN10RegexString         = "^(?:[0-9]{9}X|[0-9]{10})$"
+	iSBN13RegexString         = "^(?:(?:97(?:8|9))[0-9]{10})$"
+	uUID3RegexString          = "^[0-9a-f]{8}-[0-9a-f]{4}-3[0-9a-f]{3}-[0-9a-f]{4}-[0-9a-f]{12}$"
+	uUID4RegexString          = "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"
+	uUID5RegexString          = "^[0-9a-f]{8}-[0-9a-f]{4}-5[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"
+	uUIDRegexString           = "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$"
+	aSCIIRegexString          = "^[\x00-\x7F]*$"
+	printableASCIIRegexString = "^[\x20-\x7E]*$"
+	multibyteRegexString      = "[^\x00-\x7F]"
+	dataURIRegexString        = "^data:.+\\/(.+);base64$"
+	latitudeRegexString       = "^[-+]?([1-8]?\\d(\\.\\d+)?|90(\\.0+)?)$"
+	longitudeRegexString      = "^[-+]?(180(\\.0+)?|((1[0-7]\\d)|([1-9]?\\d))(\\.\\d+)?)$"
+	sSNRegexString            = `^\d{3}[- ]?\d{2}[- ]?\d{4}$`
+)
+
+var (
+	alphaRegex          = regexp.MustCompile(alphaRegexString)
+	alphaNumericRegex   = regexp.MustCompile(alphaNumericRegexString)
+	numericRegex        = regexp.MustCompile(numericRegexString)
+	numberRegex         = regexp.MustCompile(numberRegexString)
+	hexadecimalRegex    = regexp.MustCompile(hexadecimalRegexString)
+	hexcolorRegex       = regexp.MustCompile(hexcolorRegexString)
+	rgbRegex            = regexp.MustCompile(rgbRegexString)
+	rgbaRegex           = regexp.MustCompile(rgbaRegexString)
+	hslRegex            = regexp.MustCompile(hslRegexString)
+	hslaRegex           = regexp.MustCompile(hslaRegexString)
+	emailRegex          = regexp.MustCompile(emailRegexString)
+	base64Regex         = regexp.MustCompile(base64RegexString)
+	iSBN10Regex         = regexp.MustCompile(iSBN10RegexString)
+	iSBN13Regex         = regexp.MustCompile(iSBN13RegexString)
+	uUID3Regex          = regexp.MustCompile(uUID3RegexString)
+	uUID4Regex          = regexp.MustCompile(uUID4RegexString)
+	uUID5Regex          = regexp.MustCompile(uUID5RegexString)
+	uUIDRegex           = regexp.MustCompile(uUIDRegexString)
+	aSCIIRegex          = regexp.MustCompile(aSCIIRegexString)
+	printableASCIIRegex = regexp.MustCompile(printableASCIIRegexString)
+	multibyteRegex      = regexp.MustCompile(multibyteRegexString)
+	dataURIRegex        = regexp.MustCompile(dataURIRegexString)
+	latitudeRegex       = regexp.MustCompile(latitudeRegexString)
+	longitudeRegex      = regexp.MustCompile(longitudeRegexString)
+	sSNRegex            = regexp.MustCompile(sSNRegexString)
+)
+
+func matchesRegex(regex *regexp.Regexp, field interface{}) bool {
+	fieldAsString := field.(string) //this will panic inherently
+	return regex.MatchString(fieldAsString)
+}
diff --git a/vendor/gopkg.in/bluesuncorp/validator.v5/validator.go b/vendor/gopkg.in/bluesuncorp/validator.v5/validator.go
new file mode 100644
index 0000000..db01f1f
--- /dev/null
+++ b/vendor/gopkg.in/bluesuncorp/validator.v5/validator.go
@@ -0,0 +1,935 @@
+/**
+ * Package validator
+ *
+ * MISC:
+ * - anonymous structs - they don't have names so expect the Struct name within StructErrors to be blank
+ *
+ */
+
+package validator
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"sync"
+	"time"
+	"unicode"
+)
+
+const (
+	utf8HexComma    = "0x2C"
+	tagSeparator    = ","
+	orSeparator     = "|"
+	noValidationTag = "-"
+	tagKeySeparator = "="
+	structOnlyTag   = "structonly"
+	omitempty       = "omitempty"
+	required        = "required"
+	fieldErrMsg     = "Field validation for \"%s\" failed on the \"%s\" tag"
+	sliceErrMsg     = "Field validation for \"%s\" failed at index \"%d\" with error(s): %s"
+	mapErrMsg       = "Field validation for \"%s\" failed on key \"%v\" with error(s): %s"
+	structErrMsg    = "Struct:%s\n"
+	diveTag         = "dive"
+	// diveSplit           = "," + diveTag
+	arrayIndexFieldName = "%s[%d]"
+	mapIndexFieldName   = "%s[%v]"
+)
+
+var structPool *pool
+
+// Pool holds a channelStructErrors.
+type pool struct {
+	pool chan *StructErrors
+}
+
+// NewPool creates a new pool of Clients.
+func newPool(max int) *pool {
+	return &pool{
+		pool: make(chan *StructErrors, max),
+	}
+}
+
+// Borrow a StructErrors from the pool.
+func (p *pool) Borrow() *StructErrors {
+	var c *StructErrors
+
+	select {
+	case c = <-p.pool:
+	default:
+		c = &StructErrors{
+			Errors:       map[string]*FieldError{},
+			StructErrors: map[string]*StructErrors{},
+		}
+	}
+
+	return c
+}
+
+// Return returns a StructErrors to the pool.
+func (p *pool) Return(c *StructErrors) {
+
+	select {
+	case p.pool <- c:
+	default:
+		// let it go, let it go...
+	}
+}
+
+type cachedTags struct {
+	keyVals [][]string
+	isOrVal bool
+}
+
+type cachedField struct {
+	index          int
+	name           string
+	tags           []*cachedTags
+	tag            string
+	kind           reflect.Kind
+	typ            reflect.Type
+	isTime         bool
+	isSliceOrArray bool
+	isMap          bool
+	isTimeSubtype  bool
+	sliceSubtype   reflect.Type
+	mapSubtype     reflect.Type
+	sliceSubKind   reflect.Kind
+	mapSubKind     reflect.Kind
+	dive           bool
+	diveTag        string
+}
+
+type cachedStruct struct {
+	children int
+	name     string
+	kind     reflect.Kind
+	fields   []*cachedField
+}
+
+type structsCacheMap struct {
+	lock sync.RWMutex
+	m    map[reflect.Type]*cachedStruct
+}
+
+func (s *structsCacheMap) Get(key reflect.Type) (*cachedStruct, bool) {
+	s.lock.RLock()
+	defer s.lock.RUnlock()
+	value, ok := s.m[key]
+	return value, ok
+}
+
+func (s *structsCacheMap) Set(key reflect.Type, value *cachedStruct) {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+	s.m[key] = value
+}
+
+var structCache = &structsCacheMap{m: map[reflect.Type]*cachedStruct{}}
+
+type fieldsCacheMap struct {
+	lock sync.RWMutex
+	m    map[string][]*cachedTags
+}
+
+func (s *fieldsCacheMap) Get(key string) ([]*cachedTags, bool) {
+	s.lock.RLock()
+	defer s.lock.RUnlock()
+	value, ok := s.m[key]
+	return value, ok
+}
+
+func (s *fieldsCacheMap) Set(key string, value []*cachedTags) {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+	s.m[key] = value
+}
+
+var fieldsCache = &fieldsCacheMap{m: map[string][]*cachedTags{}}
+
+// FieldError contains a single field's validation error along
+// with other properties that may be needed for error message creation
+type FieldError struct {
+	Field            string
+	Tag              string
+	Kind             reflect.Kind
+	Type             reflect.Type
+	Param            string
+	Value            interface{}
+	IsPlaceholderErr bool
+	IsSliceOrArray   bool
+	IsMap            bool
+	SliceOrArrayErrs map[int]error         // counld be FieldError, StructErrors
+	MapErrs          map[interface{}]error // counld be FieldError, StructErrors
+}
+
+// This is intended for use in development + debugging and not intended to be a production error message.
+// it also allows FieldError to be used as an Error interface
+func (e *FieldError) Error() string {
+
+	if e.IsPlaceholderErr {
+
+		buff := bytes.NewBufferString("")
+
+		if e.IsSliceOrArray {
+
+			for j, err := range e.SliceOrArrayErrs {
+				buff.WriteString("\n")
+				buff.WriteString(fmt.Sprintf(sliceErrMsg, e.Field, j, "\n"+err.Error()))
+			}
+
+		} else if e.IsMap {
+
+			for key, err := range e.MapErrs {
+				buff.WriteString(fmt.Sprintf(mapErrMsg, e.Field, key, "\n"+err.Error()))
+			}
+		}
+
+		return strings.TrimSpace(buff.String())
+	}
+
+	return fmt.Sprintf(fieldErrMsg, e.Field, e.Tag)
+}
+
+// StructErrors is hierarchical list of field and struct validation errors
+// for a non hierarchical representation please see the Flatten method for StructErrors
+type StructErrors struct {
+	// Name of the Struct
+	Struct string
+	// Struct Field Errors
+	Errors map[string]*FieldError
+	// Struct Fields of type struct and their errors
+	// key = Field Name of current struct, but internally Struct will be the actual struct name unless anonymous struct, it will be blank
+	StructErrors map[string]*StructErrors
+}
+
+// This is intended for use in development + debugging and not intended to be a production error message.
+// it also allows StructErrors to be used as an Error interface
+func (e *StructErrors) Error() string {
+	buff := bytes.NewBufferString(fmt.Sprintf(structErrMsg, e.Struct))
+
+	for _, err := range e.Errors {
+		buff.WriteString(err.Error())
+		buff.WriteString("\n")
+	}
+
+	for _, err := range e.StructErrors {
+		buff.WriteString(err.Error())
+	}
+
+	return strings.TrimSpace(buff.String())
+}
+
+// Flatten flattens the StructErrors hierarchical structure into a flat namespace style field name
+// for those that want/need it
+func (e *StructErrors) Flatten() map[string]*FieldError {
+
+	if e == nil {
+		return nil
+	}
+
+	errs := map[string]*FieldError{}
+
+	for _, f := range e.Errors {
+
+		errs[f.Field] = f
+	}
+
+	for key, val := range e.StructErrors {
+
+		otherErrs := val.Flatten()
+
+		for _, f2 := range otherErrs {
+
+			f2.Field = fmt.Sprintf("%s.%s", key, f2.Field)
+			errs[f2.Field] = f2
+		}
+	}
+
+	return errs
+}
+
+// Func accepts all values needed for file and cross field validation
+// top     = top level struct when validating by struct otherwise nil
+// current = current level struct when validating by struct otherwise optional comparison value
+// f       = field value for validation
+// param   = parameter used in validation i.e. gt=0 param would be 0
+type Func func(top interface{}, current interface{}, f interface{}, param string) bool
+
+// Validate implements the Validate Struct
+// NOTE: Fields within are not thread safe and that is on purpose
+// Functions and Tags should all be predifined before use, so subscribe to the philosiphy
+// or make it thread safe on your end
+type Validate struct {
+	// tagName being used.
+	tagName string
+	// validateFuncs is a map of validation functions and the tag keys
+	validationFuncs map[string]Func
+}
+
+// New creates a new Validate instance for use.
+func New(tagName string, funcs map[string]Func) *Validate {
+
+	structPool = newPool(10)
+
+	return &Validate{
+		tagName:         tagName,
+		validationFuncs: funcs,
+	}
+}
+
+// SetTag sets tagName of the Validator to one of your choosing after creation
+// perhaps to dodge a tag name conflict in a specific section of code
+// NOTE: this method is not thread-safe
+func (v *Validate) SetTag(tagName string) {
+	v.tagName = tagName
+}
+
+// SetMaxStructPoolSize sets the  struct pools max size. this may be usefull for fine grained
+// performance tuning towards your application, however, the default should be fine for
+// nearly all cases. only increase if you have a deeply nested struct structure.
+// NOTE: this method is not thread-safe
+// NOTE: this is only here to keep compatibility with v5, in v6 the method will be removed
+// and the max pool size will be passed into the New function
+func (v *Validate) SetMaxStructPoolSize(max int) {
+	structPool = newPool(max)
+}
+
+// AddFunction adds a validation Func to a Validate's map of validators denoted by the key
+// NOTE: if the key already exists, it will get replaced.
+// NOTE: this method is not thread-safe
+func (v *Validate) AddFunction(key string, f Func) error {
+
+	if len(key) == 0 {
+		return errors.New("Function Key cannot be empty")
+	}
+
+	if f == nil {
+		return errors.New("Function cannot be empty")
+	}
+
+	v.validationFuncs[key] = f
+
+	return nil
+}
+
+// Struct validates a struct, even it's nested structs, and returns a struct containing the errors
+// NOTE: Nested Arrays, or Maps of structs do not get validated only the Array or Map itself; the reason is that there is no good
+// way to represent or report which struct within the array has the error, besides can validate the struct prior to adding it to
+// the Array or Map.
+func (v *Validate) Struct(s interface{}) *StructErrors {
+
+	return v.structRecursive(s, s, s)
+}
+
+// structRecursive validates a struct recursivly and passes the top level and current struct around for use in validator functions and returns a struct containing the errors
+func (v *Validate) structRecursive(top interface{}, current interface{}, s interface{}) *StructErrors {
+
+	structValue := reflect.ValueOf(s)
+
+	if structValue.Kind() == reflect.Ptr && !structValue.IsNil() {
+		return v.structRecursive(top, current, structValue.Elem().Interface())
+	}
+
+	if structValue.Kind() != reflect.Struct && structValue.Kind() != reflect.Interface {
+		panic("interface passed for validation is not a struct")
+	}
+
+	structType := reflect.TypeOf(s)
+
+	var structName string
+	var numFields int
+	var cs *cachedStruct
+	var isCached bool
+
+	cs, isCached = structCache.Get(structType)
+
+	if isCached {
+		structName = cs.name
+		numFields = cs.children
+	} else {
+		structName = structType.Name()
+		numFields = structValue.NumField()
+		cs = &cachedStruct{name: structName, children: numFields}
+	}
+
+	validationErrors := structPool.Borrow()
+	validationErrors.Struct = structName
+
+	for i := 0; i < numFields; i++ {
+
+		var valueField reflect.Value
+		var cField *cachedField
+		var typeField reflect.StructField
+
+		if isCached {
+			cField = cs.fields[i]
+			valueField = structValue.Field(cField.index)
+
+			if valueField.Kind() == reflect.Ptr && !valueField.IsNil() {
+				valueField = valueField.Elem()
+			}
+		} else {
+			valueField = structValue.Field(i)
+
+			if valueField.Kind() == reflect.Ptr && !valueField.IsNil() {
+				valueField = valueField.Elem()
+			}
+
+			typeField = structType.Field(i)
+
+			cField = &cachedField{index: i, tag: typeField.Tag.Get(v.tagName), isTime: (valueField.Type() == reflect.TypeOf(time.Time{}) || valueField.Type() == reflect.TypeOf(&time.Time{}))}
+
+			if cField.tag == noValidationTag {
+				cs.children--
+				continue
+			}
+
+			// if no validation and not a struct (which may containt fields for validation)
+			if cField.tag == "" && ((valueField.Kind() != reflect.Struct && valueField.Kind() != reflect.Interface) || valueField.Type() == reflect.TypeOf(time.Time{})) {
+				cs.children--
+				continue
+			}
+
+			cField.name = typeField.Name
+			cField.kind = valueField.Kind()
+			cField.typ = valueField.Type()
+		}
+
+		// this can happen if the first cache value was nil
+		// but the second actually has a value
+		if cField.kind == reflect.Ptr {
+			cField.kind = valueField.Kind()
+		}
+
+		switch cField.kind {
+
+		case reflect.Struct, reflect.Interface:
+
+			if !unicode.IsUpper(rune(cField.name[0])) {
+				cs.children--
+				continue
+			}
+
+			if cField.isTime {
+
+				if fieldError := v.fieldWithNameAndValue(top, current, valueField.Interface(), cField.tag, cField.name, false, cField); fieldError != nil {
+					validationErrors.Errors[fieldError.Field] = fieldError
+					// free up memory reference
+					fieldError = nil
+				}
+
+			} else {
+
+				if strings.Contains(cField.tag, structOnlyTag) {
+					cs.children--
+					continue
+				}
+
+				if (valueField.Kind() == reflect.Ptr || cField.kind == reflect.Interface) && valueField.IsNil() {
+
+					if strings.Contains(cField.tag, omitempty) {
+						goto CACHEFIELD
+					}
+
+					tags := strings.Split(cField.tag, tagSeparator)
+
+					if len(tags) > 0 {
+
+						var param string
+						vals := strings.SplitN(tags[0], tagKeySeparator, 2)
+
+						if len(vals) > 1 {
+							param = vals[1]
+						}
+
+						validationErrors.Errors[cField.name] = &FieldError{
+							Field: cField.name,
+							Tag:   vals[0],
+							Param: param,
+							Value: valueField.Interface(),
+							Kind:  valueField.Kind(),
+							Type:  valueField.Type(),
+						}
+
+						goto CACHEFIELD
+					}
+				}
+
+				// if we get here, the field is interface and could be a struct or a field
+				// and we need to check the inner type and validate
+				if cField.kind == reflect.Interface {
+
+					valueField = valueField.Elem()
+
+					if valueField.Kind() == reflect.Ptr && !valueField.IsNil() {
+						valueField = valueField.Elem()
+					}
+
+					if valueField.Kind() == reflect.Struct {
+						goto VALIDATESTRUCT
+					}
+
+					// sending nil for cField as it was type interface and could be anything
+					// each time and so must be calculated each time and can't be cached reliably
+					if fieldError := v.fieldWithNameAndValue(top, current, valueField.Interface(), cField.tag, cField.name, false, nil); fieldError != nil {
+						validationErrors.Errors[fieldError.Field] = fieldError
+						// free up memory reference
+						fieldError = nil
+					}
+
+					goto CACHEFIELD
+				}
+
+			VALIDATESTRUCT:
+				if structErrors := v.structRecursive(top, valueField.Interface(), valueField.Interface()); structErrors != nil {
+					validationErrors.StructErrors[cField.name] = structErrors
+					// free up memory map no longer needed
+					structErrors = nil
+				}
+			}
+
+		case reflect.Slice, reflect.Array:
+			cField.isSliceOrArray = true
+			cField.sliceSubtype = cField.typ.Elem()
+			cField.isTimeSubtype = (cField.sliceSubtype == reflect.TypeOf(time.Time{}) || cField.sliceSubtype == reflect.TypeOf(&time.Time{}))
+			cField.sliceSubKind = cField.sliceSubtype.Kind()
+
+			if fieldError := v.fieldWithNameAndValue(top, current, valueField.Interface(), cField.tag, cField.name, false, cField); fieldError != nil {
+				validationErrors.Errors[fieldError.Field] = fieldError
+				// free up memory reference
+				fieldError = nil
+			}
+
+		case reflect.Map:
+			cField.isMap = true
+			cField.mapSubtype = cField.typ.Elem()
+			cField.isTimeSubtype = (cField.mapSubtype == reflect.TypeOf(time.Time{}) || cField.mapSubtype == reflect.TypeOf(&time.Time{}))
+			cField.mapSubKind = cField.mapSubtype.Kind()
+
+			if fieldError := v.fieldWithNameAndValue(top, current, valueField.Interface(), cField.tag, cField.name, false, cField); fieldError != nil {
+				validationErrors.Errors[fieldError.Field] = fieldError
+				// free up memory reference
+				fieldError = nil
+			}
+
+		default:
+			if fieldError := v.fieldWithNameAndValue(top, current, valueField.Interface(), cField.tag, cField.name, false, cField); fieldError != nil {
+				validationErrors.Errors[fieldError.Field] = fieldError
+				// free up memory reference
+				fieldError = nil
+			}
+		}
+
+	CACHEFIELD:
+		if !isCached {
+			cs.fields = append(cs.fields, cField)
+		}
+	}
+
+	structCache.Set(structType, cs)
+
+	if len(validationErrors.Errors) == 0 && len(validationErrors.StructErrors) == 0 {
+		structPool.Return(validationErrors)
+		return nil
+	}
+
+	return validationErrors
+}
+
+// Field allows validation of a single field, still using tag style validation to check multiple errors
+func (v *Validate) Field(f interface{}, tag string) *FieldError {
+	return v.FieldWithValue(nil, f, tag)
+}
+
+// FieldWithValue allows validation of a single field, possibly even against another fields value, still using tag style validation to check multiple errors
+func (v *Validate) FieldWithValue(val interface{}, f interface{}, tag string) *FieldError {
+	return v.fieldWithNameAndValue(nil, val, f, tag, "", true, nil)
+}
+
+func (v *Validate) fieldWithNameAndValue(val interface{}, current interface{}, f interface{}, tag string, name string, isSingleField bool, cacheField *cachedField) *FieldError {
+
+	var cField *cachedField
+	var isCached bool
+	var valueField reflect.Value
+
+	// This is a double check if coming from validate.Struct but need to be here in case function is called directly
+	if tag == noValidationTag {
+		return nil
+	}
+
+	if strings.Contains(tag, omitempty) && !hasValue(val, current, f, "") {
+		return nil
+	}
+
+	valueField = reflect.ValueOf(f)
+
+	if cacheField == nil {
+
+		if valueField.Kind() == reflect.Ptr && !valueField.IsNil() {
+			valueField = valueField.Elem()
+			f = valueField.Interface()
+		}
+
+		cField = &cachedField{name: name, kind: valueField.Kind(), tag: tag, typ: valueField.Type()}
+
+		switch cField.kind {
+		case reflect.Slice, reflect.Array:
+			isSingleField = false // cached tags mean nothing because it will be split up while diving
+			cField.isSliceOrArray = true
+			cField.sliceSubtype = cField.typ.Elem()
+			cField.isTimeSubtype = (cField.sliceSubtype == reflect.TypeOf(time.Time{}) || cField.sliceSubtype == reflect.TypeOf(&time.Time{}))
+			cField.sliceSubKind = cField.sliceSubtype.Kind()
+		case reflect.Map:
+			isSingleField = false // cached tags mean nothing because it will be split up while diving
+			cField.isMap = true
+			cField.mapSubtype = cField.typ.Elem()
+			cField.isTimeSubtype = (cField.mapSubtype == reflect.TypeOf(time.Time{}) || cField.mapSubtype == reflect.TypeOf(&time.Time{}))
+			cField.mapSubKind = cField.mapSubtype.Kind()
+		}
+	} else {
+		cField = cacheField
+	}
+
+	switch cField.kind {
+
+	case reflect.Struct, reflect.Interface, reflect.Invalid:
+
+		if cField.typ != reflect.TypeOf(time.Time{}) {
+			panic("Invalid field passed to fieldWithNameAndValue")
+		}
+	}
+
+	if len(cField.tags) == 0 {
+
+		if isSingleField {
+			cField.tags, isCached = fieldsCache.Get(tag)
+		}
+
+		if !isCached {
+
+			for _, t := range strings.Split(tag, tagSeparator) {
+
+				if t == diveTag {
+
+					cField.dive = true
+					cField.diveTag = strings.TrimLeft(strings.SplitN(tag, diveTag, 2)[1], ",")
+					break
+				}
+
+				orVals := strings.Split(t, orSeparator)
+				cTag := &cachedTags{isOrVal: len(orVals) > 1, keyVals: make([][]string, len(orVals))}
+				cField.tags = append(cField.tags, cTag)
+
+				for i, val := range orVals {
+					vals := strings.SplitN(val, tagKeySeparator, 2)
+
+					key := strings.TrimSpace(vals[0])
+
+					if len(key) == 0 {
+						panic(fmt.Sprintf("Invalid validation tag on field %s", name))
+					}
+
+					param := ""
+					if len(vals) > 1 {
+						param = strings.Replace(vals[1], utf8HexComma, ",", -1)
+					}
+
+					cTag.keyVals[i] = []string{key, param}
+				}
+			}
+
+			if isSingleField {
+				fieldsCache.Set(cField.tag, cField.tags)
+			}
+		}
+	}
+
+	var fieldErr *FieldError
+	var err error
+
+	for _, cTag := range cField.tags {
+
+		if cTag.isOrVal {
+
+			errTag := ""
+
+			for _, val := range cTag.keyVals {
+
+				fieldErr, err = v.fieldWithNameAndSingleTag(val, current, f, val[0], val[1], name)
+
+				if err == nil {
+					return nil
+				}
+
+				errTag += orSeparator + fieldErr.Tag
+			}
+
+			errTag = strings.TrimLeft(errTag, orSeparator)
+
+			fieldErr.Tag = errTag
+			fieldErr.Kind = cField.kind
+			fieldErr.Type = cField.typ
+
+			return fieldErr
+		}
+
+		if fieldErr, err = v.fieldWithNameAndSingleTag(val, current, f, cTag.keyVals[0][0], cTag.keyVals[0][1], name); err != nil {
+
+			fieldErr.Kind = cField.kind
+			fieldErr.Type = cField.typ
+
+			return fieldErr
+		}
+	}
+
+	if cField.dive {
+
+		if cField.isSliceOrArray {
+
+			if errs := v.traverseSliceOrArray(val, current, valueField, cField); errs != nil && len(errs) > 0 {
+
+				return &FieldError{
+					Field:            cField.name,
+					Kind:             cField.kind,
+					Type:             cField.typ,
+					Value:            f,
+					IsPlaceholderErr: true,
+					IsSliceOrArray:   true,
+					SliceOrArrayErrs: errs,
+				}
+			}
+
+		} else if cField.isMap {
+			if errs := v.traverseMap(val, current, valueField, cField); errs != nil && len(errs) > 0 {
+
+				return &FieldError{
+					Field:            cField.name,
+					Kind:             cField.kind,
+					Type:             cField.typ,
+					Value:            f,
+					IsPlaceholderErr: true,
+					IsMap:            true,
+					MapErrs:          errs,
+				}
+			}
+		} else {
+			// throw error, if not a slice or map then should not have gotten here
+			panic("dive error! can't dive on a non slice or map")
+		}
+	}
+
+	return nil
+}
+
+func (v *Validate) traverseMap(val interface{}, current interface{}, valueField reflect.Value, cField *cachedField) map[interface{}]error {
+
+	errs := map[interface{}]error{}
+
+	for _, key := range valueField.MapKeys() {
+
+		idxField := valueField.MapIndex(key)
+
+		if cField.mapSubKind == reflect.Ptr && !idxField.IsNil() {
+			idxField = idxField.Elem()
+			cField.mapSubKind = idxField.Kind()
+		}
+
+		switch cField.mapSubKind {
+		case reflect.Struct, reflect.Interface:
+
+			if cField.isTimeSubtype {
+
+				if fieldError := v.fieldWithNameAndValue(val, current, idxField.Interface(), cField.diveTag, fmt.Sprintf(mapIndexFieldName, cField.name, key.Interface()), false, nil); fieldError != nil {
+					errs[key.Interface()] = fieldError
+				}
+
+				continue
+			}
+
+			if (idxField.Kind() == reflect.Ptr || idxField.Kind() == reflect.Interface) && idxField.IsNil() {
+
+				if strings.Contains(cField.diveTag, omitempty) {
+					continue
+				}
+
+				tags := strings.Split(cField.diveTag, tagSeparator)
+
+				if len(tags) > 0 {
+
+					var param string
+					vals := strings.SplitN(tags[0], tagKeySeparator, 2)
+
+					if len(vals) > 1 {
+						param = vals[1]
+					}
+
+					errs[key.Interface()] = &FieldError{
+						Field: fmt.Sprintf(mapIndexFieldName, cField.name, key.Interface()),
+						Tag:   vals[0],
+						Param: param,
+						Value: idxField.Interface(),
+						Kind:  idxField.Kind(),
+						Type:  cField.mapSubtype,
+					}
+				}
+
+				continue
+			}
+
+			// if we get here, the field is interface and could be a struct or a field
+			// and we need to check the inner type and validate
+			if idxField.Kind() == reflect.Interface {
+
+				idxField = idxField.Elem()
+
+				if idxField.Kind() == reflect.Ptr && !idxField.IsNil() {
+					idxField = idxField.Elem()
+				}
+
+				if idxField.Kind() == reflect.Struct {
+					goto VALIDATESTRUCT
+				}
+
+				// sending nil for cField as it was type interface and could be anything
+				// each time and so must be calculated each time and can't be cached reliably
+				if fieldError := v.fieldWithNameAndValue(val, current, idxField.Interface(), cField.diveTag, fmt.Sprintf(mapIndexFieldName, cField.name, key.Interface()), false, nil); fieldError != nil {
+					errs[key.Interface()] = fieldError
+				}
+
+				continue
+			}
+
+		VALIDATESTRUCT:
+			if structErrors := v.structRecursive(val, current, idxField.Interface()); structErrors != nil {
+				errs[key.Interface()] = structErrors
+			}
+
+		default:
+			if fieldError := v.fieldWithNameAndValue(val, current, idxField.Interface(), cField.diveTag, fmt.Sprintf(mapIndexFieldName, cField.name, key.Interface()), false, nil); fieldError != nil {
+				errs[key.Interface()] = fieldError
+			}
+		}
+	}
+
+	return errs
+}
+
+func (v *Validate) traverseSliceOrArray(val interface{}, current interface{}, valueField reflect.Value, cField *cachedField) map[int]error {
+
+	errs := map[int]error{}
+
+	for i := 0; i < valueField.Len(); i++ {
+
+		idxField := valueField.Index(i)
+
+		if cField.sliceSubKind == reflect.Ptr && !idxField.IsNil() {
+			idxField = idxField.Elem()
+			cField.sliceSubKind = idxField.Kind()
+		}
+
+		switch cField.sliceSubKind {
+		case reflect.Struct, reflect.Interface:
+
+			if cField.isTimeSubtype {
+
+				if fieldError := v.fieldWithNameAndValue(val, current, idxField.Interface(), cField.diveTag, fmt.Sprintf(arrayIndexFieldName, cField.name, i), false, nil); fieldError != nil {
+					errs[i] = fieldError
+				}
+
+				continue
+			}
+
+			if (idxField.Kind() == reflect.Ptr || idxField.Kind() == reflect.Interface) && idxField.IsNil() {
+
+				if strings.Contains(cField.diveTag, omitempty) {
+					continue
+				}
+
+				tags := strings.Split(cField.diveTag, tagSeparator)
+
+				if len(tags) > 0 {
+
+					var param string
+					vals := strings.SplitN(tags[0], tagKeySeparator, 2)
+
+					if len(vals) > 1 {
+						param = vals[1]
+					}
+
+					errs[i] = &FieldError{
+						Field: fmt.Sprintf(arrayIndexFieldName, cField.name, i),
+						Tag:   vals[0],
+						Param: param,
+						Value: idxField.Interface(),
+						Kind:  idxField.Kind(),
+						Type:  cField.sliceSubtype,
+					}
+				}
+
+				continue
+			}
+
+			// if we get here, the field is interface and could be a struct or a field
+			// and we need to check the inner type and validate
+			if idxField.Kind() == reflect.Interface {
+
+				idxField = idxField.Elem()
+
+				if idxField.Kind() == reflect.Ptr && !idxField.IsNil() {
+					idxField = idxField.Elem()
+				}
+
+				if idxField.Kind() == reflect.Struct {
+					goto VALIDATESTRUCT
+				}
+
+				// sending nil for cField as it was type interface and could be anything
+				// each time and so must be calculated each time and can't be cached reliably
+				if fieldError := v.fieldWithNameAndValue(val, current, idxField.Interface(), cField.diveTag, fmt.Sprintf(arrayIndexFieldName, cField.name, i), false, nil); fieldError != nil {
+					errs[i] = fieldError
+				}
+
+				continue
+			}
+
+		VALIDATESTRUCT:
+			if structErrors := v.structRecursive(val, current, idxField.Interface()); structErrors != nil {
+				errs[i] = structErrors
+			}
+
+		default:
+			if fieldError := v.fieldWithNameAndValue(val, current, idxField.Interface(), cField.diveTag, fmt.Sprintf(arrayIndexFieldName, cField.name, i), false, nil); fieldError != nil {
+				errs[i] = fieldError
+			}
+		}
+	}
+
+	return errs
+}
+
+func (v *Validate) fieldWithNameAndSingleTag(val interface{}, current interface{}, f interface{}, key string, param string, name string) (*FieldError, error) {
+
+	// OK to continue because we checked it's existance before getting into this loop
+	if key == omitempty {
+		return nil, nil
+	}
+
+	valFunc, ok := v.validationFuncs[key]
+	if !ok {
+		panic(fmt.Sprintf("Undefined validation function on field %s", name))
+	}
+
+	if err := valFunc(val, current, f, param); err {
+		return nil, nil
+	}
+
+	return &FieldError{
+		Field: name,
+		Tag:   key,
+		Value: f,
+		Param: param,
+	}, errors.New(key)
+}
diff --git a/vendor/modules.txt b/vendor/modules.txt
new file mode 100644
index 0000000..46ca8a5
--- /dev/null
+++ b/vendor/modules.txt
@@ -0,0 +1,17 @@
+# github.com/gin-gonic/gin v0.0.0-20150626140855-4cc2de6207f4
+github.com/gin-gonic/gin
+github.com/gin-gonic/gin/binding
+github.com/gin-gonic/gin/render
+# github.com/heroku/x v0.0.0-20171004170240-705849e307dd
+github.com/heroku/x/hmetrics/onload
+github.com/heroku/x/hmetrics
+# github.com/manucorporat/sse v0.0.0-20150604091100-c142f0f1baea
+github.com/manucorporat/sse
+# github.com/mattn/go-colorable v0.0.0-20150625154642-40e4aedc8fab
+github.com/mattn/go-colorable
+# github.com/mattn/go-isatty v0.0.0-20150814002629-7fcbc72f853b
+github.com/mattn/go-isatty
+# golang.org/x/net v0.0.0-20150629084131-d9558e5c97f8
+golang.org/x/net/context
+# gopkg.in/bluesuncorp/validator.v5 v5.9.1
+gopkg.in/bluesuncorp/validator.v5