Maintaining a dependency graph with weaver

MAINTAINING A DEPENDENCY GRAPH WITHMAINTAINING A DEPENDENCY GRAPH WITH
WEAVERWEAVER

THÉOPHANE RUPINTHÉOPHANE RUPIN
@thrupin

DI ContainerDI Container
An object able to instantiate, retain, and resolve other
objects’ dependencies.

Dependency GraphDependency Graph

final class Foo {
let bar: Bar
init(bar: Bar) {
self.bar = bar
bar.foo = self
}
func barDidSomething() { ... }
}
final class Bar {
weak var foo: Foo?
func doSomething() { foo?.barDidSomething() }
}

Weaver is a code generation tool which makes it easy
to inject dependencies.
https://github.com/scribd/Weaver

WHY?WHY?
I could not nd any satisfying compile time DI solution,
so I gave it a try.

ADVANTAGESADVANTAGES
1. Mimics manual DI technics. No black box.

2. Compile time errors. Fails fast.

3. Type safety. If it compiles, it works!

4. Declarativeness.

4. Declarativeness.
5. No optionality. If it's declared, it's there.

4. Declarativeness.
6. Thread safety. Immutability. No lazy loading.

4. Declarativeness.
6. Thread safety. Immutability. No lazy loading.
7. No additional framework to ship.

DRAWBACKSDRAWBACKS
1. More code to compile. Can be optimized.

DRAWBACKSDRAWBACKS
2. Meta-programmation is hard.

DRAWBACKSDRAWBACKS
3. Use of pseudo annotations.

DRAWBACKSDRAWBACKS
3. Use of pseudo annotations.
4. Experimental.

LET'S SEE IN PRACTICELET'S SEE IN PRACTICE

HOW COULD WE PROVIDEHOW COULD WE PROVIDE URLSessionURLSession??

Sharing an instance of URLSession
@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {
}

@UIApplicationMain
static var shared: AppDelegate? {
return UIApplication.shared.delegate as? AppDelegate
}
}

@UIApplicationMain
static var shared: AppDelegate? {
return UIApplication.shared.delegate as? AppDelegate
}
let urlSession: URLSession = {
let config = ...
return URLSession(configuration: config)
}()
}

Using the shared instance of URLSession
final class APIClient {
func get(_ url: URL, completion: @escaping (Data?) -> Void) ->
}
}

Using the shared instance of URLSession
AppDelegate.shared.urlSession.dataTask(with: url) {
...
}.resume()
}
}

Injecting a shared instance of URLSession in
APIClient
}
}

APIClient
private let urlSession: URLSession
}
}

APIClient
init(urlSession: URLSession = AppDelegate.shared.urlSession)
self.urlSession = urlSession
}
}
}

APIClient
init(urlSession: URLSession = AppDelegate.shared.urlSession)
}
urlSession.dataTask(with: url) { ... }.resume()
}
}

Using APIClient in MovieManager
final class MovieManager {
func getMovies(_ completion: @escaping ([Movie]?) -> Void) {
}
}

APIClient().get("http://my_movie_api/movies") { ... }
}
}

APIClient().get("http://my_movie_api/movies") { ... }
// ^ No URLSession to pass in.
}
}

Passing down an instance of URLSession in
APIClient
init(_ urlSession: URLSession) {
}
}
}

Passing down an instance of URLSession in
APIClient
init(_ urlSession: URLSession) { // <- No default anymore
}
}
}

From MovieManager to APIClient
}
}

private let apiClient: APIClient
}
}

init(urlSession: URLSession) {
apiClient = APIClient(urlSession)
}
}
}

init(urlSession: URLSession) {
}
apiClient.get("http://my_movie_api/movies") { ... }
}
}

From HomeViewController to MovieManager
final class HomeViewController {
override func viewDidLoad() {
super.viewDidLoad()
}
}

private let movieManager: MovieManager
super.viewDidLoad()
}
}

movieManager = MovieManager(urlSession: urlSession)
}
super.viewDidLoad()
}
}

movieManager = MovieManager(urlSession: urlSession)
}
super.viewDidLoad()
movieManager.getMovies { ... }
}
}

From AppDelegate to HomeViewController
@UIApplicationMain
func applicationDidFinishLaunching(_ application: UIApplicati
}
}

@UIApplicationMain
let configuration = ...
let urlSession = URLSession(configuration: configuration)
}
}

@UIApplicationMain
let controller = HomeViewController(urlSession)
...
}
}

WHY IS THIS BETTER?WHY IS THIS BETTER?

WHY IS THIS BETTER?WHY IS THIS BETTER?
MODULARITYMODULARITY

What if ImageManager needs a bigger HTTP cache?
final class ImageManager {
}

init() {
}
}

init() {
config.urlCache?.diskCapacity = 1024 * 1024 * 50
config.urlCache?.memoryCapacity = 1024 * 1024 * 5
}
}

init() {
}
}

init() {
}
func getImage(_ image: String, completion: @escaping (UIImage
apiClient.get("http://my_movie_api/images/(image)") { ..
}
}

Great! But this is too much code to write...

In a real project, we'd have to pass down dozens of
dependencies
@UIApplicationMain
let controller = HomeViewController(
)
}
}

dependencies
@UIApplicationMain
sessionManager: sessionManager,
)
}
}

dependencies
@UIApplicationMain
analyticsManager: analyticsManager,
)
}
}

dependencies
@UIApplicationMain
reachabilityManager: reachabilityManager,
)
}
}

dependencies
@UIApplicationMain
logger: logger,
)
}
}

dependencies
@UIApplicationMain
logger: logger,
...
)
}
}

dependencies
Ouch!
@UIApplicationMain
logger: logger,
...
)
}
}

THAT'S WHERE WEAVER COMES HANDY.THAT'S WHERE WEAVER COMES HANDY.

WHAT METHODOLOGY HAVE WE USED SO FAR?WHAT METHODOLOGY HAVE WE USED SO FAR?

1. Looked at the code.

2. Built a representation of the dependency graph.

3. Made sure the dependency graph was ok.

3. Made sure the dependency graph was ok.
4. Used a DI technique to implement the graph.

WEAVER DOES THE SAMEWEAVER DOES THE SAME

WEAVER DOES THE SAMEWEAVER DOES THE SAME BUT AUTOMATICALLYBUT AUTOMATICALLY

1. Scans the code, looking for annotations.

2. Builds a representation of the dependency graph.

3. Validates the dependency graph.

3. Validates the dependency graph.
4. Generates the code to implement the graph.

BACK TO OUR EXAMPLEBACK TO OUR EXAMPLE

Referencing to URLSession in APIClient

}
}

private let dependencies: APIClientDependencyResolver
init(injecting dependencies: APIClientDependencyResolver) {
self.dependencies = dependencies
}
}
}

// weaver: urlSession <- URLSession
}
}
}

// weaver: urlSession <- URLSession
}
dependencies.urlSession.dataTask(with: url) { ... }.resum
}
}

GENERATED CODEGENERATED CODE

protocol APIClientInputDependencyResolver {
var urlSession: URLSession { get }
}

}
protocol APIClientDependencyResolver {
}

}
protocol APIClientDependencyResolver {
}
final class APIClientDependencyContainer: APIClientDependencyReso
let urlSession: URLSession
init(injecting dependencies: APIClientInputDependencyResolver
urlSession = dependencies.urlSession
}
}

Registering APIClient in MovieManager
}
}

private let dependencies: MovieManagerDependencyResolver
init(injecting dependencies: MovieManagerDependencyResolver)
}
}
}

// weaver: apiClient = APIClient
}
}
}

// weaver: apiClient = APIClient
}
dependencies.apiClient.get("http://my_movie_api/movies")
}
}

protocol MovieManagerInputDependencyResolver {
}

}
protocol MovieManagerDependencyResolver {
var apiClient: APIClient { get }
}

}
}
final class MovieManagerDependencyContainer: MovieManagerDependencyResolv
var apiClient: APIClient {
let dependencies = APIClientDependencyContainer(injecting: self)
return APIClient(injecting: dependencies)
}
init(injecting dependencies: MovieManagerInputDependencyResolver) {
}
}

}
}
final class MovieManagerDependencyContainer: MovieManagerDependencyResolv
}
init(injecting dependencies: MovieManagerInputDependencyResolver) {
}
}
extension MovieManagerDependencyContainer: APIClientInputDependencyResolv

Registering MovieManager in
HomeViewController
super.viewDidLoad()
}
}

HomeViewController
private let dependencies: HomeViewControllerDependencyResolve
init(injecting dependencies: HomeViewControllerDependencyReso
}
super.viewDidLoad()
}
}

HomeViewController
// weaver: movieManager = MovieManager
}
super.viewDidLoad()
}
}

HomeViewController
// weaver: movieManager = MovieManager
}
super.viewDidLoad()
dependencies.movieManager.getMovies { ... }
}
}

HomeViewController

HomeViewController
protocol HomeViewControllerInputDependencyResolver {
}

HomeViewController
}
protocol HomeViewControllerDependencyResolver {
var movieManager: MovieManager { get }
}

HomeViewController
}
}
final class HomeViewControllerDependencyContainer: HomeViewControllerDepe
var movieManager: MovieManager {
let dependencies = MovieManagerDependencyContainer(injecting: sel
return MovieManager(injecting: dependencies)
}
init(injecting dependencies: HomeViewControllerInputDependencyResolve
}
}

HomeViewController
}
}
final class HomeViewControllerDependencyContainer: HomeViewControllerDepe
var movieManager: MovieManager {
let dependencies = MovieManagerDependencyContainer(injecting: sel
return MovieManager(injecting: dependencies)
}
init(injecting dependencies: HomeViewControllerInputDependencyResolve
}
}
extension HomeViewControllerDependencyContainer: MovieManagerInputDepende

COMPILING...COMPILING...
Oops!
URLSession cannot be resolved

Registering URLSession in AppDelegate
@UIApplicationMain
}

@UIApplicationMain
private let dependencies = AppDelegateDependencyContainer()
}

@UIApplicationMain
// weaver: urlSession = URLSession
}

@UIApplicationMain
// weaver: urlSession.scope = .container
}

@UIApplicationMain
// weaver: urlSession.builder = AppDelegate.makeURLSession
}

@UIApplicationMain
static func makeURLSession(_: AppDelegateDependencyResolver)
return URLSession(configuration: configuration)
}
}

@UIApplicationMain
static func makeURLSession(_: AppDelegateDependencyResolver)
}
// weaver: homeViewController = HomeViewController
}

protocol AppDelegateDependencyResolver {
var homeViewController: HomeViewController { get }
}

}
final class AppDelegateDependencyContainer: AppDelegateDependencyResolver
var homeViewController: HomeViewController {
let dependencies = HomeViewControllerDependencyContainer(injectin
return HomeViewController(injecting: dependencies)
}
init() {
urlSession = URLSession.makeURLSession(self)
}
}

}
final class AppDelegateDependencyContainer: AppDelegateDependencyResolver
var homeViewController: HomeViewController {
let dependencies = HomeViewControllerDependencyContainer(injectin
return HomeViewController(injecting: dependencies)
}
init() {
}
}
extension AppDelegateDependencyContainer: HomeViewControllerInputDependen

STILL MODULAR?STILL MODULAR?
YESYES

Registering URLSession with a bigger HTTP cache in
ImageManager
}

ImageManager
private let dependencies: ImageManagerDependencyResolver
init(injecting dependencies: ImageManagerDependencyResolver) { self.d
}

ImageManager
// weaver: urlSession.builder = ImageManager.makeURLSession
}

ImageManager
// weaver: urlSession.builder = ImageManager.makeURLSession
static func makeURLSession(_: ImageManagerDependencyResolver) -> URLS
configuration.urlCache?.diskCapacity = 1024 * 1024 * 50
configuration.urlCache?.memoryCapacity = 1024 * 1024 * 5
}
}

Registering URLSession in ImageManager

protocol ImageManagerDependencyResolver {
}

}
final class ImageManagerDependencyContainer: ImageManagerDependencyResolv
}
init() {
}
}

}
final class ImageManagerDependencyContainer: ImageManagerDependencyResolv
}
init() {
}
}
extension ImageManagerDependencyContainer: APIClientInputDependencyResolv

ROOM FOR IMPROVEMENTROOM FOR IMPROVEMENT

Adopt Weaver more widely at Scribd.

Dependency graph visualizer.

Dependency graph optimizations.

Detect retain cycles.

Detect suspicious graph shapes.

Detect suspicious graph shapes.
...

Maintaining a dependency graph with weaver

More Related Content

What's hot

Similar to Maintaining a dependency graph with weaver

Recently uploaded

Maintaining a dependency graph with weaver