By {{fullName author}}
29 |{{body}}
30 |
31 | Comments
32 | 33 | {{#each comments}} 34 |By {{fullName author}}
35 |{{content}}
36 | {{/each}}
37 | {{body.content}}
" 7 | 8 | ctx := map[string]interface{}{ 9 | "title": "foo", 10 | "body": map[string]string{"content": "bar"}, 11 | } 12 | 13 | // parse template 14 | tpl := MustParse(source) 15 | 16 | // evaluate template with context 17 | output := tpl.MustExec(ctx) 18 | 19 | // alternatively, for one shots: 20 | // output := MustRender(source, ctx) 21 | 22 | fmt.Print(output) 23 | // Output:bar
24 | } 25 | 26 | func Example_struct() { 27 | source := `{{body.content}}
" 86 | 87 | ctx := map[string]interface{}{ 88 | "title": "foo", 89 | "body": map[string]string{"content": "bar"}, 90 | } 91 | 92 | // render template with context 93 | output, err := Render(tpl, ctx) 94 | if err != nil { 95 | panic(err) 96 | } 97 | 98 | fmt.Print(output) 99 | // Output:bar
100 | } 101 | 102 | func ExampleMustRender() { 103 | tpl := "{{body.content}}
" 104 | 105 | ctx := map[string]interface{}{ 106 | "title": "foo", 107 | "body": map[string]string{"content": "bar"}, 108 | } 109 | 110 | // render template with context 111 | output := MustRender(tpl, ctx) 112 | 113 | fmt.Print(output) 114 | // Output:bar
115 | } 116 | -------------------------------------------------------------------------------- /utils.go: -------------------------------------------------------------------------------- 1 | package raymond 2 | 3 | import ( 4 | "path" 5 | "reflect" 6 | ) 7 | 8 | // indirect returns the item at the end of indirection, and a bool to indicate if it's nil. 9 | // We indirect through pointers and empty interfaces (only) because 10 | // non-empty interfaces have methods we might need. 11 | // 12 | // NOTE: borrowed from https://github.com/golang/go/tree/master/src/text/template/exec.go 13 | func indirect(v reflect.Value) (rv reflect.Value, isNil bool) { 14 | for ; v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface; v = v.Elem() { 15 | if v.IsNil() { 16 | return v, true 17 | } 18 | if v.Kind() == reflect.Interface && v.NumMethod() > 0 { 19 | break 20 | } 21 | } 22 | return v, false 23 | } 24 | 25 | // IsTrue returns true if obj is a truthy value. 26 | func IsTrue(obj interface{}) bool { 27 | thruth, ok := isTrueValue(reflect.ValueOf(obj)) 28 | if !ok { 29 | return false 30 | } 31 | return thruth 32 | } 33 | 34 | // isTrueValue reports whether the value is 'true', in the sense of not the zero of its type, 35 | // and whether the value has a meaningful truth value 36 | // 37 | // NOTE: borrowed from https://github.com/golang/go/tree/master/src/text/template/exec.go 38 | func isTrueValue(val reflect.Value) (truth, ok bool) { 39 | if !val.IsValid() { 40 | // Something like var x interface{}, never set. It's a form of nil. 41 | return false, true 42 | } 43 | switch val.Kind() { 44 | case reflect.Array, reflect.Map, reflect.Slice, reflect.String: 45 | truth = val.Len() > 0 46 | case reflect.Bool: 47 | truth = val.Bool() 48 | case reflect.Complex64, reflect.Complex128: 49 | truth = val.Complex() != 0 50 | case reflect.Chan, reflect.Func, reflect.Ptr, reflect.Interface: 51 | truth = !val.IsNil() 52 | case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 53 | truth = val.Int() != 0 54 | case reflect.Float32, reflect.Float64: 55 | truth = val.Float() != 0 56 | case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: 57 | truth = val.Uint() != 0 58 | case reflect.Struct: 59 | truth = true // Struct values are always true. 60 | default: 61 | return 62 | } 63 | return truth, true 64 | } 65 | 66 | // canBeNil reports whether an untyped nil can be assigned to the type. See reflect.Zero. 67 | // 68 | // NOTE: borrowed from https://github.com/golang/go/tree/master/src/text/template/exec.go 69 | func canBeNil(typ reflect.Type) bool { 70 | switch typ.Kind() { 71 | case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice: 72 | return true 73 | } 74 | return false 75 | } 76 | 77 | // fileBase returns base file name 78 | // 79 | // example: /foo/bar/baz.png => baz 80 | func fileBase(filePath string) string { 81 | fileName := path.Base(filePath) 82 | fileExt := path.Ext(filePath) 83 | 84 | return fileName[:len(fileName)-len(fileExt)] 85 | } 86 | -------------------------------------------------------------------------------- /partial.go: -------------------------------------------------------------------------------- 1 | package raymond 2 | 3 | import ( 4 | "fmt" 5 | "sync" 6 | ) 7 | 8 | // partial represents a partial template 9 | type partial struct { 10 | name string 11 | source string 12 | tpl *Template 13 | } 14 | 15 | // partials stores all global partials 16 | var partials map[string]*partial 17 | 18 | // protects global partials 19 | var partialsMutex sync.RWMutex 20 | 21 | func init() { 22 | partials = make(map[string]*partial) 23 | } 24 | 25 | // newPartial instanciates a new partial 26 | func newPartial(name string, source string, tpl *Template) *partial { 27 | return &partial{ 28 | name: name, 29 | source: source, 30 | tpl: tpl, 31 | } 32 | } 33 | 34 | // RegisterPartial registers a global partial. That partial will be available to all templates. 35 | func RegisterPartial(name string, source string) { 36 | partialsMutex.Lock() 37 | defer partialsMutex.Unlock() 38 | 39 | if partials[name] != nil { 40 | panic(fmt.Errorf("Partial already registered: %s", name)) 41 | } 42 | 43 | partials[name] = newPartial(name, source, nil) 44 | } 45 | 46 | // RegisterPartials registers several global partials. Those partials will be available to all templates. 47 | func RegisterPartials(partials map[string]string) { 48 | for name, p := range partials { 49 | RegisterPartial(name, p) 50 | } 51 | } 52 | 53 | // RegisterPartialTemplate registers a global partial with given parsed template. That partial will be available to all templates. 54 | func RegisterPartialTemplate(name string, tpl *Template) { 55 | partialsMutex.Lock() 56 | defer partialsMutex.Unlock() 57 | 58 | if partials[name] != nil { 59 | panic(fmt.Errorf("Partial already registered: %s", name)) 60 | } 61 | 62 | partials[name] = newPartial(name, "", tpl) 63 | } 64 | 65 | // 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. 66 | func RemovePartial(name string) { 67 | partialsMutex.Lock() 68 | defer partialsMutex.Unlock() 69 | 70 | delete(partials, name) 71 | } 72 | 73 | // RemoveAllPartials removes all globally registered partials. This does not affect partials registered on a specific template. 74 | func RemoveAllPartials() { 75 | partialsMutex.Lock() 76 | defer partialsMutex.Unlock() 77 | 78 | partials = make(map[string]*partial) 79 | } 80 | 81 | // findPartial finds a registered global partial 82 | func findPartial(name string) *partial { 83 | partialsMutex.RLock() 84 | defer partialsMutex.RUnlock() 85 | 86 | return partials[name] 87 | } 88 | 89 | // template returns parsed partial template 90 | func (p *partial) template() (*Template, error) { 91 | if p.tpl == nil { 92 | var err error 93 | 94 | p.tpl, err = Parse(p.source) 95 | if err != nil { 96 | return nil, err 97 | } 98 | } 99 | 100 | return p.tpl, nil 101 | } 102 | -------------------------------------------------------------------------------- /mustache/specs/partials.json: -------------------------------------------------------------------------------- 1 | {"__ATTN__":"Do not edit this file; changes belong in the appropriate YAML file.","overview":"Partial tags are used to expand an external template into the current\ntemplate.\n\nThe tag's content MUST be a non-whitespace character sequence NOT containing\nthe current closing delimiter.\n\nThis tag's content names the partial to inject. Set Delimiter tags MUST NOT\naffect the parsing of a partial. The partial MUST be rendered against the\ncontext stack local to the tag. If the named partial cannot be found, the\nempty string SHOULD be used instead, as in interpolations.\n\nPartial tags SHOULD be treated as standalone when appropriate. If this tag\nis used standalone, any whitespace preceding the tag should treated as\nindentation, and prepended to each line of the partial before rendering.\n","tests":[{"name":"Basic Behavior","data":{},"expected":"\"from partial\"","template":"\"{{>text}}\"","desc":"The greater-than operator should expand to the named partial.","partials":{"text":"from partial"}},{"name":"Failed Lookup","data":{},"expected":"\"\"","template":"\"{{>text}}\"","desc":"The empty string should be used when the named partial is not found.","partials":{}},{"name":"Context","data":{"text":"content"},"expected":"\"*content*\"","template":"\"{{>partial}}\"","desc":"The greater-than operator should operate within the current context.","partials":{"partial":"*{{text}}*"}},{"name":"Recursion","data":{"content":"X","nodes":[{"content":"Y","nodes":[]}]},"expected":"X{{body.content}}
" 81 | 82 | ctx := map[string]interface{}{ 83 | "title": "foo", 84 | "body": map[string]string{"content": "bar"}, 85 | } 86 | 87 | // parse template 88 | tpl := MustParse(source) 89 | 90 | // evaluate template with context 91 | output, err := tpl.Exec(ctx) 92 | if err != nil { 93 | panic(err) 94 | } 95 | 96 | fmt.Print(output) 97 | // Output:bar
98 | } 99 | 100 | func ExampleTemplate_MustExec() { 101 | source := "{{body.content}}
" 102 | 103 | ctx := map[string]interface{}{ 104 | "title": "foo", 105 | "body": map[string]string{"content": "bar"}, 106 | } 107 | 108 | // parse template 109 | tpl := MustParse(source) 110 | 111 | // evaluate template with context 112 | output := tpl.MustExec(ctx) 113 | 114 | fmt.Print(output) 115 | // Output:bar
116 | } 117 | 118 | func ExampleTemplate_ExecWith() { 119 | source := "{{#body}}{{content}} and {{@baz.bat}}{{/body}}
" 120 | 121 | ctx := map[string]interface{}{ 122 | "title": "foo", 123 | "body": map[string]string{"content": "bar"}, 124 | } 125 | 126 | // parse template 127 | tpl := MustParse(source) 128 | 129 | // computes private data frame 130 | frame := NewDataFrame() 131 | frame.Set("baz", map[string]string{"bat": "unicorns"}) 132 | 133 | // evaluate template 134 | output, err := tpl.ExecWith(ctx, frame) 135 | if err != nil { 136 | panic(err) 137 | } 138 | 139 | fmt.Print(output) 140 | // Output:bar and unicorns
141 | } 142 | 143 | func ExampleTemplate_PrintAST() { 144 | source := "{{#body}}{{content}} and {{@baz.bat}}{{/body}}
" 145 | 146 | // parse template 147 | tpl := MustParse(source) 148 | 149 | // print AST 150 | output := tpl.PrintAST() 151 | 152 | fmt.Print(output) 153 | // Output: CONTENT[ '' ] 156 | // BLOCK: 157 | // PATH:body [] 158 | // PROGRAM: 159 | // {{ PATH:content [] 160 | // }} 161 | // CONTENT[ ' and ' ] 162 | // {{ @PATH:baz/bat [] 163 | // }} 164 | // CONTENT[ '
' ] 165 | // 166 | } 167 | -------------------------------------------------------------------------------- /mustache/specs/delimiters.yml: -------------------------------------------------------------------------------- 1 | overview: | 2 | Set Delimiter tags are used to change the tag delimiters for all content 3 | following the tag in the current compilation unit. 4 | 5 | The tag's content MUST be any two non-whitespace sequences (separated by 6 | whitespace) EXCEPT an equals sign ('=') followed by the current closing 7 | delimiter. 8 | 9 | Set Delimiter tags SHOULD be treated as standalone when appropriate. 10 | tests: 11 | - name: Pair Behavior 12 | desc: The equals sign (used on both sides) should permit delimiter changes. 13 | data: { text: 'Hey!' } 14 | template: '{{=<% %>=}}(<%text%>)' 15 | expected: '(Hey!)' 16 | 17 | - name: Special Characters 18 | desc: Characters with special meaning regexen should be valid delimiters. 19 | data: { text: 'It worked!' } 20 | template: '({{=[ ]=}}[text])' 21 | expected: '(It worked!)' 22 | 23 | - name: Sections 24 | desc: Delimiters set outside sections should persist. 25 | data: { section: true, data: 'I got interpolated.' } 26 | template: | 27 | [ 28 | {{#section}} 29 | {{data}} 30 | |data| 31 | {{/section}} 32 | 33 | {{= | | =}} 34 | |#section| 35 | {{data}} 36 | |data| 37 | |/section| 38 | ] 39 | expected: | 40 | [ 41 | I got interpolated. 42 | |data| 43 | 44 | {{data}} 45 | I got interpolated. 46 | ] 47 | 48 | - name: Inverted Sections 49 | desc: Delimiters set outside inverted sections should persist. 50 | data: { section: false, data: 'I got interpolated.' } 51 | template: | 52 | [ 53 | {{^section}} 54 | {{data}} 55 | |data| 56 | {{/section}} 57 | 58 | {{= | | =}} 59 | |^section| 60 | {{data}} 61 | |data| 62 | |/section| 63 | ] 64 | expected: | 65 | [ 66 | I got interpolated. 67 | |data| 68 | 69 | {{data}} 70 | I got interpolated. 71 | ] 72 | 73 | - name: Partial Inheritence 74 | desc: Delimiters set in a parent template should not affect a partial. 75 | data: { value: 'yes' } 76 | partials: 77 | include: '.{{value}}.' 78 | template: | 79 | [ {{>include}} ] 80 | {{= | | =}} 81 | [ |>include| ] 82 | expected: | 83 | [ .yes. ] 84 | [ .yes. ] 85 | 86 | - name: Post-Partial Behavior 87 | desc: Delimiters set in a partial should not affect the parent template. 88 | data: { value: 'yes' } 89 | partials: 90 | include: '.{{value}}. {{= | | =}} .|value|.' 91 | template: | 92 | [ {{>include}} ] 93 | [ .{{value}}. .|value|. ] 94 | expected: | 95 | [ .yes. .yes. ] 96 | [ .yes. .|value|. ] 97 | 98 | # Whitespace Sensitivity 99 | 100 | - name: Surrounding Whitespace 101 | desc: Surrounding whitespace should be left untouched. 102 | data: { } 103 | template: '| {{=@ @=}} |' 104 | expected: '| |' 105 | 106 | - name: Outlying Whitespace (Inline) 107 | desc: Whitespace should be left untouched. 108 | data: { } 109 | template: " | {{=@ @=}}\n" 110 | expected: " | \n" 111 | 112 | - name: Standalone Tag 113 | desc: Standalone lines should be removed from the template. 114 | data: { } 115 | template: | 116 | Begin. 117 | {{=@ @=}} 118 | End. 119 | expected: | 120 | Begin. 121 | End. 122 | 123 | - name: Indented Standalone Tag 124 | desc: Indented standalone lines should be removed from the template. 125 | data: { } 126 | template: | 127 | Begin. 128 | {{=@ @=}} 129 | End. 130 | expected: | 131 | Begin. 132 | End. 133 | 134 | - name: Standalone Line Endings 135 | desc: '"\r\n" should be considered a newline for standalone tags.' 136 | data: { } 137 | template: "|\r\n{{= @ @ =}}\r\n|" 138 | expected: "|\r\n|" 139 | 140 | - name: Standalone Without Previous Line 141 | desc: Standalone tags should not require a newline to precede them. 142 | data: { } 143 | template: " {{=@ @=}}\n=" 144 | expected: "=" 145 | 146 | - name: Standalone Without Newline 147 | desc: Standalone tags should not require a newline to follow them. 148 | data: { } 149 | template: "=\n {{=@ @=}}" 150 | expected: "=\n" 151 | 152 | # Whitespace Insensitivity 153 | 154 | - name: Pair with Padding 155 | desc: Superfluous in-tag whitespace should be ignored. 156 | data: { } 157 | template: '|{{= @ @ =}}|' 158 | expected: '||' 159 | -------------------------------------------------------------------------------- /lexer/token.go: -------------------------------------------------------------------------------- 1 | package lexer 2 | 3 | import "fmt" 4 | 5 | const ( 6 | // TokenError represents an error 7 | TokenError TokenKind = iota 8 | 9 | // TokenEOF represents an End Of File 10 | TokenEOF 11 | 12 | // 13 | // Mustache delimiters 14 | // 15 | 16 | // TokenOpen is the OPEN token 17 | TokenOpen 18 | 19 | // TokenClose is the CLOSE token 20 | TokenClose 21 | 22 | // TokenOpenRawBlock is the OPEN_RAW_BLOCK token 23 | TokenOpenRawBlock 24 | 25 | // TokenCloseRawBlock is the CLOSE_RAW_BLOCK token 26 | TokenCloseRawBlock 27 | 28 | // TokenOpenEndRawBlock is the END_RAW_BLOCK token 29 | TokenOpenEndRawBlock 30 | 31 | // TokenOpenUnescaped is the OPEN_UNESCAPED token 32 | TokenOpenUnescaped 33 | 34 | // TokenCloseUnescaped is the CLOSE_UNESCAPED token 35 | TokenCloseUnescaped 36 | 37 | // TokenOpenBlock is the OPEN_BLOCK token 38 | TokenOpenBlock 39 | 40 | // TokenOpenEndBlock is the OPEN_ENDBLOCK token 41 | TokenOpenEndBlock 42 | 43 | // TokenInverse is the INVERSE token 44 | TokenInverse 45 | 46 | // TokenOpenInverse is the OPEN_INVERSE token 47 | TokenOpenInverse 48 | 49 | // TokenOpenInverseChain is the OPEN_INVERSE_CHAIN token 50 | TokenOpenInverseChain 51 | 52 | // TokenOpenPartial is the OPEN_PARTIAL token 53 | TokenOpenPartial 54 | 55 | // TokenComment is the COMMENT token 56 | TokenComment 57 | 58 | // 59 | // Inside mustaches 60 | // 61 | 62 | // TokenOpenSexpr is the OPEN_SEXPR token 63 | TokenOpenSexpr 64 | 65 | // TokenCloseSexpr is the CLOSE_SEXPR token 66 | TokenCloseSexpr 67 | 68 | // TokenEquals is the EQUALS token 69 | TokenEquals 70 | 71 | // TokenData is the DATA token 72 | TokenData 73 | 74 | // TokenSep is the SEP token 75 | TokenSep 76 | 77 | // TokenOpenBlockParams is the OPEN_BLOCK_PARAMS token 78 | TokenOpenBlockParams 79 | 80 | // TokenCloseBlockParams is the CLOSE_BLOCK_PARAMS token 81 | TokenCloseBlockParams 82 | 83 | // 84 | // Tokens with content 85 | // 86 | 87 | // TokenContent is the CONTENT token 88 | TokenContent 89 | 90 | // TokenID is the ID token 91 | TokenID 92 | 93 | // TokenString is the STRING token 94 | TokenString 95 | 96 | // TokenNumber is the NUMBER token 97 | TokenNumber 98 | 99 | // TokenBoolean is the BOOLEAN token 100 | TokenBoolean 101 | ) 102 | 103 | const ( 104 | // Option to generate token position in its string representation 105 | dumpTokenPos = false 106 | 107 | // Option to generate values for all token kinds for their string representations 108 | dumpAllTokensVal = true 109 | ) 110 | 111 | // TokenKind represents a Token type. 112 | type TokenKind int 113 | 114 | // Token represents a scanned token. 115 | type Token struct { 116 | Kind TokenKind // Token kind 117 | Val string // Token value 118 | 119 | Pos int // Byte position in input string 120 | Line int // Line number in input string 121 | } 122 | 123 | // tokenName permits to display token name given token type 124 | var tokenName = map[TokenKind]string{ 125 | TokenError: "Error", 126 | TokenEOF: "EOF", 127 | TokenContent: "Content", 128 | TokenComment: "Comment", 129 | TokenOpen: "Open", 130 | TokenClose: "Close", 131 | TokenOpenUnescaped: "OpenUnescaped", 132 | TokenCloseUnescaped: "CloseUnescaped", 133 | TokenOpenBlock: "OpenBlock", 134 | TokenOpenEndBlock: "OpenEndBlock", 135 | TokenOpenRawBlock: "OpenRawBlock", 136 | TokenCloseRawBlock: "CloseRawBlock", 137 | TokenOpenEndRawBlock: "OpenEndRawBlock", 138 | TokenOpenBlockParams: "OpenBlockParams", 139 | TokenCloseBlockParams: "CloseBlockParams", 140 | TokenInverse: "Inverse", 141 | TokenOpenInverse: "OpenInverse", 142 | TokenOpenInverseChain: "OpenInverseChain", 143 | TokenOpenPartial: "OpenPartial", 144 | TokenOpenSexpr: "OpenSexpr", 145 | TokenCloseSexpr: "CloseSexpr", 146 | TokenID: "ID", 147 | TokenEquals: "Equals", 148 | TokenString: "String", 149 | TokenNumber: "Number", 150 | TokenBoolean: "Boolean", 151 | TokenData: "Data", 152 | TokenSep: "Sep", 153 | } 154 | 155 | // String returns the token kind string representation for debugging. 156 | func (k TokenKind) String() string { 157 | s := tokenName[k] 158 | if s == "" { 159 | return fmt.Sprintf("Token-%d", int(k)) 160 | } 161 | return s 162 | } 163 | 164 | // String returns the token string representation for debugging. 165 | func (t Token) String() string { 166 | result := "" 167 | 168 | if dumpTokenPos { 169 | result += fmt.Sprintf("%d:", t.Pos) 170 | } 171 | 172 | result += fmt.Sprintf("%s", t.Kind) 173 | 174 | if (dumpAllTokensVal || (t.Kind >= TokenContent)) && len(t.Val) > 0 { 175 | if len(t.Val) > 100 { 176 | result += fmt.Sprintf("{%.20q...}", t.Val) 177 | } else { 178 | result += fmt.Sprintf("{%q}", t.Val) 179 | } 180 | } 181 | 182 | return result 183 | } 184 | -------------------------------------------------------------------------------- /context.go: -------------------------------------------------------------------------------- 1 | package raymond 2 | 3 | import ( 4 | "strings" 5 | ) 6 | 7 | type contextMember struct { 8 | path string 9 | asMapping string 10 | } 11 | 12 | type handlebarsContext struct { 13 | contextMembers []contextMember 14 | } 15 | 16 | func newHandlebarsContext() *handlebarsContext { 17 | var cm []contextMember 18 | return &handlebarsContext{contextMembers: cm} 19 | } 20 | 21 | func (h *handlebarsContext) AddMemberContext(path, asMapping string) { 22 | cmp := contextMember{path: path, asMapping: asMapping} 23 | h.contextMembers = append(h.contextMembers, cmp) 24 | } 25 | 26 | func (h *handlebarsContext) GetCurrentContext() []string { 27 | return h.GetParentContext(0) 28 | } 29 | 30 | func (h *handlebarsContext) GetCurrentContextString() string { 31 | return h.GetParentContextString(0) 32 | } 33 | 34 | func (h *handlebarsContext) GetParentContext(num_ancestors int) []string { 35 | if len(h.contextMembers) == 0 { 36 | return []string{} 37 | } 38 | return strings.Split(h.GetParentContextString(num_ancestors), ".") 39 | } 40 | 41 | func (h *handlebarsContext) GetParentContextString(num_ancestors int) string { 42 | if len(h.contextMembers) == 0 { 43 | return "" 44 | } 45 | if num_ancestors > len(h.contextMembers) { 46 | num_ancestors = 0 47 | } 48 | var res string 49 | for _, val := range h.contextMembers[:len(h.contextMembers)-num_ancestors] { 50 | if len(res) == 0 { 51 | res = val.path 52 | } else { 53 | res = res + "." + val.path 54 | } 55 | } 56 | return res 57 | } 58 | 59 | func (h *handlebarsContext) MoveUpContext() { 60 | if len(h.contextMembers) > 0 { 61 | h.contextMembers = h.contextMembers[:len(h.contextMembers)-1] 62 | } 63 | } 64 | 65 | func (h *handlebarsContext) HaveAsContexts(num_ancestors int) bool { 66 | if num_ancestors > len(h.contextMembers) { 67 | num_ancestors = 0 68 | } 69 | for val := range h.contextMembers[:len(h.contextMembers)-num_ancestors] { 70 | if h.contextMembers[val].asMapping != "" { 71 | return true 72 | } 73 | } 74 | return false 75 | } 76 | 77 | func (h *handlebarsContext) GetMappedContext(path []string, num_ancestors int) []string { 78 | if len(path) == 0 { 79 | return []string{} 80 | } 81 | return strings.Split(h.GetMappedContextString(path, num_ancestors), ".") 82 | } 83 | 84 | func (h *handlebarsContext) GetMappedContextString(path []string, num_ancestors int) string { 85 | if len(h.contextMembers) == 0 { 86 | return strings.Join(path, ".") 87 | } 88 | if num_ancestors > len(h.contextMembers) { 89 | num_ancestors = 0 90 | } 91 | if !h.HaveAsContexts(num_ancestors) { 92 | var res string 93 | if path[0] == "" { 94 | res = h.GetParentContextString(num_ancestors) 95 | } else { 96 | res = h.GetParentContextString(num_ancestors) + "." + strings.Join(path, ".") 97 | } 98 | return strings.Trim(res, ".") 99 | } 100 | var res string 101 | copiedMembers := make([]contextMember, 0) 102 | if num_ancestors > 0 { 103 | copiedMembers = append(copiedMembers, h.contextMembers[:len(h.contextMembers)-num_ancestors]...) 104 | } else { 105 | copiedMembers = append(copiedMembers, h.contextMembers...) 106 | } 107 | for p := len(path) - 1; p >= 0; p-- { 108 | var val contextMember 109 | var found string 110 | if len(copiedMembers) == 0 { 111 | found = path[p] 112 | } else { 113 | val = copiedMembers[len(copiedMembers)-1] 114 | if val.asMapping == path[p] { 115 | found = val.path 116 | if len(copiedMembers) > 1 { 117 | val2 := copiedMembers[len(copiedMembers)-2] 118 | tmp := strings.Split(val.path, ".") 119 | if tmp[0] == val2.asMapping { 120 | found = strings.Join(tmp[1:], ".") 121 | } 122 | } 123 | copiedMembers = copiedMembers[:len(copiedMembers)-1] 124 | } else { 125 | if len(val.asMapping) == 0 { 126 | found = val.path + "." + path[p] 127 | copiedMembers = copiedMembers[:len(copiedMembers)-1] 128 | } else { 129 | if len(copiedMembers) == 0 { 130 | ss := strings.Split(val.asMapping, ".") 131 | if ss[0] == path[p] { 132 | found = val.path 133 | } else { 134 | } 135 | } else { 136 | if len(copiedMembers) > 1 { 137 | cv := copiedMembers[len(copiedMembers)-2] 138 | mappedPath := strings.Split(cv.path, ".") 139 | if len(mappedPath) > 1 { 140 | tmp := strings.Join(mappedPath[1:], ".") 141 | if tmp == val.asMapping { 142 | found = val.path 143 | copiedMembers = copiedMembers[:len(copiedMembers)-1] 144 | } else { 145 | found = path[p] 146 | } 147 | } else { 148 | found = path[p] 149 | } 150 | } else { 151 | found = path[p] 152 | } 153 | } 154 | } 155 | } 156 | } 157 | res = found + "." + res 158 | } 159 | if len(copiedMembers) > 0 { 160 | for p := len(copiedMembers) - 1; p >= 0; p-- { 161 | res = copiedMembers[p].path + "." + res 162 | } 163 | } 164 | return strings.Trim(res, ".") 165 | } 166 | -------------------------------------------------------------------------------- /base_test.go: -------------------------------------------------------------------------------- 1 | package raymond 2 | 3 | import ( 4 | "fmt" 5 | "regexp" 6 | "testing" 7 | ) 8 | 9 | type Test struct { 10 | name string 11 | input string 12 | data interface{} 13 | privData map[string]interface{} 14 | helpers map[string]interface{} 15 | partials map[string]string 16 | output interface{} 17 | } 18 | 19 | func launchTests(t *testing.T, tests []Test) { 20 | // NOTE: TestMustache() makes Parallel testing fail 21 | // t.Parallel() 22 | 23 | for _, test := range tests { 24 | var err error 25 | var tpl *Template 26 | 27 | // parse template 28 | tpl, err = Parse(test.input) 29 | if err != nil { 30 | t.Errorf("Test '%s' failed - Failed to parse template\ninput:\n\t'%s'\nerror:\n\t%s", test.name, test.input, err) 31 | } else { 32 | if len(test.helpers) > 0 { 33 | // register helpers 34 | tpl.RegisterHelpers(test.helpers) 35 | } 36 | 37 | if len(test.partials) > 0 { 38 | // register partials 39 | tpl.RegisterPartials(test.partials) 40 | } 41 | 42 | // setup private data frame 43 | var privData *DataFrame 44 | if test.privData != nil { 45 | privData = NewDataFrame() 46 | for k, v := range test.privData { 47 | privData.Set(k, v) 48 | } 49 | } 50 | 51 | // render template 52 | output, err := tpl.ExecWith(test.data, privData) 53 | if err != nil { 54 | t.Errorf("Test '%s' failed\ninput:\n\t'%s'\ndata:\n\t%s\nerror:\n\t%s\nAST:\n\t%s", test.name, test.input, Str(test.data), err, tpl.PrintAST()) 55 | } else { 56 | // check output 57 | var expectedArr []string 58 | expectedArr, ok := test.output.([]string) 59 | if ok { 60 | match := false 61 | for _, expectedStr := range expectedArr { 62 | if expectedStr == output { 63 | match = true 64 | break 65 | } 66 | } 67 | 68 | if !match { 69 | t.Errorf("Test '%s' failed\ninput:\n\t'%s'\ndata:\n\t%s\npartials:\n\t%s\nexpected\n\t%q\ngot\n\t%q\nAST:\n%s", test.name, test.input, Str(test.data), Str(test.partials), expectedArr, output, tpl.PrintAST()) 70 | } 71 | } else { 72 | expectedStr, ok := test.output.(string) 73 | if !ok { 74 | panic(fmt.Errorf("Erroneous test output description: %q", test.output)) 75 | } 76 | 77 | if expectedStr != output { 78 | t.Errorf("Test '%s' failed\ninput:\n\t'%s'\ndata:\n\t%s\npartials:\n\t%s\nexpected\n\t%q\ngot\n\t%q\nAST:\n%s", test.name, test.input, Str(test.data), Str(test.partials), expectedStr, output, tpl.PrintAST()) 79 | } 80 | } 81 | } 82 | } 83 | } 84 | } 85 | 86 | func launchErrorTests(t *testing.T, tests []Test) { 87 | t.Parallel() 88 | 89 | for _, test := range tests { 90 | var err error 91 | var tpl *Template 92 | 93 | // parse template 94 | tpl, err = Parse(test.input) 95 | if err != nil { 96 | t.Errorf("Test '%s' failed - Failed to parse template\ninput:\n\t'%s'\nerror:\n\t%s", test.name, test.input, err) 97 | } else { 98 | if len(test.helpers) > 0 { 99 | // register helpers 100 | tpl.RegisterHelpers(test.helpers) 101 | } 102 | 103 | if len(test.partials) > 0 { 104 | // register partials 105 | tpl.RegisterPartials(test.partials) 106 | } 107 | 108 | // setup private data frame 109 | var privData *DataFrame 110 | if test.privData != nil { 111 | privData := NewDataFrame() 112 | for k, v := range test.privData { 113 | privData.Set(k, v) 114 | } 115 | } 116 | 117 | // render template 118 | output, err := tpl.ExecWith(test.data, privData) 119 | if err == nil { 120 | t.Errorf("Test '%s' failed - Error expected\ninput:\n\t'%s'\ngot\n\t%q\nAST:\n%q", test.name, test.input, output, tpl.PrintAST()) 121 | } else { 122 | var errMatch error 123 | match := false 124 | 125 | // check output 126 | var expectedArr []string 127 | expectedArr, ok := test.output.([]string) 128 | if ok { 129 | if len(expectedArr) > 0 { 130 | for _, expectedStr := range expectedArr { 131 | match, errMatch = regexp.MatchString(regexp.QuoteMeta(expectedStr), fmt.Sprint(err)) 132 | if errMatch != nil { 133 | panic("Failed to match regexp") 134 | } 135 | 136 | if match { 137 | break 138 | } 139 | } 140 | } else { 141 | // nothing to test 142 | match = true 143 | } 144 | } else { 145 | expectedStr, ok := test.output.(string) 146 | if !ok { 147 | panic(fmt.Errorf("Erroneous test output description: %q", test.output)) 148 | } 149 | 150 | if expectedStr != "" { 151 | match, errMatch = regexp.MatchString(regexp.QuoteMeta(expectedStr), fmt.Sprint(err)) 152 | if errMatch != nil { 153 | panic("Failed to match regexp") 154 | } 155 | } else { 156 | // nothing to test 157 | match = true 158 | } 159 | } 160 | 161 | if !match { 162 | t.Errorf("Test '%s' failed - Incorrect error returned\ninput:\n\t'%s'\ndata:\n\t%s\nexpected\n\t%q\ngot\n\t%q", test.name, test.input, Str(test.data), test.output, err) 163 | } 164 | } 165 | } 166 | } 167 | } 168 | -------------------------------------------------------------------------------- /mustache/specs/~lambdas.json: -------------------------------------------------------------------------------- 1 | {"__ATTN__":"Do not edit this file; changes belong in the appropriate YAML file.","overview":"Lambdas are a special-cased data type for use in interpolations and\nsections.\n\nWhen used as the data value for an Interpolation tag, the lambda MUST be\ntreatable as an arity 0 function, and invoked as such. The returned value\nMUST be rendered against the default delimiters, then interpolated in place\nof the lambda.\n\nWhen used as the data value for a Section tag, the lambda MUST be treatable\nas an arity 1 function, and invoked as such (passing a String containing the\nunprocessed section contents). The returned value MUST be rendered against\nthe current delimiters, then interpolated in place of the section.\n","tests":[{"name":"Interpolation","data":{"lambda":{"php":"return \"world\";","clojure":"(fn [] \"world\")","__tag__":"code","perl":"sub { \"world\" }","python":"lambda: \"world\"","ruby":"proc { \"world\" }","js":"function() { return \"world\" }"}},"expected":"Hello, world!","template":"Hello, {{lambda}}!","desc":"A lambda's return value should be interpolated."},{"name":"Interpolation - Expansion","data":{"planet":"world","lambda":{"php":"return \"{{planet}}\";","clojure":"(fn [] \"{{planet}}\")","__tag__":"code","perl":"sub { \"{{planet}}\" }","python":"lambda: \"{{planet}}\"","ruby":"proc { \"{{planet}}\" }","js":"function() { return \"{{planet}}\" }"}},"expected":"Hello, world!","template":"Hello, {{lambda}}!","desc":"A lambda's return value should be parsed."},{"name":"Interpolation - Alternate Delimiters","data":{"planet":"world","lambda":{"php":"return \"|planet| => {{planet}}\";","clojure":"(fn [] \"|planet| => {{planet}}\")","__tag__":"code","perl":"sub { \"|planet| => {{planet}}\" }","python":"lambda: \"|planet| => {{planet}}\"","ruby":"proc { \"|planet| => {{planet}}\" }","js":"function() { return \"|planet| => {{planet}}\" }"}},"expected":"Hello, (|planet| => world)!","template":"{{= | | =}}\nHello, (|&lambda|)!","desc":"A lambda's return value should parse with the default delimiters."},{"name":"Interpolation - Multiple Calls","data":{"lambda":{"php":"global $calls; return ++$calls;","clojure":"(def g (atom 0)) (fn [] (swap! g inc))","__tag__":"code","perl":"sub { no strict; $calls += 1 }","python":"lambda: globals().update(calls=globals().get(\"calls\",0)+1) or calls","ruby":"proc { $calls ||= 0; $calls += 1 }","js":"function() { return (g=(function(){return this})()).calls=(g.calls||0)+1 }"}},"expected":"1 == 2 == 3","template":"{{lambda}} == {{{lambda}}} == {{lambda}}","desc":"Interpolated lambdas should not be cached."},{"name":"Escaping","data":{"lambda":{"php":"return \">\";","clojure":"(fn [] \">\")","__tag__":"code","perl":"sub { \">\" }","python":"lambda: \">\"","ruby":"proc { \">\" }","js":"function() { return \">\" }"}},"expected":"<>>","template":"<{{lambda}}{{{lambda}}}","desc":"Lambda results should be appropriately escaped."},{"name":"Section","data":{"x":"Error!","lambda":{"php":"return ($text == \"{{x}}\") ? \"yes\" : \"no\";","clojure":"(fn [text] (if (= text \"{{x}}\") \"yes\" \"no\"))","__tag__":"code","perl":"sub { $_[0] eq \"{{x}}\" ? \"yes\" : \"no\" }","python":"lambda text: text == \"{{x}}\" and \"yes\" or \"no\"","ruby":"proc { |text| text == \"{{x}}\" ? \"yes\" : \"no\" }","js":"function(txt) { return (txt == \"{{x}}\" ? \"yes\" : \"no\") }"}},"expected":"{{alias-name}}
185 | {{/each}} 186 |his dudeness
196 |el duderino
197 |The list is empty.
82 | {{/if}} 83 | ` 84 | 85 | ctx := map[string]interface{}{ 86 | "header": func() string { return "Colors" }, 87 | "hasItems": true, 88 | "items": []map[string]interface{}{ 89 | {"name": "red", "current": true, "url": "#Red"}, 90 | {"name": "green", "current": false, "url": "#Green"}, 91 | {"name": "blue", "current": false, "url": "#Blue"}, 92 | }, 93 | } 94 | 95 | tpl := MustParse(source) 96 | 97 | b.ResetTimer() 98 | for i := 0; i < b.N; i++ { 99 | tpl.MustExec(ctx) 100 | } 101 | } 102 | 103 | func BenchmarkData(b *testing.B) { 104 | source := `{{#each names}}{{@index}}{{name}}{{/each}}` 105 | 106 | ctx := map[string][]map[string]string{ 107 | "names": { 108 | {"name": "Moe"}, 109 | {"name": "Larry"}, 110 | {"name": "Curly"}, 111 | {"name": "Shemp"}, 112 | }, 113 | } 114 | 115 | tpl := MustParse(source) 116 | 117 | b.ResetTimer() 118 | for i := 0; i < b.N; i++ { 119 | tpl.MustExec(ctx) 120 | } 121 | } 122 | 123 | func BenchmarkDepth1(b *testing.B) { 124 | source := `{{#each names}}{{../foo}}{{/each}}` 125 | 126 | ctx := map[string]interface{}{ 127 | "names": []map[string]string{ 128 | {"name": "Moe"}, 129 | {"name": "Larry"}, 130 | {"name": "Curly"}, 131 | {"name": "Shemp"}, 132 | }, 133 | "foo": "bar", 134 | } 135 | 136 | tpl := MustParse(source) 137 | 138 | b.ResetTimer() 139 | for i := 0; i < b.N; i++ { 140 | tpl.MustExec(ctx) 141 | } 142 | } 143 | 144 | func BenchmarkDepth2(b *testing.B) { 145 | source := `{{#each names}}{{#each name}}{{../bat}}{{../../foo}}{{/each}}{{/each}}` 146 | 147 | ctx := map[string]interface{}{ 148 | "names": []map[string]interface{}{ 149 | {"bat": "foo", "name": []string{"Moe"}}, 150 | {"bat": "foo", "name": []string{"Larry"}}, 151 | {"bat": "foo", "name": []string{"Curly"}}, 152 | {"bat": "foo", "name": []string{"Shemp"}}, 153 | }, 154 | "foo": "bar", 155 | } 156 | 157 | tpl := MustParse(source) 158 | 159 | b.ResetTimer() 160 | for i := 0; i < b.N; i++ { 161 | tpl.MustExec(ctx) 162 | } 163 | } 164 | 165 | func BenchmarkObjectMustache(b *testing.B) { 166 | source := `{{#person}}{{name}}{{age}}{{/person}}` 167 | 168 | ctx := map[string]interface{}{ 169 | "person": map[string]interface{}{ 170 | "name": "Larry", 171 | "age": 45, 172 | }, 173 | } 174 | 175 | tpl := MustParse(source) 176 | 177 | b.ResetTimer() 178 | for i := 0; i < b.N; i++ { 179 | tpl.MustExec(ctx) 180 | } 181 | } 182 | 183 | func BenchmarkObject(b *testing.B) { 184 | source := `{{#with person}}{{name}}{{age}}{{/with}}` 185 | 186 | ctx := map[string]interface{}{ 187 | "person": map[string]interface{}{ 188 | "name": "Larry", 189 | "age": 45, 190 | }, 191 | } 192 | 193 | tpl := MustParse(source) 194 | 195 | b.ResetTimer() 196 | for i := 0; i < b.N; i++ { 197 | tpl.MustExec(ctx) 198 | } 199 | } 200 | 201 | func BenchmarkPartialRecursion(b *testing.B) { 202 | source := `{{name}}{{#each kids}}{{>recursion}}{{/each}}` 203 | 204 | ctx := map[string]interface{}{ 205 | "name": 1, 206 | "kids": []map[string]interface{}{ 207 | { 208 | "name": "1.1", 209 | "kids": []map[string]interface{}{ 210 | { 211 | "name": "1.1.1", 212 | "kids": []map[string]interface{}{}, 213 | }, 214 | }, 215 | }, 216 | }, 217 | } 218 | 219 | tpl := MustParse(source) 220 | 221 | partial := MustParse(`{{name}}{{#each kids}}{{>recursion}}{{/each}}`) 222 | tpl.RegisterPartialTemplate("recursion", partial) 223 | 224 | b.ResetTimer() 225 | for i := 0; i < b.N; i++ { 226 | tpl.MustExec(ctx) 227 | } 228 | } 229 | 230 | func BenchmarkPartial(b *testing.B) { 231 | source := `{{#each peeps}}{{>variables}}{{/each}}` 232 | 233 | ctx := map[string]interface{}{ 234 | "peeps": []map[string]interface{}{ 235 | {"name": "Moe", "count": 15}, 236 | {"name": "Moe", "count": 5}, 237 | {"name": "Curly", "count": 1}, 238 | }, 239 | } 240 | 241 | tpl := MustParse(source) 242 | 243 | partial := MustParse(`Hello {{name}}! You have {{count}} new messages.`) 244 | tpl.RegisterPartialTemplate("variables", partial) 245 | 246 | b.ResetTimer() 247 | for i := 0; i < b.N; i++ { 248 | tpl.MustExec(ctx) 249 | } 250 | } 251 | 252 | func BenchmarkPath(b *testing.B) { 253 | source := `{{person.name.bar.baz}}{{person.age}}{{person.foo}}{{animal.age}}` 254 | 255 | ctx := map[string]interface{}{ 256 | "person": map[string]interface{}{ 257 | "name": map[string]interface{}{ 258 | "bar": map[string]string{ 259 | "baz": "Larry", 260 | }, 261 | }, 262 | "age": 45, 263 | }, 264 | } 265 | 266 | tpl := MustParse(source) 267 | 268 | b.ResetTimer() 269 | for i := 0; i < b.N; i++ { 270 | tpl.MustExec(ctx) 271 | } 272 | } 273 | 274 | func BenchmarkString(b *testing.B) { 275 | source := `Hello world` 276 | 277 | tpl := MustParse(source) 278 | 279 | b.ResetTimer() 280 | for i := 0; i < b.N; i++ { 281 | tpl.MustExec(nil) 282 | } 283 | } 284 | 285 | func BenchmarkSubExpression(b *testing.B) { 286 | source := `{{echo (header)}}` 287 | 288 | ctx := map[string]interface{}{} 289 | 290 | tpl := MustParse(source) 291 | tpl.RegisterHelpers(map[string]interface{}{ 292 | "echo": func(v string) string { return "foo " + v }, 293 | "header": func() string { return "Colors" }, 294 | }) 295 | 296 | b.ResetTimer() 297 | for i := 0; i < b.N; i++ { 298 | tpl.MustExec(ctx) 299 | } 300 | } 301 | 302 | func BenchmarkVariables(b *testing.B) { 303 | source := `Hello {{name}}! You have {{count}} new messages.` 304 | 305 | ctx := map[string]interface{}{ 306 | "name": "Mick", 307 | "count": 30, 308 | } 309 | 310 | tpl := MustParse(source) 311 | 312 | b.ResetTimer() 313 | for i := 0; i < b.N; i++ { 314 | tpl.MustExec(ctx) 315 | } 316 | } 317 | -------------------------------------------------------------------------------- /handlebars/blocks_test.go: -------------------------------------------------------------------------------- 1 | package handlebars 2 | 3 | import "testing" 4 | 5 | // 6 | // Those tests come from: 7 | // https://github.com/wycats/handlebars.js/blob/master/spec/blocks.js 8 | // 9 | var blocksTests = []Test{ 10 | { 11 | "array (1) - Arrays iterate over the contents when not empty", 12 | "{{#goodbyes}}{{text}}! {{/goodbyes}}cruel {{world}}!", 13 | map[string]interface{}{"goodbyes": []map[string]string{{"text": "goodbye"}, {"text": "Goodbye"}, {"text": "GOODBYE"}}, "world": "world"}, 14 | nil, nil, nil, 15 | "goodbye! Goodbye! GOODBYE! cruel world!", 16 | }, 17 | { 18 | "array (2) - Arrays ignore the contents when empty", 19 | "{{#goodbyes}}{{text}}! {{/goodbyes}}cruel {{world}}!", 20 | map[string]interface{}{"goodbyes": []map[string]string{}, "world": "world"}, 21 | nil, nil, nil, 22 | "cruel world!", 23 | }, 24 | { 25 | "array without data", 26 | "{{#goodbyes}}{{text}}{{/goodbyes}} {{#goodbyes}}{{text}}{{/goodbyes}}", 27 | map[string]interface{}{"goodbyes": []map[string]string{{"text": "goodbye"}, {"text": "Goodbye"}, {"text": "GOODBYE"}}, "world": "world"}, 28 | nil, nil, nil, 29 | "goodbyeGoodbyeGOODBYE goodbyeGoodbyeGOODBYE", 30 | }, 31 | { 32 | "array with @index - The @index variable is used", 33 | "{{#goodbyes}}{{@index}}. {{text}}! {{/goodbyes}}cruel {{world}}!", 34 | map[string]interface{}{"goodbyes": []map[string]string{{"text": "goodbye"}, {"text": "Goodbye"}, {"text": "GOODBYE"}}, "world": "world"}, 35 | nil, nil, nil, 36 | "0. goodbye! 1. Goodbye! 2. GOODBYE! cruel world!", 37 | }, 38 | { 39 | "empty block (1) - Arrays iterate over the contents when not empty", 40 | "{{#goodbyes}}{{/goodbyes}}cruel {{world}}!", 41 | map[string]interface{}{"goodbyes": []map[string]string{{"text": "goodbye"}, {"text": "Goodbye"}, {"text": "GOODBYE"}}, "world": "world"}, 42 | nil, nil, nil, 43 | "cruel world!", 44 | }, 45 | { 46 | "empty block (1) - Arrays ignore the contents when empty", 47 | "{{#goodbyes}}{{/goodbyes}}cruel {{world}}!", 48 | map[string]interface{}{"goodbyes": []map[string]string{}, "world": "world"}, 49 | nil, nil, nil, 50 | "cruel world!", 51 | }, 52 | { 53 | "block with complex lookup - Templates can access variables in contexts up the stack with relative path syntax", 54 | "{{#goodbyes}}{{text}} cruel {{../name}}! {{/goodbyes}}", 55 | map[string]interface{}{"goodbyes": []map[string]string{{"text": "goodbye"}, {"text": "Goodbye"}, {"text": "GOODBYE"}}, "name": "Alan"}, 56 | nil, nil, nil, 57 | "goodbye cruel Alan! Goodbye cruel Alan! GOODBYE cruel Alan! ", 58 | }, 59 | { 60 | "multiple blocks with complex lookup", 61 | "{{#goodbyes}}{{../name}}{{../name}}{{/goodbyes}}", 62 | map[string]interface{}{"goodbyes": []map[string]string{{"text": "goodbye"}, {"text": "Goodbye"}, {"text": "GOODBYE"}}, "name": "Alan"}, 63 | nil, nil, nil, 64 | "AlanAlanAlanAlanAlanAlan", 65 | }, 66 | 67 | // @todo "{{#goodbyes}}{{text}} cruel {{foo/../name}}! {{/goodbyes}}" should throw error 68 | 69 | { 70 | "block with deep nested complex lookup", 71 | "{{#outer}}Goodbye {{#inner}}cruel {{../sibling}} {{../../omg}}{{/inner}}{{/outer}}", 72 | map[string]interface{}{"omg": "OMG!", "outer": []map[string]interface{}{{"sibling": "sad", "inner": []map[string]string{{"text": "goodbye"}}}}}, 73 | nil, nil, nil, 74 | "Goodbye cruel sad OMG!", 75 | }, 76 | { 77 | "inverted sections with unset value - Inverted section rendered when value isn't set.", 78 | "{{#goodbyes}}{{this}}{{/goodbyes}}{{^goodbyes}}Right On!{{/goodbyes}}", 79 | map[string]interface{}{}, 80 | nil, nil, nil, 81 | "Right On!", 82 | }, 83 | { 84 | "inverted sections with false value - Inverted section rendered when value is false.", 85 | "{{#goodbyes}}{{this}}{{/goodbyes}}{{^goodbyes}}Right On!{{/goodbyes}}", 86 | map[string]interface{}{"goodbyes": false}, 87 | nil, nil, nil, 88 | "Right On!", 89 | }, 90 | { 91 | "inverted section with empty set - Inverted section rendered when value is empty set.", 92 | "{{#goodbyes}}{{this}}{{/goodbyes}}{{^goodbyes}}Right On!{{/goodbyes}}", 93 | map[string]interface{}{"goodbyes": []interface{}{}}, 94 | nil, nil, nil, 95 | "Right On!", 96 | }, 97 | { 98 | "block inverted sections", 99 | "{{#people}}{{name}}{{^}}{{none}}{{/people}}", 100 | map[string]interface{}{"none": "No people"}, 101 | nil, nil, nil, 102 | "No people", 103 | }, 104 | { 105 | "chained inverted sections (1)", 106 | "{{#people}}{{name}}{{else if none}}{{none}}{{/people}}", 107 | map[string]interface{}{"none": "No people"}, 108 | nil, nil, nil, 109 | "No people", 110 | }, 111 | { 112 | "chained inverted sections (2)", 113 | "{{#people}}{{name}}{{else if nothere}}fail{{else unless nothere}}{{none}}{{/people}}", 114 | map[string]interface{}{"none": "No people"}, 115 | nil, nil, nil, 116 | "No people", 117 | }, 118 | { 119 | "chained inverted sections (3)", 120 | "{{#people}}{{name}}{{else if none}}{{none}}{{else}}fail{{/people}}", 121 | map[string]interface{}{"none": "No people"}, 122 | nil, nil, nil, 123 | "No people", 124 | }, 125 | 126 | // @todo "{{#people}}{{name}}{{else if none}}{{none}}{{/if}}" should throw error 127 | 128 | { 129 | "block inverted sections with empty arrays", 130 | "{{#people}}{{name}}{{^}}{{none}}{{/people}}", 131 | map[string]interface{}{"none": "No people", "people": map[string]interface{}{}}, 132 | nil, nil, nil, 133 | "No people", 134 | }, 135 | { 136 | "block standalone else sections (1)", 137 | "{{#people}}\n{{name}}\n{{^}}\n{{none}}\n{{/people}}\n", 138 | map[string]interface{}{"none": "No people"}, 139 | nil, nil, nil, 140 | "No people\n", 141 | }, 142 | { 143 | "block standalone else sections (2)", 144 | "{{#none}}\n{{.}}\n{{^}}\n{{none}}\n{{/none}}\n", 145 | map[string]interface{}{"none": "No people"}, 146 | nil, nil, nil, 147 | "No people\n", 148 | }, 149 | { 150 | "block standalone else sections (3)", 151 | "{{#people}}\n{{name}}\n{{^}}\n{{none}}\n{{/people}}\n", 152 | map[string]interface{}{"none": "No people"}, 153 | nil, nil, nil, 154 | "No people\n", 155 | }, 156 | { 157 | "block standalone chained else sections (1)", 158 | "{{#people}}\n{{name}}\n{{else if none}}\n{{none}}\n{{/people}}\n", 159 | map[string]interface{}{"none": "No people"}, 160 | nil, nil, nil, 161 | "No people\n", 162 | }, 163 | { 164 | "block standalone chained else sections (2)", 165 | "{{#people}}\n{{name}}\n{{else if none}}\n{{none}}\n{{^}}\n{{/people}}\n", 166 | map[string]interface{}{"none": "No people"}, 167 | nil, nil, nil, 168 | "No people\n", 169 | }, 170 | { 171 | "should handle nesting", 172 | "{{#data}}\n{{#if true}}\n{{.}}\n{{/if}}\n{{/data}}\nOK.", 173 | map[string]interface{}{"data": []int{1, 3, 5}}, 174 | nil, nil, nil, 175 | "1\n3\n5\nOK.", 176 | }, 177 | // // @todo compat mode 178 | // { 179 | // "block with deep recursive lookup lookup", 180 | // "{{#outer}}Goodbye {{#inner}}cruel {{omg}}{{/inner}}{{/outer}}", 181 | // map[string]interface{}{"omg": "OMG!", "outer": []map[string]interface{}{{"inner": []map[string]string{{"text": "goodbye"}}}}}, 182 | // nil, 183 | // nil, 184 | // nil, 185 | // "Goodbye cruel OMG!", 186 | // }, 187 | // // @todo compat mode 188 | // { 189 | // "block with deep recursive pathed lookup", 190 | // "{{#outer}}Goodbye {{#inner}}cruel {{omg.yes}}{{/inner}}{{/outer}}", 191 | // map[string]interface{}{"omg": map[string]string{"yes": "OMG!"}, "outer": []map[string]interface{}{{"inner": []map[string]string{{"yes": "no", "text": "goodbye"}}}}}, 192 | // nil, 193 | // nil, 194 | // nil, 195 | // "Goodbye cruel OMG!", 196 | // }, 197 | { 198 | "block with missed recursive lookup", 199 | "{{#outer}}Goodbye {{#inner}}cruel {{omg.yes}}{{/inner}}{{/outer}}", 200 | map[string]interface{}{"omg": map[string]string{"no": "OMG!"}, "outer": []map[string]interface{}{{"inner": []map[string]string{{"yes": "no", "text": "goodbye"}}}}}, 201 | nil, nil, nil, 202 | "Goodbye cruel ", 203 | }, 204 | } 205 | 206 | func TestBlocks(t *testing.T) { 207 | launchTests(t, blocksTests) 208 | } 209 | -------------------------------------------------------------------------------- /mustache/specs/interpolation.yml: -------------------------------------------------------------------------------- 1 | overview: | 2 | Interpolation tags are used to integrate dynamic content into the template. 3 | 4 | The tag's content MUST be a non-whitespace character sequence NOT containing 5 | the current closing delimiter. 6 | 7 | This tag's content names the data to replace the tag. A single period (`.`) 8 | indicates that the item currently sitting atop the context stack should be 9 | used; otherwise, name resolution is as follows: 10 | 1) Split the name on periods; the first part is the name to resolve, any 11 | remaining parts should be retained. 12 | 2) Walk the context stack from top to bottom, finding the first context 13 | that is a) a hash containing the name as a key OR b) an object responding 14 | to a method with the given name. 15 | 3) If the context is a hash, the data is the value associated with the 16 | name. 17 | 4) If the context is an object, the data is the value returned by the 18 | method with the given name. 19 | 5) If any name parts were retained in step 1, each should be resolved 20 | against a context stack containing only the result from the former 21 | resolution. If any part fails resolution, the result should be considered 22 | falsey, and should interpolate as the empty string. 23 | Data should be coerced into a string (and escaped, if appropriate) before 24 | interpolation. 25 | 26 | The Interpolation tags MUST NOT be treated as standalone. 27 | tests: 28 | - name: No Interpolation 29 | desc: Mustache-free templates should render as-is. 30 | data: { } 31 | template: | 32 | Hello from {Mustache}! 33 | expected: | 34 | Hello from {Mustache}! 35 | 36 | - name: Basic Interpolation 37 | desc: Unadorned tags should interpolate content into the template. 38 | data: { subject: "world" } 39 | template: | 40 | Hello, {{subject}}! 41 | expected: | 42 | Hello, world! 43 | 44 | - name: HTML Escaping 45 | desc: Basic interpolation should be HTML escaped. 46 | data: { forbidden: '& " < >' } 47 | template: | 48 | These characters should be HTML escaped: {{forbidden}} 49 | expected: | 50 | These characters should be HTML escaped: & " < > 51 | 52 | - name: Triple Mustache 53 | desc: Triple mustaches should interpolate without HTML escaping. 54 | data: { forbidden: '& " < >' } 55 | template: | 56 | These characters should not be HTML escaped: {{{forbidden}}} 57 | expected: | 58 | These characters should not be HTML escaped: & " < > 59 | 60 | - name: Ampersand 61 | desc: Ampersand should interpolate without HTML escaping. 62 | data: { forbidden: '& " < >' } 63 | template: | 64 | These characters should not be HTML escaped: {{&forbidden}} 65 | expected: | 66 | These characters should not be HTML escaped: & " < > 67 | 68 | - name: Basic Integer Interpolation 69 | desc: Integers should interpolate seamlessly. 70 | data: { mph: 85 } 71 | template: '"{{mph}} miles an hour!"' 72 | expected: '"85 miles an hour!"' 73 | 74 | - name: Triple Mustache Integer Interpolation 75 | desc: Integers should interpolate seamlessly. 76 | data: { mph: 85 } 77 | template: '"{{{mph}}} miles an hour!"' 78 | expected: '"85 miles an hour!"' 79 | 80 | - name: Ampersand Integer Interpolation 81 | desc: Integers should interpolate seamlessly. 82 | data: { mph: 85 } 83 | template: '"{{&mph}} miles an hour!"' 84 | expected: '"85 miles an hour!"' 85 | 86 | - name: Basic Decimal Interpolation 87 | desc: Decimals should interpolate seamlessly with proper significance. 88 | data: { power: 1.210 } 89 | template: '"{{power}} jiggawatts!"' 90 | expected: '"1.21 jiggawatts!"' 91 | 92 | - name: Triple Mustache Decimal Interpolation 93 | desc: Decimals should interpolate seamlessly with proper significance. 94 | data: { power: 1.210 } 95 | template: '"{{{power}}} jiggawatts!"' 96 | expected: '"1.21 jiggawatts!"' 97 | 98 | - name: Ampersand Decimal Interpolation 99 | desc: Decimals should interpolate seamlessly with proper significance. 100 | data: { power: 1.210 } 101 | template: '"{{&power}} jiggawatts!"' 102 | expected: '"1.21 jiggawatts!"' 103 | 104 | # Context Misses 105 | 106 | - name: Basic Context Miss Interpolation 107 | desc: Failed context lookups should default to empty strings. 108 | data: { } 109 | template: "I ({{cannot}}) be seen!" 110 | expected: "I () be seen!" 111 | 112 | - name: Triple Mustache Context Miss Interpolation 113 | desc: Failed context lookups should default to empty strings. 114 | data: { } 115 | template: "I ({{{cannot}}}) be seen!" 116 | expected: "I () be seen!" 117 | 118 | - name: Ampersand Context Miss Interpolation 119 | desc: Failed context lookups should default to empty strings. 120 | data: { } 121 | template: "I ({{&cannot}}) be seen!" 122 | expected: "I () be seen!" 123 | 124 | # Dotted Names 125 | 126 | - name: Dotted Names - Basic Interpolation 127 | desc: Dotted names should be considered a form of shorthand for sections. 128 | data: { person: { name: 'Joe' } } 129 | template: '"{{person.name}}" == "{{#person}}{{name}}{{/person}}"' 130 | expected: '"Joe" == "Joe"' 131 | 132 | - name: Dotted Names - Triple Mustache Interpolation 133 | desc: Dotted names should be considered a form of shorthand for sections. 134 | data: { person: { name: 'Joe' } } 135 | template: '"{{{person.name}}}" == "{{#person}}{{{name}}}{{/person}}"' 136 | expected: '"Joe" == "Joe"' 137 | 138 | - name: Dotted Names - Ampersand Interpolation 139 | desc: Dotted names should be considered a form of shorthand for sections. 140 | data: { person: { name: 'Joe' } } 141 | template: '"{{&person.name}}" == "{{#person}}{{&name}}{{/person}}"' 142 | expected: '"Joe" == "Joe"' 143 | 144 | - name: Dotted Names - Arbitrary Depth 145 | desc: Dotted names should be functional to any level of nesting. 146 | data: 147 | a: { b: { c: { d: { e: { name: 'Phil' } } } } } 148 | template: '"{{a.b.c.d.e.name}}" == "Phil"' 149 | expected: '"Phil" == "Phil"' 150 | 151 | - name: Dotted Names - Broken Chains 152 | desc: Any falsey value prior to the last part of the name should yield ''. 153 | data: 154 | a: { } 155 | template: '"{{a.b.c}}" == ""' 156 | expected: '"" == ""' 157 | 158 | - name: Dotted Names - Broken Chain Resolution 159 | desc: Each part of a dotted name should resolve only against its parent. 160 | data: 161 | a: { b: { } } 162 | c: { name: 'Jim' } 163 | template: '"{{a.b.c.name}}" == ""' 164 | expected: '"" == ""' 165 | 166 | - name: Dotted Names - Initial Resolution 167 | desc: The first part of a dotted name should resolve as any other name. 168 | data: 169 | a: { b: { c: { d: { e: { name: 'Phil' } } } } } 170 | b: { c: { d: { e: { name: 'Wrong' } } } } 171 | template: '"{{#a}}{{b.c.d.e.name}}{{/a}}" == "Phil"' 172 | expected: '"Phil" == "Phil"' 173 | 174 | - name: Dotted Names - Context Precedence 175 | desc: Dotted names should be resolved against former resolutions. 176 | data: 177 | a: { b: { } } 178 | b: { c: 'ERROR' } 179 | template: '{{#a}}{{b.c}}{{/a}}' 180 | expected: '' 181 | 182 | # Whitespace Sensitivity 183 | 184 | - name: Interpolation - Surrounding Whitespace 185 | desc: Interpolation should not alter surrounding whitespace. 186 | data: { string: '---' } 187 | template: '| {{string}} |' 188 | expected: '| --- |' 189 | 190 | - name: Triple Mustache - Surrounding Whitespace 191 | desc: Interpolation should not alter surrounding whitespace. 192 | data: { string: '---' } 193 | template: '| {{{string}}} |' 194 | expected: '| --- |' 195 | 196 | - name: Ampersand - Surrounding Whitespace 197 | desc: Interpolation should not alter surrounding whitespace. 198 | data: { string: '---' } 199 | template: '| {{&string}} |' 200 | expected: '| --- |' 201 | 202 | - name: Interpolation - Standalone 203 | desc: Standalone interpolation should not alter surrounding whitespace. 204 | data: { string: '---' } 205 | template: " {{string}}\n" 206 | expected: " ---\n" 207 | 208 | - name: Triple Mustache - Standalone 209 | desc: Standalone interpolation should not alter surrounding whitespace. 210 | data: { string: '---' } 211 | template: " {{{string}}}\n" 212 | expected: " ---\n" 213 | 214 | - name: Ampersand - Standalone 215 | desc: Standalone interpolation should not alter surrounding whitespace. 216 | data: { string: '---' } 217 | template: " {{&string}}\n" 218 | expected: " ---\n" 219 | 220 | # Whitespace Insensitivity 221 | 222 | - name: Interpolation With Padding 223 | desc: Superfluous in-tag whitespace should be ignored. 224 | data: { string: "---" } 225 | template: '|{{ string }}|' 226 | expected: '|---|' 227 | 228 | - name: Triple Mustache With Padding 229 | desc: Superfluous in-tag whitespace should be ignored. 230 | data: { string: "---" } 231 | template: '|{{{ string }}}|' 232 | expected: '|---|' 233 | 234 | - name: Ampersand With Padding 235 | desc: Superfluous in-tag whitespace should be ignored. 236 | data: { string: "---" } 237 | template: '|{{& string }}|' 238 | expected: '|---|' 239 | -------------------------------------------------------------------------------- /mustache/specs/sections.yml: -------------------------------------------------------------------------------- 1 | overview: | 2 | Section tags and End Section tags are used in combination to wrap a section 3 | of the template for iteration 4 | 5 | These tags' content MUST be a non-whitespace character sequence NOT 6 | containing the current closing delimiter; each Section tag MUST be followed 7 | by an End Section tag with the same content within the same section. 8 | 9 | This tag's content names the data to replace the tag. Name resolution is as 10 | follows: 11 | 1) Split the name on periods; the first part is the name to resolve, any 12 | remaining parts should be retained. 13 | 2) Walk the context stack from top to bottom, finding the first context 14 | that is a) a hash containing the name as a key OR b) an object responding 15 | to a method with the given name. 16 | 3) If the context is a hash, the data is the value associated with the 17 | name. 18 | 4) If the context is an object and the method with the given name has an 19 | arity of 1, the method SHOULD be called with a String containing the 20 | unprocessed contents of the sections; the data is the value returned. 21 | 5) Otherwise, the data is the value returned by calling the method with 22 | the given name. 23 | 6) If any name parts were retained in step 1, each should be resolved 24 | against a context stack containing only the result from the former 25 | resolution. If any part fails resolution, the result should be considered 26 | falsey, and should interpolate as the empty string. 27 | If the data is not of a list type, it is coerced into a list as follows: if 28 | the data is truthy (e.g. `!!data == true`), use a single-element list 29 | containing the data, otherwise use an empty list. 30 | 31 | For each element in the data list, the element MUST be pushed onto the 32 | context stack, the section MUST be rendered, and the element MUST be popped 33 | off the context stack. 34 | 35 | Section and End Section tags SHOULD be treated as standalone when 36 | appropriate. 37 | tests: 38 | - name: Truthy 39 | desc: Truthy sections should have their contents rendered. 40 | data: { boolean: true } 41 | template: '"{{#boolean}}This should be rendered.{{/boolean}}"' 42 | expected: '"This should be rendered."' 43 | 44 | - name: Falsey 45 | desc: Falsey sections should have their contents omitted. 46 | data: { boolean: false } 47 | template: '"{{#boolean}}This should not be rendered.{{/boolean}}"' 48 | expected: '""' 49 | 50 | - name: Context 51 | desc: Objects and hashes should be pushed onto the context stack. 52 | data: { context: { name: 'Joe' } } 53 | template: '"{{#context}}Hi {{name}}.{{/context}}"' 54 | expected: '"Hi Joe."' 55 | 56 | - name: Deeply Nested Contexts 57 | desc: All elements on the context stack should be accessible. 58 | data: 59 | a: { one: 1 } 60 | b: { two: 2 } 61 | c: { three: 3 } 62 | d: { four: 4 } 63 | e: { five: 5 } 64 | template: | 65 | {{#a}} 66 | {{one}} 67 | {{#b}} 68 | {{one}}{{two}}{{one}} 69 | {{#c}} 70 | {{one}}{{two}}{{three}}{{two}}{{one}} 71 | {{#d}} 72 | {{one}}{{two}}{{three}}{{four}}{{three}}{{two}}{{one}} 73 | {{#e}} 74 | {{one}}{{two}}{{three}}{{four}}{{five}}{{four}}{{three}}{{two}}{{one}} 75 | {{/e}} 76 | {{one}}{{two}}{{three}}{{four}}{{three}}{{two}}{{one}} 77 | {{/d}} 78 | {{one}}{{two}}{{three}}{{two}}{{one}} 79 | {{/c}} 80 | {{one}}{{two}}{{one}} 81 | {{/b}} 82 | {{one}} 83 | {{/a}} 84 | expected: | 85 | 1 86 | 121 87 | 12321 88 | 1234321 89 | 123454321 90 | 1234321 91 | 12321 92 | 121 93 | 1 94 | 95 | - name: List 96 | desc: Lists should be iterated; list items should visit the context stack. 97 | data: { list: [ { item: 1 }, { item: 2 }, { item: 3 } ] } 98 | template: '"{{#list}}{{item}}{{/list}}"' 99 | expected: '"123"' 100 | 101 | - name: Empty List 102 | desc: Empty lists should behave like falsey values. 103 | data: { list: [ ] } 104 | template: '"{{#list}}Yay lists!{{/list}}"' 105 | expected: '""' 106 | 107 | - name: Doubled 108 | desc: Multiple sections per template should be permitted. 109 | data: { bool: true, two: 'second' } 110 | template: | 111 | {{#bool}} 112 | * first 113 | {{/bool}} 114 | * {{two}} 115 | {{#bool}} 116 | * third 117 | {{/bool}} 118 | expected: | 119 | * first 120 | * second 121 | * third 122 | 123 | - name: Nested (Truthy) 124 | desc: Nested truthy sections should have their contents rendered. 125 | data: { bool: true } 126 | template: "| A {{#bool}}B {{#bool}}C{{/bool}} D{{/bool}} E |" 127 | expected: "| A B C D E |" 128 | 129 | - name: Nested (Falsey) 130 | desc: Nested falsey sections should be omitted. 131 | data: { bool: false } 132 | template: "| A {{#bool}}B {{#bool}}C{{/bool}} D{{/bool}} E |" 133 | expected: "| A E |" 134 | 135 | - name: Context Misses 136 | desc: Failed context lookups should be considered falsey. 137 | data: { } 138 | template: "[{{#missing}}Found key 'missing'!{{/missing}}]" 139 | expected: "[]" 140 | 141 | # Implicit Iterators 142 | 143 | - name: Implicit Iterator - String 144 | desc: Implicit iterators should directly interpolate strings. 145 | data: 146 | list: [ 'a', 'b', 'c', 'd', 'e' ] 147 | template: '"{{#list}}({{.}}){{/list}}"' 148 | expected: '"(a)(b)(c)(d)(e)"' 149 | 150 | - name: Implicit Iterator - Integer 151 | desc: Implicit iterators should cast integers to strings and interpolate. 152 | data: 153 | list: [ 1, 2, 3, 4, 5 ] 154 | template: '"{{#list}}({{.}}){{/list}}"' 155 | expected: '"(1)(2)(3)(4)(5)"' 156 | 157 | - name: Implicit Iterator - Decimal 158 | desc: Implicit iterators should cast decimals to strings and interpolate. 159 | data: 160 | list: [ 1.10, 2.20, 3.30, 4.40, 5.50 ] 161 | template: '"{{#list}}({{.}}){{/list}}"' 162 | expected: '"(1.1)(2.2)(3.3)(4.4)(5.5)"' 163 | 164 | - name: Implicit Iterator - Array 165 | desc: Implicit iterators should allow iterating over nested arrays. 166 | data: 167 | list: [ [1, 2, 3], ['a', 'b', 'c'] ] 168 | template: '"{{#list}}({{#.}}{{.}}{{/.}}){{/list}}"' 169 | expected: '"(123)(abc)"' 170 | 171 | # Dotted Names 172 | 173 | - name: Dotted Names - Truthy 174 | desc: Dotted names should be valid for Section tags. 175 | data: { a: { b: { c: true } } } 176 | template: '"{{#a.b.c}}Here{{/a.b.c}}" == "Here"' 177 | expected: '"Here" == "Here"' 178 | 179 | - name: Dotted Names - Falsey 180 | desc: Dotted names should be valid for Section tags. 181 | data: { a: { b: { c: false } } } 182 | template: '"{{#a.b.c}}Here{{/a.b.c}}" == ""' 183 | expected: '"" == ""' 184 | 185 | - name: Dotted Names - Broken Chains 186 | desc: Dotted names that cannot be resolved should be considered falsey. 187 | data: { a: { } } 188 | template: '"{{#a.b.c}}Here{{/a.b.c}}" == ""' 189 | expected: '"" == ""' 190 | 191 | # Whitespace Sensitivity 192 | 193 | - name: Surrounding Whitespace 194 | desc: Sections should not alter surrounding whitespace. 195 | data: { boolean: true } 196 | template: " | {{#boolean}}\t|\t{{/boolean}} | \n" 197 | expected: " | \t|\t | \n" 198 | 199 | - name: Internal Whitespace 200 | desc: Sections should not alter internal whitespace. 201 | data: { boolean: true } 202 | template: " | {{#boolean}} {{! Important Whitespace }}\n {{/boolean}} | \n" 203 | expected: " | \n | \n" 204 | 205 | - name: Indented Inline Sections 206 | desc: Single-line sections should not alter surrounding whitespace. 207 | data: { boolean: true } 208 | template: " {{#boolean}}YES{{/boolean}}\n {{#boolean}}GOOD{{/boolean}}\n" 209 | expected: " YES\n GOOD\n" 210 | 211 | - name: Standalone Lines 212 | desc: Standalone lines should be removed from the template. 213 | data: { boolean: true } 214 | template: | 215 | | This Is 216 | {{#boolean}} 217 | | 218 | {{/boolean}} 219 | | A Line 220 | expected: | 221 | | This Is 222 | | 223 | | A Line 224 | 225 | - name: Indented Standalone Lines 226 | desc: Indented standalone lines should be removed from the template. 227 | data: { boolean: true } 228 | template: | 229 | | This Is 230 | {{#boolean}} 231 | | 232 | {{/boolean}} 233 | | A Line 234 | expected: | 235 | | This Is 236 | | 237 | | A Line 238 | 239 | - name: Standalone Line Endings 240 | desc: '"\r\n" should be considered a newline for standalone tags.' 241 | data: { boolean: true } 242 | template: "|\r\n{{#boolean}}\r\n{{/boolean}}\r\n|" 243 | expected: "|\r\n|" 244 | 245 | - name: Standalone Without Previous Line 246 | desc: Standalone tags should not require a newline to precede them. 247 | data: { boolean: true } 248 | template: " {{#boolean}}\n#{{/boolean}}\n/" 249 | expected: "#\n/" 250 | 251 | - name: Standalone Without Newline 252 | desc: Standalone tags should not require a newline to follow them. 253 | data: { boolean: true } 254 | template: "#{{#boolean}}\n/\n {{/boolean}}" 255 | expected: "#\n/\n" 256 | 257 | # Whitespace Insensitivity 258 | 259 | - name: Padding 260 | desc: Superfluous in-tag whitespace should be ignored. 261 | data: { boolean: true } 262 | template: '|{{# boolean }}={{/ boolean }}|' 263 | expected: '|=|' 264 | -------------------------------------------------------------------------------- /handlebars/data_test.go: -------------------------------------------------------------------------------- 1 | package handlebars 2 | 3 | import ( 4 | "testing" 5 | 6 | "github.com/mailgun/raymond/v2" 7 | ) 8 | 9 | // 10 | // Those tests come from: 11 | // https://github.com/wycats/handlebars.js/blob/master/spec/data.js 12 | // 13 | var dataTests = []Test{ 14 | { 15 | "passing in data to a compiled function that expects data - works with helpers", 16 | "{{hello}}", 17 | map[string]string{"noun": "cat"}, 18 | map[string]interface{}{"adjective": "happy"}, 19 | map[string]interface{}{"hello": func(options *raymond.Options) string { 20 | return options.DataStr("adjective") + " " + options.ValueStr("noun") 21 | }}, 22 | nil, 23 | "happy cat", 24 | }, 25 | { 26 | "data can be looked up via @foo", 27 | "{{@hello}}", 28 | nil, 29 | map[string]interface{}{"hello": "hello"}, 30 | nil, nil, 31 | "hello", 32 | }, 33 | { 34 | "deep @foo triggers automatic top-level data", 35 | `{{#let world="world"}}{{#if foo}}{{#if foo}}Hello {{@world}}{{/if}}{{/if}}{{/let}}`, 36 | map[string]bool{"foo": true}, 37 | map[string]interface{}{"hello": "hello"}, 38 | map[string]interface{}{"let": func(options *raymond.Options) string { 39 | frame := options.NewDataFrame() 40 | 41 | for k, v := range options.Hash() { 42 | frame.Set(k, v) 43 | } 44 | 45 | return options.FnData(frame) 46 | }}, 47 | nil, 48 | "Hello world", 49 | }, 50 | { 51 | "parameter data can be looked up via @foo", 52 | `{{hello @world}}`, 53 | nil, 54 | map[string]interface{}{"world": "world"}, 55 | map[string]interface{}{"hello": func(context string) string { 56 | return "Hello " + context 57 | }}, 58 | nil, 59 | "Hello world", 60 | }, 61 | { 62 | "hash values can be looked up via @foo", 63 | `{{hello noun=@world}}`, 64 | nil, 65 | map[string]interface{}{"world": "world"}, 66 | map[string]interface{}{"hello": func(options *raymond.Options) string { 67 | return "Hello " + options.HashStr("noun") 68 | }}, 69 | nil, 70 | "Hello world", 71 | }, 72 | { 73 | "nested parameter data can be looked up via @foo.bar", 74 | `{{hello @world.bar}}`, 75 | nil, 76 | map[string]interface{}{"world": map[string]string{"bar": "world"}}, 77 | map[string]interface{}{"hello": func(context string) string { 78 | return "Hello " + context 79 | }}, 80 | nil, 81 | "Hello world", 82 | }, 83 | { 84 | "nested parameter data does not fail with @world.bar", 85 | `{{hello @world.bar}}`, 86 | nil, 87 | map[string]interface{}{"foo": map[string]string{"bar": "world"}}, 88 | map[string]interface{}{"hello": func(context string) string { 89 | return "Hello " + context 90 | }}, 91 | nil, 92 | // @todo Test differs with JS implementation: we don't output `undefined` 93 | "Hello ", 94 | }, 95 | 96 | // @todo "parameter data throws when using complex scope references", 97 | 98 | { 99 | "data can be functions", 100 | `{{@hello}}`, 101 | nil, 102 | map[string]interface{}{"hello": func() string { return "hello" }}, 103 | nil, nil, 104 | "hello", 105 | }, 106 | { 107 | "data can be functions with params", 108 | `{{@hello "hello"}}`, 109 | nil, 110 | map[string]interface{}{"hello": func(context string) string { return context }}, 111 | nil, nil, 112 | "hello", 113 | }, 114 | 115 | { 116 | "data is inherited downstream", 117 | `{{#let foo=1 bar=2}}{{#let foo=bar.baz}}{{@bar}}{{@foo}}{{/let}}{{@foo}}{{/let}}`, 118 | map[string]map[string]string{"bar": {"baz": "hello world"}}, 119 | nil, 120 | map[string]interface{}{"let": func(options *raymond.Options) string { 121 | frame := options.NewDataFrame() 122 | 123 | for k, v := range options.Hash() { 124 | frame.Set(k, v) 125 | } 126 | 127 | return options.FnData(frame) 128 | }}, 129 | nil, 130 | "2hello world1", 131 | }, 132 | { 133 | "passing in data to a compiled function that expects data - works with helpers in partials", 134 | `{{>myPartial}}`, 135 | map[string]string{"noun": "cat"}, 136 | map[string]interface{}{"adjective": "happy"}, 137 | map[string]interface{}{"hello": func(options *raymond.Options) string { 138 | return options.DataStr("adjective") + " " + options.ValueStr("noun") 139 | }}, 140 | map[string]string{ 141 | "myPartial": "{{hello}}", 142 | }, 143 | "happy cat", 144 | }, 145 | { 146 | "passing in data to a compiled function that expects data - works with helpers and parameters", 147 | `{{hello world}}`, 148 | map[string]interface{}{"exclaim": true, "world": "world"}, 149 | map[string]interface{}{"adjective": "happy"}, 150 | map[string]interface{}{"hello": func(context string, options *raymond.Options) string { 151 | str := "error" 152 | if b, ok := options.Value("exclaim").(bool); ok { 153 | if b { 154 | str = "!" 155 | } else { 156 | str = "" 157 | } 158 | } 159 | 160 | return options.DataStr("adjective") + " " + context + str 161 | }}, 162 | nil, 163 | "happy world!", 164 | }, 165 | { 166 | "passing in data to a compiled function that expects data - works with block helpers", 167 | `{{#hello}}{{world}}{{/hello}}`, 168 | map[string]bool{"exclaim": true}, 169 | map[string]interface{}{"adjective": "happy"}, 170 | map[string]interface{}{ 171 | "hello": func(options *raymond.Options) string { 172 | return options.Fn() 173 | }, 174 | "world": func(options *raymond.Options) string { 175 | str := "error" 176 | if b, ok := options.Value("exclaim").(bool); ok { 177 | if b { 178 | str = "!" 179 | } else { 180 | str = "" 181 | } 182 | } 183 | 184 | return options.DataStr("adjective") + " world" + str 185 | }, 186 | }, 187 | nil, 188 | "happy world!", 189 | }, 190 | { 191 | "passing in data to a compiled function that expects data - works with block helpers that use ..", 192 | `{{#hello}}{{world ../zomg}}{{/hello}}`, 193 | map[string]interface{}{"exclaim": true, "zomg": "world"}, 194 | map[string]interface{}{"adjective": "happy"}, 195 | map[string]interface{}{ 196 | "hello": func(options *raymond.Options) string { 197 | return options.FnWith(map[string]string{"exclaim": "?"}) 198 | }, 199 | "world": func(context string, options *raymond.Options) string { 200 | return options.DataStr("adjective") + " " + context + options.ValueStr("exclaim") 201 | }, 202 | }, 203 | nil, 204 | "happy world?", 205 | }, 206 | { 207 | "passing in data to a compiled function that expects data - data is passed to with block helpers where children use ..", 208 | `{{#hello}}{{world ../zomg}}{{/hello}}`, 209 | map[string]interface{}{"exclaim": true, "zomg": "world"}, 210 | map[string]interface{}{"adjective": "happy", "accessData": "#win"}, 211 | map[string]interface{}{ 212 | "hello": func(options *raymond.Options) string { 213 | return options.DataStr("accessData") + " " + options.FnWith(map[string]string{"exclaim": "?"}) 214 | }, 215 | "world": func(context string, options *raymond.Options) string { 216 | return options.DataStr("adjective") + " " + context + options.ValueStr("exclaim") 217 | }, 218 | }, 219 | nil, 220 | "#win happy world?", 221 | }, 222 | { 223 | "you can override inherited data when invoking a helper", 224 | `{{#hello}}{{world zomg}}{{/hello}}`, 225 | map[string]interface{}{"exclaim": true, "zomg": "planet"}, 226 | map[string]interface{}{"adjective": "happy"}, 227 | map[string]interface{}{ 228 | "hello": func(options *raymond.Options) string { 229 | ctx := map[string]string{"exclaim": "?", "zomg": "world"} 230 | data := options.NewDataFrame() 231 | data.Set("adjective", "sad") 232 | 233 | return options.FnCtxData(ctx, data) 234 | }, 235 | "world": func(context string, options *raymond.Options) string { 236 | return options.DataStr("adjective") + " " + context + options.ValueStr("exclaim") 237 | }, 238 | }, 239 | nil, 240 | "sad world?", 241 | }, 242 | { 243 | "you can override inherited data when invoking a helper with depth", 244 | `{{#hello}}{{world ../zomg}}{{/hello}}`, 245 | map[string]interface{}{"exclaim": true, "zomg": "world"}, 246 | map[string]interface{}{"adjective": "happy"}, 247 | map[string]interface{}{ 248 | "hello": func(options *raymond.Options) string { 249 | ctx := map[string]string{"exclaim": "?"} 250 | data := options.NewDataFrame() 251 | data.Set("adjective", "sad") 252 | 253 | return options.FnCtxData(ctx, data) 254 | }, 255 | "world": func(context string, options *raymond.Options) string { 256 | return options.DataStr("adjective") + " " + context + options.ValueStr("exclaim") 257 | }, 258 | }, 259 | nil, 260 | "sad world?", 261 | }, 262 | { 263 | "@root - the root context can be looked up via @root", 264 | `{{@root.foo}}`, 265 | map[string]interface{}{"foo": "hello"}, 266 | nil, nil, nil, 267 | "hello", 268 | }, 269 | { 270 | "@root - passed root values take priority", 271 | `{{@root.foo}}`, 272 | nil, 273 | map[string]interface{}{"root": map[string]string{"foo": "hello"}}, 274 | nil, nil, 275 | "hello", 276 | }, 277 | { 278 | "nesting - the root context can be looked up via @root", 279 | `{{#helper}}{{#helper}}{{@./depth}} {{@../depth}} {{@../../depth}}{{/helper}}{{/helper}}`, 280 | map[string]interface{}{"foo": "hello"}, 281 | map[string]interface{}{"depth": 0}, 282 | map[string]interface{}{ 283 | "helper": func(options *raymond.Options) string { 284 | data := options.NewDataFrame() 285 | 286 | if depth, ok := options.Data("depth").(int); ok { 287 | data.Set("depth", depth+1) 288 | } 289 | 290 | return options.FnData(data) 291 | }, 292 | }, 293 | nil, 294 | "2 1 0", 295 | }, 296 | } 297 | 298 | func TestData(t *testing.T) { 299 | launchTests(t, dataTests) 300 | } 301 | -------------------------------------------------------------------------------- /parser/whitespace.go: -------------------------------------------------------------------------------- 1 | package parser 2 | 3 | import ( 4 | "regexp" 5 | 6 | "github.com/mailgun/raymond/v2/ast" 7 | ) 8 | 9 | // whitespaceVisitor walks through the AST to perform whitespace control 10 | // 11 | // The logic was shamelessly borrowed from: 12 | // https://github.com/wycats/handlebars.js/blob/master/lib/handlebars/compiler/whitespace-control.js 13 | type whitespaceVisitor struct { 14 | isRootSeen bool 15 | } 16 | 17 | var ( 18 | rTrimLeft = regexp.MustCompile(`^[ \t]*\r?\n?`) 19 | rTrimLeftMultiple = regexp.MustCompile(`^\s+`) 20 | 21 | rTrimRight = regexp.MustCompile(`[ \t]+$`) 22 | rTrimRightMultiple = regexp.MustCompile(`\s+$`) 23 | 24 | rPrevWhitespace = regexp.MustCompile(`\r?\n\s*?$`) 25 | rPrevWhitespaceStart = regexp.MustCompile(`(^|\r?\n)\s*?$`) 26 | 27 | rNextWhitespace = regexp.MustCompile(`^\s*?\r?\n`) 28 | rNextWhitespaceEnd = regexp.MustCompile(`^\s*?(\r?\n|$)`) 29 | 30 | rPartialIndent = regexp.MustCompile(`([ \t]+$)`) 31 | ) 32 | 33 | // newWhitespaceVisitor instanciates a new whitespaceVisitor 34 | func newWhitespaceVisitor() *whitespaceVisitor { 35 | return &whitespaceVisitor{} 36 | } 37 | 38 | // processWhitespaces performs whitespace control on given AST 39 | // 40 | // WARNING: It must be called only once on AST. 41 | func processWhitespaces(node ast.Node) { 42 | node.Accept(newWhitespaceVisitor()) 43 | } 44 | 45 | func omitRightFirst(body []ast.Node, multiple bool) { 46 | omitRight(body, -1, multiple) 47 | } 48 | 49 | func omitRight(body []ast.Node, i int, multiple bool) { 50 | if i+1 >= len(body) { 51 | return 52 | } 53 | 54 | current := body[i+1] 55 | 56 | node, ok := current.(*ast.ContentStatement) 57 | if !ok { 58 | return 59 | } 60 | 61 | if !multiple && node.RightStripped { 62 | return 63 | } 64 | 65 | original := node.Value 66 | 67 | r := rTrimLeft 68 | if multiple { 69 | r = rTrimLeftMultiple 70 | } 71 | 72 | node.Value = r.ReplaceAllString(node.Value, "") 73 | 74 | node.RightStripped = (original != node.Value) 75 | } 76 | 77 | func omitLeftLast(body []ast.Node, multiple bool) { 78 | omitLeft(body, len(body), multiple) 79 | } 80 | 81 | func omitLeft(body []ast.Node, i int, multiple bool) bool { 82 | if i-1 < 0 { 83 | return false 84 | } 85 | 86 | current := body[i-1] 87 | 88 | node, ok := current.(*ast.ContentStatement) 89 | if !ok { 90 | return false 91 | } 92 | 93 | if !multiple && node.LeftStripped { 94 | return false 95 | } 96 | 97 | original := node.Value 98 | 99 | r := rTrimRight 100 | if multiple { 101 | r = rTrimRightMultiple 102 | } 103 | 104 | node.Value = r.ReplaceAllString(node.Value, "") 105 | 106 | node.LeftStripped = (original != node.Value) 107 | 108 | return node.LeftStripped 109 | } 110 | 111 | func isPrevWhitespace(body []ast.Node) bool { 112 | return isPrevWhitespaceProgram(body, len(body), false) 113 | } 114 | 115 | func isPrevWhitespaceProgram(body []ast.Node, i int, isRoot bool) bool { 116 | if i < 1 { 117 | return isRoot 118 | } 119 | 120 | prev := body[i-1] 121 | 122 | if node, ok := prev.(*ast.ContentStatement); ok { 123 | if (node.Value == "") && node.RightStripped { 124 | // already stripped, so it may be an empty string not catched by regexp 125 | return true 126 | } 127 | 128 | r := rPrevWhitespaceStart 129 | if (i > 1) || !isRoot { 130 | r = rPrevWhitespace 131 | } 132 | 133 | return r.MatchString(node.Value) 134 | } 135 | 136 | return false 137 | } 138 | 139 | func isNextWhitespace(body []ast.Node) bool { 140 | return isNextWhitespaceProgram(body, -1, false) 141 | } 142 | 143 | func isNextWhitespaceProgram(body []ast.Node, i int, isRoot bool) bool { 144 | if i+1 >= len(body) { 145 | return isRoot 146 | } 147 | 148 | next := body[i+1] 149 | 150 | if node, ok := next.(*ast.ContentStatement); ok { 151 | if (node.Value == "") && node.LeftStripped { 152 | // already stripped, so it may be an empty string not catched by regexp 153 | return true 154 | } 155 | 156 | r := rNextWhitespaceEnd 157 | if (i+2 > len(body)) || !isRoot { 158 | r = rNextWhitespace 159 | } 160 | 161 | return r.MatchString(node.Value) 162 | } 163 | 164 | return false 165 | } 166 | 167 | // 168 | // Visitor interface 169 | // 170 | 171 | func (v *whitespaceVisitor) VisitProgram(program *ast.Program) interface{} { 172 | isRoot := !v.isRootSeen 173 | v.isRootSeen = true 174 | 175 | body := program.Body 176 | for i, current := range body { 177 | strip, _ := current.Accept(v).(*ast.Strip) 178 | if strip == nil { 179 | continue 180 | } 181 | 182 | _isPrevWhitespace := isPrevWhitespaceProgram(body, i, isRoot) 183 | _isNextWhitespace := isNextWhitespaceProgram(body, i, isRoot) 184 | 185 | openStandalone := strip.OpenStandalone && _isPrevWhitespace 186 | closeStandalone := strip.CloseStandalone && _isNextWhitespace 187 | inlineStandalone := strip.InlineStandalone && _isPrevWhitespace && _isNextWhitespace 188 | 189 | if strip.Close { 190 | omitRight(body, i, true) 191 | } 192 | 193 | if strip.Open && (i > 0) { 194 | omitLeft(body, i, true) 195 | } 196 | 197 | if inlineStandalone { 198 | omitRight(body, i, false) 199 | 200 | if omitLeft(body, i, false) { 201 | // If we are on a standalone node, save the indent info for partials 202 | if partial, ok := current.(*ast.PartialStatement); ok { 203 | // Pull out the whitespace from the final line 204 | if i > 0 { 205 | if prevContent, ok := body[i-1].(*ast.ContentStatement); ok { 206 | partial.Indent = rPartialIndent.FindString(prevContent.Original) 207 | } 208 | } 209 | } 210 | } 211 | } 212 | 213 | if b, ok := current.(*ast.BlockStatement); ok { 214 | if openStandalone { 215 | prog := b.Program 216 | if prog == nil { 217 | prog = b.Inverse 218 | } 219 | 220 | omitRightFirst(prog.Body, false) 221 | 222 | // Strip out the previous content node if it's whitespace only 223 | omitLeft(body, i, false) 224 | } 225 | 226 | if closeStandalone { 227 | prog := b.Inverse 228 | if prog == nil { 229 | prog = b.Program 230 | } 231 | 232 | // Always strip the next node 233 | omitRight(body, i, false) 234 | 235 | omitLeftLast(prog.Body, false) 236 | } 237 | 238 | } 239 | } 240 | 241 | return nil 242 | } 243 | 244 | func (v *whitespaceVisitor) VisitBlock(block *ast.BlockStatement) interface{} { 245 | if block.Program != nil { 246 | block.Program.Accept(v) 247 | } 248 | 249 | if block.Inverse != nil { 250 | block.Inverse.Accept(v) 251 | } 252 | 253 | program := block.Program 254 | inverse := block.Inverse 255 | 256 | if program == nil { 257 | program = inverse 258 | inverse = nil 259 | } 260 | 261 | firstInverse := inverse 262 | lastInverse := inverse 263 | 264 | if (inverse != nil) && inverse.Chained { 265 | b, _ := inverse.Body[0].(*ast.BlockStatement) 266 | firstInverse = b.Program 267 | 268 | for lastInverse.Chained { 269 | b, _ := lastInverse.Body[len(lastInverse.Body)-1].(*ast.BlockStatement) 270 | lastInverse = b.Program 271 | } 272 | } 273 | 274 | closeProg := firstInverse 275 | if closeProg == nil { 276 | closeProg = program 277 | } 278 | 279 | strip := &ast.Strip{ 280 | Open: (block.OpenStrip != nil) && block.OpenStrip.Open, 281 | Close: (block.CloseStrip != nil) && block.CloseStrip.Close, 282 | 283 | OpenStandalone: isNextWhitespace(program.Body), 284 | CloseStandalone: isPrevWhitespace(closeProg.Body), 285 | } 286 | 287 | if (block.OpenStrip != nil) && block.OpenStrip.Close { 288 | omitRightFirst(program.Body, true) 289 | } 290 | 291 | if inverse != nil { 292 | if block.InverseStrip != nil { 293 | inverseStrip := block.InverseStrip 294 | 295 | if inverseStrip.Open { 296 | omitLeftLast(program.Body, true) 297 | } 298 | 299 | if inverseStrip.Close { 300 | omitRightFirst(firstInverse.Body, true) 301 | } 302 | } 303 | 304 | if (block.CloseStrip != nil) && block.CloseStrip.Open { 305 | omitLeftLast(lastInverse.Body, true) 306 | } 307 | 308 | // Find standalone else statements 309 | if isPrevWhitespace(program.Body) && isNextWhitespace(firstInverse.Body) { 310 | omitLeftLast(program.Body, false) 311 | 312 | omitRightFirst(firstInverse.Body, false) 313 | } 314 | } else if (block.CloseStrip != nil) && block.CloseStrip.Open { 315 | omitLeftLast(program.Body, true) 316 | } 317 | 318 | return strip 319 | } 320 | 321 | func (v *whitespaceVisitor) VisitMustache(mustache *ast.MustacheStatement) interface{} { 322 | return mustache.Strip 323 | } 324 | 325 | func _inlineStandalone(strip *ast.Strip) interface{} { 326 | return &ast.Strip{ 327 | Open: strip.Open, 328 | Close: strip.Close, 329 | InlineStandalone: true, 330 | } 331 | } 332 | 333 | func (v *whitespaceVisitor) VisitPartial(node *ast.PartialStatement) interface{} { 334 | strip := node.Strip 335 | if strip == nil { 336 | strip = &ast.Strip{} 337 | } 338 | 339 | return _inlineStandalone(strip) 340 | } 341 | 342 | func (v *whitespaceVisitor) VisitComment(node *ast.CommentStatement) interface{} { 343 | strip := node.Strip 344 | if strip == nil { 345 | strip = &ast.Strip{} 346 | } 347 | 348 | return _inlineStandalone(strip) 349 | } 350 | 351 | // NOOP 352 | func (v *whitespaceVisitor) VisitContent(node *ast.ContentStatement) interface{} { return nil } 353 | func (v *whitespaceVisitor) VisitExpression(node *ast.Expression) interface{} { return nil } 354 | func (v *whitespaceVisitor) VisitSubExpression(node *ast.SubExpression) interface{} { return nil } 355 | func (v *whitespaceVisitor) VisitPath(node *ast.PathExpression) interface{} { return nil } 356 | func (v *whitespaceVisitor) VisitString(node *ast.StringLiteral) interface{} { return nil } 357 | func (v *whitespaceVisitor) VisitBoolean(node *ast.BooleanLiteral) interface{} { return nil } 358 | func (v *whitespaceVisitor) VisitNumber(node *ast.NumberLiteral) interface{} { return nil } 359 | func (v *whitespaceVisitor) VisitHash(node *ast.Hash) interface{} { return nil } 360 | func (v *whitespaceVisitor) VisitHashPair(node *ast.HashPair) interface{} { return nil } 361 | --------------------------------------------------------------------------------