ADD: completion and edit commands

src/main.rs

···
 mod stack;
 mod util;
 mod workspace;
+use clap_complete::{generate, Shell};
+use std::io;
 use std::path::PathBuf;
 use std::{env::current_dir, io::Read};
-use clap_complete::Shell;
 use workspace::Workspace;
 
 //use smol;
 //use iocraft::prelude::*;
-use clap::{Args, Parser, Subcommand};
+use clap::{Args, CommandFactory, Parser, Subcommand};
 use edit::edit as open_editor;
 
 fn default_dir() -> PathBuf {
···
 
     Edit {
         #[arg(short = 't')]
-        task_id: u32
+        task_id: u32,
     },
 
     Completion {
         #[arg(short = 's')]
-        shell: Shell
+        shell: Shell,
+    },
+
+    /*
+    Drop {
+        #[arg(short = 't')]
+        task_id: Option<u32>,
     }
+    */
 }
 
 #[derive(Args)]
···
             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()))
+        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),
     }
 }
 
···
 
 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 {
+    let mut title = if let Some(title) = title.title {
         title
     } else if let Some(title) = title.title_simple {
         let joined = title.join(" ");
···
             .expect("Failed to read stdin");
     }
     if edit {
-        body = open_editor(format!("{title}\n\n{body}")).expect("Failed to edit file");
+        let new_content = open_editor(format!("{title}\n\n{body}")).expect("Failed to edit file");
+        if let Some(content) = new_content.split_once("\n") {
+            title = content.0.to_string();
+            body = content.1.to_string();
+        }
     }
     let task = workspace
         .new_task(title, body)
···
     workspace.swap_top().expect("swap to work");
 }
 
-fn command_edit(dir: PathBuf) {
+fn command_edit(dir: PathBuf, id: u32) {
     let workspace = Workspace::from_path(dir).expect("Unable to find .tsk dir");
-    let task = workspace.
+    let mut task = workspace.task(id.into()).expect("To read task from disk");
+    let new_content =
+        open_editor(format!("{}\n\n{}", task.title.trim(), task.body.trim())).expect("Failed to edit file");
+    if let Some((title, body)) = new_content.split_once("\n") {
+        task.title = title.to_string();
+        task.body = body.to_string();
+        task.save().expect("Failed to save task");
+    }
+}
+
+fn command_completion(shell: Shell) {
+    generate(shell, &mut Cli::command(), "tsk", &mut io::stdout())
 }

src/workspace.rs

···
 use crate::util;
 use std::fmt::Display;
 use std::fs::File;
-use std::io::{Read, Seek};
+use std::io::{BufRead as _, BufReader, Read, Seek, SeekFrom};
 use std::path::PathBuf;
 use std::str::FromStr;
 use std::{fs::OpenOptions, io::Write};
···
 impl Display for Id {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "tsk-{}", self.0)
+    }
+}
+
+impl From<u32> for Id {
+    fn from(value: u32) -> Self {
+        Id(value)
     }
 }
 
···
         // reset the files contents
         file.set_len(0)?;
         // TODO: figure out if this is necessary
-        file.seek(std::io::SeekFrom::Start(0))?;
+        file.seek(SeekFrom::Start(0))?;
         // store the *next* if
         file.write_all(format!("{}\n", id + 1).as_bytes())?;
         Ok(Id(id))
···
     }
 
     pub fn task(&self, id: Id) -> Result<Task> {
-        let mut file = util::flopen(
+        let file = util::flopen(
             self.path.join("tasks").join(format!("tsk-{}.tsk", id.0)),
             FlockArg::LockExclusive,
         )?;
-        
+        let mut title = String::new();
+        let mut body = String::new();
+        let mut reader = BufReader::new(&*file);
+        reader.read_line(&mut title)?;
+        reader.read_to_string(&mut body)?;
+        drop(reader);
+        Ok(Task {
+            id,
+            title,
+            body,
+            file,
+        })
     }
 
     pub fn read_stack(&self, count: Option<usize>) -> Result<TaskStack> {
···
     pub file: Flock<File>,
 }
 
-#[cfg(test)]
-mod test {
-    fn test_next_id() {}
+impl Task {
+    /// Consumes a task and saves it to disk.
+    pub fn save(mut self) -> Result<()> {
+        self.file.set_len(0)?;
+        self.file.seek(SeekFrom::Start(0))?;
+        self.file.write_all(self.title.trim().as_bytes())?;
+        self.file.write_all(b"\n\n")?;
+        self.file.write_all(self.body.trim().as_bytes())?;
+        Ok(())
+    }
 }