libsql2 0.1.0

data/ext/libsql2/src/error.rs

@@ -0,0 +1,42 @@
+use std::sync::OnceLock;
+
+use magnus::{prelude::*, Error, ExceptionClass, RModule, Ruby};
+
+/// Wrapper to allow ExceptionClass in OnceLock.
+/// SAFETY: These are only accessed under the GVL (single-threaded Ruby execution).
+#[derive(Debug)]
+struct SyncExceptionClass(ExceptionClass);
+unsafe impl Send for SyncExceptionClass {}
+unsafe impl Sync for SyncExceptionClass {}
+
+static ERROR_CLASS: OnceLock<SyncExceptionClass> = OnceLock::new();
+static CLOSED_ERROR_CLASS: OnceLock<SyncExceptionClass> = OnceLock::new();
+
+pub fn init(ruby: &Ruby, module: &RModule) -> Result<(), Error> {
+    let error_class = module.define_error("Error", ruby.exception_runtime_error())?;
+    let closed_error_class = module.define_error("ClosedError", error_class)?;
+
+    ERROR_CLASS
+        .set(SyncExceptionClass(error_class))
+        .expect("error class already initialized");
+    CLOSED_ERROR_CLASS
+        .set(SyncExceptionClass(closed_error_class))
+        .expect("closed error class already initialized");
+
+    Ok(())
+}
+
+pub fn libsql_error() -> ExceptionClass {
+    ERROR_CLASS.get().expect("error class not initialized").0
+}
+
+pub fn closed_error() -> ExceptionClass {
+    CLOSED_ERROR_CLASS
+        .get()
+        .expect("closed error class not initialized")
+        .0
+}
+
+pub fn to_error(e: libsql::Error) -> Error {
+    Error::new(libsql_error(), e.to_string())
+}

data/ext/libsql2/src/lib.rs

@@ -0,0 +1,20 @@
+use magnus::{Error, Ruby};
+
+mod connection;
+mod database;
+mod error;
+mod rows;
+mod statement;
+
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    let module = ruby.define_module("Libsql")?;
+
+    error::init(ruby, &module)?;
+    database::init(ruby, &module)?;
+    connection::init(ruby, &module)?;
+    rows::init(ruby, &module)?;
+    statement::init(ruby, &module)?;
+
+    Ok(())
+}

data/ext/libsql2/src/rows.rs

@@ -0,0 +1,154 @@
+use std::sync::OnceLock;
+
+use magnus::prelude::*;
+use magnus::{Error, IntoValue, RArray, RClass, RHash, RModule, Ruby, Value};
+
+use crate::error;
+
+/// Wrapper to allow RClass in OnceLock.
+/// SAFETY: Only accessed under the GVL (single-threaded Ruby execution).
+#[derive(Debug)]
+struct SyncRClass(RClass);
+unsafe impl Send for SyncRClass {}
+unsafe impl Sync for SyncRClass {}
+
+static BLOB_CLASS: OnceLock<SyncRClass> = OnceLock::new();
+
+pub fn init(ruby: &Ruby, module: &RModule) -> Result<(), Error> {
+    let rows_class = module.define_class("Rows", ruby.class_object())?;
+    rows_class.define_method("columns", magnus::method!(Rows::columns, 0))?;
+    rows_class.define_method("types", magnus::method!(Rows::types, 0))?;
+    rows_class.define_method("each", magnus::method!(Rows::each, 0))?;
+    rows_class.define_method("to_a", magnus::method!(Rows::to_a, 0))?;
+    rows_class.include_module(ruby.module_enumerable())?;
+
+    let blob_class: RClass = ruby.eval("Libsql::Blob")?;
+    BLOB_CLASS
+        .set(SyncRClass(blob_class))
+        .expect("Blob class already initialized");
+
+    Ok(())
+}
+
+#[magnus::wrap(class = "Libsql::Rows", free_immediately, size)]
+pub struct Rows {
+    column_names: Vec<String>,
+    column_types: Vec<Option<String>>,
+    data: Vec<Vec<CellValue>>,
+}
+
+pub fn blob_class() -> RClass {
+    BLOB_CLASS.get().expect("Blob class not initialized").0
+}
+
+/// Represents a cell value from a query result row.
+pub enum CellValue {
+    Null,
+    Integer(i64),
+    Real(f64),
+    Text(String),
+    Blob(Vec<u8>),
+}
+
+impl From<libsql::Value> for CellValue {
+    fn from(val: libsql::Value) -> Self {
+        match val {
+            libsql::Value::Null => Self::Null,
+            libsql::Value::Integer(i) => Self::Integer(i),
+            libsql::Value::Real(f) => Self::Real(f),
+            libsql::Value::Text(s) => Self::Text(s),
+            libsql::Value::Blob(b) => Self::Blob(b),
+        }
+    }
+}
+
+impl Rows {
+    pub fn new(
+        column_names: Vec<String>,
+        column_types: Vec<Option<String>>,
+        data: Vec<Vec<CellValue>>,
+    ) -> Self {
+        Self {
+            column_names,
+            column_types,
+            data,
+        }
+    }
+
+    fn columns(&self) -> RArray {
+        let ruby = Ruby::get().expect("called from Ruby");
+        let ary = ruby.ary_new_capa(self.column_names.len());
+        for name in &self.column_names {
+            let _ = ary.push(ruby.str_new(name));
+        }
+        ary
+    }
+
+    fn types(&self) -> RArray {
+        let ruby = Ruby::get().expect("called from Ruby");
+        let ary = ruby.ary_new_capa(self.column_types.len());
+        for t in &self.column_types {
+            match t {
+                Some(s) => {
+                    let _ = ary.push(ruby.str_new(s));
+                }
+                None => {
+                    let _ = ary.push(ruby.qnil());
+                }
+            }
+        }
+        ary
+    }
+
+    fn each(&self) -> Result<Value, Error> {
+        let ruby = Ruby::get().expect("called from Ruby");
+        if !ruby.block_given() {
+            // TODO: return Enumerator when no block given
+            return Err(Error::new(error::libsql_error(), "no block given (yield)"));
+        }
+
+        for row_data in &self.data {
+            let hash = self.row_to_hash(&ruby, row_data)?;
+            let _: Value = ruby.yield_value(hash)?;
+        }
+
+        Ok(ruby.qnil().into_value_with(&ruby))
+    }
+
+    fn to_a(&self) -> Result<RArray, Error> {
+        let ruby = Ruby::get().expect("called from Ruby");
+        let ary = ruby.ary_new_capa(self.data.len());
+        for row_data in &self.data {
+            let hash = self.row_to_hash(&ruby, row_data)?;
+            let _ = ary.push(hash);
+        }
+        Ok(ary)
+    }
+
+    fn row_to_hash(&self, ruby: &Ruby, row_data: &[CellValue]) -> Result<RHash, Error> {
+        let hash = ruby.hash_new();
+        for (i, cell) in row_data.iter().enumerate() {
+            let key = ruby.str_new(&self.column_names[i]);
+            let val = cell_to_ruby_value(ruby, cell)?;
+            hash.aset(key, val)?;
+        }
+        Ok(hash)
+    }
+}
+
+fn cell_to_ruby_value(ruby: &Ruby, cell: &CellValue) -> Result<Value, Error> {
+    match cell {
+        CellValue::Null => Ok(ruby.qnil().into_value_with(ruby)),
+        CellValue::Integer(i) => Ok(ruby.into_value(*i)),
+        CellValue::Real(f) => Ok(ruby.into_value(*f)),
+        CellValue::Text(s) => {
+            let rstr = ruby.str_new(s);
+            Ok(rstr.into_value_with(ruby))
+        }
+        CellValue::Blob(bytes) => {
+            let rstr = ruby.str_from_slice(bytes);
+            let blob: Value = blob_class().funcall("new", (rstr,))?;
+            Ok(blob)
+        }
+    }
+}

data/ext/libsql2/src/statement.rs

@@ -0,0 +1,146 @@
+use std::cell::RefCell;
+use std::sync::Arc;
+
+use magnus::{prelude::*, Error, RModule, Ruby, Value};
+use tokio::runtime::Runtime;
+
+use crate::connection::{params_to_libsql, ruby_array_to_params};
+use crate::error;
+use crate::rows::Rows;
+
+pub fn init(ruby: &Ruby, module: &RModule) -> Result<(), Error> {
+    let class = module.define_class("Statement", ruby.class_object())?;
+    class.define_method("bind", magnus::method!(Statement::bind, 1))?;
+    class.define_method("execute", magnus::method!(Statement::execute, -1))?;
+    class.define_method("query", magnus::method!(Statement::query, -1))?;
+    class.define_method("reset", magnus::method!(Statement::reset, 0))?;
+    class.define_method("close", magnus::method!(Statement::close, 0))?;
+    class.define_method("closed?", magnus::method!(Statement::is_closed, 0))?;
+
+    Ok(())
+}
+
+/// Internal state dropped together on close to release file descriptors.
+struct StatementInner {
+    rt: Arc<Runtime>,
+    stmt: libsql::Statement,
+}
+
+#[magnus::wrap(class = "Libsql::Statement", free_immediately, size)]
+pub struct Statement {
+    inner: RefCell<Option<StatementInner>>,
+    column_names: Vec<String>,
+    column_types: Vec<Option<String>>,
+    bound_params: RefCell<Option<libsql::params::Params>>,
+}
+
+impl Statement {
+    pub fn new(
+        rt: Arc<Runtime>,
+        stmt: libsql::Statement,
+        column_names: Vec<String>,
+        column_types: Vec<Option<String>>,
+    ) -> Self {
+        Self {
+            inner: RefCell::new(Some(StatementInner { rt, stmt })),
+            column_names,
+            column_types,
+            bound_params: RefCell::new(None),
+        }
+    }
+
+    fn with_inner<F, T>(&self, f: F) -> Result<T, Error>
+    where
+        F: FnOnce(&StatementInner) -> Result<T, Error>,
+    {
+        let inner = self.inner.borrow();
+        let inner = inner
+            .as_ref()
+            .ok_or_else(|| Error::new(error::closed_error(), "statement is closed"))?;
+        f(inner)
+    }
+
+    fn bind(&self, params: Value) -> Result<(), Error> {
+        let param_values = ruby_array_to_params(&params)?;
+        let libsql_params = params_to_libsql(&param_values);
+        *self.bound_params.borrow_mut() = Some(libsql_params);
+        Ok(())
+    }
+
+    fn execute(&self, args: &[Value]) -> Result<u64, Error> {
+        let params = if args.is_empty() {
+            self.bound_params
+                .borrow_mut()
+                .take()
+                .unwrap_or(libsql::params::Params::None)
+        } else {
+            let param_values = ruby_array_to_params(&args[0])?;
+            params_to_libsql(&param_values)
+        };
+
+        self.with_inner(|inner| {
+            // Reset before re-execution to allow statement reuse
+            inner.stmt.reset();
+            inner
+                .rt
+                .block_on(async { inner.stmt.execute(params).await })
+                .map(|n| n as u64)
+                .map_err(error::to_error)
+        })
+    }
+
+    fn query(&self, args: &[Value]) -> Result<Rows, Error> {
+        let params = if args.is_empty() {
+            self.bound_params
+                .borrow_mut()
+                .take()
+                .unwrap_or(libsql::params::Params::None)
+        } else {
+            let param_values = ruby_array_to_params(&args[0])?;
+            params_to_libsql(&param_values)
+        };
+
+        self.with_inner(|inner| {
+            // Reset before re-execution to allow statement reuse
+            inner.stmt.reset();
+            inner.rt.block_on(async {
+                let mut rows = inner.stmt.query(params).await.map_err(error::to_error)?;
+
+                let col_count = self.column_names.len();
+                let mut data = Vec::new();
+                while let Some(row) = rows.next().await.map_err(error::to_error)? {
+                    let mut row_data = Vec::with_capacity(col_count);
+                    for i in 0..col_count {
+                        let val = row.get_value(i as i32).map_err(error::to_error)?;
+                        row_data.push(val.into());
+                    }
+                    data.push(row_data);
+                }
+
+                Ok(Rows::new(
+                    self.column_names.clone(),
+                    self.column_types.clone(),
+                    data,
+                ))
+            })
+        })
+    }
+
+    fn reset(&self) -> Result<(), Error> {
+        self.with_inner(|inner| {
+            inner.stmt.reset();
+            Ok(())
+        })?;
+        *self.bound_params.borrow_mut() = None;
+        Ok(())
+    }
+
+    fn close(&self) -> Result<(), Error> {
+        let _ = self.inner.borrow_mut().take();
+        Ok(())
+    }
+
+    fn is_closed(&self) -> bool {
+        self.inner.borrow().is_none()
+    }
+}

data/lib/libsql/blob.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Libsql
+  class Blob < String
+    def initialize(data = "")
+      super
+      force_encoding(Encoding::ASCII_8BIT)
+    end
+  end
+end

data/lib/libsql/connection.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Libsql
+  class Connection
+    def transaction
+      execute("BEGIN")
+      result = yield self
+      execute("COMMIT")
+      result
+    rescue Exception # rubocop:disable Lint/RescueException
+      execute("ROLLBACK")
+      raise
+    end
+  end
+end

data/lib/libsql/database.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Libsql
+  class Database
+    class << self
+      alias _open open
+
+      def open(path, **opts)
+        db = opts.empty? ? _open(path) : _open(path, opts)
+        if block_given?
+          begin
+            yield db
+          ensure
+            db.close
+          end
+        else
+          db
+        end
+      end
+    end
+
+    alias _connect connect
+
+    def connect
+      conn = _connect
+      if block_given?
+        begin
+          yield conn
+        ensure
+          conn.close
+        end
+      else
+        conn
+      end
+    end
+  end
+end

data/lib/libsql/version.rb

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

data/lib/libsql2.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative "libsql/version"
+require_relative "libsql/blob"
+require_relative "libsql/libsql2"
+require_relative "libsql/connection"
+require_relative "libsql/database"

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: libsql2
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- speria-jp
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rb_sys
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: Native Ruby bindings for libSQL database, built with Rust (magnus + libsql
+  crate)
+executables: []
+extensions:
+- ext/libsql2/extconf.rb
+extra_rdoc_files: []
+files:
+- Cargo.lock
+- Cargo.toml
+- LICENSE
+- README.md
+- ext/libsql2/Cargo.toml
+- ext/libsql2/extconf.rb
+- ext/libsql2/src/connection.rs
+- ext/libsql2/src/database.rs
+- ext/libsql2/src/error.rs
+- ext/libsql2/src/lib.rs
+- ext/libsql2/src/rows.rs
+- ext/libsql2/src/statement.rs
+- lib/libsql/blob.rb
+- lib/libsql/connection.rb
+- lib/libsql/database.rb
+- lib/libsql/version.rb
+- lib/libsql2.rb
+homepage: https://github.com/speria-jp/libsql-ruby2
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: Ruby bindings for libSQL using libsql crate + magnus
+test_files: []