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
sequence | docstring
stringlengths 6
2.61k
| docstring_tokens
sequence | 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 |