Modularizing Rails Apps

So, you've been writing Rails apps and find yourself writing the same common logic across multiple applications. Rather than duplicating the same logic across the apps, you know there must be a better way to share this functionality.

Rails has a great modular architecture allowing you to take components and integrate them into your application. We'll walk through the various ways in which you can modularize and DRY up your shared functionality to best fit your needs.

Plugins? Engines? Full? Mountable? Railties?

This talk will explain each concept, what they are best suited for, and how you can take advantage of them. We will also cover how these concepts are changing in Rails 4 so you'll prepared when it is released.

Transcript

1. http://www.flickr.com/photos/xt0ph3r/3591242324 modularizing rails apps kevin shekleton @kpshek
2. @kpshek
3. Modularizing
 Rails Apps
4. Oregon
6. 2007 Rails 2.0
7. class Plugin • The junk drawer of Rails apps • Code copied into
 your_app/vendor/plugins • Often managed via rake tasks or git submodules • Encourages local editing http://www.flickr.com/photos/listener42/3488807301
8. 2007 Rails 2.0 2009 Rails 2.3 Full engines
9. 2005 2007 Rails 2.0 2009 Rails 2.3 Engine concept introduced Full engines
10. 2005: Rails Engines Plugin
11. 2005: Engines are not evil but distracting 2009: Engines are the future! (emphasis mine)
12. Russian Doll Pattern • Y. Katz, C. Lerche
 RailsConf 2009
 http://vimeo.com/4611379 • Build reusable slices not core to your app and embed it • Apps within apps • Implemented earlier as
 Merb slices http://www.flickr.com/photos/johnkay/3539939004
13. http://www.flickr.com/photos/icebone/2876059462 Full Engines
14. Full Engine $ rails plugin new \
 name --full A reusable app that fully integrates into your app MVC, routes, assets, etc defined in the engine are automatically available in your app http://www.flickr.com/photos/scania/2869106546
17. Beware of Collisions
19. Full engines 2005 2007 Rails 2.0 2009 Rails 2.3 2010 Rails 3.0 Engine concept introduced Railties Overhauled
20. Railties http://www.flickr.com/photos/perry-pics/7721695188
21. Railtie Power • Add rake tasks • Add generators • Hook into the Rails console load • Hook into the various Rails lifecycle events (before/after_initialize, to_prepare, etc) https://blog.engineyard.com/2010/extending-rails-3-with-railties
22. # See Railtie::Configuration config.to_prepare { ... } module Awesome end class Railtie < Rails::Railtie end rake_tasks do load ‘/awesome.tasks’ end initializer ‘awesome.configure’ do |app| # do awesome things like # subscribe to ActiveSupport::Notifications end Creating a Railtie
23. •# Called before the app’s config is loaded config.before_configuration = {...} •# Called before Rails has been initialized config.before_initialize = {...} •# Called before app classes are loaded config.before_eager_load = {...} Railtie Initializer Hooks
24. •# Called after app classes are loaded config.to_prepare = {...} •# Called after Rails has been initialized config.after_initialize = {...} Railtie Initializer Hooks (cont)
25. Using a Railtie # Gemfile of your app gem ‘awesome’, ’~> 1.0’ # awesome.gem # awesome/lib/awesome.rb require ‘awesome/railtie’ if defined?(Rails)
26. How are Railties Discovered? class Railtie autoload :Configuration, "rails/railtie/configuration" include Initializable ABSTRACT_RAILTIES = %w(Rails::Railtie Rails::Engine Rails::Application) class << self private :new delegate :config, to: :instance def subclasses @subclasses ||= [] end def inherited(base) unless base.abstract_railtie? subclasses << base end end
27. How are Railties Discovered? class Railtie autoload :Configuration, "rails/railtie/configuration" include Initializable ABSTRACT_RAILTIES = %w(Rails::Railtie Rails::Engine Rails::Application) class << self private :new delegate :config, to: :instance def subclasses @subclasses ||= [] end def inherited(base) unless base.abstract_railtie? subclasses << base end end def subclasses @subclasses ||= [] end def inherited(base) unless base.abstract_railtie? subclasses << base end end
28. class Railtie The core API that all of Rails is built upon class ActionMailer::Railtie
 class ActionController::Railtie
 class ActionDispatch::Railtie
 ...
 class ActiveModel::Railtie
 class ActiveRecord::Railtie
 class ActiveSupport::Railtie If Rails can dogfood their own APIs to create Rails,
 chances are you can build awesome things too.
29. Extending with Railties class Engine < Railtie class Application < Engine class Plugin < Engine
31. Full engines Overhauled Railties 2005 2011 Rails 3.1 2007 Rails 2.0 2009 Rails 2.3 2010 Rails 3.0 Engine concept introduced Mountable engines
32. Mountable Engines http://www.flickr.com/photos/granada_turnier/5818853700
33. Mountable Engine $ rails plugin new \
 name --mountable Like full engines, but... --Namespaced --Routes must be mounted in your app http://www.flickr.com/photos/tshearer/3935429228
34. Isolation via Namespacing
35. Full vs Mountable> Defining # defining full engines class Engine < ::Rails::Engine end
36. module Blog end # defining mountable engines isolate_namespace Blog class Engine < ::Rails::Engine end Full vs Mountable> Defining
37. Full vs Mountable> Application Controller # Mountable engines define their # own ApplicationController module Blog class ApplicationController < ActionController::Base end
38. Full vs Mountable> Routes # Full engine routes Rails.application.routes.draw do resources :posts end
39. Blog::Engine.routes.draw do resources :posts end Rails.application.routes.draw do mount Blog::Engine => ‘/blog’ end # Mountable engine routes Full vs Mountable> Routes
40. Full Mountable App ✔ ✔ Namespaced ✔ Routes Engines: Full vs Mountable Recap Inherited
 by your app Must be
 mounted
42. http://www.paleofuture.com/blog/2007/4/24/postcards-show-the-year-2000-circa-1900.html Full+Mountable Engine?
43. Full + Mountable Engine # Start with a mountable engine $ rails plugin new \ name --mountable
44. Full + Mountable Engine (cont) # Draw routes into the main app # like a full engine # Caution: Beware of collisions! Rails.application.routes.draw do resources :posts end
45. Mountable engines Full engines Overhauled Railties 2005 2012 Rails 3.2 2011 Rails 3.1 2007 Rails 2.0 2009 Rails 2.3 2010 Rails 3.0 Engine concept introduced vendor/plugins deprecated
47. Mountable engines Full engines Overhauled Railties vendor/plugins deprecated 2005 2012 Rails 3.2 2011 Rails 3.1 2013 Rails 4.0 2007 Rails 2.0 2009 Rails 2.3 2010 Rails 3.0 Engine concept introduced Plugin removed
48. git rm plugin.rb
49. git rm plugin.rb
52. Testing Engines http://www.flickr.com/photos/kwl/4809326028
53. Dummy App • Full and Mountable engines are tested the same • A full blown dummy app is generated in /test which consumes your engine • Write tests against the dummy app http://www.flickr.com/photos/20759665@N03/7400887540
54. $ gem install combustion http://www.flickr.com/photos/ekilby/4877912932
55. When do you create an Engine? http://www.flickr.com/photos/m0php/530526644
56. http://www.flickr.com/photos/limebye/3775235515 Start with a Monorail
57. http://www.flickr.com/photos/wwwuppertal/6891421635 Refactor out engines only when you find commonality and duplication
58. thank you. @kpshek