srctree

#include "css/property_id.h"

#include "css/rule.h"

 

 

#include <fmt/format.h>

 

#include <vector>

 

using namespace std::literals;

 

namespace {

 

}

 

template<class KeyT, class ValueT>

ValueT value = map.at(key);

map.erase(key);

return value;

}

 

auto rules = css::parse("p { text-decoration: underline; }").rules;

auto const &p = rules.at(0);

std::map<css::PropertyId, std::string>{

{css::PropertyId::TextDecorationColor, "currentcolor"},

{css::PropertyId::TextDecorationLine, "underline"},

});

});

 

auto rules = css::parse("p { text-decoration: underline dotted; }").rules;

auto const &p = rules.at(0);

std::map<css::PropertyId, std::string>{

{css::PropertyId::TextDecorationColor, "currentcolor"},

{css::PropertyId::TextDecorationLine, "underline"},

});

});

 

auto rules = css::parse("p { text-decoration: underline overline; }").rules;

auto const &p = rules.at(0);

});

 

auto rules = css::parse("p { text-decoration: dotted dotted; }").rules;

auto const &p = rules.at(0);

});

 

// This will fail once we support text-decoration-thickness.

auto rules = css::parse("p { text-decoration: underline 3px; }").rules;

auto const &p = rules.at(0);

});

 

// This will fail once we support text-decoration-color.

auto rules = css::parse("p { text-decoration: overline blue; }").rules;

auto const &p = rules.at(0);

});

 

auto rules = css::parse("p { text-decoration: inherit; }").rules;

auto const &p = rules.at(0);

std::map<css::PropertyId, std::string>{

{css::PropertyId::TextDecorationColor, "inherit"},

{css::PropertyId::TextDecorationLine, "inherit"},

});

}

 

auto rules = css::parse("p { outline: 5px black solid; }").rules;

auto const &p = rules.at(0);

std::map<css::PropertyId, std::string>{

{css::PropertyId::OutlineColor, "black"s},

{css::PropertyId::OutlineStyle, "solid"s},

});

});

 

auto rules = css::parse("p { outline: #123 dotted; }").rules;

auto const &p = rules.at(0);

std::map<css::PropertyId, std::string>{

{css::PropertyId::OutlineColor, "#123"s},

{css::PropertyId::OutlineStyle, "dotted"s},

});

});

 

auto rules = css::parse("p { outline: ridge 30em; }").rules;

auto const &p = rules.at(0);

std::map<css::PropertyId, std::string>{

{css::PropertyId::OutlineColor, "currentcolor"s},

{css::PropertyId::OutlineStyle, "ridge"s},

});

});

 

auto rules = css::parse("p { outline: thin; }").rules;

auto const &p = rules.at(0);

std::map<css::PropertyId, std::string>{

{css::PropertyId::OutlineColor, "currentcolor"s},

{css::PropertyId::OutlineStyle, "none"s},

});

});

 

auto rules = css::parse("p { outline: .3em; }").rules;

auto const &p = rules.at(0);

std::map<css::PropertyId, std::string>{

{css::PropertyId::OutlineColor, "currentcolor"s},

{css::PropertyId::OutlineStyle, "none"s},

});

});

 

auto rules = css::parse("p { outline: outset #123 none solid; }").rules;

auto const &p = rules[0];

});

}

 

} // namespace

 

int main() {

 

auto rules = css::parse("body { width: 50px; }"sv).rules;

 

auto body = rules[0];

});

 

auto rules = css::parse("body { width: 50px !important; }"sv).rules;

 

auto body = rules[0];

});

 

auto rules = css::parse("p a { color: green; }").rules;

std::vector<css::Rule>{{

.selectors{{"p a"}},

.declarations{{css::PropertyId::Color, "green"}},

}});

});

 

auto rules = css::parse("p { color: green ; }").rules;

std::vector<css::Rule>{{

.selectors{{"p"}},

.declarations{{css::PropertyId::Color, "green"}},

}});

});

 

auto rules = css::parse("body{width:50px;font-family:inherit}head,p{display:none}"sv).rules;

 

auto first = rules[0];

 

auto second = rules[1];

});

 

auto rules = css::parse("body { width: 50px; }\np { font-size: 8em; }"sv).rules;

 

auto body = rules[0];

 

auto p = rules[1];

});

 

auto rules = css::parse("body, p { width: 50px; }"sv).rules;

 

auto body = rules[0];

});

 

auto rules = css::parse("body { width: 50px; height: 300px; }"sv).rules;

 

auto body = rules[0];

});

 

auto rules = css::parse(".cls { width: 50px; }"sv).rules;

 

auto body = rules[0];

});

 

auto rules = css::parse("#cls { width: 50px; }"sv).rules;

 

auto body = rules[0];

});

 

auto rules = css::parse("body {}"sv).rules;

 

auto body = rules[0];

});

 

auto rules = css::parse(""sv).rules;

});

 

auto rules = css::parse("body { width: 50px; }/* comment. */ p { font-size: 8em; } /* comment. */"sv).rules;

 

auto body = rules[0];

 

auto p = rules[1];

});

 

// body { width: 50px; } p { padding: 8em 4em; } with comments added everywhere currently supported.

auto rules = css::parse(R"(/**/body {/**/width:50px;/**/}/*

*/p {/**/padding:/**/8em 4em;/**//**/}/**/)"sv)

// TODO(robinlinden): Support comments in more places.

// auto rules = css::parse(R"(/**/body/**/{/**/width/**/:/**/50px/**/;/**/}/*

// */p/**/{/**/padding/**/:/**/8em/**/4em/**/;/**//**/}/**/)"sv).rules;

 

auto body = rules[0];

 

auto p = rules[1];

});

 

auto rules = css::parse(R"(

@media (min-width: 900px) {

article { width: 50px; }

}

a { background-color: indigo; })"sv)

.rules;

 

auto article = rules[0];

 

auto p = rules[1];

 

});

 

auto rules = css::parse("@media(max-width:300px){p{font-size:10px;}}").rules;

auto const &rule = rules[0];

});

 

auto rules = css::parse("@media (rip: 0) { p { font-size: 10px; } }").rules;

auto const &rule = rules.at(0);

});

 

auto rules = css::parse(

"@media (max-width: 1px) { p { font-size: 1em; } } @media (min-width: 2px) { a { color: blue; } }")

.rules;

css::Rule{.selectors{{"p"}},

.declarations{{css::PropertyId::FontSize, "1em"}},

.media_query{css::MediaQuery{css::MediaQuery::Width{.max = 1}}}});

css::Rule{.selectors{{"a"}},

.declarations{{css::PropertyId::Color, "blue"}},

.media_query{css::MediaQuery{css::MediaQuery::Width{.min = 2}}}});

});

 

auto box_shorthand_one_value = [](std::string property, std::string value, std::string post_fix = "") {

auto rules = css::parse(fmt::format("p {{ {}: {}; }}"sv, property, value)).rules;

 

if (property == "border-style" || property == "border-color" || property == "border-width") {

property = "border";

}

 

auto body = rules[0];

== value);

== value);

== value);

== value);

};

};

 

{

std::string size_value{"10px"};

 

std::string border_style{"dashed"};

box_shorthand_one_value("border-style", border_style, "-style"));

 

"parser: shorthand border-color, one value", box_shorthand_one_value("border-color", "red", "-color"));

 

"parser: shorthand border-width, one value", box_shorthand_one_value("border-width", "10px", "-width"));

}

 

auto box_shorthand_two_values = [](std::string property,

std::array<std::string, 2> values,

std::string post_fix = "") {

auto rules = css::parse(fmt::format("p {{ {}: {} {}; }}"sv, property, values[0], values[1])).rules;

 

if (property == "border-style") {

property = "border";

}

 

auto body = rules[0];

== values[0]);

== values[0]);

== values[1]);

== values[1]);

};

};

 

{

auto size_values = std::array{"12em"s, "36em"s};

 

auto border_styles = std::array{"dashed"s, "solid"s};

box_shorthand_two_values("border-style", border_styles, "-style"));

}

 

auto box_shorthand_three_values = [](std::string property,

std::array<std::string, 3> values,

std::string post_fix = "") {

auto rules =

css::parse(fmt::format("p {{ {}: {} {} {}; }}"sv, property, values[0], values[1], values[2])).rules;

 

if (property == "border-style") {

property = "border";

}

 

auto body = rules[0];

== values[0]);

== values[2]);

== values[1]);

== values[1]);

};

};

 

{

auto size_values = std::array{"12em"s, "36em"s, "52px"s};

 

auto border_styles = std::array{"groove"s, "dashed"s, "solid"s};

box_shorthand_three_values("border-style", border_styles, "-style"));

}

 

auto box_shorthand_four_values = [](std::string property,

std::array<std::string, 4> values,

std::string post_fix = "") {

auto rules = css::parse(

fmt::format("p {{ {}: {} {} {} {}; }}"sv, property, values[0], values[1], values[2], values[3]))

.rules;

 

if (property == "border-style" || property == "border-color" || property == "border-width") {

property = "border";

}

 

auto body = rules[0];

== values[0]);

== values[2]);

== values[3]);

== values[1]);

};

};

 

{

auto size_values = std::array{"12px"s, "36px"s, "52px"s, "2"s};

 

auto border_styles = std::array{"groove"s, "dashed"s, "solid"s, "dotted"s};

box_shorthand_four_values("border-style", border_styles, "-style"));

 

box_shorthand_four_values("border-color", std::array{"red"s, "green"s, "blue"s, "cyan"s}, "-color"));

 

box_shorthand_four_values("border-width", size_values, "-width"));

}

 

auto box_shorthand_overridden = [](std::string property,

std::array<std::string, 3> values,

std::string post_fix = "") {

std::string workaround_for_border_style = property == "border-style" ? "border" : property;

auto rules = css::parse(fmt::format(R"(

p {{

values[2],

workaround_for_border_style))

.rules;

 

if (property == "border-style") {

property = "border";

}

 

auto body = rules[0];

values[1]);

== values[0]);

== values[2]);

== values[0]);

};

};

 

{

auto size_values = std::array{"10px"s, "15px"s, "25px"s};

 

auto border_styles = std::array{"dashed"s, "solid"s, "dotted"s};

box_shorthand_overridden("border-style", border_styles, "-style"));

}

 

auto box_override_with_shorthand = [](std::string property,

std::array<std::string, 4> values,

std::string post_fix = "") {

std::string workaround_for_border_style = property == "border-style" ? "border" : property;

auto rules = css::parse(fmt::format(R"(

p {{

values[3],

workaround_for_border_style))

.rules;

 

if (property == "border-style") {

property = "border";

}

 

auto body = rules[0];

== values[2]);

== values[2]);

== values[3]);

== values[3]);

};

};

 

{

auto size_values = std::array{"5px"s, "25px"s, "12px"s, "40px"s};

 

auto border_styles = std::array{"dashed"s, "solid"s, "hidden"s, "dotted"s};

box_override_with_shorthand("border-style", border_styles, "-style"));

}

 

auto rules = css::parse("p { background: red }"sv).rules;

 

auto &p = rules[0];

});

 

auto rules = css::parse("p { font: 1.5em sans-serif; }"sv).rules;

 

auto body = rules[0];

});

 

auto rules = css::parse("p { font: 10%/2.5 monospace; }"sv).rules;

 

auto body = rules[0];

});

 

auto rules = css::parse(R"(p { font: x-large/110% "New Century Schoolbook", serif; })"sv).rules;

 

auto body = rules[0];

});

 

auto rules = css::parse(R"(p { font: italic 120% "Helvetica Neue", serif; })"sv).rules;

 

auto body = rules[0];

});

 

auto rules = css::parse(R"(p { font: oblique 12pt "Helvetica Neue", serif; })"sv).rules;

 

auto body = rules[0];

});

 

auto rules = css::parse("p { font: oblique 25deg 10px serif; }"sv).rules;

 

auto body = rules[0];

});

 

auto rules = css::parse("p { font: italic bold 20em/50% serif; }"sv).rules;

 

auto body = rules[0];

});

 

auto rules = css::parse("p { font: normal bolder 100px serif; }"sv).rules;

 

auto body = rules[0];

});

 

auto rules = css::parse("p { font: lighter 100px serif; }"sv).rules;

 

auto body = rules[0];

});

 

auto rules = css::parse("p { font: 1000 oblique 100px serif; }"sv).rules;

 

auto body = rules[0];

});

 

auto rules = css::parse("p { font: italic 550 100px serif; }"sv).rules;

 

auto body = rules[0];

});

 

auto rules = css::parse("p { font: oblique 1 100px serif; }"sv).rules;

 

auto body = rules[0];

});

 

auto rules = css::parse("p { font: small-caps 900 100px serif; }"sv).rules;

 

auto body = rules[0];

});

 

auto rules = css::parse(R"(p { font: condensed oblique 25deg 753 12pt "Helvetica Neue", serif; })"sv).rules;

 

auto body = rules[0];

});

 

auto rules = css::parse("p { font: italic expanded bold xx-smal/80% monospace; }"sv).rules;

 

auto body = rules[0];

});

 

auto rules = css::parse("p { font: status-bar; }"sv).rules;

 

auto p = rules[0];

});

 

auto rules = css::parse("p { font: small-caps italic ultra-expanded bold medium Arial, monospace; }"sv).rules;

 

auto body = rules[0];

});

 

auto rules = css::parse("div { border-radius: 5px; }").rules;

auto const &div = rules[0];

std::map<css::PropertyId, std::string>{

{css::PropertyId::BorderTopLeftRadius, "5px"s},

{css::PropertyId::BorderTopRightRadius, "5px"s},

});

});

 

auto rules = css::parse("div { border-radius: 1px 2px; }").rules;

auto const &div = rules[0];

std::map<css::PropertyId, std::string>{

{css::PropertyId::BorderTopLeftRadius, "1px"s},

{css::PropertyId::BorderTopRightRadius, "2px"s},

});

});

 

auto rules = css::parse("div { border-radius: 1px 2px 3px; }").rules;

auto const &div = rules[0];

std::map<css::PropertyId, std::string>{

{css::PropertyId::BorderTopLeftRadius, "1px"s},

{css::PropertyId::BorderTopRightRadius, "2px"s},

});

});

 

auto rules = css::parse("div { border-radius: 1px 2px 3px 4px; }").rules;

auto const &div = rules[0];

std::map<css::PropertyId, std::string>{

{css::PropertyId::BorderTopLeftRadius, "1px"s},

{css::PropertyId::BorderTopRightRadius, "2px"s},

});

});

 

auto rules = css::parse("div { border-radius: 5px / 10px; }").rules;

auto const &div = rules[0];

std::map<css::PropertyId, std::string>{

{css::PropertyId::BorderTopLeftRadius, "5px / 10px"s},

{css::PropertyId::BorderTopRightRadius, "5px / 10px"s},

});

});

 

auto rules = css::parse("div { border-radius: 5px / 10px 15px; }").rules;

auto const &div = rules[0];

std::map<css::PropertyId, std::string>{

{css::PropertyId::BorderTopLeftRadius, "5px / 10px"s},

{css::PropertyId::BorderTopRightRadius, "5px / 15px"s},

});

});

 

auto rules = css::parse("div { border-radius: 5px / 10px 15px 20px; }").rules;

auto const &div = rules[0];

std::map<css::PropertyId, std::string>{

{css::PropertyId::BorderTopLeftRadius, "5px / 10px"s},

{css::PropertyId::BorderTopRightRadius, "5px / 15px"s},

});

});

 

auto rules = css::parse("div { border-radius: 5px / 10px 15px 20px 25px; }").rules;

auto const &div = rules[0];

std::map<css::PropertyId, std::string>{

{css::PropertyId::BorderTopLeftRadius, "5px / 10px"s},

{css::PropertyId::BorderTopRightRadius, "5px / 15px"s},

});

});

 

auto rules = css::parse("div { border-radius: 5px / 10px 15px 20px 25px 30px; }").rules;

auto const &div = rules[0];

std::map<css::PropertyId, std::string>{

{css::PropertyId::BorderTopLeftRadius, "5px"s},

{css::PropertyId::BorderTopRightRadius, "5px"s},

});

});

 

auto css = R"(

@keyframes toast-spinner {

from {

 

// No rules produced (yet!) since this isn't handled aside from not crashing.

auto rules = css::parse(css).rules;

});

 

auto css = R"(

@keyframes toast-spinner {

from { transform: rotate(0deg) }

 

// No rules produced (yet!) since this isn't handled aside from not crashing.

auto rules = css::parse(css).rules;

});

 

// This isn't correct, but it doesn't crash.

auto css = R"(

@font-face {

})"sv;

 

auto rules = css::parse(css).rules;

 

// Very incorrect.

auto const &src = rules[0].declarations.at(css::PropertyId::Unknown);

});

 

auto rules = css::parse("p { border: 5px black solid; }").rules;

auto const &p = rules[0];

std::map<css::PropertyId, std::string>{

{css::PropertyId::BorderBottomColor, "black"s},

{css::PropertyId::BorderBottomStyle, "solid"s},

});

});

 

auto rules = css::parse("p { border-bottom: #123 dotted; }").rules;

auto const &p = rules[0];

std::map<css::PropertyId, std::string>{

{css::PropertyId::BorderBottomColor, "#123"s},

{css::PropertyId::BorderBottomStyle, "dotted"s},

});

});

 

auto rules = css::parse("p { border-left: ridge 30em; }").rules;

auto const &p = rules[0];

std::map<css::PropertyId, std::string>{

{css::PropertyId::BorderLeftColor, "currentcolor"s},

{css::PropertyId::BorderLeftStyle, "ridge"s},

});

});

 

auto rules = css::parse("p { border-right: thin; }").rules;

auto const &p = rules[0];

std::map<css::PropertyId, std::string>{

{css::PropertyId::BorderRightColor, "currentcolor"s},

{css::PropertyId::BorderRightStyle, "none"s},

});

});

 

auto rules = css::parse("p { border-right: .3em; }").rules;

auto const &p = rules[0];

std::map<css::PropertyId, std::string>{

{css::PropertyId::BorderRightColor, "currentcolor"s},

{css::PropertyId::BorderRightStyle, "none"s},

});

});

 

auto rules = css::parse("p { border-top: outset #123 none solid; }").rules;

auto const &p = rules[0];

});

 

std::ignore = css::parse("@media("); //

});

 

std::ignore = css::parse("@lol"); //

});

 

std::ignore = css::parse("@lol ");

std::ignore = css::parse("@lol { p {"); //

});

 

std::ignore = css::parse("p");

std::ignore = css::parse("p {");

std::ignore = css::parse("p { font-size:");

});

 

std::map<css::PropertyId, std::string>{

{css::PropertyId::FlexDirection, "revert"s},

{css::PropertyId::FlexWrap, "revert"s},

});

std::map<css::PropertyId, std::string>{});

});

 

std::map<css::PropertyId, std::string>{

{css::PropertyId::FlexDirection, "column"s},

{css::PropertyId::FlexWrap, "nowrap"s},

});

std::map<css::PropertyId, std::string>{

{css::PropertyId::FlexDirection, "row"s},

{css::PropertyId::FlexWrap, "wrap"s},

});

std::map<css::PropertyId, std::string>{});

});

 

std::map<css::PropertyId, std::string>{

{css::PropertyId::FlexDirection, "column"s},

{css::PropertyId::FlexWrap, "wrap"s},

});

std::map<css::PropertyId, std::string>{});

std::map<css::PropertyId, std::string>{});

});

 

std::map<css::PropertyId, std::string>{});

});

 

css::Rule{.selectors = {{"p"}}, .custom_properties = {{"--var", "value"}}});

});

 

// TODO(robinlinden): Nested rules are currently skipped, but at least

// they mostly don't break parsing of the rule they're nested in.

std::vector{

css::Rule{

.selectors = {{"p"}},

});

});

 

});

 

std::map<css::PropertyId, std::string>{{css::PropertyId::Unknown, "3px"}});

});

 

css::Rule{.selectors = {{"p"}}, .declarations{{css::PropertyId::FontSize, "3px"}}});

});

 

});

 

}

 

#include "css/media_query.h"

#include "css/property_id.h"

 

 

int main() {

css::Rule rule;

rule.selectors.emplace_back("div");

rule.declarations.emplace(css::PropertyId::BackgroundColor, "black");

"Selectors: div\n"

"Declarations:\n"

" background-color: black\n";

});

 

css::Rule rule;

rule.selectors.emplace_back("h1");

rule.selectors.emplace_back("h2");

" color: blue\n"

" font-family: Arial\n"

" text-align: center\n";

});

 

css::Rule rule;

rule.selectors.emplace_back("h1");

rule.declarations.emplace(css::PropertyId::Color, "blue");

" text-align: center\n"

"Media query:\n"

" 0 <= width <= 900\n";

});

 

css::Rule rule;

rule.selectors.emplace_back("div");

rule.important_declarations.emplace(css::PropertyId::BackgroundColor, "black");

"Declarations:\n"

"Important declarations:\n"

" background-color: black\n";

});

 

css::Rule rule;

rule.selectors.emplace_back("div");

rule.custom_properties.emplace("--ping", "pong");

"Declarations:\n"

"Custom properties:\n"

" --ping: pong\n";

});

 

}