Fix panic in Set Delimiter parsing. (#91)

* Fix panic in Set Delimiter parsing.

Mustache supports Set Delimter tags, of the form `{{=<open tag> <close tag>=}}`,
which is used to change the delimiters from `{{` and `}}`. Prior to this
commit, if there was a sequence that looked like the start of a Set
Delimiter tag, but there was not a complete Set Delimiter tag, the
library could panic.

This commit:
    * factors out the Set Delimiter tag parsing into a new function,
      'parseCustomDelimiter()'
    * adds checks to make sure an incomplete tag doesn't cause an access
      off the end of a slice
    * treats an incomplete Set Delimiter (like `{{=}}`) as a normaal
      tag

This behaviour matches the mustache playground at
https://jgonggrijp.gitlab.io/wontache/playground.html. I tried to match
the behaviour of the Ruby implementation, but it seems to be
inconsistent in this case.

* Remove checks that are no inside parseCustomDelimiter()

The parse() method contains a check for 'unbalanced' custom
delimiter tags (i.e. tags that start with {{=, but don't have a
matching closing tag), and throws an error. However, wit the
new custom delimiter fix, those tags are treated as normal tags.
For example, `{{= %}}` is interpreted as a tag named `= %`, not
a malformed custom delimiter tag.

This commit removes the extra check that returns an error.

Author: fiirhok

mustache.go

@@ -374,15 +374,7 @@ func (tmpl *Template) parseSection(section *sectionElement) error {
 			}
 			section.elems = append(section.elems, partial)
 		case '=':
-			if tag[len(tag)-1] != '=' {
-				return newError(tmpl.curline, ErrInvalidMetaTag)
-			}
-			tag = strings.TrimSpace(tag[1 : len(tag)-1])
-			newtags := strings.SplitN(tag, " ", 2)
-			if len(newtags) == 2 {
-				tmpl.otag = newtags[0]
-				tmpl.ctag = newtags[1]
-			}
+			tmpl.parseCustomDelimiter(tag)
 		case '{':
 			if tag[len(tag)-1] == '}' {
 				//use a raw tag
@@ -445,15 +437,7 @@ func (tmpl *Template) parse() error {
 			}
 			tmpl.elems = append(tmpl.elems, partial)
 		case '=':
-			if tag[len(tag)-1] != '=' {
-				return newError(tmpl.curline, ErrInvalidMetaTag)
-			}
-			tag = strings.TrimSpace(tag[1 : len(tag)-1])
-			newtags := strings.SplitN(tag, " ", 2)
-			if len(newtags) == 2 {
-				tmpl.otag = newtags[0]
-				tmpl.ctag = newtags[1]
-			}
+			tmpl.parseCustomDelimiter(tag)
 		case '{':
 			//use a raw tag
 			if tag[len(tag)-1] == '}' {
@@ -469,6 +453,21 @@ func (tmpl *Template) parse() error {
 	}
 }
 
+func (tmpl *Template) parseCustomDelimiter(tag string) {
+	if len(tag) < 3 || tag[len(tag)-1] != '=' {
+		tmpl.elems = append(tmpl.elems, &varElement{tag, tmpl.forceRaw})
+		return
+	}
+	trimmedtag := strings.TrimSpace(tag[1 : len(tag)-1])
+	newtags := strings.SplitN(trimmedtag, " ", 2)
+	if len(newtags) == 2 {
+		tmpl.otag = newtags[0]
+		tmpl.ctag = newtags[1]
+	} else {
+		tmpl.elems = append(tmpl.elems, &varElement{tag, tmpl.forceRaw})
+	}
+}
+
 // Evaluate interfaces and pointers looking for a value that can look up the name, via a
 // struct field, method, or map key, and return the result of the lookup.
 func lookup(contextChain []interface{}, name string, allowMissing bool) (reflect.Value, error) {

mustache_test.go

@@ -94,6 +94,12 @@ var tests = []Test{
 	{`hello {{! comment }}world`, map[string]string{}, "hello world", nil},
 	{`{{ a }}{{=<% %>=}}<%b %><%={{ }}=%>{{ c }}`, map[string]string{"a": "a", "b": "b", "c": "c"}, "abc", nil},
 	{`{{ a }}{{= <% %> =}}<%b %><%= {{ }}=%>{{c}}`, map[string]string{"a": "a", "b": "b", "c": "c"}, "abc", nil},
+	// variables that look like malformed custom delimiter tags
+	{`{{=}}`, map[string]string{"=": "a"}, "a", nil},
+	{`{{= %}}`, map[string]string{"= %": "a"}, "a", nil},
+	{`{{==}}`, map[string]string{"==": "a"}, "a", nil},
+	{`{{= =}}`, map[string]string{"= =": "a"}, "a", nil},
+	{`{{#A}}{{=}}{{/A}}`, map[string]string{"=": "a"}, "a", nil},
 
 	//section tests
 	{`{{#A}}{{B}}{{/A}}`, Data{true, "hello"}, "hello", nil},