added

2025-12-19 05:21:03 +01:00 · 2024-05-14 12:10:58 +02:00
parent a9bb79b01c
commit 59911aebb9
645 changed files with 263320 additions and 0 deletions
--- a/vendor/github.com/shurcooL/go-goon/LICENSE
+++ b/vendor/github.com/shurcooL/go-goon/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2013 Dave Collins
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
--- a/vendor/github.com/shurcooL/go-goon/README.md
+++ b/vendor/github.com/shurcooL/go-goon/README.md
@@ -0,0 +1,92 @@
+goon
+====
+
+[![Go Reference](https://pkg.go.dev/badge/github.com/shurcooL/go-goon.svg)](https://pkg.go.dev/github.com/shurcooL/go-goon)
+
+Package goon is a deep pretty printer with Go-like notation. It implements the [goon](https://github.com/shurcooL/goon) specification.
+
+**Deprecated:** This package is old, incomplete, low code quality, and now unmaintained.
+See [github.com/hexops/valast](https://github.com/hexops/valast) for a newer package that is the closest known direct replacement.
+See the [Alternatives](#alternatives) section for other known entries in this problem space.
+
+Installation
+------------
+
+```bash
+go get github.com/shurcooL/go-goon
+```
+
+Examples
+--------
+
+```Go
+x := Lang{
+	Name: "Go",
+	Year: 2009,
+	URL:  "http",
+	Inner: &Inner{
+		Field1: "Secret!",
+	},
+}
+
+goon.Dump(x)
+
+// Output:
+// (Lang)(Lang{
+// 	Name: (string)("Go"),
+// 	Year: (int)(2009),
+// 	URL:  (string)("http"),
+// 	Inner: (*Inner)(&Inner{
+// 		Field1: (string)("Secret!"),
+// 		Field2: (int)(0),
+// 	}),
+// })
+```
+
+```Go
+items := []int{1, 2, 3}
+
+goon.DumpExpr(len(items))
+
+// Output:
+// len(items) = (int)(3)
+```
+
+```Go
+adderFunc := func(a int, b int) int {
+	c := a + b
+	return c
+}
+
+goon.DumpExpr(adderFunc)
+
+// Output:
+// adderFunc = (func(int, int) int)(func(a int, b int) int {
+// 	c := a + b
+// 	return c
+// })
+```
+
+Directories
+-----------
+
+| Path                                                            | Synopsis                                                                                    |
+|-----------------------------------------------------------------|---------------------------------------------------------------------------------------------|
+| [bypass](https://pkg.go.dev/github.com/shurcooL/go-goon/bypass) | Package bypass allows bypassing reflect restrictions on accessing unexported struct fields. |
+
+Alternatives
+------------
+
+-	[`go-spew`](https://github.com/davecgh/go-spew) - A deep pretty printer for Go data structures to aid in debugging.
+-	[`valast`](https://github.com/hexops/valast) - Convert Go values to their AST.
+-	[`repr`](https://github.com/alecthomas/repr) - Python's repr() for Go.
+
+Attribution
+-----------
+
+go-goon source was based on the existing source of [go-spew](https://github.com/davecgh/go-spew) by [Dave Collins](https://github.com/davecgh).
+
+License
+-------
+
+-	[MIT License](LICENSE)
--- a/vendor/github.com/shurcooL/go-goon/dump.go
+++ b/vendor/github.com/shurcooL/go-goon/dump.go
@@ -0,0 +1,394 @@
+package goon
+
+import (
+	"bytes"
+	"fmt"
+	"go/format"
+	"io"
+	"reflect"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/shurcooL/go/reflectsource"
+)
+
+var config = struct {
+	indent string
+}{
+	indent: "\t",
+}
+
+// dumpState contains information about the state of a dump operation.
+type dumpState struct {
+	w                io.Writer
+	depth            int
+	pointers         map[uintptr]int
+	ignoreNextType   bool
+	ignoreNextIndent bool
+}
+
+// indent performs indentation according to the depth level and cs.Indent
+// option.
+func (d *dumpState) indent() {
+	if d.ignoreNextIndent {
+		d.ignoreNextIndent = false
+		return
+	}
+	d.w.Write(bytes.Repeat([]byte(config.indent), d.depth))
+}
+
+// unpackValue returns values inside of non-nil interfaces when possible.
+// This is useful for data types like structs, arrays, slices, and maps which
+// can contain varying types packed inside an interface.
+func (d *dumpState) unpackValue(v reflect.Value) reflect.Value {
+	if v.Kind() == reflect.Interface && !v.IsNil() {
+		v = v.Elem()
+	}
+	return v
+}
+
+// dumpPtr handles formatting of pointers by indirecting them as necessary.
+func (d *dumpState) dumpPtr(v reflect.Value) {
+	// Remove pointers at or below the current depth from map used to detect
+	// circular refs.
+	for k, depth := range d.pointers {
+		if depth >= d.depth {
+			delete(d.pointers, k)
+		}
+	}
+
+	// Figure out how many levels of indirection there are by dereferencing
+	// pointers and unpacking interfaces down the chain while detecting circular
+	// references.
+	nilFound := false
+	cycleFound := false
+	indirects := 0
+	ve := v
+	for ve.Kind() == reflect.Ptr {
+		if ve.IsNil() {
+			nilFound = true
+			break
+		}
+		indirects++
+		addr := ve.Pointer()
+		if pd, ok := d.pointers[addr]; ok && pd < d.depth {
+			cycleFound = true
+			indirects--
+			break
+		}
+		d.pointers[addr] = d.depth
+
+		ve = ve.Elem()
+		if ve.Kind() == reflect.Interface {
+			if ve.IsNil() {
+				nilFound = true
+				break
+			}
+			ve = ve.Elem()
+		}
+	}
+
+	// Display type information.
+	d.w.Write(bytes.Repeat(ampersandBytes, indirects))
+
+	// Display dereferenced value.
+	switch {
+	case nilFound:
+		d.w.Write(nilBytes)
+
+	case cycleFound:
+		d.w.Write(circularBytes)
+
+	default:
+		d.ignoreNextType = true
+		d.dump(ve)
+	}
+}
+
+// dump is the main workhorse for dumping a value.  It uses the passed reflect
+// value to figure out what kind of object we are dealing with and formats it
+// appropriately.  It is a recursive function, however circular data structures
+// are detected and handled properly.
+func (d *dumpState) dump(v reflect.Value) {
+	// Handle invalid reflect values immediately.
+	kind := v.Kind()
+	if kind == reflect.Invalid {
+		d.w.Write(invalidAngleBytes)
+		return
+	}
+
+	// Handle pointers specially.
+	if kind == reflect.Ptr {
+		d.indent()
+		d.w.Write(openParenBytes)
+		d.w.Write([]byte(typeStringWithoutPackagePrefix(v)))
+		d.w.Write(closeParenBytes)
+		d.w.Write(openParenBytes)
+		d.dumpPtr(v)
+		d.w.Write(closeParenBytes)
+		return
+	}
+
+	// Print type information unless already handled elsewhere.
+	var shouldPrintClosingBr = false
+	if !d.ignoreNextType {
+		d.indent()
+		d.w.Write(openParenBytes)
+		d.w.Write([]byte(typeStringWithoutPackagePrefix(v)))
+		d.w.Write(closeParenBytes)
+		d.w.Write(openParenBytes)
+		shouldPrintClosingBr = true
+	}
+	d.ignoreNextType = false
+
+	if v.Type() == timeType {
+		t := v.Interface().(time.Time)
+		switch t.IsZero() {
+		case false:
+			var location string
+			switch t.Location() {
+			case time.UTC:
+				location = "time.UTC"
+			case time.Local:
+				location = "time.Local"
+			default:
+				location = fmt.Sprintf("must(time.LoadLocation(%q))", t.Location().String())
+			}
+			fmt.Fprintf(d.w, "time.Date(%d, %d, %d, %d, %d, %d, %d, %s)", t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second(), t.Nanosecond(), location)
+		case true:
+			d.w.Write([]byte("time.Time{}"))
+		}
+		goto AfterKindSwitch
+	}
+
+	switch kind {
+	case reflect.Invalid:
+		// Do nothing.  We should never get here since invalid has already
+		// been handled above.
+
+	case reflect.Bool:
+		printBool(d.w, v.Bool())
+
+	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
+		printInt(d.w, v.Int(), 10)
+
+	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
+		printUint(d.w, v.Uint(), 10)
+
+	case reflect.Float32:
+		printFloat(d.w, v.Float(), 32)
+
+	case reflect.Float64:
+		printFloat(d.w, v.Float(), 64)
+
+	case reflect.Complex64:
+		printComplex(d.w, v.Complex(), 32)
+
+	case reflect.Complex128:
+		printComplex(d.w, v.Complex(), 64)
+
+	case reflect.Array:
+		d.w.Write([]byte(typeStringWithoutPackagePrefix(v)))
+		d.w.Write(openBraceNewlineBytes)
+		d.depth++
+		for i := 0; i < v.Len(); i++ {
+			d.dump(d.unpackValue(v.Index(i)))
+			d.w.Write(commaNewlineBytes)
+		}
+		d.depth--
+		d.indent()
+		d.w.Write(closeBraceBytes)
+
+	case reflect.Slice:
+		if v.IsNil() {
+			d.w.Write(nilBytes)
+		} else {
+			d.w.Write([]byte(typeStringWithoutPackagePrefix(v)))
+			d.w.Write(openBraceNewlineBytes)
+			d.depth++
+			for i := 0; i < v.Len(); i++ {
+				d.dump(d.unpackValue(v.Index(i)))
+				d.w.Write(commaNewlineBytes)
+			}
+			d.depth--
+			d.indent()
+			d.w.Write(closeBraceBytes)
+		}
+
+	case reflect.String:
+		d.w.Write([]byte(strconv.Quote(v.String())))
+
+	case reflect.Interface:
+		// If we got here, it's because interface is nil
+		// See https://github.com/davecgh/go-spew/issues/12
+		d.w.Write(nilBytes)
+
+	case reflect.Ptr:
+		// Do nothing.  We should never get here since pointers have already
+		// been handled above.
+
+	case reflect.Map:
+		if v.IsNil() {
+			d.w.Write(nilBytes)
+		} else {
+			d.w.Write([]byte(typeStringWithoutPackagePrefix(v)))
+			d.w.Write(openBraceNewlineBytes)
+			d.depth++
+			keys := v.MapKeys()
+			for _, key := range keys {
+				d.dump(d.unpackValue(key))
+				d.w.Write(colonSpaceBytes)
+				d.ignoreNextIndent = true
+				d.dump(d.unpackValue(v.MapIndex(key)))
+				d.w.Write(commaNewlineBytes)
+			}
+			d.depth--
+			d.indent()
+			d.w.Write(closeBraceBytes)
+		}
+
+	case reflect.Struct:
+		d.w.Write([]byte(typeStringWithoutPackagePrefix(v)))
+		d.w.Write(openBraceBytes)
+		d.depth++
+		{
+			vt := v.Type()
+			numFields := v.NumField()
+			if numFields > 0 {
+				d.w.Write(newlineBytes)
+			}
+			for i := 0; i < numFields; i++ {
+				d.indent()
+				vtf := vt.Field(i)
+				d.w.Write([]byte(vtf.Name))
+				d.w.Write(colonSpaceBytes)
+				d.ignoreNextIndent = true
+				d.dump(d.unpackValue(v.Field(i)))
+				d.w.Write(commaBytes)
+				d.w.Write(newlineBytes)
+			}
+		}
+		d.depth--
+		d.indent()
+		d.w.Write(closeBraceBytes)
+
+	case reflect.Uintptr:
+		printHexPtr(d.w, uintptr(v.Uint()))
+
+	case reflect.Func:
+		d.w.Write([]byte(reflectsource.GetFuncValueSourceAsString(v)))
+
+	case reflect.UnsafePointer, reflect.Chan:
+		printHexPtr(d.w, v.Pointer())
+
+	// There were not any other types at the time this code was written, but
+	// fall back to letting the default fmt package handle it in case any new
+	// types are added.
+	default:
+		if v.CanInterface() {
+			fmt.Fprintf(d.w, "%v", v.Interface())
+		} else {
+			fmt.Fprintf(d.w, "%v", v.String())
+		}
+	}
+AfterKindSwitch:
+
+	if shouldPrintClosingBr {
+		d.w.Write(closeParenBytes)
+	}
+}
+
+var timeType = reflect.TypeOf(time.Time{})
+
+func typeStringWithoutPackagePrefix(v reflect.Value) string {
+	//return v.Type().String()[len(v.Type().PkgPath())+1:]		// TODO: Error checking?
+	//return v.Type().PkgPath()
+	//return v.Type().String()
+	//return v.Type().Name()
+
+	/*x := v.Type().String()
+	if strings.HasPrefix(x, "main.") {
+		x = x[len("main."):]
+	}
+	return x*/
+
+	px := v.Type().String()
+	prefix := px[0 : len(px)-len(strings.TrimLeft(px, "*"))] // Split "**main.Lang" -> "**" and "main.Lang"
+	x := px[len(prefix):]
+	x = strings.TrimPrefix(x, "main.")
+	x = strings.TrimPrefix(x, "goon_test.")
+	return prefix + x
+
+	/*x = string(debug.Stack())//GetLine(string(debug.Stack()), 0)
+	//x = x[1:strings.Index(x, ":")]
+	//spew.Printf(">%s<\n", x)
+	//panic(nil)
+	//st := string(debug.Stack())
+	//debug.PrintStack()
+
+	return x*/
+}
+
+// fdump is a helper function to consolidate the logic from the various public
+// methods which take varying writers and config states.
+func fdump(w io.Writer, a ...interface{}) {
+	for _, arg := range a {
+		d := dumpState{w: w}
+		if arg == nil {
+			d.w.Write(interfaceBytes)
+			d.w.Write(nilParenBytes)
+		} else {
+			d.pointers = make(map[uintptr]int)
+			d.dump(reflect.ValueOf(arg))
+		}
+		d.w.Write(newlineBytes)
+	}
+}
+
+// bdump dumps to []byte.
+func bdump(a ...interface{}) []byte {
+	var buf bytes.Buffer
+	fdump(&buf, a...)
+	return gofmt(buf.Bytes())
+}
+
+func fdumpNamed(w io.Writer, names []string, a ...interface{}) {
+	for argIndex, arg := range a {
+		d := dumpState{w: w}
+		if argIndex < len(names) {
+			d.w.Write([]byte(names[argIndex]))
+			d.w.Write([]byte(" = "))
+		}
+		if arg == nil {
+			d.w.Write(interfaceBytes)
+			d.w.Write(nilParenBytes)
+		} else {
+			d.pointers = make(map[uintptr]int)
+			d.dump(reflect.ValueOf(arg))
+		}
+		if len(names) >= len(a) {
+			d.w.Write(newlineBytes)
+		} else {
+			if argIndex < len(a)-1 {
+				d.w.Write(commaNewlineBytes)
+			} else {
+				d.w.Write(newlineBytes)
+			}
+		}
+	}
+}
+
+func bdumpNamed(names []string, a ...interface{}) []byte {
+	var buf bytes.Buffer
+	fdumpNamed(&buf, names, a...)
+	return gofmt(buf.Bytes())
+}
+
+func gofmt(src []byte) []byte {
+	formattedSrc, err := format.Source(src)
+	if nil != err {
+		return []byte("gofmt error (" + err.Error() + ")!\n" + string(src))
+	}
+	return formattedSrc
+}
--- a/vendor/github.com/shurcooL/go-goon/goon.go
+++ b/vendor/github.com/shurcooL/go-goon/goon.go
@@ -0,0 +1,56 @@
+// Package goon is a deep pretty printer with Go-like notation. It implements the goon specification.
+//
+// Deprecated: This package is old, incomplete, low code quality, and now unmaintained.
+// See github.com/hexops/valast for a newer package that is the closest known direct replacement.
+// See the Alternatives section in README.md for other known entries in this problem space.
+package goon
+
+import (
+	"io"
+	"os"
+
+	"github.com/shurcooL/go/reflectsource"
+)
+
+// Dump dumps goons to stdout.
+func Dump(a ...interface{}) (n int, err error) {
+	return os.Stdout.Write(bdump(a...))
+}
+
+// Sdump dumps goons to a string.
+func Sdump(a ...interface{}) string {
+	return string(bdump(a...))
+}
+
+// Fdump dumps goons to a writer.
+func Fdump(w io.Writer, a ...interface{}) (n int, err error) {
+	return w.Write(bdump(a...))
+}
+
+// DumpExpr dumps goon expressions to stdout.
+//
+// E.g., this:
+//
+// 	somethingImportant := 5
+// 	DumpExpr(somethingImportant)
+//
+// Will print:
+//
+// 	somethingImportant = (int)(5)
+func DumpExpr(a ...interface{}) (n int, err error) {
+	return os.Stdout.Write(bdumpNamed(reflectsource.GetParentArgExprAllAsString(), a...))
+}
+
+// SdumpExpr dumps goon expressions to a string.
+func SdumpExpr(a ...interface{}) string {
+	return string(bdumpNamed(reflectsource.GetParentArgExprAllAsString(), a...))
+}
+
+// FdumpExpr dumps goon expressions to a writer.
+func FdumpExpr(w io.Writer, a ...interface{}) (n int, err error) {
+	names := reflectsource.GetParentArgExprAllAsString()
+	if len(names) >= 1 {
+		names = names[1:] // First argument is the writer, skip it.
+	}
+	return w.Write(bdumpNamed(names, a...))
+}
--- a/vendor/github.com/shurcooL/go-goon/print_types.go
+++ b/vendor/github.com/shurcooL/go-goon/print_types.go
@@ -0,0 +1,107 @@
+package goon
+
+import (
+	"io"
+	"strconv"
+)
+
+// Some constants in the form of bytes to avoid string overhead.  This mirrors
+// the technique used in the fmt package.
+var (
+	plusBytes             = []byte("+")
+	iBytes                = []byte("i")
+	trueBytes             = []byte("true")
+	falseBytes            = []byte("false")
+	interfaceBytes        = []byte("(interface{})")
+	commaBytes            = []byte(",")
+	commaNewlineBytes     = []byte(",\n")
+	newlineBytes          = []byte("\n")
+	openBraceBytes        = []byte("{")
+	openBraceNewlineBytes = []byte("{\n")
+	closeBraceBytes       = []byte("}")
+	ampersandBytes        = []byte("&")
+	colonSpaceBytes       = []byte(": ")
+	openParenBytes        = []byte("(")
+	closeParenBytes       = []byte(")")
+	nilBytes              = []byte("nil")
+	nilParenBytes         = []byte("(nil)")
+	circularBytes         = []byte("already_shown")
+	invalidAngleBytes     = []byte("<invalid>")
+)
+
+// hexDigits is used to map a decimal value to a hex digit.
+var hexDigits = "0123456789abcdef"
+
+// printBool outputs a boolean value as true or false to Writer w.
+func printBool(w io.Writer, val bool) {
+	if val {
+		w.Write(trueBytes)
+	} else {
+		w.Write(falseBytes)
+	}
+}
+
+// printInt outputs a signed integer value to Writer w.
+func printInt(w io.Writer, val int64, base int) {
+	w.Write([]byte(strconv.FormatInt(val, base)))
+}
+
+// printUint outputs an unsigned integer value to Writer w.
+func printUint(w io.Writer, val uint64, base int) {
+	w.Write([]byte(strconv.FormatUint(val, base)))
+}
+
+// printFloat outputs a floating point value using the specified precision,
+// which is expected to be 32 or 64bit, to Writer w.
+func printFloat(w io.Writer, val float64, precision int) {
+	w.Write([]byte(strconv.FormatFloat(val, 'g', -1, precision)))
+}
+
+// printComplex outputs a complex value using the specified float precision
+// for the real and imaginary parts to Writer w.
+func printComplex(w io.Writer, c complex128, floatPrecision int) {
+	r := real(c)
+	w.Write(openParenBytes)
+	w.Write([]byte(strconv.FormatFloat(r, 'g', -1, floatPrecision)))
+	i := imag(c)
+	if i >= 0 {
+		w.Write(plusBytes)
+	}
+	w.Write([]byte(strconv.FormatFloat(i, 'g', -1, floatPrecision)))
+	w.Write(iBytes)
+	w.Write(closeParenBytes)
+}
+
+// printHexPtr outputs a uintptr formatted as hexidecimal with a leading '0x'
+// prefix to Writer w.
+func printHexPtr(w io.Writer, p uintptr) {
+	// Null pointer.
+	num := uint64(p)
+	if num == 0 {
+		w.Write(nilBytes)
+		return
+	}
+
+	// Max uint64 is 16 bytes in hex + 2 bytes for '0x' prefix
+	buf := make([]byte, 18)
+
+	// It's simpler to construct the hex string right to left.
+	base := uint64(16)
+	i := len(buf) - 1
+	for num >= base {
+		buf[i] = hexDigits[num%base]
+		num /= base
+		i--
+	}
+	buf[i] = hexDigits[num]
+
+	// Add '0x' prefix.
+	i--
+	buf[i] = 'x'
+	i--
+	buf[i] = '0'
+
+	// Strip unused leading bytes.
+	buf = buf[i:]
+	w.Write(buf)
+}