breezyshim 0.7.15

Rust shim around the Breezy Python 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
133
134
135
136
137
138
139
140
141
142
143
144
145

//! UI Factory

use pyo3::prelude::*;

/// Python UI factory trait.
pub trait PyUIFactory: std::any::Any + std::fmt::Debug {
    /// Get the underlying Python object for this UI factory.
    fn to_object(&self, py: Python) -> Py<PyAny>;
}

/// UI factory trait.
pub trait UIFactory: std::fmt::Debug {}

impl<T: PyUIFactory> UIFactory for T {}

/// UI factory that does not output anything.
pub struct SilentUIFactory(Py<PyAny>);

impl SilentUIFactory {
    /// Create a new silent UI factory.
    pub fn new() -> Self {
        Python::attach(|py| {
            SilentUIFactory(
                py.import("breezy.ui")
                    .unwrap()
                    .getattr("SilentUIFactory")
                    .unwrap()
                    .call0()
                    .unwrap()
                    .unbind(),
            )
        })
    }
}

impl Default for SilentUIFactory {
    fn default() -> Self {
        Self::new()
    }
}

/// Generic wrapper for a Python UI factory.
pub struct GenericUIFactory(Py<PyAny>);

impl<'py> IntoPyObject<'py> for GenericUIFactory {
    type Target = PyAny;
    type Output = Bound<'py, Self::Target>;
    type Error = std::convert::Infallible;

    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
        Ok(self.0.into_bound(py))
    }
}

impl<'a, 'py> FromPyObject<'a, 'py> for GenericUIFactory {
    type Error = PyErr;

    fn extract(obj: Borrowed<'a, 'py, PyAny>) -> PyResult<Self> {
        Ok(GenericUIFactory(obj.to_owned().unbind()))
    }
}

impl GenericUIFactory {
    /// Create a new generic UI factory from a Python object.
    pub fn new(obj: Py<PyAny>) -> Self {
        Self(obj)
    }
}

impl PyUIFactory for GenericUIFactory {
    fn to_object(&self, py: Python) -> Py<PyAny> {
        self.0.clone_ref(py)
    }
}

impl std::fmt::Debug for GenericUIFactory {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.write_fmt(format_args!("GenericUIFactory({:?})", self.0))
    }
}

impl<'py> IntoPyObject<'py> for SilentUIFactory {
    type Target = PyAny;
    type Output = Bound<'py, Self::Target>;
    type Error = std::convert::Infallible;

    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
        Ok(self.0.into_bound(py))
    }
}

impl PyUIFactory for SilentUIFactory {
    fn to_object(&self, py: Python) -> Py<PyAny> {
        self.0.clone_ref(py)
    }
}

impl std::fmt::Debug for SilentUIFactory {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.write_fmt(format_args!("SilentUIFactory({:?})", self.0))
    }
}

/// Install a UI factory globally.
pub fn install_ui_factory(factory: &dyn PyUIFactory) {
    Python::attach(|py| {
        let m = py.import("breezy.ui").unwrap();
        m.setattr("ui_factory", factory.to_object(py)).unwrap();
    });
}

/// Get the current global UI factory.
pub fn get_ui_factory() -> Box<dyn PyUIFactory> {
    Box::new(GenericUIFactory::new(Python::attach(|py| {
        let m = py.import("breezy.ui").unwrap();
        m.getattr("ui_factory").unwrap().unbind()
    }))) as Box<dyn PyUIFactory>
}

/// Run a function with a silent UI factory temporarily installed.
pub fn with_silent_ui_factory<R>(f: impl FnOnce() -> R) -> R {
    let old_factory = get_ui_factory();
    let new_factory = SilentUIFactory::new();
    install_ui_factory(&new_factory);
    let r = f();
    install_ui_factory(old_factory.as_ref());
    r
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_create_silent_factory() {
        let _ = SilentUIFactory::new();
    }

    #[test]
    fn test_run_with_silent_factory() {
        with_silent_ui_factory(|| {
            crate::version::version();
        });
    }
}