taskchampion-rb 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '029205bd9244f841d99e2913b09dd0e631ef11c28e3ddbc4745d54c9731248ad'
-  data.tar.gz: 45c862f0b82dba0187025aaee04c85be748aa9f24a17f28428dbd9ff9827b710
+  metadata.gz: c7110e37a7e2a8af13267d10879260e10b920b1ba49c3d9f5b124cc7d618862b
+  data.tar.gz: '029792b10587e8a680b80936e1156ac2e1a15d2ba19970219b4f1d5496570bc7'
 SHA512:
-  metadata.gz: 9379b9c99bb21c7a23beeda1f92756f31f22543b05600e11302650575063e52fe23c99a49b8a51c875f602e4d88f022aaf11681232a2a66fe1201f44116d3055
-  data.tar.gz: 0745ae9e0c8350b27318c7bd741d4dfaf92921c714b396f2bfeb3c277a8d89260aa53fe2a99c63b036e65e36e9e365398ffd0729ca5bc64b209266f80ba49e0f
+  metadata.gz: 7e7ba27d8a5202767273e9221d115640493dbba79b8de6563e0cfeb0d9d2c75945244f649d1874745c0c80fe769eb7efd089737843baf843c47dd3e649fa6db4
+  data.tar.gz: d75725f6f197a67195d290a44ebd045434c1ada09779551a2e3c08e8430e4cfd5c6266d86d000135bc444aea77ac945034cdb2218835d48f706e4b8961efea5f

data/.ruby-version

@@ -0,0 +1 @@
+3.2.0

data/README.md

@@ -2,11 +2,19 @@
 
 Ruby bindings for TaskChampion, the task database that powers Taskwarrior.
 
+## Ruby Version Support (2025-08-12)
+
+This gem supports Ruby 3.2 and later. We follow Ruby's end-of-life (EOL) schedule and drop support for Ruby versions that have reached EOL.
+
+- **Ruby 3.2**: Supported (EOL: March 2026)
+- **Ruby 3.3**: Supported (Current stable)
+- **Ruby 3.0-3.1**: Not supported (reached EOL)
+
 ## Installation
 
 ### Prerequisites
 
-1. Ruby 3.0 or later
+1. Ruby 3.2 or later
 2. Rust toolchain (install from https://rustup.rs/)
 
 ```bash

data/Rakefile

@@ -26,3 +26,17 @@ end
 task test: :compile
 
 task default: %i[compile test]
+
+desc "Bump version, create tag, and release gem"
+task :publish, [:version] do |t, args|
+  version = args[:version] || "patch"
+
+  puts "Bumping version (#{version})..."
+  sh "bump #{version} --tag"
+
+  puts "Pushing to git..."
+  sh "git push && git push --tags"
+
+  puts "Building and releasing gem..."
+  Rake::Task["release"].invoke
+end

data/docs/breakthrough.md

@@ -91,7 +91,7 @@ impl Replica {
         Ok(Replica(ThreadBound::new(replica))) // ✅ Wrapped in ThreadBound
     }
 
-    fn tasks(&self) -> Result<RHash, Error> {
+    fn all_tasks(&self) -> Result<RHash, Error> {
         let mut tc_replica = self.0.get_mut()?; // ✅ Thread check + access
         let tasks = tc_replica.all_tasks().map_err(into_error)?;
         // ... process tasks

data/docs/plan.md

@@ -453,7 +453,7 @@ task1.set_status(:pending)
 replica.commit_operations(operations)
 
 # Query tasks
-all_tasks = replica.tasks
+all_tasks = replica.all_tasks
 puts "Total tasks: #{all_tasks.size}"
 
 # Sync with server (if configured)

data/examples/basic_usage.rb

@@ -233,8 +233,143 @@ begin
     end
   end
 
-  # 10. FINAL STATISTICS
-  puts "\n10. Final Statistics"
+  # 10. UPDATING TASKS WITH TASKDATA
+  puts "\n10. Updating Tasks with TaskData"
+
+  # Create a new task to demonstrate TaskData updates
+  operations_update = Taskchampion::Operations.new
+  update_uuid = SecureRandom.uuid
+
+  puts "Creating task for TaskData update demo: #{update_uuid}"
+
+  # Create task using TaskData (low-level API)
+  task_data = Taskchampion::TaskData.create(update_uuid, operations_update)
+
+  # Set initial properties using TaskData
+  task_data.update("description", "Task for update demo", operations_update)
+  task_data.update("status", "pending", operations_update)
+  task_data.update("priority", "L", operations_update) # Low priority
+  task_data.update("project", "examples", operations_update)
+
+  # Commit initial task
+  replica.commit_operations(operations_update)
+  puts "Initial task created with TaskData API"
+
+  # Retrieve and display initial task
+  initial_task_data = replica.task_data(update_uuid)
+  if initial_task_data
+    puts "Initial task properties:"
+    initial_task_data.properties.each do |prop|
+      puts "  #{prop}: #{initial_task_data.get(prop)}"
+    end
+  end
+
+  # Update the task with new properties
+  update_operations = Taskchampion::Operations.new
+  retrieved_task_data = replica.task_data(update_uuid)
+
+  if retrieved_task_data
+    puts "\nUpdating task properties..."
+
+    # Update existing properties
+    retrieved_task_data.update("description", "Updated task description", update_operations)
+    retrieved_task_data.update("priority", "M", update_operations) # Medium priority
+
+    # Add new properties
+    retrieved_task_data.update("tags", "example,taskdata,demo", update_operations)
+    retrieved_task_data.update("estimate", "2h", update_operations)
+    retrieved_task_data.update("modified", Time.now.to_i.to_s, update_operations)
+
+    # Remove a property by setting it to nil
+    retrieved_task_data.update("project", nil, update_operations)
+
+    # Commit updates
+    replica.commit_operations(update_operations)
+    puts "Task updated successfully"
+
+    # Display updated task
+    updated_task_data = replica.task_data(update_uuid)
+    if updated_task_data
+      puts "Updated task properties:"
+      updated_task_data.properties.each do |prop|
+        puts "  #{prop}: #{updated_task_data.get(prop)}"
+      end
+
+      puts "Task hash representation:"
+      puts "  #{updated_task_data.to_hash}"
+    end
+  end
+
+  # 11. DELETING TASKS WITH TASKDATA
+  puts "\n11. Deleting Tasks with TaskData"
+
+  # Create a task specifically for deletion demo
+  delete_operations = Taskchampion::Operations.new
+  delete_uuid = SecureRandom.uuid
+
+  puts "Creating task for deletion demo: #{delete_uuid}"
+
+  # Create task to be deleted
+  deletable_task_data = Taskchampion::TaskData.create(delete_uuid, delete_operations)
+  deletable_task_data.update("description", "Task to be deleted", delete_operations)
+  deletable_task_data.update("status", "completed", delete_operations)
+  deletable_task_data.update("note", "This task will be deleted", delete_operations)
+
+  # Commit the task
+  replica.commit_operations(delete_operations)
+  puts "Task created for deletion"
+
+  # Verify task exists
+  before_delete = replica.task_data(delete_uuid)
+  if before_delete
+    puts "Task exists before deletion:"
+    puts "  Description: #{before_delete.get('description')}"
+    puts "  Status: #{before_delete.get('status')}"
+    puts "  Note: #{before_delete.get('note')}"
+    puts "  Properties: #{before_delete.properties.join(', ')}"
+  else
+    puts "ERROR: Task not found before deletion"
+  end
+
+  # Delete the task using TaskData.delete
+  final_delete_operations = Taskchampion::Operations.new
+  task_to_delete = replica.task_data(delete_uuid)
+
+  if task_to_delete
+    puts "\nDeleting task..."
+    task_to_delete.delete(final_delete_operations)
+
+    # Commit the deletion
+    replica.commit_operations(final_delete_operations)
+    puts "Task deletion committed"
+
+    # Verify task is deleted
+    after_delete = replica.task_data(delete_uuid)
+    if after_delete.nil?
+      puts "✓ Task successfully deleted - no longer exists in database"
+    else
+      puts "✗ Task still exists after deletion attempt"
+    end
+
+    # Also verify it's not in the task list
+    remaining_uuids = replica.task_uuids
+    if remaining_uuids.include?(delete_uuid)
+      puts "✗ Task UUID still found in task list"
+    else
+      puts "✓ Task UUID removed from task list"
+    end
+  else
+    puts "ERROR: Could not retrieve task for deletion"
+  end
+
+  # Show difference between task deletion and status update
+  puts "\nNote: TaskData.delete() completely removes the task from the database."
+  puts "This is different from setting status to 'deleted', which keeps the task"
+  puts "but marks it as deleted. Use TaskData.delete() when you want to permanently"
+  puts "purge a task and all its data."
+
+  # 12. FINAL STATISTICS
+  puts "\n12. Final Statistics"
 
   # Refresh task list
   final_uuids = replica.task_uuids

data/examples/sync_workflow.rb

@@ -231,10 +231,10 @@ begin
     begin
       replica.sync_to_local(server_dir, avoid_snapshots: false)
       puts "  ✓ Post-work sync completed"
-      return true
+      true
     rescue => e
       puts "  ✗ Post-work sync failed: #{e.message}"
-      return false
+      false
     end
   end
 

data/ext/taskchampion/Cargo.toml

@@ -11,7 +11,7 @@ crate-type = ["cdylib"]
 
 [dependencies]
 magnus = { version = "0.7", features = ["rb-sys"] }
-rb-sys = "0.9"
+rb-sys = "0.9.103"
 taskchampion = "2.0"
 chrono = "0.4"
 uuid = "1.0"

data/ext/taskchampion/src/lib.rs

@@ -8,6 +8,7 @@ mod status;
 mod tag;
 mod annotation;
 mod task;
+mod task_data;
 mod operation;
 mod operations;
 mod replica;
@@ -31,6 +32,7 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     tag::init(&module)?;
     annotation::init(&module)?;
     task::init(&module)?;
+    task_data::init(&module)?;
     operation::init(&module)?;
     operations::init(&module)?;
     working_set::init(&module)?;

data/ext/taskchampion/src/replica.rs

@@ -6,6 +6,7 @@ use taskchampion::{Replica as TCReplica, ServerConfig, StorageConfig};
 use crate::access_mode::AccessMode;
 use crate::operations::Operations;
 use crate::task::Task;
+use crate::task_data::TaskData;
 use crate::working_set::WorkingSet;
 use crate::dependency_map::DependencyMap;
 use crate::thread_check::ThreadBound;
@@ -77,7 +78,7 @@ impl Replica {
         Ok(())
     }
 
-    fn tasks(&self) -> Result<RHash, Error> {
+    fn all_tasks(&self) -> Result<RHash, Error> {
         let mut tc_replica = self.0.get_mut()?;
 
         let tasks = tc_replica.all_tasks().map_err(into_error)?;
@@ -99,9 +100,9 @@ impl Replica {
             .get_task_data(uuid2tc(&uuid)?)
             .map_err(into_error)?;
 
-        option_to_ruby(task_data, |_data| {
-            // TODO: Convert task data to Ruby TaskData object
-            Ok(().into_value()) // () converts to nil in Magnus
+        option_to_ruby(task_data, |data| {
+            let ruby_task_data = TaskData::from_tc_task_data(data);
+            Ok(ruby_task_data.into_value())
         })
     }
 
@@ -271,7 +272,7 @@ pub fn init(module: &RModule) -> Result<(), Error> {
     // Instance methods
     class.define_method("create_task", method!(Replica::create_task, 2))?;
     class.define_method("commit_operations", method!(Replica::commit_operations, 1))?;
-    class.define_method("tasks", method!(Replica::tasks, 0))?;
+    class.define_method("all_tasks", method!(Replica::all_tasks, 0))?;
     class.define_method("task", method!(Replica::task, 1))?;
     class.define_method("task_data", method!(Replica::task_data, 1))?;
     class.define_method("task_uuids", method!(Replica::task_uuids, 0))?;

data/ext/taskchampion/src/task_data.rs

@@ -0,0 +1,124 @@
+use magnus::{
+    class, function, method, prelude::*, Error, IntoValue, RArray, RHash, RModule, Value,
+};
+use taskchampion::TaskData as TCTaskData;
+
+use crate::operations::Operations;
+use crate::thread_check::ThreadBound;
+use crate::util::{option_to_ruby, uuid2tc, vec_to_ruby};
+
+#[magnus::wrap(class = "Taskchampion::TaskData", free_immediately)]
+pub struct TaskData(ThreadBound<TCTaskData>);
+
+impl TaskData {
+    pub fn from_tc_task_data(tc_task_data: TCTaskData) -> Self {
+        TaskData(ThreadBound::new(tc_task_data))
+    }
+
+
+    fn inspect(&self) -> Result<String, Error> {
+        let task_data = self.0.get()?;
+        Ok(format!("#<Taskchampion::TaskData: {}>", task_data.get_uuid()))
+    }
+
+    fn uuid(&self) -> Result<String, Error> {
+        let task_data = self.0.get()?;
+        Ok(task_data.get_uuid().to_string())
+    }
+
+    fn get(&self, property: String) -> Result<Value, Error> {
+        let task_data = self.0.get()?;
+        option_to_ruby(task_data.get(&property), |s| Ok(s.into_value()))
+    }
+
+    fn has(&self, property: String) -> Result<bool, Error> {
+        let task_data = self.0.get()?;
+        Ok(task_data.has(&property))
+    }
+
+    fn properties(&self) -> Result<RArray, Error> {
+        let task_data = self.0.get()?;
+        let props: Vec<String> = task_data.properties().cloned().collect();
+        vec_to_ruby(props, |s| Ok(s.into_value()))
+    }
+
+    fn to_hash(&self) -> Result<RHash, Error> {
+        let task_data = self.0.get()?;
+        let hash = RHash::new();
+        
+        for (key, value) in task_data.iter() {
+            hash.aset(key.clone(), value.clone())?;
+        }
+        
+        Ok(hash)
+    }
+
+    fn update(&self, property: String, value: Value, operations: &Operations) -> Result<(), Error> {
+        if property.trim().is_empty() {
+            return Err(Error::new(
+                crate::error::validation_error(),
+                "Property name cannot be empty or whitespace-only"
+            ));
+        }
+
+        let mut task_data = self.0.get_mut()?;
+        let value_str = if value.is_nil() {
+            None
+        } else {
+            Some(value.to_string())
+        };
+
+        operations.with_inner_mut(|ops| {
+            task_data.update(&property, value_str, ops);
+            Ok(())
+        })?;
+
+        Ok(())
+    }
+
+    fn delete(&self, operations: &Operations) -> Result<(), Error> {
+        let mut task_data = self.0.get_mut()?;
+        
+        operations.with_inner_mut(|ops| {
+            task_data.delete(ops);
+            Ok(())
+        })?;
+
+        Ok(())
+    }
+}
+
+fn create_task_data(uuid: String, operations: &Operations) -> Result<TaskData, Error> {
+    let tc_uuid = uuid2tc(&uuid)?;
+    
+    // Create operations for TaskChampion
+    let mut tc_ops = taskchampion::Operations::new();
+    
+    // Create the TaskData
+    let tc_task_data = TCTaskData::create(tc_uuid, &mut tc_ops);
+    
+    // Add the resulting operations to the provided Operations object
+    operations.extend_from_tc(tc_ops.into_iter().collect())?;
+    
+    Ok(TaskData(ThreadBound::new(tc_task_data)))
+}
+
+pub fn init(module: &RModule) -> Result<(), Error> {
+    let class = module.define_class("TaskData", class::object())?;
+
+    // Class methods
+    class.define_singleton_method("create", function!(create_task_data, 2))?;
+
+    // Instance methods
+    class.define_method("inspect", method!(TaskData::inspect, 0))?;
+    class.define_method("uuid", method!(TaskData::uuid, 0))?;
+    class.define_method("get", method!(TaskData::get, 1))?;
+    class.define_method("has?", method!(TaskData::has, 1))?;
+    class.define_method("properties", method!(TaskData::properties, 0))?;
+    class.define_method("to_hash", method!(TaskData::to_hash, 0))?;
+    class.define_method("to_h", method!(TaskData::to_hash, 0))?;
+    class.define_method("update", method!(TaskData::update, 3))?;
+    class.define_method("delete", method!(TaskData::delete, 1))?;
+
+    Ok(())
+}

data/ext/taskchampion/src/util.rs

@@ -45,21 +45,34 @@ pub fn ruby_to_datetime(value: Value) -> Result<DateTime<Utc>, Error> {
                 format!("Invalid datetime format: '{}'. Expected ISO 8601 format (e.g., '2023-01-01T12:00:00Z') or '%Y-%m-%d %H:%M:%S %z'", s)
             ))
     } else {
-        // Convert Ruby DateTime/Time to ISO string then parse
-        match value.funcall::<_, (), String>("iso8601", ()) {
-            Ok(iso_string) => {
-                DateTime::parse_from_rfc3339(&iso_string)
-                    .map(|dt| dt.with_timezone(&Utc))
-                    .map_err(|_| Error::new(
-                        validation_error(),
-                        format!("Invalid datetime from Ruby object: '{}'. Unable to parse as ISO 8601", iso_string)
-                    ))
+        // Check if it's a Time object first (Time doesn't have iso8601 method)
+        let class = value.class();
+        let class_name = unsafe { class.name() };
+        let iso_string = if class_name == "Time" {
+            // For Time objects, use strftime to get ISO 8601-like format
+            value.funcall::<_, (&str,), String>("strftime", ("%Y-%m-%dT%H:%M:%S%z",))?
+        } else {
+            // For DateTime objects, use iso8601 method
+            match value.funcall::<_, (), String>("iso8601", ()) {
+                Ok(s) => s,
+                Err(_) => return Err(Error::new(
+                    validation_error(),
+                    format!("Cannot convert value to datetime. Expected Time, DateTime, or String, got: {}", class_name)
+                ))
             }
-            Err(_) => Err(Error::new(
+        };
+        
+        DateTime::parse_from_rfc3339(&iso_string)
+            .map(|dt| dt.with_timezone(&Utc))
+            .or_else(|_| {
+                // Try parsing the Time strftime format (%z gives +HHMM instead of +HH:MM)
+                DateTime::parse_from_str(&iso_string, "%Y-%m-%dT%H:%M:%S%z")
+                    .map(|dt| dt.with_timezone(&Utc))
+            })
+            .map_err(|_| Error::new(
                 validation_error(),
-                format!("Cannot convert value to datetime. Expected Time, DateTime, or String, got: {}", value.class().inspect())
+                format!("Invalid datetime from Ruby object: '{}'. Unable to parse as ISO 8601", iso_string)
             ))
-        }
     }
 }
 

data/lib/taskchampion/version.rb

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

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: taskchampion-rb
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Tim Case
+autorequire:
 bindir: exe
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2025-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -32,8 +33,8 @@ extensions:
 - ext/taskchampion/extconf.rb
 extra_rdoc_files: []
 files:
-- ".claude/settings.local.json"
 - ".rubocop.yml"
+- ".ruby-version"
 - CHANGELOG.md
 - Cargo.lock
 - Cargo.toml
@@ -61,13 +62,12 @@ files:
 - ext/taskchampion/src/status.rs
 - ext/taskchampion/src/tag.rs
 - ext/taskchampion/src/task.rs
+- ext/taskchampion/src/task_data.rs
 - ext/taskchampion/src/thread_check.rs
 - ext/taskchampion/src/util.rs
 - ext/taskchampion/src/working_set.rs
 - lib/taskchampion.rb
 - lib/taskchampion/version.rb
-- sig/taskchampion.rbs
-- taskchampion-0.2.0.gem
 homepage: https://github.com/timcase/taskchampion-rb
 licenses:
 - MIT
@@ -76,6 +76,7 @@ metadata:
   homepage_uri: https://github.com/timcase/taskchampion-rb
   source_code_uri: https://github.com/timcase/taskchampion-rb
   changelog_uri: https://github.com/timcase/taskchampion-rb/blob/main/CHANGELOG.md
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -90,7 +91,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 3.3.11
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.4.1
+signing_key:
 specification_version: 4
 summary: Ruby bindings for TaskChampion
 test_files: []

data/.claude/settings.local.json

@@ -1,14 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(bundle exec rake:*)",
-      "mcp__zen__chat",
-      "mcp__zen__thinkdeep",
-      "WebFetch(domain:github.com)",
-      "WebFetch(domain:docs.taskwarrior.org)",
-      "Bash(chmod:*)",
-      "Bash(gem build:*)"
-    ],
-    "deny": []
-  }
-}

data/sig/taskchampion.rbs

@@ -1,4 +0,0 @@
-module Taskchampion
-  VERSION: String
-  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
-end