Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

15 files changed, 1619 insertions, 0 deletions

diff --git a/third_party/rust/uniffi_bindgen/src/bindings/ruby/gen_ruby/mod.rs b/third_party/rust/uniffi_bindgen/src/bindings/ruby/gen_ruby/mod.rs
new file mode 100644
index 0000000000..9d0fc55bdc
--- /dev/null
+++ b/third_party/rust/uniffi_bindgen/src/bindings/ruby/gen_ruby/mod.rs
@@ -0,0 +1,273 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use anyhow::Result;
+use askama::Template;
+use heck::{ToShoutySnakeCase, ToSnakeCase, ToUpperCamelCase};
+use serde::{Deserialize, Serialize};
+use std::borrow::Borrow;
+
+use crate::interface::*;
+use crate::MergeWith;
+
+const RESERVED_WORDS: &[&str] = &[
+    "alias", "and", "BEGIN", "begin", "break", "case", "class", "def", "defined?", "do", "else",
+    "elsif", "END", "end", "ensure", "false", "for", "if", "module", "next", "nil", "not", "or",
+    "redo", "rescue", "retry", "return", "self", "super", "then", "true", "undef", "unless",
+    "until", "when", "while", "yield", "__FILE__", "__LINE__",
+];
+
+fn is_reserved_word(word: &str) -> bool {
+    RESERVED_WORDS.contains(&word)
+}
+
+// Some config options for it the caller wants to customize the generated ruby.
+// Note that this can only be used to control details of the ruby *that do not affect the underlying component*,
+// since the details of the underlying component are entirely determined by the `ComponentInterface`.
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct Config {
+    cdylib_name: Option<String>,
+    cdylib_path: Option<String>,
+}
+
+impl Config {
+    pub fn cdylib_name(&self) -> String {
+        self.cdylib_name
+            .clone()
+            .unwrap_or_else(|| "uniffi".to_string())
+    }
+
+    pub fn custom_cdylib_path(&self) -> bool {
+        self.cdylib_path.is_some()
+    }
+
+    pub fn cdylib_path(&self) -> String {
+        self.cdylib_path.clone().unwrap_or_default()
+    }
+}
+
+impl From<&ComponentInterface> for Config {
+    fn from(ci: &ComponentInterface) -> Self {
+        Config {
+            cdylib_name: Some(format!("uniffi_{}", ci.namespace())),
+            cdylib_path: None,
+        }
+    }
+}
+
+impl MergeWith for Config {
+    fn merge_with(&self, other: &Self) -> Self {
+        Config {
+            cdylib_name: self.cdylib_name.merge_with(&other.cdylib_name),
+            cdylib_path: self.cdylib_path.merge_with(&other.cdylib_path),
+        }
+    }
+}
+
+#[derive(Template)]
+#[template(syntax = "rb", escape = "none", path = "wrapper.rb")]
+pub struct RubyWrapper<'a> {
+    config: Config,
+    ci: &'a ComponentInterface,
+}
+impl<'a> RubyWrapper<'a> {
+    pub fn new(config: Config, ci: &'a ComponentInterface) -> Self {
+        Self { config, ci }
+    }
+}
+
+mod filters {
+    use super::*;
+
+    pub fn type_ffi(type_: &FfiType) -> Result<String, askama::Error> {
+        Ok(match type_ {
+            FfiType::Int8 => ":int8".to_string(),
+            FfiType::UInt8 => ":uint8".to_string(),
+            FfiType::Int16 => ":int16".to_string(),
+            FfiType::UInt16 => ":uint16".to_string(),
+            FfiType::Int32 => ":int32".to_string(),
+            FfiType::UInt32 => ":uint32".to_string(),
+            FfiType::Int64 => ":int64".to_string(),
+            FfiType::UInt64 => ":uint64".to_string(),
+            FfiType::Float32 => ":float".to_string(),
+            FfiType::Float64 => ":double".to_string(),
+            FfiType::RustArcPtr(_) => ":pointer".to_string(),
+            FfiType::RustBuffer(_) => "RustBuffer.by_value".to_string(),
+            FfiType::ForeignBytes => "ForeignBytes".to_string(),
+            FfiType::ForeignCallback => unimplemented!("Callback interfaces are not implemented"),
+        })
+    }
+
+    pub fn literal_rb(literal: &Literal) -> Result<String, askama::Error> {
+        Ok(match literal {
+            Literal::Boolean(v) => {
+                if *v {
+                    "true".into()
+                } else {
+                    "false".into()
+                }
+            }
+            // use the double-quote form to match with the other languages, and quote escapes.
+            Literal::String(s) => format!("\"{s}\""),
+            Literal::Null => "nil".into(),
+            Literal::EmptySequence => "[]".into(),
+            Literal::EmptyMap => "{}".into(),
+            Literal::Enum(v, type_) => match type_ {
+                Type::Enum(name) => format!("{}::{}", class_name_rb(name)?, enum_name_rb(v)?),
+                _ => panic!("Unexpected type in enum literal: {type_:?}"),
+            },
+            // https://docs.ruby-lang.org/en/2.0.0/syntax/literals_rdoc.html
+            Literal::Int(i, radix, _) => match radix {
+                Radix::Octal => format!("0o{i:o}"),
+                Radix::Decimal => format!("{i}"),
+                Radix::Hexadecimal => format!("{i:#x}"),
+            },
+            Literal::UInt(i, radix, _) => match radix {
+                Radix::Octal => format!("0o{i:o}"),
+                Radix::Decimal => format!("{i}"),
+                Radix::Hexadecimal => format!("{i:#x}"),
+            },
+            Literal::Float(string, _type_) => string.clone(),
+        })
+    }
+
+    pub fn class_name_rb(nm: &str) -> Result<String, askama::Error> {
+        Ok(nm.to_string().to_upper_camel_case())
+    }
+
+    pub fn fn_name_rb(nm: &str) -> Result<String, askama::Error> {
+        Ok(nm.to_string().to_snake_case())
+    }
+
+    pub fn var_name_rb(nm: &str) -> Result<String, askama::Error> {
+        let nm = nm.to_string();
+        let prefix = if is_reserved_word(&nm) { "_" } else { "" };
+
+        Ok(format!("{prefix}{}", nm.to_snake_case()))
+    }
+
+    pub fn enum_name_rb(nm: &str) -> Result<String, askama::Error> {
+        Ok(nm.to_string().to_shouty_snake_case())
+    }
+
+    pub fn coerce_rb(nm: &str, type_: &Type) -> Result<String, askama::Error> {
+        Ok(match type_ {
+            Type::Int8
+            | Type::UInt8
+            | Type::Int16
+            | Type::UInt16
+            | Type::Int32
+            | Type::UInt32
+            | Type::Int64
+            | Type::UInt64 => format!("{nm}.to_i"), // TODO: check max/min value
+            Type::Float32 | Type::Float64 => format!("{nm}.to_f"),
+            Type::Boolean => format!("{nm} ? true : false"),
+            Type::Object(_) | Type::Enum(_) | Type::Error(_) | Type::Record(_) => nm.to_string(),
+            Type::String => format!("{nm}.to_s"),
+            Type::Timestamp | Type::Duration => nm.to_string(),
+            Type::CallbackInterface(_) => panic!("No support for coercing callback interfaces yet"),
+            Type::Optional(t) => format!("({nm} ? {} : nil)", coerce_rb(nm, t)?),
+            Type::Sequence(t) => {
+                let coerce_code = coerce_rb("v", t)?;
+                if coerce_code == "v" {
+                    nm.to_string()
+                } else {
+                    format!("{nm}.map {{ |v| {coerce_code} }}")
+                }
+            }
+            Type::Map(_k, t) => {
+                let k_coerce_code = coerce_rb("k", &Type::String)?;
+                let v_coerce_code = coerce_rb("v", t)?;
+
+                if k_coerce_code == "k" && v_coerce_code == "v" {
+                    nm.to_string()
+                } else {
+                    format!(
+                        "{}.each.with_object({{}}) {{ |(k, v), res| res[{}] = {} }}",
+                        nm, k_coerce_code, v_coerce_code,
+                    )
+                }
+            }
+            Type::External { .. } => panic!("No support for external types, yet"),
+            Type::Custom { .. } => panic!("No support for custom types, yet"),
+            Type::Unresolved { name } => {
+                unreachable!("Type `{name}` must be resolved before calling coerce_rb")
+            }
+        })
+    }
+
+    pub fn lower_rb(nm: &str, type_: &Type) -> Result<String, askama::Error> {
+        Ok(match type_ {
+            Type::Int8
+            | Type::UInt8
+            | Type::Int16
+            | Type::UInt16
+            | Type::Int32
+            | Type::UInt32
+            | Type::Int64
+            | Type::UInt64
+            | Type::Float32
+            | Type::Float64 => nm.to_string(),
+            Type::Boolean => format!("({nm} ? 1 : 0)"),
+            Type::String => format!("RustBuffer.allocFromString({nm})"),
+            Type::Object(name) => format!("({}._uniffi_lower {nm})", class_name_rb(name)?),
+            Type::CallbackInterface(_) => panic!("No support for lowering callback interfaces yet"),
+            Type::Error(_) => panic!("No support for lowering errors, yet"),
+            Type::Enum(_)
+            | Type::Record(_)
+            | Type::Optional(_)
+            | Type::Sequence(_)
+            | Type::Timestamp
+            | Type::Duration
+            | Type::Map(_, _) => format!(
+                "RustBuffer.alloc_from_{}({})",
+                class_name_rb(&type_.canonical_name())?,
+                nm
+            ),
+            Type::External { .. } => panic!("No support for lowering external types, yet"),
+            Type::Custom { .. } => panic!("No support for lowering custom types, yet"),
+            Type::Unresolved { name } => {
+                unreachable!("Type `{name}` must be resolved before calling lower_rb")
+            }
+        })
+    }
+
+    pub fn lift_rb(nm: &str, type_: &Type) -> Result<String, askama::Error> {
+        Ok(match type_ {
+            Type::Int8
+            | Type::UInt8
+            | Type::Int16
+            | Type::UInt16
+            | Type::Int32
+            | Type::UInt32
+            | Type::Int64
+            | Type::UInt64 => format!("{nm}.to_i"),
+            Type::Float32 | Type::Float64 => format!("{nm}.to_f"),
+            Type::Boolean => format!("1 == {nm}"),
+            Type::String => format!("{nm}.consumeIntoString"),
+            Type::Object(name) => format!("{}._uniffi_allocate({nm})", class_name_rb(name)?),
+            Type::CallbackInterface(_) => panic!("No support for lifting callback interfaces, yet"),
+            Type::Error(_) => panic!("No support for lowering errors, yet"),
+            Type::Enum(_)
+            | Type::Record(_)
+            | Type::Optional(_)
+            | Type::Sequence(_)
+            | Type::Timestamp
+            | Type::Duration
+            | Type::Map(_, _) => format!(
+                "{}.consumeInto{}",
+                nm,
+                class_name_rb(&type_.canonical_name())?
+            ),
+            Type::External { .. } => panic!("No support for lifting external types, yet"),
+            Type::Custom { .. } => panic!("No support for lifting custom types, yet"),
+            Type::Unresolved { name } => {
+                unreachable!("Type `{name}` must be resolved before calling lift_rb")
+            }
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/third_party/rust/uniffi_bindgen/src/bindings/ruby/gen_ruby/tests.rs b/third_party/rust/uniffi_bindgen/src/bindings/ruby/gen_ruby/tests.rs
new file mode 100644
index 0000000000..9ae5d1816f
--- /dev/null
+++ b/third_party/rust/uniffi_bindgen/src/bindings/ruby/gen_ruby/tests.rs
@@ -0,0 +1,47 @@
+use super::{is_reserved_word, Config};
+
+#[test]
+fn when_reserved_word() {
+    assert!(is_reserved_word("end"));
+}
+
+#[test]
+fn when_not_reserved_word() {
+    assert!(!is_reserved_word("ruby"));
+}
+
+#[test]
+fn cdylib_name() {
+    let config = Config {
+        cdylib_name: None,
+        cdylib_path: None,
+    };
+
+    assert_eq!("uniffi", config.cdylib_name());
+
+    let config = Config {
+        cdylib_name: Some("todolist".to_string()),
+        cdylib_path: None,
+    };
+
+    assert_eq!("todolist", config.cdylib_name());
+}
+
+#[test]
+fn cdylib_path() {
+    let config = Config {
+        cdylib_name: None,
+        cdylib_path: None,
+    };
+
+    assert_eq!("", config.cdylib_path());
+    assert!(!config.custom_cdylib_path());
+
+    let config = Config {
+        cdylib_name: None,
+        cdylib_path: Some("/foo/bar".to_string()),
+    };
+
+    assert_eq!("/foo/bar", config.cdylib_path());
+    assert!(config.custom_cdylib_path());
+}
diff --git a/third_party/rust/uniffi_bindgen/src/bindings/ruby/mod.rs b/third_party/rust/uniffi_bindgen/src/bindings/ruby/mod.rs
new file mode 100644
index 0000000000..e0d789f42f
--- /dev/null
+++ b/third_party/rust/uniffi_bindgen/src/bindings/ruby/mod.rs
@@ -0,0 +1,50 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use std::{io::Write, process::Command};
+
+use anyhow::{Context, Result};
+use camino::Utf8Path;
+use fs_err::File;
+
+pub mod gen_ruby;
+mod test;
+pub use gen_ruby::{Config, RubyWrapper};
+pub use test::run_test;
+
+use super::super::interface::ComponentInterface;
+
+// Generate ruby bindings for the given ComponentInterface, in the given output directory.
+
+pub fn write_bindings(
+    config: &Config,
+    ci: &ComponentInterface,
+    out_dir: &Utf8Path,
+    try_format_code: bool,
+) -> Result<()> {
+    let rb_file = out_dir.join(format!("{}.rb", ci.namespace()));
+    let mut f = File::create(&rb_file)?;
+    write!(f, "{}", generate_ruby_bindings(config, ci)?)?;
+
+    if try_format_code {
+        if let Err(e) = Command::new("rubocop").arg("-A").arg(&rb_file).output() {
+            println!(
+                "Warning: Unable to auto-format {} using rubocop: {:?}",
+                rb_file.file_name().unwrap(),
+                e
+            )
+        }
+    }
+
+    Ok(())
+}
+
+// Generate ruby bindings for the given ComponentInterface, as a string.
+
+pub fn generate_ruby_bindings(config: &Config, ci: &ComponentInterface) -> Result<String> {
+    use askama::Template;
+    RubyWrapper::new(config.clone(), ci)
+        .render()
+        .context("failed to render ruby bindings")
+}
diff --git a/third_party/rust/uniffi_bindgen/src/bindings/ruby/templates/EnumTemplate.rb b/third_party/rust/uniffi_bindgen/src/bindings/ruby/templates/EnumTemplate.rb
new file mode 100644
index 0000000000..23b701f6a7
--- /dev/null
+++ b/third_party/rust/uniffi_bindgen/src/bindings/ruby/templates/EnumTemplate.rb
@@ -0,0 +1,59 @@
+{% if e.is_flat() %}
+
+class {{ e.name()|class_name_rb }}
+  {% for variant in e.variants() -%}
+  {{ variant.name()|enum_name_rb }} = {{ loop.index }}
+  {% endfor %}
+end
+
+{% else %}
+
+class {{ e.name()|class_name_rb }}
+  def initialize
+    raise RuntimeError, '{{ e.name()|class_name_rb }} cannot be instantiated directly'
+  end
+
+  # Each enum variant is a nested class of the enum itself.
+  {% for variant in e.variants() -%}
+  class {{ variant.name()|enum_name_rb }}
+    {% if variant.has_fields() %}
+    attr_reader {% for field in variant.fields() %}:{{ field.name()|var_name_rb }}{% if loop.last %}{% else %}, {% endif %}{%- endfor %}
+    {% endif %}
+    def initialize({% for field in variant.fields() %}{{ field.name()|var_name_rb }}{% if loop.last %}{% else %}, {% endif %}{% endfor %})
+      {% if variant.has_fields() %}
+      {%- for field in variant.fields() %}
+      @{{ field.name()|var_name_rb }} = {{ field.name()|var_name_rb }}
+      {%- endfor %}
+      {% else %}
+      {% endif %}
+    end
+
+    def to_s
+      "{{ e.name()|class_name_rb }}::{{ variant.name()|enum_name_rb }}({% for field in variant.fields() %}{{ field.name() }}=#{@{{ field.name() }}}{% if loop.last %}{% else %}, {% endif %}{% endfor %})"
+    end
+
+    def ==(other)
+      if !other.{{ variant.name()|var_name_rb }}?
+        return false
+      end
+      {%- for field in variant.fields() %}
+      if @{{ field.name()|var_name_rb }} != other.{{ field.name()|var_name_rb }}
+        return false
+      end
+      {%- endfor %}
+
+      true
+    end
+
+    # For each variant, we have an `NAME?` method for easily checking
+    # whether an instance is that variant.
+    {% for variant in e.variants() %}
+    def {{ variant.name()|var_name_rb }}?
+      instance_of? {{ e.name()|class_name_rb }}::{{ variant.name()|enum_name_rb }}
+    end
+    {% endfor %}
+  end
+  {% endfor %}
+end
+
+{% endif %}
diff --git a/third_party/rust/uniffi_bindgen/src/bindings/ruby/templates/ErrorTemplate.rb b/third_party/rust/uniffi_bindgen/src/bindings/ruby/templates/ErrorTemplate.rb
new file mode 100644
index 0000000000..3a64e9ffeb
--- /dev/null
+++ b/third_party/rust/uniffi_bindgen/src/bindings/ruby/templates/ErrorTemplate.rb
@@ -0,0 +1,117 @@
+class RustCallStatus < FFI::Struct
+  layout :code,    :int8,
+         :error_buf, RustBuffer
+
+  def code
+    self[:code]
+  end
+
+  def error_buf
+    self[:error_buf]
+  end
+
+  def to_s
+    "RustCallStatus(code=#{self[:code]})"
+  end
+end
+
+# These match the values from the uniffi::rustcalls module
+CALL_SUCCESS = 0
+CALL_ERROR = 1
+CALL_PANIC = 2
+{%- for e in ci.error_definitions() %}
+{% if e.is_flat() %}
+class {{ e.name()|class_name_rb }}
+    {%- for variant in e.variants() %}
+    {{ variant.name()|class_name_rb }} = Class.new StandardError
+    {%- endfor %}
+{% else %}
+module {{ e.name()|class_name_rb }}
+  {%- for variant in e.variants() %}
+  class {{ variant.name()|class_name_rb }} < StandardError
+    def initialize({% for field in variant.fields() %}{{ field.name()|var_name_rb }}{% if !loop.last %}, {% endif %}{% endfor %})
+        {%- for field in variant.fields() %}
+        @{{ field.name()|var_name_rb }} = {{ field.name()|var_name_rb }}
+        {%- endfor %}
+        super()
+      end
+    {%- if variant.has_fields() %}
+
+    attr_reader {% for field in variant.fields() %}:{{ field.name()|var_name_rb }}{% if !loop.last %}, {% endif %}{% endfor %}
+    {% endif %}
+
+    def to_s
+     "#{self.class.name}({% for field in variant.fields() %}{{ field.name()|var_name_rb }}=#{@{{ field.name()|var_name_rb }}.inspect}{% if !loop.last %}, {% endif %}{% endfor %})"
+    end
+  end
+  {%- endfor %}
+{% endif %}
+end
+{%- endfor %}
+
+# Map error modules to the RustBuffer method name that reads them
+ERROR_MODULE_TO_READER_METHOD = {
+{%- for e in ci.error_definitions() %}
+{%- let typ=ci.get_type(e.name()).unwrap() %}
+{%- let canonical_type_name = typ.canonical_name().borrow()|class_name_rb %}
+  {{ e.name()|class_name_rb }} => :read{{ canonical_type_name }},
+{%- endfor %}
+}
+
+private_constant :ERROR_MODULE_TO_READER_METHOD, :CALL_SUCCESS, :CALL_ERROR, :CALL_PANIC,
+                 :RustCallStatus
+
+def self.consume_buffer_into_error(error_module, rust_buffer)
+  rust_buffer.consumeWithStream do |stream|
+    reader_method = ERROR_MODULE_TO_READER_METHOD[error_module]
+    return stream.send(reader_method)
+  end
+end
+
+class InternalError < StandardError
+end
+
+def self.rust_call(fn_name, *args)
+  # Call a rust function
+  rust_call_with_error(nil, fn_name, *args)
+end
+
+def self.rust_call_with_error(error_module, fn_name, *args)
+  # Call a rust function and handle errors
+  #
+  # Use this when the rust function returns a Result<>.  error_module must be the error_module that corresponds to that Result.
+
+
+  # Note: RustCallStatus.new zeroes out the struct, which is exactly what we
+  # want to pass to Rust (code=0, error_buf=RustBuffer(len=0, capacity=0,
+  # data=NULL))
+  status = RustCallStatus.new
+  args << status
+
+  result = UniFFILib.public_send(fn_name, *args)
+
+  case status.code
+  when CALL_SUCCESS
+    result
+  when CALL_ERROR
+    if error_module.nil?
+      status.error_buf.free
+      raise InternalError, "CALL_ERROR with no error_module set"
+    else
+      raise consume_buffer_into_error(error_module, status.error_buf)
+    end
+  when CALL_PANIC
+    # When the rust code sees a panic, it tries to construct a RustBuffer
+    # with the message.  But if that code panics, then it just sends back
+    # an empty buffer.
+    if status.error_buf.len > 0
+      raise InternalError, status.error_buf.consumeIntoString()
+    else
+      raise InternalError, "Rust panic"
+    end
+  else
+    raise InternalError, "Unknown call status: #{status.code}"
+  end
+end
+
+private_class_method :consume_buffer_into_error
diff --git a/third_party/rust/uniffi_bindgen/src/bindings/ruby/templates/NamespaceLibraryTemplate.rb b/third_party/rust/uniffi_bindgen/src/bindings/ruby/templates/NamespaceLibraryTemplate.rb
new file mode 100644
index 0000000000..858b42bf91
--- /dev/null
+++ b/third_party/rust/uniffi_bindgen/src/bindings/ruby/templates/NamespaceLibraryTemplate.rb
@@ -0,0 +1,17 @@
+# This is how we find and load the dynamic library provided by the component.
+# For now we just look it up by name.
+module UniFFILib
+  extend FFI::Library
+
+  {% if config.custom_cdylib_path() %}
+  ffi_lib {{ config.cdylib_path() }}
+  {% else %}
+  ffi_lib '{{ config.cdylib_name() }}'
+  {% endif %}
+
+  {% for func in ci.iter_ffi_function_definitions() -%}
+  attach_function :{{ func.name() }},
+    {%- call rb::arg_list_ffi_decl(func) %},
+    {% match func.return_type() %}{% when Some with (type_) %}{{ type_|type_ffi }}{% when None %}:void{% endmatch %}
+  {% endfor %}
+end
diff --git a/third_party/rust/uniffi_bindgen/src/bindings/ruby/templates/ObjectTemplate.rb b/third_party/rust/uniffi_bindgen/src/bindings/ruby/templates/ObjectTemplate.rb
new file mode 100644
index 0000000000..677c5c729b
--- /dev/null
+++ b/third_party/rust/uniffi_bindgen/src/bindings/ruby/templates/ObjectTemplate.rb
@@ -0,0 +1,73 @@
+class {{ obj.name()|class_name_rb }}
+
+  # A private helper for initializing instances of the class from a raw pointer,
+  # bypassing any initialization logic and ensuring they are GC'd properly.
+  def self._uniffi_allocate(pointer)
+    pointer.autorelease = false
+    inst = allocate
+    inst.instance_variable_set :@pointer, pointer
+    ObjectSpace.define_finalizer(inst, _uniffi_define_finalizer_by_pointer(pointer, inst.object_id))
+    return inst
+  end
+
+  # A private helper for registering an object finalizer.
+  # N.B. it's important that this does not capture a reference
+  # to the actual instance, only its underlying pointer.
+  def self._uniffi_define_finalizer_by_pointer(pointer, object_id)
+    Proc.new do |_id|
+      {{ ci.namespace()|class_name_rb }}.rust_call(
+        :{{ obj.ffi_object_free().name() }},
+        pointer
+      )
+    end
+  end
+
+  # A private helper for lowering instances into a raw pointer.
+  # This does an explicit typecheck, because accidentally lowering a different type of
+  # object in a place where this type is expected, could lead to memory unsafety.
+  def self._uniffi_lower(inst)
+    if not inst.is_a? self
+      raise TypeError.new "Expected a {{ obj.name()|class_name_rb }} instance, got #{inst}"
+    end
+    return inst.instance_variable_get :@pointer
+  end
+
+  {%- match obj.primary_constructor() %}
+  {%- when Some with (cons) %}
+  def initialize({% call rb::arg_list_decl(cons) -%})
+    {%- call rb::coerce_args_extra_indent(cons) %}
+    pointer = {% call rb::to_ffi_call(cons) %}
+    @pointer = pointer
+    ObjectSpace.define_finalizer(self, self.class._uniffi_define_finalizer_by_pointer(pointer, self.object_id))
+  end
+  {%- when None %}
+  {%- endmatch %}
+
+  {% for cons in obj.alternate_constructors() -%}
+  def self.{{ cons.name()|fn_name_rb }}({% call rb::arg_list_decl(cons) %})
+    {%- call rb::coerce_args_extra_indent(cons) %}
+    # Call the (fallible) function before creating any half-baked object instances.
+    # Lightly yucky way to bypass the usual "initialize" logic
+    # and just create a new instance with the required pointer.
+    return _uniffi_allocate({% call rb::to_ffi_call(cons) %})
+  end
+  {% endfor %}
+
+  {% for meth in obj.methods() -%}
+  {%- match meth.return_type() -%}
+
+  {%- when Some with (return_type) -%}
+  def {{ meth.name()|fn_name_rb }}({% call rb::arg_list_decl(meth) %})
+    {%- call rb::coerce_args_extra_indent(meth) %}
+    result = {% call rb::to_ffi_call_with_prefix("@pointer", meth) %}
+    return {{ "result"|lift_rb(return_type) }}
+  end
+
+  {%- when None -%}
+  def {{ meth.name()|fn_name_rb }}({% call rb::arg_list_decl(meth) %})
+      {%- call rb::coerce_args_extra_indent(meth) %}
+      {% call rb::to_ffi_call_with_prefix("@pointer", meth) %}
+  end
+  {% endmatch %}
+  {% endfor %}
+end
diff --git a/third_party/rust/uniffi_bindgen/src/bindings/ruby/templates/RecordTemplate.rb b/third_party/rust/uniffi_bindgen/src/bindings/ruby/templates/RecordTemplate.rb
new file mode 100644
index 0000000000..c940b31060
--- /dev/null
+++ b/third_party/rust/uniffi_bindgen/src/bindings/ruby/templates/RecordTemplate.rb
@@ -0,0 +1,20 @@
+# Record type {{ rec.name() }}
+class {{ rec.name()|class_name_rb }}
+  attr_reader {% for field in rec.fields() %}:{{ field.name()|var_name_rb }}{% if loop.last %}{% else %}, {% endif %}{%- endfor %}
+
+  def initialize({% for field in rec.fields() %}{{ field.name()|var_name_rb }}{% if loop.last %}{% else %}, {% endif %}{% endfor %})
+    {%- for field in rec.fields() %}
+    @{{ field.name()|var_name_rb }} = {{ field.name()|var_name_rb }}
+    {%- endfor %}
+  end
+
+  def ==(other)
+    {%- for field in rec.fields() %}
+    if @{{ field.name()|var_name_rb }} != other.{{ field.name()|var_name_rb }}
+      return false
+    end
+    {%- endfor %}
+
+    true
+  end
+end
diff --git a/third_party/rust/uniffi_bindgen/src/bindings/ruby/templates/RustBufferBuilder.rb b/third_party/rust/uniffi_bindgen/src/bindings/ruby/templates/RustBufferBuilder.rb
new file mode 100644
index 0000000000..e4b3910b6c
--- /dev/null
+++ b/third_party/rust/uniffi_bindgen/src/bindings/ruby/templates/RustBufferBuilder.rb
@@ -0,0 +1,246 @@
+
+# Helper for structured writing of values into a RustBuffer.
+class RustBufferBuilder
+  def initialize
+    @rust_buf = RustBuffer.alloc 16
+    @rust_buf.len = 0
+  end
+
+  def finalize
+    rbuf = @rust_buf
+
+    @rust_buf = nil
+
+    rbuf
+  end
+
+  def discard
+    return if @rust_buf.nil?
+
+    rbuf = finalize
+    rbuf.free
+  end
+
+  def write(value)
+    reserve(value.bytes.size) do
+      @rust_buf.data.put_array_of_char @rust_buf.len, value.bytes
+    end
+  end
+
+  {% for typ in ci.iter_types() -%}
+  {%- let canonical_type_name = typ.canonical_name().borrow()|class_name_rb -%}
+  {%- match typ -%}
+
+  {% when Type::Int8 -%}
+
+  def write_I8(v)
+    pack_into(1, 'c', v)
+  end
+
+  {% when Type::UInt8 -%}
+
+  def write_U8(v)
+    pack_into(1, 'c', v)
+  end
+
+  {% when Type::Int16 -%}
+
+  def write_I16(v)
+    pack_into(2, 's>', v)
+  end
+
+  {% when Type::UInt16 -%}
+
+  def write_U16(v)
+    pack_into(2, 'S>', v)
+  end
+
+  {% when Type::Int32 -%}
+
+  def write_I32(v)
+    pack_into(4, 'l>', v)
+  end
+
+  {% when Type::UInt32 -%}
+
+  def write_U32(v)
+    pack_into(4, 'L>', v)
+  end
+
+  {% when Type::Int64 -%}
+
+  def write_I64(v)
+    pack_into(8, 'q>', v)
+  end
+
+  {% when Type::UInt64 -%}
+
+  def write_U64(v)
+    pack_into(8, 'Q>', v)
+  end
+
+  {% when Type::Float32 -%}
+
+  def write_F32(v)
+    pack_into(4, 'g', v)
+  end
+
+  {% when Type::Float64 -%}
+
+  def write_F64(v)
+    pack_into(8, 'G', v)
+  end
+
+  {% when Type::Boolean -%}
+
+  def write_Bool(v)
+    pack_into(1, 'c', v ? 1 : 0)
+  end
+
+  {% when Type::String -%}
+
+  def write_String(v)
+    v = v.to_s
+    pack_into 4, 'l>', v.bytes.size
+    write v
+  end
+
+  {% when Type::Timestamp -%}
+  # The Timestamp type.
+  ONE_SECOND_IN_NANOSECONDS = 10**9
+
+  def write_{{ canonical_type_name }}(v)
+    seconds = v.tv_sec
+    nanoseconds = v.tv_nsec
+
+    # UniFFi conventions assume that nanoseconds part has to represent nanoseconds portion of
+    # duration between epoch and the timestamp moment. Ruby `Time#tv_nsec` returns the number of
+    # nanoseconds for the subsecond part, which is sort of opposite to "duration" meaning.
+    # Hence we need to convert value returned by `Time#tv_nsec` back and forth with the following
+    # logic:
+    if seconds < 0 && nanoseconds != 0
+      # In order to get duration nsec we shift by 1 second:
+      nanoseconds = ONE_SECOND_IN_NANOSECONDS - nanoseconds
+
+      # Then we compensate 1 second shift:
+      seconds += 1
+    end
+
+    pack_into 8, 'q>', seconds
+    pack_into 4, 'L>', nanoseconds
+  end
+
+  {% when Type::Duration -%}
+  # The Duration type.
+
+  def write_{{ canonical_type_name }}(v)
+    seconds = v.tv_sec
+    nanoseconds = v.tv_nsec
+
+    raise ArgumentError, 'Invalid duration, must be non-negative' if seconds < 0
+
+    pack_into 8, 'Q>', seconds
+    pack_into 4, 'L>', nanoseconds
+  end
+
+  {% when Type::Object with (object_name) -%}
+  # The Object type {{ object_name }}.
+
+  def write_{{ canonical_type_name }}(obj)
+    pointer = {{ object_name|class_name_rb}}._uniffi_lower obj
+    pack_into(8, 'Q>', pointer.address)
+  end
+
+  {% when Type::Enum with (enum_name) -%}
+  {%- let e = ci.get_enum_definition(enum_name).unwrap() -%}
+  # The Enum type {{ enum_name }}.
+
+  def write_{{ canonical_type_name }}(v)
+    {%- if e.is_flat() %}
+    pack_into(4, 'l>', v)
+    {%- else -%}
+    {%- for variant in e.variants() %}
+    if v.{{ variant.name()|var_name_rb }}?
+      pack_into(4, 'l>', {{ loop.index }})
+      {%- for field in variant.fields() %}
+      self.write_{{ field.type_().canonical_name().borrow()|class_name_rb }}(v.{{ field.name() }})
+      {%- endfor %}
+    end
+    {%- endfor %}
+    {%- endif %}
+ end
+
+  {% when Type::Record with (record_name) -%}
+  {%- let rec = ci.get_record_definition(record_name).unwrap() -%}
+  # The Record type {{ record_name }}.
+
+  def write_{{ canonical_type_name }}(v)
+    {%- for field in rec.fields() %}
+    self.write_{{ field.type_().canonical_name().borrow()|class_name_rb }}(v.{{ field.name()|var_name_rb }})
+    {%- endfor %}
+  end
+
+  {% when Type::Optional with (inner_type) -%}
+  # The Optional<T> type for {{ inner_type.canonical_name() }}.
+
+  def write_{{ canonical_type_name }}(v)
+    if v.nil?
+      pack_into(1, 'c', 0)
+    else
+      pack_into(1, 'c', 1)
+      self.write_{{ inner_type.canonical_name().borrow()|class_name_rb }}(v)
+    end
+  end
+
+  {% when Type::Sequence with (inner_type) -%}
+  # The Sequence<T> type for {{ inner_type.canonical_name() }}.
+
+  def write_{{ canonical_type_name }}(items)
+    pack_into(4, 'l>', items.size)
+
+    items.each do |item|
+      self.write_{{ inner_type.canonical_name().borrow()|class_name_rb }}(item)
+    end
+  end
+
+  {% when Type::Map with (k, inner_type) -%}
+  # The Map<T> type for {{ inner_type.canonical_name() }}.
+
+  def write_{{ canonical_type_name }}(items)
+    pack_into(4, 'l>', items.size)
+
+    items.each do |k, v|
+      write_String(k)
+      self.write_{{ inner_type.canonical_name().borrow()|class_name_rb }}(v)
+    end
+  end
+
+  {%- else -%}
+  # This type is not yet supported in the Ruby backend.
+  def write_{{ canonical_type_name }}(v)
+    raise InternalError('RustBufferStream.write() not implemented yet for {{ canonical_type_name }}')
+  end
+
+  {%- endmatch -%}
+  {%- endfor %}
+
+  private
+
+  def reserve(num_bytes)
+    if @rust_buf.len + num_bytes > @rust_buf.capacity
+      @rust_buf = RustBuffer.reserve(@rust_buf, num_bytes)
+    end
+
+    yield
+
+    @rust_buf.len += num_bytes
+  end
+
+  def pack_into(size, format, value)
+    reserve(size) do
+      @rust_buf.data.put_array_of_char @rust_buf.len, [value].pack(format).bytes
+    end
+  end
+end
+
+private_constant :RustBufferBuilder
diff --git a/third_party/rust/uniffi_bindgen/src/bindings/ruby/templates/RustBufferStream.rb b/third_party/rust/uniffi_bindgen/src/bindings/ruby/templates/RustBufferStream.rb
new file mode 100644
index 0000000000..f48fbffad4
--- /dev/null
+++ b/third_party/rust/uniffi_bindgen/src/bindings/ruby/templates/RustBufferStream.rb
@@ -0,0 +1,301 @@
+
+# Helper for structured reading of values from a RustBuffer.
+class RustBufferStream
+
+  def initialize(rbuf)
+    @rbuf = rbuf
+    @offset = 0
+  end
+
+  def remaining
+    @rbuf.len - @offset
+  end
+
+  def read(size)
+    raise InternalError, 'read past end of rust buffer' if @offset + size > @rbuf.len
+
+    data = @rbuf.data.get_bytes @offset, size
+
+    @offset += size
+
+    data
+  end
+
+  {% for typ in ci.iter_types() -%}
+  {%- let canonical_type_name = typ.canonical_name().borrow()|class_name_rb -%}
+  {%- match typ -%}
+
+  {% when Type::Int8 -%}
+
+  def readI8
+    unpack_from 1, 'c'
+  end
+
+  {% when Type::UInt8 -%}
+
+  def readU8
+    unpack_from 1, 'c'
+  end
+
+  {% when Type::Int16 -%}
+
+  def readI16
+    unpack_from 2, 's>'
+  end
+
+  {% when Type::UInt16 -%}
+
+  def readU16
+    unpack_from 2, 'S>'
+  end
+
+  {% when Type::Int32 -%}
+
+  def readI32
+    unpack_from 4, 'l>'
+  end
+
+  {% when Type::UInt32 -%}
+
+  def readU32
+    unpack_from 4, 'L>'
+  end
+
+  {% when Type::Int64 -%}
+
+  def readI64
+    unpack_from 8, 'q>'
+  end
+
+  {% when Type::UInt64 -%}
+
+  def readU64
+    unpack_from 8, 'Q>'
+  end
+
+  {% when Type::Float32 -%}
+
+  def readF32
+    unpack_from 4, 'g'
+  end
+
+  {% when Type::Float64 -%}
+
+  def readF64
+    unpack_from 8, 'G'
+  end
+
+  {% when Type::Boolean -%}
+
+  def readBool
+    v = unpack_from 1, 'c'
+
+    return false if v == 0
+    return true if v == 1
+
+    raise InternalError, 'Unexpected byte for Boolean type'
+  end
+
+  {% when Type::String -%}
+
+  def readString
+    size = unpack_from 4, 'l>'
+
+    raise InternalError, 'Unexpected negative string length' if size.negative?
+
+    read(size).force_encoding(Encoding::UTF_8)
+  end
+
+  {% when Type::Timestamp -%}
+  # The Timestamp type.
+  ONE_SECOND_IN_NANOSECONDS = 10**9
+
+  def read{{ canonical_type_name }}
+    seconds = unpack_from 8, 'q>'
+    nanoseconds = unpack_from 4, 'L>'
+
+    # UniFFi conventions assume that nanoseconds part has to represent nanoseconds portion of
+    # duration between epoch and the timestamp moment. Ruby `Time#tv_nsec` returns the number of
+    # nanoseconds for the subsecond part, which is sort of opposite to "duration" meaning.
+    # Hence we need to convert value returned by `Time#tv_nsec` back and forth with the following
+    # logic:
+    if seconds < 0 && nanoseconds != 0
+      # In order to get duration nsec we shift by 1 second:
+      nanoseconds = ONE_SECOND_IN_NANOSECONDS - nanoseconds
+
+      # Then we compensate 1 second shift:
+      seconds -= 1
+    end
+
+    Time.at(seconds, nanoseconds, :nanosecond, in: '+00:00').utc
+  end
+
+  {% when Type::Duration -%}
+  # The Duration type.
+
+  def read{{ canonical_type_name }}
+    seconds = unpack_from 8, 'q>'
+    nanoseconds = unpack_from 4, 'L>'
+
+    Time.at(seconds, nanoseconds, :nanosecond, in: '+00:00').utc
+  end
+
+  {% when Type::Object with (object_name) -%}
+  # The Object type {{ object_name }}.
+
+  def read{{ canonical_type_name }}
+    pointer = FFI::Pointer.new unpack_from 8, 'Q>'
+    return {{ object_name|class_name_rb }}._uniffi_allocate(pointer)
+  end
+
+  {% when Type::Enum with (enum_name) -%}
+  {%- let e = ci.get_enum_definition(enum_name).unwrap() -%}
+  # The Enum type {{ enum_name }}.
+
+  def read{{ canonical_type_name }}
+    variant = unpack_from 4, 'l>'
+    {% if e.is_flat() -%}
+    {%- for variant in e.variants() %}
+    if variant == {{ loop.index }}
+      return {{ enum_name|class_name_rb }}::{{ variant.name()|enum_name_rb }}
+    end
+    {%- endfor %}
+
+    raise InternalError, 'Unexpected variant tag for {{ canonical_type_name }}'
+    {%- else -%}
+    {%- for variant in e.variants() %}
+    if variant == {{ loop.index }}
+        {%- if variant.has_fields() %}
+        return {{ enum_name|class_name_rb }}::{{ variant.name()|enum_name_rb }}.new(
+            {%- for field in variant.fields() %}
+            self.read{{ field.type_().canonical_name().borrow()|class_name_rb }}(){% if loop.last %}{% else %},{% endif %}
+            {%- endfor %}
+        )
+        {%- else %}
+        return {{ enum_name|class_name_rb }}::{{ variant.name()|enum_name_rb }}.new
+        {% endif %}
+    end
+    {%- endfor %}
+    raise InternalError, 'Unexpected variant tag for {{ canonical_type_name }}'
+    {%- endif %}
+  end
+
+  {% when Type::Error with (error_name) -%}
+  {%- let e = ci.get_error_definition(error_name).unwrap().wrapped_enum() %}
+
+  # The Error type {{ error_name }}
+
+  def read{{ canonical_type_name }}
+    variant = unpack_from 4, 'l>'
+    {% if e.is_flat() -%}
+    {%- for variant in e.variants() %}
+    if variant == {{ loop.index }}
+      return {{ error_name|class_name_rb }}::{{ variant.name()|class_name_rb }}.new(
+        readString()
+      )
+    end
+    {%- endfor %}
+
+    raise InternalError, 'Unexpected variant tag for {{ canonical_type_name }}'
+    {%- else -%}
+    {%- for variant in e.variants() %}
+    if variant == {{ loop.index }}
+        {%- if variant.has_fields() %}
+        return {{ error_name|class_name_rb }}::{{ variant.name()|class_name_rb }}.new(
+            {%- for field in variant.fields() %}
+            read{{ field.type_().canonical_name().borrow()|class_name_rb }}(){% if loop.last %}{% else %},{% endif %}
+            {%- endfor %}
+        )
+        {%- else %}
+        return {{ error_name|class_name_rb }}::{{ variant.name()|class_name_rb }}.new
+        {%- endif %}
+    end
+    {%- endfor %}
+
+    raise InternalError, 'Unexpected variant tag for {{ canonical_type_name }}'
+    {%- endif %}
+  end
+
+  {% when Type::Record with (record_name) -%}
+  {%- let rec = ci.get_record_definition(record_name).unwrap() -%}
+  # The Record type {{ record_name }}.
+
+  def read{{ canonical_type_name }}
+    {{ rec.name()|class_name_rb }}.new(
+      {%- for field in rec.fields() %}
+      read{{ field.type_().canonical_name().borrow()|class_name_rb }}{% if loop.last %}{% else %},{% endif %}
+      {%- endfor %}
+    )
+  end
+
+  {% when Type::Optional with (inner_type) -%}
+  # The Optional<T> type for {{ inner_type.canonical_name() }}.
+
+  def read{{ canonical_type_name }}
+    flag = unpack_from 1, 'c'
+
+    if flag == 0
+      return nil
+    elsif flag == 1
+      return read{{ inner_type.canonical_name().borrow()|class_name_rb }}
+    else
+      raise InternalError, 'Unexpected flag byte for {{ canonical_type_name }}'
+    end
+  end
+
+  {% when Type::Sequence with (inner_type) -%}
+  # The Sequence<T> type for {{ inner_type.canonical_name() }}.
+
+  def read{{ canonical_type_name }}
+    count = unpack_from 4, 'l>'
+
+    raise InternalError, 'Unexpected negative sequence length' if count.negative?
+
+    items = []
+
+    count.times do
+      items.append read{{ inner_type.canonical_name().borrow()|class_name_rb }}
+    end
+
+    items
+  end
+
+  {% when Type::Map with (k, inner_type) -%}
+  # The Map<T> type for {{ inner_type.canonical_name() }}.
+
+  def read{{ canonical_type_name }}
+    count = unpack_from 4, 'l>'
+    raise InternalError, 'Unexpected negative map size' if count.negative?
+
+    items = {}
+    count.times do
+      key = readString
+      items[key] = read{{ inner_type.canonical_name().borrow()|class_name_rb }}
+    end
+
+    items
+  end
+  {%- else -%}
+  # This type is not yet supported in the Ruby backend.
+  def read{{ canonical_type_name }}
+    raise InternalError, 'RustBufferStream.read not implemented yet for {{ canonical_type_name }}'
+  end
+
+  {%- endmatch -%}
+  {%- endfor %}
+
+  def unpack_from(size, format)
+    raise InternalError, 'read past end of rust buffer' if @offset + size > @rbuf.len
+
+    value = @rbuf.data.get_bytes(@offset, size).unpack format
+
+    @offset += size
+
+    # TODO: verify this
+    raise 'more than one element!!!' if value.size > 1
+
+    value[0]
+  end
+end
+
+private_constant :RustBufferStream
diff --git a/third_party/rust/uniffi_bindgen/src/bindings/ruby/templates/RustBufferTemplate.rb b/third_party/rust/uniffi_bindgen/src/bindings/ruby/templates/RustBufferTemplate.rb
new file mode 100644
index 0000000000..deed864572
--- /dev/null
+++ b/third_party/rust/uniffi_bindgen/src/bindings/ruby/templates/RustBufferTemplate.rb
@@ -0,0 +1,218 @@
+class RustBuffer < FFI::Struct
+  layout :capacity, :int32,
+         :len,      :int32,
+         :data,     :pointer
+
+  def self.alloc(size)
+    return {{ ci.namespace()|class_name_rb }}.rust_call(:{{ ci.ffi_rustbuffer_alloc().name() }}, size)
+  end
+
+  def self.reserve(rbuf, additional)
+    return {{ ci.namespace()|class_name_rb }}.rust_call(:{{ ci.ffi_rustbuffer_reserve().name() }}, rbuf, additional)
+  end
+
+  def free
+    {{ ci.namespace()|class_name_rb }}.rust_call(:{{ ci.ffi_rustbuffer_free().name() }}, self)
+  end
+
+  def capacity
+    self[:capacity]
+  end
+
+  def len
+    self[:len]
+  end
+
+  def len=(value)
+    self[:len] = value
+  end
+
+  def data
+    self[:data]
+  end
+
+  def to_s
+    "RustBuffer(capacity=#{capacity}, len=#{len}, data=#{data.read_bytes len})"
+  end
+
+  # The allocated buffer will be automatically freed if an error occurs, ensuring that
+  # we don't accidentally leak it.
+  def self.allocWithBuilder
+    builder = RustBufferBuilder.new
+
+    begin
+      yield builder
+    rescue => e
+      builder.discard
+      raise e
+    end
+  end
+
+  # The RustBuffer will be freed once the context-manager exits, ensuring that we don't
+  # leak it even if an error occurs.
+  def consumeWithStream
+    stream = RustBufferStream.new self
+
+    yield stream
+
+    raise RuntimeError, 'junk data left in buffer after consuming' if stream.remaining != 0
+  ensure
+    free
+  end
+
+  {%- for typ in ci.iter_types() -%}
+  {%- let canonical_type_name = typ.canonical_name() -%}
+  {%- match typ -%}
+
+  {% when Type::String -%}
+  # The primitive String type.
+
+  def self.allocFromString(value)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write value.encode('utf-8')
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoString
+    consumeWithStream do |stream|
+      return stream.read(stream.remaining).force_encoding(Encoding::UTF_8)
+    end
+  end
+
+  {% when Type::Timestamp -%}
+  def self.alloc_from_{{ canonical_type_name }}(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_{{ canonical_type_name }}(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeInto{{ canonical_type_name }}
+    consumeWithStream do |stream|
+      return stream.read{{ canonical_type_name }}
+    end
+  end
+
+  {% when Type::Duration -%}
+  def self.alloc_from_{{ canonical_type_name }}(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_{{ canonical_type_name }}(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeInto{{ canonical_type_name }}
+    consumeWithStream do |stream|
+      return stream.read{{ canonical_type_name }}
+    end
+  end
+
+  {% when Type::Record with (record_name) -%}
+  {%- let rec = ci.get_record_definition(record_name).unwrap() -%}
+  # The Record type {{ record_name }}.
+
+  def self.alloc_from_{{ canonical_type_name }}(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_{{ canonical_type_name }}(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeInto{{ canonical_type_name }}
+    consumeWithStream do |stream|
+      return stream.read{{ canonical_type_name }}
+    end
+  end
+
+  {% when Type::Enum with (enum_name) -%}
+  {%- let e = ci.get_enum_definition(enum_name).unwrap() -%}
+  # The Enum type {{ enum_name }}.
+
+  def self.alloc_from_{{ canonical_type_name }}(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_{{ canonical_type_name }}(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeInto{{ canonical_type_name }}
+    consumeWithStream do |stream|
+      return stream.read{{ canonical_type_name }}
+    end
+  end
+
+  {% when Type::Optional with (inner_type) -%}
+  # The Optional<T> type for {{ inner_type.canonical_name() }}.
+
+  def self.alloc_from_{{ canonical_type_name }}(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_{{ canonical_type_name }}(v)
+      return builder.finalize()
+    end
+  end
+
+  def consumeInto{{ canonical_type_name }}
+    consumeWithStream do |stream|
+      return stream.read{{ canonical_type_name }}
+    end
+  end
+
+  {% when Type::Sequence with (inner_type) -%}
+  # The Sequence<T> type for {{ inner_type.canonical_name() }}.
+
+  def self.alloc_from_{{ canonical_type_name }}(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_{{ canonical_type_name }}(v)
+      return builder.finalize()
+    end
+  end
+
+  def consumeInto{{ canonical_type_name }}
+    consumeWithStream do |stream|
+      return stream.read{{ canonical_type_name }}
+    end
+  end
+
+  {% when Type::Map with (k, inner_type) -%}
+  # The Map<T> type for {{ inner_type.canonical_name() }}.
+
+  def self.alloc_from_{{ canonical_type_name }}(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_{{ canonical_type_name }}(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeInto{{ canonical_type_name }}
+    consumeWithStream do |stream|
+      return stream.read{{ canonical_type_name }}
+    end
+  end
+
+  {%- else -%}
+  {#- No code emitted for types that don't lower into a RustBuffer -#}
+  {%- endmatch -%}
+  {%- endfor %}
+end
+
+module UniFFILib
+  class ForeignBytes < FFI::Struct
+    layout :len,      :int32,
+           :data,     :pointer
+
+    def len
+      self[:len]
+    end
+
+    def data
+      self[:data]
+    end
+
+    def to_s
+      "ForeignBytes(len=#{len}, data=#{data.read_bytes(len)})"
+    end
+  end
+end
+
+private_constant :UniFFILib
diff --git a/third_party/rust/uniffi_bindgen/src/bindings/ruby/templates/TopLevelFunctionTemplate.rb b/third_party/rust/uniffi_bindgen/src/bindings/ruby/templates/TopLevelFunctionTemplate.rb
new file mode 100644
index 0000000000..13214cf31b
--- /dev/null
+++ b/third_party/rust/uniffi_bindgen/src/bindings/ruby/templates/TopLevelFunctionTemplate.rb
@@ -0,0 +1,16 @@
+{%- match func.return_type() -%}
+{%- when Some with (return_type) %}
+
+def self.{{ func.name()|fn_name_rb }}({%- call rb::arg_list_decl(func) -%})
+  {%- call rb::coerce_args(func) %}
+  result = {% call rb::to_ffi_call(func) %}
+  return {{ "result"|lift_rb(return_type) }}
+end
+
+{% when None %}
+
+def self.{{ func.name()|fn_name_rb }}({%- call rb::arg_list_decl(func) -%})
+  {%- call rb::coerce_args(func) %}
+  {% call rb::to_ffi_call(func) %}
+end
+{% endmatch %}
diff --git a/third_party/rust/uniffi_bindgen/src/bindings/ruby/templates/macros.rb b/third_party/rust/uniffi_bindgen/src/bindings/ruby/templates/macros.rb
new file mode 100644
index 0000000000..c2faf63104
--- /dev/null
+++ b/third_party/rust/uniffi_bindgen/src/bindings/ruby/templates/macros.rb
@@ -0,0 +1,73 @@
+{#
+// Template to call into rust. Used in several places.
+// Variable names in `arg_list_decl` should match up with arg lists
+// passed to rust via `_arg_list_ffi_call` (we use  `var_name_rb` in `lower_rb`)
+#}
+
+{%- macro to_ffi_call(func) -%}
+    {%- match func.throws_name() -%}
+    {%- when Some with (e) -%}
+      {{ ci.namespace()|class_name_rb }}.rust_call_with_error({{ e|class_name_rb }},
+    {%- else -%}
+      {{ ci.namespace()|class_name_rb }}.rust_call(
+    {%- endmatch -%}
+    :{{ func.ffi_func().name() }},
+    {%- call _arg_list_ffi_call(func) -%}
+)
+{%- endmacro -%}
+
+{%- macro to_ffi_call_with_prefix(prefix, func) -%}
+    {%- match func.throws_name() -%}
+    {%- when Some with (e) -%}
+      {{ ci.namespace()|class_name_rb }}.rust_call_with_error({{ e|class_name_rb }},
+    {%- else -%}
+      {{ ci.namespace()|class_name_rb }}.rust_call(
+    {%- endmatch -%}
+    :{{ func.ffi_func().name() }},
+    {{- prefix }},
+    {%- call _arg_list_ffi_call(func) -%}
+)
+{%- endmacro -%}
+
+{%- macro _arg_list_ffi_call(func) %}
+    {%- for arg in func.arguments() %}
+        {{- arg.name()|lower_rb(arg.type_().borrow()) }}
+        {%- if !loop.last %},{% endif %}
+    {%- endfor %}
+{%- endmacro -%}
+
+{#-
+// Arglist as used in Ruby declarations of methods, functions and constructors.
+// Note the var_name_rb and type_rb filters.
+-#}
+
+{% macro arg_list_decl(func) %}
+    {%- for arg in func.arguments() -%}
+        {{ arg.name()|var_name_rb }}
+        {%- match arg.default_value() %}
+        {%- when Some with(literal) %} = {{ literal|literal_rb }}
+        {%- else %}
+        {%- endmatch %}
+        {%- if !loop.last %}, {% endif -%}
+    {%- endfor %}
+{%- endmacro %}
+
+{#-
+// Arglist as used in the UniFFILib function declarations.
+// Note unfiltered name but type_ffi filters.
+-#}
+{%- macro arg_list_ffi_decl(func) %}
+    [{%- for arg in func.arguments() -%}{{ arg.type_().borrow()|type_ffi }}, {% endfor -%} RustCallStatus.by_ref]
+{%- endmacro -%}
+
+{%- macro coerce_args(func) %}
+    {%- for arg in func.arguments() %}
+    {{ arg.name() }} = {{ arg.name()|coerce_rb(arg.type_().borrow()) -}}
+    {% endfor -%}
+{%- endmacro -%}
+
+{%- macro coerce_args_extra_indent(func) %}
+        {%- for arg in func.arguments() %}
+        {{ arg.name() }} = {{ arg.name()|coerce_rb(arg.type_().borrow()) }}
+        {%- endfor %}
+{%- endmacro -%}
diff --git a/third_party/rust/uniffi_bindgen/src/bindings/ruby/templates/wrapper.rb b/third_party/rust/uniffi_bindgen/src/bindings/ruby/templates/wrapper.rb
new file mode 100644
index 0000000000..72cb60f73f
--- /dev/null
+++ b/third_party/rust/uniffi_bindgen/src/bindings/ruby/templates/wrapper.rb
@@ -0,0 +1,47 @@
+# This file was autogenerated by some hot garbage in the `uniffi` crate.
+# Trust me, you don't want to mess with it!
+
+# Common helper code.
+#
+# Ideally this would live in a separate .rb file where it can be unittested etc
+# in isolation, and perhaps even published as a re-useable package.
+#
+# However, it's important that the detils of how this helper code works (e.g. the
+# way that different builtin types are passed across the FFI) exactly match what's
+# expected by the rust code on the other side of the interface. In practice right
+# now that means coming from the exact some version of `uniffi` that was used to
+# compile the rust component. The easiest way to ensure this is to bundle the Ruby
+# helpers directly inline like we're doing here.
+
+require 'ffi'
+
+module {{ ci.namespace()|class_name_rb }}
+  {% include "RustBufferTemplate.rb" %}
+  {% include "RustBufferStream.rb" %}
+  {% include "RustBufferBuilder.rb" %}
+
+  # Error definitions
+  {% include "ErrorTemplate.rb" %}
+
+  {% include "NamespaceLibraryTemplate.rb" %}
+
+  # Public interface members begin here.
+
+  {% for e in ci.enum_definitions() %}
+  {% include "EnumTemplate.rb" %}
+  {%- endfor -%}
+
+  {%- for rec in ci.record_definitions() %}
+  {% include "RecordTemplate.rb" %}
+  {% endfor %}
+
+  {% for func in ci.function_definitions() %}
+  {% include "TopLevelFunctionTemplate.rb" %}
+  {% endfor %}
+
+  {% for obj in ci.object_definitions() %}
+  {% include "ObjectTemplate.rb" %}
+  {% endfor %}
+end
+
+{% import "macros.rb" as rb %}
diff --git a/third_party/rust/uniffi_bindgen/src/bindings/ruby/test.rs b/third_party/rust/uniffi_bindgen/src/bindings/ruby/test.rs
new file mode 100644
index 0000000000..5c445bfae5
--- /dev/null
+++ b/third_party/rust/uniffi_bindgen/src/bindings/ruby/test.rs
@@ -0,0 +1,62 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+License, v. 2.0. If a copy of the MPL was not distributed with this
+* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use anyhow::{bail, Context, Result};
+use camino::Utf8Path;
+use std::env;
+use std::ffi::OsString;
+use std::process::{Command, Stdio};
+use uniffi_testing::UniFFITestHelper;
+
+/// Run Ruby tests for a UniFFI test fixture
+pub fn run_test(tmp_dir: &str, fixture_name: &str, script_file: &str) -> Result<()> {
+    let script_path = Utf8Path::new(".").join(script_file).canonicalize_utf8()?;
+    let test_helper = UniFFITestHelper::new(fixture_name).context("UniFFITestHelper::new")?;
+    let out_dir = test_helper
+        .create_out_dir(tmp_dir, &script_path)
+        .context("create_out_dir")?;
+    test_helper
+        .copy_cdylibs_to_out_dir(&out_dir)
+        .context("copy_cdylibs_to_out_dir")?;
+    generate_sources(&test_helper.cdylib_path()?, &out_dir, &test_helper)
+        .context("generate_sources")?;
+
+    let rubypath = env::var_os("RUBYLIB").unwrap_or_else(|| OsString::from(""));
+    let rubypath = env::join_paths(
+        env::split_paths(&rubypath).chain(vec![out_dir.to_path_buf().into_std_path_buf()]),
+    )?;
+
+    let status = Command::new("ruby")
+        .current_dir(out_dir)
+        .env("RUBYLIB", rubypath)
+        .arg(script_path)
+        .stderr(Stdio::inherit())
+        .stdout(Stdio::inherit())
+        .spawn()
+        .context("Failed to spawn `ruby` when running script")?
+        .wait()
+        .context("Failed to wait for `ruby` when running script")?;
+    if !status.success() {
+        bail!("running `ruby` failed");
+    }
+    Ok(())
+}
+
+fn generate_sources(
+    library_path: &Utf8Path,
+    out_dir: &Utf8Path,
+    test_helper: &UniFFITestHelper,
+) -> Result<()> {
+    for source in test_helper.get_compile_sources()? {
+        crate::generate_bindings(
+            &source.udl_path,
+            source.config_path.as_deref(),
+            vec!["ruby"],
+            Some(out_dir),
+            Some(library_path),
+            false,
+        )?;
+    }
+    Ok(())
+}