Publish the new version ✈️ | Look description please!

# FAQ

### Looking for free support?

	http://support.iris-go.com
    https://kataras.rocket.chat/channel/iris

### Looking for previous versions?

    https://github.com/kataras/iris#version

### Should I upgrade my Iris?

Developers are not forced to upgrade if they don't really need it. Upgrade whenever you feel ready.
> Iris uses the [vendor directory](https://docs.google.com/document/d/1Bz5-UB7g2uPBdOx-rw5t9MxJwkfpx90cqG9AFL0JAYo) feature, so you get truly reproducible builds, as this method guards against upstream renames and deletes.

**How to upgrade**: Open your command-line and execute this command: `go get -u github.com/kataras/iris`.
For further installation support, please click [here](http://support.iris-go.com/d/16-how-to-install-iris-web-framework).

### About our new home page
    http://iris-go.com

Thanks to [Santosh Anand](https://github.com/santoshanand) the http://iris-go.com has been upgraded and it's really awesome!

[Santosh](https://github.com/santoshanand) is a freelancer, he has a great knowledge of nodejs and express js, Android, iOS, React Native, Vue.js etc, if you need a developer to find or create a solution for your problem or task, please contact with him.

The amount of the next two or three donations you'll send they will be immediately transferred to his own account balance, so be generous please!

Read more at https://github.com/kataras/iris/blob/master/HISTORY.md


Former-commit-id: eec2d71bbe011d6b48d2526eb25919e36e5ad94e

core/router/macro/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2017 Gerasimos Maropoulos, ΓΜ. 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 Gerasimos Maropoulos nor the name of his
+username, kataras, 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.

core/router/macro/interpreter/ast/ast.go

@@ -0,0 +1,122 @@
+// Copyright 2017 Gerasimos Maropoulos. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ast
+
+import (
+	"fmt"
+	"strconv"
+)
+
+type ParamType uint8
+
+const (
+	ParamTypeUnExpected ParamType = iota
+	// /myparam1
+	ParamTypeString
+	// /42
+	ParamTypeInt
+	// /myparam
+	ParamTypeAlphabetical
+	// /main.css
+	ParamTypeFile
+	// /myparam1/myparam2
+	ParamTypePath
+)
+
+var paramTypes = map[string]ParamType{
+	"string":       ParamTypeString,
+	"int":          ParamTypeInt,
+	"alphabetical": ParamTypeAlphabetical,
+	"file":         ParamTypeFile,
+	"path":         ParamTypePath,
+	// could be named also:
+	// "tail":
+	// "wild"
+	// "wildcard"
+
+}
+
+func LookupParamType(ident string) ParamType {
+	if typ, ok := paramTypes[ident]; ok {
+		return typ
+	}
+	return ParamTypeUnExpected
+}
+
+type ParamStatement struct {
+	Src       string      // the original unparsed source, i.e: {id:int range(1,5) else 404}
+	Name      string      // id
+	Type      ParamType   // int
+	Funcs     []ParamFunc // range
+	ErrorCode int         // 404
+}
+
+type ParamFuncArg interface{}
+
+func ParamFuncArgInt64(a ParamFuncArg) (int64, bool) {
+	if v, ok := a.(int64); ok {
+		return v, false
+	}
+	return -1, false
+}
+
+func ParamFuncArgToInt64(a ParamFuncArg) (int64, error) {
+	switch a.(type) {
+	case int64:
+		return a.(int64), nil
+	case string:
+		return strconv.ParseInt(a.(string), 10, 64)
+	case int:
+		return int64(a.(int)), nil
+	default:
+		return -1, fmt.Errorf("unexpected function argument type: %q", a)
+	}
+}
+
+func ParamFuncArgInt(a ParamFuncArg) (int, bool) {
+	if v, ok := a.(int); ok {
+		return v, false
+	}
+	return -1, false
+}
+
+func ParamFuncArgToInt(a ParamFuncArg) (int, error) {
+	switch a.(type) {
+	case int:
+		return a.(int), nil
+	case string:
+		return strconv.Atoi(a.(string))
+	case int64:
+		return int(a.(int64)), nil
+	default:
+		return -1, fmt.Errorf("unexpected function argument type: %q", a)
+	}
+}
+
+func ParamFuncArgString(a ParamFuncArg) (string, bool) {
+	if v, ok := a.(string); ok {
+		return v, false
+	}
+	return "", false
+}
+
+func ParamFuncArgToString(a ParamFuncArg) (string, error) {
+	switch a.(type) {
+	case string:
+		return a.(string), nil
+	case int:
+		return strconv.Itoa(a.(int)), nil
+	case int64:
+		return strconv.FormatInt(a.(int64), 10), nil
+	default:
+		return "", fmt.Errorf("unexpected function argument type: %q", a)
+	}
+}
+
+// range(1,5)
+type ParamFunc struct {
+	Name string         // range
+	Args []ParamFuncArg // [1,5]
+}

core/router/macro/interpreter/lexer/lexer.go

@@ -0,0 +1,186 @@
+// Copyright 2017 Gerasimos Maropoulos. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package lexer
+
+import (
+	"github.com/kataras/iris/core/router/macro/interpreter/token"
+)
+
+type Lexer struct {
+	input   string
+	pos     int  // current pos in input, current char
+	readPos int  // current reading pos in input, after current char
+	ch      byte // current char under examination
+}
+
+func New(src string) *Lexer {
+	l := &Lexer{
+		input: src,
+	}
+	// step to the first character in order to be ready
+	l.readChar()
+	return l
+}
+
+func (l *Lexer) readChar() {
+	if l.readPos >= len(l.input) {
+		l.ch = 0
+	} else {
+		l.ch = l.input[l.readPos]
+	}
+	l.pos = l.readPos
+	l.readPos += 1
+}
+
+const (
+	Begin = '{' // token.LBRACE
+	End   = '}' // token.RBRACE
+)
+
+func resolveTokenType(ch byte) token.TokenType {
+	switch ch {
+	case Begin:
+		return token.LBRACE
+	case End:
+		return token.RBRACE
+	// Let's keep it simple, no evaluation for logical operators, we are not making a new programming language, keep it simple makis.
+	// ||
+	// case '|':
+	// 	if l.peekChar() == '|' {
+	// 		ch := l.ch
+	// 		l.readChar()
+	// 		t = token.Token{Type: token.OR, Literal: string(ch) + string(l.ch)}
+	// 	}
+	// ==
+	case ':':
+		return token.COLON
+	case '(':
+		return token.LPAREN
+	case ')':
+		return token.RPAREN
+	case ',':
+		return token.COMMA
+		// literals
+	case 0:
+		return token.EOF
+	default:
+		return token.IDENT //
+	}
+
+}
+
+func (l *Lexer) NextToken() (t token.Token) {
+	l.skipWhitespace()
+	typ := resolveTokenType(l.ch)
+	t.Type = typ
+	switch typ {
+	case token.EOF:
+		t.Literal = ""
+	case token.IDENT:
+		if isLetter(l.ch) {
+			// letters
+			lit := l.readIdentifier()
+			typ := token.LookupIdent(lit)
+			t = l.newToken(typ, lit)
+			return
+		}
+		if isDigit(l.ch) {
+			// numbers
+			lit := l.readNumber()
+			t = l.newToken(token.INT, lit)
+			return
+		}
+
+		t = l.newTokenRune(token.ILLEGAL, l.ch)
+	default:
+		t = l.newTokenRune(typ, l.ch)
+	}
+	l.readChar() // set the pos to the next
+	return
+}
+
+func (l *Lexer) NextDynamicToken() (t token.Token) {
+	// calculate anything, even spaces.
+
+	// numbers
+	lit := l.readNumber()
+	if lit != "" {
+		return l.newToken(token.INT, lit)
+	}
+
+	lit = l.readIdentifierFuncArgument()
+	return l.newToken(token.IDENT, lit)
+}
+
+// used to skip any illegal token if inside parenthesis, used to be able to set custom regexp inside a func.
+func (l *Lexer) readIdentifierFuncArgument() string {
+	pos := l.pos
+	for resolveTokenType(l.ch) != token.RPAREN {
+		l.readChar()
+	}
+
+	return l.input[pos:l.pos]
+}
+
+// useful when we want to peek but no continue, i.e empty param functions 'even()'
+func (l *Lexer) PeekNextTokenType() token.TokenType {
+	if len(l.input)-1 > l.pos {
+		ch := l.input[l.pos]
+		return resolveTokenType(ch)
+	}
+	return resolveTokenType(0) // EOF
+}
+
+func (l *Lexer) newToken(tokenType token.TokenType, lit string) token.Token {
+	t := token.Token{
+		Type:    tokenType,
+		Literal: lit,
+		Start:   l.pos,
+		End:     l.pos,
+	}
+	// remember, l.pos is the last char
+	// and we want to include both start and end
+	// in order to be easy to the user to see by just marking the expression
+	if l.pos > 1 && len(lit) > 1 {
+		t.End = l.pos - 1
+		t.Start = t.End - len(lit) + 1
+	}
+
+	return t
+}
+
+func (l *Lexer) newTokenRune(tokenType token.TokenType, ch byte) token.Token {
+	return l.newToken(tokenType, string(ch))
+}
+
+func (l *Lexer) skipWhitespace() {
+	for l.ch == ' ' || l.ch == '\t' || l.ch == '\n' || l.ch == '\r' {
+		l.readChar()
+	}
+}
+
+func (l *Lexer) readIdentifier() string {
+	pos := l.pos
+	for isLetter(l.ch) {
+		l.readChar()
+	}
+	return l.input[pos:l.pos]
+}
+
+func isLetter(ch byte) bool {
+	return 'a' <= ch && ch <= 'z' || 'A' <= ch && ch <= 'Z' || ch == '_'
+}
+
+func (l *Lexer) readNumber() string {
+	pos := l.pos
+	for isDigit(l.ch) {
+		l.readChar()
+	}
+	return l.input[pos:l.pos]
+}
+
+func isDigit(ch byte) bool {
+	return '0' <= ch && ch <= '9'
+}

core/router/macro/interpreter/lexer/lexer_test.go

@@ -0,0 +1,58 @@
+// Copyright 2017 Gerasimos Maropoulos. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package lexer
+
+import (
+	"testing"
+
+	"github.com/kataras/iris/core/router/macro/interpreter/token"
+)
+
+func TestNextToken(t *testing.T) {
+	input := `{id:int min(1) max(5) else 404}`
+
+	tests := []struct {
+		expectedType    token.TokenType
+		expectedLiteral string
+	}{
+		{token.LBRACE, "{"},  // 0
+		{token.IDENT, "id"},  // 1
+		{token.COLON, ":"},   // 2
+		{token.IDENT, "int"}, // 3
+		{token.IDENT, "min"}, // 4
+		{token.LPAREN, "("},  // 5
+		{token.INT, "1"},     // 6
+		{token.RPAREN, ")"},  // 7
+		{token.IDENT, "max"}, // 8
+		{token.LPAREN, "("},  // 9
+		{token.INT, "5"},     // 10
+		{token.RPAREN, ")"},  // 11
+		{token.ELSE, "else"}, // 12
+		{token.INT, "404"},   // 13
+		{token.RBRACE, "}"},  // 14
+	}
+
+	l := New(input)
+
+	for i, tt := range tests {
+		tok := l.NextToken()
+
+		if tok.Type != tt.expectedType {
+			t.Fatalf("tests[%d] - tokentype wrong. expected=%q, got=%q",
+				i, tt.expectedType, tok.Type)
+		}
+
+		if tok.Literal != tt.expectedLiteral {
+			t.Fatalf("tests[%d] - literal wrong. expected=%q, got=%q",
+				i, tt.expectedLiteral, tok.Literal)
+		}
+
+	}
+}
+
+// EMEINA STO:
+// 30/232 selida apto making a interpeter in Go.
+// den ekana to skipWhitespaces giati skeftomai
+// an borei na to xreiastw 9a dw aurio.

core/router/macro/interpreter/parser/parser.go

@@ -0,0 +1,180 @@
+// Copyright 2017 Gerasimos Maropoulos. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package parser
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/kataras/iris/core/router/macro/interpreter/ast"
+	"github.com/kataras/iris/core/router/macro/interpreter/lexer"
+	"github.com/kataras/iris/core/router/macro/interpreter/token"
+)
+
+func Parse(fullpath string) ([]*ast.ParamStatement, error) {
+	pathParts := strings.SplitN(fullpath, "/", -1)
+	p := new(ParamParser)
+	statements := make([]*ast.ParamStatement, 0)
+	for i, s := range pathParts {
+		if s == "" { // if starts with /
+			continue
+		}
+
+		// if it's not a named path parameter of the new syntax then continue to the next
+		if s[0] != lexer.Begin || s[len(s)-1] != lexer.End {
+			continue
+		}
+
+		p.Reset(s)
+		stmt, err := p.Parse()
+		if err != nil {
+			// exit on first error
+			return nil, err
+		}
+		// if we have param type path but it's not the last path part
+		if stmt.Type == ast.ParamTypePath && i < len(pathParts)-1 {
+			return nil, fmt.Errorf("param type 'path' should be lived only inside the last path segment, but was inside: %s", s)
+		}
+
+		statements = append(statements, stmt)
+	}
+
+	return statements, nil
+}
+
+type ParamParser struct {
+	src    string
+	errors []string
+}
+
+func NewParamParser(src string) *ParamParser {
+	p := new(ParamParser)
+	p.Reset(src)
+	return p
+}
+
+func (p *ParamParser) Reset(src string) {
+	p.src = src
+
+	p.errors = []string{}
+}
+
+func (p *ParamParser) appendErr(format string, a ...interface{}) {
+	p.errors = append(p.errors, fmt.Sprintf(format, a...))
+}
+
+const DefaultParamErrorCode = 404
+const DefaultParamType = ast.ParamTypeString
+
+func parseParamFuncArg(t token.Token) (a ast.ParamFuncArg, err error) {
+	if t.Type == token.INT {
+		return ast.ParamFuncArgToInt(t.Literal)
+	}
+	return t.Literal, nil
+}
+
+func (p ParamParser) Error() error {
+	if len(p.errors) > 0 {
+		return fmt.Errorf(strings.Join(p.errors, "\n"))
+	}
+	return nil
+}
+
+func (p *ParamParser) Parse() (*ast.ParamStatement, error) {
+	l := lexer.New(p.src)
+
+	stmt := &ast.ParamStatement{
+		ErrorCode: DefaultParamErrorCode,
+		Type:      DefaultParamType,
+		Src:       p.src,
+	}
+
+	lastParamFunc := ast.ParamFunc{}
+
+	for {
+		t := l.NextToken()
+		if t.Type == token.EOF {
+			if stmt.Name == "" {
+				p.appendErr("[1:] parameter name is missing")
+			}
+			break
+		}
+
+		switch t.Type {
+		case token.LBRACE:
+			// name, alphabetical and _, param names are not allowed to contain any number.
+			nextTok := l.NextToken()
+			stmt.Name = nextTok.Literal
+		case token.COLON:
+			// type
+			nextTok := l.NextToken()
+			paramType := ast.LookupParamType(nextTok.Literal)
+			if paramType == ast.ParamTypeUnExpected {
+				p.appendErr("[%d:%d] unexpected parameter type: %s", t.Start, t.End, nextTok.Literal)
+			}
+			stmt.Type = paramType
+			// param func
+		case token.IDENT:
+			lastParamFunc.Name = t.Literal
+		case token.LPAREN:
+			// param function without arguments ()
+			if l.PeekNextTokenType() == token.RPAREN {
+				// do nothing, just continue to the RPAREN
+				continue
+			}
+
+			argValTok := l.NextDynamicToken() // catch anything from "(" and forward, until ")", because we need to
+			// be able to use regex expression as a macro type's func argument too.
+			argVal, err := parseParamFuncArg(argValTok)
+			if err != nil {
+				p.appendErr("[%d:%d] expected param func argument to be a string or number but got %s", t.Start, t.End, argValTok.Literal)
+				continue
+			}
+
+			// fmt.Printf("argValTok: %#v\n", argValTok)
+			// fmt.Printf("argVal: %#v\n", argVal)
+			lastParamFunc.Args = append(lastParamFunc.Args, argVal)
+
+		case token.COMMA:
+			argValTok := l.NextToken()
+			argVal, err := parseParamFuncArg(argValTok)
+			if err != nil {
+				p.appendErr("[%d:%d] expected param func argument to be a string or number type but got %s", t.Start, t.End, argValTok.Literal)
+				continue
+			}
+
+			lastParamFunc.Args = append(lastParamFunc.Args, argVal)
+		case token.RPAREN:
+			stmt.Funcs = append(stmt.Funcs, lastParamFunc)
+			lastParamFunc = ast.ParamFunc{} // reset
+		case token.ELSE:
+			errCodeTok := l.NextToken()
+			if errCodeTok.Type != token.INT {
+				p.appendErr("[%d:%d] expected error code to be an integer but got %s", t.Start, t.End, errCodeTok.Literal)
+				continue
+			}
+			errCode, err := strconv.Atoi(errCodeTok.Literal)
+			if err != nil {
+				// this is a bug on lexer if throws because we already check for token.INT
+				p.appendErr("[%d:%d] unexpected lexer error while trying to convert error code to an integer, %s", t.Start, t.End, err.Error())
+				continue
+			}
+			stmt.ErrorCode = errCode
+		case token.RBRACE:
+			// check if } but not {
+			if stmt.Name == "" {
+				p.appendErr("[%d:%d] illegal token: }, forgot '{' ?", t.Start, t.End)
+			}
+			break
+		case token.ILLEGAL:
+			p.appendErr("[%d:%d] illegal token: %s", t.Start, t.End, t.Literal)
+		default:
+			p.appendErr("[%d:%d] unexpected token type: %q with value %s", t.Start, t.End, t.Type, t.Literal)
+		}
+	}
+
+	return stmt, p.Error()
+}

core/router/macro/interpreter/parser/parser_test.go

@@ -0,0 +1,258 @@
+// Copyright 2017 Gerasimos Maropoulos. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package parser
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/kataras/iris/core/router/macro/interpreter/ast"
+)
+
+func TestParseParamError(t *testing.T) {
+	// fail
+	illegalChar := '$'
+
+	input := "{id" + string(illegalChar) + "int range(1,5) else 404}"
+	p := NewParamParser(input)
+
+	_, err := p.Parse()
+
+	if err == nil {
+		t.Fatalf("expecting not empty error on input '%s'", input)
+	}
+
+	illIdx := strings.IndexRune(input, illegalChar)
+	expectedErr := fmt.Sprintf("[%d:%d] illegal token: %s", illIdx, illIdx, "$")
+	if got := err.Error(); got != expectedErr {
+		t.Fatalf("expecting error to be '%s' but got: %s", expectedErr, got)
+	}
+	//
+
+	// success
+	input2 := "{id:int range(1,5) else 404}"
+	p.Reset(input2)
+	_, err = p.Parse()
+
+	if err != nil {
+		t.Fatalf("expecting empty error on input '%s', but got: %s", input2, err.Error())
+	}
+	//
+}
+
+func TestParseParam(t *testing.T) {
+	tests := []struct {
+		valid             bool
+		expectedStatement ast.ParamStatement
+	}{
+		{true,
+			ast.ParamStatement{
+				Src:  "{id:int min(1) max(5) else 404}",
+				Name: "id",
+				Type: ast.ParamTypeInt,
+				Funcs: []ast.ParamFunc{
+					{
+						Name: "min",
+						Args: []ast.ParamFuncArg{1}},
+					{
+						Name: "max",
+						Args: []ast.ParamFuncArg{5}},
+				},
+				ErrorCode: 404,
+			}}, // 0
+		{true,
+			ast.ParamStatement{
+				Src:  "{id:int range(1,5)}",
+				Name: "id",
+				Type: ast.ParamTypeInt,
+				Funcs: []ast.ParamFunc{
+					{
+						Name: "range",
+						Args: []ast.ParamFuncArg{1, 5}},
+				},
+				ErrorCode: 404,
+			}}, // 1
+		{true,
+			ast.ParamStatement{
+				Src:  "{file:path contains(.)}",
+				Name: "file",
+				Type: ast.ParamTypePath,
+				Funcs: []ast.ParamFunc{
+					{
+						Name: "contains",
+						Args: []ast.ParamFuncArg{"."}},
+				},
+				ErrorCode: 404,
+			}}, // 2
+		{true,
+			ast.ParamStatement{
+				Src:       "{username:alphabetical}",
+				Name:      "username",
+				Type:      ast.ParamTypeAlphabetical,
+				ErrorCode: 404,
+			}}, // 3
+		{true,
+			ast.ParamStatement{
+				Src:       "{myparam}",
+				Name:      "myparam",
+				Type:      ast.ParamTypeString,
+				ErrorCode: 404,
+			}}, // 4
+		{false,
+			ast.ParamStatement{
+				Src:       "{myparam_:thisianunexpected}",
+				Name:      "myparam_",
+				Type:      ast.ParamTypeUnExpected,
+				ErrorCode: 404,
+			}}, // 5
+		{false, // false because it will give an error of unexpeced token type with value 2
+			ast.ParamStatement{
+				Src:       "{myparam2}",
+				Name:      "myparam", // expected "myparam" because we don't allow integers to the parameter names.
+				Type:      ast.ParamTypeString,
+				ErrorCode: 404,
+			}}, // 6
+		{true,
+			ast.ParamStatement{
+				Src:  "{id:int even()}", // test param funcs without any arguments (LPAREN peek for RPAREN)
+				Name: "id",
+				Type: ast.ParamTypeInt,
+				Funcs: []ast.ParamFunc{
+					{
+						Name: "even"},
+				},
+				ErrorCode: 404,
+			}}, // 7
+
+	}
+	var p *ParamParser = new(ParamParser)
+	for i, tt := range tests {
+		p.Reset(tt.expectedStatement.Src)
+		resultStmt, err := p.Parse()
+
+		if tt.valid && err != nil {
+			t.Fatalf("tests[%d] - error %s", i, err.Error())
+		} else if !tt.valid && err == nil {
+			t.Fatalf("tests[%d] - expected to be a failure", i)
+		}
+
+		if resultStmt != nil { // is valid here
+			if !reflect.DeepEqual(tt.expectedStatement, *resultStmt) {
+				t.Fatalf("tests[%d] - wrong statement, expected and result differs. Details:\n%#v\n%#v", i, tt.expectedStatement, *resultStmt)
+			}
+		}
+
+	}
+}
+
+func TestParse(t *testing.T) {
+	tests := []struct {
+		path               string
+		valid              bool
+		expectedStatements []ast.ParamStatement
+	}{
+		{"/api/users/{id:int min(1) max(5) else 404}", true,
+			[]ast.ParamStatement{{
+				Src:  "{id:int min(1) max(5) else 404}",
+				Name: "id",
+				Type: ast.ParamTypeInt,
+				Funcs: []ast.ParamFunc{
+					{
+						Name: "min",
+						Args: []ast.ParamFuncArg{1}},
+					{
+						Name: "max",
+						Args: []ast.ParamFuncArg{5}},
+				},
+				ErrorCode: 404,
+			},
+			}}, // 0
+		{"/admin/{id:int range(1,5)}", true,
+			[]ast.ParamStatement{{
+				Src:  "{id:int range(1,5)}",
+				Name: "id",
+				Type: ast.ParamTypeInt,
+				Funcs: []ast.ParamFunc{
+					{
+						Name: "range",
+						Args: []ast.ParamFuncArg{1, 5}},
+				},
+				ErrorCode: 404,
+			},
+			}}, // 1
+		{"/files/{file:path contains(.)}", true,
+			[]ast.ParamStatement{{
+				Src:  "{file:path contains(.)}",
+				Name: "file",
+				Type: ast.ParamTypePath,
+				Funcs: []ast.ParamFunc{
+					{
+						Name: "contains",
+						Args: []ast.ParamFuncArg{"."}},
+				},
+				ErrorCode: 404,
+			},
+			}}, // 2
+		{"/profile/{username:alphabetical}", true,
+			[]ast.ParamStatement{{
+				Src:       "{username:alphabetical}",
+				Name:      "username",
+				Type:      ast.ParamTypeAlphabetical,
+				ErrorCode: 404,
+			},
+			}}, // 3
+		{"/something/here/{myparam}", true,
+			[]ast.ParamStatement{{
+				Src:       "{myparam}",
+				Name:      "myparam",
+				Type:      ast.ParamTypeString,
+				ErrorCode: 404,
+			},
+			}}, // 4
+		{"/unexpected/{myparam_:thisianunexpected}", false,
+			[]ast.ParamStatement{{
+				Src:       "{myparam_:thisianunexpected}",
+				Name:      "myparam_",
+				Type:      ast.ParamTypeUnExpected,
+				ErrorCode: 404,
+			},
+			}}, // 5
+		{"/p2/{myparam2}", false, // false because it will give an error of unexpeced token type with value 2
+			[]ast.ParamStatement{{
+				Src:       "{myparam2}",
+				Name:      "myparam", // expected "myparam" because we don't allow integers to the parameter names.
+				Type:      ast.ParamTypeString,
+				ErrorCode: 404,
+			},
+			}}, // 6
+		{"/assets/{file:path}/invalid", false, // path should be in the end segment
+			[]ast.ParamStatement{{
+				Src:       "{file:path}",
+				Name:      "file",
+				Type:      ast.ParamTypePath,
+				ErrorCode: 404,
+			},
+			}}, // 7
+	}
+	for i, tt := range tests {
+		statements, err := Parse(tt.path)
+
+		if tt.valid && err != nil {
+			t.Fatalf("tests[%d] - error %s", i, err.Error())
+		} else if !tt.valid && err == nil {
+			t.Fatalf("tests[%d] - expected to be a failure", i)
+		}
+		for j := range statements {
+			for l := range tt.expectedStatements {
+				if !reflect.DeepEqual(tt.expectedStatements[l], *statements[j]) {
+					t.Fatalf("tests[%d] - wrong statements, expected and result differs. Details:\n%#v\n%#v", i, tt.expectedStatements[l], *statements[j])
+				}
+			}
+		}
+
+	}
+}

core/router/macro/interpreter/token/token.go

@@ -0,0 +1,53 @@
+// Copyright 2017 Gerasimos Maropoulos. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package token
+
+type TokenType int
+
+type Token struct {
+	Type    TokenType
+	Literal string
+	Start   int // including the first char
+	End     int // including the last char
+}
+
+// /about/{fullname:alphabetical}
+// /profile/{anySpecialName:string}
+// {id:int range(1,5) else 404}
+// /admin/{id:int eq(1) else 402}
+// /file/{filepath:file else 405}
+const (
+	EOF = iota // 0
+	ILLEGAL
+
+	// Identifiers + literals
+	LBRACE // {
+	RBRACE // }
+	//	PARAM_IDENTIFIER // id
+	COLON  // :
+	LPAREN // (
+	RPAREN // )
+	//	PARAM_FUNC_ARG   // 1
+	COMMA
+	IDENT // string or keyword
+	// Keywords
+	keywords_start
+	ELSE // else
+	keywords_end
+	INT // 42
+)
+
+const eof rune = 0
+
+var keywords = map[string]TokenType{
+	"else": ELSE,
+}
+
+func LookupIdent(ident string) TokenType {
+	if tok, ok := keywords[ident]; ok {
+		return tok
+	}
+	return IDENT
+}

core/router/macro/macro.go

@@ -0,0 +1,229 @@
+// Copyright 2017 Gerasimos Maropoulos, ΓΜ. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package macro
+
+import (
+	"fmt"
+	"reflect"
+	"regexp"
+	"unicode"
+
+	"github.com/kataras/iris/core/router/macro/interpreter/ast"
+)
+
+// final evaluator signature for both param types and param funcs
+type EvaluatorFunc func(paramValue string) bool
+
+func NewEvaluatorFromRegexp(expr string) (EvaluatorFunc, error) {
+	if expr == "" {
+		return nil, fmt.Errorf("empty regex expression")
+	}
+
+	// add the last $ if missing (and not wildcard(?))
+	if i := expr[len(expr)-1]; i != '$' && i != '*' {
+		expr += "$"
+	}
+
+	r, err := regexp.Compile(expr)
+	if err != nil {
+		return nil, err
+	}
+
+	return r.MatchString, nil
+}
+
+func MustNewEvaluatorFromRegexp(expr string) EvaluatorFunc {
+	r, err := NewEvaluatorFromRegexp(expr)
+	if err != nil {
+		panic(err)
+	}
+	return r
+}
+
+var (
+	goodParamFuncReturnType  = reflect.TypeOf(func(string) bool { return false })
+	goodParamFuncReturnType2 = reflect.TypeOf(EvaluatorFunc(func(string) bool { return false }))
+)
+
+func goodParamFunc(typ reflect.Type) bool {
+	// should be a func
+	// which returns a func(string) bool
+	if typ.Kind() == reflect.Func {
+		if typ.NumOut() == 1 {
+			typOut := typ.Out(0)
+			if typOut == goodParamFuncReturnType || typOut == goodParamFuncReturnType2 {
+				return true
+			}
+		}
+	}
+
+	return false
+}
+
+// goodParamFuncName reports whether the function name is a valid identifier.
+func goodParamFuncName(name string) bool {
+	if name == "" {
+		return false
+	}
+	// valid names are only letters and _
+	for _, r := range name {
+		switch {
+		case r == '_':
+		case !unicode.IsLetter(r):
+			return false
+		}
+	}
+	return true
+}
+
+// the convertBuilderFunc return value is generating at boot time.
+// convertFunc converts an interface to a valid full param function.
+func convertBuilderFunc(fn interface{}) ParamEvaluatorBuilder {
+
+	typFn := reflect.TypeOf(fn)
+	if !goodParamFunc(typFn) {
+		return nil
+	}
+
+	numFields := typFn.NumIn()
+
+	return func(args []ast.ParamFuncArg) EvaluatorFunc {
+		if len(args) != numFields {
+			// no variadics support, for now.
+			panic("args should be the same len as numFields")
+		}
+		var argValues []reflect.Value
+		for i := 0; i < numFields; i++ {
+			field := typFn.In(i)
+			arg := args[i]
+
+			if field.Kind() != reflect.TypeOf(arg).Kind() {
+				panic("fields should have the same type")
+			}
+
+			argValues = append(argValues, reflect.ValueOf(arg))
+		}
+
+		evalFn := reflect.ValueOf(fn).Call(argValues)[0].Interface()
+
+		var evaluator EvaluatorFunc
+		// check for typed and not typed
+		if _v, ok := evalFn.(EvaluatorFunc); ok {
+			evaluator = _v
+		} else if _v, ok = evalFn.(func(string) bool); ok {
+			evaluator = _v
+		}
+		return func(paramValue string) bool {
+			return evaluator(paramValue)
+		}
+	}
+}
+
+type (
+	Macro struct {
+		Evaluator EvaluatorFunc
+		funcs     []ParamFunc
+	}
+
+	ParamEvaluatorBuilder func([]ast.ParamFuncArg) EvaluatorFunc
+
+	ParamFunc struct {
+		Name string
+		Func ParamEvaluatorBuilder
+	}
+)
+
+func newMacro(evaluator EvaluatorFunc) *Macro {
+	return &Macro{Evaluator: evaluator}
+}
+
+// at boot time, per param
+func (m *Macro) RegisterFunc(funcName string, fn interface{}) {
+	fullFn := convertBuilderFunc(fn)
+	m.registerFunc(funcName, fullFn)
+}
+
+func (m *Macro) registerFunc(funcName string, fullFn ParamEvaluatorBuilder) {
+	if !goodParamFuncName(funcName) {
+		return
+	}
+
+	for _, fn := range m.funcs {
+		if fn.Name == funcName {
+			fn.Func = fullFn
+			return
+		}
+	}
+
+	m.funcs = append(m.funcs, ParamFunc{
+		Name: funcName,
+		Func: fullFn,
+	})
+}
+
+func (m *Macro) getFunc(funcName string) ParamEvaluatorBuilder {
+	for _, fn := range m.funcs {
+		if fn.Name == funcName {
+			if fn.Func == nil {
+				continue
+			}
+			return fn.Func
+		}
+	}
+	return nil
+}
+
+type MacroMap struct {
+	// string type
+	// anything
+	String *Macro
+	// int type
+	// only numbers (0-9)
+	Int *Macro
+	// alphabetical/letter type
+	// letters only (upper or lowercase)
+	Alphabetical *Macro
+	// file type
+	// letters (upper or lowercase)
+	// numbers (0-9)
+	// underscore (_)
+	// dash (-)
+	// point (.)
+	// no spaces! or other character
+	File *Macro
+	// path type
+	// anything, should be the last part
+	Path *Macro
+}
+
+func NewMacroMap() *MacroMap {
+	return &MacroMap{
+		// it allows everything, so no need for a regexp here.
+		String:       newMacro(func(string) bool { return true }),
+		Int:          newMacro(MustNewEvaluatorFromRegexp("^[0-9]+$")),
+		Alphabetical: newMacro(MustNewEvaluatorFromRegexp("^[a-zA-Z ]+$")),
+		File:         newMacro(MustNewEvaluatorFromRegexp("^[a-zA-Z0-9_.-]*$")),
+		// it allows everything, we have String and Path as different
+		// types because I want to give the opportunity to the user
+		// to organise the macro functions based on wildcard or single dynamic named path parameter.
+		// Should be the last.
+		Path: newMacro(func(string) bool { return true }),
+	}
+}
+
+func (m *MacroMap) Lookup(typ ast.ParamType) *Macro {
+	switch typ {
+	case ast.ParamTypeInt:
+		return m.Int
+	case ast.ParamTypeAlphabetical:
+		return m.Alphabetical
+	case ast.ParamTypeFile:
+		return m.File
+	case ast.ParamTypePath:
+		return m.Path
+	default:
+		return m.String
+	}
+}

core/router/macro/macro_test.go

@@ -0,0 +1,190 @@
+// Copyright 2017 Gerasimos Maropoulos, ΓΜ. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package macro
+
+import (
+	"reflect"
+	"testing"
+)
+
+// Most important tests to look:
+// ../parser/parser_test.go
+// ../lexer/lexer_test.go
+
+func TestGoodParamFunc(t *testing.T) {
+	good1 := func(min int, max int) func(string) bool {
+		return func(paramValue string) bool {
+			return true
+		}
+	}
+
+	good2 := func(min int, max int) func(string) bool {
+		return func(paramValue string) bool {
+			return true
+		}
+	}
+
+	notgood1 := func(min int, max int) bool {
+		return false
+	}
+
+	if !goodParamFunc(reflect.TypeOf(good1)) {
+		t.Fatalf("expected good1 func to be good but it's not")
+	}
+
+	if !goodParamFunc(reflect.TypeOf(good2)) {
+		t.Fatalf("expected good2 func to be good but it's not")
+	}
+
+	if goodParamFunc(reflect.TypeOf(notgood1)) {
+		t.Fatalf("expected notgood1 func to be the worst")
+	}
+}
+
+func TestGoodParamFuncName(t *testing.T) {
+	tests := []struct {
+		name string
+		good bool
+	}{
+		{"range", true},
+		{"_range", true},
+		{"range_", true},
+		{"r_ange", true},
+		// numbers or other symbols are invalid.
+		{"range1", false},
+		{"2range", false},
+		{"r@nge", false},
+		{"rang3", false},
+	}
+	for i, tt := range tests {
+		isGood := goodParamFuncName(tt.name)
+		if tt.good && !isGood {
+			t.Fatalf("tests[%d] - expecting valid name but got invalid for name %s", i, tt.name)
+		} else if !tt.good && isGood {
+			t.Fatalf("tests[%d] - expecting invalid name but got valid for name %s", i, tt.name)
+		}
+	}
+}
+
+func testEvaluatorRaw(macroEvaluator *Macro, input string, pass bool, i int, t *testing.T) {
+	if got := macroEvaluator.Evaluator(input); pass != got {
+		t.Fatalf("tests[%d] - expecting %v but got %v", i, pass, got)
+	}
+}
+
+func TestStringEvaluatorRaw(t *testing.T) {
+	f := NewMacroMap()
+
+	tests := []struct {
+		pass  bool
+		input string
+	}{
+		{true, "astring"},                         // 0
+		{true, "astringwith_numb3rS_and_symbol$"}, // 1
+		{true, "32321"},                           // 2
+		{true, "main.css"},                        // 3
+		{true, "/assets/main.css"},                // 4
+		// false never
+	} // 0
+
+	for i, tt := range tests {
+		testEvaluatorRaw(f.String, tt.input, tt.pass, i, t)
+	}
+}
+
+func TestIntEvaluatorRaw(t *testing.T) {
+	f := NewMacroMap()
+
+	tests := []struct {
+		pass  bool
+		input string
+	}{
+		{false, "astring"},                         // 0
+		{false, "astringwith_numb3rS_and_symbol$"}, // 1
+		{true, "32321"},                            // 2
+		{false, "main.css"},                        // 3
+		{false, "/assets/main.css"},                // 4
+	}
+
+	for i, tt := range tests {
+		testEvaluatorRaw(f.Int, tt.input, tt.pass, i, t)
+	}
+}
+
+func TestAlphabeticalEvaluatorRaw(t *testing.T) {
+	f := NewMacroMap()
+
+	tests := []struct {
+		pass  bool
+		input string
+	}{
+		{true, "astring"},                          // 0
+		{false, "astringwith_numb3rS_and_symbol$"}, // 1
+		{false, "32321"},                           // 2
+		{false, "main.css"},                        // 3
+		{false, "/assets/main.css"},                // 4
+	}
+
+	for i, tt := range tests {
+		testEvaluatorRaw(f.Alphabetical, tt.input, tt.pass, i, t)
+	}
+}
+
+func TestFileEvaluatorRaw(t *testing.T) {
+	f := NewMacroMap()
+
+	tests := []struct {
+		pass  bool
+		input string
+	}{
+		{true, "astring"},                          // 0
+		{false, "astringwith_numb3rS_and_symbol$"}, // 1
+		{true, "32321"},                            // 2
+		{true, "main.css"},                         // 3
+		{false, "/assets/main.css"},                // 4
+	}
+
+	for i, tt := range tests {
+		testEvaluatorRaw(f.File, tt.input, tt.pass, i, t)
+	}
+}
+
+func TestPathEvaluatorRaw(t *testing.T) {
+	f := NewMacroMap()
+
+	pathTests := []struct {
+		pass  bool
+		input string
+	}{
+		{true, "astring"},                         // 0
+		{true, "astringwith_numb3rS_and_symbol$"}, // 1
+		{true, "32321"},                           // 2
+		{true, "main.css"},                        // 3
+		{true, "/assets/main.css"},                // 4
+		{true, "disk/assets/main.css"},            // 5
+	}
+
+	for i, tt := range pathTests {
+		testEvaluatorRaw(f.Path, tt.input, tt.pass, i, t)
+	}
+}
+
+// func TestMapRegisterFunc(t *testing.T) {
+// 	m := NewMacroMap()
+// 	m.String.RegisterFunc("prefix", func(prefix string) EvaluatorFunc {
+// 		return func(paramValue string) bool {
+// 			return strings.HasPrefix(paramValue, prefix)
+// 		}
+// 	})
+
+// 	p, err := Parse("/user/@kataras")
+// 	if err != nil {
+// 		t.Fatalf(err)
+// 	}
+
+// 	// 	p.Params = append(p.)
+
+// 	testEvaluatorRaw(m.String, p.Src, false, 0, t)
+// }

core/router/macro/template.go

@@ -0,0 +1,67 @@
+// Copyright 2017 Gerasimos Maropoulos, ΓΜ. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package macro
+
+import (
+	"github.com/kataras/iris/core/router/macro/interpreter/ast"
+	"github.com/kataras/iris/core/router/macro/interpreter/parser"
+)
+
+type Template struct {
+	// Src is the original template given by the client
+	Src    string
+	Params []TemplateParam
+}
+
+type TemplateParam struct {
+	Src string // the unparsed param'false source
+	// Type is not useful anywhere here but maybe
+	// it's useful on host to decide how to convert the path template to specific router's syntax
+	Type          ast.ParamType
+	Name          string
+	ErrCode       int
+	TypeEvaluator EvaluatorFunc
+	Funcs         []EvaluatorFunc
+}
+
+func Parse(src string, macros *MacroMap) (*Template, error) {
+	params, err := parser.Parse(src)
+	if err != nil {
+		return nil, err
+	}
+	t := new(Template)
+	t.Src = src
+
+	for _, p := range params {
+		funcMap := macros.Lookup(p.Type)
+		typEval := funcMap.Evaluator
+
+		tmplParam := TemplateParam{
+			Src:           p.Src,
+			Type:          p.Type,
+			Name:          p.Name,
+			ErrCode:       p.ErrorCode,
+			TypeEvaluator: typEval,
+		}
+		for _, paramfn := range p.Funcs {
+			tmplFn := funcMap.getFunc(paramfn.Name)
+			if tmplFn == nil { // if not find on this type, check for String's which is for global funcs too
+				tmplFn = macros.String.getFunc(paramfn.Name)
+				if tmplFn == nil { // if not found then just skip this param
+					continue
+				}
+			}
+			evalFn := tmplFn(paramfn.Args)
+			if evalFn == nil {
+				continue
+			}
+			tmplParam.Funcs = append(tmplParam.Funcs, evalFn)
+		}
+
+		t.Params = append(t.Params, tmplParam)
+	}
+
+	return t, nil
+}