cel-rs-rb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4a2986048cff8c1e335c72ffc410487bae67a02251ff9ef9815c34a430199b39
+  data.tar.gz: 14df42d51ffda3ecdbfd0a9455a9e11d9990b0f30f11c9f261d5367768d35498
+SHA512:
+  metadata.gz: 1af27f75d923ded581e5dfab5d046cd97ccb3837822f2cbae96f751c6dc7e41e2db539e86e61a70520efdf98c314b5a20ba557e242ffe2fee9788b5a9f29b843
+  data.tar.gz: 16f711a65c9ef6b529410d8b3d823bb6317d80626460fa5cd43d01bd365b84efb4a6d800897bf8e927b56e8ce216aa2960e811e9f6000c959c0ec9b24c7c8207

data/Cargo.toml

@@ -0,0 +1,9 @@
+[workspace]
+members = ["ext/cel"]
+resolver = "2"
+
+[profile.release]
+strip = true
+
+[profile.dev]
+strip = true

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Chris Atkins
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,111 @@
+# cel-rs-rb
+
+Ruby bindings for the Rust [`cel`](https://crates.io/crates/cel) crate, implemented with [Magnus](https://github.com/matsadler/magnus).
+
+## Goals
+
+- Ruby-first API over the Rust CEL engine
+- Close semantic compatibility with Rust `cel::Program` + `cel::Context`
+- Ruby variable and function interop
+- Thread-safe concurrent execution
+- GVL released while CEL evaluation runs
+
+## Installation
+
+```ruby
+gem "cel-rs-rb"
+```
+
+## Usage
+
+```ruby
+require "cel"
+
+context = CEL::Context.build(user: {"name" => "Ada"}, scores: [10, 20, 30]) do |ctx|
+  ctx.define_function("sum") { |*args| args.sum }
+end
+
+program = CEL.compile("sum(scores[0], scores[1], scores[2])")
+program.execute(context)
+# => 60
+```
+
+### API mapping
+
+- `CEL.compile(source)` -> `CEL::Program`
+- `CEL::Program.compile(source)` -> `CEL::Program`
+- `CEL::Program#execute(context = nil)` -> Ruby value
+- `CEL::Program#references` -> `{ "variables" => [...], "functions" => [...] }`
+- `CEL::Context.new(empty = false)` -> context with builtins (`false`) or empty (`true`)
+- `CEL::Context#add_variable(name, value)`
+- `CEL::Context#define_function(name) { |*args| ... }`
+- `CEL::Duration.new(seconds)` -> duration value for context variables and duration results
+
+## Type support
+
+### Ruby -> CEL
+
+- `nil` -> `null`
+- `true/false` -> `bool`
+- `Integer` -> `int`
+- `Float` -> `double`
+- `String` / `Symbol` -> `string`
+- binary `String` (`ASCII-8BIT`, e.g. `"abc".b`) -> `bytes`
+- `Time` -> `timestamp`
+- `CEL::Duration` -> `duration`
+- `Array` -> `list`
+- `Hash` with keys `String|Symbol|Integer|Boolean` -> `map`
+
+### CEL -> Ruby
+
+- `null` -> `nil`
+- scalar primitives map naturally
+- `bytes` -> binary Ruby `String`
+- `timestamp` -> `Time`
+- `duration` -> `CEL::Duration`
+- `list` -> `Array`
+- `map` -> `Hash`
+
+## Error classes
+
+- `CEL::Error`
+- `CEL::ParseError`
+- `CEL::ExecutionError`
+- `CEL::TypeError`
+
+## Thread safety and concurrency
+
+- Context data is mutex-protected and immutable during execution snapshots.
+- CEL execution is run with the Ruby GVL released so other Ruby threads can run.
+- Ruby callbacks from CEL functions temporarily re-acquire the GVL.
+
+## Development
+
+### Tooling
+
+Uses [mise](https://mise.jdx.dev/) for versions:
+
+```toml
+[tools]
+ruby = "4.0"
+rust = "1.96.0"
+```
+
+### Test + lint
+
+```bash
+bundle exec rake
+```
+
+This runs:
+
+- `standard` (format/lint)
+- native extension compile
+- `rspec`
+
+CI also runs the test suite on Ruby 3.3, Ruby 3.4, and Ruby 4.0 through Buildkite.
+
+## Compatibility notes
+
+- Some CEL value variants (e.g. opaque custom Rust types) cannot be fully marshaled to Ruby and raise `CEL::TypeError`.
+- This project targets broad CEL compatibility, but parity for every Rust-only extension point is still evolving.

data/ext/cel/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "cel"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+magnus = { version = "0.8.2", features = ["chrono", "rb-sys"] }
+rb-sys = { version = "0.9.128", features = ["stable-api-compiled-fallback"] }
+cel = { version = "0.13.0", features = ["chrono", "regex", "json"] }
+chrono = "0.4.45"

data/ext/cel/extconf.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require "mkmf"
+require "rb_sys/mkmf"
+
+create_rust_makefile("cel/cel")

data/ext/cel/src/lib.rs

@@ -0,0 +1,499 @@
+use cel::{
+    Context as CelContext, ExecutionError as CelExecutionError, FunctionContext, ParseErrors,
+    Program as CelProgram, ResolveResult, Value as CelValue,
+};
+use magnus::block::Proc;
+use magnus::prelude::*;
+use magnus::typed_data::Obj;
+use magnus::{function, method, Error, IntoValue, RHash, RString, Ruby, TryConvert, Value};
+use rb_sys::{rb_thread_call_with_gvl, rb_thread_call_without_gvl};
+use std::collections::HashMap;
+use std::ffi::c_void;
+use std::panic::{self, AssertUnwindSafe};
+use std::sync::{Arc, Mutex};
+
+mod errors {
+    use magnus::prelude::*;
+    use magnus::{Error, ExceptionClass, RModule, Ruby};
+    use std::cell::RefCell;
+
+    thread_local! {
+        static PARSE: RefCell<Option<ExceptionClass>> = const { RefCell::new(None) };
+        static EXECUTION: RefCell<Option<ExceptionClass>> = const { RefCell::new(None) };
+        static TYPE: RefCell<Option<ExceptionClass>> = const { RefCell::new(None) };
+    }
+
+    pub fn define(ruby: &Ruby, module: &RModule) -> Result<(), Error> {
+        let standard = ruby.exception_standard_error();
+        let base = module.define_error("Error", standard)?;
+        let parse = module.define_error("ParseError", base)?;
+        let execution = module.define_error("ExecutionError", base)?;
+        let ty = module.define_error("TypeError", base)?;
+        PARSE.with(|slot| *slot.borrow_mut() = Some(parse));
+        EXECUTION.with(|slot| *slot.borrow_mut() = Some(execution));
+        TYPE.with(|slot| *slot.borrow_mut() = Some(ty));
+        Ok(())
+    }
+
+    fn fallback(msg: String) -> Error {
+        let ruby = Ruby::get().expect("ruby runtime");
+        Error::new(ruby.exception_runtime_error(), msg)
+    }
+
+    pub fn parse(msg: impl Into<String>) -> Error {
+        let msg = msg.into();
+        PARSE.with(|slot| {
+            slot.borrow()
+                .map(|exc| Error::new(exc, msg.clone()))
+                .unwrap_or_else(|| fallback(msg))
+        })
+    }
+
+    pub fn execution(msg: impl Into<String>) -> Error {
+        let msg = msg.into();
+        EXECUTION.with(|slot| {
+            slot.borrow()
+                .map(|exc| Error::new(exc, msg.clone()))
+                .unwrap_or_else(|| fallback(msg))
+        })
+    }
+
+    pub fn ty(msg: impl Into<String>) -> Error {
+        let msg = msg.into();
+        TYPE.with(|slot| {
+            slot.borrow()
+                .map(|exc| Error::new(exc, msg.clone()))
+                .unwrap_or_else(|| fallback(msg))
+        })
+    }
+}
+
+fn without_gvl<F, T>(f: F) -> T
+where
+    F: FnOnce() -> T,
+    T: Send,
+{
+    struct State<F, T>
+    where
+        F: FnOnce() -> T,
+        T: Send,
+    {
+        f: Option<F>,
+        result: Option<T>,
+    }
+
+    unsafe extern "C" fn call<F, T>(ptr: *mut c_void) -> *mut c_void
+    where
+        F: FnOnce() -> T,
+        T: Send,
+    {
+        let state = &mut *(ptr as *mut State<F, T>);
+        let fun = state.f.take().expect("closure missing");
+        state.result = Some(fun());
+        std::ptr::null_mut()
+    }
+
+    let mut state = State {
+        f: Some(f),
+        result: None,
+    };
+
+    unsafe {
+        rb_thread_call_without_gvl(
+            Some(call::<F, T>),
+            &mut state as *mut _ as *mut c_void,
+            None,
+            std::ptr::null_mut(),
+        );
+    }
+
+    state.result.expect("result missing")
+}
+
+fn with_gvl<F, T>(f: F) -> T
+where
+    F: FnOnce() -> T,
+{
+    struct State<F, T>
+    where
+        F: FnOnce() -> T,
+    {
+        f: Option<F>,
+        result: Option<T>,
+    }
+
+    unsafe extern "C" fn call<F, T>(ptr: *mut c_void) -> *mut c_void
+    where
+        F: FnOnce() -> T,
+    {
+        let state = &mut *(ptr as *mut State<F, T>);
+        let fun = state.f.take().expect("closure missing");
+        state.result = Some(fun());
+        std::ptr::null_mut()
+    }
+
+    let mut state = State {
+        f: Some(f),
+        result: None,
+    };
+    unsafe {
+        rb_thread_call_with_gvl(Some(call::<F, T>), &mut state as *mut _ as *mut c_void);
+    }
+    state.result.expect("result missing")
+}
+
+#[derive(Clone)]
+struct CallbackFunction {
+    proc: Proc,
+}
+unsafe impl Send for CallbackFunction {}
+unsafe impl Sync for CallbackFunction {}
+
+#[derive(Clone)]
+struct FunctionRegistration {
+    name: String,
+    callback: Arc<CallbackFunction>,
+}
+
+#[derive(Default)]
+#[magnus::wrap(class = "CEL::Context", free_immediately, size)]
+struct ContextWrap {
+    use_empty: bool,
+    variables: Mutex<HashMap<String, CelValue>>,
+    functions: Mutex<Vec<FunctionRegistration>>,
+}
+
+#[magnus::wrap(class = "CEL::Program", free_immediately, size)]
+struct ProgramWrap {
+    inner: CelProgram,
+}
+
+#[derive(Clone)]
+#[magnus::wrap(class = "CEL::Duration", free_immediately, size)]
+struct DurationWrap {
+    inner: chrono::Duration,
+}
+
+fn ruby_to_cel_value(value: Value) -> Result<CelValue, Error> {
+    let ruby = Ruby::get().expect("ruby runtime");
+
+    if value.is_nil() {
+        return Ok(CelValue::Null);
+    }
+    if value.is_kind_of(ruby.class_true_class()) || value.is_kind_of(ruby.class_false_class()) {
+        return Ok(CelValue::Bool(<bool as TryConvert>::try_convert(value)?));
+    }
+    if value.is_kind_of(ruby.class_integer()) {
+        return Ok(CelValue::Int(<i64 as TryConvert>::try_convert(value)?));
+    }
+    if value.is_kind_of(ruby.class_float()) {
+        return Ok(CelValue::Float(<f64 as TryConvert>::try_convert(value)?));
+    }
+    if value.is_kind_of(ruby.class_string()) {
+        let string = <RString as TryConvert>::try_convert(value)?;
+        if string.enc_get() == ruby.ascii8bit_encindex() {
+            return Ok(CelValue::Bytes(Arc::new(unsafe {
+                string.as_slice().to_vec()
+            })));
+        }
+
+        return Ok(CelValue::String(Arc::new(
+            <String as TryConvert>::try_convert(value)?,
+        )));
+    }
+    if value.is_kind_of(ruby.class_symbol()) {
+        let sym = <magnus::Symbol as TryConvert>::try_convert(value)?;
+        return Ok(CelValue::String(Arc::new(sym.name()?.to_string())));
+    }
+    if value.is_kind_of(ruby.class_time()) {
+        return Ok(CelValue::Timestamp(
+            <chrono::DateTime<chrono::FixedOffset> as TryConvert>::try_convert(value)?,
+        ));
+    }
+    if let Ok(duration) = <Obj<DurationWrap> as TryConvert>::try_convert(value) {
+        return Ok(CelValue::Duration(duration.inner));
+    }
+    if value.is_kind_of(ruby.class_array()) {
+        let array = <magnus::RArray as TryConvert>::try_convert(value)?;
+        let mut out = Vec::with_capacity(array.len());
+        for element in array.into_iter() {
+            out.push(ruby_to_cel_value(element)?);
+        }
+        return Ok(CelValue::List(Arc::new(out)));
+    }
+    if value.is_kind_of(ruby.class_hash()) {
+        let hash = <RHash as TryConvert>::try_convert(value)?;
+        let mut out = HashMap::new();
+        hash.foreach(|k: Value, v: Value| {
+            let key = if let Ok(s) = <String as TryConvert>::try_convert(k) {
+                cel::objects::Key::from(s)
+            } else if let Ok(sym) = <magnus::Symbol as TryConvert>::try_convert(k) {
+                cel::objects::Key::from(sym.name()?.to_string())
+            } else if let Ok(i) = <i64 as TryConvert>::try_convert(k) {
+                cel::objects::Key::from(i)
+            } else if let Ok(b) = <bool as TryConvert>::try_convert(k) {
+                cel::objects::Key::from(b)
+            } else {
+                return Err(errors::ty(
+                    "Hash keys must be String/Symbol/Integer/Boolean",
+                ));
+            };
+            out.insert(key, ruby_to_cel_value(v)?);
+            Ok(magnus::r_hash::ForEach::Continue)
+        })?;
+        return Ok(CelValue::Map(cel::objects::Map { map: Arc::new(out) }));
+    }
+
+    Err(errors::ty("Unsupported Ruby type"))
+}
+
+fn cel_to_ruby(ruby: &Ruby, value: &CelValue) -> Result<Value, Error> {
+    Ok(match value {
+        CelValue::Int(v) => (*v).into_value_with(ruby),
+        CelValue::UInt(v) => (*v).into_value_with(ruby),
+        CelValue::Float(v) => (*v).into_value_with(ruby),
+        CelValue::String(v) => v.to_string().into_value_with(ruby),
+        CelValue::Bytes(v) => ruby
+            .enc_str_new(v.as_slice(), ruby.ascii8bit_encoding())
+            .into_value_with(ruby),
+        CelValue::Bool(v) => (*v).into_value_with(ruby),
+        CelValue::Duration(v) => ruby
+            .obj_wrap(DurationWrap { inner: *v })
+            .into_value_with(ruby),
+        CelValue::Timestamp(v) => (*v).into_value_with(ruby),
+        CelValue::Null => ruby.qnil().as_value(),
+        CelValue::List(v) => {
+            let ary = ruby.ary_new();
+            for element in v.iter() {
+                ary.push(cel_to_ruby(ruby, element)?)?;
+            }
+            ary.into_value_with(ruby)
+        }
+        CelValue::Map(v) => {
+            let hash = ruby.hash_new();
+            for (k, val) in v.map.iter() {
+                let key: Value = match k {
+                    cel::objects::Key::Int(i) => (*i).into_value_with(ruby),
+                    cel::objects::Key::Uint(u) => (*u).into_value_with(ruby),
+                    cel::objects::Key::Bool(b) => (*b).into_value_with(ruby),
+                    cel::objects::Key::String(s) => s.to_string().into_value_with(ruby),
+                };
+                hash.aset(key, cel_to_ruby(ruby, val)?)?;
+            }
+            hash.into_value_with(ruby)
+        }
+        _ => {
+            return Err(errors::ty(format!(
+                "Unsupported CEL value variant: {value:?}"
+            )))
+        }
+    })
+}
+
+impl DurationWrap {
+    fn new(seconds: f64) -> Result<Self, Error> {
+        if !seconds.is_finite() {
+            return Err(errors::ty("Duration seconds must be finite"));
+        }
+
+        let nanos = (seconds * 1_000_000_000.0).round();
+        if nanos < i64::MIN as f64 || nanos > i64::MAX as f64 {
+            return Err(errors::ty("Duration is out of range"));
+        }
+
+        Ok(Self {
+            inner: chrono::Duration::nanoseconds(nanos as i64),
+        })
+    }
+
+    fn total_seconds(&self) -> f64 {
+        let nanos = self.inner.num_nanoseconds().unwrap_or_else(|| {
+            if self.inner < chrono::Duration::zero() {
+                i64::MIN
+            } else {
+                i64::MAX
+            }
+        });
+
+        nanos as f64 / 1_000_000_000.0
+    }
+
+    fn to_s(&self) -> String {
+        format!("{}s", self.total_seconds())
+    }
+
+    fn inspect(&self) -> String {
+        format!("#<CEL::Duration {}>", self.to_s())
+    }
+
+    fn eq(&self, other: Obj<DurationWrap>) -> bool {
+        self.inner == other.inner
+    }
+}
+
+impl ContextWrap {
+    fn new(empty: bool) -> Self {
+        Self {
+            use_empty: empty,
+            variables: Mutex::new(HashMap::new()),
+            functions: Mutex::new(Vec::new()),
+        }
+    }
+
+    fn add_variable(&self, name: String, value: Value) -> Result<(), Error> {
+        self.variables
+            .lock()
+            .unwrap()
+            .insert(name, ruby_to_cel_value(value)?);
+        Ok(())
+    }
+
+    fn add_function(&self, name: String, proc: Proc) {
+        self.functions.lock().unwrap().push(FunctionRegistration {
+            name,
+            callback: Arc::new(CallbackFunction { proc }),
+        });
+    }
+
+    fn build_context(&self) -> CelContext<'static> {
+        let mut ctx = if self.use_empty {
+            CelContext::empty()
+        } else {
+            CelContext::default()
+        };
+
+        for (name, value) in self.variables.lock().unwrap().iter() {
+            ctx.add_variable_from_value(name.as_str(), value.clone());
+        }
+
+        for registration in self.functions.lock().unwrap().iter() {
+            let callback = registration.callback.clone();
+            let function_name = registration.name.clone();
+            ctx.add_function(
+                &function_name,
+                move |ftx: &FunctionContext,
+                      cel::extractors::Arguments(args): cel::extractors::Arguments|
+                      -> ResolveResult {
+                    let callback = callback.clone();
+                    let this = ftx.this.clone();
+                    let args = args.clone();
+
+                    with_gvl(|| {
+                        let ruby = Ruby::get().expect("ruby runtime");
+                        let mut ruby_args = Vec::new();
+
+                        if let Some(target) = this {
+                            ruby_args.push(cel_to_ruby(&ruby, &target).map_err(|e| {
+                                CelExecutionError::function_error(ftx.name, e.to_string())
+                            })?);
+                        }
+
+                        for arg in args.iter() {
+                            ruby_args.push(cel_to_ruby(&ruby, arg).map_err(|e| {
+                                CelExecutionError::function_error(ftx.name, e.to_string())
+                            })?);
+                        }
+
+                        let proc_result =
+                            callback.proc.call(ruby_args.as_slice()).map_err(|e| {
+                                CelExecutionError::function_error(
+                                    ftx.name,
+                                    format!("Ruby callback error: {e}"),
+                                )
+                            })?;
+
+                        ruby_to_cel_value(proc_result)
+                            .map_err(|e| CelExecutionError::function_error(ftx.name, e.to_string()))
+                    })
+                },
+            );
+        }
+
+        ctx
+    }
+}
+
+impl ProgramWrap {
+    fn compile(source: String) -> Result<Self, Error> {
+        CelProgram::compile(&source)
+            .map(|inner| Self { inner })
+            .map_err(|e: ParseErrors| errors::parse(e.to_string()))
+    }
+
+    fn execute(&self) -> Result<Value, Error> {
+        self.execute_with_context_internal(&CelContext::default())
+    }
+
+    fn execute_with_context(&self, context: &ContextWrap) -> Result<Value, Error> {
+        self.execute_with_context_internal(&context.build_context())
+    }
+
+    fn execute_with_context_internal(&self, ctx: &CelContext<'_>) -> Result<Value, Error> {
+        let run = || self.inner.execute(ctx);
+        let result = panic::catch_unwind(AssertUnwindSafe(|| without_gvl(run)))
+            .map_err(|_| errors::execution("CEL execution panicked"))?;
+
+        let ruby = Ruby::get().expect("ruby runtime");
+        result
+            .map_err(|e| errors::execution(e.to_string()))
+            .and_then(|value| cel_to_ruby(&ruby, &value))
+    }
+
+    fn references(&self) -> Result<RHash, Error> {
+        let ruby = Ruby::get().expect("ruby runtime");
+        let refs = self.inner.references();
+
+        let vars = ruby.ary_new();
+        for var in refs.variables() {
+            vars.push(var)?;
+        }
+
+        let funcs = ruby.ary_new();
+        for func in refs.functions() {
+            funcs.push(func)?;
+        }
+
+        let out = ruby.hash_new();
+        out.aset("variables", vars)?;
+        out.aset("functions", funcs)?;
+        Ok(out)
+    }
+
+    fn expression(&self) -> String {
+        format!("{:?}", self.inner.expression())
+    }
+}
+
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    let module = ruby.define_module("CEL")?;
+    errors::define(ruby, &module)?;
+
+    let context_class = module.define_class("Context", ruby.class_object())?;
+    context_class.define_singleton_method("new", function!(ContextWrap::new, 1))?;
+    context_class.define_method("add_variable", method!(ContextWrap::add_variable, 2))?;
+    context_class.define_method("[]=", method!(ContextWrap::add_variable, 2))?;
+    context_class.define_method("add_function", method!(ContextWrap::add_function, 2))?;
+
+    let duration_class = module.define_class("Duration", ruby.class_object())?;
+    duration_class.define_singleton_method("new", function!(DurationWrap::new, 1))?;
+    duration_class.define_method("total_seconds", method!(DurationWrap::total_seconds, 0))?;
+    duration_class.define_method("to_f", method!(DurationWrap::total_seconds, 0))?;
+    duration_class.define_method("to_s", method!(DurationWrap::to_s, 0))?;
+    duration_class.define_method("inspect", method!(DurationWrap::inspect, 0))?;
+    duration_class.define_method("==", method!(DurationWrap::eq, 1))?;
+
+    let program_class = module.define_class("Program", ruby.class_object())?;
+    program_class.define_singleton_method("compile", function!(ProgramWrap::compile, 1))?;
+    program_class.define_method("execute", method!(ProgramWrap::execute, 0))?;
+    program_class.define_method(
+        "execute_with_context",
+        method!(ProgramWrap::execute_with_context, 1),
+    )?;
+    program_class.define_method("references", method!(ProgramWrap::references, 0))?;
+    program_class.define_method("expression", method!(ProgramWrap::expression, 0))?;
+
+    module.define_singleton_method("compile", function!(ProgramWrap::compile, 1))?;
+
+    Ok(())
+}

data/lib/cel/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module CEL
+  VERSION = "0.1.0"
+end

data/lib/cel.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "cel/version"
+
+begin
+  RUBY_VERSION =~ /(\d+\.\d+)/
+  require "cel/#{Regexp.last_match(1)}/cel"
+rescue LoadError
+  require "cel/cel"
+end
+
+module CEL
+  class Context
+    class << self
+      alias_method :__native_new, :new
+
+      def new(empty = false)
+        __native_new(!!empty)
+      end
+
+      def build(empty: false, **variables)
+        ctx = new(empty)
+        variables.each { |k, v| ctx.add_variable(k.to_s, v) }
+        yield(ctx) if block_given?
+        ctx
+      end
+    end
+
+    def define_function(name, &block)
+      raise ArgumentError, "block required" unless block
+
+      add_function(name.to_s, block)
+    end
+  end
+
+  class Program
+    alias_method :__native_execute, :execute
+
+    def execute(context = nil)
+      return __native_execute if context.nil?
+
+      execute_with_context(context)
+    end
+
+    def call(context = nil)
+      execute(context)
+    end
+  end
+end

data/spec/cel_spec.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "time"
+
+RSpec.describe CEL do
+  describe ".compile" do
+    it "compiles and executes simple expressions" do
+      program = CEL.compile("1 + 1")
+      expect(program.execute).to eq(2)
+    end
+
+    it "raises parse errors for invalid programs" do
+      expect { CEL.compile("1 +") }.to raise_error(CEL::ParseError)
+    end
+  end
+
+  describe CEL::Context do
+    it "supports ruby variables for basic types" do
+      context = CEL::Context.new
+      context.add_variable("nil_value", nil)
+      context.add_variable("flag", true)
+      context.add_variable("num", 41)
+      context.add_variable("float_num", 1.5)
+      context.add_variable("name", "cel")
+      context.add_variable("ary", [1, 2, 3])
+      context.add_variable("obj", {"a" => 1, :b => 2})
+
+      expect(CEL.compile("nil_value == null").execute(context)).to eq(true)
+      expect(CEL.compile("flag && true").execute(context)).to eq(true)
+      expect(CEL.compile("num + 1").execute(context)).to eq(42)
+      expect(CEL.compile("float_num + 0.5").execute(context)).to eq(2.0)
+      expect(CEL.compile("name.startsWith('c')").execute(context)).to eq(true)
+      expect(CEL.compile("ary[2]").execute(context)).to eq(3)
+      expect(CEL.compile("obj.a + obj.b").execute(context)).to eq(3)
+    end
+
+    it "supports ruby values for CEL bytes, timestamp, and duration types" do
+      context = CEL::Context.build(
+        bytes: "abc".b,
+        at: Time.utc(2023, 5, 29),
+        delay: CEL::Duration.new(90)
+      )
+
+      expect(CEL.compile("bytes == b'abc'").execute(context)).to eq(true)
+      expect(CEL.compile("at == timestamp('2023-05-29T00:00:00Z')").execute(context)).to eq(true)
+      expect(CEL.compile("delay == duration('90s')").execute(context)).to eq(true)
+    end
+
+    it "registers ruby functions and supports variadic calls" do
+      context = CEL::Context.new
+      context.define_function("sum") do |*values|
+        values.flatten.sum
+      end
+
+      expect(CEL.compile("sum(1, 2, 3)").execute(context)).to eq(6)
+    end
+
+    it "passes method receiver as first block arg for method calls" do
+      context = CEL::Context.new(true)
+      context.define_function("startsWith") { |target, prefix| target.start_with?(prefix) }
+
+      expect(CEL.compile("'hello'.startsWith('he')").execute(context)).to eq(true)
+    end
+
+    it "raises clear type error for unsupported variable types" do
+      context = CEL::Context.new
+      expect { context.add_variable("bad", Object.new) }.to raise_error(CEL::TypeError)
+    end
+  end
+
+  describe CEL::Program do
+    it "exposes references" do
+      program = CEL.compile("size(foo) > 0")
+      refs = program.references
+      expect(refs["variables"]).to include("foo")
+      expect(refs["functions"]).to include("size")
+    end
+
+    it "ports core CEL suite behavior examples" do
+      tests = {
+        "size([1,2,3]) == 3" => true,
+        "[1,2,3].map(x, x * 2)" => [2, 4, 6],
+        "[1,2,3].filter(x, x > 1)" => [2, 3],
+        "[1,2,3].exists(x, x == 2)" => true,
+        "[1,2,3].all(x, x > 0)" => true,
+        "{'a': 1}.contains('a')" => true,
+        "optional.of(1).hasValue()" => true
+      }
+
+      tests.each do |expr, expected|
+        expect(CEL.compile(expr).execute).to eq(expected)
+      end
+    end
+
+    it "marshals current CEL scalar value variants back to ruby" do
+      bytes = CEL.compile("b'abc'").execute
+      expect(bytes).to eq("abc".b)
+      expect(bytes.encoding).to eq(Encoding::ASCII_8BIT)
+
+      timestamp = CEL.compile("timestamp('2023-05-29T00:00:00Z')").execute
+      expect(timestamp).to be_a(Time)
+      expect(timestamp.getutc.iso8601).to eq("2023-05-29T00:00:00Z")
+
+      duration = CEL.compile("duration('1m30s')").execute
+      expect(duration).to be_a(CEL::Duration)
+      expect(duration.total_seconds).to eq(90.0)
+      expect(duration).to eq(CEL::Duration.new(90))
+    end
+
+    it "returns execution errors as CEL::ExecutionError" do
+      program = CEL.compile("1 / 0")
+      expect { program.execute }.to raise_error(CEL::ExecutionError)
+    end
+
+    it "releases GVL so other ruby threads can progress" do
+      context = CEL::Context.new
+      context.add_variable("items", Array.new(15_000, 1))
+      program = CEL.compile("items.map(x, x + 1)")
+
+      marker = Queue.new
+      worker = Thread.new do
+        100.times do
+          marker << :tick
+          sleep(0.001)
+        end
+      end
+
+      runner = Thread.new { program.execute(context) }
+
+      sleep(0.01)
+      expect(marker.size).to be > 0
+
+      runner.join
+      worker.join
+    end
+
+    it "is thread-safe when executing concurrently" do
+      context = CEL::Context.new
+      context.add_variable("n", 10)
+      program = CEL.compile("n * 2")
+
+      threads = Array.new(8) { Thread.new { 50.times.map { program.execute(context) } } }
+      values = threads.flat_map(&:value)
+
+      expect(values.uniq).to eq([20])
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "simplecov"
+
+SimpleCov.start do
+  add_filter "/spec/"
+end
+
+require "cel"

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification
+name: cel-rs-rb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- CEL Ruby Contributors
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rb_sys
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.128
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.128
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.4'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+- !ruby/object:Gem::Dependency
+  name: standard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.55'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.55'
+description: Robust Ruby bindings to the Rust CEL implementation using Magnus
+email: []
+executables: []
+extensions:
+- ext/cel/extconf.rb
+extra_rdoc_files: []
+files:
+- Cargo.toml
+- LICENSE
+- README.md
+- ext/cel/Cargo.toml
+- ext/cel/extconf.rb
+- ext/cel/src/lib.rs
+- lib/cel.rb
+- lib/cel/version.rb
+- spec/cel_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/catkins/cel-rs-rb
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/catkins/cel-rs-rb
+  source_code_uri: https://github.com/catkins/cel-rs-rb
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.10
+specification_version: 4
+summary: Ruby bindings for the Rust CEL crate
+test_files: []