Something went wrong. Try again.
A git-based task manager
Something went wrong. Try again.
Rust
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300//! A queue: an ordered list of tasks plus an inbox of pending assignments.//!//! Stored as a commit chain at `refs/tsk/queues/<name>`. Tree layout://! index → blob: ordered stable ids (one per line, top-of-stack first)//! can-pull → blob: "true" or "false" (defaults: true for `tsk`, false otherwise)//! inbox/<src>-<n> → blob: stable id of a task assigned by queue <src>//!//! Queues are pushed/shared (refspec `refs/tsk/*`). The active queue per-user//! is selected by `<git-dir>/tsk/queue`.
use crate::errors::{Error, Result};use crate::object::{self, StableId};use git2::{Oid, Repository};use std::collections::BTreeMap;
pub const QUEUE_REF_PREFIX: &str = "refs/tsk/queues/";pub const DEFAULT_QUEUE: &str = "tsk";const INDEX_FILE: &str = "index";const CAN_PULL_FILE: &str = "can-pull";const INBOX_DIR: &str = "inbox";
pub fn refname(name: &str) -> String { format!("{QUEUE_REF_PREFIX}{name}")}
pub fn validate_name(name: &str) -> Result<()> { if name.is_empty() { return Err(Error::Parse("Queue name cannot be empty".into())); } if !name .chars() .all(|c| c.is_alphanumeric() || c == '_' || c == '-') { return Err(Error::Parse(format!( "Queue '{name}' must contain only alphanumerics, '-', or '_'" ))); } Ok(())}
#[derive(Clone, Debug, Eq, PartialEq)]pub struct Queue { /// top-of-stack first pub index: Vec<StableId>, pub can_pull: bool, /// inbox key → stable id of the task being offered pub inbox: BTreeMap<String, StableId>,}
impl Queue { pub fn new(name: &str) -> Self { Self { index: Vec::new(), can_pull: name == DEFAULT_QUEUE, inbox: BTreeMap::new(), } }}
pub fn read(repo: &Repository, name: &str) -> Result<Queue> { let Some(target) = repo.find_reference(&refname(name)).ok().and_then(|r| r.target()) else { return Ok(Queue::new(name)); }; read_at_commit(repo, name, target)}
/// Read a queue from the tree of a specific commit (used by the queue/// merge driver to compare local and fetched-remote tips).pub fn read_at_commit(repo: &Repository, name: &str, commit_oid: Oid) -> Result<Queue> { let tree = repo.find_commit(commit_oid)?.tree()?; let mut q = Queue::new(name); if let Some(e) = tree.get_name(INDEX_FILE) { let blob = e.to_object(repo)?.peel_to_blob()?; q.index = String::from_utf8_lossy(blob.content()) .lines() .filter(|l| !l.trim().is_empty()) .map(|l| StableId(l.trim().to_string())) .collect(); } if let Some(e) = tree.get_name(CAN_PULL_FILE) { let blob = e.to_object(repo)?.peel_to_blob()?; q.can_pull = String::from_utf8_lossy(blob.content()).trim() == "true"; } if let Some(e) = tree.get_name(INBOX_DIR) { let inbox_tree = e.to_object(repo)?.peel_to_tree()?; for ie in inbox_tree.iter() { let Some(name) = ie.name() else { continue }; let blob = ie.to_object(repo)?.peel_to_blob()?; let stable = String::from_utf8_lossy(blob.content()).trim().to_string(); if !stable.is_empty() { q.inbox.insert(name.to_string(), StableId(stable)); } } } Ok(q)}
pub fn build_tree(repo: &Repository, q: &Queue) -> Result<Oid> { let mut tb = repo.treebuilder(None)?; let index_text: String = q .index .iter() .map(|s| format!("{}\n", s.0)) .collect(); let index_oid = repo.blob(index_text.as_bytes())?; tb.insert(INDEX_FILE, index_oid, 0o100644)?; let cp = if q.can_pull { "true\n" } else { "false\n" }; let cp_oid = repo.blob(cp.as_bytes())?; tb.insert(CAN_PULL_FILE, cp_oid, 0o100644)?; if !q.inbox.is_empty() { let mut ib = repo.treebuilder(None)?; for (k, v) in &q.inbox { let oid = repo.blob(v.0.as_bytes())?; ib.insert(k.as_str(), oid, 0o100644)?; } let ib_oid = ib.write()?; tb.insert(INBOX_DIR, ib_oid, 0o040000)?; } Ok(tb.write()?)}
pub fn write(repo: &Repository, name: &str, q: &Queue, message: &str) -> Result<()> { validate_name(name)?; let tree_oid = build_tree(repo, q)?; let parent = repo .find_reference(&refname(name)) .ok() .and_then(|r| r.target()) .and_then(|o| repo.find_commit(o).ok()); if let Some(p) = &parent && p.tree_id() == tree_oid { return Ok(()); } let sig = object::signature(repo); let parents: Vec<&git2::Commit> = parent.iter().collect(); let commit = repo.commit( None, &sig, &sig, message, &repo.find_tree(tree_oid)?, &parents, )?; repo.reference(&refname(name), commit, true, message)?; Ok(())}
pub fn list_names(repo: &Repository) -> Result<Vec<String>> { let mut out = Vec::new(); for r in repo.references_glob(&format!("{QUEUE_REF_PREFIX}*"))? { let r = r?; if let Some(name) = r.name() && let Some(rest) = name.strip_prefix(QUEUE_REF_PREFIX) { out.push(rest.to_string()); } } out.sort(); Ok(out)}
/// Push `stable` onto the top of `name`'s index. Idempotent: if already/// present, moves it to the top.pub fn push_top(repo: &Repository, name: &str, stable: StableId, message: &str) -> Result<()> { let mut q = read(repo, name)?; q.index.retain(|s| s != &stable); q.index.insert(0, stable); write(repo, name, &q, message)}
pub fn push_bottom( repo: &Repository, name: &str, stable: StableId, message: &str,) -> Result<()> { let mut q = read(repo, name)?; q.index.retain(|s| s != &stable); q.index.push(stable); write(repo, name, &q, message)}
pub fn remove(repo: &Repository, name: &str, stable: &StableId, message: &str) -> Result<bool> { let mut q = read(repo, name)?; let len = q.index.len(); q.index.retain(|s| s != stable); if q.index.len() == len { return Ok(false); } write(repo, name, &q, message)?; Ok(true)}
/// Stable inbox key for a `(source-queue, sequence)` pair so re-assigns/// overwrite the same slot rather than piling up. Sequence is the per-source/// counter the caller maintains; we don't try to compute it here.pub fn inbox_key(src_queue: &str, src_seq: u32) -> String { format!("{src_queue}-{src_seq}")}
pub fn add_to_inbox( repo: &Repository, name: &str, key: String, stable: StableId, message: &str,) -> Result<()> { let mut q = read(repo, name)?; q.inbox.insert(key, stable); write(repo, name, &q, message)}
pub fn take_from_inbox( repo: &Repository, name: &str, key: &str, message: &str,) -> Result<Option<StableId>> { let mut q = read(repo, name)?; let Some(stable) = q.inbox.remove(key) else { return Ok(None); }; write(repo, name, &q, message)?; Ok(Some(stable))}
#[cfg(test)]mod test { use super::*; use crate::object;
fn init_repo(p: &std::path::Path) -> Repository { let r = Repository::init(p).unwrap(); let mut cfg = r.config().unwrap(); cfg.set_str("user.name", "T").unwrap(); cfg.set_str("user.email", "t@e").unwrap(); r }
#[test] fn empty_default_queue_is_can_pull() { let dir = tempfile::tempdir().unwrap(); let repo = init_repo(dir.path()); let q = read(&repo, "tsk").unwrap(); assert!(q.can_pull); assert!(q.index.is_empty()); }
#[test] fn empty_named_queue_defaults_no_pull() { let dir = tempfile::tempdir().unwrap(); let repo = init_repo(dir.path()); let q = read(&repo, "private").unwrap(); assert!(!q.can_pull); }
#[test] fn push_pop_round_trip() { let dir = tempfile::tempdir().unwrap(); let repo = init_repo(dir.path()); let s1 = object::create(&repo, &object::Task::new("a"), "c").unwrap(); let s2 = object::create(&repo, &object::Task::new("b"), "c").unwrap(); push_top(&repo, "tsk", s1.clone(), "push").unwrap(); push_top(&repo, "tsk", s2.clone(), "push").unwrap(); let q = read(&repo, "tsk").unwrap(); assert_eq!(q.index, vec![s2.clone(), s1.clone()]); assert!(remove(&repo, "tsk", &s2, "drop").unwrap()); let q = read(&repo, "tsk").unwrap(); assert_eq!(q.index, vec![s1]); }
#[test] fn push_top_dedupes_existing() { let dir = tempfile::tempdir().unwrap(); let repo = init_repo(dir.path()); let s = object::create(&repo, &object::Task::new("a"), "c").unwrap(); push_top(&repo, "tsk", s.clone(), "push").unwrap(); push_bottom(&repo, "tsk", s.clone(), "push").unwrap(); // same id, moved to bottom let q = read(&repo, "tsk").unwrap(); assert_eq!(q.index.len(), 1); assert_eq!(q.index[0], s); }
#[test] fn inbox_round_trip() { let dir = tempfile::tempdir().unwrap(); let repo = init_repo(dir.path()); let s = object::create(&repo, &object::Task::new("a"), "c").unwrap(); let key = inbox_key("alice", 5); add_to_inbox(&repo, "bob", key.clone(), s.clone(), "assign").unwrap(); let q = read(&repo, "bob").unwrap(); assert_eq!(q.inbox.get(&key), Some(&s)); let taken = take_from_inbox(&repo, "bob", &key, "accept").unwrap(); assert_eq!(taken, Some(s)); let q = read(&repo, "bob").unwrap(); assert!(q.inbox.is_empty()); }}