Add tool to generate PropertyConverter implementations for proto messages.

tools/proto-gae/proto_gae.go

+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package main
+
+import (
+        "flag"
+        "fmt"
+        "io"
+        "os"
+        "sort"
+        "strings"
+        "text/template"
+
+        "github.com/luci/luci-go/common/errors"
+        "github.com/luci/luci-go/common/flag/stringsetflag"
+)
+
+type app struct {
+        out io.Writer
+
+        packageName string
+        typeNames   stringsetflag.Flag
+        outFile     string
+}
+
+const help = `Usage of %s:
+
+%s is a go-generator program that generates PropertyConverter implementations
+for types produced by protoc. It can be used in a go generation file like:
+
+  //go:generate <protoc command>
+  //go:generate proto-gae -type MessageType -type OtherMessageType
+
+This will produce a new file which implements the ToProperty and FromProperty
+methods for the named types.
+
+Options:
+`
+
+func (a *app) parseArgs(fs *flag.FlagSet, args []string) error {
+        fs.SetOutput(a.out)
+        fs.Usage = func() {
+                fmt.Fprintf(a.out, help, args[0], args[0])
+                fs.PrintDefaults()
+        }
+
+        fs.Var(&a.typeNames, "type",
+                "A generated proto.Message type to generate stubs for (required, repeatable)")
+        fs.StringVar(&a.outFile, "out", "proto_gae.gen.go",
+                "The name of the output file")
+
+        if err := fs.Parse(args[1:]); err != nil {
+                return err
+        }
+        fail := errors.MultiError(nil)
+        if a.typeNames.Data == nil || a.typeNames.Data.Len() == 0 {
+                fail = append(fail, errors.New("must specify one or more -type"))
+        }
+        if !strings.HasSuffix(a.outFile, ".go") {
+                fail = append(fail, errors.New("-output must end with '.go'"))
+        }
+        if len(fail) > 0 {
+                for _, e := range fail {
+                        fmt.Fprintln(a.out, "error:", e)
+                }
+                fmt.Fprintln(a.out)
+                fs.Usage()
+                return fail
+        }
+        return nil
+}
+
+var tmpl = template.Must(
+        template.New("main").Parse(`// AUTOGENERATED: Do not edit
+
+package {{index . "package"}}
+
+import (
+        "github.com/golang/protobuf/proto"
+
+        "github.com/luci/gae/service/datastore"
+){{range index . "types"}}
+
+var _ datastore.PropertyConverter = (*{{.}})(nil)
+
+// ToProperty implements datastore.PropertyConverter. It causes an embedded
+// '{{.}}' to serialize to an unindexed '[]byte' when used with the
+// "github.com/luci/gae" library.
+func (p *{{.}}) ToProperty() (prop datastore.Property, err error) {
+        data, err := proto.Marshal(p)
+        if err == nil {
+                prop.SetValue(data, datastore.NoIndex)
+        }
+        return
+}
+
+// FromProperty implements datastore.PropertyConverter. It parses a '[]byte'
+// into an embedded '{{.}}' when used with the "github.com/luci/gae" library.
+func (p *{{.}}) FromProperty(prop datastore.Property) error {
+        data, err := prop.Project(datastore.PTBytes)
+        if err != nil {
+                return err
+        }
+        return proto.Unmarshal(data.([]byte), p)
+}{{end}}
+`))
+
+func (a *app) writeTo(w io.Writer) error {
+        typeNames := a.typeNames.Data.ToSlice()
+        sort.Strings(typeNames)
+
+        return tmpl.Execute(w, map[string]interface{}{
+                "package": a.packageName,
+                "types":   typeNames,
+        })
+}
+
+func (a *app) main() {
+        if err := a.parseArgs(flag.NewFlagSet(os.Args[0], flag.ContinueOnError), os.Args); err != nil {

[dnj, 2016/01/23 06:15:36]

nit: Why ContinueOnError instead of ExitOnError?

[iannucci, 2016/01/23 10:01:07]

So that I could theoretically test this, except I don't.

+                os.Exit(1)
+        }
+        ofile, err := os.Create(a.outFile)
+        if err != nil {
+                fmt.Fprintf(a.out, "error: %s", err)
+                os.Exit(2)
+        }
+        defer ofile.Close()

[dnj, 2016/01/23 06:15:36]

I suppose in theory if Close fails this could fail to completely generate. Also
maybe use bufio since you're doing a bunch of successive writes?

[iannucci, 2016/01/23 10:01:07]

done, though it's completely overkill.

+        if err := a.writeTo(ofile); err != nil {
+                os.Exit(3)
+        }
+}
+
+func main() {
+        (&app{out: os.Stderr, packageName: os.Getenv("GOPACKAGE")}).main()
+}