github.com/hairyhenderson/gomplate/v3@v3.11.7/funcs/random.go (about)

     1  package funcs
     2  
     3  import (
     4  	"context"
     5  	"strconv"
     6  	"unicode/utf8"
     7  
     8  	"github.com/hairyhenderson/gomplate/v3/conv"
     9  	iconv "github.com/hairyhenderson/gomplate/v3/internal/conv"
    10  	"github.com/hairyhenderson/gomplate/v3/random"
    11  	"github.com/pkg/errors"
    12  )
    13  
    14  // RandomNS -
    15  // Deprecated: don't use
    16  func RandomNS() *RandomFuncs {
    17  	return &RandomFuncs{}
    18  }
    19  
    20  // AddRandomFuncs -
    21  // Deprecated: use CreateRandomFuncs instead
    22  func AddRandomFuncs(f map[string]interface{}) {
    23  	for k, v := range CreateRandomFuncs(context.Background()) {
    24  		f[k] = v
    25  	}
    26  }
    27  
    28  // CreateRandomFuncs -
    29  func CreateRandomFuncs(ctx context.Context) map[string]interface{} {
    30  	ns := &RandomFuncs{ctx}
    31  	return map[string]interface{}{
    32  		"random": func() interface{} { return ns },
    33  	}
    34  }
    35  
    36  // RandomFuncs -
    37  type RandomFuncs struct {
    38  	ctx context.Context
    39  }
    40  
    41  // ASCII -
    42  func (RandomFuncs) ASCII(count interface{}) (string, error) {
    43  	return random.StringBounds(conv.ToInt(count), ' ', '~')
    44  }
    45  
    46  // Alpha -
    47  func (RandomFuncs) Alpha(count interface{}) (string, error) {
    48  	return random.StringRE(conv.ToInt(count), "[[:alpha:]]")
    49  }
    50  
    51  // AlphaNum -
    52  func (RandomFuncs) AlphaNum(count interface{}) (string, error) {
    53  	return random.StringRE(conv.ToInt(count), "[[:alnum:]]")
    54  }
    55  
    56  // String -
    57  func (RandomFuncs) String(count interface{}, args ...interface{}) (s string, err error) {
    58  	c := conv.ToInt(count)
    59  	if c == 0 {
    60  		return "", errors.New("count must be greater than 0")
    61  	}
    62  	m := ""
    63  	switch len(args) {
    64  	case 0:
    65  		m = ""
    66  	case 1:
    67  		m = conv.ToString(args[0])
    68  	case 2:
    69  		var l, u rune
    70  		if isString(args[0]) && isString(args[1]) {
    71  			l, u, err = toCodePoints(args[0].(string), args[1].(string))
    72  			if err != nil {
    73  				return "", err
    74  			}
    75  		} else {
    76  			l = rune(conv.ToInt(args[0]))
    77  			u = rune(conv.ToInt(args[1]))
    78  		}
    79  
    80  		return random.StringBounds(c, l, u)
    81  	}
    82  
    83  	return random.StringRE(c, m)
    84  }
    85  
    86  func isString(s interface{}) bool {
    87  	switch s.(type) {
    88  	case string:
    89  		return true
    90  	default:
    91  		return false
    92  	}
    93  }
    94  
    95  var rlen = utf8.RuneCountInString
    96  
    97  func toCodePoints(l, u string) (rune, rune, error) {
    98  	// no way are these representing valid printable codepoints - we'll treat
    99  	// them as runes
   100  	if rlen(l) == 1 && rlen(u) == 1 {
   101  		lower, _ := utf8.DecodeRuneInString(l)
   102  		upper, _ := utf8.DecodeRuneInString(u)
   103  		return lower, upper, nil
   104  	}
   105  
   106  	li, err := strconv.ParseInt(l, 0, 32)
   107  	if err != nil {
   108  		return 0, 0, err
   109  	}
   110  	ui, err := strconv.ParseInt(u, 0, 32)
   111  	if err != nil {
   112  		return 0, 0, err
   113  	}
   114  
   115  	return rune(li), rune(ui), nil
   116  }
   117  
   118  // Item -
   119  func (RandomFuncs) Item(items interface{}) (interface{}, error) {
   120  	i, err := iconv.InterfaceSlice(items)
   121  	if err != nil {
   122  		return nil, err
   123  	}
   124  	return random.Item(i)
   125  }
   126  
   127  // Number -
   128  func (RandomFuncs) Number(args ...interface{}) (int64, error) {
   129  	var min, max int64
   130  	min, max = 0, 100
   131  	switch len(args) {
   132  	case 0:
   133  	case 1:
   134  		max = conv.ToInt64(args[0])
   135  	case 2:
   136  		min = conv.ToInt64(args[0])
   137  		max = conv.ToInt64(args[1])
   138  	}
   139  	return random.Number(min, max)
   140  }
   141  
   142  // Float -
   143  func (RandomFuncs) Float(args ...interface{}) (float64, error) {
   144  	var min, max float64
   145  	min, max = 0, 1.0
   146  	switch len(args) {
   147  	case 0:
   148  	case 1:
   149  		max = conv.ToFloat64(args[0])
   150  	case 2:
   151  		min = conv.ToFloat64(args[0])
   152  		max = conv.ToFloat64(args[1])
   153  	}
   154  	return random.Float(min, max)
   155  }