aboutsummaryrefslogtreecommitdiffstats
path: root/vendor/gotest.tools/v3/internal/source
diff options
context:
space:
mode:
authorEugene Triguba <eugenetriguba@gmail.com>2024-01-06 16:23:02 -0500
committerEugene Triguba <eugenetriguba@gmail.com>2024-01-06 16:23:02 -0500
commit263ce3e4b368a50efee1a53af11a76a12af0a119 (patch)
tree8917754f3b43830604f6ad4c7115934ed633f1d8 /vendor/gotest.tools/v3/internal/source
parentFix syntax (diff)
downloadcli-263ce3e4b368a50efee1a53af11a76a12af0a119.zip
Break up migration repo into fs and db with a service
Diffstat (limited to 'vendor/gotest.tools/v3/internal/source')
-rw-r--r--vendor/gotest.tools/v3/internal/source/defers.go52
-rw-r--r--vendor/gotest.tools/v3/internal/source/source.go148
-rw-r--r--vendor/gotest.tools/v3/internal/source/update.go171
-rw-r--r--vendor/gotest.tools/v3/internal/source/version.go35
4 files changed, 406 insertions, 0 deletions
diff --git a/vendor/gotest.tools/v3/internal/source/defers.go b/vendor/gotest.tools/v3/internal/source/defers.go
new file mode 100644
index 0000000..392d9fe
--- /dev/null
+++ b/vendor/gotest.tools/v3/internal/source/defers.go
@@ -0,0 +1,52 @@
+package source
+
+import (
+ "fmt"
+ "go/ast"
+ "go/token"
+)
+
+func scanToDeferLine(fileset *token.FileSet, node ast.Node, lineNum int) ast.Node {
+ var matchedNode ast.Node
+ ast.Inspect(node, func(node ast.Node) bool {
+ switch {
+ case node == nil || matchedNode != nil:
+ return false
+ case fileset.Position(node.End()).Line == lineNum:
+ if funcLit, ok := node.(*ast.FuncLit); ok {
+ matchedNode = funcLit
+ return false
+ }
+ }
+ return true
+ })
+ debug("defer line node: %s", debugFormatNode{matchedNode})
+ return matchedNode
+}
+
+func guessDefer(node ast.Node) (ast.Node, error) {
+ defers := collectDefers(node)
+ switch len(defers) {
+ case 0:
+ return nil, fmt.Errorf("failed to find expression in defer")
+ case 1:
+ return defers[0].Call, nil
+ default:
+ return nil, fmt.Errorf(
+ "ambiguous call expression: multiple (%d) defers in call block",
+ len(defers))
+ }
+}
+
+func collectDefers(node ast.Node) []*ast.DeferStmt {
+ var defers []*ast.DeferStmt
+ ast.Inspect(node, func(node ast.Node) bool {
+ if d, ok := node.(*ast.DeferStmt); ok {
+ defers = append(defers, d)
+ debug("defer: %s", debugFormatNode{d})
+ return false
+ }
+ return true
+ })
+ return defers
+}
diff --git a/vendor/gotest.tools/v3/internal/source/source.go b/vendor/gotest.tools/v3/internal/source/source.go
new file mode 100644
index 0000000..a4fc24e
--- /dev/null
+++ b/vendor/gotest.tools/v3/internal/source/source.go
@@ -0,0 +1,148 @@
+// Package source provides utilities for handling source-code.
+package source // import "gotest.tools/v3/internal/source"
+
+import (
+ "bytes"
+ "errors"
+ "fmt"
+ "go/ast"
+ "go/format"
+ "go/parser"
+ "go/token"
+ "os"
+ "runtime"
+)
+
+// FormattedCallExprArg returns the argument from an ast.CallExpr at the
+// index in the call stack. The argument is formatted using FormatNode.
+func FormattedCallExprArg(stackIndex int, argPos int) (string, error) {
+ args, err := CallExprArgs(stackIndex + 1)
+ if err != nil {
+ return "", err
+ }
+ if argPos >= len(args) {
+ return "", errors.New("failed to find expression")
+ }
+ return FormatNode(args[argPos])
+}
+
+// CallExprArgs returns the ast.Expr slice for the args of an ast.CallExpr at
+// the index in the call stack.
+func CallExprArgs(stackIndex int) ([]ast.Expr, error) {
+ _, filename, line, ok := runtime.Caller(stackIndex + 1)
+ if !ok {
+ return nil, errors.New("failed to get call stack")
+ }
+ debug("call stack position: %s:%d", filename, line)
+
+ fileset := token.NewFileSet()
+ astFile, err := parser.ParseFile(fileset, filename, nil, parser.AllErrors)
+ if err != nil {
+ return nil, fmt.Errorf("failed to parse source file %s: %w", filename, err)
+ }
+
+ expr, err := getCallExprArgs(fileset, astFile, line)
+ if err != nil {
+ return nil, fmt.Errorf("call from %s:%d: %w", filename, line, err)
+ }
+ return expr, nil
+}
+
+func getNodeAtLine(fileset *token.FileSet, astFile ast.Node, lineNum int) (ast.Node, error) {
+ if node := scanToLine(fileset, astFile, lineNum); node != nil {
+ return node, nil
+ }
+ if node := scanToDeferLine(fileset, astFile, lineNum); node != nil {
+ node, err := guessDefer(node)
+ if err != nil || node != nil {
+ return node, err
+ }
+ }
+ return nil, nil
+}
+
+func scanToLine(fileset *token.FileSet, node ast.Node, lineNum int) ast.Node {
+ var matchedNode ast.Node
+ ast.Inspect(node, func(node ast.Node) bool {
+ switch {
+ case node == nil || matchedNode != nil:
+ return false
+ case fileset.Position(node.Pos()).Line == lineNum:
+ matchedNode = node
+ return false
+ }
+ return true
+ })
+ return matchedNode
+}
+
+func getCallExprArgs(fileset *token.FileSet, astFile ast.Node, line int) ([]ast.Expr, error) {
+ node, err := getNodeAtLine(fileset, astFile, line)
+ switch {
+ case err != nil:
+ return nil, err
+ case node == nil:
+ return nil, fmt.Errorf("failed to find an expression")
+ }
+
+ debug("found node: %s", debugFormatNode{node})
+
+ visitor := &callExprVisitor{}
+ ast.Walk(visitor, node)
+ if visitor.expr == nil {
+ return nil, errors.New("failed to find call expression")
+ }
+ debug("callExpr: %s", debugFormatNode{visitor.expr})
+ return visitor.expr.Args, nil
+}
+
+type callExprVisitor struct {
+ expr *ast.CallExpr
+}
+
+func (v *callExprVisitor) Visit(node ast.Node) ast.Visitor {
+ if v.expr != nil || node == nil {
+ return nil
+ }
+ debug("visit: %s", debugFormatNode{node})
+
+ switch typed := node.(type) {
+ case *ast.CallExpr:
+ v.expr = typed
+ return nil
+ case *ast.DeferStmt:
+ ast.Walk(v, typed.Call.Fun)
+ return nil
+ }
+ return v
+}
+
+// FormatNode using go/format.Node and return the result as a string
+func FormatNode(node ast.Node) (string, error) {
+ buf := new(bytes.Buffer)
+ err := format.Node(buf, token.NewFileSet(), node)
+ return buf.String(), err
+}
+
+var debugEnabled = os.Getenv("GOTESTTOOLS_DEBUG") != ""
+
+func debug(format string, args ...interface{}) {
+ if debugEnabled {
+ fmt.Fprintf(os.Stderr, "DEBUG: "+format+"\n", args...)
+ }
+}
+
+type debugFormatNode struct {
+ ast.Node
+}
+
+func (n debugFormatNode) String() string {
+ if n.Node == nil {
+ return "none"
+ }
+ out, err := FormatNode(n.Node)
+ if err != nil {
+ return fmt.Sprintf("failed to format %s: %s", n.Node, err)
+ }
+ return fmt.Sprintf("(%T) %s", n.Node, out)
+}
diff --git a/vendor/gotest.tools/v3/internal/source/update.go b/vendor/gotest.tools/v3/internal/source/update.go
new file mode 100644
index 0000000..5591bff
--- /dev/null
+++ b/vendor/gotest.tools/v3/internal/source/update.go
@@ -0,0 +1,171 @@
+package source
+
+import (
+ "bytes"
+ "errors"
+ "flag"
+ "fmt"
+ "go/ast"
+ "go/format"
+ "go/parser"
+ "go/token"
+ "os"
+ "runtime"
+ "strings"
+)
+
+// IsUpdate is returns true if the -update flag is set. It indicates the user
+// running the tests would like to update any golden values.
+func IsUpdate() bool {
+ if Update {
+ return true
+ }
+ return flag.Lookup("update").Value.(flag.Getter).Get().(bool)
+}
+
+// Update is a shim for testing, and for compatibility with the old -update-golden
+// flag.
+var Update bool
+
+func init() {
+ if f := flag.Lookup("update"); f != nil {
+ getter, ok := f.Value.(flag.Getter)
+ msg := "some other package defined an incompatible -update flag, expected a flag.Bool"
+ if !ok {
+ panic(msg)
+ }
+ if _, ok := getter.Get().(bool); !ok {
+ panic(msg)
+ }
+ return
+ }
+ flag.Bool("update", false, "update golden values")
+}
+
+// ErrNotFound indicates that UpdateExpectedValue failed to find the
+// variable to update, likely because it is not a package level variable.
+var ErrNotFound = fmt.Errorf("failed to find variable for update of golden value")
+
+// UpdateExpectedValue looks for a package-level variable with a name that
+// starts with expected in the arguments to the caller. If the variable is
+// found, the value of the variable will be updated to value of the other
+// argument to the caller.
+func UpdateExpectedValue(stackIndex int, x, y interface{}) error {
+ _, filename, line, ok := runtime.Caller(stackIndex + 1)
+ if !ok {
+ return errors.New("failed to get call stack")
+ }
+ debug("call stack position: %s:%d", filename, line)
+
+ fileset := token.NewFileSet()
+ astFile, err := parser.ParseFile(fileset, filename, nil, parser.AllErrors|parser.ParseComments)
+ if err != nil {
+ return fmt.Errorf("failed to parse source file %s: %w", filename, err)
+ }
+
+ expr, err := getCallExprArgs(fileset, astFile, line)
+ if err != nil {
+ return fmt.Errorf("call from %s:%d: %w", filename, line, err)
+ }
+
+ if len(expr) < 3 {
+ debug("not enough arguments %d: %v",
+ len(expr), debugFormatNode{Node: &ast.CallExpr{Args: expr}})
+ return ErrNotFound
+ }
+
+ argIndex, ident := getIdentForExpectedValueArg(expr)
+ if argIndex < 0 || ident == nil {
+ debug("no arguments started with the word 'expected': %v",
+ debugFormatNode{Node: &ast.CallExpr{Args: expr}})
+ return ErrNotFound
+ }
+
+ value := x
+ if argIndex == 1 {
+ value = y
+ }
+
+ strValue, ok := value.(string)
+ if !ok {
+ debug("value must be type string, got %T", value)
+ return ErrNotFound
+ }
+ return UpdateVariable(filename, fileset, astFile, ident, strValue)
+}
+
+// UpdateVariable writes to filename the contents of astFile with the value of
+// the variable updated to value.
+func UpdateVariable(
+ filename string,
+ fileset *token.FileSet,
+ astFile *ast.File,
+ ident *ast.Ident,
+ value string,
+) error {
+ obj := ident.Obj
+ if obj == nil {
+ return ErrNotFound
+ }
+ if obj.Kind != ast.Con && obj.Kind != ast.Var {
+ debug("can only update var and const, found %v", obj.Kind)
+ return ErrNotFound
+ }
+
+ switch decl := obj.Decl.(type) {
+ case *ast.ValueSpec:
+ if len(decl.Names) != 1 {
+ debug("more than one name in ast.ValueSpec")
+ return ErrNotFound
+ }
+
+ decl.Values[0] = &ast.BasicLit{
+ Kind: token.STRING,
+ Value: "`" + value + "`",
+ }
+
+ case *ast.AssignStmt:
+ if len(decl.Lhs) != 1 {
+ debug("more than one name in ast.AssignStmt")
+ return ErrNotFound
+ }
+
+ decl.Rhs[0] = &ast.BasicLit{
+ Kind: token.STRING,
+ Value: "`" + value + "`",
+ }
+
+ default:
+ debug("can only update *ast.ValueSpec, found %T", obj.Decl)
+ return ErrNotFound
+ }
+
+ var buf bytes.Buffer
+ if err := format.Node(&buf, fileset, astFile); err != nil {
+ return fmt.Errorf("failed to format file after update: %w", err)
+ }
+
+ fh, err := os.Create(filename)
+ if err != nil {
+ return fmt.Errorf("failed to open file %v: %w", filename, err)
+ }
+ if _, err = fh.Write(buf.Bytes()); err != nil {
+ return fmt.Errorf("failed to write file %v: %w", filename, err)
+ }
+ if err := fh.Sync(); err != nil {
+ return fmt.Errorf("failed to sync file %v: %w", filename, err)
+ }
+ return nil
+}
+
+func getIdentForExpectedValueArg(expr []ast.Expr) (int, *ast.Ident) {
+ for i := 1; i < 3; i++ {
+ switch e := expr[i].(type) {
+ case *ast.Ident:
+ if strings.HasPrefix(strings.ToLower(e.Name), "expected") {
+ return i, e
+ }
+ }
+ }
+ return -1, nil
+}
diff --git a/vendor/gotest.tools/v3/internal/source/version.go b/vendor/gotest.tools/v3/internal/source/version.go
new file mode 100644
index 0000000..5fa8a90
--- /dev/null
+++ b/vendor/gotest.tools/v3/internal/source/version.go
@@ -0,0 +1,35 @@
+package source
+
+import (
+ "runtime"
+ "strconv"
+ "strings"
+)
+
+// GoVersionLessThan returns true if runtime.Version() is semantically less than
+// version major.minor. Returns false if a release version can not be parsed from
+// runtime.Version().
+func GoVersionLessThan(major, minor int64) bool {
+ version := runtime.Version()
+ // not a release version
+ if !strings.HasPrefix(version, "go") {
+ return false
+ }
+ version = strings.TrimPrefix(version, "go")
+ parts := strings.Split(version, ".")
+ if len(parts) < 2 {
+ return false
+ }
+ rMajor, err := strconv.ParseInt(parts[0], 10, 32)
+ if err != nil {
+ return false
+ }
+ if rMajor != major {
+ return rMajor < major
+ }
+ rMinor, err := strconv.ParseInt(parts[1], 10, 32)
+ if err != nil {
+ return false
+ }
+ return rMinor < minor
+}