defaults.go

Documentation: github.com/go-task/slim-sprig/v3

     1  package sprig
     2  
     3  import (
     4  	"bytes"
     5  	"encoding/json"
     6  	"math/rand"
     7  	"reflect"
     8  	"strings"
     9  	"time"
    10  )
    11  
    12  func init() {
    13  	rand.Seed(time.Now().UnixNano())
    14  }
    15  
    16  // dfault checks whether `given` is set, and returns default if not set.
    17  //
    18  // This returns `d` if `given` appears not to be set, and `given` otherwise.
    19  //
    20  // For numeric types 0 is unset.
    21  // For strings, maps, arrays, and slices, len() = 0 is considered unset.
    22  // For bool, false is unset.
    23  // Structs are never considered unset.
    24  //
    25  // For everything else, including pointers, a nil value is unset.
    26  func dfault(d interface{}, given ...interface{}) interface{} {
    27  
    28  	if empty(given) || empty(given[0]) {
    29  		return d
    30  	}
    31  	return given[0]
    32  }
    33  
    34  // empty returns true if the given value has the zero value for its type.
    35  func empty(given interface{}) bool {
    36  	g := reflect.ValueOf(given)
    37  	if !g.IsValid() {
    38  		return true
    39  	}
    40  
    41  	// Basically adapted from text/template.isTrue
    42  	switch g.Kind() {
    43  	default:
    44  		return g.IsNil()
    45  	case reflect.Array, reflect.Slice, reflect.Map, reflect.String:
    46  		return g.Len() == 0
    47  	case reflect.Bool:
    48  		return !g.Bool()
    49  	case reflect.Complex64, reflect.Complex128:
    50  		return g.Complex() == 0
    51  	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
    52  		return g.Int() == 0
    53  	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
    54  		return g.Uint() == 0
    55  	case reflect.Float32, reflect.Float64:
    56  		return g.Float() == 0
    57  	case reflect.Struct:
    58  		return false
    59  	}
    60  }
    61  
    62  // coalesce returns the first non-empty value.
    63  func coalesce(v ...interface{}) interface{} {
    64  	for _, val := range v {
    65  		if !empty(val) {
    66  			return val
    67  		}
    68  	}
    69  	return nil
    70  }
    71  
    72  // all returns true if empty(x) is false for all values x in the list.
    73  // If the list is empty, return true.
    74  func all(v ...interface{}) bool {
    75  	for _, val := range v {
    76  		if empty(val) {
    77  			return false
    78  		}
    79  	}
    80  	return true
    81  }
    82  
    83  // any returns true if empty(x) is false for any x in the list.
    84  // If the list is empty, return false.
    85  func any(v ...interface{}) bool {
    86  	for _, val := range v {
    87  		if !empty(val) {
    88  			return true
    89  		}
    90  	}
    91  	return false
    92  }
    93  
    94  // fromJson decodes JSON into a structured value, ignoring errors.
    95  func fromJson(v string) interface{} {
    96  	output, _ := mustFromJson(v)
    97  	return output
    98  }
    99  
   100  // mustFromJson decodes JSON into a structured value, returning errors.
   101  func mustFromJson(v string) (interface{}, error) {
   102  	var output interface{}
   103  	err := json.Unmarshal([]byte(v), &output)
   104  	return output, err
   105  }
   106  
   107  // toJson encodes an item into a JSON string
   108  func toJson(v interface{}) string {
   109  	output, _ := json.Marshal(v)
   110  	return string(output)
   111  }
   112  
   113  func mustToJson(v interface{}) (string, error) {
   114  	output, err := json.Marshal(v)
   115  	if err != nil {
   116  		return "", err
   117  	}
   118  	return string(output), nil
   119  }
   120  
   121  // toPrettyJson encodes an item into a pretty (indented) JSON string
   122  func toPrettyJson(v interface{}) string {
   123  	output, _ := json.MarshalIndent(v, "", "  ")
   124  	return string(output)
   125  }
   126  
   127  func mustToPrettyJson(v interface{}) (string, error) {
   128  	output, err := json.MarshalIndent(v, "", "  ")
   129  	if err != nil {
   130  		return "", err
   131  	}
   132  	return string(output), nil
   133  }
   134  
   135  // toRawJson encodes an item into a JSON string with no escaping of HTML characters.
   136  func toRawJson(v interface{}) string {
   137  	output, err := mustToRawJson(v)
   138  	if err != nil {
   139  		panic(err)
   140  	}
   141  	return string(output)
   142  }
   143  
   144  // mustToRawJson encodes an item into a JSON string with no escaping of HTML characters.
   145  func mustToRawJson(v interface{}) (string, error) {
   146  	buf := new(bytes.Buffer)
   147  	enc := json.NewEncoder(buf)
   148  	enc.SetEscapeHTML(false)
   149  	err := enc.Encode(&v)
   150  	if err != nil {
   151  		return "", err
   152  	}
   153  	return strings.TrimSuffix(buf.String(), "\n"), nil
   154  }
   155  
   156  // ternary returns the first value if the last value is true, otherwise returns the second value.
   157  func ternary(vt interface{}, vf interface{}, v bool) interface{} {
   158  	if v {
   159  		return vt
   160  	}
   161  
   162  	return vf
   163  }
   164
View as plain text