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