Merge in v10 work (1BADragon#34)

Author: 1BADragon

.github/workflows/rust.yml

@@ -15,21 +15,34 @@ jobs:
 
     steps:
     - uses: actions/checkout@v3
+    
     - name: Build
       run: cargo build --verbose
 
   test_default:
     runs-on: ubuntu-latest
 
     steps:
+    - name: Install Protoc
+      uses: arduino/setup-protoc@v3
+
     - uses: actions/checkout@v3
+
     - name: Run tests
       run: cargo test --verbose
+      env:
+        RSCEL_TEST_PROTO: 1
 
   test_no_default:
     runs-on: ubuntu-latest
 
     steps:
+    - name: Install Protoc
+      uses: arduino/setup-protoc@v3
+
     - uses: actions/checkout@v3
+
     - name: Run tests
       run: cargo test --verbose --no-default-features
+      env:
+        RSCEL_TEST_PROTO: 1

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rscel"
-version = "0.9.0"
+version = "0.10.0"
 edition = "2021"
 description = "Cel interpreter in rust"
 license = "MIT"
@@ -24,6 +24,9 @@ wasm = [
   "console_error_panic_hook", "chrono/wasmbind"
 ]
 
+[build-dependencies]
+protobuf-codegen = "3.4.0"
+protoc-bin-vendored = "3.0.0"
 
 [dependencies]
 test-case = "3.2.1"
@@ -34,6 +37,7 @@ serde_json = { version = "1.0.108", features = ["raw_value"] }
 chrono = { version = "0.4.31", features = ["serde"] }
 duration-str = "0.7.0"
 num = "0.4.1"
+protobuf = { version = "3.4.0" }
 
 # Dependencies for python bindings
 pyo3 = { version = "0.20.0", optional = true, features = ["extension-module", "chrono"] }

Makefile

@@ -6,10 +6,10 @@ default: build
 build:
 	cargo build $(CARGO_ARGS)
 
-test:
+run-tests:
 	cargo test $(CARGO_ARGS)
 
-test-all: test
+run-all-tests: run-tests
 	cargo test --no-default-features $(CARGO_ARGS)
 
 .env:

README.md

@@ -10,13 +10,9 @@ The design goals of this project were are as follows:
   * Sandbox'ed in such a way that only specific values can be bound
   * Can be used as a wasm depenedency (or other ffi)
 
-While Google's CEL spec was designed around the protobuf message,
-I decided to focus on using the JSON message instead (CEL spec specifies
-how to convert from JSON to CEL types).
-
 The basic example of how to use:
 ```rust
-use rscel::{CelContext, BindContext, serde_json};
+use rscel::{CelContext, BindContext};
 
 let mut ctx = CelContext::new();
 let mut exec_ctx = BindContext::new();
@@ -25,7 +21,37 @@ ctx.add_program_str("main", "foo + 3").unwrap();
 exec_ctx.bind_param("foo", 3.into()); // convert to CelValue
 
 let res = ctx.exec("main", &exec_ctx).unwrap(); // CelValue::Int(6)
-assert!(TryInto::<i64>::try_into(res).unwrap() == 6);
+assert_eq!(res, 6.into());
+```
+
+As of 0.10.0 binding protobuf messages from the protobuf crate is now available! Given 
+the following protobuf message:
+```protobuf
+
+message Point {
+  int32 x = 1;
+  int32 y = 2;
+}
+  
+```
+The following code can be used to evaluate a CEL expression on a Point message:
+
+```rust
+use rscel::{CelContext, BindContext};
+
+// currently rscel required protobuf messages to be in a box 
+let p = Box::new(protos::Point::new());
+p.x = 4;
+p.y = 5;
+
+let mut ctx = CelContext::new();
+let mut exec_ctx = BindContext::new();
+
+ctx.add_program_str("main", "p.x + 3").unwrap();
+exec_ctx.bind_protobuf_msg("p", p);
+
+assert_eq!(ctx.exec("main", &exec_ctx), 7.into());
+  
 ```
 
 ## Current Benchmark Times

build.rs

@@ -0,0 +1,15 @@
+use std::env;
+
+fn main() {
+    println!("cargo:rerun-if-env-changed=RSCEL_TEST_PROTO");
+
+    if let Ok(_) = env::var("RSCEL_TEST_PROTO") {
+        println!("cargo:rustc-cfg=test_protos");
+        protobuf_codegen::Codegen::new()
+            .protoc()
+            .include("test/protos")
+            .inputs(["test/protos/test.proto"])
+            .cargo_out_dir("test_protos")
+            .run_from_script();
+    }
+}

src/bindings/python/mod.rs

@@ -1,12 +1,12 @@
-use crate::{BindContext, CelContext, CelValue};
+use crate::{BindContext, CelContext, CelError, CelValue, CelValueDyn};
 
 use chrono::{DateTime, Duration, Utc};
 use pyo3::{
     exceptions::{PyRuntimeError, PyValueError},
     prelude::*,
     types::{PyBool, PyBytes, PyDateTime, PyDelta, PyDict, PyFloat, PyInt, PyList, PyString},
 };
-use std::collections::HashMap;
+use std::{collections::HashMap, sync::Arc};
 
 mod celpycallable;
 
@@ -143,6 +143,70 @@ fn rscel(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
     Ok(())
 }
 
+impl CelValueDyn for PyObject {
+    fn as_type(&self) -> CelValue {
+        Python::with_gil(|py| {
+            let inner = self.as_ref(py);
+            let name = inner.get_type().name().unwrap();
+
+            CelValue::Type(format!("pyobj-{}", name))
+        })
+    }
+
+    fn access(&self, key: &str) -> crate::CelResult<CelValue> {
+        Python::with_gil(|py| {
+            let obj = self.as_ref(py);
+
+            match obj.getattr(key) {
+                Ok(res) => match res.extract() {
+                    Ok(val) => Ok(val),
+                    Err(err) => Err(CelError::Misc(err.to_string())),
+                },
+                Err(err) => Err(CelError::Misc(err.to_string())),
+            }
+        })
+    }
+
+    fn eq(&self, rhs: &CelValue) -> crate::CelResult<CelValue> {
+        let lhs_type = self.as_type();
+        let rhs_type = self.as_type();
+
+        if let CelValue::Dyn(rhs) = rhs {
+            if let Some(rhs_obj) = rhs.any_ref().downcast_ref::<PyObject>() {
+                return Python::with_gil(|py| {
+                    let lhs_obj = self.as_ref(py);
+                    let rhs_obj = rhs_obj.as_ref(py);
+
+                    match lhs_obj.eq(rhs_obj) {
+                        Ok(res) => Ok(CelValue::from_bool(res)),
+                        Err(err) => Err(CelError::Misc(err.to_string())),
+                    }
+                });
+            }
+        }
+
+        Err(CelError::invalid_op(&format!(
+            "Invalid op == between {} and {}",
+            lhs_type, rhs_type
+        )))
+    }
+
+    fn is_truthy(&self) -> bool {
+        Python::with_gil(|py| {
+            let inner = self.as_ref(py);
+
+            match inner.is_true() {
+                Ok(res) => res,
+                Err(_) => false, // this is just going to have to work. Basically is the equiv of calling bool(obj) and it throwing
+            }
+        })
+    }
+
+    fn any_ref<'a>(&'a self) -> &'a dyn std::any::Any {
+        self
+    }
+}
+
 impl<'source> FromPyObject<'source> for CelValue {
     fn extract(ob: &'source PyAny) -> PyResult<Self> {
         match ob.get_type().name() {
@@ -179,10 +243,7 @@ impl<'source> FromPyObject<'source> for CelValue {
                     .into()),
                 "timedelta" => Ok(ob.downcast::<PyDelta>()?.extract::<Duration>()?.into()),
                 "NoneType" => Ok(CelValue::from_null()),
-                other => Err(PyValueError::new_err(format!(
-                    "{} is not a compatable rscel type",
-                    other
-                ))),
+                _ => Ok(CelValue::Dyn(Arc::<PyObject>::new(ob.into()))),
             },
             Err(_) => PyResult::Err(PyValueError::new_err(format!(
                 "Failed to get type from {:?}",
@@ -217,6 +278,13 @@ impl ToPyObject for CelValue {
             TimeStamp(ts) => ts.to_object(py),
             Duration(d) => d.to_object(py),
             Null => py.None(),
+            Dyn(d) => match d.any_ref().downcast_ref::<PyObject>() {
+                Some(obj) => obj.clone(),
+                // This *should* never happen. If this downcase were to fail that would
+                // mean that the data in this dyn isn't a PyObject which should be impossible
+                // for these bidnings
+                None => py.None(),
+            },
             _ => py.None(),
         }
     }