tpls

builtin_template.go (5402B)

---

 package tplc
 
 import (
 	"bytes"
 	"fmt"
 	"html"
 	"io"
 	"regexp"
 	"strconv"
 	"unicode"
 	"unicode/utf8"
 
 	"github.com/pkg/errors"
 	"github.com/valyala/bytebufferpool"
 
 	"go.lair.cx/go-core/net/htmlx"
 	"go.lair.cx/tpls/internal/stacks"
 )
 
 var regexTemplateClassParser = regexp.MustCompile(
 	`^\s*(\((?:[^\s)]+[ \t]+)?[^\s)]+\)[ \t]+)?([^\s(]+)\(([^)]+)?\)\s*$`)
 
 var regexTemplatePlainTextLineParser = regexp.MustCompile(
 	`^(?:[\t ]*([\r\n])[\t ]*)?([^\n\r]*)`)
 
 func TagTemplate(b *Builder, w *Writer, t *htmlx.Tokenizer) error {
 	attrs := getAttrs(t)
 
 	_, plainText := attrs["plain"]
 
 	className, ok := attrs["class"]
 	if !ok {
 		return errors.New("class is required for template tag")
 	}
 	caps := regexTemplateClassParser.FindStringSubmatch(className)
 	if caps == nil {
 		return fmt.Errorf("invalid template name: %s", strconv.Quote(className))
 	}
 
 	w.WriteGoCode("func ", caps[1], caps[2], "(w tpls.Writer,", caps[3], ") {\n")
 
 	err := RenderTag(b, w, t, "template", plainText)
 	if err != nil {
 		return err
 	}
 
 	w.WriteGoCode("}\n\n")
 	return nil
 }
 
 func RenderTag(
 	b *Builder,
 	w *Writer,
 	t *htmlx.Tokenizer,
 	name string,
 	plainText bool,
 ) error {
 	return renderTag(b, w, t, name, nil, false, plainText)
 }
 
 func RenderTagWithCustomTags(
 	b *Builder,
 	w *Writer,
 	t *htmlx.Tokenizer,
 	name string,
 	customHandlers map[string]TagHandler,
 	useCustomOnly bool,
 	plainText bool,
 ) error {
 	return renderTag(b, w, t, name, customHandlers, useCustomOnly, plainText)
 }
 
 func renderTag(
 	b *Builder,
 	w *Writer,
 	t *htmlx.Tokenizer,
 	name string,
 	customHandlers map[string]TagHandler,
 	useCustomOnly bool,
 	plainText bool, // Plain text mode - keep spaces, trim prefix indent, etc.
 ) 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)
 
 	flushBuffer := func() {
 		if len(buf.B) > 0 {
 			w.WriteRawBytesWithBacktick(buf.B)
 			buf.B = buf.B[:0]
 		}
 	}
 
 loop:
 	for {
 		switch t.Next() {
 		case htmlx.StartTagToken, htmlx.SelfClosingTagToken:
 			tagName, _ := t.TagName()
 			handler := b.Handler(string(tagName))
 
 			if handler == nil {
 				handler, _ = customHandlers[string(tagName)]
 			}
 			if handler == nil {
 				if useCustomOnly {
 					return fmt.Errorf("unexpected tag: %s", tagName)
 				}
 				attrs := getAttrs(t)
 				// buf.B = append(buf.B, t.Raw()...)
 				buf.B = append(buf.B, '<')
 				buf.B = append(buf.B, tagName...)
 				for key, attr := range attrs {
 					buf.B = append(buf.B, ' ')
 					if len(key) > 0 && key[0] == ':' {
 						buf.B = append(buf.B, key[1:]...)
 						buf.B = append(buf.B, '=', '"')
 						flushBuffer()
 						w.WriteString(attr)
 						buf.B = append(buf.B, '"')
 					} else {
 						buf.B = append(buf.B, key...)
 						buf.B = append(buf.B, '=', '"')
 						buf.B = append(buf.B, html.EscapeString(attr)...)
 						buf.B = append(buf.B, '"')
 					}
 				}
 				buf.B = append(buf.B, '>')
 				stack.Put(tagName)
 			} else {
 				flushBuffer()
 
 				err := handler(b, w, t)
 				if err != nil {
 					return err
 				}
 			}
 
 		case htmlx.EndTagToken:
 			tagName, _ := t.TagName()
 
 			stack.Lock()
 			if stack.Len() == 0 {
 				if string(tagName) != name {
 					return errors.New("unexpected end tag: " + string(tagName))
 				}
 				break loop
 			}
 
 			for {
 				item, ok := stack.UnsafePop()
 				if !ok && string(tagName) == name {
 					break loop
 				}
 				if bytes.Equal(item, tagName) {
 					break
 				}
 			}
 			stack.Unlock()
 
 			buf.B = append(buf.B, t.Raw()...)
 
 		case htmlx.TextToken:
 			var (
 				txt = t.Text()
 				l   int
 			)
 
 			for l < len(txt) {
 				c, width := utf8.DecodeRune(txt[l:])
 				if !unicode.IsSpace(c) {
 					break
 				}
 				l += width
 			}
 
 			// Is empty text?
 			if l == len(txt) {
 				continue
 			}
 
 			if useCustomOnly {
 				return fmt.Errorf("text node is not allowed for %s", name)
 			}
 
 			if plainText {
 				// Plain Text Mode
 				// In this mode, only the prefix 'space' character on each line
 				// is removed. space characters do not include line breaks.
 				var src = txt
 				var caps [][]byte
 				for len(src) > 0 {
 					caps = regexTemplatePlainTextLineParser.FindSubmatch(src)
 					if caps == nil {
 						break
 					}
 
 					buf.B = append(buf.B, caps[1]...)
 					buf.B = append(buf.B, caps[2]...)
 
 					src = src[len(caps[0]):]
 				}
 			} else {
 				// Smart Indent Mode
 				// In this mode, space characters are reduced. The space
 				// between the tags is removed, and the space characters at the
 				// beginning and end of the text node are replaced by ' '.
 				// this removes the 'weird padding' between tags which is
 				// useless in most cases, and make <if> tag works properly
 				// and also saves few bytes while keep a gap.
 
 				var r int
 				for r = len(txt); r > 0; {
 					c, width := utf8.DecodeLastRune(txt[:r])
 					if !unicode.IsSpace(c) {
 						break
 					}
 					r -= width
 				}
 
 				if l != 0 {
 					buf.B = append(buf.B, ' ')
 				}
 
 				buf.B = append(buf.B, txt[l:r]...)
 
 				if r != len(txt) {
 					buf.B = append(buf.B, ' ')
 				}
 			}
 
 		case htmlx.ErrorToken:
 			err := t.Err()
 			if err == io.EOF {
 				if stack.Len() == 0 && len(name) == 0 {
 					break loop
 				}
 				return io.ErrUnexpectedEOF
 			} else {
 				return err
 			}
 
 		default:
 			buf.B = append(buf.B, t.Raw()...)
 		}
 	}
 
 	flushBuffer()
 
 	return nil
 }