Refactor lib into smaller modules

src/breaks.rs

@@ -0,0 +1,64 @@
+//! Thematic break formatting utilities.
+
+use regex::Regex;
+
+use crate::wrap::is_fence;
+
+pub const THEMATIC_BREAK_LEN: usize = 70;
+
+static THEMATIC_BREAK_RE: std::sync::LazyLock<Regex> = std::sync::LazyLock::new(|| {
+    Regex::new(r"^[ ]{0,3}((?:[ \t]*\*){3,}|(?:[ \t]*-){3,}|(?:[ \t]*_){3,})[ \t]*$").unwrap()
+});
+
+static THEMATIC_BREAK_LINE: std::sync::LazyLock<String> =
+    std::sync::LazyLock::new(|| "_".repeat(THEMATIC_BREAK_LEN));
+
+#[must_use]
+pub fn format_breaks(lines: &[String]) -> Vec<String> {
+    let mut out = Vec::with_capacity(lines.len());
+    let mut in_code = false;
+
+    for line in lines {
+        if is_fence(line) {
+            in_code = !in_code;
+            out.push(line.clone());
+            continue;
+        }
+
+        if !in_code && THEMATIC_BREAK_RE.is_match(line.trim_end()) {
+            out.push(THEMATIC_BREAK_LINE.clone());
+        } else {
+            out.push(line.clone());
+        }
+    }
+
+    out
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn basic_formatting() {
+        let input = vec!["foo", "***", "bar"]
+            .into_iter()
+            .map(str::to_string)
+            .collect::<Vec<_>>();
+        let expected = vec![
+            "foo".to_string(),
+            "_".repeat(THEMATIC_BREAK_LEN),
+            "bar".to_string(),
+        ];
+        assert_eq!(format_breaks(&input), expected);
+    }
+
+    #[test]
+    fn ignores_fenced_code() {
+        let input = vec!["```", "---", "```"]
+            .into_iter()
+            .map(str::to_string)
+            .collect::<Vec<_>>();
+        assert_eq!(format_breaks(&input), input);
+    }
+}

src/html.rs

@@ -12,7 +12,7 @@ use html5ever::{driver::ParseOpts, parse_document, tendril::TendrilSink};
 use markup5ever_rcdom::{Handle, NodeData, RcDom};
 use regex::Regex;
 
-use crate::is_fence;
+use crate::wrap::is_fence;
 
 /// Matches the start of an HTML `<table>` tag, ignoring case.
 static TABLE_START_RE: LazyLock<Regex> =

src/io.rs

@@ -0,0 +1,54 @@
+//! File helpers for rewriting Markdown documents.
+
+use std::{fs, path::Path};
+
+use crate::process::{process_stream, process_stream_no_wrap};
+
+/// Rewrite a file in place with wrapped tables.
+///
+/// # Errors
+/// Returns an error if reading or writing the file fails.
+pub fn rewrite(path: &Path) -> std::io::Result<()> {
+    let text = fs::read_to_string(path)?;
+    let lines: Vec<String> = text.lines().map(str::to_string).collect();
+    let fixed = process_stream(&lines);
+    fs::write(path, fixed.join("\n") + "\n")
+}
+
+/// Rewrite a file in place without wrapping text.
+///
+/// # Errors
+/// Returns an error if reading or writing the file fails.
+pub fn rewrite_no_wrap(path: &Path) -> std::io::Result<()> {
+    let text = fs::read_to_string(path)?;
+    let lines: Vec<String> = text.lines().map(str::to_string).collect();
+    let fixed = process_stream_no_wrap(&lines);
+    fs::write(path, fixed.join("\n") + "\n")
+}
+
+#[cfg(test)]
+mod tests {
+    use tempfile::tempdir;
+
+    use super::*;
+
+    #[test]
+    fn rewrite_roundtrip() {
+        let dir = tempdir().unwrap();
+        let file = dir.path().join("sample.md");
+        fs::write(&file, "|A|B|\n|1|2|").unwrap();
+        rewrite(&file).unwrap();
+        let out = fs::read_to_string(&file).unwrap();
+        assert!(out.contains("| A | B |"));
+    }
+
+    #[test]
+    fn rewrite_no_wrap_roundtrip() {
+        let dir = tempdir().unwrap();
+        let file = dir.path().join("sample.md");
+        fs::write(&file, "|A|B|\n|1|2|").unwrap();
+        rewrite_no_wrap(&file).unwrap();
+        let out = fs::read_to_string(&file).unwrap();
+        assert_eq!(out, "| A | B |\n| 1 | 2 |\n");
+    }
+}