chess-notation-parser 0.2.3

Algebraic chess notation parser
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

use std::fmt;

/// Chess pieces
#[derive(Ord, PartialOrd, Debug, PartialEq, Eq, Copy, Clone)]
pub enum Piece {
    King,
    Queen,
    Rook,
    Knight,
    Bishop,
    Pawn,
}

impl TryFrom<&str> for Piece {
    type Error = &'static str;

    fn try_from(piece: &str) -> Result<Self, Self::Error> {
        Ok(match piece {
            "K" => Self::King,
            "Q" => Self::Queen,
            "R" => Self::Rook,
            "B" => Self::Bishop,
            "N" => Self::Knight,
            "P" => Self::Pawn,
            _ => return Err("Invalid piece character"),
        })
    }
}

impl fmt::Display for Piece {
    #[rustfmt::skip]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", match self {
            Self::King => "King",
            Self::Queen => "Queen",
            Self::Rook => "Rook",
            Self::Knight => "Knight",
            Self::Bishop => "Bishop",
            Self::Pawn => "Pawn",
        })
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn print_player() {
        assert_eq!("King", format!("{}", Piece::King));
        assert_eq!("Queen", format!("{}", Piece::Queen));
        assert_eq!("Rook", format!("{}", Piece::Rook));
        assert_eq!("Knight", format!("{}", Piece::Knight));
        assert_eq!("Bishop", format!("{}", Piece::Bishop));
        assert_eq!("Pawn", format!("{}", Piece::Pawn));
    }

    #[test]
    fn try_from_valid() {
        assert_eq!(Piece::try_from("K").unwrap(), Piece::King);
        assert_eq!(Piece::try_from("Q").unwrap(), Piece::Queen);
        assert_eq!(Piece::try_from("R").unwrap(), Piece::Rook);
        assert_eq!(Piece::try_from("N").unwrap(), Piece::Knight);
        assert_eq!(Piece::try_from("B").unwrap(), Piece::Bishop);
        assert_eq!(Piece::try_from("P").unwrap(), Piece::Pawn);
    }

    #[test]
    fn try_from_invalid() {
        assert!(Piece::try_from("").is_err());
        assert!(Piece::try_from("too big string").is_err());
        assert!(Piece::try_from("X").is_err());
    }
}