cel-rs-rb 0.2.0.pre.1-arm64-darwin

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9a2d4da435e2ac893a9db67158606ceb7f4acf2189790a751f60d9db6d2be98d
+  data.tar.gz: 5749f4974e50fcf2531823d08c597e24f30440526b19cdf501c92691c6b97ec9
+SHA512:
+  metadata.gz: b1e25762542665f8c0700a17bae746de08d722f91c2f7e9d38b50e5698223501e133cea1d977581ad06f690cb28ec9e39607464c85582e72ccadd1a2ebc9fcf4
+  data.tar.gz: 74be8bd05c12bbf1e8eb0ab43f116ec03a1f4ce06e019e59cf7b0ae53663064926671ff3193a3da667b46d1ec8265567ac6f8fa8f9380ef5d314be3b90ad3a40

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,144 @@
+# cel-rs-rb
+
+[![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).
+
+## 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
+
+- 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
+
+### 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.
+
+## 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).
+
+### 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. Commit the bump
+git commit -am "Release v0.2.0"
+
+# 3. 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
+```
+
+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
+
+- 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

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module CEL
+  VERSION = "0.2.0.pre.1"
+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,172 @@
+# 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 "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) 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(results).to eq(expected)
+    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,127 @@
+--- !ruby/object:Gem::Specification
+name: cel-rs-rb
+version: !ruby/object:Gem::Version
+  version: 0.2.0.pre.1
+platform: arm64-darwin
+authors:
+- CEL Ruby Contributors
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2026-07-01 00:00:00.000000000 Z
+dependencies:
+- !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: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/cel.rb
+- lib/cel/3.3/cel.bundle
+- lib/cel/3.4/cel.bundle
+- lib/cel/4.0/cel.bundle
+- lib/cel/version.rb
+- spec/cel_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/buildkite/cel-rs-rb
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/buildkite/cel-rs-rb
+  source_code_uri: https://github.com/buildkite/cel-rs-rb
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: 4.1.dev
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.23
+signing_key: 
+specification_version: 4
+summary: Ruby bindings for the Rust CEL crate
+test_files: []