parse

package
v1.0.0 Latest Latest
Warning

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

 Go to latest Published: Sep 26, 2023 License: MIT Imports: 0 Imported by: 0

Documentation

Overview

Package parse builds parse trees for templates as defined by text/template and html/template. Clients should use those packages to construct templates rather than this one, which provides shared internal data structures not intended for general use.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func IsEmptyTree 

func IsEmptyTree(n Node) bool

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

func Parse 

func Parse(name, text, leftDelim, rightDelim string, funcs ...map[string]interface{}) (treeSet map[string]*Tree, err error)

Parse returns a map from template name to parse.Tree, created by parsing the templates described in the argument string. The top-level template will be given the specified name. If an error is encountered, parsing stops and an empty map is returned with the error.

Types

type ActionNode 

type ActionNode struct {
	NodeType
	Line int
	Pipe *PipeNode
}

ActionNode holds an action (something bounded by delimiters). Control actions have their own nodes; ActionNode represents simple ones such as field evaluations.

func (*ActionNode) Copy 

func (a *ActionNode) Copy() Node

func (*ActionNode) String 

func (a *ActionNode) String() string

type BoolNode 

type BoolNode struct {
	NodeType
	True bool
}

BoolNode holds a boolean constant.

func (*BoolNode) Copy 

func (b *BoolNode) Copy() Node

func (*BoolNode) String 

func (b *BoolNode) String() string

type BranchNode 

type BranchNode struct {
	NodeType
	Line     int
	Pipe     *PipeNode
	List     *ListNode
	ElseList *ListNode
}

BranchNode is the common representation of if, range, and with.

func (*BranchNode) String 

func (b *BranchNode) String() string

type CommandNode 

type CommandNode struct {
	NodeType
	Args []Node
}

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

func (*CommandNode) Copy 

func (c *CommandNode) Copy() Node

func (*CommandNode) String 

func (c *CommandNode) String() string

type DotNode 

type DotNode bool

DotNode holds the special identifier '.'. It is represented by a nil pointer.

func (*DotNode) Copy 

func (d *DotNode) Copy() Node

func (*DotNode) String 

func (d *DotNode) String() string

func (*DotNode) Type 

func (d *DotNode) Type() NodeType

type FieldNode 

type FieldNode struct {
	NodeType
	Ident []string
}

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

func (*FieldNode) Copy 

func (f *FieldNode) Copy() Node

func (*FieldNode) String 

func (f *FieldNode) String() string

type IdentifierNode 

type IdentifierNode struct {
	NodeType
	Ident string
}

IdentifierNode holds an identifier.

func NewIdentifier 

func NewIdentifier(ident string) *IdentifierNode

NewIdentifier returns a new IdentifierNode with the given identifier name.

func (*IdentifierNode) Copy 

func (i *IdentifierNode) Copy() Node

func (*IdentifierNode) String 

func (i *IdentifierNode) String() string

type IfNode 

type IfNode struct {
	BranchNode
}

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

func (*IfNode) Copy 

func (i *IfNode) Copy() Node

type ListNode 

type ListNode struct {
	NodeType
	Nodes []Node
}

ListNode holds a sequence of nodes.

func (*ListNode) Copy 

func (l *ListNode) Copy() Node

func (*ListNode) CopyList 

func (l *ListNode) CopyList() *ListNode

func (*ListNode) String 

func (l *ListNode) String() string

type Node 

type Node interface {
	Type() NodeType
	String() string

	Copy() Node
}

A node is an element in the parse tree. The interface is trivial.

type NodeType 

type NodeType int

NodeType identifies the type of a parse tree node. 

const (
	NodeText NodeType = iota
	NodeAction
	NodeBool
	NodeCommand
	NodeDot

	NodeField
	NodeIdentifier
	NodeIf
	NodeList
	NodeNumber
	NodePipe
	NodeRange
	NodeString
	NodeTemplate
	NodeVariable
	NodeWith
)

func (NodeType) Type 

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 NumberNode 

type NumberNode struct {
	NodeType
	IsInt      bool
	IsUint     bool
	IsFloat    bool
	IsComplex  bool
	Int64      int64
	Uint64     uint64
	Float64    float64
	Complex128 complex128
	Text       string
}

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) Copy 

func (n *NumberNode) Copy() Node

func (*NumberNode) String 

func (n *NumberNode) String() string

type PipeNode 

type PipeNode struct {
	NodeType
	Line int
	Decl []*VariableNode
	Cmds []*CommandNode
}

PipeNode holds a pipeline with optional declaration

func (*PipeNode) Copy 

func (p *PipeNode) Copy() Node

func (*PipeNode) CopyPipe 

func (p *PipeNode) CopyPipe() *PipeNode

func (*PipeNode) String 

func (p *PipeNode) String() string

type RangeNode 

type RangeNode struct {
	BranchNode
}

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

func (*RangeNode) Copy 

func (r *RangeNode) Copy() Node

type StringNode 

type StringNode struct {
	NodeType
	Quoted string
	Text   string
}

StringNode holds a string constant. The value has been "unquoted".

func (*StringNode) Copy 

func (s *StringNode) Copy() Node

func (*StringNode) String 

func (s *StringNode) String() string

type TemplateNode 

type TemplateNode struct {
	NodeType
	Line int
	Name string
	Pipe *PipeNode
}

TemplateNode represents a {{template}} action.

func (*TemplateNode) Copy 

func (t *TemplateNode) Copy() Node

func (*TemplateNode) String 

func (t *TemplateNode) String() string

type TextNode 

type TextNode struct {
	NodeType
	Text []byte
}

TextNode holds plain text.

func (*TextNode) Copy 

func (t *TextNode) Copy() Node

func (*TextNode) String 

func (t *TextNode) String() string

type Tree 

type Tree struct {
	Name string
	Root *ListNode
	// contains filtered or unexported fields
}

Tree is the representation of a single parsed template.

func New 

func New(name string, funcs ...map[string]interface{}) *Tree

New allocates a new parse tree with the given name.

func (*Tree) Parse 

func (t *Tree) Parse(s, leftDelim, rightDelim string, treeSet map[string]*Tree, funcs ...map[string]interface{}) (tree *Tree, err error)

Parse parses the template definition string to construct a representation of the template for execution. If either action delimiter string is empty, the default ("{{" or "}}") is used. Embedded template definitions are added to the treeSet map.

type VariableNode 

type VariableNode struct {
	NodeType
	Ident []string
}

VariableNode holds a list of variable names. The dollar sign is part of the name.

func (*VariableNode) Copy 

func (v *VariableNode) Copy() Node

func (*VariableNode) String 

func (v *VariableNode) String() string

type WithNode 

type WithNode struct {
	BranchNode
}

WithNode represents a {{with}} action and its commands.

func (*WithNode) Copy 

func (w *WithNode) Copy() Node

Source Files

View all Source files

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.