dill 0.15.0

Runtime depenency injection library.
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

use std::any::TypeId;

use thiserror::Error;

use crate::{DependencyInfo, InjectionContext, InjectionStack, TypeInfo};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#[derive(Error, Debug, Clone)]
pub enum InjectionError {
    #[error(transparent)]
    Unregistered(UnregisteredTypeError),
    #[error(transparent)]
    Ambiguous(AmbiguousTypeError),
    #[error(transparent)]
    ScopeInversion(Box<ScopeInversionError>),
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

impl InjectionError {
    pub fn unregistered<Iface: 'static + ?Sized>(ctx: &InjectionContext) -> Self {
        Self::Unregistered(UnregisteredTypeError {
            dep_type: TypeInfo::of::<Iface>(),
            injection_stack: ctx.to_stack(),
        })
    }

    // TODO: Should contain information about which implementations were found
    pub fn ambiguous<Iface: 'static + ?Sized>(ctx: &InjectionContext) -> Self {
        Self::Ambiguous(AmbiguousTypeError {
            dep_type: TypeInfo::of::<Iface>(),
            injection_stack: ctx.to_stack(),
        })
    }
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#[derive(Error, Debug, Clone)]
pub struct UnregisteredTypeError {
    pub dep_type: TypeInfo,
    pub injection_stack: InjectionStack,
}

impl std::fmt::Display for UnregisteredTypeError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        writeln!(f, "Unregistered type: {}", self.dep_type.name)?;
        write!(f, "Injection stack:\n{}", self.injection_stack)
    }
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#[derive(Error, Debug, Clone)]
pub struct AmbiguousTypeError {
    pub dep_type: TypeInfo,
    pub injection_stack: InjectionStack,
}

impl std::fmt::Display for AmbiguousTypeError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        writeln!(f, "Ambiguous type: {}", self.dep_type.name)?;
        write!(f, "Injection stack:\n{}", self.injection_stack)
    }
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#[derive(Error, Debug, Clone)]
pub struct ScopeInversionError {
    pub inst_type: TypeInfo,
    pub inst_scope: TypeInfo,
    pub inst_dep: DependencyInfo,
    pub dep_type: TypeInfo,
    pub dep_scope: TypeInfo,
    pub injection_stack: InjectionStack,
}

impl std::fmt::Display for ScopeInversionError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        writeln!(
            f,
            "Scope inversion: {} in {} scope injects {} in {} scope",
            self.inst_type.name, self.inst_scope.name, self.dep_type.name, self.dep_scope.name,
        )?;

        write!(f, "Injection stack:\n{}", self.injection_stack)
    }
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#[derive(Error, Debug, Clone)]
pub struct ValidationError {
    pub errors: Vec<InjectionError>,
}

impl std::fmt::Display for ValidationError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        writeln!(f, "DI graph validation failed:")?;
        for (i, err) in self.errors.iter().enumerate() {
            writeln!(f, "{i}: {err}")?;
        }
        Ok(())
    }
}

pub trait ValidationErrorExt {
    fn ignore<T: 'static + ?Sized>(self) -> Self;
}

impl ValidationErrorExt for Result<(), ValidationError> {
    fn ignore<T: 'static + ?Sized>(self) -> Self {
        let type_id = TypeId::of::<T>();
        let Err(mut err) = self else { return Ok(()) };

        err.errors.retain(|e| match e {
            InjectionError::Unregistered(e) => e.dep_type.id != type_id,
            InjectionError::Ambiguous(e) => e.dep_type.id != type_id,
            InjectionError::ScopeInversion(e) => e.dep_type.id != type_id,
        });

        if err.errors.is_empty() {
            Ok(())
        } else {
            Err(err)
        }
    }
}