proofmode 0.8.0

data/lib/proofmode_callbacks.rb

@@ -0,0 +1,208 @@
+# Foreign callback support for ProofModeCallbacks.
+#
+# The UniFFI Ruby backend does not generate vtable callback infrastructure
+# for traits with `#[uniffi::export(with_foreign)]`. This file adds that
+# support so Ruby code can implement ProofModeCallbacks and pass instances
+# to generate_proof / check_files.
+#
+# Usage:
+#   require "proofmode"
+#   require "proofmode_callbacks"
+#
+# Then subclass Proofmode::ProofModeCallbacks and override the 7 methods.
+
+require "proofmode"
+
+module Proofmode
+  # Thread-safe handle map for storing foreign (Ruby) callback objects.
+  class CallbackHandleMap
+    def initialize
+      @mutex = Mutex.new
+      @map = {}
+      @next_handle = 1
+    end
+
+    def insert(obj)
+      @mutex.synchronize do
+        handle = (@next_handle << 1) | 1 # odd handles = foreign
+        @next_handle += 1
+        @map[handle] = obj
+        handle
+      end
+    end
+
+    def get(handle)
+      @mutex.synchronize do
+        @map.fetch(handle) { raise "CallbackHandleMap: unknown handle #{handle}" }
+      end
+    end
+
+    def remove(handle)
+      @mutex.synchronize do
+        @map.delete(handle)
+      end
+    end
+
+    def clone_handle(handle)
+      @mutex.synchronize do
+        obj = @map.fetch(handle) { raise "CallbackHandleMap: unknown handle #{handle}" }
+        new_handle = (@next_handle << 1) | 1
+        @next_handle += 1
+        @map[new_handle] = obj
+        new_handle
+      end
+    end
+  end
+
+  CALLBACK_HANDLE_MAP = CallbackHandleMap.new
+
+  # Access the private UniFFILib module using const_get
+  _uniffi_lib = const_get(:UniFFILib)
+
+  # Define vtable callback functions using FFI::Function.
+  # Each function receives a handle, arguments as RustBuffers, an out_return
+  # pointer, and a call_status pointer.
+
+  _vtable_free = FFI::Function.new(:void, [:uint64]) do |handle|
+    CALLBACK_HANDLE_MAP.remove(handle)
+  rescue => e
+    $stderr.puts "proofmode vtable free error: #{e}"
+  end
+
+  _vtable_clone = FFI::Function.new(:uint64, [:uint64]) do |handle|
+    CALLBACK_HANDLE_MAP.clone_handle(handle)
+  rescue => e
+    $stderr.puts "proofmode vtable clone error: #{e}"
+    0
+  end
+
+  _vtable_get_location = FFI::Function.new(:void, [:uint64, :pointer, :pointer]) do |handle, out_return, _call_status|
+    obj = CALLBACK_HANDLE_MAP.get(handle)
+    result = obj.get_location
+    buf = RustBuffer.alloc_from_OptionalTypeLocationData(result)
+    # Copy RustBuffer struct bytes into the out_return pointer
+    out_return.put_uint64(0, buf[:capacity])
+    out_return.put_uint64(8, buf[:len])
+    out_return.put_pointer(16, buf[:data])
+  rescue => e
+    $stderr.puts "proofmode vtable get_location error: #{e}\n#{e.backtrace.first(5).join("\n")}"
+  end
+
+  _vtable_get_device_info = FFI::Function.new(:void, [:uint64, :pointer, :pointer]) do |handle, out_return, _call_status|
+    obj = CALLBACK_HANDLE_MAP.get(handle)
+    result = obj.get_device_info
+    buf = RustBuffer.alloc_from_OptionalTypeDeviceData(result)
+    out_return.put_uint64(0, buf[:capacity])
+    out_return.put_uint64(8, buf[:len])
+    out_return.put_pointer(16, buf[:data])
+  rescue => e
+    $stderr.puts "proofmode vtable get_device_info error: #{e}\n#{e.backtrace.first(5).join("\n")}"
+  end
+
+  _vtable_get_network_info = FFI::Function.new(:void, [:uint64, :pointer, :pointer]) do |handle, out_return, _call_status|
+    obj = CALLBACK_HANDLE_MAP.get(handle)
+    result = obj.get_network_info
+    buf = RustBuffer.alloc_from_OptionalTypeNetworkData(result)
+    out_return.put_uint64(0, buf[:capacity])
+    out_return.put_uint64(8, buf[:len])
+    out_return.put_pointer(16, buf[:data])
+  rescue => e
+    $stderr.puts "proofmode vtable get_network_info error: #{e}\n#{e.backtrace.first(5).join("\n")}"
+  end
+
+  # save_data: (handle, hash_buf, filename_buf, data_buf, out_return_i8_ptr, call_status_ptr)
+  # The RustBuffer args are passed by value. In Ruby FFI, callback functions
+  # receive by-value structs as pointers that we need to cast.
+  _vtable_save_data = FFI::Function.new(:void, [:uint64, RustBuffer.by_value, RustBuffer.by_value, RustBuffer.by_value, :pointer, :pointer]) do |handle, hash_buf, filename_buf, data_buf, out_return, _call_status|
+    obj = CALLBACK_HANDLE_MAP.get(handle)
+    hash_str = hash_buf.consumeIntoString
+    filename_str = filename_buf.consumeIntoString
+    data_bytes = data_buf.consumeIntoBytes
+    result = obj.save_data(hash_str, filename_str, data_bytes)
+    out_return.put_int8(0, result ? 1 : 0)
+  rescue => e
+    $stderr.puts "proofmode vtable save_data error: #{e}\n#{e.backtrace.first(5).join("\n")}"
+  end
+
+  _vtable_save_text = FFI::Function.new(:void, [:uint64, RustBuffer.by_value, RustBuffer.by_value, RustBuffer.by_value, :pointer, :pointer]) do |handle, hash_buf, filename_buf, text_buf, out_return, _call_status|
+    obj = CALLBACK_HANDLE_MAP.get(handle)
+    hash_str = hash_buf.consumeIntoString
+    filename_str = filename_buf.consumeIntoString
+    text_str = text_buf.consumeIntoString
+    result = obj.save_text(hash_str, filename_str, text_str)
+    out_return.put_int8(0, result ? 1 : 0)
+  rescue => e
+    $stderr.puts "proofmode vtable save_text error: #{e}\n#{e.backtrace.first(5).join("\n")}"
+  end
+
+  _vtable_sign_data = FFI::Function.new(:void, [:uint64, RustBuffer.by_value, :pointer, :pointer]) do |handle, data_buf, out_return, _call_status|
+    obj = CALLBACK_HANDLE_MAP.get(handle)
+    data_bytes = data_buf.consumeIntoBytes
+    result = obj.sign_data(data_bytes)
+    buf = RustBuffer.alloc_from_Optionalbytes(result)
+    out_return.put_uint64(0, buf[:capacity])
+    out_return.put_uint64(8, buf[:len])
+    out_return.put_pointer(16, buf[:data])
+  rescue => e
+    $stderr.puts "proofmode vtable sign_data error: #{e}\n#{e.backtrace.first(5).join("\n")}"
+  end
+
+  _vtable_report_progress = FFI::Function.new(:void, [:uint64, RustBuffer.by_value, :pointer, :pointer]) do |handle, message_buf, _out_return, _call_status|
+    obj = CALLBACK_HANDLE_MAP.get(handle)
+    message_str = message_buf.consumeIntoString
+    obj.report_progress(message_str)
+  rescue => e
+    $stderr.puts "proofmode vtable report_progress error: #{e}\n#{e.backtrace.first(5).join("\n")}"
+  end
+
+  # Build the vtable as an array of function pointers.
+  # Layout order: free, clone, get_location, get_device_info, get_network_info,
+  #               save_data, save_text, sign_data, report_progress
+  vtable_fns = [
+    _vtable_free,
+    _vtable_clone,
+    _vtable_get_location,
+    _vtable_get_device_info,
+    _vtable_get_network_info,
+    _vtable_save_data,
+    _vtable_save_text,
+    _vtable_sign_data,
+    _vtable_report_progress,
+  ]
+
+  # Keep references alive to prevent GC
+  VTABLE_REFS = vtable_fns.freeze
+
+  # Allocate persistent memory for the vtable (array of function pointers)
+  VTABLE_PTR = FFI::MemoryPointer.new(:pointer, vtable_fns.length, true)
+  vtable_fns.each_with_index do |fn, i|
+    VTABLE_PTR.put_pointer(i * FFI::Pointer.size, fn)
+  end
+
+  # Register the vtable with Rust
+  _rust_call_status = const_get(:RustCallStatus).new
+  _uniffi_lib.uniffi_proofmode_fn_init_callback_vtable_proofmodecallbacks(
+    VTABLE_PTR, _rust_call_status
+  )
+
+  # Patch ProofModeCallbacks to support foreign (Ruby) implementations
+  class ProofModeCallbacks
+    class << self
+      def uniffi_check_lower(inst)
+        unless inst.is_a?(self)
+          raise TypeError, "Expected a ProofModeCallbacks instance, got #{inst}"
+        end
+      end
+
+      def uniffi_lower(inst)
+        if inst.instance_variable_defined?(:@handle)
+          # Rust-created object
+          inst.uniffi_clone_handle
+        else
+          # Ruby-created (foreign) object
+          CALLBACK_HANDLE_MAP.insert(inst)
+        end
+      end
+    end
+  end
+end

data/proofmode.gemspec

@@ -0,0 +1,22 @@
+Gem::Specification.new do |s|
+  s.name        = "proofmode"
+  s.version     = "0.8.0"
+  s.summary     = "Ruby bindings for ProofMode"
+  s.description = "Capture, share, and preserve verifiable photos and videos using ProofMode"
+  s.authors     = ["Guardian Project"]
+  s.email       = "support@guardianproject.info"
+  s.homepage    = "https://proofmode.org"
+  s.license     = "Apache-2.0"
+
+  s.files       = Dir["lib/**/*"] + ["proofmode.gemspec"]
+  s.require_paths = ["lib"]
+
+  s.required_ruby_version = ">= 2.7.0"
+
+  s.add_dependency "ffi", "~> 1.15"
+
+  s.metadata = {
+    "source_code_uri" => "https://gitlab.com/guardianproject/proofmode/proofmode-rust",
+    "bug_tracker_uri" => "https://gitlab.com/guardianproject/proofmode/proofmode-rust/-/issues"
+  }
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: proofmode
+version: !ruby/object:Gem::Version
+  version: 0.8.0
+platform: ruby
+authors:
+- Guardian Project
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-02-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+description: Capture, share, and preserve verifiable photos and videos using ProofMode
+email: support@guardianproject.info
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/libproofmode.so
+- lib/proofmode.rb
+- lib/proofmode_callbacks.rb
+- proofmode.gemspec
+homepage: https://proofmode.org
+licenses:
+- Apache-2.0
+metadata:
+  source_code_uri: https://gitlab.com/guardianproject/proofmode/proofmode-rust
+  bug_tracker_uri: https://gitlab.com/guardianproject/proofmode/proofmode-rust/-/issues
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.19
+signing_key:
+specification_version: 4
+summary: Ruby bindings for ProofMode
+test_files: []