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

use crate::{FromString, GetVariants, Score};

/// Represents the level of [Veininess] of a cock.
/// This is an enum with five possible values: [Veininess::Invisible], [Veininess::SlightPumper], [Veininess::Normal], [Veininess::HealthyPumper], and [Veininess::Juicer].
#[derive(Debug, PartialEq, Clone)]
pub enum Veininess {
    Invisible,
    SlightPumper,
    Normal,
    HealthyPumper,
    Juicer,
}

/// Implementing [Score] trait for [Veininess] enum.
/// Each [Veininess] level corresponds to a specific score.
impl Score for Veininess {
    fn score(&self) -> u32 {
        match self {
            Veininess::Invisible => 1,
            Veininess::SlightPumper => 2,
            Veininess::Normal => 3,
            Veininess::HealthyPumper => 4,
            Veininess::Juicer => 5,
        }
    }
}

/// Implementing [GetVariants] for [Veininess] enum to provide the different variant options for [Veininess].
impl GetVariants for Veininess {
    fn get_variants() -> Vec<String> {
        vec![
            String::from("Invisible"),
            String::from("SlightPumper"),
            String::from("Normal"),
            String::from("HealthyPumper"),
            String::from("Juicer"),
        ]
    }
}

/// Implementing [FromString] for [Veininess] enum to create a [Veininess] instance from a string.
impl FromString for Veininess {
    fn from_string(veininess: &str) -> Veininess {
        match veininess {
            "Invisible" => Veininess::Invisible,
            "SlightPumper" => Veininess::SlightPumper,
            "Normal" => Veininess::Normal,
            "HealthyPumper" => Veininess::HealthyPumper,
            "Juicer" => Veininess::Juicer,
            _ => panic!("Invalid veininess"),
        }
    }
}

/// Implementing display trait for [Veininess] for formatted print.
impl std::fmt::Display for Veininess {
    /// Returns a string representation of the [Veininess] variant.
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Veininess::Invisible => write!(f, "Invisible"),
            Veininess::SlightPumper => write!(f, "SlightPumper"),
            Veininess::Normal => write!(f, "Normal"),
            Veininess::HealthyPumper => write!(f, "HealthyPumper"),
            Veininess::Juicer => write!(f, "Juicer"),
        }
    }
}

/// Tests for the [Veininess] enum
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_veininess_score() {
        assert_eq!(Veininess::Invisible.score(), 1);
        assert_eq!(Veininess::SlightPumper.score(), 2);
        assert_eq!(Veininess::Normal.score(), 3);
        assert_eq!(Veininess::HealthyPumper.score(), 4);
        assert_eq!(Veininess::Juicer.score(), 5);
    }
}