hypospray 0.1.2

Lightweight dependency injection library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

#![allow(warnings)]
#![feature(plugin)]
#![plugin(hypospray_extensions)]

extern crate hypospray;

mod simple {
	use hypospray::{Construct, Graph};

	trait Foo { fn foo(&self) -> u8; }

	#[implements(Foo)]
	struct Bar;
	impl Foo for Bar { fn foo(&self) -> u8 { 10 } }
	impl<'d> Construct<'d> for Bar { type Dep = (); fn __construct(_: ()) -> Bar { Bar } }

	#[bind(Foo = "Bar#Prototype")]
	pub trait Module { }

	#[test]
	fn test() {
		let m = Graph::<Module>::new();
		let bar = m.construct::<Bar>();

		assert_eq!(bar.foo(), 10);
	}
}

mod inject {
	use hypospray::{Co, Construct, Graph};
	
	trait Foo { fn foo(&self) -> u8; }

	#[implements(Foo)]
	struct Bar;
	impl Foo for Bar { fn foo(&self) -> u8 { 12 } }
	impl<'d> Construct<'d> for Bar { type Dep = (); fn __construct(_: ()) -> Bar { Bar } }

	#[inject(Foo)]
	trait QuxDeps { }

	struct Qux<M: ?Sized + QuxDeps> { pub foo: Co<M, Foo> }

	impl<'dep, M> Construct<'dep> for Qux<M> where M: ?Sized + QuxDeps {
    
	    type Dep = Co<M, Foo>;
	    
	    fn __construct(foo: Self::Dep) -> Qux<M> {
	        Qux {
	        	foo: foo,
	        }
	    }
	}

	#[bind(Foo = "Bar#Prototype")]
	pub trait Module { }

	#[test]
	fn test() {
		let m = Graph::<Module>::new();
		let qux = m.construct::<Qux<_>>();

		assert_eq!(qux.foo.foo(), 12);
	}
}

mod reference_singleton {
	use hypospray::{Co, Construct, Graph};
	
	trait Foo { fn foo(&self) -> u8; }

	#[implements(Foo)]
	struct Bar;
	impl Foo for Bar { fn foo(&self) -> u8 { 14 } }
	impl<'d> Construct<'d> for Bar { type Dep = (); fn __construct(_: ()) -> Bar { Bar } }

	#[inject(Foo)]
	trait QuxDeps { }

	struct Qux<'a, M: ?Sized + QuxDeps> { pub foo: &'a Co<M, Foo> }

	impl<'dep, M> Construct<'dep> for Qux<'dep, M> where M: ?Sized + QuxDeps {
    
	    type Dep = &'dep Co<M, Foo>;
	    
	    fn __construct(foo: Self::Dep) -> Qux<M> {
	        Qux {
	        	foo: foo,
	        }
	    }
	}

	#[bind(Foo = "Bar#Singleton")]
	pub trait Module { }

	#[test]
	fn test() {
		let m = Graph::<Module>::new();
		let qux = m.construct::<Qux<_>>();

		assert_eq!(qux.foo.foo(), 14);
	}
}