Set version to 0.3.0

Author: hardbyte

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cel"
-version = "0.2.0"
+version = "0.3.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

src/context.rs

@@ -1,9 +1,9 @@
 use cel_interpreter::objects::TryIntoValue;
 use cel_interpreter::Value;
+use pyo3::exceptions::PyValueError;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyTuple};
 use std::collections::HashMap;
-use pyo3::exceptions::PyValueError;
 
 #[pyo3::pyclass]
 pub struct Context {
@@ -13,7 +13,6 @@ pub struct Context {
 
 #[pyo3::pymethods]
 impl Context {
-
     #[new]
     pub fn new(variables: Option<&PyDict>, functions: Option<&PyDict>) -> PyResult<Self> {
         let mut context = Context {
@@ -24,24 +23,20 @@ impl Context {
         if let Some(variables) = variables {
             //context.variables.extend(variables.clone());
             for (k, v) in variables {
-                let key = k.extract::<String>().map_err(|_| {
-                    PyValueError::new_err("Keys must be strings")
-                });
+                let key = k
+                    .extract::<String>()
+                    .map_err(|_| PyValueError::new_err("Keys must be strings"));
                 key.map(|key| context.add_variable(key, v))??;
-
             }
         };
 
         if let Some(functions) = functions {
             context.update(functions)?;
         };
 
-
-
         Ok(context)
     }
 
-
     fn add_function(&mut self, name: String, function: Py<PyAny>) {
         self.functions.insert(name, function);
     }
@@ -58,12 +53,11 @@ impl Context {
     }
 
     pub fn update(&mut self, variables: &PyDict) -> PyResult<()> {
-
         for (key, value) in variables {
             // Attempt to extract the key as a String
-            let key = key.extract::<String>().map_err(|_| {
-                PyValueError::new_err("Keys must be strings")
-            })?;
+            let key = key
+                .extract::<String>()
+                .map_err(|_| PyValueError::new_err("Keys must be strings"))?;
 
             if value.is_callable() {
                 // Value is a function, add it to the functions hashmap
@@ -77,7 +71,6 @@ impl Context {
 
                 self.variables.insert(key, value);
             }
-
         }
 
         Ok(())

src/lib.rs

@@ -186,8 +186,12 @@ impl TryIntoValue for RustyPyType<'_> {
 fn evaluate(src: String, evaluation_context: Option<&PyAny>) -> PyResult<RustyCelType> {
     debug!("Evaluating CEL expression: {}", src);
 
-    let program = Program::compile(&src)
-        .map_err(|e| pyo3::exceptions::PyValueError::new_err(format!("Failed to compile expression '{}': {}", src, e)))?;
+    let program = Program::compile(&src).map_err(|e| {
+        PyValueError::new_err(format!(
+            "Failed to compile expression '{}': {}",
+            src, e
+        ))
+    })?;
 
     debug!("Compiled program: {:?}", program);
 
@@ -205,20 +209,22 @@ fn evaluate(src: String, evaluation_context: Option<&PyAny>) -> PyResult<RustyCe
             // Clone variables and functions into our local Context
             ctx.variables = py_context_ref.variables.clone();
             ctx.functions = py_context_ref.functions.clone();
-
         } else if let Ok(py_dict) = evaluation_context.extract::<&PyDict>() {
             // User passed in a dict - let's process variables and functions from the dict
             ctx.update(&py_dict)?;
         } else {
-            return Err(PyValueError::new_err("evaluation_context must be a Context object or a dict"))
+            return Err(PyValueError::new_err(
+                "evaluation_context must be a Context object or a dict",
+            ));
         };
 
-
         // Add any variables from the passed in Python context
         for (name, value) in &ctx.variables {
             environment
                 .add_variable(name.clone(), value.clone())
-                .map_err(|e| PyValueError::new_err(format!("Failed to add variable '{}': {}", name, e)))?;
+                .map_err(|e| {
+                    PyValueError::new_err(format!("Failed to add variable '{}': {}", name, e))
+                })?;
         }
 
         // Add functions
@@ -244,11 +250,12 @@ fn evaluate(src: String, evaluation_context: Option<&PyAny>) -> PyResult<RustyCe
                         let py_args = PyTuple::new_bound(py, py_args);
 
                         // Call the Python function
-                        let py_result = py_function.call1(py, py_args)
-                            .map_err(|e|  ExecutionError::FunctionError {
+                        let py_result = py_function.call1(py, py_args).map_err(|e| {
+                            ExecutionError::FunctionError {
                                 function: name.clone(),
                                 message: e.to_string(),
-                            })?;
+                            }
+                        })?;
                         // Convert the PyObject to &PyAny
                         let py_result_ref = py_result.as_ref(py);
 
@@ -266,7 +273,6 @@ fn evaluate(src: String, evaluation_context: Option<&PyAny>) -> PyResult<RustyCe
         }
     }
 
-
     let result = program.execute(&environment);
     match result {
         Err(error) => {