taskchampion-rb 0.2.0

data/ext/taskchampion/src/annotation.rs

@@ -0,0 +1,77 @@
+use magnus::{class, function, method, prelude::*, Error, RModule, Ruby, Value};
+use taskchampion::Annotation as TCAnnotation;
+use crate::util::{datetime_to_ruby, ruby_to_datetime};
+
+#[magnus::wrap(class = "Taskchampion::Annotation", free_immediately)]
+pub struct Annotation(TCAnnotation);
+
+impl Annotation {
+    fn new(_ruby: &Ruby, entry: Value, description: String) -> Result<Self, Error> {
+        let entry = ruby_to_datetime(entry)?;
+        Ok(Annotation(TCAnnotation { entry, description }))
+    }
+
+    fn entry(&self) -> Result<Value, Error> {
+        datetime_to_ruby(self.0.entry)
+    }
+
+    fn description(&self) -> String {
+        self.0.description.clone()
+    }
+
+    fn inspect(&self) -> Result<String, Error> {
+        let entry_str = self.0.entry.to_rfc3339();
+        Ok(format!("#<Taskchampion::Annotation: {} \"{}\">", entry_str, self.0.description))
+    }
+
+    fn to_s(&self) -> String {
+        self.0.description.clone()
+    }
+
+    fn eql(&self, other: &Annotation) -> bool {
+        self.0 == other.0
+    }
+
+    fn hash(&self) -> i64 {
+        use std::collections::hash_map::DefaultHasher;
+        use std::hash::{Hash, Hasher};
+
+        let mut hasher = DefaultHasher::new();
+        self.0.entry.hash(&mut hasher);
+        self.0.description.hash(&mut hasher);
+        hasher.finish() as i64
+    }
+}
+
+impl AsRef<TCAnnotation> for Annotation {
+    fn as_ref(&self) -> &TCAnnotation {
+        &self.0
+    }
+}
+
+impl From<TCAnnotation> for Annotation {
+    fn from(value: TCAnnotation) -> Self {
+        Annotation(value)
+    }
+}
+
+impl From<Annotation> for TCAnnotation {
+    fn from(value: Annotation) -> Self {
+        value.0
+    }
+}
+
+pub fn init(module: &RModule) -> Result<(), Error> {
+    let class = module.define_class("Annotation", class::object())?;
+
+    class.define_singleton_method("new", function!(Annotation::new, 2))?;
+    class.define_method("entry", method!(Annotation::entry, 0))?;
+    class.define_method("description", method!(Annotation::description, 0))?;
+    class.define_method("inspect", method!(Annotation::inspect, 0))?;
+    class.define_method("to_s", method!(Annotation::to_s, 0))?;
+    class.define_method("eql?", method!(Annotation::eql, 1))?;
+    class.define_method("==", method!(Annotation::eql, 1))?;
+    class.define_method("hash", method!(Annotation::hash, 0))?;
+
+    Ok(())
+}

data/ext/taskchampion/src/dependency_map.rs

@@ -0,0 +1,65 @@
+use magnus::{
+    class, method, prelude::*, Error, IntoValue, RArray, RModule,
+};
+use std::sync::Arc;
+use taskchampion::DependencyMap as TCDependencyMap;
+
+use crate::thread_check::ThreadBound;
+use crate::util::{uuid2tc, vec_to_ruby};
+
+#[magnus::wrap(class = "Taskchampion::DependencyMap", free_immediately)]
+pub struct DependencyMap(ThreadBound<Arc<TCDependencyMap>>);
+
+impl DependencyMap {
+    pub fn from_tc_dependency_map(tc_dependency_map: Arc<TCDependencyMap>) -> Self {
+        DependencyMap(ThreadBound::new(tc_dependency_map))
+    }
+
+    fn dependencies(&self, uuid: String) -> Result<RArray, Error> {
+        let dep_map = self.0.get()?;
+        let tc_uuid = uuid2tc(&uuid)?;
+
+        let deps: Vec<String> = dep_map
+            .dependencies(tc_uuid)
+            .map(|uuid| uuid.to_string())
+            .collect();
+
+        vec_to_ruby(deps, |s| Ok(s.into_value()))
+    }
+
+    fn dependents(&self, uuid: String) -> Result<RArray, Error> {
+        let dep_map = self.0.get()?;
+        let tc_uuid = uuid2tc(&uuid)?;
+
+        let deps: Vec<String> = dep_map
+            .dependents(tc_uuid)
+            .map(|uuid| uuid.to_string())
+            .collect();
+
+        vec_to_ruby(deps, |s| Ok(s.into_value()))
+    }
+
+    fn has_dependency(&self, uuid: String) -> Result<bool, Error> {
+        let dep_map = self.0.get()?;
+        let tc_uuid = uuid2tc(&uuid)?;
+
+        // Check if this UUID has any dependencies
+        let result = dep_map.dependencies(tc_uuid).next().is_some();
+        Ok(result)
+    }
+
+    fn inspect(&self) -> Result<String, Error> {
+        Ok("#<Taskchampion::DependencyMap>".to_string())
+    }
+}
+
+pub fn init(module: &RModule) -> Result<(), Error> {
+    let class = module.define_class("DependencyMap", class::object())?;
+
+    class.define_method("dependencies", method!(DependencyMap::dependencies, 1))?;
+    class.define_method("dependents", method!(DependencyMap::dependents, 1))?;
+    class.define_method("has_dependency?", method!(DependencyMap::has_dependency, 1))?;
+    class.define_method("inspect", method!(DependencyMap::inspect, 0))?;
+
+    Ok(())
+}

data/ext/taskchampion/src/error.rs

@@ -0,0 +1,78 @@
+use magnus::{exception, prelude::*, Error, RModule};
+
+pub fn init_errors(module: &RModule) -> Result<(), Error> {
+    let error_class = module.define_error("Error", exception::standard_error())?;
+    module.define_error("ThreadError", error_class)?;
+    module.define_error("StorageError", error_class)?;
+    module.define_error("ValidationError", error_class)?;
+    module.define_error("ConfigError", error_class)?;
+    module.define_error("SyncError", error_class)?;
+    Ok(())
+}
+
+pub fn thread_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>("ThreadError")
+        .expect("ThreadError class not initialized")
+}
+
+pub fn storage_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>("StorageError")
+        .expect("StorageError class not initialized")
+}
+
+pub fn validation_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>("ValidationError")
+        .expect("ValidationError class not initialized")
+}
+
+pub fn config_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>("ConfigError")
+        .expect("ConfigError class not initialized")
+}
+
+pub fn sync_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>("SyncError")
+        .expect("SyncError class not initialized")
+}
+
+// Enhanced error mapping function with context-aware error types
+pub fn map_taskchampion_error(error: taskchampion::Error) -> Error {
+    let error_msg = error.to_string();
+
+    // Map TaskChampion errors to appropriate Ruby error types based on error content
+    if error_msg.contains("No such file") || error_msg.contains("Permission denied") ||
+       error_msg.contains("storage") || error_msg.contains("database") {
+        Error::new(storage_error(), format!("Storage error: {}", error_msg))
+    } else if error_msg.contains("sync") || error_msg.contains("server") ||
+              error_msg.contains("network") || error_msg.contains("remote") {
+        Error::new(sync_error(), format!("Synchronization error: {}", error_msg))
+    } else if error_msg.contains("config") || error_msg.contains("invalid config") {
+        Error::new(config_error(), format!("Configuration error: {}", error_msg))
+    } else if error_msg.contains("invalid") || error_msg.contains("parse") ||
+              error_msg.contains("format") || error_msg.contains("validation") {
+        Error::new(validation_error(), format!("Validation error: {}", error_msg))
+    } else {
+        // Generic TaskChampion error for unknown types
+        let ruby = magnus::Ruby::get().expect("Ruby not available");
+        let module = ruby.class_object().const_get::<_, RModule>("Taskchampion")
+            .expect("Taskchampion module not found");
+        let error_class = module.const_get::<_, magnus::ExceptionClass>("Error")
+            .expect("Error class not initialized");
+        Error::new(error_class, format!("TaskChampion error: {}", error_msg))
+    }
+}

data/ext/taskchampion/src/lib.rs

@@ -0,0 +1,41 @@
+use magnus::{Error, Ruby};
+
+mod error;
+mod thread_check;
+mod util;
+mod access_mode;
+mod status;
+mod tag;
+mod annotation;
+mod task;
+mod operation;
+mod operations;
+mod replica;
+mod working_set;
+mod dependency_map;
+
+use error::init_errors;
+
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    let module = ruby.define_module("Taskchampion")?;
+
+    // Initialize error classes
+    init_errors(&module)?;
+
+    // Initialize constants
+    access_mode::init(&module)?;
+    status::init(&module)?;
+
+    // Initialize classes
+    tag::init(&module)?;
+    annotation::init(&module)?;
+    task::init(&module)?;
+    operation::init(&module)?;
+    operations::init(&module)?;
+    working_set::init(&module)?;
+    dependency_map::init(&module)?;
+    replica::init(&module)?;
+
+    Ok(())
+}

data/ext/taskchampion/src/operation.rs

@@ -0,0 +1,234 @@
+use magnus::{
+    class, function, method, prelude::*, Error, IntoValue, RHash, RModule, Value,
+};
+use taskchampion::Operation as TCOperation;
+
+use crate::util::{datetime_to_ruby, ruby_to_datetime, ruby_to_hashmap, uuid2tc};
+
+#[magnus::wrap(class = "Taskchampion::Operation", free_immediately)]
+pub struct Operation(TCOperation);
+
+impl Operation {
+    fn create(uuid: String) -> Result<Self, Error> {
+        Ok(Operation(TCOperation::Create {
+            uuid: uuid2tc(&uuid)?,
+        }))
+    }
+
+    fn delete(uuid: String, old_task: RHash) -> Result<Self, Error> {
+        let old_task = ruby_to_hashmap(old_task)?;
+        Ok(Operation(TCOperation::Delete {
+            uuid: uuid2tc(&uuid)?,
+            old_task,
+        }))
+    }
+
+    fn update(
+        uuid: String,
+        property: String,
+        timestamp: Value,
+        old_value: Option<String>,
+        value: Option<String>,
+    ) -> Result<Self, Error> {
+        let timestamp = ruby_to_datetime(timestamp)?;
+        Ok(Operation(TCOperation::Update {
+            uuid: uuid2tc(&uuid)?,
+            property,
+            timestamp,
+            old_value,
+            value,
+        }))
+    }
+
+    fn undo_point() -> Self {
+        Operation(TCOperation::UndoPoint)
+    }
+
+    // Type checking methods
+    fn create_op(&self) -> bool {
+        matches!(self.0, TCOperation::Create { .. })
+    }
+
+    fn delete_op(&self) -> bool {
+        matches!(self.0, TCOperation::Delete { .. })
+    }
+
+    fn update_op(&self) -> bool {
+        matches!(self.0, TCOperation::Update { .. })
+    }
+
+    fn undo_point_op(&self) -> bool {
+        matches!(self.0, TCOperation::UndoPoint)
+    }
+
+    fn operation_type(&self) -> magnus::Symbol {
+        match &self.0 {
+            TCOperation::Create { .. } => magnus::Symbol::new("create"),
+            TCOperation::Delete { .. } => magnus::Symbol::new("delete"),
+            TCOperation::Update { .. } => magnus::Symbol::new("update"),
+            TCOperation::UndoPoint => magnus::Symbol::new("undo_point"),
+        }
+    }
+
+    // Getters for each variant
+    fn uuid(&self) -> Result<String, Error> {
+        match &self.0 {
+            TCOperation::Create { uuid } => Ok(uuid.to_string()),
+            TCOperation::Delete { uuid, .. } => Ok(uuid.to_string()),
+            TCOperation::Update { uuid, .. } => Ok(uuid.to_string()),
+            TCOperation::UndoPoint => Err(Error::new(
+                magnus::exception::arg_error(),
+                "UndoPoint operations do not have a uuid",
+            )),
+        }
+    }
+
+    fn old_task(&self) -> Result<RHash, Error> {
+        match &self.0 {
+            TCOperation::Delete { old_task, .. } => {
+                let hash = RHash::new();
+                for (k, v) in old_task {
+                    hash.aset(k.clone(), v.clone())?;
+                }
+                Ok(hash)
+            }
+            _ => Err(Error::new(
+                magnus::exception::arg_error(),
+                "Only Delete operations have old_task",
+            )),
+        }
+    }
+
+    fn property(&self) -> Result<String, Error> {
+        match &self.0 {
+            TCOperation::Update { property, .. } => Ok(property.clone()),
+            _ => Err(Error::new(
+                magnus::exception::arg_error(),
+                "Only Update operations have property",
+            )),
+        }
+    }
+
+    fn timestamp(&self) -> Result<Value, Error> {
+        match &self.0 {
+            TCOperation::Update { timestamp, .. } => datetime_to_ruby(*timestamp),
+            _ => Err(Error::new(
+                magnus::exception::arg_error(),
+                "Only Update operations have timestamp",
+            )),
+        }
+    }
+
+    fn old_value(&self) -> Result<Value, Error> {
+        match &self.0 {
+            TCOperation::Update { old_value, .. } => match old_value {
+                Some(val) => Ok(val.clone().into_value()),
+                None => Ok(().into_value()), // () converts to nil in Magnus
+            },
+            _ => Err(Error::new(
+                magnus::exception::arg_error(),
+                "Only Update operations have old_value",
+            )),
+        }
+    }
+
+    fn value(&self) -> Result<Value, Error> {
+        match &self.0 {
+            TCOperation::Update { value, .. } => match value {
+                Some(val) => Ok(val.clone().into_value()),
+                None => Ok(().into_value()), // () converts to nil in Magnus
+            },
+            _ => Err(Error::new(
+                magnus::exception::arg_error(),
+                "Only Update operations have value",
+            )),
+        }
+    }
+
+    fn to_s(&self) -> String {
+        match &self.0 {
+            TCOperation::Create { uuid } => {
+                format!("Create task {}", uuid)
+            }
+            TCOperation::Delete { uuid, .. } => {
+                format!("Delete task {}", uuid)
+            }
+            TCOperation::Update { uuid, property, value, old_value, .. } => {
+                let value_desc = match (old_value, value) {
+                    (Some(old), Some(new)) => format!("from '{}' to '{}'", old, new),
+                    (Some(old), None) => format!("from '{}' to nil", old),
+                    (None, Some(new)) => format!("to '{}'", new),
+                    (None, None) => "to nil".to_string(),
+                };
+                format!("Update task {} property '{}' {}", uuid, property, value_desc)
+            }
+            TCOperation::UndoPoint => {
+                "Undo point".to_string()
+            }
+        }
+    }
+
+    fn inspect(&self) -> String {
+        match &self.0 {
+            TCOperation::Create { uuid } => {
+                format!("#<Taskchampion::Operation::Create uuid={}>", uuid)
+            }
+            TCOperation::Delete { uuid, .. } => {
+                format!("#<Taskchampion::Operation::Delete uuid={}>", uuid)
+            }
+            TCOperation::Update { uuid, property, .. } => {
+                format!("#<Taskchampion::Operation::Update uuid={} property={}>", uuid, property)
+            }
+            TCOperation::UndoPoint => {
+                "#<Taskchampion::Operation::UndoPoint>".to_string()
+            }
+        }
+    }
+}
+
+impl AsRef<TCOperation> for Operation {
+    fn as_ref(&self) -> &TCOperation {
+        &self.0
+    }
+}
+
+impl From<TCOperation> for Operation {
+    fn from(value: TCOperation) -> Self {
+        Operation(value)
+    }
+}
+
+impl From<Operation> for TCOperation {
+    fn from(value: Operation) -> Self {
+        value.0
+    }
+}
+
+pub fn init(module: &RModule) -> Result<(), Error> {
+    let class = module.define_class("Operation", class::object())?;
+
+    // Class methods for creating operations
+    class.define_singleton_method("create", function!(Operation::create, 1))?;
+    class.define_singleton_method("delete", function!(Operation::delete, 2))?;
+    class.define_singleton_method("update", function!(Operation::update, 5))?;
+    class.define_singleton_method("undo_point", function!(Operation::undo_point, 0))?;
+
+    // Type checking methods
+    class.define_method("create?", method!(Operation::create_op, 0))?;
+    class.define_method("delete?", method!(Operation::delete_op, 0))?;
+    class.define_method("update?", method!(Operation::update_op, 0))?;
+    class.define_method("undo_point?", method!(Operation::undo_point_op, 0))?;
+    class.define_method("operation_type", method!(Operation::operation_type, 0))?;
+
+    // Getter methods
+    class.define_method("uuid", method!(Operation::uuid, 0))?;
+    class.define_method("old_task", method!(Operation::old_task, 0))?;
+    class.define_method("property", method!(Operation::property, 0))?;
+    class.define_method("timestamp", method!(Operation::timestamp, 0))?;
+    class.define_method("old_value", method!(Operation::old_value, 0))?;
+    class.define_method("value", method!(Operation::value, 0))?;
+    class.define_method("to_s", method!(Operation::to_s, 0))?;
+    class.define_method("inspect", method!(Operation::inspect, 0))?;
+
+    Ok(())
+}

data/ext/taskchampion/src/operations.rs

@@ -0,0 +1,180 @@
+use magnus::{
+    class, function, method, prelude::*, Error, IntoValue, RArray, RModule, Ruby, Value,
+};
+use std::cell::RefCell;
+use taskchampion::Operations as TCOperations;
+
+use crate::operation::Operation;
+use crate::thread_check::ThreadBound;
+
+#[magnus::wrap(class = "Taskchampion::Operations", free_immediately)]
+pub struct Operations(ThreadBound<RefCell<TCOperations>>);
+
+impl Operations {
+    fn new(_ruby: &Ruby) -> Self {
+        Operations(ThreadBound::new(RefCell::new(TCOperations::new())))
+    }
+
+    fn push(&self, operation: &Operation) -> Result<(), Error> {
+        let ops = self.0.get()?;
+        ops.borrow_mut().push(operation.as_ref().clone());
+        Ok(())
+    }
+
+    fn len(&self) -> Result<usize, Error> {
+        let ops = self.0.get()?;
+        let borrowed = ops.borrow();
+        Ok(borrowed.len())
+    }
+
+    fn empty(&self) -> Result<bool, Error> {
+        let ops = self.0.get()?;
+        let borrowed = ops.borrow();
+        Ok(borrowed.is_empty())
+    }
+
+    fn get(&self, index: isize) -> Result<Value, Error> {
+        let ops = self.0.get()?;
+        let ops = ops.borrow();
+        let len = ops.len() as isize;
+
+        // Handle negative indices (Ruby-style)
+        let actual_index = if index < 0 {
+            len + index
+        } else {
+            index
+        };
+
+        // Check bounds - return nil instead of raising for Ruby compatibility
+        if actual_index < 0 || actual_index >= len {
+            let ruby = magnus::Ruby::get().map_err(|e| Error::new(
+                magnus::exception::runtime_error(),
+                e.to_string(),
+            ))?;
+            return Ok(ruby.qnil().into_value());  // Return nil
+        }
+
+        let operation = Operation::from(ops[actual_index as usize].clone());
+        Ok(operation.into_value())
+    }
+
+    fn each(&self) -> Result<Value, Error> {
+        let ruby = magnus::Ruby::get().map_err(|e| Error::new(
+            magnus::exception::runtime_error(),
+            format!("Failed to get Ruby context: {}", e),
+        ))?;
+
+        // Check if a block was given
+        if ruby.block_given() {
+            let ops = self.0.get()?;
+            let ops = ops.borrow();
+            let block = ruby.block_proc()?;
+
+            for op in ops.iter() {
+                let operation = Operation::from(op.clone());
+                block.call::<_, Value>((operation,))?;
+            }
+
+            // Ruby's each method returns self when called with a block
+            let ruby = magnus::Ruby::get().unwrap();
+            Ok(ruby.qnil().into_value())
+        } else {
+            // No block given, return an enumerator (or array for simplicity)
+            self.to_array()
+        }
+    }
+
+    fn to_array(&self) -> Result<Value, Error> {
+        let array = RArray::new();
+        let ops = self.0.get()?;
+        let ops = ops.borrow();
+
+        for op in ops.iter() {
+            let operation = Operation::from(op.clone());
+            // Magnus handles wrapping automatically
+            array.push(operation)?;
+        }
+
+        Ok(array.into_value())
+    }
+
+    fn inspect(&self) -> Result<String, Error> {
+        let ops = self.0.get()?;
+        Ok(format!("#<Taskchampion::Operations: {} operations>", ops.borrow().len()))
+    }
+
+    fn clear(&self) -> Result<(), Error> {
+        let ops = self.0.get()?;
+        ops.borrow_mut().clear();
+        Ok(())
+    }
+
+    // Internal method for accessing the operations
+    pub(crate) fn clone_inner(&self) -> Result<TCOperations, Error> {
+        let ops = self.0.get()?;
+        let borrowed = ops.borrow();
+        Ok(borrowed.clone())
+    }
+
+    pub(crate) fn with_inner_mut<T, F>(&self, f: F) -> Result<T, Error>
+    where
+        F: FnOnce(&mut TCOperations) -> Result<T, taskchampion::Error>,
+    {
+        let ops = self.0.get()?;
+        let mut ops = ops.borrow_mut();
+        f(&mut *ops).map_err(|e| Error::new(
+            magnus::exception::runtime_error(),
+            e.to_string(),
+        ))
+    }
+
+    // Internal method for pushing operations from TaskChampion
+    pub(crate) fn extend_from_tc(&self, tc_ops: Vec<taskchampion::Operation>) -> Result<(), Error> {
+        let ops = self.0.get()?;
+        let mut ops = ops.borrow_mut();
+        for op in tc_ops {
+            ops.push(op);
+        }
+        Ok(())
+    }
+}
+
+// Note: AsRef and AsMut cannot be implemented with RefCell
+// as they require returning references with the lifetime of self.
+// Instead, we'll provide methods to work with the inner value.
+
+impl From<TCOperations> for Operations {
+    fn from(value: TCOperations) -> Self {
+        Operations(ThreadBound::new(RefCell::new(value)))
+    }
+}
+
+impl From<Operations> for TCOperations {
+    fn from(value: Operations) -> Self {
+        // This implementation will panic if called from wrong thread
+        // but that's appropriate for ThreadBound behavior
+        let cell = match value.0.into_inner() {
+            Ok(cell) => cell,
+            Err(_) => panic!("Attempted to extract Operations from wrong thread"),
+        };
+        cell.into_inner()
+    }
+}
+
+pub fn init(module: &RModule) -> Result<(), Error> {
+    let class = module.define_class("Operations", class::object())?;
+
+    class.define_singleton_method("new", function!(Operations::new, 0))?;
+    class.define_method("push", method!(Operations::push, 1))?;
+    class.define_method("<<", method!(Operations::push, 1))?;
+    class.define_method("length", method!(Operations::len, 0))?;
+    class.define_method("size", method!(Operations::len, 0))?;
+    class.define_method("empty?", method!(Operations::empty, 0))?;
+    class.define_method("[]", method!(Operations::get, 1))?;
+    class.define_method("each", method!(Operations::each, 0))?;
+    class.define_method("to_a", method!(Operations::to_array, 0))?;
+    class.define_method("inspect", method!(Operations::inspect, 0))?;
+    class.define_method("clear", method!(Operations::clear, 0))?;
+
+    Ok(())
+}