Make better use of fzf's search

src/attrs.rs

···
+use std::collections::BTreeMap;
 use std::collections::btree_map::Entry;
 use std::collections::btree_map::{IntoIter as BTreeIntoIter, Iter as BTreeMapIter};
-use std::collections::BTreeMap;
 use std::iter::Chain;
 
 type Map = BTreeMap<String, String>;

src/fzf.rs

···
 use crate::errors::{Error, Result};
+use std::ffi::OsStr;
 use std::fmt::Display;
 use std::io::Write;
 use std::process::{Command, Stdio};
···
 
 /// 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>>
+pub fn select<I, O, S>(
+    input: impl IntoIterator<Item = I>,
+    extra: impl IntoIterator<Item = S>,
+) -> Result<Option<O>>
 where
-    I: Display + FromStr,
-    Error: From<<I as FromStr>::Err>,
+    O: FromStr,
+    I: Display,
+    Error: From<<O as FromStr>::Err>,
+    S: AsRef<OsStr>,
 {
-    let mut child = Command::new("fzf")
-        .args(["-d", "\t"])
+    let mut command = Command::new("fzf");
+    let mut child = command
+        .args(extra)
+        .arg("--read0")
         .stderr(Stdio::inherit())
         .stdin(Stdio::piped())
         .stdout(Stdio::piped())
···
     // unwrap: this can never fail
     let child_in = child.stdin.as_mut().unwrap();
     for item in input.into_iter() {
-        writeln!(child_in, "{item}")?;
+        write!(child_in, "{item}\0")?;
     }
     let output = child.wait_with_output()?;
     if output.stdout.is_empty() {

src/main.rs

···
 mod task;
 mod util;
 mod workspace;
-use clap_complete::{generate, Shell};
+use clap_complete::{Shell, generate};
 use errors::Result;
 use std::io::{self, Write};
 use std::path::PathBuf;

src/stack.rs

···
 
 use crate::errors::{Error, Result};
 use crate::util;
-use std::collections::vec_deque::Iter;
 use std::collections::VecDeque;
+use std::collections::vec_deque::Iter;
 use std::fmt::Display;
 use std::fs::File;
 use std::io::{self, BufRead, BufReader, Seek, Write};

src/workspace.rs

···
 use crate::stack::{StackItem, TaskStack};
 use crate::task::parse as parse_task;
 use crate::{fzf, util};
-use std::collections::{vec_deque, BTreeMap, HashSet};
+use std::collections::{BTreeMap, HashSet, vec_deque};
 use std::ffi::OsString;
 use std::fmt::Display;
-use std::fs::{remove_file, File};
+use std::fs::{File, remove_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::process::{Command, Stdio};
 use std::str::FromStr;
 use std::{fs::OpenOptions, io::Write};
 
···
     type Err = Error;
 
     fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        let s = s
+        let upper = s.to_uppercase();
+        let s = upper
             .trim()
-            .strip_prefix("tsk-")
+            .strip_prefix("TSK-")
             .ok_or(Self::Err::Parse(format!("expected tsk- prefix. Got {s}")))?;
         Ok(Self(s.parse()?))
     }
···
             .create(true)
             .truncate(true)
             .open(tsk_dir.join("next"))?;
+        // initialize the next file with ID 1
         next.write_all(b"1\n")?;
         Ok(())
     }
···
                 workspace: self,
             };
             // search the entirety of a task
-            Ok(fzf::select(loader)?.map(|bt| bt.id))
+            Ok(fzf::select::<_, Id, _>(
+                loader,
+                [
+                    "--no-multi-line",
+                    "--accept-nth=1",
+                    "--delimiter=\t",
+                    "--preview=tsk show -T {1}",
+                    "--preview-window=top",
+                    "--ansi",
+                    "--info-command=tsk show -T {1} | head -n1",
+                    "--info=inline-right",
+                ],
+            )?)
         } else {
             // just search the stack
-            Ok(fzf::select(stack)?.map(|si| si.id))
+            Ok(fzf::select::<_, Id, _>(
+                stack,
+                ["--delimiter=\t", "--accept-nth=1"],
+            )?)
         }
     }
 
···
         Ok(())
     }
 
+    /// Returns a [`SearchTas`] which is plain task data with no file or attrs
     fn bare(self) -> SearchTask {
         SearchTask {
             id: self.id,
···
     pub body: String,
 }
 
-impl FromStr for SearchTask {
-    type Err = Error;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        let (tsk_id, task_content) = s.split_once('\t').ok_or(Error::Parse(
-            "Missing TSK-ID or content or task parse.".to_owned(),
-        ))?;
-        let (title, body) = task_content
-            .split_once('\t')
-            .ok_or(Error::Parse("Missing body for task parse.".to_owned()))?;
-        Ok(Self {
-            id: tsk_id.parse()?,
-            title: title.to_string(),
-            body: body.to_string(),
-        })
-    }
-}
-
 impl Display for SearchTask {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "{}\t{}\t{}",
-            self.id,
-            self.title.trim(),
-            self.body.replace('\n', " ").replace('\r', "")
-        )
+        write!(f, "{}\t{}", self.id, self.title.trim())?;
+        if !self.body.is_empty() {
+            write!(f, "\n\n{}", self.body)?;
+        }
+        Ok(())
     }
 }
 
···
     }
 }
 
+fn select_task(input: impl IntoIterator<Item = SearchTask>) -> Result<Option<Id>> {
+    let mut child = Command::new("cat")
+        .stderr(Stdio::inherit())
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .spawn()?;
+    let child_in = child.stdin.as_mut().unwrap();
+    for item in input.into_iter() {
+        writeln!(child_in, "{item}\0")?;
+    }
+    let output = child.wait_with_output()?;
+    if output.stdout.is_empty() {
+        Ok(None)
+    } else {
+        Ok(Some(String::from_utf8(output.stdout)?.parse()?))
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::*;
···
         let task = SearchTask {
             id: Id(123),
             title: "Hello, world".to_string(),
-            body: "The body of the task.\nAnother line\r\nis here.".to_string(),
+            body: "The body of the task.\nAnother line is here.".to_string(),
         };
         assert_eq!(
-            "tsk-123\tHello, world\tThe body of the task. Another line is here.",
+            "tsk-123\tHello, world\n\nThe body of the task.\nAnother line is here.",
             task.to_string()
         );
     }