xgettext.rs

// Copyright 2023 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

//! This file contains main logic used by the binary `mdbook-xgettext`.

use std::collections::HashMap;
use std::{io, path};

use super::{extract_events, extract_messages, reconstruct_markdown, wrap_sources};
use anyhow::{anyhow, Context};
use mdbook::renderer::RenderContext;
use mdbook::{book, BookItem};
use polib::catalog::Catalog;
use polib::message::{Message, MessageMutView, MessageView};
use polib::metadata::CatalogMetadata;
use pulldown_cmark::{Event, Tag, TagEnd};

/// Strip an optional link from a Markdown string.
fn strip_link(text: &str) -> String {
    let events = extract_events(text, None)
        .into_iter()
        .filter_map(|(_, event)| match event {
            Event::Start(Tag::Link { .. }) => None,
            Event::End(TagEnd::Link) => None,
            _ => Some((0, event)),
        })
        .collect::<Vec<_>>();
    let (without_link, _) = reconstruct_markdown(&events, None);
    without_link
}

fn add_message(catalog: &mut Catalog, msgid: &str, source: &str, comment: &str) {
    let sources = match catalog.find_message(None, msgid, None) {
        Some(msg) => format!("{}\n{}", msg.source(), source),
        None => String::from(source),
    };
    let message = Message::build_singular()
        .with_source(sources)
        .with_msgid(String::from(msgid))
        .with_comments(String::from(comment))
        .done();
    catalog.append_or_update(message);
}

/// Build a source line for a catalog message.
///
/// Use `granularity` to round `lineno`:
///
/// - Set `granularity` to `1` if you want no rounding.
/// - Set `granularity` to `0` if you want to line number at all.
/// - Set `granularity` to `n` if you want rounding down to the
///   nearest multiple of `n`. As an example, if you set it to `10`,
///   then you will get sources like `foo.md:1`, `foo.md:10`,
///   `foo.md:20`, etc.
///
/// This can help reduce number of updates to your PO files.
fn build_source<P: AsRef<path::Path>>(path: P, lineno: usize, granularity: usize) -> String {
    let path = path.as_ref();
    match granularity {
        0 => format!("{}", path.display()),
        1 => format!("{}:{}", path.display(), lineno),
        _ => format!(
            "{}:{}",
            path.display(),
            std::cmp::max(1, lineno - (lineno % granularity))
        ),
    }
}

fn dedup_sources(catalog: &mut Catalog) {
    for mut message in catalog.messages_mut() {
        let mut lines: Vec<&str> = message.source().lines().collect();
        lines.dedup();

        let wrapped_source = wrap_sources(&lines.join("\n"));
        *message.source_mut() = wrapped_source;
    }
}

/// Build CatalogMetadata from RenderContext
fn generate_catalog_metadata(ctx: &RenderContext) -> CatalogMetadata {
    let mut metadata = CatalogMetadata::new();
    if let Some(title) = &ctx.config.book.title {
        metadata.project_id_version = String::from(title);
    }
    if let Some(lang) = &ctx.config.book.language {
        metadata.language = String::from(lang);
    }
    let now = chrono::Local::now();
    metadata.pot_creation_date = now.to_rfc3339_opts(chrono::SecondsFormat::Secs, true);
    metadata.mime_version = String::from("1.0");
    metadata.content_type = String::from("text/plain; charset=UTF-8");
    metadata.content_transfer_encoding = String::from("8bit");
    metadata
}

/// Build catalog from RenderContext
///
/// The `summary_reader` is a closure which should return the
/// `SUMMARY.md` found at the given path.
pub fn create_catalogs<F>(
    ctx: &RenderContext,
    summary_reader: F,
) -> anyhow::Result<HashMap<path::PathBuf, Catalog>>
where
    F: Fn(path::PathBuf) -> io::Result<String>,
{
    let metadata = generate_catalog_metadata(ctx);
    let mut catalog = Catalog::new(metadata);

    // The line number granularity: we default to 1, but it can be
    // overridden as needed.
    let granularity = match ctx
        .config
        .get_renderer("xgettext")
        .and_then(|cfg| cfg.get("granularity"))
    {
        None => 1,
        Some(value) => value
            .as_integer()
            .and_then(|i| (i >= 0).then_some(i as usize))
            .ok_or_else(|| {
                anyhow!("Expected an unsigned integer for output.xgettext.granularity")
            })?,
    };

    // First, add all chapter names and part titles from SUMMARY.md.
    let summary_path = ctx.config.book.src.join("SUMMARY.md");
    let summary = summary_reader(ctx.root.join(&summary_path))
        .with_context(|| anyhow!("Failed to read {}", summary_path.display()))?;
    for (lineno, extracted_msg) in extract_messages(&summary) {
        let msgid = extracted_msg.message;
        let source = build_source(&summary_path, lineno, granularity);
        // The summary is mostly links like "[Foo *Bar*](foo-bar.md)".
        // We strip away the link to get "Foo *Bar*". The formatting
        // is stripped away by mdbook when it sends the book to
        // mdbook-gettext -- we keep the formatting here in case the
        // same text is used for the page title.
        add_message(
            &mut catalog,
            &strip_link(&msgid),
            &source,
            &extracted_msg.comment,
        );
    }

    let mut catalogs = HashMap::new();

    // The depth on which to split the output file. The default is to
    // include all messages into a single POT file (depth == 0).
    // Greater values will split POT files, digging into the
    // sub-chapters within each chapter.
    let depth = match ctx
        .config
        .get_renderer("xgettext")
        .and_then(|cfg| cfg.get("depth"))
    {
        None => 0,
        Some(value) => value
            .as_integer()
            .and_then(|i| (i >= 0).then_some(i as usize))
            .ok_or_else(|| anyhow!("Expected an unsigned integer for output.xgettext.depth"))?,
    };

    // The catalog from the summary data will exist in the single pot
    // file for a depth of 0, will exist in a top-level separate
    // `summary.pot` file for a depth of 1, or exist within in a
    // `summary.pot` file within the default directory for chapters
    // without a corresponding part title.
    let mut current_top_level = "summary".to_owned();
    let mut summary_destination = match depth {
        0 => path::PathBuf::from("messages"),
        1 => path::PathBuf::from("summary"),
        _ => path::PathBuf::from(&current_top_level).join("summary"),
    };
    let _: bool = summary_destination.set_extension("pot");
    catalogs.insert(summary_destination, catalog);

    // Next, we add the chapter contents.
    for item in &ctx.book.sections {
        if let BookItem::PartTitle(title) = item {
            // Iterating through the book in section-order, the
            // PartTitle represents the 'section' that each chapter
            // exists within.
            current_top_level = slug(title);
        } else if let BookItem::Chapter(chapter) = item {
            let path = match &chapter.path {
                Some(path) => ctx.config.book.src.join(path),
                None => continue,
            };
            let directory = match depth {
                0 => path::PathBuf::from("messages"),
                1 => path::PathBuf::from(current_top_level.clone()),
                // The current chapter is already at depth 2, so
                // append the chapter's name for depths greater than
                // 1.
                _ => path::PathBuf::from(current_top_level.clone()).join(slug(&chapter.name)),
            };

            // Add the (destination, catalog) to the map if it doesn't
            // yet exist, so messages can be appended to the catalog.
            let mut destination = directory.clone();
            let _: bool = destination.set_extension("pot");
            let catalog = catalogs
                .entry(destination.clone())
                .or_insert_with(|| Catalog::new(generate_catalog_metadata(ctx)));

            for (lineno, extracted) in extract_messages(&chapter.content) {
                let msgid = extracted.message;
                let source = build_source(&path, lineno, granularity);
                add_message(catalog, &msgid, &source, &extracted.comment);
            }

            // Add the contents for all of the sub-chapters within the
            // current chapter.
            for Chapter {
                content,
                source,
                mut destination,
            } in get_subcontent_for_chapter(chapter, directory, depth, 2)
            {
                let _: bool = destination.set_extension("pot");
                let catalog = catalogs
                    .entry(destination.clone())
                    .or_insert_with(|| Catalog::new(generate_catalog_metadata(ctx)));

                let path = ctx.config.book.src.join(&source);
                for (lineno, extracted) in extract_messages(&content) {
                    let msgid = extracted.message;
                    let source = build_source(&path, lineno, granularity);
                    add_message(catalog, &msgid, &source, &extracted.comment);
                }
            }
        }
    }
    catalogs
        .iter_mut()
        .for_each(|(_key, catalog)| dedup_sources(catalog));
    Ok(catalogs)
}

/// A view into the relevant template information held by
/// `mdbook::book::Chapter` and a location to store the exported polib
/// messages.
struct Chapter {
    /// The chapter's content.
    content: String,
    /// The file where the content is sourced.
    source: path::PathBuf,
    /// The output destination for the polib template.
    destination: path::PathBuf,
}

// A recursive function to crawl a chapter's sub-items and get the
// relevant info to produce a set of po template files.
fn get_subcontent_for_chapter(
    c: &book::Chapter,
    provided_file_path: path::PathBuf,
    provided_depth: usize,
    depth: usize,
) -> Vec<Chapter> {
    if c.sub_items.is_empty() {
        return Vec::new();
    };

    // Iterate through sub-chapters and pull the chapter content,
    // path, and destination to store the template.
    c.sub_items
        .iter()
        .filter_map(|item| {
            let BookItem::Chapter(chapter) = item else {
                return None;
            };
            let (chapter_info, new_path) = match &chapter.path {
                Some(chapter_path) => {
                    // Append the chapter's name to the template's
                    // destination when the depth has not surpassed
                    // the provided value.
                    let destination = if depth < provided_depth {
                        provided_file_path.join(slug(&chapter.name))
                    } else {
                        provided_file_path.clone()
                    };

                    let info = Chapter {
                        content: chapter.content.clone(),
                        source: chapter_path.clone(),
                        destination: destination.clone(),
                    };
                    (Some(info), destination)
                }
                None => (None, provided_file_path.clone()),
            };

            // Recursively call to get sub-chapter contents.
            Some(chapter_info.into_iter().chain(get_subcontent_for_chapter(
                chapter,
                new_path,
                provided_depth,
                depth + 1,
            )))
        })
        .flatten()
        .collect()
}

// Trim a string slice to only contain alphanumeric characters and
// dashes.
fn slug(title: &str) -> String {
    // Specially handle "C++" to format it as "cpp" instead of "c".
    let title = title.to_lowercase().replace("c++", "cpp");
    title
        .split_whitespace()
        .map(|word| {
            word.chars()
                .filter(|&ch| ch == '-' || ch.is_ascii_alphanumeric())
                .collect::<String>()
        })
        .filter(|word| !word.is_empty())
        .collect::<Vec<_>>()
        .join("-")
}

#[cfg(test)]
mod tests {
    use super::*;
    use mdbook::MDBook;
    use pretty_assertions::assert_eq;

    fn create_render_context(
        files: &[(&str, &str)],
    ) -> anyhow::Result<(RenderContext, tempfile::TempDir)> {
        let tmpdir = tempfile::tempdir().context("Could not create temporary directory")?;
        std::fs::create_dir(tmpdir.path().join("src"))
            .context("Could not create src/ directory")?;

        // Dynamically create the directories for the listed files.
        // Write the contents to the file in the specified directory.
        for (path, contents) in files {
            let file_path = tmpdir.path().join(path);
            let directory_path = file_path
                .parent()
                .context("File path unexpectedly ended in a root or prefix")?;

            std::fs::create_dir_all(directory_path).context(format!(
                "Could not create directory {}",
                directory_path.display()
            ))?;
            std::fs::write(file_path.clone(), contents)
                .with_context(|| format!("Could not write {}", file_path.display()))?;
        }

        let mdbook = MDBook::load(tmpdir.path()).context("Could not load book")?;
        let ctx = RenderContext::new(mdbook.root, mdbook.book, mdbook.config, "dest");
        Ok((ctx, tmpdir))
    }

    fn default_template_file() -> path::PathBuf {
        path::PathBuf::from("messages.pot")
    }

    #[test]
    fn test_strip_link_empty() {
        assert_eq!(strip_link(""), "");
    }

    #[test]
    fn test_strip_link_text() {
        assert_eq!(strip_link("Summary"), "Summary");
    }

    #[test]
    fn test_strip_link_with_formatting() {
        // The formatting is automatically normalized.
        assert_eq!(strip_link("[foo *bar* `baz`](foo.md)"), "foo _bar_ `baz`");
    }

    #[test]
    fn test_build_source_granularity_zero() {
        assert_eq!(build_source("foo.md", 0, 0), "foo.md");
        assert_eq!(build_source("foo.md", 1, 0), "foo.md");
        assert_eq!(build_source("foo.md", 9, 0), "foo.md");
        assert_eq!(build_source("foo.md", 10, 0), "foo.md");
        assert_eq!(build_source("foo.md", 11, 0), "foo.md");
        assert_eq!(build_source("foo.md", 20, 0), "foo.md");
    }

    #[test]
    fn test_build_source_granularity_one() {
        assert_eq!(build_source("foo.md", 0, 1), "foo.md:0");
        assert_eq!(build_source("foo.md", 1, 1), "foo.md:1");
        assert_eq!(build_source("foo.md", 9, 1), "foo.md:9");
        assert_eq!(build_source("foo.md", 10, 1), "foo.md:10");
        assert_eq!(build_source("foo.md", 11, 1), "foo.md:11");
        assert_eq!(build_source("foo.md", 20, 1), "foo.md:20");
    }

    #[test]
    fn test_build_source_granularity_ten() {
        assert_eq!(build_source("foo.md", 0, 10), "foo.md:1");
        assert_eq!(build_source("foo.md", 1, 10), "foo.md:1");
        assert_eq!(build_source("foo.md", 9, 10), "foo.md:1");
        assert_eq!(build_source("foo.md", 10, 10), "foo.md:10");
        assert_eq!(build_source("foo.md", 11, 10), "foo.md:10");
        assert_eq!(build_source("foo.md", 20, 10), "foo.md:20");
    }

    #[test]
    fn test_create_catalog_defaults() -> anyhow::Result<()> {
        let (ctx, _tmp) =
            create_render_context(&[("book.toml", "[book]"), ("src/SUMMARY.md", "")])?;

        let catalogs = create_catalogs(&ctx, std::fs::read_to_string).unwrap();
        let catalog = &catalogs[&default_template_file()];
        assert_eq!(catalog.metadata.project_id_version, "");
        assert!(!catalog.metadata.pot_creation_date.is_empty());
        assert!(catalog.metadata.po_revision_date.is_empty());
        assert_eq!(catalog.metadata.language, "en");
        assert_eq!(catalog.metadata.mime_version, "1.0");
        assert_eq!(catalog.metadata.content_type, "text/plain; charset=UTF-8");
        assert_eq!(catalog.metadata.content_transfer_encoding, "8bit");
        Ok(())
    }

    #[test]
    fn test_create_catalog_metadata() -> anyhow::Result<()> {
        let (ctx, _tmp) = create_render_context(&[
            (
                "book.toml",
                "[book]\n\
                 title = \"My Translatable Book\"\n\
                 language = \"fr\"",
            ),
            ("src/SUMMARY.md", ""),
        ])?;

        // Using a depth of 0 to include all messages in a single
        // template file.
        let catalogs = create_catalogs(&ctx, std::fs::read_to_string)?;
        let catalog = &catalogs[&default_template_file()];
        assert_eq!(catalog.metadata.project_id_version, "My Translatable Book");
        assert_eq!(catalog.metadata.language, "fr");
        Ok(())
    }

    #[test]
    fn test_create_catalog_summary_formatting() -> anyhow::Result<()> {
        let (ctx, _tmp) = create_render_context(&[
            ("book.toml", "[book]"),
            (
                "src/SUMMARY.md",
                "# Summary\n\
                 \n\
                 [Prefix Chapter](prefix.md)\n\
                 \n\
                 # Part Title\n\
                 \n\
                 - [Foo *Bar*](foo.md)\n\
                 \n\
                 ----------\n\
                 \n\
                 - [Baz `Quux`](baz.md)\n\
                 \n\
                 [Suffix Chapter](suffix.md)",
            ),
            // Without this, mdbook would automatically create the
            // files based on the summary above. This would add
            // unnecessary headings below.
            ("src/prefix.md", ""),
            ("src/foo.md", ""),
            ("src/baz.md", ""),
            ("src/suffix.md", ""),
        ])?;

        let catalogs = create_catalogs(&ctx, std::fs::read_to_string)?;
        let catalog = &catalogs[&default_template_file()];
        assert_eq!(
            catalog
                .messages()
                .map(|msg| msg.msgid())
                .collect::<Vec<&str>>(),
            &[
                "Summary",
                "Prefix Chapter",
                "Part Title",
                "Foo _Bar_",
                "Baz `Quux`",
                "Suffix Chapter",
            ]
        );

        Ok(())
    }

    #[test]
    fn test_create_catalogs() -> anyhow::Result<()> {
        let (ctx, _tmp) = create_render_context(&[
            ("book.toml", "[book]"),
            ("src/SUMMARY.md", "- [The *Foo* Chapter](foo.md)"),
            (
                "src/foo.md",
                "# How to Foo\n\
                 \n\
                 First paragraph.\n\
                 Same paragraph.\n\
                 \n\
                 [Link](https://example.com)\n",
            ),
        ])?;

        let catalogs = create_catalogs(&ctx, std::fs::read_to_string)?;
        let catalog = &catalogs[&default_template_file()];

        for msg in catalog.messages() {
            assert!(!msg.is_translated());
        }

        assert_eq!(
            catalog
                .messages()
                .map(|msg| (msg.source(), msg.msgid()))
                .collect::<Vec<_>>(),
            &[
                ("src/SUMMARY.md:1", "The _Foo_ Chapter"),
                ("src/foo.md:1", "How to Foo"),
                ("src/foo.md:3", "First paragraph. Same paragraph."),
                ("src/foo.md:6", "[Link](https://example.com)"),
            ]
        );

        Ok(())
    }

    #[test]
    fn test_create_catalog_duplicates() -> anyhow::Result<()> {
        let (ctx, _tmp) = create_render_context(&[
            ("book.toml", "[book]"),
            ("src/SUMMARY.md", "- [Foo](foo.md)"),
            (
                "src/foo.md",
                "# Foo\n\
                 \n\
                 Foo\n",
            ),
        ])?;

        let catalogs = create_catalogs(&ctx, std::fs::read_to_string)?;
        let catalog = &catalogs[&default_template_file()];
        assert_eq!(
            catalog
                .messages()
                .map(|msg| (msg.source(), msg.msgid()))
                .collect::<Vec<_>>(),
            &[("src/SUMMARY.md:1 src/foo.md:1 src/foo.md:3", "Foo"),]
        );

        Ok(())
    }

    #[test]
    fn test_create_catalog_lineno_granularity() -> anyhow::Result<()> {
        let (ctx, _tmp) = create_render_context(&[
            (
                "book.toml",
                "[book]\n\
                 [output.xgettext]\n\
                 granularity = 5",
            ),
            ("src/SUMMARY.md", "- [Foo](foo.md)"),
            (
                "src/foo.md",
                "- Line 1\n\
                 \n\
                 - Line 3\n\
                 \n\
                 - Line 5\n\
                 \n\
                 - Line 7\n\
                 ",
            ),
        ])?;

        let catalogs = create_catalogs(&ctx, std::fs::read_to_string)?;
        let catalog = &catalogs[&default_template_file()];
        assert_eq!(
            catalog
                .messages()
                .map(|msg| (msg.source(), msg.msgid()))
                .collect::<Vec<_>>(),
            &[
                ("src/SUMMARY.md:1", "Foo"),
                ("src/foo.md:1", "Line 1"),
                ("src/foo.md:1", "Line 3"),
                ("src/foo.md:5", "Line 5"),
                ("src/foo.md:5", "Line 7"),
            ]
        );

        Ok(())
    }

    #[test]
    fn test_create_catalog_lineno_granularity_duplicates() -> anyhow::Result<()> {
        let (ctx, _tmp) = create_render_context(&[
            (
                "book.toml",
                "[book]\n\
                 [output.xgettext]\n\
                 granularity = 3",
            ),
            ("src/SUMMARY.md", "- [Foo](foo.md)"),
            (
                "src/foo.md",
                "Bar\n\
                 \n\
                 Bar\n\
                 \n\
                 Bar\n",
            ),
        ])?;

        let catalogs = create_catalogs(&ctx, std::fs::read_to_string)?;
        let catalog = &catalogs[&default_template_file()];
        assert_eq!(
            catalog
                .messages()
                .map(|msg| (msg.source(), msg.msgid()))
                .collect::<Vec<_>>(),
            &[
                ("src/SUMMARY.md:1", "Foo"),
                ("src/foo.md:1 src/foo.md:3", "Bar"),
            ]
        );

        Ok(())
    }

    #[test]
    fn test_create_catalog_nested_directories() -> anyhow::Result<()> {
        let (ctx, _tmp) = create_render_context(&[
            ("book.toml", "[book]"),
            (
                "src/SUMMARY.md",
                "- [The Foo Chapter](foo.md)\n\
                \t- [The Bar Section](foo/bar.md)\n\
                \t\t- [The Baz Subsection](foo/bar/baz.md)",
            ),
            (
                "src/foo.md",
                "# How to Foo\n\
                 \n\
                 The first paragraph about Foo.\n",
            ),
            (
                "src/foo/bar.md",
                "# How to Bar\n\
                 \n\
                 The first paragraph about Bar.\n",
            ),
            (
                "src/foo/bar/baz.md",
                "# How to Baz\n\
                 \n\
                 The first paragraph about Baz.\n",
            ),
        ])?;

        let catalogs = create_catalogs(&ctx, std::fs::read_to_string)?;
        let catalog = &catalogs[&default_template_file()];

        for msg in catalog.messages() {
            assert!(!msg.is_translated());
        }

        let expected_message_tuples = vec![
            ("src/SUMMARY.md:1", "The Foo Chapter"),
            ("src/SUMMARY.md:2", "The Bar Section"),
            ("src/SUMMARY.md:3", "The Baz Subsection"),
            ("src/foo.md:1", "How to Foo"),
            ("src/foo.md:3", "The first paragraph about Foo."),
            ("src/foo/bar.md:1", "How to Bar"),
            ("src/foo/bar.md:3", "The first paragraph about Bar."),
            ("src/foo/bar/baz.md:1", "How to Baz"),
            ("src/foo/bar/baz.md:3", "The first paragraph about Baz."),
        ];

        let message_tuples = catalog
            .messages()
            .map(|msg| (msg.source(), msg.msgid()))
            .collect::<Vec<(&str, &str)>>();

        assert_eq!(expected_message_tuples, message_tuples);

        Ok(())
    }
    #[test]

    fn test_create_catalog_nested_directories_respects_granularity() -> anyhow::Result<()> {
        let (ctx, _tmp) = create_render_context(&[
            (
                "book.toml",
                "[book]\n\
                 [output.xgettext]\n\
                 granularity=0",
            ),
            (
                "src/SUMMARY.md",
                "- [The Foo Chapter](foo.md)\n\
                \t- [The Bar Section](foo/bar.md)\n\
                \t\t- [The Baz Subsection](foo/bar/baz.md)",
            ),
            (
                "src/foo.md",
                "# How to Foo\n\
                 \n\
                 The first paragraph about Foo.\n",
            ),
            (
                "src/foo/bar.md",
                "# How to Bar\n\
                 \n\
                 The first paragraph about Bar.\n",
            ),
            (
                "src/foo/bar/baz.md",
                "# How to Baz\n\
                 \n\
                 The first paragraph about Baz.\n",
            ),
        ])?;

        let catalogs = create_catalogs(&ctx, std::fs::read_to_string)?;
        let catalog = &catalogs[&default_template_file()];

        for msg in catalog.messages() {
            assert!(!msg.is_translated());
        }

        let expected_message_tuples = vec![
            ("src/SUMMARY.md", "The Foo Chapter"),
            ("src/SUMMARY.md", "The Bar Section"),
            ("src/SUMMARY.md", "The Baz Subsection"),
            ("src/foo.md", "How to Foo"),
            ("src/foo.md", "The first paragraph about Foo."),
            ("src/foo/bar.md", "How to Bar"),
            ("src/foo/bar.md", "The first paragraph about Bar."),
            ("src/foo/bar/baz.md", "How to Baz"),
            ("src/foo/bar/baz.md", "The first paragraph about Baz."),
        ];

        let message_tuples = catalog
            .messages()
            .map(|msg| (msg.source(), msg.msgid()))
            .collect::<Vec<(&str, &str)>>();

        assert_eq!(expected_message_tuples, message_tuples);

        Ok(())
    }

    #[test]
    fn test_split_catalog_nested_directories_depth_1() -> anyhow::Result<()> {
        let (ctx, _tmp) = create_render_context(&[
            (
                "book.toml",
                "[book]\n\
                 [output.xgettext]\n\
                 depth = 1",
            ),
            (
                "src/SUMMARY.md",
                "# Summary\n\n\
                 - [Intro](index.md)\n\
                 # Foo\n\n\
                 - [The Foo Chapter](foo.md)\n\
                 \t- [The Bar Section](foo/bar.md)\n\
                 \t\t- [The Baz Subsection](foo/bar/baz.md)\n\
                 - [Foo Exercises](exercises/foo.md)",
            ),
            ("src/index.md", "# Intro to X"),
            ("src/foo.md", "# How to Foo"),
            ("src/foo/bar.md", "# How to Bar"),
            ("src/foo/bar/baz.md", "# How to Baz"),
            ("src/exercises/foo.md", "# Exercises on Foo"),
        ])?;

        let catalogs = create_catalogs(&ctx, std::fs::read_to_string)?;

        let expected_message_tuples = HashMap::from([
            (
                path::PathBuf::from("summary.pot"),
                vec![
                    "src/SUMMARY.md:1",
                    "src/SUMMARY.md:3",
                    "src/SUMMARY.md:4",
                    "src/SUMMARY.md:6",
                    "src/SUMMARY.md:7",
                    "src/SUMMARY.md:8",
                    "src/SUMMARY.md:9",
                    "src/index.md:1",
                ],
            ),
            (
                path::PathBuf::from("foo.pot"),
                vec![
                    "src/foo.md:1",
                    "src/foo/bar.md:1",
                    "src/foo/bar/baz.md:1",
                    "src/exercises/foo.md:1",
                ],
            ),
        ]);

        assert_eq!(expected_message_tuples.keys().len(), catalogs.len());
        for (file_path, catalog) in catalogs {
            let expected_msgids = &expected_message_tuples[&file_path];
            assert_eq!(
                &catalog
                    .messages()
                    .map(|msg| msg.source())
                    .collect::<Vec<_>>(),
                expected_msgids
            );
        }

        Ok(())
    }

    #[test]
    fn test_split_catalog_nested_directories_depth_2() -> anyhow::Result<()> {
        let (ctx, _tmp) = create_render_context(&[
            (
                "book.toml",
                "[book]\n\
                 [output.xgettext]\n\
                 depth = 2",
            ),
            (
                "src/SUMMARY.md",
                "# Summary\n\n\
                 - [Intro](index.md)\n\
                 # Foo\n\n\
                 - [The Foo Chapter](foo.md)\n\
                 \t- [The Bar Section](foo/bar.md)\n\
                 \t\t- [The Baz Subsection](foo/bar/baz.md)\n\
                 - [Foo Exercises](exercises/foo.md)",
            ),
            ("src/index.md", "# Intro to X"),
            ("src/foo.md", "# How to Foo"),
            ("src/foo/bar.md", "# How to Bar"),
            ("src/foo/bar/baz.md", "# How to Baz"),
            ("src/exercises/foo.md", "# Exercises on Foo"),
        ])?;

        let catalogs = create_catalogs(&ctx, std::fs::read_to_string)?;

        let expected_message_tuples = HashMap::from([
            (
                path::PathBuf::from("summary/summary.pot"),
                vec![
                    "src/SUMMARY.md:1",
                    "src/SUMMARY.md:3",
                    "src/SUMMARY.md:4",
                    "src/SUMMARY.md:6",
                    "src/SUMMARY.md:7",
                    "src/SUMMARY.md:8",
                    "src/SUMMARY.md:9",
                ],
            ),
            (
                path::PathBuf::from("summary/intro.pot"),
                vec!["src/index.md:1"],
            ),
            (
                path::PathBuf::from("foo/the-foo-chapter.pot"),
                vec!["src/foo.md:1", "src/foo/bar.md:1", "src/foo/bar/baz.md:1"],
            ),
            (
                path::PathBuf::from("foo/foo-exercises.pot"),
                vec!["src/exercises/foo.md:1"],
            ),
        ]);

        assert_eq!(expected_message_tuples.keys().len(), catalogs.len());
        for (file_path, catalog) in catalogs {
            let expected_msgids = &expected_message_tuples[&file_path];
            assert_eq!(
                &catalog
                    .messages()
                    .map(|msg| msg.source())
                    .collect::<Vec<_>>(),
                expected_msgids
            );
        }

        Ok(())
    }

    #[test]
    fn test_split_catalog_nested_directories_depth_3() -> anyhow::Result<()> {
        let (ctx, _tmp) = create_render_context(&[
            (
                "book.toml",
                "[book]\n\
                 [output.xgettext]\n\
                 depth = 3",
            ),
            (
                "src/SUMMARY.md",
                "# Summary\n\n\
                 - [Intro](index.md)\n\
                 # Foo\n\n\
                 - [The Foo Chapter](foo.md)\n\
                 \t- [The Bar Section](foo/bar.md)\n\
                 \t\t- [The Baz Subsection](foo/bar/baz.md)\n\
                 - [Foo Exercises](exercises/foo.md)",
            ),
            ("src/index.md", "# Intro to X"),
            ("src/foo.md", "# How to Foo"),
            ("src/foo/bar.md", "# How to Bar"),
            ("src/foo/bar/baz.md", "# How to Baz"),
            ("src/exercises/foo.md", "# Exercises on Foo"),
        ])?;

        let catalogs = create_catalogs(&ctx, std::fs::read_to_string)?;

        let expected_message_tuples = HashMap::from([
            (
                path::PathBuf::from("summary/summary.pot"),
                vec![
                    "src/SUMMARY.md:1",
                    "src/SUMMARY.md:3",
                    "src/SUMMARY.md:4",
                    "src/SUMMARY.md:6",
                    "src/SUMMARY.md:7",
                    "src/SUMMARY.md:8",
                    "src/SUMMARY.md:9",
                ],
            ),
            (
                path::PathBuf::from("summary/intro.pot"),
                vec!["src/index.md:1"],
            ),
            (
                path::PathBuf::from("foo/the-foo-chapter.pot"),
                vec!["src/foo.md:1"],
            ),
            (
                path::PathBuf::from("foo/the-foo-chapter/the-bar-section.pot"),
                vec!["src/foo/bar.md:1", "src/foo/bar/baz.md:1"],
            ),
            (
                path::PathBuf::from("foo/foo-exercises.pot"),
                vec!["src/exercises/foo.md:1"],
            ),
        ]);

        assert_eq!(expected_message_tuples.keys().len(), catalogs.len());
        for (file_path, catalog) in catalogs {
            let expected_msgids = &expected_message_tuples[&file_path];
            assert_eq!(
                &catalog
                    .messages()
                    .map(|msg| msg.source())
                    .collect::<Vec<_>>(),
                expected_msgids
            );
        }

        Ok(())
    }

    #[test]
    fn test_split_catalog_nested_directories_depth_4() -> anyhow::Result<()> {
        let (ctx, _tmp) = create_render_context(&[
            (
                "book.toml",
                "[book]\n\
                 [output.xgettext]\n\
                 depth = 4",
            ),
            (
                "src/SUMMARY.md",
                "# Summary\n\n\
                 - [Intro](index.md)\n\
                 # Foo\n\n\
                 - [The Foo Chapter](foo.md)\n\
                 \t- [The Bar Section](foo/bar.md)\n\
                 \t\t- [The Baz Subsection](foo/bar/baz.md)\n\
                 - [Foo Exercises](exercises/foo.md)",
            ),
            ("src/index.md", "# Intro to X"),
            ("src/foo.md", "# How to Foo"),
            ("src/foo/bar.md", "# How to Bar"),
            ("src/foo/bar/baz.md", "# How to Baz"),
            ("src/exercises/foo.md", "# Exercises on Foo"),
        ])?;

        let catalogs = create_catalogs(&ctx, std::fs::read_to_string)?;

        let expected_message_tuples = HashMap::from([
            (
                path::PathBuf::from("summary/summary.pot"),
                vec![
                    "src/SUMMARY.md:1",
                    "src/SUMMARY.md:3",
                    "src/SUMMARY.md:4",
                    "src/SUMMARY.md:6",
                    "src/SUMMARY.md:7",
                    "src/SUMMARY.md:8",
                    "src/SUMMARY.md:9",
                ],
            ),
            (
                path::PathBuf::from("summary/intro.pot"),
                vec!["src/index.md:1"],
            ),
            (
                path::PathBuf::from("foo/the-foo-chapter.pot"),
                vec!["src/foo.md:1"],
            ),
            (
                path::PathBuf::from("foo/the-foo-chapter/the-bar-section.pot"),
                vec!["src/foo/bar.md:1"],
            ),
            (
                path::PathBuf::from("foo/the-foo-chapter/the-bar-section/the-baz-subsection.pot"),
                vec!["src/foo/bar/baz.md:1"],
            ),
            (
                path::PathBuf::from("foo/foo-exercises.pot"),
                vec!["src/exercises/foo.md:1"],
            ),
        ]);

        assert_eq!(expected_message_tuples.keys().len(), catalogs.len());
        for (file_path, catalog) in catalogs {
            let expected_msgids = &expected_message_tuples[&file_path];
            assert_eq!(
                &catalog
                    .messages()
                    .map(|msg| msg.source())
                    .collect::<Vec<_>>(),
                expected_msgids
            );
        }

        Ok(())
    }

    // The output is expected to be the same as the above test, there
    // should be no difference if the split depth is an arbitrarily
    // large number.
    #[test]
    fn test_split_catalog_nested_directories_depth_greater_than_necessary() -> anyhow::Result<()> {
        let (ctx, _tmp) = create_render_context(&[
            (
                "book.toml",
                "[book]\n\
                 [output.xgettext]\n\
                 depth = 100",
            ),
            (
                "src/SUMMARY.md",
                "# Summary\n\n\
                 - [Intro](index.md)\n\
                 # Foo\n\n\
                 - [The Foo Chapter](foo.md)\n\
                 \t- [The Bar Section](foo/bar.md)\n\
                 \t\t- [The Baz Subsection](foo/bar/baz.md)\n\
                 - [Foo Exercises](exercises/foo.md)",
            ),
            ("src/index.md", "# Intro to X"),
            ("src/foo.md", "# How to Foo"),
            ("src/foo/bar.md", "# How to Bar"),
            ("src/foo/bar/baz.md", "# How to Baz"),
            ("src/exercises/foo.md", "# Exercises on Foo"),
        ])?;

        let catalogs = create_catalogs(&ctx, std::fs::read_to_string)?;

        let expected_message_tuples = HashMap::from([
            (
                path::PathBuf::from("summary/summary.pot"),
                vec![
                    "src/SUMMARY.md:1",
                    "src/SUMMARY.md:3",
                    "src/SUMMARY.md:4",
                    "src/SUMMARY.md:6",
                    "src/SUMMARY.md:7",
                    "src/SUMMARY.md:8",
                    "src/SUMMARY.md:9",
                ],
            ),
            (
                path::PathBuf::from("summary/intro.pot"),
                vec!["src/index.md:1"],
            ),
            (
                path::PathBuf::from("foo/the-foo-chapter.pot"),
                vec!["src/foo.md:1"],
            ),
            (
                path::PathBuf::from("foo/the-foo-chapter/the-bar-section.pot"),
                vec!["src/foo/bar.md:1"],
            ),
            (
                path::PathBuf::from("foo/the-foo-chapter/the-bar-section/the-baz-subsection.pot"),
                vec!["src/foo/bar/baz.md:1"],
            ),
            (
                path::PathBuf::from("foo/foo-exercises.pot"),
                vec!["src/exercises/foo.md:1"],
            ),
        ]);

        assert_eq!(expected_message_tuples.keys().len(), catalogs.len());
        for (file_path, catalog) in catalogs {
            let expected_msgids = &expected_message_tuples[&file_path];
            assert_eq!(
                &catalog
                    .messages()
                    .map(|msg| msg.source())
                    .collect::<Vec<_>>(),
                expected_msgids
            );
        }

        Ok(())
    }
}