2023-05-14 00:04:47 +00:00
|
|
|
|
use crate::units::{NonMetric, NonMetricQuantity};
|
|
|
|
|
|
|
|
|
|
enum Expect {
|
|
|
|
|
Number,
|
|
|
|
|
Unit,
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[derive(Debug, PartialEq)]
|
|
|
|
|
pub enum ParseError {
|
|
|
|
|
NotValidNumber(String),
|
|
|
|
|
UnexpectedUnit(String),
|
|
|
|
|
UnknownUnit(String),
|
|
|
|
|
ExpectedUnit,
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub fn parse(input: &str) -> Result<Vec<NonMetricQuantity>, ParseError> {
|
|
|
|
|
let mut quantities = Vec::new();
|
|
|
|
|
let mut state = Expect::Number;
|
|
|
|
|
let mut amount = None;
|
|
|
|
|
|
|
|
|
|
for token in tokenize(input) {
|
|
|
|
|
match (&state, token) {
|
|
|
|
|
(Expect::Number, Token::Number(number)) => {
|
2023-05-28 15:22:49 +00:00
|
|
|
|
let number = parse_number(number)?;
|
2023-05-14 00:04:47 +00:00
|
|
|
|
amount = Some(number);
|
|
|
|
|
state = Expect::Unit;
|
|
|
|
|
}
|
|
|
|
|
(Expect::Number, Token::Unit(unit)) => {
|
|
|
|
|
return Err(ParseError::UnexpectedUnit(unit));
|
|
|
|
|
}
|
|
|
|
|
(Expect::Unit, Token::Number(_)) => {
|
|
|
|
|
unreachable!("token stream can't contain two numbers in a row");
|
|
|
|
|
}
|
|
|
|
|
(Expect::Unit, Token::Unit(unit)) => {
|
2023-05-28 15:22:49 +00:00
|
|
|
|
let unit = parse_unit(unit)?;
|
2023-05-14 00:04:47 +00:00
|
|
|
|
let quantity = NonMetricQuantity {
|
|
|
|
|
amount: amount.take().expect("must have read a number to be in this state"),
|
|
|
|
|
unit: unit,
|
|
|
|
|
};
|
|
|
|
|
quantities.push(quantity);
|
|
|
|
|
state = Expect::Number;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
match state {
|
2023-05-28 20:44:49 +00:00
|
|
|
|
Expect::Number => {}
|
2023-05-14 00:04:47 +00:00
|
|
|
|
Expect::Unit => {
|
|
|
|
|
return Err(ParseError::ExpectedUnit);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
Ok(quantities)
|
|
|
|
|
}
|
|
|
|
|
|
2023-05-28 15:22:49 +00:00
|
|
|
|
fn parse_number(input: String) -> Result<f64, ParseError> {
|
2023-05-28 15:07:28 +00:00
|
|
|
|
let no_whitespace: String = input.chars().filter(|c| !c.is_whitespace()).collect();
|
2023-05-28 15:22:49 +00:00
|
|
|
|
no_whitespace.parse().or_else(|_| Err(ParseError::NotValidNumber(input)))
|
2023-05-28 15:07:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-05-28 15:22:49 +00:00
|
|
|
|
fn parse_unit(input: String) -> Result<NonMetric, ParseError> {
|
|
|
|
|
match input.as_str() {
|
2023-05-14 00:04:47 +00:00
|
|
|
|
// Length
|
2023-05-28 15:22:49 +00:00
|
|
|
|
"inch" => Ok(NonMetric::Inch),
|
|
|
|
|
"inches" => Ok(NonMetric::Inch),
|
|
|
|
|
"in" => Ok(NonMetric::Inch),
|
|
|
|
|
"\"" => Ok(NonMetric::Inch),
|
|
|
|
|
"″" => Ok(NonMetric::Inch),
|
|
|
|
|
|
|
|
|
|
"foot" => Ok(NonMetric::Foot),
|
|
|
|
|
"feet" => Ok(NonMetric::Foot),
|
|
|
|
|
"ft" => Ok(NonMetric::Foot),
|
|
|
|
|
"'" => Ok(NonMetric::Foot),
|
|
|
|
|
"′" => Ok(NonMetric::Foot),
|
|
|
|
|
|
|
|
|
|
"yard" => Ok(NonMetric::Yard),
|
|
|
|
|
"yards" => Ok(NonMetric::Yard),
|
|
|
|
|
"yd" => Ok(NonMetric::Yard),
|
|
|
|
|
|
|
|
|
|
"mile" => Ok(NonMetric::Mile),
|
|
|
|
|
"miles" => Ok(NonMetric::Mile),
|
|
|
|
|
"mi" => Ok(NonMetric::Mile),
|
|
|
|
|
"m" => Ok(NonMetric::Mile),
|
2023-05-14 00:04:47 +00:00
|
|
|
|
|
|
|
|
|
// Weight
|
2023-05-28 15:22:49 +00:00
|
|
|
|
"ounce" => Ok(NonMetric::Ounce),
|
|
|
|
|
"ounces" => Ok(NonMetric::Ounce),
|
|
|
|
|
"oz" => Ok(NonMetric::Ounce),
|
2023-05-14 00:04:47 +00:00
|
|
|
|
|
2023-05-28 15:22:49 +00:00
|
|
|
|
"pound" => Ok(NonMetric::Pound),
|
|
|
|
|
"pounds" => Ok(NonMetric::Pound),
|
|
|
|
|
"lb" => Ok(NonMetric::Pound),
|
|
|
|
|
"lbs" => Ok(NonMetric::Pound),
|
|
|
|
|
"#" => Ok(NonMetric::Pound),
|
2023-05-14 00:04:47 +00:00
|
|
|
|
|
2023-05-28 15:22:49 +00:00
|
|
|
|
"stone" => Ok(NonMetric::Stone),
|
|
|
|
|
"stones" => Ok(NonMetric::Stone),
|
|
|
|
|
"st" => Ok(NonMetric::Stone),
|
2023-05-14 00:04:47 +00:00
|
|
|
|
|
2023-05-28 17:32:31 +00:00
|
|
|
|
// Temperature
|
|
|
|
|
"°F" => Ok(NonMetric::Fahrenheit),
|
|
|
|
|
"F" => Ok(NonMetric::Fahrenheit),
|
|
|
|
|
|
2023-05-28 15:22:49 +00:00
|
|
|
|
_ => Err(ParseError::UnknownUnit(input)),
|
2023-05-14 00:04:47 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[derive(Debug, PartialEq)]
|
|
|
|
|
enum Token {
|
|
|
|
|
Number(String),
|
|
|
|
|
Unit(String),
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
enum TokState {
|
|
|
|
|
Neutral,
|
|
|
|
|
Number,
|
|
|
|
|
Unit,
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn tokenize(input: &str) -> Vec<Token> {
|
|
|
|
|
let mut tokens = Vec::new();
|
|
|
|
|
let mut token = String::new();
|
|
|
|
|
let mut state = TokState::Neutral;
|
|
|
|
|
|
|
|
|
|
for c in input.chars() {
|
|
|
|
|
match state {
|
|
|
|
|
TokState::Neutral => {
|
|
|
|
|
if c.is_ascii_digit() || c == '-' {
|
|
|
|
|
token.push(c);
|
|
|
|
|
state = TokState::Number;
|
|
|
|
|
} else if !c.is_whitespace() {
|
|
|
|
|
token.push(c);
|
|
|
|
|
state = TokState::Unit;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
TokState::Number => {
|
|
|
|
|
if c.is_ascii_digit() ||
|
|
|
|
|
c.is_whitespace() ||
|
|
|
|
|
c == '.' {
|
|
|
|
|
token.push(c);
|
|
|
|
|
} else {
|
|
|
|
|
tokens.push(Token::Number(token.trim().to_string()));
|
|
|
|
|
state = TokState::Unit;
|
|
|
|
|
token = String::new();
|
|
|
|
|
token.push(c);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
TokState::Unit => {
|
|
|
|
|
if c.is_ascii_digit() || c == '-' {
|
|
|
|
|
tokens.push(Token::Unit(token));
|
|
|
|
|
state = TokState::Number;
|
|
|
|
|
token = String::new();
|
|
|
|
|
token.push(c);
|
2023-05-28 20:40:42 +00:00
|
|
|
|
} else if !c.is_whitespace() {
|
2023-05-14 00:04:47 +00:00
|
|
|
|
token.push(c);
|
|
|
|
|
} else {
|
|
|
|
|
tokens.push(Token::Unit(token));
|
|
|
|
|
state = TokState::Neutral;
|
|
|
|
|
token = String::new();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
match state {
|
|
|
|
|
TokState::Neutral => { assert!(token.len() == 0); }
|
|
|
|
|
TokState::Number => { tokens.push(Token::Number(token.trim().to_string())); }
|
|
|
|
|
TokState::Unit => { tokens.push(Token::Unit(token)); }
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
tokens
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
|
mod test {
|
|
|
|
|
use super::*;
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn parsing() {
|
|
|
|
|
assert_eq!(parse(""), Ok(vec![]));
|
|
|
|
|
assert_eq!(parse("5 ft"), Ok(vec![
|
|
|
|
|
NonMetricQuantity { amount: 5.0, unit: NonMetric::Foot },
|
|
|
|
|
]));
|
|
|
|
|
assert_eq!(parse("5 ft 8 in"), Ok(vec![
|
|
|
|
|
NonMetricQuantity { amount: 5.0, unit: NonMetric::Foot },
|
|
|
|
|
NonMetricQuantity { amount: 8.0, unit: NonMetric::Inch },
|
|
|
|
|
]));
|
2023-05-28 15:07:28 +00:00
|
|
|
|
assert_eq!(parse("20 000 lbs"), Ok(vec![
|
|
|
|
|
NonMetricQuantity { amount: 20_000.0, unit: NonMetric::Pound },
|
|
|
|
|
]));
|
2023-05-14 00:04:47 +00:00
|
|
|
|
|
|
|
|
|
assert_eq!(parse("12.0."), Err(ParseError::NotValidNumber("12.0.".to_string())));
|
|
|
|
|
assert_eq!(parse("ft"), Err(ParseError::UnexpectedUnit("ft".to_string())));
|
|
|
|
|
assert_eq!(parse("5 tf"), Err(ParseError::UnknownUnit("tf".to_string())));
|
|
|
|
|
assert_eq!(parse("12"), Err(ParseError::ExpectedUnit));
|
|
|
|
|
}
|
|
|
|
|
|
2023-05-28 15:07:28 +00:00
|
|
|
|
#[test]
|
|
|
|
|
fn numbers() {
|
2023-05-28 15:22:49 +00:00
|
|
|
|
assert_eq!(parse_number("".to_string()), Err(ParseError::NotValidNumber("".to_string())));
|
|
|
|
|
assert_eq!(parse_number("1".to_string()), Ok(1.0));
|
|
|
|
|
assert_eq!(parse_number("1.0".to_string()), Ok(1.0));
|
|
|
|
|
assert_eq!(parse_number("0.1".to_string()), Ok(0.1));
|
|
|
|
|
assert_eq!(parse_number("0.1.".to_string()), Err(ParseError::NotValidNumber("0.1.".to_string())));
|
|
|
|
|
assert_eq!(parse_number("-10".to_string()), Ok(-10.0));
|
|
|
|
|
assert_eq!(parse_number("10\t00\u{1680}000".to_string()), Ok(10_00_000.0));
|
2023-05-28 15:07:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-05-14 00:04:47 +00:00
|
|
|
|
#[test]
|
|
|
|
|
fn units() {
|
|
|
|
|
// Length
|
2023-05-28 15:22:49 +00:00
|
|
|
|
assert_eq!(parse_unit("inch".to_string()), Ok(NonMetric::Inch));
|
|
|
|
|
assert_eq!(parse_unit("inches".to_string()), Ok(NonMetric::Inch));
|
|
|
|
|
assert_eq!(parse_unit("in".to_string()), Ok(NonMetric::Inch));
|
|
|
|
|
assert_eq!(parse_unit("\"".to_string()), Ok(NonMetric::Inch));
|
|
|
|
|
assert_eq!(parse_unit("″".to_string()), Ok(NonMetric::Inch));
|
|
|
|
|
|
|
|
|
|
assert_eq!(parse_unit("foot".to_string()), Ok(NonMetric::Foot));
|
|
|
|
|
assert_eq!(parse_unit("feet".to_string()), Ok(NonMetric::Foot));
|
|
|
|
|
assert_eq!(parse_unit("ft".to_string()), Ok(NonMetric::Foot));
|
|
|
|
|
assert_eq!(parse_unit("'".to_string()), Ok(NonMetric::Foot));
|
|
|
|
|
assert_eq!(parse_unit("′".to_string()), Ok(NonMetric::Foot));
|
|
|
|
|
|
|
|
|
|
assert_eq!(parse_unit("yard".to_string()), Ok(NonMetric::Yard));
|
|
|
|
|
assert_eq!(parse_unit("yards".to_string()), Ok(NonMetric::Yard));
|
|
|
|
|
assert_eq!(parse_unit("yd".to_string()), Ok(NonMetric::Yard));
|
|
|
|
|
|
|
|
|
|
assert_eq!(parse_unit("mile".to_string()), Ok(NonMetric::Mile));
|
|
|
|
|
assert_eq!(parse_unit("miles".to_string()), Ok(NonMetric::Mile));
|
|
|
|
|
assert_eq!(parse_unit("mi".to_string()), Ok(NonMetric::Mile));
|
|
|
|
|
assert_eq!(parse_unit("m".to_string()), Ok(NonMetric::Mile));
|
2023-05-14 00:04:47 +00:00
|
|
|
|
|
|
|
|
|
// Weight
|
2023-05-28 15:22:49 +00:00
|
|
|
|
assert_eq!(parse_unit("ounce".to_string()), Ok(NonMetric::Ounce));
|
|
|
|
|
assert_eq!(parse_unit("ounces".to_string()), Ok(NonMetric::Ounce));
|
|
|
|
|
assert_eq!(parse_unit("oz".to_string()), Ok(NonMetric::Ounce));
|
2023-05-14 00:04:47 +00:00
|
|
|
|
|
2023-05-28 15:22:49 +00:00
|
|
|
|
assert_eq!(parse_unit("pound".to_string()), Ok(NonMetric::Pound));
|
|
|
|
|
assert_eq!(parse_unit("pounds".to_string()), Ok(NonMetric::Pound));
|
|
|
|
|
assert_eq!(parse_unit("lb".to_string()), Ok(NonMetric::Pound));
|
|
|
|
|
assert_eq!(parse_unit("lbs".to_string()), Ok(NonMetric::Pound));
|
|
|
|
|
assert_eq!(parse_unit("#".to_string()), Ok(NonMetric::Pound));
|
2023-05-14 00:04:47 +00:00
|
|
|
|
|
2023-05-28 15:22:49 +00:00
|
|
|
|
assert_eq!(parse_unit("stone".to_string()), Ok(NonMetric::Stone));
|
|
|
|
|
assert_eq!(parse_unit("stones".to_string()), Ok(NonMetric::Stone));
|
|
|
|
|
assert_eq!(parse_unit("st".to_string()), Ok(NonMetric::Stone));
|
2023-05-14 00:04:47 +00:00
|
|
|
|
|
2023-05-28 17:32:31 +00:00
|
|
|
|
// Temperature
|
|
|
|
|
assert_eq!(parse_unit("°F".to_string()), Ok(NonMetric::Fahrenheit));
|
|
|
|
|
assert_eq!(parse_unit("F".to_string()), Ok(NonMetric::Fahrenheit));
|
|
|
|
|
|
2023-05-14 00:04:47 +00:00
|
|
|
|
// Unknown unit
|
2023-05-28 15:22:49 +00:00
|
|
|
|
assert_eq!(parse_unit("hutenosa".to_string()), Err(ParseError::UnknownUnit("hutenosa".to_string())));
|
2023-05-14 00:04:47 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn tokens() {
|
|
|
|
|
assert_eq!(tokenize(""), vec![]);
|
|
|
|
|
assert_eq!(tokenize("10"), vec![Token::Number("10".to_string())]);
|
|
|
|
|
assert_eq!(tokenize(" 10 "), vec![Token::Number("10".to_string())]);
|
|
|
|
|
assert_eq!(tokenize("10 000"), vec![Token::Number("10 000".to_string())]);
|
2023-05-28 15:07:28 +00:00
|
|
|
|
assert_eq!(tokenize("10\t000"), vec![Token::Number("10\t000".to_string())]);
|
|
|
|
|
assert_eq!(tokenize("10\u{1680}000"), vec![Token::Number("10\u{1680}000".to_string())]);
|
2023-05-14 00:04:47 +00:00
|
|
|
|
assert_eq!(tokenize("10.0.1"), vec![Token::Number("10.0.1".to_string())]);
|
|
|
|
|
assert_eq!(tokenize("ft"), vec![Token::Unit("ft".to_string())]);
|
|
|
|
|
assert_eq!(
|
|
|
|
|
tokenize("10 ft"),
|
|
|
|
|
vec![
|
|
|
|
|
Token::Number("10".to_string()),
|
|
|
|
|
Token::Unit("ft".to_string()),
|
|
|
|
|
]
|
|
|
|
|
);
|
|
|
|
|
assert_eq!(
|
|
|
|
|
tokenize("ft in"),
|
|
|
|
|
vec![
|
|
|
|
|
Token::Unit("ft".to_string()),
|
|
|
|
|
Token::Unit("in".to_string()),
|
|
|
|
|
]
|
|
|
|
|
);
|
|
|
|
|
assert_eq!(
|
|
|
|
|
tokenize("5 ft 7 in"),
|
|
|
|
|
vec![
|
|
|
|
|
Token::Number("5".to_string()),
|
|
|
|
|
Token::Unit("ft".to_string()),
|
|
|
|
|
Token::Number("7".to_string()),
|
|
|
|
|
Token::Unit("in".to_string()),
|
|
|
|
|
]
|
|
|
|
|
);
|
|
|
|
|
assert_eq!(
|
|
|
|
|
tokenize("5\"7'"),
|
|
|
|
|
vec![
|
|
|
|
|
Token::Number("5".to_string()),
|
|
|
|
|
Token::Unit("\"".to_string()),
|
|
|
|
|
Token::Number("7".to_string()),
|
|
|
|
|
Token::Unit("'".to_string()),
|
|
|
|
|
]
|
|
|
|
|
);
|
|
|
|
|
assert_eq!(
|
|
|
|
|
tokenize(" 2.2lbs "),
|
|
|
|
|
vec![
|
|
|
|
|
Token::Number("2.2".to_string()),
|
|
|
|
|
Token::Unit("lbs".to_string()),
|
|
|
|
|
]
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
}
|