Set up a second layer to the SGF parser #226
|
@ -3687,6 +3687,7 @@ dependencies = [
|
||||||
"serde 1.0.193",
|
"serde 1.0.193",
|
||||||
"thiserror",
|
"thiserror",
|
||||||
"typeshare",
|
"typeshare",
|
||||||
|
"uuid 0.8.2",
|
||||||
]
|
]
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
|
|
|
@ -11,6 +11,7 @@ nom = { version = "7" }
|
||||||
serde = { version = "1", features = [ "derive" ] }
|
serde = { version = "1", features = [ "derive" ] }
|
||||||
thiserror = { version = "1"}
|
thiserror = { version = "1"}
|
||||||
typeshare = { version = "1" }
|
typeshare = { version = "1" }
|
||||||
|
uuid = { version = "0.8", features = ["v4", "serde"] }
|
||||||
|
|
||||||
[dev-dependencies]
|
[dev-dependencies]
|
||||||
cool_asserts = { version = "2" }
|
cool_asserts = { version = "2" }
|
||||||
|
|
|
@ -0,0 +1,787 @@
|
||||||
|
use crate::{
|
||||||
|
parser::{self, Annotation, Evaluation, Move, SetupInstr, Size, UnknownProperty},
|
||||||
|
Color, Date, GameResult, GameType,
|
||||||
|
};
|
||||||
|
use std::{collections::HashSet, time::Duration};
|
||||||
|
use uuid::Uuid;
|
||||||
|
|
||||||
|
#[derive(Clone, Debug, PartialEq)]
|
||||||
|
pub enum GameError {
|
||||||
|
InvalidGame,
|
||||||
|
RequiredPropertiesMissing,
|
||||||
|
InvalidGameNode(GameNodeError),
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Clone, Debug, PartialEq)]
|
||||||
|
pub enum MoveNodeError {
|
||||||
|
IncompatibleProperty(parser::Property),
|
||||||
|
ConflictingProperty,
|
||||||
|
NotAMoveNode,
|
||||||
|
ChildError(Box<GameNodeError>),
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Clone, Debug, PartialEq)]
|
||||||
|
pub enum SetupNodeError {
|
||||||
|
IncompatibleProperty(parser::Property),
|
||||||
|
ConflictingProperty,
|
||||||
|
ConflictingPosition,
|
||||||
|
NotASetupNode,
|
||||||
|
ChildError(Box<GameNodeError>),
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Clone, Debug, PartialEq)]
|
||||||
|
pub enum GameNodeError {
|
||||||
|
UnsupportedGameNode(MoveNodeError, SetupNodeError),
|
||||||
|
ConflictingProperty,
|
||||||
|
ConflictingPosition,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Clone, Debug, PartialEq, Default)]
|
||||||
|
pub struct Player {
|
||||||
|
pub name: Option<String>,
|
||||||
|
pub rank: Option<String>,
|
||||||
|
pub team: Option<String>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Clone, Debug, PartialEq)]
|
||||||
|
pub struct Game {
|
||||||
|
game_type: GameType,
|
||||||
|
|
||||||
|
// TODO: board size is not necessary in all games. Hive has no defined board size.
|
||||||
|
board_size: Size,
|
||||||
|
black_player: Player,
|
||||||
|
white_player: Player,
|
||||||
|
|
||||||
|
app: Option<String>,
|
||||||
|
annotator: Option<String>,
|
||||||
|
copyright: Option<String>,
|
||||||
|
dates: Vec<Date>,
|
||||||
|
event: Option<String>,
|
||||||
|
game_name: Option<String>,
|
||||||
|
extra_info: Option<String>,
|
||||||
|
opening_info: Option<String>,
|
||||||
|
location: Option<String>,
|
||||||
|
result: Option<GameResult>,
|
||||||
|
round: Option<String>,
|
||||||
|
rules: Option<String>,
|
||||||
|
source: Option<String>,
|
||||||
|
time_limit: Option<Duration>,
|
||||||
|
overtime: Option<String>,
|
||||||
|
transcriber: Option<String>,
|
||||||
|
|
||||||
|
children: Vec<GameNode>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Game {
|
||||||
|
pub fn new(
|
||||||
|
game_type: GameType,
|
||||||
|
board_size: Size,
|
||||||
|
black_player: Player,
|
||||||
|
white_player: Player,
|
||||||
|
) -> Self {
|
||||||
|
Self {
|
||||||
|
game_type,
|
||||||
|
board_size,
|
||||||
|
black_player,
|
||||||
|
white_player,
|
||||||
|
|
||||||
|
app: None,
|
||||||
|
annotator: None,
|
||||||
|
copyright: None,
|
||||||
|
dates: vec![],
|
||||||
|
event: None,
|
||||||
|
game_name: None,
|
||||||
|
extra_info: None,
|
||||||
|
opening_info: None,
|
||||||
|
location: None,
|
||||||
|
result: None,
|
||||||
|
round: None,
|
||||||
|
rules: None,
|
||||||
|
source: None,
|
||||||
|
time_limit: None,
|
||||||
|
overtime: None,
|
||||||
|
transcriber: None,
|
||||||
|
|
||||||
|
children: vec![],
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Node for Game {
|
||||||
|
fn children<'a>(&'a self) -> Vec<&'a GameNode> {
|
||||||
|
self.children.iter().collect::<Vec<&'a GameNode>>()
|
||||||
|
}
|
||||||
|
|
||||||
|
fn add_child<'a>(&'a mut self, node: GameNode) -> &'a mut GameNode {
|
||||||
|
self.children.push(node);
|
||||||
|
self.children.last_mut().unwrap()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl TryFrom<&parser::Tree> for Game {
|
||||||
|
type Error = GameError;
|
||||||
|
|
||||||
|
fn try_from(tree: &parser::Tree) -> Result<Self, Self::Error> {
|
||||||
|
let mut ty = None;
|
||||||
|
let mut size = None;
|
||||||
|
let mut black_player = Player {
|
||||||
|
name: None,
|
||||||
|
rank: None,
|
||||||
|
team: None,
|
||||||
|
};
|
||||||
|
let mut white_player = Player {
|
||||||
|
name: None,
|
||||||
|
rank: None,
|
||||||
|
team: None,
|
||||||
|
};
|
||||||
|
|
||||||
|
for prop in tree.root.properties.iter() {
|
||||||
|
match prop {
|
||||||
|
parser::Property::GameType(ty_) => ty = Some(ty_.clone()),
|
||||||
|
parser::Property::BoardSize(size_) => size = Some(size_.clone()),
|
||||||
|
parser::Property::BlackPlayer(name) => {
|
||||||
|
black_player.name = Some(name.clone());
|
||||||
|
}
|
||||||
|
parser::Property::WhitePlayer(name) => {
|
||||||
|
white_player.name = Some(name.clone());
|
||||||
|
}
|
||||||
|
parser::Property::BlackRank(rank) => {
|
||||||
|
black_player.rank = Some(rank.clone());
|
||||||
|
}
|
||||||
|
parser::Property::WhiteRank(rank) => {
|
||||||
|
white_player.rank = Some(rank.clone());
|
||||||
|
}
|
||||||
|
parser::Property::BlackTeam(team) => {
|
||||||
|
black_player.team = Some(team.clone());
|
||||||
|
}
|
||||||
|
parser::Property::WhiteTeam(team) => {
|
||||||
|
white_player.team = Some(team.clone());
|
||||||
|
}
|
||||||
|
_ => {}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
let mut s = match (ty, size) {
|
||||||
|
(Some(ty), Some(size)) => Ok(Self::new(ty, size, black_player, white_player)),
|
||||||
|
_ => Err(Self::Error::RequiredPropertiesMissing),
|
||||||
|
}?;
|
||||||
|
|
||||||
|
for prop in tree.root.properties.iter() {
|
||||||
|
match prop {
|
||||||
|
parser::Property::GameType(_)
|
||||||
|
| parser::Property::BoardSize(_)
|
||||||
|
| parser::Property::BlackPlayer(_)
|
||||||
|
| parser::Property::WhitePlayer(_)
|
||||||
|
| parser::Property::BlackRank(_)
|
||||||
|
| parser::Property::WhiteRank(_)
|
||||||
|
| parser::Property::BlackTeam(_)
|
||||||
|
| parser::Property::WhiteTeam(_) => {}
|
||||||
|
parser::Property::Application(v) => s.app = Some(v.clone()),
|
||||||
|
parser::Property::Annotator(v) => s.annotator = Some(v.clone()),
|
||||||
|
parser::Property::Copyright(v) => s.copyright = Some(v.clone()),
|
||||||
|
parser::Property::EventDates(v) => s.dates = v.clone(),
|
||||||
|
parser::Property::EventName(v) => s.event = Some(v.clone()),
|
||||||
|
parser::Property::GameName(v) => s.game_name = Some(v.clone()),
|
||||||
|
parser::Property::ExtraGameInformation(v) => s.extra_info = Some(v.clone()),
|
||||||
|
parser::Property::GameOpening(v) => s.opening_info = Some(v.clone()),
|
||||||
|
parser::Property::GameLocation(v) => s.location = Some(v.clone()),
|
||||||
|
parser::Property::Result(v) => s.result = Some(v.clone()),
|
||||||
|
parser::Property::Round(v) => s.round = Some(v.clone()),
|
||||||
|
parser::Property::Ruleset(v) => s.rules = Some(v.clone()),
|
||||||
|
parser::Property::Source(v) => s.source = Some(v.clone()),
|
||||||
|
parser::Property::TimeLimit(v) => s.time_limit = Some(v.clone()),
|
||||||
|
parser::Property::Overtime(v) => s.overtime = Some(v.clone()),
|
||||||
|
// parser::Property::Data(v) => s.transcriber = Some(v.clone()),
|
||||||
|
_ => {}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
s.children = tree
|
||||||
|
.root
|
||||||
|
.next
|
||||||
|
.iter()
|
||||||
|
.map(|node| GameNode::try_from(node))
|
||||||
|
.collect::<Result<Vec<GameNode>, GameNodeError>>()
|
||||||
|
.map_err(GameError::InvalidGameNode)?;
|
||||||
|
|
||||||
|
Ok(s)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Clone, Debug, PartialEq)]
|
||||||
|
pub enum GameNode {
|
||||||
|
MoveNode(MoveNode),
|
||||||
|
SetupNode(SetupNode),
|
||||||
|
}
|
||||||
|
|
||||||
|
pub trait Node {
|
||||||
|
/// Provide a pre-order traversal of all of the nodes in the game tree.
|
||||||
|
fn nodes<'a>(&'a self) -> Vec<&'a GameNode> {
|
||||||
|
self.children()
|
||||||
|
.iter()
|
||||||
|
.map(|node| {
|
||||||
|
let mut children = node.nodes();
|
||||||
|
let mut v = vec![*node];
|
||||||
|
v.append(&mut children);
|
||||||
|
v
|
||||||
|
})
|
||||||
|
.flatten()
|
||||||
|
.collect::<Vec<&'a GameNode>>()
|
||||||
|
}
|
||||||
|
|
||||||
|
fn children<'a>(&'a self) -> Vec<&'a GameNode>;
|
||||||
|
fn add_child<'a>(&'a mut self, node: GameNode) -> &'a mut GameNode;
|
||||||
|
}
|
||||||
|
|
||||||
|
impl GameNode {
|
||||||
|
pub fn id(&self) -> Uuid {
|
||||||
|
match self {
|
||||||
|
GameNode::MoveNode(node) => node.id,
|
||||||
|
GameNode::SetupNode(node) => node.id,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Node for GameNode {
|
||||||
|
fn children<'a>(&'a self) -> Vec<&'a GameNode> {
|
||||||
|
match self {
|
||||||
|
GameNode::MoveNode(node) => node.children(),
|
||||||
|
GameNode::SetupNode(node) => node.children(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn nodes<'a>(&'a self) -> Vec<&'a GameNode> {
|
||||||
|
match self {
|
||||||
|
GameNode::MoveNode(node) => node.nodes(),
|
||||||
|
GameNode::SetupNode(node) => node.nodes(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn add_child<'a>(&'a mut self, new_node: GameNode) -> &'a mut GameNode {
|
||||||
|
match self {
|
||||||
|
GameNode::MoveNode(node) => node.add_child(new_node),
|
||||||
|
GameNode::SetupNode(node) => node.add_child(new_node),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl TryFrom<&parser::Node> for GameNode {
|
||||||
|
type Error = GameNodeError;
|
||||||
|
fn try_from(n: &parser::Node) -> Result<Self, Self::Error> {
|
||||||
|
let move_node = MoveNode::try_from(n);
|
||||||
|
let setup_node = SetupNode::try_from(n);
|
||||||
|
|
||||||
|
match (move_node, setup_node) {
|
||||||
|
(Ok(node), _) => Ok(Self::MoveNode(node)),
|
||||||
|
(Err(_), Ok(node)) => Ok(Self::SetupNode(node)),
|
||||||
|
(Err(move_err), Err(setup_err)) => {
|
||||||
|
Err(Self::Error::UnsupportedGameNode(move_err, setup_err))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Clone, Debug, PartialEq)]
|
||||||
|
pub struct MoveNode {
|
||||||
|
id: Uuid,
|
||||||
|
color: Color,
|
||||||
|
mv: Move,
|
||||||
|
children: Vec<GameNode>,
|
||||||
|
|
||||||
|
time_left: Option<Duration>,
|
||||||
|
moves_left: Option<usize>,
|
||||||
|
name: Option<String>,
|
||||||
|
evaluation: Option<Evaluation>,
|
||||||
|
value: Option<f64>,
|
||||||
|
comments: Option<String>,
|
||||||
|
annotation: Option<Annotation>,
|
||||||
|
unknown_props: Vec<(String, String)>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl MoveNode {
|
||||||
|
pub fn new(color: Color, mv: Move) -> Self {
|
||||||
|
Self {
|
||||||
|
id: Uuid::new_v4(),
|
||||||
|
color,
|
||||||
|
mv,
|
||||||
|
children: Vec::new(),
|
||||||
|
|
||||||
|
time_left: None,
|
||||||
|
moves_left: None,
|
||||||
|
name: None,
|
||||||
|
evaluation: None,
|
||||||
|
value: None,
|
||||||
|
comments: None,
|
||||||
|
annotation: None,
|
||||||
|
unknown_props: vec![],
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Node for MoveNode {
|
||||||
|
fn children<'a>(&'a self) -> Vec<&'a GameNode> {
|
||||||
|
self.children.iter().collect::<Vec<&'a GameNode>>()
|
||||||
|
}
|
||||||
|
|
||||||
|
fn add_child<'a>(&'a mut self, node: GameNode) -> &'a mut GameNode {
|
||||||
|
self.children.push(node);
|
||||||
|
self.children.last_mut().unwrap()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl TryFrom<&parser::Node> for MoveNode {
|
||||||
|
type Error = MoveNodeError;
|
||||||
|
|
||||||
|
fn try_from(n: &parser::Node) -> Result<Self, Self::Error> {
|
||||||
|
let mut s = match n.mv() {
|
||||||
|
Some((color, mv)) => {
|
||||||
|
let mut s = Self::new(color, mv);
|
||||||
|
|
||||||
|
for prop in n.properties.iter() {
|
||||||
|
match prop {
|
||||||
|
parser::Property::Move((color, mv)) => {
|
||||||
|
if s.color != *color || s.mv != *mv {
|
||||||
|
return Err(Self::Error::ConflictingProperty);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
parser::Property::TimeLeft((color, duration)) => {
|
||||||
|
if s.color != *color {
|
||||||
|
return Err(Self::Error::ConflictingProperty);
|
||||||
|
}
|
||||||
|
if s.time_left.is_some() {
|
||||||
|
return Err(Self::Error::ConflictingProperty);
|
||||||
|
}
|
||||||
|
s.time_left = Some(duration.clone());
|
||||||
|
}
|
||||||
|
parser::Property::Comment(cmt) => {
|
||||||
|
if s.comments.is_some() {
|
||||||
|
return Err(Self::Error::ConflictingProperty);
|
||||||
|
}
|
||||||
|
s.comments = Some(cmt.clone());
|
||||||
|
}
|
||||||
|
parser::Property::Evaluation(evaluation) => {
|
||||||
|
if s.evaluation.is_some() {
|
||||||
|
return Err(Self::Error::ConflictingProperty);
|
||||||
|
}
|
||||||
|
s.evaluation = Some(*evaluation)
|
||||||
|
}
|
||||||
|
parser::Property::Annotation(annotation) => {
|
||||||
|
if s.annotation.is_some() {
|
||||||
|
return Err(Self::Error::ConflictingProperty);
|
||||||
|
}
|
||||||
|
s.annotation = Some(*annotation)
|
||||||
|
}
|
||||||
|
parser::Property::Unknown(UnknownProperty { ident, value }) => {
|
||||||
|
s.unknown_props.push((ident.clone(), value.clone()));
|
||||||
|
}
|
||||||
|
_ => return Err(Self::Error::IncompatibleProperty(prop.clone())),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
Ok(s)
|
||||||
|
}
|
||||||
|
None => Err(Self::Error::NotAMoveNode),
|
||||||
|
}?;
|
||||||
|
|
||||||
|
s.children = n
|
||||||
|
.next
|
||||||
|
.iter()
|
||||||
|
.map(|node| {
|
||||||
|
GameNode::try_from(node).map_err(|err| Self::Error::ChildError(Box::new(err)))
|
||||||
|
})
|
||||||
|
.collect::<Result<Vec<GameNode>, MoveNodeError>>()?;
|
||||||
|
|
||||||
|
Ok(s)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Clone, Debug, PartialEq)]
|
||||||
|
pub struct SetupNode {
|
||||||
|
id: Uuid,
|
||||||
|
|
||||||
|
positions: Vec<parser::SetupInstr>,
|
||||||
|
children: Vec<GameNode>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl SetupNode {
|
||||||
|
pub fn new(positions: Vec<parser::SetupInstr>) -> Result<Self, SetupNodeError> {
|
||||||
|
let mut board = HashSet::new();
|
||||||
|
for position in positions.iter() {
|
||||||
|
let point = match position {
|
||||||
|
SetupInstr::Piece((_, point)) => point,
|
||||||
|
SetupInstr::Clear(point) => point,
|
||||||
|
};
|
||||||
|
if board.contains(point) {
|
||||||
|
return Err(SetupNodeError::ConflictingPosition);
|
||||||
|
}
|
||||||
|
board.insert(point);
|
||||||
|
}
|
||||||
|
|
||||||
|
Ok(Self {
|
||||||
|
id: Uuid::new_v4(),
|
||||||
|
positions,
|
||||||
|
children: Vec::new(),
|
||||||
|
})
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Node for SetupNode {
|
||||||
|
fn children<'a>(&'a self) -> Vec<&'a GameNode> {
|
||||||
|
self.children.iter().collect::<Vec<&'a GameNode>>()
|
||||||
|
}
|
||||||
|
|
||||||
|
#[allow(dead_code)]
|
||||||
|
fn add_child<'a>(&'a mut self, _node: GameNode) -> &'a mut GameNode {
|
||||||
|
unimplemented!()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl TryFrom<&parser::Node> for SetupNode {
|
||||||
|
type Error = SetupNodeError;
|
||||||
|
|
||||||
|
fn try_from(n: &parser::Node) -> Result<Self, Self::Error> {
|
||||||
|
match n.setup() {
|
||||||
|
Some(elements) => Self::new(elements),
|
||||||
|
None => Err(Self::Error::NotASetupNode),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[allow(dead_code)]
|
||||||
|
pub fn path_to_node<'a>(node: &'a GameNode, id: Uuid) -> Vec<&'a GameNode> {
|
||||||
|
if node.id() == id {
|
||||||
|
return vec![node];
|
||||||
|
}
|
||||||
|
|
||||||
|
for child in node.children() {
|
||||||
|
let mut path = path_to_node(child, id);
|
||||||
|
if path.len() > 1 {
|
||||||
|
path.push(child);
|
||||||
|
return path;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
Vec::new()
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
mod test {
|
||||||
|
use super::*;
|
||||||
|
use cool_asserts::assert_matches;
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn it_can_create_an_empty_game_tree() {
|
||||||
|
let tree = Game::new(
|
||||||
|
GameType::Go,
|
||||||
|
Size {
|
||||||
|
width: 19,
|
||||||
|
height: 19,
|
||||||
|
},
|
||||||
|
Player::default(),
|
||||||
|
Player::default(),
|
||||||
|
);
|
||||||
|
assert_eq!(tree.nodes().len(), 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn it_can_add_moves_to_a_game() {
|
||||||
|
let mut game = Game::new(
|
||||||
|
GameType::Go,
|
||||||
|
Size {
|
||||||
|
width: 19,
|
||||||
|
height: 19,
|
||||||
|
},
|
||||||
|
Player::default(),
|
||||||
|
Player::default(),
|
||||||
|
);
|
||||||
|
|
||||||
|
let first_move = MoveNode::new(Color::Black, Move::Move("dd".to_owned()));
|
||||||
|
let first_ = game.add_child(GameNode::MoveNode(first_move.clone()));
|
||||||
|
let second_move = MoveNode::new(Color::White, Move::Move("qq".to_owned()));
|
||||||
|
first_.add_child(GameNode::MoveNode(second_move.clone()));
|
||||||
|
|
||||||
|
let nodes = game.nodes();
|
||||||
|
assert_eq!(nodes.len(), 2);
|
||||||
|
assert_eq!(nodes[0].id(), first_move.id);
|
||||||
|
assert_eq!(nodes[1].id(), second_move.id);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[ignore]
|
||||||
|
#[test]
|
||||||
|
fn it_can_set_up_a_game() {
|
||||||
|
unimplemented!()
|
||||||
|
}
|
||||||
|
|
||||||
|
#[ignore]
|
||||||
|
#[test]
|
||||||
|
fn it_can_load_tree_from_sgf() {
|
||||||
|
unimplemented!()
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn game_node_can_parse_sgf_move_node() {
|
||||||
|
let n = parser::Node {
|
||||||
|
properties: vec![
|
||||||
|
parser::Property::Move((Color::White, Move::Move("dp".to_owned()))),
|
||||||
|
parser::Property::TimeLeft((Color::White, Duration::from_secs(176))),
|
||||||
|
parser::Property::Comment("Comments in the game".to_owned()),
|
||||||
|
],
|
||||||
|
next: vec![],
|
||||||
|
};
|
||||||
|
assert_matches!(GameNode::try_from(&n), Ok(GameNode::MoveNode(_)));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
mod root_node_tests {
|
||||||
|
#[ignore]
|
||||||
|
#[test]
|
||||||
|
fn it_rejects_move_properties() {
|
||||||
|
unimplemented!()
|
||||||
|
}
|
||||||
|
|
||||||
|
#[ignore]
|
||||||
|
#[test]
|
||||||
|
fn it_rejects_setup_properties() {
|
||||||
|
unimplemented!()
|
||||||
|
}
|
||||||
|
|
||||||
|
#[ignore]
|
||||||
|
#[test]
|
||||||
|
fn it_can_parse_a_root_sgf() {
|
||||||
|
unimplemented!()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
mod move_node_tests {
|
||||||
|
use crate::parser::PositionList;
|
||||||
|
|
||||||
|
use super::*;
|
||||||
|
use cool_asserts::assert_matches;
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn it_can_parse_an_sgf_move_node() {
|
||||||
|
let n = parser::Node {
|
||||||
|
properties: vec![
|
||||||
|
parser::Property::Move((Color::White, Move::Move("dp".to_owned()))),
|
||||||
|
parser::Property::TimeLeft((Color::White, Duration::from_secs(176))),
|
||||||
|
parser::Property::Comment("Comments in the game".to_owned()),
|
||||||
|
],
|
||||||
|
next: vec![],
|
||||||
|
};
|
||||||
|
assert_matches!(MoveNode::try_from(&n), Ok(node) => {
|
||||||
|
assert_eq!(node.color, Color::White);
|
||||||
|
assert_eq!(node.mv, Move::Move("dp".to_owned()));
|
||||||
|
assert_eq!(node.children, vec![]);
|
||||||
|
assert_eq!(node.time_left, Some(Duration::from_secs(176)));
|
||||||
|
assert_eq!(node.comments, Some("Comments in the game".to_owned()));
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn it_rejects_an_sgf_setup_node() {
|
||||||
|
let n = parser::Node {
|
||||||
|
properties: vec![
|
||||||
|
parser::Property::Move((Color::White, Move::Move("dp".to_owned()))),
|
||||||
|
parser::Property::TimeLeft((Color::White, Duration::from_secs(176))),
|
||||||
|
parser::Property::SetupBlackStones(PositionList(vec![
|
||||||
|
"dd".to_owned(),
|
||||||
|
"de".to_owned(),
|
||||||
|
])),
|
||||||
|
],
|
||||||
|
next: vec![],
|
||||||
|
};
|
||||||
|
assert_matches!(
|
||||||
|
MoveNode::try_from(&n),
|
||||||
|
Err(MoveNodeError::IncompatibleProperty(_))
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
mod setup_node_tests {
|
||||||
|
use crate::parser::SetupInstr;
|
||||||
|
|
||||||
|
use super::*;
|
||||||
|
use cool_asserts::assert_matches;
|
||||||
|
|
||||||
|
#[ignore]
|
||||||
|
#[test]
|
||||||
|
fn it_can_parse_an_sgf_setup_node() {
|
||||||
|
unimplemented!()
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn it_rejects_conflicting_placement_properties() {
|
||||||
|
assert_matches!(
|
||||||
|
SetupNode::new(vec![
|
||||||
|
SetupInstr::Piece((Color::Black, "dd".to_owned())),
|
||||||
|
SetupInstr::Piece((Color::Black, "dd".to_owned())),
|
||||||
|
]),
|
||||||
|
Err(SetupNodeError::ConflictingPosition)
|
||||||
|
);
|
||||||
|
assert_matches!(
|
||||||
|
SetupNode::new(vec![
|
||||||
|
SetupInstr::Piece((Color::Black, "dd".to_owned())),
|
||||||
|
SetupInstr::Piece((Color::Black, "ee".to_owned())),
|
||||||
|
SetupInstr::Piece((Color::White, "ee".to_owned())),
|
||||||
|
]),
|
||||||
|
Err(SetupNodeError::ConflictingPosition)
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
mod path_test {
|
||||||
|
#[ignore]
|
||||||
|
#[test]
|
||||||
|
fn returns_empty_list_if_no_game_nodes() {
|
||||||
|
unimplemented!()
|
||||||
|
}
|
||||||
|
|
||||||
|
#[ignore]
|
||||||
|
#[test]
|
||||||
|
fn returns_empty_list_if_node_not_found() {
|
||||||
|
unimplemented!()
|
||||||
|
}
|
||||||
|
|
||||||
|
#[ignore]
|
||||||
|
#[test]
|
||||||
|
fn path_excludes_root_node() {
|
||||||
|
unimplemented!()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
mod file_test {
|
||||||
|
use super::*;
|
||||||
|
use crate::Win;
|
||||||
|
use cool_asserts::assert_matches;
|
||||||
|
use parser::parse_collection;
|
||||||
|
use std::{fs::File, io::Read};
|
||||||
|
|
||||||
|
fn with_text(text: &str, f: impl FnOnce(Vec<Game>)) {
|
||||||
|
let (_, games) = parse_collection::<nom::error::VerboseError<&str>>(text).unwrap();
|
||||||
|
let games = games
|
||||||
|
.into_iter()
|
||||||
|
.map(|game| Game::try_from(&game).expect("game to parse"))
|
||||||
|
.collect::<Vec<Game>>();
|
||||||
|
f(games);
|
||||||
|
}
|
||||||
|
|
||||||
|
fn with_file(path: &std::path::Path, f: impl FnOnce(Vec<Game>)) {
|
||||||
|
let mut file = File::open(path).unwrap();
|
||||||
|
let mut text = String::new();
|
||||||
|
let _ = file.read_to_string(&mut text);
|
||||||
|
with_text(&text, f);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[ignore]
|
||||||
|
#[test]
|
||||||
|
fn it_can_load_basic_game_records() {
|
||||||
|
with_file(
|
||||||
|
std::path::Path::new("test_data/2020 USGO DDK, Round 1.sgf"),
|
||||||
|
|games| {
|
||||||
|
assert_eq!(games.len(), 1);
|
||||||
|
let game = &games[0];
|
||||||
|
|
||||||
|
assert_eq!(game.game_type, GameType::Go);
|
||||||
|
assert_eq!(
|
||||||
|
game.board_size,
|
||||||
|
Size {
|
||||||
|
width: 19,
|
||||||
|
height: 19
|
||||||
|
}
|
||||||
|
);
|
||||||
|
assert_eq!(
|
||||||
|
game.black_player,
|
||||||
|
Player {
|
||||||
|
name: Some("savanni".to_owned()),
|
||||||
|
rank: Some("23k".to_owned()),
|
||||||
|
team: None
|
||||||
|
}
|
||||||
|
);
|
||||||
|
assert_eq!(
|
||||||
|
game.white_player,
|
||||||
|
Player {
|
||||||
|
name: Some("Geckoz".to_owned()),
|
||||||
|
rank: None,
|
||||||
|
team: None
|
||||||
|
}
|
||||||
|
);
|
||||||
|
assert_eq!(game.app, Some("CGoban:3".to_owned()));
|
||||||
|
|
||||||
|
assert_eq!(game.annotator, None);
|
||||||
|
assert_eq!(game.copyright, None);
|
||||||
|
assert_eq!(
|
||||||
|
game.dates,
|
||||||
|
vec![Date::Date(
|
||||||
|
chrono::NaiveDate::from_ymd_opt(2020, 8, 5).unwrap()
|
||||||
|
)]
|
||||||
|
);
|
||||||
|
assert_eq!(game.event, None);
|
||||||
|
assert_eq!(game.game_name, None);
|
||||||
|
assert_eq!(game.extra_info, None);
|
||||||
|
assert_eq!(game.opening_info, None);
|
||||||
|
assert_eq!(
|
||||||
|
game.location,
|
||||||
|
Some("The KGS Go Server at http://www.gokgs.com/".to_owned())
|
||||||
|
);
|
||||||
|
assert_eq!(game.result, Some(GameResult::White(Win::Score(17.5))));
|
||||||
|
assert_eq!(game.round, None);
|
||||||
|
assert_eq!(game.rules, Some("AGA".to_owned()));
|
||||||
|
assert_eq!(game.source, None);
|
||||||
|
assert_eq!(game.time_limit, Some(Duration::from_secs(1800)));
|
||||||
|
assert_eq!(game.overtime, Some("5x30 byo-yomi".to_owned()));
|
||||||
|
assert_eq!(game.transcriber, None);
|
||||||
|
|
||||||
|
/*
|
||||||
|
Property {
|
||||||
|
ident: "KM".to_owned(),
|
||||||
|
values: vec!["7.50".to_owned()],
|
||||||
|
},
|
||||||
|
];
|
||||||
|
|
||||||
|
for i in 0..16 {
|
||||||
|
assert_eq!(node.properties[i], expected_properties[i]);
|
||||||
|
}
|
||||||
|
*/
|
||||||
|
|
||||||
|
let children = game.children();
|
||||||
|
let node = children.first().unwrap();
|
||||||
|
assert_matches!(node, GameNode::MoveNode(node) => {
|
||||||
|
assert_eq!(node.color, Color::Black);
|
||||||
|
assert_eq!(node.mv, Move::Move("pp".to_owned()));
|
||||||
|
assert_eq!(node.time_left, Some(Duration::from_secs(1795)));
|
||||||
|
assert_eq!(node.comments, Some("Geckoz [?]: Good game\nsavanni [23k?]: There we go! This UI is... tough.\nsavanni [23k?]: Have fun! Talk to you at the end.\nGeckoz [?]: Yeah, OGS is much better; I'm a UX professional\n".to_owned())
|
||||||
|
)});
|
||||||
|
|
||||||
|
let children = node.children();
|
||||||
|
let node = children.first().unwrap();
|
||||||
|
assert_matches!(node, GameNode::MoveNode(node) => {
|
||||||
|
assert_eq!(node.color, Color::White);
|
||||||
|
assert_eq!(node.mv, Move::Move("dp".to_owned()));
|
||||||
|
assert_eq!(node.time_left, Some(Duration::from_secs(1765)));
|
||||||
|
assert_eq!(node.comments, None);
|
||||||
|
});
|
||||||
|
/*
|
||||||
|
let node = node.next().unwrap();
|
||||||
|
let expected_properties = vec![
|
||||||
|
Property {
|
||||||
|
ident: "W".to_owned(),
|
||||||
|
values: vec!["dp".to_owned()],
|
||||||
|
},
|
||||||
|
Property {
|
||||||
|
ident: "WL".to_owned(),
|
||||||
|
values: vec!["1765.099".to_owned()],
|
||||||
|
},
|
||||||
|
];
|
||||||
|
for i in 0..2 {
|
||||||
|
assert_eq!(node.properties[i], expected_properties[i]);
|
||||||
|
}
|
||||||
|
*/
|
||||||
|
},
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
|
@ -1,12 +1,14 @@
|
||||||
mod date;
|
mod date;
|
||||||
pub use date::Date;
|
mod game;
|
||||||
|
|
||||||
mod parser;
|
mod parser;
|
||||||
pub use parser::parse_collection;
|
|
||||||
|
|
||||||
use thiserror::Error;
|
|
||||||
|
|
||||||
mod types;
|
mod types;
|
||||||
|
|
||||||
|
pub use date::Date;
|
||||||
|
pub use game::Game;
|
||||||
|
use game::Player;
|
||||||
|
pub use parser::parse_collection;
|
||||||
|
use parser::Size;
|
||||||
|
use thiserror::Error;
|
||||||
pub use types::*;
|
pub use types::*;
|
||||||
|
|
||||||
#[derive(Debug)]
|
#[derive(Debug)]
|
||||||
|
@ -58,5 +60,21 @@ impl From<nom::error::Error<&str>> for ParseError {
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn parse_sgf(_input: &str) -> Result<Vec<Game>, Error> {
|
pub fn parse_sgf(_input: &str) -> Result<Vec<Game>, Error> {
|
||||||
Ok(vec![Game::default()])
|
Ok(vec![Game::new(
|
||||||
|
GameType::Go,
|
||||||
|
Size {
|
||||||
|
width: 19,
|
||||||
|
height: 19,
|
||||||
|
},
|
||||||
|
Player {
|
||||||
|
name: None,
|
||||||
|
rank: None,
|
||||||
|
team: None,
|
||||||
|
},
|
||||||
|
Player {
|
||||||
|
name: None,
|
||||||
|
rank: None,
|
||||||
|
team: None,
|
||||||
|
},
|
||||||
|
)])
|
||||||
}
|
}
|
||||||
|
|
|
@ -1,25 +1,5 @@
|
||||||
use crate::date::Date;
|
|
||||||
|
|
||||||
use thiserror::Error;
|
use thiserror::Error;
|
||||||
|
|
||||||
/// This is a placeholder structure. It is not meant to represent a game, only to provide a mock
|
|
||||||
/// interface for code already written that expects a Game data type to exist.
|
|
||||||
#[derive(Debug, Default)]
|
|
||||||
pub struct Game {
|
|
||||||
pub info: GameInfo,
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive(Debug, Default)]
|
|
||||||
pub struct GameInfo {
|
|
||||||
pub black_player: Option<String>,
|
|
||||||
pub black_rank: Option<String>,
|
|
||||||
pub white_player: Option<String>,
|
|
||||||
pub white_rank: Option<String>,
|
|
||||||
pub result: Option<GameResult>,
|
|
||||||
pub game_name: Option<String>,
|
|
||||||
pub date: Vec<Date>,
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive(Clone, Debug, PartialEq)]
|
#[derive(Clone, Debug, PartialEq)]
|
||||||
pub enum GameType {
|
pub enum GameType {
|
||||||
Go,
|
Go,
|
||||||
|
|
Loading…
Reference in New Issue