rubyx-py 0.1.1 → 0.2.1

data/ext/rubyx/src/rubyx_stream.rs

@@ -73,6 +73,7 @@ mod tests {
     use crate::stream::SendableValue;
     use crate::test_helpers::{skip_if_no_python, with_ruby_python};
     use crossbeam_channel::{bounded, unbounded};
+    use magnus::encoding::EncodingCapable;
     use magnus::value::ReprValue;
     use magnus::TryConvert;
     use serial_test::serial;
@@ -947,4 +948,171 @@ mod tests {
             assert_eq!(v, 99);
         });
     }
+
+    // ========== SendableValue::Bytes → Ruby String (ASCII-8BIT) ==========
+
+    #[test]
+    #[serial]
+    fn test_sendable_bytes_converts_to_ruby_string() {
+        with_ruby_python(|ruby, _api| {
+            let val: magnus::Value = SendableValue::Bytes(b"hello".to_vec())
+                .try_into()
+                .expect("Bytes conversion should succeed");
+
+            // Must be a Ruby String, not an Array of integers
+            let rstr = magnus::RString::try_convert(val).expect("should be a String");
+            let content = unsafe { rstr.as_slice() };
+            assert_eq!(content, b"hello");
+
+            // Verify encoding is ASCII-8BIT
+            let enc = rstr.enc_get();
+            let ascii_8bit = ruby
+                .find_encindex("ASCII-8BIT")
+                .expect("ASCII-8BIT must exist");
+            assert!(
+                enc == ascii_8bit,
+                "Bytes should produce ASCII-8BIT encoded String"
+            );
+        });
+    }
+
+    #[test]
+    #[serial]
+    fn test_sendable_bytes_empty() {
+        with_ruby_python(|ruby, _api| {
+            let val: magnus::Value = SendableValue::Bytes(Vec::new())
+                .try_into()
+                .expect("empty Bytes conversion should succeed");
+
+            let rstr = magnus::RString::try_convert(val).expect("should be a String");
+            let content = unsafe { rstr.as_slice() };
+            assert!(content.is_empty());
+
+            let enc = rstr.enc_get();
+            let ascii_8bit = ruby
+                .find_encindex("ASCII-8BIT")
+                .expect("ASCII-8BIT must exist");
+            assert!(enc == ascii_8bit, "encoding should be ASCII-8BIT");
+        });
+    }
+
+    #[test]
+    #[serial]
+    fn test_sendable_bytes_with_null_bytes() {
+        with_ruby_python(|ruby, _api| {
+            let data = vec![0x00, 0x01, 0xff, 0x00, 0xfe];
+            let val: magnus::Value = SendableValue::Bytes(data.clone())
+                .try_into()
+                .expect("Bytes with NULs should convert");
+
+            let rstr = magnus::RString::try_convert(val).expect("should be a String");
+            let content = unsafe { rstr.as_slice() };
+            assert_eq!(content, data.as_slice());
+
+            let enc = rstr.enc_get();
+            let ascii_8bit = ruby
+                .find_encindex("ASCII-8BIT")
+                .expect("ASCII-8BIT must exist");
+            assert!(enc == ascii_8bit, "encoding should be ASCII-8BIT");
+        });
+    }
+
+    #[test]
+    #[serial]
+    fn test_sendable_bytes_all_256_values() {
+        with_ruby_python(|ruby, _api| {
+            let data: Vec<u8> = (0..=255).collect();
+            let val: magnus::Value = SendableValue::Bytes(data.clone())
+                .try_into()
+                .expect("all byte values should convert");
+
+            let rstr = magnus::RString::try_convert(val).expect("should be a String");
+            let content = unsafe { rstr.as_slice() };
+            assert_eq!(content, data.as_slice());
+
+            let enc = rstr.enc_get();
+            let ascii_8bit = ruby
+                .find_encindex("ASCII-8BIT")
+                .expect("ASCII-8BIT must exist");
+            assert!(enc == ascii_8bit, "encoding should be ASCII-8BIT");
+        });
+    }
+
+    #[test]
+    #[serial]
+    fn test_sendable_bytes_is_not_array() {
+        with_ruby_python(|_ruby, _api| {
+            let val: magnus::Value = SendableValue::Bytes(b"test".to_vec())
+                .try_into()
+                .expect("Bytes conversion should succeed");
+
+            // Must NOT be an Array (Vec<u8>.into_value would produce Array<Integer>)
+            assert!(
+                magnus::RArray::try_convert(val).is_err(),
+                "Bytes must not convert to Ruby Array"
+            );
+        });
+    }
+
+    #[test]
+    #[serial]
+    fn test_sendable_bytes_in_stream_delivery() {
+        with_ruby_python(|ruby, _api| {
+            let (tx, rx) = unbounded();
+            let (cancel_tx, _cancel_rx) = bounded(1);
+
+            thread::spawn(move || {
+                tx.send(Some(SendableValue::Integer(1))).ok();
+                tx.send(Some(SendableValue::Bytes(b"\xde\xad".to_vec())))
+                    .ok();
+                tx.send(Some(SendableValue::Str("after".to_string()))).ok();
+                tx.send(None).ok();
+            });
+
+            let mut stream = crate::stream::AsyncStream::from_channel(rx, cancel_tx);
+
+            // First: integer
+            let val = stream.next().unwrap().unwrap();
+            assert_eq!(i64::try_convert(val).unwrap(), 1);
+
+            // Second: bytes → ASCII-8BIT String
+            let val = stream.next().unwrap().unwrap();
+            let rstr = magnus::RString::try_convert(val).expect("should be String");
+            let content = unsafe { rstr.as_slice() };
+            assert_eq!(content, b"\xde\xad");
+            let enc = rstr.enc_get();
+            let ascii_8bit = ruby
+                .find_encindex("ASCII-8BIT")
+                .expect("ASCII-8BIT must exist");
+            assert!(enc == ascii_8bit, "encoding should be ASCII-8BIT");
+
+            // Third: regular string
+            let val = stream.next().unwrap().unwrap();
+            assert_eq!(String::try_convert(val).unwrap(), "after");
+
+            assert!(stream.next().is_none());
+        });
+    }
+
+    #[test]
+    #[serial]
+    fn test_sendable_bytes_large_payload() {
+        with_ruby_python(|ruby, _api| {
+            let data: Vec<u8> = (0..10_000).map(|i| (i % 256) as u8).collect();
+            let val: magnus::Value = SendableValue::Bytes(data.clone())
+                .try_into()
+                .expect("large Bytes should convert");
+
+            let rstr = magnus::RString::try_convert(val).expect("should be a String");
+            let content = unsafe { rstr.as_slice() };
+            assert_eq!(content.len(), 10_000);
+            assert_eq!(content, data.as_slice());
+
+            let enc = rstr.enc_get();
+            let ascii_8bit = ruby
+                .find_encindex("ASCII-8BIT")
+                .expect("ASCII-8BIT must exist");
+            assert!(enc == ascii_8bit, "encoding should be ASCII-8BIT");
+        });
+    }
 }

data/ext/rubyx/src/stream.rs

@@ -1,8 +1,9 @@
-use crate::api;
 use crate::python_ffi::PyObject;
 use crate::ruby_helpers::runtime_error;
-use crate::rubyx_object::python_to_sendable;
+use crate::rubyx_object::{python_to_sendable, RubyxObject};
+use crate::{api, ruby_helpers};
 use crossbeam_channel::{bounded, unbounded, Receiver, Sender};
+use magnus::encoding::EncodingCapable;
 use magnus::value::ReprValue;
 use magnus::{IntoValue, Value};
 use std::thread;
@@ -21,8 +22,11 @@ pub(crate) enum SendableValue {
     Float(f64),
     Str(String),
     Bool(bool),
+    Bytes(Vec<u8>),
+    Set(Vec<SendableValue>),
     List(Vec<SendableValue>),
     Dict(Vec<(SendableValue, SendableValue)>),
+    PyObjectRef(usize),
 }
 impl TryInto<magnus::Value> for SendableValue {
     type Error = magnus::Error;
@@ -37,7 +41,15 @@ impl TryInto<magnus::Value> for SendableValue {
             SendableValue::Float(f) => f.into_value_with(&ruby),
             SendableValue::Str(s) => s.as_str().into_value_with(&ruby),
             SendableValue::Bool(b) => b.into_value_with(&ruby),
-            SendableValue::List(l) => {
+            SendableValue::Bytes(b) => {
+                let s = ruby.str_from_slice(&b);
+                s.enc_associate(ruby.find_encoding("ASCII-8BIT").ok_or(magnus::Error::new(
+                    ruby_helpers::no_method_error(),
+                    "No ASCII-8BIT",
+                ))?)?;
+                s.as_value()
+            }
+            SendableValue::List(l) | SendableValue::Set(l) => {
                 let ruby_array = ruby.ary_new_capa(l.len());
                 for item in l {
                     let val: Value = item.try_into()?;
@@ -54,6 +66,19 @@ impl TryInto<magnus::Value> for SendableValue {
                 }
                 hash.as_value()
             }
+            SendableValue::PyObjectRef(addr) => {
+                let py_obj = addr as *mut PyObject;
+                let api = crate::API.get().ok_or_else(|| {
+                    magnus::Error::new(runtime_error(), "Python API not initialized")
+                })?;
+                // RubyxObject::new increfs internally and python_to_sendable also incref
+                let wrapper = RubyxObject::new(py_obj, api).ok_or_else(|| {
+                    magnus::Error::new(runtime_error(), "Failed to wrap Python object")
+                })?;
+                // Balance the extra incref from python_to_sendable
+                api.decref(py_obj);
+                wrapper.into_value_with(&ruby)
+            }
         };
         Ok(result)
     }
@@ -710,4 +735,201 @@ mod tests {
             assert_eq!(sum, (0..1000i64).sum::<i64>());
         });
     }
+
+    // ========== PyObjectRef: SendableValue → RubyxObject ==========
+
+    #[test]
+    #[serial]
+    fn test_py_object_ref_converts_to_rubyx_object() {
+        with_ruby_python(|_ruby, api| {
+            let os = api.import_module("os").expect("os should import");
+            api.incref(os); // incref for PyObjectRef (simulates what python_to_sendable does)
+            let sendable = SendableValue::PyObjectRef(os as usize);
+
+            let val: Value = sendable.try_into().expect("PyObjectRef should convert");
+            // The result should be a RubyxObject, not a primitive
+            assert!(!val.is_nil());
+            // Verify it's not a primitive type
+            assert!(i64::try_convert(val).is_err(), "should not be an Integer");
+            assert!(String::try_convert(val).is_err(), "should not be a String");
+
+            api.decref(os); // balance the import_module refcount
+        });
+    }
+
+    #[test]
+    #[serial]
+    fn test_py_object_ref_in_stream() {
+        with_ruby_python(|_ruby, api| {
+            let os = api.import_module("os").expect("os should import");
+            api.incref(os);
+
+            let (tx, rx) = unbounded();
+            let (cancel_tx, _cancel_rx) = bounded(1);
+            let addr = os as usize;
+
+            thread::spawn(move || {
+                tx.send(Some(SendableValue::Integer(1))).ok();
+                tx.send(Some(SendableValue::PyObjectRef(addr))).ok();
+                tx.send(Some(SendableValue::Str("after".to_string()))).ok();
+                tx.send(None).ok();
+            });
+
+            let mut stream = AsyncStream::from_channel(rx, cancel_tx);
+
+            // First: integer
+            let val = stream.next().unwrap().unwrap();
+            assert_eq!(i64::try_convert(val).unwrap(), 1);
+
+            // Second: PyObjectRef → RubyxObject
+            let val = stream.next().unwrap().unwrap();
+            assert!(!val.is_nil());
+            assert!(
+                i64::try_convert(val).is_err(),
+                "should be RubyxObject, not Integer"
+            );
+
+            // Third: string
+            let val = stream.next().unwrap().unwrap();
+            assert_eq!(String::try_convert(val).unwrap(), "after");
+
+            assert!(stream.next().is_none());
+            api.decref(os);
+        });
+    }
+
+    // ========== Set: SendableValue::Set → Ruby Array ==========
+
+    #[test]
+    #[serial]
+    fn test_set_converts_to_ruby_array() {
+        with_ruby_python(|_ruby, _api| {
+            let (tx, rx) = unbounded();
+            let (cancel_tx, _cancel_rx) = bounded(1);
+
+            thread::spawn(move || {
+                tx.send(Some(SendableValue::Set(vec![
+                    SendableValue::Integer(1),
+                    SendableValue::Integer(2),
+                    SendableValue::Integer(3),
+                ])))
+                .ok();
+                tx.send(None).ok();
+            });
+
+            let mut stream = AsyncStream::from_channel(rx, cancel_tx);
+            let val = stream.next().unwrap().unwrap();
+
+            let arr = magnus::RArray::try_convert(val).unwrap();
+            assert_eq!(arr.len(), 3);
+
+            let mut items: Vec<i64> = (0..arr.len())
+                .map(|i| i64::try_convert(arr.entry::<Value>(i as isize).unwrap()).unwrap())
+                .collect();
+            items.sort();
+            assert_eq!(items, vec![1, 2, 3]);
+
+            assert!(stream.next().is_none());
+        });
+    }
+
+    #[test]
+    #[serial]
+    fn test_empty_set_converts_to_empty_ruby_array() {
+        with_ruby_python(|_ruby, _api| {
+            let (tx, rx) = unbounded();
+            let (cancel_tx, _cancel_rx) = bounded(1);
+
+            thread::spawn(move || {
+                tx.send(Some(SendableValue::Set(vec![]))).ok();
+                tx.send(None).ok();
+            });
+
+            let mut stream = AsyncStream::from_channel(rx, cancel_tx);
+            let val = stream.next().unwrap().unwrap();
+
+            let arr = magnus::RArray::try_convert(val).unwrap();
+            assert_eq!(arr.len(), 0);
+
+            assert!(stream.next().is_none());
+        });
+    }
+
+    #[test]
+    #[serial]
+    fn test_set_with_mixed_types_converts_to_ruby_array() {
+        with_ruby_python(|_ruby, _api| {
+            let (tx, rx) = unbounded();
+            let (cancel_tx, _cancel_rx) = bounded(1);
+
+            thread::spawn(move || {
+                tx.send(Some(SendableValue::Set(vec![
+                    SendableValue::Integer(42),
+                    SendableValue::Str("hello".to_string()),
+                    SendableValue::Float(3.14),
+                    SendableValue::Bool(true),
+                ])))
+                .ok();
+                tx.send(None).ok();
+            });
+
+            let mut stream = AsyncStream::from_channel(rx, cancel_tx);
+            let val = stream.next().unwrap().unwrap();
+
+            let arr = magnus::RArray::try_convert(val).unwrap();
+            assert_eq!(arr.len(), 4);
+
+            assert_eq!(
+                i64::try_convert(arr.entry::<Value>(0).unwrap()).unwrap(),
+                42
+            );
+            assert_eq!(
+                String::try_convert(arr.entry::<Value>(1).unwrap()).unwrap(),
+                "hello"
+            );
+            assert!(
+                (f64::try_convert(arr.entry::<Value>(2).unwrap()).unwrap() - 3.14).abs() < 1e-9
+            );
+            assert!(bool::try_convert(arr.entry::<Value>(3).unwrap()).unwrap());
+
+            assert!(stream.next().is_none());
+        });
+    }
+
+    #[test]
+    #[serial]
+    fn test_set_in_stream_with_other_types() {
+        with_ruby_python(|_ruby, _api| {
+            let (tx, rx) = unbounded();
+            let (cancel_tx, _cancel_rx) = bounded(1);
+
+            thread::spawn(move || {
+                tx.send(Some(SendableValue::Integer(1))).ok();
+                tx.send(Some(SendableValue::Set(vec![
+                    SendableValue::Integer(10),
+                    SendableValue::Integer(20),
+                ])))
+                .ok();
+                tx.send(Some(SendableValue::Str("after".to_string()))).ok();
+                tx.send(None).ok();
+            });
+
+            let mut stream = AsyncStream::from_channel(rx, cancel_tx);
+
+            // First: integer
+            let val = stream.next().unwrap().unwrap();
+            assert_eq!(i64::try_convert(val).unwrap(), 1);
+
+            // Second: set → array
+            let val = stream.next().unwrap().unwrap();
+            let arr = magnus::RArray::try_convert(val).unwrap();
+            assert_eq!(arr.len(), 2);
+
+            // Third: string
+            let val = stream.next().unwrap().unwrap();
+            assert_eq!(String::try_convert(val).unwrap(), "after");
+
+            assert!(stream.next().is_none());
+        });
+    }
 }

data/lib/rubyx/railtie.rb

@@ -14,7 +14,8 @@ module Rubyx
 
     # Register rake tasks
     rake_tasks do
-      load 'rubyx/tasks/rubyx.rake'
+      task_file = File.expand_path('tasks/rubyx.rake', __dir__)
+      load task_file if File.exist?(task_file)
     end
   end
 end

data/lib/rubyx/tasks/rubyx.rake

@@ -0,0 +1,127 @@
+namespace :rubyx do
+  desc 'Initialize Python environment (downloads uv and Python if needed)'
+  task init: :environment do
+    Rubyx::Rails.init!
+    puts '[Rubyx] Python environment initialized successfully.'
+  end
+
+  desc 'Check Python environment health'
+  task check: :environment do
+    puts 'Checking Python environment...'
+    puts
+
+    # Check uv
+    system_uv = `which uv 2>/dev/null`.strip
+    uv_available = !system_uv.empty? && File.exist?(system_uv)
+    puts "uv available: #{uv_available ? "Yes (#{system_uv})" : 'No (will auto-download)'}"
+
+    begin
+      Rubyx::Rails.ensure_initialized!
+      puts 'Python initialized: Yes'
+    rescue => e
+      puts "Python initialized: No (#{e.message})"
+      puts
+      puts 'Run `rake rubyx:init` to initialize.'
+      exit 1
+    end
+
+    begin
+      Rubyx.eval('1 + 1')
+      puts 'Basic eval: OK'
+    rescue => e
+      puts "Basic eval: FAILED (#{e.message})"
+      exit 1
+    end
+
+    begin
+      gen = Rubyx.eval("import sys\niter([sys.version.split()[0]])")
+      version = Rubyx.stream(gen).first
+      puts "Import sys: OK (Python #{version})"
+    rescue => e
+      puts "Import sys: FAILED (#{e.message})"
+      exit 1
+    end
+
+    puts
+    puts 'All checks passed!'
+  end
+
+  desc 'Show Rubyx configuration and status'
+  task status: :environment do
+    config = Rubyx::Rails.configuration
+
+    puts 'Rubyx Status'
+    puts '=' * 40
+
+    puts "Initialized: #{Rubyx::Rails.initialized?}"
+    puts
+
+    puts 'Configuration:'
+    puts "  pyproject_path:    #{config.pyproject_path || '(not set)'}"
+    puts "  pyproject_content: #{config.pyproject_content ? '(inline, %d bytes)' % config.pyproject_content.length : '(not set)'}"
+    puts "  auto_init:         #{config.auto_init}"
+    puts "  force_reinit:      #{config.force_reinit}"
+    puts "  uv_version:        #{config.uv_version}"
+    puts "  debug:             #{config.debug}"
+    puts "  python_paths:      #{config.python_paths.inspect}"
+    puts "  uv_path:           #{config.uv_path || '(auto-download)'}"
+    puts "  uv_args:           #{config.uv_args.inspect}"
+    puts
+
+    if config.pyproject_path
+      exists = File.exist?(config.pyproject_path.to_s)
+      puts "pyproject.toml exists: #{exists}"
+    end
+
+    if config.pyproject_path
+      venv_dir = File.join(File.dirname(config.pyproject_path.to_s), '.venv')
+      puts ".venv exists: #{Dir.exist?(venv_dir)}"
+    end
+
+    system_uv = `which uv 2>/dev/null`.strip
+    puts "System uv: #{!system_uv.empty? ? system_uv : '(not found)'}"
+  end
+
+  desc 'List installed Python packages'
+  task packages: :environment do
+    Rubyx::Rails.ensure_initialized!
+
+    gen = Rubyx.eval(<<~PY)
+      import pkg_resources
+      packages = sorted([f"{d.project_name}=={d.version}" for d in pkg_resources.working_set])
+      iter(packages)
+    PY
+
+    puts 'Installed Python packages:'
+    Rubyx.stream(gen).each { |pkg| puts "  #{pkg}" }
+  rescue => e
+    begin
+      gen = Rubyx.eval(<<~PY)
+        from importlib.metadata import distributions
+        packages = sorted([f"{d.metadata['Name']}=={d.metadata['Version']}" for d in distributions()])
+        iter(packages)
+      PY
+
+      puts 'Installed Python packages:'
+      Rubyx.stream(gen).each { |pkg| puts "  #{pkg}" }
+    rescue => e2
+      puts "Could not list packages: #{e2.message}"
+    end
+  end
+
+  desc 'Clear the Rubyx cache (re-download uv + Python on next init)'
+  task clear_cache: :environment do
+    cache_dir = File.join(
+      ENV.fetch('XDG_CACHE_HOME', File.join(Dir.home, '.cache')),
+      'rubyx'
+    )
+
+    if Dir.exist?(cache_dir)
+      require 'fileutils'
+      FileUtils.rm_rf(cache_dir)
+      puts "[Rubyx] Cache cleared: #{cache_dir}"
+    else
+      puts '[Rubyx] No cache directory found.'
+    end
+  end
+end

data/lib/rubyx/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Rubyx
-  VERSION = "0.1.1".freeze
-end
+  VERSION = "0.2.1".freeze
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubyx-py
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.1
 platform: ruby
 authors:
 - Naiker
@@ -62,6 +62,7 @@ extra_rdoc_files: []
 files:
 - Cargo.toml
 - README.md
+- docs/assets/logo.png
 - ext/rubyx/Cargo.toml
 - ext/rubyx/extconf.rb
 - ext/rubyx/src/async_gen.rs
@@ -70,6 +71,7 @@ files:
 - ext/rubyx/src/eval.rs
 - ext/rubyx/src/exception.rs
 - ext/rubyx/src/future.rs
+- ext/rubyx/src/gvl.rs
 - ext/rubyx/src/import.rs
 - ext/rubyx/src/lib.rs
 - ext/rubyx/src/nonblocking_stream.rs
@@ -94,6 +96,7 @@ files:
 - lib/rubyx/error.rb
 - lib/rubyx/rails.rb
 - lib/rubyx/railtie.rb
+- lib/rubyx/tasks/rubyx.rake
 - lib/rubyx/uv.rb
 - lib/rubyx/version.rb
 homepage: https://github.com/yinho999/rubyx