thoth

type InvalidMissingKeyError struct {
	Value string
}

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

type Matcher interface {
	Match(string) bool
}

type Matchers []Matcher

type MediaTyper interface {
	// MediaType returns the MIME type associated with this object.  If
	// this method returns the empty string, then DefaultMediaType is assumed.
	MediaType() string
}

type Model map[string]interface{}

type Parser interface {
	// Parse produces a Template from some parsed content.  The name is
	// optional, and can be the empty string.
	//
	// If a common Model was defined in ParserConfig, the returned Template
	// will also implement ModelTemplate.
	//
	// For golang templates, an internal prototype template is first cloned
	// and then used as the containing template for each parsed template.  This
	// ensures that every template is unaffected by global definitions in other templates.
	Parse(name, content string) (Template, error)
}

type ParserConfig struct {
	// HTML indicates which template package to use.  If this field is false,
	// which is the default, text/template is used by the returned Parser.
	// If this field is true, html/template is used instead.
	HTML bool `json:"html" yaml:"html"`

	// MissingKey is the "missingkey=..." option.  If unset, error is used.
	// If this field is set to an unrecognized value, an error is raised.
	MissingKey string `json:"missingKey" yaml:"missingKey"`

	// LeftDelim is the left delimiter for pipelines.  If unset, the default "{{" is used.
	LeftDelim string `json:"leftDelim" yaml:"leftDelim"`

	// RightDelim is the right delimiter for pipelines.  If unset, the default "}}" is used.
	RightDelim string `json:"rightDelim" yaml:"rightDelim"`

	// FuncMap is the function map for all templates returned by the Parser.
	FuncMap map[string]interface{} `json:"-" yaml:"-"`

	// MediaType is the media type associated with all rendered templates produced
	// by this parser configuration.  If unset, DefaultMediaType is assumed.
	MediaType string `json:"mediaType" yaml:"mediaType"`
}

type Selector interface {
	// Select chooses a parser based on the template name.  If no parser
	// was found for the template, this method returns (nil, false).
	Select(name string) (Parser, bool)
}

type SelectorConfig struct {
	// Patterns are the globs which must match a template's name in order
	// to use this configured parser.
	Patterns []string `json:"patterns" yaml:"patterns"`

	// Parser is the configuration for parsing templates that match any
	// of the configured patterns.
	Parser ParserConfig `json:"parser" yaml:"parser"`
}

type Template interface {
	// Name returns the name of this template supplied at parse time.  This will
	// typically be the relative path of this template.
	Name() string

	// Execute renders this template using the supplied data.  The type of
	// data is unspecified and is dependent on the underlying template.
	Execute(output io.Writer, data interface{}) error
}