oxd 0.1.2

Client to query Oxford Dictionary API
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

/*! Display entries */

use crate::models::*;
use colored::Colorize;
use std::fmt::Write;

/// A trait to display entries
pub trait Display {
    fn display(&self, canvas: &mut String);
}

impl Display for RetrieveEntry {
    fn display(&self, canvas: &mut String) {
        self.headword_entries.display(canvas);
    }
}

impl Display for HeadwordEntry {
    fn display(&self, canvas: &mut String) {
        writeln!(canvas, "{}", self.word).unwrap();
        self.lexical_entries.display(canvas);
        writeln!(canvas).unwrap();
    }
}

impl Display for LexicalEntry {
    fn display(&self, canvas: &mut String) {
        if is_empty_entries(&self.entries) {
            return;
        }
        write!(canvas, "\n{}  ", self.lexical_category.id.italic()).unwrap();
        self.entries.display(canvas);
    }
}

impl Display for Entry {
    fn display(&self, canvas: &mut String) {
        self.pronunciations.display(canvas);
        self.variant_forms.display(canvas);
        writeln!(canvas).unwrap();
        self.senses.display(canvas);
    }
}

impl Display for Sense {
    fn display(&self, canvas: &mut String) {
        let mut c = String::new();
        self.domains.display(&mut c);
        self.registers.display(&mut c);
        if self.domains.is_some() || self.registers.is_some() {
            writeln!(&mut c).unwrap();
        }
        self.definitions.display(&mut c);
        self.cross_reference_markers.display(&mut c);
        self.examples.display(&mut c);
        self.subsenses.display(&mut c);
        c = c.replace("\n", "\n  ");
        c.pop();
        c.pop();
        c.insert_str(0, "- ");
        write!(canvas, "{c}").unwrap();
    }
}

impl<T: Display> Display for Option<T> {
    fn display(&self, canvas: &mut String) {
        if let Some(value) = &self {
            value.display(canvas);
        }
    }
}

impl<T: Display> Display for Vec<T> {
    fn display(&self, canvas: &mut String) {
        for value in self {
            value.display(canvas);
        }
    }
}

impl Display for String {
    fn display(&self, canvas: &mut String) {
        write!(canvas, "{}", self).unwrap();
        if !self.ends_with('.') {
            write!(canvas, ".").unwrap();
        }
        writeln!(canvas, "").unwrap();
    }
}

impl Display for Example {
    fn display(&self, canvas: &mut String) {
        let text = format!("\"{}\"", self.text.trim());
        writeln!(canvas, "{}", text.italic().blue()).unwrap();
    }
}

impl Display for VariantForm {
    fn display(&self, canvas: &mut String) {
        let tag = match &self.regions {
            Some(regions) => format!(" [{}]", regions[0].text),
            None => String::new(),
        };
        write!(canvas, " (also {}{}) ", self.text, tag).unwrap();
    }
}

impl Display for Pronunciation {
    fn display(&self, canvas: &mut String) {
        if self.phonetic_notation == "IPA" {
            write!(canvas, "/{}/ ", self.phonetic_spelling).unwrap();
        }
    }
}

impl Display for Domain {
    fn display(&self, canvas: &mut String) {
        write!(canvas, "[{}] ", self.text).unwrap();
    }
}

impl Display for Register {
    fn display(&self, canvas: &mut String) {
        write!(canvas, "[{}] ", self.text).unwrap();
    }
}

fn is_empty_entries(entries: &Vec<Entry>) -> bool {
    return entries.iter().all(|entry| {
        entry.pronunciations.is_none() && entry.senses.is_none() && entry.variant_forms.is_none()
    });
}