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

//! Provides the raw data needed to convert to and from HTML entities.
//!
//! ```
//! extern crate entities;
//! use entities::ENTITIES;
//!
//! fn main() {
//!     let entity = ENTITIES
//!         .iter()
//!         .find(|e| e.entity == ">")
//!         .unwrap();
//!
//!     assert_eq!(entity.characters, ">");
//!     assert_eq!(entity.entity, ">");
//! }
//! ```
//!
//! There isn't a 1-to-1 mapping of entities to "characters" which is why this
//! crate provides a flat array rather than a map—the best way to map the
//! entities depends on the problem _you're_ trying to solve.
//!
//! If you want to create a mapping structure you can make one using static `str`
//! slices to reuse the statically allocated strings from this crate e.g.
//!
//! ```
//! # use self::std::collections::HashMap;
//! # use entities::ENTITIES;
//! fn make_mapping() -> HashMap<&'static str, &'static str> {
//!     let mut mapping = HashMap::new();
//!     mapping.insert(ENTITIES[0].entity, ENTITIES[0].characters);
//!     mapping
//! }
//! ```
//!
//! Data was generated from
//! [https://www.w3.org/TR/html5/entities.json](https://www.w3.org/TR/html5/entities.json)


#![no_std]


mod entities;


/// The unicode codepoint(s) for the "character" an entity is encoding.
#[derive(Debug)]
pub enum Codepoints {
    Single(u32),
    Double(u32, u32),
}


/// Represents an entry in the array of entity definitions.
#[derive(Debug)]
pub struct Entity {
    pub entity: &'static str,
    pub codepoints: Codepoints,
    pub characters: &'static str,
}


pub use entities::ENTITIES;


#[cfg(test)]
mod tests {
    extern crate std;
    use self::std::collections::HashMap;
    use super::ENTITIES;

    #[test]
    fn sanity() {
        let found = ENTITIES.iter().find(|e| e.entity == "&gt;");
        assert!(found.is_some());
        assert_eq!(found.unwrap().characters, ">");
    }

    #[test]
    fn make_map() {
        let mut mapping = HashMap::<&'static str, &'static str>::new();
        mapping.insert(ENTITIES[0].entity, ENTITIES[0].characters);
        assert_eq!(mapping.get(ENTITIES[0].entity),
                   Some(&ENTITIES[0].characters));
    }
}