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
|
use fmt;
use dirs;
use bufio;
use memio;
use os;
use fs;
use path;
use io;
use strings;
use format::ini;
use strconv;
use encoding::utf8;
type task = struct {
name: str,
context: (str | void),
tags: ([]str | void),
priority: uint,
};
def METADATASEP: str = "----";
type rtaskerror = !(fs::error | ini::error | strconv::error | io::error |
utf8::invalid);
fn listtasks(root: str = "tasks", context: str = "*") ([]task | rtaskerror |
path::error) = {
const dirents = os::readdir(root)?;
defer fs::dirents_free(dirents);
let tasks: []task = [];
for (const dirent .. dirents) {
if (context == "*" || dirent.name == context) {
if (fs::isdir(dirent.ftype)) {
let buf = path::init()?;
const p = path::push(&buf, root, dirent.name)?;
listtasks(p)?;
} else {
fmt::println(dirent.name)!;
let buf = path::init()?;
const p = path::push(&buf, root, dirent.name)?;
let t = readtask(p)?;
defer freetask(&t);
fmt::println(t.name)!;
};
};
};
return tasks;
};
fn readtask(taskpath: str) (task | rtaskerror) = {
const f = os::open(taskpath)?;
defer io::close(f)!;
const sc = bufio::newscanner(f);
defer bufio::finish(&sc);
const meta = memio::dynamic();
defer io::close(&meta)!;
for (let line => bufio::scan_line(&sc)?) {
line = strings::trim(line);
if (line == METADATASEP) {
break;
};
memio::concat(&meta, line, "\n")?;
//append(inilines, strings::dup(line));
};
// seek to start of memio buffer
io::seek(&meta, 0, io::whence::SET)?;
const sc = ini::scan(&meta);
defer ini::finish(&sc);
let t = task {
context = void,
tags = void,
...
};
for (let entry: ini::entry => ini::next(&sc)?) {
switch (entry.1) {
case "name" =>
t.name = strings::dup(entry.2);
case "priority" =>
t.priority = strconv::stou(entry.2)?;
case =>
void;
};
};
return t;
};
fn freetask(t: *task) void = {
free(t.name);
if (t.context is str) {
free(t.context as str);
};
if (t.tags is []str) {
strings::freeall(t.tags as []str);
};
};
export fn main() void = {
match (listtasks()) {
case let e: fs::error =>
fmt::fatal(fs::strerror(e));
case let e: path::error =>
fmt::fatal(path::strerror(e));
case =>
void;
};
};
|
