Generating Yaml Docs For Your Own cobra.Command

Generating yaml files from a cobra command is incredibly easy. An example is as follows:

  1. package main
  3. import (
  4.     "log"
  6.     "github.com/spf13/cobra"
  7.     "github.com/spf13/cobra/doc"
  8. )
  10. func main() {
  11.     cmd := &cobra.Command{
  12.         Use:   "test",
  13.         Short: "my test program",
  14.     }
  15.     err := doc.GenYamlTree(cmd, "/tmp")
  16.     if err != nil {
  17.         log.Fatal(err)
  18.     }
  19. }

That will get you a Yaml document /tmp/test.yaml

Generate yaml docs for the entire command tree

This program can actually generate docs for the kubectl command in the kubernetes project

  1. package main
  3. import (
  4.     "io/ioutil"
  5.     "log"
  6.     "os"
  8.     "k8s.io/kubernetes/pkg/kubectl/cmd"
  9.     cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
  11.     "github.com/spf13/cobra/doc"
  12. )
  14. func main() {
  15.     kubectl := cmd.NewKubectlCommand(cmdutil.NewFactory(nil), os.Stdin, ioutil.Discard, ioutil.Discard)
  16.     err := doc.GenYamlTree(kubectl, "./")
  17.     if err != nil {
  18.         log.Fatal(err)
  19.     }
  20. }

This will generate a whole series of files, one for each command in the tree, in the directory specified (in this case “./“)

Generate yaml docs for a single command

You may wish to have more control over the output, or only generate for a single command, instead of the entire command tree. If this is the case you may prefer to GenYaml instead of GenYamlTree

  1.     out := new(bytes.Buffer)
  2.     doc.GenYaml(cmd, out)

This will write the yaml doc for ONLY “cmd” into the out, buffer.

Customize the output

Both GenYaml and GenYamlTree have alternate versions with callbacks to get some control of the output:

  1. func GenYamlTreeCustom(cmd *Command, dir string, filePrepender, linkHandler func(string) string) error {
  2.     //...
  3. }
  1. func GenYamlCustom(cmd *Command, out *bytes.Buffer, linkHandler func(string) string) error {
  2.     //...
  3. }

The filePrepender will prepend the return value given the full filepath to the rendered Yaml file. A common use case is to add front matter to use the generated documentation with Hugo:

  1. const fmTemplate = `---
  2. date: %s
  3. title: "%s"
  4. slug: %s
  5. url: %s
  6. ---
  7. `
  9. filePrepender := func(filename string) string {
  10.     now := time.Now().Format(time.RFC3339)
  11.     name := filepath.Base(filename)
  12.     base := strings.TrimSuffix(name, path.Ext(name))
  13.     url := "/commands/" + strings.ToLower(base) + "/"
  14.     return fmt.Sprintf(fmTemplate, now, strings.Replace(base, "_", " ", -1), base, url)
  15. }

The linkHandler can be used to customize the rendered internal links to the commands, given a filename:

  1. linkHandler := func(name string) string {
  2.     base := strings.TrimSuffix(name, path.Ext(name))
  3.     return "/commands/" + strings.ToLower(base) + "/"
  4. }