fix: resolve pointer on tagged field (#47)

* resolve pointer on tagged field

address.go

@@ -41,11 +41,8 @@ func (i Address) Latitude(v reflect.Value) (interface{}, error) {
 	kind := v.Kind()
 	val := i.latitute()
 	if kind == reflect.Float32 {
-		v.Set(reflect.ValueOf(val))
 		return float32(val), nil
 	}
-	v.Set(reflect.ValueOf(float64(val)))
-
 	return float64(val), nil
 }
 
@@ -58,9 +55,7 @@ func (i Address) Longitude(v reflect.Value) (interface{}, error) {
 	kind := v.Kind()
 	val := i.longitude()
 	if kind == reflect.Float32 {
-		v.Set(reflect.ValueOf(val))
 		return float32(val), nil
 	}
-	v.Set(reflect.ValueOf(float64(val)))
 	return float64(val), nil
 }

datetime.go

@@ -655,7 +655,7 @@ func (d DateTime) UnixTime(v reflect.Value) (interface{}, error) {
 	} else {
 		val = 0
 	}
-	v.SetInt(val)
+
 	return val, nil
 }
 

datetime_test.go

@@ -2,7 +2,6 @@ package faker
 
 import (
 	"fmt"
-	"log"
 	"reflect"
 	"testing"
 	"time"
@@ -27,19 +26,6 @@ func TestUnixTimeValueValid(t *testing.T) {
 		t.Error("UnixTime should return time <= now")
 	}
 }
-func TestUnixTimeValueNotValid(t *testing.T) {
-	d := GetDateTimer()
-	var ref = struct {
-		some int
-	}{
-		some: 1212,
-	}
-	d.UnixTime(reflect.ValueOf(&ref.some).Elem())
-	log.Println(ref.some)
-	if ref.some != 0 {
-		t.Errorf("UnixTime should return 0, get : %v", ref.some)
-	}
-}
 
 func TestDate(t *testing.T) {
 	d := GetDateTimer()

faker.go

@@ -64,6 +64,50 @@ const (
 	SKIP               = "-"
 )
 
+var defaultTag = map[string]string{
+	Email:              Email,
+	MacAddress:         MacAddress,
+	DomainName:         DomainName,
+	URL:                URL,
+	UserName:           UserName,
+	IPV4:               IPV4,
+	IPV6:               IPV6,
+	PASSWORD:           PASSWORD,
+	CreditCardType:     CreditCardType,
+	CreditCardNumber:   CreditCardNumber,
+	LATITUDE:           LATITUDE,
+	LONGITUDE:          LONGITUDE,
+	PhoneNumber:        PhoneNumber,
+	TollFreeNumber:     TollFreeNumber,
+	E164PhoneNumber:    E164PhoneNumber,
+	TitleMale:          TitleMale,
+	TitleFemale:        TitleFemale,
+	FirstName:          FirstName,
+	FirstNameMale:      FirstNameMale,
+	FirstNameFemale:    FirstNameFemale,
+	LastName:           LastName,
+	NAME:               NAME,
+	UnixTime:           UnixTime,
+	DATE:               DATE,
+	TIME:               Time,
+	MonthName:          MonthName,
+	YEAR:               Year,
+	DayOfWeek:          DayOfWeek,
+	DayOfMonthTag:      DayOfMonth,
+	TIMESTAMP:          TIMESTAMP,
+	CENTURY:            CENTURY,
+	TIMEZONE:           TIMEZONE,
+	TimePeriodTag:      TimePeriod,
+	WORD:               WORD,
+	SENTENCE:           SENTENCE,
+	PARAGRAPH:          PARAGRAPH,
+	Currency:           Currency,
+	Amount:             Amount,
+	AmountWithCurrency: AmountWithCurrency,
+	ID:                 ID,
+	HyphenatedID:       HyphenatedID,
+}
+
 // TaggedFunction ...
 type TaggedFunction func(v reflect.Value) (interface{}, error)
 
@@ -291,8 +335,32 @@ func setDataWithTag(v reflect.Value, tag string) error {
 		return errors.New(ErrValueNotPtr)
 	}
 
+	if _, exist := mapperTag[tag]; !exist {
+		return errors.New(ErrTagNotSupported)
+	}
+
 	v = reflect.Indirect(v)
 	switch v.Kind() {
+	case reflect.Ptr:
+		if _, def := defaultTag[tag]; !def {
+			res, err := mapperTag[tag](v)
+			if err != nil {
+				return err
+			}
+			v.Set(reflect.ValueOf(res))
+			return nil
+		}
+
+		t := v.Type()
+		newv := reflect.New(t.Elem())
+		res, err := mapperTag[tag](newv.Elem())
+		if err != nil {
+			return err
+		}
+		rval := reflect.ValueOf(res)
+		newv.Elem().Set(rval)
+		v.Set(newv)
+		return nil
 	case reflect.Float32, reflect.Float64:
 		return userDefinedFloat(v, tag)
 	case reflect.String:
@@ -301,15 +369,11 @@ func setDataWithTag(v reflect.Value, tag string) error {
 	case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int8, reflect.Int16:
 		return userDefinedInt(v, tag)
 	default:
-		if _, exist := mapperTag[tag]; !exist {
-			return errors.New(ErrTagNotSupported)
-		}
 		res, err := mapperTag[tag](v)
 		if err != nil {
 			return err
 		}
 		v.Set(reflect.ValueOf(res))
-
 	}
 	return nil
 }

faker_test.go

@@ -547,3 +547,47 @@ func TestTagAlreadyExists(t *testing.T) {
 		t.Error("Expected ErrTagAlreadyExists Error,  But Got: ", err)
 	}
 }
+
+func TestTagWithPointer(t *testing.T) {
+
+	type TestStruct struct {
+		FirstName  *string  `json:"first_name,omitempty" faker:"first_name_male"`
+		Email      *string  `json:"email,omitempty" faker:"email"`
+		Latitude   *float64 `faker:"lat"`
+		Latitude32 *float32 `faker:"lat"`
+		UnixTime   *int64   `faker:"unix_time"`
+		School     *School  `faker:"school"`
+	}
+	// With custom provider
+	AddProvider("school", func(v reflect.Value) (interface{}, error) {
+		return &School{Location: "Jakarta"}, nil
+	})
+
+	var sample TestStruct
+	err := FakeData(&sample)
+	if err != nil {
+		t.Error("Expected Not Error, But Got: ", err)
+	}
+
+	//Assert
+	if sample.FirstName == nil || *sample.FirstName == "" {
+		t.Error("Expected filled but got emtpy")
+	}
+	if sample.Email == nil || *sample.Email == "" {
+		t.Error("Expected filled but got emtpy")
+	}
+	if sample.Latitude == nil || *sample.Latitude == 0 {
+		t.Error("Expected filled but got emtpy")
+	}
+	if sample.Latitude32 == nil || *sample.Latitude32 == 0 {
+		t.Error("Expected filled but got emtpy")
+	}
+
+	if sample.UnixTime == nil || *sample.UnixTime == 0 {
+		t.Error("Expected filled but got emtpy")
+	}
+
+	if sample.School == nil || sample.School.Location == "" {
+		t.Error("Expected filled but got emtpy")
+	}
+}