fosk 0.2.0

use crate::parser::{ParseError, QueryParser, ast::ScalarExpr};

pub struct ParamParser;

impl ParamParser {
    pub fn is_param(parser: &QueryParser) -> bool {
        parser.comparers.param.compare(parser)
    }

    pub fn parse(parser: &mut QueryParser) -> Result<ScalarExpr, ParseError> {
        if parser.comparers.param.compare(parser) {
            parser.jump(parser.comparers.param.length);
            return Ok(ScalarExpr::Parameter);
        }

        Err(ParseError::new(
            "Invalid Parameter",
            parser.position,
            parser,
        ))
    }
}

#[cfg(test)]
pub mod tests {
    use crate::parser::{
        QueryParser,
        ast::{ParamParser, ScalarExpr},
    };

    fn parse_param(text: &str) {
        let mut parser = QueryParser::new(text);
        match ParamParser::parse(&mut parser) {
            Ok(ScalarExpr::Parameter) => {}
            other => panic!("expected parameter expression, got {other:?}"),
        }
    }

    #[test]
    pub fn test_param_parser() {
        parse_param("?");
    }

    #[test]
    pub fn test_param_parser_upper() {
        parse_param("?");
    }

    #[test]
    pub fn test_param_parser_param_space_delimiter() {
        parse_param("? ");
    }

    #[test]
    pub fn test_param_parser_param_comma_delimiter() {
        parse_param("?,");
    }

    #[test]
    pub fn test_param_parser_param_break_line() {
        parse_param("?\r\n");
    }

    #[test]
    pub fn test_param_parser_param_wrong() {
        let text = "?e";

        let mut parser = QueryParser::new(text);

        let result = ParamParser::parse(&mut parser);

        match result {
            Ok(_) => panic!(),
            Err(err) => {
                assert_eq!(err.text, "?");
                assert_eq!(err.start, 0);
                assert_eq!(err.end, 0);
            }
        }
    }

    #[test]
    pub fn test_param_parser_param_wrong_2() {
        let text = "?#";

        let mut parser = QueryParser::new(text);

        let result = ParamParser::parse(&mut parser);

        match result {
            Ok(_) => panic!(),
            Err(err) => {
                assert_eq!(err.text, "?");
                assert_eq!(err.start, 0);
                assert_eq!(err.end, 0);
            }
        }
    }
}