tpls

tplc_commons_test.go (1734B)

---

 package tplc
 
 import (
 	"bytes"
 	"fmt"
 	"io"
 	"strconv"
 
 	"github.com/valyala/bytebufferpool"
 
 	"go.lair.cx/go-core/net/htmlx"
 	"go.lair.cx/tpls/internal/stacks"
 )
 
 func NewTestWriter() *Writer {
 	return &Writer{
 		builder: New().UseBuiltin(),
 	}
 }
 
 func NewTestBuilder(useBuiltin bool, tags map[string]TagHandler) *Builder {
 	b := New()
 	if useBuiltin {
 		b = b.UseBuiltin()
 	}
 	for key, tag := range tags {
 		b = b.AddTag(key, tag)
 	}
 	return b
 }
 
 func TagTestTransparent(name string) TagHandler {
 	return func(b *Builder, w *Writer, t *htmlx.Tokenizer) error {
 		if t.CurrentType() == htmlx.SelfClosingTagToken {
 			return nil
 		}
 
 		buf := bytebufferpool.Get()
 		defer bytebufferpool.Put(buf)
 
 		stackBuf := bytebufferpool.Get()
 		defer bytebufferpool.Put(stackBuf)
 
 		stack := stacks.NewByteStack(stackBuf.B)
 
 	loop:
 		for {
 			switch t.Next() {
 			case htmlx.StartTagToken:
 				tagName, _ := t.TagName()
 				stack.Put(tagName)
 
 			case htmlx.EndTagToken:
 				tagName, _ := t.TagName()
 
 				// Remove items in stack until the matched starting tag is found.
 				// If the tag is not exists in stack,
 				//   - Root tag's closing.
 				//   - Unexpected closing tag.
 				for {
 					item, ok := stack.Pop()
 					if !ok { // Tag is not found:
 						if string(tagName) == name {
 							break loop
 						}
 						return fmt.Errorf(
 							"unexpected closing tag: %s",
 							strconv.Quote(string(tagName)),
 						)
 					}
 					if bytes.Equal(item, tagName) {
 						break
 					}
 				}
 
 			case htmlx.ErrorToken:
 				err := t.Err()
 				if err == io.EOF {
 					if len(name) == 0 && stack.Len() == 0 {
 						return nil
 					}
 					return io.ErrUnexpectedEOF
 				}
 				return err
 			}
 
 			w.WriteGoCodeBytes(t.Raw())
 		}
 
 		return nil
 	}
 }