ADD: show command, cleanup

src/main.rs

···
         full_id: bool,
     },
 
+    Show {
+        /// The [TSK-]ID of the task to display
+        #[command(flatten)]
+        task_id: TaskId,
+    },
+
     /// Drops the task on the top of the stack and archives it.
     Drop,
 
···
         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::Edit { task_id } => command_edit(dir, task_id),
         Commands::Completion { shell } => command_completion(shell),
         Commands::Drop => command_drop(dir),
···
     let mut body = body.unwrap_or_default();
     if body == "-" {
         // add newline so you can type directly in the shell
-        eprintln!("");
+        //eprintln!("");
         body.clear();
         std::io::stdin().read_to_string(&mut body)?;
     }
···
 fn command_reprioritize(dir: PathBuf, task_id: TaskId) -> Result<()> {
     Workspace::from_path(dir)?.reprioritize(task_id.into())
 }
+
+fn command_show(dir: PathBuf, task_id: TaskId) -> Result<()> {
+    let task = Workspace::from_path(dir)?.task(task_id.into())?;
+    println!("{task}");
+    Ok(())
+}

src/workspace.rs

···
         drop(reader);
         Ok(Task {
             id,
-            title,
-            body,
+            title: title.trim().to_string(),
+            body: body.trim().to_string(),
             file,
         })
     }
···
     pub file: Flock<File>,
 }
 
-/// A task container without a file handle
-pub struct BareTask {
-    pub id: Id,
-    pub title: String,
-    pub body: String,
+impl Display for Task {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}\n\n{}", self.title, &self.body)
+    }
 }
 
 impl Task {
···
         Ok(())
     }
 
-    fn bare(self) -> BareTask {
-        BareTask {
+    fn bare(self) -> SearchTask {
+        SearchTask {
             id: self.id,
             title: self.title,
             body: self.body,
···
     }
 }
 
-impl FromStr for BareTask {
+/// A task container without a file handle
+pub struct SearchTask {
+    pub id: Id,
+    pub title: String,
+    pub body: String,
+}
+
+impl FromStr for SearchTask {
     type Err = Error;
 
     fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
···
     }
 }
 
-impl Display for BareTask {
+impl Display for SearchTask {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(
             f,
···
 }
 
 impl<'a> Iterator for LazyTaskLoader<'a> {
-    type Item = BareTask;
+    type Item = SearchTask;
 
     fn next(&mut self) -> Option<Self::Item> {
         let stack_item = self.files.next()?;
···
 
     #[test]
     fn test_bare_task_display() {
-        let task = BareTask {
+        let task = SearchTask {
             id: Id(123),
             title: "Hello, world".to_string(),
             body: "The body of the task.\nAnother line\r\nis here.".to_string(),
···
             "tsk-123\tHello, world\tThe body of the task. Another line is here.",
             task.to_string()
         );
+    }
+
+    #[test]
+    fn test_task_display() {
+        let task = Task {
+            id: Id(123),
+            title: "Hello, world".to_string(),
+            body: "The body of the task.".to_string(),
+            file: util::flopen("/dev/null".into(), FlockArg::LockShared).unwrap(),
+        };
+        assert_eq!("Hello, world\n\nThe body of the task.", task.to_string());
     }
 }