Selector.h 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310
  1. /*
  2. * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
  3. * Copyright (c) 2021-2023, Sam Atkins <atkinssj@serenityos.org>
  4. *
  5. * SPDX-License-Identifier: BSD-2-Clause
  6. */
  7. #pragma once
  8. #include <AK/FlyString.h>
  9. #include <AK/RefCounted.h>
  10. #include <AK/String.h>
  11. #include <AK/Vector.h>
  12. namespace Web::CSS {
  13. using SelectorList = Vector<NonnullRefPtr<class Selector>>;
  14. // This is a <complex-selector> in the spec. https://www.w3.org/TR/selectors-4/#complex
  15. class Selector : public RefCounted<Selector> {
  16. public:
  17. enum class PseudoElement {
  18. Before,
  19. After,
  20. FirstLine,
  21. FirstLetter,
  22. Marker,
  23. ProgressValue,
  24. ProgressBar,
  25. Placeholder,
  26. // Keep this last.
  27. PseudoElementCount,
  28. };
  29. struct SimpleSelector {
  30. enum class Type {
  31. Universal,
  32. TagName,
  33. Id,
  34. Class,
  35. Attribute,
  36. PseudoClass,
  37. PseudoElement,
  38. };
  39. struct ANPlusBPattern {
  40. int step_size { 0 }; // "A"
  41. int offset = { 0 }; // "B"
  42. // https://www.w3.org/TR/css-syntax-3/#serializing-anb
  43. ErrorOr<String> serialize() const
  44. {
  45. // 1. If A is zero, return the serialization of B.
  46. if (step_size == 0) {
  47. return String::formatted("{}", offset);
  48. }
  49. // 2. Otherwise, let result initially be an empty string.
  50. StringBuilder result;
  51. // 3.
  52. // - A is 1: Append "n" to result.
  53. if (step_size == 1)
  54. TRY(result.try_append('n'));
  55. // - A is -1: Append "-n" to result.
  56. else if (step_size == -1)
  57. TRY(result.try_append("-n"sv));
  58. // - A is non-zero: Serialize A and append it to result, then append "n" to result.
  59. else if (step_size != 0)
  60. TRY(result.try_appendff("{}n", step_size));
  61. // 4.
  62. // - B is greater than zero: Append "+" to result, then append the serialization of B to result.
  63. if (offset > 0)
  64. TRY(result.try_appendff("+{}", offset));
  65. // - B is less than zero: Append the serialization of B to result.
  66. if (offset < 0)
  67. TRY(result.try_appendff("{}", offset));
  68. // 5. Return result.
  69. return result.to_string();
  70. }
  71. };
  72. struct PseudoClass {
  73. enum class Type {
  74. Link,
  75. Visited,
  76. Hover,
  77. Focus,
  78. FocusWithin,
  79. FirstChild,
  80. LastChild,
  81. OnlyChild,
  82. NthChild,
  83. NthLastChild,
  84. Empty,
  85. Root,
  86. FirstOfType,
  87. LastOfType,
  88. OnlyOfType,
  89. NthOfType,
  90. NthLastOfType,
  91. Disabled,
  92. Enabled,
  93. Checked,
  94. Is,
  95. Not,
  96. Where,
  97. Active,
  98. Lang,
  99. };
  100. Type type;
  101. // FIXME: We don't need this field on every single SimpleSelector, but it's also annoying to malloc it somewhere.
  102. // Only used when "pseudo_class" is "NthChild" or "NthLastChild".
  103. ANPlusBPattern nth_child_pattern {};
  104. SelectorList argument_selector_list {};
  105. // Used for :lang(en-gb,dk)
  106. Vector<FlyString> languages {};
  107. };
  108. struct Attribute {
  109. enum class MatchType {
  110. HasAttribute,
  111. ExactValueMatch,
  112. ContainsWord, // [att~=val]
  113. ContainsString, // [att*=val]
  114. StartsWithSegment, // [att|=val]
  115. StartsWithString, // [att^=val]
  116. EndsWithString, // [att$=val]
  117. };
  118. enum class CaseType {
  119. DefaultMatch,
  120. CaseSensitiveMatch,
  121. CaseInsensitiveMatch,
  122. };
  123. MatchType match_type;
  124. FlyString name {};
  125. String value {};
  126. CaseType case_type;
  127. };
  128. struct Name {
  129. Name(FlyString n)
  130. : name(move(n))
  131. , lowercase_name(name.to_string().to_lowercase().release_value_but_fixme_should_propagate_errors())
  132. {
  133. }
  134. FlyString name;
  135. FlyString lowercase_name;
  136. };
  137. Type type;
  138. Variant<Empty, Attribute, PseudoClass, PseudoElement, Name> value {};
  139. Attribute const& attribute() const { return value.get<Attribute>(); }
  140. Attribute& attribute() { return value.get<Attribute>(); }
  141. PseudoClass const& pseudo_class() const { return value.get<PseudoClass>(); }
  142. PseudoClass& pseudo_class() { return value.get<PseudoClass>(); }
  143. PseudoElement const& pseudo_element() const { return value.get<PseudoElement>(); }
  144. PseudoElement& pseudo_element() { return value.get<PseudoElement>(); }
  145. FlyString const& name() const { return value.get<Name>().name; }
  146. FlyString& name() { return value.get<Name>().name; }
  147. FlyString const& lowercase_name() const { return value.get<Name>().lowercase_name; }
  148. FlyString& lowercase_name() { return value.get<Name>().lowercase_name; }
  149. ErrorOr<String> serialize() const;
  150. };
  151. enum class Combinator {
  152. None,
  153. ImmediateChild, // >
  154. Descendant, // <whitespace>
  155. NextSibling, // +
  156. SubsequentSibling, // ~
  157. Column, // ||
  158. };
  159. struct CompoundSelector {
  160. // Spec-wise, the <combinator> is not part of a <compound-selector>,
  161. // but it is more understandable to put them together.
  162. Combinator combinator { Combinator::None };
  163. Vector<SimpleSelector> simple_selectors;
  164. };
  165. static NonnullRefPtr<Selector> create(Vector<CompoundSelector>&& compound_selectors)
  166. {
  167. return adopt_ref(*new Selector(move(compound_selectors)));
  168. }
  169. ~Selector() = default;
  170. Vector<CompoundSelector> const& compound_selectors() const { return m_compound_selectors; }
  171. Optional<PseudoElement> pseudo_element() const { return m_pseudo_element; }
  172. u32 specificity() const;
  173. ErrorOr<String> serialize() const;
  174. private:
  175. explicit Selector(Vector<CompoundSelector>&&);
  176. Vector<CompoundSelector> m_compound_selectors;
  177. mutable Optional<u32> m_specificity;
  178. Optional<Selector::PseudoElement> m_pseudo_element;
  179. };
  180. constexpr StringView pseudo_element_name(Selector::PseudoElement pseudo_element)
  181. {
  182. switch (pseudo_element) {
  183. case Selector::PseudoElement::Before:
  184. return "before"sv;
  185. case Selector::PseudoElement::After:
  186. return "after"sv;
  187. case Selector::PseudoElement::FirstLine:
  188. return "first-line"sv;
  189. case Selector::PseudoElement::FirstLetter:
  190. return "first-letter"sv;
  191. case Selector::PseudoElement::Marker:
  192. return "marker"sv;
  193. case Selector::PseudoElement::ProgressBar:
  194. return "-webkit-progress-bar"sv;
  195. case Selector::PseudoElement::ProgressValue:
  196. return "-webkit-progress-value"sv;
  197. case Selector::PseudoElement::Placeholder:
  198. return "placeholder"sv;
  199. case Selector::PseudoElement::PseudoElementCount:
  200. break;
  201. }
  202. VERIFY_NOT_REACHED();
  203. }
  204. Optional<Selector::PseudoElement> pseudo_element_from_string(StringView);
  205. constexpr StringView pseudo_class_name(Selector::SimpleSelector::PseudoClass::Type pseudo_class)
  206. {
  207. switch (pseudo_class) {
  208. case Selector::SimpleSelector::PseudoClass::Type::Link:
  209. return "link"sv;
  210. case Selector::SimpleSelector::PseudoClass::Type::Visited:
  211. return "visited"sv;
  212. case Selector::SimpleSelector::PseudoClass::Type::Hover:
  213. return "hover"sv;
  214. case Selector::SimpleSelector::PseudoClass::Type::Focus:
  215. return "focus"sv;
  216. case Selector::SimpleSelector::PseudoClass::Type::FocusWithin:
  217. return "focus-within"sv;
  218. case Selector::SimpleSelector::PseudoClass::Type::FirstChild:
  219. return "first-child"sv;
  220. case Selector::SimpleSelector::PseudoClass::Type::LastChild:
  221. return "last-child"sv;
  222. case Selector::SimpleSelector::PseudoClass::Type::OnlyChild:
  223. return "only-child"sv;
  224. case Selector::SimpleSelector::PseudoClass::Type::Empty:
  225. return "empty"sv;
  226. case Selector::SimpleSelector::PseudoClass::Type::Root:
  227. return "root"sv;
  228. case Selector::SimpleSelector::PseudoClass::Type::FirstOfType:
  229. return "first-of-type"sv;
  230. case Selector::SimpleSelector::PseudoClass::Type::LastOfType:
  231. return "last-of-type"sv;
  232. case Selector::SimpleSelector::PseudoClass::Type::OnlyOfType:
  233. return "only-of-type"sv;
  234. case Selector::SimpleSelector::PseudoClass::Type::NthOfType:
  235. return "nth-of-type"sv;
  236. case Selector::SimpleSelector::PseudoClass::Type::NthLastOfType:
  237. return "nth-last-of-type"sv;
  238. case Selector::SimpleSelector::PseudoClass::Type::Disabled:
  239. return "disabled"sv;
  240. case Selector::SimpleSelector::PseudoClass::Type::Enabled:
  241. return "enabled"sv;
  242. case Selector::SimpleSelector::PseudoClass::Type::Checked:
  243. return "checked"sv;
  244. case Selector::SimpleSelector::PseudoClass::Type::Active:
  245. return "active"sv;
  246. case Selector::SimpleSelector::PseudoClass::Type::NthChild:
  247. return "nth-child"sv;
  248. case Selector::SimpleSelector::PseudoClass::Type::NthLastChild:
  249. return "nth-last-child"sv;
  250. case Selector::SimpleSelector::PseudoClass::Type::Is:
  251. return "is"sv;
  252. case Selector::SimpleSelector::PseudoClass::Type::Not:
  253. return "not"sv;
  254. case Selector::SimpleSelector::PseudoClass::Type::Where:
  255. return "where"sv;
  256. case Selector::SimpleSelector::PseudoClass::Type::Lang:
  257. return "lang"sv;
  258. }
  259. VERIFY_NOT_REACHED();
  260. }
  261. ErrorOr<String> serialize_a_group_of_selectors(Vector<NonnullRefPtr<Selector>> const& selectors);
  262. }
  263. namespace AK {
  264. template<>
  265. struct Formatter<Web::CSS::Selector> : Formatter<StringView> {
  266. ErrorOr<void> format(FormatBuilder& builder, Web::CSS::Selector const& selector)
  267. {
  268. return Formatter<StringView>::format(builder, TRY(selector.serialize()));
  269. }
  270. };
  271. }