robinpath_modules/modules/

cron_mod.rs

use robinpath::{RobinPath, Value};

pub fn register(rp: &mut RobinPath) {
    // cron.isValid expression → bool
    rp.register_builtin("cron.isValid", |args, _| {
        let expr = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        Ok(Value::Bool(parse_cron(&expr).is_some()))
    });

    // cron.parse expression → {minute, hour, dayOfMonth, month, dayOfWeek}
    rp.register_builtin("cron.parse", |args, _| {
        let expr = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        match parse_cron(&expr) {
            Some(fields) => {
                let mut obj = indexmap::IndexMap::new();
                obj.insert("minute".to_string(), vec_to_value(&fields.minutes));
                obj.insert("hour".to_string(), vec_to_value(&fields.hours));
                obj.insert("dayOfMonth".to_string(), vec_to_value(&fields.days));
                obj.insert("month".to_string(), vec_to_value(&fields.months));
                obj.insert("dayOfWeek".to_string(), vec_to_value(&fields.weekdays));
                Ok(Value::Object(obj))
            }
            None => Err(format!("Invalid cron expression: {}", expr)),
        }
    });

    // cron.next expression from? → ISO date string
    rp.register_builtin("cron.next", |args, _| {
        let expr = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let from = args.get(1).map(|v| v.to_display_string());
        let fields = parse_cron(&expr).ok_or_else(|| format!("Invalid cron: {}", expr))?;
        let start = parse_datetime(&from);
        match next_occurrence(&fields, start) {
            Some(dt) => Ok(Value::String(format_datetime(dt))),
            None => Ok(Value::Null),
        }
    });

    // cron.nextN expression count from? → array of ISO date strings
    rp.register_builtin("cron.nextN", |args, _| {
        let expr = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let count = args.get(1).map(|v| v.to_number() as usize).unwrap_or(5);
        let from = args.get(2).map(|v| v.to_display_string());
        let fields = parse_cron(&expr).ok_or_else(|| format!("Invalid cron: {}", expr))?;
        let mut current = parse_datetime(&from);
        let mut results = Vec::new();
        for _ in 0..count {
            match next_occurrence(&fields, current) {
                Some(dt) => {
                    results.push(Value::String(format_datetime(dt)));
                    current = dt + 60; // advance by 1 minute
                }
                None => break,
            }
        }
        Ok(Value::Array(results))
    });

    // cron.describe expression → human-readable string
    rp.register_builtin("cron.describe", |args, _| {
        let expr = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let fields = parse_cron(&expr).ok_or_else(|| format!("Invalid cron: {}", expr))?;
        Ok(Value::String(describe_cron(&fields)))
    });

    // cron.matches expression date? → bool
    rp.register_builtin("cron.matches", |args, _| {
        let expr = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let date = args.get(1).map(|v| v.to_display_string());
        let fields = parse_cron(&expr).ok_or_else(|| format!("Invalid cron: {}", expr))?;
        let ts = parse_datetime(&date);
        let (_, mon, day, hour, min, wday) = timestamp_to_parts(ts);
        let matches = fields.minutes.contains(&min)
            && fields.hours.contains(&hour)
            && fields.days.contains(&day)
            && fields.months.contains(&mon)
            && fields.weekdays.contains(&wday);
        Ok(Value::Bool(matches))
    });
}

struct CronFields {
    minutes: Vec<u32>,
    hours: Vec<u32>,
    days: Vec<u32>,
    months: Vec<u32>,
    weekdays: Vec<u32>,
}

fn parse_cron(expr: &str) -> Option<CronFields> {
    let parts: Vec<&str> = expr.trim().split_whitespace().collect();
    if parts.len() != 5 { return None; }
    Some(CronFields {
        minutes: parse_field(parts[0], 0, 59)?,
        hours: parse_field(parts[1], 0, 23)?,
        days: parse_field(parts[2], 1, 31)?,
        months: parse_field(parts[3], 1, 12)?,
        weekdays: parse_field(parts[4], 0, 6)?,
    })
}

fn parse_field(field: &str, min: u32, max: u32) -> Option<Vec<u32>> {
    let mut values = Vec::new();
    for part in field.split(',') {
        let part = part.trim();
        if part == "*" {
            return Some((min..=max).collect());
        }
        if let Some(slash) = part.find('/') {
            let range_part = &part[..slash];
            let step: u32 = part[slash + 1..].parse().ok()?;
            let start = if range_part == "*" { min } else { range_part.parse().ok()? };
            let mut v = start;
            while v <= max {
                values.push(v);
                v += step;
            }
        } else if let Some(dash) = part.find('-') {
            let start: u32 = part[..dash].parse().ok()?;
            let end: u32 = part[dash + 1..].parse().ok()?;
            for v in start..=end {
                values.push(v);
            }
        } else {
            values.push(part.parse().ok()?);
        }
    }
    values.sort();
    values.dedup();
    Some(values)
}

fn vec_to_value(v: &[u32]) -> Value {
    Value::Array(v.iter().map(|&n| Value::Number(n as f64)).collect())
}

// Simple timestamp-based date handling (seconds since epoch)
fn parse_datetime(s: &Option<String>) -> i64 {
    if let Some(date_str) = s {
        // Try ISO 8601 parsing (simplified)
        let trimmed = date_str.trim();
        if trimmed.len() >= 10 {
            let parts: Vec<&str> = trimmed[..10].split('-').collect();
            if parts.len() == 3 {
                if let (Ok(y), Ok(m), Ok(d)) = (parts[0].parse::<i64>(), parts[1].parse::<u32>(), parts[2].parse::<u32>()) {
                    let (hour, min) = if trimmed.len() >= 16 {
                        let time_part = &trimmed[11..];
                        let time_parts: Vec<&str> = time_part.split(':').collect();
                        (time_parts.first().and_then(|s| s.parse().ok()).unwrap_or(0u32),
                         time_parts.get(1).and_then(|s| s[..2.min(s.len())].parse().ok()).unwrap_or(0u32))
                    } else {
                        (0, 0)
                    };
                    return date_to_timestamp(y, m, d, hour, min);
                }
            }
        }
    }
    std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap_or_default()
        .as_secs() as i64
}

fn date_to_timestamp(year: i64, month: u32, day: u32, hour: u32, min: u32) -> i64 {
    // Simplified: days since epoch
    let mut y = year;
    let mut m = month as i64;
    if m <= 2 { y -= 1; m += 12; }
    let days = 365 * y + y / 4 - y / 100 + y / 400 + (153 * (m - 3) + 2) / 5 + day as i64 - 719469;
    days * 86400 + hour as i64 * 3600 + min as i64 * 60
}

fn timestamp_to_parts(ts: i64) -> (i64, u32, u32, u32, u32, u32) {
    let days = ts.div_euclid(86400);
    let time_of_day = ts.rem_euclid(86400);
    let hour = (time_of_day / 3600) as u32;
    let min = ((time_of_day % 3600) / 60) as u32;
    // Day of week: Jan 1 1970 was Thursday (4)
    let wday = ((days + 4).rem_euclid(7)) as u32;
    // Date from days since epoch
    let z = days + 719468;
    let era = z.div_euclid(146097);
    let doe = z.rem_euclid(146097);
    let yoe = (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365;
    let y = yoe + era * 400;
    let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
    let mp = (5 * doy + 2) / 153;
    let d = (doy - (153 * mp + 2) / 5 + 1) as u32;
    let m = if mp < 10 { mp + 3 } else { mp - 9 } as u32;
    let y = if m <= 2 { y + 1 } else { y };
    (y, m, d, hour, min, wday)
}

fn format_datetime(ts: i64) -> String {
    let (y, m, d, h, min, _) = timestamp_to_parts(ts);
    format!("{:04}-{:02}-{:02}T{:02}:{:02}:00Z", y, m, d, h, min)
}

fn next_occurrence(fields: &CronFields, after: i64) -> Option<i64> {
    let mut ts = after + 60; // start from next minute
    ts -= ts % 60; // round down to minute
    let max_ts = ts + 366 * 86400; // search up to 1 year
    while ts < max_ts {
        let (_, mon, day, hour, min, wday) = timestamp_to_parts(ts);
        if fields.minutes.contains(&min)
            && fields.hours.contains(&hour)
            && fields.days.contains(&day)
            && fields.months.contains(&mon)
            && fields.weekdays.contains(&wday)
        {
            return Some(ts);
        }
        ts += 60;
    }
    None
}

fn describe_cron(fields: &CronFields) -> String {
    let min_str = if fields.minutes.len() == 60 { "every minute".to_string() }
        else { format!("at minute {}", join_nums(&fields.minutes)) };
    let hour_str = if fields.hours.len() == 24 { "every hour".to_string() }
        else { format!("at hour {}", join_nums(&fields.hours)) };
    let day_str = if fields.days.len() == 31 { "every day".to_string() }
        else { format!("on day {}", join_nums(&fields.days)) };
    let mon_str = if fields.months.len() == 12 { "every month".to_string() }
        else { format!("in month {}", join_nums(&fields.months)) };
    format!("{}, {}, {}, {}", min_str, hour_str, day_str, mon_str)
}

fn join_nums(v: &[u32]) -> String {
    v.iter().map(|n| n.to_string()).collect::<Vec<_>>().join(",")
}