def test_skeleton_day_active(self, setdt):
setdt(2013, 1, 30, 12)
tracker = Tracker()
tracker.deserialize({"life":
"days\n"
" day#bcdef: today\n"
" @started: September 23, 2012 11:00 AM\n"
" _genactive#cdefg: something\n"
" @active\n"
" sleep#defgh: today\n"
"todo bucket#ghijk\n"
"fitness log#hijkl"
})
today = tracker.root.find("days > day: today").one()
tracker.root.active_node.started = None
assert match(serialize_to_str(tracker.root), (
"days#00001\n"
" day#bcdef: {0}\n"
" @started: September 23, 2012 11:00:00 AM\n"
" _genactive#cdefg: something\n"
" @active\n"
" sleep#defgh: {0}\n"
"todo bucket#ghijk\n"
"fitness log#hijkl\n"
).format(today.text))
assert set(tracker.root.ids) == {
"00001", "bcdef", "cdefg", "defgh", "ghijk", "hijkl", "00000"}
def test_activate_deactivate(monkeypatch, setdt):
setdt(2012, 10, 24)
tracker = Tracker(nodecreator=FakeNodeCreator(tasks.Task),
skeleton=False)
tracker.deserialize({"life":
"task: \xfc1\n"
" @active\n"
"task: \xfc2\n"
"task: \xfc3\n"
})
setdt(2012, 10, 24, 0, 5)
navigation._cmd("done", tracker.root)
navigation._cmd("done", tracker.root)
assert match(tracker.serialize()["life"], (
"task#?????: \xfc1\n"
" @finished: 5m after October 24, 2012 12:00:00 AM\n"
"task#?????: \xfc2\n"
" @finished: 0s after October 24, 2012 12:05:00 AM\n"
"task#?????: \xfc3\n"
" @started: October 24, 2012 12:05:00 AM\n"
" @active\n"
))
def test_iter_parents(self):
tracker = Tracker(skeleton=False)
input_str = (
"_genactive: 0\n"
" _genactive: 1\n"
" _genactive: 2\n"
" _genactive: 3\n"
" @active"
)
tracker.deserialize({"life": input_str})
expected_pairs = [
("_genactive", "3"),
("_genactive", "2"),
("_genactive", "1"),
("_genactive", "0"),
("life", None)
]
for expected, node in izip_longest(expected_pairs,
tracker.root.active_node.iter_parents()):
node_type, text = expected
assert node_type == node.node_type
assert text == node.text
def test_searchhooks(setdt, monkeypatch):
monkeypatch.setattr(searching, "parsecreatefilters", [
_parsehook_dayparse,
_parsehook_dayabs
])
setdt(2014, 2, 19, 12)
tracker = Tracker(skeleton=False)
tracker.deserialize({"life":
"task: something\n"
"days\n"
" day: today\n"
" day: tomorrow\n"
" day: September 20, 2014\n"
})
something = tracker.root.find("something").one()
assert something.find("today").one().date == date(2014, 2, 19)
assert something.find("tomorrow").one().date == date(2014, 2, 20)
assert something.find("sept 20, 2014").one().date == date(2014, 9, 20)
assert not something.find("invalid date sept 20, 1995").first()
# subject to change
assert not something.find("sept 21, 2014").first()
assert (searching.parse("day: today")
== searching.Queries(searching.parse("today").queries[0]))
setdt(2014, 2, 20, 12)
assert something.find("today").one().date == date(2014, 2, 20)
def test_task():
tracker = Tracker(nodecreator=FakeNodeCreator(tasks.Task),
skeleton=False)
tracker.deserialize({"life":
"task: \xfca task\n"
" @started: June 7, 2010 7:00 AM"
})
def test_load_continued_text(self):
tracker = Tracker(skeleton=False)
lines = (
"_gennode: derp\n"
" - herp\n"
" - derp\n"
)
tracker.deserialize({"life": lines})
assert tracker.root.children.next_neighbor.text == "derp\nherp\nderp"
def test_too_indented(self):
tracker = Tracker(skeleton=False,
nodecreator=FakeNodeCreator(GenericActivate))
with pytest.raises(exceptions.LoadError):
tracker.deserialize({"life":
"herp\n"
" derp\n"
" donk\n"
})
def test_activation_no_time(self):
tracker = Tracker(skeleton=False)
tracker.deserialize({"life":
"days\n"
" day: today\n"
" @active\n"
})
tracker.root.activate_next()
def test_active_option():
tracker = Tracker(nodecreator=FakeNodeCreator(tasks.Task),
skeleton=False)
tracker.deserialize({"life":
"task: \xfca task\n"
" @active"
})
assert tracker.root.active_node.text == "\xfca task"
def test_load_bad_order(self):
tracker_obj = Tracker(nodecreator=FakeNodeCreator(),
skeleton=False)
lines = (
"firstchild: args\n"
" secondchild: other args\n"
" @option: this won't work here\n"
)
with pytest.raises(exceptions.LoadError):
tracker_obj.deserialize({"life": lines})
def test_duplicate_day(setdt):
setdt(2014, 3, 19, 19, 40)
tracker = Tracker(skeleton=False)
tracker.deserialize({"life":
"days\n"
" day: today\n"
})
n = tracker.root.find("days").one()
with pytest.raises(LoadError):
n.createchild("day", "today")
def test_roottype(self):
class SubRootNode(TreeRootNode):
target_variable = "present"
tracker = Tracker(skeleton=False, roottype=SubRootNode)
assert tracker.roottype is SubRootNode
assert type(tracker.root) is SubRootNode
tracker.deserialize({"life": ""})
assert type(tracker.root) is SubRootNode
def test_day_creation(self, setdt, hour):
setdt(2013, 1, 30, hour)
tracker = Tracker(skeleton=False)
tracker.deserialize({"life":
"days\n"
" day: today\n"
" @active\n"
})
days_node = tracker.root.children.next_neighbor
node = days_node.find('sleep: today').one()
assert node
assert node.prev_neighbor.node_type == "day"
def test_searchhooks_mincreate(setdt, monkeypatch):
monkeypatch.setattr(searching, "parsecreatefilters", [
_parsehook_dayparse,
_parsehook_dayabs
])
setdt(2014, 2, 19, 12)
tracker = Tracker(skeleton=False)
tracker.deserialize({"life":
"task: something\n"
"days\n"
" day: today\n"
})
query = searching.parse("today > does not exist, cannot create")
assert query(tracker.root).actions().list() is not None
def test_skeleton_load_integration(self, setdt):
setdt(2013, 1, 30, 12)
tracker = Tracker()
tracker.deserialize({"life":
"todo bucket\n"
"fitness log"
})
assert tracker.root.active_node is tracker.root
assert match(serialize_to_str(tracker.root), (
"todo bucket#?????\n"
"fitness log#?????\n"
))
assert len(tracker.root.ids) == 3
assert tracker.root.id == "00000"
assert "00000" in tracker.root.ids
assert tracker.root.ids["00000"] is tracker.root
for depth, node in tracker.root.iter_flat_children():
assert node.id in tracker.root.ids
assert tracker.root.ids[node.id] is node
def test_faroff_activate(setdt):
setdt(2014, 3, 19, 20, 17)
tracker = Tracker(skeleton=False)
tracker.deserialize({"life":
"days\n"
" day: today\n"
" @active\n"
" day: March 25, 2014\n"
})
navigation._cmd("create", tracker.root, "March 25, 2014 > task: something")
navigation._cmd("activate", tracker.root, "March 25, 2014")
with pytest.raises(searching.NoMatchesError):
navigation._cmd("activate", tracker.root,
"March 25, 2014 > task: something")
assert tracker.root.active_node is tracker.root.find("today").one()
def test_archival():
tracker = Tracker(False)
tracker.deserialize(
{
"life": "archived: task#abcde: \xfctest\n"
" task#zxcvb: \xfcderp\n"
" task#qwert: \xfcderk\n"
" task#hjklo: \xfcherp\n"
}
)
assert tracker.serialize()["life"] == (
"archived#abcde: task#abcde: \xfctest\n"
" @_af\n"
" archived#zxcvb: task#zxcvb: \xfcderp\n"
" @_af\n"
" archived#qwert: task#qwert: \xfcderk\n"
" @_af\n"
" archived#hjklo: task#hjklo: \xfcherp\n"
" @_af\n"
)
tracker.deserialize(
{
"life": "unarchive: archived#abcde: task#abcde: \xfctest\n"
" @_af\n"
" archived#zxcvb: task#zxcvb: \xfcderp\n"
" @_af\n"
" archived#qwert: task#qwert: \xfcderk\n"
" @_af\n"
" archived#hjklo: task#hjklo: \xfcherp\n"
" @_af\n"
}
)
assert tracker.serialize()["life"] == (
"task#abcde: \xfctest\n"
" task#zxcvb: \xfcderp\n"
" task#qwert: \xfcderk\n"
" task#hjklo: \xfcherp\n"
)
def test_unhandled_load_error(self):
class ExcOnOptionNode(GenericNode):
def setoption(self, option, value):
raise Exception("test exception")
tracker = Tracker(skeleton=False,
nodecreator=FakeNodeCreator(ExcOnOptionNode))
input_str = (
"node1: node1\n"
"node2: node2\n"
"node3: node3\n"
" @someoption: boom\n"
)
try:
tracker.deserialize({"life": input_str})
except exceptions.LoadError as e:
result = str(e)
assert "At line 4: UNHANDLED ERROR" in result
assert "Exception: test exception" in result
else: # pragma: no cover
assert False
def test_empty_line(self):
tracker = Tracker(skeleton=False)
tracker.deserialize({"life":
"\n"
"task#12345: whatever\n"
" \n"
" task#abcde: whatever again\n"
"\n"
" task#hijkl: some other thing\n"
"\n"
"\n"
})
assert tracker.serialize()["life"] == (
"\n"
"task#12345: whatever\n"
" \n"
" task#abcde: whatever again\n"
" \n"
" task#hijkl: some other thing\n"
" \n"
" \n"
)
from __future__ import unicode_literals, print_function
if __name__ == "__main__":
import sys
from treeoflife import searching
if "create" in sys.argv:
dothing = searching.parse_create
else:
dothing = searching.parse
todofile = "/Users/lahwran/.treeoflife/life"
from treeoflife.tracker import Tracker
import time
tracker = Tracker()
with open(todofile, "r") as reader:
tracker.deserialize({"life": reader.read()})
while True:
querytext = raw_input("query: ")
import subprocess
subprocess.call(["clear"])
print("query:", querytext)
a = time.time()
queryer = dothing(querytext)
b = time.time()
print(queryer, b - a)
inittime = time.time()
results = queryer(tracker.root)
finishtime = time.time()
