1 files changed, 25 insertions, 40 deletions

diff --git a/bin/domain/imag-timetrack/src/shell.rs b/bin/domain/imag-timetrack/src/shell.rs
index c66bfe13..30693438 100644
--- a/bin/domain/imag-timetrack/src/shell.rs
+++ b/bin/domain/imag-timetrack/src/shell.rs
@@ -21,19 +21,19 @@ use std::env;
 use std::process::Command;
 
 use filters::filter::Filter;
+use failure::Fallible as Result;
+use failure::err_msg;
+use failure::Error;
+use resiter::Filter as RFilter;
+use resiter::AndThen;
 
-use libimagerror::exit::ExitUnwrap;
-use libimagerror::iter::TraceIterator;
-use libimagerror::trace::MapErrTrace;
-use libimagerror::trace::trace_error;
 use libimagrt::runtime::Runtime;
 use libimagtimetrack::iter::filter::has_one_of_tags;
 use libimagtimetrack::store::TimeTrackStore;
 use libimagtimetrack::tag::TimeTrackingTag;
 use libimagtimetrack::timetracking::TimeTracking;
-use libimagutil::warn_result::*;
 
-pub fn shell(rt: &Runtime) -> i32 {
+pub fn shell(rt: &Runtime) -> Result<()> {
     let (_, cmd) = rt.cli().subcommand();
     let cmd = cmd.unwrap(); // checked in main()
 
@@ -54,57 +54,42 @@ pub fn shell(rt: &Runtime) -> i32 {
         };
 
         if let Some(s) = cmd.value_of("shell") {
-            mkshell(s.to_owned())
+            Ok(mkshell(s.to_owned()))
         } else {
             env::var("SHELL")
                 .map(mkshell)
                 .map_err(|e| match e {
                     env::VarError::NotPresent => {
-                        error!("No $SHELL variable in environment, cannot work!");
-                        ::std::process::exit(1)
+                        err_msg("No $SHELL variable in environment, cannot work!")
                     },
                     env::VarError::NotUnicode(_) => {
-                        error!("$SHELL variable is not unicode, cannot work!");
-                        ::std::process::exit(1)
+                        err_msg("SHELL variable is not unicode, cannot work!")
                     }
                 })
-                .unwrap()
         }
-    };
+    }?;
 
     for tag in tags.iter() {
-        match rt.store().create_timetracking_at(&start, tag) {
-            Err(e) => trace_error(&e),
-            Ok(entry) => {
-                rt.report_touched(entry.get_location()).unwrap_or_exit();
-            }
-        }
+        let entry = rt.store().create_timetracking_at(&start, tag)?;
+        rt.report_touched(entry.get_location())?;
     }
 
-    let exit_code = match shellcmd.status() {
-        Ok(estat) => estat.code().unwrap_or(0),
-        Err(e) => {
-            error!("Error starting shell: {:?}", e);
-            ::std::process::exit(2)
-        },
-    };
+    if !shellcmd.status()?.success() {
+        return Err(format_err!("Failed to execute {:?}", shellcmd))
+    }
+    let stop      = ::chrono::offset::Local::now().naive_local();
+    let filter    = has_one_of_tags(&tags);
 
-    let stop = ::chrono::offset::Local::now().naive_local();
-    let filter = has_one_of_tags(&tags);
     rt.store()
-        .get_timetrackings()
-        .map_warn_err_str("Getting timetrackings failed")
-        .map_err_trace_exit_unwrap()
-        .trace_unwrap()
-        .filter(|e| filter.filter(e))
-        .for_each(|mut elem| if let Err(e) = elem.set_end_datetime(stop.clone()) {
-            trace_error(&e)
-        } else {
+        .get_timetrackings()?
+        .filter_ok(|e| filter.filter(e))
+        .and_then_ok(|mut elem| {
+            let _ = elem.set_end_datetime(stop.clone())?;
             debug!("Setting end time worked: {:?}", elem);
-            rt.report_touched(elem.get_location()).unwrap_or_exit();
-        });
-
-    ::std::process::exit(exit_code)
+            rt.report_touched(elem.get_location()).map_err(Error::from)
+        })
+        .collect::<Result<Vec<_>>>()
+        .map(|_| ())
 }