From 9e01cdf341a7866180b3a63d745f3b2d7578d28a Mon Sep 17 00:00:00 2001 From: HampusM Date: Sun, 23 Oct 2022 18:12:23 +0200 Subject: refactor!: reduce DI container coupling BREAKING CHANGE: You now have to import the DI containers's interfaces to use the DI containers's methods --- src/di_container/asynchronous/binding/builder.rs | 355 ++++++++------------- .../asynchronous/binding/scope_configurator.rs | 58 ++-- .../asynchronous/binding/when_configurator.rs | 46 +-- src/di_container/asynchronous/mod.rs | 217 ++++++++++--- src/di_container/asynchronous/prelude.rs | 3 + src/di_container/binding_map.rs | 7 - src/di_container/blocking/binding/builder.rs | 273 +++++++--------- .../blocking/binding/scope_configurator.rs | 45 +-- .../blocking/binding/when_configurator.rs | 46 +-- src/di_container/blocking/mod.rs | 166 +++++++--- src/di_container/blocking/prelude.rs | 2 + src/interfaces/async_injectable.rs | 12 +- src/interfaces/injectable.rs | 12 +- src/lib.rs | 1 + src/provider/async.rs | 103 +++--- src/provider/blocking.rs | 75 +++-- src/test_utils.rs | 172 +++++++++- 17 files changed, 964 insertions(+), 629 deletions(-) create mode 100644 src/di_container/asynchronous/prelude.rs create mode 100644 src/di_container/blocking/prelude.rs (limited to 'src') diff --git a/src/di_container/asynchronous/binding/builder.rs b/src/di_container/asynchronous/binding/builder.rs index 6daba30..d9ad0e6 100644 --- a/src/di_container/asynchronous/binding/builder.rs +++ b/src/di_container/asynchronous/binding/builder.rs @@ -1,4 +1,6 @@ -//! Binding builder for types inside of a [`AsyncDIContainer`]. +//! Binding builder for types inside of a [`IAsyncDIContainer`]. +//! +//! [`IAsyncDIContainer`]: crate::di_container::asynchronous::IAsyncDIContainer use std::any::type_name; use std::marker::PhantomData; use std::sync::Arc; @@ -6,29 +8,33 @@ use std::sync::Arc; use crate::di_container::asynchronous::binding::scope_configurator::AsyncBindingScopeConfigurator; #[cfg(feature = "factory")] use crate::di_container::asynchronous::binding::when_configurator::AsyncBindingWhenConfigurator; +use crate::di_container::asynchronous::IAsyncDIContainer; use crate::errors::async_di_container::AsyncBindingBuilderError; use crate::interfaces::async_injectable::AsyncInjectable; -use crate::AsyncDIContainer; /// Alias for a threadsafe boxed function. #[cfg(feature = "factory")] #[cfg_attr(doc_cfg, doc(cfg(feature = "factory")))] pub type BoxFn = Box<(dyn Fn + Send + Sync)>; -/// Binding builder for type `Interface` inside a [`AsyncDIContainer`]. -pub struct AsyncBindingBuilder +/// Binding builder for type `Interface` inside a [`IAsyncDIContainer`]. +/// +/// [`IAsyncDIContainer`]: crate::di_container::asynchronous::IAsyncDIContainer +pub struct AsyncBindingBuilder where Interface: 'static + ?Sized + Send + Sync, + DIContainerType: IAsyncDIContainer, { - di_container: Arc, + di_container: Arc, interface_phantom: PhantomData, } -impl AsyncBindingBuilder +impl AsyncBindingBuilder where Interface: 'static + ?Sized + Send + Sync, + DIContainerType: IAsyncDIContainer, { - pub(crate) fn new(di_container: Arc) -> Self + pub(crate) fn new(di_container: Arc) -> Self { Self { di_container, @@ -37,20 +43,21 @@ where } /// Creates a binding of type `Interface` to type `Implementation` inside of the - /// associated [`AsyncDIContainer`]. + /// associated [`IAsyncDIContainer`]. /// /// The scope of the binding is transient. But that can be changed by using the /// returned [`AsyncBindingScopeConfigurator`] /// /// # Errors - /// Will return Err if the associated [`AsyncDIContainer`] already have a binding for + /// Will return Err if the associated [`IAsyncDIContainer`] already have a binding for /// the interface. /// /// # Examples /// ``` /// # use std::error::Error; /// # - /// # use syrette::{AsyncDIContainer, injectable}; + /// # use syrette::injectable; + /// # use syrette::di_container::asynchronous::prelude::*; /// # /// # trait Foo: Send + Sync {} /// # @@ -76,24 +83,22 @@ where /// # Ok(()) /// # } /// ``` + /// + /// [`IAsyncDIContainer`]: crate::di_container::asynchronous::IAsyncDIContainer pub async fn to( &self, ) -> Result< - AsyncBindingScopeConfigurator, + AsyncBindingScopeConfigurator, AsyncBindingBuilderError, > where - Implementation: AsyncInjectable, + Implementation: AsyncInjectable, { - { - let bindings_lock = self.di_container.bindings.lock().await; - - if bindings_lock.has::(None) { - return Err(AsyncBindingBuilderError::BindingAlreadyExists(type_name::< - Interface, - >( - ))); - } + if self.di_container.has_binding::(None).await { + return Err(AsyncBindingBuilderError::BindingAlreadyExists(type_name::< + Interface, + >( + ))); } let binding_scope_configurator = @@ -105,17 +110,18 @@ where } /// Creates a binding of factory type `Interface` to a factory inside of the - /// associated [`AsyncDIContainer`]. + /// associated [`IAsyncDIContainer`]. /// /// # Errors - /// Will return Err if the associated [`AsyncDIContainer`] already have a binding + /// Will return Err if the associated [`IAsyncDIContainer`] already have a binding /// for the interface. /// /// # Examples /// ``` /// # use std::error::Error; /// # - /// # use syrette::{AsyncDIContainer, factory}; + /// # use syrette::{factory}; + /// # use syrette::di_container::asynchronous::prelude::*; /// # use syrette::ptr::TransientPtr; /// # /// # trait Foo: Send + Sync {} @@ -150,25 +156,28 @@ where /// # Ok(()) /// # } /// ``` + /// + /// [`IAsyncDIContainer`]: crate::di_container::asynchronous::IAsyncDIContainer #[cfg(feature = "factory")] #[cfg_attr(doc_cfg, doc(cfg(feature = "factory")))] pub async fn to_factory( &self, factory_func: &'static FactoryFunc, - ) -> Result, AsyncBindingBuilderError> + ) -> Result< + AsyncBindingWhenConfigurator, + AsyncBindingBuilderError, + > where Args: 'static, Return: 'static + ?Sized, Interface: Fn + Send + Sync, FactoryFunc: - Fn<(Arc,), Output = BoxFn> + Send + Sync, + Fn<(Arc,), Output = BoxFn> + Send + Sync, { use crate::castable_factory::threadsafe::ThreadsafeCastableFactory; use crate::provider::r#async::AsyncFactoryVariant; - let mut bindings_lock = self.di_container.bindings.lock().await; - - if bindings_lock.has::(None) { + if self.di_container.has_binding::(None).await { return Err(AsyncBindingBuilderError::BindingAlreadyExists(type_name::< Interface, >( @@ -177,22 +186,24 @@ where let factory_impl = ThreadsafeCastableFactory::new(factory_func); - bindings_lock.set::( - None, - Box::new(crate::provider::r#async::AsyncFactoryProvider::new( - crate::ptr::ThreadsafeFactoryPtr::new(factory_impl), - AsyncFactoryVariant::Normal, - )), - ); + self.di_container + .set_binding::( + None, + Box::new(crate::provider::r#async::AsyncFactoryProvider::new( + crate::ptr::ThreadsafeFactoryPtr::new(factory_impl), + AsyncFactoryVariant::Normal, + )), + ) + .await; Ok(AsyncBindingWhenConfigurator::new(self.di_container.clone())) } /// Creates a binding of factory type `Interface` to a async factory inside of the - /// associated [`AsyncDIContainer`]. + /// associated [`IAsyncDIContainer`]. /// /// # Errors - /// Will return Err if the associated [`AsyncDIContainer`] already have a binding + /// Will return Err if the associated [`IAsyncDIContainer`] already have a binding /// for the interface. /// /// # Examples @@ -200,7 +211,8 @@ where /// # use std::error::Error; /// # use std::time::Duration; /// # - /// # use syrette::{AsyncDIContainer, factory, async_closure}; + /// # use syrette::{factory, async_closure}; + /// # use syrette::di_container::asynchronous::prelude::*; /// # use syrette::ptr::TransientPtr; /// # /// # trait Foo: Send + Sync {} @@ -237,19 +249,24 @@ where /// # Ok(()) /// # } /// ``` + /// + /// [`IAsyncDIContainer`]: crate::di_container::asynchronous::IAsyncDIContainer #[cfg(feature = "factory")] #[cfg_attr(doc_cfg, doc(cfg(feature = "factory")))] pub async fn to_async_factory( &self, factory_func: &'static FactoryFunc, - ) -> Result, AsyncBindingBuilderError> + ) -> Result< + AsyncBindingWhenConfigurator, + AsyncBindingBuilderError, + > where Args: 'static, Return: 'static + ?Sized, Interface: Fn> + Send + Sync, FactoryFunc: Fn< - (Arc,), + (Arc,), Output = BoxFn>, > + Send + Sync, @@ -257,9 +274,7 @@ where use crate::castable_factory::threadsafe::ThreadsafeCastableFactory; use crate::provider::r#async::AsyncFactoryVariant; - let mut bindings_lock = self.di_container.bindings.lock().await; - - if bindings_lock.has::(None) { + if self.di_container.has_binding::(None).await { return Err(AsyncBindingBuilderError::BindingAlreadyExists(type_name::< Interface, >( @@ -268,29 +283,31 @@ where let factory_impl = ThreadsafeCastableFactory::new(factory_func); - bindings_lock.set::( - None, - Box::new(crate::provider::r#async::AsyncFactoryProvider::new( - crate::ptr::ThreadsafeFactoryPtr::new(factory_impl), - AsyncFactoryVariant::Normal, - )), - ); + self.di_container + .set_binding::( + None, + Box::new(crate::provider::r#async::AsyncFactoryProvider::new( + crate::ptr::ThreadsafeFactoryPtr::new(factory_impl), + AsyncFactoryVariant::Normal, + )), + ) + .await; Ok(AsyncBindingWhenConfigurator::new(self.di_container.clone())) } /// Creates a binding of type `Interface` to a factory that takes no arguments - /// inside of the associated [`AsyncDIContainer`]. + /// inside of the associated [`IAsyncDIContainer`]. /// /// # Errors - /// Will return Err if the associated [`AsyncDIContainer`] already have a binding + /// Will return Err if the associated [`IAsyncDIContainer`] already have a binding /// for the interface. /// /// # Examples /// ``` /// # use std::error::Error; /// # - /// # use syrette::AsyncDIContainer; + /// # use syrette::di_container::asynchronous::prelude::*; /// # use syrette::ptr::TransientPtr; /// # /// # trait Foo: Send + Sync {} @@ -325,16 +342,21 @@ where /// # Ok(()) /// # } /// ``` + /// + /// [`IAsyncDIContainer`]: crate::di_container::asynchronous::IAsyncDIContainer #[cfg(feature = "factory")] #[cfg_attr(doc_cfg, doc(cfg(feature = "factory")))] pub async fn to_default_factory( &self, factory_func: &'static FactoryFunc, - ) -> Result, AsyncBindingBuilderError> + ) -> Result< + AsyncBindingWhenConfigurator, + AsyncBindingBuilderError, + > where Return: 'static + ?Sized, FactoryFunc: Fn< - (Arc,), + (Arc,), Output = BoxFn<(), crate::ptr::TransientPtr>, > + Send + Sync, @@ -342,9 +364,7 @@ where use crate::castable_factory::threadsafe::ThreadsafeCastableFactory; use crate::provider::r#async::AsyncFactoryVariant; - let mut bindings_lock = self.di_container.bindings.lock().await; - - if bindings_lock.has::(None) { + if self.di_container.has_binding::(None).await { return Err(AsyncBindingBuilderError::BindingAlreadyExists(type_name::< Interface, >( @@ -353,22 +373,24 @@ where let factory_impl = ThreadsafeCastableFactory::new(factory_func); - bindings_lock.set::( - None, - Box::new(crate::provider::r#async::AsyncFactoryProvider::new( - crate::ptr::ThreadsafeFactoryPtr::new(factory_impl), - AsyncFactoryVariant::Default, - )), - ); + self.di_container + .set_binding::( + None, + Box::new(crate::provider::r#async::AsyncFactoryProvider::new( + crate::ptr::ThreadsafeFactoryPtr::new(factory_impl), + AsyncFactoryVariant::Default, + )), + ) + .await; Ok(AsyncBindingWhenConfigurator::new(self.di_container.clone())) } /// Creates a binding of factory type `Interface` to a async factory inside of the - /// associated [`AsyncDIContainer`]. + /// associated [`IAsyncDIContainer`]. /// /// # Errors - /// Will return Err if the associated [`AsyncDIContainer`] already have a binding + /// Will return Err if the associated [`IAsyncDIContainer`] already have a binding /// for the interface. /// /// # Examples @@ -376,7 +398,8 @@ where /// # use std::error::Error; /// # use std::time::Duration; /// # - /// # use syrette::{AsyncDIContainer, async_closure}; + /// # use syrette::async_closure; + /// # use syrette::di_container::asynchronous::prelude::*; /// # use syrette::ptr::TransientPtr; /// # /// # trait Foo: Send + Sync {} @@ -413,16 +436,21 @@ where /// # Ok(()) /// # } /// ``` + /// + /// [`IAsyncDIContainer`]: crate::di_container::asynchronous::IAsyncDIContainer #[cfg(feature = "factory")] #[cfg_attr(doc_cfg, doc(cfg(feature = "factory")))] pub async fn to_async_default_factory( &self, factory_func: &'static FactoryFunc, - ) -> Result, AsyncBindingBuilderError> + ) -> Result< + AsyncBindingWhenConfigurator, + AsyncBindingBuilderError, + > where Return: 'static + ?Sized, FactoryFunc: Fn< - (Arc,), + (Arc,), Output = BoxFn<(), crate::future::BoxFuture<'static, Return>>, > + Send + Sync, @@ -430,9 +458,7 @@ where use crate::castable_factory::threadsafe::ThreadsafeCastableFactory; use crate::provider::r#async::AsyncFactoryVariant; - let mut bindings_lock = self.di_container.bindings.lock().await; - - if bindings_lock.has::(None) { + if self.di_container.has_binding::(None).await { return Err(AsyncBindingBuilderError::BindingAlreadyExists(type_name::< Interface, >( @@ -441,13 +467,15 @@ where let factory_impl = ThreadsafeCastableFactory::new(factory_func); - bindings_lock.set::( - None, - Box::new(crate::provider::r#async::AsyncFactoryProvider::new( - crate::ptr::ThreadsafeFactoryPtr::new(factory_impl), - AsyncFactoryVariant::AsyncDefault, - )), - ); + self.di_container + .set_binding::( + None, + Box::new(crate::provider::r#async::AsyncFactoryProvider::new( + crate::ptr::ThreadsafeFactoryPtr::new(factory_impl), + AsyncFactoryVariant::AsyncDefault, + )), + ) + .await; Ok(AsyncBindingWhenConfigurator::new(self.di_container.clone())) } @@ -458,127 +486,40 @@ mod tests { use std::error::Error; + use mockall::predicate::eq; + use super::*; - use crate::ptr::TransientPtr; + use crate::test_utils::mocks::async_di_container::MockAsyncDIContainer; use crate::test_utils::subjects_async; #[tokio::test] async fn can_bind_to() -> Result<(), Box> { - let mut di_container = AsyncDIContainer::new(); + let mut di_container_mock = MockAsyncDIContainer::new(); - { - assert_eq!(di_container.bindings.lock().await.count(), 0); - } + di_container_mock + .expect_has_binding::() + .with(eq(None)) + .return_once(|_name| false) + .once(); - di_container - .bind::() - .to::() - .await?; + di_container_mock + .expect_set_binding::() + .withf(|name, _provider| name.is_none()) + .return_once(|_name, _provider| ()) + .once(); - { - assert_eq!(di_container.bindings.lock().await.count(), 1); - } - - Ok(()) - } - - #[tokio::test] - async fn can_bind_to_transient() -> Result<(), Box> - { - let mut di_container = AsyncDIContainer::new(); - - { - assert_eq!(di_container.bindings.lock().await.count(), 0); - } + let binding_builder = AsyncBindingBuilder::< + dyn subjects_async::IUserManager, + MockAsyncDIContainer, + >::new(Arc::new(di_container_mock)); - di_container - .bind::() - .to::() - .await? - .in_transient_scope() - .await; - - { - assert_eq!(di_container.bindings.lock().await.count(), 1); - } - - Ok(()) - } - - #[tokio::test] - async fn can_bind_to_transient_when_named() -> Result<(), Box> - { - let mut di_container = AsyncDIContainer::new(); - - { - assert_eq!(di_container.bindings.lock().await.count(), 0); - } - - di_container - .bind::() - .to::() - .await? - .in_transient_scope() - .await - .when_named("regular") - .await?; - - { - assert_eq!(di_container.bindings.lock().await.count(), 1); - } - - Ok(()) - } - - #[tokio::test] - async fn can_bind_to_singleton() -> Result<(), Box> - { - let mut di_container = AsyncDIContainer::new(); - - { - assert_eq!(di_container.bindings.lock().await.count(), 0); - } - - di_container - .bind::() - .to::() - .await? - .in_singleton_scope() - .await?; - - { - assert_eq!(di_container.bindings.lock().await.count(), 1); - } - - Ok(()) - } - - #[tokio::test] - async fn can_bind_to_singleton_when_named() -> Result<(), Box> - { - let mut di_container = AsyncDIContainer::new(); - - { - assert_eq!(di_container.bindings.lock().await.count(), 0); - } - - di_container - .bind::() - .to::() - .await? - .in_singleton_scope() - .await? - .when_named("cool") - .await?; - - { - assert_eq!(di_container.bindings.lock().await.count(), 1); - } + binding_builder.to::().await?; Ok(()) } + /* #[tokio::test] #[cfg(feature = "factory")] async fn can_bind_to_factory() -> Result<(), Box> @@ -613,41 +554,5 @@ mod tests Ok(()) } - - #[tokio::test] - #[cfg(feature = "factory")] - async fn can_bind_to_factory_when_named() -> Result<(), Box> - { - use crate as syrette; - use crate::factory; - - #[factory(threadsafe = true)] - type IUserManagerFactory = dyn Fn() -> dyn subjects_async::IUserManager; - - let mut di_container = AsyncDIContainer::new(); - - { - assert_eq!(di_container.bindings.lock().await.count(), 0); - } - - di_container - .bind::() - .to_factory(&|_| { - Box::new(|| { - let user_manager: TransientPtr = - TransientPtr::new(subjects_async::UserManager::new()); - - user_manager - }) - }) - .await? - .when_named("awesome") - .await?; - - { - assert_eq!(di_container.bindings.lock().await.count(), 1); - } - - Ok(()) - } + */ } diff --git a/src/di_container/asynchronous/binding/scope_configurator.rs b/src/di_container/asynchronous/binding/scope_configurator.rs index 2b0f0b3..fd42fea 100644 --- a/src/di_container/asynchronous/binding/scope_configurator.rs +++ b/src/di_container/asynchronous/binding/scope_configurator.rs @@ -1,31 +1,38 @@ -//! Scope configurator for a binding for types inside of a [`AsyncDIContainer`]. +//! Scope configurator for a binding for types inside of a [`IAsyncDIContainer`]. +//! +//! [`IAsyncDIContainer`]: crate::di_container::asynchronous::IAsyncDIContainer use std::marker::PhantomData; use std::sync::Arc; use crate::di_container::asynchronous::binding::when_configurator::AsyncBindingWhenConfigurator; +use crate::di_container::asynchronous::IAsyncDIContainer; use crate::errors::async_di_container::AsyncBindingScopeConfiguratorError; use crate::interfaces::async_injectable::AsyncInjectable; use crate::provider::r#async::{AsyncSingletonProvider, AsyncTransientTypeProvider}; use crate::ptr::ThreadsafeSingletonPtr; -use crate::AsyncDIContainer; -/// Scope configurator for a binding for type 'Interface' inside a [`AsyncDIContainer`]. -pub struct AsyncBindingScopeConfigurator +/// Scope configurator for a binding for type 'Interface' inside a [`IAsyncDIContainer`]. +/// +/// [`IAsyncDIContainer`]: crate::di_container::asynchronous::IAsyncDIContainer +pub struct AsyncBindingScopeConfigurator where Interface: 'static + ?Sized + Send + Sync, - Implementation: AsyncInjectable, + Implementation: AsyncInjectable, + DIContainerType: IAsyncDIContainer, { - di_container: Arc, + di_container: Arc, interface_phantom: PhantomData, implementation_phantom: PhantomData, } -impl AsyncBindingScopeConfigurator +impl + AsyncBindingScopeConfigurator where Interface: 'static + ?Sized + Send + Sync, - Implementation: AsyncInjectable, + Implementation: AsyncInjectable, + DIContainerType: IAsyncDIContainer, { - pub(crate) fn new(di_container: Arc) -> Self + pub(crate) fn new(di_container: Arc) -> Self { Self { di_container, @@ -37,14 +44,18 @@ where /// Configures the binding to be in a transient scope. /// /// This is the default. - pub async fn in_transient_scope(&self) -> AsyncBindingWhenConfigurator + pub async fn in_transient_scope( + &self, + ) -> AsyncBindingWhenConfigurator { - let mut bindings_lock = self.di_container.bindings.lock().await; - - bindings_lock.set::( - None, - Box::new(AsyncTransientTypeProvider::::new()), - ); + self.di_container + .set_binding::( + None, + Box::new( + AsyncTransientTypeProvider::::new(), + ), + ) + .await; AsyncBindingWhenConfigurator::new(self.di_container.clone()) } @@ -55,7 +66,10 @@ where /// Will return Err if resolving the implementation fails. pub async fn in_singleton_scope( &self, - ) -> Result, AsyncBindingScopeConfiguratorError> + ) -> Result< + AsyncBindingWhenConfigurator, + AsyncBindingScopeConfiguratorError, + > { let singleton: ThreadsafeSingletonPtr = ThreadsafeSingletonPtr::from( @@ -66,10 +80,12 @@ where )?, ); - let mut bindings_lock = self.di_container.bindings.lock().await; - - bindings_lock - .set::(None, Box::new(AsyncSingletonProvider::new(singleton))); + self.di_container + .set_binding::( + None, + Box::new(AsyncSingletonProvider::new(singleton)), + ) + .await; Ok(AsyncBindingWhenConfigurator::new(self.di_container.clone())) } diff --git a/src/di_container/asynchronous/binding/when_configurator.rs b/src/di_container/asynchronous/binding/when_configurator.rs index b245ad8..3175420 100644 --- a/src/di_container/asynchronous/binding/when_configurator.rs +++ b/src/di_container/asynchronous/binding/when_configurator.rs @@ -1,25 +1,31 @@ -//! When configurator for a binding for types inside of a [`AsyncDIContainer`]. +//! When configurator for a binding for types inside of a [`IAsyncDIContainer`]. +//! +//! [`IAsyncDIContainer`]: crate::di_container::asynchronous::IAsyncDIContainer use std::any::type_name; use std::marker::PhantomData; use std::sync::Arc; +use crate::di_container::asynchronous::IAsyncDIContainer; use crate::errors::async_di_container::AsyncBindingWhenConfiguratorError; -use crate::AsyncDIContainer; -/// When configurator for a binding for type 'Interface' inside a [`AsyncDIContainer`]. -pub struct AsyncBindingWhenConfigurator +/// When configurator for a binding for type 'Interface' inside a [`IAsyncDIContainer`]. +/// +/// [`IAsyncDIContainer`]: crate::di_container::asynchronous::IAsyncDIContainer +pub struct AsyncBindingWhenConfigurator where Interface: 'static + ?Sized + Send + Sync, + DIContainerType: IAsyncDIContainer, { - di_container: Arc, + di_container: Arc, interface_phantom: PhantomData, } -impl AsyncBindingWhenConfigurator +impl AsyncBindingWhenConfigurator where Interface: 'static + ?Sized + Send + Sync, + DIContainerType: IAsyncDIContainer, { - pub(crate) fn new(di_container: Arc) -> Self + pub(crate) fn new(di_container: Arc) -> Self { Self { di_container, @@ -36,18 +42,22 @@ where name: &'static str, ) -> Result<(), AsyncBindingWhenConfiguratorError> { - let mut bindings_lock = self.di_container.bindings.lock().await; + let binding = self + .di_container + .remove_binding::(None) + .await + .map_or_else( + || { + Err(AsyncBindingWhenConfiguratorError::BindingNotFound( + type_name::(), + )) + }, + Ok, + )?; - let binding = bindings_lock.remove::(None).map_or_else( - || { - Err(AsyncBindingWhenConfiguratorError::BindingNotFound( - type_name::(), - )) - }, - Ok, - )?; - - bindings_lock.set::(Some(name), binding); + self.di_container + .set_binding::(Some(name), binding) + .await; Ok(()) } diff --git a/src/di_container/asynchronous/mod.rs b/src/di_container/asynchronous/mod.rs index b6653a5..14e6abe 100644 --- a/src/di_container/asynchronous/mod.rs +++ b/src/di_container/asynchronous/mod.rs @@ -5,7 +5,8 @@ //! use std::collections::HashMap; //! use std::error::Error; //! -//! use syrette::{injectable, AsyncDIContainer}; +//! use syrette::di_container::asynchronous::prelude::*; +//! use syrette::injectable; //! //! trait IDatabaseService: Send + Sync //! { @@ -53,6 +54,7 @@ use std::any::type_name; use std::sync::Arc; +use async_trait::async_trait; use tokio::sync::Mutex; use crate::di_container::asynchronous::binding::builder::AsyncBindingBuilder; @@ -65,11 +67,64 @@ use crate::provider::r#async::{AsyncProvidable, IAsyncProvider}; use crate::ptr::{SomeThreadsafePtr, TransientPtr}; pub mod binding; +pub mod prelude; + +/// Dependency injection container interface. +#[async_trait] +pub trait IAsyncDIContainer: + Sized + 'static + Send + Sync + details::DIContainerInternals +{ + /// Returns a new [`AsyncBindingBuilder`] for the given interface. + #[must_use] + fn bind(self: &mut Arc) -> AsyncBindingBuilder + where + Interface: 'static + ?Sized + Send + Sync; + + /// Returns the type bound with `Interface`. + /// + /// # Errors + /// Will return `Err` if: + /// - No binding for `Interface` exists + /// - Resolving the binding for `Interface` fails + /// - Casting the binding for `Interface` fails + fn get<'a, 'b, Interface>( + self: &'a Arc, + ) -> BoxFuture<'b, Result, AsyncDIContainerError>> + where + Interface: 'static + 'b + ?Sized + Send + Sync, + 'a: 'b, + Self: 'b; + + /// Returns the type bound with `Interface` and the specified name. + /// + /// # Errors + /// Will return `Err` if: + /// - No binding for `Interface` with name `name` exists + /// - Resolving the binding for `Interface` fails + /// - Casting the binding for `Interface` fails + fn get_named<'a, 'b, Interface>( + self: &'a Arc, + name: &'static str, + ) -> BoxFuture<'b, Result, AsyncDIContainerError>> + where + Interface: 'static + 'b + ?Sized + Send + Sync, + 'a: 'b, + Self: 'b; + + #[doc(hidden)] + async fn get_bound( + self: &Arc, + dependency_history: Vec<&'static str>, + name: Option<&'static str>, + ) -> Result, AsyncDIContainerError> + where + Interface: 'static + ?Sized + Send + Sync; +} /// Dependency injection container. pub struct AsyncDIContainer { - bindings: Mutex>, + bindings: Mutex>>, } impl AsyncDIContainer @@ -82,51 +137,43 @@ impl AsyncDIContainer bindings: Mutex::new(DIContainerBindingMap::new()), }) } +} - /// Returns a new [`AsyncBindingBuilder`] for the given interface. +#[async_trait] +impl IAsyncDIContainer for AsyncDIContainer +{ #[must_use] - pub fn bind(self: &mut Arc) -> AsyncBindingBuilder + fn bind(self: &mut Arc) -> AsyncBindingBuilder where Interface: 'static + ?Sized + Send + Sync, { - AsyncBindingBuilder::::new(self.clone()) + AsyncBindingBuilder::new(self.clone()) } - /// Returns the type bound with `Interface`. - /// - /// # Errors - /// Will return `Err` if: - /// - No binding for `Interface` exists - /// - Resolving the binding for `Interface` fails - /// - Casting the binding for `Interface` fails - pub async fn get( - self: &Arc, - ) -> Result, AsyncDIContainerError> + fn get<'a, 'b, Interface>( + self: &'a Arc, + ) -> BoxFuture<'b, Result, AsyncDIContainerError>> where - Interface: 'static + ?Sized + Send + Sync, + Interface: 'static + 'b + ?Sized + Send + Sync, + 'a: 'b, + Self: 'b, { - self.get_bound::(Vec::new(), None).await + Box::pin(async { self.get_bound::(Vec::new(), None).await }) } - /// Returns the type bound with `Interface` and the specified name. - /// - /// # Errors - /// Will return `Err` if: - /// - No binding for `Interface` with name `name` exists - /// - Resolving the binding for `Interface` fails - /// - Casting the binding for `Interface` fails - pub async fn get_named( - self: &Arc, + fn get_named<'a, 'b, Interface>( + self: &'a Arc, name: &'static str, - ) -> Result, AsyncDIContainerError> + ) -> BoxFuture<'b, Result, AsyncDIContainerError>> where - Interface: 'static + ?Sized + Send + Sync, + Interface: 'static + 'b + ?Sized + Send + Sync, + 'a: 'b, + Self: 'b, { - self.get_bound::(Vec::new(), Some(name)).await + Box::pin(async { self.get_bound::(Vec::new(), Some(name)).await }) } - #[doc(hidden)] - pub async fn get_bound( + async fn get_bound( self: &Arc, dependency_history: Vec<&'static str>, name: Option<&'static str>, @@ -140,10 +187,44 @@ impl AsyncDIContainer self.handle_binding_providable(binding_providable).await } +} + +#[async_trait] +impl details::DIContainerInternals for AsyncDIContainer +{ + async fn has_binding(self: &Arc, name: Option<&'static str>) -> bool + where + Interface: ?Sized + 'static, + { + self.bindings.lock().await.has::(name) + } + + async fn set_binding( + self: &Arc, + name: Option<&'static str>, + provider: Box>, + ) where + Interface: 'static + ?Sized, + { + self.bindings.lock().await.set::(name, provider); + } + async fn remove_binding( + self: &Arc, + name: Option<&'static str>, + ) -> Option>> + where + Interface: 'static + ?Sized, + { + self.bindings.lock().await.remove::(name) + } +} + +impl AsyncDIContainer +{ async fn handle_binding_providable( self: &Arc, - binding_providable: AsyncProvidable, + binding_providable: AsyncProvidable, ) -> Result, AsyncDIContainerError> where Interface: 'static + ?Sized + Send + Sync, @@ -261,7 +342,7 @@ impl AsyncDIContainer self: &Arc, name: Option<&'static str>, dependency_history: Vec<&'static str>, - ) -> Result + ) -> Result, AsyncDIContainerError> where Interface: 'static + ?Sized + Send + Sync, { @@ -294,6 +375,40 @@ impl AsyncDIContainer } } +pub(crate) mod details +{ + use std::sync::Arc; + + use async_trait::async_trait; + + use crate::provider::r#async::IAsyncProvider; + + #[async_trait] + pub trait DIContainerInternals + { + async fn has_binding( + self: &Arc, + name: Option<&'static str>, + ) -> bool + where + Interface: ?Sized + 'static; + + async fn set_binding( + self: &Arc, + name: Option<&'static str>, + provider: Box>, + ) where + Interface: 'static + ?Sized; + + async fn remove_binding( + self: &Arc, + name: Option<&'static str>, + ) -> Option>> + where + Interface: 'static + ?Sized; + } +} + #[cfg(test)] mod tests { @@ -314,15 +429,15 @@ mod tests Provider {} #[async_trait] - impl IAsyncProvider for Provider + impl IAsyncProvider for Provider { async fn provide( &self, di_container: &Arc, dependency_history: Vec<&'static str>, - ) -> Result; + ) -> Result, InjectableError>; - fn do_clone(&self) -> Box; + fn do_clone(&self) -> Box>; } } @@ -365,15 +480,15 @@ mod tests Provider {} #[async_trait] - impl IAsyncProvider for Provider + impl IAsyncProvider for Provider { async fn provide( &self, di_container: &Arc, dependency_history: Vec<&'static str>, - ) -> Result; + ) -> Result, InjectableError>; - fn do_clone(&self) -> Box; + fn do_clone(&self) -> Box>; } } @@ -419,15 +534,15 @@ mod tests Provider {} #[async_trait] - impl IAsyncProvider for Provider + impl IAsyncProvider for Provider { async fn provide( &self, di_container: &Arc, dependency_history: Vec<&'static str>, - ) -> Result; + ) -> Result, InjectableError>; - fn do_clone(&self) -> Box; + fn do_clone(&self) -> Box>; } } @@ -483,15 +598,15 @@ mod tests Provider {} #[async_trait] - impl IAsyncProvider for Provider + impl IAsyncProvider for Provider { async fn provide( &self, di_container: &Arc, dependency_history: Vec<&'static str>, - ) -> Result; + ) -> Result, InjectableError>; - fn do_clone(&self) -> Box; + fn do_clone(&self) -> Box>; } } @@ -593,15 +708,15 @@ mod tests Provider {} #[async_trait] - impl IAsyncProvider for Provider + impl IAsyncProvider for Provider { async fn provide( &self, di_container: &Arc, dependency_history: Vec<&'static str>, - ) -> Result; + ) -> Result, InjectableError>; - fn do_clone(&self) -> Box; + fn do_clone(&self) -> Box>; } } @@ -704,15 +819,15 @@ mod tests Provider {} #[async_trait] - impl IAsyncProvider for Provider + impl IAsyncProvider for Provider { async fn provide( &self, di_container: &Arc, dependency_history: Vec<&'static str>, - ) -> Result; + ) -> Result, InjectableError>; - fn do_clone(&self) -> Box; + fn do_clone(&self) -> Box>; } } diff --git a/src/di_container/asynchronous/prelude.rs b/src/di_container/asynchronous/prelude.rs new file mode 100644 index 0000000..50fc42b --- /dev/null +++ b/src/di_container/asynchronous/prelude.rs @@ -0,0 +1,3 @@ +//! Commonly used types. + +pub use crate::di_container::asynchronous::{AsyncDIContainer, IAsyncDIContainer}; diff --git a/src/di_container/binding_map.rs b/src/di_container/binding_map.rs index 6ecd34c..3a73f7a 100644 --- a/src/di_container/binding_map.rs +++ b/src/di_container/binding_map.rs @@ -81,13 +81,6 @@ where name, }) } - - /// Only used by tests in the `di_container` module. - #[cfg(test)] - pub fn count(&self) -> usize - { - self.bindings.len() - } } #[cfg(test)] diff --git a/src/di_container/blocking/binding/builder.rs b/src/di_container/blocking/binding/builder.rs index 8e15f0c..e1c1561 100644 --- a/src/di_container/blocking/binding/builder.rs +++ b/src/di_container/blocking/binding/builder.rs @@ -1,4 +1,6 @@ -//! Binding builder for types inside of a [`DIContainer`]. +//! Binding builder for types inside of a [`IDIContainer`]. +//! +//! [`IDIContainer`]: crate::di_container::blocking::IDIContainer use std::any::type_name; use std::marker::PhantomData; use std::rc::Rc; @@ -6,24 +8,28 @@ use std::rc::Rc; use crate::di_container::blocking::binding::scope_configurator::BindingScopeConfigurator; #[cfg(feature = "factory")] use crate::di_container::blocking::binding::when_configurator::BindingWhenConfigurator; -use crate::di_container::blocking::DIContainer; +use crate::di_container::blocking::IDIContainer; use crate::errors::di_container::BindingBuilderError; use crate::interfaces::injectable::Injectable; -/// Binding builder for type `Interface` inside a [`DIContainer`]. -pub struct BindingBuilder +/// Binding builder for type `Interface` inside a [`IDIContainer`]. +/// +/// [`IDIContainer`]: crate::di_container::blocking::IDIContainer +pub struct BindingBuilder where Interface: 'static + ?Sized, + DIContainerType: IDIContainer, { - di_container: Rc, + di_container: Rc, interface_phantom: PhantomData, } -impl BindingBuilder +impl BindingBuilder where Interface: 'static + ?Sized, + DIContainerType: IDIContainer, { - pub(crate) fn new(di_container: Rc) -> Self + pub(crate) fn new(di_container: Rc) -> Self { Self { di_container, @@ -32,13 +38,13 @@ where } /// Creates a binding of type `Interface` to type `Implementation` inside of the - /// associated [`DIContainer`]. + /// associated [`IDIContainer`]. /// /// The scope of the binding is transient. But that can be changed by using the /// returned [`BindingScopeConfigurator`] /// /// # Errors - /// Will return Err if the associated [`DIContainer`] already have a binding for + /// Will return Err if the associated [`IDIContainer`] already have a binding for /// the interface. /// /// # Examples @@ -46,6 +52,7 @@ where /// # use std::error::Error; /// # /// # use syrette::{DIContainer, injectable}; + /// # use syrette::di_container::blocking::IDIContainer; /// # /// # trait Foo {} /// # @@ -70,16 +77,19 @@ where /// # Ok(()) /// # } /// ``` + /// + /// [`IDIContainer`]: crate::di_container::blocking::IDIContainer pub fn to( &self, - ) -> Result, BindingBuilderError> + ) -> Result< + BindingScopeConfigurator, + BindingBuilderError, + > where - Implementation: Injectable, + Implementation: Injectable, { { - let bindings = self.di_container.bindings.borrow(); - - if bindings.has::(None) { + if self.di_container.has_binding::(None) { return Err(BindingBuilderError::BindingAlreadyExists(type_name::< Interface, >( @@ -96,10 +106,10 @@ where } /// Creates a binding of factory type `Interface` to a factory inside of the - /// associated [`DIContainer`]. + /// associated [`IDIContainer`]. /// /// # Errors - /// Will return Err if the associated [`DIContainer`] already have a binding for + /// Will return Err if the associated [`IDIContainer`] already have a binding for /// the interface. /// /// # Examples @@ -108,6 +118,7 @@ where /// # /// # use syrette::{DIContainer, factory}; /// # use syrette::ptr::TransientPtr; + /// # use syrette::di_container::blocking::IDIContainer; /// # /// # trait ICustomerID {} /// # trait ICustomer {} @@ -158,36 +169,31 @@ where /// # Ok(()) /// # } /// ``` + /// + /// [`IDIContainer`]: crate::di_container::blocking::IDIContainer #[cfg(feature = "factory")] #[cfg_attr(doc_cfg, doc(cfg(feature = "factory")))] pub fn to_factory( &self, factory_func: &'static Func, - ) -> Result, BindingBuilderError> + ) -> Result, BindingBuilderError> where Args: 'static, Return: 'static + ?Sized, Interface: Fn>, - Func: Fn<(std::rc::Rc,), Output = Box>, + Func: Fn<(std::rc::Rc,), Output = Box>, { use crate::castable_factory::blocking::CastableFactory; - { - let bindings = self.di_container.bindings.borrow(); - - if bindings.has::(None) { - return Err(BindingBuilderError::BindingAlreadyExists(type_name::< - Interface, - >( - ))); - } + if self.di_container.has_binding::(None) { + return Err(BindingBuilderError::BindingAlreadyExists(type_name::< + Interface, + >())); } - let mut bindings_mut = self.di_container.bindings.borrow_mut(); - let factory_impl = CastableFactory::new(factory_func); - bindings_mut.set::( + self.di_container.set_binding::( None, Box::new(crate::provider::blocking::FactoryProvider::new( crate::ptr::FactoryPtr::new(factory_impl), @@ -199,10 +205,10 @@ where } /// Creates a binding of type `Interface` to a factory that takes no arguments - /// inside of the associated [`DIContainer`]. + /// inside of the associated [`IDIContainer`]. /// /// # Errors - /// Will return Err if the associated [`DIContainer`] already have a binding for + /// Will return Err if the associated [`IDIContainer`] already have a binding for /// the interface. /// /// # Examples @@ -211,6 +217,7 @@ where /// # /// # use syrette::{DIContainer, factory}; /// # use syrette::ptr::TransientPtr; + /// # use syrette::di_container::blocking::IDIContainer; /// # /// # trait IBuffer {} /// # @@ -248,16 +255,18 @@ where /// # Ok(()) /// # } /// ``` + /// + /// [`IDIContainer`]: crate::di_container::blocking::IDIContainer #[cfg(feature = "factory")] #[cfg_attr(doc_cfg, doc(cfg(feature = "factory")))] pub fn to_default_factory( &self, factory_func: &'static FactoryFunc, - ) -> Result, BindingBuilderError> + ) -> Result, BindingBuilderError> where Return: 'static + ?Sized, FactoryFunc: Fn< - (Rc,), + (Rc,), Output = crate::ptr::TransientPtr< dyn Fn<(), Output = crate::ptr::TransientPtr>, >, @@ -265,22 +274,15 @@ where { use crate::castable_factory::blocking::CastableFactory; - { - let bindings = self.di_container.bindings.borrow(); - - if bindings.has::(None) { - return Err(BindingBuilderError::BindingAlreadyExists(type_name::< - Interface, - >( - ))); - } + if self.di_container.has_binding::(None) { + return Err(BindingBuilderError::BindingAlreadyExists(type_name::< + Interface, + >())); } - let mut bindings_mut = self.di_container.bindings.borrow_mut(); - let factory_impl = CastableFactory::new(factory_func); - bindings_mut.set::( + self.di_container.set_binding::( None, Box::new(crate::provider::blocking::FactoryProvider::new( crate::ptr::FactoryPtr::new(factory_impl), @@ -297,92 +299,34 @@ mod tests { use std::error::Error; + use mockall::predicate::eq; + use super::*; - use crate::ptr::TransientPtr; - use crate::test_utils::subjects; + use crate::test_utils::{mocks, subjects}; #[test] fn can_bind_to() -> Result<(), Box> { - let mut di_container = DIContainer::new(); + let mut mock_di_container = mocks::blocking_di_container::MockDIContainer::new(); - assert_eq!(di_container.bindings.borrow().count(), 0); + mock_di_container + .expect_has_binding::() + .with(eq(None)) + .return_once(|_name| false) + .once(); - di_container - .bind::() - .to::()?; + mock_di_container + .expect_set_binding::() + .withf(|name, _provider| name.is_none()) + .return_once(|_name, _provider| ()) + .once(); - assert_eq!(di_container.bindings.borrow().count(), 1); + let binding_builder = BindingBuilder::< + dyn subjects::INumber, + mocks::blocking_di_container::MockDIContainer, + >::new(Rc::new(mock_di_container)); - Ok(()) - } - - #[test] - fn can_bind_to_transient() -> Result<(), Box> - { - let mut di_container = DIContainer::new(); - - assert_eq!(di_container.bindings.borrow().count(), 0); - - di_container - .bind::() - .to::()? - .in_transient_scope(); - - assert_eq!(di_container.bindings.borrow().count(), 1); - - Ok(()) - } - - #[test] - fn can_bind_to_transient_when_named() -> Result<(), Box> - { - let mut di_container = DIContainer::new(); - - assert_eq!(di_container.bindings.borrow().count(), 0); - - di_container - .bind::() - .to::()? - .in_transient_scope() - .when_named("regular")?; - - assert_eq!(di_container.bindings.borrow().count(), 1); - - Ok(()) - } - - #[test] - fn can_bind_to_singleton() -> Result<(), Box> - { - let mut di_container = DIContainer::new(); - - assert_eq!(di_container.bindings.borrow().count(), 0); - - di_container - .bind::() - .to::()? - .in_singleton_scope()?; - - assert_eq!(di_container.bindings.borrow().count(), 1); - - Ok(()) - } - - #[test] - fn can_bind_to_singleton_when_named() -> Result<(), Box> - { - let mut di_container = DIContainer::new(); - - assert_eq!(di_container.bindings.borrow().count(), 0); - - di_container - .bind::() - .to::()? - .in_singleton_scope()? - .when_named("cool")?; - - assert_eq!(di_container.bindings.borrow().count(), 1); + binding_builder.to::()?; Ok(()) } @@ -393,57 +337,80 @@ mod tests { use crate as syrette; use crate::factory; + use crate::ptr::TransientPtr; #[factory] - type IUserManagerFactory = dyn Fn() -> dyn subjects::IUserManager; + type IUserManagerFactory = dyn Fn(i32, String) -> dyn subjects::IUserManager; - let mut di_container = DIContainer::new(); + let mut mock_di_container = mocks::blocking_di_container::MockDIContainer::new(); - assert_eq!(di_container.bindings.borrow().count(), 0); + mock_di_container + .expect_has_binding::() + .with(eq(None)) + .return_once(|_name| false) + .once(); - di_container - .bind::() - .to_factory(&|_| { - Box::new(move || { - let user_manager: TransientPtr = - TransientPtr::new(subjects::UserManager::new()); + mock_di_container + .expect_set_binding::() + .withf(|name, _provider| name.is_none()) + .return_once(|_name, _provider| ()) + .once(); - user_manager - }) - })?; + let binding_builder = BindingBuilder::< + IUserManagerFactory, + mocks::blocking_di_container::MockDIContainer, + >::new(Rc::new(mock_di_container)); - assert_eq!(di_container.bindings.borrow().count(), 1); + binding_builder.to_factory(&|_| { + Box::new(move |_num, _text| { + let user_manager: TransientPtr = + TransientPtr::new(subjects::UserManager::new()); + + user_manager + }) + })?; Ok(()) } #[test] #[cfg(feature = "factory")] - fn can_bind_to_factory_when_named() -> Result<(), Box> + fn can_bind_to_default_factory() -> Result<(), Box> { + use syrette_macros::declare_default_factory; + use crate as syrette; - use crate::factory; + use crate::ptr::TransientPtr; - #[factory] - type IUserManagerFactory = dyn Fn() -> dyn subjects::IUserManager; + declare_default_factory!(dyn subjects::IUserManager); + + let mut mock_di_container = mocks::blocking_di_container::MockDIContainer::new(); - let mut di_container = DIContainer::new(); + mock_di_container + .expect_has_binding::() + .with(eq(None)) + .return_once(|_name| false) + .once(); - assert_eq!(di_container.bindings.borrow().count(), 0); + mock_di_container + .expect_set_binding::() + .withf(|name, _provider| name.is_none()) + .return_once(|_name, _provider| ()) + .once(); - di_container - .bind::() - .to_factory(&|_| { - Box::new(move || { - let user_manager: TransientPtr = - TransientPtr::new(subjects::UserManager::new()); + let binding_builder = BindingBuilder::< + dyn subjects::IUserManager, + mocks::blocking_di_container::MockDIContainer, + >::new(Rc::new(mock_di_container)); - user_manager - }) - })? - .when_named("awesome")?; + binding_builder.to_default_factory(&|_| { + Box::new(move || { + let user_manager: TransientPtr = + TransientPtr::new(subjects::UserManager::new()); - assert_eq!(di_container.bindings.borrow().count(), 1); + user_manager + }) + })?; Ok(()) } diff --git a/src/di_container/blocking/binding/scope_configurator.rs b/src/di_container/blocking/binding/scope_configurator.rs index 09897b6..5553415 100644 --- a/src/di_container/blocking/binding/scope_configurator.rs +++ b/src/di_container/blocking/binding/scope_configurator.rs @@ -1,31 +1,38 @@ -//! Scope configurator for a binding for types inside of a [`DIContainer`]. +//! Scope configurator for a binding for types inside of a [`IDIContainer`]. +//! +//! [`IDIContainer`]: crate::di_container::blocking::IDIContainer use std::marker::PhantomData; use std::rc::Rc; use crate::di_container::blocking::binding::when_configurator::BindingWhenConfigurator; -use crate::di_container::blocking::DIContainer; +use crate::di_container::blocking::IDIContainer; use crate::errors::di_container::BindingScopeConfiguratorError; use crate::interfaces::injectable::Injectable; use crate::provider::blocking::{SingletonProvider, TransientTypeProvider}; use crate::ptr::SingletonPtr; -/// Scope configurator for a binding for type 'Interface' inside a [`DIContainer`]. -pub struct BindingScopeConfigurator +/// Scope configurator for a binding for type 'Interface' inside a [`IDIContainer`]. +/// +/// [`IDIContainer`]: crate::di_container::blocking::IDIContainer +pub struct BindingScopeConfigurator where Interface: 'static + ?Sized, - Implementation: Injectable, + Implementation: Injectable, + DIContainerType: IDIContainer, { - di_container: Rc, + di_container: Rc, interface_phantom: PhantomData, implementation_phantom: PhantomData, } -impl BindingScopeConfigurator +impl + BindingScopeConfigurator where Interface: 'static + ?Sized, - Implementation: Injectable, + Implementation: Injectable, + DIContainerType: IDIContainer, { - pub(crate) fn new(di_container: Rc) -> Self + pub(crate) fn new(di_container: Rc) -> Self { Self { di_container, @@ -38,13 +45,13 @@ where /// /// This is the default. #[allow(clippy::must_use_candidate)] - pub fn in_transient_scope(&self) -> BindingWhenConfigurator + pub fn in_transient_scope( + &self, + ) -> BindingWhenConfigurator { - let mut bindings_mut = self.di_container.bindings.borrow_mut(); - - bindings_mut.set::( + self.di_container.set_binding::( None, - Box::new(TransientTypeProvider::::new()), + Box::new(TransientTypeProvider::::new()), ); BindingWhenConfigurator::new(self.di_container.clone()) @@ -56,16 +63,18 @@ where /// Will return Err if resolving the implementation fails. pub fn in_singleton_scope( &self, - ) -> Result, BindingScopeConfiguratorError> + ) -> Result< + BindingWhenConfigurator, + BindingScopeConfiguratorError, + > { let singleton: SingletonPtr = SingletonPtr::from( Implementation::resolve(&self.di_container, Vec::new()) .map_err(BindingScopeConfiguratorError::SingletonResolveFailed)?, ); - let mut bindings_mut = self.di_container.bindings.borrow_mut(); - - bindings_mut.set::(None, Box::new(SingletonProvider::new(singleton))); + self.di_container + .set_binding::(None, Box::new(SingletonProvider::new(singleton))); Ok(BindingWhenConfigurator::new(self.di_container.clone())) } diff --git a/src/di_container/blocking/binding/when_configurator.rs b/src/di_container/blocking/binding/when_configurator.rs index 9cd9bb6..5b9a8c0 100644 --- a/src/di_container/blocking/binding/when_configurator.rs +++ b/src/di_container/blocking/binding/when_configurator.rs @@ -1,25 +1,31 @@ -//! When configurator for a binding for types inside of a [`DIContainer`]. +//! When configurator for a binding for types inside of a [`IDIContainer`]. +//! +//! [`IDIContainer`]: crate::di_container::blocking::IDIContainer use std::any::type_name; use std::marker::PhantomData; use std::rc::Rc; -use crate::di_container::blocking::DIContainer; +use crate::di_container::blocking::IDIContainer; use crate::errors::di_container::BindingWhenConfiguratorError; -/// When configurator for a binding for type 'Interface' inside a [`DIContainer`]. -pub struct BindingWhenConfigurator +/// When configurator for a binding for type 'Interface' inside a [`IDIContainer`]. +/// +/// [`IDIContainer`]: crate::di_container::blocking::IDIContainer +pub struct BindingWhenConfigurator where Interface: 'static + ?Sized, + DIContainerType: IDIContainer, { - di_container: Rc, + di_container: Rc, interface_phantom: PhantomData, } -impl BindingWhenConfigurator +impl BindingWhenConfigurator where Interface: 'static + ?Sized, + DIContainerType: IDIContainer, { - pub(crate) fn new(di_container: Rc) -> Self + pub(crate) fn new(di_container: Rc) -> Self { Self { di_container, @@ -36,19 +42,21 @@ where name: &'static str, ) -> Result<(), BindingWhenConfiguratorError> { - let mut bindings_mut = self.di_container.bindings.borrow_mut(); + let binding = self + .di_container + .remove_binding::(None) + .map_or_else( + || { + Err(BindingWhenConfiguratorError::BindingNotFound(type_name::< + Interface, + >( + ))) + }, + Ok, + )?; - let binding = bindings_mut.remove::(None).map_or_else( - || { - Err(BindingWhenConfiguratorError::BindingNotFound(type_name::< - Interface, - >( - ))) - }, - Ok, - )?; - - bindings_mut.set::(Some(name), binding); + self.di_container + .set_binding::(Some(name), binding); Ok(()) } diff --git a/src/di_container/blocking/mod.rs b/src/di_container/blocking/mod.rs index f6b64fa..3b9c16e 100644 --- a/src/di_container/blocking/mod.rs +++ b/src/di_container/blocking/mod.rs @@ -5,6 +5,7 @@ //! use std::collections::HashMap; //! use std::error::Error; //! +//! use syrette::di_container::blocking::IDIContainer; //! use syrette::{injectable, DIContainer}; //! //! trait IDatabaseService @@ -61,11 +62,55 @@ use crate::provider::blocking::{IProvider, Providable}; use crate::ptr::SomePtr; pub mod binding; +pub mod prelude; -/// Dependency injection container. +/// Blocking dependency injection container interface. +pub trait IDIContainer: Sized + 'static + details::DIContainerInternals +{ + /// Returns a new [`BindingBuilder`] for the given interface. + fn bind(self: &mut Rc) -> BindingBuilder + where + Interface: 'static + ?Sized; + + /// Returns the type bound with `Interface`. + /// + /// # Errors + /// Will return `Err` if: + /// - No binding for `Interface` exists + /// - Resolving the binding for `Interface` fails + /// - Casting the binding for `Interface` fails + fn get(self: &Rc) -> Result, DIContainerError> + where + Interface: 'static + ?Sized; + + /// Returns the type bound with `Interface` and the specified name. + /// + /// # Errors + /// Will return `Err` if: + /// - No binding for `Interface` with name `name` exists + /// - Resolving the binding for `Interface` fails + /// - Casting the binding for `Interface` fails + fn get_named( + self: &Rc, + name: &'static str, + ) -> Result, DIContainerError> + where + Interface: 'static + ?Sized; + + #[doc(hidden)] + fn get_bound( + self: &Rc, + dependency_history: Vec<&'static str>, + name: Option<&'static str>, + ) -> Result, DIContainerError> + where + Interface: 'static + ?Sized; +} + +/// Blocking dependency injection container. pub struct DIContainer { - bindings: RefCell>, + bindings: RefCell>>, } impl DIContainer @@ -78,38 +123,26 @@ impl DIContainer bindings: RefCell::new(DIContainerBindingMap::new()), }) } +} - /// Returns a new [`BindingBuilder`] for the given interface. +impl IDIContainer for DIContainer +{ #[must_use] - pub fn bind(self: &mut Rc) -> BindingBuilder + fn bind(self: &mut Rc) -> BindingBuilder where Interface: 'static + ?Sized, { - BindingBuilder::::new(self.clone()) + BindingBuilder::::new(self.clone()) } - /// Returns the type bound with `Interface`. - /// - /// # Errors - /// Will return `Err` if: - /// - No binding for `Interface` exists - /// - Resolving the binding for `Interface` fails - /// - Casting the binding for `Interface` fails - pub fn get(self: &Rc) -> Result, DIContainerError> + fn get(self: &Rc) -> Result, DIContainerError> where Interface: 'static + ?Sized, { self.get_bound::(Vec::new(), None) } - /// Returns the type bound with `Interface` and the specified name. - /// - /// # Errors - /// Will return `Err` if: - /// - No binding for `Interface` with name `name` exists - /// - Resolving the binding for `Interface` fails - /// - Casting the binding for `Interface` fails - pub fn get_named( + fn get_named( self: &Rc, name: &'static str, ) -> Result, DIContainerError> @@ -120,7 +153,7 @@ impl DIContainer } #[doc(hidden)] - pub fn get_bound( + fn get_bound( self: &Rc, dependency_history: Vec<&'static str>, name: Option<&'static str>, @@ -133,10 +166,43 @@ impl DIContainer self.handle_binding_providable(binding_providable) } +} + +impl details::DIContainerInternals for DIContainer +{ + fn has_binding(self: &Rc, name: Option<&'static str>) -> bool + where + Interface: ?Sized + 'static, + { + self.bindings.borrow().has::(name) + } + + fn set_binding( + self: &Rc, + name: Option<&'static str>, + provider: Box>, + ) where + Interface: 'static + ?Sized, + { + self.bindings.borrow_mut().set::(name, provider); + } + + fn remove_binding( + self: &Rc, + name: Option<&'static str>, + ) -> Option>> + where + Interface: 'static + ?Sized, + { + self.bindings.borrow_mut().remove::(name) + } +} +impl DIContainer +{ fn handle_binding_providable( self: &Rc, - binding_providable: Providable, + binding_providable: Providable, ) -> Result, DIContainerError> where Interface: 'static + ?Sized, @@ -195,7 +261,7 @@ impl DIContainer self: &Rc, name: Option<&'static str>, dependency_history: Vec<&'static str>, - ) -> Result + ) -> Result, DIContainerError> where Interface: 'static + ?Sized, { @@ -219,6 +285,34 @@ impl DIContainer } } +pub(crate) mod details +{ + use std::rc::Rc; + + use crate::provider::blocking::IProvider; + + pub trait DIContainerInternals + { + fn has_binding(self: &Rc, name: Option<&'static str>) -> bool + where + Interface: ?Sized + 'static; + + fn set_binding( + self: &Rc, + name: Option<&'static str>, + provider: Box>, + ) where + Interface: 'static + ?Sized; + + fn remove_binding( + self: &Rc, + name: Option<&'static str>, + ) -> Option>> + where + Interface: 'static + ?Sized; + } +} + #[cfg(test)] mod tests { @@ -238,13 +332,13 @@ mod tests mock! { Provider {} - impl IProvider for Provider + impl IProvider for Provider { fn provide( &self, di_container: &Rc, dependency_history: Vec<&'static str>, - ) -> Result; + ) -> Result, InjectableError>; } } @@ -276,13 +370,13 @@ mod tests mock! { Provider {} - impl IProvider for Provider + impl IProvider for Provider { fn provide( &self, di_container: &Rc, dependency_history: Vec<&'static str>, - ) -> Result; + ) -> Result, InjectableError>; } } @@ -314,13 +408,13 @@ mod tests mock! { Provider {} - impl IProvider for Provider + impl IProvider for Provider { fn provide( &self, di_container: &Rc, dependency_history: Vec<&'static str>, - ) -> Result; + ) -> Result, InjectableError>; } } @@ -359,13 +453,13 @@ mod tests mock! { Provider {} - impl IProvider for Provider + impl IProvider for Provider { fn provide( &self, di_container: &Rc, dependency_history: Vec<&'static str>, - ) -> Result; + ) -> Result, InjectableError>; } } @@ -459,13 +553,13 @@ mod tests mock! { Provider {} - impl IProvider for Provider + impl IProvider for Provider { fn provide( &self, di_container: &Rc, dependency_history: Vec<&'static str>, - ) -> Result; + ) -> Result, InjectableError>; } } @@ -556,13 +650,13 @@ mod tests mock! { Provider {} - impl IProvider for Provider + impl IProvider for Provider { fn provide( &self, di_container: &Rc, dependency_history: Vec<&'static str>, - ) -> Result; + ) -> Result, InjectableError>; } } diff --git a/src/di_container/blocking/prelude.rs b/src/di_container/blocking/prelude.rs new file mode 100644 index 0000000..82db5e3 --- /dev/null +++ b/src/di_container/blocking/prelude.rs @@ -0,0 +1,2 @@ +//! Commonly used types. +pub use crate::di_container::blocking::{DIContainer, IDIContainer}; diff --git a/src/interfaces/async_injectable.rs b/src/interfaces/async_injectable.rs index dadb603..fb7f8ba 100644 --- a/src/interfaces/async_injectable.rs +++ b/src/interfaces/async_injectable.rs @@ -2,21 +2,23 @@ use std::fmt::Debug; use std::sync::Arc; +use crate::di_container::asynchronous::IAsyncDIContainer; use crate::errors::injectable::InjectableError; use crate::future::BoxFuture; use crate::libs::intertrait::CastFromSync; use crate::ptr::TransientPtr; -use crate::AsyncDIContainer; /// Interface for structs that can be injected into or be injected to. -pub trait AsyncInjectable: CastFromSync +pub trait AsyncInjectable: CastFromSync +where + DIContainerType: IAsyncDIContainer, { /// Resolves the dependencies of the injectable. /// /// # Errors /// Will return `Err` if resolving the dependencies fails. fn resolve<'di_container, 'fut>( - di_container: &'di_container Arc, + di_container: &'di_container Arc, dependency_history: Vec<&'static str>, ) -> BoxFuture<'fut, Result, InjectableError>> where @@ -24,7 +26,9 @@ pub trait AsyncInjectable: CastFromSync 'di_container: 'fut; } -impl Debug for dyn AsyncInjectable +impl Debug for dyn AsyncInjectable +where + DIContainerType: IAsyncDIContainer, { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { diff --git a/src/interfaces/injectable.rs b/src/interfaces/injectable.rs index f4c7fda..132935d 100644 --- a/src/interfaces/injectable.rs +++ b/src/interfaces/injectable.rs @@ -2,27 +2,31 @@ use std::fmt::Debug; use std::rc::Rc; +use crate::di_container::blocking::IDIContainer; use crate::errors::injectable::InjectableError; use crate::libs::intertrait::CastFrom; use crate::ptr::TransientPtr; -use crate::DIContainer; /// Interface for structs that can be injected into or be injected to. -pub trait Injectable: CastFrom +pub trait Injectable: CastFrom +where + DIContainerType: IDIContainer, { /// Resolves the dependencies of the injectable. /// /// # Errors /// Will return `Err` if resolving the dependencies fails. fn resolve( - di_container: &Rc, + di_container: &Rc, dependency_history: Vec<&'static str>, ) -> Result, InjectableError> where Self: Sized; } -impl Debug for dyn Injectable +impl Debug for dyn Injectable +where + DIContainerType: IDIContainer, { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { diff --git a/src/lib.rs b/src/lib.rs index a3da74a..6827768 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -57,6 +57,7 @@ mod test_utils; /// # Examples /// ``` /// # use syrette::{di_container_bind, DIContainer, injectable}; +/// # use syrette::di_container::blocking::IDIContainer; /// # /// # trait INinja {} /// # diff --git a/src/provider/async.rs b/src/provider/async.rs index ec05b06..5b4bf89 100644 --- a/src/provider/async.rs +++ b/src/provider/async.rs @@ -3,16 +3,18 @@ use std::sync::Arc; use async_trait::async_trait; +use crate::di_container::asynchronous::IAsyncDIContainer; use crate::errors::injectable::InjectableError; use crate::interfaces::async_injectable::AsyncInjectable; use crate::ptr::{ThreadsafeSingletonPtr, TransientPtr}; -use crate::AsyncDIContainer; #[derive(strum_macros::Display, Debug)] -pub enum AsyncProvidable +pub enum AsyncProvidable +where + DIContainerType: IAsyncDIContainer, { - Transient(TransientPtr), - Singleton(ThreadsafeSingletonPtr), + Transient(TransientPtr>), + Singleton(ThreadsafeSingletonPtr>), #[cfg(feature = "factory")] Factory( crate::ptr::ThreadsafeFactoryPtr< @@ -34,18 +36,22 @@ pub enum AsyncProvidable } #[async_trait] -pub trait IAsyncProvider: Send + Sync +pub trait IAsyncProvider: Send + Sync +where + DIContainerType: IAsyncDIContainer, { async fn provide( &self, - di_container: &Arc, + di_container: &Arc, dependency_history: Vec<&'static str>, - ) -> Result; + ) -> Result, InjectableError>; - fn do_clone(&self) -> Box; + fn do_clone(&self) -> Box>; } -impl Clone for Box +impl Clone for Box> +where + DIContainerType: IAsyncDIContainer, { fn clone(&self) -> Self { @@ -53,104 +59,127 @@ impl Clone for Box } } -pub struct AsyncTransientTypeProvider +pub struct AsyncTransientTypeProvider where - InjectableType: AsyncInjectable, + InjectableType: AsyncInjectable, + DIContainerType: IAsyncDIContainer, { injectable_phantom: PhantomData, + di_container_phantom: PhantomData, } -impl AsyncTransientTypeProvider +impl + AsyncTransientTypeProvider where - InjectableType: AsyncInjectable, + InjectableType: AsyncInjectable, + DIContainerType: IAsyncDIContainer, { pub fn new() -> Self { Self { injectable_phantom: PhantomData, + di_container_phantom: PhantomData, } } } #[async_trait] -impl IAsyncProvider for AsyncTransientTypeProvider +impl IAsyncProvider + for AsyncTransientTypeProvider where - InjectableType: AsyncInjectable, + InjectableType: AsyncInjectable, + DIContainerType: IAsyncDIContainer, { async fn provide( &self, - di_container: &Arc, + di_container: &Arc, dependency_history: Vec<&'static str>, - ) -> Result + ) -> Result, InjectableError> { Ok(AsyncProvidable::Transient( InjectableType::resolve(di_container, dependency_history).await?, )) } - fn do_clone(&self) -> Box + fn do_clone(&self) -> Box> { Box::new(self.clone()) } } -impl Clone for AsyncTransientTypeProvider +impl Clone + for AsyncTransientTypeProvider where - InjectableType: AsyncInjectable, + InjectableType: AsyncInjectable, + DIContainerType: IAsyncDIContainer, { fn clone(&self) -> Self { Self { injectable_phantom: self.injectable_phantom, + di_container_phantom: self.di_container_phantom, } } } -pub struct AsyncSingletonProvider +pub struct AsyncSingletonProvider where - InjectableType: AsyncInjectable, + InjectableType: AsyncInjectable, + DIContainerType: IAsyncDIContainer, { singleton: ThreadsafeSingletonPtr, + + di_container_phantom: PhantomData, } -impl AsyncSingletonProvider +impl + AsyncSingletonProvider where - InjectableType: AsyncInjectable, + InjectableType: AsyncInjectable, + DIContainerType: IAsyncDIContainer, { pub fn new(singleton: ThreadsafeSingletonPtr) -> Self { - Self { singleton } + Self { + singleton, + di_container_phantom: PhantomData, + } } } #[async_trait] -impl IAsyncProvider for AsyncSingletonProvider +impl IAsyncProvider + for AsyncSingletonProvider where - InjectableType: AsyncInjectable, + InjectableType: AsyncInjectable, + DIContainerType: IAsyncDIContainer, { async fn provide( &self, - _di_container: &Arc, + _di_container: &Arc, _dependency_history: Vec<&'static str>, - ) -> Result + ) -> Result, InjectableError> { Ok(AsyncProvidable::Singleton(self.singleton.clone())) } - fn do_clone(&self) -> Box + fn do_clone(&self) -> Box> { Box::new(self.clone()) } } -impl Clone for AsyncSingletonProvider +impl Clone + for AsyncSingletonProvider where - InjectableType: AsyncInjectable, + InjectableType: AsyncInjectable, + DIContainerType: IAsyncDIContainer, { fn clone(&self) -> Self { Self { singleton: self.singleton.clone(), + di_container_phantom: PhantomData, } } } @@ -188,13 +217,15 @@ impl AsyncFactoryProvider #[cfg(feature = "factory")] #[async_trait] -impl IAsyncProvider for AsyncFactoryProvider +impl IAsyncProvider for AsyncFactoryProvider +where + DIContainerType: IAsyncDIContainer, { async fn provide( &self, - _di_container: &Arc, + _di_container: &Arc, _dependency_history: Vec<&'static str>, - ) -> Result + ) -> Result, InjectableError> { Ok(match self.variant { AsyncFactoryVariant::Normal => AsyncProvidable::Factory(self.factory.clone()), @@ -207,7 +238,7 @@ impl IAsyncProvider for AsyncFactoryProvider }) } - fn do_clone(&self) -> Box + fn do_clone(&self) -> Box> { Box::new(self.clone()) } diff --git a/src/provider/blocking.rs b/src/provider/blocking.rs index 16e8847..b768b55 100644 --- a/src/provider/blocking.rs +++ b/src/provider/blocking.rs @@ -1,16 +1,18 @@ use std::marker::PhantomData; use std::rc::Rc; +use crate::di_container::blocking::IDIContainer; use crate::errors::injectable::InjectableError; use crate::interfaces::injectable::Injectable; use crate::ptr::{SingletonPtr, TransientPtr}; -use crate::DIContainer; #[derive(strum_macros::Display, Debug)] -pub enum Providable +pub enum Providable +where + DIContainerType: IDIContainer, { - Transient(TransientPtr), - Singleton(SingletonPtr), + Transient(TransientPtr>), + Singleton(SingletonPtr>), #[cfg(feature = "factory")] Factory(crate::ptr::FactoryPtr), #[cfg(feature = "factory")] @@ -19,43 +21,52 @@ pub enum Providable ), } -pub trait IProvider +pub trait IProvider +where + DIContainerType: IDIContainer, { fn provide( &self, - di_container: &Rc, + di_container: &Rc, dependency_history: Vec<&'static str>, - ) -> Result; + ) -> Result, InjectableError>; } -pub struct TransientTypeProvider +pub struct TransientTypeProvider where - InjectableType: Injectable, + InjectableType: Injectable, + DIContainerType: IDIContainer, { injectable_phantom: PhantomData, + di_container_phantom: PhantomData, } -impl TransientTypeProvider +impl + TransientTypeProvider where - InjectableType: Injectable, + InjectableType: Injectable, + DIContainerType: IDIContainer, { pub fn new() -> Self { Self { injectable_phantom: PhantomData, + di_container_phantom: PhantomData, } } } -impl IProvider for TransientTypeProvider +impl IProvider + for TransientTypeProvider where - InjectableType: Injectable, + InjectableType: Injectable, + DIContainerType: IDIContainer, { fn provide( &self, - di_container: &Rc, + di_container: &Rc, dependency_history: Vec<&'static str>, - ) -> Result + ) -> Result, InjectableError> { Ok(Providable::Transient(InjectableType::resolve( di_container, @@ -64,32 +75,40 @@ where } } -pub struct SingletonProvider +pub struct SingletonProvider where - InjectableType: Injectable, + InjectableType: Injectable, + DIContainerType: IDIContainer, { singleton: SingletonPtr, + di_container_phantom: PhantomData, } -impl SingletonProvider +impl SingletonProvider where - InjectableType: Injectable, + InjectableType: Injectable, + DIContainerType: IDIContainer, { pub fn new(singleton: SingletonPtr) -> Self { - Self { singleton } + Self { + singleton, + di_container_phantom: PhantomData, + } } } -impl IProvider for SingletonProvider +impl IProvider + for SingletonProvider where - InjectableType: Injectable, + InjectableType: Injectable, + DIContainerType: IDIContainer, { fn provide( &self, - _di_container: &Rc, + _di_container: &Rc, _dependency_history: Vec<&'static str>, - ) -> Result + ) -> Result, InjectableError> { Ok(Providable::Singleton(self.singleton.clone())) } @@ -118,13 +137,15 @@ impl FactoryProvider } #[cfg(feature = "factory")] -impl IProvider for FactoryProvider +impl IProvider for FactoryProvider +where + DIContainerType: IDIContainer, { fn provide( &self, - _di_container: &Rc, + _di_container: &Rc, _dependency_history: Vec<&'static str>, - ) -> Result + ) -> Result, InjectableError> { Ok(if self.is_default_factory { Providable::DefaultFactory(self.factory.clone()) diff --git a/src/test_utils.rs b/src/test_utils.rs index 1fc7015..650e338 100644 --- a/src/test_utils.rs +++ b/src/test_utils.rs @@ -7,9 +7,9 @@ pub mod subjects use syrette_macros::declare_interface; + use crate::di_container::blocking::IDIContainer; use crate::interfaces::injectable::Injectable; use crate::ptr::TransientPtr; - use crate::DIContainer; pub trait IUserManager { @@ -45,10 +45,12 @@ pub mod subjects declare_interface!(UserManager -> IUserManager); - impl Injectable for UserManager + impl Injectable for UserManager + where + DIContainerType: IDIContainer, { fn resolve( - _di_container: &Rc, + _di_container: &Rc, _dependency_history: Vec<&'static str>, ) -> Result, crate::errors::injectable::InjectableError> where @@ -109,10 +111,12 @@ pub mod subjects declare_interface!(Number -> INumber); - impl Injectable for Number + impl Injectable for Number + where + DIContainerType: IDIContainer, { fn resolve( - _di_container: &Rc, + _di_container: &Rc, _dependency_history: Vec<&'static str>, ) -> Result, crate::errors::injectable::InjectableError> where @@ -134,9 +138,9 @@ pub mod subjects_async use async_trait::async_trait; use syrette_macros::declare_interface; + use crate::di_container::asynchronous::IAsyncDIContainer; use crate::interfaces::async_injectable::AsyncInjectable; use crate::ptr::TransientPtr; - use crate::AsyncDIContainer; pub trait IUserManager: Send + Sync { @@ -173,10 +177,12 @@ pub mod subjects_async declare_interface!(UserManager -> IUserManager); #[async_trait] - impl AsyncInjectable for UserManager + impl AsyncInjectable for UserManager + where + DIContainerType: IAsyncDIContainer, { async fn resolve( - _: &Arc, + _: &Arc, _dependency_history: Vec<&'static str>, ) -> Result, crate::errors::injectable::InjectableError> where @@ -238,10 +244,12 @@ pub mod subjects_async declare_interface!(Number -> INumber, async = true); #[async_trait] - impl AsyncInjectable for Number + impl AsyncInjectable for Number + where + DIContainerType: IAsyncDIContainer, { async fn resolve( - _: &Arc, + _: &Arc, _dependency_history: Vec<&'static str>, ) -> Result, crate::errors::injectable::InjectableError> where @@ -251,3 +259,147 @@ pub mod subjects_async } } } + +pub mod mocks +{ + #![allow(clippy::ref_option_ref)] // Caused by Mockall + #![allow(dead_code)] // Not all mock functions may be used + + use mockall::mock; + + pub mod blocking_di_container + { + use std::rc::Rc; + + use super::*; + use crate::di_container::blocking::binding::builder::BindingBuilder; + use crate::di_container::blocking::details::DIContainerInternals; + use crate::di_container::blocking::IDIContainer; + use crate::errors::di_container::DIContainerError; + use crate::provider::blocking::IProvider; + use crate::ptr::SomePtr; + + mock! { + pub DIContainer {} + + impl IDIContainer for DIContainer { + fn bind(self: &mut Rc) -> BindingBuilder + where + Interface: 'static + ?Sized; + + fn get(self: &Rc) -> Result, DIContainerError> + where + Interface: 'static + ?Sized; + + fn get_named( + self: &Rc, + name: &'static str, + ) -> Result, DIContainerError> + where + Interface: 'static + ?Sized; + + #[doc(hidden)] + fn get_bound( + self: &Rc, + dependency_history: Vec<&'static str>, + name: Option<&'static str>, + ) -> Result, DIContainerError> + where + Interface: 'static + ?Sized; + } + + impl DIContainerInternals for DIContainer + { + fn has_binding(self: &Rc, name: Option<&'static str>) -> bool + where + Interface: ?Sized + 'static; + + #[doc(hidden)] + fn set_binding( + self: &Rc, + name: Option<&'static str>, + provider: Box>, + ) where + Interface: 'static + ?Sized; + + fn remove_binding( + self: &Rc, + name: Option<&'static str>, + ) -> Option>> + where + Interface: 'static + ?Sized; + } + } + } + + #[cfg(feature = "async")] + pub mod async_di_container + { + use std::sync::Arc; + + use super::*; + use crate::di_container::asynchronous::binding::builder::AsyncBindingBuilder; + use crate::di_container::asynchronous::details::DIContainerInternals; + use crate::di_container::asynchronous::IAsyncDIContainer; + use crate::errors::async_di_container::AsyncDIContainerError; + use crate::provider::r#async::IAsyncProvider; + use crate::ptr::SomeThreadsafePtr; + + mock! { + pub AsyncDIContainer {} + + #[async_trait::async_trait] + impl IAsyncDIContainer for AsyncDIContainer { + fn bind(self: &mut Arc) -> AsyncBindingBuilder + where + Interface: 'static + ?Sized + Send + Sync; + + async fn get( + self: &Arc, + ) -> Result, AsyncDIContainerError> + where + Interface: 'static + ?Sized + Send + Sync; + + async fn get_named( + self: &Arc, + name: &'static str, + ) -> Result, AsyncDIContainerError> + where + Interface: 'static + ?Sized + Send + Sync; + + #[doc(hidden)] + async fn get_bound( + self: &Arc, + dependency_history: Vec<&'static str>, + name: Option<&'static str>, + ) -> Result, AsyncDIContainerError> + where + Interface: 'static + ?Sized + Send + Sync; + } + + #[async_trait::async_trait] + impl DIContainerInternals for AsyncDIContainer { + async fn has_binding( + self: &Arc, + name: Option<&'static str>, + ) -> bool + where + Interface: ?Sized + 'static; + + async fn set_binding( + self: &Arc, + name: Option<&'static str>, + provider: Box>, + ) where + Interface: 'static + ?Sized; + + async fn remove_binding( + self: &Arc, + name: Option<&'static str>, + ) -> Option>> + where + Interface: 'static + ?Sized; + } + } + } +} -- cgit v1.2.3-18-g5258