generator

Documentation

Index

• type Args
  • func (a Args) With(key, value interface{}) Args
  • func (a Args) WithArgs(rhs Args) Args
• type SnippetWriter
  • func NewSnippetWriter(w io.Writer, c *generator.Context, left, right string) *SnippetWriter
  • func (s *SnippetWriter) AddFunc(name string, f interface{}) *SnippetWriter
  • func (s *SnippetWriter) AddFuncMap(m template.FuncMap) *SnippetWriter
  • func (s *SnippetWriter) Do(format string, args interface{}) *SnippetWriter
  • func (s *SnippetWriter) Error() error
  • func (s *SnippetWriter) Out() io.Writer

Types

type Args

type Args map[interface{}]interface{}

Args exists to make it convenient to construct arguments for SnippetWriter.Do.

func (Args) With

func (a Args) With(key, value interface{}) Args

With makes a copy of a and adds the given key, value pair.

func (Args) WithArgs

func (a Args) WithArgs(rhs Args) Args

WithArgs makes a copy of a and adds the given arguments.

type SnippetWriter

type SnippetWriter struct {
	// contains filtered or unexported fields
}

SnippetWriter is an attempt to make the template library usable. Methods are chainable, and you don't have to check Error() until you're all done.

func NewSnippetWriter

func NewSnippetWriter(w io.Writer, c *generator.Context, left, right string) *SnippetWriter

w is the destination; left and right are the delimiters; @ and $ are both reasonable choices.

c is used to make a function for every naming system, to which you can pass a type and get the corresponding name.

func (*SnippetWriter) AddFunc

func (s *SnippetWriter) AddFunc(name string, f interface{}) *SnippetWriter

func (*SnippetWriter) AddFuncMap

func (s *SnippetWriter) AddFuncMap(m template.FuncMap) *SnippetWriter

func (*SnippetWriter) Do

func (s *SnippetWriter) Do(format string, args interface{}) *SnippetWriter

Do parses format and runs args through it. You can have arbitrary logic in the format (see the text/template documentation), but consider running many short templates with ordinary go logic in between--this may be more readable. Do is chainable. Any error causes every other call to do to be ignored, and the error will be returned by Error(). So you can check it just once, at the end of your function.

'args' can be quite literally anything; read the text/template documentation for details. Maps and structs work particularly nicely. Conveniently, the types package is designed to have structs that are easily referencable from the template language.

Example:

sw := generator.NewSnippetWriter(outBuffer, context, "$", "$") sw.Do(`The public type name is: $.type|public$`, map[string]interface{}{"type": t}) return sw.Error()

Where:

• "$" starts a template directive
• "." references the entire thing passed as args
• "type" therefore sees a map and looks up the key "type"
• "|" means "pass the thing on the left to the thing on the right"
• "public" is the name of a naming system, so the SnippetWriter has given the template a function called "public" that takes a *types.Type and returns the naming system's name. E.g., if the type is "string" this might return "String".
• the second "$" ends the template directive.

The map is actually not necessary. The below does the same thing:

sw.Do(`The public type name is: $.|public$`, t)

You may or may not find it more readable to use the map with a descriptive key, but if you want to pass more than one arg, the map or a custom struct becomes a requirement. You can do arbitrary logic inside these templates, but you should consider doing the logic in go and stitching them together for the sake of your readers.

TODO: Change Do() to optionally take a list of pairs of parameters (key, value) and have it construct a combined map with that and args.

func (*SnippetWriter) Error

func (s *SnippetWriter) Error() error

Error returns any encountered error.

func (*SnippetWriter) Out

func (s *SnippetWriter) Out() io.Writer