mirror of
https://codeberg.org/forgejo/forgejo
synced 2024-12-05 02:54:46 +01:00
577 lines
14 KiB
Go
Vendored
577 lines
14 KiB
Go
Vendored
//
|
|
// Copyright (c) 2011-2019 Canonical Ltd
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package yaml
|
|
|
|
import (
|
|
"encoding"
|
|
"fmt"
|
|
"io"
|
|
"reflect"
|
|
"regexp"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
"unicode/utf8"
|
|
)
|
|
|
|
type encoder struct {
|
|
emitter yaml_emitter_t
|
|
event yaml_event_t
|
|
out []byte
|
|
flow bool
|
|
indent int
|
|
doneInit bool
|
|
}
|
|
|
|
func newEncoder() *encoder {
|
|
e := &encoder{}
|
|
yaml_emitter_initialize(&e.emitter)
|
|
yaml_emitter_set_output_string(&e.emitter, &e.out)
|
|
yaml_emitter_set_unicode(&e.emitter, true)
|
|
return e
|
|
}
|
|
|
|
func newEncoderWithWriter(w io.Writer) *encoder {
|
|
e := &encoder{}
|
|
yaml_emitter_initialize(&e.emitter)
|
|
yaml_emitter_set_output_writer(&e.emitter, w)
|
|
yaml_emitter_set_unicode(&e.emitter, true)
|
|
return e
|
|
}
|
|
|
|
func (e *encoder) init() {
|
|
if e.doneInit {
|
|
return
|
|
}
|
|
if e.indent == 0 {
|
|
e.indent = 4
|
|
}
|
|
e.emitter.best_indent = e.indent
|
|
yaml_stream_start_event_initialize(&e.event, yaml_UTF8_ENCODING)
|
|
e.emit()
|
|
e.doneInit = true
|
|
}
|
|
|
|
func (e *encoder) finish() {
|
|
e.emitter.open_ended = false
|
|
yaml_stream_end_event_initialize(&e.event)
|
|
e.emit()
|
|
}
|
|
|
|
func (e *encoder) destroy() {
|
|
yaml_emitter_delete(&e.emitter)
|
|
}
|
|
|
|
func (e *encoder) emit() {
|
|
// This will internally delete the e.event value.
|
|
e.must(yaml_emitter_emit(&e.emitter, &e.event))
|
|
}
|
|
|
|
func (e *encoder) must(ok bool) {
|
|
if !ok {
|
|
msg := e.emitter.problem
|
|
if msg == "" {
|
|
msg = "unknown problem generating YAML content"
|
|
}
|
|
failf("%s", msg)
|
|
}
|
|
}
|
|
|
|
func (e *encoder) marshalDoc(tag string, in reflect.Value) {
|
|
e.init()
|
|
var node *Node
|
|
if in.IsValid() {
|
|
node, _ = in.Interface().(*Node)
|
|
}
|
|
if node != nil && node.Kind == DocumentNode {
|
|
e.nodev(in)
|
|
} else {
|
|
yaml_document_start_event_initialize(&e.event, nil, nil, true)
|
|
e.emit()
|
|
e.marshal(tag, in)
|
|
yaml_document_end_event_initialize(&e.event, true)
|
|
e.emit()
|
|
}
|
|
}
|
|
|
|
func (e *encoder) marshal(tag string, in reflect.Value) {
|
|
tag = shortTag(tag)
|
|
if !in.IsValid() || in.Kind() == reflect.Ptr && in.IsNil() {
|
|
e.nilv()
|
|
return
|
|
}
|
|
iface := in.Interface()
|
|
switch value := iface.(type) {
|
|
case *Node:
|
|
e.nodev(in)
|
|
return
|
|
case Node:
|
|
if !in.CanAddr() {
|
|
var n = reflect.New(in.Type()).Elem()
|
|
n.Set(in)
|
|
in = n
|
|
}
|
|
e.nodev(in.Addr())
|
|
return
|
|
case time.Time:
|
|
e.timev(tag, in)
|
|
return
|
|
case *time.Time:
|
|
e.timev(tag, in.Elem())
|
|
return
|
|
case time.Duration:
|
|
e.stringv(tag, reflect.ValueOf(value.String()))
|
|
return
|
|
case Marshaler:
|
|
v, err := value.MarshalYAML()
|
|
if err != nil {
|
|
fail(err)
|
|
}
|
|
if v == nil {
|
|
e.nilv()
|
|
return
|
|
}
|
|
e.marshal(tag, reflect.ValueOf(v))
|
|
return
|
|
case encoding.TextMarshaler:
|
|
text, err := value.MarshalText()
|
|
if err != nil {
|
|
fail(err)
|
|
}
|
|
in = reflect.ValueOf(string(text))
|
|
case nil:
|
|
e.nilv()
|
|
return
|
|
}
|
|
switch in.Kind() {
|
|
case reflect.Interface:
|
|
e.marshal(tag, in.Elem())
|
|
case reflect.Map:
|
|
e.mapv(tag, in)
|
|
case reflect.Ptr:
|
|
e.marshal(tag, in.Elem())
|
|
case reflect.Struct:
|
|
e.structv(tag, in)
|
|
case reflect.Slice, reflect.Array:
|
|
e.slicev(tag, in)
|
|
case reflect.String:
|
|
e.stringv(tag, in)
|
|
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
|
e.intv(tag, in)
|
|
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
|
|
e.uintv(tag, in)
|
|
case reflect.Float32, reflect.Float64:
|
|
e.floatv(tag, in)
|
|
case reflect.Bool:
|
|
e.boolv(tag, in)
|
|
default:
|
|
panic("cannot marshal type: " + in.Type().String())
|
|
}
|
|
}
|
|
|
|
func (e *encoder) mapv(tag string, in reflect.Value) {
|
|
e.mappingv(tag, func() {
|
|
keys := keyList(in.MapKeys())
|
|
sort.Sort(keys)
|
|
for _, k := range keys {
|
|
e.marshal("", k)
|
|
e.marshal("", in.MapIndex(k))
|
|
}
|
|
})
|
|
}
|
|
|
|
func (e *encoder) fieldByIndex(v reflect.Value, index []int) (field reflect.Value) {
|
|
for _, num := range index {
|
|
for {
|
|
if v.Kind() == reflect.Ptr {
|
|
if v.IsNil() {
|
|
return reflect.Value{}
|
|
}
|
|
v = v.Elem()
|
|
continue
|
|
}
|
|
break
|
|
}
|
|
v = v.Field(num)
|
|
}
|
|
return v
|
|
}
|
|
|
|
func (e *encoder) structv(tag string, in reflect.Value) {
|
|
sinfo, err := getStructInfo(in.Type())
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
e.mappingv(tag, func() {
|
|
for _, info := range sinfo.FieldsList {
|
|
var value reflect.Value
|
|
if info.Inline == nil {
|
|
value = in.Field(info.Num)
|
|
} else {
|
|
value = e.fieldByIndex(in, info.Inline)
|
|
if !value.IsValid() {
|
|
continue
|
|
}
|
|
}
|
|
if info.OmitEmpty && isZero(value) {
|
|
continue
|
|
}
|
|
e.marshal("", reflect.ValueOf(info.Key))
|
|
e.flow = info.Flow
|
|
e.marshal("", value)
|
|
}
|
|
if sinfo.InlineMap >= 0 {
|
|
m := in.Field(sinfo.InlineMap)
|
|
if m.Len() > 0 {
|
|
e.flow = false
|
|
keys := keyList(m.MapKeys())
|
|
sort.Sort(keys)
|
|
for _, k := range keys {
|
|
if _, found := sinfo.FieldsMap[k.String()]; found {
|
|
panic(fmt.Sprintf("cannot have key %q in inlined map: conflicts with struct field", k.String()))
|
|
}
|
|
e.marshal("", k)
|
|
e.flow = false
|
|
e.marshal("", m.MapIndex(k))
|
|
}
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
func (e *encoder) mappingv(tag string, f func()) {
|
|
implicit := tag == ""
|
|
style := yaml_BLOCK_MAPPING_STYLE
|
|
if e.flow {
|
|
e.flow = false
|
|
style = yaml_FLOW_MAPPING_STYLE
|
|
}
|
|
yaml_mapping_start_event_initialize(&e.event, nil, []byte(tag), implicit, style)
|
|
e.emit()
|
|
f()
|
|
yaml_mapping_end_event_initialize(&e.event)
|
|
e.emit()
|
|
}
|
|
|
|
func (e *encoder) slicev(tag string, in reflect.Value) {
|
|
implicit := tag == ""
|
|
style := yaml_BLOCK_SEQUENCE_STYLE
|
|
if e.flow {
|
|
e.flow = false
|
|
style = yaml_FLOW_SEQUENCE_STYLE
|
|
}
|
|
e.must(yaml_sequence_start_event_initialize(&e.event, nil, []byte(tag), implicit, style))
|
|
e.emit()
|
|
n := in.Len()
|
|
for i := 0; i < n; i++ {
|
|
e.marshal("", in.Index(i))
|
|
}
|
|
e.must(yaml_sequence_end_event_initialize(&e.event))
|
|
e.emit()
|
|
}
|
|
|
|
// isBase60 returns whether s is in base 60 notation as defined in YAML 1.1.
|
|
//
|
|
// The base 60 float notation in YAML 1.1 is a terrible idea and is unsupported
|
|
// in YAML 1.2 and by this package, but these should be marshalled quoted for
|
|
// the time being for compatibility with other parsers.
|
|
func isBase60Float(s string) (result bool) {
|
|
// Fast path.
|
|
if s == "" {
|
|
return false
|
|
}
|
|
c := s[0]
|
|
if !(c == '+' || c == '-' || c >= '0' && c <= '9') || strings.IndexByte(s, ':') < 0 {
|
|
return false
|
|
}
|
|
// Do the full match.
|
|
return base60float.MatchString(s)
|
|
}
|
|
|
|
// From http://yaml.org/type/float.html, except the regular expression there
|
|
// is bogus. In practice parsers do not enforce the "\.[0-9_]*" suffix.
|
|
var base60float = regexp.MustCompile(`^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+(?:\.[0-9_]*)?$`)
|
|
|
|
// isOldBool returns whether s is bool notation as defined in YAML 1.1.
|
|
//
|
|
// We continue to force strings that YAML 1.1 would interpret as booleans to be
|
|
// rendered as quotes strings so that the marshalled output valid for YAML 1.1
|
|
// parsing.
|
|
func isOldBool(s string) (result bool) {
|
|
switch s {
|
|
case "y", "Y", "yes", "Yes", "YES", "on", "On", "ON",
|
|
"n", "N", "no", "No", "NO", "off", "Off", "OFF":
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
func (e *encoder) stringv(tag string, in reflect.Value) {
|
|
var style yaml_scalar_style_t
|
|
s := in.String()
|
|
canUsePlain := true
|
|
switch {
|
|
case !utf8.ValidString(s):
|
|
if tag == binaryTag {
|
|
failf("explicitly tagged !!binary data must be base64-encoded")
|
|
}
|
|
if tag != "" {
|
|
failf("cannot marshal invalid UTF-8 data as %s", shortTag(tag))
|
|
}
|
|
// It can't be encoded directly as YAML so use a binary tag
|
|
// and encode it as base64.
|
|
tag = binaryTag
|
|
s = encodeBase64(s)
|
|
case tag == "":
|
|
// Check to see if it would resolve to a specific
|
|
// tag when encoded unquoted. If it doesn't,
|
|
// there's no need to quote it.
|
|
rtag, _ := resolve("", s)
|
|
canUsePlain = rtag == strTag && !(isBase60Float(s) || isOldBool(s))
|
|
}
|
|
// Note: it's possible for user code to emit invalid YAML
|
|
// if they explicitly specify a tag and a string containing
|
|
// text that's incompatible with that tag.
|
|
switch {
|
|
case strings.Contains(s, "\n"):
|
|
if e.flow {
|
|
style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
|
|
} else {
|
|
style = yaml_LITERAL_SCALAR_STYLE
|
|
}
|
|
case canUsePlain:
|
|
style = yaml_PLAIN_SCALAR_STYLE
|
|
default:
|
|
style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
|
|
}
|
|
e.emitScalar(s, "", tag, style, nil, nil, nil, nil)
|
|
}
|
|
|
|
func (e *encoder) boolv(tag string, in reflect.Value) {
|
|
var s string
|
|
if in.Bool() {
|
|
s = "true"
|
|
} else {
|
|
s = "false"
|
|
}
|
|
e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE, nil, nil, nil, nil)
|
|
}
|
|
|
|
func (e *encoder) intv(tag string, in reflect.Value) {
|
|
s := strconv.FormatInt(in.Int(), 10)
|
|
e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE, nil, nil, nil, nil)
|
|
}
|
|
|
|
func (e *encoder) uintv(tag string, in reflect.Value) {
|
|
s := strconv.FormatUint(in.Uint(), 10)
|
|
e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE, nil, nil, nil, nil)
|
|
}
|
|
|
|
func (e *encoder) timev(tag string, in reflect.Value) {
|
|
t := in.Interface().(time.Time)
|
|
s := t.Format(time.RFC3339Nano)
|
|
e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE, nil, nil, nil, nil)
|
|
}
|
|
|
|
func (e *encoder) floatv(tag string, in reflect.Value) {
|
|
// Issue #352: When formatting, use the precision of the underlying value
|
|
precision := 64
|
|
if in.Kind() == reflect.Float32 {
|
|
precision = 32
|
|
}
|
|
|
|
s := strconv.FormatFloat(in.Float(), 'g', -1, precision)
|
|
switch s {
|
|
case "+Inf":
|
|
s = ".inf"
|
|
case "-Inf":
|
|
s = "-.inf"
|
|
case "NaN":
|
|
s = ".nan"
|
|
}
|
|
e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE, nil, nil, nil, nil)
|
|
}
|
|
|
|
func (e *encoder) nilv() {
|
|
e.emitScalar("null", "", "", yaml_PLAIN_SCALAR_STYLE, nil, nil, nil, nil)
|
|
}
|
|
|
|
func (e *encoder) emitScalar(value, anchor, tag string, style yaml_scalar_style_t, head, line, foot, tail []byte) {
|
|
// TODO Kill this function. Replace all initialize calls by their underlining Go literals.
|
|
implicit := tag == ""
|
|
if !implicit {
|
|
tag = longTag(tag)
|
|
}
|
|
e.must(yaml_scalar_event_initialize(&e.event, []byte(anchor), []byte(tag), []byte(value), implicit, implicit, style))
|
|
e.event.head_comment = head
|
|
e.event.line_comment = line
|
|
e.event.foot_comment = foot
|
|
e.event.tail_comment = tail
|
|
e.emit()
|
|
}
|
|
|
|
func (e *encoder) nodev(in reflect.Value) {
|
|
e.node(in.Interface().(*Node), "")
|
|
}
|
|
|
|
func (e *encoder) node(node *Node, tail string) {
|
|
// Zero nodes behave as nil.
|
|
if node.Kind == 0 && node.IsZero() {
|
|
e.nilv()
|
|
return
|
|
}
|
|
|
|
// If the tag was not explicitly requested, and dropping it won't change the
|
|
// implicit tag of the value, don't include it in the presentation.
|
|
var tag = node.Tag
|
|
var stag = shortTag(tag)
|
|
var forceQuoting bool
|
|
if tag != "" && node.Style&TaggedStyle == 0 {
|
|
if node.Kind == ScalarNode {
|
|
if stag == strTag && node.Style&(SingleQuotedStyle|DoubleQuotedStyle|LiteralStyle|FoldedStyle) != 0 {
|
|
tag = ""
|
|
} else {
|
|
rtag, _ := resolve("", node.Value)
|
|
if rtag == stag {
|
|
tag = ""
|
|
} else if stag == strTag {
|
|
tag = ""
|
|
forceQuoting = true
|
|
}
|
|
}
|
|
} else {
|
|
var rtag string
|
|
switch node.Kind {
|
|
case MappingNode:
|
|
rtag = mapTag
|
|
case SequenceNode:
|
|
rtag = seqTag
|
|
}
|
|
if rtag == stag {
|
|
tag = ""
|
|
}
|
|
}
|
|
}
|
|
|
|
switch node.Kind {
|
|
case DocumentNode:
|
|
yaml_document_start_event_initialize(&e.event, nil, nil, true)
|
|
e.event.head_comment = []byte(node.HeadComment)
|
|
e.emit()
|
|
for _, node := range node.Content {
|
|
e.node(node, "")
|
|
}
|
|
yaml_document_end_event_initialize(&e.event, true)
|
|
e.event.foot_comment = []byte(node.FootComment)
|
|
e.emit()
|
|
|
|
case SequenceNode:
|
|
style := yaml_BLOCK_SEQUENCE_STYLE
|
|
if node.Style&FlowStyle != 0 {
|
|
style = yaml_FLOW_SEQUENCE_STYLE
|
|
}
|
|
e.must(yaml_sequence_start_event_initialize(&e.event, []byte(node.Anchor), []byte(longTag(tag)), tag == "", style))
|
|
e.event.head_comment = []byte(node.HeadComment)
|
|
e.emit()
|
|
for _, node := range node.Content {
|
|
e.node(node, "")
|
|
}
|
|
e.must(yaml_sequence_end_event_initialize(&e.event))
|
|
e.event.line_comment = []byte(node.LineComment)
|
|
e.event.foot_comment = []byte(node.FootComment)
|
|
e.emit()
|
|
|
|
case MappingNode:
|
|
style := yaml_BLOCK_MAPPING_STYLE
|
|
if node.Style&FlowStyle != 0 {
|
|
style = yaml_FLOW_MAPPING_STYLE
|
|
}
|
|
yaml_mapping_start_event_initialize(&e.event, []byte(node.Anchor), []byte(longTag(tag)), tag == "", style)
|
|
e.event.tail_comment = []byte(tail)
|
|
e.event.head_comment = []byte(node.HeadComment)
|
|
e.emit()
|
|
|
|
// The tail logic below moves the foot comment of prior keys to the following key,
|
|
// since the value for each key may be a nested structure and the foot needs to be
|
|
// processed only the entirety of the value is streamed. The last tail is processed
|
|
// with the mapping end event.
|
|
var tail string
|
|
for i := 0; i+1 < len(node.Content); i += 2 {
|
|
k := node.Content[i]
|
|
foot := k.FootComment
|
|
if foot != "" {
|
|
kopy := *k
|
|
kopy.FootComment = ""
|
|
k = &kopy
|
|
}
|
|
e.node(k, tail)
|
|
tail = foot
|
|
|
|
v := node.Content[i+1]
|
|
e.node(v, "")
|
|
}
|
|
|
|
yaml_mapping_end_event_initialize(&e.event)
|
|
e.event.tail_comment = []byte(tail)
|
|
e.event.line_comment = []byte(node.LineComment)
|
|
e.event.foot_comment = []byte(node.FootComment)
|
|
e.emit()
|
|
|
|
case AliasNode:
|
|
yaml_alias_event_initialize(&e.event, []byte(node.Value))
|
|
e.event.head_comment = []byte(node.HeadComment)
|
|
e.event.line_comment = []byte(node.LineComment)
|
|
e.event.foot_comment = []byte(node.FootComment)
|
|
e.emit()
|
|
|
|
case ScalarNode:
|
|
value := node.Value
|
|
if !utf8.ValidString(value) {
|
|
if stag == binaryTag {
|
|
failf("explicitly tagged !!binary data must be base64-encoded")
|
|
}
|
|
if stag != "" {
|
|
failf("cannot marshal invalid UTF-8 data as %s", stag)
|
|
}
|
|
// It can't be encoded directly as YAML so use a binary tag
|
|
// and encode it as base64.
|
|
tag = binaryTag
|
|
value = encodeBase64(value)
|
|
}
|
|
|
|
style := yaml_PLAIN_SCALAR_STYLE
|
|
switch {
|
|
case node.Style&DoubleQuotedStyle != 0:
|
|
style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
|
|
case node.Style&SingleQuotedStyle != 0:
|
|
style = yaml_SINGLE_QUOTED_SCALAR_STYLE
|
|
case node.Style&LiteralStyle != 0:
|
|
style = yaml_LITERAL_SCALAR_STYLE
|
|
case node.Style&FoldedStyle != 0:
|
|
style = yaml_FOLDED_SCALAR_STYLE
|
|
case strings.Contains(value, "\n"):
|
|
style = yaml_LITERAL_SCALAR_STYLE
|
|
case forceQuoting:
|
|
style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
|
|
}
|
|
|
|
e.emitScalar(value, node.Anchor, tag, style, []byte(node.HeadComment), []byte(node.LineComment), []byte(node.FootComment), []byte(tail))
|
|
default:
|
|
failf("cannot encode node with unknown kind %d", node.Kind)
|
|
}
|
|
}
|