docs.rs - mozsearch

Enable keyboard shortcuts

use std::collections::HashMap;

use std::fs;

use std::fs::File;

use std::io::Write;

use pulldown_cmark::Event::{End, Start, Text};

use pulldown_cmark::Tag::List;

use pulldown_cmark::TagEnd;

use pulldown_cmark_to_cmark::cmark;

use xshell::{cmd, Shell};

#[test]

fn reference_metrics_toc_is_sorted() {

    // Relative to `glean-core`

    let index_file = "../docs/user/reference/metrics/index.md";

    let src = fs::read_to_string(index_file).expect("unable to read file");

    let parser = pulldown_cmark::Parser::new(&src);

    let mut events = parser.into_offset_iter();

    let mut modified_events = Vec::new();

    let mut output = File::create(index_file).unwrap();

    // Everything before the list

    let mut list_start = 0;

    for (event, span) in events.by_ref() {

        if let Start(List(..)) = event {

            modified_events.push(event);

            list_start = span.start;

            break;

    // Output everything up to the list start unmodified.

    if list_start > 0 {

        writeln!(&mut output, "{}", &src[0..(list_start - 1)]).unwrap();

    let mut items = HashMap::new();

    // The list itself.

    // We store a `title -> events` mapping to sort it later by `title`.

    let mut list_end = 0;

    while let Some((event, span)) = events.next() {

        if let End(TagEnd::List(..)) = event {

            list_end = span.end;

            break;

        let mut elems = Vec::new();

        elems.push(event);

        let mut title: Option<String> = None;

        for (event, _) in events.by_ref() {

            match event {

                End(TagEnd::Item) => {

                    elems.push(End(TagEnd::Item));

                    break;

                Text(s) if title.is_none() => {

                    title = Some(s.to_string());

                    elems.push(Text(s));

                e => elems.push(e),

        items.insert(title.unwrap(), elems);

    let mut item_keys: Vec<_> = items.keys().cloned().collect();

    item_keys.sort_by_key(|item| {

        // We need to handle a few special cases:

//

        // * Dual-labeled and labeled metrics should be sorted right after their top-level metric type

        // * Normalizing plurals to be sorted correctly after the singular (quantity -> quantities)

        let mut k = item.to_ascii_lowercase();

        k = k.strip_prefix("dual-labeled ").unwrap_or(&k).to_string();

        k = k.strip_prefix("labeled ").unwrap_or(&k).to_string();

        match &*k {

            _ if item == "Dual-labeled counters" => String::from("counter3"),

            "counters" => String::from("counter2"),

            "quantities" => String::from("quantity2"),

            "strings" => String::from("string2"),

            "string list" => String::from("string3"),

            _ => k,

});

    for key in item_keys {

        let elems = items.remove(&key).unwrap();

        modified_events.extend(elems);

    modified_events.push(End(TagEnd::List(false)));

    let mut output_markdown = String::new();

    cmark(modified_events.into_iter(), &mut output_markdown).unwrap();

    writeln!(&mut output, "{output_markdown}\n").unwrap();

    // The remaining document can be printed unmodified.

    if list_end > 0 {

        write!(&mut output, "{}", &src[list_end..]).unwrap();

    // Last but not least check if we modified the document.

    let sh = Shell::new().unwrap();

    cmd!(sh, "git --no-pager diff --exit-code {index_file}")

        .run()

        .unwrap();