From c1e682c25c24be3174d44ceb95b0537c38299d0c Mon Sep 17 00:00:00 2001 From: HampusM Date: Mon, 12 Sep 2022 20:22:13 +0200 Subject: feat!: allow factories access to DI container BREAKING CHANGE: Factory types should now be written with the Fn trait instead of the IFactory trait and the to_factory & to_default_factory methods of BindingBuilder now expect a function returning a factory function --- src/di_container.rs | 173 +++++++++++++++++++++++++++++++---------------- src/provider/blocking.rs | 17 ++++- 2 files changed, 128 insertions(+), 62 deletions(-) (limited to 'src') diff --git a/src/di_container.rs b/src/di_container.rs index ddd3a4f..532a905 100644 --- a/src/di_container.rs +++ b/src/di_container.rs @@ -249,27 +249,36 @@ where #[cfg(feature = "factory")] pub fn to_factory( &self, - factory_func: &'static dyn Fn>, + factory_func: &'static dyn Fn< + (std::rc::Rc,), + Output = Box>>, + >, ) -> Result, BindingBuilderError> where Args: 'static, Return: 'static + ?Sized, - Interface: crate::interfaces::factory::IFactory, + Interface: Fn>, { - let mut bindings_mut = self.di_container.bindings.borrow_mut(); + { + let bindings = self.di_container.bindings.borrow(); - if bindings_mut.has::(None) { - return Err(BindingBuilderError::BindingAlreadyExists(type_name::< - Interface, - >())); + if bindings.has::(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::( None, Box::new(crate::provider::blocking::FactoryProvider::new( crate::ptr::FactoryPtr::new(factory_impl), + false, )), ); @@ -287,25 +296,34 @@ where #[cfg(feature = "factory")] pub fn to_default_factory( &self, - factory_func: &'static dyn Fn<(), Output = crate::ptr::TransientPtr>, + factory_func: &'static dyn Fn< + (Rc,), + Output = crate::ptr::TransientPtr, + >, ) -> Result, BindingBuilderError> where Return: 'static + ?Sized, { - let mut bindings_mut = self.di_container.bindings.borrow_mut(); + { + let bindings = self.di_container.bindings.borrow(); - if bindings_mut.has::(None) { - return Err(BindingBuilderError::BindingAlreadyExists(type_name::< - Interface, - >())); + if bindings.has::(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::( None, Box::new(crate::provider::blocking::FactoryProvider::new( crate::ptr::FactoryPtr::new(factory_impl), + true, )), ); @@ -381,10 +399,11 @@ impl DIContainer let binding_providable = self.get_binding_providable::(name, dependency_history)?; - Self::handle_binding_providable(binding_providable) + self.handle_binding_providable(binding_providable) } fn handle_binding_providable( + self: &Rc, binding_providable: Providable, ) -> Result, DIContainerError> where @@ -409,21 +428,29 @@ impl DIContainer )), #[cfg(feature = "factory")] Providable::Factory(factory_binding) => { - match factory_binding.clone().cast::() { - Ok(factory) => Ok(SomePtr::Factory(factory)), - Err(_err) => { - use crate::interfaces::factory::IFactory; - - let default_factory = factory_binding - .cast::>() - .map_err(|_| DIContainerError::CastFailed { - interface: type_name::(), - binding_kind: "factory", - })?; - - Ok(SomePtr::Transient(default_factory())) - } - } + use crate::interfaces::factory::IFactory; + + let factory = factory_binding + .cast::,), Interface>>() + .map_err(|_| DIContainerError::CastFailed { + interface: type_name::(), + binding_kind: "factory", + })?; + + Ok(SomePtr::Factory(factory(self.clone()).into())) + } + #[cfg(feature = "factory")] + Providable::DefaultFactory(factory_binding) => { + use crate::interfaces::factory::IFactory; + + let default_factory = factory_binding + .cast::,), Interface>>() + .map_err(|_| DIContainerError::CastFailed { + interface: type_name::(), + binding_kind: "default factory", + })?; + + Ok(SomePtr::Transient(default_factory(self.clone()))) } } } @@ -690,12 +717,16 @@ mod tests assert_eq!(di_container.bindings.borrow().count(), 0); - di_container.bind::().to_factory(&|| { - let user_manager: TransientPtr = - TransientPtr::new(subjects::UserManager::new()); + di_container + .bind::() + .to_factory(&|_| { + Box::new(move || { + let user_manager: TransientPtr = + TransientPtr::new(subjects::UserManager::new()); - user_manager - })?; + user_manager + }) + })?; assert_eq!(di_container.bindings.borrow().count(), 1); @@ -715,11 +746,13 @@ mod tests di_container .bind::() - .to_factory(&|| { - let user_manager: TransientPtr = - TransientPtr::new(subjects::UserManager::new()); + .to_factory(&|_| { + Box::new(move || { + let user_manager: TransientPtr = + TransientPtr::new(subjects::UserManager::new()); - user_manager + user_manager + }) })? .when_named("awesome")?; @@ -901,6 +934,8 @@ mod tests #[cfg(feature = "factory")] fn can_get_factory() -> Result<(), Box> { + use crate::ptr::FactoryPtr; + trait IUserManager { fn add_user(&mut self, user_id: i128); @@ -940,8 +975,7 @@ mod tests use crate as syrette; #[crate::factory] - type IUserManagerFactory = - dyn crate::interfaces::factory::IFactory<(Vec,), dyn IUserManager>; + type IUserManagerFactory = dyn Fn(Vec) -> TransientPtr; mock! { Provider {} @@ -958,17 +992,26 @@ mod tests let di_container = DIContainer::new(); - let mut mock_provider = MockProvider::new(); + let factory_func: &'static dyn Fn< + (std::rc::Rc,), + Output = Box< + dyn Fn<(Vec,), Output = crate::ptr::TransientPtr>, + >, + > = &|_: Rc| { + Box::new(move |users| { + let user_manager: TransientPtr = + TransientPtr::new(UserManager::new(users)); - mock_provider.expect_provide().returning(|_, _| { - Ok(Providable::Factory(crate::ptr::FactoryPtr::new( - CastableFactory::new(&|users| { - let user_manager: TransientPtr = - TransientPtr::new(UserManager::new(users)); + user_manager + }) + }; - user_manager - }), - ))) + let mut mock_provider = MockProvider::new(); + + mock_provider.expect_provide().returning_st(|_, _| { + Ok(Providable::Factory(FactoryPtr::new(CastableFactory::new( + factory_func, + )))) }); di_container @@ -985,6 +1028,8 @@ mod tests #[cfg(feature = "factory")] fn can_get_factory_named() -> Result<(), Box> { + use crate::ptr::FactoryPtr; + trait IUserManager { fn add_user(&mut self, user_id: i128); @@ -1024,8 +1069,7 @@ mod tests use crate as syrette; #[crate::factory] - type IUserManagerFactory = - dyn crate::interfaces::factory::IFactory<(Vec,), dyn IUserManager>; + type IUserManagerFactory = dyn Fn(Vec) -> TransientPtr; mock! { Provider {} @@ -1042,17 +1086,26 @@ mod tests let di_container = DIContainer::new(); - let mut mock_provider = MockProvider::new(); + let factory_func: &'static dyn Fn< + (std::rc::Rc,), + Output = Box< + dyn Fn<(Vec,), Output = crate::ptr::TransientPtr>, + >, + > = &|_: Rc| { + Box::new(move |users| { + let user_manager: TransientPtr = + TransientPtr::new(UserManager::new(users)); - mock_provider.expect_provide().returning(|_, _| { - Ok(Providable::Factory(crate::ptr::FactoryPtr::new( - CastableFactory::new(&|users| { - let user_manager: TransientPtr = - TransientPtr::new(UserManager::new(users)); + user_manager + }) + }; - user_manager - }), - ))) + let mut mock_provider = MockProvider::new(); + + mock_provider.expect_provide().returning_st(|_, _| { + Ok(Providable::Factory(FactoryPtr::new(CastableFactory::new( + factory_func, + )))) }); di_container diff --git a/src/provider/blocking.rs b/src/provider/blocking.rs index 69bbe78..e00786b 100644 --- a/src/provider/blocking.rs +++ b/src/provider/blocking.rs @@ -14,6 +14,10 @@ pub enum Providable Singleton(SingletonPtr), #[cfg(feature = "factory")] Factory(crate::ptr::FactoryPtr), + #[cfg(feature = "factory")] + DefaultFactory( + crate::ptr::FactoryPtr, + ), } pub trait IProvider @@ -96,6 +100,7 @@ where pub struct FactoryProvider { factory: crate::ptr::FactoryPtr, + is_default_factory: bool, } #[cfg(feature = "factory")] @@ -103,9 +108,13 @@ impl FactoryProvider { pub fn new( factory: crate::ptr::FactoryPtr, + is_default_factory: bool, ) -> Self { - Self { factory } + Self { + factory, + is_default_factory, + } } } @@ -118,6 +127,10 @@ impl IProvider for FactoryProvider _dependency_history: Vec<&'static str>, ) -> Result { - Ok(Providable::Factory(self.factory.clone())) + Ok(if self.is_default_factory { + Providable::DefaultFactory(self.factory.clone()) + } else { + Providable::Factory(self.factory.clone()) + }) } } -- cgit v1.2.3-18-g5258