glue 0.8.7

//! Parser combinators for finding arbitrary types.

use crate::types::*;
use std::ops::Bound;
use std::ops::RangeBounds;

#[inline]
/// Run a parser a minimum number of times and up to a maximum and capture its results.
///
/// ```
/// # use glue::prelude::*;
/// assert_eq!(find(1..2, is("foo")).parse("foofoobar"), Ok((
///     ParserContext {
///         input: "foofoobar",
///         bounds: 3..6
///     },
///     vec!["foo", "foo"],
/// )));
/// ```
pub fn find<'a, Res, Par, Rep>(range: Rep, mut callback: Par) -> impl Parser<'a, Vec<Res>>
where
    Par: Parser<'a, Res>,
    Rep: RangeBounds<usize>,
{
    move |ctx: ParserContext<'a>| {
        let minimum: usize = match range.start_bound() {
            Bound::Excluded(min) => *min,
            Bound::Included(min) => *min,
            Bound::Unbounded => 0,
        };
        let maximum: usize = match range.end_bound() {
            Bound::Excluded(max) => *max,
            Bound::Included(max) => *max + 1,
            Bound::Unbounded => 0,
        };
        let mut temp_ctx = ctx.clone();
        let mut results = Vec::new();

        loop {
            if maximum > 0 && results.len() == maximum {
                break;
            }

            match callback.parse(temp_ctx) {
                Ok((ret_ctx, result)) => {
                    temp_ctx = ret_ctx;
                    results.push(result);
                }
                Err((ret_ctx, error)) => {
                    temp_ctx = ret_ctx;

                    if results.len() < minimum {
                        return Err(ctx.with_data(SourceError::Ranges(vec![error])));
                    }

                    break;
                }
            }
        }

        let end = temp_ctx.bounds.end - ctx.bounds.end;

        if end > 0 {
            Ok(temp_ctx.with_data(results))
        } else if minimum == 0 {
            Ok(temp_ctx.with_data(results))
        } else {
            let error = SourceError::Ranges(vec![SourceError::Range(ctx.bounds.clone())]);

            Err(ctx.with_data(error))
        }
    }
}

#[inline]
/// Run each of the provided parsers and in the specified order and return all of the results.
///
/// ```
/// # use glue::prelude::*;
/// assert_eq!(find_all((is("foo"), is("bar"))).parse("foobar"), Ok((
///     ParserContext {
///         input: "foobar",
///         bounds: 0..6,
///     },
///     ("foo", "bar"),
/// )));
/// ```
pub fn find_all<'a, Res, Par>(mut parser: Par) -> impl Parser<'a, Res>
where
    Par: SequenceParser<'a, Res>,
{
    move |ctx| {
        parser
            .find_all(ctx)
            .map_error(|error| SourceError::Ranges(vec![error]))
    }
}

#[inline]
/// Run each of the provided parsers until one is successful and return its result.
///
/// ```
/// # use glue::prelude::*;
/// assert_eq!(
///     find_any((is("foo"), is("bar"))).parse("foobar"),
///     Ok((
///         ParserContext {
///             input: "foobar",
///             bounds: 0..3,
///         },
///         "foo",
///     ))
/// );
/// ```
///
/// Each parser that is passed to `find_any` must return the same type as the parser only has a single output type.
pub fn find_any<'a, Res, Par>(mut parser: Par) -> impl Parser<'a, Res>
where
    Par: BranchParser<'a, Res>,
{
    move |ctx| parser.find_any(ctx)
}

#[inline]
/// Parse a structure that consists of multiple parsers separated by another.
///
/// For example, comma separated values:
///
/// ```
/// # use glue::prelude::*;
/// assert_eq!(
///     find_separated(0.., is(digit), is(',')).parse("1,2,3"),
///     Ok((
///         ParserContext {
///             input: "1,2,3",
///             bounds: 4..5,
///         },
///         vec!["1", "2", "3"]
///     ))
/// );
/// ```
pub fn find_separated<'a, Par, ParRes, Sep, SepRes, Rep>(
    range: Rep,
    mut callback: Par,
    mut separator: Sep,
) -> impl Parser<'a, Vec<ParRes>>
where
    Par: Parser<'a, ParRes>,
    Sep: Parser<'a, SepRes>,
    Rep: RangeBounds<usize>,
{
    move |ctx: ParserContext<'a>| {
        let minimum: usize = match range.start_bound() {
            Bound::Excluded(val) => *val,
            Bound::Included(val) => *val,
            Bound::Unbounded => 0,
        };
        let maximum: usize = match range.end_bound() {
            Bound::Excluded(val) => *val,
            Bound::Included(val) => *val + 1,
            Bound::Unbounded => 0,
        };
        let mut results = Vec::new();
        let mut temp_ctx = ctx.clone();

        loop {
            if !results.is_empty() {
                match separator.parse(temp_ctx) {
                    Err((ret_ctx, error)) => {
                        return if results.len() < minimum {
                            Err(ret_ctx.with_data(SourceError::Ranges(vec![error])))
                        } else {
                            Ok(ret_ctx.with_data(results))
                        };
                    }
                    Ok((ret_ctx, _)) => {
                        temp_ctx = ret_ctx;
                    }
                }
            }

            if maximum > 0 && results.len() == maximum {
                return Ok(temp_ctx.with_data(results));
            }

            match callback.parse(temp_ctx) {
                Err((ret_ctx, error)) => {
                    return if results.len() < minimum {
                        Err(ret_ctx.with_data(SourceError::Ranges(vec![error])))
                    } else {
                        Ok(ret_ctx.with_data(results))
                    }
                }
                Ok((ret_ctx, result)) => {
                    temp_ctx = ret_ctx;
                    results.push(result);
                }
            }
        }
    }
}

#[inline]
/// Run a parser until a predicate is reached and capture its results.
///
/// ```
/// # use glue::prelude::*;
/// assert_eq!(
///     find_until(eoi(), is(numeric)).parse("123"),
///     Ok((
///         ParserContext {
///             input: "123",
///             bounds: 0..3,
///         },
///         vec!["1", "2", "3"]
///     ))
/// );
/// ```
pub fn find_until<'a, Skip, Res, Pred, Par>(
    mut predicate: Pred,
    mut callback: Par,
) -> impl Parser<'a, Vec<Res>>
where
    Pred: Parser<'a, Skip>,
    Par: Parser<'a, Res>,
{
    move |ctx: ParserContext<'a>| {
        let mut temp_ctx = ctx.clone();
        let mut results = Vec::new();

        loop {
            match predicate.parse(temp_ctx.clone()) {
                Ok((_, _)) => {
                    break;
                }
                Err(_) => {}
            }

            match callback.parse(temp_ctx) {
                Ok((ret_ctx, result)) => {
                    temp_ctx = ret_ctx;
                    results.push(result);
                }
                Err((ret_ctx, error)) => {
                    return Err(ret_ctx.with_data(SourceError::Ranges(vec![error])))
                }
            }
        }

        Ok(ctx.expand(temp_ctx).with_data(results))
    }
}

#[inline]
/// Run a parser, and if it is successful, run another parser and return its results.
///
/// ```
/// # use glue::prelude::*;
/// assert_eq!(
///     find_when(is('-'), find_all((is('-'), is(digit)))).parse("-1"),
///     Ok((
///         ParserContext {
///             input: "-1",
///             bounds: 0..2,
///         },
///         ("-", "1")
///     ))
/// );
/// ```
///
/// This is useful for gating off more complicated branches of a parser behind a
/// sanity check, but less useful when applied to everything as that results in more
/// work to parse the same input.
///
/// It can also be used to hide branches from error reports as those branches will error
/// at the `find_when` parser first, and not at the main parser which might itself produce
/// a lot more errors if it is allowed to run.
///
/// For example:
///
/// ```
/// # use glue::prelude::*;
/// fn branch_a<'a>() -> impl Parser<'a, &'a str> {
///     move |ctx| {
///         map_error(take_all((is("a="), is(digit))), |error| {
///             error.tag("branch a")
///         })
///         .parse(ctx)
///     }
/// }
///
/// fn branch_b<'a>() -> impl Parser<'a, &'a str> {
///     move |ctx| {
///         map_error(take_all((is("b="), is(digit))), |error| {
///             error.tag("branch b")
///         })
///         .parse(ctx)
///     }
/// }
///
/// assert_eq!(
///     find_any((branch_a(), branch_b())).parse("b"),
///     // SourceError message contains a reference to each branch that failed:
///     Err((
///         ParserContext {
///             input: "b",
///             bounds: 0..0
///         },
///         SourceError::Ranges(vec![
///             SourceError::TaggedRanges(
///                 "branch a".into(),
///                 vec![SourceError::Ranges(vec![SourceError::Range(0..0)])]
///             ),
///             SourceError::TaggedRanges(
///                 "branch b".into(),
///                 vec![SourceError::Ranges(vec![SourceError::Range(0..0)])]
///             ),
///         ])
///     ))
/// );
/// ```
///
/// The amount of information returned in the error is reduced by using `find_when` to check which branch is followed:
///
/// ```
/// # use glue::prelude::*;
/// # fn branch_a<'a>() -> impl Parser<'a, &'a str> {
/// #     move |ctx| {
/// #         map_error(take_all((is("a="), is(digit))), |error| {
/// #             error.tag("branch a")
/// #         })
/// #         .parse(ctx)
/// #     }
/// # }
/// # fn branch_b<'a>() -> impl Parser<'a, &'a str> {
/// #     move |ctx| {
/// #         map_error(take_all((is("b="), is(digit))), |error| {
/// #             error.tag("branch b")
/// #         })
/// #         .parse(ctx)
/// #     }
/// # }
/// assert_eq!(
///     find_any((find_when(is('a'), branch_a()), find_when(is('b'), branch_b()))).parse("b"),
///     Err((
///         ParserContext {
///             input: "b",
///             bounds: 0..0
///         },
///         SourceError::Ranges(vec![
///             SourceError::Range(0..0),
///             SourceError::TaggedRanges(
///                 "branch b".into(),
///                 vec![SourceError::Ranges(vec![SourceError::Range(0..0)])]
///             ),
///         ])
///     ))
/// );
/// ```
pub fn find_when<'a, Res, Skip, Pred, Par>(
    mut predicate: Pred,
    mut parser: Par,
) -> impl Parser<'a, Res>
where
    Pred: Parser<'a, Skip>,
    Par: Parser<'a, Res>,
{
    move |ctx: ParserContext<'a>| predicate.parse(ctx.clone()).and_then(|_| parser.parse(ctx))
}

#[inline]
/// Run a predicate, and if it is not successful, run another parser and return its results.
///
/// ```
/// # use glue::prelude::*;
/// assert_eq!(
///     find_when_not(is(digit), find_all((is('-'), is(digit)))).parse("-1"),
///     Ok((
///         ParserContext {
///             input: "-1",
///             bounds: 0..2,
///         },
///         ("-", "1")
///     ))
/// );
/// ```
pub fn find_when_not<'a, Pred, PredRes, Par, ParRes>(
    mut predicate: Pred,
    mut parser: Par,
) -> impl Parser<'a, ParRes>
where
    Pred: Parser<'a, PredRes>,
    Par: Parser<'a, ParRes>,
{
    move |ctx: ParserContext<'a>| match predicate.parse(ctx.clone()) {
        Ok((ctx, _)) => {
            let error = SourceError::Range(ctx.bounds.clone());

            Err(ctx.with_data(error))
        }
        Err(_) => parser.parse(ctx),
    }
}