Skip to content

Offline, privacy-first grammar checker. Fast, open-source, Rust-powered

tests(#331): create literate haskell masker unit tests

Grant Lemonsf8e6e772674d
diff --git a/harper-literate-haskell/src/lib.rs b/harper-literate-haskell/src/lib.rs
index 4317c97ff..c18efd9df 100644
--- a/harper-literate-haskell/src/lib.rs
+++ b/harper-literate-haskell/src/lib.rs
@@ -13,11 +13,7 @@ pub struct LiterateHaskellParser;
impl LiterateHaskellParser {
pub fn create_ident_dict(&self, source: &[char]) -> Option<FullDictionary> {
let parser = CommentParser::new_from_language_id("haskell").unwrap();
- let mask = LiterateHaskellMasker {
- text: false,
- code: true,
- }
- .create_mask(source);
+ let mask = LiterateHaskellMasker::code_only().create_mask(source);
let code = mask
.iter_allowed(source)
@@ -29,13 +25,6 @@ impl LiterateHaskellParser {
impl Parser for LiterateHaskellParser {
fn parse(&mut self, source: &[char]) -> Vec<Token> {
- Mask::new(
- LiterateHaskellMasker {
- text: true,
- code: false,
- },
- Markdown,
- )
- .parse(source)
+ Mask::new(LiterateHaskellMasker::text_only(), Markdown).parse(source)
}
}
diff --git a/harper-literate-haskell/src/masker.rs b/harper-literate-haskell/src/masker.rs
index 2627576a6..3038cb6f1 100644
--- a/harper-literate-haskell/src/masker.rs
+++ b/harper-literate-haskell/src/masker.rs
@@ -1,8 +1,24 @@
use harper_core::{CharStringExt, Mask, Masker, Span};
pub struct LiterateHaskellMasker {
- pub text: bool,
- pub code: bool,
+ text: bool,
+ code: bool,
+}
+
+impl LiterateHaskellMasker {
+ pub fn text_only() -> Self {
+ Self {
+ text: true,
+ code: false,
+ }
+ }
+
+ pub fn code_only() -> Self {
+ Self {
+ text: false,
+ code: true,
+ }
+ }
}
impl Masker for LiterateHaskellMasker {
@@ -19,21 +35,111 @@ impl Masker for LiterateHaskellMasker {
let line_is_bird = line.first().map_or(false, |c| *c == '>');
// Code fencing
+ let latex_style = matches!(trimmed, r"\begin{code}" | r"\end{code}");
let code_start = trimmed == r"\begin{code}" || (last_line_blank && line_is_bird);
let code_end = trimmed == r"\end{code}" || trimmed.is_empty();
+
+ // Toggle on fence
if (!in_code_env && code_start) || (in_code_env && code_end) {
in_code_env = !in_code_env;
+
+ // Exclude latex-style fence
+ if latex_style {
+ location += line.len() + 1; // +1 for the newline split on
+ last_line_blank = trimmed.is_empty();
+ continue;
+ }
+
+ // Exclude newline after code for bird style
+ if trimmed.is_empty() {
+ location += line.len() + 1; // +1 for the newline split on
+ last_line_blank = true;
+ continue;
+ }
}
let end_loc = location + line.len();
if (!in_code_env && self.text) || (in_code_env && self.code) {
- mask.push_allowed(Span::new(location, end_loc));
+ let start_loc = if line_is_bird { location + 2 } else { location };
+ mask.push_allowed(Span::new(start_loc, end_loc));
}
location = end_loc + 1; // +1 for the newline split on
last_line_blank = trimmed.is_empty();
}
+ mask.merge_whitespace_sep(source);
mask
}
}
+
+#[cfg(test)]
+mod tests {
+ use harper_core::{Masker, Span};
+ use itertools::Itertools;
+
+ use super::LiterateHaskellMasker;
+
+ #[test]
+ fn bird_format() {
+ let source = r"Text here
+
+> fact :: Integer -> Integer
+> fact 0 = 1
+> fact n = n * fact (n-1)
+
+Text here
+"
+ .chars()
+ .collect_vec();
+
+ let text_mask = LiterateHaskellMasker::text_only().create_mask(&source);
+ assert_eq!(
+ text_mask
+ .iter_allowed(&source)
+ .map(|(s, _)| s)
+ .collect_vec(),
+ vec![Span::new(0, 10), Span::new(80, 90)],
+ );
+
+ let code_mask = LiterateHaskellMasker::code_only().create_mask(&source);
+ assert_eq!(
+ code_mask
+ .iter_allowed(&source)
+ .map(|(s, _)| s)
+ .collect_vec(),
+ vec![Span::new(13, 39), Span::new(42, 52), Span::new(55, 78)],
+ );
+ }
+
+ #[test]
+ fn latex_format() {
+ let source = r#"Text here
+\begin{code}
+main :: IO ()
+main = print "just an example"
+\end{code}
+Text here
+"#
+ .chars()
+ .collect_vec();
+
+ let text_mask = LiterateHaskellMasker::text_only().create_mask(&source);
+ assert_eq!(
+ text_mask
+ .iter_allowed(&source)
+ .map(|(s, _)| s)
+ .collect_vec(),
+ vec![Span::new(0, 9), Span::new(79, 89)],
+ );
+
+ let code_mask = LiterateHaskellMasker::code_only().create_mask(&source);
+ assert_eq!(
+ code_mask
+ .iter_allowed(&source)
+ .map(|(s, _)| s)
+ .collect_vec(),
+ vec![Span::new(23, 67)],
+ );
+ }
+}