mdbook_newday/

lib.rs

use chrono::{DateTime, Duration, Local, TimeZone};

const SIGIL: &str = "- [";

fn now() -> DateTime<Local> {
    Local::now()
}

fn mdbook_summary_line_for_time<T: TimeZone>(dt: DateTime<T>) -> String
where
    T::Offset: std::fmt::Display,
{
    dt.format("- [%A, %b %d, %Y](./%Y/%Y-%m/%Y-%m-%d.md)")
        .to_string()
}

fn todays_line() -> String {
    mdbook_summary_line_for_time(now())
}

fn future_lines(days: u32) -> Vec<String> {
    let today = now();
    (1..=days)
        .map(|day_offset| {
            let future_date = today + Duration::days(day_offset as i64);
            mdbook_summary_line_for_time(future_date)
        })
        .collect::<Vec<_>>()
        .into_iter()
        .rev()
        .collect()
}

/// Insert the new lines right before the first line starting with sigil.
/// If there is no such line, insert lines after all other lines.
/// If there are already matching lines, don't insert duplicates.
fn insert_lines_before_sigil(lines: &[String], sigil: &str, text: &str) -> String {
    let mut new_lines = vec![];
    let mut sigil_found = false;
    let mut already_added_lines: std::collections::HashSet<String> =
        std::collections::HashSet::new();

    // Check what lines are already present and identify exact matches
    for text_line in text.lines() {
        for line in lines {
            if text_line == line {
                already_added_lines.insert(line.clone());
            }
        }
    }

    // Add the lines before the first sigil if there is one.
    for text_line in text.lines() {
        if text_line.starts_with(sigil) && !sigil_found {
            // Add any new lines that aren't already present
            for line in lines {
                if !already_added_lines.contains(line) {
                    new_lines.push(line.as_str());
                    already_added_lines.insert(line.clone());
                }
            }
            sigil_found = true;
        }
        new_lines.push(text_line);
    }

    // Add the lines at the end if there is no sigil present.
    if !sigil_found {
        for line in lines {
            if !already_added_lines.contains(line) {
                new_lines.push(line.as_str());
            }
        }
    }

    let mut with_insert = new_lines.join("\n");
    with_insert.push('\n');
    with_insert
}

fn add_lines_to_file(lines: &[String], sigil: &str, file_path: &str) -> Result<(), std::io::Error> {
    let file_contents = std::fs::read_to_string(file_path)?;
    let file_contents = insert_lines_before_sigil(lines, sigil, &file_contents);
    std::fs::write(file_path, file_contents)
}

fn add_line_to_file(line: &str, sigil: &str, file_path: &str) -> Result<(), std::io::Error> {
    add_lines_to_file(&[line.to_string()], sigil, file_path)
}

// Helper function for tests - wrapper around insert_lines_before_sigil for single lines
#[cfg(test)]
fn insert_line_before_sigil(line: &str, sigil: &str, text: &str) -> String {
    insert_lines_before_sigil(&[line.to_string()], sigil, text)
}

/// Adds a new line almost to the top of an mdbook summary page.
/// That is, not quite the top because it skips any lines without the `- [`
/// prefix like any title or commentary or introduction link.
///
/// The new line comes from local time and takes the format
/// `- [%A, %b %d, %Y](./%Y/%Y-%m/%Y-%m-%d.md)`, ie
/// `- [Thursday, Jan 01, 1970](./1970/1970-01/1970-01-01.md)`.
/// If there is no line yet, it will add one.
///
/// `mdbook serve` will create the files mentioned in the summary with titles
/// given by the link text.  So if this function is run right before `mdbook serve`
/// you'll get not only the summary link but also the file.
pub fn update_summary(path: &str) -> Result<(), std::io::Error> {
    add_line_to_file(&todays_line(), SIGIL, path)
}

/// Adds multiple new lines to an mdbook summary page for the next n days.
/// Each line takes the same format as update_summary but for consecutive future days.
///
/// For example, if called with days=3, it will add lines for tomorrow, the day after,
/// and the day after that.
///
/// Lines are added in chronological order and duplicate lines are avoided.
pub fn update_summary_plan_ahead(path: &str, days: u32) -> Result<(), std::io::Error> {
    let lines = future_lines(days);
    add_lines_to_file(&lines, SIGIL, path)
}

#[cfg(test)]
mod tests {
    use super::*;
    use chrono::Utc;

    #[test]
    fn test_update_summary() -> Result<(), std::io::Error> {
        let tmp_path = "./tmp_file";
        let original_line = "original_line";

        // Create the file with only the original line.
        std::fs::write(tmp_path, original_line)?;

        // Add in the new line.
        update_summary(tmp_path)?;

        // Check file contents.
        let added_line = &todays_line();
        let contents = std::fs::read_to_string(tmp_path)?;
        assert_eq!(contents, format!("{}\n{}\n", original_line, added_line));

        // Now delete the file again.
        std::fs::remove_file(tmp_path)?;
        Ok(())
    }

    #[test]
    fn test_place_line_before() {
        let line = "- [First!](./first.md)";
        let line_without_sigil = "no sigil";
        let sigil = "- [";
        let text_without_sigil = "[Intro](./intro)";
        let text_with_sigil = "[Intro](./intro)\n- [Second!](./second.md)";
        let text_with_2_sigils = "[Intro](./intro)\n- [\n- [";

        // If there is no sigil, the line is added to the end of the file.
        let text = insert_line_before_sigil(line, sigil, text_without_sigil);
        assert_eq!(text, "[Intro](./intro)\n- [First!](./first.md)\n");

        // Otherwise, the line is added before the first appearance of the sigil.
        let text = insert_line_before_sigil(line, sigil, text_with_sigil);
        assert_eq!(
            text,
            "[Intro](./intro)\n- [First!](./first.md)\n- [Second!](./second.md)\n"
        );

        // Idempotent
        let text = insert_line_before_sigil(line, sigil, &text);
        assert_eq!(
            text,
            "[Intro](./intro)\n- [First!](./first.md)\n- [Second!](./second.md)\n"
        );

        // Only add the line in one place even if the sigil appears multiple times.
        let text = insert_line_before_sigil(line, sigil, text_with_2_sigils);
        assert_eq!(text, "[Intro](./intro)\n- [First!](./first.md)\n- [\n- [\n");

        // A line without a sigil is still added idempotently.
        let first_pass = insert_line_before_sigil(line_without_sigil, sigil, text_without_sigil);
        assert_eq!(first_pass, "[Intro](./intro)\nno sigil\n");
        let second_pass = insert_line_before_sigil(line_without_sigil, sigil, &first_pass);
        assert_eq!(first_pass, second_pass)
    }

    #[test]
    fn test_gives_summary_terminal_newline() {
        let sigil = "- [";
        let without_sigil = "[Introduction](introduction.md)";
        let with_sigil = "- [a](a.md)";
        let line = "- [Thursday, Jan 01, 1970](./1970/1970-01/1970-01-01.md)";

        let expected = format!("{without_sigil}\n{line}\n{with_sigil}\n");

        // If the terminal newline is already there, we don't lose it.
        let text = format!("{without_sigil}\n{with_sigil}\n");
        let with_insert = insert_line_before_sigil(line, sigil, &text);
        assert_eq!(with_insert, expected);

        // If it was missing, we gain it.
        let text = format!("{without_sigil}\n{with_sigil}");
        let with_insert = insert_line_before_sigil(line, sigil, &text);
        assert_eq!(with_insert, expected);
    }

    #[test]
    fn test_summary_line_format() {
        let dt: DateTime<Utc> = Utc.timestamp_opt(1, 0).unwrap();
        let formatted = mdbook_summary_line_for_time(dt);
        assert_eq!(
            formatted,
            "- [Thursday, Jan 01, 1970](./1970/1970-01/1970-01-01.md)"
        );
    }

    #[test]
    fn test_todays_line() {
        // There's no fixed value here because it depends on the time and local timezone.
        // So rather than create a test this just allows for quick inspection.
        dbg!(todays_line());
    }
    #[test]
    fn test_lines() {
        let lines = "a\n";
        for line in lines.lines() {
            println!("Here's the line: {line:?}")
        }
    }

    #[test]
    fn test_future_lines() {
        // Test that future_lines generates the correct number of lines
        let lines = future_lines(3);
        assert_eq!(lines.len(), 3);

        // Each line should be a valid mdbook summary line
        for line in &lines {
            assert!(line.starts_with("- ["));
            assert!(line.contains("](./"));
            assert!(line.ends_with(".md)"));
        }

        // Lines should be in reverse chronological order (newest first)
        // This is a simple check that the dates are decreasing
        // We can't check exact dates due to timezone issues in tests
        assert!(lines.len() >= 2);
    }

    #[test]
    fn test_insert_multiple_lines() {
        let lines = vec![
            "- [Day 1](./day1.md)".to_string(),
            "- [Day 2](./day2.md)".to_string(),
            "- [Day 3](./day3.md)".to_string(),
        ];
        let sigil = "- [";
        let text_with_sigil = "[Intro](./intro)\n- [Existing](./existing.md)";

        let result = insert_lines_before_sigil(&lines, sigil, text_with_sigil);
        let expected = "[Intro](./intro)\n- [Day 1](./day1.md)\n- [Day 2](./day2.md)\n- [Day 3](./day3.md)\n- [Existing](./existing.md)\n";
        assert_eq!(result, expected);
    }

    #[test]
    fn test_insert_multiple_lines_no_duplicates() {
        let lines = vec![
            "- [Day 1](./day1.md)".to_string(),
            "- [Day 2](./day2.md)".to_string(),
        ];
        let sigil = "- [";
        // Text that already contains one of the lines
        let text_with_existing =
            "[Intro](./intro)\n- [Day 1](./day1.md)\n- [Existing](./existing.md)";

        let result = insert_lines_before_sigil(&lines, sigil, text_with_existing);
        let expected = "[Intro](./intro)\n- [Day 2](./day2.md)\n- [Day 1](./day1.md)\n- [Existing](./existing.md)\n";
        assert_eq!(result, expected);
    }

    #[test]
    fn test_update_summary_plan_ahead() -> Result<(), std::io::Error> {
        let tmp_path = "./tmp_plan_ahead_file";
        let original_content = "[Introduction](intro.md)\n- [Existing Entry](./existing.md)\n";

        // Create the file with original content
        std::fs::write(tmp_path, original_content)?;

        // Add 2 future days
        update_summary_plan_ahead(tmp_path, 2)?;

        // Check file contents
        let contents = std::fs::read_to_string(tmp_path)?;

        // Should have the intro, then 2 new lines, then the existing entry
        let lines: Vec<&str> = contents.lines().collect();
        assert_eq!(lines.len(), 4); // intro + 2 new + existing
        assert_eq!(lines[0], "[Introduction](intro.md)");
        assert!(lines[1].starts_with("- ["));
        assert!(lines[2].starts_with("- ["));
        assert_eq!(lines[3], "- [Existing Entry](./existing.md)");

        // Clean up
        std::fs::remove_file(tmp_path)?;
        Ok(())
    }
}