|
66
|
1 package yaml
|
|
|
2
|
|
|
3 import (
|
|
|
4 "encoding"
|
|
|
5 "fmt"
|
|
|
6 "io"
|
|
|
7 "reflect"
|
|
|
8 "regexp"
|
|
|
9 "sort"
|
|
|
10 "strconv"
|
|
|
11 "strings"
|
|
|
12 "time"
|
|
|
13 "unicode/utf8"
|
|
|
14 )
|
|
|
15
|
|
|
16 // jsonNumber is the interface of the encoding/json.Number datatype.
|
|
|
17 // Repeating the interface here avoids a dependency on encoding/json, and also
|
|
|
18 // supports other libraries like jsoniter, which use a similar datatype with
|
|
|
19 // the same interface. Detecting this interface is useful when dealing with
|
|
|
20 // structures containing json.Number, which is a string under the hood. The
|
|
|
21 // encoder should prefer the use of Int64(), Float64() and string(), in that
|
|
|
22 // order, when encoding this type.
|
|
|
23 type jsonNumber interface {
|
|
|
24 Float64() (float64, error)
|
|
|
25 Int64() (int64, error)
|
|
|
26 String() string
|
|
|
27 }
|
|
|
28
|
|
|
29 type encoder struct {
|
|
|
30 emitter yaml_emitter_t
|
|
|
31 event yaml_event_t
|
|
|
32 out []byte
|
|
|
33 flow bool
|
|
|
34 // doneInit holds whether the initial stream_start_event has been
|
|
|
35 // emitted.
|
|
|
36 doneInit bool
|
|
|
37 }
|
|
|
38
|
|
|
39 func newEncoder() *encoder {
|
|
|
40 e := &encoder{}
|
|
|
41 yaml_emitter_initialize(&e.emitter)
|
|
|
42 yaml_emitter_set_output_string(&e.emitter, &e.out)
|
|
|
43 yaml_emitter_set_unicode(&e.emitter, true)
|
|
|
44 return e
|
|
|
45 }
|
|
|
46
|
|
|
47 func newEncoderWithWriter(w io.Writer) *encoder {
|
|
|
48 e := &encoder{}
|
|
|
49 yaml_emitter_initialize(&e.emitter)
|
|
|
50 yaml_emitter_set_output_writer(&e.emitter, w)
|
|
|
51 yaml_emitter_set_unicode(&e.emitter, true)
|
|
|
52 return e
|
|
|
53 }
|
|
|
54
|
|
|
55 func (e *encoder) init() {
|
|
|
56 if e.doneInit {
|
|
|
57 return
|
|
|
58 }
|
|
|
59 yaml_stream_start_event_initialize(&e.event, yaml_UTF8_ENCODING)
|
|
|
60 e.emit()
|
|
|
61 e.doneInit = true
|
|
|
62 }
|
|
|
63
|
|
|
64 func (e *encoder) finish() {
|
|
|
65 e.emitter.open_ended = false
|
|
|
66 yaml_stream_end_event_initialize(&e.event)
|
|
|
67 e.emit()
|
|
|
68 }
|
|
|
69
|
|
|
70 func (e *encoder) destroy() {
|
|
|
71 yaml_emitter_delete(&e.emitter)
|
|
|
72 }
|
|
|
73
|
|
|
74 func (e *encoder) emit() {
|
|
|
75 // This will internally delete the e.event value.
|
|
|
76 e.must(yaml_emitter_emit(&e.emitter, &e.event))
|
|
|
77 }
|
|
|
78
|
|
|
79 func (e *encoder) must(ok bool) {
|
|
|
80 if !ok {
|
|
|
81 msg := e.emitter.problem
|
|
|
82 if msg == "" {
|
|
|
83 msg = "unknown problem generating YAML content"
|
|
|
84 }
|
|
|
85 failf("%s", msg)
|
|
|
86 }
|
|
|
87 }
|
|
|
88
|
|
|
89 func (e *encoder) marshalDoc(tag string, in reflect.Value) {
|
|
|
90 e.init()
|
|
|
91 yaml_document_start_event_initialize(&e.event, nil, nil, true)
|
|
|
92 e.emit()
|
|
|
93 e.marshal(tag, in)
|
|
|
94 yaml_document_end_event_initialize(&e.event, true)
|
|
|
95 e.emit()
|
|
|
96 }
|
|
|
97
|
|
|
98 func (e *encoder) marshal(tag string, in reflect.Value) {
|
|
|
99 if !in.IsValid() || in.Kind() == reflect.Ptr && in.IsNil() {
|
|
|
100 e.nilv()
|
|
|
101 return
|
|
|
102 }
|
|
|
103 iface := in.Interface()
|
|
|
104 switch m := iface.(type) {
|
|
|
105 case jsonNumber:
|
|
|
106 integer, err := m.Int64()
|
|
|
107 if err == nil {
|
|
|
108 // In this case the json.Number is a valid int64
|
|
|
109 in = reflect.ValueOf(integer)
|
|
|
110 break
|
|
|
111 }
|
|
|
112 float, err := m.Float64()
|
|
|
113 if err == nil {
|
|
|
114 // In this case the json.Number is a valid float64
|
|
|
115 in = reflect.ValueOf(float)
|
|
|
116 break
|
|
|
117 }
|
|
|
118 // fallback case - no number could be obtained
|
|
|
119 in = reflect.ValueOf(m.String())
|
|
|
120 case time.Time, *time.Time:
|
|
|
121 // Although time.Time implements TextMarshaler,
|
|
|
122 // we don't want to treat it as a string for YAML
|
|
|
123 // purposes because YAML has special support for
|
|
|
124 // timestamps.
|
|
|
125 case Marshaler:
|
|
|
126 v, err := m.MarshalYAML()
|
|
|
127 if err != nil {
|
|
|
128 fail(err)
|
|
|
129 }
|
|
|
130 if v == nil {
|
|
|
131 e.nilv()
|
|
|
132 return
|
|
|
133 }
|
|
|
134 in = reflect.ValueOf(v)
|
|
|
135 case encoding.TextMarshaler:
|
|
|
136 text, err := m.MarshalText()
|
|
|
137 if err != nil {
|
|
|
138 fail(err)
|
|
|
139 }
|
|
|
140 in = reflect.ValueOf(string(text))
|
|
|
141 case nil:
|
|
|
142 e.nilv()
|
|
|
143 return
|
|
|
144 }
|
|
|
145 switch in.Kind() {
|
|
|
146 case reflect.Interface:
|
|
|
147 e.marshal(tag, in.Elem())
|
|
|
148 case reflect.Map:
|
|
|
149 e.mapv(tag, in)
|
|
|
150 case reflect.Ptr:
|
|
|
151 if in.Type() == ptrTimeType {
|
|
|
152 e.timev(tag, in.Elem())
|
|
|
153 } else {
|
|
|
154 e.marshal(tag, in.Elem())
|
|
|
155 }
|
|
|
156 case reflect.Struct:
|
|
|
157 if in.Type() == timeType {
|
|
|
158 e.timev(tag, in)
|
|
|
159 } else {
|
|
|
160 e.structv(tag, in)
|
|
|
161 }
|
|
|
162 case reflect.Slice, reflect.Array:
|
|
|
163 if in.Type().Elem() == mapItemType {
|
|
|
164 e.itemsv(tag, in)
|
|
|
165 } else {
|
|
|
166 e.slicev(tag, in)
|
|
|
167 }
|
|
|
168 case reflect.String:
|
|
|
169 e.stringv(tag, in)
|
|
|
170 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
|
|
171 if in.Type() == durationType {
|
|
|
172 e.stringv(tag, reflect.ValueOf(iface.(time.Duration).String()))
|
|
|
173 } else {
|
|
|
174 e.intv(tag, in)
|
|
|
175 }
|
|
|
176 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
|
|
|
177 e.uintv(tag, in)
|
|
|
178 case reflect.Float32, reflect.Float64:
|
|
|
179 e.floatv(tag, in)
|
|
|
180 case reflect.Bool:
|
|
|
181 e.boolv(tag, in)
|
|
|
182 default:
|
|
|
183 panic("cannot marshal type: " + in.Type().String())
|
|
|
184 }
|
|
|
185 }
|
|
|
186
|
|
|
187 func (e *encoder) mapv(tag string, in reflect.Value) {
|
|
|
188 e.mappingv(tag, func() {
|
|
|
189 keys := keyList(in.MapKeys())
|
|
|
190 sort.Sort(keys)
|
|
|
191 for _, k := range keys {
|
|
|
192 e.marshal("", k)
|
|
|
193 e.marshal("", in.MapIndex(k))
|
|
|
194 }
|
|
|
195 })
|
|
|
196 }
|
|
|
197
|
|
|
198 func (e *encoder) itemsv(tag string, in reflect.Value) {
|
|
|
199 e.mappingv(tag, func() {
|
|
|
200 slice := in.Convert(reflect.TypeOf([]MapItem{})).Interface().([]MapItem)
|
|
|
201 for _, item := range slice {
|
|
|
202 e.marshal("", reflect.ValueOf(item.Key))
|
|
|
203 e.marshal("", reflect.ValueOf(item.Value))
|
|
|
204 }
|
|
|
205 })
|
|
|
206 }
|
|
|
207
|
|
|
208 func (e *encoder) structv(tag string, in reflect.Value) {
|
|
|
209 sinfo, err := getStructInfo(in.Type())
|
|
|
210 if err != nil {
|
|
|
211 panic(err)
|
|
|
212 }
|
|
|
213 e.mappingv(tag, func() {
|
|
|
214 for _, info := range sinfo.FieldsList {
|
|
|
215 var value reflect.Value
|
|
|
216 if info.Inline == nil {
|
|
|
217 value = in.Field(info.Num)
|
|
|
218 } else {
|
|
|
219 value = in.FieldByIndex(info.Inline)
|
|
|
220 }
|
|
|
221 if info.OmitEmpty && isZero(value) {
|
|
|
222 continue
|
|
|
223 }
|
|
|
224 e.marshal("", reflect.ValueOf(info.Key))
|
|
|
225 e.flow = info.Flow
|
|
|
226 e.marshal("", value)
|
|
|
227 }
|
|
|
228 if sinfo.InlineMap >= 0 {
|
|
|
229 m := in.Field(sinfo.InlineMap)
|
|
|
230 if m.Len() > 0 {
|
|
|
231 e.flow = false
|
|
|
232 keys := keyList(m.MapKeys())
|
|
|
233 sort.Sort(keys)
|
|
|
234 for _, k := range keys {
|
|
|
235 if _, found := sinfo.FieldsMap[k.String()]; found {
|
|
|
236 panic(fmt.Sprintf("Can't have key %q in inlined map; conflicts with struct field", k.String()))
|
|
|
237 }
|
|
|
238 e.marshal("", k)
|
|
|
239 e.flow = false
|
|
|
240 e.marshal("", m.MapIndex(k))
|
|
|
241 }
|
|
|
242 }
|
|
|
243 }
|
|
|
244 })
|
|
|
245 }
|
|
|
246
|
|
|
247 func (e *encoder) mappingv(tag string, f func()) {
|
|
|
248 implicit := tag == ""
|
|
|
249 style := yaml_BLOCK_MAPPING_STYLE
|
|
|
250 if e.flow {
|
|
|
251 e.flow = false
|
|
|
252 style = yaml_FLOW_MAPPING_STYLE
|
|
|
253 }
|
|
|
254 yaml_mapping_start_event_initialize(&e.event, nil, []byte(tag), implicit, style)
|
|
|
255 e.emit()
|
|
|
256 f()
|
|
|
257 yaml_mapping_end_event_initialize(&e.event)
|
|
|
258 e.emit()
|
|
|
259 }
|
|
|
260
|
|
|
261 func (e *encoder) slicev(tag string, in reflect.Value) {
|
|
|
262 implicit := tag == ""
|
|
|
263 style := yaml_BLOCK_SEQUENCE_STYLE
|
|
|
264 if e.flow {
|
|
|
265 e.flow = false
|
|
|
266 style = yaml_FLOW_SEQUENCE_STYLE
|
|
|
267 }
|
|
|
268 e.must(yaml_sequence_start_event_initialize(&e.event, nil, []byte(tag), implicit, style))
|
|
|
269 e.emit()
|
|
|
270 n := in.Len()
|
|
|
271 for i := 0; i < n; i++ {
|
|
|
272 e.marshal("", in.Index(i))
|
|
|
273 }
|
|
|
274 e.must(yaml_sequence_end_event_initialize(&e.event))
|
|
|
275 e.emit()
|
|
|
276 }
|
|
|
277
|
|
|
278 // isBase60 returns whether s is in base 60 notation as defined in YAML 1.1.
|
|
|
279 //
|
|
|
280 // The base 60 float notation in YAML 1.1 is a terrible idea and is unsupported
|
|
|
281 // in YAML 1.2 and by this package, but these should be marshalled quoted for
|
|
|
282 // the time being for compatibility with other parsers.
|
|
|
283 func isBase60Float(s string) (result bool) {
|
|
|
284 // Fast path.
|
|
|
285 if s == "" {
|
|
|
286 return false
|
|
|
287 }
|
|
|
288 c := s[0]
|
|
|
289 if !(c == '+' || c == '-' || c >= '0' && c <= '9') || strings.IndexByte(s, ':') < 0 {
|
|
|
290 return false
|
|
|
291 }
|
|
|
292 // Do the full match.
|
|
|
293 return base60float.MatchString(s)
|
|
|
294 }
|
|
|
295
|
|
|
296 // From http://yaml.org/type/float.html, except the regular expression there
|
|
|
297 // is bogus. In practice parsers do not enforce the "\.[0-9_]*" suffix.
|
|
|
298 var base60float = regexp.MustCompile(`^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+(?:\.[0-9_]*)?$`)
|
|
|
299
|
|
|
300 func (e *encoder) stringv(tag string, in reflect.Value) {
|
|
|
301 var style yaml_scalar_style_t
|
|
|
302 s := in.String()
|
|
|
303 canUsePlain := true
|
|
|
304 switch {
|
|
|
305 case !utf8.ValidString(s):
|
|
|
306 if tag == yaml_BINARY_TAG {
|
|
|
307 failf("explicitly tagged !!binary data must be base64-encoded")
|
|
|
308 }
|
|
|
309 if tag != "" {
|
|
|
310 failf("cannot marshal invalid UTF-8 data as %s", shortTag(tag))
|
|
|
311 }
|
|
|
312 // It can't be encoded directly as YAML so use a binary tag
|
|
|
313 // and encode it as base64.
|
|
|
314 tag = yaml_BINARY_TAG
|
|
|
315 s = encodeBase64(s)
|
|
|
316 case tag == "":
|
|
|
317 // Check to see if it would resolve to a specific
|
|
|
318 // tag when encoded unquoted. If it doesn't,
|
|
|
319 // there's no need to quote it.
|
|
|
320 rtag, _ := resolve("", s)
|
|
|
321 canUsePlain = rtag == yaml_STR_TAG && !isBase60Float(s)
|
|
|
322 }
|
|
|
323 // Note: it's possible for user code to emit invalid YAML
|
|
|
324 // if they explicitly specify a tag and a string containing
|
|
|
325 // text that's incompatible with that tag.
|
|
|
326 switch {
|
|
|
327 case strings.Contains(s, "\n"):
|
|
|
328 style = yaml_LITERAL_SCALAR_STYLE
|
|
|
329 case canUsePlain:
|
|
|
330 style = yaml_PLAIN_SCALAR_STYLE
|
|
|
331 default:
|
|
|
332 style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
|
|
|
333 }
|
|
|
334 e.emitScalar(s, "", tag, style)
|
|
|
335 }
|
|
|
336
|
|
|
337 func (e *encoder) boolv(tag string, in reflect.Value) {
|
|
|
338 var s string
|
|
|
339 if in.Bool() {
|
|
|
340 s = "true"
|
|
|
341 } else {
|
|
|
342 s = "false"
|
|
|
343 }
|
|
|
344 e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE)
|
|
|
345 }
|
|
|
346
|
|
|
347 func (e *encoder) intv(tag string, in reflect.Value) {
|
|
|
348 s := strconv.FormatInt(in.Int(), 10)
|
|
|
349 e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE)
|
|
|
350 }
|
|
|
351
|
|
|
352 func (e *encoder) uintv(tag string, in reflect.Value) {
|
|
|
353 s := strconv.FormatUint(in.Uint(), 10)
|
|
|
354 e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE)
|
|
|
355 }
|
|
|
356
|
|
|
357 func (e *encoder) timev(tag string, in reflect.Value) {
|
|
|
358 t := in.Interface().(time.Time)
|
|
|
359 s := t.Format(time.RFC3339Nano)
|
|
|
360 e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE)
|
|
|
361 }
|
|
|
362
|
|
|
363 func (e *encoder) floatv(tag string, in reflect.Value) {
|
|
|
364 // Issue #352: When formatting, use the precision of the underlying value
|
|
|
365 precision := 64
|
|
|
366 if in.Kind() == reflect.Float32 {
|
|
|
367 precision = 32
|
|
|
368 }
|
|
|
369
|
|
|
370 s := strconv.FormatFloat(in.Float(), 'g', -1, precision)
|
|
|
371 switch s {
|
|
|
372 case "+Inf":
|
|
|
373 s = ".inf"
|
|
|
374 case "-Inf":
|
|
|
375 s = "-.inf"
|
|
|
376 case "NaN":
|
|
|
377 s = ".nan"
|
|
|
378 }
|
|
|
379 e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE)
|
|
|
380 }
|
|
|
381
|
|
|
382 func (e *encoder) nilv() {
|
|
|
383 e.emitScalar("null", "", "", yaml_PLAIN_SCALAR_STYLE)
|
|
|
384 }
|
|
|
385
|
|
|
386 func (e *encoder) emitScalar(value, anchor, tag string, style yaml_scalar_style_t) {
|
|
|
387 implicit := tag == ""
|
|
|
388 e.must(yaml_scalar_event_initialize(&e.event, []byte(anchor), []byte(tag), []byte(value), implicit, implicit, style))
|
|
|
389 e.emit()
|
|
|
390 }
|
