beenull/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-25 17:10:23 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 7

LibWeb: Make serializing selectors infallible

Browse source
This commit is contained in:
Sam Atkins 2023-08-22 12:45:29 +01:00 committed by Sam Atkins
parent afa27bad19
commit 91114c157b
Notes: sideshowbarker 2024-07-17 08:42:05 +09:00 
Author: https://github.com/AtkinsSJ
Commit: https://github.com/SerenityOS/serenity/commit/91114c157b
Pull-request: https://github.com/SerenityOS/serenity/pull/20709
3 changed files with 60 additions and 60 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
Userland/Libraries/LibWeb/CSS/CSSStyleRule.cpp
View file

@ -49,7 +49,7 @@ DeprecatedString CSSStyleRule::serialized() const
// 1. Let s initially be the result of performing serialize a group of selectors on the rule’s associated selectors,
// followed by the string " {", i.e., a single SPACE (U+0020), followed by LEFT CURLY BRACKET (U+007B).
builder.append(serialize_a_group_of_selectors(selectors()).release_value_but_fixme_should_propagate_errors());
builder.append(serialize_a_group_of_selectors(selectors()));
builder.append(" {"sv);
// 2. Let decls be the result of performing serialize a CSS declaration block on the rule’s associated declarations, or null if there are no such declarations.
@ -90,7 +90,7 @@ DeprecatedString CSSStyleRule::serialized() const
DeprecatedString CSSStyleRule::selector_text() const
{
// The selectorText attribute, on getting, must return the result of serializing the associated group of selectors.
return serialize_a_group_of_selectors(selectors()).release_value_but_fixme_should_propagate_errors().to_deprecated_string();
return serialize_a_group_of_selectors(selectors()).to_deprecated_string();
}
// https://www.w3.org/TR/cssom/#dom-cssstylerule-selectortext

92
Userland/Libraries/LibWeb/CSS/Selector.cpp
View file

@ -119,7 +119,7 @@ u32 Selector::specificity() const
}
// https://www.w3.org/TR/cssom/#serialize-a-simple-selector
ErrorOr<String> Selector::SimpleSelector::serialize() const
String Selector::SimpleSelector::serialize() const
{
StringBuilder s;
switch (type) {
@ -131,13 +131,13 @@ ErrorOr<String> Selector::SimpleSelector::serialize() const
// followed by a "|" (U+007C) to s.
if (qualified_name.namespace_type == QualifiedName::NamespaceType::Named) {
serialize_an_identifier(s, qualified_name.namespace_);
TRY(s.try_append('|'));
s.append('|');
}
// 2. If the namespace prefix maps to a namespace that is the null namespace (not in a namespace)
// append "|" (U+007C) to s.
if (qualified_name.namespace_type == QualifiedName::NamespaceType::None)
TRY(s.try_append('|'));
s.append('|');
// 3. If this is a type selector append the serialization of the element name as an identifier to s.
if (type == Selector::SimpleSelector::Type::TagName)
@ -145,7 +145,7 @@ ErrorOr<String> Selector::SimpleSelector::serialize() const
// 4. If this is a universal selector append "*" (U+002A) to s.
if (type == Selector::SimpleSelector::Type::Universal)
TRY(s.try_append('*'));
s.append('*');
break;
}
@ -153,13 +153,13 @@ ErrorOr<String> Selector::SimpleSelector::serialize() const
auto& attribute = this->attribute();
// 1. Append "[" (U+005B) to s.
TRY(s.try_append('['));
s.append('[');
// 2. If the namespace prefix maps to a namespace that is not the null namespace (not in a namespace)
// append the serialization of the namespace prefix as an identifier, followed by a "|" (U+007C) to s.
if (attribute.qualified_name.namespace_type == QualifiedName::NamespaceType::Named) {
serialize_an_identifier(s, attribute.qualified_name.namespace_);
TRY(s.try_append('|'));
s.append('|');
}
// 3. Append the serialization of the attribute name as an identifier to s.
@ -170,22 +170,22 @@ ErrorOr<String> Selector::SimpleSelector::serialize() const
if (!attribute.value.is_empty()) {
switch (attribute.match_type) {
case Selector::SimpleSelector::Attribute::MatchType::ExactValueMatch:
TRY(s.try_append("="sv));
s.append("="sv);
break;
case Selector::SimpleSelector::Attribute::MatchType::ContainsWord:
TRY(s.try_append("~="sv));
s.append("~="sv);
break;
case Selector::SimpleSelector::Attribute::MatchType::ContainsString:
TRY(s.try_append("*="sv));
s.append("*="sv);
break;
case Selector::SimpleSelector::Attribute::MatchType::StartsWithSegment:
TRY(s.try_append("|="sv));
s.append("|="sv);
break;
case Selector::SimpleSelector::Attribute::MatchType::StartsWithString:
TRY(s.try_append("^="sv));
s.append("^="sv);
break;
case Selector::SimpleSelector::Attribute::MatchType::EndsWithString:
TRY(s.try_append("$="sv));
s.append("$="sv);
break;
default:
break;
@ -199,29 +199,29 @@ ErrorOr<String> Selector::SimpleSelector::serialize() const
// (the line just above is an addition to CSS OM to match Selectors Level 4 last draft)
switch (attribute.case_type) {
case Selector::SimpleSelector::Attribute::CaseType::CaseInsensitiveMatch:
TRY(s.try_append(" i"sv));
s.append(" i"sv);
break;
case Selector::SimpleSelector::Attribute::CaseType::CaseSensitiveMatch:
TRY(s.try_append(" s"sv));
s.append(" s"sv);
break;
default:
break;
}
// 6. Append "]" (U+005D) to s.
TRY(s.try_append(']'));
s.append(']');
break;
}
case Selector::SimpleSelector::Type::Class:
// Append a "." (U+002E), followed by the serialization of the class name as an identifier to s.
TRY(s.try_append('.'));
s.append('.');
serialize_an_identifier(s, name());
break;
case Selector::SimpleSelector::Type::Id:
// Append a "#" (U+0023), followed by the serialization of the ID as an identifier to s.
TRY(s.try_append('#'));
s.append('#');
serialize_an_identifier(s, name());
break;
@ -233,44 +233,44 @@ ErrorOr<String> Selector::SimpleSelector::serialize() const
// It's also not in the spec.
if (pseudo_class.type == PseudoClass::Host) {
if (pseudo_class.argument_selector_list.is_empty()) {
TRY(s.try_append(':'));
TRY(s.try_append(pseudo_class_name(pseudo_class.type)));
s.append(':');
s.append(pseudo_class_name(pseudo_class.type));
} else {
TRY(s.try_append(':'));
TRY(s.try_append(pseudo_class_name(pseudo_class.type)));
TRY(s.try_append('('));
TRY(s.try_append(TRY(serialize_a_group_of_selectors(pseudo_class.argument_selector_list))));
TRY(s.try_append(')'));
s.append(':');
s.append(pseudo_class_name(pseudo_class.type));
s.append('(');
s.append(serialize_a_group_of_selectors(pseudo_class.argument_selector_list));
s.append(')');
}
}
// If the pseudo-class does not accept arguments append ":" (U+003A), followed by the name of the pseudo-class, to s.
else if (metadata.is_valid_as_identifier) {
TRY(s.try_append(':'));
TRY(s.try_append(pseudo_class_name(pseudo_class.type)));
s.append(':');
s.append(pseudo_class_name(pseudo_class.type));
}
// Otherwise, append ":" (U+003A), followed by the name of the pseudo-class, followed by "(" (U+0028),
// followed by the value of the pseudo-class argument(s) determined as per below, followed by ")" (U+0029), to s.
else {
TRY(s.try_append(':'));
TRY(s.try_append(pseudo_class_name(pseudo_class.type)));
TRY(s.try_append('('));
s.append(':');
s.append(pseudo_class_name(pseudo_class.type));
s.append('(');
if (pseudo_class.type == PseudoClass::NthChild
|| pseudo_class.type == PseudoClass::NthLastChild
|| pseudo_class.type == PseudoClass::NthOfType
|| pseudo_class.type == PseudoClass::NthLastOfType) {
// The result of serializing the value using the rules to serialize an <an+b> value.
TRY(s.try_append(TRY(pseudo_class.nth_child_pattern.serialize())));
s.append(pseudo_class.nth_child_pattern.serialize());
} else if (pseudo_class.type == PseudoClass::Not
|| pseudo_class.type == PseudoClass::Is
|| pseudo_class.type == PseudoClass::Where) {
// The result of serializing the value using the rules for serializing a group of selectors.
// NOTE: `:is()` and `:where()` aren't in the spec for this yet, but it should be!
TRY(s.try_append(TRY(serialize_a_group_of_selectors(pseudo_class.argument_selector_list))));
s.append(serialize_a_group_of_selectors(pseudo_class.argument_selector_list));
} else if (pseudo_class.type == PseudoClass::Lang) {
// The serialization of a comma-separated list of each argument’s serialization as a string, preserving relative order.
s.join(", "sv, pseudo_class.languages);
}
TRY(s.try_append(')'));
s.append(')');
}
break;
}
@ -281,11 +281,11 @@ ErrorOr<String> Selector::SimpleSelector::serialize() const
dbgln("FIXME: Unsupported simple selector serialization for type {}", to_underlying(type));
break;
}
return s.to_string();
return MUST(s.to_string());
}
// https://www.w3.org/TR/cssom/#serialize-a-selector
ErrorOr<String> Selector::serialize() const
String Selector::serialize() const
{
StringBuilder s;
@ -295,7 +295,7 @@ ErrorOr<String> Selector::serialize() const
// 1. If there is only one simple selector in the compound selectors which is a universal selector, append the result of serializing the universal selector to s.
if (compound_selector.simple_selectors.size() == 1
&& compound_selector.simple_selectors.first().type == Selector::SimpleSelector::Type::Universal) {
TRY(s.try_append(TRY(compound_selector.simple_selectors.first().serialize())));
s.append(compound_selector.simple_selectors.first().serialize());
}
// 2. Otherwise, for each simple selector in the compound selectors that is not a universal selector
// of which the namespace prefix maps to a namespace that is not the default namespace
@ -314,7 +314,7 @@ ErrorOr<String> Selector::serialize() const
// foo|*.bar { } /* This would skip the `foo|*` when serializing. */
// </style>
}
TRY(s.try_append(TRY(simple_selector.serialize())));
s.append(simple_selector.serialize());
}
}
@ -322,21 +322,21 @@ ErrorOr<String> Selector::serialize() const
// followed by the combinator ">", "+", "~", ">>", "||", as appropriate, followed by another
// single SPACE (U+0020) if the combinator was not whitespace, to s.
if (i != compound_selectors().size() - 1) {
TRY(s.try_append(' '));
s.append(' ');
// Note: The combinator that appears between parts `i` and `i+1` appears with the `i+1` selector,
// so we have to check that one.
switch (compound_selectors()[i + 1].combinator) {
case Selector::Combinator::ImmediateChild:
TRY(s.try_append("> "sv));
s.append("> "sv);
break;
case Selector::Combinator::NextSibling:
TRY(s.try_append("+ "sv));
s.append("+ "sv);
break;
case Selector::Combinator::SubsequentSibling:
TRY(s.try_append("~ "sv));
s.append("~ "sv);
break;
case Selector::Combinator::Column:
TRY(s.try_append("|| "sv));
s.append("|| "sv);
break;
default:
break;
@ -345,20 +345,20 @@ ErrorOr<String> Selector::serialize() const
// 4. If this is the last part of the chain of the selector and there is a pseudo-element,
// append "::" followed by the name of the pseudo-element, to s.
if (compound_selector.simple_selectors.last().type == Selector::SimpleSelector::Type::PseudoElement) {
TRY(s.try_append("::"sv));
TRY(s.try_append(pseudo_element_name(compound_selector.simple_selectors.last().pseudo_element())));
s.append("::"sv);
s.append(pseudo_element_name(compound_selector.simple_selectors.last().pseudo_element()));
}
}
}
return s.to_string();
return MUST(s.to_string());
}
// https://www.w3.org/TR/cssom/#serialize-a-group-of-selectors
ErrorOr<String> serialize_a_group_of_selectors(Vector<NonnullRefPtr<Selector>> const& selectors)
String serialize_a_group_of_selectors(Vector<NonnullRefPtr<Selector>> const& selectors)
{
// To serialize a group of selectors serialize each selector in the group of selectors and then serialize a comma-separated list of these serializations.
return String::join(", "sv, selectors);
return MUST(String::join(", "sv, selectors));
}
Optional<Selector::PseudoElement> pseudo_element_from_string(StringView name)

24
Userland/Libraries/LibWeb/CSS/Selector.h
View file

@ -52,11 +52,11 @@ public:
int offset = { 0 }; // "B"
// https://www.w3.org/TR/css-syntax-3/#serializing-anb
ErrorOr<String> serialize() const
String serialize() const
{
// 1. If A is zero, return the serialization of B.
if (step_size == 0) {
return String::formatted("{}", offset);
return MUST(String::number(offset));
}
// 2. Otherwise, let result initially be an empty string.
@ -65,24 +65,24 @@ public:
// 3.
// - A is 1: Append "n" to result.
if (step_size == 1)
TRY(result.try_append('n'));
result.append('n');
// - A is -1: Append "-n" to result.
else if (step_size == -1)
TRY(result.try_append("-n"sv));
result.append("-n"sv);
// - A is non-zero: Serialize A and append it to result, then append "n" to result.
else if (step_size != 0)
TRY(result.try_appendff("{}n", step_size));
result.appendff("{}n", step_size);
// 4.
// - B is greater than zero: Append "+" to result, then append the serialization of B to result.
if (offset > 0)
TRY(result.try_appendff("+{}", offset));
result.appendff("+{}", offset);
// - B is less than zero: Append the serialization of B to result.
if (offset < 0)
TRY(result.try_appendff("{}", offset));
result.appendff("{}", offset);
// 5. Return result.
return result.to_string();
return MUST(result.to_string());
}
};
@ -165,7 +165,7 @@ public:
QualifiedName const& qualified_name() const { return value.get<QualifiedName>(); }
QualifiedName& qualified_name() { return value.get<QualifiedName>(); }
ErrorOr<String> serialize() const;
String serialize() const;
};
enum class Combinator {
@ -194,7 +194,7 @@ public:
Vector<CompoundSelector> const& compound_selectors() const { return m_compound_selectors; }
Optional<PseudoElement> pseudo_element() const { return m_pseudo_element; }
u32 specificity() const;
ErrorOr<String> serialize() const;
String serialize() const;
private:
explicit Selector(Vector<CompoundSelector>&&);
@ -233,7 +233,7 @@ constexpr StringView pseudo_element_name(Selector::PseudoElement pseudo_element)
Optional<Selector::PseudoElement> pseudo_element_from_string(StringView);
ErrorOr<String> serialize_a_group_of_selectors(Vector<NonnullRefPtr<Selector>> const& selectors);
String serialize_a_group_of_selectors(Vector<NonnullRefPtr<Selector>> const& selectors);
}
@ -243,7 +243,7 @@ template<>
struct Formatter<Web::CSS::Selector> : Formatter<StringView> {
ErrorOr<void> format(FormatBuilder& builder, Web::CSS::Selector const& selector)
{
return Formatter<StringView>::format(builder, TRY(selector.serialize()));
return Formatter<StringView>::format(builder, selector.serialize());
}
};