nject 0.5.0

Zero cost dependency injection module
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

use nject::provider;

#[provider]
struct InitProvider;

mod modules {
    use nject::{injectable, module};

    #[derive(PartialEq, Debug)]
    #[injectable]
    pub struct Dep(#[inject(42)] pub i32);

    #[injectable]
    #[module]
    pub struct MyModule {
        #[export]
        pub hidden: Dep,
    }

    pub mod inner {
        use nject::{injectable, module};

        #[derive(PartialEq, Debug)]
        #[injectable]
        pub struct InnerDep(#[inject(7)] pub i32);

        #[injectable]
        #[module]
        pub struct InnerModule {
            #[export]
            pub hidden: InnerDep,
        }
    }
}

mod providers {
    use nject::{injectable, provider};

    use crate::modules::Dep;
    use crate::modules::inner::InnerDep;

    #[injectable]
    pub struct Facade<'a>(pub &'a Dep);

    #[injectable]
    pub struct InnerFacade<'a>(pub &'a InnerDep);

    // Imports a module from a sibling top-level module via `crate::…`.
    #[injectable]
    #[provider]
    pub struct CrateProvider(#[import] pub crate::modules::MyModule);

    // Imports a deeply nested module via `crate::…::…`.
    #[injectable]
    #[provider]
    pub struct DeepProvider(#[import] pub crate::modules::inner::InnerModule);

    // Imports a module from the parent module via `super::…`.
    pub mod inner {
        use nject::{injectable, provider};

        #[injectable]
        #[provider]
        pub struct SuperProvider(#[import] pub super::super::modules::MyModule);
    }
}

// Provider and module declared in the same module – tests the bare/`self`
// resolution paths.
mod same_scope {
    use nject::{injectable, module, provider};

    #[derive(PartialEq, Debug)]
    #[injectable]
    pub struct LocalDep(#[inject(99)] pub i32);

    #[injectable]
    #[module]
    pub struct LocalModule {
        #[export]
        pub hidden: LocalDep,
    }

    #[injectable]
    pub struct LocalFacade<'a>(pub &'a LocalDep);

    // Single-segment path – resolved via the textually in-scope macro.
    #[injectable]
    #[provider]
    pub struct BareProvider(#[import] pub LocalModule);

    // `self::…` path – resolved via the local-alias `pub(crate) use`.
    #[injectable]
    #[provider]
    pub struct SelfProvider(#[import] pub self::LocalModule);
}

#[test]
fn nested_provider_can_import_via_crate_path() {
    let provider = InitProvider.provide::<providers::CrateProvider>();
    let facade = provider.provide::<providers::Facade>();
    assert_eq!(facade.0.0, 42);
}

#[test]
fn nested_provider_can_import_deep_crate_path() {
    let provider = InitProvider.provide::<providers::DeepProvider>();
    let facade = provider.provide::<providers::InnerFacade>();
    assert_eq!(facade.0.0, 7);
}

#[test]
fn nested_provider_can_import_via_super_path() {
    let provider = InitProvider.provide::<providers::inner::SuperProvider>();
    let facade = provider.provide::<providers::Facade>();
    assert_eq!(facade.0.0, 42);
}

#[test]
fn provider_can_import_module_in_same_scope_by_bare_name() {
    let provider = InitProvider.provide::<same_scope::BareProvider>();
    let facade = provider.provide::<same_scope::LocalFacade>();
    assert_eq!(facade.0.0, 99);
}

#[test]
fn provider_can_import_module_in_same_scope_via_self_path() {
    let provider = InitProvider.provide::<same_scope::SelfProvider>();
    let facade = provider.provide::<same_scope::LocalFacade>();
    assert_eq!(facade.0.0, 99);
}