event.go

package main

import (
	"context"
	"fmt"
	"regexp"
	"strings"

	pb "codeup.aliyun.com/7799520/b/protoc-gen-go-event/pb/event/options"

	"github.com/ThreeDotsLabs/watermill"
	wamqp "github.com/ThreeDotsLabs/watermill-amqp/pkg/amqp"
	"github.com/ThreeDotsLabs/watermill/message"
	"github.com/streadway/amqp"
	"google.golang.org/protobuf/encoding/protojson"

	"github.com/go-kratos/kratos/v2"
	"google.golang.org/protobuf/compiler/protogen"
	"google.golang.org/protobuf/proto"
	"google.golang.org/protobuf/types/descriptorpb"
)

const (
	contextPackage   = protogen.GoImportPath("context")
	fmtPackage       = protogen.GoImportPath("fmt")
	amqpPackage      = protogen.GoImportPath("github.com/streadway/amqp")
	wamqpPakage      = protogen.GoImportPath("github.com/ThreeDotsLabs/watermill-amqp/pkg/amqp")
	messagePackage   = protogen.GoImportPath("github.com/ThreeDotsLabs/watermill/message")
	watermillPackage = protogen.GoImportPath("github.com/ThreeDotsLabs/watermill")
	protojsonPackage = protogen.GoImportPath("google.golang.org/protobuf/encoding/protojson")
)

var _ = new(context.Context)
var _ = new(amqp.Table)
var _ = new(wamqp.Config)
var _ = new(message.Message)
var _ = watermill.NewUUID
var _ = protojson.Marshal

var methodSets = make(map[string]int)

// generateFile generates a _event.pb.go file containing kratos errors definitions.
func generateFile(gen *protogen.Plugin, file *protogen.File, omitempty bool) *protogen.GeneratedFile {
	if len(file.Services) == 0 || (omitempty && !hasEventRule(file.Services)) {
		return nil
	}
	filename := file.GeneratedFilenamePrefix + "_event.pb.go"
	g := gen.NewGeneratedFile(filename, file.GoImportPath)
	g.P("// Code generated by protoc-gen-go-event. DO NOT EDIT.")
	g.P("// versions:")
	g.P(fmt.Sprintf("// protoc-gen-go-event %s", kratos.Release))
	g.P()
	g.P("package ", file.GoPackageName)
	g.P()
	generateFileContent(gen, file, g, omitempty)
	return g
}

// generateFileContent generates the kratos errors definitions, excluding the package statement.
func generateFileContent(gen *protogen.Plugin, file *protogen.File, g *protogen.GeneratedFile, omitempty bool) {

	if len(file.Services) == 0 {
		return
	}
	g.P("// This is a compile-time assertion to ensure that this generated file")
	g.P("// is compatible with the kratos package it is being compiled against.")
	g.P("var _ = new(", contextPackage.Ident("Context"), ")")
	g.P("var _ = new(", amqpPackage.Ident("Table"), ")")
	g.P("var _ = new(", wamqpPakage.Ident("Config"), ")")
	g.P("var _ = new(", messagePackage.Ident("Message"), ")")
	g.P("var _ = ", watermillPackage.Ident("NewUUID"))
	g.P("var _ = ", protojsonPackage.Ident("Marshal"))
	g.P()

	for _, service := range file.Services {
		genService(gen, file, g, service, omitempty)
	}
}

func genService(gen *protogen.Plugin, file *protogen.File, g *protogen.GeneratedFile, service *protogen.Service, omitempty bool) {
	if service.Desc.Options().(*descriptorpb.ServiceOptions).GetDeprecated() {
		g.P("//")
		g.P(deprecationComment)
	}

	sd := &serviceDesc{
		ServiceType: service.GoName,
		ServiceName: string(service.Desc.FullName()),
		Metadata:    file.Desc.Path(),
	}

	for _, method := range service.Methods {
		if method.Desc.IsStreamingClient() || method.Desc.IsStreamingServer() {
			continue
		}

		event, ok := proto.GetExtension(method.Desc.Options(), pb.E_Event).(*pb.Event)
		if !ok || event.GetName() == "" {
			continue
		}

		sd.Methods = append(sd.Methods, buildMethodDesc(g, method, event.GetName(), event.GetDelay()))
	}

	if len(sd.Methods) != 0 {
		g.P(sd.execute())
	}
}

func hasEventRule(services []*protogen.Service) bool {
	for _, service := range services {
		for _, method := range service.Methods {
			if method.Desc.IsStreamingClient() || method.Desc.IsStreamingServer() {
				continue
			}

			event, ok := proto.GetExtension(method.Desc.Options(), pb.E_Event).(*pb.Event)
			if event != nil && event.GetName() != "" && ok {
				return true
			}
		}
	}
	return false
}

func buildMethodDesc(g *protogen.GeneratedFile, m *protogen.Method, name string, delay int32) *methodDesc {
	defer func() { methodSets[m.GoName]++ }()

	return &methodDesc{
		Name:       m.GoName,
		Num:        methodSets[m.GoName],
		Request:    g.QualifiedGoIdent(m.Input.GoIdent),
		Reply:      g.QualifiedGoIdent(m.Output.GoIdent),
		EventName:  name,
		EventDelay: delay,
	}
}

func buildPathVars(path string) (res map[string]*string) {
	res = make(map[string]*string)
	pattern := regexp.MustCompile(`(?i){([a-z\.0-9_\s]*)=?([^{}]*)}`)
	matches := pattern.FindAllStringSubmatch(path, -1)
	for _, m := range matches {
		name := strings.TrimSpace(m[1])
		if len(name) > 1 && len(m[2]) > 0 {
			res[name] = &m[2]
		} else {
			res[name] = nil
		}
	}
	return
}

func replacePath(name string, value string, path string) string {
	pattern := regexp.MustCompile(fmt.Sprintf(`(?i){([\s]*%s[\s]*)=?([^{}]*)}`, name))
	idx := pattern.FindStringIndex(path)
	if len(idx) > 0 {
		path = fmt.Sprintf("%s{%s:%s}%s",
			path[:idx[0]], // The start of the match
			name,
			strings.ReplaceAll(value, "*", ".*"),
			path[idx[1]:],
		)
	}
	return path
}

func camelCaseVars(s string) string {
	vars := make([]string, 0)
	subs := strings.Split(s, ".")
	for _, sub := range subs {
		vars = append(vars, camelCase(sub))
	}
	return strings.Join(vars, ".")
}

// camelCase returns the CamelCased name.
// If there is an interior underscore followed by a lower case letter,
// drop the underscore and convert the letter to upper case.
// There is a remote possibility of this rewrite causing a name collision,
// but it's so remote we're prepared to pretend it's nonexistent - since the
// C++ generator lowercases names, it's extremely unlikely to have two fields
// with different capitalizations.
// In short, _my_field_name_2 becomes XMyFieldName_2.
func camelCase(s string) string {
	if s == "" {
		return ""
	}
	t := make([]byte, 0, 32)
	i := 0
	if s[0] == '_' {
		// Need a capital letter; drop the '_'.
		t = append(t, 'X')
		i++
	}
	// Invariant: if the next letter is lower case, it must be converted
	// to upper case.
	// That is, we process a word at a time, where words are marked by _ or
	// upper case letter. Digits are treated as words.
	for ; i < len(s); i++ {
		c := s[i]
		if c == '_' && i+1 < len(s) && isASCIILower(s[i+1]) {
			continue // Skip the underscore in s.
		}
		if isASCIIDigit(c) {
			t = append(t, c)
			continue
		}
		// Assume we have a letter now - if not, it's a bogus identifier.
		// The next word is a sequence of characters that must start upper case.
		if isASCIILower(c) {
			c ^= ' ' // Make it a capital letter.
		}
		t = append(t, c) // Guaranteed not lower case.
		// Accept lower case sequence that follows.
		for i+1 < len(s) && isASCIILower(s[i+1]) {
			i++
			t = append(t, s[i])
		}
	}
	return string(t)
}

// Is c an ASCII lower-case letter?
func isASCIILower(c byte) bool {
	return 'a' <= c && c <= 'z'
}

// Is c an ASCII digit?
func isASCIIDigit(c byte) bool {
	return '0' <= c && c <= '9'
}

const deprecationComment = "// Deprecated: Do not use."