lark-channel 0.6.0

Lark/Feishu Channel SDK for Rust
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

use std::collections::BTreeMap;
use std::fmt;

use serde_json::Value;
use url::Url;

pub(crate) struct Redacted;

impl fmt::Debug for Redacted {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        formatter.write_str("<redacted>")
    }
}

pub(crate) struct RedactedHeaders<'a>(pub(crate) &'a BTreeMap<String, String>);

impl fmt::Debug for RedactedHeaders<'_> {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        let mut map = formatter.debug_map();
        for name in self.0.keys() {
            map.entry(name, &Redacted);
        }
        map.finish()
    }
}

pub(crate) struct RedactedOption<'a, T>(pub(crate) &'a Option<T>);

impl<T> fmt::Debug for RedactedOption<'_, T> {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self.0 {
            Some(_) => formatter.debug_tuple("Some").field(&Redacted).finish(),
            None => formatter.write_str("None"),
        }
    }
}

pub(crate) struct RedactedUrl<'a>(pub(crate) &'a Url);

impl fmt::Debug for RedactedUrl<'_> {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        formatter
            .debug_struct("Url")
            .field("scheme", &self.0.scheme())
            .field("host", &self.0.host_str())
            .field("port", &self.0.port())
            .finish()
    }
}

pub(crate) struct JsonSummary<'a>(pub(crate) &'a Value);

impl fmt::Debug for JsonSummary<'_> {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self.0 {
            Value::Null => formatter.write_str("Null"),
            Value::Bool(_) => formatter.write_str("Bool(<redacted>)"),
            Value::Number(_) => formatter.write_str("Number(<redacted>)"),
            Value::String(value) => formatter
                .debug_struct("String")
                .field("chars", &value.chars().count())
                .finish(),
            Value::Array(values) => formatter
                .debug_struct("Array")
                .field("len", &values.len())
                .finish(),
            Value::Object(values) => formatter
                .debug_struct("Object")
                .field("fields", &values.len())
                .finish(),
        }
    }
}

pub(crate) struct OptionalJsonSummary<'a>(pub(crate) &'a Option<Value>);

impl fmt::Debug for OptionalJsonSummary<'_> {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self.0 {
            Some(value) => formatter
                .debug_tuple("Some")
                .field(&JsonSummary(value))
                .finish(),
            None => formatter.write_str("None"),
        }
    }
}