entrait 0.7.1

Loosely coupled Rust application design made easy
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
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197

#[entrait::entrait(pub Baz)]
fn baz<D>(_: &D) -> i32 {
    42
}

mod simple_static {
    use entrait::*;

    #[entrait(FoobarImpl, delegate_by = DelegateFoobar)]
    pub trait Foobar {
        fn foo(&self) -> i32;
        fn bar(&self) -> u32;
    }

    pub struct MyImpl2;

    #[entrait]
    impl FoobarImpl for MyImpl2 {
        fn bar<D>(_: &D) -> u32 {
            1337
        }

        fn foo(deps: &impl super::Baz) -> i32 {
            deps.baz()
        }
    }

    impl DelegateFoobar<Self> for () {
        type Target = MyImpl2;
    }

    #[test]
    fn test_mod() {
        let app = Impl::new(());

        assert_eq!(42, app.foo());
    }

    impl DelegateFoobar<Self> for bool {
        type Target = MyImpl2;
    }

    #[test]
    fn test_impl_block() {
        let app = Impl::new(true);

        assert_eq!(42, app.foo());
        assert_eq!(1337, app.bar());
    }
}

mod simple_dyn {
    use entrait::*;

    #[entrait(FoobarImpl, delegate_by=ref)]
    trait Foobar {
        fn foo(&self) -> i32;
        fn bar(&self) -> u32;
    }

    struct Implementor2;

    #[entrait(ref)]
    impl FoobarImpl for Implementor2 {
        pub fn bar<D>(_: &D) -> u32 {
            1337
        }

        pub fn foo(deps: &impl super::Baz) -> i32 {
            deps.baz()
        }
    }

    struct App {
        foobar: Box<dyn FoobarImpl<Self> + Sync>,
    }

    impl AsRef<dyn FoobarImpl<Self>> for App {
        fn as_ref(&self) -> &dyn FoobarImpl<Self> {
            self.foobar.as_ref()
        }
    }

    #[test]
    fn test_impl_block() {
        let app = Impl::new(App {
            foobar: Box::new(Implementor2),
        });

        assert_eq!(42, app.foo());
        assert_eq!(1337, app.bar());
    }
}

mod async_static {
    use entrait::*;

    #[entrait(FoobarImpl, delegate_by = DelegateFoobar)]
    pub trait Foobar {
        async fn foo(&self) -> i32;
        async fn bar(&self) -> u32;
    }

    pub struct Implementor2;

    #[entrait]
    impl FoobarImpl for Implementor2 {
        pub async fn bar<D>(_: &D) -> u32 {
            1337
        }

        pub async fn foo(deps: &impl super::Baz) -> i32 {
            deps.baz()
        }
    }

    impl DelegateFoobar<Self> for bool {
        type Target = Implementor2;
    }

    #[tokio::test]
    async fn test_impl_block() {
        let app = Impl::new(true);

        assert_eq!(42, app.foo().await);
        assert_eq!(1337, app.bar().await);
    }
}

mod async_dyn {
    use entrait::*;

    #[entrait(FoobarImpl, delegate_by=ref)]
    #[async_trait::async_trait]
    pub trait Foobar {
        async fn foo(&self) -> i32;
        async fn bar(&self) -> u32;
    }

    pub struct Implementor2;

    #[entrait(ref)]
    #[async_trait::async_trait]
    impl FoobarImpl for Implementor2 {
        pub async fn bar<D>(_: &D) -> u32 {
            1337
        }

        pub async fn foo(deps: &impl super::Baz) -> i32 {
            deps.baz()
        }
    }

    struct App2(Implementor2);

    impl AsRef<dyn FoobarImpl<Self> + Sync> for App2 {
        fn as_ref(&self) -> &(dyn FoobarImpl<Self> + Sync) {
            &self.0
        }
    }

    #[tokio::test]
    async fn test_impl_block() {
        let app = Impl::new(App2(Implementor2));

        assert_eq!(42, app.foo().await);
        assert_eq!(1337, app.bar().await);
    }
}

mod issue_29 {
    use entrait::*;

    #[entrait(FoobarImpl, delegate_by = DelegateFoobar)]
    pub trait Foobar {
        fn foo<'a>(&self, input: &'a str) -> &'a str;
    }

    pub struct MyImpl;

    #[entrait]
    impl FoobarImpl for MyImpl {
        fn foo<'a, D>(deps: &D, input: &'a str) -> &'a str {
            input
        }
    }

    impl DelegateFoobar<Self> for () {
        type Target = MyImpl;
    }

    #[test]
    fn test_mod() {
        let app = Impl::new(());
        assert_eq!("foo", app.foo("foo"));
    }
}