use std::path::{Path, PathBuf};
use super::rerun;
use crate::css_lex::{Lang, Role, lex, matching_close};
use makeover_geometry::Density;
mod breakpoints;
mod vocabulary_use;
pub use breakpoints::Breakpoints;
pub use vocabulary_use::{Allow, Vocabulary, check_vocabulary_use};
const CONST_NAME: &str = "TOUCH_DENSITY";
const SNIFFS: &[&str] = &["ontouchstart", "maxTouchPoints"];
pub fn check_touch_density(js_dir: impl AsRef<Path>) {
let js_dir = js_dir.as_ref();
let want = Density::Touch.media_condition();
let mut wrong: Vec<String> = Vec::new();
let mut found = 0usize;
let files = js_files(js_dir);
for path in &files {
let raw = read(path);
let src = blank(&raw, Lang::Js);
let name = shown(path, Some(js_dir));
for (offset, literal) in touch_density_literals(&src) {
found += 1;
if literal != want {
wrong.push(format!(
" {name}:{} {CONST_NAME} = '{literal}'",
line_of(&src, offset)
));
}
}
for needle in SNIFFS {
if let Some(offset) = src.find(needle) {
wrong.push(format!(
" {name}:{} {needle} -- device sniff, not a density question",
line_of(&src, offset)
));
}
}
}
assert!(
found > 0,
"no {CONST_NAME} literal found under {}.\n\n\
A frontend that asks whether it is being touched states\n\
makeover_geometry::Density::Touch's media condition in a const of that\n\
name, and this check exists to keep every copy equal to it. If the\n\
const was renamed, rename it back rather than dropping the check; if\n\
this frontend genuinely asks no density question, drop the call.",
js_dir.display()
);
assert!(
wrong.is_empty(),
"hand-written touch detection disagrees with makeover_geometry::Density.\n\n\
Density::Touch.media_condition() is: {want}\n\n\
Wrong:\n{}\n\n\
Fix the JS to state the crate's string. Never widen it to catch a\n\
device the query misses: density is what is pointing at the screen,\n\
and a laptop with a touchscreen and a mouse is a pointer device.",
wrong.join("\n")
);
for path in &files {
rerun(path);
}
rerun(js_dir);
}
fn read(path: &Path) -> String {
std::fs::read_to_string(path).unwrap_or_else(|e| panic!("read {}: {e}", path.display()))
}
fn shown(path: &Path, root: Option<&Path>) -> String {
root.and_then(|root| path.strip_prefix(root).ok())
.unwrap_or(path)
.display()
.to_string()
}
fn frontend_css(frontend: &Path) -> (PathBuf, Vec<PathBuf>) {
let css = frontend.join("css");
rerun(&css);
let files = files_with_extension(&css, "css");
(css, files)
}
fn js_files(dir: &Path) -> Vec<PathBuf> {
files_with_extension(dir, "js")
}
fn files_with_extension(dir: &Path, ext: &str) -> Vec<PathBuf> {
let mut out = Vec::new();
let mut stack = vec![dir.to_path_buf()];
while let Some(d) = stack.pop() {
for entry in std::fs::read_dir(&d)
.unwrap_or_else(|e| panic!("read {}: {e}", d.display()))
.flatten()
{
let path = entry.path();
if path.is_dir() {
stack.push(path);
} else if path.extension().is_some_and(|x| x == ext) {
out.push(path);
}
}
}
out.sort();
out
}
fn touch_density_literals(src: &str) -> Vec<(usize, &str)> {
let mut out = Vec::new();
let mut at = 0;
while let Some(i) = src[at..].find(CONST_NAME) {
let start = at + i;
at = start + CONST_NAME.len();
if start > 0 && is_ident_byte(src.as_bytes()[start - 1]) {
continue;
}
if src.as_bytes().get(at).copied().is_some_and(is_ident_byte) {
continue;
}
let rest = &src[at..];
let lead = rest.len() - rest.trim_start().len();
let rest = &rest[lead..];
if !rest.starts_with('=') {
continue;
}
let rest = &rest[1..];
let gap = rest.len() - rest.trim_start().len();
let rest = &rest[gap..];
let Some(quote @ ('\'' | '"' | '`')) = rest.chars().next() else {
continue;
};
let body = at + lead + 1 + gap + quote.len_utf8();
if let Some(j) = src[body..].find(quote) {
out.push((start, &src[body..body + j]));
at = body + j + 1;
}
}
out
}
fn is_ident_byte(b: u8) -> bool {
b.is_ascii_alphanumeric() || b == b'_' || b == b'$'
}
fn line_of(src: &str, offset: usize) -> usize {
src[..offset].matches('\n').count() + 1
}
#[derive(Debug, Clone)]
enum Source {
Frontend(PathBuf),
Files(Vec<PathBuf>),
}
impl Source {
fn files<P: AsRef<Path>>(paths: &[P]) -> Self {
Self::Files(paths.iter().map(|p| p.as_ref().to_path_buf()).collect())
}
}
fn blank(src: &str, lang: Lang) -> String {
let mut out = String::with_capacity(src.len());
for (c, role) in lex(src, lang) {
if role == Role::Code || (role == Role::Text && lang == Lang::Js) {
out.push(c);
} else if c == '\n' {
out.push('\n');
} else {
out.extend(std::iter::repeat_n(' ', c.len_utf8()));
}
}
out
}
fn drop_layers(css: &str, names: &[&str]) -> String {
if names.is_empty() {
return css.to_owned();
}
let scan = blank(css, Lang::Css);
let scan = scan.as_bytes();
let mut out = css.as_bytes().to_vec();
let mut at = 0;
while let Some(found) = find_at_layer(scan, at) {
let mut i = found + b"@layer".len();
while i < scan.len() && scan[i].is_ascii_whitespace() {
i += 1;
}
let start = i;
while i < scan.len()
&& (scan[i].is_ascii_alphanumeric() || matches!(scan[i], b'-' | b'_' | b'.'))
{
i += 1;
}
let name = &css[start..i];
while i < scan.len() && scan[i].is_ascii_whitespace() {
i += 1;
}
if i >= scan.len() || scan[i] != b'{' || !layer_is_beneath(name, names) {
at = found + 1;
continue;
}
match matching_close(scan, i, b'{', b'}') {
Some(close) => {
blank_dropped_layer(&mut out, scan, found, i, close);
at = close + 1;
}
None => {
blank_span(&mut out, found, scan.len());
at = scan.len();
}
}
}
String::from_utf8(out).unwrap_or_else(|_| css.to_owned())
}
fn layer_is_beneath(name: &str, names: &[&str]) -> bool {
names.iter().any(|beneath| {
name == *beneath
|| name
.strip_prefix(beneath)
.is_some_and(|rest| rest.starts_with('.'))
})
}
fn find_at_layer(haystack: &[u8], from: usize) -> Option<usize> {
let needle = b"@layer";
let mut i = from;
while i + needle.len() <= haystack.len() {
if haystack[i..i + needle.len()].eq_ignore_ascii_case(needle) {
return Some(i);
}
i += 1;
}
None
}
fn blank_span(out: &mut [u8], start: usize, end: usize) {
for byte in &mut out[start..end] {
if *byte != b'\n' {
*byte = b' ';
}
}
}
fn blank_dropped_layer(out: &mut [u8], scan: &[u8], head: usize, open: usize, close: usize) {
blank_span(out, head, open + 1);
blank_dropped_content(out, scan, open + 1, close);
blank_span(out, close, close + 1);
}
fn blank_dropped_content(out: &mut [u8], scan: &[u8], start: usize, end: usize) {
let mut i = start;
while i < end {
let mut open = i;
while open < end && scan[open] != b'{' && scan[open] != b';' {
open += 1;
}
if open >= end {
blank_span(out, i, end);
break;
}
if scan[open] == b';' {
blank_span(out, i, open + 1);
i = open + 1;
continue;
}
let Some(close) = matching_close(&scan[..end], open, b'{', b'}') else {
blank_span(out, i, end);
break;
};
let is_at_rule = scan[i..open]
.iter()
.position(|b| !b.is_ascii_whitespace())
.is_some_and(|k| scan[i + k] == b'@');
if is_at_rule {
blank_dropped_content(out, scan, open + 1, close);
} else if !has_important(&scan[open + 1..close]) {
blank_span(out, i, close + 1);
}
i = close + 1;
}
}
fn has_important(bytes: &[u8]) -> bool {
let keyword = b"important";
let mut i = 0;
while i < bytes.len() {
if bytes[i] == b'!' {
let mut k = i + 1;
while k < bytes.len() && bytes[k].is_ascii_whitespace() {
k += 1;
}
if k + keyword.len() <= bytes.len()
&& bytes[k..k + keyword.len()].eq_ignore_ascii_case(keyword)
{
return true;
}
}
i += 1;
}
false
}
fn layers_ordered_below_makeover(css: &str) -> Vec<String> {
let scan = blank(css, Lang::Css);
let mut below = Vec::new();
for statement in scan.split(';') {
let Some(at) = statement.rfind("@layer") else {
continue;
};
let names: Vec<&str> = statement[at + "@layer".len()..]
.split(',')
.map(str::trim)
.collect();
if names.iter().any(|name| name.contains(['{', '}'])) {
continue;
}
if let Some(position) = names.iter().position(|name| *name == crate::CSS_LAYER) {
below.extend(names[..position].iter().map(|name| (*name).to_string()));
}
}
below
}
#[cfg(test)]
mod tests {
use super::breakpoints::{Width, js_widths, media_conditions, media_widths};
use super::vocabulary_use::{haystack_names, haystack_words};
use super::*;
use crate::Emit;
use crate::test_support::scratch;
use makeover_geometry::SizeClass;
fn write(dir: &Path, name: &str, src: &str) {
if let Some(parent) = dir.join(name).parent() {
std::fs::create_dir_all(parent).unwrap();
}
std::fs::write(dir.join(name), src).unwrap();
}
fn declaring() -> String {
format!(
"const {CONST_NAME} = '{}';\n",
Density::Touch.media_condition()
)
}
#[test]
fn the_crates_own_string_passes() {
let dir = scratch("ok");
write(&dir, "touch.js", &declaring());
check_touch_density(&dir);
}
#[test]
#[should_panic(expected = "disagrees with makeover_geometry::Density")]
fn a_drifted_literal_fails() {
let dir = scratch("drift");
write(&dir, "touch.js", &declaring());
write(
&dir,
"haptics.js",
&format!("const {CONST_NAME} = '(pointer: coarse)';\n"),
);
check_touch_density(&dir);
}
#[test]
#[should_panic(expected = "device sniff")]
fn the_sniff_cannot_come_back() {
let dir = scratch("sniff");
write(&dir, "touch.js", &declaring());
write(&dir, "legacy.js", "if ('ontouchstart' in window) {}\n");
check_touch_density(&dir);
}
#[test]
#[should_panic(expected = "no TOUCH_DENSITY literal found")]
fn a_frontend_that_states_nothing_fails() {
let dir = scratch("empty");
write(&dir, "app.js", "export const x = 1;\n");
check_touch_density(&dir);
}
#[test]
fn a_use_site_is_not_a_declaration() {
let src =
format!("import {{ {CONST_NAME} }} from './touch.js';\nmatchMedia({CONST_NAME});\n");
assert!(
touch_density_literals(&src).is_empty(),
"{:?}",
touch_density_literals(&src)
);
}
#[test]
fn whitespace_and_backtick_literals_read() {
let want = Density::Touch.media_condition();
for src in [
format!("const {CONST_NAME}='{want}';\n"),
format!("const {CONST_NAME} = `{want}`;\n"),
format!("const {CONST_NAME} =\n '{want}';\n"),
] {
let found = touch_density_literals(&src);
assert_eq!(found.len(), 1, "src: {src:?}");
assert_eq!(found[0].1, want, "src: {src:?}");
}
}
#[test]
fn a_longer_identifier_is_not_the_const() {
let want = Density::Touch.media_condition();
for src in [
format!("const OLD_{CONST_NAME} = '{want}';\n"),
format!("const {CONST_NAME}_OLD = '{want}';\n"),
] {
assert!(touch_density_literals(&src).is_empty(), "src: {src:?}");
}
}
#[test]
#[should_panic(expected = "no TOUCH_DENSITY literal found")]
fn a_commented_out_declaration_is_not_a_declaration() {
let dir = scratch("commented-decl");
write(
&dir,
"touch.js",
&format!("// {}\n", declaring().trim_end()),
);
check_touch_density(&dir);
}
#[test]
fn a_sniff_named_in_a_comment_is_not_a_use() {
let dir = scratch("sniff-comment");
write(&dir, "touch.js", &declaring());
write(
&dir,
"note.js",
"// never read ontouchstart or maxTouchPoints here\n",
);
check_touch_density(&dir);
}
#[test]
#[should_panic(expected = "disagrees with makeover_geometry::Density")]
fn a_wrong_literal_without_spaces_is_caught() {
let dir = scratch("loose-drift");
write(&dir, "touch.js", &declaring());
write(
&dir,
"haptics.js",
&format!("const {CONST_NAME}='(pointer: coarse)';\n"),
);
check_touch_density(&dir);
}
#[test]
fn nested_files_are_read() {
let dir = scratch("nested");
write(&dir, "touch.js", &declaring());
write(&dir, "screens/legacy.js", "navigator.maxTouchPoints > 0;\n");
let files = js_files(&dir);
assert_eq!(files.len(), 2);
}
#[test]
fn a_non_js_file_is_ignored() {
let dir = scratch("nonjs");
write(&dir, "touch.js", &declaring());
write(&dir, "styles.css", "body { }\n");
assert_eq!(js_files(&dir).len(), 1);
}
fn frontend(name: &str) -> PathBuf {
let dir = scratch(name);
std::fs::create_dir_all(dir.join("css")).unwrap();
std::fs::create_dir_all(dir.join("js")).unwrap();
dir
}
fn boundary() -> u16 {
SizeClass::Medium.min_px()
}
#[test]
fn the_crates_own_boundaries_pass() {
let dir = frontend("bp-ok");
write(
&dir,
"css/styles.css",
&format!("@media (min-width: {}px) {{ body {{ }} }}\n", boundary()),
);
Breakpoints::in_frontend(&dir).run();
}
#[test]
#[should_panic(expected = "disagree with makeover_geometry::SizeClass")]
fn a_stale_css_width_fails() {
let dir = frontend("bp-css");
write(&dir, "css/styles.css", "@media (max-width: 768px) { }\n");
Breakpoints::in_frontend(&dir).run();
}
#[test]
#[should_panic(expected = "disagree with makeover_geometry::SizeClass")]
fn a_stale_js_width_fails() {
let dir = frontend("bp-js");
write(&dir, "js/shell.js", "matchMedia('(max-width: 768px)');\n");
Breakpoints::in_frontend(&dir).run();
}
#[test]
fn a_declared_tuning_width_passes() {
let dir = frontend("bp-tuning");
write(&dir, "css/styles.css", "@media (min-width: 1400px) { }\n");
Breakpoints::in_frontend(&dir).tuning(&[1400]).run();
}
#[test]
fn a_container_query_on_a_shell_boundary_passes() {
let dir = frontend("bp-container-ok");
write(
&dir,
"css/styles.css",
&format!("@container screen (width < {}px) {{ }}\n", boundary()),
);
Breakpoints::in_frontend(&dir).run();
}
#[test]
#[should_panic(expected = "disagree with makeover_geometry::SizeClass")]
fn a_stale_container_width_fails() {
let dir = frontend("bp-container-stale");
write(
&dir,
"css/styles.css",
"@container screen (width < 768px) { }\n",
);
Breakpoints::in_frontend(&dir).run();
}
#[test]
fn a_container_inline_size_condition_is_not_a_width_boundary() {
let dir = frontend("bp-container-inline");
write(
&dir,
"css/styles.css",
"@container tab-strip (inline-size < 36rem) { }\n",
);
Breakpoints::in_frontend(&dir).run();
}
#[test]
fn a_width_in_a_comment_is_prose() {
let dir = frontend("bp-comment");
write(
&dir,
"css/styles.css",
"/* was @media (max-width: 768px) until the size classes landed */\n",
);
Breakpoints::in_frontend(&dir).run();
}
#[test]
fn an_unparenthesized_width_is_not_a_breakpoint() {
let dir = frontend("bp-inline");
write(
&dir,
"js/style.js",
"el.style.cssText = 'max-width: 320px; display: block';\n",
);
Breakpoints::in_frontend(&dir).run();
}
#[test]
fn nested_css_is_read() {
let dir = frontend("bp-nested");
write(
&dir,
"css/screens/detail.css",
"@media (max-width: 768px) { }\n",
);
let found = std::panic::catch_unwind(|| Breakpoints::in_frontend(&dir).run());
assert!(found.is_err(), "a nested stylesheet must be scanned");
}
#[test]
fn a_css_only_frontend_scans_without_a_js_directory() {
let dir = scratch("bp-css-only");
write(
&dir,
"css/styles.css",
&format!("@media (min-width: {}px) {{ body {{ }} }}\n", boundary()),
);
Breakpoints::in_frontend(&dir).run();
}
#[test]
fn a_named_list_is_checked() {
let dir = frontend("bp-list");
write(&dir, "css/style.css", "@media (max-width: 768px) { }\n");
let listed = dir.join("css/style.css");
let err = std::panic::catch_unwind(|| Breakpoints::files(&[&listed]).run()).unwrap_err();
let msg = err.downcast_ref::<String>().expect("String payload");
assert!(msg.contains("style.css:1"), "got: {msg}");
}
#[test]
#[should_panic(expected = "read ")]
fn a_listed_file_that_is_gone_fails() {
let dir = frontend("bp-missing");
Breakpoints::files(&[dir.join("css/never-written.css")]).run();
}
#[test]
fn a_listed_js_file_is_parsed_as_script() {
let dir = frontend("bp-list-js");
write(
&dir,
"js/style.js",
"el.style.cssText = 'max-width: 320px';\n",
);
Breakpoints::files(&[dir.join("js/style.js")]).run();
}
#[test]
fn the_error_names_the_file_and_line() {
let dir = frontend("bp-message");
write(
&dir,
"css/styles.css",
"body { }\n@media (max-width: 768px) { }\n",
);
let err = std::panic::catch_unwind(|| Breakpoints::in_frontend(&dir).run()).unwrap_err();
let msg = err
.downcast_ref::<String>()
.expect("panic payload is a String");
assert!(msg.contains("css/styles.css:2"), "got: {msg}");
}
#[test]
fn a_rule_restating_an_upstream_class_fails_and_its_served_copy_does_not() {
let upstream = ".tile-set { gap: 4px; }\n";
let dir = scratch("vocab-upstream");
write(&dir, "css/quasi.css", upstream);
write(&dir, "css/styles.css", ".tile-set { gap: 0; }\n");
let err = std::panic::catch_unwind(|| {
Vocabulary::in_frontend(&dir)
.upstream(&[upstream])
.run(&Emit::default());
})
.unwrap_err();
let msg = err
.downcast_ref::<String>()
.expect("panic payload is a String");
assert!(
msg.contains("css/styles.css .tile-set { gap }"),
"got: {msg}"
);
assert!(
!msg.contains("css/quasi.css"),
"the served copy clashed with itself: {msg}"
);
Vocabulary::in_frontend(&dir).run(&Emit::default());
}
#[test]
fn a_rule_restating_a_generated_class_fails_and_names_it() {
let dir = scratch("vocab-clash");
write(
&dir,
"css/styles.css",
"body { color: red; }\n.card { box-shadow: none; }\n",
);
let err = std::panic::catch_unwind(|| Vocabulary::in_frontend(&dir).run(&Emit::default()))
.unwrap_err();
let msg = err
.downcast_ref::<String>()
.expect("panic payload is a String");
assert!(msg.contains(".card"), "got: {msg}");
assert!(msg.contains("box-shadow"), "got: {msg}");
assert!(msg.contains("css/styles.css"), "got: {msg}");
}
#[test]
fn an_app_class_of_its_own_is_left_alone() {
let dir = scratch("vocab-clean");
write(
&dir,
"css/styles.css",
".task-list-container { overflow: auto; }\n.day-plan-slot { height: 1rem; }\n",
);
Vocabulary::in_frontend(&dir).run(&Emit::default());
}
#[test]
fn the_generated_sheet_is_skipped_rather_than_reported_against_itself() {
let dir = scratch("vocab-generated");
let opts = Emit::default();
write(&dir, "css/layout.css", &crate::stylesheet(&opts));
Vocabulary::in_frontend(&dir)
.generated(&["layout.css"])
.run(&opts);
}
#[test]
fn a_prefixed_app_is_checked_against_its_own_prefix() {
let dir = scratch("vocab-prefix");
let opts = Emit::new().class_prefix("mo-");
write(&dir, "css/styles.css", ".card { box-shadow: none; }\n");
Vocabulary::in_frontend(&dir).run(&opts);
let dir = scratch("vocab-prefix-clash");
write(&dir, "css/styles.css", ".mo-card { box-shadow: none; }\n");
assert!(std::panic::catch_unwind(|| Vocabulary::in_frontend(&dir).run(&opts)).is_err());
}
#[test]
fn a_class_shared_without_a_shared_property_is_left_alone() {
let dir = scratch("vocab-additive");
write(
&dir,
"css/styles.css",
".cell-value { padding: 2px; border-radius: 3px; font-weight: 600; }\n",
);
Vocabulary::in_frontend(&dir).run(&Emit::default());
}
#[test]
fn a_reviewed_pair_passes_and_stops_passing_when_it_stops_colliding() {
let dir = scratch("vocab-allowed");
write(&dir, "css/styles.css", ".badge { padding: 0; }\n");
Vocabulary::in_frontend(&dir)
.allow(Allow::class("badge", "padding"))
.run(&Emit::default());
let dir = scratch("vocab-allowed-stale");
write(&dir, "css/styles.css", ".card { padding: 2px; }\n");
let err = std::panic::catch_unwind(|| {
Vocabulary::in_frontend(&dir)
.allow(Allow::class("badge", "padding"))
.run(&Emit::default());
})
.unwrap_err();
let msg = err
.downcast_ref::<String>()
.expect("panic payload is a String");
assert!(msg.contains("no longer collides"), "got: {msg}");
}
#[test]
fn an_element_rule_clobbering_a_generated_class_fails_and_names_all_three() {
let dir = scratch("vocab-element");
write(&dir, "css/styles.css", "select { box-shadow: none; }\n");
let err = std::panic::catch_unwind(|| Vocabulary::in_frontend(&dir).run(&Emit::default()))
.unwrap_err();
let msg = err
.downcast_ref::<String>()
.expect("panic payload is a String");
assert!(msg.contains("select {"), "got: {msg}");
assert!(msg.contains(".field"), "got: {msg}");
assert!(msg.contains("box-shadow"), "got: {msg}");
assert!(msg.contains("css/styles.css"), "got: {msg}");
}
#[test]
fn a_universal_reset_after_the_design_system_is_caught() {
let dir = scratch("vocab-universal");
write(&dir, "css/styles.css", "* { margin: 0; padding: 0; }\n");
let err = std::panic::catch_unwind(|| Vocabulary::in_frontend(&dir).run(&Emit::default()))
.unwrap_err();
let msg = err
.downcast_ref::<String>()
.expect("panic payload is a String");
assert!(msg.contains("* {"), "got: {msg}");
assert!(msg.contains("padding"), "got: {msg}");
}
#[test]
fn a_universal_reset_in_a_layer_beneath_makeover_is_not_read() {
let dir = scratch("vocab-universal-beneath");
write(
&dir,
"css/styles.css",
"/* { */ @layer reset {\n * { margin: 0; padding: 0; }\n}\n.x { content: \"}\"; }\n",
);
Vocabulary::in_frontend(&dir)
.beneath(&["reset"])
.run(&Emit::default());
}
#[test]
fn an_important_rule_in_a_layer_beneath_makeover_is_still_read() {
let dir = scratch("vocab-important-beneath");
write(
&dir,
"css/styles.css",
"@layer reset {\n .field { box-shadow: none !important; }\n}\n",
);
let err = std::panic::catch_unwind(|| {
Vocabulary::in_frontend(&dir)
.beneath(&["reset"])
.run(&Emit::default());
})
.unwrap_err();
let msg = err.downcast_ref::<String>().expect("a String payload");
assert!(msg.contains("box-shadow"), "got: {msg}");
}
#[test]
fn a_layer_not_named_beneath_is_still_read() {
let dir = scratch("vocab-universal-other-layer");
write(
&dir,
"css/styles.css",
"@layer base {\n * { padding: 0; }\n}\n",
);
let err = std::panic::catch_unwind(|| {
Vocabulary::in_frontend(&dir)
.beneath(&["reset"])
.run(&Emit::default());
})
.unwrap_err();
let msg = err.downcast_ref::<String>().expect("a String payload");
assert!(msg.contains("* {"), "got: {msg}");
}
#[test]
fn a_universal_rule_touching_nothing_generated_is_not_a_clash() {
let dir = scratch("vocab-universal-box");
write(&dir, "css/styles.css", "* { box-sizing: border-box; }\n");
Vocabulary::in_frontend(&dir).run(&Emit::default());
}
#[test]
fn a_handoff_on_the_class_is_the_remedy_and_reads_as_one() {
let dir = scratch("vocab-element-handoff");
write(
&dir,
"css/styles.css",
"select { box-shadow: none; }\n.field { box-shadow: revert-layer; }\n",
);
Vocabulary::in_frontend(&dir).run(&Emit::default());
}
#[test]
fn a_property_the_app_states_on_the_class_is_not_the_element_rules_doing() {
let dir = scratch("vocab-element-spoken-for");
write(
&dir,
"css/styles.css",
"select { box-shadow: none; }\n.field { box-shadow: none; }\n\
.field:disabled,\n.field[aria-disabled=\"true\"],\n\
.field[aria-invalid=\"true\"] {\n box-shadow: revert-layer;\n}\n",
);
Vocabulary::in_frontend(&dir)
.allow(Allow::class("field", "box-shadow"))
.run(&Emit::default());
}
#[test]
fn a_handoff_that_loses_to_the_rule_it_remedies_is_not_a_remedy() {
let dir = scratch("vocab-element-weak-handoff");
write(
&dir,
"css/styles.css",
"select:focus { box-shadow: none; }\n.field { box-shadow: revert-layer; }\n",
);
let err = std::panic::catch_unwind(|| Vocabulary::in_frontend(&dir).run(&Emit::default()))
.unwrap_err();
let msg = err
.downcast_ref::<String>()
.expect("panic payload is a String");
assert!(msg.contains(".field"), "got: {msg}");
let dir = scratch("vocab-element-strong-handoff");
write(
&dir,
"css/styles.css",
"select:focus { box-shadow: none; }\nselect.field { box-shadow: revert-layer; }\n",
);
Vocabulary::in_frontend(&dir).run(&Emit::default());
}
#[test]
fn a_scoped_rule_is_not_read_as_an_element_rule() {
let dir = scratch("vocab-element-scoped");
write(
&dir,
"css/styles.css",
".wizard select { box-shadow: none; }\n",
);
Vocabulary::in_frontend(&dir).run(&Emit::default());
}
#[test]
fn an_element_the_design_system_never_renders_onto_is_left_alone() {
let dir = scratch("vocab-element-unpaired");
write(&dir, "css/styles.css", "footer { box-shadow: none; }\n");
Vocabulary::in_frontend(&dir).run(&Emit::default());
}
#[test]
fn a_bare_rule_that_cancels_a_tone_fails_even_when_the_pair_is_reviewed() {
let dir = scratch("vocab-cancel-tone");
write(
&dir,
"css/styles.css",
".button { background: var(--surface-raised); }\n",
);
let err = std::panic::catch_unwind(|| {
Vocabulary::in_frontend(&dir)
.allow(Allow::class("button", "background"))
.run(&Emit::default());
})
.unwrap_err();
let msg = err
.downcast_ref::<String>()
.expect("panic payload is a String");
assert!(
msg.contains(".button { background } cancels"),
"got: {msg}"
);
assert!(
msg.contains(".button[data-tone=\"danger\"] { background }"),
"the message names the variant it cancels: {msg}"
);
assert!(msg.contains("restate"), "and the remedy: {msg}");
}
#[test]
fn restating_every_cancelled_variant_on_its_own_arm_passes() {
let opts = Emit::default();
let variants = crate::vocabulary::variants_by_class(&crate::stylesheet(&opts));
let mut css = String::from(".button { background: var(--surface-raised); }\n");
for (arm, properties) in &variants["button"] {
if properties.contains("background") {
let loose = arm.replace('"', "'").replace(',', " , ");
putln!(css, "{loose} {{ background: revert-layer; }}");
}
}
let dir = scratch("vocab-cancel-restated");
write(&dir, "css/styles.css", &css);
Vocabulary::in_frontend(&dir)
.allow(Allow::class("button", "background"))
.run(&opts);
}
#[test]
fn a_scoped_or_qualified_rule_cancels_nothing_this_can_prove() {
let dir = scratch("vocab-cancel-scoped");
write(
&dir,
"css/styles.css",
".toolbar .button { color: var(--content); }\n\
.button.quiet { color: var(--content); }\n",
);
Vocabulary::in_frontend(&dir)
.allow(Allow::class("button", "color"))
.run(&Emit::default());
}
#[test]
fn a_layer_the_sheet_orders_below_makeover_cancels_nothing() {
let dir = scratch("vocab-cancel-own-order");
write(
&dir,
"css/quasi.css",
"@layer reset, quasi, makeover;\n\
@layer quasi {\n .button { cursor: pointer; }\n}\n",
);
Vocabulary::in_frontend(&dir)
.allow(Allow::class("button", "cursor"))
.run(&Emit::default());
let dir = scratch("vocab-cancel-own-order-above");
write(
&dir,
"css/app.css",
"@layer reset, makeover, app;\n\
@layer app {\n .button { cursor: pointer; }\n}\n",
);
let err = std::panic::catch_unwind(|| {
Vocabulary::in_frontend(&dir)
.allow(Allow::class("button", "cursor"))
.run(&Emit::default());
})
.unwrap_err();
let msg = err
.downcast_ref::<String>()
.expect("panic payload is a String");
assert!(msg.contains(".button { cursor } cancels"), "got: {msg}");
}
#[test]
fn repro_own_below_layer_still_clashes() {
let dir = scratch("vocab-own-below-clash");
write(
&dir,
"css/quasi.css",
"@layer reset, quasi, makeover;\n\
@layer quasi {\n .button { cursor: pointer; }\n button { color: red; }\n}\n",
);
Vocabulary::in_frontend(&dir).run(&Emit::default());
}
#[test]
fn a_handoff_on_the_bare_class_cancels_nothing() {
let dir = scratch("vocab-cancel-handoff");
write(&dir, "css/styles.css", ".button { color: revert-layer; }\n");
Vocabulary::in_frontend(&dir).run(&Emit::default());
}
#[test]
fn a_reviewed_element_pairing_passes_and_stops_passing_when_it_stops_colliding() {
let dir = scratch("vocab-element-allowed");
write(&dir, "css/styles.css", "select { box-shadow: none; }\n");
Vocabulary::in_frontend(&dir)
.allow(Allow::element("select", "field", "box-shadow"))
.run(&Emit::default());
let dir = scratch("vocab-element-allowed-stale");
write(&dir, "css/styles.css", "select { padding: 2px; }\n");
let err = std::panic::catch_unwind(|| {
Vocabulary::in_frontend(&dir)
.allow(Allow::element("select", "field", "box-shadow"))
.run(&Emit::default());
})
.unwrap_err();
let msg = err
.downcast_ref::<String>()
.expect("panic payload is a String");
assert!(msg.contains("no longer collides"), "got: {msg}");
}
fn ladders(names: &std::collections::BTreeSet<String>) -> (usize, usize) {
let mut rungs = 0;
let mut ladders = 0;
for ladder in [
"min-",
"short-",
"stacks-",
"tiles-",
"drop-optional-",
"drop-secondary-",
] {
let here = names
.iter()
.filter(|c| {
c.strip_prefix(ladder)
.is_some_and(|n| !n.is_empty() && n.bytes().all(|b| b.is_ascii_digit()))
})
.count();
rungs += here;
ladders += usize::from(here > 0);
}
(rungs, ladders)
}
#[test]
fn dead_vocabulary_above_the_seal_fails_and_below_it_passes() {
let dir = scratch("vocab-seal");
let opts = Emit::default();
let names = crate::vocabulary::names(&opts);
let (rungs, ladders) = ladders(&names);
assert!(ladders >= 1, "the floor ladder is in the vocabulary");
let dead = names.len() - rungs + ladders;
write(&dir, "index.html", "<div></div>\n");
let markup = [dir.join("index.html")];
check_vocabulary_use(&markup, &opts, dead);
assert!(
std::panic::catch_unwind(|| check_vocabulary_use(&markup, &opts, dead - 1)).is_err(),
"a vocabulary deader than the seal has to fail"
);
}
#[test]
fn one_rung_of_the_floor_ladder_uses_the_ladder() {
let opts = Emit::default();
let names = crate::vocabulary::names(&opts);
let (rungs, ladders) = ladders(&names);
let dead = names.len() - rungs + ladders;
let dir = scratch("vocab-ladder");
write(&dir, "index.html", "<div class=\"cell min-16\"></div>\n");
let one_rung = [dir.join("index.html")];
check_vocabulary_use(&one_rung, &opts, dead - 2);
write(&dir, "index.html", "<div class=\"min-24\"></div>\n");
assert!(haystack_names("<div class=\"min-24\">", "min-24"));
assert!(!haystack_names("<div class=\"min-24\">", "min-2"));
}
#[test]
fn a_class_is_named_whole_on_both_sides() {
assert!(haystack_names("class=\"row\"", "row"));
assert!(!haystack_names("class=\"row-flex\"", "row"));
assert!(!haystack_names("class=\"flex-row\"", "row"));
assert!(haystack_names("el.classList.add('row')", "row"));
}
#[test]
fn the_word_set_names_what_the_whole_word_search_names() {
let haystack = "<div class=\"row min-24 mk-cell\">el.classList.add('flex-row')</div>";
let words = haystack_words(haystack);
for class in [
"row", "min-24", "min-2", "mk-cell", "cell", "flex-row", "flex", "div", "iv",
] {
assert_eq!(
words.contains(class),
haystack_names(haystack, class),
"{class}"
);
}
}
#[test]
fn range_syntax_and_units_are_read() {
assert_eq!(media_widths("(width < 600px)"), [Width::Px(600)]);
assert_eq!(
media_widths(" (600px <= width < 840px)"),
[Width::Px(600), Width::Px(840)]
);
assert_eq!(media_widths(" (max-width: 48em)"), [Width::Px(768)]);
assert_eq!(media_widths(" (min-width: 37.5rem)"), [Width::Px(600)]);
assert_eq!(
media_widths(" (max-width: 599.98px)"),
[Width::Other("599.98px".into())]
);
assert_eq!(
media_widths(" (width < 50vw)"),
[Width::Other("50vw".into())]
);
let found = media_widths(" (min-height: 600px)");
assert!(found.is_empty(), "{found:?}");
let found = media_widths(" (max-device-width: 600px)");
assert!(found.is_empty(), "{found:?}");
let found = media_widths(" (hover: hover) and (pointer: fine)");
assert!(found.is_empty(), "{found:?}");
}
#[test]
fn every_size_class_condition_passes_its_own_check() {
let dir = frontend("bp-classes");
let mut css = String::new();
for class in SizeClass::all() {
putln!(css, "@media {} {{ body {{ }} }}", class.media_condition());
}
write(&dir, "css/styles.css", &css);
write(
&dir,
"js/shell.js",
&format!("matchMedia('{}');\n", SizeClass::Compact.media_condition()),
);
Breakpoints::in_frontend(&dir).run();
}
#[test]
#[should_panic(expected = "48em")]
fn a_width_in_em_is_a_width_and_not_a_bare_number() {
let dir = frontend("bp-em");
write(&dir, "css/styles.css", "@media (max-width: 48em) { }\n");
Breakpoints::in_frontend(&dir).tuning(&[48]).run();
}
#[test]
#[should_panic(expected = "(width < 768px)")]
fn a_stale_range_width_fails() {
let dir = frontend("bp-range");
write(&dir, "css/styles.css", "@media (width < 768px) { }\n");
Breakpoints::in_frontend(&dir).run();
}
#[test]
#[should_panic(expected = "599px")]
fn the_old_inclusive_compact_bound_is_stale() {
let dir = frontend("bp-599");
write(&dir, "css/styles.css", "@media (max-width: 599px) { }\n");
Breakpoints::in_frontend(&dir).run();
}
#[test]
#[should_panic(expected = "(max-width: 600px)")]
fn an_inclusive_bound_at_a_class_edge_is_stale() {
let dir = frontend("bp-600-inclusive");
write(&dir, "css/styles.css", "@media (max-width: 600px) { }\n");
Breakpoints::in_frontend(&dir).run();
}
#[test]
#[should_panic(expected = "(width <= 600px)")]
fn an_inclusive_range_upper_bound_is_stale() {
let dir = frontend("bp-le-600");
write(&dir, "css/styles.css", "@media (width <= 600px) { }\n");
Breakpoints::in_frontend(&dir).run();
}
#[test]
fn the_inclusive_lower_bound_and_edges_are_not_stale() {
let dir = frontend("bp-edges-ok");
write(
&dir,
"css/styles.css",
"@media (min-width: 600px) { }\n\
@media (600px <= width) { }\n\
@media (width >= 840px) { }\n",
);
Breakpoints::in_frontend(&dir).run();
}
#[test]
fn a_tuning_max_width_is_left_alone() {
let dir = frontend("bp-tuning-max");
write(&dir, "css/styles.css", "@media (max-width: 1400px) { }\n");
Breakpoints::in_frontend(&dir).tuning(&[1400]).run();
}
#[test]
fn a_call_in_script_is_not_a_feature() {
let found = js_widths("const w = Math.max(width, 600);");
assert!(found.is_empty(), "{found:?}");
let found = js_widths("el.style.cssText = 'max-width: 320px';");
assert!(found.is_empty(), "{found:?}");
assert_eq!(js_widths("matchMedia('(width < 600px)')").len(), 1);
}
#[test]
fn a_slash_star_slash_opens_a_comment_rather_than_closing_one() {
let css = "/*/ @media (max-width: 768px) { } */ a { }";
let stripped = blank(css, Lang::Css);
assert!(!stripped.contains("768"), "{stripped:?}");
assert!(stripped.contains("a { }"));
assert_eq!(stripped.len(), css.len());
}
#[test]
fn a_comment_opener_inside_a_string_is_text() {
let css = "a::after { content: \"/*\"; }\n@media (max-width: 768px) { }\n";
let src = blank(css, Lang::Css);
assert_eq!(media_conditions(&src).len(), 1);
assert!(src.contains("768"));
let js = "const glob = '/*';\nmatchMedia('(width < 600px)');\n";
assert_eq!(js_widths(&blank(js, Lang::Js)).len(), 1);
}
#[test]
fn a_regex_literal_does_not_open_a_comment() {
let js = "s.replace(/\\/*$/, '');\nmatchMedia('(width < 600px)');\n";
assert_eq!(js_widths(&blank(js, Lang::Js)).len(), 1);
}
#[test]
fn a_division_is_not_a_regex_literal() {
let js = "const half = a / b;\nmatchMedia('(width < 600px)');\n";
assert_eq!(js_widths(&blank(js, Lang::Js)).len(), 1);
}
#[test]
fn a_css_bad_string_ends_at_a_newline() {
let css = "p::before { content: 'oops\n}\n@media (max-width: 768px) { }\n";
let src = blank(css, Lang::Css);
assert_eq!(media_conditions(&src).len(), 1);
assert!(src.contains("768"));
}
#[test]
fn an_escaped_quote_does_not_open_a_string() {
let css = ".a\\'b { color: red; }\n@media (max-width: 768px) { }\n";
let src = blank(css, Lang::Css);
assert_eq!(media_conditions(&src).len(), 1);
}
#[test]
fn an_unquoted_url_does_not_open_a_comment() {
let css = "a { background: url(/img/*.png); }\n@media (max-width: 768px) { }\n";
let src = blank(css, Lang::Css);
assert_eq!(media_conditions(&src).len(), 1);
let css = "a { background: url(\"/x/*.png\"); /* gone */ }\n\
@media (max-width: 768px) { }\n";
let src = blank(css, Lang::Css);
assert!(!src.contains("gone"), "{src:?}");
assert_eq!(media_conditions(&src).len(), 1);
}
#[test]
fn a_leading_dot_length_is_read() {
assert_eq!(media_widths("(max-width: .5em)"), vec![Width::Px(8)]);
assert_eq!(media_widths("(max-width: 37.5em)"), vec![Width::Px(600)]);
}
#[test]
fn an_at_media_keyword_reads_in_any_case() {
let conditions = media_conditions("@MEDIA (max-width: 768px) { body { } }");
assert_eq!(conditions.len(), 1);
assert_eq!(media_widths(conditions[0].1), vec![Width::Px(768)]);
}
#[test]
fn a_width_nested_in_a_function_is_read() {
assert_eq!(
media_widths("(max-width: calc(768px))"),
vec![Width::Px(768)]
);
assert!(media_widths("(max-width: calc(48em + 1px))").contains(&Width::Px(768)));
}
#[test]
fn a_newline_does_not_reset_an_open_group() {
assert_eq!(media_widths("(max-width:\n 768px)"), vec![Width::Px(768)]);
}
#[test]
fn custom_media_and_import_carry_media_queries() {
let css = "@custom-media --narrow (max-width: 768px);\n\
@import url(x.css) (max-width: 768px);\n";
let conditions = media_conditions(css);
assert_eq!(conditions.len(), 2);
for (_, condition) in conditions {
assert!(
media_widths(condition).contains(&Width::Px(768)),
"unread: {condition:?}"
);
}
}
#[test]
fn a_query_in_a_script_comment_is_prose() {
let js = "// was matchMedia('(width < 768px)')\n/* (max-width: 500px) */\n";
let found = js_widths(&blank(js, Lang::Js));
assert!(found.is_empty(), "{found:?}");
}
#[test]
fn a_brace_inside_a_css_string_does_not_end_a_condition() {
let css = "@media (width < 600px) { a::after { content: \"{\"; } }";
let src = blank(css, Lang::Css);
assert_eq!(media_conditions(&src).len(), 1);
}
#[test]
fn blanking_keeps_byte_offsets_through_multibyte_text() {
let css = "/* a \u{2014} b */ a::after { content: \"\u{2014}\"; }\n@layer reset { * { padding: 0; } }";
let src = blank(css, Lang::Css);
assert_eq!(src.len(), css.len());
let at = css.find("@layer").unwrap();
assert_eq!(&src[at..at + 6], "@layer");
let dropped = drop_layers(css, &["reset"]);
assert!(!dropped.contains("padding"), "{dropped:?}");
}
#[test]
fn a_dropped_layer_keeps_its_important_rules() {
let css =
"@layer reset {\n * { padding: 0; }\n .card { box-shadow: none !important; }\n}\n";
let dropped = drop_layers(css, &["reset"]);
assert!(!dropped.contains("padding"), "{dropped:?}");
assert!(dropped.contains(".card"), "{dropped:?}");
assert!(dropped.contains("box-shadow"), "{dropped:?}");
}
#[test]
fn a_dropped_layer_reads_dotted_sublayers_and_uppercase() {
let dotted = "@layer reset.base {\n .x { color: red; }\n}\n";
assert!(!drop_layers(dotted, &["reset"]).contains("color"));
let upper = "@LAYER reset {\n .x { color: red; }\n}\n";
assert!(!drop_layers(upper, &["reset"]).contains("color"));
}
#[test]
fn blanking_keeps_lines_and_offsets() {
let css = "/* one\ntwo */\n\"x\ny\"\n@media (max-width: 1px) {}";
let src = blank(css, Lang::Css);
assert_eq!(src.len(), css.len());
assert_eq!(src.lines().count(), css.lines().count());
}
#[test]
fn both_quote_styles_read() {
let want = Density::Touch.media_condition();
for q in ['\'', '"'] {
let src = format!("const {CONST_NAME} = {q}{want}{q};\n");
let found = touch_density_literals(&src);
assert_eq!(found.len(), 1);
assert_eq!(found[0].1, want);
}
}
#[test]
fn a_file_list_skips_the_sheets_named_generated() {
let dir = frontend("vocab-files");
write(&dir, "css/layout.css", ".card { box-shadow: none; }\n");
write(&dir, "css/app.css", "body { color: red; }\n");
let files = [dir.join("css/layout.css"), dir.join("css/app.css")];
Vocabulary::files(&files)
.generated(&["layout.css"])
.run(&Emit::default());
let err = std::panic::catch_unwind(|| Vocabulary::files(&files).run(&Emit::default()))
.unwrap_err();
let msg = err.downcast_ref::<String>().cloned().unwrap_or_default();
assert!(msg.contains("box-shadow"), "got: {msg}");
}
}