ADD: basic xattr read support

This is a prerequisite for file-attributes and back linking

.tsk/archive/tsk-13.tsk

···
+user-defined labels
+

.tsk/archive/tsk-14.tsk

···
+parse internal links from body
+

.tsk/archive/tsk-4.tsk

···
 Add basic metadata
 
+Currently have basic metadata reading done. There's nothing *writing* metadata, but
+we'll get there next.

.tsk/index

···
+tsk-14	parse internal links from body
+tsk-6	automatically add backlinks
 tsk-9	fix timestamp storage and parsing
 tsk-8	IMAP4-based sync
 tsk-10	foreign workspaces
 tsk-7	allow for creating tasks that don't go to top of stack
-tsk-4	Add basic metadata
-tsk-6	automatically add backlinks
+tsk-13	user-defined labels

.tsk/next

···
-13
+15

.tsk/tasks/tsk-13.tsk

···
+/home/noah/repos/tsk/.tsk/archive/tsk-13.tsk

.tsk/tasks/tsk-14.tsk

···
+/home/noah/repos/tsk/.tsk/archive/tsk-14.tsk

src/attrs.rs

···
+use std::collections::btree_map::{IntoIter as BTreeIntoIter, Iter as BTreeMapIter};
+use std::collections::BTreeMap;
+use std::iter::Chain;
+
+type Map = BTreeMap<String, String>;
+
+#[allow(dead_code)]
+/// Holds xattributes in a way that allows for differentiating between attributes that have been
+/// added/modified or that were present when reading the file. This is an *optimization* over
+/// infrequently modified values.
+#[derive(Default, Clone, Debug)]
+pub(crate) struct Attrs {
+    pub written: Map,
+    pub updated: Map,
+}
+
+impl IntoIterator for Attrs {
+    type Item = (String, String);
+
+    type IntoIter = Chain<BTreeIntoIter<String, String>, BTreeIntoIter<String, String>>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.written.into_iter().chain(self.updated.into_iter())
+    }
+}
+
+#[allow(dead_code)]
+impl Attrs {
+    pub(crate) fn from_written(written: Map) -> Self {
+        Self {
+            written,
+            ..Default::default()
+        }
+    }
+
+    pub(crate) fn get(&self, key: &str) -> Option<&String> {
+        self.updated.get(key).or_else(|| self.written.get(key))
+    }
+
+    pub(crate) fn insert(&mut self, key: String, value: String) -> Option<String> {
+        if self.updated.contains_key(&key) {
+            self.updated.insert(key, value)
+        } else {
+            let maybe_old_value = self.written.get(&key);
+            self.updated.insert(key, value);
+            maybe_old_value.cloned()
+        }
+    }
+
+    pub(crate) fn iter(
+        &self,
+    ) -> Chain<BTreeMapIter<'_, String, String>, BTreeMapIter<'_, String, String>> {
+        self.written.iter().chain(self.updated.iter())
+    }
+}

src/main.rs

···
+mod attrs;
 mod errors;
 mod fzf;
 mod stack;
···
 
     /// Prints the contents of a task.
     Show {
+        /// Shows raw file attributes for the file
+        #[arg(short = 'x', default_value_t = false)]
+        show_attrs: bool,
         /// The [TSK-]ID of the task to display
         #[command(flatten)]
         task_id: TaskId,
···
         Commands::Push { edit, body, title } => command_push(dir, edit, body, title),
         Commands::List { all, count } => command_list(dir, all, count),
         Commands::Swap => command_swap(dir),
-        Commands::Show { task_id } => command_show(dir, task_id),
+        Commands::Show {
+            task_id,
+            show_attrs,
+        } => command_show(dir, task_id, show_attrs),
         Commands::Edit { task_id } => command_edit(dir, task_id),
         Commands::Completion { shell } => command_completion(shell),
         Commands::Drop { task_id } => command_drop(dir, task_id),
···
     Workspace::from_path(dir)?.deprioritize(task_id.into())
 }
 
-fn command_show(dir: PathBuf, task_id: TaskId) -> Result<()> {
+fn command_show(dir: PathBuf, task_id: TaskId, show_attrs: bool) -> Result<()> {
     let task = Workspace::from_path(dir)?.task(task_id.into())?;
+    // YAML front-matter style. YAML is gross, but it's what everyone uses!
+    if show_attrs {
+        println!("---");
+        for (attr, value) in task.attributes.iter() {
+            println!("{attr}: \"{value}\"");
+        }
+        println!("---");
+    }
     println!("{task}");
     Ok(())
 }

src/workspace.rs

···
 #![allow(dead_code)]
 use nix::fcntl::{Flock, FlockArg};
+use xattr::FileExt;
 
+use crate::attrs::Attrs;
 use crate::errors::{Error, Result};
 use crate::stack::{StackItem, TaskStack};
 use crate::{fzf, util};
-use std::collections::vec_deque;
+use std::collections::{vec_deque, BTreeMap};
+use std::ffi::OsString;
 use std::fmt::Display;
 use std::fs::File;
 use std::io::{BufRead as _, BufReader, Read, Seek, SeekFrom};
+use std::ops::Deref;
 use std::os::unix::fs::symlink;
 use std::path::PathBuf;
 use std::str::FromStr;
···
 
 const INDEXFILE: &str = "index";
 const TITLECACHEFILE: &str = "cache";
+const XATTRPREFIX: &str = "user.tsk.";
 /// 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);
···
         }
     }
 
+    /// Increments the `next` counter and returns the previous value.
     pub fn next_id(&self) -> Result<Id> {
         let mut file = util::flopen(self.path.join("next"), FlockArg::LockExclusive)?;
         let mut buf = String::new();
···
             title,
             body,
             file,
+            attributes: Default::default(),
         })
     }
 
···
         reader.read_line(&mut title)?;
         reader.read_to_string(&mut body)?;
         drop(reader);
+        let mut read_attributes = BTreeMap::new();
+        if let Ok(attrs) = file.list_xattr() {
+            for attr in attrs {
+                if let Some((key, value)) = Self::read_xattr(&file, attr) {
+                    read_attributes.insert(key, value);
+                }
+            }
+        }
         Ok(Task {
             id,
+            file,
             title: title.trim().to_string(),
             body: body.trim().to_string(),
-            file,
+            attributes: Attrs::from_written(read_attributes),
         })
+    }
+
+    /// 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()?))
     }
 
     pub fn read_stack(&self) -> Result<TaskStack> {
···
     pub title: String,
     pub body: String,
     pub file: Flock<File>,
+    pub attributes: Attrs,
 }
 
 impl Display for Task {
···
             title: "Hello, world".to_string(),
             body: "The body of the task.".to_string(),
             file: util::flopen("/dev/null".into(), FlockArg::LockShared).unwrap(),
+            attributes: Default::default(),
         };
         assert_eq!("Hello, world\n\nThe body of the task.", task.to_string());
     }