nunc 0.2.0

WIP: time tracking application
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

use std::fmt;
use std::io::{
	Error as IoError,
	ErrorKind
};
use std::result::Result as StdResult;

use conciliator::{
	Inline,
	Buffer
};
use conciliator::edit::EditError;

use rusqlite::Error as SqlError;
use toml::de::Error as DeserializeError;
use toml::ser::Error as SerializeError;


pub type Result<T> = StdResult<T, Error>;

#[derive(Debug)]
pub enum Error {
	Sql(SqlError),
	Io(IoError),
	Toml(TomlError),

	NoConfig,
	Message(String),
}

#[derive(Debug)]
pub enum TomlError {
	Serialize(SerializeError),
	Deserialize(DeserializeError),
}

impl Error {
	pub fn not_found(err: &str) -> Self {
		Self::Io(
			IoError::new(ErrorKind::NotFound, err)
		)
	}
}

impl std::error::Error for Error {}

impl Inline for Error {
	fn inline(&self, buffer: &mut Buffer) {
		match self {
			Self::Sql(e) => buffer.push(e),
			Self::Io(e) => buffer.push(e),
			Self::Toml(e) => buffer.push(e),
			Self::NoConfig => buffer.push("No config file found!"),
			Self::Message(m) => buffer.push(m),
		};
	}
}

impl fmt::Display for Error {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
		fmt::Debug::fmt(self, f)
	}
}

impl From<IoError> for Error {
	fn from(err: IoError) -> Self {Self::Io(err)}
}
impl From<SqlError> for Error {
	fn from(err: SqlError) -> Self {Self::Sql(err)}
}
impl From<TomlError> for Error {
	fn from(err: TomlError) -> Self {Self::Toml(err)}
}
impl From<SerializeError> for Error {
	fn from(err: SerializeError) -> Self {Self::Toml(err.into())}
}
impl From<DeserializeError> for Error {
	fn from(err: DeserializeError) -> Self {Self::Toml(err.into())}
}
impl From<EditError<SerializeError>> for Error {
	fn from(err: EditError<SerializeError>) -> Self {
		match err {
			EditError::Serialize(e) => e.into(),
			EditError::Io(e) => e.into()
		}
	}
}

impl From<SerializeError> for TomlError {
	fn from(err: SerializeError) -> Self {Self::Serialize(err)}
}
impl From<DeserializeError> for TomlError {
	fn from(err: DeserializeError) -> Self {Self::Deserialize(err)}
}

impl fmt::Display for TomlError {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
		match self {
			Self::Serialize(e) => e.fmt(f),
			Self::Deserialize(e) => e.fmt(f)
		}
	}
}