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

use conciliator::{
	Buffer,
	Inline,
	Paint
};
use rusqlite::{
	Row,
	Error as SqlError
};

use super::Category;

pub enum ActOrCat {
	Activity(Activity),
	Category(Category)
}

#[derive(Debug, Eq, PartialEq)]
pub struct Activity {
	pub id: u64,
	pub category_id: u64,
	pub name: String
}

#[derive(Debug, Eq, PartialEq)]
pub struct Resolved {
	pub id: u64,
	pub category_id: u64,
	pub path: String,
	pub name: String
}


/*
 *	ACTIVITY
 */

impl Activity {
	pub fn resolve(self, path: String) -> Resolved {
		let Self {id, category_id, name} = self;
		Resolved {id, category_id, path, name}
	}
}

impl<'r> TryFrom<&Row<'r>> for Activity {
	type Error = SqlError;

	fn try_from(value: &Row<'r>) -> Result<Self, Self::Error> {
		value.try_into()
			.map(|(id, name, category_id)| Self {id, name, category_id})
	}
}

impl Inline for Activity {
	fn inline(&self, buf: &mut Buffer) {
		buf.push_beta(&self.name);
	}
}

/*
 *	ACT OR CAT
 */

impl Inline for ActOrCat {
	fn inline(&self, buffer: &mut Buffer) {
		match self {
			Self::Activity(act) => act.inline(buffer),
			Self::Category(cat) => cat.inline(buffer)
		}
	}
}
impl ActOrCat {
	pub(crate) fn len(&self) -> usize {
		match self {
			Self::Activity(act) => act.name.len(),
			Self::Category(cat) => cat.name.len()
		}
	}
}

/*
 *	RESOLVED
 */

impl Resolved {
	pub fn revert(self) -> Activity {
		let Self {id, category_id, name, ..} = self;
		Activity {id, category_id, name}
	}
}

impl Inline for Resolved {
	fn inline(&self, buffer: &mut Buffer) {
		buffer.push_plain(&self.path).push_beta(&self.name);
	}
}