diff --git a/Makefile b/Makefile
index 93d55d6..87c189e 100644
--- a/Makefile
+++ b/Makefile
@@ -7,7 +7,7 @@ all: clean fmt build cover
build: $(SOURCES) tags promote-to-tags
go build
-tags: tags/block.gen.go tags/inline.gen.go tags/void.block.gen.go tags/void.inline.gen.go tags/script.gen.go
+tags: tags/block.gen.go tags/inline.gen.go tags/void.block.gen.go tags/void.inline.gen.go tags/inlinechildren.gen.go tags/script.gen.go
promote-to-tags: tags/promote.gen.go
@@ -17,6 +17,9 @@ tags/block.gen.go: $(SOURCES) tags.block.txt
tags/inline.gen.go: $(SOURCES) tags.inline.txt
go run script/generate-tags.go Inline < tags.inline.txt > tags/inline.gen.go
+tags/inlinechildren.gen.go: $(SOURCES) tags.inlinechildren.txt
+ go run script/generate-tags.go InlineChildren < tags.inlinechildren.txt > tags/inlinechildren.gen.go
+
tags/void.block.gen.go: $(SOURCES) tags.void.block.txt
go run script/generate-tags.go Void < tags.void.block.txt > tags/void.block.gen.go
diff --git a/lib.go b/lib.go
index 1afee05..405c844 100644
--- a/lib.go
+++ b/lib.go
@@ -2,6 +2,7 @@
package html
import (
+ "bytes"
"fmt"
"io"
"strings"
@@ -22,6 +23,21 @@ type Tag func(...any) Tag
type Template[Data any] func(Data) Tag
+type Indentation struct {
+ PWidth int
+ MinPWidth int
+
+ // not used for the top level
+ Indent string
+}
+
+func (t Tag) String() string {
+ buf := bytes.NewBuffer(nil)
+ r := renderer{out: buf}
+ t()(r)
+ return buf.String()
+}
+
// convenience function primarily aimed to help with construction of html with tags
// the names and values are applied using fmt.Sprint, tolerating fmt.Stringer implementations
func Attr(a ...any) Attributes {
@@ -38,19 +54,41 @@ func Attr(a ...any) Attributes {
}
// defines a new tag with name and initial attributes and child nodes
-func NewTag(name string, children ...any) Tag {
+func Define(name string, children ...any) Tag {
if handleQuery(name, children) {
children = children[:len(children)-1]
}
return func(children1 ...any) Tag {
- if name == "br" {
- }
-
- return NewTag(name, append(children, children1...)...)
+ return Define(name, append(children, children1...)...)
}
}
+func Declaration(children ...any) Tag {
+ var name string
+ if len(children) == 0 {
+ name = "!"
+ } else {
+ name, children = fmt.Sprintf("!%v", children[0]), children[1:]
+ }
+
+ a := make([]any, len(children)*2)
+ for i, c := range children {
+ a[2*i] = c
+ a[2*i+1] = true
+ }
+
+ return Void(Define(name, Attr(a...)))
+}
+
+func Doctype(children ...any) Tag {
+ return Declaration(append([]any{"doctype"}, children...)...)
+}
+
+func Comment(children ...any) Tag {
+ return Inline(Declaration(append(append([]any{"--"}, children...), "--")))
+}
+
// returns the name of a tag
func Name(t Tag) string {
q := nameQuery{}
@@ -89,7 +127,7 @@ func DeleteAttribute(t Tag, name string) Tag {
a := AllAttributes(t)
c := Children(t)
delete(a, name)
- return NewTag(n, append(c, a)...)
+ return Define(n, append(c, a)...)
}
// the same as Attribute(t, "class")
@@ -141,15 +179,29 @@ func Children(t Tag) []any {
// consecutive spaces are considered to be so on purpose, and are converted into
// spaces around tags can behave different from when using unindented rendering
// as a last resort, one can use rendered html inside a verbatim tag
-func RenderIndent(out io.Writer, indent string, pwidth int, t Tag) error {
- r := renderer{out: out, indent: indent, pwidth: pwidth}
+func RenderIndent(out io.Writer, indent Indentation, t Tag) error {
+ if indent.PWidth < indent.MinPWidth {
+ indent.PWidth = indent.MinPWidth
+ }
+
+ if indent.Indent != "" && indent.PWidth == 0 {
+ indent.PWidth = 120
+ indent.MinPWidth = 60
+ }
+
+ r := renderer{
+ out: out,
+ indent: indent,
+ pwidth: indent.PWidth,
+ }
+
t()(&r)
return r.err
}
// renders html with t as the root node without indentation
func Render(out io.Writer, t Tag) error {
- return RenderIndent(out, "", 0, t)
+ return RenderIndent(out, Indentation{}, t)
}
// creates a new tag from t marking it verbatim. The content of verbatim tags is rendered without HTML escaping.
@@ -165,7 +217,7 @@ func ScriptContent(t Tag) Tag {
}
func InlineChildren(t Tag) Tag {
- return t
+ return t()(renderGuide{inlineChildren: true})
}
// inline tags are not broken into separate lines when rendering with indentation
@@ -192,15 +244,15 @@ func Eq(t ...Tag) bool {
}
// turns a template into a tag for composition
-func FromTemplate[Data any](f Template[Data]) Tag {
+func FromTemplate[Data any](t Template[Data]) Tag {
return func(a ...any) Tag {
var (
- t Data
+ d Data
ok bool
)
for i := range a {
- t, ok = a[0].(Data)
+ d, ok = a[0].(Data)
if !ok {
continue
}
@@ -209,33 +261,24 @@ func FromTemplate[Data any](f Template[Data]) Tag {
break
}
- return f(t)(a...)
+ return t(d)(a...)
}
}
// in the functional programming sense
-func Map[Data any](data []Data, tag Tag, tags ...Tag) []Tag {
+func Map[Data any](data []Data, tag Tag) []Tag {
var ret []Tag
for _, d := range data {
- var retd Tag
- for i := len(tags) - 1; i >= 0; i-- {
- retd = tags[i](d)
- }
-
- if retd == nil {
- retd = tag(d)
- continue
- }
-
- retd = tag(retd)
+ ret = append(ret, tag(d))
}
return ret
}
-func MapChildren[Data any](data []Data, tag Tag, tags ...Tag) []any {
+func MapChildren[Data any](data []Data, tag Tag) []any {
+ c := Map(data, tag)
+
var a []any
- c := Map(data, tag, tags...)
for _, ci := range c {
a = append(a, ci)
}
diff --git a/lib_test.go b/lib_test.go
index b5df03a..d7231d1 100644
--- a/lib_test.go
+++ b/lib_test.go
@@ -1,10 +1,11 @@
package html_test
import (
+ "bytes"
"code.squareroundforest.org/arpio/html"
. "code.squareroundforest.org/arpio/html/tags"
"testing"
- "bytes"
+ "code.squareroundforest.org/arpio/notation"
)
func TestLib(t *testing.T) {
@@ -57,17 +58,13 @@ func TestLib(t *testing.T) {
}
var b bytes.Buffer
- if err := html.RenderIndent(&b, "\t", 0, teamHTML(myTeam)); err != nil {
+ if err := html.RenderIndent(&b, html.Indentation{Indent: "\t"}, teamHTML(myTeam)); err != nil {
t.Fatal(err)
}
- if b.String() != `
-
- Foo
-
-
- Rank: 3
-
+ const expect = `
-` {
+
\n\tfoo\n
\n" {
+ if b.String() != "\n\tfoo\n
" {
t.Fatal(b.String())
}
})
diff --git a/render.go b/render.go
index fbbf3d8..31421dd 100644
--- a/render.go
+++ b/render.go
@@ -1,23 +1,28 @@
package html
import (
- "bytes"
"fmt"
"io"
+ "strings"
)
-const defaultPWidth = 112
+const (
+ defaultPWidth = 112
+ unicodeNBSP = 0xa0
+)
type renderGuide struct {
- inline bool
- void bool
- script bool
- verbatim bool
+ inline bool
+ inlineChildren bool
+ void bool
+ script bool
+ verbatim bool
}
type renderer struct {
out io.Writer
- indent string
+ originalOut io.Writer
+ indent Indentation
pwidth int
currentIndent string
err error
@@ -27,6 +32,7 @@ func mergeRenderingGuides(rgs []renderGuide) renderGuide {
var rg renderGuide
for _, rgi := range rgs {
rg.inline = rg.inline || rgi.inline
+ rg.inlineChildren = rg.inlineChildren || rgi.inlineChildren
rg.void = rg.void || rgi.void
rg.script = rg.script || rgi.script
rg.verbatim = rg.verbatim || rgi.verbatim
@@ -67,7 +73,9 @@ func htmlEscape(s string) string {
rr = append(rr, []rune(">")...)
case '&':
rr = append(rr, []rune("&")...)
- case ' ', 0xA0:
+ case unicodeNBSP:
+ rr = append(rr, []rune(" ")...)
+ case ' ':
if wsStart && lastWS {
rr = append(rr[:len(rr)-1], []rune(" ")...)
} else if lastWS {
@@ -79,7 +87,7 @@ func htmlEscape(s string) string {
rr = append(rr, r[i])
}
- ws := r[i] == ' ' || r[i] == 0xA0
+ ws := r[i] == ' '
wsStart = ws && !lastWS
lastWS = ws
}
@@ -87,12 +95,317 @@ func htmlEscape(s string) string {
return string(rr)
}
-func render(r *renderer, name string, children []any) {
+func indentLines(indent string, s string) string {
+ l := strings.Split(s, "\n")
+ for i := range l {
+ l[i] = fmt.Sprintf("%s%s", indent, l[i])
+ }
+
+ return strings.Join(l, "\n")
+}
+
+func (r *renderer) getPrintf(tagName string) func(f string, a ...any) {
+ return func(f string, a ...any) {
+ if r.err != nil {
+ return
+ }
+
+ _, r.err = fmt.Fprintf(r.out, f, a...)
+ if r.err != nil {
+ r.err = fmt.Errorf("tag %s: %w", tagName, r.err)
+ }
+ }
+}
+
+func (r *renderer) renderAttributes(tagName string, a []Attributes) {
+ printf := r.getPrintf(tagName)
+ for _, ai := range a {
+ for name, value := range ai {
+ printf(" %s=\"%s\"", name, attributeEscape(value))
+ }
+ }
+}
+
+func (r *renderer) renderUnindented(name string, rg renderGuide, a []Attributes, children []any) {
+ printf := r.getPrintf(name)
+ printf("<%s", name)
+ r.renderAttributes(name, a)
+ printf(">")
+ if rg.void {
+ return
+ }
+
+ for _, c := range children {
+ if ct, ok := c.(Tag); ok {
+ ct(r)
+ continue
+ }
+
+ s := fmt.Sprint(c)
+ if s == "" {
+ continue
+ }
+
+ if !rg.verbatim && !rg.script {
+ s = htmlEscape(s)
+ }
+
+ printf(s)
+ }
+
+ printf("", name)
+}
+
+func (r *renderer) ensureWrapper() bool {
+ if _, ok := r.out.(*wrapper); ok {
+ return false
+ }
+
+ r.originalOut = r.out
+ r.out = newWrapper(r.originalOut, r.pwidth, r.currentIndent)
+ return true
+}
+
+func (r *renderer) clearWrapper() {
+ w, ok := r.out.(*wrapper)
+ if !ok {
+ return
+ }
+
+ if err := w.Flush(); err != nil {
+ r.err = err
+ }
+
+ r.out = r.originalOut
+}
+
+func (r *renderer) renderInline(name string, rg renderGuide, a []Attributes, children []any) {
+ newWrapper := r.ensureWrapper()
+ printf := r.getPrintf(name)
+ printf("<%s", name)
+ r.renderAttributes(name, a)
+ printf(">")
+ if rg.void {
+ if newWrapper {
+ r.clearWrapper()
+ }
+
+ return
+ }
+
+ var lastBlock bool
+ for _, c := range children {
+ ct, isTag := c.(Tag)
+ if !isTag && rg.verbatim {
+ s := fmt.Sprint(c)
+ if s == "" {
+ continue
+ }
+
+ r.clearWrapper()
+ s = indentLines(r.currentIndent+r.indent.Indent, s)
+ printf("\n%s", s)
+ lastBlock = true
+ continue
+ }
+
+ if !isTag && rg.script {
+ s := fmt.Sprint(c)
+ if s == "" {
+ continue
+ }
+
+ r.clearWrapper()
+ printf("\n%s", s)
+ lastBlock = true
+ continue
+ }
+
+ if !isTag {
+ s := fmt.Sprint(c)
+ if s == "" {
+ continue
+ }
+
+ if lastBlock {
+ printf("\n%s", r.currentIndent)
+ }
+
+ if r.ensureWrapper() {
+ newWrapper = true
+ }
+
+ s = htmlEscape(s)
+ printf(s)
+ lastBlock = false
+ continue
+ }
+
+ var rgq renderGuidesQuery
+ ct(&rgq)
+ crg := mergeRenderingGuides(rgq.value)
+ if crg.inline {
+ if lastBlock {
+ printf("\n%s", r.currentIndent)
+ }
+
+ if r.ensureWrapper() {
+ newWrapper = true
+ }
+
+ ct(r)
+ lastBlock = false
+ continue
+ }
+
+ r.clearWrapper()
+ cr := new(renderer)
+ *cr = *r
+ cr.currentIndent += cr.indent.Indent
+ cr.pwidth -= len([]rune(cr.indent.Indent))
+ if cr.pwidth < cr.indent.MinPWidth {
+ cr.pwidth = cr.indent.MinPWidth
+ }
+
+ printf("\n%s", cr.currentIndent)
+ ct(cr)
+ if cr.err != nil {
+ r.err = cr.err
+ }
+
+ lastBlock = true
+ }
+
+ if lastBlock {
+ printf("\n%s", r.currentIndent)
+ }
+
+ printf("", name)
+ if newWrapper {
+ r.clearWrapper()
+ }
+}
+
+func (r *renderer) renderBlock(name string, rg renderGuide, a []Attributes, children []any) {
+ printf := r.getPrintf(name)
+ printf("<%s", name)
+ r.renderAttributes(name, a)
+ printf(">")
+ if rg.void {
+ return
+ }
+
+ if len(children) == 0 {
+ printf("", name)
+ return
+ }
+
+ lastBlock := true
+ originalIndent, originalWidth := r.currentIndent, r.pwidth
+ r.currentIndent += r.indent.Indent
+ r.pwidth -= len([]rune(r.indent.Indent))
+ if r.pwidth < r.indent.MinPWidth {
+ r.pwidth = r.indent.MinPWidth
+ }
+
+ for _, c := range children {
+ ct, isTag := c.(Tag)
+ if !isTag && rg.verbatim {
+ s := fmt.Sprint(c)
+ if s == "" {
+ continue
+ }
+
+ r.clearWrapper()
+ s = indentLines(r.currentIndent, s)
+ printf("\n%s", s)
+ lastBlock = true
+ continue
+ }
+
+ if !isTag && rg.script {
+ s := fmt.Sprint(c)
+ if s == "" {
+ continue
+ }
+
+ r.clearWrapper()
+ printf("\n%s", s)
+ lastBlock = true
+ continue
+ }
+
+ if !isTag {
+ s := fmt.Sprint(c)
+ if s == "" {
+ continue
+ }
+
+ if lastBlock {
+ printf("\n%s", r.currentIndent)
+ }
+
+ r.ensureWrapper()
+ s = htmlEscape(s)
+ printf(s)
+ lastBlock = false
+ continue
+ }
+
+ var rgq renderGuidesQuery
+ ct(&rgq)
+ crg := mergeRenderingGuides(rgq.value)
+ if crg.inline {
+ if lastBlock {
+ printf("\n%s", r.currentIndent)
+ }
+
+ r.ensureWrapper()
+ ct(r)
+ lastBlock = false
+ continue
+ }
+
+ r.clearWrapper()
+ cr := new(renderer)
+ *cr = *r
+ printf("\n%s", cr.currentIndent)
+ ct(cr)
+ if cr.err != nil {
+ r.err = cr.err
+ }
+
+ lastBlock = true
+ }
+
+ r.clearWrapper()
+ r.currentIndent, r.pwidth = originalIndent, originalWidth
+ printf("\n%s", r.currentIndent, name)
+}
+
+func (r *renderer) render(name string, children []any) {
if r.err != nil {
return
}
- printf := func(f string, a ...any) {
+ a, c, rgs := groupChildren(children)
+ rg := mergeRenderingGuides(rgs)
+ if r.indent.Indent == "" && r.indent.PWidth <= 0 {
+ r.renderUnindented(name, rg, a, c)
+ return
+ }
+
+ if rg.inline || rg.inlineChildren {
+ r.renderInline(name, rg, a, c)
+ return
+ }
+
+ r.renderBlock(name, rg, a, c)
+}
+
+/*
+func getPrintf(out io.Writer) func(f string, a ...any) {
+ return func(f string, a ...any) {
if r.err != nil {
return
}
@@ -102,16 +415,189 @@ func render(r *renderer, name string, children []any) {
r.err = fmt.Errorf("tag %s: %w", name, r.err)
}
}
+}
- a, c, rgs := groupChildren(children)
- rg := mergeRenderingGuides(rgs)
- printf(r.currentIndent)
- printf("<%s", name)
+func renderAttributes(out io.Writer, a []Attributes) {
+ printf := getPrintf(out)
for _, ai := range a {
for name, value := range ai {
printf(" %s=\"%s\"", name, attributeEscape(value))
}
}
+}
+
+func renderUnindented(r *renderer, name string, rg renderGuide, a []Attributes, children []any) {
+ printf := getPrintf(r.out)
+ printf("<%s", name)
+ renderAttributes(r.out, a)
+ printf(">")
+ if rg.void {
+ return
+ }
+
+ for _, c := range children {
+ if ct, ok := c.(Tag); ok {
+ ct(r)
+ continue
+ }
+
+ s := fmt.Sprint(c)
+ if s == "" {
+ continue
+ }
+
+ if !rg.verbatim && !rg.script {
+ s = htmlEscape(s)
+ }
+
+ printf(s)
+ }
+
+ printf("", name)
+}
+
+func renderInline(r *renderer, name string, rg renderGuide, a []Attributes, children []any) {
+ printf := getPrintf(r.out)
+ printf("<%s", name)
+ renderAttributes(r.out, a)
+ printf(">")
+ if rg.void {
+ return
+ }
+
+ for _, c := range children {
+ if ct, ok := c.(Tag); ok {
+ var rgq renderGuidesQuery
+ ct(&rgq)
+ crg := mergeRenderingGuides(rgq.value)
+ if crg.inline {
+ ct(r)
+ continue
+ }
+
+ printf("\n")
+ cr := new(renderer)
+ *cr = *r
+ cr.currentIndent += cr.indent
+ ct(cr)
+ continue
+ }
+
+ s := fmt.Sprint(c)
+ if s == "" {
+ continue
+ }
+
+ if !rg.verbatim && !rg.script {
+ s = htmlEscape(s)
+ }
+
+ printf(s)
+ }
+
+ printf("", name)
+}
+
+func renderBlock(r *renderer, name string, rg renderGuide, a []Attributes, children []any) {
+ if r.direct == nil {
+ r.direct = r.out
+ }
+
+ printf := getPrintf(r.direct)
+ printf(r.currentIndent)
+ printf("<%s", name)
+ renderAttributes(r.direct, a)
+ printf(">")
+ if len(c) == 0 {
+ printf("", name)
+ return
+ }
+
+ if r.indent != "" {
+ printf("\n")
+ }
+
+ var (
+ inlineBuffer bytes.Buffer
+ cr *renderer
+ lastInline bool
+ )
+
+ for i, c := range children {
+ if ct, ok := c.(Tag); ok {
+ var rgq renderGuidesQuery
+ ct(&rgq)
+ crg := mergeRenderingGuides(rgq.value)
+ if crg.inline {
+ if cr == nil {
+ cr = new(renderer)
+ *cr = *r
+ cr.currentIndent += cr.indent
+ }
+
+ cr.out = &inlineBuffer
+ if !lastInline {
+ printf(r.currentIndent + r.indent)
+ }
+
+ ct(cr)
+ lastInline = true
+ continue
+ }
+
+ inline := inlineBuffer.String()
+ if inline != "" {
+ // flush
+ // newline
+ }
+
+ continue
+ }
+
+ lastInline = true
+ }
+
+ inline := inlineBuffer.String()
+ if inline != "" {
+ // flush inline
+ }
+
+ if r.indent != "" {
+ printf("\n")
+ printf(r.currentIndent)
+ }
+
+ printf("", name)
+ if r.indent != "" {
+ printf("\n")
+ }
+}
+
+func render(r *renderer, name string, children []any) {
+ if r.err != nil {
+ return
+ }
+
+ a, c, rgs := groupChildren(children)
+ rg := mergeRenderingGuides(rgs)
+ if r.indent == "" {
+ renderUnindented(r, name, rg, a, c)
+ return
+ }
+
+ if rg.inline {
+ // TODO:
+ // - may need to wrap it here
+ // - could use a wrapping buffer
+ renderInline(r, name, rg, a, c)
+ return
+ }
+
+ renderBlock(r, name, rg, a, c)
+
+ // --
+
+ printf("<%s", name)
printf(">")
if r.indent != "" && !rg.inline && len(c) > 0 {
@@ -123,9 +609,6 @@ func render(r *renderer, name string, children []any) {
}
var inlineBuffer *bytes.Buffer
- if r.indent != "" {
- inlineBuffer = bytes.NewBuffer(nil)
- }
// TODO:
// - avoid rendering an inline buffer into another inline buffer
@@ -133,8 +616,21 @@ func render(r *renderer, name string, children []any) {
// - or, if inline, just use the inline buffer without indentation
// - check the wrapping again, if it preserves or eliminates the spaces the right way
for i, ci := range c {
+ // tag && rg.inline && crg.inline
+ // tag && rg.inline && !crg.inline
+ // tag && !rg.inline && crg.inline
+ // tag && !rg.inline && !crg.inline
+ // !tag && rg.inline && crg.inline
+ // !tag && rg.inline && !crg.inline
+ // !tag && !rg.inline && crg.inline
+ // !tag && !rg.inline && !crg.inline
+
if tag, ok := ci.(Tag); ok {
if rg.inline {
+ if inlineBuffer == nil {
+ inlineBuffer = bytes.NewBuffer(nil)
+ }
+
var rgq renderGuidesQuery
tag(&rgq)
crg := mergeRenderingGuides(rgq.value)
@@ -145,7 +641,6 @@ func render(r *renderer, name string, children []any) {
}
inlineBuffer = wrap(inlineBuffer, w, "")
- println(inlineBuffer.String())
if _, err := io.Copy(r.out, inlineBuffer); err != nil {
r.err = err
return
@@ -174,7 +669,6 @@ func render(r *renderer, name string, children []any) {
}
inlineBuffer = wrap(inlineBuffer, w, r.currentIndent+r.indent)
- println(inlineBuffer.String())
if _, err := io.Copy(r.out, inlineBuffer); err != nil {
r.err = err
return
@@ -248,3 +742,4 @@ func render(r *renderer, name string, children []any) {
printf("\n")
}
}
+*/
diff --git a/render_test.go b/render_test.go
index eee466e..478384e 100644
--- a/render_test.go
+++ b/render_test.go
@@ -28,15 +28,15 @@ func (w *failingWriter) Write(p []byte) (int, error) {
func TestRender(t *testing.T) {
t.Run("merge render guides", func(t *testing.T) {
- foo := html.Inline(html.Verbatim(NewTag("foo")))
+ foo := html.Inline(html.Verbatim(Define("foo")))
foo = foo("")
var b bytes.Buffer
- if err := html.RenderIndent(&b, "\t", 0, foo); err != nil {
+ if err := html.RenderIndent(&b, html.Indentation{Indent: "\t"}, foo); err != nil {
t.Fatal(err)
}
- if b.String() != "" {
+ if b.String() != "\n\t\n" {
t.Fatal(b.String())
}
})
@@ -102,7 +102,7 @@ func TestRender(t *testing.T) {
t.Run("partial text children", func(t *testing.T) {
div := Div("foo", Div("bar"), "baz")
w := failWriteAfter(5)
- if err := html.RenderIndent(w, "\t", 0, div); err == nil || !strings.Contains(err.Error(), "test error") {
+ if err := html.RenderIndent(w, html.Indentation{Indent: "\t"}, div); err == nil || !strings.Contains(err.Error(), "test error") {
t.Fatal()
}
})
@@ -110,7 +110,7 @@ func TestRender(t *testing.T) {
t.Run("text children", func(t *testing.T) {
div := Div("foo", "bar", "baz")
w := failWriteAfter(5)
- if err := html.RenderIndent(w, "\t", 0, div); err == nil || !strings.Contains(err.Error(), "test error") {
+ if err := html.RenderIndent(w, html.Indentation{Indent: "\t"}, div); err == nil || !strings.Contains(err.Error(), "test error") {
t.Fatal()
}
})
@@ -121,11 +121,11 @@ func TestRender(t *testing.T) {
div := Div(Span("foo"))
var b bytes.Buffer
- if err := html.RenderIndent(&b, "\t", 0, div); err != nil {
+ if err := html.RenderIndent(&b, html.Indentation{Indent: "\t"}, div); err != nil {
t.Fatal(err)
}
- if b.String() != "\n\tfoo\n
\n" {
+ if b.String() != "\n\tfoo\n
" {
t.Fatal(b.String())
}
})
@@ -134,11 +134,11 @@ func TestRender(t *testing.T) {
div := Div(Br())
var b bytes.Buffer
- if err := html.RenderIndent(&b, "\t", 0, div); err != nil {
+ if err := html.RenderIndent(&b, html.Indentation{Indent: "\t"}, div); err != nil {
t.Fatal(err)
}
- if b.String() != "\n\t
\n
\n" {
+ if b.String() != "\n\t
\n
" {
t.Fatal(b.String())
}
})
@@ -147,11 +147,11 @@ func TestRender(t *testing.T) {
div := Div("foo bar baz", Div("qux quux"), "corge")
var b bytes.Buffer
- if err := html.RenderIndent(&b, "\t", 0, div); err != nil {
+ if err := html.RenderIndent(&b, html.Indentation{Indent: "\t"}, div); err != nil {
t.Fatal(err)
}
- if b.String() != "\n\tfoo bar baz\n\t
\n\t\tqux quux\n\t
\n\tcorge\n
\n\tfoo bar baz\n\t
\n\t\tqux quux\n\t
\n\tcorge\n
\nXYZ
foo bar baz\nXYZXYZ\nXYZXYZXYZqux quux\nXYZXYZ
\nXYZcorge\n
\n\tfoo\n\tbar baz\n\tqux quux\n\tcorge\n
\n" {
+ if buf.String() != "\n\t\n\tfoo bar\n\tbaz qux\n\tquux\n\tcorge\n\t\n
" {
t.Fatal(buf.String())
}
})
@@ -65,12 +63,24 @@ func TestWrap(t *testing.T) {
div := Div(Span("foo"), " ", Span("bar"))
var buf bytes.Buffer
- if err := html.RenderIndent(&buf, "\t", 0, div); err != nil {
+ if err := html.RenderIndent(&buf, html.Indentation{Indent: "\t"}, div); err != nil {
t.Fatal(err)
}
- if buf.String() != "\n\tfoo bar\n
\n" {
+ if buf.String() != "\n\tfoo bar\n
" {
t.Fatal(buf.String())
}
})
+
+ t.Run("multiple lines", func(t *testing.T) {
+ })
+
+ t.Run("special whitespace characters", func(t *testing.T) {
+ })
+
+ t.Run("spaces around tags", func(t *testing.T) {
+ })
+
+ t.Run("one line primitives", func(t *testing.T) {
+ })
}