zix99 · zix99 · Dec 27, 2024 · Dec 24, 2024 · Dec 24, 2024 · Dec 24, 2024
diff --git a/cmd/expressions.go b/cmd/expressions.go
@@ -30,6 +30,7 @@ func expressionFunction(c *cli.Context) error {
 		skipNewline = c.Bool("skip-newline")
 		detailed    = stats || benchmark
 		listFuncs   = c.Bool("listfuncs")
+		raw         = c.Bool("raw")
 	)
 
 	if listFuncs {
@@ -82,6 +83,11 @@ func expressionFunction(c *cli.Context) error {
 
 	// Output results
 	result := compiled.BuildKey(&expCtx)
+
+	if !raw {
+		result = smartFormatResult(result)
+	}
+
 	if detailed {
 		fmt.Printf("Expression: %s\n", color.Wrap(color.BrightWhite, expString))
 		fmt.Printf("Result:     %s\n", color.Wrap(color.BrightYellow, result))
@@ -146,6 +152,23 @@ func buildSpecialKeyJson(matches []string, values map[string]string) string {
 	return json.String()
 }
 
+func smartFormatResult(s string) string {
+	if strings.ContainsRune(s, expressions.ArraySeparator) {
+		// Output array
+		var sb strings.Builder
+		sb.WriteRune('[')
+		for idx, val := range strings.Split(s, expressions.ArraySeparatorString) {
+			if idx > 0 {
+				sb.WriteString(", ")
+			}
+			sb.WriteString(val)
+		}
+		sb.WriteRune(']')
+		return sb.String()
+	}
+	return s
+}
+
 func extractFuncNames(lib funclib.FunctionSet) []string {
 	ret := make([]string, 0, len(lib))
 	for name := range lib {
@@ -174,6 +197,11 @@ func expressionCommand() *cli.Command {
 				Aliases: []string{"n"},
 				Usage:   "Don't add a newline character when printing plain result",
 			},
+			&cli.BoolFlag{
+				Name:    "raw",
+				Aliases: []string{"r"},
+				Usage:   "Don't format arrays, output raw with null-separators",
+			},
 			&cli.BoolFlag{
 				Name:    "benchmark",
 				Aliases: []string{"b"},

diff --git a/cmd/expressions_test.go b/cmd/expressions_test.go
@@ -2,6 +2,7 @@ package cmd
 
 import (
 	"os"
+	"rare/pkg/expressions"
 	"rare/pkg/expressions/funclib"
 	"rare/pkg/testutil"
 	"testing"
@@ -100,3 +101,11 @@ func TestKeyParser(t *testing.T) {
 	assert.Equal(t, "a", k)
 	assert.Equal(t, "b=c", v)
 }
+
+func TestSmartFormatResult(t *testing.T) {
+	assert.Equal(t, "1234", smartFormatResult("1234"))
+	assert.Equal(t, "abc", smartFormatResult("abc"))
+	assert.Equal(t, "", smartFormatResult(""))
+	assert.Equal(t, "a", smartFormatResult(expressions.MakeArray("a")))
+	assert.Equal(t, "[a, b, c]", smartFormatResult(expressions.MakeArray("a", "b", "c")))
+}
diff --git a/docs/cli-help.md b/docs/cli-help.md
@@ -483,6 +483,8 @@ Evaluate and benchmark expressions
 
 **--no-optimize**: Disable expression static analysis optimization
 
+**--raw, -r**: Don't format arrays, output raw with null-separators
+
 **--skip-newline, -n**: Don't add a newline character when printing plain result
 
 **--stats, -s**: Display stats about the expression

diff --git a/docs/usage/expressions.md b/docs/usage/expressions.md
@@ -409,6 +409,46 @@ Examples: (Array `[1,2,3,4]`)
 - `{@slice {array} -2 1}` - [3]
 
 
+#### @range
+
+!!! warning
+	Since `range` creates an array, large arrays will consume
+	a lot of memory. For non-static arrays, it will be created
+	each time and could be slow.
+
+Syntax: `{@range [start=0] <stop> [incr=1]}`
+
+Creates an array from start..stop, incrementing by `incr`. Start
+defaults to `0` and incr to `1`
+
+Eg:
+
+`{@range 5}` will result in `[0, 1, 2, 3, 4]`
+
+`{@range 1 10 2}` will result in `[1, 3, 5, 7, 9]`
+
+
+#### @for
+
+!!! warning
+	Since `for` creates an array, large arrays will consume
+	a lot of memory. For non-static arrays, it will be created
+	each time and could be slow.
+
+Syntax: `{@for <start> <whileExpr> <incrExpr>}`
+
+Unlike `@range`, `@for` uses expressions to increment and check when done
+as a *truthy* statement.  In the sub-expressions `{0}` is the current value
+and `{1}` is the index of the increment.
+
+Eg.
+
+`{@for 0 {lt {0} 5} {sumi {0} 1}}` will result in `[0, 1, 2, 3, 4]`
+
+or something more complex, such as a doubling sequence:
+
+`{@for 1 {lt {1} 5} {sumi {0} {0}}}` will result in `[1, 2, 4, 8, 16]`
+
 ### Drawing
 
 #### Colors
@@ -552,4 +592,5 @@ The following error strings may be returned while compiling or evaluating your e
 | Enum      | `<ENUM>`        | A given value is not contained within a set                               |
 | Arg Name  | `<NAME>`        | A variable accessed by a given name does not exist                        |
 | Empty     | `<EMPTY>`       | A value was expected, but was empty                                       |
-
+| File      | `<FILE>`        | Unable to read file                                                       |
+| Value     | `<VALUE>`       | Value is out of range or invalid (eg. range incrementer is 0)             |
diff --git a/pkg/expressions/stdlib/errors.go b/pkg/expressions/stdlib/errors.go
@@ -24,7 +24,8 @@ const (
 	ErrorEnum     = "<ENUM>"        // A given value is not contained within a set
 	ErrorArgName  = "<NAME>"        // A variable accessed by a given name does not exist
 	ErrorEmpty    = "<EMPTY>"       // A value was expected, but was empty
-	ErrorFile     = "<FILE>"
+	ErrorFile     = "<FILE>"        // Unable to read file
+	ErrorValue    = "<VALUE>"       // Value is out of range or invalid (eg. range incrementer is 0)
 )
 
 // Compilation errors

diff --git a/pkg/expressions/stdlib/funcs.go b/pkg/expressions/stdlib/funcs.go
@@ -97,6 +97,8 @@ var StandardFunctions = map[string]KeyBuilderFunction{
 	"@filter": kfArrayFilter,
 	"@slice":  kfArraySlice,
 	"@in":     kfArrayIn,
+	"@range":  kfArrayRange,
+	"@for":    kfArrayFor,
 
 	// Pathing
 	"basename": kfPathBase,

diff --git a/pkg/expressions/stdlib/funcsRange.go b/pkg/expressions/stdlib/funcsRange.go
@@ -225,6 +225,102 @@ func kfArraySlice(args []KeyBuilderStage) (KeyBuilderStage, error) {
 	}, nil
 }
 
+// {@range [start] <end> [incr]}
+func kfArrayRange(args []KeyBuilderStage) (KeyBuilderStage, error) {
+	var sStart, sStop, sIncr KeyBuilderStage
+	sStart = literal("0")
+	sIncr = literal("1")
+
+	switch len(args) {
+	case 1:
+		sStop = args[0]
+	case 2:
+		sStart, sStop = args[0], args[1]
+	case 3:
+		sStart, sStop, sIncr = args[0], args[1], args[2]
+	default:
+		return stageErrArgRange(args, "1-3")
+	}
+
+	return func(context KeyBuilderContext) string {
+		start, err := strconv.Atoi(sStart(context))
+		if err != nil {
+			return ErrorNum
+		}
+
+		stop, err := strconv.Atoi(sStop(context))
+		if err != nil {
+			return ErrorNum
+		}
+
+		incr, err := strconv.Atoi(sIncr(context))
+		if err != nil {
+			return ErrorNum
+		}
+
+		// Some validation
+		if incr == 0 {
+			return ErrorValue
+		}
+		if incr > 0 && start > stop {
+			return ErrorValue
+		}
+		if incr < 0 && start < stop {
+			return ErrorValue
+		}
+
+		var sb strings.Builder
+		for i := start; (incr > 0 && i < stop) || (incr < 0 && i > stop); i += incr {
+			if sb.Len() > 0 {
+				sb.WriteRune(ArraySeparator)
+			}
+			sb.WriteString(strconv.Itoa(i))
+		}
+
+		return sb.String()
+	}, nil
+}
+
+// {@for <start> <contExpr> <incrExpr>}
+func kfArrayFor(args []KeyBuilderStage) (KeyBuilderStage, error) {
+	if len(args) != 3 {
+		return stageErrArgCount(args, 3)
+	}
+
+	const MAX_ITERATIONS = 1_000_000
+
+	return func(context KeyBuilderContext) string {
+		val := args[0](context)
+
+		sub := subContextPool.Get()
+		defer subContextPool.Return(sub)
+
+		var sb strings.Builder
+
+		idx := 0
+		for {
+			sIdx := strconv.Itoa(idx)
+			if !Truthy(sub.Eval(args[1], val, sIdx)) {
+				break
+			}
+
+			if sb.Len() > 0 {
+				sb.WriteRune(ArraySeparator)
+			}
+			sb.WriteString(val)
+
+			val = sub.Eval(args[2], val, sIdx)
+
+			idx++
+			if idx > MAX_ITERATIONS { // Prevent infinite loop/memory-crash
+				return "<INF>"
+			}
+		}
+
+		return sb.String()
+	}, nil
+}
+
 // {@filter <arr> <truthy-statement>}
 func kfArrayFilter(args []KeyBuilderStage) (KeyBuilderStage, error) {
 	if len(args) != 2 {

diff --git a/pkg/expressions/stdlib/funcsRange_test.go b/pkg/expressions/stdlib/funcsRange_test.go
@@ -225,6 +225,47 @@ func TestArrayFilter(t *testing.T) {
 	)
 }
 
+func TestArrayRange(t *testing.T) {
+	// 1 Arg
+	testExpression(t, mockContext("5"), "{@range {0}}", expressions.MakeArray("0", "1", "2", "3", "4"))
+	testExpression(t, mockContext("0"), "{@range {0}}", expressions.MakeArray())
+	testExpression(t, mockContext("-1"), "{@range {0}}", expressions.MakeArray("<VALUE>"))
+	testExpression(t, mockContext("abc"), "{@range {0}}", expressions.MakeArray("<BAD-TYPE>"))
+
+	// 2 Arg
+	testExpression(t, mockContext("5"), "{@range 1 {0}}", expressions.MakeArray("1", "2", "3", "4"))
+	testExpression(t, mockContext("0"), "{@range 0 {0}}", expressions.MakeArray())
+	testExpression(t, mockContext("-1"), "{@range 0 {0}}", expressions.MakeArray("<VALUE>"))
+	testExpression(t, mockContext("-1"), "{@range -1 2}", expressions.MakeArray("-1", "0", "1"))
+	testExpression(t, mockContext("-1"), "{@range 5 3}", expressions.MakeArray("<VALUE>"))
+	testExpression(t, mockContext("abc"), "{@range 0 {0}}", expressions.MakeArray("<BAD-TYPE>"))
+
+	// 3 Arg
+	testExpression(t, mockContext("5"), "{@range 1 {0} 1}", expressions.MakeArray("1", "2", "3", "4"))
+	testExpression(t, mockContext("0"), "{@range 0 {0} 1}", expressions.MakeArray())
+	testExpression(t, mockContext("-1"), "{@range 0 {0} 1}", expressions.MakeArray("<VALUE>"))
+	testExpression(t, mockContext("-1"), "{@range -1 2 1}", expressions.MakeArray("-1", "0", "1"))
+	testExpression(t, mockContext("-1"), "{@range 5 3 1}", expressions.MakeArray("<VALUE>"))
+	testExpression(t, mockContext("abc"), "{@range 0 {0} 1}", expressions.MakeArray("<BAD-TYPE>"))
+	testExpression(t, mockContext(), "{@range 5 1 -1}", expressions.MakeArray("5", "4", "3", "2"))
+
+	// 4+ arg
+	testExpressionErr(t, mockContext(), "{@range 1 2 3 4}", "<ARGN>", ErrArgCount)
+
+	// Other error states
+	testExpression(t, mockContext(), "{@range a}", "<BAD-TYPE>")
+	testExpression(t, mockContext(), "{@range b 5}", "<BAD-TYPE>")
+	testExpression(t, mockContext(), "{@range 0 5 c}", "<BAD-TYPE>")
+	testExpression(t, mockContext(), "{@range 0 5 -1}", "<VALUE>")
+	testExpression(t, mockContext(), "{@range 5 0 2}", "<VALUE>")
+	testExpression(t, mockContext(), "{@range 0 5 0}", "<VALUE>")
+}
+
+func TestArrayFor(t *testing.T) {
+	testExpressionErr(t, mockContext(), "{@for 5}", "<ARGN>", ErrArgCount)
+	testExpression(t, mockContext(), "{@for 2 {lt {1} 5} {sumi {0} 2}}", expressions.MakeArray("2", "4", "6", "8", "10"))
+}
+
 func TestArrayIn(t *testing.T) {
 	testExpression(t, mockContext("ab"), "{@in {0} {$ cd ab qef}}", "1")
 	testExpression(t, mockContext("a"), "{@in {0} {$ cd ab qef}}", "")