2024-02-25 05:38:41 +00:00
|
|
|
use std::{collections::BTreeMap, ops::Range};
|
2024-02-23 12:40:01 +00:00
|
|
|
|
2024-02-25 05:38:41 +00:00
|
|
|
use chumsky::{prelude::*, Parser};
|
2024-02-23 12:40:01 +00:00
|
|
|
|
2024-02-23 17:14:15 +00:00
|
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
|
|
pub enum Statement {
|
2024-02-25 05:38:41 +00:00
|
|
|
Assignment(Assignment),
|
|
|
|
Identifier(Identifier),
|
|
|
|
Logic(Logic),
|
|
|
|
Value(Value),
|
2024-02-23 17:14:15 +00:00
|
|
|
}
|
|
|
|
|
2024-02-25 05:38:41 +00:00
|
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
|
|
pub struct Identifier(String);
|
2024-02-23 17:14:15 +00:00
|
|
|
|
|
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
|
|
pub struct Assignment {
|
|
|
|
identifier: Identifier,
|
2024-02-25 05:38:41 +00:00
|
|
|
value: Value,
|
2024-02-23 17:14:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Clone, Debug, PartialEq)]
|
2024-02-25 05:38:41 +00:00
|
|
|
pub struct Logic {
|
|
|
|
left: LogicExpression,
|
|
|
|
operator: LogicOperator,
|
|
|
|
right: LogicExpression,
|
2024-02-23 17:14:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Clone, Debug, PartialEq)]
|
2024-02-25 05:38:41 +00:00
|
|
|
pub enum LogicOperator {
|
|
|
|
Equal,
|
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
|
|
pub enum LogicExpression {
|
|
|
|
Identifier(Identifier),
|
|
|
|
Logic(Box<Logic>),
|
|
|
|
Value(Value),
|
2024-02-23 17:14:15 +00:00
|
|
|
}
|
|
|
|
|
2024-02-23 12:40:01 +00:00
|
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
|
|
pub enum Value {
|
|
|
|
Boolean(bool),
|
2024-02-23 13:23:35 +00:00
|
|
|
Float(f64),
|
2024-02-23 12:40:01 +00:00
|
|
|
Integer(i64),
|
2024-02-23 13:23:35 +00:00
|
|
|
List(Vec<Value>),
|
2024-02-25 05:38:41 +00:00
|
|
|
Map(BTreeMap<String, Value>),
|
2024-02-23 13:23:35 +00:00
|
|
|
Range(Range<i64>),
|
2024-02-23 12:40:01 +00:00
|
|
|
String(String),
|
|
|
|
}
|
|
|
|
|
2024-02-25 05:38:41 +00:00
|
|
|
pub fn parser<'src>() -> impl Parser<'src, &'src str, Statement, extra::Err<Rich<'src, char>>> {
|
|
|
|
let operator = |text: &'src str| just(text).padded();
|
2024-02-25 00:37:04 +00:00
|
|
|
|
2024-02-23 17:14:15 +00:00
|
|
|
let value = recursive(|value| {
|
|
|
|
let boolean = just("true")
|
|
|
|
.or(just("false"))
|
|
|
|
.map(|s: &str| Value::Boolean(s.parse().unwrap()));
|
|
|
|
|
|
|
|
let float_numeric = just('-')
|
|
|
|
.or_not()
|
|
|
|
.then(text::int(10))
|
|
|
|
.then(just('.').then(text::digits(10)))
|
|
|
|
.to_slice()
|
|
|
|
.map(|text: &str| Value::Float(text.parse().unwrap()));
|
|
|
|
|
|
|
|
let float_other = choice((just("Infinity"), just("-Infinity"), just("NaN")))
|
|
|
|
.map(|text| Value::Float(text.parse().unwrap()));
|
|
|
|
|
|
|
|
let float = choice((float_numeric, float_other));
|
|
|
|
|
2024-02-25 00:37:04 +00:00
|
|
|
let integer = just('-')
|
|
|
|
.or_not()
|
|
|
|
.then(text::int(10).padded())
|
|
|
|
.to_slice()
|
|
|
|
.map(|text: &str| {
|
|
|
|
let integer = text.parse::<i64>().unwrap();
|
2024-02-23 17:14:15 +00:00
|
|
|
|
2024-02-25 00:37:04 +00:00
|
|
|
Value::Integer(integer)
|
|
|
|
});
|
2024-02-23 17:14:15 +00:00
|
|
|
|
|
|
|
let delimited_string = |delimiter| {
|
|
|
|
just(delimiter)
|
|
|
|
.ignore_then(none_of(delimiter).repeated())
|
|
|
|
.then_ignore(just(delimiter))
|
|
|
|
.to_slice()
|
2024-02-25 00:37:04 +00:00
|
|
|
.map(|text: &str| Value::String(text[1..text.len() - 1].to_string()))
|
2024-02-23 17:14:15 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
let string = choice((
|
|
|
|
delimited_string('\''),
|
|
|
|
delimited_string('"'),
|
|
|
|
delimited_string('`'),
|
|
|
|
));
|
|
|
|
|
|
|
|
let list = value
|
|
|
|
.clone()
|
|
|
|
.separated_by(just(',').padded())
|
|
|
|
.allow_trailing()
|
|
|
|
.collect()
|
|
|
|
.padded()
|
|
|
|
.delimited_by(just('['), just(']'))
|
|
|
|
.map(|values| Value::List(values));
|
|
|
|
|
|
|
|
choice((boolean, float, integer, string, list))
|
|
|
|
});
|
|
|
|
|
2024-02-25 05:38:41 +00:00
|
|
|
let identifier = text::ident().map(|text: &str| Identifier(text.to_string()));
|
|
|
|
|
|
|
|
let assignment = identifier
|
|
|
|
.then_ignore(operator("="))
|
|
|
|
.then(value.clone())
|
|
|
|
.map(|(identifier, value)| Assignment { identifier, value });
|
|
|
|
|
|
|
|
let logic = recursive(|logic| {
|
|
|
|
choice((
|
|
|
|
value.clone().map(|value| LogicExpression::Value(value)),
|
|
|
|
identifier.map(|identifier| LogicExpression::Identifier(identifier)),
|
|
|
|
logic
|
|
|
|
.clone()
|
|
|
|
.map(|logic| LogicExpression::Logic(Box::new(logic))),
|
|
|
|
))
|
|
|
|
.then(operator("==").map(|_| LogicOperator::Equal))
|
|
|
|
.then(choice((
|
|
|
|
value.clone().map(|value| LogicExpression::Value(value)),
|
|
|
|
identifier.map(|identifier| LogicExpression::Identifier(identifier)),
|
|
|
|
logic.map(|logic| LogicExpression::Logic(Box::new(logic))),
|
|
|
|
)))
|
|
|
|
.map(|((left, operator), right)| Logic {
|
|
|
|
left,
|
|
|
|
operator,
|
|
|
|
right,
|
|
|
|
})
|
|
|
|
});
|
|
|
|
|
|
|
|
choice((
|
|
|
|
logic.map(|logic| Statement::Logic(logic)),
|
|
|
|
assignment.map(|assignment| Statement::Assignment(assignment)),
|
|
|
|
value.map(|value| Statement::Value(value)),
|
|
|
|
identifier.map(|identifier| Statement::Identifier(identifier)),
|
|
|
|
))
|
2023-09-28 19:58:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
2024-02-23 12:40:01 +00:00
|
|
|
use super::*;
|
|
|
|
|
2024-02-25 05:38:41 +00:00
|
|
|
#[test]
|
|
|
|
fn parse_identifier() {
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse("x").unwrap(),
|
|
|
|
Statement::Identifier(Identifier("x".to_string()))
|
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse("foobar").unwrap(),
|
|
|
|
Statement::Identifier(Identifier("foobar".to_string())),
|
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse("HELLO").unwrap(),
|
|
|
|
Statement::Identifier(Identifier("HELLO".to_string())),
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn parse_assignment() {
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse("foobar=1").unwrap(),
|
|
|
|
Statement::Assignment(Assignment {
|
|
|
|
identifier: Identifier("foobar".to_string()),
|
|
|
|
value: Value::Integer(1)
|
|
|
|
})
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn parse_logic() {
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse("x == 1").unwrap(),
|
|
|
|
Statement::Logic(Logic {
|
|
|
|
left: LogicExpression::Identifier(Identifier("x".to_string())),
|
|
|
|
operator: LogicOperator::Equal,
|
|
|
|
right: LogicExpression::Value(Value::Integer(1))
|
|
|
|
})
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2024-02-23 17:14:15 +00:00
|
|
|
#[test]
|
|
|
|
fn parse_list() {
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse("[]").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::List(vec![]))
|
2024-02-23 17:14:15 +00:00
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse("[42]").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::List(vec![Value::Integer(42)]))
|
2024-02-23 17:14:15 +00:00
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse("[42, 'foo', \"bar\", [1, 2, 3,]]").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::List(vec![
|
2024-02-23 17:14:15 +00:00
|
|
|
Value::Integer(42),
|
|
|
|
Value::String("foo".to_string()),
|
|
|
|
Value::String("bar".to_string()),
|
|
|
|
Value::List(vec![
|
|
|
|
Value::Integer(1),
|
|
|
|
Value::Integer(2),
|
|
|
|
Value::Integer(3),
|
|
|
|
])
|
|
|
|
]))
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2024-02-23 12:40:01 +00:00
|
|
|
#[test]
|
|
|
|
fn parse_true() {
|
2024-02-23 17:14:15 +00:00
|
|
|
assert_eq!(
|
|
|
|
parser().parse("true").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::Boolean(true))
|
2024-02-23 17:14:15 +00:00
|
|
|
);
|
2024-02-23 12:40:01 +00:00
|
|
|
}
|
|
|
|
|
2023-09-28 19:58:01 +00:00
|
|
|
#[test]
|
2024-02-23 12:40:01 +00:00
|
|
|
fn parse_false() {
|
2024-02-23 17:14:15 +00:00
|
|
|
assert_eq!(
|
|
|
|
parser().parse("false").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::Boolean(false))
|
2024-02-23 17:14:15 +00:00
|
|
|
);
|
2024-02-23 13:23:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn parse_positive_float() {
|
|
|
|
assert_eq!(
|
2024-02-23 17:14:15 +00:00
|
|
|
parser().parse("0.0").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::Float(0.0))
|
2024-02-23 13:23:35 +00:00
|
|
|
);
|
|
|
|
assert_eq!(
|
2024-02-23 17:14:15 +00:00
|
|
|
parser().parse("42.0").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::Float(42.0))
|
2024-02-23 17:14:15 +00:00
|
|
|
);
|
|
|
|
|
|
|
|
let max_float = f64::MAX.to_string() + ".0";
|
|
|
|
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse(&max_float).unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::Float(f64::MAX))
|
2024-02-23 17:14:15 +00:00
|
|
|
);
|
|
|
|
|
|
|
|
let min_positive_float = f64::MIN_POSITIVE.to_string();
|
|
|
|
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse(&min_positive_float).unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::Float(f64::MIN_POSITIVE))
|
2024-02-23 13:23:35 +00:00
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn parse_negative_float() {
|
|
|
|
assert_eq!(
|
2024-02-23 17:14:15 +00:00
|
|
|
parser().parse("-0.0").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::Float(-0.0))
|
2024-02-23 13:23:35 +00:00
|
|
|
);
|
|
|
|
assert_eq!(
|
2024-02-23 17:14:15 +00:00
|
|
|
parser().parse("-42.0").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::Float(-42.0))
|
2024-02-23 17:14:15 +00:00
|
|
|
);
|
|
|
|
|
|
|
|
let min_float = f64::MIN.to_string() + ".0";
|
|
|
|
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse(&min_float).unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::Float(f64::MIN))
|
2024-02-23 17:14:15 +00:00
|
|
|
);
|
|
|
|
|
2024-02-25 00:37:04 +00:00
|
|
|
let max_negative_float = format!("-{}", f64::MIN_POSITIVE);
|
2024-02-23 17:14:15 +00:00
|
|
|
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse(&max_negative_float).unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::Float(-f64::MIN_POSITIVE))
|
2024-02-23 13:23:35 +00:00
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn parse_other_float() {
|
|
|
|
assert_eq!(
|
2024-02-23 17:14:15 +00:00
|
|
|
parser().parse("Infinity").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::Float(f64::INFINITY))
|
2024-02-23 17:14:15 +00:00
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse("-Infinity").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::Float(f64::NEG_INFINITY))
|
2024-02-23 13:23:35 +00:00
|
|
|
);
|
|
|
|
|
2024-02-25 05:38:41 +00:00
|
|
|
if let Statement::Value(Value::Float(float)) = parser().parse("NaN").unwrap() {
|
2024-02-23 13:23:35 +00:00
|
|
|
assert!(float.is_nan())
|
|
|
|
} else {
|
|
|
|
panic!("Expected a float.")
|
|
|
|
}
|
2024-02-23 12:40:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn parse_positive_integer() {
|
2024-02-23 17:14:15 +00:00
|
|
|
assert_eq!(
|
|
|
|
parser().parse("0").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::Integer(0))
|
2024-02-23 17:14:15 +00:00
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse("1").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::Integer(1))
|
2024-02-23 17:14:15 +00:00
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse("2").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::Integer(2))
|
2024-02-23 17:14:15 +00:00
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse("3").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::Integer(3))
|
2024-02-23 17:14:15 +00:00
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse("4").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::Integer(4))
|
2024-02-23 17:14:15 +00:00
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse("5").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::Integer(5))
|
2024-02-23 17:14:15 +00:00
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse("6").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::Integer(6))
|
2024-02-23 17:14:15 +00:00
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse("7").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::Integer(7))
|
2024-02-23 17:14:15 +00:00
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse("8").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::Integer(8))
|
2024-02-23 17:14:15 +00:00
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse("9").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::Integer(9))
|
2024-02-23 17:14:15 +00:00
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse("42").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::Integer(42))
|
2024-02-23 17:14:15 +00:00
|
|
|
);
|
|
|
|
|
|
|
|
let maximum_integer = i64::MAX.to_string();
|
|
|
|
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse(&maximum_integer).unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::Integer(i64::MAX))
|
2024-02-23 12:40:01 +00:00
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn parse_negative_integer() {
|
2024-02-23 17:14:15 +00:00
|
|
|
assert_eq!(
|
|
|
|
parser().parse("-0").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::Integer(-0))
|
2024-02-23 17:14:15 +00:00
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse("-1").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::Integer(-1))
|
2024-02-23 17:14:15 +00:00
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse("-2").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::Integer(-2))
|
2024-02-23 17:14:15 +00:00
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse("-3").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::Integer(-3))
|
2024-02-23 17:14:15 +00:00
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse("-4").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::Integer(-4))
|
2024-02-23 17:14:15 +00:00
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse("-5").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::Integer(-5))
|
2024-02-23 17:14:15 +00:00
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse("-6").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::Integer(-6))
|
2024-02-23 17:14:15 +00:00
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse("-7").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::Integer(-7))
|
2024-02-23 17:14:15 +00:00
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse("-8").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::Integer(-8))
|
2024-02-23 17:14:15 +00:00
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse("-9").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::Integer(-9))
|
2024-02-23 17:14:15 +00:00
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse("-42").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::Integer(-42))
|
2024-02-23 17:14:15 +00:00
|
|
|
);
|
|
|
|
|
|
|
|
let minimum_integer = i64::MIN.to_string();
|
|
|
|
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse(&minimum_integer).unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::Integer(i64::MIN))
|
2024-02-23 12:40:01 +00:00
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn double_quoted_string() {
|
|
|
|
assert_eq!(
|
2024-02-23 17:14:15 +00:00
|
|
|
parser().parse("\"\"").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::String("".to_string()))
|
2024-02-23 17:14:15 +00:00
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse("\"1\"").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::String("1".to_string()))
|
2024-02-23 17:14:15 +00:00
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse("\"42\"").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::String("42".to_string()))
|
2024-02-23 17:14:15 +00:00
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse("\"foobar\"").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::String("foobar".to_string()))
|
2024-02-23 12:40:01 +00:00
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn single_quoted_string() {
|
|
|
|
assert_eq!(
|
2024-02-23 17:14:15 +00:00
|
|
|
parser().parse("''").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::String("".to_string()))
|
2024-02-23 17:14:15 +00:00
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse("'1'").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::String("1".to_string()))
|
2024-02-23 17:14:15 +00:00
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse("'42'").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::String("42".to_string()))
|
2024-02-23 17:14:15 +00:00
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse("'foobar'").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::String("foobar".to_string()))
|
2024-02-23 12:40:01 +00:00
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn grave_quoted_string() {
|
|
|
|
assert_eq!(
|
2024-02-23 17:14:15 +00:00
|
|
|
parser().parse("``").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::String("".to_string()))
|
2024-02-23 17:14:15 +00:00
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse("`1`").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::String("1".to_string()))
|
2024-02-23 17:14:15 +00:00
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse("`42`").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::String("42".to_string()))
|
2024-02-23 17:14:15 +00:00
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
parser().parse("`foobar`").unwrap(),
|
2024-02-25 05:38:41 +00:00
|
|
|
Statement::Value(Value::String("foobar".to_string()))
|
2024-02-23 12:40:01 +00:00
|
|
|
);
|
2023-09-28 19:58:01 +00:00
|
|
|
}
|
|
|
|
}
|