ADD: basic stack management

Cargo.lock

···
 ]
 
 [[package]]
+name = "tabwriter"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a327282c4f64f6dc37e3bba4c2b6842cc3a992f204fa58d917696a89f691e5f6"
+dependencies = [
+ "unicode-width",
+]
+
+[[package]]
 name = "taffy"
 version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "nix",
  "smallstr",
  "smol",
+ "tabwriter",
  "thiserror",
  "xattr",
 ]

Cargo.toml

···
 nix = { version = "0.29.0", features = ["fs"] }
 smallstr = { version = "0.3.0", features = ["std"] }
 smol = "2.0.2"
+tabwriter = "1.4.0"
 thiserror = "1.0.64"
 xattr = "1.3.1"

src/buffer.rs

···
-use std::{
-    collections::BinaryHeap,
-    sync::{Condvar, Mutex},
-};
-struct PooledHandle<'a, T: Ord + Default> {
-    parent: &'a Pool<T>,
-    item: Option<T>,
-}
-
-struct Pool<T: Ord + Default>(Mutex<BinaryHeap<T>>, Condvar);
-
-impl<'a, T: Ord + Default> Pool<T> {
-    pub fn give(&self, item: T) {
-        self.0.lock().expect("Poisoned lock").push(item)
-    }
-
-    /// Retrieves
-    pub fn take(&self) -> Option<T> {
-        self.0.lock().expect("Poisoned lock").pop()
-    }
-
-    pub fn lease(&self) -> PooledHandle<'a, T> {
-        let guard = self.0.lock().expect("Poisoned lock");
-        match guard.pop() {
-            Some(item) => PooledHandle {
-                parent: self,
-                item: Some(item),
-            },
-            None => {
-                let mut item = None;
-                while item.is_none() {
-                    let guard = self.1.wait(guard).expect("Poisoned lock");
-                    item = guard.pop();
-                }
-
-            },
-        }
-    }
-}
-
-impl<T: Ord> AsRef<T> for PooledHandle<'_, T> {
-    fn as_ref(&self) -> &T {
-        &self.item
-    }
-}
-
-impl<T: Ord> Drop for PooledHandle<'_, T> {
-    fn drop(&mut self) {
-        self.parent.give(self.item)
-    }
-}

src/errors.rs

···
     ParseId(#[from] std::num::ParseIntError),
     #[error("General parsing error: {0}")]
     Parse(String),
+    #[allow(dead_code)]
     #[error("An unexpected error occurred: {0}")]
     Oops(Box<dyn std::error::Error>),
 }

src/main.rs

···
 mod errors;
-mod workspace;
 mod stack;
 mod util;
-mod buffer;
+mod workspace;
 use std::path::PathBuf;
 use std::{env::current_dir, io::Read};
 use workspace::Workspace;
···
         #[command(flatten)]
         title: Title,
     },
+    List {
+        /// Whether to list all tasks in the task stack. If specified, -c / count is ignored.
+        #[arg(short = 'a', default_value_t = false)]
+        all: bool,
+        #[arg(short = 'c', default_value_t = 10)]
+        count: usize,
+    },
+
+    Swap,
 }
 
 #[derive(Args)]
···
 fn main() {
     let cli = Cli::parse();
     match cli.command {
-        Commands::Init => Workspace::init(cli.dir.unwrap_or(default_dir())).expect("Init failed"),
+        Commands::Init => command_init(cli.dir.unwrap_or(default_dir())),
         Commands::Push { edit, body, title } => {
-            let title = if let Some(title) = title.title {
-                title
-            } else if let Some(title) = title.title_simple {
-                let joined = title.join(" ");
-                joined
-            } else {
-                "".to_string()
-            };
-            let mut body = body.unwrap_or_default();
-            if body == "-" {
-                // add newline so you can type directly in the shell
-                eprintln!("");
-                body.clear();
-                std::io::stdin()
-                    .read_to_string(&mut body)
-                    .expect("Failed to read stdin");
-            }
-            if edit {
-                body = open_editor(format!("{title}\n\n{body}")).expect("Failed to edit file");
-            }
-            Workspace::from_path(cli.dir.unwrap_or(default_dir()))
-                .expect("Unable to find .tsk dir")
-                .new_task(title, body)
-                .expect("Failed to create task");
+            command_push(cli.dir.unwrap_or(default_dir()), edit, body, title)
         }
+        Commands::List { all, count } => command_list(cli.dir.unwrap_or(default_dir()), all, count),
+        Commands::Swap => command_swap(cli.dir.unwrap_or(default_dir()))
     }
 }
+
+fn command_init(dir: PathBuf) {
+    Workspace::init(dir).expect("Init failed")
+}
+
+fn command_push(dir: PathBuf, edit: bool, body: Option<String>, title: Title) {
+    let workspace = Workspace::from_path(dir).expect("Unable to find .tsk dir");
+    let title = if let Some(title) = title.title {
+        title
+    } else if let Some(title) = title.title_simple {
+        let joined = title.join(" ");
+        joined
+    } else {
+        "".to_string()
+    };
+    let mut body = body.unwrap_or_default();
+    if body == "-" {
+        // add newline so you can type directly in the shell
+        eprintln!("");
+        body.clear();
+        std::io::stdin()
+            .read_to_string(&mut body)
+            .expect("Failed to read stdin");
+    }
+    if edit {
+        body = open_editor(format!("{title}\n\n{body}")).expect("Failed to edit file");
+    }
+    let task = workspace
+        .new_task(title, body)
+        .expect("Failed to create task");
+    workspace
+        .push_task(task)
+        .expect("Failed to push task to stack");
+}
+
+fn command_list(dir: PathBuf, all: bool, count: usize) {
+    let workspace = Workspace::from_path(dir).expect("Unable to find .tsk dir");
+    let stack = if all {
+        workspace.read_stack(None).expect("Failed to read index")
+    } else {
+        workspace
+            .read_stack(Some(count))
+            .expect("Failed to read index")
+    };
+    if stack.empty() {
+        println!("*No tasks*");
+    } else {
+        println!("{}", stack);
+    }
+}
+
+fn command_swap(dir: PathBuf) {
+    let workspace = Workspace::from_path(dir).expect("Unable to find .tsk dir");
+    workspace.swap_top().expect("swap to work");
+}

src/stack.rs

···
+#![allow(dead_code)]
 //! The Task stack. Tasks created with `push` end up at the top here. It is invalid for a task that
 //! has been completed/archived to be on the stack.
 
 use crate::errors::{Error, Result};
 use crate::util;
-use std::io::{self, BufRead, Read};
+use std::collections::VecDeque;
+use std::fmt::Display;
+use std::io::{self, BufRead, BufReader, Seek, Write};
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
 use std::{fs::File, path::PathBuf};
 
 use nix::fcntl::{Flock, FlockArg};
 
-use crate::workspace::{Id, Workspace};
+use crate::workspace::{Id, Task};
 
-struct StackItem {
+const TASKSFOLDER: &str = "tasks";
+const INDEXFILE: &str = "index";
+
+pub(crate) struct StackItem {
     id: Id,
     title: String,
-    next: Id,
+    modify_time: SystemTime,
+}
+
+impl Display for StackItem {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        // .trim is used here on the title because there may be a newline in here if we read the
+        // title from the task file.
+        write!(
+            f,
+            // NOTE: we do NOT print the access time.
+            "{}\t{}",
+            self.id,
+            self.title.trim(),
+        )
+    }
+}
+
+impl TryFrom<Task> for StackItem {
+    type Error = Error;
+
+    fn try_from(value: Task) -> std::result::Result<Self, Self::Error> {
+        let modify_time = value.file.metadata()?.modified()?;
+        Ok(Self {
+            id: value.id,
+            // replace tabs with spaces, they're not valid in StackItem titles.
+            title: value.title.replace("\t", " "),
+            modify_time,
+        })
+    }
 }
 
 fn eof() -> Error {
···
 }
 
 impl StackItem {
-    fn from_reader(workspace_path: &PathBuf, reader: &mut impl BufRead) -> Result<Self> {
-        let mut buf = String::new();
-        reader.read_line(&mut buf)?;
-        if buf.is_empty() {
-            return Err(Error::Io(io::Error::new(
-                io::ErrorKind::UnexpectedEof,
-                "Empty line",
-            )));
+    /// Parses a [`StackItem`] from a string. The expected format is a tab-delimited line with the
+    /// files: task id	title
+    fn from_line(workspace_path: &PathBuf, line: String) -> Result<Self> {
+        let mut parts = line.split("\t");
+        let id: Id = parts
+            .next()
+            .ok_or(Error::Parse(format!(
+                "Incomplete index line. Missing tsk ID"
+            )))?
+            .parse()?;
+        let mut title: String = parts
+            .next()
+            .ok_or(Error::Parse(format!(
+                "Incomplete index line. Missing title."
+            )))?
+            .trim()
+            .to_string();
+        // parse the timestamp as an integer
+        let index_epoch: u64 = parts.next().unwrap_or("0").parse()?;
+        // get a usable system time from the UNIX epoch, defaulting to the UNIX_EPOCH if there's
+        // any failures. This means that if there's errors, we will always read the title and
+        // modify_time from the task file.
+        let mut modify_time = UNIX_EPOCH
+            .checked_add(Duration::from_secs(index_epoch))
+            .unwrap_or(UNIX_EPOCH);
+        let modify_epoch = modify_time
+            .duration_since(UNIX_EPOCH)
+            .expect("We're before the dawn of time!?")
+            .as_secs();
+        let task = util::flopen(
+            workspace_path.join(TASKSFOLDER).join(id.to_string()),
+            FlockArg::LockExclusive,
+        )?;
+        let task_modify_time = task.metadata()?.modified()?;
+        // if the task file has been modified since we last looked at it, re-read the title and
+        // metadata
+        if modify_epoch > index_epoch {
+            title.clear();
+            BufReader::new(&*task).read_line(&mut title)?;
+            modify_time = task_modify_time;
         }
-        let (id, next) = Self::parse(&buf)?;
-        let title = util::flopen(workspace_path.join("tasks").join(id), mode)
-        todo!();
-    }
-
-    fn parse(line: &str) -> Result<(Id, Id)> {
-        let mut split = line.split("->");
-        let curr = split.next().ok_or(eof())?;
-        let next = split.next().ok_or(eof())?;
-        if let Some(rest) = split.next() {
-            Err(Error::Parse(format!(
-                "Got unexpected data in index item: {rest}"
-            )))
-        } else {
-            Ok((curr.parse()?, next.parse()?))
-        }
+        Ok(Self {
+            id,
+            title,
+            modify_time,
+        })
     }
 }
 
 pub struct TaskStack {
-    /// The index into `all` that is the top of the stack
-    top: usize,
-    all: Vec<StackItem>,
+    /// All items within the stack
+    all: VecDeque<StackItem>,
     file: Flock<File>,
 }
 
+impl Display for TaskStack {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        for task in self.all.iter() {
+            write!(f, "{task}\n")?;
+        }
+        Ok(())
+    }
+}
+
 impl TaskStack {
-    fn from_tskdir(path: &PathBuf) -> Result<Self> {
-        todo!()
+    pub fn from_tskdir(workspace_path: &PathBuf, count: Option<usize>) -> Result<Self> {
+        let file = util::flopen(workspace_path.join(INDEXFILE), FlockArg::LockExclusive)?;
+        let index = BufReader::new(&*file).lines();
+        let mut all = VecDeque::new();
+        if let Some(count) = count {
+            for line in index.take(count) {
+                let line = line?;
+                let stack_item = StackItem::from_line(workspace_path, line)?;
+                all.push_back(stack_item);
+            }
+        } else {
+            for line in index {
+                let stack_item = StackItem::from_line(workspace_path, line?)?;
+                all.push_back(stack_item);
+            }
+        };
+        Ok(Self { all, file })
+    }
+
+    /// Saves the task stack to disk.
+    pub fn save(mut self) -> Result<()> {
+        // Clear the file
+        self.file.seek(std::io::SeekFrom::Start(0))?;
+        self.file.set_len(0)?;
+        for item in self.all.iter() {
+            self.file.write_all(format!("{item}\n").as_bytes())?;
+        }
+        Ok(())
+    }
+
+    pub fn push(&mut self, item: StackItem) {
+        self.all.push_front(item);
+    }
+
+    pub fn pop(&mut self) -> Option<StackItem> {
+        self.all.pop_front()
+    }
+
+    pub fn swap(&mut self) {
+        let tip = self.all.pop_front();
+        let second = self.all.pop_front();
+        if tip.is_some() && second.is_some() {
+            self.all.push_front(tip.unwrap());
+            self.all.push_front(second.unwrap());
+        }
+    }
+
+    pub fn empty(&self) -> bool {
+        self.all.is_empty()
     }
 }

src/workspace.rs

···
 use crate::errors::{Error, Result};
 use crate::stack::TaskStack;
 use crate::util;
+use std::fmt::Display;
 use std::fs::File;
 use std::io::{Read, Seek};
 use std::path::PathBuf;
···
     type Err = Error;
 
     fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        s.strip_prefix("tsk-")
-            .ok_or(Self::Err::Parse("expected tsk- prefix ".to_string()))?;
+        let s = s
+            .strip_prefix("tsk-")
+            .ok_or(Self::Err::Parse(format!("expected tsk- prefix. Got {s}")))?;
         Ok(Self(s.parse()?))
+    }
+}
+
+impl Display for Id {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "tsk-{}", self.0)
+    }
+}
+
+impl Id {
+    pub fn to_string(&self) -> String {
+        format!("tsk-{}.tsk", self.0)
     }
 }
 
···
         })
     }
 
-    fn read_stack(&self) -> Result<TaskStack> {
-        let mut index = String::new();
-        let mut cache = String::new();
-        let mut index_file = util::flopen(self.path.join(INDEXFILE), FlockArg::LockExclusive)?;
-        let mut cache_file = util::flopen(self.path.join(TITLECACHEFILE), FlockArg::LockShared)?;
-        index_file.read_to_string(&mut index)?;
-        for line in index.lines() {
-            
-        }
+    pub fn read_stack(&self, count: Option<usize>) -> Result<TaskStack> {
+        TaskStack::from_tskdir(&self.path, count)
+    }
+
+    pub fn push_task(&self, task: Task) -> Result<()> {
+        let mut stack = TaskStack::from_tskdir(&self.path, None)?;
+        stack.push(task.try_into()?);
+        stack.save()?;
+        Ok(())
+    }
 
-        todo!();
+    pub fn swap_top(&self) -> Result<()> {
+        let mut stack = TaskStack::from_tskdir(&self.path, None)?;
+        stack.swap();
+        stack.save()?;
+        Ok(())
     }
 }
 
 pub struct Task {
-    id: Id,
-    title: String,
-    body: String,
-    file: Flock<File>,
+    pub id: Id,
+    pub title: String,
+    pub body: String,
+    pub file: Flock<File>,
 }
 
 #[cfg(test)]