1use crate::form::escape_into;
38use crate::reset::Reset;
39use crate::{Emit, class, push_class};
40use makeover_layout::{Depth, Facet, FacetValue, GroupRank, Join, Selecting, Standing};
41use std::fmt::Write as _;
42
43pub const FACET_CLASSES: &[&str] = &[
50 "facet",
51 "facet-name",
52 "facet-values",
53 "facet-value",
54 "facet-take",
55 "facet-count",
56 "facet-prune",
57 "facet-rank",
58 "facet-start",
59 "facet-cut",
60 "facet-join",
61 "facet-join-word",
62];
63
64#[must_use]
67pub const fn kind_name(value: &FacetValue<'_>) -> &'static str {
68 if value.pickable {
69 "value"
70 } else if value.branching {
71 "heading"
72 } else {
73 "link"
74 }
75}
76
77#[must_use]
84pub const fn selecting_name(mode: Selecting) -> &'static str {
85 match mode {
86 Selecting::OneOf => "one-of",
87 Selecting::AnyOf => "any-of",
88 Selecting::Range => "range",
89 Selecting::Text => "text",
90 Selecting::Subtree => "subtree",
91 _ => "unknown",
96 }
97}
98
99#[must_use]
101pub const fn standing_name(standing: Standing) -> &'static str {
102 match standing {
103 Standing::Open => "open",
104 Standing::Taken => "taken",
105 Standing::Inherited => "inherited",
106 Standing::Pruned => "pruned",
107 Standing::PrunedAbove => "pruned-above",
108 _ => "open",
111 }
112}
113
114#[must_use]
142pub fn facet_html(facet: &Facet<'_>, opts: &Emit) -> String {
143 let mut html = String::new();
144 facet_html_into(facet, opts, &mut html);
145 html
146}
147
148pub fn facet_html_into(facet: &Facet<'_>, opts: &Emit, out: &mut String) {
152 emit_facet(facet, opts, &mut Buttons, out, None);
153}
154
155pub fn facet_html_with(
161 facet: &Facet<'_>,
162 opts: &Emit,
163 controls: &mut impl FacetControls,
164 out: &mut String,
165) {
166 emit_facet(facet, opts, controls, out, None);
167}
168
169pub fn facet_html_placed(
177 facet: &Facet<'_>,
178 opts: &Emit,
179 out: &mut String,
180 placed: &mut Vec<core::ops::Range<usize>>,
181) {
182 emit_facet(facet, opts, &mut Buttons, out, Some(placed));
183}
184
185#[derive(Clone, Copy, Debug, PartialEq, Eq)]
187#[non_exhaustive]
188pub enum FacetControl {
189 Take,
191 Join(Join),
193 Prune,
195}
196
197pub trait FacetControls {
202 fn draws(&mut self, _index: usize, _control: FacetControl) -> bool {
204 true
205 }
206
207 fn open(&mut self, _index: usize, _control: FacetControl, out: &mut String) -> &'static str {
210 out.push_str("<button type=\"button\"");
211 "</button>"
212 }
213
214 fn state(&mut self, _index: usize, _control: FacetControl, on: bool, out: &mut String) {
216 out.push_str(if on {
217 " aria-pressed=\"true\""
218 } else {
219 " aria-pressed=\"false\""
220 });
221 }
222
223 fn attrs(&mut self, _index: usize, _control: FacetControl, _out: &mut String) {}
225}
226
227struct Buttons;
228
229impl FacetControls for Buttons {}
230
231fn emit_facet(
232 facet: &Facet<'_>,
233 opts: &Emit,
234 controls: &mut impl FacetControls,
235 out: &mut String,
236 mut placed: Option<&mut Vec<core::ops::Range<usize>>>,
237) {
238 out.push_str("<div class=\"");
239 push_class(out, "facet", opts);
240 out.push_str("\" role=\"group\" data-selecting=\"");
241 out.push_str(selecting_name(facet.mode));
242 let _ = write!(
246 out,
247 "\" {}=\"--facet-reach: {}\">",
248 crate::VARS_ATTR,
249 facet.reach()
250 );
251
252 out.push_str("<p class=\"");
253 push_class(out, "facet-name", opts);
254 out.push_str("\">");
255 escape_into(facet.name, out);
256 out.push_str("</p>");
257
258 out.push_str("<ul class=\"");
259 push_class(out, "facet-values", opts);
260 out.push_str("\">");
261 if facet.mode.offers_values() {
262 for (index, value) in facet.values.iter().enumerate() {
263 let at = out.len();
264 value_html_into(facet, index, value, opts, controls, out);
265 if let Some(placed) = placed.as_deref_mut() {
266 placed.push(at..out.len());
267 }
268 }
269 }
270 out.push_str("</ul></div>");
271}
272
273fn control_open(
276 controls: &mut impl FacetControls,
277 index: usize,
278 control: FacetControl,
279 class: &str,
280 value: &FacetValue<'_>,
281 opts: &Emit,
282 out: &mut String,
283) -> &'static str {
284 let close = controls.open(index, control, out);
285 out.push_str(" class=\"");
286 push_class(out, class, opts);
287 out.push_str("\" data-facet-value=\"");
288 escape_into(value.value, out);
289 out.push('"');
290 close
291}
292
293fn is_empty(value: &FacetValue<'_>) -> bool {
297 value.pickable && value.count == Some(0) && value.standing == Standing::Open
298}
299
300fn value_html_into(
301 facet: &Facet<'_>,
302 index: usize,
303 value: &FacetValue<'_>,
304 opts: &Emit,
305 controls: &mut impl FacetControls,
306 out: &mut String,
307) {
308 out.push_str("<li class=\"");
309 push_class(out, "facet-value", opts);
310 out.push_str("\" data-standing=\"");
311 out.push_str(standing_name(value.standing));
312 out.push_str("\" data-kind=\"");
313 out.push_str(kind_name(value));
314 let _ = write!(
315 out,
316 "\" {}=\"--facet-depth: {}\">",
317 crate::VARS_ATTR,
318 value.depth.level
319 );
320
321 if is_empty(value) {
324 out.push_str("<span class=\"");
325 push_class(out, "facet-take", opts);
326 out.push_str("\" aria-disabled=\"true\" data-facet-value=\"");
327 escape_into(value.value, out);
328 out.push_str("\">");
329 escape_into(value.label, out);
330 out.push_str("<span class=\"");
331 push_class(out, "facet-count", opts);
332 out.push_str("\">0</span></span></li>");
333 return;
334 }
335
336 let take = FacetControl::Take;
337 let close = control_open(controls, index, take, "facet-take", value, opts, out);
338 if value.pickable {
342 controls.state(index, take, value.standing.in_force(), out);
343 }
344 if value.branching {
348 out.push_str(" aria-expanded=\"");
349 out.push_str(if value.is_open() { "true\"" } else { "false\"" });
350 }
351 controls.attrs(index, take, out);
352 out.push('>');
353 escape_into(value.label, out);
354
355 if let Some(count) = value.count {
360 out.push_str("<span class=\"");
361 push_class(out, "facet-count", opts);
362 let sign = if value.gain { "+" } else { "" };
363 let _ = write!(out, "\">{sign}{count}</span>");
364 } else if let Some(rank) = value.rank {
365 rank_html_into(rank, opts, out);
366 }
367 out.push_str(close);
368
369 if !value.pickable
370 && value.is_open()
371 && let Some(join) = value.join
372 {
373 join_html_into(index, value, join, opts, controls, out);
374 }
375
376 let prune = FacetControl::Prune;
377 if facet.mode.prunes() && value.pickable && controls.draws(index, prune) {
378 let close = control_open(controls, index, prune, "facet-prune", value, opts, out);
379 controls.state(index, prune, value.standing == Standing::Pruned, out);
382 out.push_str(" aria-label=\"");
386 escape_into(opts.exclude_label, out);
387 out.push(' ');
388 escape_into(value.label, out);
389 out.push('"');
390 controls.attrs(index, prune, out);
391 out.push_str(">\u{2718}");
396 out.push_str(close);
397 }
398
399 out.push_str("</li>");
400}
401
402pub fn rank_html_into(rank: GroupRank, opts: &Emit, out: &mut String) {
410 out.push_str("<span class=\"");
411 push_class(out, "facet-rank", opts);
412 out.push_str("\">");
413 if rank.start {
414 out.push_str("<span class=\"");
415 push_class(out, "facet-start", opts);
416 out.push_str("\">");
417 escape_into(opts.start_label, out);
418 out.push_str("</span>");
419 }
420 if rank.in_use || !rank.live {
421 out.push_str("<span class=\"");
422 push_class(out, "facet-count", opts);
423 out.push_str("\">");
424 escape_into(
425 if rank.in_use {
426 opts.in_use_label
427 } else {
428 opts.dead_label
429 },
430 out,
431 );
432 out.push_str("</span>");
433 } else {
434 out.push_str("<span class=\"");
435 push_class(out, "facet-cut", opts);
436 let _ = write!(
437 out,
438 "\" aria-hidden=\"true\" {}=\"--facet-cut: {}%\"></span>",
439 crate::VARS_ATTR,
440 rank.cut
441 );
442 }
443 out.push_str("</span>");
444}
445
446fn join_html_into(
450 index: usize,
451 value: &FacetValue<'_>,
452 join: Join,
453 opts: &Emit,
454 controls: &mut impl FacetControls,
455 out: &mut String,
456) {
457 let words = [(Join::Any, opts.any_label), (Join::All, opts.all_label)];
458 if !words
459 .iter()
460 .all(|&(word, _)| controls.draws(index, FacetControl::Join(word)))
461 {
462 return;
463 }
464 out.push_str("<span class=\"");
465 push_class(out, "facet-join", opts);
466 out.push_str("\" role=\"group\" aria-label=\"");
467 escape_into(opts.join_label, out);
468 out.push(' ');
469 escape_into(value.label, out);
470 out.push_str("\">");
471 for (word, label) in words {
472 let control = FacetControl::Join(word);
473 let close = control_open(
474 controls,
475 index,
476 control,
477 "facet-join-word",
478 value,
479 opts,
480 out,
481 );
482 out.push_str(" data-facet-join=\"");
483 out.push_str(join_name(word));
484 out.push('"');
485 controls.state(index, control, word == join, out);
486 controls.attrs(index, control, out);
487 out.push('>');
488 escape_into(label, out);
489 out.push_str(close);
490 }
491 out.push_str("</span>");
492}
493
494#[must_use]
496pub const fn join_name(join: Join) -> &'static str {
497 match join {
498 Join::All => "all",
499 _ => "any",
501 }
502}
503
504pub(crate) fn facet_rules(opts: &Emit) -> String {
513 let mut css = String::new();
514 let panel = class("facet", opts);
515 let name = class("facet-name", opts);
516 let values = class("facet-values", opts);
517 let value = class("facet-value", opts);
518 let take = class("facet-take", opts);
519 let count = class("facet-count", opts);
520 let prune = class("facet-prune", opts);
521
522 let _ = writeln!(css, ".{name} {{\n color: var(--content-muted);\n}}");
525
526 css.push_str(&Reset::BULLETS.rule(&format!(".{values}")));
530
531 let _ = writeln!(
538 css,
539 ".{value} {{\n display: flex;\n align-items: center;\n gap: var(--gap-bound);\n padding-inline-start: calc(var(--facet-depth, 0) * var(--gap-group));\n}}"
540 );
541
542 let _ = writeln!(
543 css,
544 ".{panel} {{\n min-inline-size: calc(var(--facet-reach, 0) * var(--gap-group));\n}}"
545 );
546
547 css.push_str(&Reset::FLAT_BUTTON.rule(&format!(".{take}")));
557 let _ = writeln!(
562 css,
563 ".{take} {{\n display: flex;\n flex: 1 1 auto;\n align-items: center;\n justify-content: space-between;\n gap: var(--gap-peer);\n min-block-size: var(--tap-target, 2rem);\n padding: 0 var(--gap-bound);\n color: var(--content);\n text-decoration: none;\n text-align: start;\n font: inherit;\n}}"
564 );
565 css.push_str(&crate::interactive_rules(&take, Depth::Flat, opts));
566 css.push_str(&held_rules(&take));
567
568 for standing in [Standing::Pruned, Standing::PrunedAbove] {
574 let _ = writeln!(
575 css,
576 ".{value}[data-standing=\"{}\"] .{take} {{\n color: var(--{});\n}}",
577 standing_name(standing),
578 standing.intent()
579 );
580 }
581
582 let _ = writeln!(
587 css,
588 ".{count} {{\n color: var(--content-muted);\n font-variant-numeric: tabular-nums;\n}}"
589 );
590
591 css.push_str(&Reset::FLAT_BUTTON.rule(&format!(".{prune}")));
595 let _ = writeln!(
596 css,
597 ".{prune} {{\n display: inline-flex;\n align-items: center;\n justify-content: center;\n min-block-size: var(--tap-target, 2rem);\n min-inline-size: var(--tap-target, 2rem);\n color: var(--content-secondary);\n text-decoration: none;\n font: inherit;\n}}"
598 );
599 css.push_str(&crate::interactive_rules(&prune, Depth::Flat, opts));
600 css.push_str(&held_rules(&prune));
601 let _ = writeln!(
604 css,
605 ".{panel}[data-selecting=\"subtree\"] .{take}[aria-disabled=\"true\"] {{\n margin-inline-end: calc(var(--tap-target, 2rem) + var(--gap-bound));\n}}"
606 );
607
608 let rank = class("facet-rank", opts);
612 let start = class("facet-start", opts);
613 let cut = class("facet-cut", opts);
614 let join = class("facet-join", opts);
615 let word = class("facet-join-word", opts);
616 let _ = writeln!(
617 css,
618 ".{value}[data-kind=\"heading\"] .{take} {{\n font-weight: bold;\n}}"
619 );
620 let _ = writeln!(
623 css,
624 ".{value}[data-kind=\"link\"] .{take} {{\n color: var(--content-secondary);\n}}"
625 );
626
627 let _ = writeln!(
631 css,
632 ".{rank} {{\n display: inline-flex;\n align-items: center;\n gap: var(--gap-peer);\n font-weight: normal;\n}}"
633 );
634 let _ = writeln!(css, ".{start} {{\n color: var(--content-secondary);\n}}");
635 let _ = writeln!(
636 css,
637 ".{cut} {{\n inline-size: calc(var(--gap-pane) * 2);\n block-size: var(--gap-bound);\n background: linear-gradient(to right, var(--content-secondary) var(--facet-cut, 0%), var(--surface-raised) 0);\n}}"
638 );
639
640 let _ = writeln!(
643 css,
644 ".{join} {{\n display: inline-flex;\n flex: none;\n}}"
645 );
646 css.push_str(&Reset::FLAT_BUTTON.rule(&format!(".{word}")));
647 let _ = writeln!(
648 css,
649 ".{word} {{\n min-block-size: var(--tap-target, 2rem);\n padding: 0 var(--gap-bound);\n color: var(--content-secondary);\n font: inherit;\n}}"
650 );
651 css.push_str(&crate::interactive_rules(&word, Depth::Flat, opts));
652 css.push_str(&held_rules(&word));
653
654 css
655}
656
657fn held_rules(class: &str) -> String {
666 let mut css = String::new();
667 for state in ["aria-pressed", "aria-current"] {
668 css.push_str(&crate::depth_rule(
669 &format!("{class}[{state}=\"true\"]"),
670 Depth::Well,
671 ));
672 }
673 css
674}
675
676#[cfg(test)]
677mod tests {
678 use super::*;
679 use makeover_layout::Nesting;
680
681 fn tag_values() -> [FacetValue<'static>; 3] {
682 [
683 FacetValue::new("music", "Music")
684 .standing(Standing::Taken)
685 .counted(128)
686 .at(Nesting::at(0), true),
687 FacetValue::new("music/synths", "Synths")
688 .standing(Standing::Inherited)
689 .at(Nesting::at(1), false),
690 FacetValue::new("music/drums", "Drums")
691 .standing(Standing::Pruned)
692 .at(Nesting::at(1), false),
693 ]
694 }
695
696 #[test]
697 fn a_streamed_facet_is_the_facet_the_other_form_returns() {
698 let opts = Emit {
699 class_prefix: "mk-",
700 ..Emit::default()
701 };
702 let values = tag_values();
703 for facet in [
704 Facet::new("Tag", Selecting::Subtree, &values),
705 Facet::new("Type", Selecting::AnyOf, &values),
706 Facet::new("Search", Selecting::Text, &[]),
707 ] {
708 let mut streamed = String::new();
709 facet_html_into(&facet, &opts, &mut streamed);
710 assert_eq!(streamed, facet_html(&facet, &opts));
711 }
712 }
713
714 struct Links;
717
718 impl FacetControls for Links {
719 fn draws(&mut self, index: usize, control: FacetControl) -> bool {
720 !(index == 0 && control == FacetControl::Prune)
721 }
722
723 fn open(&mut self, _index: usize, control: FacetControl, out: &mut String) -> &'static str {
724 if control == FacetControl::Take {
725 out.push_str("<a");
726 "</a>"
727 } else {
728 out.push_str("<button type=\"button\"");
729 "</button>"
730 }
731 }
732
733 fn state(&mut self, _index: usize, control: FacetControl, on: bool, out: &mut String) {
734 if control != FacetControl::Take {
735 out.push_str(if on {
736 " aria-pressed=\"true\""
737 } else {
738 " aria-pressed=\"false\""
739 });
740 } else if on {
741 out.push_str(" aria-current=\"true\"");
742 }
743 }
744
745 fn attrs(&mut self, index: usize, control: FacetControl, out: &mut String) {
746 let _ = write!(out, " data-at=\"{index}:{control:?}\"");
747 }
748 }
749
750 #[test]
751 fn the_controls_a_caller_finishes_keep_the_anatomy_and_take_its_choices() {
752 let opts = Emit::default();
753 let values = tag_values();
754 let facet = Facet::new("Tag", Selecting::Subtree, &values);
755 let mut html = String::new();
756 facet_html_with(&facet, &opts, &mut Links, &mut html);
757
758 assert!(html.contains(
759 r#"<a class="facet-take" data-facet-value="music" aria-current="true" aria-expanded="true" data-at="0:Take">Music"#
760 ), "{html}");
761 assert!(
762 html.contains(r#"<span class="facet-count">128</span></a>"#),
763 "{html}"
764 );
765 assert!(!html.contains(r#"data-at="0:Prune""#), "{html}");
767 assert!(html.contains(
768 r#"<button type="button" class="facet-prune" data-facet-value="music/drums" aria-pressed="true" aria-label="Exclude Drums" data-at="2:Prune">"#
769 ), "{html}");
770
771 let groups = group_values();
772 let facet = Facet::new("Tags", Selecting::Subtree, &groups);
773 let mut html = String::new();
774 facet_html_with(&facet, &opts, &mut Links, &mut html);
775 assert!(html.contains(
776 r#"class="facet-join-word" data-facet-value="genre" data-facet-join="all" aria-pressed="true" data-at="0:Join(All)">"#
777 ), "{html}");
778 }
779
780 #[test]
781 fn a_caller_that_changes_nothing_writes_the_plain_facet() {
782 let opts = Emit {
783 class_prefix: "mk-",
784 ..Emit::default()
785 };
786 struct Plain;
787 impl FacetControls for Plain {}
788 let values = tag_values();
789 let groups = group_values();
790 for facet in [
791 Facet::new("Tag", Selecting::Subtree, &values),
792 Facet::new("Tags", Selecting::Subtree, &groups),
793 ] {
794 let mut with = String::new();
795 facet_html_with(&facet, &opts, &mut Plain, &mut with);
796 assert_eq!(with, facet_html(&facet, &opts));
797 }
798 }
799
800 #[test]
801 fn only_a_subtree_draws_an_exclude_affordance() {
802 let values = tag_values();
805 let subtree = facet_html(
806 &Facet::new("Tag", Selecting::Subtree, &values),
807 &Emit::default(),
808 );
809 assert!(subtree.contains("facet-prune"));
810 assert!(subtree.contains(r#"aria-label="Exclude Drums""#));
811 assert!(subtree.contains("\u{2718}</button>"), "{subtree}");
813 assert!(!subtree.contains('\u{2715}'), "{subtree}");
814
815 let flat = facet_html(
816 &Facet::new("Type", Selecting::AnyOf, &values),
817 &Emit::default(),
818 );
819 assert!(!flat.contains("facet-prune"));
820 }
821
822 #[test]
823 fn an_inherited_value_reads_as_pressed_without_having_been_pressed() {
824 let values = tag_values();
828 let html = facet_html(
829 &Facet::new("Tag", Selecting::Subtree, &values),
830 &Emit::default(),
831 );
832 let synths = html
833 .split("<li")
834 .find(|chunk| chunk.contains("music/synths"))
835 .expect("the inherited value");
836 assert!(synths.contains(r#"data-standing="inherited""#));
837 assert!(synths.contains(r#"aria-pressed="true""#));
838
839 let drums = html
840 .split("<li")
841 .find(|chunk| chunk.contains("music/drums"))
842 .expect("the pruned value");
843 assert!(drums.contains(r#"data-standing="pruned""#));
846 assert!(drums.contains(r#"aria-pressed="false""#));
847 assert!(drums.contains(r#"aria-label="Exclude Drums""#));
848 }
849
850 #[test]
851 fn a_value_is_one_line_laid_out_with_geometry_that_exists() {
852 let css = facet_rules(&Emit::default());
853 assert!(!css.contains("--space-tight"), "{css}");
856 assert!(css.contains("var(--gap-group)"), "{css}");
857 assert!(css.contains("justify-content: space-between"), "{css}");
858 assert!(css.contains("font-variant-numeric: tabular-nums"), "{css}");
859 assert!(css.contains("text-decoration: none"), "{css}");
860 }
861
862 #[test]
863 fn a_value_drawn_as_a_link_is_held_in_while_it_is_in_force() {
864 let css = facet_rules(&Emit::default());
865 for control in ["facet-take", "facet-prune"] {
866 assert!(
867 css.contains(&format!(r#".{control}[aria-current="true"]"#)),
868 "{control} drawn as an anchor must read pressed in force: {css}"
869 );
870 assert!(css.contains(&format!(r#".{control}[aria-pressed="true"]"#)));
871 }
872 }
873
874 #[test]
875 fn a_value_under_a_prune_is_named_and_reads_back_like_one() {
876 let values = [FacetValue::new("music/drums/808", "808")
877 .standing(Standing::PrunedAbove)
878 .at(Nesting::at(2), false)];
879 let html = facet_html(
880 &Facet::new("Tag", Selecting::Subtree, &values),
881 &Emit::default(),
882 );
883 assert!(html.contains(r#"data-standing="pruned-above""#), "{html}");
884 assert!(
886 !html
887 .contains(r#"facet-prune" data-facet-value="music/drums/808" aria-pressed="true""#)
888 );
889
890 let css = facet_rules(&Emit::default());
891 assert!(
892 css.contains(r#"[data-standing="pruned-above"]"#),
893 "the sheet reads a value under a prune back a step: {css}"
894 );
895 }
896
897 #[test]
898 fn a_mode_that_lists_nothing_still_renders_its_panel() {
899 let html = facet_html(
902 &Facet::new("Search", Selecting::Text, &[]),
903 &Emit::default(),
904 );
905 assert!(html.contains("facet-name"));
906 assert!(html.contains(r#"data-selecting="text""#));
907 assert!(!html.contains("facet-take"));
908 }
909
910 #[test]
911 fn a_value_counted_at_zero_answers_no_press_and_takes_the_disabled_ink() {
912 let values = [
913 FacetValue::of("Live").counted(0),
914 FacetValue::of("Audio").counted(12),
915 FacetValue::of("Video"),
916 FacetValue::of("Text").counted(0).standing(Standing::Taken),
917 ];
918 let html = facet_html(
919 &Facet::new("Medium", Selecting::Subtree, &values),
920 &Emit::default(),
921 );
922 let line = |label: &str| {
923 let at = html.find(&format!(">{label}<")).expect(label);
924 let start = html[..at].rfind("<li").expect("li");
925 let end = at + html[at..].find("</li>").expect("/li");
926 html[start..end].to_owned()
927 };
928 let live = line("Live");
929 assert!(
930 live.contains(r#"<span class="facet-take" aria-disabled="true""#),
931 "{live}"
932 );
933 assert!(!live.contains("<button"), "{live}");
934 assert!(!live.contains("facet-prune"), "{live}");
935 assert!(
936 live.contains(r#"<span class="facet-count">0</span>"#),
937 "{live}"
938 );
939 for label in ["Audio", "Video", "Text"] {
940 let other = line(label);
941 assert!(other.contains("<button"), "{other}");
942 assert!(!other.contains("aria-disabled"), "{other}");
943 }
944
945 let css = facet_rules(&Emit::default());
946 assert!(css.contains("color: var(--content-disabled)"), "{css}");
947 assert!(
948 css.contains(r#".facet[data-selecting="subtree"] .facet-take[aria-disabled="true"]"#),
949 "{css}"
950 );
951 }
952
953 #[test]
954 fn an_unmeasured_count_emits_no_number_at_all() {
955 let values = [FacetValue::of("Ambient")];
958 let html = facet_html(
959 &Facet::new("Tag", Selecting::AnyOf, &values),
960 &Emit::default(),
961 );
962 assert!(!html.contains("facet-count"));
963
964 let counted = [FacetValue::of("Ambient").counted(0)];
965 let html = facet_html(
966 &Facet::new("Tag", Selecting::AnyOf, &counted),
967 &Emit::default(),
968 );
969 assert!(html.contains(">0</span>"));
970 }
971
972 #[test]
973 fn the_gutter_is_reserved_from_the_deepest_value_before_anything_is_drawn() {
974 let values = tag_values();
977 let html = facet_html(
978 &Facet::new("Tag", Selecting::Subtree, &values),
979 &Emit::default(),
980 );
981 assert!(html.contains("--facet-reach: 1"));
982 assert!(html.contains("--facet-depth: 0"));
983 assert!(html.contains("--facet-depth: 1"));
984 }
985
986 #[test]
987 fn labels_and_identifiers_are_escaped_like_every_other_string() {
988 let values = [FacetValue::new("a&b", "A & B")];
991 let html = facet_html(
992 &Facet::new("T<ag>", Selecting::AnyOf, &values),
993 &Emit::default(),
994 );
995 assert!(html.contains("A & B"));
996 assert!(html.contains(r#"data-facet-value="a&b""#));
997 assert!(html.contains("T<ag>"));
998 assert!(!html.contains("<ag>"));
999 }
1000
1001 #[test]
1002 fn a_value_reads_flat_before_it_is_touched() {
1003 let css = facet_rules(&Emit::default());
1009 for name in ["facet-take", "facet-prune"] {
1010 assert!(
1011 css.contains(&format!(
1012 ".{name} {{\n background: none;\n border: none;\n box-shadow: none;\n}}"
1013 )),
1014 "{name} is not withdrawn: {css}"
1015 );
1016 }
1017 }
1018
1019 #[test]
1020 fn every_class_this_module_emits_is_one_the_stylesheet_rules() {
1021 let names = crate::vocabulary::names(&Emit::default());
1024 for name in FACET_CLASSES {
1025 assert!(
1026 names.contains(&crate::class(name, &Emit::default())),
1027 "{name} is not in the vocabulary"
1028 );
1029 }
1030 }
1031
1032 #[test]
1033 fn the_prefix_reaches_every_class_in_the_markup() {
1034 let opts = Emit {
1037 class_prefix: "mo-",
1038 ..Emit::default()
1039 };
1040 let values = tag_values();
1041 let mut html = facet_html(&Facet::new("Tag", Selecting::Subtree, &values), &opts);
1042 let groups = group_values();
1043 html.push_str(&facet_html(
1044 &Facet::new("Tags", Selecting::Subtree, &groups),
1045 &opts,
1046 ));
1047 for name in FACET_CLASSES {
1048 assert!(html.contains(&format!("mo-{name}")), "{name} is unprefixed");
1049 }
1050 }
1051
1052 fn group_values() -> [FacetValue<'static>; 5] {
1055 [
1056 FacetValue::new("genre", "Genre")
1057 .heading()
1058 .at(Nesting::at(0), true)
1059 .opened(true)
1060 .joined(Join::All)
1061 .ranked(GroupRank::in_use()),
1062 FacetValue::new("genre.ambient", "Ambient")
1063 .standing(Standing::Taken)
1064 .counted(12)
1065 .at(Nesting::at(1), false),
1066 FacetValue::new("genre.drone", "Drone")
1067 .counted(3)
1068 .gained()
1069 .at(Nesting::at(1), false),
1070 FacetValue::new("mood", "Mood")
1071 .heading()
1072 .at(Nesting::at(0), true)
1073 .opened(false)
1074 .joined(Join::Any)
1075 .ranked(GroupRank::cutting(70).starting()),
1076 FacetValue::new("more", "More groups (2)").heading(),
1077 ]
1078 }
1079
1080 #[test]
1081 fn a_group_opens_rather_than_picks_and_says_how_its_picks_combine() {
1082 let groups = group_values();
1083 let html = facet_html(
1084 &Facet::new("Tags", Selecting::Subtree, &groups),
1085 &Emit::default(),
1086 );
1087 let genre = html.split("<li").nth(1).unwrap();
1089 assert!(genre.contains(r#"data-kind="heading""#), "{genre}");
1090 assert!(genre.contains(r#"aria-expanded="true""#), "{genre}");
1091 assert!(!genre.contains("aria-pressed=\"false\">Genre"), "{genre}");
1092 assert!(!genre.contains("facet-prune"), "{genre}");
1093 assert!(genre.contains("in use"), "{genre}");
1094 assert!(
1096 genre.contains(r#"data-facet-join="all" aria-pressed="true""#),
1097 "{genre}"
1098 );
1099 assert!(html.contains(">+3</span>"), "{html}");
1101 let mood = html.split("<li").nth(4).unwrap();
1103 assert!(!mood.contains("facet-join"), "{mood}");
1104 assert!(mood.contains("start here"), "{mood}");
1105 assert!(mood.contains("--facet-cut: 70%"), "{mood}");
1106 let more = html.split("<li").nth(5).unwrap();
1108 assert!(more.contains(r#"data-kind="link""#), "{more}");
1109 assert!(
1110 !more.contains("aria-pressed") && !more.contains("aria-expanded"),
1111 "{more}"
1112 );
1113 }
1114}