Import the new level-one parser

This is the parser that does a raw parse of the SGF file, interpreting components but not enforcing node types.

kifu/core/src/ui/elements/game_preview.rs

@@ -43,10 +43,11 @@ impl GamePreviewElement {
             Win::Time => "Timeout".to_owned(),
             Win::Forfeit => "Forfeit".to_owned(),
             Win::Score(score) => format!("{:.1}", score),
+            Win::Unknown => "Unknown".to_owned(),
         };
 
         let result = match game.info.result {
-            Some(GameResult::Annulled) => "Annulled".to_owned(),
+            Some(GameResult::Void) => "Annulled".to_owned(),
             Some(GameResult::Draw) => "Draw".to_owned(),
             Some(GameResult::Black(ref win)) => format!("Black by {}", format_win(win)),
             Some(GameResult::White(ref win)) => format!("White by {}", format_win(win)),

sgf/src/lib.rs

@@ -1,8 +1,8 @@
 mod date;
 pub use date::Date;
 
-mod tree;
+mod parser;
-pub use tree::parse_collection;
+pub use parser::parse_collection;
 
 use thiserror::Error;
 

sgf/src/tree.rs

@@ -1,547 +0,0 @@
-use crate::Error;
-use nom::{
-    branch::alt,
-    bytes::complete::{escaped_transform, tag},
-    character::complete::{alpha1, multispace0, multispace1, none_of},
-    combinator::{opt, value},
-    multi::{many0, many1, separated_list1},
-    IResult,
-};
-use std::num::ParseIntError;
-
-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, 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(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>,
-}
-
-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)
-    }
-}
-
-impl Node {
-    pub fn find_prop(&self, ident: &str) -> Option<Property> {
-        self.properties
-            .iter()
-            .find(|prop| prop.ident == ident)
-            .cloned()
-    }
-
-    pub fn next(&self) -> Option<&Node> {
-        self.next.get(0)
-    }
-}
-
-#[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> {
-    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, values) = many1(parse_propval)(input)?;
-    let (input, _) = multispace0(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)?;
-    let (input, _) = tag("[")(input)?;
-    let (input, value) = parse_propval_text(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())))
-}
-
-#[cfg(test)]
-mod test {
-    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()]
-                }],
-                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 {
-                    ident: "B".to_owned(),
-                    values: vec!["ab".to_owned()]
-                }],
-                next: vec![Node {
-                    properties: vec![Property {
-                        ident: "W".to_owned(),
-                        values: vec!["dp".to_owned()]
-                    }],
-                    next: vec![Node {
-                        properties: vec![
-                            Property {
-                                ident: "B".to_owned(),
-                                values: vec!["pq".to_owned()]
-                            },
-                            Property {
-                                ident: "C".to_owned(),
-                                values: vec!["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 {
-                    ident: "B".to_owned(),
-                    values: vec!["ab".to_owned()]
-                }],
-                next: vec![Node {
-                    properties: vec![Property {
-                        ident: "W".to_owned(),
-                        values: vec!["dp".to_owned()]
-                    }],
-                    next: vec![Node {
-                        properties: vec![
-                            Property {
-                                ident: "B".to_owned(),
-                                values: vec!["pq".to_owned()]
-                            },
-                            Property {
-                                ident: "C".to_owned(),
-                                values: vec!["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 {
-                ident: "C".to_owned(),
-                values: vec!["a".to_owned()],
-            }],
-            next: vec![Node {
-                properties: vec![Property {
-                    ident: "C".to_owned(),
-                    values: vec!["b".to_owned()],
-                }],
-                next: vec![
-                    Node {
-                        properties: vec![Property {
-                            ident: "C".to_owned(),
-                            values: vec!["c".to_owned()],
-                        }],
-                        next: vec![],
-                    },
-                    Node {
-                        properties: vec![Property {
-                            ident: "C".to_owned(),
-                            values: vec!["d".to_owned()],
-                        }],
-                        next: vec![Node {
-                            properties: vec![Property {
-                                ident: "C".to_owned(),
-                                values: vec!["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 {
-                ident: "C".to_owned(),
-                values: vec!["j".to_owned()],
-            }],
-            next: vec![],
-        };
-        let i = Node {
-            properties: vec![Property {
-                ident: "C".to_owned(),
-                values: vec!["i".to_owned()],
-            }],
-            next: vec![],
-        };
-        let h = Node {
-            properties: vec![Property {
-                ident: "C".to_owned(),
-                values: vec!["h".to_owned()],
-            }],
-            next: vec![i],
-        };
-        let g = Node {
-            properties: vec![Property {
-                ident: "C".to_owned(),
-                values: vec!["g".to_owned()],
-            }],
-            next: vec![h],
-        };
-        let f = Node {
-            properties: vec![Property {
-                ident: "C".to_owned(),
-                values: vec!["f".to_owned()],
-            }],
-            next: vec![g, j],
-        };
-        let e = Node {
-            properties: vec![Property {
-                ident: "C".to_owned(),
-                values: vec!["e".to_owned()],
-            }],
-            next: vec![],
-        };
-        let d = Node {
-            properties: vec![Property {
-                ident: "C".to_owned(),
-                values: vec!["d".to_owned()],
-            }],
-            next: vec![e],
-        };
-        let c = Node {
-            properties: vec![Property {
-                ident: "C".to_owned(),
-                values: vec!["c".to_owned()],
-            }],
-            next: vec![],
-        };
-        let b = Node {
-            properties: vec![Property {
-                ident: "C".to_owned(),
-                values: vec!["b".to_owned()],
-            }],
-            next: vec![c, d],
-        };
-        let a = Node {
-            properties: vec![Property {
-                ident: "C".to_owned(),
-                values: vec!["a".to_owned()],
-            }],
-            next: vec![b],
-        };
-        let expected = Node {
-            properties: vec![
-                Property {
-                    ident: "FF".to_owned(),
-                    values: vec!["4".to_owned()],
-                },
-                Property {
-                    ident: "C".to_owned(),
-                    values: vec!["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>>("[]").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()
-        );
-    }
-
-    #[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();
-    }
-}

sgf/src/types.rs

@@ -1,5 +1,7 @@
 use crate::date::Date;
 
+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)]
@@ -19,11 +21,120 @@ pub struct GameInfo {
 }
 
 #[derive(Clone, Debug, PartialEq)]
+pub enum GameType {
+    Go,
+    Othello,
+    Chess,
+    GomokuRenju,
+    NineMensMorris,
+    Backgammon,
+    ChineseChess,
+    Shogi,
+    LinesOfAction,
+    Ataxx,
+    Hex,
+    Jungle,
+    Neutron,
+    PhilosophersFootball,
+    Quadrature,
+    Trax,
+    Tantrix,
+    Amazons,
+    Octi,
+    Gess,
+    Twixt,
+    Zertz,
+    Plateau,
+    Yinsh,
+    Punct,
+    Gobblet,
+    Hive,
+    Exxit,
+    Hnefatal,
+    Kuba,
+    Tripples,
+    Chase,
+    TumblingDown,
+    Sahara,
+    Byte,
+    Focus,
+    Dvonn,
+    Tamsk,
+    Gipf,
+    Kropki,
+    Other(String),
+}
+
+#[derive(Debug)]
+pub enum Error {
+    // InvalidField,
+    // InvalidBoardSize,
+    Incomplete,
+    InvalidSgf(VerboseNomError),
+}
+
+#[derive(Debug)]
+pub struct VerboseNomError(nom::error::VerboseError<String>);
+
+impl From<nom::error::VerboseError<&str>> for VerboseNomError {
+    fn from(err: nom::error::VerboseError<&str>) -> Self {
+        VerboseNomError(nom::error::VerboseError {
+            errors: err
+                .errors
+                .into_iter()
+                .map(|err| (err.0.to_owned(), err.1))
+                .collect(),
+        })
+    }
+}
+
+impl From<nom::Err<nom::error::VerboseError<&str>>> for Error {
+    fn from(err: nom::Err<nom::error::VerboseError<&str>>) -> Self {
+        match err {
+            nom::Err::Incomplete(_) => Error::Incomplete,
+            nom::Err::Error(e) => Error::InvalidSgf(VerboseNomError::from(e)),
+            nom::Err::Failure(e) => Error::InvalidSgf(VerboseNomError::from(e)),
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, Error)]
+pub enum ParseError {
+    #[error("An unknown error was found")]
+    NomError(nom::error::Error<String>),
+}
+
+impl From<nom::error::Error<&str>> for ParseError {
+    fn from(err: nom::error::Error<&str>) -> Self {
+        Self::NomError(nom::error::Error {
+            input: err.input.to_owned(),
+            code: err.code,
+        })
+    }
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum Color {
+    Black,
+    White,
+}
+
+impl Color {
+    pub fn abbreviation(&self) -> String {
+        match self {
+            Color::White => "W",
+            Color::Black => "B",
+        }
+        .to_owned()
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
 pub enum GameResult {
-    Annulled,
     Draw,
     Black(Win),
     White(Win),
+    Void,
     Unknown(String),
 }
 
@@ -33,13 +144,13 @@ impl TryFrom<&str> for GameResult {
         if s == "0" {
             Ok(GameResult::Draw)
         } else if s == "Void" {
-            Ok(GameResult::Annulled)
+            Ok(GameResult::Void)
         } else {
             let parts = s.split('+').collect::<Vec<&str>>();
             let res = match parts[0].to_ascii_lowercase().as_str() {
                 "b" => GameResult::Black,
                 "w" => GameResult::White,
-                _ => return Ok(GameResult::Unknown(parts[0].to_owned())),
+                res => return Ok(GameResult::Unknown(res.to_owned())),
             };
             match parts[1].to_ascii_lowercase().as_str() {
                 "r" | "resign" => Ok(res(Win::Resignation)),
@@ -60,4 +171,5 @@ pub enum Win {
     Resignation,
     Forfeit,
     Time,
+    Unknown,
 }