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
143
144
145
146
147

use crate::{error::ErrorKind, Error};

/// A project id.
///
/// # Limit
///
/// <https://cloud.google.com/resource-manager/docs/creating-managing-projects>
///
/// > - Must be 6 to 30 characters in length.
/// > - Can only contain lowercase letters, numbers, and hyphens.
/// > - Must start with a letter.
/// > - Cannot end with a hyphen.
/// > - Cannot be in use or previously used; this includes deleted projects.
/// > - Cannot contain restricted strings, such as google, null, undefined, and ssl.
///
/// # Examples
///
/// ```rust
/// # fn main() -> anyhow::Result<()> {
/// use firestore_path::ProjectId;
/// use std::str::FromStr;
///
/// let project_id = ProjectId::from_str("my-project")?;
/// assert_eq!(project_id.as_ref(), "my-project");
/// assert_eq!(project_id.to_string(), "my-project");
/// #     Ok(())
/// # }
/// ```
///
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ProjectId(String);

impl std::convert::AsRef<str> for ProjectId {
    fn as_ref(&self) -> &str {
        self.0.as_ref()
    }
}

impl std::convert::TryFrom<&str> for ProjectId {
    type Error = Error;

    fn try_from(s: &str) -> Result<Self, Self::Error> {
        Self::try_from(s.to_string())
    }
}

impl std::convert::TryFrom<String> for ProjectId {
    type Error = Error;

    fn try_from(s: String) -> Result<Self, Self::Error> {
        // <https://cloud.google.com/resource-manager/docs/creating-managing-projects>

        if !(6..=30).contains(&s.len()) {
            return Err(Error::from(ErrorKind::LengthOutOfBounds));
        }

        if !s
            .chars()
            .all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '-')
        {
            return Err(Error::from(ErrorKind::ContainsInvalidCharacter));
        }

        let first_char = s.chars().next().expect("already length checked");
        if !first_char.is_ascii_lowercase() {
            return Err(Error::from(ErrorKind::StartsWithNonLetter));
        }

        let last_char = s.chars().next_back().expect("already length checked");
        if last_char == '-' {
            return Err(Error::from(ErrorKind::EndsWithHyphen));
        }

        if s.contains("google")
            || s.contains("null")
            || s.contains("undefined")
            || s.contains("ssl")
        {
            return Err(Error::from(ErrorKind::MatchesReservedIdPattern));
        }

        Ok(Self(s))
    }
}

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

impl std::str::FromStr for ProjectId {
    type Err = Error;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        Self::try_from(s)
    }
}

#[cfg(test)]
mod tests {
    use std::str::FromStr;

    use super::*;

    #[test]
    fn test() -> anyhow::Result<()> {
        let s = "my-project";
        let project_id = ProjectId::from_str(s)?;
        assert_eq!(project_id.to_string(), s);

        assert_eq!(project_id.as_ref(), s);
        Ok(())
    }

    #[test]
    fn test_impl_from_str_and_impl_try_from_string() -> anyhow::Result<()> {
        for (s, expected) in [
            ("x".repeat(5).as_ref(), false),
            ("x".repeat(6).as_ref(), true),
            ("x".repeat(30).as_ref(), true),
            ("x".repeat(31).as_ref(), false),
            ("chat/rooms", false),
            ("xxxxxx", true),
            ("x-xxxx", true),
            ("x0xxxx", true),
            ("xAxxxx", false),
            ("0xxxxx", false),
            ("xxxxx0", true),
            ("xxxxx-", false),
            ("xgoogle", false),
            ("xnull", false),
            ("xundefined", false),
            ("xssl", false),
        ] {
            assert_eq!(ProjectId::from_str(s).is_ok(), expected);
            assert_eq!(ProjectId::try_from(s).is_ok(), expected);
            assert_eq!(ProjectId::try_from(s.to_string()).is_ok(), expected);
            if expected {
                assert_eq!(ProjectId::from_str(s)?, ProjectId::try_from(s)?);
                assert_eq!(ProjectId::from_str(s)?, ProjectId::try_from(s.to_string())?);
                assert_eq!(ProjectId::from_str(s)?.to_string(), s);
            }
        }
        Ok(())
    }
}