dymokomi/luce-browser-engine
Source of release 0.6.1
0.6.1 / src / web / html / parser / tests_html_parser_support.lucb
#==============================================================================================
#
# tests_html_parser_support - helpers of the HTML parser tests (region r21)
#
# DESCRIPTION:
# A DOM dump in the html5lib tree-construction format (`| <tag>`, attributes sorted, text
# in quotes, two spaces per level) and a parser made by hand in a test realm.
#
# Document's constructor and parser hookup (set_parser, set_encoding) are region r17's,
# and the HTML element constructors are r22/r26/r27's: until they land, the tests
# construct the parser the way its constructor does minus the Document calls, on r18's
# hand-built document.
#
#==============================================================================================
# mark: The html5lib tree dump ==================================================================
## The test namespace of the foreign-content tests.
func parser_test_namespace() -> ak.FlyString:
return ak.fly_string_from_str("urn:x-test")
## Appends `level` levels of indentation after the "| " prefix.
func parser_test_dump_indent(builder: ak.StringBuilder*, level: usize):
ak.string_builder_append(builder, "| ")
for _unused in 0..<level:
ak.string_builder_append(builder, " ")
## The html5lib prefix of a namespace ("svg ", "math ", "" for HTML; other namespaces in braces).
func parser_test_dump_namespace_prefix(builder: ak.StringBuilder*, namespace_: ak.FlyString?):
let ns = namespace_ else return
if ak.fly_string_eq_fly_string(&ns, &namespace_html):
return
if ak.fly_string_eq_fly_string(&ns, &namespace_svg):
ak.string_builder_append(builder, "svg ")
return
if ak.fly_string_eq_fly_string(&ns, &namespace_math_ml):
ak.string_builder_append(builder, "math ")
return
if ak.fly_string_eq_fly_string(&ns, &namespace_x_link):
ak.string_builder_append(builder, "xlink ")
return
if ak.fly_string_eq_fly_string(&ns, &namespace_xml):
ak.string_builder_append(builder, "xml ")
return
if ak.fly_string_eq_fly_string(&ns, &namespace_xmlns):
ak.string_builder_append(builder, "xmlns ")
return
ak.string_builder_append(builder, "{")
html_parser_append_fly_string(builder, ns)
ak.string_builder_append(builder, "} ")
## A line per attribute, sorted by name as html5lib prints them.
func parser_test_dump_attributes(builder: ak.StringBuilder*, element: DomElement*, level: usize):
let attributes = element.m_attributes else return
let count = dom_named_node_map_length(attributes)
var lines: ak.Vector[ak.String]
for index in 0..<count:
let attribute = dom_named_node_map_item(attributes, (u32)index) else trap("item in range")
var line = ak.string_builder_new()
parser_test_dump_namespace_prefix(&line, dom_attr_namespace_uri(attribute))
html_parser_append_fly_string(&line, dom_attr_local_name(attribute))
ak.string_builder_append(&line, "=\"")
html_parser_append_string(&line, dom_attr_value(attribute))
ak.string_builder_append(&line, "\"")
ak.vector_append_t(&lines, ak.string_builder_to_string_without_validation(&line))
# Insertion sort by bytes (the lists are short).
for i in 1..<ak.vector_size(&lines):
var j = i
while j > 0 and parser_test_string_less(ak.vector_at(&lines, j), ak.vector_at(&lines, j - 1)):
let tmp = *ak.vector_at(&lines, j)
*ak.vector_at(&lines, j) = *ak.vector_at(&lines, j - 1)
*ak.vector_at(&lines, j - 1) = tmp
j -= 1
for line in &ak.vector_span(&lines):
parser_test_dump_indent(builder, level)
html_parser_append_string(builder, *line)
ak.string_builder_append(builder, "\n")
## Byte order of two strings.
func parser_test_string_less(a: const ak.String*, b: const ak.String*) -> bool:
let a_view = ak.string_bytes_as_string_view(a)
let b_view = ak.string_bytes_as_string_view(b)
let a_bytes = ak.string_view_bytes(&a_view)
let b_bytes = ak.string_view_bytes(&b_view)
let n = a_bytes.length if a_bytes.length < b_bytes.length else b_bytes.length
for i in 0..<n:
if a_bytes[i] != b_bytes[i]:
return a_bytes[i] < b_bytes[i]
return a_bytes.length < b_bytes.length
## Dumps `node`'s children (and, for a template, its contents) at `level`.
func parser_test_dump_children(builder: ak.StringBuilder*, node: DomNode*, level: usize):
for child in dom_node_children(node):
parser_test_dump_node(builder, child, level)
## Dumps one node and its subtree in the html5lib format.
func parser_test_dump_node(builder: ak.StringBuilder*, node: DomNode*, level: usize):
parser_test_dump_indent(builder, level)
if let element = as_if_dom_element(node):
ak.string_builder_append(builder, "<")
parser_test_dump_namespace_prefix(builder, dom_element_namespace_uri(element))
html_parser_append_fly_string(builder, dom_element_local_name(element))
ak.string_builder_append(builder, ">\n")
parser_test_dump_attributes(builder, element, level + 1)
parser_test_dump_children(builder, node, level + 1)
return
if let text = as_if_dom_text(node):
ak.string_builder_append(builder, "\"")
html_parser_append_utf16_string(builder, dom_character_data_data(text.dom_character_data()))
ak.string_builder_append(builder, "\"\n")
return
if let comment = as_if_dom_comment(node):
ak.string_builder_append(builder, "<!-- ")
html_parser_append_utf16_string(builder, dom_character_data_data(comment.dom_character_data()))
ak.string_builder_append(builder, " -->\n")
return
if let doctype = as_if_dom_document_type(node):
ak.string_builder_append(builder, "<!DOCTYPE ")
html_parser_append_string(builder, dom_document_type_name(doctype))
ak.string_builder_append(builder, ">\n")
return
ak.string_builder_append(builder, "?\n")
## The html5lib dump of `node`'s children.
func parser_test_dump(node: DomNode*) -> ak.String:
var builder = ak.string_builder_new()
parser_test_dump_children(&builder, node, 0)
return ak.string_builder_to_string_without_validation(&builder)
## Asserts that a dump is `expected`, printing both when not.
func parser_test_expect_dump(actual: ak.String, expected: str):
if ak.string_eq_string_view(&actual, ak.sv(expected)):
return
let actual_view = ak.string_bytes_as_string_view(&actual)
print(f"expected:\n{expected}\nactual:\n{(str)ak.string_view_bytes(&actual_view)}")
assert(false, "dump mismatch")
# mark: A parser made by hand ===================================================================
## An HTMLParser over `input`, made the way HTMLParser's constructor makes it except for its
## Document calls (set_parser, set_encoding: region r17), in `realm` for `document`.
func parser_test_html_parser(realm: Realm*, document: DomDocument*, input: str, scripting_mode: HtmlParserScriptingMode = HtmlParserScriptingMode.disabled) -> HtmlParser*:
let heap = realm_heap(realm)
let this = (HtmlParser*)web_heap_allocate_cell(heap, &html_parser_class)
gc.heap_defer_gc(heap)
html_parser_init_fields(this)
html_syntax.html_tokenizer_construct_string_view(&this.m_tokenizer, ak.sv(input), ak.byte_string_from_str("UTF-8"))
this.m_scripting_mode = scripting_mode
this.m_character_insertion_builder = ak.string_builder_new_mode(ak.StringBuilderMode.utf16)
this.m_document = document
html_syntax.html_tokenizer_set_parser(&this.m_tokenizer, html_parser_adjusted_current_node_is_foreign, this)
html_stack_of_open_elements_set_on_element_popped(&this.m_stack_of_open_elements, ak.Function1[DomElement*, unit](call = html_parser_on_element_popped, context = this))
gc.heap_undefer_gc(heap)
return this