def test_append_multiple_children_returns_codelist(self):
l = Code("something").append(Code("child1"), Code("child2"),
Code("child3"))
self.assertIsInstance(l, List)
self.assertEqual(len(l.codes), 3)
self.assertEqual(l.codes[0].data, "child1")
self.assertEqual(l.codes[1].data, "child2")
self.assertEqual(l.codes[2].data, "child3")
def create_code(self):
return Code("something").contains(
Code("child1").tag("child", "1", "sticky").stick_top(),
Code("child2").tag("child", "2").contains(
Code("child2a").tag("mr red", "grandchild", "a"),
Code("child2b").tag("mr pink", "grandchild", "b").contains(
Code("child2b1").tag("great", "grand", "child", "b", "1"),
Code("child2b2").tag("great", "grand", "child", "b", "2")),
Code("child2c").tag("c")),
# note: child3 and child4 are swapped because child3 is sticked
# to the bottom !!!
Code("child3").tag("child", "3", "sticky").stick_bottom(),
Code("child4").tag("c"))
def test_insert(self):
code = Code("something")
childa = code.append(Code("childa"))
childb = code.append(Code("childb"))
childc = code.append(Code("childc"))
childd = code.append(Code("childd"))
child1 = Code("child1").insert_before(childc)
child2 = Code("child2").insert_before(childc)
child3 = Code("child3").insert_after(child1)
self.assertEqual("\n" + str(code), """
something
childa
childb
child1
child3
child2
childc
childd""")
def test_select_with_wildcard(self):
code = Code("something").contains(
Code("child1").tag("child", "1").contains(
Code("child1a").tag("grand", "child", "a").contains(
Code("child1a1").tag("great-grand", "child", "1"),
Code("child1a2").tag("great-grand", "child", "2"),
Code("child1a3").tag("great-grand", "child", "3")
),
Code("child1b").tag("grand", "child", "b").contains(
Code("child1b1").tag("great-grand", "child", "1"),
Code("child1b2").tag("great-grand", "child", "2", "bastard"),
Code("child1b3").tag("great-grand", "child", "3")
),
Code("child1c").tag("grand", "child", "c").contains(
Code("child1c1").tag("great-grand", "child", "1"),
Code("child1c2").tag("great-grand", "child", "2"),
Code("child1c3").tag("great-grand", "child", "3", "bastard")
)
),
Code("child2").tag("child", "2").contains(
Code("child2a").tag("grand", "child", "a"),
Code("child2b").tag("grand", "child", "b").contains(
Code("child2b1").tag("great-grand", "child", "1"),
Code("child2b2").tag("great-grand", "child", "2")
),
Code("child2c").tag("grand", "child", "c")
),
Code("child3").tag("no-child", "3").contains(
Code("child3a").tag("unimportant").contains(
Code("child3a1").tag("bastard")
)
)
)
l = code.select("child", "*", "bastard")
self.assertIsInstance(l, List)
self.assertEqual(len(l.codes), 2)
self.assertEqual(l.codes[0].data, "child1b2")
self.assertEqual(l.codes[1].data, "child1c3")
def test_contains_codelist(self):
code = self.create_code()
l = code.find("b")
self.assertIsInstance(l, List)
self.assertEqual(len(l), 3)
new = Code("new").tag("new")
l.contains(new)
self.assertIs(code.select(
"2",
"b",
)[2], new)
self.assertIs(code.select("2", "b", "1")[0], new)
self.assertIs(code.select("2", "b", "2")[0], new)
def test_append_multiple_children(self):
code = Code("something")
code.append(Code("child1"), Code("child2"), Code("child3"))
self.assertEqual(str(code), "something\n child1\n child2\n child3")
def test_append_child(self):
code = Code("something")
code.append(Code("child1"))
self.assertEqual(str(code), "something\n child1")
def test_insert(self):
code = Code("something")
childa = code.append(Code("childa"))
childb = code.append(Code("childb"))
childc = code.append(Code("childc"))
childd = code.append(Code("childd"))
child1 = Code("child1").insert_before(childc)
child2 = Code("child2").insert_before(childc)
child3 = Code("child3").insert_after(child1)
self.assertEqual(
"\n" + str(code), """
something
childa
childb
child1
child3
child2
childc
childd""")
def test_append_multiple_children(self):
code = Code("something")
code.append(Code("child1"), Code("child2"), Code("child3"))
self.assertEqual(str(code), "something\n child1\n child2\n child3")
def test_select_with_wildcard(self):
code = Code("something").contains(
Code("child1").tag("child", "1").contains(
Code("child1a").tag("grand", "child", "a").contains(
Code("child1a1").tag("great-grand", "child", "1"),
Code("child1a2").tag("great-grand", "child", "2"),
Code("child1a3").tag("great-grand", "child", "3")),
Code("child1b").tag("grand", "child", "b").contains(
Code("child1b1").tag("great-grand", "child", "1"),
Code("child1b2").tag("great-grand", "child", "2",
"bastard"),
Code("child1b3").tag("great-grand", "child", "3")),
Code("child1c").tag("grand", "child", "c").contains(
Code("child1c1").tag("great-grand", "child", "1"),
Code("child1c2").tag("great-grand", "child", "2"),
Code("child1c3").tag("great-grand", "child", "3",
"bastard"))),
Code("child2").tag("child", "2").contains(
Code("child2a").tag("grand", "child", "a"),
Code("child2b").tag("grand", "child", "b").contains(
Code("child2b1").tag("great-grand", "child", "1"),
Code("child2b2").tag("great-grand", "child", "2")),
Code("child2c").tag("grand", "child", "c")),
Code("child3").tag("no-child", "3").contains(
Code("child3a").tag("unimportant").contains(
Code("child3a1").tag("bastard"))))
l = code.select("child", "*", "bastard")
self.assertIsInstance(l, List)
self.assertEqual(len(l.codes), 2)
self.assertEqual(l.codes[0].data, "child1b2")
self.assertEqual(l.codes[1].data, "child1c3")
def test_code_untag(self):
code = Code("something").tag("tagged", "more",
"even more").untag("more")
self.assertEqual(str(code), "something [even more,tagged]")
def test_code_duplicate_tags(self):
code = Code("something").tag("tagged", "more").tag("more")
self.assertEqual(str(code), "something [more,tagged]")
def test_code_tag(self):
code = Code("something").tag("tagged")
self.assertEqual(str(code), "something [tagged]")
def test_code_unstick(self):
code = Code("something").stick_top().unstick()
self.assertEqual(str(code), "something")
def test_code_stickyness(self):
code = Code("something").stick_top()
self.assertEqual(str(code), "something <sticky>")
code = Code("something").stick_bottom()
self.assertEqual(str(code), "something <sticky>")
def test_append_child(self):
code = Code("something")
code.append(Code("child1"))
self.assertEqual(str(code), "something\n child1")
def test_readme_canvas(self):
# create a canvas
canvas = Canvas()
# add code and tag them for later access
canvas.append(Code("1")).tag("code1")
canvas.append(Code("2")).tag("code2")
# add hierarchical code, access through variables
code1b = canvas.select("code1").append(Code("1b")).tag("code1b")
Code("1a").tag("code1a").insert_before(code1b)
# add more tags and access multiple tags globally
canvas.select("code1", "code1a").tag("child")
canvas.select("code1", "code1b").tag("child")
canvas.select("code1").append(Code("1c")).tag("child")
canvas.select("code1").append(Code("1d")).tag("child")
canvas.find("child").tag("child of code1")
# append accepts multiple arguments and result allows all to be tagged
canvas.select("code2").append(Code("2a").tag("code2a"),
Code("2b").tag("code2b"),
Code("2c").tag("code2c")
).tag("child")
# localized actions
canvas.select("code2", "child").tag("child of code2")
# mark code sticky and force order of children
canvas.select("code1", "code1a").stick_top()
Code("1aa").insert_before(canvas.select("code1", "code1b"))
Code("2aa").insert_before(canvas.select("code2", "code2b"))
self.assertEqual("\n" + str(canvas), """
1 [code1]
1a [child,child of code1,code1a] <sticky>
1aa
1b [child,child of code1,code1b]
1c [child,child of code1]
1d [child,child of code1]
2 [code2]
2a [child,child of code2,code2a]
2aa
2b [child,child of code2,code2b]
2c [child,child of code2,code2c]""")
def test_code_data(self):
code = Code("something")
self.assertEqual(str(code), "something")
