Set up SGF reading and start on the game database #47
|
|
@ -0,0 +1,269 @@
|
|||
// https://red-bean.com/sgf/user_guide/index.html
|
||||
// https://red-bean.com/sgf/sgf4.html
|
||||
|
||||
// todo: support collections in a file
|
||||
// Properties to support. Remove each one as it gets support.
|
||||
// B
|
||||
// KO
|
||||
// MN
|
||||
// W
|
||||
// AB
|
||||
// AE
|
||||
// AW
|
||||
// PL
|
||||
// C
|
||||
// DM
|
||||
// GB
|
||||
// GW
|
||||
// HO
|
||||
// N
|
||||
// UC
|
||||
// V
|
||||
// BM
|
||||
// DO
|
||||
// IT
|
||||
// TE
|
||||
// AR
|
||||
// CR
|
||||
// DD
|
||||
// LB
|
||||
// LN
|
||||
// MA
|
||||
// SL
|
||||
// SQ
|
||||
// TR
|
||||
// AP
|
||||
// CA
|
||||
// FF
|
||||
// GM
|
||||
// ST
|
||||
// SZ
|
||||
// AN
|
||||
// BR
|
||||
// BT
|
||||
// CP
|
||||
// DT
|
||||
// EV
|
||||
// GN
|
||||
// GC
|
||||
// ON
|
||||
// OT
|
||||
// PB
|
||||
// PC
|
||||
// PW
|
||||
// RE
|
||||
// RO
|
||||
// RU
|
||||
// SO
|
||||
// TM
|
||||
// US
|
||||
// WR
|
||||
// WT
|
||||
// BL
|
||||
// OB
|
||||
// OW
|
||||
// WL
|
||||
// FG
|
||||
// PM
|
||||
// VW
|
||||
|
||||
use crate::tree::{parse_collection, parse_size, ParseSizeError, Size};
|
||||
use nom::IResult;
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum Error<'a> {
|
||||
InvalidField,
|
||||
InvalidBoardSize,
|
||||
Incomplete,
|
||||
InvalidSgf(nom::error::VerboseError<&'a str>),
|
||||
}
|
||||
|
||||
impl<'a> From<nom::Err<nom::error::VerboseError<&'a str>>> for Error<'a> {
|
||||
fn from(err: nom::Err<nom::error::VerboseError<&'a str>>) -> Self {
|
||||
match err {
|
||||
nom::Err::Incomplete(_) => Error::Incomplete,
|
||||
nom::Err::Error(e) => Error::InvalidSgf(e.clone()),
|
||||
nom::Err::Failure(e) => Error::InvalidSgf(e.clone()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> From<ParseSizeError> for Error<'a> {
|
||||
fn from(_: ParseSizeError) -> Self {
|
||||
Self::InvalidBoardSize
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct GameTree {
|
||||
pub file_format: i8,
|
||||
pub app: Option<String>,
|
||||
pub game_type: GameType,
|
||||
pub board_size: Size,
|
||||
|
||||
pub text: String,
|
||||
}
|
||||
|
||||
pub struct GameInfo {
|
||||
pub annotator: Option<String>,
|
||||
pub copyright: Option<String>,
|
||||
pub event: Option<String>,
|
||||
// Games can be played across multiple days, even multiple years. The format specifies
|
||||
// shortcuts.
|
||||
pub date_time: Vec<chrono::NaiveDate>,
|
||||
pub location: Option<String>,
|
||||
// special rules for the round-number and type
|
||||
pub round: Option<String>,
|
||||
pub ruleset: Option<String>,
|
||||
pub source: Option<String>,
|
||||
pub time_limits: Option<std::time::Duration>,
|
||||
pub game_keeper: Option<String>,
|
||||
|
||||
pub game_name: Option<String>,
|
||||
pub game_comments: Option<String>,
|
||||
|
||||
pub black_player: Option<String>,
|
||||
pub black_rank: Option<String>,
|
||||
pub black_team: Option<String>,
|
||||
|
||||
pub white_player: Option<String>,
|
||||
pub white_rank: Option<String>,
|
||||
pub white_team: Option<String>,
|
||||
|
||||
pub opening: Option<String>,
|
||||
pub overtime: Option<String>,
|
||||
pub result: Option<GameResult>,
|
||||
}
|
||||
|
||||
pub enum GameResult {
|
||||
Annulled,
|
||||
Draw,
|
||||
Black(Win),
|
||||
White(Win),
|
||||
}
|
||||
|
||||
pub enum Win {
|
||||
Score(i32),
|
||||
Resignation,
|
||||
Forfeit,
|
||||
Time,
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq)]
|
||||
pub enum GameType {
|
||||
Go,
|
||||
Unsupported,
|
||||
}
|
||||
|
||||
enum PropType {
|
||||
Move,
|
||||
Setup,
|
||||
Root,
|
||||
GameInfo,
|
||||
}
|
||||
|
||||
enum PropValue {
|
||||
Empty,
|
||||
Number,
|
||||
Real,
|
||||
Double,
|
||||
Color,
|
||||
SimpleText,
|
||||
Text,
|
||||
Point,
|
||||
Move,
|
||||
Stone,
|
||||
}
|
||||
|
||||
pub fn parse_sgf<'a>(input: &'a str) -> Result<Vec<GameTree>, Error<'a>> {
|
||||
let (input, trees) = parse_collection::<nom::error::VerboseError<&'a str>>(input)?;
|
||||
|
||||
let games = trees
|
||||
.into_iter()
|
||||
.map(|tree| {
|
||||
let file_format = match tree.sequence[0].find_prop("FF") {
|
||||
Some(prop) => prop.values[0].parse::<i8>().unwrap(),
|
||||
None => 4,
|
||||
};
|
||||
let app = tree.sequence[0]
|
||||
.find_prop("AP")
|
||||
.map(|prop| prop.values[0].clone());
|
||||
let board_size = match tree.sequence[0].find_prop("SZ") {
|
||||
Some(prop) => Size::try_from(prop.values[0].as_str())?,
|
||||
None => Size {
|
||||
width: 19,
|
||||
height: 19,
|
||||
},
|
||||
};
|
||||
|
||||
Ok(GameTree {
|
||||
file_format,
|
||||
|
||||
app,
|
||||
game_type: GameType::Go,
|
||||
board_size,
|
||||
text: input.to_owned(),
|
||||
})
|
||||
})
|
||||
.collect::<Result<Vec<GameTree>, Error>>()?;
|
||||
Ok(games)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::tree::Size;
|
||||
use std::fs::File;
|
||||
use std::io::Read;
|
||||
|
||||
const EXAMPLE: &'static 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])))";
|
||||
|
||||
fn with_text(text: &str, f: impl FnOnce(Vec<GameTree>)) {
|
||||
let games = parse_sgf(text).unwrap();
|
||||
f(games);
|
||||
}
|
||||
|
||||
fn with_file(path: &std::path::Path, f: impl FnOnce(Vec<GameTree>)) {
|
||||
let mut file = File::open(path).unwrap();
|
||||
let mut text = String::new();
|
||||
let _ = file.read_to_string(&mut text);
|
||||
with_text(&text, f);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn it_parses_game_root() {
|
||||
with_text(EXAMPLE, |trees| {
|
||||
assert_eq!(trees.len(), 1);
|
||||
let tree = &trees[0];
|
||||
assert_eq!(tree.file_format, 4);
|
||||
assert_eq!(tree.app, None);
|
||||
assert_eq!(tree.game_type, GameType::Go);
|
||||
assert_eq!(
|
||||
tree.board_size,
|
||||
Size {
|
||||
width: 19,
|
||||
height: 19
|
||||
}
|
||||
);
|
||||
// assert_eq!(tree.text, EXAMPLE.to_owned());
|
||||
});
|
||||
|
||||
with_file(std::path::Path::new("test_data/print1.sgf"), |trees| {
|
||||
assert_eq!(trees.len(), 1);
|
||||
let tree = &trees[0];
|
||||
assert_eq!(tree.file_format, 4);
|
||||
assert_eq!(tree.app, None);
|
||||
assert_eq!(tree.game_type, GameType::Go);
|
||||
assert_eq!(
|
||||
tree.board_size,
|
||||
Size {
|
||||
width: 19,
|
||||
height: 19
|
||||
}
|
||||
);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
|
@ -1,81 +1,6 @@
|
|||
// https://red-bean.com/sgf/user_guide/index.html
|
||||
// https://red-bean.com/sgf/sgf4.html
|
||||
pub mod go;
|
||||
pub mod tree;
|
||||
|
||||
// todo: support collections in a file
|
||||
// Properties to support. Remove each one as it gets support.
|
||||
// B
|
||||
// KO
|
||||
// MN
|
||||
// W
|
||||
// AB
|
||||
// AE
|
||||
// AW
|
||||
// PL
|
||||
// C
|
||||
// DM
|
||||
// GB
|
||||
// GW
|
||||
// HO
|
||||
// N
|
||||
// UC
|
||||
// V
|
||||
// BM
|
||||
// DO
|
||||
// IT
|
||||
// TE
|
||||
// AR
|
||||
// CR
|
||||
// DD
|
||||
// LB
|
||||
// LN
|
||||
// MA
|
||||
// SL
|
||||
// SQ
|
||||
// TR
|
||||
// AP
|
||||
// CA
|
||||
// FF
|
||||
// GM
|
||||
// ST
|
||||
// SZ
|
||||
// AN
|
||||
// BR
|
||||
// BT
|
||||
// CP
|
||||
// DT
|
||||
// EV
|
||||
// GN
|
||||
// GC
|
||||
// ON
|
||||
// OT
|
||||
// PB
|
||||
// PC
|
||||
// PW
|
||||
// RE
|
||||
// RO
|
||||
// RU
|
||||
// SO
|
||||
// TM
|
||||
// US
|
||||
// WR
|
||||
// WT
|
||||
// BL
|
||||
// OB
|
||||
// OW
|
||||
// WL
|
||||
// FG
|
||||
// PM
|
||||
// VW
|
||||
|
||||
use nom::{
|
||||
branch::alt,
|
||||
bytes::complete::{escaped, escaped_transform, is_not, tag},
|
||||
character::complete::{alpha1, digit1, multispace0, multispace1, none_of, one_of},
|
||||
combinator::{opt, value},
|
||||
multi::{many0, many1, separated_list1},
|
||||
sequence::delimited,
|
||||
Finish, IResult,
|
||||
};
|
||||
use thiserror::Error;
|
||||
|
||||
pub enum Warning {}
|
||||
|
|
@ -115,637 +40,3 @@ impl From<nom::error::VerboseError<&str>> for ParseError {
|
|||
}
|
||||
}
|
||||
*/
|
||||
|
||||
// todo: support ST root node
|
||||
#[derive(Debug)]
|
||||
pub struct GameTree {
|
||||
pub file_format: i8,
|
||||
pub app: Option<String>,
|
||||
pub game_type: GameType,
|
||||
pub board_size: Size,
|
||||
|
||||
pub text: String,
|
||||
}
|
||||
|
||||
pub struct GameInfo {
|
||||
pub annotator: Option<String>,
|
||||
pub copyright: Option<String>,
|
||||
pub event: Option<String>,
|
||||
// Games can be played across multiple days, even multiple years. The format specifies
|
||||
// shortcuts.
|
||||
pub date_time: Vec<chrono::NaiveDate>,
|
||||
pub location: Option<String>,
|
||||
// special rules for the round-number and type
|
||||
pub round: Option<String>,
|
||||
pub ruleset: Option<String>,
|
||||
pub source: Option<String>,
|
||||
pub time_limits: Option<std::time::Duration>,
|
||||
pub game_keeper: Option<String>,
|
||||
|
||||
pub game_name: Option<String>,
|
||||
pub game_comments: Option<String>,
|
||||
|
||||
pub black_player: Option<String>,
|
||||
pub black_rank: Option<String>,
|
||||
pub black_team: Option<String>,
|
||||
|
||||
pub white_player: Option<String>,
|
||||
pub white_rank: Option<String>,
|
||||
pub white_team: Option<String>,
|
||||
|
||||
pub opening: Option<String>,
|
||||
pub overtime: Option<String>,
|
||||
pub result: Option<GameResult>,
|
||||
}
|
||||
|
||||
pub enum GameResult {
|
||||
Annulled,
|
||||
Draw,
|
||||
Black(Win),
|
||||
White(Win),
|
||||
}
|
||||
|
||||
pub enum Win {
|
||||
Score(i32),
|
||||
Resignation,
|
||||
Forfeit,
|
||||
Time,
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq)]
|
||||
pub struct Size {
|
||||
width: i32,
|
||||
height: i32,
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq)]
|
||||
pub enum GameType {
|
||||
Go,
|
||||
Unsupported,
|
||||
}
|
||||
|
||||
// struct Sequence(Node);
|
||||
|
||||
/*
|
||||
struct Node {
|
||||
// properties
|
||||
}
|
||||
*/
|
||||
|
||||
enum PropType {
|
||||
Move,
|
||||
Setup,
|
||||
Root,
|
||||
GameInfo,
|
||||
}
|
||||
|
||||
enum PropValue {
|
||||
Empty,
|
||||
Number,
|
||||
Real,
|
||||
Double,
|
||||
Color,
|
||||
SimpleText,
|
||||
Text,
|
||||
Point,
|
||||
Move,
|
||||
Stone,
|
||||
}
|
||||
|
||||
pub fn parse_sgf(input: &str) -> Result<Vec<GameTree>, ParseError> {
|
||||
let (_, trees) = parse_collection::<nom::error::Error<&str>>(input).finish()?;
|
||||
|
||||
trees
|
||||
.into_iter()
|
||||
.map(|tree| {
|
||||
let file_format = match tree.sequence[0].find_prop("FF") {
|
||||
Some(prop) => prop.values[0].parse::<i8>().unwrap(),
|
||||
None => 4,
|
||||
};
|
||||
let app = tree.sequence[0]
|
||||
.find_prop("AP")
|
||||
.map(|prop| prop.values[0].clone());
|
||||
let board_size = match tree.sequence[0].find_prop("SZ") {
|
||||
Some(prop) => {
|
||||
let (_, size) =
|
||||
parse_size::<nom::error::Error<&str>>(prop.values[0].as_str()).finish()?;
|
||||
size
|
||||
}
|
||||
None => Size {
|
||||
width: 19,
|
||||
height: 19,
|
||||
},
|
||||
};
|
||||
|
||||
Ok(GameTree {
|
||||
file_format,
|
||||
|
||||
app,
|
||||
game_type: GameType::Go,
|
||||
board_size,
|
||||
text: input.to_owned(),
|
||||
})
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq)]
|
||||
struct Tree {
|
||||
sequence: Vec<Node>,
|
||||
sub_sequences: Vec<Tree>,
|
||||
}
|
||||
|
||||
impl ToString for Tree {
|
||||
fn to_string(&self) -> String {
|
||||
let sequence = self
|
||||
.sequence
|
||||
.iter()
|
||||
.map(|node| node.to_string())
|
||||
.collect::<String>();
|
||||
let subsequences = self
|
||||
.sub_sequences
|
||||
.iter()
|
||||
.map(|seq| seq.to_string())
|
||||
.collect::<String>();
|
||||
format!("({}{})", sequence, subsequences)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq)]
|
||||
struct Node {
|
||||
properties: Vec<Property>,
|
||||
}
|
||||
|
||||
impl ToString for Node {
|
||||
fn to_string(&self) -> String {
|
||||
let props = self
|
||||
.properties
|
||||
.iter()
|
||||
.map(|prop| prop.to_string())
|
||||
.collect::<String>();
|
||||
format!(";{}", props)
|
||||
}
|
||||
}
|
||||
|
||||
impl Node {
|
||||
fn find_prop(&self, ident: &str) -> Option<Property> {
|
||||
self.properties
|
||||
.iter()
|
||||
.find(|prop| prop.ident == ident)
|
||||
.cloned()
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
struct Property {
|
||||
ident: String,
|
||||
values: Vec<String>,
|
||||
}
|
||||
|
||||
impl ToString for Property {
|
||||
fn to_string(&self) -> String {
|
||||
let values = self
|
||||
.values
|
||||
.iter()
|
||||
.map(|val| format!("[{}]", val))
|
||||
.collect::<String>();
|
||||
format!("{}{}", self.ident, values)
|
||||
}
|
||||
}
|
||||
|
||||
fn parse_collection<'a, E: nom::error::ParseError<&'a str>>(
|
||||
input: &'a str,
|
||||
) -> IResult<&'a str, Vec<Tree>, E> {
|
||||
separated_list1(multispace1, parse_tree)(input)
|
||||
}
|
||||
|
||||
// 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, Tree, E> {
|
||||
println!("::: parse_tree: {}", input);
|
||||
let (input, _) = multispace0(input)?;
|
||||
delimited(tag("("), parse_sequence, tag(")"))(input)
|
||||
}
|
||||
|
||||
fn parse_sequence<'a, E: nom::error::ParseError<&'a str>>(
|
||||
input: &'a str,
|
||||
) -> IResult<&'a str, Tree, E> {
|
||||
println!("::: parse_sequence: {}", input);
|
||||
let (input, _) = multispace0(input)?;
|
||||
let (input, nodes) = many1(parse_node)(input)?;
|
||||
let (input, sub_sequences) = many0(parse_tree)(input)?;
|
||||
|
||||
Ok((
|
||||
input,
|
||||
Tree {
|
||||
sequence: nodes,
|
||||
sub_sequences,
|
||||
},
|
||||
))
|
||||
}
|
||||
|
||||
fn parse_node<'a, E: nom::error::ParseError<&'a str>>(input: &'a str) -> IResult<&'a str, Node, E> {
|
||||
println!("::: parse_node: {}", input);
|
||||
let (input, _) = multispace0(input)?;
|
||||
let (input, _) = tag(";")(input)?;
|
||||
let (input, properties) = many1(parse_property)(input)?;
|
||||
Ok((input, Node { properties }))
|
||||
}
|
||||
|
||||
fn parse_property<'a, E: nom::error::ParseError<&'a str>>(
|
||||
input: &'a str,
|
||||
) -> IResult<&'a str, Property, E> {
|
||||
println!(":: parse_property: {}", input);
|
||||
let (input, _) = multispace0(input)?;
|
||||
let (input, ident) = alpha1(input)?;
|
||||
let (input, values) = many1(parse_propval)(input)?;
|
||||
|
||||
let values = values
|
||||
.into_iter()
|
||||
.map(|v| v.to_owned())
|
||||
.collect::<Vec<String>>();
|
||||
Ok((
|
||||
input,
|
||||
Property {
|
||||
ident: ident.to_owned(),
|
||||
values,
|
||||
},
|
||||
))
|
||||
}
|
||||
|
||||
fn parse_propval<'a, E: nom::error::ParseError<&'a str>>(
|
||||
input: &'a str,
|
||||
) -> IResult<&'a str, String, E> {
|
||||
let (input, _) = multispace0(input)?;
|
||||
println!("- {}", input);
|
||||
|
||||
let (input, _) = tag("[")(input)?;
|
||||
println!("-- {}", input);
|
||||
|
||||
let (input, value) = parse_propval_text(input)?;
|
||||
println!("--- {}", input);
|
||||
|
||||
let (input, _) = tag("]")(input)?;
|
||||
|
||||
Ok((input, value.unwrap_or(String::new())))
|
||||
}
|
||||
|
||||
fn parse_propval_text<'a, E: nom::error::ParseError<&'a str>>(
|
||||
input: &'a str,
|
||||
) -> IResult<&'a str, Option<String>, E> {
|
||||
let (input, value) = opt(escaped_transform(
|
||||
none_of("\\]"),
|
||||
'\\',
|
||||
alt((
|
||||
value("]", tag("]")),
|
||||
value("\\", tag("\\")),
|
||||
value("", tag("\n")),
|
||||
)),
|
||||
))(input)?;
|
||||
Ok((input, value.map(|v| v.to_owned())))
|
||||
}
|
||||
|
||||
fn parse_size<'a, E: nom::error::ParseError<&'a str>>(input: &'a str) -> IResult<&'a str, Size, E> {
|
||||
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 }))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use std::{fs::File, io::Read};
|
||||
|
||||
use super::*;
|
||||
|
||||
const EXAMPLE: &'static 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 {
|
||||
ident: "C".to_owned(),
|
||||
values: vec!["a".to_owned()]
|
||||
}
|
||||
);
|
||||
|
||||
let (_, prop) = parse_property::<nom::error::VerboseError<&str>>("C[a][b][c]").unwrap();
|
||||
assert_eq!(
|
||||
prop,
|
||||
Property {
|
||||
ident: "C".to_owned(),
|
||||
values: vec!["a".to_owned(), "b".to_owned(), "c".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 {
|
||||
ident: "B".to_owned(),
|
||||
values: vec!["ab".to_owned()]
|
||||
}]
|
||||
}
|
||||
);
|
||||
|
||||
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 {
|
||||
ident: "B".to_owned(),
|
||||
values: vec!["ab".to_owned()]
|
||||
}]
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
#[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,
|
||||
Tree {
|
||||
sequence: vec![
|
||||
Node {
|
||||
properties: vec![Property {
|
||||
ident: "B".to_owned(),
|
||||
values: vec!["ab".to_owned()]
|
||||
}]
|
||||
},
|
||||
Node {
|
||||
properties: vec![Property {
|
||||
ident: "W".to_owned(),
|
||||
values: vec!["dp".to_owned()]
|
||||
}]
|
||||
},
|
||||
Node {
|
||||
properties: vec![
|
||||
Property {
|
||||
ident: "B".to_owned(),
|
||||
values: vec!["pq".to_owned()]
|
||||
},
|
||||
Property {
|
||||
ident: "C".to_owned(),
|
||||
values: vec!["some comments".to_owned()]
|
||||
}
|
||||
]
|
||||
}
|
||||
],
|
||||
sub_sequences: vec![],
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn it_can_parse_a_sequence_with_subsequences() {
|
||||
let text = "(;C[a];C[b](;C[c])(;C[d];C[e]))";
|
||||
let (_, sequence) = parse_tree::<nom::error::VerboseError<&str>>(text).unwrap();
|
||||
|
||||
let main_sequence = vec![
|
||||
Node {
|
||||
properties: vec![Property {
|
||||
ident: "C".to_owned(),
|
||||
values: vec!["a".to_owned()],
|
||||
}],
|
||||
},
|
||||
Node {
|
||||
properties: vec![Property {
|
||||
ident: "C".to_owned(),
|
||||
values: vec!["b".to_owned()],
|
||||
}],
|
||||
},
|
||||
];
|
||||
let subsequence_1 = Tree {
|
||||
sequence: vec![Node {
|
||||
properties: vec![Property {
|
||||
ident: "C".to_owned(),
|
||||
values: vec!["c".to_owned()],
|
||||
}],
|
||||
}],
|
||||
sub_sequences: vec![],
|
||||
};
|
||||
let subsequence_2 = Tree {
|
||||
sequence: vec![
|
||||
Node {
|
||||
properties: vec![Property {
|
||||
ident: "C".to_owned(),
|
||||
values: vec!["d".to_owned()],
|
||||
}],
|
||||
},
|
||||
Node {
|
||||
properties: vec![Property {
|
||||
ident: "C".to_owned(),
|
||||
values: vec!["e".to_owned()],
|
||||
}],
|
||||
},
|
||||
],
|
||||
sub_sequences: vec![],
|
||||
};
|
||||
|
||||
assert_eq!(
|
||||
sequence,
|
||||
Tree {
|
||||
sequence: main_sequence,
|
||||
sub_sequences: vec![subsequence_1, subsequence_2],
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn it_can_parse_example_1() {
|
||||
let (_, ex_tree) = parse_tree::<nom::error::VerboseError<&str>>(EXAMPLE).unwrap();
|
||||
assert_eq!(ex_tree.sequence.len(), 1);
|
||||
|
||||
assert_eq!(ex_tree.sequence[0].properties.len(), 2);
|
||||
assert_eq!(
|
||||
ex_tree.sequence[0].properties[0],
|
||||
Property {
|
||||
ident: "FF".to_owned(),
|
||||
values: vec!["4".to_owned()]
|
||||
}
|
||||
);
|
||||
assert_eq!(ex_tree.sub_sequences.len(), 2);
|
||||
|
||||
assert_eq!(ex_tree.sub_sequences[0].sequence.len(), 2);
|
||||
assert_eq!(
|
||||
ex_tree.sub_sequences[0].sequence,
|
||||
vec![
|
||||
Node {
|
||||
properties: vec![Property {
|
||||
ident: "C".to_owned(),
|
||||
values: vec!["a".to_owned()]
|
||||
}]
|
||||
},
|
||||
Node {
|
||||
properties: vec![Property {
|
||||
ident: "C".to_owned(),
|
||||
values: vec!["b".to_owned()]
|
||||
}]
|
||||
},
|
||||
]
|
||||
);
|
||||
assert_eq!(ex_tree.sub_sequences[0].sub_sequences.len(), 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn it_can_regenerate_the_tree() {
|
||||
let (_, tree1) = parse_tree::<nom::error::VerboseError<&str>>(EXAMPLE).unwrap();
|
||||
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, tree2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn it_parses_propvals() {
|
||||
let (_, propval) = parse_propval::<nom::error::VerboseError<&str>>("[]").unwrap();
|
||||
assert_eq!(propval, "".to_owned());
|
||||
|
||||
let (_, propval) =
|
||||
parse_propval::<nom::error::VerboseError<&str>>("[normal propval]").unwrap();
|
||||
assert_eq!(propval, "normal propval".to_owned());
|
||||
|
||||
let (_, propval) =
|
||||
parse_propval::<nom::error::VerboseError<&str>>(r"[need an [escape\] in the propval]")
|
||||
.unwrap();
|
||||
assert_eq!(propval, "need an [escape] in the propval".to_owned());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn it_parses_propvals_with_hard_linebreaks() {
|
||||
let (_, propval) = parse_propval_text::<nom::error::VerboseError<&str>>(
|
||||
"There are hard linebreaks & soft linebreaks.
|
||||
Soft linebreaks...",
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
propval,
|
||||
Some(
|
||||
"There are hard linebreaks & soft linebreaks.
|
||||
Soft linebreaks..."
|
||||
.to_owned()
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn it_parses_propvals_with_escaped_closing_brackets() {
|
||||
let (_, propval) =
|
||||
parse_propval_text::<nom::error::VerboseError<&str>>(r"escaped closing \] bracket")
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
propval,
|
||||
Some(r"escaped closing ] bracket".to_owned()).to_owned()
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn it_parses_propvals_with_soft_linebreaks() {
|
||||
let (_, propval) = parse_propval_text::<nom::error::VerboseError<&str>>(
|
||||
r"Soft linebreaks are linebreaks preceeded by '\\' like this one >o\
|
||||
k<. Hard line breaks are all other linebreaks.",
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
propval,
|
||||
Some("Soft linebreaks are linebreaks preceeded by '\\' like this one >ok<. Hard line breaks are all other linebreaks.".to_owned())
|
||||
.to_owned()
|
||||
);
|
||||
}
|
||||
|
||||
fn with_text(text: &str, f: impl FnOnce(Vec<GameTree>)) {
|
||||
f(parse_sgf(text).unwrap());
|
||||
}
|
||||
|
||||
fn with_file(path: &std::path::Path, f: impl FnOnce(Vec<GameTree>)) {
|
||||
let mut file = File::open(path).unwrap();
|
||||
let mut text = String::new();
|
||||
let _ = file.read_to_string(&mut text);
|
||||
with_text(&text, f);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn it_parses_game_root() {
|
||||
with_text(EXAMPLE, |trees| {
|
||||
assert_eq!(trees.len(), 1);
|
||||
let tree = &trees[0];
|
||||
assert_eq!(tree.file_format, 4);
|
||||
assert_eq!(tree.app, None);
|
||||
assert_eq!(tree.game_type, GameType::Go);
|
||||
assert_eq!(
|
||||
tree.board_size,
|
||||
Size {
|
||||
width: 19,
|
||||
height: 19
|
||||
}
|
||||
);
|
||||
assert_eq!(tree.text, EXAMPLE.to_owned());
|
||||
});
|
||||
|
||||
with_file(std::path::Path::new("test_data/print1.sgf"), |trees| {
|
||||
assert_eq!(trees.len(), 1);
|
||||
let tree = &trees[0];
|
||||
assert_eq!(tree.file_format, 4);
|
||||
assert_eq!(tree.app, None);
|
||||
assert_eq!(tree.game_type, GameType::Go);
|
||||
assert_eq!(
|
||||
tree.board_size,
|
||||
Size {
|
||||
width: 19,
|
||||
height: 19
|
||||
}
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
/*
|
||||
#[test]
|
||||
fn it_parses_linebreaks() {
|
||||
with_file(
|
||||
std::path::Path::new("test_data/linebreak_tests.sgf"),
|
||||
|tree| {},
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn it_parses_ff4_a() {
|
||||
with_file(std::path::Path::new("test_data/ff4_a.sgf"), |tree| {});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn it_parses_ff4_b() {
|
||||
with_file(std::path::Path::new("test_data/ff4_b.sgf"), |tree| {});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn it_parses_ff4_ex() {
|
||||
with_file(std::path::Path::new("test_data/ff4_ex.sgf"), |tree| {});
|
||||
}
|
||||
*/
|
||||
}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,480 @@
|
|||
use std::num::ParseIntError;
|
||||
|
||||
use nom::{
|
||||
branch::alt,
|
||||
bytes::complete::{escaped_transform, tag},
|
||||
character::complete::{alpha1, digit1, multispace0, multispace1, none_of},
|
||||
combinator::{opt, value},
|
||||
multi::{many0, many1, separated_list1},
|
||||
sequence::delimited,
|
||||
IResult,
|
||||
};
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum ParseSizeError {
|
||||
ParseIntError(ParseIntError),
|
||||
InsufficientArguments,
|
||||
}
|
||||
|
||||
impl From<ParseIntError> for ParseSizeError {
|
||||
fn from(e: ParseIntError) -> Self {
|
||||
Self::ParseIntError(e)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq)]
|
||||
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(Debug, PartialEq)]
|
||||
pub struct Tree {
|
||||
pub sequence: Vec<Node>,
|
||||
pub sub_sequences: Vec<Tree>,
|
||||
}
|
||||
|
||||
impl ToString for Tree {
|
||||
fn to_string(&self) -> String {
|
||||
let sequence = self
|
||||
.sequence
|
||||
.iter()
|
||||
.map(|node| node.to_string())
|
||||
.collect::<String>();
|
||||
let subsequences = self
|
||||
.sub_sequences
|
||||
.iter()
|
||||
.map(|seq| seq.to_string())
|
||||
.collect::<String>();
|
||||
format!("({}{})", sequence, subsequences)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq)]
|
||||
pub struct Node {
|
||||
pub properties: Vec<Property>,
|
||||
}
|
||||
|
||||
impl ToString for Node {
|
||||
fn to_string(&self) -> String {
|
||||
let props = self
|
||||
.properties
|
||||
.iter()
|
||||
.map(|prop| prop.to_string())
|
||||
.collect::<String>();
|
||||
format!(";{}", props)
|
||||
}
|
||||
}
|
||||
|
||||
impl Node {
|
||||
pub fn find_prop(&self, ident: &str) -> Option<Property> {
|
||||
self.properties
|
||||
.iter()
|
||||
.find(|prop| prop.ident == ident)
|
||||
.cloned()
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub struct Property {
|
||||
pub ident: String,
|
||||
pub values: Vec<String>,
|
||||
}
|
||||
|
||||
impl ToString for Property {
|
||||
fn to_string(&self) -> String {
|
||||
let values = self
|
||||
.values
|
||||
.iter()
|
||||
.map(|val| format!("[{}]", val))
|
||||
.collect::<String>();
|
||||
format!("{}{}", self.ident, values)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn parse_collection<'a, E: nom::error::ParseError<&'a str>>(
|
||||
input: &'a str,
|
||||
) -> IResult<&'a str, Vec<Tree>, E> {
|
||||
separated_list1(multispace1, parse_tree)(input)
|
||||
}
|
||||
|
||||
// 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, Tree, E> {
|
||||
println!("::: parse_tree: {}", input);
|
||||
let (input, _) = multispace0(input)?;
|
||||
delimited(tag("("), parse_sequence, tag(")"))(input)
|
||||
}
|
||||
|
||||
fn parse_sequence<'a, E: nom::error::ParseError<&'a str>>(
|
||||
input: &'a str,
|
||||
) -> IResult<&'a str, Tree, E> {
|
||||
println!("::: parse_sequence: {}", input);
|
||||
let (input, _) = multispace0(input)?;
|
||||
let (input, nodes) = many1(parse_node)(input)?;
|
||||
let (input, sub_sequences) = many0(parse_tree)(input)?;
|
||||
|
||||
Ok((
|
||||
input,
|
||||
Tree {
|
||||
sequence: nodes,
|
||||
sub_sequences,
|
||||
},
|
||||
))
|
||||
}
|
||||
|
||||
fn parse_node<'a, E: nom::error::ParseError<&'a str>>(input: &'a str) -> IResult<&'a str, Node, E> {
|
||||
println!("::: parse_node: {}", input);
|
||||
let (input, _) = multispace0(input)?;
|
||||
let (input, _) = tag(";")(input)?;
|
||||
let (input, properties) = many1(parse_property)(input)?;
|
||||
Ok((input, Node { properties }))
|
||||
}
|
||||
|
||||
fn parse_property<'a, E: nom::error::ParseError<&'a str>>(
|
||||
input: &'a str,
|
||||
) -> IResult<&'a str, Property, E> {
|
||||
println!(":: parse_property: {}", input);
|
||||
let (input, _) = multispace0(input)?;
|
||||
let (input, ident) = alpha1(input)?;
|
||||
let (input, values) = many1(parse_propval)(input)?;
|
||||
|
||||
let values = values
|
||||
.into_iter()
|
||||
.map(|v| v.to_owned())
|
||||
.collect::<Vec<String>>();
|
||||
Ok((
|
||||
input,
|
||||
Property {
|
||||
ident: ident.to_owned(),
|
||||
values,
|
||||
},
|
||||
))
|
||||
}
|
||||
|
||||
fn parse_propval<'a, E: nom::error::ParseError<&'a str>>(
|
||||
input: &'a str,
|
||||
) -> IResult<&'a str, String, E> {
|
||||
let (input, _) = multispace0(input)?;
|
||||
println!("- {}", input);
|
||||
|
||||
let (input, _) = tag("[")(input)?;
|
||||
println!("-- {}", input);
|
||||
|
||||
let (input, value) = parse_propval_text(input)?;
|
||||
println!("--- {}", input);
|
||||
|
||||
let (input, _) = tag("]")(input)?;
|
||||
|
||||
Ok((input, value.unwrap_or(String::new())))
|
||||
}
|
||||
|
||||
fn parse_propval_text<'a, E: nom::error::ParseError<&'a str>>(
|
||||
input: &'a str,
|
||||
) -> IResult<&'a str, Option<String>, E> {
|
||||
let (input, value) = opt(escaped_transform(
|
||||
none_of("\\]"),
|
||||
'\\',
|
||||
alt((
|
||||
value("]", tag("]")),
|
||||
value("\\", tag("\\")),
|
||||
value("", tag("\n")),
|
||||
)),
|
||||
))(input)?;
|
||||
Ok((input, value.map(|v| v.to_owned())))
|
||||
}
|
||||
|
||||
pub fn parse_size<'a, E: nom::error::ParseError<&'a str>>(
|
||||
input: &'a str,
|
||||
) -> IResult<&'a str, Size, E> {
|
||||
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 }))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod test {
|
||||
use std::{fs::File, io::Read};
|
||||
|
||||
use super::*;
|
||||
|
||||
const EXAMPLE: &'static 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 {
|
||||
ident: "C".to_owned(),
|
||||
values: vec!["a".to_owned()]
|
||||
}
|
||||
);
|
||||
|
||||
let (_, prop) = parse_property::<nom::error::VerboseError<&str>>("C[a][b][c]").unwrap();
|
||||
assert_eq!(
|
||||
prop,
|
||||
Property {
|
||||
ident: "C".to_owned(),
|
||||
values: vec!["a".to_owned(), "b".to_owned(), "c".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 {
|
||||
ident: "B".to_owned(),
|
||||
values: vec!["ab".to_owned()]
|
||||
}]
|
||||
}
|
||||
);
|
||||
|
||||
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 {
|
||||
ident: "B".to_owned(),
|
||||
values: vec!["ab".to_owned()]
|
||||
}]
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
#[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,
|
||||
Tree {
|
||||
sequence: vec![
|
||||
Node {
|
||||
properties: vec![Property {
|
||||
ident: "B".to_owned(),
|
||||
values: vec!["ab".to_owned()]
|
||||
}]
|
||||
},
|
||||
Node {
|
||||
properties: vec![Property {
|
||||
ident: "W".to_owned(),
|
||||
values: vec!["dp".to_owned()]
|
||||
}]
|
||||
},
|
||||
Node {
|
||||
properties: vec![
|
||||
Property {
|
||||
ident: "B".to_owned(),
|
||||
values: vec!["pq".to_owned()]
|
||||
},
|
||||
Property {
|
||||
ident: "C".to_owned(),
|
||||
values: vec!["some comments".to_owned()]
|
||||
}
|
||||
]
|
||||
}
|
||||
],
|
||||
sub_sequences: vec![],
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn it_can_parse_a_sequence_with_subsequences() {
|
||||
let text = "(;C[a];C[b](;C[c])(;C[d];C[e]))";
|
||||
let (_, sequence) = parse_tree::<nom::error::VerboseError<&str>>(text).unwrap();
|
||||
|
||||
let main_sequence = vec![
|
||||
Node {
|
||||
properties: vec![Property {
|
||||
ident: "C".to_owned(),
|
||||
values: vec!["a".to_owned()],
|
||||
}],
|
||||
},
|
||||
Node {
|
||||
properties: vec![Property {
|
||||
ident: "C".to_owned(),
|
||||
values: vec!["b".to_owned()],
|
||||
}],
|
||||
},
|
||||
];
|
||||
let subsequence_1 = Tree {
|
||||
sequence: vec![Node {
|
||||
properties: vec![Property {
|
||||
ident: "C".to_owned(),
|
||||
values: vec!["c".to_owned()],
|
||||
}],
|
||||
}],
|
||||
sub_sequences: vec![],
|
||||
};
|
||||
let subsequence_2 = Tree {
|
||||
sequence: vec![
|
||||
Node {
|
||||
properties: vec![Property {
|
||||
ident: "C".to_owned(),
|
||||
values: vec!["d".to_owned()],
|
||||
}],
|
||||
},
|
||||
Node {
|
||||
properties: vec![Property {
|
||||
ident: "C".to_owned(),
|
||||
values: vec!["e".to_owned()],
|
||||
}],
|
||||
},
|
||||
],
|
||||
sub_sequences: vec![],
|
||||
};
|
||||
|
||||
assert_eq!(
|
||||
sequence,
|
||||
Tree {
|
||||
sequence: main_sequence,
|
||||
sub_sequences: vec![subsequence_1, subsequence_2],
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn it_can_parse_example_1() {
|
||||
let (_, ex_tree) = parse_tree::<nom::error::VerboseError<&str>>(EXAMPLE).unwrap();
|
||||
assert_eq!(ex_tree.sequence.len(), 1);
|
||||
|
||||
assert_eq!(ex_tree.sequence[0].properties.len(), 2);
|
||||
assert_eq!(
|
||||
ex_tree.sequence[0].properties[0],
|
||||
Property {
|
||||
ident: "FF".to_owned(),
|
||||
values: vec!["4".to_owned()]
|
||||
}
|
||||
);
|
||||
assert_eq!(ex_tree.sub_sequences.len(), 2);
|
||||
|
||||
assert_eq!(ex_tree.sub_sequences[0].sequence.len(), 2);
|
||||
assert_eq!(
|
||||
ex_tree.sub_sequences[0].sequence,
|
||||
vec![
|
||||
Node {
|
||||
properties: vec![Property {
|
||||
ident: "C".to_owned(),
|
||||
values: vec!["a".to_owned()]
|
||||
}]
|
||||
},
|
||||
Node {
|
||||
properties: vec![Property {
|
||||
ident: "C".to_owned(),
|
||||
values: vec!["b".to_owned()]
|
||||
}]
|
||||
},
|
||||
]
|
||||
);
|
||||
assert_eq!(ex_tree.sub_sequences[0].sub_sequences.len(), 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn it_can_regenerate_the_tree() {
|
||||
let (_, tree1) = parse_tree::<nom::error::VerboseError<&str>>(EXAMPLE).unwrap();
|
||||
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, tree2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn it_parses_propvals() {
|
||||
let (_, propval) = parse_propval::<nom::error::VerboseError<&str>>("[]").unwrap();
|
||||
assert_eq!(propval, "".to_owned());
|
||||
|
||||
let (_, propval) =
|
||||
parse_propval::<nom::error::VerboseError<&str>>("[normal propval]").unwrap();
|
||||
assert_eq!(propval, "normal propval".to_owned());
|
||||
|
||||
let (_, propval) =
|
||||
parse_propval::<nom::error::VerboseError<&str>>(r"[need an [escape\] in the propval]")
|
||||
.unwrap();
|
||||
assert_eq!(propval, "need an [escape] in the propval".to_owned());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn it_parses_propvals_with_hard_linebreaks() {
|
||||
let (_, propval) = parse_propval_text::<nom::error::VerboseError<&str>>(
|
||||
"There are hard linebreaks & soft linebreaks.
|
||||
Soft linebreaks...",
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
propval,
|
||||
Some(
|
||||
"There are hard linebreaks & soft linebreaks.
|
||||
Soft linebreaks..."
|
||||
.to_owned()
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn it_parses_propvals_with_escaped_closing_brackets() {
|
||||
let (_, propval) =
|
||||
parse_propval_text::<nom::error::VerboseError<&str>>(r"escaped closing \] bracket")
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
propval,
|
||||
Some(r"escaped closing ] bracket".to_owned()).to_owned()
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn it_parses_propvals_with_soft_linebreaks() {
|
||||
let (_, propval) = parse_propval_text::<nom::error::VerboseError<&str>>(
|
||||
r"Soft linebreaks are linebreaks preceeded by '\\' like this one >o\
|
||||
k<. Hard line breaks are all other linebreaks.",
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
propval,
|
||||
Some("Soft linebreaks are linebreaks preceeded by '\\' like this one >ok<. Hard line breaks are all other linebreaks.".to_owned())
|
||||
.to_owned()
|
||||
);
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue