slidy 0.3.2

Utilities for working with sliding puzzles
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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

//! Defines ways in which a [`Move`] can be displayed.

use std::fmt::Display;

use crate::algorithm::r#move::r#move::Move;

/// Marker trait for structs that are used to display moves
pub trait MoveDisplay {
    /// Create a new [`MoveDisplay`] for displaying `mv`.
    #[must_use]
    fn new(mv: Move) -> Self;
}

macro_rules! define_display {
    ($($(#[$annot:meta])* $name:ident),* $(,)?) => {
        $(
            $(#[$annot])*
            #[derive(Clone, Debug)]
            pub struct $name(Move);

            impl MoveDisplay for $name {
                fn new(mv: Move) -> Self {
                    Self(mv)
                }
            }
        )*
    };
}

define_display!(
    /// Formats the move using one character per tile move, with spaces between them.
    ///
    /// # Example
    ///
    /// ```
    /// # use slidy::algorithm::{
    /// #     direction::Direction,
    /// #     display::r#move::{DisplayLongSpaced, MoveDisplay},
    /// #     r#move::r#move::Move,
    /// # };
    /// # use std::str::FromStr as _;
    /// let a = Move::new(Direction::Up, 5);
    /// assert_eq!(&DisplayLongSpaced::new(a).to_string(), "U U U U U");
    /// ```
    DisplayLongSpaced,
    /// Formats the move using one character per tile move.
    ///
    /// # Example
    ///
    /// ```
    /// # use slidy::algorithm::{
    /// #     direction::Direction,
    /// #     display::r#move::{DisplayLongUnspaced, MoveDisplay},
    /// #     r#move::r#move::Move,
    /// # };
    /// # use std::str::FromStr as _;
    /// let a = Move::new(Direction::Up, 5);
    /// assert_eq!(&DisplayLongUnspaced::new(a).to_string(), "UUUUU");
    /// ```
    DisplayLongUnspaced,
    /// Formats the move as a direction followed by a number.
    ///
    /// # Example
    ///
    /// ```
    /// # use slidy::algorithm::{
    /// #     direction::Direction,
    /// #     display::r#move::{DisplayShort, MoveDisplay},
    /// #     r#move::r#move::Move,
    /// # };
    /// # use std::str::FromStr as _;
    /// let a = Move::new(Direction::Up, 5);
    /// assert_eq!(&DisplayShort::new(a).to_string(), "U5");
    /// ```
    DisplayShort
);

impl Display for DisplayLongSpaced {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut s = self.0.direction.to_string();
        s.push(' ');
        s = s.repeat(self.0.amount as usize);
        s.pop();

        f.write_str(&s)
    }
}

impl Display for DisplayLongUnspaced {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(&self.0.direction.to_string().repeat(self.0.amount as usize))
    }
}

impl Display for DisplayShort {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        if self.0.amount == 1 {
            write!(f, "{}", self.0.direction)
        } else {
            write!(f, "{}{}", self.0.direction, self.0.amount)
        }
    }
}

#[cfg(test)]
mod tests {
    use crate::algorithm::{
        direction::Direction,
        display::r#move::{DisplayLongSpaced, DisplayLongUnspaced, DisplayShort},
        r#move::r#move::Move,
    };

    #[test]
    fn test_display() {
        let m = Move {
            direction: Direction::Up,
            amount: 1,
        };
        assert_eq!(DisplayLongSpaced(m).to_string(), "U");
        assert_eq!(DisplayLongUnspaced(m).to_string(), "U");
        assert_eq!(DisplayShort(m).to_string(), "U");
    }

    #[test]
    fn test_display_2() {
        let m = Move {
            direction: Direction::Up,
            amount: 3,
        };
        assert_eq!(DisplayLongSpaced(m).to_string(), "U U U");
        assert_eq!(DisplayLongUnspaced(m).to_string(), "UUU");
        assert_eq!(DisplayShort(m).to_string(), "U3");
    }
}