This document discusses dependency injection in Ruby. Dependency injection is when one part of code uses or relies on another part. In Ruby, common ways to implement dependency injection include using the constructor/initialize method and passing parameters, including modules, and inheritance. While these provide dependency injection, they can also introduce disadvantages like tight coupling, unexpected behavior from included modules, and rigid inheritance hierarchies. Dependency injection frameworks provide an alternative approach but may not be needed for many Ruby applications. The key benefits of dependency injection are improved testability, loose coupling between classes, and more extensible code.

1. Dependency injection
in ruby
@huydx

2. what is
depedency injection
(DI)

3. dependency:
a part of your code "use"
another part
dependency injection:
how you inject a part of your
code in another part

4. Some examples

5. example
class Train
attr_accessor :food_service, :drink_service
def initialize(food_service, drink_service)
@food_service = food_service
@drink_service = drink_service
end
def serve(customer = Customer.new)
customer.eat(food_service.make_food)
customer.drink(drink_service.make_drink)
customer.sleep
end
end

6. example
class Train
attr_accessor :food_service, :drink_service
def initialize(food_service, drink_service)
@food_service = food_service
@drink_service = drink_service
end
def serve(customer = Customer.new)
customer.eat(food_service.make_food)
customer.drink(drink_service.make_drink)
customer.sleep
end
end
Train depends on
food service and
drink service
Train depends
on customer

7. You already use it
everyday!

8. Some "ruby" ways:
- constructor (initialize)
- parameter passing
- module include / extend
- inheritance

9. Disadvantages
- constructor (initialize)+
parameter passing:
api changes -> parameter
changes

10. Disadvantages
- module include / extend
poison method call space,
sometimes you don't know
what is included??!!

11. Disadvantages
- inheritance
create once, stick
forever!! Parent API/
interface needed to be
carefully design

12. Another DI approach (not ruby
way):
- Use DI framework
- define dependencies in configuration
file
- found https://github.com/
dsawardekar/encase
Point: is it really needed??

13. Point is: why do you
need to care about DI?

14. Some points:
- Testability
- Loosely coupled
- Code extensibility