feat(logic): add base64_encoded/3 precicate

ccamel · ccamel · commit d1a75eea1197 · 2025-03-28T14:28:43.000+01:00
diff --git a/x/logic/interpreter/registry.go b/x/logic/interpreter/registry.go
@@ -125,6 +125,7 @@ var registry = orderedmap.New[string, any](
 		{Key: "atomic_list_concat/3", Value: predicate.AtomicListConcat3},
 		{Key: "json_read/2", Value: predicate.JSONRead},
 		{Key: "json_write/2", Value: predicate.JSONWrite},
+		{Key: "base64_encoded/3", Value: predicate.Base64Encoded},
 	}...),
 )
 
diff --git a/x/logic/predicate/encoding.go b/x/logic/predicate/encoding.go
@@ -1,13 +1,151 @@
 package predicate
 
 import (
+	"encoding/base64"
 	"encoding/hex"
 
 	"github.com/axone-protocol/prolog/v2/engine"
 
 	"github.com/axone-protocol/axoned/v11/x/logic/prolog"
 )
 
+var (
+	atomClassic = engine.NewAtom("classic")
+	atomURL     = engine.NewAtom("url")
+	atomString  = engine.NewAtom("string")
+	atomAtom    = engine.NewAtom("atom")
+)
+
+// Base64Encoded is a predicate that unifies a string to a base64 encoded string as specified by [RFC 4648].
+//
+// The signature is as follows:
+//
+//	base64_encoded(+Plain, -Encoded, +Options) is det
+//	base64_encoded(-Plain, +Encoded, +Options) is det
+//	base64_encoded(+Plain, +Encoded, +Options) is det
+//
+// Where:
+//   - Plain is an atom, a list of character codes, or list of characters containing the unencoded (plain) text.
+//   - Encoded is an atom or string containing the base64 encoded text.
+//   - Options is a list of options that can be used to control the encoding process.
+//
+// # Options
+//
+// The following options are supported:
+//
+//   - padding(+Boolean)
+//
+// If true (default), the output is padded with = characters.
+//
+//   - charset(+Charset)
+//
+// Define the encoding character set to use. The (default) 'classic' uses the classical rfc2045 characters. The value 'url'
+// uses URL and file name friendly characters.
+//
+//   - as(+Type)
+//
+// Defines the type of the output. One of string (default) or atom.
+//
+//   - encoding(+Encoding)
+//
+// Encoding to use for translation between (Unicode) text and bytes (Base64 is an encoding for bytes). Default is utf8.
+//
+// [RFC 4648]: https://rfc-editor.org/rfc/rfc4648.html
+func Base64Encoded(_ *engine.VM, plain, encoded, options engine.Term, cont engine.Cont, env *engine.Env) *engine.Promise {
+	encoding, err := getBase64Encoding(options, env)
+	if err != nil {
+		return engine.Error(err)
+	}
+
+	asOpt, err := prolog.GetOptionWithDefault(prolog.AtomAs, options, atomString, env)
+	if err != nil {
+		return engine.Error(err)
+	}
+
+	forwardConverter := func(value []engine.Term, _ engine.Term, env *engine.Env) ([]engine.Term, error) {
+		src, err := prolog.TextTermToString(value[0], env)
+		if err != nil {
+			return nil, err
+		}
+		dst := encoding.EncodeToString([]byte(src))
+
+		switch asOpt {
+		case atomString:
+			return []engine.Term{prolog.StringToCharacterListTerm(dst)}, nil
+		case atomAtom:
+			return []engine.Term{engine.NewAtom(dst)}, nil
+		default:
+			return nil, engine.DomainError(prolog.AtomAs, asOpt, env)
+		}
+	}
+	backwardConverter := func(value []engine.Term, options engine.Term, env *engine.Env) ([]engine.Term, error) {
+		src, err := prolog.TextTermToString(value[0], env)
+		if err != nil {
+			return nil, err
+		}
+
+		dst, err := encoding.DecodeString(src)
+		if err != nil {
+			return nil,
+				prolog.WithError(
+					engine.DomainError(prolog.ValidEncoding("base64"), value[0], env), err, env)
+		}
+
+		encodingOpt, err := prolog.GetOptionAsAtomWithDefault(prolog.AtomEncoding, options, prolog.AtomUtf8, env)
+		if err != nil {
+			return nil, err
+		}
+		dstStr, err := prolog.Decode(value[0], dst, encodingOpt, env)
+		if err != nil {
+			return nil, err
+		}
+
+		switch asOpt {
+		case atomString:
+			return []engine.Term{prolog.StringToCharacterListTerm(dstStr)}, nil
+		case atomAtom:
+			return []engine.Term{engine.NewAtom(dstStr)}, nil
+		default:
+			return nil, engine.DomainError(prolog.AtomAs, asOpt, env)
+		}
+	}
+
+	return prolog.UnifyFunctionalPredicate(
+		[]engine.Term{plain}, []engine.Term{encoded}, options, forwardConverter, backwardConverter, cont, env)
+}
+
+// getBase64Encoding returns the base64 encoding based on the options provided.
+func getBase64Encoding(options engine.Term, env *engine.Env) (*base64.Encoding, error) {
+	var encoding *base64.Encoding
+
+	charsetOpt, err := prolog.GetOptionAsAtomWithDefault(prolog.AtomCharset, options, atomClassic, env)
+	if err != nil {
+		return nil, err
+	}
+	switch charsetOpt {
+	case atomClassic:
+		encoding = base64.StdEncoding
+	case atomURL:
+		encoding = base64.URLEncoding
+	default:
+		return nil, engine.DomainError(prolog.AtomCharset, charsetOpt, env)
+	}
+
+	paddingOpt, err := prolog.GetOptionWithDefault(prolog.AtomPadding, options, prolog.AtomTrue, env)
+	if err != nil {
+		return nil, err
+	}
+	switch paddingOpt {
+	case prolog.AtomTrue:
+		encoding = encoding.WithPadding(base64.StdPadding)
+	case prolog.AtomFalse:
+		encoding = encoding.WithPadding(base64.NoPadding)
+	default:
+		return nil, engine.DomainError(prolog.AtomPadding, paddingOpt, env)
+	}
+	return encoding, nil
+}
+
 // HexBytes is a predicate that unifies hexadecimal encoded bytes to a list of bytes.
 //
 // The signature is as follows:
diff --git a/x/logic/prolog/atom.go b/x/logic/prolog/atom.go
@@ -33,6 +33,8 @@ var (
 	AtomOctet = engine.NewAtom("octet")
 	// AtomPadding is the term used to indicate the padding encoding type option.
 	AtomPadding = engine.NewAtom("padding")
+	// AtomCharset is the term used to indicate the charset encoding type option.
+	AtomCharset = engine.NewAtom("charset")
 	// AtomPair are terms with principal functor (-)/2.
 	// For example, the term -(A, B) denotes the pair of elements A and B.
 	AtomPair = engine.NewAtom("-")
@@ -47,6 +49,8 @@ var (
 	AtomSegment = engine.NewAtom("segment")
 	// AtomText is the term used to indicate the atom text.
 	AtomText = engine.NewAtom("text")
+	// AtomBoolean is the term used to indicate the atom boolean.
+	AtomBoolean = engine.NewAtom("boolean")
 	// AtomTrue is the term true.
 	AtomTrue = engine.NewAtom("true")
 	// AtomUtf8 is the term used to indicate the UTF-8 encoding type option.
diff --git a/x/logic/prolog/error.go b/x/logic/prolog/error.go
@@ -51,6 +51,8 @@ var (
 	AtomTypeJSON = engine.NewAtom("json")
 	// AtomTypeURIComponent is the term used to represent the URI component type.
 	AtomTypeURIComponent = engine.NewAtom("uri_component")
+	// AtomTypeBoolean is the term used to represent the boolean type.
+	AtomTypeBoolean = engine.NewAtom("boolean")
 )
 
 var (

Original file line number	Diff line number	Diff line change
`@@ -125,6 +125,7 @@ var registry = orderedmap.New[string, any](`
`125`	`125`	`{Key: "atomic_list_concat/3", Value: predicate.AtomicListConcat3},`
`126`	`126`	`{Key: "json_read/2", Value: predicate.JSONRead},`
`127`	`127`	`{Key: "json_write/2", Value: predicate.JSONWrite},`
	`128`	`+ {Key: "base64_encoded/3", Value: predicate.Base64Encoded},`
`128`	`129`	`}...),`
`129`	`130`	`)`
`130`	`131`
Original file line number	Diff line number	Diff line change
`@@ -51,6 +51,8 @@ var (`
`51`	`51`	`AtomTypeJSON = engine.NewAtom("json")`
`52`	`52`	`// AtomTypeURIComponent is the term used to represent the URI component type.`
`53`	`53`	`AtomTypeURIComponent = engine.NewAtom("uri_component")`
	`54`	`+ // AtomTypeBoolean is the term used to represent the boolean type.`
	`55`	`+ AtomTypeBoolean = engine.NewAtom("boolean")`
`54`	`56`	`)`
`55`	`57`
`56`	`58`	`var (`