taskchampion-rb 0.9.1 → 0.9.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97cd610777ff12232ab4625cbbca59e2a9241d1789926dd9a5f21d982876f25d
-  data.tar.gz: d8b3232d7fe7fe9cdc518136e08e7b3873683c90ac32cf62e1947179f53ded8c
+  metadata.gz: 6d963e64502ad438957e3345671387a3915de84947a63bbcced83270f5c50848
+  data.tar.gz: 19309ecfe6ccf1a5a077a513a7b6ff769109ba7949c0282617b8b74e3b54f116
 SHA512:
-  metadata.gz: 61a011d70095d38bb2009a653fa151115b5327282977243cf6bc56947ab38d488b62a027470c363fe45ee40e17c5673f95857207ceb7d5f1d150b109dc60b469
-  data.tar.gz: 71e0d7baa33d944308f03d5ae5fb210b840b8834c7081980073e68f1649f2c21b86c0c7a39763a21f8c676019ae3d94bef1f82803071164c6963d59546c015c9
+  metadata.gz: '052509a0688871de92bc3d4219d7c257b712b7f4b7f5693f4e051d2ff38f891d5b6095d66aaf0cec8d06466ec272ec1fe5bd7e166dd790fb2a0c649592a29d4b'
+  data.tar.gz: f21cca16bd5da5921474361eb81d18937a1e328313a4c3dac2ea521ccc4d7b93cf356816d11e67abfa7292bbcfb76e40548766b94718030e42a315a80c3e5531

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())
         })
@@ -360,7 +358,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 +385,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 +407,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(())
     }

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.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: taskchampion-rb
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.9.2
 platform: ruby
 authors:
 - Tim Case