use joda_rs::{DayOfWeek, LocalDate};
use std::cmp::Ordering;
#[derive(Copy, Clone, Debug)]
pub struct DateRange {
start_date: LocalDate,
end_date: LocalDate,
len: usize,
prior_fn: Option<fn(&DateRange) -> DateRange>,
next_fn: Option<fn(&DateRange) -> DateRange>,
start_day: Option<usize>,
}
impl DateRange {
pub fn new(start_date: LocalDate, end_date: LocalDate) -> DateRange {
let mut days: usize = 1;
let mut d = start_date;
while d < end_date {
days += 1;
d = d.plus_days(1);
}
Self {
start_date,
end_date,
len: days,
prior_fn: None,
next_fn: None,
start_day: None,
}
}
pub(crate) fn new_with_prior_next(
start_date: LocalDate,
end_date: LocalDate,
prior_fn: fn(&DateRange) -> DateRange,
next_fn: fn(&DateRange) -> DateRange,
) -> DateRange {
let mut days: usize = 1;
let mut d = start_date;
while d < end_date {
days += 1;
d = d.plus_days(1);
}
Self {
start_date,
end_date,
len: days,
prior_fn: Some(prior_fn),
next_fn: Some(next_fn),
start_day: None,
}
}
pub(crate) fn new_with_prior_next_start_day(
start_date: LocalDate,
end_date: LocalDate,
prior_fn: fn(&DateRange) -> DateRange,
next_fn: fn(&DateRange) -> DateRange,
start_day: Option<usize>,
) -> DateRange {
let mut days: usize = 1;
let mut d = start_date;
while d < end_date {
days += 1;
d = d.plus_days(1);
}
Self {
start_date,
end_date,
len: days,
prior_fn: Some(prior_fn),
next_fn: Some(next_fn),
start_day,
}
}
pub fn start_date(&self) -> LocalDate {
self.start_date
}
pub fn end_date(&self) -> LocalDate {
self.end_date
}
pub fn len(&self) -> usize {
self.len
}
pub fn iter(&self) -> DateRangeIter {
DateRangeIter {
current: self.start_date,
end: self.end_date,
}
}
pub fn start_day(&self) -> Option<usize> {
self.start_day
}
pub fn dates(&self) -> Vec<LocalDate> {
let mut dates = Vec::with_capacity(self.len());
let mut current = self.start_date();
while current <= self.end_date() {
dates.push(current);
current = current.plus_days(1);
}
dates
}
pub fn date_at(&self, index: usize) -> Option<LocalDate> {
self.dates().get(index).copied()
}
pub fn dates_for_day(&self, day: DayOfWeek) -> Vec<LocalDate> {
self.dates()
.into_iter()
.filter(|d| d.day_of_week() == day)
.collect()
}
pub fn contains_date(&self, date: LocalDate) -> bool {
date >= self.start_date() && date <= self.end_date()
}
pub fn contains_range(&self, date_range: &DateRange) -> bool {
date_range.start_date() >= self.start_date() && date_range.end_date() <= self.end_date()
}
pub fn overlaps(&self, date_range: &DateRange) -> bool {
self.start_date() <= date_range.end_date() && self.end_date() >= date_range.start_date()
}
pub fn overlaps_any(&self, date_ranges: &[DateRange]) -> bool {
date_ranges.iter().any(|range| self.overlaps(range))
}
pub fn range_containing_date(&self, date: LocalDate) -> DateRange {
let mut range = self.create_new_date_range(self.start_date(), self.end_date());
while !range.contains_date(date) {
if date > range.end_date() {
range = range.next();
} else {
range = range.prior();
}
}
range
}
pub fn prior(&self) -> DateRange {
if self.prior_fn.is_some() {
self.prior_fn.unwrap()(self)
} else {
self.create_new_date_range(
self.start_date().minus_days(self.len() as i64),
self.end_date().minus_days(self.len() as i64),
)
}
}
pub fn prior_n(&self, number: usize) -> DateRange {
let mut range = self.prior();
for _ in 1..number {
range = range.prior();
}
range
}
pub fn next(&self) -> DateRange {
if self.next_fn.is_some() {
self.next_fn.unwrap()(self)
} else {
self.create_new_date_range(
self.start_date().plus_days(self.len() as i64),
self.end_date().plus_days(self.len() as i64),
)
}
}
pub fn next_n(&self, number: usize) -> DateRange {
let mut range = self.next();
for _ in 1..number {
range = range.next();
}
range
}
pub fn ranges_before(&self, number: usize) -> Vec<DateRange> {
self.ranges_before_impl(number, false)
}
pub fn ranges_before_inclusive(&self, number: usize) -> Vec<DateRange> {
self.ranges_before_impl(number, true)
}
pub fn ranges_after(&self, number: usize) -> Vec<DateRange> {
self.ranges_after_impl(number, false)
}
pub fn ranges_after_inclusive(&self, number: usize) -> Vec<DateRange> {
self.ranges_after_impl(number, true)
}
pub fn ranges_window(&self, before: usize, after: usize) -> Vec<DateRange> {
let mut ranges = Vec::with_capacity(before + after + 1);
ranges.extend(self.ranges_before_impl(before, true));
let mut after_ranges = self.ranges_after_impl(after, false);
ranges.append(&mut after_ranges);
ranges
}
pub fn ranges_containing_span(
&self,
from_date: LocalDate,
to_date: LocalDate,
) -> Vec<DateRange> {
let mut ranges = Vec::new();
let mut range = self.range_containing_date(from_date);
ranges.push(range.clone());
while range.end_date() < to_date {
range = range.next();
ranges.push(range.clone());
}
ranges.sort_by_key(|r| r.start_date());
ranges
}
fn ranges_before_impl(&self, number: usize, include_self: bool) -> Vec<DateRange> {
let mut ranges = Vec::with_capacity(number + 1);
if include_self {
ranges.push(self.create_new_date_range(self.start_date(), self.end_date()));
}
let mut current = self.create_new_date_range(self.start_date(), self.end_date());
for _ in 0..number {
current = current.prior();
ranges.push(current.create_new_date_range(current.start_date(), current.end_date()));
}
ranges.reverse(); ranges
}
fn ranges_after_impl(&self, number: usize, include_self: bool) -> Vec<DateRange> {
let mut ranges = Vec::with_capacity(number + 1);
if include_self {
ranges.push(self.create_new_date_range(self.start_date(), self.end_date()));
}
let mut current = self.create_new_date_range(self.start_date(), self.end_date());
for _ in 0..number {
current = current.next();
ranges.push(current.create_new_date_range(current.start_date(), current.end_date()));
}
ranges
}
fn create_new_date_range(&self, start: LocalDate, end: LocalDate) -> DateRange {
let mut len: usize = 1;
let mut d = start;
while d < end {
len += 1;
d = d.plus_days(1);
}
Self {
start_date: start,
end_date: end,
len,
prior_fn: self.prior_fn.clone(),
next_fn: self.next_fn.clone(),
start_day: self.start_day.clone(),
}
}
}
impl PartialEq for DateRange {
fn eq(&self, other: &Self) -> bool {
self.start_date == other.start_date && self.end_date == other.end_date
}
}
impl Eq for DateRange {}
impl PartialOrd for DateRange {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
Some(self.cmp(other))
}
}
impl Ord for DateRange {
fn cmp(&self, other: &Self) -> Ordering {
self.start_date.cmp(&other.start_date)
}
}
pub struct DateRangeIter {
current: LocalDate,
end: LocalDate,
}
impl Iterator for DateRangeIter {
type Item = LocalDate;
fn next(&mut self) -> Option<Self::Item> {
if self.current > self.end {
None
} else {
let result = self.current;
self.current = self.current.plus_days(1);
Some(result)
}
}
}
#[cfg(test)]
mod tests {
use super::DateRange;
use joda_rs::{DayOfWeek, LocalDate};
fn d(y: i32, m: i32, day: i32) -> LocalDate {
LocalDate::of(y, m, day)
}
fn prior_shift_by_one(dr: &DateRange) -> DateRange {
DateRange::new_with_prior_next_start_day(
dr.start_date().minus_days(1),
dr.end_date().minus_days(1),
prior_shift_by_one,
next_shift_by_one,
dr.start_day(),
)
}
fn next_shift_by_one(dr: &DateRange) -> DateRange {
DateRange::new_with_prior_next_start_day(
dr.start_date().plus_days(1),
dr.end_date().plus_days(1),
prior_shift_by_one,
next_shift_by_one,
dr.start_day(),
)
}
#[test]
fn new_and_accessors_and_len_inclusive() {
let r = DateRange::new(d(2023, 1, 1), d(2023, 1, 7));
assert_eq!(r.start_date(), d(2023, 1, 1));
assert_eq!(r.end_date(), d(2023, 1, 7));
assert_eq!(r.len(), 7); }
#[test]
fn iter_and_dates_and_date_at_bounds() {
let r = DateRange::new(d(2023, 3, 28), d(2023, 4, 2)); let v = r.dates();
assert_eq!(v.len(), r.len());
assert_eq!(v.first().copied(), Some(d(2023, 3, 28)));
assert_eq!(v.last().copied(), Some(d(2023, 4, 2)));
let it: Vec<_> = r.iter().collect();
assert_eq!(it, v);
assert_eq!(r.date_at(0), Some(d(2023, 3, 28)));
assert_eq!(r.date_at(r.len() - 1), Some(d(2023, 4, 2)));
assert_eq!(r.date_at(r.len()), None);
}
#[test]
fn dates_for_day_filters_correct_weekdays() {
let r = DateRange::new(d(2023, 5, 1), d(2023, 5, 7));
let mondays = r.dates_for_day(DayOfWeek::Monday);
assert_eq!(mondays, vec![d(2023, 5, 1)]);
let sunday = r.dates_for_day(DayOfWeek::Sunday);
assert_eq!(sunday, vec![d(2023, 5, 7)]);
}
#[test]
fn predicates_contains_overlaps() {
let r = DateRange::new(d(2023, 1, 10), d(2023, 1, 20));
assert!(r.contains_date(d(2023, 1, 10)));
assert!(r.contains_date(d(2023, 1, 15)));
assert!(r.contains_date(d(2023, 1, 20)));
assert!(!r.contains_date(d(2023, 1, 9)));
assert!(!r.contains_date(d(2023, 1, 21)));
let inner = DateRange::new(d(2023, 1, 12), d(2023, 1, 18));
assert!(r.contains_range(&inner));
let left_overlap = DateRange::new(d(2023, 1, 5), d(2023, 1, 12));
let right_overlap = DateRange::new(d(2023, 1, 18), d(2023, 1, 25));
let non_overlap = DateRange::new(d(2023, 1, 21), d(2023, 1, 25));
assert!(r.overlaps(&left_overlap));
assert!(r.overlaps(&right_overlap));
assert!(!r.overlaps(&non_overlap));
let many = vec![non_overlap, left_overlap, right_overlap];
assert!(r.overlaps_any(&many));
let none = vec![DateRange::new(d(2023, 1, 1), d(2023, 1, 5))];
assert!(!r.overlaps_any(&none));
}
#[test]
fn prior_next_default_shift_by_len_and_n_variants() {
let r = DateRange::new(d(2023, 1, 1), d(2023, 1, 7)); let p = r.prior();
assert_eq!(p.start_date(), d(2022, 12, 25));
assert_eq!(p.end_date(), d(2022, 12, 31));
let n = r.next();
assert_eq!(n.start_date(), d(2023, 1, 8));
assert_eq!(n.end_date(), d(2023, 1, 14));
let p2 = r.prior_n(2);
assert_eq!(p2.start_date(), d(2022, 12, 18));
assert_eq!(p2.end_date(), d(2022, 12, 24));
let n3 = r.next_n(3);
assert_eq!(n3.start_date(), d(2023, 1, 22));
assert_eq!(n3.end_date(), d(2023, 1, 28));
}
#[test]
fn prior_next_with_custom_functions_shift_by_one_day() {
let base = DateRange::new_with_prior_next_start_day(
d(2023, 6, 10),
d(2023, 6, 15),
prior_shift_by_one,
next_shift_by_one,
Some(16),
);
assert_eq!(base.start_day(), Some(16));
let p = base.prior();
assert_eq!(p.start_date(), d(2023, 6, 9));
assert_eq!(p.end_date(), d(2023, 6, 14));
let n = base.next();
assert_eq!(n.start_date(), d(2023, 6, 11));
assert_eq!(n.end_date(), d(2023, 6, 16));
}
#[test]
fn range_containing_date_moves_forward_and_backward() {
let base = DateRange::new(d(2023, 1, 1), d(2023, 1, 7));
let f = base.range_containing_date(d(2023, 1, 19));
assert_eq!(f.start_date(), d(2023, 1, 15));
assert_eq!(f.end_date(), d(2023, 1, 21));
let b = base.range_containing_date(d(2022, 12, 20));
assert_eq!(b.start_date(), d(2022, 12, 18));
assert_eq!(b.end_date(), d(2022, 12, 24));
}
#[test]
fn ranges_before_and_after_and_window_orders() {
let base = DateRange::new(d(2023, 1, 1), d(2023, 1, 7));
let before = base.ranges_before(2);
assert_eq!(before.len(), 2);
assert_eq!(before[0].start_date(), d(2022, 12, 18));
assert_eq!(before[0].end_date(), d(2022, 12, 24));
assert_eq!(before[1].start_date(), d(2022, 12, 25));
assert_eq!(before[1].end_date(), d(2022, 12, 31));
let before_incl = base.ranges_before_inclusive(2);
assert_eq!(before_incl.len(), 3);
assert_eq!(before_incl[0].start_date(), d(2022, 12, 18));
assert_eq!(before_incl[1].start_date(), d(2022, 12, 25));
assert_eq!(before_incl[2].start_date(), d(2023, 1, 1));
let after = base.ranges_after(2);
assert_eq!(after.len(), 2);
assert_eq!(after[0].start_date(), d(2023, 1, 8));
assert_eq!(after[1].start_date(), d(2023, 1, 15));
let after_incl = base.ranges_after_inclusive(2);
assert_eq!(after_incl.len(), 3);
assert_eq!(after_incl[0].start_date(), d(2023, 1, 1));
assert_eq!(after_incl[1].start_date(), d(2023, 1, 8));
assert_eq!(after_incl[2].start_date(), d(2023, 1, 15));
let window = base.ranges_window(2, 2);
let expected = vec![
DateRange::new(d(2022, 12, 18), d(2022, 12, 24)),
DateRange::new(d(2022, 12, 25), d(2022, 12, 31)),
DateRange::new(d(2023, 1, 1), d(2023, 1, 7)),
DateRange::new(d(2023, 1, 8), d(2023, 1, 14)),
DateRange::new(d(2023, 1, 15), d(2023, 1, 21)),
];
assert_eq!(window, expected);
}
#[test]
fn ranges_containing_span_covers_all_intervening_ranges() {
let base = DateRange::new(d(2023, 1, 1), d(2023, 1, 7));
let ranges = base.ranges_containing_span(d(2023, 1, 5), d(2023, 1, 25));
let starts: Vec<_> = ranges.iter().map(|r| r.start_date()).collect();
assert_eq!(starts, vec![
d(2023, 1, 1),
d(2023, 1, 8),
d(2023, 1, 15),
d(2023, 1, 22),
]);
assert!(ranges.first().unwrap().contains_date(d(2023, 1, 5)));
assert!(ranges.last().unwrap().contains_date(d(2023, 1, 25)));
}
#[test]
fn ordering_and_equality_semantics() {
let a = DateRange::new(d(2023, 1, 1), d(2023, 1, 7));
let b = DateRange::new(d(2023, 1, 8), d(2023, 1, 14));
let c_same_as_a = DateRange::new(d(2023, 1, 1), d(2023, 1, 7));
assert_eq!(a, c_same_as_a);
assert!(a < b);
let mut v = vec![b, a];
v.sort();
assert_eq!(v, vec![a, b]);
}
}