lora-ruby 0.4.0 → 0.5.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f225172245d7983494a2d5d498edc749e31629b811453667be8517d7624fde0
-  data.tar.gz: 36e8d24e24003755b36abcf34354df4c7af42125d969c27c2e76de551d2cb06d
+  metadata.gz: b5ba0aa4fc27617800ec4053cabef91152e7aeb369c37671b5b42c8b63262191
+  data.tar.gz: 68db7428ccf49b03dddf70bfe430c92388269060653541819c19bcebd120db38
 SHA512:
-  metadata.gz: 48356ff0802ae5949f2d000580779c865b793dc562d8068deb92e72eefc7a2409fa9890b7a69ff336ef8c0ba2d67c27da57f253e6db2674920715b71320f7c07
-  data.tar.gz: 4446b8aac9ac26302ccb688784c6bd20f3e6f4ca80d6fb66525505c7022964f672cf9272876584672ce8b34a183708a50f9cc54e785ae75420394b365ecc43f2
+  metadata.gz: c25ead41256e9c1a7db8b9842f161d5c9efad153dc52da52323381d5eb380a9f81d616f5dba8bcc9f1e0bbca4a5010f5b57a6f0e09c048cc4ac0367bc30384a0
+  data.tar.gz: 891572a4890c93d4af1f92020e623724e3a7509340f29d6985f7a106e3e4ec0085c92aa08b98301219e4ca75cd45fe2062945bf51fe62f58c058ce5fd03dd08e

data/README.md

@@ -43,10 +43,10 @@ Initialization rule:
 
 ```ruby
 scratch = LoraRuby::Database.create         # in-memory
-persistent = LoraRuby::Database.create("./app") # persistent: directory string
+persistent = LoraRuby::Database.create("app", {"database_dir": "./data"}) # persistent: ./data/app.loradb
 ```
 
-If you want persistence, pass a directory string to
+If you want persistence, pass a database name and `database_dir` to
 `LoraRuby::Database.create(...)` or `LoraRuby::Database.new(...)`.
 
 ### Params
@@ -148,16 +148,16 @@ db.execute(
 
 ## 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
+`LoraRuby::Database.create("app", {"database_dir": "./data"})` and
+`LoraRuby::Database.new("app", { database_dir: "./data" })` open or create
+an archive-backed persistent database at `./data/app.loradb`. Reopening the same path
 replays committed writes before returning the handle.
 
-Call `db.close` before reopening the same WAL directory inside one
+Call `db.close` before reopening the same archive inside one
 process.
 
 This first Ruby persistence slice intentionally stays small: the
-binding exposes WAL-backed initialization plus the existing snapshot
+binding exposes archive-backed initialization plus the existing snapshot
 APIs, but not checkpoint, truncate, status, or sync-mode controls.
 
 ## Concurrency (GVL release)

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.4.0" unless const_defined?(:VERSION)
+  VERSION = "0.5.5" unless const_defined?(:VERSION)
 end

data/src/lib.rs

@@ -24,8 +24,8 @@ use magnus::{
 };
 
 use lora_database::{
-    Database as InnerDatabase, ExecuteOptions, InMemoryGraph, LoraValue, QueryResult, ResultFormat,
-    WalConfig,
+    Database as InnerDatabase, DatabaseOpenOptions, ExecuteOptions, InMemoryGraph, LoraValue,
+    QueryResult, ResultFormat,
 };
 use lora_store::{
     LoraDate, LoraDateTime, LoraDuration, LoraLocalDateTime, LoraLocalTime, LoraPoint, LoraTime,
@@ -138,8 +138,9 @@ impl Database {
 // singletons so callers can use whichever idiom they prefer; both are
 // cost-equivalent.
 fn database_new(ruby: &Ruby, args: &[Value]) -> Result<Database, MagnusError> {
-    let wal_dir = optional_wal_dir_arg(ruby, args)?;
-    let db = without_gvl(move || open_database(wal_dir)).map_err(|e| query_error(ruby, e))?;
+    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))
 }
 
@@ -233,28 +234,50 @@ fn snapshot_meta_to_rhash(
     Ok(h)
 }
 
-fn optional_wal_dir_arg(ruby: &Ruby, args: &[Value]) -> Result<Option<String>, MagnusError> {
+fn database_open_args(
+    ruby: &Ruby,
+    args: &[Value],
+) -> Result<(Option<String>, DatabaseOpenOptions), MagnusError> {
     match args.len() {
-        0 => Ok(None),
+        0 => Ok((None, DatabaseOpenOptions::default())),
         1 => {
             if args[0].is_nil() {
-                Ok(None)
+                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 {
-                Ok(Some(RString::try_convert(args[0])?.to_string()?))
+                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..1)"),
+            format!("wrong number of arguments (given {n}, expected 0..2)"),
         )),
     }
 }
 
-fn open_database(wal_dir: Option<String>) -> Result<Arc<InnerDatabase<InMemoryGraph>>, String> {
-    let db = match wal_dir {
-        Some(dir) => {
-            InnerDatabase::open_with_wal(WalConfig::enabled(dir)).map_err(|e| e.to_string())?
-        }
+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))

metadata

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