github.com/grahambrereton-form3/tilt@v0.10.18/internal/tiltfile/value/value.go (about)

     1  package value
     2  
     3  import (
     4  	"fmt"
     5  
     6  	"go.starlark.net/starlark"
     7  
     8  	"github.com/windmilleng/tilt/internal/tiltfile/starkit"
     9  )
    10  
    11  // If `v` is a `starlark.Sequence`, return a slice of its elements
    12  // Otherwise, return it as a single-element slice
    13  // For functions that take `Union[List[T], T]`
    14  func ValueOrSequenceToSlice(v starlark.Value) []starlark.Value {
    15  	if seq, ok := v.(starlark.Sequence); ok {
    16  		var ret []starlark.Value
    17  		it := seq.Iterate()
    18  		defer it.Done()
    19  		var i starlark.Value
    20  		for it.Next(&i) {
    21  			ret = append(ret, i)
    22  		}
    23  		return ret
    24  	} else if v == nil || v == starlark.None {
    25  		return nil
    26  	} else {
    27  		return []starlark.Value{v}
    28  	}
    29  }
    30  
    31  func ValueToStringMap(v starlark.Value) (map[string]string, error) {
    32  	var result map[string]string
    33  	if v != nil && v != starlark.None {
    34  		d, ok := v.(*starlark.Dict)
    35  		if !ok {
    36  			return nil, fmt.Errorf("expected dict, got %T", v)
    37  		}
    38  
    39  		var err error
    40  		result, err = skylarkStringDictToGoMap(d)
    41  		if err != nil {
    42  			return nil, err
    43  		}
    44  	}
    45  	return result, nil
    46  }
    47  
    48  func skylarkStringDictToGoMap(d *starlark.Dict) (map[string]string, error) {
    49  	r := map[string]string{}
    50  
    51  	for _, tuple := range d.Items() {
    52  		kV, ok := AsString(tuple[0])
    53  		if !ok {
    54  			return nil, fmt.Errorf("key is not a string: %T (%v)", tuple[0], tuple[0])
    55  		}
    56  
    57  		k := string(kV)
    58  
    59  		vV, ok := AsString(tuple[1])
    60  		if !ok {
    61  			return nil, fmt.Errorf("value is not a string: %T (%v)", tuple[1], tuple[1])
    62  		}
    63  
    64  		v := string(vV)
    65  
    66  		r[k] = v
    67  	}
    68  
    69  	return r, nil
    70  }
    71  
    72  func ValueToAbsPath(thread *starlark.Thread, v starlark.Value) (string, error) {
    73  	pathMaker, ok := v.(PathMaker)
    74  	if ok {
    75  		return pathMaker.MakeLocalPath("."), nil
    76  	}
    77  
    78  	str, ok := v.(starlark.String)
    79  	if ok {
    80  		return starkit.AbsPath(thread, string(str)), nil
    81  	}
    82  
    83  	return "", fmt.Errorf("expected path | string. Actual type: %T", v)
    84  }
    85  
    86  type PathMaker interface {
    87  	MakeLocalPath(relPath string) string
    88  }
    89  
    90  func SequenceToStringSlice(seq starlark.Sequence) ([]string, error) {
    91  	if seq == nil {
    92  		return nil, nil
    93  	}
    94  	it := seq.Iterate()
    95  	defer it.Done()
    96  	var ret []string
    97  	var v starlark.Value
    98  	for it.Next(&v) {
    99  		s, ok := v.(starlark.String)
   100  		if !ok {
   101  			return nil, fmt.Errorf("'%v' is a %T, not a string", v, v)
   102  		}
   103  		ret = append(ret, string(s))
   104  	}
   105  	return ret, nil
   106  }