rubyx-py 0.1.0

data/ext/rubyx/src/python_ffi.rs

@@ -0,0 +1,18 @@
+use std::ffi::c_void;
+
+pub type PyObject = c_void;
+#[allow(non_camel_case_types)]
+pub type Py_ssize_t = isize;
+
+#[repr(C)]
+pub struct PyThreadState {
+    _private: [u8; 0],
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug, PartialEq)]
+#[allow(dead_code)]
+pub enum PyGILState {
+    Locked = 0,
+    Unlocked = 1,
+}

data/ext/rubyx/src/python_finder.rs

@@ -0,0 +1,119 @@
+use std::path::PathBuf;
+use std::process::Command;
+
+pub fn find_libpython() -> Option<PathBuf> {
+    if let Some(path) = find_via_python_config() {
+        if path.exists() {
+            return Some(path);
+        }
+    }
+
+    common_paths().into_iter().find(|path| path.exists())
+}
+
+fn find_via_python_config() -> Option<PathBuf> {
+    let output = Command::new("python3")
+        .args([
+            "-c",
+            "import sysconfig; print(sysconfig.get_config_var('LIBDIR'))",
+        ])
+        .output()
+        .ok()?;
+
+    if !output.status.success() {
+        return None;
+    }
+
+    let libdir = String::from_utf8_lossy(&output.stdout).trim().to_string();
+    if libdir.is_empty() || libdir == "None" {
+        return None;
+    }
+
+    let version_output = Command::new("python3")
+        .args([
+            "-c",
+            "import sys; print(f'{sys.version_info.major}.{sys.version_info.minor}')",
+        ])
+        .output()
+        .ok()?;
+
+    let version = String::from_utf8_lossy(&version_output.stdout)
+        .trim()
+        .to_string();
+
+    #[cfg(target_os = "macos")]
+    let lib_name = format!("libpython{}.dylib", version);
+    #[cfg(target_os = "linux")]
+    let lib_name = format!("libpython{}.so", version);
+    #[cfg(target_os = "windows")]
+    let lib_name = format!("python{}.dll", version.replace(".", ""));
+    #[cfg(not(any(target_os = "macos", target_os = "linux", target_os = "windows")))]
+    let lib_name = format!("libpython{}.so", version);
+
+    let path = PathBuf::from(libdir).join(&lib_name);
+    if path.exists() {
+        return Some(path);
+    }
+
+    #[cfg(target_os = "macos")]
+    {
+        if let Some(p) = find_macos_framework(&version) {
+            if p.exists() {
+                return Some(p);
+            }
+        }
+    }
+
+    Some(path)
+}
+
+#[cfg(target_os = "macos")]
+fn find_macos_framework(version: &str) -> Option<PathBuf> {
+    let output = Command::new("python3")
+        .args(["-c", "import sys; print(sys.prefix)"])
+        .output()
+        .ok()?;
+
+    let prefix = String::from_utf8_lossy(&output.stdout).trim().to_string();
+
+    let framework_lib = PathBuf::from(&prefix)
+        .join("lib")
+        .join(format!("libpython{}.dylib", version));
+    if framework_lib.exists() {
+        return Some(framework_lib);
+    }
+
+    let python_dylib = PathBuf::from(&prefix).join("Python");
+    if python_dylib.exists() {
+        return Some(python_dylib);
+    }
+
+    None
+}
+
+fn common_paths() -> Vec<PathBuf> {
+    let mut paths = Vec::new();
+
+    #[cfg(target_os = "macos")]
+    for minor in (8..=15).rev() {
+        paths.push(PathBuf::from(format!(
+            "/opt/homebrew/opt/python@3.{}/Frameworks/Python.framework/Versions/3.{}/lib/libpython3.{}.dylib",
+            minor, minor, minor
+        )));
+        paths.push(PathBuf::from(format!(
+            "/opt/homebrew/opt/python@3.{}/Frameworks/Python.framework/Versions/3.{}/Python",
+            minor, minor
+        )));
+    }
+
+    #[cfg(target_os = "linux")]
+    for minor in (8..=15).rev() {
+        paths.push(PathBuf::from(format!(
+            "/usr/lib/x86_64-linux-gnu/libpython3.{}.so",
+            minor
+        )));
+        paths.push(PathBuf::from(format!("/usr/lib/libpython3.{}.so", minor)));
+    }
+
+    paths
+}

data/ext/rubyx/src/python_guard.rs

@@ -0,0 +1,25 @@
+use crate::python_api::PythonApi;
+use crate::python_ffi::PyObject;
+
+/// RAII guard that decrefs a PyObject when dropped.
+pub(crate) struct PyGuard<'a> {
+    obj: *mut PyObject,
+    api: &'a PythonApi,
+}
+impl<'a> PyGuard<'a> {
+    pub(crate) fn new(obj: *mut PyObject, api: &'a PythonApi) -> Option<Self> {
+        if obj.is_null() {
+            None
+        } else {
+            Some(Self { obj, api })
+        }
+    }
+    pub(crate) fn ptr(&self) -> *mut PyObject {
+        self.obj
+    }
+}
+impl Drop for PyGuard<'_> {
+    fn drop(&mut self) {
+        self.api.decref(self.obj);
+    }
+}

data/ext/rubyx/src/ruby_helpers.rs

@@ -0,0 +1,74 @@
+//! Many call sites (trait impls like `From<PythonException>`, deeply nested
+//! helpers) don't have a `&Ruby` in scope and cannot easily thread one through.
+//! These helpers centralise the `Ruby::get()` call so each caller can simply
+//! write `runtime_error()` instead of repeating the boilerplate.
+//!
+//! # Panics
+//!
+//! Every function in this module calls `Ruby::get().expect(…)` and will panic
+//! if invoked from a non-Ruby thread. This is intentional — it mirrors the
+//! behaviour of the deprecated `magnus::exception::*()` functions, and all
+//! code paths that reach these helpers originate from Ruby callbacks registered
+//! via magnus, where `Ruby::get()` is guaranteed to succeed.
+use magnus::{ExceptionClass, Module};
+
+/// Returns Ruby's `RuntimeError` exception class.
+pub(crate) fn runtime_error() -> ExceptionClass {
+    let ruby = magnus::Ruby::get().expect("must be called from Ruby thread");
+    ruby.exception_runtime_error()
+}
+
+/// Returns Ruby's `TypeError` exception class.
+pub(crate) fn type_error() -> ExceptionClass {
+    let ruby = magnus::Ruby::get().expect("must be called from Ruby thread");
+    ruby.exception_type_error()
+}
+
+/// Returns Ruby's `ArgumentError` exception class.
+pub(crate) fn arg_error() -> ExceptionClass {
+    let ruby = magnus::Ruby::get().expect("must be called from Ruby thread");
+    ruby.exception_arg_error()
+}
+
+/// Returns Ruby's `SyntaxError` exception class.
+pub(crate) fn syntax_error() -> ExceptionClass {
+    let ruby = magnus::Ruby::get().expect("must be called from Ruby thread");
+    ruby.exception_syntax_error()
+}
+
+/// Returns Ruby's base `Exception` exception class.
+pub(crate) fn exception() -> ExceptionClass {
+    let ruby = magnus::Ruby::get().expect("must be called from Ruby thread");
+    ruby.exception_exception()
+}
+
+/// Returns Ruby's `NoMethodError` exception class.
+pub(crate) fn no_method_error() -> ExceptionClass {
+    let ruby = magnus::Ruby::get().expect("must be called from Ruby thread");
+    ruby.exception_no_method_error()
+}
+
+/// Look up a Rubyx error class by Python exception kind.
+/// Falls back to `Rubyx::PythonError` for unrecognized kinds,
+/// and `RuntimeError` if the Rubyx module isn't available.
+pub(crate) fn rubyx_exception_class(kind: &str) -> ExceptionClass {
+    let ruby = magnus::Ruby::get().expect("must be called from Ruby thread");
+    let rubyx = match ruby.define_module("Rubyx") {
+        Ok(m) => m,
+        Err(_) => return ruby.exception_runtime_error(),
+    };
+
+    let class_name = match kind {
+        "KeyError" => "KeyError",
+        "IndexError" => "IndexError",
+        "ValueError" => "ValueError",
+        "AttributeError" => "AttributeError",
+        "TypeError" => "TypeError",
+        "ImportError" | "ModuleNotFoundError" => "ImportError",
+        _ => "PythonError",
+    };
+
+    rubyx
+        .const_get::<_, ExceptionClass>(class_name)
+        .unwrap_or_else(|_| ruby.exception_runtime_error())
+}