validating

package main

import (
	"fmt"
	"time"

	v "github.com/RussellLuo/validating/v2"
)

func validate(field v.Field) v.Errors {
	switch t := field.ValuePtr.(type) {
	case *map[string]time.Time:
		if *t == nil {
			return v.NewErrors(field.Name, v.ErrInvalid, "is empty")
		}
		return nil
	default:
		return v.NewErrors(field.Name, v.ErrUnsupported, "is unsupported")
	}
}

type MyValidator struct{}

func (mv *MyValidator) Validate(field v.Field) v.Errors {
	return validate(field)
}

func main() {
	var value map[string]time.Time

	// do validation by funcValidator
	funcValidator := v.Func(validate)
	errs := v.Validate(v.Schema{
		v.F("value", &value): funcValidator,
	})
	fmt.Printf("errs from funcValidator: %+v\n", errs)

	// do validation by structValidator
	structValidator := &MyValidator{}
	errs = v.Validate(v.Schema{
		v.F("value", &value): structValidator,
	})
	fmt.Printf("errs from structValidator: %+v\n", errs)

}

Output:

errs from funcValidator: value: INVALID(is empty)
errs from structValidator: value: INVALID(is empty)

package main

import (
	"fmt"

	v "github.com/RussellLuo/validating/v2"
)

type Address struct {
	Country, Province, City string
}

type Person struct {
	Name    string
	Age     int
	Address Address
}

func main() {
	p := Person{}
	err := v.Validate(v.Schema{
		v.F("name", &p.Name): v.Len(1, 5),
		v.F("age", &p.Age):   v.Gte(10),
		v.F("address", &p.Address): v.Schema{
			v.F("country", &p.Address.Country):  v.Nonzero(),
			v.F("province", &p.Address.Country): v.Nonzero(),
			v.F("city", &p.Address.City):        v.Nonzero(),
		},
	})
	fmt.Printf("err: %+v\n", err)
}

package main

import (
	"fmt"

	v "github.com/RussellLuo/validating/v2"
)

type Member struct {
	Name string
}

type Person1 struct {
	Name   string
	Age    int
	Family map[string]*Member
}

func makeSchema1(p *Person1) v.Schema {
	return v.Schema{
		v.F("name", &p.Name): v.Len(1, 5),
		v.F("age", &p.Age):   v.Nonzero(),
		v.F("family", &p.Family): v.ZeroOr(
			v.Map(func() map[string]v.Schema {
				schemas := make(map[string]v.Schema)
				for relation, member := range p.Family {
					schemas[relation] = v.Schema{
						v.F("name", &member.Name): v.Len(10, 15).Msg("is too long"),
					}
				}
				return schemas
			}),
		),
	}
}

func main() {
	p1 := Person1{}
	err := v.Validate(makeSchema1(&p1))
	fmt.Printf("err of p1: %+v\n", err)

	p2 := Person1{Family: map[string]*Member{
		"father": {"father's name"},
		"mother": {"mother's name is long"},
	}}
	err = v.Validate(makeSchema1(&p2))
	fmt.Printf("err of p2: %+v\n", err)
}

package main

import (
	"fmt"

	v "github.com/RussellLuo/validating/v2"
)

type Address2 struct {
	Country, Province, City string
}

type Person2 struct {
	Name    string
	Age     int
	Address *Address2
}

func makeSchema2(p *Person2) v.Schema {
	return v.Schema{
		v.F("name", &p.Name): v.Len(1, 5),
		v.F("age", &p.Age):   v.Lte(50),
		v.F("address", &p.Address): v.All(
			v.Assert(p.Address != nil).Msg("is nil"),
			v.Lazy(func() v.Validator {
				return v.Schema{
					v.F("country", &p.Address.Country):  v.Nonzero(),
					v.F("province", &p.Address.Country): v.Nonzero(),
					v.F("city", &p.Address.City):        v.Nonzero(),
				}
			}),
		),
	}
}

func main() {
	p1 := Person2{}
	err := v.Validate(makeSchema2(&p1))
	fmt.Printf("err of p1: %+v\n", err)

	p2 := Person2{Age: 60, Address: &Address2{}}
	err = v.Validate(makeSchema2(&p2))
	fmt.Printf("err of p2: %+v\n", err)
}

package main

import (
	"fmt"

	v "github.com/RussellLuo/validating/v2"
)

type Address3 struct {
	Country, Province, City string
}

func (a *Address3) Schema() v.Schema {
	return v.Schema{
		v.F("country", &a.Country):  v.Nonzero(),
		v.F("province", &a.Country): v.Nonzero(),
		v.F("city", &a.City):        v.Nonzero(),
	}
}

type Person3 struct {
	Name    string
	Age     int
	Address Address3
}

func (p *Person3) Schema() v.Schema {
	return v.Schema{
		v.F("name", &p.Name):       v.Len(1, 5),
		v.F("age", &p.Age):         v.Gte(10),
		v.F("address", &p.Address): p.Address.Schema(),
	}
}

func main() {
	p := Person3{}
	err := v.Validate(p.Schema())
	fmt.Printf("err: %+v\n", err)
}

package main

import (
	"fmt"

	v "github.com/RussellLuo/validating/v2"
)

type Phone struct {
	Number, Remark string
}

type Person4 struct {
	Name   string
	Age    int
	Phones []*Phone
}

func makeSchema4(p *Person4) v.Schema {
	return v.Schema{
		v.F("name", &p.Name): v.Len(1, 5),
		v.F("age", &p.Age):   v.Nonzero(),
		v.F("phones", &p.Phones): v.ZeroOr(
			v.Slice(func() (schemas []v.Schema) {
				for _, phone := range p.Phones {
					schemas = append(schemas, v.Schema{
						v.F("number", &phone.Number): v.Nonzero(),
						v.F("remark", &phone.Remark): v.Len(5, 7),
					})
				}
				return
			}),
		),
	}
}

func main() {
	p1 := Person4{}
	err := v.Validate(makeSchema4(&p1))
	fmt.Printf("err of p1: %+v\n", err)

	p2 := Person4{Phones: []*Phone{
		{"13011112222", "private"},
		{"13033334444", "business"},
	}}
	err = v.Validate(makeSchema4(&p2))
	fmt.Printf("err of p2: %+v\n", err)
}

package main

import (
	"fmt"

	v "github.com/RussellLuo/validating/v2"
)

func main() {
	ages := map[string]int{
		"foo": 0,
		"bar": 1,
	}
	err := v.Validate(v.Map(func() map[string]v.Schema {
		schemas := make(map[string]v.Schema)
		for name, age := range ages {
			age := age
			schemas[name] = v.Value(&age, v.Nonzero())
		}
		return schemas
	}))
	fmt.Printf("%+v\n", err)

}

Output:

[foo]: INVALID(is zero valued)

package main

import (
	"fmt"

	v "github.com/RussellLuo/validating/v2"
)

func main() {
	names := []string{"", "foo"}
	err := v.Validate(v.Slice(func() (schemas []v.Schema) {
		for _, name := range names {
			name := name
			schemas = append(schemas, v.Value(&name, v.Nonzero()))
		}
		return schemas
	}))
	fmt.Printf("%+v\n", err)

}

Output:

[0]: INVALID(is zero valued)

package main

import (
	"fmt"

	v "github.com/RussellLuo/validating/v2"
)

type Person5 struct {
	Name string
	Age  int
}

func main() {
	p := Person5{Age: 1}
	err := v.Validate(v.Schema{
		v.F("name", &p.Name): v.Len(1, 5).Msg("length is not between 1 and 5"),
		v.F("age", &p.Age):   v.Nonzero(),
	})
	fmt.Printf("%+v\n", err)

}

Output:

name: INVALID(length is not between 1 and 5)

package main

import (
	"fmt"

	v "github.com/RussellLuo/validating/v2"
)

func main() {
	value := 0
	err := v.Validate(v.Value(&value, v.Range(1, 5)))
	fmt.Printf("%+v\n", err)

}

Output:

INVALID(is not between given range)