planetscale 0.2.0 → 0.3.3

data/vendor/google.golang.org/protobuf/internal/descfmt/stringer.go

@@ -1,318 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package descfmt provides functionality to format descriptors.
-package descfmt
-
-import (
-	"fmt"
-	"io"
-	"reflect"
-	"strconv"
-	"strings"
-
-	"google.golang.org/protobuf/internal/detrand"
-	"google.golang.org/protobuf/internal/pragma"
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-type list interface {
-	Len() int
-	pragma.DoNotImplement
-}
-
-func FormatList(s fmt.State, r rune, vs list) {
-	io.WriteString(s, formatListOpt(vs, true, r == 'v' && (s.Flag('+') || s.Flag('#'))))
-}
-func formatListOpt(vs list, isRoot, allowMulti bool) string {
-	start, end := "[", "]"
-	if isRoot {
-		var name string
-		switch vs.(type) {
-		case pref.Names:
-			name = "Names"
-		case pref.FieldNumbers:
-			name = "FieldNumbers"
-		case pref.FieldRanges:
-			name = "FieldRanges"
-		case pref.EnumRanges:
-			name = "EnumRanges"
-		case pref.FileImports:
-			name = "FileImports"
-		case pref.Descriptor:
-			name = reflect.ValueOf(vs).MethodByName("Get").Type().Out(0).Name() + "s"
-		default:
-			name = reflect.ValueOf(vs).Elem().Type().Name()
-		}
-		start, end = name+"{", "}"
-	}
-
-	var ss []string
-	switch vs := vs.(type) {
-	case pref.Names:
-		for i := 0; i < vs.Len(); i++ {
-			ss = append(ss, fmt.Sprint(vs.Get(i)))
-		}
-		return start + joinStrings(ss, false) + end
-	case pref.FieldNumbers:
-		for i := 0; i < vs.Len(); i++ {
-			ss = append(ss, fmt.Sprint(vs.Get(i)))
-		}
-		return start + joinStrings(ss, false) + end
-	case pref.FieldRanges:
-		for i := 0; i < vs.Len(); i++ {
-			r := vs.Get(i)
-			if r[0]+1 == r[1] {
-				ss = append(ss, fmt.Sprintf("%d", r[0]))
-			} else {
-				ss = append(ss, fmt.Sprintf("%d:%d", r[0], r[1])) // enum ranges are end exclusive
-			}
-		}
-		return start + joinStrings(ss, false) + end
-	case pref.EnumRanges:
-		for i := 0; i < vs.Len(); i++ {
-			r := vs.Get(i)
-			if r[0] == r[1] {
-				ss = append(ss, fmt.Sprintf("%d", r[0]))
-			} else {
-				ss = append(ss, fmt.Sprintf("%d:%d", r[0], int64(r[1])+1)) // enum ranges are end inclusive
-			}
-		}
-		return start + joinStrings(ss, false) + end
-	case pref.FileImports:
-		for i := 0; i < vs.Len(); i++ {
-			var rs records
-			rs.Append(reflect.ValueOf(vs.Get(i)), "Path", "Package", "IsPublic", "IsWeak")
-			ss = append(ss, "{"+rs.Join()+"}")
-		}
-		return start + joinStrings(ss, allowMulti) + end
-	default:
-		_, isEnumValue := vs.(pref.EnumValueDescriptors)
-		for i := 0; i < vs.Len(); i++ {
-			m := reflect.ValueOf(vs).MethodByName("Get")
-			v := m.Call([]reflect.Value{reflect.ValueOf(i)})[0].Interface()
-			ss = append(ss, formatDescOpt(v.(pref.Descriptor), false, allowMulti && !isEnumValue))
-		}
-		return start + joinStrings(ss, allowMulti && isEnumValue) + end
-	}
-}
-
-// descriptorAccessors is a list of accessors to print for each descriptor.
-//
-// Do not print all accessors since some contain redundant information,
-// while others are pointers that we do not want to follow since the descriptor
-// is actually a cyclic graph.
-//
-// Using a list allows us to print the accessors in a sensible order.
-var descriptorAccessors = map[reflect.Type][]string{
-	reflect.TypeOf((*pref.FileDescriptor)(nil)).Elem():      {"Path", "Package", "Imports", "Messages", "Enums", "Extensions", "Services"},
-	reflect.TypeOf((*pref.MessageDescriptor)(nil)).Elem():   {"IsMapEntry", "Fields", "Oneofs", "ReservedNames", "ReservedRanges", "RequiredNumbers", "ExtensionRanges", "Messages", "Enums", "Extensions"},
-	reflect.TypeOf((*pref.FieldDescriptor)(nil)).Elem():     {"Number", "Cardinality", "Kind", "HasJSONName", "JSONName", "HasPresence", "IsExtension", "IsPacked", "IsWeak", "IsList", "IsMap", "MapKey", "MapValue", "HasDefault", "Default", "ContainingOneof", "ContainingMessage", "Message", "Enum"},
-	reflect.TypeOf((*pref.OneofDescriptor)(nil)).Elem():     {"Fields"}, // not directly used; must keep in sync with formatDescOpt
-	reflect.TypeOf((*pref.EnumDescriptor)(nil)).Elem():      {"Values", "ReservedNames", "ReservedRanges"},
-	reflect.TypeOf((*pref.EnumValueDescriptor)(nil)).Elem(): {"Number"},
-	reflect.TypeOf((*pref.ServiceDescriptor)(nil)).Elem():   {"Methods"},
-	reflect.TypeOf((*pref.MethodDescriptor)(nil)).Elem():    {"Input", "Output", "IsStreamingClient", "IsStreamingServer"},
-}
-
-func FormatDesc(s fmt.State, r rune, t pref.Descriptor) {
-	io.WriteString(s, formatDescOpt(t, true, r == 'v' && (s.Flag('+') || s.Flag('#'))))
-}
-func formatDescOpt(t pref.Descriptor, isRoot, allowMulti bool) string {
-	rv := reflect.ValueOf(t)
-	rt := rv.MethodByName("ProtoType").Type().In(0)
-
-	start, end := "{", "}"
-	if isRoot {
-		start = rt.Name() + "{"
-	}
-
-	_, isFile := t.(pref.FileDescriptor)
-	rs := records{allowMulti: allowMulti}
-	if t.IsPlaceholder() {
-		if isFile {
-			rs.Append(rv, "Path", "Package", "IsPlaceholder")
-		} else {
-			rs.Append(rv, "FullName", "IsPlaceholder")
-		}
-	} else {
-		switch {
-		case isFile:
-			rs.Append(rv, "Syntax")
-		case isRoot:
-			rs.Append(rv, "Syntax", "FullName")
-		default:
-			rs.Append(rv, "Name")
-		}
-		switch t := t.(type) {
-		case pref.FieldDescriptor:
-			for _, s := range descriptorAccessors[rt] {
-				switch s {
-				case "MapKey":
-					if k := t.MapKey(); k != nil {
-						rs.recs = append(rs.recs, [2]string{"MapKey", k.Kind().String()})
-					}
-				case "MapValue":
-					if v := t.MapValue(); v != nil {
-						switch v.Kind() {
-						case pref.EnumKind:
-							rs.recs = append(rs.recs, [2]string{"MapValue", string(v.Enum().FullName())})
-						case pref.MessageKind, pref.GroupKind:
-							rs.recs = append(rs.recs, [2]string{"MapValue", string(v.Message().FullName())})
-						default:
-							rs.recs = append(rs.recs, [2]string{"MapValue", v.Kind().String()})
-						}
-					}
-				case "ContainingOneof":
-					if od := t.ContainingOneof(); od != nil {
-						rs.recs = append(rs.recs, [2]string{"Oneof", string(od.Name())})
-					}
-				case "ContainingMessage":
-					if t.IsExtension() {
-						rs.recs = append(rs.recs, [2]string{"Extendee", string(t.ContainingMessage().FullName())})
-					}
-				case "Message":
-					if !t.IsMap() {
-						rs.Append(rv, s)
-					}
-				default:
-					rs.Append(rv, s)
-				}
-			}
-		case pref.OneofDescriptor:
-			var ss []string
-			fs := t.Fields()
-			for i := 0; i < fs.Len(); i++ {
-				ss = append(ss, string(fs.Get(i).Name()))
-			}
-			if len(ss) > 0 {
-				rs.recs = append(rs.recs, [2]string{"Fields", "[" + joinStrings(ss, false) + "]"})
-			}
-		default:
-			rs.Append(rv, descriptorAccessors[rt]...)
-		}
-		if rv.MethodByName("GoType").IsValid() {
-			rs.Append(rv, "GoType")
-		}
-	}
-	return start + rs.Join() + end
-}
-
-type records struct {
-	recs       [][2]string
-	allowMulti bool
-}
-
-func (rs *records) Append(v reflect.Value, accessors ...string) {
-	for _, a := range accessors {
-		var rv reflect.Value
-		if m := v.MethodByName(a); m.IsValid() {
-			rv = m.Call(nil)[0]
-		}
-		if v.Kind() == reflect.Struct && !rv.IsValid() {
-			rv = v.FieldByName(a)
-		}
-		if !rv.IsValid() {
-			panic(fmt.Sprintf("unknown accessor: %v.%s", v.Type(), a))
-		}
-		if _, ok := rv.Interface().(pref.Value); ok {
-			rv = rv.MethodByName("Interface").Call(nil)[0]
-			if !rv.IsNil() {
-				rv = rv.Elem()
-			}
-		}
-
-		// Ignore zero values.
-		var isZero bool
-		switch rv.Kind() {
-		case reflect.Interface, reflect.Slice:
-			isZero = rv.IsNil()
-		case reflect.Bool:
-			isZero = rv.Bool() == false
-		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-			isZero = rv.Int() == 0
-		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-			isZero = rv.Uint() == 0
-		case reflect.String:
-			isZero = rv.String() == ""
-		}
-		if n, ok := rv.Interface().(list); ok {
-			isZero = n.Len() == 0
-		}
-		if isZero {
-			continue
-		}
-
-		// Format the value.
-		var s string
-		v := rv.Interface()
-		switch v := v.(type) {
-		case list:
-			s = formatListOpt(v, false, rs.allowMulti)
-		case pref.FieldDescriptor, pref.OneofDescriptor, pref.EnumValueDescriptor, pref.MethodDescriptor:
-			s = string(v.(pref.Descriptor).Name())
-		case pref.Descriptor:
-			s = string(v.FullName())
-		case string:
-			s = strconv.Quote(v)
-		case []byte:
-			s = fmt.Sprintf("%q", v)
-		default:
-			s = fmt.Sprint(v)
-		}
-		rs.recs = append(rs.recs, [2]string{a, s})
-	}
-}
-
-func (rs *records) Join() string {
-	var ss []string
-
-	// In single line mode, simply join all records with commas.
-	if !rs.allowMulti {
-		for _, r := range rs.recs {
-			ss = append(ss, r[0]+formatColon(0)+r[1])
-		}
-		return joinStrings(ss, false)
-	}
-
-	// In allowMulti line mode, align single line records for more readable output.
-	var maxLen int
-	flush := func(i int) {
-		for _, r := range rs.recs[len(ss):i] {
-			ss = append(ss, r[0]+formatColon(maxLen-len(r[0]))+r[1])
-		}
-		maxLen = 0
-	}
-	for i, r := range rs.recs {
-		if isMulti := strings.Contains(r[1], "\n"); isMulti {
-			flush(i)
-			ss = append(ss, r[0]+formatColon(0)+strings.Join(strings.Split(r[1], "\n"), "\n\t"))
-		} else if maxLen < len(r[0]) {
-			maxLen = len(r[0])
-		}
-	}
-	flush(len(rs.recs))
-	return joinStrings(ss, true)
-}
-
-func formatColon(padding int) string {
-	// Deliberately introduce instability into the debug output to
-	// discourage users from performing string comparisons.
-	// This provides us flexibility to change the output in the future.
-	if detrand.Bool() {
-		return ":" + strings.Repeat(" ", 1+padding) // use non-breaking spaces (U+00a0)
-	} else {
-		return ":" + strings.Repeat(" ", 1+padding) // use regular spaces (U+0020)
-	}
-}
-
-func joinStrings(ss []string, isMulti bool) string {
-	if len(ss) == 0 {
-		return ""
-	}
-	if isMulti {
-		return "\n\t" + strings.Join(ss, "\n\t") + "\n"
-	}
-	return strings.Join(ss, ", ")
-}

data/vendor/google.golang.org/protobuf/internal/descopts/options.go

@@ -1,29 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package descopts contains the nil pointers to concrete descriptor options.
-//
-// This package exists as a form of reverse dependency injection so that certain
-// packages (e.g., internal/filedesc and internal/filetype can avoid a direct
-// dependency on the descriptor proto package).
-package descopts
-
-import pref "google.golang.org/protobuf/reflect/protoreflect"
-
-// These variables are set by the init function in descriptor.pb.go via logic
-// in internal/filetype. In other words, so long as the descriptor proto package
-// is linked in, these variables will be populated.
-//
-// Each variable is populated with a nil pointer to the options struct.
-var (
-	File           pref.ProtoMessage
-	Enum           pref.ProtoMessage
-	EnumValue      pref.ProtoMessage
-	Message        pref.ProtoMessage
-	Field          pref.ProtoMessage
-	Oneof          pref.ProtoMessage
-	ExtensionRange pref.ProtoMessage
-	Service        pref.ProtoMessage
-	Method         pref.ProtoMessage
-)

data/vendor/google.golang.org/protobuf/internal/detrand/rand.go

@@ -1,69 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package detrand provides deterministically random functionality.
-//
-// The pseudo-randomness of these functions is seeded by the program binary
-// itself and guarantees that the output does not change within a program,
-// while ensuring that the output is unstable across different builds.
-package detrand
-
-import (
-	"encoding/binary"
-	"hash/fnv"
-	"os"
-)
-
-// Disable disables detrand such that all functions returns the zero value.
-// This function is not concurrent-safe and must be called during program init.
-func Disable() {
-	randSeed = 0
-}
-
-// Bool returns a deterministically random boolean.
-func Bool() bool {
-	return randSeed%2 == 1
-}
-
-// Intn returns a deterministically random integer between 0 and n-1, inclusive.
-func Intn(n int) int {
-	if n <= 0 {
-		panic("must be positive")
-	}
-	return int(randSeed % uint64(n))
-}
-
-// randSeed is a best-effort at an approximate hash of the Go binary.
-var randSeed = binaryHash()
-
-func binaryHash() uint64 {
-	// Open the Go binary.
-	s, err := os.Executable()
-	if err != nil {
-		return 0
-	}
-	f, err := os.Open(s)
-	if err != nil {
-		return 0
-	}
-	defer f.Close()
-
-	// Hash the size and several samples of the Go binary.
-	const numSamples = 8
-	var buf [64]byte
-	h := fnv.New64()
-	fi, err := f.Stat()
-	if err != nil {
-		return 0
-	}
-	binary.LittleEndian.PutUint64(buf[:8], uint64(fi.Size()))
-	h.Write(buf[:8])
-	for i := int64(0); i < numSamples; i++ {
-		if _, err := f.ReadAt(buf[:], i*fi.Size()/numSamples); err != nil {
-			return 0
-		}
-		h.Write(buf[:])
-	}
-	return h.Sum64()
-}

data/vendor/google.golang.org/protobuf/internal/encoding/defval/default.go

@@ -1,213 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package defval marshals and unmarshals textual forms of default values.
-//
-// This package handles both the form historically used in Go struct field tags
-// and also the form used by google.protobuf.FieldDescriptorProto.default_value
-// since they differ in superficial ways.
-package defval
-
-import (
-	"fmt"
-	"math"
-	"strconv"
-
-	ptext "google.golang.org/protobuf/internal/encoding/text"
-	errors "google.golang.org/protobuf/internal/errors"
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// Format is the serialization format used to represent the default value.
-type Format int
-
-const (
-	_ Format = iota
-
-	// Descriptor uses the serialization format that protoc uses with the
-	// google.protobuf.FieldDescriptorProto.default_value field.
-	Descriptor
-
-	// GoTag uses the historical serialization format in Go struct field tags.
-	GoTag
-)
-
-// Unmarshal deserializes the default string s according to the given kind k.
-// When k is an enum, a list of enum value descriptors must be provided.
-func Unmarshal(s string, k pref.Kind, evs pref.EnumValueDescriptors, f Format) (pref.Value, pref.EnumValueDescriptor, error) {
-	switch k {
-	case pref.BoolKind:
-		if f == GoTag {
-			switch s {
-			case "1":
-				return pref.ValueOfBool(true), nil, nil
-			case "0":
-				return pref.ValueOfBool(false), nil, nil
-			}
-		} else {
-			switch s {
-			case "true":
-				return pref.ValueOfBool(true), nil, nil
-			case "false":
-				return pref.ValueOfBool(false), nil, nil
-			}
-		}
-	case pref.EnumKind:
-		if f == GoTag {
-			// Go tags use the numeric form of the enum value.
-			if n, err := strconv.ParseInt(s, 10, 32); err == nil {
-				if ev := evs.ByNumber(pref.EnumNumber(n)); ev != nil {
-					return pref.ValueOfEnum(ev.Number()), ev, nil
-				}
-			}
-		} else {
-			// Descriptor default_value use the enum identifier.
-			ev := evs.ByName(pref.Name(s))
-			if ev != nil {
-				return pref.ValueOfEnum(ev.Number()), ev, nil
-			}
-		}
-	case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
-		if v, err := strconv.ParseInt(s, 10, 32); err == nil {
-			return pref.ValueOfInt32(int32(v)), nil, nil
-		}
-	case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
-		if v, err := strconv.ParseInt(s, 10, 64); err == nil {
-			return pref.ValueOfInt64(int64(v)), nil, nil
-		}
-	case pref.Uint32Kind, pref.Fixed32Kind:
-		if v, err := strconv.ParseUint(s, 10, 32); err == nil {
-			return pref.ValueOfUint32(uint32(v)), nil, nil
-		}
-	case pref.Uint64Kind, pref.Fixed64Kind:
-		if v, err := strconv.ParseUint(s, 10, 64); err == nil {
-			return pref.ValueOfUint64(uint64(v)), nil, nil
-		}
-	case pref.FloatKind, pref.DoubleKind:
-		var v float64
-		var err error
-		switch s {
-		case "-inf":
-			v = math.Inf(-1)
-		case "inf":
-			v = math.Inf(+1)
-		case "nan":
-			v = math.NaN()
-		default:
-			v, err = strconv.ParseFloat(s, 64)
-		}
-		if err == nil {
-			if k == pref.FloatKind {
-				return pref.ValueOfFloat32(float32(v)), nil, nil
-			} else {
-				return pref.ValueOfFloat64(float64(v)), nil, nil
-			}
-		}
-	case pref.StringKind:
-		// String values are already unescaped and can be used as is.
-		return pref.ValueOfString(s), nil, nil
-	case pref.BytesKind:
-		if b, ok := unmarshalBytes(s); ok {
-			return pref.ValueOfBytes(b), nil, nil
-		}
-	}
-	return pref.Value{}, nil, errors.New("could not parse value for %v: %q", k, s)
-}
-
-// Marshal serializes v as the default string according to the given kind k.
-// When specifying the Descriptor format for an enum kind, the associated
-// enum value descriptor must be provided.
-func Marshal(v pref.Value, ev pref.EnumValueDescriptor, k pref.Kind, f Format) (string, error) {
-	switch k {
-	case pref.BoolKind:
-		if f == GoTag {
-			if v.Bool() {
-				return "1", nil
-			} else {
-				return "0", nil
-			}
-		} else {
-			if v.Bool() {
-				return "true", nil
-			} else {
-				return "false", nil
-			}
-		}
-	case pref.EnumKind:
-		if f == GoTag {
-			return strconv.FormatInt(int64(v.Enum()), 10), nil
-		} else {
-			return string(ev.Name()), nil
-		}
-	case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind, pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
-		return strconv.FormatInt(v.Int(), 10), nil
-	case pref.Uint32Kind, pref.Fixed32Kind, pref.Uint64Kind, pref.Fixed64Kind:
-		return strconv.FormatUint(v.Uint(), 10), nil
-	case pref.FloatKind, pref.DoubleKind:
-		f := v.Float()
-		switch {
-		case math.IsInf(f, -1):
-			return "-inf", nil
-		case math.IsInf(f, +1):
-			return "inf", nil
-		case math.IsNaN(f):
-			return "nan", nil
-		default:
-			if k == pref.FloatKind {
-				return strconv.FormatFloat(f, 'g', -1, 32), nil
-			} else {
-				return strconv.FormatFloat(f, 'g', -1, 64), nil
-			}
-		}
-	case pref.StringKind:
-		// String values are serialized as is without any escaping.
-		return v.String(), nil
-	case pref.BytesKind:
-		if s, ok := marshalBytes(v.Bytes()); ok {
-			return s, nil
-		}
-	}
-	return "", errors.New("could not format value for %v: %v", k, v)
-}
-
-// unmarshalBytes deserializes bytes by applying C unescaping.
-func unmarshalBytes(s string) ([]byte, bool) {
-	// Bytes values use the same escaping as the text format,
-	// however they lack the surrounding double quotes.
-	v, err := ptext.UnmarshalString(`"` + s + `"`)
-	if err != nil {
-		return nil, false
-	}
-	return []byte(v), true
-}
-
-// marshalBytes serializes bytes by using C escaping.
-// To match the exact output of protoc, this is identical to the
-// CEscape function in strutil.cc of the protoc source code.
-func marshalBytes(b []byte) (string, bool) {
-	var s []byte
-	for _, c := range b {
-		switch c {
-		case '\n':
-			s = append(s, `\n`...)
-		case '\r':
-			s = append(s, `\r`...)
-		case '\t':
-			s = append(s, `\t`...)
-		case '"':
-			s = append(s, `\"`...)
-		case '\'':
-			s = append(s, `\'`...)
-		case '\\':
-			s = append(s, `\\`...)
-		default:
-			if printableASCII := c >= 0x20 && c <= 0x7e; printableASCII {
-				s = append(s, c)
-			} else {
-				s = append(s, fmt.Sprintf(`\%03o`, c)...)
-			}
-		}
-	}
-	return string(s), true
-}