diff options
-rw-r--r-- | Cargo.toml | 4 | ||||
-rw-r--r-- | examples/prevent-circular/main.rs | 48 | ||||
-rw-r--r-- | macros/src/injectable/implementation.rs | 26 | ||||
-rw-r--r-- | src/dependency_history.rs | 186 | ||||
-rw-r--r-- | src/dependency_trace.rs | 18 | ||||
-rw-r--r-- | src/di_container/asynchronous/binding/builder.rs | 102 | ||||
-rw-r--r-- | src/di_container/asynchronous/binding/scope_configurator.rs | 75 | ||||
-rw-r--r-- | src/di_container/asynchronous/binding/when_configurator.rs | 18 | ||||
-rw-r--r-- | src/di_container/asynchronous/mod.rs | 182 | ||||
-rw-r--r-- | src/di_container/blocking/binding/builder.rs | 69 | ||||
-rw-r--r-- | src/di_container/blocking/binding/scope_configurator.rs | 69 | ||||
-rw-r--r-- | src/di_container/blocking/binding/when_configurator.rs | 18 | ||||
-rw-r--r-- | src/di_container/blocking/mod.rs | 146 | ||||
-rw-r--r-- | src/errors/injectable.rs | 7 | ||||
-rw-r--r-- | src/interfaces/async_injectable.rs | 14 | ||||
-rw-r--r-- | src/interfaces/injectable.rs | 14 | ||||
-rw-r--r-- | src/lib.rs | 4 | ||||
-rw-r--r-- | src/provider/async.rs | 161 | ||||
-rw-r--r-- | src/provider/blocking.rs | 124 | ||||
-rw-r--r-- | src/test_utils.rs | 179 |
20 files changed, 944 insertions, 520 deletions
@@ -34,6 +34,10 @@ required-features = ["async", "factory"] name = "async-factory" required-features = ["async", "factory"] +[[example]] +name = "prevent-circular" +required-features = ["prevent-circular"] + [dependencies] syrette_macros = { path = "./macros", version = "0.4.0" } linkme = "0.3.0" diff --git a/examples/prevent-circular/main.rs b/examples/prevent-circular/main.rs new file mode 100644 index 0000000..7e10024 --- /dev/null +++ b/examples/prevent-circular/main.rs @@ -0,0 +1,48 @@ +#![deny(clippy::all)] +#![deny(clippy::pedantic)] +#![allow(clippy::disallowed_names)] +use std::error::Error; + +use syrette::di_container::blocking::prelude::*; +use syrette::injectable; +use syrette::ptr::TransientPtr; + +struct Foo +{ + bar: TransientPtr<Bar>, +} + +#[injectable] +impl Foo +{ + fn new(bar: TransientPtr<Bar>) -> Self + { + Self { bar } + } +} + +struct Bar +{ + foo: TransientPtr<Foo>, +} + +#[injectable] +impl Bar +{ + fn new(foo: TransientPtr<Foo>) -> Self + { + Self { foo } + } +} + +fn main() -> Result<(), anyhow::Error> +{ + let mut di_container = DIContainer::new(); + + di_container.bind::<Foo>().to::<Foo>()?; + di_container.bind::<Bar>().to::<Bar>()?; + + let foo = di_container.get::<Foo>()?.transient()?; + + Ok(()) +} diff --git a/macros/src/injectable/implementation.rs b/macros/src/injectable/implementation.rs index 6cde446..cfbc620 100644 --- a/macros/src/injectable/implementation.rs +++ b/macros/src/injectable/implementation.rs @@ -101,19 +101,17 @@ impl<Dep: IDependency> InjectableImpl<Dep> ) -> proc_macro2::TokenStream { quote! { - if #dependency_history_var.contains(&self_type_name) { - #dependency_history_var.push(self_type_name); + use syrette::dependency_history::IDependencyHistory; - let dependency_trace = - syrette::dependency_trace::create_dependency_trace( - #dependency_history_var.as_slice(), - self_type_name - ); + if #dependency_history_var.contains::<Self>() { + #dependency_history_var.push::<Self>(); - return Err(InjectableError::DetectedCircular {dependency_trace }); + return Err(InjectableError::DetectedCircular { + dependency_history: #dependency_history_var + }); } - #dependency_history_var.push(self_type_name); + #dependency_history_var.push::<Self>(); } } @@ -133,14 +131,15 @@ impl<Dep: IDependency> InjectableImpl<Dep> quote! { #maybe_doc_hidden impl #generics syrette::interfaces::async_injectable::AsyncInjectable< - syrette::di_container::asynchronous::AsyncDIContainer + syrette::di_container::asynchronous::AsyncDIContainer, + syrette::dependency_history::DependencyHistory > for #self_type { fn resolve<'di_container, 'fut>( #di_container_var: &'di_container std::sync::Arc< syrette::di_container::asynchronous::AsyncDIContainer >, - mut #dependency_history_var: Vec<&'static str>, + mut #dependency_history_var: syrette::dependency_history::DependencyHistory ) -> syrette::future::BoxFuture< 'fut, Result< @@ -187,14 +186,15 @@ impl<Dep: IDependency> InjectableImpl<Dep> quote! { #maybe_doc_hidden impl #generics syrette::interfaces::injectable::Injectable< - syrette::di_container::blocking::DIContainer + syrette::di_container::blocking::DIContainer, + syrette::dependency_history::DependencyHistory > for #self_type { fn resolve( #di_container_var: &std::rc::Rc< syrette::di_container::blocking::DIContainer >, - mut #dependency_history_var: Vec<&'static str>, + mut #dependency_history_var: syrette::dependency_history::DependencyHistory ) -> Result< syrette::ptr::TransientPtr<Self>, syrette::errors::injectable::InjectableError> diff --git a/src/dependency_history.rs b/src/dependency_history.rs new file mode 100644 index 0000000..4e36a7b --- /dev/null +++ b/src/dependency_history.rs @@ -0,0 +1,186 @@ +//! Dependency history. + +use std::any::type_name; +use std::collections::HashSet; +use std::fmt::{Debug, Display}; + +const BOLD_MODE: &str = "\x1b[1m"; +const RESET_BOLD_MODE: &str = "\x1b[22m"; + +/// Dependency history interface. +/// +/// **This trait is sealed and cannot be implemented for types outside this crate.** +pub trait IDependencyHistory: private::Sealed +{ + #[doc(hidden)] + fn push<Dependency: 'static + ?Sized>(&mut self); + + #[doc(hidden)] + fn contains<Dependency: 'static + ?Sized>(&self) -> bool; +} + +/// Dependency history. +#[derive(Clone, Debug)] +pub struct DependencyHistory +{ + inner: Vec<&'static str>, +} + +impl DependencyHistory +{ + #[must_use] + pub(crate) fn new() -> Self + { + Self { inner: vec![] } + } +} + +impl IDependencyHistory for DependencyHistory +{ + #[doc(hidden)] + fn push<Dependency: 'static + ?Sized>(&mut self) + { + self.inner.push(type_name::<Dependency>()); + } + + #[doc(hidden)] + fn contains<Dependency: 'static + ?Sized>(&self) -> bool + { + self.inner.contains(&type_name::<Dependency>()) + } +} + +impl Display for DependencyHistory +{ + fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result + { + let mut found_items = HashSet::new(); + + let opt_dupe_item = self.inner.iter().find(|item| { + if found_items.contains(item) { + return true; + } + + found_items.insert(*item); + + false + }); + + for (index, item) in self.inner.iter().enumerate() { + let mut item_is_dupe = false; + + if let Some(dupe_item) = opt_dupe_item { + if *item == *dupe_item { + formatter + .write_fmt(format_args!("{BOLD_MODE}{item}{RESET_BOLD_MODE}"))?; + + item_is_dupe = true; + } + } + + if !item_is_dupe { + formatter.write_str(item)?; + } + + if index != self.inner.len() - 1 { + formatter.write_str(" -> ")?; + } + } + + if opt_dupe_item.is_some() { + formatter.write_str(" -> ...")?; + } + + Ok(()) + } +} + +impl Default for DependencyHistory +{ + fn default() -> Self + { + Self::new() + } +} + +impl private::Sealed for DependencyHistory {} + +pub(crate) mod private +{ + pub trait Sealed {} +} + +#[cfg(test)] +mod tests +{ + use super::*; + use crate::test_utils::subjects; + + #[test] + fn can_push() + { + let mut dependency_history = DependencyHistory::new(); + + dependency_history.push::<dyn subjects::INumber>(); + + assert!(dependency_history + .inner + .contains(&type_name::<dyn subjects::INumber>())); + } + + #[test] + fn contains_works() + { + let mut dependency_history = DependencyHistory::new(); + + dependency_history + .inner + .push(type_name::<dyn subjects::IUserManager>()); + + assert!(dependency_history.contains::<dyn subjects::IUserManager>()); + + assert!(!dependency_history.contains::<dyn subjects::INumber>()); + } + + #[test] + fn display_works() + { + trait Ninja {} + trait Katana {} + trait Blade {} + + let mut dependency_history = DependencyHistory::new(); + + dependency_history.inner.push(type_name::<dyn Ninja>()); + dependency_history.inner.push(type_name::<dyn Katana>()); + dependency_history.inner.push(type_name::<dyn Blade>()); + + assert_eq!( + dependency_history.to_string(), + format!( + "{} -> {} -> {}", + type_name::<dyn Ninja>(), + type_name::<dyn Katana>(), + type_name::<dyn Blade>() + ) + ); + + dependency_history.inner.push(type_name::<dyn Katana>()); + + assert_eq!( + dependency_history.to_string(), + format!( + concat!( + "{} -> {bold_mode}{}{reset_bold_mode} -> {} -> ", + "{bold_mode}{}{reset_bold_mode} -> ...", + ), + type_name::<dyn Ninja>(), + type_name::<dyn Katana>(), + type_name::<dyn Blade>(), + type_name::<dyn Katana>(), + bold_mode = BOLD_MODE, + reset_bold_mode = RESET_BOLD_MODE + ) + ); + } +} diff --git a/src/dependency_trace.rs b/src/dependency_trace.rs deleted file mode 100644 index 86906f4..0000000 --- a/src/dependency_trace.rs +++ /dev/null @@ -1,18 +0,0 @@ -#[must_use] -pub fn create_dependency_trace( - dependency_history: &[&'static str], - err_dependency: &'static str, -) -> String -{ - dependency_history - .iter() - .map(|dep| { - if dep == &err_dependency { - format!("\x1b[1m{}\x1b[22m", dep) - } else { - (*dep).to_string() - } - }) - .collect::<Vec<_>>() - .join(" -> ") -} diff --git a/src/di_container/asynchronous/binding/builder.rs b/src/di_container/asynchronous/binding/builder.rs index f334cd7..3d03562 100644 --- a/src/di_container/asynchronous/binding/builder.rs +++ b/src/di_container/asynchronous/binding/builder.rs @@ -5,6 +5,7 @@ use std::any::type_name; use std::marker::PhantomData; use std::sync::Arc; +use crate::dependency_history::IDependencyHistory; use crate::di_container::asynchronous::binding::scope_configurator::AsyncBindingScopeConfigurator; #[cfg(feature = "factory")] use crate::di_container::asynchronous::binding::when_configurator::AsyncBindingWhenConfigurator; @@ -20,24 +21,33 @@ pub type BoxFn<Args, Return> = Box<(dyn Fn<Args, Output = Return> + Send + Sync) /// Binding builder for type `Interface` inside a [`IAsyncDIContainer`]. /// /// [`IAsyncDIContainer`]: crate::di_container::asynchronous::IAsyncDIContainer -pub struct AsyncBindingBuilder<Interface, DIContainerType> +pub struct AsyncBindingBuilder<Interface, DIContainerType, DependencyHistoryType> where Interface: 'static + ?Sized + Send + Sync, - DIContainerType: IAsyncDIContainer, + DIContainerType: IAsyncDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory + Send + Sync, { di_container: Arc<DIContainerType>, + dependency_history_factory: fn() -> DependencyHistoryType, + interface_phantom: PhantomData<Interface>, } -impl<Interface, DIContainerType> AsyncBindingBuilder<Interface, DIContainerType> +impl<Interface, DIContainerType, DependencyHistoryType> + AsyncBindingBuilder<Interface, DIContainerType, DependencyHistoryType> where Interface: 'static + ?Sized + Send + Sync, - DIContainerType: IAsyncDIContainer, + DIContainerType: IAsyncDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory + Send + Sync + 'static, { - pub(crate) fn new(di_container: Arc<DIContainerType>) -> Self + pub(crate) fn new( + di_container: Arc<DIContainerType>, + dependency_history_factory: fn() -> DependencyHistoryType, + ) -> Self { Self { di_container, + dependency_history_factory, interface_phantom: PhantomData, } } @@ -88,11 +98,16 @@ where pub async fn to<Implementation>( &self, ) -> Result< - AsyncBindingScopeConfigurator<Interface, Implementation, DIContainerType>, + AsyncBindingScopeConfigurator< + Interface, + Implementation, + DIContainerType, + DependencyHistoryType, + >, AsyncBindingBuilderError, > where - Implementation: AsyncInjectable<DIContainerType>, + Implementation: AsyncInjectable<DIContainerType, DependencyHistoryType>, { if self.di_container.has_binding::<Interface>(None).await { return Err(AsyncBindingBuilderError::BindingAlreadyExists(type_name::< @@ -101,8 +116,10 @@ where ))); } - let binding_scope_configurator = - AsyncBindingScopeConfigurator::new(self.di_container.clone()); + let binding_scope_configurator = AsyncBindingScopeConfigurator::new( + self.di_container.clone(), + self.dependency_history_factory, + ); binding_scope_configurator.in_transient_scope().await; @@ -164,7 +181,7 @@ where &self, factory_func: &'static FactoryFunc, ) -> Result< - AsyncBindingWhenConfigurator<Interface, DIContainerType>, + AsyncBindingWhenConfigurator<Interface, DIContainerType, DependencyHistoryType>, AsyncBindingBuilderError, > where @@ -257,7 +274,7 @@ where &self, factory_func: &'static FactoryFunc, ) -> Result< - AsyncBindingWhenConfigurator<Interface, DIContainerType>, + AsyncBindingWhenConfigurator<Interface, DIContainerType, DependencyHistoryType>, AsyncBindingBuilderError, > where @@ -350,7 +367,7 @@ where &self, factory_func: &'static FactoryFunc, ) -> Result< - AsyncBindingWhenConfigurator<Interface, DIContainerType>, + AsyncBindingWhenConfigurator<Interface, DIContainerType, DependencyHistoryType>, AsyncBindingBuilderError, > where @@ -444,7 +461,7 @@ where &self, factory_func: &'static FactoryFunc, ) -> Result< - AsyncBindingWhenConfigurator<Interface, DIContainerType>, + AsyncBindingWhenConfigurator<Interface, DIContainerType, DependencyHistoryType>, AsyncBindingBuilderError, > where @@ -489,13 +506,14 @@ mod tests use mockall::predicate::eq; use super::*; - use crate::test_utils::mocks::async_di_container::MockAsyncDIContainer; - use crate::test_utils::subjects_async; + use crate::test_utils::{mocks, subjects_async}; #[tokio::test] async fn can_bind_to() -> Result<(), Box<dyn Error>> { - let mut di_container_mock = MockAsyncDIContainer::new(); + let mut di_container_mock = mocks::async_di_container::MockAsyncDIContainer::< + mocks::MockDependencyHistory, + >::new(); di_container_mock .expect_has_binding::<dyn subjects_async::IUserManager>() @@ -511,8 +529,12 @@ mod tests let binding_builder = AsyncBindingBuilder::< dyn subjects_async::IUserManager, - MockAsyncDIContainer, - >::new(Arc::new(di_container_mock)); + mocks::async_di_container::MockAsyncDIContainer<mocks::MockDependencyHistory>, + mocks::MockDependencyHistory, + >::new( + Arc::new(di_container_mock), + mocks::MockDependencyHistory::new, + ); binding_builder.to::<subjects_async::UserManager>().await?; @@ -534,7 +556,8 @@ mod tests subjects_async::Number, ) -> dyn subjects_async::IUserManager; - let mut di_container_mock = MockAsyncDIContainer::new(); + let mut di_container_mock = + mocks::async_di_container::MockAsyncDIContainer::new(); di_container_mock .expect_has_binding::<IUserManagerFactory>() @@ -550,8 +573,12 @@ mod tests let binding_builder = AsyncBindingBuilder::< IUserManagerFactory, - MockAsyncDIContainer, - >::new(Arc::new(di_container_mock)); + mocks::async_di_container::MockAsyncDIContainer<mocks::MockDependencyHistory>, + mocks::MockDependencyHistory, + >::new( + Arc::new(di_container_mock), + mocks::MockDependencyHistory::new, + ); binding_builder .to_factory(&|_| { @@ -577,7 +604,8 @@ mod tests #[factory(async = true)] type IUserManagerFactory = dyn Fn(String) -> dyn subjects_async::IUserManager; - let mut di_container_mock = MockAsyncDIContainer::new(); + let mut di_container_mock = + mocks::async_di_container::MockAsyncDIContainer::new(); di_container_mock .expect_has_binding::<IUserManagerFactory>() @@ -593,8 +621,12 @@ mod tests let binding_builder = AsyncBindingBuilder::< IUserManagerFactory, - MockAsyncDIContainer, - >::new(Arc::new(di_container_mock)); + mocks::async_di_container::MockAsyncDIContainer<mocks::MockDependencyHistory>, + mocks::MockDependencyHistory, + >::new( + Arc::new(di_container_mock), + mocks::MockDependencyHistory::new, + ); binding_builder .to_async_factory(&|_| { @@ -621,7 +653,8 @@ mod tests declare_default_factory!(dyn subjects_async::IUserManager); - let mut di_container_mock = MockAsyncDIContainer::new(); + let mut di_container_mock = + mocks::async_di_container::MockAsyncDIContainer::new(); di_container_mock .expect_has_binding::<dyn subjects_async::IUserManager>() @@ -637,8 +670,12 @@ mod tests let binding_builder = AsyncBindingBuilder::< dyn subjects_async::IUserManager, - MockAsyncDIContainer, - >::new(Arc::new(di_container_mock)); + mocks::async_di_container::MockAsyncDIContainer<mocks::MockDependencyHistory>, + mocks::MockDependencyHistory, + >::new( + Arc::new(di_container_mock), + mocks::MockDependencyHistory::new, + ); binding_builder .to_default_factory(&|_| { @@ -665,7 +702,8 @@ mod tests declare_default_factory!(dyn subjects_async::IUserManager, async = true); - let mut di_container_mock = MockAsyncDIContainer::new(); + let mut di_container_mock = + mocks::async_di_container::MockAsyncDIContainer::new(); di_container_mock .expect_has_binding::<dyn subjects_async::IUserManager>() @@ -681,8 +719,12 @@ mod tests let binding_builder = AsyncBindingBuilder::< dyn subjects_async::IUserManager, - MockAsyncDIContainer, - >::new(Arc::new(di_container_mock)); + mocks::async_di_container::MockAsyncDIContainer<mocks::MockDependencyHistory>, + mocks::MockDependencyHistory, + >::new( + Arc::new(di_container_mock), + mocks::MockDependencyHistory::new, + ); binding_builder .to_async_default_factory(&|_| { diff --git a/src/di_container/asynchronous/binding/scope_configurator.rs b/src/di_container/asynchronous/binding/scope_configurator.rs index e2e916a..b5923ec 100644 --- a/src/di_container/asynchronous/binding/scope_configurator.rs +++ b/src/di_container/asynchronous/binding/scope_configurator.rs @@ -4,6 +4,7 @@ use std::marker::PhantomData; use std::sync::Arc; +use crate::dependency_history::IDependencyHistory; use crate::di_container::asynchronous::binding::when_configurator::AsyncBindingWhenConfigurator; use crate::di_container::asynchronous::IAsyncDIContainer; use crate::errors::async_di_container::AsyncBindingScopeConfiguratorError; @@ -14,28 +15,45 @@ use crate::ptr::ThreadsafeSingletonPtr; /// Scope configurator for a binding for type 'Interface' inside a [`IAsyncDIContainer`]. /// /// [`IAsyncDIContainer`]: crate::di_container::asynchronous::IAsyncDIContainer -pub struct AsyncBindingScopeConfigurator<Interface, Implementation, DIContainerType> -where +pub struct AsyncBindingScopeConfigurator< + Interface, + Implementation, + DIContainerType, + DependencyHistoryType, +> where Interface: 'static + ?Sized + Send + Sync, - Implementation: AsyncInjectable<DIContainerType>, - DIContainerType: IAsyncDIContainer, + Implementation: AsyncInjectable<DIContainerType, DependencyHistoryType>, + DIContainerType: IAsyncDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory + Send + Sync, { di_container: Arc<DIContainerType>, + dependency_history_factory: fn() -> DependencyHistoryType, + interface_phantom: PhantomData<Interface>, implementation_phantom: PhantomData<Implementation>, } -impl<Interface, Implementation, DIContainerType> - AsyncBindingScopeConfigurator<Interface, Implementation, DIContainerType> +impl<Interface, Implementation, DIContainerType, DependencyHistoryType> + AsyncBindingScopeConfigurator< + Interface, + Implementation, + DIContainerType, + DependencyHistoryType, + > where Interface: 'static + ?Sized + Send + Sync, - Implementation: AsyncInjectable<DIContainerType>, - DIContainerType: IAsyncDIContainer, + Implementation: AsyncInjectable<DIContainerType, DependencyHistoryType>, + DIContainerType: IAsyncDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory + Send + Sync + 'static, { - pub(crate) fn new(di_container: Arc<DIContainerType>) -> Self + pub(crate) fn new( + di_container: Arc<DIContainerType>, + dependency_history_factory: fn() -> DependencyHistoryType, + ) -> Self { Self { di_container, + dependency_history_factory, interface_phantom: PhantomData, implementation_phantom: PhantomData, } @@ -46,14 +64,16 @@ where /// This is the default. pub async fn in_transient_scope( &self, - ) -> AsyncBindingWhenConfigurator<Interface, DIContainerType> + ) -> AsyncBindingWhenConfigurator<Interface, DIContainerType, DependencyHistoryType> { self.di_container .set_binding::<Interface>( None, - Box::new( - AsyncTransientTypeProvider::<Implementation, DIContainerType>::new(), - ), + Box::new(AsyncTransientTypeProvider::< + Implementation, + DIContainerType, + DependencyHistoryType, + >::new()), ) .await; @@ -67,17 +87,18 @@ where pub async fn in_singleton_scope( &self, ) -> Result< - AsyncBindingWhenConfigurator<Interface, DIContainerType>, + AsyncBindingWhenConfigurator<Interface, DIContainerType, DependencyHistoryType>, AsyncBindingScopeConfiguratorError, > { let singleton: ThreadsafeSingletonPtr<Implementation> = ThreadsafeSingletonPtr::from( - Implementation::resolve(&self.di_container, Vec::new()) - .await - .map_err( - AsyncBindingScopeConfiguratorError::SingletonResolveFailed, - )?, + Implementation::resolve( + &self.di_container, + (self.dependency_history_factory)(), + ) + .await + .map_err(AsyncBindingScopeConfiguratorError::SingletonResolveFailed)?, ); self.di_container @@ -112,8 +133,12 @@ mod tests let binding_scope_configurator = AsyncBindingScopeConfigurator::< dyn subjects_async::IUserManager, subjects_async::UserManager, - mocks::async_di_container::MockAsyncDIContainer, - >::new(Arc::new(di_container_mock)); + mocks::async_di_container::MockAsyncDIContainer<mocks::MockDependencyHistory>, + mocks::MockDependencyHistory, + >::new( + Arc::new(di_container_mock), + mocks::MockDependencyHistory::new, + ); binding_scope_configurator.in_transient_scope().await; } @@ -133,8 +158,12 @@ mod tests let binding_scope_configurator = AsyncBindingScopeConfigurator::< dyn subjects_async::IUserManager, subjects_async::UserManager, - mocks::async_di_container::MockAsyncDIContainer, - >::new(Arc::new(di_container_mock)); + mocks::async_di_container::MockAsyncDIContainer<mocks::MockDependencyHistory>, + mocks::MockDependencyHistory, + >::new( + Arc::new(di_container_mock), + mocks::MockDependencyHistory::new, + ); assert!(matches!( binding_scope_configurator.in_singleton_scope().await, diff --git a/src/di_container/asynchronous/binding/when_configurator.rs b/src/di_container/asynchronous/binding/when_configurator.rs index 9a1505b..4d56347 100644 --- a/src/di_container/asynchronous/binding/when_configurator.rs +++ b/src/di_container/asynchronous/binding/when_configurator.rs @@ -5,31 +5,38 @@ use std::any::type_name; use std::marker::PhantomData; use std::sync::Arc; +use crate::dependency_history::IDependencyHistory; use crate::di_container::asynchronous::IAsyncDIContainer; use crate::errors::async_di_container::AsyncBindingWhenConfiguratorError; /// When configurator for a binding for type 'Interface' inside a [`IAsyncDIContainer`]. /// /// [`IAsyncDIContainer`]: crate::di_container::asynchronous::IAsyncDIContainer -pub struct AsyncBindingWhenConfigurator<Interface, DIContainerType> +pub struct AsyncBindingWhenConfigurator<Interface, DIContainerType, DependencyHistoryType> where Interface: 'static + ?Sized + Send + Sync, - DIContainerType: IAsyncDIContainer, + DIContainerType: IAsyncDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory + Send + Sync, { di_container: Arc<DIContainerType>, + interface_phantom: PhantomData<Interface>, + dependency_history_phantom: PhantomData<DependencyHistoryType>, } -impl<Interface, DIContainerType> AsyncBindingWhenConfigurator<Interface, DIContainerType> +impl<Interface, DIContainerType, DependencyHistoryType> + AsyncBindingWhenConfigurator<Interface, DIContainerType, DependencyHistoryType> where Interface: 'static + ?Sized + Send + Sync, - DIContainerType: IAsyncDIContainer, + DIContainerType: IAsyncDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory + Send + Sync, { pub(crate) fn new(di_container: Arc<DIContainerType>) -> Self { Self { di_container, interface_phantom: PhantomData, + dependency_history_phantom: PhantomData, } } @@ -92,7 +99,8 @@ mod tests let binding_when_configurator = AsyncBindingWhenConfigurator::< dyn subjects_async::INumber, - mocks::async_di_container::MockAsyncDIContainer, + mocks::async_di_container::MockAsyncDIContainer<mocks::MockDependencyHistory>, + mocks::MockDependencyHistory, >::new(Arc::new(di_container_mock)); assert!(matches!( diff --git a/src/di_container/asynchronous/mod.rs b/src/di_container/asynchronous/mod.rs index 128fbbe..99a33be 100644 --- a/src/di_container/asynchronous/mod.rs +++ b/src/di_container/asynchronous/mod.rs @@ -57,6 +57,7 @@ use std::sync::Arc; use async_trait::async_trait; use tokio::sync::Mutex; +use crate::dependency_history::{DependencyHistory, IDependencyHistory}; use crate::di_container::asynchronous::binding::builder::AsyncBindingBuilder; use crate::di_container::binding_storage::DIContainerBindingStorage; use crate::errors::async_di_container::AsyncDIContainerError; @@ -71,12 +72,16 @@ pub mod prelude; /// Dependency injection container interface. #[async_trait] -pub trait IAsyncDIContainer: - Sized + 'static + Send + Sync + details::DIContainerInternals +pub trait IAsyncDIContainer<DependencyHistoryType>: + Sized + 'static + Send + Sync + details::DIContainerInternals<DependencyHistoryType> +where + DependencyHistoryType: IDependencyHistory + Send + Sync, { /// Returns a new [`AsyncBindingBuilder`] for the given interface. #[must_use] - fn bind<Interface>(self: &mut Arc<Self>) -> AsyncBindingBuilder<Interface, Self> + fn bind<Interface>( + self: &mut Arc<Self>, + ) -> AsyncBindingBuilder<Interface, Self, DependencyHistoryType> where Interface: 'static + ?Sized + Send + Sync; @@ -114,7 +119,7 @@ pub trait IAsyncDIContainer: #[doc(hidden)] async fn get_bound<Interface>( self: &Arc<Self>, - dependency_history: Vec<&'static str>, + dependency_history: DependencyHistoryType, name: Option<&'static str>, ) -> Result<SomeThreadsafePtr<Interface>, AsyncDIContainerError> where @@ -124,7 +129,8 @@ pub trait IAsyncDIContainer: /// Dependency injection container. pub struct AsyncDIContainer { - binding_storage: Mutex<DIContainerBindingStorage<dyn IAsyncProvider<Self>>>, + binding_storage: + Mutex<DIContainerBindingStorage<dyn IAsyncProvider<Self, DependencyHistory>>>, } impl AsyncDIContainer @@ -140,14 +146,16 @@ impl AsyncDIContainer } #[async_trait] -impl IAsyncDIContainer for AsyncDIContainer +impl IAsyncDIContainer<DependencyHistory> for AsyncDIContainer { #[must_use] - fn bind<Interface>(self: &mut Arc<Self>) -> AsyncBindingBuilder<Interface, Self> + fn bind<Interface>( + self: &mut Arc<Self>, + ) -> AsyncBindingBuilder<Interface, Self, DependencyHistory> where Interface: 'static + ?Sized + Send + Sync, { - AsyncBindingBuilder::new(self.clone()) + AsyncBindingBuilder::new(self.clone(), DependencyHistory::new) } fn get<'a, 'b, Interface>( @@ -158,7 +166,10 @@ impl IAsyncDIContainer for AsyncDIContainer 'a: 'b, Self: 'b, { - Box::pin(async { self.get_bound::<Interface>(Vec::new(), None).await }) + Box::pin(async { + self.get_bound::<Interface>(DependencyHistory::new(), None) + .await + }) } fn get_named<'a, 'b, Interface>( @@ -170,12 +181,15 @@ impl IAsyncDIContainer for AsyncDIContainer 'a: 'b, Self: 'b, { - Box::pin(async { self.get_bound::<Interface>(Vec::new(), Some(name)).await }) + Box::pin(async { + self.get_bound::<Interface>(DependencyHistory::new(), Some(name)) + .await + }) } async fn get_bound<Interface>( self: &Arc<Self>, - dependency_history: Vec<&'static str>, + dependency_history: DependencyHistory, name: Option<&'static str>, ) -> Result<SomeThreadsafePtr<Interface>, AsyncDIContainerError> where @@ -190,7 +204,7 @@ impl IAsyncDIContainer for AsyncDIContainer } #[async_trait] -impl details::DIContainerInternals for AsyncDIContainer +impl details::DIContainerInternals<DependencyHistory> for AsyncDIContainer { async fn has_binding<Interface>(self: &Arc<Self>, name: Option<&'static str>) -> bool where @@ -202,7 +216,7 @@ impl details::DIContainerInternals for AsyncDIContainer async fn set_binding<Interface>( self: &Arc<Self>, name: Option<&'static str>, - provider: Box<dyn IAsyncProvider<Self>>, + provider: Box<dyn IAsyncProvider<Self, DependencyHistory>>, ) where Interface: 'static + ?Sized, { @@ -215,7 +229,7 @@ impl details::DIContainerInternals for AsyncDIContainer async fn remove_binding<Interface>( self: &Arc<Self>, name: Option<&'static str>, - ) -> Option<Box<dyn IAsyncProvider<Self>>> + ) -> Option<Box<dyn IAsyncProvider<Self, DependencyHistory>>> where Interface: 'static + ?Sized, { @@ -227,7 +241,7 @@ impl AsyncDIContainer { async fn handle_binding_providable<Interface>( self: &Arc<Self>, - binding_providable: AsyncProvidable<Self>, + binding_providable: AsyncProvidable<Self, DependencyHistory>, ) -> Result<SomeThreadsafePtr<Interface>, AsyncDIContainerError> where Interface: 'static + ?Sized + Send + Sync, @@ -344,8 +358,8 @@ impl AsyncDIContainer async fn get_binding_providable<Interface>( self: &Arc<Self>, name: Option<&'static str>, - dependency_history: Vec<&'static str>, - ) -> Result<AsyncProvidable<Self>, AsyncDIContainerError> + dependency_history: DependencyHistory, + ) -> Result<AsyncProvidable<Self, DependencyHistory>, AsyncDIContainerError> where Interface: 'static + ?Sized + Send + Sync, { @@ -384,10 +398,13 @@ pub(crate) mod details use async_trait::async_trait; + use crate::dependency_history::IDependencyHistory; use crate::provider::r#async::IAsyncProvider; #[async_trait] - pub trait DIContainerInternals + pub trait DIContainerInternals<DependencyHistoryType> + where + DependencyHistoryType: IDependencyHistory, { async fn has_binding<Interface>( self: &Arc<Self>, @@ -399,14 +416,14 @@ pub(crate) mod details async fn set_binding<Interface>( self: &Arc<Self>, name: Option<&'static str>, - provider: Box<dyn IAsyncProvider<Self>>, + provider: Box<dyn IAsyncProvider<Self, DependencyHistoryType>>, ) where Interface: 'static + ?Sized; async fn remove_binding<Interface>( self: &Arc<Self>, name: Option<&'static str>, - ) -> Option<Box<dyn IAsyncProvider<Self>>> + ) -> Option<Box<dyn IAsyncProvider<Self, DependencyHistoryType>>> where Interface: 'static + ?Sized; } @@ -417,39 +434,20 @@ mod tests { use std::error::Error; - use async_trait::async_trait; - use mockall::mock; - use super::*; - use crate::errors::injectable::InjectableError; use crate::ptr::{ThreadsafeSingletonPtr, TransientPtr}; + use crate::test_utils::mocks::async_provider::MockAsyncProvider; use crate::test_utils::subjects_async; #[tokio::test] async fn can_get() -> Result<(), Box<dyn Error>> { - mock! { - Provider {} - - #[async_trait] - impl IAsyncProvider<AsyncDIContainer> for Provider - { - async fn provide( - &self, - di_container: &Arc<AsyncDIContainer>, - dependency_history: Vec<&'static str>, - ) -> Result<AsyncProvidable<AsyncDIContainer>, InjectableError>; - - fn do_clone(&self) -> Box<dyn IAsyncProvider<AsyncDIContainer>>; - } - } - let di_container = AsyncDIContainer::new(); - let mut mock_provider = MockProvider::new(); + let mut mock_provider = MockAsyncProvider::new(); mock_provider.expect_do_clone().returning(|| { - let mut inner_mock_provider = MockProvider::new(); + let mut inner_mock_provider = MockAsyncProvider::new(); inner_mock_provider.expect_provide().returning(|_, _| { Ok(AsyncProvidable::Transient(TransientPtr::new( @@ -479,28 +477,12 @@ mod tests #[tokio::test] async fn can_get_named() -> Result<(), Box<dyn Error>> { - mock! { - Provider {} - - #[async_trait] - impl IAsyncProvider<AsyncDIContainer> for Provider - { - async fn provide( - &self, - di_container: &Arc<AsyncDIContainer>, - dependency_history: Vec<&'static str>, - ) -> Result<AsyncProvidable<AsyncDIContainer>, InjectableError>; - - fn do_clone(&self) -> Box<dyn IAsyncProvider<AsyncDIContainer>>; - } - } - let di_container = AsyncDIContainer::new(); - let mut mock_provider = MockProvider::new(); + let mut mock_provider = MockAsyncProvider::new(); mock_provider.expect_do_clone().returning(|| { - let mut inner_mock_provider = MockProvider::new(); + let mut inner_mock_provider = MockAsyncProvider::new(); inner_mock_provider.expect_provide().returning(|_, _| { Ok(AsyncProvidable::Transient(TransientPtr::new( @@ -533,32 +515,16 @@ mod tests #[tokio::test] async fn can_get_singleton() -> Result<(), Box<dyn Error>> { - mock! { - Provider {} - - #[async_trait] - impl IAsyncProvider<AsyncDIContainer> for Provider - { - async fn provide( - &self, - di_container: &Arc<AsyncDIContainer>, - dependency_history: Vec<&'static str>, - ) -> Result<AsyncProvidable<AsyncDIContainer>, InjectableError>; - - fn do_clone(&self) -> Box<dyn IAsyncProvider<AsyncDIContainer>>; - } - } - let di_container = AsyncDIContainer::new(); - let mut mock_provider = MockProvider::new(); + let mut mock_provider = MockAsyncProvider::new(); let mut singleton = ThreadsafeSingletonPtr::new(subjects_async::Number::new()); ThreadsafeSingletonPtr::get_mut(&mut singleton).unwrap().num = 2820; mock_provider.expect_do_clone().returning(move || { - let mut inner_mock_provider = MockProvider::new(); + let mut inner_mock_provider = MockAsyncProvider::new(); let singleton_clone = singleton.clone(); @@ -597,32 +563,16 @@ mod tests #[tokio::test] async fn can_get_singleton_named() -> Result<(), Box<dyn Error>> { - mock! { - Provider {} - - #[async_trait] - impl IAsyncProvider<AsyncDIContainer> for Provider - { - async fn provide( - &self, - di_container: &Arc<AsyncDIContainer>, - dependency_history: Vec<&'static str>, - ) -> Result<AsyncProvidable<AsyncDIContainer>, InjectableError>; - - fn do_clone(&self) -> Box<dyn IAsyncProvider<AsyncDIContainer>>; - } - } - let di_container = AsyncDIContainer::new(); - let mut mock_provider = MockProvider::new(); + let mut mock_provider = MockAsyncProvider::new(); let mut singleton = ThreadsafeSingletonPtr::new(subjects_async::Number::new()); ThreadsafeSingletonPtr::get_mut(&mut singleton).unwrap().num = 2820; mock_provider.expect_do_clone().returning(move || { - let mut inner_mock_provider = MockProvider::new(); + let mut inner_mock_provider = MockAsyncProvider::new(); let singleton_clone = singleton.clone(); @@ -707,32 +657,16 @@ mod tests #[crate::factory(threadsafe = true)] type IUserManagerFactory = dyn Fn(Vec<i128>) -> dyn IUserManager; - mock! { - Provider {} - - #[async_trait] - impl IAsyncProvider<AsyncDIContainer> for Provider - { - async fn provide( - &self, - di_container: &Arc<AsyncDIContainer>, - dependency_history: Vec<&'static str>, - ) -> Result<AsyncProvidable<AsyncDIContainer>, InjectableError>; - - fn do_clone(&self) -> Box<dyn IAsyncProvider<AsyncDIContainer>>; - } - } - let di_container = AsyncDIContainer::new(); - let mut mock_provider = MockProvider::new(); + let mut mock_provider = MockAsyncProvider::new(); mock_provider.expect_do_clone().returning(|| { type FactoryFunc = Box< (dyn Fn<(Vec<i128>,), Output = TransientPtr<dyn IUserManager>> + Send + Sync) >; - let mut inner_mock_provider = MockProvider::new(); + let mut inner_mock_provider = MockAsyncProvider::new(); let factory_func: &'static (dyn Fn< (Arc<AsyncDIContainer>,), @@ -818,32 +752,16 @@ mod tests #[crate::factory(threadsafe = true)] type IUserManagerFactory = dyn Fn(Vec<i128>) -> dyn IUserManager; - mock! { - Provider {} - - #[async_trait] - impl IAsyncProvider<AsyncDIContainer> for Provider - { - async fn provide( - &self, - di_container: &Arc<AsyncDIContainer>, - dependency_history: Vec<&'static str>, - ) -> Result<AsyncProvidable<AsyncDIContainer>, InjectableError>; - - fn do_clone(&self) -> Box<dyn IAsyncProvider<AsyncDIContainer>>; - } - } - let di_container = AsyncDIContainer::new(); - let mut mock_provider = MockProvider::new(); + let mut mock_provider = MockAsyncProvider::new(); mock_provider.expect_do_clone().returning(|| { type FactoryFunc = Box< (dyn Fn<(Vec<i128>,), Output = TransientPtr<dyn IUserManager>> + Send + Sync) >; - let mut inner_mock_provider = MockProvider::new(); + let mut inner_mock_provider = MockAsyncProvider::new(); let factory_func: &'static (dyn Fn< (Arc<AsyncDIContainer>,), diff --git a/src/di_container/blocking/binding/builder.rs b/src/di_container/blocking/binding/builder.rs index e1c1561..7aa1755 100644 --- a/src/di_container/blocking/binding/builder.rs +++ b/src/di_container/blocking/binding/builder.rs @@ -5,6 +5,7 @@ use std::any::type_name; use std::marker::PhantomData; use std::rc::Rc; +use crate::dependency_history::IDependencyHistory; use crate::di_container::blocking::binding::scope_configurator::BindingScopeConfigurator; #[cfg(feature = "factory")] use crate::di_container::blocking::binding::when_configurator::BindingWhenConfigurator; @@ -15,24 +16,33 @@ use crate::interfaces::injectable::Injectable; /// Binding builder for type `Interface` inside a [`IDIContainer`]. /// /// [`IDIContainer`]: crate::di_container::blocking::IDIContainer -pub struct BindingBuilder<Interface, DIContainerType> +pub struct BindingBuilder<Interface, DIContainerType, DependencyHistoryType> where Interface: 'static + ?Sized, - DIContainerType: IDIContainer, + DIContainerType: IDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory, { di_container: Rc<DIContainerType>, + dependency_history_factory: fn() -> DependencyHistoryType, + interface_phantom: PhantomData<Interface>, } -impl<Interface, DIContainerType> BindingBuilder<Interface, DIContainerType> +impl<Interface, DIContainerType, DependencyHistoryType> + BindingBuilder<Interface, DIContainerType, DependencyHistoryType> where Interface: 'static + ?Sized, - DIContainerType: IDIContainer, + DIContainerType: IDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory + 'static, { - pub(crate) fn new(di_container: Rc<DIContainerType>) -> Self + pub(crate) fn new( + di_container: Rc<DIContainerType>, + dependency_history_factory: fn() -> DependencyHistoryType, + ) -> Self { Self { di_container, + dependency_history_factory, interface_phantom: PhantomData, } } @@ -82,11 +92,16 @@ where pub fn to<Implementation>( &self, ) -> Result< - BindingScopeConfigurator<Interface, Implementation, DIContainerType>, + BindingScopeConfigurator< + Interface, + Implementation, + DIContainerType, + DependencyHistoryType, + >, BindingBuilderError, > where - Implementation: Injectable<DIContainerType>, + Implementation: Injectable<DIContainerType, DependencyHistoryType>, { { if self.di_container.has_binding::<Interface>(None) { @@ -97,8 +112,10 @@ where } } - let binding_scope_configurator = - BindingScopeConfigurator::new(self.di_container.clone()); + let binding_scope_configurator = BindingScopeConfigurator::new( + self.di_container.clone(), + self.dependency_history_factory, + ); binding_scope_configurator.in_transient_scope(); @@ -176,7 +193,10 @@ where pub fn to_factory<Args, Return, Func>( &self, factory_func: &'static Func, - ) -> Result<BindingWhenConfigurator<Interface, DIContainerType>, BindingBuilderError> + ) -> Result< + BindingWhenConfigurator<Interface, DIContainerType, DependencyHistoryType>, + BindingBuilderError, + > where Args: 'static, Return: 'static + ?Sized, @@ -262,7 +282,10 @@ where pub fn to_default_factory<Return, FactoryFunc>( &self, factory_func: &'static FactoryFunc, - ) -> Result<BindingWhenConfigurator<Interface, DIContainerType>, BindingBuilderError> + ) -> Result< + BindingWhenConfigurator<Interface, DIContainerType, DependencyHistoryType>, + BindingBuilderError, + > where Return: 'static + ?Sized, FactoryFunc: Fn< @@ -323,8 +346,12 @@ mod tests let binding_builder = BindingBuilder::< dyn subjects::INumber, - mocks::blocking_di_container::MockDIContainer, - >::new(Rc::new(mock_di_container)); + mocks::blocking_di_container::MockDIContainer<mocks::MockDependencyHistory>, + mocks::MockDependencyHistory, + >::new( + Rc::new(mock_di_container), + mocks::MockDependencyHistory::new, + ); binding_builder.to::<subjects::Number>()?; @@ -358,8 +385,12 @@ mod tests let binding_builder = BindingBuilder::< IUserManagerFactory, - mocks::blocking_di_container::MockDIContainer, - >::new(Rc::new(mock_di_container)); + mocks::blocking_di_container::MockDIContainer<mocks::MockDependencyHistory>, + mocks::MockDependencyHistory, + >::new( + Rc::new(mock_di_container), + mocks::MockDependencyHistory::new, + ); binding_builder.to_factory(&|_| { Box::new(move |_num, _text| { @@ -400,8 +431,12 @@ mod tests let binding_builder = BindingBuilder::< dyn subjects::IUserManager, - mocks::blocking_di_container::MockDIContainer, - >::new(Rc::new(mock_di_container)); + mocks::blocking_di_container::MockDIContainer<mocks::MockDependencyHistory>, + mocks::MockDependencyHistory, + >::new( + Rc::new(mock_di_container), + mocks::MockDependencyHistory::new, + ); binding_builder.to_default_factory(&|_| { Box::new(move || { diff --git a/src/di_container/blocking/binding/scope_configurator.rs b/src/di_container/blocking/binding/scope_configurator.rs index dc33cbc..6c6c32d 100644 --- a/src/di_container/blocking/binding/scope_configurator.rs +++ b/src/di_container/blocking/binding/scope_configurator.rs @@ -4,6 +4,7 @@ use std::marker::PhantomData; use std::rc::Rc; +use crate::dependency_history::IDependencyHistory; use crate::di_container::blocking::binding::when_configurator::BindingWhenConfigurator; use crate::di_container::blocking::IDIContainer; use crate::errors::di_container::BindingScopeConfiguratorError; @@ -14,28 +15,45 @@ use crate::ptr::SingletonPtr; /// Scope configurator for a binding for type 'Interface' inside a [`IDIContainer`]. /// /// [`IDIContainer`]: crate::di_container::blocking::IDIContainer -pub struct BindingScopeConfigurator<Interface, Implementation, DIContainerType> -where +pub struct BindingScopeConfigurator< + Interface, + Implementation, + DIContainerType, + DependencyHistoryType, +> where Interface: 'static + ?Sized, - Implementation: Injectable<DIContainerType>, - DIContainerType: IDIContainer, + Implementation: Injectable<DIContainerType, DependencyHistoryType>, + DIContainerType: IDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory, { di_container: Rc<DIContainerType>, + dependency_history_factory: fn() -> DependencyHistoryType, + interface_phantom: PhantomData<Interface>, implementation_phantom: PhantomData<Implementation>, } -impl<Interface, Implementation, DIContainerType> - BindingScopeConfigurator<Interface, Implementation, DIContainerType> +impl<Interface, Implementation, DIContainerType, DependencyHistoryType> + BindingScopeConfigurator< + Interface, + Implementation, + DIContainerType, + DependencyHistoryType, + > where Interface: 'static + ?Sized, - Implementation: Injectable<DIContainerType>, - DIContainerType: IDIContainer, + Implementation: Injectable<DIContainerType, DependencyHistoryType>, + DIContainerType: IDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory + 'static, { - pub(crate) fn new(di_container: Rc<DIContainerType>) -> Self + pub(crate) fn new( + di_container: Rc<DIContainerType>, + dependency_history_factory: fn() -> DependencyHistoryType, + ) -> Self { Self { di_container, + dependency_history_factory, interface_phantom: PhantomData, implementation_phantom: PhantomData, } @@ -47,11 +65,15 @@ where #[allow(clippy::must_use_candidate)] pub fn in_transient_scope( &self, - ) -> BindingWhenConfigurator<Interface, DIContainerType> + ) -> BindingWhenConfigurator<Interface, DIContainerType, DependencyHistoryType> { self.di_container.set_binding::<Interface>( None, - Box::new(TransientTypeProvider::<Implementation, DIContainerType>::new()), + Box::new(TransientTypeProvider::< + Implementation, + DIContainerType, + DependencyHistoryType, + >::new()), ); BindingWhenConfigurator::new(self.di_container.clone()) @@ -64,13 +86,16 @@ where pub fn in_singleton_scope( &self, ) -> Result< - BindingWhenConfigurator<Interface, DIContainerType>, + BindingWhenConfigurator<Interface, DIContainerType, DependencyHistoryType>, BindingScopeConfiguratorError, > { let singleton: SingletonPtr<Implementation> = SingletonPtr::from( - Implementation::resolve(&self.di_container, Vec::new()) - .map_err(BindingScopeConfiguratorError::SingletonResolveFailed)?, + Implementation::resolve( + &self.di_container, + (self.dependency_history_factory)(), + ) + .map_err(BindingScopeConfiguratorError::SingletonResolveFailed)?, ); self.di_container @@ -100,8 +125,12 @@ mod tests let binding_scope_configurator = BindingScopeConfigurator::< dyn subjects::IUserManager, subjects::UserManager, - mocks::blocking_di_container::MockDIContainer, - >::new(Rc::new(di_container_mock)); + mocks::blocking_di_container::MockDIContainer<mocks::MockDependencyHistory>, + mocks::MockDependencyHistory, + >::new( + Rc::new(di_container_mock), + mocks::MockDependencyHistory::new, + ); binding_scope_configurator.in_transient_scope(); } @@ -120,8 +149,12 @@ mod tests let binding_scope_configurator = BindingScopeConfigurator::< dyn subjects::IUserManager, subjects::UserManager, - mocks::blocking_di_container::MockDIContainer, - >::new(Rc::new(di_container_mock)); + mocks::blocking_di_container::MockDIContainer<mocks::MockDependencyHistory>, + mocks::MockDependencyHistory, + >::new( + Rc::new(di_container_mock), + mocks::MockDependencyHistory::new, + ); assert!(matches!( binding_scope_configurator.in_singleton_scope(), diff --git a/src/di_container/blocking/binding/when_configurator.rs b/src/di_container/blocking/binding/when_configurator.rs index 49c9d9e..f93806b 100644 --- a/src/di_container/blocking/binding/when_configurator.rs +++ b/src/di_container/blocking/binding/when_configurator.rs @@ -5,31 +5,38 @@ use std::any::type_name; use std::marker::PhantomData; use std::rc::Rc; +use crate::dependency_history::IDependencyHistory; use crate::di_container::blocking::IDIContainer; use crate::errors::di_container::BindingWhenConfiguratorError; /// When configurator for a binding for type 'Interface' inside a [`IDIContainer`]. /// /// [`IDIContainer`]: crate::di_container::blocking::IDIContainer -pub struct BindingWhenConfigurator<Interface, DIContainerType> +pub struct BindingWhenConfigurator<Interface, DIContainerType, DependencyHistoryType> where Interface: 'static + ?Sized, - DIContainerType: IDIContainer, + DIContainerType: IDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory, { di_container: Rc<DIContainerType>, + interface_phantom: PhantomData<Interface>, + dependency_history_phantom: PhantomData<DependencyHistoryType>, } -impl<Interface, DIContainerType> BindingWhenConfigurator<Interface, DIContainerType> +impl<Interface, DIContainerType, DependencyHistoryType> + BindingWhenConfigurator<Interface, DIContainerType, DependencyHistoryType> where Interface: 'static + ?Sized, - DIContainerType: IDIContainer, + DIContainerType: IDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory, { pub(crate) fn new(di_container: Rc<DIContainerType>) -> Self { Self { di_container, interface_phantom: PhantomData, + dependency_history_phantom: PhantomData, } } @@ -90,7 +97,8 @@ mod tests let binding_when_configurator = BindingWhenConfigurator::< dyn subjects::INumber, - mocks::blocking_di_container::MockDIContainer, + mocks::blocking_di_container::MockDIContainer<mocks::MockDependencyHistory>, + mocks::MockDependencyHistory, >::new(Rc::new(di_container_mock)); assert!(matches!( diff --git a/src/di_container/blocking/mod.rs b/src/di_container/blocking/mod.rs index bf77aba..6338118 100644 --- a/src/di_container/blocking/mod.rs +++ b/src/di_container/blocking/mod.rs @@ -54,6 +54,7 @@ use std::any::type_name; use std::cell::RefCell; use std::rc::Rc; +use crate::dependency_history::{DependencyHistory, IDependencyHistory}; use crate::di_container::binding_storage::DIContainerBindingStorage; use crate::di_container::blocking::binding::builder::BindingBuilder; use crate::errors::di_container::DIContainerError; @@ -65,10 +66,15 @@ pub mod binding; pub mod prelude; /// Blocking dependency injection container interface. -pub trait IDIContainer: Sized + 'static + details::DIContainerInternals +pub trait IDIContainer<DependencyHistoryType>: + Sized + 'static + details::DIContainerInternals<DependencyHistoryType> +where + DependencyHistoryType: IDependencyHistory, { /// Returns a new [`BindingBuilder`] for the given interface. - fn bind<Interface>(self: &mut Rc<Self>) -> BindingBuilder<Interface, Self> + fn bind<Interface>( + self: &mut Rc<Self>, + ) -> BindingBuilder<Interface, Self, DependencyHistoryType> where Interface: 'static + ?Sized; @@ -100,7 +106,7 @@ pub trait IDIContainer: Sized + 'static + details::DIContainerInternals #[doc(hidden)] fn get_bound<Interface>( self: &Rc<Self>, - dependency_history: Vec<&'static str>, + dependency_history: DependencyHistoryType, name: Option<&'static str>, ) -> Result<SomePtr<Interface>, DIContainerError> where @@ -110,7 +116,8 @@ pub trait IDIContainer: Sized + 'static + details::DIContainerInternals /// Blocking dependency injection container. pub struct DIContainer { - binding_storage: RefCell<DIContainerBindingStorage<dyn IProvider<Self>>>, + binding_storage: + RefCell<DIContainerBindingStorage<dyn IProvider<Self, DependencyHistory>>>, } impl DIContainer @@ -125,21 +132,23 @@ impl DIContainer } } -impl IDIContainer for DIContainer +impl IDIContainer<DependencyHistory> for DIContainer { #[must_use] - fn bind<Interface>(self: &mut Rc<Self>) -> BindingBuilder<Interface, Self> + fn bind<Interface>( + self: &mut Rc<Self>, + ) -> BindingBuilder<Interface, Self, DependencyHistory> where Interface: 'static + ?Sized, { - BindingBuilder::<Interface, Self>::new(self.clone()) + BindingBuilder::new(self.clone(), DependencyHistory::new) } fn get<Interface>(self: &Rc<Self>) -> Result<SomePtr<Interface>, DIContainerError> where Interface: 'static + ?Sized, { - self.get_bound::<Interface>(Vec::new(), None) + self.get_bound::<Interface>(DependencyHistory::new(), None) } fn get_named<Interface>( @@ -149,13 +158,13 @@ impl IDIContainer for DIContainer where Interface: 'static + ?Sized, { - self.get_bound::<Interface>(Vec::new(), Some(name)) + self.get_bound::<Interface>(DependencyHistory::new(), Some(name)) } #[doc(hidden)] fn get_bound<Interface>( self: &Rc<Self>, - dependency_history: Vec<&'static str>, + dependency_history: DependencyHistory, name: Option<&'static str>, ) -> Result<SomePtr<Interface>, DIContainerError> where @@ -168,7 +177,7 @@ impl IDIContainer for DIContainer } } -impl details::DIContainerInternals for DIContainer +impl details::DIContainerInternals<DependencyHistory> for DIContainer { fn has_binding<Interface>(self: &Rc<Self>, name: Option<&'static str>) -> bool where @@ -180,7 +189,7 @@ impl details::DIContainerInternals for DIContainer fn set_binding<Interface>( self: &Rc<Self>, name: Option<&'static str>, - provider: Box<dyn IProvider<Self>>, + provider: Box<dyn IProvider<Self, DependencyHistory>>, ) where Interface: 'static + ?Sized, { @@ -192,7 +201,7 @@ impl details::DIContainerInternals for DIContainer fn remove_binding<Interface>( self: &Rc<Self>, name: Option<&'static str>, - ) -> Option<Box<dyn IProvider<Self>>> + ) -> Option<Box<dyn IProvider<Self, DependencyHistory>>> where Interface: 'static + ?Sized, { @@ -204,7 +213,7 @@ impl DIContainer { fn handle_binding_providable<Interface>( self: &Rc<Self>, - binding_providable: Providable<Self>, + binding_providable: Providable<Self, DependencyHistory>, ) -> Result<SomePtr<Interface>, DIContainerError> where Interface: 'static + ?Sized, @@ -262,8 +271,8 @@ impl DIContainer fn get_binding_providable<Interface>( self: &Rc<Self>, name: Option<&'static str>, - dependency_history: Vec<&'static str>, - ) -> Result<Providable<Self>, DIContainerError> + dependency_history: DependencyHistory, + ) -> Result<Providable<Self, DependencyHistory>, DIContainerError> where Interface: 'static + ?Sized, { @@ -291,9 +300,12 @@ pub(crate) mod details { use std::rc::Rc; + use crate::dependency_history::IDependencyHistory; use crate::provider::blocking::IProvider; - pub trait DIContainerInternals + pub trait DIContainerInternals<DependencyHistoryType> + where + DependencyHistoryType: IDependencyHistory, { fn has_binding<Interface>(self: &Rc<Self>, name: Option<&'static str>) -> bool where @@ -302,14 +314,14 @@ pub(crate) mod details fn set_binding<Interface>( self: &Rc<Self>, name: Option<&'static str>, - provider: Box<dyn IProvider<Self>>, + provider: Box<dyn IProvider<Self, DependencyHistoryType>>, ) where Interface: 'static + ?Sized; fn remove_binding<Interface>( self: &Rc<Self>, name: Option<&'static str>, - ) -> Option<Box<dyn IProvider<Self>>> + ) -> Option<Box<dyn IProvider<Self, DependencyHistoryType>>> where Interface: 'static + ?Sized; } @@ -320,33 +332,16 @@ mod tests { use std::error::Error; - use mockall::mock; - use super::*; - use crate::errors::injectable::InjectableError; - use crate::provider::blocking::IProvider; use crate::ptr::{SingletonPtr, TransientPtr}; - use crate::test_utils::subjects; + use crate::test_utils::{mocks, subjects}; #[test] fn can_get() -> Result<(), Box<dyn Error>> { - mock! { - Provider {} - - impl IProvider<DIContainer> for Provider - { - fn provide( - &self, - di_container: &Rc<DIContainer>, - dependency_history: Vec<&'static str>, - ) -> Result<Providable<DIContainer>, InjectableError>; - } - } - let di_container = DIContainer::new(); - let mut mock_provider = MockProvider::new(); + let mut mock_provider = mocks::blocking_provider::MockProvider::new(); mock_provider.expect_provide().returning(|_, _| { Ok(Providable::Transient(TransientPtr::new( @@ -369,22 +364,9 @@ mod tests #[test] fn can_get_named() -> Result<(), Box<dyn Error>> { - mock! { - Provider {} - - impl IProvider<DIContainer> for Provider - { - fn provide( - &self, - di_container: &Rc<DIContainer>, - dependency_history: Vec<&'static str>, - ) -> Result<Providable<DIContainer>, InjectableError>; - } - } - let di_container = DIContainer::new(); - let mut mock_provider = MockProvider::new(); + let mut mock_provider = mocks::blocking_provider::MockProvider::new(); mock_provider.expect_provide().returning(|_, _| { Ok(Providable::Transient(TransientPtr::new( @@ -407,22 +389,9 @@ mod tests #[test] fn can_get_singleton() -> Result<(), Box<dyn Error>> { - mock! { - Provider {} - - impl IProvider<DIContainer> for Provider - { - fn provide( - &self, - di_container: &Rc<DIContainer>, - dependency_history: Vec<&'static str>, - ) -> Result<Providable<DIContainer>, InjectableError>; - } - } - let di_container = DIContainer::new(); - let mut mock_provider = MockProvider::new(); + let mut mock_provider = mocks::blocking_provider::MockProvider::new(); let mut singleton = SingletonPtr::new(subjects::Number::new()); @@ -452,22 +421,9 @@ mod tests #[test] fn can_get_singleton_named() -> Result<(), Box<dyn Error>> { - mock! { - Provider {} - - impl IProvider<DIContainer> for Provider - { - fn provide( - &self, - di_container: &Rc<DIContainer>, - dependency_history: Vec<&'static str>, - ) -> Result<Providable<DIContainer>, InjectableError>; - } - } - let di_container = DIContainer::new(); - let mut mock_provider = MockProvider::new(); + let mut mock_provider = mocks::blocking_provider::MockProvider::new(); let mut singleton = SingletonPtr::new(subjects::Number::new()); @@ -552,19 +508,6 @@ mod tests #[crate::factory] type IUserManagerFactory = dyn Fn(Vec<i128>) -> dyn IUserManager; - mock! { - Provider {} - - impl IProvider<DIContainer> for Provider - { - fn provide( - &self, - di_container: &Rc<DIContainer>, - dependency_history: Vec<&'static str>, - ) -> Result<Providable<DIContainer>, InjectableError>; - } - } - let di_container = DIContainer::new(); let factory_func: &'static FactoryFunc = &|_: Rc<DIContainer>| { @@ -576,7 +519,7 @@ mod tests }) }; - let mut mock_provider = MockProvider::new(); + let mut mock_provider = mocks::blocking_provider::MockProvider::new(); mock_provider.expect_provide().returning_st(|_, _| { Ok(Providable::Factory(FactoryPtr::new(CastableFactory::new( @@ -649,19 +592,6 @@ mod tests #[crate::factory] type IUserManagerFactory = dyn Fn(Vec<i128>) -> dyn IUserManager; - mock! { - Provider {} - - impl IProvider<DIContainer> for Provider - { - fn provide( - &self, - di_container: &Rc<DIContainer>, - dependency_history: Vec<&'static str>, - ) -> Result<Providable<DIContainer>, InjectableError>; - } - } - let di_container = DIContainer::new(); let factory_func: &'static FactoryFunc = &|_: Rc<DIContainer>| { @@ -673,7 +603,7 @@ mod tests }) }; - let mut mock_provider = MockProvider::new(); + let mut mock_provider = mocks::blocking_provider::MockProvider::new(); mock_provider.expect_provide().returning_st(|_, _| { Ok(Providable::Factory(FactoryPtr::new(CastableFactory::new( diff --git a/src/errors/injectable.rs b/src/errors/injectable.rs index df71f48..f132063 100644 --- a/src/errors/injectable.rs +++ b/src/errors/injectable.rs @@ -2,6 +2,7 @@ //! //! [`Injectable`]: crate::interfaces::injectable::Injectable +use crate::dependency_history::DependencyHistory; use crate::errors::di_container::DIContainerError; /// Error type for structs that implement [`Injectable`]. @@ -35,10 +36,10 @@ pub enum InjectableError affected: &'static str, }, /// Detected circular dependencies. - #[error("Detected circular dependencies. {dependency_trace}")] + #[error("Detected circular dependencies. {dependency_history}")] DetectedCircular { - /// A visual trace of dependencies. - dependency_trace: String, + /// History of dependencies. + dependency_history: DependencyHistory, }, } diff --git a/src/interfaces/async_injectable.rs b/src/interfaces/async_injectable.rs index fb7f8ba..4e614a3 100644 --- a/src/interfaces/async_injectable.rs +++ b/src/interfaces/async_injectable.rs @@ -2,6 +2,7 @@ use std::fmt::Debug; use std::sync::Arc; +use crate::dependency_history::IDependencyHistory; use crate::di_container::asynchronous::IAsyncDIContainer; use crate::errors::injectable::InjectableError; use crate::future::BoxFuture; @@ -9,9 +10,10 @@ use crate::libs::intertrait::CastFromSync; use crate::ptr::TransientPtr; /// Interface for structs that can be injected into or be injected to. -pub trait AsyncInjectable<DIContainerType>: CastFromSync +pub trait AsyncInjectable<DIContainerType, DependencyHistoryType>: CastFromSync where - DIContainerType: IAsyncDIContainer, + DIContainerType: IAsyncDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory + Send + Sync, { /// Resolves the dependencies of the injectable. /// @@ -19,16 +21,18 @@ where /// Will return `Err` if resolving the dependencies fails. fn resolve<'di_container, 'fut>( di_container: &'di_container Arc<DIContainerType>, - dependency_history: Vec<&'static str>, + dependency_history: DependencyHistoryType, ) -> BoxFuture<'fut, Result<TransientPtr<Self>, InjectableError>> where Self: Sized + 'fut, 'di_container: 'fut; } -impl<DIContainerType> Debug for dyn AsyncInjectable<DIContainerType> +impl<DIContainerType, DependencyHistoryType> Debug + for dyn AsyncInjectable<DIContainerType, DependencyHistoryType> where - DIContainerType: IAsyncDIContainer, + DIContainerType: IAsyncDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory + Send + Sync, { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { diff --git a/src/interfaces/injectable.rs b/src/interfaces/injectable.rs index 132935d..6130d2b 100644 --- a/src/interfaces/injectable.rs +++ b/src/interfaces/injectable.rs @@ -2,15 +2,17 @@ use std::fmt::Debug; use std::rc::Rc; +use crate::dependency_history::IDependencyHistory; use crate::di_container::blocking::IDIContainer; use crate::errors::injectable::InjectableError; use crate::libs::intertrait::CastFrom; use crate::ptr::TransientPtr; /// Interface for structs that can be injected into or be injected to. -pub trait Injectable<DIContainerType>: CastFrom +pub trait Injectable<DIContainerType, DependencyHistoryType>: CastFrom where - DIContainerType: IDIContainer, + DIContainerType: IDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory, { /// Resolves the dependencies of the injectable. /// @@ -18,15 +20,17 @@ where /// Will return `Err` if resolving the dependencies fails. fn resolve( di_container: &Rc<DIContainerType>, - dependency_history: Vec<&'static str>, + dependency_history: DependencyHistoryType, ) -> Result<TransientPtr<Self>, InjectableError> where Self: Sized; } -impl<DIContainerType> Debug for dyn Injectable<DIContainerType> +impl<DIContainerType, DependencyHistoryType> Debug + for dyn Injectable<DIContainerType, DependencyHistoryType> where - DIContainerType: IDIContainer, + DIContainerType: IDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory, { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { @@ -9,6 +9,7 @@ //! //! Syrette is a collection of utilities useful for performing dependency injection. +pub mod dependency_history; pub mod di_container; pub mod errors; pub mod interfaces; @@ -32,9 +33,6 @@ pub use syrette_macros::{declare_interface, injectable, named}; pub mod castable_factory; #[doc(hidden)] -pub mod dependency_trace; - -#[doc(hidden)] pub mod libs; // Private diff --git a/src/provider/async.rs b/src/provider/async.rs index 8d482cd..557617b 100644 --- a/src/provider/async.rs +++ b/src/provider/async.rs @@ -3,18 +3,24 @@ use std::sync::Arc; use async_trait::async_trait; +use crate::dependency_history::IDependencyHistory; use crate::di_container::asynchronous::IAsyncDIContainer; use crate::errors::injectable::InjectableError; use crate::interfaces::async_injectable::AsyncInjectable; use crate::ptr::{ThreadsafeSingletonPtr, TransientPtr}; #[derive(strum_macros::Display, Debug)] -pub enum AsyncProvidable<DIContainerType> +pub enum AsyncProvidable<DIContainerType, DependencyHistoryType> where - DIContainerType: IAsyncDIContainer, + DIContainerType: IAsyncDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory + Send + Sync, { - Transient(TransientPtr<dyn AsyncInjectable<DIContainerType>>), - Singleton(ThreadsafeSingletonPtr<dyn AsyncInjectable<DIContainerType>>), + Transient(TransientPtr<dyn AsyncInjectable<DIContainerType, DependencyHistoryType>>), + Singleton( + ThreadsafeSingletonPtr< + dyn AsyncInjectable<DIContainerType, DependencyHistoryType>, + >, + ), #[cfg(feature = "factory")] Factory( crate::ptr::ThreadsafeFactoryPtr< @@ -37,22 +43,26 @@ where #[async_trait] #[cfg_attr(test, mockall::automock, allow(dead_code))] -pub trait IAsyncProvider<DIContainerType>: Send + Sync +pub trait IAsyncProvider<DIContainerType, DependencyHistoryType>: Send + Sync where - DIContainerType: IAsyncDIContainer, + DIContainerType: IAsyncDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory + Send + Sync, { async fn provide( &self, di_container: &Arc<DIContainerType>, - dependency_history: Vec<&'static str>, - ) -> Result<AsyncProvidable<DIContainerType>, InjectableError>; + dependency_history: DependencyHistoryType, + ) -> Result<AsyncProvidable<DIContainerType, DependencyHistoryType>, InjectableError>; - fn do_clone(&self) -> Box<dyn IAsyncProvider<DIContainerType>>; + fn do_clone(&self) + -> Box<dyn IAsyncProvider<DIContainerType, DependencyHistoryType>>; } -impl<DIContainerType> Clone for Box<dyn IAsyncProvider<DIContainerType>> +impl<DIContainerType, DependencyHistoryType> Clone + for Box<dyn IAsyncProvider<DIContainerType, DependencyHistoryType>> where - DIContainerType: IAsyncDIContainer, + DIContainerType: IAsyncDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory + Send + Sync, { fn clone(&self) -> Self { @@ -60,127 +70,148 @@ where } } -pub struct AsyncTransientTypeProvider<InjectableType, DIContainerType> -where - InjectableType: AsyncInjectable<DIContainerType>, - DIContainerType: IAsyncDIContainer, +pub struct AsyncTransientTypeProvider< + InjectableType, + DIContainerType, + DependencyHistoryType, +> where + InjectableType: AsyncInjectable<DIContainerType, DependencyHistoryType>, + DIContainerType: IAsyncDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory + Send + Sync, { injectable_phantom: PhantomData<InjectableType>, di_container_phantom: PhantomData<DIContainerType>, + dependency_history_phantom: PhantomData<DependencyHistoryType>, } -impl<InjectableType, DIContainerType> - AsyncTransientTypeProvider<InjectableType, DIContainerType> +impl<InjectableType, DIContainerType, DependencyHistoryType> + AsyncTransientTypeProvider<InjectableType, DIContainerType, DependencyHistoryType> where - InjectableType: AsyncInjectable<DIContainerType>, - DIContainerType: IAsyncDIContainer, + InjectableType: AsyncInjectable<DIContainerType, DependencyHistoryType>, + DIContainerType: IAsyncDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory + Send + Sync, { pub fn new() -> Self { Self { injectable_phantom: PhantomData, di_container_phantom: PhantomData, + dependency_history_phantom: PhantomData, } } } #[async_trait] -impl<InjectableType, DIContainerType> IAsyncProvider<DIContainerType> - for AsyncTransientTypeProvider<InjectableType, DIContainerType> +impl<InjectableType, DIContainerType, DependencyHistoryType> + IAsyncProvider<DIContainerType, DependencyHistoryType> + for AsyncTransientTypeProvider<InjectableType, DIContainerType, DependencyHistoryType> where - InjectableType: AsyncInjectable<DIContainerType>, - DIContainerType: IAsyncDIContainer, + InjectableType: AsyncInjectable<DIContainerType, DependencyHistoryType>, + DIContainerType: IAsyncDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory + Send + Sync + 'static, { async fn provide( &self, di_container: &Arc<DIContainerType>, - dependency_history: Vec<&'static str>, - ) -> Result<AsyncProvidable<DIContainerType>, InjectableError> + dependency_history: DependencyHistoryType, + ) -> Result<AsyncProvidable<DIContainerType, DependencyHistoryType>, InjectableError> { Ok(AsyncProvidable::Transient( InjectableType::resolve(di_container, dependency_history).await?, )) } - fn do_clone(&self) -> Box<dyn IAsyncProvider<DIContainerType>> + fn do_clone(&self) + -> Box<dyn IAsyncProvider<DIContainerType, DependencyHistoryType>> { Box::new(self.clone()) } } -impl<InjectableType, DIContainerType> Clone - for AsyncTransientTypeProvider<InjectableType, DIContainerType> +impl<InjectableType, DIContainerType, DependencyHistoryType> Clone + for AsyncTransientTypeProvider<InjectableType, DIContainerType, DependencyHistoryType> where - InjectableType: AsyncInjectable<DIContainerType>, - DIContainerType: IAsyncDIContainer, + InjectableType: AsyncInjectable<DIContainerType, DependencyHistoryType>, + DIContainerType: IAsyncDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory + Send + Sync, { fn clone(&self) -> Self { Self { injectable_phantom: self.injectable_phantom, - di_container_phantom: self.di_container_phantom, + di_container_phantom: PhantomData, + dependency_history_phantom: PhantomData, } } } -pub struct AsyncSingletonProvider<InjectableType, DIContainerType> +pub struct AsyncSingletonProvider<InjectableType, DIContainerType, DependencyHistoryType> where - InjectableType: AsyncInjectable<DIContainerType>, - DIContainerType: IAsyncDIContainer, + InjectableType: AsyncInjectable<DIContainerType, DependencyHistoryType>, + DIContainerType: IAsyncDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory + Send + Sync, { singleton: ThreadsafeSingletonPtr<InjectableType>, di_container_phantom: PhantomData<DIContainerType>, + dependency_history_phantom: PhantomData<DependencyHistoryType>, } -impl<InjectableType, DIContainerType> - AsyncSingletonProvider<InjectableType, DIContainerType> +impl<InjectableType, DIContainerType, DependencyHistoryType> + AsyncSingletonProvider<InjectableType, DIContainerType, DependencyHistoryType> where - InjectableType: AsyncInjectable<DIContainerType>, - DIContainerType: IAsyncDIContainer, + InjectableType: AsyncInjectable<DIContainerType, DependencyHistoryType>, + DIContainerType: IAsyncDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory + Send + Sync, { pub fn new(singleton: ThreadsafeSingletonPtr<InjectableType>) -> Self { Self { singleton, di_container_phantom: PhantomData, + dependency_history_phantom: PhantomData, } } } #[async_trait] -impl<InjectableType, DIContainerType> IAsyncProvider<DIContainerType> - for AsyncSingletonProvider<InjectableType, DIContainerType> +impl<InjectableType, DIContainerType, DependencyHistoryType> + IAsyncProvider<DIContainerType, DependencyHistoryType> + for AsyncSingletonProvider<InjectableType, DIContainerType, DependencyHistoryType> where - InjectableType: AsyncInjectable<DIContainerType>, - DIContainerType: IAsyncDIContainer, + InjectableType: AsyncInjectable<DIContainerType, DependencyHistoryType>, + DIContainerType: IAsyncDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory + Send + Sync + 'static, { async fn provide( &self, _di_container: &Arc<DIContainerType>, - _dependency_history: Vec<&'static str>, - ) -> Result<AsyncProvidable<DIContainerType>, InjectableError> + _dependency_history: DependencyHistoryType, + ) -> Result<AsyncProvidable<DIContainerType, DependencyHistoryType>, InjectableError> { Ok(AsyncProvidable::Singleton(self.singleton.clone())) } - fn do_clone(&self) -> Box<dyn IAsyncProvider<DIContainerType>> + fn do_clone(&self) + -> Box<dyn IAsyncProvider<DIContainerType, DependencyHistoryType>> { Box::new(self.clone()) } } -impl<InjectableType, DIContainerType> Clone - for AsyncSingletonProvider<InjectableType, DIContainerType> +impl<InjectableType, DIContainerType, DependencyHistoryType> Clone + for AsyncSingletonProvider<InjectableType, DIContainerType, DependencyHistoryType> where - InjectableType: AsyncInjectable<DIContainerType>, - DIContainerType: IAsyncDIContainer, + InjectableType: AsyncInjectable<DIContainerType, DependencyHistoryType>, + DIContainerType: IAsyncDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory + Send + Sync, { fn clone(&self) -> Self { Self { singleton: self.singleton.clone(), di_container_phantom: PhantomData, + dependency_history_phantom: PhantomData, } } } @@ -218,15 +249,17 @@ impl AsyncFactoryProvider #[cfg(feature = "factory")] #[async_trait] -impl<DIContainerType> IAsyncProvider<DIContainerType> for AsyncFactoryProvider +impl<DIContainerType, DependencyHistoryType> + IAsyncProvider<DIContainerType, DependencyHistoryType> for AsyncFactoryProvider where - DIContainerType: IAsyncDIContainer, + DIContainerType: IAsyncDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory + Send + Sync + 'static, { async fn provide( &self, _di_container: &Arc<DIContainerType>, - _dependency_history: Vec<&'static str>, - ) -> Result<AsyncProvidable<DIContainerType>, InjectableError> + _dependency_history: DependencyHistoryType, + ) -> Result<AsyncProvidable<DIContainerType, DependencyHistoryType>, InjectableError> { Ok(match self.variant { AsyncFactoryVariant::Normal => AsyncProvidable::Factory(self.factory.clone()), @@ -239,7 +272,8 @@ where }) } - fn do_clone(&self) -> Box<dyn IAsyncProvider<DIContainerType>> + fn do_clone(&self) + -> Box<dyn IAsyncProvider<DIContainerType, DependencyHistoryType>> { Box::new(self.clone()) } @@ -263,6 +297,7 @@ mod tests use std::error::Error; use super::*; + use crate::test_utils::mocks::MockDependencyHistory; use crate::test_utils::{mocks, subjects_async}; #[tokio::test] @@ -270,7 +305,8 @@ mod tests { let transient_type_provider = AsyncTransientTypeProvider::< subjects_async::UserManager, - mocks::async_di_container::MockAsyncDIContainer, + mocks::async_di_container::MockAsyncDIContainer<mocks::MockDependencyHistory>, + mocks::MockDependencyHistory, >::new(); let di_container = mocks::async_di_container::MockAsyncDIContainer::new(); @@ -278,7 +314,7 @@ mod tests assert!( matches!( transient_type_provider - .provide(&Arc::new(di_container), vec![]) + .provide(&Arc::new(di_container), MockDependencyHistory::new()) .await?, AsyncProvidable::Transient(_) ), @@ -293,7 +329,8 @@ mod tests { let singleton_provider = AsyncSingletonProvider::< subjects_async::UserManager, - mocks::async_di_container::MockAsyncDIContainer, + mocks::async_di_container::MockAsyncDIContainer<mocks::MockDependencyHistory>, + mocks::MockDependencyHistory, >::new(ThreadsafeSingletonPtr::new( subjects_async::UserManager {}, )); @@ -303,7 +340,7 @@ mod tests assert!( matches!( singleton_provider - .provide(&Arc::new(di_container), vec![]) + .provide(&Arc::new(di_container), MockDependencyHistory::new()) .await?, AsyncProvidable::Singleton(_) ), @@ -345,7 +382,9 @@ mod tests assert!( matches!( - factory_provider.provide(&di_container, vec![]).await?, + factory_provider + .provide(&di_container, mocks::MockDependencyHistory::new()) + .await?, AsyncProvidable::Factory(_) ), "The provided type is not a factory" @@ -354,7 +393,7 @@ mod tests assert!( matches!( default_factory_provider - .provide(&di_container, vec![]) + .provide(&di_container, MockDependencyHistory::new()) .await?, AsyncProvidable::DefaultFactory(_) ), @@ -364,7 +403,7 @@ mod tests assert!( matches!( async_default_factory_provider - .provide(&di_container, vec![]) + .provide(&di_container, MockDependencyHistory::new()) .await?, AsyncProvidable::AsyncDefaultFactory(_) ), diff --git a/src/provider/blocking.rs b/src/provider/blocking.rs index e1e2aad..ebe0c37 100644 --- a/src/provider/blocking.rs +++ b/src/provider/blocking.rs @@ -1,18 +1,20 @@ use std::marker::PhantomData; use std::rc::Rc; +use crate::dependency_history::IDependencyHistory; use crate::di_container::blocking::IDIContainer; use crate::errors::injectable::InjectableError; use crate::interfaces::injectable::Injectable; use crate::ptr::{SingletonPtr, TransientPtr}; #[derive(strum_macros::Display, Debug)] -pub enum Providable<DIContainerType> +pub enum Providable<DIContainerType, DependencyHistoryType> where - DIContainerType: IDIContainer, + DIContainerType: IDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory, { - Transient(TransientPtr<dyn Injectable<DIContainerType>>), - Singleton(SingletonPtr<dyn Injectable<DIContainerType>>), + Transient(TransientPtr<dyn Injectable<DIContainerType, DependencyHistoryType>>), + Singleton(SingletonPtr<dyn Injectable<DIContainerType, DependencyHistoryType>>), #[cfg(feature = "factory")] Factory(crate::ptr::FactoryPtr<dyn crate::interfaces::any_factory::AnyFactory>), #[cfg(feature = "factory")] @@ -22,52 +24,59 @@ where } #[cfg_attr(test, mockall::automock, allow(dead_code))] -pub trait IProvider<DIContainerType> +pub trait IProvider<DIContainerType, DependencyHistoryType> where - DIContainerType: IDIContainer, + DIContainerType: IDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory, { fn provide( &self, di_container: &Rc<DIContainerType>, - dependency_history: Vec<&'static str>, - ) -> Result<Providable<DIContainerType>, InjectableError>; + dependency_history: DependencyHistoryType, + ) -> Result<Providable<DIContainerType, DependencyHistoryType>, InjectableError>; } -pub struct TransientTypeProvider<InjectableType, DIContainerType> +pub struct TransientTypeProvider<InjectableType, DIContainerType, DependencyHistoryType> where - InjectableType: Injectable<DIContainerType>, - DIContainerType: IDIContainer, + InjectableType: Injectable<DIContainerType, DependencyHistoryType>, + DIContainerType: IDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory, { injectable_phantom: PhantomData<InjectableType>, di_container_phantom: PhantomData<DIContainerType>, + dependency_history_phantom: PhantomData<DependencyHistoryType>, } -impl<InjectableType, DIContainerType> - TransientTypeProvider<InjectableType, DIContainerType> +impl<InjectableType, DIContainerType, DependencyHistoryType> + TransientTypeProvider<InjectableType, DIContainerType, DependencyHistoryType> where - InjectableType: Injectable<DIContainerType>, - DIContainerType: IDIContainer, + InjectableType: Injectable<DIContainerType, DependencyHistoryType>, + DIContainerType: IDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory, { pub fn new() -> Self { Self { injectable_phantom: PhantomData, di_container_phantom: PhantomData, + dependency_history_phantom: PhantomData, } } } -impl<InjectableType, DIContainerType> IProvider<DIContainerType> - for TransientTypeProvider<InjectableType, DIContainerType> +impl<InjectableType, DIContainerType, DependencyHistoryType> + IProvider<DIContainerType, DependencyHistoryType> + for TransientTypeProvider<InjectableType, DIContainerType, DependencyHistoryType> where - InjectableType: Injectable<DIContainerType>, - DIContainerType: IDIContainer, + InjectableType: Injectable<DIContainerType, DependencyHistoryType>, + DIContainerType: IDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory, { fn provide( &self, di_container: &Rc<DIContainerType>, - dependency_history: Vec<&'static str>, - ) -> Result<Providable<DIContainerType>, InjectableError> + dependency_history: DependencyHistoryType, + ) -> Result<Providable<DIContainerType, DependencyHistoryType>, InjectableError> { Ok(Providable::Transient(InjectableType::resolve( di_container, @@ -76,40 +85,48 @@ where } } -pub struct SingletonProvider<InjectableType, DIContainerType> +pub struct SingletonProvider<InjectableType, DIContainerType, DependencyHistoryType> where - InjectableType: Injectable<DIContainerType>, - DIContainerType: IDIContainer, + InjectableType: Injectable<DIContainerType, DependencyHistoryType>, + DIContainerType: IDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory, { singleton: SingletonPtr<InjectableType>, + di_container_phantom: PhantomData<DIContainerType>, + dependency_history_phantom: PhantomData<DependencyHistoryType>, } -impl<InjectableType, DIContainerType> SingletonProvider<InjectableType, DIContainerType> +impl<InjectableType, DIContainerType, DependencyHistoryType> + SingletonProvider<InjectableType, DIContainerType, DependencyHistoryType> where - InjectableType: Injectable<DIContainerType>, - DIContainerType: IDIContainer, + InjectableType: Injectable<DIContainerType, DependencyHistoryType>, + DIContainerType: IDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory, { pub fn new(singleton: SingletonPtr<InjectableType>) -> Self { Self { singleton, di_container_phantom: PhantomData, + dependency_history_phantom: PhantomData, } } } -impl<InjectableType, DIContainerType> IProvider<DIContainerType> - for SingletonProvider<InjectableType, DIContainerType> +impl<InjectableType, DIContainerType, DependencyHistoryType> + IProvider<DIContainerType, DependencyHistoryType> + for SingletonProvider<InjectableType, DIContainerType, DependencyHistoryType> where - InjectableType: Injectable<DIContainerType>, - DIContainerType: IDIContainer, + InjectableType: Injectable<DIContainerType, DependencyHistoryType>, + DIContainerType: IDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory, { fn provide( &self, _di_container: &Rc<DIContainerType>, - _dependency_history: Vec<&'static str>, - ) -> Result<Providable<DIContainerType>, InjectableError> + _dependency_history: DependencyHistoryType, + ) -> Result<Providable<DIContainerType, DependencyHistoryType>, InjectableError> { Ok(Providable::Singleton(self.singleton.clone())) } @@ -138,15 +155,17 @@ impl FactoryProvider } #[cfg(feature = "factory")] -impl<DIContainerType> IProvider<DIContainerType> for FactoryProvider +impl<DIContainerType, DependencyHistoryType> + IProvider<DIContainerType, DependencyHistoryType> for FactoryProvider where - DIContainerType: IDIContainer, + DIContainerType: IDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory, { fn provide( &self, _di_container: &Rc<DIContainerType>, - _dependency_history: Vec<&'static str>, - ) -> Result<Providable<DIContainerType>, InjectableError> + _dependency_history: DependencyHistoryType, + ) -> Result<Providable<DIContainerType, DependencyHistoryType>, InjectableError> { Ok(if self.is_default_factory { Providable::DefaultFactory(self.factory.clone()) @@ -169,14 +188,18 @@ mod tests { let transient_type_provider = TransientTypeProvider::< subjects::UserManager, - mocks::blocking_di_container::MockDIContainer, + mocks::blocking_di_container::MockDIContainer<mocks::MockDependencyHistory>, + mocks::MockDependencyHistory, >::new(); let di_container = mocks::blocking_di_container::MockDIContainer::new(); + let dependency_history_mock = mocks::MockDependencyHistory::new(); + assert!( matches!( - transient_type_provider.provide(&Rc::new(di_container), vec![])?, + transient_type_provider + .provide(&Rc::new(di_container), dependency_history_mock)?, Providable::Transient(_) ), "The provided type is not transient" @@ -188,17 +211,22 @@ mod tests #[test] fn singleton_provider_works() -> Result<(), Box<dyn Error>> { - let singleton_provider = - SingletonProvider::< - subjects::UserManager, - mocks::blocking_di_container::MockDIContainer, - >::new(SingletonPtr::new(subjects::UserManager {})); + let singleton_provider = SingletonProvider::< + subjects::UserManager, + mocks::blocking_di_container::MockDIContainer<mocks::MockDependencyHistory>, + mocks::MockDependencyHistory, + >::new(SingletonPtr::new( + subjects::UserManager {}, + )); let di_container = mocks::blocking_di_container::MockDIContainer::new(); assert!( matches!( - singleton_provider.provide(&Rc::new(di_container), vec![])?, + singleton_provider.provide( + &Rc::new(di_container), + mocks::MockDependencyHistory::new() + )?, Providable::Singleton(_) ), "The provided type is not a singleton" @@ -227,7 +255,8 @@ mod tests assert!( matches!( - factory_provider.provide(&di_container, vec![])?, + factory_provider + .provide(&di_container, mocks::MockDependencyHistory::new())?, Providable::Factory(_) ), "The provided type is not a factory" @@ -235,7 +264,8 @@ mod tests assert!( matches!( - default_factory_provider.provide(&di_container, vec![])?, + default_factory_provider + .provide(&di_container, mocks::MockDependencyHistory::new())?, Providable::DefaultFactory(_) ), "The provided type is not a default factory" diff --git a/src/test_utils.rs b/src/test_utils.rs index 650e338..b4ec951 100644 --- a/src/test_utils.rs +++ b/src/test_utils.rs @@ -7,6 +7,7 @@ pub mod subjects use syrette_macros::declare_interface; + use crate::dependency_history::IDependencyHistory; use crate::di_container::blocking::IDIContainer; use crate::interfaces::injectable::Injectable; use crate::ptr::TransientPtr; @@ -45,13 +46,15 @@ pub mod subjects declare_interface!(UserManager -> IUserManager); - impl<DIContainerType> Injectable<DIContainerType> for UserManager + impl<DIContainerType, DependencyHistoryType> + Injectable<DIContainerType, DependencyHistoryType> for UserManager where - DIContainerType: IDIContainer, + DIContainerType: IDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory, { fn resolve( _di_container: &Rc<DIContainerType>, - _dependency_history: Vec<&'static str>, + _dependency_history: DependencyHistoryType, ) -> Result<TransientPtr<Self>, crate::errors::injectable::InjectableError> where Self: Sized, @@ -111,13 +114,15 @@ pub mod subjects declare_interface!(Number -> INumber); - impl<DIContainerType> Injectable<DIContainerType> for Number + impl<DIContainerType, DependencyHistoryType> + Injectable<DIContainerType, DependencyHistoryType> for Number where - DIContainerType: IDIContainer, + DIContainerType: IDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory, { fn resolve( _di_container: &Rc<DIContainerType>, - _dependency_history: Vec<&'static str>, + _dependency_history: DependencyHistoryType, ) -> Result<TransientPtr<Self>, crate::errors::injectable::InjectableError> where Self: Sized, @@ -138,6 +143,7 @@ pub mod subjects_async use async_trait::async_trait; use syrette_macros::declare_interface; + use crate::dependency_history::IDependencyHistory; use crate::di_container::asynchronous::IAsyncDIContainer; use crate::interfaces::async_injectable::AsyncInjectable; use crate::ptr::TransientPtr; @@ -177,13 +183,15 @@ pub mod subjects_async declare_interface!(UserManager -> IUserManager); #[async_trait] - impl<DIContainerType> AsyncInjectable<DIContainerType> for UserManager + impl<DIContainerType, DependencyHistoryType> + AsyncInjectable<DIContainerType, DependencyHistoryType> for UserManager where - DIContainerType: IAsyncDIContainer, + DIContainerType: IAsyncDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory + Send + Sync + 'static, { async fn resolve( _: &Arc<DIContainerType>, - _dependency_history: Vec<&'static str>, + _dependency_history: DependencyHistoryType, ) -> Result<TransientPtr<Self>, crate::errors::injectable::InjectableError> where Self: Sized, @@ -244,13 +252,15 @@ pub mod subjects_async declare_interface!(Number -> INumber, async = true); #[async_trait] - impl<DIContainerType> AsyncInjectable<DIContainerType> for Number + impl<DIContainerType, DependencyHistoryType> + AsyncInjectable<DIContainerType, DependencyHistoryType> for Number where - DIContainerType: IAsyncDIContainer, + DIContainerType: IAsyncDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory + Send + Sync + 'static, { async fn resolve( _: &Arc<DIContainerType>, - _dependency_history: Vec<&'static str>, + _dependency_history: DependencyHistoryType, ) -> Result<TransientPtr<Self>, crate::errors::injectable::InjectableError> where Self: Sized, @@ -272,6 +282,7 @@ pub mod mocks use std::rc::Rc; use super::*; + use crate::dependency_history::IDependencyHistory; use crate::di_container::blocking::binding::builder::BindingBuilder; use crate::di_container::blocking::details::DIContainerInternals; use crate::di_container::blocking::IDIContainer; @@ -280,10 +291,18 @@ pub mod mocks use crate::ptr::SomePtr; mock! { - pub DIContainer {} - - impl IDIContainer for DIContainer { - fn bind<Interface>(self: &mut Rc<Self>) -> BindingBuilder<Interface, Self> + pub DIContainer<DependencyHistoryType> + where + DependencyHistoryType: IDependencyHistory + 'static + {} + + impl<DependencyHistoryType> IDIContainer<DependencyHistoryType> for + DIContainer<DependencyHistoryType> + where + DependencyHistoryType: IDependencyHistory + 'static + { + fn bind<Interface>(self: &mut Rc<Self>) -> + BindingBuilder<Interface, Self, DependencyHistoryType> where Interface: 'static + ?Sized; @@ -301,14 +320,18 @@ pub mod mocks #[doc(hidden)] fn get_bound<Interface>( self: &Rc<Self>, - dependency_history: Vec<&'static str>, + dependency_history: DependencyHistoryType, name: Option<&'static str>, ) -> Result<SomePtr<Interface>, DIContainerError> where Interface: 'static + ?Sized; } - impl DIContainerInternals for DIContainer + impl<DependencyHistoryType> DIContainerInternals< + DependencyHistoryType + > for DIContainer<DependencyHistoryType> + where + DependencyHistoryType: IDependencyHistory { fn has_binding<Interface>(self: &Rc<Self>, name: Option<&'static str>) -> bool where @@ -318,14 +341,14 @@ pub mod mocks fn set_binding<Interface>( self: &Rc<Self>, name: Option<&'static str>, - provider: Box<dyn IProvider<Self>>, + provider: Box<dyn IProvider<Self, DependencyHistoryType>>, ) where Interface: 'static + ?Sized; fn remove_binding<Interface>( self: &Rc<Self>, name: Option<&'static str>, - ) -> Option<Box<dyn IProvider<Self>>> + ) -> Option<Box<dyn IProvider<Self, DependencyHistoryType>>> where Interface: 'static + ?Sized; } @@ -338,6 +361,7 @@ pub mod mocks use std::sync::Arc; use super::*; + use crate::dependency_history::IDependencyHistory; use crate::di_container::asynchronous::binding::builder::AsyncBindingBuilder; use crate::di_container::asynchronous::details::DIContainerInternals; use crate::di_container::asynchronous::IAsyncDIContainer; @@ -346,11 +370,20 @@ pub mod mocks use crate::ptr::SomeThreadsafePtr; mock! { - pub AsyncDIContainer {} + pub AsyncDIContainer<DependencyHistoryType> + where + DependencyHistoryType: IDependencyHistory + 'static + Send + Sync + {} #[async_trait::async_trait] - impl IAsyncDIContainer for AsyncDIContainer { - fn bind<Interface>(self: &mut Arc<Self>) -> AsyncBindingBuilder<Interface, Self> + impl<DependencyHistoryType> IAsyncDIContainer< + DependencyHistoryType + > for AsyncDIContainer<DependencyHistoryType> + where + DependencyHistoryType: IDependencyHistory + 'static + Send + Sync + { + fn bind<Interface>(self: &mut Arc<Self>) -> + AsyncBindingBuilder<Interface, Self, DependencyHistoryType> where Interface: 'static + ?Sized + Send + Sync; @@ -370,7 +403,7 @@ pub mod mocks #[doc(hidden)] async fn get_bound<Interface>( self: &Arc<Self>, - dependency_history: Vec<&'static str>, + dependency_history: DependencyHistoryType, name: Option<&'static str>, ) -> Result<SomeThreadsafePtr<Interface>, AsyncDIContainerError> where @@ -378,7 +411,12 @@ pub mod mocks } #[async_trait::async_trait] - impl DIContainerInternals for AsyncDIContainer { + impl<DependencyHistoryType> DIContainerInternals< + DependencyHistoryType + > for AsyncDIContainer<DependencyHistoryType> + where + DependencyHistoryType: IDependencyHistory + 'static + Send + Sync + { async fn has_binding<Interface>( self: &Arc<Self>, name: Option<&'static str>, @@ -389,17 +427,104 @@ pub mod mocks async fn set_binding<Interface>( self: &Arc<Self>, name: Option<&'static str>, - provider: Box<dyn IAsyncProvider<Self>>, + provider: Box<dyn IAsyncProvider<Self, DependencyHistoryType>>, ) where Interface: 'static + ?Sized; async fn remove_binding<Interface>( self: &Arc<Self>, name: Option<&'static str>, - ) -> Option<Box<dyn IAsyncProvider<Self>>> + ) -> Option<Box<dyn IAsyncProvider<Self, DependencyHistoryType>>> where Interface: 'static + ?Sized; } } } + + #[cfg(feature = "async")] + pub mod async_provider + { + use std::sync::Arc; + + use async_trait::async_trait; + + use super::*; + use crate::dependency_history::IDependencyHistory; + use crate::di_container::asynchronous::IAsyncDIContainer; + use crate::errors::injectable::InjectableError; + use crate::provider::r#async::{AsyncProvidable, IAsyncProvider}; + + mock! { + pub AsyncProvider< + DIContainerType: IAsyncDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory + Send + Sync + > {} + + #[async_trait] + impl< + DIContainerType: IAsyncDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory + Send + Sync + > IAsyncProvider<DIContainerType, DependencyHistoryType> for AsyncProvider< + DIContainerType, + DependencyHistoryType + > + { + async fn provide( + &self, + di_container: &Arc<DIContainerType>, + dependency_history: DependencyHistoryType + ) -> Result<AsyncProvidable<DIContainerType, DependencyHistoryType>, InjectableError>; + + fn do_clone(&self) -> + Box<dyn IAsyncProvider<DIContainerType, DependencyHistoryType>>; + } + } + } + + pub mod blocking_provider + { + use std::rc::Rc; + + use super::*; + use crate::dependency_history::IDependencyHistory; + use crate::di_container::blocking::IDIContainer; + use crate::errors::injectable::InjectableError; + use crate::provider::blocking::{IProvider, Providable}; + + mock! { + pub Provider<DIContainerType, DependencyHistoryType> + where + DIContainerType: IDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory, + {} + + impl<DIContainerType, DependencyHistoryType> IProvider< + DIContainerType, + DependencyHistoryType + > for Provider<DIContainerType, DependencyHistoryType> + where + DIContainerType: IDIContainer<DependencyHistoryType>, + DependencyHistoryType: IDependencyHistory + { + fn provide( + &self, + di_container: &Rc<DIContainerType>, + dependency_history: DependencyHistoryType, + ) -> Result<Providable<DIContainerType, DependencyHistoryType>, InjectableError>; + } + } + } + + mock! { + pub DependencyHistory {} + + impl crate::dependency_history::IDependencyHistory for DependencyHistory + { + fn push<Dependency: 'static + ?Sized>(&mut self); + + fn contains<Dependency: 'static + ?Sized>(&self) -> bool; + } + + impl crate::dependency_history::private::Sealed for DependencyHistory {} + } } |