move utils to utils libs & func move to templatefunc

@@ -3,6 +3,7 @@ package beego
 import (
 import (
 	"bytes"
 	"bytes"
 	"crypto/hmac"
 	"crypto/hmac"
+	"crypto/rand"
 	"crypto/sha1"
 	"crypto/sha1"
 	"encoding/base64"
 	"encoding/base64"
 	"errors"
 	"errors"
@@ -370,7 +371,7 @@ func (c *Controller) XsrfToken() string {
 			} else {
 			} else {
 				expire = int64(XSRFExpire)
 				expire = int64(XSRFExpire)
 			}
 			}
-			token = GetRandomString(15)
+			token = getRandomString(15)
 			c.SetSecureCookie(XSRFKEY, "_xsrf", token, expire)
 			c.SetSecureCookie(XSRFKEY, "_xsrf", token, expire)
 		}
 		}
 		c._xsrf_token = token
 		c._xsrf_token = token
@@ -405,3 +406,14 @@ func (c *Controller) GoToFunc(funcname string) {
 	}
 	}
 	c.gotofunc = funcname
 	c.gotofunc = funcname
 }
 }
+
+//utils func for controller internal
+func getRandomString(n int) string {
+	const alphanum = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+	var bytes = make([]byte, n)
+	rand.Read(bytes)
+	for i, b := range bytes {
+		bytes[i] = alphanum[b%byte(len(alphanum))]
+	}
+	return string(bytes)
+}

@@ -15,6 +15,7 @@ import (
 	beecontext "github.com/astaxie/beego/context"
 	beecontext "github.com/astaxie/beego/context"
 	"github.com/astaxie/beego/middleware"
 	"github.com/astaxie/beego/middleware"
 	"github.com/astaxie/beego/toolbox"
 	"github.com/astaxie/beego/toolbox"
+	"github.com/astaxie/beego/utils"
 )
 )
 
 
 const (
 const (
@@ -159,7 +160,7 @@ func (p *ControllerRegistor) Add(pattern string, c ControllerInterface, mappingM
 			}
 			}
 			comma := strings.Split(colon[0], ",")
 			comma := strings.Split(colon[0], ",")
 			for _, m := range comma {
 			for _, m := range comma {
-				if m == "*" || inSlice(strings.ToLower(m), HTTPMETHOD) {
+				if m == "*" || utils.InSlice(strings.ToLower(m), HTTPMETHOD) {
 					if val := reflectVal.MethodByName(colon[1]); val.IsValid() {
 					if val := reflectVal.MethodByName(colon[1]); val.IsValid() {
 						methods[strings.ToLower(m)] = colon[1]
 						methods[strings.ToLower(m)] = colon[1]
 					} else {
 					} else {
@@ -272,7 +273,7 @@ func (p *ControllerRegistor) UrlFor(endpoint string, values ...string) string {
 	for _, route := range p.fixrouters {
 	for _, route := range p.fixrouters {
 		if route.controllerType.Name() == controllName {
 		if route.controllerType.Name() == controllName {
 			var finded bool
 			var finded bool
-			if inSlice(strings.ToLower(methodName), HTTPMETHOD) {
+			if utils.InSlice(strings.ToLower(methodName), HTTPMETHOD) {
 				if route.hasMethod {
 				if route.hasMethod {
 					if m, ok := route.methods[strings.ToLower(methodName)]; ok && m != methodName {
 					if m, ok := route.methods[strings.ToLower(methodName)]; ok && m != methodName {
 						finded = false
 						finded = false
@@ -303,7 +304,7 @@ func (p *ControllerRegistor) UrlFor(endpoint string, values ...string) string {
 	for _, route := range p.routers {
 	for _, route := range p.routers {
 		if route.controllerType.Name() == controllName {
 		if route.controllerType.Name() == controllName {
 			var finded bool
 			var finded bool
-			if inSlice(strings.ToLower(methodName), HTTPMETHOD) {
+			if utils.InSlice(strings.ToLower(methodName), HTTPMETHOD) {
 				if route.hasMethod {
 				if route.hasMethod {
 					if m, ok := route.methods[strings.ToLower(methodName)]; ok && m != methodName {
 					if m, ok := route.methods[strings.ToLower(methodName)]; ok && m != methodName {
 						finded = false
 						finded = false
@@ -419,7 +420,7 @@ func (p *ControllerRegistor) ServeHTTP(rw http.ResponseWriter, r *http.Request)
 		context.Output = beecontext.NewOutput(rw)
 		context.Output = beecontext.NewOutput(rw)
 	}
 	}
 
 
-	if !inSlice(strings.ToLower(r.Method), HTTPMETHOD) {
+	if !utils.InSlice(strings.ToLower(r.Method), HTTPMETHOD) {
 		http.Error(w, "Method Not Allowed", 405)
 		http.Error(w, "Method Not Allowed", 405)
 		goto Admin
 		goto Admin
 	}
 	}

@@ -9,9 +9,10 @@ import (
 	"io/ioutil"
 	"io/ioutil"
 	"os"
 	"os"
 	"path/filepath"
 	"path/filepath"
-	"reflect"
 	"regexp"
 	"regexp"
 	"strings"
 	"strings"
+
+	"github.com/astaxie/beego/utils"
 )
 )
 
 
 var (
 var (
@@ -144,7 +145,7 @@ func getTplDeep(root, file, parent string, t *template.Template) (*template.Temp
 	} else {
 	} else {
 		fileabspath = filepath.Join(root, file)
 		fileabspath = filepath.Join(root, file)
 	}
 	}
-	if e, _ := FileExists(fileabspath); !e {
+	if e := utils.FileExists(fileabspath); !e {
 		panic("can't find template file" + file)
 		panic("can't find template file" + file)
 	}
 	}
 	data, err := ioutil.ReadFile(fileabspath)
 	data, err := ioutil.ReadFile(fileabspath)
@@ -238,156 +239,3 @@ func _getTemplate(t0 *template.Template, root string, submods [][]string, others
 	}
 	}
 	return
 	return
 }
 }
-
-// go1.2 added template funcs. begin
-var (
-	errBadComparisonType = errors.New("invalid type for comparison")
-	errBadComparison     = errors.New("incompatible types for comparison")
-	errNoComparison      = errors.New("missing argument for comparison")
-)
-
-type kind int
-
-const (
-	invalidKind kind = iota
-	boolKind
-	complexKind
-	intKind
-	floatKind
-	integerKind
-	stringKind
-	uintKind
-)
-
-func basicKind(v reflect.Value) (kind, error) {
-	switch v.Kind() {
-	case reflect.Bool:
-		return boolKind, nil
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		return intKind, nil
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
-		return uintKind, nil
-	case reflect.Float32, reflect.Float64:
-		return floatKind, nil
-	case reflect.Complex64, reflect.Complex128:
-		return complexKind, nil
-	case reflect.String:
-		return stringKind, nil
-	}
-	return invalidKind, errBadComparisonType
-}
-
-// eq evaluates the comparison a == b || a == c || ...
-func eq(arg1 interface{}, arg2 ...interface{}) (bool, error) {
-	v1 := reflect.ValueOf(arg1)
-	k1, err := basicKind(v1)
-	if err != nil {
-		return false, err
-	}
-	if len(arg2) == 0 {
-		return false, errNoComparison
-	}
-	for _, arg := range arg2 {
-		v2 := reflect.ValueOf(arg)
-		k2, err := basicKind(v2)
-		if err != nil {
-			return false, err
-		}
-		if k1 != k2 {
-			return false, errBadComparison
-		}
-		truth := false
-		switch k1 {
-		case boolKind:
-			truth = v1.Bool() == v2.Bool()
-		case complexKind:
-			truth = v1.Complex() == v2.Complex()
-		case floatKind:
-			truth = v1.Float() == v2.Float()
-		case intKind:
-			truth = v1.Int() == v2.Int()
-		case stringKind:
-			truth = v1.String() == v2.String()
-		case uintKind:
-			truth = v1.Uint() == v2.Uint()
-		default:
-			panic("invalid kind")
-		}
-		if truth {
-			return true, nil
-		}
-	}
-	return false, nil
-}
-
-// ne evaluates the comparison a != b.
-func ne(arg1, arg2 interface{}) (bool, error) {
-	// != is the inverse of ==.
-	equal, err := eq(arg1, arg2)
-	return !equal, err
-}
-
-// lt evaluates the comparison a < b.
-func lt(arg1, arg2 interface{}) (bool, error) {
-	v1 := reflect.ValueOf(arg1)
-	k1, err := basicKind(v1)
-	if err != nil {
-		return false, err
-	}
-	v2 := reflect.ValueOf(arg2)
-	k2, err := basicKind(v2)
-	if err != nil {
-		return false, err
-	}
-	if k1 != k2 {
-		return false, errBadComparison
-	}
-	truth := false
-	switch k1 {
-	case boolKind, complexKind:
-		return false, errBadComparisonType
-	case floatKind:
-		truth = v1.Float() < v2.Float()
-	case intKind:
-		truth = v1.Int() < v2.Int()
-	case stringKind:
-		truth = v1.String() < v2.String()
-	case uintKind:
-		truth = v1.Uint() < v2.Uint()
-	default:
-		panic("invalid kind")
-	}
-	return truth, nil
-}
-
-// le evaluates the comparison <= b.
-func le(arg1, arg2 interface{}) (bool, error) {
-	// <= is < or ==.
-	lessThan, err := lt(arg1, arg2)
-	if lessThan || err != nil {
-		return lessThan, err
-	}
-	return eq(arg1, arg2)
-}
-
-// gt evaluates the comparison a > b.
-func gt(arg1, arg2 interface{}) (bool, error) {
-	// > is the inverse of <=.
-	lessOrEqual, err := le(arg1, arg2)
-	if err != nil {
-		return false, err
-	}
-	return !lessOrEqual, nil
-}
-
-// ge evaluates the comparison a >= b.
-func ge(arg1, arg2 interface{}) (bool, error) {
-	// >= is the inverse of <.
-	lessThan, err := lt(arg1, arg2)
-	if err != nil {
-		return false, err
-	}
-	return !lessThan, nil
-}
-
-// go1.2 added template funcs. end

@@ -7,18 +7,6 @@ import (
 	"time"
 	"time"
 )
 )
 
 
-func TestWebTime(t *testing.T) {
-	ts := "Fri, 26 Jul 2013 12:27:42 CST"
-	l, _ := time.LoadLocation("GST")
-	tt, _ := time.ParseInLocation(time.RFC1123, ts, l)
-	if ts != webTime(tt) {
-		t.Error("should be equal")
-	}
-	if "Fri, 26 Jul 2013 12:27:42 GMT" != webTime(tt.UTC()) {
-		t.Error("should be equal")
-	}
-}
-
 func TestSubstr(t *testing.T) {
 func TestSubstr(t *testing.T) {
 	s := `012345`
 	s := `012345`
 	if Substr(s, 0, 2) != "01" {
 	if Substr(s, 0, 2) != "01" {
@@ -92,16 +80,6 @@ func TestHtmlunquote(t *testing.T) {
 	}
 	}
 }
 }
 
 
-func TestInSlice(t *testing.T) {
-	sl := []string{"A", "b"}
-	if !inSlice("A", sl) {
-		t.Error("should be true")
-	}
-	if inSlice("B", sl) {
-		t.Error("should be false")
-	}
-}
-
 func TestParseForm(t *testing.T) {
 func TestParseForm(t *testing.T) {
 	type user struct {
 	type user struct {
 		Id    int         `form:"-"`
 		Id    int         `form:"-"`

+package utils
+
+func InSlice(v string, sl []string) bool {
+	for _, vv := range sl {
+		if vv == v {
+			return true
+		}
+	}
+	return false
+}

+package utils
+
+import (
+	"testing"
+)
+
+func TestInSlice(t *testing.T) {
+	sl := []string{"A", "b"}
+	if !InSlice("A", sl) {
+		t.Error("should be true")
+	}
+	if InSlice("B", sl) {
+		t.Error("should be false")
+	}
+}