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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

use std::result::Result as StdResult;

use clap::{
	ArgAction,
	Subcommand,
	ValueEnum
};

use conciliator::{
	Buffer,
	Claw,
	Conciliator,
	List
};

use greg::Point;
use greg::real::Scale;

use crate::{
	Nunc,
	Result
};
use crate::core::{
	Log,
	Tree,
	Measure,
	Zone
};
use crate::data::entry::{
	Entry,
	List as EntryList
};

#[derive(Subcommand)]
pub(crate) enum Cmd {
	/// Show entries for a given timespan
	Recap {
		#[clap(short = 'l', long = "last", action = ArgAction::Count)]
		offset: u8,
		#[clap(value_enum, default_value_t)]
		timespan: RecapTimespan
	},
	/// Show running activities and status of streaks
	Now,
}

#[derive(Clone, Default, ValueEnum)]
pub(crate) enum RecapTimespan {
	#[default]
	Day,
	Week,
	Month,
	All
}

fn cmd_now(con: &Claw, nunc: &Nunc) -> Result<()> {
	let states = nunc
		.show()?
		.drain(..)
		.map(|s| s.make_inline(nunc))
		.collect::<StdResult<Vec<_>, _>>()?;

	con.print(List::new("Streaks", states.iter()));

	let fmt_active = |buf: &mut Buffer, ent: &Entry| {
		let activity = nunc.get_activity(ent.activity_id).unwrap();
		let (pre, span) = match Point::now() > ent.start {
			true => ("for", Point::now() - ent.start),
			false => ("in", ent.start - Point::now())
		};
		buf.push(activity).push(format_args!(": {pre} {span:#}"));
	};
	List::new("currently running", nunc.get_active_entries()?.iter())
		.with_formatter(fmt_active)
		.print_to(con);

	Ok(())
}

impl Cmd {
	pub fn run(self, con: &Claw, nunc: &Nunc) -> Result<()> {
		match self {
			Self::Now => cmd_now(con, nunc),
			Self::Recap{offset, timespan} =>
				cmd_recap(con, nunc, offset, timespan),
		}
	}
}

pub(crate) fn cmd_recap(
	con: &Claw,
	nunc: &Nunc,
	offset: u8,
	timespan: RecapTimespan)
	-> Result<()>
{
	let cal = nunc.load_calendar()?;

	let scale = match timespan {
		RecapTimespan::Day => Scale::Days,
		RecapTimespan::Week => Scale::Weeks,
		RecapTimespan::Month => Scale::Months,
		RecapTimespan::All => todo!(),
	};
	let mut frames = cal.frames(scale, Point::now());
	let frame = match offset {
		0 => frames.next().unwrap(),
		n => frames
			.rev()
			.nth(n as usize - 1)
			.unwrap()
	};

	let entries = nunc.recap(frame)?;

	con.print(EntryList::new(nunc, entries.iter())?);

	Ok(())
}