You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
282 lines
6.6 KiB
282 lines
6.6 KiB
//nolint:gomnd
|
|
package field
|
|
|
|
import (
|
|
"fmt"
|
|
"strconv"
|
|
"time"
|
|
"unicode"
|
|
"unicode/utf8"
|
|
)
|
|
|
|
type Encoder interface {
|
|
AppendField(dst []byte, field Field) []byte
|
|
AppendValue(dst []byte, val Value) []byte
|
|
}
|
|
|
|
func WithAppendString(fn func(dst []byte, in string) []byte) func(*BaseEncoder) {
|
|
return func(be *BaseEncoder) {
|
|
be.AppendString = fn
|
|
}
|
|
}
|
|
|
|
func WithNullValue(in string) func(*BaseEncoder) {
|
|
return func(be *BaseEncoder) {
|
|
be.nullValue = []byte(in)
|
|
}
|
|
}
|
|
|
|
func WithDelimeter(in byte) func(*BaseEncoder) {
|
|
return func(be *BaseEncoder) {
|
|
be.delimeter = in
|
|
}
|
|
}
|
|
|
|
func WithGropuConfig(start, end, deli byte) func(*BaseEncoder) {
|
|
return func(be *BaseEncoder) {
|
|
be.group = groupConfig{
|
|
start: start,
|
|
end: end,
|
|
deli: deli,
|
|
}
|
|
}
|
|
}
|
|
|
|
func WithDefaultValue(fn func(dst []byte, e Encoder, val Value) []byte) func(*BaseEncoder) {
|
|
return func(be *BaseEncoder) {
|
|
be.DefaultValue = fn
|
|
}
|
|
}
|
|
|
|
func NewEncoder(opts ...func(*BaseEncoder)) BaseEncoder {
|
|
be := BaseEncoder{
|
|
nullValue: []byte("null"),
|
|
group: groupConfig{
|
|
start: '{',
|
|
end: '}',
|
|
deli: ',',
|
|
},
|
|
array: groupConfig{
|
|
start: '[',
|
|
end: ']',
|
|
deli: ',',
|
|
},
|
|
timeFormat: time.RFC3339,
|
|
AppendString: AppendString,
|
|
delimeter: '=',
|
|
DefaultValue: func(dst []byte, e Encoder, val Value) []byte {
|
|
return e.AppendValue(dst, StringValue(fmt.Sprintf("%+v", val.Any())))
|
|
},
|
|
}
|
|
|
|
for _, opt := range opts {
|
|
opt(&be)
|
|
}
|
|
|
|
return be
|
|
}
|
|
|
|
type groupConfig struct {
|
|
start byte
|
|
end byte
|
|
deli byte
|
|
}
|
|
|
|
type BaseEncoder struct {
|
|
nullValue []byte
|
|
group groupConfig
|
|
array groupConfig
|
|
timeFormat string
|
|
AppendString func(dst []byte, in string) []byte
|
|
delimeter byte
|
|
DefaultValue func(dst []byte, e Encoder, val Value) []byte
|
|
}
|
|
|
|
func (b BaseEncoder) AppendValue(dst []byte, val Value) []byte {
|
|
return b.appendValue(dst, val, "", 0)
|
|
}
|
|
|
|
func (b BaseEncoder) AppendDelimiter(dst []byte, deli byte) []byte {
|
|
if deli == 0 {
|
|
return dst
|
|
}
|
|
|
|
return append(dst, deli)
|
|
}
|
|
|
|
//nolint:gocyclo,cyclop
|
|
func (b BaseEncoder) appendValue(dst []byte, val Value, prefix string, deli byte) []byte {
|
|
switch val.Kind {
|
|
case KindGroup:
|
|
return b.appendGroup(dst, val.AsGroup(), prefix)
|
|
case KindClosure:
|
|
return b.appendValue(dst, AnyValue(val.Resolve()), prefix, deli)
|
|
case KindArray:
|
|
return b.AppendArray(b.AppendDelimiter(dst, deli), val.AsArray())
|
|
case KindNil:
|
|
return b.AppendNull(b.AppendDelimiter(dst, deli))
|
|
case KindBool:
|
|
return b.AppendBool(b.AppendDelimiter(dst, deli), val.AsBool())
|
|
case KindBinary:
|
|
return b.AppendBytes(b.AppendDelimiter(dst, deli), val.AsBinary())
|
|
case KindComplex128:
|
|
return b.AppendComplex(b.AppendDelimiter(dst, deli), val.AsComplex128())
|
|
case KindInt64:
|
|
return b.AppendInt(b.AppendDelimiter(dst, deli), val.AsInt64())
|
|
case KindFloat32:
|
|
return b.AppendFloat(b.AppendDelimiter(dst, deli), float64(val.AsFloat32()), 32)
|
|
case KindFloat64:
|
|
return b.AppendFloat(b.AppendDelimiter(dst, deli), val.AsFloat64(), 64)
|
|
case KindUint64:
|
|
return b.AppendUint(b.AppendDelimiter(dst, deli), val.AsUint64())
|
|
case KindError:
|
|
return b.AppendString(b.AppendDelimiter(dst, deli), val.AsError().Error())
|
|
case KindString:
|
|
return b.AppendString(b.AppendDelimiter(dst, deli), val.AsString())
|
|
case KindDuration:
|
|
return b.AppendDuration(b.AppendDelimiter(dst, deli), val.AsDuration())
|
|
case KindTime:
|
|
return b.AppendTime(b.AppendDelimiter(dst, deli), val.AsTime())
|
|
case KindAny:
|
|
return b.DefaultValue(b.AppendDelimiter(dst, deli), b, val)
|
|
}
|
|
|
|
return b.DefaultValue(b.AppendDelimiter(dst, deli), b, val)
|
|
}
|
|
|
|
func (b BaseEncoder) AppendDuration(dst []byte, d time.Duration) []byte {
|
|
return b.AppendString(dst, d.String())
|
|
}
|
|
|
|
func (b BaseEncoder) AppendTime(dst []byte, t time.Time) []byte {
|
|
return b.AppendString(dst, t.Format(b.timeFormat))
|
|
}
|
|
|
|
func AppendString(dst []byte, in string) []byte {
|
|
if needsQuoting(in) {
|
|
return strconv.AppendQuote(dst, in)
|
|
}
|
|
|
|
return append(dst, in...)
|
|
}
|
|
|
|
//nolint:cyclop
|
|
func needsQuoting(in string) bool {
|
|
if len(in) == 0 {
|
|
return true
|
|
}
|
|
|
|
for i := 0; i < len(in); {
|
|
char := in[i]
|
|
if char < utf8.RuneSelf {
|
|
// Quote anything except a backslash that would need quoting in a
|
|
// JSON string, as well as space and '='
|
|
if char != '\\' && (char == ' ' || char == '=' || !safeSet[char]) {
|
|
return true
|
|
}
|
|
|
|
i++
|
|
|
|
continue
|
|
}
|
|
|
|
decodeRune, size := utf8.DecodeRuneInString(in[i:])
|
|
if decodeRune == utf8.RuneError || unicode.IsSpace(decodeRune) || !unicode.IsPrint(decodeRune) {
|
|
return true
|
|
}
|
|
|
|
i += size
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
func (b BaseEncoder) AppendField(dst []byte, field Field) []byte {
|
|
prefix := ""
|
|
|
|
if len(dst) != 0 {
|
|
prew := dst[len(dst)-1]
|
|
if prew != '{' && prew != '.' {
|
|
prefix = string(b.group.deli)
|
|
}
|
|
}
|
|
|
|
return b.appendField(dst, field, prefix, b.delimeter)
|
|
}
|
|
|
|
func (b BaseEncoder) appendField(dst []byte, field Field, prefix string, deli byte) []byte {
|
|
dst = b.AppendKey(dst, field.Key, prefix)
|
|
|
|
return b.appendValue(dst, field.Value, field.Key+".", deli)
|
|
}
|
|
|
|
func (b BaseEncoder) AppendKey(dst []byte, key string, prefix string) []byte {
|
|
if prefix != "" {
|
|
dst = append(dst, prefix...)
|
|
}
|
|
|
|
return b.AppendString(dst, key)
|
|
}
|
|
|
|
func (b BaseEncoder) AppendComplex(dst []byte, c complex128) []byte {
|
|
cmplx := strconv.FormatComplex(c, 'g', -1, 128)
|
|
|
|
return b.AppendString(dst, cmplx)
|
|
}
|
|
|
|
func (b BaseEncoder) AppendFloat(dst []byte, f float64, bitSize int) []byte {
|
|
return strconv.AppendFloat(dst, f, 'g', -1, bitSize)
|
|
}
|
|
|
|
func (b BaseEncoder) AppendUint(dst []byte, u uint64) []byte {
|
|
return strconv.AppendUint(dst, u, 10)
|
|
}
|
|
|
|
func (b BaseEncoder) AppendNull(dst []byte) []byte {
|
|
return append(dst, b.nullValue...)
|
|
}
|
|
|
|
func (b BaseEncoder) AppendInt(dst []byte, val int64) []byte {
|
|
return strconv.AppendInt(dst, val, 10)
|
|
}
|
|
|
|
func (b BaseEncoder) AppendBool(dst []byte, val bool) []byte {
|
|
return strconv.AppendBool(dst, val)
|
|
}
|
|
|
|
func (b BaseEncoder) AppendGroup(dst []byte, fields []Field) []byte {
|
|
dst = append(dst, b.group.start)
|
|
dst = b.appendGroup(dst, fields, "")
|
|
|
|
return append(dst, b.group.end)
|
|
}
|
|
|
|
func (b BaseEncoder) appendGroup(dst []byte, fields []Field, prefix string) []byte {
|
|
if len(fields) > 0 {
|
|
dst = b.appendField(dst, fields[0], ".", b.delimeter)
|
|
for _, field := range fields[1:] {
|
|
dst = b.appendField(append(dst, b.group.deli), field, prefix, b.delimeter)
|
|
}
|
|
}
|
|
|
|
return dst
|
|
}
|
|
|
|
func (b BaseEncoder) AppendArray(dst []byte, in []Value) []byte {
|
|
dst = append(dst, b.array.start)
|
|
if len(in) > 0 {
|
|
dst = b.appendValue(dst, in[0], "", 0)
|
|
for _, value := range in[1:] {
|
|
dst = b.appendValue(append(dst, b.array.deli), value, "", 0)
|
|
}
|
|
}
|
|
|
|
return append(dst, b.array.end)
|
|
}
|
|
|
|
func (b BaseEncoder) AppendBytes(dst, in []byte) []byte {
|
|
dst = append(dst, '"')
|
|
dst = append(dst, in...)
|
|
|
|
return append(dst, '"')
|
|
}
|
|
|