Documentation ¶
Index ¶
- func IsEmptyTree(n Node) bool
- type ActionNode
- type AdditiveExprNode
- type Arguments
- func (a *Arguments) Get(argumentIndex int) reflect.Value
- func (a *Arguments) IsSet(argumentIndex int) bool
- func (a *Arguments) NumOfArguments() int
- func (a *Arguments) Panicf(format string, v ...interface{})
- func (a *Arguments) ParseInto(ptrs ...interface{}) error
- func (a *Arguments) RequireNumOfArguments(funcname string, min, max int)
- func (a *Arguments) Runtime() *Runtime
- type BlockNode
- type BlockParameter
- type BlockParameterList
- type BoolNode
- type BranchNode
- type Cache
- type CallArgs
- type CallExprNode
- type ChainNode
- type CommandNode
- type ComparativeExprNode
- type Expression
- type FieldNode
- type Func
- type IdentifierNode
- type IfNode
- type InMemLoader
- type IncludeNode
- type IndexExprNode
- type ListNode
- type Loader
- type LogicalExprNode
- type MultiplicativeExprNode
- type NilNode
- type Node
- type NodeBase
- type NodeType
- type NotExprNode
- type NumberNode
- type NumericComparativeExprNode
- type OSFileSystemLoader
- type Option
- type PipeNode
- type Pos
- type RangeNode
- type Ranger
- type Renderer
- type RendererFunc
- type ReturnNode
- type Runtime
- func (r *Runtime) Context() reflect.Value
- func (state *Runtime) Let(name string, val interface{})
- func (state *Runtime) LetGlobal(name string, val interface{})
- func (state *Runtime) MustResolve(name string) reflect.Value
- func (state *Runtime) Resolve(name string) reflect.Value
- func (state *Runtime) Set(name string, val interface{}) error
- func (state *Runtime) SetOrLet(name string, val interface{})
- func (w Runtime) Write(b []byte) (int, error)
- func (st *Runtime) YieldBlock(name string, context interface{})
- type SafeWriter
- type Set
- func (s *Set) AddGlobal(key string, i interface{}) *Set
- func (s *Set) AddGlobalFunc(key string, fn Func) *Set
- func (s *Set) GetTemplate(templatePath string) (t *Template, err error)
- func (s *Set) LookupGlobal(key string) (val interface{}, found bool)
- func (s *Set) Parse(templatePath, contents string) (template *Template, err error)
- type SetNode
- type SliceExprNode
- type StringNode
- type Template
- type TernaryExprNode
- type TextNode
- type TryNode
- type UnderscoreNode
- type VarMap
- type YieldNode
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func IsEmptyTree ¶
IsEmptyTree reports whether this tree (node) is empty of everything but space.
Types ¶
type ActionNode ¶
ActionNode holds an action (something bounded by delimiters). Control actions have their own nodes; ActionNode represents simple ones such as field evaluations and parenthesized pipelines.
func (*ActionNode) String ¶
func (a *ActionNode) String() string
type AdditiveExprNode ¶
type AdditiveExprNode struct {
// contains filtered or unexported fields
}
AdditiveExprNode represents an add or subtract expression ex: expression ( '+' | '-' ) expression
type Arguments ¶
type Arguments struct {
// contains filtered or unexported fields
}
Arguments holds the arguments passed to jet.Func.
func (*Arguments) IsSet ¶
IsSet checks whether an argument is set or not. It behaves like the build-in isset function.
func (*Arguments) NumOfArguments ¶
NumOfArguments returns the number of arguments
func (*Arguments) ParseInto ¶
ParseInto parses the arguments into the provided pointers. It returns an error if the number of pointers passed in does not equal the number of arguments, if any argument's value is invalid according to Go's reflect package, if an argument can't be used as the value the pointer passed in at the corresponding position points to, or if an unhandled pointer type is encountered. Allowed pointer types are pointers to interface{}, int, int64, float64, bool, string, time.Time, reflect.Value, []interface{}, map[string]interface{}. If a pointer to a reflect.Value is passed in, the argument be assigned as-is to the value pointed to. For pointers to int or float types, type conversion is performed automatically if necessary.
func (*Arguments) RequireNumOfArguments ¶
RequireNumOfArguments panics if the number of arguments is not in the range specified by min and max. In case there is no minimum pass -1, in case there is no maximum pass -1 respectively.
type BlockNode ¶
type BlockNode struct { NodeBase //The line number in the input. Deprecated: Kept for compatibility. Name string //The name of the template (unquoted). Parameters *BlockParameterList Expression Expression //The command to evaluate as dot for the template. List *ListNode Content *ListNode }
BlockNode represents a {{block }} action.
type BlockParameter ¶
type BlockParameter struct { Identifier string Expression Expression }
type BlockParameterList ¶
type BlockParameterList struct { NodeBase List []BlockParameter }
func (*BlockParameterList) Param ¶
func (bplist *BlockParameterList) Param(name string) (Expression, int)
func (*BlockParameterList) String ¶
func (bplist *BlockParameterList) String() (str string)
type BranchNode ¶
type BranchNode struct { NodeBase Set *SetNode Expression Expression List *ListNode ElseList *ListNode }
BranchNode is the common representation of if, range, and with.
func (*BranchNode) String ¶
func (b *BranchNode) String() string
type Cache ¶
type Cache interface { // Get fetches a template from the cache. If Get returns nil, the same path with a different extension will be tried. // If Get() returns nil for all configured extensions, the same path and extensions will be tried on the Set's Loader. Get(templatePath string) *Template // Put places the result of parsing a template "file"/string in the cache. Put(templatePath string, t *Template) }
Cache is the interface Jet uses to store and retrieve parsed templates.
type CallArgs ¶
type CallArgs struct { Exprs []Expression HasPipeSlot bool }
type CallExprNode ¶
type CallExprNode struct { NodeBase BaseExpr Expression CallArgs }
CallExprNode represents a call expression ex: expression '(' (expression (',' expression)* )? ')'
func (*CallExprNode) String ¶
func (s *CallExprNode) String() string
type ChainNode ¶
ChainNode holds a term followed by a chain of field accesses (identifier starting with '.'). The names may be chained ('.x.y'). The periods are dropped from each ident.
type CommandNode ¶
type CommandNode struct { NodeBase CallExprNode }
CommandNode holds a command (a pipeline inside an evaluating action).
func (*CommandNode) String ¶
func (c *CommandNode) String() string
type ComparativeExprNode ¶
type ComparativeExprNode struct {
// contains filtered or unexported fields
}
ComparativeExprNode represents a comparative expression ex: expression ( '==' | '!=' ) expression
type Expression ¶
type Expression interface { Node }
type FieldNode ¶
FieldNode holds a field (identifier starting with '.'). The names may be chained ('.x.y'). The period is dropped from each ident.
type Func ¶
Func function implementing this type is called directly, which is faster than calling through reflect. If a function is being called many times in the execution of a template, you may consider implementing a wrapper for that function implementing a Func.
type IdentifierNode ¶
IdentifierNode holds an identifier.
func (*IdentifierNode) String ¶
func (i *IdentifierNode) String() string
type IfNode ¶
type IfNode struct {
BranchNode
}
IfNode represents an {{if}} action and its commands.
type InMemLoader ¶
type InMemLoader struct {
// contains filtered or unexported fields
}
InMemLoader is a simple in-memory loader storing template contents in a simple map. InMemLoader normalizes paths passed to its methods by converting any input path to a slash-delimited path, turning it into an absolute path by prepending a "/" if neccessary, and cleaning it (see path.Clean()). It is safe for concurrent use.
func (*InMemLoader) Delete ¶
func (l *InMemLoader) Delete(templatePath string)
Delete removes whatever contents are stored under the given path.
func (*InMemLoader) Exists ¶
func (l *InMemLoader) Exists(templatePath string) bool
Exists returns whether or not a template is indexed under this path.
func (*InMemLoader) Open ¶
func (l *InMemLoader) Open(templatePath string) (io.ReadCloser, error)
Open returns a template's contents, or an error if no template was added under this path using Set().
func (*InMemLoader) Set ¶
func (l *InMemLoader) Set(templatePath, contents string)
Set adds a template to the loader.
type IncludeNode ¶
type IncludeNode struct { NodeBase Name Expression Context Expression }
IncludeNode represents a {{include }} action.
func (*IncludeNode) String ¶
func (t *IncludeNode) String() string
type IndexExprNode ¶
type IndexExprNode struct { NodeBase Base Expression Index Expression }
func (*IndexExprNode) String ¶
func (s *IndexExprNode) String() string
type Loader ¶
type Loader interface { // Exists returns whether or not a template exists under the requested path. Exists(templatePath string) bool // Open returns the template's contents or an error if something went wrong. // Calls to Open() will always be preceded by a call to Exists() with the same `templatePath`. // It is the caller's duty to close the template. Open(templatePath string) (io.ReadCloser, error) }
Loader is a minimal interface required for loading templates.
Jet will build an absolute path (with slash delimiters) before looking up templates by resolving paths in extends/import/include statements:
- `{{ extends "/bar.jet" }}` will make Jet look up `/bar.jet` in the Loader unchanged, no matter where it occurs (since it's an absolute path) - `{{ include("\views\bar.jet") }}` will make Jet look up `/views/bar.jet` in the Loader, no matter where it occurs - `{{ import "bar.jet" }}` in `/views/foo.jet` will result in a lookup of `/views/bar.jet` - `{{ extends "./bar.jet" }}` in `/views/foo.jet` will result in a lookup of `/views/bar.jet` - `{{ import "../views\bar.jet" }}` in `/views/foo.jet` will result in a lookup of `/views/bar.jet` - `{{ include("../bar.jet") }}` in `/views/foo.jet` will result in a lookup of `/bar.jet` - `{{ import "../views/../bar.jet" }}` in `/views/foo.jet` will result in a lookup of `/bar.jet`
This means that the same template will always be looked up using the same path.
Jet will also try appending multiple file endings for convenience: `{{ extends "/bar" }}` will lookup `/bar`, `/bar.jet`, `/bar.html.jet` and `/bar.jet.html` (in that order). To avoid unneccessary lookups, use the full file name in your templates (so the first lookup is always a hit, or override this list of extensions using Set.SetExtensions().
type LogicalExprNode ¶
type LogicalExprNode struct {
// contains filtered or unexported fields
}
LogicalExprNode represents a boolean expression, 'and' or 'or' ex: expression ( '&&' | '||' ) expression
type MultiplicativeExprNode ¶
type MultiplicativeExprNode struct {
// contains filtered or unexported fields
}
MultiplicativeExprNode represents a multiplication, division, or module expression ex: expression ( '*' | '/' | '%' ) expression
type NilNode ¶
type NilNode struct {
NodeBase
}
NilNode holds the special identifier 'nil' representing an untyped nil constant.
type NodeType ¶
type NodeType int
NodeType identifies the type of a parse tree node.
const ( NodeText NodeType = iota //Plain text. NodeAction //A non-control action such as a field evaluation. NodeChain //A sequence of field accesses. NodeCommand //An element of a pipeline. NodeField //A field or method name. NodeIdentifier //An identifier; always a function name. NodeUnderscore //An underscore (discard in assignment, or slot in argument list for piped value) NodeList //A list of Nodes. NodePipe //A pipeline of commands. NodeSet //NodeWith //A with action. NodeInclude NodeBlock NodeYield NodeIf //An if action. NodeRange //A range action. NodeTry NodeReturn NodeString //A string constant. NodeNil //An untyped nil constant. NodeNumber //A numerical constant. NodeBool //A boolean constant. NodeAdditiveExpr NodeMultiplicativeExpr NodeComparativeExpr NodeNumericComparativeExpr NodeLogicalExpr NodeCallExpr NodeNotExpr NodeTernaryExpr NodeIndexExpr NodeSliceExpr )
type NotExprNode ¶
type NotExprNode struct { NodeBase Expr Expression }
NotExprNode represents a negate expression ex: '!' expression
func (*NotExprNode) String ¶
func (s *NotExprNode) String() string
type NumberNode ¶
type NumberNode struct { NodeBase IsInt bool //Number has an integral value. IsUint bool //Number has an unsigned integral value. IsFloat bool //Number has a floating-point value. IsComplex bool //Number is complex. Int64 int64 //The signed integer value. Uint64 uint64 //The unsigned integer value. Float64 float64 //The floating-point value. Complex128 complex128 //The complex value. Text string //The original textual representation from the input. }
NumberNode holds a number: signed or unsigned integer, float, or complex. The value is parsed and stored under all the types that can represent the value. This simulates in a small amount of code the behavior of Go's ideal constants.
func (*NumberNode) String ¶
func (n *NumberNode) String() string
type NumericComparativeExprNode ¶
type NumericComparativeExprNode struct {
// contains filtered or unexported fields
}
NumericComparativeExprNode represents a numeric comparative expression ex: expression ( '<' | '>' | '<=' | '>=' ) expression
type OSFileSystemLoader ¶
type OSFileSystemLoader struct {
// contains filtered or unexported fields
}
OSFileSystemLoader implements Loader interface using OS file system (os.File).
func NewOSFileSystemLoader ¶
func NewOSFileSystemLoader(dirPath string) *OSFileSystemLoader
NewOSFileSystemLoader returns an initialized OSFileSystemLoader.
func (*OSFileSystemLoader) Exists ¶
func (l *OSFileSystemLoader) Exists(templatePath string) bool
Exists returns true if a file is found under the template path after converting it to a file path using the OS's path seperator and joining it with the loader's directory path.
func (*OSFileSystemLoader) Open ¶
func (l *OSFileSystemLoader) Open(templatePath string) (io.ReadCloser, error)
Open returns the result of `os.Open()` on the file located using the same logic as Exists().
type Option ¶
type Option func(*Set)
Option is the type of option functions that can be used in NewSet().
func InDevelopmentMode ¶
func InDevelopmentMode() Option
InDevelopmentMode returns an option function that toggles development mode on, meaning the cache will always be bypassed and every template lookup will go to the loader.
func WithCache ¶
WithCache returns an option function that sets the cache to use for template parsing results. Use InDevelopmentMode() to disable caching of parsed templates. By default, Jet uses a concurrency-safe in-memory cache that holds templates forever.
func WithDelims ¶
WithDelims returns an option function that sets the delimiters to the specified strings. Parsed templates will inherit the settings. Not setting them leaves them at the default: `{{` and `}}`.
func WithSafeWriter ¶
func WithSafeWriter(w SafeWriter) Option
WithSafeWriter returns an option function that sets the escaping function to use when executing templates. By default, Jet uses a writer that takes care of HTML escaping. Pass nil to disable escaping.
func WithTemplateNameExtensions ¶
WithTemplateNameExtensions returns an option function that sets the extensions to try when looking up template names in the cache or loader. Default extensions are `""` (no extension), `".jet"`, `".html.jet"`, `".jet.html"`. Extensions will be tried in the order they are defined in the slice. WithTemplateNameExtensions panics when you pass in a nil or empty slice.
type PipeNode ¶
type PipeNode struct { NodeBase //The line number in the input. Deprecated: Kept for compatibility. Cmds []*CommandNode //The commands in lexical order. }
PipeNode holds a pipeline with optional declaration
type Pos ¶
type Pos int
Pos represents a byte position in the original input text from which this template was parsed.
type RangeNode ¶
type RangeNode struct {
BranchNode
}
RangeNode represents a {{range}} action and its commands.
type Ranger ¶
Ranger describes an interface for types that iterate over something. Implementing this interface means the ranger will be used when it's encountered on the right hand side of a range's "let" expression.
type Renderer ¶
type Renderer interface {
Render(*Runtime)
}
Renderer is used to detect if a value has its own rendering logic. If the value an action evaluates to implements this interface, it will not be printed using github.com/CloudyKit/fastprinter, instead, its Render() method will be called and is responsible for writing the value to the render output.
type RendererFunc ¶
type RendererFunc func(*Runtime)
RendererFunc func implementing interface Renderer
func (RendererFunc) Render ¶
func (renderer RendererFunc) Render(r *Runtime)
type ReturnNode ¶
type ReturnNode struct { NodeBase Value Expression }
func (*ReturnNode) String ¶
func (n *ReturnNode) String() string
type Runtime ¶
type Runtime struct {
// contains filtered or unexported fields
}
Runtime this type holds the state of the execution of an template
func (*Runtime) Let ¶
Let initialises a variable in the current template scope (possibly shadowing an existing variable of the same name in a parent scope).
func (*Runtime) LetGlobal ¶
LetGlobal sets or initialises a variable in the top-most template scope.
func (*Runtime) MustResolve ¶
Resolve calls resolve() and panics if there is an error.
func (*Runtime) Resolve ¶
Resolve calls resolve() and ignores any errors, meaning it may return a zero reflect.Value.
func (*Runtime) SetOrLet ¶
SetOrLet calls Set() (if a variable with the given name is visible from the current scope) or Let() (if there is no variable with the given name in the current or any parent scope).
func (*Runtime) YieldBlock ¶
YieldBlock yields a block in the current context, will panic if the context is not available
type SafeWriter ¶
SafeWriter is a function that writes bytes directly to the render output, without going through Jet's auto-escaping phase. Use/implement this if content should be escaped differently or not at all (see raw/unsafe builtins).
type Set ¶
type Set struct {
// contains filtered or unexported fields
}
Set is responsible to load, parse and cache templates. Every Jet template is associated with a Set.
func (*Set) AddGlobal ¶
AddGlobal adds a global variable into the Set, overriding any value previously set under the specified key. It returns the Set it was called on to allow for method chaining.
func (*Set) AddGlobalFunc ¶
AddGlobalFunc adds a global function into the Set, overriding any function previously set under the specified key. It returns the Set it was called on to allow for method chaining.
func (*Set) GetTemplate ¶
GetTemplate tries to find (and parse, if not yet parsed) the template at the specified path.
For example, GetTemplate("catalog/products.list") with extensions set to []string{"", ".html.jet",".jet"} will try to look for:
- catalog/products.list
- catalog/products.list.html.jet
- catalog/products.list.jet
in the set's templates cache, and if it can't find the template it will try to load the same paths via the loader, and, if parsed successfully, cache the template (unless running in development mode).
func (*Set) LookupGlobal ¶
LookupGlobal returns the global variable previously set under the specified key. It returns the nil interface and false if no variable exists under that key.
func (*Set) Parse ¶
Parse parses `contents` as if it were located at `templatePath`, but won't put the result into the cache. Any referenced template (e.g. via `extends` or `import` statements) will be tried to be loaded from the cache. If a referenced template has to be loaded and parsed, it will also not be put into the cache after parsing.
type SetNode ¶
type SetNode struct { NodeBase Let bool IndexExprGetLookup bool Left []Expression Right []Expression }
SetNode represents a set action, ident( ',' ident)* '=' expression ( ',' expression )*
type SliceExprNode ¶
type SliceExprNode struct { NodeBase Base Expression Index Expression EndIndex Expression }
func (*SliceExprNode) String ¶
func (s *SliceExprNode) String() string
type StringNode ¶
type StringNode struct { NodeBase Quoted string //The original text of the string, with quotes. Text string //The string, after quote processing. }
StringNode holds a string constant. The value has been "unquoted".
func (*StringNode) String ¶
func (s *StringNode) String() string
type Template ¶
type Template struct { Name string // name of the template represented by the tree. ParseName string // name of the top-level template during parsing, for error messages. Root *ListNode // top-level root of the tree. // contains filtered or unexported fields }
Template is the representation of a single parsed template.
type TernaryExprNode ¶
type TernaryExprNode struct { NodeBase Boolean, Left, Right Expression }
TernaryExprNod represents a ternary expression, ex: expression '?' expression ':' expression
func (*TernaryExprNode) String ¶
func (s *TernaryExprNode) String() string
type UnderscoreNode ¶
type UnderscoreNode struct {
NodeBase
}
UnderscoreNode is used for one of two things: - signals to discard the corresponding right side of an assignment - tells Jet where in a pipelined function call to inject the piped value
func (*UnderscoreNode) String ¶
func (i *UnderscoreNode) String() string
type VarMap ¶
func (VarMap) SortedKeys ¶
SortedKeys returns a sorted slice of VarMap keys
type YieldNode ¶
type YieldNode struct { NodeBase //The line number in the input. Deprecated: Kept for compatibility. Name string //The name of the template (unquoted). Parameters *BlockParameterList Expression Expression //The command to evaluate as dot for the template. Content *ListNode IsContent bool }
YieldNode represents a {{yield}} action
Source Files ¶
Directories ¶
Path | Synopsis |
---|---|
examples
|
|
asset_packaging
+Build ignore
|
+Build ignore |
todos
+Build ignore
|
+Build ignore |
loaders
|
|