yttlibrary

package
v0.41.1 Latest Latest
Warning

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

 Go to latest Published: May 26, 2022 License: Apache-2.0 Imports: 18 Imported by: 0

Documentation

Overview

Package yttlibrary implements the "Standard Library" of modules that are built-in to the ytt templating engine.

Index

Constants

View Source 
const (
	SemverRegex string = `^(?P<major>0|[1-9]\d*)\.(?P<minor>0|[1-9]\d*)\.(?P<patch>0|[1-9]\d*)` +
		`(?:-(?P<prerelease>(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))` +
		`?(?:\+(?P<buildmetadata>[0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$`
)

Variables

View Source 
var (
	AssertAPI = starlark.StringDict{
		"assert": &starlarkstruct.Module{
			Name: "assert",
			Members: starlark.StringDict{
				"equals": starlark.NewBuiltin("assert.equals", core.ErrWrapper(assertModule{}.Equals)),
				"fail":   starlark.NewBuiltin("assert.fail", core.ErrWrapper(assertModule{}.Fail)),
				"try_to": starlark.NewBuiltin("assert.try_to", core.ErrWrapper(assertModule{}.TryTo)),
			},
		},
	}
)
View Source 
var (
	Base64API = starlark.StringDict{
		"base64": &starlarkstruct.Module{
			Name: "base64",
			Members: starlark.StringDict{
				"encode": starlark.NewBuiltin("base64.encode", core.ErrWrapper(base64Module{}.Encode)),
				"decode": starlark.NewBuiltin("base64.decode", core.ErrWrapper(base64Module{}.Decode)),
			},
		},
	}
)
View Source 
var (
	// IPAPI describes the contents of "@ytt:ip" module of the ytt standard library.
	IPAPI = starlark.StringDict{
		"ip": &starlarkstruct.Module{
			Name: "ip",
			Members: starlark.StringDict{
				"parse_addr": starlark.NewBuiltin("ip.parse_addr", core.ErrWrapper(ipModule{}.ParseAddr)),
				"parse_cidr": starlark.NewBuiltin("ip.parse_cidr", core.ErrWrapper(ipModule{}.ParseCIDR)),
			},
		},
	}
)
View Source 
var (
	// JSONAPI contains the definition of the @ytt:json module
	JSONAPI = starlark.StringDict{
		"json": &starlarkstruct.Module{
			Name: "json",
			Members: starlark.StringDict{
				"encode": starlark.NewBuiltin("json.encode", core.ErrWrapper(jsonModule{}.Encode)),
				"decode": starlark.NewBuiltin("json.decode", core.ErrWrapper(jsonModule{}.Decode)),
			},
		},
	}
)
View Source 
var (
	MD5API = starlark.StringDict{
		"md5": &starlarkstruct.Module{
			Name: "md5",
			Members: starlark.StringDict{
				"sum": starlark.NewBuiltin("md5.sum", core.ErrWrapper(md5Module{}.Sum)),
			},
		},
	}
)
View Source 
var (
	ModuleAPI = starlark.StringDict{
		"module": &starlarkstruct.Module{
			Name: "module",
			Members: starlark.StringDict{
				"make": starlark.NewBuiltin("module.make", core.ErrWrapper(starlarkstruct.MakeModule)),
			},
		},
	}
)
View Source 
var (
	RegexpAPI = starlark.StringDict{
		"regexp": &starlarkstruct.Module{
			Name: "regexp",
			Members: starlark.StringDict{
				"match":   starlark.NewBuiltin("regexp.match", core.ErrWrapper(regexpModule{}.Match)),
				"replace": starlark.NewBuiltin("regexp.replace", core.ErrWrapper(regexpModule{}.Replace)),
			},
		},
	}
)
View Source 
var (
	SHA256API = starlark.StringDict{
		"sha256": &starlarkstruct.Module{
			Name: "sha256",
			Members: starlark.StringDict{
				"sum": starlark.NewBuiltin("sha256.sum", core.ErrWrapper(sha256Module{}.Sum)),
			},
		},
	}
)
View Source 
var (
	StructAPI = starlark.StringDict{
		"struct": &starlarkstruct.Module{
			Name: "struct",
			Members: starlark.StringDict{
				"make":          starlark.NewBuiltin("struct.make", core.ErrWrapper(structModule{}.Make)),
				"make_and_bind": starlark.NewBuiltin("struct.make_and_bind", core.ErrWrapper(structModule{}.MakeAndBind)),
				"bind":          starlark.NewBuiltin("struct.bind", core.ErrWrapper(structModule{}.Bind)),

				"encode": starlark.NewBuiltin("struct.encode", core.ErrWrapper(structModule{}.Encode)),
				"decode": starlark.NewBuiltin("struct.decode", core.ErrWrapper(structModule{}.Decode)),
			},
		},
	}
)
View Source 
var (
	URLAPI = starlark.StringDict{
		"url": &starlarkstruct.Module{
			Name: "url",
			Members: starlark.StringDict{
				"path_segment_encode": starlark.NewBuiltin("url.path_segment_encode", core.ErrWrapper(urlModule{}.PathSegmentEncode)),
				"path_segment_decode": starlark.NewBuiltin("url.path_segment_decode", core.ErrWrapper(urlModule{}.PathSegmentDecode)),

				"query_param_value_encode": starlark.NewBuiltin("url.query_param_value_encode", core.ErrWrapper(urlModule{}.QueryParamValueEncode)),
				"query_param_value_decode": starlark.NewBuiltin("url.query_param_value_decode", core.ErrWrapper(urlModule{}.QueryParamValueDecode)),

				"query_params_encode": starlark.NewBuiltin("url.query_params_encode", core.ErrWrapper(urlModule{}.QueryParamsEncode)),
				"query_params_decode": starlark.NewBuiltin("url.query_params_decode", core.ErrWrapper(urlModule{}.QueryParamsDecode)),

				"parse": starlark.NewBuiltin("url.parse", core.ErrWrapper(urlModule{}.ParseURL)),
			},
		},
	}
)
View Source 
var (
	VersionAPI = starlark.StringDict{
		"version": &starlarkstruct.Module{
			Name: "version",
			Members: starlark.StringDict{
				"require_at_least": starlark.NewBuiltin("version.require_at_least", core.ErrWrapper(versionModule{}.RequireAtLeast)),
			},
		},
	}
)
View Source 
var (
	// YAMLAPI contains the definition of the @ytt:yaml module
	YAMLAPI = starlark.StringDict{
		"yaml": &starlarkstruct.Module{
			Name: "yaml",
			Members: starlark.StringDict{
				"encode": starlark.NewBuiltin("yaml.encode", core.ErrWrapper(yamlModule{}.starlarkEncode)),
				"decode": starlark.NewBuiltin("yaml.decode", core.ErrWrapper(yamlModule{}.Decode)),
			},
		},
	}
)

Functions

func RegisterExt added in v0.41.0 

func RegisterExt(mod *starlarkstruct.Module)

RegisterExt adds "mod" to the standard set of ytt library modules as an extension. An "extension" is a Starlark module that has external Go dependencies (as opposed to other Starlark modules in the ytt library that either have no dependencies or depend on the Go standard lib). This enables those using ytt as a Go module to opt-in (rather than be forced) to accept such dependencies. Only Carvel-maintained extensions can be registered; this reserves the `@ytt:` namespace. Integrators who want to write their own extensions should construct their own library.

Types

type API 

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

func NewAPI 

func NewAPI(replaceNodeFunc tplcore.StarlarkFunc, dataMod DataModule,
	libraryMod starlark.StringDict) API

func (API) FindModule added in v0.40.0 

func (a API) FindModule(module string) (starlark.StringDict, error)

type DataLoader added in v0.40.0 

type DataLoader interface {
	FilePaths(string) ([]string, error)
	FileData(string) ([]byte, error)
}

type DataModule added in v0.40.0 

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

func NewDataModule 

func NewDataModule(values *yamlmeta.Document, loader DataLoader) DataModule

func (DataModule) AsModule added in v0.40.0 

func (b DataModule) AsModule() starlark.StringDict

func (DataModule) List added in v0.40.0 

func (b DataModule) List(thread *starlark.Thread, f *starlark.Builtin,
	args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error)

func (DataModule) Read added in v0.40.0 

func (b DataModule) Read(thread *starlark.Thread, f *starlark.Builtin,
	args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error)

type IPAddrValue added in v0.40.0 

type IPAddrValue struct {
	*core.StarlarkStruct // TODO: keep authorship of the interface by delegating instead of embedding
	// contains filtered or unexported fields
}

IPAddrValue stores a parsed IP

func (*IPAddrValue) AsStarlarkValue added in v0.40.0 

func (av *IPAddrValue) AsStarlarkValue() starlark.Value

AsStarlarkValue converts this instance into a value suitable for use in a Starlark program.

func (*IPAddrValue) ConversionHint added in v0.40.0 

func (av *IPAddrValue) ConversionHint() string

ConversionHint provides a hint on how the user can explicitly convert this value to a type that can be automatically encoded.

func (*IPAddrValue) IsIPv4 added in v0.40.0 

func (av *IPAddrValue) IsIPv4(thread *starlark.Thread, f *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error)

IsIPv4 is a core.StarlarkFunc that reveals whether this value is an IPv4 address.

func (*IPAddrValue) IsIPv6 added in v0.40.0 

func (av *IPAddrValue) IsIPv6(thread *starlark.Thread, f *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error)

IsIPv6 is a core.StarlarkFunc that reveals whether this value is an IPv6 address.

func (*IPAddrValue) Type added in v0.40.0 

func (av *IPAddrValue) Type() string

Type reports the name of this type as seen from a Starlark program (i.e. via the `type()` built-in)

type IPNetValue added in v0.40.0 

type IPNetValue struct {
	*core.StarlarkStruct // TODO: keep authorship of the interface by delegating instead of embedding
	// contains filtered or unexported fields
}

IPNetValue holds the data for an instance of an IP Network value

func (*IPNetValue) Addr added in v0.40.0 

func (inv *IPNetValue) Addr(thread *starlark.Thread, f *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error)

Addr is a core.StarlarkFunc that returns the masked address portion of the network value

func (*IPNetValue) AsStarlarkValue added in v0.40.0 

func (inv *IPNetValue) AsStarlarkValue() starlark.Value

AsStarlarkValue converts this instance into a value suitable for use in a Starlark program.

func (*IPNetValue) ConversionHint added in v0.40.0 

func (inv *IPNetValue) ConversionHint() string

ConversionHint provides a hint on how the user can explicitly convert this value to a type that can be automatically encoded.

func (*IPNetValue) Type added in v0.40.0 

func (inv *IPNetValue) Type() string

Type reports the name of this type as seen from a Starlark program (i.e. via the `type()` built-in)

type TemplateModule added in v0.40.0 

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

func NewTemplateModule 

func NewTemplateModule(replaceNodeFunc core.StarlarkFunc) TemplateModule

func (TemplateModule) AsModule added in v0.40.0 

func (b TemplateModule) AsModule() starlark.StringDict

type URLUser added in v0.40.0 

type URLUser struct {
	*core.StarlarkStruct // TODO: keep authorship of the interface by delegating instead of embedding
	// contains filtered or unexported fields
}

URLUser stores the user information

func (*URLUser) ConversionHint added in v0.40.0 

func (uu *URLUser) ConversionHint() string

func (*URLUser) Type added in v0.40.0 

func (uu *URLUser) Type() string

Type reports the fully-qualified name of type of this custom struct.

type URLValue added in v0.40.0 

type URLValue struct {
	*core.StarlarkStruct // TODO: keep authorship of the interface by delegating instead of embedding
	// contains filtered or unexported fields
}

URLValue stores a parsed URL

func (*URLValue) AsStarlarkValue added in v0.40.0 

func (uv *URLValue) AsStarlarkValue() starlark.Value

func (*URLValue) ConversionHint added in v0.40.0 

func (uv *URLValue) ConversionHint() string

func (*URLValue) Hostname added in v0.40.0 

func (uv *URLValue) Hostname(thread *starlark.Thread, f *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error)

func (*URLValue) Type added in v0.40.0 

func (uv *URLValue) Type() string

Type reports the fully-qualified name of type of this custom struct.

func (*URLValue) User added in v0.40.0 

func (uv *URLValue) User() starlark.Value

func (*URLValue) WithoutUser added in v0.40.0 

func (uv *URLValue) WithoutUser(thread *starlark.Thread, f *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error)

Source Files

View all Source files

Directories

Path Synopsis
Package overlay implements YAML patching via ytt annotations.
 Package overlay implements YAML patching via ytt annotations.

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.