serenity/Meta/Lagom/Tools/CodeGenerators/LibWeb/GenerateAriaRoles.cpp

/*
 * Copyright (c) 2023, Jonah Shafran <jonahshafran@gmail.com>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

#include "GeneratorUtil.h"
#include <AK/SourceGenerator.h>
#include <AK/String.h>
#include <LibCore/ArgsParser.h>
#include <LibMain/Main.h>

ErrorOr<void> generate_header_file(JsonObject& roles_data, Core::File& file);
ErrorOr<void> generate_implementation_file(JsonObject& roles_data, Core::File& file);

ErrorOr<int> serenity_main(Main::Arguments arguments)
{
    StringView generated_header_path;
    StringView generated_implementation_path;
    StringView identifiers_json_path;

    Core::ArgsParser args_parser;
    args_parser.add_option(generated_header_path, "Path to the TransformFunctions header file to generate", "generated-header-path", 'h', "generated-header-path");
    args_parser.add_option(generated_implementation_path, "Path to the TransformFunctions implementation file to generate", "generated-implementation-path", 'c', "generated-implementation-path");
    args_parser.add_option(identifiers_json_path, "Path to the JSON file to read from", "json-path", 'j', "json-path");
    args_parser.parse(arguments);

    auto json = TRY(read_entire_file_as_json(identifiers_json_path));
    VERIFY(json.is_object());
    auto roles_data = json.as_object();

    auto generated_header_file = TRY(Core::File::open(generated_header_path, Core::File::OpenMode::Write));
    auto generated_implementation_file = TRY(Core::File::open(generated_implementation_path, Core::File::OpenMode::Write));

    TRY(generate_header_file(roles_data, *generated_header_file));
    TRY(generate_implementation_file(roles_data, *generated_implementation_file));

    return 0;
}

ErrorOr<void> generate_header_file(JsonObject& roles_data, Core::File& file)
{
    StringBuilder builder;
    SourceGenerator generator { builder };

    generator.append(R"~~~(
#pragma once

#include <LibWeb/ARIA/RoleType.h>

namespace Web::ARIA {
)~~~");

    TRY(roles_data.try_for_each_member([&](auto& name, auto& value) -> ErrorOr<void> {
        VERIFY(value.is_object());
        JsonObject const& value_object = value.as_object();

        auto class_definition_generator = TRY(generator.fork());
        class_definition_generator.set("spec_link"sv, value_object.get_deprecated_string("specLink"sv).value());
        class_definition_generator.set("description"sv, value_object.get_deprecated_string("description"sv).value());
        class_definition_generator.set("name"sv, name);
        class_definition_generator.append(R"~~~(
// @spec_link@
// @description@
class @name@ :
)~~~");

        JsonArray const& super_classes = value_object.get_array("superClassRoles"sv).value();
        bool first = true;
        TRY(super_classes.try_for_each([&](JsonValue const& value) -> ErrorOr<void> {
            VERIFY(value.is_string());

            class_definition_generator.append(first ? " "sv : ", "sv);
            class_definition_generator.append(TRY(String::formatted("public {}", value.as_string())));
            first = false;
            return {};
        }));

        class_definition_generator.append(R"~~~(
{
public:
    @name@(AriaData const&);

    virtual HashTable<StateAndProperties> const& supported_states() const override;
    virtual HashTable<StateAndProperties> const& supported_properties() const override;

    virtual HashTable<StateAndProperties> const& required_states() const override;
    virtual HashTable<StateAndProperties> const& required_properties() const override;

    virtual HashTable<StateAndProperties> const& prohibited_properties() const override;
    virtual HashTable<StateAndProperties> const& prohibited_states() const override;

    virtual HashTable<Role> const& required_context_roles() const override;
    virtual HashTable<Role> const& required_owned_elements() const override;
    virtual bool accessible_name_required() const override;
    virtual bool children_are_presentational() const override;
    virtual DefaultValueType default_value_for_property_or_state(StateAndProperties) const override;
protected:
    @name@();
)~~~");

        auto name_from_source = value.as_object().get("nameFromSource"sv).value();
        if (!name_from_source.is_null())
            class_definition_generator.append(R"~~~(
public:
    virtual NameFromSource name_from_source() const override;
)~~~");
        class_definition_generator.appendln("};");
        return {};
    }));

    generator.appendln("}");

    TRY(file.write_until_depleted((generator.as_string_view().bytes())));
    return {};
}

ErrorOr<String> generate_hash_table_population(JsonArray const& values, StringView hash_table_name, StringView enum_class)
{
    StringBuilder builder;
    TRY(values.try_for_each([&](auto& value) -> ErrorOr<void> {
        VERIFY(value.is_string());
        TRY(builder.try_appendff("        {}.set({}::{});\n", hash_table_name, enum_class, value.as_string()));
        return {};
    }));

    return builder.to_string();
}

ErrorOr<void> generate_hash_table_member(SourceGenerator& generator, StringView member_name, StringView hash_table_name, StringView enum_class, JsonArray const& values)
{
    auto member_generator = TRY(generator.fork());
    member_generator.set("member_name"sv, member_name);
    member_generator.set("hash_table_name"sv, hash_table_name);
    member_generator.set("enum_class"sv, enum_class);
    TRY(member_generator.set("hash_table_size"sv, TRY(String::number(values.size()))));

    if (values.size() == 0) {
        member_generator.append(R"~~~(
HashTable<@enum_class@> const& @name@::@member_name@() const
{
    static HashTable<@enum_class@> @hash_table_name@;
    return @hash_table_name@;
}
)~~~");
        return {};
    }

    member_generator.append(R"~~~(
HashTable<@enum_class@> const& @name@::@member_name@() const
{
    static HashTable<@enum_class@> @hash_table_name@;
    if (@hash_table_name@.is_empty()) {
        @hash_table_name@.ensure_capacity(@hash_table_size@);
)~~~");
    member_generator.append(TRY(generate_hash_table_population(values, hash_table_name, enum_class)));
    member_generator.append(R"~~~(
    }
    return @hash_table_name@;
}
)~~~");

    return {};
}

StringView aria_name_to_enum_name(StringView name)
{
    if (name == "aria-activedescendant"sv) {
        return "AriaActiveDescendant"sv;
    } else if (name == "aria-atomic"sv) {
        return "AriaAtomic"sv;
    } else if (name == "aria-autocomplete"sv) {
        return "AriaAutoComplete"sv;
    } else if (name == "aria-busy"sv) {
        return "AriaBusy"sv;
    } else if (name == "aria-checked"sv) {
        return "AriaChecked"sv;
    } else if (name == "aria-colcount"sv) {
        return "AriaColCount"sv;
    } else if (name == "aria-colindex"sv) {
        return "AriaColIndex"sv;
    } else if (name == "aria-colspan"sv) {
        return "AriaColSpan"sv;
    } else if (name == "aria-controls"sv) {
        return "AriaControls"sv;
    } else if (name == "aria-current"sv) {
        return "AriaCurrent"sv;
    } else if (name == "aria-describedby"sv) {
        return "AriaDescribedBy"sv;
    } else if (name == "aria-details"sv) {
        return "AriaDetails"sv;
    } else if (name == "aria-disabled"sv) {
        return "AriaDisabled"sv;
    } else if (name == "aria-dropeffect"sv) {
        return "AriaDropEffect"sv;
    } else if (name == "aria-errormessage"sv) {
        return "AriaErrorMessage"sv;
    } else if (name == "aria-expanded"sv) {
        return "AriaExpanded"sv;
    } else if (name == "aria-flowto"sv) {
        return "AriaFlowTo"sv;
    } else if (name == "aria-grabbed"sv) {
        return "AriaGrabbed"sv;
    } else if (name == "aria-haspopup"sv) {
        return "AriaHasPopup"sv;
    } else if (name == "aria-hidden"sv) {
        return "AriaHidden"sv;
    } else if (name == "aria-invalid"sv) {
        return "AriaInvalid"sv;
    } else if (name == "aria-keyshortcuts"sv) {
        return "AriaKeyShortcuts"sv;
    } else if (name == "aria-label"sv) {
        return "AriaLabel"sv;
    } else if (name == "aria-labelledby"sv) {
        return "AriaLabelledBy"sv;
    } else if (name == "aria-level"sv) {
        return "AriaLevel"sv;
    } else if (name == "aria-live"sv) {
        return "AriaLive"sv;
    } else if (name == "aria-modal"sv) {
        return "AriaModal"sv;
    } else if (name == "aria-multiline"sv) {
        return "AriaMultiLine"sv;
    } else if (name == "aria-multiselectable"sv) {
        return "AriaMultiSelectable"sv;
    } else if (name == "aria-orientation"sv) {
        return "AriaOrientation"sv;
    } else if (name == "aria-owns"sv) {
        return "AriaOwns"sv;
    } else if (name == "aria-placeholder"sv) {
        return "AriaPlaceholder"sv;
    } else if (name == "aria-posinset"sv) {
        return "AriaPosInSet"sv;
    } else if (name == "aria-pressed"sv) {
        return "AriaPressed"sv;
    } else if (name == "aria-readonly"sv) {
        return "AriaReadOnly"sv;
    } else if (name == "aria-relevant"sv) {
        return "AriaRelevant"sv;
    } else if (name == "aria-required"sv) {
        return "AriaRequired"sv;
    } else if (name == "aria-roledescription"sv) {
        return "AriaRoleDescription"sv;
    } else if (name == "aria-rowcount"sv) {
        return "AriaRowCount"sv;
    } else if (name == "aria-rowindex"sv) {
        return "AriaRowIndex"sv;
    } else if (name == "aria-rowspan"sv) {
        return "AriaRowSpan"sv;
    } else if (name == "aria-selected"sv) {
        return "AriaSelected"sv;
    } else if (name == "aria-setsize"sv) {
        return "AriaSetSize"sv;
    } else if (name == "aria-sort"sv) {
        return "AriaSort"sv;
    } else if (name == "aria-valuemax"sv) {
        return "AriaValueMax"sv;
    } else if (name == "aria-valuemin"sv) {
        return "AriaValueMin"sv;
    } else if (name == "aria-valuenow"sv) {
        return "AriaValueNow"sv;
    } else if (name == "aria-valuetext"sv) {
        return "AriaValueText"sv;
    } else {
        VERIFY_NOT_REACHED();
    }
}

ErrorOr<JsonArray> translate_aria_names_to_enum(JsonArray const& names)
{
    JsonArray translated_names;
    TRY(names.try_for_each([&](JsonValue const& value) -> ErrorOr<void> {
        VERIFY(value.is_string());
        auto name = value.as_string();
        TRY(translated_names.append(aria_name_to_enum_name(name)));
        return {};
    }));
    return translated_names;
}

ErrorOr<void> generate_implementation_file(JsonObject& roles_data, Core::File& file)
{
    StringBuilder builder;
    SourceGenerator generator { builder };

    generator.append(R"~~~(
#include <LibWeb/ARIA/AriaRoles.h>

namespace Web::ARIA {
)~~~");

    TRY(roles_data.try_for_each_member([&](auto& name, auto& value) -> ErrorOr<void> {
        VERIFY(value.is_object());

        auto member_generator = TRY(generator.fork());
        member_generator.set("name"sv, name);

        JsonObject const& value_object = value.as_object();

        JsonArray const& supported_states = TRY(translate_aria_names_to_enum(value_object.get_array("supportedStates"sv).value()));
        TRY(generate_hash_table_member(member_generator, "supported_states"sv, "states"sv, "StateAndProperties"sv, supported_states));
        JsonArray const& supported_properties = TRY(translate_aria_names_to_enum(value_object.get_array("supportedProperties"sv).value()));
        TRY(generate_hash_table_member(member_generator, "supported_properties"sv, "properties"sv, "StateAndProperties"sv, supported_properties));

        JsonArray const& required_states = TRY(translate_aria_names_to_enum(value_object.get_array("requiredStates"sv).value()));
        TRY(generate_hash_table_member(member_generator, "required_states"sv, "states"sv, "StateAndProperties"sv, required_states));
        JsonArray const& required_properties = TRY(translate_aria_names_to_enum(value_object.get_array("requiredProperties"sv).value()));
        TRY(generate_hash_table_member(member_generator, "required_properties"sv, "properties"sv, "StateAndProperties"sv, required_properties));

        JsonArray const& prohibited_states = TRY(translate_aria_names_to_enum(value_object.get_array("prohibitedStates"sv).value()));
        TRY(generate_hash_table_member(member_generator, "prohibited_states"sv, "states"sv, "StateAndProperties"sv, prohibited_states));
        JsonArray const& prohibited_properties = TRY(translate_aria_names_to_enum(value_object.get_array("prohibitedProperties"sv).value()));
        TRY(generate_hash_table_member(member_generator, "prohibited_properties"sv, "properties"sv, "StateAndProperties"sv, prohibited_properties));

        JsonArray const& required_context_roles = value_object.get_array("requiredContextRoles"sv).value();
        TRY(generate_hash_table_member(member_generator, "required_context_roles"sv, "roles"sv, "Role"sv, required_context_roles));
        JsonArray const& required_owned_elements = value_object.get_array("requiredOwnedElements"sv).value();
        TRY(generate_hash_table_member(member_generator, "required_owned_elements"sv, "roles"sv, "Role"sv, required_owned_elements));

        bool accessible_name_required = value_object.get_bool("accessibleNameRequired"sv).value();
        member_generator.set("accessible_name_required"sv, accessible_name_required ? "true"sv : "false"sv);
        bool children_are_presentational = value_object.get_bool("childrenArePresentational"sv).value();
        member_generator.set("children_are_presentational", children_are_presentational ? "true"sv : "false"sv);

        JsonArray const& super_classes = value.as_object().get_array("superClassRoles"sv).value();
        member_generator.set("parent", super_classes.at(0).as_string());

        member_generator.append(R"~~~(
@name@::@name@() { }

@name@::@name@(AriaData const& data)
    : @parent@(data)
{
}

bool @name@::accessible_name_required() const
{
    return @accessible_name_required@;
}

bool @name@::children_are_presentational() const
{
    return @children_are_presentational@;
}
)~~~");

        JsonObject const& implicit_value_for_role = value_object.get_object("implicitValueForRole"sv).value();
        if (implicit_value_for_role.size() == 0) {
            member_generator.append(R"~~~(
DefaultValueType @name@::default_value_for_property_or_state(StateAndProperties) const
{
    return {};
}
)~~~");
        } else {
            member_generator.append(R"~~~(
DefaultValueType @name@::default_value_for_property_or_state(StateAndProperties state_or_property) const
{
    switch (state_or_property) {
)~~~");
            TRY(implicit_value_for_role.try_for_each_member([&](auto& name, auto& value) -> ErrorOr<void> {
                auto case_generator = TRY(member_generator.fork());
                VERIFY(value.is_string());
                case_generator.set("state_or_property"sv, aria_name_to_enum_name(name));
                case_generator.set("implicit_value"sv, value.as_string());
                case_generator.append(R"~~~(
    case StateAndProperties::@state_or_property@:
        return @implicit_value@;
)~~~");
                return {};
            }));
            member_generator.append(R"~~~(
    default:
        return {};
    }
}
)~~~");
        }

        JsonValue const& name_from_source = value.as_object().get("nameFromSource"sv).value();
        if (!name_from_source.is_null()) {
            member_generator.set("name_from_source"sv, name_from_source.as_string());
            member_generator.append(R"~~~(
NameFromSource @name@::name_from_source() const
{
    return NameFromSource::@name_from_source@;
}
)~~~");
        }

        return {};
    }));

    generator.append("}");

    TRY(file.write_until_depleted(generator.as_string_view().bytes()));
    return {};
}