taskchampion-rb 0.9.1 → 0.9.3

data/ext/taskchampion/Cargo.toml

@@ -12,7 +12,7 @@ crate-type = ["cdylib"]
 [dependencies]
 magnus = { version = "0.7", features = ["rb-sys"] }
 rb-sys = "0.9.103"
-taskchampion = "2.0"
+taskchampion = { version = "2.0", default-features = false, features = ["server-sync", "server-gcp"] }
 chrono = "0.4"
 uuid = "1.0"
 

data/ext/taskchampion/src/error.rs

@@ -11,14 +11,6 @@ pub fn init_errors(module: &RModule) -> Result<(), Error> {
     Ok(())
 }
 
-pub fn base_error() -> magnus::ExceptionClass {
-    let ruby = magnus::Ruby::get().expect("Ruby not available");
-    let module = ruby.class_object().const_get::<_, RModule>("Taskchampion")
-        .expect("Taskchampion module not found");
-    module.const_get::<_, magnus::ExceptionClass>("Error")
-        .expect("Error class not initialized")
-}
-
 pub fn thread_error() -> magnus::ExceptionClass {
     let ruby = magnus::Ruby::get().expect("Ruby not available");
     let module = ruby.class_object().const_get::<_, RModule>("Taskchampion")

data/ext/taskchampion/src/replica.rs

@@ -58,7 +58,7 @@ impl Replica {
         let tc_task = tc_replica.create_task(tc_uuid, &mut tc_ops).map_err(into_error)?;
 
         // Add the resulting operations to the provided Operations object
-        operations.extend_from_tc(tc_ops);
+        operations.extend_from_tc(tc_ops)?;
 
         // Convert to Ruby Task object
         let task = Task::from_tc_task(tc_task);

data/ext/taskchampion/src/task.rs

@@ -137,24 +137,22 @@ impl Task {
 
     fn get_uda(&self, namespace: String, key: String) -> Result<Value, Error> {
         let task = self.0.get()?;
-        match task.get_uda(&namespace, &key) {
+        let combined_key = if namespace.is_empty() { key } else { format!("{}.{}", namespace, key) };
+        match task.get_user_defined_attribute(&combined_key) {
             Some(value) => Ok(value.into_value()),
-            None => Ok(().into_value()), // () converts to nil in Magnus
+            None => Ok(().into_value()),
         }
     }
 
     fn udas(&self) -> Result<RArray, Error> {
         let task = self.0.get()?;
-        let udas: Vec<((String, String), String)> = task.get_udas()
-            .map(|((ns, key), value)| ((ns.to_string(), key.to_string()), value.to_string()))
+        let udas: Vec<(String, String)> = task.get_user_defined_attributes()
+            .map(|(key, value)| (key.to_string(), value.to_string()))
             .collect();
 
-        vec_to_ruby(udas, |(key_tuple, value)| {
+        vec_to_ruby(udas, |(key, value)| {
             let array = RArray::new();
-            let key_array = RArray::new();
-            key_array.push(key_tuple.0)?;
-            key_array.push(key_tuple.1)?;
-            array.push(key_array)?;
+            array.push(key)?;
             array.push(value)?;
             Ok(array.into_value())
         })
@@ -305,6 +303,15 @@ impl Task {
         Ok(())
     }
 
+    fn set_modified(&self, modified: Value, operations: &crate::operations::Operations) -> Result<(), Error> {
+        let mut task = self.0.get_mut()?;
+        let modified_datetime = ruby_to_datetime(modified)?;
+        operations.with_inner_mut(|ops| {
+            task.set_modified(modified_datetime, ops)
+        })?;
+        Ok(())
+    }
+
     fn set_value(&self, property: String, value: Value, operations: &crate::operations::Operations) -> Result<(), Error> {
         if property.trim().is_empty() {
             return Err(Error::new(
@@ -360,7 +367,7 @@ impl Task {
             Some(timestamp_str) => {
                 // Parse the string as Unix timestamp (seconds since epoch)
                 if let Ok(timestamp_secs) = timestamp_str.parse::<i64>() {
-                    use chrono::{DateTime, Utc};
+                    use chrono::DateTime;
                     if let Some(dt) = DateTime::from_timestamp(timestamp_secs, 0) {
                         return datetime_to_ruby(dt);
                     }
@@ -387,8 +394,9 @@ impl Task {
         }
 
         let mut task = self.0.get_mut()?;
+        let combined_key = format!("{}.{}", namespace, key);
         operations.with_inner_mut(|ops| {
-            task.set_uda(&namespace, &key, &value, ops)
+            task.set_user_defined_attribute(&combined_key, &value, ops)
         })?;
         Ok(())
     }
@@ -408,8 +416,9 @@ impl Task {
         }
 
         let mut task = self.0.get_mut()?;
+        let combined_key = format!("{}.{}", namespace, key);
         operations.with_inner_mut(|ops| {
-            task.remove_uda(&namespace, &key, ops)
+            task.remove_user_defined_attribute(&combined_key, ops)
         })?;
         Ok(())
     }
@@ -480,6 +489,7 @@ pub fn init(module: &RModule) -> Result<(), Error> {
     class.define_method("add_annotation_with_timestamp", method!(Task::add_annotation_with_timestamp, 3))?;
     class.define_method("set_due", method!(Task::set_due, 2))?;
     class.define_method("set_entry", method!(Task::set_entry, 2))?;
+    class.define_method("set_modified", method!(Task::set_modified, 2))?;
     class.define_method("set_value", method!(Task::set_value, 3))?;
     class.define_method("set_timestamp", method!(Task::set_timestamp, 3))?;
     class.define_method("get_timestamp", method!(Task::get_timestamp, 1))?;

data/ext/taskchampion/src/thread_check.rs

@@ -32,12 +32,12 @@ impl<T> ThreadBound<T> {
         Ok(())
     }
 
-    pub fn get(&self) -> Result<std::cell::Ref<T>, Error> {
+    pub fn get(&self) -> Result<std::cell::Ref<'_, T>, Error> {
         self.check_thread()?;
         Ok(self.inner.borrow())
     }
 
-    pub fn get_mut(&self) -> Result<std::cell::RefMut<T>, Error> {
+    pub fn get_mut(&self) -> Result<std::cell::RefMut<'_, T>, Error> {
         self.check_thread()?;
         Ok(self.inner.borrow_mut())
     }

data/ext/taskchampion/src/util.rs

@@ -31,8 +31,6 @@ pub fn datetime_to_ruby(dt: DateTime<Utc>) -> Result<Value, Error> {
 
 /// Convert Ruby DateTime/Time/String to Rust DateTime<Utc> with enhanced validation
 pub fn ruby_to_datetime(value: Value) -> Result<DateTime<Utc>, Error> {
-    let ruby = magnus::Ruby::get().map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))?;
-
     // If it's a string, parse it
     if let Ok(s) = RString::try_convert(value) {
         let s = unsafe { s.as_str()? };
@@ -99,15 +97,6 @@ where
     }
 }
 
-/// Convert HashMap to Ruby Hash
-pub fn hashmap_to_ruby(map: HashMap<String, String>) -> Result<RHash, Error> {
-    let hash = RHash::new();
-    for (k, v) in map {
-        hash.aset(k, v)?;
-    }
-    Ok(hash)
-}
-
 /// Convert Ruby Hash to HashMap
 pub fn ruby_to_hashmap(hash: RHash) -> Result<HashMap<String, String>, Error> {
     let mut map = HashMap::new();
@@ -130,15 +119,3 @@ where
     Ok(array)
 }
 
-/// Convert Ruby Array to Vec
-pub fn ruby_to_vec<T, F>(array: RArray, converter: F) -> Result<Vec<T>, Error>
-where
-    F: Fn(Value) -> Result<T, Error>,
-{
-    let mut vec = Vec::with_capacity(array.len());
-    for i in 0..array.len() {
-        let value: Value = array.entry(i as isize)?;
-        vec.push(converter(value)?);
-    }
-    Ok(vec)
-}

data/lib/taskchampion/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Taskchampion
-  VERSION = "0.9.1"
+  VERSION = "0.9.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: taskchampion-rb
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.9.3
 platform: ruby
 authors:
 - Tim Case
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-23 00:00:00.000000000 Z
+date: 2026-05-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -41,10 +41,10 @@ files:
 - Cargo.toml
 - README.md
 - Rakefile
-- TaskchampionRbErrors.md
 - docs/ANNOTATION_IMPLEMENTATION.md
 - docs/API_REFERENCE.md
 - docs/THREAD_SAFETY.md
+- docs/TaskchampionRbErrors.md
 - docs/breakthrough.md
 - docs/date_conversion_analysis.md
 - docs/description.md