Add tests for custom node renderers

renderer.go

@@ -105,6 +105,7 @@ func (r *Renderer) Render(w io.Writer, source []byte, n ast.Node) error {
 	})
 }
 
+// transform wraps a renderer.NodeRendererFunc to match the nodeRenderer function signature
 func (r *Renderer) transform(fn renderer.NodeRendererFunc) nodeRenderer {
 	return func(n ast.Node, entering bool) ast.WalkStatus {
 		status, _ := fn(r.rc.writer, r.rc.source, n, entering)

renderer_test.go

@@ -9,6 +9,7 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/yuin/goldmark"
 	"github.com/yuin/goldmark/ast"
+	"github.com/yuin/goldmark/extension"
 	"github.com/yuin/goldmark/parser"
 	"github.com/yuin/goldmark/text"
 	"github.com/yuin/goldmark/util"
@@ -59,9 +60,26 @@ func TestRenderError(t *testing.T) {
 	assert.Equal(t, err, result)
 }
 
+// TestCustomRenderers tests that the renderer uses any config.NodeRenderers defined by the user
+func TestCustomRenderers(t *testing.T) {
+	md := goldmark.New(
+		goldmark.WithRenderer(NewRenderer()),
+		goldmark.WithParserOptions(parser.WithASTTransformers(util.Prioritized(&transformer, 0))),
+	)
+	buf := bytes.Buffer{}
+	source := `# My Tasks
+- [x] Add support for custom renderers
+	`
+
+	extension.TaskList.Extend(md)
+	err := md.Convert([]byte(source), &buf)
+	assert.NoError(t, err)
+	t.Log(buf.String())
+}
+
 // TestRenderedOutput tests that the renderer produces the expected output for all test cases
 func TestRenderedOutput(t *testing.T) {
-	var testCases = []struct {
+	testCases := []struct {
 		name     string
 		options  []Option
 		source   string

writer.go

@@ -140,21 +140,19 @@ func (m *markdownWriter) Err() error {
 	return m.err
 }
 
-// returns how many bytes are unused in the buffer.
+// Available returns how many bytes are unused in the buffer.
 func (m *markdownWriter) Available() int {
-	return m.buf.Cap() - m.buf.Len()
+	return m.buf.Available()
 }
 
+// Buffered returns the number of bytes that have been written into the current buffer.
 func (m *markdownWriter) Buffered() int {
 	return m.buf.Len()
 }
 
+// Flush flushes the contents of the buffer to the output.
 func (m *markdownWriter) Flush() error {
-	_, err := m.output.Write(m.buf.Bytes())
-	if err != nil {
-		return err
-	}
-	m.buf.Reset()
+	m.FlushLine()
 	return nil
 }
 

writer_test.go

@@ -7,8 +7,29 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
+func TestWrite(t *testing.T) {
+	buf := &bytes.Buffer{}
+	writer := newMarkdownWriter(buf, NewConfig())
+
+	available := writer.Available()
+	assert.Equal(t, 0, available)
+	assert.Equal(t, 0, writer.Buffered())
+
+	writer.WriteByte(byte('b'))
+	writer.WriteRune('r')
+	writer.WriteString("s")
+
+	assert.Less(t, available, writer.Available())
+	assert.Equal(t, 3, writer.Buffered())
+
+	err := writer.Flush()
+	require.NoError(t, err)
+	assert.Equal(t, "brs\n", buf.String())
+}
+
 // TestFlushLine tests that the writer will flush the current buffered line if non-empty.
 func TestFlushLine(t *testing.T) {
 	assert := assert.New(t)
@@ -38,7 +59,7 @@ func TestEndLine(t *testing.T) {
 
 // TestWriterOutputs tests that the writer produces expected output in various scenarios.
 func TestWriterOutputs(t *testing.T) {
-	var testCases = []struct {
+	testCases := []struct {
 		name      string
 		writeFunc func(writer *markdownWriter)
 		expected  string