nortti
/
metrify
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Compare commits

base: nortti:f354fbe55512eebcbbc044e406a59ad6541c3456
Branches Tags
nortti:main
...
compare: nortti:db674d1419f33c94577a328574e965408165a865
Branches Tags
nortti:main

5 Commits
f354fbe555 ... db674d1419

Author SHA1 Message Date
Juhani Krekelä db674d1419 Suggest disambiguation for tons 2023-06-01 02:55:47 +03:00
Juhani Krekelä 9badd90b91 Add support for long tons 2023-06-01 02:53:07 +03:00
Juhani Krekelä f69177edca Add support for short tons 2023-06-01 02:53:07 +03:00
Juhani Krekelä d6e0e95a6a Simplify parse::test::units 2023-06-01 02:53:07 +03:00
Juhani Krekelä a297d87ff1 Simplify parse::test::ambiguous_units 2023-06-01 02:53:07 +03:00
4 changed files with 321 additions and 265 deletions
Show Stats Expand all files Collapse all files

12
src/conversions.rs
View File

@ -64,6 +64,16 @@ fn get_conversion(unit: NonMetric) -> Conversion {
from: pound_from,
to: MetricQuantity { amount: 14.0 * pound_to, unit: Metric::Gram },
},
NonMetric::ShortTon => Conversion {
offset: 0.0,
from: pound_from,
to: MetricQuantity { amount: 2000.0 * pound_to, unit: Metric::Gram },
},
NonMetric::LongTon => Conversion {
offset: 0.0,
from: pound_from,
to: MetricQuantity { amount: 2240.0 * pound_to, unit: Metric::Gram },
},
// Temperature
NonMetric::Fahrenheit => Conversion {
offset: 32.0,
@ -184,6 +194,8 @@ mod test {
Test(NonMetric::Ounce, 28.349523125),
Test(NonMetric::Pound, 453.59237),
Test(NonMetric::Stone, 6350.29318),
Test(NonMetric::ShortTon, 907184.74),
Test(NonMetric::LongTon, 1016046.9088),
];
run_tests(&tests, Metric::Gram);
}

4
src/lib.rs
View File

@ -77,6 +77,8 @@ fn unit_to_name(unit: NonMetric) -> &'static str {
NonMetric::Ounce => "ounces",
NonMetric::Pound => "pounds",
NonMetric::Stone => "stones",
NonMetric::ShortTon => "short tons",
NonMetric::LongTon => "long tons",
// Temperature
NonMetric::Fahrenheit => "degrees Fahrenheit",
// Area
@ -129,6 +131,8 @@ mod test {
assert_eq!(run("1 oz"), Ok("28.35 g".to_string()));
assert_eq!(run("1 lb"), Ok("453.6 g".to_string()));
assert_eq!(run("1 st"), Ok("6.35 kg".to_string()));
assert_eq!(run("1 short ton"), Ok("907.2 kg".to_string()));
assert_eq!(run("1 long ton"), Ok("1 016 kg".to_string()));
// Temperature
assert_eq!(run("-40 °F"), Ok("-40 °C".to_string()));
assert_eq!(run("0 °F"), Ok("-17.78 °C".to_string()));

568
src/parse.rs
View File

@ -98,6 +98,20 @@ fn parse_unit(input: String) -> Result<NonMetric, ParseError> {
"stones" => Ok(NonMetric::Stone),
"st" => Ok(NonMetric::Stone),
"short ton" => Ok(NonMetric::ShortTon),
"short tons" => Ok(NonMetric::ShortTon),
"US ton" => Ok(NonMetric::ShortTon),
"US tons" => Ok(NonMetric::ShortTon),
"us ton" => Ok(NonMetric::ShortTon),
"us tons" => Ok(NonMetric::ShortTon),
"long ton" => Ok(NonMetric::LongTon),
"long tons" => Ok(NonMetric::LongTon),
"imperial ton" => Ok(NonMetric::LongTon),
"imperial tons" => Ok(NonMetric::LongTon),
"imp ton" => Ok(NonMetric::LongTon),
"imp tons" => Ok(NonMetric::LongTon),
// Temperature
"degree Fahrenheit" => Ok(NonMetric::Fahrenheit),
"degrees Fahrenheit" => Ok(NonMetric::Fahrenheit),
@ -282,6 +296,9 @@ fn parse_unit(input: String) -> Result<NonMetric, ParseError> {
"us gal" => Ok(NonMetric::USGallon),
// Ambiguous units
"ton" => Err(ParseError::AmbiguousUnit(input, "short", "long")),
"tons" => Err(ParseError::AmbiguousUnit(input, "short", "long")),
"fluid ounce" => Err(ParseError::AmbiguousUnit(input, "imperial", "US")),
"fluid ounces" => Err(ParseError::AmbiguousUnit(input, "imperial", "US")),
"fl oz" => Err(ParseError::AmbiguousUnit(input, "imp", "US")),
@ -413,325 +430,346 @@ mod test {
#[test]
fn units() {
// Length
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));
test_units(NonMetric::Inch, &[
"inch",
"inches",
"in",
"\"",
"″",
]);
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));
test_units(NonMetric::Foot, &[
"foot",
"feet",
"ft",
"'",
"′",
]);
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));
test_units(NonMetric::Yard, &[
"yard",
"yards",
"yd",
]);
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));
test_units(NonMetric::Mile, &[
"mile",
"miles",
"mi",
"m",
]);
// Weight
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));
test_units(NonMetric::Ounce, &[
"ounce",
"ounces",
"oz",
]);
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));
test_units(NonMetric::Pound, &[
"pound",
"pounds",
"lb",
"lbs",
"#",
]);
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));
test_units(NonMetric::Stone, &[
"stone",
"stones",
"st",
]);
test_units(NonMetric::ShortTon, &[
"short ton",
"short tons",
"US ton",
"US tons",
"us ton",
"us tons",
]);
test_units(NonMetric::LongTon, &[
"long ton",
"long tons",
"imperial ton",
"imperial tons",
"imp ton",
"imp tons",
]);
// Temperature
assert_eq!(parse_unit("degree Fahrenheit".to_string()), Ok(NonMetric::Fahrenheit));
assert_eq!(parse_unit("degrees Fahrenheit".to_string()), Ok(NonMetric::Fahrenheit));
assert_eq!(parse_unit("degree fahrenheit".to_string()), Ok(NonMetric::Fahrenheit));
assert_eq!(parse_unit("degrees fahrenheit".to_string()), Ok(NonMetric::Fahrenheit));
assert_eq!(parse_unit("Fahrenheit".to_string()), Ok(NonMetric::Fahrenheit));
assert_eq!(parse_unit("fahrenheit".to_string()), Ok(NonMetric::Fahrenheit));
assert_eq!(parse_unit("°F".to_string()), Ok(NonMetric::Fahrenheit));
assert_eq!(parse_unit("F".to_string()), Ok(NonMetric::Fahrenheit));
test_units(NonMetric::Fahrenheit, &[
"degree Fahrenheit",
"degrees Fahrenheit",
"degree fahrenheit",
"degrees fahrenheit",
"Fahrenheit",
"fahrenheit",
"°F",
"F",
]);
// Area
assert_eq!(parse_unit("square inch".to_string()), Ok(NonMetric::SquareInch));
assert_eq!(parse_unit("square inches".to_string()), Ok(NonMetric::SquareInch));
assert_eq!(parse_unit("square in".to_string()), Ok(NonMetric::SquareInch));
assert_eq!(parse_unit("sq inch".to_string()), Ok(NonMetric::SquareInch));
assert_eq!(parse_unit("sq inches".to_string()), Ok(NonMetric::SquareInch));
assert_eq!(parse_unit("sq in".to_string()), Ok(NonMetric::SquareInch));
assert_eq!(parse_unit("inch²".to_string()), Ok(NonMetric::SquareInch));
assert_eq!(parse_unit("inches²".to_string()), Ok(NonMetric::SquareInch));
assert_eq!(parse_unit("in²".to_string()), Ok(NonMetric::SquareInch));
assert_eq!(parse_unit("\"²".to_string()), Ok(NonMetric::SquareInch));
assert_eq!(parse_unit("″²".to_string()), Ok(NonMetric::SquareInch));
assert_eq!(parse_unit("inch^2".to_string()), Ok(NonMetric::SquareInch));
assert_eq!(parse_unit("inches^2".to_string()), Ok(NonMetric::SquareInch));
assert_eq!(parse_unit("in^2".to_string()), Ok(NonMetric::SquareInch));
assert_eq!(parse_unit("\"^2".to_string()), Ok(NonMetric::SquareInch));
test_units(NonMetric::SquareInch, &[
"square inch",
"square inches",
"square in",
"sq inch",
"sq inches",
"sq in",
"inch²",
"inches²",
"in²",
"\"²",
"″²",
"inch^2",
"inches^2",
"in^2",
"\"^2",
]);
assert_eq!(parse_unit("square foot".to_string()), Ok(NonMetric::SquareFoot));
assert_eq!(parse_unit("square feet".to_string()), Ok(NonMetric::SquareFoot));
assert_eq!(parse_unit("square ft".to_string()), Ok(NonMetric::SquareFoot));
assert_eq!(parse_unit("sq foot".to_string()), Ok(NonMetric::SquareFoot));
assert_eq!(parse_unit("sq feet".to_string()), Ok(NonMetric::SquareFoot));
assert_eq!(parse_unit("sq ft".to_string()), Ok(NonMetric::SquareFoot));
assert_eq!(parse_unit("foot²".to_string()), Ok(NonMetric::SquareFoot));
assert_eq!(parse_unit("feet²".to_string()), Ok(NonMetric::SquareFoot));
assert_eq!(parse_unit("ft²".to_string()), Ok(NonMetric::SquareFoot));
assert_eq!(parse_unit("'²".to_string()), Ok(NonMetric::SquareFoot));
assert_eq!(parse_unit("′²".to_string()), Ok(NonMetric::SquareFoot));
assert_eq!(parse_unit("foot^2".to_string()), Ok(NonMetric::SquareFoot));
assert_eq!(parse_unit("feet^2".to_string()), Ok(NonMetric::SquareFoot));
assert_eq!(parse_unit("ft^2".to_string()), Ok(NonMetric::SquareFoot));
assert_eq!(parse_unit("'^2".to_string()), Ok(NonMetric::SquareFoot));
assert_eq!(parse_unit("sf".to_string()), Ok(NonMetric::SquareFoot));
test_units(NonMetric::SquareFoot, &[
"square foot",
"square feet",
"square ft",
"sq foot",
"sq feet",
"sq ft",
"foot²",
"feet²",
"ft²",
"'²",
"′²",
"foot^2",
"feet^2",
"ft^2",
"'^2",
"sf",
]);
assert_eq!(parse_unit("acre".to_string()), Ok(NonMetric::Acre));
assert_eq!(parse_unit("acres".to_string()), Ok(NonMetric::Acre));
assert_eq!(parse_unit("ac".to_string()), Ok(NonMetric::Acre));
test_units(NonMetric::Acre, &[
"acre",
"acres",
"ac",
]);
assert_eq!(parse_unit("square mile".to_string()), Ok(NonMetric::SquareMile));
assert_eq!(parse_unit("square miles".to_string()), Ok(NonMetric::SquareMile));
assert_eq!(parse_unit("square mi".to_string()), Ok(NonMetric::SquareMile));
assert_eq!(parse_unit("sq mile".to_string()), Ok(NonMetric::SquareMile));
assert_eq!(parse_unit("sq miles".to_string()), Ok(NonMetric::SquareMile));
assert_eq!(parse_unit("sq mi".to_string()), Ok(NonMetric::SquareMile));
assert_eq!(parse_unit("mile²".to_string()), Ok(NonMetric::SquareMile));
assert_eq!(parse_unit("miles²".to_string()), Ok(NonMetric::SquareMile));
assert_eq!(parse_unit("mi²".to_string()), Ok(NonMetric::SquareMile));
assert_eq!(parse_unit("mile^2".to_string()), Ok(NonMetric::SquareMile));
assert_eq!(parse_unit("miles^2".to_string()), Ok(NonMetric::SquareMile));
assert_eq!(parse_unit("mi^2".to_string()), Ok(NonMetric::SquareMile));
test_units(NonMetric::SquareMile, &[
"square mile",
"square miles",
"square mi",
"sq mile",
"sq miles",
"sq mi",
"mile²",
"miles²",
"mi²",
"mile^2",
"miles^2",
"mi^2",
]);
// Volume
assert_eq!(parse_unit("cubic inch".to_string()), Ok(NonMetric::CubicInch));
assert_eq!(parse_unit("cubic inches".to_string()), Ok(NonMetric::CubicInch));
assert_eq!(parse_unit("cubic in".to_string()), Ok(NonMetric::CubicInch));
assert_eq!(parse_unit("cu inch".to_string()), Ok(NonMetric::CubicInch));
assert_eq!(parse_unit("cu inches".to_string()), Ok(NonMetric::CubicInch));
assert_eq!(parse_unit("cu in".to_string()), Ok(NonMetric::CubicInch));
assert_eq!(parse_unit("inch³".to_string()), Ok(NonMetric::CubicInch));
assert_eq!(parse_unit("inches³".to_string()), Ok(NonMetric::CubicInch));
assert_eq!(parse_unit("in³".to_string()), Ok(NonMetric::CubicInch));
assert_eq!(parse_unit("inch^3".to_string()), Ok(NonMetric::CubicInch));
assert_eq!(parse_unit("inches^3".to_string()), Ok(NonMetric::CubicInch));
assert_eq!(parse_unit("in^3".to_string()), Ok(NonMetric::CubicInch));
test_units(NonMetric::CubicInch, &[
"cubic inch",
"cubic inches",
"cubic in",
"cu inch",
"cu inches",
"cu in",
"inch³",
"inches³",
"in³",
"inch^3",
"inches^3",
"in^3",
]);
assert_eq!(parse_unit("cubic foot".to_string()), Ok(NonMetric::CubicFoot));
assert_eq!(parse_unit("cubic feet".to_string()), Ok(NonMetric::CubicFoot));
assert_eq!(parse_unit("cubic ft".to_string()), Ok(NonMetric::CubicFoot));
assert_eq!(parse_unit("cu foot".to_string()), Ok(NonMetric::CubicFoot));
assert_eq!(parse_unit("cu feet".to_string()), Ok(NonMetric::CubicFoot));
assert_eq!(parse_unit("cu ft".to_string()), Ok(NonMetric::CubicFoot));
assert_eq!(parse_unit("foot³".to_string()), Ok(NonMetric::CubicFoot));
assert_eq!(parse_unit("feet³".to_string()), Ok(NonMetric::CubicFoot));
assert_eq!(parse_unit("ft³".to_string()), Ok(NonMetric::CubicFoot));
assert_eq!(parse_unit("foot^3".to_string()), Ok(NonMetric::CubicFoot));
assert_eq!(parse_unit("feet^3".to_string()), Ok(NonMetric::CubicFoot));
assert_eq!(parse_unit("ft^3".to_string()), Ok(NonMetric::CubicFoot));
test_units(NonMetric::CubicFoot, &[
"cubic foot",
"cubic feet",
"cubic ft",
"cu foot",
"cu feet",
"cu ft",
"foot³",
"feet³",
"ft³",
"foot^3",
"feet^3",
"ft^3",
]);
// Fluid volume
assert_eq!(parse_unit("imperial fluid ounce".to_string()), Ok(NonMetric::ImperialFluidOunce));
assert_eq!(parse_unit("imperial fluid ounces".to_string()), Ok(NonMetric::ImperialFluidOunce));
assert_eq!(parse_unit("imp fl oz".to_string()), Ok(NonMetric::ImperialFluidOunce));
assert_eq!(parse_unit("imp fl. oz.".to_string()), Ok(NonMetric::ImperialFluidOunce));
assert_eq!(parse_unit("imp oz. fl.".to_string()), Ok(NonMetric::ImperialFluidOunce));
test_units(NonMetric::ImperialFluidOunce, &[
"imperial fluid ounce",
"imperial fluid ounces",
"imp fl oz",
"imp fl. oz.",
"imp oz. fl.",
]);
assert_eq!(parse_unit("imperial pint".to_string()), Ok(NonMetric::ImperialPint));
assert_eq!(parse_unit("imperial pints".to_string()), Ok(NonMetric::ImperialPint));
assert_eq!(parse_unit("imp pt".to_string()), Ok(NonMetric::ImperialPint));
assert_eq!(parse_unit("imp p".to_string()), Ok(NonMetric::ImperialPint));
test_units(NonMetric::ImperialPint, &[
"imperial pint",
"imperial pints",
"imp pt",
"imp p",
]);
assert_eq!(parse_unit("imperial quart".to_string()), Ok(NonMetric::ImperialQuart));
assert_eq!(parse_unit("imperial quarts".to_string()), Ok(NonMetric::ImperialQuart));
assert_eq!(parse_unit("imp qt".to_string()), Ok(NonMetric::ImperialQuart));
test_units(NonMetric::ImperialQuart, &[
"imperial quart",
"imperial quarts",
"imp qt",
]);
assert_eq!(parse_unit("imperial gallon".to_string()), Ok(NonMetric::ImperialGallon));
assert_eq!(parse_unit("imperial gallons".to_string()), Ok(NonMetric::ImperialGallon));
assert_eq!(parse_unit("imp gal".to_string()), Ok(NonMetric::ImperialGallon));
test_units(NonMetric::ImperialGallon, &[
"imperial gallon",
"imperial gallons",
"imp gal",
]);
assert_eq!(parse_unit("US teaspoon".to_string()), Ok(NonMetric::USTeaspoon));
assert_eq!(parse_unit("US teaspoons".to_string()), Ok(NonMetric::USTeaspoon));
assert_eq!(parse_unit("US tsp.".to_string()), Ok(NonMetric::USTeaspoon));
assert_eq!(parse_unit("US tsp".to_string()), Ok(NonMetric::USTeaspoon));
assert_eq!(parse_unit("us teaspoon".to_string()), Ok(NonMetric::USTeaspoon));
assert_eq!(parse_unit("us teaspoons".to_string()), Ok(NonMetric::USTeaspoon));
assert_eq!(parse_unit("us tsp.".to_string()), Ok(NonMetric::USTeaspoon));
assert_eq!(parse_unit("us tsp".to_string()), Ok(NonMetric::USTeaspoon));
assert_eq!(parse_unit("teaspoon".to_string()), Ok(NonMetric::USTeaspoon));
assert_eq!(parse_unit("teaspoons".to_string()), Ok(NonMetric::USTeaspoon));
assert_eq!(parse_unit("tsp.".to_string()), Ok(NonMetric::USTeaspoon));
assert_eq!(parse_unit("tsp".to_string()), Ok(NonMetric::USTeaspoon));
test_units(NonMetric::USTeaspoon, &[
"US teaspoon",
"US teaspoons",
"US tsp.",
"US tsp",
"us teaspoon",
"us teaspoons",
"us tsp.",
"us tsp",
"teaspoon",
"teaspoons",
"tsp.",
"tsp",
]);
assert_eq!(parse_unit("US tablespoon".to_string()), Ok(NonMetric::USTablespoon));
assert_eq!(parse_unit("US tablespoons".to_string()), Ok(NonMetric::USTablespoon));
assert_eq!(parse_unit("US Tbsp.".to_string()), Ok(NonMetric::USTablespoon));
assert_eq!(parse_unit("US Tbsp".to_string()), Ok(NonMetric::USTablespoon));
assert_eq!(parse_unit("us tablespoon".to_string()), Ok(NonMetric::USTablespoon));
assert_eq!(parse_unit("us tablespoons".to_string()), Ok(NonMetric::USTablespoon));
assert_eq!(parse_unit("us tbsp.".to_string()), Ok(NonMetric::USTablespoon));
assert_eq!(parse_unit("us tbsp".to_string()), Ok(NonMetric::USTablespoon));
assert_eq!(parse_unit("tablespoon".to_string()), Ok(NonMetric::USTablespoon));
assert_eq!(parse_unit("tablespoons".to_string()), Ok(NonMetric::USTablespoon));
assert_eq!(parse_unit("Tbsp.".to_string()), Ok(NonMetric::USTablespoon));
assert_eq!(parse_unit("Tbsp".to_string()), Ok(NonMetric::USTablespoon));
assert_eq!(parse_unit("tbsp.".to_string()), Ok(NonMetric::USTablespoon));
assert_eq!(parse_unit("tbsp".to_string()), Ok(NonMetric::USTablespoon));
test_units(NonMetric::USTablespoon, &[
"US tablespoon",
"US tablespoons",
"US Tbsp.",
"US Tbsp",
"us tablespoon",
"us tablespoons",
"us tbsp.",
"us tbsp",
"tablespoon",
"tablespoons",
"Tbsp.",
"Tbsp",
"tbsp.",
"tbsp",
]);
assert_eq!(parse_unit("US fluid ounce".to_string()), Ok(NonMetric::USFluidOunce));
assert_eq!(parse_unit("US fluid ounces".to_string()), Ok(NonMetric::USFluidOunce));
assert_eq!(parse_unit("US fl oz".to_string()), Ok(NonMetric::USFluidOunce));
assert_eq!(parse_unit("US fl. oz.".to_string()), Ok(NonMetric::USFluidOunce));
assert_eq!(parse_unit("US oz. fl.".to_string()), Ok(NonMetric::USFluidOunce));
assert_eq!(parse_unit("us fluid ounce".to_string()), Ok(NonMetric::USFluidOunce));
assert_eq!(parse_unit("us fluid ounces".to_string()), Ok(NonMetric::USFluidOunce));
assert_eq!(parse_unit("us fl oz".to_string()), Ok(NonMetric::USFluidOunce));
assert_eq!(parse_unit("us fl. oz.".to_string()), Ok(NonMetric::USFluidOunce));
assert_eq!(parse_unit("us oz. fl.".to_string()), Ok(NonMetric::USFluidOunce));
test_units(NonMetric::USFluidOunce, &[
"US fluid ounce",
"US fluid ounces",
"US fl oz",
"US fl. oz.",
"US oz. fl.",
"us fluid ounce",
"us fluid ounces",
"us fl oz",
"us fl. oz.",
"us oz. fl.",
]);
assert_eq!(parse_unit("US cup".to_string()), Ok(NonMetric::USCup));
assert_eq!(parse_unit("US cups".to_string()), Ok(NonMetric::USCup));
assert_eq!(parse_unit("us cup".to_string()), Ok(NonMetric::USCup));
assert_eq!(parse_unit("us cups".to_string()), Ok(NonMetric::USCup));
test_units(NonMetric::USCup, &[
"US cup",
"US cups",
"us cup",
"us cups",
]);
assert_eq!(parse_unit("US liquid pint".to_string()), Ok(NonMetric::USLiquidPint));
assert_eq!(parse_unit("US liquid pints".to_string()), Ok(NonMetric::USLiquidPint));
assert_eq!(parse_unit("US pint".to_string()), Ok(NonMetric::USLiquidPint));
assert_eq!(parse_unit("US pints".to_string()), Ok(NonMetric::USLiquidPint));
assert_eq!(parse_unit("US pt".to_string()), Ok(NonMetric::USLiquidPint));
assert_eq!(parse_unit("US p".to_string()), Ok(NonMetric::USLiquidPint));
assert_eq!(parse_unit("us liquid pint".to_string()), Ok(NonMetric::USLiquidPint));
assert_eq!(parse_unit("us liquid pints".to_string()), Ok(NonMetric::USLiquidPint));
assert_eq!(parse_unit("us pint".to_string()), Ok(NonMetric::USLiquidPint));
assert_eq!(parse_unit("us pints".to_string()), Ok(NonMetric::USLiquidPint));
assert_eq!(parse_unit("us pt".to_string()), Ok(NonMetric::USLiquidPint));
assert_eq!(parse_unit("us p".to_string()), Ok(NonMetric::USLiquidPint));
test_units(NonMetric::USLiquidPint, &[
"US liquid pint",
"US liquid pints",
"US pint",
"US pints",
"US pt",
"US p",
"us liquid pint",
"us liquid pints",
"us pint",
"us pints",
"us pt",
"us p",
]);
assert_eq!(parse_unit("US liquid quart".to_string()), Ok(NonMetric::USLiquidQuart));
assert_eq!(parse_unit("US liquid quarts".to_string()), Ok(NonMetric::USLiquidQuart));
assert_eq!(parse_unit("US quart".to_string()), Ok(NonMetric::USLiquidQuart));
assert_eq!(parse_unit("US quarts".to_string()), Ok(NonMetric::USLiquidQuart));
assert_eq!(parse_unit("US qt".to_string()), Ok(NonMetric::USLiquidQuart));
assert_eq!(parse_unit("us liquid quart".to_string()), Ok(NonMetric::USLiquidQuart));
assert_eq!(parse_unit("us liquid quarts".to_string()), Ok(NonMetric::USLiquidQuart));
assert_eq!(parse_unit("us quart".to_string()), Ok(NonMetric::USLiquidQuart));
assert_eq!(parse_unit("us quarts".to_string()), Ok(NonMetric::USLiquidQuart));
assert_eq!(parse_unit("us qt".to_string()), Ok(NonMetric::USLiquidQuart));
test_units(NonMetric::USLiquidQuart, &[
"US liquid quart",
"US liquid quarts",
"US quart",
"US quarts",
"US qt",
"us liquid quart",
"us liquid quarts",
"us quart",
"us quarts",
"us qt",
]);
assert_eq!(parse_unit("US gallon".to_string()), Ok(NonMetric::USGallon));
assert_eq!(parse_unit("US gallons".to_string()), Ok(NonMetric::USGallon));
assert_eq!(parse_unit("US gal".to_string()), Ok(NonMetric::USGallon));
assert_eq!(parse_unit("us gallon".to_string()), Ok(NonMetric::USGallon));
assert_eq!(parse_unit("us gallons".to_string()), Ok(NonMetric::USGallon));
assert_eq!(parse_unit("us gal".to_string()), Ok(NonMetric::USGallon));
test_units(NonMetric::USGallon, &[
"US gallon",
"US gallons",
"US gal",
"us gallon",
"us gallons",
"us gal",
]);
}
fn test_units(unit: NonMetric, spellings: &[&str]) {
for spelling in spellings {
assert_eq!(parse_unit(spelling.to_string()), Ok(unit));
}
}
#[test]
fn ambiguous_units() {
assert_eq!(
parse_unit("fluid ounce".to_string()),
Err(ParseError::AmbiguousUnit("fluid ounce".to_string(), "imperial", "US"))
);
assert_eq!(
parse_unit("fluid ounces".to_string()),
Err(ParseError::AmbiguousUnit("fluid ounces".to_string(), "imperial", "US"))
);
assert_eq!(
parse_unit("fl oz".to_string()),
Err(ParseError::AmbiguousUnit("fl oz".to_string(), "imp", "US"))
);
assert_eq!(
parse_unit("fl. oz.".to_string()),
Err(ParseError::AmbiguousUnit("fl. oz.".to_string(), "imp", "US"))
);
assert_eq!(
parse_unit("oz. fl.".to_string()),
Err(ParseError::AmbiguousUnit("oz. fl.".to_string(), "imp", "US"))
);
test_ambiguous_units(NonMetric::ShortTon, NonMetric::LongTon, &[
"ton",
"tons",
]);
assert_eq!(
parse_unit("pint".to_string()),
Err(ParseError::AmbiguousUnit("pint".to_string(), "imperial", "US"))
);
assert_eq!(
parse_unit("pints".to_string()),
Err(ParseError::AmbiguousUnit("pints".to_string(), "imperial", "US"))
);
assert_eq!(
parse_unit("pt".to_string()),
Err(ParseError::AmbiguousUnit("pt".to_string(), "imp", "US"))
);
assert_eq!(
parse_unit("p".to_string()),
Err(ParseError::AmbiguousUnit("p".to_string(), "imp", "US"))
);
assert_eq!(
parse_unit("quart".to_string()),
Err(ParseError::AmbiguousUnit("quart".to_string(), "imperial", "US"))
);
assert_eq!(
parse_unit("quarts".to_string()),
Err(ParseError::AmbiguousUnit("quarts".to_string(), "imperial", "US"))
);
assert_eq!(
parse_unit("qt".to_string()),
Err(ParseError::AmbiguousUnit("qt".to_string(), "imp", "US"))
);
assert_eq!(
parse_unit("gallon".to_string()),
Err(ParseError::AmbiguousUnit("gallon".to_string(), "imperial", "US"))
);
assert_eq!(
parse_unit("gallons".to_string()),
Err(ParseError::AmbiguousUnit("gallons".to_string(), "imperial", "US"))
);
assert_eq!(
parse_unit("gal".to_string()),
Err(ParseError::AmbiguousUnit("gal".to_string(), "imp", "US"))
);
}
#[test]
fn ambiguous_unit_suggestions() {
let ambiguous_units = [
test_ambiguous_units(NonMetric::ImperialFluidOunce, NonMetric::USFluidOunce, &[
"fluid ounce",
"fluid ounces",
"fl oz",
"fl. oz.",
"oz. fl.",
]);
test_ambiguous_units(NonMetric::ImperialPint, NonMetric::USLiquidPint, &[
"pint",
"pints",
"pt",
"p",
]);
test_ambiguous_units(NonMetric::ImperialQuart, NonMetric::USLiquidQuart, &[
"quart",
"quarts",
"qt",
]);
test_ambiguous_units(NonMetric::ImperialGallon, NonMetric::USGallon, &[
"gallon",
"gallons",
"gal",
];
]);
}
for unit in ambiguous_units {
let parsed = parse_unit(unit.to_string());
if let Err(ParseError::AmbiguousUnit(unit, prefix1, prefix2)) = parsed {
let suggestion1 = format!("{prefix1} {unit}");
let suggestion2 = format!("{prefix2} {unit}");
assert!(parse_unit(suggestion1).is_ok());
assert!(parse_unit(suggestion2).is_ok());
fn test_ambiguous_units(unit1: NonMetric, unit2: NonMetric, spellings: &[&str]) {
for spelling in spellings {
let parsed = parse_unit(spelling.to_string());
if let Err(ParseError::AmbiguousUnit(unit_name, prefix1, prefix2)) = parsed {
assert_eq!(&unit_name, spelling);
let suggestion1 = format!("{prefix1} {unit_name}");
let suggestion2 = format!("{prefix2} {unit_name}");
assert_eq!(parse_unit(suggestion1), Ok(unit1));
assert_eq!(parse_unit(suggestion2), Ok(unit2));
} else {
unreachable!();
panic!("units passed to test_ambiguous_units() must be ambiguous");
}
}
}

2
src/units.rs
View File

@ -19,6 +19,8 @@ pub enum NonMetric {
Ounce,
Pound,
Stone,
ShortTon,
LongTon,
// Temperature
Fahrenheit,
// Area