Correctly raise Ruby exception instead of panicking

Gemfile.lock

@@ -1,15 +1,15 @@
 PATH
   remote: .
   specs:
-    pdq (0.1.0)
+    pdq (0.1.1)
       rb_sys (~> 0.9.91)
 
 GEM
   remote: https://rubygems.org/
   specs:
     ast (2.4.3)
     diff-lcs (1.6.2)
-    json (2.18.0)
+    json (2.18.1)
     language_server-protocol (3.17.0.5)
     lint_roller (1.1.0)
     parallel (1.27.0)
@@ -38,7 +38,7 @@ GEM
     rspec-mocks (3.13.7)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.13.0)
-    rspec-support (3.13.6)
+    rspec-support (3.13.7)
     rubocop (1.82.1)
       json (~> 2.3)
       language_server-protocol (~> 3.17.0.2)

ext/pdq/Cargo.toml

@@ -10,10 +10,10 @@ publish = false
 crate-type = ["cdylib"]
 
 [dependencies]
-magnus = { version = "0.6.2" }
+magnus = { version = "0.8.2" }
 pdqhash = { git = "https://github.com/fetlife/pdqhash", package = "pdqhash" }
 image = "0.25"
 hex = "0.4"
 
 [build-dependencies]
-rb-sys-env = "0.2.2"
+rb-sys-env = "0.2.3"

ext/pdq/build.rs

@@ -1,5 +1,5 @@
 pub fn main() -> Result<(), Box<dyn std::error::Error>> {
-  let _rb_env = rb_sys_env::activate()?;
+    let _rb_env = rb_sys_env::activate()?;
 
-  Ok(())
-}
+    Ok(())
+}

ext/pdq/src/lib.rs

@@ -1,33 +1,67 @@
-use magnus::{function, prelude::*, Error, Ruby, RString, RArray};
+use hex;
 use image::ImageReader;
+use magnus::{
+    Error, ExceptionClass, RArray, RModule, RString, Ruby, function, gc::register_mark_object, prelude::*, value::Lazy
+};
 use pdqhash::generate_pdq;
-use hex;
 
-fn pdq_hash(image_path: RString) -> RArray {
-    let path = image_path.to_string()
-        .expect("Failed to convert path to string");
-
+static PDQ_ERROR: Lazy<ExceptionClass> = Lazy::new(|ruby| {
+    let ex = ruby
+        .class_object()
+        .const_get::<_, RModule>("Pdq")
+        .unwrap()
+        .const_get("Error")
+        .unwrap();
+    // ensure `ex` is never garbage collected (e.g. if constant is
+    // redefined) and also not moved under compacting GC.
+    // ruby.gc_register_mark_object(ex);
+    register_mark_object(ex);
+    ex
+});
+
+fn pdq_hash(ruby: &Ruby, image_path: RString) -> Result<RArray, Error> {
+    let path = image_path.to_string().map_err(|e| {
+        Error::new(
+            ruby.get_inner(&PDQ_ERROR),
+            format!("Failed to convert path to string: {}", e),
+        )
+    })?;
+
     // Load the image
     let img = ImageReader::open(path)
-        .expect("Failed to open image")
+        .map_err(|e| {
+            Error::new(
+                ruby.get_inner(&PDQ_ERROR),
+                format!("Failed to open image: {}", e),
+            )
+        })?
         .decode()
-        .expect("Failed to decode image");
-
+        .map_err(|e| {
+            Error::new(
+                ruby.get_inner(&PDQ_ERROR),
+                format!("Failed to decode image: {}", e),
+            )
+        })?;
+
     // Generate PDQ hash
-    let (hash, quality) = generate_pdq(&img)
-        .expect("Failed to generate PDQ hash");
-
+    let (hash, quality) = generate_pdq(&img).ok_or_else(|| {
+        Error::new(
+            ruby.get_inner(&PDQ_ERROR),
+            format!("Failed to generate PDQ hash"),
+        )
+    })?;
+
     // Create Ruby array with hash and quality
-    let result = RArray::new();
+    let result = ruby.ary_new();
     result.push(hex::encode(hash)).unwrap();
     result.push(quality).unwrap();
 
-    result
+    Ok(result)
 }
 
 #[magnus::init]
 fn init(ruby: &Ruby) -> Result<(), Error> {
     let module = ruby.define_module("Pdq")?;
     module.define_singleton_method("pdq_hash", function!(pdq_hash, 1))?;
     Ok(())
-}
+}

lib/pdq/version.rb

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