gomplate

package module
v3.20.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Sep 22, 2022 License: MIT Imports: 17 Imported by: 38

README

gomplate logo

Read the docs at docs.gomplate.ca, chat with developers and community in the #gomplate channel on Gophers Slack

Build Go Report Card Codebeat Status Coverage Total Downloads CII Best Practices

DockerHub Pulls

Chocolatey Chocolatey

Install Docs Slack Discussions

gomplate is a template renderer which supports a growing list of datasources, such as: JSON (including EJSON - encrypted JSON), YAML, AWS EC2 metadata.

Come chat with developers and community in the #gomplate channel on Gophers Slack and on GitHub Discussions!

Here are some hands-on examples of how gomplate works:

$ # at its most basic, gomplate can be used with environment variables...
$ echo 'Hello, {{ .Env.USER }}' | gomplate
Hello, hairyhenderson

$ # but that's kind of boring. gomplate has tons of functions to do useful stuff, too
$ gomplate -i 'the answer is: {{ mul 6 7 }}'
the answer is: 42

$ # and, since gomplate uses Go's templating syntax, you can do fun things like:
$ gomplate -i '{{ range seq 5 1 }}{{ . }} {{ if eq . 1 }}{{ "blastoff" | toUpper }}{{ end }}{{ end }}'
5 4 3 2 1 BLASTOFF

$ # the real fun comes when you use datasources!
$ cat ./config.yaml
foo:
  bar:
    baz: qux
$ gomplate -d config=./config.yaml -i 'the value we want is: {{ (datasource "config").foo.bar.baz }}'
the value we want is: qux

$ # datasources are defined by URLs, and gomplate is not limited to just file-based datasources:
$ gomplate -d ip=https://ipinfo.io -i 'country code: {{ (ds "ip").country }}'
country code: CA

$ # standard input can be used as a datasource too:
$ echo '{"cities":["London", "Johannesburg", "Windhoek"]}' | gomplate -d city=stdin:///in.json -i '{{ range (ds "city").cities }}{{.}}, {{end}}'
London, Johannesburg, Windhoek,

$ # and here's something a little more complicated:
$ export CITIES='city: [London, Johannesburg, Windhoek]'
$ cat in.tmpl
{{ range $i, $city := (ds "cities").city -}}
{{ add 1 $i }}: {{ include "weather" (print $city "?0") }}
{{ end }}
$ gomplate -d 'cities=env:///CITIES?type=application/yaml' -d 'weather=https://wttr.in/?0' -H 'weather=User-Agent: curl' -f in.tmpl
1: Weather report: London

    \  /       Partly cloudy
  _ /"".-.     4-7 °C
    \_(   ).   ↑ 20 km/h
    /(___(__)  10 km
               0.0 mm

2: Weather report: Johannesburg

    \  /       Partly cloudy
  _ /"".-.     15 °C
    \_(   ).   ↘ 0 km/h
    /(___(__)  10 km
               2.2 mm

3: Weather report: Windhoek

    \  /       Partly cloudy
  _ /"".-.     20 °C
    \_(   ).   ↑ 6 km/h
    /(___(__)  20 km
               0.0 mm

Read the documentation at docs.gomplate.ca, and join the discussion in GitHub Discussions!

Please report any bugs found in the issue tracker.

License

The MIT License

Copyright (c) 2016-2022 Dave Henderson

Analytics

Documentation

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func CreateFuncs 

func CreateFuncs(ctx context.Context, d *data.Data) template.FuncMap

CreateFuncs - function mappings are created here

func Funcs 

func Funcs(d *data.Data) template.FuncMap

Funcs - Deprecated: use CreateFuncs instead

func PluginFunc 

func PluginFunc(ctx context.Context, cmd string, opts PluginOpts) func(...interface{}) (interface{}, error)

PluginFunc creates a template function that runs an external process - either a shell script or commandline executable.

Example 
ctx := context.Background()

// PluginFunc creates a template function that runs an arbitrary command.
f := PluginFunc(ctx, "echo", PluginOpts{})

// The function can be used in a template, but here we'll just run it
// directly. This is equivalent to running 'echo foo bar'
out, err := f("foo", "bar")
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

foo bar
Example (With_template) 
ctx := context.Background()

f := PluginFunc(ctx, "echo", PluginOpts{})

// PluginFunc is intended for use with gomplate, but can be used in any
// text/template by adding it to the FuncMap.
tmpl := template.New("new").Funcs(template.FuncMap{"echo": f})

tmpl, err := tmpl.Parse(`{{ echo "baz" "qux" }}`)
if err != nil {
	panic(err)
}

err = tmpl.Execute(os.Stdout, nil)
if err != nil {
	panic(err)
}

Output:

baz qux

func SetExperimental 

func SetExperimental(ctx context.Context) context.Context

SetExperimental enables experimental functions and features in the given context. This must be done before creating functions. The set of experimental features enabled by this is not fixed and will change over time.

Types

type Config deprecated 

type Config struct {
	Input       string
	InputFiles  []string
	InputDir    string
	ExcludeGlob []string
	OutputFiles []string
	OutputDir   string
	OutputMap   string
	OutMode     string
	Out         io.Writer

	DataSources       []string
	DataSourceHeaders []string
	Contexts          []string

	Plugins []string

	LDelim string
	RDelim string

	Templates []string
}

Config - values necessary for rendering templates with gomplate. Mainly for use by the CLI

Deprecated: this type will be phased out, internal/config.Config is used everywhere else, and will be exposed as API in a future version

func (*Config) String 

func (o *Config) String() string

nolint: gocyclo

type MetricsType 

type MetricsType struct {
	// times for rendering each template
	RenderDuration map[string]time.Duration
	// time it took to gather templates
	GatherDuration time.Duration
	// time it took to render all templates
	TotalRenderDuration time.Duration

	TemplatesGathered  int
	TemplatesProcessed int
	Errors             int
}

MetricsType - Warning: experimental! This may change in breaking ways without warning. This is not subject to any semantic versioning guarantees! 

var Metrics *MetricsType

Metrics tracks interesting basic metrics around gomplate executions. Warning: experimental! This may change in breaking ways without warning. This is not subject to any semantic versioning guarantees!

type PluginOpts 

type PluginOpts struct {
	// Stderr can be set to redirect the plugin's stderr to a custom writer.
	// Defaults to os.Stderr.
	Stderr io.Writer

	// Timeout is the maximum amount of time to wait for the plugin to complete.
	// Defaults to 5 seconds.
	Timeout time.Duration

	// Pipe indicates whether the last argument should be piped to the plugin's
	// stdin (true) or processed as a commandline argument (false)
	Pipe bool
}

PluginOpts are options for controlling plugin function execution

Source Files

View all Source files

Directories

Path Synopsis
Package aws contains functions which wrap various Amazon Web Services APIs
 Package aws contains functions which wrap various Amazon Web Services APIs
Package base64 contains Base64 encoding/decoding functions
 Package base64 contains Base64 encoding/decoding functions
Package coll contains functions to help manipulate and query collections of data, like slices/arrays and maps.
 Package coll contains functions to help manipulate and query collections of data, like slices/arrays and maps.
Package conv contains functions that help converting data between different types
 Package conv contains functions that help converting data between different types
Package crypto contains functions to help perform hashing and simple encryption operations
 Package crypto contains functions to help perform hashing and simple encryption operations
Package data contains functions that parse and produce data structures in different formats.
 Package data contains functions that parse and produce data structures in different formats.
Package env contains functions that retrieve data from the environment
 Package env contains functions that retrieve data from the environment
Package file contains functions for working with files and directories on the local filesystem
 Package file contains functions for working with files and directories on the local filesystem
Package funcs is an internal package that provides gomplate namespaces and functions to be used in 'text/template' templates.
 Package funcs is an internal package that provides gomplate namespaces and functions to be used in 'text/template' templates.
internal
config
conv
deprecated
iohelpers
Package math contains set of basic math functions to be able to perform simple arithmetic operations
 Package math contains set of basic math functions to be able to perform simple arithmetic operations
Package net contains functions to help with network-oriented lookups
 Package net contains functions to help with network-oriented lookups
Package random contains functions for generating random values
 Package random contains functions for generating random values
Package regexp contains functions for dealing with regular expressions
 Package regexp contains functions for dealing with regular expressions
Package strings contains functions to manipulate strings
 Package strings contains functions to manipulate strings
Package test contains functions to help validate assumptions and can cause template generation to fail in specific cases
 Package test contains functions to help validate assumptions and can cause template generation to fail in specific cases
Package time contains functions to help work with date and time
 Package time contains functions to help work with date and time
Package tmpl contains functions for defining or executing in-line templates.
 Package tmpl contains functions for defining or executing in-line templates.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.