organic/src/parser/timestamp.rs

use nom::branch::alt;

use super::Context;
use crate::error::Res;
use crate::parser::parser_with_context::parser_with_context;
use crate::parser::util::not_yet_implemented;
use crate::parser::Timestamp;

#[tracing::instrument(ret, level = "debug")]
pub fn timestamp<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, Timestamp<'s>> {
    // TODO: This would be more efficient if we didn't throw away the parse result of the first half of an active/inactive date range timestamp if the parse fails (as in, the first thing active_date_range_timestamp parses is a active_timestamp but then we throw that away if it doesn't turn out to be a full active_date_range_timestamp despite the active_timestamp parse being completely valid). I am going with the simplest/cleanest approach for the first implementation.
    alt((
        // Order matters here. If its a date range, we need to parse the entire date range instead of just the first timestamp. If its a time range, we need to make sure thats parsed as a time range instead of as the "rest" portion of a single timestamp.
        parser_with_context!(diary_timestamp)(context),
        parser_with_context!(active_time_range_timestamp)(context),
        parser_with_context!(inactive_time_range_timestamp)(context),
        parser_with_context!(active_date_range_timestamp)(context),
        parser_with_context!(inactive_date_range_timestamp)(context),
        parser_with_context!(active_timestamp)(context),
        parser_with_context!(inactive_timestamp)(context),
    ))(input)
}

#[tracing::instrument(ret, level = "debug")]
fn diary_timestamp<'r, 's>(
    context: Context<'r, 's>,
    input: &'s str,
) -> Res<&'s str, Timestamp<'s>> {
    not_yet_implemented()?;
    todo!()
}

#[tracing::instrument(ret, level = "debug")]
fn active_timestamp<'r, 's>(
    context: Context<'r, 's>,
    input: &'s str,
) -> Res<&'s str, Timestamp<'s>> {
    not_yet_implemented()?;
    todo!()
}

#[tracing::instrument(ret, level = "debug")]
fn inactive_timestamp<'r, 's>(
    context: Context<'r, 's>,
    input: &'s str,
) -> Res<&'s str, Timestamp<'s>> {
    not_yet_implemented()?;
    todo!()
}

#[tracing::instrument(ret, level = "debug")]
fn active_date_range_timestamp<'r, 's>(
    context: Context<'r, 's>,
    input: &'s str,
) -> Res<&'s str, Timestamp<'s>> {
    not_yet_implemented()?;
    todo!()
}

#[tracing::instrument(ret, level = "debug")]
fn active_time_range_timestamp<'r, 's>(
    context: Context<'r, 's>,
    input: &'s str,
) -> Res<&'s str, Timestamp<'s>> {
    not_yet_implemented()?;
    todo!()
}

#[tracing::instrument(ret, level = "debug")]
fn inactive_date_range_timestamp<'r, 's>(
    context: Context<'r, 's>,
    input: &'s str,
) -> Res<&'s str, Timestamp<'s>> {
    not_yet_implemented()?;
    todo!()
}

#[tracing::instrument(ret, level = "debug")]
fn inactive_time_range_timestamp<'r, 's>(
    context: Context<'r, 's>,
    input: &'s str,
) -> Res<&'s str, Timestamp<'s>> {
    not_yet_implemented()?;
    todo!()
}