mirror of
https://github.com/octoleo/syncthing.git
synced 2024-11-19 03:25:16 +00:00
313 lines
9.1 KiB
Go
313 lines
9.1 KiB
Go
// Copyright (C) 2020 The Syncthing Authors.
|
|
//
|
|
// This Source Code Form is subject to the terms of the Mozilla Public
|
|
// License, v. 2.0. If a copy of the MPL was not distributed with this file,
|
|
// You can obtain one at https://mozilla.org/MPL/2.0/.
|
|
|
|
//+build ignore
|
|
|
|
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"path/filepath"
|
|
"strings"
|
|
"unicode"
|
|
|
|
"github.com/syncthing/syncthing/proto/ext"
|
|
|
|
"github.com/gogo/protobuf/gogoproto"
|
|
"github.com/gogo/protobuf/proto"
|
|
"github.com/gogo/protobuf/protoc-gen-gogo/descriptor"
|
|
"github.com/gogo/protobuf/vanity"
|
|
"github.com/gogo/protobuf/vanity/command"
|
|
)
|
|
|
|
func main() {
|
|
req := command.Read()
|
|
files := req.GetProtoFile()
|
|
files = vanity.FilterFiles(files, vanity.NotGoogleProtobufDescriptorProto)
|
|
|
|
vanity.ForEachFile(files, vanity.TurnOffGoGettersAll)
|
|
vanity.ForEachFile(files, TurnOnProtoSizerAll)
|
|
vanity.ForEachFile(files, vanity.TurnOffGoEnumPrefixAll)
|
|
vanity.ForEachFile(files, vanity.TurnOffGoUnrecognizedAll)
|
|
vanity.ForEachFile(files, vanity.TurnOffGoUnkeyedAll)
|
|
vanity.ForEachFile(files, vanity.TurnOffGoSizecacheAll)
|
|
vanity.ForEachFile(files, vanity.TurnOnMarshalerAll)
|
|
vanity.ForEachFile(files, vanity.TurnOnUnmarshalerAll)
|
|
vanity.ForEachEnumInFiles(files, HandleCustomEnumExtensions)
|
|
vanity.ForEachFile(files, SetPackagePrefix("github.com/syncthing/syncthing"))
|
|
vanity.ForEachFile(files, HandleFile)
|
|
vanity.ForEachFieldInFilesExcludingExtensions(files, TurnOffNullableForMessages)
|
|
|
|
resp := command.Generate(req)
|
|
command.Write(resp)
|
|
}
|
|
|
|
func TurnOnProtoSizerAll(file *descriptor.FileDescriptorProto) {
|
|
vanity.SetBoolFileOption(gogoproto.E_ProtosizerAll, true)(file)
|
|
}
|
|
|
|
func TurnOffNullableForMessages(field *descriptor.FieldDescriptorProto) {
|
|
if !vanity.FieldHasBoolExtension(field, gogoproto.E_Nullable) {
|
|
_, hasCustomType := GetFieldStringExtension(field, gogoproto.E_Customtype)
|
|
if field.IsMessage() || hasCustomType {
|
|
vanity.SetBoolFieldOption(gogoproto.E_Nullable, false)(field)
|
|
}
|
|
}
|
|
}
|
|
|
|
func HandleCustomEnumExtensions(enum *descriptor.EnumDescriptorProto) {
|
|
for _, field := range enum.Value {
|
|
if field == nil {
|
|
continue
|
|
}
|
|
if field.Options == nil {
|
|
field.Options = &descriptor.EnumValueOptions{}
|
|
}
|
|
customName := gogoproto.GetEnumValueCustomName(field)
|
|
if customName != "" {
|
|
continue
|
|
}
|
|
if v, ok := GetEnumValueStringExtension(field, ext.E_Enumgoname); ok {
|
|
SetEnumValueStringFieldOption(field, gogoproto.E_EnumvalueCustomname, v)
|
|
} else {
|
|
SetEnumValueStringFieldOption(field, gogoproto.E_EnumvalueCustomname, toCamelCase(*field.Name, true))
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
func SetPackagePrefix(prefix string) func(file *descriptor.FileDescriptorProto) {
|
|
return func(file *descriptor.FileDescriptorProto) {
|
|
if file.Options.GoPackage == nil {
|
|
pkg, _ := filepath.Split(file.GetName())
|
|
fullPkg := prefix + "/" + strings.TrimSuffix(pkg, "/")
|
|
file.Options.GoPackage = &fullPkg
|
|
}
|
|
}
|
|
}
|
|
|
|
func toCamelCase(input string, firstUpper bool) string {
|
|
runes := []rune(strings.ToLower(input))
|
|
outputRunes := make([]rune, 0, len(runes))
|
|
|
|
nextUpper := false
|
|
for i, rune := range runes {
|
|
if rune == '_' {
|
|
nextUpper = true
|
|
continue
|
|
}
|
|
if (firstUpper && i == 0) || nextUpper {
|
|
rune = unicode.ToUpper(rune)
|
|
nextUpper = false
|
|
}
|
|
outputRunes = append(outputRunes, rune)
|
|
}
|
|
return string(outputRunes)
|
|
}
|
|
|
|
func SetStringFieldOption(field *descriptor.FieldDescriptorProto, extension *proto.ExtensionDesc, value string) {
|
|
if _, ok := GetFieldStringExtension(field, extension); ok {
|
|
return
|
|
}
|
|
if field.Options == nil {
|
|
field.Options = &descriptor.FieldOptions{}
|
|
}
|
|
if err := proto.SetExtension(field.Options, extension, &value); err != nil {
|
|
panic(err)
|
|
}
|
|
}
|
|
|
|
func SetEnumValueStringFieldOption(field *descriptor.EnumValueDescriptorProto, extension *proto.ExtensionDesc, value string) {
|
|
if _, ok := GetEnumValueStringExtension(field, extension); ok {
|
|
return
|
|
}
|
|
if field.Options == nil {
|
|
field.Options = &descriptor.EnumValueOptions{}
|
|
}
|
|
if err := proto.SetExtension(field.Options, extension, &value); err != nil {
|
|
panic(err)
|
|
}
|
|
}
|
|
|
|
func GetEnumValueStringExtension(enumValue *descriptor.EnumValueDescriptorProto, extension *proto.ExtensionDesc) (string, bool) {
|
|
if enumValue.Options == nil {
|
|
return "", false
|
|
}
|
|
value, err := proto.GetExtension(enumValue.Options, extension)
|
|
if err != nil {
|
|
return "", false
|
|
}
|
|
if value == nil {
|
|
return "", false
|
|
}
|
|
if v, ok := value.(*string); !ok || v == nil {
|
|
return "", false
|
|
} else {
|
|
return *v, true
|
|
}
|
|
}
|
|
|
|
func GetFieldStringExtension(field *descriptor.FieldDescriptorProto, extension *proto.ExtensionDesc) (string, bool) {
|
|
if field.Options == nil {
|
|
return "", false
|
|
}
|
|
value, err := proto.GetExtension(field.Options, extension)
|
|
if err != nil {
|
|
return "", false
|
|
}
|
|
if value == nil {
|
|
return "", false
|
|
}
|
|
if v, ok := value.(*string); !ok || v == nil {
|
|
return "", false
|
|
} else {
|
|
return *v, true
|
|
}
|
|
}
|
|
|
|
func GetFieldBooleanExtension(field *descriptor.FieldDescriptorProto, extension *proto.ExtensionDesc) (bool, bool) {
|
|
if field.Options == nil {
|
|
return false, false
|
|
}
|
|
value, err := proto.GetExtension(field.Options, extension)
|
|
if err != nil {
|
|
return false, false
|
|
}
|
|
if value == nil {
|
|
return false, false
|
|
}
|
|
if v, ok := value.(*bool); !ok || v == nil {
|
|
return false, false
|
|
} else {
|
|
return *v, true
|
|
}
|
|
}
|
|
|
|
func GetMessageBoolExtension(msg *descriptor.DescriptorProto, extension *proto.ExtensionDesc) (bool, bool) {
|
|
if msg.Options == nil {
|
|
return false, false
|
|
}
|
|
value, err := proto.GetExtension(msg.Options, extension)
|
|
if err != nil {
|
|
return false, false
|
|
}
|
|
if value == nil {
|
|
return false, false
|
|
}
|
|
val, ok := value.(*bool)
|
|
if !ok || val == nil {
|
|
return false, false
|
|
}
|
|
return *val, true
|
|
}
|
|
|
|
func HandleFile(file *descriptor.FileDescriptorProto) {
|
|
vanity.ForEachMessageInFiles([]*descriptor.FileDescriptorProto{file}, HandleCustomExtensions(file))
|
|
}
|
|
|
|
func HandleCustomExtensions(file *descriptor.FileDescriptorProto) func(msg *descriptor.DescriptorProto) {
|
|
return func(msg *descriptor.DescriptorProto) {
|
|
generateXmlTags := true
|
|
if generate, ok := GetMessageBoolExtension(msg, ext.E_XmlTags); ok {
|
|
generateXmlTags = generate
|
|
}
|
|
|
|
vanity.ForEachField([]*descriptor.DescriptorProto{msg}, func(field *descriptor.FieldDescriptorProto) {
|
|
if field.Options == nil {
|
|
field.Options = &descriptor.FieldOptions{}
|
|
}
|
|
deprecated := field.Options.Deprecated != nil && *field.Options.Deprecated == true
|
|
|
|
if field.Type != nil && *field.Type == descriptor.FieldDescriptorProto_TYPE_INT32 {
|
|
SetStringFieldOption(field, gogoproto.E_Casttype, "int")
|
|
}
|
|
|
|
if field.TypeName != nil && *field.TypeName == ".google.protobuf.Timestamp" {
|
|
vanity.SetBoolFieldOption(gogoproto.E_Stdtime, true)(field)
|
|
}
|
|
|
|
if goName, ok := GetFieldStringExtension(field, ext.E_Goname); ok {
|
|
SetStringFieldOption(field, gogoproto.E_Customname, goName)
|
|
} else if deprecated {
|
|
SetStringFieldOption(field, gogoproto.E_Customname, "Deprecated"+toCamelCase(*field.Name, true))
|
|
}
|
|
|
|
if goType, ok := GetFieldStringExtension(field, ext.E_Gotype); ok {
|
|
SetStringFieldOption(field, gogoproto.E_Customtype, goType)
|
|
}
|
|
|
|
if val, ok := GetFieldBooleanExtension(field, ext.E_DeviceId); ok && val {
|
|
if *file.Options.GoPackage != "github.com/syncthing/syncthing/lib/protocol" {
|
|
SetStringFieldOption(field, gogoproto.E_Customtype, "github.com/syncthing/syncthing/lib/protocol.DeviceID")
|
|
} else {
|
|
SetStringFieldOption(field, gogoproto.E_Customtype, "DeviceID")
|
|
}
|
|
}
|
|
|
|
if jsonValue, ok := GetFieldStringExtension(field, ext.E_Json); ok {
|
|
SetStringFieldOption(field, gogoproto.E_Jsontag, jsonValue)
|
|
} else if deprecated {
|
|
SetStringFieldOption(field, gogoproto.E_Jsontag, "-")
|
|
} else {
|
|
SetStringFieldOption(field, gogoproto.E_Jsontag, toCamelCase(*field.Name, false))
|
|
}
|
|
|
|
current := ""
|
|
if v, ok := GetFieldStringExtension(field, gogoproto.E_Moretags); ok {
|
|
current = v
|
|
}
|
|
|
|
if generateXmlTags {
|
|
if len(current) > 0 {
|
|
current += " "
|
|
}
|
|
if xmlValue, ok := GetFieldStringExtension(field, ext.E_Xml); ok {
|
|
current += fmt.Sprintf(`xml:"%s"`, xmlValue)
|
|
} else {
|
|
xmlValue = toCamelCase(*field.Name, false)
|
|
// XML dictates element name within the collection, not collection name, so trim plural suffix.
|
|
if field.IsRepeated() {
|
|
if strings.HasSuffix(xmlValue, "ses") {
|
|
// addresses -> address
|
|
xmlValue = strings.TrimSuffix(xmlValue, "es")
|
|
} else {
|
|
// devices -> device
|
|
xmlValue = strings.TrimSuffix(xmlValue, "s")
|
|
}
|
|
}
|
|
if deprecated {
|
|
xmlValue += ",omitempty"
|
|
}
|
|
current += fmt.Sprintf(`xml:"%s"`, xmlValue)
|
|
}
|
|
}
|
|
|
|
if defaultValue, ok := GetFieldStringExtension(field, ext.E_Default); ok {
|
|
if len(current) > 0 {
|
|
current += " "
|
|
}
|
|
current += fmt.Sprintf(`default:"%s"`, defaultValue)
|
|
}
|
|
|
|
if nodefaultValue, ok := GetFieldBooleanExtension(field, ext.E_Nodefault); ok {
|
|
if len(current) > 0 {
|
|
current += " "
|
|
}
|
|
current += fmt.Sprintf(`nodefault:"%t"`, nodefaultValue)
|
|
}
|
|
|
|
if restartValue, ok := GetFieldBooleanExtension(field, ext.E_Restart); ok {
|
|
if len(current) > 0 {
|
|
current += " "
|
|
}
|
|
current += fmt.Sprintf(`restart:"%t"`, restartValue)
|
|
}
|
|
|
|
SetStringFieldOption(field, gogoproto.E_Moretags, current)
|
|
})
|
|
}
|
|
}
|