1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
|
package formatter
import (
"fmt"
"slices"
"unicode"
"git.thomasvoss.com/gsp/parser"
)
var (
attrValueEscapes = map[rune]string{
'"': """,
'&': "&",
'<': "<",
}
stringEscapes = map[rune]string {
'"': """,
'&': "&",
'<': "<",
'>': ">",
'\'': "'",
}
)
func PrintAst(ast parser.AstNode) {
switch ast.Type {
case parser.Text:
printText(ast.Text)
case parser.Normal:
fmt.Printf("<%s", ast.Text)
printAttrs(ast.Attrs)
fmt.Print(">")
if len(ast.Children) > 0 {
printChildren(ast.Children)
fmt.Printf("</%s>", ast.Text)
}
case parser.Tagless:
printChildren(ast.Children)
}
}
func printAttrs(attrs []parser.Attr) {
classes := attrs
classes = slices.DeleteFunc(classes, func (a parser.Attr) bool {
return a.Key != "class"
})
attrs = slices.DeleteFunc(attrs, func (a parser.Attr) bool {
return a.Key == "class"
})
if len(classes) > 0 {
fmt.Print(" class=\"")
for i, a := range classes {
fmt.Print(a.Value)
if i != len(classes) - 1 {
fmt.Print(" ")
} else {
fmt.Print("\"")
}
}
}
for _, a := range attrs {
fmt.Printf(" %s", a.Key)
if a.Value != "" {
fmt.Print("=\"")
for _, r := range a.Value {
if v, ok := attrValueEscapes[r]; ok {
fmt.Print(v)
} else {
fmt.Printf("%c", r)
}
}
fmt.Print("\"")
}
}
}
func printText(s string) {
for _, r := range s {
if v, ok := stringEscapes[r]; ok {
fmt.Print(v)
} else {
fmt.Printf("%c", r)
}
}
}
func printChildren(nodes []parser.AstNode) {
for i, n := range nodes {
if i == 0 && n.Type == parser.Text {
n.Text = trimLeftSpaces(n.Text)
}
if i == len(nodes) - 1 && n.Type == parser.Text {
n.Text = trimRightSpaces(n.Text)
}
PrintAst(n)
}
}
func trimLeftSpaces(s string) string {
i := 0
rs := []rune(s)
for i < len(s) && unicode.IsSpace(rs[i]) {
i++
}
return string(rs[i:])
}
func trimRightSpaces(s string) string {
rs := []rune(s)
i := len(rs) - 1
for i >= 0 && unicode.IsSpace(rs[i]) {
i--
}
return string(rs[:i+1])
}
|
