cel-rs-rb 0.2.0.pre.1-aarch64-linux → 0.3.1-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f0131ec68b9a0fc2590167779c08ee336f7d4a54c9b789d004a1b57938ab5657
-  data.tar.gz: 289fdf028556b83a4f4a05b87ca0f61367ceaaaeef1d779da848448416699c3a
+  metadata.gz: cdb06e3dbfb08cf5f35c8c57c0a3f157dcfb3dfdecabc242bb717e98d5faac67
+  data.tar.gz: 4fcbdb696df2b5b6a2f123c3611370206e75d8a5d60337c10d4586e8c2b8a532
 SHA512:
-  metadata.gz: 345c10b1f3327de41e00317c3ded1aef5e0c4fcc39befbfef05c3212ea75d0b649f7c56bb8d56574cbad9ed3edc1a6a26c86988cc4e4815dd7d34568aa9735f2
-  data.tar.gz: 7dbe2387e69626c7f58e2b8f3eff9f72134b38d48df083ffa3cebe64211382469923995aed748ef2da5350fc0c7540c32d369fec0b5c2daf6025a2610e132ab7
+  metadata.gz: f6400aa89ca7995314ac5c13ce38e7e30bc01be90bf55a2391584cc143d8b93aef03da5651bd5cc6a34e1ab4da0c7b468326695a94c09a39713d808da292cc60
+  data.tar.gz: 163037c4a8787f598a774dad13ed44d075b9d77b2b9308832a04794c229945161712e75bbe961a7bb1ddde37a20184f93647ba8e7838b777416285bbc247fdca

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

@@ -2,7 +2,7 @@
 
 [![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) crate, implemented with [Magnus](https://github.com/matsadler/magnus).
+Ruby bindings for the Rust [`cel`](https://crates.io/crates/cel) 0.15 crate, implemented with [Magnus](https://github.com/matsadler/magnus).
 
 ## Goals
 
@@ -32,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`)
@@ -114,9 +173,14 @@ CI also runs the test suite on Ruby 3.3, Ruby 3.4, and Ruby 4.0 through Buildkit
 
 ## Releasing
 
-Releases publish **precompiled native gems** for five platforms
-(`x86_64-linux`, `aarch64-linux`, `x86_64-linux-musl`, `arm64-darwin`,
-`x86_64-darwin`) to [rubygems.org](https://rubygems.org/gems/cel-rs-rb).
+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
 
@@ -125,20 +189,34 @@ file and tag the same version:
 
 ```bash
 # 1. Bump CEL::VERSION in lib/cel/version.rb (e.g. "0.2.0")
-# 2. Commit the bump
-git commit -am "Release v0.2.0"
+# 2. Refresh Gemfile.lock's local gem version
+bundle install
 
-# 3. Tag that commit (the v-prefix triggers the release pipeline)
+# 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/lib/cel/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CEL
-  VERSION = "0.2.0.pre.1"
+  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))

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cel-rs-rb
 version: !ruby/object:Gem::Version
-  version: 0.2.0.pre.1
+  version: 0.3.1
 platform: aarch64-linux
 authors:
 - CEL Ruby Contributors
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-07-01 00:00:00.000000000 Z
+date: 2026-11-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -86,6 +86,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - LICENSE
 - README.md
 - lib/cel.rb