Dependency Injection in Ruby

Transcript

1. Joshua Tompkins | @jtompkinsx DEPENDENCY INJECTION (IN )
3. What makes good software?
5. What makes bad software?
6. Hard to change because change affects too many parts of the system. Bad software is…
7. Brittle because changes cause unexpected parts of the system to break. Bad software is…
8. Hard to reuse because components cannot be disentangled from their application. Bad software is…
9. Tightly coupled. Bad software is…
10. Single Responsibility Open/Closed Liskov Substitution Interface Segregation Dependency Inversion
11. is SOLID, Mr. Reynolds Good software
12. High level modules should not depend on low level modules. Both should depend on abstractions.
13. DUCK TYPES
14. class SuperCoolApp def do_a_cool_thing logger = Logger.new(STDOUT) logger.info(‘log a cool thing’) end end
15. class SuperCoolApp def do_a_cool_thing logger = Logger.new(STDOUT) logger.info(‘log a cool thing’) end end
16. Don’t initialize your dependencies - ask an outside source for them. Service Locator
17. class Locator def self.logger Logger.new end def self.user_repository UserRepository.new(logger) end end
18. class SuperCoolApp def do_a_cool_thing logger = Locator.logger logger.info(‘log a cool thing’) end end
19. Locator.register :logger { Logger.new } class SuperCoolApp def do_a_cool_thing logger = Locator.resolve(:logger) logger.info(‘log a cool thing’) end end
20. Don’t initialize your dependencies - receive them from an outside source. Dependency Injection
21. class SuperCoolApp def initialize(logger) @logger = logger end def do_a_cool_thing! @logger.info(‘log a cool thing’) end end app = SuperCoolApp.new(Logger.new(STDOUT)) app.do_a_cool_thing!
23. class Decoder def initialize @processor = Processor.new end def call(message) @processor.process(message) end end
24. class Processor def initialize @repository = Repository.new @factory = Factory.new end def process(message) model = @factory.parse(message) @repository.save(model) end end
25. class Processor def initialize(repository, factory) @repository = repository @factory = factory end def process(message) model = @factory.parse(message) @repository.save(model) end end Constructor Injection
26. repository = Repository.new factory = Factory.new processor = Processor.new(repository, factory)
27. class Processor attr_accessor :factory, :repository def process(message) model = factory.parse(message) repository.save(model) end end Setter Injection
28. processor = Processor.new processor.repository = Repository.new processor.factory = Factory.new
29. Smaller classes with single responsibilities
30. Composable components with limited public interfaces
31. Swappable dependencies that make tests easy to write
35. zero stars lol
36. “…dependency injection has spread and been advocated as a cross-language best practice on trumped up benefits of flexibility and malleability. If your code never knows exactly who it's talking to, it can talk to anyone! …Hogwash.”
37. class Processor def initialize @repository = Repository.new @factory = Factory.new end def process(message) model = @factory.parse(message) @repository.save(model) end end
38. allow_any_instance_of(Factory) .to_receive(:parse) .with(json_message) .and_return(a_model) allow_any_instance_of(Repository) .to_receive(:save) .with(a_model) json_message = ‘’ # some JSON! processor = Processor.new processor.process(json_message)
39. “…the ways [Ruby will] bend to extract the best of hard coding is truly impressive.” - A guy who’s wrong about stuff
40. class Processor def initialize @repository = Repository.new @factory = Factory.new @billing_repo = BillingRepository.new end def process(message) @billing_repo.email_receipts model = @factory.parse(message) @repository.save(model) end end
41. class Processor def initialize(repository, factory, billing_repo) @repository = repository @factory = factory @billing_repo = billing_repo end def process(message) @billing_repo.email_receipts model = @factory.parse(message) @repository.save(model) end end
42. json_message = ‘’ # some JSON! processor = Processor.new( mock_repository, mock_factory, mock_billing_repository ) processor.process(json_message) Constructor Injection
43. ArgumentError: wrong number of arguments (given 2, expected 3)
44. json_message = ‘’ # some JSON! processor = Processor.new processor.repository = mock_repository processor.factory = mock_factory processor.billing_repo = mock_billing_repo processor.process(json_message) Setter Injection
45. NoMethodError: undefined method ‘email_receipts’ for #<NilClass>
46. def publish! self.update published_at: Time.now end
47. def publish!(time_factory) self.update published_at: time_factory.now end class TimeFactory def now Date.now end end
48. class TimeFactoryProvider def resolve(type) if type == :now TimeFactory.new elsif # etc… end end end def publish!(provider) time = provider.resolve.now self.update published_at: time end
50. db_connection = Sequel::Connection.new(‘mysql:…’) accessor = DbAccessor.new(db_connection) agent_repository = AgentRepository.new(accessor) usage_repository = UsageRepository.new(accessor) host_repository = HostRepository.new(accessor) factory = Factory.new processor = Processor.new( agent_repository, usage_repository, host_repository, factory ) decoder = Decoder.new(processor) decoder.run
52. logger = Logger.new(STDOUT) db_connection = Sequel::Connection.new(‘mysql:…’) accessor = DbAccessor.new(db_connection) agent_repository = AgentRepository.new(accessor, logger) usage_repository = UsageRepository.new(accessor, logger) host_repository = HostRepository.new(accessor, logger) factory = Factory.new processor = Processor.new( agent_repository, usage_repository, host_repository, factory, logger ) decoder = Decoder.new(processor, logger) decoder.run
54. class ClientsController < ApplicationController def index logger = Logger.new(STDOUT) dbAccessor = DbAccessor.new(CONN_STR, logger) client_repo = ClientRepository.new(dbAccessor, logger) client_repo.all end end
55. client_repo.all end end class ClientsController < ApplicationController def index logger = Logger.new(STDOUT) dbAccessor = DbAccessor.new(CONN_STR, logger) client_repo = ClientRepository.new(dbAccessor, logger) client_repo.all end end class ClientsController < ApplicationController def index logger = Logger.new(STDOUT) dbAccessor = DbAccessor.new(CONN_STR, logger) client_repo = ClientRepository.new(dbAccessor, logger) client_repo.all end end class ClientsController < ApplicationController def index logger = Logger.new(STDOUT) dbAccessor = DbAccessor.new(CONN_STR, logger)
56. Codependent github.com/jtompkins/codependent
57. Repeatable, declarative dependency graph configuration Codependent Features
58. singleton :logger from_value Logger.new end
59. Constructor or setter injection Codependent Features
60. singleton :user_repository from_type UserRepository depends_on :logger end instance :account_repository from_type AccountRepository inject_setters depends_on :user_repository end
61. Dependency providers Codependent Features
62. singleton :user_repository from_provider do |deps| connection = DB.open(connection_string) UserRepository.new(logger, connection) end depends_on :logger, :connection_string end
63. Doesn’t infect domain objects Codependent Features
64. container = Codependent::Container.new do singleton :greeting from_value “Hello, World!” end end
65. Globally-available containers Codependent Features
66. Codependent::Manager.container :my_container do singleton :greeting from_value “Hello, World!” end end greeting = Codependent::Manager[:my_container] .resolve(:greeting) Codependent::Manager .reset_container!(:my_container)
67. Simple DSL Manual configuration, no magic Circular dependencies (via setter injection) Instance & singleton dependencies Codependent Features
68. Thanks for listening! github.com/jtompkins @jtompkinsx