ent: better error reporting

Reviewed-on: #7

src/bin/ent/main.rs

@@ -1,5 +1,6 @@
 use clap::Parser;
 
+use entomologist::issue::State;
 #[cfg(feature = "log")]
 use simple_logger;
 
@@ -32,6 +33,12 @@ enum Commands {
 
     /// Show the full description of an issue.
     Show { issue_id: String },
+
+    /// Modify the state of an issue
+    State {
+        issue_id: String,
+        new_state: Option<State>,
+    },
 }
 
 fn handle_command(args: &Args, issues_dir: &std::path::Path) -> anyhow::Result<()> {
@@ -43,6 +50,7 @@ fn handle_command(args: &Args, issues_dir: &std::path::Path) -> anyhow::Result<(
                 println!("{} {} ({:?})", uuid, issue.title(), issue.state);
             }
         }
+
         Commands::New {
             description: Some(description),
         } => {
@@ -50,35 +58,68 @@ fn handle_command(args: &Args, issues_dir: &std::path::Path) -> anyhow::Result<(
             issue.set_description(description)?;
             println!("created new issue '{}'", issue.title());
         }
+
         Commands::New { description: None } => {
             let mut issue = entomologist::issue::Issue::new(issues_dir)?;
             issue.edit_description()?;
             println!("created new issue '{}'", issue.title());
         }
+
         Commands::Edit { issue_id } => {
             let mut issues =
                 entomologist::issues::Issues::new_from_dir(std::path::Path::new(issues_dir))?;
-            match issues.issues.get_mut(issue_id) {
+            match issues.get_mut_issue(issue_id) {
                 Some(issue) => {
                     issue.edit_description()?;
                 }
                 None => {
-                    println!("issue {} not found", issue_id);
+                    return Err(anyhow::anyhow!("issue {} not found", issue_id));
                 }
             }
         }
+
         Commands::Show { issue_id } => {
             let issues =
                 entomologist::issues::Issues::new_from_dir(std::path::Path::new(issues_dir))?;
-            match issues.issues.get(issue_id) {
+            match issues.get_issue(issue_id) {
                 Some(issue) => {
                     println!("issue {}", issue_id);
-                    println!("state {:?}", issue.state);
+                    println!("state: {:?}", issue.state);
+                    if let Some(dependencies) = &issue.dependencies {
+                        println!("dependencies: {:?}", dependencies);
+                    }
                     println!("");
                     println!("{}", issue.description);
                 }
                 None => {
-                    println!("issue {} not found", issue_id);
+                    return Err(anyhow::anyhow!("issue {} not found", issue_id));
+                }
+            }
+        }
+
+        Commands::State {
+            issue_id,
+            new_state,
+        } => {
+            let mut issues =
+                entomologist::issues::Issues::new_from_dir(std::path::Path::new(issues_dir))?;
+            match issues.issues.get_mut(issue_id) {
+                Some(issue) => {
+                    let current_state = issue.state.clone();
+                    match new_state {
+                        Some(s) => {
+                            issue.set_state(s.clone())?;
+                            println!("issue: {}", issue_id);
+                            println!("state: {} -> {}", current_state, s);
+                        }
+                        None => {
+                            println!("issue: {}", issue_id);
+                            println!("state: {}", current_state);
+                        }
+                    }
+                }
+                None => {
+                    return Err(anyhow::anyhow!("issue {} not found", issue_id));
                 }
             }
         }

src/git.rs

@@ -213,7 +213,7 @@ mod tests {
     fn test_create_orphan_branch() {
         let rnd: u128 = rand::random();
         let mut branch = std::string::String::from("entomologist-test-branch-");
-        branch.push_str(&format!("{:0x}", rnd));
+        branch.push_str(&format!("{:032x}", rnd));
         create_orphan_branch(&branch).unwrap();
         git_remove_branch(&branch).unwrap();
     }
@@ -228,7 +228,7 @@ mod tests {
     fn test_branch_exists_1() {
         let rnd: u128 = rand::random();
         let mut branch = std::string::String::from("entomologist-missing-branch-");
-        branch.push_str(&format!("{:0x}", rnd));
+        branch.push_str(&format!("{:032x}", rnd));
         let r = git_branch_exists(&branch).unwrap();
         assert_eq!(r, false);
     }

src/issue.rs

@@ -1,10 +1,11 @@
+use core::fmt;
 use std::io::Write;
 use std::str::FromStr;
 
 #[cfg(feature = "log")]
 use log::debug;
 
-#[derive(Debug, PartialEq, serde::Deserialize)]
+#[derive(Clone, Debug, PartialEq, serde::Deserialize)]
 /// These are the states an issue can be in.
 pub enum State {
     New,
@@ -62,6 +63,21 @@ impl FromStr for State {
     }
 }
 
+impl fmt::Display for State {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let fmt_str = match self {
+            State::New => "new",
+            State::Backlog => "backlog",
+            State::Blocked => "blocked",
+            State::InProgress => "inprogress",
+            State::Done => "done",
+            State::WontDo => "wontdo",
+            
+        };
+        write!(f, "{fmt_str}")
+    }
+}
+
 impl Issue {
     pub fn new_from_dir(dir: &std::path::Path) -> Result<Self, IssueError> {
         let mut description: Option<String> = None;
@@ -107,7 +123,7 @@ impl Issue {
     pub fn new(dir: &std::path::Path) -> Result<Self, IssueError> {
         let mut issue_dir = std::path::PathBuf::from(dir);
         let rnd: u128 = rand::random();
-        issue_dir.push(&format!("{:0x}", rnd));
+        issue_dir.push(&format!("{:032x}", rnd));
         std::fs::create_dir(&issue_dir)?;
         Ok(Self {
             description: String::from(""), // FIXME: kind of bogus to use the empty string as None
@@ -157,6 +173,23 @@ impl Issue {
             None => self.description.as_str(),
         }
     }
+
+    pub fn set_state(&mut self, new_state: State) -> Result<(), IssueError> {
+        let mut state_filename = std::path::PathBuf::from(&self.dir);
+        state_filename.push("state");
+        let mut state_file = std::fs::File::create(&state_filename)?;
+        write!(state_file, "{}", new_state)?;
+        crate::git::git_commit_file(&state_filename)?;
+        Ok(())
+    }
+
+    pub fn read_state(&mut self) -> Result<(), IssueError> {
+        let mut state_filename = std::path::PathBuf::from(&self.dir);
+        state_filename.push("state");
+        let state_string = std::fs::read_to_string(state_filename)?;
+        self.state = State::from_str(state_string.trim())?;
+        Ok(())
+    }
 }
 
 #[cfg(test)]

src/issues.rs

@@ -35,6 +35,14 @@ impl Issues {
         self.issues.insert(uuid, issue);
     }
 
+    pub fn get_issue(&self, issue_id: &str) -> Option<&crate::issue::Issue> {
+        self.issues.get(issue_id)
+    }
+
+    pub fn get_mut_issue(&mut self, issue_id: &str) -> Option<&mut crate::issue::Issue> {
+        self.issues.get_mut(issue_id)
+    }
+
     fn parse_config(&mut self, config_path: &std::path::Path) -> Result<(), ReadIssuesError> {
         let config_contents = std::fs::read_to_string(config_path)?;
         let config: Config = toml::from_str(&config_contents)?;