imag-notes: Do not call exit() but propagate error to main function

Signed-off-by: Matthias Beyer <mail@beyermatthias.de>

bin/domain/imag-notes/Cargo.toml

@@ -23,6 +23,7 @@ maintenance                       = { status     = "actively-developed" }
 log = "0.4.6"
 itertools = "0.8.0"
 failure = "0.1.5"
+resiter = "0.4.0"
 
 libimagrt        = { version = "0.10.0", path = "../../../lib/core/libimagrt" }
 libimagerror     = { version = "0.10.0", path = "../../../lib/core/libimagerror" }

bin/domain/imag-notes/src/lib.rs

@@ -37,7 +37,8 @@
 extern crate clap;
 #[macro_use] extern crate log;
 extern crate itertools;
-extern crate failure;
+#[macro_use] extern crate failure;
+extern crate resiter;
 
 extern crate libimagnotes;
 extern crate libimagrt;
@@ -47,11 +48,13 @@ extern crate libimagutil;
 extern crate libimagstore;
 
 use std::io::Write;
-use std::process::exit;
 
 use itertools::Itertools;
 use clap::App;
+use failure::Error;
+use failure::err_msg;
 use failure::Fallible as Result;
+use resiter::IterInnerOkOrElse;
 
 use libimagentryedit::edit::Edit;
 use libimagrt::runtime::Runtime;
@@ -59,11 +62,6 @@ use libimagrt::application::ImagApplication;
 use libimagstore::iter::get::StoreIdGetIteratorExtension;
 use libimagnotes::note::Note;
 use libimagnotes::notestore::*;
-use libimagerror::trace::MapErrTrace;
-use libimagerror::exit::ExitUnwrap;
-use libimagerror::io::ToExitCode;
-use libimagerror::iter::TraceIterator;
-use libimagutil::info_result::*;
 use libimagutil::warn_result::WarnResult;
 
 
@@ -76,25 +74,20 @@ mod ui;
 pub enum ImagNotes {}
 impl ImagApplication for ImagNotes {
     fn run(rt: Runtime) -> Result<()> {
-        if let Some(name) = rt.cli().subcommand_name() {
+        match rt.cli().subcommand_name().ok_or_else(|| err_msg("No subcommand called"))? {
-
+            "create" => create(&rt),
-            debug!("Call: {}", name);
+            "delete" => delete(&rt),
-            match name {
+            "edit"  => edit(&rt),
-                "create" => create(&rt),
+            "list"  => list(&rt),
-                "delete" => delete(&rt),
+            other    => {
-                "edit"   => edit(&rt),
+                debug!("Unknown command");
-                "list"   => list(&rt),
+                if rt.handle_unknown_subcommand("imag-notes", other, rt.cli())?.success() {
-                other    => {
+                    Ok(())
-                    debug!("Unknown command");
+                } else {
-                    let _ = rt.handle_unknown_subcommand("imag-notes", other, rt.cli())
+                    Err(err_msg("Failed to handle unknown subcommand"))
-                        .map_err_trace_exit_unwrap()
+                }
-                        .code()
+            },
-                        .map(::std::process::exit);
-                },
-            };
         }
-        
-        Ok(())
     }
 
     fn build_cli<'a>(app: App<'a, 'a>) -> App<'a, 'a> {
@@ -118,74 +111,53 @@ fn name_from_cli(rt: &Runtime, subcmd: &str) -> String {
     rt.cli().subcommand_matches(subcmd).unwrap().value_of("name").map(String::from).unwrap()
 }
 
-fn create(rt: &Runtime) {
+fn create(rt: &Runtime) -> Result<()> {
     let name = name_from_cli(rt, "create");
-    let mut note = rt
+    let mut note = rt.store().new_note(name.clone(), String::new())?;
-        .store()
-        .new_note(name.clone(), String::new())
-        .map_err_trace_exit_unwrap();
 
     if rt.cli().subcommand_matches("create").unwrap().is_present("edit") {
-        note
+        note.edit_content(rt)?
-            .edit_content(rt)
-            .map_warn_err_str("Editing failed")
-            .map_err_trace_exit_unwrap();
     }
 
-    rt.report_touched(note.get_location()).unwrap_or_exit();
+    rt.report_touched(note.get_location()).map_err(Error::from)
 }
 
-fn delete(rt: &Runtime) {
+fn delete(rt: &Runtime) -> Result<()> {
-    rt.store()
+    rt.store().delete_note(name_from_cli(rt, "delete")).map(|_| ())
-        .delete_note(name_from_cli(rt, "delete"))
-        .map_info_str("Ok")
-        .map_err_trace_exit_unwrap();
 }
 
-fn edit(rt: &Runtime) {
+fn edit(rt: &Runtime) -> Result<()> {
     let name = name_from_cli(rt, "edit");
     rt
         .store()
-        .get_note(name.clone())
+        .get_note(name.clone())?
-        .map_err_trace_exit_unwrap()
+        .ok_or_else(|| format_err!("Name '{}' not found", name))
-        .map(|mut note| {
+        .and_then(|mut note| {
-            note
+            note.edit_content(rt).map_warn_err_str("Editing failed")?;
-                .edit_content(rt)
+            rt.report_touched(note.get_location()).map_err(Error::from)
-                .map_warn_err_str("Editing failed")
-                .map_err_trace_exit_unwrap();
-
-            rt.report_touched(note.get_location()).unwrap_or_exit();
         })
-        .unwrap_or_else(|| {
-            error!("Cannot find note with name '{}'", name);
-        });
 }
 
-fn list(rt: &Runtime) {
+fn list(rt: &Runtime) -> Result<()> {
     use std::cmp::Ordering;
 
     rt
         .store()
-        .all_notes()
+        .all_notes()?
-        .map_err_trace_exit_unwrap()
         .into_get_iter(rt.store())
-        .trace_unwrap_exit()
+        .map_inner_ok_or_else(|| err_msg("Did not find one entry"))
-        .map(|opt| opt.unwrap_or_else(|| {
+        .collect::<Result<Vec<_>>>()?
-            error!("Fatal: Nonexistent entry where entry should exist");
+        .into_iter()
-            exit(1)
+        .sorted_by(|a, b| match (a.get_name(), b.get_name()) {
-        }))
+            (Ok(a), Ok(b)) => a.cmp(&b),
-        .sorted_by(|note_a, note_b| if let (Ok(a), Ok(b)) = (note_a.get_name(), note_b.get_name()) {
+            _ => Ordering::Greater,
-            a.cmp(&b)
-        } else {
-            Ordering::Greater
         })
-        .for_each(|note| {
+        .map(|note| {
-            let name = note.get_name().map_err_trace_exit_unwrap();
+            let name = note.get_name().map_err(Error::from)?;
-            writeln!(rt.stdout(), "{}", name)
+            writeln!(rt.stdout(), "{}", name)?;
-                .to_exit_code()
+            rt.report_touched(note.get_location()).map_err(Error::from)
-                .unwrap_or_exit();
+        })
-
+        .collect::<Result<Vec<_>>>()
-            rt.report_touched(note.get_location()).unwrap_or_exit();
+        .map(|_| ())
-        });
 }