add lib methods: random.randstr, fix typos (#45)

* draft for randstr

* random value

* case 1

* fix nil / none

* for case cjk

* rename to chars

* Update docs

* '我爱你'

Author: hyorigo

lib/random/README.md

@@ -27,6 +27,30 @@ print(b)
 # Output: b'K\xaa\xbb4\xbaEh0\x19\x9c'
 ```
 
+### `randstr(chars, n)`
+
+Generate a random string containing n number of unicode characters from the given unicode string.
+
+#### Parameters
+
+| name    | type     | description                                                                                   |
+|---------|----------|-----------------------------------------------------------------------------------------------|
+| `chars` | `string` | The characters to choose from.                                                                |
+| `n`     | `int`    | The length of the string. If n is non-positive or not supplied, a reasonable default is used. |
+
+#### Examples
+
+**basic**
+
+Generate a random string containing 10 characters from the given unicode string.
+
+```python
+load("random", "randstr")
+s = randstr("abcdefghijklmnopqrstuvwxyz", 10)
+print(s)
+# Output: "enfknqfbra"
+```
+
 ### `randint(a,b)`
 
 Return a random integer N such that a <= N <= b.

lib/random/random.go

@@ -28,6 +28,7 @@ func LoadModule() (starlark.StringDict, error) {
 				Name: "random",
 				Members: starlark.StringDict{
 					"randbytes": starlark.NewBuiltin("random.randbytes", randbytes),
+					"randstr":   starlark.NewBuiltin("random.randstr", randstr),
 					"randint":   starlark.NewBuiltin("random.randint", randint),
 					"choice":    starlark.NewBuiltin("random.choice", choice),
 					"shuffle":   starlark.NewBuiltin("random.shuffle", shuffle),
@@ -40,6 +41,13 @@ func LoadModule() (starlark.StringDict, error) {
 	return module, nil
 }
 
+// for convenience
+var (
+	emptyStr    string
+	none        = starlark.None
+	defaultLenN = big.NewInt(10)
+)
+
 // randbytes(n) returns a random byte string of length n.
 func randbytes(thread *starlark.Thread, bn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
 	// precondition checks
@@ -50,7 +58,7 @@ func randbytes(thread *starlark.Thread, bn *starlark.Builtin, args starlark.Tupl
 	// set default value if n is not provided correctly
 	nInt := n.BigInt()
 	if nInt.Sign() <= 0 {
-		nInt = big.NewInt(10)
+		nInt = defaultLenN
 	}
 	// get random bytes
 	buf := make([]byte, nInt.Int64())
@@ -60,6 +68,29 @@ func randbytes(thread *starlark.Thread, bn *starlark.Builtin, args starlark.Tupl
 	return starlark.Bytes(buf), nil
 }
 
+// randstr(chars, n) returns a random string of given length from given characters.
+func randstr(thread *starlark.Thread, bn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
+	// precondition checks
+	var (
+		ab starlark.String
+		n  starlark.Int
+	)
+	if err := starlark.UnpackArgs(bn.Name(), args, kwargs, "chars", &ab, "n?", &n); err != nil {
+		return nil, err
+	}
+	// set default value if n is not provided correctly
+	nInt := n.BigInt()
+	if nInt.Sign() <= 0 {
+		nInt = defaultLenN
+	}
+	// get random strings
+	s, err := getRandStr(ab.GoString(), nInt.Int64())
+	if err != nil {
+		return nil, err
+	}
+	return starlark.String(s), nil
+}
+
 // randint(a, b) returns a random integer N such that a <= N <= b. Alias for randrange(a, b+1).
 func randint(thread *starlark.Thread, bn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
 	// precondition checks
@@ -92,16 +123,16 @@ func choice(thread *starlark.Thread, bn *starlark.Builtin, args starlark.Tuple,
 	// precondition checks
 	var seq starlark.Indexable
 	if err := starlark.UnpackArgs(bn.Name(), args, kwargs, "seq", &seq); err != nil {
-		return starlark.None, err
+		return nil, err
 	}
 	l := seq.Len()
 	if l == 0 {
-		return starlark.None, errors.New(`cannot choose from an empty sequence`)
+		return nil, errors.New(`cannot choose from an empty sequence`)
 	}
 	// get random index
 	i, err := getRandomInt(l)
 	if err != nil {
-		return starlark.None, err
+		return nil, err
 	}
 	// return element at index
 	return seq.Index(i), nil
@@ -112,12 +143,12 @@ func shuffle(thread *starlark.Thread, bn *starlark.Builtin, args starlark.Tuple,
 	// precondition checks
 	var seq starlark.HasSetIndex
 	if err := starlark.UnpackArgs(bn.Name(), args, kwargs, "seq", &seq); err != nil {
-		return starlark.None, err
+		return nil, err
 	}
 	// nothing to do if seq is empty or has only one element
 	l := seq.Len()
 	if l <= 1 {
-		return starlark.None, nil
+		return none, nil
 	}
 	// The shuffle algorithm is the Fisher-Yates Shuffle and its complexity is O(n).
 	var (
@@ -137,27 +168,27 @@ func shuffle(thread *starlark.Thread, bn *starlark.Builtin, args starlark.Tuple,
 	)
 	for i := uint64(l - 1); i > 0; {
 		if _, err := rand.Read(randBytes); err != nil {
-			return starlark.None, err
+			return nil, err
 		}
 		randBig.SetBytes(randBytes)
 		for num := randBig.Uint64(); num > i && i > 0; i-- {
 			max := i + 1
 			j := int(num % max)
 			num /= max
 			if e := swap(int(i), j); e != nil {
-				return starlark.None, e
+				return nil, e
 			}
 		}
 	}
 	// done
-	return starlark.None, nil
+	return none, nil
 }
 
 // random() returns a random floating point number in the range 0.0 <= X < 1.0.
 func random(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
 	f, err := getRandomFloat(1 << 53)
 	if err != nil {
-		return starlark.None, err
+		return nil, err
 	}
 	return starlark.Float(f), nil
 }
@@ -167,12 +198,12 @@ func uniform(thread *starlark.Thread, bn *starlark.Builtin, args starlark.Tuple,
 	// precondition checks
 	var a, b itn.FloatOrInt
 	if err := starlark.UnpackArgs(bn.Name(), args, kwargs, "a", &a, "b", &b); err != nil {
-		return starlark.None, err
+		return nil, err
 	}
 	// get random float
 	f, err := getRandomFloat(1 << 53)
 	if err != nil {
-		return starlark.None, err
+		return nil, err
 	}
 	// a + (b-a) * random()
 	diff := float64(b - a)
@@ -192,6 +223,7 @@ func getRandomInt(max int) (int, error) {
 	return int(n.Int64()), nil
 }
 
+// getRandomFloat returns a random floating point number in the range [0.0, 1.0).
 func getRandomFloat(prec int64) (n float64, err error) {
 	if prec <= 0 {
 		return 0, errors.New(`prec must be > 0`)
@@ -203,3 +235,31 @@ func getRandomFloat(prec int64) (n float64, err error) {
 	}
 	return float64(nBig.Int64()) / float64(prec), nil
 }
+
+// getRandStr returns a random string of given length from given characters.
+func getRandStr(chars string, length int64) (string, error) {
+	// basic checks
+	if length <= 0 {
+		return emptyStr, errors.New(`length must be > 0`)
+	}
+	if chars == emptyStr {
+		return emptyStr, errors.New(`chars must not be empty`)
+	}
+
+	// split chars into runes
+	runes := []rune(chars)
+	rc := len(runes)
+
+	// get random runes
+	buf := make([]rune, length)
+	for i := range buf {
+		idx, err := getRandomInt(rc)
+		if err != nil {
+			return emptyStr, err
+		}
+		buf[i] = runes[idx]
+	}
+
+	// convert to string
+	return string(buf), nil
+}

lib/random/random_test.go

@@ -259,6 +259,72 @@ func TestLoadModule_Random(t *testing.T) {
 				assert.eq(len(x), 20)
 			`),
 		},
+		{
+			name: "randstr with less than 1 args",
+			script: itn.HereDoc(`
+				load('random', 'randstr')
+				x = randstr()
+			`),
+			wantErr: `random.randstr: missing argument for chars`,
+		},
+		{
+			name: "randstr with invalid args",
+			script: itn.HereDoc(`
+				load('random', 'randstr')
+				x = randstr(123)
+			`),
+			wantErr: `random.randstr: for parameter chars: got int, want string`,
+		},
+		{
+			name: "randstr with invalid N",
+			script: itn.HereDoc(`
+				load('random', 'randstr')
+				x = randstr('abc', -2)
+				assert.eq(len(x), 10)
+				y = randstr('abc', 0)
+				assert.eq(len(y), 10)
+			`),
+		},
+		{
+			name: "randstr with empty chars",
+			script: itn.HereDoc(`
+				load('random', 'randstr')
+				x = randstr('', 10)
+			`),
+			wantErr: `chars must not be empty`,
+		},
+		{
+			name: "randstr with n=1",
+			script: itn.HereDoc(`
+				load('random', 'randstr')
+				x = randstr('我爱你', 1)
+				assert.eq(len(x), 3)
+				cs = ["我", "爱", "你"]
+				assert.true(x in cs)
+				print(x)
+			`),
+		},
+		{
+			name: "randstr with same chars",
+			script: itn.HereDoc(`
+				load('random', 'randstr')
+				x = randstr('AAA', 10)
+				assert.eq(len(x), 10)
+				assert.eq(x, 'AAAAAAAAAA')
+			`),
+		},
+		{
+			name: "randstr for unicode",
+			script: itn.HereDoc(`
+				load('random', 'randstr')
+				x = randstr('你好', 2)
+				assert.eq(len(x), 6)
+				cs = ["你好", "好你", "好好", "你你"]
+				assert.true(x in cs)
+				print(x)
+				print(randstr("abcdefghijklmnopqrstuvwxyz", 10))
+			`),
+		},
 		{
 			name: "random",
 			script: itn.HereDoc(`