0.5.1

add option to use San instead of SanPlus

Author: tigerros

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rpgn"
-version = "0.5.0"
+version = "0.5.1"
 edition = "2021"
 authors = ["Leonard D. <tigerros.gh@gmail.com>"]
 description = "A crate for parsing PGNs (Portable [Chess] Game Notation)."

benches/pgn.rs

@@ -2,12 +2,13 @@ use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
 use rpgn::samples::{sans0, sans1, variation0, variation1, variation2, PgnSample};
 use rpgn::Pgn;
 use rpgn::{Sans, Variation};
+use shakmaty::san::SanPlus;
 
-fn sans_samples() -> [PgnSample<Sans>; 2] {
+fn sans_samples() -> [PgnSample<Sans<SanPlus>>; 2] {
     [sans0(), sans1()]
 }
 
-fn variation_samples() -> [PgnSample<Variation>; 3] {
+fn variation_samples() -> [PgnSample<Variation<SanPlus>>; 3] {
     [variation0(), variation1(), variation2()]
 }
 
@@ -69,7 +70,7 @@ pub fn from_pgn(c: &mut Criterion) {
         group.bench_with_input(
             BenchmarkId::from_parameter(id),
             &pgn_string,
-            |b, pgn_string| b.iter(|| Pgn::<Sans>::from_str(pgn_string)),
+            |b, pgn_string| b.iter(|| Pgn::<Sans<SanPlus>>::from_str(pgn_string)),
         );
     }
 
@@ -89,7 +90,7 @@ pub fn from_pgn(c: &mut Criterion) {
         group.bench_with_input(
             BenchmarkId::from_parameter(id),
             &pgn_string,
-            |b, pgn_string| b.iter(|| Pgn::<Variation>::from_str(pgn_string)),
+            |b, pgn_string| b.iter(|| Pgn::<Variation<SanPlus>>::from_str(pgn_string)),
         );
     }
 

examples/example.rs

@@ -1,4 +1,5 @@
 use rpgn::{Pgn, Sans, Variation};
+use shakmaty::san::{San, SanPlus};
 
 const PGN: &str = r#"[Event "Live Chess"]
 [Site "Chess.com"]
@@ -34,9 +35,9 @@ Bg4 9. Qa1 d4 10. h3 dxe3 11. fxe3 Bf5 12. Nf3 Nb4 13. O-O Nxc2 14. Nxc2 Bxc2
 Bxg7 Qd7 22. Bh6 Ne4 23. Bg4 Qe7 (23... Qe7 24. Be6+) 1-0"#;
 
 fn main() {
-    let simple_pgn = Pgn::<Sans>::from_str(PGN);
-    let variation_pgn = Pgn::<Variation>::from_str(PGN);
+    let simple_pgn = Pgn::<Sans<San>>::from_str(PGN);
+    let full_pgn = Pgn::<Variation<SanPlus>>::from_str(PGN);
 
-    println!("Simple parsed PGN: {simple_pgn:#?}");
-    println!("Parsed PGN with variations: {variation_pgn:#?}");
+    println!("Parsed PGN with simple movetext: {simple_pgn:#?}");
+    println!("Parsed PGN with variations: {full_pgn:#?}");
 }

src/movetext/sans.rs

@@ -1,16 +1,21 @@
-use shakmaty::san::SanPlus;
+use shakmaty::san::{San, SanPlus};
 use std::fmt::{Display, Formatter, Write};
 use crate::{MoveNumber, Movetext};
+use crate::movetext::{SanWithVariations, Variation};
 
-/// Use if you don't care about variations.
+/// A vec of SANs. Use if you don't care about variations.
+/// 
+/// Why is there a generic? To allow usage of either a [`San`] or a [`SanPlus`].
+/// A [`San`] is often sufficient and is smaller than a [`SanPlus`], so use a [`San`]
+/// unless you need the [`SanPlus`] suffix.
+/// 
+/// Only implements [`Movetext`] if `S` is [`San`] or [`SanPlus`].
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Sans(pub Vec<SanPlus>);
-
-use crate::movetext::{SanWithVariations, Variation};
+pub struct Sans<S>(pub Vec<S>);
 
-impl From<Variation> for Sans {
+impl<S> From<Variation<S>> for Sans<S> {
     /// Takes the root variation of the given [`Variation`] and transfers it to a [`Sans`].
-    fn from(variation: Variation) -> Self {
+    fn from(variation: Variation<S>) -> Self {
         let mut san_vec = Self(Vec::with_capacity(variation.0.len()));
 
         for SanWithVariations { san, .. } in variation.0 {
@@ -21,7 +26,7 @@ impl From<Variation> for Sans {
     }
 }
 
-impl Display for Sans {
+impl<S> Display for Sans<S> where S: Display {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         let mut move_number = MoveNumber(0);
         let mut first_move = true;
@@ -54,10 +59,23 @@ impl Display for Sans {
     }
 }
 
-impl Movetext for Sans {
-    type Agent = Self;
+macro_rules! base_movetext_impl {
+    () => {
+        type Agent = Self;
+
+        fn begin_game() -> Self { Self(Vec::with_capacity(100)) }
+        fn end_game(agent: Self) -> Self { agent }
+    };
+}
+
+impl Movetext for Sans<San> {
+    base_movetext_impl! {}
+
+    fn san(agent: &mut Self, san: SanPlus) { agent.0.push(san.san); }
+}
 
-    fn begin_game() -> Self { Self(Vec::with_capacity(100)) }
+impl Movetext for Sans<SanPlus> {
+    base_movetext_impl! {}
+    
     fn san(agent: &mut Self, san: SanPlus) { agent.0.push(san); }
-    fn end_game(agent: Self) -> Self { agent }
 }

src/movetext/variation.rs

@@ -1,20 +1,23 @@
 use std::fmt::{Display, Formatter, Write};
 use pgn_reader::Skip;
-use shakmaty::san::SanPlus;
+use shakmaty::san::{San, SanPlus};
 use crate::{MoveNumber, Movetext, movetext::Sans};
 
+/// See [`Variation`].
 #[derive(Debug, PartialEq, Eq, Clone)]
-pub struct SanWithVariations {
-    pub san: SanPlus,
-    pub variations: Vec<Variation>,
+pub struct SanWithVariations<S> {
+    pub san: S,
+    pub variations: Vec<Variation<S>>,
 }
 
+/// A vec of SANs with variations. Use if you do care about variations.
+///
+/// Regarding the generic `S`, see the docs for [`Sans`].
 #[derive(Debug, PartialEq, Eq, Clone)]
-/// Use if you do care about variations.
-pub struct Variation(pub Vec<SanWithVariations>);
+pub struct Variation<S>(pub Vec<SanWithVariations<S>>);
 
-impl From<Sans> for Variation {
-    fn from(san_vec: Sans) -> Self {
+impl<S> From<Sans<S>> for Variation<S> {
+    fn from(san_vec: Sans<S>) -> Self {
         let mut variation_movetext = Self(Vec::with_capacity(san_vec.0.len()));
 
         for san in san_vec.0 {
@@ -25,7 +28,7 @@ impl From<Sans> for Variation {
     }
 }
 
-impl Variation {
+impl<S> Variation<S> where S: Display {
     fn fmt(&self, f: &mut Formatter<'_>, mut move_number: MoveNumber, mut very_first_move: bool) -> std::fmt::Result {
         for SanWithVariations { san, variations } in &self.0 {
             if very_first_move {
@@ -62,7 +65,7 @@ impl Variation {
     }
 }
 
-impl Display for Variation {
+impl<S> Display for Variation<S> where S: Display {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         self.fmt(f, MoveNumber::MIN, true)
     }
@@ -71,45 +74,63 @@ impl Display for Variation {
 #[derive(Debug)]
 #[doc(hidden)]
 /// Only used in [`Variation`]'s implementation of [`Movetext`].
-pub struct VariationAgent {
-    root_variation: Variation,
-    variation_layers: Vec<Variation>
+pub struct VariationAgent<S> {
+    root_variation: Variation<S>,
+    variation_layers: Vec<Variation<S>>
 }
 
-impl Movetext for Variation {
-    type Agent = VariationAgent;
+macro_rules! base_movetext_impl {
+    () => {
+        fn begin_game() -> Self::Agent {
+            VariationAgent {
+                root_variation: Self(Vec::new()),
+                variation_layers: Vec::new()
+            }
+        }
 
-    fn begin_game() -> Self::Agent {
-        VariationAgent {
-            root_variation: Self(Vec::new()),
-            variation_layers: Vec::new()
+        fn begin_variation(agent: &mut Self::Agent) -> Skip {
+            agent.variation_layers.push(Self(Vec::new()));
+
+            Skip(false)
         }
-    }
 
-    fn begin_variation(agent: &mut Self::Agent) -> Skip {
-        agent.variation_layers.push(Self(Vec::new()));
+        fn end_variation(agent: &mut Self::Agent) {
+            let Some(ending_variation) = agent.variation_layers.pop() else {
+                return;
+            };
 
-        Skip(false)
-    }
+            let ending_variation_parent = agent.variation_layers.last_mut().unwrap_or(&mut agent.root_variation);
+
+            #[allow(clippy::unwrap_used)]
+            ending_variation_parent.0.last_mut().unwrap().variations.push(ending_variation);
+        }
+
+        fn end_game(agent: Self::Agent) -> Self {
+            agent.root_variation
+        }
+    };
+}
 
-    fn end_variation(agent: &mut Self::Agent) {
-        let Some(ending_variation) = agent.variation_layers.pop() else {
-            return;
-        };
+impl Movetext for Variation<San> {
+    type Agent = VariationAgent<San>;
 
-        let ending_variation_parent = agent.variation_layers.last_mut().unwrap_or(&mut agent.root_variation);
+    fn san(agent: &mut Self::Agent, san: SanPlus) {
+        let current_variation = agent.variation_layers.last_mut().unwrap_or(&mut agent.root_variation);
 
-        #[allow(clippy::unwrap_used)]
-        ending_variation_parent.0.last_mut().unwrap().variations.push(ending_variation);
+        current_variation.0.push(SanWithVariations { san: san.san, variations: Vec::new() });
     }
 
+    base_movetext_impl! {}
+}
+
+impl Movetext for Variation<SanPlus> {
+    type Agent = VariationAgent<SanPlus>;
+
     fn san(agent: &mut Self::Agent, san: SanPlus) {
         let current_variation = agent.variation_layers.last_mut().unwrap_or(&mut agent.root_variation);
 
         current_variation.0.push(SanWithVariations { san, variations: Vec::new() });
     }
 
-    fn end_game(agent: Self::Agent) -> Self {
-        agent.root_variation
-    }
+    base_movetext_impl! {}
 }

src/pgn.rs

@@ -6,6 +6,7 @@ use shakmaty::fen::{Fen, ParseFenError};
 use super::visitor::{Visitor};
 use crate::{Eco, Outcome, Date, Round, RawHeaderOwned, Movetext};
 
+/// The generic `M` should be a struct that implements [`Movetext`].
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct Pgn<M> {
     /// See "Event" under "Seven Tag Roster".
@@ -164,20 +165,21 @@ impl<M> Display for Pgn<M> where M: Display {
 #[allow(clippy::unreachable)]
 #[allow(clippy::panic)]
 mod tests {
+    use shakmaty::san::SanPlus;
     use test_case::test_case;
     use crate::movetext::{Sans, Variation};
     use crate::samples::*;
 
     #[test_case(&sans0())]
     #[test_case(&sans1())]
-    fn san_vec_to_pgn_from_pgn(sample: &PgnSample<Sans>) {
+    fn san_vec_to_pgn_from_pgn(sample: &PgnSample<Sans<SanPlus>>) {
         sample.test();
     }
 
     #[test_case(&variation0())]
     #[test_case(&variation1())]
     #[test_case(&variation2())]
-    fn variation_to_pgn_from_pgn(sample: &PgnSample<Variation>) {
+    fn variation_to_pgn_from_pgn(sample: &PgnSample<Variation<SanPlus>>) {
         sample.test();
     }
 }

src/samples.rs

@@ -13,6 +13,7 @@ use pgn_reader::RawHeader;
 #[cfg(test)]
 use pretty_assertions::assert_eq;
 use shakmaty::fen::Fen;
+use shakmaty::san::SanPlus;
 use shakmaty::Color;
 use std::fmt::Debug;
 #[cfg(test)]
@@ -60,7 +61,7 @@ where
     }
 }
 
-pub fn variation0() -> PgnSample<Variation> {
+pub fn variation0() -> PgnSample<Variation<SanPlus>> {
     const PGN: &str = r#"[Event "Let's Play!"]
 [Site "Chess.com"]
 [Date "2024.02.14"]
@@ -112,7 +113,7 @@ pub fn variation0() -> PgnSample<Variation> {
     )
 }
 
-pub fn variation1() -> PgnSample<Variation> {
+pub fn variation1() -> PgnSample<Variation<SanPlus>> {
     const PGN: &str = r#"[Event "Live Chess"]
 [Site "Lichess"]
 [Date "2024.02.??"]
@@ -156,7 +157,7 @@ pub fn variation1() -> PgnSample<Variation> {
     )
 }
 
-pub fn variation2() -> PgnSample<Variation> {
+pub fn variation2() -> PgnSample<Variation<SanPlus>> {
     const PGN: &str = r#"[Date "????.01.??"]
 [Round "1"]
 [Result "1/2-1/2"]
@@ -200,7 +201,7 @@ pub fn variation2() -> PgnSample<Variation> {
 }
 
 /// Nd2 is ambiguous, but we don't care.
-pub fn sans0() -> PgnSample<Sans> {
+pub fn sans0() -> PgnSample<Sans<SanPlus>> {
     const PGN: &str = r#"[FEN "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"]
 
 1. Nf3 1... a6 2. d3 2... a5 3. Nd2"#;
@@ -221,7 +222,7 @@ pub fn sans0() -> PgnSample<Sans> {
 }
 
 /// One move.
-pub fn sans1() -> PgnSample<Sans> {
+pub fn sans1() -> PgnSample<Sans<SanPlus>> {
     const PGN: &str = "1. e4";
 
     let movetext = sans!(b"e4");