date_range_rs 0.2.0

A collection of date range types
Documentation
use crate::daterange::date_range::{DateRange, calculate_day_of_week_offset};
use joda_rs::{DayOfWeek, LocalDate};

pub struct WeeklyDateRange;

impl WeeklyDateRange {
    /// Creates a 7-day range starting at the given start_date.
    pub fn with_start_date(start_date: LocalDate) -> DateRange {
        let end = start_date.plus_days(6);
        DateRange::new(start_date, end)
    }

    /// Creates a 7-day range ending at the given end_date.
    pub fn with_end_date(end_date: LocalDate) -> DateRange {
        let start = end_date.minus_days(6);
        DateRange::new(start, end_date)
    }

    /// Creates a 7-day range ending on the next occurrence of end_day on or after target.
    pub fn with_target_date(target: LocalDate, end_day: DayOfWeek) -> DateRange {
        let offset = calculate_day_of_week_offset(target, end_day);
        let end = target.plus_days(offset as i64);
        let start = end.minus_days(6);
        DateRange::new(start, end)
    }
}

#[cfg(test)]
mod tests {
    use super::WeeklyDateRange;
    use joda_rs::{DayOfWeek, LocalDate};

    fn d(y: i32, m: i32, day: i32) -> LocalDate {
        LocalDate::of(y, m, day)
    }

    #[test]
    fn with_start_date_spans_7_days_inclusive() {
        let start = d(2023, 3, 1);
        let dr = WeeklyDateRange::with_start_date(start);

        assert_eq!(dr.start_date(), d(2023, 3, 1));
        assert_eq!(dr.end_date(), start.plus_days(6));
        assert_eq!(dr.len(), 7);
    }

    #[test]
    fn with_end_date_spans_7_days_inclusive() {
        let end = d(2023, 3, 7);
        let dr = WeeklyDateRange::with_end_date(end);

        assert_eq!(dr.end_date(), d(2023, 3, 7));
        assert_eq!(dr.start_date(), end.minus_days(6));
        assert_eq!(dr.len(), 7);
    }

    #[test]
    fn prior_and_next_shift_by_one_week() {
        let start = d(2023, 5, 10);
        let dr = WeeklyDateRange::with_start_date(start);

        let prior = dr.prior();
        let next = dr.next();

        assert_eq!(prior.start_date(), start.minus_days(7));
        assert_eq!(prior.end_date(), dr.start_date().minus_days(1));

        assert_eq!(next.start_date(), dr.end_date().plus_days(1));
        assert_eq!(next.end_date(), dr.end_date().plus_days(7));
    }

    #[test]
    fn with_target_date_when_target_is_end_day() {
        // If target is the end day, end should equal target and start should be 6 days prior
        // Example: target is Sunday and end_day is Sunday
        let target = d(2023, 1, 1); // 2023-01-01 was a Sunday
        let dr = WeeklyDateRange::with_target_date(target, DayOfWeek::Sunday);

        assert_eq!(dr.end_date(), target);
        assert_eq!(dr.start_date(), target.minus_days(6));
        assert_eq!(dr.len(), 7);
    }

    #[test]
    fn with_target_date_wraps_forward_to_specified_end_day() {
        // Example: target Monday with end_day Sunday -> end is following Sunday
        let target = d(2023, 1, 2); // Monday
        let dr = WeeklyDateRange::with_target_date(target, DayOfWeek::Sunday);

        assert_eq!(dr.end_date(), d(2023, 1, 8));
        assert_eq!(dr.start_date(), d(2023, 1, 2));
    }

    #[test]
    fn with_target_date_when_target_after_end_day_wraps_to_next_week() {
        // Example: target Tuesday, end_day Monday -> wrap to next Monday
        let target = d(2023, 1, 3); // Tuesday
        let dr = WeeklyDateRange::with_target_date(target, DayOfWeek::Monday);

        assert_eq!(dr.end_date(), d(2023, 1, 9)); // next Monday
        assert_eq!(dr.start_date(), d(2023, 1, 3)); // Tuesday
    }

    #[test]
    fn handles_year_boundary() {
        // Starting late December should end in early January next year
        let dr = WeeklyDateRange::with_start_date(d(2020, 12, 29));
        assert_eq!(dr.start_date(), d(2020, 12, 29));
        assert_eq!(dr.end_date(), d(2021, 1, 4));
    }

    #[test]
    fn leap_year_week_crossing_feb_29() {
        // A week covering Feb 29 in a leap year
        let dr = WeeklyDateRange::with_start_date(d(2020, 2, 25));
        assert_eq!(dr.start_date(), d(2020, 2, 25));
        assert_eq!(dr.end_date(), d(2020, 3, 2));
    }
}