1304 lines
41 KiB
Rust
1304 lines
41 KiB
Rust
use crate::{Color, Date, Error, GameResult, GameType, Win};
|
|
use chrono::Datelike;
|
|
use nom::{
|
|
branch::alt,
|
|
bytes::complete::{escaped_transform, tag, take_until, take_until1},
|
|
character::complete::{alpha1, digit1, multispace0, multispace1, none_of},
|
|
combinator::{opt, value},
|
|
error::ParseError,
|
|
multi::{many0, many1, separated_list1},
|
|
IResult, Parser,
|
|
};
|
|
use serde::{Deserialize, Serialize};
|
|
use std::{fmt::Write, num::ParseIntError, time::Duration};
|
|
|
|
impl From<ParseSizeError> for Error {
|
|
fn from(_: ParseSizeError) -> Self {
|
|
Self::InvalidBoardSize
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub enum ParseSizeError {
|
|
ParseIntError(ParseIntError),
|
|
InsufficientArguments,
|
|
}
|
|
|
|
impl From<ParseIntError> for ParseSizeError {
|
|
fn from(e: ParseIntError) -> Self {
|
|
Self::ParseIntError(e)
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Copy, Debug, PartialEq, Deserialize, Serialize)]
|
|
pub enum Annotation {
|
|
BadMove,
|
|
DoubtfulMove,
|
|
InterestingMove,
|
|
Tesuji,
|
|
}
|
|
|
|
#[derive(Clone, Copy, Debug, PartialEq, Deserialize, Serialize)]
|
|
pub enum Evaluation {
|
|
Even,
|
|
GoodForBlack,
|
|
GoodForWhite,
|
|
Unclear,
|
|
}
|
|
|
|
impl From<&str> for GameType {
|
|
fn from(s: &str) -> Self {
|
|
match s {
|
|
"1" => Self::Go,
|
|
"2" => Self::Othello,
|
|
"3" => Self::Chess,
|
|
"4" => Self::GomokuRenju,
|
|
"5" => Self::NineMensMorris,
|
|
"6" => Self::Backgammon,
|
|
"7" => Self::ChineseChess,
|
|
"8" => Self::Shogi,
|
|
"9" => Self::LinesOfAction,
|
|
"10" => Self::Ataxx,
|
|
"11" => Self::Hex,
|
|
"12" => Self::Jungle,
|
|
"13" => Self::Neutron,
|
|
"14" => Self::PhilosophersFootball,
|
|
"15" => Self::Quadrature,
|
|
"16" => Self::Trax,
|
|
"17" => Self::Tantrix,
|
|
"18" => Self::Amazons,
|
|
"19" => Self::Octi,
|
|
"20" => Self::Gess,
|
|
"21" => Self::Twixt,
|
|
"22" => Self::Zertz,
|
|
"23" => Self::Plateau,
|
|
"24" => Self::Yinsh,
|
|
"25" => Self::Punct,
|
|
"26" => Self::Gobblet,
|
|
"27" => Self::Hive,
|
|
"28" => Self::Exxit,
|
|
"29" => Self::Hnefatal,
|
|
"30" => Self::Kuba,
|
|
"31" => Self::Tripples,
|
|
"32" => Self::Chase,
|
|
"33" => Self::TumblingDown,
|
|
"34" => Self::Sahara,
|
|
"35" => Self::Byte,
|
|
"36" => Self::Focus,
|
|
"37" => Self::Dvonn,
|
|
"38" => Self::Tamsk,
|
|
"39" => Self::Gipf,
|
|
"40" => Self::Kropki,
|
|
_ => Self::Other(s.to_owned()),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<&GameType> for String {
|
|
fn from(g: &GameType) -> String {
|
|
match g {
|
|
GameType::Go => "1".to_owned(),
|
|
GameType::Othello => "2".to_owned(),
|
|
GameType::Chess => "3".to_owned(),
|
|
GameType::GomokuRenju => "4".to_owned(),
|
|
GameType::NineMensMorris => "5".to_owned(),
|
|
GameType::Backgammon => "6".to_owned(),
|
|
GameType::ChineseChess => "7".to_owned(),
|
|
GameType::Shogi => "8".to_owned(),
|
|
GameType::LinesOfAction => "9".to_owned(),
|
|
GameType::Ataxx => "10".to_owned(),
|
|
GameType::Hex => "11".to_owned(),
|
|
GameType::Jungle => "12".to_owned(),
|
|
GameType::Neutron => "13".to_owned(),
|
|
GameType::PhilosophersFootball => "14".to_owned(),
|
|
GameType::Quadrature => "15".to_owned(),
|
|
GameType::Trax => "16".to_owned(),
|
|
GameType::Tantrix => "17".to_owned(),
|
|
GameType::Amazons => "18".to_owned(),
|
|
GameType::Octi => "19".to_owned(),
|
|
GameType::Gess => "20".to_owned(),
|
|
GameType::Twixt => "21".to_owned(),
|
|
GameType::Zertz => "22".to_owned(),
|
|
GameType::Plateau => "23".to_owned(),
|
|
GameType::Yinsh => "24".to_owned(),
|
|
GameType::Punct => "25".to_owned(),
|
|
GameType::Gobblet => "26".to_owned(),
|
|
GameType::Hive => "27".to_owned(),
|
|
GameType::Exxit => "28".to_owned(),
|
|
GameType::Hnefatal => "29".to_owned(),
|
|
GameType::Kuba => "30".to_owned(),
|
|
GameType::Tripples => "31".to_owned(),
|
|
GameType::Chase => "32".to_owned(),
|
|
GameType::TumblingDown => "33".to_owned(),
|
|
GameType::Sahara => "34".to_owned(),
|
|
GameType::Byte => "35".to_owned(),
|
|
GameType::Focus => "36".to_owned(),
|
|
GameType::Dvonn => "37".to_owned(),
|
|
GameType::Tamsk => "38".to_owned(),
|
|
GameType::Gipf => "39".to_owned(),
|
|
GameType::Kropki => "40".to_owned(),
|
|
GameType::Other(v) => v.clone(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl ToString for GameType {
|
|
fn to_string(&self) -> String {
|
|
String::from(self)
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
|
|
pub struct Size {
|
|
pub width: i32,
|
|
pub height: i32,
|
|
}
|
|
|
|
impl TryFrom<&str> for Size {
|
|
type Error = ParseSizeError;
|
|
fn try_from(s: &str) -> Result<Self, Self::Error> {
|
|
let parts = s
|
|
.split(':')
|
|
.map(|v| v.parse::<i32>())
|
|
.collect::<Result<Vec<i32>, ParseIntError>>()?;
|
|
match parts[..] {
|
|
[width, height, ..] => Ok(Size { width, height }),
|
|
[dim] => Ok(Size {
|
|
width: dim,
|
|
height: dim,
|
|
}),
|
|
[] => Err(ParseSizeError::InsufficientArguments),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
|
|
pub struct Position(String);
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
|
|
pub struct PositionList(pub Vec<String>);
|
|
|
|
impl PositionList {
|
|
pub fn compressed_list(&self) -> String {
|
|
self.0.to_vec().join(":")
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub struct Tree {
|
|
pub root: Node,
|
|
}
|
|
|
|
impl ToString for Tree {
|
|
fn to_string(&self) -> String {
|
|
format!("({})", self.root.to_string())
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub struct Node {
|
|
pub properties: Vec<Property>,
|
|
pub next: Vec<Node>,
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
|
|
pub enum SetupInstr {
|
|
Piece((Color, String)),
|
|
Clear(String),
|
|
}
|
|
|
|
impl Node {
|
|
pub fn mv(&self) -> Option<(Color, Move)> {
|
|
self.find_by(|prop| match prop {
|
|
Property::Move(val) => Some(val.clone()),
|
|
_ => None,
|
|
})
|
|
}
|
|
|
|
pub fn setup(&self) -> Option<Vec<SetupInstr>> {
|
|
let mut setup = Vec::new();
|
|
for prop in self.properties.iter() {
|
|
match prop {
|
|
Property::SetupBlackStones(positions) => {
|
|
setup.append(
|
|
&mut positions
|
|
.0
|
|
.iter()
|
|
.map(|pos| SetupInstr::Piece((Color::Black, pos.clone())))
|
|
.collect::<Vec<SetupInstr>>(),
|
|
);
|
|
}
|
|
Property::SetupWhiteStones(positions) => {
|
|
setup.append(
|
|
&mut positions
|
|
.0
|
|
.iter()
|
|
.map(|pos| SetupInstr::Piece((Color::White, pos.clone())))
|
|
.collect::<Vec<SetupInstr>>(),
|
|
);
|
|
}
|
|
Property::ClearStones(positions) => {
|
|
setup.append(
|
|
&mut positions
|
|
.0
|
|
.iter()
|
|
.map(|pos| SetupInstr::Clear(pos.clone()))
|
|
.collect::<Vec<SetupInstr>>(),
|
|
);
|
|
}
|
|
_ => return None,
|
|
}
|
|
}
|
|
if !setup.is_empty() {
|
|
Some(setup)
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
|
|
fn find_by<F, R>(&self, f: F) -> Option<R>
|
|
where
|
|
F: FnMut(&Property) -> Option<R>,
|
|
{
|
|
self.properties.iter().filter_map(f).next()
|
|
}
|
|
}
|
|
|
|
impl ToString for Node {
|
|
fn to_string(&self) -> String {
|
|
let props = self
|
|
.properties
|
|
.iter()
|
|
.map(|prop| prop.to_string())
|
|
.collect::<String>();
|
|
|
|
let next = if self.next.len() == 1 {
|
|
self.next
|
|
.iter()
|
|
.map(|node| node.to_string())
|
|
.collect::<Vec<String>>()
|
|
.join("")
|
|
} else {
|
|
self.next
|
|
.iter()
|
|
.map(|node| format!("({})", node.to_string()))
|
|
.collect::<Vec<String>>()
|
|
.join("")
|
|
};
|
|
format!(";{}{}", props, next)
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
|
|
pub enum Move {
|
|
Move(String),
|
|
Pass,
|
|
}
|
|
|
|
impl Move {
|
|
pub fn coordinate(&self) -> Option<(u8, u8)> {
|
|
match self {
|
|
Move::Pass => None,
|
|
Move::Move(s) => {
|
|
if s.len() == 2 {
|
|
let mut parts = s.chars();
|
|
let row_char = parts.next().unwrap();
|
|
let row = row_char as u8 - b'a';
|
|
let column_char = parts.next().unwrap();
|
|
let column = column_char as u8 - b'a';
|
|
Some((row, column))
|
|
} else {
|
|
unimplemented!("moves must contain exactly two characters");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// KO
|
|
// MN
|
|
// N
|
|
// AR
|
|
// CR
|
|
// DD
|
|
// LB
|
|
// LN
|
|
// MA
|
|
// SL
|
|
// SQ
|
|
// TR
|
|
// OB
|
|
// OW
|
|
// FG
|
|
// PM
|
|
// VW
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub enum Property {
|
|
// B, W
|
|
Move((Color, Move)),
|
|
|
|
// C
|
|
Comment(String),
|
|
|
|
// BM, DO, IT, TE
|
|
Annotation(Annotation),
|
|
|
|
// AP
|
|
Application(String),
|
|
|
|
// CA
|
|
Charset(String),
|
|
|
|
// FF
|
|
FileFormat(i32),
|
|
|
|
// GM
|
|
GameType(GameType),
|
|
|
|
// ST
|
|
VariationDisplay,
|
|
|
|
// SZ
|
|
BoardSize(Size),
|
|
|
|
// AB
|
|
SetupBlackStones(PositionList),
|
|
|
|
// AE
|
|
ClearStones(PositionList),
|
|
|
|
// AW
|
|
SetupWhiteStones(PositionList),
|
|
|
|
// PL
|
|
NextPlayer(Color),
|
|
|
|
// DM, GB, GW, UC
|
|
Evaluation(Evaluation),
|
|
|
|
// HO
|
|
Hotspot,
|
|
|
|
// V
|
|
Value(f32),
|
|
|
|
// AN
|
|
Annotator(String),
|
|
|
|
// BR
|
|
BlackRank(String),
|
|
|
|
// BT
|
|
BlackTeam(String),
|
|
|
|
// CP
|
|
Copyright(String),
|
|
|
|
// DT
|
|
EventDates(Vec<Date>),
|
|
|
|
// EV
|
|
EventName(String),
|
|
|
|
// GN
|
|
GameName(String),
|
|
|
|
// GC
|
|
ExtraGameInformation(String),
|
|
|
|
// ON
|
|
GameOpening(String),
|
|
|
|
// OT
|
|
Overtime(String),
|
|
|
|
// PB
|
|
BlackPlayer(String),
|
|
|
|
// PC
|
|
GameLocation(String),
|
|
|
|
// PW
|
|
WhitePlayer(String),
|
|
|
|
// RE
|
|
Result(GameResult),
|
|
|
|
// RO
|
|
Round(String),
|
|
|
|
// RU
|
|
Ruleset(String),
|
|
|
|
// SO
|
|
Source(String),
|
|
|
|
// TM
|
|
TimeLimit(Duration),
|
|
|
|
// US
|
|
User(String),
|
|
|
|
// WR
|
|
WhiteRank(String),
|
|
|
|
// WT
|
|
WhiteTeam(String),
|
|
|
|
// BL, WL
|
|
TimeLeft((Color, Duration)),
|
|
|
|
// TW, TB
|
|
Territory(Color, Vec<Position>),
|
|
|
|
Unknown(UnknownProperty),
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub struct UnknownProperty {
|
|
pub ident: String,
|
|
pub value: String,
|
|
}
|
|
|
|
impl ToString for Property {
|
|
fn to_string(&self) -> String {
|
|
match self {
|
|
Property::Move((color, Move::Move(mv))) => {
|
|
format!("{}[{}]", color.abbreviation(), mv)
|
|
}
|
|
Property::Move((color, Move::Pass)) => {
|
|
format!("{}[]", color.abbreviation())
|
|
}
|
|
Property::TimeLeft((color, time)) => {
|
|
format!("{}[{}]", color.abbreviation(), time.as_secs())
|
|
}
|
|
Property::Comment(value) => format!("C[{}]", value),
|
|
Property::Annotation(Annotation::BadMove) => "BM[]".to_owned(),
|
|
Property::Annotation(Annotation::DoubtfulMove) => "DO[]".to_owned(),
|
|
Property::Annotation(Annotation::InterestingMove) => "IT[]".to_owned(),
|
|
Property::Annotation(Annotation::Tesuji) => "TE[]".to_owned(),
|
|
Property::Application(app) => format!("AP[{}]", app),
|
|
Property::Charset(set) => format!("CA[{}]", set),
|
|
Property::FileFormat(ff) => format!("FF[{}]", ff),
|
|
Property::GameType(gt) => format!("GM[{}]", gt.to_string()),
|
|
Property::VariationDisplay => unimplemented!(),
|
|
Property::BoardSize(Size { width, height }) => {
|
|
if width == height {
|
|
format!("SZ[{}]", width)
|
|
} else {
|
|
format!("SZ[{}:{}]", width, height)
|
|
}
|
|
}
|
|
Property::SetupBlackStones(positions) => {
|
|
format!("AB[{}]", positions.compressed_list(),)
|
|
}
|
|
Property::ClearStones(positions) => {
|
|
format!("AE[{}]", positions.compressed_list(),)
|
|
}
|
|
Property::SetupWhiteStones(positions) => {
|
|
format!("AW[{}]", positions.compressed_list(),)
|
|
}
|
|
Property::NextPlayer(color) => format!("PL[{}]", color.abbreviation()),
|
|
Property::Evaluation(Evaluation::Even) => "DM[]".to_owned(),
|
|
Property::Evaluation(Evaluation::GoodForBlack) => "GB[]".to_owned(),
|
|
Property::Evaluation(Evaluation::GoodForWhite) => "GW[]".to_owned(),
|
|
Property::Evaluation(Evaluation::Unclear) => "UC[]".to_owned(),
|
|
Property::Hotspot => "HO[]".to_owned(),
|
|
Property::Value(value) => format!("V[{}]", value),
|
|
Property::Annotator(value) => format!("AN[{}]", value),
|
|
Property::BlackRank(value) => format!("BR[{}]", value),
|
|
Property::BlackTeam(value) => format!("BT[{}]", value),
|
|
Property::Copyright(value) => format!("CP[{}]", value),
|
|
Property::EventDates(_) => unimplemented!(),
|
|
Property::EventName(value) => format!("EV[{}]", value),
|
|
Property::GameName(value) => format!("GN[{}]", value),
|
|
Property::ExtraGameInformation(value) => format!("GC[{}]", value),
|
|
Property::GameOpening(value) => format!("ON[{}]", value),
|
|
Property::Overtime(value) => format!("OT[{}]", value),
|
|
Property::BlackPlayer(value) => format!("PB[{}]", value),
|
|
Property::GameLocation(value) => format!("PC[{}]", value),
|
|
Property::WhitePlayer(value) => format!("PW[{}]", value),
|
|
Property::Result(_) => unimplemented!(),
|
|
Property::Round(value) => format!("RO[{}]", value),
|
|
Property::Ruleset(value) => format!("RU[{}]", value),
|
|
Property::Source(value) => format!("SO[{}]", value),
|
|
Property::TimeLimit(value) => format!("TM[{}]", value.as_secs()),
|
|
Property::User(value) => format!("US[{}]", value),
|
|
Property::WhiteRank(value) => format!("WR[{}]", value),
|
|
Property::WhiteTeam(value) => format!("WT[{}]", value),
|
|
Property::Territory(Color::White, positions) => {
|
|
positions
|
|
.iter()
|
|
.fold("TW".to_owned(), |mut output, Position(p)| {
|
|
let _ = write!(output, "{}", p);
|
|
output
|
|
})
|
|
}
|
|
Property::Territory(Color::Black, positions) => {
|
|
positions
|
|
.iter()
|
|
.fold("TB".to_owned(), |mut output, Position(p)| {
|
|
let _ = write!(output, "{}", p);
|
|
output
|
|
})
|
|
}
|
|
Property::Unknown(UnknownProperty { ident, value }) => {
|
|
format!("{}[{}]", ident, value)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn parse_collection<'a, E: nom::error::ParseError<&'a str>>(
|
|
input: &'a str,
|
|
) -> IResult<&'a str, Vec<Tree>, E> {
|
|
let (input, roots) = separated_list1(multispace1, parse_tree)(input)?;
|
|
let trees = roots
|
|
.into_iter()
|
|
.map(|root| Tree { root })
|
|
.collect::<Vec<Tree>>();
|
|
|
|
Ok((input, trees))
|
|
}
|
|
|
|
// note: must preserve unknown properties
|
|
// note: must fix or preserve illegally formatted game-info properties
|
|
// note: must correct or delete illegally foramtted properties, but display a warning
|
|
fn parse_tree<'a, E: nom::error::ParseError<&'a str>>(input: &'a str) -> IResult<&'a str, Node, E> {
|
|
let (input, _) = multispace0(input)?;
|
|
let (input, _) = tag("(")(input)?;
|
|
let (input, node) = parse_node(input)?;
|
|
let (input, _) = multispace0(input)?;
|
|
let (input, _) = tag(")")(input)?;
|
|
|
|
Ok((input, node))
|
|
}
|
|
|
|
fn parse_node<'a, E: nom::error::ParseError<&'a str>>(input: &'a str) -> IResult<&'a str, Node, E> {
|
|
let (input, _) = multispace0(input)?;
|
|
let (input, _) = opt(tag(";"))(input)?;
|
|
let (input, properties) = many1(parse_property)(input)?;
|
|
|
|
let (input, next) = opt(parse_node)(input)?;
|
|
let (input, mut next_seq) = many0(parse_tree)(input)?;
|
|
|
|
let mut next = next.map(|n| vec![n]).unwrap_or(vec![]);
|
|
next.append(&mut next_seq);
|
|
|
|
Ok((input, Node { properties, next }))
|
|
}
|
|
|
|
fn parse_property<'a, E: nom::error::ParseError<&'a str>>(
|
|
input: &'a str,
|
|
) -> IResult<&'a str, Property, E> {
|
|
let (input, _) = multispace0(input)?;
|
|
let (input, ident) = alpha1(input)?;
|
|
|
|
let (input, prop) = match ident {
|
|
"W" => parse_propval(parse_move(Color::White))(input)?,
|
|
"B" => parse_propval(parse_move(Color::Black))(input)?,
|
|
"C" => parse_propval(parse_comment())(input)?,
|
|
"WL" => parse_propval(parse_time_left(Color::White))(input)?,
|
|
"BL" => parse_propval(parse_time_left(Color::Black))(input)?,
|
|
"BM" => discard_propval()
|
|
.map(|_| Property::Annotation(Annotation::BadMove))
|
|
.parse(input)?,
|
|
"DO" => discard_propval()
|
|
.map(|_| Property::Annotation(Annotation::DoubtfulMove))
|
|
.parse(input)?,
|
|
"IT" => discard_propval()
|
|
.map(|_| Property::Annotation(Annotation::InterestingMove))
|
|
.parse(input)?,
|
|
"TE" => discard_propval()
|
|
.map(|_| Property::Annotation(Annotation::Tesuji))
|
|
.parse(input)?,
|
|
"AP" => parse_propval(parse_simple_text().map(Property::Application))(input)?,
|
|
"CA" => parse_propval(parse_simple_text().map(Property::Charset))(input)?,
|
|
"FF" => parse_propval(parse_number().map(Property::FileFormat))(input)?,
|
|
"GM" => parse_propval(parse_gametype().map(Property::GameType))(input)?,
|
|
"ST" => discard_propval()
|
|
.map(|_| Property::VariationDisplay)
|
|
.parse(input)?,
|
|
"SZ" => parse_propval(parse_size().map(Property::BoardSize))(input)?,
|
|
"DM" => discard_propval()
|
|
.map(|_| Property::Evaluation(Evaluation::Even))
|
|
.parse(input)?,
|
|
"GB" => discard_propval()
|
|
.map(|_| Property::Evaluation(Evaluation::GoodForBlack))
|
|
.parse(input)?,
|
|
"GW" => discard_propval()
|
|
.map(|_| Property::Evaluation(Evaluation::GoodForWhite))
|
|
.parse(input)?,
|
|
"UC" => discard_propval()
|
|
.map(|_| Property::Evaluation(Evaluation::Unclear))
|
|
.parse(input)?,
|
|
"V" => unimplemented!(),
|
|
"AN" => parse_propval(parse_simple_text().map(Property::Annotator))(input)?,
|
|
"BR" => parse_propval(parse_simple_text().map(Property::BlackRank))(input)?,
|
|
"BT" => parse_propval(parse_simple_text().map(Property::BlackTeam))(input)?,
|
|
"CP" => parse_propval(parse_simple_text().map(Property::Copyright))(input)?,
|
|
"DT" => parse_propval(parse_date_field().map(Property::EventDates))(input)?,
|
|
"EV" => parse_propval(parse_simple_text().map(Property::EventName))(input)?,
|
|
"GN" => parse_propval(parse_simple_text().map(Property::GameName))(input)?,
|
|
"GC" => parse_propval(parse_simple_text().map(Property::ExtraGameInformation))(input)?,
|
|
"ON" => parse_propval(parse_simple_text().map(Property::GameOpening))(input)?,
|
|
"OT" => parse_propval(parse_simple_text().map(Property::Overtime))(input)?,
|
|
"PB" => parse_propval(parse_simple_text().map(Property::BlackPlayer))(input)?,
|
|
"PC" => parse_propval(parse_simple_text().map(Property::GameLocation))(input)?,
|
|
"PW" => parse_propval(parse_simple_text().map(Property::WhitePlayer))(input)?,
|
|
"RE" => parse_propval(parse_game_result().map(Property::Result))(input)?,
|
|
"RO" => parse_propval(parse_simple_text().map(Property::Round))(input)?,
|
|
"RU" => parse_propval(parse_simple_text().map(Property::Ruleset))(input)?,
|
|
"SO" => parse_propval(parse_simple_text().map(Property::Source))(input)?,
|
|
"TM" => parse_propval(
|
|
parse_real().map(|seconds| Property::TimeLimit(Duration::from_secs(seconds as u64))),
|
|
)(input)?,
|
|
"US" => parse_propval(parse_simple_text().map(Property::User))(input)?,
|
|
"WR" => parse_propval(parse_simple_text().map(Property::WhiteRank))(input)?,
|
|
"WT" => parse_propval(parse_simple_text().map(Property::WhiteTeam))(input)?,
|
|
"TW" => parse_territory()
|
|
.map(|p| Property::Territory(Color::White, p))
|
|
.parse(input)?,
|
|
"TB" => parse_territory()
|
|
.map(|p| Property::Territory(Color::Black, p))
|
|
.parse(input)?,
|
|
_ => parse_propval(parse_simple_text().map(|value| {
|
|
Property::Unknown(UnknownProperty {
|
|
ident: ident.to_owned(),
|
|
value,
|
|
})
|
|
}))(input)?,
|
|
};
|
|
|
|
Ok((input, prop))
|
|
}
|
|
|
|
fn parse_comment<'a, E: nom::error::ParseError<&'a str>>() -> impl Parser<&'a str, Property, E> {
|
|
parse_text().map(Property::Comment)
|
|
}
|
|
|
|
fn parse_move<'a, E: nom::error::ParseError<&'a str>>(
|
|
color: Color,
|
|
) -> impl Parser<&'a str, Property, E> {
|
|
{
|
|
let color = color.clone();
|
|
move |input: &'a str| {
|
|
take_until("]")
|
|
.map(|text: &'a str| {
|
|
if text.is_empty() {
|
|
Property::Move((color.clone(), Move::Pass))
|
|
} else {
|
|
Property::Move((color.clone(), Move::Move(text.to_owned())))
|
|
}
|
|
})
|
|
.parse(input)
|
|
}
|
|
}
|
|
}
|
|
|
|
fn parse_gametype<'a, E: nom::error::ParseError<&'a str>>() -> impl Parser<&'a str, GameType, E> {
|
|
|input: &'a str| take_until1("]").map(GameType::from).parse(input)
|
|
}
|
|
|
|
fn parse_time_left<'a, E: ParseError<&'a str>>(
|
|
color: Color,
|
|
) -> impl FnMut(&'a str) -> IResult<&'a str, Property, E> {
|
|
{
|
|
let color = color.clone();
|
|
move |input: &'a str| {
|
|
let (input, value) = parse_real().parse(input)?;
|
|
Ok((
|
|
input,
|
|
Property::TimeLeft((color.clone(), Duration::from_secs(value as u64))),
|
|
))
|
|
}
|
|
}
|
|
}
|
|
|
|
fn parse_size<'a, E: nom::error::ParseError<&'a str>>() -> impl Parser<&'a str, Size, E> {
|
|
|input: &'a str| {
|
|
let (input, dimensions) = separated_list1(tag(":"), digit1)(input)?;
|
|
let (width, height) = match dimensions.as_slice() {
|
|
[width] => (width.parse::<i32>().unwrap(), width.parse::<i32>().unwrap()),
|
|
[width, height] => (
|
|
width.parse::<i32>().unwrap(),
|
|
height.parse::<i32>().unwrap(),
|
|
),
|
|
_ => (19, 19),
|
|
};
|
|
Ok((input, Size { width, height }))
|
|
}
|
|
}
|
|
|
|
fn parse_game_result<'a, E: nom::error::ParseError<&'a str>>() -> impl Parser<&'a str, GameResult, E>
|
|
{
|
|
alt((parse_draw_result(), parse_void_result(), parse_win_result()))
|
|
}
|
|
|
|
fn parse_territory<'a, E: nom::error::ParseError<&'a str>>(
|
|
) -> impl Parser<&'a str, Vec<Position>, E> {
|
|
many1(|input| {
|
|
let (input, _) = tag("[")(input)?;
|
|
let (input, position) = parse_simple_text().map(Position).parse(input)?;
|
|
let (input, _) = tag("]")(input)?;
|
|
Ok((input, position))
|
|
})
|
|
}
|
|
|
|
fn parse_propval<'a, E: nom::error::ParseError<&'a str>>(
|
|
mut parser: impl Parser<&'a str, Property, E>,
|
|
) -> impl FnMut(&'a str) -> IResult<&'a str, Property, E> {
|
|
move |input| {
|
|
let (input, _) = multispace0(input)?;
|
|
let (input, _) = tag("[")(input)?;
|
|
let (input, value) = parser.parse(input)?;
|
|
let (input, _) = tag("]")(input)?;
|
|
|
|
Ok((input, value))
|
|
}
|
|
}
|
|
|
|
fn discard_propval<'a, E: nom::error::ParseError<&'a str>>() -> impl Parser<&'a str, (), E> {
|
|
|input| {
|
|
let (input, _) = multispace0(input)?;
|
|
let (input, _) = tag("[")(input)?;
|
|
let (input, _) = parse_text().parse(input)?;
|
|
let (input, _) = tag("]")(input)?;
|
|
Ok((input, ()))
|
|
}
|
|
}
|
|
|
|
fn parse_number<'a, E: ParseError<&'a str>>() -> impl Parser<&'a str, i32, E> {
|
|
|input| {
|
|
let (input, sign) = opt(alt((tag("+"), tag("-"))))(input)?;
|
|
let (input, value) = digit1(input)?;
|
|
let mult = if sign == Some("-") { -1 } else { 1 };
|
|
Ok((input, value.parse::<i32>().unwrap() * mult))
|
|
}
|
|
}
|
|
|
|
fn parse_real<'a, E: ParseError<&'a str>>() -> impl Parser<&'a str, f32, E> {
|
|
|input| {
|
|
let (input, sign) = opt(alt((tag("+"), tag("-"))))(input)?;
|
|
let (input, whole_value) = digit1(input)?;
|
|
let (input, fractional_value) = opt(|input| {
|
|
let (input, _) = tag(".")(input)?;
|
|
let (input, fractional_value) = digit1(input)?;
|
|
Ok((input, format!(".{}", fractional_value)))
|
|
})(input)?;
|
|
let value = format!(
|
|
"{}{}{}",
|
|
sign.unwrap_or("+"),
|
|
whole_value,
|
|
fractional_value.unwrap_or("".to_owned())
|
|
)
|
|
.parse::<f32>()
|
|
.unwrap();
|
|
Ok((input, value))
|
|
}
|
|
}
|
|
|
|
fn parse_simple_text<'a, E: ParseError<&'a str>>() -> impl Parser<&'a str, String, E> {
|
|
|input| {
|
|
let (input, value) = opt(escaped_transform(
|
|
none_of("\\]"),
|
|
'\\',
|
|
alt((
|
|
value("]", tag("]")),
|
|
value("\\", tag("\\")),
|
|
value("", tag("\n")),
|
|
)),
|
|
))(input)?;
|
|
Ok((input, value.unwrap_or("".to_owned())))
|
|
}
|
|
}
|
|
|
|
fn parse_text<'a, E: ParseError<&'a str>>() -> impl Parser<&'a str, String, E> {
|
|
|input| {
|
|
let (input, value) = opt(escaped_transform(
|
|
none_of("\\]"),
|
|
'\\',
|
|
alt((
|
|
value("]", tag("]")),
|
|
value("\\", tag("\\")),
|
|
value("", tag("\n")),
|
|
)),
|
|
))(input)?;
|
|
Ok((input, value.unwrap_or("".to_owned())))
|
|
}
|
|
}
|
|
|
|
enum DateSegment {
|
|
One(i32),
|
|
Two(i32, i32),
|
|
Three(i32, i32, i32),
|
|
}
|
|
|
|
fn parse_date_field<'a, E: ParseError<&'a str>>() -> impl Parser<&'a str, Vec<Date>, E> {
|
|
|input| {
|
|
let (input, first_date) = parse_date().parse(input)?;
|
|
let (input, mut more_dates) = many0(parse_date_segment())(input)?;
|
|
|
|
let mut date_segments = vec![first_date];
|
|
date_segments.append(&mut more_dates);
|
|
|
|
let mut dates = vec![];
|
|
let mut most_recent = None;
|
|
|
|
for date_segment in date_segments {
|
|
let new_date = match date_segment {
|
|
DateSegment::One(v) => match most_recent {
|
|
Some(Date::Year(_)) => Date::Year(v),
|
|
Some(Date::YearMonth(y, _)) => Date::YearMonth(y, v as u32),
|
|
Some(Date::Date(d)) => Date::Date(d.clone().with_day(v as u32).unwrap()),
|
|
None => Date::Year(v),
|
|
},
|
|
DateSegment::Two(y, m) => Date::YearMonth(y, m as u32),
|
|
DateSegment::Three(y, m, d) => {
|
|
Date::Date(chrono::NaiveDate::from_ymd_opt(y, m as u32, d as u32).unwrap())
|
|
}
|
|
};
|
|
dates.push(new_date.clone());
|
|
most_recent = Some(new_date);
|
|
}
|
|
|
|
Ok((input, dates))
|
|
}
|
|
}
|
|
|
|
fn parse_date_segment<'a, E: ParseError<&'a str>>() -> impl Parser<&'a str, DateSegment, E> {
|
|
|input| {
|
|
let (input, _) = tag(",")(input)?;
|
|
let (input, element) = parse_date().parse(input)?;
|
|
|
|
Ok((input, element))
|
|
}
|
|
}
|
|
|
|
fn parse_date<'a, E: ParseError<&'a str>>() -> impl Parser<&'a str, DateSegment, E> {
|
|
alt((parse_three(), parse_two(), parse_one()))
|
|
}
|
|
|
|
fn parse_one<'a, E: ParseError<&'a str>>() -> impl Parser<&'a str, DateSegment, E> {
|
|
parse_number().map(DateSegment::One)
|
|
}
|
|
|
|
fn parse_two<'a, E: ParseError<&'a str>>() -> impl Parser<&'a str, DateSegment, E> {
|
|
|input| {
|
|
let (input, year) = parse_number().parse(input)?;
|
|
let (input, _) = tag("-")(input)?;
|
|
let (input, month) = parse_number().parse(input)?;
|
|
Ok((input, DateSegment::Two(year, month)))
|
|
}
|
|
}
|
|
|
|
fn parse_three<'a, E: ParseError<&'a str>>() -> impl Parser<&'a str, DateSegment, E> {
|
|
|input| {
|
|
let (input, year) = parse_number().parse(input)?;
|
|
let (input, _) = tag("-")(input)?;
|
|
let (input, month) = parse_number().parse(input)?;
|
|
let (input, _) = tag("-")(input)?;
|
|
let (input, day) = parse_number().parse(input)?;
|
|
Ok((input, DateSegment::Three(year, month, day)))
|
|
}
|
|
}
|
|
|
|
fn parse_draw_result<'a, E: nom::error::ParseError<&'a str>>() -> impl Parser<&'a str, GameResult, E>
|
|
{
|
|
tag("0").map(|_| GameResult::Draw)
|
|
}
|
|
|
|
fn parse_void_result<'a, E: nom::error::ParseError<&'a str>>() -> impl Parser<&'a str, GameResult, E>
|
|
{
|
|
tag("Void").map(|_| GameResult::Void)
|
|
}
|
|
|
|
fn parse_win_result<'a, E: nom::error::ParseError<&'a str>>() -> impl Parser<&'a str, GameResult, E>
|
|
{
|
|
|input: &'a str| {
|
|
let (input, color) = alt((
|
|
tag("B").map(|_| Color::Black),
|
|
tag("b").map(|_| Color::Black),
|
|
tag("W").map(|_| Color::White),
|
|
tag("w").map(|_| Color::White),
|
|
))(input)?;
|
|
let (input, _) = tag("+")(input)?;
|
|
let (input, score) = parse_win_score().parse(input)?;
|
|
|
|
Ok((
|
|
input,
|
|
match color {
|
|
Color::Black => GameResult::Black(score),
|
|
Color::White => GameResult::White(score),
|
|
},
|
|
))
|
|
}
|
|
}
|
|
|
|
enum WinType {
|
|
St(String),
|
|
Num(f32),
|
|
}
|
|
|
|
fn parse_win_score<'a, E: nom::error::ParseError<&'a str>>() -> impl Parser<&'a str, Win, E> {
|
|
|input: &'a str| {
|
|
let (input, win) = alt((
|
|
parse_real().map(WinType::Num),
|
|
parse_simple_text().map(WinType::St),
|
|
))(input)?;
|
|
let w = match win {
|
|
WinType::St(s) => match s.to_ascii_lowercase().as_str() {
|
|
"r" | "resign" => Win::Resignation,
|
|
"t" | "time" => Win::Time,
|
|
"f" | "forfeit" => Win::Forfeit,
|
|
_ => Win::Unknown,
|
|
},
|
|
WinType::Num(n) => Win::Score(n),
|
|
};
|
|
Ok((input, w))
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use super::*;
|
|
|
|
const EXAMPLE: &str = "(;FF[4]C[root](;C[a];C[b](;C[c])
|
|
(;C[d];C[e]))
|
|
(;C[f](;C[g];C[h];C[i])
|
|
(;C[j])))";
|
|
|
|
#[test]
|
|
fn it_can_parse_properties() {
|
|
let (_, prop) = parse_property::<nom::error::VerboseError<&str>>("C[a]").unwrap();
|
|
assert_eq!(prop, Property::Comment("a".to_owned()));
|
|
}
|
|
|
|
#[test]
|
|
fn it_can_parse_a_standalone_node() {
|
|
let (_, node) = parse_node::<nom::error::VerboseError<&str>>(";B[ab]").unwrap();
|
|
|
|
assert_eq!(
|
|
node,
|
|
Node {
|
|
properties: vec![Property::Move((Color::Black, Move::Move("ab".to_owned())))],
|
|
next: vec![]
|
|
}
|
|
);
|
|
|
|
let (_, node) =
|
|
parse_node::<nom::error::VerboseError<&str>>(";B[ab];W[dp];B[pq]C[some comments]")
|
|
.unwrap();
|
|
|
|
assert_eq!(
|
|
node,
|
|
Node {
|
|
properties: vec![Property::Move((Color::Black, Move::Move("ab".to_owned())))],
|
|
next: vec![Node {
|
|
properties: vec![Property::Move((Color::White, Move::Move("dp".to_owned())))],
|
|
next: vec![Node {
|
|
properties: vec![
|
|
Property::Move((Color::Black, Move::Move("pq".to_owned()))),
|
|
Property::Comment("some comments".to_owned())
|
|
],
|
|
next: vec![],
|
|
}]
|
|
}]
|
|
}
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn it_can_parse_a_simple_sequence() {
|
|
let (_, sequence) =
|
|
parse_tree::<nom::error::VerboseError<&str>>("(;B[ab];W[dp];B[pq]C[some comments])")
|
|
.unwrap();
|
|
|
|
assert_eq!(
|
|
sequence,
|
|
Node {
|
|
properties: vec![Property::Move((Color::Black, Move::Move("ab".to_owned())))],
|
|
next: vec![Node {
|
|
properties: vec![Property::Move((Color::White, Move::Move("dp".to_owned())))],
|
|
next: vec![Node {
|
|
properties: vec![
|
|
Property::Move((Color::Black, Move::Move("pq".to_owned()))),
|
|
Property::Comment("some comments".to_owned())
|
|
],
|
|
next: vec![],
|
|
}]
|
|
}],
|
|
},
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn it_can_parse_a_branching_sequence() {
|
|
let text = "(;C[a];C[b](;C[c])(;C[d];C[e]))";
|
|
let (_, tree) = parse_tree::<nom::error::VerboseError<&str>>(text).unwrap();
|
|
|
|
let expected = Node {
|
|
properties: vec![Property::Comment("a".to_owned())],
|
|
next: vec![Node {
|
|
properties: vec![Property::Comment("b".to_owned())],
|
|
next: vec![
|
|
Node {
|
|
properties: vec![Property::Comment("c".to_owned())],
|
|
next: vec![],
|
|
},
|
|
Node {
|
|
properties: vec![Property::Comment("d".to_owned())],
|
|
next: vec![Node {
|
|
properties: vec![Property::Comment("e".to_owned())],
|
|
next: vec![],
|
|
}],
|
|
},
|
|
],
|
|
}],
|
|
};
|
|
|
|
assert_eq!(tree, expected);
|
|
}
|
|
|
|
#[test]
|
|
fn it_can_parse_example_1() {
|
|
let (_, tree) = parse_tree::<nom::error::VerboseError<&str>>(EXAMPLE).unwrap();
|
|
|
|
let j = Node {
|
|
properties: vec![Property::Comment("j".to_owned())],
|
|
next: vec![],
|
|
};
|
|
let i = Node {
|
|
properties: vec![Property::Comment("i".to_owned())],
|
|
next: vec![],
|
|
};
|
|
let h = Node {
|
|
properties: vec![Property::Comment("h".to_owned())],
|
|
next: vec![i],
|
|
};
|
|
let g = Node {
|
|
properties: vec![Property::Comment("g".to_owned())],
|
|
next: vec![h],
|
|
};
|
|
let f = Node {
|
|
properties: vec![Property::Comment("f".to_owned())],
|
|
next: vec![g, j],
|
|
};
|
|
let e = Node {
|
|
properties: vec![Property::Comment("e".to_owned())],
|
|
next: vec![],
|
|
};
|
|
let d = Node {
|
|
properties: vec![Property::Comment("d".to_owned())],
|
|
next: vec![e],
|
|
};
|
|
let c = Node {
|
|
properties: vec![Property::Comment("c".to_owned())],
|
|
next: vec![],
|
|
};
|
|
let b = Node {
|
|
properties: vec![Property::Comment("b".to_owned())],
|
|
next: vec![c, d],
|
|
};
|
|
let a = Node {
|
|
properties: vec![Property::Comment("a".to_owned())],
|
|
next: vec![b],
|
|
};
|
|
let expected = Node {
|
|
properties: vec![
|
|
Property::FileFormat(4),
|
|
Property::Comment("root".to_owned()),
|
|
],
|
|
next: vec![a, f],
|
|
};
|
|
|
|
assert_eq!(tree, expected);
|
|
}
|
|
|
|
#[test]
|
|
fn it_can_regenerate_the_tree() {
|
|
let (_, tree1) = parse_tree::<nom::error::VerboseError<&str>>(EXAMPLE).unwrap();
|
|
let tree1 = Tree { root: tree1 };
|
|
assert_eq!(
|
|
tree1.to_string(),
|
|
"(;FF[4]C[root](;C[a];C[b](;C[c])(;C[d];C[e]))(;C[f](;C[g];C[h];C[i])(;C[j])))"
|
|
);
|
|
let (_, tree2) = parse_tree::<nom::error::VerboseError<&str>>(&tree1.to_string()).unwrap();
|
|
assert_eq!(tree1, Tree { root: tree2 });
|
|
}
|
|
|
|
#[test]
|
|
fn it_parses_propvals() {
|
|
let (_, propval) = parse_propval::<nom::error::VerboseError<&str>>(parse_comment())
|
|
.parse("[]")
|
|
.unwrap();
|
|
assert_eq!(propval, Property::Comment("".to_owned()));
|
|
|
|
let (_, propval) = parse_propval::<nom::error::VerboseError<&str>>(parse_comment())
|
|
.parse("[normal propval]")
|
|
.unwrap();
|
|
assert_eq!(propval, Property::Comment("normal propval".to_owned()));
|
|
|
|
let (_, propval) = parse_propval::<nom::error::VerboseError<&str>>(parse_comment())
|
|
.parse(r"[need an [escape\] in the propval]")
|
|
.unwrap();
|
|
assert_eq!(
|
|
propval,
|
|
Property::Comment("need an [escape] in the propval".to_owned())
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn it_parses_propvals_with_hard_linebreaks() {
|
|
let (_, propval) = parse_text::<nom::error::VerboseError<&str>>()
|
|
.parse(
|
|
"There are hard linebreaks & soft linebreaks.
|
|
Soft linebreaks...",
|
|
)
|
|
.unwrap();
|
|
assert_eq!(
|
|
propval,
|
|
"There are hard linebreaks & soft linebreaks.
|
|
Soft linebreaks..."
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn it_parses_propvals_with_escaped_closing_brackets() {
|
|
let (_, propval) = parse_text::<nom::error::VerboseError<&str>>()
|
|
.parse(r"escaped closing \] bracket")
|
|
.unwrap();
|
|
assert_eq!(propval, r"escaped closing ] bracket".to_owned());
|
|
}
|
|
|
|
#[test]
|
|
fn it_parses_propvals_with_soft_linebreaks() {
|
|
let (_, propval) = parse_text::<nom::error::VerboseError<&str>>()
|
|
.parse(
|
|
r"Soft linebreaks are linebreaks preceeded by '\\' like this one >o\
|
|
k<. Hard line breaks are all other linebreaks.",
|
|
)
|
|
.unwrap();
|
|
assert_eq!(
|
|
propval,
|
|
"Soft linebreaks are linebreaks preceeded by '\\' like this one >ok<. Hard line breaks are all other linebreaks."
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn it_parses_sgf_with_newline_in_sequence() {
|
|
let data = String::from(
|
|
"(;FF[4]C[root](;C[a];C[b](;C[c])(;C[d];C[e]
|
|
))(;C[f](;C[g];C[h];C[i])(;C[j])))",
|
|
);
|
|
parse_tree::<nom::error::VerboseError<&str>>(&data).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn it_parses_sgf_with_newline_between_two_sequence_closings() {
|
|
let data = String::from(
|
|
"(;FF[4]C[root](;C[a];C[b](;C[c])(;C[d];C[e])
|
|
)(;C[f](;C[g];C[h];C[i])(;C[j])))",
|
|
);
|
|
parse_tree::<nom::error::VerboseError<&str>>(&data).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn it_can_convert_moves_to_coordinates() {
|
|
assert_eq!(Move::Pass.coordinate(), None);
|
|
assert_eq!(Move::Move("dd".to_owned()).coordinate(), Some((3, 3)));
|
|
assert_eq!(Move::Move("jj".to_owned()).coordinate(), Some((9, 9)));
|
|
assert_eq!(Move::Move("pp".to_owned()).coordinate(), Some((15, 15)));
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod date_test {
|
|
use super::*;
|
|
use chrono::NaiveDate;
|
|
use cool_asserts::assert_matches;
|
|
|
|
#[test]
|
|
fn it_parses_a_year() {
|
|
assert_matches!(parse_date_field::<nom::error::VerboseError<&str>>().parse("1996"), Ok((_, date)) => {
|
|
assert_eq!(date, vec![Date::Year(1996)]);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn it_parses_a_month() {
|
|
assert_matches!(
|
|
parse_date_field::<nom::error::VerboseError<&str>>().parse("1996-12"),
|
|
Ok((_, date)) => assert_eq!(date, vec![Date::YearMonth(1996, 12)])
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn it_parses_a_date() {
|
|
assert_matches!(
|
|
parse_date_field::<nom::error::VerboseError<&str>>().parse("1996-12-27"),
|
|
Ok((_, date)) => assert_eq!(date, vec![Date::Date(
|
|
NaiveDate::from_ymd_opt(1996, 12, 27).unwrap()
|
|
)])
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn it_parses_date_continuation() {
|
|
assert_matches!(
|
|
parse_date_field::<nom::error::VerboseError<&str>>().parse("1996-12-27,28"),
|
|
Ok((_, date)) => assert_eq!(date, vec![
|
|
Date::Date(NaiveDate::from_ymd_opt(1996, 12, 27).unwrap()),
|
|
Date::Date(NaiveDate::from_ymd_opt(1996, 12, 28).unwrap())
|
|
])
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn it_parses_date_crossing_year_boundary() {
|
|
assert_matches!(
|
|
parse_date_field::<nom::error::VerboseError<&str>>().parse("1996-12-27,28,1997-01-03,04"),
|
|
Ok((_, date)) => assert_eq!(date, vec![
|
|
Date::Date(NaiveDate::from_ymd_opt(1996, 12, 27).unwrap()),
|
|
Date::Date(NaiveDate::from_ymd_opt(1996, 12, 28).unwrap()),
|
|
Date::Date(NaiveDate::from_ymd_opt(1997, 1, 3).unwrap()),
|
|
Date::Date(NaiveDate::from_ymd_opt(1997, 1, 4).unwrap()),
|
|
])
|
|
);
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod property_tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn it_can_parse_time_left() {
|
|
let (_, val) =
|
|
parse_time_left::<nom::error::VerboseError<&str>>(Color::Black)("170]").unwrap();
|
|
assert_eq!(
|
|
val,
|
|
Property::TimeLeft((Color::Black, Duration::from_secs(170)))
|
|
);
|
|
|
|
let (_, val) =
|
|
parse_time_left::<nom::error::VerboseError<&str>>(Color::Black)("170.6]").unwrap();
|
|
assert_eq!(
|
|
val,
|
|
Property::TimeLeft((Color::Black, Duration::from_secs(170)))
|
|
);
|
|
|
|
let (_, prop) = parse_property::<nom::error::VerboseError<&str>>("BL[170]").unwrap();
|
|
assert_eq!(
|
|
prop,
|
|
Property::TimeLeft((Color::Black, Duration::from_secs(170)))
|
|
);
|
|
|
|
let (_, prop) = parse_property::<nom::error::VerboseError<&str>>("BL[170.5]").unwrap();
|
|
assert_eq!(
|
|
prop,
|
|
Property::TimeLeft((Color::Black, Duration::from_secs(170)))
|
|
);
|
|
}
|
|
}
|