lora-ruby 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c27b39620c0d4484f27a0d1d80ca4bfe85fbf4a7cc9ee85866cdbc15a1f028f0
-  data.tar.gz: 6474c3321d2fef98b602deb92d184778861b4330217ebb882569cd3b828790cc
+  metadata.gz: 93108d86cc62dc1e96f8f4f486696b9b422a4ccf62119e56c79131df476a8144
+  data.tar.gz: a2d547e01de27be476b969c8cecfdaaf940eda38b58ea39a930a16bf57001c98
 SHA512:
-  metadata.gz: adad8d60ecf6a6df5f7156d0176d43b2981170a57bf7d2239554b94666dd06dcb8ff551c3487025cf2f3812d4465c0f4e5ecd912ed70af97f98474104e742e99
-  data.tar.gz: 63d8a74a82179146ef6dc0c9fc7ff2b30902cee5cda9a44d157953fd61a36b74c4a89a466d4a6f1b4336b2bd6ebcf6ea5dbc14c87a7e527ca999660497f2a90f
+  metadata.gz: 53a6ef06bc8d0e456d53100fde0ee2aeae43085d4923b65842f70b014360d7ab18025f70f7ac09a101fb7916cfabe0f385fa632cea1b8105440a24011ef657f7
+  data.tar.gz: 90f93b470012d15fb981e79db8ae47913396f95de2a7379e3258749ef5bbaab70b9712d480f268759c96a4e0996bbd1bed044b1406e1dac4ef76edf1aba9ad90

data/README.md

@@ -1,6 +1,6 @@
 # lora-ruby
 
-Ruby bindings for the [Lora](../../README.md) in-memory graph engine.
+Ruby bindings for the [Lora](../../README.md) graph engine.
 Ships a native extension built with [Magnus](https://github.com/matsadler/magnus)
 on top of [`rb-sys`](https://github.com/oxidize-rb/rb-sys) so the Rust
 engine runs in-process — no separate server, no socket hop.
@@ -39,6 +39,16 @@ result["rows"].each do |row|
 end
 ```
 
+Initialization rule:
+
+```ruby
+scratch = LoraRuby::Database.create         # in-memory
+persistent = LoraRuby::Database.create("./app") # persistent: directory string
+```
+
+If you want persistence, pass a directory string to
+`LoraRuby::Database.create(...)` or `LoraRuby::Database.new(...)`.
+
 ### Params
 
 `execute` accepts a second argument — either `nil` or a `Hash` keyed by
@@ -66,8 +76,8 @@ binding's `lora_python.Database` and because it mirrors the
 ## Public API
 
 ```ruby
-LoraRuby::Database.create            # -> Database
-LoraRuby::Database.new               # -> Database  (alias of .create)
+LoraRuby::Database.create(wal_dir = nil)  # -> Database
+LoraRuby::Database.new(wal_dir = nil)     # -> Database  (alias of .create)
 
 db.execute(query, params = nil)       # -> { "columns" => [...], "rows" => [...] }
 db.clear                              # -> nil
@@ -136,6 +146,20 @@ db.execute(
 - `LoraRuby::QueryError` — parse / analyze / execute failure.
 - `LoraRuby::InvalidParamsError` — a parameter value couldn't be mapped.
 
+## Persistence
+
+`LoraRuby::Database.create("./app")` and
+`LoraRuby::Database.new("./app")` open or create a WAL-backed
+persistent database rooted at that directory. Reopening the same path
+replays committed writes before returning the handle.
+
+Call `db.close` before reopening the same WAL directory inside one
+process.
+
+This first Ruby persistence slice intentionally stays small: the
+binding exposes WAL-backed initialization plus the existing snapshot
+APIs, but not checkpoint, truncate, status, or sync-mode controls.
+
 ## Concurrency (GVL release)
 
 `Database#execute` calls `rb_thread_call_without_gvl`, so other Ruby

data/lib/lora_ruby/version.rb

@@ -10,5 +10,5 @@ module LoraRuby
   # Guard against redefinition so re-requiring this file (or loading
   # both paths) doesn't emit a "warning: already initialized constant"
   # when the native extension loads second with the identical value.
-  VERSION = "0.3.0" unless const_defined?(:VERSION)
+  VERSION = "0.5.0" unless const_defined?(:VERSION)
 end

data/src/lib.rs

@@ -16,7 +16,7 @@
 use std::collections::BTreeMap;
 use std::ffi::c_void;
 use std::mem::MaybeUninit;
-use std::sync::Arc;
+use std::sync::{Arc, Mutex};
 
 use magnus::{
     function, method, prelude::*, r_hash::ForEach, value::ReprValue, Error as MagnusError,
@@ -24,7 +24,8 @@ use magnus::{
 };
 
 use lora_database::{
-    Database as InnerDatabase, ExecuteOptions, InMemoryGraph, LoraValue, QueryResult, ResultFormat,
+    Database as InnerDatabase, DatabaseOpenOptions, ExecuteOptions, InMemoryGraph, LoraValue,
+    QueryResult, ResultFormat,
 };
 use lora_store::{
     LoraDate, LoraDateTime, LoraDuration, LoraLocalDateTime, LoraLocalTime, LoraPoint, LoraTime,
@@ -60,10 +61,11 @@ fn init(ruby: &Ruby) -> Result<(), MagnusError> {
     lora_ruby.define_class("InvalidParamsError", error)?;
 
     let database = lora_ruby.define_class("Database", ruby.class_object())?;
-    database.define_singleton_method("create", function!(database_create, 0))?;
-    database.define_singleton_method("new", function!(database_new, 0))?;
+    database.define_singleton_method("create", function!(database_create, -1))?;
+    database.define_singleton_method("new", function!(database_new, -1))?;
     database.define_method("execute", method!(database_execute, -1))?;
     database.define_method("clear", method!(database_clear, 0))?;
+    database.define_method("close", method!(database_close, 0))?;
     database.define_method("node_count", method!(database_node_count, 0))?;
     database.define_method(
         "relationship_count",
@@ -114,20 +116,20 @@ fn invalid_params(ruby: &Ruby, msg: impl Into<String>) -> MagnusError {
 // Database
 // ============================================================================
 
-/// In-memory Lora graph database handle exposed to Ruby.
+/// Lora graph database handle exposed to Ruby.
 ///
 /// Wraps an `Arc<Database<InMemoryGraph>>`; the same handle is cloned
 /// across the GVL-release boundary for query execution without borrowing
 /// any Ruby state.
 #[magnus::wrap(class = "LoraRuby::Database", free_immediately, size)]
 struct Database {
-    db: Arc<InnerDatabase<InMemoryGraph>>,
+    db: Mutex<Option<Arc<InnerDatabase<InMemoryGraph>>>>,
 }
 
 impl Database {
-    fn empty() -> Self {
+    fn from_db(db: Arc<InnerDatabase<InMemoryGraph>>) -> Self {
         Self {
-            db: Arc::new(InnerDatabase::in_memory()),
+            db: Mutex::new(Some(db)),
         }
     }
 }
@@ -135,32 +137,53 @@ impl Database {
 // Constructors — we expose `Database.create` and `Database.new` as
 // singletons so callers can use whichever idiom they prefer; both are
 // cost-equivalent.
-fn database_new() -> Database {
-    Database::empty()
+fn database_new(ruby: &Ruby, args: &[Value]) -> Result<Database, MagnusError> {
+    let (database_name, options) = database_open_args(ruby, args)?;
+    let db = without_gvl(move || open_database(database_name, options))
+        .map_err(|e| query_error(ruby, e))?;
+    Ok(Database::from_db(db))
 }
 
-fn database_create() -> Database {
-    Database::empty()
+fn database_create(ruby: &Ruby, args: &[Value]) -> Result<Database, MagnusError> {
+    database_new(ruby, args)
 }
 
-fn database_clear(rb_self: &Database) {
-    rb_self.db.clear();
+fn database_clear(ruby: &Ruby, rb_self: &Database) -> Result<(), MagnusError> {
+    database_inner(ruby, rb_self)?.clear();
+    Ok(())
+}
+
+fn database_close(ruby: &Ruby, rb_self: &Database) -> Result<(), MagnusError> {
+    let mut slot = rb_self
+        .db
+        .lock()
+        .map_err(|_| query_error(ruby, "database lock poisoned"))?;
+    slot.take();
+    Ok(())
 }
 
-fn database_node_count(rb_self: &Database) -> u64 {
-    rb_self.db.node_count() as u64
+fn database_node_count(ruby: &Ruby, rb_self: &Database) -> Result<u64, MagnusError> {
+    Ok(database_inner(ruby, rb_self)?.node_count() as u64)
 }
 
-fn database_relationship_count(rb_self: &Database) -> u64 {
-    rb_self.db.relationship_count() as u64
+fn database_relationship_count(ruby: &Ruby, rb_self: &Database) -> Result<u64, MagnusError> {
+    Ok(database_inner(ruby, rb_self)?.relationship_count() as u64)
 }
 
 fn database_inspect(rb_self: &Database) -> String {
-    format!(
-        "#<LoraRuby::Database nodes={} relationships={}>",
-        rb_self.db.node_count(),
-        rb_self.db.relationship_count(),
-    )
+    match rb_self
+        .db
+        .lock()
+        .ok()
+        .and_then(|slot| slot.as_ref().cloned())
+    {
+        Some(db) => format!(
+            "#<LoraRuby::Database nodes={} relationships={}>",
+            db.node_count(),
+            db.relationship_count(),
+        ),
+        None => "#<LoraRuby::Database closed>".to_string(),
+    }
 }
 
 fn database_save_snapshot(
@@ -169,7 +192,7 @@ fn database_save_snapshot(
     path: RString,
 ) -> Result<RHash, MagnusError> {
     let path = path.to_string()?;
-    let db = Arc::clone(&rb_self.db);
+    let db = database_inner(ruby, rb_self)?;
     let meta = without_gvl(move || db.save_snapshot_to(&path))
         .map_err(|e| query_error(ruby, format!("{e}")))?;
     snapshot_meta_to_rhash(ruby, meta)
@@ -181,7 +204,7 @@ fn database_load_snapshot(
     path: RString,
 ) -> Result<RHash, MagnusError> {
     let path = path.to_string()?;
-    let db = Arc::clone(&rb_self.db);
+    let db = database_inner(ruby, rb_self)?;
     let meta = without_gvl(move || db.load_snapshot_from(&path))
         .map_err(|e| query_error(ruby, format!("{e}")))?;
     snapshot_meta_to_rhash(ruby, meta)
@@ -211,6 +234,68 @@ fn snapshot_meta_to_rhash(
     Ok(h)
 }
 
+fn database_open_args(
+    ruby: &Ruby,
+    args: &[Value],
+) -> Result<(Option<String>, DatabaseOpenOptions), MagnusError> {
+    match args.len() {
+        0 => Ok((None, DatabaseOpenOptions::default())),
+        1 => {
+            if args[0].is_nil() {
+                Ok((None, DatabaseOpenOptions::default()))
+            } else {
+                Ok((
+                    Some(RString::try_convert(args[0])?.to_string()?),
+                    DatabaseOpenOptions::default(),
+                ))
+            }
+        }
+        2 => {
+            let database_name = if args[0].is_nil() {
+                None
+            } else {
+                Some(RString::try_convert(args[0])?.to_string()?)
+            };
+            let mut options = DatabaseOpenOptions::default();
+            let hash = RHash::try_convert(args[1])?;
+            if let Some(dir) = hash_get_either(ruby, hash, "database_dir")
+                .or_else(|| hash_get_either(ruby, hash, "databaseDir"))
+            {
+                options.database_dir = RString::try_convert(dir)?.to_string()?.into();
+            }
+            Ok((database_name, options))
+        }
+        n => Err(MagnusError::new(
+            ruby.exception_arg_error(),
+            format!("wrong number of arguments (given {n}, expected 0..2)"),
+        )),
+    }
+}
+
+fn open_database(
+    database_name: Option<String>,
+    options: DatabaseOpenOptions,
+) -> Result<Arc<InnerDatabase<InMemoryGraph>>, String> {
+    let db = match database_name {
+        Some(name) => InnerDatabase::open_named(name, options).map_err(|e| e.to_string())?,
+        None => InnerDatabase::in_memory(),
+    };
+    Ok(Arc::new(db))
+}
+
+fn database_inner(
+    ruby: &Ruby,
+    rb_self: &Database,
+) -> Result<Arc<InnerDatabase<InMemoryGraph>>, MagnusError> {
+    let slot = rb_self
+        .db
+        .lock()
+        .map_err(|_| query_error(ruby, "database lock poisoned"))?;
+    slot.as_ref()
+        .cloned()
+        .ok_or_else(|| query_error(ruby, "database is closed"))
+}
+
 /// `execute(query, params = nil)` — `-1` arity so `params` is optional and
 /// we can distinguish "not passed" from `nil`/`{}` (both map to empty
 /// params). Everything that touches Ruby values happens under the GVL;
@@ -248,7 +333,7 @@ fn database_execute(ruby: &Ruby, rb_self: &Database, args: &[Value]) -> Result<R
     // Run the engine with the GVL released. Everything inside the closure
     // is pure Rust — no Ruby values cross the boundary — which keeps this
     // sound.
-    let db = Arc::clone(&rb_self.db);
+    let db = database_inner(ruby, rb_self)?;
     let exec_result = without_gvl(move || {
         let options = ExecuteOptions {
             format: ResultFormat::RowArrays,

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lora-ruby
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.0
 platform: ruby
 authors:
 - LoraDB, Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-24 00:00:00.000000000 Z
+date: 2026-04-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys