Luce packages
LuceLuce BaseLuciaOS

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