Fix regexp support for type aliases

Fixes #90

Author: jameshartig

Diff for: builtins.go

@@ -27,7 +27,7 @@ import (
 // as defined by the golang spec.
 func nonzero(v interface{}, param string) error {
 	st := reflect.ValueOf(v)
-	valid := true
+	var valid bool
 	switch st.Kind() {
 	case reflect.String:
 		valid = utf8.RuneCountInString(st.String()) != 0
@@ -62,7 +62,7 @@ func nonzero(v interface{}, param string) error {
 // for maps and slices it tests the number of items.
 func length(v interface{}, param string) error {
 	st := reflect.ValueOf(v)
-	valid := true
+	var valid bool
 	if st.Kind() == reflect.Ptr {
 		if st.IsNil() {
 			return nil
@@ -218,18 +218,17 @@ func max(v interface{}, param string) error {
 // regex is the builtin validation function that checks
 // whether the string variable matches a regular expression
 func regex(v interface{}, param string) error {
-	s, ok := v.(string)
-	if !ok {
-		sptr, ok := v.(*string)
-		if !ok {
-			return ErrUnsupported
-		}
-		if sptr == nil {
+	rv := reflect.ValueOf(v)
+	if rv.Kind() == reflect.Ptr {
+		if rv.IsNil() {
 			return nil
 		}
-		s = *sptr
+		rv = rv.Elem()
 	}
-
+	if rv.Kind() != reflect.String {
+		return ErrUnsupported
+	}
+	s := rv.String()
 	re, err := regexp.Compile(param)
 	if err != nil {
 		return ErrBadParameter
@@ -241,7 +240,7 @@ func regex(v interface{}, param string) error {
 	return nil
 }
 
-// asInt retuns the parameter as a int64
+// asInt returns the parameter as a int64
 // or panics if it can't convert
 func asInt(param string) (int64, error) {
 	i, err := strconv.ParseInt(param, 0, 64)
@@ -251,7 +250,7 @@ func asInt(param string) (int64, error) {
 	return i, nil
 }
 
-// asUint retuns the parameter as a uint64
+// asUint returns the parameter as a uint64
 // or panics if it can't convert
 func asUint(param string) (uint64, error) {
 	i, err := strconv.ParseUint(param, 0, 64)
@@ -261,7 +260,7 @@ func asUint(param string) (uint64, error) {
 	return i, nil
 }
 
-// asFloat retuns the parameter as a float64
+// asFloat returns the parameter as a float64
 // or panics if it can't convert
 func asFloat(param string) (float64, error) {
 	i, err := strconv.ParseFloat(param, 64)

Diff for: validator.go

@@ -114,11 +114,11 @@ type ValidationFunc func(v interface{}, param string) error
 
 // Validator implements a validator
 type Validator struct {
-	// Tag name being used.
-	tagName string
 	// validationFuncs is a map of ValidationFuncs indexed
 	// by their name.
 	validationFuncs map[string]ValidationFunc
+	// Tag name being used.
+	tagName string
 	// printJSON set to true will make errors print with the
 	// name of their json field instead of their struct tag.
 	// If no json tag is present the name of the struct field is used.

Diff for: validator_test.go

@@ -576,7 +576,9 @@ func (ms *MySuite) TestPrivateFields(c *C) {
 		b string `validate:"min=1"`
 	}
 
-	err := validator.Validate(test{})
+	err := validator.Validate(test{
+		b: "",
+	})
 	c.Assert(err, IsNil)
 }
 
@@ -785,6 +787,40 @@ func (ms *MySuite) TestNonNilFunction(c *C) {
 	c.Assert(err, IsNil)
 }
 
+func (ms *MySuite) TestTypeAliases(c *C) {
+	type A string
+	type B int64
+	type test struct {
+		A1 A  `validate:"regexp=^[0-9]+$"`
+		A2 *A `validate:"regexp=^[0-9]+$"`
+		B1 B  `validate:"min=10"`
+		B2 B  `validate:"max=10"`
+	}
+	a123 := A("123")
+	err := validator.Validate(test{
+		A1: a123,
+		A2: &a123,
+		B1: B(11),
+		B2: B(9),
+	})
+	c.Assert(err, IsNil)
+
+	abc := A("abc")
+	err = validator.Validate(test{
+		A1: abc,
+		A2: &abc,
+		B2: B(11),
+	})
+	c.Assert(err, NotNil)
+	errs, ok := err.(validator.ErrorMap)
+	c.Assert(ok, Equals, true)
+	c.Assert(errs, HasLen, 4)
+	c.Assert(errs["A1"], HasError, validator.ErrRegexp)
+	c.Assert(errs["A2"], HasError, validator.ErrRegexp)
+	c.Assert(errs["B1"], HasError, validator.ErrMin)
+	c.Assert(errs["B2"], HasError, validator.ErrMax)
+}
+
 type hasErrorChecker struct {
 	*CheckerInfo
 }