By {{author.FirstName}} {{Author.lastName}}
118 |{{Body}}
119 |
120 | Comments
121 | 122 | {{#each comments}} 123 |By {{Author.FirstName}} {{author.LastName}}
124 |{{body}}
125 | {{/each}}
126 | 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 | -------------------------------------------------------------------------------- /data_frame.go: -------------------------------------------------------------------------------- 1 | package raymond 2 | 3 | import "reflect" 4 | 5 | // DataFrame represents a private data frame. 6 | // 7 | // Cf. private variables documentation at: http://handlebarsjs.com/block_helpers.html 8 | type DataFrame struct { 9 | parent *DataFrame 10 | data map[string]interface{} 11 | } 12 | 13 | // NewDataFrame instanciates a new private data frame. 14 | func NewDataFrame() *DataFrame { 15 | return &DataFrame{ 16 | data: make(map[string]interface{}), 17 | } 18 | } 19 | 20 | // Copy instanciates a new private data frame with receiver as parent. 21 | func (p *DataFrame) Copy() *DataFrame { 22 | result := NewDataFrame() 23 | 24 | for k, v := range p.data { 25 | result.data[k] = v 26 | } 27 | 28 | result.parent = p 29 | 30 | return result 31 | } 32 | 33 | // newIterDataFrame instanciates a new private data frame with receiver as parent and with iteration data set (@index, @key, @first, @last) 34 | func (p *DataFrame) newIterDataFrame(length int, i int, key interface{}) *DataFrame { 35 | result := p.Copy() 36 | 37 | result.Set("index", i) 38 | result.Set("key", key) 39 | result.Set("first", i == 0) 40 | result.Set("last", i == length-1) 41 | 42 | return result 43 | } 44 | 45 | // Set sets a data value. 46 | func (p *DataFrame) Set(key string, val interface{}) { 47 | p.data[key] = val 48 | } 49 | 50 | // Get gets a data value. 51 | func (p *DataFrame) Get(key string) interface{} { 52 | return p.find([]string{key}) 53 | } 54 | 55 | // find gets a deep data value 56 | // 57 | // @todo This is NOT consistent with the way we resolve data in template (cf. `evalDataPathExpression()`) ! FIX THAT ! 58 | func (p *DataFrame) find(parts []string) interface{} { 59 | data := p.data 60 | 61 | for i, part := range parts { 62 | val := data[part] 63 | if val == nil { 64 | return nil 65 | } 66 | 67 | if i == len(parts)-1 { 68 | // found 69 | return val 70 | } 71 | 72 | valValue := reflect.ValueOf(val) 73 | if valValue.Kind() != reflect.Map { 74 | // not found 75 | return nil 76 | } 77 | 78 | // continue 79 | data = mapStringInterface(valValue) 80 | } 81 | 82 | // not found 83 | return nil 84 | } 85 | 86 | // mapStringInterface converts any `map` to `map[string]interface{}` 87 | func mapStringInterface(value reflect.Value) map[string]interface{} { 88 | result := make(map[string]interface{}) 89 | 90 | for _, key := range value.MapKeys() { 91 | result[strValue(key)] = value.MapIndex(key).Interface() 92 | } 93 | 94 | return result 95 | } 96 | -------------------------------------------------------------------------------- /escape.go: -------------------------------------------------------------------------------- 1 | package raymond 2 | 3 | import ( 4 | "bytes" 5 | "strings" 6 | ) 7 | 8 | // 9 | // That whole file is borrowed from https://github.com/golang/go/tree/master/src/html/escape.go 10 | // 11 | // With changes: 12 | // ' => ' 13 | // " => " 14 | // 15 | // To stay in sync with JS implementation, and make mustache tests pass. 16 | // 17 | 18 | type writer interface { 19 | WriteString(string) (int, error) 20 | } 21 | 22 | const escapedChars = `&'<>"` 23 | 24 | func escape(w writer, s string) error { 25 | i := strings.IndexAny(s, escapedChars) 26 | for i != -1 { 27 | if _, err := w.WriteString(s[:i]); err != nil { 28 | return err 29 | } 30 | var esc string 31 | switch s[i] { 32 | case '&': 33 | esc = "&" 34 | case '\'': 35 | esc = "'" 36 | case '<': 37 | esc = "<" 38 | case '>': 39 | esc = ">" 40 | case '"': 41 | esc = """ 42 | default: 43 | panic("unrecognized escape character") 44 | } 45 | s = s[i+1:] 46 | if _, err := w.WriteString(esc); err != nil { 47 | return err 48 | } 49 | i = strings.IndexAny(s, escapedChars) 50 | } 51 | _, err := w.WriteString(s) 52 | return err 53 | } 54 | 55 | // Escape escapes special HTML characters. 56 | // 57 | // It can be used by helpers that return a SafeString and that need to escape some content by themselves. 58 | func Escape(s string) string { 59 | if strings.IndexAny(s, escapedChars) == -1 { 60 | return s 61 | } 62 | var buf bytes.Buffer 63 | escape(&buf, s) 64 | return buf.String() 65 | } 66 | -------------------------------------------------------------------------------- /escape_test.go: -------------------------------------------------------------------------------- 1 | package raymond 2 | 3 | import "fmt" 4 | 5 | func ExampleEscape() { 6 | tpl := MustParse("{{link url text}}") 7 | 8 | tpl.RegisterHelper("link", func(url string, text string) SafeString { 9 | return SafeString("" + Escape(text) + "") 10 | }) 11 | 12 | ctx := map[string]string{ 13 | "url": "http://www.aymerick.com/", 14 | "text": "This is a cool website", 15 | } 16 | 17 | result := tpl.MustExec(ctx) 18 | fmt.Print(result) 19 | // Output: This is a <em>cool</em> website 20 | } 21 | -------------------------------------------------------------------------------- /eval_test.go: -------------------------------------------------------------------------------- 1 | package raymond 2 | 3 | import "testing" 4 | 5 | var evalTests = []Test{ 6 | { 7 | "only content", 8 | "this is content", 9 | nil, nil, nil, nil, 10 | "this is content", 11 | }, 12 | { 13 | "checks path in parent contexts", 14 | "{{#a}}{{one}}{{#b}}{{one}}{{two}}{{one}}{{/b}}{{/a}}", 15 | map[string]interface{}{"a": map[string]int{"one": 1}, "b": map[string]int{"two": 2}}, 16 | nil, nil, nil, 17 | "1121", 18 | }, 19 | { 20 | "block params", 21 | "{{#foo as |bar|}}{{bar}}{{/foo}}{{bar}}", 22 | map[string]string{"foo": "baz", "bar": "bat"}, 23 | nil, nil, nil, 24 | "bazbat", 25 | }, 26 | { 27 | "block params on array", 28 | "{{#foo as |bar i|}}{{i}}.{{bar}} {{/foo}}", 29 | map[string][]string{"foo": {"baz", "bar", "bat"}}, 30 | nil, nil, nil, 31 | "0.baz 1.bar 2.bat ", 32 | }, 33 | { 34 | "nested block params", 35 | "{{#foos as |foo iFoo|}}{{#wats as |wat iWat|}}{{iFoo}}.{{iWat}}.{{foo}}-{{wat}} {{/wats}}{{/foos}}", 36 | map[string][]string{"foos": {"baz", "bar"}, "wats": {"the", "phoque"}}, 37 | nil, nil, nil, 38 | "0.0.baz-the 0.1.baz-phoque 1.0.bar-the 1.1.bar-phoque ", 39 | }, 40 | { 41 | "block params with path reference", 42 | "{{#foo as |bar|}}{{bar.baz}}{{/foo}}", 43 | map[string]map[string]string{"foo": {"baz": "bat"}}, 44 | nil, nil, nil, 45 | "bat", 46 | }, 47 | { 48 | "falsy block evaluation", 49 | "{{#foo}}bar{{/foo}} baz", 50 | map[string]interface{}{"foo": false}, 51 | nil, nil, nil, 52 | " baz", 53 | }, 54 | { 55 | "block helper returns a SafeString", 56 | "{{title}} - {{#bold}}{{body}}{{/bold}}", 57 | map[string]string{ 58 | "title": "My new blog post", 59 | "body": "I have so many things to say!", 60 | }, 61 | nil, 62 | map[string]interface{}{"bold": func(options *Options) SafeString { 63 | return SafeString(`{{alias-name}}
183 | {{/each}} 184 |his dudeness
194 |el duderino
195 |{{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 | -------------------------------------------------------------------------------- /string.go: -------------------------------------------------------------------------------- 1 | package raymond 2 | 3 | import ( 4 | "fmt" 5 | "reflect" 6 | "strconv" 7 | ) 8 | 9 | // SafeString represents a string that must not be escaped. 10 | // 11 | // A SafeString can be returned by helpers to disable escaping. 12 | type SafeString string 13 | 14 | // isSafeString returns true if argument is a SafeString 15 | func isSafeString(value interface{}) bool { 16 | if _, ok := value.(SafeString); ok { 17 | return true 18 | } 19 | return false 20 | } 21 | 22 | // Str returns string representation of any basic type value. 23 | func Str(value interface{}) string { 24 | return strValue(reflect.ValueOf(value)) 25 | } 26 | 27 | // strValue returns string representation of a reflect.Value 28 | func strValue(value reflect.Value) string { 29 | result := "" 30 | 31 | ival, ok := printableValue(value) 32 | if !ok { 33 | panic(fmt.Errorf("Can't print value: %q", value)) 34 | } 35 | 36 | val := reflect.ValueOf(ival) 37 | 38 | switch val.Kind() { 39 | case reflect.Array, reflect.Slice: 40 | for i := 0; i < val.Len(); i++ { 41 | result += strValue(val.Index(i)) 42 | } 43 | case reflect.Bool: 44 | result = "false" 45 | if val.Bool() { 46 | result = "true" 47 | } 48 | case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: 49 | result = fmt.Sprintf("%d", ival) 50 | case reflect.Float32, reflect.Float64: 51 | result = strconv.FormatFloat(val.Float(), 'f', -1, 64) 52 | case reflect.Invalid: 53 | result = "" 54 | default: 55 | result = fmt.Sprintf("%s", ival) 56 | } 57 | 58 | return result 59 | } 60 | 61 | // printableValue returns the, possibly indirected, interface value inside v that 62 | // is best for a call to formatted printer. 63 | // 64 | // NOTE: borrowed from https://github.com/golang/go/tree/master/src/text/template/exec.go 65 | func printableValue(v reflect.Value) (interface{}, bool) { 66 | if v.Kind() == reflect.Ptr { 67 | v, _ = indirect(v) // fmt.Fprint handles nil. 68 | } 69 | if !v.IsValid() { 70 | return "", true 71 | } 72 | 73 | if !v.Type().Implements(errorType) && !v.Type().Implements(fmtStringerType) { 74 | if v.CanAddr() && (reflect.PtrTo(v.Type()).Implements(errorType) || reflect.PtrTo(v.Type()).Implements(fmtStringerType)) { 75 | v = v.Addr() 76 | } else { 77 | switch v.Kind() { 78 | case reflect.Chan, reflect.Func: 79 | return nil, false 80 | } 81 | } 82 | } 83 | return v.Interface(), true 84 | } 85 | -------------------------------------------------------------------------------- /string_test.go: -------------------------------------------------------------------------------- 1 | package raymond 2 | 3 | import ( 4 | "fmt" 5 | "testing" 6 | ) 7 | 8 | type strTest struct { 9 | name string 10 | input interface{} 11 | output string 12 | } 13 | 14 | var strTests = []strTest{ 15 | {"String", "foo", "foo"}, 16 | {"Boolean true", true, "true"}, 17 | {"Boolean false", false, "false"}, 18 | {"Integer", 25, "25"}, 19 | {"Float", 25.75, "25.75"}, 20 | {"Nil", nil, ""}, 21 | {"[]string", []string{"foo", "bar"}, "foobar"}, 22 | {"[]interface{} (strings)", []interface{}{"foo", "bar"}, "foobar"}, 23 | {"[]Boolean", []bool{true, false}, "truefalse"}, 24 | } 25 | 26 | func TestStr(t *testing.T) { 27 | t.Parallel() 28 | 29 | for _, test := range strTests { 30 | if res := Str(test.input); res != test.output { 31 | t.Errorf("Failed to stringify: %s\nexpected:\n\t'%s'got:\n\t%q", test.name, test.output, res) 32 | } 33 | } 34 | } 35 | 36 | func ExampleStr() { 37 | output := Str(3) + " foos are " + Str(true) + " and " + Str(-1.25) + " bars are " + Str(false) + "\n" 38 | output += "But you know '" + Str(nil) + "' John Snow\n" 39 | output += "map: " + Str(map[string]string{"foo": "bar"}) + "\n" 40 | output += "array: " + Str([]interface{}{true, 10, "foo", 5, "bar"}) 41 | 42 | fmt.Println(output) 43 | // Output: 3 foos are true and -1.25 bars are false 44 | // But you know '' John Snow 45 | // map: map[foo:bar] 46 | // array: true10foo5bar 47 | } 48 | 49 | func ExampleSafeString() { 50 | RegisterHelper("em", func() SafeString { 51 | return SafeString("FOO BAR") 52 | }) 53 | 54 | tpl := MustParse("{{em}}") 55 | 56 | result := tpl.MustExec(nil) 57 | fmt.Print(result) 58 | // Output: FOO BAR 59 | } 60 | -------------------------------------------------------------------------------- /template.go: -------------------------------------------------------------------------------- 1 | package raymond 2 | 3 | import ( 4 | "fmt" 5 | "io/ioutil" 6 | "reflect" 7 | "runtime" 8 | "sync" 9 | 10 | "github.com/aymerick/raymond/ast" 11 | "github.com/aymerick/raymond/parser" 12 | ) 13 | 14 | // Template represents a handlebars template. 15 | type Template struct { 16 | source string 17 | program *ast.Program 18 | helpers map[string]reflect.Value 19 | partials map[string]*partial 20 | mutex sync.RWMutex // protects helpers and partials 21 | } 22 | 23 | // newTemplate instanciate a new template without parsing it 24 | func newTemplate(source string) *Template { 25 | return &Template{ 26 | source: source, 27 | helpers: make(map[string]reflect.Value), 28 | partials: make(map[string]*partial), 29 | } 30 | } 31 | 32 | // Parse instanciates a template by parsing given source. 33 | func Parse(source string) (*Template, error) { 34 | tpl := newTemplate(source) 35 | 36 | // parse template 37 | if err := tpl.parse(); err != nil { 38 | return nil, err 39 | } 40 | 41 | return tpl, nil 42 | } 43 | 44 | // MustParse instanciates a template by parsing given source. It panics on error. 45 | func MustParse(source string) *Template { 46 | result, err := Parse(source) 47 | if err != nil { 48 | panic(err) 49 | } 50 | return result 51 | } 52 | 53 | // ParseFile reads given file and returns parsed template. 54 | func ParseFile(filePath string) (*Template, error) { 55 | b, err := ioutil.ReadFile(filePath) 56 | if err != nil { 57 | return nil, err 58 | } 59 | 60 | return Parse(string(b)) 61 | } 62 | 63 | // parse parses the template 64 | // 65 | // It can be called several times, the parsing will be done only once. 66 | func (tpl *Template) parse() error { 67 | if tpl.program == nil { 68 | var err error 69 | 70 | tpl.program, err = parser.Parse(tpl.source) 71 | if err != nil { 72 | return err 73 | } 74 | } 75 | 76 | return nil 77 | } 78 | 79 | // Clone returns a copy of that template. 80 | func (tpl *Template) Clone() *Template { 81 | result := newTemplate(tpl.source) 82 | 83 | result.program = tpl.program 84 | 85 | tpl.mutex.RLock() 86 | defer tpl.mutex.RUnlock() 87 | 88 | for name, helper := range tpl.helpers { 89 | result.RegisterHelper(name, helper.Interface()) 90 | } 91 | 92 | for name, partial := range tpl.partials { 93 | result.addPartial(name, partial.source, partial.tpl) 94 | } 95 | 96 | return result 97 | } 98 | 99 | func (tpl *Template) findHelper(name string) reflect.Value { 100 | tpl.mutex.RLock() 101 | defer tpl.mutex.RUnlock() 102 | 103 | return tpl.helpers[name] 104 | } 105 | 106 | // RegisterHelper registers a helper for that template. 107 | func (tpl *Template) RegisterHelper(name string, helper interface{}) { 108 | tpl.mutex.Lock() 109 | defer tpl.mutex.Unlock() 110 | 111 | if tpl.helpers[name] != zero { 112 | panic(fmt.Sprintf("Helper %s already registered", name)) 113 | } 114 | 115 | val := reflect.ValueOf(helper) 116 | ensureValidHelper(name, val) 117 | 118 | tpl.helpers[name] = val 119 | } 120 | 121 | // RegisterHelpers registers several helpers for that template. 122 | func (tpl *Template) RegisterHelpers(helpers map[string]interface{}) { 123 | for name, helper := range helpers { 124 | tpl.RegisterHelper(name, helper) 125 | } 126 | } 127 | 128 | func (tpl *Template) addPartial(name string, source string, template *Template) { 129 | tpl.mutex.Lock() 130 | defer tpl.mutex.Unlock() 131 | 132 | if tpl.partials[name] != nil { 133 | panic(fmt.Sprintf("Partial %s already registered", name)) 134 | } 135 | 136 | tpl.partials[name] = newPartial(name, source, template) 137 | } 138 | 139 | func (tpl *Template) findPartial(name string) *partial { 140 | tpl.mutex.RLock() 141 | defer tpl.mutex.RUnlock() 142 | 143 | return tpl.partials[name] 144 | } 145 | 146 | // RegisterPartial registers a partial for that template. 147 | func (tpl *Template) RegisterPartial(name string, source string) { 148 | tpl.addPartial(name, source, nil) 149 | } 150 | 151 | // RegisterPartials registers several partials for that template. 152 | func (tpl *Template) RegisterPartials(partials map[string]string) { 153 | for name, partial := range partials { 154 | tpl.RegisterPartial(name, partial) 155 | } 156 | } 157 | 158 | // RegisterPartialFile reads given file and registers its content as a partial with given name. 159 | func (tpl *Template) RegisterPartialFile(filePath string, name string) error { 160 | b, err := ioutil.ReadFile(filePath) 161 | if err != nil { 162 | return err 163 | } 164 | 165 | tpl.RegisterPartial(name, string(b)) 166 | 167 | return nil 168 | } 169 | 170 | // RegisterPartialFiles reads several files and registers them as partials, the filename base is used as the partial name. 171 | func (tpl *Template) RegisterPartialFiles(filePaths ...string) error { 172 | if len(filePaths) == 0 { 173 | return nil 174 | } 175 | 176 | for _, filePath := range filePaths { 177 | name := fileBase(filePath) 178 | 179 | if err := tpl.RegisterPartialFile(filePath, name); err != nil { 180 | return err 181 | } 182 | } 183 | 184 | return nil 185 | } 186 | 187 | // RegisterPartialTemplate registers an already parsed partial for that template. 188 | func (tpl *Template) RegisterPartialTemplate(name string, template *Template) { 189 | tpl.addPartial(name, "", template) 190 | } 191 | 192 | // Exec evaluates template with given context. 193 | func (tpl *Template) Exec(ctx interface{}) (result string, err error) { 194 | return tpl.ExecWith(ctx, nil) 195 | } 196 | 197 | // MustExec evaluates template with given context. It panics on error. 198 | func (tpl *Template) MustExec(ctx interface{}) string { 199 | result, err := tpl.Exec(ctx) 200 | if err != nil { 201 | panic(err) 202 | } 203 | return result 204 | } 205 | 206 | // ExecWith evaluates template with given context and private data frame. 207 | func (tpl *Template) ExecWith(ctx interface{}, privData *DataFrame) (result string, err error) { 208 | defer errRecover(&err) 209 | 210 | // parses template if necessary 211 | err = tpl.parse() 212 | if err != nil { 213 | return 214 | } 215 | 216 | // setup visitor 217 | v := newEvalVisitor(tpl, ctx, privData) 218 | 219 | // visit AST 220 | result, _ = tpl.program.Accept(v).(string) 221 | 222 | // named return values 223 | return 224 | } 225 | 226 | // errRecover recovers evaluation panic 227 | func errRecover(errp *error) { 228 | e := recover() 229 | if e != nil { 230 | switch err := e.(type) { 231 | case runtime.Error: 232 | panic(e) 233 | case error: 234 | *errp = err 235 | default: 236 | panic(e) 237 | } 238 | } 239 | } 240 | 241 | // PrintAST returns string representation of parsed template. 242 | func (tpl *Template) PrintAST() string { 243 | if err := tpl.parse(); err != nil { 244 | return fmt.Sprintf("PARSER ERROR: %s", err) 245 | } 246 | 247 | return ast.Print(tpl.program) 248 | } 249 | -------------------------------------------------------------------------------- /template_test.go: -------------------------------------------------------------------------------- 1 | package raymond 2 | 3 | import ( 4 | "fmt" 5 | "testing" 6 | ) 7 | 8 | var sourceBasic = `{{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 | -------------------------------------------------------------------------------- /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 | -------------------------------------------------------------------------------- /utils_test.go: -------------------------------------------------------------------------------- 1 | package raymond 2 | 3 | import "fmt" 4 | 5 | func ExampleIsTrue() { 6 | output := "Empty array: " + Str(IsTrue([0]string{})) + "\n" 7 | output += "Non empty array: " + Str(IsTrue([1]string{"foo"})) + "\n" 8 | 9 | output += "Empty slice: " + Str(IsTrue([]string{})) + "\n" 10 | output += "Non empty slice: " + Str(IsTrue([]string{"foo"})) + "\n" 11 | 12 | output += "Empty map: " + Str(IsTrue(map[string]string{})) + "\n" 13 | output += "Non empty map: " + Str(IsTrue(map[string]string{"foo": "bar"})) + "\n" 14 | 15 | output += "Empty string: " + Str(IsTrue("")) + "\n" 16 | output += "Non empty string: " + Str(IsTrue("foo")) + "\n" 17 | 18 | output += "true bool: " + Str(IsTrue(true)) + "\n" 19 | output += "false bool: " + Str(IsTrue(false)) + "\n" 20 | 21 | output += "0 integer: " + Str(IsTrue(0)) + "\n" 22 | output += "positive integer: " + Str(IsTrue(10)) + "\n" 23 | output += "negative integer: " + Str(IsTrue(-10)) + "\n" 24 | 25 | output += "0 float: " + Str(IsTrue(0.0)) + "\n" 26 | output += "positive float: " + Str(IsTrue(10.0)) + "\n" 27 | output += "negative integer: " + Str(IsTrue(-10.0)) + "\n" 28 | 29 | output += "struct: " + Str(IsTrue(struct{}{})) + "\n" 30 | output += "nil: " + Str(IsTrue(nil)) + "\n" 31 | 32 | fmt.Println(output) 33 | // Output: Empty array: false 34 | // Non empty array: true 35 | // Empty slice: false 36 | // Non empty slice: true 37 | // Empty map: false 38 | // Non empty map: true 39 | // Empty string: false 40 | // Non empty string: true 41 | // true bool: true 42 | // false bool: false 43 | // 0 integer: false 44 | // positive integer: true 45 | // negative integer: true 46 | // 0 float: false 47 | // positive float: true 48 | // negative integer: true 49 | // struct: true 50 | // nil: false 51 | } 52 | --------------------------------------------------------------------------------