prosesmasher-app-core 0.1.7

Internal core checks crate for the prosesmasher workspace. Published to support the workspace dependency graph.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

//! Shared test helpers for building hand-crafted `Document` structs.

use prosesmasher_domain_types::{
    Block, Document, DocumentMetadata, Locale, Paragraph, Section, Sentence, Word,
};

/// Build a simple document with one paragraph containing the given text.
///
/// Words are split on whitespace. All syllable counts are set to 1.
/// Metadata `total_words` is computed from the words vec.
pub fn make_doc(text: &str, locale: Locale) -> Document {
    let words: Vec<Word> = text
        .split_whitespace()
        .map(|w| Word {
            text: w.to_owned(),
            syllable_count: 1,
        })
        .collect();
    let word_count = words.len();

    Document {
        locale,
        sections: vec![Section {
            heading: None,
            blocks: vec![Block::Paragraph(Paragraph {
                sentences: vec![Sentence {
                    text: text.to_owned(),
                    words,
                }],
                has_bold: false,
                has_italic: false,
                links: vec![],
            })],
        }],
        metadata: DocumentMetadata {
            total_words: word_count,
            total_sentences: 1,
            ..Default::default()
        },
    }
}

/// Build a document with a specific `total_words` in metadata.
///
/// Creates N dummy words. Useful for testing word count thresholds.
pub fn make_doc_with_word_count(word_count: usize, locale: Locale) -> Document {
    let words: Vec<Word> = (0..word_count)
        .map(|i| Word {
            text: format!("word{i}"),
            syllable_count: 1,
        })
        .collect();
    let text = words.iter().map(|w| w.text.as_str()).collect::<Vec<_>>().join(" ");

    Document {
        locale,
        sections: vec![Section {
            heading: None,
            blocks: vec![Block::Paragraph(Paragraph {
                sentences: vec![Sentence { text, words }],
                has_bold: false,
                has_italic: false,
                links: vec![],
            })],
        }],
        metadata: DocumentMetadata {
            total_words: word_count,
            total_sentences: 1,
            ..Default::default()
        },
    }
}

/// Build a document with text inside a blockquote.
pub fn make_doc_in_blockquote(text: &str, locale: Locale) -> Document {
    let words: Vec<Word> = text
        .split_whitespace()
        .map(|w| Word { text: w.to_owned(), syllable_count: 1 })
        .collect();
    let word_count = words.len();

    Document {
        locale,
        sections: vec![Section {
            heading: None,
            blocks: vec![Block::BlockQuote(vec![
                Block::Paragraph(Paragraph {
                    sentences: vec![Sentence { text: text.to_owned(), words }],
                    has_bold: false,
                    has_italic: false,
                    links: vec![],
                }),
            ])],
        }],
        metadata: DocumentMetadata {
            total_words: word_count,
            total_sentences: 1,
            ..Default::default()
        },
    }
}

/// Build a document with only a code block (no paragraphs).
pub fn make_doc_code_only(code: &str, locale: Locale) -> Document {
    Document {
        locale,
        sections: vec![Section {
            heading: None,
            blocks: vec![Block::CodeBlock(code.to_owned())],
        }],
        metadata: DocumentMetadata::default(),
    }
}

/// Build a document with multiple sections, each with one paragraph.
pub fn make_doc_multi_section(texts: &[&str], locale: Locale) -> Document {
    let mut total_words: usize = 0;
    let sections: Vec<Section> = texts
        .iter()
        .map(|text| {
            let words: Vec<Word> = text
                .split_whitespace()
                .map(|w| Word { text: w.to_owned(), syllable_count: 1 })
                .collect();
            total_words = total_words.saturating_add(words.len());
            Section {
                heading: None,
                blocks: vec![Block::Paragraph(Paragraph {
                    sentences: vec![Sentence { text: (*text).to_owned(), words }],
                    has_bold: false,
                    has_italic: false,
                    links: vec![],
                })],
            }
        })
        .collect();

    Document {
        locale,
        sections,
        metadata: DocumentMetadata {
            total_words,
            total_sentences: texts.len(),
            ..Default::default()
        },
    }
}