id
int32 0
167k
| repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
list | docstring
stringlengths 6
2.61k
| docstring_tokens
list | sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
500 |
aymerick/raymond
|
helper.go
|
Eval
|
func (options *Options) Eval(ctx interface{}, field string) interface{} {
if ctx == nil {
return nil
}
if field == "" {
return nil
}
val := options.eval.evalField(reflect.ValueOf(ctx), field, false)
if !val.IsValid() {
return nil
}
return val.Interface()
}
|
go
|
func (options *Options) Eval(ctx interface{}, field string) interface{} {
if ctx == nil {
return nil
}
if field == "" {
return nil
}
val := options.eval.evalField(reflect.ValueOf(ctx), field, false)
if !val.IsValid() {
return nil
}
return val.Interface()
}
|
[
"func",
"(",
"options",
"*",
"Options",
")",
"Eval",
"(",
"ctx",
"interface",
"{",
"}",
",",
"field",
"string",
")",
"interface",
"{",
"}",
"{",
"if",
"ctx",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"field",
"==",
"\"",
"\"",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"val",
":=",
"options",
".",
"eval",
".",
"evalField",
"(",
"reflect",
".",
"ValueOf",
"(",
"ctx",
")",
",",
"field",
",",
"false",
")",
"\n",
"if",
"!",
"val",
".",
"IsValid",
"(",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"return",
"val",
".",
"Interface",
"(",
")",
"\n",
"}"
] |
// Eval evaluates field for given context.
|
[
"Eval",
"evaluates",
"field",
"for",
"given",
"context",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/helper.go#L258-L273
|
501 |
aymerick/raymond
|
helper.go
|
isIncludableZero
|
func (options *Options) isIncludableZero() bool {
b, ok := options.HashProp("includeZero").(bool)
if ok && b {
nb, ok := options.Param(0).(int)
if ok && nb == 0 {
return true
}
}
return false
}
|
go
|
func (options *Options) isIncludableZero() bool {
b, ok := options.HashProp("includeZero").(bool)
if ok && b {
nb, ok := options.Param(0).(int)
if ok && nb == 0 {
return true
}
}
return false
}
|
[
"func",
"(",
"options",
"*",
"Options",
")",
"isIncludableZero",
"(",
")",
"bool",
"{",
"b",
",",
"ok",
":=",
"options",
".",
"HashProp",
"(",
"\"",
"\"",
")",
".",
"(",
"bool",
")",
"\n",
"if",
"ok",
"&&",
"b",
"{",
"nb",
",",
"ok",
":=",
"options",
".",
"Param",
"(",
"0",
")",
".",
"(",
"int",
")",
"\n",
"if",
"ok",
"&&",
"nb",
"==",
"0",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"false",
"\n",
"}"
] |
//
// Misc
//
// isIncludableZero returns true if 'includeZero' option is set and first param is the number 0
|
[
"Misc",
"isIncludableZero",
"returns",
"true",
"if",
"includeZero",
"option",
"is",
"set",
"and",
"first",
"param",
"is",
"the",
"number",
"0"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/helper.go#L280-L290
|
502 |
aymerick/raymond
|
lexer/lexer.go
|
run
|
func (l *Lexer) run() {
for l.nextFunc = lexContent; l.nextFunc != nil; {
l.nextFunc = l.nextFunc(l)
}
}
|
go
|
func (l *Lexer) run() {
for l.nextFunc = lexContent; l.nextFunc != nil; {
l.nextFunc = l.nextFunc(l)
}
}
|
[
"func",
"(",
"l",
"*",
"Lexer",
")",
"run",
"(",
")",
"{",
"for",
"l",
".",
"nextFunc",
"=",
"lexContent",
";",
"l",
".",
"nextFunc",
"!=",
"nil",
";",
"{",
"l",
".",
"nextFunc",
"=",
"l",
".",
"nextFunc",
"(",
"l",
")",
"\n",
"}",
"\n",
"}"
] |
// run starts lexical analysis
|
[
"run",
"starts",
"lexical",
"analysis"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/lexer/lexer.go#L135-L139
|
503 |
aymerick/raymond
|
lexer/lexer.go
|
emit
|
func (l *Lexer) emit(kind TokenKind) {
l.produce(kind, l.input[l.start:l.pos])
}
|
go
|
func (l *Lexer) emit(kind TokenKind) {
l.produce(kind, l.input[l.start:l.pos])
}
|
[
"func",
"(",
"l",
"*",
"Lexer",
")",
"emit",
"(",
"kind",
"TokenKind",
")",
"{",
"l",
".",
"produce",
"(",
"kind",
",",
"l",
".",
"input",
"[",
"l",
".",
"start",
":",
"l",
".",
"pos",
"]",
")",
"\n",
"}"
] |
// emit emits a new scanned token
|
[
"emit",
"emits",
"a",
"new",
"scanned",
"token"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/lexer/lexer.go#L166-L168
|
504 |
aymerick/raymond
|
lexer/lexer.go
|
emitContent
|
func (l *Lexer) emitContent() {
if l.pos > l.start {
l.emit(TokenContent)
}
}
|
go
|
func (l *Lexer) emitContent() {
if l.pos > l.start {
l.emit(TokenContent)
}
}
|
[
"func",
"(",
"l",
"*",
"Lexer",
")",
"emitContent",
"(",
")",
"{",
"if",
"l",
".",
"pos",
">",
"l",
".",
"start",
"{",
"l",
".",
"emit",
"(",
"TokenContent",
")",
"\n",
"}",
"\n",
"}"
] |
// emitContent emits scanned content
|
[
"emitContent",
"emits",
"scanned",
"content"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/lexer/lexer.go#L171-L175
|
505 |
aymerick/raymond
|
lexer/lexer.go
|
emitString
|
func (l *Lexer) emitString(delimiter rune) {
str := l.input[l.start:l.pos]
// replace escaped delimiters
str = strings.Replace(str, "\\"+string(delimiter), string(delimiter), -1)
l.produce(TokenString, str)
}
|
go
|
func (l *Lexer) emitString(delimiter rune) {
str := l.input[l.start:l.pos]
// replace escaped delimiters
str = strings.Replace(str, "\\"+string(delimiter), string(delimiter), -1)
l.produce(TokenString, str)
}
|
[
"func",
"(",
"l",
"*",
"Lexer",
")",
"emitString",
"(",
"delimiter",
"rune",
")",
"{",
"str",
":=",
"l",
".",
"input",
"[",
"l",
".",
"start",
":",
"l",
".",
"pos",
"]",
"\n\n",
"// replace escaped delimiters",
"str",
"=",
"strings",
".",
"Replace",
"(",
"str",
",",
"\"",
"\\\\",
"\"",
"+",
"string",
"(",
"delimiter",
")",
",",
"string",
"(",
"delimiter",
")",
",",
"-",
"1",
")",
"\n\n",
"l",
".",
"produce",
"(",
"TokenString",
",",
"str",
")",
"\n",
"}"
] |
// emitString emits a scanned string
|
[
"emitString",
"emits",
"a",
"scanned",
"string"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/lexer/lexer.go#L178-L185
|
506 |
aymerick/raymond
|
lexer/lexer.go
|
peek
|
func (l *Lexer) peek() rune {
r := l.next()
l.backup()
return r
}
|
go
|
func (l *Lexer) peek() rune {
r := l.next()
l.backup()
return r
}
|
[
"func",
"(",
"l",
"*",
"Lexer",
")",
"peek",
"(",
")",
"rune",
"{",
"r",
":=",
"l",
".",
"next",
"(",
")",
"\n",
"l",
".",
"backup",
"(",
")",
"\n",
"return",
"r",
"\n",
"}"
] |
// peek returns but does not consume the next character in the input
|
[
"peek",
"returns",
"but",
"does",
"not",
"consume",
"the",
"next",
"character",
"in",
"the",
"input"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/lexer/lexer.go#L188-L192
|
507 |
aymerick/raymond
|
lexer/lexer.go
|
accept
|
func (l *Lexer) accept(valid string) bool {
if strings.IndexRune(valid, l.next()) >= 0 {
return true
}
l.backup()
return false
}
|
go
|
func (l *Lexer) accept(valid string) bool {
if strings.IndexRune(valid, l.next()) >= 0 {
return true
}
l.backup()
return false
}
|
[
"func",
"(",
"l",
"*",
"Lexer",
")",
"accept",
"(",
"valid",
"string",
")",
"bool",
"{",
"if",
"strings",
".",
"IndexRune",
"(",
"valid",
",",
"l",
".",
"next",
"(",
")",
")",
">=",
"0",
"{",
"return",
"true",
"\n",
"}",
"\n\n",
"l",
".",
"backup",
"(",
")",
"\n\n",
"return",
"false",
"\n",
"}"
] |
// accept scans the next character if it is included in given string
|
[
"accept",
"scans",
"the",
"next",
"character",
"if",
"it",
"is",
"included",
"in",
"given",
"string"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/lexer/lexer.go#L207-L215
|
508 |
aymerick/raymond
|
lexer/lexer.go
|
acceptRun
|
func (l *Lexer) acceptRun(valid string) {
for strings.IndexRune(valid, l.next()) >= 0 {
}
l.backup()
}
|
go
|
func (l *Lexer) acceptRun(valid string) {
for strings.IndexRune(valid, l.next()) >= 0 {
}
l.backup()
}
|
[
"func",
"(",
"l",
"*",
"Lexer",
")",
"acceptRun",
"(",
"valid",
"string",
")",
"{",
"for",
"strings",
".",
"IndexRune",
"(",
"valid",
",",
"l",
".",
"next",
"(",
")",
")",
">=",
"0",
"{",
"}",
"\n\n",
"l",
".",
"backup",
"(",
")",
"\n",
"}"
] |
// acceptRun scans all following characters that are part of given string
|
[
"acceptRun",
"scans",
"all",
"following",
"characters",
"that",
"are",
"part",
"of",
"given",
"string"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/lexer/lexer.go#L218-L223
|
509 |
aymerick/raymond
|
lexer/lexer.go
|
errorf
|
func (l *Lexer) errorf(format string, args ...interface{}) lexFunc {
l.tokens <- Token{TokenError, fmt.Sprintf(format, args...), l.start, l.line}
return nil
}
|
go
|
func (l *Lexer) errorf(format string, args ...interface{}) lexFunc {
l.tokens <- Token{TokenError, fmt.Sprintf(format, args...), l.start, l.line}
return nil
}
|
[
"func",
"(",
"l",
"*",
"Lexer",
")",
"errorf",
"(",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"lexFunc",
"{",
"l",
".",
"tokens",
"<-",
"Token",
"{",
"TokenError",
",",
"fmt",
".",
"Sprintf",
"(",
"format",
",",
"args",
"...",
")",
",",
"l",
".",
"start",
",",
"l",
".",
"line",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// errorf emits an error token
|
[
"errorf",
"emits",
"an",
"error",
"token"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/lexer/lexer.go#L226-L229
|
510 |
aymerick/raymond
|
lexer/lexer.go
|
isString
|
func (l *Lexer) isString(str string) bool {
return strings.HasPrefix(l.input[l.pos:], str)
}
|
go
|
func (l *Lexer) isString(str string) bool {
return strings.HasPrefix(l.input[l.pos:], str)
}
|
[
"func",
"(",
"l",
"*",
"Lexer",
")",
"isString",
"(",
"str",
"string",
")",
"bool",
"{",
"return",
"strings",
".",
"HasPrefix",
"(",
"l",
".",
"input",
"[",
"l",
".",
"pos",
":",
"]",
",",
"str",
")",
"\n",
"}"
] |
// isString returns true if content at current scanning position starts with given string
|
[
"isString",
"returns",
"true",
"if",
"content",
"at",
"current",
"scanning",
"position",
"starts",
"with",
"given",
"string"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/lexer/lexer.go#L232-L234
|
511 |
aymerick/raymond
|
lexer/lexer.go
|
findRegexp
|
func (l *Lexer) findRegexp(r *regexp.Regexp) string {
return r.FindString(l.input[l.pos:])
}
|
go
|
func (l *Lexer) findRegexp(r *regexp.Regexp) string {
return r.FindString(l.input[l.pos:])
}
|
[
"func",
"(",
"l",
"*",
"Lexer",
")",
"findRegexp",
"(",
"r",
"*",
"regexp",
".",
"Regexp",
")",
"string",
"{",
"return",
"r",
".",
"FindString",
"(",
"l",
".",
"input",
"[",
"l",
".",
"pos",
":",
"]",
")",
"\n",
"}"
] |
// findRegexp returns the first string from current scanning position that matches given regular expression
|
[
"findRegexp",
"returns",
"the",
"first",
"string",
"from",
"current",
"scanning",
"position",
"that",
"matches",
"given",
"regular",
"expression"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/lexer/lexer.go#L237-L239
|
512 |
aymerick/raymond
|
lexer/lexer.go
|
indexRegexp
|
func (l *Lexer) indexRegexp(r *regexp.Regexp) int {
loc := r.FindStringIndex(l.input[l.pos:])
if loc == nil {
return -1
}
return loc[0]
}
|
go
|
func (l *Lexer) indexRegexp(r *regexp.Regexp) int {
loc := r.FindStringIndex(l.input[l.pos:])
if loc == nil {
return -1
}
return loc[0]
}
|
[
"func",
"(",
"l",
"*",
"Lexer",
")",
"indexRegexp",
"(",
"r",
"*",
"regexp",
".",
"Regexp",
")",
"int",
"{",
"loc",
":=",
"r",
".",
"FindStringIndex",
"(",
"l",
".",
"input",
"[",
"l",
".",
"pos",
":",
"]",
")",
"\n",
"if",
"loc",
"==",
"nil",
"{",
"return",
"-",
"1",
"\n",
"}",
"\n",
"return",
"loc",
"[",
"0",
"]",
"\n",
"}"
] |
// indexRegexp returns the index of the first string from current scanning position that matches given regular expression
//
// It returns -1 if not found
|
[
"indexRegexp",
"returns",
"the",
"index",
"of",
"the",
"first",
"string",
"from",
"current",
"scanning",
"position",
"that",
"matches",
"given",
"regular",
"expression",
"It",
"returns",
"-",
"1",
"if",
"not",
"found"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/lexer/lexer.go#L244-L250
|
513 |
aymerick/raymond
|
lexer/lexer.go
|
lexCloseMustache
|
func lexCloseMustache(l *Lexer) lexFunc {
var str string
var tok TokenKind
if str = l.findRegexp(rCloseRaw); str != "" {
// }}}}
tok = TokenCloseRawBlock
} else if str = l.findRegexp(rCloseUnescaped); str != "" {
// }}}
tok = TokenCloseUnescaped
} else if str = l.findRegexp(rClose); str != "" {
// }}
tok = TokenClose
} else {
// this is rotten
panic("Current pos MUST be a closing mustache")
}
l.pos += len(str)
l.emit(tok)
return lexContent
}
|
go
|
func lexCloseMustache(l *Lexer) lexFunc {
var str string
var tok TokenKind
if str = l.findRegexp(rCloseRaw); str != "" {
// }}}}
tok = TokenCloseRawBlock
} else if str = l.findRegexp(rCloseUnescaped); str != "" {
// }}}
tok = TokenCloseUnescaped
} else if str = l.findRegexp(rClose); str != "" {
// }}
tok = TokenClose
} else {
// this is rotten
panic("Current pos MUST be a closing mustache")
}
l.pos += len(str)
l.emit(tok)
return lexContent
}
|
[
"func",
"lexCloseMustache",
"(",
"l",
"*",
"Lexer",
")",
"lexFunc",
"{",
"var",
"str",
"string",
"\n",
"var",
"tok",
"TokenKind",
"\n\n",
"if",
"str",
"=",
"l",
".",
"findRegexp",
"(",
"rCloseRaw",
")",
";",
"str",
"!=",
"\"",
"\"",
"{",
"// }}}}",
"tok",
"=",
"TokenCloseRawBlock",
"\n",
"}",
"else",
"if",
"str",
"=",
"l",
".",
"findRegexp",
"(",
"rCloseUnescaped",
")",
";",
"str",
"!=",
"\"",
"\"",
"{",
"// }}}",
"tok",
"=",
"TokenCloseUnescaped",
"\n",
"}",
"else",
"if",
"str",
"=",
"l",
".",
"findRegexp",
"(",
"rClose",
")",
";",
"str",
"!=",
"\"",
"\"",
"{",
"// }}",
"tok",
"=",
"TokenClose",
"\n",
"}",
"else",
"{",
"// this is rotten",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"l",
".",
"pos",
"+=",
"len",
"(",
"str",
")",
"\n",
"l",
".",
"emit",
"(",
"tok",
")",
"\n\n",
"return",
"lexContent",
"\n",
"}"
] |
// lexCloseMustache scans }} or ~}}
|
[
"lexCloseMustache",
"scans",
"}}",
"or",
"~",
"}}"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/lexer/lexer.go#L373-L395
|
514 |
aymerick/raymond
|
lexer/lexer.go
|
lexExpression
|
func lexExpression(l *Lexer) lexFunc {
// search close mustache delimiter
if l.isString(closeMustache) || l.isString(closeStripMustache) || l.isString(closeUnescapedStripMustache) {
return lexCloseMustache
}
// search some patterns before advancing scanning position
// "as |"
if str := l.findRegexp(rOpenBlockParams); str != "" {
l.pos += len(str)
l.emit(TokenOpenBlockParams)
return lexExpression
}
// ..
if l.isString("..") {
l.pos += len("..")
l.emit(TokenID)
return lexExpression
}
// .
if str := l.findRegexp(rDotID); str != "" {
l.pos += len(".")
l.emit(TokenID)
return lexExpression
}
// true
if str := l.findRegexp(rTrue); str != "" {
l.pos += len("true")
l.emit(TokenBoolean)
return lexExpression
}
// false
if str := l.findRegexp(rFalse); str != "" {
l.pos += len("false")
l.emit(TokenBoolean)
return lexExpression
}
// let's scan next character
switch r := l.next(); {
case r == eof:
return l.errorf("Unclosed expression")
case isIgnorable(r):
return lexIgnorable
case r == '(':
l.emit(TokenOpenSexpr)
case r == ')':
l.emit(TokenCloseSexpr)
case r == '=':
l.emit(TokenEquals)
case r == '@':
l.emit(TokenData)
case r == '"' || r == '\'':
l.backup()
return lexString
case r == '/' || r == '.':
l.emit(TokenSep)
case r == '|':
l.emit(TokenCloseBlockParams)
case r == '+' || r == '-' || (r >= '0' && r <= '9'):
l.backup()
return lexNumber
case r == '[':
return lexPathLiteral
case strings.IndexRune(unallowedIDChars, r) < 0:
l.backup()
return lexIdentifier
default:
return l.errorf("Unexpected character in expression: '%c'", r)
}
return lexExpression
}
|
go
|
func lexExpression(l *Lexer) lexFunc {
// search close mustache delimiter
if l.isString(closeMustache) || l.isString(closeStripMustache) || l.isString(closeUnescapedStripMustache) {
return lexCloseMustache
}
// search some patterns before advancing scanning position
// "as |"
if str := l.findRegexp(rOpenBlockParams); str != "" {
l.pos += len(str)
l.emit(TokenOpenBlockParams)
return lexExpression
}
// ..
if l.isString("..") {
l.pos += len("..")
l.emit(TokenID)
return lexExpression
}
// .
if str := l.findRegexp(rDotID); str != "" {
l.pos += len(".")
l.emit(TokenID)
return lexExpression
}
// true
if str := l.findRegexp(rTrue); str != "" {
l.pos += len("true")
l.emit(TokenBoolean)
return lexExpression
}
// false
if str := l.findRegexp(rFalse); str != "" {
l.pos += len("false")
l.emit(TokenBoolean)
return lexExpression
}
// let's scan next character
switch r := l.next(); {
case r == eof:
return l.errorf("Unclosed expression")
case isIgnorable(r):
return lexIgnorable
case r == '(':
l.emit(TokenOpenSexpr)
case r == ')':
l.emit(TokenCloseSexpr)
case r == '=':
l.emit(TokenEquals)
case r == '@':
l.emit(TokenData)
case r == '"' || r == '\'':
l.backup()
return lexString
case r == '/' || r == '.':
l.emit(TokenSep)
case r == '|':
l.emit(TokenCloseBlockParams)
case r == '+' || r == '-' || (r >= '0' && r <= '9'):
l.backup()
return lexNumber
case r == '[':
return lexPathLiteral
case strings.IndexRune(unallowedIDChars, r) < 0:
l.backup()
return lexIdentifier
default:
return l.errorf("Unexpected character in expression: '%c'", r)
}
return lexExpression
}
|
[
"func",
"lexExpression",
"(",
"l",
"*",
"Lexer",
")",
"lexFunc",
"{",
"// search close mustache delimiter",
"if",
"l",
".",
"isString",
"(",
"closeMustache",
")",
"||",
"l",
".",
"isString",
"(",
"closeStripMustache",
")",
"||",
"l",
".",
"isString",
"(",
"closeUnescapedStripMustache",
")",
"{",
"return",
"lexCloseMustache",
"\n",
"}",
"\n\n",
"// search some patterns before advancing scanning position",
"// \"as |\"",
"if",
"str",
":=",
"l",
".",
"findRegexp",
"(",
"rOpenBlockParams",
")",
";",
"str",
"!=",
"\"",
"\"",
"{",
"l",
".",
"pos",
"+=",
"len",
"(",
"str",
")",
"\n",
"l",
".",
"emit",
"(",
"TokenOpenBlockParams",
")",
"\n",
"return",
"lexExpression",
"\n",
"}",
"\n\n",
"// ..",
"if",
"l",
".",
"isString",
"(",
"\"",
"\"",
")",
"{",
"l",
".",
"pos",
"+=",
"len",
"(",
"\"",
"\"",
")",
"\n",
"l",
".",
"emit",
"(",
"TokenID",
")",
"\n",
"return",
"lexExpression",
"\n",
"}",
"\n\n",
"// .",
"if",
"str",
":=",
"l",
".",
"findRegexp",
"(",
"rDotID",
")",
";",
"str",
"!=",
"\"",
"\"",
"{",
"l",
".",
"pos",
"+=",
"len",
"(",
"\"",
"\"",
")",
"\n",
"l",
".",
"emit",
"(",
"TokenID",
")",
"\n",
"return",
"lexExpression",
"\n",
"}",
"\n\n",
"// true",
"if",
"str",
":=",
"l",
".",
"findRegexp",
"(",
"rTrue",
")",
";",
"str",
"!=",
"\"",
"\"",
"{",
"l",
".",
"pos",
"+=",
"len",
"(",
"\"",
"\"",
")",
"\n",
"l",
".",
"emit",
"(",
"TokenBoolean",
")",
"\n",
"return",
"lexExpression",
"\n",
"}",
"\n\n",
"// false",
"if",
"str",
":=",
"l",
".",
"findRegexp",
"(",
"rFalse",
")",
";",
"str",
"!=",
"\"",
"\"",
"{",
"l",
".",
"pos",
"+=",
"len",
"(",
"\"",
"\"",
")",
"\n",
"l",
".",
"emit",
"(",
"TokenBoolean",
")",
"\n",
"return",
"lexExpression",
"\n",
"}",
"\n\n",
"// let's scan next character",
"switch",
"r",
":=",
"l",
".",
"next",
"(",
")",
";",
"{",
"case",
"r",
"==",
"eof",
":",
"return",
"l",
".",
"errorf",
"(",
"\"",
"\"",
")",
"\n",
"case",
"isIgnorable",
"(",
"r",
")",
":",
"return",
"lexIgnorable",
"\n",
"case",
"r",
"==",
"'('",
":",
"l",
".",
"emit",
"(",
"TokenOpenSexpr",
")",
"\n",
"case",
"r",
"==",
"')'",
":",
"l",
".",
"emit",
"(",
"TokenCloseSexpr",
")",
"\n",
"case",
"r",
"==",
"'='",
":",
"l",
".",
"emit",
"(",
"TokenEquals",
")",
"\n",
"case",
"r",
"==",
"'@'",
":",
"l",
".",
"emit",
"(",
"TokenData",
")",
"\n",
"case",
"r",
"==",
"'\"'",
"||",
"r",
"==",
"'\\''",
":",
"l",
".",
"backup",
"(",
")",
"\n",
"return",
"lexString",
"\n",
"case",
"r",
"==",
"'/'",
"||",
"r",
"==",
"'.'",
":",
"l",
".",
"emit",
"(",
"TokenSep",
")",
"\n",
"case",
"r",
"==",
"'|'",
":",
"l",
".",
"emit",
"(",
"TokenCloseBlockParams",
")",
"\n",
"case",
"r",
"==",
"'+'",
"||",
"r",
"==",
"'-'",
"||",
"(",
"r",
">=",
"'0'",
"&&",
"r",
"<=",
"'9'",
")",
":",
"l",
".",
"backup",
"(",
")",
"\n",
"return",
"lexNumber",
"\n",
"case",
"r",
"==",
"'['",
":",
"return",
"lexPathLiteral",
"\n",
"case",
"strings",
".",
"IndexRune",
"(",
"unallowedIDChars",
",",
"r",
")",
"<",
"0",
":",
"l",
".",
"backup",
"(",
")",
"\n",
"return",
"lexIdentifier",
"\n",
"default",
":",
"return",
"l",
".",
"errorf",
"(",
"\"",
"\"",
",",
"r",
")",
"\n",
"}",
"\n\n",
"return",
"lexExpression",
"\n",
"}"
] |
// lexExpression scans inside mustaches
|
[
"lexExpression",
"scans",
"inside",
"mustaches"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/lexer/lexer.go#L398-L475
|
515 |
aymerick/raymond
|
lexer/lexer.go
|
lexIgnorable
|
func lexIgnorable(l *Lexer) lexFunc {
for isIgnorable(l.peek()) {
l.next()
}
l.ignore()
return lexExpression
}
|
go
|
func lexIgnorable(l *Lexer) lexFunc {
for isIgnorable(l.peek()) {
l.next()
}
l.ignore()
return lexExpression
}
|
[
"func",
"lexIgnorable",
"(",
"l",
"*",
"Lexer",
")",
"lexFunc",
"{",
"for",
"isIgnorable",
"(",
"l",
".",
"peek",
"(",
")",
")",
"{",
"l",
".",
"next",
"(",
")",
"\n",
"}",
"\n",
"l",
".",
"ignore",
"(",
")",
"\n\n",
"return",
"lexExpression",
"\n",
"}"
] |
// lexIgnorable scans all following ignorable characters
|
[
"lexIgnorable",
"scans",
"all",
"following",
"ignorable",
"characters"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/lexer/lexer.go#L494-L501
|
516 |
aymerick/raymond
|
lexer/lexer.go
|
lexString
|
func lexString(l *Lexer) lexFunc {
// get string delimiter
delim := l.next()
var prev rune
// ignore delimiter
l.ignore()
for {
r := l.next()
if r == eof || r == '\n' {
return l.errorf("Unterminated string")
}
if (r == delim) && (prev != '\\') {
break
}
prev = r
}
// remove end delimiter
l.backup()
// emit string
l.emitString(delim)
// skip end delimiter
l.next()
l.ignore()
return lexExpression
}
|
go
|
func lexString(l *Lexer) lexFunc {
// get string delimiter
delim := l.next()
var prev rune
// ignore delimiter
l.ignore()
for {
r := l.next()
if r == eof || r == '\n' {
return l.errorf("Unterminated string")
}
if (r == delim) && (prev != '\\') {
break
}
prev = r
}
// remove end delimiter
l.backup()
// emit string
l.emitString(delim)
// skip end delimiter
l.next()
l.ignore()
return lexExpression
}
|
[
"func",
"lexString",
"(",
"l",
"*",
"Lexer",
")",
"lexFunc",
"{",
"// get string delimiter",
"delim",
":=",
"l",
".",
"next",
"(",
")",
"\n",
"var",
"prev",
"rune",
"\n\n",
"// ignore delimiter",
"l",
".",
"ignore",
"(",
")",
"\n\n",
"for",
"{",
"r",
":=",
"l",
".",
"next",
"(",
")",
"\n",
"if",
"r",
"==",
"eof",
"||",
"r",
"==",
"'\\n'",
"{",
"return",
"l",
".",
"errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"(",
"r",
"==",
"delim",
")",
"&&",
"(",
"prev",
"!=",
"'\\\\'",
")",
"{",
"break",
"\n",
"}",
"\n\n",
"prev",
"=",
"r",
"\n",
"}",
"\n\n",
"// remove end delimiter",
"l",
".",
"backup",
"(",
")",
"\n\n",
"// emit string",
"l",
".",
"emitString",
"(",
"delim",
")",
"\n\n",
"// skip end delimiter",
"l",
".",
"next",
"(",
")",
"\n",
"l",
".",
"ignore",
"(",
")",
"\n\n",
"return",
"lexExpression",
"\n",
"}"
] |
// lexString scans a string
|
[
"lexString",
"scans",
"a",
"string"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/lexer/lexer.go#L504-L536
|
517 |
aymerick/raymond
|
lexer/lexer.go
|
lexIdentifier
|
func lexIdentifier(l *Lexer) lexFunc {
str := l.findRegexp(rID)
if len(str) == 0 {
// this is rotten
panic("Identifier expected")
}
l.pos += len(str)
l.emit(TokenID)
return lexExpression
}
|
go
|
func lexIdentifier(l *Lexer) lexFunc {
str := l.findRegexp(rID)
if len(str) == 0 {
// this is rotten
panic("Identifier expected")
}
l.pos += len(str)
l.emit(TokenID)
return lexExpression
}
|
[
"func",
"lexIdentifier",
"(",
"l",
"*",
"Lexer",
")",
"lexFunc",
"{",
"str",
":=",
"l",
".",
"findRegexp",
"(",
"rID",
")",
"\n",
"if",
"len",
"(",
"str",
")",
"==",
"0",
"{",
"// this is rotten",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"l",
".",
"pos",
"+=",
"len",
"(",
"str",
")",
"\n",
"l",
".",
"emit",
"(",
"TokenID",
")",
"\n\n",
"return",
"lexExpression",
"\n",
"}"
] |
// lexIdentifier scans an ID
|
[
"lexIdentifier",
"scans",
"an",
"ID"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/lexer/lexer.go#L598-L609
|
518 |
aymerick/raymond
|
utils.go
|
IsTrue
|
func IsTrue(obj interface{}) bool {
thruth, ok := isTrueValue(reflect.ValueOf(obj))
if !ok {
return false
}
return thruth
}
|
go
|
func IsTrue(obj interface{}) bool {
thruth, ok := isTrueValue(reflect.ValueOf(obj))
if !ok {
return false
}
return thruth
}
|
[
"func",
"IsTrue",
"(",
"obj",
"interface",
"{",
"}",
")",
"bool",
"{",
"thruth",
",",
"ok",
":=",
"isTrueValue",
"(",
"reflect",
".",
"ValueOf",
"(",
"obj",
")",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"thruth",
"\n",
"}"
] |
// IsTrue returns true if obj is a truthy value.
|
[
"IsTrue",
"returns",
"true",
"if",
"obj",
"is",
"a",
"truthy",
"value",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/utils.go#L26-L32
|
519 |
aymerick/raymond
|
lexer/token.go
|
String
|
func (k TokenKind) String() string {
s := tokenName[k]
if s == "" {
return fmt.Sprintf("Token-%d", int(k))
}
return s
}
|
go
|
func (k TokenKind) String() string {
s := tokenName[k]
if s == "" {
return fmt.Sprintf("Token-%d", int(k))
}
return s
}
|
[
"func",
"(",
"k",
"TokenKind",
")",
"String",
"(",
")",
"string",
"{",
"s",
":=",
"tokenName",
"[",
"k",
"]",
"\n",
"if",
"s",
"==",
"\"",
"\"",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"int",
"(",
"k",
")",
")",
"\n",
"}",
"\n",
"return",
"s",
"\n",
"}"
] |
// String returns the token kind string representation for debugging.
|
[
"String",
"returns",
"the",
"token",
"kind",
"string",
"representation",
"for",
"debugging",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/lexer/token.go#L156-L162
|
520 |
aymerick/raymond
|
lexer/token.go
|
String
|
func (t Token) String() string {
result := ""
if dumpTokenPos {
result += fmt.Sprintf("%d:", t.Pos)
}
result += fmt.Sprintf("%s", t.Kind)
if (dumpAllTokensVal || (t.Kind >= TokenContent)) && len(t.Val) > 0 {
if len(t.Val) > 100 {
result += fmt.Sprintf("{%.20q...}", t.Val)
} else {
result += fmt.Sprintf("{%q}", t.Val)
}
}
return result
}
|
go
|
func (t Token) String() string {
result := ""
if dumpTokenPos {
result += fmt.Sprintf("%d:", t.Pos)
}
result += fmt.Sprintf("%s", t.Kind)
if (dumpAllTokensVal || (t.Kind >= TokenContent)) && len(t.Val) > 0 {
if len(t.Val) > 100 {
result += fmt.Sprintf("{%.20q...}", t.Val)
} else {
result += fmt.Sprintf("{%q}", t.Val)
}
}
return result
}
|
[
"func",
"(",
"t",
"Token",
")",
"String",
"(",
")",
"string",
"{",
"result",
":=",
"\"",
"\"",
"\n\n",
"if",
"dumpTokenPos",
"{",
"result",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"t",
".",
"Pos",
")",
"\n",
"}",
"\n\n",
"result",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"t",
".",
"Kind",
")",
"\n\n",
"if",
"(",
"dumpAllTokensVal",
"||",
"(",
"t",
".",
"Kind",
">=",
"TokenContent",
")",
")",
"&&",
"len",
"(",
"t",
".",
"Val",
")",
">",
"0",
"{",
"if",
"len",
"(",
"t",
".",
"Val",
")",
">",
"100",
"{",
"result",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"t",
".",
"Val",
")",
"\n",
"}",
"else",
"{",
"result",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"t",
".",
"Val",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"result",
"\n",
"}"
] |
// String returns the token string representation for debugging.
|
[
"String",
"returns",
"the",
"token",
"string",
"representation",
"for",
"debugging",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/lexer/token.go#L165-L183
|
521 |
aymerick/raymond
|
template.go
|
newTemplate
|
func newTemplate(source string) *Template {
return &Template{
source: source,
helpers: make(map[string]reflect.Value),
partials: make(map[string]*partial),
}
}
|
go
|
func newTemplate(source string) *Template {
return &Template{
source: source,
helpers: make(map[string]reflect.Value),
partials: make(map[string]*partial),
}
}
|
[
"func",
"newTemplate",
"(",
"source",
"string",
")",
"*",
"Template",
"{",
"return",
"&",
"Template",
"{",
"source",
":",
"source",
",",
"helpers",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"reflect",
".",
"Value",
")",
",",
"partials",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"partial",
")",
",",
"}",
"\n",
"}"
] |
// newTemplate instanciate a new template without parsing it
|
[
"newTemplate",
"instanciate",
"a",
"new",
"template",
"without",
"parsing",
"it"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/template.go#L24-L30
|
522 |
aymerick/raymond
|
template.go
|
Parse
|
func Parse(source string) (*Template, error) {
tpl := newTemplate(source)
// parse template
if err := tpl.parse(); err != nil {
return nil, err
}
return tpl, nil
}
|
go
|
func Parse(source string) (*Template, error) {
tpl := newTemplate(source)
// parse template
if err := tpl.parse(); err != nil {
return nil, err
}
return tpl, nil
}
|
[
"func",
"Parse",
"(",
"source",
"string",
")",
"(",
"*",
"Template",
",",
"error",
")",
"{",
"tpl",
":=",
"newTemplate",
"(",
"source",
")",
"\n\n",
"// parse template",
"if",
"err",
":=",
"tpl",
".",
"parse",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"tpl",
",",
"nil",
"\n",
"}"
] |
// Parse instanciates a template by parsing given source.
|
[
"Parse",
"instanciates",
"a",
"template",
"by",
"parsing",
"given",
"source",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/template.go#L33-L42
|
523 |
aymerick/raymond
|
template.go
|
MustParse
|
func MustParse(source string) *Template {
result, err := Parse(source)
if err != nil {
panic(err)
}
return result
}
|
go
|
func MustParse(source string) *Template {
result, err := Parse(source)
if err != nil {
panic(err)
}
return result
}
|
[
"func",
"MustParse",
"(",
"source",
"string",
")",
"*",
"Template",
"{",
"result",
",",
"err",
":=",
"Parse",
"(",
"source",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"result",
"\n",
"}"
] |
// MustParse instanciates a template by parsing given source. It panics on error.
|
[
"MustParse",
"instanciates",
"a",
"template",
"by",
"parsing",
"given",
"source",
".",
"It",
"panics",
"on",
"error",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/template.go#L45-L51
|
524 |
aymerick/raymond
|
template.go
|
ParseFile
|
func ParseFile(filePath string) (*Template, error) {
b, err := ioutil.ReadFile(filePath)
if err != nil {
return nil, err
}
return Parse(string(b))
}
|
go
|
func ParseFile(filePath string) (*Template, error) {
b, err := ioutil.ReadFile(filePath)
if err != nil {
return nil, err
}
return Parse(string(b))
}
|
[
"func",
"ParseFile",
"(",
"filePath",
"string",
")",
"(",
"*",
"Template",
",",
"error",
")",
"{",
"b",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"filePath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"Parse",
"(",
"string",
"(",
"b",
")",
")",
"\n",
"}"
] |
// ParseFile reads given file and returns parsed template.
|
[
"ParseFile",
"reads",
"given",
"file",
"and",
"returns",
"parsed",
"template",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/template.go#L54-L61
|
525 |
aymerick/raymond
|
template.go
|
parse
|
func (tpl *Template) parse() error {
if tpl.program == nil {
var err error
tpl.program, err = parser.Parse(tpl.source)
if err != nil {
return err
}
}
return nil
}
|
go
|
func (tpl *Template) parse() error {
if tpl.program == nil {
var err error
tpl.program, err = parser.Parse(tpl.source)
if err != nil {
return err
}
}
return nil
}
|
[
"func",
"(",
"tpl",
"*",
"Template",
")",
"parse",
"(",
")",
"error",
"{",
"if",
"tpl",
".",
"program",
"==",
"nil",
"{",
"var",
"err",
"error",
"\n\n",
"tpl",
".",
"program",
",",
"err",
"=",
"parser",
".",
"Parse",
"(",
"tpl",
".",
"source",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// parse parses the template
//
// It can be called several times, the parsing will be done only once.
|
[
"parse",
"parses",
"the",
"template",
"It",
"can",
"be",
"called",
"several",
"times",
"the",
"parsing",
"will",
"be",
"done",
"only",
"once",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/template.go#L66-L77
|
526 |
aymerick/raymond
|
template.go
|
Clone
|
func (tpl *Template) Clone() *Template {
result := newTemplate(tpl.source)
result.program = tpl.program
tpl.mutex.RLock()
defer tpl.mutex.RUnlock()
for name, helper := range tpl.helpers {
result.RegisterHelper(name, helper.Interface())
}
for name, partial := range tpl.partials {
result.addPartial(name, partial.source, partial.tpl)
}
return result
}
|
go
|
func (tpl *Template) Clone() *Template {
result := newTemplate(tpl.source)
result.program = tpl.program
tpl.mutex.RLock()
defer tpl.mutex.RUnlock()
for name, helper := range tpl.helpers {
result.RegisterHelper(name, helper.Interface())
}
for name, partial := range tpl.partials {
result.addPartial(name, partial.source, partial.tpl)
}
return result
}
|
[
"func",
"(",
"tpl",
"*",
"Template",
")",
"Clone",
"(",
")",
"*",
"Template",
"{",
"result",
":=",
"newTemplate",
"(",
"tpl",
".",
"source",
")",
"\n\n",
"result",
".",
"program",
"=",
"tpl",
".",
"program",
"\n\n",
"tpl",
".",
"mutex",
".",
"RLock",
"(",
")",
"\n",
"defer",
"tpl",
".",
"mutex",
".",
"RUnlock",
"(",
")",
"\n\n",
"for",
"name",
",",
"helper",
":=",
"range",
"tpl",
".",
"helpers",
"{",
"result",
".",
"RegisterHelper",
"(",
"name",
",",
"helper",
".",
"Interface",
"(",
")",
")",
"\n",
"}",
"\n\n",
"for",
"name",
",",
"partial",
":=",
"range",
"tpl",
".",
"partials",
"{",
"result",
".",
"addPartial",
"(",
"name",
",",
"partial",
".",
"source",
",",
"partial",
".",
"tpl",
")",
"\n",
"}",
"\n\n",
"return",
"result",
"\n",
"}"
] |
// Clone returns a copy of that template.
|
[
"Clone",
"returns",
"a",
"copy",
"of",
"that",
"template",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/template.go#L80-L97
|
527 |
aymerick/raymond
|
template.go
|
RegisterHelper
|
func (tpl *Template) RegisterHelper(name string, helper interface{}) {
tpl.mutex.Lock()
defer tpl.mutex.Unlock()
if tpl.helpers[name] != zero {
panic(fmt.Sprintf("Helper %s already registered", name))
}
val := reflect.ValueOf(helper)
ensureValidHelper(name, val)
tpl.helpers[name] = val
}
|
go
|
func (tpl *Template) RegisterHelper(name string, helper interface{}) {
tpl.mutex.Lock()
defer tpl.mutex.Unlock()
if tpl.helpers[name] != zero {
panic(fmt.Sprintf("Helper %s already registered", name))
}
val := reflect.ValueOf(helper)
ensureValidHelper(name, val)
tpl.helpers[name] = val
}
|
[
"func",
"(",
"tpl",
"*",
"Template",
")",
"RegisterHelper",
"(",
"name",
"string",
",",
"helper",
"interface",
"{",
"}",
")",
"{",
"tpl",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"tpl",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"tpl",
".",
"helpers",
"[",
"name",
"]",
"!=",
"zero",
"{",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"name",
")",
")",
"\n",
"}",
"\n\n",
"val",
":=",
"reflect",
".",
"ValueOf",
"(",
"helper",
")",
"\n",
"ensureValidHelper",
"(",
"name",
",",
"val",
")",
"\n\n",
"tpl",
".",
"helpers",
"[",
"name",
"]",
"=",
"val",
"\n",
"}"
] |
// RegisterHelper registers a helper for that template.
|
[
"RegisterHelper",
"registers",
"a",
"helper",
"for",
"that",
"template",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/template.go#L107-L119
|
528 |
aymerick/raymond
|
template.go
|
RegisterHelpers
|
func (tpl *Template) RegisterHelpers(helpers map[string]interface{}) {
for name, helper := range helpers {
tpl.RegisterHelper(name, helper)
}
}
|
go
|
func (tpl *Template) RegisterHelpers(helpers map[string]interface{}) {
for name, helper := range helpers {
tpl.RegisterHelper(name, helper)
}
}
|
[
"func",
"(",
"tpl",
"*",
"Template",
")",
"RegisterHelpers",
"(",
"helpers",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"{",
"for",
"name",
",",
"helper",
":=",
"range",
"helpers",
"{",
"tpl",
".",
"RegisterHelper",
"(",
"name",
",",
"helper",
")",
"\n",
"}",
"\n",
"}"
] |
// RegisterHelpers registers several helpers for that template.
|
[
"RegisterHelpers",
"registers",
"several",
"helpers",
"for",
"that",
"template",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/template.go#L122-L126
|
529 |
aymerick/raymond
|
template.go
|
RegisterPartial
|
func (tpl *Template) RegisterPartial(name string, source string) {
tpl.addPartial(name, source, nil)
}
|
go
|
func (tpl *Template) RegisterPartial(name string, source string) {
tpl.addPartial(name, source, nil)
}
|
[
"func",
"(",
"tpl",
"*",
"Template",
")",
"RegisterPartial",
"(",
"name",
"string",
",",
"source",
"string",
")",
"{",
"tpl",
".",
"addPartial",
"(",
"name",
",",
"source",
",",
"nil",
")",
"\n",
"}"
] |
// RegisterPartial registers a partial for that template.
|
[
"RegisterPartial",
"registers",
"a",
"partial",
"for",
"that",
"template",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/template.go#L147-L149
|
530 |
aymerick/raymond
|
template.go
|
RegisterPartials
|
func (tpl *Template) RegisterPartials(partials map[string]string) {
for name, partial := range partials {
tpl.RegisterPartial(name, partial)
}
}
|
go
|
func (tpl *Template) RegisterPartials(partials map[string]string) {
for name, partial := range partials {
tpl.RegisterPartial(name, partial)
}
}
|
[
"func",
"(",
"tpl",
"*",
"Template",
")",
"RegisterPartials",
"(",
"partials",
"map",
"[",
"string",
"]",
"string",
")",
"{",
"for",
"name",
",",
"partial",
":=",
"range",
"partials",
"{",
"tpl",
".",
"RegisterPartial",
"(",
"name",
",",
"partial",
")",
"\n",
"}",
"\n",
"}"
] |
// RegisterPartials registers several partials for that template.
|
[
"RegisterPartials",
"registers",
"several",
"partials",
"for",
"that",
"template",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/template.go#L152-L156
|
531 |
aymerick/raymond
|
template.go
|
RegisterPartialFile
|
func (tpl *Template) RegisterPartialFile(filePath string, name string) error {
b, err := ioutil.ReadFile(filePath)
if err != nil {
return err
}
tpl.RegisterPartial(name, string(b))
return nil
}
|
go
|
func (tpl *Template) RegisterPartialFile(filePath string, name string) error {
b, err := ioutil.ReadFile(filePath)
if err != nil {
return err
}
tpl.RegisterPartial(name, string(b))
return nil
}
|
[
"func",
"(",
"tpl",
"*",
"Template",
")",
"RegisterPartialFile",
"(",
"filePath",
"string",
",",
"name",
"string",
")",
"error",
"{",
"b",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"filePath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"tpl",
".",
"RegisterPartial",
"(",
"name",
",",
"string",
"(",
"b",
")",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// RegisterPartialFile reads given file and registers its content as a partial with given name.
|
[
"RegisterPartialFile",
"reads",
"given",
"file",
"and",
"registers",
"its",
"content",
"as",
"a",
"partial",
"with",
"given",
"name",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/template.go#L159-L168
|
532 |
aymerick/raymond
|
template.go
|
RegisterPartialFiles
|
func (tpl *Template) RegisterPartialFiles(filePaths ...string) error {
if len(filePaths) == 0 {
return nil
}
for _, filePath := range filePaths {
name := fileBase(filePath)
if err := tpl.RegisterPartialFile(filePath, name); err != nil {
return err
}
}
return nil
}
|
go
|
func (tpl *Template) RegisterPartialFiles(filePaths ...string) error {
if len(filePaths) == 0 {
return nil
}
for _, filePath := range filePaths {
name := fileBase(filePath)
if err := tpl.RegisterPartialFile(filePath, name); err != nil {
return err
}
}
return nil
}
|
[
"func",
"(",
"tpl",
"*",
"Template",
")",
"RegisterPartialFiles",
"(",
"filePaths",
"...",
"string",
")",
"error",
"{",
"if",
"len",
"(",
"filePaths",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"filePath",
":=",
"range",
"filePaths",
"{",
"name",
":=",
"fileBase",
"(",
"filePath",
")",
"\n\n",
"if",
"err",
":=",
"tpl",
".",
"RegisterPartialFile",
"(",
"filePath",
",",
"name",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// RegisterPartialFiles reads several files and registers them as partials, the filename base is used as the partial name.
|
[
"RegisterPartialFiles",
"reads",
"several",
"files",
"and",
"registers",
"them",
"as",
"partials",
"the",
"filename",
"base",
"is",
"used",
"as",
"the",
"partial",
"name",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/template.go#L171-L185
|
533 |
aymerick/raymond
|
template.go
|
RegisterPartialTemplate
|
func (tpl *Template) RegisterPartialTemplate(name string, template *Template) {
tpl.addPartial(name, "", template)
}
|
go
|
func (tpl *Template) RegisterPartialTemplate(name string, template *Template) {
tpl.addPartial(name, "", template)
}
|
[
"func",
"(",
"tpl",
"*",
"Template",
")",
"RegisterPartialTemplate",
"(",
"name",
"string",
",",
"template",
"*",
"Template",
")",
"{",
"tpl",
".",
"addPartial",
"(",
"name",
",",
"\"",
"\"",
",",
"template",
")",
"\n",
"}"
] |
// RegisterPartialTemplate registers an already parsed partial for that template.
|
[
"RegisterPartialTemplate",
"registers",
"an",
"already",
"parsed",
"partial",
"for",
"that",
"template",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/template.go#L188-L190
|
534 |
aymerick/raymond
|
template.go
|
Exec
|
func (tpl *Template) Exec(ctx interface{}) (result string, err error) {
return tpl.ExecWith(ctx, nil)
}
|
go
|
func (tpl *Template) Exec(ctx interface{}) (result string, err error) {
return tpl.ExecWith(ctx, nil)
}
|
[
"func",
"(",
"tpl",
"*",
"Template",
")",
"Exec",
"(",
"ctx",
"interface",
"{",
"}",
")",
"(",
"result",
"string",
",",
"err",
"error",
")",
"{",
"return",
"tpl",
".",
"ExecWith",
"(",
"ctx",
",",
"nil",
")",
"\n",
"}"
] |
// Exec evaluates template with given context.
|
[
"Exec",
"evaluates",
"template",
"with",
"given",
"context",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/template.go#L193-L195
|
535 |
aymerick/raymond
|
template.go
|
MustExec
|
func (tpl *Template) MustExec(ctx interface{}) string {
result, err := tpl.Exec(ctx)
if err != nil {
panic(err)
}
return result
}
|
go
|
func (tpl *Template) MustExec(ctx interface{}) string {
result, err := tpl.Exec(ctx)
if err != nil {
panic(err)
}
return result
}
|
[
"func",
"(",
"tpl",
"*",
"Template",
")",
"MustExec",
"(",
"ctx",
"interface",
"{",
"}",
")",
"string",
"{",
"result",
",",
"err",
":=",
"tpl",
".",
"Exec",
"(",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"result",
"\n",
"}"
] |
// MustExec evaluates template with given context. It panics on error.
|
[
"MustExec",
"evaluates",
"template",
"with",
"given",
"context",
".",
"It",
"panics",
"on",
"error",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/template.go#L198-L204
|
536 |
aymerick/raymond
|
template.go
|
ExecWith
|
func (tpl *Template) ExecWith(ctx interface{}, privData *DataFrame) (result string, err error) {
defer errRecover(&err)
// parses template if necessary
err = tpl.parse()
if err != nil {
return
}
// setup visitor
v := newEvalVisitor(tpl, ctx, privData)
// visit AST
result, _ = tpl.program.Accept(v).(string)
// named return values
return
}
|
go
|
func (tpl *Template) ExecWith(ctx interface{}, privData *DataFrame) (result string, err error) {
defer errRecover(&err)
// parses template if necessary
err = tpl.parse()
if err != nil {
return
}
// setup visitor
v := newEvalVisitor(tpl, ctx, privData)
// visit AST
result, _ = tpl.program.Accept(v).(string)
// named return values
return
}
|
[
"func",
"(",
"tpl",
"*",
"Template",
")",
"ExecWith",
"(",
"ctx",
"interface",
"{",
"}",
",",
"privData",
"*",
"DataFrame",
")",
"(",
"result",
"string",
",",
"err",
"error",
")",
"{",
"defer",
"errRecover",
"(",
"&",
"err",
")",
"\n\n",
"// parses template if necessary",
"err",
"=",
"tpl",
".",
"parse",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"// setup visitor",
"v",
":=",
"newEvalVisitor",
"(",
"tpl",
",",
"ctx",
",",
"privData",
")",
"\n\n",
"// visit AST",
"result",
",",
"_",
"=",
"tpl",
".",
"program",
".",
"Accept",
"(",
"v",
")",
".",
"(",
"string",
")",
"\n\n",
"// named return values",
"return",
"\n",
"}"
] |
// ExecWith evaluates template with given context and private data frame.
|
[
"ExecWith",
"evaluates",
"template",
"with",
"given",
"context",
"and",
"private",
"data",
"frame",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/template.go#L207-L224
|
537 |
aymerick/raymond
|
template.go
|
PrintAST
|
func (tpl *Template) PrintAST() string {
if err := tpl.parse(); err != nil {
return fmt.Sprintf("PARSER ERROR: %s", err)
}
return ast.Print(tpl.program)
}
|
go
|
func (tpl *Template) PrintAST() string {
if err := tpl.parse(); err != nil {
return fmt.Sprintf("PARSER ERROR: %s", err)
}
return ast.Print(tpl.program)
}
|
[
"func",
"(",
"tpl",
"*",
"Template",
")",
"PrintAST",
"(",
")",
"string",
"{",
"if",
"err",
":=",
"tpl",
".",
"parse",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"ast",
".",
"Print",
"(",
"tpl",
".",
"program",
")",
"\n",
"}"
] |
// PrintAST returns string representation of parsed template.
|
[
"PrintAST",
"returns",
"string",
"representation",
"of",
"parsed",
"template",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/template.go#L242-L248
|
538 |
aymerick/raymond
|
ast/print.go
|
Print
|
func Print(node Node) string {
visitor := newPrintVisitor()
node.Accept(visitor)
return visitor.output()
}
|
go
|
func Print(node Node) string {
visitor := newPrintVisitor()
node.Accept(visitor)
return visitor.output()
}
|
[
"func",
"Print",
"(",
"node",
"Node",
")",
"string",
"{",
"visitor",
":=",
"newPrintVisitor",
"(",
")",
"\n",
"node",
".",
"Accept",
"(",
"visitor",
")",
"\n",
"return",
"visitor",
".",
"output",
"(",
")",
"\n",
"}"
] |
// Print returns a string representation of given AST, that can be used for debugging purpose.
|
[
"Print",
"returns",
"a",
"string",
"representation",
"of",
"given",
"AST",
"that",
"can",
"be",
"used",
"for",
"debugging",
"purpose",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/ast/print.go#L22-L26
|
539 |
aymerick/raymond
|
ast/print.go
|
VisitComment
|
func (v *printVisitor) VisitComment(node *CommentStatement) interface{} {
v.line("{{! '" + node.Value + "' }}")
return nil
}
|
go
|
func (v *printVisitor) VisitComment(node *CommentStatement) interface{} {
v.line("{{! '" + node.Value + "' }}")
return nil
}
|
[
"func",
"(",
"v",
"*",
"printVisitor",
")",
"VisitComment",
"(",
"node",
"*",
"CommentStatement",
")",
"interface",
"{",
"}",
"{",
"v",
".",
"line",
"(",
"\"",
"\"",
"+",
"node",
".",
"Value",
"+",
"\"",
"\"",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// VisitComment implements corresponding Visitor interface method
|
[
"VisitComment",
"implements",
"corresponding",
"Visitor",
"interface",
"method"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/ast/print.go#L155-L159
|
540 |
aymerick/raymond
|
string.go
|
isSafeString
|
func isSafeString(value interface{}) bool {
if _, ok := value.(SafeString); ok {
return true
}
return false
}
|
go
|
func isSafeString(value interface{}) bool {
if _, ok := value.(SafeString); ok {
return true
}
return false
}
|
[
"func",
"isSafeString",
"(",
"value",
"interface",
"{",
"}",
")",
"bool",
"{",
"if",
"_",
",",
"ok",
":=",
"value",
".",
"(",
"SafeString",
")",
";",
"ok",
"{",
"return",
"true",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] |
// isSafeString returns true if argument is a SafeString
|
[
"isSafeString",
"returns",
"true",
"if",
"argument",
"is",
"a",
"SafeString"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/string.go#L15-L20
|
541 |
aymerick/raymond
|
string.go
|
strValue
|
func strValue(value reflect.Value) string {
result := ""
ival, ok := printableValue(value)
if !ok {
panic(fmt.Errorf("Can't print value: %q", value))
}
val := reflect.ValueOf(ival)
switch val.Kind() {
case reflect.Array, reflect.Slice:
for i := 0; i < val.Len(); i++ {
result += strValue(val.Index(i))
}
case reflect.Bool:
result = "false"
if val.Bool() {
result = "true"
}
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
result = fmt.Sprintf("%d", ival)
case reflect.Float32, reflect.Float64:
result = strconv.FormatFloat(val.Float(), 'f', -1, 64)
case reflect.Invalid:
result = ""
default:
result = fmt.Sprintf("%s", ival)
}
return result
}
|
go
|
func strValue(value reflect.Value) string {
result := ""
ival, ok := printableValue(value)
if !ok {
panic(fmt.Errorf("Can't print value: %q", value))
}
val := reflect.ValueOf(ival)
switch val.Kind() {
case reflect.Array, reflect.Slice:
for i := 0; i < val.Len(); i++ {
result += strValue(val.Index(i))
}
case reflect.Bool:
result = "false"
if val.Bool() {
result = "true"
}
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
result = fmt.Sprintf("%d", ival)
case reflect.Float32, reflect.Float64:
result = strconv.FormatFloat(val.Float(), 'f', -1, 64)
case reflect.Invalid:
result = ""
default:
result = fmt.Sprintf("%s", ival)
}
return result
}
|
[
"func",
"strValue",
"(",
"value",
"reflect",
".",
"Value",
")",
"string",
"{",
"result",
":=",
"\"",
"\"",
"\n\n",
"ival",
",",
"ok",
":=",
"printableValue",
"(",
"value",
")",
"\n",
"if",
"!",
"ok",
"{",
"panic",
"(",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"value",
")",
")",
"\n",
"}",
"\n\n",
"val",
":=",
"reflect",
".",
"ValueOf",
"(",
"ival",
")",
"\n\n",
"switch",
"val",
".",
"Kind",
"(",
")",
"{",
"case",
"reflect",
".",
"Array",
",",
"reflect",
".",
"Slice",
":",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"val",
".",
"Len",
"(",
")",
";",
"i",
"++",
"{",
"result",
"+=",
"strValue",
"(",
"val",
".",
"Index",
"(",
"i",
")",
")",
"\n",
"}",
"\n",
"case",
"reflect",
".",
"Bool",
":",
"result",
"=",
"\"",
"\"",
"\n",
"if",
"val",
".",
"Bool",
"(",
")",
"{",
"result",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"case",
"reflect",
".",
"Int",
",",
"reflect",
".",
"Int8",
",",
"reflect",
".",
"Int16",
",",
"reflect",
".",
"Int32",
",",
"reflect",
".",
"Int64",
",",
"reflect",
".",
"Uint",
",",
"reflect",
".",
"Uint8",
",",
"reflect",
".",
"Uint16",
",",
"reflect",
".",
"Uint32",
",",
"reflect",
".",
"Uint64",
",",
"reflect",
".",
"Uintptr",
":",
"result",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"ival",
")",
"\n",
"case",
"reflect",
".",
"Float32",
",",
"reflect",
".",
"Float64",
":",
"result",
"=",
"strconv",
".",
"FormatFloat",
"(",
"val",
".",
"Float",
"(",
")",
",",
"'f'",
",",
"-",
"1",
",",
"64",
")",
"\n",
"case",
"reflect",
".",
"Invalid",
":",
"result",
"=",
"\"",
"\"",
"\n",
"default",
":",
"result",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"ival",
")",
"\n",
"}",
"\n\n",
"return",
"result",
"\n",
"}"
] |
// strValue returns string representation of a reflect.Value
|
[
"strValue",
"returns",
"string",
"representation",
"of",
"a",
"reflect",
".",
"Value"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/string.go#L28-L59
|
542 |
aymerick/raymond
|
partial.go
|
newPartial
|
func newPartial(name string, source string, tpl *Template) *partial {
return &partial{
name: name,
source: source,
tpl: tpl,
}
}
|
go
|
func newPartial(name string, source string, tpl *Template) *partial {
return &partial{
name: name,
source: source,
tpl: tpl,
}
}
|
[
"func",
"newPartial",
"(",
"name",
"string",
",",
"source",
"string",
",",
"tpl",
"*",
"Template",
")",
"*",
"partial",
"{",
"return",
"&",
"partial",
"{",
"name",
":",
"name",
",",
"source",
":",
"source",
",",
"tpl",
":",
"tpl",
",",
"}",
"\n",
"}"
] |
// newPartial instanciates a new partial
|
[
"newPartial",
"instanciates",
"a",
"new",
"partial"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/partial.go#L26-L32
|
543 |
aymerick/raymond
|
partial.go
|
RegisterPartial
|
func RegisterPartial(name string, source string) {
partialsMutex.Lock()
defer partialsMutex.Unlock()
if partials[name] != nil {
panic(fmt.Errorf("Partial already registered: %s", name))
}
partials[name] = newPartial(name, source, nil)
}
|
go
|
func RegisterPartial(name string, source string) {
partialsMutex.Lock()
defer partialsMutex.Unlock()
if partials[name] != nil {
panic(fmt.Errorf("Partial already registered: %s", name))
}
partials[name] = newPartial(name, source, nil)
}
|
[
"func",
"RegisterPartial",
"(",
"name",
"string",
",",
"source",
"string",
")",
"{",
"partialsMutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"partialsMutex",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"partials",
"[",
"name",
"]",
"!=",
"nil",
"{",
"panic",
"(",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"name",
")",
")",
"\n",
"}",
"\n\n",
"partials",
"[",
"name",
"]",
"=",
"newPartial",
"(",
"name",
",",
"source",
",",
"nil",
")",
"\n",
"}"
] |
// RegisterPartial registers a global partial. That partial will be available to all templates.
|
[
"RegisterPartial",
"registers",
"a",
"global",
"partial",
".",
"That",
"partial",
"will",
"be",
"available",
"to",
"all",
"templates",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/partial.go#L35-L44
|
544 |
aymerick/raymond
|
partial.go
|
RegisterPartials
|
func RegisterPartials(partials map[string]string) {
for name, p := range partials {
RegisterPartial(name, p)
}
}
|
go
|
func RegisterPartials(partials map[string]string) {
for name, p := range partials {
RegisterPartial(name, p)
}
}
|
[
"func",
"RegisterPartials",
"(",
"partials",
"map",
"[",
"string",
"]",
"string",
")",
"{",
"for",
"name",
",",
"p",
":=",
"range",
"partials",
"{",
"RegisterPartial",
"(",
"name",
",",
"p",
")",
"\n",
"}",
"\n",
"}"
] |
// RegisterPartials registers several global partials. Those partials will be available to all templates.
|
[
"RegisterPartials",
"registers",
"several",
"global",
"partials",
".",
"Those",
"partials",
"will",
"be",
"available",
"to",
"all",
"templates",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/partial.go#L47-L51
|
545 |
aymerick/raymond
|
partial.go
|
RegisterPartialTemplate
|
func RegisterPartialTemplate(name string, tpl *Template) {
partialsMutex.Lock()
defer partialsMutex.Unlock()
if partials[name] != nil {
panic(fmt.Errorf("Partial already registered: %s", name))
}
partials[name] = newPartial(name, "", tpl)
}
|
go
|
func RegisterPartialTemplate(name string, tpl *Template) {
partialsMutex.Lock()
defer partialsMutex.Unlock()
if partials[name] != nil {
panic(fmt.Errorf("Partial already registered: %s", name))
}
partials[name] = newPartial(name, "", tpl)
}
|
[
"func",
"RegisterPartialTemplate",
"(",
"name",
"string",
",",
"tpl",
"*",
"Template",
")",
"{",
"partialsMutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"partialsMutex",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"partials",
"[",
"name",
"]",
"!=",
"nil",
"{",
"panic",
"(",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"name",
")",
")",
"\n",
"}",
"\n\n",
"partials",
"[",
"name",
"]",
"=",
"newPartial",
"(",
"name",
",",
"\"",
"\"",
",",
"tpl",
")",
"\n",
"}"
] |
// RegisterPartialTemplate registers a global partial with given parsed template. That partial will be available to all templates.
|
[
"RegisterPartialTemplate",
"registers",
"a",
"global",
"partial",
"with",
"given",
"parsed",
"template",
".",
"That",
"partial",
"will",
"be",
"available",
"to",
"all",
"templates",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/partial.go#L54-L63
|
546 |
aymerick/raymond
|
partial.go
|
RemovePartial
|
func RemovePartial(name string) {
partialsMutex.Lock()
defer partialsMutex.Unlock()
delete(partials, name)
}
|
go
|
func RemovePartial(name string) {
partialsMutex.Lock()
defer partialsMutex.Unlock()
delete(partials, name)
}
|
[
"func",
"RemovePartial",
"(",
"name",
"string",
")",
"{",
"partialsMutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"partialsMutex",
".",
"Unlock",
"(",
")",
"\n\n",
"delete",
"(",
"partials",
",",
"name",
")",
"\n",
"}"
] |
// RemovePartial removes the partial registered under the given name. The partial will not be available globally anymore. This does not affect partials registered on a specific template.
|
[
"RemovePartial",
"removes",
"the",
"partial",
"registered",
"under",
"the",
"given",
"name",
".",
"The",
"partial",
"will",
"not",
"be",
"available",
"globally",
"anymore",
".",
"This",
"does",
"not",
"affect",
"partials",
"registered",
"on",
"a",
"specific",
"template",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/partial.go#L66-L71
|
547 |
aymerick/raymond
|
partial.go
|
findPartial
|
func findPartial(name string) *partial {
partialsMutex.RLock()
defer partialsMutex.RUnlock()
return partials[name]
}
|
go
|
func findPartial(name string) *partial {
partialsMutex.RLock()
defer partialsMutex.RUnlock()
return partials[name]
}
|
[
"func",
"findPartial",
"(",
"name",
"string",
")",
"*",
"partial",
"{",
"partialsMutex",
".",
"RLock",
"(",
")",
"\n",
"defer",
"partialsMutex",
".",
"RUnlock",
"(",
")",
"\n\n",
"return",
"partials",
"[",
"name",
"]",
"\n",
"}"
] |
// findPartial finds a registered global partial
|
[
"findPartial",
"finds",
"a",
"registered",
"global",
"partial"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/partial.go#L82-L87
|
548 |
aymerick/raymond
|
partial.go
|
template
|
func (p *partial) template() (*Template, error) {
if p.tpl == nil {
var err error
p.tpl, err = Parse(p.source)
if err != nil {
return nil, err
}
}
return p.tpl, nil
}
|
go
|
func (p *partial) template() (*Template, error) {
if p.tpl == nil {
var err error
p.tpl, err = Parse(p.source)
if err != nil {
return nil, err
}
}
return p.tpl, nil
}
|
[
"func",
"(",
"p",
"*",
"partial",
")",
"template",
"(",
")",
"(",
"*",
"Template",
",",
"error",
")",
"{",
"if",
"p",
".",
"tpl",
"==",
"nil",
"{",
"var",
"err",
"error",
"\n\n",
"p",
".",
"tpl",
",",
"err",
"=",
"Parse",
"(",
"p",
".",
"source",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"p",
".",
"tpl",
",",
"nil",
"\n",
"}"
] |
// template returns parsed partial template
|
[
"template",
"returns",
"parsed",
"partial",
"template"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/partial.go#L90-L101
|
549 |
aymerick/raymond
|
eval.go
|
newEvalVisitor
|
func newEvalVisitor(tpl *Template, ctx interface{}, privData *DataFrame) *evalVisitor {
frame := privData
if frame == nil {
frame = NewDataFrame()
}
return &evalVisitor{
tpl: tpl,
ctx: []reflect.Value{reflect.ValueOf(ctx)},
dataFrame: frame,
exprFunc: make(map[*ast.Expression]bool),
}
}
|
go
|
func newEvalVisitor(tpl *Template, ctx interface{}, privData *DataFrame) *evalVisitor {
frame := privData
if frame == nil {
frame = NewDataFrame()
}
return &evalVisitor{
tpl: tpl,
ctx: []reflect.Value{reflect.ValueOf(ctx)},
dataFrame: frame,
exprFunc: make(map[*ast.Expression]bool),
}
}
|
[
"func",
"newEvalVisitor",
"(",
"tpl",
"*",
"Template",
",",
"ctx",
"interface",
"{",
"}",
",",
"privData",
"*",
"DataFrame",
")",
"*",
"evalVisitor",
"{",
"frame",
":=",
"privData",
"\n",
"if",
"frame",
"==",
"nil",
"{",
"frame",
"=",
"NewDataFrame",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"evalVisitor",
"{",
"tpl",
":",
"tpl",
",",
"ctx",
":",
"[",
"]",
"reflect",
".",
"Value",
"{",
"reflect",
".",
"ValueOf",
"(",
"ctx",
")",
"}",
",",
"dataFrame",
":",
"frame",
",",
"exprFunc",
":",
"make",
"(",
"map",
"[",
"*",
"ast",
".",
"Expression",
"]",
"bool",
")",
",",
"}",
"\n",
"}"
] |
// NewEvalVisitor instanciate a new evaluation visitor with given context and initial private data frame
//
// If privData is nil, then a default data frame is created
|
[
"NewEvalVisitor",
"instanciate",
"a",
"new",
"evaluation",
"visitor",
"with",
"given",
"context",
"and",
"initial",
"private",
"data",
"frame",
"If",
"privData",
"is",
"nil",
"then",
"a",
"default",
"data",
"frame",
"is",
"created"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/eval.go#L50-L62
|
550 |
aymerick/raymond
|
eval.go
|
pushCtx
|
func (v *evalVisitor) pushCtx(ctx reflect.Value) {
v.ctx = append(v.ctx, ctx)
}
|
go
|
func (v *evalVisitor) pushCtx(ctx reflect.Value) {
v.ctx = append(v.ctx, ctx)
}
|
[
"func",
"(",
"v",
"*",
"evalVisitor",
")",
"pushCtx",
"(",
"ctx",
"reflect",
".",
"Value",
")",
"{",
"v",
".",
"ctx",
"=",
"append",
"(",
"v",
".",
"ctx",
",",
"ctx",
")",
"\n",
"}"
] |
//
// Contexts stack
//
// pushCtx pushes new context to the stack
|
[
"Contexts",
"stack",
"pushCtx",
"pushes",
"new",
"context",
"to",
"the",
"stack"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/eval.go#L74-L76
|
551 |
aymerick/raymond
|
eval.go
|
popCtx
|
func (v *evalVisitor) popCtx() reflect.Value {
if len(v.ctx) == 0 {
return zero
}
var result reflect.Value
result, v.ctx = v.ctx[len(v.ctx)-1], v.ctx[:len(v.ctx)-1]
return result
}
|
go
|
func (v *evalVisitor) popCtx() reflect.Value {
if len(v.ctx) == 0 {
return zero
}
var result reflect.Value
result, v.ctx = v.ctx[len(v.ctx)-1], v.ctx[:len(v.ctx)-1]
return result
}
|
[
"func",
"(",
"v",
"*",
"evalVisitor",
")",
"popCtx",
"(",
")",
"reflect",
".",
"Value",
"{",
"if",
"len",
"(",
"v",
".",
"ctx",
")",
"==",
"0",
"{",
"return",
"zero",
"\n",
"}",
"\n\n",
"var",
"result",
"reflect",
".",
"Value",
"\n",
"result",
",",
"v",
".",
"ctx",
"=",
"v",
".",
"ctx",
"[",
"len",
"(",
"v",
".",
"ctx",
")",
"-",
"1",
"]",
",",
"v",
".",
"ctx",
"[",
":",
"len",
"(",
"v",
".",
"ctx",
")",
"-",
"1",
"]",
"\n\n",
"return",
"result",
"\n",
"}"
] |
// popCtx pops last context from stack
|
[
"popCtx",
"pops",
"last",
"context",
"from",
"stack"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/eval.go#L79-L88
|
552 |
aymerick/raymond
|
eval.go
|
ancestorCtx
|
func (v *evalVisitor) ancestorCtx(depth int) reflect.Value {
index := len(v.ctx) - 1 - depth
if index < 0 {
return zero
}
return v.ctx[index]
}
|
go
|
func (v *evalVisitor) ancestorCtx(depth int) reflect.Value {
index := len(v.ctx) - 1 - depth
if index < 0 {
return zero
}
return v.ctx[index]
}
|
[
"func",
"(",
"v",
"*",
"evalVisitor",
")",
"ancestorCtx",
"(",
"depth",
"int",
")",
"reflect",
".",
"Value",
"{",
"index",
":=",
"len",
"(",
"v",
".",
"ctx",
")",
"-",
"1",
"-",
"depth",
"\n",
"if",
"index",
"<",
"0",
"{",
"return",
"zero",
"\n",
"}",
"\n\n",
"return",
"v",
".",
"ctx",
"[",
"index",
"]",
"\n",
"}"
] |
// ancestorCtx returns ancestor context
|
[
"ancestorCtx",
"returns",
"ancestor",
"context"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/eval.go#L101-L108
|
553 |
aymerick/raymond
|
eval.go
|
pushBlockParams
|
func (v *evalVisitor) pushBlockParams(params map[string]interface{}) {
v.blockParams = append(v.blockParams, params)
}
|
go
|
func (v *evalVisitor) pushBlockParams(params map[string]interface{}) {
v.blockParams = append(v.blockParams, params)
}
|
[
"func",
"(",
"v",
"*",
"evalVisitor",
")",
"pushBlockParams",
"(",
"params",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"{",
"v",
".",
"blockParams",
"=",
"append",
"(",
"v",
".",
"blockParams",
",",
"params",
")",
"\n",
"}"
] |
//
// Block Parameters stack
//
// pushBlockParams pushes new block params to the stack
|
[
"Block",
"Parameters",
"stack",
"pushBlockParams",
"pushes",
"new",
"block",
"params",
"to",
"the",
"stack"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/eval.go#L129-L131
|
554 |
aymerick/raymond
|
eval.go
|
popBlockParams
|
func (v *evalVisitor) popBlockParams() map[string]interface{} {
var result map[string]interface{}
if len(v.blockParams) == 0 {
return result
}
result, v.blockParams = v.blockParams[len(v.blockParams)-1], v.blockParams[:len(v.blockParams)-1]
return result
}
|
go
|
func (v *evalVisitor) popBlockParams() map[string]interface{} {
var result map[string]interface{}
if len(v.blockParams) == 0 {
return result
}
result, v.blockParams = v.blockParams[len(v.blockParams)-1], v.blockParams[:len(v.blockParams)-1]
return result
}
|
[
"func",
"(",
"v",
"*",
"evalVisitor",
")",
"popBlockParams",
"(",
")",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"var",
"result",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"\n\n",
"if",
"len",
"(",
"v",
".",
"blockParams",
")",
"==",
"0",
"{",
"return",
"result",
"\n",
"}",
"\n\n",
"result",
",",
"v",
".",
"blockParams",
"=",
"v",
".",
"blockParams",
"[",
"len",
"(",
"v",
".",
"blockParams",
")",
"-",
"1",
"]",
",",
"v",
".",
"blockParams",
"[",
":",
"len",
"(",
"v",
".",
"blockParams",
")",
"-",
"1",
"]",
"\n",
"return",
"result",
"\n",
"}"
] |
// popBlockParams pops last block params from stack
|
[
"popBlockParams",
"pops",
"last",
"block",
"params",
"from",
"stack"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/eval.go#L134-L143
|
555 |
aymerick/raymond
|
eval.go
|
blockParam
|
func (v *evalVisitor) blockParam(name string) interface{} {
for i := len(v.blockParams) - 1; i >= 0; i-- {
for k, v := range v.blockParams[i] {
if name == k {
return v
}
}
}
return nil
}
|
go
|
func (v *evalVisitor) blockParam(name string) interface{} {
for i := len(v.blockParams) - 1; i >= 0; i-- {
for k, v := range v.blockParams[i] {
if name == k {
return v
}
}
}
return nil
}
|
[
"func",
"(",
"v",
"*",
"evalVisitor",
")",
"blockParam",
"(",
"name",
"string",
")",
"interface",
"{",
"}",
"{",
"for",
"i",
":=",
"len",
"(",
"v",
".",
"blockParams",
")",
"-",
"1",
";",
"i",
">=",
"0",
";",
"i",
"--",
"{",
"for",
"k",
",",
"v",
":=",
"range",
"v",
".",
"blockParams",
"[",
"i",
"]",
"{",
"if",
"name",
"==",
"k",
"{",
"return",
"v",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// blockParam iterates on stack to find given block parameter, and returns its value or nil if not founc
|
[
"blockParam",
"iterates",
"on",
"stack",
"to",
"find",
"given",
"block",
"parameter",
"and",
"returns",
"its",
"value",
"or",
"nil",
"if",
"not",
"founc"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/eval.go#L146-L156
|
556 |
aymerick/raymond
|
eval.go
|
pushBlock
|
func (v *evalVisitor) pushBlock(block *ast.BlockStatement) {
v.blocks = append(v.blocks, block)
}
|
go
|
func (v *evalVisitor) pushBlock(block *ast.BlockStatement) {
v.blocks = append(v.blocks, block)
}
|
[
"func",
"(",
"v",
"*",
"evalVisitor",
")",
"pushBlock",
"(",
"block",
"*",
"ast",
".",
"BlockStatement",
")",
"{",
"v",
".",
"blocks",
"=",
"append",
"(",
"v",
".",
"blocks",
",",
"block",
")",
"\n",
"}"
] |
//
// Blocks stack
//
// pushBlock pushes new block statement to stack
|
[
"Blocks",
"stack",
"pushBlock",
"pushes",
"new",
"block",
"statement",
"to",
"stack"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/eval.go#L163-L165
|
557 |
aymerick/raymond
|
eval.go
|
popBlock
|
func (v *evalVisitor) popBlock() *ast.BlockStatement {
if len(v.blocks) == 0 {
return nil
}
var result *ast.BlockStatement
result, v.blocks = v.blocks[len(v.blocks)-1], v.blocks[:len(v.blocks)-1]
return result
}
|
go
|
func (v *evalVisitor) popBlock() *ast.BlockStatement {
if len(v.blocks) == 0 {
return nil
}
var result *ast.BlockStatement
result, v.blocks = v.blocks[len(v.blocks)-1], v.blocks[:len(v.blocks)-1]
return result
}
|
[
"func",
"(",
"v",
"*",
"evalVisitor",
")",
"popBlock",
"(",
")",
"*",
"ast",
".",
"BlockStatement",
"{",
"if",
"len",
"(",
"v",
".",
"blocks",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"var",
"result",
"*",
"ast",
".",
"BlockStatement",
"\n",
"result",
",",
"v",
".",
"blocks",
"=",
"v",
".",
"blocks",
"[",
"len",
"(",
"v",
".",
"blocks",
")",
"-",
"1",
"]",
",",
"v",
".",
"blocks",
"[",
":",
"len",
"(",
"v",
".",
"blocks",
")",
"-",
"1",
"]",
"\n\n",
"return",
"result",
"\n",
"}"
] |
// popBlock pops last block statement from stack
|
[
"popBlock",
"pops",
"last",
"block",
"statement",
"from",
"stack"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/eval.go#L168-L177
|
558 |
aymerick/raymond
|
eval.go
|
curBlock
|
func (v *evalVisitor) curBlock() *ast.BlockStatement {
if len(v.blocks) == 0 {
return nil
}
return v.blocks[len(v.blocks)-1]
}
|
go
|
func (v *evalVisitor) curBlock() *ast.BlockStatement {
if len(v.blocks) == 0 {
return nil
}
return v.blocks[len(v.blocks)-1]
}
|
[
"func",
"(",
"v",
"*",
"evalVisitor",
")",
"curBlock",
"(",
")",
"*",
"ast",
".",
"BlockStatement",
"{",
"if",
"len",
"(",
"v",
".",
"blocks",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"return",
"v",
".",
"blocks",
"[",
"len",
"(",
"v",
".",
"blocks",
")",
"-",
"1",
"]",
"\n",
"}"
] |
// curBlock returns current block statement
|
[
"curBlock",
"returns",
"current",
"block",
"statement"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/eval.go#L180-L186
|
559 |
aymerick/raymond
|
eval.go
|
pushExpr
|
func (v *evalVisitor) pushExpr(expression *ast.Expression) {
v.exprs = append(v.exprs, expression)
}
|
go
|
func (v *evalVisitor) pushExpr(expression *ast.Expression) {
v.exprs = append(v.exprs, expression)
}
|
[
"func",
"(",
"v",
"*",
"evalVisitor",
")",
"pushExpr",
"(",
"expression",
"*",
"ast",
".",
"Expression",
")",
"{",
"v",
".",
"exprs",
"=",
"append",
"(",
"v",
".",
"exprs",
",",
"expression",
")",
"\n",
"}"
] |
//
// Expressions stack
//
// pushExpr pushes new expression to stack
|
[
"Expressions",
"stack",
"pushExpr",
"pushes",
"new",
"expression",
"to",
"stack"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/eval.go#L193-L195
|
560 |
aymerick/raymond
|
eval.go
|
popExpr
|
func (v *evalVisitor) popExpr() *ast.Expression {
if len(v.exprs) == 0 {
return nil
}
var result *ast.Expression
result, v.exprs = v.exprs[len(v.exprs)-1], v.exprs[:len(v.exprs)-1]
return result
}
|
go
|
func (v *evalVisitor) popExpr() *ast.Expression {
if len(v.exprs) == 0 {
return nil
}
var result *ast.Expression
result, v.exprs = v.exprs[len(v.exprs)-1], v.exprs[:len(v.exprs)-1]
return result
}
|
[
"func",
"(",
"v",
"*",
"evalVisitor",
")",
"popExpr",
"(",
")",
"*",
"ast",
".",
"Expression",
"{",
"if",
"len",
"(",
"v",
".",
"exprs",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"var",
"result",
"*",
"ast",
".",
"Expression",
"\n",
"result",
",",
"v",
".",
"exprs",
"=",
"v",
".",
"exprs",
"[",
"len",
"(",
"v",
".",
"exprs",
")",
"-",
"1",
"]",
",",
"v",
".",
"exprs",
"[",
":",
"len",
"(",
"v",
".",
"exprs",
")",
"-",
"1",
"]",
"\n\n",
"return",
"result",
"\n",
"}"
] |
// popExpr pops last expression from stack
|
[
"popExpr",
"pops",
"last",
"expression",
"from",
"stack"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/eval.go#L198-L207
|
561 |
aymerick/raymond
|
eval.go
|
curExpr
|
func (v *evalVisitor) curExpr() *ast.Expression {
if len(v.exprs) == 0 {
return nil
}
return v.exprs[len(v.exprs)-1]
}
|
go
|
func (v *evalVisitor) curExpr() *ast.Expression {
if len(v.exprs) == 0 {
return nil
}
return v.exprs[len(v.exprs)-1]
}
|
[
"func",
"(",
"v",
"*",
"evalVisitor",
")",
"curExpr",
"(",
")",
"*",
"ast",
".",
"Expression",
"{",
"if",
"len",
"(",
"v",
".",
"exprs",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"return",
"v",
".",
"exprs",
"[",
"len",
"(",
"v",
".",
"exprs",
")",
"-",
"1",
"]",
"\n",
"}"
] |
// curExpr returns current expression
|
[
"curExpr",
"returns",
"current",
"expression"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/eval.go#L210-L216
|
562 |
aymerick/raymond
|
eval.go
|
errPanic
|
func (v *evalVisitor) errPanic(err error) {
panic(fmt.Errorf("Evaluation error: %s\nCurrent node:\n\t%s", err, v.curNode))
}
|
go
|
func (v *evalVisitor) errPanic(err error) {
panic(fmt.Errorf("Evaluation error: %s\nCurrent node:\n\t%s", err, v.curNode))
}
|
[
"func",
"(",
"v",
"*",
"evalVisitor",
")",
"errPanic",
"(",
"err",
"error",
")",
"{",
"panic",
"(",
"fmt",
".",
"Errorf",
"(",
"\"",
"\\n",
"\\n",
"\\t",
"\"",
",",
"err",
",",
"v",
".",
"curNode",
")",
")",
"\n",
"}"
] |
//
// Error functions
//
// errPanic panics
|
[
"Error",
"functions",
"errPanic",
"panics"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/eval.go#L223-L225
|
563 |
aymerick/raymond
|
eval.go
|
errorf
|
func (v *evalVisitor) errorf(format string, args ...interface{}) {
v.errPanic(fmt.Errorf(format, args...))
}
|
go
|
func (v *evalVisitor) errorf(format string, args ...interface{}) {
v.errPanic(fmt.Errorf(format, args...))
}
|
[
"func",
"(",
"v",
"*",
"evalVisitor",
")",
"errorf",
"(",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"v",
".",
"errPanic",
"(",
"fmt",
".",
"Errorf",
"(",
"format",
",",
"args",
"...",
")",
")",
"\n",
"}"
] |
// errorf panics with a custom message
|
[
"errorf",
"panics",
"with",
"a",
"custom",
"message"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/eval.go#L228-L230
|
564 |
aymerick/raymond
|
eval.go
|
evalProgram
|
func (v *evalVisitor) evalProgram(program *ast.Program, ctx interface{}, data *DataFrame, key interface{}) string {
blockParams := make(map[string]interface{})
// compute block params
if len(program.BlockParams) > 0 {
blockParams[program.BlockParams[0]] = ctx
}
if (len(program.BlockParams) > 1) && (key != nil) {
blockParams[program.BlockParams[1]] = key
}
// push contexts
if len(blockParams) > 0 {
v.pushBlockParams(blockParams)
}
ctxVal := reflect.ValueOf(ctx)
if ctxVal.IsValid() {
v.pushCtx(ctxVal)
}
if data != nil {
v.setDataFrame(data)
}
// evaluate program
result, _ := program.Accept(v).(string)
// pop contexts
if data != nil {
v.popDataFrame()
}
if ctxVal.IsValid() {
v.popCtx()
}
if len(blockParams) > 0 {
v.popBlockParams()
}
return result
}
|
go
|
func (v *evalVisitor) evalProgram(program *ast.Program, ctx interface{}, data *DataFrame, key interface{}) string {
blockParams := make(map[string]interface{})
// compute block params
if len(program.BlockParams) > 0 {
blockParams[program.BlockParams[0]] = ctx
}
if (len(program.BlockParams) > 1) && (key != nil) {
blockParams[program.BlockParams[1]] = key
}
// push contexts
if len(blockParams) > 0 {
v.pushBlockParams(blockParams)
}
ctxVal := reflect.ValueOf(ctx)
if ctxVal.IsValid() {
v.pushCtx(ctxVal)
}
if data != nil {
v.setDataFrame(data)
}
// evaluate program
result, _ := program.Accept(v).(string)
// pop contexts
if data != nil {
v.popDataFrame()
}
if ctxVal.IsValid() {
v.popCtx()
}
if len(blockParams) > 0 {
v.popBlockParams()
}
return result
}
|
[
"func",
"(",
"v",
"*",
"evalVisitor",
")",
"evalProgram",
"(",
"program",
"*",
"ast",
".",
"Program",
",",
"ctx",
"interface",
"{",
"}",
",",
"data",
"*",
"DataFrame",
",",
"key",
"interface",
"{",
"}",
")",
"string",
"{",
"blockParams",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n\n",
"// compute block params",
"if",
"len",
"(",
"program",
".",
"BlockParams",
")",
">",
"0",
"{",
"blockParams",
"[",
"program",
".",
"BlockParams",
"[",
"0",
"]",
"]",
"=",
"ctx",
"\n",
"}",
"\n\n",
"if",
"(",
"len",
"(",
"program",
".",
"BlockParams",
")",
">",
"1",
")",
"&&",
"(",
"key",
"!=",
"nil",
")",
"{",
"blockParams",
"[",
"program",
".",
"BlockParams",
"[",
"1",
"]",
"]",
"=",
"key",
"\n",
"}",
"\n\n",
"// push contexts",
"if",
"len",
"(",
"blockParams",
")",
">",
"0",
"{",
"v",
".",
"pushBlockParams",
"(",
"blockParams",
")",
"\n",
"}",
"\n\n",
"ctxVal",
":=",
"reflect",
".",
"ValueOf",
"(",
"ctx",
")",
"\n",
"if",
"ctxVal",
".",
"IsValid",
"(",
")",
"{",
"v",
".",
"pushCtx",
"(",
"ctxVal",
")",
"\n",
"}",
"\n\n",
"if",
"data",
"!=",
"nil",
"{",
"v",
".",
"setDataFrame",
"(",
"data",
")",
"\n",
"}",
"\n\n",
"// evaluate program",
"result",
",",
"_",
":=",
"program",
".",
"Accept",
"(",
"v",
")",
".",
"(",
"string",
")",
"\n\n",
"// pop contexts",
"if",
"data",
"!=",
"nil",
"{",
"v",
".",
"popDataFrame",
"(",
")",
"\n",
"}",
"\n\n",
"if",
"ctxVal",
".",
"IsValid",
"(",
")",
"{",
"v",
".",
"popCtx",
"(",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"blockParams",
")",
">",
"0",
"{",
"v",
".",
"popBlockParams",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"result",
"\n",
"}"
] |
//
// Evaluation
//
// evalProgram eEvaluates program with given context and returns string result
|
[
"Evaluation",
"evalProgram",
"eEvaluates",
"program",
"with",
"given",
"context",
"and",
"returns",
"string",
"result"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/eval.go#L237-L280
|
565 |
aymerick/raymond
|
eval.go
|
evalPath
|
func (v *evalVisitor) evalPath(ctx reflect.Value, parts []string, exprRoot bool) (reflect.Value, bool) {
partResolved := false
for i := 0; i < len(parts); i++ {
part := parts[i]
// "[foo bar]"" => "foo bar"
if (len(part) >= 2) && (part[0] == '[') && (part[len(part)-1] == ']') {
part = part[1 : len(part)-1]
}
ctx = v.evalField(ctx, part, exprRoot)
if !ctx.IsValid() {
break
}
// we resolved at least one part of path
partResolved = true
}
return ctx, partResolved
}
|
go
|
func (v *evalVisitor) evalPath(ctx reflect.Value, parts []string, exprRoot bool) (reflect.Value, bool) {
partResolved := false
for i := 0; i < len(parts); i++ {
part := parts[i]
// "[foo bar]"" => "foo bar"
if (len(part) >= 2) && (part[0] == '[') && (part[len(part)-1] == ']') {
part = part[1 : len(part)-1]
}
ctx = v.evalField(ctx, part, exprRoot)
if !ctx.IsValid() {
break
}
// we resolved at least one part of path
partResolved = true
}
return ctx, partResolved
}
|
[
"func",
"(",
"v",
"*",
"evalVisitor",
")",
"evalPath",
"(",
"ctx",
"reflect",
".",
"Value",
",",
"parts",
"[",
"]",
"string",
",",
"exprRoot",
"bool",
")",
"(",
"reflect",
".",
"Value",
",",
"bool",
")",
"{",
"partResolved",
":=",
"false",
"\n\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"parts",
")",
";",
"i",
"++",
"{",
"part",
":=",
"parts",
"[",
"i",
"]",
"\n\n",
"// \"[foo bar]\"\" => \"foo bar\"",
"if",
"(",
"len",
"(",
"part",
")",
">=",
"2",
")",
"&&",
"(",
"part",
"[",
"0",
"]",
"==",
"'['",
")",
"&&",
"(",
"part",
"[",
"len",
"(",
"part",
")",
"-",
"1",
"]",
"==",
"']'",
")",
"{",
"part",
"=",
"part",
"[",
"1",
":",
"len",
"(",
"part",
")",
"-",
"1",
"]",
"\n",
"}",
"\n\n",
"ctx",
"=",
"v",
".",
"evalField",
"(",
"ctx",
",",
"part",
",",
"exprRoot",
")",
"\n",
"if",
"!",
"ctx",
".",
"IsValid",
"(",
")",
"{",
"break",
"\n",
"}",
"\n\n",
"// we resolved at least one part of path",
"partResolved",
"=",
"true",
"\n",
"}",
"\n\n",
"return",
"ctx",
",",
"partResolved",
"\n",
"}"
] |
// evalPath evaluates all path parts with given context
|
[
"evalPath",
"evaluates",
"all",
"path",
"parts",
"with",
"given",
"context"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/eval.go#L283-L304
|
566 |
aymerick/raymond
|
eval.go
|
evalField
|
func (v *evalVisitor) evalField(ctx reflect.Value, fieldName string, exprRoot bool) reflect.Value {
result := zero
ctx, _ = indirect(ctx)
if !ctx.IsValid() {
return result
}
// check if this is a method call
result, isMeth := v.evalMethod(ctx, fieldName, exprRoot)
if !isMeth {
switch ctx.Kind() {
case reflect.Struct:
// example: firstName => FirstName
expFieldName := strings.Title(fieldName)
// check if struct have this field and that it is exported
if tField, ok := ctx.Type().FieldByName(expFieldName); ok && (tField.PkgPath == "") {
// struct field
result = ctx.FieldByIndex(tField.Index)
break
}
// attempts to find template variable name as a struct tag
result = v.evalStructTag(ctx, fieldName)
case reflect.Map:
nameVal := reflect.ValueOf(fieldName)
if nameVal.Type().AssignableTo(ctx.Type().Key()) {
// map key
result = ctx.MapIndex(nameVal)
}
case reflect.Array, reflect.Slice:
if i, err := strconv.Atoi(fieldName); (err == nil) && (i < ctx.Len()) {
result = ctx.Index(i)
}
}
}
// check if result is a function
result, _ = indirect(result)
if result.Kind() == reflect.Func {
result = v.evalFieldFunc(fieldName, result, exprRoot)
}
return result
}
|
go
|
func (v *evalVisitor) evalField(ctx reflect.Value, fieldName string, exprRoot bool) reflect.Value {
result := zero
ctx, _ = indirect(ctx)
if !ctx.IsValid() {
return result
}
// check if this is a method call
result, isMeth := v.evalMethod(ctx, fieldName, exprRoot)
if !isMeth {
switch ctx.Kind() {
case reflect.Struct:
// example: firstName => FirstName
expFieldName := strings.Title(fieldName)
// check if struct have this field and that it is exported
if tField, ok := ctx.Type().FieldByName(expFieldName); ok && (tField.PkgPath == "") {
// struct field
result = ctx.FieldByIndex(tField.Index)
break
}
// attempts to find template variable name as a struct tag
result = v.evalStructTag(ctx, fieldName)
case reflect.Map:
nameVal := reflect.ValueOf(fieldName)
if nameVal.Type().AssignableTo(ctx.Type().Key()) {
// map key
result = ctx.MapIndex(nameVal)
}
case reflect.Array, reflect.Slice:
if i, err := strconv.Atoi(fieldName); (err == nil) && (i < ctx.Len()) {
result = ctx.Index(i)
}
}
}
// check if result is a function
result, _ = indirect(result)
if result.Kind() == reflect.Func {
result = v.evalFieldFunc(fieldName, result, exprRoot)
}
return result
}
|
[
"func",
"(",
"v",
"*",
"evalVisitor",
")",
"evalField",
"(",
"ctx",
"reflect",
".",
"Value",
",",
"fieldName",
"string",
",",
"exprRoot",
"bool",
")",
"reflect",
".",
"Value",
"{",
"result",
":=",
"zero",
"\n\n",
"ctx",
",",
"_",
"=",
"indirect",
"(",
"ctx",
")",
"\n",
"if",
"!",
"ctx",
".",
"IsValid",
"(",
")",
"{",
"return",
"result",
"\n",
"}",
"\n\n",
"// check if this is a method call",
"result",
",",
"isMeth",
":=",
"v",
".",
"evalMethod",
"(",
"ctx",
",",
"fieldName",
",",
"exprRoot",
")",
"\n",
"if",
"!",
"isMeth",
"{",
"switch",
"ctx",
".",
"Kind",
"(",
")",
"{",
"case",
"reflect",
".",
"Struct",
":",
"// example: firstName => FirstName",
"expFieldName",
":=",
"strings",
".",
"Title",
"(",
"fieldName",
")",
"\n\n",
"// check if struct have this field and that it is exported",
"if",
"tField",
",",
"ok",
":=",
"ctx",
".",
"Type",
"(",
")",
".",
"FieldByName",
"(",
"expFieldName",
")",
";",
"ok",
"&&",
"(",
"tField",
".",
"PkgPath",
"==",
"\"",
"\"",
")",
"{",
"// struct field",
"result",
"=",
"ctx",
".",
"FieldByIndex",
"(",
"tField",
".",
"Index",
")",
"\n",
"break",
"\n",
"}",
"\n\n",
"// attempts to find template variable name as a struct tag",
"result",
"=",
"v",
".",
"evalStructTag",
"(",
"ctx",
",",
"fieldName",
")",
"\n",
"case",
"reflect",
".",
"Map",
":",
"nameVal",
":=",
"reflect",
".",
"ValueOf",
"(",
"fieldName",
")",
"\n",
"if",
"nameVal",
".",
"Type",
"(",
")",
".",
"AssignableTo",
"(",
"ctx",
".",
"Type",
"(",
")",
".",
"Key",
"(",
")",
")",
"{",
"// map key",
"result",
"=",
"ctx",
".",
"MapIndex",
"(",
"nameVal",
")",
"\n",
"}",
"\n",
"case",
"reflect",
".",
"Array",
",",
"reflect",
".",
"Slice",
":",
"if",
"i",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"fieldName",
")",
";",
"(",
"err",
"==",
"nil",
")",
"&&",
"(",
"i",
"<",
"ctx",
".",
"Len",
"(",
")",
")",
"{",
"result",
"=",
"ctx",
".",
"Index",
"(",
"i",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"// check if result is a function",
"result",
",",
"_",
"=",
"indirect",
"(",
"result",
")",
"\n",
"if",
"result",
".",
"Kind",
"(",
")",
"==",
"reflect",
".",
"Func",
"{",
"result",
"=",
"v",
".",
"evalFieldFunc",
"(",
"fieldName",
",",
"result",
",",
"exprRoot",
")",
"\n",
"}",
"\n\n",
"return",
"result",
"\n",
"}"
] |
// evalField evaluates field with given context
|
[
"evalField",
"evaluates",
"field",
"with",
"given",
"context"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/eval.go#L307-L352
|
567 |
aymerick/raymond
|
eval.go
|
evalMethod
|
func (v *evalVisitor) evalMethod(ctx reflect.Value, name string, exprRoot bool) (reflect.Value, bool) {
if ctx.Kind() != reflect.Interface && ctx.CanAddr() {
ctx = ctx.Addr()
}
method := ctx.MethodByName(name)
if !method.IsValid() {
// example: subject() => Subject()
method = ctx.MethodByName(strings.Title(name))
}
if !method.IsValid() {
return zero, false
}
return v.evalFieldFunc(name, method, exprRoot), true
}
|
go
|
func (v *evalVisitor) evalMethod(ctx reflect.Value, name string, exprRoot bool) (reflect.Value, bool) {
if ctx.Kind() != reflect.Interface && ctx.CanAddr() {
ctx = ctx.Addr()
}
method := ctx.MethodByName(name)
if !method.IsValid() {
// example: subject() => Subject()
method = ctx.MethodByName(strings.Title(name))
}
if !method.IsValid() {
return zero, false
}
return v.evalFieldFunc(name, method, exprRoot), true
}
|
[
"func",
"(",
"v",
"*",
"evalVisitor",
")",
"evalMethod",
"(",
"ctx",
"reflect",
".",
"Value",
",",
"name",
"string",
",",
"exprRoot",
"bool",
")",
"(",
"reflect",
".",
"Value",
",",
"bool",
")",
"{",
"if",
"ctx",
".",
"Kind",
"(",
")",
"!=",
"reflect",
".",
"Interface",
"&&",
"ctx",
".",
"CanAddr",
"(",
")",
"{",
"ctx",
"=",
"ctx",
".",
"Addr",
"(",
")",
"\n",
"}",
"\n\n",
"method",
":=",
"ctx",
".",
"MethodByName",
"(",
"name",
")",
"\n",
"if",
"!",
"method",
".",
"IsValid",
"(",
")",
"{",
"// example: subject() => Subject()",
"method",
"=",
"ctx",
".",
"MethodByName",
"(",
"strings",
".",
"Title",
"(",
"name",
")",
")",
"\n",
"}",
"\n\n",
"if",
"!",
"method",
".",
"IsValid",
"(",
")",
"{",
"return",
"zero",
",",
"false",
"\n",
"}",
"\n\n",
"return",
"v",
".",
"evalFieldFunc",
"(",
"name",
",",
"method",
",",
"exprRoot",
")",
",",
"true",
"\n",
"}"
] |
// evalFieldFunc tries to evaluate given method name, and a boolean to indicate if this was a method call
|
[
"evalFieldFunc",
"tries",
"to",
"evaluate",
"given",
"method",
"name",
"and",
"a",
"boolean",
"to",
"indicate",
"if",
"this",
"was",
"a",
"method",
"call"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/eval.go#L355-L371
|
568 |
aymerick/raymond
|
eval.go
|
evalFieldFunc
|
func (v *evalVisitor) evalFieldFunc(name string, funcVal reflect.Value, exprRoot bool) reflect.Value {
ensureValidHelper(name, funcVal)
var options *Options
if exprRoot {
// create function arg with all params/hash
expr := v.curExpr()
options = v.helperOptions(expr)
// ok, that expression was a function call
v.exprFunc[expr] = true
} else {
// we are not at root of expression, so we are a parameter... and we don't like
// infinite loops caused by trying to parse ourself forever
options = newEmptyOptions(v)
}
return v.callFunc(name, funcVal, options)
}
|
go
|
func (v *evalVisitor) evalFieldFunc(name string, funcVal reflect.Value, exprRoot bool) reflect.Value {
ensureValidHelper(name, funcVal)
var options *Options
if exprRoot {
// create function arg with all params/hash
expr := v.curExpr()
options = v.helperOptions(expr)
// ok, that expression was a function call
v.exprFunc[expr] = true
} else {
// we are not at root of expression, so we are a parameter... and we don't like
// infinite loops caused by trying to parse ourself forever
options = newEmptyOptions(v)
}
return v.callFunc(name, funcVal, options)
}
|
[
"func",
"(",
"v",
"*",
"evalVisitor",
")",
"evalFieldFunc",
"(",
"name",
"string",
",",
"funcVal",
"reflect",
".",
"Value",
",",
"exprRoot",
"bool",
")",
"reflect",
".",
"Value",
"{",
"ensureValidHelper",
"(",
"name",
",",
"funcVal",
")",
"\n\n",
"var",
"options",
"*",
"Options",
"\n",
"if",
"exprRoot",
"{",
"// create function arg with all params/hash",
"expr",
":=",
"v",
".",
"curExpr",
"(",
")",
"\n",
"options",
"=",
"v",
".",
"helperOptions",
"(",
"expr",
")",
"\n\n",
"// ok, that expression was a function call",
"v",
".",
"exprFunc",
"[",
"expr",
"]",
"=",
"true",
"\n",
"}",
"else",
"{",
"// we are not at root of expression, so we are a parameter... and we don't like",
"// infinite loops caused by trying to parse ourself forever",
"options",
"=",
"newEmptyOptions",
"(",
"v",
")",
"\n",
"}",
"\n\n",
"return",
"v",
".",
"callFunc",
"(",
"name",
",",
"funcVal",
",",
"options",
")",
"\n",
"}"
] |
// evalFieldFunc evaluates given function
|
[
"evalFieldFunc",
"evaluates",
"given",
"function"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/eval.go#L374-L392
|
569 |
aymerick/raymond
|
eval.go
|
evalStructTag
|
func (v *evalVisitor) evalStructTag(ctx reflect.Value, name string) reflect.Value {
val := reflect.ValueOf(ctx.Interface())
for i := 0; i < val.NumField(); i++ {
field := val.Type().Field(i)
tag := field.Tag.Get("handlebars")
if tag == name {
return val.Field(i)
}
}
return zero
}
|
go
|
func (v *evalVisitor) evalStructTag(ctx reflect.Value, name string) reflect.Value {
val := reflect.ValueOf(ctx.Interface())
for i := 0; i < val.NumField(); i++ {
field := val.Type().Field(i)
tag := field.Tag.Get("handlebars")
if tag == name {
return val.Field(i)
}
}
return zero
}
|
[
"func",
"(",
"v",
"*",
"evalVisitor",
")",
"evalStructTag",
"(",
"ctx",
"reflect",
".",
"Value",
",",
"name",
"string",
")",
"reflect",
".",
"Value",
"{",
"val",
":=",
"reflect",
".",
"ValueOf",
"(",
"ctx",
".",
"Interface",
"(",
")",
")",
"\n\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"val",
".",
"NumField",
"(",
")",
";",
"i",
"++",
"{",
"field",
":=",
"val",
".",
"Type",
"(",
")",
".",
"Field",
"(",
"i",
")",
"\n",
"tag",
":=",
"field",
".",
"Tag",
".",
"Get",
"(",
"\"",
"\"",
")",
"\n",
"if",
"tag",
"==",
"name",
"{",
"return",
"val",
".",
"Field",
"(",
"i",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"zero",
"\n",
"}"
] |
// evalStructTag checks for the existence of a struct tag containing the
// name of the variable in the template. This allows for a template variable to
// be separated from the field in the struct.
|
[
"evalStructTag",
"checks",
"for",
"the",
"existence",
"of",
"a",
"struct",
"tag",
"containing",
"the",
"name",
"of",
"the",
"variable",
"in",
"the",
"template",
".",
"This",
"allows",
"for",
"a",
"template",
"variable",
"to",
"be",
"separated",
"from",
"the",
"field",
"in",
"the",
"struct",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/eval.go#L397-L409
|
570 |
aymerick/raymond
|
eval.go
|
findBlockParam
|
func (v *evalVisitor) findBlockParam(node *ast.PathExpression) (string, interface{}) {
if len(node.Parts) > 0 {
name := node.Parts[0]
if value := v.blockParam(name); value != nil {
return name, value
}
}
return "", nil
}
|
go
|
func (v *evalVisitor) findBlockParam(node *ast.PathExpression) (string, interface{}) {
if len(node.Parts) > 0 {
name := node.Parts[0]
if value := v.blockParam(name); value != nil {
return name, value
}
}
return "", nil
}
|
[
"func",
"(",
"v",
"*",
"evalVisitor",
")",
"findBlockParam",
"(",
"node",
"*",
"ast",
".",
"PathExpression",
")",
"(",
"string",
",",
"interface",
"{",
"}",
")",
"{",
"if",
"len",
"(",
"node",
".",
"Parts",
")",
">",
"0",
"{",
"name",
":=",
"node",
".",
"Parts",
"[",
"0",
"]",
"\n",
"if",
"value",
":=",
"v",
".",
"blockParam",
"(",
"name",
")",
";",
"value",
"!=",
"nil",
"{",
"return",
"name",
",",
"value",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"\"",
"\"",
",",
"nil",
"\n",
"}"
] |
// findBlockParam returns node's block parameter
|
[
"findBlockParam",
"returns",
"node",
"s",
"block",
"parameter"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/eval.go#L412-L421
|
571 |
aymerick/raymond
|
eval.go
|
evalPathExpression
|
func (v *evalVisitor) evalPathExpression(node *ast.PathExpression, exprRoot bool) interface{} {
var result interface{}
if name, value := v.findBlockParam(node); value != nil {
// block parameter value
// We push a new context so we can evaluate the path expression (note: this may be a bad idea).
//
// Example:
// {{#foo as |bar|}}
// {{bar.baz}}
// {{/foo}}
//
// With data:
// {"foo": {"baz": "bat"}}
newCtx := map[string]interface{}{name: value}
v.pushCtx(reflect.ValueOf(newCtx))
result = v.evalCtxPathExpression(node, exprRoot)
v.popCtx()
} else {
ctxTried := false
if node.IsDataRoot() {
// context path
result = v.evalCtxPathExpression(node, exprRoot)
ctxTried = true
}
if (result == nil) && node.Data {
// if it is @root, then we tried to evaluate with root context but nothing was found
// so let's try with private data
// private data
result = v.evalDataPathExpression(node, exprRoot)
}
if (result == nil) && !ctxTried {
// context path
result = v.evalCtxPathExpression(node, exprRoot)
}
}
return result
}
|
go
|
func (v *evalVisitor) evalPathExpression(node *ast.PathExpression, exprRoot bool) interface{} {
var result interface{}
if name, value := v.findBlockParam(node); value != nil {
// block parameter value
// We push a new context so we can evaluate the path expression (note: this may be a bad idea).
//
// Example:
// {{#foo as |bar|}}
// {{bar.baz}}
// {{/foo}}
//
// With data:
// {"foo": {"baz": "bat"}}
newCtx := map[string]interface{}{name: value}
v.pushCtx(reflect.ValueOf(newCtx))
result = v.evalCtxPathExpression(node, exprRoot)
v.popCtx()
} else {
ctxTried := false
if node.IsDataRoot() {
// context path
result = v.evalCtxPathExpression(node, exprRoot)
ctxTried = true
}
if (result == nil) && node.Data {
// if it is @root, then we tried to evaluate with root context but nothing was found
// so let's try with private data
// private data
result = v.evalDataPathExpression(node, exprRoot)
}
if (result == nil) && !ctxTried {
// context path
result = v.evalCtxPathExpression(node, exprRoot)
}
}
return result
}
|
[
"func",
"(",
"v",
"*",
"evalVisitor",
")",
"evalPathExpression",
"(",
"node",
"*",
"ast",
".",
"PathExpression",
",",
"exprRoot",
"bool",
")",
"interface",
"{",
"}",
"{",
"var",
"result",
"interface",
"{",
"}",
"\n\n",
"if",
"name",
",",
"value",
":=",
"v",
".",
"findBlockParam",
"(",
"node",
")",
";",
"value",
"!=",
"nil",
"{",
"// block parameter value",
"// We push a new context so we can evaluate the path expression (note: this may be a bad idea).",
"//",
"// Example:",
"// {{#foo as |bar|}}",
"// {{bar.baz}}",
"// {{/foo}}",
"//",
"// With data:",
"// {\"foo\": {\"baz\": \"bat\"}}",
"newCtx",
":=",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"name",
":",
"value",
"}",
"\n\n",
"v",
".",
"pushCtx",
"(",
"reflect",
".",
"ValueOf",
"(",
"newCtx",
")",
")",
"\n",
"result",
"=",
"v",
".",
"evalCtxPathExpression",
"(",
"node",
",",
"exprRoot",
")",
"\n",
"v",
".",
"popCtx",
"(",
")",
"\n",
"}",
"else",
"{",
"ctxTried",
":=",
"false",
"\n\n",
"if",
"node",
".",
"IsDataRoot",
"(",
")",
"{",
"// context path",
"result",
"=",
"v",
".",
"evalCtxPathExpression",
"(",
"node",
",",
"exprRoot",
")",
"\n\n",
"ctxTried",
"=",
"true",
"\n",
"}",
"\n\n",
"if",
"(",
"result",
"==",
"nil",
")",
"&&",
"node",
".",
"Data",
"{",
"// if it is @root, then we tried to evaluate with root context but nothing was found",
"// so let's try with private data",
"// private data",
"result",
"=",
"v",
".",
"evalDataPathExpression",
"(",
"node",
",",
"exprRoot",
")",
"\n",
"}",
"\n\n",
"if",
"(",
"result",
"==",
"nil",
")",
"&&",
"!",
"ctxTried",
"{",
"// context path",
"result",
"=",
"v",
".",
"evalCtxPathExpression",
"(",
"node",
",",
"exprRoot",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"result",
"\n",
"}"
] |
// evalPathExpression evaluates a path expression
|
[
"evalPathExpression",
"evaluates",
"a",
"path",
"expression"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/eval.go#L424-L469
|
572 |
aymerick/raymond
|
eval.go
|
evalDataPathExpression
|
func (v *evalVisitor) evalDataPathExpression(node *ast.PathExpression, exprRoot bool) interface{} {
// find data frame
frame := v.dataFrame
for i := node.Depth; i > 0; i-- {
if frame.parent == nil {
return nil
}
frame = frame.parent
}
// resolve data
// @note Can be changed to v.evalCtx() as context can't be an array
result, _ := v.evalCtxPath(reflect.ValueOf(frame.data), node.Parts, exprRoot)
return result
}
|
go
|
func (v *evalVisitor) evalDataPathExpression(node *ast.PathExpression, exprRoot bool) interface{} {
// find data frame
frame := v.dataFrame
for i := node.Depth; i > 0; i-- {
if frame.parent == nil {
return nil
}
frame = frame.parent
}
// resolve data
// @note Can be changed to v.evalCtx() as context can't be an array
result, _ := v.evalCtxPath(reflect.ValueOf(frame.data), node.Parts, exprRoot)
return result
}
|
[
"func",
"(",
"v",
"*",
"evalVisitor",
")",
"evalDataPathExpression",
"(",
"node",
"*",
"ast",
".",
"PathExpression",
",",
"exprRoot",
"bool",
")",
"interface",
"{",
"}",
"{",
"// find data frame",
"frame",
":=",
"v",
".",
"dataFrame",
"\n",
"for",
"i",
":=",
"node",
".",
"Depth",
";",
"i",
">",
"0",
";",
"i",
"--",
"{",
"if",
"frame",
".",
"parent",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"frame",
"=",
"frame",
".",
"parent",
"\n",
"}",
"\n\n",
"// resolve data",
"// @note Can be changed to v.evalCtx() as context can't be an array",
"result",
",",
"_",
":=",
"v",
".",
"evalCtxPath",
"(",
"reflect",
".",
"ValueOf",
"(",
"frame",
".",
"data",
")",
",",
"node",
".",
"Parts",
",",
"exprRoot",
")",
"\n",
"return",
"result",
"\n",
"}"
] |
// evalDataPathExpression evaluates a private data path expression
|
[
"evalDataPathExpression",
"evaluates",
"a",
"private",
"data",
"path",
"expression"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/eval.go#L472-L486
|
573 |
aymerick/raymond
|
eval.go
|
evalCtxPathExpression
|
func (v *evalVisitor) evalCtxPathExpression(node *ast.PathExpression, exprRoot bool) interface{} {
v.at(node)
if node.IsDataRoot() {
// `@root` - remove the first part
parts := node.Parts[1:len(node.Parts)]
result, _ := v.evalCtxPath(v.rootCtx(), parts, exprRoot)
return result
}
return v.evalDepthPath(node.Depth, node.Parts, exprRoot)
}
|
go
|
func (v *evalVisitor) evalCtxPathExpression(node *ast.PathExpression, exprRoot bool) interface{} {
v.at(node)
if node.IsDataRoot() {
// `@root` - remove the first part
parts := node.Parts[1:len(node.Parts)]
result, _ := v.evalCtxPath(v.rootCtx(), parts, exprRoot)
return result
}
return v.evalDepthPath(node.Depth, node.Parts, exprRoot)
}
|
[
"func",
"(",
"v",
"*",
"evalVisitor",
")",
"evalCtxPathExpression",
"(",
"node",
"*",
"ast",
".",
"PathExpression",
",",
"exprRoot",
"bool",
")",
"interface",
"{",
"}",
"{",
"v",
".",
"at",
"(",
"node",
")",
"\n\n",
"if",
"node",
".",
"IsDataRoot",
"(",
")",
"{",
"// `@root` - remove the first part",
"parts",
":=",
"node",
".",
"Parts",
"[",
"1",
":",
"len",
"(",
"node",
".",
"Parts",
")",
"]",
"\n\n",
"result",
",",
"_",
":=",
"v",
".",
"evalCtxPath",
"(",
"v",
".",
"rootCtx",
"(",
")",
",",
"parts",
",",
"exprRoot",
")",
"\n",
"return",
"result",
"\n",
"}",
"\n\n",
"return",
"v",
".",
"evalDepthPath",
"(",
"node",
".",
"Depth",
",",
"node",
".",
"Parts",
",",
"exprRoot",
")",
"\n",
"}"
] |
// evalCtxPathExpression evaluates a context path expression
|
[
"evalCtxPathExpression",
"evaluates",
"a",
"context",
"path",
"expression"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/eval.go#L489-L501
|
574 |
aymerick/raymond
|
eval.go
|
evalDepthPath
|
func (v *evalVisitor) evalDepthPath(depth int, parts []string, exprRoot bool) interface{} {
var result interface{}
partResolved := false
ctx := v.ancestorCtx(depth)
for (result == nil) && ctx.IsValid() && (depth <= len(v.ctx) && !partResolved) {
// try with context
result, partResolved = v.evalCtxPath(ctx, parts, exprRoot)
// As soon as we find the first part of a path, we must not try to resolve with parent context if result is finally `nil`
// Reference: "Dotted Names - Context Precedence" mustache test
if !partResolved && (result == nil) {
// try with previous context
depth++
ctx = v.ancestorCtx(depth)
}
}
return result
}
|
go
|
func (v *evalVisitor) evalDepthPath(depth int, parts []string, exprRoot bool) interface{} {
var result interface{}
partResolved := false
ctx := v.ancestorCtx(depth)
for (result == nil) && ctx.IsValid() && (depth <= len(v.ctx) && !partResolved) {
// try with context
result, partResolved = v.evalCtxPath(ctx, parts, exprRoot)
// As soon as we find the first part of a path, we must not try to resolve with parent context if result is finally `nil`
// Reference: "Dotted Names - Context Precedence" mustache test
if !partResolved && (result == nil) {
// try with previous context
depth++
ctx = v.ancestorCtx(depth)
}
}
return result
}
|
[
"func",
"(",
"v",
"*",
"evalVisitor",
")",
"evalDepthPath",
"(",
"depth",
"int",
",",
"parts",
"[",
"]",
"string",
",",
"exprRoot",
"bool",
")",
"interface",
"{",
"}",
"{",
"var",
"result",
"interface",
"{",
"}",
"\n",
"partResolved",
":=",
"false",
"\n\n",
"ctx",
":=",
"v",
".",
"ancestorCtx",
"(",
"depth",
")",
"\n\n",
"for",
"(",
"result",
"==",
"nil",
")",
"&&",
"ctx",
".",
"IsValid",
"(",
")",
"&&",
"(",
"depth",
"<=",
"len",
"(",
"v",
".",
"ctx",
")",
"&&",
"!",
"partResolved",
")",
"{",
"// try with context",
"result",
",",
"partResolved",
"=",
"v",
".",
"evalCtxPath",
"(",
"ctx",
",",
"parts",
",",
"exprRoot",
")",
"\n\n",
"// As soon as we find the first part of a path, we must not try to resolve with parent context if result is finally `nil`",
"// Reference: \"Dotted Names - Context Precedence\" mustache test",
"if",
"!",
"partResolved",
"&&",
"(",
"result",
"==",
"nil",
")",
"{",
"// try with previous context",
"depth",
"++",
"\n",
"ctx",
"=",
"v",
".",
"ancestorCtx",
"(",
"depth",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"result",
"\n",
"}"
] |
// evalDepthPath iterates on contexts, starting at given depth, until there is one that resolve given path parts
|
[
"evalDepthPath",
"iterates",
"on",
"contexts",
"starting",
"at",
"given",
"depth",
"until",
"there",
"is",
"one",
"that",
"resolve",
"given",
"path",
"parts"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/eval.go#L504-L524
|
575 |
aymerick/raymond
|
eval.go
|
evalCtxPath
|
func (v *evalVisitor) evalCtxPath(ctx reflect.Value, parts []string, exprRoot bool) (interface{}, bool) {
var result interface{}
partResolved := false
switch ctx.Kind() {
case reflect.Array, reflect.Slice:
// Array context
var results []interface{}
for i := 0; i < ctx.Len(); i++ {
value, _ := v.evalPath(ctx.Index(i), parts, exprRoot)
if value.IsValid() {
results = append(results, value.Interface())
}
}
result = results
default:
// NOT array context
var value reflect.Value
value, partResolved = v.evalPath(ctx, parts, exprRoot)
if value.IsValid() {
result = value.Interface()
}
}
return result, partResolved
}
|
go
|
func (v *evalVisitor) evalCtxPath(ctx reflect.Value, parts []string, exprRoot bool) (interface{}, bool) {
var result interface{}
partResolved := false
switch ctx.Kind() {
case reflect.Array, reflect.Slice:
// Array context
var results []interface{}
for i := 0; i < ctx.Len(); i++ {
value, _ := v.evalPath(ctx.Index(i), parts, exprRoot)
if value.IsValid() {
results = append(results, value.Interface())
}
}
result = results
default:
// NOT array context
var value reflect.Value
value, partResolved = v.evalPath(ctx, parts, exprRoot)
if value.IsValid() {
result = value.Interface()
}
}
return result, partResolved
}
|
[
"func",
"(",
"v",
"*",
"evalVisitor",
")",
"evalCtxPath",
"(",
"ctx",
"reflect",
".",
"Value",
",",
"parts",
"[",
"]",
"string",
",",
"exprRoot",
"bool",
")",
"(",
"interface",
"{",
"}",
",",
"bool",
")",
"{",
"var",
"result",
"interface",
"{",
"}",
"\n",
"partResolved",
":=",
"false",
"\n\n",
"switch",
"ctx",
".",
"Kind",
"(",
")",
"{",
"case",
"reflect",
".",
"Array",
",",
"reflect",
".",
"Slice",
":",
"// Array context",
"var",
"results",
"[",
"]",
"interface",
"{",
"}",
"\n\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"ctx",
".",
"Len",
"(",
")",
";",
"i",
"++",
"{",
"value",
",",
"_",
":=",
"v",
".",
"evalPath",
"(",
"ctx",
".",
"Index",
"(",
"i",
")",
",",
"parts",
",",
"exprRoot",
")",
"\n",
"if",
"value",
".",
"IsValid",
"(",
")",
"{",
"results",
"=",
"append",
"(",
"results",
",",
"value",
".",
"Interface",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"result",
"=",
"results",
"\n",
"default",
":",
"// NOT array context",
"var",
"value",
"reflect",
".",
"Value",
"\n\n",
"value",
",",
"partResolved",
"=",
"v",
".",
"evalPath",
"(",
"ctx",
",",
"parts",
",",
"exprRoot",
")",
"\n",
"if",
"value",
".",
"IsValid",
"(",
")",
"{",
"result",
"=",
"value",
".",
"Interface",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"result",
",",
"partResolved",
"\n",
"}"
] |
// evalCtxPath evaluates path with given context
|
[
"evalCtxPath",
"evaluates",
"path",
"with",
"given",
"context"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/eval.go#L527-L555
|
576 |
aymerick/raymond
|
eval.go
|
isHelperCall
|
func (v *evalVisitor) isHelperCall(node *ast.Expression) bool {
if helperName := node.HelperName(); helperName != "" {
return v.findHelper(helperName) != zero
}
return false
}
|
go
|
func (v *evalVisitor) isHelperCall(node *ast.Expression) bool {
if helperName := node.HelperName(); helperName != "" {
return v.findHelper(helperName) != zero
}
return false
}
|
[
"func",
"(",
"v",
"*",
"evalVisitor",
")",
"isHelperCall",
"(",
"node",
"*",
"ast",
".",
"Expression",
")",
"bool",
"{",
"if",
"helperName",
":=",
"node",
".",
"HelperName",
"(",
")",
";",
"helperName",
"!=",
"\"",
"\"",
"{",
"return",
"v",
".",
"findHelper",
"(",
"helperName",
")",
"!=",
"zero",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] |
//
// Helpers
//
// isHelperCall returns true if given expression is a helper call
|
[
"Helpers",
"isHelperCall",
"returns",
"true",
"if",
"given",
"expression",
"is",
"a",
"helper",
"call"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/eval.go#L562-L567
|
577 |
aymerick/raymond
|
eval.go
|
findHelper
|
func (v *evalVisitor) findHelper(name string) reflect.Value {
// check template helpers
if h := v.tpl.findHelper(name); h != zero {
return h
}
// check global helpers
return findHelper(name)
}
|
go
|
func (v *evalVisitor) findHelper(name string) reflect.Value {
// check template helpers
if h := v.tpl.findHelper(name); h != zero {
return h
}
// check global helpers
return findHelper(name)
}
|
[
"func",
"(",
"v",
"*",
"evalVisitor",
")",
"findHelper",
"(",
"name",
"string",
")",
"reflect",
".",
"Value",
"{",
"// check template helpers",
"if",
"h",
":=",
"v",
".",
"tpl",
".",
"findHelper",
"(",
"name",
")",
";",
"h",
"!=",
"zero",
"{",
"return",
"h",
"\n",
"}",
"\n\n",
"// check global helpers",
"return",
"findHelper",
"(",
"name",
")",
"\n",
"}"
] |
// findHelper finds given helper
|
[
"findHelper",
"finds",
"given",
"helper"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/eval.go#L570-L578
|
578 |
aymerick/raymond
|
eval.go
|
callFunc
|
func (v *evalVisitor) callFunc(name string, funcVal reflect.Value, options *Options) reflect.Value {
params := options.Params()
funcType := funcVal.Type()
// @todo Is there a better way to do that ?
strType := reflect.TypeOf("")
boolType := reflect.TypeOf(true)
// check parameters number
addOptions := false
numIn := funcType.NumIn()
if numIn == len(params)+1 {
lastArgType := funcType.In(numIn - 1)
if reflect.TypeOf(options).AssignableTo(lastArgType) {
addOptions = true
}
}
if !addOptions && (len(params) != numIn) {
v.errorf("Helper '%s' called with wrong number of arguments, needed %d but got %d", name, numIn, len(params))
}
// check and collect arguments
args := make([]reflect.Value, numIn)
for i, param := range params {
arg := reflect.ValueOf(param)
argType := funcType.In(i)
if !arg.IsValid() {
if canBeNil(argType) {
arg = reflect.Zero(argType)
} else if argType.Kind() == reflect.String {
arg = reflect.ValueOf("")
} else {
// @todo Maybe we can panic on that
return reflect.Zero(strType)
}
}
if !arg.Type().AssignableTo(argType) {
if strType.AssignableTo(argType) {
// convert parameter to string
arg = reflect.ValueOf(strValue(arg))
} else if boolType.AssignableTo(argType) {
// convert parameter to bool
val, _ := isTrueValue(arg)
arg = reflect.ValueOf(val)
} else {
v.errorf("Helper %s called with argument %d with type %s but it should be %s", name, i, arg.Type(), argType)
}
}
args[i] = arg
}
if addOptions {
args[numIn-1] = reflect.ValueOf(options)
}
result := funcVal.Call(args)
return result[0]
}
|
go
|
func (v *evalVisitor) callFunc(name string, funcVal reflect.Value, options *Options) reflect.Value {
params := options.Params()
funcType := funcVal.Type()
// @todo Is there a better way to do that ?
strType := reflect.TypeOf("")
boolType := reflect.TypeOf(true)
// check parameters number
addOptions := false
numIn := funcType.NumIn()
if numIn == len(params)+1 {
lastArgType := funcType.In(numIn - 1)
if reflect.TypeOf(options).AssignableTo(lastArgType) {
addOptions = true
}
}
if !addOptions && (len(params) != numIn) {
v.errorf("Helper '%s' called with wrong number of arguments, needed %d but got %d", name, numIn, len(params))
}
// check and collect arguments
args := make([]reflect.Value, numIn)
for i, param := range params {
arg := reflect.ValueOf(param)
argType := funcType.In(i)
if !arg.IsValid() {
if canBeNil(argType) {
arg = reflect.Zero(argType)
} else if argType.Kind() == reflect.String {
arg = reflect.ValueOf("")
} else {
// @todo Maybe we can panic on that
return reflect.Zero(strType)
}
}
if !arg.Type().AssignableTo(argType) {
if strType.AssignableTo(argType) {
// convert parameter to string
arg = reflect.ValueOf(strValue(arg))
} else if boolType.AssignableTo(argType) {
// convert parameter to bool
val, _ := isTrueValue(arg)
arg = reflect.ValueOf(val)
} else {
v.errorf("Helper %s called with argument %d with type %s but it should be %s", name, i, arg.Type(), argType)
}
}
args[i] = arg
}
if addOptions {
args[numIn-1] = reflect.ValueOf(options)
}
result := funcVal.Call(args)
return result[0]
}
|
[
"func",
"(",
"v",
"*",
"evalVisitor",
")",
"callFunc",
"(",
"name",
"string",
",",
"funcVal",
"reflect",
".",
"Value",
",",
"options",
"*",
"Options",
")",
"reflect",
".",
"Value",
"{",
"params",
":=",
"options",
".",
"Params",
"(",
")",
"\n\n",
"funcType",
":=",
"funcVal",
".",
"Type",
"(",
")",
"\n\n",
"// @todo Is there a better way to do that ?",
"strType",
":=",
"reflect",
".",
"TypeOf",
"(",
"\"",
"\"",
")",
"\n",
"boolType",
":=",
"reflect",
".",
"TypeOf",
"(",
"true",
")",
"\n\n",
"// check parameters number",
"addOptions",
":=",
"false",
"\n",
"numIn",
":=",
"funcType",
".",
"NumIn",
"(",
")",
"\n\n",
"if",
"numIn",
"==",
"len",
"(",
"params",
")",
"+",
"1",
"{",
"lastArgType",
":=",
"funcType",
".",
"In",
"(",
"numIn",
"-",
"1",
")",
"\n",
"if",
"reflect",
".",
"TypeOf",
"(",
"options",
")",
".",
"AssignableTo",
"(",
"lastArgType",
")",
"{",
"addOptions",
"=",
"true",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"!",
"addOptions",
"&&",
"(",
"len",
"(",
"params",
")",
"!=",
"numIn",
")",
"{",
"v",
".",
"errorf",
"(",
"\"",
"\"",
",",
"name",
",",
"numIn",
",",
"len",
"(",
"params",
")",
")",
"\n",
"}",
"\n\n",
"// check and collect arguments",
"args",
":=",
"make",
"(",
"[",
"]",
"reflect",
".",
"Value",
",",
"numIn",
")",
"\n",
"for",
"i",
",",
"param",
":=",
"range",
"params",
"{",
"arg",
":=",
"reflect",
".",
"ValueOf",
"(",
"param",
")",
"\n",
"argType",
":=",
"funcType",
".",
"In",
"(",
"i",
")",
"\n\n",
"if",
"!",
"arg",
".",
"IsValid",
"(",
")",
"{",
"if",
"canBeNil",
"(",
"argType",
")",
"{",
"arg",
"=",
"reflect",
".",
"Zero",
"(",
"argType",
")",
"\n",
"}",
"else",
"if",
"argType",
".",
"Kind",
"(",
")",
"==",
"reflect",
".",
"String",
"{",
"arg",
"=",
"reflect",
".",
"ValueOf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"else",
"{",
"// @todo Maybe we can panic on that",
"return",
"reflect",
".",
"Zero",
"(",
"strType",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"!",
"arg",
".",
"Type",
"(",
")",
".",
"AssignableTo",
"(",
"argType",
")",
"{",
"if",
"strType",
".",
"AssignableTo",
"(",
"argType",
")",
"{",
"// convert parameter to string",
"arg",
"=",
"reflect",
".",
"ValueOf",
"(",
"strValue",
"(",
"arg",
")",
")",
"\n",
"}",
"else",
"if",
"boolType",
".",
"AssignableTo",
"(",
"argType",
")",
"{",
"// convert parameter to bool",
"val",
",",
"_",
":=",
"isTrueValue",
"(",
"arg",
")",
"\n",
"arg",
"=",
"reflect",
".",
"ValueOf",
"(",
"val",
")",
"\n",
"}",
"else",
"{",
"v",
".",
"errorf",
"(",
"\"",
"\"",
",",
"name",
",",
"i",
",",
"arg",
".",
"Type",
"(",
")",
",",
"argType",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"args",
"[",
"i",
"]",
"=",
"arg",
"\n",
"}",
"\n\n",
"if",
"addOptions",
"{",
"args",
"[",
"numIn",
"-",
"1",
"]",
"=",
"reflect",
".",
"ValueOf",
"(",
"options",
")",
"\n",
"}",
"\n\n",
"result",
":=",
"funcVal",
".",
"Call",
"(",
"args",
")",
"\n\n",
"return",
"result",
"[",
"0",
"]",
"\n",
"}"
] |
// callFunc calls function with given options
|
[
"callFunc",
"calls",
"function",
"with",
"given",
"options"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/eval.go#L581-L645
|
579 |
aymerick/raymond
|
eval.go
|
callHelper
|
func (v *evalVisitor) callHelper(name string, helper reflect.Value, node *ast.Expression) interface{} {
result := v.callFunc(name, helper, v.helperOptions(node))
if !result.IsValid() {
return nil
}
// @todo We maybe want to ensure here that helper returned a string or a SafeString
return result.Interface()
}
|
go
|
func (v *evalVisitor) callHelper(name string, helper reflect.Value, node *ast.Expression) interface{} {
result := v.callFunc(name, helper, v.helperOptions(node))
if !result.IsValid() {
return nil
}
// @todo We maybe want to ensure here that helper returned a string or a SafeString
return result.Interface()
}
|
[
"func",
"(",
"v",
"*",
"evalVisitor",
")",
"callHelper",
"(",
"name",
"string",
",",
"helper",
"reflect",
".",
"Value",
",",
"node",
"*",
"ast",
".",
"Expression",
")",
"interface",
"{",
"}",
"{",
"result",
":=",
"v",
".",
"callFunc",
"(",
"name",
",",
"helper",
",",
"v",
".",
"helperOptions",
"(",
"node",
")",
")",
"\n",
"if",
"!",
"result",
".",
"IsValid",
"(",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// @todo We maybe want to ensure here that helper returned a string or a SafeString",
"return",
"result",
".",
"Interface",
"(",
")",
"\n",
"}"
] |
// callHelper invoqs helper function for given expression node
|
[
"callHelper",
"invoqs",
"helper",
"function",
"for",
"given",
"expression",
"node"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/eval.go#L648-L656
|
580 |
aymerick/raymond
|
eval.go
|
helperOptions
|
func (v *evalVisitor) helperOptions(node *ast.Expression) *Options {
var params []interface{}
var hash map[string]interface{}
for _, paramNode := range node.Params {
param := paramNode.Accept(v)
params = append(params, param)
}
if node.Hash != nil {
hash, _ = node.Hash.Accept(v).(map[string]interface{})
}
return newOptions(v, params, hash)
}
|
go
|
func (v *evalVisitor) helperOptions(node *ast.Expression) *Options {
var params []interface{}
var hash map[string]interface{}
for _, paramNode := range node.Params {
param := paramNode.Accept(v)
params = append(params, param)
}
if node.Hash != nil {
hash, _ = node.Hash.Accept(v).(map[string]interface{})
}
return newOptions(v, params, hash)
}
|
[
"func",
"(",
"v",
"*",
"evalVisitor",
")",
"helperOptions",
"(",
"node",
"*",
"ast",
".",
"Expression",
")",
"*",
"Options",
"{",
"var",
"params",
"[",
"]",
"interface",
"{",
"}",
"\n",
"var",
"hash",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"\n\n",
"for",
"_",
",",
"paramNode",
":=",
"range",
"node",
".",
"Params",
"{",
"param",
":=",
"paramNode",
".",
"Accept",
"(",
"v",
")",
"\n",
"params",
"=",
"append",
"(",
"params",
",",
"param",
")",
"\n",
"}",
"\n\n",
"if",
"node",
".",
"Hash",
"!=",
"nil",
"{",
"hash",
",",
"_",
"=",
"node",
".",
"Hash",
".",
"Accept",
"(",
"v",
")",
".",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"}",
"\n\n",
"return",
"newOptions",
"(",
"v",
",",
"params",
",",
"hash",
")",
"\n",
"}"
] |
// helperOptions computes helper options argument from an expression
|
[
"helperOptions",
"computes",
"helper",
"options",
"argument",
"from",
"an",
"expression"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/eval.go#L659-L673
|
581 |
aymerick/raymond
|
eval.go
|
findPartial
|
func (v *evalVisitor) findPartial(name string) *partial {
// check template partials
if p := v.tpl.findPartial(name); p != nil {
return p
}
// check global partials
return findPartial(name)
}
|
go
|
func (v *evalVisitor) findPartial(name string) *partial {
// check template partials
if p := v.tpl.findPartial(name); p != nil {
return p
}
// check global partials
return findPartial(name)
}
|
[
"func",
"(",
"v",
"*",
"evalVisitor",
")",
"findPartial",
"(",
"name",
"string",
")",
"*",
"partial",
"{",
"// check template partials",
"if",
"p",
":=",
"v",
".",
"tpl",
".",
"findPartial",
"(",
"name",
")",
";",
"p",
"!=",
"nil",
"{",
"return",
"p",
"\n",
"}",
"\n\n",
"// check global partials",
"return",
"findPartial",
"(",
"name",
")",
"\n",
"}"
] |
//
// Partials
//
// findPartial finds given partial
|
[
"Partials",
"findPartial",
"finds",
"given",
"partial"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/eval.go#L680-L688
|
582 |
aymerick/raymond
|
eval.go
|
partialContext
|
func (v *evalVisitor) partialContext(node *ast.PartialStatement) reflect.Value {
if nb := len(node.Params); nb > 1 {
v.errorf("Unsupported number of partial arguments: %d", nb)
}
if (len(node.Params) > 0) && (node.Hash != nil) {
v.errorf("Passing both context and named parameters to a partial is not allowed")
}
if len(node.Params) == 1 {
return reflect.ValueOf(node.Params[0].Accept(v))
}
if node.Hash != nil {
hash, _ := node.Hash.Accept(v).(map[string]interface{})
return reflect.ValueOf(hash)
}
return zero
}
|
go
|
func (v *evalVisitor) partialContext(node *ast.PartialStatement) reflect.Value {
if nb := len(node.Params); nb > 1 {
v.errorf("Unsupported number of partial arguments: %d", nb)
}
if (len(node.Params) > 0) && (node.Hash != nil) {
v.errorf("Passing both context and named parameters to a partial is not allowed")
}
if len(node.Params) == 1 {
return reflect.ValueOf(node.Params[0].Accept(v))
}
if node.Hash != nil {
hash, _ := node.Hash.Accept(v).(map[string]interface{})
return reflect.ValueOf(hash)
}
return zero
}
|
[
"func",
"(",
"v",
"*",
"evalVisitor",
")",
"partialContext",
"(",
"node",
"*",
"ast",
".",
"PartialStatement",
")",
"reflect",
".",
"Value",
"{",
"if",
"nb",
":=",
"len",
"(",
"node",
".",
"Params",
")",
";",
"nb",
">",
"1",
"{",
"v",
".",
"errorf",
"(",
"\"",
"\"",
",",
"nb",
")",
"\n",
"}",
"\n\n",
"if",
"(",
"len",
"(",
"node",
".",
"Params",
")",
">",
"0",
")",
"&&",
"(",
"node",
".",
"Hash",
"!=",
"nil",
")",
"{",
"v",
".",
"errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"node",
".",
"Params",
")",
"==",
"1",
"{",
"return",
"reflect",
".",
"ValueOf",
"(",
"node",
".",
"Params",
"[",
"0",
"]",
".",
"Accept",
"(",
"v",
")",
")",
"\n",
"}",
"\n\n",
"if",
"node",
".",
"Hash",
"!=",
"nil",
"{",
"hash",
",",
"_",
":=",
"node",
".",
"Hash",
".",
"Accept",
"(",
"v",
")",
".",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"return",
"reflect",
".",
"ValueOf",
"(",
"hash",
")",
"\n",
"}",
"\n\n",
"return",
"zero",
"\n",
"}"
] |
// partialContext computes partial context
|
[
"partialContext",
"computes",
"partial",
"context"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/eval.go#L691-L710
|
583 |
aymerick/raymond
|
eval.go
|
evalPartial
|
func (v *evalVisitor) evalPartial(p *partial, node *ast.PartialStatement) string {
// get partial template
partialTpl, err := p.template()
if err != nil {
v.errPanic(err)
}
// push partial context
ctx := v.partialContext(node)
if ctx.IsValid() {
v.pushCtx(ctx)
}
// evaluate partial template
result, _ := partialTpl.program.Accept(v).(string)
// ident partial
result = indentLines(result, node.Indent)
if ctx.IsValid() {
v.popCtx()
}
return result
}
|
go
|
func (v *evalVisitor) evalPartial(p *partial, node *ast.PartialStatement) string {
// get partial template
partialTpl, err := p.template()
if err != nil {
v.errPanic(err)
}
// push partial context
ctx := v.partialContext(node)
if ctx.IsValid() {
v.pushCtx(ctx)
}
// evaluate partial template
result, _ := partialTpl.program.Accept(v).(string)
// ident partial
result = indentLines(result, node.Indent)
if ctx.IsValid() {
v.popCtx()
}
return result
}
|
[
"func",
"(",
"v",
"*",
"evalVisitor",
")",
"evalPartial",
"(",
"p",
"*",
"partial",
",",
"node",
"*",
"ast",
".",
"PartialStatement",
")",
"string",
"{",
"// get partial template",
"partialTpl",
",",
"err",
":=",
"p",
".",
"template",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"v",
".",
"errPanic",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"// push partial context",
"ctx",
":=",
"v",
".",
"partialContext",
"(",
"node",
")",
"\n",
"if",
"ctx",
".",
"IsValid",
"(",
")",
"{",
"v",
".",
"pushCtx",
"(",
"ctx",
")",
"\n",
"}",
"\n\n",
"// evaluate partial template",
"result",
",",
"_",
":=",
"partialTpl",
".",
"program",
".",
"Accept",
"(",
"v",
")",
".",
"(",
"string",
")",
"\n\n",
"// ident partial",
"result",
"=",
"indentLines",
"(",
"result",
",",
"node",
".",
"Indent",
")",
"\n\n",
"if",
"ctx",
".",
"IsValid",
"(",
")",
"{",
"v",
".",
"popCtx",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"result",
"\n",
"}"
] |
// evalPartial evaluates a partial
|
[
"evalPartial",
"evaluates",
"a",
"partial"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/eval.go#L713-L737
|
584 |
aymerick/raymond
|
eval.go
|
indentLines
|
func indentLines(str string, indent string) string {
if indent == "" {
return str
}
var indented []string
lines := strings.Split(str, "\n")
for i, line := range lines {
if (i == (len(lines) - 1)) && (line == "") {
// input string ends with a new line
indented = append(indented, line)
} else {
indented = append(indented, indent+line)
}
}
return strings.Join(indented, "\n")
}
|
go
|
func indentLines(str string, indent string) string {
if indent == "" {
return str
}
var indented []string
lines := strings.Split(str, "\n")
for i, line := range lines {
if (i == (len(lines) - 1)) && (line == "") {
// input string ends with a new line
indented = append(indented, line)
} else {
indented = append(indented, indent+line)
}
}
return strings.Join(indented, "\n")
}
|
[
"func",
"indentLines",
"(",
"str",
"string",
",",
"indent",
"string",
")",
"string",
"{",
"if",
"indent",
"==",
"\"",
"\"",
"{",
"return",
"str",
"\n",
"}",
"\n\n",
"var",
"indented",
"[",
"]",
"string",
"\n\n",
"lines",
":=",
"strings",
".",
"Split",
"(",
"str",
",",
"\"",
"\\n",
"\"",
")",
"\n",
"for",
"i",
",",
"line",
":=",
"range",
"lines",
"{",
"if",
"(",
"i",
"==",
"(",
"len",
"(",
"lines",
")",
"-",
"1",
")",
")",
"&&",
"(",
"line",
"==",
"\"",
"\"",
")",
"{",
"// input string ends with a new line",
"indented",
"=",
"append",
"(",
"indented",
",",
"line",
")",
"\n",
"}",
"else",
"{",
"indented",
"=",
"append",
"(",
"indented",
",",
"indent",
"+",
"line",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"strings",
".",
"Join",
"(",
"indented",
",",
"\"",
"\\n",
"\"",
")",
"\n",
"}"
] |
// indentLines indents all lines of given string
|
[
"indentLines",
"indents",
"all",
"lines",
"of",
"given",
"string"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/eval.go#L740-L758
|
585 |
aymerick/raymond
|
eval.go
|
wasFuncCall
|
func (v *evalVisitor) wasFuncCall(node *ast.Expression) bool {
// check if expression was tagged as a function call
return v.exprFunc[node]
}
|
go
|
func (v *evalVisitor) wasFuncCall(node *ast.Expression) bool {
// check if expression was tagged as a function call
return v.exprFunc[node]
}
|
[
"func",
"(",
"v",
"*",
"evalVisitor",
")",
"wasFuncCall",
"(",
"node",
"*",
"ast",
".",
"Expression",
")",
"bool",
"{",
"// check if expression was tagged as a function call",
"return",
"v",
".",
"exprFunc",
"[",
"node",
"]",
"\n",
"}"
] |
//
// Functions
//
// wasFuncCall returns true if given expression was a function call
|
[
"Functions",
"wasFuncCall",
"returns",
"true",
"if",
"given",
"expression",
"was",
"a",
"function",
"call"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/eval.go#L765-L768
|
586 |
aymerick/raymond
|
ast/node.go
|
NewStrip
|
func NewStrip(openStr, closeStr string) *Strip {
return &Strip{
Open: (len(openStr) > 2) && openStr[2] == '~',
Close: (len(closeStr) > 2) && closeStr[len(closeStr)-3] == '~',
}
}
|
go
|
func NewStrip(openStr, closeStr string) *Strip {
return &Strip{
Open: (len(openStr) > 2) && openStr[2] == '~',
Close: (len(closeStr) > 2) && closeStr[len(closeStr)-3] == '~',
}
}
|
[
"func",
"NewStrip",
"(",
"openStr",
",",
"closeStr",
"string",
")",
"*",
"Strip",
"{",
"return",
"&",
"Strip",
"{",
"Open",
":",
"(",
"len",
"(",
"openStr",
")",
">",
"2",
")",
"&&",
"openStr",
"[",
"2",
"]",
"==",
"'~'",
",",
"Close",
":",
"(",
"len",
"(",
"closeStr",
")",
">",
"2",
")",
"&&",
"closeStr",
"[",
"len",
"(",
"closeStr",
")",
"-",
"3",
"]",
"==",
"'~'",
",",
"}",
"\n",
"}"
] |
// NewStrip instanciates a Strip for given open and close mustaches.
|
[
"NewStrip",
"instanciates",
"a",
"Strip",
"for",
"given",
"open",
"and",
"close",
"mustaches",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/ast/node.go#L129-L134
|
587 |
aymerick/raymond
|
ast/node.go
|
NewStripForStr
|
func NewStripForStr(str string) *Strip {
return &Strip{
Open: (len(str) > 2) && str[2] == '~',
Close: (len(str) > 2) && str[len(str)-3] == '~',
}
}
|
go
|
func NewStripForStr(str string) *Strip {
return &Strip{
Open: (len(str) > 2) && str[2] == '~',
Close: (len(str) > 2) && str[len(str)-3] == '~',
}
}
|
[
"func",
"NewStripForStr",
"(",
"str",
"string",
")",
"*",
"Strip",
"{",
"return",
"&",
"Strip",
"{",
"Open",
":",
"(",
"len",
"(",
"str",
")",
">",
"2",
")",
"&&",
"str",
"[",
"2",
"]",
"==",
"'~'",
",",
"Close",
":",
"(",
"len",
"(",
"str",
")",
">",
"2",
")",
"&&",
"str",
"[",
"len",
"(",
"str",
")",
"-",
"3",
"]",
"==",
"'~'",
",",
"}",
"\n",
"}"
] |
// NewStripForStr instanciates a Strip for given tag.
|
[
"NewStripForStr",
"instanciates",
"a",
"Strip",
"for",
"given",
"tag",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/ast/node.go#L137-L142
|
588 |
aymerick/raymond
|
ast/node.go
|
NewProgram
|
func NewProgram(pos int, line int) *Program {
return &Program{
NodeType: NodeProgram,
Loc: Loc{pos, line},
}
}
|
go
|
func NewProgram(pos int, line int) *Program {
return &Program{
NodeType: NodeProgram,
Loc: Loc{pos, line},
}
}
|
[
"func",
"NewProgram",
"(",
"pos",
"int",
",",
"line",
"int",
")",
"*",
"Program",
"{",
"return",
"&",
"Program",
"{",
"NodeType",
":",
"NodeProgram",
",",
"Loc",
":",
"Loc",
"{",
"pos",
",",
"line",
"}",
",",
"}",
"\n",
"}"
] |
// NewProgram instanciates a new program node.
|
[
"NewProgram",
"instanciates",
"a",
"new",
"program",
"node",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/ast/node.go#L167-L172
|
589 |
aymerick/raymond
|
ast/node.go
|
AddStatement
|
func (node *Program) AddStatement(statement Node) {
node.Body = append(node.Body, statement)
}
|
go
|
func (node *Program) AddStatement(statement Node) {
node.Body = append(node.Body, statement)
}
|
[
"func",
"(",
"node",
"*",
"Program",
")",
"AddStatement",
"(",
"statement",
"Node",
")",
"{",
"node",
".",
"Body",
"=",
"append",
"(",
"node",
".",
"Body",
",",
"statement",
")",
"\n",
"}"
] |
// AddStatement adds given statement to program.
|
[
"AddStatement",
"adds",
"given",
"statement",
"to",
"program",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/ast/node.go#L185-L187
|
590 |
aymerick/raymond
|
ast/node.go
|
NewMustacheStatement
|
func NewMustacheStatement(pos int, line int, unescaped bool) *MustacheStatement {
return &MustacheStatement{
NodeType: NodeMustache,
Loc: Loc{pos, line},
Unescaped: unescaped,
}
}
|
go
|
func NewMustacheStatement(pos int, line int, unescaped bool) *MustacheStatement {
return &MustacheStatement{
NodeType: NodeMustache,
Loc: Loc{pos, line},
Unescaped: unescaped,
}
}
|
[
"func",
"NewMustacheStatement",
"(",
"pos",
"int",
",",
"line",
"int",
",",
"unescaped",
"bool",
")",
"*",
"MustacheStatement",
"{",
"return",
"&",
"MustacheStatement",
"{",
"NodeType",
":",
"NodeMustache",
",",
"Loc",
":",
"Loc",
"{",
"pos",
",",
"line",
"}",
",",
"Unescaped",
":",
"unescaped",
",",
"}",
"\n",
"}"
] |
// NewMustacheStatement instanciates a new mustache node.
|
[
"NewMustacheStatement",
"instanciates",
"a",
"new",
"mustache",
"node",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/ast/node.go#L206-L212
|
591 |
aymerick/raymond
|
ast/node.go
|
NewBlockStatement
|
func NewBlockStatement(pos int, line int) *BlockStatement {
return &BlockStatement{
NodeType: NodeBlock,
Loc: Loc{pos, line},
}
}
|
go
|
func NewBlockStatement(pos int, line int) *BlockStatement {
return &BlockStatement{
NodeType: NodeBlock,
Loc: Loc{pos, line},
}
}
|
[
"func",
"NewBlockStatement",
"(",
"pos",
"int",
",",
"line",
"int",
")",
"*",
"BlockStatement",
"{",
"return",
"&",
"BlockStatement",
"{",
"NodeType",
":",
"NodeBlock",
",",
"Loc",
":",
"Loc",
"{",
"pos",
",",
"line",
"}",
",",
"}",
"\n",
"}"
] |
// NewBlockStatement instanciates a new block node.
|
[
"NewBlockStatement",
"instanciates",
"a",
"new",
"block",
"node",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/ast/node.go#L245-L250
|
592 |
aymerick/raymond
|
ast/node.go
|
NewPartialStatement
|
func NewPartialStatement(pos int, line int) *PartialStatement {
return &PartialStatement{
NodeType: NodePartial,
Loc: Loc{pos, line},
}
}
|
go
|
func NewPartialStatement(pos int, line int) *PartialStatement {
return &PartialStatement{
NodeType: NodePartial,
Loc: Loc{pos, line},
}
}
|
[
"func",
"NewPartialStatement",
"(",
"pos",
"int",
",",
"line",
"int",
")",
"*",
"PartialStatement",
"{",
"return",
"&",
"PartialStatement",
"{",
"NodeType",
":",
"NodePartial",
",",
"Loc",
":",
"Loc",
"{",
"pos",
",",
"line",
"}",
",",
"}",
"\n",
"}"
] |
// NewPartialStatement instanciates a new partial node.
|
[
"NewPartialStatement",
"instanciates",
"a",
"new",
"partial",
"node",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/ast/node.go#L281-L286
|
593 |
aymerick/raymond
|
ast/node.go
|
NewContentStatement
|
func NewContentStatement(pos int, line int, val string) *ContentStatement {
return &ContentStatement{
NodeType: NodeContent,
Loc: Loc{pos, line},
Value: val,
Original: val,
}
}
|
go
|
func NewContentStatement(pos int, line int, val string) *ContentStatement {
return &ContentStatement{
NodeType: NodeContent,
Loc: Loc{pos, line},
Value: val,
Original: val,
}
}
|
[
"func",
"NewContentStatement",
"(",
"pos",
"int",
",",
"line",
"int",
",",
"val",
"string",
")",
"*",
"ContentStatement",
"{",
"return",
"&",
"ContentStatement",
"{",
"NodeType",
":",
"NodeContent",
",",
"Loc",
":",
"Loc",
"{",
"pos",
",",
"line",
"}",
",",
"Value",
":",
"val",
",",
"Original",
":",
"val",
",",
"}",
"\n",
"}"
] |
// NewContentStatement instanciates a new content node.
|
[
"NewContentStatement",
"instanciates",
"a",
"new",
"content",
"node",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/ast/node.go#L316-L324
|
594 |
aymerick/raymond
|
ast/node.go
|
NewCommentStatement
|
func NewCommentStatement(pos int, line int, val string) *CommentStatement {
return &CommentStatement{
NodeType: NodeComment,
Loc: Loc{pos, line},
Value: val,
}
}
|
go
|
func NewCommentStatement(pos int, line int, val string) *CommentStatement {
return &CommentStatement{
NodeType: NodeComment,
Loc: Loc{pos, line},
Value: val,
}
}
|
[
"func",
"NewCommentStatement",
"(",
"pos",
"int",
",",
"line",
"int",
",",
"val",
"string",
")",
"*",
"CommentStatement",
"{",
"return",
"&",
"CommentStatement",
"{",
"NodeType",
":",
"NodeComment",
",",
"Loc",
":",
"Loc",
"{",
"pos",
",",
"line",
"}",
",",
"Value",
":",
"val",
",",
"}",
"\n",
"}"
] |
// NewCommentStatement instanciates a new comment node.
|
[
"NewCommentStatement",
"instanciates",
"a",
"new",
"comment",
"node",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/ast/node.go#L352-L359
|
595 |
aymerick/raymond
|
ast/node.go
|
NewExpression
|
func NewExpression(pos int, line int) *Expression {
return &Expression{
NodeType: NodeExpression,
Loc: Loc{pos, line},
}
}
|
go
|
func NewExpression(pos int, line int) *Expression {
return &Expression{
NodeType: NodeExpression,
Loc: Loc{pos, line},
}
}
|
[
"func",
"NewExpression",
"(",
"pos",
"int",
",",
"line",
"int",
")",
"*",
"Expression",
"{",
"return",
"&",
"Expression",
"{",
"NodeType",
":",
"NodeExpression",
",",
"Loc",
":",
"Loc",
"{",
"pos",
",",
"line",
"}",
",",
"}",
"\n",
"}"
] |
// NewExpression instanciates a new expression node.
|
[
"NewExpression",
"instanciates",
"a",
"new",
"expression",
"node",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/ast/node.go#L386-L391
|
596 |
aymerick/raymond
|
ast/node.go
|
HelperName
|
func (node *Expression) HelperName() string {
path, ok := node.Path.(*PathExpression)
if !ok {
return ""
}
if path.Data || (len(path.Parts) != 1) || (path.Depth > 0) || path.Scoped {
return ""
}
return path.Parts[0]
}
|
go
|
func (node *Expression) HelperName() string {
path, ok := node.Path.(*PathExpression)
if !ok {
return ""
}
if path.Data || (len(path.Parts) != 1) || (path.Depth > 0) || path.Scoped {
return ""
}
return path.Parts[0]
}
|
[
"func",
"(",
"node",
"*",
"Expression",
")",
"HelperName",
"(",
")",
"string",
"{",
"path",
",",
"ok",
":=",
"node",
".",
"Path",
".",
"(",
"*",
"PathExpression",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n\n",
"if",
"path",
".",
"Data",
"||",
"(",
"len",
"(",
"path",
".",
"Parts",
")",
"!=",
"1",
")",
"||",
"(",
"path",
".",
"Depth",
">",
"0",
")",
"||",
"path",
".",
"Scoped",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n\n",
"return",
"path",
".",
"Parts",
"[",
"0",
"]",
"\n",
"}"
] |
// HelperName returns helper name, or an empty string if this expression can't be a helper.
|
[
"HelperName",
"returns",
"helper",
"name",
"or",
"an",
"empty",
"string",
"if",
"this",
"expression",
"can",
"t",
"be",
"a",
"helper",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/ast/node.go#L404-L415
|
597 |
aymerick/raymond
|
ast/node.go
|
FieldPath
|
func (node *Expression) FieldPath() *PathExpression {
path, ok := node.Path.(*PathExpression)
if !ok {
return nil
}
return path
}
|
go
|
func (node *Expression) FieldPath() *PathExpression {
path, ok := node.Path.(*PathExpression)
if !ok {
return nil
}
return path
}
|
[
"func",
"(",
"node",
"*",
"Expression",
")",
"FieldPath",
"(",
")",
"*",
"PathExpression",
"{",
"path",
",",
"ok",
":=",
"node",
".",
"Path",
".",
"(",
"*",
"PathExpression",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"return",
"path",
"\n",
"}"
] |
// FieldPath returns path expression representing a field path, or nil if this is not a field path.
|
[
"FieldPath",
"returns",
"path",
"expression",
"representing",
"a",
"field",
"path",
"or",
"nil",
"if",
"this",
"is",
"not",
"a",
"field",
"path",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/ast/node.go#L418-L425
|
598 |
aymerick/raymond
|
ast/node.go
|
Canonical
|
func (node *Expression) Canonical() string {
if str, ok := HelperNameStr(node.Path); ok {
return str
}
return ""
}
|
go
|
func (node *Expression) Canonical() string {
if str, ok := HelperNameStr(node.Path); ok {
return str
}
return ""
}
|
[
"func",
"(",
"node",
"*",
"Expression",
")",
"Canonical",
"(",
")",
"string",
"{",
"if",
"str",
",",
"ok",
":=",
"HelperNameStr",
"(",
"node",
".",
"Path",
")",
";",
"ok",
"{",
"return",
"str",
"\n",
"}",
"\n\n",
"return",
"\"",
"\"",
"\n",
"}"
] |
// Canonical returns the canonical form of expression node as a string.
|
[
"Canonical",
"returns",
"the",
"canonical",
"form",
"of",
"expression",
"node",
"as",
"a",
"string",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/ast/node.go#L433-L439
|
599 |
aymerick/raymond
|
ast/node.go
|
PathExpressionStr
|
func PathExpressionStr(node Node) (string, bool) {
if path, ok := node.(*PathExpression); ok {
result := path.Original
// "[foo bar]"" => "foo bar"
if (len(result) >= 2) && (result[0] == '[') && (result[len(result)-1] == ']') {
result = result[1 : len(result)-1]
}
return result, true
}
return "", false
}
|
go
|
func PathExpressionStr(node Node) (string, bool) {
if path, ok := node.(*PathExpression); ok {
result := path.Original
// "[foo bar]"" => "foo bar"
if (len(result) >= 2) && (result[0] == '[') && (result[len(result)-1] == ']') {
result = result[1 : len(result)-1]
}
return result, true
}
return "", false
}
|
[
"func",
"PathExpressionStr",
"(",
"node",
"Node",
")",
"(",
"string",
",",
"bool",
")",
"{",
"if",
"path",
",",
"ok",
":=",
"node",
".",
"(",
"*",
"PathExpression",
")",
";",
"ok",
"{",
"result",
":=",
"path",
".",
"Original",
"\n\n",
"// \"[foo bar]\"\" => \"foo bar\"",
"if",
"(",
"len",
"(",
"result",
")",
">=",
"2",
")",
"&&",
"(",
"result",
"[",
"0",
"]",
"==",
"'['",
")",
"&&",
"(",
"result",
"[",
"len",
"(",
"result",
")",
"-",
"1",
"]",
"==",
"']'",
")",
"{",
"result",
"=",
"result",
"[",
"1",
":",
"len",
"(",
"result",
")",
"-",
"1",
"]",
"\n",
"}",
"\n\n",
"return",
"result",
",",
"true",
"\n",
"}",
"\n\n",
"return",
"\"",
"\"",
",",
"false",
"\n",
"}"
] |
// PathExpressionStr returns the string representation of path expression value, with a boolean set to false if this is not a path expression.
|
[
"PathExpressionStr",
"returns",
"the",
"string",
"representation",
"of",
"path",
"expression",
"value",
"with",
"a",
"boolean",
"set",
"to",
"false",
"if",
"this",
"is",
"not",
"a",
"path",
"expression",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/ast/node.go#L459-L472
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.