General fixes and improvements

execution/execute.go

@@ -59,6 +59,9 @@ func ExecuteAST(expr ast.Expr, value *model.Value, options *Options) (*model.Val
 		if err != nil {
 			return err
 		}
+		if r.IsIgnore() {
+			return nil
+		}
 		return res.Append(r)
 	}); err != nil {
 		return nil, fmt.Errorf("branch execution error: %w", err)

execution/execute_func.go

@@ -1,7 +1,9 @@
 package execution
 
 import (
+	"errors"
 	"fmt"
+	"slices"
 
 	"github.com/tomwright/dasel/v3/model"
 	"github.com/tomwright/dasel/v3/selector/ast"
@@ -41,7 +43,14 @@ func callFnExecutor(opts *Options, f FuncFn, argsE ast.Expressions) (expressionE
 	}, nil
 }
 
+var unstableFuncs = []string{
+	"ignore",
+}
+
 func callExprExecutor(opts *Options, e ast.CallExpr) (expressionExecutor, error) {
+	if !opts.Unstable && (slices.Contains(unstableFuncs, e.Function)) {
+		return nil, errors.New("unstable function are not enabled. to enable them use --unstable")
+	}
 	if f, ok := opts.Funcs.Get(e.Function); ok {
 		res, err := callFnExecutor(opts, f, e.Args)
 		if err != nil {

execution/func.go

@@ -19,6 +19,10 @@ var (
 		FuncTypeOf,
 		FuncMax,
 		FuncMin,
+		FuncIgnore,
+		FuncBase64Encode,
+		FuncBase64Decode,
+		FuncParse,
 	)
 )
 

execution/func_base64.go

@@ -0,0 +1,40 @@
+package execution
+
+import (
+	"encoding/base64"
+
+	"github.com/tomwright/dasel/v3/model"
+)
+
+// FuncBase64Encode base64 encodes the given value.
+var FuncBase64Encode = NewFunc(
+	"base64e",
+	func(data *model.Value, args model.Values) (*model.Value, error) {
+		arg := args[0]
+		strVal, err := arg.StringValue()
+		if err != nil {
+			return nil, err
+		}
+		out := base64.StdEncoding.EncodeToString([]byte(strVal))
+		return model.NewStringValue(out), nil
+	},
+	ValidateArgsExactly(1),
+)
+
+// FuncBase64Decode base64 decodes the given value.
+var FuncBase64Decode = NewFunc(
+	"base64d",
+	func(data *model.Value, args model.Values) (*model.Value, error) {
+		arg := args[0]
+		strVal, err := arg.StringValue()
+		if err != nil {
+			return nil, err
+		}
+		out, err := base64.StdEncoding.DecodeString(strVal)
+		if err != nil {
+			return nil, err
+		}
+		return model.NewStringValue(string(out)), nil
+	},
+	ValidateArgsExactly(1),
+)

execution/func_ignore.go

@@ -0,0 +1,15 @@
+package execution
+
+import (
+	"github.com/tomwright/dasel/v3/model"
+)
+
+// FuncIgnore is a function that ignores the value, causing it to be rejected from a branch.
+var FuncIgnore = NewFunc(
+	"ignore",
+	func(data *model.Value, args model.Values) (*model.Value, error) {
+		data.MarkAsIgnore()
+		return data, nil
+	},
+	ValidateArgsExactly(0),
+)

execution/func_parse.go

@@ -0,0 +1,42 @@
+package execution
+
+import (
+	"github.com/tomwright/dasel/v3/model"
+	"github.com/tomwright/dasel/v3/parsing"
+)
+
+// FuncParse parses the given data at runtime.
+var FuncParse = NewFunc(
+	"parse",
+	func(data *model.Value, args model.Values) (*model.Value, error) {
+		var format parsing.Format
+		var content []byte
+		{
+			strVal, err := args[0].StringValue()
+			if err != nil {
+				return nil, err
+			}
+			format = parsing.Format(strVal)
+		}
+		{
+			strVal, err := args[1].StringValue()
+			if err != nil {
+				return nil, err
+			}
+			content = []byte(strVal)
+		}
+
+		reader, err := format.NewReader(parsing.DefaultReaderOptions())
+		if err != nil {
+			return nil, err
+		}
+
+		doc, err := reader.Read(content)
+		if err != nil {
+			return nil, err
+		}
+
+		return doc, nil
+	},
+	ValidateArgsExactly(2),
+)