def create_entry_link(self, item):
link = Element("a")
link.add_class("entry_link")
link["href"] = self.get_entry_url(item)
link.append(self.get_item_label(item))
return link
def create_group_row(self, group):
row = Element("tr")
row.add_class("group")
cell = Element(
"td",
colspan=len(self.head_row.children),
children=[
Element("span",
class_name="grouping_value",
children=[
self.grouping.translate_grouping_value(group)
or self.translate_value(
self.data, self.grouping.member, group)
]),
Element("span",
class_name="grouping_member",
children=[self._grouping_member_translation]),
Element("a",
href="?" +
get_request_query(grouping="", page=0).escape(),
class_name="remove_grouping",
children=[self._remove_grouping_translation])
])
row.append(cell)
return row
def create_entry(self, item):
entry = Element()
entry.add_class("entry")
entry.control = self.create_control(item)
entry.append(entry.control)
entry.remove_button = self.create_remove_button(item)
entry.append(entry.remove_button)
return entry
def test_single_elements_with_children(self):
from cocktail.html.element import Element
from cocktail.html.renderers import HTML4Renderer, RenderingError
e = Element("img")
e.append(Element())
self.assertRaises(RenderingError, e.render, HTML4Renderer())
def create_group(self, group, members):
tbody = Element("tbody")
if group:
tbody.add_class(group.replace(".", "_") + "_group")
tbody.header_row = self.create_group_header(group)
if tbody.header_row:
tbody.append(tbody.header_row)
self._create_rows(members, tbody)
return tbody
def create_entry(self, item):
entry = Element()
entry.add_class("entry")
if self.is_selected(item):
entry.add_class("selected")
link = self.create_entry_link(item)
entry.append(link)
return entry
def create_group_header(self, group):
label = self.get_group_label(group)
if label:
row = Element("tr")
row.add_class("group_header")
th = Element("th")
th["colspan"] = 2
th.append(label)
row.header = th
row.append(th)
return row
def embed(self, document, source):
from cocktail.html.element import Element
embed = Element("script")
embed["type"] = self.mime_type
embed.append("\n//<![CDATA[\n" + source + "\n//]]>\n")
if self.ie_condition:
from cocktail.html.ieconditionalcomment import IEConditionalComment
embed = IEConditionalComment(self.ie_condition, children=[embed])
document.scripts_container.append(embed)
return embed
def test_release(self):
from cocktail.html.element import Element
# Releasing a top-level element is a no-op
parent = Element()
parent.release()
# Releasing a child element removes it from its parent
child = Element()
parent.append(child)
child.release()
self.assertTrue(child.parent is None)
self.assertEqual(parent.children, [])
def test_elements_reuse_cached_content(self):
from cocktail.html.element import Element
e = Element("div")
e.append("Hello, world")
e.cached = True
e.cache_key = "test"
e.render(cache=self.cache)
e.append("!!!")
assert e.render(cache=self.cache) == "<div>Hello, world</div>"
e.cached = False
assert e.render(cache=self.cache) == "<div>Hello, world!!!</div>"
def create_cell(self, item, column, language=None):
cell = Element("td")
if language:
cell["dir"] = directionality.get(language)
if (self.order and (column.name, language) in self._sorted_columns
and not (self.user_collection
and not self.user_collection.allow_sorting)):
cell.add_class("sorted")
self._init_cell(cell, column, language)
display = self.create_member_display(
item, column, self.get_member_value(item, column))
cell.append(display)
return cell
def test_invisible_element_not_rendered(self):
from cocktail.html.element import Element
e = Element()
e.visible = False
self.assertEqual(self.get_html(e), "")
e.visible = True
e.collapsible = True
self.assertEqual(self.get_html(e), "")
child = Element()
child.visible = False
e.append(child)
self.assertEqual(self.get_html(e), "")
def read_only_display(ui_generator, obj, member, value, **context):
read_only_ui_generator = (ui_generator.read_only_ui_generator
or default_display)
element = Element()
element.add_class("read_only_display")
element.display = read_only_ui_generator.create_member_display(
obj, member, value, **context)
element.append(element.display)
element.hidden_input = HiddenInput()
element.append(element.hidden_input)
element.data_binding_delegate = element.hidden_input
return element
def test_elements_can_invalidate_cached_content(self):
from cocktail.html.element import Element
e = Element()
e.cached = True
e.cached_key = "foo"
e.cache_tags.add("foo")
e.render(cache=self.cache)
e.append("foo")
html = e.render(cache=self.cache)
assert "foo" not in html
self.cache.clear(scope=["foo"])
html = e.render(cache=self.cache)
assert "foo" in html
def test_elements_can_define_cache_expiration(self):
from time import sleep
from datetime import timedelta
from cocktail.html.element import Element
e = Element()
e.cached = True
e.cache_key = "test"
e.cache_expiration = timedelta(seconds=1)
e.render(cache=self.cache)
e.append("foo")
assert "foo" not in e.render(cache=self.cache)
sleep(1.2)
assert "foo" in e.render(cache=self.cache)
def create_header(self, column, language=None):
header = Element("th")
self._init_cell(header, column, language)
header.label = Element("span")
header.label.add_class("label")
header.label.append(self.get_member_label(column))
header.append(header.label)
# Translation label
if self.show_language_headers and language:
header.translation_label = self.create_translation_label(language)
header.append(header.translation_label)
self.add_header_ui(header, column, language)
return header
def create_entry(self, item):
entry = Element()
entry.add_class("radio_entry")
entry.input = Element("input")
entry.input["type"] = "radio"
entry.input["value"] = self.get_item_value(item)
entry.input["checked"] = self.is_selected(item)
entry.input["name"] = self.name
entry.append(entry.input)
entry.label = self.create_label(item)
if entry.label.tag == "label":
entry.label["for"] = entry.input.require_id()
entry.append(entry.label)
return entry
def test_empty(self):
from cocktail.html.element import Element
parent = Element()
# Emptying an empty element is a no-op
parent.empty()
# Emptying an element removes all its children
child1 = Element()
parent.append(child1)
child2 = Element()
parent.append(child2)
parent.empty()
self.assertEqual(parent.children, [])
self.assertTrue(child1.parent is None)
self.assertTrue(child2.parent is None)
def test_append_content(self):
from cocktail.html.element import Element, Content
parent = Element()
parent.append("hello world")
self.assertEqual(len(parent.children), 1)
child = parent.children[0]
self.assertTrue(isinstance(child, Content))
self.assertEqual(child.value, "hello world")
self.assertTrue(child.parent is parent)
parent = Element(children=["hello world"])
self.assertEqual(len(parent.children), 1)
child = parent.children[0]
self.assertTrue(isinstance(child, Content))
self.assertEqual(child.value, "hello world")
self.assertTrue(child.parent is parent)
def test_place_after(self):
from cocktail.html.element import Element
parent = Element()
child1 = Element()
parent.append(child1)
child2 = Element()
child2.place_after(child1)
self.assertTrue(child2.parent is parent)
self.assertEqual(parent.children, [child1, child2])
child3 = Element()
child3.place_after(child1)
self.assertTrue(child3.parent is parent)
self.assertEqual(parent.children, [child1, child3, child2])
child3.place_after(child2)
self.assertTrue(child3.parent is parent)
self.assertEqual(parent.children, [child1, child2, child3])
def test_cached_content_is_indexed_by_cache_key(self):
from cocktail.html.element import Element
a = Element("div")
a.append("a")
a.cached = True
a.cache_key = "a"
a.render(cache=self.cache)
b = Element("div")
b.append("b")
b.cached = True
b.cache_key = "b"
b.render(cache=self.cache)
x = Element("div")
x.append("x")
x.cached = True
x.cache_key = "x"
x.render(cache=self.cache)
assert x.render(cache=self.cache) == "<div>x</div>"
x.cache_key = "a"
assert x.render(cache=self.cache) == "<div>a</div>"
x.cache_key = "b"
assert x.render(cache=self.cache) == "<div>b</div>"
def _add_split_rows(self, item, row):
if not self.__split_rows:
return
row_span = 1
end = False
while not end:
extra_row = Element("tr")
has_content = False
for group, columns in self.columns_by_group:
for column in columns:
key = column.name
iterator = self.__split_row_iterators.get(key)
cell = None
if iterator is not None:
try:
self.__split_row_values[key] = next(iterator)
except StopIteration:
end = True
else:
cell = self.create_cell(item, column)
has_content = True
if cell is not None:
extra_row.append(cell)
if has_content:
self.append(extra_row)
row_span += 1
for cell in row.children:
if cell.member is None \
or cell.member.name not in self.__split_rows:
cell["rowspan"] = row_span
def create_translated_values(self, member):
cell = Element("td")
table = Element("table")
table.add_class("translated_values")
cell.append(table)
for language in (self.translations or (get_language(), )):
language_row = Element("tr")
language_row.add_class(language)
table.append(language_row)
language_label = Element("th")
language_label.append(translations(language))
language_row.append(language_label)
with language_context(language):
language_value_cell = self.create_value(member)
language_row.append(language_value_cell)
return cell
def test_collapsible_rendered(self):
from cocktail.html.element import Element
parent = Element()
# An element starts with no rendered children
self.assertFalse(parent.has_rendered_children())
# A collapsible element with no children is not rendered
parent.collapsible = True
self.assertFalse(parent.rendered)
# A collapsible element with visible children is rendered
child1 = Element()
parent.append(child1)
self.assertTrue(parent.has_rendered_children())
self.assertTrue(parent.rendered)
# A collapsible element with invisible children is not rendered
child1.visible = False
self.assertFalse(parent.has_rendered_children())
self.assertFalse(parent.rendered)
# A collapsible element with collapsible children without rendered
# children is not rendered
child1.visible = True
child1.collapsible = True
self.assertFalse(parent.has_rendered_children())
self.assertFalse(parent.rendered)
# The collapsible property applies recursively
grandchild1 = Element()
child1.append(grandchild1)
self.assertTrue(parent.has_rendered_children())
self.assertTrue(parent.rendered)
self.assertTrue(child1.has_rendered_children())
self.assertTrue(child1.rendered)
grandchild1.visible = False
self.assertFalse(parent.has_rendered_children())
self.assertFalse(parent.rendered)
self.assertFalse(child1.has_rendered_children())
self.assertFalse(child1.rendered)
# Just one rendered child suffices to get a collapsible element to be
# rendered
child2 = Element()
parent.append(child2)
self.assertTrue(parent.has_rendered_children())
self.assertTrue(parent.rendered)
def create_member_row(self, member):
row = Element("tr")
row.add_class("member_row")
row.add_class(member.name + "_member")
label = self.create_label(member)
row.append(label)
if member.translated:
row.add_class("translated")
row.append(self.create_translated_values(member))
else:
row.append(self.create_value(member))
return row
def test_append(self):
from cocktail.html.element import Element
parent = Element()
child1 = Element()
parent.append(child1)
self.assertTrue(child1.parent is parent)
self.assertEqual(parent.children, [child1])
child2 = Element()
parent.append(child2)
self.assertTrue(child2.parent is parent)
self.assertEqual(parent.children, [child1, child2])
child2.append(child1)
self.assertTrue(child1.parent is child2)
self.assertEqual(child2.children, [child1])
parent.append(child1)
self.assertTrue(child1.parent is parent)
self.assertEqual(parent.children, [child2, child1])
def create_entry(self, key, value):
entry = Element()
entry.add_class("entry")
entry.key_control = self.create_key_control(key, value)
entry.append(entry.key_control)
entry.value_control = self.create_value_control(key, value)
entry.append(entry.value_control)
if not self.fixed_entries:
entry.remove_button = self.create_remove_button(key, value)
entry.append(entry.remove_button)
return entry
def create_row(self, index, item):
self.__split_row_iterators.clear()
self.__split_row_values.clear()
row = Element("tr")
row.add_class(index % 2 == 0 and "odd" or "even")
if (self.selection_mode != NO_SELECTION
and self.use_separate_selection_column):
row.append(self.create_selection_cell(item))
if self.schema.primary_member:
row["id"] = item.id
for group, columns in self.columns_by_group:
for column in columns:
if self.translations and column.translated:
for language in self.translations:
with language_context(language):
cell = self.create_cell(item, column, language)
row.append(cell)
else:
key = column.name
sequence_factory = self.__split_rows.get(key)
if sequence_factory is not None:
iterator = iter(sequence_factory(item))
self.__split_row_iterators[key] = iterator
try:
value = next(iterator)
except StopIteration:
value = None
self.__split_row_values[key] = value
cell = self.create_cell(item, column)
row.append(cell)
if (self.selection_mode != NO_SELECTION
and not self.use_separate_selection_column):
row.children[0].insert(0, self.create_selection_control(item))
return row
def create_entry(self, value, label, selected):
entry = Element("li")
link = self.create_entry_link(value, label)
if selected:
strong = Element("strong")
strong.append(link)
entry.append(strong)
else:
entry.append(link)
if self.missing_translations != "redirect":
publishable = context["publishable"]
if not publishable.is_accessible(language=value):
if self.missing_translations == "hide":
entry.visible = False
elif self.missing_translations == "disable":
link.tag = "span"
link["href"] = None
return entry
def create_label(self, item):
label = Element("label")
label.append(self.get_item_label(item))
return label
