checker

package
v1.0.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 26, 2022 License: MIT Imports: 13 Imported by: 0

Documentation

Index

Examples

Constants

This section is empty.

Variables

View Source 
var Description = "make a Struct.Validate() function"
View Source 
var Flags = []cli.Flag{

	cli.StringFlag{
		Name:  "type,t",
		Usage: "the `TYPE` to map field",
	},
	cli.StringFlag{
		Name:  "name,n",
		Usage: "the `FUNCTION` to generate, default is Validate",
	},
	cli.StringFlag{
		Name:  "tag,g",
		Usage: "tag name to define the checker rule, defualt is checker",
	},
	cli.StringSliceFlag{
		Name:  "import,i",
		Usage: "the requried imports",
	},
	cli.StringFlag{
		Name:  "output,o",
		Usage: "the `FILE` to output",
	},
}
View Source 
var Usage = "generate struct checker function"

Functions

func Action 

func Action(c *cli.Context) error

Types

type ArrayProc 

type ArrayProc struct {
	// contains filtered or unexported fields
}
Example 
typ := parser.ParseTypeString("[]int")
ck := &CheckerInfo{
	chk:        "mychecker",
	name:       "\"hello\"",
	expr:       "t.Hello",
	targetType: typ,
}
checker := &Checker{
	c: ck,
	p: &customPriter{},
}

// arrays:123
str := "arrays:1"
proc := NewArrayProc(strings.Split(str, ":"))
checker.procs = []CheckerProc{proc, NewDefaultValueProc(strings.Split("default:100", ":"))}
checker.Next()

typ = parser.ParseTypeString("[][]string")
ck = &CheckerInfo{
	chk:        "mychecker",
	name:       "\"hello\"",
	expr:       "t.Hello",
	targetType: typ,
}
checker = &Checker{
	c: ck,
	p: &customPriter{},
}

str = "arrays:2"
proc = NewArrayProc(strings.Split(str, ":"))
checker.procs = []CheckerProc{proc, NewDefaultValueProc(strings.Split("default:'null'", ":"))}

checker.Next()

Output:

for i, it := range t.Hello {
if it == 0 {
t.Hello[i] = 100
}
}
for i, it := range t.Hello {
for ii, itt := range it {
if itt == "" {
it[ii] = "null"
}
}
}

func (*ArrayProc) Print 

func (cp *ArrayProc) Print(cm *Checker)

type CallProc 

type CallProc struct {
	// contains filtered or unexported fields
}
Example 
ck := &CheckerInfo{
	chk:        "mychecker",
	name:       "\"hello\"",
	expr:       "t.Hello",
	targetType: parser.NewBasicType("int"),
}
checker := &Checker{
	c: ck,
	p: &customPriter{},
}

// call:some-function:error/bool:CustomType:MsgA:MsgB:....
str := "call:CheckIt:error:CustomError:hello:is:not:valid"
proc := NewCallProc(strings.Split(str, ":"))
checker.procs = []CheckerProc{proc}
checker.Next()

ck = &CheckerInfo{
	chk:        "mychecker",
	name:       "\"hello\"",
	expr:       "t.Hello",
	targetType: &parser.ArrayType{},
}
checker = &Checker{
	c: ck,
	p: &customPriter{},
}

// call:some-function
str = "call:CheckIt:false"
proc = NewCallProc(strings.Split(str, ":"))
checker.procs = []CheckerProc{proc}
checker.Next()

ck = &CheckerInfo{
	chk:        "mychecker",
	name:       "\"hello\"",
	expr:       "t.Hello",
	targetType: parser.NewBasicType("string"),
}
checker = &Checker{
	c: ck,
	p: &customPriter{},
}

// call:some-function:bool::MsgA:MsgB:....
str = "call:CheckIt:bool::not valid"
proc = NewCallProc(strings.Split(str, ":"))
checker.procs = []CheckerProc{proc}
checker.Next()

Output:

mychecker.AssertError(t.Hello.CheckIt(), "hello", CustomError, "hello", "is", "not", "valid")
mychecker.Assert(!t.Hello.CheckIt(), "hello", "Invalid")
mychecker.Assert(t.Hello.CheckIt(), "hello", "Invalid", "not valid")

func (*CallProc) Print 

func (cp *CallProc) Print(cm *Checker)

type Checker 

type Checker struct {
	// contains filtered or unexported fields
}

func NewChecker 

func NewChecker(c *CheckerInfo, p builder.Printer, tagSrc string) *Checker

func (*Checker) Next 

func (c *Checker) Next()

type CheckerInfo 

type CheckerInfo struct {
	// contains filtered or unexported fields
}

func (*CheckerInfo) Copy 

func (c *CheckerInfo) Copy() *CheckerInfo

type CheckerProc 

type CheckerProc interface {
	Print(cm *Checker)
}

func NewArrayProc added in v1.0.1 

func NewArrayProc(vs []string) CheckerProc

arrays:123

func NewCallProc added in v1.0.1 

func NewCallProc(vs []string) CheckerProc

call:some-function:error/bool/true/false:CustomType:MsgA:MsgB:....

func NewCompareProc added in v1.0.1 

func NewCompareProc(vs []string) CheckerProc

compare:!=><:value:CustomType:MsgA:MsgB...

func NewConvertProc added in v1.0.1 

func NewConvertProc(vs []string) CheckerProc

convert:convert-to-type:custom-new-name

func NewDefaultValueProc added in v1.0.1 

func NewDefaultValueProc(vs []string) CheckerProc

default:somevalue default:'stringvalue'

func NewIsValidProc added in v1.0.1 

func NewIsValidProc(vs []string) CheckerProc

isvalid:valid-function:CustomType:MsgA:MsgB....

func NewMergeProc added in v1.0.1 

func NewMergeProc(vs []string) CheckerProc

merge:other-valid-function

func NewNoEmptyProc added in v1.0.1 

func NewNoEmptyProc(vs []string) CheckerProc

noemtpy:emptyValue:CustomType:msgA:msgB:msgC...

func NewStarProc added in v1.0.1 

func NewStarProc(vs []string) CheckerProc

stars:123

type CompareProc 

type CompareProc struct {
	// contains filtered or unexported fields
}
Example 
ck := &CheckerInfo{
	chk:        "mychecker",
	name:       "\"hello\"",
	expr:       "t.Hello",
	targetType: parser.NewBasicType("int"),
}
checker := &Checker{
	c: ck,
	p: &customPriter{},
}

// compare:!=><:value:CustomType:MsgA:MsgB...
str := "compare:!=:'null':CustomError:hello:is:null"
proc := NewCompareProc(strings.Split(str, ":"))
checker.procs = []CheckerProc{proc}
checker.Next()

ck = &CheckerInfo{
	chk:        "mychecker",
	name:       "\"hello\"",
	expr:       "t.Hello",
	targetType: &parser.ArrayType{},
}
checker = &Checker{
	c: ck,
	p: &customPriter{},
}

// compare:!=><:value
str = "compare:>:0"
proc = NewCompareProc(strings.Split(str, ":"))
checker.procs = []CheckerProc{proc}
checker.Next()

ck = &CheckerInfo{
	chk:        "mychecker",
	name:       "\"hello\"",
	expr:       "t.Hello",
	targetType: parser.NewBasicType("string"),
}
checker = &Checker{
	c: ck,
	p: &customPriter{},
}

// compare:!=><:value::MsgA:MsgB...
str = "compare:<:100::too big"
proc = NewCompareProc(strings.Split(str, ":"))
checker.procs = []CheckerProc{proc}
checker.Next()

Output:

mychecker.Assert(t.Hello != "null", "hello", CustomError, "hello", "is", "null")
mychecker.Assert(t.Hello > 0, "hello", "Invalid")
mychecker.Assert(t.Hello < 100, "hello", "Invalid", "too big")

func (*CompareProc) Print 

func (cp *CompareProc) Print(cm *Checker)

type Config 

type Config struct {
	Type    string
	Name    string
	Output  string
	TagName string
	Imports map[string]string
}

type ConvertProc 

type ConvertProc struct {
	// contains filtered or unexported fields
}
Example 
ck := &CheckerInfo{
	chk:        "mychecker",
	name:       "\"hello\"",
	expr:       "t.Hello",
	targetType: parser.NewBasicType("int"),
}
checker := &Checker{
	c: ck,
	p: &customPriter{},
}

// convert:convert-to-type:custom-new-name
str := "convert:int64:big"
proc := NewConvertProc(strings.Split(str, ":"))
checker.procs = []CheckerProc{proc}
checker.Next()

Output:

big := int64(t.Hello)

func (*ConvertProc) Print 

func (cp *ConvertProc) Print(cm *Checker)

type DefaultValueProc 

type DefaultValueProc struct {
	// contains filtered or unexported fields
}
Example 
ck := &CheckerInfo{
	chk:        "mychecker",
	name:       "\"hello\"",
	expr:       "t.Hello",
	targetType: parser.NewBasicType("int"),
}
checker := &Checker{
	c: ck,
	p: &customPriter{},
}

// default:value
str := "default:100"
proc := NewDefaultValueProc(strings.Split(str, ":"))
checker.procs = []CheckerProc{proc}
checker.Next()

ck = &CheckerInfo{
	chk:        "mychecker",
	name:       "\"hello\"",
	expr:       "t.Hello",
	targetType: parser.NewBasicType("string"),
}
checker = &Checker{
	c: ck,
	p: &customPriter{},
}

str = "default:'world'"
proc = NewDefaultValueProc(strings.Split(str, ":"))
checker.procs = []CheckerProc{proc}
checker.Next()

Output:

if t.Hello == 0 {
t.Hello = 100
}
if t.Hello == "" {
t.Hello = "world"
}

func (*DefaultValueProc) Print 

func (cp *DefaultValueProc) Print(cm *Checker)

type Generator 

type Generator struct {
	generator.Generator
}

func NewGenerator 

func NewGenerator() *Generator

func (*Generator) Generate 

func (g *Generator) Generate(c *Config) error

func (*Generator) Run 

func (g *Generator) Run(c *Config)

type IsValidProc 

type IsValidProc struct {
	// contains filtered or unexported fields
}
Example 
ck := &CheckerInfo{
	chk:        "mychecker",
	name:       "\"hello\"",
	expr:       "t.Hello",
	targetType: parser.NewBasicType("int"),
}
checker := &Checker{
	c: ck,
	p: &customPriter{},
}

// isvalid:valid-function:CustomType:MsgA:MsgB....
str := "isvalid:CheckValid:CustomError:hello:is:not:valid"
proc := NewIsValidProc(strings.Split(str, ":"))
checker.procs = []CheckerProc{proc}
checker.Next()

ck = &CheckerInfo{
	chk:        "mychecker",
	name:       "\"hello\"",
	expr:       "t.Hello",
	targetType: &parser.ArrayType{},
}
checker = &Checker{
	c: ck,
	p: &customPriter{},
}

// isvalid:valid-function
str = "isvalid:CheckValid"
proc = NewIsValidProc(strings.Split(str, ":"))
checker.procs = []CheckerProc{proc}
checker.Next()

ck = &CheckerInfo{
	chk:        "mychecker",
	name:       "\"hello\"",
	expr:       "t.Hello",
	targetType: parser.NewBasicType("string"),
}
checker = &Checker{
	c: ck,
	p: &customPriter{},
}
// isvalid:valid-function::MsgA:MsgB....
str = "isvalid:CheckValid::not valid"
proc = NewIsValidProc(strings.Split(str, ":"))
checker.procs = []CheckerProc{proc}
checker.Next()

Output:

mychecker.Assert(CheckValid(t.Hello), "hello", CustomError, "hello", "is", "not", "valid")
mychecker.Assert(CheckValid(t.Hello), "hello", "Invalid")
mychecker.Assert(CheckValid(t.Hello), "hello", "Invalid", "not valid")

func (*IsValidProc) Print 

func (cp *IsValidProc) Print(cm *Checker)

type MergeProc 

type MergeProc struct {
	// contains filtered or unexported fields
}
Example 
ck := &CheckerInfo{
	chk:        "mychecker",
	name:       "\"hello\"",
	expr:       "t.Hello",
	targetType: parser.NewBasicType("int"),
}
checker := &Checker{
	c: ck,
	p: &customPriter{},
}

// merge:other-valid-function
str := "merge:OtherCheck"
proc := NewMergeProc(strings.Split(str, ":"))
checker.procs = []CheckerProc{proc}
checker.Next()

Output:

if err := t.Hello.OtherCheck(); err != nil {
mychecker.Merge(err)
}

func (*MergeProc) Print 

func (cp *MergeProc) Print(cm *Checker)

type NoEmptyProc 

type NoEmptyProc struct {
	// contains filtered or unexported fields
}
Example 
ck := &CheckerInfo{
	chk:        "mychecker",
	name:       "\"hello\"",
	expr:       "t.Hello",
	targetType: parser.NewBasicType("int"),
}
checker := &Checker{
	c: ck,
	p: &customPriter{},
}
// noemtpy:emptyValue:CustomType:msgA:msgB:msgC...
str := "noemtpy:0:CustomError:hello:is:empty"
proc := NewNoEmptyProc(strings.Split(str, ":"))
checker.procs = []CheckerProc{proc}
checker.Next()

ck = &CheckerInfo{
	chk:        "mychecker",
	name:       "\"hello\"",
	expr:       "t.Hello",
	targetType: &parser.ArrayType{},
}
checker = &Checker{
	c: ck,
	p: &customPriter{},
}
// noemtpy:emptyValue::msgA:msgB:msgC...
str = "noemtpy:0::hello:"
proc = NewNoEmptyProc(strings.Split(str, ":"))
checker.procs = []CheckerProc{proc}
checker.Next()

ck = &CheckerInfo{
	chk:        "mychecker",
	name:       "\"hello\"",
	expr:       "t.Hello",
	targetType: parser.NewBasicType("string"),
}
checker = &Checker{
	c: ck,
	p: &customPriter{},
}
// noemtpy:emptyValue::msgA:msgB:msgC...
str = "noemtpy:'null'"
proc = NewNoEmptyProc(strings.Split(str, ":"))
checker.procs = []CheckerProc{proc}
checker.Next()

Output:

mychecker.Assert(t.Hello != 0, "hello", CustomError, "hello", "is", "empty")
mychecker.Assert(len(t.Hello) != 0, "hello", "IsEmpty", "hello")
mychecker.Assert(t.Hello != "null", "hello", "IsEmpty")

func (*NoEmptyProc) Print 

func (proc *NoEmptyProc) Print(cm *Checker)

type StarProc 

type StarProc struct {
	// contains filtered or unexported fields
}
Example 
ck := &CheckerInfo{
	chk:        "mychecker",
	name:       "\"hello\"",
	expr:       "t.Hello",
	targetType: parser.NewBasicType("int"),
}
checker := &Checker{
	c: ck,
	p: &customPriter{},
}

// stars:123
str := "stars:1"
proc := NewStarProc(strings.Split(str, ":"))
checker.procs = []CheckerProc{proc}
checker.Next()

ck = &CheckerInfo{
	chk:        "mychecker",
	name:       "\"hello\"",
	expr:       "t.Hello",
	targetType: parser.NewBasicType("int"),
}
checker = &Checker{
	c: ck,
	p: &customPriter{},
}

str = "stars:2"
proc = NewStarProc(strings.Split(str, ":"))
checker.procs = []CheckerProc{proc, NewDefaultValueProc(strings.Split("default:20", ":"))}
checker.Next()

Output:

if t.Hello != nil {
}
if t.Hello != nil && *t.Hello != nil {
if **t.Hello == 0 {
**t.Hello = 20
}
}

func (*StarProc) Print 

func (cp *StarProc) Print(cm *Checker)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.