README
¶
Chew
All you need to know right now is that chew is a CLI for Go text/template engine with some additional bits and pieces. In chew you decide which templates will be generated and with which data. A more elaborate readme will be written when the time comes.. :)
Documentation
¶
Overview ¶
Package chew is the core package in Chew.
Chew is a lean and fast CLI wrapper for Go text/template with additional functions. The template generation in Chew is data-centric, meaning that the input data dictates which templates will be generated and with which data.
You can define a folder where you store all of your templates and Chew will parse all files in the folder and sub-folders when you run it. When running chew you also define the input data in JSON format, which will be used to generate the output.
For example if we have the folder /templates:
▾ templates
▾ special
bearing.tmpl
case.tmpl
fidget_spinner.tmpl
Content of fidget_spinner.tmpl:
Spinner model: {{ .model }}
Spinner year of construction: {{ .construction.year }}
Parts:
{{ indentTemplate "case" .case . 2 }}
Content of case.tmpl:
Case type: {{ .parent.model }}.{{ .type }}
Main Bearings:
{{ plugins .bearings "template" "main" . 2 }}
Outer Bearings:
{{ plugins .bearings "template" "outer" . 2 }}
Content of bearing.tmpl:
Index ¶
- Variables
- func Exists(data map[string]interface{}, key string) bool
- func Indent(identSize int, a string) string
- func MaxLength(data interface{}) int
- func Offset(length int, a interface{}) string
- func ToMap(data interface{}) (map[string]interface{}, error)
- type Chewable
- type ChewableData
- type MultiFileWriter
- type Template
- func (ct *Template) ExecuteChewable(w Writer, c Chewable) error
- func (ct *Template) IndentTemplate(template string, data interface{}, parent interface{}, indentSize int) string
- func (ct *Template) IndentTemplates(nestedTemplates interface{}, templateField string, parent interface{}, ...) string
- func (ct *Template) InjectFunctions()
- func (ct *Template) ParseFolder(folderPath string) (*Template, error)
- func (ct *Template) Plugins(pluginsRaw interface{}, insertPoint, templateField string, parent interface{}, ...) string
- type Writer
- type WriterWrapper
Examples ¶
Constants ¶
This section is empty.
Variables ¶
var ( // Version of Chew Version string // ReleaseDate of Chew ReleaseDate string )
Functions ¶
func MaxLength ¶
func MaxLength(data interface{}) int
MaxLength returns the length of the longest field in a []string.
func Offset ¶
Offset returns a string of blank spaces so that the input string reaches the input length.
func ToMap ¶
ToMap takes an object and extracts a map[string]interface{}. If the object is already a map[string]interface{} it is returned as it is. If the object is a struct, then the fields of the struct are mapped to a map where the keys are the names of the fields, while the values are the actual values. If anything else is passed to the function an error is thrown.
Types ¶
type Chewable ¶
type Chewable struct {
Global map[string]interface{}
Data []ChewableData
}
Chewable is the main object which carries the data in chew. It stores everything that is used when generating the data. The slice of ChewableData is looped through and used in executing the specified templates. Chewable also carries a map of objects called Global, which is accessible in every template.
func (*Chewable) UnmarshalJSON ¶
UnmarshalJSON parses data from JSON into Chewable. Returns an error if parsing was unsuccessful, else nil.
type ChewableData ¶
ChewableData is a collection of data which can be used in executing one or more templates. The field Templates stores a map in which the key denotes the name of the template which will be generated and the value denotes the output filename. Everything in field Local will be accessible in the templates. If a key in the map Local also exists in the map Global in Chewable, the Local value will be used.
type MultiFileWriter ¶
MultiFileWriter is a Writer which writes everything to files in the folder Out. If the folder defined in Out doesn't exist it is created before writing to the first file. SetOut has to be called before starting to write to this Writer, so that the file is created or truncated before writing to it.
func (*MultiFileWriter) SetOut ¶
func (w *MultiFileWriter) SetOut(filename string)
SetOut sets the filename of the output file into which the succeeding calls to Write will output the content. A file with the provided filename will be created in the folder defined in Out. If the file exists, it will be truncated.
type Template ¶
type Template struct {
*template.Template
Functions funcmap.Functions
// contains filtered or unexported fields
}
Template wraps *text/template.Template and adds some additional functionality. It should be created via chew.New. If a manual instantiation is used the method InjectFunctions should be called before processing templates to be able to use all custom chew functions.
func New ¶
New creates a new chew.Template with the provided name and injects the template functions.
func (*Template) ExecuteChewable ¶
ExecuteChewable loops through all ChewableData in Chewable and executes every Template defined in ChewableData.Templates. The output is written to the supplied chew.Writer, which also gets notified about the desired output filename before every template execution. If template.Template.ExecuteTemplate returns an error the execution stops and returns it.
Example ¶
dataRaw, _ := ioutil.ReadFile("test/data/example.json")
chewable := &Chewable{}
err := json.Unmarshal(dataRaw, chewable)
if err != nil {
log.Fatal(err)
}
template := New("main")
template.ParseFolder("test/templates")
template.ExecuteChewable(WriterWrapper{os.Stdout}, *chewable)
Output:
func (*Template) IndentTemplate ¶
func (ct *Template) IndentTemplate(template string, data interface{}, parent interface{}, indentSize int) string
IndentTemplate is similar to the built-in template function with the additional functionality of indenting the content of the template and accessing parent data. It takes the name of the template, the data which will be sent to the template when executing it, the parent data which will be accessible in the executed template and the number of spaces which will indent the content of the processed template.
func (*Template) IndentTemplates ¶
func (ct *Template) IndentTemplates(nestedTemplates interface{}, templateField string, parent interface{}, indentSize int) string
IndentTemplates is similar to IndentTemplate, only that it processes all templates defined in a slice. It takes the slice of objects which carry the data about the nested templates, the field in the nested template object which carries the name of the template, the parent data which will be accessible in the executed template and the number of spaces which will indent the content of the processed template.
func (*Template) InjectFunctions ¶
func (ct *Template) InjectFunctions()
InjectFunctions adds template specific functions to Template.Functions and adds the function map to the template.
func (*Template) ParseFolder ¶
ParseFolder recursively walks through the provided folder path and parses every template it can find with the template suffix.
func (*Template) Plugins ¶
func (ct *Template) Plugins(pluginsRaw interface{}, insertPoint, templateField string, parent interface{}, indentSize int) string
Plugins is similar to IndentTemplates, only that it skips nested templates which don't define a template for the insertion point. It takes the slice of objects which carry the data about the plugins, the insertion point where the plugin will be inserted, the field in the plugin object which carries the name of the template, the parent data which will be accessible in the executed template and the number of spaces which will indent the content of the processed template.
type Writer ¶
type Writer interface {
io.Writer
// SetOut sets the output filename for the current template
SetOut(filename string)
}
Writer extends the io.Writer and adds the option to set the output filename.
When processing Chewable the SetOut method will be called before each template execution informing the writer of the new target file. When writing to standard output this information is meaningless.
type WriterWrapper ¶
WriterWrapper is a convenience object to allow wrapping an io.Writer and implement the Writer interface. The SetOut method is empty and does nothing.
func (WriterWrapper) SetOut ¶
func (WriterWrapper) SetOut(filename string)
SetOut is empty and does nothing.
Source Files
Directories