nhs-number 1.0.0

National Health Service (NHS) number for NHS England, NHS Wales, NHS Isle of Man.
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

use crate::NHSNumber;
use crate::parse_error::ParseError;
use std::str::FromStr;

/// Implement the `FromStr` trait for NHSNumber to allow parsing from a string.
///
/// This parser allows for optional space separators in the NHS Number string,
/// so long as the space separators are in their expected positions.
///
/// A valid NHS Number format can be either:
///
/// - 10 digits e.g. "0123456789"
///
/// - 12 characters with spaces e.g. "012 345 6789".
///
/// Example:
///
/// ```rust
/// use nhs_number::NHSNumber;
/// use std::str::FromStr;
/// let nhs_number_str = "012 345 6789";
/// let nhs_number: NHSNumber = NHSNumber::from_str(nhs_number_str).unwrap();
/// assert_eq!(nhs_number.digits, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
/// ```
///
impl FromStr for NHSNumber {
    type Err = ParseError;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let chars: Vec<char> = s.chars().collect();
        match chars.len() {
            10 => {
                let mut digits: [i8; 10] = [0; 10];
                for i in 0..10 {
                    digits[i] = chars[i].to_digit(10).ok_or(ParseError)? as i8
                }
                Ok(NHSNumber { digits: digits })
            }
            12 => {
                if chars[3] != ' ' || chars[7] != ' ' {
                    return Err(ParseError);
                }
                let mut digits: [i8; 10] = [0; 10];
                for i in 0..3 {
                    digits[i] = chars[i].to_digit(10).ok_or(ParseError)? as i8
                }
                for i in 0..3 {
                    digits[i + 3] = chars[i + 4].to_digit(10).ok_or(ParseError)? as i8
                }
                for i in 0..4 {
                    digits[i + 6] = chars[i + 8].to_digit(10).ok_or(ParseError)? as i8
                }
                Ok(NHSNumber { digits: digits })
            }
            _ => {
                return Err(ParseError);
            }
        }
    }
}

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

    #[test]
    fn test_from_str_with_length_10_without_spaces() {
        let s = String::from("0123456789");
        let actual: NHSNumber = NHSNumber::from_str(&s).unwrap();
        let expect: NHSNumber = NHSNumber::new([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
        assert_eq!(actual, expect);
    }

    #[test]
    fn test_from_str_with_length_12_with_spaces() {
        let s = String::from("012 345 6789");
        let actual: NHSNumber = NHSNumber::from_str(&s).unwrap();
        let expect: NHSNumber = NHSNumber::new([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
        assert_eq!(actual, expect);
    }

    #[test]
    fn test_from_str_with_wrong_characters() {
        let s = String::from("012-345-6789");
        let result: Result<NHSNumber, ParseError> = NHSNumber::from_str(&s);
        assert!(result.is_err());
    }

    #[test]
    fn test_from_str_with_wrong_leading_space() {
        let s = String::from(" 012 345 6789");
        let result: Result<NHSNumber, ParseError> = NHSNumber::from_str(&s);
        assert!(result.is_err());
    }

    #[test]
    fn test_from_str_with_first_space_without_last_space() {
        let s = String::from("012 3456789");
        let result: Result<NHSNumber, ParseError> = NHSNumber::from_str(&s);
        assert!(result.is_err());
    }

    #[test]
    fn test_from_str_without_first_space_with_last_space() {
        let s = String::from("012345 6789");
        let result: Result<NHSNumber, ParseError> = NHSNumber::from_str(&s);
        assert!(result.is_err());
    }

    #[test]
    fn test_from_str_with_wrong_inner_space() {
        let s = String::from("012  345  6789");
        let result: Result<NHSNumber, ParseError> = NHSNumber::from_str(&s);
        assert!(result.is_err());
    }

    #[test]
    fn test_from_str_with_wrong_trailing_space() {
        let s = String::from("012 345 6789 ");
        let result: Result<NHSNumber, ParseError> = NHSNumber::from_str(&s);
        assert!(result.is_err());
    }

    #[test]
    fn test_from_str_with_wrong_length() {
        let s = String::from("012");
        let result: Result<NHSNumber, ParseError> = NHSNumber::from_str(&s);
        assert!(result.is_err());
    }
}