ENH: add cat string operator

Author: mplanchard

src/data.rs

@@ -1,5 +1,8 @@
 //! Data functions and operators
-//!
+
+// TODO: it's possible that "missing", "var", et al. could be implemented
+// as operators. They were originally done as parsers because there wasn't
+// yet a LazyOperator concept.
 
 use crate::error::Error;
 use crate::value::Evaluated;

src/lib.rs

@@ -852,6 +852,17 @@ mod jsonlogic_tests {
         ]
     }
 
+    fn cat_cases() -> Vec<(Value, Value, Result<Value, ()>)> {
+        vec![
+            (json!({"cat": []}), json!({}), Ok(json!(""))),
+            (json!({"cat": [1]}), json!({}), Err(())),
+            (json!({"cat": ["a"]}), json!({}), Ok(json!("a"))),
+            (json!({"cat": ["a", "b"]}), json!({}), Ok(json!("ab"))),
+            (json!({"cat": ["a", "b", "c"]}), json!({}), Ok(json!("abc"))),
+            (json!({"cat": ["a", "b", 1]}), json!({}), Err(())),
+        ]
+    }
+
     fn lt_cases() -> Vec<(Value, Value, Result<Value, ()>)> {
         vec![
             (json!({"<": [1, 2]}), json!({}), Ok(json!(true))),
@@ -1176,6 +1187,11 @@ mod jsonlogic_tests {
         merge_cases().into_iter().for_each(assert_jsonlogic)
     }
 
+    #[test]
+    fn test_cat_op() {
+        cat_cases().into_iter().for_each(assert_jsonlogic)
+    }
+
     #[test]
     fn test_lt_op() {
         lt_cases().into_iter().for_each(assert_jsonlogic)

src/op/mod.rs

@@ -1,5 +1,13 @@
 //! Operators
 //!
+//! This module contains the global operator map, which defines the available
+//! JsonLogic operations. Note that some "operations", notably data-related
+//! operations like "var" and "missing", are not included here, because they are
+//! implemented as parsers rather than operators.
+
+// TODO: it's possible that "missing", "var", et al. could be implemented
+// as operators. They were originally done differently because there wasn't
+// yet a LazyOperator concept.
 
 use phf::phf_map;
 use serde_json::{Map, Number, Value};
@@ -12,6 +20,7 @@ use crate::{js_op, Parser};
 mod array;
 mod logic;
 mod numeric;
+mod string;
 
 pub const OPERATOR_MAP: phf::Map<&'static str, Operator> = phf_map! {
     "==" => Operator {
@@ -164,6 +173,11 @@ pub const OPERATOR_MAP: phf::Map<&'static str, Operator> = phf_map! {
         operator: array::in_,
         num_params: NumParams::Exactly(2),
     },
+    "cat" => Operator {
+        symbol: "cat",
+        operator: string::cat,
+        num_params: NumParams::Any,
+    },
 };
 
 pub const LAZY_OPERATOR_MAP: phf::Map<&'static str, LazyOperator> = phf_map! {

src/op/string.rs

@@ -1 +1,32 @@
 //! String Operations
+
+use serde_json::Value;
+
+use crate::error::Error;
+
+/// Concatenate strings.
+///
+/// Note: the reference implementation just uses JS' builtin string
+/// concatenation with implicit casting, so e.g. `cast("foo", {})`
+/// evaluates to `"foo[object Object]". Here we explicitly require all
+/// arguments to be strings, because the specification explicitly defines
+/// `cat` as a string operation.
+pub fn cat(items: &Vec<&Value>) -> Result<Value, Error> {
+    let mut rv = String::from("");
+    items
+        .into_iter()
+        .map(|i| match i {
+            Value::String(i_string) => Ok(i_string),
+            _ => Err(Error::InvalidArgument {
+                value: (**i).clone(),
+                operation: "cat".into(),
+                reason: "All arguments to `cat` must be strings".into(),
+            }),
+        })
+        .fold(Ok(&mut rv), |acc: Result<&mut String, Error>, i| {
+            let rv = acc?;
+            rv.push_str(i?);
+            Ok(rv)
+        })?;
+    Ok(Value::String(rv))
+}