matthiasbeyer
/
imag
1
0
Fork 0
Code Releases Activity

Merge branch 'error-context' into master

This commit is contained in:
Matthias Beyer 2019-05-18 00:55:20 +02:00
parent c7f5420c1d d034a6f0e2
commit 85f8082cbe
39 changed files with 177 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lib/core/libimagrt/src/logger.rs
View File

@ -370,6 +370,7 @@ fn aggregate_module_settings(_matches: &ArgMatches, config: Option<&Value>)
for (module_name, v) in t {
let destinations = inner_try! {
v.read("destinations")
.context("Failed reading header 'destinations'")
.map_err(Error::from)
.context(EM::TomlQueryError)?
.map(|val| {
@ -384,6 +385,7 @@ fn aggregate_module_settings(_matches: &ArgMatches, config: Option<&Value>)
let level = inner_try! {
v.read_string("level")
.context("Failed reading header 'level'")
.map_err(Error::from)
.context(EM::TomlQueryError)?
.map(|s| match_log_level_str(&s))

1
lib/core/libimagrt/src/runtime.rs
View File

@ -408,6 +408,7 @@ impl<'a> Runtime<'a> {
let mut buf = String::new();
lock.read_to_string(&mut buf)
.context("Failed to read stdin to buffer")
.map_err(Error::from)
.and_then(|_| {
trace!("Got IDs = {}", buf);

1
lib/core/libimagstore/src/configuration.rs
View File

@ -34,6 +34,7 @@ pub fn config_implicit_store_create_allowed(config: &Option<Value>) -> Result<bo
if let Some(ref t) = *config {
t.read_bool(key)
.context(format_err!("Error reading header '{}' in configuration", key))
.map_err(Error::from)
.context(EM::TomlQueryError)?
.ok_or_else(|| format_err!("Config key missing: {}", key))

3
lib/core/libimagstore/src/storeid.rs
View File

@ -184,6 +184,9 @@ impl<'a> StoreIdWithBase<'a> {
store_part.display());
let p = full_path
.strip_prefix(store_part)
.context(format_err!("Cannot strip prefix '{}' from path: '{}'",
store_part.display(),
full_path.display()))
.map_err(Error::from)
.context(err_msg("Error building Store Id from full path"))?;
Ok(StoreIdWithBase(store_part, PathBuf::from(p)))

16
lib/domain/libimagbookmark/src/collection.rs
View File

@ -27,6 +27,7 @@
use regex::Regex;
use failure::Fallible as Result;
use failure::ResultExt;
use failure::Error;
use libimagstore::store::Store;
@ -52,19 +53,28 @@ impl<'a> BookmarkCollectionStore<'a> for Store {
fn new(&'a self, name: &str) -> Result<FileLockEntry<'a>> {
crate::module_path::new_id(name)
.and_then(|id| self.create(id).map_err(Error::from))
.and_then(|id| self.create(id)
.context("Failed to create FileLockEntry")
.map_err(Error::from))
.context("Failed to create Id for new Bookmark Collection")
.map_err(Error::from)
}
fn get(&'a self, name: &str) -> Result<Option<FileLockEntry<'a>>> {
crate::module_path::new_id(name)
.and_then(|id| self.get(id).map_err(Error::from))
.and_then(|id| self.get(id)
.context("Failed to get FileLockEntry")
.map_err(Error::from))
.context("Failed to get Bookmark Collection")
.map_err(Error::from)
}
fn delete(&'a self, name: &str) -> Result<()> {
crate::module_path::new_id(name)
.and_then(|id| self.delete(id).map_err(Error::from))
.and_then(|id| self.delete(id)
.context("Failed to delete FileLockEntry")
.map_err(Error::from))
.context("Failed to delete Bookmark Collection")
.map_err(Error::from)
}

14
lib/domain/libimagcontact/src/iter.rs
View File

@ -25,6 +25,7 @@ use libimagerror::errors::ErrorMsg as EM;
use crate::contact::Contact;
use failure::Fallible as Result;
use failure::Error;
use failure::ResultExt;
pub struct ContactIter<'a>(StoreIdIterator, &'a Store);
@ -44,12 +45,21 @@ impl<'a> Iterator for ContactIter<'a> {
loop {
match self.0.next() {
None => return None,
Some(Err(e)) => return Some(Err(e).map_err(Error::from)),
Some(Err(e)) => {
let e = Err(e)
.context("Found error while iterating over contacts")
.map_err(Error::from);
return Some(e)
},
Some(Ok(sid)) => match self.1.get(sid.clone()).map_err(From::from) {
Err(e) => return Some(Err(e)),
Ok(None) => return
Some(Err(Error::from(EM::EntryNotFound(sid.local_display_string())))),
Ok(Some(entry)) => match entry.is_contact().map_err(Error::from) {
Ok(Some(entry)) => match entry.is_contact()
.context("Cannot check whether entry is a contact")
.map_err(Error::from)
{
Ok(true) => return Some(Ok(entry)),
Ok(false) => continue,
Err(e) => return Some(Err(e)),

3
lib/domain/libimagcontact/src/store.rs
View File

@ -27,6 +27,7 @@ use toml_query::insert::TomlValueInsertExt;
use vobject::vcard::Vcard;
use failure::Error;
use failure::Fallible as Result;
use failure::ResultExt;
use libimagstore::storeid::StoreId;
use libimagstore::iter::Entries;
@ -152,7 +153,7 @@ impl<'a> ContactStore<'a> for Store {
///
/// That means calculating the StoreId and the Value from the vcard data
fn prepare_fetching_from_store(buf: &str) -> Result<(StoreId, Value)> {
let vcard = Vcard::build(&buf).map_err(Error::from)?;
let vcard = Vcard::build(&buf).context("Cannot parse Vcard").map_err(Error::from)?;
debug!("Parsed: {:?}", vcard);
let uid = vcard.uid()

2
lib/domain/libimagdiary/src/diary.rs
View File

@ -30,6 +30,7 @@ use itertools::Itertools;
use chrono::naive::NaiveDateTime;
use chrono::Timelike;
use failure::Fallible as Result;
use failure::ResultExt;
use failure::Error;
use crate::entry::IsDiaryEntry;
@ -141,6 +142,7 @@ impl Diary for Store {
fn diary_names(&self) -> Result<DiaryNameIterator> {
self.entries()
.map(|it| DiaryNameIterator::new(it.into_storeid_iter()))
.context("Failed building DiaryNameIteator from entries iterator")
.map_err(Error::from)
}

3
lib/domain/libimagdiary/src/diaryid.rs
View File

@ -234,6 +234,7 @@ impl FromStoreId for DiaryId {
let day: Result<u32> = next_component(&mut cmps)
.and_then(|s| {
s.parse::<u32>()
.context("Failed to parse day from u32")
.map_err(Error::from)
.context(err_msg("ID parse error"))
.map_err(Error::from)
@ -242,6 +243,7 @@ impl FromStoreId for DiaryId {
let month: Result<u32> = next_component(&mut cmps)
.and_then(|s| {
s.parse::<u32>()
.context("Failed to parse month from u32")
.map_err(Error::from)
.context(err_msg("ID Parse error"))
.map_err(Error::from)
@ -250,6 +252,7 @@ impl FromStoreId for DiaryId {
let year: Result<i32> = next_component(&mut cmps)
.and_then(|s| {
s.parse::<i32>()
.context("Failed to parse year from i32")
.map_err(Error::from)
.context(err_msg("ID Parse error"))
.map_err(Error::from)

5
lib/domain/libimaghabit/src/habit.rs
View File

@ -25,6 +25,7 @@ use chrono::Local;
use chrono::NaiveDate;
use failure::Error;
use failure::Fallible as Result;
use failure::ResultExt;
use failure::err_msg;
use crate::iter::HabitInstanceStoreIdIterator;
@ -257,7 +258,9 @@ impl HabitTemplate for Entry {
}
fn instance_id_for_name_and_datestr(habit_name: &String, habit_date: &String) -> Result<StoreId> {
crate::module_path::new_id(format!("instance/{}-{}", habit_name, habit_date)).map_err(Error::from)
crate::module_path::new_id(format!("instance/{}-{}", habit_name, habit_date))
.context(format_err!("Failed building ID for instance: habit name = {}, habit date = {}", habit_name, habit_date))
.map_err(Error::from)
}
pub mod builder {

5
lib/domain/libimaghabit/src/iter.rs
View File

@ -19,6 +19,7 @@
use failure::Error;
use failure::Fallible as Result;
use failure::ResultExt;
use libimagstore::storeid::StoreIdIterator;
use libimagstore::storeid::StoreIdIteratorWithStore;
@ -33,11 +34,11 @@ impl Iterator for HabitTemplateStoreIdIterator {
fn next(&mut self) -> Option<Self::Item> {
while let Some(n) = self.0.next() {
match n {
match n.context("Error while iterating").map_err(Error::from) {
Ok(n) => if n.is_habit_template() {
return Some(Ok(n))
},
Err(e) => return Some(Err(e).map_err(Error::from)),
Err(e) => return Some(Err(e)),
}
}
None

2
lib/domain/libimaghabit/src/util.rs
View File

@ -21,6 +21,7 @@ use std::ops::BitXor;
use failure::Error;
use failure::Fallible as Result;
use failure::ResultExt;
use crate::habit::HabitTemplate;
use crate::instance::HabitInstance;
@ -88,6 +89,7 @@ pub fn get_string_header_from_entry(e: &Entry, path: &'static str) -> Result<Str
e.get_header()
.read_string(path)?
.ok_or_else(|| EM::EntryHeaderFieldMissing(path))
.context(format_err!("Error while reading header '{}' from '{}'", path, e.get_location()))
.map_err(Error::from)
}

4
lib/domain/libimaglog/src/log.rs
View File

@ -24,6 +24,7 @@ use libimagentryutil::isa::IsKindHeaderPathProvider;
use failure::Fallible as Result;
use failure::Error;
use failure::ResultExt;
use toml::Value;
@ -38,12 +39,13 @@ provide_kindflag_path!(pub IsLog, "log.is_log");
impl Log for Entry {
fn is_log(&self) -> Result<bool> {
self.is::<IsLog>().map_err(From::from)
self.is::<IsLog>().context("Cannot check whether Entry is a Log").map_err(From::from)
}
fn make_log_entry(&mut self) -> Result<()> {
self.get_header_mut()
.insert("log.is_log", Value::Boolean(true))
.context("Cannot insert 'log.is_log' into header of entry")
.map_err(Error::from)
.map(|_| ())
}

34
lib/domain/libimagmail/src/mail.rs
View File

@ -57,12 +57,17 @@ impl Mail for Entry {
.context(format_err!("Cannot parse Email {}", mail_file_location.display()))?
.headers
.into_iter()
.filter_map(|hdr| match hdr.get_key() {
Err(e) => Some(Err(e).map_err(Error::from)),
Ok(k) => if k == field {
Some(Ok(hdr))
} else {
None
.filter_map(|hdr| {
match hdr.get_key()
.context(format_err!("Cannot fetch key '{}' from Email {}", field, mail_file_location.display()))
.map_err(Error::from)
{
Ok(k) => if k == field {
Some(Ok(hdr))
} else {
None
},
Err(e) => Some(Err(e)),
}
})
.next()
@ -135,12 +140,17 @@ impl<'a> MailHeader<'a> {
pub fn get_field(&self, field: &str) -> Result<Option<String>> {
match self.0
.iter()
.filter_map(|hdr| match hdr.get_key() {
Err(e) => Some(Err(e).map_err(Error::from)),
Ok(key) => if key == field {
Some(Ok(hdr))
} else {
None
.filter_map(|hdr| {
match hdr.get_key()
.context(format_err!("Cannot get field {}", field))
.map_err(Error::from)
{
Ok(key) => if key == field {
Some(Ok(hdr))
} else {
None
},
Err(e) => Some(Err(e))
}
})
.next()

9
lib/domain/libimagmail/src/util.rs
View File

@ -39,8 +39,7 @@ pub(crate) fn get_message_header_at_key<P: AsRef<Path>, K: AsRef<str>>(p: P, k:
.context(format_err!("Cannot parse Email {}", p.as_ref().display()))?
.headers
.into_iter()
.filter_map(|hdr| match hdr.get_key() {
Err(e) => Some(Err(e).map_err(Error::from)),
.filter_map(|hdr| match hdr.get_key().context("Cannot get key from mail header").map_err(Error::from) {
Ok(key) => {
let lower_key = key.to_lowercase();
trace!("Test: {} == {}", lower_key, k.as_ref());
@ -49,11 +48,12 @@ pub(crate) fn get_message_header_at_key<P: AsRef<Path>, K: AsRef<str>>(p: P, k:
} else {
None
}
}
},
Err(e) => Some(Err(e))
})
.next()
.ok_or_else(|| format_err!("'{}' not found in {}", k.as_ref(), p.as_ref().display()))?
.and_then(|hdr| hdr.get_value().map_err(Error::from))
.and_then(|hdr| hdr.get_value().context("Cannot get value from mail header").map_err(Error::from))
}
pub(crate) fn get_message_id_for_mailfile<P: AsRef<Path>>(p: P) -> Result<String> {
@ -77,6 +77,7 @@ pub fn get_mail_text_content<P: AsRef<Path>>(p: P) -> Result<String> {
::mailparse::parse_mail(::std::fs::read_to_string(p.as_ref())?.as_bytes())
.context(format_err!("Cannot parse Email {}", p.as_ref().display()))?
.get_body()
.context("Cannot get body of mail")
.map_err(Error::from)
}

5
lib/domain/libimagnotes/src/iter.rs
View File

@ -23,6 +23,7 @@ use libimagstore::storeid::StoreIdIterator;
use crate::notestoreid::*;
use failure::Fallible as Result;
use failure::Error;
use failure::ResultExt;
#[derive(Debug)]
pub struct NoteIterator(StoreIdIterator);
@ -40,11 +41,11 @@ impl Iterator for NoteIterator {
fn next(&mut self) -> Option<Self::Item> {
while let Some(n) = self.0.next() {
match n {
match n.context("Error while iterating").map_err(Error::from) {
Ok(n) => if n.is_note_id() {
return Some(Ok(n));
},
Err(e) => return Some(Err(e).map_err(Error::from)),
Err(e) => return Some(Err(e)),
}
}

2
lib/domain/libimagnotes/src/note.rs
View File

@ -27,6 +27,7 @@ use toml_query::set::TomlValueSetExt;
use failure::Fallible as Result;
use failure::Error;
use failure::ResultExt;
pub trait Note {
fn set_name(&mut self, n: String) -> Result<()>;
@ -40,6 +41,7 @@ impl Note for Entry {
fn set_name(&mut self, n: String) -> Result<()> {
self.get_header_mut()
.set("note.name", Value::String(n))
.context(format_err!("Cannot set 'note.name' in header of {}", self.get_location()))
.map_err(Error::from)
.map(|_| ())
}

2
lib/domain/libimagtimetrack/src/iter/create.rs
View File

@ -21,6 +21,7 @@ use toml::Value;
use toml_query::insert::TomlValueInsertExt;
use chrono::naive::NaiveDateTime as NDT;
use failure::Fallible as Result;
use failure::ResultExt;
use failure::Error;
use crate::constants::*;
@ -60,6 +61,7 @@ impl<'a> Iterator for CreateTimeTrackIter<'a>
res.and_then(|(id, starttime)| {
self.store
.create(id)
.context("Failed to create entry")
.map_err(Error::from)
.and_then(|mut entry| {
let v = Value::String(starttime.format(DATE_TIME_FORMAT).to_string());

20
lib/domain/libimagtimetrack/src/timetracking.rs
View File

@ -37,6 +37,7 @@ use toml_query::delete::TomlValueDeleteExt;
use toml_query::insert::TomlValueInsertExt;
use toml_query::read::TomlValueReadTypeExt;
use failure::Fallible as Result;
use failure::ResultExt;
use failure::Error;
pub trait TimeTracking {
@ -64,6 +65,8 @@ impl TimeTracking for Entry {
fn get_timetrack_tag(&self) -> Result<TTT> {
self.get_header()
.read_string(DATE_TIME_TAG_HEADER_PATH)
.context(format_err!("Failed to read header '{}' of {}", DATE_TIME_TAG_HEADER_PATH,
self.get_location()))
.map_err(Error::from)?
.ok_or_else(|| Error::from(EM::EntryHeaderReadError))
.map(Into::into)
@ -74,6 +77,8 @@ impl TimeTracking for Entry {
self.get_header_mut()
.insert(DATE_TIME_START_HEADER_PATH, Value::String(s))
.context(format_err!("Failed get header '{}' of {}", DATE_TIME_START_HEADER_PATH,
self.get_location()))
.map_err(Error::from)
.map(|_| ())
}
@ -81,6 +86,8 @@ impl TimeTracking for Entry {
fn get_start_datetime(&self) -> Result<Option<NaiveDateTime>> {
self.get_header()
.read_string(DATE_TIME_START_HEADER_PATH)
.context(format_err!("Failed read header '{}' of {}", DATE_TIME_START_HEADER_PATH,
self.get_location()))
.map_err(Error::from)
.and_then(header_value_to_dt)
}
@ -88,6 +95,8 @@ impl TimeTracking for Entry {
fn delete_start_datetime(&mut self) -> Result<()> {
self.get_header_mut()
.delete(DATE_TIME_START_HEADER_PATH)
.context(format_err!("Failed delete header '{}' of {}", DATE_TIME_START_HEADER_PATH,
self.get_location()))
.map_err(Error::from)
.map(|_| ())
}
@ -97,6 +106,8 @@ impl TimeTracking for Entry {
self.get_header_mut()
.insert(DATE_TIME_END_HEADER_PATH, Value::String(s))
.context(format_err!("Failed insert header '{}' in {}", DATE_TIME_END_HEADER_PATH,
self.get_location()))
.map_err(Error::from)
.map(|_| ())
}
@ -104,6 +115,8 @@ impl TimeTracking for Entry {
fn get_end_datetime(&self) -> Result<Option<NaiveDateTime>> {
self.get_header()
.read_string(DATE_TIME_END_HEADER_PATH)
.context(format_err!("Failed read header '{}' of {}", DATE_TIME_END_HEADER_PATH,
self.get_location()))
.map_err(Error::from)
.and_then(header_value_to_dt)
}
@ -111,6 +124,8 @@ impl TimeTracking for Entry {
fn delete_end_datetime(&mut self) -> Result<()> {
self.get_header_mut()
.delete(DATE_TIME_END_HEADER_PATH)
.context(format_err!("Failed delete header '{}' of {}", DATE_TIME_END_HEADER_PATH,
self.get_location()))
.map_err(Error::from)
.map(|_| ())
}
@ -135,7 +150,10 @@ impl TimeTracking for Entry {
fn header_value_to_dt(val: Option<String>) -> Result<Option<NaiveDateTime>> {
match val {
Some(ref s) => NaiveDateTime::parse_from_str(s, DATE_TIME_FORMAT).map_err(Error::from).map(Some),
Some(ref s) => NaiveDateTime::parse_from_str(s, DATE_TIME_FORMAT)
.context(format_err!("Failed to parse '{}' datetime with format '{}'",
s, DATE_TIME_FORMAT))
.map_err(Error::from).map(Some),
None => Ok(None),
}
}

3
lib/domain/libimagtimetrack/src/timetrackingstore.rs
View File

@ -26,6 +26,7 @@ use chrono::NaiveDateTime as NDT;
use toml::Value;
use toml_query::insert::TomlValueInsertExt;
use failure::Fallible as Result;
use failure::ResultExt;
use failure::Error;
use libimagstore::store::Store;
@ -70,6 +71,8 @@ impl<'a> TimeTrackStore<'a> for Store {
use std::path::PathBuf;
COMPILER.compile(CRATE_NAME, start)
.context(format_err!("Failed to compile DatePath for crate '{}' with start = '{}'",
CRATE_NAME, start))
.map_err(Error::from)
.map(|mut id| {
id.local_push(PathBuf::from(ts.as_str()));

2
lib/domain/libimagwiki/src/wiki.rs
View File

@ -27,6 +27,7 @@ use libimagentrylink::internal::InternalLinker;
use failure::Fallible as Result;
use failure::Error;
use failure::err_msg;
use failure::ResultExt;
pub struct Wiki<'a, 'b>(&'a Store, &'b str);
@ -58,6 +59,7 @@ impl<'a, 'b> Wiki<'a, 'b> {
self.0
.get(sid)
.context("Cannot get ID from store")
.map_err(Error::from)?
.ok_or_else(|| Error::from(err_msg("Missing index")))
}

2
lib/entry/libimagentrycategory/src/category.rs
View File

@ -27,6 +27,7 @@ use libimagentrylink::internal::InternalLinker;
use toml_query::read::TomlValueReadTypeExt;
use failure::Fallible as Result;
use failure::ResultExt;
use failure::Error;
use failure::err_msg;
use crate::store::CATEGORY_REGISTER_NAME_FIELD_PATH;
@ -49,6 +50,7 @@ impl Category for Entry {
trace!("Getting category name of '{:?}'", self.get_location());
self.get_header()
.read_string(CATEGORY_REGISTER_NAME_FIELD_PATH)
.context(format_err!("Failed to read header at '{}'", CATEGORY_REGISTER_NAME_FIELD_PATH))
.map_err(Error::from)?
.ok_or_else(|| Error::from(err_msg("Category name missing")))
}

6
lib/entry/libimagentrycategory/src/entry.rs
View File

@ -52,7 +52,7 @@ impl EntryCategory for Entry {
trace!("Setting category '{}' UNCHECKED", s);
self.get_header_mut()
.insert(&String::from("category.value"), Value::String(s.to_string()))
.map_err(Error::from)
.context(format_err!("Failed to insert header at 'category.value' of '{}'", self.get_location()))
.context(EM::EntryHeaderWriteError)
.map_err(Error::from)
.map(|_| ())
@ -84,7 +84,7 @@ impl EntryCategory for Entry {
trace!("Has category? '{}'", self.get_location());
self.get_header()
.read("category.value")
.map_err(Error::from)
.context(format_err!("Failed to read header at 'category.value' of '{}'", self.get_location()))
.context(EM::EntryHeaderReadError)
.map_err(Error::from)
.map(|x| x.is_some())
@ -101,7 +101,7 @@ impl EntryCategory for Entry {
self.get_header_mut()
.delete("category.value")
.map_err(Error::from)
.context(format_err!("Failed to delete header at 'category.value' of '{}'", self.get_location()))
.context(EM::EntryHeaderWriteError)
.map_err(Error::from)
.map(|_| ())

12
lib/entry/libimagentrycategory/src/iter.rs
View File

@ -20,7 +20,6 @@
use libimagstore::storeid::StoreIdIterator;
use libimagstore::store::Store;
use libimagstore::store::FileLockEntry;
use libimagerror::errors::ErrorMsg as EM;
use toml_query::read::TomlValueReadTypeExt;
@ -60,8 +59,8 @@ impl<'a> Iterator for CategoryNameIter<'a> {
let query = CATEGORY_REGISTER_NAME_FIELD_PATH;
while let Some(sid) = self.1.next() {
match sid {
Err(e) => return Some(Err(e).map_err(Error::from)),
match sid.context("Error while iterating over category names").map_err(Error::from) {
Err(e) => return Some(Err(e)),
Ok(sid) => {
if sid.is_in_collection(&["category"]) {
let func = |store: &Store| { // hack for returning Some(Result<_, _>)
@ -70,8 +69,7 @@ impl<'a> Iterator for CategoryNameIter<'a> {
.ok_or_else(|| err_msg("Store read error"))?
.get_header()
.read_string(query)
.map_err(Error::from)
.context(EM::EntryHeaderReadError)?
.context(format_err!("Failed to read header at '{}'", query))?
.ok_or_else(|| err_msg("Store read error"))
.map_err(Error::from)
};
@ -99,8 +97,8 @@ impl<'a> Iterator for CategoryEntryIterator<'a> {
fn next(&mut self) -> Option<Self::Item> {
while let Some(next) = self.1.next() {
match next {
Err(e) => return Some(Err(e).map_err(Error::from)),
match next.context("Error while iterating over category entries").map_err(Error::from) {
Err(e) => return Some(Err(e)),
Ok(next) => {
let getter = |next| -> Result<(String, FileLockEntry<'a>)> {
let entry = self.0

3
lib/entry/libimagentrydatetime/src/datetime.rs
View File

@ -92,6 +92,9 @@ impl EntryDate for Entry {
self.get_header_mut()
.insert(&DATE_HEADER_LOCATION, Value::String(date))
.context(format_err!("Failed to insert header '{}' in '{}'",
*DATE_HEADER_LOCATION,
self.get_location()))
.map_err(Error::from)
.map(|opt| opt.map(|stri| {
stri.as_str()

2
lib/entry/libimagentrydatetime/src/lib.rs
View File

@ -38,10 +38,10 @@
)]
#[macro_use] extern crate lazy_static;
#[macro_use] extern crate failure;
extern crate chrono;
extern crate toml_query;
extern crate toml;
extern crate failure;
extern crate libimagerror;
extern crate libimagstore;

4
lib/entry/libimagentryedit/src/edit.rs
View File

@ -66,7 +66,9 @@ impl EditHeader for Entry {
fn edit_header_and_content(&mut self, rt: &Runtime) -> Result<()> {
let mut header_and_content = self.to_str()?;
let _ = edit_in_tmpfile(rt, &mut header_and_content)?;
self.replace_from_buffer(&header_and_content).map_err(Error::from)
self.replace_from_buffer(&header_and_content)
.context("Failed to replace header and content from buffer")
.map_err(Error::from)
}
}

4
lib/entry/libimagentryfilter/src/builtin/header/field_exists.rs
View File

@ -23,6 +23,7 @@ use toml_query::read::TomlValueReadExt;
use filters::failable::filter::FailableFilter;
use failure::Fallible as Result;
use failure::ResultExt;
use failure::Error;
use crate::builtin::header::field_path::FieldPath;
@ -47,6 +48,9 @@ impl FailableFilter<Entry> for FieldExists {
fn filter(&self, e: &Entry) -> Result<bool> {
e.get_header()
.read(&self.header_field_path[..])
.context(format_err!("Failed reading header '{}' in '{}'",
self.header_field_path,
e.get_location()))
.map_err(Error::from)
.map(|o| o.is_some())
}

2
lib/entry/libimagentryfilter/src/lib.rs
View File

@ -40,7 +40,7 @@ extern crate regex;
extern crate semver;
extern crate toml;
extern crate toml_query;
extern crate failure;
#[macro_use] extern crate failure;
extern crate libimagstore;
extern crate libimagentrytag;

9
lib/entry/libimagentrygps/src/entry.rs
View File

@ -60,11 +60,16 @@ impl GPSEntry for Entry {
self.get_header_mut()
.insert("gps.coordinates", c.into())
.map(|_| ())
.context(format_err!("Error while inserting header 'gps.coordinates' in '{}'", self.get_location()))
.map_err(Error::from)
}
fn get_coordinates(&self) -> Result<Option<Coordinates>> {
match self.get_header().read("gps.coordinates").map_err(Error::from)? {
match self
.get_header()
.read("gps.coordinates")
.context(format_err!("Error while reading header 'gps.coordinates' in '{}'", self.get_location()))?
{
Some(hdr) => Coordinates::from_value(hdr).map(Some),
None => Ok(None),
}
@ -89,7 +94,7 @@ impl GPSEntry for Entry {
let hdr = self.get_header_mut();
for pattern in patterns.iter() {
let _ = hdr.delete(pattern)
.map_err(Error::from)
.context(format_err!("Error while deleting header '{}'", pattern))
.context("Error writing header")?;
}

2
lib/entry/libimagentrygps/src/lib.rs
View File

@ -38,7 +38,7 @@
extern crate toml;
extern crate toml_query;
#[macro_use] extern crate serde_derive;
extern crate failure;
#[macro_use] extern crate failure;
extern crate libimagstore;
extern crate libimagerror;

5
lib/entry/libimagentrylink/src/external.rs
View File

@ -70,7 +70,7 @@ impl Link for Entry {
fn get_link_uri_from_filelockentry(&self) -> Result<Option<Url>> {
self.get_header()
.read_string("links.external.content.url")
.map_err(Error::from)
.context(format_err!("Error reading header 'links.external.content.url' from '{}'", self.get_location()))
.context(EM::EntryHeaderReadError)
.map_err(Error::from)
.and_then(|opt| match opt {
@ -79,11 +79,13 @@ impl Link for Entry {
debug!("Found url, parsing: {:?}", s);
Url::parse(&s[..])
.map_err(Error::from)
.context(format_err!("Failed to parse URL: '{}'", s))
.context(err_msg("Invalid URI"))
.map_err(Error::from)
.map(Some)
},
})
.context("Failed to get link URI from entry")
.map_err(Error::from)
}
@ -91,6 +93,7 @@ impl Link for Entry {
match self.get_header().read_string("links.external.url")? {
None => Ok(None),
Some(ref s) => Url::parse(&s[..])
.context(format_err!("Failed to parse URL: '{}'", s))
.map(Some)
.map_err(Error::from)
.context(EM::EntryHeaderReadError)

10
lib/entry/libimagentrylink/src/internal.rs
View File

@ -265,7 +265,7 @@ impl InternalLinker for Entry {
let res = self
.get_header()
.read("links.internal")
.map_err(Error::from)
.context(format_err!("Failed to read header 'links.internal' of '{}'", self.get_location()))
.context(EM::EntryHeaderReadError)
.context(EM::EntryHeaderError)
.map_err(Error::from)
@ -299,7 +299,7 @@ impl InternalLinker for Entry {
let res = self
.get_header_mut()
.insert("links.internal", Value::Array(new_links))
.map_err(Error::from)
.context(format_err!("Failed to insert header 'links.internal' of '{}'", self.get_location()))
.context(EM::EntryHeaderReadError)
.map_err(Error::from);
process_rw_result(res)
@ -336,7 +336,7 @@ impl InternalLinker for Entry {
fn unlink(&mut self, store: &Store) -> Result<()> {
for id in self.get_internal_links()?.map(|l| l.get_store_id().clone()) {
match store.get(id).map_err(Error::from)? {
match store.get(id).context("Failed to get entry")? {
Some(mut entry) => self.remove_internal_link(&mut entry)?,
None => return Err(err_msg("Link target does not exist")),
}
@ -382,7 +382,7 @@ fn rewrite_links<I: Iterator<Item = Link>>(header: &mut Value, links: I) -> Resu
debug!("Setting new link array: {:?}", links);
let process = header
.insert("links.internal", Value::Array(links))
.map_err(Error::from)
.context(format_err!("Failed to insert header 'links.internal'"))
.context(EM::EntryHeaderReadError)
.map_err(Error::from);
process_rw_result(process).map(|_| ())
@ -409,7 +409,7 @@ fn add_foreign_link(target: &mut Entry, from: StoreId) -> Result<()> {
let res = target
.get_header_mut()
.insert("links.internal", Value::Array(links))
.map_err(Error::from)
.context(format_err!("Failed to insert header 'links.internal'"))
.context(EM::EntryHeaderReadError)
.map_err(Error::from);

21
lib/entry/libimagentryref/src/reference.rs
View File

@ -89,6 +89,7 @@ pub mod fassade {
use libimagentryutil::isa::Is;
use failure::Fallible as Result;
use failure::ResultExt;
use failure::Error;
use crate::hasher::sha1::Sha1Hasher;
@ -104,7 +105,7 @@ pub mod fassade {
impl RefFassade for Entry {
/// Check whether the underlying object is actually a ref
fn is_ref(&self) -> Result<bool> {
self.is::<IsRef>().map_err(Error::from)
self.is::<IsRef>().context("Failed to check is-ref flag").map_err(Error::from)
}
fn as_ref_with_hasher<H: Hasher>(&self) -> RefWithHasher<H> {
@ -163,7 +164,7 @@ impl<'a, H: Hasher> Ref for RefWithHasher<'a, H> {
/// Check whether the underlying object is actually a ref
fn is_ref(&self) -> Result<bool> {
self.0.is::<IsRef>().map_err(Error::from)
self.0.is::<IsRef>().context("Failed to check is-ref flag").map_err(Error::from)
}
fn get_hash(&self) -> Result<&str> {
@ -171,6 +172,7 @@ impl<'a, H: Hasher> Ref for RefWithHasher<'a, H> {
self.0
.get_header()
.read(&header_path)
.context(format_err!("Failed to read header at '{}'", header_path))
.map_err(Error::from)?
.ok_or_else(|| {
Error::from(EM::EntryHeaderFieldMissing("ref.hash.<hash>"))
@ -210,7 +212,7 @@ impl<'a, H: Hasher> Ref for RefWithHasher<'a, H> {
self.0
.get_header()
.read("ref.relpath")
.map_err(Error::from)?
.context("Failed to read header at 'ref.relpath'")?
.ok_or_else(|| Error::from(EM::EntryHeaderFieldMissing("ref.relpath")))
.and_then(|v| {
v.as_str()
@ -223,19 +225,20 @@ impl<'a, H: Hasher> Ref for RefWithHasher<'a, H> {
fn hash_valid(&self, config: &Config) -> Result<bool> {
let ref_header = self.0
.get_header()
.read("ref")?
.read("ref")
.context("Failed to read header at 'ref'")?
.ok_or_else(|| err_msg("Header missing at 'ref'"))?;
let basepath_name = ref_header
.read("basepath")
.map_err(Error::from)?
.context("Failed to read header at 'ref.basepath'")?
.ok_or_else(|| err_msg("Header missing at 'ref.basepath'"))?
.as_str()
.ok_or_else(|| Error::from(EM::EntryHeaderTypeError2("ref.hash.<hash>", "string")))?;
let path = ref_header
.read("relpath")
.map_err(Error::from)?
.context("Failed to read header at 'ref.relpath'")?
.ok_or_else(|| err_msg("Header missing at 'ref.relpath'"))?
.as_str()
.map(PathBuf::from)
@ -246,7 +249,7 @@ impl<'a, H: Hasher> Ref for RefWithHasher<'a, H> {
ref_header
.read(H::NAME)
.map_err(Error::from)?
.context(format_err!("Failed to read header at 'ref.{}'", H::NAME))?
.ok_or_else(|| format_err!("Header missing at 'ref.{}'", H::NAME))
.and_then(|v| {
v.as_str().ok_or_else(|| {
@ -352,7 +355,9 @@ impl<'a, H> MutRef for MutRefWithHasher<'a, H>
trace!("Using relpath = {} to make header section", relpath.display());
make_header_section(hash, H::NAME, relpath, basepath_name)
})
.and_then(|h| self.0.get_header_mut().insert("ref", h).map_err(Error::from))
.and_then(|h| self.0.get_header_mut().insert("ref", h)
.context("Failed to insert 'ref' in header")
.map_err(Error::from))
.and_then(|_| self.0.set_isflag::<IsRef>())
.context("Making ref out of entry")?;

1
lib/entry/libimagentrytag/src/tagable.rs
View File

@ -51,6 +51,7 @@ impl Tagable for Value {
fn get_tags(&self) -> Result<Vec<Tag>> {
self.read("tag.values")
.context(format_err!("Failed to read header at 'tag.values'"))
.map_err(Error::from)
.context(EM::EntryHeaderReadError)?
.map(|val| {

10
lib/entry/libimagentryutil/src/isa.rs
View File

@ -18,6 +18,7 @@
//
use failure::Fallible as Result;
use failure::ResultExt;
use failure::Error;
use toml::Value;
@ -79,7 +80,12 @@ impl Is for ::libimagstore::store::Entry {
fn is<T: IsKindHeaderPathProvider>(&self) -> Result<bool> {
let field = T::kindflag_header_location();
match self.get_header().read_bool(field).map_err(Error::from)? {
match self
.get_header()
.read_bool(field)
.context(format_err!("Failed reading header '{}' in '{}'", field, self.get_location()))
.map_err(Error::from)?
{
Some(b) => Ok(b),
None => Ok(false),
}
@ -88,6 +94,7 @@ impl Is for ::libimagstore::store::Entry {
fn set_isflag<T: IsKindHeaderPathProvider>(&mut self) -> Result<()> {
self.get_header_mut()
.insert(T::kindflag_header_location(), Value::Boolean(true))
.context(format_err!("Failed inserting header '{}' in '{}'", T::kindflag_header_location(), self.get_location()))
.map_err(Error::from)
.map(|_| ())
}
@ -96,6 +103,7 @@ impl Is for ::libimagstore::store::Entry {
trace!("Trying to remove: {}", T::kindflag_header_location());
self.get_header_mut()
.delete(T::kindflag_header_location())
.context(format_err!("Failed deleting header '{}' in '{}'", T::kindflag_header_location(), self.get_location()))
.map_err(Error::from)
.map(|_| ())
}

2
lib/entry/libimagentryutil/src/lib.rs
View File

@ -40,7 +40,7 @@
extern crate filters;
extern crate toml;
extern crate toml_query;
extern crate failure;
#[macro_use] extern crate failure;
#[macro_use] extern crate log;
extern crate libimagstore;

3
lib/entry/libimagentryview/src/builtin/editor.rs
View File

@ -27,7 +27,6 @@ use crate::viewer::Viewer;
use failure::Fallible as Result;
use failure::ResultExt;
use failure::Error;
use failure::err_msg;
pub struct EditorView<'a>(&'a Runtime<'a>);
@ -43,7 +42,7 @@ impl<'a> Viewer for EditorView<'a> {
{
let mut entry = e.to_str()?.clone().to_string();
edit_in_tmpfile(self.0, &mut entry)
.context(err_msg("Error while viewing"))
.context("Error while viewing")
.map_err(Error::from)
}
}

6
lib/etc/libimaginteraction/src/ask.rs
View File

@ -178,10 +178,12 @@ pub fn ask_select_from_list(list: &[&str]) -> Result<String> {
/// The `nl` parameter can be used to configure whether a newline character should be printed
pub fn ask_question(question: &str, nl: bool, output: &mut Write) -> Result<()> {
if nl {
writeln!(output, "[imag]: {}?", Yellow.paint(question)).map_err(Error::from)
writeln!(output, "[imag]: {}?", Yellow.paint(question))
} else {
write!(output, "[imag]: {}?", Yellow.paint(question)).map_err(Error::from)
write!(output, "[imag]: {}?", Yellow.paint(question))
}
.context("Failed to write question to output")
.map_err(Error::from)
}
#[cfg(test)]