arvo 0.7.0

Validated, immutable value objects for common domain types (email, money, identifiers, …)
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
135
136
137
138
139
140
141
142

use crate::errors::ValidationError;
use crate::traits::ValueObject;

/// Input type for [`Isbn13`].
pub type Isbn13Input = String;

/// Output type for [`Isbn13`] — 13 bare digits.
pub type Isbn13Output = String;

/// A validated ISBN-13 number.
///
/// Hyphens and spaces are stripped on construction. Must start with `978`
/// or `979`. Check digit validated using the EAN-13 algorithm (alternating
/// weights 1 and 3, total mod 10 == 0).
///
/// # Example
///
/// ```rust,ignore
/// use arvo::identifiers::Isbn13;
/// use arvo::traits::ValueObject;
///
/// let isbn = Isbn13::new("978-0-306-40615-7".into()).unwrap();
/// assert_eq!(isbn.value(), "9780306406157");
/// assert_eq!(isbn.prefix(), "978");
/// ```
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[cfg_attr(feature = "serde", serde(transparent))]
pub struct Isbn13(String);

impl ValueObject for Isbn13 {
    type Input = Isbn13Input;
    type Output = Isbn13Output;
    type Error = ValidationError;

    fn new(value: Self::Input) -> Result<Self, Self::Error> {
        let stripped: String = value.chars().filter(|c| c.is_ascii_digit()).collect();

        if stripped.len() != 13 {
            return Err(ValidationError::invalid("Isbn13", value.trim()));
        }

        if !stripped.starts_with("978") && !stripped.starts_with("979") {
            return Err(ValidationError::invalid("Isbn13", &stripped));
        }

        let digits: Vec<u8> = stripped.chars().map(|c| c as u8 - b'0').collect();
        let sum: u32 = digits
            .iter()
            .enumerate()
            .map(|(i, &d)| {
                let weight = if i % 2 == 0 { 1u32 } else { 3u32 };
                weight * d as u32
            })
            .sum();

        if sum % 10 != 0 {
            return Err(ValidationError::invalid("Isbn13", &stripped));
        }

        Ok(Self(stripped))
    }

    fn value(&self) -> &Self::Output {
        &self.0
    }

    fn into_inner(self) -> Self::Input {
        self.0
    }
}

impl Isbn13 {
    /// Returns the GS1 prefix — `"978"` or `"979"`.
    pub fn prefix(&self) -> &str {
        &self.0[..3]
    }
}

impl TryFrom<&str> for Isbn13 {
    type Error = ValidationError;

    fn try_from(value: &str) -> Result<Self, Self::Error> {
        Self::new(value.to_owned())
    }
}

impl std::fmt::Display for Isbn13 {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.0)
    }
}

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

    #[test]
    fn accepts_valid_isbn13_with_hyphens() {
        let i = Isbn13::new("978-0-306-40615-7".into()).unwrap();
        assert_eq!(i.value(), "9780306406157");
    }

    #[test]
    fn accepts_bare_digits() {
        let i = Isbn13::new("9780306406157".into()).unwrap();
        assert_eq!(i.value(), "9780306406157");
    }

    #[test]
    fn prefix_978() {
        let i = Isbn13::new("9780306406157".into()).unwrap();
        assert_eq!(i.prefix(), "978");
    }

    #[test]
    fn prefix_979() {
        let i = Isbn13::new("9791032309056".into()).unwrap();
        assert_eq!(i.prefix(), "979");
    }

    #[test]
    fn rejects_wrong_prefix() {
        assert!(Isbn13::new("1234567890123".into()).is_err());
    }

    #[test]
    fn rejects_wrong_length() {
        assert!(Isbn13::new("978030640615".into()).is_err());
    }

    #[test]
    fn rejects_invalid_checksum() {
        assert!(Isbn13::new("9780306406150".into()).is_err());
    }

    #[test]
    fn try_from_str() {
        let i: Isbn13 = "9780306406157".try_into().unwrap();
        assert_eq!(i.value(), "9780306406157");
    }
}