arpio/html
1
0
Fork 0
Code

preformatted elements

Browse Source
This commit is contained in:
Arpad Ryszka 2025-10-29 21:04:07 +01:00
parent 70f7795400
commit effffeadf9
14 changed files with 344 additions and 188 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Makefile
View File

@ -13,6 +13,7 @@ tags: \
tag/void.block.gen.go \
tag/void.inline.gen.go \
tag/inlinechildren.gen.go \
tag/preformatted.gen.go \
tag/script.gen.go
go fmt tag/*
@ -34,6 +35,9 @@ tag/void.block.gen.go: $(SOURCES) tag.void.block.txt
tag/void.inline.gen.go: $(SOURCES) tag.void.inline.txt
go run script/generate-tags.go Void Inline < tag.void.inline.txt > tag/void.inline.gen.go
tag/preformatted.gen.go: $(SOURCES) tag.preformatted.txt
go run script/generate-tags.go Preformatted < tag.preformatted.txt > tag/preformatted.gen.go
tag/script.gen.go: $(SOURCES) tag.script.txt
go run script/generate-tags.go ScriptContent < tag.script.txt > tag/script.gen.go

14
escape.go
View File

@ -12,12 +12,16 @@ const unicodeNBSP = 0xa0
type escapeWriter struct {
out *bufio.Writer
nonbreakSpaces bool
spaceStarted, lastSpace bool
err error
}
func newEscapeWriter(out io.Writer) *escapeWriter {
return &escapeWriter{out: bufio.NewWriter(out)}
func newEscapeWriter(out io.Writer, nonbreakSpaces bool) *escapeWriter {
return &escapeWriter{
out: bufio.NewWriter(out),
nonbreakSpaces: nonbreakSpaces,
}
}
func (w *escapeWriter) write(r ...rune) {
@ -59,7 +63,7 @@ func (w *escapeWriter) Write(p []byte) (int, error) {
continue
}
space := r == ' '
space := w.nonbreakSpaces && r == ' '
switch {
case space && w.spaceStarted:
w.write([]rune("&nbsp;&nbsp;")...)
@ -106,9 +110,9 @@ func (w *escapeWriter) Flush() error {
return w.err
}
func escape(s string) string {
func escape(s string, nonbreakSpaces bool) string {
var b bytes.Buffer
w := newEscapeWriter(&b)
w := newEscapeWriter(&b, nonbreakSpaces)
w.Write([]byte(s))
w.Flush()
return b.String()

16
escape_test.go
View File

@ -10,7 +10,7 @@ import (
func TestEscape(t *testing.T) {
t.Run("attribute escape", func(t *testing.T) {
var buf bytes.Buffer
if err := html.Render(&buf, Div(Attr("foo", "\"bar\" & \"baz\""))); err != nil {
if err := html.WriteRaw(&buf, Div(Attr("foo", "\"bar\" & \"baz\""))); err != nil {
t.Fatal(err)
}
@ -21,7 +21,7 @@ func TestEscape(t *testing.T) {
t.Run("failing writer", func(t *testing.T) {
ew := &errorWriter{}
if err := html.Render(ew, Span("foo bar baz")); err == nil {
if err := html.WriteRaw(ew, Span("foo bar baz")); err == nil {
t.Fatal("failed to fail")
}
})
@ -30,7 +30,7 @@ func TestEscape(t *testing.T) {
b := []byte{'f', 0xc2, 'o', 'o'}
var buf bytes.Buffer
if err := html.Render(&buf, Span(string(b))); err != nil {
if err := html.WriteRaw(&buf, Span(string(b))); err != nil {
t.Fatal(err)
}
@ -41,7 +41,7 @@ func TestEscape(t *testing.T) {
t.Run("multiple spaces", func(t *testing.T) {
var buf bytes.Buffer
if err := html.Render(&buf, Span("foo bar")); err != nil {
if err := html.WriteRaw(&buf, Span("foo bar")); err != nil {
t.Fatal(err)
}
@ -52,7 +52,7 @@ func TestEscape(t *testing.T) {
t.Run("single space", func(t *testing.T) {
var buf bytes.Buffer
if err := html.Render(&buf, Span("foo bar")); err != nil {
if err := html.WriteRaw(&buf, Span("foo bar")); err != nil {
t.Fatal(err)
}
@ -63,7 +63,7 @@ func TestEscape(t *testing.T) {
t.Run("tailing space", func(t *testing.T) {
var buf bytes.Buffer
if err := html.Render(&buf, Span("foo ")); err != nil {
if err := html.WriteRaw(&buf, Span("foo ")); err != nil {
t.Fatal(err)
}
@ -74,7 +74,7 @@ func TestEscape(t *testing.T) {
t.Run("unicode non-break space", func(t *testing.T) {
var buf bytes.Buffer
if err := html.Render(&buf, Span(string([]rune{0xa0}))); err != nil {
if err := html.WriteRaw(&buf, Span(string([]rune{0xa0}))); err != nil {
t.Fatal(err)
}
@ -85,7 +85,7 @@ func TestEscape(t *testing.T) {
t.Run("html characters", func(t *testing.T) {
var buf bytes.Buffer
if err := html.Render(&buf, Span("<foo&bar>")); err != nil {
if err := html.WriteRaw(&buf, Span("<foo&bar>")); err != nil {
t.Fatal(err)
}

29
lib.go
View File

@ -169,11 +169,11 @@ func Doctype(children ...any) Tag {
// String returns the rendered HTML text.
//
// It is meant to be used for debugging. Use the Render function to avoid buffering up an entire HTML document
// It is meant to be used for debugging. Use the Write functions to avoid buffering up an entire HTML document
// as string.
func (t Tag) String() string {
buf := bytes.NewBuffer(nil)
Render(buf, t)
WriteRaw(buf, t)
return buf.String()
}
@ -295,6 +295,14 @@ func Children(t Tag) []any {
return c
}
// Preformatted creates a new tag from t that will prevent changing the whitespaces of text content enclosed by
// a tag.
//
// The input tag remains unchanged.
func Preformatted(t Tag) Tag {
return t()(renderGuide{preformatted: true})
}
// Verbatim creates a new tag from t marking the new one verbatim. The content of verbatim tags is rendered
// without HTML escaping. This may cause security issues when using it in an incosiderate way. Verbatim content
// gets indented when rendering with indentation.
@ -341,12 +349,12 @@ func Indent() Indentation {
return Indentation{Indent: "\t"}
}
// RenderIndent renders html with t as the root nodes using the specified indentation and wrapping.
// WriteIndent renders html with t as the root nodes using the specified indentation and wrapping.
//
// Non-tag child nodes are rendered via fmt.Sprint. Consecutive spaces are considered to be so on purpose, and
// are converted into &nbsp;. Spaces around tags, in special cases, can behave different from when using
// unindented rendering.
func RenderIndent(out io.Writer, indent Indentation, t ...Tag) error {
func WriteIndent(out io.Writer, indent Indentation, t ...Tag) error {
if indent.PWidth < indent.MinPWidth {
indent.PWidth = indent.MinPWidth
}
@ -378,9 +386,14 @@ func RenderIndent(out io.Writer, indent Indentation, t ...Tag) error {
return nil
}
// Render renders html with t as the root nodes without indentation or wrapping.
func Render(out io.Writer, t ...Tag) error {
return RenderIndent(out, Indentation{}, t...)
// Write renders html with t as the root nodes with the default indentation and wrapping.
func Write(out io.Writer, t ...Tag) error {
return WriteIndent(out, Indent(), t...)
}
// WriteRaw renders html with t as the root nodes without indentation or wrapping.
func WriteRaw(out io.Writer, t ...Tag) error {
return WriteIndent(out, Indentation{}, t...)
}
// Eq returns if one or more tags are considered equivalent. Equivalent nodes, in the most cases, will result in
@ -452,7 +465,7 @@ func MapChildren[Data any](data []Data, tag Tag) []any {
// Escape escapes HTML.
func Escape(s string) string {
return escape(s)
return escape(s, true)
}
// EscapeAttribute escape attribute values. It does not escape single-quotes, because it assumes attribute

58
lib_test.go
View File

@ -42,7 +42,7 @@ func TestLib(t *testing.T) {
foo := html.Define("foo+bar")
var b bytes.Buffer
if err := html.Render(&b, foo); err == nil {
if err := html.WriteRaw(&b, foo); err == nil {
t.Fatal("failed to fail")
}
})
@ -143,7 +143,7 @@ func TestLib(t *testing.T) {
t.Run("invalid attribute name", func(t *testing.T) {
var b bytes.Buffer
if err := html.Render(&b, Div(Attr("foo+bar", "baz"))); err == nil {
if err := html.WriteRaw(&b, Div(Attr("foo+bar", "baz"))); err == nil {
t.Fatal()
}
})
@ -225,7 +225,7 @@ func TestLib(t *testing.T) {
}
var b bytes.Buffer
if err := html.Render(&b, Div(tagChildren...)); err != nil {
if err := html.WriteRaw(&b, Div(tagChildren...)); err != nil {
t.Fatal(err)
}
@ -238,7 +238,7 @@ func TestLib(t *testing.T) {
tags := html.MapChildren([]string{"foo", "bar", "baz"}, Div)
var b bytes.Buffer
if err := html.Render(&b, Div(tags...)); err != nil {
if err := html.WriteRaw(&b, Div(tags...)); err != nil {
t.Fatal(err)
}
@ -252,7 +252,7 @@ func TestLib(t *testing.T) {
div1 := div0("bar")
var b bytes.Buffer
if err := html.Render(&b, Div(div0, div1)); err != nil {
if err := html.WriteRaw(&b, Div(div0, div1)); err != nil {
t.Fatal(err)
}
@ -265,7 +265,7 @@ func TestLib(t *testing.T) {
t.Run("render", func(t *testing.T) {
t.Run("block", func(t *testing.T) {
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), Div("foo")); err != nil {
if err := html.Write(&b, Div("foo")); err != nil {
t.Fatal(err)
}
@ -276,7 +276,7 @@ func TestLib(t *testing.T) {
t.Run("inline", func(t *testing.T) {
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), Span("foo")); err != nil {
if err := html.Write(&b, Span("foo")); err != nil {
t.Fatal(err)
}
@ -287,7 +287,7 @@ func TestLib(t *testing.T) {
t.Run("inline children", func(t *testing.T) {
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), Div(P("foo"), P("bar"))); err != nil {
if err := html.Write(&b, Div(P("foo"), P("bar"))); err != nil {
t.Fatal(err)
}
@ -300,7 +300,7 @@ func TestLib(t *testing.T) {
inlineP := html.Inline(P)
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), Div(inlineP("foo"), inlineP("bar"))); err != nil {
if err := html.Write(&b, Div(inlineP("foo"), inlineP("bar"))); err != nil {
t.Fatal(err)
}
@ -311,7 +311,7 @@ func TestLib(t *testing.T) {
t.Run("void", func(t *testing.T) {
var b bytes.Buffer
if err := html.Render(&b, Br); err != nil {
if err := html.WriteRaw(&b, Br); err != nil {
t.Fatal(err)
}
@ -322,7 +322,7 @@ func TestLib(t *testing.T) {
t.Run("void with children", func(t *testing.T) {
var b bytes.Buffer
if err := html.Render(&b, Br("foo")); err == nil {
if err := html.WriteRaw(&b, Br("foo")); err == nil {
t.Fatal()
}
})
@ -331,7 +331,7 @@ func TestLib(t *testing.T) {
div := html.Verbatim(Div("foo &\nbar"))
var b bytes.Buffer
if err := html.Render(&b, div); err != nil {
if err := html.WriteRaw(&b, div); err != nil {
t.Fatal(err)
}
@ -344,7 +344,7 @@ func TestLib(t *testing.T) {
div := html.Verbatim(Div("foo &\nbar"))
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), div); err != nil {
if err := html.Write(&b, div); err != nil {
t.Fatal(err)
}
@ -357,7 +357,7 @@ func TestLib(t *testing.T) {
script := Script("let foo = 42\nlet bar = 84")
var b bytes.Buffer
if err := html.Render(&b, script); err != nil {
if err := html.WriteRaw(&b, script); err != nil {
t.Fatal(err)
}
@ -370,7 +370,7 @@ func TestLib(t *testing.T) {
script := Script("let foo = 42\nlet bar = 84")
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), script); err != nil {
if err := html.Write(&b, script); err != nil {
t.Fatal(err)
}
@ -383,7 +383,7 @@ func TestLib(t *testing.T) {
script := html.Verbatim(Script("let foo = 42\nlet bar = 84"))
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), script); err != nil {
if err := html.Write(&b, script); err != nil {
t.Fatal(err)
}
@ -398,7 +398,7 @@ func TestLib(t *testing.T) {
div := Div(div0, div1)
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), div); err != nil {
if err := html.Write(&b, div); err != nil {
t.Fatal(err)
}
@ -411,7 +411,7 @@ func TestLib(t *testing.T) {
p := P("foo bar baz")
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indentation{PWidth: 8, MinPWidth: 12}, p); err != nil {
if err := html.WriteIndent(&b, html.Indentation{PWidth: 8, MinPWidth: 12}, p); err != nil {
t.Fatal(err)
}
@ -424,7 +424,7 @@ func TestLib(t *testing.T) {
doc := Html(Body(P("foo bar baz")))
var b bytes.Buffer
if err := html.Render(&b, Doctype("html"), doc); err != nil {
if err := html.WriteRaw(&b, Doctype("html"), doc); err != nil {
t.Fatal(err)
}
@ -437,7 +437,7 @@ func TestLib(t *testing.T) {
doc := Html(Body(P("foo bar baz")))
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), Doctype("html"), doc); err != nil {
if err := html.Write(&b, Doctype("html"), doc); err != nil {
t.Fatal(err)
}
@ -452,7 +452,7 @@ func TestLib(t *testing.T) {
double := func(i int) html.Tag { return Div(2 * i) }
var b bytes.Buffer
if err := html.Render(&b, double(42)); err != nil {
if err := html.WriteRaw(&b, double(42)); err != nil {
t.Fatal(err)
}
@ -510,7 +510,7 @@ func TestLib(t *testing.T) {
}
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), teamHTML(myTeam)); err != nil {
if err := html.Write(&b, teamHTML(myTeam)); err != nil {
t.Fatal(err)
}
@ -558,7 +558,7 @@ func TestLib(t *testing.T) {
double = double("foo")
var b bytes.Buffer
if err := html.Render(&b, double); err != nil {
if err := html.WriteRaw(&b, double); err != nil {
t.Fatal(err)
}
@ -572,7 +572,7 @@ func TestLib(t *testing.T) {
double = double(42, 84)
var b bytes.Buffer
if err := html.Render(&b, double); err != nil {
if err := html.WriteRaw(&b, double); err != nil {
t.Fatal(err)
}
@ -587,7 +587,7 @@ func TestLib(t *testing.T) {
double1 := double0("foo")
var b bytes.Buffer
if err := html.Render(&b, Div(double0, double1)); err != nil {
if err := html.WriteRaw(&b, Div(double0, double1)); err != nil {
t.Fatal(err)
}
@ -602,7 +602,7 @@ func TestLib(t *testing.T) {
comment := Comment("foo &\nbar")
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), comment); err != nil {
if err := html.Write(&b, comment); err != nil {
t.Fatal(err)
}
@ -615,7 +615,7 @@ func TestLib(t *testing.T) {
doctype := Doctype("html")
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), doctype); err != nil {
if err := html.Write(&b, doctype); err != nil {
t.Fatal(err)
}
@ -628,7 +628,7 @@ func TestLib(t *testing.T) {
doctype := Doctype("html", "public", "-//W3C//DTD HTML 4.01//EN", "http://www.w3.org/TR/html4/strict.dtd")
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), doctype); err != nil {
if err := html.Write(&b, doctype); err != nil {
t.Fatal(err)
}
@ -645,7 +645,7 @@ func TestLib(t *testing.T) {
cdata := html.FromTemplate(cdataTemplate)
var b bytes.Buffer
if err := html.Render(&b, cdata("foo &\nbar")); err != nil {
if err := html.WriteRaw(&b, cdata("foo &\nbar")); err != nil {
t.Fatal(err)
}

10
query_test.go
View File

@ -21,7 +21,7 @@ func TestQuery(t *testing.T) {
}
var b bytes.Buffer
if err := html.Render(&b, inlineDiv); err != nil {
if err := html.WriteRaw(&b, inlineDiv); err != nil {
t.Fatal(err)
}
@ -109,7 +109,7 @@ func TestQuery(t *testing.T) {
div := Div(Span("foo"))
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), div); err != nil {
if err := html.Write(&b, div); err != nil {
t.Fatal(err)
}
@ -123,7 +123,7 @@ func TestQuery(t *testing.T) {
script := Script(`function() { return "Hello, world!" }`)
var b bytes.Buffer
if err := html.Render(&b, script); err != nil {
if err := html.WriteRaw(&b, script); err != nil {
t.Fatal(err)
}
})
@ -132,7 +132,7 @@ func TestQuery(t *testing.T) {
div := Div(Attr("foo+", "bar"))
var b bytes.Buffer
if err := html.Render(&b, div); err == nil {
if err := html.WriteRaw(&b, div); err == nil {
t.Fatal()
}
})
@ -141,7 +141,7 @@ func TestQuery(t *testing.T) {
div := Div(Div(Attr("foo+", "bar")))
var b bytes.Buffer
if err := html.Render(&b, div); err == nil {
if err := html.WriteRaw(&b, div); err == nil {
t.Fatal()
}
})

92
render.go
View File

@ -13,6 +13,7 @@ type renderGuide struct {
inlineChildren bool
void bool
script bool
preformatted bool
verbatim bool
}
@ -32,6 +33,7 @@ func mergeRenderingGuides(rgs []renderGuide) renderGuide {
rg.inlineChildren = rg.inlineChildren || rgi.inlineChildren
rg.void = rg.void || rgi.void
rg.script = rg.script || rgi.script
rg.preformatted = rg.preformatted || rgi.preformatted
rg.verbatim = rg.verbatim || rgi.verbatim
}
@ -74,12 +76,12 @@ func (r *renderer) clearWrapper() {
r.out = r.originalOut
}
func (r *renderer) writeEscaped(s string) {
func (r *renderer) writeEscaped(s string, nonbreakSpaces bool) {
if r.err != nil {
return
}
ew := newEscapeWriter(r.out)
ew := newEscapeWriter(r.out, nonbreakSpaces)
if _, r.err = ew.Write([]byte(s)); r.err != nil {
return
}
@ -87,12 +89,12 @@ func (r *renderer) writeEscaped(s string) {
r.err = ew.Flush()
}
func (r *renderer) copyEscaped(rd io.Reader) {
func (r *renderer) copyEscaped(rd io.Reader, nonbreakSpaces bool) {
if r.err != nil {
return
}
ew := newEscapeWriter(r.out)
ew := newEscapeWriter(r.out, nonbreakSpaces)
if _, r.err = io.Copy(ew, rd); r.err != nil {
return
}
@ -185,11 +187,15 @@ func (r *renderer) renderUnindented(name string, rg renderGuide, a []Attributes,
}
if isReader {
r.copyEscaped(rd)
r.copyEscaped(rd, !rg.preformatted)
continue
}
if ct, ok := c.(Tag); ok {
if rg.preformatted {
ct = Preformatted(ct)
}
ct(r)
continue
}
@ -204,14 +210,21 @@ func (r *renderer) renderUnindented(name string, rg renderGuide, a []Attributes,
continue
}
r.writeEscaped(s)
r.writeEscaped(s, !rg.preformatted)
}
printf("</%s>", name)
}
func (r *renderer) renderChildTag(tagName string, block, lastBlock bool, ct Tag) (bool, bool) {
func (r *renderer) renderChildTag(tagName string, rg renderGuide, lastBlock bool, ct Tag) (bool, bool) {
printf := r.getPrintf(tagName)
if rg.preformatted {
cr := new(renderer)
*cr = *r
cr.indent = Indentation{}
Preformatted(ct)(cr)
return false, false
}
var rgq renderGuidesQuery
ct(&rgq)
@ -229,7 +242,7 @@ func (r *renderer) renderChildTag(tagName string, block, lastBlock bool, ct Tag)
r.clearWrapper()
cr := new(renderer)
*cr = *r
if !block {
if rg.inline || rg.inlineChildren {
cr.currentIndent += cr.indent.Indent
cr.pwidth -= indentLen(cr.indent.Indent)
if cr.pwidth < cr.indent.MinPWidth {
@ -246,19 +259,8 @@ func (r *renderer) renderChildTag(tagName string, block, lastBlock bool, ct Tag)
return true, false
}
func (r *renderer) renderReaderChild(tagName string, rg renderGuide, block, lastBlock bool, rd io.Reader) bool {
func (r *renderer) renderReaderChild(tagName string, rg renderGuide, lastBlock bool, rd io.Reader) bool {
printf := r.getPrintf(tagName)
if rg.verbatim {
r.clearWrapper()
indent := r.currentIndent
if !block {
indent += r.indent.Indent
}
r.copyIndented(indent, rd)
return false
}
if rg.script {
r.clearWrapper()
printf("\n")
@ -269,12 +271,29 @@ func (r *renderer) renderReaderChild(tagName string, rg renderGuide, block, last
return false
}
if rg.verbatim {
r.clearWrapper()
indent := r.currentIndent
if rg.inline || rg.inlineChildren {
indent += r.indent.Indent
}
r.copyIndented(indent, rd)
return false
}
if rg.preformatted {
r.clearWrapper()
r.copyEscaped(rd, false)
return false
}
if lastBlock {
printf("\n%s", r.currentIndent)
}
newWrapper := r.ensureWrapper()
r.copyEscaped(rd)
r.copyEscaped(rd, true)
return newWrapper
}
@ -289,34 +308,44 @@ func (r *renderer) renderChildScript(tagName string, c any) {
printf("\n%s", s)
}
func (r *renderer) renderVerbatimChild(block bool, c any) {
func (r *renderer) renderVerbatimChild(rg renderGuide, c any) {
s := fmt.Sprint(c)
if s == "" {
return
}
r.clearWrapper()
if rg.preformatted {
_, r.err = r.out.Write([]byte(s))
return
}
indent := r.currentIndent
if !block {
if rg.inline || rg.inlineChildren {
indent += r.indent.Indent
}
r.writeIndented(indent, s)
}
func (r *renderer) renderChildContent(tagName string, lastBlock bool, c any) bool {
func (r *renderer) renderChildContent(tagName string, rg renderGuide, lastBlock bool, c any) bool {
s := fmt.Sprint(c)
if s == "" {
return false
}
if rg.preformatted {
r.writeEscaped(s, false)
return false
}
if lastBlock {
printf := r.getPrintf(tagName)
printf("\n%s", r.currentIndent)
}
newWrapper := r.ensureWrapper()
r.writeEscaped(s)
r.writeEscaped(s, true)
return newWrapper
}
@ -358,6 +387,11 @@ func (r *renderer) renderIndented(name string, rg renderGuide, a []Attributes, c
}
}
if rg.preformatted {
r.clearWrapper()
printf("\n")
}
for _, c := range children {
if c == nil {
continue
@ -365,7 +399,7 @@ func (r *renderer) renderIndented(name string, rg renderGuide, a []Attributes, c
if ct, isTag := c.(Tag); isTag {
var nw bool
lastBlock, nw = r.renderChildTag(name, block, lastBlock, ct)
lastBlock, nw = r.renderChildTag(name, rg, lastBlock, ct)
if nw {
newWrapper = true
}
@ -374,7 +408,7 @@ func (r *renderer) renderIndented(name string, rg renderGuide, a []Attributes, c
}
if rd, isReader := c.(io.Reader); isReader {
if r.renderReaderChild(name, rg, block, lastBlock, rd) {
if r.renderReaderChild(name, rg, lastBlock, rd) {
newWrapper = true
}
@ -389,12 +423,12 @@ func (r *renderer) renderIndented(name string, rg renderGuide, a []Attributes, c
}
if rg.verbatim {
r.renderVerbatimChild(block, c)
r.renderVerbatimChild(rg, c)
lastBlock = true
continue
}
if r.renderChildContent(name, lastBlock, c) {
if r.renderChildContent(name, rg, lastBlock, c) {
newWrapper = true
}

246
render_test.go
View File

@ -14,7 +14,7 @@ func TestRender(t *testing.T) {
foo = foo("<bar><baz></bar>")
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), foo); err != nil {
if err := html.Write(&b, foo); err != nil {
t.Fatal(err)
}
@ -28,7 +28,7 @@ func TestRender(t *testing.T) {
span := Span(Attr("foo", "bar=\"&\""))
var b bytes.Buffer
if err := html.Render(&b, span); err != nil {
if err := html.WriteRaw(&b, span); err != nil {
t.Fatal(err)
}
@ -41,7 +41,7 @@ func TestRender(t *testing.T) {
span := Span(Attr("foo", true))
var b bytes.Buffer
if err := html.Render(&b, span); err != nil {
if err := html.WriteRaw(&b, span); err != nil {
t.Fatal(err)
}
@ -54,7 +54,7 @@ func TestRender(t *testing.T) {
comment := Comment("foo & bar & baz", "qux")
var b bytes.Buffer
if err := html.Render(&b, comment); err != nil {
if err := html.WriteRaw(&b, comment); err != nil {
t.Fatal(err)
}
@ -69,7 +69,7 @@ func TestRender(t *testing.T) {
span := Span("<foo>bar&baz</foo>")
var b bytes.Buffer
if err := html.Render(&b, span); err != nil {
if err := html.WriteRaw(&b, span); err != nil {
t.Fatal(err)
}
@ -82,7 +82,7 @@ func TestRender(t *testing.T) {
span := Span("consecutive spaces: \" \"")
var b bytes.Buffer
if err := html.Render(&b, span); err != nil {
if err := html.WriteRaw(&b, span); err != nil {
t.Fatal(err)
}
@ -96,7 +96,7 @@ func TestRender(t *testing.T) {
t.Run("fail immediately", func(t *testing.T) {
div := Div(Span("foo"))
w := &errorWriter{}
if err := html.Render(w, div); err == nil || !strings.Contains(err.Error(), "test write error") {
if err := html.WriteRaw(w, div); err == nil || !strings.Contains(err.Error(), "test write error") {
t.Fatal()
}
})
@ -104,7 +104,7 @@ func TestRender(t *testing.T) {
t.Run("fail in tag", func(t *testing.T) {
div := Div(Span("foo"))
w := &errorWriter{failAfter: 6}
if err := html.Render(w, div); err == nil || !strings.Contains(err.Error(), "test write error") {
if err := html.WriteRaw(w, div); err == nil || !strings.Contains(err.Error(), "test write error") {
t.Fatal()
}
})
@ -112,7 +112,7 @@ func TestRender(t *testing.T) {
t.Run("partial text children", func(t *testing.T) {
div := Div("foo", Div("bar"), "baz")
w := &errorWriter{failAfter: 5}
if err := html.RenderIndent(w, html.Indent(), div); err == nil || !strings.Contains(err.Error(), "test write error") {
if err := html.Write(w, div); err == nil || !strings.Contains(err.Error(), "test write error") {
t.Fatal()
}
})
@ -120,7 +120,7 @@ func TestRender(t *testing.T) {
t.Run("text children", func(t *testing.T) {
div := Div("foo", "bar", "baz")
w := &errorWriter{failAfter: 5}
if err := html.RenderIndent(w, html.Indent(), div); err == nil || !strings.Contains(err.Error(), "test write error") {
if err := html.Write(w, div); err == nil || !strings.Contains(err.Error(), "test write error") {
t.Fatal()
}
})
@ -131,7 +131,7 @@ func TestRender(t *testing.T) {
div := Div(Span("foo"))
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), div); err != nil {
if err := html.Write(&b, div); err != nil {
t.Fatal(err)
}
@ -144,7 +144,7 @@ func TestRender(t *testing.T) {
div := Div(Br)
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), div); err != nil {
if err := html.Write(&b, div); err != nil {
t.Fatal(err)
}
@ -157,7 +157,7 @@ func TestRender(t *testing.T) {
div := Div("foo bar baz", Div("qux quux"), "corge")
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), div); err != nil {
if err := html.Write(&b, div); err != nil {
t.Fatal(err)
}
@ -170,7 +170,7 @@ func TestRender(t *testing.T) {
div := Div(Span("foo bar baz", Div("qux quux"), "corge"))
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), div); err != nil {
if err := html.Write(&b, div); err != nil {
t.Fatal(err)
}
@ -184,7 +184,7 @@ func TestRender(t *testing.T) {
foo = foo("bar\nbaz\nqux")
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), foo); err != nil {
if err := html.Write(&b, foo); err != nil {
t.Fatal(err)
}
@ -197,7 +197,7 @@ func TestRender(t *testing.T) {
script := Div(Script("foo()\nbar()\nbaz()"))
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), script); err != nil {
if err := html.Write(&b, script); err != nil {
t.Fatal(err)
}
@ -212,7 +212,7 @@ func TestRender(t *testing.T) {
div := Div("foo")
var b bytes.Buffer
if err := html.Render(&b, div); err != nil {
if err := html.WriteRaw(&b, div); err != nil {
t.Fatal(err)
}
@ -225,7 +225,7 @@ func TestRender(t *testing.T) {
div := Div(42)
var b bytes.Buffer
if err := html.Render(&b, div); err != nil {
if err := html.WriteRaw(&b, div); err != nil {
t.Fatal(err)
}
@ -238,7 +238,7 @@ func TestRender(t *testing.T) {
div := Div(Div, "foo")
var b bytes.Buffer
if err := html.Render(&b, div); err != nil {
if err := html.WriteRaw(&b, div); err != nil {
t.Fatal(err)
}
@ -251,7 +251,7 @@ func TestRender(t *testing.T) {
div := Div(Span, "foo")
var b bytes.Buffer
if err := html.Render(&b, div); err != nil {
if err := html.WriteRaw(&b, div); err != nil {
t.Fatal(err)
}
@ -264,7 +264,7 @@ func TestRender(t *testing.T) {
span := Span("foo")
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), span); err != nil {
if err := html.Write(&b, span); err != nil {
t.Fatal(err)
}
@ -277,7 +277,7 @@ func TestRender(t *testing.T) {
span := Span(42)
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), span); err != nil {
if err := html.Write(&b, span); err != nil {
t.Fatal(err)
}
@ -290,7 +290,7 @@ func TestRender(t *testing.T) {
span := Span(Div, "foo")
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), span); err != nil {
if err := html.Write(&b, span); err != nil {
t.Fatal(err)
}
@ -303,7 +303,7 @@ func TestRender(t *testing.T) {
span := Span(Span, "foo")
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), span); err != nil {
if err := html.Write(&b, span); err != nil {
t.Fatal(err)
}
@ -316,7 +316,7 @@ func TestRender(t *testing.T) {
span := Span(Div, Span("foo"))
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), span); err != nil {
if err := html.Write(&b, span); err != nil {
t.Fatal(err)
}
@ -329,7 +329,7 @@ func TestRender(t *testing.T) {
p := P("foo")
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), p); err != nil {
if err := html.Write(&b, p); err != nil {
t.Fatal(err)
}
@ -342,7 +342,7 @@ func TestRender(t *testing.T) {
p := P(42)
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), p); err != nil {
if err := html.Write(&b, p); err != nil {
t.Fatal(err)
}
@ -355,7 +355,7 @@ func TestRender(t *testing.T) {
p := P(P, "foo")
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), p); err != nil {
if err := html.Write(&b, p); err != nil {
t.Fatal(err)
}
@ -368,7 +368,7 @@ func TestRender(t *testing.T) {
div := Div("foo")
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), div); err != nil {
if err := html.Write(&b, div); err != nil {
t.Fatal(err)
}
@ -381,7 +381,7 @@ func TestRender(t *testing.T) {
div := Div(42)
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), div); err != nil {
if err := html.Write(&b, div); err != nil {
t.Fatal(err)
}
@ -394,7 +394,7 @@ func TestRender(t *testing.T) {
div := Div(Div, 42)
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), div); err != nil {
if err := html.Write(&b, div); err != nil {
t.Fatal(err)
}
@ -407,7 +407,7 @@ func TestRender(t *testing.T) {
div := Div(Span, 42)
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), div); err != nil {
if err := html.Write(&b, div); err != nil {
t.Fatal(err)
}
@ -422,7 +422,7 @@ func TestRender(t *testing.T) {
div := Div("foo", nil, "bar")
var b bytes.Buffer
if err := html.Render(&b, div); err != nil {
if err := html.WriteRaw(&b, div); err != nil {
t.Fatal(err)
}
@ -435,7 +435,7 @@ func TestRender(t *testing.T) {
div := html.Verbatim(Div("foo &", nil, " bar"))
var b bytes.Buffer
if err := html.Render(&b, div); err != nil {
if err := html.WriteRaw(&b, div); err != nil {
t.Fatal(err)
}
@ -448,7 +448,7 @@ func TestRender(t *testing.T) {
script := Script("let foo =", nil, " bar && baz")
var b bytes.Buffer
if err := html.Render(&b, script); err != nil {
if err := html.WriteRaw(&b, script); err != nil {
t.Fatal(err)
}
@ -461,7 +461,7 @@ func TestRender(t *testing.T) {
span := Span("foo", nil, "bar")
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), span); err != nil {
if err := html.Write(&b, span); err != nil {
t.Fatal(err)
}
@ -474,7 +474,7 @@ func TestRender(t *testing.T) {
span := html.Verbatim(Span("foo &", nil, " bar"))
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), span); err != nil {
if err := html.Write(&b, span); err != nil {
t.Fatal(err)
}
@ -487,7 +487,7 @@ func TestRender(t *testing.T) {
script := html.Inline(Script("let foo =", nil, " bar && baz"))
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), script); err != nil {
if err := html.Write(&b, script); err != nil {
t.Fatal(err)
}
@ -500,7 +500,7 @@ func TestRender(t *testing.T) {
div := Div("foo", nil, "bar")
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), div); err != nil {
if err := html.Write(&b, div); err != nil {
t.Fatal(err)
}
@ -513,7 +513,7 @@ func TestRender(t *testing.T) {
div := html.Verbatim(Div("foo &", nil, " bar"))
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), div); err != nil {
if err := html.Write(&b, div); err != nil {
t.Fatal(err)
}
@ -526,7 +526,7 @@ func TestRender(t *testing.T) {
script := Script("let foo =", nil, " bar && baz")
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), script); err != nil {
if err := html.Write(&b, script); err != nil {
t.Fatal(err)
}
@ -541,7 +541,7 @@ func TestRender(t *testing.T) {
div := Div("foo", "", "bar")
var b bytes.Buffer
if err := html.Render(&b, div); err != nil {
if err := html.WriteRaw(&b, div); err != nil {
t.Fatal(err)
}
@ -554,7 +554,7 @@ func TestRender(t *testing.T) {
div := html.Verbatim(Div("foo &", "", " bar"))
var b bytes.Buffer
if err := html.Render(&b, div); err != nil {
if err := html.WriteRaw(&b, div); err != nil {
t.Fatal(err)
}
@ -567,7 +567,7 @@ func TestRender(t *testing.T) {
script := Script("let foo =", "", " bar && baz")
var b bytes.Buffer
if err := html.Render(&b, script); err != nil {
if err := html.WriteRaw(&b, script); err != nil {
t.Fatal(err)
}
@ -580,7 +580,7 @@ func TestRender(t *testing.T) {
span := Span("foo", "", "bar")
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), span); err != nil {
if err := html.Write(&b, span); err != nil {
t.Fatal(err)
}
@ -593,7 +593,7 @@ func TestRender(t *testing.T) {
span := html.Verbatim(Span("foo &", "", " bar"))
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), span); err != nil {
if err := html.Write(&b, span); err != nil {
t.Fatal(err)
}
@ -606,7 +606,7 @@ func TestRender(t *testing.T) {
script := html.Inline(Script("let foo =", "", " bar && baz"))
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), script); err != nil {
if err := html.Write(&b, script); err != nil {
t.Fatal(err)
}
@ -619,7 +619,7 @@ func TestRender(t *testing.T) {
div := Div("foo", "", "bar")
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), div); err != nil {
if err := html.Write(&b, div); err != nil {
t.Fatal(err)
}
@ -632,7 +632,7 @@ func TestRender(t *testing.T) {
div := html.Verbatim(Div("foo &", "", " bar"))
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), div); err != nil {
if err := html.Write(&b, div); err != nil {
t.Fatal(err)
}
@ -645,7 +645,7 @@ func TestRender(t *testing.T) {
script := Script("let foo =", "", " bar && baz")
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), script); err != nil {
if err := html.Write(&b, script); err != nil {
t.Fatal(err)
}
@ -661,7 +661,7 @@ func TestRender(t *testing.T) {
div := Div(rd)
var b bytes.Buffer
if err := html.Render(&b, div); err != nil {
if err := html.WriteRaw(&b, div); err != nil {
t.Fatal(err)
}
@ -675,7 +675,7 @@ func TestRender(t *testing.T) {
div := html.Verbatim(Div(rd))
var b bytes.Buffer
if err := html.Render(&b, div); err != nil {
if err := html.WriteRaw(&b, div); err != nil {
t.Fatal(err)
}
@ -689,7 +689,7 @@ func TestRender(t *testing.T) {
script := Script(rd)
var b bytes.Buffer
if err := html.Render(&b, script); err != nil {
if err := html.WriteRaw(&b, script); err != nil {
t.Fatal(err)
}
@ -703,7 +703,7 @@ func TestRender(t *testing.T) {
span := Span(rd)
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), span); err != nil {
if err := html.Write(&b, span); err != nil {
t.Fatal(err)
}
@ -717,7 +717,7 @@ func TestRender(t *testing.T) {
span := html.Verbatim(Span(rd))
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), span); err != nil {
if err := html.Write(&b, span); err != nil {
t.Fatal(err)
}
@ -731,7 +731,7 @@ func TestRender(t *testing.T) {
script := html.Inline(Script(rd))
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), script); err != nil {
if err := html.Write(&b, script); err != nil {
t.Fatal(err)
}
@ -745,7 +745,7 @@ func TestRender(t *testing.T) {
span := Span(Div, rd)
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), span); err != nil {
if err := html.Write(&b, span); err != nil {
t.Fatal(err)
}
@ -759,7 +759,7 @@ func TestRender(t *testing.T) {
div := Div(rd)
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), div); err != nil {
if err := html.Write(&b, div); err != nil {
t.Fatal(err)
}
@ -773,7 +773,7 @@ func TestRender(t *testing.T) {
div := html.Verbatim(Div(rd))
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), div); err != nil {
if err := html.Write(&b, div); err != nil {
t.Fatal(err)
}
@ -787,7 +787,7 @@ func TestRender(t *testing.T) {
script := Script(rd)
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), script); err != nil {
if err := html.Write(&b, script); err != nil {
t.Fatal(err)
}
@ -800,7 +800,7 @@ func TestRender(t *testing.T) {
t.Run("void", func(t *testing.T) {
t.Run("unindented", func(t *testing.T) {
var b bytes.Buffer
if err := html.Render(&b, Br); err != nil {
if err := html.WriteRaw(&b, Br); err != nil {
t.Fatal(err)
}
@ -811,7 +811,7 @@ func TestRender(t *testing.T) {
t.Run("inline", func(t *testing.T) {
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), Br); err != nil {
if err := html.Write(&b, Br); err != nil {
t.Fatal(err)
}
@ -822,7 +822,7 @@ func TestRender(t *testing.T) {
t.Run("block", func(t *testing.T) {
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), Hr); err != nil {
if err := html.Write(&b, Hr); err != nil {
t.Fatal(err)
}
@ -835,7 +835,7 @@ func TestRender(t *testing.T) {
t.Run("no children", func(t *testing.T) {
t.Run("unindented", func(t *testing.T) {
var b bytes.Buffer
if err := html.Render(&b, Div); err != nil {
if err := html.WriteRaw(&b, Div); err != nil {
t.Fatal(err)
}
@ -846,7 +846,7 @@ func TestRender(t *testing.T) {
t.Run("inline", func(t *testing.T) {
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), Span); err != nil {
if err := html.Write(&b, Span); err != nil {
t.Fatal(err)
}
@ -857,7 +857,7 @@ func TestRender(t *testing.T) {
t.Run("block", func(t *testing.T) {
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), Div); err != nil {
if err := html.Write(&b, Div); err != nil {
t.Fatal(err)
}
@ -872,7 +872,7 @@ func TestRender(t *testing.T) {
div := html.Verbatim(Div("foo & bar"))
var b bytes.Buffer
if err := html.Render(&b, div); err != nil {
if err := html.WriteRaw(&b, div); err != nil {
t.Fatal(err)
}
@ -885,7 +885,7 @@ func TestRender(t *testing.T) {
span := html.Verbatim(Span("foo & bar"))
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), span); err != nil {
if err := html.Write(&b, span); err != nil {
t.Fatal(err)
}
@ -898,7 +898,7 @@ func TestRender(t *testing.T) {
div := html.Verbatim(Div("foo & bar"))
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), div); err != nil {
if err := html.Write(&b, div); err != nil {
t.Fatal(err)
}
@ -908,12 +908,108 @@ func TestRender(t *testing.T) {
})
})
t.Run("preformatted", func(t *testing.T) {
t.Run("simple", func(t *testing.T) {
pre := Pre("foo\nbar")
var b bytes.Buffer
if err := html.Write(&b, pre); err != nil {
t.Fatal(err)
}
if b.String() != "<pre>\nfoo\nbar\n</pre>" {
t.Fatal(b.String())
}
})
t.Run("indented", func(t *testing.T) {
div := Div(Pre("foo\nbar"))
var b bytes.Buffer
if err := html.Write(&b, div); err != nil {
t.Fatal(err)
}
if b.String() != "<div>\n\t<pre>\nfoo\nbar\n\t</pre>\n</div>" {
t.Fatal(b.String())
}
})
t.Run("child elements", func(t *testing.T) {
div := Div(Pre("foo", Div("bar\n\t", Span("baz\n"), " "), "\t"))
var b bytes.Buffer
if err := html.Write(&b, div); err != nil {
t.Fatal(err)
}
const expect = "<div>\n\t<pre>\nfoo<div>bar\n\t<span>baz\n</span> </div>\t\n\t</pre>\n</div>"
if b.String() != expect {
t.Fatal(b.String())
}
})
t.Run("escaping", func(t *testing.T) {
pre := Pre("foo & ", Span("baz & "), "qux")
var b bytes.Buffer
if err := html.Write(&b, pre); err != nil {
t.Fatal(err)
}
if b.String() != "<pre>\nfoo &amp; <span>baz &amp; </span>qux\n</pre>" {
t.Fatal(b.String())
}
})
t.Run("verbatim child element", func(t *testing.T) {
div := html.Verbatim(Div)
pre := Pre("foo", div("<span>\n\tbar\t\n</span>"), "baz")
var b bytes.Buffer
if err := html.Write(&b, pre); err != nil {
t.Fatal(err)
}
if b.String() != "<pre>\nfoo<div><span>\n\tbar\t\n</span></div>baz\n</pre>" {
t.Fatal(b.String())
}
})
t.Run("verbatim", func(t *testing.T) {
pre := html.Verbatim(Pre)
pre = pre("<div>\n <span>foo</span>\n</div>")
var b bytes.Buffer
if err := html.Write(&b, pre); err != nil {
t.Fatal(err)
}
if b.String() != "<pre>\n<div>\n <span>foo</span>\n</div>\n</pre>" {
t.Fatal(b.String())
}
})
t.Run("reader child", func(t *testing.T) {
pre := Pre(bytes.NewBufferString("foo &\nbar &\nbaz"))
var b bytes.Buffer
if err := html.Write(&b, pre); err != nil {
t.Fatal(err)
}
if b.String() != "<pre>\nfoo &amp;\nbar &amp;\nbaz\n</pre>" {
t.Fatal(b.String())
}
})
})
t.Run("script", func(t *testing.T) {
t.Run("unindented", func(t *testing.T) {
script := Script("let foo = bar && baz")
var b bytes.Buffer
if err := html.Render(&b, script); err != nil {
if err := html.WriteRaw(&b, script); err != nil {
t.Fatal(err)
}
@ -926,7 +1022,7 @@ func TestRender(t *testing.T) {
script := html.Inline(Script("let foo = bar && baz"))
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), script); err != nil {
if err := html.Write(&b, script); err != nil {
t.Fatal(err)
}
@ -939,7 +1035,7 @@ func TestRender(t *testing.T) {
script := Script("let foo = bar && baz")
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indent(), script); err != nil {
if err := html.Write(&b, script); err != nil {
t.Fatal(err)
}
@ -954,7 +1050,7 @@ func TestRender(t *testing.T) {
p := P("foo bar baz qux quux corge")
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indentation{Indent: "\t", PWidth: 15}, p); err != nil {
if err := html.WriteIndent(&b, html.Indentation{Indent: "\t", PWidth: 15}, p); err != nil {
t.Error(err)
}
@ -967,7 +1063,7 @@ func TestRender(t *testing.T) {
div := Div(P("foo bar baz qux quux corge"))
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indentation{Indent: "\t", PWidth: 21, MinPWidth: 18}, div); err != nil {
if err := html.WriteIndent(&b, html.Indentation{Indent: "\t", PWidth: 21, MinPWidth: 18}, div); err != nil {
t.Error(err)
}
@ -980,7 +1076,7 @@ func TestRender(t *testing.T) {
span := Span(P("foo bar baz qux quux corge"))
var b bytes.Buffer
if err := html.RenderIndent(&b, html.Indentation{Indent: "\t", PWidth: 21, MinPWidth: 18}, span); err != nil {
if err := html.WriteIndent(&b, html.Indentation{Indent: "\t", PWidth: 21, MinPWidth: 18}, span); err != nil {
t.Error(err)
}

1
tag.block.txt
View File

@ -34,7 +34,6 @@ noscript
ol
optgroup
picture
pre
q
search
section

1
tag.preformatted.txt Normal file
View File

@ -0,0 +1 @@
pre

1
tag/block.gen.go
View File

@ -40,7 +40,6 @@ var Noscript = html.Define("noscript")
var Ol = html.Define("ol")
var Optgroup = html.Define("optgroup")
var Picture = html.Define("picture")
var Pre = html.Define("pre")
var Q = html.Define("q")
var Search = html.Define("search")
var Section = html.Define("section")

7
tag/preformatted.gen.go Normal file
View File

@ -0,0 +1,7 @@
// generated by ../script/generate-tags.go
package tag
import "code.squareroundforest.org/arpio/html"
var Pre = html.Preformatted(html.Define("pre"))

28
validate_test.go
View File

@ -13,7 +13,7 @@ func TestValidate(t *testing.T) {
mytag := html.Define("foo+bar")
var b bytes.Buffer
if err := html.Render(&b, mytag); err == nil {
if err := html.WriteRaw(&b, mytag); err == nil {
t.Fatal()
}
})
@ -22,7 +22,7 @@ func TestValidate(t *testing.T) {
mytag := html.Define("0foo")
var b bytes.Buffer
if err := html.Render(&b, mytag); err == nil {
if err := html.WriteRaw(&b, mytag); err == nil {
t.Fatal()
}
})
@ -31,7 +31,7 @@ func TestValidate(t *testing.T) {
mytag := html.Define("-foo")
var b bytes.Buffer
if err := html.Render(&b, mytag); err == nil {
if err := html.WriteRaw(&b, mytag); err == nil {
t.Fatal()
}
})
@ -40,7 +40,7 @@ func TestValidate(t *testing.T) {
mytag := html.Define("foo")
var b bytes.Buffer
if err := html.Render(&b, mytag); err != nil {
if err := html.WriteRaw(&b, mytag); err != nil {
t.Fatal(err)
}
})
@ -49,7 +49,7 @@ func TestValidate(t *testing.T) {
mytag := html.Define("foo-bar-1")
var b bytes.Buffer
if err := html.Render(&b, mytag); err != nil {
if err := html.WriteRaw(&b, mytag); err != nil {
t.Fatal(err)
}
})
@ -59,7 +59,7 @@ func TestValidate(t *testing.T) {
div := Div(Attr("foo+", "bar"))
var b bytes.Buffer
if err := html.Render(&b, div); err == nil {
if err := html.WriteRaw(&b, div); err == nil {
t.Fatal()
}
})
@ -68,7 +68,7 @@ func TestValidate(t *testing.T) {
br := Br("foo")
var b bytes.Buffer
if err := html.Render(&b, br); err == nil {
if err := html.WriteRaw(&b, br); err == nil {
t.Fatal()
}
})
@ -77,7 +77,7 @@ func TestValidate(t *testing.T) {
div := html.Verbatim(Div(Br()))
var b bytes.Buffer
if err := html.Render(&b, div); err != nil {
if err := html.WriteRaw(&b, div); err != nil {
t.Fatal(err)
}
})
@ -86,7 +86,7 @@ func TestValidate(t *testing.T) {
script := Script(Br())
var b bytes.Buffer
if err := html.Render(&b, script); err == nil {
if err := html.WriteRaw(&b, script); err == nil {
t.Fatal()
}
})
@ -95,7 +95,7 @@ func TestValidate(t *testing.T) {
div := Div(Div(Attr("foo+", "bar")))
var b bytes.Buffer
if err := html.Render(&b, div); err == nil {
if err := html.WriteRaw(&b, div); err == nil {
t.Fatal()
}
})
@ -104,7 +104,7 @@ func TestValidate(t *testing.T) {
div := Div(Div(Attr("foo", "bar")))
var b bytes.Buffer
if err := html.Render(&b, div); err != nil {
if err := html.WriteRaw(&b, div); err != nil {
t.Fatal()
}
})
@ -113,7 +113,7 @@ func TestValidate(t *testing.T) {
decl := html.Declaration("foo", "bar", "baz qux")
var b bytes.Buffer
if err := html.Render(&b, decl); err != nil {
if err := html.WriteRaw(&b, decl); err != nil {
t.Fatal(err)
}
})
@ -122,7 +122,7 @@ func TestValidate(t *testing.T) {
decl := html.Declaration("#", "foo")
var b bytes.Buffer
if err := html.Render(&b, decl); err != nil {
if err := html.WriteRaw(&b, decl); err != nil {
t.Fatal(err)
}
})
@ -132,7 +132,7 @@ func TestValidate(t *testing.T) {
decl = decl("bar")
var b bytes.Buffer
if err := html.Render(&b, decl); err == nil {
if err := html.WriteRaw(&b, decl); err == nil {
t.Fatal("failed to fail")
}
})

25
wrap_test.go
View File

@ -10,7 +10,7 @@ import (
func TestWrap(t *testing.T) {
t.Run("write error", func(t *testing.T) {
ew := &errorWriter{failAfter: 9}
if err := html.RenderIndent(
if err := html.WriteIndent(
ew,
html.Indentation{Indent: "\t", PWidth: 12},
Span(Span("foo"), Span("bar"), Span("baz")),
@ -21,7 +21,7 @@ func TestWrap(t *testing.T) {
t.Run("write error in text", func(t *testing.T) {
ew := &errorWriter{}
if err := html.RenderIndent(
if err := html.WriteIndent(
ew,
html.Indentation{Indent: "\t", PWidth: 2},
Span("foo", "bar", "baz"),
@ -32,7 +32,7 @@ func TestWrap(t *testing.T) {
t.Run("write error on line feed", func(t *testing.T) {
ew := &errorWriter{failAfter: 7}
if err := html.RenderIndent(
if err := html.WriteIndent(
ew,
html.Indentation{Indent: "\t", PWidth: 3},
Span("foo"),
@ -43,7 +43,7 @@ func TestWrap(t *testing.T) {
t.Run("write error on indentation", func(t *testing.T) {
ew := &errorWriter{failAfter: 15}
if err := html.RenderIndent(
if err := html.WriteIndent(
ew,
html.Indentation{Indent: "\t", PWidth: 3},
Div(Span("foo")),
@ -54,9 +54,8 @@ func TestWrap(t *testing.T) {
t.Run("write error on flush", func(t *testing.T) {
ew := &errorWriter{}
if err := html.RenderIndent(
if err := html.Write(
ew,
html.Indent(),
Span(Span("foo"), Span("bar"), Span("baz")),
); err == nil {
t.Fatal()
@ -65,7 +64,7 @@ func TestWrap(t *testing.T) {
t.Run("write error on flush during line feed", func(t *testing.T) {
ew := &errorWriter{}
if err := html.RenderIndent(
if err := html.WriteIndent(
ew,
html.Indentation{Indent: "\t", PWidth: 10},
Span("foo bar", Div),
@ -76,7 +75,7 @@ func TestWrap(t *testing.T) {
t.Run("null write", func(t *testing.T) {
var buf bytes.Buffer
if err := html.Render(&buf, Div("")); err != nil {
if err := html.WriteRaw(&buf, Div("")); err != nil {
t.Fatal(err)
}
@ -89,7 +88,7 @@ func TestWrap(t *testing.T) {
span := Span("foo bar baz")
var buf bytes.Buffer
if err := html.RenderIndent(&buf, html.Indentation{Indent: "\t", PWidth: 2}, span); err != nil {
if err := html.WriteIndent(&buf, html.Indentation{Indent: "\t", PWidth: 2}, span); err != nil {
t.Fatal(err)
}
@ -104,7 +103,7 @@ func TestWrap(t *testing.T) {
span := Span("foo ", Span("bar", Attr("qux", 42)), " baz")
var buf bytes.Buffer
if err := html.RenderIndent(&buf, html.Indentation{Indent: "X", PWidth: 2}, span); err != nil {
if err := html.WriteIndent(&buf, html.Indentation{Indent: "X", PWidth: 2}, span); err != nil {
t.Fatal(err)
}
@ -117,7 +116,7 @@ func TestWrap(t *testing.T) {
div := Div(Span("foo bar baz qux quux corge"))
var buf bytes.Buffer
if err := html.RenderIndent(&buf, html.Indentation{Indent: "\t", PWidth: 15}, div); err != nil {
if err := html.WriteIndent(&buf, html.Indentation{Indent: "\t", PWidth: 15}, div); err != nil {
t.Fatal(err)
}
@ -130,7 +129,7 @@ func TestWrap(t *testing.T) {
div := Div(Span("foo"), " ", Span("bar"))
var buf bytes.Buffer
if err := html.RenderIndent(&buf, html.Indent(), div); err != nil {
if err := html.Write(&buf, div); err != nil {
t.Fatal(err)
}
@ -143,7 +142,7 @@ func TestWrap(t *testing.T) {
div := Div("foo\nbar\tbaz")
var buf bytes.Buffer
if err := html.RenderIndent(&buf, html.Indent(), div); err != nil {
if err := html.Write(&buf, div); err != nil {
t.Fatal(err)
}