func fillTreeWithFile(tree *tree, file *descriptor.FileDescriptorProto) { key := fmt.Sprintf(".%s", file.GetPackage()) locs := make(map[string]*descriptor.SourceCodeInfo_Location) for _, loc := range file.GetSourceCodeInfo().GetLocation() { if loc.LeadingComments == nil { continue } var p []string for _, n := range loc.Path { p = append(p, strconv.Itoa(int(n))) } locs[strings.Join(p, ",")] = loc } // Messages for idx, proto := range file.GetMessageType() { fillTreeWithMessage(tree, key, proto, fmt.Sprintf("4,%d", idx), locs) } // Enums for idx, proto := range file.GetEnumType() { fillTreeWithEnum(tree, key, proto, fmt.Sprintf("5,%d", idx), locs) } // Services for idx, proto := range file.GetService() { fillTreeWithService(tree, key, proto, fmt.Sprintf("6,%d", idx), locs) } }
func convertFile(file *descriptor.FileDescriptorProto) ([]*plugin.CodeGeneratorResponse_File, error) { name := path.Base(file.GetName()) pkg, ok := globalPkg.relativelyLookupPackage(file.GetPackage()) if !ok { return nil, fmt.Errorf("no such package found: %s", file.GetPackage()) } response := []*plugin.CodeGeneratorResponse_File{} for _, msg := range file.GetMessageType() { options := msg.GetOptions() if options == nil { continue } if !proto.HasExtension(options, E_TableName) { continue } optionValue, err := proto.GetExtension(options, E_TableName) if err != nil { return nil, err } tableName := *optionValue.(*string) if len(tableName) == 0 { return nil, fmt.Errorf("table name of %s cannot be empty", msg.GetName()) } glog.V(2).Info("Generating schema for a message type ", msg.GetName()) schema, err := convertMessageType(pkg, msg) if err != nil { glog.Errorf("Failed to convert %s: %v", name, err) return nil, err } jsonSchema, err := json.Marshal(schema) if err != nil { glog.Error("Failed to encode schema", err) return nil, err } resFile := &plugin.CodeGeneratorResponse_File{ Name: proto.String(fmt.Sprintf("%s/%s.schema", strings.Replace(file.GetPackage(), ".", "/", -1), tableName)), Content: proto.String(string(jsonSchema)), } response = append(response, resFile) } return response, nil }
// loadFile loads messages and fiels from "file". // It does not loads services and methods in "file". You need to call // loadServices after loadFiles is called for all files to load services and methods. func (r *Registry) loadFile(file *descriptor.FileDescriptorProto) { pkg := GoPackage{ Path: r.goPackagePath(file), Name: defaultGoPackageName(file), } if err := r.ReserveGoPackageAlias(pkg.Name, pkg.Path); err != nil { for i := 0; ; i++ { alias := fmt.Sprintf("%s_%d", pkg.Name, i) if err := r.ReserveGoPackageAlias(alias, pkg.Path); err == nil { pkg.Alias = alias break } } } f := &File{ FileDescriptorProto: file, GoPkg: pkg, } r.files[file.GetName()] = f r.registerMsg(f, nil, file.GetMessageType()) }
// loadFile loads messages and fiels from "file". // It does not loads services and methods in "file". You need to call // loadServices after loadFiles is called for all files to load services and methods. func (r *Registry) loadFile(file *descriptor.FileDescriptorProto) { pkg := GoPackage{ Path: r.goPackagePath(file), Name: defaultGoPackageName(file), } if err := r.ReserveGoPackageAlias(pkg.Name, pkg.Path); err != nil { for i := 0; ; i++ { alias := fmt.Sprintf("%s_%d", pkg.Name, i) if err := r.ReserveGoPackageAlias(alias, pkg.Path); err == nil { pkg.Alias = alias break } } } comments := make(map[string]*descriptor.SourceCodeInfo_Location) for _, loc := range file.GetSourceCodeInfo().GetLocation() { if loc.LeadingComments == nil && loc.TrailingComments == nil { continue } var p []string for _, n := range loc.Path { p = append(p, strconv.Itoa(int(n))) } comments[strings.Join(p, ",")] = loc } f := &File{ FileDescriptorProto: file, GoPkg: pkg, Comments: comments, } r.files[file.GetName()] = f r.registerMsg(f, nil, nil, file.GetMessageType()) }
// LintProtoFile takes a file name, proto file description, and a file. // It checks the file for errors and writes them to the output file func LintProtoFile( protoFile *descriptor.FileDescriptorProto, outFile io.WriteCloser, ) (int, error) { var ( errors = protoBufErrors{} protoSource = protoFile.GetSourceCodeInfo() ) for i, v := range protoFile.GetMessageType() { errors.lintProtoMessage(int32(i), pathMessage, []int32{}, v) } for i, v := range protoFile.GetEnumType() { errors.lintProtoEnumType(int32(i), pathEnumType, []int32{}, v) } for i, v := range protoFile.GetService() { errors.lintProtoService(int32(i), v) } for _, v := range errors { line, col := v.getSourceLineNumber(protoSource) fmt.Fprintf( outFile, "%s:%d:%d: '%s' - %s\n", *protoFile.Name, line, col, v.errorString, linterErrors[v.errorCode], ) } return len(errors), nil }
func processFile(inFile *descriptor.FileDescriptorProto) (*plugin.CodeGeneratorResponse_File, error) { if inFile.GetSyntax() != "proto3" { return nil, fmt.Errorf("Only proto3 syntax is supported") } outFile := &plugin.CodeGeneratorResponse_File{} inFilePath := inFile.GetName() inFileDir, inFileName := filepath.Split(inFilePath) shortModuleName := firstUpper(strings.TrimSuffix(inFileName, ".proto")) fullModuleName := "" outFileName := "" for _, segment := range strings.Split(inFileDir, "/") { if segment == "" { continue } fullModuleName += firstUpper(segment) + "." outFileName += firstUpper(segment) + "/" } fullModuleName += shortModuleName outFileName += shortModuleName + ".elm" outFile.Name = proto.String(outFileName) b := &bytes.Buffer{} fg := NewFileGenerator(b) fg.GenerateModule(fullModuleName) fg.GenerateImports() fg.GenerateRuntime() var err error // Top-level enums. for _, inEnum := range inFile.GetEnumType() { err = fg.GenerateEnumDefinition("", inEnum) if err != nil { return nil, err } err = fg.GenerateEnumDecoder("", inEnum) if err != nil { return nil, err } err = fg.GenerateEnumEncoder("", inEnum) if err != nil { return nil, err } } // Top-level messages. for _, inMessage := range inFile.GetMessageType() { err = fg.GenerateEverything("", inMessage) if err != nil { return nil, err } } outFile.Content = proto.String(b.String()) return outFile, nil }