// Package main ... package main import ( "fmt" "os" "path/filepath" "regexp" "strings" "github.com/go-rod/rod/lib/utils" ) func main() { comment := `// This file is generated by "./lib/proto/generate"` schema := getSchema() cleanup() init := comment + utils.S(` package proto import ( "reflect" "github.com/ysmood/gson" ) // Version of cdp protocol const Version = "v{{.major}}.{{.minor}}" var types = map[string]reflect.Type{ `, "major", schema.Get("version.major").Str(), "minor", schema.Get("version.minor").Str()) testsCode := comment + ` package proto_test import ( "github.com/go-rod/rod/lib/proto" ) ` for _, domain := range parse(schema) { code := comment + ` package proto import ( "github.com/ysmood/gson" ) ` code += fmt.Sprintf("/*\n\n%s\n\n", domain.name) if domain.description != "" { code += domain.description + "\n\n" } code += "*/\n\n" for _, definition := range domain.definitions { if definition.skip { continue } code += definition.format() testsCode += definition.formatTests() if definition.originName != "" { init += utils.S(` "{{.name}}": reflect.TypeOf({{.type}}{}),`, "name", definition.domain.name+"."+definition.originName, "type", definition.name, ) } } utils.E(utils.OutputFile( filepath.FromSlash( fmt.Sprintf("lib/proto/%s.go", toSnakeCase(domain.name))), code)) } init += ` } ` utils.E(utils.OutputFile(filepath.FromSlash("lib/proto/definitions.go"), init)) utils.E(utils.OutputFile(filepath.FromSlash("lib/proto/definitions_test.go"), testsCode)) path := "./lib/proto" utils.Exec("gofumpt -w", path) utils.Exec("go run golang.org/x/tools/cmd/goimports@latest -w", path) utils.Exec( "go run github.com/ysmood/golangci-lint@latest -- run --fix", path, ) } func (d *definition) comment() string { comment := d.description if comment == "" { comment = "..." } if d.optional { comment = "(optional) " + comment } if d.experimental { comment = "(experimental) " + comment } if d.deprecated { comment = "(deprecated) " + comment } name := symbol(d.name) if !strings.HasPrefix(strings.TrimSpace(comment), name) { comment = name + " " + comment } return regexp.MustCompile(`(?m)^`).ReplaceAllString(comment, "// ") } func (d *definition) format() (code string) { switch d.objType { case objTypePrimitive: code = utils.S(` {{.comment}} type {{.name}} {{.type}} `, "name", d.name, "type", d.typeName, "comment", d.comment()) if d.enum != nil { code += "const (" for _, value := range d.enum { name := d.name + symbol(value) code += utils.S(` // {{.name}} enum const {{.name}} {{.type}} = "{{.value}}" `, "name", name, "type", d.name, "value", value) } code += ")\n" } case objTypeStruct: code = utils.S(` {{.comment}} type {{.name}} struct { `, "name", d.name, "comment", d.comment()) for _, prop := range d.props { tag := jsonTag(prop.originName, prop.optional) t := prop.typeName if prop.optional { switch prop.typeName { case "float64", "int": if !strings.Contains(prop.comment(), "(default: 0)") { t = "*" + t } } } code += utils.S(` {{.comment}} {{.name}} {{.type}} {{.tag}} `, "comment", prop.comment(), "name", prop.name, "type", t, "tag", tag) } code += "}\n" if d.command { method := d.domain.name + "." + d.originName if d.returnValue { code += utils.S(` // ProtoReq name func (m {{.name}}) ProtoReq() string { return "{{.method}}" } // Call the request func (m {{.name}}) Call(c Client) (*{{.name}}Result, error) { var res {{.name}}Result return &res, call(m.ProtoReq(), m, &res, c) } `, "name", d.name, "method", method) } else { code += utils.S(` // ProtoReq name func (m {{.name}}) ProtoReq() string { return "{{.method}}" } // Call sends the request func (m {{.name}}) Call(c Client) error { return call(m.ProtoReq(), m, nil, c) } `, "name", d.name, "method", method) } } if d.cdpType == cdpTypeEvents { code += utils.S(` // ProtoEvent name func (evt {{.name}}) ProtoEvent() string { return "{{.event}}" } `, "name", d.name, "event", d.domain.name+"."+d.originName) } } return } func (d *definition) formatTests() (code string) { switch d.cdpType { case cdpTypeCommands: if !d.command { return "" } if d.returnValue { return utils.S(` func (t T) {{.name}}() { c := &Client{} _, err := proto.{{.name}}{}.Call(c) t.Nil(err) } `, "name", d.name) } return utils.S(` func (t T) {{.name}}() { c := &Client{} err := proto.{{.name}}{}.Call(c) t.Nil(err) } `, "name", d.name) case cdpTypeEvents: return utils.S(` func (t T) {{.name}}() { e := proto.{{.name}}{} t.Regex("", e.ProtoEvent()) } `, "name", d.name) } return "" } // The "a_" prefixed files won't removed, other go files will be removed before the generation. func cleanup() { d := filepath.Join("lib", "proto") list, err := os.ReadDir(d) utils.E(err) for _, f := range list { if !f.IsDir() && !strings.HasPrefix(f.Name(), "a_") && strings.HasSuffix(f.Name(), ".go") { utils.E(os.Remove(filepath.Join(d, f.Name()))) } } }