encode.go raw
1 //
2 // Copyright (c) 2011-2019 Canonical Ltd
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 // http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15
16 package yaml
17
18 import (
19 "encoding"
20 "fmt"
21 "io"
22 "reflect"
23 "regexp"
24 "sort"
25 "strconv"
26 "strings"
27 "time"
28 "unicode/utf8"
29 )
30
31 type encoder struct {
32 emitter yaml_emitter_t
33 event yaml_event_t
34 out []byte
35 flow bool
36 indent int
37 doneInit bool
38 }
39
40 func newEncoder() *encoder {
41 e := &encoder{}
42 yaml_emitter_initialize(&e.emitter)
43 yaml_emitter_set_output_string(&e.emitter, &e.out)
44 yaml_emitter_set_unicode(&e.emitter, true)
45 return e
46 }
47
48 func newEncoderWithWriter(w io.Writer) *encoder {
49 e := &encoder{}
50 yaml_emitter_initialize(&e.emitter)
51 yaml_emitter_set_output_writer(&e.emitter, w)
52 yaml_emitter_set_unicode(&e.emitter, true)
53 return e
54 }
55
56 func (e *encoder) init() {
57 if e.doneInit {
58 return
59 }
60 if e.indent == 0 {
61 e.indent = 4
62 }
63 e.emitter.best_indent = e.indent
64 yaml_stream_start_event_initialize(&e.event, yaml_UTF8_ENCODING)
65 e.emit()
66 e.doneInit = true
67 }
68
69 func (e *encoder) finish() {
70 e.emitter.open_ended = false
71 yaml_stream_end_event_initialize(&e.event)
72 e.emit()
73 }
74
75 func (e *encoder) destroy() {
76 yaml_emitter_delete(&e.emitter)
77 }
78
79 func (e *encoder) emit() {
80 // This will internally delete the e.event value.
81 e.must(yaml_emitter_emit(&e.emitter, &e.event))
82 }
83
84 func (e *encoder) must(ok bool) {
85 if !ok {
86 msg := e.emitter.problem
87 if msg == "" {
88 msg = "unknown problem generating YAML content"
89 }
90 failf("%s", msg)
91 }
92 }
93
94 func (e *encoder) marshalDoc(tag string, in reflect.Value) {
95 e.init()
96 var node *Node
97 if in.IsValid() {
98 node, _ = in.Interface().(*Node)
99 }
100 if node != nil && node.Kind == DocumentNode {
101 e.nodev(in)
102 } else {
103 yaml_document_start_event_initialize(&e.event, nil, nil, true)
104 e.emit()
105 e.marshal(tag, in)
106 yaml_document_end_event_initialize(&e.event, true)
107 e.emit()
108 }
109 }
110
111 func (e *encoder) marshal(tag string, in reflect.Value) {
112 tag = shortTag(tag)
113 if !in.IsValid() || in.Kind() == reflect.Ptr && in.IsNil() {
114 e.nilv()
115 return
116 }
117 iface := in.Interface()
118 switch value := iface.(type) {
119 case *Node:
120 e.nodev(in)
121 return
122 case Node:
123 if !in.CanAddr() {
124 var n = reflect.New(in.Type()).Elem()
125 n.Set(in)
126 in = n
127 }
128 e.nodev(in.Addr())
129 return
130 case time.Time:
131 e.timev(tag, in)
132 return
133 case *time.Time:
134 e.timev(tag, in.Elem())
135 return
136 case time.Duration:
137 e.stringv(tag, reflect.ValueOf(value.String()))
138 return
139 case Marshaler:
140 v, err := value.MarshalYAML()
141 if err != nil {
142 fail(err)
143 }
144 if v == nil {
145 e.nilv()
146 return
147 }
148 e.marshal(tag, reflect.ValueOf(v))
149 return
150 case encoding.TextMarshaler:
151 text, err := value.MarshalText()
152 if err != nil {
153 fail(err)
154 }
155 in = reflect.ValueOf(string(text))
156 case nil:
157 e.nilv()
158 return
159 }
160 switch in.Kind() {
161 case reflect.Interface:
162 e.marshal(tag, in.Elem())
163 case reflect.Map:
164 e.mapv(tag, in)
165 case reflect.Ptr:
166 e.marshal(tag, in.Elem())
167 case reflect.Struct:
168 e.structv(tag, in)
169 case reflect.Slice, reflect.Array:
170 e.slicev(tag, in)
171 case reflect.String:
172 e.stringv(tag, in)
173 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
174 e.intv(tag, in)
175 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
176 e.uintv(tag, in)
177 case reflect.Float32, reflect.Float64:
178 e.floatv(tag, in)
179 case reflect.Bool:
180 e.boolv(tag, in)
181 default:
182 panic("cannot marshal type: " + in.Type().String())
183 }
184 }
185
186 func (e *encoder) mapv(tag string, in reflect.Value) {
187 e.mappingv(tag, func() {
188 keys := keyList(in.MapKeys())
189 sort.Sort(keys)
190 for _, k := range keys {
191 e.marshal("", k)
192 e.marshal("", in.MapIndex(k))
193 }
194 })
195 }
196
197 func (e *encoder) fieldByIndex(v reflect.Value, index []int) (field reflect.Value) {
198 for _, num := range index {
199 for {
200 if v.Kind() == reflect.Ptr {
201 if v.IsNil() {
202 return reflect.Value{}
203 }
204 v = v.Elem()
205 continue
206 }
207 break
208 }
209 v = v.Field(num)
210 }
211 return v
212 }
213
214 func (e *encoder) structv(tag string, in reflect.Value) {
215 sinfo, err := getStructInfo(in.Type())
216 if err != nil {
217 panic(err)
218 }
219 e.mappingv(tag, func() {
220 for _, info := range sinfo.FieldsList {
221 var value reflect.Value
222 if info.Inline == nil {
223 value = in.Field(info.Num)
224 } else {
225 value = e.fieldByIndex(in, info.Inline)
226 if !value.IsValid() {
227 continue
228 }
229 }
230 if info.OmitEmpty && isZero(value) {
231 continue
232 }
233 e.marshal("", reflect.ValueOf(info.Key))
234 e.flow = info.Flow
235 e.marshal("", value)
236 }
237 if sinfo.InlineMap >= 0 {
238 m := in.Field(sinfo.InlineMap)
239 if m.Len() > 0 {
240 e.flow = false
241 keys := keyList(m.MapKeys())
242 sort.Sort(keys)
243 for _, k := range keys {
244 if _, found := sinfo.FieldsMap[k.String()]; found {
245 panic(fmt.Sprintf("cannot have key %q in inlined map: conflicts with struct field", k.String()))
246 }
247 e.marshal("", k)
248 e.flow = false
249 e.marshal("", m.MapIndex(k))
250 }
251 }
252 }
253 })
254 }
255
256 func (e *encoder) mappingv(tag string, f func()) {
257 implicit := tag == ""
258 style := yaml_BLOCK_MAPPING_STYLE
259 if e.flow {
260 e.flow = false
261 style = yaml_FLOW_MAPPING_STYLE
262 }
263 yaml_mapping_start_event_initialize(&e.event, nil, []byte(tag), implicit, style)
264 e.emit()
265 f()
266 yaml_mapping_end_event_initialize(&e.event)
267 e.emit()
268 }
269
270 func (e *encoder) slicev(tag string, in reflect.Value) {
271 implicit := tag == ""
272 style := yaml_BLOCK_SEQUENCE_STYLE
273 if e.flow {
274 e.flow = false
275 style = yaml_FLOW_SEQUENCE_STYLE
276 }
277 e.must(yaml_sequence_start_event_initialize(&e.event, nil, []byte(tag), implicit, style))
278 e.emit()
279 n := in.Len()
280 for i := 0; i < n; i++ {
281 e.marshal("", in.Index(i))
282 }
283 e.must(yaml_sequence_end_event_initialize(&e.event))
284 e.emit()
285 }
286
287 // isBase60 returns whether s is in base 60 notation as defined in YAML 1.1.
288 //
289 // The base 60 float notation in YAML 1.1 is a terrible idea and is unsupported
290 // in YAML 1.2 and by this package, but these should be marshalled quoted for
291 // the time being for compatibility with other parsers.
292 func isBase60Float(s string) (result bool) {
293 // Fast path.
294 if s == "" {
295 return false
296 }
297 c := s[0]
298 if !(c == '+' || c == '-' || c >= '0' && c <= '9') || strings.IndexByte(s, ':') < 0 {
299 return false
300 }
301 // Do the full match.
302 return base60float.MatchString(s)
303 }
304
305 // From http://yaml.org/type/float.html, except the regular expression there
306 // is bogus. In practice parsers do not enforce the "\.[0-9_]*" suffix.
307 var base60float = regexp.MustCompile(`^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+(?:\.[0-9_]*)?$`)
308
309 // isOldBool returns whether s is bool notation as defined in YAML 1.1.
310 //
311 // We continue to force strings that YAML 1.1 would interpret as booleans to be
312 // rendered as quotes strings so that the marshalled output valid for YAML 1.1
313 // parsing.
314 func isOldBool(s string) (result bool) {
315 switch s {
316 case "y", "Y", "yes", "Yes", "YES", "on", "On", "ON",
317 "n", "N", "no", "No", "NO", "off", "Off", "OFF":
318 return true
319 default:
320 return false
321 }
322 }
323
324 func (e *encoder) stringv(tag string, in reflect.Value) {
325 var style yaml_scalar_style_t
326 s := in.String()
327 canUsePlain := true
328 switch {
329 case !utf8.ValidString(s):
330 if tag == binaryTag {
331 failf("explicitly tagged !!binary data must be base64-encoded")
332 }
333 if tag != "" {
334 failf("cannot marshal invalid UTF-8 data as %s", shortTag(tag))
335 }
336 // It can't be encoded directly as YAML so use a binary tag
337 // and encode it as base64.
338 tag = binaryTag
339 s = encodeBase64(s)
340 case tag == "":
341 // Check to see if it would resolve to a specific
342 // tag when encoded unquoted. If it doesn't,
343 // there's no need to quote it.
344 rtag, _ := resolve("", s)
345 canUsePlain = rtag == strTag && !(isBase60Float(s) || isOldBool(s))
346 }
347 // Note: it's possible for user code to emit invalid YAML
348 // if they explicitly specify a tag and a string containing
349 // text that's incompatible with that tag.
350 switch {
351 case strings.Contains(s, "\n"):
352 if e.flow {
353 style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
354 } else {
355 style = yaml_LITERAL_SCALAR_STYLE
356 }
357 case canUsePlain:
358 style = yaml_PLAIN_SCALAR_STYLE
359 default:
360 style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
361 }
362 e.emitScalar(s, "", tag, style, nil, nil, nil, nil)
363 }
364
365 func (e *encoder) boolv(tag string, in reflect.Value) {
366 var s string
367 if in.Bool() {
368 s = "true"
369 } else {
370 s = "false"
371 }
372 e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE, nil, nil, nil, nil)
373 }
374
375 func (e *encoder) intv(tag string, in reflect.Value) {
376 s := strconv.FormatInt(in.Int(), 10)
377 e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE, nil, nil, nil, nil)
378 }
379
380 func (e *encoder) uintv(tag string, in reflect.Value) {
381 s := strconv.FormatUint(in.Uint(), 10)
382 e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE, nil, nil, nil, nil)
383 }
384
385 func (e *encoder) timev(tag string, in reflect.Value) {
386 t := in.Interface().(time.Time)
387 s := t.Format(time.RFC3339Nano)
388 e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE, nil, nil, nil, nil)
389 }
390
391 func (e *encoder) floatv(tag string, in reflect.Value) {
392 // Issue #352: When formatting, use the precision of the underlying value
393 precision := 64
394 if in.Kind() == reflect.Float32 {
395 precision = 32
396 }
397
398 s := strconv.FormatFloat(in.Float(), 'g', -1, precision)
399 switch s {
400 case "+Inf":
401 s = ".inf"
402 case "-Inf":
403 s = "-.inf"
404 case "NaN":
405 s = ".nan"
406 }
407 e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE, nil, nil, nil, nil)
408 }
409
410 func (e *encoder) nilv() {
411 e.emitScalar("null", "", "", yaml_PLAIN_SCALAR_STYLE, nil, nil, nil, nil)
412 }
413
414 func (e *encoder) emitScalar(value, anchor, tag string, style yaml_scalar_style_t, head, line, foot, tail []byte) {
415 // TODO Kill this function. Replace all initialize calls by their underlining Go literals.
416 implicit := tag == ""
417 if !implicit {
418 tag = longTag(tag)
419 }
420 e.must(yaml_scalar_event_initialize(&e.event, []byte(anchor), []byte(tag), []byte(value), implicit, implicit, style))
421 e.event.head_comment = head
422 e.event.line_comment = line
423 e.event.foot_comment = foot
424 e.event.tail_comment = tail
425 e.emit()
426 }
427
428 func (e *encoder) nodev(in reflect.Value) {
429 e.node(in.Interface().(*Node), "")
430 }
431
432 func (e *encoder) node(node *Node, tail string) {
433 // Zero nodes behave as nil.
434 if node.Kind == 0 && node.IsZero() {
435 e.nilv()
436 return
437 }
438
439 // If the tag was not explicitly requested, and dropping it won't change the
440 // implicit tag of the value, don't include it in the presentation.
441 var tag = node.Tag
442 var stag = shortTag(tag)
443 var forceQuoting bool
444 if tag != "" && node.Style&TaggedStyle == 0 {
445 if node.Kind == ScalarNode {
446 if stag == strTag && node.Style&(SingleQuotedStyle|DoubleQuotedStyle|LiteralStyle|FoldedStyle) != 0 {
447 tag = ""
448 } else {
449 rtag, _ := resolve("", node.Value)
450 if rtag == stag {
451 tag = ""
452 } else if stag == strTag {
453 tag = ""
454 forceQuoting = true
455 }
456 }
457 } else {
458 var rtag string
459 switch node.Kind {
460 case MappingNode:
461 rtag = mapTag
462 case SequenceNode:
463 rtag = seqTag
464 }
465 if rtag == stag {
466 tag = ""
467 }
468 }
469 }
470
471 switch node.Kind {
472 case DocumentNode:
473 yaml_document_start_event_initialize(&e.event, nil, nil, true)
474 e.event.head_comment = []byte(node.HeadComment)
475 e.emit()
476 for _, node := range node.Content {
477 e.node(node, "")
478 }
479 yaml_document_end_event_initialize(&e.event, true)
480 e.event.foot_comment = []byte(node.FootComment)
481 e.emit()
482
483 case SequenceNode:
484 style := yaml_BLOCK_SEQUENCE_STYLE
485 if node.Style&FlowStyle != 0 {
486 style = yaml_FLOW_SEQUENCE_STYLE
487 }
488 e.must(yaml_sequence_start_event_initialize(&e.event, []byte(node.Anchor), []byte(longTag(tag)), tag == "", style))
489 e.event.head_comment = []byte(node.HeadComment)
490 e.emit()
491 for _, node := range node.Content {
492 e.node(node, "")
493 }
494 e.must(yaml_sequence_end_event_initialize(&e.event))
495 e.event.line_comment = []byte(node.LineComment)
496 e.event.foot_comment = []byte(node.FootComment)
497 e.emit()
498
499 case MappingNode:
500 style := yaml_BLOCK_MAPPING_STYLE
501 if node.Style&FlowStyle != 0 {
502 style = yaml_FLOW_MAPPING_STYLE
503 }
504 yaml_mapping_start_event_initialize(&e.event, []byte(node.Anchor), []byte(longTag(tag)), tag == "", style)
505 e.event.tail_comment = []byte(tail)
506 e.event.head_comment = []byte(node.HeadComment)
507 e.emit()
508
509 // The tail logic below moves the foot comment of prior keys to the following key,
510 // since the value for each key may be a nested structure and the foot needs to be
511 // processed only the entirety of the value is streamed. The last tail is processed
512 // with the mapping end event.
513 var tail string
514 for i := 0; i+1 < len(node.Content); i += 2 {
515 k := node.Content[i]
516 foot := k.FootComment
517 if foot != "" {
518 kopy := *k
519 kopy.FootComment = ""
520 k = &kopy
521 }
522 e.node(k, tail)
523 tail = foot
524
525 v := node.Content[i+1]
526 e.node(v, "")
527 }
528
529 yaml_mapping_end_event_initialize(&e.event)
530 e.event.tail_comment = []byte(tail)
531 e.event.line_comment = []byte(node.LineComment)
532 e.event.foot_comment = []byte(node.FootComment)
533 e.emit()
534
535 case AliasNode:
536 yaml_alias_event_initialize(&e.event, []byte(node.Value))
537 e.event.head_comment = []byte(node.HeadComment)
538 e.event.line_comment = []byte(node.LineComment)
539 e.event.foot_comment = []byte(node.FootComment)
540 e.emit()
541
542 case ScalarNode:
543 value := node.Value
544 if !utf8.ValidString(value) {
545 if stag == binaryTag {
546 failf("explicitly tagged !!binary data must be base64-encoded")
547 }
548 if stag != "" {
549 failf("cannot marshal invalid UTF-8 data as %s", stag)
550 }
551 // It can't be encoded directly as YAML so use a binary tag
552 // and encode it as base64.
553 tag = binaryTag
554 value = encodeBase64(value)
555 }
556
557 style := yaml_PLAIN_SCALAR_STYLE
558 switch {
559 case node.Style&DoubleQuotedStyle != 0:
560 style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
561 case node.Style&SingleQuotedStyle != 0:
562 style = yaml_SINGLE_QUOTED_SCALAR_STYLE
563 case node.Style&LiteralStyle != 0:
564 style = yaml_LITERAL_SCALAR_STYLE
565 case node.Style&FoldedStyle != 0:
566 style = yaml_FOLDED_SCALAR_STYLE
567 case strings.Contains(value, "\n"):
568 style = yaml_LITERAL_SCALAR_STYLE
569 case forceQuoting:
570 style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
571 }
572
573 e.emitScalar(value, node.Anchor, tag, style, []byte(node.HeadComment), []byte(node.LineComment), []byte(node.FootComment), []byte(tail))
574 default:
575 failf("cannot encode node with unknown kind %d", node.Kind)
576 }
577 }
578