Dependency injection in Ruby made by hands

1. 1/103

2. Me
Nikita Shilnikov
• github.com/flash-gordon
2/103

3. Me
Nikita Shilnikov
• github.com/flash-gordon
3/103

4. Me
Nikita Shilnikov
• github.com/flash-gordon
• dry-rb and rom-rb core team member
4/103

5. DI in Ruby
5/103

6. What, why, how
6/103

7. What?
7/103

8. Inversion of Control
8/103

9. Event-based programming
(JavaScript)
9/103

10. Dependency Injection
10/103

11. class CreateUser
def call(name)
user_repo.create(name: name)
end
end
11/103

12. class CreateUser
def call(name)
user_repo.create(name: name)
end
end
12/103

13. undefined local variable or method user_repo
13/103

14. undefined local variable or method user_repo
14/103

15. Local variable
def call(user_repo, name)
user_repo.create(name: name)
end
15/103

16. Method
def user_repo
# dependency resolution
end
def call(name)
user_repo.create(name: name)
end
16/103

17. Constant (or singleton)
def user_repo
UserRepo.new
end
17/103

18. Constant
Pros:
• Dumb simple
• Easy to follow
• You don't need a method
Cons:
• High coupling
• Hard to test (?)
• Less extendable
18/103

19. Method
attr_accessor :user_repo
def initialize(user_repo)
@user_repo = user_repo
end
19/103

20. Method
let(:fake_repo) { FakeRepo.new }
let(:create_user) { CreateUser.new(fake_repo) }
example do
create_user.(name: 'Jade')
end
20/103

21. Why?
21/103

22. 22/103

23. S O L I D
23/103

24. Dependency
Inversion Principle
24/103

25. Dependency Inversion Principle
A. High-level modules should not depend on low-level
modules. Both should depend on abstractions.
B. Abstractions should not depend on details. Details should
depend on abstractions.
25/103

26. 26/103

27. Think about
interfaces
27/103

28. Think about interfaces
• External services (network)
• Message queues
• Background jobs
28/103

29. Harder to write, easier to use and
support
29/103

30. Not harder in Ruby
30/103

31. How?
31/103

32. class CreateUser
attr_reader :user_repo
def initialize(user_repo)
@user_repo = user_repo
end
end
32/103

33. Container
Container = { user_repo: UserRepo.new }
def initialize(user_repo = nil)
@user_repo = user_repo || Container[:user_repo]
end
33/103

34. create_user = CreateUser.new(UserRepo.new)
34/103

35. create_user = CreateUser.new(UserRepo.new)
create_user = CreateUser.new
35/103

36. create_user = CreateUser.new(UserRepo.new)
create_user = CreateUser.new
create_user = CreateUser.new(FakeRepo.new)
36/103

37. create_user = CreateUser.new(UserRepo.new)
create_user = CreateUser.new
create_user = CreateUser.new(FakeRepo.new)
before { Container[:user_repo] = FakeRepo.new }
let(:create_user) { CreateUser.new }
example { create_user.(name: 'Jade') }
37/103

38. Loading order problem
38/103

39. Loading order
Container = {
user_repo: UserRepo.new,
create_user: CreateUser.new(?)
}
39/103

40. Loading order
Conainter = {
user_repo: -> { UserRepo.new },
create_user: -> { CreateUser.new }
}
40/103

41. Loading order
Conainter = {
user_repo: -> { UserRepo.new },
create_user: -> { CreateUser.new }
}
user = Container[:create_user].call.call(name: 'Jade')
41/103

42. dry-container
42/103

43. dry-container
Container = Dry::Container.new
Container.register(:user_repo) { UserRepo.new }
Container.register(:create_user) { CreateUser.new }
43/103

44. dry-container
Container[:create_user]
44/103

45. dry-container
Container[:create_user]
CreateUser.new
45/103

46. dry-container
Container[:create_user]
CreateUser.new
Container[:user_repo]
UserRepo.new
46/103

47. dry-container
Container[:create_user]
CreateUser.new
Container[:user_repo]
UserRepo.new
47/103

48. dry-container
Dir['repositories/*.rb'].each do |path|
key = path.sub('repositories/', '').sub('.rb', '')
class_name = Inflecto.camelize(key)
Container.register(key) do
require path
Inflecto.contantize(class_name).new
end
end
48/103

49. dry-container
Dir['repositories/*.rb'].each do |path|
key = path.sub('repositories/', '').sub('.rb', '')
class_name = Inflecto.camelize(key)
Container.register(key) do
require path
Inflecto.contantize(class_name).new
end
end
49/103

50. dry-container
Dir['repositories/*.rb'].each do |path|
key = path.sub('repositories/', '').sub('.rb', '')
class_name = Inflecto.camelize(key)
Container.register(key) do
require path
Inflecto.contantize(class_name).new
end
end
50/103

51. dry-container
Container.enable_stubs!
around do |ex|
Container.stub(:user_repo, FakeRepo.new) { ex.run }
end
51/103

52. dry-container
Container.register('user_repo', memoize: true) {
UserRepo.new
}
52/103

53. class CreateUser
attr_reader :user_repo, :user_created_worker
def initialize(user_repo: Container[:user_repo], user_created_worker: Container[:user_created_worker])
@user_repo = user_repo
@user_created_worker = user_created_worker
end
end
53/103

54. Boilerplate!
54/103

55. dry-auto_inject
55/103

56. • Needs a container
• Creates a constructor
56/103

57. dry-auto_inject
Import = Dry::AutoInject(Container)
57/103

58. dry-auto_inject
class CreateUserWithAccount
include Import['repo.user_repo', 'workers.user_created']
def call(name)
user = user_repo.create(name: name)
user_created.(user.user_id)
user
end
end
58/103

59. dry-auto_inject
class CreateUserWithAccount
include Import['repo.user_repo', 'workers.user_created']
def call(name)
user = user_repo.create(name: name)
user_created.(user.user_id)
user
end
end
59/103

60. dry-auto_inject
Plays nice with inheritance
60/103

61. dry-auto_inject
Compatible with existing constructors
61/103

62. dry-auto_inject
class CreateUserFromParams
attr_reader :params
def initialize(params)
@param = params
end
def create
UserRepo.new.create(params)
end
end
62/103

63. dry-auto_inject
class CreateUserFromParams
include Import['user_repo']
attr_reader :params
def initialize(params, **other)
super(other)
@param = params
end
end
63/103

64. Cost
• One line with explicitly defined dependencies
64/103

65. Benefits
• You don't need to think about building objects
• All code is built on the same principles
• It's far easier to write testable code
• You, most likely, will write functional-ish code
• Speeds up tests in a natural way
65/103

66. What if?
66/103

67. dry-system
67/103

68. dry-system
Container + injector + loading mechanism
68/103

69. dry-system
• Extends $LOAD_PATH
• Uses require to load files
• Registers dependencies automatically
• Builds dependencies using name conventions
• Can split an application into sub-apps
69/103

70. dry-system
class Application < Dry::System::Container
configure do |config|
config.root = Pathname('./app')
end
end
70/103

71. dry-system
class Application < Dry::System::Container
configure do |config|
config.root = Pathname('./app')
config.auto_register = 'lib'
end
load_paths!('lib')
end
71/103

72. dry-system
Application.register('utils.logger', Logger.new($stdout))
Application.finalize!
Application['utils.logger']
72/103

73. dry-system
Import = Application.injector
class CreateUser
include Import['repos.user_repo', 'utils.logger']
def call(name)
# ...
end
end
73/103

74. Stateful components
Application.finalize(:persistence) do |container|
start do
require 'sequel'
conn = Sequel.connect(ENV['DB_URL'])
container.register('persistence.db', conn)
end
stop do
db.disconnect
end
end
74/103

75. Stateful components
before(:all) do
Application.start(:persistence)
end
75/103

76. dry-system
• May not play nice with Rails (but who knows)
• Good for new projects
76/103

77. Future
• Instrumenting code
• Debugging tools
77/103

78. Application graph
78/103

79. Application graph
79/103

80. Application graph
• web.services.create_user [640ms]
• user_repo.create [10ms]
• web.view.user_created [215ms]
• external.billing.create_user [278ms]
80/103

81. Bonus
81/103

82. Singleton container
Import = Dry::AutoInject(Container)
class CreateUser
include Import['repo.user_repo']
end
82/103

83. Sharing the context
logger = TaggedLogger.new(env['X-Request-ID'])
83/103

84. Sharing the context
Application.finalize!
logger = TaggedLogger.new(env['X-Request-ID'])
Application.register('logger', logger) # => Error
84/103

85. Sharing the context
Application.register_abstract('logger')
Application.finalize!
85/103

86. Sharing the context
Application.register_abstract('logger')
Application.finalize!
logger = TaggedLogger.new(env['X-Request-ID'])
AppWithLogger = Application.provide(logger: logger)
86/103

87. Sharing the context
AppWithLogger[:create_user] # => #<CreateUser logger=#<Logger>>
87/103

88. Sharing the context
Import = Dry::AutoInject(Application)
class CreateUser
include Import['logger']
end
88/103

89. Passing the container as a dependency
Container.register('create_user') {
CreateUser.new
}
89/103

90. Passing the container as a dependency
Container.register('create_user') { |app_with_logger|
CreateUser.new(container: app_with_logger)
}
90/103

91. Zero global state
(literally)
91/103

92. 92/103

93. Cons:
• Can't be memoized
• Can violate boundaries
93/103

94. Cons:
• Can't be memoized
• Can violate boundaries
Pros:
94/103

95. Cons:
• Can't be memoized
• Can violate boundaries
Pros:
• Reduces code duplcation
95/103

96. Cons:
• Can't be memoized
• Can violate boundaries
Pros:
• Reduces code duplcation
• Simplifies context sharing
96/103

97. Cons:
• Can't be memoized
• Can violate boundaries
Pros:
• Reduces code duplcation (no need to pass arguments)
• Simplifies context sharing
• Kills global state
97/103

98. Recap
98/103

99. Recap
• DI is a way to implement the dependency inversion
principle
• This makes your code easier to test and write
• Can break an application into sub-apps
• Can remove the global state as a whole (100% FP)
• Can be done in Ruby in one evening
• Doesn't have any major disadvantages *
99/103

100. DI 101
• Replace hard dependencies with interfaces (plain Ruby)
• Put dependencies into a container (dry-container)
• Inject dependencies automatically (dry-auto_inject)
• Organize application code in modules (dry-system)
100/103

101. Caveats
• Don't put every single thing into a container
• Make dependencies pure (aka thread-safe)
• Keep interfaces simple
• Injecting a dozen of deps at once is bad, m'kay?
• Fear new abstractions
101/103

102. Try it!
102/103

103. Thank you
• github.com/flash-gordon
• dry-rb.org
• dry-rb/dry-container
• dry-rb/dry-auto_inject
• dry-rb/dry-system
• dry-rb/dry-web-blog
103/103