cel-rs-rb 0.1.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4a2986048cff8c1e335c72ffc410487bae67a02251ff9ef9815c34a430199b39
-  data.tar.gz: 14df42d51ffda3ecdbfd0a9455a9e11d9990b0f30f11c9f261d5367768d35498
+  metadata.gz: 4649bfaf71cdf145a7cce4befa9b00e6e74d9a5d4463253a0bfee3ad13e516fa
+  data.tar.gz: '0940f3b1af9507a22f77c7471c3d96a045afe2c86bd977617d45eae902c8f570'
 SHA512:
-  metadata.gz: 1af27f75d923ded581e5dfab5d046cd97ccb3837822f2cbae96f751c6dc7e41e2db539e86e61a70520efdf98c314b5a20ba557e242ffe2fee9788b5a9f29b843
-  data.tar.gz: 16f711a65c9ef6b529410d8b3d823bb6317d80626460fa5cd43d01bd365b84efb4a6d800897bf8e927b56e8ce216aa2960e811e9f6000c959c0ec9b24c7c8207
+  metadata.gz: 94a4d0a7ad34e64a5b4afbfc6895b5432df83b0397af2d985a1d589fff8790efe23a6abd6fadebe2c9955d039553cdd4f48ad52e9785f6513d8b025d64a53dcf
+  data.tar.gz: f17cc32784ddf733bd690b3f688a04a8586f1ed9a23e281be88c4432d5052fa0691318cf9d389b0678f9e8e6201390075afeee8ae061dbc2aee749d4ef622fd0

data/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+## 0.3.1
+
+### Fixed
+
+- Keep registered Ruby callback Procs and their captured values alive while their
+  `CEL::Context` is reachable. Prevents use-after-free after the caller drops its
+  own reference and Ruby runs garbage collection. Callbacks are also pinned during
+  compaction, including when collection runs inside a callback.

data/README.md

@@ -1,6 +1,8 @@
 # cel-rs-rb
 
-Ruby bindings for the Rust [`cel`](https://crates.io/crates/cel) crate, implemented with [Magnus](https://github.com/matsadler/magnus).
+[![Gem Version](https://img.shields.io/gem/v/cel-rs-rb.svg)](https://rubygems.org/gems/cel-rs-rb)
+
+Ruby bindings for the Rust [`cel`](https://crates.io/crates/cel) 0.15 crate, implemented with [Magnus](https://github.com/matsadler/magnus).
 
 ## Goals
 
@@ -30,10 +32,69 @@ program.execute(context)
 # => 60
 ```
 
+### Optional values
+
+Use optional access to handle missing fields, and `orValue` to supply a default:
+
+```ruby
+context = CEL::Context.build(user: {})
+CEL.compile("user.?name.orValue('unknown')").execute(context)
+# => "unknown"
+
+context = CEL::Context.build(user: {"name" => "Ada"})
+CEL.compile("user.?name.optMap(n, n.size()).orValue(0)").execute(context)
+# => 3
+```
+
+Unwrap optional values inside CEL with `orValue` or `value()` before returning
+them to Ruby. Returning an optional directly raises `CEL::TypeError`; it is not
+automatically converted to its contained value or `nil`.
+
+### `max` and `min`
+
+Default contexts include `max` and `min`. They take a list or positional arguments and
+return `nil` when given no values:
+
+```ruby
+CEL.compile("max(2, 9, -3)").execute   # => 9
+CEL.compile("min([2, 9, -3])").execute # => -3
+CEL.compile("max([])").execute         # => nil
+```
+
+### Extension libraries
+
+Opt into upstream CEL extension libraries when compiling a program:
+
+```ruby
+program = CEL.compile(
+  "[label.lowerAscii(), scores.sort(), math.greatest(scores), base64.encode(b'hi')]",
+  extensions: [:strings, :lists, :math, :encoders]
+)
+program.execute(CEL::Context.build(label: "TacoCat", scores: [2, 9, -3]))
+# => ["tacocat", [-3, 2, 9], 9, "aGk="]
+```
+
+| Library | Examples |
+| --- | --- |
+| [`strings`](https://docs.rs/cel/0.15.0/cel/extensions/fn.strings.html) | `'TacoCat'.lowerAscii()`, `'a,b'.split(',')` |
+| [`lists`](https://docs.rs/cel/0.15.0/cel/extensions/fn.lists.html) | `lists.range(3)`, `[3, 1, 2].sort()`, `items.sortBy(x, x.score)` |
+| [`math`](https://docs.rs/cel/0.15.0/cel/extensions/fn.math.html) | `math.greatest(1, 5, 3)`, `math.least([1, 5, 3])` |
+| [`encoders`](https://docs.rs/cel/0.15.0/cel/extensions/fn.encoders.html) | `base64.encode(b'hi')`, `base64.decode('aGk=')` |
+
+`CEL::Program.compile` accepts the same `extensions:` option. Names can be
+symbols or strings; unknown or repeated names raise `ArgumentError`.
+
+Extensions are disabled by default and registered per program, for both macro
+expansion and execution. They work with bare `execute` or a default context,
+including its variables and Ruby callbacks. They do not change other programs
+or add functions to explicitly empty contexts. Ruby callbacks that conflict
+with enabled extension functions raise `CEL::ExecutionError` during execution,
+just like conflicts with standard CEL builtins.
+
 ### API mapping
 
-- `CEL.compile(source)` -> `CEL::Program`
-- `CEL::Program.compile(source)` -> `CEL::Program`
+- `CEL.compile(source, extensions: [])` -> `CEL::Program`
+- `CEL::Program.compile(source, extensions: [])` -> `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`)
@@ -75,9 +136,14 @@ program.execute(context)
 
 ## 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.
+- Compiled `CEL::Program` instances can be shared and executed concurrently from
+  multiple Ruby threads with separate execution contexts.
+- Each thread may pass its own `CEL::Context`; context data is mutex-protected
+  and copied into an immutable execution snapshot for each run.
+- CEL evaluation runs with the Ruby GVL released, so other Ruby threads can keep
+  progressing while a program executes.
+- Ruby callbacks from CEL functions temporarily re-acquire the GVL before
+  invoking Ruby code.
 
 ## Development
 
@@ -105,7 +171,52 @@ This runs:
 
 CI also runs the test suite on Ruby 3.3, Ruby 3.4, and Ruby 4.0 through Buildkite.
 
+## Releasing
+
+See [CHANGELOG.md](CHANGELOG.md) for release notes. Update it alongside each version bump.
+
+Releases publish a generic `ruby` platform gem and **precompiled native gems**
+for six platforms (`x86_64-linux`, `aarch64-linux`, `x86_64-linux-musl`,
+`aarch64-linux-musl`, `arm64-darwin`, `x86_64-darwin`) to
+[rubygems.org](https://rubygems.org/gems/cel-rs-rb). The generic gem keeps
+RubyGems' latest-version metadata aligned; supported platforms should still
+resolve to their matching precompiled native gem.
+
+### Cutting a release
+
+The gem version comes from `lib/cel/version.rb`, not from the tag, so bump the
+file and tag the same version:
+
+```bash
+# 1. Bump CEL::VERSION in lib/cel/version.rb (e.g. "0.2.0")
+# 2. Refresh Gemfile.lock's local gem version
+bundle install
+
+# 3. Commit the bump
+git add lib/cel/version.rb Gemfile.lock
+git commit -m "Release v0.2.0"
+
+# 4. Tag that commit (the v-prefix triggers the release pipeline)
+git tag v0.2.0
+git push origin main
+git push origin v0.2.0
+```
+
+`Gemfile.lock` includes a local `cel-rs-rb` path entry, so commit its version
+change alongside `lib/cel/version.rb`.
+
+The `release:verify-tag` step fails the build if the tag and
+`CEL::VERSION` disagree, so the tag (`v0.2.0`) must match `version.rb`
+(`0.2.0`).
+
 ## Compatibility notes
 
+- Compilation uses the standard CEL environment, including optional access syntax (`user.?name`) and the `optMap` / `optFlatMap` macros.
+- The upstream strings, lists, math, and encoders extension libraries are opt-in through the `extensions:` compile option.
+- cel 0.15 no longer includes `max` and `min` by default, so default contexts register them for compatibility with cel 0.13. See [`max` and `min`](#max-and-min).
+- When upgrading from cel 0.13, replace list/map `.contains(value)` expressions with `value in collection`; `.contains()` now only accepts strings. Map literals with duplicate keys raise `CEL::ExecutionError`, and string `size()` counts Unicode code points rather than bytes. See the [cel 0.15 release notes](https://github.com/cel-rust/cel-rust/releases/tag/v0.15.0) for further CEL semantic changes.
+- `string(bytes)` now rejects invalid UTF-8. Numeric conversions reject out-of-range results, and parsed timestamps and durations must fit CEL's allowed ranges.
+- `all()` and `exists()` can now absorb an earlier evaluation error when a later element determines the result. For example, `[2, 1].exists(e, 6 / (2 - e) == 6)` returns `true` despite the first element's division by zero.
+- Ruby callbacks cannot shadow standard CEL builtins (such as `size`) in a default context; the compatibility functions `max` and `min` are exceptions. Conflicts raise `CEL::ExecutionError` when `Program#execute(context)` builds the execution snapshot, even if the expression does not call the conflicting function. Use `CEL::Context.new(true)` or `CEL::Context.build(empty: true)` to define functions without builtins. Registering the same custom callback name again replaces the previous callback.
 - 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

@@ -10,5 +10,5 @@ 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"] }
+cel = { version = "0.15.0", features = ["chrono", "regex", "json"] }
 chrono = "0.4.45"

data/ext/cel/src/lib.rs

@@ -155,17 +155,27 @@ struct FunctionRegistration {
     callback: Arc<CallbackFunction>,
 }
 
-#[derive(Default)]
-#[magnus::wrap(class = "CEL::Context", free_immediately, size)]
+#[derive(Default, magnus::TypedData)]
+#[magnus(class = "CEL::Context", free_immediately, size, mark)]
 struct ContextWrap {
     use_empty: bool,
     variables: Mutex<HashMap<String, CelValue>>,
     functions: Mutex<Vec<FunctionRegistration>>,
 }
 
+impl magnus::DataTypeFunctions for ContextWrap {
+    fn mark(&self, marker: &magnus::gc::Marker) {
+        for registration in self.functions.lock().unwrap().iter() {
+            // Non-movable marking also pins the Proc during Ruby compaction.
+            marker.mark(registration.callback.proc);
+        }
+    }
+}
+
 #[magnus::wrap(class = "CEL::Program", free_immediately, size)]
 struct ProgramWrap {
     inner: CelProgram,
+    env: Arc<cel::Env>,
 }
 
 #[derive(Clone)]
@@ -355,11 +365,16 @@ impl ContextWrap {
         });
     }
 
-    fn build_context(&self) -> CelContext<'static> {
+    fn build_context(&self, env: Arc<cel::Env>) -> Result<CelContext<'static, 'static>, Error> {
         let mut ctx = if self.use_empty {
             CelContext::empty()
         } else {
-            CelContext::default()
+            let mut ctx = CelContext::with_env(env);
+            ctx.add_function("max", cel::functions::max)
+                .map_err(|e| errors::execution(e.to_string()))?;
+            ctx.add_function("min", cel::functions::min)
+                .map_err(|e| errors::execution(e.to_string()))?;
+            ctx
         };
 
         for (name, value) in self.variables.lock().unwrap().iter() {
@@ -375,7 +390,11 @@ impl ContextWrap {
                       cel::extractors::Arguments(args): cel::extractors::Arguments|
                       -> ResolveResult {
                     let callback = callback.clone();
-                    let this = ftx.this.clone();
+                    let this = ftx
+                        .this
+                        .as_ref()
+                        .map(|value| CelValue::try_from(value.as_ref()))
+                        .transpose()?;
                     let args = args.clone();
 
                     with_gvl(|| {
@@ -406,29 +425,49 @@ impl ContextWrap {
                             .map_err(|e| CelExecutionError::function_error(ftx.name, e.to_string()))
                     })
                 },
-            );
+            )
+            .map_err(|e| errors::execution(e.to_string()))?;
         }
 
-        ctx
+        Ok(ctx)
     }
 }
 
 impl ProgramWrap {
-    fn compile(source: String) -> Result<Self, Error> {
-        CelProgram::compile(&source)
-            .map(|inner| Self { inner })
+    fn compile(source: String, extensions: Vec<String>) -> Result<Self, Error> {
+        let ruby = Ruby::get().expect("ruby runtime");
+        let mut env = cel::Env::stdlib();
+        for name in extensions {
+            let extension = match name.as_str() {
+                "strings" => cel::extensions::strings,
+                "lists" => cel::extensions::lists,
+                "math" => cel::extensions::math,
+                "encoders" => cel::extensions::encoders,
+                _ => {
+                    return Err(Error::new(
+                        ruby.exception_arg_error(),
+                        format!("Unknown CEL extension: {name}"),
+                    ))
+                }
+            };
+            env.add_extension(extension)
+                .map_err(|e| Error::new(ruby.exception_arg_error(), e.to_string()))?;
+        }
+        let env = Arc::new(env);
+        env.compile(&source)
+            .map(|inner| Self { inner, env })
             .map_err(|e: ParseErrors| errors::parse(e.to_string()))
     }
 
     fn execute(&self) -> Result<Value, Error> {
-        self.execute_with_context_internal(&CelContext::default())
+        self.execute_with_context(&ContextWrap::new(false))
     }
 
     fn execute_with_context(&self, context: &ContextWrap) -> Result<Value, Error> {
-        self.execute_with_context_internal(&context.build_context())
+        self.execute_with_context_internal(&context.build_context(self.env.clone())?)
     }
 
-    fn execute_with_context_internal(&self, ctx: &CelContext<'_>) -> Result<Value, Error> {
+    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"))?;
@@ -484,7 +523,7 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     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_singleton_method("compile", function!(ProgramWrap::compile, 2))?;
     program_class.define_method("execute", method!(ProgramWrap::execute, 0))?;
     program_class.define_method(
         "execute_with_context",
@@ -493,7 +532,5 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     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

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

data/lib/cel.rb

@@ -10,6 +10,10 @@ rescue LoadError
 end
 
 module CEL
+  def self.compile(source, extensions: [])
+    Program.compile(source, extensions: extensions)
+  end
+
   class Context
     class << self
       alias_method :__native_new, :new
@@ -34,6 +38,14 @@ module CEL
   end
 
   class Program
+    class << self
+      alias_method :__native_compile, :compile
+
+      def compile(source, extensions: [])
+        __native_compile(source, extensions.map(&:to_s))
+      end
+    end
+
     alias_method :__native_execute, :execute
 
     def execute(context = nil)

data/spec/cel_spec.rb

@@ -2,6 +2,7 @@
 
 require "spec_helper"
 require "time"
+require "open3"
 
 RSpec.describe CEL do
   describe ".compile" do
@@ -13,6 +14,49 @@ RSpec.describe CEL do
     it "raises parse errors for invalid programs" do
       expect { CEL.compile("1 +") }.to raise_error(CEL::ParseError)
     end
+
+    it "enables each upstream extension for compilation and execution" do
+      tests = {
+        strings: ["'TacoCat'.lowerAscii()", "tacocat"],
+        lists: ["[{'n': 8}, {'n': 2}, {'n': 5}].sortBy(x, x.n).map(x, x.n)", [2, 5, 8]],
+        math: ["math.greatest(2, 9, -3)", 9],
+        encoders: ["base64.encode(b'hi')", "aGk="]
+      }
+
+      tests.each do |extension, (expression, expected)|
+        program = CEL.compile(expression, extensions: [extension])
+        expect(program.execute).to eq(expected)
+        expect(program.execute(CEL::Context.new)).to eq(expected)
+      end
+    end
+
+    it "combines extensions with context variables and Ruby callbacks" do
+      context = CEL::Context.build(label: "TacoCat", scores: [2, 9, -3]) do |ctx|
+        ctx.define_function("decorate") { |value| "[#{value}]" }
+      end
+      program = CEL::Program.compile(
+        "[decorate(label.lowerAscii()), scores.sort(), math.greatest(scores), base64.encode(b'hi')]",
+        extensions: ["strings", "lists", "math", "encoders"]
+      )
+
+      expect(program.execute(context)).to eq(["[tacocat]", [-3, 2, 9], 9, "aGk="])
+    end
+
+    it "keeps extensions local to a program and excludes them from empty contexts" do
+      context = CEL::Context.new
+      enabled = CEL.compile("'ABC'.lowerAscii()", extensions: [:strings])
+      expect(enabled.execute(context)).to eq("abc")
+      expect { CEL.compile("'ABC'.lowerAscii()").execute(context) }.to raise_error(CEL::ExecutionError)
+      expect { enabled.execute(CEL::Context.new(true)) }.to raise_error(CEL::ExecutionError)
+
+      context.define_function("lowerAscii") { |value| value }
+      expect { enabled.execute(context) }.to raise_error(CEL::ExecutionError, /lowerAscii/)
+    end
+
+    it "rejects unknown and repeated extension registrations" do
+      expect { CEL.compile("1", extensions: [:unknown]) }.to raise_error(ArgumentError, /unknown/)
+      expect { CEL.compile("1", extensions: [:strings, "strings"]) }.to raise_error(ArgumentError)
+    end
   end
 
   describe CEL::Context do
@@ -56,6 +100,40 @@ RSpec.describe CEL do
       expect(CEL.compile("sum(1, 2, 3)").execute(context)).to eq(6)
     end
 
+    it "keeps registered callbacks alive through garbage collection and compaction" do
+      # Isolate native GC failures and discard the registering thread's stack roots.
+      output, status = Open3.capture2e(
+        RbConfig.ruby, "-I", File.expand_path("../lib", __dir__), "-rcel", "-rweakref", "-e", <<~RUBY
+          context, callbacks = Thread.new do
+            ctx = CEL::Context.new
+            prefix = +"retained:token:"
+            decorate = proc { |value| prefix + value }
+            collect = proc do
+              GC.start
+              GC.verify_compaction_references(expand_heap: true, toward: :empty)
+              17
+            end
+            ctx.define_function("decorate", &decorate)
+            ctx.define_function("collect", &collect)
+            [ctx, [WeakRef.new(decorate), WeakRef.new(collect)]]
+          end.value
+
+          program = CEL.compile("[decorate('ok'), collect(), decorate('again')]")
+          3.times do
+            GC.start
+            GC.verify_compaction_references(expand_heap: true, toward: :empty)
+            raise "registered callback was collected" unless callbacks.all?(&:weakref_alive?)
+            result = program.execute(context)
+            raise "incorrect callback result: \#{result.inspect}" unless result == [
+              "retained:token:ok", 17, "retained:token:again"
+            ]
+          end
+        RUBY
+      )
+
+      expect(status.success?).to eq(true), output
+    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) }
@@ -63,6 +141,31 @@ RSpec.describe CEL do
       expect(CEL.compile("'hello'.startsWith('he')").execute(context)).to eq(true)
     end
 
+    it "marshals callback receivers, arguments, and results" do
+      context = CEL::Context.build(prefix: {"label" => "result"})
+      context.define_function("combine") do |target, values, suffix|
+        {target["label"] => values + [suffix]}
+      end
+
+      expect(CEL.compile("prefix.combine([2, 5], 9)").execute(context)).to eq("result" => [2, 5, 9])
+    end
+
+    it "reports builtin callback conflicts when building the execution context" do
+      context = CEL::Context.new
+      context.define_function("size") { |_| 99 }
+
+      expect { CEL.compile("size([1, 2])").execute(context) }
+        .to raise_error(CEL::ExecutionError, /size/)
+    end
+
+    it "replaces callbacks with the same name" do
+      context = CEL::Context.new
+      context.define_function("adjust") { |value| value + 1 }
+      context.define_function("adjust") { |value| value + 7 }
+
+      expect(CEL.compile("adjust(3)").execute(context)).to eq(10)
+    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)
@@ -77,6 +180,36 @@ RSpec.describe CEL do
       expect(refs["functions"]).to include("size")
     end
 
+    it "registers max and min by default" do
+      tests = {
+        "max(2, 9, -3)" => 9,
+        "min(2, 9, -3)" => -3,
+        "max([2, 9, -3])" => 9,
+        "min([2, 9, -3])" => -3,
+        "max()" => nil,
+        "min([])" => nil
+      }
+
+      [nil, CEL::Context.new].each do |context|
+        tests.each do |expression, expected|
+          expect(CEL.compile(expression).execute(context)).to eq(expected)
+        end
+      end
+    end
+
+    it "leaves max and min out of empty contexts and allows custom callbacks" do
+      ["max", "min"].each do |name|
+        program = CEL.compile("#{name}(2, 9)")
+        empty = CEL::Context.new(true)
+        expect { program.execute(empty) }.to raise_error(CEL::ExecutionError)
+
+        [empty, CEL::Context.new].each do |context|
+          context.define_function(name) { |a, b| a + b }
+          expect(program.execute(context)).to eq(11)
+        end
+      end
+    end
+
     it "ports core CEL suite behavior examples" do
       tests = {
         "size([1,2,3]) == 3" => true,
@@ -84,8 +217,13 @@ RSpec.describe CEL do
         "[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
+        "'a' in {'a': 1}" => true,
+        "optional.of(1).hasValue()" => true,
+        "size('café😊')" => 5,
+        "{'name': 'Ada'}.?name.optMap(n, n.size()).orValue(0)" => 3,
+        "{}.?name.optMap(n, n.size()).orValue(0)" => 0,
+        "{'user': {'name': 'Ada'}}.?user.optFlatMap(u, u.?name).orValue('missing')" => "Ada",
+        "[2, 1].exists(e, 6 / (2 - e) == 6)" => true
       }
 
       tests.each do |expr, expected|
@@ -113,6 +251,10 @@ RSpec.describe CEL do
       expect { program.execute }.to raise_error(CEL::ExecutionError)
     end
 
+    it "rejects duplicate map literal keys" do
+      expect { CEL.compile("{'a': 1, 'a': 2}").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))
@@ -135,15 +277,38 @@ RSpec.describe CEL do
       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")
+    it "executes the same program concurrently with independent contexts" do
+      program = CEL.compile("items.map(x, x + offset).filter(x, x > cutoff).size() + id")
+      ready = Queue.new
+      start = Queue.new
 
-      threads = Array.new(8) { Thread.new { 50.times.map { program.execute(context) } } }
-      values = threads.flat_map(&:value)
+      threads = Array.new(8) do |id|
+        Thread.new do
+          ready << true
+          start.pop
+
+          offset = id % 3
+          context = CEL::Context.build(
+            id: id,
+            items: Array.new(200, id),
+            offset: offset,
+            cutoff: id
+          )
+
+          25.times.map { program.execute(context) }
+        end
+      end
+      8.times { ready.pop }
+      8.times { start << true }
+      results = threads.map(&:value)
+
+      expected = Array.new(8) do |id|
+        offset = id % 3
+        value = (offset.zero? ? 0 : 200) + id
+        Array.new(25, value)
+      end
 
-      expect(values.uniq).to eq([20])
+      expect(results).to eq(expected)
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cel-rs-rb
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.1
 platform: ruby
 authors:
 - CEL Ruby Contributors
@@ -100,6 +100,7 @@ extensions:
 - ext/cel/extconf.rb
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - Cargo.toml
 - LICENSE
 - README.md
@@ -110,12 +111,12 @@ files:
 - lib/cel/version.rb
 - spec/cel_spec.rb
 - spec/spec_helper.rb
-homepage: https://github.com/catkins/cel-rs-rb
+homepage: https://github.com/buildkite/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
+  homepage_uri: https://github.com/buildkite/cel-rs-rb
+  source_code_uri: https://github.com/buildkite/cel-rs-rb
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
@@ -131,7 +132,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Ruby bindings for the Rust CEL crate
 test_files: []