matthiasbeyer/imag
1
0
Fork 0
Code Releases Activity

Merge pull request #1037 from matthiasbeyer/libimagerror/based-on-error-chain

Browse source 
Libimagerror/based on error chain
This commit is contained in:
Matthias Beyer 2017-09-05 09:02:47 +02:00 committed by GitHub
commit e6d96c9f83
168 changed files with 2077 additions and 2252 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
bin/core/imag-store/Cargo.toml
View file

@ -18,6 +18,7 @@ clap = ">=2.17"
log = "0.3"
version = "2.0.1"
toml = "^0.4"
error-chain = "0.10"
libimagstore = { version = "0.4.0", path = "../../../lib/core/libimagstore", features = ["verify"] }
libimagrt = { version = "0.4.0", path = "../../../lib/core/libimagrt" }

7
bin/core/imag-store/src/create.rs
View file

@ -38,6 +38,7 @@ use libimagutil::debug_result::*;
use error::StoreError;
use error::StoreErrorKind;
use error::ResultExt;
use util::build_toml_header;
type Result<T> = RResult<T, StoreError>;
@ -110,7 +111,7 @@ fn create_from_cli_spec(rt: &Runtime, matches: &ArgMatches, path: &StoreId) -> R
fn create_from_source(rt: &Runtime, matches: &ArgMatches, path: &StoreId) -> Result<()> {
let content = matches
.value_of("from-raw")
.ok_or(StoreError::new(StoreErrorKind::NoCommandlineCall, None))
.ok_or(StoreError::from_kind(StoreErrorKind::NoCommandlineCall))
.map(string_from_raw_src);
if content.is_err() {
@ -133,7 +134,7 @@ fn create_from_source(rt: &Runtime, matches: &ArgMatches, path: &StoreId) -> Res
r
})
.map_dbg_err(|e| format!("Error storing entry: {:?}", e))
.map_err(|serr| StoreError::new(StoreErrorKind::BackendError, Some(Box::new(serr))))
.chain_err(|| StoreErrorKind::BackendError)
}
fn create_with_content_and_header(rt: &Runtime,
@ -157,7 +158,7 @@ fn create_with_content_and_header(rt: &Runtime,
debug!("New header set");
}
})
.map_err(|e| StoreError::new(StoreErrorKind::BackendError, Some(Box::new(e))))
.chain_err(|| StoreErrorKind::BackendError)
}
fn string_from_raw_src(raw_src: &str) -> String {

25
bin/core/imag-store/src/error.rs
View file

@ -17,13 +17,22 @@
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
generate_error_module!(
generate_error_types!(StoreError, StoreErrorKind,
BackendError => "Backend Error",
NoCommandlineCall => "No commandline call"
);
);
error_chain! {
types {
StoreError, StoreErrorKind, ResultExt, Result;
}
pub use self::error::StoreError;
pub use self::error::StoreErrorKind;
errors {
BackendError {
description("Backend Error")
display("Backend Error")
}
NoCommandlineCall {
description("No commandline call")
display("No commandline call")
}
}
}

4
bin/core/imag-store/src/main.rs
View file

@ -37,14 +37,16 @@ extern crate clap;
extern crate toml;
#[cfg(test)] extern crate toml_query;
#[macro_use] extern crate version;
#[macro_use] extern crate error_chain;
extern crate libimagrt;
extern crate libimagstore;
#[macro_use] extern crate libimagerror;
extern crate libimagerror;
#[cfg(test)]
#[macro_use]
extern crate libimagutil;
#[cfg(not(test))]
extern crate libimagutil;

6
bin/domain/imag-diary/src/create.rs
View file

@ -24,7 +24,7 @@ use clap::ArgMatches;
use libimagdiary::diary::Diary;
use libimagdiary::diaryid::DiaryId;
use libimagdiary::error::DiaryErrorKind as DEK;
use libimagdiary::error::MapErrInto;
use libimagdiary::error::ResultExt;
use libimagentryedit::edit::Edit;
use libimagrt::runtime::Runtime;
use libimagerror::trace::trace_error_exit;
@ -46,7 +46,7 @@ pub fn create(rt: &Runtime) {
} else {
debug!("Editing new diary entry");
entry.edit_content(rt)
.map_err_into(DEK::DiaryEditError)
.chain_err(|| DEK::DiaryEditError)
};
if let Err(e) = res {
@ -63,7 +63,7 @@ fn create_entry<'a>(diary: &'a Store, diaryname: &str, rt: &Runtime) -> FileLock
diary.new_entry_today(diaryname)
} else {
let id = create_id_from_clispec(&create, &diaryname);
diary.retrieve(id).map_err_into(DEK::StoreReadError)
diary.retrieve(id).chain_err(|| DEK::StoreReadError)
};
match entry {

8
bin/domain/imag-diary/src/edit.rs
View file

@ -24,11 +24,11 @@ use chrono::naive::NaiveDateTime;
use libimagdiary::diary::Diary;
use libimagdiary::diaryid::DiaryId;
use libimagdiary::error::DiaryErrorKind as DEK;
use libimagdiary::error::MapErrInto;
use libimagdiary::error::DiaryError as DE;
use libimagdiary::error::ResultExt;
use libimagentryedit::edit::Edit;
use libimagrt::runtime::Runtime;
use libimagerror::trace::MapErrTrace;
use libimagerror::into::IntoError;
use libimagtimeui::datetime::DateTime;
use libimagtimeui::parse::Parse;
use libimagutil::warn_exit::warn_exit;
@ -60,8 +60,8 @@ pub fn edit(rt: &Runtime) {
})
.and_then(|id| rt.store().get(id))
.map(|opte| match opte {
Some(mut e) => e.edit_content(rt).map_err_into(DEK::IOError),
None => Err(DEK::EntryNotInDiary.into_error()),
Some(mut e) => e.edit_content(rt).chain_err(|| DEK::IOError),
None => Err(DE::from_kind(DEK::EntryNotInDiary)),
})
.map_err_trace()
.ok();

4
bin/domain/imag-diary/src/list.rs
View file

@ -19,7 +19,7 @@
use libimagdiary::diary::Diary;
use libimagdiary::error::DiaryErrorKind as DEK;
use libimagdiary::error::MapErrInto;
use libimagdiary::error::ResultExt;
use libimagentrylist::listers::core::CoreLister;
use libimagentrylist::lister::Lister;
use libimagrt::runtime::Runtime;
@ -57,7 +57,7 @@ pub fn list(rt: &Runtime) {
CoreLister::new(&entry_to_location_listing_string)
.list(es)
.map_err_into(DEK::IOError)
.chain_err(|| DEK::IOError)
})
.map_dbg_str("Ok")
.map_err_trace()

4
bin/domain/imag-mail/src/main.rs
View file

@ -66,13 +66,13 @@ fn import_mail(rt: &Runtime) {
fn list(rt: &Runtime) {
use libimagmail::error::MailErrorKind as MEK;
use libimagmail::error::MapErrInto;
use libimagmail::error::ResultExt;
let store = rt.store();
let iter = match store.retrieve_for_module("ref") {
Ok(iter) => iter.filter_map(|id| {
match store.get(id).map_err_into(MEK::RefHandlingError).map_err_trace() {
match store.get(id).chain_err(|| MEK::RefHandlingError).map_err_trace() {
Ok(Some(fle)) => Mail::from_fle(fle).map_err_trace().ok(),
Ok(None) => None,
Err(e) => trace_error_exit(&e, 1),

10
doc/src/09000-todos.md
View file

@ -72,15 +72,15 @@ Now the modules that are not yet started:
## Libraries
- [ ] Ensure all libraries are implemented as extension traits rather than
wrapping store types
- [ ] Rewrite logger to allow config/env-var based module white/blacklisting and
writing log to file
- [ ] Rewrite libimagerror to be based on `chain-error` crate. This basically
- [x] Rewrite libimagerror to be based on `chain-error` crate. This basically
removes our error infrastructure, though existing traits and convenience
functionality should be kept (for example the `MapErrInto` or the `IntoError`
traits), as much as possible). If the switch to `chain-error` would require
too much code to be rewritten, reconsider.
- [ ] Ensure all libraries are implemented as extension traits rather than
wrapping store types
- [ ] Rewrite logger to allow config/env-var based module white/blacklisting and
writing log to file
## User Interface

3
doc/src/09020-changelog.md
View file

@ -26,6 +26,9 @@ This section contains the changelog from the last release to the next release.
subdirectories were introduced for different types of crates
* The documentation got a major overhaul and was partly rewritten
* The logger is now configurable via the config file.
* The error handling of the whole codebase is based on the `error_chain`
now. `libimagerror` only contains convenience functionality, no
error-generating macros or such things anymore.
* New
* `libimagentrygps` was introduced
* Fixed bugs

440
lib/core/libimagerror/src/error_gen.rs
View file

@ -1,440 +0,0 @@
//
// imag - the personal information management suite for the commandline
// Copyright (C) 2015, 2016 Matthias Beyer <mail@beyermatthias.de> and contributors
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; version
// 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
#[macro_export]
macro_rules! generate_error_imports {
() => {
use std::error::Error;
use std::fmt::Error as FmtError;
use std::fmt::{Display, Formatter};
use $crate::into::IntoError;
}
}
#[macro_export]
macro_rules! generate_error_module {
( $exprs:item ) => {
pub mod error {
generate_error_imports!();
$exprs
}
}
}
#[macro_export]
macro_rules! generate_custom_error_types {
{
$name: ident,
$kindname: ident,
$customMemberTypeName: ident,
$($kind:ident => $string:expr),*
} => {
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum $kindname {
$( $kind ),*
}
impl Display for $kindname {
fn fmt(&self, fmt: &mut Formatter) -> Result<(), FmtError> {
let s = match *self {
$( $kindname::$kind => $string ),*
};
try!(write!(fmt, "{}", s));
Ok(())
}
}
impl IntoError for $kindname {
type Target = $name;
fn into_error(self) -> Self::Target {
$name::new(self, None)
}
fn into_error_with_cause(self, cause: Box<Error>) -> Self::Target {
$name::new(self, Some(cause))
}
}
#[derive(Debug)]
pub struct $name {
err_type: $kindname,
cause: Option<Box<Error>>,
custom_data: Option<$customMemberTypeName>,
}
impl $name {
pub fn new(errtype: $kindname, cause: Option<Box<Error>>) -> $name {
$name {
err_type: errtype,
cause: cause,
custom_data: None,
}
}
#[allow(dead_code)]
pub fn err_type(&self) -> $kindname {
self.err_type
}
#[allow(dead_code)]
pub fn with_custom_data(mut self, custom: $customMemberTypeName) -> $name {
self.custom_data = Some(custom);
self
}
}
impl Into<$name> for $kindname {
fn into(self) -> $name {
$name::new(self, None)
}
}
impl Display for $name {
fn fmt(&self, fmt: &mut Formatter) -> Result<(), FmtError> {
try!(write!(fmt, "[{}]", self.err_type));
match self.custom_data {
Some(ref c) => write!(fmt, "{}", c),
None => Ok(()),
}
}
}
impl Error for $name {
fn description(&self) -> &str {
match self.err_type {
$( $kindname::$kind => $string ),*
}
}
fn cause(&self) -> Option<&Error> {
self.cause.as_ref().map(|e| &**e)
}
}
}
}
#[macro_export]
macro_rules! generate_result_helper {
(
$name: ident,
$kindname: ident
) => {
/// Trait to replace
///
/// ```ignore
/// foo.map_err(Box::new).map_err(|e| SomeType::SomeErrorKind.into_error_with_cause(e))
/// // or:
/// foo.map_err(|e| SomeType::SomeErrorKind.into_error_with_cause(Box::new(e)))
/// ```
///
/// with much nicer
///
/// ```ignore
/// foo.map_err_into(SomeType::SomeErrorKind)
/// ```
///
pub trait MapErrInto<T> {
fn map_err_into(self, error_kind: $kindname) -> Result<T, $name>;
}
impl<T, E: Error + 'static> MapErrInto<T> for Result<T, E> {
fn map_err_into(self, error_kind: $kindname) -> Result<T, $name> {
self.map_err(Box::new)
.map_err(|e| error_kind.into_error_with_cause(e))
}
}
}
}
#[macro_export]
macro_rules! generate_option_helper {
(
$name: ident,
$kindname: ident
) => {
/// Trait to replace
///
/// ```ignore
/// foo.ok_or(SomeType::SomeErrorKind.into_error())
/// ```
///
/// with
///
/// ```ignore
/// foo.ok_or_errkind(SomeType::SomeErrorKind)
/// ```
pub trait OkOrErr<T> {
fn ok_or_errkind(self, kind: $kindname) -> Result<T, $name>;
}
impl<T> OkOrErr<T> for Option<T> {
fn ok_or_errkind(self, kind: $kindname) -> Result<T, $name> {
self.ok_or(kind.into_error())
}
}
}
}
#[macro_export]
macro_rules! generate_error_types {
(
$name: ident,
$kindname: ident,
$($kind:ident => $string:expr),*
) => {
#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Copy)]
pub struct SomeNotExistingTypeWithATypeNameNoOneWillEverChoose {}
impl Display for SomeNotExistingTypeWithATypeNameNoOneWillEverChoose {
fn fmt(&self, _: &mut Formatter) -> Result<(), FmtError> {
Ok(())
}
}
generate_custom_error_types!($name, $kindname,
SomeNotExistingTypeWithATypeNameNoOneWillEverChoose,
$($kind => $string),*);
generate_result_helper!($name, $kindname);
generate_option_helper!($name, $kindname);
}
}
#[cfg(test)]
#[allow(dead_code)]
mod test {
generate_error_module!(
generate_error_types!(TestError, TestErrorKind,
TestErrorKindA => "testerrorkind a",
TestErrorKindB => "testerrorkind B");
);
#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Copy)]
pub struct CustomData {
pub test: i32,
pub othr: i64,
}
impl Display for CustomData {
fn fmt(&self, _: &mut Formatter) -> Result<(), FmtError> {
Ok(())
}
}
generate_error_imports!();
#[allow(dead_code)]
generate_custom_error_types!(CustomTestError, CustomTestErrorKind,
CustomData,
CustomErrorKindA => "customerrorkind a",
CustomErrorKindB => "customerrorkind B");
// Allow dead code here.
// We wrote this to show that custom test types can be implemented.
#[allow(dead_code)]
impl CustomTestError {
pub fn test(&self) -> i32 {
match self.custom_data {
Some(t) => t.test,
None => 0,
}
}
pub fn bar(&self) -> i64 {
match self.custom_data {
Some(t) => t.othr,
None => 0,
}
}
}
#[test]
fn test_a() {
use self::error::{TestError, TestErrorKind};
let kind = TestErrorKind::TestErrorKindA;
assert_eq!(String::from("testerrorkind a"), format!("{}", kind));
let e = TestError::new(kind, None);
assert_eq!(String::from("[testerrorkind a]"), format!("{}", e));
}
#[test]
fn test_b() {
use self::error::{TestError, TestErrorKind};
let kind = TestErrorKind::TestErrorKindB;
assert_eq!(String::from("testerrorkind B"), format!("{}", kind));
let e = TestError::new(kind, None);
assert_eq!(String::from("[testerrorkind B]"), format!("{}", e));
}
#[test]
fn test_ab() {
use std::error::Error;
use self::error::{TestError, TestErrorKind};
let kinda = TestErrorKind::TestErrorKindA;
let kindb = TestErrorKind::TestErrorKindB;
assert_eq!(String::from("testerrorkind a"), format!("{}", kinda));
assert_eq!(String::from("testerrorkind B"), format!("{}", kindb));
let e = TestError::new(kinda, Some(Box::new(TestError::new(kindb, None))));
assert_eq!(String::from("[testerrorkind a]"), format!("{}", e));
assert_eq!(TestErrorKind::TestErrorKindA, e.err_type());
assert_eq!(String::from("[testerrorkind B]"), format!("{}", e.cause().unwrap()));
}
pub mod anothererrormod {
generate_error_imports!();
generate_error_types!(TestError, TestErrorKind,
TestErrorKindA => "testerrorkind a",
TestErrorKindB => "testerrorkind B");
}
#[test]
fn test_other_a() {
use self::anothererrormod::{TestError, TestErrorKind};
let kind = TestErrorKind::TestErrorKindA;
assert_eq!(String::from("testerrorkind a"), format!("{}", kind));
let e = TestError::new(kind, None);
assert_eq!(String::from("[testerrorkind a]"), format!("{}", e));
}
#[test]
fn test_other_b() {
use self::anothererrormod::{TestError, TestErrorKind};
let kind = TestErrorKind::TestErrorKindB;
assert_eq!(String::from("testerrorkind B"), format!("{}", kind));
let e = TestError::new(kind, None);
assert_eq!(String::from("[testerrorkind B]"), format!("{}", e));
}
#[test]
fn test_other_ab() {
use std::error::Error;
use self::anothererrormod::{TestError, TestErrorKind};
let kinda = TestErrorKind::TestErrorKindA;
let kindb = TestErrorKind::TestErrorKindB;
assert_eq!(String::from("testerrorkind a"), format!("{}", kinda));
assert_eq!(String::from("testerrorkind B"), format!("{}", kindb));
let e = TestError::new(kinda, Some(Box::new(TestError::new(kindb, None))));
assert_eq!(String::from("[testerrorkind a]"), format!("{}", e));
assert_eq!(TestErrorKind::TestErrorKindA, e.err_type());
assert_eq!(String::from("[testerrorkind B]"), format!("{}", e.cause().unwrap()));
}
#[test]
fn test_error_kind_mapping() {
use std::io::{Error, ErrorKind};
use self::error::MapErrInto;
use self::error::TestErrorKind;
let err : Result<(), _> = Err(Error::new(ErrorKind::Other, ""));
let err : Result<(), _> = err.map_err_into(TestErrorKind::TestErrorKindA);
assert!(err.is_err());
let err = err.unwrap_err();
match err.err_type() {
TestErrorKind::TestErrorKindA => assert!(true),
_ => assert!(false),
}
}
#[test]
fn test_error_kind_double_mapping() {
use std::io::{Error, ErrorKind};
use self::error::MapErrInto;
use self::error::TestErrorKind;
let err : Result<(), _> = Err(Error::new(ErrorKind::Other, ""));
let err : Result<(), _> = err.map_err_into(TestErrorKind::TestErrorKindA)
.map_err_into(TestErrorKind::TestErrorKindB);
assert!(err.is_err());
let err = err.unwrap_err();
match err.err_type() {
TestErrorKind::TestErrorKindB => assert!(true),
_ => assert!(false),
}
// not sure how to test that the inner error is of TestErrorKindA, actually...
match err.cause() {
Some(_) => assert!(true),
None => assert!(false),
}
}
#[test]
fn test_error_option_good() {
use self::error::OkOrErr;
use self::error::TestErrorKind;
let something = Some(1);
match something.ok_or_errkind(TestErrorKind::TestErrorKindA) {
Ok(1) => assert!(true),
_ => assert!(false),
}
}
#[test]
fn test_error_option_bad() {
use self::error::OkOrErr;
use self::error::TestErrorKind;
let something : Option<i32> = None;
match something.ok_or_errkind(TestErrorKind::TestErrorKindA) {
Ok(_) => assert!(false),
Err(_) => assert!(true),
}
}
}

33
lib/core/libimagerror/src/into.rs
View file

@ -1,33 +0,0 @@
//
// imag - the personal information management suite for the commandline
// Copyright (C) 2015, 2016 Matthias Beyer <mail@beyermatthias.de> and contributors
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; version
// 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
use std::error::Error;
/// Trait to help converting Error kinds into Error instances
pub trait IntoError {
type Target: Error;
/// Convert the type into an error with no cause
fn into_error(self) -> Self::Target;
/// Convert the type into an error with cause
fn into_error_with_cause(self, cause: Box<Error>) -> Self::Target;
}

4
lib/core/libimagerror/src/iter.rs
View file

@ -168,10 +168,10 @@ impl<I, T, E> TraceIterator<T, E> for I where
#[cfg(test)]
mod test {
use super::TraceIterator;
#[derive(Copy, Clone, Eq, PartialEq, Debug)]
struct TestError(i32);
#[test]
fn test_unwrap_with() {
let original = vec![Ok(1), Err(TestError(2)), Ok(3), Err(TestError(4))];

2
lib/core/libimagerror/src/lib.rs
View file

@ -36,7 +36,5 @@
#[macro_use] extern crate log;
extern crate ansi_term;
pub mod into;
pub mod error_gen;
pub mod trace;
pub mod iter;

1
lib/core/libimagrt/Cargo.toml
View file

@ -23,6 +23,7 @@ itertools = "0.5"
ansi_term = "0.9"
is-match = "0.1"
toml-query = "0.3.0"
error-chain = "0.10"
handlebars = "0.29.0"
libimagstore = { version = "0.4.0", path = "../../../lib/core/libimagstore" }

60
lib/core/libimagrt/src/configuration.rs
View file

@ -18,29 +18,45 @@
//
use std::path::PathBuf;
use std::result::Result as RResult;
use std::ops::Deref;
use toml::Value;
use clap::App;
generate_error_module!(
generate_error_types!(ConfigError, ConfigErrorKind,
TOMLParserError => "TOML Parsing error",
NoConfigFileFound => "No config file found",
error_chain! {
types {
ConfigError, ConfigErrorKind, ResultExt, Result;
}
ConfigOverrideError => "Config override error",
ConfigOverrideKeyNotAvailable => "Key not available",
ConfigOverrideTypeNotMatching => "Configuration Type not matching"
errors {
TOMLParserError {
description("TOML Parsing error")
display("TOML Parsing error")
}
);
);
NoConfigFileFound {
description("No config file found")
display("No config file found")
}
pub use self::error::{ConfigError, ConfigErrorKind, MapErrInto};
use libimagerror::into::IntoError;
ConfigOverrideError {
description("Config override error")
display("Config override error")
}
/// Result type of this module. Either `T` or `ConfigError`
pub type Result<T> = RResult<T, ConfigError>;
ConfigOverrideKeyNotAvailable {
description("Key not available")
display("Key not available")
}
ConfigOverrideTypeNotMatching {
description("Configuration Type not matching")
display("Configuration Type not matching")
}
}
}
use self::ConfigErrorKind as CEK;
use self::ConfigError as CE;
/// `Configuration` object
///
@ -130,9 +146,6 @@ impl Configuration {
pub fn override_config(&mut self, v: Vec<String>) -> Result<()> {
use libimagutil::key_value_split::*;
use libimagutil::iter::*;
use self::error::ConfigErrorKind as CEK;
use self::error::MapErrInto;
use libimagerror::into::IntoError;
use toml_query::read::TomlValueReadExt;
@ -148,21 +161,20 @@ impl Configuration {
.map(|(k, v)| self
.config
.read(&k[..])
.map_err_into(CEK::TOMLParserError)
.chain_err(|| CEK::TOMLParserError)
.map(|toml| match toml {
Some(value) => match into_value(value, v) {
Some(v) => {
info!("Successfully overridden: {} = {}", k, v);
Ok(v)
},
None => Err(CEK::ConfigOverrideTypeNotMatching.into_error()),
None => Err(CE::from_kind(CEK::ConfigOverrideTypeNotMatching)),
},
None => Err(CEK::ConfigOverrideKeyNotAvailable.into_error()),
None => Err(CE::from_kind(CEK::ConfigOverrideKeyNotAvailable)),
})
)
.fold_result(|i| i)
.map_err(Box::new)
.map_err(|e| CEK::ConfigOverrideError.into_error_with_cause(e))
.chain_err(|| CEK::ConfigOverrideError)
}
}
@ -282,13 +294,13 @@ fn fetch_config(searchpath: &PathBuf) -> Result<Value> {
.unwrap_or_else(|| String::from("Line unknown, Column unknown"));
let _ = write!(stderr(), "Config file parser error at {}", line_col);
trace_error(&ConfigErrorKind::TOMLParserError.into_error_with_cause(Box::new(e)));
trace_error(&e);
None
}
}
})
.nth(0)
.ok_or(ConfigErrorKind::NoConfigFileFound.into())
.ok_or(CE::from_kind(ConfigErrorKind::NoConfigFileFound))
}
pub trait InternalConfiguration {

111
lib/core/libimagrt/src/error.rs
View file

@ -17,33 +17,92 @@
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
generate_error_imports!();
use std::io::Error as IOError;
generate_error_types!(RuntimeError, RuntimeErrorKind,
Instantiate => "Could not instantiate",
IOError => "IO Error",
IOLogFileOpenError => "IO Error: Could not open logfile",
ProcessExitFailure => "Process exited with failure",
ConfigReadError => "Error while reading the configuration",
ConfigTypeError => "Error while reading the configuration: Type Error",
GlobalLogLevelConfigMissing => "Global config 'imag.logging.level' missing",
GlobalDestinationConfigMissing => "Global config 'imag.logging.destinations' missing",
InvalidLogLevelSpec => "Invalid log level specification: Only 'trace', 'debug', 'info', 'warn', 'error' are allowed",
TomlReadError => "Error while reading in TOML document",
TemplateStringRegistrationError => "Error while registering logging template string",
ConfigMissingLoggingFormatTrace => "Missing config for logging format for trace logging",
ConfigMissingLoggingFormatDebug => "Missing config for logging format for debug logging",
ConfigMissingLoggingFormatInfo => "Missing config for logging format for info logging",
ConfigMissingLoggingFormatWarn => "Missing config for logging format for warn logging",
ConfigMissingLoggingFormatError => "Missing config for logging format for error logging"
);
impl From<IOError> for RuntimeError {
fn from(ioe: IOError) -> RuntimeError {
RuntimeErrorKind::IOError.into_error_with_cause(Box::new(ioe))
error_chain! {
types {
RuntimeError, RuntimeErrorKind, ResultExt, Result;
}
errors {
Instantiate {
description("Could not instantiate")
display("Could not instantiate")
}
IOError {
description("IO Error")
display("IO Error")
}
ProcessExitFailure {
description("Process exited with failure")
display("Process exited with failure")
}
IOLogFileOpenError {
description("IO Error: Could not open logfile")
display("IO Error: Could not open logfile")
}
ConfigReadError {
description("Error while reading the configuration")
display("Error while reading the configuration")
}
ConfigTypeError {
description("Error while reading the configuration: Type Error")
display("Error while reading the configuration: Type Error")
}
GlobalLogLevelConfigMissing {
description("Global config 'imag.logging.level' missing")
display("Global config 'imag.logging.level' missing")
}
GlobalDestinationConfigMissing {
description("Global config 'imag.logging.destinations' missing")
display("Global config 'imag.logging.destinations' missing")
}
InvalidLogLevelSpec {
description("Invalid log level specification: Only 'trace', 'debug', 'info', 'warn', 'error' are allowed")
display("Invalid log level specification: Only 'trace', 'debug', 'info', 'warn', 'error' are allowed")
}
TomlReadError {
description("Error while reading in TOML document")
display("Error while reading in TOML document")
}
TemplateStringRegistrationError {
description("Error while registering logging template string")
display("Error while registering logging template string")
}
ConfigMissingLoggingFormatTrace {
description("Missing config for logging format for trace logging")
display("Missing config for logging format for trace logging")
}
ConfigMissingLoggingFormatDebug {
description("Missing config for logging format for debug logging")
display("Missing config for logging format for debug logging")
}
ConfigMissingLoggingFormatInfo {
description("Missing config for logging format for info logging")
display("Missing config for logging format for info logging")
}
ConfigMissingLoggingFormatWarn {
description("Missing config for logging format for warn logging")
display("Missing config for logging format for warn logging")
}
ConfigMissingLoggingFormatError {
description("Missing config for logging format for error logging")
display("Missing config for logging format for error logging")
}
}
}

5
lib/core/libimagrt/src/lib.rs
View file

@ -17,6 +17,8 @@
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
#![recursion_limit="256"]
#![deny(
dead_code,
non_camel_case_types,
@ -34,6 +36,7 @@
)]
#[macro_use] extern crate log;
#[macro_use] extern crate error_chain;
extern crate itertools;
#[cfg(unix)] extern crate xdg_basedir;
extern crate env_logger;
@ -47,7 +50,7 @@ extern crate toml_query;
extern crate libimagstore;
extern crate libimagutil;
#[macro_use] extern crate libimagerror;
extern crate libimagerror;
pub mod error;
pub mod configuration;

60
lib/core/libimagrt/src/logger.rs
View file

@ -23,12 +23,10 @@ use std::collections::BTreeMap;
use configuration::Configuration;
use error::RuntimeErrorKind as EK;
use error::RuntimeError;
use error::MapErrInto;
use error::RuntimeError as RE;
use error::ResultExt;
use runtime::Runtime;
use libimagerror::into::IntoError;
use clap::ArgMatches;
use log::{Log, LogLevel, LogRecord, LogMetadata};
use toml::Value;
@ -36,7 +34,7 @@ use toml_query::read::TomlValueReadExt;
use handlebars::Handlebars;
type ModuleName = String;
type Result<T> = ::std::result::Result<T, RuntimeError>;
type Result<T> = ::std::result::Result<T, RE>;
enum LogDestination {
Stderr,
@ -96,27 +94,27 @@ impl ImagLogger {
{
let fmt = try!(aggregate_global_format_trace(matches, config));
try!(handlebars.register_template_string("TRACE", fmt) // name must be uppercase
.map_err_into(EK::TemplateStringRegistrationError));
.chain_err(|| EK::TemplateStringRegistrationError));
}
{
let fmt = try!(aggregate_global_format_debug(matches, config));
try!(handlebars.register_template_string("DEBUG", fmt) // name must be uppercase
.map_err_into(EK::TemplateStringRegistrationError));
.chain_err(|| EK::TemplateStringRegistrationError));
}
{
let fmt = try!(aggregate_global_format_info(matches, config));
try!(handlebars.register_template_string("INFO", fmt) // name must be uppercase
.map_err_into(EK::TemplateStringRegistrationError));
.chain_err(|| EK::TemplateStringRegistrationError));
}
{
let fmt = try!(aggregate_global_format_warn(matches, config));
try!(handlebars.register_template_string("WARN", fmt) // name must be uppercase
.map_err_into(EK::TemplateStringRegistrationError));
.chain_err(|| EK::TemplateStringRegistrationError));
}
{
let fmt = try!(aggregate_global_format_error(matches, config));
try!(handlebars.register_template_string("ERROR", fmt) // name must be uppercase
.map_err_into(EK::TemplateStringRegistrationError));
.chain_err(|| EK::TemplateStringRegistrationError));
}
Ok(ImagLogger {
@ -194,7 +192,7 @@ fn match_log_level_str(s: &str) -> Result<LogLevel> {
"info" => Ok(LogLevel::Info),
"warn" => Ok(LogLevel::Warn),
"error" => Ok(LogLevel::Error),
_ => return Err(EK::InvalidLogLevelSpec.into_error()),
_ => return Err(RE::from_kind(EK::InvalidLogLevelSpec)),
}
}
@ -204,11 +202,11 @@ fn aggregate_global_loglevel(matches: &ArgMatches, config: Option<&Configuration
match config {
Some(cfg) => match cfg
.read("imag.logging.level")
.map_err_into(EK::ConfigReadError)
.chain_err(|| EK::ConfigReadError)
{
Ok(Some(&Value::String(ref s))) => match_log_level_str(s),
Ok(Some(_)) => Err(EK::ConfigTypeError.into_error()),
Ok(None) => Err(EK::GlobalLogLevelConfigMissing.into_error()),
Ok(Some(_)) => Err(RE::from_kind(EK::ConfigTypeError)),
Ok(None) => Err(RE::from_kind(EK::GlobalLogLevelConfigMissing)),
Err(e) => Err(e)
},
None => {
@ -235,7 +233,7 @@ fn translate_destination(raw: &str) -> Result<LogDestination> {
.create(true)
.open(other)
.map(LogDestination::File)
.map_err_into(EK::IOLogFileOpenError)
.chain_err(|| EK::IOLogFileOpenError)
}
}
}
@ -247,7 +245,7 @@ fn translate_destinations(raw: &Vec<Value>) -> Result<Vec<LogDestination>> {
acc.and_then(|mut v| {
let dest = match *val {
Value::String(ref s) => try!(translate_destination(s)),
_ => return Err(EK::ConfigTypeError.into_error()),
_ => return Err(RE::from_kind(EK::ConfigTypeError)),
};
v.push(dest);
Ok(v)
@ -262,11 +260,11 @@ fn aggregate_global_destinations(matches: &ArgMatches, config: Option<&Configura
match config {
Some(cfg) => match cfg
.read("imag.logging.destinations")
.map_err_into(EK::ConfigReadError)
.chain_err(|| EK::ConfigReadError)
{
Ok(Some(&Value::Array(ref a))) => translate_destinations(a),
Ok(Some(_)) => Err(EK::ConfigTypeError.into_error()),
Ok(None) => Err(EK::GlobalDestinationConfigMissing.into_error()),
Ok(Some(_)) => Err(RE::from_kind(EK::ConfigTypeError)),
Ok(None) => Err(RE::from_kind(EK::GlobalDestinationConfigMissing)),
Err(e) => Err(e)
},
None => {
@ -300,16 +298,16 @@ fn aggregate_global_format(
match config {
Some(cfg) => match cfg
.read(read_str)
.map_err_into(EK::ConfigReadError)
.chain_err(|| EK::ConfigReadError)
{
Ok(Some(&Value::String(ref s))) => Ok(s.clone()),
Ok(Some(_)) => Err(EK::ConfigTypeError.into_error()),
Ok(None) => Err(error_kind_if_missing.into_error()),
Ok(Some(_)) => Err(RE::from_kind(EK::ConfigTypeError)),
Ok(None) => Err(RE::from_kind(error_kind_if_missing)),
Err(e) => Err(e)
},
None => match matches.value_of(cli_match_name).map(String::from) {
Some(s) => Ok(s),
None => Err(error_kind_if_missing.into_error())
None => Err(RE::from_kind(error_kind_if_missing))
}
}
}
@ -370,7 +368,7 @@ fn aggregate_module_settings(_matches: &ArgMatches, config: Option<&Configuratio
match config {
Some(cfg) => match cfg
.read("imag.logging.modules")
.map_err_into(EK::ConfigReadError)
.chain_err(|| EK::ConfigReadError)
{
Ok(Some(&Value::Table(ref t))) => {
// translate the module settings from the table `t`
@ -380,22 +378,22 @@ fn aggregate_module_settings(_matches: &ArgMatches, config: Option<&Configuratio
let destinations = try!(match v.read("destinations") {
Ok(Some(&Value::Array(ref a))) => translate_destinations(a).map(Some),
Ok(None) => Ok(None),
Ok(Some(_)) => Err(EK::ConfigTypeError.into_error()),
Err(e) => Err(e).map_err_into(EK::TomlReadError),
Ok(Some(_)) => Err(RE::from_kind(EK::ConfigTypeError)),
Err(e) => Err(e).chain_err(|| EK::TomlReadError),
});
let level = try!(match v.read("level") {
Ok(Some(&Value::String(ref s))) => match_log_level_str(s).map(Some),
Ok(None) => Ok(None),
Ok(Some(_)) => Err(EK::ConfigTypeError.into_error()),
Err(e) => Err(e).map_err_into(EK::TomlReadError),
Ok(Some(_)) => Err(RE::from_kind(EK::ConfigTypeError)),
Err(e) => Err(e).chain_err(|| EK::TomlReadError),
});
let enabled = try!(match v.read("enabled") {
Ok(Some(&Value::Boolean(b))) => Ok(b),
Ok(None) => Ok(false),
Ok(Some(_)) => Err(EK::ConfigTypeError.into_error()),
Err(e) => Err(e).map_err_into(EK::TomlReadError),
Ok(Some(_)) => Err(RE::from_kind(EK::ConfigTypeError)),
Err(e) => Err(e).chain_err(|| EK::TomlReadError),
});
let module_settings = ModuleSettings {
@ -410,7 +408,7 @@ fn aggregate_module_settings(_matches: &ArgMatches, config: Option<&Configuratio
Ok(settings)
},
Ok(Some(_)) => Err(EK::ConfigTypeError.into_error()),
Ok(Some(_)) => Err(RE::from_kind(EK::ConfigTypeError)),
Ok(None) => {
// No modules configured. This is okay!
Ok(BTreeMap::new())

19
lib/core/libimagrt/src/runtime.rs
View file

@ -30,7 +30,7 @@ use log;
use configuration::{Configuration, InternalConfiguration};
use error::RuntimeError;
use error::RuntimeErrorKind;
use error::MapErrInto;
use error::ResultExt;
use logger::ImagLogger;
use libimagerror::trace::*;
@ -60,9 +60,8 @@ impl<'a> Runtime<'a> {
where C: Clone + CliSpec<'a> + InternalConfiguration
{
use libimagerror::trace::trace_error;
use libimagerror::into::IntoError;
use configuration::error::ConfigErrorKind;
use configuration::ConfigErrorKind;
let matches = cli_app.clone().matches();
@ -74,8 +73,8 @@ impl<'a> Runtime<'a> {
debug!("Config path = {:?}", configpath);
let config = match Configuration::new(&configpath) {
Err(e) => if e.err_type() != ConfigErrorKind::NoConfigFileFound {
return Err(RuntimeErrorKind::Instantiate.into_error_with_cause(Box::new(e)));
Err(e) => if !is_match!(e.kind(), &ConfigErrorKind::NoConfigFileFound) {
return Err(e).chain_err(|| RuntimeErrorKind::Instantiate);
} else {
println!("No config file found.");
println!("Continuing without configuration file");
@ -165,7 +164,7 @@ impl<'a> Runtime<'a> {
store: store,
}
})
.map_err_into(RuntimeErrorKind::Instantiate)
.chain_err(|| RuntimeErrorKind::Instantiate)
}
///
@ -485,11 +484,11 @@ impl<'a> Runtime<'a> {
let mapper = JsonMapper::new();
StdIoFileAbstraction::new(&mut input, output, mapper)
.map_err_into(RuntimeErrorKind::Instantiate)
.chain_err(|| RuntimeErrorKind::Instantiate)
.and_then(|backend| {
self.store
.reset_backend(Box::new(backend))
.map_err_into(RuntimeErrorKind::Instantiate)
.chain_err(|| RuntimeErrorKind::Instantiate)
})
}
@ -504,11 +503,11 @@ impl<'a> Runtime<'a> {
let mapper = JsonMapper::new();
StdoutFileAbstraction::new(output, mapper)
.map_err_into(RuntimeErrorKind::Instantiate)
.chain_err(|| RuntimeErrorKind::Instantiate)
.and_then(|backend| {
self.store
.reset_backend(Box::new(backend))
.map_err_into(RuntimeErrorKind::Instantiate)
.chain_err(|| RuntimeErrorKind::Instantiate)
})
}

1
lib/core/libimagstore/Cargo.toml
View file

@ -26,6 +26,7 @@ is-match = "0.1"
serde = "1.0"
serde_json = "1.0"
serde_derive = "1.0"
error-chain = "0.10"
libimagerror = { version = "0.4.0", path = "../../../lib/core/libimagerror" }
libimagutil = { version = "0.4.0", path = "../../../lib/etc/libimagutil" }

5
lib/core/libimagstore/src/configuration.rs
View file

@ -19,9 +19,8 @@
use toml::Value;
use libimagerror::into::IntoError;
use store::Result;
use error::StoreError as SE;
/// Check whether the configuration is valid for the store
pub fn config_is_valid(config: &Option<Value>) -> Result<()> {
@ -35,7 +34,7 @@ pub fn config_is_valid(config: &Option<Value>) -> Result<()> {
Some(Value::Table(_)) => Ok(()),
_ => {
warn!("Store config is no table");
Err(SEK::ConfigTypeError.into_error())
Err(SE::from_kind(SEK::ConfigTypeError))
},
}
}

354
lib/core/libimagstore/src/error.rs
View file

@ -17,99 +17,283 @@
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
generate_error_imports!();
use std::convert::From;
#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Copy)]
pub struct CustomErrorData {}
impl Display for CustomErrorData {
fn fmt(&self, _: &mut Formatter) -> Result<(), FmtError> {
Ok(()) // Do nothing here, we don't need to print smth
error_chain! {
types {
StoreError, StoreErrorKind, ResultExt, Result;
}
}
generate_custom_error_types!(StoreError, StoreErrorKind, CustomErrorData,
ConfigurationError => "Store Configuration Error",
ConfigTypeError => "Store configuration type error",
ConfigKeyMissingError => "Configuration Key missing",
foreign_links {
Io(::std::io::Error);
TomlDeserError(::toml::de::Error);
}
VersionError => "Incompatible store versions detected",
errors {
CreateStoreDirDenied => "Creating store directory implicitely denied",
FileError => "File Error",
IoError => "IO Error",
IdLocked => "ID locked",
IdNotFound => "ID not found",
OutOfMemory => "Out of Memory",
FileNotFound => "File corresponding to ID not found",
FileNotCreated => "File corresponding to ID could not be created",
FileNotWritten => "File corresponding to ID could not be written to",
FileNotSeeked => "File corresponding to ID could not be seeked",
FileNotRemoved => "File corresponding to ID could not be removed",
FileNotRenamed => "File corresponding to ID could not be renamed",
FileNotCopied => "File could not be copied",
DirNotCreated => "Directory/Directories could not be created",
StorePathExists => "Store path exists",
StorePathCreate => "Store path create",
LockError => "Error locking datastructure",
LockPoisoned => "The internal Store Lock has been poisoned",
EntryAlreadyBorrowed => "Entry is already borrowed",
EntryAlreadyExists => "Entry already exists",
MalformedEntry => "Entry has invalid formatting, missing header",
HeaderPathSyntaxError => "Syntax error in accessor string",
HeaderPathTypeFailure => "Header has wrong type for path",
HeaderKeyNotFound => "Header Key not found",
HeaderTypeFailure => "Header type is wrong",
StorePathLacksVersion => "The supplied store path has no version part",
GlobError => "glob() error",
EncodingError => "Encoding error",
StorePathError => "Store Path error",
EntryRenameError => "Entry rename error",
StoreIdHandlingError => "StoreId handling error",
StoreIdLocalPartAbsoluteError => "StoreId 'id' part is absolute (starts with '/') which is not allowed",
StoreIdBuildFromFullPathError => "Building StoreId from full file path failed",
StoreIdHasNoBaseError => "StoreId has no 'base' part",
ConfigurationError {
description("Store Configuration Error")
display("Store Configuration Error")
}
CreateCallError => "Error when calling create()",
RetrieveCallError => "Error when calling retrieve()",
GetCallError => "Error when calling get()",
GetAllVersionsCallError => "Error when calling get_all_versions()",
RetrieveForModuleCallError => "Error when calling retrieve_for_module()",
UpdateCallError => "Error when calling update()",
RetrieveCopyCallError => "Error when calling retrieve_copy()",
DeleteCallError => "Error when calling delete()",
MoveCallError => "Error when calling move()",
MoveByIdCallError => "Error when calling move_by_id()"
);
ConfigTypeError {
description("Store configuration type error")
display("Store configuration type error")
}
generate_result_helper!(StoreError, StoreErrorKind);
generate_option_helper!(StoreError, StoreErrorKind);
ConfigKeyMissingError {
description("Configuration Key missing")
display("Configuration Key missing")
}
generate_custom_error_types!(ParserError, ParserErrorKind, CustomErrorData,
TOMLParserErrors => "Several TOML-Parser-Errors",
MissingMainSection => "Missing main section",
MissingVersionInfo => "Missing version information in main section",
NonTableInBaseTable => "A non-table was found in the base table",
HeaderInconsistency => "The header is inconsistent"
);
VersionError {
description("Incompatible store versions detected")
display("Incompatible store versions detected")
}
impl From<ParserError> for StoreError {
fn from(ps: ParserError) -> StoreError {
StoreError {
err_type: StoreErrorKind::MalformedEntry,
cause: Some(Box::new(ps)),
custom_data: None,
}
}
}
impl From<::std::io::Error> for StoreError {
fn from(ps: ::std::io::Error) -> StoreError {
StoreError {
err_type: StoreErrorKind::IoError,
cause: Some(Box::new(ps)),
custom_data: None,
CreateStoreDirDenied {
description("Creating store directory implicitely denied")
display("Creating store directory implicitely denied")
}
FileError {
description("File Error")
display("File Error")
}
IoError {
description("IO Error")
display("IO Error")
}
IdLocked {
description("ID locked")
display("ID locked")
}
IdNotFound {
description("ID not found")
display("ID not found")
}
OutOfMemory {
description("Out of Memory")
display("Out of Memory")
}
FileNotFound {
description("File corresponding to ID not found")
display("File corresponding to ID not found")
}
FileNotCreated {
description("File corresponding to ID could not be created")
display("File corresponding to ID could not be created")
}
FileNotWritten {
description("File corresponding to ID could not be written to")
display("File corresponding to ID could not be written to")
}
FileNotSeeked {
description("File corresponding to ID could not be seeked")
display("File corresponding to ID could not be seeked")
}
FileNotRemoved {
description("File corresponding to ID could not be removed")
display("File corresponding to ID could not be removed")
}
FileNotRenamed {
description("File corresponding to ID could not be renamed")
display("File corresponding to ID could not be renamed")
}
FileNotCopied {
description("File could not be copied")
display("File could not be copied")
}
DirNotCreated {
description("Directory/Directories could not be created")
display("Directory/Directories could not be created")
}
StorePathExists {
description("Store path exists")
display("Store path exists")
}
StorePathCreate {
description("Store path create")
display("Store path create")
}
LockError {
description("Error locking datastructure")
display("Error locking datastructure")
}
LockPoisoned {
description("The internal Store Lock has been poisoned")
display("The internal Store Lock has been poisoned")
}
EntryAlreadyBorrowed {
description("Entry is already borrowed")
display("Entry is already borrowed")
}
EntryAlreadyExists {
description("Entry already exists")
display("Entry already exists")
}
MalformedEntry {
description("Entry has invalid formatting, missing header")
display("Entry has invalid formatting, missing header")
}
HeaderPathSyntaxError {
description("Syntax error in accessor string")
display("Syntax error in accessor string")
}
HeaderPathTypeFailure {
description("Header has wrong type for path")
display("Header has wrong type for path")
}
HeaderKeyNotFound {
description("Header Key not found")
display("Header Key not found")
}
HeaderTypeFailure {
description("Header type is wrong")
display("Header type is wrong")
}
StorePathLacksVersion {
description("The supplied store path has no version part")
display("The supplied store path has no version part")
}
GlobError {
description("glob() error")
display("glob() error")
}
EncodingError {
description("Encoding error")
display("Encoding error")
}
StorePathError {
description("Store Path error")
display("Store Path error")
}
EntryRenameError {
description("Entry rename error")
display("Entry rename error")
}
StoreIdHandlingError {
description("StoreId handling error")
display("StoreId handling error")
}
StoreIdLocalPartAbsoluteError {
description("StoreId 'id' part is absolute (starts with '/') which is not allowed")
display("StoreId 'id' part is absolute (starts with '/') which is not allowed")
}
StoreIdBuildFromFullPathError {
description("Building StoreId from full file path failed")
display("Building StoreId from full file path failed")
}
StoreIdHasNoBaseError {
description("StoreId has no 'base' part")
display("StoreId has no 'base' part")
}
CreateCallError {
description("Error when calling create()")
display("Error when calling create()")
}
RetrieveCallError {
description("Error when calling retrieve()")
display("Error when calling retrieve()")
}
GetCallError {
description("Error when calling get()")
display("Error when calling get()")
}
GetAllVersionsCallError {
description("Error when calling get_all_versions()")
display("Error when calling get_all_versions()")
}
RetrieveForModuleCallError {
description("Error when calling retrieve_for_module()")
display("Error when calling retrieve_for_module()")
}
UpdateCallError {
description("Error when calling update()")
display("Error when calling update()")
}
RetrieveCopyCallError {
description("Error when calling retrieve_copy()")
display("Error when calling retrieve_copy()")
}
DeleteCallError {
description("Error when calling delete()")
display("Error when calling delete()")
}
MoveCallError {
description("Error when calling move()")
display("Error when calling move()")
}
MoveByIdCallError {
description("Error when calling move_by_id()")
display("Error when calling move_by_id()")
}
// Parser-related errors
TOMLParserErrors {
description("Several TOML-Parser-Errors")
display("Several TOML-Parser-Errors")
}
MissingMainSection {
description("Missing main section")
display("Missing main section")
}
MissingVersionInfo {
description("Missing version information in main section")
display("Missing version information in main section")
}
NonTableInBaseTable {
description("A non-table was found in the base table")
display("A non-table was found in the base table")
}
HeaderInconsistency {
description("The header is inconsistent")
display("The header is inconsistent")
}
}
}

29
lib/core/libimagstore/src/file_abstraction/fs.rs
View file

@ -21,7 +21,8 @@ use std::fs::{File, OpenOptions, create_dir_all, remove_file, copy, rename};
use std::io::{Seek, SeekFrom, Read};
use std::path::{Path, PathBuf};
use error::{MapErrInto, StoreError as SE, StoreErrorKind as SEK};
use error::{StoreError as SE, StoreErrorKind as SEK};
use error::ResultExt;
use super::FileAbstraction;
use super::FileAbstractionInstance;
@ -47,22 +48,22 @@ impl FileAbstractionInstance for FSFileAbstractionInstance {
// We seek to the beginning of the file since we expect each
// access to the file to be in a different context
try!(f.seek(SeekFrom::Start(0))
.map_err_into(SEK::FileNotSeeked));
.chain_err(|| SEK::FileNotSeeked));
let mut s = String::new();
f.read_to_string(&mut s)
.map_err_into(SEK::IoError)
.chain_err(|| SEK::IoError)
.map(|_| s)
.and_then(|s| Entry::from_str(id, &s))
},
FSFileAbstractionInstance::Absent(ref p) =>
(try!(open_file(p).map_err_into(SEK::FileNotFound)), p.clone()),
(try!(open_file(p).chain_err(|| SEK::FileNotFound)), p.clone()),
};
*self = FSFileAbstractionInstance::File(file, path);
if let FSFileAbstractionInstance::File(ref mut f, _) = *self {
let mut s = String::new();
f.read_to_string(&mut s)
.map_err_into(SEK::IoError)
.chain_err(|| SEK::IoError)
.map(|_| s)
.and_then(|s| Entry::from_str(id, &s))
} else {
@ -83,18 +84,18 @@ impl FileAbstractionInstance for FSFileAbstractionInstance {
// We seek to the beginning of the file since we expect each
// access to the file to be in a different context
try!(f.seek(SeekFrom::Start(0))
.map_err_into(SEK::FileNotCreated));
.chain_err(|| SEK::FileNotCreated));
try!(f.set_len(buf.len() as u64).map_err_into(SEK::FileNotWritten));
try!(f.set_len(buf.len() as u64).chain_err(|| SEK::FileNotWritten));
f.write_all(&buf).map_err_into(SEK::FileNotWritten)
f.write_all(&buf).chain_err(|| SEK::FileNotWritten)
},
FSFileAbstractionInstance::Absent(ref p) =>
(try!(create_file(p).map_err_into(SEK::FileNotCreated)), p.clone()),
(try!(create_file(p).chain_err(|| SEK::FileNotCreated)), p.clone()),
};
*self = FSFileAbstractionInstance::File(file, path);
if let FSFileAbstractionInstance::File(ref mut f, _) = *self {
return f.write_all(&buf).map_err_into(SEK::FileNotWritten);
return f.write_all(&buf).chain_err(|| SEK::FileNotWritten);
}
unreachable!();
}
@ -117,19 +118,19 @@ impl FSFileAbstraction {
impl FileAbstraction for FSFileAbstraction {
fn remove_file(&self, path: &PathBuf) -> Result<(), SE> {
remove_file(path).map_err_into(SEK::FileNotRemoved)
remove_file(path).chain_err(|| SEK::FileNotRemoved)
}
fn copy(&self, from: &PathBuf, to: &PathBuf) -> Result<(), SE> {
copy(from, to).map_err_into(SEK::FileNotCopied).map(|_| ())
copy(from, to).chain_err(|| SEK::FileNotCopied).map(|_| ())
}
fn rename(&self, from: &PathBuf, to: &PathBuf) -> Result<(), SE> {
rename(from, to).map_err_into(SEK::FileNotRenamed)
rename(from, to).chain_err(|| SEK::FileNotRenamed)
}
fn create_dir_all(&self, path: &PathBuf) -> Result<(), SE> {
create_dir_all(path).map_err_into(SEK::DirNotCreated)
create_dir_all(path).chain_err(|| SEK::DirNotCreated)
}
fn new_instance(&self, p: PathBuf) -> Box<FileAbstractionInstance> {

28
lib/core/libimagstore/src/file_abstraction/inmemory.rs
View file

@ -17,17 +17,16 @@
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
use std::path::PathBuf;
use error::StoreError as SE;
use error::StoreErrorKind as SEK;
use std::path::PathBuf;
use std::collections::HashMap;
use std::sync::Mutex;
use std::cell::RefCell;
use std::sync::Arc;
use std::ops::Deref;
use libimagerror::into::IntoError;
use super::FileAbstraction;
use super::FileAbstractionInstance;
use super::Drain;
@ -64,16 +63,15 @@ impl FileAbstractionInstance for InMemoryFileAbstractionInstance {
fn get_file_content(&mut self, _: StoreId) -> Result<Entry, SE> {
debug!("Getting lazy file: {:?}", self);
match self.fs_abstraction.lock() {
Ok(mut mtx) => {
self.fs_abstraction
.lock()
.map_err(|_| SE::from_kind(SEK::LockError))
.and_then(|mut mtx| {
mtx.get_mut()
.get(&self.absent_path)
.cloned()
.ok_or(SEK::FileNotFound.into_error())
}
Err(_) => Err(SEK::LockError.into_error())
}
.ok_or(SE::from_kind(SEK::FileNotFound))
})
}
fn write_file_content(&mut self, buf: &Entry) -> Result<(), SE> {
@ -108,7 +106,7 @@ impl InMemoryFileAbstraction {
fn backend_cloned<'a>(&'a self) -> Result<HashMap<PathBuf, Entry>, SE> {
self.virtual_filesystem
.lock()
.map_err(|_| SEK::LockError.into_error())
.map_err(|_| SE::from_kind(SEK::LockError))
.map(|mtx| mtx.deref().borrow().clone())
}
@ -124,7 +122,7 @@ impl FileAbstraction for InMemoryFileAbstraction {
.get_mut()
.remove(path)
.map(|_| ())
.ok_or(SEK::FileNotFound.into_error())
.ok_or(SE::from_kind(SEK::FileNotFound))
}
fn copy(&self, from: &PathBuf, to: &PathBuf) -> Result<(), SE> {
@ -132,7 +130,7 @@ impl FileAbstraction for InMemoryFileAbstraction {
let mut mtx = self.backend().lock().expect("Locking Mutex failed");
let backend = mtx.get_mut();
let a = try!(backend.get(from).cloned().ok_or(SEK::FileNotFound.into_error()));
let a = try!(backend.get(from).cloned().ok_or(SE::from_kind(SEK::FileNotFound)));
backend.insert(to.clone(), a);
debug!("Copying: {:?} -> {:?} worked", from, to);
Ok(())
@ -143,7 +141,7 @@ impl FileAbstraction for InMemoryFileAbstraction {
let mut mtx = self.backend().lock().expect("Locking Mutex failed");
let backend = mtx.get_mut();
let a = try!(backend.get(from).cloned().ok_or(SEK::FileNotFound.into_error()));
let a = try!(backend.get(from).cloned().ok_or(SE::from_kind(SEK::FileNotFound)));
backend.insert(to.clone(), a);
debug!("Renaming: {:?} -> {:?} worked", from, to);
Ok(())
@ -163,7 +161,7 @@ impl FileAbstraction for InMemoryFileAbstraction {
fn fill<'a>(&'a mut self, mut d: Drain) -> Result<(), SE> {
debug!("Draining into : {:?}", self);
let mut mtx = try!(self.backend().lock().map_err(|_| SEK::LockError.into_error()));
let mut mtx = try!(self.backend().lock().map_err(|_| SEK::LockError));
let backend = mtx.get_mut();
for (path, element) in d.iter() {

21
lib/core/libimagstore/src/file_abstraction/stdio/mapper/json.rs
View file

@ -25,14 +25,13 @@ use serde_json;
use toml;
use error::StoreErrorKind as SEK;
use error::MapErrInto;
use error::StoreError as SE;
use error::ResultExt;
use super::Mapper;
use store::Result;
use store::Entry;
use storeid::StoreId;
use libimagerror::into::IntoError;
#[derive(Debug, Deserialize, Serialize)]
struct BackendEntry {
header: serde_json::Value,
@ -43,7 +42,7 @@ impl BackendEntry {
fn to_string(self) -> Result<String> {
toml::to_string(&self.header)
.map_err_into(SEK::IoError)
.chain_err(|| SEK::IoError)
.map(|hdr| {
format!("---\n{header}---\n{content}",
header = hdr,
@ -74,16 +73,16 @@ impl Mapper for JsonMapper {
let mut document = {
debug!("Reading Document");
let mut s = String::new();
try!(r.read_to_string(&mut s).map_err_into(SEK::IoError));
try!(r.read_to_string(&mut s).chain_err(|| SEK::IoError));
debug!("Document = {:?}", s);
debug!("Parsing Document");
let doc : Document = try!(serde_json::from_str(&s).map_err_into(SEK::IoError));
let doc : Document = try!(serde_json::from_str(&s).chain_err(|| SEK::IoError));
debug!("Document = {:?}", doc);
doc
};
let _ = try!(::semver::Version::parse(&document.version)
.map_err_into(SEK::VersionError)
.chain_err(|| SEK::VersionError)
.and_then(|doc_vers| {
// safe because cargo does not compile if crate version is not valid
let crate_version = ::semver::Version::parse(version!()).unwrap();
@ -93,7 +92,7 @@ impl Mapper for JsonMapper {
crate_vers = crate_version);
if doc_vers > crate_version {
Err(SEK::VersionError.into_error())
Err(SE::from_kind(SEK::VersionError))
} else {
Ok(())
}
@ -150,9 +149,9 @@ impl Mapper for JsonMapper {
};
serde_json::to_string(&doc)
.map_err_into(SEK::IoError)
.and_then(|json| out.write(&json.into_bytes()).map_err_into(SEK::IoError))
.and_then(|_| out.flush().map_err_into(SEK::IoError))
.chain_err(|| SEK::IoError)
.and_then(|json| out.write(&json.into_bytes()).chain_err(|| SEK::IoError))
.and_then(|_| out.flush().chain_err(|| SEK::IoError))
.map(|_| ())
}
}

12
lib/core/libimagstore/src/file_abstraction/stdio/mod.rs
View file

@ -29,8 +29,6 @@ use std::fmt::Debug;
use std::fmt::Error as FmtError;
use std::fmt::Formatter;
use libimagerror::into::IntoError;
use error::StoreErrorKind as SEK;
use error::StoreError as SE;
use super::FileAbstraction;
@ -57,11 +55,11 @@ impl<W, M> StdIoFileAbstraction<W, M>
pub fn new<R: Read>(in_stream: &mut R, out_stream: Rc<RefCell<W>>, mapper: M) -> Result<StdIoFileAbstraction<W, M>, SE> {
StdoutFileAbstraction::new(out_stream, mapper)
.and_then(|out| {
let fill_res = match out.backend().lock() {
Err(_) => Err(SEK::LockError.into_error()),
Ok(mut mtx) => out.mapper().read_to_fs(in_stream, mtx.get_mut())
};
let _ = try!(fill_res);
let _ = try!(out
.backend()
.lock()
.map_err(|_| SE::from_kind(SEK::LockError))
.map(|mut mtx| out.mapper().read_to_fs(in_stream, mtx.get_mut())));
Ok(StdIoFileAbstraction(out))
})

7
lib/core/libimagstore/src/file_abstraction/stdio/out.rs
View file

@ -31,7 +31,6 @@ use std::sync::Arc;
use std::sync::Mutex;
use std::ops::Deref;
use libimagerror::into::IntoError;
use libimagerror::trace::*;
use error::StoreErrorKind as SEK;
@ -74,7 +73,7 @@ impl<W, M> StdoutFileAbstraction<W, M>
self.mem
.backend()
.lock()
.map_err(|_| SEK::LockError.into_error())
.map_err(|_| SE::from_kind(SEK::LockError))
.map(|mtx| mtx.deref().borrow().clone())
}
@ -101,7 +100,7 @@ impl<W, M> Drop for StdoutFileAbstraction<W, M>
use std::ops::DerefMut;
let fill_res = match self.mem.backend().lock() {
Err(_) => Err(SEK::LockError.into_error()),
Err(_) => Err(SE::from_kind(SEK::LockError)),
Ok(mut mtx) => {
self.mapper.fs_to_write(mtx.get_mut(), self.out.borrow_mut().deref_mut())
},
@ -142,7 +141,7 @@ impl<W: Write, M: Mapper> FileAbstraction for StdoutFileAbstraction<W, M> {
fn fill(&mut self, mut d: Drain) -> Result<(), SE> {
debug!("Draining into : {:?}", self);
let mut mtx = try!(self.backend().lock().map_err(|_| SEK::IoError.into_error()));
let mut mtx = try!(self.backend().lock().map_err(|_| SE::from_kind(SEK::IoError)));
let backend = mtx.get_mut();
for (path, element) in d.iter() {

5
lib/core/libimagstore/src/lib.rs
View file

@ -17,6 +17,8 @@
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
#![recursion_limit="256"]
#![deny(
dead_code,
non_camel_case_types,
@ -45,8 +47,9 @@ extern crate walkdir;
#[macro_use] extern crate is_match;
extern crate serde_json;
#[macro_use] extern crate serde_derive;
#[macro_use] extern crate error_chain;
#[macro_use] extern crate libimagerror;
extern crate libimagerror;
extern crate libimagutil;
#[macro_use] mod util;

125
lib/core/libimagstore/src/store.rs
View file

@ -38,8 +38,8 @@ use glob::glob;
use walkdir::WalkDir;
use walkdir::Iter as WalkDirIter;
use error::{StoreError as SE, StoreErrorKind as SEK, ParserError, ParserErrorKind};
use error::MapErrInto;
use error::{StoreError as SE, StoreErrorKind as SEK};
use error::ResultExt;
use storeid::{IntoStoreId, StoreId, StoreIdIterator};
use file_abstraction::FileAbstractionInstance;
@ -48,7 +48,6 @@ pub use file_abstraction::FileAbstraction;
pub use file_abstraction::FSFileAbstraction;
pub use file_abstraction::InMemoryFileAbstraction;
use libimagerror::into::IntoError;
use libimagerror::trace::trace_error;
use libimagutil::debug_result::*;
@ -147,8 +146,8 @@ impl StoreEntry {
#[cfg(feature = "fs-lock")]
{
try!(open_file(pb.clone())
.and_then(|f| f.lock_exclusive().map_err_into(SEK::FileError))
.map_err_into(SEK::IoError));
.and_then(|f| f.lock_exclusive().chain_err(|| SEK::FileError))
.chain_err(|| SEK::IoError));
}
Ok(StoreEntry {
@ -168,13 +167,13 @@ impl StoreEntry {
if !self.is_borrowed() {
self.file
.get_file_content(self.id.clone())
.or_else(|err| if err.err_type() == SEK::FileNotFound {
.or_else(|err| if is_match!(err.kind(), &SEK::FileNotFound) {
Ok(Entry::new(self.id.clone()))
} else {
Err(err)
})
} else {
Err(SE::new(SEK::EntryAlreadyBorrowed, None))
Err(SE::from_kind(SEK::EntryAlreadyBorrowed))
}
}
@ -182,7 +181,7 @@ impl StoreEntry {
if self.is_borrowed() {
assert_eq!(self.id, entry.location);
self.file.write_file_content(entry)
.map_err_into(SEK::FileError)
.chain_err(|| SEK::FileError)
.map(|_| ())
} else {
Ok(())
@ -195,9 +194,9 @@ impl Drop for StoreEntry {
fn drop(self) {
self.get_entry()
.and_then(|entry| open_file(entry.get_location().clone()).map_err_into(SEK::IoError))
.and_then(|f| f.unlock().map_err_into(SEK::FileError))
.map_err_into(SEK::IoError)
.and_then(|entry| open_file(entry.get_location().clone()).chain_err(|| SEK::IoError))
.and_then(|f| f.unlock().chain_err(|| SEK::FileError))
.chain_err(|| SEK::IoError)
}
}
@ -266,7 +265,7 @@ impl Store {
use configuration::*;
debug!("Validating Store configuration");
let _ = try!(config_is_valid(&store_config).map_err_into(SEK::ConfigurationError));
let _ = try!(config_is_valid(&store_config).chain_err(|| SEK::ConfigurationError));
debug!("Building new Store object");
if !location.exists() {
@ -274,17 +273,17 @@ impl Store {
warn!("Implicitely creating store directory is denied");
warn!(" -> Either because configuration does not allow it");
warn!(" -> or because there is no configuration");
return Err(SEK::CreateStoreDirDenied.into_error())
.map_err_into(SEK::FileError)
.map_err_into(SEK::IoError);
return Err(SE::from_kind(SEK::CreateStoreDirDenied))
.chain_err(|| SEK::FileError)
.chain_err(|| SEK::IoError);
}
try!(backend.create_dir_all(&location)
.map_err_into(SEK::StorePathCreate)
.chain_err(|| SEK::StorePathCreate)
.map_dbg_err_str("Failed"));
} else if location.is_file() {
debug!("Store path exists as file");
return Err(SEK::StorePathExists.into_error());
return Err(SE::from_kind(SEK::StorePathExists));
}
let store = Store {
@ -408,13 +407,13 @@ impl Store {
{
let mut hsmap = match self.entries.write() {
Err(_) => return Err(SEK::LockPoisoned.into_error()).map_err_into(SEK::CreateCallError),
Err(_) => return Err(SE::from_kind(SEK::LockPoisoned)).chain_err(|| SEK::CreateCallError),
Ok(s) => s,
};
if hsmap.contains_key(&id) {
debug!("Cannot create, internal cache already contains: '{}'", id);
return Err(SEK::EntryAlreadyExists.into_error()).map_err_into(SEK::CreateCallError);
return Err(SE::from_kind(SEK::EntryAlreadyExists)).chain_err(|| SEK::CreateCallError);
}
hsmap.insert(id.clone(), {
debug!("Creating: '{}'", id);
@ -449,7 +448,7 @@ impl Store {
let entry = try!({
self.entries
.write()
.map_err(|_| SE::new(SEK::LockPoisoned, None))
.map_err(|_| SE::from_kind(SEK::LockPoisoned))
.and_then(|mut es| {
let new_se = try!(StoreEntry::new(id.clone(), &self.backend));
let se = es.entry(id.clone()).or_insert(new_se);
@ -457,7 +456,7 @@ impl Store {
se.status = StoreEntryStatus::Borrowed;
entry
})
.map_err_into(SEK::RetrieveCallError)
.chain_err(|| SEK::RetrieveCallError)
});
debug!("Constructing FileLockEntry: '{}'", id);
@ -482,8 +481,8 @@ impl Store {
let exists = try!(id.exists()) || try!(self.entries
.read()
.map(|map| map.contains_key(&id))
.map_err(|_| SE::new(SEK::LockPoisoned, None))
.map_err_into(SEK::GetCallError)
.map_err(|_| SE::from_kind(SEK::LockPoisoned))
.chain_err(|| SEK::GetCallError)
);
if !exists {
@ -491,7 +490,7 @@ impl Store {
return Ok(None);
}
self.retrieve(id).map(Some).map_err_into(SEK::GetCallError)
self.retrieve(id).map(Some).chain_err(|| SEK::GetCallError)
}
/// Iterate over all StoreIds for one module name
@ -512,15 +511,15 @@ impl Store {
debug!("Retrieving for module: '{}'", mod_name);
path.to_str()
.ok_or(SE::new(SEK::EncodingError, None))
.ok_or(SE::from_kind(SEK::EncodingError))
.and_then(|path| {
let path = [ path, "/**/*" ].join("");
debug!("glob()ing with '{}'", path);
glob(&path[..]).map_err_into(SEK::GlobError)
glob(&path[..]).chain_err(|| SEK::GlobError)
})
.map(|paths| GlobStoreIdIterator::new(paths, self.path().clone()).into())
.map_err_into(SEK::GlobError)
.map_err_into(SEK::RetrieveForModuleCallError)
.chain_err(|| SEK::GlobError)
.chain_err(|| SEK::RetrieveForModuleCallError)
}
/// Walk the store tree for the module
@ -538,7 +537,7 @@ impl Store {
///
pub fn update<'a>(&'a self, entry: &mut FileLockEntry<'a>) -> Result<()> {
debug!("Updating FileLockEntry at '{}'", entry.get_location());
self._update(entry, false).map_err_into(SEK::UpdateCallError)
self._update(entry, false).chain_err(|| SEK::UpdateCallError)
}
/// Internal method to write to the filesystem store.
@ -560,11 +559,11 @@ impl Store {
///
fn _update<'a>(&'a self, entry: &mut FileLockEntry<'a>, modify_presence: bool) -> Result<()> {
let mut hsmap = match self.entries.write() {
Err(_) => return Err(SE::new(SEK::LockPoisoned, None)),
Err(_) => return Err(SE::from_kind(SEK::LockPoisoned)),
Ok(e) => e,
};
let se = try!(hsmap.get_mut(&entry.location).ok_or(SE::new(SEK::IdNotFound, None)));
let se = try!(hsmap.get_mut(&entry.location).ok_or(SE::from_kind(SEK::IdNotFound)));
assert!(se.is_borrowed(), "Tried to update a non borrowed entry.");
@ -597,15 +596,15 @@ impl Store {
debug!("Retrieving copy of '{}'", id);
let entries = match self.entries.write() {
Err(_) => {
return Err(SE::new(SEK::LockPoisoned, None))
.map_err_into(SEK::RetrieveCopyCallError);
return Err(SE::from_kind(SEK::LockPoisoned))
.chain_err(|| SEK::RetrieveCopyCallError);
},
Ok(e) => e,
};
// if the entry is currently modified by the user, we cannot drop it
if entries.get(&id).map(|e| e.is_borrowed()).unwrap_or(false) {
return Err(SE::new(SEK::IdLocked, None)).map_err_into(SEK::RetrieveCopyCallError);
return Err(SE::from_kind(SEK::IdLocked)).chain_err(|| SEK::RetrieveCopyCallError);
}
try!(StoreEntry::new(id, &self.backend)).get_entry()
@ -629,18 +628,18 @@ impl Store {
{
let mut entries = match self.entries.write() {
Err(_) => return Err(SE::new(SEK::LockPoisoned, None))
.map_err_into(SEK::DeleteCallError),
Err(_) => return Err(SE::from_kind(SEK::LockPoisoned))
.chain_err(|| SEK::DeleteCallError),
Ok(e) => e,
};
// if the entry is currently modified by the user, we cannot drop it
match entries.get(&id) {
None => {
return Err(SEK::FileNotFound.into_error()).map_err_into(SEK::DeleteCallError)
return Err(SE::from_kind(SEK::FileNotFound)).chain_err(|| SEK::DeleteCallError)
},
Some(e) => if e.is_borrowed() {
return Err(SE::new(SEK::IdLocked, None)).map_err_into(SEK::DeleteCallError)
return Err(SE::from_kind(SEK::IdLocked)).chain_err(|| SEK::DeleteCallError)
}
}
@ -648,8 +647,9 @@ impl Store {
entries.remove(&id);
let pb = try!(id.clone().with_base(self.path().clone()).into_pathbuf());
if let Err(e) = self.backend.remove_file(&pb) {
return Err(SEK::FileError.into_error_with_cause(Box::new(e)))
.map_err_into(SEK::DeleteCallError);
return Err(e)
.chain_err(|| SEK::FileError)
.chain_err(|| SEK::DeleteCallError);
}
}
@ -677,12 +677,12 @@ impl Store {
let hsmap = try!(
self.entries
.write()
.map_err(|_| SEK::LockPoisoned.into_error())
.map_err_into(SEK::MoveCallError)
.map_err(|_| SE::from_kind(SEK::LockPoisoned))
.chain_err(|| SEK::MoveCallError)
);
if hsmap.contains_key(&new_id) {
return Err(SEK::EntryAlreadyExists.into_error()).map_err_into(SEK::MoveCallError)
return Err(SE::from_kind(SEK::EntryAlreadyExists)).chain_err(|| SEK::MoveCallError)
}
let old_id = entry.get_location().clone();
@ -698,8 +698,8 @@ impl Store {
Ok(())
}
})
.map_err_into(SEK::FileError)
.map_err_into(SEK::MoveCallError)
.chain_err(|| SEK::FileError)
.chain_err(|| SEK::MoveCallError)
}
/// Move an entry without loading
@ -743,26 +743,26 @@ impl Store {
{
let mut hsmap = match self.entries.write() {
Err(_) => return Err(SE::new(SEK::LockPoisoned, None)),
Err(_) => return Err(SE::from_kind(SEK::LockPoisoned)),
Ok(m) => m,
};
if hsmap.contains_key(&new_id) {
return Err(SEK::EntryAlreadyExists.into_error());
return Err(SE::from_kind(SEK::EntryAlreadyExists));
}
// if we do not have an entry here, we fail in `FileAbstraction::rename()` below.
// if we have one, but it is borrowed, we really should not rename it, as this might
// lead to strange errors
if hsmap.get(&old_id).map(|e| e.is_borrowed()).unwrap_or(false) {
return Err(SEK::EntryAlreadyBorrowed.into_error());
return Err(SE::from_kind(SEK::EntryAlreadyBorrowed));
}
let old_id_pb = try!(old_id.clone().with_base(self.path().clone()).into_pathbuf());
let new_id_pb = try!(new_id.clone().with_base(self.path().clone()).into_pathbuf());
match self.backend.rename(&old_id_pb, &new_id_pb) {
Err(e) => return Err(SEK::EntryRenameError.into_error_with_cause(Box::new(e))),
Err(e) => return Err(e).chain_err(|| SEK::EntryRenameError),
Ok(_) => {
debug!("Rename worked on filesystem");
@ -1035,7 +1035,7 @@ mod glob_store_iter {
use storeid::StoreIdIterator;
use error::StoreErrorKind as SEK;
use error::MapErrInto;
use error::ResultExt;
use libimagerror::trace::trace_error;
@ -1088,7 +1088,7 @@ mod glob_store_iter {
fn next(&mut self) -> Option<StoreId> {
while let Some(o) = self.paths.next() {
debug!("GlobStoreIdIterator::next() => {:?}", o);
match o.map_err_into(SEK::StoreIdHandlingError) {
match o.chain_err(|| SEK::StoreIdHandlingError) {
Ok(path) => {
if path.exists() && path.is_file() {
return match StoreId::from_full_path(&self.store_path, path) {
@ -1121,7 +1121,7 @@ mod glob_store_iter {
/// top-level Value::Table, but not on intermediate tables.
pub trait Header {
fn verify(&self) -> Result<()>;
fn parse(s: &str) -> RResult<Value, ParserError>;
fn parse(s: &str) -> Result<Value>;
fn default_header() -> Value;
}
@ -1130,15 +1130,15 @@ impl Header for Value {
fn verify(&self) -> Result<()> {
match *self {
Value::Table(ref t) => verify_header(&t),
_ => Err(SE::new(SEK::HeaderTypeFailure, None)),
_ => Err(SE::from_kind(SEK::HeaderTypeFailure)),
}
}
fn parse(s: &str) -> RResult<Value, ParserError> {
fn parse(s: &str) -> Result<Value> {
use toml::de::from_str;
from_str(s)
.map_err(|_| ParserErrorKind::TOMLParserErrors.into())
.chain_err(|| SEK::TOMLParserErrors)
.and_then(verify_header_consistency)
.map(Value::Table)
}
@ -1160,21 +1160,18 @@ impl Header for Value {
}
fn verify_header_consistency(t: Table) -> RResult<Table, ParserError> {
verify_header(&t)
.map_err(Box::new)
.map_err(|e| ParserErrorKind::HeaderInconsistency.into_error_with_cause(e))
.map(|_| t)
fn verify_header_consistency(t: Table) -> Result<Table> {
verify_header(&t).chain_err(|| SEK::HeaderInconsistency).map(|_| t)
}
fn verify_header(t: &Table) -> Result<()> {
if !has_main_section(t) {
Err(SE::from(ParserErrorKind::MissingMainSection.into_error()))
Err(SE::from_kind(SEK::MissingMainSection))
} else if !has_imag_version_in_main_section(t) {
Err(SE::from(ParserErrorKind::MissingVersionInfo.into_error()))
Err(SE::from_kind(SEK::MissingVersionInfo))
} else if !has_only_tables(t) {
debug!("Could not verify that it only has tables in its base table");
Err(SE::from(ParserErrorKind::NonTableInBaseTable.into_error()))
Err(SE::from_kind(SEK::NonTableInBaseTable))
} else {
Ok(())
}
@ -1518,7 +1515,7 @@ mod store_tests {
for n in 1..100 {
let s = format!("test-{}", n % 50);
store.create(PathBuf::from(s.clone()))
.map_err(|e| assert!(is_match!(e.err_type(), SEK::CreateCallError) && n >= 50))
.map_err(|e| assert!(is_match!(e.kind(), &SEK::CreateCallError) && n >= 50))
.ok()
.map(|entry| {
assert!(entry.verify().is_ok());

15
lib/core/libimagstore/src/storeid.rs
View file

@ -26,10 +26,9 @@ use std::fmt::Error as FmtError;
use std::result::Result as RResult;
use std::path::Components;
use libimagerror::into::IntoError;
use error::StoreErrorKind as SEK;
use error::MapErrInto;
use error::StoreError as SE;
use error::ResultExt;
use store::Result;
/// The Index into the Store
@ -61,7 +60,7 @@ impl StoreId {
where D: Deref<Target = Path>
{
let p = try!(
full_path.strip_prefix(store_part).map_err_into(SEK::StoreIdBuildFromFullPathError)
full_path.strip_prefix(store_part).chain_err(|| SEK::StoreIdBuildFromFullPathError)
);
StoreId::new(Some(store_part.clone()), PathBuf::from(p))
}
@ -69,7 +68,7 @@ impl StoreId {
pub fn new_baseless(id: PathBuf) -> Result<StoreId> {
debug!("Trying to get a new baseless id from: {:?}", id);
if id.is_absolute() {
Err(SEK::StoreIdLocalPartAbsoluteError.into_error())
Err(SE::from_kind(SEK::StoreIdLocalPartAbsoluteError))
} else {
Ok(StoreId {
base: None,
@ -91,7 +90,7 @@ impl StoreId {
/// Transform the StoreId object into a PathBuf, error if the base of the StoreId is not
/// specified.
pub fn into_pathbuf(self) -> Result<PathBuf> {
let mut base = try!(self.base.ok_or(SEK::StoreIdHasNoBaseError.into_error()));
let mut base = try!(self.base.ok_or(SEK::StoreIdHasNoBaseError));
base.push(self.id);
Ok(base)
}
@ -108,7 +107,7 @@ impl StoreId {
.unwrap_or_else(|| self.id.clone())
.to_str()
.map(String::from)
.ok_or(SEK::StoreIdHandlingError.into_error())
.ok_or(SE::from_kind(SEK::StoreIdHandlingError))
}
/// Returns the components of the `id` part of the StoreId object.
@ -347,7 +346,7 @@ mod test {
let pb = id.unwrap().into_pathbuf();
assert!(pb.is_err());
assert_eq!(pb.unwrap_err().err_type(), SEK::StoreIdHasNoBaseError);
assert!(is_match!(pb.unwrap_err().kind(), &SEK::StoreIdHasNoBaseError));
}
#[test]

7
lib/core/libimagstore/src/util.rs
View file

@ -20,11 +20,10 @@
use regex::Regex;
use toml::Value;
use libimagerror::into::IntoError;
use store::Result;
use store::Header;
use error::StoreErrorKind as SEK;
use error::StoreError as SE;
#[cfg(feature = "early-panic")]
#[macro_export]
@ -54,12 +53,12 @@ pub fn entry_buffer_to_header_content(buf: &str) -> Result<(Value, String)> {
}
let matches = match RE.captures(buf) {
None => return Err(SEK::MalformedEntry.into_error()),
None => return Err(SE::from_kind(SEK::MalformedEntry)),
Some(s) => s,
};
let header = match matches.name("header") {
None => return Err(SEK::MalformedEntry.into_error()),
None => return Err(SE::from_kind(SEK::MalformedEntry)),
Some(s) => s
};

1
lib/domain/libimagbookmark/Cargo.toml
View file

@ -16,6 +16,7 @@ homepage = "http://imag-pim.org"
[dependencies]
url = "1.2"
regex = "0.1"
error-chain = "0.10"
libimagstore = { version = "0.4.0", path = "../../../lib/core/libimagstore" }
libimagerror = { version = "0.4.0", path = "../../../lib/core/libimagerror" }

34
lib/domain/libimagbookmark/src/collection.rs
View file

@ -29,8 +29,9 @@ use std::ops::DerefMut;
use regex::Regex;
use error::BookmarkErrorKind as BEK;
use error::MapErrInto;
use result::Result;
use error::BookmarkError as BE;
use error::ResultExt;
use error::Result;
use module_path::ModuleEntryPath;
use libimagstore::store::Store;
@ -40,7 +41,6 @@ use libimagentrylink::external::ExternalLinker;
use libimagentrylink::external::iter::UrlIter;
use libimagentrylink::internal::InternalLinker;
use libimagentrylink::internal::Link as StoreLink;
use libimagerror::into::IntoError;
use link::Link;
@ -81,17 +81,17 @@ impl<'a> BookmarkCollection<'a> {
store: store,
}
})
.map_err_into(BEK::StoreReadError)
.chain_err(|| BEK::StoreReadError)
}
pub fn get(store: &'a Store, name: &str) -> Result<BookmarkCollection<'a>> {
ModuleEntryPath::new(name)
.into_storeid()
.and_then(|id| store.get(id))
.map_err_into(BEK::StoreReadError)
.chain_err(|| BEK::StoreReadError)
.and_then(|fle| {
match fle {
None => Err(BEK::CollectionNotFound.into_error()),
None => Err(BE::from_kind(BEK::CollectionNotFound)),
Some(e) => Ok(BookmarkCollection {
fle: e,
store: store,
@ -104,11 +104,11 @@ impl<'a> BookmarkCollection<'a> {
ModuleEntryPath::new(name)
.into_storeid()
.and_then(|id| store.delete(id))
.map_err_into(BEK::StoreReadError)
.chain_err(|| BEK::StoreReadError)
}
pub fn links(&self) -> Result<UrlIter> {
self.fle.get_external_links(&self.store).map_err_into(BEK::LinkError)
self.fle.get_external_links(&self.store).chain_err(|| BEK::LinkError)
}
pub fn link_entries(&self) -> Result<Vec<StoreLink>> {
@ -117,22 +117,22 @@ impl<'a> BookmarkCollection<'a> {
self.fle
.get_internal_links()
.map(|v| v.filter(|id| is_external_link_storeid(id)).collect())
.map_err_into(BEK::StoreReadError)
.chain_err(|| BEK::StoreReadError)
}
pub fn add_link(&mut self, l: Link) -> Result<()> {
use link::IntoUrl;
l.into_url()
.and_then(|url| self.add_external_link(self.store, url).map_err_into(BEK::LinkingError))
.map_err_into(BEK::LinkError)
.and_then(|url| self.add_external_link(self.store, url).chain_err(|| BEK::LinkingError))
.chain_err(|| BEK::LinkError)
}
pub fn get_links_matching(&self, r: Regex) -> Result<LinksMatchingRegexIter<'a>> {
use self::iter::IntoLinksMatchingRegexIter;
self.get_external_links(self.store)
.map_err_into(BEK::LinkError)
.chain_err(|| BEK::LinkError)
.map(|iter| iter.matching_regex(r))
}
@ -141,17 +141,17 @@ impl<'a> BookmarkCollection<'a> {
l.into_url()
.and_then(|url| {
self.remove_external_link(self.store, url).map_err_into(BEK::LinkingError)
self.remove_external_link(self.store, url).chain_err(|| BEK::LinkingError)
})
.map_err_into(BEK::LinkError)
.chain_err(|| BEK::LinkError)
}
}
pub mod iter {
use link::Link;
use result::Result;
use error::{MapErrInto, BookmarkErrorKind as BEK};
use error::Result;
use error::{ResultExt, BookmarkErrorKind as BEK};
pub struct LinkIter<I>(I)
where I: Iterator<Item = Link>;
@ -194,7 +194,7 @@ pub mod iter {
loop {
let n = match self.0.next() {
Some(Ok(n)) => n,
Some(Err(e)) => return Some(Err(e).map_err_into(BEK::LinkError)),
Some(Err(e)) => return Some(Err(e).chain_err(|| BEK::LinkError)),
None => return None,
};

44
lib/domain/libimagbookmark/src/error.rs
View file

@ -17,17 +17,37 @@
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
generate_error_module!(
generate_error_types!(BookmarkError, BookmarkErrorKind,
StoreReadError => "Store read error",
LinkError => "Link error",
LinkParsingError => "Link parsing error",
LinkingError => "Error while linking",
CollectionNotFound => "Link-Collection not found"
);
);
error_chain! {
types {
BookmarkError, BookmarkErrorKind, ResultExt, Result;
}
pub use self::error::BookmarkError;
pub use self::error::BookmarkErrorKind;
pub use self::error::MapErrInto;
errors {
StoreReadError {
description("Store read error")
display("Store read error")
}
LinkError {
description("Link error")
display("Link error")
}
LinkParsingError {
description("Link parsing error")
display("Link parsing error")
}
LinkingError {
description("Error while linking")
display("Error while linking")
}
CollectionNotFound {
description("Link-Collection not found")
display("Link-Collection not found")
}
}
}

6
lib/domain/libimagbookmark/src/lib.rs
View file

@ -17,6 +17,8 @@
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
#![recursion_limit="256"]
#![deny(
dead_code,
non_camel_case_types,
@ -35,9 +37,10 @@
extern crate url;
extern crate regex;
#[macro_use] extern crate error_chain;
#[macro_use] extern crate libimagstore;
#[macro_use] extern crate libimagerror;
extern crate libimagerror;
extern crate libimagentrylink;
module_entry_path_mod!("bookmark");
@ -45,4 +48,3 @@ module_entry_path_mod!("bookmark");
pub mod collection;
pub mod error;
pub mod link;
pub mod result;

6
lib/domain/libimagbookmark/src/link.rs
View file

@ -19,7 +19,7 @@
use std::ops::{Deref, DerefMut};
use result::Result;
use error::Result;
use url::Url;
@ -67,9 +67,9 @@ impl IntoUrl for Link {
fn into_url(self) -> Result<Url> {
use error::BookmarkErrorKind as BEK;
use error::MapErrInto;
use error::ResultExt;
Url::parse(&self[..]).map_err_into(BEK::LinkParsingError)
Url::parse(&self[..]).chain_err(|| BEK::LinkParsingError)
}
}

25
lib/domain/libimagbookmark/src/result.rs
View file

@ -1,25 +0,0 @@
//
// imag - the personal information management suite for the commandline
// Copyright (C) 2015, 2016 Matthias Beyer <mail@beyermatthias.de> and contributors
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; version
// 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
use std::result::Result as RResult;
use error::BookmarkError;
pub type Result<T> = RResult<T, BookmarkError>;

1
lib/domain/libimagcounter/Cargo.toml
View file

@ -17,6 +17,7 @@ homepage = "http://imag-pim.org"
log = "0.3"
toml = "0.4.*"
toml-query = "0.3.*"
error-chain = "0.10"
libimagstore = { version = "0.4.0", path = "../../../lib/core/libimagstore" }
libimagerror = { version = "0.4.0", path = "../../../lib/core/libimagerror" }

57
lib/domain/libimagcounter/src/counter.rs
View file

@ -32,13 +32,12 @@ use libimagstore::storeid::StoreIdIterator;
use libimagstore::store::FileLockEntry;
use libimagstore::storeid::StoreId;
use libimagstore::storeid::IntoStoreId;
use libimagerror::into::IntoError;
use module_path::ModuleEntryPath;
use result::Result;
use error::Result;
use error::CounterError as CE;
use error::CounterErrorKind as CEK;
use error::error::MapErrInto;
use error::ResultExt;
pub type CounterName = String;
@ -71,25 +70,25 @@ impl<'a> Counter<'a> {
let fle = {
let id = try!(ModuleEntryPath::new(name.clone())
.into_storeid()
.map_err_into(CEK::StoreWriteError));
let mut lockentry = try!(store.create(id).map_err_into(CEK::StoreWriteError));
.chain_err(|| CEK::StoreWriteError));
let mut lockentry = try!(store.create(id).chain_err(|| CEK::StoreWriteError));
{
let entry = lockentry.deref_mut();
let header = entry.get_header_mut();
let setres = header.set(&String::from("counter"), Value::Table(BTreeMap::new()));
if setres.is_err() {
return Err(CEK::StoreWriteError.into_error());
return Err(CE::from_kind(CEK::StoreWriteError));
}
let setres = header.set(&String::from("counter.name"), Value::String(name));
if setres.is_err() {
return Err(CEK::StoreWriteError.into_error())
return Err(CE::from_kind(CEK::StoreWriteError))
}
let setres = header.set(&String::from("counter.value"), Value::Integer(init));
if setres.is_err() {
return Err(CEK::StoreWriteError.into_error())
return Err(CE::from_kind(CEK::StoreWriteError))
}
}
@ -107,7 +106,7 @@ impl<'a> Counter<'a> {
let setres = header.set(&String::from("counter.unit"), Value::String(u.0));
if setres.is_err() {
self.unit = None;
return Err(CEK::StoreWriteError.into_error())
return Err(CE::from_kind(CEK::StoreWriteError))
}
};
Ok(self)
@ -116,26 +115,26 @@ impl<'a> Counter<'a> {
pub fn inc(&mut self) -> Result<()> {
let header = self.fle.deref_mut().get_header_mut();
let query = String::from("counter.value");
match try!(header.read(&query).map_err_into(CEK::StoreReadError)) {
match try!(header.read(&query).chain_err(|| CEK::StoreReadError)) {
Some(&Value::Integer(i)) => {
header.set(&query, Value::Integer(i + 1))
.map_err_into(CEK::StoreWriteError)
.chain_err(|| CEK::StoreWriteError)
.map(|_| ())
},
_ => Err(CE::new(CEK::StoreReadError, None)),
_ => Err(CE::from_kind(CEK::StoreReadError)),
}
}
pub fn dec(&mut self) -> Result<()> {
let header = self.fle.deref_mut().get_header_mut();
let query = String::from("counter.value");
match try!(header.read(&query).map_err_into(CEK::StoreReadError)) {
match try!(header.read(&query).chain_err(|| CEK::StoreReadError)) {
Some(&Value::Integer(i)) => {
header.set(&query, Value::Integer(i - 1))
.map_err_into(CEK::StoreWriteError)
.chain_err(|| CEK::StoreWriteError)
.map(|_| ())
},
_ => Err(CE::new(CEK::StoreReadError, None)),
_ => Err(CE::from_kind(CEK::StoreReadError)),
}
}
@ -148,23 +147,23 @@ impl<'a> Counter<'a> {
.deref_mut()
.get_header_mut()
.set(&String::from("counter.value"), Value::Integer(v))
.map_err_into(CEK::StoreWriteError)
.chain_err(|| CEK::StoreWriteError)
.map(|_| ())
}
pub fn name(&self) -> Result<CounterName> {
self.read_header_at("counter.name", |v| match v {
Some(&Value::String(ref s)) => Ok(s.clone()),
Some(_) => Err(CEK::HeaderTypeError.into_error()),
_ => Err(CEK::StoreReadError.into_error()),
Some(_) => Err(CE::from_kind(CEK::HeaderTypeError)),
_ => Err(CE::from_kind(CEK::StoreReadError)),
})
}
pub fn value(&self) -> Result<i64> {
self.read_header_at("counter.value", |v| match v {
Some(&Value::Integer(i)) => Ok(i),
Some(_) => Err(CEK::HeaderTypeError.into_error()),
_ => Err(CEK::StoreReadError.into_error()),
Some(_) => Err(CE::from_kind(CEK::HeaderTypeError)),
_ => Err(CE::from_kind(CEK::StoreReadError)),
})
}
@ -175,8 +174,8 @@ impl<'a> Counter<'a> {
pub fn read_unit(&self) -> Result<Option<CounterUnit>> {
self.read_header_at("counter.unit", |s| match s {
Some(&Value::String(ref s)) => Ok(Some(CounterUnit::new(s.clone()))),
Some(_) => Err(CEK::HeaderTypeError.into_error()),
_ => Err(CEK::StoreReadError.into_error()),
Some(_) => Err(CE::from_kind(CEK::HeaderTypeError)),
_ => Err(CE::from_kind(CEK::StoreReadError)),
})
}
@ -187,7 +186,7 @@ impl<'a> Counter<'a> {
self.fle
.get_header()
.read(&String::from(name))
.map_err_into(CEK::StoreWriteError)
.chain_err(|| CEK::StoreWriteError)
.and_then(f)
}
@ -195,7 +194,7 @@ impl<'a> Counter<'a> {
debug!("Loading counter: '{}'", name);
let id = try!(ModuleEntryPath::new(name)
.into_storeid()
.map_err_into(CEK::StoreWriteError));
.chain_err(|| CEK::StoreWriteError));
Counter::from_storeid(store, id)
}
@ -203,14 +202,14 @@ impl<'a> Counter<'a> {
debug!("Deleting counter: '{}'", name);
let id = try!(ModuleEntryPath::new(name)
.into_storeid()
.map_err_into(CEK::StoreWriteError));
store.delete(id).map_err_into(CEK::StoreWriteError)
.chain_err(|| CEK::StoreWriteError));
store.delete(id).chain_err(|| CEK::StoreWriteError)
}
pub fn all_counters(store: &Store) -> Result<CounterIterator> {
store.retrieve_for_module("counter")
.map(|iter| CounterIterator::new(store, iter))
.map_err_into(CEK::StoreReadError)
.chain_err(|| CEK::StoreReadError)
}
}
@ -224,11 +223,11 @@ impl<'a> FromStoreId for Counter<'a> {
fn from_storeid(store: &Store, id: StoreId) -> Result<Counter> {
debug!("Loading counter from storeid: '{:?}'", id);
match store.retrieve(id) {
Err(e) => Err(CE::new(CEK::StoreReadError, Some(Box::new(e)))),
Err(e) => Err(e).chain_err(|| CEK::StoreReadError),
Ok(c) => {
let mut counter = Counter { fle: c, unit: None };
counter.read_unit()
.map_err_into(CEK::StoreReadError)
.chain_err(|| CEK::StoreReadError)
.and_then(|u| {
counter.unit = u;
Ok(counter)

43
lib/domain/libimagcounter/src/error.rs
View file

@ -17,16 +17,37 @@
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
generate_error_module!(
generate_error_types!(CounterError, CounterErrorKind,
StoreIdError => "StoreId error",
StoreReadError => "Store read error",
StoreWriteError => "Store write error",
HeaderTypeError => "Header type error",
HeaderFieldMissingError => "Header field missing error"
);
);
error_chain! {
types {
CounterError, CounterErrorKind, ResultExt, Result;
}
pub use self::error::CounterError;
pub use self::error::CounterErrorKind;
errors {
StoreIdError {
description("StoreId error")
display("StoreId error")
}
StoreReadError {
description("Store read error")
display("Store read error")
}
StoreWriteError {
description("Store write error")
display("Store write error")
}
HeaderTypeError {
description("Header type error")
display("Header type error")
}
HeaderFieldMissingError {
description("Header field missing error")
display("Header field missing error")
}
}
}

6
lib/domain/libimagcounter/src/lib.rs
View file

@ -17,6 +17,8 @@
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
#![recursion_limit="256"]
#![deny(
dead_code,
non_camel_case_types,
@ -36,13 +38,13 @@
extern crate toml;
extern crate toml_query;
#[macro_use] extern crate log;
#[macro_use] extern crate error_chain;
#[macro_use] extern crate libimagstore;
#[macro_use] extern crate libimagerror;
extern crate libimagerror;
module_entry_path_mod!("counter");
pub mod counter;
pub mod error;
pub mod result;

25
lib/domain/libimagcounter/src/result.rs
View file

@ -1,25 +0,0 @@
//
// imag - the personal information management suite for the commandline
// Copyright (C) 2015, 2016 Matthias Beyer <mail@beyermatthias.de> and contributors
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; version
// 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
use std::result::Result as RResult;
use error::CounterError;
pub type Result<T> = RResult<T, CounterError>;

1
lib/domain/libimagdiary/Cargo.toml
View file

@ -19,6 +19,7 @@ log = "0.3"
toml = "0.4.*"
toml-query = "0.3.*"
itertools = "0.5"
error-chain = "0.10"
libimagstore = { version = "0.4.0", path = "../../../lib/core/libimagstore" }
libimagerror = { version = "0.4.0", path = "../../../lib/core/libimagerror" }

23
lib/domain/libimagdiary/src/diary.rs
View file

@ -32,8 +32,8 @@ use chrono::Timelike;
use entry::DiaryEntry;
use diaryid::DiaryId;
use error::DiaryErrorKind as DEK;
use error::MapErrInto;
use result::Result;
use error::ResultExt;
use error::Result;
use iter::DiaryEntryIterator;
use iter::DiaryNameIterator;
@ -63,28 +63,27 @@ impl Diary for Store {
let ndt = dt.naive_local();
let id = DiaryId::new(String::from(diary_name), ndt.year(), ndt.month(), ndt.day(), 0, 0);
self.retrieve(id).map_err_into(DEK::StoreReadError)
self.retrieve(id).chain_err(|| DEK::StoreReadError)
}
// create or get a new entry for today
fn new_entry_now(&self, diary_name: &str) -> Result<FileLockEntry> {
let dt = Local::now();
let ndt = dt.naive_local();
let id = DiaryId::new(String::from(diary_name),
ndt.year(),
ndt.month(),
ndt.day(),
ndt.minute(),
ndt.second());
ndt.year(),
ndt.month(),
ndt.day(),
ndt.hour(),
ndt.minute());
self.retrieve(id).map_err_into(DEK::StoreReadError)
self.retrieve(id).chain_err(|| DEK::StoreReadError)
}
// Get an iterator for iterating over all entries
fn entries(&self, diary_name: &str) -> Result<DiaryEntryIterator> {
self.retrieve_for_module("diary")
.map(|iter| DiaryEntryIterator::new(self, String::from(diary_name), iter))
.map_err_into(DEK::StoreReadError)
.chain_err(|| DEK::StoreReadError)
}
fn get_youngest_entry_id(&self, diary_name: &str) -> Option<Result<DiaryId>> {
@ -127,7 +126,7 @@ impl Diary for Store {
/// Get all diary names
fn diary_names(&self) -> Result<DiaryNameIterator> {
self.retrieve_for_module("diary")
.map_err_into(DEK::StoreReadError)
.chain_err(|| DEK::StoreReadError)
.map(DiaryNameIterator::new)
}

15
lib/domain/libimagdiary/src/diaryid.rs
View file

@ -32,8 +32,7 @@ use libimagstore::store::Result as StoreResult;
use error::DiaryError as DE;
use error::DiaryErrorKind as DEK;
use error::MapErrInto;
use libimagerror::into::IntoError;
use error::ResultExt;
use module_path::ModuleEntryPath;
@ -191,7 +190,7 @@ fn component_to_str<'a>(com: Component<'a>) -> Result<&'a str, DE> {
Component::Normal(s) => Some(s),
_ => None,
}.and_then(|s| s.to_str())
.ok_or(DEK::IdParseError.into_error())
.ok_or(DE::from_kind(DEK::IdParseError))
}
impl FromStoreId for DiaryId {
@ -204,7 +203,7 @@ impl FromStoreId for DiaryId {
fn next_component<'a>(components: &'a mut Rev<Components>) -> Result<&'a str, DE> {
components.next()
.ok_or(DEK::IdParseError.into_error())
.ok_or(DE::from_kind(DEK::IdParseError))
.and_then(component_to_str)
}
@ -222,21 +221,21 @@ impl FromStoreId for DiaryId {
match (hour, minute) {
(Some(h), Some(m)) => Ok((h, m)),
_ => return Err(DE::new(DEK::IdParseError, None)),
_ => return Err(DE::from_kind(DEK::IdParseError)),
}
}));
let day: Result<u32,_> = next_component(&mut cmps)
.and_then(|s| s.parse::<u32>()
.map_err_into(DEK::IdParseError));
.chain_err(|| DEK::IdParseError));
let month: Result<u32,_> = next_component(&mut cmps)
.and_then(|s| s.parse::<u32>()
.map_err_into(DEK::IdParseError));
.chain_err(|| DEK::IdParseError));
let year: Result<i32,_> = next_component(&mut cmps)
.and_then(|s| s.parse::<i32>()
.map_err_into(DEK::IdParseError));
.chain_err(|| DEK::IdParseError));
let name = next_component(&mut cmps).map(String::from);

2
lib/domain/libimagdiary/src/entry.rs
View file

@ -21,7 +21,7 @@ use libimagstore::store::Entry;
use diaryid::DiaryId;
use diaryid::FromStoreId;
use result::Result;
use error::Result;
pub trait DiaryEntry {
fn diary_id(&self) -> Result<DiaryId>;

80
lib/domain/libimagdiary/src/error.rs
View file

@ -17,23 +17,67 @@
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
generate_error_module!(
generate_error_types!(DiaryError, DiaryErrorKind,
StoreWriteError => "Error writing store",
StoreReadError => "Error reading store",
CannotFindDiary => "Cannot find diary",
CannotCreateNote => "Cannot create Note object for diary entry",
DiaryEditError => "Cannot edit diary entry",
PathConversionError => "Error while converting paths internally",
EntryNotInDiary => "Entry not in Diary",
IOError => "IO Error",
ViewError => "Error viewing diary entry",
IdParseError => "Error while parsing ID",
DiaryNameFindingError => "Error while finding a diary name"
);
);
error_chain! {
types {
DiaryError, DiaryErrorKind, ResultExt, Result;
}
pub use self::error::DiaryError;
pub use self::error::DiaryErrorKind;
pub use self::error::MapErrInto;
errors {
StoreWriteError {
description("Error writing store")
display("Error writing store")
}
StoreReadError {
description("Error reading store")
display("Error reading store")
}
CannotFindDiary {
description("Cannot find diary")
display("Cannot find diary")
}
CannotCreateNote {
description("Cannot create Note object for diary entry")
display("Cannot create Note object for diary entry")
}
DiaryEditError {
description("Cannot edit diary entry")
display("Cannot edit diary entry")
}
PathConversionError {
description("Error while converting paths internally")
display("Error while converting paths internally")
}
EntryNotInDiary {
description("Entry not in Diary")
display("Entry not in Diary")
}
IOError {
description("IO Error")
display("IO Error")
}
ViewError {
description("Error viewing diary entry")
display("Error viewing diary entry")
}
IdParseError {
description("Error while parsing ID")
display("Error while parsing ID")
}
DiaryNameFindingError {
description("Error while finding a diary name")
display("Error while finding a diary name")
}
}
}

16
lib/domain/libimagdiary/src/iter.rs
View file

@ -24,15 +24,14 @@ use libimagstore::store::Store;
use libimagstore::store::FileLockEntry;
use libimagstore::storeid::StoreIdIterator;
use libimagerror::trace::trace_error;
use libimagerror::into::IntoError;
use diaryid::DiaryId;
use diaryid::FromStoreId;
use error::DiaryError as DE;
use error::DiaryErrorKind as DEK;
use error::MapErrInto;
use result::Result;
use is_in_diary::IsInDiary;
use error::DiaryErrorKind as DEK;
use error::DiaryError as DE;
use error::ResultExt;
use error::Result;
/// A iterator for iterating over diary entries
pub struct DiaryEntryIterator<'a> {
@ -120,8 +119,7 @@ impl<'a> Iterator for DiaryEntryIterator<'a> {
return Some(self
.store
.retrieve(next)
.map_err(|e| DE::new(DEK::StoreReadError, Some(Box::new(e))))
);
.chain_err(|| DEK::StoreReadError));
}
} else {
debug!("Not in the requested diary ({}): {:?}", self.name, next);
@ -153,12 +151,12 @@ impl Iterator for DiaryNameIterator {
.next()
.map(|s| {
s.to_str()
.map_err_into(DEK::DiaryNameFindingError)
.chain_err(|| DEK::DiaryNameFindingError)
.and_then(|s| {
s.split("diary/")
.nth(1)
.and_then(|n| n.split("/").nth(0).map(String::from))
.ok_or(DEK::DiaryNameFindingError.into_error())
.ok_or(DE::from_kind(DEK::DiaryNameFindingError))
})
})
}

6
lib/domain/libimagdiary/src/lib.rs
View file

@ -17,6 +17,8 @@
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
#![recursion_limit="256"]
#![deny(
dead_code,
non_camel_case_types,
@ -38,9 +40,10 @@ extern crate chrono;
extern crate toml;
extern crate toml_query;
extern crate itertools;
#[macro_use] extern crate error_chain;
#[macro_use] extern crate libimagstore;
#[macro_use] extern crate libimagerror;
extern crate libimagerror;
extern crate libimagentryedit;
extern crate libimagentryview;
extern crate libimagrt;
@ -54,6 +57,5 @@ pub mod diary;
pub mod is_in_diary;
pub mod entry;
pub mod iter;
pub mod result;
pub mod viewer;

24
lib/domain/libimagdiary/src/result.rs
View file

@ -1,24 +0,0 @@
//
// imag - the personal information management suite for the commandline
// Copyright (C) 2015, 2016 Matthias Beyer <mail@beyermatthias.de> and contributors
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; version
// 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
use std::result::Result as RResult;
use error::DiaryError;
pub type Result<T> = RResult<T, DiaryError>;

8
lib/domain/libimagdiary/src/viewer.rs
View file

@ -21,8 +21,8 @@
use entry::DiaryEntry;
use error::DiaryErrorKind as DEK;
use error::MapErrInto;
use result::Result;
use error::ResultExt;
use error::Result;
use libimagstore::store::FileLockEntry;
use libimagentryview::viewer::Viewer;
@ -56,8 +56,8 @@ impl DiaryViewer {
}
let _ = try!(self.0
.view_entry(&entry)
.map_err_into(DEK::ViewError)
.map_err_into(DEK::IOError));
.chain_err(|| DEK::ViewError)
.chain_err(|| DEK::IOError));
println!("\n---\n");
}

1
lib/domain/libimagmail/Cargo.toml
View file

@ -17,6 +17,7 @@ homepage = "http://imag-pim.org"
log = "0.3"
email = "0.0.17"
filters = "0.1.*"
error-chain = "0.10"
libimagstore = { version = "0.4.0", path = "../../../lib/core/libimagstore" }
libimagerror = { version = "0.4.0", path = "../../../lib/core/libimagerror" }

51
lib/domain/libimagmail/src/error.rs
View file

@ -17,19 +17,44 @@
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
generate_error_module!(
generate_error_types!(MailError, MailErrorKind,
RefCreationError => "Error creating a reference to a file/directory",
RefHandlingError => "Error while handling the internal reference object",
MailParsingError => "Error while parsing mail",
error_chain! {
types {
MailError, MailErrorKind, ResultExt, Result;
}
FetchByHashError => "Error fetching mail from Store by hash",
FetchError => "Error fetching mail from Store",
IOError => "IO Error"
);
);
links {
RefError(::libimagentryref::error::RefError, ::libimagentryref::error::RefErrorKind);
}
pub use self::error::MailError;
pub use self::error::MailErrorKind;
pub use self::error::MapErrInto;
errors {
RefCreationError {
description("Error creating a reference to a file/directory")
display("Error creating a reference to a file/directory")
}
RefHandlingError {
description("Error handling a reference")
display("Error handling a reference")
}
MailParsingError {
description("Failed to parse mail")
display("Failed to parse mail")
}
FetchByHashError {
description("Error fetching mail from Store by hash")
display("Error fetching mail from Store by hash")
}
FetchError {
description("Error fetching mail from Store")
display("Error fetching mail from Store")
}
IOError {
description("IO Error")
display("IO Error")
}
}
}

16
lib/domain/libimagmail/src/hasher.rs
View file

@ -25,11 +25,8 @@ use email::MimeMessage;
use libimagentryref::hasher::Hasher;
use libimagentryref::hasher::DefaultHasher;
use libimagentryref::error::RefErrorKind as REK;
use libimagentryref::error::MapErrInto;
use libimagentryref::result::Result as RResult;
use libimagerror::into::IntoError;
use error::MailErrorKind as MEK;
use libimagentryref::error::ResultExt;
use libimagentryref::error::Result as RResult;
pub struct MailHasher {
defaulthasher: DefaultHasher,
@ -54,12 +51,10 @@ impl Hasher for MailHasher {
use email::Header;
let mut s = String::new();
try!(c.read_to_string(&mut s).map_err_into(REK::UTF8Error).map_err_into(REK::IOError));
try!(c.read_to_string(&mut s).chain_err(|| REK::UTF8Error).chain_err(|| REK::IOError));
MimeMessage::parse(&s)
.map_err(Box::new)
.map_err(|e| MEK::MailParsingError.into_error_with_cause(e))
.map_err_into(REK::RefHashingError)
.chain_err(|| REK::RefHashingError)
.and_then(|mail| {
let has_key = |hdr: &Header, exp: &str| hdr.name == exp;
@ -73,8 +68,7 @@ impl Hasher for MailHasher {
for hdr in mail.headers.iter().filter(|item| filter.filter(item)) {
let s = try!(hdr
.get_value()
.map_err(Box::new)
.map_err(|e| REK::RefHashingError.into_error_with_cause(e)));
.chain_err(|| REK::RefHashingError));
v.push(s);
}

2
lib/domain/libimagmail/src/iter.rs
View file

@ -25,7 +25,7 @@
//!
use mail::Mail;
use result::Result;
use error::Result;
use libimagstore::store::FileLockEntry;

6
lib/domain/libimagmail/src/lib.rs
View file

@ -17,6 +17,8 @@
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
#![recursion_limit="256"]
#![deny(
dead_code,
non_camel_case_types,
@ -36,8 +38,9 @@
#[macro_use] extern crate log;
extern crate email;
extern crate filters;
#[macro_use] extern crate error_chain;
#[macro_use] extern crate libimagerror;
extern crate libimagerror;
extern crate libimagstore;
extern crate libimagentryref;
@ -45,5 +48,4 @@ pub mod error;
pub mod hasher;
pub mod iter;
pub mod mail;
pub mod result;

24
lib/domain/libimagmail/src/mail.rs
View file

@ -32,8 +32,8 @@ use email::MimeMessage;
use email::results::ParsingResult as EmailParsingResult;
use hasher::MailHasher;
use result::Result;
use error::{MapErrInto, MailErrorKind as MEK};
use error::Result;
use error::{ResultExt, MailErrorKind as MEK};
struct Buffer(String);
@ -61,17 +61,17 @@ impl<'a> Mail<'a> {
let p = PathBuf::from(p.as_ref());
store.create_with_hasher(p, f, h)
.map_err_into(MEK::RefCreationError)
.chain_err(|| MEK::RefCreationError)
.and_then(|reference| {
debug!("Build reference file: {:?}", reference);
reference.fs_file()
.map_err_into(MEK::RefHandlingError)
.and_then(|path| File::open(path).map_err_into(MEK::IOError))
.chain_err(|| MEK::RefHandlingError)
.and_then(|path| File::open(path).chain_err(|| MEK::IOError))
.and_then(|mut file| {
let mut s = String::new();
file.read_to_string(&mut s)
.map(|_| s)
.map_err_into(MEK::IOError)
.chain_err(|| MEK::IOError)
})
.map(Buffer::from)
.map(|buffer| Mail(reference, buffer))
@ -82,8 +82,8 @@ impl<'a> Mail<'a> {
pub fn open<S: AsRef<str>>(store: &Store, hash: S) -> Result<Option<Mail>> {
debug!("Opening Mail by Hash");
store.get_by_hash(String::from(hash.as_ref()))
.map_err_into(MEK::FetchByHashError)
.map_err_into(MEK::FetchError)
.chain_err(|| MEK::FetchByHashError)
.chain_err(|| MEK::FetchError)
.and_then(|o| match o {
Some(r) => Mail::from_fle(r).map(Some),
None => Ok(None),
@ -94,13 +94,13 @@ impl<'a> Mail<'a> {
/// Implement me as TryFrom as soon as it is stable
pub fn from_fle(fle: FileLockEntry<'a>) -> Result<Mail<'a>> {
fle.fs_file()
.map_err_into(MEK::RefHandlingError)
.and_then(|path| File::open(path).map_err_into(MEK::IOError))
.chain_err(|| MEK::RefHandlingError)
.and_then(|path| File::open(path).chain_err(|| MEK::IOError))
.and_then(|mut file| {
let mut s = String::new();
file.read_to_string(&mut s)
.map(|_| s)
.map_err_into(MEK::IOError)
.chain_err(|| MEK::IOError)
})
.map(Buffer::from)
.map(|buffer| Mail(fle, buffer))
@ -110,7 +110,7 @@ impl<'a> Mail<'a> {
debug!("Getting field in mail: {:?}", field);
self.1
.parsed()
.map_err_into(MEK::MailParsingError)
.chain_err(|| MEK::MailParsingError)
.map(|parsed| {
parsed.headers
.iter()

25
lib/domain/libimagmail/src/result.rs
View file

@ -1,25 +0,0 @@
//
// imag - the personal information management suite for the commandline
// Copyright (C) 2015, 2016 Matthias Beyer <mail@beyermatthias.de> and contributors
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; version
// 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
use std::result::Result as RResult;
use error::MailError;
pub type Result<T> = RResult<T, MailError>;

1
lib/domain/libimagnotes/Cargo.toml
View file

@ -17,6 +17,7 @@ homepage = "http://imag-pim.org"
log = "0.3"
toml = "^0.4"
toml-query = "0.3.0"
error-chain = "0.10"
libimagstore = { version = "0.4.0", path = "../../../lib/core/libimagstore" }
libimagerror = { version = "0.4.0", path = "../../../lib/core/libimagerror" }

38
lib/domain/libimagnotes/src/error.rs
View file

@ -17,16 +17,32 @@
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
generate_error_module!(
generate_error_types!(NoteError, NoteErrorKind,
StoreWriteError => "Error writing store",
StoreReadError => "Error reading store",
HeaderTypeError => "Header type error",
NoteToEntryConversion => "Error converting Note instance to Entry instance"
);
);
error_chain! {
types {
NoteError, NoteErrorKind, ResultExt, Result;
}
pub use self::error::NoteError;
pub use self::error::NoteErrorKind;
pub use self::error::MapErrInto;
errors {
StoreWriteError {
description("Error writing store")
display("Error writing store")
}
StoreReadError {
description("Error reading store")
display("Error reading store")
}
HeaderTypeError {
description("Header type error")
display("Header type error")
}
NoteToEntryConversion {
description("Error converting Note instance to Entry instance")
display("Error converting Note instance to Entry instance")
}
}
}

6
lib/domain/libimagnotes/src/lib.rs
View file

@ -17,6 +17,8 @@
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
#![recursion_limit="256"]
#![deny(
dead_code,
non_camel_case_types,
@ -36,15 +38,15 @@
#[macro_use] extern crate log;
extern crate toml;
extern crate toml_query;
#[macro_use] extern crate error_chain;
extern crate libimagrt;
#[macro_use] extern crate libimagstore;
#[macro_use] extern crate libimagerror;
extern crate libimagerror;
extern crate libimagentryedit;
module_entry_path_mod!("notes");
pub mod error;
pub mod note;
pub mod result;

45
lib/domain/libimagnotes/src/note.rs
View file

@ -24,7 +24,7 @@ use toml::Value;
use libimagrt::runtime::Runtime;
use libimagentryedit::edit::Edit;
use libimagentryedit::result::Result as EditResult;
use libimagentryedit::error::Result as EditResult;
use libimagstore::storeid::IntoStoreId;
use libimagstore::storeid::StoreId;
use libimagstore::storeid::StoreIdIterator;
@ -35,10 +35,10 @@ use toml_query::read::TomlValueReadExt;
use toml_query::set::TomlValueSetExt;
use module_path::ModuleEntryPath;
use result::Result;
use error::NoteError as NE;
use error::Result;
use error::NoteErrorKind as NEK;
use error::MapErrInto;
use error::NoteError as NE;
use error::ResultExt;
#[derive(Debug)]
pub struct Note<'a> {
@ -55,24 +55,20 @@ impl<'a> Note<'a> {
let mut lockentry = try!(ModuleEntryPath::new(name.clone())
.into_storeid()
.and_then(|id| store.create(id))
.map_err_into(NEK::StoreWriteError));
.chain_err(|| NEK::StoreWriteError));
{
let entry = lockentry.deref_mut();
{
let header = entry.get_header_mut();
let setres = header.set("note", Value::Table(BTreeMap::new()));
if setres.is_err() {
let kind = NEK::StoreWriteError;
return Err(NE::new(kind, Some(Box::new(setres.unwrap_err()))));
}
let _ = header
.set("note", Value::Table(BTreeMap::new()))
.chain_err(|| NEK::StoreWriteError);
let setres = header.set("note.name", Value::String(name));
if setres.is_err() {
let kind = NEK::StoreWriteError;
return Err(NE::new(kind, Some(Box::new(setres.unwrap_err()))));
}
let _ = header
.set("note.name", Value::String(name))
.chain_err(|| NEK::StoreWriteError);
}
*entry.get_content_mut() = text;
@ -88,7 +84,7 @@ impl<'a> Note<'a> {
self.entry
.get_header_mut()
.set("note.name", Value::String(n))
.map_err(|e| NE::new(NEK::StoreWriteError, Some(Box::new(e))))
.chain_err(|| NEK::StoreWriteError)
.map(|_| ())
}
@ -96,11 +92,10 @@ impl<'a> Note<'a> {
let header = self.entry.get_header();
match header.read("note.name") {
Ok(Some(&Value::String(ref s))) => Ok(s.clone()),
Ok(_) => {
let e = NE::new(NEK::HeaderTypeError, None);
Err(NE::new(NEK::StoreReadError, Some(Box::new(e))))
Ok(_) => {
Err(NE::from_kind(NEK::HeaderTypeError)).chain_err(|| NEK::StoreReadError)
},
Err(e) => Err(NE::new(NEK::StoreReadError, Some(Box::new(e))))
Err(e) => Err(e).chain_err(|| NEK::StoreReadError)
}
}
@ -116,14 +111,14 @@ impl<'a> Note<'a> {
ModuleEntryPath::new(name)
.into_storeid()
.and_then(|id| store.delete(id))
.map_err_into(NEK::StoreWriteError)
.chain_err(|| NEK::StoreWriteError)
}
pub fn retrieve(store: &Store, name: String) -> Result<Note> {
ModuleEntryPath::new(name)
.into_storeid()
.and_then(|id| store.retrieve(id))
.map_err_into(NEK::StoreWriteError)
.chain_err(|| NEK::StoreWriteError)
.map(|entry| Note { entry: entry })
}
@ -131,14 +126,14 @@ impl<'a> Note<'a> {
ModuleEntryPath::new(name)
.into_storeid()
.and_then(|id| store.get(id))
.map_err_into(NEK::StoreWriteError)
.chain_err(|| NEK::StoreWriteError)
.map(|o| o.map(|entry| Note { entry: entry }))
}
pub fn all_notes(store: &Store) -> Result<NoteIterator> {
store.retrieve_for_module("notes")
.map(|iter| NoteIterator::new(store, iter))
.map_err(|e| NE::new(NEK::StoreReadError, Some(Box::new(e))))
.chain_err(|| NEK::StoreReadError)
}
}
@ -160,7 +155,7 @@ impl<'a> FromStoreId for Note<'a> {
fn from_storeid(store: &Store, id: StoreId) -> Result<Note> {
debug!("Loading note from storeid: '{:?}'", id);
match store.retrieve(id) {
Err(e) => Err(NE::new(NEK::StoreReadError, Some(Box::new(e)))),
Err(e) => Err(e).chain_err(|| NEK::StoreReadError),
Ok(entry) => Ok(Note { entry: entry }),
}
}

25
lib/domain/libimagnotes/src/result.rs
View file

@ -1,25 +0,0 @@
//
// imag - the personal information management suite for the commandline
// Copyright (C) 2015, 2016 Matthias Beyer <mail@beyermatthias.de> and contributors
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; version
// 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
use std::result::Result as RResult;
use error::NoteError;
pub type Result<T> = RResult<T, NoteError>;

1
lib/domain/libimagtimetrack/Cargo.toml
View file

@ -20,6 +20,7 @@ toml = "0.4"
toml-query = "0.3"
lazy_static = "0.2"
is-match = "0.1"
error-chain = "0.10"
libimagerror = { version = "0.4.0", path = "../../../lib/core/libimagerror" }
libimagstore = { version = "0.4.0", path = "../../../lib/core/libimagstore" }

55
lib/domain/libimagtimetrack/src/error.rs
View file

@ -17,23 +17,48 @@
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
generate_error_module!(
generate_error_types!(TimeTrackError, TimeTrackErrorKind,
StoreReadError => "Store read error",
StoreWriteError => "Store write error",
error_chain! {
types {
TimeTrackError, TimeTrackErrorKind, ResultExt, Result;
}
StoreIdError => "Error while handling StoreId",
errors {
StoreReadError {
description("Error while writing Store")
display("Error while writing Store")
}
TagFormat => "Tag has invalid format",
StoreWriteError {
description("Error while reading Store")
display("Error while reading Store")
}
HeaderReadError => "Error writing header",
HeaderWriteError => "Error writing header",
HeaderFieldTypeError => "Type error in header",
DateTimeParserError => "Error while parsing DateTime"
);
);
StoreIdError {
description("Error while handling StoreId")
display("Error while handling StoreId")
}
pub use self::error::TimeTrackError;
pub use self::error::TimeTrackErrorKind;
pub use self::error::MapErrInto;
TagFormat {
description("Tag has invalid format")
display("Tag has invalid format")
}
HeaderReadError {
description("Error writing header")
display("Error writing header")
}
HeaderWriteError {
description("Error writing header")
display("Error writing header")
}
HeaderFieldTypeError {
description("Type error in header")
display("Type error in header")
}
DateTimeParserError {
description("Error while parsing DateTime")
display("Error while parsing DateTime")
}
}
}

6
lib/domain/libimagtimetrack/src/iter/create.rs
View file

@ -24,7 +24,7 @@ use chrono::naive::NaiveDateTime as NDT;
use constants::*;
use error::TimeTrackError as TTE;
use error::TimeTrackErrorKind as TTEK;
use error::MapErrInto;
use error::ResultExt;
use iter::storeid::TagStoreIdIter;
use iter::setendtime::SetEndTimeIter;
@ -61,12 +61,12 @@ impl<'a> Iterator for CreateTimeTrackIter<'a>
res.and_then(|(id, starttime)| {
self.store
.create(id)
.map_err_into(TTEK::StoreWriteError)
.chain_err(|| TTEK::StoreWriteError)
.and_then(|mut entry| {
let v = Value::String(starttime.format(DATE_TIME_FORMAT).to_string());
entry.get_header_mut()
.insert(DATE_TIME_START_HEADER_PATH, v)
.map_err_into(TTEK::HeaderWriteError)
.chain_err(|| TTEK::HeaderWriteError)
.map(|_| entry)
})
})

7
lib/domain/libimagtimetrack/src/iter/get.rs
View file

@ -19,12 +19,11 @@
use error::TimeTrackError as TTE;
use error::TimeTrackErrorKind as TTEK;
use error::MapErrInto;
use error::ResultExt;
use libimagstore::store::FileLockEntry;
use libimagstore::store::Store;
use libimagstore::storeid::StoreIdIterator;
use libimagerror::into::IntoError;
pub struct GetTimeTrackIter<'a>{
inner: StoreIdIterator,
@ -46,8 +45,8 @@ impl<'a> Iterator for GetTimeTrackIter<'a> {
fn next(&mut self) -> Option<Self::Item> {
self.inner.next().map(|sid| {
match self.store.get(sid).map_err_into(TTEK::StoreReadError) {
Ok(None) => Err(TTEK::StoreReadError.into_error()),
match self.store.get(sid).chain_err(|| TTEK::StoreReadError) {
Ok(None) => Err(TTE::from_kind(TTEK::StoreReadError)),
Ok(Some(s)) => Ok(s),
Err(e) => Err(e)
}

4
lib/domain/libimagtimetrack/src/iter/setendtime.rs
View file

@ -24,7 +24,7 @@ use chrono::naive::NaiveDateTime as NDT;
use constants::*;
use error::TimeTrackError as TTE;
use error::TimeTrackErrorKind as TTEK;
use error::MapErrInto;
use error::ResultExt;
use iter::create::CreateTimeTrackIter;
use libimagstore::store::FileLockEntry;
@ -55,7 +55,7 @@ impl<'a> Iterator for SetEndTimeIter<'a> {
let v = Value::String(self.datetime.format(DATE_TIME_FORMAT).to_string());
fle.get_header_mut()
.insert(DATE_TIME_END_HEADER_PATH, v)
.map_err_into(TTEK::HeaderWriteError)
.chain_err(|| TTEK::HeaderWriteError)
.map(|_| fle)
})
})

4
lib/domain/libimagtimetrack/src/iter/storeid.rs
View file

@ -22,7 +22,7 @@ use chrono::naive::NaiveDateTime as NDT;
use constants::*;
use error::TimeTrackError;
use error::TimeTrackErrorKind as TTEK;
use error::MapErrInto;
use error::ResultExt;
use iter::tag::TagIter;
use iter::create::CreateTimeTrackIter;
@ -64,7 +64,7 @@ impl Iterator for TagStoreIdIter {
let id_str = format!("{}-{}", dt, tag.as_str());
ModuleEntryPath::new(id_str)
.into_storeid()
.map_err_into(TTEK::StoreIdError)
.chain_err(|| TTEK::StoreIdError)
.map(|id| (id, self.datetime.clone()))
})
})

4
lib/domain/libimagtimetrack/src/iter/tag.rs
View file

@ -21,11 +21,11 @@ use chrono::naive::NaiveDateTime as NDT;
use error::TimeTrackError;
use error::TimeTrackErrorKind as TTEK;
use error::TimeTrackError as TTE;
use tag::TimeTrackingTag as TTT;
use iter::storeid::TagStoreIdIter;
use libimagentrytag::tag::is_tag_str;
use libimagerror::into::IntoError;
pub struct TagIter(Box<Iterator<Item = String>>);
@ -48,7 +48,7 @@ impl Iterator for TagIter {
.map(|t| if is_tag_str(&t).is_ok() {
Ok(TTT::from(t))
} else {
Err(TTEK::TagFormat.into_error())
Err(TTE::from_kind(TTEK::TagFormat))
})
}
}

7
lib/domain/libimagtimetrack/src/lib.rs
View file

@ -17,6 +17,8 @@
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
#![recursion_limit="256"]
#![deny(
dead_code,
non_camel_case_types,
@ -41,20 +43,19 @@ extern crate toml_query;
extern crate lazy_static;
#[macro_use]
extern crate is_match;
#[macro_use] extern crate error_chain;
#[macro_use]
extern crate libimagerror;
#[macro_use]
extern crate libimagstore;
extern crate libimagentrydatetime;
extern crate libimagentrytag;
extern crate libimagerror;
mod constants;
pub mod error;
pub mod timetracking;
pub mod timetrackingstore;
pub mod iter;
pub mod result;
pub mod tag;
module_entry_path_mod!("timetrack");

26
lib/domain/libimagtimetrack/src/result.rs
View file

@ -1,26 +0,0 @@
//
// imag - the personal information management suite for the commandline
// Copyright (C) 2015, 2016 Matthias Beyer <mail@beyermatthias.de> and contributors
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; version
// 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
use std::result::Result as RResult;
use error::TimeTrackError;
pub type Result<T> = RResult<T, TimeTrackError>;

28
lib/domain/libimagtimetrack/src/timetracking.rs
View file

@ -27,12 +27,12 @@
use chrono::naive::NaiveDateTime;
use libimagstore::store::Entry;
use libimagerror::into::IntoError;
use tag::TimeTrackingTag as TTT;
use error::TimeTrackErrorKind as TTEK;
use error::MapErrInto;
use result::Result;
use error::TimeTrackError as TTE;
use error::ResultExt;
use error::Result;
use constants::*;
use toml::Value;
@ -65,11 +65,11 @@ impl TimeTracking for Entry {
fn get_timetrack_tag(&self) -> Result<TTT> {
self.get_header()
.read(DATE_TIME_TAG_HEADER_PATH)
.map_err_into(TTEK::HeaderReadError)
.chain_err(|| TTEK::HeaderReadError)
.and_then(|value| match value {
Some(&Value::String(ref s)) => Ok(s.clone().into()),
Some(_) => Err(TTEK::HeaderFieldTypeError.into_error()),
_ => Err(TTEK::HeaderReadError.into_error())
Some(_) => Err(TTE::from_kind(TTEK::HeaderFieldTypeError)),
_ => Err(TTE::from_kind(TTEK::HeaderReadError))
})
}
@ -78,21 +78,21 @@ impl TimeTracking for Entry {
self.get_header_mut()
.insert(DATE_TIME_START_HEADER_PATH, Value::String(s))
.map_err_into(TTEK::HeaderWriteError)
.chain_err(|| TTEK::HeaderWriteError)
.map(|_| ())
}
fn get_start_datetime(&self) -> Result<Option<NaiveDateTime>> {
self.get_header()
.read(DATE_TIME_START_HEADER_PATH)
.map_err_into(TTEK::HeaderReadError)
.chain_err(|| TTEK::HeaderReadError)
.and_then(header_value_to_dt)
}
fn delete_start_datetime(&mut self) -> Result<()> {
self.get_header_mut()
.delete(DATE_TIME_START_HEADER_PATH)
.map_err_into(TTEK::HeaderWriteError)
.chain_err(|| TTEK::HeaderWriteError)
.map(|_| ())
}
@ -101,21 +101,21 @@ impl TimeTracking for Entry {
self.get_header_mut()
.insert(DATE_TIME_END_HEADER_PATH, Value::String(s))
.map_err_into(TTEK::HeaderWriteError)
.chain_err(|| TTEK::HeaderWriteError)
.map(|_| ())
}
fn get_end_datetime(&self) -> Result<Option<NaiveDateTime>> {
self.get_header()
.read(DATE_TIME_END_HEADER_PATH)
.map_err_into(TTEK::HeaderReadError)
.chain_err(|| TTEK::HeaderReadError)
.and_then(header_value_to_dt)
}
fn delete_end_datetime(&mut self) -> Result<()> {
self.get_header_mut()
.delete(DATE_TIME_END_HEADER_PATH)
.map_err_into(TTEK::HeaderWriteError)
.chain_err(|| TTEK::HeaderWriteError)
.map(|_| ())
}
@ -141,11 +141,11 @@ fn header_value_to_dt(val: Option<&Value>) -> Result<Option<NaiveDateTime>> {
match val {
Some(&Value::String(ref s)) => {
NaiveDateTime::parse_from_str(s, DATE_TIME_FORMAT)
.map_err_into(TTEK::DateTimeParserError)
.chain_err(|| TTEK::DateTimeParserError)
.map(Some)
},
Some(_) => Err(TTEK::HeaderFieldTypeError.into_error()),
Some(_) => Err(TTE::from_kind(TTEK::HeaderFieldTypeError)),
None => Ok(None),
}
}

16
lib/domain/libimagtimetrack/src/timetrackingstore.rs
View file

@ -30,10 +30,10 @@ use libimagstore::store::Store;
use libimagstore::store::FileLockEntry;
use libimagentrydatetime::datepath::compiler::DatePathCompiler;
use result::Result;
use error::Result;
use constants::*;
use error::TimeTrackErrorKind as TTEK;
use error::MapErrInto;
use error::ResultExt;
use iter::get::GetTimeTrackIter;
use tag::TimeTrackingTag as TTT;
@ -71,24 +71,24 @@ impl<'a> TimeTrackStore<'a> for Store {
use std::path::PathBuf;
COMPILER.compile(CRATE_NAME, start)
.map_err_into(TTEK::StoreIdError)
.chain_err(|| TTEK::StoreIdError)
.map(|mut id| {
id.local_push(PathBuf::from(ts.as_str()));
id
})
.and_then(|id| self.create(id).map_err_into(TTEK::StoreWriteError))
.and_then(|id| self.create(id).chain_err(|| TTEK::StoreWriteError))
.and_then(|mut fle| {
let v = Value::String(ts.as_str().to_owned());
fle.get_header_mut()
.insert(DATE_TIME_TAG_HEADER_PATH, v)
.map_err_into(TTEK::HeaderWriteError)
.chain_err(|| TTEK::HeaderWriteError)
.map(|_| fle)
})
.and_then(|mut fle| {
let v = Value::String(start.format(DATE_TIME_FORMAT).to_string());
fle.get_header_mut()
.insert(DATE_TIME_START_HEADER_PATH, v)
.map_err_into(TTEK::HeaderWriteError)
.chain_err(|| TTEK::HeaderWriteError)
.map(|_| fle)
})
}
@ -99,14 +99,14 @@ impl<'a> TimeTrackStore<'a> for Store {
let v = Value::String(end.format(DATE_TIME_FORMAT).to_string());
fle.get_header_mut()
.insert(DATE_TIME_END_HEADER_PATH, v)
.map_err_into(TTEK::HeaderWriteError)
.chain_err(|| TTEK::HeaderWriteError)
.map(|_| fle)
})
}
fn get_timetrackings(&'a self) -> Result<GetTimeTrackIter<'a>> {
self.retrieve_for_module(CRATE_NAME)
.map_err_into(TTEK::StoreReadError)
.chain_err(|| TTEK::StoreReadError)
.map(|iter| GetTimeTrackIter::new(iter, self))
}

1
lib/domain/libimagtodo/Cargo.toml
View file

@ -20,6 +20,7 @@ toml = "0.4.*"
toml-query = "0.3.*"
log = "0.3"
serde_json = "0.8"
error-chain = "0.10"
libimagstore = { version = "0.4.0", path = "../../../lib/core/libimagstore" }
libimagerror = { version = "0.4.0", path = "../../../lib/core/libimagerror" }

61
lib/domain/libimagtodo/src/error.rs
View file

@ -17,20 +17,51 @@
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
generate_error_module!(
generate_error_types!(TodoError, TodoErrorKind,
ConversionError => "Conversion Error",
StoreError => "Store Error",
StoreIdError => "Store Id handling error",
ImportError => "Error importing",
UTF8Error => "Encountered non-UTF8 characters while reading input",
HeaderFieldMissing => "Header field missing",
HeaderTypeError => "Header field type error",
UuidParserError => "Uuid parser error"
);
);
error_chain! {
types {
TodoError, TodoErrorKind, ResultExt, Result;
}
pub use self::error::TodoError;
pub use self::error::TodoErrorKind;
pub use self::error::MapErrInto;
errors {
ConversionError {
description("Conversion Error")
display("Conversion Error")
}
StoreError {
description("Store Error")
display("Store Error")
}
StoreIdError {
description("Store Id handling error")
display("Store Id handling error")
}
ImportError {
description("Error importing")
display("Error importing")
}
UTF8Error {
description("Encountered non-UTF8 characters while reading input")
display("Encountered non-UTF8 characters while reading input")
}
HeaderFieldMissing {
description("Header field missing")
display("Header field missing")
}
HeaderTypeError {
description("Header field type error")
display("Header field type error")
}
UuidParserError {
description("Uuid parser error")
display("Uuid parser error")
}
}
}

6
lib/domain/libimagtodo/src/lib.rs
View file

@ -17,6 +17,8 @@
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
#![recursion_limit="256"]
#![deny(
dead_code,
non_camel_case_types,
@ -38,15 +40,15 @@ extern crate toml;
extern crate toml_query;
#[macro_use] extern crate log;
extern crate serde_json;
#[macro_use] extern crate error_chain;
#[macro_use] extern crate libimagstore;
#[macro_use] extern crate libimagerror;
extern crate libimagerror;
extern crate task_hookrs;
module_entry_path_mod!("todo");
pub mod error;
pub mod result;
pub mod task;
pub mod taskstore;

24
lib/domain/libimagtodo/src/result.rs
View file

@ -1,24 +0,0 @@
//
// imag - the personal information management suite for the commandline
// Copyright (C) 2015, 2016 Matthias Beyer <mail@beyermatthias.de> and contributors
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; version
// 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
use error::TodoError;
use std::result::Result as RResult;
pub type Result<T> = RResult<T, TodoError>;

14
lib/domain/libimagtodo/src/task.rs
View file

@ -17,12 +17,12 @@
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
use error::TodoError as TE;
use error::TodoErrorKind as TEK;
use error::MapErrInto;
use result::Result;
use error::ResultExt;
use error::Result;
use libimagstore::store::Entry;
use libimagerror::into::IntoError;
use uuid::Uuid;
use toml::Value;
@ -36,11 +36,11 @@ impl Task for Entry {
fn get_uuid(&self) -> Result<Uuid> {
match self.get_header().read("todo.uuid") {
Ok(Some(&Value::String(ref uuid))) => {
Uuid::parse_str(uuid).map_err_into(TEK::UuidParserError)
Uuid::parse_str(uuid).chain_err(|| TEK::UuidParserError)
},
Ok(Some(_)) => Err(TEK::HeaderTypeError.into_error()),
Ok(None) => Err(TEK::HeaderFieldMissing.into_error()),
Err(e) => Err(e).map_err_into(TEK::StoreError),
Ok(Some(_)) => Err(TE::from_kind(TEK::HeaderTypeError)),
Ok(None) => Err(TE::from_kind(TEK::HeaderFieldMissing)),
Err(e) => Err(e).chain_err(|| TEK::StoreError),
}
}
}

38
lib/domain/libimagtodo/src/taskstore.rs
View file

@ -31,8 +31,10 @@ use libimagstore::store::{FileLockEntry, Store};
use libimagstore::storeid::{IntoStoreId, StoreIdIterator};
use module_path::ModuleEntryPath;
use error::{TodoErrorKind as TEK, MapErrInto};
use result::Result;
use error::TodoErrorKind as TEK;
use error::TodoError as TE;
use error::Result;
use error::ResultExt;
/// Task struct containing a `FileLockEntry`
pub trait TaskStore<'a> {
@ -52,9 +54,9 @@ impl<'a> TaskStore<'a> for Store {
fn import_task_from_reader<R: BufRead>(&'a self, mut r: R) -> Result<(FileLockEntry<'a>, String, Uuid)> {
let mut line = String::new();
try!(r.read_line(&mut line).map_err_into(TEK::UTF8Error));
try!(r.read_line(&mut line).map_err(|_| TE::from_kind(TEK::UTF8Error)));
import_task(&line.as_str())
.map_err_into(TEK::ImportError)
.map_err(|_| TE::from_kind(TEK::ImportError))
.and_then(|t| {
let uuid = t.uuid().clone();
self.new_from_twtask(t).map(|t| (t, line, uuid))
@ -72,7 +74,7 @@ impl<'a> TaskStore<'a> for Store {
///
fn get_task_from_import<R: BufRead>(&'a self, mut r: R) -> Result<RResult<FileLockEntry<'a>, String>> {
let mut line = String::new();
try!(r.read_line(&mut line).map_err_into(TEK::UTF8Error));
try!(r.read_line(&mut line).chain_err(|| TEK::UTF8Error));
self.get_task_from_string(line)
}
@ -82,7 +84,7 @@ impl<'a> TaskStore<'a> for Store {
/// For an explanation on the return values see `Task::get_from_import()`.
fn get_task_from_string(&'a self, s: String) -> Result<RResult<FileLockEntry<'a>, String>> {
import_task(s.as_str())
.map_err_into(TEK::ImportError)
.map_err(|_| TE::from_kind(TEK::ImportError))
.map(|t| t.uuid().clone())
.and_then(|uuid| self.get_task_from_uuid(uuid))
.and_then(|o| match o {
@ -98,14 +100,14 @@ impl<'a> TaskStore<'a> for Store {
ModuleEntryPath::new(format!("taskwarrior/{}", uuid))
.into_storeid()
.and_then(|store_id| self.get(store_id))
.map_err_into(TEK::StoreError)
.chain_err(|| TEK::StoreError)
}
/// Same as Task::get_from_import() but uses Store::retrieve() rather than Store::get(), to
/// implicitely create the task if it does not exist.
fn retrieve_task_from_import<R: BufRead>(&'a self, mut r: R) -> Result<FileLockEntry<'a>> {
let mut line = String::new();
try!(r.read_line(&mut line).map_err_into(TEK::UTF8Error));
try!(r.read_line(&mut line).chain_err(|| TEK::UTF8Error));
self.retrieve_task_from_string(line)
}
@ -116,7 +118,7 @@ impl<'a> TaskStore<'a> for Store {
.and_then(|opt| match opt {
Ok(task) => Ok(task),
Err(string) => import_task(string.as_str())
.map_err_into(TEK::ImportError)
.map_err(|_| TE::from_kind(TEK::ImportError))
.and_then(|t| self.new_from_twtask(t)),
})
}
@ -133,7 +135,7 @@ impl<'a> TaskStore<'a> for Store {
// task before the change, and the second one after
// the change. The (maybe modified) second one is
// expected by taskwarrior.
match serde_to_string(&ttask).map_err_into(TEK::ImportError) {
match serde_to_string(&ttask).chain_err(|| TEK::ImportError) {
// use println!() here, as we talk with TW
Ok(val) => println!("{}", val),
Err(e) => return Err(e),
@ -152,7 +154,7 @@ impl<'a> TaskStore<'a> for Store {
}
} // end if c % 2
},
Err(e) => return Err(e).map_err_into(TEK::ImportError),
Err(e) => return Err(TE::from_kind(TEK::ImportError)),
}
}
Ok(())
@ -162,12 +164,12 @@ impl<'a> TaskStore<'a> for Store {
ModuleEntryPath::new(format!("taskwarrior/{}", uuid))
.into_storeid()
.and_then(|id| self.delete(id))
.map_err_into(TEK::StoreError)
.chain_err(|| TEK::StoreError)
}
fn all_tasks(&self) -> Result<StoreIdIterator> {
self.retrieve_for_module("todo/taskwarrior")
.map_err_into(TEK::StoreError)
.chain_err(|| TEK::StoreError)
}
fn new_from_twtask(&'a self, task: TTask) -> Result<FileLockEntry<'a>> {
@ -177,21 +179,21 @@ impl<'a> TaskStore<'a> for Store {
let uuid = task.uuid();
ModuleEntryPath::new(format!("taskwarrior/{}", uuid))
.into_storeid()
.map_err_into(TEK::StoreIdError)
.chain_err(|| TEK::StoreIdError)
.and_then(|id| {
self.retrieve(id)
.map_err_into(TEK::StoreError)
.chain_err(|| TEK::StoreError)
.and_then(|mut fle| {
{
let hdr = fle.get_header_mut();
if try!(hdr.read("todo").map_err_into(TEK::StoreError)).is_none() {
if try!(hdr.read("todo").chain_err(|| TEK::StoreError)).is_none() {
try!(hdr
.set("todo", Value::Table(BTreeMap::new()))
.map_err_into(TEK::StoreError));
.chain_err(|| TEK::StoreError));
}
try!(hdr.set("todo.uuid", Value::String(format!("{}",uuid)))
.map_err_into(TEK::StoreError));
.chain_err(|| TEK::StoreError));
}
// If none of the errors above have returned the function, everything is fine

1
lib/entry/libimagentryannotation/Cargo.toml
View file

@ -13,6 +13,7 @@ license = "LGPL-2.1"
lazy_static = "0.1.15"
toml = "^0.4"
toml-query = "0.3.0"
error-chain = "0.10"
libimagstore = { version = "0.4.0", path = "../../../lib/core/libimagstore" }
libimagerror = { version = "0.4.0", path = "../../../lib/core/libimagerror" }

16
lib/entry/libimagentryannotation/src/annotateable.rs
View file

@ -25,14 +25,14 @@ use libimagstore::store::Entry;
use libimagstore::store::FileLockEntry;
use libimagstore::store::Store;
use libimagentrylink::internal::InternalLinker;
use libimagerror::into::IntoError;
use toml_query::read::TomlValueReadExt;
use toml_query::insert::TomlValueInsertExt;
use result::Result;
use error::Result;
use error::AnnotationErrorKind as AEK;
use error::MapErrInto;
use error::AnnotationError as AE;
use error::ResultExt;
pub trait Annotateable {
@ -51,16 +51,16 @@ impl Annotateable for Entry {
fn annotate<'a>(&mut self, store: &'a Store, ann_name: &str) -> Result<FileLockEntry<'a>> {
store.retrieve(PathBuf::from(ann_name))
.map_err_into(AEK::StoreWriteError)
.chain_err(|| AEK::StoreWriteError)
.and_then(|mut anno| {
anno.get_header_mut()
.insert("annotation.is_annotation", Value::Boolean(true))
.map_err_into(AEK::HeaderWriteError)
.chain_err(|| AEK::HeaderWriteError)
.map(|_| anno)
})
.and_then(|mut anno| {
anno.add_internal_link(self)
.map_err_into(AEK::LinkingError)
.chain_err(|| AEK::LinkingError)
.map(|_| anno)
})
}
@ -68,11 +68,11 @@ impl Annotateable for Entry {
fn is_annotation(&self) -> Result<bool> {
self.get_header()
.read("annotation.is_annotation")
.map_err_into(AEK::StoreReadError)
.chain_err(|| AEK::StoreReadError)
.and_then(|res| match res {
Some(&Value::Boolean(b)) => Ok(b),
None => Ok(false),
_ => Err(AEK::HeaderTypeError.into_error()),
_ => Err(AE::from_kind(AEK::HeaderTypeError)),
})
}

20
lib/entry/libimagentryannotation/src/annotation_fetcher.rs
View file

@ -24,9 +24,9 @@ use libimagnotes::note::Note;
use libimagnotes::note::NoteIterator;
use libimagstore::storeid::StoreIdIterator;
use result::Result;
use error::Result;
use error::AnnotationErrorKind as AEK;
use error::MapErrInto;
use error::ResultExt;
use self::iter::*;
@ -45,7 +45,7 @@ impl<'a> AnnotationFetcher<'a> for Store {
fn all_annotations(&'a self) -> Result<AnnotationIter<'a>> {
Note::all_notes(self)
.map(|iter| AnnotationIter::new(iter))
.map_err_into(AEK::StoreReadError)
.chain_err(|| AEK::StoreReadError)
}
/// Get all annotations (in an iterator) for an entry
@ -57,7 +57,7 @@ impl<'a> AnnotationFetcher<'a> for Store {
/// entry, but should normally be not that heavy.
fn annotations_for_entry(&'a self, entry: &Entry) -> Result<AnnotationIter<'a>> {
entry.get_internal_links()
.map_err_into(AEK::StoreReadError)
.chain_err(|| AEK::StoreReadError)
.map(|iter| StoreIdIterator::new(Box::new(iter.map(|e| e.get_store_id().clone()))))
.map(|iter| NoteIterator::new(self, iter))
.map(|iter| AnnotationIter::new(iter))
@ -70,13 +70,13 @@ pub mod iter {
use toml_query::read::TomlValueReadExt;
use libimagerror::into::IntoError;
use libimagnotes::note::Note;
use libimagnotes::note::NoteIterator;
use result::Result;
use error::Result;
use error::AnnotationErrorKind as AEK;
use error::MapErrInto;
use error::AnnotationError as AE;
use error::ResultExt;
#[derive(Debug)]
pub struct AnnotationIter<'a>(NoteIterator<'a>);
@ -99,11 +99,11 @@ pub mod iter {
match note.get_header().read("annotation.is_annotation") {
Ok(None) => continue, // not an annotation
Ok(Some(&Value::Boolean(true))) => return Some(Ok(note)),
Ok(Some(_)) => return Some(Err(AEK::HeaderTypeError.into_error())),
Err(e) => return Some(Err(e).map_err_into(AEK::HeaderReadError)),
Ok(Some(_)) => return Some(Err(AE::from_kind(AEK::HeaderTypeError))),
Err(e) => return Some(Err(e).chain_err(|| AEK::HeaderReadError)),
}
},
Some(Err(e)) => return Some(Err(e).map_err_into(AEK::StoreReadError)),
Some(Err(e)) => return Some(Err(e).chain_err(|| AEK::StoreReadError)),
None => return None, // iterator consumed
}
}

49
lib/entry/libimagentryannotation/src/error.rs
View file

@ -17,19 +17,42 @@
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
generate_error_module!(
generate_error_types!(AnnotationError, AnnotationErrorKind,
StoreReadError => "Store read error",
StoreWriteError => "Store write error",
error_chain! {
types {
AnnotationError, AnnotationErrorKind, ResultExt, Result;
}
LinkingError => "Error while linking",
HeaderWriteError => "Couldn't write Header for annotation",
HeaderReadError => "Couldn't read Header of Entry",
HeaderTypeError => "Header field has unexpected type"
);
);
errors {
StoreReadError {
description("Store read error")
display("Store read error")
}
pub use self::error::AnnotationError;
pub use self::error::AnnotationErrorKind;
pub use self::error::MapErrInto;
StoreWriteError {
description("Store write error")
display("Store write error")
}
LinkingError {
description("Error while linking")
display("Error while linking")
}
HeaderWriteError {
description("Couldn't write Header for annotation")
display("Couldn't write Header for annotation")
}
HeaderReadError {
description("Couldn't read Header of Entry")
display("Couldn't read Header of Entry")
}
HeaderTypeError {
description("Header field has unexpected type")
display("Header field has unexpected type")
}
}
}

6
lib/entry/libimagentryannotation/src/lib.rs
View file

@ -17,6 +17,8 @@
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
#![recursion_limit="256"]
#![deny(
dead_code,
non_camel_case_types,
@ -35,8 +37,9 @@
extern crate toml;
extern crate toml_query;
#[macro_use] extern crate error_chain;
#[macro_use] extern crate libimagerror;
extern crate libimagerror;
extern crate libimagstore;
extern crate libimagentrylink;
extern crate libimagnotes;
@ -44,5 +47,4 @@ extern crate libimagnotes;
pub mod annotateable;
pub mod annotation_fetcher;
pub mod error;
pub mod result;

26
lib/entry/libimagentryannotation/src/result.rs
View file

@ -1,26 +0,0 @@
//
// imag - the personal information management suite for the commandline
// Copyright (C) 2015, 2016 Matthias Beyer <mail@beyermatthias.de> and contributors
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; version
// 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
use std::result::Result as RResult;
use error::AnnotationError;
pub type Result<T> = RResult<T, AnnotationError>;

1
lib/entry/libimagentrycategory/Cargo.toml
View file

@ -18,6 +18,7 @@ log = "0.3"
toml = "0.4"
toml-query = "0.3"
is-match = "0.1"
error-chain = "0.10"
libimagerror = { version = "0.4.0", path = "../../../lib/core/libimagerror" }
libimagstore = { version = "0.4.0", path = "../../../lib/core/libimagstore" }

18
lib/entry/libimagentrycategory/src/category.rs
View file

@ -23,11 +23,11 @@ use toml_query::error::ErrorKind as TQEK;
use toml::Value;
use libimagstore::store::Entry;
use libimagerror::into::IntoError;
use error::CategoryErrorKind as CEK;
use error::MapErrInto;
use result::Result;
use error::CategoryError as CE;
use error::ResultExt;
use error::Result;
use register::CategoryRegister;
#[derive(Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
@ -64,7 +64,7 @@ impl EntryCategory for Entry {
fn set_category(&mut self, s: Category) -> Result<()> {
self.get_header_mut()
.insert(&String::from("category.value"), Value::String(s.into()))
.map_err_into(CEK::HeaderWriteError)
.chain_err(|| CEK::HeaderWriteError)
.map(|_| ())
}
@ -76,7 +76,7 @@ impl EntryCategory for Entry {
.and_then(|bl| if bl {
self.set_category(s)
} else {
Err(CEK::CategoryDoesNotExist.into_error())
Err(CE::from_kind(CEK::CategoryDoesNotExist))
})
}
@ -86,17 +86,17 @@ impl EntryCategory for Entry {
&TQEK::IdentifierNotFoundInDocument(_) => Ok(None),
_ => Err(res),
}
.map_err_into(CEK::HeaderReadError),
.chain_err(|| CEK::HeaderReadError),
Ok(Some(&Value::String(ref s))) => Ok(Some(s.clone().into())),
Ok(None) => Err(CEK::StoreReadError.into_error()).map_err_into(CEK::HeaderReadError),
Ok(_) => Err(CEK::TypeError.into_error()).map_err_into(CEK::HeaderReadError),
Ok(None) => Err(CE::from_kind(CEK::StoreReadError)).chain_err(|| CEK::HeaderReadError),
Ok(_) => Err(CE::from_kind(CEK::TypeError)).chain_err(|| CEK::HeaderReadError),
}
}
fn has_category(&self) -> Result<bool> {
self.get_header().read(&String::from("category.value"))
.map_err_into(CEK::HeaderReadError)
.chain_err(|| CEK::HeaderReadError)
.map(|e| e.is_some())
}

54
lib/entry/libimagentrycategory/src/error.rs
View file

@ -17,20 +17,46 @@
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
generate_error_module!(
generate_error_types!(CategoryError, CategoryErrorKind,
StoreReadError => "Store Read error",
StoreWriteError => "Store Write error",
StoreIdHandlingError => "StoreId handling error",
HeaderReadError => "Header read error",
HeaderWriteError => "Header write error",
TypeError => "Found wrong type in header",
error_chain! {
types {
CategoryError, CategoryErrorKind, ResultExt, Result;
}
CategoryDoesNotExist => "Category does not exist"
);
);
errors {
StoreReadError {
description("Store Read error")
display("Store Read error")
}
pub use self::error::CategoryError;
pub use self::error::CategoryErrorKind;
pub use self::error::MapErrInto;
StoreWriteError {
description("Store Write error")
display("Store Write error")
}
StoreIdHandlingError {
description("StoreId handling error")
display("StoreId handling error")
}
HeaderReadError {
description("Header read error")
display("Header read error")
}
HeaderWriteError {
description("Header write error")
display("Header write error")
}
CategoryDoesNotExist {
description("Category does not exist")
display("Category does not exist")
}
TypeError {
description("Type Error")
display("Type Error")
}
}
}

5
lib/entry/libimagentrycategory/src/lib.rs
View file

@ -17,6 +17,8 @@
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
#![recursion_limit="256"]
#![deny(
dead_code,
non_camel_case_types,
@ -39,8 +41,8 @@ extern crate toml;
extern crate is_match;
#[macro_use]
extern crate log;
#[macro_use] extern crate error_chain;
#[macro_use]
extern crate libimagerror;
#[macro_use]
extern crate libimagstore;
@ -48,7 +50,6 @@ extern crate libimagstore;
pub mod category;
pub mod error;
pub mod register;
pub mod result;
module_entry_path_mod!("category");

40
lib/entry/libimagentrycategory/src/register.rs
View file

@ -27,12 +27,12 @@ use libimagstore::store::Store;
use libimagstore::store::FileLockEntry;
use libimagstore::storeid::StoreId;
use libimagstore::storeid::StoreIdIterator;
use libimagerror::into::IntoError;
use category::Category;
use error::CategoryErrorKind as CEK;
use error::MapErrInto;
use result::Result;
use error::CategoryError as CE;
use error::ResultExt;
use error::Result;
pub const CATEGORY_REGISTER_NAME_FIELD_PATH : &'static str = "category.register.name";
@ -81,13 +81,13 @@ impl CategoryRegister for Store {
warn!("Setting category header replaced existing value: {:?}", opt);
})
.map(|_| true)
.map_err_into(CEK::HeaderWriteError)
.map_err_into(CEK::StoreWriteError)
.chain_err(|| CEK::HeaderWriteError)
.chain_err(|| CEK::StoreWriteError)
}
Err(store_error) => if is_match!(store_error.err_type(), SEK::EntryAlreadyExists) {
Err(store_error) => if is_match!(store_error.kind(), &SEK::EntryAlreadyExists) {
Ok(false)
} else {
Err(store_error).map_err_into(CEK::StoreWriteError)
Err(store_error).chain_err(|| CEK::StoreWriteError)
}
}
}
@ -96,13 +96,13 @@ impl CategoryRegister for Store {
fn delete_category(&self, name: &str) -> Result<()> {
let sid = try!(mk_category_storeid(self.path().clone(), name));
self.delete(sid).map_err_into(CEK::StoreWriteError)
self.delete(sid).chain_err(|| CEK::StoreWriteError)
}
/// Get all category names
fn all_category_names(&self) -> Result<CategoryNameIter> {
self.retrieve_for_module("category")
.map_err_into(CEK::StoreReadError)
.chain_err(|| CEK::StoreReadError)
.map(|iter| CategoryNameIter::new(self, iter))
}
@ -114,7 +114,7 @@ impl CategoryRegister for Store {
let sid = try!(mk_category_storeid(self.path().clone(), name));
self.get(sid)
.map_err_into(CEK::StoreWriteError)
.chain_err(|| CEK::StoreWriteError)
}
}
@ -212,26 +212,26 @@ fn mk_category_storeid(base: PathBuf, s: &str) -> Result<StoreId> {
::module_path::ModuleEntryPath::new(s)
.into_storeid()
.map(|id| id.with_base(base))
.map_err_into(CEK::StoreIdHandlingError)
.chain_err(|| CEK::StoreIdHandlingError)
}
#[inline]
fn represents_category(store: &Store, sid: StoreId, name: &str) -> Result<bool> {
sid.exists()
.map_err_into(CEK::StoreIdHandlingError)
.chain_err(|| CEK::StoreIdHandlingError)
.and_then(|bl| {
if bl {
store.get(sid)
.map_err_into(CEK::StoreReadError)
.chain_err(|| CEK::StoreReadError)
.and_then(|fle| {
if let Some(fle) = fle {
match fle.get_header()
.read(&String::from(CATEGORY_REGISTER_NAME_FIELD_PATH))
.map_err_into(CEK::HeaderReadError)
.chain_err(|| CEK::HeaderReadError)
{
Ok(Some(&Value::String(ref s))) => Ok(s == name),
Ok(_) => Err(CEK::TypeError.into_error()),
Err(e) => Err(e).map_err_into(CEK::HeaderReadError),
Ok(_) => Err(CE::from_kind(CEK::TypeError)),
Err(e) => Err(e).chain_err(|| CEK::HeaderReadError),
}
} else {
Ok(false)
@ -277,12 +277,12 @@ impl<'a> Iterator for CategoryNameIter<'a> {
.map(|sid| {
self.0
.get(sid)
.map_err_into(CEK::StoreReadError)
.and_then(|fle| fle.ok_or(CEK::StoreReadError.into_error()))
.chain_err(|| CEK::StoreReadError)
.and_then(|fle| fle.ok_or(CE::from_kind(CEK::StoreReadError)))
.and_then(|fle| match fle.get_header().read(&query) {
Ok(Some(&Value::String(ref s))) => Ok(Category::from(s.clone())),
Ok(_) => Err(CEK::TypeError.into_error()),
Err(e) => Err(e).map_err_into(CEK::HeaderReadError),
Ok(_) => Err(CE::from_kind(CEK::TypeError)),
Err(e) => Err(e).chain_err(|| CEK::HeaderReadError),
})
})
}

26
lib/entry/libimagentrycategory/src/result.rs
View file

@ -1,26 +0,0 @@
//
// imag - the personal information management suite for the commandline
// Copyright (C) 2015, 2016 Matthias Beyer <mail@beyermatthias.de> and contributors
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; version
// 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
use std::result::Result as RResult;
use error::CategoryError;
pub type Result<T> = RResult<T, CategoryError>;

1
lib/entry/libimagentrydatetime/Cargo.toml
View file

@ -18,6 +18,7 @@ chrono = "0.4"
toml-query = "0.3"
lazy_static = "0.2"
toml = "0.4"
error-chain = "0.10"
libimagerror = { version = "0.4.0", path = "../../../lib/core/libimagerror" }
libimagstore = { version = "0.4.0", path = "../../../lib/core/libimagstore" }

6
lib/entry/libimagentrydatetime/src/datepath/compiler.rs
View file

@ -27,9 +27,9 @@ use libimagstore::storeid::StoreId;
use datepath::accuracy::Accuracy;
use datepath::format::Format;
use datepath::result::Result;
use datepath::error::Result;
use datepath::error::DatePathCompilerErrorKind as DPCEK;
use datepath::error::MapErrInto;
use datepath::error::ResultExt;
pub struct DatePathCompiler {
accuracy : Accuracy,
@ -122,7 +122,7 @@ impl DatePathCompiler {
}
StoreId::new_baseless(PathBuf::from(s))
.map_err_into(DPCEK::StoreIdBuildFailed)
.chain_err(|| DPCEK::StoreIdBuildFailed)
}
}

28
lib/entry/libimagentrydatetime/src/datepath/error.rs
View file

@ -17,14 +17,22 @@
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
/// Error module for the DatePathCompiler type
generate_error_module! {
generate_error_types!(DatePathCompilerError, DatePathCompilerErrorKind,
UnknownDatePathCompilerError => "Unknown DatePathCompiler error",
StoreIdBuildFailed => "Failed building StoreId object"
);
}
pub use self::error::DatePathCompilerError;
pub use self::error::DatePathCompilerErrorKind;
pub use self::error::MapErrInto;
error_chain! {
types {
DatePathCompilerError, DatePathCompilerErrorKind, ResultExt, Result;
}
errors {
UnknownDatePathCompilerError {
description("Unknown DatePathCompiler error")
display("Unknown DatePathCompiler error")
}
StoreIdBuildFailed {
description("Failed building StoreId object")
display("Failed building StoreId object")
}
}
}

1
lib/entry/libimagentrydatetime/src/datepath/mod.rs
View file

@ -21,6 +21,5 @@ pub mod accuracy;
pub mod compiler;
pub mod error;
pub mod format;
pub mod result;
pub mod to_store_id;

25
lib/entry/libimagentrydatetime/src/datepath/result.rs
View file

@ -1,25 +0,0 @@
//
// imag - the personal information management suite for the commandline
// Copyright (C) 2015, 2016 Matthias Beyer <mail@beyermatthias.de> and contributors
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; version
// 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
/// Result type for this module.
use super::error::DatePathCompilerError as DPCE;
use std::result::Result as RResult;
pub type Result<T> = RResult<T, DPCE>;

2
lib/entry/libimagentrydatetime/src/datepath/to_store_id.rs
View file

@ -20,7 +20,7 @@
use chrono::naive::NaiveDateTime;
use libimagstore::storeid::StoreId;
use datepath::result::Result;
use datepath::error::Result;
use datepath::compiler::DatePathCompiler;
//

55
lib/entry/libimagentrydatetime/src/datetime.rs
View file

@ -24,11 +24,10 @@ use toml_query::read::TomlValueReadExt;
use toml::Value;
use libimagstore::store::Entry;
use libimagerror::into::IntoError;
use error::DateErrorKind as DEK;
use error::DateError as DE;
use error::*;
use result::Result;
use range::DateTimeRange;
pub trait EntryDate {
@ -56,19 +55,19 @@ impl EntryDate for Entry {
self.get_header_mut()
.delete(&DATE_HEADER_LOCATION)
.map(|_| ())
.map_err_into(DEK::DeleteDateError)
.chain_err(|| DEK::DeleteDateError)
}
fn read_date(&self) -> Result<NaiveDateTime> {
self.get_header()
.read(&DATE_HEADER_LOCATION)
.map_err_into(DEK::ReadDateError)
.chain_err(|| DEK::ReadDateError)
.and_then(|v| {
match v {
Some(&Value::String(ref s)) => s.parse::<NaiveDateTime>()
.map_err_into(DEK::DateTimeParsingError),
Some(_) => Err(DEK::DateHeaderFieldTypeError.into_error()),
_ => Err(DEK::ReadDateError.into_error()),
.chain_err(|| DEK::DateTimeParsingError),
Some(_) => Err(DE::from_kind(DEK::DateHeaderFieldTypeError)),
_ => Err(DE::from_kind(DEK::ReadDateError)),
}
})
}
@ -97,11 +96,11 @@ impl EntryDate for Entry {
.map(|opt| opt.map(|stri| {
match stri {
Value::String(ref s) => s.parse::<NaiveDateTime>()
.map_err_into(DEK::DateTimeParsingError),
_ => Err(DEK::DateHeaderFieldTypeError.into_error()),
.chain_err(|| DEK::DateTimeParsingError),
_ => Err(DE::from_kind(DEK::DateHeaderFieldTypeError)),
}
}))
.map_err_into(DEK::SetDateError)
.chain_err(|| DEK::SetDateError)
}
@ -117,43 +116,43 @@ impl EntryDate for Entry {
.get_header_mut()
.delete(&DATE_RANGE_START_HEADER_LOCATION)
.map(|_| ())
.map_err_into(DEK::DeleteDateTimeRangeError));
.chain_err(|| DEK::DeleteDateTimeRangeError));
self.get_header_mut()
.delete(&DATE_RANGE_END_HEADER_LOCATION)
.map(|_| ())
.map_err_into(DEK::DeleteDateTimeRangeError)
.chain_err(|| DEK::DeleteDateTimeRangeError)
}
fn read_date_range(&self) -> Result<DateTimeRange> {
let start = try!(self
.get_header()
.read(&DATE_RANGE_START_HEADER_LOCATION)
.map_err_into(DEK::ReadDateTimeRangeError)
.chain_err(|| DEK::ReadDateTimeRangeError)
.and_then(|v| {
match v {
Some(&Value::String(ref s)) => s.parse::<NaiveDateTime>()
.map_err_into(DEK::DateTimeParsingError),
Some(_) => Err(DEK::DateHeaderFieldTypeError.into_error()),
_ => Err(DEK::ReadDateError.into_error()),
.chain_err(|| DEK::DateTimeParsingError),
Some(_) => Err(DE::from_kind(DEK::DateHeaderFieldTypeError)),
_ => Err(DE::from_kind(DEK::ReadDateError)),
}
}));
let end = try!(self
.get_header()
.read(&DATE_RANGE_START_HEADER_LOCATION)
.map_err_into(DEK::ReadDateTimeRangeError)
.chain_err(|| DEK::ReadDateTimeRangeError)
.and_then(|v| {
match v {
Some(&Value::String(ref s)) => s.parse::<NaiveDateTime>()
.map_err_into(DEK::DateTimeParsingError),
Some(_) => Err(DEK::DateHeaderFieldTypeError.into_error()),
_ => Err(DEK::ReadDateError.into_error()),
.chain_err(|| DEK::DateTimeParsingError),
Some(_) => Err(DE::from_kind(DEK::DateHeaderFieldTypeError)),
_ => Err(DE::from_kind(DEK::ReadDateError)),
}
}));
DateTimeRange::new(start, end)
.map_err_into(DEK::DateTimeRangeError)
.chain_err(|| DEK::DateTimeRangeError)
}
/// Set the date range
@ -175,11 +174,11 @@ impl EntryDate for Entry {
.map(|opt| opt.map(|stri| {
match stri {
Value::String(ref s) => s.parse::<NaiveDateTime>()
.map_err_into(DEK::DateTimeParsingError),
_ => Err(DEK::DateHeaderFieldTypeError.into_error()),
.chain_err(|| DEK::DateTimeParsingError),
_ => Err(DE::from_kind(DEK::DateHeaderFieldTypeError)),
}
}))
.map_err_into(DEK::SetDateTimeRangeError));
.chain_err(|| DEK::SetDateTimeRangeError));
let opt_old_end = try!(self
.get_header_mut()
@ -187,16 +186,16 @@ impl EntryDate for Entry {
.map(|opt| opt.map(|stri| {
match stri {
Value::String(ref s) => s.parse::<NaiveDateTime>()
.map_err_into(DEK::DateTimeParsingError),
_ => Err(DEK::DateHeaderFieldTypeError.into_error()),
.chain_err(|| DEK::DateTimeParsingError),
_ => Err(DE::from_kind(DEK::DateHeaderFieldTypeError)),
}
}))
.map_err_into(DEK::SetDateTimeRangeError));
.chain_err(|| DEK::SetDateTimeRangeError));
match (opt_old_start, opt_old_end) {
(Some(Ok(old_start)), Some(Ok(old_end))) => {
let dr = DateTimeRange::new(old_start, old_end)
.map_err_into(DEK::DateTimeRangeError);
.chain_err(|| DEK::DateTimeRangeError);
Ok(Some(dr))
},

Some files were not shown because too many files have changed in this diff Show more