func main() {
// Configure logging.
log.SetFlags(0)
log.SetPrefix("protoc-gen-json: ")
// Read input from the protoc compiler.
data, err := ioutil.ReadAll(os.Stdin)
if err != nil {
log.Fatal(err, ": failed to read input")
}
// Unmarshal the protoc generation request.
request := &plugin.CodeGeneratorRequest{}
if err := proto.Unmarshal(data, request); err != nil {
log.Fatal(err, ": failed to parse input proto")
}
if len(request.FileToGenerate) == 0 {
log.Fatal(err, ": no input files")
}
// Parse the command-line parameters.
params := util.ParseParams(request)
// Determine the correct output file name.
name := "out.json"
if v, ok := params["out"]; ok {
name = v
}
// Determine the JSON indention.
indent := " "
if v, ok := params["indent"]; ok {
indent = v
}
// Perform generation.
response := &plugin.CodeGeneratorResponse{}
data, err = json.MarshalIndent(request, "", indent)
if err != nil {
response.Error = proto.String(err.Error())
} else {
response.File = []*plugin.CodeGeneratorResponse_File{
&plugin.CodeGeneratorResponse_File{
Name: proto.String(name),
Content: proto.String(string(data)),
},
}
}
// Marshal the results and write back to the protoc compiler.
data, err = proto.Marshal(response)
if err != nil {
log.Fatal(err, ": failed to marshal output proto")
}
_, err = io.Copy(os.Stdout, bytes.NewReader(data))
if err != nil {
log.Fatal(err, ": failed to write output proto")
}
}
func main() {
// Configure logging.
log.SetFlags(0)
log.SetPrefix("protoc-gen-doc: ")
// Create a template generator.
g := tmpl.New()
// Read input from the protoc compiler.
data, err := ioutil.ReadAll(os.Stdin)
if err != nil {
log.Fatal(err, ": failed to read input")
}
// Unmarshal the protoc generation request.
request := &plugin.CodeGeneratorRequest{}
if err := proto.Unmarshal(data, request); err != nil {
log.Fatal(err, ": failed to parse input proto")
}
if err := g.SetRequest(request); err != nil {
log.Fatal(err, ": failed to set request")
}
if len(request.FileToGenerate) == 0 {
log.Fatal(err, ": no input files")
}
// Verify the command-line parameters.
params := util.ParseParams(request)
// Handle configuration files.
if conf, ok := params["conf"]; ok {
confData, err := ioutil.ReadFile(conf)
if err != nil {
log.Fatal(err, ": could not read conf file")
}
request.Parameter = proto.String(string(confData))
params = extendParams(params, util.ParseParams(request))
}
paramTemplate, haveTemplate := params["template"]
paramFileMap, haveFileMap := params["filemap"]
if haveTemplate && haveFileMap {
log.Fatal("expected either template or filemap argument, not both")
}
// Build the filemap based on the command-line parameters.
var fileMapDir, fileMapData string
if haveTemplate {
// Use the specified template file once on each input proto file.
fileMapData = fmt.Sprintf(basicFileMap, paramTemplate)
} else if haveFileMap {
// Load the filemap template.
data, err := ioutil.ReadFile(paramFileMap)
if err != nil {
log.Fatal(err, ": failed to read file map")
}
fileMapData = string(data)
fileMapDir = filepath.Dir(paramFileMap)
} else {
// Use the default filemap template once on each input proto file.
def := PathDir("src/sourcegraph.com/sourcegraph/prototools/templates/tmpl.html")
fileMapData = fmt.Sprintf(basicFileMap, def)
fileMapDir = filepath.Dir(def)
}
// Parse the file map template.
if err = g.ParseFileMap(fileMapDir, fileMapData); err != nil {
log.Fatal(err, ": failed to parse file map")
}
// Dump the execute filemap template, if desired.
if v, ok := params["dump-filemap"]; ok {
f, err := os.Create(v)
if err != nil {
log.Fatal(err, ": failed to crate dump file")
}
dump, err := xml.MarshalIndent(g.FileMap, "", " ")
if err != nil {
log.Fatal(err, ": failed to marshal filemap")
}
_, err = io.Copy(f, bytes.NewReader(dump))
if err != nil {
log.Fatal(err, ": failed to write dump file")
}
}
// Determine the root directory.
if v, ok := params["root"]; ok {
g.RootDir = v
} else {
g.RootDir, err = os.Getwd()
if err != nil {
log.Fatal(err)
}
}
// Map the API host, if any.
if v, ok := params["apihost"]; ok {
g.APIHost = v
}
// Perform generation.
response, err := g.Generate()
if err != nil {
log.Fatal(err, ": failed to generate")
}
// Marshal the results and write back to the protoc compiler.
data, err = proto.Marshal(response)
if err != nil {
log.Fatal(err, ": failed to marshal output proto")
}
_, err = io.Copy(os.Stdout, bytes.NewReader(data))
if err != nil {
log.Fatal(err, ": failed to write output proto")
}
}