update dependencies

vendor/github.com/gin-contrib/multitemplate/.travis.yml

@@ -6,6 +6,7 @@ go:
   - 1.7.x
   - 1.8.x
   - 1.9.x
+  - 1.10.x
   - tip
 
 install:

vendor/github.com/gin-contrib/multitemplate/README.md

@@ -36,8 +36,8 @@ import (
 	"github.com/gin-gonic/gin"
 )
 
-func createMyRender() multitemplate.Render {
-	r := multitemplate.New()
+func createMyRender() multitemplate.Renderer {
+	r := multitemplate.NewRenderer()
 	r.AddFromFiles("index", "templates/base.html", "templates/index.html")
 	r.AddFromFiles("article", "templates/base.html", "templates/index.html", "templates/article.html")
 	return r
@@ -86,8 +86,8 @@ func main() {
 	router.Run(":8080")
 }
 
-func loadTemplates(templatesDir string) multitemplate.Render {
-	r := multitemplate.New()
+func loadTemplates(templatesDir string) multitemplate.Renderer {
+	r := multitemplate.NewRenderer()
 
 	layouts, err := filepath.Glob(templatesDir + "/layouts/*.tmpl")
 	if err != nil {

vendor/github.com/gin-contrib/multitemplate/dynamic.go

@@ -0,0 +1,147 @@
+package multitemplate
+
+import (
+	"fmt"
+	"html/template"
+	"path/filepath"
+
+	"github.com/gin-gonic/gin"
+	"github.com/gin-gonic/gin/render"
+)
+
+// DynamicRender type
+type DynamicRender map[string]*templateBuilder
+
+var (
+	_ render.HTMLRender = DynamicRender{}
+	_ Renderer          = DynamicRender{}
+)
+
+// NewDynamic is the constructor for Dynamic templates
+func NewDynamic() DynamicRender {
+	return make(DynamicRender)
+}
+
+// NewRenderer allows create an agnostic multitemplate renderer
+// depending on enabled gin mode
+func NewRenderer() Renderer {
+	if gin.IsDebugging() {
+		return NewDynamic()
+	}
+	return New()
+}
+
+// Type of dynamic builder
+type builderType int
+
+// Types of dynamic builders
+const (
+	templateType builderType = iota
+	filesTemplateType
+	globTemplateType
+	stringTemplateType
+	stringFuncTemplateType
+	filesFuncTemplateType
+)
+
+// Builder for dynamic templates
+type templateBuilder struct {
+	buildType       builderType
+	tmpl            *template.Template
+	templateName    string
+	files           []string
+	glob            string
+	templateString  string
+	funcMap         template.FuncMap
+	templateStrings []string
+}
+
+func (tb templateBuilder) buildTemplate() *template.Template {
+	switch tb.buildType {
+	case templateType:
+		return tb.tmpl
+	case filesTemplateType:
+		return template.Must(template.ParseFiles(tb.files...))
+	case globTemplateType:
+		return template.Must(template.ParseGlob(tb.glob))
+	case stringTemplateType:
+		return template.Must(template.New(tb.templateName).Parse(tb.templateString))
+	case stringFuncTemplateType:
+		tmpl := template.New(tb.templateName).Funcs(tb.funcMap)
+		for _, ts := range tb.templateStrings {
+			tmpl = template.Must(tmpl.Parse(ts))
+		}
+		return tmpl
+	case filesFuncTemplateType:
+		return template.Must(template.New(tb.templateName).Funcs(tb.funcMap).ParseFiles(tb.files...))
+	default:
+		panic("Invalid builder type for dynamic template")
+	}
+}
+
+// Add new template
+func (r DynamicRender) Add(name string, tmpl *template.Template) {
+	if tmpl == nil {
+		panic("template cannot be nil")
+	}
+	if len(name) == 0 {
+		panic("template name cannot be empty")
+	}
+	builder := &templateBuilder{templateName: name, tmpl: tmpl}
+	builder.buildType = templateType
+	r[name] = builder
+}
+
+// AddFromFiles supply add template from files
+func (r DynamicRender) AddFromFiles(name string, files ...string) *template.Template {
+	builder := &templateBuilder{templateName: name, files: files}
+	builder.buildType = filesTemplateType
+	r[name] = builder
+	return builder.buildTemplate()
+}
+
+// AddFromGlob supply add template from global path
+func (r DynamicRender) AddFromGlob(name, glob string) *template.Template {
+	builder := &templateBuilder{templateName: name, glob: glob}
+	builder.buildType = globTemplateType
+	r[name] = builder
+	return builder.buildTemplate()
+}
+
+// AddFromString supply add template from strings
+func (r DynamicRender) AddFromString(name, templateString string) *template.Template {
+	builder := &templateBuilder{templateName: name, templateString: templateString}
+	builder.buildType = stringTemplateType
+	r[name] = builder
+	return builder.buildTemplate()
+}
+
+// AddFromStringsFuncs supply add template from strings
+func (r DynamicRender) AddFromStringsFuncs(name string, funcMap template.FuncMap, templateStrings ...string) *template.Template {
+	builder := &templateBuilder{templateName: name, funcMap: funcMap,
+		templateStrings: templateStrings}
+	builder.buildType = stringFuncTemplateType
+	r[name] = builder
+	return builder.buildTemplate()
+}
+
+// AddFromFilesFuncs supply add template from file callback func
+func (r DynamicRender) AddFromFilesFuncs(name string, funcMap template.FuncMap, files ...string) *template.Template {
+	tname := filepath.Base(files[0])
+	builder := &templateBuilder{templateName: tname, funcMap: funcMap, files: files}
+	builder.buildType = filesFuncTemplateType
+	r[name] = builder
+	return builder.buildTemplate()
+}
+
+// Instance supply render string
+func (r DynamicRender) Instance(name string, data interface{}) render.Render {
+	builder, ok := r[name]
+	if !ok {
+		panic(fmt.Sprintf("Dynamic template with name %s not found", name))
+	}
+	return render.HTML{
+		Template: builder.buildTemplate(),
+		Data:     data,
+	}
+}

vendor/github.com/gin-contrib/multitemplate/dynamic_test.go

@@ -0,0 +1,172 @@
+package multitemplate
+
+import (
+	"html/template"
+	"testing"
+
+	"github.com/gin-gonic/gin"
+	"github.com/stretchr/testify/assert"
+)
+
+func createFromFileDynamic() Renderer {
+	r := NewRenderer()
+	r.AddFromFiles("index", "tests/base.html", "tests/article.html")
+
+	return r
+}
+
+func createFromGlobDynamic() Renderer {
+	r := NewRenderer()
+	r.AddFromGlob("index", "tests/global/*")
+
+	return r
+}
+
+func createFromStringDynamic() Renderer {
+	r := NewRenderer()
+	r.AddFromString("index", "Welcome to {{ .name }} template")
+
+	return r
+}
+
+func createFromStringsWithFuncsDynamic() Renderer {
+	r := NewRenderer()
+	r.AddFromStringsFuncs("index", template.FuncMap{}, `Welcome to {{ .name }} {{template "content"}}`, `{{define "content"}}template{{end}}`)
+
+	return r
+}
+
+func createFromFilesWithFuncsDynamic() Renderer {
+	r := NewRenderer()
+	r.AddFromFilesFuncs("index", template.FuncMap{}, "tests/welcome.html", "tests/content.html")
+
+	return r
+}
+
+func createFromTemplatesDynamic() Renderer {
+	tmpl := template.Must(template.New("test").Parse("Welcome to {{ .name }} template"))
+	r := NewRenderer()
+	r.Add("test", tmpl)
+	return r
+}
+
+func TestMissingTemplateOrNameDynamic(t *testing.T) {
+	r := NewRenderer()
+	tmpl := template.Must(template.New("test").Parse("Welcome to {{ .name }} template"))
+	assert.Panics(t, func() {
+		r.Add("", tmpl)
+	}, "template name cannot be empty")
+
+	assert.Panics(t, func() {
+		r.Add("test", nil)
+	}, "template can not be nil")
+}
+
+func TestAddFromFilesDynamic(t *testing.T) {
+	router := gin.New()
+	router.HTMLRender = createFromFileDynamic()
+	router.GET("/", func(c *gin.Context) {
+		c.HTML(200, "index", gin.H{
+			"title": "Test Multiple Template",
+		})
+	})
+
+	w := performRequest(router, "GET", "/")
+	assert.Equal(t, 200, w.Code)
+	assert.Equal(t, "<p>Test Multiple Template</p>\nHi, this is article template\n", w.Body.String())
+}
+
+func TestAddFromGlobDynamic(t *testing.T) {
+	router := gin.New()
+	router.HTMLRender = createFromGlobDynamic()
+	router.GET("/", func(c *gin.Context) {
+		c.HTML(200, "index", gin.H{
+			"title": "Test Multiple Template",
+		})
+	})
+
+	w := performRequest(router, "GET", "/")
+	assert.Equal(t, 200, w.Code)
+	assert.Equal(t, "<p>Test Multiple Template</p>\nHi, this is login template\n", w.Body.String())
+}
+
+func TestAddFromStringDynamic(t *testing.T) {
+	router := gin.New()
+	router.HTMLRender = createFromStringDynamic()
+	router.GET("/", func(c *gin.Context) {
+		c.HTML(200, "index", gin.H{
+			"name": "index",
+		})
+	})
+
+	w := performRequest(router, "GET", "/")
+	assert.Equal(t, 200, w.Code)
+	assert.Equal(t, "Welcome to index template", w.Body.String())
+}
+
+func TestAddFromStringsFruncsDynamic(t *testing.T) {
+	router := gin.New()
+	router.HTMLRender = createFromStringsWithFuncsDynamic()
+	router.GET("/", func(c *gin.Context) {
+		c.HTML(200, "index", gin.H{
+			"name": "index",
+		})
+	})
+
+	w := performRequest(router, "GET", "/")
+	assert.Equal(t, 200, w.Code)
+	assert.Equal(t, "Welcome to index template", w.Body.String())
+}
+
+func TestAddFromFilesFruncsDynamic(t *testing.T) {
+	router := gin.New()
+	router.HTMLRender = createFromFilesWithFuncsDynamic()
+	router.GET("/", func(c *gin.Context) {
+		c.HTML(200, "index", gin.H{
+			"name": "index",
+		})
+	})
+
+	w := performRequest(router, "GET", "/")
+	assert.Equal(t, 200, w.Code)
+	assert.Equal(t, "Welcome to index template\n", w.Body.String())
+}
+
+func TestPanicInvalidTypeBuilder(t *testing.T) {
+	assert.Panics(t, func() {
+		var b = templateBuilder{}
+		b.buildType = 10
+		b.buildTemplate()
+	})
+}
+
+func TestTemplateNotFound(t *testing.T) {
+	r := make(DynamicRender)
+	r.AddFromString("index", "This is a test template")
+	assert.Panics(t, func() {
+		r.Instance("NotFoundTemplate", nil)
+	})
+}
+
+func TestNotDynamicMode(t *testing.T) {
+	gin.SetMode("test")
+	TestAddFromFilesDynamic(t)
+	gin.SetMode("debug")
+}
+
+func TestAddTemplate(t *testing.T) {
+	tmpl := template.Must(template.ParseFiles("tests/base.html", "tests/article.html"))
+	b := templateBuilder{}
+	b.buildType = templateType
+	b.tmpl = tmpl
+	tmpl = b.buildTemplate()
+	assert.NotPanics(t, func() {
+		b.buildTemplate()
+	})
+}
+
+func TestAddingTemplate(t *testing.T) {
+	assert.NotPanics(t, func() {
+		createFromTemplatesDynamic()
+	})
+}

vendor/github.com/gin-contrib/multitemplate/example/example.go

@@ -5,8 +5,8 @@ import (
 	"github.com/gin-gonic/gin"
 )
 
-func createMyRender() multitemplate.Render {
-	r := multitemplate.New()
+func createMyRender() multitemplate.Renderer {
+	r := multitemplate.NewRenderer()
 	r.AddFromFiles("index", "templates/base.html", "templates/index.html")
 	r.AddFromFiles("article", "templates/base.html", "templates/index.html", "templates/article.html")
 	return r

vendor/github.com/gin-contrib/multitemplate/multitemplate.go

@@ -1,6 +1,7 @@
 package multitemplate
 
 import (
+	"fmt"
 	"html/template"
 	"path/filepath"
 
@@ -10,7 +11,10 @@ import (
 // Render type
 type Render map[string]*template.Template
 
-var _ render.HTMLRender = Render{}
+var (
+	_ render.HTMLRender = Render{}
+	_ Renderer          = Render{}
+)
 
 // New instance
 func New() Render {
@@ -25,6 +29,9 @@ func (r Render) Add(name string, tmpl *template.Template) {
 	if len(name) == 0 {
 		panic("template name cannot be empty")
 	}
+	if _, ok := r[name]; ok {
+		panic(fmt.Sprintf("template %s already exists", name))
+	}
 	r[name] = tmpl
 }
 
@@ -43,14 +50,14 @@ func (r Render) AddFromGlob(name, glob string) *template.Template {
 }
 
 // AddFromString supply add template from strings
-func (r *Render) AddFromString(name, templateString string) *template.Template {
+func (r Render) AddFromString(name, templateString string) *template.Template {
 	tmpl := template.Must(template.New(name).Parse(templateString))
 	r.Add(name, tmpl)
 	return tmpl
 }
 
 // AddFromStringsFuncs supply add template from strings
-func (r *Render) AddFromStringsFuncs(name string, funcMap template.FuncMap, templateStrings ...string) *template.Template {
+func (r Render) AddFromStringsFuncs(name string, funcMap template.FuncMap, templateStrings ...string) *template.Template {
 	tmpl := template.New(name).Funcs(funcMap)
 
 	for _, ts := range templateStrings {

vendor/github.com/gin-contrib/multitemplate/multitemplate_test.go

@@ -140,3 +140,11 @@ func TestAddFromFilesFruncs(t *testing.T) {
 	assert.Equal(t, 200, w.Code)
 	assert.Equal(t, "Welcome to index template\n", w.Body.String())
 }
+
+func TestDuplicateTemplate(t *testing.T) {
+	assert.Panics(t, func() {
+		r := New()
+		r.AddFromString("index", "Welcome to {{ .name }} template")
+		r.AddFromString("index", "Welcome to {{ .name }} template")
+	})
+}

vendor/github.com/gin-contrib/multitemplate/renderer.go

@@ -0,0 +1,18 @@
+package multitemplate
+
+import "html/template"
+import "github.com/gin-gonic/gin/render"
+
+// Renderer type is the Agnostic Renderer for multitemplates.
+// When gin is in debug mode then all multitemplates works with
+// hot reloading allowing you modify file templates and seeing changes instantly.
+// Renderer should be created using multitemplate.NewRenderer() constructor.
+type Renderer interface {
+	render.HTMLRender
+	Add(name string, tmpl *template.Template)
+	AddFromFiles(name string, files ...string) *template.Template
+	AddFromGlob(name, glob string) *template.Template
+	AddFromString(name, templateString string) *template.Template
+	AddFromStringsFuncs(name string, funcMap template.FuncMap, templateStrings ...string) *template.Template
+	AddFromFilesFuncs(name string, funcMap template.FuncMap, files ...string) *template.Template
+}

vendor/github.com/gin-contrib/sessions/.travis.yml

@@ -6,6 +6,7 @@ go:
   - 1.7.x
   - 1.8.x
   - 1.9.x
+  - 1.10.x
   - tip
 
 services: