TUN-528: Move cloudflared into a separate repo

vendor/zombiezen.com/go/capnproto2/internal/cmd/mktemplates/mktemplates.go

@@ -0,0 +1,193 @@
+// +build mktemplates
+// Build tag so that users who run `go get zombiezen.com/go/capnproto2/...` don't install this command.
+// cd internal/cmd/mktemplates && go build -tags=mktemplates
+
+// mktemplates is a command to regenerate capnpc-go/templates.go.
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"go/format"
+	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"text/template/parse"
+)
+
+func main() {
+	if len(os.Args) != 3 {
+		fmt.Fprintln(os.Stderr, "usage: mktemplates OUT DIR")
+		os.Exit(64)
+	}
+	dir := os.Args[2]
+	names, err := listdir(dir)
+	if err != nil {
+		fatalln(err)
+	}
+	ts := make([]template, len(names))
+	for i, name := range names {
+		src, err := ioutil.ReadFile(filepath.Join(dir, name))
+		if err != nil {
+			fatalf("reading template %s: %v", name, err)
+		}
+		compiled, err := compileTemplate(name, string(src))
+		if err != nil {
+			fatalf("compiling template %s: %v", name, err)
+		}
+		ts[i] = template{
+			name:    name,
+			content: compiled,
+		}
+	}
+	genbuf := new(bytes.Buffer)
+	err = generateGo(genbuf, os.Args, ts)
+	if err != nil {
+		fatalln("generating code:", err)
+	}
+	code, err := format.Source(genbuf.Bytes())
+	if err != nil {
+		fatalln("formatting code:", err)
+	}
+	outname := os.Args[1]
+	out, err := os.Create(outname)
+	if err != nil {
+		fatalf("opening destination %s: %v", outname, err)
+	}
+	_, err = out.Write(code)
+	cerr := out.Close()
+	if err != nil {
+		fatalf("write to %s: %v", outname, err)
+	}
+	if cerr != nil {
+		fatalln(err)
+	}
+}
+
+func compileTemplate(name, src string) (string, error) {
+	tset, err := parse.Parse(name, src, "{{", "}}", funcStubs)
+	if err != nil {
+		return "", err
+	}
+	return tset[name].Root.String(), nil
+}
+
+func generateGo(w io.Writer, args []string, ts []template) error {
+	src := new(bytes.Buffer)
+	for _, t := range ts {
+		fmt.Fprintf(src, "{{define %q}}", t.name)
+		src.WriteString(t.content)
+		src.WriteString("{{end}}")
+	}
+
+	// TODO(light): collect errors
+	fmt.Fprintln(w, "// Code generated from templates directory. DO NOT EDIT.")
+	fmt.Fprintln(w)
+	fmt.Fprintln(w, "//go:generate", strings.Join(args, " "))
+	fmt.Fprintln(w)
+	fmt.Fprintln(w, "package main")
+	fmt.Fprintln(w, "import (")
+	fmt.Fprintln(w, "\t\"strings\"")
+	fmt.Fprintln(w, "\t\"text/template\"")
+	fmt.Fprintln(w, ")")
+	fmt.Fprintln(w, "var templates = template.Must(template.New(\"\").Funcs(template.FuncMap{")
+	fmt.Fprintln(w, "\t\"title\": strings.Title,")
+	fmt.Fprintf(w, "}).Parse(\n\t%q))\n", src.Bytes())
+	for _, t := range ts {
+		if strings.HasPrefix(t.name, "_") {
+			continue
+		}
+		fmt.Fprintf(w, "func render%s(r renderer, p %sParams) error {\n\treturn r.Render(%[2]q, p)\n}\n", strings.Title(t.name), t.name)
+	}
+	return nil
+}
+
+type template struct {
+	name    string
+	content string
+}
+
+func listdir(name string) ([]string, error) {
+	f, err := os.Open(name)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+	names, err := f.Readdirnames(-1)
+	if err != nil {
+		return nil, err
+	}
+	n := 0
+	for _, name := range names {
+		if !strings.HasPrefix(name, ".") {
+			names[n] = name
+			n++
+		}
+	}
+	names = names[:n]
+	sort.Strings(names)
+	return names, nil
+}
+
+func fatalln(args ...interface{}) {
+	var buf bytes.Buffer
+	buf.WriteString("mktemplates: ")
+	fmt.Fprintln(&buf, args...)
+	os.Stderr.Write(buf.Bytes())
+	os.Exit(1)
+}
+
+func fatalf(format string, args ...interface{}) {
+	var buf bytes.Buffer
+	buf.WriteString("mktemplates: ")
+	fmt.Fprintf(&buf, format, args...)
+	if !bytes.HasSuffix(buf.Bytes(), []byte{'\n'}) {
+		buf.Write([]byte{'\n'})
+	}
+	os.Stderr.Write(buf.Bytes())
+	os.Exit(1)
+}
+
+var funcStubs = map[string]interface{}{
+	// Built-ins
+	"and":      variadicBoolStub,
+	"call":     func(interface{}, ...interface{}) (interface{}, error) { return nil, nil },
+	"eq":       func(arg0 interface{}, args ...interface{}) (bool, error) { return false, nil },
+	"ge":       cmpStub,
+	"gt":       cmpStub,
+	"html":     escaperStub,
+	"index":    func(interface{}, ...interface{}) (interface{}, error) { return nil, nil },
+	"js":       escaperStub,
+	"le":       cmpStub,
+	"len":      func(interface{}) (int, error) { return 0, nil },
+	"lt":       cmpStub,
+	"ne":       cmpStub,
+	"not":      func(interface{}) bool { return false },
+	"or":       variadicBoolStub,
+	"print":    fmt.Sprint,
+	"printf":   fmt.Sprintf,
+	"println":  fmt.Sprintln,
+	"urlquery": escaperStub,
+
+	// App-specific
+	"title": strings.Title,
+}
+
+func variadicBoolStub(arg0 interface{}, args ...interface{}) interface{} {
+	return arg0
+}
+
+func cmpStub(interface{}, interface{}) (bool, error) {
+	return false, nil
+}
+
+func escaperStub(...interface{}) string {
+	return ""
+}
+
+func importStub() string {
+	return ""
+}