FIX: links removed from task will be cleaned up in the attrs of target

.tsk/archive/tsk-24.tsk

···
+properly handle removing links from task
+

.tsk/next

···
-24
+25

.tsk/tasks/tsk-24.tsk

···
+../archive/tsk-24.tsk

src/main.rs

···
         }
     }
     let task = workspace.new_task(title, body)?;
-    workspace.handle_metadata(&task)?;
+    workspace.handle_metadata(&task, None)?;
     workspace.push_task(task)
 }
 
···
     let workspace = Workspace::from_path(dir)?;
     let id: TaskIdentifier = id.into();
     let mut task = workspace.task(id)?;
+    let pre_links = task::parse(&task.to_string()).map(|pt| pt.intenal_links());
     let new_content = open_editor(format!("{}\n\n{}", task.title.trim(), task.body.trim()))?;
     if let Some((title, body)) = new_content.split_once("\n") {
         task.title = title.to_string();
         task.body = body.to_string();
-        workspace.handle_metadata(&task)?;
+        workspace.handle_metadata(&task, pre_links)?;
         task.save()?;
     }
     Ok(())

src/task.rs

···
 #![allow(dead_code)]
 
-use std::str::FromStr;
+use std::{collections::HashSet, str::FromStr};
 use url::Url;
 
 use crate::workspace::Id;
···
 pub(crate) struct ParsedTask {
     pub(crate) content: String,
     pub(crate) links: Vec<ParsedLink>,
+}
+
+impl ParsedTask {
+    pub(crate) fn intenal_links(&self) -> HashSet<Id> {
+        let mut out = HashSet::with_capacity(self.links.len());
+        for link in &self.links {
+            if let ParsedLink::Internal(id) = link {
+                out.insert(*id);
+            }
+        }
+        out
+    }
 }
 
 pub(crate) fn parse(s: &str) -> Option<ParsedTask> {

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::task::parse as parse_task;
 use crate::{fzf, util};
-use std::collections::{vec_deque, BTreeMap};
+use std::collections::{vec_deque, BTreeMap, HashSet};
 use std::ffi::OsString;
 use std::fmt::Display;
 use std::fs::File;
···
 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)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
 pub struct Id(pub u32);
 
 impl FromStr for Id {
···
         })
     }
 
-    pub fn handle_metadata(&self, tsk: &Task) -> Result<()> {
+    pub fn handle_metadata(&self, tsk: &Task, pre_links: Option<HashSet<Id>>) -> 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)?;
+            let internal_links = parsed_task.intenal_links();
+            for link in &internal_links {
+                self.add_backlink(*link, tsk.id)?;
+            }
+            if let Some(pre_links) = pre_links {
+                let removed_links = pre_links.difference(&internal_links);
+                for link in removed_links {
+                    self.remove_backlink(*link, tsk.id)?;
                 }
             }
         }
         Ok(())
     }
 
-    pub fn add_backlink(&self, to: Id, from: Id) -> Result<()> {
+    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();
···
             .filter_map(|s| Id::from_str(s).ok())
             .collect();
         backlinks.push(from);
+        Self::set_xattr(
+            &to_task.file,
+            BACKREFXATTR.into(),
+            &itertools::join(backlinks, ","),
+        )
+    }
+
+    fn remove_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: HashSet<Id> = current_backlinks_text
+            .split(',')
+            .filter_map(|s| Id::from_str(s).ok())
+            .collect();
+        backlinks.remove(&from);
         Self::set_xattr(
             &to_task.file,
             BACKREFXATTR.into(),