Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / src / web / dump_2.lucb

#==============================================================================================
#
#   dump_2 - Dump: the selector, rule, style sheet and paintable tree dumps
#
#   DESCRIPTION:
#       Port of Libraries/LibWeb/Dump.cpp (lines 429-770). The paintable tree dump is the
#       second part of a Layout test's expected text (DESIGN.md ยง6.2). The formatting helpers
#       are dump_1's.
#
#       The selector dump (dump_selector, dump_qualified_name) was completed by region r38 once
#       r31 had filled CSS::Selector's types.
#
#       Copyright (c) 2018-2023, Andreas Kling <andreas@ladybird.org>
#       Copyright (c) 2021, the SerenityOS developers.
#       Copyright (c) 2021-2025, Sam Atkins <sam@ladybird.org>
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

# mark: Selectors ===============================================================================

## Ported from Libraries/LibWeb/Dump.cpp:429 Web::dump_selector.
pub func dump_selector_css_selector(selector: const CssSelector*):
    var builder = ak.string_builder_new()
    dump_selector_string_builder(&builder, selector)
    dump_dbgln(&builder)

## Ported from Libraries/LibWeb/Dump.cpp:436 Web::dump_qualified_name.
pub func dump_qualified_name(builder: ak.StringBuilder*, qualified_name: const CssSelectorSimpleSelectorQualifiedName*):
    var namespace_type: str
    match qualified_name.namespace_type:
        .default_: namespace_type = "Default"
        .none_: namespace_type = "None"
        .any: namespace_type = "Any"
        .named: namespace_type = "Named"
        _: trap("VERIFY_NOT_REACHED")
    dump_appendff(builder, "NamespaceType={}, Namespace='{}', Name='{}'",
                  [ak.arg_str(namespace_type), dump_arg_fly_string(&qualified_name.namespace_), dump_arg_fly_string(&qualified_name.name.name)])

## Ported from Libraries/LibWeb/Dump.cpp:456 Web::dump_selector.
pub func dump_selector_string_builder(builder: ak.StringBuilder*, selector: const CssSelector*, indent_levels: i32 = 0):
    dump_indent(builder, indent_levels)
    ak.string_builder_append(builder, "CSS::Selector:\n")

    let compound_selectors = css_selector_compound_selectors(selector)
    let relative_selectors = ak.vector_span_const(&compound_selectors)
    for relative_selector in &relative_selectors:
        dump_indent(builder, indent_levels + 1)

        var relation_description = ""
        match relative_selector.combinator:
            .none_: relation_description = "None"
            .immediate_child: relation_description = "ImmediateChild"
            .descendant: relation_description = "Descendant"
            .next_sibling: relation_description = "AdjacentSibling"
            .subsequent_sibling: relation_description = "GeneralSibling"
            .column: relation_description = "Column"
            _: _ = relation_description

        if relation_description.length != 0:
            dump_appendff(builder, "{{{}}} ", [ak.arg_str(relation_description)])

        let simple_selectors = ak.vector_span_const(&relative_selector.simple_selectors)
        for i in 0..<simple_selectors.length:
            let simple_selector = &simple_selectors[i]
            var type_description = "Unknown"
            match simple_selector.type_:
                .universal: type_description = "Universal"
                .id: type_description = "Id"
                .class_: type_description = "Class"
                .tag_name: type_description = "TagName"
                .attribute: type_description = "Attribute"
                .pseudo_class: type_description = "PseudoClassSelector"
                .pseudo_element: type_description = "PseudoElement"
                .nesting: type_description = "Nesting"
                .invalid: type_description = "INVALID"
                _: _ = type_description

            dump_appendff(builder, "{}:", [ak.arg_str(type_description)])

            # FIXME: This is goofy
            match simple_selector.value:
                .css_selector_simple_selector_name(name):
                    ak.string_builder_append_string_view(builder, ak.fly_string_bytes_as_string_view(&name.name))
                .css_selector_simple_selector_qualified_name(qualified_name):
                    dump_qualified_name(builder, &qualified_name)
                _:
                    _ = simple_selector

            if simple_selector.type_ == CssSelectorSimpleSelectorType.pseudo_class:
                let pseudo_class = css_selector_simple_selector_pseudo_class(simple_selector)

                dump_appendff(builder, " pseudo_class={}", [ak.arg_string_view(css_data.pseudo_class_name(pseudo_class.type_))])
                let pseudo_class_metadata = css_data.pseudo_class_metadata(pseudo_class.type_)

                match pseudo_class_metadata.parameter_type:
                    .none_:
                        _ = pseudo_class_metadata
                    .an_plus_b, .an_plus_b_of:
                        dump_appendff(builder, "(step={}, offset={}", [ak.arg_i64((i64)pseudo_class.an_plus_b_pattern.step_size), ak.arg_i64((i64)pseudo_class.an_plus_b_pattern.offset)])
                        if not ak.vector_is_empty(&pseudo_class.argument_selector_list):
                            ak.string_builder_append(builder, ", selectors=[\n")
                            for child_selector in ak.vector_span_const(&pseudo_class.argument_selector_list):
                                dump_selector_string_builder(builder, child_selector, indent_levels + 2)
                            dump_indent(builder, indent_levels + 1)
                            ak.string_builder_append(builder, "]")
                        ak.string_builder_append(builder, ")")
                    .compound_selector, .forgiving_selector_list, .forgiving_relative_selector_list, .relative_selector_list, .selector_list:
                        ak.string_builder_append(builder, "([\n")
                        for child_selector in ak.vector_span_const(&pseudo_class.argument_selector_list):
                            dump_selector_string_builder(builder, child_selector, indent_levels + 2)
                        dump_indent(builder, indent_levels + 1)
                        ak.string_builder_append(builder, "])")
                    .ident:
                        let ident = pseudo_class.ident else trap("VERIFY: a pseudo-class without its ident")
                        dump_appendff(builder, "(ident={})", [dump_arg_fly_string(&ident.string_value)])
                    .language_ranges:
                        ak.string_builder_append_u8(builder, '(')
                        ak.string_builder_join_fly_string(builder, ak.sv(","), ak.vector_span_const(&pseudo_class.languages))
                        ak.string_builder_append_u8(builder, ')')
                    .level_list:
                        ak.string_builder_append_u8(builder, '(')
                        # builder.join(',', pseudo_class.levels)
                        var first = true
                        for level in ak.vector_span_const(&pseudo_class.levels):
                            if not first:
                                ak.string_builder_append_u8(builder, ',')
                            first = false
                            dump_appendff(builder, "{}", [ak.arg_i64(level)])
                        ak.string_builder_append_u8(builder, ')')
                    _:
                        trap("VERIFY_NOT_REACHED")

            if simple_selector.type_ == CssSelectorSimpleSelectorType.pseudo_element:
                let pseudo_element = css_selector_simple_selector_pseudo_element(simple_selector)
                let serialized = css_selector_pseudo_element_selector_serialize(&pseudo_element)
                dump_appendff(builder, " pseudo_element={}", [dump_arg_string(&serialized)])
                let pseudo_element_metadata = css_data.pseudo_element_metadata(css_selector_pseudo_element_selector_type(&pseudo_element))

                match pseudo_element_metadata.parameter_type:
                    .none_, .compound_selector, .ident_list:
                        _ = pseudo_element_metadata
                    .pt_name_selector:
                        let pt_name_selector = css_selector_pseudo_element_selector_pt_name_selector(&pseudo_element)
                        dump_appendff(builder, "(is_universal={}, value='{}')", [ak.arg_bool(pt_name_selector.is_universal), dump_arg_fly_string(&pt_name_selector.value)])
                    _:
                        trap("VERIFY_NOT_REACHED")

            if simple_selector.type_ == CssSelectorSimpleSelectorType.attribute:
                let attribute = css_selector_simple_selector_attribute(simple_selector)
                var attribute_match_type_description = ""

                match attribute.match_type:
                    .has_attribute: attribute_match_type_description = "HasAttribute"
                    .exact_value_match: attribute_match_type_description = "ExactValueMatch"
                    .contains_word: attribute_match_type_description = "ContainsWord"
                    .contains_string: attribute_match_type_description = "ContainsString"
                    .starts_with_segment: attribute_match_type_description = "StartsWithSegment"
                    .starts_with_string: attribute_match_type_description = "StartsWithString"
                    .ends_with_string: attribute_match_type_description = "EndsWithString"
                    _: _ = attribute_match_type_description

                dump_appendff(builder, " [{}, ", [ak.arg_str(attribute_match_type_description)])
                dump_qualified_name(builder, &attribute.qualified_name)
                dump_appendff(builder, ", value='{}']", [dump_arg_string(&attribute.value)])

            if simple_selector.type_ == CssSelectorSimpleSelectorType.invalid:
                match simple_selector.value:
                    .css_selector_simple_selector_invalid(invalid):
                        ak.string_builder_append(builder, " '")
                        let component_values = ak.vector_span_const(&invalid.component_values)
                        for component_value in &component_values:
                            let text = css_syntax.component_value_to_string(component_value)
                            ak.string_builder_append_string_view(builder, ak.string_bytes_as_string_view(&text))
                        ak.string_builder_append(builder, "'")
                    _:
                        trap("VERIFY: SimpleSelector::Invalid without its value")

            if i != simple_selectors.length - 1:
                ak.string_builder_append(builder, ", ")
        ak.string_builder_append(builder, "\n")

# mark: Rules and declarations ==================================================================

## Ported from Libraries/LibWeb/Dump.cpp:649 Web::dump_rule.
pub func dump_rule_css_rule(rule: CssRule*):
    var builder = ak.string_builder_new()
    dump_rule_string_builder(&builder, rule)
    dump_dbgln(&builder)

## Ported from Libraries/LibWeb/Dump.cpp:656 Web::dump_rule.
pub func dump_rule_string_builder(builder: ak.StringBuilder*, rule: CssRule*, indent_levels: i32 = 0):
    css_rule_dump(rule, builder, indent_levels)

## Ported from Libraries/LibWeb/Dump.cpp:661 Web::dump_style_properties.
pub func dump_style_properties(builder: ak.StringBuilder*, declaration: CssStyleProperties*, indent_levels: i32 = 0):
    dump_indent(builder, indent_levels)
    dump_appendff(builder, "Declarations ({}):\n", [ak.arg_u64((u64)css_style_declaration_length(declaration.css_style_declaration()))])
    let properties = css_style_properties_properties(declaration)
    for property in ak.vector_span_const(&properties):
        dump_indent(builder, indent_levels)
        let name = css_data.string_from_property_id(property.property_id)
        let value = css_style_value_to_string(property.value, css_syntax.SerializationMode.normal)
        dump_appendff(builder, "  {}: '{}'", [dump_arg_fly_string(&name), dump_arg_string(&value)])
        if property.important == css_syntax.Important.yes:
            ak.string_builder_append(builder, " \u{1b}[31;1m!important\u{1b}[0m")
        ak.string_builder_append_u8(builder, '\n')
    let custom_properties = css_style_properties_custom_properties(declaration)
    for property in ak.ordered_hash_map_begin_const(&custom_properties):
        dump_indent(builder, indent_levels)
        let value = css_style_value_to_string(property.value.value, css_syntax.SerializationMode.normal)
        dump_appendff(builder, "  {}: '{}'", [dump_arg_fly_string(&property.key), dump_arg_string(&value)])
        if property.value.important == css_syntax.Important.yes:
            ak.string_builder_append(builder, " \u{1b}[31;1m!important\u{1b}[0m")
        ak.string_builder_append_u8(builder, '\n')

## Ported from Libraries/LibWeb/Dump.cpp:681 Web::dump_descriptors.
pub func dump_descriptors(builder: ak.StringBuilder*, descriptors: CssDescriptors*, indent_levels: i32 = 0):
    dump_indent(builder, indent_levels)
    dump_appendff(builder, "Declarations ({}):\n", [ak.arg_u64((u64)css_style_declaration_length(descriptors.css_style_declaration()))])
    let all_descriptors = css_descriptors_descriptors(descriptors)
    for descriptor in ak.vector_span_const(&all_descriptors):
        dump_indent(builder, indent_levels)
        let name = css_descriptor_name_and_id_name(&descriptor.descriptor_name_and_id)
        let value = css_style_value_to_string(descriptor.value, css_syntax.SerializationMode.normal)
        dump_appendff(builder, "  {}: '{}'", [dump_arg_fly_string(&name), dump_arg_string(&value)])
        ak.string_builder_append_u8(builder, '\n')

# mark: Style sheets ============================================================================

## Ported from Libraries/LibWeb/Dump.cpp:692 Web::dump_sheet.
pub func dump_sheet_css_style_sheet(sheet: CssStyleSheet*):
    var builder = ak.string_builder_new()
    dump_sheet_string_builder(&builder, sheet)
    dump_dbgln(&builder)

## Ported from Libraries/LibWeb/Dump.cpp:699 Web::dump_sheet.
pub func dump_sheet_string_builder(builder: ak.StringBuilder*, sheet: CssStyleSheet*, indent_levels: i32 = 0):
    dump_indent(builder, indent_levels)
    let css_stylesheet = as_css_css_style_sheet(sheet)
    let rules = css_css_style_sheet_rules(css_stylesheet)
    dump_appendff(builder, "CSSStyleSheet{{{}}}: {} rule(s)\n", [ak.arg_pointer(sheet), ak.arg_u64((u64)css_rule_list_length(rules))])

    # CSSRuleList's begin() and end() are m_rules's.
    for rule in ak.vector_span_const(&rules.m_rules):
        dump_rule_string_builder(builder, rule, indent_levels + 1)

# mark: Paintable tree ==========================================================================

## Ported from Libraries/LibWeb/Dump.cpp:709 Web::dump_tree.
pub func dump_tree_paint_paintable(paintable: PaintPaintable*):
    var builder = ak.string_builder_new()
    dump_tree_string_builder_paint_paintable(&builder, paintable, true)
    dump_dbgln(&builder)

## Ported from Libraries/LibWeb/Dump.cpp:716 Web::dump_tree.
pub func dump_tree_string_builder_paint_paintable(builder: ak.StringBuilder*, paintable: PaintPaintable*, colorize: bool = false, indent: i32 = 0):
    # Dump all paintables attached to this layout node at every level.
    # This makes detached/disconnected paintables visible across the full subtree.
    var paintable_with_lines_color_on = ""
    var paintable_box_color_on = ""
    var text_paintable_color_on = ""
    var paintable_color_on = ""
    var color_off = ""

    if colorize:
        paintable_with_lines_color_on = "\u{1b}[34m"
        paintable_box_color_on = "\u{1b}[33m"
        text_paintable_color_on = "\u{1b}[35m"
        paintable_color_on = "\u{1b}[32m"
        color_off = "\u{1b}[0m"

    var dumped_any = false
    for node_paintable in ak.intrusive_list_begin(layout_node_paintables(paint_paintable_layout_node(paintable))):
        if dumped_any:
            ak.string_builder_append(builder, "\n")

        ak.string_builder_append_repeated_string_view(builder, ak.sv("  "), (usize)indent)

        if is_paint_paintable_with_lines(node_paintable):
            ak.string_builder_append(builder, paintable_with_lines_color_on)
        elif is_paint_paintable_box(node_paintable):
            ak.string_builder_append(builder, paintable_box_color_on)
        elif is_paint_text_paintable(node_paintable):
            ak.string_builder_append(builder, text_paintable_color_on)
        else:
            ak.string_builder_append(builder, paintable_color_on)

        let debug_description = layout_node_debug_description(paint_paintable_layout_node(node_paintable))
        dump_appendff(builder, "{}{} ({})", [ak.arg_string_view(dump_class_name(node_paintable.cell())), ak.arg_str(color_off), dump_arg_string(&debug_description)])

        if let paintable_box = as_if_paint_paintable_box(node_paintable):
            ak.string_builder_append(builder, " ")
            dump_append_css_pixel_rect(builder, paint_paintable_box_absolute_border_box_rect(paintable_box))

            if paint_paintable_box_has_scrollable_overflow(paintable_box):
                ak.string_builder_append(builder, " overflow: ")
                # Formatter<Optional<T>>: the value, or "None".
                if let scrollable_overflow_rect = paint_paintable_box_scrollable_overflow_rect(paintable_box):
                    dump_append_css_pixel_rect(builder, scrollable_overflow_rect)
                else:
                    ak.string_builder_append(builder, "None")

            let scroll_offset = paint_paintable_box_scroll_offset(paintable_box)
            if not gfx.css_pixel_point_is_zero(&scroll_offset):
                ak.string_builder_append(builder, " scroll-offset: ")
                dump_append_css_pixel_point(builder, scroll_offset)
        ak.string_builder_append(builder, "\n")

        var child = tree_node_first_child(node_paintable)
        while let at = child:
            dump_tree_string_builder_paint_paintable(builder, at, colorize, indent + 1)
            child = tree_node_next_sibling(at)
        dumped_any = true