Coverage

.gitignore

@@ -1,3 +1,4 @@
 
 *.output
 liquid
+*.out

chunks/control_tags.go

@@ -71,11 +71,11 @@ func (b tagBuilder) Governs(_ []string) tagBuilder {
 
 // SameSyntaxAs tells the parser that this tag has the same syntax as the named tag.
 func (b tagBuilder) SameSyntaxAs(name string) tagBuilder {
-	ot := b.s.controlTags[name]
-	if ot == nil {
+	rt := b.s.controlTags[name]
+	if rt == nil {
 		panic(fmt.Errorf("undefined: %s", name))
 	}
-	b.tag.syntaxModel = ot
+	b.tag.syntaxModel = rt
 	return b
 }
 

chunks/marshal.go

@@ -23,7 +23,7 @@ func (c Chunk) MarshalYAML() (interface{}, error) {
 	case TagChunkType:
 		return map[string]interface{}{"tag": c.Name, "args": c.Args}, nil
 	case ObjChunkType:
-		return map[string]interface{}{"obj": c.Name}, nil
+		return map[string]interface{}{"obj": c.Args}, nil
 	default:
 		return nil, fmt.Errorf("unknown chunk tag type: %v", c.Type)
 	}

chunks/parser_test.go

@@ -2,36 +2,44 @@ package chunks
 
 import (
 	"fmt"
+	"io"
 	"testing"
 
 	"github.com/stretchr/testify/require"
 )
 
-func addTestTags(s Settings) {
+func addParserTestTags(s Settings) {
 	s.AddStartTag("case").Branch("when")
 	s.AddStartTag("comment")
 	s.AddStartTag("for").Governs([]string{"break"})
 	s.AddStartTag("if").Branch("else").Branch("elsif")
+	s.AddStartTag("unless").SameSyntaxAs("if")
 	s.AddStartTag("raw")
+	s.AddStartTag("err1").Parser(func(c ASTControlTag) (func(io.Writer, RenderContext) error, error) {
+		return nil, fmt.Errorf("stage 1 error")
+	})
 }
 
 var parseErrorTests = []struct{ in, expected string }{
 	{"{%unknown_tag%}", "unknown tag"},
 	{"{%if test%}", "unterminated if tag"},
+	{"{%if test%}{% endunless %}", "not inside unless"},
+	{`{% err1 %}{% enderr1 %}`, "stage 1 error"},
 	// {"{%for syntax error%}{%endfor%}", "parse error"},
 }
 
 var parserTests = []struct{ in string }{
 	{`{% for item in list %}{% endfor %}`},
 	{`{% if test %}{% else %}{% endif %}`},
 	{`{% if test %}{% if test %}{% endif %}{% endif %}`},
+	{`{% unless test %}{% else %}{% endunless %}`},
 	{`{% for item in list %}{% if test %}{% else %}{% endif x %}{% endfor %}`},
 	{`{% if true %}{% raw %}{% endraw %}{% endif %}`},
 }
 
 func TestParseErrors(t *testing.T) {
 	settings := NewSettings()
-	addTestTags(settings)
+	addParserTestTags(settings)
 	for i, test := range parseErrorTests {
 		t.Run(fmt.Sprintf("%02d", i+1), func(t *testing.T) {
 			ast, err := settings.Parse(test.in)
@@ -44,7 +52,7 @@ func TestParseErrors(t *testing.T) {
 
 func TestParser(t *testing.T) {
 	settings := NewSettings()
-	addTestTags(settings)
+	addParserTestTags(settings)
 	for i, test := range parserTests {
 		t.Run(fmt.Sprintf("%02d", i+1), func(t *testing.T) {
 			_, err := settings.Parse(test.in)

chunks/render_test.go

@@ -3,17 +3,39 @@ package chunks
 import (
 	"bytes"
 	"fmt"
+	"io"
+	"io/ioutil"
 	"testing"
 
 	"github.com/stretchr/testify/require"
 )
 
-var renderTests = []struct{ in, expected string }{
-	// {"{%if syntax error%}{%endif%}", "parse error"},
+func addRenderTestTags(s Settings) {
+	s.AddStartTag("parse").Parser(func(c ASTControlTag) (func(io.Writer, RenderContext) error, error) {
+		a := c.Args
+		return func(w io.Writer, c RenderContext) error {
+			_, err := w.Write([]byte(a))
+			return err
+		}, nil
+	})
+	s.AddStartTag("err2").Parser(func(c ASTControlTag) (func(io.Writer, RenderContext) error, error) {
+		return func(w io.Writer, c RenderContext) error {
+			return fmt.Errorf("stage 2 error")
+		}, nil
+	})
+}
+
+var renderTests = []struct{ in, out string }{
 	{`{{ 12 }}`, "12"},
 	{`{{ x }}`, "123"},
 	{`{{ page.title }}`, "Introduction"},
 	{`{{ ar[1] }}`, "second"},
+	{`{% parse args %}{% endparse %}`, "args"},
+}
+
+var renderErrorTests = []struct{ in, out string }{
+	// {"{%if syntax error%}{%endif%}", "parse error"},
+	{`{% err2 %}{% enderr2 %}`, "stage 2 error"},
 }
 
 var renderTestBindings = map[string]interface{}{
@@ -45,6 +67,7 @@ var renderTestBindings = map[string]interface{}{
 
 func TestRender(t *testing.T) {
 	settings := NewSettings()
+	addRenderTestTags(settings)
 	context := NewContext(renderTestBindings, settings)
 	for i, test := range renderTests {
 		t.Run(fmt.Sprintf("%02d", i+1), func(t *testing.T) {
@@ -53,7 +76,22 @@ func TestRender(t *testing.T) {
 			buf := new(bytes.Buffer)
 			err = ast.Render(buf, context)
 			require.NoErrorf(t, err, test.in)
-			require.Equalf(t, test.expected, buf.String(), test.in)
+			require.Equalf(t, test.out, buf.String(), test.in)
+		})
+	}
+}
+
+func TestRenderErrors(t *testing.T) {
+	settings := NewSettings()
+	addRenderTestTags(settings)
+	context := NewContext(renderTestBindings, settings)
+	for i, test := range renderErrorTests {
+		t.Run(fmt.Sprintf("%02d", i+1), func(t *testing.T) {
+			ast, err := settings.Parse(test.in)
+			require.NoErrorf(t, err, test.in)
+			err = ast.Render(ioutil.Discard, context)
+			require.Errorf(t, err, test.in)
+			require.Containsf(t, err.Error(), test.out, test.in)
 		})
 	}
 }

chunks/scanner_test.go

@@ -22,7 +22,7 @@ var scannerCountTests = []struct {
 	{`{{ expr arg }}{{ expr arg }}`, 2},
 }
 
-func TestScanner(t *testing.T) {
+func TestChunkScanner(t *testing.T) {
 	tokens := Scan("12", "")
 	require.NotNil(t, tokens)
 	require.Len(t, tokens, 1)
@@ -55,6 +55,10 @@ func TestScanner(t *testing.T) {
 	require.Equal(t, "tag", tokens[0].Name)
 	require.Equal(t, "args", tokens[0].Args)
 
+	tokens = Scan("pre{% tag args %}mid{{ object }}post", "")
+	require.Equal(t, `[TextChunkType{"pre"} TagChunkType{Tag:"tag", Args:"args"} TextChunkType{"mid"} ObjChunkType{"object"} TextChunkType{"post"}]`, fmt.Sprint(tokens))
+	require.Equal(t, "- text: pre\n- args: args\n  tag: tag\n- text: mid\n- obj: object\n- text: post\n", MustYAML(tokens))
+
 	for i, test := range scannerCountTests {
 		t.Run(fmt.Sprintf("%02d", i), func(t *testing.T) {
 			tokens := Scan(test.in, "")

expressions/expressions_test.go

@@ -2,6 +2,7 @@ package expressions
 
 import (
 	"fmt"
+	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/require"
@@ -91,9 +92,12 @@ var evaluatorTests = []struct {
 
 	{`"seafood" contains "foo"`, true},
 	{`"seafood" contains "bar"`, false},
+
+	// filters
+	{`"seafood" | length`, 8},
 }
 
-var evaluatorTestContext = NewContext(map[string]interface{}{
+var evaluatorTestBindings = (map[string]interface{}{
 	"n":          123,
 	"array":      []string{"first", "second", "third"},
 	"empty_list": []interface{}{},
@@ -103,12 +107,15 @@ var evaluatorTestContext = NewContext(map[string]interface{}{
 		"b": map[string]interface{}{"c": "d"},
 		"c": []string{"r", "g", "b"},
 	},
-}, NewSettings())
+})
 
 func TestEvaluator(t *testing.T) {
+	settings := NewSettings()
+	settings.AddFilter("length", strings.Count)
+	context := NewContext(evaluatorTestBindings, settings)
 	for i, test := range evaluatorTests {
 		t.Run(fmt.Sprint(i), func(t *testing.T) {
-			val, err := EvaluateString(test.in, evaluatorTestContext)
+			val, err := EvaluateString(test.in, context)
 			require.NoErrorf(t, err, test.in)
 			require.Equalf(t, test.expected, val, test.in)
 		})

expressions/parser.go

@@ -39,7 +39,7 @@ func Parse(source string) (expr Expression, err error) {
 	lexer := newLexer([]byte(source + ";"))
 	n := yyParse(lexer)
 	if n != 0 {
-		return nil, fmt.Errorf("parse error in %s", source)
+		return nil, fmt.Errorf("parse error in %q", source)
 	}
 	return &expression{lexer.val}, nil
 }

expressions/parser_test.go

@@ -8,10 +8,10 @@ import (
 )
 
 var parseErrorTests = []struct{ in, expected string }{
-// {"a | unknown_filter", "undefined filter: unknown_filter"},
+	{"a syntax error", "parse error"},
 }
 
-func TestParseErrors(t *testing.T) {
+func TestExpressionParseErrors(t *testing.T) {
 	for i, test := range parseErrorTests {
 		t.Run(fmt.Sprintf("%02d", i+1), func(t *testing.T) {
 			expr, err := Parse(test.in)