jet: github.com/CloudyKit/jet Index | Files | Directories

package jet

import "github.com/CloudyKit/jet"

Index

Package Files

constructors.go default.go eval.go func.go lex.go loader.go node.go parse.go template.go

func IsEmptyTree Uses

func IsEmptyTree(n Node) bool

IsEmptyTree reports whether this tree (node) is empty of everything but space.

type ActionNode Uses

type ActionNode struct {
    NodeBase
    Set  *SetNode
    Pipe *PipeNode
}

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 Uses

func (a *ActionNode) String() string

type AdditiveExprNode Uses

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

AdditiveExprNode represents an add or subtract expression ex: expression ( '+' | '-' ) expression

func (*AdditiveExprNode) String Uses

func (node *AdditiveExprNode) String() string

type Arguments Uses

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

Arguments holds the arguments passed to jet.Func.

func (*Arguments) Get Uses

func (a *Arguments) Get(argumentIndex int) reflect.Value

Get gets an argument by index.

func (*Arguments) NumOfArguments Uses

func (a *Arguments) NumOfArguments() int

NumOfArguments returns the number of arguments

func (*Arguments) Panicf Uses

func (a *Arguments) Panicf(format string, v ...interface{})

Panicf panics with formatted error message.

func (*Arguments) RequireNumOfArguments Uses

func (a *Arguments) RequireNumOfArguments(funcname string, min, max int)

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.

func (*Arguments) Runtime Uses

func (a *Arguments) Runtime() *Runtime

Runtime get the Runtime context

type BlockNode Uses

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.

func (*BlockNode) String Uses

func (t *BlockNode) String() string

type BlockParameter Uses

type BlockParameter struct {
    Identifier string
    Expression Expression
}

type BlockParameterList Uses

type BlockParameterList struct {
    NodeBase
    List []BlockParameter
}

func (*BlockParameterList) Param Uses

func (bplist *BlockParameterList) Param(name string) (Expression, int)

func (*BlockParameterList) String Uses

func (bplist *BlockParameterList) String() (str string)

type BoolNode Uses

type BoolNode struct {
    NodeBase
    True bool //The value of the boolean constant.
}

BoolNode holds a boolean constant.

func (*BoolNode) String Uses

func (b *BoolNode) String() string

type BranchNode Uses

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 Uses

func (b *BranchNode) String() string

type CallExprNode Uses

type CallExprNode struct {
    NodeBase
    BaseExpr Expression
    Args     []Expression
}

CallExprNode represents a call expression ex: expression '(' (expression (',' expression)* )? ')'

func (*CallExprNode) String Uses

func (s *CallExprNode) String() string

type ChainNode Uses

type ChainNode struct {
    NodeBase
    Node  Node
    Field []string //The identifiers in lexical order.
}

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.

func (*ChainNode) Add Uses

func (c *ChainNode) Add(field string)

Add adds the named field (which should start with a period) to the end of the chain.

func (*ChainNode) String Uses

func (c *ChainNode) String() string

type CommandNode Uses

type CommandNode struct {
    NodeBase
    Call     bool
    BaseExpr Expression
    Args     []Expression
}

CommandNode holds a command (a pipeline inside an evaluating action).

func (*CommandNode) String Uses

func (c *CommandNode) String() string

type ComparativeExprNode Uses

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

ComparativeExprNode represents a comparative expression ex: expression ( '==' | '!=' ) expression

func (*ComparativeExprNode) String Uses

func (node *ComparativeExprNode) String() string

type Expression Uses

type Expression interface {
    Node
}

type FieldNode Uses

type FieldNode struct {
    NodeBase
    Ident []string //The identifiers in lexical order.
}

FieldNode holds a field (identifier starting with '.'). The names may be chained ('.x.y'). The period is dropped from each ident.

func (*FieldNode) String Uses

func (f *FieldNode) String() string

type Func Uses

type Func func(Arguments) reflect.Value

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 Uses

type IdentifierNode struct {
    NodeBase
    Ident string //The identifier's name.
}

IdentifierNode holds an identifier.

func (*IdentifierNode) String Uses

func (i *IdentifierNode) String() string

type IfNode Uses

type IfNode struct {
    BranchNode
}

IfNode represents an {{if}} action and its commands.

type IncludeNode Uses

type IncludeNode struct {
    NodeBase
    Name       Expression
    Expression Expression
}

IncludeNode represents a {{include }} action.

func (*IncludeNode) String Uses

func (t *IncludeNode) String() string

type IndexExprNode Uses

type IndexExprNode struct {
    NodeBase
    Base  Expression
    Index Expression
}

func (*IndexExprNode) String Uses

func (s *IndexExprNode) String() string

type ListNode Uses

type ListNode struct {
    NodeBase
    Nodes []Node //The element nodes in lexical order.
}

ListNode holds a sequence of nodes.

func (*ListNode) String Uses

func (l *ListNode) String() string

type Loader Uses

type Loader interface {
    // Open opens the underlying reader with template content.
    Open(name string) (io.ReadCloser, error)
    // Exists checks for template existence and returns full path.
    Exists(name string) (string, bool)
}

Loader is a minimal interface required for loading templates.

type LogicalExprNode Uses

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

LogicalExprNode represents a boolean expression, 'and' or 'or' ex: expression ( '&&' | '||' ) expression

func (*LogicalExprNode) String Uses

func (node *LogicalExprNode) String() string

type MultiplicativeExprNode Uses

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

MultiplicativeExprNode represents a multiplication, division, or module expression ex: expression ( '*' | '/' | '%' ) expression

func (*MultiplicativeExprNode) String Uses

func (node *MultiplicativeExprNode) String() string

type NilNode Uses

type NilNode struct {
    NodeBase
}

NilNode holds the special identifier 'nil' representing an untyped nil constant.

func (*NilNode) String Uses

func (n *NilNode) String() string

type Node Uses

type Node interface {
    Type() NodeType
    String() string
    Position() Pos
    // contains filtered or unexported methods
}

type NodeBase Uses

type NodeBase struct {
    TemplateName string
    Line         int
    NodeType
    Pos
}

type NodeType Uses

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.
    NodeIf         //An if action.
    NodeList       //A list of Nodes.
    NodePipe       //A pipeline of commands.
    NodeRange      //A range action.

    //NodeWith                       //A with action.
    NodeBlock
    NodeInclude
    NodeYield
    NodeSet

    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
)

func (NodeType) Type Uses

func (t NodeType) Type() NodeType

Type returns itself and provides an easy default implementation for embedding in a Node. Embedded in all non-trivial Nodes.

type NotExprNode Uses

type NotExprNode struct {
    NodeBase
    Expr Expression
}

NotExprNode represents a negate expression ex: '!' expression

func (*NotExprNode) String Uses

func (s *NotExprNode) String() string

type NumberNode Uses

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 Uses

func (n *NumberNode) String() string

type NumericComparativeExprNode Uses

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

NumericComparativeExprNode represents a numeric comparative expression ex: expression ( '<' | '>' | '<=' | '>=' ) expression

func (*NumericComparativeExprNode) String Uses

func (node *NumericComparativeExprNode) String() string

type OSFileSystemLoader Uses

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

OSFileSystemLoader implements Loader interface using OS file system (os.File).

func NewOSFileSystemLoader Uses

func NewOSFileSystemLoader(paths ...string) *OSFileSystemLoader

NewOSFileSystemLoader returns an initialized OSFileSystemLoader.

func (*OSFileSystemLoader) AddGopathPath Uses

func (l *OSFileSystemLoader) AddGopathPath(path string)

AddGopathPath adds a path located in the GOPATH. Example: l.AddGopathPath("github.com/CloudyKit/jet/example/views")

func (*OSFileSystemLoader) AddPath Uses

func (l *OSFileSystemLoader) AddPath(path string)

AddPath adds the path to the internal list of paths searched when loading templates.

func (*OSFileSystemLoader) Exists Uses

func (l *OSFileSystemLoader) Exists(name string) (string, bool)

Exists checks if the template name exists by walking the list of template paths returns string with the full path of the template and bool true if the template file was found

func (*OSFileSystemLoader) Open Uses

func (l *OSFileSystemLoader) Open(name string) (io.ReadCloser, error)

Open opens a file from OS file system.

type PipeNode Uses

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

func (*PipeNode) String Uses

func (p *PipeNode) String() string

type Pos Uses

type Pos int

Pos represents a byte position in the original input text from which this template was parsed.

func (Pos) Position Uses

func (p Pos) Position() Pos

type RangeNode Uses

type RangeNode struct {
    BranchNode
}

RangeNode represents a {{range}} action and its commands.

type Ranger Uses

type Ranger interface {
    Range() (reflect.Value, reflect.Value, bool)
}

Ranger a value implementing a ranger interface is able to iterate on his value and can be used directly in a range statement

type Renderer Uses

type Renderer interface {
    Render(*Runtime)
}

Renderer any resulting value from an expression in an action that implements this interface will not be printed, instead, we will invoke his Render() method which will be responsible to render his self

type RendererFunc Uses

type RendererFunc func(*Runtime)

RendererFunc func implementing interface Renderer

func (RendererFunc) Render Uses

func (renderer RendererFunc) Render(r *Runtime)

type Runtime Uses

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

Runtime this type holds the state of the execution of an template

func (*Runtime) Context Uses

func (r *Runtime) Context() reflect.Value

Context returns the current context value

func (*Runtime) Resolve Uses

func (state *Runtime) Resolve(name string) reflect.Value

Resolve resolves a value from the execution context

func (*Runtime) Set Uses

func (state *Runtime) Set(name string, val interface{})

Set sets variable ${name} in the current template scope

func (Runtime) Write Uses

func (w Runtime) Write(b []byte) (int, error)

func (*Runtime) YieldBlock Uses

func (st *Runtime) YieldBlock(name string, context interface{})

YieldBlock yields a block in the current context, will panic if the context is not available

func (*Runtime) YieldTemplate Uses

func (st *Runtime) YieldTemplate(name string, context interface{})

YieldTemplate yields a template same as include

type SafeWriter Uses

type SafeWriter func(io.Writer, []byte)

SafeWriter escapee func. Functions implementing this type will write directly into the writer, skipping the escape phase; use this type to create special types of escapee funcs.

type Set Uses

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

Set is responsible to load,invoke parse and cache templates and relations every jet template is associated with one set. create a set with jet.NewSet(escapeeFn) returns a pointer to the Set

func NewHTMLSet Uses

func NewHTMLSet(dirs ...string) *Set

NewHTMLSet creates a new set, dirs is a list of directories to be searched for templates

func NewHTMLSetLoader Uses

func NewHTMLSetLoader(loader Loader) *Set

NewHTMLSetLoader creates a new set with custom Loader

func NewSet Uses

func NewSet(escapee SafeWriter, dirs ...string) *Set

NewSet creates a new set, dirs is a list of directories to be searched for templates

func NewSetLoader Uses

func NewSetLoader(escapee SafeWriter, loader Loader) *Set

NewSetLoader creates a new set with custom Loader

func (*Set) AddGlobal Uses

func (s *Set) AddGlobal(key string, i interface{}) *Set

AddGlobal add or set a global variable into the Set

func (*Set) AddGlobalFunc Uses

func (s *Set) AddGlobalFunc(key string, fn Func) *Set

func (*Set) AddGopathPath Uses

func (s *Set) AddGopathPath(path string)

AddGopathPath add path based on GOPATH env to the lookup list, when loading a template the Set will look into the lookup list for the file matching the provided name.

func (*Set) AddPath Uses

func (s *Set) AddPath(path string)

AddPath add path to the lookup list, when loading a template the Set will look into the lookup list for the file matching the provided name.

func (*Set) Delims Uses

func (s *Set) Delims(left, right string)

Delims sets the delimiters to the specified strings. Parsed templates will inherit the settings. Not setting them leaves them at the default: {{ or }}.

func (*Set) GetTemplate Uses

func (s *Set) GetTemplate(name string) (template *Template, err error)

func (*Set) LoadTemplate Uses

func (s *Set) LoadTemplate(name, content string) (template *Template, err error)

func (*Set) LookupGlobal Uses

func (a *Set) LookupGlobal(key string) (val interface{}, found bool)

func (*Set) Parse Uses

func (s *Set) Parse(name, content string) (*Template, error)

Parse parses the template, this method will link the template to the set but not the set to

func (*Set) SetDevelopmentMode Uses

func (s *Set) SetDevelopmentMode(b bool) *Set

SetDevelopmentMode set's development mode on/off, in development mode template will be recompiled on every run

type SetNode Uses

type SetNode struct {
    NodeBase
    Let                bool
    IndexExprGetLookup bool
    Left               []Expression
    Right              []Expression
}

SetNode represents a set action, ident( ',' ident)* '=' expression ( ',' expression )*

func (*SetNode) String Uses

func (set *SetNode) String() string

type SliceExprNode Uses

type SliceExprNode struct {
    NodeBase
    Base     Expression
    Index    Expression
    EndIndex Expression
}

func (*SliceExprNode) String Uses

func (s *SliceExprNode) String() string

type StringNode Uses

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 Uses

func (s *StringNode) String() string

type Template Uses

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.

func (*Template) Execute Uses

func (t *Template) Execute(w io.Writer, variables VarMap, data interface{}) error

Execute executes the template in the w Writer

func (*Template) ExecuteI18N Uses

func (t *Template) ExecuteI18N(translator Translator, w io.Writer, variables VarMap, data interface{}) (err error)

func (*Template) String Uses

func (t *Template) String() (template string)

type TernaryExprNode Uses

type TernaryExprNode struct {
    NodeBase
    Boolean, Left, Right Expression
}

TernaryExprNod represents a ternary expression, ex: expression '?' expression ':' expression

func (*TernaryExprNode) String Uses

func (s *TernaryExprNode) String() string

type TextNode Uses

type TextNode struct {
    NodeBase
    Text []byte
}

TextNode holds plain text.

func (*TextNode) String Uses

func (t *TextNode) String() string

type Translator Uses

type Translator interface {
    Msg(key, defaultValue string) string
    Trans(format, defaultFormat string, v ...interface{}) string
}

type VarMap Uses

type VarMap map[string]reflect.Value

func (VarMap) Set Uses

func (scope VarMap) Set(name string, v interface{}) VarMap

func (VarMap) SetFunc Uses

func (scope VarMap) SetFunc(name string, v Func) VarMap

func (VarMap) SetWriter Uses

func (scope VarMap) SetWriter(name string, v SafeWriter) VarMap

type YieldNode Uses

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

func (*YieldNode) String Uses

func (t *YieldNode) String() string

Directories

PathSynopsis
jettest
loaders/httpfs
loaders/multi
utils
yield

Package jet imports 20 packages (graph) and is imported by 39 packages. Updated 2019-10-04. Refresh now. Tools for package owners.