Add More Examples & Categorized in Folders & TOC

Former-commit-id: ce4d711a75a4ba08ffab075e6baa88724725885b

_examples/examples/intermediate/view/custom-renderer/main.go

@@ -0,0 +1,48 @@
+package main
+
+import (
+	"io"
+
+	"gopkg.in/kataras/iris.v6"
+	"gopkg.in/kataras/iris.v6/adaptors/httprouter"
+)
+
+func main() {
+	app := iris.New()
+	// output startup banner and error logs on os.Stdout
+	app.Adapt(iris.DevLogger())
+	// set the router, you can choose gorillamux too
+	app.Adapt(httprouter.New())
+
+	// Custom Render Policy to override or create new content-type render
+	// i,e: "text/html" with a prefix,
+	// we will just write to the writer and return false
+	// to continue to the next contentType-matched renderer if any.
+	app.Adapt(iris.RenderPolicy(func(out io.Writer, contentType string, binding interface{}, options ...map[string]interface{}) (bool, error) {
+
+		if contentType == "text/html" {
+			if content, ok := binding.(string); ok {
+				out.Write([]byte("<pre>My Custom prefix</pre><br/>" + content))
+			}
+
+		}
+		// continue to the next, no error
+		// note: if we wanted to stop here we would return true instead of false.
+		return false, nil
+	}))
+
+	app.Get("", func(ctx *iris.Context) {
+
+		// These content-types are not managed by our RenderPolicy:
+		// text, binary and html content-types are
+		// not rendered via serializers, you have to
+		// use the ctx.Render functions instead.
+		// so something like this:
+		// ctx.Text(iris.StatusOK, "my text content body here!")
+		// will NOT work with out custom render policy.
+		ctx.Render("text/html",
+			"my text content body here!")
+	})
+
+	app.Listen(":8080")
+}

_examples/examples/intermediate/view/embedding-templates-into-app/bindata.go

@@ -0,0 +1,238 @@
+// Code generated by go-bindata.
+// sources:
+// templates/hi.html
+// DO NOT EDIT!
+
+// NOTE: execute your own look main.go
+package main
+
+import (
+	"bytes"
+	"compress/gzip"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+func bindataRead(data []byte, name string) ([]byte, error) {
+	gz, err := gzip.NewReader(bytes.NewBuffer(data))
+	if err != nil {
+		return nil, fmt.Errorf("Read %q: %v", name, err)
+	}
+
+	var buf bytes.Buffer
+	_, err = io.Copy(&buf, gz)
+	clErr := gz.Close()
+
+	if err != nil {
+		return nil, fmt.Errorf("Read %q: %v", name, err)
+	}
+	if clErr != nil {
+		return nil, err
+	}
+
+	return buf.Bytes(), nil
+}
+
+type asset struct {
+	bytes []byte
+	info  os.FileInfo
+}
+
+type bindataFileInfo struct {
+	name    string
+	size    int64
+	mode    os.FileMode
+	modTime time.Time
+}
+
+func (fi bindataFileInfo) Name() string {
+	return fi.name
+}
+func (fi bindataFileInfo) Size() int64 {
+	return fi.size
+}
+func (fi bindataFileInfo) Mode() os.FileMode {
+	return fi.mode
+}
+func (fi bindataFileInfo) ModTime() time.Time {
+	return fi.modTime
+}
+func (fi bindataFileInfo) IsDir() bool {
+	return false
+}
+func (fi bindataFileInfo) Sys() interface{} {
+	return nil
+}
+
+var _templatesHiHtml = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\xb2\xc9\x28\xc9\xcd\xb1\xe3\xe5\xb2\xc9\x48\x4d\x4c\x01\xd1\x25\x99\x25\x39\xa9\x76\x1e\x99\x0a\x9e\x45\x99\xc5\x0a\xd1\x21\x1e\xae\x0a\x21\x9e\x21\x3e\xae\xb1\x36\xfa\x10\x29\xa0\x1a\x7d\x98\xe2\xa4\xfc\x94\x4a\x20\xcd\x69\x93\x61\x08\xd2\x52\x5d\xad\xe7\x97\x98\x9b\x5a\x5b\x0b\x52\x03\x95\x03\x2a\x86\xd8\x00\x08\x00\x00\xff\xff\xed\x0e\xad\x42\x6a\x00\x00\x00")
+
+func templatesHiHtmlBytes() ([]byte, error) {
+	return bindataRead(
+		_templatesHiHtml,
+		"templates/hi.html",
+	)
+}
+
+func templatesHiHtml() (*asset, error) {
+	bytes, err := templatesHiHtmlBytes()
+	if err != nil {
+		return nil, err
+	}
+
+	info := bindataFileInfo{name: "templates/hi.html", size: 106, mode: os.FileMode(438), modTime: time.Unix(1487682349, 0)}
+	a := &asset{bytes: bytes, info: info}
+	return a, nil
+}
+
+// Asset loads and returns the asset for the given name.
+// It returns an error if the asset could not be found or
+// could not be loaded.
+func Asset(name string) ([]byte, error) {
+	cannonicalName := strings.Replace(name, "\\", "/", -1)
+	if f, ok := _bindata[cannonicalName]; ok {
+		a, err := f()
+		if err != nil {
+			return nil, fmt.Errorf("Asset %s can't read by error: %v", name, err)
+		}
+		return a.bytes, nil
+	}
+	return nil, fmt.Errorf("Asset %s not found", name)
+}
+
+// MustAsset is like Asset but panics when Asset would return an error.
+// It simplifies safe initialization of global variables.
+func MustAsset(name string) []byte {
+	a, err := Asset(name)
+	if err != nil {
+		panic("asset: Asset(" + name + "): " + err.Error())
+	}
+
+	return a
+}
+
+// AssetInfo loads and returns the asset info for the given name.
+// It returns an error if the asset could not be found or
+// could not be loaded.
+func AssetInfo(name string) (os.FileInfo, error) {
+	cannonicalName := strings.Replace(name, "\\", "/", -1)
+	if f, ok := _bindata[cannonicalName]; ok {
+		a, err := f()
+		if err != nil {
+			return nil, fmt.Errorf("AssetInfo %s can't read by error: %v", name, err)
+		}
+		return a.info, nil
+	}
+	return nil, fmt.Errorf("AssetInfo %s not found", name)
+}
+
+// AssetNames returns the names of the assets.
+func AssetNames() []string {
+	names := make([]string, 0, len(_bindata))
+	for name := range _bindata {
+		names = append(names, name)
+	}
+	return names
+}
+
+// _bindata is a table, holding each asset generator, mapped to its name.
+var _bindata = map[string]func() (*asset, error){
+	"templates/hi.html": templatesHiHtml,
+}
+
+// AssetDir returns the file names below a certain
+// directory embedded in the file by go-bindata.
+// For example if you run go-bindata on data/... and data contains the
+// following hierarchy:
+//     data/
+//       foo.txt
+//       img/
+//         a.png
+//         b.png
+// then AssetDir("data") would return []string{"foo.txt", "img"}
+// AssetDir("data/img") would return []string{"a.png", "b.png"}
+// AssetDir("foo.txt") and AssetDir("notexist") would return an error
+// AssetDir("") will return []string{"data"}.
+func AssetDir(name string) ([]string, error) {
+	node := _bintree
+	if len(name) != 0 {
+		cannonicalName := strings.Replace(name, "\\", "/", -1)
+		pathList := strings.Split(cannonicalName, "/")
+		for _, p := range pathList {
+			node = node.Children[p]
+			if node == nil {
+				return nil, fmt.Errorf("Asset %s not found", name)
+			}
+		}
+	}
+	if node.Func != nil {
+		return nil, fmt.Errorf("Asset %s not found", name)
+	}
+	rv := make([]string, 0, len(node.Children))
+	for childName := range node.Children {
+		rv = append(rv, childName)
+	}
+	return rv, nil
+}
+
+type bintree struct {
+	Func     func() (*asset, error)
+	Children map[string]*bintree
+}
+
+var _bintree = &bintree{nil, map[string]*bintree{
+	"templates": &bintree{nil, map[string]*bintree{
+		"hi.html": &bintree{templatesHiHtml, map[string]*bintree{}},
+	}},
+}}
+
+// RestoreAsset restores an asset under the given directory
+func RestoreAsset(dir, name string) error {
+	data, err := Asset(name)
+	if err != nil {
+		return err
+	}
+	info, err := AssetInfo(name)
+	if err != nil {
+		return err
+	}
+	err = os.MkdirAll(_filePath(dir, filepath.Dir(name)), os.FileMode(0755))
+	if err != nil {
+		return err
+	}
+	err = ioutil.WriteFile(_filePath(dir, name), data, info.Mode())
+	if err != nil {
+		return err
+	}
+	err = os.Chtimes(_filePath(dir, name), info.ModTime(), info.ModTime())
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// RestoreAssets restores an asset under the given directory recursively
+func RestoreAssets(dir, name string) error {
+	children, err := AssetDir(name)
+	// File
+	if err != nil {
+		return RestoreAsset(dir, name)
+	}
+	// Dir
+	for _, child := range children {
+		err = RestoreAssets(dir, filepath.Join(name, child))
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func _filePath(dir, name string) string {
+	cannonicalName := strings.Replace(name, "\\", "/", -1)
+	return filepath.Join(append([]string{dir}, strings.Split(cannonicalName, "/")...)...)
+}

_examples/examples/intermediate/view/embedding-templates-into-app/main.go

@@ -0,0 +1,25 @@
+package main
+
+import (
+	"gopkg.in/kataras/iris.v6"
+	"gopkg.in/kataras/iris.v6/adaptors/httprouter"
+	"gopkg.in/kataras/iris.v6/adaptors/view"
+)
+
+func main() {
+	app := iris.New()
+	app.Adapt(iris.DevLogger())
+	app.Adapt(httprouter.New())
+
+	// $ go-bindata ./templates/...
+	// $ go build
+	// $ ./template_binary
+	// templates are not used, you can delete the folder and run the example
+	app.Adapt(view.HTML("./templates", ".html").Binary(Asset, AssetNames))
+	app.Get("/hi", hi)
+	app.Listen(":8080")
+}
+
+func hi(ctx *iris.Context) {
+	ctx.MustRender("hi.html", struct{ Name string }{Name: "iris"})
+}

_examples/examples/intermediate/view/embedding-templates-into-app/templates/hi.html

@@ -0,0 +1,8 @@
+<html>
+<head>
+<title>Hi Iris [THE TITLE]</title>
+</head>
+<body>
+	<h1>Hi {{.Name}}
+</body>
+</html>

_examples/examples/intermediate/view/overview/main.go

@@ -0,0 +1,59 @@
+package main
+
+import (
+	"encoding/xml"
+
+	"gopkg.in/kataras/iris.v6"
+	"gopkg.in/kataras/iris.v6/adaptors/gorillamux"
+	"gopkg.in/kataras/iris.v6/adaptors/view"
+)
+
+// ExampleXML just a test struct to view represents xml content-type
+type ExampleXML struct {
+	XMLName xml.Name `xml:"example"`
+	One     string   `xml:"one,attr"`
+	Two     string   `xml:"two,attr"`
+}
+
+func main() {
+	app := iris.New()
+	app.Adapt(iris.DevLogger())
+	app.Adapt(gorillamux.New())
+
+	app.Get("/data", func(ctx *iris.Context) {
+		ctx.Data(iris.StatusOK, []byte("Some binary data here."))
+	})
+
+	app.Get("/text", func(ctx *iris.Context) {
+		ctx.Text(iris.StatusOK, "Plain text here")
+	})
+
+	app.Get("/json", func(ctx *iris.Context) {
+		ctx.JSON(iris.StatusOK, map[string]string{"hello": "json"}) // or myjsonStruct{hello:"json}
+	})
+
+	app.Get("/jsonp", func(ctx *iris.Context) {
+		ctx.JSONP(iris.StatusOK, "callbackName", map[string]string{"hello": "jsonp"})
+	})
+
+	app.Get("/xml", func(ctx *iris.Context) {
+		ctx.XML(iris.StatusOK, ExampleXML{One: "hello", Two: "xml"}) // or iris.Map{"One":"hello"...}
+	})
+
+	app.Get("/markdown", func(ctx *iris.Context) {
+		ctx.Markdown(iris.StatusOK, "# Hello Dynamic Markdown Iris")
+	})
+
+	app.Adapt(view.HTML("./templates", ".html"))
+	app.Get("/template", func(ctx *iris.Context) {
+
+		ctx.MustRender(
+			"hi.html",                // the file name of the template relative to the './templates'
+			iris.Map{"Name": "Iris"}, // the .Name inside the ./templates/hi.html
+			iris.Map{"gzip": false},  // enable gzip for big files
+		)
+
+	})
+
+	app.Listen(":8080")
+}

_examples/examples/intermediate/view/overview/templates/hi.html

@@ -0,0 +1,8 @@
+<html>
+<head>
+<title>Hi Iris</title>
+</head>
+<body>
+	<h1>Hi {{.Name}} </h1>
+</body>
+</html>

_examples/examples/intermediate/view/template_html_0/main.go

@@ -0,0 +1,23 @@
+package main
+
+import (
+	"gopkg.in/kataras/iris.v6"
+	"gopkg.in/kataras/iris.v6/adaptors/httprouter"
+	"gopkg.in/kataras/iris.v6/adaptors/view"
+)
+
+func main() {
+	app := iris.New(iris.Configuration{Gzip: false, Charset: "UTF-8"}) // defaults to these
+
+	app.Adapt(iris.DevLogger())
+	app.Adapt(httprouter.New())
+
+	app.Adapt(view.HTML("./templates", ".html"))
+
+	app.Get("/hi", hi)
+	app.Listen(":8080")
+}
+
+func hi(ctx *iris.Context) {
+	ctx.MustRender("hi.html", struct{ Name string }{Name: "iris"})
+}

_examples/examples/intermediate/view/template_html_0/templates/hi.html

@@ -0,0 +1,8 @@
+<html>
+<head>
+<title>Hi Iris</title>
+</head>
+<body>
+	<h1>Hi {{.Name}} </h1>
+</body>
+</html>

_examples/examples/intermediate/view/template_html_1/main.go

@@ -0,0 +1,32 @@
+package main
+
+import (
+	"gopkg.in/kataras/iris.v6"
+	"gopkg.in/kataras/iris.v6/adaptors/httprouter"
+	"gopkg.in/kataras/iris.v6/adaptors/view"
+)
+
+type mypage struct {
+	Title   string
+	Message string
+}
+
+func main() {
+	app := iris.New()
+	app.Adapt(iris.DevLogger())
+	app.Adapt(httprouter.New())
+
+	tmpl := view.HTML("./templates", ".html")
+	tmpl.Layout("layout.html")
+
+	app.Adapt(tmpl)
+
+	app.Get("/", func(ctx *iris.Context) {
+		ctx.Render("mypage.html", mypage{"My Page title", "Hello world!"}, iris.Map{"gzip": true})
+		// Note that: you can pass "layout" : "otherLayout.html" to bypass the config's Layout property
+		// or iris.NoLayout to disable layout on this render action.
+		// third is an optional parameter
+	})
+
+	app.Listen(":8080")
+}

_examples/examples/intermediate/view/template_html_1/templates/layout.html

@@ -0,0 +1,11 @@
+<html>
+<head>
+<title>My Layout</title>
+
+</head>
+<body>
+	<h1>Body is:</h1>
+	<!-- Render the current template here -->
+	{{ yield }}
+</body>
+</html>

_examples/examples/intermediate/view/template_html_1/templates/mypage.html

@@ -0,0 +1,4 @@
+<h1>
+	Title: {{.Title}}
+</h1>
+<h3>Message: {{.Message}} </h3>

_examples/examples/intermediate/view/template_html_2/README.md

@@ -0,0 +1,3 @@
+## Info
+
+This folder examines the {{render "dir/templatefilename"}} functionality to manually render any template inside any template

_examples/examples/intermediate/view/template_html_2/main.go

@@ -0,0 +1,49 @@
+package main
+
+import (
+	"gopkg.in/kataras/iris.v6"
+	"gopkg.in/kataras/iris.v6/adaptors/httprouter"
+	"gopkg.in/kataras/iris.v6/adaptors/view"
+)
+
+func main() {
+	app := iris.New()
+	app.Adapt(iris.DevLogger())
+	app.Adapt(httprouter.New())
+
+	tmpl := view.HTML("./templates", ".html")
+	tmpl.Layout("layouts/layout.html")
+	tmpl.Funcs(map[string]interface{}{
+		"greet": func(s string) string {
+			return "Greetings " + s + "!"
+		},
+	})
+
+	app.Adapt(tmpl)
+
+	app.Get("/", func(ctx *iris.Context) {
+		if err := ctx.Render("page1.html", nil); err != nil {
+			println(err.Error())
+		}
+	})
+
+	// remove the layout for a specific route
+	app.Get("/nolayout", func(ctx *iris.Context) {
+		if err := ctx.Render("page1.html", nil, iris.RenderOptions{"layout": iris.NoLayout}); err != nil {
+			println(err.Error())
+		}
+	})
+
+	// set a layout for a party, .Layout should be BEFORE any Get or other Handle party's method
+	my := app.Party("/my").Layout("layouts/mylayout.html")
+	{
+		my.Get("/", func(ctx *iris.Context) {
+			ctx.MustRender("page1.html", nil)
+		})
+		my.Get("/other", func(ctx *iris.Context) {
+			ctx.MustRender("page1.html", nil)
+		})
+	}
+
+	app.Listen(":8080")
+}

_examples/examples/intermediate/view/template_html_2/templates/layouts/layout.html

@@ -0,0 +1,12 @@
+<html>
+<head>
+<title>Layout</title>
+
+</head>
+<body>
+	<h1>This is the global layout</h1>
+	<br />
+	<!-- Render the current template here -->
+	{{ yield }}
+</body>
+</html>

_examples/examples/intermediate/view/template_html_2/templates/layouts/mylayout.html

@@ -0,0 +1,12 @@
+<html>
+<head>
+<title>my Layout</title>
+
+</head>
+<body>
+	<h1>This is the layout for the /my/ and /my/other routes only</h1>
+	<br />
+	<!-- Render the current template here -->
+	{{ yield }}
+</body>
+</html>

_examples/examples/intermediate/view/template_html_2/templates/page1.html

@@ -0,0 +1,7 @@
+<div style="background-color: black; color: blue">
+
+	<h1>Page 1 {{ greet "iris developer"}}</h1>
+
+	{{ render "partials/page1_partial1.html"}}
+
+</div>

_examples/examples/intermediate/view/template_html_2/templates/partials/page1_partial1.html

@@ -0,0 +1,3 @@
+<div style="background-color: white; color: red">
+	<h1>Page 1's Partial 1</h1>
+</div>

_examples/examples/intermediate/view/template_html_3/main.go

@@ -0,0 +1,103 @@
+// Package main an example on how to naming your routes & use the custom 'url' HTML Template Engine, same for other template engines.
+package main
+
+import (
+	"gopkg.in/kataras/iris.v6"
+	"gopkg.in/kataras/iris.v6/adaptors/gorillamux"
+	"gopkg.in/kataras/iris.v6/adaptors/httprouter"
+	"gopkg.in/kataras/iris.v6/adaptors/view"
+)
+
+func main() {
+	app := iris.New()
+	app.Adapt(iris.DevLogger())
+	app.Adapt(view.HTML("./templates", ".html").Reload(true))
+
+	startWithHTTPRouter(app)
+	// or uncomment
+	// startWithGorillamux()
+
+	app.Listen("localhost:8080")
+
+}
+
+func writePathHandler(ctx *iris.Context) {
+	ctx.Writef("Hello from %s.", ctx.Path())
+}
+
+func startWithHTTPRouter(app *iris.Framework) {
+
+	app.Adapt(httprouter.New())
+
+	app.Get("/mypath", writePathHandler).ChangeName("my-page1")
+	app.Get("/mypath2/:param1/:param2", writePathHandler).ChangeName("my-page2")
+	app.Get("/mypath3/:param1/statichere/:param2", writePathHandler).ChangeName("my-page3")
+	app.Get("/mypath4/:param1/statichere/:param2/:otherparam/*something", writePathHandler).ChangeName("my-page4")
+
+	// same with Handle/Func
+	app.HandleFunc("GET", "/mypath5/:param1/statichere/:param2/:otherparam/anything/*something", writePathHandler).ChangeName("my-page5")
+
+	app.Get("/mypath6/:param1/:param2/staticParam/:param3AfterStatic", writePathHandler).ChangeName("my-page6")
+
+	app.Get("/", func(ctx *iris.Context) {
+		// for /mypath6...
+		paramsAsArray := []string{"param1", "theParam1",
+			"param2", "theParam2",
+			"param3AfterStatic", "theParam3"}
+
+		if err := ctx.Render("page.html", iris.Map{"ParamsAsArray": paramsAsArray}); err != nil {
+			panic(err)
+		}
+	})
+
+	app.Get("/redirect/:namedRoute", func(ctx *iris.Context) {
+		routeName := ctx.Param("namedRoute")
+
+		println("The full uri of " + routeName + "is: " + app.URL(routeName))
+		// if routeName == "my-page1"
+		// prints: The full uri of my-page1 is: http://127.0.0.1:8080/mypath
+		ctx.RedirectTo(routeName)
+		// http://127.0.0.1:8080/redirect/my-page1 will redirect to -> http://127.0.0.1:8080/mypath
+	})
+
+}
+
+// for gorillamux adaptor is the same thing, the path syntax is the only thing changed ofc.
+// Note: Here, we could use app.RouteParam("param1") without even care what router is being used,
+//       but I have two examples of the same thing in order to be more understable for you.
+func startWithGorillamux(app *iris.Framework) {
+	app.Adapt(gorillamux.New())
+
+	app.Get("/mypath", writePathHandler).ChangeName("my-page1")
+	app.Get("/mypath2/{param1}/{param2}", writePathHandler).ChangeName("my-page2")
+	app.Get("/mypath3/{param1}/statichere/{param2}", writePathHandler).ChangeName("my-page3")
+	app.Get("/mypath4/{param1}/statichere/{param2}/{otherparam}/{something:.*}", writePathHandler).ChangeName("my-page4")
+
+	// same with Handle/Func
+	app.HandleFunc("GET", "/mypath5/{param1}/statichere/{param2}/{otherparam}/anything/{something:.*}", writePathHandler).ChangeName("my-page5")
+
+	app.Get("/mypath6/{param1}/{param2}/staticParam/{param3AfterStatic}", writePathHandler).ChangeName("my-page6")
+
+	app.Get("/", func(ctx *iris.Context) {
+		// for /mypath6...
+		paramsAsArray := []string{"param1", "theParam1",
+			"param2", "theParam2",
+			"param3AfterStatic", "theParam3"}
+
+		if err := ctx.Render("page.html", iris.Map{"ParamsAsArray": paramsAsArray}); err != nil {
+			panic(err)
+		}
+	})
+
+	app.Get("/redirect/{namedRoute}", func(ctx *iris.Context) {
+		routeName := ctx.Param("namedRoute")
+
+		println("The full uri of " + routeName + "is: " + app.URL(routeName))
+		// if routeName == "my-page1"
+		// prints: The full uri of my-page1 is: http://127.0.0.1:8080/mypath
+		ctx.RedirectTo(routeName)
+		// http://127.0.0.1:8080/redirect/my-page1 will redirect to -> http://127.0.0.1:8080/mypath
+	})
+
+	app.Listen("localhost:8080")
+}

_examples/examples/intermediate/view/template_html_3/templates/page.html

@@ -0,0 +1,29 @@
+<a href="{{url "my-page1"}}">http://127.0.0.1:8080/mypath</a>
+<br />
+<br />
+
+<a href="{{url "my-page2" "param1" "theParam1" "param2" "theParam2"}}">http://localhost:8080/mypath2/:param1/:param2</a>
+or path only:
+<a href="{{urlpath "my-page2" "param1" "theParam1" "param2" "theParam2"}}">/mypath2/:param1/:param2</a>
+
+<br />
+<br />
+
+<a href="{{url "my-page3" "param1" "theParam1" "param2" "theParam2AfterStatic"}}">
+  http://localhost:8080/mypath3/:param1/statichere/:param2</a>
+
+<br />
+<br />
+
+<a href="{{url "my-page4" "param1" "theParam1" "param2" "theparam2AfterStatic" "otherparam" "otherParam" "something" "matchAnything"}}">http://localhost/mypath4/:param1/statichere/:param2/:otherparam/*something</a>
+
+<br />
+<br />
+
+<a href="{{url "my-page5" "param1" "theParam1" "param2" "theParam2AfterStatic" "otherparam" "otherParam" "something" "matchAnythingAfterStatic"}}">
+  http://localhost:8080/mypath5/:param1/statichere/:param2/:otherparam/anything/*anything</a>
+
+<br />
+<br />
+
+<a href={{url "my-page6" .ParamsAsArray }}>http://localhost:8080/mypath6/{param1}/{param2}/staticParam/{param3AfterStatic}</a>

_examples/examples/intermediate/view/template_html_4/hosts

@@ -0,0 +1,32 @@
+# Copyright (c) 1993-2009 Microsoft Corp.
+#
+# This is a sample HOSTS file used by Microsoft TCP/IP for Windows.
+#
+# This file contains the mappings of IP addresses to host names. Each
+# entry should be kept on an individual line. The IP address should
+# be placed in the first column followed by the corresponding host name.
+# The IP address and the host name should be separated by at least one
+# space.
+#
+# Additionally, comments (such as these) may be inserted on individual
+# lines or following the machine name denoted by a '#' symbol.
+#
+# For example:
+#
+#      102.54.94.97     rhino.acme.com          # source server
+#       38.25.63.10     x.acme.com              # x client host
+
+# localhost name resolution is handled within DNS itself.
+127.0.0.1       localhost
+::1             localhost
+#-IRIS-For development machine, you have to configure your dns also for online, search google how to do it if you don't know
+
+127.0.0.1		username1.127.0.0.1
+127.0.0.1		username2.127.0.0.1
+127.0.0.1		username3.127.0.0.1
+127.0.0.1		username4.127.0.0.1
+127.0.0.1		username5.127.0.0.1
+# note that you can always use custom subdomains
+#-END IRIS-
+
+# Windows: Drive:/Windows/system32/drivers/etc/hosts, on Linux: /etc/hosts

_examples/examples/intermediate/view/template_html_4/main.go

@@ -0,0 +1,53 @@
+// Package main an example on how to naming your routes & use the custom 'url' HTML Template Engine, same for other template engines.
+package main
+
+import (
+	"gopkg.in/kataras/iris.v6"
+	"gopkg.in/kataras/iris.v6/adaptors/gorillamux"
+	"gopkg.in/kataras/iris.v6/adaptors/view"
+)
+
+func main() {
+	app := iris.New()
+	app.Adapt(iris.DevLogger())
+	app.Adapt(gorillamux.New())
+
+	app.Adapt(view.HTML("./templates", ".html"))
+
+	app.Get("/mypath", emptyHandler).ChangeName("my-page1")
+	app.Get("/mypath2/{param1}/{param2}", emptyHandler).ChangeName("my-page2")
+	app.Get("/mypath3/{param1}/statichere/{param2}", emptyHandler).ChangeName("my-page3")
+	app.Get("/mypath4/{param1}/statichere/{param2}/{otherparam}/{something:.*}", emptyHandler).ChangeName("my-page4")
+
+	// same with Handle/Func
+	app.HandleFunc("GET", "/mypath5/{param1}/statichere/{param2}/{otherparam}/anything/{something:.*}", emptyHandler).ChangeName("my-page5")
+
+	app.Get("/mypath6/{param1}/{param2}/staticParam/{param3AfterStatic}", emptyHandler).ChangeName("my-page6")
+
+	app.Get("/", func(ctx *iris.Context) {
+		// for /mypath6...
+		paramsAsArray := []string{"param1", "theParam1",
+			"param2", "theParam2",
+			"param3AfterStatic", "theParam3"}
+
+		if err := ctx.Render("page.html", iris.Map{"ParamsAsArray": paramsAsArray}); err != nil {
+			panic(err)
+		}
+	})
+
+	app.Get("/redirect/{namedRoute}", func(ctx *iris.Context) {
+		routeName := ctx.Param("namedRoute")
+
+		println("The full uri of " + routeName + "is: " + app.URL(routeName))
+		// if routeName == "my-page1"
+		// prints: The full uri of my-page1 is: http://127.0.0.1:8080/mypath
+		ctx.RedirectTo(routeName)
+		// http://127.0.0.1:8080/redirect/my-page1 will redirect to -> http://127.0.0.1:8080/mypath
+	})
+
+	app.Listen("localhost:8080")
+}
+
+func emptyHandler(ctx *iris.Context) {
+	ctx.Writef("Hello from %s.", ctx.Path())
+}

_examples/examples/intermediate/view/template_html_4/templates/page.html

@@ -0,0 +1,16 @@
+<!-- the only difference between normal named routes and dynamic subdomains named routes is that the first argument of  url
+is the subdomain part instead of named parameter-->
+
+<a href="{{url "dynamic-subdomain1" "username1"}}">username1.127.0.0.1:8080/mypath</a>
+<br />
+<br />
+<a href="{{url "dynamic-subdomain2" "username2" "theParam1" "theParam2"}}">username2.127.0.0.1:8080/mypath2/{param1}/{param2}</a>
+<br />
+<br />
+<a href="{{url "dynamic-subdomain3" "username3" "theParam1" "theParam2AfterStatic"}}">username3.127.0.0.1:8080/mypath3/{param1}/statichere/{param2}</a>
+<br />
+<br />
+<a href="{{url "dynamic-subdomain4" "username4" "theParam1" "theparam2AfterStatic" "otherParam" "matchAnything"}}">username4.127.0.0.1:8080/mypath4/{param1}/statichere/{param2}/{otherParam}/{something:.*}</a>
+<br />
+<br />
+<a href="{{url "dynamic-subdomain5" .ParamsAsArray }}" >username5.127.0.0.1:8080/mypath6/{param1}/{param2}/staticParam/{param3}AfterStatic</a>