matthiasbeyer/imag
1
0
Fork 0
Code Releases Activity

Merge branch 'imag-calendar-noexit' into master

Browse source 
Signed-off-by: Matthias Beyer <mail@beyermatthias.de>
This commit is contained in:
Matthias Beyer 2019-10-27 18:44:49 +01:00
commit c67f0bbd4b
2 changed files with 117 additions and 127 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
bin/domain/imag-calendar/Cargo.toml
View file

@ -28,6 +28,7 @@ vobject = "0.7"
handlebars = "2" handlebars = "2"
chrono = "0.4" chrono = "0.4"
kairos = "0.3" kairos = "0.3"
resiter = "0.4.0"
libimagrt = { version = "0.10.0", path = "../../../lib/core/libimagrt" } libimagrt = { version = "0.10.0", path = "../../../lib/core/libimagrt" }
libimagstore = { version = "0.10.0", path = "../../../lib/core/libimagstore" } libimagstore = { version = "0.10.0", path = "../../../lib/core/libimagstore" }
@ -54,4 +55,4 @@ path = "src/lib.rs"
[[bin]] [[bin]]
name = "imag-calendar" name = "imag-calendar"
path = "src/bin.rs" path = "src/bin.rs"

241
bin/domain/imag-calendar/src/lib.rs
View file

@ -42,6 +42,7 @@ extern crate walkdir;
extern crate handlebars; extern crate handlebars;
extern crate chrono; extern crate chrono;
extern crate kairos; extern crate kairos;
extern crate resiter;
extern crate libimagrt; extern crate libimagrt;
extern crate libimagcalendar; extern crate libimagcalendar;
@ -50,7 +51,6 @@ extern crate libimagstore;
extern crate libimagutil; extern crate libimagutil;
use std::path::PathBuf; use std::path::PathBuf;
use std::result::Result as RResult;
use std::io::Write; use std::io::Write;
use failure::Error; use failure::Error;
@ -62,14 +62,14 @@ use walkdir::DirEntry;
use walkdir::WalkDir; use walkdir::WalkDir;
use vobject::icalendar::Event; use vobject::icalendar::Event;
use clap::App; use clap::App;
use resiter::AndThen;
use resiter::Filter;
use resiter::Map;
use libimagcalendar::store::EventStore; use libimagcalendar::store::EventStore;
use libimagerror::io::ToExitCode;
use libimagerror::exit::ExitUnwrap;
use libimagerror::iter::TraceIterator;
use libimagerror::trace::MapErrTrace;
use libimagrt::runtime::Runtime; use libimagrt::runtime::Runtime;
use libimagrt::application::ImagApplication; use libimagrt::application::ImagApplication;
use crate::resiter::IterInnerOkOrElse;
mod filters; mod filters;
mod ui; mod ui;
@ -82,66 +82,58 @@ mod util;
pub enum ImagCalendar {} pub enum ImagCalendar {}
impl ImagApplication for ImagCalendar { impl ImagApplication for ImagCalendar {
fn run(rt: Runtime) -> Result<()> { 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"))? {
debug!("Call {}", name); "import" => import(&rt),
match name { "list" => list(&rt),
"import" => import(&rt), "show" => show(&rt),
"list" => list(&rt), other => {
"show" => show(&rt), warn!("Right now, only the 'import' command is available");
other => { debug!("Unknown command");
warn!("Right now, only the 'import' command is available"); if rt.handle_unknown_subcommand("imag-calendar", other, rt.cli())?.success() {
debug!("Unknown command"); Ok(())
let _ = rt.handle_unknown_subcommand("imag-calendar", other, rt.cli()) } else {
.map_err_trace_exit_unwrap() Err(err_msg("Failed to handle unknown subcommand"))
.code() }
.map(::std::process::exit); },
}, }
}
}
Ok(())
} }
fn build_cli<'a>(app: App<'a, 'a>) -> App<'a, 'a> { fn build_cli<'a>(app: App<'a, 'a>) -> App<'a, 'a> {
ui::build_ui(app) ui::build_ui(app)
} }
fn name() -> &'static str { fn name() -> &'static str {
env!("CARGO_PKG_NAME") env!("CARGO_PKG_NAME")
} }
fn description() -> &'static str { fn description() -> &'static str {
"Calendar management tool" "Calendar management tool"
} }
fn version() -> &'static str { fn version() -> &'static str {
env!("CARGO_PKG_VERSION") env!("CARGO_PKG_VERSION")
} }
} }
fn import(rt: &Runtime) { fn import(rt: &Runtime) -> Result<()> {
let scmd = rt.cli().subcommand_matches("import").unwrap(); // safe by clap let scmd = rt.cli().subcommand_matches("import").unwrap(); // safe by clap
let collection_name = rt.cli().value_of("calendar-ref-collection-name").unwrap(); // default by clap let collection_name = rt.cli().value_of("calendar-ref-collection-name").unwrap(); // default by clap
let do_fail = scmd.is_present("import-fail"); let do_fail = scmd.is_present("import-fail");
let force_override = scmd.is_present("import-force-override"); let force_override = scmd.is_present("import-force-override");
let ref_config = rt.config() let ref_config = rt.config()
.ok_or_else(|| format_err!("No configuration, cannot continue!")) .ok_or_else(|| format_err!("No configuration, cannot continue!"))?
.map_err_trace_exit_unwrap() .read_partial::<libimagentryref::reference::Config>()?
.read_partial::<libimagentryref::reference::Config>() .ok_or_else(|| format_err!("Configuration missing: {}", libimagentryref::reference::Config::LOCATION))?;
.map_err(Error::from)
.map_err_trace_exit_unwrap()
.ok_or_else(|| format_err!("Configuration missing: {}", libimagentryref::reference::Config::LOCATION))
.map_err_trace_exit_unwrap();
// sanity check // sanity check
debug!("Doing sanity check on config, to see whether the configuration required for importing is there"); debug!("Doing sanity check on config, to see whether the configuration required for importing is there");
if ref_config.get(collection_name).is_none() { if ref_config.get(collection_name).is_none() {
error!("Configuration missing: {}.{}", libimagentryref::reference::Config::LOCATION, collection_name); return Err(format_err!("Configuration missing: {}.{}", libimagentryref::reference::Config::LOCATION, collection_name))
::std::process::exit(1);
} }
debug!("Starting import..."); debug!("Starting import...");
scmd.values_of("filesordirs") let iter = scmd
.values_of("filesordirs")
.unwrap() // save by clap .unwrap() // save by clap
.into_iter() .into_iter()
.map(PathBuf::from) .map(PathBuf::from)
@ -166,51 +158,49 @@ fn import(rt: &Runtime) {
Box::new(std::iter::once(Ok(path))) Box::new(std::iter::once(Ok(path)))
}) })
.flat_map(|it| it) // From Iter<Iter<Result<PathBuf>>> to Iter<Result<PathBuf>> .flat_map(|it| it) // From Iter<Iter<Result<PathBuf>>> to Iter<Result<PathBuf>>
.trace_unwrap_exit() //... to Iter<PathBuf> .and_then_ok(|path| {
.map(|path| {
trace!("Importing {}", path.display()); trace!("Importing {}", path.display());
let v = rt.store().import_from_path(path, collection_name, &ref_config, force_override)?; Ok({
Ok(v.into_iter() rt.store()
.filter_map(|result| if do_fail { .import_from_path(path, collection_name, &ref_config, force_override)?
Some(result.map_err_trace_exit_unwrap()) .into_iter()
} else { })
match result { }) // Iter<Result<Iter<_>>
Err(e) => { warn!("Error while importing: {}", e); None } .collect::<Result<Vec<_>>>()?
Ok(fle) => Some(fle), .into_iter()
}
}))
})
.trace_unwrap_exit()
.flat_map(|it| it) .flat_map(|it| it)
.for_each(|fle| rt.report_touched(fle.get_location()).unwrap_or_exit()); .and_then_ok(|fle| rt.report_touched(fle.get_location()).map_err(Error::from));
if do_fail {
iter.collect()
} else {
for element in iter {
if let Err(e) = element {
writeln!(rt.stderr(), "Error while importing: {:?}", e)?;
}
}
Ok(())
}
} }
fn list(rt: &Runtime) { fn list(rt: &Runtime) -> Result<()> {
use util::*; use util::*;
let scmd = rt.cli().subcommand_matches("list").unwrap(); // safe by clap let scmd = rt.cli().subcommand_matches("list").unwrap(); // safe by clap
let list_format = get_event_print_format("calendar.list_format", rt, &scmd) let list_format = get_event_print_format("calendar.list_format", rt, &scmd)?;
.map_err_trace_exit_unwrap();
let do_filter_past = !scmd.is_present("list-past"); let do_filter_past = !scmd.is_present("list-past");
let do_filter_before = scmd.value_of("list-before"); let do_filter_before = scmd.value_of("list-before");
let do_filter_after = scmd.value_of("list-after"); let do_filter_after = scmd.value_of("list-after");
let ref_config = rt.config()
let ref_config = rt.config() .ok_or_else(|| format_err!("No configuration, cannot continue!"))?
.ok_or_else(|| format_err!("No configuration, cannot continue!")) .read_partial::<libimagentryref::reference::Config>()?
.map_err_trace_exit_unwrap() .ok_or_else(|| format_err!("Configuration missing: {}", libimagentryref::reference::Config::LOCATION))?;
.read_partial::<libimagentryref::reference::Config>()
.map_err(Error::from)
.map_err_trace_exit_unwrap()
.ok_or_else(|| format_err!("Configuration missing: {}", libimagentryref::reference::Config::LOCATION))
.map_err_trace_exit_unwrap();
debug!("List format: {:?}", list_format); debug!("List format: {:?}", list_format);
debug!("Ref config : {:?}", ref_config); debug!("Ref config : {:?}", ref_config);
let today = ::chrono::Local::now().naive_local(); let today = ::chrono::Local::now().naive_local();
let event_filter = |e: &'_ Event| { // what a crazy hack to make the compiler happy let event_filter = |e: &'_ Event| -> Result<bool> { // what a crazy hack to make the compiler happy
debug!("Filtering event: {:?}", e); debug!("Filtering event: {:?}", e);
// generate a function `filter_past` which filters out the past or not // generate a function `filter_past` which filters out the past or not
@ -220,105 +210,104 @@ fn list(rt: &Runtime) {
true true
}; };
let do_filter_before = do_filter_before.map(|spec| kairos_parse(spec).map_err_trace_exit_unwrap()); let do_filter_before = do_filter_before.map(|spec| kairos_parse(spec));
let allow_events_before_date = |event| do_filter_before.as_ref().map(|spec| { let allow_events_before_date = |event| -> Result<bool> {
filters::event_is_before(event, spec) Ok(do_filter_before.transpose()?.as_ref().map(|spec| {
}).unwrap_or(true); filters::event_is_before(event, spec)
}).unwrap_or(true))
};
let do_filter_after = do_filter_after.map(|spec| kairos_parse(spec).map_err_trace_exit_unwrap()); let do_filter_after = do_filter_after.map(|spec| kairos_parse(spec));
let allow_events_after_date = |event| do_filter_after.as_ref().map(|spec| { let allow_events_after_date = |event| -> Result<bool> {
filters::event_is_after(event, spec) Ok(do_filter_after.transpose()?.as_ref().map(|spec| {
}).unwrap_or(true); filters::event_is_after(event, spec)
}).unwrap_or(true))
};
allow_all_past_events(e) && allow_events_before_date(e) && allow_events_after_date(e) Ok(allow_all_past_events(e) && allow_events_before_date(e)? && allow_events_after_date(e)?)
}; };
let mut listed_events = 0; let mut listed_events = 0;
rt.store() rt.store()
.all_events() .all_events()?
.map_err_trace_exit_unwrap() .and_then_ok(|sid| rt.store().get(sid))
.trace_unwrap_exit() .map_inner_ok_or_else(|| err_msg("Missing entrty while calling all_events()"))
.map(|sid| rt.store().get(sid)) .and_then_ok(|ev| ParsedEventFLE::parse(ev, &ref_config))
.trace_unwrap_exit() .and_then_ok(|parsed_entry| {
.map(|oe| oe.ok_or_else(|| err_msg("Missing entry while calling all_events()")))
.trace_unwrap_exit()
.map(|ev| ParsedEventFLE::parse(ev, &ref_config))
.trace_unwrap_exit()
.for_each(|parsed_entry| {
parsed_entry parsed_entry
.get_data() .get_data()
.events() .events()
.filter_map(RResult::ok) .map_err(|component| Error::from(format_err!("Failed to parse entry: {}", component.name)))
.filter(event_filter) .and_then_ok(|event| {
.for_each(|event| { event_filter(&event).map(|b| (event, b))
})
.filter_ok(|tpl| (*tpl).1)
.map_ok(|tpl| tpl.0)
.and_then_ok(|event| {
listed_events = listed_events + 1; listed_events = listed_events + 1;
let data = build_data_object_for_handlebars(listed_events, &event); let data = build_data_object_for_handlebars(listed_events, &event);
let rendered = list_format let rendered = list_format.render("format", &data)?;
.render("format", &data)
.map_err(Error::from)
.map_err_trace_exit_unwrap();
writeln!(rt.stdout(), "{}", rendered).to_exit_code().unwrap_or_exit() writeln!(rt.stdout(), "{}", rendered).map_err(Error::from)
}); })
.collect::<Result<Vec<_>>>()?;
rt.report_touched(parsed_entry.get_entry().get_location()).unwrap_or_exit(); rt.report_touched(parsed_entry.get_entry().get_location()).map_err(Error::from)
}); })
.collect()
} }
fn show(rt: &Runtime) { fn show(rt: &Runtime) -> Result<()> {
let scmd = rt.cli().subcommand_matches("show").unwrap(); // safe by clap let scmd = rt.cli().subcommand_matches("show").unwrap(); // safe by clap
let ref_config = rt.config() let ref_config = rt.config()
.ok_or_else(|| format_err!("No configuration, cannot continue!")) .ok_or_else(|| format_err!("No configuration, cannot continue!"))?
.map_err_trace_exit_unwrap() .read_partial::<libimagentryref::reference::Config>()?
.read_partial::<libimagentryref::reference::Config>() .ok_or_else(|| format_err!("Configuration missing: {}", libimagentryref::reference::Config::LOCATION))?;
.map_err(Error::from)
.map_err_trace_exit_unwrap()
.ok_or_else(|| format_err!("Configuration missing: {}", libimagentryref::reference::Config::LOCATION))
.map_err_trace_exit_unwrap();
let list_format = util::get_event_print_format("calendar.show_format", rt, &scmd) let list_format = util::get_event_print_format("calendar.show_format", rt, &scmd)?;
.map_err_trace_exit_unwrap();
let mut shown_events = 0; let mut shown_events = 0;
scmd.values_of("show-ids") scmd.values_of("show-ids")
.unwrap() // safe by clap .unwrap() // safe by clap
.into_iter() .into_iter()
.filter_map(|id| { .map(|id| {
util::find_event_by_id(rt.store(), id, &ref_config) let e = util::find_event_by_id(rt.store(), id, &ref_config)?;
.map(|entry| { debug!("Found => {:?}", entry); entry }) debug!("Found => {:?}", e);
.map_err_trace_exit_unwrap() Ok((e, id))
.map(|parsed| (parsed, id))
}) })
.for_each(|(parsed_entry, id)| { .and_then_ok(|tpl| match tpl {
(None, id) => Err(format_err!("Missing entry: {}", id)),
(Some(e), id) => Ok((e, id)),
})
.and_then_ok(|(parsed_entry, id)| {
parsed_entry parsed_entry
.get_data() .get_data()
.events() .events()
.filter_map(RResult::ok) .map_err(|component| Error::from(format_err!("Failed to parse entry: {}", component.name)))
.filter(|pent| { .filter_ok(|pent| {
let relevant = pent.uid().map(|uid| uid.raw().starts_with(id)).unwrap_or(false); let relevant = pent.uid().map(|uid| uid.raw().starts_with(id)).unwrap_or(false);
debug!("Relevant {} => {}", parsed_entry.get_entry().get_location(), relevant); debug!("Relevant {} => {}", parsed_entry.get_entry().get_location(), relevant);
relevant relevant
}) })
.for_each(|event| { .and_then_ok(|event| {
shown_events = shown_events + 1; shown_events = shown_events + 1;
let data = util::build_data_object_for_handlebars(shown_events, &event); let data = util::build_data_object_for_handlebars(shown_events, &event);
let rendered = list_format let rendered = list_format.render("format", &data)?;
.render("format", &data)
.map_err(Error::from)
.map_err_trace_exit_unwrap();
writeln!(rt.stdout(), "{}", rendered).to_exit_code().unwrap_or_exit() writeln!(rt.stdout(), "{}", rendered).map_err(Error::from)
}); })
.collect::<Result<Vec<_>>>()?;
rt.report_touched(parsed_entry.get_entry().get_location()).unwrap_or_exit(); rt.report_touched(parsed_entry.get_entry().get_location()).map_err(Error::from)
}); })
.collect()
} }
/// helper function to check whether a DirEntry points to something hidden (starting with dot) /// helper function to check whether a DirEntry points to something hidden (starting with dot)