ADD: automatic backreference

.tsk/archive/tsk-14.tsk

···
 
 here's [a link](https://ngp.computer).
 
-and an internal link: [[tsk-11]]
+and an internal link: [[tsk-11]]. This should add a backlink
 
 and some _underlined text_
 

.tsk/archive/tsk-6.tsk

···
 automatically add backlinks
 
 I need to parse on save/edit/create for outgoing internal links. If any exist and their
-corresponding task exists, update the targetted task with a backlink reference
+corresponding task exists, update the targetted task with a backlink reference
+
+Using [[tsk-11]] as my test.

.tsk/index

···
-tsk-6	automatically add backlinks
 tsk-21	Add command to setup git stuff
 tsk-8	IMAP4-based sync
 tsk-17	Add reopen command

Cargo.lock

···
 checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf"
 
 [[package]]
+name = "itertools"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
+dependencies = [
+ "either",
+]
+
+[[package]]
 name = "lazy_static"
 version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 
 [[package]]
 name = "thiserror"
-version = "1.0.69"
+version = "2.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
+checksum = "c006c85c7651b3cf2ada4584faa36773bd07bac24acfb39f3c431b36d7e667aa"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.69"
+version = "2.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
+checksum = "f077553d607adc1caf65430528a576c757a71ed73944b66ebb58ef2bbd243568"
 dependencies = [
  "proc-macro2",
  "quote",
···
  "clap_mangen",
  "colored",
  "edit",
+ "itertools",
  "nix",
  "open",
  "thiserror",

Cargo.toml

···
 clap_complete = "4"
 edit = "0"
 nix = { version = "0", features = ["fs"] }
-thiserror = "1"
+thiserror = "2"
 url = "2"
 xattr = "1"
 colored = "2"
 open = "5"
+itertools = "0"
 
 [build-dependencies]
 clap_mangen = "0"

src/main.rs

···
         }
     }
     let task = workspace.new_task(title, body)?;
+    workspace.handle_metadata(&task)?;
     workspace.push_task(task)
 }
 
···
     if let Some((title, body)) = new_content.split_once("\n") {
         task.title = title.to_string();
         task.body = body.to_string();
+        workspace.handle_metadata(&task)?;
         task.save()?;
     }
     Ok(())

src/workspace.rs

···
 use crate::attrs::Attrs;
 use crate::errors::{Error, Result};
 use crate::stack::{StackItem, TaskStack};
+use crate::task::{parse as parse_task, ParsedLink};
 use crate::{fzf, util};
 use std::collections::{vec_deque, BTreeMap};
 use std::ffi::OsString;
···
 const INDEXFILE: &str = "index";
 const TITLECACHEFILE: &str = "cache";
 const XATTRPREFIX: &str = "user.tsk.";
+const BACKREFXATTR: &str = "user.tsk.references";
 /// A unique identifier for a task. When referenced in text, it is prefixed with `tsk-`.
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub struct Id(pub u32);
···
         })
     }
 
+    pub fn handle_metadata(&self, tsk: &Task) -> Result<()> {
+        // Parse the task and update any backlinks
+        if let Some(parsed_task) = parse_task(&tsk.to_string()) {
+            for link in parsed_task.links {
+                if let ParsedLink::Internal(id) = link {
+                    self.add_backlink(id, tsk.id)?;
+                }
+            }
+        }
+        Ok(())
+    }
+
+    pub fn add_backlink(&self, to: Id, from: Id) -> Result<()> {
+        let to_task = self.task(TaskIdentifier::Id(to))?;
+        let (_, current_backlinks_text) =
+            Self::read_xattr(&to_task.file, BACKREFXATTR.into()).unwrap_or_default();
+        let mut backlinks: Vec<Id> = current_backlinks_text
+            .split(',')
+            .filter_map(|s| Id::from_str(s).ok())
+            .collect();
+        backlinks.push(from);
+        Self::set_xattr(
+            &to_task.file,
+            BACKREFXATTR.into(),
+            &itertools::join(backlinks, ","),
+        )
+    }
+
     /// Reads an xattr from a file, stripping the prefix for
     fn read_xattr<D: Deref<Target = File>>(file: &D, key: OsString) -> Option<(String, String)> {
         // this *shouldn't* allocate, but it does O(n) scan the str for UTF-8 correctness
         let parsedkey = key.as_os_str().to_str()?.strip_prefix(XATTRPREFIX)?;
         let valuebytes = file.get_xattr(&key).ok().flatten()?;
         Some((parsedkey.to_string(), String::from_utf8(valuebytes).ok()?))
+    }
+
+    fn set_xattr<D: Deref<Target = File>>(file: &D, key: &str, value: &str) -> Result<()> {
+        let key = if !key.starts_with(XATTRPREFIX) {
+            format!("{XATTRPREFIX}.{key}")
+        } else {
+            key.to_string()
+        };
+        Ok(file.set_xattr(key, value.as_bytes())?)
     }
 
     pub fn read_stack(&self) -> Result<TaskStack> {