github.com/joomcode/cue@v0.4.4-0.20221111115225-539fe3512047/pkg/joom/starlark/starlark.go (about)

     1  package alauda
     2  
     3  import (
     4  	"fmt"
     5  	"log"
     6  
     7  	"github.com/joomcode/cue/cue"
     8  	"github.com/joomcode/cue/internal/core/runtime"
     9  	"github.com/joomcode/cue/internal/value"
    10  	"go.starlark.net/starlark"
    11  )
    12  
    13  func Run(in cue.Value, fn *starlark.Function, r *runtime.Runtime) (*cue.Value, error) {
    14  	var args starlark.Tuple
    15  	cueFunctionArgs := in
    16  	if cueFunctionArgs.Exists() {
    17  		var argStruct interface{}
    18  		if err := cueFunctionArgs.Decode(&argStruct); err != nil {
    19  			return nil, err
    20  		}
    21  		marshalledArgs, err := marshallStarlarkValue(argStruct)
    22  		if err != nil {
    23  			return nil, err
    24  		}
    25  		args = starlark.Tuple{marshalledArgs}
    26  	}
    27  
    28  	thread := &starlark.Thread{Name: "function execution"}
    29  	result, err := starlark.Call(thread, fn, args, nil)
    30  	if err != nil {
    31  		if evalErr, ok := err.(*starlark.EvalError); ok {
    32  			log.Fatal(evalErr.Backtrace())
    33  		}
    34  		return nil, err
    35  	}
    36  
    37  	var resultStruct interface{}
    38  	resultStruct, err = unmarshallStarlarkValue(result)
    39  	if err != nil {
    40  		return nil, err
    41  	}
    42  	v := value.FromGoValue((*cue.Context)(r), resultStruct, true)
    43  	if err := v.Err(); err != nil {
    44  		return &v, err
    45  	}
    46  	return &v, nil
    47  }
    48  
    49  func ExtractFunctionName(val cue.Value) (string, error) {
    50  	starFuncNameField := val.LookupPath(cue.ParsePath("$star"))
    51  	if !starFuncNameField.Exists() {
    52  		return "", fmt.Errorf("starlark function name must be specified: %v", val)
    53  	}
    54  	functionName, err := starFuncNameField.String()
    55  	if err != nil {
    56  		return "", err
    57  	}
    58  	return functionName, nil
    59  }
    60  
    61  //func validateSchema(_ *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
    62  //	var schemaPath string
    63  //	var dataValue starlark.Value
    64  //
    65  //	if err := starlark.UnpackArgs(b.Name(), args, kwargs, "data", &dataValue, "schema", &schemaPath); err != nil {
    66  //		return nil, err
    67  //	}
    68  //	cueSchema, err := cuetools.LoadConfig(schemaPath, cuetools.ConfigContext{}, true)
    69  //	if err != nil {
    70  //		return starlark.Bool(false), err
    71  //	}
    72  //
    73  //	data, err := unmarshallStarlarkValue(dataValue)
    74  //	if err != nil {
    75  //		return starlark.Bool(false), err
    76  //	}
    77  //
    78  //	var cueData cue.Value
    79  	// @see https://github.com/cue-lang/cue/issues/1806 for notes on Runtime deprecation
    80  	//codec := gocodec.New((*cue.Runtime)(cueSchema.Context()), nil)
    81  	//v := value.FromGoValue(cueSchema.Context(), data, true)
    82  
    83  	//if cueData, err = codec.Decode(data); err != nil {
    84  	//	return starlark.Bool(false), cuetools.CueErrorDetails(err)
    85  	//}
    86  //	if err = cueData.Unify(*cueSchema).Validate(); err != nil {
    87  //		fmt.Println("schema validation error:", cuetools.CueErrorDetails(err).Error())
    88  //		return starlark.Bool(false), nil
    89  //	}
    90  //	return starlark.Bool(true), nil
    91  //}
    92  //