Rails & SOLID by José Valim - RailsConf 2011

1. Design Principles behind
2. I am José Valim @josevalim
3. I work at blog.plataformatec.co
4. Core Team Member
5. Rails 3
6. SOLID Design
8. •Single Responsibility Principle •Open/closed Principle •Liskov Substitution
9. Single Responsibility Principle
10. “A class should have one, and only one, reason to change” - Uncle Bob
11. Example: Views Refactoring
12. 0.x ActionView::Base tracking details finding templates compiling templates rendering templates rendering context Controller Render Contents
13. 1.0 ActionView::Base tracking details finding templates rendering templates rendering context Controller Render Contents Template Template handler compiling templates
14. builder, rjs, haml...
15. 2.2 ActionView::Base tracking details rendering templates rendering context Controller Render Contents Template Template handler compiling templates View paths hold filesystem paths finding templates
16. Rails Engines!
17. 3.0 ActionView::Base tracking details rendering templates rendering context Controller Render Contents Template Template handler compiling templates View paths hold resolvers Resolvers finding templates
18. The resolver object no longer restricts templates to the filesystem
19. class BasicController < ActionController::Base self.view_paths = [ ActionView::FixtureResolver.new( "basic/hello_world.html.erb" => "Hello world!" ) ] def hello_world render :action => "hello_world" end end
20. You can create your own abstractions, allowing you to read templates from the database!
21. 3.0 ActionView::Base tracking details rendering templates rendering context Controller Render Contents Template Template handler compiling templates View paths hold resolvers Resolvers finding templates
22. 3.0 ActionView::Base rendering templates rendering context Controller Render Contents Template Template handler compiling templates View paths hold resolvers Resolvers finding templates Lookup context tracking details
23. 3.1 Controller Template Template handler compiling templates View paths hold resolvers Resolvers finding templates Lookup context tracking details AV::Renderer rendering templates ActionView::Base rendering context
24. def lookup_context ActionView::LookupContext.new(self.class._view_paths) end def view_renderer ActionView::Renderer.new(lookup_context) end def _render_template(options) view_renderer.render(view_context, options) end
25. def view_context ActionView::Base.new(view_renderer, view_assigns, self) end
26. Maybe templates could be rendered in the controller context?
27. class BasicController < ActionController::Base include ActionView::Context # STEP 1 before_filter :_prepare_context # STEP 2 def hello_world @value = "Hello" end protected def view_context # STEP 3 self end def __controller_method__ "controller context!" end end
28. # app/views/basic/hello_world.html.erb <%= @value %> from <%= __controller_method__ %> # would return... Hello from controller context!
29. 3.1 Controller Template Template handler compiling templates View paths hold resolvers Resolvers finding templates Lookup context tracking details AV::Renderer rendering templates ActionView::Base rendering context
30. Top-down comprehension Worse Maintainability Better Focused comprehension Much Better Extensibility POSSIBLE!
31. Open/closed Principle
32. “You should be able to extend a class behavior without modifying it” - Uncle Bob
33. Open for extension, closed for modification
34. class ApplicationController < ActionController::Base end
35. Easy to follow because Ruby classes are all open for extensions...
36. ... but easy to violate because they are not closed for modification.
37. # In your initializer ... config.active_record.table_name_prefix = “foo” # Then ... ActiveRecord::Base.table_name_prefix #=> “foo”
38. class ApplicationModel < ActiveRecord::Base end
39. class MyApp::ApplicationModel < ActiveRecord::Base end
40. Dependency Inversion
41. “Depend on abstractions, not on concretions” - Uncle Bob
42. def initialize(app:
43. def initialize(app)
44. @rack_app.call
45. 1) Define
46. match “/foo”, to:
47. match “/foo”, to: match “/foo”, to: PostsController.action
48. 3.1 Controller Template Template handler compiling templates View paths hold resolvers Resolvers finding templates Lookup context tracking details AV::Renderer rendering templates ActionView::Base rendering context
49. @resolver.find_all( name, prefix, partial, details, key, locals
50. @haml_handler.call
51. 2) Remove hardcoded dependencies
52. class PostsController < ApplicationController use ActiveRecord::IdentityMap::Middleware, :only => :index # ... end # And this builds the middleware stack ... PostsController.action(:index)
53. def self.action(name) middleware_stack.build(name.to_s) do |env| new.dispatch(name, ActionDispatch::Request.new(env)) end end
54. def self.action(name, klass = ActionDispatch::Request) middleware_stack.build(name.to_s) do |env| new.dispatch(name, klass.new(env)) end end
55. 3) Define hooks
56. 1) Load console on sandbox rails console --sandbox 2) Internally... require “rails/console/ sandbox”
57. ActiveRecord::Base.connection.increment_open_transactions ActiveRecord::Base.connection.begin_db_transaction at_exit do ActiveRecord::Base.connection.rollback_db_transaction ActiveRecord::Base.connection.decrement_open_transactions end
58. Instead provide a hook...
59. class ActiveRecord::Railtie < Rails::Railtie console do |sandbox| if sandbox require "active_record/railties/console_sandbox" end ActiveRecord::Base.logger = Logger.new(STDERR) end end
60. Liskov Substitution Principle
61. “Derived classes must be substitutable for their base classes” - Uncle Bob
62. “Derived classes must be substitutable for their base classes” - Uncle Bob
63. @rack_app.call •Receives a hash •Returns an array with status code, headers and an object that responds
64. Define substitutable but also don’t violate the principle
65. Datamapper x Active Record
66. Active Model User.model_name user.persisted? user.valid? user.errors user.to_key user.to_param
67. How do we ensure substitutability?
68. ActiveModel::Lint::Tests
69. class LintTest < ActiveSupport::TestCase include ActiveModel::Lint::Tests def setup @model = SomeDatamapperModel.new end end
70. Interface Segregation Principle
71. “Make fine grained interfaces that are client specific” - Uncle Bob
72. “Clients should depend on as narrow protocol as possible” - Jim Weirich
73. Active Model User.model_name user.persisted? user.valid? user.errors user.to_key user.to_param
74. How do we ensure a narrow protocol?
75. class MyPost < ActiveRecord::Base end my_post = MyPost.new assert_equal "my_posts/1", url_for(my_post)
76. my_post = Mock.new my_post.stubs(:model_name).returns("MyPost") my_post.stubs(:to_param).returns(2) assert_equal "my_posts/1", url_for(my_post)
77. Code to well- defined and narrow protocols
80. Questions? José Valim @josevalim blog.plataformatec.com
81. Questions? blog twitter ID José Valim @josevalim blog.plataformatec.com