ADD: .git-like parent search, searching

src/errors.rs

···
+use std::{convert::Infallible, string::FromUtf8Error};
+
 use thiserror::Error as ThisError;
 
 pub type Result<T> = std::result::Result<T, Error>;
···
     ParseId(#[from] std::num::ParseIntError),
     #[error("General parsing error: {0}")]
     Parse(String),
+    #[error("Error parsing bytes as utf-8: {0}")]
+    FromUtf8(#[from] FromUtf8Error),
     #[allow(dead_code)]
     #[error("An unexpected error occurred: {0}")]
     Oops(Box<dyn std::error::Error>),
 }
+
+impl From<Infallible> for Error {
+    fn from(_: Infallible) -> Self {
+        unreachable!();
+    }
+}

src/fzf.rs

···
+use crate::errors::{Error, Result};
+use std::fmt::Display;
+use std::io::Write;
+use std::process::{Command, Stdio};
+use std::str::FromStr;
+
+/// Sends each item as a line to stdin to the `fzf` command and returns the selected item's string
+/// representation as output
+pub fn select<I>(input: impl IntoIterator<Item = I>) -> Result<Option<I>>
+where
+    I: Display + FromStr,
+    Error: From<<I as FromStr>::Err>,
+{
+    let mut child = Command::new("fzf")
+        .args(["-d", "\t"])
+        .stderr(Stdio::inherit())
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .spawn()?;
+    // unwrap: this can never fail
+    let child_in = child.stdin.as_mut().unwrap();
+    for item in input.into_iter() {
+        write!(child_in, "{}\n", item.to_string())?;
+    }
+    let output = child.wait_with_output()?;
+    if output.stdout.is_empty() {
+        Ok(None)
+    } else {
+        Ok(Some(String::from_utf8(output.stdout)?.parse()?))
+    }
+}

src/main.rs

···
 mod errors;
+mod fzf;
 mod stack;
 mod util;
 mod workspace;
···
 use std::io;
 use std::path::PathBuf;
 use std::{env::current_dir, io::Read};
-use workspace::Workspace;
+use workspace::{Id, Workspace};
 
 //use smol;
 //use iocraft::prelude::*;
-use clap::{Args, CommandFactory, Parser, Subcommand};
+use clap::{value_parser, Args, CommandFactory, Parser, Subcommand};
 use edit::edit as open_editor;
 
 fn default_dir() -> PathBuf {
···
 
 #[derive(Subcommand)]
 enum Commands {
+    /// Initializes a .tsk workspace in the current effective directory, which defaults to PWD.
     Init,
     /// Creates a new task, automatically assigning it a unique identifider and persisting
     Push {
···
         count: usize,
     },
 
+    /// Swaps the top two tasks on the stack. If there are less than 2 tasks on the stack, there is
+    /// no effect.
     Swap,
 
+    /// Open up an editor to modify the task with the given ID.
     Edit {
-        #[arg(short = 't')]
-        task_id: Option<u32>,
+        #[command(flatten)]
+        task_id: TaskId,
     },
 
+    /// Generates completion for a given shell.
     Completion {
         #[arg(short = 's')]
         shell: Shell,
     },
-    /*
-    Drop {
-        #[arg(short = 't')]
-        task_id: Option<u32>,
-    }
-    */
+
+    /// Use fuzzy finding with `fzf` to search for a task
+    Find {
+        /// Include the contents of tasks in the search criteria.
+        #[arg(short = 'b', default_value_t = false)]
+        search_body: bool,
+        /// Include archived tasks in the search criteria. Combine with `-b` to include archived
+        /// bodies in the search criteria.
+        #[arg(short = 'a', default_value_t = false)]
+        search_archived: bool,
+    },
+
+    /// Drops the task on the top of the stack and archives it.
+    Drop,
 }
 
 #[derive(Args)]
-#[group(required = true, multiple = false)]
+#[group(required = false, multiple = false)]
 struct Title {
     /// The title of the task. This is useful for when you also wish to specify the body of the
     /// task as an argument (ie. with -b).
···
     title_simple: Option<Vec<String>>,
 }
 
+#[derive(Args)]
+#[group(required = true, multiple = false)]
+struct TaskId {
+    #[arg(short = 't', value_name = "ID")]
+    id: Option<u32>,
+
+    #[arg(short = 'T', value_name = "TSK-ID", value_parser = value_parser!(String))]
+    tsk_id: Option<Id>,
+}
+
 fn main() {
     let cli = Cli::parse();
     match cli.command {
···
         Commands::Swap => command_swap(cli.dir.unwrap_or(default_dir())),
         Commands::Edit { task_id } => command_edit(cli.dir.unwrap_or(default_dir()), task_id),
         Commands::Completion { shell } => command_completion(shell),
+        Commands::Drop => command_drop(cli.dir.unwrap_or(default_dir())),
+        Commands::Find {
+            search_body,
+            search_archived,
+        } => command_search(cli.dir.unwrap_or(default_dir())),
     }
 }
 
···
 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")
+        workspace.read_stack().expect("Failed to read index")
     } else {
-        workspace
-            .read_stack(Some(count))
-            .expect("Failed to read index")
+        workspace.read_stack().expect("Failed to read index")
     };
     if stack.empty() {
         println!("*No tasks*");
     } else {
-        println!("{}", stack);
+        if !all {
+            for stack_item in stack.into_iter().take(count) {
+                println!("{stack_item}");
+            }
+        } else {
+            for stack_item in stack.into_iter() {
+                println!("{stack_item}");
+            }
+        }
     }
 }
 
···
     workspace.swap_top().expect("swap to work");
 }
 
-fn command_edit(dir: PathBuf, id: Option<u32>) {
+fn command_edit(dir: PathBuf, id: TaskId) {
     let workspace = Workspace::from_path(dir).expect("Unable to find .tsk dir");
-    let mut task = if let Some(id) = id {
+    let tsk_id: Option<Id> = id.id.map(Id::from).or(id.tsk_id);
+    let mut task = if let Some(id) = tsk_id {
         workspace.task(id.into()).expect("To read task from disk")
     } else {
-        let mut stack = workspace.read_stack(Some(1)).expect("to read stack");
+        let mut stack = workspace.read_stack().expect("to read stack");
         let stack_item = stack.pop().expect("No tasks on stack.");
         workspace.task(stack_item.id).expect("couldn't read task")
     };
···
 fn command_completion(shell: Shell) {
     generate(shell, &mut Cli::command(), "tsk", &mut io::stdout())
 }
+
+fn command_drop(dir: PathBuf) {
+    if let Some(id) = Workspace::from_path(dir)
+        .expect("Unable to find .tsk dir")
+        .drop()
+        .expect("Unable to drop task.") {
+            println!("Dropped {id}")
+    }
+}
+
+fn command_search(dir: PathBuf) {
+    let id = Workspace::from_path(dir).unwrap().search().unwrap();
+    if let Some(id) = id {
+        eprint!("Dropping ");
+        println!("{id}");
+    } else {
+        eprintln!("No task to drop.")
+    }
+}

src/stack.rs

···
 use std::collections::VecDeque;
 use std::fmt::Display;
 use std::io::{self, BufRead, BufReader, Seek, Write};
+use std::str::FromStr;
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
 use std::{fs::File, path::PathBuf};
 
···
 const TASKSFOLDER: &str = "tasks";
 const INDEXFILE: &str = "index";
 
-pub(crate) struct StackItem {
+pub struct StackItem {
     pub id: Id,
     pub title: String,
     pub modify_time: SystemTime,
···
     ))
 }
 
-impl StackItem {
-    /// 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");
+impl FromStr for StackItem {
+    type Err = Error;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        let mut parts = s.trim().split("\t");
         let id: Id = parts
             .next()
             .ok_or(Error::Parse(format!(
                 "Incomplete index line. Missing tsk ID"
             )))?
             .parse()?;
-        let mut title: String = parts
+        let title: String = parts
             .next()
             .ok_or(Error::Parse(format!(
                 "Incomplete index line. Missing title."
···
         // 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
+        let 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();
+        Ok(Self {
+            id,
+            title,
+            modify_time,
+        })
+    }
+}
+
+impl StackItem {
+    /// 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 stack_item: StackItem = line.parse()?;
+
         let task = util::flopen(
-            workspace_path.join(TASKSFOLDER).join(id.to_string()),
+            workspace_path
+                .join(TASKSFOLDER)
+                .join(stack_item.id.to_filename()),
             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;
+        if (task_modify_time - Duration::from_secs(1)) > stack_item.modify_time {
+            stack_item.title.clear();
+            BufReader::new(&*task).read_line(&mut stack_item.title)?;
+            stack_item.modify_time = task_modify_time;
         }
-        Ok(Self {
-            id,
-            title,
-            modify_time,
-        })
+        Ok(stack_item)
     }
 }
 
···
     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 {
-    pub fn from_tskdir(workspace_path: &PathBuf, count: Option<usize>) -> Result<Self> {
+    pub fn from_tskdir(workspace_path: &PathBuf) -> 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);
-            }
-        };
+        for line in index {
+            let stack_item = StackItem::from_line(workspace_path, line?)?;
+            all.push_back(stack_item);
+        }
         Ok(Self { all, file })
     }
 
···
         self.all.is_empty()
     }
 }
+
+impl IntoIterator for TaskStack {
+    type Item = StackItem;
+
+    type IntoIter = std::collections::vec_deque::IntoIter<Self::Item>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.all.into_iter()
+    }
+}

src/util.rs

···
 use crate::errors::{Error, Result};
+use std::fs;
+use std::os::unix::fs::MetadataExt;
 use std::{
     fs::{File, OpenOptions},
-    path::PathBuf,
+    path::{Path, PathBuf},
 };
 
 use nix::fcntl::{Flock, FlockArg};
···
         .open(path)?;
     Ok(Flock::lock(file, mode).map_err(|(_, errno)| Error::Lock(errno))?)
 }
+
+/// Recursively searches upwards for a directory
+pub fn find_parent_with_dir(
+    dir: PathBuf,
+    searching_for: impl AsRef<Path>,
+) -> Result<Option<PathBuf>> {
+    // Create a new pathbuf to modify, we slap a segment onto the end but then pop it off right
+    // away
+    let mut d = dir.join(&searching_for);
+    while d.pop() {
+        let check = d.join(&searching_for);
+        eprintln!("Searching {check:?}");
+        if check.exists() {
+            if fs::metadata(&check)?.dev() != fs::metadata(&dir)?.dev() {
+                // we hit a filesystem boundary
+                return Ok(None);
+            }
+            return Ok(Some(check));
+        }
+    }
+    Ok(None)
+}

src/workspace.rs

···
 
 use crate::errors::{Error, Result};
 use crate::stack::TaskStack;
-use crate::util;
+use crate::{fzf, util};
 use std::fmt::Display;
-use std::fs::File;
+use std::fs::{self, File};
 use std::io::{BufRead as _, BufReader, Read, Seek, SeekFrom};
 use std::path::PathBuf;
 use std::str::FromStr;
···
 const INDEXFILE: &str = "index";
 const TITLECACHEFILE: &str = "cache";
 /// A unique identifier for a task. When referenced in text, it is prefixed with `tsk-`.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub struct Id(u32);
 
 impl FromStr for Id {
···
 }
 
 impl Id {
-    pub fn to_string(&self) -> String {
+    pub fn to_filename(&self) -> String {
         format!("tsk-{}.tsk", self.0)
     }
 }
···
         std::fs::create_dir(&tsk_dir)?;
         // Create the tasks directory
         std::fs::create_dir(&tsk_dir.join("tasks"))?;
+        // Create the archive directory
+        std::fs::create_dir(&tsk_dir.join("archive"))?;
         let mut next = OpenOptions::new()
             .read(true)
             .write(true)
···
     }
 
     pub fn from_path(path: PathBuf) -> Result<Self> {
-        // TODO: recursively walk up the path until we find a .tsk dir or error if we can't find
-        // one / cross a filesystem boundary
-        let tsk_dir = path.join(".tsk");
-        if !tsk_dir.exists() {
-            return Err(Error::Uninitialized);
-        } else {
-            Ok(Self { path: tsk_dir })
-        }
+        let tsk_dir = util::find_parent_with_dir(path, ".tsk")?.ok_or(Error::Uninitialized)?;
+        Ok(Self { path: tsk_dir })
     }
 
     pub fn next_id(&self) -> Result<Id> {
···
         let id = buf.trim().parse::<u32>()?;
         // reset the files contents
         file.set_len(0)?;
-        // TODO: figure out if this is necessary
         file.seek(SeekFrom::Start(0))?;
         // store the *next* if
         file.write_all(format!("{}\n", id + 1).as_bytes())?;
···
     }
 
     pub fn new_task(&self, title: String, body: String) -> Result<Task> {
-        // TODO: we could improperly increment the id if the task is not written to disk/errors
+        // WARN: we could improperly increment the id if the task is not written to disk/errors.
+        // But who cares
         let id = self.next_id()?;
-        let mut file = util::flopen(
-            self.path.join("tasks").join(format!("tsk-{}.tsk", id.0)),
-            FlockArg::LockExclusive,
-        )?;
+        let task_path = self.path.join("tasks").join(format!("tsk-{}.tsk", id.0));
+        let mut file = util::flopen(task_path.clone(), FlockArg::LockExclusive)?;
         file.write_all(format!("{title}\n\n{body}").as_bytes())?;
+        // create a hardlink to the archive dir
+        fs::hard_link(
+            task_path,
+            self.path.join("archive").join(format!("tsk-{}.tsk", id.0)),
+        )?;
         Ok(Task {
             id,
             title,
···
         })
     }
 
-    pub fn read_stack(&self, count: Option<usize>) -> Result<TaskStack> {
-        TaskStack::from_tskdir(&self.path, count)
+    pub fn read_stack(&self) -> Result<TaskStack> {
+        TaskStack::from_tskdir(&self.path)
     }
 
     pub fn push_task(&self, task: Task) -> Result<()> {
-        let mut stack = TaskStack::from_tskdir(&self.path, None)?;
+        let mut stack = TaskStack::from_tskdir(&self.path)?;
         stack.push(task.try_into()?);
         stack.save()?;
         Ok(())
     }
 
     pub fn swap_top(&self) -> Result<()> {
-        let mut stack = TaskStack::from_tskdir(&self.path, None)?;
+        let mut stack = TaskStack::from_tskdir(&self.path)?;
         stack.swap();
         stack.save()?;
         Ok(())
+    }
+
+    pub fn drop(&self) -> Result<Option<Id>> {
+        let mut stack = self.read_stack()?;
+        if let Some(stack_item) = stack.pop() {
+            let task_path = self
+                .path
+                .join("tasks")
+                .join(format!("{}.tsk", stack_item.id));
+            fs::remove_file(task_path)?;
+            stack.save()?;
+            Ok(Some(stack_item.id))
+        } else {
+            Ok(None)
+        }
+    }
+
+    pub fn search(&self) -> Result<Option<Id>> {
+        let stack = self.read_stack()?;
+        Ok(fzf::select(stack)?.map(|si| si.id))
     }
 }