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


pub mod uri_rules {
    pub use regex::Regex;

    pub struct WampUriRule {
        pub loose: Regex,
        pub strict: Regex
    }

    pub trait Rule {
        fn rule(&self) -> WampUriRule;
    }

    pub enum EasyRule {
        WithEmpty,
        NoEmpty
    }

    impl Rule for EasyRule {
        fn rule(&self) -> WampUriRule {
            match &self {
                EasyRule::WithEmpty => {
                    WampUriRule {
                        loose: Regex::new(r"^(([^\s\.#]+\.)|\.)*([^\s\.#]+)?$").unwrap(),
                        strict: Regex::new(r"^(([0-9a-z_]+\.)|\.)*([0-9a-z_]+)?$").unwrap()
                    }
                },
                EasyRule::NoEmpty => {
                    WampUriRule {
                        strict: Regex::new(r"^([0-9a-z_]+\.)*([0-9a-z_]+)$").unwrap(),
                        loose: Regex::new(r"^([^\s\.#]+\.)*([^\s\.#]+)$").unwrap()
                    }
                }
            }
        }
    }
    
    /// Wamp URI Rules
    /// Read More: https://wamp-proto.org/wamp_latest_ietf.html#section-16.1.2-11
    pub enum WampRules {
        Name,
        URI,
        Prefix,
        PrefixOrWildcard,
    }

    impl Rule for WampRules {
        fn rule(&self) -> WampUriRule {
            match self {
                WampRules::Name => {
                    WampUriRule {
                        loose: Regex::new(r"^[^\s\.#]+$").unwrap(),
                        strict: Regex::new(r"^[\da-z_]+$").unwrap()
                    }
                }

                WampRules::URI => {
                    WampUriRule {
                        loose: Regex::new(r"^([^\s\.#]+\.)*([^\s\.#]+)$").unwrap(),
                        strict: Regex::new(r"^([\da-z_]+\.)*([\da-z_]+)$").unwrap()
                    }
                }

                WampRules::PrefixOrWildcard => {
                    WampUriRule {
                        loose: Regex::new(r"^(([^\s\.#]+\.)|\.)*([^\s\.#]+)?$").unwrap(),
                        strict: Regex::new(r"^(([\da-z_]+\.)|\.)*([\da-z_]+)?$").unwrap()
                    }
                }

                WampRules::Prefix => {
                    WampUriRule {
                        loose: Regex::new(r"^([^\s\.#]+\.)*([^\s\.#]*)$").unwrap(),
                        strict: Regex::new(r"^([\da-z_]+\.)*([\da-z_]*)$").unwrap()
                    }
                }
            }
        }
    }
    
}

//pub struct URI(String);
//
//impl URI {
//    pub fn validate<R: uri_rules::Rule>(r: R, v: String) -> Self {
//        todo!();
//        let rule = r.rule().loose;
//        //let values = rule.capture
//    }
//}