diff options
Diffstat (limited to 'vendor/golang.org/x/net/html/render.go')
-rw-r--r-- | vendor/golang.org/x/net/html/render.go | 271 |
1 files changed, 271 insertions, 0 deletions
diff --git a/vendor/golang.org/x/net/html/render.go b/vendor/golang.org/x/net/html/render.go new file mode 100644 index 0000000..d34564f --- /dev/null +++ b/vendor/golang.org/x/net/html/render.go | |||
@@ -0,0 +1,271 @@ | |||
1 | // Copyright 2011 The Go Authors. All rights reserved. | ||
2 | // Use of this source code is governed by a BSD-style | ||
3 | // license that can be found in the LICENSE file. | ||
4 | |||
5 | package html | ||
6 | |||
7 | import ( | ||
8 | "bufio" | ||
9 | "errors" | ||
10 | "fmt" | ||
11 | "io" | ||
12 | "strings" | ||
13 | ) | ||
14 | |||
15 | type writer interface { | ||
16 | io.Writer | ||
17 | io.ByteWriter | ||
18 | WriteString(string) (int, error) | ||
19 | } | ||
20 | |||
21 | // Render renders the parse tree n to the given writer. | ||
22 | // | ||
23 | // Rendering is done on a 'best effort' basis: calling Parse on the output of | ||
24 | // Render will always result in something similar to the original tree, but it | ||
25 | // is not necessarily an exact clone unless the original tree was 'well-formed'. | ||
26 | // 'Well-formed' is not easily specified; the HTML5 specification is | ||
27 | // complicated. | ||
28 | // | ||
29 | // Calling Parse on arbitrary input typically results in a 'well-formed' parse | ||
30 | // tree. However, it is possible for Parse to yield a 'badly-formed' parse tree. | ||
31 | // For example, in a 'well-formed' parse tree, no <a> element is a child of | ||
32 | // another <a> element: parsing "<a><a>" results in two sibling elements. | ||
33 | // Similarly, in a 'well-formed' parse tree, no <a> element is a child of a | ||
34 | // <table> element: parsing "<p><table><a>" results in a <p> with two sibling | ||
35 | // children; the <a> is reparented to the <table>'s parent. However, calling | ||
36 | // Parse on "<a><table><a>" does not return an error, but the result has an <a> | ||
37 | // element with an <a> child, and is therefore not 'well-formed'. | ||
38 | // | ||
39 | // Programmatically constructed trees are typically also 'well-formed', but it | ||
40 | // is possible to construct a tree that looks innocuous but, when rendered and | ||
41 | // re-parsed, results in a different tree. A simple example is that a solitary | ||
42 | // text node would become a tree containing <html>, <head> and <body> elements. | ||
43 | // Another example is that the programmatic equivalent of "a<head>b</head>c" | ||
44 | // becomes "<html><head><head/><body>abc</body></html>". | ||
45 | func Render(w io.Writer, n *Node) error { | ||
46 | if x, ok := w.(writer); ok { | ||
47 | return render(x, n) | ||
48 | } | ||
49 | buf := bufio.NewWriter(w) | ||
50 | if err := render(buf, n); err != nil { | ||
51 | return err | ||
52 | } | ||
53 | return buf.Flush() | ||
54 | } | ||
55 | |||
56 | // plaintextAbort is returned from render1 when a <plaintext> element | ||
57 | // has been rendered. No more end tags should be rendered after that. | ||
58 | var plaintextAbort = errors.New("html: internal error (plaintext abort)") | ||
59 | |||
60 | func render(w writer, n *Node) error { | ||
61 | err := render1(w, n) | ||
62 | if err == plaintextAbort { | ||
63 | err = nil | ||
64 | } | ||
65 | return err | ||
66 | } | ||
67 | |||
68 | func render1(w writer, n *Node) error { | ||
69 | // Render non-element nodes; these are the easy cases. | ||
70 | switch n.Type { | ||
71 | case ErrorNode: | ||
72 | return errors.New("html: cannot render an ErrorNode node") | ||
73 | case TextNode: | ||
74 | return escape(w, n.Data) | ||
75 | case DocumentNode: | ||
76 | for c := n.FirstChild; c != nil; c = c.NextSibling { | ||
77 | if err := render1(w, c); err != nil { | ||
78 | return err | ||
79 | } | ||
80 | } | ||
81 | return nil | ||
82 | case ElementNode: | ||
83 | // No-op. | ||
84 | case CommentNode: | ||
85 | if _, err := w.WriteString("<!--"); err != nil { | ||
86 | return err | ||
87 | } | ||
88 | if _, err := w.WriteString(n.Data); err != nil { | ||
89 | return err | ||
90 | } | ||
91 | if _, err := w.WriteString("-->"); err != nil { | ||
92 | return err | ||
93 | } | ||
94 | return nil | ||
95 | case DoctypeNode: | ||
96 | if _, err := w.WriteString("<!DOCTYPE "); err != nil { | ||
97 | return err | ||
98 | } | ||
99 | if _, err := w.WriteString(n.Data); err != nil { | ||
100 | return err | ||
101 | } | ||
102 | if n.Attr != nil { | ||
103 | var p, s string | ||
104 | for _, a := range n.Attr { | ||
105 | switch a.Key { | ||
106 | case "public": | ||
107 | p = a.Val | ||
108 | case "system": | ||
109 | s = a.Val | ||
110 | } | ||
111 | } | ||
112 | if p != "" { | ||
113 | if _, err := w.WriteString(" PUBLIC "); err != nil { | ||
114 | return err | ||
115 | } | ||
116 | if err := writeQuoted(w, p); err != nil { | ||
117 | return err | ||
118 | } | ||
119 | if s != "" { | ||
120 | if err := w.WriteByte(' '); err != nil { | ||
121 | return err | ||
122 | } | ||
123 | if err := writeQuoted(w, s); err != nil { | ||
124 | return err | ||
125 | } | ||
126 | } | ||
127 | } else if s != "" { | ||
128 | if _, err := w.WriteString(" SYSTEM "); err != nil { | ||
129 | return err | ||
130 | } | ||
131 | if err := writeQuoted(w, s); err != nil { | ||
132 | return err | ||
133 | } | ||
134 | } | ||
135 | } | ||
136 | return w.WriteByte('>') | ||
137 | default: | ||
138 | return errors.New("html: unknown node type") | ||
139 | } | ||
140 | |||
141 | // Render the <xxx> opening tag. | ||
142 | if err := w.WriteByte('<'); err != nil { | ||
143 | return err | ||
144 | } | ||
145 | if _, err := w.WriteString(n.Data); err != nil { | ||
146 | return err | ||
147 | } | ||
148 | for _, a := range n.Attr { | ||
149 | if err := w.WriteByte(' '); err != nil { | ||
150 | return err | ||
151 | } | ||
152 | if a.Namespace != "" { | ||
153 | if _, err := w.WriteString(a.Namespace); err != nil { | ||
154 | return err | ||
155 | } | ||
156 | if err := w.WriteByte(':'); err != nil { | ||
157 | return err | ||
158 | } | ||
159 | } | ||
160 | if _, err := w.WriteString(a.Key); err != nil { | ||
161 | return err | ||
162 | } | ||
163 | if _, err := w.WriteString(`="`); err != nil { | ||
164 | return err | ||
165 | } | ||
166 | if err := escape(w, a.Val); err != nil { | ||
167 | return err | ||
168 | } | ||
169 | if err := w.WriteByte('"'); err != nil { | ||
170 | return err | ||
171 | } | ||
172 | } | ||
173 | if voidElements[n.Data] { | ||
174 | if n.FirstChild != nil { | ||
175 | return fmt.Errorf("html: void element <%s> has child nodes", n.Data) | ||
176 | } | ||
177 | _, err := w.WriteString("/>") | ||
178 | return err | ||
179 | } | ||
180 | if err := w.WriteByte('>'); err != nil { | ||
181 | return err | ||
182 | } | ||
183 | |||
184 | // Add initial newline where there is danger of a newline beging ignored. | ||
185 | if c := n.FirstChild; c != nil && c.Type == TextNode && strings.HasPrefix(c.Data, "\n") { | ||
186 | switch n.Data { | ||
187 | case "pre", "listing", "textarea": | ||
188 | if err := w.WriteByte('\n'); err != nil { | ||
189 | return err | ||
190 | } | ||
191 | } | ||
192 | } | ||
193 | |||
194 | // Render any child nodes. | ||
195 | switch n.Data { | ||
196 | case "iframe", "noembed", "noframes", "noscript", "plaintext", "script", "style", "xmp": | ||
197 | for c := n.FirstChild; c != nil; c = c.NextSibling { | ||
198 | if c.Type == TextNode { | ||
199 | if _, err := w.WriteString(c.Data); err != nil { | ||
200 | return err | ||
201 | } | ||
202 | } else { | ||
203 | if err := render1(w, c); err != nil { | ||
204 | return err | ||
205 | } | ||
206 | } | ||
207 | } | ||
208 | if n.Data == "plaintext" { | ||
209 | // Don't render anything else. <plaintext> must be the | ||
210 | // last element in the file, with no closing tag. | ||
211 | return plaintextAbort | ||
212 | } | ||
213 | default: | ||
214 | for c := n.FirstChild; c != nil; c = c.NextSibling { | ||
215 | if err := render1(w, c); err != nil { | ||
216 | return err | ||
217 | } | ||
218 | } | ||
219 | } | ||
220 | |||
221 | // Render the </xxx> closing tag. | ||
222 | if _, err := w.WriteString("</"); err != nil { | ||
223 | return err | ||
224 | } | ||
225 | if _, err := w.WriteString(n.Data); err != nil { | ||
226 | return err | ||
227 | } | ||
228 | return w.WriteByte('>') | ||
229 | } | ||
230 | |||
231 | // writeQuoted writes s to w surrounded by quotes. Normally it will use double | ||
232 | // quotes, but if s contains a double quote, it will use single quotes. | ||
233 | // It is used for writing the identifiers in a doctype declaration. | ||
234 | // In valid HTML, they can't contain both types of quotes. | ||
235 | func writeQuoted(w writer, s string) error { | ||
236 | var q byte = '"' | ||
237 | if strings.Contains(s, `"`) { | ||
238 | q = '\'' | ||
239 | } | ||
240 | if err := w.WriteByte(q); err != nil { | ||
241 | return err | ||
242 | } | ||
243 | if _, err := w.WriteString(s); err != nil { | ||
244 | return err | ||
245 | } | ||
246 | if err := w.WriteByte(q); err != nil { | ||
247 | return err | ||
248 | } | ||
249 | return nil | ||
250 | } | ||
251 | |||
252 | // Section 12.1.2, "Elements", gives this list of void elements. Void elements | ||
253 | // are those that can't have any contents. | ||
254 | var voidElements = map[string]bool{ | ||
255 | "area": true, | ||
256 | "base": true, | ||
257 | "br": true, | ||
258 | "col": true, | ||
259 | "command": true, | ||
260 | "embed": true, | ||
261 | "hr": true, | ||
262 | "img": true, | ||
263 | "input": true, | ||
264 | "keygen": true, | ||
265 | "link": true, | ||
266 | "meta": true, | ||
267 | "param": true, | ||
268 | "source": true, | ||
269 | "track": true, | ||
270 | "wbr": true, | ||
271 | } | ||